YQL-13710 try to switch to new shiny PG

ref:2bed0445c8e8bd6c575883632adf19445f0a72a7

1 files changed, 808 insertions, 0 deletions

diff --git a/contrib/libs/icu/i18n/listformatter.cpp b/contrib/libs/icu/i18n/listformatter.cpp
new file mode 100644
index 0000000000..da99c9291d
--- /dev/null
+++ b/contrib/libs/icu/i18n/listformatter.cpp
@@ -0,0 +1,808 @@
+// © 2016 and later: Unicode, Inc. and others.
+// License & terms of use: http://www.unicode.org/copyright.html
+/*
+*******************************************************************************
+*
+*   Copyright (C) 2013-2016, International Business Machines
+*   Corporation and others.  All Rights Reserved.
+*
+*******************************************************************************
+*   file name:  listformatter.cpp
+*   encoding:   UTF-8
+*   tab size:   8 (not used)
+*   indentation:4
+*
+*   created on: 2012aug27
+*   created by: Umesh P. Nair
+*/
+
+#include "cmemory.h"
+#include "unicode/fpositer.h"  // FieldPositionIterator
+#include "unicode/listformatter.h"
+#include "unicode/simpleformatter.h"
+#include "unicode/ulistformatter.h"
+#include "unicode/uscript.h"
+#include "fphdlimp.h"
+#include "mutex.h"
+#include "hash.h"
+#include "cstring.h"
+#include "uarrsort.h"
+#include "ulocimp.h"
+#include "charstr.h"
+#include "ucln_in.h"
+#include "uresimp.h"
+#include "resource.h"
+#include "formattedval_impl.h"
+
+U_NAMESPACE_BEGIN
+
+namespace {
+
+class PatternHandler : public UObject {
+public:
+    PatternHandler(const UnicodeString& two, const UnicodeString& end, UErrorCode& errorCode) :
+        twoPattern(two, 2, 2, errorCode),
+        endPattern(end, 2, 2, errorCode) {  }
+
+    PatternHandler(const SimpleFormatter& two, const SimpleFormatter& end) :
+        twoPattern(two),
+        endPattern(end) { }
+
+    virtual ~PatternHandler();
+
+    virtual PatternHandler* clone() const { return new PatternHandler(twoPattern, endPattern); }
+
+    virtual const SimpleFormatter& getTwoPattern(const UnicodeString&) const {
+        return twoPattern;
+    }
+
+    virtual const SimpleFormatter& getEndPattern(const UnicodeString&) const {
+        return endPattern;
+    }
+
+protected:
+    SimpleFormatter twoPattern;
+    SimpleFormatter endPattern;
+};
+
+PatternHandler::~PatternHandler() {
+}
+
+class ContextualHandler : public PatternHandler {
+public:
+    ContextualHandler(bool (*testFunc)(const UnicodeString& text),
+                      const UnicodeString& thenTwo,
+                      const UnicodeString& elseTwo,
+                      const UnicodeString& thenEnd,
+                      const UnicodeString& elseEnd,
+                      UErrorCode& errorCode) :
+        PatternHandler(elseTwo, elseEnd, errorCode),
+        test(testFunc),
+        thenTwoPattern(thenTwo, 2, 2, errorCode),
+        thenEndPattern(thenEnd, 2, 2, errorCode) {  }
+
+    ContextualHandler(bool (*testFunc)(const UnicodeString& text),
+                      const SimpleFormatter& thenTwo, SimpleFormatter elseTwo,
+                      const SimpleFormatter& thenEnd, SimpleFormatter elseEnd) :
+      PatternHandler(elseTwo, elseEnd),
+      test(testFunc),
+      thenTwoPattern(thenTwo),
+      thenEndPattern(thenEnd) { }
+
+    ~ContextualHandler() override;
+
+    PatternHandler* clone() const override {
+        return new ContextualHandler(
+            test, thenTwoPattern, twoPattern, thenEndPattern, endPattern);
+    }
+
+    const SimpleFormatter& getTwoPattern(
+        const UnicodeString& text) const override {
+        return (test)(text) ? thenTwoPattern : twoPattern;
+    }
+
+    const SimpleFormatter& getEndPattern(
+        const UnicodeString& text) const override {
+        return (test)(text) ? thenEndPattern : endPattern;
+    }
+
+private:
+    bool (*test)(const UnicodeString&);
+    SimpleFormatter thenTwoPattern;
+    SimpleFormatter thenEndPattern;
+};
+
+ContextualHandler::~ContextualHandler() {
+}
+
+static const char16_t *spanishY = u"{0} y {1}";
+static const char16_t *spanishE = u"{0} e {1}";
+static const char16_t *spanishO = u"{0} o {1}";
+static const char16_t *spanishU = u"{0} u {1}";
+static const char16_t *hebrewVav = u"{0} \u05D5{1}";
+static const char16_t *hebrewVavDash = u"{0} \u05D5-{1}";
+
+// Condiction to change to e.
+// Starts with "hi" or "i" but not with "hie" nor "hia"
+static bool shouldChangeToE(const UnicodeString& text) {
+    int32_t len = text.length();
+    if (len == 0) { return false; }
+    // Case insensitive match hi but not hie nor hia.
+    if ((text[0] == u'h' || text[0] == u'H') &&
+            ((len > 1) && (text[1] == u'i' || text[1] == u'I')) &&
+            ((len == 2) || !(text[2] == u'a' || text[2] == u'A' || text[2] == u'e' || text[2] == u'E'))) {
+        return true;
+    }
+    // Case insensitive for "start with i"
+    if (text[0] == u'i' || text[0] == u'I') { return true; }
+    return false;
+}
+
+// Condiction to change to u.
+// Starts with "o", "ho", and "8". Also "11" by itself.
+// re: ^((o|ho|8).*|11)$
+static bool shouldChangeToU(const UnicodeString& text) {
+    int32_t len = text.length();
+    if (len == 0) { return false; }
+    // Case insensitive match o.* and 8.*
+    if (text[0] == u'o' || text[0] == u'O' || text[0] == u'8') { return true; }
+    // Case insensitive match ho.*
+    if ((text[0] == u'h' || text[0] == u'H') &&
+            ((len > 1) && (text[1] == 'o' || text[1] == u'O'))) {
+        return true;
+    }
+    // match "^11$" and "^11 .*"
+    if ((len >= 2) && text[0] == u'1' && text[1] == u'1' && (len == 2 || text[2] == u' ')) { return true; }
+    return false;
+}
+
+// Condiction to change to VAV follow by a dash.
+// Starts with non Hebrew letter.
+static bool shouldChangeToVavDash(const UnicodeString& text) {
+    if (text.isEmpty()) { return false; }
+    UErrorCode status = U_ZERO_ERROR;
+    return uscript_getScript(text.char32At(0), &status) != USCRIPT_HEBREW;
+}
+
+PatternHandler* createPatternHandler(
+        const char* lang, const UnicodeString& two, const UnicodeString& end,
+    UErrorCode& status) {
+    if (uprv_strcmp(lang, "es") == 0) {
+        // Spanish
+        UnicodeString spanishYStr(TRUE, spanishY, -1);
+        bool twoIsY = two == spanishYStr;
+        bool endIsY = end == spanishYStr;
+        if (twoIsY || endIsY) {
+            UnicodeString replacement(TRUE, spanishE, -1);
+            return new ContextualHandler(
+                shouldChangeToE,
+                twoIsY ? replacement : two, two,
+                endIsY ? replacement : end, end, status);
+        }
+        UnicodeString spanishOStr(TRUE, spanishO, -1);
+        bool twoIsO = two == spanishOStr;
+        bool endIsO = end == spanishOStr;
+        if (twoIsO || endIsO) {
+            UnicodeString replacement(TRUE, spanishU, -1);
+            return new ContextualHandler(
+                shouldChangeToU,
+                twoIsO ? replacement : two, two,
+                endIsO ? replacement : end, end, status);
+        }
+    } else if (uprv_strcmp(lang, "he") == 0 || uprv_strcmp(lang, "iw") == 0) {
+        // Hebrew
+        UnicodeString hebrewVavStr(TRUE, hebrewVav, -1);
+        bool twoIsVav = two == hebrewVavStr;
+        bool endIsVav = end == hebrewVavStr;
+        if (twoIsVav || endIsVav) {
+            UnicodeString replacement(TRUE, hebrewVavDash, -1);
+            return new ContextualHandler(
+                shouldChangeToVavDash,
+                twoIsVav ? replacement : two, two,
+                endIsVav ? replacement : end, end, status);
+        }
+    }
+    return new PatternHandler(two, end, status);
+}
+
+}  // namespace
+
+struct ListFormatInternal : public UMemory {
+    SimpleFormatter startPattern;
+    SimpleFormatter middlePattern;
+    LocalPointer<PatternHandler> patternHandler;
+
+ListFormatInternal(
+        const UnicodeString& two,
+        const UnicodeString& start,
+        const UnicodeString& middle,
+        const UnicodeString& end,
+        const Locale& locale,
+        UErrorCode &errorCode) :
+        startPattern(start, 2, 2, errorCode),
+        middlePattern(middle, 2, 2, errorCode),
+        patternHandler(createPatternHandler(locale.getLanguage(), two, end, errorCode), errorCode) { }
+
+ListFormatInternal(const ListFormatData &data, UErrorCode &errorCode) :
+        startPattern(data.startPattern, errorCode),
+        middlePattern(data.middlePattern, errorCode),
+        patternHandler(createPatternHandler(
+            data.locale.getLanguage(), data.twoPattern, data.endPattern, errorCode), errorCode) { }
+
+ListFormatInternal(const ListFormatInternal &other) :
+    startPattern(other.startPattern),
+    middlePattern(other.middlePattern),
+    patternHandler(other.patternHandler->clone()) { }
+};
+
+
+#if !UCONFIG_NO_FORMATTING
+class FormattedListData : public FormattedValueFieldPositionIteratorImpl {
+public:
+    FormattedListData(UErrorCode& status) : FormattedValueFieldPositionIteratorImpl(5, status) {}
+    virtual ~FormattedListData();
+};
+
+FormattedListData::~FormattedListData() = default;
+
+UPRV_FORMATTED_VALUE_SUBCLASS_AUTO_IMPL(FormattedList)
+#endif
+
+
+static Hashtable* listPatternHash = nullptr;
+
+U_CDECL_BEGIN
+static UBool U_CALLCONV uprv_listformatter_cleanup() {
+    delete listPatternHash;
+    listPatternHash = nullptr;
+    return TRUE;
+}
+
+static void U_CALLCONV
+uprv_deleteListFormatInternal(void *obj) {
+    delete static_cast<ListFormatInternal *>(obj);
+}
+
+U_CDECL_END
+
+ListFormatter::ListFormatter(const ListFormatter& other) :
+        owned(other.owned), data(other.data) {
+    if (other.owned != nullptr) {
+        owned = new ListFormatInternal(*other.owned);
+        data = owned;
+    }
+}
+
+ListFormatter& ListFormatter::operator=(const ListFormatter& other) {
+    if (this == &other) {
+        return *this;
+    }
+    delete owned;
+    if (other.owned) {
+        owned = new ListFormatInternal(*other.owned);
+        data = owned;
+    } else {
+        owned = nullptr;
+        data = other.data;
+    }
+    return *this;
+}
+
+void ListFormatter::initializeHash(UErrorCode& errorCode) {
+    if (U_FAILURE(errorCode)) {
+        return;
+    }
+
+    listPatternHash = new Hashtable();
+    if (listPatternHash == nullptr) {
+        errorCode = U_MEMORY_ALLOCATION_ERROR;
+        return;
+    }
+
+    listPatternHash->setValueDeleter(uprv_deleteListFormatInternal);
+    ucln_i18n_registerCleanup(UCLN_I18N_LIST_FORMATTER, uprv_listformatter_cleanup);
+
+}
+
+const ListFormatInternal* ListFormatter::getListFormatInternal(
+        const Locale& locale, const char *style, UErrorCode& errorCode) {
+    if (U_FAILURE(errorCode)) {
+        return nullptr;
+    }
+    CharString keyBuffer(locale.getName(), errorCode);
+    keyBuffer.append(':', errorCode).append(style, errorCode);
+    UnicodeString key(keyBuffer.data(), -1, US_INV);
+    ListFormatInternal* result = nullptr;
+    static UMutex listFormatterMutex;
+    {
+        Mutex m(&listFormatterMutex);
+        if (listPatternHash == nullptr) {
+            initializeHash(errorCode);
+            if (U_FAILURE(errorCode)) {
+                return nullptr;
+            }
+        }
+        result = static_cast<ListFormatInternal*>(listPatternHash->get(key));
+    }
+    if (result != nullptr) {
+        return result;
+    }
+    result = loadListFormatInternal(locale, style, errorCode);
+    if (U_FAILURE(errorCode)) {
+        return nullptr;
+    }
+
+    {
+        Mutex m(&listFormatterMutex);
+        ListFormatInternal* temp = static_cast<ListFormatInternal*>(listPatternHash->get(key));
+        if (temp != nullptr) {
+            delete result;
+            result = temp;
+        } else {
+            listPatternHash->put(key, result, errorCode);
+            if (U_FAILURE(errorCode)) {
+                return nullptr;
+            }
+        }
+    }
+    return result;
+}
+
+#if !UCONFIG_NO_FORMATTING
+static const char* typeWidthToStyleString(UListFormatterType type, UListFormatterWidth width) {
+    switch (type) {
+        case ULISTFMT_TYPE_AND:
+            switch (width) {
+                case ULISTFMT_WIDTH_WIDE:
+                    return "standard";
+                case ULISTFMT_WIDTH_SHORT:
+                    return "standard-short";
+                case ULISTFMT_WIDTH_NARROW:
+                    return "standard-narrow";
+                default:
+                    return nullptr;
+            }
+            break;
+
+        case ULISTFMT_TYPE_OR:
+            switch (width) {
+                case ULISTFMT_WIDTH_WIDE:
+                    return "or";
+                case ULISTFMT_WIDTH_SHORT:
+                    return "or-short";
+                case ULISTFMT_WIDTH_NARROW:
+                    return "or-narrow";
+                default:
+                    return nullptr;
+            }
+            break;
+
+        case ULISTFMT_TYPE_UNITS:
+            switch (width) {
+                case ULISTFMT_WIDTH_WIDE:
+                    return "unit";
+                case ULISTFMT_WIDTH_SHORT:
+                    return "unit-short";
+                case ULISTFMT_WIDTH_NARROW:
+                    return "unit-narrow";
+                default:
+                    return nullptr;
+            }
+    }
+
+    return nullptr;
+}
+#endif
+
+static const UChar solidus = 0x2F;
+static const UChar aliasPrefix[] = { 0x6C,0x69,0x73,0x74,0x50,0x61,0x74,0x74,0x65,0x72,0x6E,0x2F }; // "listPattern/"
+enum {
+    kAliasPrefixLen = UPRV_LENGTHOF(aliasPrefix),
+    kStyleLenMax = 24 // longest currently is 14
+};
+
+struct ListFormatter::ListPatternsSink : public ResourceSink {
+    UnicodeString two, start, middle, end;
+#if ((U_PLATFORM == U_PF_AIX) || (U_PLATFORM == U_PF_OS390)) && (U_CPLUSPLUS_VERSION < 11)
+    char aliasedStyle[kStyleLenMax+1];
+    ListPatternsSink() {
+      uprv_memset(aliasedStyle, 0, kStyleLenMax+1);
+    }
+#else
+    char aliasedStyle[kStyleLenMax+1] = {0};
+
+    ListPatternsSink() {}
+#endif
+    virtual ~ListPatternsSink();
+
+    void setAliasedStyle(UnicodeString alias) {
+        int32_t startIndex = alias.indexOf(aliasPrefix, kAliasPrefixLen, 0);
+        if (startIndex < 0) {
+            return;
+        }
+        startIndex += kAliasPrefixLen;
+        int32_t endIndex = alias.indexOf(solidus, startIndex);
+        if (endIndex < 0) {
+            endIndex = alias.length();
+        }
+        alias.extract(startIndex, endIndex-startIndex, aliasedStyle, kStyleLenMax+1, US_INV);
+        aliasedStyle[kStyleLenMax] = 0;
+    }
+
+    void handleValueForPattern(ResourceValue &value, UnicodeString &pattern, UErrorCode &errorCode) {
+        if (pattern.isEmpty()) {
+            if (value.getType() == URES_ALIAS) {
+                if (aliasedStyle[0] == 0) {
+                    setAliasedStyle(value.getAliasUnicodeString(errorCode));
+                }
+            } else {
+                pattern = value.getUnicodeString(errorCode);
+            }
+        }
+    }
+
+    virtual void put(const char *key, ResourceValue &value, UBool /*noFallback*/,
+            UErrorCode &errorCode) {
+        aliasedStyle[0] = 0;
+        if (value.getType() == URES_ALIAS) {
+            setAliasedStyle(value.getAliasUnicodeString(errorCode));
+            return;
+        }
+        ResourceTable listPatterns = value.getTable(errorCode);
+        for (int i = 0; U_SUCCESS(errorCode) && listPatterns.getKeyAndValue(i, key, value); ++i) {
+            if (uprv_strcmp(key, "2") == 0) {
+                handleValueForPattern(value, two, errorCode);
+            } else if (uprv_strcmp(key, "end") == 0) {
+                handleValueForPattern(value, end, errorCode);
+            } else if (uprv_strcmp(key, "middle") == 0) {
+                handleValueForPattern(value, middle, errorCode);
+            } else if (uprv_strcmp(key, "start") == 0) {
+                handleValueForPattern(value, start, errorCode);
+            }
+        }
+    }
+};
+
+// Virtual destructors must be defined out of line.
+ListFormatter::ListPatternsSink::~ListPatternsSink() {}
+
+ListFormatInternal* ListFormatter::loadListFormatInternal(
+        const Locale& locale, const char * style, UErrorCode& errorCode) {
+    UResourceBundle* rb = ures_open(nullptr, locale.getName(), &errorCode);
+    rb = ures_getByKeyWithFallback(rb, "listPattern", rb, &errorCode);
+    if (U_FAILURE(errorCode)) {
+        ures_close(rb);
+        return nullptr;
+    }
+    ListFormatter::ListPatternsSink sink;
+    char currentStyle[kStyleLenMax+1];
+    uprv_strncpy(currentStyle, style, kStyleLenMax);
+    currentStyle[kStyleLenMax] = 0;
+
+    for (;;) {
+        ures_getAllItemsWithFallback(rb, currentStyle, sink, errorCode);
+        if (U_FAILURE(errorCode) || sink.aliasedStyle[0] == 0 || uprv_strcmp(currentStyle, sink.aliasedStyle) == 0) {
+            break;
+        }
+        uprv_strcpy(currentStyle, sink.aliasedStyle);
+    }
+    ures_close(rb);
+    if (U_FAILURE(errorCode)) {
+        return nullptr;
+    }
+    if (sink.two.isEmpty() || sink.start.isEmpty() || sink.middle.isEmpty() || sink.end.isEmpty()) {
+        errorCode = U_MISSING_RESOURCE_ERROR;
+        return nullptr;
+    }
+
+    ListFormatInternal* result = new ListFormatInternal(sink.two, sink.start, sink.middle, sink.end, locale, errorCode);
+    if (result == nullptr) {
+        errorCode = U_MEMORY_ALLOCATION_ERROR;
+        return nullptr;
+    }
+    if (U_FAILURE(errorCode)) {
+        delete result;
+        return nullptr;
+    }
+    return result;
+}
+
+ListFormatter* ListFormatter::createInstance(UErrorCode& errorCode) {
+    Locale locale;  // The default locale.
+    return createInstance(locale, errorCode);
+}
+
+ListFormatter* ListFormatter::createInstance(const Locale& locale, UErrorCode& errorCode) {
+#if !UCONFIG_NO_FORMATTING
+    return createInstance(locale, ULISTFMT_TYPE_AND, ULISTFMT_WIDTH_WIDE, errorCode);
+#else
+    return createInstance(locale, "standard", errorCode);
+#endif
+}
+
+#if !UCONFIG_NO_FORMATTING
+ListFormatter* ListFormatter::createInstance(
+        const Locale& locale, UListFormatterType type, UListFormatterWidth width, UErrorCode& errorCode) {
+    const char* style = typeWidthToStyleString(type, width);
+    if (style == nullptr) {
+        errorCode = U_ILLEGAL_ARGUMENT_ERROR;
+        return nullptr;
+    }
+    return createInstance(locale, style, errorCode);
+}
+#endif
+
+ListFormatter* ListFormatter::createInstance(const Locale& locale, const char *style, UErrorCode& errorCode) {
+    const ListFormatInternal* listFormatInternal = getListFormatInternal(locale, style, errorCode);
+    if (U_FAILURE(errorCode)) {
+        return nullptr;
+    }
+    ListFormatter* p = new ListFormatter(listFormatInternal);
+    if (p == nullptr) {
+        errorCode = U_MEMORY_ALLOCATION_ERROR;
+        return nullptr;
+    }
+    return p;
+}
+
+ListFormatter::ListFormatter(const ListFormatData& listFormatData, UErrorCode &errorCode) {
+    owned = new ListFormatInternal(listFormatData, errorCode);
+    data = owned;
+}
+
+ListFormatter::ListFormatter(const ListFormatInternal* listFormatterInternal) : owned(nullptr), data(listFormatterInternal) {
+}
+
+ListFormatter::~ListFormatter() {
+    delete owned;
+}
+
+/**
+ * Joins first and second using the pattern pat.
+ * On entry offset is an offset into first or -1 if offset unspecified.
+ * On exit offset is offset of second in result if recordOffset was set
+ * Otherwise if it was >=0 it is set to point into result where it used
+ * to point into first. On exit, result is the join of first and second
+ * according to pat. Any previous value of result gets replaced.
+ */
+static void joinStringsAndReplace(
+        const SimpleFormatter& pat,
+        const UnicodeString& first,
+        const UnicodeString& second,
+        UnicodeString &result,
+        UBool recordOffset,
+        int32_t &offset,
+        int32_t *offsetFirst,
+        int32_t *offsetSecond,
+        UErrorCode& errorCode) {
+    if (U_FAILURE(errorCode)) {
+        return;
+    }
+    const UnicodeString *params[2] = {&first, &second};
+    int32_t offsets[2];
+    pat.formatAndReplace(
+            params,
+            UPRV_LENGTHOF(params),
+            result,
+            offsets,
+            UPRV_LENGTHOF(offsets),
+            errorCode);
+    if (U_FAILURE(errorCode)) {
+        return;
+    }
+    if (offsets[0] == -1 || offsets[1] == -1) {
+        errorCode = U_INVALID_FORMAT_ERROR;
+        return;
+    }
+    if (recordOffset) {
+        offset = offsets[1];
+    } else if (offset >= 0) {
+        offset += offsets[0];
+    }
+    if (offsetFirst != nullptr) *offsetFirst = offsets[0];
+    if (offsetSecond != nullptr) *offsetSecond = offsets[1];
+}
+
+UnicodeString& ListFormatter::format(
+        const UnicodeString items[],
+        int32_t nItems,
+        UnicodeString& appendTo,
+        UErrorCode& errorCode) const {
+    int32_t offset;
+    return format(items, nItems, appendTo, -1, offset, errorCode);
+}
+
+UnicodeString& ListFormatter::format(
+        const UnicodeString items[],
+        int32_t nItems,
+        UnicodeString& appendTo,
+        int32_t index,
+        int32_t &offset,
+        UErrorCode& errorCode) const {
+  return format_(items, nItems, appendTo, index, offset, nullptr, errorCode);
+}
+
+#if !UCONFIG_NO_FORMATTING
+FormattedList ListFormatter::formatStringsToValue(
+        const UnicodeString items[],
+        int32_t nItems,
+        UErrorCode& errorCode) const {
+    LocalPointer<FormattedListData> result(new FormattedListData(errorCode), errorCode);
+    if (U_FAILURE(errorCode)) {
+        return FormattedList(errorCode);
+    }
+    UnicodeString string;
+    int32_t offset;
+    auto handler = result->getHandler(errorCode);
+    handler.setCategory(UFIELD_CATEGORY_LIST);
+    format_(items, nItems, string, -1, offset, &handler, errorCode);
+    handler.getError(errorCode);
+    result->appendString(string, errorCode);
+    if (U_FAILURE(errorCode)) {
+        return FormattedList(errorCode);
+    }
+
+    // Add span fields and sort
+    ConstrainedFieldPosition cfpos;
+    cfpos.constrainField(UFIELD_CATEGORY_LIST, ULISTFMT_ELEMENT_FIELD);
+    int32_t i = 0;
+    handler.setCategory(UFIELD_CATEGORY_LIST_SPAN);
+    while (result->nextPosition(cfpos, errorCode)) {
+        handler.addAttribute(i++, cfpos.getStart(), cfpos.getLimit());
+    }
+    handler.getError(errorCode);
+    if (U_FAILURE(errorCode)) {
+        return FormattedList(errorCode);
+    }
+    result->sort();
+
+    return FormattedList(result.orphan());
+}
+#endif
+
+UnicodeString& ListFormatter::format_(
+        const UnicodeString items[],
+        int32_t nItems,
+        UnicodeString& appendTo,
+        int32_t index,
+        int32_t &offset,
+        FieldPositionHandler* handler,
+        UErrorCode& errorCode) const {
+#if !UCONFIG_NO_FORMATTING
+    offset = -1;
+    if (U_FAILURE(errorCode)) {
+        return appendTo;
+    }
+    if (data == nullptr) {
+        errorCode = U_INVALID_STATE_ERROR;
+        return appendTo;
+    }
+
+    if (nItems <= 0) {
+        return appendTo;
+    }
+    if (nItems == 1) {
+        if (index == 0) {
+            offset = appendTo.length();
+        }
+        if (handler != nullptr) {
+            handler->addAttribute(ULISTFMT_ELEMENT_FIELD,
+                                  appendTo.length(),
+                                  appendTo.length() + items[0].length());
+        }
+        appendTo.append(items[0]);
+        return appendTo;
+    }
+    UnicodeString result(items[0]);
+    if (index == 0) {
+        offset = 0;
+    }
+    int32_t offsetFirst = 0;
+    int32_t offsetSecond = 0;
+    int32_t prefixLength = 0;
+    // for n items, there are 2 * (n + 1) boundary including 0 and the upper
+    // edge.
+    MaybeStackArray<int32_t, 10> offsets((handler != nullptr) ? 2 * (nItems + 1): 0);
+    if (nItems == 2) {
+        joinStringsAndReplace(
+                data->patternHandler->getTwoPattern(items[1]),
+                result,
+                items[1],
+                result,
+                index == 1,
+                offset,
+                &offsetFirst,
+                &offsetSecond,
+                errorCode);
+    } else {
+        joinStringsAndReplace(
+                data->startPattern,
+                result,
+                items[1],
+                result,
+                index == 1,
+                offset,
+                &offsetFirst,
+                &offsetSecond,
+                errorCode);
+    }
+    if (handler != nullptr) {
+        offsets[0] = 0;
+        prefixLength += offsetFirst;
+        offsets[1] = offsetSecond - prefixLength;
+    }
+    if (nItems > 2) {
+        for (int32_t i = 2; i < nItems - 1; ++i) {
+             joinStringsAndReplace(
+                     data->middlePattern,
+                     result,
+                     items[i],
+                     result,
+                     index == i,
+                     offset,
+                     &offsetFirst,
+                     &offsetSecond,
+                     errorCode);
+            if (handler != nullptr) {
+                prefixLength += offsetFirst;
+                offsets[i] = offsetSecond - prefixLength;
+            }
+        }
+        joinStringsAndReplace(
+                data->patternHandler->getEndPattern(items[nItems - 1]),
+                result,
+                items[nItems - 1],
+                result,
+                index == nItems - 1,
+                offset,
+                &offsetFirst,
+                &offsetSecond,
+                errorCode);
+        if (handler != nullptr) {
+            prefixLength += offsetFirst;
+            offsets[nItems - 1] = offsetSecond - prefixLength;
+        }
+    }
+    if (handler != nullptr) {
+        // If there are already some data in appendTo, we need to adjust the index
+        // by shifting that lenght while insert into handler.
+        int32_t shift = appendTo.length() + prefixLength;
+        // Output the ULISTFMT_ELEMENT_FIELD in the order of the input elements
+        for (int32_t i = 0; i < nItems; ++i) {
+            offsets[i + nItems] = offsets[i] + items[i].length() + shift;
+            offsets[i] += shift;
+            handler->addAttribute(
+                ULISTFMT_ELEMENT_FIELD,  // id
+                offsets[i],  // index
+                offsets[i + nItems]);  // limit
+        }
+        // The locale pattern may reorder the items (such as in ur-IN locale),
+        // so we cannot assume the array is in accendning order.
+        // To handle the edging case, just insert the two ends into the array
+        // and sort. Then we output ULISTFMT_LITERAL_FIELD if the indecies
+        // between the even and odd position are not the same in the sorted array.
+        offsets[2 * nItems] = shift - prefixLength;
+        offsets[2 * nItems + 1] = result.length() + shift - prefixLength;
+        uprv_sortArray(offsets.getAlias(), 2 * (nItems + 1), sizeof(int32_t),
+               uprv_int32Comparator, nullptr,
+               false, &errorCode);
+        for (int32_t i = 0; i <= nItems; ++i) {
+          if (offsets[i * 2] != offsets[i * 2 + 1]) {
+            handler->addAttribute(
+                ULISTFMT_LITERAL_FIELD,  // id
+                offsets[i * 2],  // index
+                offsets[i * 2 + 1]);  // limit
+          }
+        }
+    }
+    if (U_SUCCESS(errorCode)) {
+        if (offset >= 0) {
+            offset += appendTo.length();
+        }
+        appendTo += result;
+    }
+#endif  
+    return appendTo;
+}
+ 
+U_NAMESPACE_END