summaryrefslogtreecommitdiffstats
path: root/svl/source/numbers
diff options
context:
space:
mode:
Diffstat (limited to '')
-rw-r--r--svl/source/numbers/currencytable.cxx37
-rw-r--r--svl/source/numbers/numfmuno.cxx988
-rw-r--r--svl/source/numbers/numfmuno.hxx222
-rw-r--r--svl/source/numbers/numuno.cxx89
-rw-r--r--svl/source/numbers/supservs.cxx161
-rw-r--r--svl/source/numbers/supservs.hxx80
-rw-r--r--svl/source/numbers/zforfind.cxx4288
-rw-r--r--svl/source/numbers/zforfind.hxx441
-rw-r--r--svl/source/numbers/zforlist.cxx4972
-rw-r--r--svl/source/numbers/zformat.cxx6035
-rw-r--r--svl/source/numbers/zforscan.cxx3322
-rw-r--r--svl/source/numbers/zforscan.hxx304
12 files changed, 20939 insertions, 0 deletions
diff --git a/svl/source/numbers/currencytable.cxx b/svl/source/numbers/currencytable.cxx
new file mode 100644
index 000000000..84604ecc9
--- /dev/null
+++ b/svl/source/numbers/currencytable.cxx
@@ -0,0 +1,37 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+* This file is part of the LibreOffice project.
+*
+* This Source Code Form is subject to the terms of the Mozilla Public
+* License, v. 2.0. If a copy of the MPL was not distributed with this
+* file, You can obtain one at http://mozilla.org/MPL/2.0/.
+*/
+
+#include <svl/currencytable.hxx>
+
+NfCurrencyTable::iterator NfCurrencyTable::begin()
+{
+ return maData.begin();
+}
+
+NfCurrencyEntry& NfCurrencyTable::operator[] ( size_t i )
+{
+ return maData[i];
+}
+
+const NfCurrencyEntry& NfCurrencyTable::operator[] ( size_t i ) const
+{
+ return maData[i];
+}
+
+size_t NfCurrencyTable::size() const
+{
+ return maData.size();
+}
+
+void NfCurrencyTable::insert(const iterator& it, NfCurrencyEntry p)
+{
+ maData.insert(it, std::move(p));
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/svl/source/numbers/numfmuno.cxx b/svl/source/numbers/numfmuno.cxx
new file mode 100644
index 000000000..b1e9adef8
--- /dev/null
+++ b/svl/source/numbers/numfmuno.cxx
@@ -0,0 +1,988 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed
+ * with this work for additional information regarding copyright
+ * ownership. The ASF licenses this file to you under the Apache
+ * License, Version 2.0 (the "License"); you may not use this file
+ * except in compliance with the License. You may obtain a copy of
+ * the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#include <tools/color.hxx>
+#include <o3tl/any.hxx>
+#include <osl/mutex.hxx>
+#include <osl/diagnose.h>
+#include <rtl/ustring.hxx>
+
+#include <com/sun/star/util/Date.hpp>
+#include <com/sun/star/util/MalformedNumberFormatException.hpp>
+#include <com/sun/star/util/NotNumericException.hpp>
+#include <com/sun/star/beans/PropertyAttribute.hpp>
+#include <comphelper/propertysequence.hxx>
+#include <cppuhelper/supportsservice.hxx>
+
+#include "numfmuno.hxx"
+#include <svl/numformat.hxx>
+#include <svl/numuno.hxx>
+#include <svl/zforlist.hxx>
+#include <svl/zformat.hxx>
+#include <svl/itemprop.hxx>
+#include <utility>
+
+using namespace com::sun::star;
+
+constexpr OUStringLiteral PROPERTYNAME_FMTSTR = u"FormatString";
+constexpr OUStringLiteral PROPERTYNAME_LOCALE = u"Locale";
+constexpr OUStringLiteral PROPERTYNAME_TYPE = u"Type";
+constexpr OUStringLiteral PROPERTYNAME_COMMENT = u"Comment";
+constexpr OUStringLiteral PROPERTYNAME_CURREXT = u"CurrencyExtension";
+constexpr OUStringLiteral PROPERTYNAME_CURRSYM = u"CurrencySymbol";
+constexpr OUStringLiteral PROPERTYNAME_CURRABB = u"CurrencyAbbreviation";
+constexpr OUStringLiteral PROPERTYNAME_DECIMALS = u"Decimals";
+constexpr OUStringLiteral PROPERTYNAME_LEADING = u"LeadingZeros";
+constexpr OUStringLiteral PROPERTYNAME_NEGRED = u"NegativeRed";
+constexpr OUStringLiteral PROPERTYNAME_STDFORM = u"StandardFormat";
+constexpr OUStringLiteral PROPERTYNAME_THOUS = u"ThousandsSeparator";
+constexpr OUStringLiteral PROPERTYNAME_USERDEF = u"UserDefined";
+
+constexpr OUStringLiteral PROPERTYNAME_NOZERO = u"NoZero";
+constexpr OUStringLiteral PROPERTYNAME_NULLDATE = u"NullDate";
+constexpr OUStringLiteral PROPERTYNAME_STDDEC = u"StandardDecimals";
+constexpr OUStringLiteral PROPERTYNAME_TWODIGIT = u"TwoDigitDateStart";
+
+// All without a Which-ID, Map only for PropertySetInfo
+
+static const SfxItemPropertyMapEntry* lcl_GetNumberFormatPropertyMap()
+{
+ static const SfxItemPropertyMapEntry aNumberFormatPropertyMap_Impl[] =
+ {
+ {PROPERTYNAME_FMTSTR, 0, cppu::UnoType<OUString>::get(), beans::PropertyAttribute::BOUND | beans::PropertyAttribute::READONLY, 0},
+ {PROPERTYNAME_LOCALE, 0, cppu::UnoType<lang::Locale>::get(),beans::PropertyAttribute::BOUND | beans::PropertyAttribute::READONLY, 0},
+ {PROPERTYNAME_TYPE, 0, cppu::UnoType<sal_Int16>::get(), beans::PropertyAttribute::BOUND | beans::PropertyAttribute::READONLY, 0},
+ {PROPERTYNAME_COMMENT, 0, cppu::UnoType<OUString>::get(), beans::PropertyAttribute::BOUND | beans::PropertyAttribute::READONLY, 0},
+ {PROPERTYNAME_CURREXT, 0, cppu::UnoType<OUString>::get(), beans::PropertyAttribute::BOUND | beans::PropertyAttribute::READONLY, 0},
+ {PROPERTYNAME_CURRSYM, 0, cppu::UnoType<OUString>::get(), beans::PropertyAttribute::BOUND | beans::PropertyAttribute::READONLY, 0},
+ {PROPERTYNAME_DECIMALS, 0, cppu::UnoType<sal_Int16>::get(), beans::PropertyAttribute::BOUND | beans::PropertyAttribute::READONLY, 0},
+ {PROPERTYNAME_LEADING, 0, cppu::UnoType<sal_Int16>::get(), beans::PropertyAttribute::BOUND | beans::PropertyAttribute::READONLY, 0},
+ {PROPERTYNAME_NEGRED, 0, cppu::UnoType<bool>::get(), beans::PropertyAttribute::BOUND | beans::PropertyAttribute::READONLY, 0},
+ {PROPERTYNAME_STDFORM, 0, cppu::UnoType<bool>::get(), beans::PropertyAttribute::BOUND | beans::PropertyAttribute::READONLY, 0},
+ {PROPERTYNAME_THOUS, 0, cppu::UnoType<bool>::get(), beans::PropertyAttribute::BOUND | beans::PropertyAttribute::READONLY, 0},
+ {PROPERTYNAME_USERDEF, 0, cppu::UnoType<bool>::get(), beans::PropertyAttribute::BOUND | beans::PropertyAttribute::READONLY, 0},
+ {PROPERTYNAME_CURRABB, 0, cppu::UnoType<OUString>::get(), beans::PropertyAttribute::BOUND | beans::PropertyAttribute::READONLY, 0},
+ { u"", 0, css::uno::Type(), 0, 0 }
+ };
+ return aNumberFormatPropertyMap_Impl;
+}
+
+static const SfxItemPropertyMapEntry* lcl_GetNumberSettingsPropertyMap()
+{
+ static const SfxItemPropertyMapEntry aNumberSettingsPropertyMap_Impl[] =
+ {
+ {PROPERTYNAME_NOZERO, 0, cppu::UnoType<bool>::get(), beans::PropertyAttribute::BOUND, 0},
+ {PROPERTYNAME_NULLDATE, 0, cppu::UnoType<util::Date>::get(), beans::PropertyAttribute::BOUND, 0},
+ {PROPERTYNAME_STDDEC, 0, cppu::UnoType<sal_Int16>::get(), beans::PropertyAttribute::BOUND, 0},
+ {PROPERTYNAME_TWODIGIT, 0, cppu::UnoType<sal_Int16>::get(), beans::PropertyAttribute::BOUND, 0},
+ { u"", 0, css::uno::Type(), 0, 0 }
+ };
+ return aNumberSettingsPropertyMap_Impl;
+}
+
+static LanguageType lcl_GetLanguage( const lang::Locale& rLocale )
+{
+ LanguageType eRet = LanguageTag::convertToLanguageTypeWithFallback( rLocale );
+ if ( eRet == LANGUAGE_NONE )
+ eRet = LANGUAGE_SYSTEM; //! or throw an exception?
+
+ return eRet;
+}
+
+SvNumberFormatterServiceObj::SvNumberFormatterServiceObj()
+{
+}
+
+SvNumberFormatterServiceObj::~SvNumberFormatterServiceObj()
+{
+}
+
+// XNumberFormatter
+
+void SAL_CALL SvNumberFormatterServiceObj::attachNumberFormatsSupplier( const uno::Reference<util::XNumberFormatsSupplier>& _xSupplier )
+{
+ ::rtl::Reference< SvNumberFormatsSupplierObj > xAutoReleaseOld;
+
+ // SYNCHRONIZED ->
+ {
+ ::osl::MutexGuard aGuard( ::osl::Mutex::getGlobalMutex() );
+
+ SvNumberFormatsSupplierObj* pNew = comphelper::getFromUnoTunnel<SvNumberFormatsSupplierObj>( _xSupplier );
+ if (!pNew)
+ throw uno::RuntimeException(); // wrong object
+
+ xAutoReleaseOld = xSupplier;
+
+ xSupplier = pNew;
+ m_aMutex = xSupplier->getSharedMutex();
+ }
+ // <- SYNCHRONIZED
+}
+
+uno::Reference<util::XNumberFormatsSupplier> SAL_CALL SvNumberFormatterServiceObj::getNumberFormatsSupplier()
+{
+ ::osl::MutexGuard aGuard( m_aMutex );
+ return xSupplier;
+}
+
+sal_Int32 SAL_CALL SvNumberFormatterServiceObj::detectNumberFormat( sal_Int32 nKey, const OUString& aString )
+{
+ ::osl::MutexGuard aGuard( m_aMutex );
+
+ SvNumberFormatter* pFormatter = xSupplier.is() ? xSupplier->GetNumberFormatter() : nullptr;
+ if (!pFormatter)
+ throw uno::RuntimeException();
+
+ sal_uInt32 nUKey = nKey;
+ double fValue = 0.0;
+ if ( !pFormatter->IsNumberFormat(aString, nUKey, fValue) )
+ throw util::NotNumericException();
+
+ return nUKey;
+}
+
+double SAL_CALL SvNumberFormatterServiceObj::convertStringToNumber( sal_Int32 nKey, const OUString& aString )
+{
+ ::osl::MutexGuard aGuard( m_aMutex );
+
+ SvNumberFormatter* pFormatter = xSupplier.is() ? xSupplier->GetNumberFormatter() : nullptr;
+ if (!pFormatter)
+ throw uno::RuntimeException();
+
+ sal_uInt32 nUKey = nKey;
+ double fValue = 0.0;
+ if ( !pFormatter->IsNumberFormat(aString, nUKey, fValue) )
+ throw util::NotNumericException();
+
+ return fValue;
+}
+
+OUString SAL_CALL SvNumberFormatterServiceObj::convertNumberToString( sal_Int32 nKey, double fValue )
+{
+ ::osl::MutexGuard aGuard( m_aMutex );
+
+ OUString aRet;
+ SvNumberFormatter* pFormatter = xSupplier.is() ? xSupplier->GetNumberFormatter() : nullptr;
+ if (!pFormatter)
+ throw uno::RuntimeException();
+
+ const Color* pColor = nullptr;
+ pFormatter->GetOutputString(fValue, nKey, aRet, &pColor);
+
+ return aRet;
+}
+
+sal_Int32 SAL_CALL SvNumberFormatterServiceObj::queryColorForNumber( sal_Int32 nKey,
+ double fValue,
+ sal_Int32 aDefaultColor )
+{
+ ::osl::MutexGuard aGuard( m_aMutex );
+
+ util::Color nRet = aDefaultColor; // color = sal_Int32
+ SvNumberFormatter* pFormatter = xSupplier.is() ? xSupplier->GetNumberFormatter() : nullptr;
+ if (!pFormatter)
+ throw uno::RuntimeException();
+
+ OUString aStr;
+ const Color* pColor = nullptr;
+ pFormatter->GetOutputString(fValue, nKey, aStr, &pColor);
+ if (pColor)
+ nRet = sal_uInt32(*pColor);
+ // Else keep Default
+
+ return nRet;
+}
+
+OUString SAL_CALL SvNumberFormatterServiceObj::formatString( sal_Int32 nKey,
+ const OUString& aString )
+{
+ ::osl::MutexGuard aGuard( m_aMutex );
+
+ OUString aRet;
+ SvNumberFormatter* pFormatter = xSupplier.is() ? xSupplier->GetNumberFormatter() : nullptr;
+ if (!pFormatter)
+ {
+ throw uno::RuntimeException();
+ }
+
+ const Color* pColor = nullptr;
+ pFormatter->GetOutputString(aString, nKey, aRet, &pColor);
+
+ return aRet;
+}
+
+sal_Int32 SAL_CALL SvNumberFormatterServiceObj::queryColorForString( sal_Int32 nKey,
+ const OUString& aString,
+ sal_Int32 aDefaultColor )
+{
+ ::osl::MutexGuard aGuard( m_aMutex );
+
+ util::Color nRet = aDefaultColor; // color = sal_Int32
+ SvNumberFormatter* pFormatter = xSupplier.is() ? xSupplier->GetNumberFormatter() : nullptr;
+ if (!pFormatter)
+ {
+ throw uno::RuntimeException();
+ }
+
+ OUString aStr;
+ const Color* pColor = nullptr;
+ pFormatter->GetOutputString(aString, nKey, aStr, &pColor);
+ if (pColor)
+ {
+ nRet = sal_uInt32(*pColor);
+ }
+ // Else keep Default
+
+ return nRet;
+}
+
+OUString SAL_CALL SvNumberFormatterServiceObj::getInputString( sal_Int32 nKey, double fValue )
+{
+ ::osl::MutexGuard aGuard( m_aMutex );
+
+ OUString aRet;
+ SvNumberFormatter* pFormatter = xSupplier.is() ? xSupplier->GetNumberFormatter() : nullptr;
+ if (!pFormatter)
+ throw uno::RuntimeException();
+
+ pFormatter->GetInputLineString(fValue, nKey, aRet);
+
+ return aRet;
+}
+
+// XNumberFormatPreviewer
+
+OUString SAL_CALL SvNumberFormatterServiceObj::convertNumberToPreviewString( const OUString& aFormat,
+ double fValue,
+ const lang::Locale& nLocale,
+ sal_Bool bAllowEnglish )
+{
+ ::osl::MutexGuard aGuard( m_aMutex );
+
+ OUString aRet;
+ SvNumberFormatter* pFormatter = xSupplier.is() ? xSupplier->GetNumberFormatter() : nullptr;
+ if (!pFormatter)
+ throw uno::RuntimeException();
+
+ LanguageType eLang = lcl_GetLanguage( nLocale );
+ const Color* pColor = nullptr;
+
+ bool bOk;
+ if ( bAllowEnglish )
+ bOk = pFormatter->GetPreviewStringGuess( aFormat, fValue, aRet, &pColor, eLang );
+ else
+ bOk = pFormatter->GetPreviewString( aFormat, fValue, aRet, &pColor, eLang );
+
+ if (!bOk)
+ throw util::MalformedNumberFormatException();
+
+ return aRet;
+}
+
+sal_Int32 SAL_CALL SvNumberFormatterServiceObj::queryPreviewColorForNumber( const OUString& aFormat,
+ double fValue,
+ const lang::Locale& nLocale,
+ sal_Bool bAllowEnglish,
+ sal_Int32 aDefaultColor )
+{
+ ::osl::MutexGuard aGuard( m_aMutex );
+
+ util::Color nRet = aDefaultColor; // color = sal_Int32
+ SvNumberFormatter* pFormatter = xSupplier.is() ? xSupplier->GetNumberFormatter() : nullptr;
+ if (!pFormatter)
+ throw uno::RuntimeException();
+
+ OUString aOutString;
+ LanguageType eLang = lcl_GetLanguage( nLocale );
+ const Color* pColor = nullptr;
+
+ bool bOk;
+ if ( bAllowEnglish )
+ bOk = pFormatter->GetPreviewStringGuess( aFormat, fValue, aOutString, &pColor, eLang );
+ else
+ bOk = pFormatter->GetPreviewString( aFormat, fValue, aOutString, &pColor, eLang );
+
+ if (!bOk)
+ throw util::MalformedNumberFormatException();
+
+ if (pColor)
+ nRet = sal_uInt32(*pColor);
+ // Else keep Default
+
+ return nRet;
+}
+
+// XServiceInfo
+
+OUString SAL_CALL SvNumberFormatterServiceObj::getImplementationName()
+{
+ return "com.sun.star.uno.util.numbers.SvNumberFormatterServiceObject";
+}
+
+sal_Bool SAL_CALL SvNumberFormatterServiceObj::supportsService( const OUString& ServiceName )
+{
+ return cppu::supportsService( this, ServiceName );
+}
+
+uno::Sequence<OUString> SAL_CALL SvNumberFormatterServiceObj::getSupportedServiceNames()
+{
+ return { "com.sun.star.util.NumberFormatter" };
+}
+
+SvNumberFormatsObj::SvNumberFormatsObj( SvNumberFormatsSupplierObj& _rParent, ::comphelper::SharedMutex _aMutex )
+ :m_xSupplier( &_rParent )
+ ,m_aMutex(std::move( _aMutex ))
+{
+}
+
+SvNumberFormatsObj::~SvNumberFormatsObj()
+{
+}
+
+// XNumberFormats
+
+uno::Reference<beans::XPropertySet> SAL_CALL SvNumberFormatsObj::getByKey( sal_Int32 nKey )
+{
+ ::osl::MutexGuard aGuard( m_aMutex );
+
+ SvNumberFormatter* pFormatter = m_xSupplier->GetNumberFormatter();
+ const SvNumberformat* pFormat = pFormatter ? pFormatter->GetEntry(nKey) : nullptr;
+ if (!pFormat)
+ throw uno::RuntimeException();
+
+ return new SvNumberFormatObj( *m_xSupplier, nKey, m_aMutex );
+}
+
+uno::Sequence<sal_Int32> SAL_CALL SvNumberFormatsObj::queryKeys( sal_Int16 nType,
+ const lang::Locale& nLocale,
+ sal_Bool bCreate )
+{
+ ::osl::MutexGuard aGuard( m_aMutex );
+
+ SvNumberFormatter* pFormatter = m_xSupplier->GetNumberFormatter();
+ if ( !pFormatter )
+ throw uno::RuntimeException();
+
+ sal_uInt32 nIndex = 0;
+ LanguageType eLang = lcl_GetLanguage( nLocale );
+ SvNumberFormatTable& rTable = bCreate ?
+ pFormatter->ChangeCL( static_cast<SvNumFormatType>(nType), nIndex, eLang ) :
+ pFormatter->GetEntryTable( static_cast<SvNumFormatType>(nType), nIndex, eLang );
+ sal_uInt32 nCount = rTable.size();
+ uno::Sequence<sal_Int32> aSeq(nCount);
+ sal_Int32* pAry = aSeq.getArray();
+ sal_uInt32 i=0;
+ for (const auto& rEntry : rTable)
+ {
+ pAry[i] = rEntry.first;
+ ++i;
+ }
+ return aSeq;
+}
+
+sal_Int32 SAL_CALL SvNumberFormatsObj::queryKey( const OUString& aFormat,
+ const lang::Locale& nLocale,
+ sal_Bool bScan )
+{
+ ::osl::MutexGuard aGuard( m_aMutex );
+
+ SvNumberFormatter* pFormatter = m_xSupplier->GetNumberFormatter();
+ if (!pFormatter)
+ throw uno::RuntimeException();
+
+ LanguageType eLang = lcl_GetLanguage( nLocale );
+ if (bScan)
+ {
+ //! FIXME: Something still needs to happen here ...
+ }
+ sal_uInt32 nRet = pFormatter->GetEntryKey( aFormat, eLang );
+ if (nRet == NUMBERFORMAT_ENTRY_NOT_FOUND)
+ {
+ // This seems to be a workaround for what maybe the bScan option was
+ // intended for? Tokenize the format code?
+
+ // The format string based search is vague and fuzzy, as it is case
+ // sensitive, but the format string is only half way cased, the
+ // keywords (except the "General" keyword) are uppercased and literals
+ // of course are not. Clients using this queryKey() and if not
+ // successful addNew() may still fail if the result of PutEntry() is
+ // false because the format actually existed, just with a different
+ // casing. The only clean way is to just use PutEntry() and ignore the
+ // duplicate case, which clients can't because the API doesn't provide
+ // the information.
+ // Try just another possibilty here, without any guarantee.
+
+ // Use only ASCII upper, because keywords are only those.
+ // Do not transliterate any quoted literals.
+ const sal_Int32 nLen = aFormat.getLength();
+ OUStringBuffer aBuf(0);
+ sal_Unicode* p = aBuf.appendUninitialized( nLen + 1);
+ memcpy( p, aFormat.getStr(), (nLen + 1) * sizeof(sal_Unicode)); // including 0-char
+ aBuf.setLength( nLen);
+ assert(p == aBuf.getStr());
+ sal_Unicode const * const pStop = p + aBuf.getLength();
+ bool bQuoted = false;
+ for ( ; p < pStop; ++p)
+ {
+ if (bQuoted)
+ {
+ // Format codes don't have embedded doubled quotes, i.e. "a""b"
+ // is two literals displayed as `ab`.
+ if (*p == '"')
+ bQuoted = false;
+ }
+ else if (*p == '"')
+ bQuoted = true;
+ else if ('a' <= *p && *p <= 'z')
+ *p -= 0x20; // upper
+ else if (*p == '\\')
+ ++p; // skip escaped next char
+ // Theoretically that should cater for UTF-32 with
+ // iterateCodePoints(), but such character would not match any
+ // of [a-z\"] in its UTF-16 units.
+ }
+ nRet = pFormatter->GetEntryKey( aBuf, eLang );
+ }
+ return static_cast<sal_Int32>(nRet);
+}
+
+sal_Int32 SAL_CALL SvNumberFormatsObj::addNew( const OUString& aFormat,
+ const lang::Locale& nLocale )
+{
+ ::osl::MutexGuard aGuard( m_aMutex );
+
+ sal_Int32 nRet = 0;
+ SvNumberFormatter* pFormatter = m_xSupplier->GetNumberFormatter();
+ if (!pFormatter)
+ throw uno::RuntimeException();
+
+ OUString aFormStr = aFormat;
+ LanguageType eLang = lcl_GetLanguage( nLocale );
+ sal_uInt32 nKey = 0;
+ sal_Int32 nCheckPos = 0;
+ SvNumFormatType nType = SvNumFormatType::ALL;
+ bool bOk = pFormatter->PutEntry( aFormStr, nCheckPos, nType, nKey, eLang );
+ if (bOk)
+ nRet = nKey;
+ else if (nCheckPos)
+ {
+ throw util::MalformedNumberFormatException(); // Invalid Format
+ }
+ else if (aFormStr != aFormat)
+ {
+ // The format exists but with a different format code string, and if it
+ // was only uppercase vs lowercase keywords; but also syntax extensions
+ // are possible like resulting embedded LCIDs and what not the client
+ // doesn't know about. Silently accept instead of throwing an error.
+ nRet = nKey;
+ }
+ else
+ throw uno::RuntimeException(); // Other error (e.g. already added)
+
+ return nRet;
+}
+
+sal_Int32 SAL_CALL SvNumberFormatsObj::addNewConverted( const OUString& aFormat,
+ const lang::Locale& nLocale,
+ const lang::Locale& nNewLocale )
+{
+ ::osl::MutexGuard aGuard( m_aMutex );
+
+ sal_Int32 nRet = 0;
+ SvNumberFormatter* pFormatter = m_xSupplier->GetNumberFormatter();
+ if (!pFormatter)
+ throw uno::RuntimeException();
+
+ OUString aFormStr = aFormat;
+ LanguageType eLang = lcl_GetLanguage( nLocale );
+ LanguageType eNewLang = lcl_GetLanguage( nNewLocale );
+ sal_uInt32 nKey = 0;
+ sal_Int32 nCheckPos = 0;
+ SvNumFormatType nType = SvNumFormatType::ALL;
+ // This is used also when reading OOXML documents, there's no indicator
+ // whether to convert date particle order as well, so don't. See tdf#119013
+ bool bOk = pFormatter->PutandConvertEntry( aFormStr, nCheckPos, nType, nKey, eLang, eNewLang, false);
+ if (bOk || nKey > 0)
+ nRet = nKey;
+ else if (nCheckPos)
+ {
+ throw util::MalformedNumberFormatException(); // Invalid format
+ }
+ else
+ throw uno::RuntimeException(); // Other error (e.g. already added)
+
+ return nRet;
+}
+
+void SAL_CALL SvNumberFormatsObj::removeByKey( sal_Int32 nKey )
+{
+ ::osl::MutexGuard aGuard( m_aMutex );
+ SvNumberFormatter* pFormatter = m_xSupplier->GetNumberFormatter();
+
+ if (pFormatter)
+ {
+ pFormatter->DeleteEntry(nKey);
+ }
+}
+
+OUString SAL_CALL SvNumberFormatsObj::generateFormat( sal_Int32 nBaseKey,
+ const lang::Locale& nLocale,
+ sal_Bool bThousands,
+ sal_Bool bRed, sal_Int16 nDecimals,
+ sal_Int16 nLeading )
+{
+ ::osl::MutexGuard aGuard( m_aMutex );
+
+ SvNumberFormatter* pFormatter = m_xSupplier->GetNumberFormatter();
+ if (!pFormatter)
+ throw uno::RuntimeException();
+
+ LanguageType eLang = lcl_GetLanguage( nLocale );
+ OUString aRet = pFormatter->GenerateFormat(nBaseKey, eLang, bThousands, bRed, nDecimals, nLeading);
+ return aRet;
+}
+
+// XNumberFormatTypes
+
+sal_Int32 SAL_CALL SvNumberFormatsObj::getStandardIndex( const lang::Locale& nLocale )
+{
+ ::osl::MutexGuard aGuard( m_aMutex );
+
+ SvNumberFormatter* pFormatter = m_xSupplier->GetNumberFormatter();
+ if (!pFormatter)
+ throw uno::RuntimeException();
+
+ LanguageType eLang = lcl_GetLanguage( nLocale );
+ sal_Int32 nRet = pFormatter->GetStandardIndex(eLang);
+ return nRet;
+}
+
+sal_Int32 SAL_CALL SvNumberFormatsObj::getStandardFormat( sal_Int16 nType, const lang::Locale& nLocale )
+{
+ ::osl::MutexGuard aGuard( m_aMutex );
+
+ SvNumberFormatter* pFormatter = m_xSupplier->GetNumberFormatter();
+ if (!pFormatter)
+ throw uno::RuntimeException();
+
+ LanguageType eLang = lcl_GetLanguage( nLocale );
+ // Mask out "defined" bit, so type from an existing number format
+ // can directly be used for getStandardFormat
+ SvNumFormatType nType2 = static_cast<SvNumFormatType>(nType);
+ nType2 &= ~SvNumFormatType::DEFINED;
+ sal_Int32 nRet = pFormatter->GetStandardFormat(nType2, eLang);
+ return nRet;
+}
+
+sal_Int32 SAL_CALL SvNumberFormatsObj::getFormatIndex( sal_Int16 nIndex, const lang::Locale& nLocale )
+{
+ ::osl::MutexGuard aGuard( m_aMutex );
+
+ SvNumberFormatter* pFormatter = m_xSupplier->GetNumberFormatter();
+ if (!pFormatter)
+ throw uno::RuntimeException();
+
+ LanguageType eLang = lcl_GetLanguage( nLocale );
+ sal_Int32 nRet = pFormatter->GetFormatIndex( static_cast<NfIndexTableOffset>(nIndex), eLang );
+ return nRet;
+}
+
+sal_Bool SAL_CALL SvNumberFormatsObj::isTypeCompatible( sal_Int16 nOldType, sal_Int16 nNewType )
+{
+ ::osl::MutexGuard aGuard( m_aMutex );
+
+ return SvNumberFormatter::IsCompatible( static_cast<SvNumFormatType>(nOldType), static_cast<SvNumFormatType>(nNewType) );
+}
+
+sal_Int32 SAL_CALL SvNumberFormatsObj::getFormatForLocale( sal_Int32 nKey, const lang::Locale& nLocale )
+{
+ ::osl::MutexGuard aGuard( m_aMutex );
+
+ SvNumberFormatter* pFormatter = m_xSupplier->GetNumberFormatter();
+ if (!pFormatter)
+ throw uno::RuntimeException();
+
+ LanguageType eLang = lcl_GetLanguage( nLocale );
+ sal_Int32 nRet = pFormatter->GetFormatForLanguageIfBuiltIn(nKey, eLang);
+ return nRet;
+}
+
+// XServiceInfo
+
+OUString SAL_CALL SvNumberFormatsObj::getImplementationName()
+{
+ return "SvNumberFormatsObj";
+}
+
+sal_Bool SAL_CALL SvNumberFormatsObj::supportsService( const OUString& ServiceName )
+{
+ return cppu::supportsService( this, ServiceName );
+}
+
+uno::Sequence<OUString> SAL_CALL SvNumberFormatsObj::getSupportedServiceNames()
+{
+ return { "com.sun.star.util.NumberFormats" };
+}
+
+SvNumberFormatObj::SvNumberFormatObj( SvNumberFormatsSupplierObj& rParent, sal_uLong nK, ::comphelper::SharedMutex _aMutex )
+ :m_xSupplier( &rParent )
+ ,nKey( nK )
+ ,m_aMutex(std::move( _aMutex ))
+{
+}
+
+SvNumberFormatObj::~SvNumberFormatObj()
+{
+}
+
+// XPropertySet
+
+uno::Reference<beans::XPropertySetInfo> SAL_CALL SvNumberFormatObj::getPropertySetInfo()
+{
+ static uno::Reference<beans::XPropertySetInfo> aRef =
+ new SfxItemPropertySetInfo( lcl_GetNumberFormatPropertyMap() );
+ return aRef;
+}
+
+void SAL_CALL SvNumberFormatObj::setPropertyValue( const OUString&,
+ const uno::Any& )
+{
+ throw beans::UnknownPropertyException(); // Everything is read-only
+}
+
+uno::Any SAL_CALL SvNumberFormatObj::getPropertyValue( const OUString& aPropertyName )
+{
+ ::osl::MutexGuard aGuard( m_aMutex );
+
+ uno::Any aRet;
+ SvNumberFormatter* pFormatter = m_xSupplier->GetNumberFormatter();
+ const SvNumberformat* pFormat = pFormatter ? pFormatter->GetEntry(nKey) : nullptr;
+ if (!pFormat)
+ throw uno::RuntimeException();
+
+ bool bThousand, bRed;
+ sal_uInt16 nDecimals, nLeading;
+
+ if (aPropertyName == PROPERTYNAME_FMTSTR)
+ {
+ aRet <<= pFormat->GetFormatstring();
+ }
+ else if (aPropertyName == PROPERTYNAME_LOCALE)
+ {
+ lang::Locale aLocale( LanguageTag::convertToLocale( pFormat->GetLanguage(), false));
+ aRet <<= aLocale;
+ }
+ else if (aPropertyName == PROPERTYNAME_TYPE)
+ {
+ aRet <<= static_cast<sal_Int16>( pFormat->GetType() );
+ }
+ else if (aPropertyName == PROPERTYNAME_COMMENT)
+ {
+ aRet <<= pFormat->GetComment();
+ }
+ else if (aPropertyName == PROPERTYNAME_STDFORM)
+ {
+ //! Pass through SvNumberformat Member bStandard?
+ aRet <<= ( ( nKey % SV_COUNTRY_LANGUAGE_OFFSET ) == 0 );
+ }
+ else if (aPropertyName == PROPERTYNAME_USERDEF)
+ {
+ aRet <<= bool( pFormat->GetType() & SvNumFormatType::DEFINED );
+ }
+ else if (aPropertyName == PROPERTYNAME_DECIMALS)
+ {
+ pFormat->GetFormatSpecialInfo( bThousand, bRed, nDecimals, nLeading );
+ aRet <<= static_cast<sal_Int16>(nDecimals);
+ }
+ else if (aPropertyName == PROPERTYNAME_LEADING)
+ {
+ pFormat->GetFormatSpecialInfo( bThousand, bRed, nDecimals, nLeading );
+ aRet <<= static_cast<sal_Int16>(nLeading);
+ }
+ else if (aPropertyName == PROPERTYNAME_NEGRED)
+ {
+ pFormat->GetFormatSpecialInfo( bThousand, bRed, nDecimals, nLeading );
+ aRet <<= bRed;
+ }
+ else if (aPropertyName == PROPERTYNAME_THOUS)
+ {
+ pFormat->GetFormatSpecialInfo( bThousand, bRed, nDecimals, nLeading );
+ aRet <<= bThousand;
+ }
+ else if (aPropertyName == PROPERTYNAME_CURRSYM)
+ {
+ OUString aSymbol, aExt;
+ pFormat->GetNewCurrencySymbol( aSymbol, aExt );
+ aRet <<= aSymbol;
+ }
+ else if (aPropertyName == PROPERTYNAME_CURREXT)
+ {
+ OUString aSymbol, aExt;
+ pFormat->GetNewCurrencySymbol( aSymbol, aExt );
+ aRet <<= aExt;
+ }
+ else if (aPropertyName == PROPERTYNAME_CURRABB)
+ {
+ OUString aSymbol, aExt;
+ bool bBank = false;
+ pFormat->GetNewCurrencySymbol( aSymbol, aExt );
+ const NfCurrencyEntry* pCurr = SvNumberFormatter::GetCurrencyEntry( bBank,
+ aSymbol, aExt, pFormat->GetLanguage() );
+ if ( pCurr )
+ aRet <<= pCurr->GetBankSymbol();
+ else
+ aRet <<= OUString();
+ }
+ else
+ throw beans::UnknownPropertyException(aPropertyName);
+
+ return aRet;
+}
+
+void SAL_CALL SvNumberFormatObj::addPropertyChangeListener( const OUString&,
+ const uno::Reference<beans::XPropertyChangeListener>&)
+{
+ OSL_FAIL("not implemented");
+}
+
+void SAL_CALL SvNumberFormatObj::removePropertyChangeListener( const OUString&,
+ const uno::Reference<beans::XPropertyChangeListener>&)
+{
+ OSL_FAIL("not implemented");
+}
+
+void SAL_CALL SvNumberFormatObj::addVetoableChangeListener( const OUString&,
+ const uno::Reference<beans::XVetoableChangeListener>&)
+{
+ OSL_FAIL("not implemented");
+}
+
+void SAL_CALL SvNumberFormatObj::removeVetoableChangeListener( const OUString&,
+ const uno::Reference<beans::XVetoableChangeListener>&)
+{
+ OSL_FAIL("not implemented");
+}
+
+// XPropertyAccess
+
+uno::Sequence<beans::PropertyValue> SAL_CALL SvNumberFormatObj::getPropertyValues()
+{
+ ::osl::MutexGuard aGuard( m_aMutex );
+
+ SvNumberFormatter* pFormatter = m_xSupplier->GetNumberFormatter();
+ const SvNumberformat* pFormat = pFormatter ? pFormatter->GetEntry(nKey) : nullptr;
+ if (!pFormat)
+ throw uno::RuntimeException();
+
+ OUString aSymbol, aExt;
+ OUString aAbb;
+ bool bBank = false;
+ pFormat->GetNewCurrencySymbol( aSymbol, aExt );
+ const NfCurrencyEntry* pCurr = SvNumberFormatter::GetCurrencyEntry( bBank,
+ aSymbol, aExt, pFormat->GetLanguage() );
+ if ( pCurr )
+ aAbb = pCurr->GetBankSymbol();
+
+ OUString aFmtStr = pFormat->GetFormatstring();
+ OUString aComment = pFormat->GetComment();
+ bool bStandard = ( ( nKey % SV_COUNTRY_LANGUAGE_OFFSET ) == 0 );
+ //! Pass through SvNumberformat Member bStandard?
+ bool bUserDef( pFormat->GetType() & SvNumFormatType::DEFINED );
+ bool bThousand, bRed;
+ sal_uInt16 nDecimals, nLeading;
+ pFormat->GetFormatSpecialInfo( bThousand, bRed, nDecimals, nLeading );
+ lang::Locale aLocale( LanguageTag( pFormat->GetLanguage()).getLocale());
+
+ uno::Sequence<beans::PropertyValue> aSeq( comphelper::InitPropertySequence({
+ { PROPERTYNAME_FMTSTR, uno::Any(aFmtStr) },
+ { PROPERTYNAME_LOCALE, uno::Any(aLocale) },
+ { PROPERTYNAME_TYPE, uno::Any(sal_Int16( pFormat->GetType() )) },
+ { PROPERTYNAME_COMMENT, uno::Any(aComment) },
+ { PROPERTYNAME_STDFORM, uno::Any(bStandard) },
+ { PROPERTYNAME_USERDEF, uno::Any(bUserDef) },
+ { PROPERTYNAME_DECIMALS, uno::Any(sal_Int16( nDecimals )) },
+ { PROPERTYNAME_LEADING, uno::Any(sal_Int16( nLeading )) },
+ { PROPERTYNAME_NEGRED, uno::Any(bRed) },
+ { PROPERTYNAME_THOUS, uno::Any(bThousand) },
+ { PROPERTYNAME_CURRSYM, uno::Any(aSymbol) },
+ { PROPERTYNAME_CURREXT, uno::Any(aExt) },
+ { PROPERTYNAME_CURRABB, uno::Any(aAbb) }
+ }));
+
+ return aSeq;
+}
+
+void SAL_CALL SvNumberFormatObj::setPropertyValues( const uno::Sequence<beans::PropertyValue>& )
+{
+ throw beans::UnknownPropertyException(); // Everything is read-only
+}
+
+// XServiceInfo
+
+OUString SAL_CALL SvNumberFormatObj::getImplementationName()
+{
+ return "SvNumberFormatObj";
+}
+
+sal_Bool SAL_CALL SvNumberFormatObj::supportsService( const OUString& ServiceName )
+{
+ return cppu::supportsService( this, ServiceName );
+}
+
+uno::Sequence<OUString> SAL_CALL SvNumberFormatObj::getSupportedServiceNames()
+{
+ return { "com.sun.star.util.NumberFormatProperties" };
+}
+
+SvNumberFormatSettingsObj::SvNumberFormatSettingsObj( SvNumberFormatsSupplierObj& rParent, ::comphelper::SharedMutex _aMutex )
+ :m_xSupplier( &rParent )
+ ,m_aMutex(std::move( _aMutex ))
+{
+}
+
+SvNumberFormatSettingsObj::~SvNumberFormatSettingsObj()
+{
+}
+
+// XPropertySet
+
+uno::Reference<beans::XPropertySetInfo> SAL_CALL SvNumberFormatSettingsObj::getPropertySetInfo()
+{
+ static uno::Reference<beans::XPropertySetInfo> aRef =
+ new SfxItemPropertySetInfo( lcl_GetNumberSettingsPropertyMap() );
+ return aRef;
+}
+
+void SAL_CALL SvNumberFormatSettingsObj::setPropertyValue( const OUString& aPropertyName,
+ const uno::Any& aValue )
+{
+ ::osl::MutexGuard aGuard( m_aMutex );
+
+ SvNumberFormatter* pFormatter = m_xSupplier->GetNumberFormatter();
+ if (!pFormatter)
+ throw uno::RuntimeException();
+
+ if (aPropertyName == PROPERTYNAME_NOZERO)
+ {
+ // operator >>= shouldn't be used for bool (?)
+ if ( auto b = o3tl::tryAccess<bool>(aValue) )
+ pFormatter->SetNoZero( *b );
+ }
+ else if (aPropertyName == PROPERTYNAME_NULLDATE)
+ {
+ util::Date aDate;
+ if ( aValue >>= aDate )
+ pFormatter->ChangeNullDate( aDate.Day, aDate.Month, aDate.Year );
+ }
+ else if (aPropertyName == PROPERTYNAME_STDDEC)
+ {
+ sal_Int16 nInt16 = sal_Int16();
+ if ( aValue >>= nInt16 )
+ pFormatter->ChangeStandardPrec( nInt16 );
+ }
+ else if (aPropertyName == PROPERTYNAME_TWODIGIT)
+ {
+ sal_Int16 nInt16 = sal_Int16();
+ if ( aValue >>= nInt16 )
+ pFormatter->SetYear2000( nInt16 );
+ }
+ else
+ throw beans::UnknownPropertyException(aPropertyName);
+
+}
+
+uno::Any SAL_CALL SvNumberFormatSettingsObj::getPropertyValue( const OUString& aPropertyName )
+{
+ ::osl::MutexGuard aGuard( m_aMutex );
+
+ uno::Any aRet;
+ SvNumberFormatter* pFormatter = m_xSupplier->GetNumberFormatter();
+ if (!pFormatter)
+ throw uno::RuntimeException();
+
+ if (aPropertyName == PROPERTYNAME_NOZERO)
+ {
+ aRet <<= pFormatter->GetNoZero();
+ }
+ else if (aPropertyName == PROPERTYNAME_NULLDATE)
+ {
+ const Date& rDate = pFormatter->GetNullDate();
+ aRet <<= rDate.GetUNODate();
+ }
+ else if (aPropertyName == PROPERTYNAME_STDDEC)
+ aRet <<= static_cast<sal_Int16>( pFormatter->GetStandardPrec() );
+ else if (aPropertyName == PROPERTYNAME_TWODIGIT)
+ aRet <<= static_cast<sal_Int16>( pFormatter->GetYear2000() );
+ else
+ throw beans::UnknownPropertyException(aPropertyName);
+
+ return aRet;
+}
+
+void SAL_CALL SvNumberFormatSettingsObj::addPropertyChangeListener( const OUString&,
+ const uno::Reference<beans::XPropertyChangeListener>&)
+{
+ OSL_FAIL("not implemented");
+}
+
+void SAL_CALL SvNumberFormatSettingsObj::removePropertyChangeListener( const OUString&,
+ const uno::Reference<beans::XPropertyChangeListener>&)
+{
+ OSL_FAIL("not implemented");
+}
+
+void SAL_CALL SvNumberFormatSettingsObj::addVetoableChangeListener( const OUString&,
+ const uno::Reference<beans::XVetoableChangeListener>&)
+{
+ OSL_FAIL("not implemented");
+}
+
+void SAL_CALL SvNumberFormatSettingsObj::removeVetoableChangeListener( const OUString&,
+ const uno::Reference<beans::XVetoableChangeListener>&)
+{
+ OSL_FAIL("not implemented");
+}
+
+// XServiceInfo
+
+OUString SAL_CALL SvNumberFormatSettingsObj::getImplementationName()
+{
+ return "SvNumberFormatSettingsObj";
+}
+
+sal_Bool SAL_CALL SvNumberFormatSettingsObj::supportsService( const OUString& ServiceName )
+{
+ return cppu::supportsService( this, ServiceName );
+}
+
+uno::Sequence<OUString> SAL_CALL SvNumberFormatSettingsObj::getSupportedServiceNames()
+{
+ return { "com.sun.star.util.NumberFormatSettings" };
+}
+
+
+extern "C" SAL_DLLPUBLIC_EXPORT css::uno::XInterface*
+com_sun_star_uno_util_numbers_SvNumberFormatterServiceObject_get_implementation(css::uno::XComponentContext*,
+ css::uno::Sequence<css::uno::Any> const &)
+{
+ return cppu::acquire(new SvNumberFormatterServiceObj());
+}
+
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/svl/source/numbers/numfmuno.hxx b/svl/source/numbers/numfmuno.hxx
new file mode 100644
index 000000000..f88c2e642
--- /dev/null
+++ b/svl/source/numbers/numfmuno.hxx
@@ -0,0 +1,222 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed
+ * with this work for additional information regarding copyright
+ * ownership. The ASF licenses this file to you under the Apache
+ * License, Version 2.0 (the "License"); you may not use this file
+ * except in compliance with the License. You may obtain a copy of
+ * the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#ifndef INCLUDED_SVL_SOURCE_NUMBERS_NUMFMUNO_HXX
+#define INCLUDED_SVL_SOURCE_NUMBERS_NUMFMUNO_HXX
+
+#include <com/sun/star/util/XNumberFormatter2.hpp>
+#include <com/sun/star/util/XNumberFormats.hpp>
+#include <com/sun/star/util/XNumberFormatTypes.hpp>
+#include <com/sun/star/lang/XServiceInfo.hpp>
+#include <com/sun/star/beans/XPropertyAccess.hpp>
+#include <cppuhelper/implbase.hxx>
+#include <comphelper/sharedmutex.hxx>
+#include <rtl/ref.hxx>
+#include <tools/solar.h>
+
+class SvNumberFormatsSupplierObj;
+
+
+/**
+ * SvNumberFormatterServiceObj is registered globally as a Service
+ */
+class SvNumberFormatterServiceObj : public cppu::WeakImplHelper<
+ css::util::XNumberFormatter2,
+ css::lang::XServiceInfo>
+{
+private:
+ ::rtl::Reference< SvNumberFormatsSupplierObj > xSupplier;
+ mutable ::comphelper::SharedMutex m_aMutex;
+
+public:
+ SvNumberFormatterServiceObj();
+ virtual ~SvNumberFormatterServiceObj() override;
+
+ // XNumberFormatter
+ virtual void SAL_CALL attachNumberFormatsSupplier(
+ const css::uno::Reference< css::util::XNumberFormatsSupplier >& xSupplier ) override;
+ virtual css::uno::Reference< css::util::XNumberFormatsSupplier >
+ SAL_CALL getNumberFormatsSupplier() override;
+ virtual sal_Int32 SAL_CALL detectNumberFormat( sal_Int32 nKey, const OUString& aString ) override;
+ virtual double SAL_CALL convertStringToNumber( sal_Int32 nKey, const OUString& aString ) override;
+ virtual OUString SAL_CALL convertNumberToString( sal_Int32 nKey, double fValue ) override;
+ virtual sal_Int32 SAL_CALL queryColorForNumber( sal_Int32 nKey,
+ double fValue, sal_Int32 aDefaultColor ) override;
+ virtual OUString SAL_CALL formatString( sal_Int32 nKey, const OUString& aString ) override;
+ virtual sal_Int32 SAL_CALL queryColorForString( sal_Int32 nKey,
+ const OUString& aString,
+ sal_Int32 aDefaultColor ) override;
+ virtual OUString SAL_CALL getInputString( sal_Int32 nKey, double fValue ) override;
+
+ // XNumberFormatPreviewer
+ virtual OUString SAL_CALL convertNumberToPreviewString(
+ const OUString& aFormat, double fValue,
+ const css::lang::Locale& nLocale, sal_Bool bAllowEnglish ) override;
+ virtual sal_Int32 SAL_CALL queryPreviewColorForNumber(
+ const OUString& aFormat, double fValue,
+ const css::lang::Locale& nLocale, sal_Bool bAllowEnglish,
+ sal_Int32 aDefaultColor ) override;
+
+ // XServiceInfo
+ virtual OUString SAL_CALL getImplementationName( ) override;
+ virtual sal_Bool SAL_CALL supportsService( const OUString& ServiceName ) override;
+ virtual css::uno::Sequence< OUString > SAL_CALL getSupportedServiceNames() override;
+};
+
+
+class SvNumberFormatsObj : public cppu::WeakImplHelper<
+ css::util::XNumberFormats,
+ css::util::XNumberFormatTypes,
+ css::lang::XServiceInfo>
+{
+private:
+ rtl::Reference<SvNumberFormatsSupplierObj> m_xSupplier;
+ mutable ::comphelper::SharedMutex m_aMutex;
+
+public:
+ SvNumberFormatsObj(SvNumberFormatsSupplierObj& pParent, ::comphelper::SharedMutex _aMutex);
+ virtual ~SvNumberFormatsObj() override;
+
+
+ // XNumberFormats
+ virtual css::uno::Reference< css::beans::XPropertySet > SAL_CALL
+ getByKey( sal_Int32 nKey ) override;
+ virtual css::uno::Sequence< sal_Int32 > SAL_CALL queryKeys( sal_Int16 nType,
+ const css::lang::Locale& nLocale, sal_Bool bCreate ) override;
+ virtual sal_Int32 SAL_CALL queryKey( const OUString& aFormat,
+ const css::lang::Locale& nLocale, sal_Bool bScan ) override;
+ virtual sal_Int32 SAL_CALL addNew( const OUString& aFormat,
+ const css::lang::Locale& nLocale ) override;
+ virtual sal_Int32 SAL_CALL addNewConverted( const OUString& aFormat,
+ const css::lang::Locale& nLocale,
+ const css::lang::Locale& nNewLocale ) override;
+ virtual void SAL_CALL removeByKey( sal_Int32 nKey ) override;
+ virtual OUString SAL_CALL generateFormat( sal_Int32 nBaseKey,
+ const css::lang::Locale& nLocale, sal_Bool bThousands,
+ sal_Bool bRed, sal_Int16 nDecimals, sal_Int16 nLeading ) override;
+
+ // XNumberFormatTypes
+ virtual sal_Int32 SAL_CALL getStandardIndex( const css::lang::Locale& nLocale ) override;
+ virtual sal_Int32 SAL_CALL getStandardFormat( sal_Int16 nType,
+ const css::lang::Locale& nLocale ) override;
+ virtual sal_Int32 SAL_CALL getFormatIndex( sal_Int16 nIndex,
+ const css::lang::Locale& nLocale ) override;
+ virtual sal_Bool SAL_CALL isTypeCompatible( sal_Int16 nOldType, sal_Int16 nNewType ) override;
+ virtual sal_Int32 SAL_CALL getFormatForLocale( sal_Int32 nKey,
+ const css::lang::Locale& nLocale ) override;
+
+ // XServiceInfo
+ virtual OUString SAL_CALL getImplementationName( ) override;
+ virtual sal_Bool SAL_CALL supportsService( const OUString& ServiceName ) override;
+ virtual css::uno::Sequence< OUString > SAL_CALL getSupportedServiceNames() override;
+};
+
+
+class SvNumberFormatObj : public cppu::WeakImplHelper<
+ css::beans::XPropertySet,
+ css::beans::XPropertyAccess,
+ css::lang::XServiceInfo>
+{
+private:
+ rtl::Reference<SvNumberFormatsSupplierObj>
+ m_xSupplier;
+ sal_uLong nKey;
+ mutable ::comphelper::SharedMutex m_aMutex;
+
+public:
+ SvNumberFormatObj( SvNumberFormatsSupplierObj& rParent, sal_uLong nK, ::comphelper::SharedMutex _aMutex );
+ virtual ~SvNumberFormatObj() override;
+
+ // XPropertySet
+ virtual css::uno::Reference< css::beans::XPropertySetInfo >
+ SAL_CALL getPropertySetInfo( ) override;
+ virtual void SAL_CALL setPropertyValue( const OUString& aPropertyName,
+ const css::uno::Any& aValue ) override;
+ virtual css::uno::Any SAL_CALL getPropertyValue(
+ const OUString& PropertyName ) override;
+ virtual void SAL_CALL addPropertyChangeListener( const OUString& aPropertyName,
+ const css::uno::Reference<
+ css::beans::XPropertyChangeListener >& xListener ) override;
+ virtual void SAL_CALL removePropertyChangeListener( const OUString& aPropertyName,
+ const css::uno::Reference<
+ css::beans::XPropertyChangeListener >& aListener ) override;
+ virtual void SAL_CALL addVetoableChangeListener( const OUString& PropertyName,
+ const css::uno::Reference<
+ css::beans::XVetoableChangeListener >& aListener ) override;
+ virtual void SAL_CALL removeVetoableChangeListener( const OUString& PropertyName,
+ const css::uno::Reference<
+ css::beans::XVetoableChangeListener >& aListener ) override;
+
+ // XPropertyAccess
+ virtual css::uno::Sequence< css::beans::PropertyValue > SAL_CALL
+ getPropertyValues() override;
+ virtual void SAL_CALL setPropertyValues( const css::uno::Sequence<
+ css::beans::PropertyValue >& aProps ) override;
+
+ // XServiceInfo
+ virtual OUString SAL_CALL getImplementationName( ) override;
+ virtual sal_Bool SAL_CALL supportsService( const OUString& ServiceName ) override;
+ virtual css::uno::Sequence< OUString > SAL_CALL getSupportedServiceNames() override;
+};
+
+
+class SvNumberFormatSettingsObj : public cppu::WeakImplHelper<
+ css::beans::XPropertySet,
+ css::lang::XServiceInfo>
+{
+private:
+ rtl::Reference<SvNumberFormatsSupplierObj>
+ m_xSupplier;
+ mutable ::comphelper::SharedMutex m_aMutex;
+
+public:
+ SvNumberFormatSettingsObj( SvNumberFormatsSupplierObj& rParent, ::comphelper::SharedMutex _aMutex);
+ virtual ~SvNumberFormatSettingsObj() override;
+
+
+ // XPropertySet
+ virtual css::uno::Reference< css::beans::XPropertySetInfo >
+ SAL_CALL getPropertySetInfo( ) override;
+ virtual void SAL_CALL setPropertyValue( const OUString& aPropertyName,
+ const css::uno::Any& aValue ) override;
+ virtual css::uno::Any SAL_CALL getPropertyValue(
+ const OUString& PropertyName ) override;
+ virtual void SAL_CALL addPropertyChangeListener( const OUString& aPropertyName,
+ const css::uno::Reference<
+ css::beans::XPropertyChangeListener >& xListener ) override;
+ virtual void SAL_CALL removePropertyChangeListener( const OUString& aPropertyName,
+ const css::uno::Reference<
+ css::beans::XPropertyChangeListener >& aListener ) override;
+ virtual void SAL_CALL addVetoableChangeListener( const OUString& PropertyName,
+ const css::uno::Reference<
+ css::beans::XVetoableChangeListener >& aListener ) override;
+ virtual void SAL_CALL removeVetoableChangeListener( const OUString& PropertyName,
+ const css::uno::Reference<
+ css::beans::XVetoableChangeListener >& aListener ) override;
+
+ // XServiceInfo
+ virtual OUString SAL_CALL getImplementationName( ) override;
+ virtual sal_Bool SAL_CALL supportsService( const OUString& ServiceName ) override;
+ virtual css::uno::Sequence< OUString > SAL_CALL getSupportedServiceNames() override;
+};
+
+
+#endif
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/svl/source/numbers/numuno.cxx b/svl/source/numbers/numuno.cxx
new file mode 100644
index 000000000..db633f405
--- /dev/null
+++ b/svl/source/numbers/numuno.cxx
@@ -0,0 +1,89 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed
+ * with this work for additional information regarding copyright
+ * ownership. The ASF licenses this file to you under the Apache
+ * License, Version 2.0 (the "License"); you may not use this file
+ * except in compliance with the License. You may obtain a copy of
+ * the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+
+#include <svl/numuno.hxx>
+#include "numfmuno.hxx"
+
+using namespace com::sun::star;
+
+
+class SvNumFmtSuppl_Impl
+{
+public:
+ SvNumberFormatter* pFormatter;
+ mutable ::comphelper::SharedMutex aMutex;
+
+ explicit SvNumFmtSuppl_Impl(SvNumberFormatter* p) :
+ pFormatter(p) {}
+};
+
+
+// Default ctor for getReflection
+SvNumberFormatsSupplierObj::SvNumberFormatsSupplierObj()
+ : pImpl( new SvNumFmtSuppl_Impl(nullptr) )
+{
+}
+
+SvNumberFormatsSupplierObj::SvNumberFormatsSupplierObj(SvNumberFormatter* pForm)
+ : pImpl( new SvNumFmtSuppl_Impl(pForm) )
+{
+}
+
+SvNumberFormatsSupplierObj::~SvNumberFormatsSupplierObj()
+{
+}
+
+::comphelper::SharedMutex& SvNumberFormatsSupplierObj::getSharedMutex() const
+{
+ return pImpl->aMutex;
+}
+
+SvNumberFormatter* SvNumberFormatsSupplierObj::GetNumberFormatter() const
+{
+ return pImpl->pFormatter;
+}
+
+void SvNumberFormatsSupplierObj::SetNumberFormatter(SvNumberFormatter* pNew)
+{
+ // The old Numberformatter has been retired, do not access it anymore!
+ pImpl->pFormatter = pNew;
+}
+
+// XNumberFormatsSupplier
+
+uno::Reference<beans::XPropertySet> SAL_CALL SvNumberFormatsSupplierObj::getNumberFormatSettings()
+{
+ ::osl::MutexGuard aGuard( pImpl->aMutex );
+
+ return new SvNumberFormatSettingsObj( *this, pImpl->aMutex );
+}
+
+uno::Reference<util::XNumberFormats> SAL_CALL SvNumberFormatsSupplierObj::getNumberFormats()
+{
+ ::osl::MutexGuard aGuard( pImpl->aMutex );
+
+ return new SvNumberFormatsObj( *this, pImpl->aMutex );
+}
+
+// XUnoTunnel
+
+UNO3_GETIMPLEMENTATION_IMPL(SvNumberFormatsSupplierObj);
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/svl/source/numbers/supservs.cxx b/svl/source/numbers/supservs.cxx
new file mode 100644
index 000000000..5a51158a2
--- /dev/null
+++ b/svl/source/numbers/supservs.cxx
@@ -0,0 +1,161 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed
+ * with this work for additional information regarding copyright
+ * ownership. The ASF licenses this file to you under the Apache
+ * License, Version 2.0 (the "License"); you may not use this file
+ * except in compliance with the License. You may obtain a copy of
+ * the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#include "supservs.hxx"
+#include <com/sun/star/lang/Locale.hpp>
+#include <comphelper/sharedmutex.hxx>
+#include <cppuhelper/supportsservice.hxx>
+#include <cppuhelper/queryinterface.hxx>
+#include <cppuhelper/weak.hxx>
+#include <i18nlangtag/languagetag.hxx>
+#include <svl/numformat.hxx>
+#include <tools/debug.hxx>
+#include <osl/mutex.hxx>
+#include <utility>
+#include <osl/diagnose.h>
+
+using namespace ::com::sun::star::uno;
+using namespace ::com::sun::star::lang;
+using namespace ::com::sun::star::beans;
+using namespace ::com::sun::star::util;
+using namespace ::utl;
+
+
+SvNumberFormatsSupplierServiceObject::SvNumberFormatsSupplierServiceObject(css::uno::Reference< css::uno::XComponentContext > _xORB)
+ :m_xORB(std::move(_xORB))
+{
+}
+
+SvNumberFormatsSupplierServiceObject::~SvNumberFormatsSupplierServiceObject()
+{
+}
+
+Any SAL_CALL SvNumberFormatsSupplierServiceObject::queryAggregation( const Type& _rType )
+{
+ Any aReturn = ::cppu::queryInterface(_rType,
+ static_cast< XInitialization* >(this),
+ static_cast< XServiceInfo* >(this)
+ );
+
+ if (!aReturn.hasValue())
+ aReturn = SvNumberFormatsSupplierObj::queryAggregation(_rType);
+
+ return aReturn;
+}
+
+void SAL_CALL SvNumberFormatsSupplierServiceObject::initialize( const Sequence< Any >& _rArguments )
+{
+ ::osl::MutexGuard aGuard( getSharedMutex() );
+
+ DBG_ASSERT(m_pOwnFormatter == nullptr,
+ "SvNumberFormatsSupplierServiceObject::initialize : already initialized !");
+ // maybe you already called a method which needed the formatter
+ // you should use XMultiServiceFactory::createInstanceWithArguments to avoid that
+ if (m_pOwnFormatter)
+ { // !!! this is only an emergency handling, normally this should not occur !!!
+ m_pOwnFormatter.reset();
+ SetNumberFormatter(m_pOwnFormatter.get());
+ }
+
+ Type aExpectedArgType = ::cppu::UnoType<css::lang::Locale>::get();
+ LanguageType eNewFormatterLanguage = LANGUAGE_SYSTEM;
+ // the default
+
+ for (const Any& rArg : _rArguments)
+ {
+ if (rArg.getValueType().equals(aExpectedArgType))
+ {
+ css::lang::Locale aLocale;
+ rArg >>= aLocale;
+ eNewFormatterLanguage = LanguageTag::convertToLanguageType( aLocale, false);
+ }
+#ifdef DBG_UTIL
+ else
+ {
+ OSL_FAIL("SvNumberFormatsSupplierServiceObject::initialize : unknown argument !");
+ }
+#endif
+ }
+
+ m_pOwnFormatter.reset( new SvNumberFormatter( m_xORB, eNewFormatterLanguage) );
+ m_pOwnFormatter->SetEvalDateFormat( NF_EVALDATEFORMAT_FORMAT_INTL );
+ SetNumberFormatter(m_pOwnFormatter.get());
+}
+
+OUString SAL_CALL SvNumberFormatsSupplierServiceObject::getImplementationName( )
+{
+ return "com.sun.star.uno.util.numbers.SvNumberFormatsSupplierServiceObject";
+}
+
+sal_Bool SAL_CALL SvNumberFormatsSupplierServiceObject::supportsService( const OUString& _rServiceName )
+{
+ return cppu::supportsService(this, _rServiceName);
+}
+
+Sequence< OUString > SAL_CALL SvNumberFormatsSupplierServiceObject::getSupportedServiceNames( )
+{
+ return { "com.sun.star.util.NumberFormatsSupplier" };
+}
+
+Reference< XPropertySet > SAL_CALL SvNumberFormatsSupplierServiceObject::getNumberFormatSettings()
+{
+ ::osl::MutexGuard aGuard( getSharedMutex() );
+ implEnsureFormatter();
+ return SvNumberFormatsSupplierObj::getNumberFormatSettings();
+}
+
+Reference< XNumberFormats > SAL_CALL SvNumberFormatsSupplierServiceObject::getNumberFormats()
+{
+ ::osl::MutexGuard aGuard( getSharedMutex() );
+ implEnsureFormatter();
+ return SvNumberFormatsSupplierObj::getNumberFormats();
+}
+
+sal_Int64 SAL_CALL SvNumberFormatsSupplierServiceObject::getSomething( const Sequence< sal_Int8 >& aIdentifier )
+{
+ sal_Int64 nReturn = SvNumberFormatsSupplierObj::getSomething( aIdentifier );
+ if ( nReturn )
+ // if somebody accesses internals then we should have the formatter
+ implEnsureFormatter();
+ return nReturn;
+}
+
+void SvNumberFormatsSupplierServiceObject::implEnsureFormatter()
+{
+ if (!m_pOwnFormatter)
+ {
+ // get the office's UI locale
+ SvtSysLocale aSysLocale;
+ css::lang::Locale aOfficeLocale = aSysLocale.GetLocaleData().getLanguageTag().getLocale();
+
+ // initialize with this locale
+ initialize({ Any(aOfficeLocale) });
+ }
+}
+
+
+extern "C" SAL_DLLPUBLIC_EXPORT css::uno::XInterface*
+com_sun_star_uno_util_numbers_SvNumberFormatsSupplierServiceObject_get_implementation(css::uno::XComponentContext* context,
+ css::uno::Sequence<css::uno::Any> const &)
+{
+ return cppu::acquire(new SvNumberFormatsSupplierServiceObject(context));
+}
+
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/svl/source/numbers/supservs.hxx b/svl/source/numbers/supservs.hxx
new file mode 100644
index 000000000..4ddf5751e
--- /dev/null
+++ b/svl/source/numbers/supservs.hxx
@@ -0,0 +1,80 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed
+ * with this work for additional information regarding copyright
+ * ownership. The ASF licenses this file to you under the Apache
+ * License, Version 2.0 (the "License"); you may not use this file
+ * except in compliance with the License. You may obtain a copy of
+ * the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#ifndef INCLUDED_SVL_SOURCE_NUMBERS_SUPSERVS_HXX
+#define INCLUDED_SVL_SOURCE_NUMBERS_SUPSERVS_HXX
+
+#include <svl/numuno.hxx>
+#include <com/sun/star/lang/XInitialization.hpp>
+#include <com/sun/star/lang/XServiceInfo.hpp>
+#include <com/sun/star/uno/XComponentContext.hpp>
+#include <memory>
+
+/**
+ * SvNumberFormatsSupplierServiceObject - a number formats supplier which
+ * - can be instantiated as a service
+ * - works with its own SvNumberFormatter instance
+ * - can be initialized (css::lang::XInitialization)
+ * with a specific language (i.e. css::lang::Locale)
+ */
+class SvNumberFormatsSupplierServiceObject final
+ :public SvNumberFormatsSupplierObj
+ ,public css::lang::XInitialization
+ ,public css::lang::XServiceInfo
+{
+ std::unique_ptr<SvNumberFormatter> m_pOwnFormatter;
+ css::uno::Reference< css::uno::XComponentContext > m_xORB;
+
+ void implEnsureFormatter();
+
+public:
+ explicit SvNumberFormatsSupplierServiceObject(css::uno::Reference< css::uno::XComponentContext > _xORB);
+ virtual ~SvNumberFormatsSupplierServiceObject() override;
+
+ // XInterface
+ virtual void SAL_CALL acquire() noexcept override { SvNumberFormatsSupplierObj::acquire(); }
+ virtual void SAL_CALL release() noexcept override { SvNumberFormatsSupplierObj::release(); }
+ virtual css::uno::Any SAL_CALL queryInterface( const css::uno::Type& _rType ) override
+ { return SvNumberFormatsSupplierObj::queryInterface(_rType); }
+
+ // XAggregation
+ virtual css::uno::Any SAL_CALL queryAggregation( const css::uno::Type& _rType ) override;
+
+ // XInitialization
+ virtual void SAL_CALL initialize( const css::uno::Sequence< css::uno::Any >& aArguments ) override;
+
+ // XServiceInfo
+ virtual OUString SAL_CALL getImplementationName( ) override;
+ virtual sal_Bool SAL_CALL supportsService( const OUString& ServiceName ) override;
+ virtual css::uno::Sequence< OUString > SAL_CALL getSupportedServiceNames( ) override;
+
+ // XNumberFormatsSupplier
+ virtual css::uno::Reference< css::beans::XPropertySet > SAL_CALL
+ getNumberFormatSettings() override;
+ virtual css::uno::Reference< css::util::XNumberFormats > SAL_CALL
+ getNumberFormats() override;
+
+ // XUnoTunneler
+ virtual sal_Int64 SAL_CALL getSomething( const css::uno::Sequence< sal_Int8 >& aIdentifier ) override;
+};
+
+
+#endif // INCLUDED_SVL_SOURCE_NUMBERS_SUPSERVS_HXX
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/svl/source/numbers/zforfind.cxx b/svl/source/numbers/zforfind.cxx
new file mode 100644
index 000000000..e3d8c752e
--- /dev/null
+++ b/svl/source/numbers/zforfind.cxx
@@ -0,0 +1,4288 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed
+ * with this work for additional information regarding copyright
+ * ownership. The ASF licenses this file to you under the Apache
+ * License, Version 2.0 (the "License"); you may not use this file
+ * except in compliance with the License. You may obtain a copy of
+ * the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#include <cstdlib>
+#include <dtoa.h>
+#include <float.h>
+#include <comphelper/string.hxx>
+#include <sal/log.hxx>
+#include <tools/date.hxx>
+#include <rtl/math.hxx>
+#include <rtl/character.hxx>
+#include <unotools/charclass.hxx>
+#include <unotools/calendarwrapper.hxx>
+#include <unotools/localedatawrapper.hxx>
+#include <com/sun/star/i18n/CalendarFieldIndex.hpp>
+#include <com/sun/star/i18n/LocaleCalendar2.hpp>
+#include <unotools/digitgroupingiterator.hxx>
+#include <comphelper/sequence.hxx>
+
+#include <svl/zforlist.hxx>
+#include "zforscan.hxx"
+#include <svl/zformat.hxx>
+
+#include <memory>
+
+#include "zforfind.hxx"
+
+#ifndef DBG_UTIL
+#define NF_TEST_CALENDAR 0
+#else
+#define NF_TEST_CALENDAR 0
+#endif
+#if NF_TEST_CALENDAR
+#include <comphelper/processfactory.hxx>
+#include <com/sun/star/i18n/XCalendar4.hpp>
+#endif
+
+
+const sal_uInt8 ImpSvNumberInputScan::nMatchedEndString = 0x01;
+const sal_uInt8 ImpSvNumberInputScan::nMatchedMidString = 0x02;
+const sal_uInt8 ImpSvNumberInputScan::nMatchedStartString = 0x04;
+const sal_uInt8 ImpSvNumberInputScan::nMatchedVirgin = 0x08;
+const sal_uInt8 ImpSvNumberInputScan::nMatchedUsedAsReturn = 0x10;
+
+/* It is not clear how we want timezones to be handled. Convert them to local
+ * time isn't wanted, as it isn't done in any other place and timezone
+ * information isn't stored anywhere. Ignoring them and pretending local time
+ * may be wrong too and might not be what the user expects. Keep the input as
+ * string so that no information is lost.
+ * Anyway, defining NF_RECOGNIZE_ISO8601_TIMEZONES to 1 would be the way how it
+ * would work, together with the nTimezonePos handling in GetTimeRef(). */
+#define NF_RECOGNIZE_ISO8601_TIMEZONES 0
+
+const sal_Unicode cNoBreakSpace = 0xA0;
+const sal_Unicode cNarrowNoBreakSpace = 0x202F;
+const bool kDefaultEra = true; // Gregorian CE, positive year
+
+ImpSvNumberInputScan::ImpSvNumberInputScan( SvNumberFormatter* pFormatterP )
+ :
+ bTextInitialized( false ),
+ bScanGenitiveMonths( false ),
+ bScanPartitiveMonths( false ),
+ eScannedType( SvNumFormatType::UNDEFINED ),
+ eSetType( SvNumFormatType::UNDEFINED )
+{
+ pFormatter = pFormatterP;
+ pNullDate.reset( new Date(30,12,1899) );
+ nYear2000 = SvNumberFormatter::GetYear2000Default();
+ Reset();
+ ChangeIntl();
+}
+
+
+ImpSvNumberInputScan::~ImpSvNumberInputScan()
+{
+}
+
+
+void ImpSvNumberInputScan::Reset()
+{
+ mpFormat = nullptr;
+ nMonth = 0;
+ nMonthPos = 0;
+ nDayOfWeek = 0;
+ nTimePos = 0;
+ nSign = 0;
+ nESign = 0;
+ nDecPos = 0;
+ bNegCheck = false;
+ nStringsCnt = 0;
+ nNumericsCnt = 0;
+ nThousand = 0;
+ eScannedType = SvNumFormatType::UNDEFINED;
+ nAmPm = 0;
+ nPosThousandString = 0;
+ nLogical = 0;
+ mbEraCE = kDefaultEra;
+ nStringScanNumFor = 0;
+ nStringScanSign = 0;
+ nMatchedAllStrings = nMatchedVirgin;
+ nMayBeIso8601 = 0;
+ bIso8601Tsep = false;
+ nMayBeMonthDate = 0;
+ nAcceptedDatePattern = -2;
+ nDatePatternStart = 0;
+ nDatePatternNumbers = 0;
+
+ for (sal_uInt32 i = 0; i < SV_MAX_COUNT_INPUT_STRINGS; i++)
+ {
+ IsNum[i] = false;
+ nNums[i] = 0;
+ }
+}
+
+// native number transliteration if necessary
+static void TransformInput( SvNumberFormatter const * pFormatter, OUString& rStr )
+{
+ sal_Int32 nPos, nLen;
+ for ( nPos = 0, nLen = rStr.getLength(); nPos < nLen; ++nPos )
+ {
+ if ( 256 <= rStr[ nPos ] &&
+ pFormatter->GetCharClass()->isDigit( rStr, nPos ) )
+ {
+ break;
+ }
+ }
+ if ( nPos < nLen )
+ {
+ rStr = pFormatter->GetNatNum()->getNativeNumberString( rStr,
+ pFormatter->GetLanguageTag().getLocale(), 0 );
+ }
+}
+
+
+/**
+ * Only simple unsigned floating point values without any error detection,
+ * decimal separator has to be '.'
+ */
+double ImpSvNumberInputScan::StringToDouble( std::u16string_view aStr, bool bForceFraction )
+{
+ std::unique_ptr<char[]> bufInHeap;
+ constexpr int bufOnStackSize = 256;
+ char bufOnStack[bufOnStackSize];
+ char* buf = bufOnStack;
+ const sal_Int32 bufsize = aStr.size() + (bForceFraction ? 2 : 1);
+ if (bufsize > bufOnStackSize)
+ {
+ bufInHeap = std::make_unique<char[]>(bufsize);
+ buf = bufInHeap.get();
+ }
+ char* p = buf;
+ if (bForceFraction)
+ *p++ = '.';
+ for (size_t nPos = 0; nPos < aStr.size(); ++nPos)
+ {
+ sal_Unicode c = aStr[nPos];
+ if (c == '.' || (c >= '0' && c <= '9'))
+ *p++ = static_cast<char>(c);
+ else
+ break;
+ }
+ *p = '\0';
+
+ return strtod_nolocale(buf, nullptr);
+}
+
+namespace {
+
+/**
+ * Splits up the input into numbers and strings for further processing
+ * (by the Turing machine).
+ *
+ * Starting state = GetChar
+ * ---------------+-------------------+-----------------------------+---------------
+ * Old State | Character read | Event | New state
+ * ---------------+-------------------+-----------------------------+---------------
+ * GetChar | Number | Symbol = Character | GetValue
+ * | Else | Symbol = Character | GetString
+ * ---------------|-------------------+-----------------------------+---------------
+ * GetValue | Number | Symbol = Symbol + Character | GetValue
+ * | Else | Dec(CharPos) | Stop
+ * ---------------+-------------------+-----------------------------+---------------
+ * GetString | Number | Dec(CharPos) | Stop
+ * | Else | Symbol = Symbol + Character | GetString
+ * ---------------+-------------------+-----------------------------+---------------
+ */
+enum ScanState // States of the Turing machine
+{
+ SsStop = 0,
+ SsStart = 1,
+ SsGetValue = 2,
+ SsGetString = 3
+};
+
+}
+
+bool ImpSvNumberInputScan::NextNumberStringSymbol( const sal_Unicode*& pStr,
+ OUString& rSymbol )
+{
+ bool isNumber = false;
+ sal_Unicode cToken;
+ ScanState eState = SsStart;
+ const sal_Unicode* pHere = pStr;
+ sal_Int32 nChars = 0;
+
+ for (;;)
+ {
+ cToken = *pHere;
+ if (cToken == 0 || eState == SsStop)
+ break;
+ pHere++;
+ switch (eState)
+ {
+ case SsStart:
+ if ( rtl::isAsciiDigit( cToken ) )
+ {
+ eState = SsGetValue;
+ isNumber = true;
+ }
+ else
+ {
+ eState = SsGetString;
+ }
+ nChars++;
+ break;
+ case SsGetValue:
+ if ( rtl::isAsciiDigit( cToken ) )
+ {
+ nChars++;
+ }
+ else
+ {
+ eState = SsStop;
+ pHere--;
+ }
+ break;
+ case SsGetString:
+ if ( !rtl::isAsciiDigit( cToken ) )
+ {
+ nChars++;
+ }
+ else
+ {
+ eState = SsStop;
+ pHere--;
+ }
+ break;
+ default:
+ break;
+ } // switch
+ } // while
+
+ if ( nChars )
+ {
+ rSymbol = OUString( pStr, nChars );
+ }
+ else
+ {
+ rSymbol.clear();
+ }
+
+ pStr = pHere;
+
+ return isNumber;
+}
+
+
+// FIXME: should be grouping; it is only used though in case nStringsCnt is
+// near SV_MAX_COUNT_INPUT_STRINGS, in NumberStringDivision().
+
+bool ImpSvNumberInputScan::SkipThousands( const sal_Unicode*& pStr,
+ OUString& rSymbol ) const
+{
+ bool res = false;
+ OUStringBuffer sBuff(rSymbol);
+ sal_Unicode cToken;
+ const OUString& rThSep = pFormatter->GetNumThousandSep();
+ const sal_Unicode* pHere = pStr;
+ ScanState eState = SsStart;
+ sal_Int32 nCounter = 0; // counts 3 digits
+
+ for (;;)
+ {
+ cToken = *pHere;
+ if (cToken == 0 || eState == SsStop)
+ break;
+ pHere++;
+ switch (eState)
+ {
+ case SsStart:
+ if ( StringPtrContains( rThSep, pHere-1, 0 ) )
+ {
+ nCounter = 0;
+ eState = SsGetValue;
+ pHere += rThSep.getLength() - 1;
+ }
+ else
+ {
+ eState = SsStop;
+ pHere--;
+ }
+ break;
+ case SsGetValue:
+ if ( rtl::isAsciiDigit( cToken ) )
+ {
+ sBuff.append(cToken);
+ nCounter++;
+ if (nCounter == 3)
+ {
+ eState = SsStart;
+ res = true; // .000 combination found
+ }
+ }
+ else
+ {
+ eState = SsStop;
+ pHere--;
+ }
+ break;
+ default:
+ break;
+ } // switch
+ } // while
+
+ if (eState == SsGetValue) // break with less than 3 digits
+ {
+ if ( nCounter )
+ {
+ sBuff.remove( sBuff.getLength() - nCounter, nCounter );
+ }
+ pHere -= nCounter + rThSep.getLength(); // put back ThSep also
+ }
+ rSymbol = sBuff.makeStringAndClear();
+ pStr = pHere;
+
+ return res;
+}
+
+
+void ImpSvNumberInputScan::NumberStringDivision( const OUString& rString )
+{
+ const sal_Unicode* pStr = rString.getStr();
+ const sal_Unicode* const pEnd = pStr + rString.getLength();
+ while ( pStr < pEnd && nStringsCnt < SV_MAX_COUNT_INPUT_STRINGS )
+ {
+ if ( NextNumberStringSymbol( pStr, sStrArray[nStringsCnt] ) )
+ { // Number
+ IsNum[nStringsCnt] = true;
+ nNums[nNumericsCnt] = nStringsCnt;
+ nNumericsCnt++;
+ if (nStringsCnt >= SV_MAX_COUNT_INPUT_STRINGS - 7 &&
+ nPosThousandString == 0) // Only once
+ {
+ if ( SkipThousands( pStr, sStrArray[nStringsCnt] ) )
+ {
+ nPosThousandString = nStringsCnt;
+ }
+ }
+ }
+ else
+ {
+ IsNum[nStringsCnt] = false;
+ }
+ nStringsCnt++;
+ }
+}
+
+
+/**
+ * Whether rString contains rWhat at nPos
+ */
+bool ImpSvNumberInputScan::StringContainsImpl( const OUString& rWhat,
+ const OUString& rString, sal_Int32 nPos )
+{
+ if ( nPos + rWhat.getLength() <= rString.getLength() )
+ {
+ return StringPtrContainsImpl( rWhat, rString.getStr(), nPos );
+ }
+ return false;
+}
+
+
+/**
+ * Whether pString contains rWhat at nPos
+ */
+bool ImpSvNumberInputScan::StringPtrContainsImpl( const OUString& rWhat,
+ const sal_Unicode* pString, sal_Int32 nPos )
+{
+ if ( rWhat.isEmpty() )
+ {
+ return false;
+ }
+ const sal_Unicode* pWhat = rWhat.getStr();
+ const sal_Unicode* const pEnd = pWhat + rWhat.getLength();
+ const sal_Unicode* pStr = pString + nPos;
+ while ( pWhat < pEnd )
+ {
+ if ( *pWhat != *pStr )
+ {
+ return false;
+ }
+ pWhat++;
+ pStr++;
+ }
+ return true;
+}
+
+
+/**
+ * Whether rString contains word rWhat at nPos
+ */
+bool ImpSvNumberInputScan::StringContainsWord( const OUString& rWhat,
+ const OUString& rString, sal_Int32 nPos ) const
+{
+ if (rWhat.isEmpty() || rString.getLength() < nPos + rWhat.getLength())
+ return false;
+
+ if (StringPtrContainsImpl( rWhat, rString.getStr(), nPos))
+ {
+ nPos += rWhat.getLength();
+ if (nPos == rString.getLength())
+ return true; // word at end of string
+
+ /* TODO: we COULD invoke bells and whistles word break iterator to find
+ * the next boundary, but really ... this is called for date input, so
+ * how many languages do not separate the day and month names in some
+ * form? */
+
+ // Check simple ASCII first before invoking i18n or anything else.
+ const sal_Unicode c = rString[nPos];
+
+ // Common separating ASCII characters in date context.
+ switch (c)
+ {
+ case ' ':
+ case '-':
+ case '.':
+ case '/':
+ return true;
+ default:
+ ; // nothing
+ }
+
+ if (rtl::isAsciiAlphanumeric( c ))
+ return false; // Alpha or numeric is not word gap.
+
+ sal_Int32 nIndex = nPos;
+ rString.iterateCodePoints( &nIndex);
+ if (nPos+1 < nIndex)
+ return true; // Surrogate, assume these to be new words.
+
+ const sal_Int32 nType = pFormatter->GetCharClass()->getCharacterType( rString, nPos);
+ using namespace ::com::sun::star::i18n;
+
+ if ((nType & (KCharacterType::UPPER | KCharacterType::LOWER | KCharacterType::DIGIT)) != 0)
+ return false; // Alpha or numeric is not word gap.
+
+ if (nType & KCharacterType::LETTER)
+ return true; // Letter other than alpha is new word. (Is it?)
+
+ return true; // Catch all remaining as gap until we know better.
+ }
+
+ return false;
+}
+
+
+/**
+ * Skips the supplied char
+ */
+inline bool ImpSvNumberInputScan::SkipChar( sal_Unicode c, const OUString& rString,
+ sal_Int32& nPos )
+{
+ if ((nPos < rString.getLength()) && (rString[nPos] == c))
+ {
+ nPos++;
+ return true;
+ }
+ return false;
+}
+
+
+/**
+ * Skips blanks
+ */
+inline bool ImpSvNumberInputScan::SkipBlanks( const OUString& rString,
+ sal_Int32& nPos )
+{
+ sal_Int32 nHere = nPos;
+ if ( nPos < rString.getLength() )
+ {
+ const sal_Unicode* p = rString.getStr() + nPos;
+ while ( *p == ' ' || *p == cNoBreakSpace || *p == cNarrowNoBreakSpace )
+ {
+ nPos++;
+ p++;
+ }
+ }
+ return nHere < nPos;
+}
+
+
+/**
+ * jump over rWhat in rString at nPos
+ */
+inline bool ImpSvNumberInputScan::SkipString( const OUString& rWhat,
+ const OUString& rString, sal_Int32& nPos )
+{
+ if ( StringContains( rWhat, rString, nPos ) )
+ {
+ nPos = nPos + rWhat.getLength();
+ return true;
+ }
+ return false;
+}
+
+
+/**
+ * Recognizes exactly ,111 in {3} and {3,2} or ,11 in {3,2} grouping
+ */
+inline bool ImpSvNumberInputScan::GetThousandSep( const OUString& rString,
+ sal_Int32& nPos,
+ sal_uInt16 nStringPos ) const
+{
+ const OUString& rSep = pFormatter->GetNumThousandSep();
+ // Is it an ordinary space instead of a no-break space?
+ bool bSpaceBreak = (rSep[0] == cNoBreakSpace || rSep[0] == cNarrowNoBreakSpace) &&
+ rString[0] == u' ' &&
+ rSep.getLength() == 1 && rString.getLength() == 1;
+ if (!((rString == rSep || bSpaceBreak) && // nothing else
+ nStringPos < nStringsCnt - 1 && // safety first!
+ IsNum[ nStringPos + 1 ] )) // number follows
+ {
+ return false; // no? => out
+ }
+
+ utl::DigitGroupingIterator aGrouping( pFormatter->GetLocaleData()->getDigitGrouping());
+ // Match ,### in {3} or ,## in {3,2}
+ /* FIXME: this could be refined to match ,## in {3,2} only if ,##,## or
+ * ,##,### and to match ,### in {3,2} only if it's the last. However,
+ * currently there is no track kept where group separators occur. In {3,2}
+ * #,###,### and #,##,## would be valid input, which maybe isn't even bad
+ * for #,###,###. Other combinations such as #,###,## maybe not. */
+ sal_Int32 nLen = sStrArray[ nStringPos + 1 ].getLength();
+ if (nLen == aGrouping.get() || // with 3 (or so) digits
+ nLen == aGrouping.advance().get() || // or with 2 (or 3 or so) digits
+ nPosThousandString == nStringPos + 1 ) // or concatenated
+ {
+ nPos = nPos + rSep.getLength();
+ return true;
+ }
+ return false;
+}
+
+
+/**
+ * Conversion of text to logical value
+ * "true" => 1:
+ * "false"=> -1:
+ * else => 0:
+ */
+short ImpSvNumberInputScan::GetLogical( std::u16string_view rString ) const
+{
+ short res;
+
+ const ImpSvNumberformatScan* pFS = pFormatter->GetFormatScanner();
+ if ( rString == pFS->GetTrueString() )
+ {
+ res = 1;
+ }
+ else if ( rString == pFS->GetFalseString() )
+ {
+ res = -1;
+ }
+ else
+ {
+ res = 0;
+ }
+ return res;
+}
+
+
+/**
+ * Converts a string containing a month name (JAN, January) at nPos into the
+ * month number (negative if abbreviated), returns 0 if nothing found
+ */
+short ImpSvNumberInputScan::GetMonth( const OUString& rString, sal_Int32& nPos )
+{
+ short res = 0; // no month found
+
+ if (rString.getLength() > nPos) // only if needed
+ {
+ if ( !bTextInitialized )
+ {
+ InitText();
+ }
+ sal_Int16 nMonths = pFormatter->GetCalendar()->getNumberOfMonthsInYear();
+ for ( sal_Int16 i = 0; i < nMonths; i++ )
+ {
+ if ( bScanGenitiveMonths && StringContainsWord( pUpperGenitiveMonthText[i], rString, nPos ) )
+ { // genitive full names first
+ nPos = nPos + pUpperGenitiveMonthText[i].getLength();
+ res = i + 1;
+ break; // for
+ }
+ else if ( bScanGenitiveMonths && StringContainsWord( pUpperGenitiveAbbrevMonthText[i], rString, nPos ) )
+ { // genitive abbreviated
+ nPos = nPos + pUpperGenitiveAbbrevMonthText[i].getLength();
+ res = sal::static_int_cast< short >(-(i+1)); // negative
+ break; // for
+ }
+ else if ( bScanPartitiveMonths && StringContainsWord( pUpperPartitiveMonthText[i], rString, nPos ) )
+ { // partitive full names
+ nPos = nPos + pUpperPartitiveMonthText[i].getLength();
+ res = i+1;
+ break; // for
+ }
+ else if ( bScanPartitiveMonths && StringContainsWord( pUpperPartitiveAbbrevMonthText[i], rString, nPos ) )
+ { // partitive abbreviated
+ nPos = nPos + pUpperPartitiveAbbrevMonthText[i].getLength();
+ res = sal::static_int_cast< short >(-(i+1)); // negative
+ break; // for
+ }
+ else if ( StringContainsWord( pUpperMonthText[i], rString, nPos ) )
+ { // noun full names
+ nPos = nPos + pUpperMonthText[i].getLength();
+ res = i+1;
+ break; // for
+ }
+ else if ( StringContainsWord( pUpperAbbrevMonthText[i], rString, nPos ) )
+ { // noun abbreviated
+ nPos = nPos + pUpperAbbrevMonthText[i].getLength();
+ res = sal::static_int_cast< short >(-(i+1)); // negative
+ break; // for
+ }
+ else if (i == 2 && pFormatter->GetLanguageTag().getLanguage() == "de")
+ {
+ if (pUpperAbbrevMonthText[i] == u"M\u00C4R" && StringContainsWord( "MRZ", rString, nPos))
+ { // Accept MRZ for MÄR
+ nPos = nPos + 3;
+ res = sal::static_int_cast< short >(-(i+1)); // negative
+ break; // for
+ }
+ else if (pUpperAbbrevMonthText[i] == "MRZ" && StringContainsWord( u"M\u00C4R", rString, nPos))
+ { // And vice versa, accept MÄR for MRZ
+ nPos = nPos + 3;
+ res = sal::static_int_cast< short >(-(i+1)); // negative
+ break; // for
+ }
+ }
+ else if (i == 8)
+ {
+ // This assumes the weirdness is applicable to all locales.
+ // It is the case for at least en-* and de-* locales.
+ if (pUpperAbbrevMonthText[i] == "SEPT" && StringContainsWord( "SEP", rString, nPos))
+ { // #102136# The correct English form of month September abbreviated is
+ // SEPT, but almost every data contains SEP instead.
+ nPos = nPos + 3;
+ res = sal::static_int_cast< short >(-(i+1)); // negative
+ break; // for
+ }
+ else if (pUpperAbbrevMonthText[i] == "SEP" && StringContainsWord( "SEPT", rString, nPos))
+ { // And vice versa, accept SEPT for SEP
+ nPos = nPos + 4;
+ res = sal::static_int_cast< short >(-(i+1)); // negative
+ break; // for
+ }
+ }
+ }
+ if (!res)
+ {
+ // Brutal hack for German locales that know "Januar" or "Jänner".
+ /* TODO: add alternative month names to locale data? if there are
+ * more languages... */
+ const LanguageTag& rLanguageTag = pFormatter->GetLanguageTag();
+ if (rLanguageTag.getLanguage() == "de")
+ {
+ if (rLanguageTag.getCountry() == "AT")
+ {
+ // Locale data has Jänner/Jän
+ assert(pUpperMonthText[0] == u"J\u00C4NNER");
+ if (StringContainsWord( "JANUAR", rString, nPos))
+ {
+ nPos += 6;
+ res = 1;
+ }
+ else if (StringContainsWord( "JAN", rString, nPos))
+ {
+ nPos += 3;
+ res = -1;
+ }
+ }
+ else
+ {
+ // Locale data has Januar/Jan
+ assert(pUpperMonthText[0] == "JANUAR");
+ if (StringContainsWord( u"J\u00C4NNER", rString, nPos))
+ {
+ nPos += 6;
+ res = 1;
+ }
+ else if (StringContainsWord( u"J\u00C4N", rString, nPos))
+ {
+ nPos += 3;
+ res = -1;
+ }
+ }
+ }
+ }
+ }
+
+ return res;
+}
+
+
+/**
+ * Converts a string containing a DayOfWeek name (Mon, Monday) at nPos into the
+ * DayOfWeek number + 1 (negative if abbreviated), returns 0 if nothing found
+ */
+int ImpSvNumberInputScan::GetDayOfWeek( const OUString& rString, sal_Int32& nPos )
+{
+ int res = 0; // no day found
+
+ if (rString.getLength() > nPos) // only if needed
+ {
+ if ( !bTextInitialized )
+ {
+ InitText();
+ }
+ sal_Int16 nDays = pFormatter->GetCalendar()->getNumberOfDaysInWeek();
+ for ( sal_Int16 i = 0; i < nDays; i++ )
+ {
+ if ( StringContainsWord( pUpperDayText[i], rString, nPos ) )
+ { // full names first
+ nPos = nPos + pUpperDayText[i].getLength();
+ res = i + 1;
+ break; // for
+ }
+ if ( StringContainsWord( pUpperAbbrevDayText[i], rString, nPos ) )
+ { // abbreviated
+ nPos = nPos + pUpperAbbrevDayText[i].getLength();
+ res = -(i + 1); // negative
+ break; // for
+ }
+ }
+ }
+
+ return res;
+}
+
+
+/**
+ * Reading a currency symbol
+ * '$' => true
+ * else => false
+ */
+bool ImpSvNumberInputScan::GetCurrency( const OUString& rString, sal_Int32& nPos )
+{
+ if ( rString.getLength() > nPos )
+ {
+ if ( !aUpperCurrSymbol.getLength() )
+ { // If no format specified the currency of the currently active locale.
+ LanguageType eLang = (mpFormat ? mpFormat->GetLanguage() :
+ pFormatter->GetLocaleData()->getLanguageTag().getLanguageType());
+ aUpperCurrSymbol = pFormatter->GetCharClass()->uppercase(
+ SvNumberFormatter::GetCurrencyEntry( eLang ).GetSymbol() );
+ }
+ if ( StringContains( aUpperCurrSymbol, rString, nPos ) )
+ {
+ nPos = nPos + aUpperCurrSymbol.getLength();
+ return true;
+ }
+ if ( mpFormat )
+ {
+ OUString aSymbol, aExtension;
+ if ( mpFormat->GetNewCurrencySymbol( aSymbol, aExtension ) )
+ {
+ if ( aSymbol.getLength() <= rString.getLength() - nPos )
+ {
+ aSymbol = pFormatter->GetCharClass()->uppercase(aSymbol);
+ if ( StringContains( aSymbol, rString, nPos ) )
+ {
+ nPos = nPos + aSymbol.getLength();
+ return true;
+ }
+ }
+ }
+ }
+ }
+
+ return false;
+}
+
+
+/**
+ * Reading the time period specifier (AM/PM) for the 12 hour clock
+ *
+ * Returns:
+ * "AM" or "PM" => true
+ * else => false
+ *
+ * nAmPos:
+ * "AM" => 1
+ * "PM" => -1
+ * else => 0
+*/
+bool ImpSvNumberInputScan::GetTimeAmPm( const OUString& rString, sal_Int32& nPos )
+{
+
+ if ( rString.getLength() > nPos )
+ {
+ const CharClass* pChr = pFormatter->GetCharClass();
+ const LocaleDataWrapper* pLoc = pFormatter->GetLocaleData();
+ if ( StringContains( pChr->uppercase( pLoc->getTimeAM() ), rString, nPos ) )
+ {
+ nAmPm = 1;
+ nPos = nPos + pLoc->getTimeAM().getLength();
+ return true;
+ }
+ else if ( StringContains( pChr->uppercase( pLoc->getTimePM() ), rString, nPos ) )
+ {
+ nAmPm = -1;
+ nPos = nPos + pLoc->getTimePM().getLength();
+ return true;
+ }
+ }
+
+ return false;
+}
+
+
+/**
+ * Read a decimal separator (',')
+ * ',' => true
+ * else => false
+ */
+inline bool ImpSvNumberInputScan::GetDecSep( const OUString& rString, sal_Int32& nPos ) const
+{
+ if ( rString.getLength() > nPos )
+ {
+ const OUString& rSep = pFormatter->GetNumDecimalSep();
+ if ( rString.match( rSep, nPos) )
+ {
+ nPos = nPos + rSep.getLength();
+ return true;
+ }
+ const OUString& rSepAlt = pFormatter->GetNumDecimalSepAlt();
+ if ( !rSepAlt.isEmpty() && rString.match( rSepAlt, nPos) )
+ {
+ nPos = nPos + rSepAlt.getLength();
+ return true;
+ }
+ }
+ return false;
+}
+
+
+/**
+ * Reading a hundredth seconds separator
+ */
+inline bool ImpSvNumberInputScan::GetTime100SecSep( const OUString& rString, sal_Int32& nPos ) const
+{
+ if ( rString.getLength() > nPos )
+ {
+ if (bIso8601Tsep)
+ {
+ // ISO 8601 specifies both '.' dot and ',' comma as fractional
+ // separator.
+ if (rString[nPos] == '.' || rString[nPos] == ',')
+ {
+ ++nPos;
+ return true;
+ }
+ }
+ // Even in an otherwise ISO 8601 string be lenient and accept the
+ // locale defined separator.
+ const OUString& rSep = pFormatter->GetLocaleData()->getTime100SecSep();
+ if ( rString.match( rSep, nPos ))
+ {
+ nPos = nPos + rSep.getLength();
+ return true;
+ }
+ }
+ return false;
+}
+
+
+/**
+ * Read a sign including brackets
+ * '+' => 1
+ * '-' => -1
+ * '(' => -1, bNegCheck = 1
+ * else => 0
+ */
+int ImpSvNumberInputScan::GetSign( const OUString& rString, sal_Int32& nPos )
+{
+ if (rString.getLength() > nPos)
+ switch (rString[ nPos ])
+ {
+ case '+':
+ nPos++;
+ return 1;
+ case '(': // '(' similar to '-' ?!?
+ bNegCheck = true;
+ [[fallthrough]];
+ case '-':
+ nPos++;
+ return -1;
+ default:
+ break;
+ }
+
+ return 0;
+}
+
+
+/**
+ * Read a sign with an exponent
+ * '+' => 1
+ * '-' => -1
+ * else => 0
+ */
+short ImpSvNumberInputScan::GetESign( const OUString& rString, sal_Int32& nPos )
+{
+ if (rString.getLength() > nPos)
+ {
+ switch (rString[nPos])
+ {
+ case '+':
+ nPos++;
+ return 1;
+ case '-':
+ nPos++;
+ return -1;
+ default:
+ break;
+ }
+ }
+ return 0;
+}
+
+
+/**
+ * i counts string portions, j counts numbers thereof.
+ * It should had been called SkipNumber instead.
+ */
+inline bool ImpSvNumberInputScan::GetNextNumber( sal_uInt16& i, sal_uInt16& j ) const
+{
+ if ( i < nStringsCnt && IsNum[i] )
+ {
+ j++;
+ i++;
+ return true;
+ }
+ return false;
+}
+
+
+bool ImpSvNumberInputScan::GetTimeRef( double& fOutNumber,
+ sal_uInt16 nIndex, // j-value of the first numeric time part of input, default 0
+ sal_uInt16 nCnt, // count of numeric time parts
+ SvNumInputOptions eInputOptions
+ ) const
+{
+ bool bRet = true;
+ sal_uInt16 nHour;
+ sal_uInt16 nMinute = 0;
+ sal_uInt16 nSecond = 0;
+ double fSecond100 = 0.0;
+ sal_uInt16 nStartIndex = nIndex;
+
+ if (nDecPos == 2 && (nCnt == 3 || nCnt == 2)) // 20:45.5 or 45.5
+ {
+ nHour = 0;
+ }
+ else if (mpFormat && nDecPos == 0 && nCnt == 2 && mpFormat->IsMinuteSecondFormat())
+ {
+ // Input on MM:SS format, instead of doing HH:MM:00
+ nHour = 0;
+ }
+ else if (nIndex - nStartIndex < nCnt)
+ {
+ nHour = static_cast<sal_uInt16>(sStrArray[nNums[nIndex++]].toInt32());
+ }
+ else
+ {
+ nHour = 0;
+ bRet = false;
+ SAL_WARN( "svl.numbers", "ImpSvNumberInputScan::GetTimeRef: bad number index");
+ }
+
+ // 0:123 or 0:0:123 or 0:123:59 is valid
+ bool bAllowDuration = (nHour == 0 && !nAmPm);
+
+ if (nAmPm && nHour > 12) // not a valid AM/PM clock time
+ {
+ bRet = false;
+ }
+ else if (nAmPm == -1 && nHour != 12) // PM
+ {
+ nHour += 12;
+ }
+ else if (nAmPm == 1 && nHour == 12) // 12 AM
+ {
+ nHour = 0;
+ }
+
+ if (nDecPos == 2 && nCnt == 2) // 45.5
+ {
+ nMinute = 0;
+ }
+ else if (nIndex - nStartIndex < nCnt)
+ {
+ nMinute = static_cast<sal_uInt16>(sStrArray[nNums[nIndex++]].toInt32());
+ if (!(eInputOptions & SvNumInputOptions::LAX_TIME) && !bAllowDuration
+ && nIndex > 1 && nMinute > 59)
+ bRet = false; // 1:60 or 1:123 is invalid, 123:1 or 0:123 is valid
+ if (bAllowDuration)
+ bAllowDuration = (nMinute == 0);
+ }
+ if (nIndex - nStartIndex < nCnt)
+ {
+ nSecond = static_cast<sal_uInt16>(sStrArray[nNums[nIndex++]].toInt32());
+ if (!(eInputOptions & SvNumInputOptions::LAX_TIME) && !bAllowDuration
+ && nIndex > 1 && nSecond > 59 && !(nHour == 23 && nMinute == 59 && nSecond == 60))
+ bRet = false; // 1:60 or 1:123 or 1:1:123 is invalid, 123:1 or 123:1:1 or 0:0:123 is valid, or leap second
+ }
+ if (nIndex - nStartIndex < nCnt)
+ {
+ fSecond100 = StringToDouble( sStrArray[nNums[nIndex]], true );
+ }
+ fOutNumber = (static_cast<double>(nHour)*3600 +
+ static_cast<double>(nMinute)*60 +
+ static_cast<double>(nSecond) +
+ fSecond100)/86400.0;
+ return bRet;
+}
+
+
+sal_uInt16 ImpSvNumberInputScan::ImplGetDay( sal_uInt16 nIndex ) const
+{
+ sal_uInt16 nRes = 0;
+
+ if (sStrArray[nNums[nIndex]].getLength() <= 2)
+ {
+ sal_uInt16 nNum = static_cast<sal_uInt16>(sStrArray[nNums[nIndex]].toInt32());
+ if (nNum <= 31)
+ {
+ nRes = nNum;
+ }
+ }
+
+ return nRes;
+}
+
+
+sal_uInt16 ImpSvNumberInputScan::ImplGetMonth( sal_uInt16 nIndex ) const
+{
+ // Preset invalid month number
+ sal_uInt16 nRes = pFormatter->GetCalendar()->getNumberOfMonthsInYear();
+
+ if (sStrArray[nNums[nIndex]].getLength() <= 2)
+ {
+ sal_uInt16 nNum = static_cast<sal_uInt16>(sStrArray[nNums[nIndex]].toInt32());
+ if ( 0 < nNum && nNum <= nRes )
+ {
+ nRes = nNum - 1; // zero based for CalendarFieldIndex::MONTH
+ }
+ }
+
+ return nRes;
+}
+
+
+/**
+ * 30 -> 1930, 29 -> 2029, or 56 -> 1756, 55 -> 1855, ...
+ */
+sal_uInt16 ImpSvNumberInputScan::ImplGetYear( sal_uInt16 nIndex )
+{
+ sal_uInt16 nYear = 0;
+
+ sal_Int32 nLen = sStrArray[nNums[nIndex]].getLength();
+ // 16-bit integer year width can have 5 digits, allow for one additional
+ // leading zero as convention.
+ if (nLen <= 6)
+ {
+ nYear = static_cast<sal_uInt16>(sStrArray[nNums[nIndex]].toInt32());
+ // A year in another, not Gregorian CE era is never expanded.
+ // A year < 100 entered with at least 3 digits with leading 0 is taken
+ // as is without expansion.
+ if (mbEraCE == kDefaultEra && nYear < 100 && nLen < 3)
+ {
+ nYear = SvNumberFormatter::ExpandTwoDigitYear( nYear, nYear2000 );
+ }
+ }
+
+ return nYear;
+}
+
+
+bool ImpSvNumberInputScan::MayBeIso8601()
+{
+ if (nMayBeIso8601 == 0)
+ {
+ nMayBeIso8601 = 1;
+ sal_Int32 nLen = ((nNumericsCnt >= 1 && nNums[0] < nStringsCnt) ? sStrArray[nNums[0]].getLength() : 0);
+ if (nLen)
+ {
+ sal_Int32 n;
+ if (nNumericsCnt >= 3 && nNums[2] < nStringsCnt &&
+ sStrArray[nNums[0]+1] == "-" && // separator year-month
+ (n = sStrArray[nNums[1]].toInt32()) >= 1 && n <= 12 && // month
+ sStrArray[nNums[1]+1] == "-" && // separator month-day
+ (n = sStrArray[nNums[2]].toInt32()) >= 1 && n <= 31) // day
+ {
+ // Year (nNums[0]) value not checked, may be anything, but
+ // length (number of digits) is checked.
+ nMayBeIso8601 = (nLen >= 4 ? 4 : (nLen == 3 ? 3 : (nLen > 0 ? 2 : 1)));
+ }
+ }
+ }
+ return nMayBeIso8601 > 1;
+}
+
+
+bool ImpSvNumberInputScan::CanForceToIso8601( DateOrder eDateOrder )
+{
+ int nCanForceToIso8601 = 0;
+ if (!MayBeIso8601())
+ {
+ return false;
+ }
+ else if (nMayBeIso8601 >= 3)
+ {
+ return true; // at least 3 digits in year
+ }
+ else
+ {
+ if (eDateOrder == DateOrder::Invalid)
+ {
+ // As if any of the cases below can be applied, but only if a
+ // locale dependent date pattern was not matched.
+ if ((GetDatePatternNumbers() == nNumericsCnt) && IsDatePatternNumberOfType(0,'Y'))
+ return false;
+ eDateOrder = GetDateOrder();
+ }
+
+ nCanForceToIso8601 = 1;
+ }
+
+ sal_Int32 n;
+ switch (eDateOrder)
+ {
+ case DateOrder::DMY: // "day" value out of range => ISO 8601 year
+ n = sStrArray[nNums[0]].toInt32();
+ if (n < 1 || n > 31)
+ {
+ nCanForceToIso8601 = 2;
+ }
+ break;
+ case DateOrder::MDY: // "month" value out of range => ISO 8601 year
+ n = sStrArray[nNums[0]].toInt32();
+ if (n < 1 || n > 12)
+ {
+ nCanForceToIso8601 = 2;
+ }
+ break;
+ case DateOrder::YMD: // always possible
+ nCanForceToIso8601 = 2;
+ break;
+ default: break;
+ }
+ return nCanForceToIso8601 > 1;
+}
+
+
+bool ImpSvNumberInputScan::IsAcceptableIso8601()
+{
+ if (mpFormat && (mpFormat->GetType() & SvNumFormatType::DATE))
+ {
+ switch (pFormatter->GetEvalDateFormat())
+ {
+ case NF_EVALDATEFORMAT_INTL:
+ return CanForceToIso8601( GetDateOrder());
+ case NF_EVALDATEFORMAT_FORMAT:
+ return CanForceToIso8601( mpFormat->GetDateOrder());
+ default:
+ return CanForceToIso8601( GetDateOrder()) || CanForceToIso8601( mpFormat->GetDateOrder());
+ }
+ }
+ return CanForceToIso8601( GetDateOrder());
+}
+
+
+bool ImpSvNumberInputScan::MayBeMonthDate()
+{
+ if (nMayBeMonthDate == 0)
+ {
+ nMayBeMonthDate = 1;
+ if (nNumericsCnt >= 2 && nNums[1] < nStringsCnt)
+ {
+ // "-Jan-"
+ const OUString& rM = sStrArray[ nNums[ 0 ] + 1 ];
+ if (rM.getLength() >= 3 && rM[0] == '-' && rM[ rM.getLength() - 1] == '-')
+ {
+ // Check year length assuming at least 3 digits (including
+ // leading zero). Two digit years 1..31 are out of luck here
+ // and may be taken as day of month.
+ bool bYear1 = (sStrArray[nNums[0]].getLength() >= 3);
+ bool bYear2 = (sStrArray[nNums[1]].getLength() >= 3);
+ sal_Int32 n;
+ bool bDay1 = !bYear1;
+ if (bDay1)
+ {
+ n = sStrArray[nNums[0]].toInt32();
+ bDay1 = n >= 1 && n <= 31;
+ }
+ bool bDay2 = !bYear2;
+ if (bDay2)
+ {
+ n = sStrArray[nNums[1]].toInt32();
+ bDay2 = n >= 1 && n <= 31;
+ }
+
+ if (bDay1 && !bDay2)
+ {
+ nMayBeMonthDate = 2; // dd-month-yy
+ }
+ else if (!bDay1 && bDay2)
+ {
+ nMayBeMonthDate = 3; // yy-month-dd
+ }
+ else if (bDay1 && bDay2)
+ {
+ // Ambiguous ##-MMM-## date, but some big vendor's database
+ // reports write this crap, assume this always to be
+ nMayBeMonthDate = 2; // dd-month-yy
+ }
+ }
+ }
+ }
+ return nMayBeMonthDate > 1;
+}
+
+
+/** If a string is a separator plus '-' minus sign preceding a 'Y' year in
+ a date pattern at position nPat.
+ */
+static bool lcl_IsSignedYearSep( const OUString& rStr, const OUString& rPat, sal_Int32 nPat )
+{
+ bool bOk = false;
+ sal_Int32 nLen = rStr.getLength();
+ if (nLen > 1 && rStr[nLen-1] == '-')
+ {
+ --nLen;
+ if (nPat + nLen < rPat.getLength() && rPat[nPat+nLen] == 'Y')
+ {
+ // Signed year is possible.
+ bOk = (rPat.indexOf( rStr.subView( 0, nLen), nPat) == nPat);
+ }
+ }
+ return bOk;
+}
+
+
+/** Length of separator usually is 1 but theoretically could be anything. */
+static sal_Int32 lcl_getPatternSeparatorLength( const OUString& rPat, sal_Int32 nPat )
+{
+ sal_Int32 nSep = nPat;
+ sal_Unicode c;
+ while (nSep < rPat.getLength() && (c = rPat[nSep]) != 'D' && c != 'M' && c != 'Y')
+ ++nSep;
+ return nSep - nPat;
+}
+
+
+bool ImpSvNumberInputScan::IsAcceptedDatePattern( sal_uInt16 nStartPatternAt )
+{
+ if (nAcceptedDatePattern >= -1)
+ {
+ return (nAcceptedDatePattern >= 0);
+ }
+ if (!nNumericsCnt)
+ {
+ nAcceptedDatePattern = -1;
+ }
+ else if (!sDateAcceptancePatterns.hasElements())
+ {
+ // The current locale is the format's locale, if a format is present.
+ const NfEvalDateFormat eEDF = pFormatter->GetEvalDateFormat();
+ if (!mpFormat || eEDF == NF_EVALDATEFORMAT_FORMAT || mpFormat->GetLanguage() == pFormatter->GetLanguage())
+ {
+ sDateAcceptancePatterns = pFormatter->GetLocaleData()->getDateAcceptancePatterns();
+ }
+ else
+ {
+ OnDemandLocaleDataWrapper& xLocaleData = pFormatter->GetOnDemandLocaleDataWrapper(
+ SvNumberFormatter::InputScannerPrivateAccess());
+ const LanguageTag aSaveLocale( xLocaleData->getLanguageTag() );
+ assert(mpFormat->GetLanguage() == aSaveLocale.getLanguageType()); // prerequisite
+ // Obtain formatter's locale's (e.g. system) patterns.
+ xLocaleData.changeLocale( LanguageTag( pFormatter->GetLanguage()));
+ const css::uno::Sequence<OUString> aLocalePatterns( xLocaleData->getDateAcceptancePatterns());
+ // Reset to format's locale.
+ xLocaleData.changeLocale( aSaveLocale);
+ // When concatenating don't care about duplicates, combining
+ // weeding those out reallocs yet another time and probably doesn't
+ // take less time than looping over two additional patterns below...
+ switch (eEDF)
+ {
+ case NF_EVALDATEFORMAT_FORMAT:
+ assert(!"shouldn't reach here");
+ break;
+ case NF_EVALDATEFORMAT_INTL:
+ sDateAcceptancePatterns = aLocalePatterns;
+ break;
+ case NF_EVALDATEFORMAT_INTL_FORMAT:
+ sDateAcceptancePatterns = comphelper::concatSequences(
+ aLocalePatterns,
+ xLocaleData->getDateAcceptancePatterns());
+ break;
+ case NF_EVALDATEFORMAT_FORMAT_INTL:
+ sDateAcceptancePatterns = comphelper::concatSequences(
+ xLocaleData->getDateAcceptancePatterns(),
+ aLocalePatterns);
+ break;
+ }
+ }
+ SAL_WARN_IF( !sDateAcceptancePatterns.hasElements(), "svl.numbers", "ImpSvNumberInputScan::IsAcceptedDatePattern: no date acceptance patterns");
+ nAcceptedDatePattern = (sDateAcceptancePatterns.hasElements() ? -2 : -1);
+ }
+
+ if (nAcceptedDatePattern == -1)
+ {
+ return false;
+ }
+ nDatePatternStart = nStartPatternAt; // remember start particle
+
+ const sal_Int32 nMonthsInYear = pFormatter->GetCalendar()->getNumberOfMonthsInYear();
+
+ for (sal_Int32 nPattern=0; nPattern < sDateAcceptancePatterns.getLength(); ++nPattern)
+ {
+ const OUString& rPat = sDateAcceptancePatterns[nPattern];
+ if (rPat.getLength() == 3)
+ {
+ // Ignore a pattern that would match numeric input with decimal
+ // separator. It may had been read from configuration or resulted
+ // from the locales' patterns concatenation above.
+ if ( rPat[1] == pFormatter->GetLocaleData()->getNumDecimalSep().toChar()
+ || rPat[1] == pFormatter->GetLocaleData()->getNumDecimalSepAlt().toChar())
+ {
+ SAL_WARN("svl.numbers", "ignoring date acceptance pattern with decimal separator ambiguity: " << rPat);
+ continue; // for, next pattern
+ }
+ }
+ sal_uInt16 nNext = nDatePatternStart;
+ nDatePatternNumbers = 0;
+ bool bOk = true;
+ sal_Int32 nPat = 0;
+ for ( ; nPat < rPat.getLength() && bOk && nNext < nStringsCnt; ++nPat, ++nNext)
+ {
+ const sal_Unicode c = rPat[nPat];
+ switch (c)
+ {
+ case 'Y':
+ case 'M':
+ case 'D':
+ bOk = IsNum[nNext];
+ if (bOk && (c == 'M' || c == 'D'))
+ {
+ // Check the D and M cases for plausibility. This also
+ // prevents recognition of date instead of number with a
+ // numeric group input if date separator is identical to
+ // group separator, for example with D.M as a pattern and
+ // #.### as a group.
+ sal_Int32 nMaxLen, nMaxVal;
+ switch (c)
+ {
+ case 'M':
+ nMaxLen = 2;
+ nMaxVal = nMonthsInYear;
+ break;
+ case 'D':
+ nMaxLen = 2;
+ nMaxVal = 31;
+ break;
+ default:
+ // This merely exists against
+ // -Werror=maybe-uninitialized, which is nonsense
+ // after the (c == 'M' || c == 'D') check above,
+ // but ...
+ nMaxLen = 2;
+ nMaxVal = 31;
+ }
+ bOk = (sStrArray[nNext].getLength() <= nMaxLen);
+ if (bOk)
+ {
+ sal_Int32 nNum = sStrArray[nNext].toInt32();
+ bOk = (1 <= nNum && nNum <= nMaxVal);
+ }
+ }
+ if (bOk)
+ ++nDatePatternNumbers;
+ break;
+ default:
+ bOk = !IsNum[nNext];
+ if (bOk)
+ {
+ const sal_Int32 nSepLen = lcl_getPatternSeparatorLength( rPat, nPat);
+ // Non-numeric input must match separator exactly to be
+ // accepted as such.
+ const sal_Int32 nLen = sStrArray[nNext].getLength();
+ bOk = (nLen == nSepLen && rPat.indexOf( sStrArray[nNext], nPat) == nPat);
+ if (bOk)
+ {
+ nPat += nLen - 1;
+ }
+ else if ((bOk = lcl_IsSignedYearSep( sStrArray[nNext], rPat, nPat)))
+ {
+ nPat += nLen - 2;
+ }
+ else if (nPat + nLen > rPat.getLength() && sStrArray[nNext][ nLen - 1 ] == ' ')
+ {
+ using namespace comphelper::string;
+ // Trailing blanks in input.
+ OUStringBuffer aBuf(sStrArray[nNext]);
+ aBuf.stripEnd();
+ // Expand again in case of pattern "M. D. " and
+ // input "M. D. ", maybe fetched far, but...
+ padToLength(aBuf, rPat.getLength() - nPat, ' ');
+ bOk = (rPat.indexOf( aBuf, nPat) == nPat);
+ if (bOk)
+ {
+ nPat += aBuf.getLength() - 1;
+ }
+ }
+ }
+ break;
+ }
+ }
+ if (bOk)
+ {
+ // Check for trailing characters mismatch.
+ if (nNext < nStringsCnt)
+ {
+ // Pattern end but not input end.
+ // A trailing blank may be part of the current pattern input,
+ // if pattern is "D.M." and input is "D.M. hh:mm" last was
+ // ". ", or may be following the current pattern input, if
+ // pattern is "D.M" and input is "D.M hh:mm" last was "M".
+ sal_Int32 nPos = 0;
+ sal_uInt16 nCheck;
+ if (nPat > 0 && nNext > 0)
+ {
+ // nPat is one behind after the for loop.
+ sal_Int32 nPatCheck = nPat - 1;
+ switch (rPat[nPatCheck])
+ {
+ case 'Y':
+ case 'M':
+ case 'D':
+ nCheck = nNext;
+ break;
+ default:
+ {
+ nCheck = nNext - 1;
+ // Advance position in input to match length of
+ // non-YMD (separator) characters in pattern.
+ sal_Unicode c;
+ do
+ {
+ ++nPos;
+ c = rPat[--nPatCheck];
+ } while (c != 'Y' && c != 'M' && c != 'D' && nPatCheck > 0);
+ }
+ }
+ }
+ else
+ {
+ nCheck = nNext;
+ }
+ if (!IsNum[nCheck])
+ {
+ // Trailing (or separating if time follows) blanks are ok.
+ // No blank and a following number is not.
+ const bool bBlanks = SkipBlanks( sStrArray[nCheck], nPos);
+ if (nPos == sStrArray[nCheck].getLength() && (bBlanks || !IsNum[nNext]))
+ {
+ nAcceptedDatePattern = nPattern;
+ return true;
+ }
+ }
+ }
+ else if (nPat == rPat.getLength())
+ {
+ // Input end and pattern end => match.
+ nAcceptedDatePattern = nPattern;
+ return true;
+ }
+ // else Input end but not pattern end, no match.
+ }
+ }
+ nAcceptedDatePattern = -1;
+ return false;
+}
+
+
+bool ImpSvNumberInputScan::SkipDatePatternSeparator( sal_uInt16 nParticle, sal_Int32 & rPos, bool & rSignedYear )
+{
+ // If not initialized yet start with first number, if any.
+ if (!IsAcceptedDatePattern( nNumericsCnt ? nNums[0] : 0 ))
+ {
+ return false;
+ }
+ if (nParticle < nDatePatternStart || nParticle >= nStringsCnt || IsNum[nParticle])
+ {
+ return false;
+ }
+ sal_uInt16 nNext = nDatePatternStart;
+ const OUString& rPat = sDateAcceptancePatterns[nAcceptedDatePattern];
+ for (sal_Int32 nPat = 0; nPat < rPat.getLength() && nNext < nStringsCnt; ++nPat, ++nNext)
+ {
+ switch (rPat[nPat])
+ {
+ case 'Y':
+ case 'M':
+ case 'D':
+ break;
+ default:
+ if (nNext == nParticle)
+ {
+ const sal_Int32 nSepLen = lcl_getPatternSeparatorLength( rPat, nPat);
+ const sal_Int32 nLen = sStrArray[nNext].getLength();
+ bool bOk = (nLen == nSepLen && rPat.indexOf( sStrArray[nNext], nPat) == nPat);
+ if (!bOk)
+ {
+ bOk = lcl_IsSignedYearSep( sStrArray[nNext], rPat, nPat);
+ if (bOk)
+ rSignedYear = true;
+ }
+ if (!bOk && (nPat + nLen > rPat.getLength() && sStrArray[nNext][ nLen - 1 ] == ' '))
+ {
+ // The same ugly trailing blanks check as in
+ // IsAcceptedDatePattern().
+ using namespace comphelper::string;
+ OUStringBuffer aBuf(sStrArray[nNext]);
+ aBuf.stripEnd();
+ padToLength(aBuf, rPat.getLength() - nPat, ' ');
+ bOk = (rPat.indexOf(aBuf, nPat) == nPat);
+ }
+ if (bOk)
+ {
+ rPos = nLen; // yes, set, not add!
+ return true;
+ }
+ else
+ return false;
+ }
+ nPat += sStrArray[nNext].getLength() - 1;
+ break;
+ }
+ }
+ return false;
+}
+
+
+sal_uInt16 ImpSvNumberInputScan::GetDatePatternNumbers()
+{
+ // If not initialized yet start with first number, if any.
+ if (!IsAcceptedDatePattern( nNumericsCnt ? nNums[0] : 0 ))
+ {
+ return 0;
+ }
+ return nDatePatternNumbers;
+}
+
+
+bool ImpSvNumberInputScan::IsDatePatternNumberOfType( sal_uInt16 nNumber, sal_Unicode cType )
+{
+ if (GetDatePatternNumbers() <= nNumber)
+ return false;
+
+ sal_uInt16 nNum = 0;
+ const OUString& rPat = sDateAcceptancePatterns[nAcceptedDatePattern];
+ for (sal_Int32 nPat = 0; nPat < rPat.getLength(); ++nPat)
+ {
+ switch (rPat[nPat])
+ {
+ case 'Y':
+ case 'M':
+ case 'D':
+ if (nNum == nNumber)
+ return rPat[nPat] == cType;
+ ++nNum;
+ break;
+ }
+ }
+ return false;
+}
+
+
+sal_uInt32 ImpSvNumberInputScan::GetDatePatternOrder()
+{
+ // If not initialized yet start with first number, if any.
+ if (!IsAcceptedDatePattern( nNumericsCnt ? nNums[0] : 0 ))
+ {
+ return 0;
+ }
+ sal_uInt32 nOrder = 0;
+ const OUString& rPat = sDateAcceptancePatterns[nAcceptedDatePattern];
+ for (sal_Int32 nPat = 0; nPat < rPat.getLength() && !(nOrder & 0xff0000); ++nPat)
+ {
+ switch (rPat[nPat])
+ {
+ case 'Y':
+ case 'M':
+ case 'D':
+ nOrder = (nOrder << 8) | rPat[nPat];
+ break;
+ }
+ }
+ return nOrder;
+}
+
+
+DateOrder ImpSvNumberInputScan::GetDateOrder( bool bFromFormatIfNoPattern )
+{
+ sal_uInt32 nOrder = GetDatePatternOrder();
+ if (!nOrder)
+ {
+ if (bFromFormatIfNoPattern && mpFormat)
+ return mpFormat->GetDateOrder();
+ else
+ return pFormatter->GetLocaleData()->getDateOrder();
+ }
+ switch ((nOrder & 0xff0000) >> 16)
+ {
+ case 'Y':
+ if ((((nOrder & 0xff00) >> 8) == 'M') && ((nOrder & 0xff) == 'D'))
+ {
+ return DateOrder::YMD;
+ }
+ break;
+ case 'M':
+ if ((((nOrder & 0xff00) >> 8) == 'D') && ((nOrder & 0xff) == 'Y'))
+ {
+ return DateOrder::MDY;
+ }
+ break;
+ case 'D':
+ if ((((nOrder & 0xff00) >> 8) == 'M') && ((nOrder & 0xff) == 'Y'))
+ {
+ return DateOrder::DMY;
+ }
+ break;
+ default:
+ case 0:
+ switch ((nOrder & 0xff00) >> 8)
+ {
+ case 'Y':
+ switch (nOrder & 0xff)
+ {
+ case 'M':
+ return DateOrder::YMD;
+ }
+ break;
+ case 'M':
+ switch (nOrder & 0xff)
+ {
+ case 'Y':
+ return DateOrder::DMY;
+ case 'D':
+ return DateOrder::MDY;
+ }
+ break;
+ case 'D':
+ switch (nOrder & 0xff)
+ {
+ case 'Y':
+ return DateOrder::MDY;
+ case 'M':
+ return DateOrder::DMY;
+ }
+ break;
+ default:
+ case 0:
+ switch (nOrder & 0xff)
+ {
+ case 'Y':
+ return DateOrder::YMD;
+ case 'M':
+ return DateOrder::MDY;
+ case 'D':
+ return DateOrder::DMY;
+ }
+ break;
+ }
+ }
+ SAL_WARN( "svl.numbers", "ImpSvNumberInputScan::GetDateOrder: undefined, falling back to locale's default");
+ return pFormatter->GetLocaleData()->getDateOrder();
+}
+
+LongDateOrder ImpSvNumberInputScan::GetMiddleMonthLongDateOrder( bool bFormatTurn,
+ const LocaleDataWrapper* pLoc,
+ DateOrder eDateOrder )
+{
+ if (MayBeMonthDate())
+ return (nMayBeMonthDate == 2) ? LongDateOrder::DMY : LongDateOrder::YMD;
+
+ LongDateOrder eLDO;
+ const sal_uInt32 nExactDateOrder = (bFormatTurn ? mpFormat->GetExactDateOrder() : 0);
+ if (!nExactDateOrder)
+ eLDO = pLoc->getLongDateOrder();
+ else if ((((nExactDateOrder >> 16) & 0xff) == 'Y') && ((nExactDateOrder & 0xff) == 'D'))
+ eLDO = LongDateOrder::YMD;
+ else if ((((nExactDateOrder >> 16) & 0xff) == 'D') && ((nExactDateOrder & 0xff) == 'Y'))
+ eLDO = LongDateOrder::DMY;
+ else
+ eLDO = pLoc->getLongDateOrder();
+ if (eLDO != LongDateOrder::YMD && eLDO != LongDateOrder::DMY)
+ {
+ switch (eDateOrder)
+ {
+ case DateOrder::YMD:
+ eLDO = LongDateOrder::YMD;
+ break;
+ case DateOrder::DMY:
+ eLDO = LongDateOrder::DMY;
+ break;
+ default:
+ ; // nothing, not a date
+ }
+ }
+ else if (eLDO == LongDateOrder::DMY && eDateOrder == DateOrder::YMD)
+ {
+ // Check possible order and maybe switch.
+ if (!ImplGetDay(0) && ImplGetDay(1))
+ eLDO = LongDateOrder::YMD;
+ }
+ else if (eLDO == LongDateOrder::YMD && eDateOrder == DateOrder::DMY)
+ {
+ // Check possible order and maybe switch.
+ if (!ImplGetDay(1) && ImplGetDay(0))
+ eLDO = LongDateOrder::DMY;
+ }
+ return eLDO;
+}
+
+bool ImpSvNumberInputScan::GetDateRef( double& fDays, sal_uInt16& nCounter )
+{
+ using namespace ::com::sun::star::i18n;
+ NfEvalDateFormat eEDF;
+ int nFormatOrder;
+ if ( mpFormat && (mpFormat->GetType() & SvNumFormatType::DATE) )
+ {
+ eEDF = pFormatter->GetEvalDateFormat();
+ switch ( eEDF )
+ {
+ case NF_EVALDATEFORMAT_INTL :
+ case NF_EVALDATEFORMAT_FORMAT :
+ nFormatOrder = 1; // only one loop
+ break;
+ default:
+ nFormatOrder = 2;
+ if ( nMatchedAllStrings )
+ {
+ eEDF = NF_EVALDATEFORMAT_FORMAT_INTL;
+ // we have a complete match, use it
+ }
+ }
+ }
+ else
+ {
+ eEDF = NF_EVALDATEFORMAT_INTL;
+ nFormatOrder = 1;
+ }
+ bool res = true;
+
+ const LocaleDataWrapper* pLoc = pFormatter->GetLocaleData();
+ CalendarWrapper* pCal = pFormatter->GetCalendar();
+ for ( int nTryOrder = 1; nTryOrder <= nFormatOrder; nTryOrder++ )
+ {
+ pCal->setGregorianDateTime( Date( Date::SYSTEM ) ); // today
+ OUString aOrgCalendar; // empty => not changed yet
+ DateOrder DateFmt;
+ bool bFormatTurn;
+ switch ( eEDF )
+ {
+ case NF_EVALDATEFORMAT_INTL :
+ bFormatTurn = false;
+ DateFmt = GetDateOrder();
+ break;
+ case NF_EVALDATEFORMAT_FORMAT :
+ bFormatTurn = true;
+ DateFmt = mpFormat->GetDateOrder();
+ break;
+ case NF_EVALDATEFORMAT_INTL_FORMAT :
+ if ( nTryOrder == 1 )
+ {
+ bFormatTurn = false;
+ DateFmt = GetDateOrder();
+ }
+ else
+ {
+ bFormatTurn = true;
+ DateFmt = mpFormat->GetDateOrder();
+ }
+ break;
+ case NF_EVALDATEFORMAT_FORMAT_INTL :
+ if ( nTryOrder == 2 )
+ {
+ bFormatTurn = false;
+ DateFmt = GetDateOrder();
+ }
+ else
+ {
+ bFormatTurn = true;
+ // Even if the format pattern is to be preferred, the input may
+ // have matched a pattern of the current locale, which then
+ // again is to be preferred. Both date orders can be different
+ // so we need to obtain the actual match. For example ISO
+ // YYYY-MM-DD format vs locale's DD.MM.YY input.
+ // If no pattern was matched, obtain from format.
+ // Note that patterns may have been constructed from the
+ // format's locale and prepended to the current locale's
+ // patterns, it doesn't necessarily mean a current locale's
+ // pattern was matched, but may if the format's locale's
+ // patterns didn't match, which were tried first.
+ DateFmt = GetDateOrder(true);
+ }
+ break;
+ default:
+ SAL_WARN( "svl.numbers", "ImpSvNumberInputScan::GetDateRef: unknown NfEvalDateFormat" );
+ DateFmt = DateOrder::YMD;
+ bFormatTurn = false;
+ }
+ if ( bFormatTurn )
+ {
+/* TODO:
+We are currently not able to fully support a switch to another calendar during
+input for the following reasons:
+1. We do have a problem if both (locale's default and format's) calendars
+ define the same YMD order and use the same date separator, there is no way
+ to distinguish between them if the input results in valid calendar input for
+ both calendars. How to solve? Would NfEvalDateFormat be sufficient? Should
+ it always be set to NF_EVALDATEFORMAT_FORMAT_INTL and thus the format's
+ calendar be preferred? This could be confusing if a Calc cell was formatted
+ different to the locale's default and has no content yet, then the user has
+ no clue about the format or calendar being set.
+2. In Calc cell edit mode a date is always displayed and edited using the
+ default edit format of the default calendar (normally being Gregorian). If
+ input was ambiguous due to issue #1 we'd need a mechanism to tell that a
+ date was edited and not newly entered. Not feasible. Otherwise we'd need a
+ mechanism to use a specific edit format with a specific calendar according
+ to the format set.
+3. For some calendars like Japanese Gengou we'd need era input, which isn't
+ implemented at all. Though this is a rare and special case, forcing a
+ calendar dependent edit format as suggested in item #2 might require era
+ input, if it shouldn't result in a fallback to Gregorian calendar.
+4. Last and least: the GetMonth() method currently only matches month names of
+ the default calendar. Alternating month names of the actual format's
+ calendar would have to be implemented. No problem.
+
+*/
+#ifdef THE_FUTURE
+ if ( mpFormat->IsOtherCalendar( nStringScanNumFor ) )
+ {
+ mpFormat->SwitchToOtherCalendar( aOrgCalendar, fOrgDateTime );
+ }
+ else
+ {
+ mpFormat->SwitchToSpecifiedCalendar( aOrgCalendar, fOrgDateTime,
+ nStringScanNumFor );
+ }
+#endif
+ }
+
+ res = true;
+ nCounter = 0;
+ // For incomplete dates, always assume first day of month if not specified.
+ pCal->setValue( CalendarFieldIndex::DAY_OF_MONTH, 1 );
+
+ switch (nNumericsCnt) // count of numbers in string
+ {
+ case 0: // none
+ if (nMonthPos) // only month (Jan)
+ {
+ pCal->setValue( CalendarFieldIndex::MONTH, std::abs(nMonth)-1 );
+ }
+ else
+ {
+ res = false;
+ }
+ break;
+
+ case 1: // only one number
+ nCounter = 1;
+ switch (nMonthPos) // where is the month
+ {
+ case 0: // not found
+ {
+ // If input matched a date pattern, use the pattern
+ // to determine if it is a day, month or year. The
+ // pattern should have only one single value then,
+ // 'D-', 'M-' or 'Y-'. If input did not match a
+ // pattern assume the usual day of current month.
+ sal_uInt32 nDateOrder = (bFormatTurn ?
+ mpFormat->GetExactDateOrder() :
+ GetDatePatternOrder());
+ switch (nDateOrder)
+ {
+ case 'Y':
+ pCal->setValue( CalendarFieldIndex::YEAR, ImplGetYear(0) );
+ break;
+ case 'M':
+ pCal->setValue( CalendarFieldIndex::MONTH, ImplGetMonth(0) );
+ break;
+ case 'D':
+ default:
+ pCal->setValue( CalendarFieldIndex::DAY_OF_MONTH, ImplGetDay(0) );
+ break;
+ }
+ break;
+ }
+ case 1: // month at the beginning (Jan 01)
+ pCal->setValue( CalendarFieldIndex::MONTH, std::abs(nMonth)-1 );
+ switch (DateFmt)
+ {
+ case DateOrder::MDY:
+ case DateOrder::YMD:
+ {
+ sal_uInt16 nDay = ImplGetDay(0);
+ sal_uInt16 nYear = ImplGetYear(0);
+ if (nDay == 0 || nDay > 32)
+ {
+ pCal->setValue( CalendarFieldIndex::YEAR, nYear);
+ }
+ else
+ {
+ pCal->setValue( CalendarFieldIndex::DAY_OF_MONTH, ImplGetDay(0) );
+ }
+ break;
+ }
+ case DateOrder::DMY:
+ pCal->setValue( CalendarFieldIndex::YEAR, ImplGetYear(0) );
+ break;
+ default:
+ res = false;
+ break;
+ }
+ break;
+ case 3: // month at the end (10 Jan)
+ pCal->setValue( CalendarFieldIndex::MONTH, std::abs(nMonth)-1 );
+ switch (DateFmt)
+ {
+ case DateOrder::DMY:
+ pCal->setValue( CalendarFieldIndex::DAY_OF_MONTH, ImplGetDay(0) );
+ break;
+ case DateOrder::YMD:
+ pCal->setValue( CalendarFieldIndex::YEAR, ImplGetYear(0) );
+ break;
+ default:
+ res = false;
+ break;
+ }
+ break;
+ default:
+ res = false;
+ break;
+ } // switch (nMonthPos)
+ break;
+
+ case 2: // 2 numbers
+ nCounter = 2;
+ switch (nMonthPos) // where is the month
+ {
+ case 0: // not found
+ {
+ sal_uInt32 nExactDateOrder = (bFormatTurn ?
+ mpFormat->GetExactDateOrder() :
+ GetDatePatternOrder());
+ bool bIsExact = (0xff < nExactDateOrder && nExactDateOrder <= 0xffff);
+ if (!bIsExact && bFormatTurn && IsAcceptedDatePattern( nNums[0]))
+ {
+ // If input does not match format but pattern, use pattern
+ // instead, even if eEDF==NF_EVALDATEFORMAT_FORMAT_INTL.
+ // For example, format has "Y-M-D" and pattern is "D.M.",
+ // input with 2 numbers can't match format and 31.12. would
+ // lead to 1931-12-01 (fdo#54344)
+ nExactDateOrder = GetDatePatternOrder();
+ bIsExact = (0xff < nExactDateOrder && nExactDateOrder <= 0xffff);
+ }
+ bool bHadExact;
+ if (bIsExact)
+ {
+ // formatted as date and exactly 2 parts
+ bHadExact = true;
+ switch ( (nExactDateOrder >> 8) & 0xff )
+ {
+ case 'Y':
+ pCal->setValue( CalendarFieldIndex::YEAR, ImplGetYear(0) );
+ break;
+ case 'M':
+ pCal->setValue( CalendarFieldIndex::MONTH, ImplGetMonth(0) );
+ break;
+ case 'D':
+ pCal->setValue( CalendarFieldIndex::DAY_OF_MONTH, ImplGetDay(0) );
+ break;
+ default:
+ bHadExact = false;
+ }
+ switch ( nExactDateOrder & 0xff )
+ {
+ case 'Y':
+ pCal->setValue( CalendarFieldIndex::YEAR, ImplGetYear(1) );
+ break;
+ case 'M':
+ pCal->setValue( CalendarFieldIndex::MONTH, ImplGetMonth(1) );
+ break;
+ case 'D':
+ pCal->setValue( CalendarFieldIndex::DAY_OF_MONTH, ImplGetDay(1) );
+ break;
+ default:
+ bHadExact = false;
+ }
+ SAL_WARN_IF( !bHadExact, "svl.numbers", "ImpSvNumberInputScan::GetDateRef: error in exact date order");
+ }
+ else
+ {
+ bHadExact = false;
+ }
+ // If input matched against a date acceptance pattern
+ // do not attempt to mess around with guessing the
+ // order, either it matches or it doesn't.
+ if ((bFormatTurn || !bIsExact) && (!bHadExact || !pCal->isValid()))
+ {
+ if ( !bHadExact && nExactDateOrder )
+ {
+ pCal->setGregorianDateTime( Date( Date::SYSTEM ) ); // reset today
+ }
+ switch (DateFmt)
+ {
+ case DateOrder::MDY:
+ // M D
+ pCal->setValue( CalendarFieldIndex::DAY_OF_MONTH, ImplGetDay(1) );
+ pCal->setValue( CalendarFieldIndex::MONTH, ImplGetMonth(0) );
+ if ( !pCal->isValid() ) // 2nd try
+ { // M Y
+ pCal->setValue( CalendarFieldIndex::DAY_OF_MONTH, 1 );
+ pCal->setValue( CalendarFieldIndex::MONTH, ImplGetMonth(0) );
+ pCal->setValue( CalendarFieldIndex::YEAR, ImplGetYear(1) );
+ }
+ break;
+ case DateOrder::DMY:
+ // D M
+ pCal->setValue( CalendarFieldIndex::DAY_OF_MONTH, ImplGetDay(0) );
+ pCal->setValue( CalendarFieldIndex::MONTH, ImplGetMonth(1) );
+ if ( !pCal->isValid() ) // 2nd try
+ { // M Y
+ pCal->setValue( CalendarFieldIndex::DAY_OF_MONTH, 1 );
+ pCal->setValue( CalendarFieldIndex::MONTH, ImplGetMonth(0) );
+ pCal->setValue( CalendarFieldIndex::YEAR, ImplGetYear(1) );
+ }
+ break;
+ case DateOrder::YMD:
+ // M D
+ pCal->setValue( CalendarFieldIndex::DAY_OF_MONTH, ImplGetDay(1) );
+ pCal->setValue( CalendarFieldIndex::MONTH, ImplGetMonth(0) );
+ if ( !pCal->isValid() ) // 2nd try
+ { // Y M
+ pCal->setValue( CalendarFieldIndex::DAY_OF_MONTH, 1 );
+ pCal->setValue( CalendarFieldIndex::MONTH, ImplGetMonth(1) );
+ pCal->setValue( CalendarFieldIndex::YEAR, ImplGetYear(0) );
+ }
+ break;
+ default:
+ res = false;
+ break;
+ }
+ }
+ }
+ break;
+ case 1: // month at the beginning (Jan 01 01)
+ {
+ // The input is valid as MDY in almost any
+ // constellation, there is no date order (M)YD except if
+ // set in a format applied.
+ pCal->setValue( CalendarFieldIndex::MONTH, std::abs(nMonth)-1 );
+ sal_uInt32 nExactDateOrder = (bFormatTurn ? mpFormat->GetExactDateOrder() : 0);
+ if ((((nExactDateOrder >> 8) & 0xff) == 'Y') && ((nExactDateOrder & 0xff) == 'D'))
+ {
+ pCal->setValue( CalendarFieldIndex::DAY_OF_MONTH, ImplGetDay(1) );
+ pCal->setValue( CalendarFieldIndex::YEAR, ImplGetYear(0) );
+ }
+ else
+ {
+ pCal->setValue( CalendarFieldIndex::DAY_OF_MONTH, ImplGetDay(0) );
+ pCal->setValue( CalendarFieldIndex::YEAR, ImplGetYear(1) );
+ }
+ break;
+ }
+ case 2: // month in the middle (10 Jan 94)
+ {
+ pCal->setValue( CalendarFieldIndex::MONTH, std::abs(nMonth)-1 );
+ const LongDateOrder eLDO = GetMiddleMonthLongDateOrder( bFormatTurn, pLoc, DateFmt);
+ switch (eLDO)
+ {
+ case LongDateOrder::DMY:
+ pCal->setValue( CalendarFieldIndex::DAY_OF_MONTH, ImplGetDay(0) );
+ pCal->setValue( CalendarFieldIndex::YEAR, ImplGetYear(1) );
+ break;
+ case LongDateOrder::YMD:
+ pCal->setValue( CalendarFieldIndex::DAY_OF_MONTH, ImplGetDay(1) );
+ pCal->setValue( CalendarFieldIndex::YEAR, ImplGetYear(0) );
+ break;
+ default:
+ res = false;
+ break;
+ }
+ break;
+ }
+ default: // else, e.g. month at the end (94 10 Jan)
+ res = false;
+ break;
+ } // switch (nMonthPos)
+ break;
+
+ default: // more than two numbers (31.12.94 8:23) (31.12. 8:23)
+ switch (nMonthPos) // where is the month
+ {
+ case 0: // not found
+ {
+ nCounter = 3;
+ if ( nTimePos > 1 )
+ { // find first time number index (should only be 3 or 2 anyway)
+ for ( sal_uInt16 j = 0; j < nNumericsCnt; j++ )
+ {
+ if ( nNums[j] == nTimePos - 2 )
+ {
+ nCounter = j;
+ break; // for
+ }
+ }
+ }
+ // ISO 8601 yyyy-mm-dd forced recognition
+ DateOrder eDF = (CanForceToIso8601( DateFmt) ? DateOrder::YMD : DateFmt);
+ switch (eDF)
+ {
+ case DateOrder::MDY:
+ pCal->setValue( CalendarFieldIndex::DAY_OF_MONTH, ImplGetDay(1) );
+ pCal->setValue( CalendarFieldIndex::MONTH, ImplGetMonth(0) );
+ if ( nCounter > 2 )
+ pCal->setValue( CalendarFieldIndex::YEAR, ImplGetYear(2) );
+ break;
+ case DateOrder::DMY:
+ pCal->setValue( CalendarFieldIndex::DAY_OF_MONTH, ImplGetDay(0) );
+ pCal->setValue( CalendarFieldIndex::MONTH, ImplGetMonth(1) );
+ if ( nCounter > 2 )
+ pCal->setValue( CalendarFieldIndex::YEAR, ImplGetYear(2) );
+ break;
+ case DateOrder::YMD:
+ if ( nCounter > 2 )
+ pCal->setValue( CalendarFieldIndex::DAY_OF_MONTH, ImplGetDay(2) );
+ pCal->setValue( CalendarFieldIndex::MONTH, ImplGetMonth(1) );
+ pCal->setValue( CalendarFieldIndex::YEAR, ImplGetYear(0) );
+ break;
+ default:
+ res = false;
+ break;
+ }
+ break;
+ }
+ case 1: // month at the beginning (Jan 01 01 8:23)
+ nCounter = 2;
+ switch (DateFmt)
+ {
+ case DateOrder::MDY:
+ pCal->setValue( CalendarFieldIndex::DAY_OF_MONTH, ImplGetDay(0) );
+ pCal->setValue( CalendarFieldIndex::MONTH, std::abs(nMonth)-1 );
+ pCal->setValue( CalendarFieldIndex::YEAR, ImplGetYear(1) );
+ break;
+ default:
+ res = false;
+ break;
+ }
+ break;
+ case 2: // month in the middle (10 Jan 94 8:23)
+ {
+ nCounter = 2;
+ pCal->setValue( CalendarFieldIndex::MONTH, std::abs(nMonth)-1 );
+ const LongDateOrder eLDO = GetMiddleMonthLongDateOrder( bFormatTurn, pLoc, DateFmt);
+ switch (eLDO)
+ {
+ case LongDateOrder::DMY:
+ pCal->setValue( CalendarFieldIndex::DAY_OF_MONTH, ImplGetDay(0) );
+ pCal->setValue( CalendarFieldIndex::YEAR, ImplGetYear(1) );
+ break;
+ case LongDateOrder::YMD:
+ pCal->setValue( CalendarFieldIndex::DAY_OF_MONTH, ImplGetDay(1) );
+ pCal->setValue( CalendarFieldIndex::YEAR, ImplGetYear(0) );
+ break;
+ default:
+ res = false;
+ break;
+ }
+ break;
+ }
+ default: // else, e.g. month at the end (94 10 Jan 8:23)
+ nCounter = 2;
+ res = false;
+ break;
+ } // switch (nMonthPos)
+ break;
+ } // switch (nNumericsCnt)
+
+ if (mbEraCE != kDefaultEra)
+ pCal->setValue( CalendarFieldIndex::ERA, mbEraCE ? 1 : 0);
+
+ if ( res && pCal->isValid() )
+ {
+ double fDiff = DateTime(*pNullDate) - pCal->getEpochStart();
+ fDays = ::rtl::math::approxFloor( pCal->getLocalDateTime() );
+ fDays -= fDiff;
+ nTryOrder = nFormatOrder; // break for
+ }
+ else
+ {
+ res = false;
+ }
+ if ( aOrgCalendar.getLength() )
+ {
+ pCal->loadCalendar( aOrgCalendar, pLoc->getLanguageTag().getLocale() ); // restore calendar
+ }
+#if NF_TEST_CALENDAR
+ {
+ using namespace ::com::sun::star;
+ struct entry { const char* lan; const char* cou; const char* cal; };
+ const entry cals[] = {
+ { "en", "US", "gregorian" },
+ { "ar", "TN", "hijri" },
+ { "he", "IL", "jewish" },
+ { "ja", "JP", "gengou" },
+ { "ko", "KR", "hanja_yoil" },
+ { "th", "TH", "buddhist" },
+ { "zh", "TW", "ROC" },
+ {0,0,0}
+ };
+ lang::Locale aLocale;
+ bool bValid;
+ sal_Int16 nDay, nMyMonth, nYear, nHour, nMinute, nSecond;
+ sal_Int16 nDaySet, nMonthSet, nYearSet, nHourSet, nMinuteSet, nSecondSet;
+ sal_Int16 nZO, nDST1, nDST2, nDST, nZOmillis, nDST1millis, nDST2millis, nDSTmillis;
+ sal_Int32 nZoneInMillis, nDST1InMillis, nDST2InMillis;
+ uno::Reference< uno::XComponentContext > xContext =
+ ::comphelper::getProcessComponentContext();
+ uno::Reference< i18n::XCalendar4 > xCal = i18n::LocaleCalendar2::create(xContext);
+ for ( const entry* p = cals; p->lan; ++p )
+ {
+ aLocale.Language = OUString::createFromAscii( p->lan );
+ aLocale.Country = OUString::createFromAscii( p->cou );
+ xCal->loadCalendar( OUString::createFromAscii( p->cal ),
+ aLocale );
+ double nDateTime = 0.0; // 1-Jan-1970 00:00:00
+ nZO = xCal->getValue( i18n::CalendarFieldIndex::ZONE_OFFSET );
+ nZOmillis = xCal->getValue( i18n::CalendarFieldIndex::ZONE_OFFSET_SECOND_MILLIS );
+ nZoneInMillis = static_cast<sal_Int32>(nZO) * 60000 +
+ (nZO < 0 ? -1 : 1) * static_cast<sal_uInt16>(nZOmillis);
+ nDST1 = xCal->getValue( i18n::CalendarFieldIndex::DST_OFFSET );
+ nDST1millis = xCal->getValue( i18n::CalendarFieldIndex::DST_OFFSET_SECOND_MILLIS );
+ nDST1InMillis = static_cast<sal_Int32>(nDST1) * 60000 +
+ (nDST1 < 0 ? -1 : 1) * static_cast<sal_uInt16>(nDST1millis);
+ nDateTime -= (double)(nZoneInMillis + nDST1InMillis) / 1000.0 / 60.0 / 60.0 / 24.0;
+ xCal->setDateTime( nDateTime );
+ nDST2 = xCal->getValue( i18n::CalendarFieldIndex::DST_OFFSET );
+ nDST2millis = xCal->getValue( i18n::CalendarFieldIndex::DST_OFFSET_SECOND_MILLIS );
+ nDST2InMillis = static_cast<sal_Int32>(nDST2) * 60000 +
+ (nDST2 < 0 ? -1 : 1) * static_cast<sal_uInt16>(nDST2millis);
+ if ( nDST1InMillis != nDST2InMillis )
+ {
+ nDateTime = 0.0 - (double)(nZoneInMillis + nDST2InMillis) / 1000.0 / 60.0 / 60.0 / 24.0;
+ xCal->setDateTime( nDateTime );
+ }
+ nDaySet = xCal->getValue( i18n::CalendarFieldIndex::DAY_OF_MONTH );
+ nMonthSet = xCal->getValue( i18n::CalendarFieldIndex::MONTH );
+ nYearSet = xCal->getValue( i18n::CalendarFieldIndex::YEAR );
+ nHourSet = xCal->getValue( i18n::CalendarFieldIndex::HOUR );
+ nMinuteSet = xCal->getValue( i18n::CalendarFieldIndex::MINUTE );
+ nSecondSet = xCal->getValue( i18n::CalendarFieldIndex::SECOND );
+ nZO = xCal->getValue( i18n::CalendarFieldIndex::ZONE_OFFSET );
+ nZOmillis = xCal->getValue( i18n::CalendarFieldIndex::ZONE_OFFSET_SECOND_MILLIS );
+ nDST = xCal->getValue( i18n::CalendarFieldIndex::DST_OFFSET );
+ nDSTmillis = xCal->getValue( i18n::CalendarFieldIndex::DST_OFFSET_SECOND_MILLIS );
+ xCal->setValue( i18n::CalendarFieldIndex::DAY_OF_MONTH, nDaySet );
+ xCal->setValue( i18n::CalendarFieldIndex::MONTH, nMonthSet );
+ xCal->setValue( i18n::CalendarFieldIndex::YEAR, nYearSet );
+ xCal->setValue( i18n::CalendarFieldIndex::HOUR, nHourSet );
+ xCal->setValue( i18n::CalendarFieldIndex::MINUTE, nMinuteSet );
+ xCal->setValue( i18n::CalendarFieldIndex::SECOND, nSecondSet );
+ bValid = xCal->isValid();
+ nDay = xCal->getValue( i18n::CalendarFieldIndex::DAY_OF_MONTH );
+ nMyMonth= xCal->getValue( i18n::CalendarFieldIndex::MONTH );
+ nYear = xCal->getValue( i18n::CalendarFieldIndex::YEAR );
+ nHour = xCal->getValue( i18n::CalendarFieldIndex::HOUR );
+ nMinute = xCal->getValue( i18n::CalendarFieldIndex::MINUTE );
+ nSecond = xCal->getValue( i18n::CalendarFieldIndex::SECOND );
+ bValid = bValid && nDay == nDaySet && nMyMonth == nMonthSet && nYear ==
+ nYearSet && nHour == nHourSet && nMinute == nMinuteSet && nSecond
+ == nSecondSet;
+ }
+ }
+#endif // NF_TEST_CALENDAR
+
+ }
+
+ return res;
+}
+
+
+/**
+ * Analyze first string
+ * All gone => true
+ * else => false
+ */
+bool ImpSvNumberInputScan::ScanStartString( const OUString& rString )
+{
+ sal_Int32 nPos = 0;
+
+ // First of all, eat leading blanks
+ SkipBlanks(rString, nPos);
+
+ // Yes, nMatchedAllStrings should know about the sign position
+ nSign = GetSign(rString, nPos);
+ if ( nSign ) // sign?
+ {
+ SkipBlanks(rString, nPos);
+ }
+ // #102371# match against format string only if start string is not a sign character
+ if ( nMatchedAllStrings && !(nSign && rString.getLength() == 1) )
+ {
+ // Match against format in any case, so later on for a "x1-2-3" input
+ // we may distinguish between a xy-m-d (or similar) date and a x0-0-0
+ // format. No sign detection here!
+ if ( ScanStringNumFor( rString, nPos, 0, true ) )
+ {
+ nMatchedAllStrings |= nMatchedStartString;
+ }
+ else
+ {
+ nMatchedAllStrings = 0;
+ }
+ }
+
+ // Bail out early for just a sign.
+ if (nSign && nPos == rString.getLength())
+ return true;
+
+ const sal_Int32 nStartBlanks = nPos;
+ if ( GetDecSep(rString, nPos) ) // decimal separator in start string
+ {
+ if (SkipBlanks(rString, nPos))
+ nPos = nStartBlanks; // `. 2` not a decimal separator
+ else
+ nDecPos = 1; // leading decimal separator
+ }
+ else if ( GetCurrency(rString, nPos) ) // currency (DM 1)?
+ {
+ eScannedType = SvNumFormatType::CURRENCY; // !!! it IS currency !!!
+ SkipBlanks(rString, nPos);
+ if (nSign == 0) // no sign yet
+ {
+ nSign = GetSign(rString, nPos);
+ if ( nSign ) // DM -1
+ {
+ SkipBlanks(rString, nPos);
+ }
+ }
+ if ( GetDecSep(rString, nPos) ) // decimal separator follows currency
+ {
+ if (SkipBlanks(rString, nPos))
+ {
+ nPos = nStartBlanks; // `DM . 2` not a decimal separator
+ eScannedType = SvNumFormatType::UNDEFINED; // !!! it is NOT currency !!!
+ }
+ else
+ nDecPos = 1; // leading decimal separator
+ }
+ }
+ else
+ {
+ const sal_Int32 nMonthStart = nPos;
+ short nTempMonth = GetMonth(rString, nPos);
+ if (nTempMonth < 0)
+ {
+ // Short month and day names may be identical in some locales, e.g.
+ // "mar" for "martes" or "marzo" in Spanish.
+ // Do not let a month name immediately take precedence if a day
+ // name was meant instead. Assume that both could be valid, until
+ // encountered differently or the final evaluation in
+ // IsNumberFormat() checks, but continue with weighing the month
+ // name higher unless we have both day of week and month name here.
+ sal_Int32 nTempPos = nMonthStart;
+ nDayOfWeek = GetDayOfWeek( rString, nTempPos);
+ if (nDayOfWeek < 0)
+ {
+ SkipChar( '.', rString, nTempPos ); // abbreviated
+ SkipString( pFormatter->GetLocaleData()->getLongDateDayOfWeekSep(), rString, nTempPos );
+ SkipBlanks( rString, nTempPos);
+ short nTempTempMonth = GetMonth( rString, nTempPos);
+ if (nTempTempMonth)
+ {
+ // Fall into the else branch below that handles both.
+ nTempMonth = 0;
+ nPos = nMonthStart;
+ nDayOfWeek = 0;
+ // Do not set nDayOfWeek hereafter, anywhere.
+ }
+ }
+ }
+ if ( nTempMonth ) // month (Jan 1)?
+ {
+ // Jan1 without separator is not a date, unless it is followed by a
+ // separator and a (year) number.
+ if (nPos < rString.getLength() || (nStringsCnt >= 4 && nNumericsCnt >= 2))
+ {
+ eScannedType = SvNumFormatType::DATE; // !!! it IS a date !!!
+ nMonth = nTempMonth;
+ nMonthPos = 1; // month at the beginning
+ if ( nMonth < 0 )
+ {
+ SkipChar( '.', rString, nPos ); // abbreviated
+ }
+ SkipBlanks(rString, nPos);
+ }
+ else
+ {
+ nPos = nMonthStart; // rewind month
+ }
+ }
+ else
+ {
+ int nTempDayOfWeek = GetDayOfWeek( rString, nPos );
+ if ( nTempDayOfWeek )
+ {
+ // day of week is just parsed away
+ eScannedType = SvNumFormatType::DATE; // !!! it IS a date !!!
+ if ( nPos < rString.getLength() )
+ {
+ if ( nTempDayOfWeek < 0 )
+ {
+ // abbreviated
+ if ( rString[ nPos ] == '.' )
+ {
+ ++nPos;
+ }
+ }
+ else
+ {
+ // full long name
+ SkipBlanks(rString, nPos);
+ SkipString( pFormatter->GetLocaleData()->getLongDateDayOfWeekSep(), rString, nPos );
+ }
+ SkipBlanks(rString, nPos);
+ nTempMonth = GetMonth(rString, nPos);
+ if ( nTempMonth ) // month (Jan 1)?
+ {
+ // Jan1 without separator is not a date, unless it is followed by a
+ // separator and a (year) number.
+ if (nPos < rString.getLength() || (nStringsCnt >= 4 && nNumericsCnt >= 2))
+ {
+ nMonth = nTempMonth;
+ nMonthPos = 1; // month at the beginning
+ if ( nMonth < 0 )
+ {
+ SkipChar( '.', rString, nPos ); // abbreviated
+ }
+ SkipBlanks(rString, nPos);
+ }
+ else
+ {
+ nPos = nMonthStart; // rewind month
+ }
+ }
+ }
+ if (!nMonth)
+ {
+ // Determine and remember following date pattern, if any.
+ IsAcceptedDatePattern( 1);
+ }
+ }
+ }
+ // Skip one trailing '-' or '/' character to recognize June-2007
+ if (nMonth && nPos + 1 == rString.getLength())
+ {
+ SkipChar('-', rString, nPos) || SkipChar('/', rString, nPos);
+ }
+ }
+
+ if (nPos < rString.getLength()) // not everything consumed
+ {
+ // Does input StartString equal StartString of format?
+ // This time with sign detection!
+ if ( !ScanStringNumFor( rString, nPos, 0 ) )
+ {
+ return MatchedReturn();
+ }
+ }
+
+ return true;
+}
+
+
+/**
+ * Analyze string in the middle
+ * All gone => true
+ * else => false
+ */
+bool ImpSvNumberInputScan::ScanMidString( const OUString& rString, sal_uInt16 nStringPos )
+{
+ sal_Int32 nPos = 0;
+ SvNumFormatType eOldScannedType = eScannedType;
+
+ if ( nMatchedAllStrings )
+ { // Match against format in any case, so later on for a "1-2-3-4" input
+ // we may distinguish between a y-m-d (or similar) date and a 0-0-0-0
+ // format.
+ if ( ScanStringNumFor( rString, 0, nStringPos ) )
+ {
+ nMatchedAllStrings |= nMatchedMidString;
+ }
+ else
+ {
+ nMatchedAllStrings = 0;
+ }
+ }
+
+ const sal_Int32 nStartBlanks = nPos;
+ const bool bBlanks = SkipBlanks(rString, nPos);
+ if (GetDecSep(rString, nPos)) // decimal separator?
+ {
+ if (nDecPos == 1 || nDecPos == 3) // .12.4 or 1.E2.1
+ {
+ return MatchedReturn();
+ }
+ else if (nDecPos == 2) // . dup: 12.4.
+ {
+ bool bSignedYear = false;
+ if (bDecSepInDateSeps || // . also date separator
+ SkipDatePatternSeparator( nStringPos, nPos, bSignedYear))
+ {
+ if ( eScannedType != SvNumFormatType::UNDEFINED &&
+ eScannedType != SvNumFormatType::DATE &&
+ eScannedType != SvNumFormatType::DATETIME) // already another type
+ {
+ return MatchedReturn();
+ }
+ if (eScannedType == SvNumFormatType::UNDEFINED)
+ {
+ eScannedType = SvNumFormatType::DATE; // !!! it IS a date
+ }
+ SkipBlanks(rString, nPos);
+ }
+ else
+ {
+ return MatchedReturn();
+ }
+ }
+ else if (bBlanks)
+ {
+ // `1 .2` or `1 . 2` not a decimal separator, reset
+ nPos = nStartBlanks;
+ }
+ else if (SkipBlanks(rString, nPos))
+ {
+ // `1. 2` not a decimal separator, reset
+ nPos = nStartBlanks;
+ }
+ else
+ {
+ nDecPos = 2; // . in mid string
+ }
+ }
+ else if ( (eScannedType & SvNumFormatType::TIME) &&
+ GetTime100SecSep( rString, nPos ) )
+ { // hundredth seconds separator
+ if ( nDecPos )
+ {
+ return MatchedReturn();
+ }
+ nDecPos = 2; // . in mid string
+
+ // If this is exactly an ISO 8601 fractional seconds separator, bail
+ // out early to not get confused by later checks for group separator or
+ // other.
+ if (bIso8601Tsep && nPos == rString.getLength() &&
+ eScannedType == SvNumFormatType::DATETIME && (rString == "." || rString == ","))
+ return true;
+
+ SkipBlanks(rString, nPos);
+ }
+
+ if (SkipChar('/', rString, nPos)) // fraction?
+ {
+ if ( eScannedType != SvNumFormatType::UNDEFINED && // already another type
+ eScannedType != SvNumFormatType::DATE) // except date
+ {
+ return MatchedReturn(); // => jan/31/1994
+ }
+ else if (eScannedType != SvNumFormatType::DATE && // analyzed no date until now
+ (eSetType == SvNumFormatType::FRACTION || // and preset was fraction
+ (nNumericsCnt == 3 && // or 3 numbers
+ (nStringPos == 3 || // and 4th string particle
+ (nStringPos == 4 && nSign)) && // or 5th if signed
+ sStrArray[nStringPos-2].indexOf('/') == -1))) // and not 23/11/1999
+ // that was not accepted as date yet
+ {
+ SkipBlanks(rString, nPos);
+ if (nPos == rString.getLength())
+ {
+ eScannedType = SvNumFormatType::FRACTION; // !!! it IS a fraction (so far)
+ if (eSetType == SvNumFormatType::FRACTION &&
+ nNumericsCnt == 2 &&
+ (nStringPos == 1 || // for 4/5
+ (nStringPos == 2 && nSign))) // or signed -4/5
+ {
+ return true; // don't fall into date trap
+ }
+ }
+ }
+ else
+ {
+ nPos--; // put '/' back
+ }
+ }
+
+ if (GetThousandSep(rString, nPos, nStringPos)) // 1,000
+ {
+ if ( eScannedType != SvNumFormatType::UNDEFINED && // already another type
+ eScannedType != SvNumFormatType::CURRENCY) // except currency
+ {
+ return MatchedReturn();
+ }
+ nThousand++;
+ }
+
+ const LocaleDataWrapper* pLoc = pFormatter->GetLocaleData();
+ bool bSignedYear = false;
+ bool bDate = SkipDatePatternSeparator( nStringPos, nPos, bSignedYear); // 12/31 31.12. 12/31/1999 31.12.1999
+ if (!bDate)
+ {
+ const OUString& rDate = pFormatter->GetDateSep();
+ SkipBlanks(rString, nPos);
+ bDate = SkipString( rDate, rString, nPos); // 10. 10- 10/
+ }
+ if (!bDate && nStringPos == 1 && mpFormat && (mpFormat->GetType() & SvNumFormatType::DATE))
+ {
+ // If a DMY format was given and a mid string starts with a literal
+ // ". " dot+space and could contain a following month name and ends
+ // with a space or LongDateMonthSeparator, like it's scanned in
+ // `14". AUG "18`, then it may be a date as well. Regardless whether
+ // defined such by the locale or not.
+ // This *could* check for presence of ". "MMM or ". "MMMM in the actual
+ // format code for further restriction to match only if present, but..
+
+ const sal_uInt32 nExactDateOrder = mpFormat->GetExactDateOrder();
+ // Exactly DMY.
+ if (((nExactDateOrder & 0xff) == 'Y') && (((nExactDateOrder >> 8) & 0xff) == 'M')
+ && (((nExactDateOrder >> 16) & 0xff) == 'D'))
+ {
+ const sal_Int32 nTmpPos = nPos;
+ if (SkipChar('.', rString, nPos) && SkipBlanks(rString, nPos) && nPos + 2 < rString.getLength()
+ && (rString.endsWith(" ") || rString.endsWith( pLoc->getLongDateMonthSep())))
+ bDate = true;
+ else
+ nPos = nTmpPos;
+ }
+ }
+ if (bDate || ((MayBeIso8601() || MayBeMonthDate()) && // 1999-12-31 31-Dec-1999
+ SkipChar( '-', rString, nPos)))
+ {
+ if ( eScannedType != SvNumFormatType::UNDEFINED && // already another type
+ eScannedType != SvNumFormatType::DATE) // except date
+ {
+ return MatchedReturn();
+ }
+ SkipBlanks(rString, nPos);
+ eScannedType = SvNumFormatType::DATE; // !!! it IS a date
+ short nTmpMonth = GetMonth(rString, nPos); // 10. Jan 94
+ if (nMonth && nTmpMonth) // month dup
+ {
+ return MatchedReturn();
+ }
+ if (nTmpMonth)
+ {
+ nMonth = nTmpMonth;
+ nMonthPos = 2; // month in the middle
+ if ( nMonth < 0 && SkipChar( '.', rString, nPos ) )
+ ; // short month may be abbreviated Jan.
+ else if ( SkipChar( '-', rString, nPos ) )
+ ; // #79632# recognize 17-Jan-2001 to be a date
+ // #99065# short and long month name
+ else
+ {
+ SkipString( pLoc->getLongDateMonthSep(), rString, nPos );
+ }
+ SkipBlanks(rString, nPos);
+ }
+ if (bSignedYear)
+ {
+ if (mbEraCE != kDefaultEra) // signed year twice?
+ return MatchedReturn();
+
+ mbEraCE = false; // BCE
+ }
+ }
+
+ const sal_Int32 nMonthStart = nPos;
+ short nTempMonth = GetMonth(rString, nPos); // month in the middle (10 Jan 94)
+ if (nTempMonth)
+ {
+ if (nMonth != 0) // month dup
+ {
+ return MatchedReturn();
+ }
+ if ( eScannedType != SvNumFormatType::UNDEFINED && // already another type
+ eScannedType != SvNumFormatType::DATE) // except date
+ {
+ return MatchedReturn();
+ }
+ if (nMonthStart > 0 && nPos < rString.getLength()) // 10Jan or Jan94 without separator are not dates
+ {
+ eScannedType = SvNumFormatType::DATE; // !!! it IS a date
+ nMonth = nTempMonth;
+ nMonthPos = 2; // month in the middle
+ if ( nMonth < 0 )
+ {
+ SkipChar( '.', rString, nPos ); // abbreviated
+ }
+ SkipString( pLoc->getLongDateMonthSep(), rString, nPos );
+ SkipBlanks(rString, nPos);
+ }
+ else
+ {
+ nPos = nMonthStart; // rewind month
+ }
+ }
+
+ if ( SkipChar('E', rString, nPos) || // 10E, 10e, 10,Ee
+ SkipChar('e', rString, nPos) )
+ {
+ if (eScannedType != SvNumFormatType::UNDEFINED) // already another type
+ {
+ return MatchedReturn();
+ }
+ else
+ {
+ SkipBlanks(rString, nPos);
+ eScannedType = SvNumFormatType::SCIENTIFIC; // !!! it IS scientific
+ if ( nThousand+2 == nNumericsCnt && nDecPos == 2 ) // special case 1.E2
+ {
+ nDecPos = 3; // 1,100.E2 1,100,100.E3
+ }
+ }
+ nESign = GetESign(rString, nPos); // signed exponent?
+ SkipBlanks(rString, nPos);
+ }
+
+ const OUString& rTime = pLoc->getTimeSep();
+ if ( SkipString(rTime, rString, nPos) ) // time separator?
+ {
+ if (nDecPos) // already . => maybe error
+ {
+ if (bDecSepInDateSeps) // . also date sep
+ {
+ if ( eScannedType != SvNumFormatType::DATE && // already another type than date
+ eScannedType != SvNumFormatType::DATETIME) // or date time
+ {
+ return MatchedReturn();
+ }
+ if (eScannedType == SvNumFormatType::DATE)
+ {
+ nDecPos = 0; // reset for time transition
+ }
+ }
+ else
+ {
+ return MatchedReturn();
+ }
+ }
+ if ((eScannedType == SvNumFormatType::DATE || // already date type
+ eScannedType == SvNumFormatType::DATETIME) && // or date time
+ nNumericsCnt > 3) // and more than 3 numbers? (31.Dez.94 8:23)
+ {
+ SkipBlanks(rString, nPos);
+ eScannedType = SvNumFormatType::DATETIME; // !!! it IS date with time
+ }
+ else if ( eScannedType != SvNumFormatType::UNDEFINED && // already another type
+ eScannedType != SvNumFormatType::TIME) // except time
+ {
+ return MatchedReturn();
+ }
+ else
+ {
+ SkipBlanks(rString, nPos);
+ eScannedType = SvNumFormatType::TIME; // !!! it IS a time
+ }
+ if ( !nTimePos )
+ {
+ nTimePos = nStringPos + 1;
+ }
+ }
+
+ if (nPos < rString.getLength())
+ {
+ switch (eScannedType)
+ {
+ case SvNumFormatType::DATE:
+ if (nMonthPos == 1 && pLoc->getLongDateOrder() == LongDateOrder::MDY)
+ {
+ // #68232# recognize long date separators like ", " in "September 5, 1999"
+ if (SkipString( pLoc->getLongDateDaySep(), rString, nPos ))
+ {
+ SkipBlanks( rString, nPos );
+ }
+ }
+ else if (nPos == 0 && rString.getLength() == 1 && MayBeIso8601())
+ {
+ if ( (nStringPos == 5 && rString[0] == 'T') ||
+ (nStringPos == 6 && rString[0] == 'T' && sStrArray[0] == "-"))
+ {
+ // ISO 8601 combined date and time, yyyy-mm-ddThh:mm or -yyyy-mm-ddThh:mm
+ ++nPos;
+ bIso8601Tsep = true;
+ }
+ else if (nStringPos == 7 && rString[0] == ':')
+ {
+ // ISO 8601 combined date and time, the time part; we reach
+ // here if the locale's separator is not ':' so it couldn't
+ // be detected above in the time block.
+ if (nNumericsCnt >= 5)
+ eScannedType = SvNumFormatType::DATETIME;
+ ++nPos;
+ }
+ }
+ break;
+ case SvNumFormatType::DATETIME:
+ if (nPos == 0 && rString.getLength() == 1 && MayBeIso8601())
+ {
+ if (nStringPos == 9 && rString[0] == ':')
+ {
+ // ISO 8601 combined date and time, the time part continued.
+ ++nPos;
+ }
+ }
+#if NF_RECOGNIZE_ISO8601_TIMEZONES
+ else if (nPos == 0 && rString.getLength() == 1 && nStringPos >= 9 && MayBeIso8601())
+ {
+ // ISO 8601 timezone offset
+ switch (rString[ 0 ])
+ {
+ case '+':
+ case '-':
+ if (nStringPos == nStringsCnt - 2 ||
+ nStringPos == nStringsCnt - 4)
+ {
+ ++nPos; // yyyy-mm-ddThh:mm[:ss]+xx[[:]yy]
+ // nTimezonePos needed for GetTimeRef()
+ if (!nTimezonePos)
+ {
+ nTimezonePos = nStringPos + 1;
+ }
+ }
+ break;
+ case ':':
+ if (nTimezonePos && nStringPos >= 11 &&
+ nStringPos == nStringsCnt - 2)
+ {
+ ++nPos; // yyyy-mm-ddThh:mm[:ss]+xx:yy
+ }
+ break;
+ }
+ }
+#endif
+ break;
+ default: break;
+ }
+ }
+
+ if (nPos < rString.getLength()) // not everything consumed?
+ {
+ if ( nMatchedAllStrings & ~nMatchedVirgin )
+ {
+ eScannedType = eOldScannedType;
+ }
+ else
+ {
+ return false;
+ }
+ }
+
+ return true;
+}
+
+
+/**
+ * Analyze the end
+ * All gone => true
+ * else => false
+ */
+bool ImpSvNumberInputScan::ScanEndString( const OUString& rString )
+{
+ sal_Int32 nPos = 0;
+
+ if ( nMatchedAllStrings )
+ { // Match against format in any case, so later on for a "1-2-3-4" input
+ // we may distinguish between a y-m-d (or similar) date and a 0-0-0-0
+ // format.
+ if ( ScanStringNumFor( rString, 0, 0xFFFF ) )
+ {
+ nMatchedAllStrings |= nMatchedEndString;
+ }
+ else
+ {
+ nMatchedAllStrings = 0;
+ }
+ }
+
+ const sal_Int32 nStartBlanks = nPos;
+ const bool bBlanks = SkipBlanks(rString, nPos);
+ if (GetDecSep(rString, nPos)) // decimal separator?
+ {
+ if (nDecPos == 1 || nDecPos == 3) // .12.4 or 12.E4.
+ {
+ return MatchedReturn();
+ }
+ else if (nDecPos == 2) // . dup: 12.4.
+ {
+ bool bSignedYear = false;
+ if (bDecSepInDateSeps || // . also date separator
+ SkipDatePatternSeparator( nStringsCnt-1, nPos, bSignedYear))
+ {
+ if ( eScannedType != SvNumFormatType::UNDEFINED &&
+ eScannedType != SvNumFormatType::DATE &&
+ eScannedType != SvNumFormatType::DATETIME) // already another type
+ {
+ return MatchedReturn();
+ }
+ if (eScannedType == SvNumFormatType::UNDEFINED)
+ {
+ eScannedType = SvNumFormatType::DATE; // !!! it IS a date
+ }
+ SkipBlanks(rString, nPos);
+ }
+ else
+ {
+ return MatchedReturn();
+ }
+ }
+ else if (bBlanks)
+ {
+ // not a decimal separator, reset
+ nPos = nStartBlanks;
+ }
+ else
+ {
+ nDecPos = 3; // . in end string
+ SkipBlanks(rString, nPos);
+ }
+ }
+
+ bool bSignDetectedHere = false;
+ if ( nSign == 0 && // conflict - not signed
+ eScannedType != SvNumFormatType::DATE) // and not date
+ //!? catch time too?
+ { // not signed yet
+ nSign = GetSign(rString, nPos); // 1- DM
+ if (bNegCheck) // '(' as sign
+ {
+ return MatchedReturn();
+ }
+ if (nSign)
+ {
+ bSignDetectedHere = true;
+ }
+ }
+
+ SkipBlanks(rString, nPos);
+ if (bNegCheck && SkipChar(')', rString, nPos)) // skip ')' if appropriate
+ {
+ bNegCheck = false;
+ SkipBlanks(rString, nPos);
+ }
+
+ if ( GetCurrency(rString, nPos) ) // currency symbol?
+ {
+ if (eScannedType != SvNumFormatType::UNDEFINED) // currency dup
+ {
+ return MatchedReturn();
+ }
+ else
+ {
+ SkipBlanks(rString, nPos);
+ eScannedType = SvNumFormatType::CURRENCY;
+ } // behind currency a '-' is allowed
+ if (nSign == 0) // not signed yet
+ {
+ nSign = GetSign(rString, nPos); // DM -
+ SkipBlanks(rString, nPos);
+ if (bNegCheck) // 3 DM (
+ {
+ return MatchedReturn();
+ }
+ }
+ if ( bNegCheck && eScannedType == SvNumFormatType::CURRENCY &&
+ SkipChar(')', rString, nPos) )
+ {
+ bNegCheck = false; // ')' skipped
+ SkipBlanks(rString, nPos); // only if currency
+ }
+ }
+
+ if ( SkipChar('%', rString, nPos) ) // 1%
+ {
+ if (eScannedType != SvNumFormatType::UNDEFINED) // already another type
+ {
+ return MatchedReturn();
+ }
+ SkipBlanks(rString, nPos);
+ eScannedType = SvNumFormatType::PERCENT;
+ }
+
+ const LocaleDataWrapper* pLoc = pFormatter->GetLocaleData();
+ const OUString& rTime = pLoc->getTimeSep();
+ if ( SkipString(rTime, rString, nPos) ) // 10:
+ {
+ if (nDecPos) // already , => error
+ {
+ return MatchedReturn();
+ }
+ if (eScannedType == SvNumFormatType::DATE && nNumericsCnt > 2) // 31.Dez.94 8:
+ {
+ SkipBlanks(rString, nPos);
+ eScannedType = SvNumFormatType::DATETIME;
+ }
+ else if (eScannedType != SvNumFormatType::UNDEFINED &&
+ eScannedType != SvNumFormatType::TIME) // already another type
+ {
+ return MatchedReturn();
+ }
+ else
+ {
+ SkipBlanks(rString, nPos);
+ eScannedType = SvNumFormatType::TIME;
+ }
+ if ( !nTimePos )
+ {
+ nTimePos = nStringsCnt;
+ }
+ }
+
+ bool bSignedYear = false;
+ bool bDate = SkipDatePatternSeparator( nStringsCnt-1, nPos, bSignedYear); // 12/31 31.12. 12/31/1999 31.12.1999
+ if (!bDate)
+ {
+ const OUString& rDate = pFormatter->GetDateSep();
+ bDate = SkipString( rDate, rString, nPos); // 10. 10- 10/
+ }
+ if (bDate && bSignDetectedHere)
+ {
+ nSign = 0; // 'D-' takes precedence over signed date
+ }
+ if (bDate || ((MayBeIso8601() || MayBeMonthDate())
+ && SkipChar( '-', rString, nPos)))
+ {
+ if (eScannedType != SvNumFormatType::UNDEFINED &&
+ eScannedType != SvNumFormatType::DATE) // already another type
+ {
+ return MatchedReturn();
+ }
+ else
+ {
+ SkipBlanks(rString, nPos);
+ eScannedType = SvNumFormatType::DATE;
+ }
+ short nTmpMonth = GetMonth(rString, nPos); // 10. Jan
+ if (nMonth && nTmpMonth) // month dup
+ {
+ return MatchedReturn();
+ }
+ if (nTmpMonth)
+ {
+ nMonth = nTmpMonth;
+ nMonthPos = 3; // month at end
+ if ( nMonth < 0 )
+ {
+ SkipChar( '.', rString, nPos ); // abbreviated
+ }
+ SkipBlanks(rString, nPos);
+ }
+ }
+
+ const sal_Int32 nMonthStart = nPos;
+ short nTempMonth = GetMonth(rString, nPos); // 10 Jan
+ if (nTempMonth)
+ {
+ if (nMonth) // month dup
+ {
+ return MatchedReturn();
+ }
+ if (eScannedType != SvNumFormatType::UNDEFINED &&
+ eScannedType != SvNumFormatType::DATE) // already another type
+ {
+ return MatchedReturn();
+ }
+ if (nMonthStart > 0) // 10Jan without separator is not a date
+ {
+ eScannedType = SvNumFormatType::DATE;
+ nMonth = nTempMonth;
+ nMonthPos = 3; // month at end
+ if ( nMonth < 0 )
+ {
+ SkipChar( '.', rString, nPos ); // abbreviated
+ }
+ SkipBlanks(rString, nPos);
+ }
+ else
+ {
+ nPos = nMonthStart; // rewind month
+ }
+ }
+
+ sal_Int32 nOrigPos = nPos;
+ if (GetTimeAmPm(rString, nPos))
+ {
+ if (eScannedType != SvNumFormatType::UNDEFINED &&
+ eScannedType != SvNumFormatType::TIME &&
+ eScannedType != SvNumFormatType::DATETIME) // already another type
+ {
+ return MatchedReturn();
+ }
+ else
+ {
+ // If not already scanned as time, 6.78am does not result in 6
+ // seconds and 78 hundredths in the morning. Keep as suffix.
+ if (eScannedType != SvNumFormatType::TIME && nDecPos == 2 && nNumericsCnt == 2)
+ {
+ nPos = nOrigPos; // rewind am/pm
+ }
+ else
+ {
+ SkipBlanks(rString, nPos);
+ if ( eScannedType != SvNumFormatType::DATETIME )
+ {
+ eScannedType = SvNumFormatType::TIME;
+ }
+ }
+ }
+ }
+
+ if ( bNegCheck && SkipChar(')', rString, nPos) )
+ {
+ if (eScannedType == SvNumFormatType::CURRENCY) // only if currency
+ {
+ bNegCheck = false; // skip ')'
+ SkipBlanks(rString, nPos);
+ }
+ else
+ {
+ return MatchedReturn();
+ }
+ }
+
+ if ( nPos < rString.getLength() &&
+ (eScannedType == SvNumFormatType::DATE ||
+ eScannedType == SvNumFormatType::DATETIME) )
+ {
+ // day of week is just parsed away
+ sal_Int32 nOldPos = nPos;
+ const OUString& rSep = pFormatter->GetLocaleData()->getLongDateDayOfWeekSep();
+ if ( StringContains( rSep, rString, nPos ) )
+ {
+ nPos = nPos + rSep.getLength();
+ SkipBlanks(rString, nPos);
+ }
+ int nTempDayOfWeek = GetDayOfWeek( rString, nPos );
+ if ( nTempDayOfWeek )
+ {
+ if ( nPos < rString.getLength() )
+ {
+ if ( nTempDayOfWeek < 0 )
+ { // short
+ if ( rString[ nPos ] == '.' )
+ {
+ ++nPos;
+ }
+ }
+ SkipBlanks(rString, nPos);
+ }
+ }
+ else
+ {
+ nPos = nOldPos;
+ }
+ }
+
+#if NF_RECOGNIZE_ISO8601_TIMEZONES
+ if (nPos == 0 && eScannedType == SvNumFormatType::DATETIME &&
+ rString.getLength() == 1 && rString[ 0 ] == 'Z' && MayBeIso8601())
+ {
+ // ISO 8601 timezone UTC yyyy-mm-ddThh:mmZ
+ ++nPos;
+ }
+#endif
+
+ if (nPos < rString.getLength()) // everything consumed?
+ {
+ // does input EndString equal EndString in Format?
+ if ( !ScanStringNumFor( rString, nPos, 0xFFFF ) )
+ {
+ return false;
+ }
+ }
+
+ return true;
+}
+
+
+bool ImpSvNumberInputScan::ScanStringNumFor( const OUString& rString, // String to scan
+ sal_Int32 nPos, // Position until which was consumed
+ sal_uInt16 nString, // Substring of format, 0xFFFF => last
+ bool bDontDetectNegation) // Suppress sign detection
+{
+ if ( !mpFormat )
+ {
+ return false;
+ }
+ const ::utl::TransliterationWrapper* pTransliteration = pFormatter->GetTransliteration();
+ const OUString* pStr;
+ OUString aString( rString );
+ bool bFound = false;
+ bool bFirst = true;
+ bool bContinue = true;
+ sal_uInt16 nSub;
+ do
+ {
+ // Don't try "lower" subformats ff the very first match was the second
+ // or third subformat.
+ nSub = nStringScanNumFor;
+ do
+ { // Step through subformats, first positive, then negative, then
+ // other, but not the last (text) subformat.
+ pStr = mpFormat->GetNumForString( nSub, nString, true );
+ if ( pStr && pTransliteration->isEqual( aString, *pStr ) )
+ {
+ bFound = true;
+ bContinue = false;
+ }
+ else if ( nSub < 2 )
+ {
+ ++nSub;
+ }
+ else
+ {
+ bContinue = false;
+ }
+ }
+ while ( bContinue );
+ if ( !bFound && bFirst && nPos )
+ {
+ // try remaining substring
+ bFirst = false;
+ aString = aString.copy(nPos);
+ bContinue = true;
+ }
+ }
+ while ( bContinue );
+
+ if ( !bFound )
+ {
+ if ( !bDontDetectNegation && (nString == 0) &&
+ !bFirst && (nSign < 0) && mpFormat->IsSecondSubformatRealNegative() )
+ {
+ // simply negated twice? --1
+ aString = aString.replaceAll(" ", "");
+ if ( (aString.getLength() == 1) && (aString[0] == '-') )
+ {
+ bFound = true;
+ nStringScanSign = -1;
+ nSub = 0; //! not 1
+ }
+ }
+ if ( !bFound )
+ {
+ return false;
+ }
+ }
+ else if ( !bDontDetectNegation && (nSub == 1) &&
+ mpFormat->IsSecondSubformatRealNegative() )
+ {
+ // negative
+ if ( nStringScanSign < 0 )
+ {
+ if ( (nSign < 0) && (nStringScanNumFor != 1) )
+ {
+ nStringScanSign = 1; // triple negated --1 yyy
+ }
+ }
+ else if ( nStringScanSign == 0 )
+ {
+ if ( nSign < 0 )
+ { // nSign and nStringScanSign will be combined later,
+ // flip sign if doubly negated
+ if ( (nString == 0) && !bFirst &&
+ SvNumberformat::HasStringNegativeSign( aString ) )
+ {
+ nStringScanSign = -1; // direct double negation
+ }
+ else if ( mpFormat->IsNegativeWithoutSign() )
+ {
+ nStringScanSign = -1; // indirect double negation
+ }
+ }
+ else
+ {
+ nStringScanSign = -1;
+ }
+ }
+ else // > 0
+ {
+ nStringScanSign = -1;
+ }
+ }
+ nStringScanNumFor = nSub;
+ return true;
+}
+
+
+/**
+ * Recognizes types of number, exponential, fraction, percent, currency, date, time.
+ * Else text => return false
+ */
+bool ImpSvNumberInputScan::IsNumberFormatMain( const OUString& rString, // string to be analyzed
+ const SvNumberformat* pFormat ) // maybe number format set to match against
+{
+ Reset();
+ mpFormat = pFormat;
+ NumberStringDivision( rString ); // breakdown into strings and numbers
+ if (nStringsCnt >= SV_MAX_COUNT_INPUT_STRINGS) // too many elements
+ {
+ return false; // Njet, Nope, ...
+ }
+ if (nNumericsCnt == 0) // no number in input
+ {
+ if ( nStringsCnt > 0 )
+ {
+ // Here we may change the original, we don't need it anymore.
+ // This saves copies and ToUpper() in GetLogical() and is faster.
+ sStrArray[0] = comphelper::string::strip(sStrArray[0], ' ');
+ OUString& rStrArray = sStrArray[0];
+ nLogical = GetLogical( rStrArray );
+ if ( nLogical )
+ {
+ eScannedType = SvNumFormatType::LOGICAL; // !!! it's a BOOLEAN
+ nMatchedAllStrings &= ~nMatchedVirgin;
+ return true;
+ }
+ else
+ {
+ return false; // simple text
+ }
+ }
+ else
+ {
+ return false; // simple text
+ }
+ }
+
+ sal_uInt16 i = 0; // mark any symbol
+ sal_uInt16 j = 0; // mark only numbers
+
+ switch ( nNumericsCnt )
+ {
+ case 1 : // Exactly 1 number in input
+ // nStringsCnt >= 1
+ if (GetNextNumber(i,j)) // i=1,0
+ { // Number at start
+ if (eSetType == SvNumFormatType::FRACTION) // Fraction 1 = 1/1
+ {
+ if (i >= nStringsCnt || // no end string nor decimal separator
+ pFormatter->IsDecimalSep( sStrArray[i]))
+ {
+ eScannedType = SvNumFormatType::FRACTION;
+ nMatchedAllStrings &= ~nMatchedVirgin;
+ return true;
+ }
+ }
+ }
+ else
+ { // Analyze start string
+ if (!ScanStartString( sStrArray[i] )) // i=0
+ {
+ return false; // already an error
+ }
+ i++; // next symbol, i=1
+ }
+ GetNextNumber(i,j); // i=1,2
+ if (eSetType == SvNumFormatType::FRACTION) // Fraction -1 = -1/1
+ {
+ if (nSign && !bNegCheck && // Sign +, -
+ eScannedType == SvNumFormatType::UNDEFINED && // not date or currency
+ nDecPos == 0 && // no previous decimal separator
+ (i >= nStringsCnt || // no end string nor decimal separator
+ pFormatter->IsDecimalSep( sStrArray[i]))
+ )
+ {
+ eScannedType = SvNumFormatType::FRACTION;
+ nMatchedAllStrings &= ~nMatchedVirgin;
+ return true;
+ }
+ }
+ if (i < nStringsCnt && !ScanEndString( sStrArray[i] ))
+ {
+ return false;
+ }
+ break;
+ case 2 : // Exactly 2 numbers in input
+ // nStringsCnt >= 3
+ if (!GetNextNumber(i,j)) // i=1,0
+ { // Analyze start string
+ if (!ScanStartString( sStrArray[i] ))
+ return false; // already an error
+ i++; // i=1
+ }
+ GetNextNumber(i,j); // i=1,2
+ if ( !ScanMidString( sStrArray[i], i ) )
+ {
+ return false;
+ }
+ i++; // next symbol, i=2,3
+ GetNextNumber(i,j); // i=3,4
+ if (i < nStringsCnt && !ScanEndString( sStrArray[i] ))
+ {
+ return false;
+ }
+ if (eSetType == SvNumFormatType::FRACTION) // -1,200. as fraction
+ {
+ if (!bNegCheck && // no sign '('
+ eScannedType == SvNumFormatType::UNDEFINED &&
+ (nDecPos == 0 || nDecPos == 3) // no decimal separator or at end
+ )
+ {
+ eScannedType = SvNumFormatType::FRACTION;
+ nMatchedAllStrings &= ~nMatchedVirgin;
+ return true;
+ }
+ }
+ break;
+ case 3 : // Exactly 3 numbers in input
+ // nStringsCnt >= 5
+ if (!GetNextNumber(i,j)) // i=1,0
+ { // Analyze start string
+ if (!ScanStartString( sStrArray[i] ))
+ {
+ return false; // already an error
+ }
+ i++; // i=1
+ if (nDecPos == 1) // decimal separator at start => error
+ {
+ return false;
+ }
+ }
+ GetNextNumber(i,j); // i=1,2
+ if ( !ScanMidString( sStrArray[i], i ) )
+ {
+ return false;
+ }
+ i++; // i=2,3
+ if (eScannedType == SvNumFormatType::SCIENTIFIC) // E only at end
+ {
+ return false;
+ }
+ GetNextNumber(i,j); // i=3,4
+ if ( !ScanMidString( sStrArray[i], i ) )
+ {
+ return false;
+ }
+ i++; // i=4,5
+ GetNextNumber(i,j); // i=5,6
+ if (i < nStringsCnt && !ScanEndString( sStrArray[i] ))
+ {
+ return false;
+ }
+ if (eSetType == SvNumFormatType::FRACTION) // -1,200,100. as fraction
+ {
+ if (!bNegCheck && // no sign '('
+ eScannedType == SvNumFormatType::UNDEFINED &&
+ (nDecPos == 0 || nDecPos == 3) // no decimal separator or at end
+ )
+ {
+ eScannedType = SvNumFormatType::FRACTION;
+ nMatchedAllStrings &= ~nMatchedVirgin;
+ return true;
+ }
+ }
+ if ( eScannedType == SvNumFormatType::FRACTION && nDecPos )
+ {
+ return false; // #36857# not a real fraction
+ }
+ break;
+ default: // More than 3 numbers in input
+ // nStringsCnt >= 7
+ if (!GetNextNumber(i,j)) // i=1,0
+ { // Analyze startstring
+ if (!ScanStartString( sStrArray[i] ))
+ return false; // already an error
+ i++; // i=1
+ if (nDecPos == 1) // decimal separator at start => error
+ return false;
+ }
+ GetNextNumber(i,j); // i=1,2
+ if ( !ScanMidString( sStrArray[i], i ) )
+ {
+ return false;
+ }
+ i++; // i=2,3
+ {
+ sal_uInt16 nThOld = 10; // just not 0 or 1
+ while (nThOld != nThousand && j < nNumericsCnt-1) // Execute at least one time
+ // but leave one number.
+ { // Loop over group separators
+ nThOld = nThousand;
+ if (eScannedType == SvNumFormatType::SCIENTIFIC) // E only at end
+ {
+ return false;
+ }
+ GetNextNumber(i,j);
+ if ( i < nStringsCnt && !ScanMidString( sStrArray[i], i ) )
+ {
+ return false;
+ }
+ i++;
+ }
+ }
+ if (eScannedType == SvNumFormatType::DATE || // long date or
+ eScannedType == SvNumFormatType::TIME || // long time or
+ eScannedType == SvNumFormatType::UNDEFINED) // long number
+ {
+ for (sal_uInt16 k = j; k < nNumericsCnt-1; k++)
+ {
+ if (eScannedType == SvNumFormatType::SCIENTIFIC) // E only at endd
+ {
+ return false;
+ }
+ GetNextNumber(i,j);
+ if ( i < nStringsCnt && !ScanMidString( sStrArray[i], i ) )
+ {
+ return false;
+ }
+ i++;
+ }
+ }
+ GetNextNumber(i,j);
+ if (i < nStringsCnt && !ScanEndString( sStrArray[i] ))
+ {
+ return false;
+ }
+ if (eSetType == SvNumFormatType::FRACTION) // -1,200,100. as fraction
+ {
+ if (!bNegCheck && // no sign '('
+ eScannedType == SvNumFormatType::UNDEFINED &&
+ (nDecPos == 0 || nDecPos == 3) // no decimal separator or at end
+ )
+ {
+ eScannedType = SvNumFormatType::FRACTION;
+ nMatchedAllStrings &= ~nMatchedVirgin;
+ return true;
+ }
+ }
+ if ( eScannedType == SvNumFormatType::FRACTION && nDecPos )
+ {
+ return false; // #36857# not a real fraction
+ }
+ break;
+ }
+
+ if (eScannedType == SvNumFormatType::UNDEFINED)
+ {
+ nMatchedAllStrings &= ~nMatchedVirgin;
+ // did match including nMatchedUsedAsReturn
+ bool bDidMatch = (nMatchedAllStrings != 0);
+ if ( nMatchedAllStrings )
+ {
+ bool bMatch = mpFormat && mpFormat->IsNumForStringElementCountEqual(
+ nStringScanNumFor, nStringsCnt, nNumericsCnt );
+ if ( !bMatch )
+ {
+ nMatchedAllStrings = 0;
+ }
+ }
+ if ( nMatchedAllStrings )
+ {
+ // A type DEFINED means that no category could be assigned to the
+ // overall format because of mixed type subformats. Use the scan
+ // matched subformat's type if any.
+ SvNumFormatType eForType = eSetType;
+ if ((eForType == SvNumFormatType::UNDEFINED || eForType == SvNumFormatType::DEFINED) && mpFormat)
+ eForType = mpFormat->GetNumForInfoScannedType( nStringScanNumFor);
+ if (eForType != SvNumFormatType::UNDEFINED && eForType != SvNumFormatType::DEFINED)
+ eScannedType = eForType;
+ else
+ eScannedType = SvNumFormatType::NUMBER;
+ }
+ else if ( bDidMatch )
+ {
+ // Accept a plain fractional number like 123.45 as there may be a
+ // decimal separator also present as literal like in a 0"."0 weirdo
+ // format.
+ if (nDecPos != 2 || nNumericsCnt != 2)
+ return false;
+ eScannedType = SvNumFormatType::NUMBER;
+ }
+ else
+ {
+ eScannedType = SvNumFormatType::NUMBER;
+ // everything else should have been recognized by now
+ }
+ }
+ else if ( eScannedType == SvNumFormatType::DATE )
+ {
+ // the very relaxed date input checks may interfere with a preset format
+ nMatchedAllStrings &= ~nMatchedVirgin;
+ bool bWasReturn = ((nMatchedAllStrings & nMatchedUsedAsReturn) != 0);
+ if ( nMatchedAllStrings )
+ {
+ bool bMatch = mpFormat && mpFormat->IsNumForStringElementCountEqual(
+ nStringScanNumFor, nStringsCnt, nNumericsCnt );
+ if ( !bMatch )
+ {
+ nMatchedAllStrings = 0;
+ }
+ }
+ if ( nMatchedAllStrings )
+ {
+ // A type DEFINED means that no category could be assigned to the
+ // overall format because of mixed type subformats. Do not override
+ // the scanned type in this case. Otherwise in IsNumberFormat() the
+ // first numeric particle would be accepted as number.
+ SvNumFormatType eForType = eSetType;
+ if ((eForType == SvNumFormatType::UNDEFINED || eForType == SvNumFormatType::DEFINED) && mpFormat)
+ eForType = mpFormat->GetNumForInfoScannedType( nStringScanNumFor);
+ if (eForType != SvNumFormatType::UNDEFINED && eForType != SvNumFormatType::DEFINED)
+ eScannedType = eForType;
+ }
+ else if ( bWasReturn )
+ {
+ return false;
+ }
+ }
+ else
+ {
+ nMatchedAllStrings = 0; // reset flag to no substrings matched
+ }
+ return true;
+}
+
+
+/**
+ * Return true or false depending on the nMatched... state and remember usage
+ */
+bool ImpSvNumberInputScan::MatchedReturn()
+{
+ if ( nMatchedAllStrings & ~nMatchedVirgin )
+ {
+ nMatchedAllStrings |= nMatchedUsedAsReturn;
+ return true;
+ }
+ return false;
+}
+
+
+/**
+ * Initialize uppercase months and weekdays
+ */
+void ImpSvNumberInputScan::InitText()
+{
+ sal_Int32 j, nElems;
+ const CharClass* pChrCls = pFormatter->GetCharClass();
+ const CalendarWrapper* pCal = pFormatter->GetCalendar();
+
+ pUpperMonthText.reset();
+ pUpperAbbrevMonthText.reset();
+ css::uno::Sequence< css::i18n::CalendarItem2 > xElems = pCal->getMonths();
+ nElems = xElems.getLength();
+ pUpperMonthText.reset( new OUString[nElems] );
+ pUpperAbbrevMonthText.reset( new OUString[nElems] );
+ for ( j = 0; j < nElems; j++ )
+ {
+ pUpperMonthText[j] = pChrCls->uppercase( xElems[j].FullName );
+ pUpperAbbrevMonthText[j] = pChrCls->uppercase( xElems[j].AbbrevName );
+ }
+
+ pUpperGenitiveMonthText.reset();
+ pUpperGenitiveAbbrevMonthText.reset();
+ xElems = pCal->getGenitiveMonths();
+ bScanGenitiveMonths = (nElems != xElems.getLength());
+ nElems = xElems.getLength();
+ pUpperGenitiveMonthText.reset( new OUString[nElems] );
+ pUpperGenitiveAbbrevMonthText.reset( new OUString[nElems] );
+ for ( j = 0; j < nElems; j++ )
+ {
+ pUpperGenitiveMonthText[j] = pChrCls->uppercase( xElems[j].FullName );
+ pUpperGenitiveAbbrevMonthText[j] = pChrCls->uppercase( xElems[j].AbbrevName );
+ if (!bScanGenitiveMonths &&
+ (pUpperGenitiveMonthText[j] != pUpperMonthText[j] ||
+ pUpperGenitiveAbbrevMonthText[j] != pUpperAbbrevMonthText[j]))
+ {
+ bScanGenitiveMonths = true;
+ }
+ }
+
+ pUpperPartitiveMonthText.reset();
+ pUpperPartitiveAbbrevMonthText.reset();
+ xElems = pCal->getPartitiveMonths();
+ bScanPartitiveMonths = (nElems != xElems.getLength());
+ nElems = xElems.getLength();
+ pUpperPartitiveMonthText.reset( new OUString[nElems] );
+ pUpperPartitiveAbbrevMonthText.reset( new OUString[nElems] );
+ for ( j = 0; j < nElems; j++ )
+ {
+ pUpperPartitiveMonthText[j] = pChrCls->uppercase( xElems[j].FullName );
+ pUpperPartitiveAbbrevMonthText[j] = pChrCls->uppercase( xElems[j].AbbrevName );
+ if (!bScanPartitiveMonths &&
+ (pUpperPartitiveMonthText[j] != pUpperGenitiveMonthText[j] ||
+ pUpperPartitiveAbbrevMonthText[j] != pUpperGenitiveAbbrevMonthText[j]))
+ {
+ bScanPartitiveMonths = true;
+ }
+ }
+
+ pUpperDayText.reset();
+ pUpperAbbrevDayText.reset();
+ xElems = pCal->getDays();
+ nElems = xElems.getLength();
+ pUpperDayText.reset( new OUString[nElems] );
+ pUpperAbbrevDayText.reset( new OUString[nElems] );
+ for ( j = 0; j < nElems; j++ )
+ {
+ pUpperDayText[j] = pChrCls->uppercase( xElems[j].FullName );
+ pUpperAbbrevDayText[j] = pChrCls->uppercase( xElems[j].AbbrevName );
+ }
+
+ bTextInitialized = true;
+}
+
+
+/**
+ * MUST be called if International/Locale is changed
+ */
+void ImpSvNumberInputScan::ChangeIntl()
+{
+ sal_Unicode cDecSep = pFormatter->GetNumDecimalSep()[0];
+ bDecSepInDateSeps = ( cDecSep == '-' ||
+ cDecSep == pFormatter->GetDateSep()[0] );
+ if (!bDecSepInDateSeps)
+ {
+ sal_Unicode cDecSepAlt = pFormatter->GetNumDecimalSepAlt().toChar();
+ bDecSepInDateSeps = cDecSepAlt && (cDecSepAlt == '-' || cDecSepAlt == pFormatter->GetDateSep()[0]);
+ }
+ bTextInitialized = false;
+ aUpperCurrSymbol.clear();
+ InvalidateDateAcceptancePatterns();
+}
+
+
+void ImpSvNumberInputScan::InvalidateDateAcceptancePatterns()
+{
+ if (sDateAcceptancePatterns.hasElements())
+ {
+ sDateAcceptancePatterns = css::uno::Sequence< OUString >();
+ }
+}
+
+
+void ImpSvNumberInputScan::ChangeNullDate( const sal_uInt16 Day,
+ const sal_uInt16 Month,
+ const sal_Int16 Year )
+{
+ if ( pNullDate )
+ {
+ *pNullDate = Date(Day, Month, Year);
+ }
+ else
+ {
+ pNullDate.reset(new Date(Day, Month, Year));
+ }
+}
+
+
+/**
+ * Does rString represent a number (also date, time et al)
+ */
+bool ImpSvNumberInputScan::IsNumberFormat( const OUString& rString, // string to be analyzed
+ SvNumFormatType& F_Type, // IN: old type, OUT: new type
+ double& fOutNumber, // OUT: number if convertible
+ const SvNumberformat* pFormat, // maybe a number format to match against
+ SvNumInputOptions eInputOptions )
+{
+ bool res; // return value
+ sal_uInt16 k;
+ eSetType = F_Type; // old type set
+
+ if ( !rString.getLength() )
+ {
+ res = false;
+ }
+ else if (rString.getLength() > 308) // arbitrary
+ {
+ res = false;
+ }
+ else
+ {
+ // NoMoreUpperNeeded, all comparisons on UpperCase
+ OUString aString = pFormatter->GetCharClass()->uppercase( rString );
+ // convert native number to ASCII if necessary
+ TransformInput(pFormatter, aString);
+ res = IsNumberFormatMain( aString, pFormat );
+ }
+
+ if (res)
+ {
+ // Accept signed date only for ISO date with at least four digits in
+ // year to not have an input of -M-D-Y arbitrarily recognized. The
+ // final order is only determined in GetDateRef().
+ // Also accept for Y/M/D date pattern match, i.e. if the first number
+ // is year.
+ // Accept only if the year immediately follows the sign character with
+ // no space in between.
+ if (nSign && (eScannedType == SvNumFormatType::DATE ||
+ eScannedType == SvNumFormatType::DATETIME) && mbEraCE == kDefaultEra &&
+ (IsDatePatternNumberOfType(0,'Y') || (MayBeIso8601() && sStrArray[nNums[0]].getLength() >= 4)))
+ {
+ const sal_Unicode c = sStrArray[0][sStrArray[0].getLength()-1];
+ if (c == '-' || c == '+')
+ {
+ // A '+' sign doesn't change the era.
+ if (nSign < 0)
+ mbEraCE = false; // BCE
+ nSign = 0;
+ }
+ }
+ if ( bNegCheck || // ')' not found for '('
+ (nSign && (eScannedType == SvNumFormatType::DATE ||
+ eScannedType == SvNumFormatType::DATETIME))) // signed date/datetime
+ {
+ res = false;
+ }
+ else
+ { // check count of partial number strings
+ switch (eScannedType)
+ {
+ case SvNumFormatType::PERCENT:
+ case SvNumFormatType::CURRENCY:
+ case SvNumFormatType::NUMBER:
+ if (nDecPos == 1) // .05
+ {
+ // Matched MidStrings function like group separators, but
+ // there can't be an integer part numeric input, so
+ // effectively 0 thousands groups.
+ if ( nMatchedAllStrings )
+ {
+ nThousand = 0;
+ }
+ else if ( nNumericsCnt != 1 )
+ {
+ res = false;
+ }
+ }
+ else if (nDecPos == 2) // 1.05
+ {
+ // Matched MidStrings function like group separators, but
+ // let a decimal separator override a literal separator
+ // string; like 0"." with input 123.45
+ if ( nMatchedAllStrings )
+ {
+ if (nNumericsCnt == 2)
+ nThousand = 0;
+ else
+ {
+ // Assume that if there was a decimal separator
+ // matching also a literal string then it was the
+ // last. We could find the last possible match to
+ // support literals in fractions, but really..
+ nThousand = nNumericsCnt - 1;
+ }
+ }
+ else if ( nNumericsCnt != nThousand+2 )
+ {
+ res = false;
+ }
+ }
+ else // 1,100 or 1,100.
+ {
+ // matched MidStrings function like group separators
+ if ( nMatchedAllStrings )
+ {
+ nThousand = nNumericsCnt - 1;
+ }
+ else if ( nNumericsCnt != nThousand+1 )
+ {
+ res = false;
+ }
+ }
+ break;
+
+ case SvNumFormatType::SCIENTIFIC: // 1.0e-2
+ if (nDecPos == 1) // .05
+ {
+ if (nNumericsCnt != 2)
+ {
+ res = false;
+ }
+ }
+ else if (nDecPos == 2) // 1.05
+ {
+ if (nNumericsCnt != nThousand+3)
+ {
+ res = false;
+ }
+ }
+ else // 1,100 or 1,100.
+ {
+ if (nNumericsCnt != nThousand+2)
+ {
+ res = false;
+ }
+ }
+ break;
+
+ case SvNumFormatType::DATE:
+ if (nMonth < 0 && nDayOfWeek < 0 && nNumericsCnt == 3)
+ {
+ // If both, short month name and day of week name were
+ // detected, and also numbers for full date, assume that we
+ // have a day of week instead of month name.
+ nMonth = 0;
+ nMonthPos = 0;
+ }
+ if (nMonth)
+ { // month name and numbers
+ if (nNumericsCnt > 2)
+ {
+ res = false;
+ }
+ }
+ else
+ {
+ if (nNumericsCnt > 3)
+ {
+ res = false;
+ }
+ else
+ {
+ // Even if a date pattern was matched, for abbreviated
+ // pattern like "D.M." an input of "D.M. #" was
+ // accepted because # could had been a time. Here we do
+ // not have a combined date/time input though and #
+ // would be taken as Year in this example, which it is
+ // not. The count of numbers in pattern must match the
+ // count of numbers in input.
+ res = (GetDatePatternNumbers() == nNumericsCnt)
+ || IsAcceptableIso8601() || nMatchedAllStrings;
+ }
+ }
+ break;
+
+ case SvNumFormatType::TIME:
+ if (nDecPos)
+ { // hundredth seconds included
+ if (nNumericsCnt > 4)
+ {
+ res = false;
+ }
+ }
+ else
+ {
+ if (nNumericsCnt > 3)
+ {
+ res = false;
+ }
+ }
+ break;
+
+ case SvNumFormatType::DATETIME:
+ if (nMonth < 0 && nDayOfWeek < 0 && nNumericsCnt >= 5)
+ {
+ // If both, abbreviated month name and day of week name
+ // were detected, and also at least numbers for full date
+ // plus time including minutes, assume that we have a day
+ // of week instead of month name.
+ nMonth = 0;
+ nMonthPos = 0;
+ }
+ if (nMonth)
+ { // month name and numbers
+ if (nDecPos)
+ { // hundredth seconds included
+ if (nNumericsCnt > 6)
+ {
+ res = false;
+ }
+ }
+ else
+ {
+ if (nNumericsCnt > 5)
+ {
+ res = false;
+ }
+ }
+ }
+ else
+ {
+ if (nDecPos)
+ { // hundredth seconds included
+ if (nNumericsCnt > 7)
+ {
+ res = false;
+ }
+ }
+ else
+ {
+ if (nNumericsCnt > 6)
+ {
+ res = false;
+ }
+ }
+ if (res)
+ {
+ res = IsAcceptedDatePattern( nNums[0]) || MayBeIso8601() || nMatchedAllStrings;
+ }
+ }
+ break;
+
+ default:
+ break;
+ } // switch
+ } // else
+ } // if (res)
+
+ OUStringBuffer sResString;
+
+ if (res)
+ { // we finally have a number
+ switch (eScannedType)
+ {
+ case SvNumFormatType::LOGICAL:
+ if (nLogical == 1)
+ {
+ fOutNumber = 1.0; // True
+ }
+ else if (nLogical == -1)
+ {
+ fOutNumber = 0.0; // False
+ }
+ else
+ {
+ res = false; // Oops
+ }
+ break;
+
+ case SvNumFormatType::PERCENT:
+ case SvNumFormatType::CURRENCY:
+ case SvNumFormatType::NUMBER:
+ case SvNumFormatType::SCIENTIFIC:
+ case SvNumFormatType::DEFINED: // if no category detected handle as number
+ if ( nDecPos == 1 ) // . at start
+ {
+ sResString.append("0.");
+ }
+
+ for ( k = 0; k <= nThousand; k++)
+ {
+ sResString.append(sStrArray[nNums[k]]); // integer part
+ }
+ if ( nDecPos == 2 && k < nNumericsCnt ) // . somewhere
+ {
+ sResString.append('.');
+ sal_uInt16 nStop = (eScannedType == SvNumFormatType::SCIENTIFIC ?
+ nNumericsCnt-1 : nNumericsCnt);
+ for ( ; k < nStop; k++)
+ {
+ sResString.append(sStrArray[nNums[k]]); // fractional part
+ }
+ }
+
+ if (eScannedType != SvNumFormatType::SCIENTIFIC)
+ {
+ fOutNumber = StringToDouble(sResString);
+ }
+ else
+ { // append exponent
+ sResString.append('E');
+ if ( nESign == -1 )
+ {
+ sResString.append('-');
+ }
+ sResString.append(sStrArray[nNums[nNumericsCnt-1]]);
+ rtl_math_ConversionStatus eStatus;
+ fOutNumber = ::rtl::math::stringToDouble( sResString, '.', ',', &eStatus );
+ if ( eStatus == rtl_math_ConversionStatus_OutOfRange )
+ {
+ F_Type = SvNumFormatType::TEXT; // overflow/underflow -> Text
+ if (nESign == -1)
+ {
+ fOutNumber = 0.0;
+ }
+ else
+ {
+ fOutNumber = DBL_MAX;
+ }
+ return true;
+ }
+ }
+
+ if ( nStringScanSign )
+ {
+ if ( nSign )
+ {
+ nSign *= nStringScanSign;
+ }
+ else
+ {
+ nSign = nStringScanSign;
+ }
+ }
+ if ( nSign < 0 )
+ {
+ fOutNumber = -fOutNumber;
+ }
+
+ if (eScannedType == SvNumFormatType::PERCENT)
+ {
+ fOutNumber/= 100.0;
+ }
+ break;
+
+ case SvNumFormatType::FRACTION:
+ if (nNumericsCnt == 1)
+ {
+ fOutNumber = StringToDouble(sStrArray[nNums[0]]);
+ }
+ else if (nNumericsCnt == 2)
+ {
+ if (nThousand == 1)
+ {
+ sResString = sStrArray[nNums[0]];
+ sResString.append(sStrArray[nNums[1]]); // integer part
+ fOutNumber = StringToDouble(sResString);
+ }
+ else
+ {
+ double fNumerator = StringToDouble(sStrArray[nNums[0]]);
+ double fDenominator = StringToDouble(sStrArray[nNums[1]]);
+ if (fDenominator != 0.0)
+ {
+ fOutNumber = fNumerator/fDenominator;
+ }
+ else
+ {
+ res = false;
+ }
+ }
+ }
+ else // nNumericsCnt > 2
+ {
+ k = 1;
+ sResString = sStrArray[nNums[0]];
+ if (nThousand > 0)
+ {
+ for (; k <= nThousand; k++)
+ {
+ sResString.append(sStrArray[nNums[k]]);
+ }
+ }
+ fOutNumber = StringToDouble(sResString);
+
+ if (k == nNumericsCnt-2)
+ {
+ double fNumerator = StringToDouble(sStrArray[nNums[k]]);
+ double fDenominator = StringToDouble(sStrArray[nNums[k + 1]]);
+ if (fDenominator != 0.0)
+ {
+ fOutNumber += fNumerator/fDenominator;
+ }
+ else
+ {
+ res = false;
+ }
+ }
+ }
+
+ if ( nStringScanSign )
+ {
+ if ( nSign )
+ {
+ nSign *= nStringScanSign;
+ }
+ else
+ {
+ nSign = nStringScanSign;
+ }
+ }
+ if ( nSign < 0 )
+ {
+ fOutNumber = -fOutNumber;
+ }
+ break;
+
+ case SvNumFormatType::TIME:
+ res = GetTimeRef(fOutNumber, 0, nNumericsCnt, eInputOptions);
+ if ( nSign < 0 )
+ {
+ fOutNumber = -fOutNumber;
+ }
+ break;
+
+ case SvNumFormatType::DATE:
+ res = GetDateRef( fOutNumber, k );
+ break;
+
+ case SvNumFormatType::DATETIME:
+ res = GetDateRef( fOutNumber, k );
+ if ( res )
+ {
+ double fTime;
+ res = GetTimeRef( fTime, k, nNumericsCnt - k, eInputOptions);
+ fOutNumber += fTime;
+ }
+ break;
+
+ default:
+ SAL_WARN( "svl.numbers", "Some number recognized but what's it?" );
+ fOutNumber = 0.0;
+ break;
+ }
+ }
+
+ if (res) // overflow/underflow -> Text
+ {
+ if (fOutNumber < -DBL_MAX) // -1.7E308
+ {
+ F_Type = SvNumFormatType::TEXT;
+ fOutNumber = -DBL_MAX;
+ return true;
+ }
+ else if (fOutNumber > DBL_MAX) // 1.7E308
+ {
+ F_Type = SvNumFormatType::TEXT;
+ fOutNumber = DBL_MAX;
+ return true;
+ }
+ }
+
+ if (!res)
+ {
+ eScannedType = SvNumFormatType::TEXT;
+ fOutNumber = 0.0;
+ }
+
+ F_Type = eScannedType;
+ return res;
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/svl/source/numbers/zforfind.hxx b/svl/source/numbers/zforfind.hxx
new file mode 100644
index 000000000..7e6ddeb59
--- /dev/null
+++ b/svl/source/numbers/zforfind.hxx
@@ -0,0 +1,441 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed
+ * with this work for additional information regarding copyright
+ * ownership. The ASF licenses this file to you under the Apache
+ * License, Version 2.0 (the "License"); you may not use this file
+ * except in compliance with the License. You may obtain a copy of
+ * the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#ifndef INCLUDED_SVL_SOURCE_NUMBERS_ZFORFIND_HXX
+#define INCLUDED_SVL_SOURCE_NUMBERS_ZFORFIND_HXX
+
+#include <com/sun/star/uno/Sequence.hxx>
+#include <rtl/ustring.hxx>
+#include <svl/zforlist.hxx>
+#include <memory>
+
+class Date;
+class SvNumberformat;
+class SvNumberFormatter;
+enum class SvNumFormatType : sal_Int16;
+
+#define SV_MAX_COUNT_INPUT_STRINGS 20 // max count of substrings in input scanner
+
+class ImpSvNumberInputScan
+{
+public:
+ explicit ImpSvNumberInputScan( SvNumberFormatter* pFormatter );
+ ~ImpSvNumberInputScan();
+
+/*!*/ void ChangeIntl(); // MUST be called if language changes
+
+ /// set reference date for offset calculation
+ void ChangeNullDate( const sal_uInt16 nDay,
+ const sal_uInt16 nMonth,
+ const sal_Int16 nYear );
+
+ /// convert input string to number
+ bool IsNumberFormat( const OUString& rString, /// input string
+ SvNumFormatType& F_Type, /// format type (in + out)
+ double& fOutNumber, /// value determined (out)
+ const SvNumberformat* pFormat, /// number format to which compare against
+ SvNumInputOptions eInputOptions);
+
+ /// after IsNumberFormat: get decimal position
+ short GetDecPos() const { return nDecPos; }
+ /// after IsNumberFormat: get count of numeric substrings in input string
+ sal_uInt16 GetNumericsCount() const { return nNumericsCnt; }
+
+ /// set threshold of two-digit year input
+ void SetYear2000( sal_uInt16 nVal ) { nYear2000 = nVal; }
+ /// get threshold of two-digit year input
+ sal_uInt16 GetYear2000() const { return nYear2000; }
+
+ /** Whether input can be forced to ISO 8601 format.
+
+ Depends on locale's date separator and a specific date format order.
+ */
+ bool CanForceToIso8601( DateOrder eDateOrder );
+
+ void InvalidateDateAcceptancePatterns();
+
+ /** Whether 'T' separator was detected in an ISO 8601 date+time format.
+ */
+ bool HasIso8601Tsep() const { return bIso8601Tsep; }
+
+private:
+ SvNumberFormatter* pFormatter;
+ const SvNumberformat* mpFormat; //* The format to compare against, if any
+ std::unique_ptr<OUString[]> pUpperMonthText; //* Array of month names, uppercase
+ std::unique_ptr<OUString[]> pUpperAbbrevMonthText; //* Array of month names, abbreviated, uppercase
+ std::unique_ptr<OUString[]> pUpperGenitiveMonthText; //* Array of genitive month names, uppercase
+ std::unique_ptr<OUString[]> pUpperGenitiveAbbrevMonthText; //* Array of genitive month names, abbreviated, uppercase
+ std::unique_ptr<OUString[]> pUpperPartitiveMonthText; //* Array of partitive month names, uppercase
+ std::unique_ptr<OUString[]> pUpperPartitiveAbbrevMonthText;//* Array of partitive month names, abbreviated, uppercase
+ std::unique_ptr<OUString[]> pUpperDayText; //* Array of day of week names, uppercase
+ std::unique_ptr<OUString[]> pUpperAbbrevDayText; //* Array of day of week names, abbreviated, uppercase
+ OUString aUpperCurrSymbol; //* Currency symbol, uppercase
+ bool bTextInitialized; //* Whether days and months are initialized
+ bool bScanGenitiveMonths; //* Whether to scan an input for genitive months
+ bool bScanPartitiveMonths; //* Whether to scan an input for partitive months
+ std::unique_ptr<Date> pNullDate; //* 30Dec1899
+ // Variables for provisional results:
+ OUString sStrArray[SV_MAX_COUNT_INPUT_STRINGS];//* Array of scanned substrings
+ bool IsNum[SV_MAX_COUNT_INPUT_STRINGS]; //* Whether a substring is numeric
+ sal_uInt16 nNums[SV_MAX_COUNT_INPUT_STRINGS]; //* Sequence of offsets to numeric strings
+ sal_uInt16 nStringsCnt; //* Total count of scanned substrings
+ sal_uInt16 nNumericsCnt; //* Count of numeric substrings
+ bool bDecSepInDateSeps; //* True <=> DecSep in {.,-,/,DateSep}
+ sal_uInt8 nMatchedAllStrings; //* Scan...String() matched all substrings,
+
+ // bit mask of nMatched... constants
+ static const sal_uInt8 nMatchedEndString; // 0x01
+ static const sal_uInt8 nMatchedMidString; // 0x02
+ static const sal_uInt8 nMatchedStartString; // 0x04
+ static const sal_uInt8 nMatchedVirgin; // 0x08
+ static const sal_uInt8 nMatchedUsedAsReturn; // 0x10
+
+ int nSign; // Sign of number
+ int nMonth; // Month (1..x) if date
+ // negative => short format
+ short nMonthPos; // 1 = front, 2 = middle
+ // 3 = end
+ int nDayOfWeek; // Temporary (!) day of week (1..7,-1..-7) if date
+ sal_uInt16 nTimePos; // Index of first time separator (+1)
+ short nDecPos; // Index of substring containing "," (+1)
+ bool bNegCheck; // '( )' for negative
+ short nESign; // Sign of exponent
+ short nAmPm; // +1 AM, -1 PM, 0 if none
+ short nLogical; // -1 => False, 1 => True
+ bool mbEraCE; // Era if date, 0 => BCE, 1 => CE (currently only Gregorian)
+ sal_uInt16 nThousand; // Count of group (AKA thousand) separators
+ sal_uInt16 nPosThousandString; // Position of concatenated 000,000,000 string
+ SvNumFormatType eScannedType; // Scanned type
+ SvNumFormatType eSetType; // Preset Type
+
+ sal_uInt16 nStringScanNumFor; // Fixed strings recognized in
+ // pFormat->NumFor[nNumForStringScan]
+ short nStringScanSign; // Sign resulting of FixString
+ sal_uInt16 nYear2000; // Two-digit threshold
+ // Year as 20xx
+ // default 18
+ // number <= nYear2000 => 20xx
+ // number > nYear2000 => 19xx
+
+ /** State of ISO 8601 detection.
+
+ 0:= don't know yet
+ 1:= no
+ 2:= yes, <=2 digits in year
+ 3:= yes, 3 digits in year
+ 4:= yes, >=4 digits in year
+
+ @see MayBeIso8601()
+ */
+ sal_uInt8 nMayBeIso8601;
+
+ /** Whether the 'T' time separator was detected in an ISO 8601 string. */
+ bool bIso8601Tsep;
+
+ /** State of dd-month-yy or yy-month-dd detection, with month name.
+
+ 0:= don't know yet
+ 1:= no
+ 2:= yes, dd-month-yy
+ 3:= yes, yy-month-dd
+
+ @see MayBeMonthDate()
+ */
+ sal_uInt8 nMayBeMonthDate;
+
+ /** Input matched this locale dependent date acceptance pattern.
+ -2 if not checked yet, -1 if no match, >=0 matched pattern.
+
+ @see IsAcceptedDatePattern()
+ */
+ sal_Int32 nAcceptedDatePattern;
+ css::uno::Sequence< OUString > sDateAcceptancePatterns;
+
+ /** If input matched a date acceptance pattern that starts at input
+ particle sStrArray[nDatePatternStart].
+
+ @see IsAcceptedDatePattern()
+ */
+ sal_uInt16 nDatePatternStart;
+
+ /** Count of numbers that matched the accepted pattern, if any, else 0.
+
+ @see GetDatePatternNumbers()
+ */
+ sal_uInt16 nDatePatternNumbers;
+
+ // Copy assignment is forbidden and not implemented.
+ ImpSvNumberInputScan (const ImpSvNumberInputScan &) = delete;
+ ImpSvNumberInputScan & operator= (const ImpSvNumberInputScan &) = delete;
+
+ void Reset(); // Reset all variables before start of analysis
+
+ void InitText(); // Init of months and days of week
+
+ // Convert string to double.
+ // Only simple unsigned floating point values without any error detection,
+ // decimal separator has to be '.'
+ // If bForceFraction==true the string is taken to be the fractional part
+ // of 0.1234 without the leading 0. (thus being just "1234").
+ static double StringToDouble( std::u16string_view aStr,
+ bool bForceFraction = false );
+
+ // Next number/string symbol
+ static bool NextNumberStringSymbol( const sal_Unicode*& pStr,
+ OUString& rSymbol );
+
+ // Concatenate ,000,23 blocks
+ // in input to 000123
+ bool SkipThousands( const sal_Unicode*& pStr, OUString& rSymbol ) const;
+
+ // Divide numbers/strings into
+ // arrays and variables above.
+ // Leading blanks and blanks
+ // after numbers are thrown away
+ void NumberStringDivision( const OUString& rString );
+
+
+ /** Whether rString contains word (!) rWhat at nPos.
+ rWhat will not be matched if it is a substring of a word.
+ */
+ bool StringContainsWord( const OUString& rWhat,
+ const OUString& rString,
+ sal_Int32 nPos ) const;
+
+ // optimized substring versions
+
+ // Whether rString contains rWhat at nPos
+ static bool StringContains( const OUString& rWhat,
+ const OUString& rString,
+ sal_Int32 nPos )
+ {
+ if (rWhat.isEmpty() || rString.getLength() <= nPos)
+ {
+ return false;
+ }
+ // mostly used with one character
+ if ( rWhat[ 0 ] != rString[ nPos ] )
+ {
+ return false;
+ }
+ return StringContainsImpl( rWhat, rString, nPos );
+ }
+
+ // Whether pString contains rWhat at nPos
+ static bool StringPtrContains( const OUString& rWhat,
+ const sal_Unicode* pString,
+ sal_Int32 nPos ) // nPos MUST be a valid offset from pString
+ {
+ // mostly used with one character
+ if ( rWhat[ 0 ] != pString[ nPos ] )
+ {
+ return false;
+ }
+ return StringPtrContainsImpl( rWhat, pString, nPos );
+ }
+
+ //! DO NOT use directly
+ static bool StringContainsImpl( const OUString& rWhat,
+ const OUString& rString,
+ sal_Int32 nPos );
+ //! DO NOT use directly
+ static bool StringPtrContainsImpl( const OUString& rWhat,
+ const sal_Unicode* pString,
+ sal_Int32 nPos );
+
+ // Skip a special character
+ static inline bool SkipChar( sal_Unicode c,
+ const OUString& rString,
+ sal_Int32& nPos );
+
+ // Skip blank
+ static inline bool SkipBlanks( const OUString& rString,
+ sal_Int32& nPos );
+
+ // Jump over rWhat in rString at nPos
+ static inline bool SkipString( const OUString& rWhat,
+ const OUString& rString,
+ sal_Int32& nPos );
+
+ // Recognizes exactly ,111 as group separator
+ inline bool GetThousandSep( const OUString& rString,
+ sal_Int32& nPos,
+ sal_uInt16 nStringPos ) const;
+ // Get boolean value
+ short GetLogical( std::u16string_view rString ) const;
+
+ // Get month and advance string position
+ short GetMonth( const OUString& rString,
+ sal_Int32& nPos );
+
+ // Get day of week and advance string position
+ int GetDayOfWeek( const OUString& rString,
+ sal_Int32& nPos );
+
+ // Get currency symbol and advance string position
+ bool GetCurrency( const OUString& rString,
+ sal_Int32& nPos );
+
+ // Get symbol AM or PM and advance string position
+ bool GetTimeAmPm( const OUString& rString,
+ sal_Int32& nPos );
+
+ // Get decimal separator and advance string position
+ inline bool GetDecSep( const OUString& rString,
+ sal_Int32& nPos ) const;
+
+ // Get hundredth seconds separator and advance string position
+ inline bool GetTime100SecSep( const OUString& rString,
+ sal_Int32& nPos ) const;
+
+ // Get sign and advance string position
+ // Including special case '('
+ int GetSign( const OUString& rString,
+ sal_Int32& nPos );
+
+ // Get sign of exponent and advance string position
+ static short GetESign( const OUString& rString,
+ sal_Int32& nPos );
+
+ // Get next number as array offset
+ inline bool GetNextNumber( sal_uInt16& i,
+ sal_uInt16& j ) const;
+
+ /** Converts time -> double (only decimals)
+
+ @return TRUE if time, FALSE if not (e.g. hours >12 with AM/PM)
+ */
+ bool GetTimeRef( double& fOutNumber, // result as double
+ sal_uInt16 nIndex, // Index of hour in input
+ sal_uInt16 nCnt, // Count of time substrings in input
+ SvNumInputOptions eInputOptions ) const;
+ sal_uInt16 ImplGetDay ( sal_uInt16 nIndex ) const; // Day input, 0 if no match
+ sal_uInt16 ImplGetMonth( sal_uInt16 nIndex ) const; // Month input, zero based return, NumberOfMonths if no match
+ sal_uInt16 ImplGetYear ( sal_uInt16 nIndex ); // Year input, 0 if no match
+
+ // Conversion of date to number
+ bool GetDateRef( double& fDays, // OUT: days diff to null date
+ sal_uInt16& nCounter ); // Count of date substrings
+
+ // Analyze start of string
+ bool ScanStartString( const OUString& rString );
+
+ // Analyze middle substring
+ bool ScanMidString( const OUString& rString,
+ sal_uInt16 nStringPos );
+
+
+ // Analyze end of string
+ bool ScanEndString( const OUString& rString );
+
+ // Compare rString to substring of array indexed by nString
+ // nString == 0xFFFF => last substring
+ bool ScanStringNumFor( const OUString& rString,
+ sal_Int32 nPos,
+ sal_uInt16 nString,
+ bool bDontDetectNegation = false );
+
+ // if nMatchedAllStrings set nMatchedUsedAsReturn and return true,
+ // else do nothing and return false
+ bool MatchedReturn();
+
+ //! Be sure that the string to be analyzed is already converted to upper
+ //! case and if it contained native number digits that they are already
+ //! converted to ASCII.
+
+ // Main analyzing function
+ bool IsNumberFormatMain( const OUString& rString,
+ const SvNumberformat* pFormat); // number format to match against
+
+ /** Whether input matches locale dependent date acceptance pattern.
+
+ @param nStartPatternAt
+ The pattern matching starts at input particle
+ sStrArray[nStartPatternAt].
+
+ NOTE: once called the result is remembered, subsequent calls with
+ different parameters do not check for a match and do not lead to a
+ different result.
+ */
+ bool IsAcceptedDatePattern( sal_uInt16 nStartPatternAt );
+
+ /** Sets (not advances!) rPos to sStrArray[nParticle].getLength() if string
+ matches separator in pattern at nParticle.
+
+ Also detects a signed year case like M/D/-Y
+
+ @returns TRUE if separator matched.
+ */
+ bool SkipDatePatternSeparator( sal_uInt16 nParticle, sal_Int32 & rPos, bool & rSignedYear );
+
+ /** Returns count of numbers in accepted date pattern.
+ */
+ sal_uInt16 GetDatePatternNumbers();
+
+ /** Whether numeric string nNumber is of type cType in accepted date
+ pattern, 'Y', 'M' or 'D'.
+ */
+ bool IsDatePatternNumberOfType( sal_uInt16 nNumber, sal_Unicode cType );
+
+ /** Obtain order of accepted date pattern coded as, for example,
+ ('D'<<16)|('M'<<8)|'Y'
+ */
+ sal_uInt32 GetDatePatternOrder();
+
+ /** Obtain date format order, from accepted date pattern if available or
+ otherwise the locale's default order.
+
+ @param bFromFormatIfNoPattern
+ If <TRUE/> and no pattern was matched, obtain date order from
+ format if available, instead from format's or current locale.
+ */
+ DateOrder GetDateOrder( bool bFromFormatIfNoPattern = false );
+
+ /** Whether input may be an ISO 8601 date format, yyyy-mm-dd...
+
+ Checks if input has at least 3 numbers for yyyy-mm-dd and the separator
+ is '-', and 1<=mm<=12 and 1<=dd<=31.
+
+ @see nMayBeIso8601
+ */
+ bool MayBeIso8601();
+
+ /** Whether input may be a dd-month-yy format, with month name, not
+ number.
+
+ @see nMayBeMonthDate
+ */
+ bool MayBeMonthDate();
+
+ /** Whether input is acceptable as ISO 8601 date format in the current
+ NfEvalDateFormat setting.
+ */
+ bool IsAcceptableIso8601();
+
+ /** If month name in the middle was parsed, get the corresponding
+ LongDateOrder in GetDateRef().
+ */
+ LongDateOrder GetMiddleMonthLongDateOrder( bool bFormatTurn,
+ const LocaleDataWrapper* pLoc,
+ DateOrder eDateOrder );
+};
+
+#endif // INCLUDED_SVL_SOURCE_NUMBERS_ZFORFIND_HXX
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/svl/source/numbers/zforlist.cxx b/svl/source/numbers/zforlist.cxx
new file mode 100644
index 000000000..e7de0d615
--- /dev/null
+++ b/svl/source/numbers/zforlist.cxx
@@ -0,0 +1,4972 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed
+ * with this work for additional information regarding copyright
+ * ownership. The ASF licenses this file to you under the Apache
+ * License, Version 2.0 (the "License"); you may not use this file
+ * except in compliance with the License. You may obtain a copy of
+ * the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#include <sal/config.h>
+
+#include <sal/log.hxx>
+#include <officecfg/Office/Common.hxx>
+#include <svl/zforlist.hxx>
+#include <svl/currencytable.hxx>
+
+#include <comphelper/string.hxx>
+#include <tools/debug.hxx>
+#include <unotools/charclass.hxx>
+#include <unotools/configmgr.hxx>
+#include <i18nlangtag/mslangid.hxx>
+#include <unotools/localedatawrapper.hxx>
+#include <com/sun/star/i18n/KNumberFormatUsage.hpp>
+#include <com/sun/star/i18n/KNumberFormatType.hpp>
+#include <com/sun/star/i18n/FormatElement.hpp>
+#include <com/sun/star/i18n/Currency2.hpp>
+#include <com/sun/star/i18n/NumberFormatCode.hpp>
+#include <com/sun/star/i18n/XNumberFormatCode.hpp>
+#include <com/sun/star/i18n/NumberFormatMapper.hpp>
+#include <comphelper/processfactory.hxx>
+
+#include <osl/mutex.hxx>
+
+#include "zforscan.hxx"
+#include "zforfind.hxx"
+#include <svl/zformat.hxx>
+#include <i18npool/reservedconstants.hxx>
+
+#include <unotools/syslocaleoptions.hxx>
+#include <unotools/digitgroupingiterator.hxx>
+#include <rtl/strbuf.hxx>
+#include <rtl/math.hxx>
+
+#include <math.h>
+#include <limits>
+#include <memory>
+#include <set>
+
+using namespace ::com::sun::star;
+using namespace ::com::sun::star::uno;
+using namespace ::com::sun::star::i18n;
+using namespace ::com::sun::star::lang;
+using namespace ::std;
+
+// Constants for type offsets per Country/Language (CL)
+#define ZF_STANDARD 0
+#define ZF_STANDARD_PERCENT 10
+#define ZF_STANDARD_CURRENCY 20
+#define ZF_STANDARD_DATE 30
+#define ZF_STANDARD_TIME 60
+#define ZF_STANDARD_DURATION (ZF_STANDARD_TIME + 4)
+#define ZF_STANDARD_DATETIME 70
+#define ZF_STANDARD_SCIENTIFIC 80
+#define ZF_STANDARD_FRACTION 85
+
+// Additional builtin formats, historically not fitting into the first 10 of a
+// category. Make sure it doesn't spill over to the next category.
+#define ZF_STANDARD_DATE_SYS_DMMMYYYY (ZF_STANDARD_DATE + 10)
+#define ZF_STANDARD_DATE_SYS_DMMMMYYYY (ZF_STANDARD_DATE + 11)
+#define ZF_STANDARD_DATE_SYS_NNDMMMYY (ZF_STANDARD_DATE + 12)
+#define ZF_STANDARD_DATE_SYS_NNDMMMMYYYY (ZF_STANDARD_DATE + 13)
+#define ZF_STANDARD_DATE_SYS_NNNNDMMMMYYYY (ZF_STANDARD_DATE + 14)
+#define ZF_STANDARD_DATE_DIN_DMMMYYYY (ZF_STANDARD_DATE + 15)
+#define ZF_STANDARD_DATE_DIN_DMMMMYYYY (ZF_STANDARD_DATE + 16)
+#define ZF_STANDARD_DATE_DIN_MMDD (ZF_STANDARD_DATE + 17)
+#define ZF_STANDARD_DATE_DIN_YYMMDD (ZF_STANDARD_DATE + 18)
+#define ZF_STANDARD_DATE_DIN_YYYYMMDD (ZF_STANDARD_DATE + 19)
+#define ZF_STANDARD_DATE_WW (ZF_STANDARD_DATE + 20)
+
+#define ZF_STANDARD_LOGICAL SV_MAX_COUNT_STANDARD_FORMATS-1 // 99
+#define ZF_STANDARD_TEXT SV_MAX_COUNT_STANDARD_FORMATS // 100
+
+static_assert( ZF_STANDARD_TEXT == NF_STANDARD_FORMAT_TEXT, "definition mismatch" );
+
+static_assert( NF_INDEX_TABLE_RESERVED_START == i18npool::nStopPredefinedFormatIndex,
+ "NfIndexTableOffset does not match i18npool's locale data predefined format code index bounds.");
+
+static_assert( NF_INDEX_TABLE_ENTRIES <= i18npool::nFirstFreeFormatIndex,
+ "NfIndexTableOffset crosses i18npool's locale data reserved format code index bounds.\n"
+ "You will need to adapt all locale data files defining index values "
+ "(formatIndex=\"...\") in that range and increment those and when done "
+ "adjust nFirstFreeFormatIndex in include/i18npool/reservedconstants.hxx");
+
+/* Locale that is set if an unknown locale (from another system) is loaded of
+ * legacy documents. Can not be SYSTEM because else, for example, a German "DM"
+ * (old currency) is recognized as a date (#53155#). */
+#define UNKNOWN_SUBSTITUTE LANGUAGE_ENGLISH_US
+
+// Same order as in include/svl/zforlist.hxx enum NfIndexTableOffset
+sal_uInt32 const indexTable[NF_INDEX_TABLE_ENTRIES] = {
+ ZF_STANDARD, // NF_NUMBER_STANDARD
+ ZF_STANDARD + 1, // NF_NUMBER_INT
+ ZF_STANDARD + 2, // NF_NUMBER_DEC2
+ ZF_STANDARD + 3, // NF_NUMBER_1000INT
+ ZF_STANDARD + 4, // NF_NUMBER_1000DEC2
+ ZF_STANDARD + 5, // NF_NUMBER_SYSTEM
+ ZF_STANDARD_SCIENTIFIC, // NF_SCIENTIFIC_000E000
+ ZF_STANDARD_SCIENTIFIC + 1, // NF_SCIENTIFIC_000E00
+ ZF_STANDARD_PERCENT, // NF_PERCENT_INT
+ ZF_STANDARD_PERCENT + 1, // NF_PERCENT_DEC2
+ ZF_STANDARD_FRACTION, // NF_FRACTION_1D
+ ZF_STANDARD_FRACTION + 1, // NF_FRACTION_2D
+ ZF_STANDARD_CURRENCY, // NF_CURRENCY_1000INT
+ ZF_STANDARD_CURRENCY + 1, // NF_CURRENCY_1000DEC2
+ ZF_STANDARD_CURRENCY + 2, // NF_CURRENCY_1000INT_RED
+ ZF_STANDARD_CURRENCY + 3, // NF_CURRENCY_1000DEC2_RED
+ ZF_STANDARD_CURRENCY + 4, // NF_CURRENCY_1000DEC2_CCC
+ ZF_STANDARD_CURRENCY + 5, // NF_CURRENCY_1000DEC2_DASHED
+ ZF_STANDARD_DATE, // NF_DATE_SYSTEM_SHORT
+ ZF_STANDARD_DATE + 8, // NF_DATE_SYSTEM_LONG
+ ZF_STANDARD_DATE + 7, // NF_DATE_SYS_DDMMYY
+ ZF_STANDARD_DATE + 6, // NF_DATE_SYS_DDMMYYYY
+ ZF_STANDARD_DATE + 9, // NF_DATE_SYS_DMMMYY
+ ZF_STANDARD_DATE_SYS_DMMMYYYY, // NF_DATE_SYS_DMMMYYYY
+ ZF_STANDARD_DATE_DIN_DMMMYYYY, // NF_DATE_DIN_DMMMYYYY
+ ZF_STANDARD_DATE_SYS_DMMMMYYYY, // NF_DATE_SYS_DMMMMYYYY
+ ZF_STANDARD_DATE_DIN_DMMMMYYYY, // NF_DATE_DIN_DMMMMYYYY
+ ZF_STANDARD_DATE_SYS_NNDMMMYY, // NF_DATE_SYS_NNDMMMYY
+ ZF_STANDARD_DATE + 1, // NF_DATE_DEF_NNDDMMMYY
+ ZF_STANDARD_DATE_SYS_NNDMMMMYYYY, // NF_DATE_SYS_NNDMMMMYYYY
+ ZF_STANDARD_DATE_SYS_NNNNDMMMMYYYY, // NF_DATE_SYS_NNNNDMMMMYYYY
+ ZF_STANDARD_DATE_DIN_MMDD, // NF_DATE_DIN_MMDD
+ ZF_STANDARD_DATE_DIN_YYMMDD, // NF_DATE_DIN_YYMMDD
+ ZF_STANDARD_DATE_DIN_YYYYMMDD, // NF_DATE_DIN_YYYYMMDD
+ ZF_STANDARD_DATE + 2, // NF_DATE_SYS_MMYY
+ ZF_STANDARD_DATE + 3, // NF_DATE_SYS_DDMMM
+ ZF_STANDARD_DATE + 4, // NF_DATE_MMMM
+ ZF_STANDARD_DATE + 5, // NF_DATE_QQJJ
+ ZF_STANDARD_DATE_WW, // NF_DATE_WW
+ ZF_STANDARD_TIME, // NF_TIME_HHMM
+ ZF_STANDARD_TIME + 1, // NF_TIME_HHMMSS
+ ZF_STANDARD_TIME + 2, // NF_TIME_HHMMAMPM
+ ZF_STANDARD_TIME + 3, // NF_TIME_HHMMSSAMPM
+ ZF_STANDARD_TIME + 4, // NF_TIME_HH_MMSS
+ ZF_STANDARD_TIME + 5, // NF_TIME_MMSS00
+ ZF_STANDARD_TIME + 6, // NF_TIME_HH_MMSS00
+ ZF_STANDARD_DATETIME, // NF_DATETIME_SYSTEM_SHORT_HHMM
+ ZF_STANDARD_DATETIME + 1, // NF_DATETIME_SYS_DDMMYYYY_HHMMSS
+ ZF_STANDARD_LOGICAL, // NF_BOOLEAN
+ ZF_STANDARD_TEXT, // NF_TEXT
+ ZF_STANDARD_DATETIME + 2, // NF_DATETIME_SYS_DDMMYYYY_HHMM
+ ZF_STANDARD_FRACTION + 2, // NF_FRACTION_3D
+ ZF_STANDARD_FRACTION + 3, // NF_FRACTION_2
+ ZF_STANDARD_FRACTION + 4, // NF_FRACTION_4
+ ZF_STANDARD_FRACTION + 5, // NF_FRACTION_8
+ ZF_STANDARD_FRACTION + 6, // NF_FRACTION_16
+ ZF_STANDARD_FRACTION + 7, // NF_FRACTION_10
+ ZF_STANDARD_FRACTION + 8, // NF_FRACTION_100
+ ZF_STANDARD_DATETIME + 3, // NF_DATETIME_ISO_YYYYMMDD_HHMMSS
+ ZF_STANDARD_DATETIME + 4, // NF_DATETIME_ISO_YYYYMMDD_HHMMSS000
+ ZF_STANDARD_DATETIME + 5, // NF_DATETIME_ISO_YYYYMMDDTHHMMSS
+ ZF_STANDARD_DATETIME + 6 // NF_DATETIME_ISO_YYYYMMDDTHHMMSS000
+};
+
+/**
+ instead of every number formatter being a listener we have a registry which
+ also handles one instance of the SysLocale options
+ */
+
+class SvNumberFormatterRegistry_Impl : public utl::ConfigurationListener
+{
+ std::vector< SvNumberFormatter* >
+ aFormatters;
+ SvtSysLocaleOptions aSysLocaleOptions;
+ LanguageType eSysLanguage;
+
+public:
+ SvNumberFormatterRegistry_Impl();
+ virtual ~SvNumberFormatterRegistry_Impl() override;
+
+ void Insert( SvNumberFormatter* pThis )
+ { aFormatters.push_back( pThis ); }
+
+ void Remove( SvNumberFormatter const * pThis );
+
+ size_t Count() const
+ { return aFormatters.size(); }
+
+ virtual void ConfigurationChanged( utl::ConfigurationBroadcaster*, ConfigurationHints ) override;
+};
+
+SvNumberFormatterRegistry_Impl::SvNumberFormatterRegistry_Impl()
+ : eSysLanguage(MsLangId::getRealLanguage( LANGUAGE_SYSTEM ))
+{
+ aSysLocaleOptions.AddListener( this );
+}
+
+
+SvNumberFormatterRegistry_Impl::~SvNumberFormatterRegistry_Impl()
+{
+ aSysLocaleOptions.RemoveListener( this );
+}
+
+
+void SvNumberFormatterRegistry_Impl::Remove( SvNumberFormatter const * pThis )
+{
+ auto it = std::find(aFormatters.begin(), aFormatters.end(), pThis);
+ if (it != aFormatters.end())
+ aFormatters.erase( it );
+}
+
+void SvNumberFormatterRegistry_Impl::ConfigurationChanged( utl::ConfigurationBroadcaster*,
+ ConfigurationHints nHint)
+{
+ ::osl::MutexGuard aGuard( SvNumberFormatter::GetGlobalMutex() );
+
+ if ( nHint & ConfigurationHints::Locale )
+ {
+ for(SvNumberFormatter* pFormatter : aFormatters)
+ pFormatter->ReplaceSystemCL( eSysLanguage );
+ eSysLanguage = MsLangId::getRealLanguage( LANGUAGE_SYSTEM );
+ }
+ if ( nHint & ConfigurationHints::Currency )
+ {
+ for(SvNumberFormatter* pFormatter : aFormatters)
+ pFormatter->ResetDefaultSystemCurrency();
+ }
+ if ( nHint & ConfigurationHints::DatePatterns )
+ {
+ for(SvNumberFormatter* pFormatter : aFormatters)
+ pFormatter->InvalidateDateAcceptancePatterns();
+ }
+}
+
+
+SvNumberFormatterRegistry_Impl* SvNumberFormatter::pFormatterRegistry = nullptr;
+volatile bool SvNumberFormatter::bCurrencyTableInitialized = false;
+namespace
+{
+ NfCurrencyTable& theCurrencyTable()
+ {
+ static NfCurrencyTable SINGLETON;
+ return SINGLETON;
+ }
+
+ NfCurrencyTable& theLegacyOnlyCurrencyTable()
+ {
+ static NfCurrencyTable SINGLETON;
+ return SINGLETON;
+ }
+
+ /** THE set of installed locales. */
+ std::set< LanguageType > theInstalledLocales;
+
+}
+sal_uInt16 SvNumberFormatter::nSystemCurrencyPosition = 0;
+
+// Whether BankSymbol (not CurrencySymbol!) is always at the end (1 $;-1 $) or
+// language dependent.
+#define NF_BANKSYMBOL_FIX_POSITION 1
+
+const sal_uInt16 SvNumberFormatter::UNLIMITED_PRECISION = ::std::numeric_limits<sal_uInt16>::max();
+const sal_uInt16 SvNumberFormatter::INPUTSTRING_PRECISION = ::std::numeric_limits<sal_uInt16>::max()-1;
+
+SvNumberFormatter::SvNumberFormatter( const Reference< XComponentContext >& rxContext,
+ LanguageType eLang )
+ : m_xContext( rxContext )
+ , maLanguageTag( eLang)
+{
+ ImpConstruct( eLang );
+}
+
+SvNumberFormatter::~SvNumberFormatter()
+{
+ {
+ ::osl::MutexGuard aGuard( GetGlobalMutex() );
+ pFormatterRegistry->Remove( this );
+ if ( !pFormatterRegistry->Count() )
+ {
+ delete pFormatterRegistry;
+ pFormatterRegistry = nullptr;
+ }
+ }
+
+ aFTable.clear();
+ ClearMergeTable();
+}
+
+
+void SvNumberFormatter::ImpConstruct( LanguageType eLang )
+{
+ if ( eLang == LANGUAGE_DONTKNOW )
+ {
+ eLang = UNKNOWN_SUBSTITUTE;
+ }
+ IniLnge = eLang;
+ ActLnge = eLang;
+ eEvalDateFormat = NF_EVALDATEFORMAT_INTL;
+ nDefaultSystemCurrencyFormat = NUMBERFORMAT_ENTRY_NOT_FOUND;
+
+ maLanguageTag.reset( eLang );
+ xCharClass.changeLocale( m_xContext, maLanguageTag );
+ xLocaleData.init( m_xContext, maLanguageTag );
+ xCalendar.init( m_xContext, maLanguageTag.getLocale() );
+ xTransliteration.init( m_xContext, eLang );
+ xNatNum.init( m_xContext );
+
+ // cached locale data items
+ const LocaleDataWrapper* pLoc = GetLocaleData();
+ aDecimalSep = pLoc->getNumDecimalSep();
+ aDecimalSepAlt = pLoc->getNumDecimalSepAlt();
+ aThousandSep = pLoc->getNumThousandSep();
+ aDateSep = pLoc->getDateSep();
+
+ pStringScanner.reset( new ImpSvNumberInputScan( this ) );
+ pFormatScanner.reset( new ImpSvNumberformatScan( this ) );
+ pFormatTable = nullptr;
+ MaxCLOffset = 0;
+ ImpGenerateFormats( 0, false ); // 0 .. 999 for initialized language formats
+ pMergeTable = nullptr;
+ bNoZero = false;
+
+ ::osl::MutexGuard aGuard( GetGlobalMutex() );
+ GetFormatterRegistry().Insert( this );
+}
+
+
+void SvNumberFormatter::ChangeIntl(LanguageType eLnge)
+{
+ ::osl::MutexGuard aGuard( GetInstanceMutex() );
+ if (ActLnge == eLnge)
+ return;
+
+ ActLnge = eLnge;
+
+ maLanguageTag.reset( eLnge );
+ xCharClass.changeLocale( m_xContext, maLanguageTag );
+ xLocaleData.changeLocale( maLanguageTag );
+ xCalendar.changeLocale( maLanguageTag.getLocale() );
+ xTransliteration.changeLocale( eLnge );
+
+ // cached locale data items, initialize BEFORE calling ChangeIntl below
+ const LocaleDataWrapper* pLoc = GetLocaleData();
+ aDecimalSep = pLoc->getNumDecimalSep();
+ aDecimalSepAlt = pLoc->getNumDecimalSepAlt();
+ aThousandSep = pLoc->getNumThousandSep();
+ aDateSep = pLoc->getDateSep();
+
+ pFormatScanner->ChangeIntl();
+ pStringScanner->ChangeIntl();
+}
+
+
+// static
+::osl::Mutex& SvNumberFormatter::GetGlobalMutex()
+{
+ // #i77768# Due to a static reference in the toolkit lib
+ // we need a mutex that lives longer than the svl library.
+ // Otherwise the dtor would use a destructed mutex!!
+ static osl::Mutex* persistentMutex(new osl::Mutex);
+
+ return *persistentMutex;
+}
+
+
+// static
+SvNumberFormatterRegistry_Impl& SvNumberFormatter::GetFormatterRegistry()
+{
+ ::osl::MutexGuard aGuard( GetGlobalMutex() );
+ if ( !pFormatterRegistry )
+ {
+ pFormatterRegistry = new SvNumberFormatterRegistry_Impl;
+ }
+ return *pFormatterRegistry;
+}
+
+void SvNumberFormatter::SetColorLink( const Link<sal_uInt16,Color*>& rColorTableCallBack )
+{
+ ::osl::MutexGuard aGuard( GetInstanceMutex() );
+ aColorLink = rColorTableCallBack;
+}
+
+Color* SvNumberFormatter::GetUserDefColor(sal_uInt16 nIndex)
+{
+ ::osl::MutexGuard aGuard( GetInstanceMutex() );
+ if( aColorLink.IsSet() )
+ {
+ return aColorLink.Call(nIndex);
+ }
+ else
+ {
+ return nullptr;
+ }
+}
+
+void SvNumberFormatter::ChangeNullDate(sal_uInt16 nDay,
+ sal_uInt16 nMonth,
+ sal_Int16 nYear)
+{
+ ::osl::MutexGuard aGuard( GetInstanceMutex() );
+ pFormatScanner->ChangeNullDate(nDay, nMonth, nYear);
+ pStringScanner->ChangeNullDate(nDay, nMonth, nYear);
+}
+
+const Date& SvNumberFormatter::GetNullDate() const
+{
+ ::osl::MutexGuard aGuard( GetInstanceMutex() );
+ return pFormatScanner->GetNullDate();
+}
+
+void SvNumberFormatter::ChangeStandardPrec(short nPrec)
+{
+ ::osl::MutexGuard aGuard( GetInstanceMutex() );
+ pFormatScanner->ChangeStandardPrec(nPrec);
+}
+
+void SvNumberFormatter::SetNoZero(bool bNZ)
+{
+ ::osl::MutexGuard aGuard( GetInstanceMutex() );
+ bNoZero = bNZ;
+}
+
+sal_uInt16 SvNumberFormatter::GetStandardPrec() const
+{
+ ::osl::MutexGuard aGuard( GetInstanceMutex() );
+ return pFormatScanner->GetStandardPrec();
+}
+
+bool SvNumberFormatter::GetNoZero() const
+{
+ ::osl::MutexGuard aGuard( GetInstanceMutex() );
+ return bNoZero;
+}
+
+void SvNumberFormatter::ReplaceSystemCL( LanguageType eOldLanguage )
+{
+ sal_uInt32 nCLOffset = ImpGetCLOffset( LANGUAGE_SYSTEM );
+ if ( nCLOffset > MaxCLOffset )
+ {
+ return ; // no SYSTEM entries to replace
+ }
+ const sal_uInt32 nMaxBuiltin = nCLOffset + SV_MAX_COUNT_STANDARD_FORMATS;
+ const sal_uInt32 nNextCL = nCLOffset + SV_COUNTRY_LANGUAGE_OFFSET;
+ sal_uInt32 nKey;
+
+ // remove old builtin formats
+ auto it = aFTable.find( nCLOffset );
+ while ( it != aFTable.end() && (nKey = it->first) >= nCLOffset && nKey <= nMaxBuiltin )
+ {
+ it = aFTable.erase(it);
+ }
+
+ // move additional and user defined to temporary table
+ SvNumberFormatTable aOldTable;
+ while ( it != aFTable.end() && (nKey = it->first) >= nCLOffset && nKey < nNextCL )
+ {
+ aOldTable[ nKey ] = it->second.release();
+ it = aFTable.erase(it);
+ }
+
+ // generate new old builtin formats
+ // reset ActLnge otherwise ChangeIntl() wouldn't switch if already LANGUAGE_SYSTEM
+ ActLnge = LANGUAGE_DONTKNOW;
+ ChangeIntl( LANGUAGE_SYSTEM );
+ ImpGenerateFormats( nCLOffset, true );
+
+ // convert additional and user defined from old system to new system
+ SvNumberformat* pStdFormat = GetFormatEntry( nCLOffset + ZF_STANDARD );
+ sal_uInt32 nLastKey = nMaxBuiltin;
+ pFormatScanner->SetConvertMode( eOldLanguage, LANGUAGE_SYSTEM, true , true);
+ while ( !aOldTable.empty() )
+ {
+ nKey = aOldTable.begin()->first;
+ if ( nLastKey < nKey )
+ {
+ nLastKey = nKey;
+ }
+ std::unique_ptr<SvNumberformat> pOldEntry(aOldTable.begin()->second);
+ aOldTable.erase( nKey );
+ OUString aString( pOldEntry->GetFormatstring() );
+
+ // Same as PutEntry() but assures key position even if format code is
+ // a duplicate. Also won't mix up any LastInsertKey.
+ ChangeIntl( eOldLanguage );
+ LanguageType eLge = eOldLanguage; // ConvertMode changes this
+ bool bCheck = false;
+ sal_Int32 nCheckPos = -1;
+ std::unique_ptr<SvNumberformat> pNewEntry(new SvNumberformat( aString, pFormatScanner.get(),
+ pStringScanner.get(), nCheckPos, eLge ));
+ if ( nCheckPos == 0 )
+ {
+ SvNumFormatType eCheckType = pNewEntry->GetType();
+ if ( eCheckType != SvNumFormatType::UNDEFINED )
+ {
+ pNewEntry->SetType( eCheckType | SvNumFormatType::DEFINED );
+ }
+ else
+ {
+ pNewEntry->SetType( SvNumFormatType::DEFINED );
+ }
+
+ if ( aFTable.emplace( nKey, std::move(pNewEntry) ).second )
+ {
+ bCheck = true;
+ }
+ }
+ DBG_ASSERT( bCheck, "SvNumberFormatter::ReplaceSystemCL: couldn't convert" );
+ }
+ pFormatScanner->SetConvertMode(false);
+ pStdFormat->SetLastInsertKey( sal_uInt16(nLastKey - nCLOffset), SvNumberformat::FormatterPrivateAccess() );
+
+ // append new system additional formats
+ css::uno::Reference< css::i18n::XNumberFormatCode > xNFC = i18n::NumberFormatMapper::create( m_xContext );
+ ImpGenerateAdditionalFormats( nCLOffset, xNFC, true );
+}
+
+const css::uno::Reference<css::uno::XComponentContext>& SvNumberFormatter::GetComponentContext() const
+{
+ return m_xContext;
+}
+
+const ImpSvNumberformatScan* SvNumberFormatter::GetFormatScanner() const { return pFormatScanner.get(); }
+
+const LanguageTag& SvNumberFormatter::GetLanguageTag() const { return maLanguageTag; }
+
+const ::utl::TransliterationWrapper* SvNumberFormatter::GetTransliteration() const
+{
+ return xTransliteration.get();
+}
+
+const CharClass* SvNumberFormatter::GetCharClass() const { return xCharClass.get(); }
+
+const LocaleDataWrapper* SvNumberFormatter::GetLocaleData() const { return xLocaleData.get(); }
+
+CalendarWrapper* SvNumberFormatter::GetCalendar() const { return xCalendar.get(); }
+
+const NativeNumberWrapper* SvNumberFormatter::GetNatNum() const { return xNatNum.get(); }
+
+const OUString& SvNumberFormatter::GetNumDecimalSep() const { return aDecimalSep; }
+
+const OUString& SvNumberFormatter::GetNumDecimalSepAlt() const { return aDecimalSepAlt; }
+
+const OUString& SvNumberFormatter::GetNumThousandSep() const { return aThousandSep; }
+
+const OUString& SvNumberFormatter::GetDateSep() const { return aDateSep; }
+
+bool SvNumberFormatter::IsDecimalSep( std::u16string_view rStr ) const
+{
+ if (rStr == GetNumDecimalSep())
+ return true;
+ if (GetNumDecimalSepAlt().isEmpty())
+ return false;
+ return rStr == GetNumDecimalSepAlt();
+}
+
+bool SvNumberFormatter::IsTextFormat(sal_uInt32 F_Index) const
+{
+ ::osl::MutexGuard aGuard( GetInstanceMutex() );
+ const SvNumberformat* pFormat = GetFormatEntry(F_Index);
+
+ return pFormat && pFormat->IsTextFormat();
+}
+
+bool SvNumberFormatter::PutEntry(OUString& rString,
+ sal_Int32& nCheckPos,
+ SvNumFormatType& nType,
+ sal_uInt32& nKey, // format key
+ LanguageType eLnge,
+ bool bReplaceBooleanEquivalent)
+{
+ ::osl::MutexGuard aGuard( GetInstanceMutex() );
+ nKey = 0;
+ if (rString.isEmpty()) // empty string
+ {
+ nCheckPos = 1; // -> Error
+ return false;
+ }
+ if (eLnge == LANGUAGE_DONTKNOW)
+ {
+ eLnge = IniLnge;
+ }
+ ChangeIntl(eLnge); // change locale if necessary
+ LanguageType eLge = eLnge; // non-const for ConvertMode
+ bool bCheck = false;
+ std::unique_ptr<SvNumberformat> p_Entry(new SvNumberformat(rString,
+ pFormatScanner.get(),
+ pStringScanner.get(),
+ nCheckPos,
+ eLge,
+ bReplaceBooleanEquivalent));
+
+ if (nCheckPos == 0) // Format ok
+ { // Type comparison:
+ SvNumFormatType eCheckType = p_Entry->GetType();
+ if ( eCheckType != SvNumFormatType::UNDEFINED)
+ {
+ p_Entry->SetType(eCheckType | SvNumFormatType::DEFINED);
+ nType = eCheckType;
+ }
+ else
+ {
+ p_Entry->SetType(SvNumFormatType::DEFINED);
+ nType = SvNumFormatType::DEFINED;
+ }
+
+ sal_uInt32 CLOffset = ImpGenerateCL(eLge); // create new standard formats if necessary
+
+ nKey = ImpIsEntry(p_Entry->GetFormatstring(),CLOffset, eLge);
+ if (nKey == NUMBERFORMAT_ENTRY_NOT_FOUND) // only in not yet present
+ {
+ SvNumberformat* pStdFormat = GetFormatEntry(CLOffset + ZF_STANDARD);
+ sal_uInt32 nPos = CLOffset + pStdFormat->GetLastInsertKey( SvNumberformat::FormatterPrivateAccess() );
+ if (nPos+1 - CLOffset >= SV_COUNTRY_LANGUAGE_OFFSET)
+ {
+ SAL_WARN( "svl.numbers", "SvNumberFormatter::PutEntry: too many formats for CL");
+ }
+ else if (!aFTable.emplace( nPos+1, std::move(p_Entry)).second)
+ {
+ SAL_WARN( "svl.numbers", "SvNumberFormatter::PutEntry: dup position");
+ }
+ else
+ {
+ bCheck = true;
+ nKey = nPos+1;
+ pStdFormat->SetLastInsertKey(static_cast<sal_uInt16>(nKey-CLOffset), SvNumberformat::FormatterPrivateAccess());
+ }
+ }
+ }
+ return bCheck;
+}
+
+bool SvNumberFormatter::PutandConvertEntry(OUString& rString,
+ sal_Int32& nCheckPos,
+ SvNumFormatType& nType,
+ sal_uInt32& nKey,
+ LanguageType eLnge,
+ LanguageType eNewLnge,
+ bool bConvertDateOrder,
+ bool bReplaceBooleanEquivalent )
+{
+ ::osl::MutexGuard aGuard( GetInstanceMutex() );
+ bool bRes;
+ if (eNewLnge == LANGUAGE_DONTKNOW)
+ {
+ eNewLnge = IniLnge;
+ }
+ pFormatScanner->SetConvertMode(eLnge, eNewLnge, false, bConvertDateOrder);
+ bRes = PutEntry(rString, nCheckPos, nType, nKey, eLnge, bReplaceBooleanEquivalent);
+ pFormatScanner->SetConvertMode(false);
+
+ if (bReplaceBooleanEquivalent && nCheckPos == 0 && nType == SvNumFormatType::DEFINED
+ && nKey != NUMBERFORMAT_ENTRY_NOT_FOUND)
+ {
+ // The boolean string formats are always "user defined" without any
+ // other type.
+ const SvNumberformat* pEntry = GetFormatEntry(nKey);
+ if (pEntry && pEntry->GetType() == SvNumFormatType::DEFINED)
+ {
+ // Replace boolean string format with Boolean in target locale, in
+ // case the source strings are the target locale's.
+ const OUString aSaveString = rString;
+ ChangeIntl(eNewLnge);
+ if (pFormatScanner->ReplaceBooleanEquivalent( rString))
+ {
+ const sal_Int32 nSaveCheckPos = nCheckPos;
+ const SvNumFormatType nSaveType = nType;
+ const sal_uInt32 nSaveKey = nKey;
+ const bool bTargetRes = PutEntry(rString, nCheckPos, nType, nKey, eNewLnge, false);
+ if (nCheckPos == 0 && nType == SvNumFormatType::LOGICAL && nKey != NUMBERFORMAT_ENTRY_NOT_FOUND)
+ {
+ bRes = bTargetRes;
+ }
+ else
+ {
+ SAL_WARN("svl.numbers", "SvNumberFormatter::PutandConvertEntry: can't scan boolean replacement");
+ // Live with the source boolean string format.
+ rString = aSaveString;
+ nCheckPos = nSaveCheckPos;
+ nType = nSaveType;
+ nKey = nSaveKey;
+ }
+ }
+ }
+ }
+ return bRes;
+}
+
+bool SvNumberFormatter::PutandConvertEntrySystem(OUString& rString,
+ sal_Int32& nCheckPos,
+ SvNumFormatType& nType,
+ sal_uInt32& nKey,
+ LanguageType eLnge,
+ LanguageType eNewLnge)
+{
+ ::osl::MutexGuard aGuard( GetInstanceMutex() );
+ bool bRes;
+ if (eNewLnge == LANGUAGE_DONTKNOW)
+ {
+ eNewLnge = IniLnge;
+ }
+ pFormatScanner->SetConvertMode(eLnge, eNewLnge, true, true);
+ bRes = PutEntry(rString, nCheckPos, nType, nKey, eLnge);
+ pFormatScanner->SetConvertMode(false);
+ return bRes;
+}
+
+sal_uInt32 SvNumberFormatter::GetIndexPuttingAndConverting( OUString & rString, LanguageType eLnge,
+ LanguageType eSysLnge, SvNumFormatType & rType,
+ bool & rNewInserted, sal_Int32 & rCheckPos )
+{
+ ::osl::MutexGuard aGuard( GetInstanceMutex() );
+ sal_uInt32 nKey = NUMBERFORMAT_ENTRY_NOT_FOUND;
+ rNewInserted = false;
+ rCheckPos = 0;
+
+ // #62389# empty format string (of Writer) => General standard format
+ if (rString.isEmpty())
+ {
+ // nothing
+ }
+ else if (eLnge == LANGUAGE_SYSTEM && eSysLnge != SvtSysLocale().GetLanguageTag().getLanguageType())
+ {
+ sal_uInt32 nOrig = GetEntryKey( rString, eSysLnge );
+ if (nOrig == NUMBERFORMAT_ENTRY_NOT_FOUND)
+ {
+ nKey = nOrig; // none available, maybe user-defined
+ }
+ else
+ {
+ nKey = GetFormatForLanguageIfBuiltIn( nOrig, SvtSysLocale().GetLanguageTag().getLanguageType() );
+ }
+ if (nKey == nOrig)
+ {
+ // Not a builtin format, convert.
+ // The format code string may get modified and adapted to the real
+ // language and wouldn't match eSysLnge anymore, do that on a copy.
+ OUString aTmp( rString);
+ rNewInserted = PutandConvertEntrySystem( aTmp, rCheckPos, rType,
+ nKey, eLnge, SvtSysLocale().GetLanguageTag().getLanguageType());
+ if (rCheckPos > 0)
+ {
+ SAL_WARN( "svl.numbers", "SvNumberFormatter::GetIndexPuttingAndConverting: bad format code string for current locale");
+ nKey = NUMBERFORMAT_ENTRY_NOT_FOUND;
+ }
+ }
+ }
+ else
+ {
+ nKey = GetEntryKey( rString, eLnge);
+ if (nKey == NUMBERFORMAT_ENTRY_NOT_FOUND)
+ {
+ rNewInserted = PutEntry( rString, rCheckPos, rType, nKey, eLnge);
+ if (rCheckPos > 0)
+ {
+ SAL_WARN( "svl.numbers", "SvNumberFormatter::GetIndexPuttingAndConverting: bad format code string for specified locale");
+ nKey = NUMBERFORMAT_ENTRY_NOT_FOUND;
+ }
+ }
+ }
+ if (nKey == NUMBERFORMAT_ENTRY_NOT_FOUND)
+ {
+ nKey = GetStandardIndex( eLnge);
+ }
+ rType = GetType( nKey);
+ // Convert any (!) old "automatic" currency format to new fixed currency
+ // default format.
+ if (rType & SvNumFormatType::CURRENCY)
+ {
+ const SvNumberformat* pFormat = GetEntry( nKey);
+ if (!pFormat->HasNewCurrency())
+ {
+ if (rNewInserted)
+ {
+ DeleteEntry( nKey); // don't leave trails of rubbish
+ rNewInserted = false;
+ }
+ nKey = GetStandardFormat( SvNumFormatType::CURRENCY, eLnge);
+ }
+ }
+ return nKey;
+}
+
+void SvNumberFormatter::DeleteEntry(sal_uInt32 nKey)
+{
+ ::osl::MutexGuard aGuard( GetInstanceMutex() );
+ aFTable.erase(nKey);
+}
+
+void SvNumberFormatter::GetUsedLanguages( std::vector<LanguageType>& rList )
+{
+ ::osl::MutexGuard aGuard( GetInstanceMutex() );
+ rList.clear();
+
+ sal_uInt32 nOffset = 0;
+ while (nOffset <= MaxCLOffset)
+ {
+ SvNumberformat* pFormat = GetFormatEntry(nOffset);
+ if (pFormat)
+ {
+ rList.push_back( pFormat->GetLanguage() );
+ }
+ nOffset += SV_COUNTRY_LANGUAGE_OFFSET;
+ }
+}
+
+
+void SvNumberFormatter::FillKeywordTable( NfKeywordTable& rKeywords,
+ LanguageType eLang )
+{
+ ::osl::MutexGuard aGuard( GetInstanceMutex() );
+ ChangeIntl( eLang );
+ const NfKeywordTable & rTable = pFormatScanner->GetKeywords();
+ for ( sal_uInt16 i = 0; i < NF_KEYWORD_ENTRIES_COUNT; ++i )
+ {
+ rKeywords[i] = rTable[i];
+ }
+}
+
+
+void SvNumberFormatter::FillKeywordTableForExcel( NfKeywordTable& rKeywords )
+{
+ ::osl::MutexGuard aGuard( GetInstanceMutex() );
+ FillKeywordTable( rKeywords, LANGUAGE_ENGLISH_US );
+
+ // Replace upper case "GENERAL" with proper case "General".
+ rKeywords[ NF_KEY_GENERAL ] = GetStandardName( LANGUAGE_ENGLISH_US );
+
+ // Excel or OOXML do not specify format code keywords case sensitivity,
+ // but given and writes them lower case. Using upper case even lead to an
+ // odd misrepresentation in iOS viewer and OSX Quicklook viewer that
+ // strangely use "D" and "DD" for "days since beginning of year", which is
+ // nowhere defined. See tdf#126773
+ // Use lower case for all date and time keywords where known. See OOXML
+ // ECMA-376-1:2016 18.8.31 numFmts (Number Formats)
+ rKeywords[ NF_KEY_MI ] = "m";
+ rKeywords[ NF_KEY_MMI ] = "mm";
+ rKeywords[ NF_KEY_M ] = "m";
+ rKeywords[ NF_KEY_MM ] = "mm";
+ rKeywords[ NF_KEY_MMM ] = "mmm";
+ rKeywords[ NF_KEY_MMMM ] = "mmmm";
+ rKeywords[ NF_KEY_MMMMM ] = "mmmmm";
+ rKeywords[ NF_KEY_H ] = "h";
+ rKeywords[ NF_KEY_HH ] = "hh";
+ rKeywords[ NF_KEY_S ] = "s";
+ rKeywords[ NF_KEY_SS ] = "ss";
+ /* XXX: not defined in OOXML: rKeywords[ NF_KEY_Q ] = "q"; */
+ /* XXX: not defined in OOXML: rKeywords[ NF_KEY_QQ ] = "qq"; */
+ rKeywords[ NF_KEY_D ] = "d";
+ rKeywords[ NF_KEY_DD ] = "dd";
+ rKeywords[ NF_KEY_DDD ] = "ddd";
+ rKeywords[ NF_KEY_DDDD ] = "dddd";
+ rKeywords[ NF_KEY_YY ] = "yy";
+ rKeywords[ NF_KEY_YYYY ] = "yyyy";
+ /* XXX: not defined in OOXML: rKeywords[ NF_KEY_AAA ] = "aaa"; */
+ /* XXX: not defined in OOXML: rKeywords[ NF_KEY_AAAA ] = "aaaa"; */
+ rKeywords[ NF_KEY_EC ] = "e";
+ rKeywords[ NF_KEY_EEC ] = "ee";
+ rKeywords[ NF_KEY_G ] = "g";
+ rKeywords[ NF_KEY_GG ] = "gg";
+ rKeywords[ NF_KEY_GGG ] = "ggg";
+ rKeywords[ NF_KEY_R ] = "r";
+ rKeywords[ NF_KEY_RR ] = "rr";
+ /* XXX: not defined in OOXML: rKeywords[ NF_KEY_WW ] = "ww"; */
+
+ // Remap codes unknown to Excel.
+ rKeywords[ NF_KEY_NN ] = "ddd";
+ rKeywords[ NF_KEY_NNN ] = "dddd";
+ // NNNN gets a separator appended in SvNumberformat::GetMappedFormatString()
+ rKeywords[ NF_KEY_NNNN ] = "dddd";
+ // Export the Thai T NatNum modifier. This must be uppercase for internal reasons.
+ rKeywords[ NF_KEY_THAI_T ] = "T";
+}
+
+
+static OUString lcl_buildBooleanStringFormat( SvNumberformat* pEntry )
+{
+ // Build Boolean number format, which needs non-zero and zero subformat
+ // codes with TRUE and FALSE strings.
+ const Color* pColor = nullptr;
+ OUString aFormatStr, aTemp;
+ pEntry->GetOutputString( 1.0, aTemp, &pColor );
+ aFormatStr += "\"" + aTemp + "\";\"" + aTemp + "\";\"";
+ pEntry->GetOutputString( 0.0, aTemp, &pColor );
+ aFormatStr += aTemp + "\"";
+ return aFormatStr;
+}
+
+
+OUString SvNumberFormatter::GetFormatStringForExcel( sal_uInt32 nKey, const NfKeywordTable& rKeywords,
+ SvNumberFormatter& rTempFormatter ) const
+{
+ ::osl::MutexGuard aGuard( GetInstanceMutex() );
+ OUString aFormatStr;
+ if (const SvNumberformat* pEntry = GetEntry( nKey))
+ {
+ if (pEntry->GetType() == SvNumFormatType::LOGICAL)
+ {
+ // Build a source locale dependent string boolean. This is
+ // expected when loading the document in the same locale or if
+ // several locales are used, but not for other system/default
+ // locales. You can't have both. We could force to English for all
+ // locales like below, but Excel would display English strings then
+ // even for the system locale matching this locale. YMMV.
+ aFormatStr = lcl_buildBooleanStringFormat( const_cast< SvNumberformat* >(pEntry));
+ }
+ else
+ {
+ bool bSystemLanguage = false;
+ LanguageType nLang = pEntry->GetLanguage();
+ if (nLang == LANGUAGE_SYSTEM)
+ {
+ bSystemLanguage = true;
+ nLang = SvtSysLocale().GetLanguageTag().getLanguageType();
+ }
+ if (nLang != LANGUAGE_ENGLISH_US)
+ {
+ sal_Int32 nCheckPos;
+ SvNumFormatType nType = SvNumFormatType::DEFINED;
+ sal_uInt32 nTempKey;
+ OUString aTemp( pEntry->GetFormatstring());
+ /* TODO: do we want bReplaceBooleanEquivalent=true in any case
+ * to write it as English string boolean? */
+ rTempFormatter.PutandConvertEntry( aTemp, nCheckPos, nType, nTempKey, nLang, LANGUAGE_ENGLISH_US,
+ false /*bConvertDateOrder*/, false /*bReplaceBooleanEquivalent*/);
+ SAL_WARN_IF( nCheckPos != 0, "svl.numbers",
+ "SvNumberFormatter::GetFormatStringForExcel - format code not convertible");
+ if (nTempKey != NUMBERFORMAT_ENTRY_NOT_FOUND)
+ pEntry = rTempFormatter.GetEntry( nTempKey);
+ }
+
+ if (pEntry)
+ {
+ if (pEntry->GetType() == SvNumFormatType::LOGICAL)
+ {
+ // This would be reached if bReplaceBooleanEquivalent was
+ // true and the source format is a string boolean like
+ // >"VRAI";"VRAI";"FAUX"< recognized as real boolean and
+ // properly converted. Then written as
+ // >"TRUE";"TRUE";"FALSE"<
+ aFormatStr = lcl_buildBooleanStringFormat( const_cast< SvNumberformat* >(pEntry));
+ }
+ else
+ {
+ // GetLocaleData() returns the current locale's data, so switch
+ // before (which doesn't do anything if it was the same locale
+ // already).
+ rTempFormatter.ChangeIntl( LANGUAGE_ENGLISH_US);
+ aFormatStr = pEntry->GetMappedFormatstring( rKeywords, *rTempFormatter.GetLocaleData(), nLang,
+ bSystemLanguage);
+ }
+ }
+ }
+ }
+ else
+ {
+ SAL_WARN("svl.numbers","SvNumberFormatter::GetFormatStringForExcel - format not found: " << nKey);
+ }
+
+ if (aFormatStr.isEmpty())
+ aFormatStr = "General";
+ return aFormatStr;
+}
+
+
+OUString SvNumberFormatter::GetKeyword( LanguageType eLnge, sal_uInt16 nIndex )
+{
+ ::osl::MutexGuard aGuard( GetInstanceMutex() );
+ ChangeIntl(eLnge);
+ const NfKeywordTable & rTable = pFormatScanner->GetKeywords();
+ if ( nIndex < NF_KEYWORD_ENTRIES_COUNT )
+ {
+ return rTable[nIndex];
+ }
+ SAL_WARN( "svl.numbers", "GetKeyword: invalid index");
+ return OUString();
+}
+
+
+OUString SvNumberFormatter::GetStandardName( LanguageType eLnge )
+{
+ ::osl::MutexGuard aGuard( GetInstanceMutex() );
+ ChangeIntl( eLnge );
+ return pFormatScanner->GetStandardName();
+}
+
+
+sal_uInt32 SvNumberFormatter::ImpGetCLOffset(LanguageType eLnge) const
+{
+ sal_uInt32 nOffset = 0;
+ while (nOffset <= MaxCLOffset)
+ {
+ const SvNumberformat* pFormat = GetFormatEntry(nOffset);
+ if (pFormat && pFormat->GetLanguage() == eLnge)
+ {
+ return nOffset;
+ }
+ nOffset += SV_COUNTRY_LANGUAGE_OFFSET;
+ }
+ return nOffset;
+}
+
+sal_uInt32 SvNumberFormatter::ImpIsEntry(std::u16string_view rString,
+ sal_uInt32 nCLOffset,
+ LanguageType eLnge)
+{
+ sal_uInt32 res = NUMBERFORMAT_ENTRY_NOT_FOUND;
+ auto it = aFTable.find( nCLOffset);
+ while ( res == NUMBERFORMAT_ENTRY_NOT_FOUND &&
+ it != aFTable.end() && it->second->GetLanguage() == eLnge )
+ {
+ if ( rString == it->second->GetFormatstring() )
+ {
+ res = it->first;
+ }
+ else
+ {
+ ++it;
+ }
+ }
+ return res;
+}
+
+
+SvNumberFormatTable& SvNumberFormatter::GetFirstEntryTable(
+ SvNumFormatType& eType,
+ sal_uInt32& FIndex,
+ LanguageType& rLnge)
+{
+ ::osl::MutexGuard aGuard( GetInstanceMutex() );
+ SvNumFormatType eTypetmp = eType;
+ if (eType == SvNumFormatType::ALL) // empty cell or don't care
+ {
+ rLnge = IniLnge;
+ }
+ else
+ {
+ SvNumberformat* pFormat = GetFormatEntry(FIndex);
+ if (!pFormat)
+ {
+ rLnge = IniLnge;
+ eType = SvNumFormatType::ALL;
+ eTypetmp = eType;
+ }
+ else
+ {
+ rLnge = pFormat->GetLanguage();
+ eType = pFormat->GetMaskedType();
+ if (eType == SvNumFormatType::ALL)
+ {
+ eType = SvNumFormatType::DEFINED;
+ eTypetmp = eType;
+ }
+ else if (eType == SvNumFormatType::DATETIME)
+ {
+ eTypetmp = eType;
+ eType = SvNumFormatType::DATE;
+ }
+ else
+ {
+ eTypetmp = eType;
+ }
+ }
+ }
+ ChangeIntl(rLnge);
+ return GetEntryTable(eTypetmp, FIndex, rLnge);
+}
+
+sal_uInt32 SvNumberFormatter::ImpGenerateCL( LanguageType eLnge )
+{
+ ChangeIntl(eLnge);
+ sal_uInt32 CLOffset = ImpGetCLOffset(ActLnge);
+ if (CLOffset > MaxCLOffset)
+ {
+ // new CL combination
+ if (LocaleDataWrapper::areChecksEnabled())
+ {
+ const LanguageTag& rLoadedLocale = xLocaleData->getLoadedLanguageTag();
+ if ( !rLoadedLocale.equals( maLanguageTag ) )
+ {
+ LocaleDataWrapper::outputCheckMessage( xLocaleData->appendLocaleInfo( u"SvNumberFormatter::ImpGenerateCL: locales don't match:" ));
+ }
+ // test XML locale data FormatElement entries
+ {
+ uno::Sequence< i18n::FormatElement > xSeq = xLocaleData->getAllFormats();
+ // A test for completeness of formatindex="0" ...
+ // formatindex="47" is not needed here since it is done in
+ // ImpGenerateFormats().
+
+ // Test for dupes of formatindex="..."
+ for ( sal_Int32 j = 0; j < xSeq.getLength(); j++ )
+ {
+ sal_Int16 nIdx = xSeq[j].formatIndex;
+ OUStringBuffer aDupes;
+ for ( sal_Int32 i = 0; i < xSeq.getLength(); i++ )
+ {
+ if ( i != j && xSeq[i].formatIndex == nIdx )
+ {
+ aDupes.append( i );
+ aDupes.append("(");
+ aDupes.append(xSeq[i].formatKey);
+ aDupes.append( ") ");
+ }
+ }
+ if ( !aDupes.isEmpty() )
+ {
+ OUString aMsg = "XML locale data FormatElement formatindex dupe: "
+ + OUString::number(nIdx)
+ + "\nFormatElements: "
+ + OUString::number( j )
+ + "("
+ + xSeq[j].formatKey
+ + ") "
+ + aDupes.makeStringAndClear();
+ LocaleDataWrapper::outputCheckMessage( xLocaleData->appendLocaleInfo( aMsg ));
+ }
+ }
+ }
+ }
+
+ MaxCLOffset += SV_COUNTRY_LANGUAGE_OFFSET;
+ ImpGenerateFormats( MaxCLOffset, false/*bNoAdditionalFormats*/ );
+ CLOffset = MaxCLOffset;
+ }
+ return CLOffset;
+}
+
+SvNumberFormatTable& SvNumberFormatter::ChangeCL(SvNumFormatType eType,
+ sal_uInt32& FIndex,
+ LanguageType eLnge)
+{
+ ::osl::MutexGuard aGuard( GetInstanceMutex() );
+ ImpGenerateCL(eLnge);
+ return GetEntryTable(eType, FIndex, ActLnge);
+}
+
+SvNumberFormatTable& SvNumberFormatter::GetEntryTable(
+ SvNumFormatType eType,
+ sal_uInt32& FIndex,
+ LanguageType eLnge)
+{
+ ::osl::MutexGuard aGuard( GetInstanceMutex() );
+ if ( pFormatTable )
+ {
+ pFormatTable->clear();
+ }
+ else
+ {
+ pFormatTable.reset( new SvNumberFormatTable );
+ }
+ ChangeIntl(eLnge);
+ sal_uInt32 CLOffset = ImpGetCLOffset(ActLnge);
+
+ // Might generate and insert a default format for the given type
+ // (e.g. currency) => has to be done before collecting formats.
+ sal_uInt32 nDefaultIndex = GetStandardFormat( eType, ActLnge );
+
+ auto it = aFTable.find( CLOffset);
+
+ if (eType == SvNumFormatType::ALL)
+ {
+ while (it != aFTable.end() && it->second->GetLanguage() == ActLnge)
+ { // copy all entries to output table
+ (*pFormatTable)[ it->first ] = it->second.get();
+ ++it;
+ }
+ }
+ else
+ {
+ while (it != aFTable.end() && it->second->GetLanguage() == ActLnge)
+ { // copy entries of queried type to output table
+ if ((it->second->GetType()) & eType)
+ (*pFormatTable)[ it->first ] = it->second.get();
+ ++it;
+ }
+ }
+ if ( !pFormatTable->empty() )
+ { // select default if queried format doesn't exist or queried type or
+ // language differ from existing format
+ SvNumberformat* pEntry = GetFormatEntry(FIndex);
+ if ( !pEntry || !(pEntry->GetType() & eType) || pEntry->GetLanguage() != ActLnge )
+ {
+ FIndex = nDefaultIndex;
+ }
+ }
+ return *pFormatTable;
+}
+
+bool SvNumberFormatter::IsNumberFormat(const OUString& sString,
+ sal_uInt32& F_Index,
+ double& fOutNumber,
+ SvNumInputOptions eInputOptions)
+{
+ ::osl::MutexGuard aGuard( GetInstanceMutex() );
+
+ SvNumFormatType FType;
+ // For the 0 General format directly use the init/system locale and avoid
+ // all overhead that is associated with a format passed to the scanner.
+ const SvNumberformat* pFormat = (F_Index == 0 ? nullptr : ImpSubstituteEntry( GetFormatEntry(F_Index)));
+ if (!pFormat)
+ {
+ ChangeIntl(IniLnge);
+ FType = SvNumFormatType::NUMBER;
+ }
+ else
+ {
+ FType = pFormat->GetMaskedType();
+ if (FType == SvNumFormatType::ALL)
+ {
+ FType = SvNumFormatType::DEFINED;
+ }
+ ChangeIntl(pFormat->GetLanguage());
+ // Avoid scanner overhead with the General format of any locale.
+ // These are never substituted above so safe to ignore.
+ if ((F_Index % SV_COUNTRY_LANGUAGE_OFFSET) == 0)
+ {
+ assert(FType == SvNumFormatType::NUMBER);
+ pFormat = nullptr;
+ }
+ }
+
+ bool res;
+ SvNumFormatType RType = FType;
+ if (RType == SvNumFormatType::TEXT)
+ {
+ res = false; // type text preset => no conversion to number
+ }
+ else
+ {
+ res = pStringScanner->IsNumberFormat(sString, RType, fOutNumber, pFormat, eInputOptions);
+ }
+ if (res && !IsCompatible(FType, RType)) // non-matching type
+ {
+ switch ( RType )
+ {
+ case SvNumFormatType::DATE :
+ // Preserve ISO 8601 input.
+ if (pStringScanner->CanForceToIso8601( DateOrder::Invalid))
+ {
+ F_Index = GetFormatIndex( NF_DATE_DIN_YYYYMMDD, ActLnge );
+ }
+ else
+ {
+ F_Index = GetStandardFormat( RType, ActLnge );
+ }
+ break;
+ case SvNumFormatType::TIME :
+ if ( pStringScanner->GetDecPos() )
+ {
+ // 100th seconds
+ if ( pStringScanner->GetNumericsCount() > 3 || fOutNumber < 0.0 )
+ {
+ F_Index = GetFormatIndex( NF_TIME_HH_MMSS00, ActLnge );
+ }
+ else
+ {
+ F_Index = GetFormatIndex( NF_TIME_MMSS00, ActLnge );
+ }
+ }
+ else if ( fOutNumber >= 1.0 || fOutNumber < 0.0 )
+ {
+ F_Index = GetFormatIndex( NF_TIME_HH_MMSS, ActLnge );
+ }
+ else
+ {
+ F_Index = GetStandardFormat( RType, ActLnge );
+ }
+ break;
+ case SvNumFormatType::DATETIME :
+ // Preserve ISO 8601 input.
+ if (pStringScanner->HasIso8601Tsep())
+ {
+ if (pStringScanner->GetDecPos())
+ F_Index = GetFormatIndex( NF_DATETIME_ISO_YYYYMMDDTHHMMSS000, ActLnge );
+ else
+ F_Index = GetFormatIndex( NF_DATETIME_ISO_YYYYMMDDTHHMMSS, ActLnge );
+ }
+ else if (pStringScanner->CanForceToIso8601( DateOrder::Invalid))
+ {
+ if (pStringScanner->GetDecPos())
+ F_Index = GetFormatIndex( NF_DATETIME_ISO_YYYYMMDD_HHMMSS000, ActLnge );
+ else
+ F_Index = GetFormatIndex( NF_DATETIME_ISO_YYYYMMDD_HHMMSS, ActLnge );
+ }
+ else
+ {
+ F_Index = GetStandardFormat( RType, ActLnge );
+ }
+ break;
+ default:
+ F_Index = GetStandardFormat( RType, ActLnge );
+ }
+ }
+ return res;
+}
+
+LanguageType SvNumberFormatter::GetLanguage() const
+{
+ ::osl::MutexGuard aGuard( GetInstanceMutex() );
+ return IniLnge;
+}
+
+// static
+bool SvNumberFormatter::IsCompatible(SvNumFormatType eOldType, SvNumFormatType eNewType)
+{
+ if (eOldType == eNewType)
+ {
+ return true;
+ }
+ else if (eOldType == SvNumFormatType::DEFINED)
+ {
+ return true;
+ }
+ else
+ {
+ switch (eNewType)
+ {
+ case SvNumFormatType::NUMBER:
+ switch (eOldType)
+ {
+ case SvNumFormatType::PERCENT:
+ case SvNumFormatType::CURRENCY:
+ case SvNumFormatType::SCIENTIFIC:
+ case SvNumFormatType::FRACTION:
+ case SvNumFormatType::DEFINED:
+ return true;
+ case SvNumFormatType::LOGICAL:
+ default:
+ return false;
+ }
+ break;
+ case SvNumFormatType::DATE:
+ switch (eOldType)
+ {
+ case SvNumFormatType::DATETIME:
+ return true;
+ default:
+ return false;
+ }
+ break;
+ case SvNumFormatType::TIME:
+ switch (eOldType)
+ {
+ case SvNumFormatType::DATETIME:
+ return true;
+ default:
+ return false;
+ }
+ break;
+ case SvNumFormatType::DATETIME:
+ switch (eOldType)
+ {
+ case SvNumFormatType::TIME:
+ case SvNumFormatType::DATE:
+ return true;
+ default:
+ return false;
+ }
+ break;
+ case SvNumFormatType::DURATION:
+ return false;
+ default:
+ return false;
+ }
+ }
+}
+
+
+sal_uInt32 SvNumberFormatter::ImpGetDefaultFormat( SvNumFormatType nType )
+{
+ sal_uInt32 CLOffset = ImpGetCLOffset( ActLnge );
+ sal_uInt32 nSearch;
+ switch( nType )
+ {
+ case SvNumFormatType::DATE:
+ nSearch = CLOffset + ZF_STANDARD_DATE;
+ break;
+ case SvNumFormatType::TIME:
+ nSearch = CLOffset + ZF_STANDARD_TIME;
+ break;
+ case SvNumFormatType::DATETIME:
+ nSearch = CLOffset + ZF_STANDARD_DATETIME;
+ break;
+ case SvNumFormatType::DURATION:
+ nSearch = CLOffset + ZF_STANDARD_DURATION;
+ break;
+ case SvNumFormatType::PERCENT:
+ nSearch = CLOffset + ZF_STANDARD_PERCENT;
+ break;
+ case SvNumFormatType::SCIENTIFIC:
+ nSearch = CLOffset + ZF_STANDARD_SCIENTIFIC;
+ break;
+ default:
+ nSearch = CLOffset + ZF_STANDARD;
+ }
+
+ DefaultFormatKeysMap::const_iterator it = aDefaultFormatKeys.find( nSearch);
+ sal_uInt32 nDefaultFormat = (it != aDefaultFormatKeys.end() ?
+ it->second : NUMBERFORMAT_ENTRY_NOT_FOUND);
+ if ( nDefaultFormat == NUMBERFORMAT_ENTRY_NOT_FOUND )
+ {
+ // look for a defined standard
+ sal_uInt32 nStopKey = CLOffset + SV_COUNTRY_LANGUAGE_OFFSET;
+ sal_uInt32 nKey(0);
+ auto it2 = aFTable.find( CLOffset );
+ while ( it2 != aFTable.end() && (nKey = it2->first ) >= CLOffset && nKey < nStopKey )
+ {
+ const SvNumberformat* pEntry = it2->second.get();
+ if ( pEntry->IsStandard() && (pEntry->GetMaskedType() == nType) )
+ {
+ nDefaultFormat = nKey;
+ break; // while
+ }
+ ++it2;
+ }
+
+ if ( nDefaultFormat == NUMBERFORMAT_ENTRY_NOT_FOUND )
+ { // none found, use old fixed standards
+ switch( nType )
+ {
+ case SvNumFormatType::DATE:
+ nDefaultFormat = CLOffset + ZF_STANDARD_DATE;
+ break;
+ case SvNumFormatType::TIME:
+ nDefaultFormat = CLOffset + ZF_STANDARD_TIME+1;
+ break;
+ case SvNumFormatType::DATETIME:
+ nDefaultFormat = CLOffset + ZF_STANDARD_DATETIME;
+ break;
+ case SvNumFormatType::DURATION:
+ nDefaultFormat = CLOffset + ZF_STANDARD_DURATION;
+ break;
+ case SvNumFormatType::PERCENT:
+ nDefaultFormat = CLOffset + ZF_STANDARD_PERCENT+1;
+ break;
+ case SvNumFormatType::SCIENTIFIC:
+ nDefaultFormat = CLOffset + ZF_STANDARD_SCIENTIFIC;
+ break;
+ default:
+ nDefaultFormat = CLOffset + ZF_STANDARD;
+ }
+ }
+ aDefaultFormatKeys[ nSearch ] = nDefaultFormat;
+ }
+ return nDefaultFormat;
+}
+
+
+sal_uInt32 SvNumberFormatter::GetStandardFormat( SvNumFormatType eType, LanguageType eLnge )
+{
+ ::osl::MutexGuard aGuard( GetInstanceMutex() );
+ if (eLnge == LANGUAGE_DONTKNOW)
+ {
+ eLnge = IniLnge;
+ }
+ sal_uInt32 CLOffset = ImpGenerateCL(eLnge);
+ switch(eType)
+ {
+ case SvNumFormatType::CURRENCY:
+ return ( eLnge == LANGUAGE_SYSTEM ) ? ImpGetDefaultSystemCurrencyFormat() : ImpGetDefaultCurrencyFormat();
+ case SvNumFormatType::DURATION :
+ return GetFormatIndex( NF_TIME_HH_MMSS, eLnge);
+ case SvNumFormatType::DATE:
+ case SvNumFormatType::TIME:
+ case SvNumFormatType::DATETIME:
+ case SvNumFormatType::PERCENT:
+ case SvNumFormatType::SCIENTIFIC:
+ return ImpGetDefaultFormat( eType );
+ case SvNumFormatType::FRACTION:
+ return CLOffset + ZF_STANDARD_FRACTION;
+ case SvNumFormatType::LOGICAL:
+ return CLOffset + ZF_STANDARD_LOGICAL;
+ case SvNumFormatType::TEXT:
+ return CLOffset + ZF_STANDARD_TEXT;
+ case SvNumFormatType::ALL:
+ case SvNumFormatType::DEFINED:
+ case SvNumFormatType::NUMBER:
+ case SvNumFormatType::UNDEFINED:
+ default:
+ return CLOffset + ZF_STANDARD;
+ }
+}
+
+bool SvNumberFormatter::IsSpecialStandardFormat( sal_uInt32 nFIndex,
+ LanguageType eLnge )
+{
+ ::osl::MutexGuard aGuard( GetInstanceMutex() );
+ return
+ nFIndex == GetFormatIndex( NF_TIME_MMSS00, eLnge ) ||
+ nFIndex == GetFormatIndex( NF_TIME_HH_MMSS00, eLnge ) ||
+ nFIndex == GetFormatIndex( NF_TIME_HH_MMSS, eLnge )
+ ;
+}
+
+sal_uInt32 SvNumberFormatter::GetStandardFormat( sal_uInt32 nFIndex, SvNumFormatType eType,
+ LanguageType eLnge )
+{
+ ::osl::MutexGuard aGuard( GetInstanceMutex() );
+ if ( IsSpecialStandardFormat( nFIndex, eLnge ) )
+ return nFIndex;
+ else
+ return GetStandardFormat( eType, eLnge );
+}
+
+sal_uInt32 SvNumberFormatter::GetTimeFormat( double fNumber, LanguageType eLnge, bool bForceDuration )
+{
+ ::osl::MutexGuard aGuard( GetInstanceMutex() );
+ bool bSign;
+ if ( fNumber < 0.0 )
+ {
+ bSign = true;
+ fNumber = -fNumber;
+ }
+ else
+ bSign = false;
+ double fSeconds = fNumber * 86400;
+ if ( floor( fSeconds + 0.5 ) * 100 != floor( fSeconds * 100 + 0.5 ) )
+ { // with 100th seconds
+ if ( bForceDuration || bSign || fSeconds >= 3600 )
+ return GetFormatIndex( NF_TIME_HH_MMSS00, eLnge );
+ else
+ return GetFormatIndex( NF_TIME_MMSS00, eLnge );
+ }
+ else
+ {
+ if ( bForceDuration || bSign || fNumber >= 1.0 )
+ return GetFormatIndex( NF_TIME_HH_MMSS, eLnge );
+ else
+ return GetStandardFormat( SvNumFormatType::TIME, eLnge );
+ }
+}
+
+sal_uInt32 SvNumberFormatter::GetStandardFormat( double fNumber, sal_uInt32 nFIndex,
+ SvNumFormatType eType, LanguageType eLnge )
+{
+ ::osl::MutexGuard aGuard( GetInstanceMutex() );
+ if ( IsSpecialStandardFormat( nFIndex, eLnge ) )
+ return nFIndex;
+
+ switch( eType )
+ {
+ case SvNumFormatType::DURATION :
+ return GetTimeFormat( fNumber, eLnge, true);
+ case SvNumFormatType::TIME :
+ return GetTimeFormat( fNumber, eLnge, false);
+ default:
+ return GetStandardFormat( eType, eLnge );
+ }
+}
+
+sal_uInt32 SvNumberFormatter::GuessDateTimeFormat( SvNumFormatType& rType, double fNumber, LanguageType eLnge )
+{
+ ::osl::MutexGuard aGuard( GetInstanceMutex() );
+ // Categorize the format according to the implementation of
+ // SvNumberFormatter::GetEditFormat(), making assumptions about what
+ // would be time only.
+ sal_uInt32 nRet;
+ if (0.0 <= fNumber && fNumber < 1.0)
+ {
+ // Clearly a time.
+ rType = SvNumFormatType::TIME;
+ nRet = GetTimeFormat( fNumber, eLnge, false);
+ }
+ else if (fabs( fNumber) * 24 < 0x7fff)
+ {
+ // Assuming duration within 32k hours or 3.7 years.
+ // This should be SvNumFormatType::DURATION instead, but the outer
+ // world can't cope with that.
+ rType = SvNumFormatType::TIME;
+ nRet = GetTimeFormat( fNumber, eLnge, true);
+ }
+ else if (rtl::math::approxFloor( fNumber) != fNumber)
+ {
+ // Date+Time.
+ rType = SvNumFormatType::DATETIME;
+ nRet = GetFormatIndex( NF_DATETIME_SYS_DDMMYYYY_HHMMSS, eLnge);
+ }
+ else
+ {
+ // Date only.
+ rType = SvNumFormatType::DATE;
+ nRet = GetFormatIndex( NF_DATE_SYS_DDMMYYYY, eLnge);
+ }
+ return nRet;
+}
+
+sal_uInt32 SvNumberFormatter::GetEditFormat( double fNumber, sal_uInt32 nFIndex,
+ SvNumFormatType eType,
+ SvNumberformat const * pFormat,
+ LanguageType eForLocale )
+{
+ ::osl::MutexGuard aGuard( GetInstanceMutex() );
+ const LanguageType eLang = (pFormat ? pFormat->GetLanguage() : LANGUAGE_SYSTEM);
+ if (eForLocale == LANGUAGE_DONTKNOW)
+ eForLocale = eLang;
+ sal_uInt32 nKey = nFIndex;
+ switch ( eType )
+ {
+ // #61619# always edit using 4-digit year
+ case SvNumFormatType::DATE :
+ {
+ // Preserve ISO 8601 format.
+ bool bIsoDate =
+ nFIndex == GetFormatIndex( NF_DATE_DIN_YYYYMMDD, eLang) ||
+ nFIndex == GetFormatIndex( NF_DATE_DIN_YYMMDD, eLang) ||
+ nFIndex == GetFormatIndex( NF_DATE_DIN_MMDD, eLang) ||
+ (pFormat && pFormat->IsIso8601( 0 ));
+ if (rtl::math::approxFloor( fNumber) != fNumber)
+ {
+ // fdo#34977 preserve time when editing even if only date was
+ // displayed.
+ if (bIsoDate)
+ nKey = GetFormatIndex( NF_DATETIME_ISO_YYYYMMDD_HHMMSS, eForLocale);
+ else
+ nKey = GetFormatIndex( NF_DATETIME_SYS_DDMMYYYY_HHMMSS, eForLocale );
+ }
+ else
+ {
+ if (bIsoDate)
+ nKey = GetFormatIndex( NF_DATE_ISO_YYYYMMDD, eForLocale);
+ else
+ nKey = GetFormatIndex( NF_DATE_SYS_DDMMYYYY, eForLocale );
+ }
+ }
+ break;
+ case SvNumFormatType::TIME :
+ if (fNumber < 0.0 || fNumber >= 1.0)
+ {
+ /* XXX NOTE: this is a purely arbitrary value within the limits
+ * of a signed 16-bit. 32k hours are 3.7 years ... or
+ * 1903-09-26 if date. */
+ if (fabs( fNumber) * 24 < 0x7fff)
+ nKey = GetTimeFormat( fNumber, eForLocale, true);
+ // Preserve duration, use [HH]:MM:SS instead of time.
+ else
+ nKey = GetFormatIndex( NF_DATETIME_SYS_DDMMYYYY_HHMMSS, eForLocale );
+ // Assume that a large value is a datetime with only time
+ // displayed.
+ }
+ else
+ nKey = GetStandardFormat( fNumber, nFIndex, eType, eForLocale );
+ break;
+ case SvNumFormatType::DURATION :
+ nKey = GetTimeFormat( fNumber, eForLocale, true);
+ break;
+ case SvNumFormatType::DATETIME :
+ if (nFIndex == GetFormatIndex( NF_DATETIME_ISO_YYYYMMDDTHHMMSS, eLang))
+ nKey = GetFormatIndex( NF_DATETIME_ISO_YYYYMMDDTHHMMSS, eForLocale );
+ else if (nFIndex == GetFormatIndex( NF_DATETIME_ISO_YYYYMMDDTHHMMSS000, eLang))
+ nKey = GetFormatIndex( NF_DATETIME_ISO_YYYYMMDDTHHMMSS000, eForLocale );
+ else if (nFIndex == GetFormatIndex( NF_DATETIME_ISO_YYYYMMDD_HHMMSS000, eLang))
+ nKey = GetFormatIndex( NF_DATETIME_ISO_YYYYMMDD_HHMMSS000, eForLocale );
+ else if (nFIndex == GetFormatIndex( NF_DATETIME_ISO_YYYYMMDD_HHMMSS, eLang) || (pFormat && pFormat->IsIso8601( 0 )))
+ nKey = GetFormatIndex( NF_DATETIME_ISO_YYYYMMDD_HHMMSS, eForLocale );
+ else
+ nKey = GetFormatIndex( NF_DATETIME_SYS_DDMMYYYY_HHMMSS, eForLocale );
+ break;
+ case SvNumFormatType::NUMBER:
+ nKey = GetStandardFormat( eType, eForLocale );
+ break;
+ default:
+ nKey = GetStandardFormat( fNumber, nFIndex, eType, eForLocale );
+ }
+ return nKey;
+}
+
+void SvNumberFormatter::GetInputLineString(const double& fOutNumber,
+ sal_uInt32 nFIndex,
+ OUString& sOutString,
+ bool bFiltering, bool bForceSystemLocale)
+{
+ ::osl::MutexGuard aGuard( GetInstanceMutex() );
+ const Color* pColor;
+ sal_uInt32 nRealKey = nFIndex;
+ SvNumberformat* pFormat = ImpSubstituteEntry( GetFormatEntry( nFIndex ), &nRealKey);
+ if (!pFormat)
+ {
+ pFormat = GetFormatEntry(ZF_STANDARD);
+ }
+
+ LanguageType eLang = pFormat->GetLanguage();
+ ChangeIntl( eLang );
+
+ SvNumFormatType eType = pFormat->GetMaskedType();
+ if (eType == SvNumFormatType::ALL)
+ {
+ // Mixed types in subformats, use first.
+ /* XXX we could choose a subformat according to fOutNumber and
+ * subformat conditions, but they may exist to suppress 0 or negative
+ * numbers so wouldn't be a safe bet. */
+ eType = pFormat->GetNumForInfoScannedType(0);
+ }
+ const SvNumFormatType eTypeOrig = eType;
+
+ sal_uInt16 nOldPrec = pFormatScanner->GetStandardPrec();
+ bool bPrecChanged = false;
+ if (eType == SvNumFormatType::NUMBER ||
+ eType == SvNumFormatType::PERCENT ||
+ eType == SvNumFormatType::CURRENCY ||
+ eType == SvNumFormatType::SCIENTIFIC ||
+ eType == SvNumFormatType::FRACTION)
+ {
+ if (eType != SvNumFormatType::PERCENT) // special treatment of % later
+ {
+ eType = SvNumFormatType::NUMBER;
+ }
+ ChangeStandardPrec(INPUTSTRING_PRECISION);
+ bPrecChanged = true;
+ }
+
+ sal_uInt32 nKey = GetEditFormat( fOutNumber, nRealKey, eType, pFormat,
+ bForceSystemLocale ? LANGUAGE_SYSTEM : LANGUAGE_DONTKNOW);
+ // if bFiltering true keep the nRealKey format
+ if ( nKey != nRealKey && !bFiltering )
+ {
+ pFormat = GetFormatEntry( nKey );
+ }
+ assert(pFormat);
+ if (pFormat)
+ {
+ if ( eType == SvNumFormatType::TIME && pFormat->GetFormatPrecision() )
+ {
+ ChangeStandardPrec(INPUTSTRING_PRECISION);
+ bPrecChanged = true;
+ }
+ pFormat->GetOutputString(fOutNumber, sOutString, &pColor);
+
+ // The #FMT error string must not be used for input as it would lead to
+ // data loss. This can happen for at least date(+time). Fall back to a
+ // last resort of plain number in the locale the formatter was
+ // constructed with.
+ if (eTypeOrig != SvNumFormatType::NUMBER && sOutString == ImpSvNumberformatScan::sErrStr)
+ {
+ pFormat = GetFormatEntry(ZF_STANDARD);
+ assert(pFormat);
+ if (pFormat)
+ {
+ ChangeStandardPrec(INPUTSTRING_PRECISION);
+ bPrecChanged = true;
+ pFormat->GetOutputString(fOutNumber, sOutString, &pColor);
+ }
+ }
+ assert(sOutString != ImpSvNumberformatScan::sErrStr);
+ }
+ if (bPrecChanged)
+ {
+ ChangeStandardPrec(nOldPrec);
+ }
+}
+
+void SvNumberFormatter::GetOutputString(const OUString& sString,
+ sal_uInt32 nFIndex,
+ OUString& sOutString,
+ const Color** ppColor,
+ bool bUseStarFormat )
+{
+ ::osl::MutexGuard aGuard( GetInstanceMutex() );
+ SvNumberformat* pFormat = GetFormatEntry( nFIndex );
+ // ImpSubstituteEntry() is unnecessary here because so far only numeric
+ // (time and date) are substituted.
+ if (!pFormat)
+ {
+ pFormat = GetFormatEntry(ZF_STANDARD_TEXT);
+ }
+ if (!pFormat->IsTextFormat() && !pFormat->HasTextFormat())
+ {
+ *ppColor = nullptr;
+ sOutString = sString;
+ }
+ else
+ {
+ ChangeIntl(pFormat->GetLanguage());
+ if ( bUseStarFormat )
+ {
+ pFormat->SetStarFormatSupport( true );
+ }
+ pFormat->GetOutputString(sString, sOutString, ppColor);
+ if ( bUseStarFormat )
+ {
+ pFormat->SetStarFormatSupport( false );
+ }
+ }
+}
+
+void SvNumberFormatter::GetOutputString(const double& fOutNumber,
+ sal_uInt32 nFIndex,
+ OUString& sOutString,
+ const Color** ppColor,
+ bool bUseStarFormat )
+{
+ ::osl::MutexGuard aGuard( GetInstanceMutex() );
+ if (bNoZero && fOutNumber == 0.0)
+ {
+ sOutString.clear();
+ return;
+ }
+ SvNumberformat* pFormat = ImpSubstituteEntry( GetFormatEntry( nFIndex ));
+ if (!pFormat)
+ pFormat = GetFormatEntry(ZF_STANDARD);
+ ChangeIntl(pFormat->GetLanguage());
+ if ( bUseStarFormat )
+ pFormat->SetStarFormatSupport( true );
+ pFormat->GetOutputString(fOutNumber, sOutString, ppColor);
+ if ( bUseStarFormat )
+ pFormat->SetStarFormatSupport( false );
+}
+
+bool SvNumberFormatter::GetPreviewString(const OUString& sFormatString,
+ double fPreviewNumber,
+ OUString& sOutString,
+ const Color** ppColor,
+ LanguageType eLnge,
+ bool bUseStarFormat )
+{
+ ::osl::MutexGuard aGuard( GetInstanceMutex() );
+ if (sFormatString.isEmpty()) // no empty string
+ {
+ return false;
+ }
+ if (eLnge == LANGUAGE_DONTKNOW)
+ {
+ eLnge = IniLnge;
+ }
+ ChangeIntl(eLnge); // change locale if necessary
+ eLnge = ActLnge;
+ sal_Int32 nCheckPos = -1;
+ OUString sTmpString = sFormatString;
+ SvNumberformat aEntry(sTmpString,
+ pFormatScanner.get(),
+ pStringScanner.get(),
+ nCheckPos,
+ eLnge);
+ if (nCheckPos == 0) // String ok
+ {
+ sal_uInt32 CLOffset = ImpGenerateCL(eLnge); // create new standard formats if necessary
+ sal_uInt32 nKey = ImpIsEntry(aEntry.GetFormatstring(),CLOffset, eLnge);
+ if (nKey != NUMBERFORMAT_ENTRY_NOT_FOUND) // already present
+ {
+ GetOutputString(fPreviewNumber, nKey, sOutString, ppColor, bUseStarFormat);
+ }
+ else
+ {
+ if ( bUseStarFormat )
+ {
+ aEntry.SetStarFormatSupport( true );
+ }
+ aEntry.GetOutputString(fPreviewNumber, sOutString, ppColor);
+ if ( bUseStarFormat )
+ {
+ aEntry.SetStarFormatSupport( false );
+ }
+ }
+ return true;
+ }
+ else
+ {
+ return false;
+ }
+}
+
+bool SvNumberFormatter::GetPreviewStringGuess( const OUString& sFormatString,
+ double fPreviewNumber,
+ OUString& sOutString,
+ const Color** ppColor,
+ LanguageType eLnge )
+{
+ ::osl::MutexGuard aGuard( GetInstanceMutex() );
+ if (sFormatString.isEmpty()) // no empty string
+ {
+ return false;
+ }
+ if (eLnge == LANGUAGE_DONTKNOW)
+ {
+ eLnge = IniLnge;
+ }
+ ChangeIntl( eLnge );
+ eLnge = ActLnge;
+ bool bEnglish = (eLnge == LANGUAGE_ENGLISH_US);
+
+ OUString aFormatStringUpper( xCharClass->uppercase( sFormatString ) );
+ sal_uInt32 nCLOffset = ImpGenerateCL( eLnge );
+ sal_uInt32 nKey = ImpIsEntry( aFormatStringUpper, nCLOffset, eLnge );
+ if ( nKey != NUMBERFORMAT_ENTRY_NOT_FOUND )
+ {
+ // Target format present
+ GetOutputString( fPreviewNumber, nKey, sOutString, ppColor );
+ return true;
+ }
+
+ std::optional<SvNumberformat> pEntry;
+ sal_Int32 nCheckPos = -1;
+ OUString sTmpString;
+
+ if ( bEnglish )
+ {
+ sTmpString = sFormatString;
+ pEntry.emplace( sTmpString, pFormatScanner.get(),
+ pStringScanner.get(), nCheckPos, eLnge );
+ }
+ else
+ {
+ nCLOffset = ImpGenerateCL( LANGUAGE_ENGLISH_US );
+ nKey = ImpIsEntry( aFormatStringUpper, nCLOffset, LANGUAGE_ENGLISH_US );
+ bool bEnglishFormat = (nKey != NUMBERFORMAT_ENTRY_NOT_FOUND);
+
+ // Try English -> other or convert english to other
+ LanguageType eFormatLang = LANGUAGE_ENGLISH_US;
+ pFormatScanner->SetConvertMode( LANGUAGE_ENGLISH_US, eLnge, false, false);
+ sTmpString = sFormatString;
+ pEntry.emplace( sTmpString, pFormatScanner.get(),
+ pStringScanner.get(), nCheckPos, eFormatLang );
+ pFormatScanner->SetConvertMode( false );
+ ChangeIntl( eLnge );
+
+ if ( !bEnglishFormat )
+ {
+ if ( nCheckPos != 0 || xTransliteration->isEqual( sFormatString,
+ pEntry->GetFormatstring() ) )
+ {
+ // other Format
+ // Force locale's keywords.
+ pFormatScanner->ChangeIntl( ImpSvNumberformatScan::KeywordLocalization::LocaleLegacy );
+ sTmpString = sFormatString;
+ pEntry.emplace( sTmpString, pFormatScanner.get(),
+ pStringScanner.get(), nCheckPos, eLnge );
+ }
+ else
+ {
+ // verify english
+ sal_Int32 nCheckPos2 = -1;
+ // try other --> english
+ eFormatLang = eLnge;
+ pFormatScanner->SetConvertMode( eLnge, LANGUAGE_ENGLISH_US, false, false);
+ sTmpString = sFormatString;
+ SvNumberformat aEntry2( sTmpString, pFormatScanner.get(),
+ pStringScanner.get(), nCheckPos2, eFormatLang );
+ pFormatScanner->SetConvertMode( false );
+ ChangeIntl( eLnge );
+ if ( nCheckPos2 == 0 && !xTransliteration->isEqual( sFormatString,
+ aEntry2.GetFormatstring() ) )
+ {
+ // other Format
+ // Force locale's keywords.
+ pFormatScanner->ChangeIntl( ImpSvNumberformatScan::KeywordLocalization::LocaleLegacy );
+ sTmpString = sFormatString;
+ pEntry.emplace( sTmpString, pFormatScanner.get(),
+ pStringScanner.get(), nCheckPos, eLnge );
+ }
+ }
+ }
+ }
+
+ if (nCheckPos == 0) // String ok
+ {
+ ImpGenerateCL( eLnge ); // create new standard formats if necessary
+ pEntry->GetOutputString( fPreviewNumber, sOutString, ppColor );
+ return true;
+ }
+ return false;
+}
+
+bool SvNumberFormatter::GetPreviewString( const OUString& sFormatString,
+ const OUString& sPreviewString,
+ OUString& sOutString,
+ const Color** ppColor,
+ LanguageType eLnge )
+{
+ ::osl::MutexGuard aGuard( GetInstanceMutex() );
+ if (sFormatString.isEmpty()) // no empty string
+ {
+ return false;
+ }
+ if (eLnge == LANGUAGE_DONTKNOW)
+ {
+ eLnge = IniLnge;
+ }
+ ChangeIntl(eLnge); // switch if needed
+ eLnge = ActLnge;
+ sal_Int32 nCheckPos = -1;
+ OUString sTmpString = sFormatString;
+ SvNumberformat aEntry( sTmpString,
+ pFormatScanner.get(),
+ pStringScanner.get(),
+ nCheckPos,
+ eLnge);
+ if (nCheckPos == 0) // String ok
+ {
+ // May have to create standard formats for this locale.
+ sal_uInt32 CLOffset = ImpGenerateCL(eLnge);
+ sal_uInt32 nKey = ImpIsEntry( aEntry.GetFormatstring(), CLOffset, eLnge);
+ if (nKey != NUMBERFORMAT_ENTRY_NOT_FOUND) // already present
+ {
+ GetOutputString( sPreviewString, nKey, sOutString, ppColor);
+ }
+ else
+ {
+ // If the format is valid but not a text format and does not
+ // include a text subformat, an empty string would result. Same as
+ // in SvNumberFormatter::GetOutputString()
+ if (aEntry.IsTextFormat() || aEntry.HasTextFormat())
+ {
+ aEntry.GetOutputString( sPreviewString, sOutString, ppColor);
+ }
+ else
+ {
+ *ppColor = nullptr;
+ sOutString = sPreviewString;
+ }
+ }
+ return true;
+ }
+ else
+ {
+ return false;
+ }
+}
+
+sal_uInt32 SvNumberFormatter::TestNewString(const OUString& sFormatString,
+ LanguageType eLnge)
+{
+ ::osl::MutexGuard aGuard( GetInstanceMutex() );
+ if (sFormatString.isEmpty()) // no empty string
+ {
+ return NUMBERFORMAT_ENTRY_NOT_FOUND;
+ }
+ if (eLnge == LANGUAGE_DONTKNOW)
+ {
+ eLnge = IniLnge;
+ }
+ ChangeIntl(eLnge); // change locale if necessary
+ eLnge = ActLnge;
+ sal_uInt32 nRes;
+ sal_Int32 nCheckPos = -1;
+ OUString sTmpString = sFormatString;
+ SvNumberformat aEntry(sTmpString,
+ pFormatScanner.get(),
+ pStringScanner.get(),
+ nCheckPos,
+ eLnge);
+ if (nCheckPos == 0) // String ok
+ {
+ sal_uInt32 CLOffset = ImpGenerateCL(eLnge); // create new standard formats if necessary
+ nRes = ImpIsEntry(aEntry.GetFormatstring(),CLOffset, eLnge);
+ // already present?
+ }
+ else
+ {
+ nRes = NUMBERFORMAT_ENTRY_NOT_FOUND;
+ }
+ return nRes;
+}
+
+SvNumberformat* SvNumberFormatter::ImpInsertFormat( const css::i18n::NumberFormatCode& rCode,
+ sal_uInt32 nPos, bool bAfterChangingSystemCL,
+ sal_Int16 nOrgIndex )
+{
+ SAL_WARN_IF( NF_INDEX_TABLE_RESERVED_START <= rCode.Index && rCode.Index < NF_INDEX_TABLE_ENTRIES,
+ "svl.numbers", "i18npool locale '" << maLanguageTag.getBcp47() <<
+ "' uses reserved formatIndex value " << rCode.Index << ", next free: " << NF_INDEX_TABLE_ENTRIES <<
+ " Please see description in include/svl/zforlist.hxx at end of enum NfIndexTableOffset");
+ assert( (rCode.Index < NF_INDEX_TABLE_RESERVED_START || NF_INDEX_TABLE_ENTRIES <= rCode.Index) &&
+ "reserved formatIndex, see warning above");
+
+ OUString aCodeStr( rCode.Code );
+ if ( rCode.Index < NF_INDEX_TABLE_RESERVED_START &&
+ rCode.Usage == css::i18n::KNumberFormatUsage::CURRENCY &&
+ rCode.Index != NF_CURRENCY_1000DEC2_CCC )
+ { // strip surrounding [$...] on automatic currency
+ if ( aCodeStr.indexOf( "[$" ) >= 0)
+ aCodeStr = SvNumberformat::StripNewCurrencyDelimiters( aCodeStr );
+ else
+ {
+ if (LocaleDataWrapper::areChecksEnabled() &&
+ rCode.Index != NF_CURRENCY_1000DEC2_CCC )
+ {
+ OUString aMsg = "SvNumberFormatter::ImpInsertFormat: no [$...] on currency format code, index " +
+ OUString::number( rCode.Index) +
+ ":\n" +
+ rCode.Code;
+ LocaleDataWrapper::outputCheckMessage( xLocaleData->appendLocaleInfo( aMsg));
+ }
+ }
+ }
+ sal_Int32 nCheckPos = 0;
+ std::unique_ptr<SvNumberformat> pFormat(new SvNumberformat(aCodeStr,
+ pFormatScanner.get(),
+ pStringScanner.get(),
+ nCheckPos,
+ ActLnge));
+ if (nCheckPos != 0)
+ {
+ if (LocaleDataWrapper::areChecksEnabled())
+ {
+ OUString aMsg = "SvNumberFormatter::ImpInsertFormat: bad format code, index " +
+ OUString::number( rCode.Index ) +
+ "\n" +
+ rCode.Code;
+ LocaleDataWrapper::outputCheckMessage( xLocaleData->appendLocaleInfo( aMsg));
+ }
+ return nullptr;
+ }
+ if ( rCode.Index >= NF_INDEX_TABLE_RESERVED_START )
+ {
+ sal_uInt32 nCLOffset = nPos - (nPos % SV_COUNTRY_LANGUAGE_OFFSET);
+ sal_uInt32 nKey = ImpIsEntry( aCodeStr, nCLOffset, ActLnge );
+ if ( nKey != NUMBERFORMAT_ENTRY_NOT_FOUND )
+ {
+ // If bAfterChangingSystemCL there will definitely be some dups,
+ // don't cry then.
+ if (LocaleDataWrapper::areChecksEnabled() && !bAfterChangingSystemCL)
+ {
+ // Test for duplicate indexes in locale data.
+ switch ( nOrgIndex )
+ {
+ // These may be dups of integer versions for locales where
+ // currencies have no decimals like Italian Lira.
+ case NF_CURRENCY_1000DEC2 : // NF_CURRENCY_1000INT
+ case NF_CURRENCY_1000DEC2_RED : // NF_CURRENCY_1000INT_RED
+ case NF_CURRENCY_1000DEC2_DASHED : // NF_CURRENCY_1000INT_RED
+ break;
+ default:
+ {
+ OUString aMsg = "SvNumberFormatter::ImpInsertFormat: dup format code, index "
+ + OUString::number( rCode.Index )
+ + "\n"
+ + rCode.Code;
+ LocaleDataWrapper::outputCheckMessage( xLocaleData->appendLocaleInfo( aMsg));
+ }
+ }
+ }
+ return nullptr;
+ }
+ else if ( nPos - nCLOffset >= SV_COUNTRY_LANGUAGE_OFFSET )
+ {
+ if (LocaleDataWrapper::areChecksEnabled())
+ {
+ OUString aMsg = "SvNumberFormatter::ImpInsertFormat: too many format codes, index "
+ + OUString::number( rCode.Index )
+ + "\n"
+ + rCode.Code;
+ LocaleDataWrapper::outputCheckMessage( xLocaleData->appendLocaleInfo( aMsg));
+ }
+ return nullptr;
+ }
+ }
+ auto pFormat2 = pFormat.get();
+ if ( !aFTable.emplace( nPos, std::move(pFormat) ).second )
+ {
+ if (LocaleDataWrapper::areChecksEnabled())
+ {
+ OUString aMsg = "ImpInsertFormat: can't insert number format key pos: "
+ + OUString::number( nPos )
+ + ", code index "
+ + OUString::number( rCode.Index )
+ + "\n"
+ + rCode.Code;
+ LocaleDataWrapper::outputCheckMessage( xLocaleData->appendLocaleInfo( aMsg));
+ }
+ else
+ {
+ SAL_WARN( "svl.numbers", "SvNumberFormatter::ImpInsertFormat: dup position");
+ }
+ return nullptr;
+ }
+ if ( rCode.Default )
+ pFormat2->SetStandard();
+ if ( !rCode.DefaultName.isEmpty() )
+ pFormat2->SetComment( rCode.DefaultName );
+ return pFormat2;
+}
+
+void SvNumberFormatter::GetFormatSpecialInfo(sal_uInt32 nFormat,
+ bool& bThousand,
+ bool& IsRed,
+ sal_uInt16& nPrecision,
+ sal_uInt16& nLeadingCnt)
+
+{
+ ::osl::MutexGuard aGuard( GetInstanceMutex() );
+ SvNumberformat* pFormat = GetFormatEntry( nFormat );
+ if (pFormat)
+ pFormat->GetFormatSpecialInfo(bThousand, IsRed,
+ nPrecision, nLeadingCnt);
+ else
+ {
+ bThousand = false;
+ IsRed = false;
+ nPrecision = pFormatScanner->GetStandardPrec();
+ nLeadingCnt = 0;
+ }
+}
+
+sal_uInt16 SvNumberFormatter::GetFormatPrecision( sal_uInt32 nFormat ) const
+{
+ ::osl::MutexGuard aGuard( GetInstanceMutex() );
+ const SvNumberformat* pFormat = GetFormatEntry( nFormat );
+ if ( pFormat )
+ return pFormat->GetFormatPrecision();
+ else
+ return pFormatScanner->GetStandardPrec();
+}
+
+sal_uInt16 SvNumberFormatter::GetFormatIntegerDigits( sal_uInt32 nFormat ) const
+{
+ ::osl::MutexGuard aGuard( GetInstanceMutex() );
+ const SvNumberformat* pFormat = GetFormatEntry( nFormat );
+ if ( pFormat )
+ return pFormat->GetFormatIntegerDigits();
+ else
+ return 1;
+}
+
+OUString SvNumberFormatter::GetFormatDecimalSep( sal_uInt32 nFormat ) const
+{
+ ::osl::MutexGuard aGuard( GetInstanceMutex() );
+ const SvNumberformat* pFormat = GetFormatEntry(nFormat);
+ if (!pFormat)
+ {
+ return GetNumDecimalSep();
+ }
+ return GetLangDecimalSep( pFormat->GetLanguage());
+}
+
+OUString SvNumberFormatter::GetLangDecimalSep( LanguageType nLang ) const
+{
+ ::osl::MutexGuard aGuard( GetInstanceMutex() );
+ if (nLang == ActLnge)
+ {
+ return GetNumDecimalSep();
+ }
+ OUString aRet;
+ LanguageType eSaveLang = xLocaleData.getCurrentLanguage();
+ if (nLang == eSaveLang)
+ {
+ aRet = xLocaleData->getNumDecimalSep();
+ }
+ else
+ {
+ LanguageTag aSaveLocale( xLocaleData->getLanguageTag() );
+ const_cast<SvNumberFormatter*>(this)->xLocaleData.changeLocale( LanguageTag( nLang));
+ aRet = xLocaleData->getNumDecimalSep();
+ const_cast<SvNumberFormatter*>(this)->xLocaleData.changeLocale( aSaveLocale );
+ }
+ return aRet;
+}
+
+
+sal_uInt32 SvNumberFormatter::GetFormatSpecialInfo( const OUString& rFormatString,
+ bool& bThousand, bool& IsRed, sal_uInt16& nPrecision,
+ sal_uInt16& nLeadingCnt, LanguageType eLnge )
+
+{
+ ::osl::MutexGuard aGuard( GetInstanceMutex() );
+ if (eLnge == LANGUAGE_DONTKNOW)
+ {
+ eLnge = IniLnge;
+ }
+ ChangeIntl(eLnge); // change locale if necessary
+ eLnge = ActLnge;
+ OUString aTmpStr( rFormatString );
+ sal_Int32 nCheckPos = 0;
+ SvNumberformat aFormat( aTmpStr, pFormatScanner.get(),
+ pStringScanner.get(), nCheckPos, eLnge );
+ if ( nCheckPos == 0 )
+ {
+ aFormat.GetFormatSpecialInfo( bThousand, IsRed, nPrecision, nLeadingCnt );
+ }
+ else
+ {
+ bThousand = false;
+ IsRed = false;
+ nPrecision = pFormatScanner->GetStandardPrec();
+ nLeadingCnt = 0;
+ }
+ return nCheckPos;
+}
+
+OUString SvNumberFormatter::GetCalcCellReturn( sal_uInt32 nFormat ) const
+{
+ ::osl::MutexGuard aGuard( GetInstanceMutex() );
+ const SvNumberformat* pFormat = GetFormatEntry( nFormat );
+ if (!pFormat)
+ return "G";
+
+ OUString aStr;
+ bool bAppendPrec = true;
+ sal_uInt16 nPrec, nLeading;
+ bool bThousand, bIsRed;
+ pFormat->GetFormatSpecialInfo( bThousand, bIsRed, nPrec, nLeading );
+
+ switch (pFormat->GetMaskedType())
+ {
+ case SvNumFormatType::NUMBER:
+ if (bThousand)
+ aStr = ",";
+ else
+ aStr = "F";
+ break;
+ case SvNumFormatType::CURRENCY:
+ aStr = "C";
+ break;
+ case SvNumFormatType::SCIENTIFIC:
+ aStr = "S";
+ break;
+ case SvNumFormatType::PERCENT:
+ aStr = "P";
+ break;
+ default:
+ {
+ bAppendPrec = false;
+ switch (GetIndexTableOffset( nFormat ))
+ {
+ case NF_DATE_SYSTEM_SHORT:
+ case NF_DATE_SYS_DMMMYY:
+ case NF_DATE_SYS_DDMMYY:
+ case NF_DATE_SYS_DDMMYYYY:
+ case NF_DATE_SYS_DMMMYYYY:
+ case NF_DATE_DIN_DMMMYYYY:
+ case NF_DATE_SYS_DMMMMYYYY:
+ case NF_DATE_DIN_DMMMMYYYY: aStr = "D1"; break;
+ case NF_DATE_SYS_DDMMM: aStr = "D2"; break;
+ case NF_DATE_SYS_MMYY: aStr = "D3"; break;
+ case NF_DATETIME_SYSTEM_SHORT_HHMM:
+ case NF_DATETIME_SYS_DDMMYYYY_HHMM:
+ case NF_DATETIME_SYS_DDMMYYYY_HHMMSS:
+ aStr = "D4"; break;
+ case NF_DATE_DIN_MMDD: aStr = "D5"; break;
+ case NF_TIME_HHMMSSAMPM: aStr = "D6"; break;
+ case NF_TIME_HHMMAMPM: aStr = "D7"; break;
+ case NF_TIME_HHMMSS: aStr = "D8"; break;
+ case NF_TIME_HHMM: aStr = "D9"; break;
+ default: aStr = "G";
+ }
+ }
+ }
+
+ if (bAppendPrec)
+ aStr += OUString::number(nPrec);
+
+ if (pFormat->GetColor( 1 ))
+ aStr += "-"; // negative color
+
+ /* FIXME: this probably should not match on literal strings and only be
+ * performed on number or currency formats, but it is what Calc originally
+ * implemented. */
+ if (pFormat->GetFormatstring().indexOf('(') != -1)
+ aStr += "()";
+
+ return aStr;
+}
+
+sal_Int32 SvNumberFormatter::ImpGetFormatCodeIndex(
+ css::uno::Sequence< css::i18n::NumberFormatCode >& rSeq,
+ const NfIndexTableOffset nTabOff )
+{
+ auto pSeq = std::find_if(std::cbegin(rSeq), std::cend(rSeq),
+ [nTabOff](const css::i18n::NumberFormatCode& rCode) { return rCode.Index == nTabOff; });
+ if (pSeq != std::cend(rSeq))
+ return static_cast<sal_Int32>(std::distance(std::cbegin(rSeq), pSeq));
+ if (LocaleDataWrapper::areChecksEnabled() && (nTabOff < NF_CURRENCY_START
+ || NF_CURRENCY_END < nTabOff || nTabOff == NF_CURRENCY_1000INT
+ || nTabOff == NF_CURRENCY_1000INT_RED
+ || nTabOff == NF_CURRENCY_1000DEC2_CCC))
+ { // currency entries with decimals might not exist, e.g. Italian Lira
+ OUString aMsg = "SvNumberFormatter::ImpGetFormatCodeIndex: not found: "
+ + OUString::number( nTabOff );
+ LocaleDataWrapper::outputCheckMessage( xLocaleData->appendLocaleInfo(aMsg));
+ }
+ if ( rSeq.hasElements() )
+ {
+ // look for a preset default
+ pSeq = std::find_if(std::cbegin(rSeq), std::cend(rSeq),
+ [](const css::i18n::NumberFormatCode& rCode) { return rCode.Default; });
+ if (pSeq != std::cend(rSeq))
+ return static_cast<sal_Int32>(std::distance(std::cbegin(rSeq), pSeq));
+ // currencies are special, not all format codes must exist, but all
+ // builtin number format key index positions must have a format assigned
+ if ( NF_CURRENCY_START <= nTabOff && nTabOff <= NF_CURRENCY_END )
+ {
+ // look for a format with decimals
+ pSeq = std::find_if(std::cbegin(rSeq), std::cend(rSeq),
+ [](const css::i18n::NumberFormatCode& rCode) { return rCode.Index == NF_CURRENCY_1000DEC2; });
+ if (pSeq != std::cend(rSeq))
+ return static_cast<sal_Int32>(std::distance(std::cbegin(rSeq), pSeq));
+ // last resort: look for a format without decimals
+ pSeq = std::find_if(std::cbegin(rSeq), std::cend(rSeq),
+ [](const css::i18n::NumberFormatCode& rCode) { return rCode.Index == NF_CURRENCY_1000INT; });
+ if (pSeq != std::cend(rSeq))
+ return static_cast<sal_Int32>(std::distance(std::cbegin(rSeq), pSeq));
+ }
+ }
+ else
+ { // we need at least _some_ format
+ rSeq = { css::i18n::NumberFormatCode() };
+ rSeq.getArray()[0].Code = "0" + GetNumDecimalSep() + "############";
+ }
+ return 0;
+}
+
+
+void SvNumberFormatter::ImpAdjustFormatCodeDefault(
+ css::i18n::NumberFormatCode * pFormatArr,
+ sal_Int32 nCnt )
+{
+ if ( !nCnt )
+ return;
+ if (LocaleDataWrapper::areChecksEnabled())
+ {
+ // check the locale data for correctness
+ OStringBuffer aMsg;
+ sal_Int32 nElem, nShort, nMedium, nLong, nShortDef, nMediumDef, nLongDef;
+ nShort = nMedium = nLong = nShortDef = nMediumDef = nLongDef = -1;
+ for ( nElem = 0; nElem < nCnt; nElem++ )
+ {
+ switch ( pFormatArr[nElem].Type )
+ {
+ case i18n::KNumberFormatType::SHORT :
+ nShort = nElem;
+ break;
+ case i18n::KNumberFormatType::MEDIUM :
+ nMedium = nElem;
+ break;
+ case i18n::KNumberFormatType::LONG :
+ nLong = nElem;
+ break;
+ default:
+ aMsg.append("unknown type");
+ }
+ if ( pFormatArr[nElem].Default )
+ {
+ switch ( pFormatArr[nElem].Type )
+ {
+ case i18n::KNumberFormatType::SHORT :
+ if ( nShortDef != -1 )
+ aMsg.append("dupe short type default");
+ nShortDef = nElem;
+ break;
+ case i18n::KNumberFormatType::MEDIUM :
+ if ( nMediumDef != -1 )
+ aMsg.append("dupe medium type default");
+ nMediumDef = nElem;
+ break;
+ case i18n::KNumberFormatType::LONG :
+ if ( nLongDef != -1 )
+ aMsg.append("dupe long type default");
+ nLongDef = nElem;
+ break;
+ }
+ }
+ if (!aMsg.isEmpty())
+ {
+ aMsg.insert(0, "SvNumberFormatter::ImpAdjustFormatCodeDefault: ");
+ aMsg.append("\nXML locale data FormatElement formatindex: ");
+ aMsg.append(static_cast<sal_Int32>(pFormatArr[nElem].Index));
+ OUString aUMsg(OStringToOUString(aMsg.makeStringAndClear(),
+ RTL_TEXTENCODING_ASCII_US));
+ LocaleDataWrapper::outputCheckMessage(xLocaleData->appendLocaleInfo(aUMsg));
+ }
+ }
+ if ( nShort != -1 && nShortDef == -1 )
+ aMsg.append("no short type default ");
+ if ( nMedium != -1 && nMediumDef == -1 )
+ aMsg.append("no medium type default ");
+ if ( nLong != -1 && nLongDef == -1 )
+ aMsg.append("no long type default ");
+ if (!aMsg.isEmpty())
+ {
+ aMsg.insert(0, "SvNumberFormatter::ImpAdjustFormatCodeDefault: ");
+ aMsg.append("\nXML locale data FormatElement group of: ");
+ OUString aUMsg(OStringToOUString(aMsg.makeStringAndClear(), RTL_TEXTENCODING_ASCII_US));
+ LocaleDataWrapper::outputCheckMessage(
+ xLocaleData->appendLocaleInfo(OUStringConcatenation(aUMsg + pFormatArr[0].NameID)));
+ }
+ }
+ // find the default (medium preferred, then long) and reset all other defaults
+ sal_Int32 nElem, nDef, nMedium;
+ nDef = nMedium = -1;
+ for ( nElem = 0; nElem < nCnt; nElem++ )
+ {
+ if ( pFormatArr[nElem].Default )
+ {
+ switch ( pFormatArr[nElem].Type )
+ {
+ case i18n::KNumberFormatType::MEDIUM :
+ nDef = nMedium = nElem;
+ break;
+ case i18n::KNumberFormatType::LONG :
+ if ( nMedium == -1 )
+ nDef = nElem;
+ [[fallthrough]];
+ default:
+ if ( nDef == -1 )
+ nDef = nElem;
+ pFormatArr[nElem].Default = false;
+ }
+ }
+ }
+ if ( nDef == -1 )
+ nDef = 0;
+ pFormatArr[nDef].Default = true;
+}
+
+SvNumberformat* SvNumberFormatter::GetFormatEntry( sal_uInt32 nKey )
+{
+ auto it = aFTable.find( nKey);
+ if (it != aFTable.end())
+ return it->second.get();
+ return nullptr;
+}
+
+const SvNumberformat* SvNumberFormatter::GetFormatEntry( sal_uInt32 nKey ) const
+{
+ return GetEntry( nKey);
+}
+
+const SvNumberformat* SvNumberFormatter::GetEntry( sal_uInt32 nKey ) const
+{
+ ::osl::MutexGuard aGuard( GetInstanceMutex() );
+ auto it = aFTable.find( nKey);
+ if (it != aFTable.end())
+ return it->second.get();
+ return nullptr;
+}
+
+const SvNumberformat* SvNumberFormatter::GetSubstitutedEntry( sal_uInt32 nKey, sal_uInt32 & o_rNewKey ) const
+{
+ ::osl::MutexGuard aGuard( GetInstanceMutex() );
+ // A tad ugly, but GetStandardFormat() and GetFormatIndex() in
+ // ImpSubstituteEntry() may have to add the LANGUAGE_SYSTEM formats if not
+ // already present (which in practice most times they are).
+ SvNumberFormatter* pThis = const_cast<SvNumberFormatter*>(this);
+ return pThis->ImpSubstituteEntry( pThis->GetFormatEntry( nKey), &o_rNewKey);
+}
+
+SvNumberformat* SvNumberFormatter::ImpSubstituteEntry( SvNumberformat* pFormat, sal_uInt32 * o_pRealKey )
+{
+ if (!pFormat || !pFormat->IsSubstituted())
+ return pFormat;
+
+ // XXX NOTE: substitution can not be done in GetFormatEntry() as otherwise
+ // to be substituted formats would "vanish", i.e. from the number formatter
+ // dialog or when exporting to Excel.
+
+ sal_uInt32 nKey;
+ if (pFormat->IsSystemTimeFormat())
+ /* TODO: should we have NF_TIME_SYSTEM for consistency? */
+ nKey = GetStandardFormat( SvNumFormatType::TIME, LANGUAGE_SYSTEM);
+ else if (pFormat->IsSystemLongDateFormat())
+ /* TODO: either that above, or have a long option for GetStandardFormat() */
+ nKey = GetFormatIndex( NF_DATE_SYSTEM_LONG, LANGUAGE_SYSTEM);
+ else
+ return pFormat;
+
+ if (o_pRealKey)
+ *o_pRealKey = nKey;
+ auto it = aFTable.find( nKey);
+ return it == aFTable.end() ? nullptr : it->second.get();
+}
+
+void SvNumberFormatter::ImpGenerateFormats( sal_uInt32 CLOffset, bool bNoAdditionalFormats )
+{
+ bool bOldConvertMode = pFormatScanner->GetConvertMode();
+ if (bOldConvertMode)
+ {
+ pFormatScanner->SetConvertMode(false); // switch off for this function
+ }
+
+ css::lang::Locale aLocale = GetLanguageTag().getLocale();
+ css::uno::Reference< css::i18n::XNumberFormatCode > xNFC = i18n::NumberFormatMapper::create( m_xContext );
+ sal_Int32 nIdx;
+
+ // Number
+ uno::Sequence< i18n::NumberFormatCode > aFormatSeq = xNFC->getAllFormatCode( i18n::KNumberFormatUsage::FIXED_NUMBER, aLocale );
+ ImpAdjustFormatCodeDefault( aFormatSeq.getArray(), aFormatSeq.getLength() );
+
+ // General
+ nIdx = ImpGetFormatCodeIndex( aFormatSeq, NF_NUMBER_STANDARD );
+ SvNumberformat* pStdFormat = ImpInsertFormat( aFormatSeq[nIdx],
+ CLOffset + ZF_STANDARD /* NF_NUMBER_STANDARD */ );
+ if (pStdFormat)
+ {
+ // This is _the_ standard format.
+ if (LocaleDataWrapper::areChecksEnabled() && pStdFormat->GetType() != SvNumFormatType::NUMBER)
+ {
+ LocaleDataWrapper::outputCheckMessage( xLocaleData->
+ appendLocaleInfo( u"SvNumberFormatter::ImpGenerateFormats: General format not NUMBER"));
+ }
+ pStdFormat->SetType( SvNumFormatType::NUMBER );
+ pStdFormat->SetStandard();
+ pStdFormat->SetLastInsertKey( SV_MAX_COUNT_STANDARD_FORMATS, SvNumberformat::FormatterPrivateAccess() );
+ }
+ else
+ {
+ if (LocaleDataWrapper::areChecksEnabled())
+ {
+ LocaleDataWrapper::outputCheckMessage( xLocaleData->
+ appendLocaleInfo( u"SvNumberFormatter::ImpGenerateFormats: General format not insertable, nothing will work"));
+ }
+ }
+
+ {
+ // Boolean
+ OUString aFormatCode = pFormatScanner->GetBooleanString();
+ sal_Int32 nCheckPos = 0;
+
+ std::unique_ptr<SvNumberformat> pNewFormat(new SvNumberformat( aFormatCode, pFormatScanner.get(),
+ pStringScanner.get(), nCheckPos, ActLnge ));
+ pNewFormat->SetType(SvNumFormatType::LOGICAL);
+ pNewFormat->SetStandard();
+ if ( !aFTable.emplace(CLOffset + ZF_STANDARD_LOGICAL /* NF_BOOLEAN */,
+ std::move(pNewFormat)).second )
+ {
+ SAL_WARN( "svl.numbers", "SvNumberFormatter::ImpGenerateFormats: dup position Boolean");
+ }
+
+ // Text
+ aFormatCode = "@";
+ pNewFormat.reset(new SvNumberformat( aFormatCode, pFormatScanner.get(),
+ pStringScanner.get(), nCheckPos, ActLnge ));
+ pNewFormat->SetType(SvNumFormatType::TEXT);
+ pNewFormat->SetStandard();
+ if ( !aFTable.emplace( CLOffset + ZF_STANDARD_TEXT /* NF_TEXT */,
+ std::move(pNewFormat)).second )
+ {
+ SAL_WARN( "svl.numbers", "SvNumberFormatter::ImpGenerateFormats: dup position Text");
+ }
+ }
+
+ // 0
+ nIdx = ImpGetFormatCodeIndex( aFormatSeq, NF_NUMBER_INT );
+ ImpInsertFormat( aFormatSeq[nIdx],
+ CLOffset + ZF_STANDARD+1 /* NF_NUMBER_INT */ );
+
+ // 0.00
+ nIdx = ImpGetFormatCodeIndex( aFormatSeq, NF_NUMBER_DEC2 );
+ ImpInsertFormat( aFormatSeq[nIdx],
+ CLOffset + ZF_STANDARD+2 /* NF_NUMBER_DEC2 */ );
+
+ // #,##0
+ nIdx = ImpGetFormatCodeIndex( aFormatSeq, NF_NUMBER_1000INT );
+ ImpInsertFormat( aFormatSeq[nIdx],
+ CLOffset + ZF_STANDARD+3 /* NF_NUMBER_1000INT */ );
+
+ // #,##0.00
+ nIdx = ImpGetFormatCodeIndex( aFormatSeq, NF_NUMBER_1000DEC2 );
+ ImpInsertFormat( aFormatSeq[nIdx],
+ CLOffset + ZF_STANDARD+4 /* NF_NUMBER_1000DEC2 */ );
+
+ // #.##0,00 System country/language dependent
+ nIdx = ImpGetFormatCodeIndex( aFormatSeq, NF_NUMBER_SYSTEM );
+ ImpInsertFormat( aFormatSeq[nIdx],
+ CLOffset + ZF_STANDARD+5 /* NF_NUMBER_SYSTEM */ );
+
+
+ // Percent number
+ aFormatSeq = xNFC->getAllFormatCode( i18n::KNumberFormatUsage::PERCENT_NUMBER, aLocale );
+ ImpAdjustFormatCodeDefault( aFormatSeq.getArray(), aFormatSeq.getLength() );
+
+ // 0%
+ nIdx = ImpGetFormatCodeIndex( aFormatSeq, NF_PERCENT_INT );
+ ImpInsertFormat( aFormatSeq[nIdx],
+ CLOffset + ZF_STANDARD_PERCENT /* NF_PERCENT_INT */ );
+
+ // 0.00%
+ nIdx = ImpGetFormatCodeIndex( aFormatSeq, NF_PERCENT_DEC2 );
+ ImpInsertFormat( aFormatSeq[nIdx],
+ CLOffset + ZF_STANDARD_PERCENT+1 /* NF_PERCENT_DEC2 */ );
+
+
+ // Currency. NO default standard option! Default is determined of locale
+ // data default currency and format is generated if needed.
+ aFormatSeq = xNFC->getAllFormatCode( i18n::KNumberFormatUsage::CURRENCY, aLocale );
+ if (LocaleDataWrapper::areChecksEnabled())
+ {
+ // though no default desired here, test for correctness of locale data
+ ImpAdjustFormatCodeDefault( aFormatSeq.getArray(), aFormatSeq.getLength() );
+ }
+
+ // #,##0
+ nIdx = ImpGetFormatCodeIndex( aFormatSeq, NF_CURRENCY_1000INT );
+ // Just copy the format, to avoid COW on sequence after each possible reallocation
+ auto aFormat = aFormatSeq[nIdx];
+ aFormat.Default = false;
+ ImpInsertFormat( aFormat,
+ CLOffset + ZF_STANDARD_CURRENCY /* NF_CURRENCY_1000INT */ );
+
+ // #,##0.00
+ nIdx = ImpGetFormatCodeIndex( aFormatSeq, NF_CURRENCY_1000DEC2 );
+ aFormat = aFormatSeq[nIdx];
+ aFormat.Default = false;
+ ImpInsertFormat( aFormat,
+ CLOffset + ZF_STANDARD_CURRENCY+1 /* NF_CURRENCY_1000DEC2 */ );
+
+ // #,##0 negative red
+ nIdx = ImpGetFormatCodeIndex( aFormatSeq, NF_CURRENCY_1000INT_RED );
+ aFormat = aFormatSeq[nIdx];
+ aFormat.Default = false;
+ ImpInsertFormat(aFormat,
+ CLOffset + ZF_STANDARD_CURRENCY+2 /* NF_CURRENCY_1000INT_RED */ );
+
+ // #,##0.00 negative red
+ nIdx = ImpGetFormatCodeIndex( aFormatSeq, NF_CURRENCY_1000DEC2_RED );
+ aFormat = aFormatSeq[nIdx];
+ aFormat.Default = false;
+ ImpInsertFormat(aFormat,
+ CLOffset + ZF_STANDARD_CURRENCY+3 /* NF_CURRENCY_1000DEC2_RED */ );
+
+ // #,##0.00 USD
+ nIdx = ImpGetFormatCodeIndex( aFormatSeq, NF_CURRENCY_1000DEC2_CCC );
+ aFormat = aFormatSeq[nIdx];
+ aFormat.Default = false;
+ ImpInsertFormat( aFormat,
+ CLOffset + ZF_STANDARD_CURRENCY+4 /* NF_CURRENCY_1000DEC2_CCC */ );
+
+ // #.##0,--
+ nIdx = ImpGetFormatCodeIndex( aFormatSeq, NF_CURRENCY_1000DEC2_DASHED );
+ aFormat = aFormatSeq[nIdx];
+ aFormat.Default = false;
+ ImpInsertFormat(aFormat,
+ CLOffset + ZF_STANDARD_CURRENCY+5 /* NF_CURRENCY_1000DEC2_DASHED */ );
+
+
+ // Date
+ aFormatSeq = xNFC->getAllFormatCode( i18n::KNumberFormatUsage::DATE, aLocale );
+ ImpAdjustFormatCodeDefault( aFormatSeq.getArray(), aFormatSeq.getLength() );
+
+ // DD.MM.YY System
+ nIdx = ImpGetFormatCodeIndex( aFormatSeq, NF_DATE_SYSTEM_SHORT );
+ ImpInsertFormat( aFormatSeq[nIdx],
+ CLOffset + ZF_STANDARD_DATE /* NF_DATE_SYSTEM_SHORT */ );
+
+ // NN DD.MMM YY
+ nIdx = ImpGetFormatCodeIndex( aFormatSeq, NF_DATE_DEF_NNDDMMMYY );
+ ImpInsertFormat( aFormatSeq[nIdx],
+ CLOffset + ZF_STANDARD_DATE+1 /* NF_DATE_DEF_NNDDMMMYY */ );
+
+ // DD.MM.YY def/System
+ nIdx = ImpGetFormatCodeIndex( aFormatSeq, NF_DATE_SYS_MMYY );
+ ImpInsertFormat( aFormatSeq[nIdx],
+ CLOffset + ZF_STANDARD_DATE+2 /* NF_DATE_SYS_MMYY */ );
+
+ // DD MMM
+ nIdx = ImpGetFormatCodeIndex( aFormatSeq, NF_DATE_SYS_DDMMM );
+ ImpInsertFormat( aFormatSeq[nIdx],
+ CLOffset + ZF_STANDARD_DATE+3 /* NF_DATE_SYS_DDMMM */ );
+
+ // MMMM
+ nIdx = ImpGetFormatCodeIndex( aFormatSeq, NF_DATE_MMMM );
+ ImpInsertFormat( aFormatSeq[nIdx],
+ CLOffset + ZF_STANDARD_DATE+4 /* NF_DATE_MMMM */ );
+
+ // QQ YY
+ nIdx = ImpGetFormatCodeIndex( aFormatSeq, NF_DATE_QQJJ );
+ ImpInsertFormat( aFormatSeq[nIdx],
+ CLOffset + ZF_STANDARD_DATE+5 /* NF_DATE_QQJJ */ );
+
+ // DD.MM.YYYY was DD.MM.[YY]YY
+ nIdx = ImpGetFormatCodeIndex( aFormatSeq, NF_DATE_SYS_DDMMYYYY );
+ ImpInsertFormat( aFormatSeq[nIdx],
+ CLOffset + ZF_STANDARD_DATE+6 /* NF_DATE_SYS_DDMMYYYY */ );
+
+ // DD.MM.YY def/System
+ nIdx = ImpGetFormatCodeIndex( aFormatSeq, NF_DATE_SYS_DDMMYY );
+ ImpInsertFormat( aFormatSeq[nIdx],
+ CLOffset + ZF_STANDARD_DATE+7 /* NF_DATE_SYS_DDMMYY */ );
+
+ // NNN, D. MMMM YYYY System
+ // Long day of week: "NNNN" instead of "NNN," because of compatibility
+ nIdx = ImpGetFormatCodeIndex( aFormatSeq, NF_DATE_SYSTEM_LONG );
+ ImpInsertFormat( aFormatSeq[nIdx],
+ CLOffset + ZF_STANDARD_DATE+8 /* NF_DATE_SYSTEM_LONG */ );
+
+ // Hard coded but system (regional settings) delimiters dependent long date formats
+
+ // D. MMM YY def/System
+ nIdx = ImpGetFormatCodeIndex( aFormatSeq, NF_DATE_SYS_DMMMYY );
+ ImpInsertFormat( aFormatSeq[nIdx],
+ CLOffset + ZF_STANDARD_DATE+9 /* NF_DATE_SYS_DMMMYY */ );
+
+ // D. MMM YYYY def/System
+ nIdx = ImpGetFormatCodeIndex( aFormatSeq, NF_DATE_SYS_DMMMYYYY );
+ ImpInsertFormat( aFormatSeq[nIdx],
+ CLOffset + ZF_STANDARD_DATE_SYS_DMMMYYYY /* NF_DATE_SYS_DMMMYYYY */ );
+
+ // D. MMMM YYYY def/System
+ nIdx = ImpGetFormatCodeIndex( aFormatSeq, NF_DATE_SYS_DMMMMYYYY );
+ ImpInsertFormat( aFormatSeq[nIdx],
+ CLOffset + ZF_STANDARD_DATE_SYS_DMMMMYYYY /* NF_DATE_SYS_DMMMMYYYY */ );
+
+ // NN, D. MMM YY def/System
+ nIdx = ImpGetFormatCodeIndex( aFormatSeq, NF_DATE_SYS_NNDMMMYY );
+ ImpInsertFormat( aFormatSeq[nIdx],
+ CLOffset + ZF_STANDARD_DATE_SYS_NNDMMMYY /* NF_DATE_SYS_NNDMMMYY */ );
+
+ // NN, D. MMMM YYYY def/System
+ nIdx = ImpGetFormatCodeIndex( aFormatSeq, NF_DATE_SYS_NNDMMMMYYYY );
+ ImpInsertFormat( aFormatSeq[nIdx],
+ CLOffset + ZF_STANDARD_DATE_SYS_NNDMMMMYYYY /* NF_DATE_SYS_NNDMMMMYYYY */ );
+
+ // NNN, D. MMMM YYYY def/System
+ nIdx = ImpGetFormatCodeIndex( aFormatSeq, NF_DATE_SYS_NNNNDMMMMYYYY );
+ ImpInsertFormat( aFormatSeq[nIdx],
+ CLOffset + ZF_STANDARD_DATE_SYS_NNNNDMMMMYYYY /* NF_DATE_SYS_NNNNDMMMMYYYY */ );
+
+ // Hard coded DIN (Deutsche Industrie Norm) and EN (European Norm) date formats
+
+ // D. MMM. YYYY DIN/EN
+ nIdx = ImpGetFormatCodeIndex( aFormatSeq, NF_DATE_DIN_DMMMYYYY );
+ ImpInsertFormat( aFormatSeq[nIdx],
+ CLOffset + ZF_STANDARD_DATE_DIN_DMMMYYYY /* NF_DATE_DIN_DMMMYYYY */ );
+
+ // D. MMMM YYYY DIN/EN
+ nIdx = ImpGetFormatCodeIndex( aFormatSeq, NF_DATE_DIN_DMMMMYYYY );
+ ImpInsertFormat( aFormatSeq[nIdx],
+ CLOffset + ZF_STANDARD_DATE_DIN_DMMMMYYYY /* NF_DATE_DIN_DMMMMYYYY */ );
+
+ // MM-DD DIN/EN
+ nIdx = ImpGetFormatCodeIndex( aFormatSeq, NF_DATE_DIN_MMDD );
+ ImpInsertFormat( aFormatSeq[nIdx],
+ CLOffset + ZF_STANDARD_DATE_DIN_MMDD /* NF_DATE_DIN_MMDD */ );
+
+ // YY-MM-DD DIN/EN
+ nIdx = ImpGetFormatCodeIndex( aFormatSeq, NF_DATE_DIN_YYMMDD );
+ ImpInsertFormat( aFormatSeq[nIdx],
+ CLOffset + ZF_STANDARD_DATE_DIN_YYMMDD /* NF_DATE_DIN_YYMMDD */ );
+
+ // YYYY-MM-DD DIN/EN/ISO
+ nIdx = ImpGetFormatCodeIndex( aFormatSeq, NF_DATE_DIN_YYYYMMDD );
+ ImpInsertFormat( aFormatSeq[nIdx],
+ CLOffset + ZF_STANDARD_DATE_DIN_YYYYMMDD /* NF_DATE_DIN_YYYYMMDD */ );
+
+
+ // Time
+ aFormatSeq = xNFC->getAllFormatCode( i18n::KNumberFormatUsage::TIME, aLocale );
+ ImpAdjustFormatCodeDefault( aFormatSeq.getArray(), aFormatSeq.getLength() );
+
+ // HH:MM
+ nIdx = ImpGetFormatCodeIndex( aFormatSeq, NF_TIME_HHMM );
+ ImpInsertFormat( aFormatSeq[nIdx],
+ CLOffset + ZF_STANDARD_TIME /* NF_TIME_HHMM */ );
+
+ // HH:MM:SS
+ nIdx = ImpGetFormatCodeIndex( aFormatSeq, NF_TIME_HHMMSS );
+ ImpInsertFormat( aFormatSeq[nIdx],
+ CLOffset + ZF_STANDARD_TIME+1 /* NF_TIME_HHMMSS */ );
+
+ // HH:MM AM/PM
+ nIdx = ImpGetFormatCodeIndex( aFormatSeq, NF_TIME_HHMMAMPM );
+ ImpInsertFormat( aFormatSeq[nIdx],
+ CLOffset + ZF_STANDARD_TIME+2 /* NF_TIME_HHMMAMPM */ );
+
+ // HH:MM:SS AM/PM
+ nIdx = ImpGetFormatCodeIndex( aFormatSeq, NF_TIME_HHMMSSAMPM );
+ ImpInsertFormat( aFormatSeq[nIdx],
+ CLOffset + ZF_STANDARD_TIME+3 /* NF_TIME_HHMMSSAMPM */ );
+
+ // [HH]:MM:SS
+ nIdx = ImpGetFormatCodeIndex( aFormatSeq, NF_TIME_HH_MMSS );
+ ImpInsertFormat( aFormatSeq[nIdx],
+ CLOffset + ZF_STANDARD_TIME+4 /* NF_TIME_HH_MMSS */ );
+
+ // MM:SS,00
+ nIdx = ImpGetFormatCodeIndex( aFormatSeq, NF_TIME_MMSS00 );
+ ImpInsertFormat( aFormatSeq[nIdx],
+ CLOffset + ZF_STANDARD_TIME+5 /* NF_TIME_MMSS00 */ );
+
+ // [HH]:MM:SS,00
+ nIdx = ImpGetFormatCodeIndex( aFormatSeq, NF_TIME_HH_MMSS00 );
+ ImpInsertFormat( aFormatSeq[nIdx],
+ CLOffset + ZF_STANDARD_TIME+6 /* NF_TIME_HH_MMSS00 */ );
+
+
+ // DateTime
+ aFormatSeq = xNFC->getAllFormatCode( i18n::KNumberFormatUsage::DATE_TIME, aLocale );
+ ImpAdjustFormatCodeDefault( aFormatSeq.getArray(), aFormatSeq.getLength() );
+
+ // DD.MM.YY HH:MM System
+ nIdx = ImpGetFormatCodeIndex( aFormatSeq, NF_DATETIME_SYSTEM_SHORT_HHMM );
+ ImpInsertFormat( aFormatSeq[nIdx],
+ CLOffset + ZF_STANDARD_DATETIME /* NF_DATETIME_SYSTEM_SHORT_HHMM */ );
+
+ // DD.MM.YYYY HH:MM:SS System
+ nIdx = ImpGetFormatCodeIndex( aFormatSeq, NF_DATETIME_SYS_DDMMYYYY_HHMMSS );
+ ImpInsertFormat( aFormatSeq[nIdx],
+ CLOffset + ZF_STANDARD_DATETIME+1 /* NF_DATETIME_SYS_DDMMYYYY_HHMMSS */ );
+
+ // DD.MM.YYYY HH:MM System
+ nIdx = ImpGetFormatCodeIndex( aFormatSeq, NF_DATETIME_SYS_DDMMYYYY_HHMM );
+ ImpInsertFormat( aFormatSeq[nIdx],
+ CLOffset + ZF_STANDARD_DATETIME+2 /* NF_DATETIME_SYS_DDMMYYYY_HHMM */ );
+
+ const NfKeywordTable & rKeyword = pFormatScanner->GetKeywords();
+ i18n::NumberFormatCode aSingleFormatCode;
+ aSingleFormatCode.Usage = i18n::KNumberFormatUsage::DATE_TIME;
+
+ // YYYY-MM-DD HH:MM:SS ISO (with blank instead of 'T')
+ aSingleFormatCode.Code =
+ rKeyword[NF_KEY_YYYY] + "-" +
+ rKeyword[NF_KEY_MM] + "-" +
+ rKeyword[NF_KEY_DD] + " " +
+ rKeyword[NF_KEY_HH] + ":" +
+ rKeyword[NF_KEY_MMI] + ":" +
+ rKeyword[NF_KEY_SS];
+ SvNumberformat* pFormat = ImpInsertFormat( aSingleFormatCode,
+ CLOffset + ZF_STANDARD_DATETIME+3 /* NF_DATETIME_ISO_YYYYMMDD_HHMMSS */ );
+ assert(pFormat);
+
+ // YYYY-MM-DD HH:MM:SS,000 ISO (with blank instead of 'T') and
+ // milliseconds and locale's time decimal separator
+ aSingleFormatCode.Code =
+ rKeyword[NF_KEY_YYYY] + "-" +
+ rKeyword[NF_KEY_MM] + "-" +
+ rKeyword[NF_KEY_DD] + " " +
+ rKeyword[NF_KEY_HH] + ":" +
+ rKeyword[NF_KEY_MMI] + ":" +
+ rKeyword[NF_KEY_SS] + GetLocaleData()->getTime100SecSep() +
+ "000";
+ pFormat = ImpInsertFormat( aSingleFormatCode,
+ CLOffset + ZF_STANDARD_DATETIME+4 /* NF_DATETIME_ISO_YYYYMMDD_HHMMSS000 */ );
+ assert(pFormat);
+
+ // YYYY-MM-DD"T"HH:MM:SS ISO
+ aSingleFormatCode.Code =
+ rKeyword[NF_KEY_YYYY] + "-" +
+ rKeyword[NF_KEY_MM] + "-" +
+ rKeyword[NF_KEY_DD] + "\"T\"" +
+ rKeyword[NF_KEY_HH] + ":" +
+ rKeyword[NF_KEY_MMI] + ":" +
+ rKeyword[NF_KEY_SS];
+ pFormat = ImpInsertFormat( aSingleFormatCode,
+ CLOffset + ZF_STANDARD_DATETIME+5 /* NF_DATETIME_ISO_YYYYMMDDTHHMMSS */ );
+ assert(pFormat);
+ pFormat->SetComment("ISO 8601"); // not to be localized
+
+ // YYYY-MM-DD"T"HH:MM:SS,000 ISO with milliseconds and ',' or '.' decimal separator
+ aSingleFormatCode.Code =
+ rKeyword[NF_KEY_YYYY] + "-" +
+ rKeyword[NF_KEY_MM] + "-" +
+ rKeyword[NF_KEY_DD] + "\"T\"" +
+ rKeyword[NF_KEY_HH] + ":" +
+ rKeyword[NF_KEY_MMI] + ":" +
+ rKeyword[NF_KEY_SS] + (GetLocaleData()->getTime100SecSep() == "." ? "." : ",") +
+ "000";
+ pFormat = ImpInsertFormat( aSingleFormatCode,
+ CLOffset + ZF_STANDARD_DATETIME+6 /* NF_DATETIME_ISO_YYYYMMDDTHHMMSS000 */ );
+ assert(pFormat);
+ pFormat->SetComment("ISO 8601"); // not to be localized
+
+
+ // Scientific number
+ aFormatSeq = xNFC->getAllFormatCode( i18n::KNumberFormatUsage::SCIENTIFIC_NUMBER, aLocale );
+ ImpAdjustFormatCodeDefault( aFormatSeq.getArray(), aFormatSeq.getLength() );
+
+ // 0.00E+000
+ nIdx = ImpGetFormatCodeIndex( aFormatSeq, NF_SCIENTIFIC_000E000 );
+ ImpInsertFormat( aFormatSeq[nIdx],
+ CLOffset + ZF_STANDARD_SCIENTIFIC /* NF_SCIENTIFIC_000E000 */ );
+
+ // 0.00E+00
+ nIdx = ImpGetFormatCodeIndex( aFormatSeq, NF_SCIENTIFIC_000E00 );
+ ImpInsertFormat( aFormatSeq[nIdx],
+ CLOffset + ZF_STANDARD_SCIENTIFIC+1 /* NF_SCIENTIFIC_000E00 */ );
+
+
+ // Fraction number (no default option)
+ aSingleFormatCode.Usage = i18n::KNumberFormatUsage::FRACTION_NUMBER;
+
+ // # ?/?
+ aSingleFormatCode.Code = "# ?/?";
+ ImpInsertFormat( aSingleFormatCode,
+ CLOffset + ZF_STANDARD_FRACTION /* NF_FRACTION_1D */ );
+
+ // # ??/??
+ //! "??/" would be interpreted by the compiler as a trigraph for '\'
+ aSingleFormatCode.Code = "# ?\?/?\?";
+ ImpInsertFormat( aSingleFormatCode,
+ CLOffset + ZF_STANDARD_FRACTION+1 /* NF_FRACTION_2D */ );
+
+ // # ???/???
+ //! "??/" would be interpreted by the compiler as a trigraph for '\'
+ aSingleFormatCode.Code = "# ?\?\?/?\?\?";
+ ImpInsertFormat( aSingleFormatCode,
+ CLOffset + ZF_STANDARD_FRACTION+2 /* NF_FRACTION_3D */ );
+
+ // # ?/2
+ aSingleFormatCode.Code = "# ?/2";
+ ImpInsertFormat( aSingleFormatCode,
+ CLOffset + ZF_STANDARD_FRACTION+3 /* NF_FRACTION_2 */ );
+
+ // # ?/4
+ aSingleFormatCode.Code = "# ?/4";
+ ImpInsertFormat( aSingleFormatCode,
+ CLOffset + ZF_STANDARD_FRACTION+4 /* NF_FRACTION_4 */ );
+
+ // # ?/8
+ aSingleFormatCode.Code = "# ?/8";
+ ImpInsertFormat( aSingleFormatCode,
+ CLOffset + ZF_STANDARD_FRACTION+5 /* NF_FRACTION_8 */ );
+
+ // # ??/16
+ aSingleFormatCode.Code = "# ?\?/16";
+ ImpInsertFormat( aSingleFormatCode,
+ CLOffset + ZF_STANDARD_FRACTION+6 /* NF_FRACTION_16 */ );
+
+ // # ??/10
+ aSingleFormatCode.Code = "# ?\?/10";
+ ImpInsertFormat( aSingleFormatCode,
+ CLOffset + ZF_STANDARD_FRACTION+7 /* NF_FRACTION_10 */ );
+
+ // # ??/100
+ aSingleFormatCode.Code = "# ?\?/100";
+ ImpInsertFormat( aSingleFormatCode,
+ CLOffset + ZF_STANDARD_FRACTION+8 /* NF_FRACTION_100 */ );
+
+
+ // Week of year
+ aSingleFormatCode.Code = rKeyword[NF_KEY_WW];
+ ImpInsertFormat( aSingleFormatCode,
+ CLOffset + ZF_STANDARD_DATE_WW /* NF_DATE_WW */ );
+
+ // Now all additional format codes provided by I18N, but only if not
+ // changing SystemCL, then they are appended last after user defined.
+ if ( !bNoAdditionalFormats )
+ {
+ ImpGenerateAdditionalFormats( CLOffset, xNFC, false );
+ }
+ if (bOldConvertMode)
+ {
+ pFormatScanner->SetConvertMode(true);
+ }
+}
+
+
+void SvNumberFormatter::ImpGenerateAdditionalFormats( sal_uInt32 CLOffset,
+ css::uno::Reference< css::i18n::XNumberFormatCode > const & rNumberFormatCode,
+ bool bAfterChangingSystemCL )
+{
+ SvNumberformat* pStdFormat = GetFormatEntry( CLOffset + ZF_STANDARD );
+ if ( !pStdFormat )
+ {
+ SAL_WARN( "svl.numbers", "ImpGenerateAdditionalFormats: no GENERAL format" );
+ return ;
+ }
+ sal_uInt32 nPos = CLOffset + pStdFormat->GetLastInsertKey( SvNumberformat::FormatterPrivateAccess() );
+ css::lang::Locale aLocale = GetLanguageTag().getLocale();
+
+ // All currencies, this time with [$...] which was stripped in
+ // ImpGenerateFormats for old "automatic" currency formats.
+ uno::Sequence< i18n::NumberFormatCode > aFormatSeq = rNumberFormatCode->getAllFormatCode( i18n::KNumberFormatUsage::CURRENCY, aLocale );
+ sal_Int32 nCodes = aFormatSeq.getLength();
+ auto aNonConstRange = asNonConstRange(aFormatSeq);
+ ImpAdjustFormatCodeDefault( aNonConstRange.begin(), nCodes);
+ for ( i18n::NumberFormatCode& rFormat : aNonConstRange )
+ {
+ if ( nPos - CLOffset >= SV_COUNTRY_LANGUAGE_OFFSET )
+ {
+ SAL_WARN( "svl.numbers", "ImpGenerateAdditionalFormats: too many formats" );
+ break; // for
+ }
+ if ( rFormat.Index < NF_INDEX_TABLE_RESERVED_START &&
+ rFormat.Index != NF_CURRENCY_1000DEC2_CCC )
+ { // Insert only if not already inserted, but internal index must be
+ // above so ImpInsertFormat can distinguish it.
+ sal_Int16 nOrgIndex = rFormat.Index;
+ rFormat.Index = sal::static_int_cast< sal_Int16 >(
+ rFormat.Index + nCodes + NF_INDEX_TABLE_ENTRIES);
+ //! no default on currency
+ bool bDefault = rFormat.Default;
+ rFormat.Default = false;
+ if ( SvNumberformat* pNewFormat = ImpInsertFormat( rFormat, nPos+1,
+ bAfterChangingSystemCL, nOrgIndex ) )
+ {
+ pNewFormat->SetAdditionalBuiltin();
+ nPos++;
+ }
+ rFormat.Index = nOrgIndex;
+ rFormat.Default = bDefault;
+ }
+ }
+
+ // All additional format codes provided by I18N that are not old standard
+ // index. Additional formats may define defaults, currently there is no
+ // check if more than one default of a usage/type combination is provided,
+ // like it is done for usage groups with ImpAdjustFormatCodeDefault().
+ // There is no harm though, on first invocation ImpGetDefaultFormat() will
+ // use the first default encountered.
+ aFormatSeq = rNumberFormatCode->getAllFormatCodes( aLocale );
+ for ( const auto& rFormat : std::as_const(aFormatSeq) )
+ {
+ if ( nPos - CLOffset >= SV_COUNTRY_LANGUAGE_OFFSET )
+ {
+ SAL_WARN( "svl.numbers", "ImpGenerateAdditionalFormats: too many formats" );
+ break; // for
+ }
+ if ( rFormat.Index >= NF_INDEX_TABLE_RESERVED_START )
+ {
+ if ( SvNumberformat* pNewFormat = ImpInsertFormat( rFormat, nPos+1,
+ bAfterChangingSystemCL ) )
+ {
+ pNewFormat->SetAdditionalBuiltin();
+ nPos++;
+ }
+ }
+ }
+
+ pStdFormat->SetLastInsertKey( static_cast<sal_uInt16>(nPos - CLOffset), SvNumberformat::FormatterPrivateAccess() );
+}
+
+
+sal_Int32 SvNumberFormatter::ImpPosToken ( const OUStringBuffer & sFormat, sal_Unicode token, sal_Int32 nStartPos /* = 0*/ ) const
+{
+ sal_Int32 nLength = sFormat.getLength();
+ for ( sal_Int32 i=nStartPos; i<nLength && i>=0 ; i++ )
+ {
+ switch(sFormat[i])
+ {
+ case '\"' : // skip text
+ i = sFormat.indexOf('\"',i+1);
+ break;
+ case '[' : // skip condition
+ i = sFormat.indexOf(']',i+1);
+ break;
+ case '\\' : // skip escaped character
+ i++;
+ break;
+ case ';' :
+ if (token == ';')
+ return i;
+ break;
+ case 'e' :
+ case 'E' :
+ if (token == 'E')
+ return i; // if 'E' is outside "" and [] it must be the 'E' exponent
+ break;
+ default : break;
+ }
+ if ( i<0 )
+ i--;
+ }
+ return -2;
+}
+
+OUString SvNumberFormatter::GenerateFormat(sal_uInt32 nIndex,
+ LanguageType eLnge,
+ bool bThousand,
+ bool IsRed,
+ sal_uInt16 nPrecision,
+ sal_uInt16 nLeadingZeros)
+{
+ ::osl::MutexGuard aGuard( GetInstanceMutex() );
+ if (eLnge == LANGUAGE_DONTKNOW)
+ {
+ eLnge = IniLnge;
+ }
+
+ const SvNumberformat* pFormat = GetFormatEntry( nIndex );
+ const SvNumFormatType eType = (pFormat ? pFormat->GetMaskedType() : SvNumFormatType::UNDEFINED);
+
+ ImpGenerateCL(eLnge); // create new standard formats if necessary
+
+ utl::DigitGroupingIterator aGrouping( xLocaleData->getDigitGrouping());
+ // always group of 3 for Engineering notation
+ const sal_Int32 nDigitsInFirstGroup = ( bThousand && (eType == SvNumFormatType::SCIENTIFIC) ) ? 3 : aGrouping.get();
+ const OUString& rThSep = GetNumThousandSep();
+
+ OUStringBuffer sString;
+ using comphelper::string::padToLength;
+
+ if (eType & SvNumFormatType::TIME)
+ {
+ assert(pFormat && "with !pFormat eType can only be SvNumFormatType::UNDEFINED");
+ sString = pFormat->GetFormatStringForTimePrecision( nPrecision );
+ }
+ else if (nLeadingZeros == 0)
+ {
+ if (!bThousand)
+ sString.append('#');
+ else
+ {
+ if (eType == SvNumFormatType::SCIENTIFIC)
+ { // for scientific, bThousand is used for Engineering notation
+ sString.append("###");
+ }
+ else
+ {
+ sString.append('#');
+ sString.append(rThSep);
+ padToLength(sString, sString.getLength() + nDigitsInFirstGroup, '#');
+ }
+ }
+ }
+ else
+ {
+ for (sal_uInt16 i = 0; i < nLeadingZeros; i++)
+ {
+ if (bThousand && i > 0 && i == aGrouping.getPos())
+ {
+ sString.insert(0, rThSep);
+ aGrouping.advance();
+ }
+ sString.insert(0, '0');
+ }
+ if ( bThousand )
+ {
+ sal_Int32 nDigits = (eType == SvNumFormatType::SCIENTIFIC) ? 3*((nLeadingZeros-1)/3 + 1) : nDigitsInFirstGroup + 1;
+ for (sal_Int32 i = nLeadingZeros; i < nDigits; i++)
+ {
+ if ( i % nDigitsInFirstGroup == 0 )
+ sString.insert(0, rThSep);
+ sString.insert(0, '#');
+ }
+ }
+ }
+ if (nPrecision > 0 && eType != SvNumFormatType::FRACTION && !( eType & SvNumFormatType::TIME ) )
+ {
+ sString.append(GetNumDecimalSep());
+ padToLength(sString, sString.getLength() + nPrecision, '0');
+ }
+ if (eType == SvNumFormatType::PERCENT)
+ {
+ sString.append( pFormat->GetPercentString() );
+ }
+ else if (eType == SvNumFormatType::SCIENTIFIC)
+ {
+ OUStringBuffer sOldFormatString(pFormat->GetFormatstring());
+ sal_Int32 nIndexE = ImpPosToken( sOldFormatString, 'E' );
+ if (nIndexE > -1)
+ {
+ sal_Int32 nIndexSep = ImpPosToken( sOldFormatString, ';', nIndexE );
+ if (nIndexSep > nIndexE)
+ sString.append( sOldFormatString.subView(nIndexE, nIndexSep - nIndexE) );
+ else
+ sString.append( sOldFormatString.subView(nIndexE) );
+ }
+ }
+ else if (eType == SvNumFormatType::CURRENCY)
+ {
+ OUStringBuffer sNegStr(sString);
+ OUString aCurr;
+ const NfCurrencyEntry* pEntry;
+ bool bBank;
+ if ( GetNewCurrencySymbolString( nIndex, aCurr, &pEntry, &bBank ) )
+ {
+ if ( pEntry )
+ {
+ sal_uInt16 nPosiForm = NfCurrencyEntry::GetEffectivePositiveFormat(
+ xLocaleData->getCurrPositiveFormat(),
+ pEntry->GetPositiveFormat(), bBank );
+ sal_uInt16 nNegaForm = NfCurrencyEntry::GetEffectiveNegativeFormat(
+ xLocaleData->getCurrNegativeFormat(),
+ pEntry->GetNegativeFormat(), bBank );
+ pEntry->CompletePositiveFormatString( sString, bBank, nPosiForm );
+ pEntry->CompleteNegativeFormatString( sNegStr, bBank, nNegaForm );
+ }
+ else
+ { // assume currency abbreviation (AKA banking symbol), not symbol
+ sal_uInt16 nPosiForm = NfCurrencyEntry::GetEffectivePositiveFormat(
+ xLocaleData->getCurrPositiveFormat(),
+ xLocaleData->getCurrPositiveFormat(), true );
+ sal_uInt16 nNegaForm = NfCurrencyEntry::GetEffectiveNegativeFormat(
+ xLocaleData->getCurrNegativeFormat(),
+ xLocaleData->getCurrNegativeFormat(), true );
+ NfCurrencyEntry::CompletePositiveFormatString( sString, aCurr, nPosiForm );
+ NfCurrencyEntry::CompleteNegativeFormatString( sNegStr, aCurr, nNegaForm );
+ }
+ }
+ else
+ { // "automatic" old style
+ OUString aSymbol, aAbbrev;
+ GetCompatibilityCurrency( aSymbol, aAbbrev );
+ NfCurrencyEntry::CompletePositiveFormatString( sString,
+ aSymbol, xLocaleData->getCurrPositiveFormat() );
+ NfCurrencyEntry::CompleteNegativeFormatString( sNegStr,
+ aSymbol, xLocaleData->getCurrNegativeFormat() );
+ }
+ if (IsRed)
+ {
+ sString.append(';');
+ sString.append('[');
+ sString.append(pFormatScanner->GetRedString());
+ sString.append(']');
+ }
+ else
+ {
+ sString.append(';');
+ }
+ sString.append(sNegStr);
+ }
+ else if (eType == SvNumFormatType::FRACTION)
+ {
+ OUString aIntegerFractionDelimiterString = pFormat->GetIntegerFractionDelimiterString( 0 );
+ if ( aIntegerFractionDelimiterString == " " )
+ sString.append( aIntegerFractionDelimiterString );
+ else
+ {
+ sString.append( '"' );
+ sString.append( aIntegerFractionDelimiterString );
+ sString.append( '"' );
+ }
+ sString.append( pFormat->GetNumeratorString( 0 ) );
+ sString.append( '/' );
+ if ( nPrecision > 0 )
+ padToLength(sString, sString.getLength() + nPrecision, '?');
+ else
+ sString.append( '#' );
+ }
+ if (eType != SvNumFormatType::CURRENCY)
+ {
+ bool insertBrackets = false;
+ if ( eType != SvNumFormatType::UNDEFINED)
+ {
+ insertBrackets = pFormat->IsNegativeInBracket();
+ }
+ if (IsRed || insertBrackets)
+ {
+ OUStringBuffer sTmpStr(sString);
+
+ if (pFormat && pFormat->HasPositiveBracketPlaceholder())
+ {
+ sTmpStr.append('_');
+ sTmpStr.append(')');
+ }
+ sTmpStr.append(';');
+
+ if (IsRed)
+ {
+ sTmpStr.append('[');
+ sTmpStr.append(pFormatScanner->GetRedString());
+ sTmpStr.append(']');
+ }
+
+ if (insertBrackets)
+ {
+ sTmpStr.append('(');
+ sTmpStr.append(sString);
+ sTmpStr.append(')');
+ }
+ else
+ {
+ sTmpStr.append('-');
+ sTmpStr.append(sString);
+ }
+ sString = sTmpStr;
+ }
+ }
+ return sString.makeStringAndClear();
+}
+
+bool SvNumberFormatter::IsUserDefined(sal_uInt32 F_Index) const
+{
+ ::osl::MutexGuard aGuard( GetInstanceMutex() );
+ const SvNumberformat* pFormat = GetFormatEntry(F_Index);
+
+ return pFormat && (pFormat->GetType() & SvNumFormatType::DEFINED);
+}
+
+bool SvNumberFormatter::IsUserDefined(std::u16string_view sStr,
+ LanguageType eLnge)
+{
+ ::osl::MutexGuard aGuard( GetInstanceMutex() );
+ if (eLnge == LANGUAGE_DONTKNOW)
+ {
+ eLnge = IniLnge;
+ }
+ sal_uInt32 CLOffset = ImpGenerateCL(eLnge); // create new standard formats if necessary
+ eLnge = ActLnge;
+
+ sal_uInt32 nKey = ImpIsEntry(sStr, CLOffset, eLnge);
+ if (nKey == NUMBERFORMAT_ENTRY_NOT_FOUND)
+ {
+ return true;
+ }
+ SvNumberformat* pEntry = GetFormatEntry( nKey );
+ return pEntry && (pEntry->GetType() & SvNumFormatType::DEFINED);
+}
+
+sal_uInt32 SvNumberFormatter::GetEntryKey(std::u16string_view sStr,
+ LanguageType eLnge)
+{
+ ::osl::MutexGuard aGuard( GetInstanceMutex() );
+ if (eLnge == LANGUAGE_DONTKNOW)
+ {
+ eLnge = IniLnge;
+ }
+ sal_uInt32 CLOffset = ImpGenerateCL(eLnge); // create new standard formats if necessary
+ return ImpIsEntry(sStr, CLOffset, eLnge);
+}
+
+sal_uInt32 SvNumberFormatter::GetStandardIndex(LanguageType eLnge)
+{
+ ::osl::MutexGuard aGuard( GetInstanceMutex() );
+ if (eLnge == LANGUAGE_DONTKNOW)
+ {
+ eLnge = IniLnge;
+ }
+ return GetStandardFormat(SvNumFormatType::NUMBER, eLnge);
+}
+
+SvNumFormatType SvNumberFormatter::GetType(sal_uInt32 nFIndex) const
+{
+ ::osl::MutexGuard aGuard( GetInstanceMutex() );
+ SvNumFormatType eType;
+ const SvNumberformat* pFormat = GetFormatEntry( nFIndex );
+ if (!pFormat)
+ {
+ eType = SvNumFormatType::UNDEFINED;
+ }
+ else
+ {
+ eType = pFormat->GetMaskedType();
+ if (eType == SvNumFormatType::ALL)
+ {
+ eType = SvNumFormatType::DEFINED;
+ }
+ }
+ return eType;
+}
+
+void SvNumberFormatter::ClearMergeTable()
+{
+ ::osl::MutexGuard aGuard( GetInstanceMutex() );
+ if ( pMergeTable )
+ {
+ pMergeTable->clear();
+ }
+}
+
+SvNumberFormatterIndexTable* SvNumberFormatter::MergeFormatter(SvNumberFormatter& rTable)
+{
+ ::osl::MutexGuard aGuard( GetInstanceMutex() );
+ if ( pMergeTable )
+ {
+ ClearMergeTable();
+ }
+ else
+ {
+ pMergeTable.reset( new SvNumberFormatterIndexTable );
+ }
+
+ sal_uInt32 nCLOffset = 0;
+ sal_uInt32 nOldKey, nOffset, nNewKey;
+
+ for (const auto& rEntry : rTable.aFTable)
+ {
+ SvNumberformat* pFormat = rEntry.second.get();
+ nOldKey = rEntry.first;
+ nOffset = nOldKey % SV_COUNTRY_LANGUAGE_OFFSET; // relative index
+ if (nOffset == 0) // 1st format of CL
+ {
+ nCLOffset = ImpGenerateCL(pFormat->GetLanguage());
+ }
+ if (nOffset <= SV_MAX_COUNT_STANDARD_FORMATS) // Std.form.
+ {
+ nNewKey = nCLOffset + nOffset;
+ if (aFTable.find( nNewKey) == aFTable.end()) // not already present
+ {
+ std::unique_ptr<SvNumberformat> pNewEntry(new SvNumberformat( *pFormat, *pFormatScanner ));
+ if (!aFTable.emplace( nNewKey, std::move(pNewEntry)).second)
+ {
+ SAL_WARN( "svl.numbers", "SvNumberFormatter::MergeFormatter: dup position");
+ }
+ }
+ if (nNewKey != nOldKey) // new index
+ {
+ (*pMergeTable)[nOldKey] = nNewKey;
+ }
+ }
+ else // user defined
+ {
+ std::unique_ptr<SvNumberformat> pNewEntry(new SvNumberformat( *pFormat, *pFormatScanner ));
+ nNewKey = ImpIsEntry(pNewEntry->GetFormatstring(),
+ nCLOffset,
+ pFormat->GetLanguage());
+ if (nNewKey == NUMBERFORMAT_ENTRY_NOT_FOUND) // only if not present yet
+ {
+ SvNumberformat* pStdFormat = GetFormatEntry(nCLOffset + ZF_STANDARD);
+ sal_uInt32 nPos = nCLOffset + pStdFormat->GetLastInsertKey( SvNumberformat::FormatterPrivateAccess() );
+ nNewKey = nPos+1;
+ if (nNewKey - nCLOffset >= SV_COUNTRY_LANGUAGE_OFFSET)
+ {
+ SAL_WARN( "svl.numbers", "SvNumberFormatter::MergeFormatter: too many formats for CL");
+ }
+ else if (!aFTable.emplace( nNewKey, std::move(pNewEntry)).second)
+ {
+ SAL_WARN( "svl.numbers", "SvNumberFormatter::MergeFormatter: dup position");
+ }
+ else
+ {
+ pStdFormat->SetLastInsertKey(static_cast<sal_uInt16>(nNewKey - nCLOffset),
+ SvNumberformat::FormatterPrivateAccess());
+ }
+ }
+ if (nNewKey != nOldKey) // new index
+ {
+ (*pMergeTable)[nOldKey] = nNewKey;
+ }
+ }
+ }
+ return pMergeTable.get();
+}
+
+
+SvNumberFormatterMergeMap SvNumberFormatter::ConvertMergeTableToMap()
+{
+ ::osl::MutexGuard aGuard( GetInstanceMutex() );
+ if (!HasMergeFormatTable())
+ {
+ return SvNumberFormatterMergeMap();
+ }
+ SvNumberFormatterMergeMap aMap;
+ for (const auto& rEntry : *pMergeTable)
+ {
+ sal_uInt32 nOldKey = rEntry.first;
+ aMap[ nOldKey ] = rEntry.second;
+ }
+ ClearMergeTable();
+ return aMap;
+}
+
+
+sal_uInt32 SvNumberFormatter::GetFormatForLanguageIfBuiltIn( sal_uInt32 nFormat,
+ LanguageType eLnge )
+{
+ ::osl::MutexGuard aGuard( GetInstanceMutex() );
+ if ( eLnge == LANGUAGE_DONTKNOW )
+ {
+ eLnge = IniLnge;
+ }
+ if ( nFormat < SV_COUNTRY_LANGUAGE_OFFSET && eLnge == IniLnge )
+ {
+ return nFormat; // it stays as it is
+ }
+ sal_uInt32 nOffset = nFormat % SV_COUNTRY_LANGUAGE_OFFSET; // relative index
+ if ( nOffset > SV_MAX_COUNT_STANDARD_FORMATS )
+ {
+ return nFormat; // not a built-in format
+ }
+ sal_uInt32 nCLOffset = ImpGenerateCL(eLnge); // create new standard formats if necessary
+ return nCLOffset + nOffset;
+}
+
+
+sal_uInt32 SvNumberFormatter::GetFormatIndex( NfIndexTableOffset nTabOff,
+ LanguageType eLnge )
+{
+ ::osl::MutexGuard aGuard( GetInstanceMutex() );
+ if (nTabOff >= NF_INDEX_TABLE_ENTRIES)
+ return NUMBERFORMAT_ENTRY_NOT_FOUND;
+
+ if (eLnge == LANGUAGE_DONTKNOW)
+ eLnge = IniLnge;
+
+ if (indexTable[nTabOff] == NUMBERFORMAT_ENTRY_NOT_FOUND)
+ return NUMBERFORMAT_ENTRY_NOT_FOUND;
+
+ sal_uInt32 nCLOffset = ImpGenerateCL(eLnge); // create new standard formats if necessary
+
+ return nCLOffset + indexTable[nTabOff];
+}
+
+
+NfIndexTableOffset SvNumberFormatter::GetIndexTableOffset( sal_uInt32 nFormat ) const
+{
+ ::osl::MutexGuard aGuard( GetInstanceMutex() );
+ sal_uInt32 nOffset = nFormat % SV_COUNTRY_LANGUAGE_OFFSET; // relative index
+ if ( nOffset > SV_MAX_COUNT_STANDARD_FORMATS )
+ {
+ return NF_INDEX_TABLE_ENTRIES; // not a built-in format
+ }
+
+ for ( sal_uInt16 j = 0; j < NF_INDEX_TABLE_ENTRIES; j++ )
+ {
+ if (indexTable[j] == nOffset)
+ return static_cast<NfIndexTableOffset>(j);
+ }
+ return NF_INDEX_TABLE_ENTRIES; // bad luck
+}
+
+void SvNumberFormatter::SetEvalDateFormat( NfEvalDateFormat eEDF )
+{
+ ::osl::MutexGuard aGuard( GetInstanceMutex() );
+ eEvalDateFormat = eEDF;
+}
+
+NfEvalDateFormat SvNumberFormatter::GetEvalDateFormat() const
+{
+ ::osl::MutexGuard aGuard( GetInstanceMutex() );
+ return eEvalDateFormat;
+}
+
+void SvNumberFormatter::SetYear2000( sal_uInt16 nVal )
+{
+ ::osl::MutexGuard aGuard( GetInstanceMutex() );
+ pStringScanner->SetYear2000( nVal );
+}
+
+
+sal_uInt16 SvNumberFormatter::GetYear2000() const
+{
+ ::osl::MutexGuard aGuard( GetInstanceMutex() );
+ return pStringScanner->GetYear2000();
+}
+
+
+sal_uInt16 SvNumberFormatter::ExpandTwoDigitYear( sal_uInt16 nYear ) const
+{
+ if ( nYear < 100 )
+ return SvNumberFormatter::ExpandTwoDigitYear( nYear,
+ pStringScanner->GetYear2000() );
+ return nYear;
+}
+
+
+// static
+sal_uInt16 SvNumberFormatter::GetYear2000Default()
+{
+ if (!utl::ConfigManager::IsFuzzing())
+ return officecfg::Office::Common::DateFormat::TwoDigitYear::get();
+ return 1930;
+}
+
+// static
+void SvNumberFormatter::resetTheCurrencyTable()
+{
+ SAL_INFO("svl", "Resetting the currency table.");
+
+ nSystemCurrencyPosition = 0;
+ bCurrencyTableInitialized = false;
+
+ GetFormatterRegistry().ConfigurationChanged(nullptr, ConfigurationHints::Locale | ConfigurationHints::Currency | ConfigurationHints::DatePatterns);
+}
+
+// static
+const NfCurrencyTable& SvNumberFormatter::GetTheCurrencyTable()
+{
+ while ( !bCurrencyTableInitialized )
+ ImpInitCurrencyTable();
+ return theCurrencyTable();
+}
+
+
+// static
+const NfCurrencyEntry* SvNumberFormatter::MatchSystemCurrency()
+{
+ // MUST call GetTheCurrencyTable() before accessing nSystemCurrencyPosition
+ const NfCurrencyTable& rTable = GetTheCurrencyTable();
+ return nSystemCurrencyPosition ? &rTable[nSystemCurrencyPosition] : nullptr;
+}
+
+
+// static
+const NfCurrencyEntry& SvNumberFormatter::GetCurrencyEntry( LanguageType eLang )
+{
+ if ( eLang == LANGUAGE_SYSTEM )
+ {
+ const NfCurrencyEntry* pCurr = MatchSystemCurrency();
+ return pCurr ? *pCurr : GetTheCurrencyTable()[0];
+ }
+ else
+ {
+ eLang = MsLangId::getRealLanguage( eLang );
+ const NfCurrencyTable& rTable = GetTheCurrencyTable();
+ sal_uInt16 nCount = rTable.size();
+ for ( sal_uInt16 j = 0; j < nCount; j++ )
+ {
+ if ( rTable[j].GetLanguage() == eLang )
+ return rTable[j];
+ }
+ return rTable[0];
+ }
+}
+
+
+// static
+const NfCurrencyEntry* SvNumberFormatter::GetCurrencyEntry(std::u16string_view rAbbrev, LanguageType eLang )
+{
+ eLang = MsLangId::getRealLanguage( eLang );
+ const NfCurrencyTable& rTable = GetTheCurrencyTable();
+ sal_uInt16 nCount = rTable.size();
+ for ( sal_uInt16 j = 0; j < nCount; j++ )
+ {
+ if ( rTable[j].GetLanguage() == eLang &&
+ rTable[j].GetBankSymbol() == rAbbrev )
+ {
+ return &rTable[j];
+ }
+ }
+ return nullptr;
+}
+
+
+// static
+const NfCurrencyEntry* SvNumberFormatter::GetLegacyOnlyCurrencyEntry( std::u16string_view rSymbol,
+ std::u16string_view rAbbrev )
+{
+ GetTheCurrencyTable(); // just for initialization
+ const NfCurrencyTable& rTable = theLegacyOnlyCurrencyTable();
+ sal_uInt16 nCount = rTable.size();
+ for ( sal_uInt16 j = 0; j < nCount; j++ )
+ {
+ if ( rTable[j].GetSymbol() == rSymbol &&
+ rTable[j].GetBankSymbol() == rAbbrev )
+ {
+ return &rTable[j];
+ }
+ }
+ return nullptr;
+}
+
+
+// static
+IMPL_STATIC_LINK_NOARG( SvNumberFormatter, CurrencyChangeLink, LinkParamNone*, void )
+{
+ OUString aAbbrev;
+ LanguageType eLang = LANGUAGE_SYSTEM;
+ SvtSysLocaleOptions().GetCurrencyAbbrevAndLanguage( aAbbrev, eLang );
+ SetDefaultSystemCurrency( aAbbrev, eLang );
+}
+
+
+// static
+void SvNumberFormatter::SetDefaultSystemCurrency( std::u16string_view rAbbrev, LanguageType eLang )
+{
+ ::osl::MutexGuard aGuard( GetGlobalMutex() );
+ if ( eLang == LANGUAGE_SYSTEM )
+ {
+ eLang = SvtSysLocale().GetLanguageTag().getLanguageType();
+ }
+ const NfCurrencyTable& rTable = GetTheCurrencyTable();
+ sal_uInt16 nCount = rTable.size();
+ if ( !rAbbrev.empty() )
+ {
+ for ( sal_uInt16 j = 0; j < nCount; j++ )
+ {
+ if ( rTable[j].GetLanguage() == eLang && rTable[j].GetBankSymbol() == rAbbrev )
+ {
+ nSystemCurrencyPosition = j;
+ return ;
+ }
+ }
+ }
+ else
+ {
+ for ( sal_uInt16 j = 0; j < nCount; j++ )
+ {
+ if ( rTable[j].GetLanguage() == eLang )
+ {
+ nSystemCurrencyPosition = j;
+ return ;
+ }
+ }
+ }
+ nSystemCurrencyPosition = 0; // not found => simple SYSTEM
+}
+
+
+void SvNumberFormatter::ResetDefaultSystemCurrency()
+{
+ nDefaultSystemCurrencyFormat = NUMBERFORMAT_ENTRY_NOT_FOUND;
+}
+
+
+void SvNumberFormatter::InvalidateDateAcceptancePatterns()
+{
+ pStringScanner->InvalidateDateAcceptancePatterns();
+}
+
+
+sal_uInt32 SvNumberFormatter::ImpGetDefaultSystemCurrencyFormat()
+{
+ if ( nDefaultSystemCurrencyFormat == NUMBERFORMAT_ENTRY_NOT_FOUND )
+ {
+ sal_Int32 nCheck;
+ SvNumFormatType nType;
+ NfWSStringsDtor aCurrList;
+ sal_uInt16 nDefault = GetCurrencyFormatStrings( aCurrList,
+ GetCurrencyEntry( LANGUAGE_SYSTEM ), false );
+ DBG_ASSERT( aCurrList.size(), "where is the NewCurrency System standard format?!?" );
+ // if already loaded or user defined nDefaultSystemCurrencyFormat
+ // will be set to the right value
+ PutEntry( aCurrList[ nDefault ], nCheck, nType,
+ nDefaultSystemCurrencyFormat, LANGUAGE_SYSTEM );
+ DBG_ASSERT( nCheck == 0, "NewCurrency CheckError" );
+ DBG_ASSERT( nDefaultSystemCurrencyFormat != NUMBERFORMAT_ENTRY_NOT_FOUND,
+ "nDefaultSystemCurrencyFormat == NUMBERFORMAT_ENTRY_NOT_FOUND" );
+ }
+ return nDefaultSystemCurrencyFormat;
+}
+
+
+sal_uInt32 SvNumberFormatter::ImpGetDefaultCurrencyFormat()
+{
+ sal_uInt32 CLOffset = ImpGetCLOffset( ActLnge );
+ DefaultFormatKeysMap::const_iterator it = aDefaultFormatKeys.find( CLOffset + ZF_STANDARD_CURRENCY );
+ sal_uInt32 nDefaultCurrencyFormat = (it != aDefaultFormatKeys.end() ?
+ it->second : NUMBERFORMAT_ENTRY_NOT_FOUND);
+ if ( nDefaultCurrencyFormat == NUMBERFORMAT_ENTRY_NOT_FOUND )
+ {
+ // look for a defined standard
+ sal_uInt32 nStopKey = CLOffset + SV_COUNTRY_LANGUAGE_OFFSET;
+ sal_uInt32 nKey(0);
+ auto it2 = aFTable.lower_bound( CLOffset );
+ while ( it2 != aFTable.end() && (nKey = it2->first) >= CLOffset && nKey < nStopKey )
+ {
+ const SvNumberformat* pEntry = it2->second.get();
+ if ( pEntry->IsStandard() && (pEntry->GetType() & SvNumFormatType::CURRENCY) )
+ {
+ nDefaultCurrencyFormat = nKey;
+ break; // while
+ }
+ ++it2;
+ }
+
+ if ( nDefaultCurrencyFormat == NUMBERFORMAT_ENTRY_NOT_FOUND )
+ { // none found, create one
+ sal_Int32 nCheck;
+ NfWSStringsDtor aCurrList;
+ sal_uInt16 nDefault = GetCurrencyFormatStrings( aCurrList,
+ GetCurrencyEntry( ActLnge ), false );
+ DBG_ASSERT( aCurrList.size(), "where is the NewCurrency standard format?" );
+ if ( !aCurrList.empty() )
+ {
+ // if already loaded or user defined nDefaultSystemCurrencyFormat
+ // will be set to the right value
+ SvNumFormatType nType;
+ PutEntry( aCurrList[ nDefault ], nCheck, nType,
+ nDefaultCurrencyFormat, ActLnge );
+ DBG_ASSERT( nCheck == 0, "NewCurrency CheckError" );
+ DBG_ASSERT( nDefaultCurrencyFormat != NUMBERFORMAT_ENTRY_NOT_FOUND,
+ "nDefaultCurrencyFormat == NUMBERFORMAT_ENTRY_NOT_FOUND" );
+ }
+ // old automatic currency format as a last resort
+ if ( nDefaultCurrencyFormat == NUMBERFORMAT_ENTRY_NOT_FOUND )
+ nDefaultCurrencyFormat = CLOffset + ZF_STANDARD_CURRENCY+3;
+ else
+ { // mark as standard so that it is found next time
+ SvNumberformat* pEntry = GetFormatEntry( nDefaultCurrencyFormat );
+ if ( pEntry )
+ pEntry->SetStandard();
+ }
+ }
+ aDefaultFormatKeys[ CLOffset + ZF_STANDARD_CURRENCY ] = nDefaultCurrencyFormat;
+ }
+ return nDefaultCurrencyFormat;
+}
+
+
+// static
+// true: continue; false: break loop, if pFoundEntry==NULL dupe found
+bool SvNumberFormatter::ImpLookupCurrencyEntryLoopBody(
+ const NfCurrencyEntry*& pFoundEntry, bool& bFoundBank, const NfCurrencyEntry* pData,
+ sal_uInt16 nPos, std::u16string_view rSymbol )
+{
+ bool bFound;
+ if ( pData->GetSymbol() == rSymbol )
+ {
+ bFound = true;
+ bFoundBank = false;
+ }
+ else if ( pData->GetBankSymbol() == rSymbol )
+ {
+ bFound = true;
+ bFoundBank = true;
+ }
+ else
+ bFound = false;
+ if ( bFound )
+ {
+ if ( pFoundEntry && pFoundEntry != pData )
+ {
+ pFoundEntry = nullptr;
+ return false; // break loop, not unique
+ }
+ if ( nPos == 0 )
+ { // first entry is SYSTEM
+ pFoundEntry = MatchSystemCurrency();
+ if ( pFoundEntry )
+ {
+ return false; // break loop
+ // even if there are more matching entries
+ // this one is probably the one we are looking for
+ }
+ else
+ {
+ pFoundEntry = pData;
+ }
+ }
+ else
+ {
+ pFoundEntry = pData;
+ }
+ }
+ return true;
+}
+
+
+bool SvNumberFormatter::GetNewCurrencySymbolString( sal_uInt32 nFormat, OUString& rStr,
+ const NfCurrencyEntry** ppEntry /* = NULL */,
+ bool* pBank /* = NULL */ ) const
+{
+ ::osl::MutexGuard aGuard( GetInstanceMutex() );
+ if ( ppEntry )
+ *ppEntry = nullptr;
+ if ( pBank )
+ *pBank = false;
+
+ const SvNumberformat* pFormat = GetFormatEntry(nFormat);
+ if ( pFormat )
+ {
+ OUString aSymbol, aExtension;
+ if ( pFormat->GetNewCurrencySymbol( aSymbol, aExtension ) )
+ {
+ OUStringBuffer sBuff(128); // guess-estimate of a value that will pretty much guarantee no re-alloc
+ if ( ppEntry )
+ {
+ bool bFoundBank = false;
+ // we definitely need an entry matching the format code string
+ const NfCurrencyEntry* pFoundEntry = GetCurrencyEntry(
+ bFoundBank, aSymbol, aExtension, pFormat->GetLanguage(),
+ true );
+ if ( pFoundEntry )
+ {
+ *ppEntry = pFoundEntry;
+ if ( pBank )
+ *pBank = bFoundBank;
+ rStr = pFoundEntry->BuildSymbolString(bFoundBank);
+ }
+ }
+ if ( rStr.isEmpty() )
+ { // analog to BuildSymbolString
+ sBuff.append("[$");
+ if ( aSymbol.indexOf( '-' ) != -1 ||
+ aSymbol.indexOf( ']' ) != -1 )
+ {
+ sBuff.append('"');
+ sBuff.append( aSymbol);
+ sBuff.append('"');
+ }
+ else
+ {
+ sBuff.append(aSymbol);
+ }
+ if ( !aExtension.isEmpty() )
+ {
+ sBuff.append(aExtension);
+ }
+ sBuff.append(']');
+ }
+ rStr = sBuff.makeStringAndClear();
+ return true;
+ }
+ }
+ rStr.clear();
+ return false;
+}
+
+
+// static
+const NfCurrencyEntry* SvNumberFormatter::GetCurrencyEntry( bool & bFoundBank,
+ std::u16string_view rSymbol,
+ const OUString& rExtension,
+ LanguageType eFormatLanguage,
+ bool bOnlyStringLanguage )
+{
+ sal_Int32 nExtLen = rExtension.getLength();
+ LanguageType eExtLang;
+ if ( nExtLen )
+ {
+ // rExtension should be a 16-bit hex value max FFFF which may contain a
+ // leading "-" separator (that is not a minus sign, but toInt32 can be
+ // used to parse it, with post-processing as necessary):
+ sal_Int32 nExtLang = rExtension.toInt32( 16 );
+ if ( !nExtLang )
+ {
+ eExtLang = LANGUAGE_DONTKNOW;
+ }
+ else
+ {
+ eExtLang = LanguageType((nExtLang < 0) ? -nExtLang : nExtLang);
+ }
+ }
+ else
+ {
+ eExtLang = LANGUAGE_DONTKNOW;
+ }
+ const NfCurrencyEntry* pFoundEntry = nullptr;
+ const NfCurrencyTable& rTable = GetTheCurrencyTable();
+ sal_uInt16 nCount = rTable.size();
+ bool bCont = true;
+
+ // first try with given extension language/country
+ if ( nExtLen )
+ {
+ for ( sal_uInt16 j = 0; j < nCount && bCont; j++ )
+ {
+ LanguageType eLang = rTable[j].GetLanguage();
+ if ( eLang == eExtLang ||
+ ((eExtLang == LANGUAGE_DONTKNOW) &&
+ (eLang == LANGUAGE_SYSTEM)))
+ {
+ bCont = ImpLookupCurrencyEntryLoopBody( pFoundEntry, bFoundBank,
+ &rTable[j], j, rSymbol );
+ }
+ }
+ }
+
+ // ok?
+ if ( pFoundEntry || !bCont || (bOnlyStringLanguage && nExtLen) )
+ {
+ return pFoundEntry;
+ }
+ if ( !bOnlyStringLanguage )
+ {
+ // now try the language/country of the number format
+ for ( sal_uInt16 j = 0; j < nCount && bCont; j++ )
+ {
+ LanguageType eLang = rTable[j].GetLanguage();
+ if ( eLang == eFormatLanguage ||
+ ((eFormatLanguage == LANGUAGE_DONTKNOW) &&
+ (eLang == LANGUAGE_SYSTEM)))
+ {
+ bCont = ImpLookupCurrencyEntryLoopBody( pFoundEntry, bFoundBank,
+ &rTable[j], j, rSymbol );
+ }
+ }
+
+ // ok?
+ if ( pFoundEntry || !bCont )
+ {
+ return pFoundEntry;
+ }
+ }
+
+ // then try without language/country if no extension specified
+ if ( !nExtLen )
+ {
+ for ( sal_uInt16 j = 0; j < nCount && bCont; j++ )
+ {
+ bCont = ImpLookupCurrencyEntryLoopBody( pFoundEntry, bFoundBank,
+ &rTable[j], j, rSymbol );
+ }
+ }
+
+ return pFoundEntry;
+}
+
+
+void SvNumberFormatter::GetCompatibilityCurrency( OUString& rSymbol, OUString& rAbbrev ) const
+{
+ ::osl::MutexGuard aGuard( GetInstanceMutex() );
+ const css::uno::Sequence< css::i18n::Currency2 >
+ xCurrencies( xLocaleData->getAllCurrencies() );
+
+ auto pCurrency = std::find_if(xCurrencies.begin(), xCurrencies.end(),
+ [](const css::i18n::Currency2& rCurrency) { return rCurrency.UsedInCompatibleFormatCodes; });
+ if (pCurrency != xCurrencies.end())
+ {
+ rSymbol = pCurrency->Symbol;
+ rAbbrev = pCurrency->BankSymbol;
+ }
+ else
+ {
+ if (LocaleDataWrapper::areChecksEnabled())
+ {
+ LocaleDataWrapper::outputCheckMessage( xLocaleData->
+ appendLocaleInfo( u"GetCompatibilityCurrency: none?"));
+ }
+ rSymbol = xLocaleData->getCurrSymbol();
+ rAbbrev = xLocaleData->getCurrBankSymbol();
+ }
+}
+
+
+static void lcl_CheckCurrencySymbolPosition( const NfCurrencyEntry& rCurr )
+{
+ switch ( rCurr.GetPositiveFormat() )
+ {
+ case 0: // $1
+ case 1: // 1$
+ case 2: // $ 1
+ case 3: // 1 $
+ break;
+ default:
+ LocaleDataWrapper::outputCheckMessage( "lcl_CheckCurrencySymbolPosition: unknown PositiveFormat");
+ break;
+ }
+ switch ( rCurr.GetNegativeFormat() )
+ {
+ case 0: // ($1)
+ case 1: // -$1
+ case 2: // $-1
+ case 3: // $1-
+ case 4: // (1$)
+ case 5: // -1$
+ case 6: // 1-$
+ case 7: // 1$-
+ case 8: // -1 $
+ case 9: // -$ 1
+ case 10: // 1 $-
+ case 11: // $ -1
+ case 12 : // $ 1-
+ case 13 : // 1- $
+ case 14 : // ($ 1)
+ case 15 : // (1 $)
+ break;
+ default:
+ LocaleDataWrapper::outputCheckMessage( "lcl_CheckCurrencySymbolPosition: unknown NegativeFormat");
+ break;
+ }
+}
+
+// static
+bool SvNumberFormatter::IsLocaleInstalled( LanguageType eLang )
+{
+ // The set is initialized as a side effect of the currency table
+ // created, make sure that exists, which usually is the case unless a
+ // SvNumberFormatter was never instantiated.
+ GetTheCurrencyTable();
+ return theInstalledLocales.find( eLang) != theInstalledLocales.end();
+}
+
+// static
+void SvNumberFormatter::ImpInitCurrencyTable()
+{
+ // Race condition possible:
+ // ::osl::MutexGuard aGuard( GetMutex() );
+ // while ( !bCurrencyTableInitialized )
+ // ImpInitCurrencyTable();
+ static bool bInitializing = false;
+ if ( bCurrencyTableInitialized || bInitializing )
+ {
+ return ;
+ }
+ bInitializing = true;
+
+ LanguageType eSysLang = SvtSysLocale().GetLanguageTag().getLanguageType();
+ std::optional<LocaleDataWrapper> pLocaleData(std::in_place,
+ ::comphelper::getProcessComponentContext(),
+ SvtSysLocale().GetLanguageTag() );
+ // get user configured currency
+ OUString aConfiguredCurrencyAbbrev;
+ LanguageType eConfiguredCurrencyLanguage = LANGUAGE_SYSTEM;
+ SvtSysLocaleOptions().GetCurrencyAbbrevAndLanguage(
+ aConfiguredCurrencyAbbrev, eConfiguredCurrencyLanguage );
+ sal_uInt16 nSecondarySystemCurrencyPosition = 0;
+ sal_uInt16 nMatchingSystemCurrencyPosition = 0;
+
+ // First entry is SYSTEM:
+ auto& rCurrencyTable = theCurrencyTable();
+ rCurrencyTable.insert(
+ rCurrencyTable.begin(),
+ NfCurrencyEntry(*pLocaleData, LANGUAGE_SYSTEM));
+ sal_uInt16 nCurrencyPos = 1;
+
+ const css::uno::Sequence< css::lang::Locale > xLoc = LocaleDataWrapper::getInstalledLocaleNames();
+ sal_Int32 nLocaleCount = xLoc.getLength();
+ SAL_INFO( "svl.numbers", "number of locales: \"" << nLocaleCount << "\"" );
+ NfCurrencyTable &rLegacyOnlyCurrencyTable = theLegacyOnlyCurrencyTable();
+ sal_uInt16 nLegacyOnlyCurrencyPos = 0;
+ for ( css::lang::Locale const & rLocale : xLoc )
+ {
+ LanguageType eLang = LanguageTag::convertToLanguageType( rLocale, false);
+ theInstalledLocales.insert( eLang);
+ pLocaleData.emplace(
+ ::comphelper::getProcessComponentContext(),
+ LanguageTag(rLocale) );
+ Sequence< Currency2 > aCurrSeq = pLocaleData->getAllCurrencies();
+ sal_Int32 nCurrencyCount = aCurrSeq.getLength();
+ Currency2 const * const pCurrencies = aCurrSeq.getConstArray();
+
+ // one default currency for each locale, insert first so it is found first
+ sal_Int32 nDefault;
+ for ( nDefault = 0; nDefault < nCurrencyCount; nDefault++ )
+ {
+ if ( pCurrencies[nDefault].Default )
+ break;
+ }
+ std::optional<NfCurrencyEntry> pEntry;
+ if ( nDefault < nCurrencyCount )
+ {
+ pEntry.emplace(pCurrencies[nDefault], *pLocaleData, eLang);
+ }
+ else
+ { // first or ShellsAndPebbles
+ pEntry.emplace(*pLocaleData, eLang);
+ }
+ if (LocaleDataWrapper::areChecksEnabled())
+ {
+ lcl_CheckCurrencySymbolPosition( *pEntry );
+ }
+ if ( !nSystemCurrencyPosition && !aConfiguredCurrencyAbbrev.isEmpty() &&
+ pEntry->GetBankSymbol() == aConfiguredCurrencyAbbrev &&
+ pEntry->GetLanguage() == eConfiguredCurrencyLanguage )
+ {
+ nSystemCurrencyPosition = nCurrencyPos;
+ }
+ if ( !nMatchingSystemCurrencyPosition &&
+ pEntry->GetLanguage() == eSysLang )
+ {
+ nMatchingSystemCurrencyPosition = nCurrencyPos;
+ }
+ rCurrencyTable.insert(
+ rCurrencyTable.begin() + nCurrencyPos++, std::move(*pEntry));
+ // all remaining currencies for each locale
+ if ( nCurrencyCount > 1 )
+ {
+ sal_Int32 nCurrency;
+ for ( nCurrency = 0; nCurrency < nCurrencyCount; nCurrency++ )
+ {
+ if (pCurrencies[nCurrency].LegacyOnly)
+ {
+ rLegacyOnlyCurrencyTable.insert(
+ rLegacyOnlyCurrencyTable.begin() + nLegacyOnlyCurrencyPos++,
+ NfCurrencyEntry(
+ pCurrencies[nCurrency], *pLocaleData, eLang));
+ }
+ else if ( nCurrency != nDefault )
+ {
+ pEntry.emplace(pCurrencies[nCurrency], *pLocaleData, eLang);
+ // no dupes
+ bool bInsert = true;
+ sal_uInt16 n = rCurrencyTable.size();
+ sal_uInt16 aCurrencyIndex = 1; // skip first SYSTEM entry
+ for ( sal_uInt16 j=1; j<n; j++ )
+ {
+ if ( rCurrencyTable[aCurrencyIndex++] == *pEntry )
+ {
+ bInsert = false;
+ break; // for
+ }
+ }
+ if ( !bInsert )
+ {
+ pEntry.reset();
+ }
+ else
+ {
+ if ( !nSecondarySystemCurrencyPosition &&
+ (!aConfiguredCurrencyAbbrev.isEmpty() ?
+ pEntry->GetBankSymbol() == aConfiguredCurrencyAbbrev :
+ pEntry->GetLanguage() == eConfiguredCurrencyLanguage) )
+ {
+ nSecondarySystemCurrencyPosition = nCurrencyPos;
+ }
+ if ( !nMatchingSystemCurrencyPosition &&
+ pEntry->GetLanguage() == eSysLang )
+ {
+ nMatchingSystemCurrencyPosition = nCurrencyPos;
+ }
+ rCurrencyTable.insert(
+ rCurrencyTable.begin() + nCurrencyPos++, std::move(*pEntry));
+ }
+ }
+ }
+ }
+ }
+ if ( !nSystemCurrencyPosition )
+ {
+ nSystemCurrencyPosition = nSecondarySystemCurrencyPosition;
+ }
+ if ((!aConfiguredCurrencyAbbrev.isEmpty() && !nSystemCurrencyPosition) &&
+ LocaleDataWrapper::areChecksEnabled())
+ {
+ LocaleDataWrapper::outputCheckMessage(
+ "SvNumberFormatter::ImpInitCurrencyTable: configured currency not in I18N locale data.");
+ }
+ // match SYSTEM if no configured currency found
+ if ( !nSystemCurrencyPosition )
+ {
+ nSystemCurrencyPosition = nMatchingSystemCurrencyPosition;
+ }
+ if ((aConfiguredCurrencyAbbrev.isEmpty() && !nSystemCurrencyPosition) &&
+ LocaleDataWrapper::areChecksEnabled())
+ {
+ LocaleDataWrapper::outputCheckMessage(
+ "SvNumberFormatter::ImpInitCurrencyTable: system currency not in I18N locale data.");
+ }
+ pLocaleData.reset();
+ SvtSysLocaleOptions::SetCurrencyChangeLink( LINK( nullptr, SvNumberFormatter, CurrencyChangeLink ) );
+ bInitializing = false;
+ bCurrencyTableInitialized = true;
+}
+
+
+static std::ptrdiff_t addToCurrencyFormatsList( NfWSStringsDtor& rStrArr, const OUString& rFormat )
+{
+ // Prevent duplicates even over subsequent calls of
+ // GetCurrencyFormatStrings() with the same vector.
+ NfWSStringsDtor::const_iterator it( std::find( rStrArr.begin(), rStrArr.end(), rFormat));
+ if (it != rStrArr.end())
+ return it - rStrArr.begin();
+
+ rStrArr.push_back( rFormat);
+ return rStrArr.size() - 1;
+}
+
+
+sal_uInt16 SvNumberFormatter::GetCurrencyFormatStrings( NfWSStringsDtor& rStrArr,
+ const NfCurrencyEntry& rCurr,
+ bool bBank ) const
+{
+ ::osl::MutexGuard aGuard( GetInstanceMutex() );
+ OUString aRed = "["
+ + pFormatScanner->GetRedString()
+ + "]";
+
+ sal_uInt16 nDefault = 0;
+ if ( bBank )
+ {
+ // Only bank symbols.
+ OUString aPositiveBank = rCurr.BuildPositiveFormatString(true, *xLocaleData);
+ OUString aNegativeBank = rCurr.BuildNegativeFormatString(true, *xLocaleData );
+
+ OUString format1 = aPositiveBank
+ + ";"
+ + aNegativeBank;
+ addToCurrencyFormatsList( rStrArr, format1);
+
+ OUString format2 = aPositiveBank
+ + ";"
+ + aRed
+ + aNegativeBank;
+ nDefault = addToCurrencyFormatsList( rStrArr, format2);
+ }
+ else
+ {
+ // Mixed formats like in SvNumberFormatter::ImpGenerateFormats() but no
+ // duplicates if no decimals in currency.
+ OUString aPositive = rCurr.BuildPositiveFormatString(false, *xLocaleData );
+ OUString aNegative = rCurr.BuildNegativeFormatString(false, *xLocaleData );
+ OUString format1;
+ OUString format2;
+ OUString format3;
+ OUString format4;
+ OUString format5;
+ if (rCurr.GetDigits())
+ {
+ OUString aPositiveNoDec = rCurr.BuildPositiveFormatString(false, *xLocaleData, 0);
+ OUString aNegativeNoDec = rCurr.BuildNegativeFormatString(false, *xLocaleData, 0 );
+ OUString aPositiveDashed = rCurr.BuildPositiveFormatString(false, *xLocaleData, 2);
+ OUString aNegativeDashed = rCurr.BuildNegativeFormatString(false, *xLocaleData, 2);
+
+ format1 = aPositiveNoDec
+ + ";"
+ + aNegativeNoDec;
+
+ format3 = aPositiveNoDec
+ + ";"
+ + aRed
+ + aNegativeNoDec;
+
+ format5 = aPositiveDashed
+ + ";"
+ + aRed
+ + aNegativeDashed;
+ }
+
+ format2 = aPositive
+ + ";"
+ + aNegative;
+
+ format4 = aPositive
+ + ";"
+ + aRed
+ + aNegative;
+
+ if (rCurr.GetDigits())
+ {
+ addToCurrencyFormatsList( rStrArr, format1);
+ }
+ addToCurrencyFormatsList( rStrArr, format2);
+ if (rCurr.GetDigits())
+ {
+ addToCurrencyFormatsList( rStrArr, format3);
+ }
+ nDefault = addToCurrencyFormatsList( rStrArr, format4);
+ if (rCurr.GetDigits())
+ {
+ addToCurrencyFormatsList( rStrArr, format5);
+ }
+ }
+ return nDefault;
+}
+
+sal_uInt32 SvNumberFormatter::GetMergeFormatIndex( sal_uInt32 nOldFmt ) const
+{
+ ::osl::MutexGuard aGuard( GetInstanceMutex() );
+ if (pMergeTable)
+ {
+ SvNumberFormatterIndexTable::const_iterator it = pMergeTable->find(nOldFmt);
+ if (it != pMergeTable->end())
+ {
+ return it->second;
+ }
+ }
+ return nOldFmt;
+}
+
+bool SvNumberFormatter::HasMergeFormatTable() const
+{
+ ::osl::MutexGuard aGuard( GetInstanceMutex() );
+ return pMergeTable && !pMergeTable->empty();
+}
+
+// static
+sal_uInt16 SvNumberFormatter::ExpandTwoDigitYear( sal_uInt16 nYear, sal_uInt16 nTwoDigitYearStart )
+{
+ if ( nYear < 100 )
+ {
+ if ( nYear < (nTwoDigitYearStart % 100) )
+ {
+ return nYear + (((nTwoDigitYearStart / 100) + 1) * 100);
+ }
+ else
+ {
+ return nYear + ((nTwoDigitYearStart / 100) * 100);
+ }
+ }
+ return nYear;
+}
+
+NfCurrencyEntry::NfCurrencyEntry( const LocaleDataWrapper& rLocaleData, LanguageType eLang )
+{
+ aSymbol = rLocaleData.getCurrSymbol();
+ aBankSymbol = rLocaleData.getCurrBankSymbol();
+ eLanguage = eLang;
+ nPositiveFormat = rLocaleData.getCurrPositiveFormat();
+ nNegativeFormat = rLocaleData.getCurrNegativeFormat();
+ nDigits = rLocaleData.getCurrDigits();
+ cZeroChar = rLocaleData.getCurrZeroChar();
+}
+
+
+NfCurrencyEntry::NfCurrencyEntry( const css::i18n::Currency & rCurr,
+ const LocaleDataWrapper& rLocaleData, LanguageType eLang )
+{
+ aSymbol = rCurr.Symbol;
+ aBankSymbol = rCurr.BankSymbol;
+ eLanguage = eLang;
+ nPositiveFormat = rLocaleData.getCurrPositiveFormat();
+ nNegativeFormat = rLocaleData.getCurrNegativeFormat();
+ nDigits = rCurr.DecimalPlaces;
+ cZeroChar = rLocaleData.getCurrZeroChar();
+}
+
+bool NfCurrencyEntry::operator==( const NfCurrencyEntry& r ) const
+{
+ return aSymbol == r.aSymbol
+ && aBankSymbol == r.aBankSymbol
+ && eLanguage == r.eLanguage
+ ;
+}
+
+OUString NfCurrencyEntry::BuildSymbolString(bool bBank,
+ bool bWithoutExtension) const
+{
+ OUStringBuffer aBuf("[$");
+ if (bBank)
+ {
+ aBuf.append(aBankSymbol);
+ }
+ else
+ {
+ if ( aSymbol.indexOf( '-' ) >= 0 ||
+ aSymbol.indexOf( ']' ) >= 0)
+ {
+ aBuf.append("\"" + aSymbol + "\"");
+ }
+ else
+ {
+ aBuf.append(aSymbol);
+ }
+ if ( !bWithoutExtension && eLanguage != LANGUAGE_DONTKNOW && eLanguage != LANGUAGE_SYSTEM )
+ {
+ sal_Int32 nLang = static_cast<sal_uInt16>(eLanguage);
+ aBuf.append('-').append(OUString::number(nLang, 16).toAsciiUpperCase());
+ }
+ }
+ aBuf.append(']');
+ return aBuf.makeStringAndClear();
+}
+
+OUString NfCurrencyEntry::Impl_BuildFormatStringNumChars( const LocaleDataWrapper& rLoc,
+ sal_uInt16 nDecimalFormat) const
+{
+ OUStringBuffer aBuf;
+ aBuf.append("#" + rLoc.getNumThousandSep() + "##0");
+ if (nDecimalFormat && nDigits)
+ {
+ aBuf.append(rLoc.getNumDecimalSep());
+ sal_Unicode cDecimalChar = nDecimalFormat == 2 ? '-' : cZeroChar;
+ for (sal_uInt16 i = 0; i < nDigits; ++i)
+ {
+ aBuf.append(cDecimalChar);
+ }
+ }
+ return aBuf.makeStringAndClear();
+}
+
+
+OUString NfCurrencyEntry::BuildPositiveFormatString(bool bBank, const LocaleDataWrapper& rLoc,
+ sal_uInt16 nDecimalFormat) const
+{
+ OUStringBuffer sBuf(Impl_BuildFormatStringNumChars(rLoc, nDecimalFormat));
+ sal_uInt16 nPosiForm = NfCurrencyEntry::GetEffectivePositiveFormat( rLoc.getCurrPositiveFormat(),
+ nPositiveFormat, bBank );
+ CompletePositiveFormatString(sBuf, bBank, nPosiForm);
+ return sBuf.makeStringAndClear();
+}
+
+
+OUString NfCurrencyEntry::BuildNegativeFormatString(bool bBank,
+ const LocaleDataWrapper& rLoc, sal_uInt16 nDecimalFormat ) const
+{
+ OUStringBuffer sBuf(Impl_BuildFormatStringNumChars(rLoc, nDecimalFormat));
+ sal_uInt16 nNegaForm = NfCurrencyEntry::GetEffectiveNegativeFormat( rLoc.getCurrNegativeFormat(),
+ nNegativeFormat, bBank );
+ CompleteNegativeFormatString(sBuf, bBank, nNegaForm);
+ return sBuf.makeStringAndClear();
+}
+
+
+void NfCurrencyEntry::CompletePositiveFormatString(OUStringBuffer& rStr, bool bBank,
+ sal_uInt16 nPosiForm) const
+{
+ OUString aSymStr = BuildSymbolString(bBank);
+ NfCurrencyEntry::CompletePositiveFormatString( rStr, aSymStr, nPosiForm );
+}
+
+
+void NfCurrencyEntry::CompleteNegativeFormatString(OUStringBuffer& rStr, bool bBank,
+ sal_uInt16 nNegaForm) const
+{
+ OUString aSymStr = BuildSymbolString(bBank);
+ NfCurrencyEntry::CompleteNegativeFormatString( rStr, aSymStr, nNegaForm );
+}
+
+
+// static
+void NfCurrencyEntry::CompletePositiveFormatString(OUStringBuffer& rStr, std::u16string_view rSymStr,
+ sal_uInt16 nPositiveFormat)
+{
+ switch( nPositiveFormat )
+ {
+ case 0: // $1
+ rStr.insert(0, rSymStr);
+ break;
+ case 1: // 1$
+ rStr.append(rSymStr);
+ break;
+ case 2: // $ 1
+ {
+ rStr.insert(0, ' ');
+ rStr.insert(0, rSymStr);
+ }
+ break;
+ case 3: // 1 $
+ {
+ rStr.append(' ');
+ rStr.append(rSymStr);
+ }
+ break;
+ default:
+ SAL_WARN( "svl.numbers", "NfCurrencyEntry::CompletePositiveFormatString: unknown option");
+ break;
+ }
+}
+
+
+// static
+void NfCurrencyEntry::CompleteNegativeFormatString(OUStringBuffer& rStr,
+ std::u16string_view rSymStr,
+ sal_uInt16 nNegativeFormat)
+{
+ switch( nNegativeFormat )
+ {
+ case 0: // ($1)
+ {
+ rStr.insert(0, rSymStr);
+ rStr.insert(0, '(');
+ rStr.append(')');
+ }
+ break;
+ case 1: // -$1
+ {
+ rStr.insert(0, rSymStr);
+ rStr.insert(0, '-');
+ }
+ break;
+ case 2: // $-1
+ {
+ rStr.insert(0, '-');
+ rStr.insert(0, rSymStr);
+ }
+ break;
+ case 3: // $1-
+ {
+ rStr.insert(0, rSymStr);
+ rStr.append('-');
+ }
+ break;
+ case 4: // (1$)
+ {
+ rStr.insert(0, '(');
+ rStr.append(rSymStr);
+ rStr.append(')');
+ }
+ break;
+ case 5: // -1$
+ {
+ rStr.append(rSymStr);
+ rStr.insert(0, '-');
+ }
+ break;
+ case 6: // 1-$
+ {
+ rStr.append('-');
+ rStr.append(rSymStr);
+ }
+ break;
+ case 7: // 1$-
+ {
+ rStr.append(rSymStr);
+ rStr.append('-');
+ }
+ break;
+ case 8: // -1 $
+ {
+ rStr.append(' ');
+ rStr.append(rSymStr);
+ rStr.insert(0, '-');
+ }
+ break;
+ case 9: // -$ 1
+ {
+ rStr.insert(0, ' ');
+ rStr.insert(0, rSymStr);
+ rStr.insert(0, '-');
+ }
+ break;
+ case 10: // 1 $-
+ {
+ rStr.append(' ');
+ rStr.append(rSymStr);
+ rStr.append('-');
+ }
+ break;
+ case 11: // $ -1
+ {
+ rStr.insert(0, " -");
+ rStr.insert(0, rSymStr);
+ }
+ break;
+ case 12 : // $ 1-
+ {
+ rStr.insert(0, ' ');
+ rStr.insert(0, rSymStr);
+ rStr.append('-');
+ }
+ break;
+ case 13 : // 1- $
+ {
+ rStr.append('-');
+ rStr.append(' ');
+ rStr.append(rSymStr);
+ }
+ break;
+ case 14 : // ($ 1)
+ {
+ rStr.insert(0, ' ');
+ rStr.insert(0, rSymStr);
+ rStr.insert(0, '(');
+ rStr.append(')');
+ }
+ break;
+ case 15 : // (1 $)
+ {
+ rStr.insert(0, '(');
+ rStr.append(' ');
+ rStr.append(rSymStr);
+ rStr.append(')');
+ }
+ break;
+ default:
+ SAL_WARN( "svl.numbers", "NfCurrencyEntry::CompleteNegativeFormatString: unknown option");
+ break;
+ }
+}
+
+
+// static
+sal_uInt16 NfCurrencyEntry::GetEffectivePositiveFormat( sal_uInt16 nIntlFormat,
+ sal_uInt16 nCurrFormat, bool bBank )
+{
+ if ( bBank )
+ {
+#if NF_BANKSYMBOL_FIX_POSITION
+ (void) nIntlFormat; // avoid warnings
+ return 3;
+#else
+ switch ( nIntlFormat )
+ {
+ case 0: // $1
+ nIntlFormat = 2; // $ 1
+ break;
+ case 1: // 1$
+ nIntlFormat = 3; // 1 $
+ break;
+ case 2: // $ 1
+ break;
+ case 3: // 1 $
+ break;
+ default:
+ SAL_WARN( "svl.numbers", "NfCurrencyEntry::GetEffectivePositiveFormat: unknown option");
+ break;
+ }
+ return nIntlFormat;
+#endif
+ }
+ else
+ return nCurrFormat;
+}
+
+
+//! Call this only if nCurrFormat is really with parentheses!
+static sal_uInt16 lcl_MergeNegativeParenthesisFormat( sal_uInt16 nIntlFormat, sal_uInt16 nCurrFormat )
+{
+ short nSign = 0; // -1:=bracket 0:=left, 1:=middle, 2:=right
+ switch ( nIntlFormat )
+ {
+ case 0: // ($1)
+ case 4: // (1$)
+ case 14 : // ($ 1)
+ case 15 : // (1 $)
+ return nCurrFormat;
+ case 1: // -$1
+ case 5: // -1$
+ case 8: // -1 $
+ case 9: // -$ 1
+ nSign = 0;
+ break;
+ case 2: // $-1
+ case 6: // 1-$
+ case 11 : // $ -1
+ case 13 : // 1- $
+ nSign = 1;
+ break;
+ case 3: // $1-
+ case 7: // 1$-
+ case 10: // 1 $-
+ case 12 : // $ 1-
+ nSign = 2;
+ break;
+ default:
+ SAL_WARN( "svl.numbers", "lcl_MergeNegativeParenthesisFormat: unknown option");
+ break;
+ }
+
+ switch ( nCurrFormat )
+ {
+ case 0: // ($1)
+ switch ( nSign )
+ {
+ case 0:
+ return 1; // -$1
+ case 1:
+ return 2; // $-1
+ case 2:
+ return 3; // $1-
+ }
+ break;
+ case 4: // (1$)
+ switch ( nSign )
+ {
+ case 0:
+ return 5; // -1$
+ case 1:
+ return 6; // 1-$
+ case 2:
+ return 7; // 1$-
+ }
+ break;
+ case 14 : // ($ 1)
+ switch ( nSign )
+ {
+ case 0:
+ return 9; // -$ 1
+ case 1:
+ return 11; // $ -1
+ case 2:
+ return 12; // $ 1-
+ }
+ break;
+ case 15 : // (1 $)
+ switch ( nSign )
+ {
+ case 0:
+ return 8; // -1 $
+ case 1:
+ return 13; // 1- $
+ case 2:
+ return 10; // 1 $-
+ }
+ break;
+ }
+ return nCurrFormat;
+}
+
+
+// static
+sal_uInt16 NfCurrencyEntry::GetEffectiveNegativeFormat( sal_uInt16 nIntlFormat,
+ sal_uInt16 nCurrFormat, bool bBank )
+{
+ if ( bBank )
+ {
+#if NF_BANKSYMBOL_FIX_POSITION
+ return 8;
+#else
+ switch ( nIntlFormat )
+ {
+ case 0: // ($1)
+// nIntlFormat = 14; // ($ 1)
+ nIntlFormat = 9; // -$ 1
+ break;
+ case 1: // -$1
+ nIntlFormat = 9; // -$ 1
+ break;
+ case 2: // $-1
+ nIntlFormat = 11; // $ -1
+ break;
+ case 3: // $1-
+ nIntlFormat = 12; // $ 1-
+ break;
+ case 4: // (1$)
+// nIntlFormat = 15; // (1 $)
+ nIntlFormat = 8; // -1 $
+ break;
+ case 5: // -1$
+ nIntlFormat = 8; // -1 $
+ break;
+ case 6: // 1-$
+ nIntlFormat = 13; // 1- $
+ break;
+ case 7: // 1$-
+ nIntlFormat = 10; // 1 $-
+ break;
+ case 8: // -1 $
+ break;
+ case 9: // -$ 1
+ break;
+ case 10: // 1 $-
+ break;
+ case 11: // $ -1
+ break;
+ case 12 : // $ 1-
+ break;
+ case 13 : // 1- $
+ break;
+ case 14 : // ($ 1)
+// nIntlFormat = 14; // ($ 1)
+ nIntlFormat = 9; // -$ 1
+ break;
+ case 15 : // (1 $)
+// nIntlFormat = 15; // (1 $)
+ nIntlFormat = 8; // -1 $
+ break;
+ default:
+ SAL_WARN( "svl.numbers", "NfCurrencyEntry::GetEffectiveNegativeFormat: unknown option");
+ break;
+ }
+#endif
+ }
+ else if ( nIntlFormat != nCurrFormat )
+ {
+ switch ( nCurrFormat )
+ {
+ case 0: // ($1)
+ nIntlFormat = lcl_MergeNegativeParenthesisFormat(
+ nIntlFormat, nCurrFormat );
+ break;
+ case 1: // -$1
+ nIntlFormat = nCurrFormat;
+ break;
+ case 2: // $-1
+ nIntlFormat = nCurrFormat;
+ break;
+ case 3: // $1-
+ nIntlFormat = nCurrFormat;
+ break;
+ case 4: // (1$)
+ nIntlFormat = lcl_MergeNegativeParenthesisFormat(
+ nIntlFormat, nCurrFormat );
+ break;
+ case 5: // -1$
+ nIntlFormat = nCurrFormat;
+ break;
+ case 6: // 1-$
+ nIntlFormat = nCurrFormat;
+ break;
+ case 7: // 1$-
+ nIntlFormat = nCurrFormat;
+ break;
+ case 8: // -1 $
+ nIntlFormat = nCurrFormat;
+ break;
+ case 9: // -$ 1
+ nIntlFormat = nCurrFormat;
+ break;
+ case 10: // 1 $-
+ nIntlFormat = nCurrFormat;
+ break;
+ case 11: // $ -1
+ nIntlFormat = nCurrFormat;
+ break;
+ case 12 : // $ 1-
+ nIntlFormat = nCurrFormat;
+ break;
+ case 13 : // 1- $
+ nIntlFormat = nCurrFormat;
+ break;
+ case 14 : // ($ 1)
+ nIntlFormat = lcl_MergeNegativeParenthesisFormat(
+ nIntlFormat, nCurrFormat );
+ break;
+ case 15 : // (1 $)
+ nIntlFormat = lcl_MergeNegativeParenthesisFormat(
+ nIntlFormat, nCurrFormat );
+ break;
+ default:
+ SAL_WARN( "svl.numbers", "NfCurrencyEntry::GetEffectiveNegativeFormat: unknown option");
+ break;
+ }
+ }
+ return nIntlFormat;
+}
+
+const NfKeywordTable & SvNumberFormatter::GetKeywords( sal_uInt32 nKey )
+{
+ osl::MutexGuard aGuard( GetInstanceMutex() );
+ const SvNumberformat* pFormat = GetFormatEntry( nKey);
+ if (pFormat)
+ ChangeIntl( pFormat->GetLanguage());
+ else
+ ChangeIntl( IniLnge);
+ return pFormatScanner->GetKeywords();
+}
+
+const NfKeywordTable & SvNumberFormatter::GetEnglishKeywords() const
+{
+ return ImpSvNumberformatScan::GetEnglishKeywords();
+}
+
+const std::vector<Color> & SvNumberFormatter::GetStandardColors() const
+{
+ return ImpSvNumberformatScan::GetStandardColors();
+}
+
+size_t SvNumberFormatter::GetMaxDefaultColors() const
+{
+ return ImpSvNumberformatScan::GetMaxDefaultColors();
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/svl/source/numbers/zformat.cxx b/svl/source/numbers/zformat.cxx
new file mode 100644
index 000000000..0ddd6e084
--- /dev/null
+++ b/svl/source/numbers/zformat.cxx
@@ -0,0 +1,6035 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed
+ * with this work for additional information regarding copyright
+ * ownership. The ASF licenses this file to you under the Apache
+ * License, Version 2.0 (the "License"); you may not use this file
+ * except in compliance with the License. You may obtain a copy of
+ * the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#include <stdio.h>
+#include <string_view>
+
+#include <o3tl/string_view.hxx>
+#include <comphelper/string.hxx>
+#include <sal/log.hxx>
+#include <tools/debug.hxx>
+#include <tools/long.hxx>
+#include <i18nlangtag/mslangid.hxx>
+#include <rtl/math.hxx>
+#include <unotools/charclass.hxx>
+#include <unotools/calendarwrapper.hxx>
+#include <unotools/nativenumberwrapper.hxx>
+#include <com/sun/star/i18n/CalendarFieldIndex.hpp>
+#include <com/sun/star/i18n/CalendarDisplayIndex.hpp>
+#include <com/sun/star/i18n/CalendarDisplayCode.hpp>
+#include <com/sun/star/i18n/AmPmValue.hpp>
+#include <com/sun/star/i18n/NativeNumberMode.hpp>
+#include <com/sun/star/i18n/NativeNumberXmlAttributes2.hpp>
+
+#include <svl/zformat.hxx>
+#include "zforscan.hxx"
+
+#include "zforfind.hxx"
+#include <svl/zforlist.hxx>
+#include <unotools/digitgroupingiterator.hxx>
+#include <svl/nfsymbol.hxx>
+
+#include <cmath>
+#include <array>
+
+using namespace svt;
+
+namespace {
+
+constexpr OUStringLiteral GREGORIAN = u"gregorian";
+
+const sal_uInt16 UPPER_PRECISION = 300; // entirely arbitrary...
+const double EXP_LOWER_BOUND = 1.0E-4; // prefer scientific notation below this value.
+const double EXP_ABS_UPPER_BOUND = 1.0E15; // use exponential notation above that absolute value.
+ // Back in time was E16 that lead
+ // to display rounding errors, see
+ // also sal/rtl/math.cxx
+ // doubleToString()
+
+} // namespace
+
+const double D_MAX_U_INT32 = double(0xffffffff); // 4294967295.0
+constexpr double D_MAX_INTEGER = (sal_uInt64(1) << 53) - 1;
+
+const double D_MAX_D_BY_100 = 1.7E306;
+const double D_MIN_M_BY_1000 = 2.3E-305;
+
+const sal_uInt8 cCharWidths[ 128-32 ] = {
+ 1,1,1,2,2,3,2,1,1,1,1,2,1,1,1,1,
+ 2,2,2,2,2,2,2,2,2,2,1,1,2,2,2,2,
+ 3,2,2,2,2,2,2,3,2,1,2,2,2,3,3,3,
+ 2,3,2,2,2,2,2,3,2,2,2,1,1,1,2,2,
+ 1,2,2,2,2,2,1,2,2,1,1,2,1,3,2,2,
+ 2,2,1,2,1,2,2,2,2,2,2,1,1,1,2,1
+};
+
+// static
+sal_Int32 SvNumberformat::InsertBlanks( OUStringBuffer& r, sal_Int32 nPos, sal_Unicode c )
+{
+ if( c >= 32 )
+ {
+ int n = 2; // Default for chars > 128 (HACK!)
+ if( c <= 127 )
+ {
+ n = static_cast<int>(cCharWidths[ c - 32 ]);
+ }
+ while( n-- )
+ {
+ r.insert( nPos++, ' ');
+ }
+ }
+ return nPos;
+}
+
+static tools::Long GetPrecExp( double fAbsVal )
+{
+ DBG_ASSERT( fAbsVal > 0.0, "GetPrecExp: fAbsVal <= 0.0" );
+ if ( fAbsVal < 1e-7 || fAbsVal > 1e7 )
+ {
+ // Shear: whether it's faster or not, falls in between 1e6 and 1e7
+ return static_cast<tools::Long>(floor( log10( fAbsVal ) )) + 1;
+ }
+ else
+ {
+ tools::Long nPrecExp = 1;
+ while( fAbsVal < 1 )
+ {
+ fAbsVal *= 10;
+ nPrecExp--;
+ }
+ while( fAbsVal >= 10 )
+ {
+ fAbsVal /= 10;
+ nPrecExp++;
+ }
+ return nPrecExp;
+ }
+}
+
+/**
+ * SvNumberformatInfo
+ * */
+
+void ImpSvNumberformatInfo::Copy( const ImpSvNumberformatInfo& rNumFor, sal_uInt16 nCnt )
+{
+ for (sal_uInt16 i = 0; i < nCnt; ++i)
+ {
+ sStrArray[i] = rNumFor.sStrArray[i];
+ nTypeArray[i] = rNumFor.nTypeArray[i];
+ }
+ eScannedType = rNumFor.eScannedType;
+ bThousand = rNumFor.bThousand;
+ nThousand = rNumFor.nThousand;
+ nCntPre = rNumFor.nCntPre;
+ nCntPost = rNumFor.nCntPost;
+ nCntExp = rNumFor.nCntExp;
+}
+
+const std::map<LanguageType, std::array<sal_uInt8, 4>> tblDBNumToNatNum
+ = { { primary(LANGUAGE_CHINESE), { 4, 5, 3, 0 } },
+ { primary(LANGUAGE_JAPANESE), { 4, 5, 3, 0 } },
+ { primary(LANGUAGE_KOREAN), { 4, 5, 6, 10 } } };
+
+// static
+sal_uInt8 SvNumberNatNum::MapDBNumToNatNum( sal_uInt8 nDBNum, LanguageType eLang, bool bDate )
+{
+ sal_uInt8 nNatNum = 0;
+ eLang = MsLangId::getRealLanguage( eLang ); // resolve SYSTEM etc.
+ eLang = primary(eLang); // 10 bit primary language
+ if ( bDate )
+ {
+ if ( nDBNum == 4 && eLang == primary(LANGUAGE_KOREAN) )
+ {
+ nNatNum = 10;
+ }
+ else if ( nDBNum <= 3 )
+ {
+ nNatNum = nDBNum; // known to be good for: zh,ja,ko / 1,2,3
+ }
+ }
+ else
+ {
+ if (1 <= nDBNum && nDBNum <= 4)
+ {
+ auto const it = tblDBNumToNatNum.find(eLang);
+ if (it != tblDBNumToNatNum.end())
+ nNatNum = it->second[nDBNum - 1];
+
+ }
+ }
+ return nNatNum;
+}
+
+const std::map<LanguageType, std::array<sal_uInt8, 9>> tblNatNumToDBNum
+ = { { primary(LANGUAGE_CHINESE), { 1, 0, 0, 1, 2, 3, 0, 0, 0 } },
+ { primary(LANGUAGE_JAPANESE), { 1, 2, 3, 1, 2, 3, 1, 2, 0 } },
+ { primary(LANGUAGE_KOREAN), { 1, 2, 3, 1, 2, 3, 1, 2, 4 } } };
+
+// static
+sal_uInt8 SvNumberNatNum::MapNatNumToDBNum( sal_uInt8 nNatNum, LanguageType eLang, bool bDate )
+{
+ sal_uInt8 nDBNum = 0;
+ eLang = MsLangId::getRealLanguage( eLang ); // resolve SYSTEM etc.
+ eLang = primary(eLang); // 10 bit primary language
+ if ( bDate )
+ {
+ if ( nNatNum == 10 && eLang == primary(LANGUAGE_KOREAN) )
+ {
+ nDBNum = 4;
+ }
+ else if ( nNatNum <= 3 )
+ {
+ nDBNum = nNatNum; // known to be good for: zh,ja,ko / 1,2,3
+ }
+ }
+ else
+ {
+ if (1 <= nNatNum && nNatNum <= 9)
+ {
+ auto const it = tblNatNumToDBNum.find(eLang);
+ if (it != tblNatNumToDBNum.end())
+ nDBNum = it->second[nNatNum - 1];
+ }
+ }
+ return nDBNum;
+}
+
+/**
+ * SvNumFor
+ */
+
+ImpSvNumFor::ImpSvNumFor()
+{
+ nStringsCnt = 0;
+ aI.eScannedType = SvNumFormatType::UNDEFINED;
+ aI.bThousand = false;
+ aI.nThousand = 0;
+ aI.nCntPre = 0;
+ aI.nCntPost = 0;
+ aI.nCntExp = 0;
+ pColor = nullptr;
+}
+
+ImpSvNumFor::~ImpSvNumFor()
+{
+}
+
+void ImpSvNumFor::Enlarge(sal_uInt16 nCnt)
+{
+ if ( nStringsCnt != nCnt )
+ {
+ nStringsCnt = nCnt;
+ aI.nTypeArray.resize(nCnt);
+ aI.sStrArray.resize(nCnt);
+ }
+}
+
+void ImpSvNumFor::Copy( const ImpSvNumFor& rNumFor, const ImpSvNumberformatScan* pSc )
+{
+ Enlarge( rNumFor.nStringsCnt );
+ aI.Copy( rNumFor.aI, nStringsCnt );
+ sColorName = rNumFor.sColorName;
+ if ( pSc )
+ {
+ pColor = pSc->GetColor( sColorName ); // #121103# don't copy pointer between documents
+ }
+ else
+ {
+ pColor = rNumFor.pColor;
+ }
+ aNatNum = rNumFor.aNatNum;
+}
+
+bool ImpSvNumFor::HasNewCurrency() const
+{
+ for ( sal_uInt16 j=0; j<nStringsCnt; j++ )
+ {
+ if ( aI.nTypeArray[j] == NF_SYMBOLTYPE_CURRENCY )
+ {
+ return true;
+ }
+ }
+ return false;
+}
+
+bool ImpSvNumFor::GetNewCurrencySymbol( OUString& rSymbol,
+ OUString& rExtension ) const
+{
+ for ( sal_uInt16 j=0; j<nStringsCnt; j++ )
+ {
+ if ( aI.nTypeArray[j] == NF_SYMBOLTYPE_CURRENCY )
+ {
+ rSymbol = aI.sStrArray[j];
+ if ( j < nStringsCnt-1 && aI.nTypeArray[j+1] == NF_SYMBOLTYPE_CURREXT )
+ {
+ rExtension = aI.sStrArray[j+1];
+ }
+ else
+ {
+ rExtension.clear();
+ }
+ return true;
+ }
+ }
+ //! No Erase at rSymbol, rExtension
+ return false;
+}
+
+/**
+ * SvNumberformat
+ */
+
+namespace {
+
+enum BracketFormatSymbolType
+{
+ BRACKET_SYMBOLTYPE_FORMAT = -1, // subformat string
+ BRACKET_SYMBOLTYPE_COLOR = -2, // color
+ BRACKET_SYMBOLTYPE_ERROR = -3, // error
+ BRACKET_SYMBOLTYPE_DBNUM1 = -4, // DoubleByteNumber, represent numbers
+ BRACKET_SYMBOLTYPE_DBNUM2 = -5, // using CJK characters, Excel compatible
+ BRACKET_SYMBOLTYPE_DBNUM3 = -6,
+ BRACKET_SYMBOLTYPE_DBNUM4 = -7,
+ BRACKET_SYMBOLTYPE_DBNUM5 = -8,
+ BRACKET_SYMBOLTYPE_DBNUM6 = -9,
+ BRACKET_SYMBOLTYPE_DBNUM7 = -10,
+ BRACKET_SYMBOLTYPE_DBNUM8 = -11,
+ BRACKET_SYMBOLTYPE_DBNUM9 = -12,
+ BRACKET_SYMBOLTYPE_LOCALE = -13,
+ BRACKET_SYMBOLTYPE_NATNUM0 = -14, // Our NativeNumber support, ASCII
+ BRACKET_SYMBOLTYPE_NATNUM1 = -15, // Our NativeNumber support, represent
+ BRACKET_SYMBOLTYPE_NATNUM2 = -16, // numbers using CJK, CTL, ...
+ BRACKET_SYMBOLTYPE_NATNUM3 = -17,
+ BRACKET_SYMBOLTYPE_NATNUM4 = -18,
+ BRACKET_SYMBOLTYPE_NATNUM5 = -19,
+ BRACKET_SYMBOLTYPE_NATNUM6 = -20,
+ BRACKET_SYMBOLTYPE_NATNUM7 = -21,
+ BRACKET_SYMBOLTYPE_NATNUM8 = -22,
+ BRACKET_SYMBOLTYPE_NATNUM9 = -23,
+ BRACKET_SYMBOLTYPE_NATNUM10 = -24,
+ BRACKET_SYMBOLTYPE_NATNUM11 = -25,
+ BRACKET_SYMBOLTYPE_NATNUM12 = -26,
+ BRACKET_SYMBOLTYPE_NATNUM13 = -27,
+ BRACKET_SYMBOLTYPE_NATNUM14 = -28,
+ BRACKET_SYMBOLTYPE_NATNUM15 = -29,
+ BRACKET_SYMBOLTYPE_NATNUM16 = -30,
+ BRACKET_SYMBOLTYPE_NATNUM17 = -31,
+ BRACKET_SYMBOLTYPE_NATNUM18 = -32,
+ BRACKET_SYMBOLTYPE_NATNUM19 = -33
+};
+
+}
+
+void SvNumberformat::ImpCopyNumberformat( const SvNumberformat& rFormat )
+{
+ sFormatstring = rFormat.sFormatstring;
+ eType = rFormat.eType;
+ maLocale = rFormat.maLocale;
+ fLimit1 = rFormat.fLimit1;
+ fLimit2 = rFormat.fLimit2;
+ eOp1 = rFormat.eOp1;
+ eOp2 = rFormat.eOp2;
+ bStandard = rFormat.bStandard;
+ bIsUsed = rFormat.bIsUsed;
+ sComment = rFormat.sComment;
+ bAdditionalBuiltin = rFormat.bAdditionalBuiltin;
+
+ // #121103# when copying between documents, get color pointers from own scanner
+ ImpSvNumberformatScan* pColorSc = ( &rScan != &rFormat.rScan ) ? &rScan : nullptr;
+
+ for (sal_uInt16 i = 0; i < 4; i++)
+ {
+ NumFor[i].Copy(rFormat.NumFor[i], pColorSc);
+ }
+}
+
+SvNumberformat::SvNumberformat( SvNumberformat const & rFormat )
+ : rScan(rFormat.rScan), bStarFlag( rFormat.bStarFlag )
+{
+ ImpCopyNumberformat( rFormat );
+}
+
+SvNumberformat::SvNumberformat( SvNumberformat const & rFormat, ImpSvNumberformatScan& rSc )
+ : rScan(rSc)
+ , bStarFlag( rFormat.bStarFlag )
+{
+ ImpCopyNumberformat( rFormat );
+}
+
+static bool lcl_SvNumberformat_IsBracketedPrefix( short nSymbolType )
+{
+ if ( nSymbolType > 0 )
+ {
+ return true; // conditions
+ }
+ switch ( nSymbolType )
+ {
+ case BRACKET_SYMBOLTYPE_COLOR :
+ case BRACKET_SYMBOLTYPE_DBNUM1 :
+ case BRACKET_SYMBOLTYPE_DBNUM2 :
+ case BRACKET_SYMBOLTYPE_DBNUM3 :
+ case BRACKET_SYMBOLTYPE_DBNUM4 :
+ case BRACKET_SYMBOLTYPE_DBNUM5 :
+ case BRACKET_SYMBOLTYPE_DBNUM6 :
+ case BRACKET_SYMBOLTYPE_DBNUM7 :
+ case BRACKET_SYMBOLTYPE_DBNUM8 :
+ case BRACKET_SYMBOLTYPE_DBNUM9 :
+ case BRACKET_SYMBOLTYPE_LOCALE :
+ case BRACKET_SYMBOLTYPE_NATNUM0 :
+ case BRACKET_SYMBOLTYPE_NATNUM1 :
+ case BRACKET_SYMBOLTYPE_NATNUM2 :
+ case BRACKET_SYMBOLTYPE_NATNUM3 :
+ case BRACKET_SYMBOLTYPE_NATNUM4 :
+ case BRACKET_SYMBOLTYPE_NATNUM5 :
+ case BRACKET_SYMBOLTYPE_NATNUM6 :
+ case BRACKET_SYMBOLTYPE_NATNUM7 :
+ case BRACKET_SYMBOLTYPE_NATNUM8 :
+ case BRACKET_SYMBOLTYPE_NATNUM9 :
+ case BRACKET_SYMBOLTYPE_NATNUM10 :
+ case BRACKET_SYMBOLTYPE_NATNUM11 :
+ case BRACKET_SYMBOLTYPE_NATNUM12 :
+ case BRACKET_SYMBOLTYPE_NATNUM13 :
+ case BRACKET_SYMBOLTYPE_NATNUM14 :
+ case BRACKET_SYMBOLTYPE_NATNUM15 :
+ case BRACKET_SYMBOLTYPE_NATNUM16 :
+ case BRACKET_SYMBOLTYPE_NATNUM17 :
+ case BRACKET_SYMBOLTYPE_NATNUM18 :
+ case BRACKET_SYMBOLTYPE_NATNUM19 :
+ return true;
+ }
+ return false;
+}
+
+/** Import extended LCID from Excel
+ */
+OUString SvNumberformat::ImpObtainCalendarAndNumerals( OUStringBuffer& rString, sal_Int32 nPos,
+ LanguageType& nLang, const LocaleType& aTmpLocale )
+{
+ OUString sCalendar;
+ sal_uInt16 nNatNum = 0;
+ LanguageType nLocaleLang = MsLangId::getRealLanguage( maLocale.meLanguage );
+ LanguageType nTmpLocaleLang = MsLangId::getRealLanguage( aTmpLocale.meLanguage );
+ /* NOTE: enhancement to allow other possible locale dependent
+ * calendars and numerals. BUT only if our locale data allows it! For LCID
+ * numerals and calendars see
+ * http://office.microsoft.com/en-us/excel/HA010346351033.aspx
+ * Calendar is inserted after
+ * all prefixes have been consumed as it is actually a format modifier
+ * and not a prefix.
+ * Currently calendars are tied to the locale of the entire number
+ * format, e.g. [~buddhist] in en_US doesn't work.
+ * => Having different locales in sub formats does not work!
+ * */
+ /* TODO: calendars could be tied to a sub format's NatNum info
+ * instead, or even better be available for any locale. Needs a
+ * different implementation of GetCal() and locale data calendars.
+ * */
+ switch ( aTmpLocale.mnCalendarType & 0x7F )
+ {
+ case 0x03 : // Gengou calendar
+ // Only Japanese language support Gengou calendar.
+ // It is an implicit "other" calendar where E, EE, R and RR
+ // automatically switch to and YY and YYYY switch to Gregorian. Do
+ // not add the "[~gengou]" modifier.
+ if ( nLocaleLang != LANGUAGE_JAPANESE )
+ {
+ nLang = maLocale.meLanguage = LANGUAGE_JAPANESE;
+ }
+ break;
+ case 0x05 : // Korean Dangi calendar
+ sCalendar = "[~dangi]";
+ // Only Korean language support dangi calendar
+ if ( nLocaleLang != LANGUAGE_KOREAN )
+ {
+ nLang = maLocale.meLanguage = LANGUAGE_KOREAN;
+ }
+ break;
+ case 0x06 : // Hijri calendar
+ case 0x17 : // same?
+ sCalendar = "[~hijri]";
+ // Only Arabic or Farsi languages support Hijri calendar
+ if ( ( primary( nLocaleLang ) != LANGUAGE_ARABIC_PRIMARY_ONLY )
+ && nLocaleLang != LANGUAGE_FARSI )
+ {
+ if ( ( primary( nTmpLocaleLang ) == LANGUAGE_ARABIC_PRIMARY_ONLY )
+ || nTmpLocaleLang == LANGUAGE_FARSI )
+ {
+ nLang = maLocale.meLanguage = aTmpLocale.meLanguage;
+ }
+ else
+ {
+ nLang = maLocale.meLanguage = LANGUAGE_ARABIC_SAUDI_ARABIA;
+ }
+ }
+ break;
+ case 0x07 : // Buddhist calendar
+ sCalendar="[~buddhist]";
+ // Only Thai or Lao languages support Buddhist calendar
+ if ( nLocaleLang != LANGUAGE_THAI && nLocaleLang != LANGUAGE_LAO )
+ {
+ if ( nTmpLocaleLang == LANGUAGE_THAI || nTmpLocaleLang == LANGUAGE_LAO )
+ {
+ nLang = maLocale.meLanguage = aTmpLocale.meLanguage;
+ }
+ else
+ {
+ nLang = maLocale.meLanguage = LANGUAGE_THAI;
+ }
+ }
+ break;
+ case 0x08 : // Hebrew calendar
+ sCalendar = "[~jewish]";
+ // Many languages (but not all) support Jewish calendar
+ // Unable to find any logic => keep same language
+ break;
+ case 0x0E : // unknown calendar
+ case 0x0F : // unknown calendar
+ case 0x10 : // Indian calendar (unsupported)
+ case 0x11 : // unknown calendar
+ case 0x12 : // unknown calendar
+ case 0x13 : // unknown calendar
+ default : // other calendars (see tdf#36038) are not handle by LibO
+ break;
+ }
+ /** Reference language for each numeral ID */
+ static const LanguageType aNumeralIDtoLanguage []=
+ {
+ LANGUAGE_DONTKNOW, // 0x00
+ LANGUAGE_ENGLISH_US, // 0x01
+ LANGUAGE_ARABIC_SAUDI_ARABIA, // 0x02 + all Arabic
+ LANGUAGE_FARSI, // 0x03
+ LANGUAGE_HINDI, // 0x04 + Devanagari
+ LANGUAGE_BENGALI, // 0x05
+ LANGUAGE_PUNJABI, // 0x06
+ LANGUAGE_GUJARATI, // 0x07
+ LANGUAGE_ODIA, // 0x08
+ LANGUAGE_TAMIL, // 0x09
+ LANGUAGE_TELUGU, // 0x0A
+ LANGUAGE_KANNADA, // 0x0B
+ LANGUAGE_MALAYALAM, // 0x0C
+ LANGUAGE_THAI, // 0x0D
+ LANGUAGE_LAO, // 0x0E
+ LANGUAGE_TIBETAN, // 0x0F
+ LANGUAGE_BURMESE, // 0x10
+ LANGUAGE_TIGRIGNA_ETHIOPIA, // 0x11
+ LANGUAGE_KHMER, // 0x12
+ LANGUAGE_MONGOLIAN_MONGOLIAN_MONGOLIA, // 0x13
+ LANGUAGE_DONTKNOW, // 0x14
+ LANGUAGE_DONTKNOW, // 0x15
+ LANGUAGE_DONTKNOW, // 0x16
+ LANGUAGE_DONTKNOW, // 0x17
+ LANGUAGE_DONTKNOW, // 0x18
+ LANGUAGE_DONTKNOW, // 0x19
+ LANGUAGE_DONTKNOW, // 0x1A
+ LANGUAGE_JAPANESE, // 0x1B
+ LANGUAGE_JAPANESE, // 0x1C
+ LANGUAGE_JAPANESE, // 0x1D
+ LANGUAGE_CHINESE_SIMPLIFIED, // 0x1E
+ LANGUAGE_CHINESE_SIMPLIFIED, // 0x1F
+ LANGUAGE_CHINESE_SIMPLIFIED, // 0x20
+ LANGUAGE_CHINESE_TRADITIONAL, // 0x21
+ LANGUAGE_CHINESE_TRADITIONAL, // 0x22
+ LANGUAGE_CHINESE_TRADITIONAL, // 0x23
+ LANGUAGE_KOREAN, // 0x24
+ LANGUAGE_KOREAN, // 0x25
+ LANGUAGE_KOREAN, // 0x26
+ LANGUAGE_KOREAN // 0x27
+ };
+
+ sal_uInt16 nNumeralID = aTmpLocale.mnNumeralShape & 0x7F;
+ LanguageType nReferenceLanguage = nNumeralID <= 0x27 ? aNumeralIDtoLanguage[nNumeralID] : LANGUAGE_DONTKNOW;
+
+ switch ( nNumeralID )
+ {
+ // Regular cases: all languages with same primary mask use same numerals
+ case 0x03 : // Perso-Arabic (Farsi) numerals
+ case 0x05 : // Bengali numerals
+ case 0x06 : // Punjabi numerals
+ case 0x07 : // Gujarati numerals
+ case 0x08 : // Odia (Orya) numerals
+ case 0x09 : // Tamil numerals
+ case 0x0A : // Telugu numerals
+ case 0x0B : // Kannada numerals
+ case 0x0C : // Malayalam numerals
+ case 0x0D : // Thai numerals
+ case 0x0E : // Lao numerals
+ case 0x0F : // Tibetan numerals
+ case 0x10 : // Burmese (Myanmar) numerals
+ case 0x11 : // Tigrigna (Ethiopia) numerals
+ case 0x12 : // Khmer numerals
+ if ( primary( nLocaleLang ) != primary( nReferenceLanguage ) )
+ {
+ if ( primary( nTmpLocaleLang ) == primary( nReferenceLanguage ) )
+ {
+ nLang = maLocale.meLanguage = aTmpLocale.meLanguage;
+ }
+ else
+ {
+ nLang = maLocale.meLanguage = nReferenceLanguage;
+ }
+ }
+ break;
+ // Special cases
+ case 0x04 : // Devanagari (Hindi) numerals
+ // same numerals (Devanagari) for languages with different primary masks
+ if ( nLocaleLang != LANGUAGE_HINDI && nLocaleLang != LANGUAGE_MARATHI
+ && primary( nLocaleLang ) != primary( LANGUAGE_NEPALI ) )
+ {
+ if ( nTmpLocaleLang == LANGUAGE_HINDI || nTmpLocaleLang == LANGUAGE_MARATHI
+ || primary( nTmpLocaleLang ) == primary( LANGUAGE_NEPALI ) )
+ {
+ nLang = maLocale.meLanguage = aTmpLocale.meLanguage;
+ }
+ else
+ {
+ nLang = maLocale.meLanguage = LANGUAGE_HINDI;
+ }
+ }
+ break;
+ case 0x13 : // Mongolian numerals
+ // not all Mongolian languages use Mongolian numerals
+ if ( nLocaleLang != LANGUAGE_MONGOLIAN_MONGOLIAN_MONGOLIA
+ && nLocaleLang != LANGUAGE_MONGOLIAN_MONGOLIAN_CHINA
+ && nLocaleLang != LANGUAGE_MONGOLIAN_MONGOLIAN_LSO )
+ {
+ if ( nTmpLocaleLang == LANGUAGE_MONGOLIAN_MONGOLIAN_MONGOLIA
+ || nTmpLocaleLang == LANGUAGE_MONGOLIAN_MONGOLIAN_CHINA
+ || nTmpLocaleLang == LANGUAGE_MONGOLIAN_MONGOLIAN_LSO )
+ {
+ nLang = maLocale.meLanguage = aTmpLocale.meLanguage;
+ }
+ else
+ {
+ nLang = maLocale.meLanguage = LANGUAGE_MONGOLIAN_MONGOLIAN_MONGOLIA;
+ }
+ }
+ break;
+ case 0x02 : // Eastern-Arabic numerals
+ // all arabic primary mask + LANGUAGE_PUNJABI_ARABIC_LSO
+ if ( primary( nLocaleLang ) != LANGUAGE_ARABIC_PRIMARY_ONLY
+ && nLocaleLang != LANGUAGE_PUNJABI_ARABIC_LSO )
+ {
+ if ( primary( nTmpLocaleLang ) == LANGUAGE_ARABIC_PRIMARY_ONLY
+ || nTmpLocaleLang != LANGUAGE_PUNJABI_ARABIC_LSO )
+ {
+ nLang = maLocale.meLanguage = aTmpLocale.meLanguage;
+ }
+ else
+ {
+ nLang = maLocale.meLanguage = nReferenceLanguage;
+ }
+ }
+ break;
+ // CJK numerals
+ case 0x1B : // simple Asian numerals, Japanese
+ case 0x1C : // financial Asian numerals, Japanese
+ case 0x1D : // Arabic fullwidth numerals, Japanese
+ case 0x24 : // simple Asian numerals, Korean
+ case 0x25 : // financial Asian numerals, Korean
+ case 0x26 : // Arabic fullwidth numerals, Korean
+ case 0x27 : // Korean Hangul numerals
+ // Japanese and Korean are regular
+ if ( primary( nLocaleLang ) != primary( nReferenceLanguage ) )
+ {
+ if ( primary( nTmpLocaleLang ) == primary( nReferenceLanguage ) )
+ {
+ nLang = maLocale.meLanguage = aTmpLocale.meLanguage;
+ }
+ else
+ {
+ nLang = maLocale.meLanguage = nReferenceLanguage;
+ }
+ }
+ [[fallthrough]];
+ case 0x1E : // simple Asian numerals, Chinese-PRC
+ case 0x1F : // financial Asian numerals, Chinese-PRC
+ case 0x20 : // Arabic fullwidth numerals, Chinese-PRC
+ case 0x21 : // simple Asian numerals, Chinese-Taiwan
+ case 0x22 : // financial Asian numerals, Chinese-Taiwan
+ case 0x23 : // Arabic fullwidth numerals, Chinese-Taiwan
+ nNatNum = nNumeralID == 0x27 ? 9 : ( ( nNumeralID - 0x1B ) % 3 ) + 1;
+ // [NatNum1] simple numerals
+ // [natNum2] financial numerals
+ // [NatNum3] Arabic fullwidth numerals
+ // Chinese simplified and Chinese traditional have same primary mask
+ // Chinese-PRC
+ if ( nReferenceLanguage == LANGUAGE_CHINESE_SIMPLIFIED
+ && nLocaleLang != LANGUAGE_CHINESE_SIMPLIFIED
+ && nLocaleLang != LANGUAGE_CHINESE_SINGAPORE
+ && nLocaleLang != LANGUAGE_CHINESE_LSO )
+ {
+ if ( nTmpLocaleLang == LANGUAGE_CHINESE_SIMPLIFIED
+ || nTmpLocaleLang == LANGUAGE_CHINESE_SINGAPORE
+ || nTmpLocaleLang == LANGUAGE_CHINESE_LSO )
+ {
+ nLang = maLocale.meLanguage = aTmpLocale.meLanguage;
+ }
+ else
+ {
+ nLang = maLocale.meLanguage = LANGUAGE_CHINESE_SIMPLIFIED;
+ }
+ }
+ // Chinese-Taiwan
+ else if ( nReferenceLanguage == LANGUAGE_CHINESE_TRADITIONAL
+ && nLocaleLang != LANGUAGE_CHINESE_TRADITIONAL
+ && nLocaleLang != LANGUAGE_CHINESE_HONGKONG
+ && nLocaleLang != LANGUAGE_CHINESE_MACAU )
+ {
+ if ( nTmpLocaleLang == LANGUAGE_CHINESE_TRADITIONAL
+ || nTmpLocaleLang == LANGUAGE_CHINESE_HONGKONG
+ || nTmpLocaleLang == LANGUAGE_CHINESE_MACAU )
+ {
+ nLang = maLocale.meLanguage = aTmpLocale.meLanguage;
+ }
+ else
+ {
+ nLang = maLocale.meLanguage = LANGUAGE_CHINESE_TRADITIONAL;
+ }
+ }
+ break;
+ }
+ if ( nNumeralID >= 0x02 && nNumeralID <= 0x13 )
+ nNatNum = 1;
+ if ( nNatNum )
+ rString.insert( nPos, OUStringConcatenation("[NatNum"+OUString::number(nNatNum)+"]"));
+ return sCalendar;
+}
+
+namespace
+{
+bool NatNumTakesParameters(sal_Int16 nNum)
+{
+ return (nNum == css::i18n::NativeNumberMode::NATNUM12);
+}
+}
+
+SvNumberformat::SvNumberformat(OUString& rString,
+ ImpSvNumberformatScan* pSc,
+ ImpSvNumberInputScan* pISc,
+ sal_Int32& nCheckPos,
+ LanguageType& eLan,
+ bool bReplaceBooleanEquivalent)
+ : rScan(*pSc)
+ , bAdditionalBuiltin( false )
+ , bStarFlag( false )
+{
+ if (bReplaceBooleanEquivalent)
+ rScan.ReplaceBooleanEquivalent( rString);
+
+ OUStringBuffer sBuff(rString);
+
+ // If the group (AKA thousand) separator is a No-Break Space (French)
+ // replace all occurrences by a simple space.
+ // The same for Narrow No-Break Space just in case some locale uses it.
+ // The tokens will be changed to the LocaleData separator again later on.
+ const OUString& rThSep = GetFormatter().GetNumThousandSep();
+ if ( rThSep.getLength() == 1)
+ {
+ const sal_Unicode cNBSp = 0xA0;
+ const sal_Unicode cNNBSp = 0x202F;
+ if (rThSep[0] == cNBSp )
+ sBuff.replace( cNBSp, ' ');
+ else if (rThSep[0] == cNNBSp )
+ sBuff.replace( cNNBSp, ' ');
+ }
+
+ OUString aConvertFromDecSep;
+ OUString aConvertToDecSep;
+ if (rScan.GetConvertMode())
+ {
+ aConvertFromDecSep = GetFormatter().GetNumDecimalSep();
+ maLocale.meLanguage = rScan.GetNewLnge();
+ eLan = maLocale.meLanguage; // Make sure to return switch
+ }
+ else
+ {
+ maLocale.meLanguage = eLan;
+ }
+ bStandard = false;
+ bIsUsed = false;
+ fLimit1 = 0.0;
+ fLimit2 = 0.0;
+ eOp1 = NUMBERFORMAT_OP_NO;
+ eOp2 = NUMBERFORMAT_OP_NO;
+ eType = SvNumFormatType::DEFINED;
+
+ bool bCancel = false;
+ bool bCondition = false;
+ short eSymbolType;
+ sal_Int32 nPos = 0;
+ sal_Int32 nPosOld;
+ nCheckPos = 0;
+
+ // Split into 4 sub formats
+ sal_uInt16 nIndex;
+ for ( nIndex = 0; nIndex < 4 && !bCancel; nIndex++ )
+ {
+ // Original language/country may have to be reestablished
+ if (rScan.GetConvertMode())
+ {
+ rScan.GetNumberformatter()->ChangeIntl(rScan.GetTmpLnge());
+ }
+ OUString sInsertCalendar; // a calendar resulting from parsing LCID
+ OUString sStr;
+ nPosOld = nPos; // Start position of substring
+ // first get bracketed prefixes; e.g. conditions, color
+ do
+ {
+ eSymbolType = ImpNextSymbol(sBuff, nPos, sStr);
+ if (eSymbolType > 0) // condition
+ {
+ if ( nIndex == 0 && !bCondition )
+ {
+ bCondition = true;
+ eOp1 = static_cast<SvNumberformatLimitOps>(eSymbolType);
+ }
+ else if ( nIndex == 1 && bCondition )
+ {
+ eOp2 = static_cast<SvNumberformatLimitOps>(eSymbolType);
+ }
+ else // error
+ {
+ bCancel = true; // break for
+ nCheckPos = nPosOld;
+ }
+ if (!bCancel)
+ {
+ double fNumber;
+ sal_Int32 nCntChars = ImpGetNumber(sBuff, nPos, sStr);
+ if (nCntChars > 0)
+ {
+ sal_Int32 nDecPos;
+ SvNumFormatType F_Type = SvNumFormatType::UNDEFINED;
+ if (!pISc->IsNumberFormat(sStr, F_Type, fNumber, nullptr, SvNumInputOptions::NONE) ||
+ ( F_Type != SvNumFormatType::NUMBER &&
+ F_Type != SvNumFormatType::SCIENTIFIC) )
+ {
+ fNumber = 0.0;
+ nPos = nPos - nCntChars;
+ sBuff.remove(nPos, nCntChars);
+ sBuff.insert(nPos, '0');
+ nPos++;
+ }
+ else if (rScan.GetConvertMode() && ((nDecPos = sStr.indexOf( aConvertFromDecSep)) >= 0))
+ {
+ if (aConvertToDecSep.isEmpty())
+ aConvertToDecSep = GetFormatter().GetLangDecimalSep( rScan.GetNewLnge());
+ if (aConvertToDecSep != aConvertFromDecSep)
+ {
+ const OUString aStr( sStr.replaceAt( nDecPos,
+ aConvertFromDecSep.getLength(), aConvertToDecSep));
+ nPos = nPos - nCntChars;
+ sBuff.remove(nPos, nCntChars);
+ sBuff.insert(nPos, aStr);
+ nPos += aStr.getLength();
+ }
+ }
+ }
+ else
+ {
+ fNumber = 0.0;
+ sBuff.insert(nPos++, '0');
+ }
+ if (nIndex == 0)
+ {
+ fLimit1 = fNumber;
+ }
+ else
+ {
+ fLimit2 = fNumber;
+ }
+ if ( nPos < sBuff.getLength() && sBuff[nPos] == ']' )
+ {
+ nPos++;
+ }
+ else
+ {
+ bCancel = true; // break for
+ nCheckPos = nPos;
+ }
+ }
+ nPosOld = nPos; // position before string
+ }
+ else if ( lcl_SvNumberformat_IsBracketedPrefix( eSymbolType ) )
+ {
+ OUString sSymbol( sStr);
+ switch ( eSymbolType )
+ {
+ case BRACKET_SYMBOLTYPE_COLOR :
+ if ( NumFor[nIndex].GetColor() != nullptr )
+ { // error, more than one color
+ bCancel = true; // break for
+ nCheckPos = nPosOld;
+ }
+ else
+ {
+ const Color* pColor = pSc->GetColor( sStr);
+ NumFor[nIndex].SetColor( pColor, sStr);
+ if (pColor == nullptr)
+ { // error
+ bCancel = true; // break for
+ nCheckPos = nPosOld;
+ }
+ }
+ break;
+ case BRACKET_SYMBOLTYPE_NATNUM0 :
+ case BRACKET_SYMBOLTYPE_NATNUM1 :
+ case BRACKET_SYMBOLTYPE_NATNUM2 :
+ case BRACKET_SYMBOLTYPE_NATNUM3 :
+ case BRACKET_SYMBOLTYPE_NATNUM4 :
+ case BRACKET_SYMBOLTYPE_NATNUM5 :
+ case BRACKET_SYMBOLTYPE_NATNUM6 :
+ case BRACKET_SYMBOLTYPE_NATNUM7 :
+ case BRACKET_SYMBOLTYPE_NATNUM8 :
+ case BRACKET_SYMBOLTYPE_NATNUM9 :
+ case BRACKET_SYMBOLTYPE_NATNUM10 :
+ case BRACKET_SYMBOLTYPE_NATNUM11 :
+ case BRACKET_SYMBOLTYPE_NATNUM12 :
+ case BRACKET_SYMBOLTYPE_NATNUM13 :
+ case BRACKET_SYMBOLTYPE_NATNUM14 :
+ case BRACKET_SYMBOLTYPE_NATNUM15 :
+ case BRACKET_SYMBOLTYPE_NATNUM16 :
+ case BRACKET_SYMBOLTYPE_NATNUM17 :
+ case BRACKET_SYMBOLTYPE_NATNUM18 :
+ case BRACKET_SYMBOLTYPE_NATNUM19 :
+ if ( NumFor[nIndex].GetNatNum().IsSet() )
+ {
+ bCancel = true; // break for
+ nCheckPos = nPosOld;
+ }
+ else
+ {
+ OUString sParams;
+ sal_Int32 nSpacePos = sStr.indexOf(' ');
+ if (nSpacePos >= 0)
+ {
+ sParams = o3tl::trim(sStr.subView(nSpacePos+1));
+ }
+ //! eSymbolType is negative
+ sal_uInt8 nNum = static_cast<sal_uInt8>(0 - (eSymbolType - BRACKET_SYMBOLTYPE_NATNUM0));
+ if (!sParams.isEmpty() && !NatNumTakesParameters(nNum))
+ {
+ bCancel = true; // break for
+ nCheckPos = nPosOld;
+ break;
+ }
+ sStr = "NatNum" + OUString::number(nNum);
+ NumFor[nIndex].SetNatNumNum( nNum, false );
+ // NatNum12 supports arguments
+ if (nNum == 12)
+ {
+ if (sParams.isEmpty())
+ sParams = "cardinal"; // default NatNum12 format is "cardinal"
+ NumFor[nIndex].SetNatNumParams(sParams);
+ sStr += " " + sParams;
+ }
+ }
+ break;
+ case BRACKET_SYMBOLTYPE_DBNUM1 :
+ case BRACKET_SYMBOLTYPE_DBNUM2 :
+ case BRACKET_SYMBOLTYPE_DBNUM3 :
+ case BRACKET_SYMBOLTYPE_DBNUM4 :
+ case BRACKET_SYMBOLTYPE_DBNUM5 :
+ case BRACKET_SYMBOLTYPE_DBNUM6 :
+ case BRACKET_SYMBOLTYPE_DBNUM7 :
+ case BRACKET_SYMBOLTYPE_DBNUM8 :
+ case BRACKET_SYMBOLTYPE_DBNUM9 :
+ if ( NumFor[nIndex].GetNatNum().IsSet() )
+ {
+ bCancel = true; // break for
+ nCheckPos = nPosOld;
+ }
+ else
+ {
+ //! eSymbolType is negative
+ sal_uInt8 nNum = static_cast<sal_uInt8>(1 - (eSymbolType - BRACKET_SYMBOLTYPE_DBNUM1));
+ sStr = "DBNum" + OUStringChar(sal_Unicode('0' + nNum));
+ NumFor[nIndex].SetNatNumNum( nNum, true );
+ }
+ break;
+ case BRACKET_SYMBOLTYPE_LOCALE :
+ if ( NumFor[nIndex].GetNatNum().GetLang() != LANGUAGE_DONTKNOW ||
+ sBuff[nPos-1] != ']' )
+ // Check also for ']' to avoid pulling in
+ // locale data for the preview string for not
+ // yet completed LCIDs in the dialog.
+ {
+ bCancel = true; // break for
+ nCheckPos = nPosOld;
+ }
+ else
+ {
+ sal_Int32 nTmp = 2;
+ LocaleType aTmpLocale( ImpGetLocaleType( sStr, nTmp));
+ if (aTmpLocale.meLanguage == LANGUAGE_DONTKNOW)
+ {
+ bCancel = true; // break for
+ nCheckPos = nPosOld;
+ }
+ else
+ {
+ // Only the first sub format's locale will be
+ // used as the format's overall locale.
+ // Sorts this also under the corresponding
+ // locale for the dialog.
+ // If we don't support the locale this would
+ // result in an unknown (empty) language
+ // listbox entry and the user would never see
+ // this format.
+ if (nIndex == 0 && (aTmpLocale.meLanguage == LANGUAGE_SYSTEM ||
+ SvNumberFormatter::IsLocaleInstalled( aTmpLocale.meLanguage)))
+ {
+ maLocale = aTmpLocale;
+ eLan = aTmpLocale.meLanguage; // return to caller
+
+ // Set new target locale also at scanner.
+ // We have to do this because switching locale
+ // may make replacing keywords and separators
+ // necessary.
+ // We can do this because it's the first
+ // subformat and we're still at parsing the
+ // modifiers, not keywords.
+ rScan.SetNewLnge( eLan);
+ // We can not force conversion though because
+ // the caller may have explicitly not set it.
+ // In the usual case the target locale is the
+ // originating locale the conversion is not
+ // necessary, when reading alien documents
+ // conversion is enabled anyway.
+
+ /* TODO: fiddle with scanner to make this
+ * known? A change in the locale may affect
+ * separators and keywords. On the other
+ * hand they may have been entered as used
+ * in the originating locale, there's no
+ * way to predict other than analyzing the
+ * format code, we assume here the current
+ * context is used, which is most likely
+ * the case.
+ * */
+
+ // Strip a plain locale identifier if locale
+ // data is available to avoid duplicated
+ // formats with and without LCID for the same
+ // locale. Besides it looks ugly and confusing
+ // and is unnecessary as the format will be
+ // listed for the resulting locale.
+ if (aTmpLocale.isPlainLocale())
+ sStr.clear();
+ else
+ sStr = "$-" + aTmpLocale.generateCode();
+ }
+ else
+ {
+ if (nIndex == 0)
+ // Locale data not available, remember.
+ maLocale.meLanguageWithoutLocaleData = aTmpLocale.meLanguage;
+
+ sStr = "$-" + aTmpLocale.generateCode();
+ }
+ NumFor[nIndex].SetNatNumLang( MsLangId::getRealLanguage( aTmpLocale.meLanguage));
+
+ // "$-NNCCLLLL" Numerals and Calendar
+ if (sSymbol.getLength() > 6)
+ {
+ sInsertCalendar = ImpObtainCalendarAndNumerals( sBuff, nPos, eLan, aTmpLocale);
+ }
+ /* NOTE: there can be only one calendar
+ * inserted so the last one wins, though
+ * our own calendar modifiers support
+ * multiple calendars within one sub format
+ * code if at different positions. */
+ }
+ }
+ break;
+ }
+ if ( !bCancel )
+ {
+ if (sStr == sSymbol)
+ {
+ nPosOld = nPos;
+ }
+ else
+ {
+ sBuff.remove(nPosOld, nPos - nPosOld);
+ if (!sStr.isEmpty())
+ {
+ sBuff.insert(nPosOld, sStr);
+ nPos = nPosOld + sStr.getLength();
+ sBuff.insert(nPos, "]");
+ sBuff.insert(nPosOld, "[");
+ nPos += 2;
+ nPosOld = nPos; // position before string
+ }
+ else
+ {
+ nPos = nPosOld; // prefix removed for whatever reason
+ }
+ }
+ }
+ }
+ }
+ while ( !bCancel && lcl_SvNumberformat_IsBracketedPrefix( eSymbolType ) );
+
+ // The remaining format code string
+ if ( !bCancel )
+ {
+ if (eSymbolType == BRACKET_SYMBOLTYPE_FORMAT)
+ {
+ if (nIndex == 1 && eOp1 == NUMBERFORMAT_OP_NO)
+ {
+ eOp1 = NUMBERFORMAT_OP_GT; // undefined condition, default: > 0
+ }
+ else if (nIndex == 2 && eOp2 == NUMBERFORMAT_OP_NO)
+ {
+ eOp2 = NUMBERFORMAT_OP_LT; // undefined condition, default: < 0
+ }
+ if (sStr.isEmpty())
+ {
+ // Empty sub format.
+ NumFor[nIndex].Info().eScannedType = SvNumFormatType::EMPTY;
+ }
+ else
+ {
+ if (!sInsertCalendar.isEmpty())
+ {
+ sStr = sInsertCalendar + sStr;
+ }
+ sal_Int32 nStrPos = pSc->ScanFormat( sStr);
+ sal_uInt16 nCnt = pSc->GetResultStringsCnt();
+ if (nCnt == 0 && nStrPos == 0) // error
+ {
+ nStrPos = 1;
+ }
+ if (nStrPos == 0) // ok
+ {
+ // e.g. Thai T speciality
+ if (pSc->GetNatNumModifier() && !NumFor[nIndex].GetNatNum().IsSet())
+ {
+ sStr = "[NatNum" + OUString::number( pSc->GetNatNumModifier()) + "]" + sStr;
+ NumFor[nIndex].SetNatNumNum( pSc->GetNatNumModifier(), false );
+ }
+ // #i53826# #i42727# For the Thai T speciality we need
+ // to freeze the locale and immunize it against
+ // conversions during exports, just in case we want to
+ // save to Xcl. This disables the feature of being able
+ // to convert a NatNum to another locale. You can't
+ // have both.
+ // FIXME: implement a specialized export conversion
+ // that works on tokens (have to tokenize all first)
+ // and doesn't use the format string and
+ // PutandConvertEntry() to LANGUAGE_ENGLISH_US in
+ // sc/source/filter/excel/xestyle.cxx
+ // XclExpNumFmtBuffer::WriteFormatRecord().
+ LanguageType eLanguage;
+ if (NumFor[nIndex].GetNatNum().GetNatNum() == 1 &&
+ ((eLanguage = MsLangId::getRealLanguage( eLan)) == LANGUAGE_THAI) &&
+ NumFor[nIndex].GetNatNum().GetLang() == LANGUAGE_DONTKNOW)
+ {
+ sStr = "[$-" + OUString::number( sal_uInt16(eLanguage), 16 ).toAsciiUpperCase() + "]" + sStr;
+ NumFor[nIndex].SetNatNumLang( eLanguage);
+ }
+ sBuff.remove(nPosOld, nPos - nPosOld);
+ sBuff.insert(nPosOld, sStr);
+ nPos = nPosOld + sStr.getLength();
+ if (nPos < sBuff.getLength())
+ {
+ sBuff.insert(nPos, ";");
+ nPos++;
+ }
+ else if (nIndex > 0)
+ {
+ // The last subformat. If it is a trailing text
+ // format the omitted subformats act like they were
+ // not specified and "inherited" the first format,
+ // e.g. 0;@ behaves like 0;-0;0;@
+ if (pSc->GetScannedType() == SvNumFormatType::TEXT)
+ {
+ // Reset conditions, reverting any set above.
+ if (nIndex == 1)
+ eOp1 = NUMBERFORMAT_OP_NO;
+ else if (nIndex == 2)
+ eOp2 = NUMBERFORMAT_OP_NO;
+ nIndex = 3;
+ }
+ }
+ NumFor[nIndex].Enlarge(nCnt);
+ pSc->CopyInfo(&(NumFor[nIndex].Info()), nCnt);
+ // type check
+ if (nIndex == 0)
+ {
+ eType = NumFor[nIndex].Info().eScannedType;
+ }
+ else if (nIndex == 3)
+ { // #77026# Everything recognized IS text
+ NumFor[nIndex].Info().eScannedType = SvNumFormatType::TEXT;
+ }
+ else if ( NumFor[nIndex].Info().eScannedType != eType)
+ {
+ eType = SvNumFormatType::DEFINED;
+ }
+ }
+ else
+ {
+ nCheckPos = nPosOld + nStrPos; // error in string
+ bCancel = true; // break for
+ }
+ }
+ }
+ else if (eSymbolType == BRACKET_SYMBOLTYPE_ERROR) // error
+ {
+ nCheckPos = nPosOld;
+ bCancel = true;
+ }
+ else if ( lcl_SvNumberformat_IsBracketedPrefix( eSymbolType ) )
+ {
+ nCheckPos = nPosOld + 1; // error, prefix in string
+ bCancel = true; // break for
+ }
+ }
+ if ( bCancel && !nCheckPos )
+ {
+ nCheckPos = 1; // nCheckPos is used as an error condition
+ }
+ if ( !bCancel )
+ {
+ if ( NumFor[nIndex].GetNatNum().IsSet() &&
+ NumFor[nIndex].GetNatNum().GetLang() == LANGUAGE_DONTKNOW )
+ {
+ NumFor[nIndex].SetNatNumLang( eLan );
+ }
+ }
+ if (sBuff.getLength() == nPos)
+ {
+ if (nIndex < 3 && rString[rString.getLength()-1] == ';')
+ {
+ // A trailing ';' is significant and specifies the following
+ // subformat to be empty. We don't enter the scanning loop
+ // above again though.
+ // Note that the operators apply to the current last scanned
+ // subformat.
+ if (nIndex == 0 && eOp1 == NUMBERFORMAT_OP_NO)
+ {
+ eOp1 = NUMBERFORMAT_OP_GT; // undefined condition, default: > 0
+ }
+ else if (nIndex == 1 && eOp2 == NUMBERFORMAT_OP_NO)
+ {
+ eOp2 = NUMBERFORMAT_OP_LT; // undefined condition, default: < 0
+ }
+ NumFor[nIndex+1].Info().eScannedType = SvNumFormatType::EMPTY;
+ if (sBuff[nPos-1] != ';')
+ sBuff.insert( nPos++, ';');
+ }
+ if (nIndex == 2 && eSymbolType == BRACKET_SYMBOLTYPE_FORMAT && sBuff[nPos-1] == ';')
+ {
+ // #83510# A 4th subformat explicitly specified to be empty
+ // hides any text. Need the type here for HasTextFormat()
+ NumFor[3].Info().eScannedType = SvNumFormatType::TEXT;
+ }
+ bCancel = true;
+ }
+ if ( NumFor[nIndex].GetNatNum().IsSet() )
+ {
+ NumFor[nIndex].SetNatNumDate( bool(NumFor[nIndex].Info().eScannedType & SvNumFormatType::DATE) );
+ }
+ }
+
+ if (!nCheckPos && IsSubstituted())
+ {
+ // For to be substituted formats the scanned type must match the
+ // substitute type.
+ if (IsSystemTimeFormat())
+ {
+ if ((eType & ~SvNumFormatType::DEFINED) != SvNumFormatType::TIME)
+ nCheckPos = std::max<sal_Int32>( sBuff.indexOf(']') + 1, 1);
+ }
+ else if (IsSystemLongDateFormat())
+ {
+ if ((eType & ~SvNumFormatType::DEFINED) != SvNumFormatType::DATE)
+ nCheckPos = std::max<sal_Int32>( sBuff.indexOf(']') + 1, 1);
+ }
+ else
+ assert(!"unhandled substitute");
+ }
+
+ if ( bCondition && !nCheckPos )
+ {
+ if ( nIndex == 1 && NumFor[0].GetCount() == 0 &&
+ sBuff[sBuff.getLength() - 1] != ';' )
+ {
+ // No format code => GENERAL but not if specified empty
+ OUString aAdd( pSc->GetStandardName() );
+ if ( !pSc->ScanFormat( aAdd ) )
+ {
+ sal_uInt16 nCnt = pSc->GetResultStringsCnt();
+ if ( nCnt )
+ {
+ NumFor[0].Enlarge(nCnt);
+ pSc->CopyInfo( &(NumFor[0].Info()), nCnt );
+ sBuff.append(aAdd);
+ }
+ }
+ }
+ else if ( nIndex == 1 && NumFor[nIndex].GetCount() == 0 &&
+ sBuff[sBuff.getLength() - 1] != ';' &&
+ (NumFor[0].GetCount() > 1 ||
+ (NumFor[0].GetCount() == 1 &&
+ NumFor[0].Info().nTypeArray[0] != NF_KEY_GENERAL)) )
+ {
+ // No trailing second subformat => GENERAL but not if specified empty
+ // and not if first subformat is GENERAL
+ OUString aAdd( pSc->GetStandardName() );
+ if ( !pSc->ScanFormat( aAdd ) )
+ {
+ sal_uInt16 nCnt = pSc->GetResultStringsCnt();
+ if ( nCnt )
+ {
+ NumFor[nIndex].Enlarge(nCnt);
+ pSc->CopyInfo( &(NumFor[nIndex].Info()), nCnt );
+ sBuff.append(";");
+ sBuff.append(aAdd);
+ }
+ }
+ }
+ else if ( nIndex == 2 && NumFor[nIndex].GetCount() == 0 &&
+ sBuff[sBuff.getLength() - 1] != ';' &&
+ eOp2 != NUMBERFORMAT_OP_NO )
+ {
+ // No trailing third subformat => GENERAL but not if specified empty
+ OUString aAdd( pSc->GetStandardName() );
+ if ( !pSc->ScanFormat( aAdd ) )
+ {
+ sal_uInt16 nCnt = pSc->GetResultStringsCnt();
+ if ( nCnt )
+ {
+ NumFor[nIndex].Enlarge(nCnt);
+ pSc->CopyInfo( &(NumFor[nIndex].Info()), nCnt );
+ sBuff.append(";");
+ sBuff.append(aAdd);
+ }
+ }
+ }
+ }
+ rString = sBuff.makeStringAndClear();
+ sFormatstring = rString;
+
+ if (NumFor[2].GetCount() == 0 && // No third partial string
+ eOp1 == NUMBERFORMAT_OP_GT && eOp2 == NUMBERFORMAT_OP_NO &&
+ fLimit1 == 0.0 && fLimit2 == 0.0)
+ {
+ eOp1 = NUMBERFORMAT_OP_GE; // Add 0 to the first format
+ }
+
+}
+
+SvNumberformat::~SvNumberformat()
+{
+}
+
+/**
+ * Next_Symbol
+ *
+ * Splits up the symbols for further processing (by the Turing machine)
+ *
+ * Start state = SsStart, * = Special state
+ * ---------------+-------------------+----------------------------+---------------
+ * Old State | Symbol read | Event | New state
+ * ---------------+-------------------+----------------------------+---------------
+ * SsStart | " | Symbol += Character | SsGetQuoted
+ * | ; | Pos-- | SsGetString
+ * | [ | Symbol += Character | SsGetBracketed
+ * | ] | Error | SsStop
+ * | BLANK | |
+ * | Else | Symbol += Character | SsGetString
+ * ---------------+-------------------+----------------------------+---------------
+ * SsGetString | " | Symbol += Character | SsGetQuoted
+ * | ; | | SsStop
+ * | Else | Symbol += Character |
+ * ---------------+-------------------+----------------------------+---------------
+ * SsGetQuoted | " | Symbol += Character | SsGetString
+ * | Else | Symbol += Character |
+ * ---------------+-------------------+----------------------------+---------------
+ * SsGetBracketed | <, > = | del [ |
+ * | | Symbol += Character | SsGetCon
+ * | BLANK | |
+ * | h, H, m, M, s, S | Symbol += Character | SsGetTime
+ * | Else | del [ |
+ * | | Symbol += Character | SsGetPrefix
+ * ---------------+-------------------+----------------------------+---------------
+ * SsGetTime | ] | Symbol += Character | SsGetString
+ * | h, H, m, M, s, S | Symbol += Character, * | SsGetString
+ * | Else | del [; Symbol += Character | SsGetPrefix
+ * ---------------+-------------------+----------------------------+---------------
+ * SsGetPrefix | ] | | SsStop
+ * | Else | Symbol += Character |
+ * ---------------+-------------------+----------------------------+---------------
+ * SsGetCon | >, = | Symbol += Character |
+ * | ] | | SsStop
+ * | Else | Error | SsStop
+ * ---------------+-------------------+----------------------------+---------------
+ */
+
+namespace {
+
+enum ScanState
+{
+ SsStop,
+ SsStart,
+ SsGetCon, // condition
+ SsGetString, // format string
+ SsGetPrefix, // color or NatNumN
+ SsGetTime, // [HH] for time
+ SsGetBracketed, // any [...] not decided yet
+ SsGetQuoted // quoted text
+};
+
+}
+
+// read a string until ']' and delete spaces in input
+// static
+sal_Int32 SvNumberformat::ImpGetNumber(OUStringBuffer& rString,
+ sal_Int32& nPos,
+ OUString& sSymbol)
+{
+ sal_Int32 nStartPos = nPos;
+ sal_Unicode cToken;
+ sal_Int32 nLen = rString.getLength();
+ OUStringBuffer sBuffSymbol;
+ while ( nPos < nLen )
+ {
+ cToken = rString[nPos];
+ if (cToken == ']')
+ break;
+ if (cToken == ' ')
+ { // delete spaces
+ rString.remove(nPos,1);
+ nLen--;
+ }
+ else
+ {
+ nPos++;
+ sBuffSymbol.append(cToken);
+ }
+ }
+ sSymbol = sBuffSymbol.makeStringAndClear();
+ return nPos - nStartPos;
+}
+
+namespace {
+
+sal_Unicode toUniChar(sal_uInt8 n)
+{
+ char c;
+ if (n < 10)
+ {
+ c = '0' + n;
+ }
+ else
+ {
+ c = 'A' + n - 10;
+ }
+ return sal_Unicode(c);
+}
+
+bool IsCombiningSymbol( OUStringBuffer& rStringBuffer, sal_Int32 nPos )
+{
+ bool bRet = false;
+ while (nPos >= 0)
+ {
+ switch (rStringBuffer[nPos])
+ {
+ case '*':
+ case '\\':
+ case '_':
+ bRet = !bRet;
+ --nPos;
+ break;
+ default:
+ return bRet;
+ }
+ }
+ return bRet;
+}
+
+} // namespace
+
+OUString SvNumberformat::LocaleType::generateCode() const
+{
+ OUStringBuffer aBuf;
+#if 0
+ // TODO: We may re-enable this later. Don't remove it! --Kohei
+ if (mnNumeralShape)
+ {
+ sal_uInt8 nVal = mnNumeralShape;
+ for (sal_uInt8 i = 0; i < 2; ++i)
+ {
+ sal_uInt8 n = (nVal & 0xF0) >> 4;
+ if (n || aBuf.getLength())
+ {
+ aBuf.append(toUniChar(n));
+ }
+ nVal = nVal << 4;
+ }
+ }
+
+ if (mnNumeralShape || mnCalendarType)
+ {
+ sal_uInt8 nVal = mnCalendarType;
+ for (sal_uInt8 i = 0; i < 2; ++i)
+ {
+ sal_uInt8 n = (nVal & 0xF0) >> 4;
+ if (n || aBuf.getLength())
+ {
+ aBuf.append(toUniChar(n));
+ }
+ nVal = nVal << 4;
+ }
+ }
+#endif
+
+ sal_uInt16 n16 = static_cast<sal_uInt16>(
+ (meLanguageWithoutLocaleData == LANGUAGE_DONTKNOW) ? meLanguage :
+ meLanguageWithoutLocaleData);
+ if (meLanguage == LANGUAGE_SYSTEM)
+ {
+ switch (meSubstitute)
+ {
+ case Substitute::NONE:
+ ; // nothing
+ break;
+ case Substitute::TIME:
+ n16 = static_cast<sal_uInt16>(LANGUAGE_NF_SYSTEM_TIME);
+ break;
+ case Substitute::LONGDATE:
+ n16 = static_cast<sal_uInt16>(LANGUAGE_NF_SYSTEM_DATE);
+ break;
+ }
+ }
+ for (sal_uInt8 i = 0; i < 4; ++i)
+ {
+ sal_uInt8 n = static_cast<sal_uInt8>((n16 & 0xF000) >> 12);
+ // Omit leading zeros for consistency.
+ if (n || !aBuf.isEmpty() || i == 3)
+ {
+ aBuf.append(toUniChar(n));
+ }
+ n16 = n16 << 4;
+ }
+
+ return aBuf.makeStringAndClear();
+}
+
+SvNumberformat::LocaleType::LocaleType()
+ : meLanguage(LANGUAGE_DONTKNOW)
+ , meLanguageWithoutLocaleData(LANGUAGE_DONTKNOW)
+ , meSubstitute(Substitute::NONE)
+ , mnNumeralShape(0)
+ , mnCalendarType(0)
+{
+}
+
+SvNumberformat::LocaleType::LocaleType(sal_uInt32 nRawNum)
+ : meLanguage(LANGUAGE_DONTKNOW)
+ , meLanguageWithoutLocaleData(LANGUAGE_DONTKNOW)
+ , meSubstitute(Substitute::NONE)
+ , mnNumeralShape(0)
+ , mnCalendarType(0)
+{
+ meLanguage = static_cast<LanguageType>(nRawNum & 0x0000FFFF);
+ if (meLanguage == LANGUAGE_NF_SYSTEM_TIME)
+ {
+ meSubstitute = Substitute::TIME;
+ meLanguage = LANGUAGE_SYSTEM;
+ }
+ else if (meLanguage == LANGUAGE_NF_SYSTEM_DATE)
+ {
+ meSubstitute = Substitute::LONGDATE;
+ meLanguage = LANGUAGE_SYSTEM;
+ }
+ nRawNum = (nRawNum >> 16);
+ mnCalendarType = static_cast<sal_uInt8>(nRawNum & 0xFF);
+ nRawNum = (nRawNum >> 8);
+ mnNumeralShape = static_cast<sal_uInt8>(nRawNum & 0xFF);
+}
+
+bool SvNumberformat::LocaleType::isPlainLocale() const
+{
+ return meSubstitute == Substitute::NONE && !mnCalendarType && !mnNumeralShape;
+}
+
+// static
+SvNumberformat::LocaleType SvNumberformat::ImpGetLocaleType(const OUString& rString, sal_Int32& nPos )
+{
+ sal_uInt32 nNum = 0;
+ sal_Unicode cToken = 0;
+ sal_Int32 nStart = nPos;
+ sal_Int32 nLen = rString.getLength();
+ while ( nPos < nLen && (nPos - nStart < 8) )
+ {
+ cToken = rString[nPos];
+ if (cToken == ']')
+ break;
+ if ( '0' <= cToken && cToken <= '9' )
+ {
+ nNum *= 16;
+ nNum += cToken - '0';
+ }
+ else if ( 'a' <= cToken && cToken <= 'f' )
+ {
+ nNum *= 16;
+ nNum += cToken - 'a' + 10;
+ }
+ else if ( 'A' <= cToken && cToken <= 'F' )
+ {
+ nNum *= 16;
+ nNum += cToken - 'A' + 10;
+ }
+ else
+ {
+ return LocaleType(); // LANGUAGE_DONTKNOW;
+ }
+ ++nPos;
+ }
+
+ return (cToken == ']' || nPos == nLen) ? LocaleType(nNum) : LocaleType();
+}
+
+static bool lcl_matchKeywordAndGetNumber( const OUString & rString, const sal_Int32 nPos,
+ const OUString & rKeyword, sal_Int32 & nNumber )
+{
+ if (0 <= nPos && nPos + rKeyword.getLength() < rString.getLength() && rString.matchIgnoreAsciiCase( rKeyword, nPos))
+ {
+ nNumber = o3tl::toInt32(rString.subView( nPos + rKeyword.getLength()));
+ return true;
+ }
+ else
+ {
+ nNumber = 0;
+ return false;
+ }
+}
+
+short SvNumberformat::ImpNextSymbol(OUStringBuffer& rString,
+ sal_Int32& nPos,
+ OUString& sSymbol) const
+{
+ short eSymbolType = BRACKET_SYMBOLTYPE_FORMAT;
+ sal_Unicode cToken;
+ sal_Unicode cLetter = ' '; // Preliminary result
+ sal_Int32 nLen = rString.getLength();
+ ScanState eState = SsStart;
+ OUStringBuffer sBuffSymbol(128);
+
+ const NfKeywordTable & rKeywords = rScan.GetKeywords();
+ while (nPos < nLen && eState != SsStop)
+ {
+ cToken = rString[nPos];
+ nPos++;
+ switch (eState)
+ {
+ case SsStart:
+ if (cToken == '\"')
+ {
+ eState = SsGetQuoted;
+ sBuffSymbol.append(cToken);
+ }
+ else if (cToken == '[')
+ {
+ eState = SsGetBracketed;
+ sBuffSymbol.append(cToken);
+ }
+ else if (cToken == ';')
+ {
+ eState = SsGetString;
+ nPos--;
+ eSymbolType = BRACKET_SYMBOLTYPE_FORMAT;
+ }
+ else if (cToken == ']')
+ {
+ eState = SsStop;
+ eSymbolType = BRACKET_SYMBOLTYPE_ERROR;
+ }
+ else if (cToken == ' ') // Skip Blanks
+ {
+ nPos--;
+ rString.remove(nPos, 1);
+ nLen--;
+ }
+ else
+ {
+ sBuffSymbol.append(cToken);
+ eState = SsGetString;
+ eSymbolType = BRACKET_SYMBOLTYPE_FORMAT;
+ }
+ break;
+ case SsGetBracketed:
+ switch (cToken)
+ {
+ case '<':
+ case '>':
+ case '=':
+ sBuffSymbol.stripStart('[');
+ sBuffSymbol.append(cToken);
+ cLetter = cToken;
+ eState = SsGetCon;
+ switch (cToken)
+ {
+ case '<':
+ eSymbolType = NUMBERFORMAT_OP_LT;
+ break;
+ case '>':
+ eSymbolType = NUMBERFORMAT_OP_GT;
+ break;
+ case '=':
+ eSymbolType = NUMBERFORMAT_OP_EQ;
+ break;
+ }
+ break;
+ case ' ':
+ nPos--;
+ rString.remove(nPos, 1);
+ nLen--;
+ break;
+ case '$' :
+ if ( nPos < nLen && rString[nPos] == '-' )
+ {
+ // [$-xxx] locale
+ sBuffSymbol.stripStart('[');
+ eSymbolType = BRACKET_SYMBOLTYPE_LOCALE;
+ eState = SsGetPrefix;
+ }
+ else
+ { // currency
+ eSymbolType = BRACKET_SYMBOLTYPE_FORMAT;
+ eState = SsGetString;
+ }
+ sBuffSymbol.append(cToken);
+ break;
+ case '~' :
+ // calendarID
+ eSymbolType = BRACKET_SYMBOLTYPE_FORMAT;
+ sBuffSymbol.append(cToken);
+ eState = SsGetString;
+ break;
+ default:
+ {
+ static const OUStringLiteral aNatNum(u"NATNUM");
+ static const OUStringLiteral aDBNum(u"DBNUM");
+ const OUString aBufStr( rString.toString());
+ sal_Int32 nNatNumNum;
+ sal_Int32 nDBNum;
+ if ( lcl_matchKeywordAndGetNumber( aBufStr, nPos-1, aNatNum, nNatNumNum) &&
+ 0 <= nNatNumNum && nNatNumNum <= 19 )
+ {
+ sBuffSymbol.stripStart('[');
+ sBuffSymbol.append( aBufStr.subView(--nPos, aNatNum.getLength()+1) );
+ nPos += aNatNum.getLength()+1;
+ //! SymbolType is negative
+ eSymbolType = static_cast<short>(BRACKET_SYMBOLTYPE_NATNUM0 - nNatNumNum);
+ eState = SsGetPrefix;
+ }
+ else if ( lcl_matchKeywordAndGetNumber( aBufStr, nPos-1, aDBNum, nDBNum) &&
+ 1 <= nDBNum && nDBNum <= 9 )
+ {
+ sBuffSymbol.stripStart('[');
+ sBuffSymbol.append( aBufStr.subView(--nPos, aDBNum.getLength()+1) );
+ nPos += aDBNum.getLength()+1;
+ //! SymbolType is negative
+ eSymbolType = sal::static_int_cast< short >( BRACKET_SYMBOLTYPE_DBNUM1 - (nDBNum - 1) );
+ eState = SsGetPrefix;
+ }
+ else
+ {
+ sal_Unicode cUpper = rChrCls().uppercase( aBufStr, nPos-1, 1)[0];
+ if ( cUpper == rKeywords[NF_KEY_H][0] || // H
+ cUpper == rKeywords[NF_KEY_MI][0] || // M
+ cUpper == rKeywords[NF_KEY_S][0] ) // S
+ {
+ sBuffSymbol.append(cToken);
+ eState = SsGetTime;
+ cLetter = cToken;
+ }
+ else
+ {
+ sBuffSymbol.stripStart('[');
+ sBuffSymbol.append(cToken);
+ eSymbolType = BRACKET_SYMBOLTYPE_COLOR;
+ eState = SsGetPrefix;
+ }
+ }
+ }
+ }
+ break;
+ case SsGetString:
+ if (cToken == '\"')
+ {
+ eState = SsGetQuoted;
+ sBuffSymbol.append(cToken);
+ }
+ else if (cToken == ';' && (nPos < 2 || !IsCombiningSymbol( rString, nPos-2)))
+ {
+ eState = SsStop;
+ }
+ else
+ {
+ sBuffSymbol.append(cToken);
+ }
+ break;
+ case SsGetQuoted:
+ if (cToken == '\"')
+ {
+ eState = SsGetString;
+ sBuffSymbol.append(cToken);
+ }
+ else
+ {
+ sBuffSymbol.append(cToken);
+ }
+ break;
+ case SsGetTime:
+ if (cToken == ']')
+ {
+ sBuffSymbol.append(cToken);
+ eState = SsGetString;
+ eSymbolType = BRACKET_SYMBOLTYPE_FORMAT;
+ }
+ else
+ {
+ sal_Unicode cUpper = rChrCls().uppercase(rString.toString(), nPos-1, 1)[0];
+ if (cUpper == rKeywords[NF_KEY_H][0] || // H
+ cUpper == rKeywords[NF_KEY_MI][0] || // M
+ cUpper == rKeywords[NF_KEY_S][0] ) // S
+ {
+ if (cLetter == cToken)
+ {
+ sBuffSymbol.append(cToken);
+ cLetter = ' ';
+ }
+ else
+ {
+ sBuffSymbol.stripStart('[');
+ sBuffSymbol.append(cToken);
+ eState = SsGetPrefix;
+ }
+ }
+ else
+ {
+ sBuffSymbol.stripStart('[');
+ sBuffSymbol.append(cToken);
+ eSymbolType = BRACKET_SYMBOLTYPE_COLOR;
+ eState = SsGetPrefix;
+ }
+ }
+ break;
+ case SsGetCon:
+ switch (cToken)
+ {
+ case '<':
+ eState = SsStop;
+ eSymbolType = BRACKET_SYMBOLTYPE_ERROR;
+ break;
+ case '>':
+ if (cLetter == '<')
+ {
+ sBuffSymbol.append(cToken);
+ cLetter = ' ';
+ eState = SsStop;
+ eSymbolType = NUMBERFORMAT_OP_NE;
+ }
+ else
+ {
+ eState = SsStop;
+ eSymbolType = BRACKET_SYMBOLTYPE_ERROR;
+ }
+ break;
+ case '=':
+ if (cLetter == '<')
+ {
+ sBuffSymbol.append(cToken);
+ cLetter = ' ';
+ eSymbolType = NUMBERFORMAT_OP_LE;
+ }
+ else if (cLetter == '>')
+ {
+ sBuffSymbol.append(cToken);
+ cLetter = ' ';
+ eSymbolType = NUMBERFORMAT_OP_GE;
+ }
+ else
+ {
+ eState = SsStop;
+ eSymbolType = BRACKET_SYMBOLTYPE_ERROR;
+ }
+ break;
+ case ' ':
+ nPos--;
+ rString.remove(nPos,1);
+ nLen--;
+ break;
+ default:
+ eState = SsStop;
+ nPos--;
+ break;
+ }
+ break;
+ case SsGetPrefix:
+ if (cToken == ']')
+ {
+ eState = SsStop;
+ }
+ else
+ {
+ sBuffSymbol.append(cToken);
+ }
+ break;
+ default:
+ break;
+ } // of switch
+ } // of while
+ sSymbol = sBuffSymbol.makeStringAndClear();
+ return eSymbolType;
+}
+
+void SvNumberformat::ConvertLanguage( SvNumberFormatter& rConverter,
+ LanguageType eConvertFrom,
+ LanguageType eConvertTo )
+{
+ sal_Int32 nCheckPos;
+ sal_uInt32 nKey;
+ SvNumFormatType nType = eType;
+ OUString aFormatString( sFormatstring );
+ rConverter.PutandConvertEntry( aFormatString, nCheckPos, nType,
+ nKey, eConvertFrom, eConvertTo, false);
+ const SvNumberformat* pFormat = rConverter.GetEntry( nKey );
+ DBG_ASSERT( pFormat, "SvNumberformat::ConvertLanguage: Conversion without format" );
+ if ( pFormat )
+ {
+ ImpCopyNumberformat( *pFormat );
+ // Reset values taken over from Formatter/Scanner
+ // pColor still points to table in temporary Formatter/Scanner
+ for (ImpSvNumFor & rFormatter : NumFor)
+ {
+ OUString aColorName = rFormatter.GetColorName();
+ const Color* pColor = rScan.GetColor( aColorName );
+ rFormatter.SetColor( pColor, aColorName );
+ }
+ }
+}
+
+bool SvNumberformat::HasNewCurrency() const
+{
+ for (const auto & j : NumFor)
+ {
+ if ( j.HasNewCurrency() )
+ {
+ return true;
+ }
+ }
+ return false;
+}
+
+bool SvNumberformat::GetNewCurrencySymbol( OUString& rSymbol,
+ OUString& rExtension ) const
+{
+ for (const auto & j : NumFor)
+ {
+ if ( j.GetNewCurrencySymbol( rSymbol, rExtension ) )
+ {
+ return true;
+ }
+ }
+ rSymbol.clear();
+ rExtension.clear();
+ return false;
+}
+
+// static
+OUString SvNumberformat::StripNewCurrencyDelimiters( const OUString& rStr )
+{
+ OUStringBuffer aTmp(rStr.getLength());
+ sal_Int32 nStartPos, nPos, nLen;
+ nLen = rStr.getLength();
+ nStartPos = 0;
+ while ( (nPos = rStr.indexOf( "[$", nStartPos )) >= 0 )
+ {
+ sal_Int32 nEnd;
+ if ( (nEnd = GetQuoteEnd( rStr, nPos )) >= 0 )
+ {
+ aTmp.append(rStr.subView( nStartPos, ++nEnd - nStartPos ));
+ nStartPos = nEnd;
+ }
+ else
+ {
+ aTmp.append(rStr.subView(nStartPos, nPos - nStartPos) );
+ nStartPos = nPos + 2;
+ sal_Int32 nDash;
+ nEnd = nStartPos - 1;
+ do
+ {
+ nDash = rStr.indexOf( '-', ++nEnd );
+ nEnd = GetQuoteEnd( rStr, nDash );
+ }
+ while ( nEnd >= 0 );
+ sal_Int32 nClose;
+ nEnd = nStartPos - 1;
+ do
+ {
+ nClose = rStr.indexOf( ']', ++nEnd );
+ nEnd = GetQuoteEnd( rStr, nClose );
+ }
+ while ( nEnd >= 0 );
+
+ if(nClose < 0)
+ {
+ /* there should always be a closing ]
+ * but the old String class would have hidden
+ * that. so be conservative too
+ */
+ nClose = nLen;
+ }
+
+ nPos = nClose;
+ if(nDash >= 0 && nDash < nClose)
+ {
+ nPos = nDash;
+ }
+ aTmp.append(rStr.subView(nStartPos, nPos - nStartPos) );
+ nStartPos = nClose + 1;
+ }
+ }
+ if ( nLen > nStartPos )
+ {
+ aTmp.append(rStr.subView(nStartPos, nLen - nStartPos) );
+ }
+ return aTmp.makeStringAndClear();
+}
+
+void SvNumberformat::ImpGetOutputStandard(double& fNumber, OUStringBuffer& rOutString) const
+{
+ OUString sTemp;
+ ImpGetOutputStandard(fNumber, sTemp);
+ rOutString = sTemp;
+}
+
+void SvNumberformat::ImpGetOutputStandard(double& fNumber, OUString& rOutString) const
+{
+ sal_uInt16 nStandardPrec = rScan.GetStandardPrec();
+
+ if ( fabs(fNumber) > EXP_ABS_UPPER_BOUND )
+ {
+ nStandardPrec = ::std::min(nStandardPrec, static_cast<sal_uInt16>(14)); // limits to 14 decimals
+ rOutString = ::rtl::math::doubleToUString( fNumber,
+ rtl_math_StringFormat_E2, nStandardPrec /*2*/,
+ GetFormatter().GetNumDecimalSep()[0]);
+ }
+ else
+ {
+ ImpGetOutputStdToPrecision(fNumber, rOutString, nStandardPrec);
+ }
+}
+
+namespace
+{
+
+template<typename T>
+bool checkForAll0s(const T& rString, sal_Int32 nIdx=0)
+{
+ if (nIdx>=rString.getLength())
+ return false;
+
+ do
+ {
+ if (rString[nIdx]!='0')
+ return false;
+ }
+ while (++nIdx<rString.getLength());
+
+ return true;
+}
+
+}
+
+void SvNumberformat::ImpGetOutputStdToPrecision(double& rNumber, OUString& rOutString, sal_uInt16 nPrecision) const
+{
+ // Make sure the precision doesn't go over the maximum allowable precision.
+ nPrecision = ::std::min(UPPER_PRECISION, nPrecision);
+
+ // We decided to strip trailing zeros unconditionally, since binary
+ // double-precision rounding error makes it impossible to determine e.g.
+ // whether 844.10000000000002273737 is what the user has typed, or the
+ // user has typed 844.1 but IEEE 754 represents it that way internally.
+
+ rOutString = ::rtl::math::doubleToUString( rNumber,
+ rtl_math_StringFormat_F, nPrecision /*2*/,
+ GetFormatter().GetNumDecimalSep()[0], true );
+ if (rOutString[0] == '-' && checkForAll0s(rOutString, 1))
+ {
+ rOutString = comphelper::string::stripStart(rOutString, '-'); // not -0
+ }
+ rOutString = impTransliterate(rOutString, NumFor[0].GetNatNum());
+}
+
+void SvNumberformat::ImpGetOutputInputLine(double fNumber, OUString& OutString) const
+{
+ bool bModified = false;
+ if ( (eType & SvNumFormatType::PERCENT) && (fabs(fNumber) < D_MAX_D_BY_100))
+ {
+ if (fNumber == 0.0)
+ {
+ OutString = "0%";
+ return;
+ }
+ fNumber *= 100;
+ bModified = true;
+ }
+
+ if (fNumber == 0.0)
+ {
+ OutString = "0";
+ return;
+ }
+
+ OutString = ::rtl::math::doubleToUString( fNumber,
+ rtl_math_StringFormat_Automatic,
+ rtl_math_DecimalPlaces_Max,
+ GetFormatter().GetNumDecimalSep()[0], true );
+
+ if ( eType & SvNumFormatType::PERCENT && bModified)
+ {
+ OutString += "%";
+ }
+}
+
+short SvNumberformat::ImpCheckCondition(double fNumber,
+ double fLimit,
+ SvNumberformatLimitOps eOp)
+{
+ switch(eOp)
+ {
+ case NUMBERFORMAT_OP_NO:
+ return -1;
+ case NUMBERFORMAT_OP_EQ:
+ return static_cast<short>(fNumber == fLimit);
+ case NUMBERFORMAT_OP_NE:
+ return static_cast<short>(fNumber != fLimit);
+ case NUMBERFORMAT_OP_LT:
+ return static_cast<short>(fNumber < fLimit);
+ case NUMBERFORMAT_OP_LE:
+ return static_cast<short>(fNumber <= fLimit);
+ case NUMBERFORMAT_OP_GT:
+ return static_cast<short>(fNumber > fLimit);
+ case NUMBERFORMAT_OP_GE:
+ return static_cast<short>(fNumber >= fLimit);
+ default:
+ return -1;
+ }
+}
+
+static bool lcl_appendStarFillChar( OUStringBuffer& rBuf, const OUString& rStr )
+{
+ // Right during user input the star symbol is the very
+ // last character before the user enters another one.
+ if (rStr.getLength() > 1)
+ {
+ rBuf.append(u'\x001B');
+ rBuf.append(rStr[1]);
+ return true;
+ }
+ return false;
+}
+
+static bool lcl_insertStarFillChar( OUStringBuffer& rBuf, sal_Int32 nPos, const OUString& rStr )
+{
+ if (rStr.getLength() > 1)
+ {
+ rBuf.insert( nPos, rStr[1]);
+ rBuf.insert( nPos, u'\x001B');
+ return true;
+ }
+ return false;
+}
+
+void SvNumberformat::GetOutputString(std::u16string_view sString,
+ OUString& OutString,
+ const Color** ppColor)
+{
+ OUStringBuffer sOutBuff;
+ sal_uInt16 nIx;
+ if (eType & SvNumFormatType::TEXT)
+ {
+ nIx = 0;
+ }
+ else if (NumFor[3].GetCount() > 0)
+ {
+ nIx = 3;
+ }
+ else
+ {
+ *ppColor = nullptr; // no change of color
+ return;
+ }
+ *ppColor = NumFor[nIx].GetColor();
+ const ImpSvNumberformatInfo& rInfo = NumFor[nIx].Info();
+ if (rInfo.eScannedType == SvNumFormatType::TEXT)
+ {
+ const sal_uInt16 nCnt = NumFor[nIx].GetCount();
+ for (sal_uInt16 i = 0; i < nCnt; i++)
+ {
+ switch (rInfo.nTypeArray[i])
+ {
+ case NF_SYMBOLTYPE_STAR:
+ if( bStarFlag )
+ {
+ lcl_appendStarFillChar( sOutBuff, rInfo.sStrArray[i]);
+ }
+ break;
+ case NF_SYMBOLTYPE_BLANK:
+ if (rInfo.sStrArray[i].getLength() >= 2)
+ InsertBlanks( sOutBuff, sOutBuff.getLength(), rInfo.sStrArray[i][1] );
+ break;
+ case NF_KEY_GENERAL : // #77026# "General" is the same as "@"
+ case NF_SYMBOLTYPE_DEL :
+ sOutBuff.append(sString);
+ break;
+ default:
+ sOutBuff.append(rInfo.sStrArray[i]);
+ }
+ }
+ }
+ OutString = sOutBuff.makeStringAndClear();
+}
+
+namespace {
+
+void lcl_GetOutputStringScientific(double fNumber, sal_uInt16 nCharCount,
+ const SvNumberFormatter& rFormatter, OUString& rOutString)
+{
+ bool bSign = std::signbit(fNumber);
+
+ // 1.000E+015 (one digit and the decimal point, and the two chars +
+ // nExpDigit for the exponential part, totalling 6 or 7).
+ double fExp = log10( fabs(fNumber) );
+ if( fExp < 0.0 )
+ fExp = 1.0 - fExp;
+ sal_uInt16 nCharFormat = 6 + (fExp >= 100.0 ? 1 : 0);
+ sal_uInt16 nPrec = nCharCount > nCharFormat ? nCharCount - nCharFormat : 0;
+ if (nPrec && bSign)
+ {
+ // Make room for the negative sign.
+ --nPrec;
+ }
+ nPrec = ::std::min(nPrec, static_cast<sal_uInt16>(14)); // limit to 14 decimals.
+
+ rOutString = ::rtl::math::doubleToUString(fNumber, rtl_math_StringFormat_E2,
+ nPrec, rFormatter.GetNumDecimalSep()[0], true );
+}
+
+OUString lcl_GetPercentString(const ImpSvNumberformatInfo &rInfo, sal_uInt16 nCnt)
+{
+ sal_Int32 i;
+ OUStringBuffer aPercentString;
+ for( i = 0; i < nCnt; i++ )
+ {
+ if( rInfo.nTypeArray[i] == NF_SYMBOLTYPE_PERCENT )
+ {
+ aPercentString.append( rInfo.sStrArray[i] );
+ bool bStringFound = false;
+ for( i--; i >= 0 && rInfo.nTypeArray[i] == NF_SYMBOLTYPE_STRING ; i-- )
+ {
+ if( !bStringFound )
+ {
+ bStringFound = true;
+ aPercentString.insert( 0, "\"" );
+ }
+ aPercentString.insert( 0, rInfo.sStrArray[i] );
+ }
+ i = nCnt;
+ if( bStringFound )
+ aPercentString.insert( 0, "\"" );
+ }
+ }
+ return aPercentString.makeStringAndClear();
+}
+
+OUString lcl_GetDenominatorString(const ImpSvNumberformatInfo &rInfo, sal_uInt16 nCnt)
+{
+ sal_Int32 i;
+ OUStringBuffer aDenominatorString;
+ for( i = 0; i < nCnt; i++ )
+ {
+ if( rInfo.nTypeArray[i] == NF_SYMBOLTYPE_FRAC )
+ {
+ while ( ( ++i < nCnt ) && rInfo.nTypeArray[i] != NF_SYMBOLTYPE_FRAC_FDIV
+ && rInfo.nTypeArray[i] != NF_SYMBOLTYPE_DIGIT );
+ for( ; i < nCnt; i++ )
+ {
+ if( rInfo.nTypeArray[i] == NF_SYMBOLTYPE_FRAC_FDIV || rInfo.nTypeArray[i] == NF_SYMBOLTYPE_DIGIT )
+ aDenominatorString.append( rInfo.sStrArray[i] );
+ else
+ i = nCnt;
+ }
+ }
+ }
+ return aDenominatorString.makeStringAndClear();
+}
+
+OUString lcl_GetNumeratorString(const ImpSvNumberformatInfo &rInfo, sal_uInt16 nCnt)
+{
+ sal_Int32 i;
+ OUStringBuffer aNumeratorString;
+ for( i = 0; i < nCnt; i++ )
+ {
+ if( rInfo.nTypeArray[i] == NF_SYMBOLTYPE_FRAC )
+ {
+ for( i--; i >= 0 && rInfo.nTypeArray[i] == NF_SYMBOLTYPE_DIGIT ; i-- )
+ {
+ aNumeratorString.insert( 0, rInfo.sStrArray[i] );
+ }
+ i = nCnt;
+ }
+ }
+ return aNumeratorString.makeStringAndClear();
+}
+
+OUString lcl_GetFractionIntegerString(const ImpSvNumberformatInfo &rInfo, sal_uInt16 nCnt)
+{
+ sal_Int32 i;
+ OUStringBuffer aIntegerString;
+ for( i = 0; i < nCnt; i++ )
+ {
+ if( rInfo.nTypeArray[i] == NF_SYMBOLTYPE_FRACBLANK )
+ {
+ for( i--; i >= 0 && ( rInfo.nTypeArray[i] == NF_SYMBOLTYPE_DIGIT
+ || rInfo.nTypeArray[i] == NF_SYMBOLTYPE_THSEP ); i-- )
+ {
+ aIntegerString.insert( 0, rInfo.sStrArray[i] );
+ }
+ i = nCnt;
+ }
+ }
+ return aIntegerString.makeStringAndClear();
+}
+
+OUString lcl_GetIntegerFractionDelimiterString(const ImpSvNumberformatInfo &rInfo, sal_uInt16 nCnt)
+{
+ sal_uInt16 i;
+ for( i = 0; i < nCnt; i++ )
+ {
+ if( rInfo.nTypeArray[i] == NF_SYMBOLTYPE_FRACBLANK )
+ {
+ return rInfo.sStrArray[i];
+ }
+ }
+ return OUString();
+}
+
+}
+
+OUString SvNumberformat::GetPercentString( sal_uInt16 nNumFor ) const
+{
+ const ImpSvNumberformatInfo& rInfo = NumFor[nNumFor].Info();
+ sal_uInt16 nCnt = NumFor[nNumFor].GetCount();
+ return lcl_GetPercentString( rInfo, nCnt );
+}
+
+OUString SvNumberformat::GetDenominatorString( sal_uInt16 nNumFor ) const
+{
+ const ImpSvNumberformatInfo& rInfo = NumFor[nNumFor].Info();
+ sal_uInt16 nCnt = NumFor[nNumFor].GetCount();
+ return lcl_GetDenominatorString( rInfo, nCnt );
+}
+
+OUString SvNumberformat::GetNumeratorString( sal_uInt16 nNumFor ) const
+{
+ const ImpSvNumberformatInfo& rInfo = NumFor[nNumFor].Info();
+ sal_uInt16 nCnt = NumFor[nNumFor].GetCount();
+ return lcl_GetNumeratorString( rInfo, nCnt );
+}
+
+OUString SvNumberformat::GetIntegerFractionDelimiterString( sal_uInt16 nNumFor ) const
+{
+ const ImpSvNumberformatInfo& rInfo = NumFor[nNumFor].Info();
+ sal_uInt16 nCnt = NumFor[nNumFor].GetCount();
+ return lcl_GetIntegerFractionDelimiterString( rInfo, nCnt );
+}
+
+bool SvNumberformat::GetOutputString(double fNumber, sal_uInt16 nCharCount, OUString& rOutString) const
+{
+ if (eType != SvNumFormatType::NUMBER)
+ {
+ return false;
+ }
+ double fTestNum = fNumber;
+ bool bSign = std::signbit(fTestNum);
+ if (bSign)
+ {
+ fTestNum = -fTestNum;
+ }
+ if (fTestNum < EXP_LOWER_BOUND)
+ {
+ lcl_GetOutputStringScientific(fNumber, nCharCount, GetFormatter(), rOutString);
+ return true;
+ }
+
+ double fExp = log10(fTestNum);
+ // Values < 1.0 always have one digit before the decimal point.
+ sal_uInt16 nDigitPre = fExp >= 0.0 ? static_cast<sal_uInt16>(ceil(fExp)) : 1;
+
+ if (nDigitPre > 15)
+ {
+ lcl_GetOutputStringScientific(fNumber, nCharCount, GetFormatter(), rOutString);
+ return true;
+ }
+
+ sal_uInt16 nPrec = nCharCount >= nDigitPre ? nCharCount - nDigitPre : 0;
+ if (nPrec && bSign)
+ {
+ // Subtract the negative sign.
+ --nPrec;
+ }
+ if (nPrec)
+ {
+ // Subtract the decimal point.
+ --nPrec;
+ }
+ ImpGetOutputStdToPrecision(fNumber, rOutString, nPrec);
+ if (rOutString.getLength() > nCharCount)
+ {
+ // String still wider than desired. Switch to scientific notation.
+ lcl_GetOutputStringScientific(fNumber, nCharCount, GetFormatter(), rOutString);
+ }
+ return true;
+}
+
+sal_uInt16 SvNumberformat::GetSubformatIndex (double fNumber ) const
+{
+ sal_uInt16 nIx; // Index of the partial format
+ double fLimit_1 = fLimit1;
+ short nCheck = ImpCheckCondition(fNumber, fLimit_1, eOp1);
+ if (nCheck == -1 || nCheck == 1) // Only 1 String or True
+ {
+ nIx = 0;
+ }
+ else
+ {
+ double fLimit_2 = fLimit2;
+ nCheck = ImpCheckCondition(fNumber, fLimit_2, eOp2);
+ if (nCheck == -1 || nCheck == 1)
+ {
+ nIx = 1;
+ }
+ else
+ {
+ nIx = 2;
+ }
+ }
+ return nIx;
+}
+
+bool SvNumberformat::GetOutputString(double fNumber,
+ OUString& OutString,
+ const Color** ppColor)
+{
+ bool bRes = false;
+ OutString.clear();
+ *ppColor = nullptr; // No color change
+ if (eType & SvNumFormatType::LOGICAL && sFormatstring == rScan.GetKeywords()[NF_KEY_BOOLEAN])
+ {
+ if (fNumber)
+ {
+ OutString = rScan.GetTrueString();
+ }
+ else
+ {
+ OutString = rScan.GetFalseString();
+ }
+ return false;
+ }
+ OUStringBuffer sBuff(64);
+ if (eType & SvNumFormatType::TEXT)
+ {
+ ImpGetOutputStandard(fNumber, sBuff);
+ OutString = sBuff.makeStringAndClear();
+ return false;
+ }
+ bool bHadStandard = false;
+ if (bStandard) // Individual standard formats
+ {
+ if (rScan.GetStandardPrec() == SvNumberFormatter::INPUTSTRING_PRECISION) // All number format InputLine
+ {
+ ImpGetOutputInputLine(fNumber, OutString);
+ return false;
+ }
+ switch (eType)
+ {
+ case SvNumFormatType::NUMBER: // Standard number format
+ if (rScan.GetStandardPrec() == SvNumberFormatter::UNLIMITED_PRECISION)
+ {
+ if (std::signbit(fNumber))
+ {
+ if (!(fNumber < 0.0))
+ fNumber = -fNumber; // do not display -0.0
+ }
+ if (fNumber == 0.0)
+ {
+ OutString = "0";
+ }
+ else if (fNumber < 1.0 && fNumber > -1.0)
+ {
+ // Decide whether to display as 0.000000123... or 1.23...e-07
+ bool bFix = (fNumber < -EXP_LOWER_BOUND || EXP_LOWER_BOUND < fNumber);
+ if (!bFix)
+ {
+ // Arbitrary, not too many 0s visually, start E2 at 1E-10.
+ constexpr sal_Int32 kMaxExp = 9;
+ const sal_Int32 nExp = static_cast<sal_Int32>(ceil( -log10( fabs( fNumber))));
+ if (nExp <= kMaxExp && rtl::math::approxEqual(
+ rtl::math::round( fNumber, 16), rtl::math::round( fNumber, nExp + 16)))
+ {
+ // Not too many significant digits or accuracy
+ // artefacts, otherwise leave everything to E2
+ // format.
+ bFix = true;
+ }
+ }
+ if (bFix)
+ OutString = ::rtl::math::doubleToUString( fNumber,
+ rtl_math_StringFormat_F,
+ rtl_math_DecimalPlaces_Max,
+ GetFormatter().GetNumDecimalSep()[0], true);
+ else
+ OutString = ::rtl::math::doubleToUString( fNumber,
+ rtl_math_StringFormat_E2,
+ rtl_math_DecimalPlaces_Max,
+ GetFormatter().GetNumDecimalSep()[0], true);
+ }
+ else
+ {
+ OutString = ::rtl::math::doubleToUString( fNumber,
+ rtl_math_StringFormat_Automatic,
+ rtl_math_DecimalPlaces_Max,
+ GetFormatter().GetNumDecimalSep()[0], true);
+ }
+ return false;
+ }
+ ImpGetOutputStandard(fNumber, sBuff);
+ bHadStandard = true;
+ break;
+ case SvNumFormatType::DATE:
+ bRes |= ImpGetDateOutput(fNumber, 0, sBuff);
+ bHadStandard = true;
+ break;
+ case SvNumFormatType::TIME:
+ bRes |= ImpGetTimeOutput(fNumber, 0, sBuff);
+ bHadStandard = true;
+ break;
+ case SvNumFormatType::DATETIME:
+ bRes |= ImpGetDateTimeOutput(fNumber, 0, sBuff);
+ bHadStandard = true;
+ break;
+ default: break;
+ }
+ }
+ if ( !bHadStandard )
+ {
+ sal_uInt16 nIx = GetSubformatIndex ( fNumber ); // Index of the partial format
+ if (fNumber < 0.0 &&
+ ((nIx == 0 && IsFirstSubformatRealNegative()) || // 1st, usually positive subformat
+ (nIx == 1 && IsSecondSubformatRealNegative()))) // 2nd, usually negative subformat
+ {
+ fNumber = -fNumber; // eliminate sign
+ }
+ *ppColor = NumFor[nIx].GetColor();
+ const ImpSvNumberformatInfo& rInfo = NumFor[nIx].Info();
+ const sal_uInt16 nCnt = NumFor[nIx].GetCount();
+ if (nCnt == 0 && rInfo.eScannedType == SvNumFormatType::EMPTY)
+ {
+ return false; // Empty => nothing
+ }
+ else if (nCnt == 0) // Else Standard Format
+ {
+ ImpGetOutputStandard(fNumber, sBuff);
+ OutString = sBuff.makeStringAndClear();
+ return false;
+ }
+ switch (rInfo.eScannedType)
+ {
+ case SvNumFormatType::TEXT:
+ case SvNumFormatType::DEFINED:
+ for (sal_uInt16 i = 0; i < nCnt; i++)
+ {
+ switch (rInfo.nTypeArray[i])
+ {
+ case NF_SYMBOLTYPE_STAR:
+ if( bStarFlag )
+ {
+ bRes = lcl_appendStarFillChar( sBuff, rInfo.sStrArray[i]);
+ }
+ break;
+ case NF_SYMBOLTYPE_BLANK:
+ if (rInfo.sStrArray[i].getLength() >= 2)
+ InsertBlanks(sBuff, sBuff.getLength(), rInfo.sStrArray[i][1] );
+ break;
+ case NF_SYMBOLTYPE_STRING:
+ case NF_SYMBOLTYPE_CURRENCY:
+ sBuff.append(rInfo.sStrArray[i]);
+ break;
+ case NF_SYMBOLTYPE_THSEP:
+ if (rInfo.nThousand == 0)
+ {
+ sBuff.append(rInfo.sStrArray[i]);
+ }
+ break;
+ default:
+ break;
+ }
+ }
+ break;
+ case SvNumFormatType::DATE:
+ bRes |= ImpGetDateOutput(fNumber, nIx, sBuff);
+ break;
+ case SvNumFormatType::TIME:
+ bRes |= ImpGetTimeOutput(fNumber, nIx, sBuff);
+ break;
+ case SvNumFormatType::DATETIME:
+ bRes |= ImpGetDateTimeOutput(fNumber, nIx, sBuff);
+ break;
+ case SvNumFormatType::NUMBER:
+ case SvNumFormatType::PERCENT:
+ case SvNumFormatType::CURRENCY:
+ bRes |= ImpGetNumberOutput(fNumber, nIx, sBuff);
+ break;
+ case SvNumFormatType::LOGICAL:
+ bRes |= ImpGetLogicalOutput(fNumber, nIx, sBuff);
+ break;
+ case SvNumFormatType::FRACTION:
+ bRes |= ImpGetFractionOutput(fNumber, nIx, sBuff);
+ break;
+ case SvNumFormatType::SCIENTIFIC:
+ bRes |= ImpGetScientificOutput(fNumber, nIx, sBuff);
+ break;
+ default: break;
+ }
+ }
+ OutString = sBuff.makeStringAndClear();
+ return bRes;
+}
+
+bool SvNumberformat::ImpGetScientificOutput(double fNumber,
+ sal_uInt16 nIx,
+ OUStringBuffer& sStr)
+{
+ bool bRes = false;
+ bool bSign = false;
+
+ const ImpSvNumberformatInfo& rInfo = NumFor[nIx].Info();
+ const sal_uInt16 nCnt = NumFor[nIx].GetCount();
+
+ if (fNumber < 0)
+ {
+ if (nIx == 0) // Not in the ones at the end
+ {
+ bSign = true; // Formats
+ }
+ fNumber = -fNumber;
+ }
+
+ sStr = ::rtl::math::doubleToUString( fNumber,
+ rtl_math_StringFormat_E,
+ rInfo.nCntPre + rInfo.nCntPost - 1, '.' );
+ OUStringBuffer ExpStr;
+ short nExpSign = 1;
+ sal_Int32 nExPos = sStr.indexOf('E');
+ sal_Int32 nDecPos = -1;
+
+ if ( nExPos >= 0 )
+ {
+ // split into mantissa and exponent and get rid of "E+" or "E-"
+ sal_Int32 nExpStart = nExPos + 1;
+
+ switch ( sStr[ nExpStart ] )
+ {
+ case '-' :
+ nExpSign = -1;
+ [[fallthrough]];
+ case '+' :
+ ++nExpStart;
+ break;
+ }
+ ExpStr = sStr.subView( nExpStart ); // part following the "E+"
+ sStr.truncate( nExPos );
+
+ if ( rInfo.nCntPre != 1 ) // rescale Exp
+ {
+ sal_Int32 nExp = OUString::unacquired(ExpStr).toInt32() * nExpSign;
+ sal_Int32 nRescale = (rInfo.nCntPre != 0) ? nExp % static_cast<sal_Int32>(rInfo.nCntPre) : -1;
+ if( nRescale < 0 && rInfo.nCntPre != 0 )
+ nRescale += static_cast<sal_Int32>(rInfo.nCntPre);
+ nExp -= nRescale;
+ if ( nExp < 0 )
+ {
+ nExpSign = -1;
+ nExp = -nExp;
+ }
+ else
+ {
+ nExpSign = 1;
+ }
+ ExpStr = OUString::number( nExp );
+ const sal_Unicode cFirstDigit = sStr[0];
+ // rescale mantissa
+ sStr = ::rtl::math::doubleToUString( fNumber,
+ rtl_math_StringFormat_E,
+ nRescale + rInfo.nCntPost, '.' );
+
+ // sStr now may contain a rounded-up value shifted into the next
+ // magnitude, for example 1.000E+02 (4 digits) for fNumber 99.995
+ // (9.9995E+02 rounded to 3 decimals) but we want the final result
+ // to be 100.00E+00 (5 digits), so for the following fill routines
+ // below to work correctly append a zero decimal.
+ /* TODO: this is awkward, could an engineering notation mode be
+ * introduced to rtl_math_doubleToUString()? */
+ sStr.truncate( sStr.indexOf('E') );
+ if (sStr[0] == '1' && cFirstDigit != '1')
+ sStr.append('0');
+ }
+
+ // cut any decimal delimiter
+ sal_Int32 index = 0;
+
+ while((index = sStr.indexOf('.', index)) >= 0)
+ {
+ if (nDecPos < 0)
+ nDecPos = index;
+ sStr.remove(index, 1);
+ }
+ }
+
+ sal_uInt16 j = nCnt-1; // Last symbol
+ sal_Int32 k; // Position in ExpStr
+ sal_Int32 nZeros = 0; // Erase leading zeros
+
+ bRes |= ImpNumberFill(ExpStr, fNumber, k, j, nIx, NF_SYMBOLTYPE_EXP);
+
+ while (nZeros < k && ExpStr[nZeros] == '0')
+ {
+ ++nZeros;
+ }
+ if (nZeros)
+ {
+ ExpStr.remove( 0, nZeros);
+ }
+
+ bool bCont = true;
+
+ if (rInfo.nTypeArray[j] == NF_SYMBOLTYPE_EXP)
+ {
+ const OUString& rStr = rInfo.sStrArray[j];
+ if (nExpSign == -1)
+ {
+ ExpStr.insert(0, '-');
+ }
+ else if (rStr.getLength() > 1 && rStr[1] == '+')
+ {
+ ExpStr.insert(0, '+');
+ }
+ ExpStr.insert(0, rStr[0]);
+ if ( j )
+ {
+ j--;
+ }
+ else
+ {
+ bCont = false;
+ }
+ }
+ // Continue main number:
+ if ( !bCont )
+ {
+ sStr.truncate();
+ }
+ else
+ {
+ bRes |= ImpDecimalFill(sStr, fNumber, nDecPos, j, nIx, false);
+ }
+
+ if (bSign)
+ {
+ sStr.insert(0, '-');
+ }
+ sStr.append(ExpStr);
+
+ return bRes;
+}
+
+double SvNumberformat::GetRoundFractionValue ( double fNumber ) const
+{
+ sal_uInt16 nIx = GetSubformatIndex ( fNumber );
+ double fIntPart = 0.0; // integer part of fraction
+ sal_Int64 nFrac = 0, nDiv = 1; // numerator and denominator
+ double fSign = (fNumber < 0.0) ? -1.0 : 1.0;
+ // fNumber is modified in ImpGetFractionElements to absolute fractional part
+ ImpGetFractionElements ( fNumber, nIx, fIntPart, nFrac, nDiv );
+ if ( nDiv > 0 )
+ return fSign * ( fIntPart + static_cast<double>(nFrac) / static_cast<double>(nDiv) );
+ else
+ return fSign * fIntPart;
+}
+
+void SvNumberformat::ImpGetFractionElements ( double& fNumber, sal_uInt16 nIx,
+ double& fIntPart, sal_Int64& nFrac, sal_Int64& nDiv ) const
+{
+ if ( fNumber < 0.0 )
+ fNumber = -fNumber;
+ fIntPart = floor(fNumber); // Integral part
+ fNumber -= fIntPart; // Fractional part
+ const ImpSvNumberformatInfo& rInfo = NumFor[nIx].Info();
+ sal_Int64 nForcedDiv = lcl_GetDenominatorString( rInfo, NumFor[nIx].GetCount() ).toInt32();
+ if( nForcedDiv > 0 )
+ { // Forced Denominator
+ nDiv = nForcedDiv;
+ nFrac = static_cast<sal_Int64>(floor ( fNumber * nDiv ));
+ double fFracNew = static_cast<double>(nFrac) / static_cast<double>(nDiv);
+ double fFracNew1 = static_cast<double>(nFrac + 1) / static_cast<double>(nDiv);
+ double fDiff = fNumber - fFracNew;
+ if( fDiff > ( fFracNew1 - fNumber ) )
+ {
+ nFrac++;
+ }
+ }
+ else // Calculated Denominator
+ {
+ nDiv = 1;
+ sal_Int64 nBasis = static_cast<sal_Int64>(floor( pow(10.0,rInfo.nCntExp))) - 1; // 9, 99, 999 ,...
+ sal_Int64 nFracPrev = 1, nDivPrev = 0, nFracNext, nDivNext, nPartialDenom;
+ double fRemainder = fNumber;
+
+ // Use continued fraction representation of fNumber
+ // See https://en.wikipedia.org/wiki/Continued_fraction#Best_rational_approximations
+ while ( fRemainder > 0.0 )
+ {
+ double fTemp = 1.0 / fRemainder; // 64bits precision required when fRemainder is very weak
+ nPartialDenom = static_cast<sal_Int64>(floor(fTemp)); // due to floating point notation with double precision
+ fRemainder = fTemp - static_cast<double>(nPartialDenom);
+ nDivNext = nPartialDenom * nDiv + nDivPrev;
+ if ( nDivNext <= nBasis ) // continue loop
+ {
+ nFracNext = nPartialDenom * nFrac + nFracPrev;
+ nFracPrev = nFrac;
+ nFrac = nFracNext;
+ nDivPrev = nDiv;
+ nDiv = nDivNext;
+ }
+ else // calculate collateral fraction and exit
+ {
+ sal_Int64 nCollat = (nBasis - nDivPrev) / nDiv;
+ if ( 2 * nCollat >= nPartialDenom )
+ {
+ sal_Int64 nFracTest = nCollat * nFrac + nFracPrev;
+ sal_Int64 nDivTest = nCollat * nDiv + nDivPrev;
+ double fSign = (static_cast<double>(nFrac) > fNumber * static_cast<double>(nDiv))?1.0:-1.0;
+ if ( fSign * ( double(nFrac * nDivTest + nDiv * nFracTest) - 2.0 * double(nDiv * nDivTest) * fNumber ) > 0.0 )
+ {
+ nFrac = nFracTest;
+ nDiv = nDivTest;
+ }
+ }
+ fRemainder = 0.0; // exit while loop
+ }
+ }
+ }
+ if (nFrac >= nDiv)
+ {
+ ++fIntPart;
+ nFrac = 0;
+ nDiv = ( nForcedDiv > 0 ) ? nForcedDiv : 1;
+ }
+}
+
+bool SvNumberformat::ImpGetFractionOutput(double fNumber,
+ sal_uInt16 nIx,
+ OUStringBuffer& sBuff)
+{
+ bool bRes = false;
+ const ImpSvNumberformatInfo& rInfo = NumFor[nIx].Info();
+ const sal_uInt16 nCnt = NumFor[nIx].GetCount();
+ OUStringBuffer sStr, sFrac, sDiv; // Strings, value for Integral part Numerator and denominator
+ bool bSign = ( (fNumber < 0) && (nIx == 0) ); // sign Not in the ones at the end
+ const OUString sIntegerFormat = lcl_GetFractionIntegerString(rInfo, nCnt);
+ const OUString sNumeratorFormat = lcl_GetNumeratorString(rInfo, nCnt);
+ const OUString sDenominatorFormat = lcl_GetDenominatorString(rInfo, nCnt);
+
+ sal_Int64 nFrac = 0, nDiv = 1;
+ double fNum = floor(fNumber); // Integral part
+
+ if (fNum > D_MAX_U_INT32 || rInfo.nCntExp > 9) // Too large
+ {
+ sBuff = ImpSvNumberformatScan::sErrStr;
+ return false;
+ }
+ if (rInfo.nCntExp == 0)
+ {
+ SAL_WARN( "svl.numbers", "SvNumberformat:: Fraction, nCntExp == 0");
+ sBuff.truncate();
+ return false;
+ }
+
+ ImpGetFractionElements( fNumber, nIx, fNum, nFrac, nDiv);
+
+ if (rInfo.nCntPre == 0) // Improper fraction
+ {
+ double fNum1 = fNum * static_cast<double>(nDiv) + static_cast<double>(nFrac);
+
+ if (fNum1 > D_MAX_INTEGER)
+ {
+ sBuff = ImpSvNumberformatScan::sErrStr;
+ return false;
+ }
+ nFrac = static_cast<sal_Int64>(floor(fNum1));
+ }
+ else if (fNum == 0.0 && nFrac != 0)
+ {
+ }
+ else
+ {
+ char aBuf[100];
+ sprintf( aBuf, "%.f", fNum ); // simple rounded integer (#100211# - checked)
+ sStr.appendAscii( aBuf );
+ impTransliterate(sStr, NumFor[nIx].GetNatNum());
+ }
+ bool bHideFraction = (rInfo.nCntPre > 0 && nFrac == 0
+ && (sNumeratorFormat.indexOf('0') < 0)
+ && (sDenominatorFormat.indexOf('0') < 0
+ || sDenominatorFormat.toInt32() > 0) );
+ if ( bHideFraction )
+ {
+ sDiv.truncate();
+ }
+ else // if there are some '0' in format, force display of fraction
+ {
+ sFrac = ImpIntToString( nIx, nFrac );
+ sDiv = ImpIntToString( nIx, nDiv );
+ }
+
+ sal_uInt16 j = nCnt-1; // Last symbol -> backwards
+ sal_Int32 k; // Denominator
+
+ bRes |= ImpNumberFill(sDiv, fNumber, k, j, nIx, NF_SYMBOLTYPE_FRAC, true);
+
+ bool bCont = true;
+ if (rInfo.nTypeArray[j] == NF_SYMBOLTYPE_FRAC)
+ {
+ if ( bHideFraction )
+ { // do not insert blank for fraction if there is no '?'
+ if ( sNumeratorFormat.indexOf('?') >= 0
+ || sDenominatorFormat.indexOf('?') >= 0 )
+ sDiv.insert(0, ' ');
+ }
+ else
+ {
+ sDiv.insert(0, rInfo.sStrArray[j][0]);
+ }
+ if ( j )
+ {
+ j--;
+ }
+ else
+ {
+ bCont = false;
+ }
+ }
+ // Further numerators:
+ if ( !bCont )
+ {
+ sFrac.truncate();
+ }
+ else
+ {
+ bRes |= ImpNumberFill(sFrac, fNumber, k, j, nIx, NF_SYMBOLTYPE_FRACBLANK);
+ bCont = false; // there is no integer part?
+ if (rInfo.nTypeArray[j] == NF_SYMBOLTYPE_FRACBLANK)
+ {
+ if ( j )
+ {
+ if ( bHideFraction )
+ { // '?' in any format force display of blank as delimiter
+ if ( sIntegerFormat.indexOf('?') >= 0
+ || sNumeratorFormat.indexOf('?') >= 0
+ || sDenominatorFormat.indexOf('?') >= 0 )
+ {
+ for (sal_Int32 i = 0; i < rInfo.sStrArray[j].getLength(); i++)
+ sFrac.insert(0, ' ');
+ }
+ }
+ else
+ {
+ if ( fNum != 0.0 || sIntegerFormat.indexOf('0') >= 0 )
+ sFrac.insert(0, rInfo.sStrArray[j]); // insert Blank string only if there are both integer and fraction
+ else
+ {
+ if ( sIntegerFormat.indexOf('?') >= 0
+ || sNumeratorFormat.indexOf('?') >= 0 )
+ {
+ for (sal_Int32 i = 0; i < rInfo.sStrArray[j].getLength(); i++)
+ sFrac.insert(0, ' ');
+ }
+ }
+ }
+ j--;
+ bCont = true; // Yes, there is an integer
+ }
+ else
+ sFrac.insert(0, rInfo.sStrArray[j]);
+ }
+ }
+ // Continue integer part
+ if ( !bCont )
+ {
+ sStr.truncate();
+ }
+ else
+ {
+ k = sStr.getLength(); // After last figure
+ bRes |= ImpNumberFillWithThousands(sStr, fNumber, k, j, nIx,
+ rInfo.nCntPre);
+ }
+ if (bSign && (nFrac != 0 || fNum != 0.0))
+ {
+ sBuff.insert(0, '-'); // Not -0
+ }
+ sBuff.append(sStr);
+ sBuff.append(sFrac);
+ sBuff.append(sDiv);
+ return bRes;
+}
+
+sal_uInt16 SvNumberformat::ImpGetFractionOfSecondString( OUStringBuffer& rBuf, double fFractionOfSecond,
+ int nFractionDecimals, bool bAddOneRoundingDecimal, sal_uInt16 nIx, sal_uInt16 nMinimumInputLineDecimals )
+{
+ if (!nFractionDecimals)
+ return 0;
+
+ // nFractionDecimals+1 to not round up what Time::GetClock() carefully
+ // truncated.
+ rBuf.append( rtl::math::doubleToUString( fFractionOfSecond, rtl_math_StringFormat_F,
+ (bAddOneRoundingDecimal ? nFractionDecimals + 1 : nFractionDecimals), '.'));
+ rBuf.stripStart('0');
+ rBuf.stripStart('.');
+ if (bAddOneRoundingDecimal && rBuf.getLength() > nFractionDecimals)
+ rBuf.truncate( nFractionDecimals); // the digit appended because of nFractionDecimals+1
+ if (nMinimumInputLineDecimals)
+ {
+ rBuf.stripEnd('0');
+ for (sal_Int32 index = rBuf.getLength(); index < nMinimumInputLineDecimals; ++index)
+ {
+ rBuf.append('0');
+ }
+ impTransliterate(rBuf, NumFor[nIx].GetNatNum());
+ nFractionDecimals = rBuf.getLength();
+ }
+ else
+ {
+ impTransliterate(rBuf, NumFor[nIx].GetNatNum());
+ }
+ return static_cast<sal_uInt16>(nFractionDecimals);
+}
+
+bool SvNumberformat::ImpGetTimeOutput(double fNumber,
+ sal_uInt16 nIx,
+ OUStringBuffer& sBuff)
+{
+ using namespace ::com::sun::star::i18n;
+ bool bCalendarSet = false;
+ const double fNumberOrig = fNumber;
+ bool bRes = false;
+ bool bSign = false;
+ if (fNumber < 0.0)
+ {
+ fNumber = -fNumber;
+ if (nIx == 0)
+ {
+ bSign = true;
+ }
+ }
+ const ImpSvNumberformatInfo& rInfo = NumFor[nIx].Info();
+ bool bInputLine;
+ sal_Int32 nCntPost;
+ if ( rScan.GetStandardPrec() == SvNumberFormatter::INPUTSTRING_PRECISION &&
+ 0 < rInfo.nCntPost && rInfo.nCntPost < 7 )
+ { // round at 7 decimals (+5 of 86400 == 12 significant digits)
+ bInputLine = true;
+ nCntPost = 7;
+ }
+ else
+ {
+ bInputLine = false;
+ nCntPost = rInfo.nCntPost;
+ }
+
+ OUStringBuffer sSecStr;
+ sal_Int32 nSecPos = 0; // For figure by figure processing
+ sal_uInt32 nHour, nMin, nSec;
+ if (!rInfo.bThousand) // No [] format
+ {
+ sal_uInt16 nCHour, nCMinute, nCSecond;
+ double fFractionOfSecond;
+ tools::Time::GetClock( fNumberOrig, nCHour, nCMinute, nCSecond, fFractionOfSecond, nCntPost);
+ nHour = nCHour;
+ nMin = nCMinute;
+ nSec = nCSecond;
+ nCntPost = ImpGetFractionOfSecondString( sSecStr, fFractionOfSecond, nCntPost, true, nIx,
+ (bInputLine ? rInfo.nCntPost : 0));
+ }
+ else
+ {
+ const double fTime = rtl::math::round( fNumber * 86400.0, int(nCntPost));
+ if (bSign && fTime == 0.0)
+ {
+ bSign = false; // Not -00:00:00
+ }
+ if (fTime > D_MAX_U_INT32)
+ {
+ sBuff = ImpSvNumberformatScan::sErrStr;
+ return false;
+ }
+ sal_uInt32 nSeconds = static_cast<sal_uInt32>(fTime);
+
+ nCntPost = ImpGetFractionOfSecondString( sSecStr, fTime - nSeconds, nCntPost, false, nIx,
+ (bInputLine ? rInfo.nCntPost : 0));
+
+ if (rInfo.nThousand == 3) // [ss]
+ {
+ nHour = 0;
+ nMin = 0;
+ nSec = nSeconds;
+ }
+ else if (rInfo.nThousand == 2) // [mm]:ss
+ {
+ nHour = 0;
+ nMin = nSeconds / 60;
+ nSec = nSeconds % 60;
+ }
+ else if (rInfo.nThousand == 1) // [hh]:mm:ss
+ {
+ nHour = nSeconds / 3600;
+ nMin = (nSeconds%3600) / 60;
+ nSec = nSeconds%60;
+ }
+ else
+ {
+ // TODO What should these be set to?
+ nHour = 0;
+ nMin = 0;
+ nSec = 0;
+ }
+ }
+
+ sal_Unicode cAmPm = ' '; // a or p
+ if (rInfo.nCntExp) // AM/PM
+ {
+ if (nHour == 0)
+ {
+ nHour = 12;
+ cAmPm = 'a';
+ }
+ else if (nHour < 12)
+ {
+ cAmPm = 'a';
+ }
+ else
+ {
+ cAmPm = 'p';
+ if (nHour > 12)
+ {
+ nHour -= 12;
+ }
+ }
+ }
+ const sal_uInt16 nCnt = NumFor[nIx].GetCount();
+ for (sal_uInt16 i = 0; i < nCnt; i++)
+ {
+ sal_Int32 nLen;
+ switch (rInfo.nTypeArray[i])
+ {
+ case NF_SYMBOLTYPE_STAR:
+ if( bStarFlag )
+ {
+ bRes = lcl_appendStarFillChar( sBuff, rInfo.sStrArray[i]);
+ }
+ break;
+ case NF_SYMBOLTYPE_BLANK:
+ if (rInfo.sStrArray[i].getLength() >= 2)
+ InsertBlanks(sBuff, sBuff.getLength(), rInfo.sStrArray[i][1] );
+ break;
+ case NF_SYMBOLTYPE_STRING:
+ case NF_SYMBOLTYPE_CURRENCY:
+ case NF_SYMBOLTYPE_DATESEP:
+ case NF_SYMBOLTYPE_TIMESEP:
+ case NF_SYMBOLTYPE_TIME100SECSEP:
+ sBuff.append(rInfo.sStrArray[i]);
+ break;
+ case NF_SYMBOLTYPE_DIGIT:
+ nLen = ( bInputLine && i > 0 &&
+ (rInfo.nTypeArray[i-1] == NF_SYMBOLTYPE_STRING ||
+ rInfo.nTypeArray[i-1] == NF_SYMBOLTYPE_TIME100SECSEP) ?
+ nCntPost : rInfo.sStrArray[i].getLength() );
+ for (sal_Int32 j = 0; j < nLen && nSecPos < nCntPost && nSecPos < sSecStr.getLength(); ++j)
+ {
+ sBuff.append(sSecStr[nSecPos]);
+ nSecPos++;
+ }
+ break;
+ case NF_KEY_AMPM: // AM/PM
+ if ( !bCalendarSet )
+ {
+ double fDiff = DateTime(rScan.GetNullDate()) - GetCal().getEpochStart();
+ fDiff += fNumberOrig;
+ GetCal().setLocalDateTime( fDiff );
+ bCalendarSet = true;
+ }
+ if (cAmPm == 'a')
+ {
+ sBuff.append(GetCal().getDisplayName(
+ CalendarDisplayIndex::AM_PM, AmPmValue::AM, 0 ));
+ }
+ else
+ {
+ sBuff.append(GetCal().getDisplayName(
+ CalendarDisplayIndex::AM_PM, AmPmValue::PM, 0 ));
+ }
+ break;
+ case NF_KEY_AP: // A/P
+ if (cAmPm == 'a')
+ {
+ sBuff.append('a');
+ }
+ else
+ {
+ sBuff.append('p');
+ }
+ break;
+ case NF_KEY_MI: // M
+ sBuff.append(ImpIntToString( nIx, nMin ));
+ break;
+ case NF_KEY_MMI: // MM
+ sBuff.append(ImpIntToString( nIx, nMin, 2 ));
+ break;
+ case NF_KEY_H: // H
+ sBuff.append(ImpIntToString( nIx, nHour ));
+ break;
+ case NF_KEY_HH: // HH
+ sBuff.append(ImpIntToString( nIx, nHour, 2 ));
+ break;
+ case NF_KEY_S: // S
+ sBuff.append(ImpIntToString( nIx, nSec ));
+ break;
+ case NF_KEY_SS: // SS
+ sBuff.append(ImpIntToString( nIx, nSec, 2 ));
+ break;
+ default:
+ break;
+ }
+ }
+ if (bSign && rInfo.bThousand)
+ {
+ sBuff.insert(0, '-');
+ }
+ return bRes;
+}
+
+
+/** If a day of month occurs within the format, the month name is in possessive
+ genitive case if the day follows the month, and partitive case if the day
+ precedes the month. If there is no day of month the nominative case (noun)
+ is returned. Also if the month is immediately preceded or followed by a
+ literal string other than space and not followed by a comma, the nominative
+ name is used, this prevents duplicated casing for MMMM\t\a and such in
+ documents imported from (e.g. Finnish) Excel or older LibO/OOo releases.
+ */
+
+// IDEA: instead of eCodeType pass the index to nTypeArray and restrict
+// inspection of month name around that one, that would enable different month
+// cases in one format. Though probably the most rare use case ever...
+
+sal_Int32 SvNumberformat::ImpUseMonthCase( int & io_nState, const ImpSvNumFor& rNumFor, NfKeywordIndex eCodeType )
+{
+ using namespace ::com::sun::star::i18n;
+ if (!io_nState)
+ {
+ bool bMonthSeen = false;
+ bool bDaySeen = false;
+ const ImpSvNumberformatInfo& rInfo = rNumFor.Info();
+ const sal_uInt16 nCount = rNumFor.GetCount();
+ for (sal_uInt16 i = 0; i < nCount && io_nState == 0; ++i)
+ {
+ sal_Int32 nLen;
+ switch (rInfo.nTypeArray[i])
+ {
+ case NF_KEY_D :
+ case NF_KEY_DD :
+ if (bMonthSeen)
+ {
+ io_nState = 2;
+ }
+ else
+ {
+ bDaySeen = true;
+ }
+ break;
+ case NF_KEY_MMM:
+ case NF_KEY_MMMM:
+ case NF_KEY_MMMMM:
+ if ((i < nCount-1 &&
+ rInfo.nTypeArray[i+1] == NF_SYMBOLTYPE_STRING &&
+ // Literal following, not empty, space nor comma.
+ !rInfo.sStrArray[i+1].isEmpty() &&
+ rInfo.sStrArray[i+1][0] != ' ' && rInfo.sStrArray[i+1][0] != ',') ||
+ (i > 0 && rInfo.nTypeArray[i-1] == NF_SYMBOLTYPE_STRING &&
+ ((nLen = rInfo.sStrArray[i-1].getLength()) > 0) &&
+ // Literal preceding, not space.
+ rInfo.sStrArray[i-1][nLen-1] != ' '))
+ {
+ io_nState = 1;
+ }
+ else if (bDaySeen)
+ {
+ io_nState = 3;
+ }
+ else
+ {
+ bMonthSeen = true;
+ }
+ break;
+ }
+ }
+ if (io_nState == 0)
+ {
+ io_nState = 1; // No day of month
+ }
+ }
+ switch (io_nState)
+ {
+ case 1:
+ // No day of month or forced nominative
+ switch (eCodeType)
+ {
+ case NF_KEY_MMM:
+ return CalendarDisplayCode::SHORT_MONTH_NAME;
+ case NF_KEY_MMMM:
+ return CalendarDisplayCode::LONG_MONTH_NAME;
+ case NF_KEY_MMMMM:
+ return CalendarDisplayCode::NARROW_MONTH_NAME;
+ default:
+ ; // nothing
+ }
+ break;
+ case 2:
+ // Day of month follows month (the month's 17th)
+ switch (eCodeType)
+ {
+ case NF_KEY_MMM:
+ return CalendarDisplayCode::SHORT_GENITIVE_MONTH_NAME;
+ case NF_KEY_MMMM:
+ return CalendarDisplayCode::LONG_GENITIVE_MONTH_NAME;
+ case NF_KEY_MMMMM:
+ return CalendarDisplayCode::NARROW_GENITIVE_MONTH_NAME;
+ default:
+ ; // Nothing
+ }
+ break;
+ case 3:
+ // Day of month precedes month (17 of month)
+ switch (eCodeType)
+ {
+ case NF_KEY_MMM:
+ return CalendarDisplayCode::SHORT_PARTITIVE_MONTH_NAME;
+ case NF_KEY_MMMM:
+ return CalendarDisplayCode::LONG_PARTITIVE_MONTH_NAME;
+ case NF_KEY_MMMMM:
+ return CalendarDisplayCode::NARROW_PARTITIVE_MONTH_NAME;
+ default:
+ ; // nothing
+ }
+ break;
+ }
+ SAL_WARN( "svl.numbers", "ImpUseMonthCase: unhandled keyword index eCodeType");
+ return CalendarDisplayCode::LONG_MONTH_NAME;
+}
+
+
+bool SvNumberformat::ImpIsOtherCalendar( const ImpSvNumFor& rNumFor ) const
+{
+ if ( GetCal().getUniqueID() != GREGORIAN )
+ {
+ return false;
+ }
+ const ImpSvNumberformatInfo& rInfo = rNumFor.Info();
+ const sal_uInt16 nCnt = rNumFor.GetCount();
+ sal_uInt16 i;
+ for ( i = 0; i < nCnt; i++ )
+ {
+ switch ( rInfo.nTypeArray[i] )
+ {
+ case NF_SYMBOLTYPE_CALENDAR :
+ return false;
+ case NF_KEY_EC :
+ case NF_KEY_EEC :
+ case NF_KEY_R :
+ case NF_KEY_RR :
+ case NF_KEY_AAA :
+ case NF_KEY_AAAA :
+ case NF_KEY_G :
+ case NF_KEY_GG :
+ case NF_KEY_GGG :
+ return true;
+ }
+ }
+ return false;
+}
+
+void SvNumberformat::SwitchToOtherCalendar( OUString& rOrgCalendar,
+ double& fOrgDateTime ) const
+{
+ CalendarWrapper& rCal = GetCal();
+ if ( rCal.getUniqueID() != GREGORIAN )
+ return;
+
+ using namespace ::com::sun::star::i18n;
+ const css::uno::Sequence< OUString > xCals = rCal.getAllCalendars(
+ rLoc().getLanguageTag().getLocale() );
+ sal_Int32 nCnt = xCals.getLength();
+ if ( nCnt <= 1 )
+ return;
+
+ auto pCal = std::find_if(xCals.begin(), xCals.end(),
+ [](const OUString& rCalName) { return rCalName != GREGORIAN; });
+ if (pCal == xCals.end())
+ return;
+
+ if ( !rOrgCalendar.getLength() )
+ {
+ rOrgCalendar = rCal.getUniqueID();
+ fOrgDateTime = rCal.getDateTime();
+ }
+ rCal.loadCalendar( *pCal, rLoc().getLanguageTag().getLocale() );
+ rCal.setDateTime( fOrgDateTime );
+}
+
+void SvNumberformat::SwitchToGregorianCalendar( const OUString& rOrgCalendar,
+ double fOrgDateTime ) const
+{
+ CalendarWrapper& rCal = GetCal();
+ if ( rOrgCalendar.getLength() && rCal.getUniqueID() != GREGORIAN )
+ {
+ rCal.loadCalendar( GREGORIAN, rLoc().getLanguageTag().getLocale() );
+ rCal.setDateTime( fOrgDateTime );
+ }
+}
+
+bool SvNumberformat::ImpFallBackToGregorianCalendar( OUString& rOrgCalendar, double& fOrgDateTime )
+{
+ using namespace ::com::sun::star::i18n;
+ CalendarWrapper& rCal = GetCal();
+ if ( rCal.getUniqueID() != GREGORIAN )
+ {
+ sal_Int16 nVal = rCal.getValue( CalendarFieldIndex::ERA );
+ if ( nVal == 0 && rCal.getLoadedCalendar().Eras[0].ID == "Dummy" )
+ {
+ if ( !rOrgCalendar.getLength() )
+ {
+ rOrgCalendar = rCal.getUniqueID();
+ fOrgDateTime = rCal.getDateTime();
+ }
+ else if ( rOrgCalendar == GREGORIAN )
+ {
+ rOrgCalendar.clear();
+ }
+ rCal.loadCalendar( GREGORIAN, rLoc().getLanguageTag().getLocale() );
+ rCal.setDateTime( fOrgDateTime );
+ return true;
+ }
+ }
+ return false;
+}
+
+
+#ifdef THE_FUTURE
+/* XXX NOTE: even if the ImpSwitchToSpecifiedCalendar method is currently
+ * unused please don't remove it, it would be needed by
+ * SwitchToSpecifiedCalendar(), see comment in
+ * ImpSvNumberInputScan::GetDateRef() */
+
+bool SvNumberformat::ImpSwitchToSpecifiedCalendar( OUString& rOrgCalendar,
+ double& fOrgDateTime,
+ const ImpSvNumFor& rNumFor ) const
+{
+ const ImpSvNumberformatInfo& rInfo = rNumFor.Info();
+ const sal_uInt16 nCnt = rNumFor.GetCount();
+ for ( sal_uInt16 i = 0; i < nCnt; i++ )
+ {
+ if ( rInfo.nTypeArray[i] == NF_SYMBOLTYPE_CALENDAR )
+ {
+ CalendarWrapper& rCal = GetCal();
+ if ( !rOrgCalendar.getLength() )
+ {
+ rOrgCalendar = rCal.getUniqueID();
+ fOrgDateTime = rCal.getDateTime();
+ }
+ rCal.loadCalendar( rInfo.sStrArray[i], rLoc().getLocale() );
+ rCal.setDateTime( fOrgDateTime );
+ return true;
+ }
+ }
+ return false;
+}
+#endif
+
+// static
+void SvNumberformat::ImpAppendEraG( OUStringBuffer& OutString,
+ const CalendarWrapper& rCal,
+ sal_Int16 nNatNum )
+{
+ using namespace ::com::sun::star::i18n;
+ if ( rCal.getUniqueID() == "gengou" )
+ {
+ sal_Unicode cEra;
+ sal_Int16 nVal = rCal.getValue( CalendarFieldIndex::ERA );
+ switch ( nVal )
+ {
+ case 1:
+ cEra = 'M';
+ break;
+ case 2:
+ cEra = 'T';
+ break;
+ case 3:
+ cEra = 'S';
+ break;
+ case 4:
+ cEra = 'H';
+ break;
+ case 5:
+ cEra = 'R';
+ break;
+ default:
+ cEra = '?';
+ break;
+ }
+ OutString.append(cEra);
+ }
+ else
+ {
+ OutString.append(rCal.getDisplayString( CalendarDisplayCode::SHORT_ERA, nNatNum ));
+ }
+}
+
+bool SvNumberformat::ImpIsIso8601( const ImpSvNumFor& rNumFor ) const
+{
+ bool bIsIso = false;
+ if (eType & SvNumFormatType::DATE)
+ {
+ enum State
+ {
+ eNone,
+ eAtYear,
+ eAtSep1,
+ eAtMonth,
+ eAtSep2,
+ eNotIso
+ };
+ State eState = eNone;
+ auto & rTypeArray = rNumFor.Info().nTypeArray;
+ sal_uInt16 nCnt = rNumFor.GetCount();
+ for (sal_uInt16 i=0; i < nCnt && !bIsIso && eState != eNotIso; ++i)
+ {
+ switch ( rTypeArray[i] )
+ {
+ case NF_KEY_YY: // two digits not strictly ISO 8601
+ case NF_KEY_YYYY:
+ if (eState != eNone)
+ {
+ eState = eNotIso;
+ }
+ else
+ {
+ eState = eAtYear;
+ }
+ break;
+ case NF_KEY_M: // single digit not strictly ISO 8601
+ case NF_KEY_MM:
+ if (eState != eAtSep1)
+ {
+ eState = eNotIso;
+ }
+ else
+ {
+ eState = eAtMonth;
+ }
+ break;
+ case NF_KEY_D: // single digit not strictly ISO 8601
+ case NF_KEY_DD:
+ if (eState != eAtSep2)
+ {
+ eState = eNotIso;
+ }
+ else
+ {
+ bIsIso = true;
+ }
+ break;
+ case NF_SYMBOLTYPE_STRING:
+ case NF_SYMBOLTYPE_DATESEP:
+ if (rNumFor.Info().sStrArray[i] == "-")
+ {
+ if (eState == eAtYear)
+ {
+ eState = eAtSep1;
+ }
+ else if (eState == eAtMonth)
+ {
+ eState = eAtSep2;
+ }
+ else
+ {
+ eState = eNotIso;
+ }
+ }
+ else
+ {
+ eState = eNotIso;
+ }
+ break;
+ default:
+ eState = eNotIso;
+ }
+ }
+ }
+ else
+ {
+ SAL_WARN( "svl.numbers", "SvNumberformat::ImpIsIso8601: no date" );
+ }
+ return bIsIso;
+}
+
+static bool lcl_hasEra( const ImpSvNumFor& rNumFor )
+{
+ const ImpSvNumberformatInfo& rInfo = rNumFor.Info();
+ const sal_uInt16 nCnt = rNumFor.GetCount();
+ for ( sal_uInt16 i = 0; i < nCnt; i++ )
+ {
+ switch ( rInfo.nTypeArray[i] )
+ {
+ case NF_KEY_RR :
+ case NF_KEY_G :
+ case NF_KEY_GG :
+ case NF_KEY_GGG :
+ return true;
+ }
+ }
+ return false;
+}
+
+static bool lcl_isSignedYear( const CalendarWrapper& rCal, const ImpSvNumFor& rNumFor )
+{
+ return rCal.getValue( css::i18n::CalendarFieldIndex::ERA ) == 0 &&
+ rCal.getUniqueID() == GREGORIAN && !lcl_hasEra( rNumFor );
+}
+
+/* XXX: if needed this could be stripped from rEpochStart and diff adding and
+ * moved to tools' DateTime to be reused elsewhere. */
+static bool lcl_getValidDate( const DateTime& rNullDate, const DateTime& rEpochStart, double& fNumber )
+{
+ static const DateTime aCE( Date(1,1,1));
+ static const DateTime aMin( Date(1,1, SAL_MIN_INT16));
+ static const DateTime aMax( Date(31,12, SAL_MAX_INT16), tools::Time(23,59,59, tools::Time::nanoSecPerSec - 1));
+ static const double fMin = aMin - aCE;
+ static const double fMax = aMax - aCE;
+ // Value must be representable in our tools::Date proleptic Gregorian
+ // calendar as well.
+ const double fOff = (rNullDate - aCE) + fNumber;
+ // Add diff between epochs to serial date number.
+ const double fDiff = rNullDate - rEpochStart;
+ fNumber += fDiff;
+ return fMin <= fOff && fOff <= fMax;
+}
+
+bool SvNumberformat::ImpGetDateOutput(double fNumber,
+ sal_uInt16 nIx,
+ OUStringBuffer& sBuff)
+{
+ using namespace ::com::sun::star::i18n;
+ bool bRes = false;
+
+ CalendarWrapper& rCal = GetCal();
+ if (!lcl_getValidDate( rScan.GetNullDate(), rCal.getEpochStart(), fNumber))
+ {
+ sBuff = ImpSvNumberformatScan::sErrStr;
+ return false;
+ }
+ rCal.setLocalDateTime( fNumber );
+ int nUseMonthCase = 0; // Not decided yet
+ OUString aOrgCalendar; // empty => not changed yet
+
+ double fOrgDateTime(0.0);
+ bool bOtherCalendar = ImpIsOtherCalendar( NumFor[nIx] );
+ if ( bOtherCalendar )
+ {
+ SwitchToOtherCalendar( aOrgCalendar, fOrgDateTime );
+ }
+ if ( ImpFallBackToGregorianCalendar( aOrgCalendar, fOrgDateTime ) )
+ {
+ bOtherCalendar = false;
+ }
+ const ImpSvNumberformatInfo& rInfo = NumFor[nIx].Info();
+ const sal_uInt16 nCnt = NumFor[nIx].GetCount();
+ sal_Int16 nNatNum = NumFor[nIx].GetNatNum().GetNatNum();
+ OUString aStr;
+
+ // NatNum12: if the date format contains more than a date
+ // field, it needs to specify in NatNum12 argument
+ // which date element needs special formatting:
+ //
+ // '[NatNum12 ordinal-number]D' -> "1st"
+ // '[NatNum12 D=ordinal-number]D" of "MMMM' -> "1st of April"
+ // '[NatNum12 D=ordinal]D" of "MMMM' -> "first of April"
+ // '[NatNum12 YYYY=year,D=ordinal]D" of "MMMM", "YYYY' -> "first of April, nineteen ninety"
+ //
+ // Note: set only for YYYY, MMMM, M, DDDD, D and NNN/AAAA in date formats.
+ // Additionally for MMMMM, MMM, DDD and NN/AA to support at least
+ // capitalize, upper, lower, title.
+ // XXX It's possible to extend this for other keywords and date + time
+ // combinations, as required.
+
+ bool bUseSpellout = NatNumTakesParameters(nNatNum) &&
+ (nCnt == 1 || NumFor[nIx].GetNatNum().GetParams().indexOf('=') > -1);
+
+ for (sal_uInt16 i = 0; i < nCnt; i++)
+ {
+ switch (rInfo.nTypeArray[i])
+ {
+ case NF_SYMBOLTYPE_CALENDAR :
+ if ( !aOrgCalendar.getLength() )
+ {
+ aOrgCalendar = rCal.getUniqueID();
+ fOrgDateTime = rCal.getDateTime();
+ }
+ rCal.loadCalendar( rInfo.sStrArray[i], rLoc().getLanguageTag().getLocale() );
+ rCal.setDateTime( fOrgDateTime );
+ ImpFallBackToGregorianCalendar( aOrgCalendar, fOrgDateTime );
+ break;
+ case NF_SYMBOLTYPE_STAR:
+ if( bStarFlag )
+ {
+ bRes = lcl_appendStarFillChar( sBuff, rInfo.sStrArray[i]);
+ }
+ break;
+ case NF_SYMBOLTYPE_BLANK:
+ if (rInfo.sStrArray[i].getLength() >= 2)
+ InsertBlanks( sBuff, sBuff.getLength(), rInfo.sStrArray[i][1] );
+ break;
+ case NF_SYMBOLTYPE_STRING:
+ case NF_SYMBOLTYPE_CURRENCY:
+ case NF_SYMBOLTYPE_DATESEP:
+ case NF_SYMBOLTYPE_TIMESEP:
+ case NF_SYMBOLTYPE_TIME100SECSEP:
+ sBuff.append(rInfo.sStrArray[i]);
+ break;
+ case NF_KEY_M: // M
+ aStr = rCal.getDisplayString( CalendarDisplayCode::SHORT_MONTH, nNatNum );
+ // NatNum12: support variants of preposition, suffixation or article
+ // for example, Catalan "de març", but "d'abril" etc.
+ if ( bUseSpellout )
+ {
+ aStr = impTransliterate(aStr, NumFor[nIx].GetNatNum(), rInfo.nTypeArray[i]);
+ }
+ sBuff.append(aStr);
+ break;
+ case NF_KEY_MM: // MM
+ sBuff.append(rCal.getDisplayString( CalendarDisplayCode::LONG_MONTH, nNatNum ));
+ break;
+ case NF_KEY_MMM: // MMM
+ case NF_KEY_MMMM: // MMMM
+ case NF_KEY_MMMMM: // MMMMM
+ // NatNum12: support variants of preposition, suffixation or
+ // article, or capitalize, upper, lower, title.
+ // Note: result of the "spell out" conversion can depend from the optional
+ // PartitiveMonths or GenitiveMonths defined in the locale data,
+ // see description of ImpUseMonthCase(), and locale data in
+ // i18npool/source/localedata/data/ and libnumbertext
+ aStr = rCal.getDisplayString( ImpUseMonthCase( nUseMonthCase, NumFor[nIx],
+ static_cast<NfKeywordIndex>(rInfo.nTypeArray[i])),
+ nNatNum);
+ if ( bUseSpellout )
+ {
+ aStr = impTransliterate(aStr, NumFor[nIx].GetNatNum(), rInfo.nTypeArray[i]);
+ }
+ sBuff.append(aStr);
+ break;
+ case NF_KEY_Q: // Q
+ sBuff.append(rCal.getDisplayString( CalendarDisplayCode::SHORT_QUARTER, nNatNum ));
+ break;
+ case NF_KEY_QQ: // QQ
+ sBuff.append(rCal.getDisplayString( CalendarDisplayCode::LONG_QUARTER, nNatNum ));
+ break;
+ case NF_KEY_D: // D
+ aStr = rCal.getDisplayString( CalendarDisplayCode::SHORT_DAY, nNatNum );
+ // NatNum12: support variants of preposition, suffixation or article
+ if ( bUseSpellout )
+ {
+ aStr = impTransliterate(aStr, NumFor[nIx].GetNatNum(), rInfo.nTypeArray[i]);
+ }
+ sBuff.append(aStr);
+ break;
+ case NF_KEY_DD: // DD
+ sBuff.append(rCal.getDisplayString( CalendarDisplayCode::LONG_DAY, nNatNum ));
+ break;
+ case NF_KEY_DDD: // DDD
+ if ( bOtherCalendar )
+ {
+ SwitchToGregorianCalendar( aOrgCalendar, fOrgDateTime );
+ }
+ aStr = rCal.getDisplayString( CalendarDisplayCode::SHORT_DAY_NAME, nNatNum );
+ // NatNum12: support at least capitalize, upper, lower, title
+ if ( bUseSpellout )
+ {
+ aStr = impTransliterate(aStr, NumFor[nIx].GetNatNum(), rInfo.nTypeArray[i]);
+ }
+ sBuff.append(aStr);
+ if ( bOtherCalendar )
+ {
+ SwitchToOtherCalendar( aOrgCalendar, fOrgDateTime );
+ }
+ break;
+ case NF_KEY_DDDD: // DDDD
+ if ( bOtherCalendar )
+ {
+ SwitchToGregorianCalendar( aOrgCalendar, fOrgDateTime );
+ }
+ aStr = rCal.getDisplayString( CalendarDisplayCode::LONG_DAY_NAME, nNatNum );
+ // NatNum12: support variants of preposition, suffixation or article
+ if ( bUseSpellout )
+ {
+ aStr = impTransliterate(aStr, NumFor[nIx].GetNatNum(), rInfo.nTypeArray[i]);
+ }
+ sBuff.append(aStr);
+ if ( bOtherCalendar )
+ {
+ SwitchToOtherCalendar( aOrgCalendar, fOrgDateTime );
+ }
+ break;
+ case NF_KEY_YY: // YY
+ if ( bOtherCalendar )
+ {
+ SwitchToGregorianCalendar( aOrgCalendar, fOrgDateTime );
+ }
+ // Prepend a minus sign if Gregorian BCE and era is not displayed.
+ if (lcl_isSignedYear( rCal, NumFor[nIx] ))
+ {
+ sBuff.append('-');
+ }
+ sBuff.append(rCal.getDisplayString( CalendarDisplayCode::SHORT_YEAR, nNatNum ));
+ if ( bOtherCalendar )
+ {
+ SwitchToOtherCalendar( aOrgCalendar, fOrgDateTime );
+ }
+ break;
+ case NF_KEY_YYYY: // YYYY
+ if ( bOtherCalendar )
+ {
+ SwitchToGregorianCalendar( aOrgCalendar, fOrgDateTime );
+ }
+ // Prepend a minus sign if Gregorian BCE and era is not displayed.
+ if (lcl_isSignedYear( rCal, NumFor[nIx] ))
+ {
+ sBuff.append('-');
+ }
+ aStr = rCal.getDisplayString( CalendarDisplayCode::LONG_YEAR, nNatNum );
+ if (aStr.getLength() < 4 && !lcl_hasEra(NumFor[nIx]))
+ {
+ using namespace comphelper::string;
+ // Ensure that year consists of at least 4 digits, so it
+ // can be distinguished from 2 digits display and edited
+ // without suddenly being hit by the 2-digit year magic.
+ OUStringBuffer aBuf;
+ padToLength(aBuf, 4 - aStr.getLength(), '0');
+ impTransliterate(aBuf, NumFor[nIx].GetNatNum());
+ aBuf.append(aStr);
+ aStr = aBuf.makeStringAndClear();
+ }
+ // NatNum12: support variants of preposition, suffixation or article
+ if ( bUseSpellout )
+ {
+ aStr = impTransliterate(aStr, NumFor[nIx].GetNatNum(), rInfo.nTypeArray[i]);
+ }
+ sBuff.append(aStr);
+ if ( bOtherCalendar )
+ {
+ SwitchToOtherCalendar( aOrgCalendar, fOrgDateTime );
+ }
+ break;
+ case NF_KEY_EC: // E
+ sBuff.append(rCal.getDisplayString( CalendarDisplayCode::SHORT_YEAR, nNatNum ));
+ break;
+ case NF_KEY_EEC: // EE
+ case NF_KEY_R: // R
+ sBuff.append(rCal.getDisplayString( CalendarDisplayCode::LONG_YEAR, nNatNum ));
+ break;
+ case NF_KEY_NN: // NN
+ case NF_KEY_AAA: // AAA
+ aStr = rCal.getDisplayString( CalendarDisplayCode::SHORT_DAY_NAME, nNatNum );
+ // NatNum12: support at least capitalize, upper, lower, title
+ if ( bUseSpellout )
+ {
+ aStr = impTransliterate(aStr, NumFor[nIx].GetNatNum(), rInfo.nTypeArray[i]);
+ }
+ sBuff.append(aStr);
+ break;
+ case NF_KEY_NNN: // NNN
+ case NF_KEY_AAAA: // AAAA
+ aStr = rCal.getDisplayString( CalendarDisplayCode::LONG_DAY_NAME, nNatNum );
+ // NatNum12: support variants of preposition, suffixation or article
+ if ( bUseSpellout )
+ {
+ aStr = impTransliterate(aStr, NumFor[nIx].GetNatNum(), rInfo.nTypeArray[i]);
+ }
+ sBuff.append(aStr);
+ break;
+ case NF_KEY_NNNN: // NNNN
+ sBuff.append(rCal.getDisplayString( CalendarDisplayCode::LONG_DAY_NAME, nNatNum ));
+ sBuff.append(rLoc().getLongDateDayOfWeekSep());
+ break;
+ case NF_KEY_WW : // WW
+ sBuff.append(ImpIntToString( nIx,
+ rCal.getValue( CalendarFieldIndex::WEEK_OF_YEAR )));
+ break;
+ case NF_KEY_G: // G
+ ImpAppendEraG(sBuff, rCal, nNatNum );
+ break;
+ case NF_KEY_GG: // GG
+ sBuff.append(rCal.getDisplayString( CalendarDisplayCode::SHORT_ERA, nNatNum ));
+ break;
+ case NF_KEY_GGG: // GGG
+ sBuff.append(rCal.getDisplayString( CalendarDisplayCode::LONG_ERA, nNatNum ));
+ break;
+ case NF_KEY_RR: // RR => GGGEE
+ sBuff.append(rCal.getDisplayString( CalendarDisplayCode::LONG_YEAR_AND_ERA, nNatNum ));
+ break;
+ }
+ }
+ if ( aOrgCalendar.getLength() )
+ {
+ rCal.loadCalendar( aOrgCalendar, rLoc().getLanguageTag().getLocale() ); // restore calendar
+ }
+ return bRes;
+}
+
+bool SvNumberformat::ImpGetDateTimeOutput(double fNumber,
+ sal_uInt16 nIx,
+ OUStringBuffer& sBuff)
+{
+ using namespace ::com::sun::star::i18n;
+ bool bRes = false;
+
+ CalendarWrapper& rCal = GetCal();
+ if (!lcl_getValidDate( rScan.GetNullDate(), rCal.getEpochStart(), fNumber))
+ {
+ sBuff = ImpSvNumberformatScan::sErrStr;
+ return false;
+ }
+
+ const ImpSvNumberformatInfo& rInfo = NumFor[nIx].Info();
+ bool bInputLine;
+ sal_Int32 nCntPost;
+ if ( rScan.GetStandardPrec() == SvNumberFormatter::INPUTSTRING_PRECISION &&
+ 0 < rInfo.nCntPost && rInfo.nCntPost < 7 )
+ {
+ // round at 7 decimals (+5 of 86400 == 12 significant digits)
+ bInputLine = true;
+ nCntPost = 7;
+ }
+ else
+ {
+ bInputLine = false;
+ nCntPost = rInfo.nCntPost;
+ }
+ double fTime = (fNumber - floor( fNumber )) * 86400.0;
+ fTime = ::rtl::math::round( fTime, int(nCntPost) );
+ if (fTime >= 86400.0)
+ {
+ // result of fNumber==x.999999999... rounded up, use correct date/time
+ fTime -= 86400.0;
+ fNumber = floor( fNumber + 0.5) + fTime;
+ }
+ rCal.setLocalDateTime( fNumber );
+
+ int nUseMonthCase = 0; // Not decided yet
+ OUString aOrgCalendar; // empty => not changed yet
+ double fOrgDateTime(0.0);
+ bool bOtherCalendar = ImpIsOtherCalendar( NumFor[nIx] );
+ if ( bOtherCalendar )
+ {
+ SwitchToOtherCalendar( aOrgCalendar, fOrgDateTime );
+ }
+ if ( ImpFallBackToGregorianCalendar( aOrgCalendar, fOrgDateTime ) )
+ {
+ bOtherCalendar = false;
+ }
+ sal_Int16 nNatNum = NumFor[nIx].GetNatNum().GetNatNum();
+
+ OUStringBuffer sSecStr;
+ sal_Int32 nSecPos = 0; // For figure by figure processing
+ sal_uInt32 nHour, nMin, nSec;
+ if (!rInfo.bThousand) // No [] format
+ {
+ sal_uInt16 nCHour, nCMinute, nCSecond;
+ double fFractionOfSecond;
+ tools::Time::GetClock( fNumber, nCHour, nCMinute, nCSecond, fFractionOfSecond, nCntPost);
+ nHour = nCHour;
+ nMin = nCMinute;
+ nSec = nCSecond;
+ nCntPost = ImpGetFractionOfSecondString( sSecStr, fFractionOfSecond, nCntPost, true, nIx,
+ (bInputLine ? rInfo.nCntPost : 0));
+ }
+ else
+ {
+ sal_uInt32 nSeconds = static_cast<sal_uInt32>(floor( fTime ));
+
+ nCntPost = ImpGetFractionOfSecondString( sSecStr, fTime - nSeconds, nCntPost, false, nIx,
+ (bInputLine ? rInfo.nCntPost : 0));
+
+ if (rInfo.nThousand == 3) // [ss]
+ {
+ nHour = 0;
+ nMin = 0;
+ nSec = nSeconds;
+ }
+ else if (rInfo.nThousand == 2) // [mm]:ss
+ {
+ nHour = 0;
+ nMin = nSeconds / 60;
+ nSec = nSeconds % 60;
+ }
+ else if (rInfo.nThousand == 1) // [hh]:mm:ss
+ {
+ nHour = nSeconds / 3600;
+ nMin = (nSeconds%3600) / 60;
+ nSec = nSeconds%60;
+ }
+ else
+ {
+ nHour = 0; // TODO What should these values be?
+ nMin = 0;
+ nSec = 0;
+ }
+ }
+ sal_Unicode cAmPm = ' '; // a or p
+ if (rInfo.nCntExp) // AM/PM
+ {
+ if (nHour == 0)
+ {
+ nHour = 12;
+ cAmPm = 'a';
+ }
+ else if (nHour < 12)
+ {
+ cAmPm = 'a';
+ }
+ else
+ {
+ cAmPm = 'p';
+ if (nHour > 12)
+ {
+ nHour -= 12;
+ }
+ }
+ }
+ const sal_uInt16 nCnt = NumFor[nIx].GetCount();
+ sal_Int32 nLen;
+ OUString aYear;
+ for (sal_uInt16 i = 0; i < nCnt; i++)
+ {
+ switch (rInfo.nTypeArray[i])
+ {
+ case NF_SYMBOLTYPE_CALENDAR :
+ if ( !aOrgCalendar.getLength() )
+ {
+ aOrgCalendar = rCal.getUniqueID();
+ fOrgDateTime = rCal.getDateTime();
+ }
+ rCal.loadCalendar( rInfo.sStrArray[i], rLoc().getLanguageTag().getLocale() );
+ rCal.setDateTime( fOrgDateTime );
+ ImpFallBackToGregorianCalendar( aOrgCalendar, fOrgDateTime );
+ break;
+ case NF_SYMBOLTYPE_STAR:
+ if( bStarFlag )
+ {
+ bRes = lcl_appendStarFillChar( sBuff, rInfo.sStrArray[i]);
+ }
+ break;
+ case NF_SYMBOLTYPE_BLANK:
+ if (rInfo.sStrArray[i].getLength() >= 2)
+ InsertBlanks( sBuff, sBuff.getLength(), rInfo.sStrArray[i][1] );
+ break;
+ case NF_SYMBOLTYPE_STRING:
+ case NF_SYMBOLTYPE_CURRENCY:
+ case NF_SYMBOLTYPE_DATESEP:
+ case NF_SYMBOLTYPE_TIMESEP:
+ case NF_SYMBOLTYPE_TIME100SECSEP:
+ sBuff.append(rInfo.sStrArray[i]);
+ break;
+ case NF_SYMBOLTYPE_DIGIT:
+ nLen = ( bInputLine && i > 0 &&
+ (rInfo.nTypeArray[i-1] == NF_SYMBOLTYPE_STRING ||
+ rInfo.nTypeArray[i-1] == NF_SYMBOLTYPE_TIME100SECSEP) ?
+ nCntPost : rInfo.sStrArray[i].getLength() );
+ for (sal_Int32 j = 0; j < nLen && nSecPos < nCntPost && nSecPos < sSecStr.getLength(); ++j)
+ {
+ sBuff.append(sSecStr[ nSecPos ]);
+ nSecPos++;
+ }
+ break;
+ case NF_KEY_AMPM: // AM/PM
+ if (cAmPm == 'a')
+ {
+ sBuff.append(rCal.getDisplayName( CalendarDisplayIndex::AM_PM,
+ AmPmValue::AM, 0 ));
+ }
+ else
+ {
+ sBuff.append(rCal.getDisplayName( CalendarDisplayIndex::AM_PM,
+ AmPmValue::PM, 0 ));
+ }
+ break;
+ case NF_KEY_AP: // A/P
+ if (cAmPm == 'a')
+ {
+ sBuff.append('a');
+ }
+ else
+ {
+ sBuff.append('p');
+ }
+ break;
+ case NF_KEY_MI: // M
+ sBuff.append(ImpIntToString( nIx, nMin ));
+ break;
+ case NF_KEY_MMI: // MM
+ sBuff.append(ImpIntToString( nIx, nMin, 2 ));
+ break;
+ case NF_KEY_H: // H
+ sBuff.append(ImpIntToString( nIx, nHour ));
+ break;
+ case NF_KEY_HH: // HH
+ sBuff.append(ImpIntToString( nIx, nHour, 2 ));
+ break;
+ case NF_KEY_S: // S
+ sBuff.append(ImpIntToString( nIx, nSec ));
+ break;
+ case NF_KEY_SS: // SS
+ sBuff.append(ImpIntToString( nIx, nSec, 2 ));
+ break;
+ case NF_KEY_M: // M
+ sBuff.append(rCal.getDisplayString(
+ CalendarDisplayCode::SHORT_MONTH, nNatNum ));
+ break;
+ case NF_KEY_MM: // MM
+ sBuff.append(rCal.getDisplayString(
+ CalendarDisplayCode::LONG_MONTH, nNatNum ));
+ break;
+ case NF_KEY_MMM: // MMM
+ sBuff.append(rCal.getDisplayString( ImpUseMonthCase( nUseMonthCase, NumFor[nIx],
+ static_cast<NfKeywordIndex>(rInfo.nTypeArray[i])),
+ nNatNum));
+ break;
+ case NF_KEY_MMMM: // MMMM
+ sBuff.append(rCal.getDisplayString( ImpUseMonthCase( nUseMonthCase, NumFor[nIx],
+ static_cast<NfKeywordIndex>(rInfo.nTypeArray[i])),
+ nNatNum));
+ break;
+ case NF_KEY_MMMMM: // MMMMM
+ sBuff.append(rCal.getDisplayString( ImpUseMonthCase( nUseMonthCase, NumFor[nIx],
+ static_cast<NfKeywordIndex>(rInfo.nTypeArray[i])),
+ nNatNum));
+ break;
+ case NF_KEY_Q: // Q
+ sBuff.append(rCal.getDisplayString( CalendarDisplayCode::SHORT_QUARTER, nNatNum ));
+ break;
+ case NF_KEY_QQ: // QQ
+ sBuff.append(rCal.getDisplayString( CalendarDisplayCode::LONG_QUARTER, nNatNum ));
+ break;
+ case NF_KEY_D: // D
+ sBuff.append(rCal.getDisplayString( CalendarDisplayCode::SHORT_DAY, nNatNum ));
+ break;
+ case NF_KEY_DD: // DD
+ sBuff.append(rCal.getDisplayString( CalendarDisplayCode::LONG_DAY, nNatNum ));
+ break;
+ case NF_KEY_DDD: // DDD
+ if ( bOtherCalendar )
+ {
+ SwitchToGregorianCalendar( aOrgCalendar, fOrgDateTime );
+ }
+ sBuff.append(rCal.getDisplayString( CalendarDisplayCode::SHORT_DAY_NAME, nNatNum ));
+ if ( bOtherCalendar )
+ {
+ SwitchToOtherCalendar( aOrgCalendar, fOrgDateTime );
+ }
+ break;
+ case NF_KEY_DDDD: // DDDD
+ if ( bOtherCalendar )
+ {
+ SwitchToGregorianCalendar( aOrgCalendar, fOrgDateTime );
+ }
+ sBuff.append(rCal.getDisplayString( CalendarDisplayCode::LONG_DAY_NAME, nNatNum ));
+ if ( bOtherCalendar )
+ {
+ SwitchToOtherCalendar( aOrgCalendar, fOrgDateTime );
+ }
+ break;
+ case NF_KEY_YY: // YY
+ if ( bOtherCalendar )
+ {
+ SwitchToGregorianCalendar( aOrgCalendar, fOrgDateTime );
+ }
+ // Prepend a minus sign if Gregorian BCE and era is not displayed.
+ if (lcl_isSignedYear( rCal, NumFor[nIx] ))
+ {
+ sBuff.append('-');
+ }
+ sBuff.append(rCal.getDisplayString( CalendarDisplayCode::SHORT_YEAR, nNatNum ));
+ if ( bOtherCalendar )
+ {
+ SwitchToOtherCalendar( aOrgCalendar, fOrgDateTime );
+ }
+ break;
+ case NF_KEY_YYYY: // YYYY
+ if ( bOtherCalendar )
+ {
+ SwitchToGregorianCalendar( aOrgCalendar, fOrgDateTime );
+ }
+ // Prepend a minus sign if Gregorian BCE and era is not displayed.
+ if (lcl_isSignedYear( rCal, NumFor[nIx] ))
+ {
+ sBuff.append('-');
+ }
+ aYear = rCal.getDisplayString( CalendarDisplayCode::LONG_YEAR, nNatNum );
+ if (aYear.getLength() < 4 && !lcl_hasEra(NumFor[nIx]))
+ {
+ using namespace comphelper::string;
+ // Ensure that year consists of at least 4 digits, so it
+ // can be distinguished from 2 digits display and edited
+ // without suddenly being hit by the 2-digit year magic.
+ OUStringBuffer aBuf;
+ padToLength(aBuf, 4 - aYear.getLength(), '0');
+ impTransliterate(aBuf, NumFor[nIx].GetNatNum());
+ aBuf.append(aYear);
+ sBuff.append(aBuf);
+ }
+ else
+ {
+ sBuff.append(aYear);
+ }
+ if ( bOtherCalendar )
+ {
+ SwitchToOtherCalendar( aOrgCalendar, fOrgDateTime );
+ }
+ break;
+ case NF_KEY_EC: // E
+ sBuff.append(rCal.getDisplayString( CalendarDisplayCode::SHORT_YEAR, nNatNum ));
+ break;
+ case NF_KEY_EEC: // EE
+ case NF_KEY_R: // R
+ sBuff.append(rCal.getDisplayString( CalendarDisplayCode::LONG_YEAR, nNatNum ));
+ break;
+ case NF_KEY_NN: // NN
+ case NF_KEY_AAA: // AAA
+ sBuff.append(rCal.getDisplayString( CalendarDisplayCode::SHORT_DAY_NAME, nNatNum ));
+ break;
+ case NF_KEY_NNN: // NNN
+ case NF_KEY_AAAA: // AAAA
+ sBuff.append(rCal.getDisplayString( CalendarDisplayCode::LONG_DAY_NAME, nNatNum ));
+ break;
+ case NF_KEY_NNNN: // NNNN
+ sBuff.append(rCal.getDisplayString( CalendarDisplayCode::LONG_DAY_NAME, nNatNum ));
+ sBuff.append(rLoc().getLongDateDayOfWeekSep());
+ break;
+ case NF_KEY_WW : // WW
+ sBuff.append(ImpIntToString( nIx, rCal.getValue( CalendarFieldIndex::WEEK_OF_YEAR )));
+ break;
+ case NF_KEY_G: // G
+ ImpAppendEraG( sBuff, rCal, nNatNum );
+ break;
+ case NF_KEY_GG: // GG
+ sBuff.append(rCal.getDisplayString( CalendarDisplayCode::SHORT_ERA, nNatNum ));
+ break;
+ case NF_KEY_GGG: // GGG
+ sBuff.append(rCal.getDisplayString( CalendarDisplayCode::LONG_ERA, nNatNum ));
+ break;
+ case NF_KEY_RR: // RR => GGGEE
+ sBuff.append(rCal.getDisplayString( CalendarDisplayCode::LONG_YEAR_AND_ERA, nNatNum ));
+ break;
+ }
+ }
+ if ( aOrgCalendar.getLength() )
+ {
+ rCal.loadCalendar( aOrgCalendar, rLoc().getLanguageTag().getLocale() ); // restore calendar
+ }
+ return bRes;
+}
+
+bool SvNumberformat::ImpGetLogicalOutput(double fNumber,
+ sal_uInt16 nIx,
+ OUStringBuffer& sStr)
+{
+ bool bRes = false;
+ const ImpSvNumberformatInfo& rInfo = NumFor[nIx].Info();
+ const sal_uInt16 nCnt = NumFor[nIx].GetCount();
+ for (sal_uInt16 j = 0; j < nCnt; ++j)
+ {
+ switch (rInfo.nTypeArray[j])
+ {
+ case NF_KEY_BOOLEAN:
+ sStr.append( fNumber ? rScan.GetTrueString() : rScan.GetFalseString());
+ break;
+ case NF_SYMBOLTYPE_STRING:
+ sStr.append( rInfo.sStrArray[j]);
+ break;
+ }
+ }
+ impTransliterate(sStr, NumFor[nIx].GetNatNum());
+ return bRes;
+}
+
+bool SvNumberformat::ImpGetNumberOutput(double fNumber,
+ sal_uInt16 nIx,
+ OUStringBuffer& sStr)
+{
+ bool bRes = false;
+ bool bSign;
+ if (fNumber < 0.0)
+ {
+ bSign = (nIx == 0); // Not in the ones at the back;
+ fNumber = -fNumber;
+ }
+ else
+ {
+ bSign = false;
+ if ( std::signbit( fNumber ) )
+ {
+ fNumber = -fNumber; // yes, -0.0 is possible, eliminate '-'
+ }
+ }
+ const ImpSvNumberformatInfo& rInfo = NumFor[nIx].Info();
+ if (rInfo.eScannedType == SvNumFormatType::PERCENT)
+ {
+ if (fNumber < D_MAX_D_BY_100)
+ {
+ fNumber *= 100.0;
+ }
+ else
+ {
+ sStr = ImpSvNumberformatScan::sErrStr;
+ return false;
+ }
+ }
+ sal_uInt16 i, j;
+ sal_Int32 nDecPos = -1;
+ bool bInteger = false;
+ if ( rInfo.nThousand != FLAG_STANDARD_IN_FORMAT )
+ {
+ // Special formatting only if no GENERAL keyword in format code
+ const sal_uInt16 nThousand = rInfo.nThousand;
+ tools::Long nPrecExp;
+ for (i = 0; i < nThousand; i++)
+ {
+ if (fNumber > D_MIN_M_BY_1000)
+ {
+ fNumber /= 1000.0;
+ }
+ else
+ {
+ fNumber = 0.0;
+ }
+ }
+ if (fNumber > 0.0)
+ {
+ nPrecExp = GetPrecExp( fNumber );
+ }
+ else
+ {
+ nPrecExp = 0;
+ }
+ if (rInfo.nCntPost) // Decimal places
+ {
+ if ((rInfo.nCntPost + nPrecExp) > 15 && nPrecExp < 15)
+ {
+ sStr = ::rtl::math::doubleToUString( fNumber, rtl_math_StringFormat_F, 15-nPrecExp, '.');
+ for (tools::Long l = 15-nPrecExp; l < static_cast<tools::Long>(rInfo.nCntPost); l++)
+ {
+ sStr.append('0');
+ }
+ }
+ else
+ {
+ sStr = ::rtl::math::doubleToUString( fNumber, rtl_math_StringFormat_F, rInfo.nCntPost, '.' );
+ }
+ sStr.stripStart('0'); // Strip leading zeros
+ }
+ else if (fNumber == 0.0) // Null
+ {
+ // Nothing to be done here, keep empty string sStr,
+ // ImpNumberFillWithThousands does the rest
+ }
+ else // Integer
+ {
+ sStr = ::rtl::math::doubleToUString( fNumber, rtl_math_StringFormat_F, 0, '.');
+ sStr.stripStart('0'); // Strip leading zeros
+ }
+ nDecPos = sStr.indexOf('.' );
+ if ( nDecPos >= 0)
+ {
+ const sal_Unicode* p = sStr.getStr() + nDecPos;
+ while ( *++p == '0' )
+ ;
+ if ( !*p )
+ {
+ bInteger = true;
+ }
+ sStr.remove( nDecPos, 1 ); // Remove .
+ }
+ if (bSign && (sStr.isEmpty() || checkForAll0s(sStr))) // Only 00000
+ {
+ bSign = false; // Not -0.00
+ }
+ } // End of != FLAG_STANDARD_IN_FORMAT
+
+ // Edit backwards:
+ j = NumFor[nIx].GetCount()-1; // Last symbol
+ // Decimal places:
+ bRes |= ImpDecimalFill( sStr, fNumber, nDecPos, j, nIx, bInteger );
+ if (bSign)
+ {
+ sStr.insert(0, '-');
+ }
+ impTransliterate(sStr, NumFor[nIx].GetNatNum());
+ return bRes;
+}
+
+bool SvNumberformat::ImpDecimalFill( OUStringBuffer& sStr, // number string
+ double& rNumber, // number
+ sal_Int32 nDecPos, // decimals start
+ sal_uInt16 j, // symbol index within format code
+ sal_uInt16 nIx, // subformat index
+ bool bInteger) // is integer
+{
+ bool bRes = false;
+ bool bFilled = false; // Was filled?
+ const ImpSvNumberformatInfo& rInfo = NumFor[nIx].Info();
+ sal_Int32 k = sStr.getLength(); // After last figure
+ // Decimal places:
+ if (rInfo.nCntPost > 0)
+ {
+ bool bTrailing = true; // Trailing zeros?
+ short nType;
+ while (j > 0 && // Backwards
+ (nType = rInfo.nTypeArray[j]) != NF_SYMBOLTYPE_DECSEP)
+ {
+ switch ( nType )
+ {
+ case NF_SYMBOLTYPE_STAR:
+ if( bStarFlag )
+ {
+ bRes = lcl_insertStarFillChar( sStr, k, rInfo.sStrArray[j]);
+ }
+ break;
+ case NF_SYMBOLTYPE_BLANK:
+ if (rInfo.sStrArray[j].getLength() >= 2)
+ /*k = */ InsertBlanks(sStr, k, rInfo.sStrArray[j][1] );
+ break;
+ case NF_SYMBOLTYPE_STRING:
+ case NF_SYMBOLTYPE_CURRENCY:
+ case NF_SYMBOLTYPE_PERCENT:
+ sStr.insert(k, rInfo.sStrArray[j]);
+ break;
+ case NF_SYMBOLTYPE_THSEP:
+ if (rInfo.nThousand == 0)
+ {
+ sStr.insert(k, rInfo.sStrArray[j]);
+ }
+ break;
+ case NF_SYMBOLTYPE_DIGIT:
+ {
+ const OUString& rStr = rInfo.sStrArray[j];
+ const sal_Unicode* p1 = rStr.getStr();
+ const sal_Unicode* p = p1 + rStr.getLength();
+ // In case the number of decimals passed are less than the
+ // "digits" given, append trailing '0' characters, which here
+ // means insert them because literal strings may have been
+ // appended already. If they weren't to be '0' characters
+ // they'll be changed below, as if decimals with trailing zeros
+ // were passed.
+ if (nDecPos >= 0 && nDecPos <= k)
+ {
+ sal_Int32 nAppend = rStr.getLength() - (k - nDecPos);
+ while (nAppend-- > 0)
+ {
+ sStr.insert( k++, '0');
+ }
+ }
+ while (k && p1 < p--)
+ {
+ const sal_Unicode c = *p;
+ k--;
+ if ( sStr[k] != '0' )
+ {
+ bTrailing = false;
+ bFilled = true;
+ }
+ if (bTrailing)
+ {
+ if ( c == '0' )
+ {
+ bFilled = true;
+ }
+ else if ( c == '-' )
+ {
+ if ( bInteger )
+ {
+ sStr[ k ] = '-';
+ }
+ bFilled = true;
+ }
+ else if ( c == '?' )
+ {
+ sStr[ k ] = ' ';
+ bFilled = true;
+ }
+ else if ( !bFilled ) // #
+ {
+ sStr.remove(k,1);
+ }
+ }
+ } // of for
+ break;
+ } // of case digi
+ case NF_KEY_CCC: // CCC currency
+ sStr.insert(k, rScan.GetCurAbbrev());
+ break;
+ case NF_KEY_GENERAL: // Standard in the String
+ {
+ OUStringBuffer sNum;
+ ImpGetOutputStandard(rNumber, sNum);
+ sNum.stripStart('-');
+ sStr.insert(k, sNum.makeStringAndClear());
+ break;
+ }
+ default:
+ break;
+ } // of switch
+ j--;
+ } // of while
+ } // of decimal places
+
+ bRes |= ImpNumberFillWithThousands(sStr, rNumber, k, j, nIx, // Fill with . if needed
+ rInfo.nCntPre, bFilled );
+
+ return bRes;
+}
+
+bool SvNumberformat::ImpNumberFillWithThousands( OUStringBuffer& sBuff, // number string
+ double& rNumber, // number
+ sal_Int32 k, // position within string
+ sal_uInt16 j, // symbol index within format code
+ sal_uInt16 nIx, // subformat index
+ sal_Int32 nDigCnt, // count of integer digits in format
+ bool bAddDecSep) // add decimal separator if necessary
+{
+ bool bRes = false;
+ sal_Int32 nLeadingStringChars = 0; // inserted StringChars before number
+ sal_Int32 nDigitCount = 0; // count of integer digits from the right
+ bool bStop = false;
+ const ImpSvNumberformatInfo& rInfo = NumFor[nIx].Info();
+ // no normal thousands separators if number divided by thousands
+ bool bDoThousands = (rInfo.nThousand == 0);
+ utl::DigitGroupingIterator aGrouping( GetFormatter().GetLocaleData()->getDigitGrouping());
+
+ while (!bStop) // backwards
+ {
+ if (j == 0)
+ {
+ bStop = true;
+ }
+ switch (rInfo.nTypeArray[j])
+ {
+ case NF_SYMBOLTYPE_DECSEP:
+ aGrouping.reset();
+ [[fallthrough]];
+ case NF_SYMBOLTYPE_STRING:
+ case NF_SYMBOLTYPE_CURRENCY:
+ case NF_SYMBOLTYPE_PERCENT:
+ if ( rInfo.nTypeArray[j] != NF_SYMBOLTYPE_DECSEP || bAddDecSep )
+ sBuff.insert(k, rInfo.sStrArray[j]);
+ if ( k == 0 )
+ {
+ nLeadingStringChars = nLeadingStringChars + rInfo.sStrArray[j].getLength();
+ }
+ break;
+ case NF_SYMBOLTYPE_STAR:
+ if( bStarFlag )
+ {
+ bRes = lcl_insertStarFillChar( sBuff, k, rInfo.sStrArray[j]);
+ }
+ break;
+ case NF_SYMBOLTYPE_BLANK:
+ if (rInfo.sStrArray[j].getLength() >= 2)
+ /*k = */ InsertBlanks(sBuff, k, rInfo.sStrArray[j][1] );
+ break;
+ case NF_SYMBOLTYPE_THSEP:
+ // #i7284# #102685# Insert separator also if number is divided
+ // by thousands and the separator is specified somewhere in
+ // between and not only at the end.
+ // #i12596# But do not insert if it's a parenthesized negative
+ // format like (#,)
+ // In fact, do not insert if divided and regex [0#,],[^0#] and
+ // no other digit symbol follows (which was already detected
+ // during scan of format code, otherwise there would be no
+ // division), else do insert. Same in ImpNumberFill() below.
+ if ( !bDoThousands && j < NumFor[nIx].GetCount()-1 )
+ {
+ bDoThousands = ((j == 0) ||
+ (rInfo.nTypeArray[j-1] != NF_SYMBOLTYPE_DIGIT &&
+ rInfo.nTypeArray[j-1] != NF_SYMBOLTYPE_THSEP) ||
+ (rInfo.nTypeArray[j+1] == NF_SYMBOLTYPE_DIGIT));
+ }
+ if ( bDoThousands )
+ {
+ if (k > 0)
+ {
+ sBuff.insert(k, rInfo.sStrArray[j]);
+ }
+ else if (nDigitCount < nDigCnt)
+ {
+ // Leading '#' displays nothing (e.g. no leading
+ // separator for numbers <1000 with #,##0 format).
+ // Leading '?' displays blank.
+ // Everything else, including nothing, displays the
+ // separator.
+ sal_Unicode cLeader = 0;
+ if (j > 0 && rInfo.nTypeArray[j-1] == NF_SYMBOLTYPE_DIGIT)
+ {
+ const OUString& rStr = rInfo.sStrArray[j-1];
+ sal_Int32 nLen = rStr.getLength();
+ if (nLen)
+ {
+ cLeader = rStr[ nLen - 1 ];
+ }
+ }
+ switch (cLeader)
+ {
+ case '#':
+ ; // nothing
+ break;
+ case '?':
+ // replace thousand separator with blank
+ sBuff.insert(k, ' ');
+ break;
+ default:
+ sBuff.insert(k, rInfo.sStrArray[j]);
+ }
+ }
+ aGrouping.advance();
+ }
+ break;
+ case NF_SYMBOLTYPE_DIGIT:
+ {
+ const OUString& rStr = rInfo.sStrArray[j];
+ const sal_Unicode* p1 = rStr.getStr();
+ const sal_Unicode* p = p1 + rStr.getLength();
+ while ( p1 < p-- )
+ {
+ nDigitCount++;
+ if (k > 0)
+ {
+ k--;
+ }
+ else
+ {
+ switch (*p)
+ {
+ case '0':
+ sBuff.insert(0, '0');
+ break;
+ case '?':
+ sBuff.insert(0, ' ');
+ break;
+ }
+ }
+ if (nDigitCount == nDigCnt && k > 0)
+ {
+ // more digits than specified
+ ImpDigitFill(sBuff, 0, k, nIx, nDigitCount, aGrouping);
+ }
+ }
+ break;
+ }
+ case NF_KEY_CCC: // CCC currency
+ sBuff.insert(k, rScan.GetCurAbbrev());
+ break;
+ case NF_KEY_GENERAL: // "General" in string
+ {
+ OUStringBuffer sNum;
+ ImpGetOutputStandard(rNumber, sNum);
+ sNum.stripStart('-');
+ sBuff.insert(k, sNum.makeStringAndClear());
+ break;
+ }
+ default:
+ break;
+ } // switch
+ j--; // next format code string
+ } // while
+
+ k = k + nLeadingStringChars; // MSC converts += to int and then warns, so ...
+ if (k > nLeadingStringChars)
+ {
+ ImpDigitFill(sBuff, nLeadingStringChars, k, nIx, nDigitCount, aGrouping);
+ }
+ return bRes;
+}
+
+void SvNumberformat::ImpDigitFill(OUStringBuffer& sStr, // number string
+ sal_Int32 nStart, // start of digits
+ sal_Int32 & k, // position within string
+ sal_uInt16 nIx, // subformat index
+ sal_Int32 & nDigitCount, // count of integer digits from the right so far
+ utl::DigitGroupingIterator & rGrouping ) // current grouping
+{
+ if (NumFor[nIx].Info().bThousand) // Only if grouping fill in separators
+ {
+ const OUString& rThousandSep = GetFormatter().GetNumThousandSep();
+ while (k > nStart)
+ {
+ if (nDigitCount == rGrouping.getPos())
+ {
+ sStr.insert( k, rThousandSep );
+ rGrouping.advance();
+ }
+ nDigitCount++;
+ k--;
+ }
+ }
+ else // simply skip
+ {
+ k = nStart;
+ }
+}
+
+bool SvNumberformat::ImpNumberFill( OUStringBuffer& sBuff, // number string
+ double& rNumber, // number for "General" format
+ sal_Int32& k, // position within string
+ sal_uInt16& j, // symbol index within format code
+ sal_uInt16 nIx, // subformat index
+ short eSymbolType, // type of stop condition
+ bool bInsertRightBlank)// insert blank on right for denominator (default = false)
+{
+ bool bRes = false;
+ bool bStop = false;
+ const ImpSvNumberformatInfo& rInfo = NumFor[nIx].Info();
+ // no normal thousands separators if number divided by thousands
+ bool bDoThousands = (rInfo.nThousand == 0);
+ bool bFoundNumber = false;
+ short nType;
+
+ k = sBuff.getLength(); // behind last digit
+
+ while (!bStop && (nType = rInfo.nTypeArray[j]) != eSymbolType ) // Backwards
+ {
+ switch ( nType )
+ {
+ case NF_SYMBOLTYPE_STAR:
+ if( bStarFlag )
+ {
+ if ( bFoundNumber && eSymbolType != NF_SYMBOLTYPE_EXP )
+ k = 0; // tdf#100842 jump to beginning of number before inserting something else
+ bRes = lcl_insertStarFillChar( sBuff, k, rInfo.sStrArray[j]);
+ }
+ break;
+ case NF_SYMBOLTYPE_BLANK:
+ if (rInfo.sStrArray[j].getLength() >= 2)
+ {
+ if ( bFoundNumber && eSymbolType != NF_SYMBOLTYPE_EXP )
+ k = 0; // tdf#100842 jump to beginning of number before inserting something else
+ k = InsertBlanks(sBuff, k, rInfo.sStrArray[j][1] );
+ }
+ break;
+ case NF_SYMBOLTYPE_THSEP:
+ // Same as in ImpNumberFillWithThousands() above, do not insert
+ // if divided and regex [0#,],[^0#] and no other digit symbol
+ // follows (which was already detected during scan of format
+ // code, otherwise there would be no division), else do insert.
+ if ( !bDoThousands && j < NumFor[nIx].GetCount()-1 )
+ {
+ bDoThousands = ((j == 0) ||
+ (rInfo.nTypeArray[j-1] != NF_SYMBOLTYPE_DIGIT &&
+ rInfo.nTypeArray[j-1] != NF_SYMBOLTYPE_THSEP) ||
+ (rInfo.nTypeArray[j+1] == NF_SYMBOLTYPE_DIGIT));
+ }
+ if ( bDoThousands && k > 0 )
+ {
+ sBuff.insert(k, rInfo.sStrArray[j]);
+ }
+ break;
+ case NF_SYMBOLTYPE_DIGIT:
+ {
+ bFoundNumber = true;
+ sal_uInt16 nPosInsertBlank = bInsertRightBlank ? k : 0; // left alignment of denominator
+ const OUString& rStr = rInfo.sStrArray[j];
+ const sal_Unicode* p1 = rStr.getStr();
+ const sal_Unicode* p = p1 + rStr.getLength();
+ while ( p1 < p-- )
+ {
+ if (k > 0)
+ {
+ k--;
+ }
+ else
+ {
+ switch (*p)
+ {
+ case '0':
+ sBuff.insert(0, '0');
+ break;
+ case '?':
+ sBuff.insert(nPosInsertBlank, ' ');
+ break;
+ }
+ }
+ }
+ }
+ break;
+ case NF_KEY_CCC: // CCC currency
+ sBuff.insert(k, rScan.GetCurAbbrev());
+ break;
+ case NF_KEY_GENERAL: // Standard in the String
+ {
+ OUStringBuffer sNum;
+ bFoundNumber = true;
+ ImpGetOutputStandard(rNumber, sNum);
+ sNum.stripStart('-');
+ sBuff.insert(k, sNum.makeStringAndClear());
+ }
+ break;
+ case NF_SYMBOLTYPE_FRAC_FDIV: // Do Nothing
+ if (k > 0)
+ {
+ k--;
+ }
+ break;
+
+ default:
+ if ( bFoundNumber && eSymbolType != NF_SYMBOLTYPE_EXP )
+ k = 0; // tdf#100842 jump to beginning of number before inserting something else
+ sBuff.insert(k, rInfo.sStrArray[j]);
+ break;
+ } // of switch
+ if ( j )
+ j--; // Next String
+ else
+ bStop = true;
+ } // of while
+ return bRes;
+}
+
+void SvNumberformat::GetFormatSpecialInfo(bool& bThousand,
+ bool& IsRed,
+ sal_uInt16& nPrecision,
+ sal_uInt16& nLeadingCnt) const
+{
+ // as before: take info from nNumFor=0 for whole format (for dialog etc.)
+
+ SvNumFormatType nDummyType;
+ GetNumForInfo( 0, nDummyType, bThousand, nPrecision, nLeadingCnt );
+
+ // "negative in red" is only useful for the whole format
+
+ const Color* pColor = NumFor[1].GetColor();
+ IsRed = fLimit1 == 0.0 && fLimit2 == 0.0 && pColor
+ && (*pColor == ImpSvNumberformatScan::GetRedColor());
+}
+
+void SvNumberformat::GetNumForInfo( sal_uInt16 nNumFor, SvNumFormatType& rScannedType,
+ bool& bThousand, sal_uInt16& nPrecision, sal_uInt16& nLeadingCnt ) const
+{
+ // take info from a specified sub-format (for XML export)
+
+ if ( nNumFor > 3 )
+ {
+ return; // invalid
+ }
+
+ const ImpSvNumberformatInfo& rInfo = NumFor[nNumFor].Info();
+ rScannedType = rInfo.eScannedType;
+ bThousand = rInfo.bThousand;
+ nPrecision = (rInfo.eScannedType == SvNumFormatType::FRACTION)
+ ? rInfo.nCntExp // number of denominator digits for fraction
+ : rInfo.nCntPost;
+ sal_Int32 nPosHash = 1;
+ if ( rInfo.eScannedType == SvNumFormatType::FRACTION &&
+ ( (nPosHash += GetDenominatorString(nNumFor).indexOf('#')) > 0 ) )
+ nPrecision -= nPosHash;
+ if (bStandard && rInfo.eScannedType == SvNumFormatType::NUMBER)
+ {
+ // StandardFormat
+ nLeadingCnt = 1;
+ }
+ else
+ {
+ nLeadingCnt = 0;
+ bool bStop = false;
+ sal_uInt16 i = 0;
+ const sal_uInt16 nCnt = NumFor[nNumFor].GetCount();
+ while (!bStop && i < nCnt)
+ {
+ short nType = rInfo.nTypeArray[i];
+ if ( nType == NF_SYMBOLTYPE_DIGIT)
+ {
+ const sal_Unicode* p = rInfo.sStrArray[i].getStr();
+ while ( *p == '#' )
+ {
+ p++;
+ }
+ while ( *p++ == '0' )
+ {
+ nLeadingCnt++;
+ }
+ }
+ else if (nType == NF_SYMBOLTYPE_DECSEP
+ || nType == NF_SYMBOLTYPE_EXP
+ || nType == NF_SYMBOLTYPE_FRACBLANK) // Fraction: stop after integer part,
+ { // do not count '0' of fraction
+ bStop = true;
+ }
+ i++;
+ }
+ }
+}
+
+const OUString* SvNumberformat::GetNumForString( sal_uInt16 nNumFor, sal_uInt16 nPos,
+ bool bString /* = false */ ) const
+{
+ if ( nNumFor > 3 )
+ {
+ return nullptr;
+ }
+ sal_uInt16 nCnt = NumFor[nNumFor].GetCount();
+ if ( !nCnt )
+ {
+ return nullptr;
+ }
+ if ( nPos == 0xFFFF )
+ {
+ nPos = nCnt - 1;
+ if ( bString )
+ { // Backwards
+ short const * pType = NumFor[nNumFor].Info().nTypeArray.data() + nPos;
+ while ( nPos > 0 && (*pType != NF_SYMBOLTYPE_STRING) &&
+ (*pType != NF_SYMBOLTYPE_CURRENCY) )
+ {
+ pType--;
+ nPos--;
+ }
+ if ( (*pType != NF_SYMBOLTYPE_STRING) && (*pType != NF_SYMBOLTYPE_CURRENCY) )
+ {
+ return nullptr;
+ }
+ }
+ }
+ else if ( nPos > nCnt - 1 )
+ {
+ return nullptr;
+ }
+ else if ( bString )
+ {
+ // forward
+ short const * pType = NumFor[nNumFor].Info().nTypeArray.data() + nPos;
+ while ( nPos < nCnt && (*pType != NF_SYMBOLTYPE_STRING) &&
+ (*pType != NF_SYMBOLTYPE_CURRENCY) )
+ {
+ pType++;
+ nPos++;
+ }
+ if ( nPos >= nCnt || ((*pType != NF_SYMBOLTYPE_STRING) &&
+ (*pType != NF_SYMBOLTYPE_CURRENCY)) )
+ {
+ return nullptr;
+ }
+ }
+ return &NumFor[nNumFor].Info().sStrArray[nPos];
+}
+
+short SvNumberformat::GetNumForType( sal_uInt16 nNumFor, sal_uInt16 nPos ) const
+{
+ if ( nNumFor > 3 )
+ {
+ return 0;
+ }
+ sal_uInt16 nCnt = NumFor[nNumFor].GetCount();
+ if ( !nCnt )
+ {
+ return 0;
+ }
+ if ( nPos == 0xFFFF )
+ {
+ nPos = nCnt - 1;
+ }
+ else if ( nPos > nCnt - 1 )
+ {
+ return 0;
+ }
+ return NumFor[nNumFor].Info().nTypeArray[nPos];
+}
+
+bool SvNumberformat::IsNegativeWithoutSign() const
+{
+ if ( IsSecondSubformatRealNegative() )
+ {
+ const OUString* pStr = GetNumForString( 1, 0, true );
+ if ( pStr )
+ {
+ return !HasStringNegativeSign( *pStr );
+ }
+ }
+ return false;
+}
+
+bool SvNumberformat::IsNegativeInBracket() const
+{
+ sal_uInt16 nCnt = NumFor[1].GetCount();
+ if (!nCnt)
+ {
+ return false;
+ }
+ auto& tmp = NumFor[1].Info().sStrArray;
+ return tmp[0] == "(" && tmp[nCnt-1] == ")";
+}
+
+bool SvNumberformat::HasPositiveBracketPlaceholder() const
+{
+ sal_uInt16 nCnt = NumFor[0].GetCount();
+ return NumFor[0].Info().sStrArray[nCnt-1] == "_)";
+}
+
+DateOrder SvNumberformat::GetDateOrder() const
+{
+ if ( eType & SvNumFormatType::DATE )
+ {
+ auto& rTypeArray = NumFor[0].Info().nTypeArray;
+ sal_uInt16 nCnt = NumFor[0].GetCount();
+ for ( sal_uInt16 j=0; j<nCnt; j++ )
+ {
+ switch ( rTypeArray[j] )
+ {
+ case NF_KEY_D :
+ case NF_KEY_DD :
+ return DateOrder::DMY;
+ case NF_KEY_M :
+ case NF_KEY_MM :
+ case NF_KEY_MMM :
+ case NF_KEY_MMMM :
+ case NF_KEY_MMMMM :
+ return DateOrder::MDY;
+ case NF_KEY_YY :
+ case NF_KEY_YYYY :
+ case NF_KEY_EC :
+ case NF_KEY_EEC :
+ case NF_KEY_R :
+ case NF_KEY_RR :
+ return DateOrder::YMD;
+ }
+ }
+ }
+ else
+ {
+ SAL_WARN( "svl.numbers", "SvNumberformat::GetDateOrder: no date" );
+ }
+ return rLoc().getDateOrder();
+}
+
+sal_uInt32 SvNumberformat::GetExactDateOrder() const
+{
+ sal_uInt32 nRet = 0;
+ if ( !(eType & SvNumFormatType::DATE) )
+ {
+ SAL_WARN( "svl.numbers", "SvNumberformat::GetExactDateOrder: no date" );
+ return nRet;
+ }
+ auto& rTypeArray = NumFor[0].Info().nTypeArray;
+ sal_uInt16 nCnt = NumFor[0].GetCount();
+ int nShift = 0;
+ for ( sal_uInt16 j=0; j<nCnt && nShift < 3; j++ )
+ {
+ switch ( rTypeArray[j] )
+ {
+ case NF_KEY_D :
+ case NF_KEY_DD :
+ nRet = (nRet << 8) | 'D';
+ ++nShift;
+ break;
+ case NF_KEY_M :
+ case NF_KEY_MM :
+ case NF_KEY_MMM :
+ case NF_KEY_MMMM :
+ case NF_KEY_MMMMM :
+ nRet = (nRet << 8) | 'M';
+ ++nShift;
+ break;
+ case NF_KEY_YY :
+ case NF_KEY_YYYY :
+ case NF_KEY_EC :
+ case NF_KEY_EEC :
+ case NF_KEY_R :
+ case NF_KEY_RR :
+ nRet = (nRet << 8) | 'Y';
+ ++nShift;
+ break;
+ }
+ }
+ return nRet;
+}
+
+void SvNumberformat::GetConditions( SvNumberformatLimitOps& rOper1, double& rVal1,
+ SvNumberformatLimitOps& rOper2, double& rVal2 ) const
+{
+ rOper1 = eOp1;
+ rOper2 = eOp2;
+ rVal1 = fLimit1;
+ rVal2 = fLimit2;
+}
+
+const Color* SvNumberformat::GetColor( sal_uInt16 nNumFor ) const
+{
+ if ( nNumFor > 3 )
+ {
+ return nullptr;
+ }
+ return NumFor[nNumFor].GetColor();
+}
+
+static void lcl_SvNumberformat_AddLimitStringImpl( OUString& rStr,
+ SvNumberformatLimitOps eOp,
+ double fLimit, std::u16string_view rDecSep )
+{
+ if ( eOp == NUMBERFORMAT_OP_NO )
+ return;
+
+ switch ( eOp )
+ {
+ case NUMBERFORMAT_OP_EQ :
+ rStr = "[=";
+ break;
+ case NUMBERFORMAT_OP_NE :
+ rStr = "[<>";
+ break;
+ case NUMBERFORMAT_OP_LT :
+ rStr = "[<";
+ break;
+ case NUMBERFORMAT_OP_LE :
+ rStr = "[<=";
+ break;
+ case NUMBERFORMAT_OP_GT :
+ rStr = "[>";
+ break;
+ case NUMBERFORMAT_OP_GE :
+ rStr = "[>=";
+ break;
+ default:
+ SAL_WARN( "svl.numbers", "unsupported number format" );
+ break;
+ }
+ rStr += ::rtl::math::doubleToUString( fLimit,
+ rtl_math_StringFormat_Automatic, rtl_math_DecimalPlaces_Max,
+ rDecSep[0], true);
+ rStr += "]";
+}
+
+static void lcl_insertLCID( OUStringBuffer& rFormatStr, sal_uInt32 nLCID, sal_Int32 nPosInsertLCID, bool bDBNumInserted )
+{
+ if ( nLCID == 0 )
+ return;
+ if (nPosInsertLCID == rFormatStr.getLength() && !bDBNumInserted)
+ // No format code, no locale.
+ return;
+
+ OUStringBuffer aLCIDString = OUString::number( nLCID , 16 ).toAsciiUpperCase();
+ // Search for only last DBNum which is the last element before insertion position
+ if ( bDBNumInserted && nPosInsertLCID >= 8
+ && aLCIDString.getLength() > 4
+ && rFormatStr.indexOf( "[DBNum", nPosInsertLCID-8) == nPosInsertLCID-8 )
+ { // remove DBNumX code if long LCID
+ nPosInsertLCID -= 8;
+ rFormatStr.remove( nPosInsertLCID, 8 );
+ }
+ aLCIDString.insert( 0, "[$-" );
+ aLCIDString.append( "]" );
+ rFormatStr.insert( nPosInsertLCID, aLCIDString.makeStringAndClear() );
+}
+
+/** Increment nAlphabetID for CJK numerals
+ * +1 for financial numerals [NatNum2]
+ * +2 for Arabic fullwidth numerals [NatNum3]
+ * */
+static void lcl_incrementAlphabetWithNatNum ( sal_uInt32& nAlphabetID, sal_uInt32 nNatNum )
+{
+ if ( nNatNum == 2) // financial
+ nAlphabetID += 1;
+ else if ( nNatNum == 3)
+ nAlphabetID += 2;
+ nAlphabetID = nAlphabetID << 24;
+}
+
+OUString SvNumberformat::GetMappedFormatstring( const NfKeywordTable& rKeywords,
+ const LocaleDataWrapper& rLocWrp,
+ LanguageType nOriginalLang /* =LANGUAGE_DONTKNOW */,
+ bool bSystemLanguage /* =false */ ) const
+{
+ OUStringBuffer aStr;
+ if (maLocale.meSubstitute != LocaleType::Substitute::NONE)
+ {
+ // XXX: theoretically this could clash with the first subformat's
+ // lcl_insertLCID() below, in practice as long as it is used for system
+ // time and date modifiers it shouldn't (i.e. there is no calendar or
+ // numeral specified as well).
+ aStr.append("[$-" + maLocale.generateCode() + "]");
+ }
+ bool bDefault[4];
+ // 1 subformat matches all if no condition specified,
+ bDefault[0] = ( NumFor[1].GetCount() == 0 && eOp1 == NUMBERFORMAT_OP_NO );
+ // with 2 subformats [>=0];[<0] is implied if no condition specified
+ bDefault[1] = ( !bDefault[0] && NumFor[2].GetCount() == 0 &&
+ eOp1 == NUMBERFORMAT_OP_GE && fLimit1 == 0.0 &&
+ eOp2 == NUMBERFORMAT_OP_NO && fLimit2 == 0.0 );
+ // with 3 or more subformats [>0];[<0];[=0] is implied if no condition specified,
+ // note that subformats may be empty (;;;) and NumFor[2].GetCount()>0 is not checked.
+ bDefault[2] = ( !bDefault[0] && !bDefault[1] &&
+ eOp1 == NUMBERFORMAT_OP_GT && fLimit1 == 0.0 &&
+ eOp2 == NUMBERFORMAT_OP_LT && fLimit2 == 0.0 );
+ bool bDefaults = bDefault[0] || bDefault[1] || bDefault[2];
+ // from now on bDefault[] values are used to append empty subformats at the end
+ bDefault[3] = false;
+ if ( !bDefaults )
+ {
+ // conditions specified
+ if ( eOp1 != NUMBERFORMAT_OP_NO && eOp2 == NUMBERFORMAT_OP_NO )
+ {
+ bDefault[0] = bDefault[1] = true; // [];x
+ }
+ else if ( eOp1 != NUMBERFORMAT_OP_NO && eOp2 != NUMBERFORMAT_OP_NO &&
+ NumFor[2].GetCount() == 0 )
+ {
+ bDefault[0] = bDefault[1] = bDefault[2] = bDefault[3] = true; // [];[];;
+ }
+ // nothing to do if conditions specified for every subformat
+ }
+ else if ( bDefault[0] )
+ {
+ bDefault[0] = false; // a single unconditional subformat is never delimited
+ }
+ else
+ {
+ if ( bDefault[2] && NumFor[2].GetCount() == 0 && NumFor[1].GetCount() > 0 )
+ {
+ bDefault[3] = true; // special cases x;x;; and ;x;;
+ }
+ for ( int i=0; i<3 && !bDefault[i]; ++i )
+ {
+ bDefault[i] = true;
+ }
+ }
+ int nSem = 0; // needed ';' delimiters
+ int nSub = 0; // subformats delimited so far
+ for ( int n=0; n<4; n++ )
+ {
+ if ( n > 0 && NumFor[n].Info().eScannedType != SvNumFormatType::UNDEFINED )
+ {
+ nSem++;
+ }
+ OUString aPrefix;
+
+ if ( !bDefaults )
+ {
+ switch ( n )
+ {
+ case 0 :
+ lcl_SvNumberformat_AddLimitStringImpl( aPrefix, eOp1,
+ fLimit1, rLocWrp.getNumDecimalSep() );
+ break;
+ case 1 :
+ lcl_SvNumberformat_AddLimitStringImpl( aPrefix, eOp2,
+ fLimit2, rLocWrp.getNumDecimalSep() );
+ break;
+ }
+ }
+
+ const OUString& rColorName = NumFor[n].GetColorName();
+ if ( !rColorName.isEmpty() )
+ {
+ const NfKeywordTable & rKey = rScan.GetKeywords();
+ for ( int j = NF_KEY_FIRSTCOLOR; j <= NF_KEY_LASTCOLOR; j++ )
+ {
+ if ( rKey[j] == rColorName )
+ {
+ aPrefix += "[" + rKeywords[j] + "]";
+ break; // for
+ }
+ }
+ }
+
+ SvNumberNatNum aNatNum = NumFor[n].GetNatNum();
+ bool bDBNumInserted = false;
+ if (aNatNum.IsComplete() && (aNatNum.GetDBNum() > 0 || nOriginalLang != LANGUAGE_DONTKNOW))
+ { // GetFormatStringForExcel() may have changed language to en_US
+ if (aNatNum.GetLang() == LANGUAGE_ENGLISH_US && nOriginalLang != LANGUAGE_DONTKNOW)
+ aNatNum.SetLang( nOriginalLang );
+ if ( aNatNum.GetDBNum() > 0 )
+ {
+ aPrefix += "[DBNum" + OUString::number( aNatNum.GetDBNum() ) + "]";
+ bDBNumInserted = true;
+ }
+ }
+
+ sal_uInt16 nCnt = NumFor[n].GetCount();
+ if ( nSem && (nCnt || !aPrefix.isEmpty()) )
+ {
+ for ( ; nSem; --nSem )
+ {
+ aStr.append( ';' );
+ }
+ for ( ; nSub <= n; ++nSub )
+ {
+ bDefault[nSub] = false;
+ }
+ }
+
+ if ( !aPrefix.isEmpty() )
+ {
+ aStr.append( aPrefix );
+ }
+ sal_Int32 nPosHaveLCID = -1;
+ sal_Int32 nPosInsertLCID = aStr.getLength();
+ sal_uInt32 nCalendarID = 0x0000000; // Excel ID of calendar used in sub-format see tdf#36038
+ constexpr sal_uInt32 kCalGengou = 0x0030000;
+ if ( nCnt )
+ {
+ auto& rTypeArray = NumFor[n].Info().nTypeArray;
+ auto& rStrArray = NumFor[n].Info().sStrArray;
+ for ( sal_uInt16 j=0; j<nCnt; j++ )
+ {
+ if ( 0 <= rTypeArray[j] && rTypeArray[j] < NF_KEYWORD_ENTRIES_COUNT )
+ {
+ aStr.append( rKeywords[rTypeArray[j]] );
+ if( NF_KEY_NNNN == rTypeArray[j] )
+ {
+ aStr.append( rLocWrp.getLongDateDayOfWeekSep() );
+ }
+ switch (rTypeArray[j])
+ {
+ case NF_KEY_EC:
+ case NF_KEY_EEC:
+ case NF_KEY_R:
+ case NF_KEY_RR:
+ // Implicit secondary (non-gregorian) calendar.
+ // Currently only for ja-JP.
+ /* TODO: same for all locales in
+ * LocaleDataWrapper::doesSecondaryCalendarUseEC() ?
+ * Should split the locales off that then. */
+ if (!nCalendarID)
+ {
+ const LanguageType nLang = MsLangId::getRealLanguage( nOriginalLang);
+ if (nLang == LANGUAGE_JAPANESE)
+ nCalendarID = kCalGengou;
+ }
+ break;
+ default:
+ ; // nothing
+ }
+ }
+ else
+ {
+ switch ( rTypeArray[j] )
+ {
+ case NF_SYMBOLTYPE_DECSEP :
+ aStr.append( rLocWrp.getNumDecimalSep() );
+ break;
+ case NF_SYMBOLTYPE_THSEP :
+ aStr.append( rLocWrp.getNumThousandSep() );
+ break;
+ case NF_SYMBOLTYPE_EXP :
+ aStr.append( rKeywords[NF_KEY_E] );
+ if ( rStrArray[j].getLength() > 1 && rStrArray[j][1] == '+' )
+ aStr.append( "+" );
+ else
+ // tdf#102370: Excel code for exponent without sign
+ aStr.append( "-" );
+ break;
+ case NF_SYMBOLTYPE_DATESEP :
+ aStr.append( rLocWrp.getDateSep() );
+ break;
+ case NF_SYMBOLTYPE_TIMESEP :
+ aStr.append( rLocWrp.getTimeSep() );
+ break;
+ case NF_SYMBOLTYPE_TIME100SECSEP :
+ aStr.append( rLocWrp.getTime100SecSep() );
+ break;
+ case NF_SYMBOLTYPE_FRACBLANK :
+ case NF_SYMBOLTYPE_STRING :
+ if ( rStrArray[j].getLength() == 1 )
+ {
+ if ( rTypeArray[j] == NF_SYMBOLTYPE_STRING )
+ aStr.append( '\\' );
+ aStr.append( rStrArray[j] );
+ }
+ else
+ {
+ aStr.append( '"' );
+ aStr.append( rStrArray[j] );
+ aStr.append( '"' );
+ }
+ break;
+ case NF_SYMBOLTYPE_CALDEL :
+ if (j + 1 >= nCnt)
+ break;
+ if ( rStrArray[j+1] == "gengou" )
+ {
+ nCalendarID = kCalGengou;
+ }
+ else if ( rStrArray[j+1] == "hijri" )
+ {
+ nCalendarID = 0x0060000;
+ }
+ else if ( rStrArray[j+1] == "buddhist" )
+ {
+ nCalendarID = 0x0070000;
+ }
+ else if ( rStrArray[j+1] == "jewish" )
+ {
+ nCalendarID = 0x0080000;
+ }
+ // Other calendars (see tdf#36038) not corresponding between LibO and XL.
+ // However, skip any calendar modifier and don't write
+ // as format code (if not as literal string).
+ j += 2;
+ break;
+ case NF_SYMBOLTYPE_CURREXT :
+ nPosHaveLCID = aStr.getLength();
+ aStr.append( rStrArray[j] );
+ break;
+ default:
+ aStr.append( rStrArray[j] );
+ }
+ }
+ }
+ }
+ sal_uInt32 nAlphabetID = 0x0000000; // Excel ID of alphabet used for numerals see tdf#36038
+ LanguageType nLanguageID = LANGUAGE_SYSTEM;
+ if ( aNatNum.IsComplete() )
+ {
+ nLanguageID = MsLangId::getRealLanguage( aNatNum.GetLang());
+ if ( aNatNum.GetNatNum() == 0 )
+ {
+ nAlphabetID = 0x01000000; // Arabic-european numerals
+ }
+ else if ( nCalendarID > 0 || aNatNum.GetDBNum() == 0 || aNatNum.GetDBNum() == aNatNum.GetNatNum() )
+ { // if no DBNum code then use long LCID
+ // if DBNum value != NatNum value, use DBNum and not extended LCID
+ // if calendar, then DBNum will be removed
+ LanguageType pri = primary(nLanguageID);
+ if ( pri == LANGUAGE_ARABIC_PRIMARY_ONLY )
+ nAlphabetID = 0x02000000; // Arabic-indic numerals
+ else if ( pri == primary(LANGUAGE_FARSI) )
+ nAlphabetID = 0x03000000; // Farsi numerals
+ else if ( pri.anyOf(
+ primary(LANGUAGE_HINDI),
+ primary(LANGUAGE_MARATHI),
+ primary(LANGUAGE_NEPALI) ))
+ nAlphabetID = 0x04000000; // Devanagari numerals
+ else if ( pri == primary(LANGUAGE_BENGALI) )
+ nAlphabetID = 0x05000000; // Bengali numerals
+ else if ( pri == primary(LANGUAGE_PUNJABI) )
+ {
+ if ( nLanguageID == LANGUAGE_PUNJABI_ARABIC_LSO )
+ nAlphabetID = 0x02000000; // Arabic-indic numerals
+ else
+ nAlphabetID = 0x06000000; // Punjabi numerals
+ }
+ else if ( pri == primary(LANGUAGE_GUJARATI) )
+ nAlphabetID = 0x07000000; // Gujarati numerals
+ else if ( pri == primary(LANGUAGE_ODIA))
+ nAlphabetID = 0x08000000; // Odia (Oriya) numerals
+ else if ( pri == primary(LANGUAGE_TAMIL))
+ nAlphabetID = 0x09000000; // Tamil numerals
+ else if ( pri == primary(LANGUAGE_TELUGU))
+ nAlphabetID = 0x0A000000; // Telugu numerals
+ else if ( pri == primary(LANGUAGE_KANNADA))
+ nAlphabetID = 0x0B000000; // Kannada numerals
+ else if ( pri == primary(LANGUAGE_MALAYALAM))
+ nAlphabetID = 0x0C000000; // Malayalam numerals
+ else if ( pri == primary(LANGUAGE_THAI))
+ {
+ // The Thai T NatNum modifier during Xcl export.
+ if ( rKeywords[NF_KEY_THAI_T] == "T" )
+ nAlphabetID = 0x0D000000; // Thai numerals
+ }
+ else if ( pri == primary(LANGUAGE_LAO))
+ nAlphabetID = 0x0E000000; // Lao numerals
+ else if ( pri == primary(LANGUAGE_TIBETAN))
+ nAlphabetID = 0x0F000000; // Tibetan numerals
+ else if ( pri == primary(LANGUAGE_BURMESE))
+ nAlphabetID = 0x10000000; // Burmese numerals
+ else if ( pri == primary(LANGUAGE_TIGRIGNA_ETHIOPIA))
+ nAlphabetID = 0x11000000; // Tigrigna numerals
+ else if ( pri == primary(LANGUAGE_KHMER))
+ nAlphabetID = 0x12000000; // Khmer numerals
+ else if ( pri == primary(LANGUAGE_MONGOLIAN_MONGOLIAN_MONGOLIA))
+ {
+ if ( nLanguageID != LANGUAGE_MONGOLIAN_CYRILLIC_MONGOLIA
+ && nLanguageID != LANGUAGE_MONGOLIAN_CYRILLIC_LSO )
+ nAlphabetID = 0x13000000; // Mongolian numerals
+ }
+ // CJK numerals
+ else if ( pri == primary(LANGUAGE_JAPANESE))
+ {
+ nAlphabetID = 0x1B;
+ lcl_incrementAlphabetWithNatNum ( nAlphabetID, aNatNum.GetNatNum() );
+ }
+ else if ( pri == primary(LANGUAGE_CHINESE))
+ {
+ if ( nLanguageID == LANGUAGE_CHINESE_TRADITIONAL
+ || nLanguageID == LANGUAGE_CHINESE_HONGKONG
+ || nLanguageID == LANGUAGE_CHINESE_MACAU )
+ {
+ nAlphabetID = 0x21;
+ lcl_incrementAlphabetWithNatNum ( nAlphabetID, aNatNum.GetNatNum() );
+ }
+ else // LANGUAGE_CHINESE_SIMPLIFIED
+ {
+ nAlphabetID = 0x1E;
+ lcl_incrementAlphabetWithNatNum ( nAlphabetID, aNatNum.GetNatNum() );
+ }
+ }
+ else if ( pri == primary(LANGUAGE_KOREAN))
+ {
+ if ( aNatNum.GetNatNum() == 9 ) // Hangul
+ {
+ nAlphabetID = 0x27000000;
+ }
+ else
+ {
+ nAlphabetID = 0x24;
+ lcl_incrementAlphabetWithNatNum ( nAlphabetID, aNatNum.GetNatNum() );
+ }
+ }
+ }
+ // Add LCID to DBNum
+ if ( aNatNum.GetDBNum() > 0 && nLanguageID == LANGUAGE_SYSTEM )
+ nLanguageID = MsLangId::getRealLanguage( aNatNum.GetLang());
+ }
+ else if (nPosHaveLCID < 0)
+ {
+ // Do not insert a duplicated LCID that was already given with a
+ // currency format as [$R-1C09]
+ if (!bSystemLanguage && nOriginalLang != LANGUAGE_DONTKNOW)
+ {
+ // Explicit locale, write only to the first subformat.
+ if (n == 0)
+ nLanguageID = MsLangId::getRealLanguage( nOriginalLang);
+ }
+ else if (bSystemLanguage && maLocale.meLanguageWithoutLocaleData != LANGUAGE_DONTKNOW)
+ {
+ // Explicit locale but no locale data thus assigned to system
+ // locale, preserve for roundtrip, write only to the first
+ // subformat.
+ if (n == 0)
+ nLanguageID = maLocale.meLanguageWithoutLocaleData;
+ }
+ }
+ if ( nCalendarID > 0 )
+ { // Add alphabet and language to calendar
+ if ( nAlphabetID == 0 )
+ nAlphabetID = 0x01000000;
+ if ( nLanguageID == LANGUAGE_SYSTEM && nOriginalLang != LANGUAGE_DONTKNOW )
+ nLanguageID = nOriginalLang;
+ }
+ lcl_insertLCID( aStr, nAlphabetID + nCalendarID + static_cast<sal_uInt16>(nLanguageID), nPosInsertLCID,
+ bDBNumInserted);
+ }
+ for ( ; nSub<4 && bDefault[nSub]; ++nSub )
+ { // append empty subformats
+ aStr.append( ';' );
+ }
+ return aStr.makeStringAndClear();
+}
+
+OUString SvNumberformat::ImpGetNatNumString( const SvNumberNatNum& rNum,
+ sal_Int64 nVal, sal_uInt16 nMinDigits ) const
+{
+ OUString aStr;
+ if ( nMinDigits )
+ {
+ if ( nMinDigits == 2 )
+ {
+ // speed up the most common case
+ if ( 0 <= nVal && nVal < 10 )
+ {
+ sal_Unicode aBuf[2];
+ aBuf[0] = '0';
+ aBuf[1] = '0' + nVal;
+ aStr = OUString(aBuf, SAL_N_ELEMENTS(aBuf));
+ }
+ else
+ {
+ aStr = OUString::number( nVal );
+ }
+ }
+ else
+ {
+ OUString aValStr( OUString::number( nVal ) );
+ if ( aValStr.getLength() >= nMinDigits )
+ {
+ aStr = aValStr;
+ }
+ else
+ {
+ OUStringBuffer aBuf;
+ for(sal_Int32 index = 0; index < nMinDigits - aValStr.getLength(); ++index)
+ {
+ aBuf.append('0');
+ }
+ aBuf.append(aValStr);
+ aStr = aBuf.makeStringAndClear();
+ }
+ }
+ }
+ else
+ {
+ aStr = OUString::number( nVal );
+ }
+ return impTransliterate(aStr, rNum);
+}
+
+OUString SvNumberformat::impTransliterateImpl(const OUString& rStr,
+ const SvNumberNatNum& rNum ) const
+{
+ css::lang::Locale aLocale( LanguageTag( rNum.GetLang() ).getLocale() );
+ return GetFormatter().GetNatNum()->getNativeNumberStringParams(rStr, aLocale, rNum.GetNatNum(),
+ rNum.GetParams());
+}
+
+void SvNumberformat::impTransliterateImpl(OUStringBuffer& rStr,
+ const SvNumberNatNum& rNum ) const
+{
+ css::lang::Locale aLocale( LanguageTag( rNum.GetLang() ).getLocale() );
+
+ rStr = GetFormatter().GetNatNum()->getNativeNumberStringParams(
+ OUString::unacquired(rStr), aLocale, rNum.GetNatNum(), rNum.GetParams());
+}
+
+OUString SvNumberformat::impTransliterateImpl(const OUString& rStr,
+ const SvNumberNatNum& rNum,
+ const sal_uInt16 nDateKey) const
+{
+ // no KEYWORD=argument list in NatNum12
+ if (rNum.GetParams().indexOf('=') == -1)
+ return impTransliterateImpl( rStr, rNum);
+
+ const NfKeywordTable & rKeywords = rScan.GetKeywords();
+
+ // Format: KEYWORD=numbertext_prefix, ..., for example:
+ // [NatNum12 YYYY=title ordinal,MMMM=article, D=ordinal-number]
+ sal_Int32 nField = -1;
+ do
+ {
+ nField = rNum.GetParams().indexOf(OUStringConcatenation(rKeywords[nDateKey] + "="), ++nField);
+ }
+ while (nField != -1 && nField != 0 &&
+ (rNum.GetParams()[nField - 1] != ',' &&
+ rNum.GetParams()[nField - 1] != ' '));
+
+ // no format specified for actual keyword
+ if (nField == -1)
+ return rStr;
+
+ sal_Int32 nKeywordLen = rKeywords[nDateKey].getLength() + 1;
+ sal_Int32 nFieldEnd = rNum.GetParams().indexOf(',', nField);
+
+ if (nFieldEnd == -1)
+ nFieldEnd = rNum.GetParams().getLength();
+
+ css::lang::Locale aLocale( LanguageTag( rNum.GetLang() ).getLocale() );
+
+ return GetFormatter().GetNatNum()->getNativeNumberStringParams(
+ rStr, aLocale, rNum.GetNatNum(),
+ rNum.GetParams().copy(nField + nKeywordLen, nFieldEnd - nField - nKeywordLen));
+}
+
+void SvNumberformat::GetNatNumXml( css::i18n::NativeNumberXmlAttributes2& rAttr,
+ sal_uInt16 nNumFor ) const
+{
+ if ( nNumFor <= 3 )
+ {
+ const SvNumberNatNum& rNum = NumFor[nNumFor].GetNatNum();
+ if ( rNum.IsSet() )
+ {
+ css::lang::Locale aLocale(
+ LanguageTag( rNum.GetLang() ).getLocale() );
+
+ /* TODO: a new XNativeNumberSupplier2::convertToXmlAttributes()
+ * should rather return NativeNumberXmlAttributes2 and places
+ * adapted, and whether to fill Spellout or something different
+ * should be internal there. */
+ css::i18n::NativeNumberXmlAttributes aTmp(
+ GetFormatter().GetNatNum()->convertToXmlAttributes(
+ aLocale, rNum.GetNatNum()));
+ rAttr.Locale = aTmp.Locale;
+ rAttr.Format = aTmp.Format;
+ rAttr.Style = aTmp.Style;
+ if ( NatNumTakesParameters(rNum.GetNatNum()) )
+ {
+ // NatNum12 spell out numbers, dates and money amounts
+ rAttr.Spellout = rNum.GetParams();
+ // Mutually exclusive.
+ rAttr.Format.clear();
+ rAttr.Style.clear();
+ }
+ else
+ {
+ rAttr.Spellout.clear();
+ }
+ }
+ else
+ {
+ rAttr = css::i18n::NativeNumberXmlAttributes2();
+ }
+ }
+ else
+ {
+ rAttr = css::i18n::NativeNumberXmlAttributes2();
+ }
+}
+
+// static
+bool SvNumberformat::HasStringNegativeSign( const OUString& rStr )
+{
+ // For Sign '-' needs to be at the start or at the end of the string (blanks ignored)
+ sal_Int32 nLen = rStr.getLength();
+ if ( !nLen )
+ {
+ return false;
+ }
+ const sal_Unicode* const pBeg = rStr.getStr();
+ const sal_Unicode* const pEnd = pBeg + nLen;
+ const sal_Unicode* p = pBeg;
+ do
+ { // Start
+ if ( *p == '-' )
+ {
+ return true;
+ }
+ }
+ while ( *p == ' ' && ++p < pEnd );
+
+ p = pEnd - 1;
+
+ do
+ { // End
+ if ( *p == '-' )
+ {
+ return true;
+ }
+ }
+ while ( *p == ' ' && pBeg < --p );
+ return false;
+}
+
+// static
+bool SvNumberformat::IsInQuote( const OUString& rStr, sal_Int32 nPos,
+ sal_Unicode cQuote, sal_Unicode cEscIn, sal_Unicode cEscOut )
+{
+ sal_Int32 nLen = rStr.getLength();
+ if ( nPos >= nLen )
+ {
+ return false;
+ }
+ const sal_Unicode* p0 = rStr.getStr();
+ const sal_Unicode* p = p0;
+ const sal_Unicode* p1 = p0 + nPos;
+ bool bQuoted = false;
+ while ( p <= p1 )
+ {
+ if ( *p == cQuote )
+ {
+ if ( p == p0 )
+ {
+ bQuoted = true;
+ }
+ else if ( bQuoted )
+ {
+ if ( *(p-1) != cEscIn )
+ {
+ bQuoted = false;
+ }
+ }
+ else
+ {
+ if ( *(p-1) != cEscOut )
+ {
+ bQuoted = true;
+ }
+ }
+ }
+ p++;
+ }
+ return bQuoted;
+}
+
+// static
+sal_Int32 SvNumberformat::GetQuoteEnd( const OUString& rStr, sal_Int32 nPos,
+ sal_Unicode cQuote, sal_Unicode cEscIn )
+{
+ if ( nPos < 0 )
+ {
+ return -1;
+ }
+ sal_Int32 nLen = rStr.getLength();
+ if ( nPos >= nLen )
+ {
+ return -1;
+ }
+ if ( !IsInQuote( rStr, nPos, cQuote, cEscIn ) )
+ {
+ if ( rStr[ nPos ] == cQuote )
+ {
+ return nPos; // Closing cQuote
+ }
+ return -1;
+ }
+ const sal_Unicode* p0 = rStr.getStr();
+ const sal_Unicode* p = p0 + nPos;
+ const sal_Unicode* p1 = p0 + nLen;
+ while ( p < p1 )
+ {
+ if ( *p == cQuote && p > p0 && *(p-1) != cEscIn )
+ {
+ return sal::static_int_cast< sal_Int32 >(p - p0);
+ }
+ p++;
+ }
+ return nLen; // End of String
+}
+
+sal_uInt16 SvNumberformat::GetNumForNumberElementCount( sal_uInt16 nNumFor ) const
+{
+ if ( nNumFor < 4 )
+ {
+ sal_uInt16 nCnt = NumFor[nNumFor].GetCount();
+ return nCnt - ImpGetNumForStringElementCount( nNumFor );
+ }
+ return 0;
+}
+
+sal_uInt16 SvNumberformat::ImpGetNumForStringElementCount( sal_uInt16 nNumFor ) const
+{
+ sal_uInt16 nCnt = 0;
+ sal_uInt16 nNumForCnt = NumFor[nNumFor].GetCount();
+ auto& rTypeArray = NumFor[nNumFor].Info().nTypeArray;
+ for ( sal_uInt16 j=0; j<nNumForCnt; ++j )
+ {
+ switch ( rTypeArray[j] )
+ {
+ case NF_SYMBOLTYPE_STRING:
+ case NF_SYMBOLTYPE_CURRENCY:
+ case NF_SYMBOLTYPE_DATESEP:
+ case NF_SYMBOLTYPE_TIMESEP:
+ case NF_SYMBOLTYPE_TIME100SECSEP:
+ case NF_SYMBOLTYPE_PERCENT:
+ ++nCnt;
+ break;
+ }
+ }
+ return nCnt;
+}
+
+bool SvNumberformat::IsMinuteSecondFormat() const
+{
+ if (GetMaskedType() != SvNumFormatType::TIME)
+ return false;
+
+ constexpr sal_uInt16 k00 = 0x00; // Nada, Nilch
+ constexpr sal_uInt16 kLB = 0x01; // '[' Left Bracket
+ constexpr sal_uInt16 kRB = 0x02; // ']' Right Bracket
+ constexpr sal_uInt16 kMM = 0x04; // M or MM
+ constexpr sal_uInt16 kTS = 0x08; // Time Separator
+ constexpr sal_uInt16 kSS = 0x10; // S or SS
+#define HAS_MINUTE_SECOND(state) ((state) == (kMM|kTS|kSS) || (state) == (kLB|kMM|kRB|kTS|kSS))
+ // Also (kMM|kTS|kLB|kSS|kRB) but those are the same bits.
+
+ sal_uInt16 nState = k00;
+ bool bSep = false;
+ sal_uInt16 nNumForCnt = NumFor[0].GetCount();
+ auto const & rTypeArray = NumFor[0].Info().nTypeArray;
+ for (sal_uInt16 j=0; j < nNumForCnt; ++j)
+ {
+ switch (rTypeArray[j])
+ {
+ case NF_SYMBOLTYPE_DEL:
+ {
+ // '[' or ']' before/after MM or SS
+ const OUString& rStr = NumFor[0].Info().sStrArray[j];
+ if (rStr == "[")
+ {
+ if (nState != k00 && nState != (kMM|kTS))
+ return false;
+ nState |= kLB;
+ }
+ else if (rStr == "]")
+ {
+ if (nState != (kLB|kMM) && nState != (kMM|kTS|kLB|kSS))
+ return false;
+ nState |= kRB;
+ }
+ else
+ return false;
+ }
+ break;
+ case NF_KEY_MI:
+ case NF_KEY_MMI:
+ if (nState != k00 && nState != kLB)
+ return false;
+ nState |= kMM;
+ break;
+ case NF_SYMBOLTYPE_TIMESEP:
+ if (nState != kMM && nState != (kLB|kMM|kRB))
+ return false;
+ nState |= kTS;
+ break;
+ case NF_KEY_S:
+ case NF_KEY_SS:
+ if (nState != (kMM|kTS) && nState != (kLB|kMM|kRB|kTS) && nState != (kMM|kTS|kLB))
+ return false;
+ nState |= kSS;
+ break;
+ case NF_SYMBOLTYPE_TIME100SECSEP:
+ // Trailing fraction of seconds allowed.
+ if (!HAS_MINUTE_SECOND(nState))
+ return false;
+ bSep = true;
+ break;
+ case NF_SYMBOLTYPE_DIGIT:
+ if (!bSep)
+ return false;
+ break;
+ case NF_SYMBOLTYPE_STRING:
+ // nothing, display literal
+ break;
+ default:
+ return false;
+ }
+ }
+ return HAS_MINUTE_SECOND(nState);
+#undef HAS_MINUTE_SECOND
+}
+
+OUString SvNumberformat::GetFormatStringForTimePrecision( int nPrecision ) const
+{
+ OUStringBuffer sString;
+ using comphelper::string::padToLength;
+
+ sal_uInt16 nNumForCnt = NumFor[0].GetCount();
+ auto const & rTypeArray = NumFor[0].Info().nTypeArray;
+ for (sal_uInt16 j=0; j < nNumForCnt; ++j)
+ {
+ switch (rTypeArray[j])
+ {
+ case NF_KEY_S :
+ case NF_KEY_SS:
+ sString.append( NumFor[0].Info().sStrArray[j] );
+ if ( j > 0 && rTypeArray[j-1] == NF_SYMBOLTYPE_DEL && j < nNumForCnt-1 )
+ {
+ j++;
+ sString.append( NumFor[0].Info().sStrArray[j] );
+ }
+ if (nPrecision > 0)
+ {
+ sString.append( rLoc().getTime100SecSep() );
+ padToLength(sString, sString.getLength() + nPrecision, '0');
+ }
+ break;
+ case NF_SYMBOLTYPE_TIME100SECSEP:
+ case NF_SYMBOLTYPE_DIGIT:
+ break;
+ case NF_SYMBOLTYPE_STRING:
+ sString.append( "\"" );
+ [[fallthrough]];
+ default:
+ sString.append( NumFor[0].Info().sStrArray[j] );
+ if (rTypeArray[j] == NF_SYMBOLTYPE_STRING)
+ {
+ sString.append( "\"" );
+ }
+ }
+ }
+
+ return sString.makeStringAndClear();
+}
+
+sal_uInt16 SvNumberformat::GetThousandDivisorPrecision( sal_uInt16 nIx ) const
+{
+ if (nIx >= 4)
+ return 0;
+
+ const ImpSvNumberformatInfo& rInfo = NumFor[nIx].Info();
+
+ if (rInfo.eScannedType != SvNumFormatType::NUMBER && rInfo.eScannedType != SvNumFormatType::CURRENCY)
+ return 0;
+
+ if (rInfo.nThousand == FLAG_STANDARD_IN_FORMAT)
+ return SvNumberFormatter::UNLIMITED_PRECISION;
+
+ return rInfo.nThousand * 3;
+}
+
+const CharClass& SvNumberformat::rChrCls() const
+{
+ return rScan.GetChrCls();
+}
+
+const LocaleDataWrapper& SvNumberformat::rLoc() const
+{
+ return rScan.GetLoc();
+}
+
+CalendarWrapper& SvNumberformat::GetCal() const
+{
+ return rScan.GetCal();
+}
+
+const SvNumberFormatter& SvNumberformat::GetFormatter() const
+{
+ return *rScan.GetNumberformatter();
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/svl/source/numbers/zforscan.cxx b/svl/source/numbers/zforscan.cxx
new file mode 100644
index 000000000..a5f256376
--- /dev/null
+++ b/svl/source/numbers/zforscan.cxx
@@ -0,0 +1,3322 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed
+ * with this work for additional information regarding copyright
+ * ownership. The ASF licenses this file to you under the Apache
+ * License, Version 2.0 (the "License"); you may not use this file
+ * except in compliance with the License. You may obtain a copy of
+ * the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+
+#include <stdlib.h>
+#include <comphelper/string.hxx>
+#include <sal/log.hxx>
+#include <tools/debug.hxx>
+#include <i18nlangtag/mslangid.hxx>
+#include <unotools/charclass.hxx>
+#include <unotools/localedatawrapper.hxx>
+#include <com/sun/star/i18n/NumberFormatCode.hpp>
+#include <com/sun/star/i18n/NumberFormatMapper.hpp>
+
+#include <svl/zforlist.hxx>
+#include <svl/zformat.hxx>
+#include <unotools/digitgroupingiterator.hxx>
+
+#include "zforscan.hxx"
+
+#include <svl/nfsymbol.hxx>
+using namespace svt;
+
+const sal_Unicode cNoBreakSpace = 0xA0;
+const sal_Unicode cNarrowNoBreakSpace = 0x202F;
+
+const int MaxCntPost = 20; //max dec places allow by rtl_math_round
+
+const NfKeywordTable ImpSvNumberformatScan::sEnglishKeyword =
+{ // Syntax keywords in English (USA)
+ //! All keywords MUST be UPPERCASE! In same order as NfKeywordIndex
+ "", // NF_KEY_NONE 0
+ "E", // NF_KEY_E Exponent
+ "AM/PM", // NF_KEY_AMPM AM/PM
+ "A/P", // NF_KEY_AP AM/PM short
+ "M", // NF_KEY_MI Minute
+ "MM", // NF_KEY_MMI Minute 02
+ "M", // NF_KEY_M month (!)
+ "MM", // NF_KEY_MM month 02 (!)
+ "MMM", // NF_KEY_MMM month short name
+ "MMMM", // NF_KEY_MMMM month long name
+ "MMMMM", // NF_KEY_MMMMM first letter of month name
+ "H", // NF_KEY_H hour
+ "HH", // NF_KEY_HH hour 02
+ "S", // NF_KEY_S Second
+ "SS", // NF_KEY_SS Second 02
+ "Q", // NF_KEY_Q Quarter short 'Q'
+ "QQ", // NF_KEY_QQ Quarter long
+ "D", // NF_KEY_D day of month
+ "DD", // NF_KEY_DD day of month 02
+ "DDD", // NF_KEY_DDD day of week short
+ "DDDD", // NF_KEY_DDDD day of week long
+ "YY", // NF_KEY_YY year two digits
+ "YYYY", // NF_KEY_YYYY year four digits
+ "NN", // NF_KEY_NN Day of week short
+ "NNN", // NF_KEY_NNN Day of week long
+ "NNNN", // NF_KEY_NNNN Day of week long incl. separator
+ "AAA", // NF_KEY_AAA
+ "AAAA", // NF_KEY_AAAA
+ "E", // NF_KEY_EC
+ "EE", // NF_KEY_EEC
+ "G", // NF_KEY_G
+ "GG", // NF_KEY_GG
+ "GGG", // NF_KEY_GGG
+ "R", // NF_KEY_R
+ "RR", // NF_KEY_RR
+ "WW", // NF_KEY_WW Week of year
+ "t", // NF_KEY_THAI_T Thai T modifier, speciality of Thai Excel, only
+ // used with Thai locale and converted to [NatNum1], only
+ // exception as lowercase
+ "CCC", // NF_KEY_CCC Currency abbreviation
+ "BOOLEAN", // NF_KEY_BOOLEAN boolean
+ "GENERAL", // NF_KEY_GENERAL General / Standard
+
+ // Reserved words translated and color names follow:
+ "TRUE", // NF_KEY_TRUE boolean true
+ "FALSE", // NF_KEY_FALSE boolean false
+ "COLOR", // NF_KEY_COLOR color
+ // colours
+ "BLACK", // NF_KEY_BLACK
+ "BLUE", // NF_KEY_BLUE
+ "GREEN", // NF_KEY_GREEN
+ "CYAN", // NF_KEY_CYAN
+ "RED", // NF_KEY_RED
+ "MAGENTA", // NF_KEY_MAGENTA
+ "BROWN", // NF_KEY_BROWN
+ "GREY", // NF_KEY_GREY
+ "YELLOW", // NF_KEY_YELLOW
+ "WHITE" // NF_KEY_WHITE
+};
+
+const ::std::vector<Color> ImpSvNumberformatScan::StandardColor{
+ COL_BLACK, COL_LIGHTBLUE, COL_LIGHTGREEN, COL_LIGHTCYAN, COL_LIGHTRED,
+ COL_LIGHTMAGENTA, COL_BROWN, COL_GRAY, COL_YELLOW, COL_WHITE
+};
+
+// This vector will hold *only* the color names in German language.
+static const std::u16string_view& GermanColorName(size_t i)
+{
+ static const std::u16string_view sGermanColorNames[]{ u"FARBE", u"SCHWARZ", u"BLAU",
+ u"GRÜN", u"CYAN", u"ROT",
+ u"MAGENTA", u"BRAUN", u"GRAU",
+ u"GELB", u"WEISS" };
+ assert(i < SAL_N_ELEMENTS(sGermanColorNames));
+ return sGermanColorNames[i];
+}
+
+ImpSvNumberformatScan::ImpSvNumberformatScan( SvNumberFormatter* pFormatterP )
+ : maNullDate( 30, 12, 1899)
+ , eNewLnge(LANGUAGE_DONTKNOW)
+ , eTmpLnge(LANGUAGE_DONTKNOW)
+ , nCurrPos(-1)
+ , meKeywordLocalization(KeywordLocalization::AllowEnglish)
+{
+ pFormatter = pFormatterP;
+ xNFC = css::i18n::NumberFormatMapper::create( pFormatter->GetComponentContext() );
+ bConvertMode = false;
+ mbConvertDateOrder = false;
+ bConvertSystemToSystem = false;
+ bKeywordsNeedInit = true; // locale dependent and not locale dependent keywords
+ bCompatCurNeedInit = true; // locale dependent compatibility currency strings
+
+ static_assert( NF_KEY_BLACK - NF_KEY_COLOR == 1, "bad FARBE(COLOR), SCHWARZ(BLACK) sequence");
+ static_assert( NF_KEY_FIRSTCOLOR - NF_KEY_COLOR == 1, "bad color sequence");
+ static_assert( NF_MAX_DEFAULT_COLORS + 1 == 11, "bad color count");
+ static_assert( NF_KEY_WHITE - NF_KEY_COLOR + 1 == 11, "bad color sequence count");
+
+ nStandardPrec = 2;
+
+ Reset();
+}
+
+ImpSvNumberformatScan::~ImpSvNumberformatScan()
+{
+ Reset();
+}
+
+void ImpSvNumberformatScan::ChangeIntl( KeywordLocalization eKeywordLocalization )
+{
+ meKeywordLocalization = eKeywordLocalization;
+ bKeywordsNeedInit = true;
+ bCompatCurNeedInit = true;
+ // may be initialized by InitSpecialKeyword()
+ sKeyword[NF_KEY_TRUE].clear();
+ sKeyword[NF_KEY_FALSE].clear();
+}
+
+void ImpSvNumberformatScan::InitSpecialKeyword( NfKeywordIndex eIdx ) const
+{
+ switch ( eIdx )
+ {
+ case NF_KEY_TRUE :
+ const_cast<ImpSvNumberformatScan*>(this)->sKeyword[NF_KEY_TRUE] =
+ pFormatter->GetCharClass()->uppercase( pFormatter->GetLocaleData()->getTrueWord() );
+ if ( sKeyword[NF_KEY_TRUE].isEmpty() )
+ {
+ SAL_WARN( "svl.numbers", "InitSpecialKeyword: TRUE_WORD?" );
+ const_cast<ImpSvNumberformatScan*>(this)->sKeyword[NF_KEY_TRUE] = sEnglishKeyword[NF_KEY_TRUE];
+ }
+ break;
+ case NF_KEY_FALSE :
+ const_cast<ImpSvNumberformatScan*>(this)->sKeyword[NF_KEY_FALSE] =
+ pFormatter->GetCharClass()->uppercase( pFormatter->GetLocaleData()->getFalseWord() );
+ if ( sKeyword[NF_KEY_FALSE].isEmpty() )
+ {
+ SAL_WARN( "svl.numbers", "InitSpecialKeyword: FALSE_WORD?" );
+ const_cast<ImpSvNumberformatScan*>(this)->sKeyword[NF_KEY_FALSE] = sEnglishKeyword[NF_KEY_FALSE];
+ }
+ break;
+ default:
+ SAL_WARN( "svl.numbers", "InitSpecialKeyword: unknown request" );
+ }
+}
+
+void ImpSvNumberformatScan::InitCompatCur() const
+{
+ ImpSvNumberformatScan* pThis = const_cast<ImpSvNumberformatScan*>(this);
+ // currency symbol for old style ("automatic") compatibility format codes
+ pFormatter->GetCompatibilityCurrency( pThis->sCurSymbol, pThis->sCurAbbrev );
+ // currency symbol upper case
+ pThis->sCurString = pFormatter->GetCharClass()->uppercase( sCurSymbol );
+ bCompatCurNeedInit = false;
+}
+
+void ImpSvNumberformatScan::InitKeywords() const
+{
+ if ( !bKeywordsNeedInit )
+ return ;
+ const_cast<ImpSvNumberformatScan*>(this)->SetDependentKeywords();
+ bKeywordsNeedInit = false;
+}
+
+/** Extract the name of General, Standard, Whatever, ignoring leading modifiers
+ such as [NatNum1]. */
+static OUString lcl_extractStandardGeneralName( const OUString & rCode )
+{
+ OUString aStr;
+ const sal_Unicode* p = rCode.getStr();
+ const sal_Unicode* const pStop = p + rCode.getLength();
+ const sal_Unicode* pBeg = p; // name begins here
+ bool bMod = false;
+ bool bDone = false;
+ while (p < pStop && !bDone)
+ {
+ switch (*p)
+ {
+ case '[':
+ bMod = true;
+ break;
+ case ']':
+ if (bMod)
+ {
+ bMod = false;
+ pBeg = p+1;
+ }
+ // else: would be a locale data error, easily to be spotted in
+ // UI dialog
+ break;
+ case ';':
+ if (!bMod)
+ {
+ bDone = true;
+ --p; // put back, increment by one follows
+ }
+ break;
+ }
+ ++p;
+ if (bMod)
+ {
+ pBeg = p;
+ }
+ }
+ if (pBeg < p)
+ {
+ aStr = rCode.copy( pBeg - rCode.getStr(), p - pBeg);
+ }
+ return aStr;
+}
+
+void ImpSvNumberformatScan::SetDependentKeywords()
+{
+ using namespace ::com::sun::star;
+ using namespace ::com::sun::star::uno;
+
+ const CharClass* pCharClass = pFormatter->GetCharClass();
+ const LocaleDataWrapper* pLocaleData = pFormatter->GetLocaleData();
+ // #80023# be sure to generate keywords for the loaded Locale, not for the
+ // requested Locale, otherwise number format codes might not match
+ const LanguageTag& rLoadedLocale = pLocaleData->getLoadedLanguageTag();
+ LanguageType eLang = rLoadedLocale.getLanguageType( false);
+
+ bool bL10n = (meKeywordLocalization != KeywordLocalization::EnglishOnly);
+ if (bL10n)
+ {
+ // Check if this actually is a locale that uses any localized keywords,
+ // if not then disable localized keywords completely.
+ if ( !eLang.anyOf( LANGUAGE_GERMAN,
+ LANGUAGE_GERMAN_SWISS,
+ LANGUAGE_GERMAN_AUSTRIAN,
+ LANGUAGE_GERMAN_LUXEMBOURG,
+ LANGUAGE_GERMAN_LIECHTENSTEIN,
+ LANGUAGE_DUTCH,
+ LANGUAGE_DUTCH_BELGIAN,
+ LANGUAGE_FRENCH,
+ LANGUAGE_FRENCH_BELGIAN,
+ LANGUAGE_FRENCH_CANADIAN,
+ LANGUAGE_FRENCH_SWISS,
+ LANGUAGE_FRENCH_LUXEMBOURG,
+ LANGUAGE_FRENCH_MONACO,
+ LANGUAGE_FINNISH,
+ LANGUAGE_ITALIAN,
+ LANGUAGE_ITALIAN_SWISS,
+ LANGUAGE_DANISH,
+ LANGUAGE_NORWEGIAN,
+ LANGUAGE_NORWEGIAN_BOKMAL,
+ LANGUAGE_NORWEGIAN_NYNORSK,
+ LANGUAGE_SWEDISH,
+ LANGUAGE_SWEDISH_FINLAND,
+ LANGUAGE_PORTUGUESE,
+ LANGUAGE_PORTUGUESE_BRAZILIAN,
+ LANGUAGE_SPANISH_MODERN,
+ LANGUAGE_SPANISH_DATED,
+ LANGUAGE_SPANISH_MEXICAN,
+ LANGUAGE_SPANISH_GUATEMALA,
+ LANGUAGE_SPANISH_COSTARICA,
+ LANGUAGE_SPANISH_PANAMA,
+ LANGUAGE_SPANISH_DOMINICAN_REPUBLIC,
+ LANGUAGE_SPANISH_VENEZUELA,
+ LANGUAGE_SPANISH_COLOMBIA,
+ LANGUAGE_SPANISH_PERU,
+ LANGUAGE_SPANISH_ARGENTINA,
+ LANGUAGE_SPANISH_ECUADOR,
+ LANGUAGE_SPANISH_CHILE,
+ LANGUAGE_SPANISH_URUGUAY,
+ LANGUAGE_SPANISH_PARAGUAY,
+ LANGUAGE_SPANISH_BOLIVIA,
+ LANGUAGE_SPANISH_EL_SALVADOR,
+ LANGUAGE_SPANISH_HONDURAS,
+ LANGUAGE_SPANISH_NICARAGUA,
+ LANGUAGE_SPANISH_PUERTO_RICO ))
+ {
+ bL10n = false;
+ meKeywordLocalization = KeywordLocalization::EnglishOnly;
+ }
+ }
+
+ // Init the current NfKeywordTable with English keywords.
+ sKeyword = sEnglishKeyword;
+
+ // Set the uppercase localized General name, e.g. Standard -> STANDARD
+ i18n::NumberFormatCode aFormat = xNFC->getFormatCode( NF_NUMBER_STANDARD, rLoadedLocale.getLocale() );
+ sNameStandardFormat = lcl_extractStandardGeneralName( aFormat.Code );
+ sKeyword[NF_KEY_GENERAL] = pCharClass->uppercase( sNameStandardFormat );
+
+ // Thai T NatNum special. Other locale's small letter 't' results in upper
+ // case comparison not matching but length does in conversion mode. Ugly.
+ if (eLang == LANGUAGE_THAI)
+ {
+ sKeyword[NF_KEY_THAI_T] = "T";
+ }
+ else
+ {
+ sKeyword[NF_KEY_THAI_T] = sEnglishKeyword[NF_KEY_THAI_T];
+ }
+
+ // boolean keywords
+ InitSpecialKeyword( NF_KEY_TRUE );
+ InitSpecialKeyword( NF_KEY_FALSE );
+
+ // Boolean equivalent format codes that are written to Excel files, may
+ // have been written to ODF as well, specifically if such loaded Excel file
+ // was saved as ODF, and shall result in proper Boolean again.
+ // "TRUE";"TRUE";"FALSE"
+ sBooleanEquivalent1 = "\"" + sKeyword[NF_KEY_TRUE] + "\";\"" +
+ sKeyword[NF_KEY_TRUE] + "\";\"" + sKeyword[NF_KEY_FALSE] + "\"";
+ // [>0]"TRUE";[<0]"TRUE";"FALSE"
+ sBooleanEquivalent2 = "[>0]\"" + sKeyword[NF_KEY_TRUE] + "\";[<0]\"" +
+ sKeyword[NF_KEY_TRUE] + "\";\"" + sKeyword[NF_KEY_FALSE] + "\"";
+
+ // compatibility currency strings
+ InitCompatCur();
+
+ if (!bL10n)
+ return;
+
+ // All locale dependent keywords overrides follow.
+
+ if ( eLang.anyOf(
+ LANGUAGE_GERMAN,
+ LANGUAGE_GERMAN_SWISS,
+ LANGUAGE_GERMAN_AUSTRIAN,
+ LANGUAGE_GERMAN_LUXEMBOURG,
+ LANGUAGE_GERMAN_LIECHTENSTEIN))
+ {
+ //! all capital letters
+ sKeyword[NF_KEY_M] = "M"; // month 1
+ sKeyword[NF_KEY_MM] = "MM"; // month 01
+ sKeyword[NF_KEY_MMM] = "MMM"; // month Jan
+ sKeyword[NF_KEY_MMMM] = "MMMM"; // month Januar
+ sKeyword[NF_KEY_MMMMM] = "MMMMM"; // month J
+ sKeyword[NF_KEY_H] = "H"; // hour 2
+ sKeyword[NF_KEY_HH] = "HH"; // hour 02
+ sKeyword[NF_KEY_D] = "T";
+ sKeyword[NF_KEY_DD] = "TT";
+ sKeyword[NF_KEY_DDD] = "TTT";
+ sKeyword[NF_KEY_DDDD] = "TTTT";
+ sKeyword[NF_KEY_YY] = "JJ";
+ sKeyword[NF_KEY_YYYY] = "JJJJ";
+ sKeyword[NF_KEY_BOOLEAN] = "LOGISCH";
+ sKeyword[NF_KEY_COLOR] = GermanColorName(NF_KEY_COLOR - NF_KEY_COLOR);
+ sKeyword[NF_KEY_BLACK] = GermanColorName(NF_KEY_BLACK - NF_KEY_COLOR);
+ sKeyword[NF_KEY_BLUE] = GermanColorName(NF_KEY_BLUE - NF_KEY_COLOR);
+ sKeyword[NF_KEY_GREEN] = GermanColorName(NF_KEY_GREEN - NF_KEY_COLOR);
+ sKeyword[NF_KEY_CYAN] = GermanColorName(NF_KEY_CYAN - NF_KEY_COLOR);
+ sKeyword[NF_KEY_RED] = GermanColorName(NF_KEY_RED - NF_KEY_COLOR);
+ sKeyword[NF_KEY_MAGENTA] = GermanColorName(NF_KEY_MAGENTA - NF_KEY_COLOR);
+ sKeyword[NF_KEY_BROWN] = GermanColorName(NF_KEY_BROWN - NF_KEY_COLOR);
+ sKeyword[NF_KEY_GREY] = GermanColorName(NF_KEY_GREY - NF_KEY_COLOR);
+ sKeyword[NF_KEY_YELLOW] = GermanColorName(NF_KEY_YELLOW - NF_KEY_COLOR);
+ sKeyword[NF_KEY_WHITE] = GermanColorName(NF_KEY_WHITE - NF_KEY_COLOR);
+ }
+ else
+ {
+ // day
+ if ( eLang.anyOf(
+ LANGUAGE_ITALIAN,
+ LANGUAGE_ITALIAN_SWISS))
+ {
+ sKeyword[NF_KEY_D] = "G";
+ sKeyword[NF_KEY_DD] = "GG";
+ sKeyword[NF_KEY_DDD] = "GGG";
+ sKeyword[NF_KEY_DDDD] = "GGGG";
+ // must exchange the era code, same as Xcl
+ sKeyword[NF_KEY_G] = "X";
+ sKeyword[NF_KEY_GG] = "XX";
+ sKeyword[NF_KEY_GGG] = "XXX";
+ }
+ else if ( eLang.anyOf(
+ LANGUAGE_FRENCH,
+ LANGUAGE_FRENCH_BELGIAN,
+ LANGUAGE_FRENCH_CANADIAN,
+ LANGUAGE_FRENCH_SWISS,
+ LANGUAGE_FRENCH_LUXEMBOURG,
+ LANGUAGE_FRENCH_MONACO))
+ {
+ sKeyword[NF_KEY_D] = "J";
+ sKeyword[NF_KEY_DD] = "JJ";
+ sKeyword[NF_KEY_DDD] = "JJJ";
+ sKeyword[NF_KEY_DDDD] = "JJJJ";
+ }
+ else if ( eLang == LANGUAGE_FINNISH )
+ {
+ sKeyword[NF_KEY_D] = "P";
+ sKeyword[NF_KEY_DD] = "PP";
+ sKeyword[NF_KEY_DDD] = "PPP";
+ sKeyword[NF_KEY_DDDD] = "PPPP";
+ }
+
+ // month
+ if ( eLang == LANGUAGE_FINNISH )
+ {
+ sKeyword[NF_KEY_M] = "K";
+ sKeyword[NF_KEY_MM] = "KK";
+ sKeyword[NF_KEY_MMM] = "KKK";
+ sKeyword[NF_KEY_MMMM] = "KKKK";
+ sKeyword[NF_KEY_MMMMM] = "KKKKK";
+ }
+
+ // year
+ if ( eLang.anyOf(
+ LANGUAGE_ITALIAN,
+ LANGUAGE_ITALIAN_SWISS,
+ LANGUAGE_FRENCH,
+ LANGUAGE_FRENCH_BELGIAN,
+ LANGUAGE_FRENCH_CANADIAN,
+ LANGUAGE_FRENCH_SWISS,
+ LANGUAGE_FRENCH_LUXEMBOURG,
+ LANGUAGE_FRENCH_MONACO,
+ LANGUAGE_PORTUGUESE,
+ LANGUAGE_PORTUGUESE_BRAZILIAN,
+ LANGUAGE_SPANISH_MODERN,
+ LANGUAGE_SPANISH_DATED,
+ LANGUAGE_SPANISH_MEXICAN,
+ LANGUAGE_SPANISH_GUATEMALA,
+ LANGUAGE_SPANISH_COSTARICA,
+ LANGUAGE_SPANISH_PANAMA,
+ LANGUAGE_SPANISH_DOMINICAN_REPUBLIC,
+ LANGUAGE_SPANISH_VENEZUELA,
+ LANGUAGE_SPANISH_COLOMBIA,
+ LANGUAGE_SPANISH_PERU,
+ LANGUAGE_SPANISH_ARGENTINA,
+ LANGUAGE_SPANISH_ECUADOR,
+ LANGUAGE_SPANISH_CHILE,
+ LANGUAGE_SPANISH_URUGUAY,
+ LANGUAGE_SPANISH_PARAGUAY,
+ LANGUAGE_SPANISH_BOLIVIA,
+ LANGUAGE_SPANISH_EL_SALVADOR,
+ LANGUAGE_SPANISH_HONDURAS,
+ LANGUAGE_SPANISH_NICARAGUA,
+ LANGUAGE_SPANISH_PUERTO_RICO))
+ {
+ sKeyword[NF_KEY_YY] = "AA";
+ sKeyword[NF_KEY_YYYY] = "AAAA";
+ // must exchange the day of week name code, same as Xcl
+ sKeyword[NF_KEY_AAA] = "OOO";
+ sKeyword[NF_KEY_AAAA] = "OOOO";
+ }
+ else if ( eLang.anyOf(
+ LANGUAGE_DUTCH,
+ LANGUAGE_DUTCH_BELGIAN))
+ {
+ sKeyword[NF_KEY_YY] = "JJ";
+ sKeyword[NF_KEY_YYYY] = "JJJJ";
+ }
+ else if ( eLang == LANGUAGE_FINNISH )
+ {
+ sKeyword[NF_KEY_YY] = "VV";
+ sKeyword[NF_KEY_YYYY] = "VVVV";
+ }
+
+ // hour
+ if ( eLang.anyOf(
+ LANGUAGE_DUTCH,
+ LANGUAGE_DUTCH_BELGIAN))
+ {
+ sKeyword[NF_KEY_H] = "U";
+ sKeyword[NF_KEY_HH] = "UU";
+ }
+ else if ( eLang.anyOf(
+ LANGUAGE_FINNISH,
+ LANGUAGE_SWEDISH,
+ LANGUAGE_SWEDISH_FINLAND,
+ LANGUAGE_DANISH,
+ LANGUAGE_NORWEGIAN,
+ LANGUAGE_NORWEGIAN_BOKMAL,
+ LANGUAGE_NORWEGIAN_NYNORSK))
+ {
+ sKeyword[NF_KEY_H] = "T";
+ sKeyword[NF_KEY_HH] = "TT";
+ }
+ }
+}
+
+void ImpSvNumberformatScan::ChangeNullDate(sal_uInt16 nDay, sal_uInt16 nMonth, sal_Int16 nYear)
+{
+ maNullDate = Date(nDay, nMonth, nYear);
+ if (!maNullDate.IsValidDate())
+ {
+ maNullDate.Normalize();
+ SAL_WARN("svl.numbers","ImpSvNumberformatScan::ChangeNullDate - not valid"
+ " d: " << nDay << " m: " << nMonth << " y: " << nYear << " normalized to"
+ " d: " << maNullDate.GetDay() << " m: " << maNullDate.GetMonth() << " y: " << maNullDate.GetYear());
+ }
+}
+
+void ImpSvNumberformatScan::ChangeStandardPrec(sal_uInt16 nPrec)
+{
+ nStandardPrec = nPrec;
+}
+
+const Color* ImpSvNumberformatScan::GetColor(OUString& sStr) const
+{
+ OUString sString = pFormatter->GetCharClass()->uppercase(sStr);
+ const NfKeywordTable & rKeyword = GetKeywords();
+ size_t i = 0;
+ while (i < NF_MAX_DEFAULT_COLORS && sString != rKeyword[NF_KEY_FIRSTCOLOR+i] )
+ {
+ i++;
+ }
+ if (i >= NF_MAX_DEFAULT_COLORS && meKeywordLocalization == KeywordLocalization::AllowEnglish)
+ {
+ LanguageType eLang = pFormatter->GetLocaleData()->getLoadedLanguageTag().getLanguageType( false);
+ if ( eLang.anyOf(
+ LANGUAGE_GERMAN,
+ LANGUAGE_GERMAN_SWISS,
+ LANGUAGE_GERMAN_AUSTRIAN,
+ LANGUAGE_GERMAN_LUXEMBOURG,
+ LANGUAGE_GERMAN_LIECHTENSTEIN )) // only German uses localized color names
+ {
+ size_t j = 0;
+ while ( j < NF_MAX_DEFAULT_COLORS && sString != sEnglishKeyword[NF_KEY_FIRSTCOLOR + j] )
+ {
+ ++j;
+ }
+ if ( j < NF_MAX_DEFAULT_COLORS )
+ {
+ i = j;
+ }
+ }
+ }
+
+ enum ColorKeywordConversion
+ {
+ None,
+ GermanToEnglish,
+ EnglishToGerman
+ } eColorKeywordConversion(None);
+
+ if (bConvertMode)
+ {
+ const bool bFromGerman = eTmpLnge.anyOf(
+ LANGUAGE_GERMAN,
+ LANGUAGE_GERMAN_SWISS,
+ LANGUAGE_GERMAN_AUSTRIAN,
+ LANGUAGE_GERMAN_LUXEMBOURG,
+ LANGUAGE_GERMAN_LIECHTENSTEIN);
+ const bool bToGerman = eNewLnge.anyOf(
+ LANGUAGE_GERMAN,
+ LANGUAGE_GERMAN_SWISS,
+ LANGUAGE_GERMAN_AUSTRIAN,
+ LANGUAGE_GERMAN_LUXEMBOURG,
+ LANGUAGE_GERMAN_LIECHTENSTEIN);
+ if (bFromGerman && !bToGerman)
+ eColorKeywordConversion = ColorKeywordConversion::GermanToEnglish;
+ else if (!bFromGerman && bToGerman)
+ eColorKeywordConversion = ColorKeywordConversion::EnglishToGerman;
+ }
+
+ const Color* pResult = nullptr;
+ if (i >= NF_MAX_DEFAULT_COLORS)
+ {
+ const OUString& rColorWord = rKeyword[NF_KEY_COLOR];
+ bool bL10n = true;
+ if ((bL10n = sString.startsWith(rColorWord)) ||
+ ((meKeywordLocalization == KeywordLocalization::AllowEnglish) &&
+ sString.startsWith(sEnglishKeyword[NF_KEY_COLOR])))
+ {
+ sal_Int32 nPos = (bL10n ? rColorWord.getLength() : sEnglishKeyword[NF_KEY_COLOR].getLength());
+ sStr = sStr.copy(nPos);
+ sStr = comphelper::string::strip(sStr, ' ');
+ switch (eColorKeywordConversion)
+ {
+ case ColorKeywordConversion::None:
+ sStr = rColorWord + sStr;
+ break;
+ case ColorKeywordConversion::GermanToEnglish:
+ sStr = sEnglishKeyword[NF_KEY_COLOR] + sStr; // Farbe -> COLOR
+ break;
+ case ColorKeywordConversion::EnglishToGerman:
+ sStr = GermanColorName(NF_KEY_COLOR - NF_KEY_COLOR) + sStr; // Color -> FARBE
+ break;
+ }
+ sString = sString.copy(nPos);
+ sString = comphelper::string::strip(sString, ' ');
+
+ if ( CharClass::isAsciiNumeric( sString ) )
+ {
+ sal_Int32 nIndex = sString.toInt32();
+ if (nIndex > 0 && nIndex <= 64)
+ {
+ pResult = pFormatter->GetUserDefColor(static_cast<sal_uInt16>(nIndex)-1);
+ }
+ }
+ }
+ }
+ else
+ {
+ sStr.clear();
+ switch (eColorKeywordConversion)
+ {
+ case ColorKeywordConversion::None:
+ sStr = rKeyword[NF_KEY_FIRSTCOLOR+i];
+ break;
+ case ColorKeywordConversion::GermanToEnglish:
+ sStr = sEnglishKeyword[NF_KEY_FIRSTCOLOR + i]; // Rot -> RED
+ break;
+ case ColorKeywordConversion::EnglishToGerman:
+ sStr = GermanColorName(NF_KEY_FIRSTCOLOR - NF_KEY_COLOR + i); // Red -> ROT
+ break;
+ }
+ pResult = &(StandardColor[i]);
+ }
+ return pResult;
+}
+
+short ImpSvNumberformatScan::GetKeyWord( const OUString& sSymbol, sal_Int32 nPos, bool& rbFoundEnglish ) const
+{
+ OUString sString = pFormatter->GetCharClass()->uppercase( sSymbol, nPos, sSymbol.getLength() - nPos );
+ const NfKeywordTable & rKeyword = GetKeywords();
+ // #77026# for the Xcl perverts: the GENERAL keyword is recognized anywhere
+ if (sString.startsWith( rKeyword[NF_KEY_GENERAL] ))
+ {
+ return NF_KEY_GENERAL;
+ }
+ if ((meKeywordLocalization == KeywordLocalization::AllowEnglish) &&
+ sString.startsWith( sEnglishKeyword[NF_KEY_GENERAL]))
+ {
+ rbFoundEnglish = true;
+ return NF_KEY_GENERAL;
+ }
+
+ // MUST be a reverse search to find longer strings first,
+ // new keywords take precedence over old keywords,
+ // skip colors et al after keywords.
+ short i = NF_KEY_LASTKEYWORD;
+ while (i > 0 && !sString.startsWith( rKeyword[i]))
+ {
+ i--;
+ }
+ if (i == 0 && meKeywordLocalization == KeywordLocalization::AllowEnglish)
+ {
+ // No localized (if so) keyword, try English keywords if keywords
+ // are localized. That was already checked in SetDependentKeywords().
+ i = NF_KEY_LASTKEYWORD;
+ while (i > 0 && !sString.startsWith( sEnglishKeyword[i]))
+ {
+ i--;
+ }
+ }
+
+ // The Thai T NatNum modifier during Xcl import.
+ if (i == 0 && bConvertMode &&
+ sString[0] == 'T' &&
+ eTmpLnge == LANGUAGE_ENGLISH_US &&
+ MsLangId::getRealLanguage( eNewLnge) == LANGUAGE_THAI)
+ {
+ i = NF_KEY_THAI_T;
+ }
+ return i; // 0 => not found
+}
+
+/**
+ * Next_Symbol
+ *
+ * Splits up the input for further processing (by the Turing machine).
+ *
+ * Starting state = SsStar
+ *
+ * ---------------+-------------------+---------------------------+---------------
+ * Old state | Character read | Event | New state
+ * ---------------+-------------------+---------------------------+---------------
+ * SsStart | Character | Symbol = Character | SsGetWord
+ * | " | Type = String | SsGetString
+ * | \ | Type = String | SsGetChar
+ * | * | Type = Star | SsGetStar
+ * | _ | Type = Blank | SsGetBlank
+ * | @ # 0 ? / . , % [ | Symbol = Character; |
+ * | ] ' Blank | Type = Control character | SsStop
+ * | $ - + ( ) : | Type = String; |
+ * | Else | Symbol = Character | SsStop
+ * ---------------|-------------------+---------------------------+---------------
+ * SsGetChar | Else | Symbol = Character | SsStop
+ * ---------------+-------------------+---------------------------+---------------
+ * GetString | " | | SsStop
+ * | Else | Symbol += Character | GetString
+ * ---------------+-------------------+---------------------------+---------------
+ * SsGetWord | Character | Symbol += Character |
+ * | + - (E+ E-)| Symbol += Character | SsStop
+ * | / (AM/PM)| Symbol += Character |
+ * | Else | Pos--, if Key Type = Word | SsStop
+ * ---------------+-------------------+---------------------------+---------------
+ * SsGetStar | Else | Symbol += Character | SsStop
+ * | | Mark special case * |
+ * ---------------+-------------------+---------------------------+---------------
+ * SsGetBlank | Else | Symbol + =Character | SsStop
+ * | | Mark special case _ |
+ * ---------------------------------------------------------------+--------------
+ *
+ * If we recognize a keyword in the state SsGetWord (even as the symbol's start text)
+ * we write back the rest of the characters!
+ */
+
+namespace {
+
+enum ScanState
+{
+ SsStop = 0,
+ SsStart = 1,
+ SsGetChar = 2,
+ SsGetString = 3,
+ SsGetWord = 4,
+ SsGetStar = 5,
+ SsGetBlank = 6
+};
+
+}
+
+short ImpSvNumberformatScan::Next_Symbol( const OUString& rStr,
+ sal_Int32& nPos,
+ OUString& sSymbol ) const
+{
+ InitKeywords();
+ const CharClass* pChrCls = pFormatter->GetCharClass();
+ const LocaleDataWrapper* pLoc = pFormatter->GetLocaleData();
+ short eType = 0;
+ ScanState eState = SsStart;
+ OUStringBuffer sSymbolBuffer;
+ while ( nPos < rStr.getLength() && eState != SsStop )
+ {
+ sal_Unicode cToken = rStr[nPos++];
+ switch (eState)
+ {
+ case SsStart:
+ // Fetch any currency longer than one character and don't get
+ // confused later on by "E/" or other combinations of letters
+ // and meaningful symbols. Necessary for old automatic currency.
+ // #96158# But don't do it if we're starting a "[...]" section,
+ // for example a "[$...]" new currency symbol to not parse away
+ // "$U" (symbol) of "[$UYU]" (abbreviation).
+ if ( nCurrPos >= 0 && sCurString.getLength() > 1 &&
+ nPos-1 + sCurString.getLength() <= rStr.getLength() &&
+ (nPos <= 1 || rStr[nPos-2] != '[') )
+ {
+ OUString aTest = pChrCls->uppercase( rStr.copy( nPos-1, sCurString.getLength() ) );
+ if ( aTest == sCurString )
+ {
+ sSymbol = rStr.copy( --nPos, sCurString.getLength() );
+ nPos = nPos + sSymbol.getLength();
+ eType = NF_SYMBOLTYPE_STRING;
+ return eType;
+ }
+ }
+ switch (cToken)
+ {
+ case '#':
+ case '0':
+ case '?':
+ case '%':
+ case '@':
+ case '[':
+ case ']':
+ case ',':
+ case '.':
+ case '/':
+ case '\'':
+ case ' ':
+ case ':':
+ case '-':
+ eType = NF_SYMBOLTYPE_DEL;
+ sSymbolBuffer.append(OUStringChar(cToken));
+ eState = SsStop;
+ break;
+ case '*':
+ eType = NF_SYMBOLTYPE_STAR;
+ sSymbolBuffer.append(OUStringChar(cToken));
+ eState = SsGetStar;
+ break;
+ case '_':
+ eType = NF_SYMBOLTYPE_BLANK;
+ sSymbolBuffer.append(OUStringChar(cToken));
+ eState = SsGetBlank;
+ break;
+ case '"':
+ eType = NF_SYMBOLTYPE_STRING;
+ eState = SsGetString;
+ sSymbolBuffer.append(OUStringChar(cToken));
+ break;
+ case '\\':
+ eType = NF_SYMBOLTYPE_STRING;
+ eState = SsGetChar;
+ sSymbolBuffer.append(OUStringChar(cToken));
+ break;
+ case '$':
+ case '+':
+ case '(':
+ case ')':
+ eType = NF_SYMBOLTYPE_STRING;
+ eState = SsStop;
+ sSymbolBuffer.append(OUStringChar(cToken));
+ break;
+ default :
+ if (StringEqualsChar( pFormatter->GetNumDecimalSep(), cToken) ||
+ StringEqualsChar( pFormatter->GetNumThousandSep(), cToken) ||
+ StringEqualsChar( pFormatter->GetDateSep(), cToken) ||
+ StringEqualsChar( pLoc->getTimeSep(), cToken) ||
+ StringEqualsChar( pLoc->getTime100SecSep(), cToken))
+ {
+ // Another separator than pre-known ASCII
+ eType = NF_SYMBOLTYPE_DEL;
+ sSymbolBuffer.append(OUStringChar(cToken));
+ eState = SsStop;
+ }
+ else if ( pChrCls->isLetter( rStr, nPos-1 ) )
+ {
+ bool bFoundEnglish = false;
+ short nTmpType = GetKeyWord( rStr, nPos-1, bFoundEnglish);
+ if ( nTmpType )
+ {
+ bool bCurrency = false;
+ // "Automatic" currency may start with keyword,
+ // like "R" (Rand) and 'R' (era)
+ if ( nCurrPos >= 0 &&
+ nPos-1 + sCurString.getLength() <= rStr.getLength() &&
+ sCurString.startsWith( bFoundEnglish ? sEnglishKeyword[nTmpType] : sKeyword[nTmpType]))
+ {
+ OUString aTest = pChrCls->uppercase( rStr.copy( nPos-1, sCurString.getLength() ) );
+ if ( aTest == sCurString )
+ {
+ bCurrency = true;
+ }
+ }
+ if ( bCurrency )
+ {
+ eState = SsGetWord;
+ sSymbolBuffer.append(OUStringChar(cToken));
+ }
+ else
+ {
+ eType = nTmpType;
+ // The code to be advanced is the detected keyword,
+ // not necessarily the locale's keyword, but the
+ // symbol is to be the locale's keyword.
+ sal_Int32 nLen;
+ if (bFoundEnglish)
+ {
+ nLen = sEnglishKeyword[eType].getLength();
+ // Use the locale's General keyword name, not uppercase.
+ sSymbolBuffer = (eType == NF_KEY_GENERAL ? sNameStandardFormat : sKeyword[eType]);
+ }
+ else
+ {
+ nLen = sKeyword[eType].getLength();
+ // Preserve a locale's keyword's case as entered.
+ sSymbolBuffer = rStr.subView( nPos-1, nLen);
+ }
+ if ((eType == NF_KEY_E || IsAmbiguousE(eType)) && nPos < rStr.getLength())
+ {
+ sal_Unicode cNext = rStr[nPos];
+ switch ( cNext )
+ {
+ case '+' :
+ case '-' : // E+ E- combine to one symbol
+ sSymbolBuffer.append(OUStringChar(cNext));
+ eType = NF_KEY_E;
+ nPos++;
+ break;
+ case '0' :
+ case '#' : // scientific E without sign
+ eType = NF_KEY_E;
+ break;
+ }
+ }
+ nPos--;
+ nPos = nPos + nLen;
+ eState = SsStop;
+ }
+ }
+ else
+ {
+ eState = SsGetWord;
+ sSymbolBuffer.append(OUStringChar(cToken));
+ }
+ }
+ else
+ {
+ eType = NF_SYMBOLTYPE_STRING;
+ eState = SsStop;
+ sSymbolBuffer.append(OUStringChar(cToken));
+ }
+ break;
+ }
+ break;
+ case SsGetChar:
+ sSymbolBuffer.append(OUStringChar(cToken));
+ eState = SsStop;
+ break;
+ case SsGetString:
+ if (cToken == '"')
+ {
+ eState = SsStop;
+ }
+ sSymbolBuffer.append(OUStringChar(cToken));
+ break;
+ case SsGetWord:
+ if ( pChrCls->isLetter( rStr, nPos-1 ) )
+ {
+ bool bFoundEnglish = false;
+ short nTmpType = GetKeyWord( rStr, nPos-1, bFoundEnglish);
+ if ( nTmpType )
+ {
+ // beginning of keyword, stop scan and put back
+ eType = NF_SYMBOLTYPE_STRING;
+ eState = SsStop;
+ nPos--;
+ }
+ else
+ {
+ sSymbolBuffer.append(OUStringChar(cToken));
+ }
+ }
+ else
+ {
+ bool bDontStop = false;
+ sal_Unicode cNext;
+ switch (cToken)
+ {
+ case '/': // AM/PM, A/P
+ if (nPos < rStr.getLength())
+ {
+ cNext = rStr[nPos];
+ if ( cNext == 'P' || cNext == 'p' )
+ {
+ sal_Int32 nLen = sSymbolBuffer.getLength();
+ if ( 1 <= nLen &&
+ (sSymbolBuffer[0] == 'A' || sSymbolBuffer[0] == 'a') &&
+ (nLen == 1 ||
+ (nLen == 2 && (sSymbolBuffer[1] == 'M' || sSymbolBuffer[1] == 'm')
+ && (rStr[nPos + 1] == 'M' || rStr[nPos + 1] == 'm'))))
+ {
+ sSymbolBuffer.append(OUStringChar(cToken));
+ bDontStop = true;
+ }
+ }
+ }
+ break;
+ }
+ // anything not recognized will stop the scan
+ if (!bDontStop)
+ {
+ eState = SsStop;
+ nPos--;
+ eType = NF_SYMBOLTYPE_STRING;
+ }
+ }
+ break;
+ case SsGetStar:
+ eState = SsStop;
+ sSymbolBuffer.append(OUStringChar(cToken));
+ break;
+ case SsGetBlank:
+ eState = SsStop;
+ sSymbolBuffer.append(OUStringChar(cToken));
+ break;
+ default:
+ break;
+ } // of switch
+ } // of while
+ if (eState == SsGetWord)
+ {
+ eType = NF_SYMBOLTYPE_STRING;
+ }
+ sSymbol = sSymbolBuffer.makeStringAndClear();
+ return eType;
+}
+
+sal_Int32 ImpSvNumberformatScan::Symbol_Division(const OUString& rString)
+{
+ nCurrPos = -1;
+ // Do we have some sort of currency?
+ OUString sString = pFormatter->GetCharClass()->uppercase(rString);
+ sal_Int32 nCPos = 0;
+ while (nCPos >= 0 && nCPos < sString.getLength())
+ {
+ nCPos = sString.indexOf(GetCurString(),nCPos);
+ if (nCPos >= 0)
+ {
+ // In Quotes?
+ sal_Int32 nQ = SvNumberformat::GetQuoteEnd( sString, nCPos );
+ if ( nQ < 0 )
+ {
+ sal_Unicode c;
+ if ( nCPos == 0 ||
+ ((c = sString[nCPos-1]) != '"'
+ && c != '\\') ) // dm can be protected by "dm \d
+ {
+ nCurrPos = nCPos;
+ nCPos = -1;
+ }
+ else
+ {
+ nCPos++; // Continue search
+ }
+ }
+ else
+ {
+ nCPos = nQ + 1; // Continue search
+ }
+ }
+ }
+ nStringsCnt = 0;
+ bool bStar = false; // Is set on detecting '*'
+ Reset();
+
+ sal_Int32 nPos = 0;
+ const sal_Int32 nLen = rString.getLength();
+ while (nPos < nLen && nStringsCnt < NF_MAX_FORMAT_SYMBOLS)
+ {
+ nTypeArray[nStringsCnt] = Next_Symbol(rString, nPos, sStrArray[nStringsCnt]);
+ if (nTypeArray[nStringsCnt] == NF_SYMBOLTYPE_STAR)
+ { // Monitoring the '*'
+ if (bStar)
+ {
+ return nPos; // Error: double '*'
+ }
+ else
+ {
+ // Valid only if there is a character following, else we are
+ // at the end of a code that does not have a fill character
+ // (yet?).
+ if (sStrArray[nStringsCnt].getLength() < 2)
+ return nPos;
+ bStar = true;
+ }
+ }
+ nStringsCnt++;
+ }
+
+ return 0; // 0 => ok
+}
+
+void ImpSvNumberformatScan::SkipStrings(sal_uInt16& i, sal_Int32& nPos) const
+{
+ while (i < nStringsCnt && ( nTypeArray[i] == NF_SYMBOLTYPE_STRING
+ || nTypeArray[i] == NF_SYMBOLTYPE_BLANK
+ || nTypeArray[i] == NF_SYMBOLTYPE_STAR) )
+ {
+ nPos = nPos + sStrArray[i].getLength();
+ i++;
+ }
+}
+
+sal_uInt16 ImpSvNumberformatScan::PreviousKeyword(sal_uInt16 i) const
+{
+ short res = 0;
+ if (i > 0 && i < nStringsCnt)
+ {
+ i--;
+ while (i > 0 && nTypeArray[i] <= 0)
+ {
+ i--;
+ }
+ if (nTypeArray[i] > 0)
+ {
+ res = nTypeArray[i];
+ }
+ }
+ return res;
+}
+
+sal_uInt16 ImpSvNumberformatScan::NextKeyword(sal_uInt16 i) const
+{
+ short res = 0;
+ if (i < nStringsCnt-1)
+ {
+ i++;
+ while (i < nStringsCnt-1 && nTypeArray[i] <= 0)
+ {
+ i++;
+ }
+ if (nTypeArray[i] > 0)
+ {
+ res = nTypeArray[i];
+ }
+ }
+ return res;
+}
+
+short ImpSvNumberformatScan::PreviousType( sal_uInt16 i ) const
+{
+ if ( i > 0 && i < nStringsCnt )
+ {
+ do
+ {
+ i--;
+ }
+ while ( i > 0 && nTypeArray[i] == NF_SYMBOLTYPE_EMPTY );
+ return nTypeArray[i];
+ }
+ return 0;
+}
+
+sal_Unicode ImpSvNumberformatScan::PreviousChar(sal_uInt16 i) const
+{
+ sal_Unicode res = ' ';
+ if (i > 0 && i < nStringsCnt)
+ {
+ i--;
+ while (i > 0 &&
+ ( nTypeArray[i] == NF_SYMBOLTYPE_EMPTY ||
+ nTypeArray[i] == NF_SYMBOLTYPE_STRING ||
+ nTypeArray[i] == NF_SYMBOLTYPE_STAR ||
+ nTypeArray[i] == NF_SYMBOLTYPE_BLANK ))
+ {
+ i--;
+ }
+ if (sStrArray[i].getLength() > 0)
+ {
+ res = sStrArray[i][sStrArray[i].getLength()-1];
+ }
+ }
+ return res;
+}
+
+sal_Unicode ImpSvNumberformatScan::NextChar(sal_uInt16 i) const
+{
+ sal_Unicode res = ' ';
+ if (i < nStringsCnt-1)
+ {
+ i++;
+ while (i < nStringsCnt-1 &&
+ ( nTypeArray[i] == NF_SYMBOLTYPE_EMPTY ||
+ nTypeArray[i] == NF_SYMBOLTYPE_STRING ||
+ nTypeArray[i] == NF_SYMBOLTYPE_STAR ||
+ nTypeArray[i] == NF_SYMBOLTYPE_BLANK))
+ {
+ i++;
+ }
+ if (sStrArray[i].getLength() > 0)
+ {
+ res = sStrArray[i][0];
+ }
+ }
+ return res;
+}
+
+bool ImpSvNumberformatScan::IsLastBlankBeforeFrac(sal_uInt16 i) const
+{
+ bool res = true;
+ if (i < nStringsCnt-1)
+ {
+ bool bStop = false;
+ i++;
+ while (i < nStringsCnt-1 && !bStop)
+ {
+ i++;
+ if ( nTypeArray[i] == NF_SYMBOLTYPE_DEL &&
+ sStrArray[i][0] == '/')
+ {
+ bStop = true;
+ }
+ else if ( ( nTypeArray[i] == NF_SYMBOLTYPE_DEL &&
+ sStrArray[i][0] == ' ') ||
+ nTypeArray[i] == NF_SYMBOLTYPE_STRING ) // integer/fraction delimiter can also be a string
+ {
+ res = false;
+ }
+ }
+ if (!bStop) // no '/'{
+ {
+ res = false;
+ }
+ }
+ else
+ {
+ res = false; // no '/' any more
+ }
+ return res;
+}
+
+void ImpSvNumberformatScan::Reset()
+{
+ nStringsCnt = 0;
+ nResultStringsCnt = 0;
+ eScannedType = SvNumFormatType::UNDEFINED;
+ bExp = false;
+ bThousand = false;
+ nThousand = 0;
+ bDecSep = false;
+ nDecPos = sal_uInt16(-1);
+ nExpPos = sal_uInt16(-1);
+ nBlankPos = sal_uInt16(-1);
+ nCntPre = 0;
+ nCntPost = 0;
+ nCntExp = 0;
+ bFrac = false;
+ bBlank = false;
+ nNatNumModifier = 0;
+}
+
+bool ImpSvNumberformatScan::Is100SecZero( sal_uInt16 i, bool bHadDecSep ) const
+{
+ sal_uInt16 nIndexPre = PreviousKeyword( i );
+ return (nIndexPre == NF_KEY_S || nIndexPre == NF_KEY_SS) &&
+ (bHadDecSep ||
+ ( i > 0 && nTypeArray[i-1] == NF_SYMBOLTYPE_STRING));
+ // SS"any"00 take "any" as a valid decimal separator
+}
+
+sal_Int32 ImpSvNumberformatScan::ScanType()
+{
+ const LocaleDataWrapper* pLoc = pFormatter->GetLocaleData();
+
+ sal_Int32 nPos = 0;
+ sal_uInt16 i = 0;
+ SvNumFormatType eNewType;
+ bool bMatchBracket = false;
+ bool bHaveGeneral = false; // if General/Standard encountered
+ bool bIsTimeDetected =false; // hour or second found in format
+ bool bHaveMinute = false;
+
+ SkipStrings(i, nPos);
+ while (i < nStringsCnt)
+ {
+ if (nTypeArray[i] > 0)
+ { // keyword
+ sal_uInt16 nIndexPre;
+ sal_uInt16 nIndexNex;
+
+ switch (nTypeArray[i])
+ {
+ case NF_KEY_E: // E
+ eNewType = SvNumFormatType::SCIENTIFIC;
+ break;
+ case NF_KEY_H: // H
+ case NF_KEY_HH: // HH
+ bIsTimeDetected = true;
+ [[fallthrough]];
+ case NF_KEY_S: // S
+ case NF_KEY_SS: // SS
+ if ( !bHaveMinute )
+ bIsTimeDetected = true;
+ [[fallthrough]];
+ case NF_KEY_AMPM: // AM,A,PM,P
+ case NF_KEY_AP:
+ eNewType = SvNumFormatType::TIME;
+ break;
+ case NF_KEY_M: // M
+ case NF_KEY_MM: // MM
+ case NF_KEY_MI: // M minute detected in Finnish
+ case NF_KEY_MMI: // MM
+ /* Minute or month.
+ Minute if one of:
+ * preceded by time keyword H (ignoring separators)
+ * followed by time keyword S (ignoring separators)
+ * H or S was detected and this is the first M following
+ * preceded by '[' amount bracket
+ Else month.
+ That are the Excel rules. BUT, we break it because certainly
+ in something like {HH YYYY-MM-DD} the MM is NOT meant to be
+ minute, so not if MM is between YY and DD or DD and YY.
+ Actually not if any date specific keyword followed a time
+ setting keyword.
+ */
+ nIndexPre = PreviousKeyword(i);
+ nIndexNex = NextKeyword(i);
+ if (nIndexPre == NF_KEY_H || // H
+ nIndexPre == NF_KEY_HH || // HH
+ nIndexNex == NF_KEY_S || // S
+ nIndexNex == NF_KEY_SS || // SS
+ bIsTimeDetected || // tdf#101147
+ PreviousChar(i) == '[' ) // [M
+ {
+ eNewType = SvNumFormatType::TIME;
+ if ( nTypeArray[i] == NF_KEY_M || nTypeArray[i] == NF_KEY_MM )
+ {
+ nTypeArray[i] -= 2; // 6 -> 4, 7 -> 5
+ }
+ bIsTimeDetected = false; // next M should be month
+ bHaveMinute = true;
+ }
+ else
+ {
+ eNewType = SvNumFormatType::DATE;
+ if ( nTypeArray[i] == NF_KEY_MI || nTypeArray[i] == NF_KEY_MMI )
+ { // follow resolution of tdf#33689 for Finnish
+ nTypeArray[i] += 2; // 4 -> 6, 5 -> 7
+ }
+ }
+ break;
+ case NF_KEY_MMM: // MMM
+ case NF_KEY_MMMM: // MMMM
+ case NF_KEY_MMMMM: // MMMMM
+ case NF_KEY_Q: // Q
+ case NF_KEY_QQ: // QQ
+ case NF_KEY_D: // D
+ case NF_KEY_DD: // DD
+ case NF_KEY_DDD: // DDD
+ case NF_KEY_DDDD: // DDDD
+ case NF_KEY_YY: // YY
+ case NF_KEY_YYYY: // YYYY
+ case NF_KEY_NN: // NN
+ case NF_KEY_NNN: // NNN
+ case NF_KEY_NNNN: // NNNN
+ case NF_KEY_WW : // WW
+ case NF_KEY_AAA : // AAA
+ case NF_KEY_AAAA : // AAAA
+ case NF_KEY_EC : // E
+ case NF_KEY_EEC : // EE
+ case NF_KEY_G : // G
+ case NF_KEY_GG : // GG
+ case NF_KEY_GGG : // GGG
+ case NF_KEY_R : // R
+ case NF_KEY_RR : // RR
+ eNewType = SvNumFormatType::DATE;
+ bIsTimeDetected = false;
+ break;
+ case NF_KEY_CCC: // CCC
+ eNewType = SvNumFormatType::CURRENCY;
+ break;
+ case NF_KEY_BOOLEAN: // BOOLEAN
+ eNewType = SvNumFormatType::LOGICAL;
+ break;
+ case NF_KEY_GENERAL: // General
+ eNewType = SvNumFormatType::NUMBER;
+ bHaveGeneral = true;
+ break;
+ default:
+ eNewType = SvNumFormatType::UNDEFINED;
+ break;
+ }
+ }
+ else
+ { // control character
+ switch ( sStrArray[i][0] )
+ {
+ case '#':
+ case '?':
+ eNewType = SvNumFormatType::NUMBER;
+ break;
+ case '0':
+ if ( eScannedType & SvNumFormatType::TIME )
+ {
+ if ( Is100SecZero( i, bDecSep ) )
+ {
+ bDecSep = true; // subsequent 0's
+ eNewType = SvNumFormatType::TIME;
+ }
+ else
+ {
+ return nPos; // Error
+ }
+ }
+ else
+ {
+ eNewType = SvNumFormatType::NUMBER;
+ }
+ break;
+ case '%':
+ eNewType = SvNumFormatType::PERCENT;
+ break;
+ case '/':
+ eNewType = SvNumFormatType::FRACTION;
+ break;
+ case '[':
+ if ( i < nStringsCnt-1 &&
+ nTypeArray[i+1] == NF_SYMBOLTYPE_STRING &&
+ sStrArray[i+1][0] == '$' )
+ {
+ eNewType = SvNumFormatType::CURRENCY;
+ bMatchBracket = true;
+ }
+ else if ( i < nStringsCnt-1 &&
+ nTypeArray[i+1] == NF_SYMBOLTYPE_STRING &&
+ sStrArray[i+1][0] == '~' )
+ {
+ eNewType = SvNumFormatType::DATE;
+ bMatchBracket = true;
+ }
+ else
+ {
+ sal_uInt16 nIndexNex = NextKeyword(i);
+ if (nIndexNex == NF_KEY_H || // H
+ nIndexNex == NF_KEY_HH || // HH
+ nIndexNex == NF_KEY_M || // M
+ nIndexNex == NF_KEY_MM || // MM
+ nIndexNex == NF_KEY_S || // S
+ nIndexNex == NF_KEY_SS ) // SS
+ eNewType = SvNumFormatType::TIME;
+ else
+ {
+ return nPos; // Error
+ }
+ }
+ break;
+ case '@':
+ eNewType = SvNumFormatType::TEXT;
+ break;
+ default:
+ // Separator for SS,0
+ if ((eScannedType & SvNumFormatType::TIME)
+ && 0 < i && (nTypeArray[i-1] == NF_KEY_S || nTypeArray[i-1] == NF_KEY_SS))
+ {
+ // For ISO 8601 only YYYY-MM-DD"T"HH:MM:SS,0 accept both
+ // ',' and '.' regardless of locale's separator, and only
+ // those.
+ // XXX NOTE: this catches only known separators of
+ // NF_SYMBOLTYPE_DEL as all NF_SYMBOLTYPE_STRING are
+ // skipped during the loop. Meant to error out if the
+ // Time100SecSep or decimal separator differ and were used.
+ if ((eScannedType & SvNumFormatType::DATE)
+ && 11 <= i && i < nStringsCnt-1
+ && (nTypeArray[i-6] == NF_SYMBOLTYPE_STRING
+ && (sStrArray[i-6] == "\"T\"" || sStrArray[i-6] == "\\T"
+ || sStrArray[i-6] == "T"))
+ && (nTypeArray[i-11] == NF_KEY_YYYY)
+ && (nTypeArray[i-9] == NF_KEY_M || nTypeArray[i-9] == NF_KEY_MM)
+ && (nTypeArray[i-7] == NF_KEY_D || nTypeArray[i-7] == NF_KEY_DD)
+ && (nTypeArray[i-5] == NF_KEY_H || nTypeArray[i-5] == NF_KEY_HH)
+ && (nTypeArray[i-3] == NF_KEY_MI || nTypeArray[i-3] == NF_KEY_MMI)
+ && (nTypeArray[i+1] == NF_SYMBOLTYPE_DEL && sStrArray[i+1][0] == '0'))
+
+ {
+ if (sStrArray[i].getLength() == 1 && (sStrArray[i][0] == ',' || sStrArray[i][0] == '.'))
+ bDecSep = true;
+ else
+ return nPos; // Error
+ }
+ else if (pLoc->getTime100SecSep() == sStrArray[i])
+ bDecSep = true;
+ }
+ eNewType = SvNumFormatType::UNDEFINED;
+ break;
+ }
+ }
+ if (eScannedType == SvNumFormatType::UNDEFINED)
+ {
+ eScannedType = eNewType;
+ }
+ else if (eScannedType == SvNumFormatType::TEXT || eNewType == SvNumFormatType::TEXT)
+ {
+ eScannedType = SvNumFormatType::TEXT; // Text always remains text
+ }
+ else if (eNewType == SvNumFormatType::UNDEFINED)
+ { // Remains as is
+ }
+ else if (eScannedType != eNewType)
+ {
+ switch (eScannedType)
+ {
+ case SvNumFormatType::DATE:
+ switch (eNewType)
+ {
+ case SvNumFormatType::TIME:
+ eScannedType = SvNumFormatType::DATETIME;
+ break;
+ case SvNumFormatType::FRACTION: // DD/MM
+ break;
+ default:
+ if (nCurrPos >= 0)
+ {
+ eScannedType = SvNumFormatType::UNDEFINED;
+ }
+ else if ( sStrArray[i] != pFormatter->GetDateSep() )
+ {
+ return nPos;
+ }
+ }
+ break;
+ case SvNumFormatType::TIME:
+ switch (eNewType)
+ {
+ case SvNumFormatType::DATE:
+ eScannedType = SvNumFormatType::DATETIME;
+ break;
+ case SvNumFormatType::FRACTION: // MM/SS
+ break;
+ default:
+ if (nCurrPos >= 0)
+ {
+ eScannedType = SvNumFormatType::UNDEFINED;
+ }
+ else if (pLoc->getTimeSep() != sStrArray[i])
+ {
+ return nPos;
+ }
+ break;
+ }
+ break;
+ case SvNumFormatType::DATETIME:
+ switch (eNewType)
+ {
+ case SvNumFormatType::TIME:
+ case SvNumFormatType::DATE:
+ break;
+ case SvNumFormatType::FRACTION: // DD/MM
+ break;
+ default:
+ if (nCurrPos >= 0)
+ {
+ eScannedType = SvNumFormatType::UNDEFINED;
+ }
+ else if ( pFormatter->GetDateSep() != sStrArray[i] &&
+ pLoc->getTimeSep() != sStrArray[i] )
+ {
+ return nPos;
+ }
+ }
+ break;
+ case SvNumFormatType::PERCENT:
+ switch (eNewType)
+ {
+ case SvNumFormatType::NUMBER: // Only number to percent
+ break;
+ default:
+ return nPos;
+ }
+ break;
+ case SvNumFormatType::SCIENTIFIC:
+ switch (eNewType)
+ {
+ case SvNumFormatType::NUMBER: // Only number to E
+ break;
+ default:
+ return nPos;
+ }
+ break;
+ case SvNumFormatType::NUMBER:
+ switch (eNewType)
+ {
+ case SvNumFormatType::SCIENTIFIC:
+ case SvNumFormatType::PERCENT:
+ case SvNumFormatType::FRACTION:
+ case SvNumFormatType::CURRENCY:
+ eScannedType = eNewType;
+ break;
+ default:
+ if (nCurrPos >= 0)
+ {
+ eScannedType = SvNumFormatType::UNDEFINED;
+ }
+ else
+ {
+ return nPos;
+ }
+ }
+ break;
+ case SvNumFormatType::FRACTION:
+ switch (eNewType)
+ {
+ case SvNumFormatType::NUMBER: // Only number to fraction
+ break;
+ default:
+ return nPos;
+ }
+ break;
+ default:
+ break;
+ }
+ }
+ nPos = nPos + sStrArray[i].getLength(); // Position of correction
+ i++;
+ if ( bMatchBracket )
+ { // no type detection inside of matching brackets if [$...], [~...]
+ while ( bMatchBracket && i < nStringsCnt )
+ {
+ if ( nTypeArray[i] == NF_SYMBOLTYPE_DEL
+ && sStrArray[i][0] == ']' )
+ {
+ bMatchBracket = false;
+ }
+ else
+ {
+ nTypeArray[i] = NF_SYMBOLTYPE_STRING;
+ }
+ nPos = nPos + sStrArray[i].getLength();
+ i++;
+ }
+ if ( bMatchBracket )
+ {
+ return nPos; // missing closing bracket at end of code
+ }
+ }
+ SkipStrings(i, nPos);
+ }
+
+ if ((eScannedType == SvNumFormatType::NUMBER ||
+ eScannedType == SvNumFormatType::UNDEFINED) &&
+ nCurrPos >= 0 && !bHaveGeneral)
+ {
+ eScannedType = SvNumFormatType::CURRENCY; // old "automatic" currency
+ }
+ if (eScannedType == SvNumFormatType::UNDEFINED)
+ {
+ eScannedType = SvNumFormatType::DEFINED;
+ }
+ return 0; // All is fine
+}
+
+bool ImpSvNumberformatScan::InsertSymbol( sal_uInt16 & nPos, svt::NfSymbolType eType, const OUString& rStr )
+{
+ if (nStringsCnt >= NF_MAX_FORMAT_SYMBOLS || nPos > nStringsCnt)
+ {
+ return false;
+ }
+ if (nPos > 0 && nTypeArray[nPos-1] == NF_SYMBOLTYPE_EMPTY)
+ {
+ --nPos; // reuse position
+ }
+ else
+ {
+ if (nStringsCnt >= NF_MAX_FORMAT_SYMBOLS - 1)
+ {
+ return false;
+ }
+ ++nStringsCnt;
+ for (size_t i = nStringsCnt; i > nPos; --i)
+ {
+ nTypeArray[i] = nTypeArray[i-1];
+ sStrArray[i] = sStrArray[i-1];
+ }
+ }
+ ++nResultStringsCnt;
+ nTypeArray[nPos] = static_cast<short>(eType);
+ sStrArray[nPos] = rStr;
+ return true;
+}
+
+int ImpSvNumberformatScan::FinalScanGetCalendar( sal_Int32& nPos, sal_uInt16& i,
+ sal_uInt16& rResultStringsCnt )
+{
+ if ( i < nStringsCnt-1 &&
+ sStrArray[i][0] == '[' &&
+ nTypeArray[i+1] == NF_SYMBOLTYPE_STRING &&
+ sStrArray[i+1][0] == '~' )
+ {
+ // [~calendarID]
+ nPos = nPos + sStrArray[i].getLength(); // [
+ nTypeArray[i] = NF_SYMBOLTYPE_CALDEL;
+ nPos = nPos + sStrArray[++i].getLength(); // ~
+ sStrArray[i-1] += sStrArray[i]; // [~
+ nTypeArray[i] = NF_SYMBOLTYPE_EMPTY;
+ rResultStringsCnt--;
+ if ( ++i >= nStringsCnt )
+ {
+ return -1; // error
+ }
+ nPos = nPos + sStrArray[i].getLength(); // calendarID
+ OUString& rStr = sStrArray[i];
+ nTypeArray[i] = NF_SYMBOLTYPE_CALENDAR; // convert
+ i++;
+ while ( i < nStringsCnt && sStrArray[i][0] != ']' )
+ {
+ nPos = nPos + sStrArray[i].getLength();
+ rStr += sStrArray[i];
+ nTypeArray[i] = NF_SYMBOLTYPE_EMPTY;
+ rResultStringsCnt--;
+ i++;
+ }
+ if ( rStr.getLength() && i < nStringsCnt &&
+ sStrArray[i][0] == ']' )
+ {
+ nTypeArray[i] = NF_SYMBOLTYPE_CALDEL;
+ nPos = nPos + sStrArray[i].getLength();
+ i++;
+ }
+ else
+ {
+ return -1; // error
+ }
+ return 1;
+ }
+ return 0;
+}
+
+bool ImpSvNumberformatScan::IsDateFragment( size_t nPos1, size_t nPos2 ) const
+{
+ return nPos2 - nPos1 == 2 && nTypeArray[nPos1+1] == NF_SYMBOLTYPE_DATESEP;
+}
+
+void ImpSvNumberformatScan::SwapArrayElements( size_t nPos1, size_t nPos2 )
+{
+ std::swap( nTypeArray[nPos1], nTypeArray[nPos2]);
+ std::swap( sStrArray[nPos1], sStrArray[nPos2]);
+}
+
+sal_Int32 ImpSvNumberformatScan::FinalScan( OUString& rString )
+{
+ const LocaleDataWrapper* pLoc = pFormatter->GetLocaleData();
+
+ // save values for convert mode
+ OUString sOldDecSep = pFormatter->GetNumDecimalSep();
+ OUString sOldThousandSep = pFormatter->GetNumThousandSep();
+ OUString sOldDateSep = pFormatter->GetDateSep();
+ OUString sOldTimeSep = pLoc->getTimeSep();
+ OUString sOldTime100SecSep= pLoc->getTime100SecSep();
+ OUString sOldCurSymbol = GetCurSymbol();
+ OUString sOldCurString = GetCurString();
+ sal_Unicode cOldKeyH = sKeyword[NF_KEY_H][0];
+ sal_Unicode cOldKeyMI = sKeyword[NF_KEY_MI][0];
+ sal_Unicode cOldKeyS = sKeyword[NF_KEY_S][0];
+ DateOrder eOldDateOrder = pLoc->getDateOrder();
+ sal_uInt16 nDayPos, nMonthPos, nYearPos;
+ nDayPos = nMonthPos = nYearPos = SAL_MAX_UINT16;
+
+ // If the group separator is a No-Break Space (French) continue with a
+ // normal space instead so queries on space work correctly.
+ // The same for Narrow No-Break Space just in case some locale uses it.
+ // The format string is adjusted to allow both.
+ // For output of the format code string the LocaleData characters are used.
+ if ( (sOldThousandSep[0] == cNoBreakSpace || sOldThousandSep[0] == cNarrowNoBreakSpace) &&
+ sOldThousandSep.getLength() == 1 )
+ {
+ sOldThousandSep = " ";
+ }
+ bool bNewDateOrder = false;
+ // change locale data et al
+ if (bConvertMode)
+ {
+ pFormatter->ChangeIntl(eNewLnge);
+ //! pointer may have changed
+ pLoc = pFormatter->GetLocaleData();
+ //! init new keywords
+ InitKeywords();
+ // Adapt date order to target locale, but Excel does not handle date
+ // particle re-ordering for the target locale when loading documents,
+ // though it does exchange separators, tdf#113889
+ bNewDateOrder = (mbConvertDateOrder && eOldDateOrder != pLoc->getDateOrder());
+ }
+ const CharClass* pChrCls = pFormatter->GetCharClass();
+
+ sal_Int32 nPos = 0; // error correction position
+ sal_uInt16 i = 0; // symbol loop counter
+ sal_uInt16 nCounter = 0; // counts digits
+ nResultStringsCnt = nStringsCnt; // counts remaining symbols
+ bDecSep = false; // reset in case already used in TypeCheck
+ bool bThaiT = false; // Thai T NatNum modifier present
+ bool bTimePart = false;
+ bool bDenomin = false; // Set when reading end of denominator
+
+ switch (eScannedType)
+ {
+ case SvNumFormatType::TEXT:
+ case SvNumFormatType::DEFINED:
+ while (i < nStringsCnt)
+ {
+ switch (nTypeArray[i])
+ {
+ case NF_SYMBOLTYPE_BLANK:
+ case NF_SYMBOLTYPE_STAR:
+ break;
+ case NF_KEY_GENERAL : // #77026# "General" is the same as "@"
+ break;
+ default:
+ if ( nTypeArray[i] != NF_SYMBOLTYPE_DEL ||
+ sStrArray[i][0] != '@' )
+ {
+ nTypeArray[i] = NF_SYMBOLTYPE_STRING;
+ }
+ break;
+ }
+ nPos = nPos + sStrArray[i].getLength();
+ i++;
+ } // of while
+ break;
+
+ case SvNumFormatType::NUMBER:
+ case SvNumFormatType::PERCENT:
+ case SvNumFormatType::CURRENCY:
+ case SvNumFormatType::SCIENTIFIC:
+ case SvNumFormatType::FRACTION:
+ while (i < nStringsCnt)
+ {
+ // TODO: rechecking eScannedType is unnecessary.
+ // This switch-case is for eScannedType == SvNumFormatType::FRACTION anyway
+ if (eScannedType == SvNumFormatType::FRACTION && // special case
+ nTypeArray[i] == NF_SYMBOLTYPE_DEL && // # ### #/#
+ StringEqualsChar( sOldThousandSep, ' ' ) && // e.g. France or Sweden
+ StringEqualsChar( sStrArray[i], ' ' ) &&
+ !bFrac &&
+ IsLastBlankBeforeFrac(i) )
+ {
+ nTypeArray[i] = NF_SYMBOLTYPE_STRING; // del->string
+ } // No thousands marker
+
+ if (nTypeArray[i] == NF_SYMBOLTYPE_BLANK ||
+ nTypeArray[i] == NF_SYMBOLTYPE_STAR ||
+ nTypeArray[i] == NF_KEY_CCC || // CCC
+ nTypeArray[i] == NF_KEY_GENERAL ) // Standard
+ {
+ if (nTypeArray[i] == NF_KEY_GENERAL)
+ {
+ nThousand = FLAG_STANDARD_IN_FORMAT;
+ if ( bConvertMode )
+ {
+ sStrArray[i] = sNameStandardFormat;
+ }
+ }
+ nPos = nPos + sStrArray[i].getLength();
+ i++;
+ }
+ else if (nTypeArray[i] == NF_SYMBOLTYPE_STRING || // No Strings or
+ nTypeArray[i] > 0) // Keywords
+ {
+ if (eScannedType == SvNumFormatType::SCIENTIFIC &&
+ nTypeArray[i] == NF_KEY_E) // E+
+ {
+ if (bExp) // Double
+ {
+ return nPos;
+ }
+ bExp = true;
+ nExpPos = i;
+ if (bDecSep)
+ {
+ nCntPost = nCounter;
+ }
+ else
+ {
+ nCntPre = nCounter;
+ }
+ nCounter = 0;
+ nTypeArray[i] = NF_SYMBOLTYPE_EXP;
+ }
+ else if (eScannedType == SvNumFormatType::FRACTION &&
+ (sStrArray[i][0] == ' ' || ( nTypeArray[i] == NF_SYMBOLTYPE_STRING && (sStrArray[i][0] < '0' || sStrArray[i][0] > '9') ) ) )
+ {
+ if (!bBlank && !bFrac) // Not double or after a /
+ {
+ if (bDecSep && nCounter > 0) // Decimal places
+ {
+ return nPos; // Error
+ }
+ if (sStrArray[i][0] == ' ' || nCounter > 0 ) // treat string as integer/fraction delimiter only if there is integer
+ {
+ bBlank = true;
+ nBlankPos = i;
+ nCntPre = nCounter;
+ nCounter = 0;
+ nTypeArray[i] = NF_SYMBOLTYPE_FRACBLANK;
+ }
+ }
+ else if ( sStrArray[i][0] == ' ' )
+ nTypeArray[i] = NF_SYMBOLTYPE_FRACBLANK;
+ else if ( bFrac && ( nCounter > 0 ) )
+ bDenomin = true; // following elements are no more part of denominator
+ }
+ else if (nTypeArray[i] == NF_KEY_THAI_T)
+ {
+ bThaiT = true;
+ sStrArray[i] = sKeyword[nTypeArray[i]];
+ }
+ else if (sStrArray[i][0] >= '0' &&
+ sStrArray[i][0] <= '9' && !bDenomin) // denominator was not yet found
+ {
+ OUString sDiv;
+ sal_uInt16 j = i;
+ while(j < nStringsCnt && sStrArray[j][0] >= '0' && sStrArray[j][0] <= '9')
+ {
+ sDiv += sStrArray[j++];
+ }
+ assert(j > 0 && "if i is 0, first iteration through loop is guaranteed by surrounding if condition");
+ if (std::u16string_view(OUString::number(sDiv.toInt32())) == sDiv)
+ {
+ // Found a Divisor
+ while (i < j)
+ {
+ nTypeArray[i++] = NF_SYMBOLTYPE_FRAC_FDIV;
+ }
+ i = j - 1; // Stop the loop
+ if (nCntPost)
+ {
+ nCounter = nCntPost;
+ }
+ else if (nCntPre)
+ {
+ nCounter = nCntPre;
+ }
+ // don't artificially increment nCntPre for forced denominator
+ if ( ( eScannedType != SvNumFormatType::FRACTION ) && (!nCntPre) )
+ {
+ nCntPre++;
+ }
+ if ( bFrac )
+ bDenomin = true; // next content should be treated as outside denominator
+ }
+ }
+ else
+ {
+ if ( bFrac && ( nCounter > 0 ) )
+ bDenomin = true; // next content should be treated as outside denominator
+ nTypeArray[i] = NF_SYMBOLTYPE_STRING;
+ }
+ nPos = nPos + sStrArray[i].getLength();
+ i++;
+ }
+ else if (nTypeArray[i] == NF_SYMBOLTYPE_DEL)
+ {
+ sal_Unicode cHere = sStrArray[i][0];
+ sal_Unicode cSaved = cHere;
+ // Handle not pre-known separators in switch.
+ sal_Unicode cSimplified;
+ if (StringEqualsChar( pFormatter->GetNumThousandSep(), cHere))
+ {
+ cSimplified = ',';
+ }
+ else if (StringEqualsChar( pFormatter->GetNumDecimalSep(), cHere))
+ {
+ cSimplified = '.';
+ }
+ else
+ {
+ cSimplified = cHere;
+ }
+
+ OUString& rStr = sStrArray[i];
+
+ switch ( cSimplified )
+ {
+ case '#':
+ case '0':
+ case '?':
+ if (nThousand > 0) // #... #
+ {
+ return nPos; // Error
+ }
+ if ( !bDenomin )
+ {
+ nTypeArray[i] = NF_SYMBOLTYPE_DIGIT;
+ nPos = nPos + rStr.getLength();
+ i++;
+ nCounter++;
+ while (i < nStringsCnt &&
+ (sStrArray[i][0] == '#' ||
+ sStrArray[i][0] == '0' ||
+ sStrArray[i][0] == '?'))
+ {
+ nTypeArray[i] = NF_SYMBOLTYPE_DIGIT;
+ nPos = nPos + sStrArray[i].getLength();
+ nCounter++;
+ i++;
+ }
+ }
+ else // after denominator, treat any character as text
+ {
+ nTypeArray[i] = NF_SYMBOLTYPE_STRING;
+ nPos = nPos + sStrArray[i].getLength();
+ }
+ break;
+ case '-':
+ if ( bDecSep && nDecPos+1 == i &&
+ nTypeArray[nDecPos] == NF_SYMBOLTYPE_DECSEP )
+ {
+ // "0.--"
+ nTypeArray[i] = NF_SYMBOLTYPE_DIGIT;
+ nPos = nPos + rStr.getLength();
+ i++;
+ nCounter++;
+ while (i < nStringsCnt &&
+ (sStrArray[i][0] == '-') )
+ {
+ // If more than two dashes are present in
+ // currency formats the last dash will be
+ // interpreted literally as a minus sign.
+ // Has to be this ugly. Period.
+ if ( eScannedType == SvNumFormatType::CURRENCY
+ && rStr.getLength() >= 2 &&
+ (i == nStringsCnt-1 ||
+ sStrArray[i+1][0] != '-') )
+ {
+ break;
+ }
+ rStr += sStrArray[i];
+ nPos = nPos + sStrArray[i].getLength();
+ nTypeArray[i] = NF_SYMBOLTYPE_EMPTY;
+ nResultStringsCnt--;
+ nCounter++;
+ i++;
+ }
+ }
+ else
+ {
+ nTypeArray[i] = NF_SYMBOLTYPE_STRING;
+ nPos = nPos + sStrArray[i].getLength();
+ i++;
+ }
+ break;
+ case '.':
+ case ',':
+ case '\'':
+ case ' ':
+ if ( StringEqualsChar( sOldThousandSep, cSaved ) )
+ {
+ // previous char with skip empty
+ sal_Unicode cPre = PreviousChar(i);
+ sal_Unicode cNext;
+ if (bExp || bBlank || bFrac)
+ {
+ // after E, / or ' '
+ if ( !StringEqualsChar( sOldThousandSep, ' ' ) )
+ {
+ nPos = nPos + sStrArray[i].getLength();
+ nTypeArray[i] = NF_SYMBOLTYPE_EMPTY;
+ nResultStringsCnt--;
+ i++; // eat it
+ }
+ else
+ {
+ nTypeArray[i] = NF_SYMBOLTYPE_STRING;
+ if ( bFrac && (nCounter > 0) )
+ bDenomin = true; // end of denominator
+ }
+ }
+ else if (i > 0 && i < nStringsCnt-1 &&
+ (cPre == '#' || cPre == '0' || cPre == '?') &&
+ ((cNext = NextChar(i)) == '#' || cNext == '0' || cNext == '?')) // #,#
+ {
+ nPos = nPos + sStrArray[i].getLength();
+ if (!bThousand) // only once
+ {
+ bThousand = true;
+ }
+ // Eat it, will be reinserted at proper grouping positions further down.
+ nTypeArray[i] = NF_SYMBOLTYPE_EMPTY;
+ nResultStringsCnt--;
+ i++;
+ }
+ else if (i > 0 && (cPre == '#' || cPre == '0' || cPre == '?')
+ && PreviousType(i) == NF_SYMBOLTYPE_DIGIT
+ && nThousand < FLAG_STANDARD_IN_FORMAT )
+ { // #,,,,
+ if ( StringEqualsChar( sOldThousandSep, ' ' ) )
+ {
+ // strange, those French...
+ bool bFirst = true;
+ // set a hard No-Break Space or ConvertMode
+ const OUString& rSepF = pFormatter->GetNumThousandSep();
+ while ( i < nStringsCnt &&
+ sStrArray[i] == sOldThousandSep &&
+ StringEqualsChar( sOldThousandSep, NextChar(i) ) )
+ { // last was a space or another space
+ // is following => separator
+ nPos = nPos + sStrArray[i].getLength();
+ if ( bFirst )
+ {
+ bFirst = false;
+ rStr = rSepF;
+ nTypeArray[i] = NF_SYMBOLTYPE_THSEP;
+ }
+ else
+ {
+ rStr += rSepF;
+ nTypeArray[i] = NF_SYMBOLTYPE_EMPTY;
+ nResultStringsCnt--;
+ }
+ nThousand++;
+ i++;
+ }
+ if ( i < nStringsCnt-1 &&
+ sStrArray[i] == sOldThousandSep )
+ {
+ // something following last space
+ // => space if currency contained,
+ // else separator
+ nPos = nPos + sStrArray[i].getLength();
+ if ( (nPos <= nCurrPos &&
+ nCurrPos < nPos + sStrArray[i+1].getLength()) ||
+ nTypeArray[i+1] == NF_KEY_CCC ||
+ (i < nStringsCnt-2 &&
+ sStrArray[i+1][0] == '[' &&
+ sStrArray[i+2][0] == '$') )
+ {
+ nTypeArray[i] = NF_SYMBOLTYPE_STRING;
+ }
+ else
+ {
+ if ( bFirst )
+ {
+ rStr = rSepF;
+ nTypeArray[i] = NF_SYMBOLTYPE_THSEP;
+ }
+ else
+ {
+ rStr += rSepF;
+ nTypeArray[i] = NF_SYMBOLTYPE_EMPTY;
+ nResultStringsCnt--;
+ }
+ nThousand++;
+ }
+ i++;
+ }
+ }
+ else
+ {
+ do
+ {
+ nThousand++;
+ nTypeArray[i] = NF_SYMBOLTYPE_THSEP;
+ nPos = nPos + sStrArray[i].getLength();
+ sStrArray[i] = pFormatter->GetNumThousandSep();
+ i++;
+ }
+ while (i < nStringsCnt && sStrArray[i] == sOldThousandSep);
+ }
+ }
+ else // any grsep
+ {
+ nTypeArray[i] = NF_SYMBOLTYPE_STRING;
+ nPos = nPos + rStr.getLength();
+ i++;
+ while ( i < nStringsCnt && sStrArray[i] == sOldThousandSep )
+ {
+ rStr += sStrArray[i];
+ nPos = nPos + sStrArray[i].getLength();
+ nTypeArray[i] = NF_SYMBOLTYPE_EMPTY;
+ nResultStringsCnt--;
+ i++;
+ }
+ }
+ }
+ else if ( StringEqualsChar( sOldDecSep, cSaved ) )
+ {
+ if (bBlank || bFrac) // . behind / or ' '
+ {
+ return nPos; // error
+ }
+ else if (bExp) // behind E
+ {
+ nPos = nPos + sStrArray[i].getLength();
+ nTypeArray[i] = NF_SYMBOLTYPE_EMPTY;
+ nResultStringsCnt--;
+ i++; // eat it
+ }
+ else if (bDecSep) // any .
+ {
+ nTypeArray[i] = NF_SYMBOLTYPE_STRING;
+ nPos = nPos + rStr.getLength();
+ i++;
+ while ( i < nStringsCnt && sStrArray[i] == sOldDecSep )
+ {
+ rStr += sStrArray[i];
+ nPos = nPos + sStrArray[i].getLength();
+ nTypeArray[i] = NF_SYMBOLTYPE_EMPTY;
+ nResultStringsCnt--;
+ i++;
+ }
+ }
+ else
+ {
+ nPos = nPos + sStrArray[i].getLength();
+ nTypeArray[i] = NF_SYMBOLTYPE_DECSEP;
+ sStrArray[i] = pFormatter->GetNumDecimalSep();
+ bDecSep = true;
+ nDecPos = i;
+ nCntPre = nCounter;
+ nCounter = 0;
+
+ i++;
+ }
+ } // of else = DecSep
+ else // . without meaning
+ {
+ if (cSaved == ' ' &&
+ eScannedType == SvNumFormatType::FRACTION &&
+ StringEqualsChar( sStrArray[i], ' ' ) )
+ {
+ if (!bBlank && !bFrac) // no dups
+ { // or behind /
+ if (bDecSep && nCounter > 0) // dec.
+ {
+ return nPos; // error
+ }
+ bBlank = true;
+ nBlankPos = i;
+ nCntPre = nCounter;
+ nCounter = 0;
+ }
+ if ( bFrac && (nCounter > 0) )
+ bDenomin = true; // next content is not part of denominator
+ nTypeArray[i] = NF_SYMBOLTYPE_STRING;
+ nPos = nPos + sStrArray[i].getLength();
+ }
+ else
+ {
+ nTypeArray[i] = NF_SYMBOLTYPE_STRING;
+ if ( bFrac && (nCounter > 0) )
+ bDenomin = true; // next content is not part of denominator
+ nPos = nPos + rStr.getLength();
+ i++;
+ while (i < nStringsCnt && StringEqualsChar( sStrArray[i], cSaved ) )
+ {
+ rStr += sStrArray[i];
+ nPos = nPos + sStrArray[i].getLength();
+ nTypeArray[i] = NF_SYMBOLTYPE_EMPTY;
+ nResultStringsCnt--;
+ i++;
+ }
+ }
+ }
+ break;
+ case '/':
+ if (eScannedType == SvNumFormatType::FRACTION)
+ {
+ if ( i == 0 ||
+ (nTypeArray[i-1] != NF_SYMBOLTYPE_DIGIT &&
+ nTypeArray[i-1] != NF_SYMBOLTYPE_EMPTY) )
+ {
+ return nPos ? nPos : 1; // /? not allowed
+ }
+ else if (!bFrac || (bDecSep && nCounter > 0))
+ {
+ bFrac = true;
+ nCntPost = nCounter;
+ nCounter = 0;
+ nTypeArray[i] = NF_SYMBOLTYPE_FRAC;
+ nPos = nPos + sStrArray[i].getLength();
+ i++;
+ }
+ else // / double or in , in the denominator
+ {
+ return nPos; // Error
+ }
+ }
+ else
+ {
+ nTypeArray[i] = NF_SYMBOLTYPE_STRING;
+ nPos = nPos + sStrArray[i].getLength();
+ i++;
+ }
+ break;
+ case '[' :
+ if ( eScannedType == SvNumFormatType::CURRENCY &&
+ i < nStringsCnt-1 &&
+ nTypeArray[i+1] == NF_SYMBOLTYPE_STRING &&
+ sStrArray[i+1][0] == '$' )
+ {
+ // [$DM-xxx]
+ nPos = nPos + sStrArray[i].getLength(); // [
+ nTypeArray[i] = NF_SYMBOLTYPE_CURRDEL;
+ nPos = nPos + sStrArray[++i].getLength(); // $
+ sStrArray[i-1] += sStrArray[i]; // [$
+ nTypeArray[i] = NF_SYMBOLTYPE_EMPTY;
+ nResultStringsCnt--;
+ if ( ++i >= nStringsCnt )
+ {
+ return nPos; // Error
+ }
+ nPos = nPos + sStrArray[i].getLength(); // DM
+ OUString* pStr = &sStrArray[i];
+ nTypeArray[i] = NF_SYMBOLTYPE_CURRENCY; // convert
+ bool bHadDash = false;
+ i++;
+ while ( i < nStringsCnt && sStrArray[i][0] != ']' )
+ {
+ nPos = nPos + sStrArray[i].getLength();
+ if ( bHadDash )
+ {
+ *pStr += sStrArray[i];
+ nTypeArray[i] = NF_SYMBOLTYPE_EMPTY;
+ nResultStringsCnt--;
+ }
+ else
+ {
+ if ( sStrArray[i][0] == '-' )
+ {
+ bHadDash = true;
+ pStr = &sStrArray[i];
+ nTypeArray[i] = NF_SYMBOLTYPE_CURREXT;
+ }
+ else
+ {
+ *pStr += sStrArray[i];
+ nTypeArray[i] = NF_SYMBOLTYPE_EMPTY;
+ nResultStringsCnt--;
+ }
+ }
+ i++;
+ }
+ if ( rStr.getLength() && i < nStringsCnt && sStrArray[i][0] == ']' )
+ {
+ nTypeArray[i] = NF_SYMBOLTYPE_CURRDEL;
+ nPos = nPos + sStrArray[i].getLength();
+ i++;
+ }
+ else
+ {
+ return nPos; // Error
+ }
+ }
+ else
+ {
+ nTypeArray[i] = NF_SYMBOLTYPE_STRING;
+ nPos = nPos + sStrArray[i].getLength();
+ i++;
+ }
+ break;
+ default: // Other Dels
+ if (eScannedType == SvNumFormatType::PERCENT && cHere == '%')
+ {
+ nTypeArray[i] = NF_SYMBOLTYPE_PERCENT;
+ }
+ else
+ {
+ nTypeArray[i] = NF_SYMBOLTYPE_STRING;
+ }
+ nPos = nPos + sStrArray[i].getLength();
+ i++;
+ break;
+ } // of switch (Del)
+ } // of else Del
+ else
+ {
+ SAL_WARN( "svl.numbers", "unknown NF_SYMBOLTYPE_..." );
+ nPos = nPos + sStrArray[i].getLength();
+ i++;
+ }
+ } // of while
+ if (eScannedType == SvNumFormatType::FRACTION)
+ {
+ if (bFrac)
+ {
+ nCntExp = nCounter;
+ }
+ else if (bBlank)
+ {
+ nCntPost = nCounter;
+ }
+ else
+ {
+ nCntPre = nCounter;
+ }
+ }
+ else
+ {
+ if (bExp)
+ {
+ nCntExp = nCounter;
+ }
+ else if (bDecSep)
+ {
+ nCntPost = nCounter;
+ }
+ else
+ {
+ nCntPre = nCounter;
+ }
+ }
+ if (bThousand) // Expansion of grouping separators
+ {
+ sal_uInt16 nMaxPos;
+ if (bFrac)
+ {
+ if (bBlank)
+ {
+ nMaxPos = nBlankPos;
+ }
+ else
+ {
+ nMaxPos = 0; // no grouping
+ }
+ }
+ else if (bDecSep) // decimal separator present
+ {
+ nMaxPos = nDecPos;
+ }
+ else if (bExp) // 'E' exponent present
+ {
+ nMaxPos = nExpPos;
+ }
+ else // up to end
+ {
+ nMaxPos = i;
+ }
+ // Insert separators at proper positions.
+ sal_Int32 nCount = 0;
+ utl::DigitGroupingIterator aGrouping( pLoc->getDigitGrouping());
+ size_t nFirstDigitSymbol = nMaxPos;
+ size_t nFirstGroupingSymbol = nMaxPos;
+ i = nMaxPos;
+ while (i-- > 0)
+ {
+ if (nTypeArray[i] == NF_SYMBOLTYPE_DIGIT)
+ {
+ nFirstDigitSymbol = i;
+ nCount = nCount + sStrArray[i].getLength(); // MSC converts += to int and then warns, so ...
+ // Insert separator only if not leftmost symbol.
+ if (i > 0 && nCount >= aGrouping.getPos())
+ {
+ DBG_ASSERT( sStrArray[i].getLength() == 1,
+ "ImpSvNumberformatScan::FinalScan: combined digits in group separator insertion");
+ if (!InsertSymbol( i, NF_SYMBOLTYPE_THSEP, pFormatter->GetNumThousandSep()))
+ {
+ // nPos isn't correct here, but signals error
+ return nPos;
+ }
+ // i may have been decremented by 1
+ nFirstDigitSymbol = i + 1;
+ nFirstGroupingSymbol = i;
+ aGrouping.advance();
+ }
+ }
+ }
+ // Generated something like "string",000; remove separator again.
+ if (nFirstGroupingSymbol < nFirstDigitSymbol)
+ {
+ nTypeArray[nFirstGroupingSymbol] = NF_SYMBOLTYPE_EMPTY;
+ nResultStringsCnt--;
+ }
+ }
+ // Combine digits into groups to save memory (Info will be copied
+ // later, taking only non-empty symbols).
+ for (i = 0; i < nStringsCnt; ++i)
+ {
+ if (nTypeArray[i] == NF_SYMBOLTYPE_DIGIT)
+ {
+ OUString& rStr = sStrArray[i];
+ while (++i < nStringsCnt && nTypeArray[i] == NF_SYMBOLTYPE_DIGIT)
+ {
+ rStr += sStrArray[i];
+ nTypeArray[i] = NF_SYMBOLTYPE_EMPTY;
+ nResultStringsCnt--;
+ }
+ }
+ }
+ break; // of SvNumFormatType::NUMBER
+ case SvNumFormatType::DATE:
+ while (i < nStringsCnt)
+ {
+ switch (nTypeArray[i])
+ {
+ case NF_SYMBOLTYPE_BLANK:
+ case NF_SYMBOLTYPE_STAR:
+ case NF_SYMBOLTYPE_STRING:
+ nPos = nPos + sStrArray[i].getLength();
+ i++;
+ break;
+ case NF_SYMBOLTYPE_DEL:
+ int nCalRet;
+ if (sStrArray[i] == sOldDateSep)
+ {
+ nTypeArray[i] = NF_SYMBOLTYPE_DATESEP;
+ nPos = nPos + sStrArray[i].getLength();
+ if (bConvertMode)
+ {
+ sStrArray[i] = pFormatter->GetDateSep();
+ }
+ i++;
+ }
+ else if ( (nCalRet = FinalScanGetCalendar( nPos, i, nResultStringsCnt )) != 0 )
+ {
+ if ( nCalRet < 0 )
+ {
+ return nPos; // error
+ }
+ }
+ else
+ {
+ nTypeArray[i] = NF_SYMBOLTYPE_STRING;
+ nPos = nPos + sStrArray[i].getLength();
+ i++;
+ }
+ break;
+ case NF_KEY_THAI_T :
+ bThaiT = true;
+ [[fallthrough]];
+ case NF_KEY_M: // M
+ case NF_KEY_MM: // MM
+ case NF_KEY_MMM: // MMM
+ case NF_KEY_MMMM: // MMMM
+ case NF_KEY_MMMMM: // MMMMM
+ case NF_KEY_Q: // Q
+ case NF_KEY_QQ: // QQ
+ case NF_KEY_D: // D
+ case NF_KEY_DD: // DD
+ case NF_KEY_DDD: // DDD
+ case NF_KEY_DDDD: // DDDD
+ case NF_KEY_YY: // YY
+ case NF_KEY_YYYY: // YYYY
+ case NF_KEY_NN: // NN
+ case NF_KEY_NNN: // NNN
+ case NF_KEY_NNNN: // NNNN
+ case NF_KEY_WW : // WW
+ case NF_KEY_AAA : // AAA
+ case NF_KEY_AAAA : // AAAA
+ case NF_KEY_EC : // E
+ case NF_KEY_EEC : // EE
+ case NF_KEY_G : // G
+ case NF_KEY_GG : // GG
+ case NF_KEY_GGG : // GGG
+ case NF_KEY_R : // R
+ case NF_KEY_RR : // RR
+ sStrArray[i] = sKeyword[nTypeArray[i]]; // tTtT -> TTTT
+ nPos = nPos + sStrArray[i].getLength();
+ if (bNewDateOrder)
+ {
+ // For simple numeric date formats record date order and
+ // later rearrange.
+ switch (nTypeArray[i])
+ {
+ case NF_KEY_M:
+ case NF_KEY_MM:
+ if (nMonthPos == SAL_MAX_UINT16)
+ nMonthPos = i;
+ else
+ bNewDateOrder = false;
+ break;
+ case NF_KEY_D:
+ case NF_KEY_DD:
+ if (nDayPos == SAL_MAX_UINT16)
+ nDayPos = i;
+ else
+ bNewDateOrder = false;
+ break;
+ case NF_KEY_YY:
+ case NF_KEY_YYYY:
+ if (nYearPos == SAL_MAX_UINT16)
+ nYearPos = i;
+ else
+ bNewDateOrder = false;
+ break;
+ default:
+ ; // nothing
+ }
+ }
+ i++;
+ break;
+ default: // Other keywords
+ nTypeArray[i] = NF_SYMBOLTYPE_STRING;
+ nPos = nPos + sStrArray[i].getLength();
+ i++;
+ break;
+ }
+ } // of while
+ break; // of SvNumFormatType::DATE
+ case SvNumFormatType::TIME:
+ while (i < nStringsCnt)
+ {
+ sal_Unicode cChar;
+
+ switch (nTypeArray[i])
+ {
+ case NF_SYMBOLTYPE_BLANK:
+ case NF_SYMBOLTYPE_STAR:
+ nPos = nPos + sStrArray[i].getLength();
+ i++;
+ break;
+ case NF_SYMBOLTYPE_DEL:
+ switch( sStrArray[i][0] )
+ {
+ case '0':
+ if ( Is100SecZero( i, bDecSep ) )
+ {
+ bDecSep = true;
+ nTypeArray[i] = NF_SYMBOLTYPE_DIGIT;
+ OUString& rStr = sStrArray[i];
+ nCounter++;
+ i++;
+ while (i < nStringsCnt &&
+ sStrArray[i][0] == '0')
+ {
+ rStr += sStrArray[i];
+ nTypeArray[i] = NF_SYMBOLTYPE_EMPTY;
+ nResultStringsCnt--;
+ nCounter++;
+ i++;
+ }
+ nPos += rStr.getLength();
+ }
+ else
+ {
+ return nPos;
+ }
+ break;
+ case '#':
+ case '?':
+ return nPos;
+ case '[':
+ if (bThousand) // Double
+ {
+ return nPos;
+ }
+ bThousand = true; // Empty for Time
+ cChar = pChrCls->uppercase(OUString(NextChar(i)))[0];
+ if ( cChar == cOldKeyH )
+ {
+ nThousand = 1; // H
+ }
+ else if ( cChar == cOldKeyMI )
+ {
+ nThousand = 2; // M
+ }
+ else if ( cChar == cOldKeyS )
+ {
+ nThousand = 3; // S
+ }
+ else
+ {
+ return nPos;
+ }
+ nPos = nPos + sStrArray[i].getLength();
+ i++;
+ break;
+ case ']':
+ if (!bThousand) // No preceding [
+ {
+ return nPos;
+ }
+ nPos = nPos + sStrArray[i].getLength();
+ i++;
+ break;
+ default:
+ nPos = nPos + sStrArray[i].getLength();
+ if ( sStrArray[i] == sOldTimeSep )
+ {
+ nTypeArray[i] = NF_SYMBOLTYPE_TIMESEP;
+ if ( bConvertMode )
+ {
+ sStrArray[i] = pLoc->getTimeSep();
+ }
+ }
+ else if ( sStrArray[i] == sOldTime100SecSep )
+ {
+ bDecSep = true;
+ nTypeArray[i] = NF_SYMBOLTYPE_TIME100SECSEP;
+ if ( bConvertMode )
+ {
+ sStrArray[i] = pLoc->getTime100SecSep();
+ }
+ }
+ else
+ {
+ nTypeArray[i] = NF_SYMBOLTYPE_STRING;
+ }
+ i++;
+ break;
+ }
+ break;
+ case NF_SYMBOLTYPE_STRING:
+ nPos = nPos + sStrArray[i].getLength();
+ i++;
+ break;
+ case NF_KEY_AMPM: // AM/PM
+ case NF_KEY_AP: // A/P
+ bExp = true; // Abuse for A/P
+ sStrArray[i] = sKeyword[nTypeArray[i]]; // tTtT -> TTTT
+ nPos = nPos + sStrArray[i].getLength();
+ i++;
+ break;
+ case NF_KEY_THAI_T :
+ bThaiT = true;
+ [[fallthrough]];
+ case NF_KEY_MI: // M
+ case NF_KEY_MMI: // MM
+ case NF_KEY_H: // H
+ case NF_KEY_HH: // HH
+ case NF_KEY_S: // S
+ case NF_KEY_SS: // SS
+ sStrArray[i] = sKeyword[nTypeArray[i]]; // tTtT -> TTTT
+ nPos = nPos + sStrArray[i].getLength();
+ i++;
+ break;
+ default: // Other keywords
+ nTypeArray[i] = NF_SYMBOLTYPE_STRING;
+ nPos = nPos + sStrArray[i].getLength();
+ i++;
+ break;
+ }
+ } // of while
+ nCntPost = nCounter; // Zero counter
+ if (bExp)
+ {
+ nCntExp = 1; // Remembers AM/PM
+ }
+ break; // of SvNumFormatType::TIME
+ case SvNumFormatType::DATETIME:
+ while (i < nStringsCnt)
+ {
+ int nCalRet;
+ switch (nTypeArray[i])
+ {
+ case NF_SYMBOLTYPE_BLANK:
+ case NF_SYMBOLTYPE_STAR:
+ case NF_SYMBOLTYPE_STRING:
+ nPos = nPos + sStrArray[i].getLength();
+ i++;
+ break;
+ case NF_SYMBOLTYPE_DEL:
+ if ( (nCalRet = FinalScanGetCalendar( nPos, i, nResultStringsCnt )) != 0 )
+ {
+ if ( nCalRet < 0 )
+ {
+ return nPos; // Error
+ }
+ }
+ else
+ {
+ switch( sStrArray[i][0] )
+ {
+ case '0':
+ if (bTimePart && Is100SecZero(i, bDecSep) && nCounter < MaxCntPost)
+ {
+ bDecSep = true;
+ nTypeArray[i] = NF_SYMBOLTYPE_DIGIT;
+ OUString& rStr = sStrArray[i];
+ nCounter++;
+ i++;
+ while (i < nStringsCnt &&
+ sStrArray[i][0] == '0' && nCounter < MaxCntPost)
+ {
+ rStr += sStrArray[i];
+ nTypeArray[i] = NF_SYMBOLTYPE_EMPTY;
+ nResultStringsCnt--;
+ nCounter++;
+ i++;
+ }
+ nPos += rStr.getLength();
+ }
+ else
+ {
+ return nPos;
+ }
+ break;
+ case '#':
+ case '?':
+ return nPos;
+ default:
+ nPos = nPos + sStrArray[i].getLength();
+ if (bTimePart)
+ {
+ if ( sStrArray[i] == sOldTimeSep )
+ {
+ nTypeArray[i] = NF_SYMBOLTYPE_TIMESEP;
+ if ( bConvertMode )
+ {
+ sStrArray[i] = pLoc->getTimeSep();
+ }
+ }
+ else if ( sStrArray[i] == sOldTime100SecSep )
+ {
+ bDecSep = true;
+ nTypeArray[i] = NF_SYMBOLTYPE_TIME100SECSEP;
+ if ( bConvertMode )
+ {
+ sStrArray[i] = pLoc->getTime100SecSep();
+ }
+ }
+ else
+ {
+ nTypeArray[i] = NF_SYMBOLTYPE_STRING;
+ }
+ }
+ else
+ {
+ if ( sStrArray[i] == sOldDateSep )
+ {
+ nTypeArray[i] = NF_SYMBOLTYPE_DATESEP;
+ if (bConvertMode)
+ sStrArray[i] = pFormatter->GetDateSep();
+ }
+ else
+ {
+ nTypeArray[i] = NF_SYMBOLTYPE_STRING;
+ }
+ }
+ i++;
+ break;
+ }
+ }
+ break;
+ case NF_KEY_AMPM: // AM/PM
+ case NF_KEY_AP: // A/P
+ bTimePart = true;
+ bExp = true; // Abuse for A/P
+ sStrArray[i] = sKeyword[nTypeArray[i]]; // tTtT -> TTTT
+ nPos = nPos + sStrArray[i].getLength();
+ i++;
+ break;
+ case NF_KEY_MI: // M
+ case NF_KEY_MMI: // MM
+ case NF_KEY_H: // H
+ case NF_KEY_HH: // HH
+ case NF_KEY_S: // S
+ case NF_KEY_SS: // SS
+ bTimePart = true;
+ sStrArray[i] = sKeyword[nTypeArray[i]]; // tTtT -> TTTT
+ nPos = nPos + sStrArray[i].getLength();
+ i++;
+ break;
+ case NF_KEY_M: // M
+ case NF_KEY_MM: // MM
+ case NF_KEY_MMM: // MMM
+ case NF_KEY_MMMM: // MMMM
+ case NF_KEY_MMMMM: // MMMMM
+ case NF_KEY_Q: // Q
+ case NF_KEY_QQ: // QQ
+ case NF_KEY_D: // D
+ case NF_KEY_DD: // DD
+ case NF_KEY_DDD: // DDD
+ case NF_KEY_DDDD: // DDDD
+ case NF_KEY_YY: // YY
+ case NF_KEY_YYYY: // YYYY
+ case NF_KEY_NN: // NN
+ case NF_KEY_NNN: // NNN
+ case NF_KEY_NNNN: // NNNN
+ case NF_KEY_WW : // WW
+ case NF_KEY_AAA : // AAA
+ case NF_KEY_AAAA : // AAAA
+ case NF_KEY_EC : // E
+ case NF_KEY_EEC : // EE
+ case NF_KEY_G : // G
+ case NF_KEY_GG : // GG
+ case NF_KEY_GGG : // GGG
+ case NF_KEY_R : // R
+ case NF_KEY_RR : // RR
+ bTimePart = false;
+ sStrArray[i] = sKeyword[nTypeArray[i]]; // tTtT -> TTTT
+ nPos = nPos + sStrArray[i].getLength();
+ if (bNewDateOrder)
+ {
+ // For simple numeric date formats record date order and
+ // later rearrange.
+ switch (nTypeArray[i])
+ {
+ case NF_KEY_M:
+ case NF_KEY_MM:
+ if (nMonthPos == SAL_MAX_UINT16)
+ nMonthPos = i;
+ else
+ bNewDateOrder = false;
+ break;
+ case NF_KEY_D:
+ case NF_KEY_DD:
+ if (nDayPos == SAL_MAX_UINT16)
+ nDayPos = i;
+ else
+ bNewDateOrder = false;
+ break;
+ case NF_KEY_YY:
+ case NF_KEY_YYYY:
+ if (nYearPos == SAL_MAX_UINT16)
+ nYearPos = i;
+ else
+ bNewDateOrder = false;
+ break;
+ default:
+ ; // nothing
+ }
+ }
+ i++;
+ break;
+ case NF_KEY_THAI_T :
+ bThaiT = true;
+ sStrArray[i] = sKeyword[nTypeArray[i]];
+ nPos = nPos + sStrArray[i].getLength();
+ i++;
+ break;
+ default: // Other keywords
+ nTypeArray[i] = NF_SYMBOLTYPE_STRING;
+ nPos = nPos + sStrArray[i].getLength();
+ i++;
+ break;
+ }
+ } // of while
+ nCntPost = nCounter; // decimals (100th seconds)
+ if (bExp)
+ {
+ nCntExp = 1; // Remembers AM/PM
+ }
+ break; // of SvNumFormatType::DATETIME
+ default:
+ break;
+ }
+ if (eScannedType == SvNumFormatType::SCIENTIFIC &&
+ (nCntPre + nCntPost == 0 || nCntExp == 0))
+ {
+ return nPos;
+ }
+ else if (eScannedType == SvNumFormatType::FRACTION && (nCntExp > 8 || nCntExp == 0))
+ {
+ return nPos;
+ }
+ if (bThaiT && !GetNatNumModifier())
+ {
+ SetNatNumModifier(1);
+ }
+ if ( bConvertMode )
+ {
+ if (bNewDateOrder && sOldDateSep == "-")
+ {
+ // Keep ISO formats Y-M-D, Y-M and M-D
+ if (IsDateFragment( nYearPos, nMonthPos))
+ {
+ nTypeArray[nYearPos+1] = NF_SYMBOLTYPE_STRING;
+ sStrArray[nYearPos+1] = sOldDateSep;
+ bNewDateOrder = false;
+ }
+ if (IsDateFragment( nMonthPos, nDayPos))
+ {
+ nTypeArray[nMonthPos+1] = NF_SYMBOLTYPE_STRING;
+ sStrArray[nMonthPos+1] = sOldDateSep;
+ bNewDateOrder = false;
+ }
+ }
+ if (bNewDateOrder)
+ {
+ // Rearrange date order to the target locale if the original order
+ // includes date separators and is adjacent.
+ /* TODO: for incomplete dates trailing separators need to be
+ * handled according to the locale's usage, e.g. en-US M/D should
+ * be converted to de-DE D.M. and vice versa. As is, it's
+ * M/D -> D.M and D.M. -> M/D/ where specifically the latter looks
+ * odd. Check accepted date patterns and append/remove? */
+ switch (eOldDateOrder)
+ {
+ case DateOrder::DMY:
+ switch (pLoc->getDateOrder())
+ {
+ case DateOrder::MDY:
+ // Convert only if the actual format is not of YDM
+ // order (which would be a completely unusual order
+ // anyway, but..), e.g. YYYY.DD.MM not to
+ // YYYY/MM/DD
+ if (IsDateFragment( nDayPos, nMonthPos) && !IsDateFragment( nYearPos, nDayPos))
+ SwapArrayElements( nDayPos, nMonthPos);
+ break;
+ case DateOrder::YMD:
+ if (nYearPos != SAL_MAX_UINT16)
+ {
+ if (IsDateFragment( nDayPos, nMonthPos) && IsDateFragment( nMonthPos, nYearPos))
+ SwapArrayElements( nDayPos, nYearPos);
+ }
+ else
+ {
+ if (IsDateFragment( nDayPos, nMonthPos))
+ SwapArrayElements( nDayPos, nMonthPos);
+ }
+ break;
+ default:
+ ; // nothing
+ }
+ break;
+ case DateOrder::MDY:
+ switch (pLoc->getDateOrder())
+ {
+ case DateOrder::DMY:
+ // Convert only if the actual format is not of YMD
+ // order, e.g. YYYY/MM/DD not to YYYY.DD.MM
+ /* TODO: convert such to DD.MM.YYYY instead? */
+ if (IsDateFragment( nMonthPos, nDayPos) && !IsDateFragment( nYearPos, nMonthPos))
+ SwapArrayElements( nMonthPos, nDayPos);
+ break;
+ case DateOrder::YMD:
+ if (nYearPos != SAL_MAX_UINT16)
+ {
+ if (IsDateFragment( nMonthPos, nDayPos) && IsDateFragment( nDayPos, nYearPos))
+ {
+ SwapArrayElements( nYearPos, nMonthPos); // YDM
+ SwapArrayElements( nYearPos, nDayPos); // YMD
+ }
+ }
+ break;
+ default:
+ ; // nothing
+ }
+ break;
+ case DateOrder::YMD:
+ switch (pLoc->getDateOrder())
+ {
+ case DateOrder::DMY:
+ if (nYearPos != SAL_MAX_UINT16)
+ {
+ if (IsDateFragment( nYearPos, nMonthPos) && IsDateFragment( nMonthPos, nDayPos))
+ SwapArrayElements( nYearPos, nDayPos);
+ }
+ else
+ {
+ if (IsDateFragment( nMonthPos, nDayPos))
+ SwapArrayElements( nMonthPos, nDayPos);
+ }
+ break;
+ case DateOrder::MDY:
+ if (nYearPos != SAL_MAX_UINT16)
+ {
+ if (IsDateFragment( nYearPos, nMonthPos) && IsDateFragment( nMonthPos, nDayPos))
+ {
+ SwapArrayElements( nYearPos, nDayPos); // DMY
+ SwapArrayElements( nYearPos, nMonthPos); // MDY
+ }
+ }
+ break;
+ default:
+ ; // nothing
+ }
+ break;
+ default:
+ ; // nothing
+ }
+ }
+ // strings containing keywords of the target locale must be quoted, so
+ // the user sees the difference and is able to edit the format string
+ for ( i=0; i < nStringsCnt; i++ )
+ {
+ if ( nTypeArray[i] == NF_SYMBOLTYPE_STRING &&
+ sStrArray[i][0] != '\"' )
+ {
+ if ( bConvertSystemToSystem && eScannedType == SvNumFormatType::CURRENCY )
+ {
+ // don't stringize automatic currency, will be converted
+ if ( sStrArray[i] == sOldCurSymbol )
+ {
+ continue; // for
+ }
+ // DM might be split into D and M
+ if ( sStrArray[i].getLength() < sOldCurSymbol.getLength() &&
+ pChrCls->uppercase( sStrArray[i], 0, 1 )[0] ==
+ sOldCurString[0] )
+ {
+ OUString aTmp( sStrArray[i] );
+ sal_uInt16 j = i + 1;
+ while ( aTmp.getLength() < sOldCurSymbol.getLength() &&
+ j < nStringsCnt &&
+ nTypeArray[j] == NF_SYMBOLTYPE_STRING )
+ {
+ aTmp += sStrArray[j++];
+ }
+ if ( pChrCls->uppercase( aTmp ) == sOldCurString )
+ {
+ sStrArray[i++] = aTmp;
+ for ( ; i<j; i++ )
+ {
+ nTypeArray[i] = NF_SYMBOLTYPE_EMPTY;
+ nResultStringsCnt--;
+ }
+ i = j - 1;
+ continue; // for
+ }
+ }
+ }
+ OUString& rStr = sStrArray[i];
+ sal_Int32 nLen = rStr.getLength();
+ for ( sal_Int32 j = 0; j < nLen; j++ )
+ {
+ bool bFoundEnglish = false;
+ if ( (j == 0 || rStr[j - 1] != '\\') && GetKeyWord( rStr, j, bFoundEnglish) )
+ {
+ rStr = "\"" + rStr + "\"";
+ break; // for
+ }
+ }
+ }
+ }
+ }
+ // Concatenate strings, remove quotes for output, and rebuild the format string
+ rString.clear();
+ i = 0;
+ while (i < nStringsCnt)
+ {
+ sal_Int32 nStringPos;
+ sal_Int32 nArrPos = 0;
+ sal_uInt16 iPos = i;
+ switch ( nTypeArray[i] )
+ {
+ case NF_SYMBOLTYPE_STRING :
+ case NF_SYMBOLTYPE_FRACBLANK :
+ nStringPos = rString.getLength();
+ do
+ {
+ if (sStrArray[i].getLength() == 2 &&
+ sStrArray[i][0] == '\\')
+ {
+ // Unescape some simple forms of symbols even in the UI
+ // visible string to prevent duplicates that differ
+ // only in notation, originating from import.
+ // e.g. YYYY-MM-DD and YYYY\-MM\-DD are identical,
+ // but 0\ 000 0 and 0 000 0 in a French locale are not.
+
+ sal_Unicode c = sStrArray[i][1];
+
+ switch (c)
+ {
+ case '+':
+ case '-':
+ rString += OUStringChar(c);
+ break;
+ case ' ':
+ case '.':
+ case '/':
+ if (!(eScannedType & SvNumFormatType::DATE) &&
+ (StringEqualsChar( pFormatter->GetNumThousandSep(), c) ||
+ StringEqualsChar( pFormatter->GetNumDecimalSep(), c) ||
+ (c == ' ' &&
+ (StringEqualsChar( pFormatter->GetNumThousandSep(), cNoBreakSpace) ||
+ StringEqualsChar( pFormatter->GetNumThousandSep(), cNarrowNoBreakSpace)))))
+ {
+ rString += sStrArray[i];
+ }
+ else if ((eScannedType & SvNumFormatType::DATE) &&
+ StringEqualsChar( pFormatter->GetDateSep(), c))
+ {
+ rString += sStrArray[i];
+ }
+ else if ((eScannedType & SvNumFormatType::TIME) &&
+ (StringEqualsChar( pLoc->getTimeSep(), c) ||
+ StringEqualsChar( pLoc->getTime100SecSep(), c)))
+ {
+ rString += sStrArray[i];
+ }
+ else if (eScannedType & SvNumFormatType::FRACTION)
+ {
+ rString += sStrArray[i];
+ }
+ else
+ {
+ rString += OUStringChar(c);
+ }
+ break;
+ default:
+ rString += sStrArray[i];
+ }
+ }
+ else
+ {
+ rString += sStrArray[i];
+ }
+ if ( RemoveQuotes( sStrArray[i] ) > 0 )
+ {
+ // update currency up to quoted string
+ if ( eScannedType == SvNumFormatType::CURRENCY )
+ {
+ // dM -> DM or DM -> $ in old automatic
+ // currency formats, oh my ..., why did we ever introduce them?
+ OUString aTmp( pChrCls->uppercase( sStrArray[iPos], nArrPos,
+ sStrArray[iPos].getLength()-nArrPos ) );
+ sal_Int32 nCPos = aTmp.indexOf( sOldCurString );
+ if ( nCPos >= 0 )
+ {
+ const OUString& rCur = bConvertMode && bConvertSystemToSystem ?
+ GetCurSymbol() : sOldCurSymbol;
+ sStrArray[iPos] = sStrArray[iPos].replaceAt( nArrPos + nCPos,
+ sOldCurString.getLength(),
+ rCur );
+ rString = rString.replaceAt( nStringPos + nCPos,
+ sOldCurString.getLength(),
+ rCur );
+ }
+ nStringPos = rString.getLength();
+ if ( iPos == i )
+ {
+ nArrPos = sStrArray[iPos].getLength();
+ }
+ else
+ {
+ nArrPos = sStrArray[iPos].getLength() + sStrArray[i].getLength();
+ }
+ }
+ }
+ if ( iPos != i )
+ {
+ sStrArray[iPos] += sStrArray[i];
+ nTypeArray[i] = NF_SYMBOLTYPE_EMPTY;
+ nResultStringsCnt--;
+ }
+ i++;
+ }
+ while ( i < nStringsCnt && nTypeArray[i] == NF_SYMBOLTYPE_STRING );
+
+ if ( i < nStringsCnt )
+ {
+ i--; // enter switch on next symbol again
+ }
+ if ( eScannedType == SvNumFormatType::CURRENCY && nStringPos < rString.getLength() )
+ {
+ // same as above, since last RemoveQuotes
+ OUString aTmp( pChrCls->uppercase( sStrArray[iPos], nArrPos,
+ sStrArray[iPos].getLength()-nArrPos ) );
+ sal_Int32 nCPos = aTmp.indexOf( sOldCurString );
+ if ( nCPos >= 0 )
+ {
+ const OUString& rCur = bConvertMode && bConvertSystemToSystem ?
+ GetCurSymbol() : sOldCurSymbol;
+ sStrArray[iPos] = sStrArray[iPos].replaceAt( nArrPos + nCPos,
+ sOldCurString.getLength(),
+ rCur );
+ rString = rString.replaceAt( nStringPos + nCPos,
+ sOldCurString.getLength(), rCur );
+ }
+ }
+ break;
+ case NF_SYMBOLTYPE_CURRENCY :
+ rString += sStrArray[i];
+ RemoveQuotes( sStrArray[i] );
+ break;
+ case NF_KEY_THAI_T:
+ if (bThaiT && GetNatNumModifier() == 1)
+ {
+ // Remove T from format code, will be replaced with a [NatNum1] prefix.
+ nTypeArray[i] = NF_SYMBOLTYPE_EMPTY;
+ nResultStringsCnt--;
+ }
+ else
+ {
+ rString += sStrArray[i];
+ }
+ break;
+ case NF_SYMBOLTYPE_EMPTY :
+ // nothing
+ break;
+ default:
+ rString += sStrArray[i];
+ }
+ i++;
+ }
+ return 0;
+}
+
+sal_Int32 ImpSvNumberformatScan::RemoveQuotes( OUString& rStr )
+{
+ if ( rStr.getLength() > 1 )
+ {
+ sal_Unicode c = rStr[0];
+ sal_Int32 n = rStr.getLength() - 1;
+ if ( c == '"' && rStr[n] == '"' )
+ {
+ rStr = rStr.copy( 1, n-1);
+ return 2;
+ }
+ else if ( c == '\\' )
+ {
+ rStr = rStr.copy(1);
+ return 1;
+ }
+ }
+ return 0;
+}
+
+sal_Int32 ImpSvNumberformatScan::ScanFormat( OUString& rString )
+{
+ sal_Int32 res = Symbol_Division(rString); // Lexical analysis
+ if (!res)
+ {
+ res = ScanType(); // Recognizing the Format type
+ }
+ if (!res)
+ {
+ res = FinalScan( rString ); // Type dependent final analysis
+ }
+ return res; // res = control position; res = 0 => Format ok
+}
+
+void ImpSvNumberformatScan::CopyInfo(ImpSvNumberformatInfo* pInfo, sal_uInt16 nCnt)
+{
+ size_t i,j;
+ j = 0;
+ i = 0;
+ while (i < nCnt && j < NF_MAX_FORMAT_SYMBOLS)
+ {
+ if (nTypeArray[j] != NF_SYMBOLTYPE_EMPTY)
+ {
+ pInfo->sStrArray[i] = sStrArray[j];
+ pInfo->nTypeArray[i] = nTypeArray[j];
+ i++;
+ }
+ j++;
+ }
+ pInfo->eScannedType = eScannedType;
+ pInfo->bThousand = bThousand;
+ pInfo->nThousand = nThousand;
+ pInfo->nCntPre = nCntPre;
+ pInfo->nCntPost = nCntPost;
+ pInfo->nCntExp = nCntExp;
+}
+
+bool ImpSvNumberformatScan::ReplaceBooleanEquivalent( OUString& rString )
+{
+ InitKeywords();
+ /* TODO: compare case insensitive? Or rather leave as is and case not
+ * matching indicates user supplied on purpose? Written to file / generated
+ * was always uppercase. */
+ if (rString == sBooleanEquivalent1 || rString == sBooleanEquivalent2)
+ {
+ rString = GetKeywords()[NF_KEY_BOOLEAN];
+ return true;
+ }
+ return false;
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/svl/source/numbers/zforscan.hxx b/svl/source/numbers/zforscan.hxx
new file mode 100644
index 000000000..4e6f7d145
--- /dev/null
+++ b/svl/source/numbers/zforscan.hxx
@@ -0,0 +1,304 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed
+ * with this work for additional information regarding copyright
+ * ownership. The ASF licenses this file to you under the Apache
+ * License, Version 2.0 (the "License"); you may not use this file
+ * except in compliance with the License. You may obtain a copy of
+ * the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+#ifndef INCLUDED_SVL_SOURCE_NUMBERS_ZFORSCAN_HXX
+#define INCLUDED_SVL_SOURCE_NUMBERS_ZFORSCAN_HXX
+
+#include <i18nlangtag/lang.h>
+#include <rtl/ustring.hxx>
+#include <svl/nfkeytab.hxx>
+#include <svl/nfsymbol.hxx>
+#include <svl/numformat.hxx>
+#include <svl/zforlist.hxx>
+#include <tools/color.hxx>
+#include <tools/date.hxx>
+#include <unotools/localedatawrapper.hxx>
+
+class SvNumberFormatter;
+struct ImpSvNumberformatInfo;
+
+
+const size_t NF_MAX_DEFAULT_COLORS = 10;
+
+// Hack: nThousand==1000 => "Default" occurs in format string
+const sal_uInt16 FLAG_STANDARD_IN_FORMAT = 1000;
+
+class ImpSvNumberformatScan
+{
+public:
+
+ /** Specify what keyword localization is allowed when scanning the format code. */
+ enum class KeywordLocalization
+ {
+ LocaleLegacy, ///< unfortunately localized in few locales, otherwise English
+ EnglishOnly, ///< only English, no localized keywords
+ AllowEnglish ///< allow English keywords as well as localized keywords
+ };
+
+ explicit ImpSvNumberformatScan( SvNumberFormatter* pFormatter );
+ ~ImpSvNumberformatScan();
+ void ChangeIntl( KeywordLocalization eKeywordLocalization = KeywordLocalization::AllowEnglish ); // Replaces Keywords
+
+ void ChangeNullDate(sal_uInt16 nDay, sal_uInt16 nMonth, sal_Int16 nYear); // Replaces reference date
+ void ChangeStandardPrec(sal_uInt16 nPrec); // Replaces standard precision
+
+ sal_Int32 ScanFormat( OUString& rString ); // Call scan analysis
+
+ void CopyInfo(ImpSvNumberformatInfo* pInfo,
+ sal_uInt16 nCnt); // Copies the FormatInfo
+ sal_uInt16 GetResultStringsCnt() const { return nResultStringsCnt; }
+
+ const CharClass& GetChrCls() const { return *pFormatter->GetCharClass(); }
+ const LocaleDataWrapper& GetLoc() const { return *pFormatter->GetLocaleData(); }
+ CalendarWrapper& GetCal() const { return *pFormatter->GetCalendar(); }
+
+ const NfKeywordTable & GetKeywords() const
+ {
+ if ( bKeywordsNeedInit )
+ {
+ InitKeywords();
+ }
+ return sKeyword;
+ }
+
+ static const NfKeywordTable & GetEnglishKeywords()
+ {
+ return sEnglishKeyword;
+ }
+
+ // Keywords used in output like true and false
+ const OUString& GetSpecialKeyword( NfKeywordIndex eIdx ) const
+ {
+ if ( sKeyword[eIdx].isEmpty() )
+ {
+ InitSpecialKeyword( eIdx );
+ }
+ return sKeyword[eIdx];
+ }
+ const OUString& GetTrueString() const { return GetSpecialKeyword( NF_KEY_TRUE ); }
+ const OUString& GetFalseString() const { return GetSpecialKeyword( NF_KEY_FALSE ); }
+ const OUString& GetRedString() const { return GetKeywords()[NF_KEY_RED]; }
+ const OUString& GetBooleanString() const { return GetKeywords()[NF_KEY_BOOLEAN]; }
+ static const ::std::vector<Color> & GetStandardColors()
+ {
+ return StandardColor;
+ }
+ static size_t GetMaxDefaultColors()
+ {
+ return NF_MAX_DEFAULT_COLORS;
+ }
+
+ const Date& GetNullDate() const { return maNullDate; }
+ const OUString& GetStandardName() const
+ {
+ if ( bKeywordsNeedInit )
+ {
+ InitKeywords();
+ }
+ return sNameStandardFormat;
+ }
+ sal_uInt16 GetStandardPrec() const { return nStandardPrec; }
+ static const Color& GetRedColor() { return StandardColor[4]; }
+ const Color* GetColor(OUString& sStr) const; // Set main colors or defines colors
+
+ // the compatibility currency symbol for old automatic currency formats
+ const OUString& GetCurSymbol() const
+ {
+ if ( bCompatCurNeedInit )
+ {
+ InitCompatCur();
+ }
+ return sCurSymbol;
+ }
+
+ // the compatibility currency abbreviation for CCC format code
+ const OUString& GetCurAbbrev() const
+ {
+ if ( bCompatCurNeedInit )
+ {
+ InitCompatCur();
+ }
+ return sCurAbbrev;
+ }
+
+ // the compatibility currency symbol upper case for old automatic currency formats
+ const OUString& GetCurString() const
+ {
+ if ( bCompatCurNeedInit )
+ {
+ InitCompatCur();
+ }
+ return sCurString;
+ }
+
+ /// Replace Boolean equivalent format codes with proper Boolean format.
+ bool ReplaceBooleanEquivalent( OUString& rString );
+
+ void SetConvertMode(LanguageType eTmpLge, LanguageType eNewLge,
+ bool bSystemToSystem, bool bConvertDateOrder)
+ {
+ bConvertMode = true;
+ eNewLnge = eNewLge;
+ eTmpLnge = eTmpLge;
+ bConvertSystemToSystem = bSystemToSystem;
+ mbConvertDateOrder = bConvertDateOrder;
+ }
+ // Only changes the bool variable, in order to temporarily pause the convert mode
+ void SetConvertMode(bool bMode) { bConvertMode = bMode; }
+ bool GetConvertMode() const { return bConvertMode; }
+ LanguageType GetNewLnge() const { return eNewLnge; } // Read access on ConvertMode and convert country/language
+ LanguageType GetTmpLnge() const { return eTmpLnge; } // Read access on StartCountry/Language
+ void SetNewLnge( LanguageType e ) { eNewLnge = e; } // Set new convert country/language
+
+ /// get Thai T speciality
+ sal_uInt8 GetNatNumModifier() const { return nNatNumModifier; }
+ /// set Thai T speciality
+ void SetNatNumModifier( sal_uInt8 n ) { nNatNumModifier = n; }
+
+ SvNumberFormatter* GetNumberformatter() { return pFormatter; } // Access to formatter (for zformat.cxx)
+
+ /// Get type scanned (so far).
+ SvNumFormatType GetScannedType() const { return eScannedType; }
+
+ static constexpr OUStringLiteral sErrStr = u"#FMT"; // String for error output
+
+private: // Private section
+ NfKeywordTable sKeyword; // Syntax keywords
+ static const NfKeywordTable sEnglishKeyword; // English Syntax keywords
+ static const ::std::vector<Color> StandardColor; // Standard color array
+ Date maNullDate; // 30Dec1899
+ OUString sNameStandardFormat; // "Standard"
+ sal_uInt16 nStandardPrec; // Default Precision for Standardformat
+ SvNumberFormatter* pFormatter; // Pointer to the FormatList
+ css::uno::Reference< css::i18n::XNumberFormatCode > xNFC;
+
+ OUString sStrArray[NF_MAX_FORMAT_SYMBOLS]; // Array of symbols
+ short nTypeArray[NF_MAX_FORMAT_SYMBOLS]; // Array of infos
+ // External Infos:
+ sal_uInt16 nResultStringsCnt; // Result symbol count
+ SvNumFormatType eScannedType; // Type according to scan
+ bool bThousand; // With thousands marker
+ sal_uInt16 nThousand; // Counts ... series
+ sal_uInt16 nCntPre; // Counts digits of integral part
+ sal_uInt16 nCntPost; // Counts digits of fractional part
+ sal_uInt16 nCntExp; // Counts exponent digits AM/PM
+ // Internal info:
+ sal_uInt16 nStringsCnt; // Symbol count
+ sal_uInt16 nExpPos; // Internal position of E
+ sal_uInt16 nBlankPos; // Internal position of the Blank
+ short nDecPos; // Internal position of the ,
+ bool bExp; // Set when reading E
+ bool bFrac; // Set when reading /
+ bool bBlank; // Set when reading ' ' (Fraction)
+ bool bDecSep; // Set on first ,
+ mutable bool bKeywordsNeedInit; // Locale dependent keywords need to be initialized
+ mutable bool bCompatCurNeedInit; // Locale dependent compatibility currency need to be initialized
+ OUString sCurSymbol; // Currency symbol for compatibility format codes
+ OUString sCurString; // Currency symbol in upper case
+ OUString sCurAbbrev; // Currency abbreviation
+ OUString sBooleanEquivalent1; // "TRUE";"TRUE";"FALSE"
+ OUString sBooleanEquivalent2; // [>0]"TRUE";[<0]"TRUE";"FALSE"
+
+ bool bConvertMode; // Set in the convert mode
+ bool mbConvertDateOrder; // Set in the convert mode whether to convert date particles order
+
+ LanguageType eNewLnge; // Language/country which the scanned string is converted to (for Excel filter)
+ LanguageType eTmpLnge; // Language/country which the scanned string is converted from (for Excel filter)
+
+ bool bConvertSystemToSystem; // Whether the conversion is from one system locale to another system locale
+ // (in this case the automatic currency symbol is converted too).
+
+ sal_Int32 nCurrPos; // Position of currency symbol
+
+ sal_uInt8 nNatNumModifier; // Thai T speciality
+
+ KeywordLocalization meKeywordLocalization; ///< which keywords localization to scan
+
+ // Copy assignment is forbidden and not implemented.
+ ImpSvNumberformatScan (const ImpSvNumberformatScan &) = delete;
+ ImpSvNumberformatScan & operator= (const ImpSvNumberformatScan &) = delete;
+
+ void InitKeywords() const;
+ void InitSpecialKeyword( NfKeywordIndex eIdx ) const;
+ void InitCompatCur() const;
+
+ void SetDependentKeywords();
+ // Sets the language dependent keywords
+ void SkipStrings(sal_uInt16& i, sal_Int32& nPos) const;// Skips StringSymbols
+ sal_uInt16 PreviousKeyword(sal_uInt16 i) const; // Returns index of the preceding one
+ // Keyword or 0
+ sal_uInt16 NextKeyword(sal_uInt16 i) const; // Returns index of the next one
+ // Keyword or 0
+ sal_Unicode PreviousChar(sal_uInt16 i) const; // Returns last char before index skips EMPTY, STRING, STAR, BLANK
+ sal_Unicode NextChar(sal_uInt16 i) const; // Returns first following char
+ short PreviousType( sal_uInt16 i ) const; // Returns type before position skips EMPTY
+ bool IsLastBlankBeforeFrac(sal_uInt16 i) const; // True <=> there won't be a ' ' until the '/'
+ void Reset(); // Reset all variables before starting the analysis
+
+ /** Determine keyword at nPos.
+ @param rbFoundEnglish set if English instead of locale's keyword
+ found, never cleared, thus init with false.
+ @return 0 if not found, else keyword enumeration.
+ */
+ short GetKeyWord( const OUString& sSymbol,
+ sal_Int32 nPos,
+ bool& rbFoundEnglish ) const;
+
+ bool IsAmbiguousE( short nKey ) const // whether nKey is ambiguous E of NF_KEY_E/NF_KEY_EC
+ {
+ return (nKey == NF_KEY_EC || nKey == NF_KEY_E) &&
+ (GetKeywords()[NF_KEY_EC] == GetKeywords()[NF_KEY_E]);
+ }
+
+ // if 0 at strArray[i] is of S,00 or SS,00 or SS"any"00 in ScanType() or FinalScan()
+ bool Is100SecZero( sal_uInt16 i, bool bHadDecSep ) const;
+
+ short Next_Symbol(const OUString& rStr,
+ sal_Int32& nPos,
+ OUString& sSymbol) const; // Next Symbol
+ sal_Int32 Symbol_Division(const OUString& rString);// Initial lexical scan
+ sal_Int32 ScanType(); // Analysis of the Format type
+ sal_Int32 FinalScan( OUString& rString ); // Final analysis with supplied type
+
+ // -1:= error, return nPos in FinalScan; 0:= no calendar, 1:= calendar found
+ int FinalScanGetCalendar( sal_Int32& nPos, sal_uInt16& i, sal_uInt16& nResultStringsCnt );
+
+ /** Insert symbol into nTypeArray and sStrArray, e.g. grouping separator.
+ If at nPos-1 a symbol type NF_SYMBOLTYPE_EMPTY is present, that is
+ reused instead of shifting all one up and nPos is decremented! */
+ bool InsertSymbol( sal_uInt16 & nPos, svt::NfSymbolType eType, const OUString& rStr );
+
+ /** Whether two key symbols are adjacent separated by date separator.
+ This can only be used at the end of FinalScan() after
+ NF_SYMBOLTYPE_DATESEP has already been set.
+ */
+ bool IsDateFragment( size_t nPos1, size_t nPos2 ) const;
+
+ /** Swap nTypeArray and sStrArray elements at positions. */
+ void SwapArrayElements( size_t nPos1, size_t nPos2 );
+
+ static bool StringEqualsChar( const OUString& rStr, sal_Unicode ch )
+ { return rStr.getLength() == 1 && rStr[0] == ch; }
+
+ // remove "..." and \... quotes from rStr, return how many chars removed
+ static sal_Int32 RemoveQuotes( OUString& rStr );
+};
+
+#endif // INCLUDED_SVL_SOURCE_NUMBERS_ZFORSCAN_HXX
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
generated by cgit v1.2.3 (git 2.39.1) at 2024-11-28 01:02:48 +0000