organicmaps/icu
13
Fork 0
mirror of https://github.com/unicode-org/icu.git synced 2025-04-05 21:45:37 +00:00
Code Issues 1 Projects Releases Wiki Activity Actions 12

ICU-22261 Refactor error handling for internal MF2 array-allocating functions

Browse source
This commit is contained in:
Elango Cheran 2024-04-11 14:12:58 -07:00 • committed by Markus Scherer
parent 75eab42060
commit a1bce0c096
5 changed files with 160 additions and 94 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

4
.ci-builds/.azure-pipelines-icu4c.yml
View file

@ -381,7 +381,7 @@ jobs:
#-------------------------------------------------------------------------
- job: ICU4C_MSVC_x64_Debug
displayName: 'C: MSVC x64 Debug (VS 2022)'
timeoutInMinutes: 35
timeoutInMinutes: 60
pool:
vmImage: 'windows-2022'
demands:
@ -487,7 +487,7 @@ jobs:
#-------------------------------------------------------------------------
- job: ICU4C_MSVC_x86_Debug_VS2019
displayName: 'C: MSVC 32-bit Debug (VS 2019)'
timeoutInMinutes: 60
timeoutInMinutes: 90
pool:
vmImage: 'windows-2019'
demands:

36
icu4c/source/i18n/messageformat2_allocation.h
View file

@ -24,16 +24,15 @@ namespace message2 {
// Helpers
template<typename T>
static T* copyArray(const T* source, int32_t& len) { // `len` is an in/out param
if (source == nullptr) {
len = 0;
static T* copyArray(const T* source, int32_t len, UErrorCode& status) {
if (U_FAILURE(status)) {
return nullptr;
}
U_ASSERT(source != nullptr);
U_ASSERT(len >= 0);
T* dest = new T[len];
if (dest == nullptr) {
// Set length to 0 to prevent the
// array from being accessed
len = 0;
status = U_MEMORY_ALLOCATION_ERROR;
} else {
for (int32_t i = 0; i < len; i++) {
dest[i] = source[i];
@ -43,13 +42,14 @@ namespace message2 {
}
template<typename T>
static T* copyVectorToArray(const UVector& source, int32_t& len) {
len = source.size();
static T* copyVectorToArray(const UVector& source, UErrorCode& status) {
if (U_FAILURE(status)) {
return nullptr;
}
int32_t len = source.size();
T* dest = new T[len];
if (dest == nullptr) {
// Set length to 0 to prevent the
// array from being accessed
len = 0;
status = U_MEMORY_ALLOCATION_ERROR;
} else {
for (int32_t i = 0; i < len; i++) {
dest[i] = *(static_cast<T*>(source.elementAt(i)));
@ -59,19 +59,21 @@ namespace message2 {
}
template<typename T>
static T* moveVectorToArray(UVector& source, int32_t& len) {
len = source.size();
static T* moveVectorToArray(UVector& source, UErrorCode& status) {
if (U_FAILURE(status)) {
return nullptr;
}
int32_t len = source.size();
T* dest = new T[len];
if (dest == nullptr) {
// Set length to 0 to prevent the
// array from being accessed
len = 0;
status = U_MEMORY_ALLOCATION_ERROR;
} else {
for (int32_t i = 0; i < len; i++) {
dest[i] = std::move(*static_cast<T*>(source.elementAt(i)));
}
source.removeAllElements();
}
source.removeAllElements();
return dest;
}

160
icu4c/source/i18n/messageformat2_data_model.cpp
View file

@ -77,15 +77,10 @@ SelectorKeys::Builder::~Builder() {
}
SelectorKeys::SelectorKeys(const UVector& ks, UErrorCode& status) : len(ks.size()) {
Key* result = copyVectorToArray<Key>(ks, status);
if (U_FAILURE(status)) {
return;
}
Key* result = copyVectorToArray<Key>(ks, len);
if (result == nullptr) {
status = U_MEMORY_ALLOCATION_ERROR;
len = 0;
return;
}
keys.adoptInstead(result);
}
@ -95,7 +90,13 @@ SelectorKeys& SelectorKeys::operator=(SelectorKeys other) noexcept {
}
SelectorKeys::SelectorKeys(const SelectorKeys& other) : len(other.len) {
keys.adoptInstead(copyArray(other.keys.getAlias(), len));
UErrorCode localErrorCode = U_ZERO_ERROR;
if (len != 0) {
keys.adoptInstead(copyArray(other.keys.getAlias(), len, localErrorCode));
}
if (U_FAILURE(localErrorCode)) {
len = 0;
}
}
SelectorKeys::~SelectorKeys() {
@ -198,9 +199,18 @@ Key::~Key() {}
// ------------ Reserved
// Copy constructor
Reserved::Reserved(const Reserved& other) {
len = other.len;
parts.adoptInstead(copyArray(other.parts.getAlias(), len));
Reserved::Reserved(const Reserved& other) : len(other.len) {
U_ASSERT(!other.bogus);
UErrorCode localErrorCode = U_ZERO_ERROR;
if (len == 0) {
parts.adoptInstead(nullptr);
} else {
parts.adoptInstead(copyArray(other.parts.getAlias(), len, localErrorCode));
}
if (U_FAILURE(localErrorCode)) {
bogus = true;
}
}
Reserved& Reserved::operator=(Reserved other) noexcept {
@ -212,14 +222,16 @@ Reserved::Reserved(const UVector& ps, UErrorCode& status) noexcept : len(ps.size
if (U_FAILURE(status)) {
return;
}
parts = LocalArray<Literal>(copyVectorToArray<Literal>(ps, len));
parts = LocalArray<Literal>(copyVectorToArray<Literal>(ps, status));
}
int32_t Reserved::numParts() const {
U_ASSERT(!bogus);
return len;
}
const Literal& Reserved::getPart(int32_t i) const {
U_ASSERT(!bogus);
U_ASSERT(i < numParts());
return parts[i];
}
@ -257,14 +269,10 @@ Reserved::~Reserved() {
//------------------------ Operator
OptionMap::OptionMap(const UVector& opts, UErrorCode& status) {
CHECK_ERROR(status);
len = opts.size();
Option* result = copyVectorToArray<Option>(opts, len);
if (result == nullptr && len != 0) {
OptionMap::OptionMap(const UVector& opts, UErrorCode& status) : len(opts.size()) {
Option* result = copyVectorToArray<Option>(opts, status);
if (U_FAILURE(status)) {
bogus = true;
status = U_MEMORY_ALLOCATION_ERROR;
return;
}
options.adoptInstead(result);
@ -273,8 +281,9 @@ OptionMap::OptionMap(const UVector& opts, UErrorCode& status) {
OptionMap::OptionMap(const OptionMap& other) : len(other.len) {
U_ASSERT(!other.bogus);
Option* result = copyArray(other.options.getAlias(), len);
if (result == nullptr && len != 0) {
UErrorCode localErrorCode = U_ZERO_ERROR;
Option* result = copyArray(other.options.getAlias(), len, localErrorCode);
if (U_FAILURE(localErrorCode)) {
bogus = true;
return;
}
@ -653,16 +662,13 @@ const Reserved* UnsupportedStatement::getBody(UErrorCode& errorCode) const {
UnsupportedStatement::UnsupportedStatement(const UnicodeString& k,
const std::optional<Reserved>& r,
const UVector& es,
UErrorCode& status) : keyword(k), body(r) {
UErrorCode& status)
: keyword(k), body(r), expressionsLen(es.size()) {
CHECK_ERROR(status);
U_ASSERT(es.size() >= 1);
Expression* result = copyVectorToArray<Expression>(es, expressionsLen);
if (result == nullptr) {
status = U_MEMORY_ALLOCATION_ERROR;
expressionsLen = 0;
return;
}
U_ASSERT(expressionsLen >= 1);
Expression* result = copyVectorToArray<Expression>(es, status);
CHECK_ERROR(status);
expressions.adoptInstead(result);
}
@ -671,7 +677,11 @@ UnsupportedStatement::UnsupportedStatement(const UnsupportedStatement& other) {
body = other.body;
expressionsLen = other.expressionsLen;
U_ASSERT(expressionsLen > 0);
expressions.adoptInstead(copyArray(other.expressions.getAlias(), expressionsLen));
UErrorCode localErrorCode = U_ZERO_ERROR;
expressions.adoptInstead(copyArray(other.expressions.getAlias(), expressionsLen, localErrorCode));
if (U_FAILURE(localErrorCode)) {
expressionsLen = 0;
}
}
UnsupportedStatement& UnsupportedStatement::operator=(UnsupportedStatement other) noexcept {
@ -722,21 +732,32 @@ Pattern::Pattern(const UVector& ps, UErrorCode& status) : len(ps.size()) {
if (U_FAILURE(status)) {
return;
}
PatternPart* result = copyVectorToArray<PatternPart>(ps, len);
if (result == nullptr) {
status = U_MEMORY_ALLOCATION_ERROR;
return;
}
PatternPart* result = copyVectorToArray<PatternPart>(ps, status);
CHECK_ERROR(status);
parts.adoptInstead(result);
}
// Copy constructor
Pattern::Pattern(const Pattern& other) noexcept : len(other.len) {
parts.adoptInstead(copyArray(other.parts.getAlias(), len));
Pattern::Pattern(const Pattern& other) : len(other.len) {
U_ASSERT(!other.bogus);
UErrorCode localErrorCode = U_ZERO_ERROR;
if (len == 0) {
parts.adoptInstead(nullptr);
} else {
parts.adoptInstead(copyArray(other.parts.getAlias(), len, localErrorCode));
}
if (U_FAILURE(localErrorCode)) {
bogus = true;
}
}
int32_t Pattern::numParts() const {
U_ASSERT(!bogus);
return len;
}
const PatternPart& Pattern::getPart(int32_t i) const {
U_ASSERT(i < numParts());
U_ASSERT(!bogus && i < numParts());
return parts[i];
}
@ -875,12 +896,26 @@ Matcher& Matcher::operator=(Matcher other) {
}
Matcher::Matcher(const Matcher& other) {
U_ASSERT(!other.bogus);
numSelectors = other.numSelectors;
numVariants = other.numVariants;
selectors.adoptInstead(copyArray<Expression>(other.selectors.getAlias(), numSelectors));
variants.adoptInstead(copyArray<Variant>(other.variants.getAlias(), numVariants));
UErrorCode localErrorCode = U_ZERO_ERROR;
selectors.adoptInstead(copyArray<Expression>(other.selectors.getAlias(),
numSelectors,
localErrorCode));
variants.adoptInstead(copyArray<Variant>(other.variants.getAlias(),
numVariants,
localErrorCode));
if (U_FAILURE(localErrorCode)) {
bogus = true;
}
}
Matcher::Matcher(Expression* ss, int32_t ns, Variant* vs, int32_t nv)
: selectors(ss), numSelectors(ns), variants(vs), numVariants(nv) {}
Matcher::~Matcher() {}
// --------------- MFDataModel
const Pattern& MFDataModel::getPattern() const {
@ -1014,29 +1049,34 @@ MFDataModel::Builder& MFDataModel::Builder::setPattern(Pattern&& pat) {
MFDataModel::MFDataModel(const MFDataModel& other) : body(Pattern()) {
U_ASSERT(!other.bogus);
UErrorCode localErrorCode = U_ZERO_ERROR;
if (other.hasPattern()) {
body.emplace<Pattern>(Pattern(*std::get_if<Pattern>(&other.body)));
// body.emplace<Pattern>(Pattern(*std::get_if<Pattern>(&other.body)));
body = *std::get_if<Pattern>(&other.body);
} else {
const Expression* otherSelectors = other.getSelectorsInternal();
const Variant* otherVariants = other.getVariantsInternal();
int32_t numSelectors = other.numSelectors();
int32_t numVariants = other.numVariants();
Expression* copiedSelectors = copyArray(otherSelectors, numSelectors);
Variant* copiedVariants = copyArray(otherVariants, numVariants);
if (!(copiedSelectors != nullptr && copiedVariants != nullptr)) {
Expression* copiedSelectors = copyArray(otherSelectors, numSelectors, localErrorCode);
Variant* copiedVariants = copyArray(otherVariants, numVariants, localErrorCode);
if (U_FAILURE(localErrorCode)) {
bogus = true;
return;
}
body.emplace<Matcher>(Matcher(copiedSelectors, numSelectors, copiedVariants, numVariants));
// body.emplace<Matcher>(Matcher(copiedSelectors, numSelectors, copiedVariants, numVariants));
body = Matcher(copiedSelectors, numSelectors, copiedVariants, numVariants);
}
bindingsLen = other.bindingsLen;
bindings.adoptInstead(copyArray(other.bindings.getAlias(), bindingsLen));
if (!bindings.isValid()) {
bindings.adoptInstead(copyArray(other.bindings.getAlias(), bindingsLen, localErrorCode));
if (U_FAILURE(localErrorCode)) {
bogus = true;
}
unsupportedStatementsLen = other.unsupportedStatementsLen;
unsupportedStatements.adoptInstead(copyArray(other.unsupportedStatements.getAlias(), unsupportedStatementsLen));
if (!unsupportedStatements.isValid()) {
unsupportedStatements.adoptInstead(copyArray(other.unsupportedStatements.getAlias(), unsupportedStatementsLen, localErrorCode));
if (U_FAILURE(localErrorCode)) {
bogus = true;
}
}
@ -1047,25 +1087,33 @@ MFDataModel::MFDataModel(const MFDataModel::Builder& builder, UErrorCode& errorC
if (builder.hasPattern) {
body.emplace<Pattern>(builder.pattern);
} else {
int32_t numVariants = builder.variants == nullptr ? 0 : builder.variants->size();
int32_t numSelectors = builder.selectors == nullptr ? 0 : builder.selectors->size();
Variant* variants = copyVectorToArray<Variant>(*builder.variants, numVariants);
Expression* selectors = copyVectorToArray<Expression>(*builder.selectors, numSelectors);
bogus &= (variants != nullptr && selectors != nullptr);
U_ASSERT(builder.variants != nullptr);
U_ASSERT(builder.selectors != nullptr);
int32_t numVariants = builder.variants->size();
int32_t numSelectors = builder.selectors->size();
Variant* variants = copyVectorToArray<Variant>(*builder.variants, errorCode);
Expression* selectors = copyVectorToArray<Expression>(*builder.selectors, errorCode);
if (U_FAILURE(errorCode)) {
bogus = true;
return;
}
body.emplace<Matcher>(Matcher(selectors, numSelectors, variants, numVariants));
}
U_ASSERT(builder.bindings != nullptr);
bindingsLen = builder.bindings->size();
bindings.adoptInstead(copyVectorToArray<Binding>(*builder.bindings, bindingsLen));
bindings.adoptInstead(copyVectorToArray<Binding>(*builder.bindings, errorCode));
unsupportedStatementsLen = builder.unsupportedStatements->size();
unsupportedStatements.adoptInstead(copyVectorToArray<UnsupportedStatement>(*builder.unsupportedStatements, unsupportedStatementsLen));
bogus &= ((bool) (bindings.isValid() && unsupportedStatements.isValid()));
unsupportedStatements.adoptInstead(copyVectorToArray<UnsupportedStatement>(*builder.unsupportedStatements, errorCode));
if (U_FAILURE(errorCode)) {
bogus = true;
}
}
MFDataModel::MFDataModel() : body(Pattern()) {}
MFDataModel& MFDataModel::operator=(MFDataModel other) noexcept {
U_ASSERT(!other.bogus);
swap(*this, other);
return *this;
}

6
icu4c/source/i18n/messageformat2_evaluation.cpp
View file

@ -40,10 +40,8 @@ const ResolvedFunctionOption* FunctionOptions::getResolvedFunctionOptions(int32_
FunctionOptions::FunctionOptions(UVector&& optionsVector, UErrorCode& status) {
CHECK_ERROR(status);
options = moveVectorToArray<ResolvedFunctionOption>(optionsVector, functionOptionsLen);
if (options == nullptr) {
status = U_MEMORY_ALLOCATION_ERROR;
}
functionOptionsLen = optionsVector.size();
options = moveVectorToArray<ResolvedFunctionOption>(optionsVector, status);
}
UBool FunctionOptions::getFunctionOption(const UnicodeString& key, Formattable& option) const {

48
icu4c/source/i18n/unicode/messageformat2_data_model.h
View file

@ -167,6 +167,7 @@ namespace message2 {
friend inline void swap(Reserved& r1, Reserved& r2) noexcept {
using std::swap;
swap(r1.bogus, r2.bogus);
swap(r1.parts, r2.parts);
swap(r1.len, r2.len);
}
@ -203,11 +204,16 @@ namespace message2 {
friend class Builder;
friend class Operator;
// True if a copy failed; this has to be distinguished
// from a valid `Reserved` with empty parts
bool bogus = false;
// Possibly-empty list of parts
// `literal` reserved as a quoted literal; `reserved-char` / `reserved-escape`
// strings represented as unquoted literals
/* const */ LocalArray<Literal> parts;
int32_t len = 0;
Reserved(const UVector& parts, UErrorCode& status) noexcept;
// Helper
static void initLiterals(Reserved&, const Reserved&);
@ -2255,6 +2261,7 @@ namespace message2 {
friend inline void swap(Pattern& p1, Pattern& p2) noexcept {
using std::swap;
swap(p1.bogus, p2.bogus);
swap(p1.len, p2.len);
swap(p1.parts, p2.parts);
}
@ -2264,7 +2271,7 @@ namespace message2 {
* @internal ICU 75.0 technology preview
* @deprecated This API is for technology preview only.
*/
Pattern(const Pattern& other) noexcept;
Pattern(const Pattern& other);
/**
* Assignment operator
*
@ -2336,6 +2343,11 @@ namespace message2 {
friend class message2::MessageFormatter;
friend class message2::Serializer;
// Set to true if a copy constructor fails;
// needed in order to distinguish an uninitialized
// Pattern from a 0-length pattern
bool bogus = false;
// Possibly-empty array of parts
int32_t len = 0;
LocalArray<PatternPart> parts;
@ -2352,7 +2364,7 @@ namespace message2 {
* @internal ICU 75.0 technology preview
* @deprecated This API is for technology preview only.
*/
int32_t numParts() const { return len; }
int32_t numParts() const;
/**
* Returns the `i`th part in the pattern.
* Precondition: i < numParts()
@ -2367,10 +2379,8 @@ namespace message2 {
// Gets around not being able to declare Pattern::Iterator as a friend
// in PatternPart
static const std::variant<UnicodeString, Expression, Markup>& patternContents(const PatternPart& p) {
return p.piece;
}
static const std::variant<UnicodeString, Expression, Markup>&
patternContents(const PatternPart& p) { return p.piece; }
}; // class Pattern
/**
@ -2622,7 +2632,7 @@ namespace message2 {
class MFDataModel;
#ifndef U_IN_DOXYGEN
class Matcher {
class Matcher : public UObject {
public:
Matcher& operator=(Matcher);
Matcher(const Matcher&);
@ -2637,24 +2647,32 @@ namespace message2 {
friend inline void swap(Matcher& m1, Matcher& m2) noexcept {
using std::swap;
if (m1.bogus) {
m2.bogus = true;
return;
}
if (m2.bogus) {
m1.bogus = true;
return;
}
swap(m1.selectors, m2.selectors);
swap(m1.numSelectors, m2.numSelectors);
swap(m1.variants, m2.variants);
swap(m1.numVariants, m2.numVariants);
}
virtual ~Matcher();
private:
friend class MFDataModel;
Matcher(Expression* ss, int32_t ns, Variant* vs, int32_t nv) : selectors(ss), numSelectors(ns), variants(vs), numVariants(nv) {
if (selectors == nullptr) {
numSelectors = 0;
}
if (variants == nullptr) {
numVariants = 0;
}
}
Matcher(Expression* ss, int32_t ns, Variant* vs, int32_t nv);
Matcher() {}
// A Matcher may have numSelectors=0 and numVariants=0
// (this is a data model error, but it's representable).
// So we have to keep a separate flag to track failed copies.
bool bogus = false;
// The expressions that are being matched on.
LocalArray<Expression> selectors;
// The number of selectors