Changeset 281688 in webkit

Timestamp:

Aug 27, 2021, 12:15:06 AM (3 years ago)

Author:

[email protected]

Message:

Intl.DateTimeFormat incorrectly parses patterns with 'h' literal
​https://bugs.webkit.org/show_bug.cgi?id=229313
rdar://82414310

Reviewed by Ross Kirsling.

JSTests:

• stress/intl-date-pattern-includes-literal-text.js: Added.

(shouldBe):

Source/JavaScriptCore:

While DateTimeFormat pattern and skeleton can include single-quoted literal texts,
we are not respecting that when parsing them to extract information. As a result,
we are incorrectly extracting hour-cycle information for "fr" locale since it can
include "HH 'h'" pattern text. This patch fixes that by skipping literal text
correctly.

• runtime/IntlDateTimeFormat.cpp:

(JSC::skipLiteralText):
(JSC::IntlDateTimeFormat::setFormatsFromPattern):
(JSC::IntlDateTimeFormat::hourCycleFromPattern):
(JSC::IntlDateTimeFormat::replaceHourCycleInSkeleton):
(JSC::IntlDateTimeFormat::replaceHourCycleInPattern):

• runtime/IntlDateTimeFormat.h:
• runtime/IntlLocale.cpp:

(JSC::IntlLocale::hourCycles):

Location:

trunk

Files:

• JSTests/ChangeLog (modified) (1 diff)
• JSTests/stress/intl-date-pattern-includes-literal-text.js (added)
• Source/JavaScriptCore/ChangeLog (modified) (1 diff)
• Source/JavaScriptCore/runtime/IntlDateTimeFormat.cpp (modified) (4 diffs)
• Source/JavaScriptCore/runtime/IntlDateTimeFormat.h (modified) (3 diffs)
• Source/JavaScriptCore/runtime/IntlLocale.cpp (modified) (3 diffs)

trunk/JSTests/ChangeLog

@@ +1 @@
+2021-08-26  Yusuke Suzuki  <[email protected]>
+
+        Intl.DateTimeFormat incorrectly parses patterns with 'h' literal
+        https://bugs.webkit.org/show_bug.cgi?id=229313
+        rdar://82414310
+
+        Reviewed by Ross Kirsling.
+
+        * stress/intl-date-pattern-includes-literal-text.js: Added.
+        (shouldBe):
+
 2021-08-26  Yusuke Suzuki  <[email protected]>
 

trunk/Source/JavaScriptCore/ChangeLog

@@ +1 @@
+2021-08-26  Yusuke Suzuki  <[email protected]>
+
+        Intl.DateTimeFormat incorrectly parses patterns with 'h' literal
+        https://bugs.webkit.org/show_bug.cgi?id=229313
+        rdar://82414310
+
+        Reviewed by Ross Kirsling.
+
+        While DateTimeFormat pattern and skeleton can include single-quoted literal texts,
+        we are not respecting that when parsing them to extract information. As a result,
+        we are incorrectly extracting hour-cycle information for "fr" locale since it can
+        include "HH 'h'" pattern text. This patch fixes that by skipping literal text
+        correctly.
+
+        * runtime/IntlDateTimeFormat.cpp:
+        (JSC::skipLiteralText):
+        (JSC::IntlDateTimeFormat::setFormatsFromPattern):
+        (JSC::IntlDateTimeFormat::hourCycleFromPattern):
+        (JSC::IntlDateTimeFormat::replaceHourCycleInSkeleton):
+        (JSC::IntlDateTimeFormat::replaceHourCycleInPattern):
+        * runtime/IntlDateTimeFormat.h:
+        * runtime/IntlLocale.cpp:
+        (JSC::IntlLocale::hourCycles):
+
 2021-08-26  Yusuke Suzuki  <[email protected]>
 

trunk/Source/JavaScriptCore/runtime/IntlDateTimeFormat.cpp

@@ -307 +307 @@
 }
 
+template<typename Container>
+static inline unsigned skipLiteralText(const Container& container, unsigned start, unsigned length)
+{
+    // Skip literal text. We do not recognize '' single quote specially.
+    // `'ICU''s change'` is `ICU's change` literal text, but even if we split this text into two literal texts,
+    // we can anyway skip the same thing.
+    // This function returns the last character index which can be considered as a literal text.
+    ASSERT(length);
+    ASSERT(start < length);
+    ASSERT(container[start] == '\'');
+    unsigned index = start;
+      index;
+    if (!(index < length))
+        return length - 1;
+    for (; index < length;   index) {
+        if (container[index] == '\'')
+            return index;
+    }
+    return length - 1;
+}
+
 void IntlDateTimeFormat::setFormatsFromPattern(const StringView& pattern)
 {
     // Get all symbols from the pattern, and set format fields accordingly.
     // http://unicode.org/reports/tr35/tr35-dates.html#Date_Field_Symbol_Table
+    //
+    // A date pattern is a character string consisting of two types of elements:
+    // 1. Pattern fields, which repeat a specific pattern character one or more times.
+    //    These fields are replaced with date and time data from a calendar when formatting,
+    //    or used to generate data for a calendar when parsing. Currently, A..Z and a..z are
+    //    reserved for use as pattern characters (unless they are quoted, see next item).
+    //    The pattern characters currently defined, and the meaning of different fields
+    //    lengths for then, are listed in the Date Field Symbol Table below.
+    // 2. Literal text, which is output as-is when formatting, and must closely match when
+    //    parsing. Literal text can include:
+    //      1. Any characters other than A..Z and a..z, including spaces and punctuation.
+    //      2. Any text between single vertical quotes ('xxxx'), which may include A..Z and
+    //         a..z as literal text.
+    //      3. Two adjacent single vertical quotes (''), which represent a literal single quote,
+    //         either inside or outside quoted text.
     unsigned length = pattern.length();
     for (unsigned i = 0; i < length;   i) {
-        UChar currentCharacter = pattern[i];
+        auto currentCharacter = pattern[i];
+
+        if (currentCharacter == '\'') {
+            i = skipLiteralText(pattern, i, length);
+            continue;
+        }
+
         if (!isASCIIAlpha(currentCharacter))
             continue;
@@ -461 +503 @@
 }
 
-inline IntlDateTimeFormat::HourCycle IntlDateTimeFormat::hourCycleFromPattern(const Vector<UChar, 32>& pattern)
-{
-    for (auto character : pattern) {
+IntlDateTimeFormat::HourCycle IntlDateTimeFormat::hourCycleFromPattern(const Vector<UChar, 32>& pattern)
+{
+    for (unsigned i = 0, length = pattern.size(); i < length;   i) {
+        auto character = pattern[i];
+
+        if (character == '\'') {
+            i = skipLiteralText(pattern, i, length);
+            continue;
+        }
+
         switch (character) {
         case 'K':
@@ -480 +529 @@
     if (isHour12)
         skeletonCharacter = 'h';
-    for (auto& character : skeleton) {
+    for (unsigned i = 0, length = skeleton.size(); i < length;   i) {
+        auto& character = skeleton[i];
+
+        // ICU DateTimeFormat skeleton also has single-quoted literal text.
+        // https://github.com/unicode-org/icu/blob/main/icu4c/source/i18n/dtptngen.cpp
+        if (character == '\'') {
+            i = skipLiteralText(skeleton, i, length);
+            continue;
+        }
+
         switch (character) {
         case 'h':
@@ -511 +569 @@
     }
 
-    for (auto& character : pattern) {
+    for (unsigned i = 0, length = pattern.size(); i < length;   i) {
+        auto& character = pattern[i];
+
+        if (character == '\'') {
+            i = skipLiteralText(pattern, i, length);
+            continue;
+        }
+
         switch (character) {
         case 'K':

trunk/Source/JavaScriptCore/runtime/IntlDateTimeFormat.h

@@ -84 +84 @@
     static IntlDateTimeFormat* unwrapForOldFunctions(JSGlobalObject*, JSValue);
 
+    enum class HourCycle : uint8_t { None, H11, H12, H23, H24 };
+    static HourCycle hourCycleFromPattern(const Vector<UChar, 32>&);
+
 private:
     IntlDateTimeFormat(VM&, Structure*);
@@ -93 +96 @@
     UDateIntervalFormat* createDateIntervalFormatIfNecessary(JSGlobalObject*);
 
-    enum class HourCycle : uint8_t { None, H11, H12, H23, H24 };
     enum class Weekday : uint8_t { None, Narrow, Short, Long };
     enum class Era : uint8_t { None, Narrow, Short, Long };
@@ -122 +124 @@
     static HourCycle hourCycleFromSymbol(UChar);
     static HourCycle parseHourCycle(const String&);
-    static HourCycle hourCycleFromPattern(const Vector<UChar, 32>&);
     static void replaceHourCycleInSkeleton(Vector<UChar, 32>&, bool hour12);
     static void replaceHourCycleInPattern(Vector<UChar, 32>&, HourCycle);

trunk/Source/JavaScriptCore/runtime/IntlLocale.cpp

@@ -28 +28 @@
 #include "IntlLocale.h"
 
+#include "IntlDateTimeFormat.h"
 #include "IntlObjectInlines.h"
 #include "JSCInlines.h"
@@ -41 +42 @@
 
 const ClassInfo IntlLocale::s_info = { "Object", &Base::s_info, nullptr, nullptr, CREATE_METHOD_TABLE(IntlLocale) };
+
+namespace IntlLocaleInternal {
+static constexpr bool verbose = false;
+}
 
 IntlLocale* IntlLocale::create(VM& vm, Structure* structure)
@@ -644 +649 @@
     }
 
-    for (unsigned i = 0; i < pattern.size();   i) {
-        UChar currentCharacter = pattern[i];
-        if (!isASCIIAlpha(currentCharacter))
-            continue;
-
-        while (i   1 < pattern.size() && pattern[i   1] == currentCharacter)
-              i;
-
-        switch (currentCharacter) {
-        case 'h': {
-            elements.append("h12"_s);
-            RELEASE_AND_RETURN(scope, createArrayFromStringVector(globalObject, WTFMove(elements)));
-        }
-        case 'H': {
-            elements.append("h23"_s);
-            RELEASE_AND_RETURN(scope, createArrayFromStringVector(globalObject, WTFMove(elements)));
-        }
-        case 'k': {
-            elements.append("h24"_s);
-            RELEASE_AND_RETURN(scope, createArrayFromStringVector(globalObject, WTFMove(elements)));
-        }
-        case 'K': {
-            elements.append("h11"_s);
-            RELEASE_AND_RETURN(scope, createArrayFromStringVector(globalObject, WTFMove(elements)));
-        }
-        default:
-            break;
-        }
+    dataLogLnIf(IntlLocaleInternal::verbose, "pattern:(", StringView(pattern.data(), pattern.size()), ")");
+
+    switch (IntlDateTimeFormat::hourCycleFromPattern(pattern)) {
+    case IntlDateTimeFormat::HourCycle::None:
+        break;
+    case IntlDateTimeFormat::HourCycle::H11: {
+        elements.append("h11"_s);
+        RELEASE_AND_RETURN(scope, createArrayFromStringVector(globalObject, WTFMove(elements)));
+    }
+    case IntlDateTimeFormat::HourCycle::H12: {
+        elements.append("h12"_s);
+        RELEASE_AND_RETURN(scope, createArrayFromStringVector(globalObject, WTFMove(elements)));
+    }
+    case IntlDateTimeFormat::HourCycle::H23: {
+        elements.append("h23"_s);
+        RELEASE_AND_RETURN(scope, createArrayFromStringVector(globalObject, WTFMove(elements)));
+    }
+    case IntlDateTimeFormat::HourCycle::H24: {
+        elements.append("h24"_s);
+        RELEASE_AND_RETURN(scope, createArrayFromStringVector(globalObject, WTFMove(elements)));
+    }
     }