DRAFT: MF2: fix various parser bugs and add more tests

icu4c/source/i18n/messageformat2_data_model.cpp

@@ -829,31 +829,28 @@ const Expression& Binding::getValue() const {
         } else {
             const Operator* rator = rhs.getOperator(errorCode);
             bool hasOperator = U_SUCCESS(errorCode);
-            if (hasOperator && rator->isReserved()) {
-                errorCode = U_INVALID_STATE_ERROR;
+            // Clear error code -- the "error" from the absent operator
+            // is handled
+            errorCode = U_ZERO_ERROR;
+            b = Binding(variableName, std::move(rhs));
+            b.local = false;
+            if (hasOperator) {
+                rator = b.getValue().getOperator(errorCode);
+                U_ASSERT(U_SUCCESS(errorCode));
+                b.annotation = &rator->contents;
             } else {
-                // Clear error code -- the "error" from the absent operator
-                // is handled
-                errorCode = U_ZERO_ERROR;
-                b = Binding(variableName, std::move(rhs));
-                b.local = false;
-                if (hasOperator) {
-                    rator = b.getValue().getOperator(errorCode);
-                    U_ASSERT(U_SUCCESS(errorCode));
-                    b.annotation = std::get_if<Callable>(&(rator->contents));
-                } else {
-                    b.annotation = nullptr;
-                }
-                U_ASSERT(!hasOperator || b.annotation != nullptr);
+                b.annotation = nullptr;
             }
+            U_ASSERT(!hasOperator || b.annotation != nullptr);
         }
     }
     return b;
 }
 
 const OptionMap& Binding::getOptionsInternal() const {
     U_ASSERT(annotation != nullptr);
-    return annotation->getOptions();
+    U_ASSERT(std::holds_alternative<Callable>(*annotation));
+    return std::get_if<Callable>(annotation)->getOptions();
 }
 
 void Binding::updateAnnotation() {
@@ -863,7 +860,7 @@ void Binding::updateAnnotation() {
         return;
     }
     U_ASSERT(U_SUCCESS(localErrorCode) && !rator->isReserved());
-    annotation = std::get_if<Callable>(&(rator->contents));
+    annotation = &rator->contents;
 }
 
 Binding::Binding(const Binding& other) : var(other.var), expr(other.expr), local(other.local) {

icu4c/source/i18n/messageformat2_function_registry.cpp

@@ -7,6 +7,8 @@
 
 #if !UCONFIG_NO_MF2
 
+#include <math.h>
+
 #include "unicode/dtptngen.h"
 #include "unicode/messageformat2_data_model_names.h"
 #include "unicode/messageformat2_function_registry.h"
@@ -414,25 +416,185 @@ static FormattedPlaceholder notANumber(const FormattedPlaceholder& input) {
     return FormattedPlaceholder(input, FormattedValue(UnicodeString("NaN")));
 }
 
-static FormattedPlaceholder stringAsNumber(const number::LocalizedNumberFormatter& nf, const FormattedPlaceholder& input, UErrorCode& errorCode) {
+// Returns true if `c` is in the interval [`first`, `last`]
+static bool inRange(UChar32 c, UChar32 first, UChar32 last) {
+    U_ASSERT(first < last);
+    return c >= first && c <= last;
+}
+
+static bool isDigit(UChar32 c) { return inRange(c, 0x0030, 0x0039); }
+
+static int32_t parseDigit(UChar32 c) {
+    switch(c) {
+    case DIGIT_ZERO: {
+        return 0;
+    }
+    case DIGIT_ONE: {
+        return 1;
+    }
+    case DIGIT_TWO: {
+        return 2;
+    }
+    case THREE: {
+        return 3;
+    }
+    case FOUR: {
+        return 4;
+    }
+    case FIVE: {
+        return 5;
+    }
+    case SIX: {
+        return 6;
+    }
+    case SEVEN: {
+        return 7;
+    }
+    case EIGHT: {
+        return 8;
+    }
+    case NINE: {
+        return 9;
+    }
+    default: {
+        // Should be unreachable
+        return 0;
+    }
+    }
+}
+
+static int32_t parseDigits(const UnicodeString& s, int32_t& i) {
+    int32_t firstDigit = i;
+    // Assumes that i < s.length() and s[i] is a digit
+    while (isDigit(s[i])) {
+        i++;
+    }
+    int32_t numDigits = i - firstDigit;
+    int32_t placeValue = 1;
+    int32_t result = 0;
+    for (int32_t j = firstDigit + numDigits - 1; j >= firstDigit; j--) {
+        result += placeValue * parseDigit(s[j]);
+        placeValue *= 10;
+    }
+    return result;
+}
+
+static double parseDecimalPart(const UnicodeString& s, int32_t& i) {
+    int32_t firstDigit = i;
+    // Assumes that i < s.length() and s[i] is a digit
+    while (isDigit(s[i])) {
+        i++;
+    }
+    int32_t numDigits = i - firstDigit;
+    double placeValue = 10;
+    double result = 0;
+    for (int32_t j = firstDigit; j < firstDigit + numDigits; j++) {
+        result += ((double) parseDigit(s[j])) / placeValue;
+        placeValue *= 10;
+    }
+    return result;
+}
+
+static double parseNumberLiteral(const FormattedPlaceholder& input, UErrorCode& errorCode) {
     if (U_FAILURE(errorCode)) {
         return {};
     }
 
-    double numberValue;
     // Copying string to avoid GCC dangling-reference warning
     // (although the reference is safe)
     UnicodeString inputStr = input.asFormattable().getString(errorCode);
     // Precondition: `input`'s source Formattable has type string
     if (U_FAILURE(errorCode)) {
         return {};
     }
-    UErrorCode localErrorCode = U_ZERO_ERROR;
-    strToDouble(inputStr, numberValue, localErrorCode);
-    if (U_FAILURE(localErrorCode)) {
-        errorCode = U_MF_OPERAND_MISMATCH_ERROR;
+
+    int32_t index = 0;
+
+#define ERROR() errorCode = U_MF_OPERAND_MISMATCH_ERROR; return 0;
+#define IN_BOUNDS(inputStr, index) (index < inputStr.length())
+#define CHECK_BOUNDS(inputStr, index) if (!IN_BOUNDS(inputStr, index)) { ERROR(); }
+
+    CHECK_BOUNDS(inputStr, index);
+
+    // Parse the sign if present
+    double sign = 1;
+    if (inputStr[index] == HYPHEN) {
+        sign = -1;
+        index++;
+    }
+
+    CHECK_BOUNDS(inputStr, index);
+
+    // Parse the integer part
+    if (!isDigit(inputStr[index])) {
+        // Non-numeric first character after sign -- not valid
+        ERROR();
+    }
+
+    // First, check for leading zero with no decimal point
+    if (inputStr[index] == DIGIT_ZERO) {
+        bool isZero = inputStr.length() == index + 1;
+        bool hasDecimalPart = inputStr.length() > index && inputStr[index + 1] == PERIOD;
+        if (!(isZero || hasDecimalPart)) {
+            ERROR();
+        }
+    }
+
+    double result = parseDigits(inputStr, index);
+
+    if (IN_BOUNDS(inputStr, index) && inputStr[index] == PERIOD) {
+        index++;
+        CHECK_BOUNDS(inputStr, index);
+        if (isDigit(inputStr[index])) {
+            result += parseDecimalPart(inputStr, index);
+        } else {
+            // '.' not followed by a digit is an error
+            ERROR();
+        }
+    }
+
+    result *= sign;
+
+    if (IN_BOUNDS(inputStr, index) &&
+        (inputStr[index] == UPPERCASE_E || inputStr[index] == LOWERCASE_E)) {
+        double exponent;
+        bool positive = true;
+        index++;
+        CHECK_BOUNDS(inputStr, index);
+        // Parse sign if present
+        if (inputStr[index] == PLUS) {
+            index++;
+        } else if (inputStr[index] == HYPHEN) {
+            positive = false;
+            index++;
+        }
+        // Parse exponent digits
+        CHECK_BOUNDS(inputStr, index);
+        if (!isDigit(inputStr[index])) {
+            ERROR();
+        }
+        exponent = parseDigits(inputStr, index);
+        if (positive) {
+            result *= (exponent * 10);
+        } else {
+            result *= (exponent * -10);
+        }
+    }
+
+    // Make sure entire input is consumed
+    if (index != inputStr.length()) {
+        ERROR();
+    }
+
+    return result;
+}
+
+static FormattedPlaceholder tryParsingNumberLiteral(const number::LocalizedNumberFormatter& nf, const FormattedPlaceholder& input, UErrorCode& errorCode) {
+    double numberValue = parseNumberLiteral(input, errorCode);
+    if (U_FAILURE(errorCode)) {
         return notANumber(input);
     }
+
     UErrorCode savedStatus = errorCode;
     number::FormattedNumber result = nf.formatDouble(numberValue, errorCode);
     // Ignore U_USING_DEFAULT_WARNING
@@ -583,7 +745,7 @@ FormattedPlaceholder StandardFunctions::Number::format(FormattedPlaceholder&& ar
         }
         case UFMT_STRING: {
             // Try to parse the string as a number
-            return stringAsNumber(realFormatter, arg, errorCode);
+            return tryParsingNumberLiteral(realFormatter, arg, errorCode);
         }
         default: {
             // Other types can't be parsed as a number

icu4c/source/i18n/messageformat2_macros.h

@@ -46,6 +46,17 @@ using namespace pluralimpl;
 #define LOWERCASE_E ((UChar32)0x0065)
 #define UPPERCASE_E ((UChar32)0x0045)
 
+#define DIGIT_ZERO ((UChar32)0x0030)
+#define DIGIT_ONE ((UChar32)0x0031)
+#define DIGIT_TWO ((UChar32)0x0032)
+#define THREE ((UChar32)0x0033)
+#define FOUR ((UChar32)0x0034)
+#define FIVE ((UChar32)0x0035)
+#define SIX ((UChar32)0x0036)
+#define SEVEN ((UChar32)0x0037)
+#define EIGHT ((UChar32)0x0038)
+#define NINE ((UChar32)0x0039)
+
 // Reserved sigils
 #define BANG ((UChar32)0x0021)
 #define AT ((UChar32)0x0040)