Add support for korean-hangul-formal list style type

Source/core/layout/LayoutListMarker.cpp

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
  * Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008 Apple Inc. All rights reserved.
  * Copyright (C) 2006 Andrew Wellington (proton@wiretapped.net)
  * Copyright (C) 2010 Daniel Bates (dbates@intudata.com)
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
@@ skipping 300 matching lines @@
             0x10D0, 0x10D1, 0x10D2, 0x10D3, 0x10D4, 0x10D5, 0x10D6, 0x10F1, 0x10D7
         };
         letters[length++] = georgianOnes[ones - 1];
     }
 
     ASSERT(length <= lettersSize);
     return String(letters, length);
 }
 
 // The table uses the order from the CSS3 specification:
-// first 3 group markers, then 3 digit markers, then ten digits.
-static String toCJKIdeographic(int number, const UChar table[16])
+// first 3 group markers, then 3 digit markers, then ten digits, then negative symbols.
+static String toCJKIdeographic(int number, const UChar table[23])
 {
-    ASSERT(number >= 0);
-
     enum AbstractCJKChar {
-        NoChar,
+        NoChar = 0,
+        Lang = 0,
         SecondGroupMarker, ThirdGroupMarker, FourthGroupMarker,
         SecondDigitMarker, ThirdDigitMarker, FourthDigitMarker,
         Digit0, Digit1, Digit2, Digit3, Digit4,
-        Digit5, Digit6, Digit7, Digit8, Digit9
+        Digit5, Digit6, Digit7, Digit8, Digit9,
+        Neg1, Neg2, Neg3, Neg4, Neg5
+    };
+
+    enum CJKLang {
+        Chinese = 1,
+        Korean,
+        Japanese
     };
 
     if (number == 0)
-        return String(&table[Digit0 - 1], 1);
+        return String(&table[Digit0], 1);
+
+    const bool negative = number < 0;
+    if (negative)
+        number = -number;
 
     const int groupLength = 8; // 4 digits, 3 digit markers, and a group marker
     const int bufferLength = 4 * groupLength;
     AbstractCJKChar buffer[bufferLength] = { NoChar };
 
     for (int i = 0; i < 4; ++i) {
         int groupValue = number % 10000;
         number /= 10000;
 
         // Process least-significant group first, but put it in the buffer last.
@@ skipping 18 matching lines @@
         }
         if (number != 0 || groupValue > 999) {
             int digitValue = groupValue / 1000;
             group[0] = static_cast<AbstractCJKChar>(Digit0 + digitValue);
             if (digitValue)
                 group[1] = FourthDigitMarker;
         }
 
         // Remove the tens digit, but leave the marker, for any group that has
         // a value of less than 20.
-        if (groupValue < 20) {
+        if (table[Lang] == Chinese && groupValue < 20) {
             ASSERT(group[4] == NoChar || group[4] == Digit0 || group[4] == Digit1);
             group[4] = NoChar;
         }
 
         if (number == 0)
             break;
     }
 
     // Convert into characters, omitting consecutive runs of Digit0 and
     // any trailing Digit0.
     int length = 0;
-    UChar characters[bufferLength];
+    const int maxLengthForNegativeSymbols = 5;
+    UChar characters[bufferLength + maxLengthForNegativeSymbols];
     AbstractCJKChar last = NoChar;
+    if (negative) {
+        while (UChar a = table[Neg1 + length])
+            characters[length++] = a;
+    }
     for (int i = 0; i < bufferLength; ++i) {
         AbstractCJKChar a = buffer[i];
         if (a != NoChar) {
-            if (a != Digit0 || last != Digit0)
-                characters[length++] = table[a - 1];
+            if (a != Digit0 || (table[Lang] == Chinese && last != Digit0)) {
+                characters[length++] = table[a];
+                if (table[Lang] == Korean && a >= SecondGroupMarker && a <= FourthGroupMarker)
+                    characters[length++] = ' ';
+            }
             last = a;
         }
     }
-    if (last == Digit0)
+    if ((table[Lang] == Chinese && last == Digit0) || characters[length - 1] == ' ')
         --length;
 
     return String(characters, length);
 }
 
 static EListStyleType effectiveListMarkerType(EListStyleType type, int value)
 {
     // Note, the following switch statement has been explicitly grouped
     // by list-style-type ordinal range.
     switch (type) {
@@ skipping 14 matching lines @@
     case Mongolian:
     case Myanmar:
     case NoneListStyle:
     case Oriya:
     case Persian:
     case Square:
     case Telugu:
     case Thai:
     case Tibetan:
     case Urdu:
+    case KoreanHangulFormal:
         return type; // Can represent all ordinals.
     case Armenian:
         return (value < 1 || value > 99999999) ? DecimalListStyle : type;
     case CJKIdeographic:
         return (value < 0) ? DecimalListStyle : type;
     case Georgian:
         return (value < 1 || value > 19999) ? DecimalListStyle : type;
     case Hebrew:
         return (value < 0 || value > 999999) ? DecimalListStyle : type;
     case LowerRoman:
@@ skipping 79 matching lines @@
     case Persian:
     case Telugu:
     case Thai:
     case Tibetan:
     case UpperAlpha:
     case UpperArmenian:
     case UpperLatin:
     case UpperRoman:
     case Urdu:
         return '.';
+    case KoreanHangulFormal:
+        return ',';
     }
 
     ASSERT_NOT_REACHED();
     return '.';
 }
 
 String listMarkerText(EListStyleType type, int value)
 {
     // If the list-style-type, say hebrew, cannot represent |value| because it's outside
     // its ordinal range then we fallback to some list style that can represent |value|.
@@ skipping 254 matching lines @@
     }
     case EthiopicHalehameTiEt: {
         static const UChar ethiopicHalehameTiEtAlphabet[34] = {
             0x1200, 0x1208, 0x1210, 0x1218, 0x1220, 0x1228, 0x1230, 0x1238, 0x1240,
             0x1250, 0x1260, 0x1270, 0x1278, 0x1280, 0x1290, 0x1298, 0x12A0, 0x12A8,
             0x12B8, 0x12C8, 0x12D0, 0x12D8, 0x12E0, 0x12E8, 0x12F0, 0x1300, 0x1308,
             0x1320, 0x1328, 0x1330, 0x1338, 0x1340, 0x1348, 0x1350
         };
         return toAlphabetic(value, ethiopicHalehameTiEtAlphabet);
     }
+    case KoreanHangulFormal: {
+        static const UChar koreanHangulFormalTable[23] = {
+            0x2,
+            0xB9CC, 0xC5B5, 0xC870,
+            0xC2ED, 0xBC31, 0xCC9C,
+            0xC601, 0xC77C, 0xC774, 0xC0BC, 0xC0AC,
+            0xC624, 0xC721, 0xCE60, 0xD314, 0xAD6C,
+            0xB9C8, 0xC774, 0xB108, 0xC2A4, 0x0020, 0x0000
+        };
+        return toCJKIdeographic(value, koreanHangulFormalTable);
+    }
     case CJKIdeographic: {
-        static const UChar traditionalChineseInformalTable[16] = {
+        static const UChar traditionalChineseInformalTable[19] = {
+            0x1,
             0x842C, 0x5104, 0x5146,
             0x5341, 0x767E, 0x5343,
             0x96F6, 0x4E00, 0x4E8C, 0x4E09, 0x56DB,
-            0x4E94, 0x516D, 0x4E03, 0x516B, 0x4E5D
+            0x4E94, 0x516D, 0x4E03, 0x516B, 0x4E5D,
+            0x8CA0, 0x0000
         };
         return toCJKIdeographic(value, traditionalChineseInformalTable);
     }
 
     case LowerRoman:
         return toRoman(value, false);
     case UpperRoman:
         return toRoman(value, true);
 
     case Armenian:
@@ skipping 177 matching lines @@
     case Devanagari:
     case EthiopicHalehame:
     case EthiopicHalehameAm:
     case EthiopicHalehameTiEr:
     case EthiopicHalehameTiEt:
     case Georgian:
     case Gujarati:
     case Gurmukhi:
     case Hangul:
     case HangulConsonant:
+    case KoreanHangulFormal:
     case Hebrew:
     case Hiragana:
     case HiraganaIroha:
     case Kannada:
     case Katakana:
     case KatakanaIroha:
     case Khmer:
     case Lao:
     case LowerAlpha:
     case LowerArmenian:
@@ skipping 55 matching lines @@
     case Devanagari:
     case EthiopicHalehame:
     case EthiopicHalehameAm:
     case EthiopicHalehameTiEr:
     case EthiopicHalehameTiEt:
     case Georgian:
     case Gujarati:
     case Gurmukhi:
     case Hangul:
     case HangulConsonant:
+    case KoreanHangulFormal:
     case Hebrew:
     case Hiragana:
     case HiraganaIroha:
     case Kannada:
     case Katakana:
     case KatakanaIroha:
     case Khmer:
     case Lao:
     case LowerAlpha:
     case LowerArmenian:
@@ skipping 150 matching lines @@
     case DecimalListStyle:
     case Devanagari:
     case EthiopicHalehame:
     case EthiopicHalehameAm:
     case EthiopicHalehameTiEr:
     case EthiopicHalehameTiEt:
     case Georgian:
     case Gujarati:
     case Gurmukhi:
     case Hangul:
+    case KoreanHangulFormal:
     case HangulConsonant:
     case Hebrew:
     case Hiragana:
     case HiraganaIroha:
     case Kannada:
     case Katakana:
     case KatakanaIroha:
     case Khmer:
     case Lao:
     case LowerAlpha:
@@ skipping 65 matching lines @@
     if (style()) {
         // Reuse the current margins. Otherwise resetting the margins to initial values
         // would trigger unnecessary layout.
         newStyle->setMarginStart(style()->marginStart());
         newStyle->setMarginEnd(style()->marginRight());
     }
     setStyle(newStyle.release());
 }
 
 } // namespace blink