1 /**
2 * Copyright (c) 2024 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include "plugins/ets/stdlib/native/core/IntlNumberFormat.h"
17 #include "plugins/ets/stdlib/native/core/IntlState.h"
18 #include "libpandabase/macros.h"
19 #include "libpandabase/os/mutex.h"
20 #include "unicode/numberformatter.h"
21 #include "unicode/numberrangeformatter.h"
22 #include "unicode/locid.h"
23 #include "unicode/coll.h"
24 #include "unicode/unistr.h"
25
26 #include <string>
27 #include <unordered_map>
28 #include <iterator>
29 #include <cstdlib>
30 #include <array>
31
32 namespace ark::ets::stdlib {
33
EtsToStdStr(EtsEnv * env,ets_string etsStr)34 std::string EtsToStdStr(EtsEnv *env, ets_string etsStr)
35 {
36 const char *charString = env->GetStringUTFChars(etsStr, nullptr);
37 std::string stdStr {charString};
38 env->ReleaseStringUTFChars(etsStr, charString);
39 return stdStr;
40 }
41
LocTagToIcuLocale(EtsEnv * env,const std::string & locTag)42 icu::Locale LocTagToIcuLocale(EtsEnv *env, const std::string &locTag)
43 {
44 icu::StringPiece sp {locTag.data(), static_cast<int32_t>(locTag.size())};
45 UErrorCode status = U_ZERO_ERROR;
46 icu::Locale loc = icu::Locale::forLanguageTag(sp, status);
47 if (UNLIKELY(U_FAILURE(status))) {
48 std::string message = "Language tag '" + locTag + std::string("' is invalid or not supported");
49 env->ThrowErrorNew(env->FindClass("std/core/RuntimeException"), message.c_str());
50 return icu::Locale::getDefault();
51 }
52 return loc;
53 }
54
IcuFormatDouble(EtsEnv * env,ets_class klass,ets_string locale,ets_double value)55 ets_string IcuFormatDouble(EtsEnv *env, [[maybe_unused]] ets_class klass, ets_string locale, ets_double value)
56 {
57 const std::string &locTag = EtsToStdStr(env, locale);
58 const icu::Locale &loc = LocTagToIcuLocale(env, locTag);
59 const icu::number::LocalizedNumberFormatter &formatter =
60 g_intlState->fmtsCache.NumFmtsCacheInvalidation(locTag, loc);
61
62 UErrorCode status = U_ZERO_ERROR;
63 const icu::number::FormattedNumber &fmtNumber = formatter.formatDouble(value, status);
64 if (UNLIKELY(U_FAILURE(status))) {
65 std::string message = "IcuFormatDouble. Unable to format double " + std::to_string(value);
66 env->ThrowErrorNew(env->FindClass("std/core/RuntimeException"), message.c_str());
67 return nullptr;
68 }
69 icu::UnicodeString ustr = fmtNumber.toString(status);
70 return env->NewString(reinterpret_cast<const uint16_t *>(ustr.getBuffer()), ustr.length());
71 }
72
IcuFormatDecStr(EtsEnv * env,ets_class klass,ets_string locale,ets_string value)73 ets_string IcuFormatDecStr(EtsEnv *env, [[maybe_unused]] ets_class klass, ets_string locale, ets_string value)
74 {
75 const std::string &locTag = EtsToStdStr(env, locale);
76 const icu::Locale &loc = LocTagToIcuLocale(env, locTag);
77 const icu::number::LocalizedNumberFormatter &formatter =
78 g_intlState->fmtsCache.NumFmtsCacheInvalidation(locTag, loc);
79
80 const std::string &valueString = EtsToStdStr(env, value);
81 const icu::StringPiece sp {valueString.data(), static_cast<int32_t>(valueString.size())};
82
83 UErrorCode status = U_ZERO_ERROR;
84 const icu::number::FormattedNumber &fmtNumber = formatter.formatDecimal(sp, status);
85 if (UNLIKELY(U_FAILURE(status))) {
86 std::string message = "IcuFormatDecimal. Unable to format BigInt " + valueString;
87 env->ThrowErrorNew(env->FindClass("std/core/RuntimeException"), message.c_str());
88 return nullptr;
89 }
90 icu::UnicodeString ustr = fmtNumber.toString(status);
91 return env->NewString(reinterpret_cast<const uint16_t *>(ustr.getBuffer()), ustr.length());
92 }
93
IcuFormatRange(EtsEnv * env,ets_string locale,icu::Formattable startFrmtbl,icu::Formattable endFrmtbl)94 ets_string IcuFormatRange(EtsEnv *env, ets_string locale, icu::Formattable startFrmtbl, icu::Formattable endFrmtbl)
95 {
96 const std::string &locTag = EtsToStdStr(env, locale);
97 const icu::Locale &loc = LocTagToIcuLocale(env, locTag);
98 const icu::number::LocalizedNumberRangeFormatter &formatter =
99 g_intlState->fmtsCache.NumRangeFmtsCacheInvalidation(locTag, loc);
100
101 UErrorCode status = U_ZERO_ERROR;
102 const icu::number::FormattedNumberRange &fmtRangeNumber =
103 formatter.formatFormattableRange(startFrmtbl, endFrmtbl, status);
104 if (UNLIKELY(U_FAILURE(status))) {
105 std::string message = "IcuFormatRangeFormattable. Unable to rangeformat ";
106 UErrorCode startStatus = U_ZERO_ERROR;
107 std::string startStr {startFrmtbl.getDecimalNumber(startStatus).data()};
108 UErrorCode endStatus = U_ZERO_ERROR;
109 std::string endStr {endFrmtbl.getDecimalNumber(endStatus).data()};
110 if (UNLIKELY(U_FAILURE(startStatus))) {
111 message += ". Crashed conversion startFrmtbl into std::string";
112 } else if (UNLIKELY(U_FAILURE(endStatus))) {
113 message += ". Crashed conversion endFrmtbl into std::string";
114 } else {
115 message += std::string(" start ") + startStr + std::string(" end ") + endStr;
116 }
117 env->ThrowErrorNew(env->FindClass("std/core/RuntimeException"), message.c_str());
118 return nullptr;
119 }
120 icu::UnicodeString ustr = fmtRangeNumber.toString(status);
121 return env->NewString(reinterpret_cast<const uint16_t *>(ustr.getBuffer()), ustr.length());
122 }
123
DoubleToFormattable(EtsEnv * env,double value)124 icu::Formattable DoubleToFormattable([[maybe_unused]] EtsEnv *env, double value)
125 {
126 return icu::Formattable(value);
127 }
128
EtsStrToFormattable(EtsEnv * env,ets_string value)129 icu::Formattable EtsStrToFormattable(EtsEnv *env, ets_string value)
130 {
131 UErrorCode status = U_ZERO_ERROR;
132 const std::string &str = EtsToStdStr(env, value);
133 const icu::StringPiece sp {str.data(), static_cast<int32_t>(str.size())};
134 icu::Formattable ret(sp, status);
135 if (UNLIKELY(U_FAILURE(status))) {
136 std::string message = "EtsStrToToFormattable. Unable to create icu::Formattable from value " + str;
137 env->ThrowErrorNew(env->FindClass("std/core/RuntimeException"), message.c_str());
138 return icu::Formattable();
139 }
140 return ret;
141 }
142
IcuFormatRangeDoubleDouble(EtsEnv * env,ets_class klass,ets_string locale,double startValue,double endValue)143 ets_string IcuFormatRangeDoubleDouble(EtsEnv *env, [[maybe_unused]] ets_class klass, ets_string locale,
144 double startValue, double endValue)
145 {
146 return IcuFormatRange(env, locale, DoubleToFormattable(env, startValue), DoubleToFormattable(env, endValue));
147 }
148
IcuFormatRangeDoubleDecStr(EtsEnv * env,ets_class klass,ets_string locale,double startValue,ets_string endValue)149 ets_string IcuFormatRangeDoubleDecStr(EtsEnv *env, [[maybe_unused]] ets_class klass, ets_string locale,
150 double startValue, ets_string endValue)
151 {
152 return IcuFormatRange(env, locale, DoubleToFormattable(env, startValue), EtsStrToFormattable(env, endValue));
153 }
154
IcuFormatRangeDecStrDouble(EtsEnv * env,ets_class klass,ets_string locale,ets_string startValue,double endValue)155 ets_string IcuFormatRangeDecStrDouble(EtsEnv *env, [[maybe_unused]] ets_class klass, ets_string locale,
156 ets_string startValue, double endValue)
157 {
158 return IcuFormatRange(env, locale, EtsStrToFormattable(env, startValue), DoubleToFormattable(env, endValue));
159 }
160
IcuFormatRangeDecStrDecStr(EtsEnv * env,ets_class klass,ets_string locale,ets_string startValue,ets_string endValue)161 ets_string IcuFormatRangeDecStrDecStr(EtsEnv *env, [[maybe_unused]] ets_class klass, ets_string locale,
162 ets_string startValue, ets_string endValue)
163 {
164 return IcuFormatRange(env, locale, EtsStrToFormattable(env, startValue), EtsStrToFormattable(env, endValue));
165 }
166
RegisterIntlNumberFormatNativeMethods(EtsEnv * env)167 ets_int RegisterIntlNumberFormatNativeMethods(EtsEnv *env)
168 {
169 const auto methods =
170 std::array {EtsNativeMethod {"formatDouble", nullptr, reinterpret_cast<ets_string *>(IcuFormatDouble)},
171 EtsNativeMethod {"formatDecStr", nullptr, reinterpret_cast<ets_string *>(IcuFormatDecStr)},
172 EtsNativeMethod {"formatRangeDoubleDouble", nullptr,
173 reinterpret_cast<ets_string *>(IcuFormatRangeDoubleDouble)},
174 EtsNativeMethod {"formatRangeDoubleDecStr", nullptr,
175 reinterpret_cast<ets_string *>(IcuFormatRangeDoubleDecStr)},
176 EtsNativeMethod {"formatRangeDecStrDouble", nullptr,
177 reinterpret_cast<ets_string *>(IcuFormatRangeDecStrDouble)},
178 EtsNativeMethod {"formatRangeDecStrDecStr", nullptr,
179 reinterpret_cast<ets_string *>(IcuFormatRangeDecStrDecStr)}};
180
181 ets_class numberFormatClass = env->FindClass("std/core/NumberFormat");
182 return env->RegisterNatives(numberFormatClass, methods.data(), methods.size());
183 }
184
185 } // namespace ark::ets::stdlib
186