Function context and u:options

Author: catamorphism

icu4c/source/i18n/messageformat2.cpp

@@ -11,6 +11,7 @@
 #include "unicode/messageformat2_data_model.h"
 #include "unicode/messageformat2_formattable.h"
 #include "unicode/messageformat2.h"
+#include "unicode/ubidi.h"
 #include "unicode/unistr.h"
 #include "messageformat2_allocation.h"
 #include "messageformat2_evaluation.h"
@@ -153,6 +154,48 @@ FunctionOptions MessageFormatter::resolveOptions(const Environment& env,
     return FunctionOptions(std::move(*optionsVector), status);
 }
 
+static UBiDiDirection getBiDiDirection(const Locale& locale,
+                                       const UnicodeString& s) {
+    if (s.isEmpty()) {
+        return locale.isRightToLeft() ? UBIDI_RTL : UBIDI_LTR;
+    }
+    if (s == u"ltr") {
+        return UBIDI_LTR;
+    }
+    if (s == u"rtl") {
+        return UBIDI_RTL;
+    }
+    if (s == u"auto") {
+        return UBIDI_MIXED;
+    }
+    return UBIDI_NEUTRAL;
+}
+
+FunctionContext MessageFormatter::makeFunctionContext(const FunctionOptions& options) const {
+    // Look up "u:locale", "u:dir", and "u:id" in the options
+    UnicodeString localeStr = options.getStringFunctionOption(UnicodeString("u:locale"));
+
+    // Use default locale from context, unless "u:locale" is provided
+    Locale localeToUse;
+    if (localeStr.isEmpty()) {
+        localeToUse = locale;
+    } else {
+        UErrorCode localStatus = U_ZERO_ERROR;
+        std::string u8;
+        Locale l = Locale::forLanguageTag(localeStr.toUTF8String(u8), localStatus);
+        if (U_SUCCESS(localStatus)) {
+            localeToUse = l;
+        } else {
+            localeToUse = locale;
+        }
+    }
+    UBiDiDirection dir = getBiDiDirection(localeToUse,
+                                          options.getStringFunctionOption(UnicodeString("u:dir")));
+    UnicodeString id = options.getStringFunctionOption(UnicodeString("u:id"));
+
+    return FunctionContext(localeToUse, dir, id);
+}
+
 // Looks up `functionName` and applies it to an operand and options,
 // handling errors if the function is unbound
 [[nodiscard]] InternalValue MessageFormatter::apply(const FunctionName& functionName,
@@ -180,13 +223,16 @@ FunctionOptions MessageFormatter::resolveOptions(const Environment& env,
         context.getErrors().setUnknownFunction(functionName, status);
         return InternalValue::fallback(fallbackStr);
     }
-    LocalPointer<Function> function(functionFactory->createFunction(locale, status));
+    LocalPointer<Function> function(functionFactory->createFunction(status));
     // Value is not a fallback, so we can safely call takeValue()
     LocalPointer<FunctionValue> functionArg(rand.takeValue(status));
     U_ASSERT(U_SUCCESS(status));
     // Call the function
     LocalPointer<FunctionValue>
-        functionResult(function->call(*functionArg, std::move(options), status));
+        functionResult(function->call(makeFunctionContext(options),
+                                      *functionArg,
+                                      std::move(options),
+                                      status));
     // Handle any errors signaled by the function
     // (and use the fallback value)
     if (status == U_MF_OPERAND_MISMATCH_ERROR) {

icu4c/source/i18n/messageformat2_evaluation.cpp

@@ -7,6 +7,7 @@
 
 #if !UCONFIG_NO_MF2
 
+#include "unicode/ubidi.h"
 #include "messageformat2_allocation.h"
 #include "messageformat2_evaluation.h"
 #include "messageformat2_macros.h"
@@ -34,10 +35,13 @@ BaseValue::BaseValue(const Locale& loc, const Formattable& source)
     return message2::create<BaseValue>(BaseValue(locale, source), errorCode);
 }
 
-extern UnicodeString formattableToString(const Locale&, const Formattable&, UErrorCode&);
+extern UnicodeString formattableToString(const Locale&, const UBiDiDirection, const Formattable&, UErrorCode&);
 
 UnicodeString BaseValue::formatToString(UErrorCode& errorCode) const {
-    return formattableToString(locale, operand, errorCode);
+    return formattableToString(locale,
+                               UBIDI_NEUTRAL,
+                               operand,
+                               errorCode);
 }
 
 BaseValue& BaseValue::operator=(BaseValue&& other) noexcept {

icu4c/source/i18n/messageformat2_formattable.cpp

@@ -9,8 +9,10 @@
 
 #include "unicode/messageformat2_formattable.h"
 #include "unicode/smpdtfmt.h"
+#include "unicode/ubidi.h"
 #include "messageformat2_allocation.h"
 #include "messageformat2_macros.h"
+#include "ubidiimp.h"
 
 #include "limits.h"
 
@@ -184,9 +186,37 @@ namespace message2 {
         df->format(date, result, 0, errorCode);
     }
 
+    static UnicodeString& handleBiDi(const Locale& locale,
+                                     UBiDiDirection dir,
+                                     UnicodeString& result) {
+        switch (dir) {
+        case UBIDI_LTR:
+            if (locale.isRightToLeft()) {
+                result.insert(0, LRI_CHAR);
+                result.insert(result.length(), PDI_CHAR);
+            }
+            break;
+        case UBIDI_RTL:
+            result.insert(0, RLI_CHAR);
+            result.insert(result.length(), PDI_CHAR);
+            break;
+        case UBIDI_NEUTRAL:
+            // Do nothing
+            break;
+        case UBIDI_MIXED:
+            // mixed = auto
+            result.insert(0, FSI_CHAR);
+            result.insert(result.length(), PDI_CHAR);
+            break;
+        }
+
+        return result;
+    }
+
     UnicodeString formattableToString(const Locale& locale,
-                                             const Formattable& toFormat,
-                                             UErrorCode& status) {
+                                      UBiDiDirection dir,
+                                      const Formattable& toFormat,
+                                      UErrorCode& status) {
         EMPTY_ON_ERROR(status);
 
         // Try as decimal number first
@@ -205,33 +235,37 @@ namespace message2 {
         }
 
         UFormattableType type = toFormat.getType();
+        UnicodeString result;
+
         switch (type) {
         case UFMT_DATE: {
-            UnicodeString result;
             UDate d = toFormat.getDate(status);
             U_ASSERT(U_SUCCESS(status));
             formatDateWithDefaults(locale, d, result, status);
-            return result;
+            break;
         }
         case UFMT_DOUBLE: {
             double d = toFormat.getDouble(status);
             U_ASSERT(U_SUCCESS(status));
-            return formatNumberWithDefaults(locale, d, status).toString(status);
+            result = formatNumberWithDefaults(locale, d, status).toString(status);
+            break;
         }
         case UFMT_LONG: {
             int32_t l = toFormat.getLong(status);
             U_ASSERT(U_SUCCESS(status));
-            return formatNumberWithDefaults(locale, l, status).toString(status);
+            result = formatNumberWithDefaults(locale, l, status).toString(status);
+            break;
         }
         case UFMT_INT64: {
             int64_t i = toFormat.getInt64Value(status);
             U_ASSERT(U_SUCCESS(status));
-            return formatNumberWithDefaults(locale, i, status).toString(status);
+            result = formatNumberWithDefaults(locale, i, status).toString(status);
+            break;
         }
         case UFMT_STRING: {
-            const UnicodeString& s = toFormat.getString(status);
+            result = toFormat.getString(status);
             U_ASSERT(U_SUCCESS(status));
-            return s;
+            break;
         }
         default: {
             // No default formatters for other types; use fallback
@@ -242,6 +276,8 @@ namespace message2 {
             return {};
         }
         }
+
+        return handleBiDi(locale, dir, result);
     }
 
 } // namespace message2