Adding upstream version 4:7.4.7.upstream/4%7.4.7upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

2 files changed, 1540 insertions, 0 deletions

diff --git a/i18npool/source/nativenumber/data/numberchar.h b/i18npool/source/nativenumber/data/numberchar.h
new file mode 100644
index 000000000..a711e9607
--- /dev/null
+++ b/i18npool/source/nativenumber/data/numberchar.h
@@ -0,0 +1,277 @@
+/* -*- 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_I18NPOOL_SOURCE_NATIVENUMBER_DATA_NUMBERCHAR_H
+#define INCLUDED_I18NPOOL_SOURCE_NATIVENUMBER_DATA_NUMBERCHAR_H
+
+#include <sal/types.h>
+
+namespace i18npool {
+
+const sal_Int16 NumberChar_HalfWidth     = 0;
+const sal_Int16 NumberChar_FullWidth     = 1;
+const sal_Int16 NumberChar_Lower_zh  = 2;
+const sal_Int16 NumberChar_Upper_zh  = 3;
+const sal_Int16 NumberChar_Upper_zh_TW   = 4;
+const sal_Int16 NumberChar_Modern_ja     = 5;
+const sal_Int16 NumberChar_Traditional_ja= 6;
+const sal_Int16 NumberChar_Lower_ko  = 7;
+const sal_Int16 NumberChar_Upper_ko  = 8;
+const sal_Int16 NumberChar_Hangul_ko     = 9;
+const sal_Int16 NumberChar_Indic_ar  = 10;
+const sal_Int16 NumberChar_EastIndic_ar  = 11;
+const sal_Int16 NumberChar_hi        = 12;
+const sal_Int16 NumberChar_th        = 13;
+const sal_Int16 NumberChar_or        = 14;
+const sal_Int16 NumberChar_mr        = 15;
+const sal_Int16 NumberChar_bn        = 16;
+const sal_Int16 NumberChar_pa        = 17;
+const sal_Int16 NumberChar_gu        = 18;
+const sal_Int16 NumberChar_ta        = 19;
+const sal_Int16 NumberChar_te        = 20;
+const sal_Int16 NumberChar_kn        = 21;
+const sal_Int16 NumberChar_ml        = 22;
+const sal_Int16 NumberChar_lo        = 23;
+const sal_Int16 NumberChar_bo        = 24;
+const sal_Int16 NumberChar_my        = 25;
+const sal_Int16 NumberChar_km        = 26;
+const sal_Int16 NumberChar_mn        = 27;
+const sal_Int16 NumberChar_he        = 28;
+const sal_Int16 NumberChar_ne        = 29;
+const sal_Int16 NumberChar_dz        = 30;
+const sal_Int16 NumberChar_cu        = 31;
+const sal_Int16 NumberChar_Count     = 32;
+
+const sal_Unicode NumberChar[][10] = {
+//  0   1   2   3   4   5   6   7   8   9
+    { 0x0030, 0x0031, 0x0032, 0x0033, 0x0034, 0x0035, 0x0036, 0x0037, 0x0038, 0x0039 }, // Half Width (Ascii)
+    { 0xFF10, 0xFF11, 0xFF12, 0xFF13, 0xFF14, 0xFF15, 0xFF16, 0xFF17, 0xFF18, 0xFF19 }, // Full Width
+    { 0x3007, 0x4E00, 0x4E8c, 0x4E09, 0x56DB, 0x4E94, 0x516D, 0x4E03, 0x516B, 0x4E5D }, // Chinese Lower
+    { 0x96F6, 0x58F9, 0x8D30, 0x53C1, 0x8086, 0x4F0D, 0x9646, 0x67D2, 0x634C, 0x7396 }, // S. Chinese Upper
+    { 0x96F6, 0x58F9, 0x8CB3, 0x53C3, 0x8086, 0x4F0D, 0x9678, 0x67D2, 0x634C, 0x7396 }, // T. Chinese Upper
+    { 0x3007, 0x4E00, 0x4E8C, 0x4E09, 0x56DB, 0x4E94, 0x516D, 0x4E03, 0x516B, 0x4E5D }, // Japanese Modern
+    { 0x96F6, 0x58F1, 0x5F10, 0x53C2, 0x56DB, 0x4F0D, 0x516D, 0x4E03, 0x516B, 0x4E5D }, // Japanese Trad.
+    { 0x96F6, 0x4E00, 0x4E8C, 0x4E09, 0x56DB, 0x4E94, 0x516D, 0x4E03, 0x516B, 0x4E5D }, // Korean Lower
+    { 0x96F6, 0x58F9, 0x8CB3, 0x53C3, 0x56DB, 0x4F0D, 0x516D, 0x4E03, 0x516B, 0x4E5D }, // Korean Upper
+    { 0xC601, 0xC77C, 0xC774, 0xC0BC, 0xC0AC, 0xC624, 0xC721, 0xCE60, 0xD314, 0xAD6C }, // Korean Hangul
+    { 0x0660, 0x0661, 0x0662, 0x0663, 0x0664, 0x0665, 0x0666, 0x0667, 0x0668, 0x0669 }, // Arabic Indic
+    { 0x06F0, 0x06F1, 0x06F2, 0x06F3, 0x06F4, 0x06F5, 0x06F6, 0x06F7, 0x06F8, 0x06F9 }, // Est. Arabic Indic
+    { 0x0966, 0x0967, 0x0968, 0x0969, 0x096A, 0x096B, 0x096C, 0x096D, 0x096E, 0x096F }, // Indic (Devanagari)
+    { 0x0E50, 0x0E51, 0x0E52, 0x0E53, 0x0E54, 0x0E55, 0x0E56, 0x0E57, 0x0E58, 0x0E59 }, // Thai
+    { 0x0866, 0x0867, 0x0868, 0x0869, 0x086A, 0x086B, 0x086C, 0x086D, 0x086E, 0x086F }, // Odia
+    { 0x0966, 0x0967, 0x0968, 0x0969, 0x096A, 0x096B, 0x096C, 0x096D, 0x096E, 0x096F }, // Marathi
+    { 0x09E6, 0x09E7, 0x09E8, 0x09E9, 0x09EA, 0x09EB, 0x09EC, 0x09ED, 0x09EE, 0x09EF }, // Bengali
+    { 0x0A66, 0x0A67, 0x0A68, 0x0A69, 0x0A6A, 0x0A6B, 0x0A6C, 0x0A6D, 0x0A6E, 0x0A6F }, // Punjabi (Gurmukhi)
+    { 0x0AE6, 0x0AE7, 0x0AE8, 0x0AE9, 0x0AEA, 0x0AEB, 0x0AEC, 0x0AED, 0x0AEE, 0x0AEF }, // Gujarati
+    { 0x0030, 0x0BE7, 0x0BE8, 0x0BE9, 0x0BEA, 0x0BEB, 0x0BEC, 0x0BED, 0x0BEE, 0x0BEF }, // Tamil
+    { 0x0C66, 0x0C67, 0x0C68, 0x0C69, 0x0C6A, 0x0C6B, 0x0C6C, 0x0C6D, 0x0C6E, 0x0C6F }, // Telugu
+    { 0x0CE6, 0x0CE7, 0x0CE8, 0x0CE9, 0x0CEA, 0x0CEB, 0x0CEC, 0x0CED, 0x0CEE, 0x0CEF }, // Kannada
+    { 0x0DE6, 0x0DE7, 0x0DE8, 0x0DE9, 0x0DEA, 0x0DEB, 0x0DEC, 0x0DED, 0x0DEE, 0x0DEF }, // Malayalam
+    { 0x0ED0, 0x0ED1, 0x0ED2, 0x0ED3, 0x0ED4, 0x0ED5, 0x0ED6, 0x0ED7, 0x0ED8, 0x0ED9 }, // Lao
+    { 0x0F20, 0x0F21, 0x0F22, 0x0F23, 0x0F24, 0x0F25, 0x0F26, 0x0F27, 0x0F28, 0x0F29 }, // Tibetan
+    { 0x1040, 0x1041, 0x1042, 0x1043, 0x1044, 0x1045, 0x1046, 0x1047, 0x1048, 0x1049 }, // Myanmar
+    { 0x17E0, 0x17E1, 0x17E2, 0x17E3, 0x17E4, 0x17E5, 0x17E6, 0x17E7, 0x17E8, 0x17E9 }, // Cambodian (Khmer)
+    { 0x1810, 0x1811, 0x1812, 0x1813, 0x1814, 0x1815, 0x1816, 0x1817, 0x1818, 0x1819 }, // Mongolian
+    { 0x0020, 0x05D0, 0x05D1, 0x05D2, 0x05D3, 0x05D4, 0x05D5, 0x05D6, 0x05D7, 0x05D8 }, // Hebrew
+    { 0x0966, 0x0967, 0x0968, 0x0969, 0x096A, 0x096B, 0x096C, 0x096D, 0x096E, 0x096F }, // Nepali
+    { 0x0F20, 0x0F21, 0x0F22, 0x0F23, 0x0F24, 0x0F25, 0x0F26, 0x0F27, 0x0F28, 0x0F29 }, // Dzongkha
+    { 0x0030, 0x0430, 0x0432, 0x0433, 0x0434, 0x0454, 0x0455, 0x0437, 0x0438, 0x0473 }, // Church Slavic
+};
+
+static sal_Unicode DecimalChar[] = {
+    0x002E, // Half Width (Ascii)
+    0xFF0E, // Full Width
+    0xFF0E, // Chinese Lower
+    0x70B9, // S. Chinese Upper
+    0x9EDE, // T. Chinese Upper
+    0x30FB, // Japanese Modern
+    0x30FB, // Japanese Trad.
+    0xFF0E, // Korean Lower
+    0x9EDE, // Korean Upper
+    0xC810, // Korean Hangul
+    0x066B, // Arabic Indic
+    0x066B, // Est. Arabic Indic
+    0x0000, // Indic (Devanagari)
+    0x0000, // Thai
+    0x0000, // Odia
+    0x0000, // Marathi
+    0x0000, // Bengali
+    0x0000, // Punjabi (Gurmukhi)
+    0x0000, // Gujarati
+    0x0000, // Tamil
+    0x0000, // Telugu
+    0x0000, // Kannada
+    0x0000, // Malayalam
+    0x0000, // Lao
+    0x0000, // Tibetan
+    0x0000, // Myanmar
+    0x0000, // Cambodian (Khmer)
+    0x0000, // Mongolian
+    0x0000, // Hebrew
+    0x0000, // Nepali
+    0x0000, // Dzongkha
+    0x0000, // Church Slavic
+};
+
+const sal_Unicode MinusChar[] = {
+    0x002D, // Half Width (Ascii)
+    0xFF0D, // Full Width
+    0xFF0D, // Chinese Lower
+    0x8D1F, // S. Chinese Upper
+    0x5069, // T. Chinese Upper
+    0x2212, // Japanese Modern
+    0x2212, // Japanese Trad.
+    0xFF0D, // Korean Lower
+    0xFF0D, // Korean Upper
+    0xFF0D, // Korean Hangul
+    0x0000, // Arabic Indic
+    0x2212, // Est. Arabic Indic
+    0x0000, // Indic
+    0x0000, // Thai
+    0x0000, // Odia
+    0x0000, // Marathi
+    0x0000, // Bengali
+    0x0000, // Punjabi
+    0x0000, // Gujarati
+    0x0000, // Tamil
+    0x0000, // Telugu
+    0x0000, // Kannada
+    0x0000, // Malayalam
+    0x0000, // Lao
+    0x0000, // Tibetan
+    0x0000, // Myanmar
+    0x0000, // Cambodian (Khmer)
+    0x0000, // Mongolian
+    0x0000, // Hebrew
+    0x0000, // Nepali
+    0x0000, // Dzongkha
+    0x0000, // Church Slavic
+};
+
+static sal_uInt16 SeparatorChar[] = {
+    0x002C, // Half Width (Ascii)
+    0xFF0C, // Full Width
+    0x3001, // Chinese Lower
+    0x3001, // S. Chinese Upper
+    0x3001, // T. Chinese Upper
+    0x3001, // Japanese Modern
+    0x3001, // Japanese Trad.
+    0x002C, // Korean Lower
+    0x002C, // Korean Upper
+    0x002C, // Korean Hangul
+    0x0000, // Arabic Indic
+    0x066C, // Est. Arabic Indic
+    0x0000, // Indic
+    0x0000, // Thai
+    0x0000, // Odia
+    0x0000, // Marathi
+    0x0000, // Bengali
+    0x0000, // Punjabi
+    0x0000, // Gujarati
+    0x0000, // Tamil
+    0x0000, // Telugu
+    0x0000, // Kannada
+    0x0000, // Malayalam
+    0x0000, // Lao
+    0x0000, // Tibetan
+    0x0000, // Myanmar
+    0x0000, // Cambodian (Khmer)
+    0x0000, // Mongolian
+    0x0000, // Hebrew
+    0x0000, // Nepali
+    0x0000, // Dzongkha
+    0x0000, // Church Slavic
+};
+
+#define NUMBER_ZERO     NumberChar[NumberChar_HalfWidth][0] // 0x0030
+#define NUMBER_ONE      NumberChar[NumberChar_HalfWidth][1]     // 0x0031
+#define NUMBER_NINE     NumberChar[NumberChar_HalfWidth][9]     // 0x0039
+#define isNumber(n)     ( NUMBER_ZERO <= n && n <= NUMBER_NINE )
+#define isDecimal(n)    ( n == DecimalChar[NumberChar_HalfWidth] )
+#define isMinus(n)      ( n == MinusChar[NumberChar_HalfWidth] )
+#define isSeparator(n)  ( n == SeparatorChar[NumberChar_HalfWidth] )
+
+const sal_Int16 Multiplier_Lower_zh     = 0;
+const sal_Int16 Multiplier_Upper_zh     = 1;
+const sal_Int16 Multiplier_Lower_zh_TW  = 2;
+const sal_Int16 Multiplier_Upper_zh_TW  = 3;
+const sal_Int16 Multiplier_Lower_ko     = 4;
+const sal_Int16 Multiplier_Upper_ko     = 5;
+const sal_Int16 Multiplier_Hangul_ko    = 6;
+const sal_Int16 Multiplier_Modern_ja    = 7;
+const sal_Int16 Multiplier_Traditional_ja = 8;
+const sal_Int16 Multiplier_Count    = 9;
+
+const sal_Int16 ExponentCount_6_CJK     = 6;
+
+const sal_Int16 MultiplierExponent_6_CJK[ExponentCount_6_CJK] = {
+        12,     8,  4,  3,  2,  1
+};
+const sal_Unicode MultiplierChar_6_CJK[][ExponentCount_6_CJK] = {
+    {0x5146, 0x4EBF, 0x4E07, 0x5343, 0x767E, 0x5341},   // S. Chinese Lower
+    {0x5146, 0x4EBF, 0x4E07, 0x4EDF, 0x4F70, 0x62FE},   // S. Chinese Upper
+    {0x5146, 0x5104, 0x842C, 0x5343, 0x767E, 0x5341},   // T. Chinese Lower
+    {0x5146, 0x5104, 0x842C, 0x4EDF, 0x4F70, 0x62FE},   // T. Chinese Upper
+    {0x5146, 0x5104, 0x4E07, 0x5343, 0x767E, 0x5341},   // Korean Lower
+    {0x5146, 0x5104, 0x842C, 0x9621, 0x4F70, 0x62FE},   // Korean Upper
+    {0xC870, 0xC5B5, 0xB9CC, 0xCC9C, 0xBC31, 0xC2ED},   // Korean Hangul
+    {0x5146, 0x5104, 0x4E07, 0x5343, 0x767E, 0x5341},   // Japanese Modern
+    {0x5146, 0x5104, 0x842C, 0x9621, 0x767E, 0x62FE}    // Japanese Traditional
+};
+
+const sal_Int16 ExponentCount_2_CJK     = 2;
+
+const sal_Int16 MultiplierExponent_2_CJK[ExponentCount_2_CJK] = {
+        8,  4,
+};
+
+const sal_Unicode MultiplierChar_2_CJK[][ExponentCount_2_CJK] = {
+    {0x4EBF, 0x4E07}, // S. Chinese Lower
+    {0x4EBF, 0x4E07}, // S. Chinese Upper
+    {0x5104, 0x842C}, // T. Chinese Lower
+    {0x5104, 0x842C}, // T. Chinese Upper
+    {0x5104, 0x4E07}, // Korean Lower
+    {0x5104, 0x842C}, // Korean Upper
+    {0xC5B5, 0xB9CC}, // Korean Hangul
+    {0x5104, 0x4E07}, // Japanese Modern
+    {0x5104, 0x842C}  // Japanese Traditional
+};
+
+const sal_Int16 ExponentCount_7_CJK     = 7;
+
+const sal_Int16 MultiplierExponent_7_CJK[ExponentCount_7_CJK] = {
+        16, 12,     8,  4,  3,  2,  1
+};
+const sal_Unicode MultiplierChar_7_CJK[][ExponentCount_7_CJK] = {
+    {0x4EAC, 0x5146, 0x4EBF, 0x4E07, 0x5343, 0x767E, 0x5341},   // S. Chinese Lower
+    {0x4EAC, 0x5146, 0x4EBF, 0x4E07, 0x4EDF, 0x4F70, 0x62FE},   // S. Chinese Upper
+    {0x4EAC, 0x5146, 0x5104, 0x842C, 0x5343, 0x767E, 0x5341},   // T. Chinese Lower
+    {0x4EAC, 0x5146, 0x5104, 0x842C, 0x4EDF, 0x4F70, 0x62FE},   // T. Chinese Upper
+    {0x4EAC, 0x5146, 0x5104, 0x4E07, 0x5343, 0x767E, 0x5341},   // Korean Lower
+    {0x4EAC, 0x5146, 0x5104, 0x842C, 0x9621, 0x4F70, 0x62FE},   // Korean Upper
+    {0x4EAC, 0xC870, 0xC5B5, 0xB9CC, 0xCC9C, 0xBC31, 0xC2ED},   // Korean Hangul
+    {0x4EAC, 0x5146, 0x5104, 0x4E07, 0x5343, 0x767E, 0x5341},   // Japanese Modern
+    {0x4EAC, 0x5146, 0x5104, 0x842C, 0x9621, 0x767E, 0x62FE}    // Japanese Traditional
+};
+
+}
+
+#endif // INCLUDED_I18NPOOL_SOURCE_NATIVENUMBER_DATA_NUMBERCHAR_H
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/i18npool/source/nativenumber/nativenumbersupplier.cxx b/i18npool/source/nativenumber/nativenumbersupplier.cxx
new file mode 100644
index 000000000..59c38b39e
--- /dev/null
+++ b/i18npool/source/nativenumber/nativenumbersupplier.cxx
@@ -0,0 +1,1263 @@
+/* -*- 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 <i18nlangtag/languagetag.hxx>
+#include <i18nlangtag/mslangid.hxx>
+#include <rtl/ustrbuf.hxx>
+#include <sal/macros.h>
+#include <nativenumbersupplier.hxx>
+#include <localedata.hxx>
+#include "data/numberchar.h"
+#include <comphelper/processfactory.hxx>
+#include <cppuhelper/supportsservice.hxx>
+#include <o3tl/string_view.hxx>
+#include <cstddef>
+#include <map>
+#include <mutex>
+#include <memory>
+#include <string_view>
+#include <unordered_map>
+#include <com/sun/star/i18n/CharacterClassification.hpp>
+#include <com/sun/star/i18n/NativeNumberMode.hpp>
+#include <com/sun/star/linguistic2/NumberText.hpp>
+
+using namespace ::com::sun::star::uno;
+using namespace ::com::sun::star::i18n;
+using namespace ::com::sun::star::lang;
+
+namespace {
+
+struct Number {
+    sal_Int16 number;
+    const sal_Unicode *multiplierChar;
+    sal_Int16 numberFlag;
+    sal_Int16 exponentCount;
+    const sal_Int16 *multiplierExponent;
+};
+
+}
+
+#define NUMBER_OMIT_ZERO (1 << 0)
+#define NUMBER_OMIT_ONLY_ZERO  (1 << 1)
+#define NUMBER_OMIT_ONE_1  (1 << 2)
+#define NUMBER_OMIT_ONE_2  (1 << 3)
+#define NUMBER_OMIT_ONE_3  (1 << 4)
+#define NUMBER_OMIT_ONE_4  (1 << 5)
+#define NUMBER_OMIT_ONE_5  (1 << 6)
+#define NUMBER_OMIT_ONE_6  (1 << 7)
+#define NUMBER_OMIT_ONE_7  (1 << 8)
+#define NUMBER_OMIT_ONE  (NUMBER_OMIT_ONE_1|NUMBER_OMIT_ONE_2|NUMBER_OMIT_ONE_3|NUMBER_OMIT_ONE_4|NUMBER_OMIT_ONE_5|NUMBER_OMIT_ONE_6|NUMBER_OMIT_ONE_7)
+#define NUMBER_OMIT_ONE_CHECK(bit)  (1 << (2 + bit))
+#define NUMBER_OMIT_ALL ( NUMBER_OMIT_ZERO|NUMBER_OMIT_ONE|NUMBER_OMIT_ONLY_ZERO )
+#define NUMBER_OMIT_ZERO_ONE ( NUMBER_OMIT_ZERO|NUMBER_OMIT_ONE )
+#define NUMBER_OMIT_ONE_67 (NUMBER_OMIT_ONE_6|NUMBER_OMIT_ONE_7)
+#define NUMBER_OMIT_ZERO_ONE_67 ( NUMBER_OMIT_ZERO|NUMBER_OMIT_ONE_67 )
+
+namespace i18npool {
+
+namespace {
+
+std::mutex theNatNumMutex;
+
+}
+
+static OUString getHebrewNativeNumberString(const OUString& aNumberString, bool useGeresh);
+
+static OUString getCyrillicNativeNumberString(const OUString& aNumberString);
+
+/// @throws RuntimeException
+static OUString AsciiToNativeChar( const OUString& inStr, sal_Int32 nCount,
+        Sequence< sal_Int32 >* pOffset, sal_Int16 number )
+{
+    const sal_Unicode *src = inStr.getStr();
+    rtl_uString *newStr = rtl_uString_alloc(nCount);
+    if (pOffset)
+        pOffset->realloc(nCount);
+    auto ppOffset = pOffset ? pOffset->getArray() : nullptr;
+
+    for (sal_Int32 i = 0; i < nCount; i++)
+    {
+        sal_Unicode ch = src[i];
+        if (isNumber(ch))
+            newStr->buffer[i] = NumberChar[number][ ch - NUMBER_ZERO ];
+        else if (i+1 < nCount && isNumber(src[i+1])) {
+            if (i > 0 && isNumber(src[i-1]) && isSeparator(ch))
+                newStr->buffer[i] = SeparatorChar[number] ? SeparatorChar[number] : ch;
+            else
+                newStr->buffer[i] = isDecimal(ch) ? (DecimalChar[number] ? DecimalChar[number] : ch) :
+                    isMinus(ch) ? (MinusChar[number] ? MinusChar[number] : ch) : ch;
+        }
+        else
+            newStr->buffer[i] = ch;
+        if (ppOffset)
+            ppOffset[i] = i;
+    }
+    return OUString(newStr, SAL_NO_ACQUIRE); // take ownership
+}
+
+static bool AsciiToNative_numberMaker(const sal_Unicode *str, sal_Int32 begin, sal_Int32 len,
+        sal_Unicode *dst, sal_Int32& count, sal_Int16 multiChar_index, Sequence< sal_Int32 >* pOffset, sal_Int32 startPos,
+ const Number *number, const sal_Unicode* numberChar)
+{
+    sal_Unicode multiChar = (multiChar_index == -1 ? 0 : number->multiplierChar[multiChar_index]);
+    auto ppOffset = pOffset ? pOffset->getArray() : nullptr;
+    if ( len <= number->multiplierExponent[number->exponentCount-1] ) {
+        if (number->multiplierExponent[number->exponentCount-1] > 1) {
+            bool bNotZero = false;
+            for (const sal_Int32 end = begin+len; begin < end; begin++) {
+                if (bNotZero || str[begin] != NUMBER_ZERO) {
+                    dst[count] = numberChar[str[begin] - NUMBER_ZERO];
+                    if (ppOffset)
+                        ppOffset[count] = begin + startPos;
+                    count++;
+                    bNotZero = true;
+                }
+            }
+            if (bNotZero && multiChar > 0) {
+                dst[count] = multiChar;
+                if (ppOffset)
+                    ppOffset[count] = begin + startPos;
+                count++;
+            }
+            return bNotZero;
+        } else if (str[begin] != NUMBER_ZERO) {
+            if (!(number->numberFlag & (multiChar_index < 0 ? 0 : NUMBER_OMIT_ONE_CHECK(multiChar_index))) || str[begin] != NUMBER_ONE) {
+                dst[count] = numberChar[str[begin] - NUMBER_ZERO];
+                if (ppOffset)
+                    ppOffset[count] = begin + startPos;
+                count++;
+            }
+            if (multiChar > 0) {
+                dst[count] = multiChar;
+                if (ppOffset)
+                    ppOffset[count] = begin + startPos;
+                count++;
+            }
+        } else if (!(number->numberFlag & NUMBER_OMIT_ZERO) && count > 0 && dst[count-1] != numberChar[0]) {
+            dst[count] = numberChar[0];
+            if (ppOffset)
+                ppOffset[count] = begin + startPos;
+            count++;
+        }
+        return str[begin] != NUMBER_ZERO;
+    } else {
+        bool bPrintPower = false;
+        // sal_Int16 last = 0;
+        for (sal_Int16 i = 1; i <= number->exponentCount; i++) {
+            sal_Int32 tmp = len - (i == number->exponentCount ? 0 : number->multiplierExponent[i]);
+            if (tmp > 0) {
+                bPrintPower |= AsciiToNative_numberMaker(str, begin, tmp, dst, count,
+                        (i == number->exponentCount ? -1 : i), pOffset, startPos, number, numberChar);
+                begin += tmp;
+                len -= tmp;
+            }
+        }
+        if (bPrintPower) {
+            if (count > 0 && number->multiplierExponent[number->exponentCount-1] == 1 &&
+                    dst[count-1] == numberChar[0])
+                count--;
+            if (multiChar > 0) {
+                dst[count] = multiChar;
+                if (ppOffset)
+                    ppOffset[count] = begin + startPos;
+                count++;
+            }
+        }
+        return bPrintPower;
+    }
+}
+
+/// @throws RuntimeException
+static OUString AsciiToNative( const OUString& inStr, sal_Int32 nCount,
+        Sequence< sal_Int32 >* pOffset, const Number* number )
+{
+    OUString aRet;
+
+    sal_Int32 strLen = inStr.getLength();
+    const sal_Unicode *numberChar = NumberChar[number->number];
+
+    if (nCount > strLen)
+        nCount = strLen;
+
+    if (nCount > 0)
+    {
+        const sal_Unicode *str = inStr.getStr();
+        std::unique_ptr<sal_Unicode[]> newStr(new sal_Unicode[nCount * 2 + 1]);
+        std::unique_ptr<sal_Unicode[]> srcStr(new sal_Unicode[nCount + 1]); // for keeping number without comma
+        sal_Int32 i, len = 0, count = 0;
+
+        if (pOffset)
+            pOffset->realloc( nCount * 2 );
+        auto ppOffset = pOffset ? pOffset->getArray() : nullptr;
+        bool bDoDecimal = false;
+
+        for (i = 0; i <= nCount; i++)
+        {
+            if (i < nCount && isNumber(str[i])) {
+                if (bDoDecimal) {
+                    newStr[count] = numberChar[str[i] - NUMBER_ZERO];
+                    if (ppOffset)
+                        ppOffset[count] = i;
+                    count++;
+                }
+                else
+                    srcStr[len++] = str[i];
+            } else {
+                if (len > 0) {
+                    if (i < nCount-1 && isSeparator(str[i]) && isNumber(str[i+1]))
+                        continue; // skip comma inside number string
+                    bool bNotZero = false;
+                    for (sal_Int32 begin = 0, end = len % number->multiplierExponent[0];
+                            end <= len; begin = end, end += number->multiplierExponent[0]) {
+                        if (end == 0) continue;
+                        sal_Int32 _count = count;
+                        bNotZero |= AsciiToNative_numberMaker(srcStr.get(), begin, end - begin, newStr.get(), count,
+                                end == len ? -1 : 0, pOffset, i - len, number, numberChar);
+                        if (count > 0 && number->multiplierExponent[number->exponentCount-1] == 1 &&
+                                newStr[count-1] == numberChar[0])
+                            count--;
+                        if (bNotZero && _count == count && end != len) {
+                            newStr[count] = number->multiplierChar[0];
+                            if (ppOffset)
+                                ppOffset[count] = i - len;
+                            count++;
+                        }
+                    }
+                    if (! bNotZero && ! (number->numberFlag & NUMBER_OMIT_ONLY_ZERO)) {
+                        newStr[count] = numberChar[0];
+                        if (ppOffset)
+                            ppOffset[count] = i - len;
+                        count++;
+                    }
+                    len = 0;
+                }
+                if (i < nCount) {
+                    bDoDecimal = (!bDoDecimal && i < nCount-1 && isDecimal(str[i]) && isNumber(str[i+1]));
+                    if (bDoDecimal)
+                        newStr[count] = (DecimalChar[number->number] ? DecimalChar[number->number] : str[i]);
+                    else if (i < nCount-1 && isMinus(str[i]) && isNumber(str[i+1]))
+                        newStr[count] = (MinusChar[number->number] ? MinusChar[number->number] : str[i]);
+                    else if (i < nCount-1 && isSeparator(str[i]) && isNumber(str[i+1]))
+                        newStr[count] = (SeparatorChar[number->number] ? SeparatorChar[number->number] : str[i]);
+                    else
+                        newStr[count] = str[i];
+                    if (ppOffset)
+                        ppOffset[count] = i;
+                    count++;
+                }
+            }
+        }
+
+        if (pOffset)
+            pOffset->realloc(count);
+        aRet = OUString(newStr.get(), count);
+    }
+    return aRet;
+}
+
+namespace
+{
+void NativeToAscii_numberMaker(sal_Int16 max, sal_Int16 prev, const sal_Unicode *str,
+        sal_Int32& i, sal_Int32 nCount, sal_Unicode *dst, sal_Int32& count, Sequence< sal_Int32 >* pOffset,
+        OUString& numberChar, OUString& multiplierChar)
+{
+    auto ppOffset = pOffset ? pOffset->getArray() : nullptr;
+    sal_Int16 curr = 0, num = 0, end = 0, shift = 0;
+    while (++i < nCount) {
+        if ((curr = sal::static_int_cast<sal_Int16>( numberChar.indexOf(str[i]) )) >= 0) {
+            if (num > 0)
+                break;
+            num = curr % 10;
+        } else if ((curr = sal::static_int_cast<sal_Int16>( multiplierChar.indexOf(str[i]) )) >= 0) {
+            curr = MultiplierExponent_7_CJK[curr % ExponentCount_7_CJK];
+            if (prev > curr && num == 0) num = 1; // One may be omitted in informal format
+            shift = end = 0;
+            if (curr >= max)
+                max = curr;
+            else if (curr > prev)
+                shift = max - curr;
+            else
+                end = curr;
+            while (end++ < prev) {
+                dst[count] = NUMBER_ZERO + (end == prev ? num : 0);
+                if (ppOffset)
+                    ppOffset[count] = i;
+                count++;
+            }
+            if (shift) {
+                count -= max;
+                for (const sal_Int32 countEnd = count+shift; count < countEnd; count++) {
+                    dst[count] = dst[count + curr];
+                    if (ppOffset)
+                        ppOffset[count] = ppOffset[count + curr];
+                }
+                max = curr;
+            }
+            NativeToAscii_numberMaker(max, curr, str, i, nCount, dst,
+                    count, pOffset, numberChar, multiplierChar);
+            return;
+        } else
+            break;
+    }
+    while (end++ < prev) {
+        dst[count] = NUMBER_ZERO + (end == prev ? num : 0);
+        if (ppOffset)
+            ppOffset[count] = i - 1;
+        count++;
+    }
+}
+
+/// @throws RuntimeException
+OUString NativeToAscii(const OUString& inStr,
+        sal_Int32 nCount, Sequence< sal_Int32 >* pOffset )
+{
+    OUString aRet;
+
+    sal_Int32 strLen = inStr.getLength();
+
+    if (nCount > strLen)
+        nCount = strLen;
+
+    if (nCount > 0) {
+        const sal_Unicode *str = inStr.getStr();
+        std::unique_ptr<sal_Unicode[]> newStr(new sal_Unicode[nCount * MultiplierExponent_7_CJK[0] + 2]);
+        if (pOffset)
+            pOffset->realloc( nCount * MultiplierExponent_7_CJK[0] + 1 );
+        auto ppOffset = pOffset ? pOffset->getArray() : nullptr;
+        sal_Int32 count = 0, index;
+        sal_Int32 i;
+
+        OUString numberChar, multiplierChar, decimalChar, separatorChar;
+        numberChar = OUString(NumberChar[0], 10*NumberChar_Count);
+        multiplierChar = OUString(MultiplierChar_7_CJK[0], ExponentCount_7_CJK*Multiplier_Count);
+        decimalChar = OUString(DecimalChar, NumberChar_Count);
+        std::u16string_view const minusChar(MinusChar, NumberChar_Count);
+        separatorChar = OUString(
+            reinterpret_cast<sal_Unicode *>(SeparatorChar), NumberChar_Count);
+
+        for ( i = 0; i < nCount; i++) {
+            if ((index = multiplierChar.indexOf(str[i])) >= 0) {
+                if (count == 0 || !isNumber(newStr[count-1])) { // add 1 in front of multiplier
+                    newStr[count] = NUMBER_ONE;
+                    if (ppOffset)
+                        ppOffset[count] = i;
+                    count++;
+                }
+                index = MultiplierExponent_7_CJK[index % ExponentCount_7_CJK];
+                NativeToAscii_numberMaker(
+                        sal::static_int_cast<sal_Int16>( index ), sal::static_int_cast<sal_Int16>( index ),
+                        str, i, nCount, newStr.get(), count, pOffset,
+                        numberChar, multiplierChar);
+            } else {
+                if ((index = numberChar.indexOf(str[i])) >= 0)
+                    newStr[count] = sal::static_int_cast<sal_Unicode>( (index % 10) + NUMBER_ZERO );
+                else if (separatorChar.indexOf(str[i]) >= 0 &&
+                        (i < nCount-1 && (numberChar.indexOf(str[i+1]) >= 0 ||
+                                          multiplierChar.indexOf(str[i+1]) >= 0)))
+                    newStr[count] = SeparatorChar[NumberChar_HalfWidth];
+                else if (decimalChar.indexOf(str[i]) >= 0 &&
+                        (i < nCount-1 && (numberChar.indexOf(str[i+1]) >= 0 ||
+                                          multiplierChar.indexOf(str[i+1]) >= 0)))
+                    // Only when decimal point is followed by numbers,
+                    // it will be convert to ASCII decimal point
+                    newStr[count] = DecimalChar[NumberChar_HalfWidth];
+                else if (minusChar.find(str[i]) != std::u16string_view::npos &&
+                        (i < nCount-1 && (numberChar.indexOf(str[i+1]) >= 0 ||
+                                          multiplierChar.indexOf(str[i+1]) >= 0)))
+                    // Only when minus is followed by numbers,
+                    // it will be convert to ASCII minus sign
+                    newStr[count] = MinusChar[NumberChar_HalfWidth];
+                else
+                    newStr[count] = str[i];
+                if (ppOffset)
+                    ppOffset[count] = i;
+                count++;
+            }
+        }
+
+        if (pOffset) {
+            pOffset->realloc(count);
+        }
+        aRet = OUString(newStr.get(), count);
+    }
+    return aRet;
+}
+
+const Number natnum4[4] = {
+        { NumberChar_Lower_zh, MultiplierChar_6_CJK[Multiplier_Lower_zh], 0,
+                ExponentCount_6_CJK, MultiplierExponent_6_CJK },
+        { NumberChar_Lower_zh, MultiplierChar_6_CJK[Multiplier_Lower_zh_TW], 0,
+                ExponentCount_6_CJK, MultiplierExponent_6_CJK },
+        { NumberChar_Modern_ja, MultiplierChar_7_CJK[Multiplier_Modern_ja], NUMBER_OMIT_ZERO_ONE_67,
+                ExponentCount_7_CJK, MultiplierExponent_7_CJK },
+        { NumberChar_Lower_ko, MultiplierChar_6_CJK[Multiplier_Lower_ko], NUMBER_OMIT_ZERO,
+                ExponentCount_6_CJK, MultiplierExponent_6_CJK },
+};
+
+const Number natnum5[4] = {
+        { NumberChar_Upper_zh, MultiplierChar_6_CJK[Multiplier_Upper_zh], 0,
+                ExponentCount_6_CJK, MultiplierExponent_6_CJK },
+        { NumberChar_Upper_zh_TW, MultiplierChar_6_CJK[Multiplier_Upper_zh_TW], 0,
+                ExponentCount_6_CJK, MultiplierExponent_6_CJK },
+        { NumberChar_Traditional_ja, MultiplierChar_7_CJK[Multiplier_Traditional_ja], NUMBER_OMIT_ZERO_ONE_67,
+                ExponentCount_7_CJK, MultiplierExponent_7_CJK },
+        { NumberChar_Upper_ko, MultiplierChar_6_CJK[Multiplier_Upper_ko], 0,
+                ExponentCount_6_CJK, MultiplierExponent_6_CJK },
+};
+
+const Number natnum6[4] = {
+        { NumberChar_FullWidth, MultiplierChar_6_CJK[Multiplier_Lower_zh], 0,
+                ExponentCount_6_CJK, MultiplierExponent_6_CJK },
+        { NumberChar_FullWidth, MultiplierChar_6_CJK[Multiplier_Lower_zh_TW], 0,
+                ExponentCount_6_CJK, MultiplierExponent_6_CJK },
+        { NumberChar_FullWidth, MultiplierChar_7_CJK[Multiplier_Modern_ja], NUMBER_OMIT_ZERO_ONE_67,
+                ExponentCount_7_CJK, MultiplierExponent_7_CJK },
+        { NumberChar_FullWidth, MultiplierChar_6_CJK[Multiplier_Hangul_ko], NUMBER_OMIT_ZERO,
+                ExponentCount_6_CJK, MultiplierExponent_6_CJK },
+};
+
+const Number natnum7[4] = {
+        { NumberChar_Lower_zh, MultiplierChar_6_CJK[Multiplier_Lower_zh], NUMBER_OMIT_ALL,
+                ExponentCount_6_CJK, MultiplierExponent_6_CJK },
+        { NumberChar_Lower_zh, MultiplierChar_6_CJK[Multiplier_Lower_zh_TW], NUMBER_OMIT_ALL,
+                ExponentCount_6_CJK, MultiplierExponent_6_CJK },
+        { NumberChar_Modern_ja, MultiplierChar_2_CJK[Multiplier_Modern_ja], NUMBER_OMIT_ZERO_ONE,
+                ExponentCount_2_CJK, MultiplierExponent_2_CJK },
+        { NumberChar_Lower_ko, MultiplierChar_6_CJK[Multiplier_Lower_ko], NUMBER_OMIT_ALL,
+                ExponentCount_6_CJK, MultiplierExponent_6_CJK },
+};
+
+const Number natnum8[4] = {
+        { NumberChar_Upper_zh, MultiplierChar_6_CJK[Multiplier_Upper_zh], NUMBER_OMIT_ALL,
+                ExponentCount_6_CJK, MultiplierExponent_6_CJK },
+        { NumberChar_Upper_zh_TW, MultiplierChar_6_CJK[Multiplier_Upper_zh_TW], NUMBER_OMIT_ALL,
+                ExponentCount_6_CJK, MultiplierExponent_6_CJK },
+        { NumberChar_Traditional_ja, MultiplierChar_2_CJK[Multiplier_Traditional_ja], NUMBER_OMIT_ZERO_ONE,
+                ExponentCount_2_CJK, MultiplierExponent_2_CJK },
+        { NumberChar_Upper_ko, MultiplierChar_6_CJK[Multiplier_Upper_ko], NUMBER_OMIT_ALL,
+                ExponentCount_6_CJK, MultiplierExponent_6_CJK },
+};
+
+const Number natnum10 = { NumberChar_Hangul_ko, MultiplierChar_6_CJK[Multiplier_Hangul_ko], NUMBER_OMIT_ZERO,
+                ExponentCount_6_CJK, MultiplierExponent_6_CJK };
+const Number natnum11 = { NumberChar_Hangul_ko, MultiplierChar_6_CJK[Multiplier_Hangul_ko], NUMBER_OMIT_ALL,
+                ExponentCount_6_CJK, MultiplierExponent_6_CJK };
+
+//! ATTENTION: Do not change order of elements!
+//! Append new languages to the end of the list!
+const char *natnum1Locales[] = {
+    "zh_CN",
+    "zh_TW",
+    "ja",
+    "ko",
+    "he",
+    "ar",
+    "th",
+    "hi",
+    "or",
+    "mr",
+    "bn",
+    "pa",
+    "gu",
+    "ta",
+    "te",
+    "kn",
+    "ml",
+    "lo",
+    "bo",
+    "my",
+    "km",
+    "mn",
+    "ne",
+    "dz",
+    "fa",
+    "cu"
+};
+const sal_Int16 nbOfLocale = SAL_N_ELEMENTS(natnum1Locales);
+
+//! ATTENTION: Do not change order of elements!
+//! Number and order must match elements of natnum1Locales!
+const sal_Int16 natnum1[] = {
+    NumberChar_Lower_zh,
+    NumberChar_Lower_zh,
+    NumberChar_Modern_ja,
+    NumberChar_Lower_ko,
+    NumberChar_he,
+    NumberChar_Indic_ar,
+    NumberChar_th,
+    NumberChar_hi,
+    NumberChar_or,
+    NumberChar_mr,
+    NumberChar_bn,
+    NumberChar_pa,
+    NumberChar_gu,
+    NumberChar_ta,
+    NumberChar_te,
+    NumberChar_kn,
+    NumberChar_ml,
+    NumberChar_lo,
+    NumberChar_bo,
+    NumberChar_my,
+    NumberChar_km,
+    NumberChar_mn,
+    NumberChar_ne,
+    NumberChar_dz,
+    NumberChar_EastIndic_ar,
+    NumberChar_cu
+};
+const sal_Int16 sizeof_natnum1 = SAL_N_ELEMENTS(natnum1);
+
+//! ATTENTION: Do not change order of elements!
+//! Order must match first elements of natnum1Locales!
+const sal_Int16 natnum2[] = {
+    NumberChar_Upper_zh,
+    NumberChar_Upper_zh_TW,
+    NumberChar_Traditional_ja,
+    NumberChar_Upper_ko,
+    NumberChar_he
+};
+const sal_Int16 sizeof_natnum2 = SAL_N_ELEMENTS(natnum2);
+
+sal_Int16 getLanguageNumber( const Locale& rLocale)
+{
+    // return zh_TW for TW, HK and MO, return zh_CN for other zh locales.
+    if (rLocale.Language == "zh") return MsLangId::isTraditionalChinese(rLocale) ? 1 : 0;
+
+    for (sal_Int16 i = 2; i < nbOfLocale; i++)
+        if (rLocale.Language.equalsAsciiL(natnum1Locales[i], 2))
+            return i;
+
+    return -1;
+}
+
+struct Separators
+{
+    sal_Unicode DecimalSeparator;
+    sal_Unicode ThousandSeparator;
+    Separators(const Locale& rLocale)
+    {
+        LocaleDataItem aLocaleItem = LocaleDataImpl::get()->getLocaleItem(rLocale);
+        DecimalSeparator = aLocaleItem.decimalSeparator.toChar();
+        ThousandSeparator = aLocaleItem.thousandSeparator.toChar();
+    }
+};
+
+Separators getLocaleSeparators(const Locale& rLocale, const OUString& rLocStr)
+{
+    // Guard the static variable below.
+    std::scoped_lock aGuard(theNatNumMutex);
+    // Maximum a couple hundred of pairs with 4-byte structs - so no need for smart managing
+    static std::unordered_map<OUString, Separators> aLocaleSeparatorsBuf;
+    auto it = aLocaleSeparatorsBuf.find(rLocStr);
+    if (it == aLocaleSeparatorsBuf.end())
+    {
+        it = aLocaleSeparatorsBuf.emplace(rLocStr, Separators(rLocale)).first;
+    }
+    return it->second;
+}
+
+OUString getNumberText(const Locale& rLocale, const OUString& rNumberString,
+                       std::u16string_view sNumberTextParams)
+{
+    sal_Int32 i, count = 0;
+    const sal_Int32 len = rNumberString.getLength();
+    const sal_Unicode* src = rNumberString.getStr();
+
+    OUString aLoc = LanguageTag::convertToBcp47(rLocale);
+    Separators aSeparators = getLocaleSeparators(rLocale, aLoc);
+
+    OUStringBuffer sBuf(len);
+    for (i = 0; i < len; i++)
+    {
+        sal_Unicode ch = src[i];
+        if (isNumber(ch))
+        {
+            ++count;
+            sBuf.append(ch);
+        }
+        else if (ch == aSeparators.DecimalSeparator)
+            // Convert any decimal separator to point - in case libnumbertext has a different one
+            // for this locale (it seems that point is supported for all locales in libnumbertext)
+            sBuf.append('.');
+        else if (ch == aSeparators.ThousandSeparator && count > 0)
+            continue;
+        else if (isMinus(ch) && count == 0)
+            sBuf.append(ch);
+        else
+            break;
+    }
+
+    // Handle also month and day names for NatNum12 date formatting
+    const OUString& rNumberStr = (count == 0) ? rNumberString : sBuf.makeStringAndClear();
+
+    static auto xNumberText
+        = css::linguistic2::NumberText::create(comphelper::getProcessComponentContext());
+
+    // Guard the static variables below.
+    std::scoped_lock aGuard( theNatNumMutex );
+
+    OUString numbertext_prefix;
+    // default "cardinal" gets empty prefix
+    if (!sNumberTextParams.empty() && sNumberTextParams != u"cardinal")
+        numbertext_prefix = OUString::Concat(sNumberTextParams) + " ";
+    // Several hundreds of headings could result typing lags because
+    // of the continuous update of the multiple number names during typing.
+    // We fix this by buffering the result of the conversion.
+    static std::unordered_map<OUString, std::map<OUString, OUString>> aBuff;
+    auto& rItems = aBuff[rNumberStr];
+    auto& rItem = rItems[numbertext_prefix + aLoc];
+    if (rItem.isEmpty())
+    {
+        rItem = xNumberText->getNumberText(numbertext_prefix + rNumberStr, rLocale);
+        // use number at missing number to text conversion
+        if (rItem.isEmpty())
+            rItem = rNumberStr;
+    }
+    OUString sResult = rItem;
+    if (i != 0 && i < len)
+        sResult += rNumberString.subView(i);
+    return sResult;
+}
+}
+
+OUString NativeNumberSupplierService::getNativeNumberString(const OUString& aNumberString, const Locale& rLocale,
+                                                            sal_Int16 nNativeNumberMode,
+                                                            Sequence<sal_Int32>* pOffset,
+                                                            std::u16string_view rNativeNumberParams)
+{
+    if (!isValidNatNumImpl(rLocale, nNativeNumberMode))
+        return aNumberString;
+
+    if (nNativeNumberMode == NativeNumberMode::NATNUM12)
+    {
+        // handle capitalization prefixes "capitalize", "upper", "lower" and "title"
+
+        enum WhichCasing
+        {
+            CAPITALIZE,
+            UPPER,
+            LOWER,
+            TITLE
+        };
+
+        struct CasingEntry
+        {
+            std::u16string_view aLiteral;
+            WhichCasing     eCasing;
+        };
+
+        static const CasingEntry Casings[] =
+        {
+            { std::u16string_view(u"capitalize"), CAPITALIZE },
+            { std::u16string_view(u"upper"), UPPER },
+            { std::u16string_view(u"lower"), LOWER },
+            { std::u16string_view(u"title"), TITLE }
+        };
+
+        std::size_t nStripCase = 0;
+        size_t nCasing;
+        for (nCasing = 0; nCasing < SAL_N_ELEMENTS(Casings); ++nCasing)
+        {
+            if (o3tl::starts_with(rNativeNumberParams, Casings[nCasing].aLiteral))
+            {
+                nStripCase = Casings[nCasing].aLiteral.size();
+                break;
+            }
+        }
+
+        if (nStripCase > 0 && (rNativeNumberParams.size() == nStripCase ||
+                    rNativeNumberParams[nStripCase++] == ' '))
+        {
+            OUString aStr = getNumberText(rLocale, aNumberString, rNativeNumberParams.substr(nStripCase));
+
+            if (!xCharClass.is())
+                xCharClass = CharacterClassification::create(comphelper::getProcessComponentContext());
+
+            switch (Casings[nCasing].eCasing)
+            {
+                case CAPITALIZE:
+                    return xCharClass->toTitle(aStr, 0, 1, aLocale) +
+                        (aStr.getLength() > 1 ? aStr.subView(1) : u"");
+                case UPPER:
+                    return xCharClass->toUpper(aStr, 0, aStr.getLength(), aLocale);
+                case LOWER:
+                    return xCharClass->toLower(aStr, 0, aStr.getLength(), aLocale);
+                case TITLE:
+                    return xCharClass->toTitle(aStr, 0, aStr.getLength(), aLocale);
+            }
+        }
+        else
+        {
+            return getNumberText(rLocale, aNumberString, rNativeNumberParams);
+        }
+    }
+
+    sal_Int16 langnum = getLanguageNumber(rLocale);
+    if (langnum == -1)
+        return aNumberString;
+
+    const Number *number = nullptr;
+    sal_Int16 num = -1;
+
+    switch (nNativeNumberMode)
+    {
+        case NativeNumberMode::NATNUM0: // Ascii
+            return NativeToAscii(aNumberString, aNumberString.getLength(), pOffset);
+        case NativeNumberMode::NATNUM1: // Char, Lower
+            num = natnum1[langnum];
+            break;
+        case NativeNumberMode::NATNUM2: // Char, Upper
+            num = natnum2[langnum];
+            break;
+        case NativeNumberMode::NATNUM3: // Char, FullWidth
+            num = NumberChar_FullWidth;
+            break;
+        case NativeNumberMode::NATNUM4: // Text, Lower, Long
+            number = &natnum4[langnum];
+            break;
+        case NativeNumberMode::NATNUM5: // Text, Upper, Long
+            number = &natnum5[langnum];
+            break;
+        case NativeNumberMode::NATNUM6: // Text, FullWidth
+            number = &natnum6[langnum];
+            break;
+        case NativeNumberMode::NATNUM7: // Text. Lower, Short
+            number = &natnum7[langnum];
+            break;
+        case NativeNumberMode::NATNUM8: // Text, Upper, Short
+            number = &natnum8[langnum];
+            break;
+        case NativeNumberMode::NATNUM9: // Char, Hangul
+            num = NumberChar_Hangul_ko;
+            break;
+        case NativeNumberMode::NATNUM10:        // Text, Hangul, Long
+            number = &natnum10;
+            break;
+        case NativeNumberMode::NATNUM11:        // Text, Hangul, Short
+            number = &natnum11;
+            break;
+        default:
+            break;
+    }
+
+    if (number || num >= 0) {
+        if (aLocale.Language != rLocale.Language ||
+                aLocale.Country != rLocale.Country ||
+                aLocale.Variant != rLocale.Variant) {
+            LocaleDataItem item = LocaleDataImpl::get()->getLocaleItem( rLocale );
+            aLocale = rLocale;
+            DecimalChar[NumberChar_HalfWidth]=item.decimalSeparator.toChar();
+            if (DecimalChar[NumberChar_HalfWidth] > 0x7E || DecimalChar[NumberChar_HalfWidth] < 0x21)
+                DecimalChar[NumberChar_FullWidth]=0xFF0E;
+            else
+                DecimalChar[NumberChar_FullWidth]=DecimalChar[NumberChar_HalfWidth]+0xFEE0;
+            SeparatorChar[NumberChar_HalfWidth]=item.thousandSeparator.toChar();
+            if (SeparatorChar[NumberChar_HalfWidth] > 0x7E || SeparatorChar[NumberChar_HalfWidth] < 0x21)
+                SeparatorChar[NumberChar_FullWidth]=0xFF0C;
+            else
+                SeparatorChar[NumberChar_FullWidth]=SeparatorChar[NumberChar_HalfWidth]+0xFEE0;
+        }
+        if (number)
+            return AsciiToNative( aNumberString, aNumberString.getLength(), pOffset, number );
+        else if (num == NumberChar_he)
+            return getHebrewNativeNumberString(aNumberString,
+                    nNativeNumberMode == NativeNumberMode::NATNUM2);
+        else if (num == NumberChar_cu)
+            return getCyrillicNativeNumberString(aNumberString);
+        else
+            return AsciiToNativeChar(aNumberString, aNumberString.getLength(), pOffset, num);
+    }
+    else
+        return aNumberString;
+}
+
+OUString SAL_CALL NativeNumberSupplierService::getNativeNumberString(const OUString& aNumberString, const Locale& rLocale,
+                sal_Int16 nNativeNumberMode)
+{
+    return getNativeNumberString(aNumberString, rLocale, nNativeNumberMode, nullptr);
+}
+
+OUString SAL_CALL NativeNumberSupplierService::getNativeNumberStringParams(
+    const OUString& rNumberString, const css::lang::Locale& rLocale, sal_Int16 nNativeNumberMode,
+    const OUString& rNativeNumberParams)
+{
+    return getNativeNumberString(rNumberString, rLocale, nNativeNumberMode, nullptr, rNativeNumberParams);
+}
+
+sal_Unicode NativeNumberSupplierService::getNativeNumberChar( const sal_Unicode inChar, const Locale& rLocale, sal_Int16 nNativeNumberMode )
+{
+    if (nNativeNumberMode == NativeNumberMode::NATNUM0) { // Ascii
+        for (const auto & i : NumberChar)
+            for (sal_Int16 j = 0; j < 10; j++)
+                if (inChar == i[j])
+                    return j;
+        return inChar;
+    }
+
+    if (!isNumber(inChar))
+        return inChar;
+
+    if (!isValidNatNumImpl(rLocale, nNativeNumberMode))
+        return inChar;
+
+    sal_Int16 langnum = getLanguageNumber(rLocale);
+    if (langnum == -1)
+        return inChar;
+
+    switch (nNativeNumberMode)
+    {
+        case NativeNumberMode::NATNUM1: // Char, Lower
+        case NativeNumberMode::NATNUM4: // Text, Lower, Long
+        case NativeNumberMode::NATNUM7: // Text. Lower, Short
+            return NumberChar[natnum1[langnum]][inChar - NUMBER_ZERO];
+        case NativeNumberMode::NATNUM2: // Char, Upper
+        case NativeNumberMode::NATNUM5: // Text, Upper, Long
+        case NativeNumberMode::NATNUM8: // Text, Upper, Short
+            return NumberChar[natnum2[langnum]][inChar - NUMBER_ZERO];
+        case NativeNumberMode::NATNUM3: // Char, FullWidth
+        case NativeNumberMode::NATNUM6: // Text, FullWidth
+            return NumberChar[NumberChar_FullWidth][inChar - NUMBER_ZERO];
+        case NativeNumberMode::NATNUM9: // Char, Hangul
+        case NativeNumberMode::NATNUM10:        // Text, Hangul, Long
+        case NativeNumberMode::NATNUM11:        // Text, Hangul, Short
+            return NumberChar[NumberChar_Hangul_ko][inChar - NUMBER_ZERO];
+        default:
+            break;
+    }
+
+    return inChar;
+}
+
+bool NativeNumberSupplierService::isValidNatNumImpl( const Locale& rLocale, sal_Int16 nNativeNumberMode )
+{
+    sal_Int16 langnum = getLanguageNumber(rLocale);
+
+    switch (nNativeNumberMode) {
+        case NativeNumberMode::NATNUM0:     // Ascii
+        case NativeNumberMode::NATNUM3:     // Char, FullWidth
+        case NativeNumberMode::NATNUM12:    // spell out numbers, dates and money amounts
+            return true;
+        case NativeNumberMode::NATNUM1:     // Char, Lower
+            return (langnum >= 0);
+        case NativeNumberMode::NATNUM2:     // Char, Upper
+            if (langnum == 4) // Hebrew numbering
+                return true;
+            [[fallthrough]];
+        case NativeNumberMode::NATNUM4:     // Text, Lower, Long
+        case NativeNumberMode::NATNUM5:     // Text, Upper, Long
+        case NativeNumberMode::NATNUM6:     // Text, FullWidth
+        case NativeNumberMode::NATNUM7:     // Text. Lower, Short
+        case NativeNumberMode::NATNUM8:     // Text, Upper, Short
+            return (langnum >= 0 && langnum < 4); // CJK numbering
+        case NativeNumberMode::NATNUM9:     // Char, Hangul
+        case NativeNumberMode::NATNUM10:    // Text, Hangul, Long
+        case NativeNumberMode::NATNUM11:    // Text, Hangul, Short
+            return (langnum == 3); // Korean numbering
+    }
+    return false;
+}
+
+NativeNumberXmlAttributes SAL_CALL NativeNumberSupplierService::convertToXmlAttributes( const Locale& rLocale, sal_Int16 nNativeNumberMode )
+{
+    static const sal_Int16 attShort         = 0;
+    static const sal_Int16 attMedium        = 1;
+    static const sal_Int16 attLong          = 2;
+    static const char *attType[] = { "short", "medium", "long" };
+
+    sal_Int16 number = NumberChar_HalfWidth, type = attShort;
+
+    sal_Int16 langnum = -1;
+    if (isValidNatNum(rLocale, nNativeNumberMode)) {
+        langnum = getLanguageNumber(rLocale);
+    }
+    if (langnum != -1) {
+        switch (nNativeNumberMode) {
+            case NativeNumberMode::NATNUM0: // Ascii
+                number = NumberChar_HalfWidth;
+                type = attShort;
+                break;
+            case NativeNumberMode::NATNUM1: // Char, Lower
+                number = natnum1[langnum];
+                type = attShort;
+                break;
+            case NativeNumberMode::NATNUM2: // Char, Upper
+                number = natnum2[langnum];
+                type = number == NumberChar_he ? attMedium : attShort;
+                break;
+            case NativeNumberMode::NATNUM3: // Char, FullWidth
+                number = NumberChar_FullWidth;
+                type = attShort;
+                break;
+            case NativeNumberMode::NATNUM4: // Text, Lower, Long
+                number = natnum1[langnum];
+                type = attLong;
+                break;
+            case NativeNumberMode::NATNUM5: // Text, Upper, Long
+                number = natnum2[langnum];
+                type = attLong;
+                break;
+            case NativeNumberMode::NATNUM6: // Text, FullWidth
+                number = NumberChar_FullWidth;
+                type = attLong;
+                break;
+            case NativeNumberMode::NATNUM7: // Text. Lower, Short
+                number = natnum1[langnum];
+                type = attMedium;
+                break;
+            case NativeNumberMode::NATNUM8: // Text, Upper, Short
+                number = natnum2[langnum];
+                type = attMedium;
+                break;
+            case NativeNumberMode::NATNUM9: // Char, Hangul
+                number = NumberChar_Hangul_ko;
+                type = attShort;
+                break;
+            case NativeNumberMode::NATNUM10:        // Text, Hangul, Long
+                number = NumberChar_Hangul_ko;
+                type = attLong;
+                break;
+            case NativeNumberMode::NATNUM11:        // Text, Hangul, Short
+                number = NumberChar_Hangul_ko;
+                type = attMedium;
+                break;
+            default:
+                break;
+        }
+    }
+    return NativeNumberXmlAttributes(rLocale, OUString(&NumberChar[number][1], 1),
+            OUString::createFromAscii(attType[type]));
+}
+
+static bool natNumIn(sal_Int16 num, const sal_Int16 natnum[], sal_Int16 len)
+{
+    for (sal_Int16 i = 0; i < len; i++)
+        if (natnum[i] == num)
+            return true;
+    return false;
+}
+
+sal_Int16 SAL_CALL NativeNumberSupplierService::convertFromXmlAttributes( const NativeNumberXmlAttributes& aAttr )
+{
+    sal_Unicode numberChar[NumberChar_Count];
+    for (sal_Int16 i = 0; i < NumberChar_Count; i++)
+        numberChar[i] = NumberChar[i][1];
+    OUString number(numberChar, NumberChar_Count);
+
+    sal_Int16 num = sal::static_int_cast<sal_Int16>( number.indexOf(aAttr.Format) );
+
+    if ( aAttr.Style == "short" ) {
+        if (num == NumberChar_FullWidth)
+            return NativeNumberMode::NATNUM3;
+        else if (num == NumberChar_Hangul_ko)
+            return NativeNumberMode::NATNUM9;
+        else if (natNumIn(num, natnum1, sizeof_natnum1))
+            return NativeNumberMode::NATNUM1;
+        else if (natNumIn(num, natnum2, sizeof_natnum2))
+            return NativeNumberMode::NATNUM2;
+    } else if ( aAttr.Style == "medium" ) {
+        if (num == NumberChar_Hangul_ko)
+            return NativeNumberMode::NATNUM11;
+        else if (num == NumberChar_he)
+            return NativeNumberMode::NATNUM2;
+        else if (natNumIn(num, natnum1, sizeof_natnum1))
+            return NativeNumberMode::NATNUM7;
+        else if (natNumIn(num, natnum2, sizeof_natnum2))
+            return NativeNumberMode::NATNUM8;
+    } else if ( aAttr.Style == "long" ) {
+        if (num == NumberChar_FullWidth)
+            return NativeNumberMode::NATNUM6;
+        else if (num == NumberChar_Hangul_ko)
+            return NativeNumberMode::NATNUM10;
+        else if (natNumIn(num, natnum1, sizeof_natnum1))
+            return NativeNumberMode::NATNUM4;
+        else if (natNumIn(num, natnum2, sizeof_natnum2))
+            return NativeNumberMode::NATNUM5;
+    } else {
+        throw RuntimeException();
+    }
+    return NativeNumberMode::NATNUM0;
+}
+
+
+// Following code generates Hebrew Number,
+// see numerical system in the Hebrew Numbering System in following link for details,
+// http://smontagu.org/writings/HebrewNumbers.html
+
+namespace {
+
+struct HebrewNumberChar {
+    sal_Unicode code;
+    sal_Int16 value;
+};
+
+}
+
+HebrewNumberChar const HebrewNumberCharArray[] = {
+    { 0x05ea, 400 },
+    { 0x05ea, 400 },
+    { 0x05e9, 300 },
+    { 0x05e8, 200 },
+    { 0x05e7, 100 },
+    { 0x05e6, 90 },
+    { 0x05e4, 80 },
+    { 0x05e2, 70 },
+    { 0x05e1, 60 },
+    { 0x05e0, 50 },
+    { 0x05de, 40 },
+    { 0x05dc, 30 },
+    { 0x05db, 20 },
+    { 0x05d9, 10 },
+    { 0x05d8, 9 },
+    { 0x05d7, 8 },
+    { 0x05d6, 7 },
+    { 0x05d5, 6 },
+    { 0x05d4, 5 },
+    { 0x05d3, 4 },
+    { 0x05d2, 3 },
+    { 0x05d1, 2 },
+    { 0x05d0, 1 }
+};
+
+const sal_Unicode thousand[] = {0x05d0, 0x05dc, 0x05e3, 0x0};
+const sal_Unicode thousands[] = {0x05d0, 0x05dc, 0x05e4, 0x05d9, 0x0};
+const sal_Unicode thousands_last[] = {0x05d0, 0x05dc, 0x05e4, 0x05d9, 0x05dd, 0x0};
+const sal_Unicode geresh = 0x05f3;
+const sal_Unicode gershayim = 0x05f4;
+
+static void makeHebrewNumber(sal_Int64 value, OUStringBuffer& output, bool isLast, bool useGeresh)
+{
+    sal_Int16 num = sal::static_int_cast<sal_Int16>(value % 1000);
+
+    if (value > 1000) {
+        makeHebrewNumber(value / 1000, output, num != 0, useGeresh);
+        output.append(" ");
+    }
+    if (num == 0) {
+        output.append(value == 1000 ? thousand : isLast ? thousands_last : thousands);
+    } else {
+        sal_Int16 nbOfChar = 0;
+        for (sal_Int32 j = 0; num > 0 && j < sal_Int32(SAL_N_ELEMENTS(HebrewNumberCharArray)); j++) {
+            if (num - HebrewNumberCharArray[j].value >= 0) {
+                nbOfChar++;
+                // https://en.wikipedia.org/wiki/Hebrew_numerals#Key_exceptions
+                // By convention, the numbers 15 and 16 are represented as 9 + 6 and 9 + 7
+                if (num == 15 || num == 16) // substitution for 15 and 16
+                    j++;
+                assert(j < sal_Int32(SAL_N_ELEMENTS(HebrewNumberCharArray)));
+                num = sal::static_int_cast<sal_Int16>( num - HebrewNumberCharArray[j].value );
+                output.append(HebrewNumberCharArray[j].code);
+            }
+        }
+        if (useGeresh) {
+            if (nbOfChar > 1)   // a number is written as more than one character
+                output.insert(output.getLength() - 1, gershayim);
+            else if (nbOfChar == 1) // a number is written as a single character
+                output.append(geresh);
+        }
+    }
+}
+
+OUString getHebrewNativeNumberString(const OUString& aNumberString, bool useGeresh)
+{
+    sal_Int64 value = 0;
+    sal_Int32 i, count = 0, len = aNumberString.getLength();
+    const sal_Unicode *src = aNumberString.getStr();
+
+    for (i = 0; i < len; i++) {
+        sal_Unicode ch = src[i];
+        if (isNumber(ch)) {
+            if (++count >= 20) // Number is too long, could not be handled.
+                return aNumberString;
+            value = value * 10 + (ch - NUMBER_ZERO);
+        }
+        else if (isSeparator(ch) && count > 0) continue;
+        else if (isMinus(ch) && count == 0) continue;
+        else break;
+    }
+
+    if (value > 0) {
+        OUStringBuffer output(count*2 + 2 + len - i);
+
+        makeHebrewNumber(value, output, true, useGeresh);
+
+        if (i < len)
+            output.append(aNumberString.subView(i));
+
+        return output.makeStringAndClear();
+    }
+    else
+        return aNumberString;
+}
+
+// Support for Cyrillic Numerals
+// See UTN 41 for implementation information
+// http://www.unicode.org/notes/tn41/
+
+const sal_Unicode cyrillicThousandsMark = 0x0482;
+const sal_Unicode cyrillicTitlo = 0x0483;
+const sal_Unicode cyrillicTen = 0x0456;
+
+namespace {
+
+struct CyrillicNumberChar {
+    sal_Unicode code;
+    sal_Int16 value;
+};
+
+}
+
+CyrillicNumberChar const CyrillicNumberCharArray[] = {
+    { 0x0446, 900 },
+    { 0x047f, 800 },
+    { 0x0471, 700 },
+    { 0x0445, 600 },
+    { 0x0444, 500 },
+    { 0x0443, 400 },
+    { 0x0442, 300 },
+    { 0x0441, 200 },
+    { 0x0440, 100 },
+    { 0x0447, 90 },
+    { 0x043f, 80 },
+    { 0x047b, 70 },
+    { 0x046f, 60 },
+    { 0x043d, 50 },
+    { 0x043c, 40 },
+    { 0x043b, 30 },
+    { 0x043a, 20 },
+    { 0x0456, 10 },
+    { 0x0473, 9 },
+    { 0x0438, 8 },
+    { 0x0437, 7 },
+    { 0x0455, 6 },
+    { 0x0454, 5 },
+    { 0x0434, 4 },
+    { 0x0433, 3 },
+    { 0x0432, 2 },
+    { 0x0430, 1 }
+};
+
+static void makeCyrillicNumber(sal_Int64 value, OUStringBuffer& output, bool addTitlo)
+{
+    sal_Int16 num = sal::static_int_cast<sal_Int16>(value % 1000);
+    if (value >= 1000) {
+        output.append(cyrillicThousandsMark);
+        makeCyrillicNumber(value / 1000, output, false);
+        if (value >= 10000 && (value - 10000) % 1000 != 0) {
+            output.append(" ");
+        }
+        if (value % 1000 == 0)
+            addTitlo = false;
+    }
+
+    for (sal_Int32 j = 0; num > 0 && j < sal_Int32(SAL_N_ELEMENTS(CyrillicNumberCharArray)); j++) {
+        if (num < 20 && num > 10) {
+            num -= 10;
+            makeCyrillicNumber(num, output, false);
+            output.append(cyrillicTen);
+            break;
+        }
+
+        if (CyrillicNumberCharArray[j].value <= num) {
+            output.append(CyrillicNumberCharArray[j].code);
+            num = sal::static_int_cast<sal_Int16>( num - CyrillicNumberCharArray[j].value );
+        }
+    }
+
+    if (!addTitlo)
+        return;
+
+    if (output.getLength() == 1) {
+        output.append(cyrillicTitlo);
+    } else if (output.getLength() == 2) {
+        if (value > 800 && value < 900) {
+            output.append(cyrillicTitlo);
+        } else {
+            output.insert(1, cyrillicTitlo);
+        }
+    } else if (output.getLength() > 2) {
+        if (output.indexOf(" ") == output.getLength() - 2) {
+            output.append(cyrillicTitlo);
+        } else {
+            output.insert(output.getLength() - 1, cyrillicTitlo);
+        }
+    }
+}
+
+OUString getCyrillicNativeNumberString(const OUString& aNumberString)
+{
+    sal_Int64 value = 0;
+    sal_Int32 i, count = 0, len = aNumberString.getLength();
+    const sal_Unicode *src = aNumberString.getStr();
+
+    for (i = 0; i < len; i++) {
+        sal_Unicode ch = src[i];
+        if (isNumber(ch)) {
+            if (++count >= 8) // Number is too long, could not be handled.
+                return aNumberString;
+            value = value * 10 + (ch - NUMBER_ZERO);
+        }
+        else if (isSeparator(ch) && count > 0) continue;
+        else if (isMinus(ch) && count == 0) continue;
+        else break;
+    }
+
+    if (value > 0) {
+        OUStringBuffer output(count*2 + 2 + len - i);
+
+        makeCyrillicNumber(value, output, true);
+
+        if (i < len)
+            output.append(aNumberString.subView(i));
+
+        return output.makeStringAndClear();
+    }
+    else
+        return aNumberString;
+}
+
+constexpr OUStringLiteral implementationName = u"com.sun.star.i18n.NativeNumberSupplier";
+
+OUString SAL_CALL NativeNumberSupplierService::getImplementationName()
+{
+    return implementationName;
+}
+
+sal_Bool SAL_CALL
+NativeNumberSupplierService::supportsService(const OUString& rServiceName)
+{
+    return cppu::supportsService(this, rServiceName);
+}
+
+Sequence< OUString > SAL_CALL
+NativeNumberSupplierService::getSupportedServiceNames()
+{
+    return {implementationName, "com.sun.star.i18n.NativeNumberSupplier2"};
+}
+
+}
+
+extern "C" SAL_DLLPUBLIC_EXPORT css::uno::XInterface *
+com_sun_star_i18n_NativeNumberSupplier_get_implementation(
+    css::uno::XComponentContext *,
+    css::uno::Sequence<css::uno::Any> const &)
+{
+    return cppu::acquire(new i18npool::NativeNumberSupplierService());
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */