Implement chinese counter styles

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 299 matching lines @@
         static const UChar georgianOnes[9] = {
             0x10D0, 0x10D1, 0x10D2, 0x10D3, 0x10D4, 0x10D5, 0x10D6, 0x10F1, 0x10D7
         };
         letters[length++] = georgianOnes[ones - 1];
     }
 
     ASSERT(length <= lettersSize);
     return String(letters, length);
 }
 
+enum CJKLang {
+    Chinese = 1,
+    Korean,
+    Japanese
+};
+
+enum CJKStyle {
+    Formal,
+    Informal
+};
+
 // The table uses the order from the CSS3 specification:
 // first 3 group markers, then 3 digit markers, then ten digits, then negative symbols.
-static String toCJKIdeographic(int number, const UChar table[23])
+static String toCJKIdeographic(int number, const UChar table[26], CJKStyle cjkStyle)
 {
     enum AbstractCJKChar {
         NoChar = 0,
         Lang = 0,
-        SecondGroupMarker, ThirdGroupMarker, FourthGroupMarker,
-        SecondDigitMarker, ThirdDigitMarker, FourthDigitMarker,
+        // FourthGroupMarker for simplified chinese has two codepoints, to simplify
+        // the main algorithm below use two codepoints for all group markers.
+        SecondGroupMarker = 1, ThirdGroupMarker = 3, FourthGroupMarker = 5,
+        SecondDigitMarker = 7, ThirdDigitMarker, FourthDigitMarker,
         Digit0, Digit1, Digit2, Digit3, Digit4,
         Digit5, Digit6, Digit7, Digit8, Digit9,
         Neg1, Neg2, Neg3, Neg4, Neg5
     };
 
-    enum CJKLang {
-        Chinese = 1,
-        Korean,
-        Japanese
-    };
-
     if (number == 0)
         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 groupLength = 9; // 4 digits, 3 digit markers, group marker of size 2.
     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.
         AbstractCJKChar* group = &buffer[(3 - i) * groupLength];
 
-        if (groupValue && i)
+        if (groupValue && i) {
+            group[8] = static_cast<AbstractCJKChar>(SecondGroupMarker + i);
             group[7] = static_cast<AbstractCJKChar>(SecondGroupMarker - 1 + i);
+        }
 
         // Put in the four digits and digit markers for any non-zero digits.
         int digitValue = (groupValue % 10);
         bool trailingZero = table[Lang] == Chinese && !digitValue;
         if (digitValue)
             group[6] = static_cast<AbstractCJKChar>(Digit0 + (groupValue % 10));
         if (number != 0 || groupValue > 9) {
             digitValue = ((groupValue / 10) % 10);
             if (digitValue || !trailingZero)
                 group[4] = static_cast<AbstractCJKChar>(Digit0 + digitValue);
@@ skipping 12 matching lines @@
         if (number != 0 || groupValue > 999) {
             digitValue = groupValue / 1000;
             if (digitValue || !trailingZero)
                 group[0] = static_cast<AbstractCJKChar>(Digit0 + digitValue);
             if (digitValue)
                 group[1] = FourthDigitMarker;
         }
 
         if (trailingZero && i > 0) {
             group[6] = group[7];
-            group[7] = Digit0;
+            group[7] = group[8];
+            group[8] = Digit0;
         }
 
         // Remove the tens digit, but leave the marker, for any group that has
         // a value of less than 20.
-        if (table[Lang] == Chinese && groupValue < 20) {
+        if (table[Lang] == Chinese && cjkStyle == Informal && 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;
     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 || (table[Lang] == Chinese && last != Digit0)) {
-                characters[length++] = table[a];
-                if (table[Lang] == Korean && a >= SecondGroupMarker && a <= FourthGroupMarker)
-                    characters[length++] = ' ';
+                UChar newChar = table[a];
+                if (newChar != NoChar) {
+                    characters[length++] = table[a];
+                    if (table[Lang] == Korean && (a == SecondGroupMarker || a == ThirdGroupMarker || a == FourthGroupMarker))
+                        characters[length++] = ' ';
+                }
             }
             last = a;
         }
     }
     if ((table[Lang] == Chinese && last == Digit0) || characters[length - 1] == ' ')
         --length;
 
     return String(characters, length);
 }
 
@@ skipping 21 matching lines @@
     case NoneListStyle:
     case Oriya:
     case Persian:
     case Square:
     case Telugu:
     case Thai:
     case Tibetan:
     case Urdu:
     case KoreanHangulFormal:
     case CJKIdeographic:
+    case SimpChineseFormal:
+    case SimpChineseInformal:
+    case TradChineseFormal:
+    case TradChineseInformal:
         return type; // Can represent all ordinals.
     case Armenian:
     case LowerArmenian:
     case UpperArmenian:
         return (value < 1 || value > 99999999) ? DecimalListStyle : type;
     case Georgian:
         return (value < 1 || value > 19999) ? DecimalListStyle : type;
     case Hebrew:
         return (value < 0 || value > 999999) ? DecimalListStyle : type;
     case LowerRoman:
@@ skipping 77 matching lines @@
     case Persian:
     case Telugu:
     case Thai:
     case Tibetan:
     case UpperAlpha:
     case UpperArmenian:
     case UpperLatin:
     case UpperRoman:
     case Urdu:
         return '.';
+    case SimpChineseFormal:
+    case SimpChineseInformal:
+    case TradChineseFormal:
+    case TradChineseInformal:
     case KoreanHangulFormal:
-        return ',';
+        return 0x3001;
     }
 
     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 255 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,
+        static const UChar koreanHangulFormalTable[26] = {
+            Korean,
+            0xB9CC, 0x0000, 0xC5B5, 0x0000, 0xC870, 0x0000,
             0xC2ED, 0xBC31, 0xCC9C,
             0xC601, 0xC77C, 0xC774, 0xC0BC, 0xC0AC,
             0xC624, 0xC721, 0xCE60, 0xD314, 0xAD6C,
             0xB9C8, 0xC774, 0xB108, 0xC2A4, 0x0020, 0x0000
         };
-        return toCJKIdeographic(value, koreanHangulFormalTable);
+        return toCJKIdeographic(value, koreanHangulFormalTable, Formal);
     }
-    case CJKIdeographic: {
-        static const UChar traditionalChineseInformalTable[19] = {
-            0x1,
-            0x842C, 0x5104, 0x5146,
+    case CJKIdeographic:
+    case TradChineseInformal: {
+        static const UChar traditionalChineseInformalTable[22] = {
+            Chinese,
+            0x842C, 0x0000, 0x5104, 0x0000, 0x5146, 0x0000,
             0x5341, 0x767E, 0x5343,
             0x96F6, 0x4E00, 0x4E8C, 0x4E09, 0x56DB,
             0x4E94, 0x516D, 0x4E03, 0x516B, 0x4E5D,
             0x8CA0, 0x0000
         };
-        return toCJKIdeographic(value, traditionalChineseInformalTable);
+        return toCJKIdeographic(value, traditionalChineseInformalTable, Informal);
+    }
+    case SimpChineseInformal: {
+        static const UChar simpleChineseInformalTable[22] = {
+            Chinese,
+            0x4E07, 0x0000, 0x4EBF, 0x0000, 0x4E07, 0x4EBF,
+            0x5341, 0x767E, 0x5343,
+            0x96F6, 0x4E00, 0x4E8C, 0x4E09, 0x56DB,
+            0x4E94, 0x516D, 0x4E03, 0x516B, 0x4E5D,
+            0x8D1F, 0x0000
+        };
+        return toCJKIdeographic(value, simpleChineseInformalTable, Informal);
+    }
+    case TradChineseFormal: {
+        static const UChar traditionalChineseFormalTable[22] = {
+            Chinese,
+            0x842C, 0x0000, 0x5104, 0x0000, 0x5146, 0x0000,
+            0x62FE, 0x4F70, 0x4EDF,
+            0x96F6, 0x58F9, 0x8CB3, 0x53C3, 0x8086,
+            0x4F0D, 0x9678, 0x67D2, 0x634C, 0x7396,
+            0x8CA0, 0x0000
+        };
+        return toCJKIdeographic(value, traditionalChineseFormalTable, Formal);
+    }
+    case SimpChineseFormal: {
+        static const UChar simpleChineseFormalTable[22] = {
+            Chinese,
+            0x4E07, 0x0000, 0x4EBF, 0x0000, 0x4E07, 0x4EBF,
+            0x62FE, 0x4F70, 0x4EDF,
+            0x96F6, 0x58F9, 0x8D30, 0x53C1, 0x8086,
+            0x4F0D, 0x9646, 0x67D2, 0x634C, 0x7396,
+            0x8D1F, 0x0000
+        };
+        return toCJKIdeographic(value, simpleChineseFormalTable, Formal);
     }
 
     case LowerRoman:
         return toRoman(value, false);
     case UpperRoman:
         return toRoman(value, true);
 
     case Armenian:
     case UpperArmenian:
         // CSS3 says "armenian" means "lower-armenian".
@@ skipping 194 matching lines @@
     case LowerAlpha:
     case LowerArmenian:
     case LowerGreek:
     case LowerLatin:
     case LowerRoman:
     case Malayalam:
     case Mongolian:
     case Myanmar:
     case Oriya:
     case Persian:
+    case SimpChineseFormal:
+    case SimpChineseInformal:
     case Telugu:
     case Thai:
     case Tibetan:
+    case TradChineseFormal:
+    case TradChineseInformal:
     case UpperAlpha:
     case UpperArmenian:
     case UpperLatin:
     case UpperRoman:
     case Urdu:
         m_text = listMarkerText(type, m_listItem->value());
         break;
     }
 }
 
@@ skipping 53 matching lines @@
     case LowerAlpha:
     case LowerArmenian:
     case LowerGreek:
     case LowerLatin:
     case LowerRoman:
     case Malayalam:
     case Mongolian:
     case Myanmar:
     case Oriya:
     case Persian:
+    case SimpChineseFormal:
+    case SimpChineseInformal:
     case Telugu:
     case Thai:
     case Tibetan:
+    case TradChineseFormal:
+    case TradChineseInformal:
     case UpperAlpha:
     case UpperArmenian:
     case UpperLatin:
     case UpperRoman:
     case Urdu:
         if (m_text.isEmpty()) {
             logicalWidth = 0;
         } else {
             LayoutUnit itemWidth = font.width(m_text);
             UChar suffixSpace[2] = { listMarkerSuffix(type, m_listItem->value()), ' ' };
@@ skipping 149 matching lines @@
     case LowerAlpha:
     case LowerArmenian:
     case LowerGreek:
     case LowerLatin:
     case LowerRoman:
     case Malayalam:
     case Mongolian:
     case Myanmar:
     case Oriya:
     case Persian:
+    case SimpChineseFormal:
+    case SimpChineseInformal:
     case Telugu:
     case Thai:
     case Tibetan:
+    case TradChineseFormal:
+    case TradChineseInformal:
     case UpperAlpha:
     case UpperArmenian:
     case UpperLatin:
     case UpperRoman:
     case Urdu:
         if (m_text.isEmpty())
             return IntRect();
         const Font& font = style()->font();
         int itemWidth = font.width(m_text);
         UChar suffixSpace[2] = { listMarkerSuffix(type, m_listItem->value()), ' ' };
@@ skipping 43 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