nagai/fune
3
0
Fork 0
forked from mirrors/gecko-dev
Code Pull requests Activity
fune/layout/style/CounterStyleManager.cpp
Emilio Cobos Álvarez a7526d2a34 Bug 1832173 - Finish removing HasArcFFI. r=boris 
Use the actual Locked<T> types around (via a typedef, just for
convenience).

Differential Revision: https://phabricator.services.mozilla.com/D177824
2023-05-12 22:31:38 +00:00

1884 lines
60 KiB
C++
Raw Blame History

/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* vim: set ts=8 sts=2 et sw=2 tw=80: */
/* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
#include "CounterStyleManager.h"
#include <type_traits>
#include "mozilla/ArenaObjectID.h"
#include "mozilla/ArrayUtils.h"
#include "mozilla/CheckedInt.h"
#include "mozilla/MathAlgorithms.h"
#include "mozilla/PresShell.h"
#include "mozilla/Types.h"
#include "mozilla/WritingModes.h"
#include "nsPresContext.h"
#include "nsPresContextInlines.h"
#include "nsString.h"
#include "nsTArray.h"
#include "nsTHashtable.h"
#include "nsUnicodeProperties.h"
#include "mozilla/ServoBindings.h"
#include "mozilla/ServoStyleSet.h"
namespace mozilla {
using AdditiveSymbol = StyleAdditiveSymbol;
struct NegativeType {
nsString before, after;
};
struct PadType {
int32_t width;
nsString symbol;
};
// This limitation will be applied to some systems, and pad descriptor.
// Any initial representation generated by symbolic or additive which is
// longer than this limitation will be dropped. If any pad is longer
// than this, the whole counter text will be dropped as well.
// The spec requires user agents to support at least 60 Unicode code-
// points for counter text. However, this constant only limits the
// length in 16-bit units. So it has to be at least 120, since code-
// points outside the BMP will need 2 16-bit units.
#define LENGTH_LIMIT 150
static bool GetCyclicCounterText(CounterValue aOrdinal, nsAString& aResult,
Span<const nsString> aSymbols) {
MOZ_ASSERT(aSymbols.Length() >= 1, "No symbol available for cyclic counter.");
auto n = CounterValue(aSymbols.Length());
CounterValue index = (aOrdinal - 1) % n;
aResult = aSymbols[index >= 0 ? index : index + n];
return true;
}
static bool GetFixedCounterText(CounterValue aOrdinal, nsAString& aResult,
CounterValue aStart,
Span<const nsString> aSymbols) {
CounterValue index = aOrdinal - aStart;
if (index >= 0 && index < CounterValue(aSymbols.Length())) {
aResult = aSymbols[index];
return true;
} else {
return false;
}
}
static bool GetSymbolicCounterText(CounterValue aOrdinal, nsAString& aResult,
Span<const nsString> aSymbols) {
MOZ_ASSERT(aSymbols.Length() >= 1,
"No symbol available for symbolic counter.");
MOZ_ASSERT(aOrdinal >= 0, "Invalid ordinal.");
if (aOrdinal == 0) {
return false;
}
aResult.Truncate();
auto n = aSymbols.Length();
const nsString& symbol = aSymbols[(aOrdinal - 1) % n];
size_t len = (aOrdinal + n - 1) / n;
auto symbolLength = symbol.Length();
if (symbolLength > 0) {
if (len > LENGTH_LIMIT || symbolLength > LENGTH_LIMIT ||
len * symbolLength > LENGTH_LIMIT) {
return false;
}
for (size_t i = 0; i < len; ++i) {
aResult.Append(symbol);
}
}
return true;
}
static bool GetAlphabeticCounterText(CounterValue aOrdinal, nsAString& aResult,
Span<const nsString> aSymbols) {
MOZ_ASSERT(aSymbols.Length() >= 2, "Too few symbols for alphabetic counter.");
MOZ_ASSERT(aOrdinal >= 0, "Invalid ordinal.");
if (aOrdinal == 0) {
return false;
}
auto n = aSymbols.Length();
// The precise length of this array should be
// ceil(log((double) aOrdinal / n * (n - 1) + 1) / log(n)).
// The max length is slightly smaller than which defined below.
AutoTArray<int32_t, std::numeric_limits<CounterValue>::digits> indexes;
while (aOrdinal > 0) {
--aOrdinal;
indexes.AppendElement(aOrdinal % n);
aOrdinal /= n;
}
aResult.Truncate();
for (auto i = indexes.Length(); i > 0; --i) {
aResult.Append(aSymbols[indexes[i - 1]]);
}
return true;
}
static bool GetNumericCounterText(CounterValue aOrdinal, nsAString& aResult,
Span<const nsString> aSymbols) {
MOZ_ASSERT(aSymbols.Length() >= 2, "Too few symbols for numeric counter.");
MOZ_ASSERT(aOrdinal >= 0, "Invalid ordinal.");
if (aOrdinal == 0) {
aResult = aSymbols[0];
return true;
}
auto n = aSymbols.Length();
AutoTArray<int32_t, std::numeric_limits<CounterValue>::digits> indexes;
while (aOrdinal > 0) {
indexes.AppendElement(aOrdinal % n);
aOrdinal /= n;
}
aResult.Truncate();
for (auto i = indexes.Length(); i > 0; --i) {
aResult.Append(aSymbols[indexes[i - 1]]);
}
return true;
}
static bool GetAdditiveCounterText(CounterValue aOrdinal, nsAString& aResult,
Span<const AdditiveSymbol> aSymbols) {
MOZ_ASSERT(aOrdinal >= 0, "Invalid ordinal.");
if (aOrdinal == 0) {
const AdditiveSymbol& last = aSymbols[aSymbols.Length() - 1];
if (last.weight == 0) {
aResult = last.symbol;
return true;
}
return false;
}
aResult.Truncate();
size_t length = 0;
for (size_t i = 0, iEnd = aSymbols.Length(); i < iEnd; ++i) {
const AdditiveSymbol& symbol = aSymbols[i];
if (symbol.weight == 0) {
break;
}
CounterValue times = aOrdinal / symbol.weight;
if (times > 0) {
auto symbolLength = symbol.symbol.Length();
if (symbolLength > 0) {
length += times * symbolLength;
if (times > LENGTH_LIMIT || symbolLength > LENGTH_LIMIT ||
length > LENGTH_LIMIT) {
return false;
}
for (CounterValue j = 0; j < times; ++j) {
aResult.Append(symbol.symbol);
}
}
aOrdinal -= times * symbol.weight;
}
}
return aOrdinal == 0;
}
static bool DecimalToText(CounterValue aOrdinal, nsAString& aResult) {
aResult.AppendInt(aOrdinal);
return true;
}
// We know cjk-ideographic need 31 characters to display 99,999,999,999,999,999
// georgian needs 6 at most
// armenian needs 12 at most
// hebrew may need more...
#define NUM_BUF_SIZE 34
enum CJKIdeographicLang { CHINESE, KOREAN, JAPANESE };
struct CJKIdeographicData {
char16_t digit[10];
char16_t unit[3];
char16_t unit10K[2];
uint8_t lang;
bool informal;
};
static const CJKIdeographicData gDataJapaneseInformal = {
{0x3007, 0x4e00, 0x4e8c, 0x4e09, 0x56db, 0x4e94, 0x516d, 0x4e03, 0x516b,
0x4e5d}, // digit
{0x5341, 0x767e, 0x5343}, // unit
{0x4e07, 0x5104}, // unit10K
JAPANESE, // lang
true // informal
};
static const CJKIdeographicData gDataJapaneseFormal = {
{0x96f6, 0x58f1, 0x5f10, 0x53c2, 0x56db, 0x4f0d, 0x516d, 0x4e03, 0x516b,
0x4e5d}, // digit
{0x62fe, 0x767e, 0x9621}, // unit
{0x842c, 0x5104}, // unit10K
JAPANESE, // lang
false // informal
};
static const CJKIdeographicData gDataKoreanHangulFormal = {
{0xc601, 0xc77c, 0xc774, 0xc0bc, 0xc0ac, 0xc624, 0xc721, 0xce60, 0xd314,
0xad6c}, // digit
{0xc2ed, 0xbc31, 0xcc9c}, // unit
{0xb9cc, 0xc5b5}, // unit10K
KOREAN, // lang
false // informal
};
static const CJKIdeographicData gDataKoreanHanjaInformal = {
{0x96f6, 0x4e00, 0x4e8c, 0x4e09, 0x56db, 0x4e94, 0x516d, 0x4e03, 0x516b,
0x4e5d}, // digit
{0x5341, 0x767e, 0x5343}, // unit
{0x842c, 0x5104}, // unit10K
KOREAN, // lang
true // informal
};
static const CJKIdeographicData gDataKoreanHanjaFormal = {
{0x96f6, 0x58f9, 0x8cb3, 0x53c3, 0x56db, 0x4e94, 0x516d, 0x4e03, 0x516b,
0x4e5d}, // digit
{0x62fe, 0x767e, 0x4edf}, // unit
{0x842c, 0x5104}, // unit10K
KOREAN, // lang
false // informal
};
static const CJKIdeographicData gDataSimpChineseInformal = {
{0x96f6, 0x4e00, 0x4e8c, 0x4e09, 0x56db, 0x4e94, 0x516d, 0x4e03, 0x516b,
0x4e5d}, // digit
{0x5341, 0x767e, 0x5343}, // unit
{0x4e07, 0x4ebf}, // unit10K
CHINESE, // lang
true // informal
};
static const CJKIdeographicData gDataSimpChineseFormal = {
{0x96f6, 0x58f9, 0x8d30, 0x53c1, 0x8086, 0x4f0d, 0x9646, 0x67d2, 0x634c,
0x7396}, // digit
{0x62fe, 0x4f70, 0x4edf}, // unit
{0x4e07, 0x4ebf}, // unit10K
CHINESE, // lang
false // informal
};
static const CJKIdeographicData gDataTradChineseInformal = {
{0x96f6, 0x4e00, 0x4e8c, 0x4e09, 0x56db, 0x4e94, 0x516d, 0x4e03, 0x516b,
0x4e5d}, // digit
{0x5341, 0x767e, 0x5343}, // unit
{0x842c, 0x5104}, // unit10K
CHINESE, // lang
true // informal
};
static const CJKIdeographicData gDataTradChineseFormal = {
{0x96f6, 0x58f9, 0x8cb3, 0x53c3, 0x8086, 0x4f0d, 0x9678, 0x67d2, 0x634c,
0x7396}, // digit
{0x62fe, 0x4f70, 0x4edf}, // unit
{0x842c, 0x5104}, // unit10K
CHINESE, // lang
false // informal
};
static bool CJKIdeographicToText(CounterValue aOrdinal, nsAString& aResult,
const CJKIdeographicData& data) {
NS_ASSERTION(aOrdinal >= 0, "Only accept non-negative ordinal");
char16_t buf[NUM_BUF_SIZE];
int32_t idx = NUM_BUF_SIZE;
int32_t pos = 0;
bool needZero = (aOrdinal == 0);
int32_t unitidx = 0, unit10Kidx = 0;
do {
unitidx = pos % 4;
if (unitidx == 0) {
unit10Kidx = pos / 4;
}
auto cur = static_cast<std::make_unsigned_t<CounterValue>>(aOrdinal) % 10;
if (cur == 0) {
if (needZero) {
needZero = false;
buf[--idx] = data.digit[0];
}
} else {
if (data.lang == CHINESE) {
needZero = true;
}
if (unit10Kidx != 0) {
if (data.lang == KOREAN && idx != NUM_BUF_SIZE) {
buf[--idx] = ' ';
}
buf[--idx] = data.unit10K[unit10Kidx - 1];
}
if (unitidx != 0) {
buf[--idx] = data.unit[unitidx - 1];
}
if (cur != 1) {
buf[--idx] = data.digit[cur];
} else {
bool needOne = true;
if (data.informal) {
switch (data.lang) {
case CHINESE:
if (unitidx == 1 &&
(aOrdinal == 1 || (pos > 4 && aOrdinal % 1000 == 1))) {
needOne = false;
}
break;
case JAPANESE:
if (unitidx > 0 &&
(unitidx != 3 || (pos == 3 && aOrdinal == 1))) {
needOne = false;
}
break;
case KOREAN:
if (unitidx > 0 || (pos == 4 && (aOrdinal % 1000) == 1)) {
needOne = false;
}
break;
}
}
if (needOne) {
buf[--idx] = data.digit[1];
}
}
unit10Kidx = 0;
}
aOrdinal /= 10;
pos++;
} while (aOrdinal > 0);
aResult.Assign(buf + idx, NUM_BUF_SIZE - idx);
return true;
}
#define HEBREW_GERESH 0x05F3
static const char16_t gHebrewDigit[22] = {
// 1 2 3 4 5 6 7 8 9
0x05D0, 0x05D1, 0x05D2, 0x05D3, 0x05D4, 0x05D5, 0x05D6, 0x05D7, 0x05D8,
// 10 20 30 40 50 60 70 80 90
0x05D9, 0x05DB, 0x05DC, 0x05DE, 0x05E0, 0x05E1, 0x05E2, 0x05E4, 0x05E6,
// 100 200 300 400
0x05E7, 0x05E8, 0x05E9, 0x05EA};
static bool HebrewToText(CounterValue aOrdinal, nsAString& aResult) {
if (aOrdinal < 1 || aOrdinal > 999999) {
return false;
}
bool outputSep = false;
nsAutoString allText, thousandsGroup;
do {
thousandsGroup.Truncate();
int32_t n3 = aOrdinal % 1000;
// Process digit for 100 - 900
for (int32_t n1 = 400; n1 > 0;) {
if (n3 >= n1) {
n3 -= n1;
thousandsGroup.Append(gHebrewDigit[(n1 / 100) - 1 + 18]);
} else {
n1 -= 100;
} // if
} // for
// Process digit for 10 - 90
int32_t n2;
if (n3 >= 10) {
// Special process for 15 and 16
if ((15 == n3) || (16 == n3)) {
// Special rule for religious reason...
// 15 is represented by 9 and 6, not 10 and 5
// 16 is represented by 9 and 7, not 10 and 6
n2 = 9;
thousandsGroup.Append(gHebrewDigit[n2 - 1]);
} else {
n2 = n3 - (n3 % 10);
thousandsGroup.Append(gHebrewDigit[(n2 / 10) - 1 + 9]);
} // if
n3 -= n2;
} // if
// Process digit for 1 - 9
if (n3 > 0) thousandsGroup.Append(gHebrewDigit[n3 - 1]);
if (outputSep) thousandsGroup.Append((char16_t)HEBREW_GERESH);
if (allText.IsEmpty())
allText = thousandsGroup;
else
allText = thousandsGroup + allText;
aOrdinal /= 1000;
outputSep = true;
} while (aOrdinal >= 1);
aResult = allText;
return true;
}
// Convert ordinal to Ethiopic numeric representation.
// The detail is available at http://www.ethiopic.org/Numerals/
// The algorithm used here is based on the pseudo-code put up there by
// Daniel Yacob <yacob@geez.org>.
// Another reference is Unicode 3.0 standard section 11.1.
#define ETHIOPIC_ONE 0x1369
#define ETHIOPIC_TEN 0x1372
#define ETHIOPIC_HUNDRED 0x137B
#define ETHIOPIC_TEN_THOUSAND 0x137C
static bool EthiopicToText(CounterValue aOrdinal, nsAString& aResult) {
if (aOrdinal < 1) {
return false;
}
nsAutoString asciiNumberString; // decimal string representation of ordinal
DecimalToText(aOrdinal, asciiNumberString);
uint8_t asciiStringLength = asciiNumberString.Length();
// If number length is odd, add a leading "0"
// the leading "0" preconditions the string to always have the
// leading tens place populated, this avoids a check within the loop.
// If we didn't add the leading "0", decrement asciiStringLength so
// it will be equivalent to a zero-based index in both cases.
if (asciiStringLength & 1) {
asciiNumberString.InsertLiteral(u"0", 0);
} else {
asciiStringLength--;
}
aResult.Truncate();
// Iterate from the highest digits to lowest
// indexFromLeft indexes digits (0 = most significant)
// groupIndexFromRight indexes pairs of digits (0 = least significant)
for (uint8_t indexFromLeft = 0, groupIndexFromRight = asciiStringLength >> 1;
indexFromLeft <= asciiStringLength;
indexFromLeft += 2, groupIndexFromRight--) {
uint8_t tensValue = asciiNumberString.CharAt(indexFromLeft) & 0x0F;
uint8_t unitsValue = asciiNumberString.CharAt(indexFromLeft + 1) & 0x0F;
uint8_t groupValue = tensValue * 10 + unitsValue;
bool oddGroup = (groupIndexFromRight & 1);
// we want to clear ETHIOPIC_ONE when it is superfluous
if (aOrdinal > 1 && groupValue == 1 && // one without a leading ten
(oddGroup ||
indexFromLeft == 0)) { // preceding (100) or leading the sequence
unitsValue = 0;
}
// put it all together...
if (tensValue) {
// map onto Ethiopic "tens":
aResult.Append((char16_t)(tensValue + ETHIOPIC_TEN - 1));
}
if (unitsValue) {
// map onto Ethiopic "units":
aResult.Append((char16_t)(unitsValue + ETHIOPIC_ONE - 1));
}
// Add a separator for all even groups except the last,
// and for odd groups with non-zero value.
if (oddGroup) {
if (groupValue) {
aResult.Append((char16_t)ETHIOPIC_HUNDRED);
}
} else {
if (groupIndexFromRight) {
aResult.Append((char16_t)ETHIOPIC_TEN_THOUSAND);
}
}
}
return true;
}
static SpeakAs GetDefaultSpeakAsForSystem(StyleCounterSystem aSystem) {
MOZ_ASSERT(aSystem != StyleCounterSystem::Extends,
"Extends system does not have static default speak-as");
switch (aSystem) {
case StyleCounterSystem::Alphabetic:
return SpeakAs::Spellout;
case StyleCounterSystem::Cyclic:
return SpeakAs::Bullets;
default:
return SpeakAs::Numbers;
}
}
static bool SystemUsesNegativeSign(StyleCounterSystem aSystem) {
MOZ_ASSERT(aSystem != StyleCounterSystem::Extends,
"Cannot check this for extending style");
switch (aSystem) {
case StyleCounterSystem::Symbolic:
case StyleCounterSystem::Alphabetic:
case StyleCounterSystem::Numeric:
case StyleCounterSystem::Additive:
return true;
default:
return false;
}
}
class BuiltinCounterStyle : public CounterStyle {
public:
constexpr BuiltinCounterStyle(ListStyle aStyle, nsStaticAtom* aName)
: CounterStyle(aStyle), mName(aName) {}
nsStaticAtom* GetStyleName() const { return mName; }
virtual void GetPrefix(nsAString& aResult) override;
virtual void GetSuffix(nsAString& aResult) override;
virtual void GetSpokenCounterText(CounterValue aOrdinal,
WritingMode aWritingMode,
nsAString& aResult,
bool& aIsBullet) override;
virtual bool IsBullet() override;
virtual void GetNegative(NegativeType& aResult) override;
virtual bool IsOrdinalInRange(CounterValue aOrdinal) override;
virtual bool IsOrdinalInAutoRange(CounterValue aOrdinal) override;
virtual void GetPad(PadType& aResult) override;
virtual CounterStyle* GetFallback() override;
virtual SpeakAs GetSpeakAs() override;
virtual bool UseNegativeSign() override;
virtual bool GetInitialCounterText(CounterValue aOrdinal,
WritingMode aWritingMode,
nsAString& aResult, bool& aIsRTL) override;
protected:
constexpr BuiltinCounterStyle(const BuiltinCounterStyle& aOther)
: CounterStyle(aOther.mStyle), mName(aOther.mName) {}
private:
nsStaticAtom* mName;
};
/* virtual */
void BuiltinCounterStyle::GetPrefix(nsAString& aResult) { aResult.Truncate(); }
/* virtual */
void BuiltinCounterStyle::GetSuffix(nsAString& aResult) {
switch (mStyle) {
case ListStyle::None:
aResult.Truncate();
break;
case ListStyle::Disc:
case ListStyle::Circle:
case ListStyle::Square:
case ListStyle::DisclosureClosed:
case ListStyle::DisclosureOpen:
case ListStyle::EthiopicNumeric:
aResult = ' ';
break;
case ListStyle::TradChineseInformal:
case ListStyle::TradChineseFormal:
case ListStyle::SimpChineseInformal:
case ListStyle::SimpChineseFormal:
case ListStyle::JapaneseInformal:
case ListStyle::JapaneseFormal:
aResult = 0x3001;
break;
case ListStyle::KoreanHangulFormal:
case ListStyle::KoreanHanjaInformal:
case ListStyle::KoreanHanjaFormal:
aResult.AssignLiteral(u", ");
break;
default:
aResult.AssignLiteral(u". ");
break;
}
}
static const char16_t kDiscCharacter = 0x2022;
static const char16_t kCircleCharacter = 0x25e6;
static const char16_t kSquareCharacter = 0x25aa;
static const char16_t kRightPointingCharacter = 0x25b8;
static const char16_t kLeftPointingCharacter = 0x25c2;
static const char16_t kDownPointingCharacter = 0x25be;
/* virtual */
void BuiltinCounterStyle::GetSpokenCounterText(CounterValue aOrdinal,
WritingMode aWritingMode,
nsAString& aResult,
bool& aIsBullet) {
switch (mStyle) {
case ListStyle::None:
case ListStyle::Disc:
case ListStyle::Circle:
case ListStyle::Square:
case ListStyle::DisclosureClosed:
case ListStyle::DisclosureOpen: {
// Same as the initial representation
bool isRTL;
GetInitialCounterText(aOrdinal, aWritingMode, aResult, isRTL);
aIsBullet = true;
break;
}
default:
CounterStyle::GetSpokenCounterText(aOrdinal, aWritingMode, aResult,
aIsBullet);
break;
}
}
/* virtual */
bool BuiltinCounterStyle::IsBullet() {
switch (mStyle) {
case ListStyle::Disc:
case ListStyle::Circle:
case ListStyle::Square:
case ListStyle::DisclosureClosed:
case ListStyle::DisclosureOpen:
return true;
default:
return false;
}
}
static const char16_t gJapaneseNegative[] = {0x30de, 0x30a4, 0x30ca, 0x30b9,
0x0000};
static const char16_t gKoreanNegative[] = {0xb9c8, 0xc774, 0xb108,
0xc2a4, 0x0020, 0x0000};
static const char16_t gSimpChineseNegative[] = {0x8d1f, 0x0000};
static const char16_t gTradChineseNegative[] = {0x8ca0, 0x0000};
/* virtual */
void BuiltinCounterStyle::GetNegative(NegativeType& aResult) {
switch (mStyle) {
case ListStyle::JapaneseFormal:
case ListStyle::JapaneseInformal:
aResult.before = gJapaneseNegative;
break;
case ListStyle::KoreanHangulFormal:
case ListStyle::KoreanHanjaInformal:
case ListStyle::KoreanHanjaFormal:
aResult.before = gKoreanNegative;
break;
case ListStyle::SimpChineseFormal:
case ListStyle::SimpChineseInformal:
aResult.before = gSimpChineseNegative;
break;
case ListStyle::TradChineseFormal:
case ListStyle::TradChineseInformal:
aResult.before = gTradChineseNegative;
break;
default:
aResult.before.AssignLiteral(u"-");
}
aResult.after.Truncate();
}
/* virtual */
bool BuiltinCounterStyle::IsOrdinalInRange(CounterValue aOrdinal) {
switch (mStyle) {
default:
// cyclic
case ListStyle::None:
case ListStyle::Disc:
case ListStyle::Circle:
case ListStyle::Square:
case ListStyle::DisclosureClosed:
case ListStyle::DisclosureOpen:
// use DecimalToText
case ListStyle::Decimal:
// use CJKIdeographicToText
case ListStyle::JapaneseFormal:
case ListStyle::JapaneseInformal:
case ListStyle::KoreanHanjaFormal:
case ListStyle::KoreanHanjaInformal:
case ListStyle::KoreanHangulFormal:
case ListStyle::TradChineseFormal:
case ListStyle::TradChineseInformal:
case ListStyle::SimpChineseFormal:
case ListStyle::SimpChineseInformal:
return true;
// use EthiopicToText
case ListStyle::EthiopicNumeric:
return aOrdinal >= 1;
// use HebrewToText
case ListStyle::Hebrew:
return aOrdinal >= 1 && aOrdinal <= 999999;
}
}
/* virtual */
bool BuiltinCounterStyle::IsOrdinalInAutoRange(CounterValue aOrdinal) {
switch (mStyle) {
// cyclic:
case ListStyle::None:
case ListStyle::Disc:
case ListStyle::Circle:
case ListStyle::Square:
case ListStyle::DisclosureClosed:
case ListStyle::DisclosureOpen:
// numeric:
case ListStyle::Decimal:
return true;
// additive:
case ListStyle::Hebrew:
return aOrdinal >= 0;
// complex predefined:
case ListStyle::JapaneseFormal:
case ListStyle::JapaneseInformal:
case ListStyle::KoreanHanjaFormal:
case ListStyle::KoreanHanjaInformal:
case ListStyle::KoreanHangulFormal:
case ListStyle::TradChineseFormal:
case ListStyle::TradChineseInformal:
case ListStyle::SimpChineseFormal:
case ListStyle::SimpChineseInformal:
case ListStyle::EthiopicNumeric:
return IsOrdinalInRange(aOrdinal);
default:
MOZ_ASSERT_UNREACHABLE("Unknown counter style");
return false;
}
}
/* virtual */
void BuiltinCounterStyle::GetPad(PadType& aResult) {
aResult.width = 0;
aResult.symbol.Truncate();
}
/* virtual */
CounterStyle* BuiltinCounterStyle::GetFallback() {
// Fallback of dependent builtin counter styles are handled in class
// DependentBuiltinCounterStyle.
return CounterStyleManager::GetDecimalStyle();
}
/* virtual */
SpeakAs BuiltinCounterStyle::GetSpeakAs() {
switch (mStyle) {
case ListStyle::None:
case ListStyle::Disc:
case ListStyle::Circle:
case ListStyle::Square:
case ListStyle::DisclosureClosed:
case ListStyle::DisclosureOpen:
return SpeakAs::Bullets;
default:
return SpeakAs::Numbers;
}
}
/* virtual */
bool BuiltinCounterStyle::UseNegativeSign() {
switch (mStyle) {
case ListStyle::None:
case ListStyle::Disc:
case ListStyle::Circle:
case ListStyle::Square:
case ListStyle::DisclosureClosed:
case ListStyle::DisclosureOpen:
return false;
default:
return true;
}
}
/* virtual */
bool BuiltinCounterStyle::GetInitialCounterText(CounterValue aOrdinal,
WritingMode aWritingMode,
nsAString& aResult,
bool& aIsRTL) {
aIsRTL = false;
switch (mStyle) {
// used by counters & extends counter-style code only
// XXX We really need to do this the same way we do list bullets.
case ListStyle::None:
aResult.Truncate();
return true;
case ListStyle::Disc:
aResult.Assign(kDiscCharacter);
return true;
case ListStyle::Circle:
aResult.Assign(kCircleCharacter);
return true;
case ListStyle::Square:
aResult.Assign(kSquareCharacter);
return true;
case ListStyle::DisclosureClosed:
if (aWritingMode.IsVertical()) {
aResult.Assign(kDownPointingCharacter);
} else if (aWritingMode.IsBidiLTR()) {
aResult.Assign(kRightPointingCharacter);
} else {
aResult.Assign(kLeftPointingCharacter);
}
return true;
case ListStyle::DisclosureOpen:
if (!aWritingMode.IsVertical()) {
aResult.Assign(kDownPointingCharacter);
} else if (aWritingMode.IsVerticalLR()) {
aResult.Assign(kRightPointingCharacter);
} else {
aResult.Assign(kLeftPointingCharacter);
}
return true;
case ListStyle::Decimal:
return DecimalToText(aOrdinal, aResult);
case ListStyle::TradChineseInformal:
return CJKIdeographicToText(aOrdinal, aResult, gDataTradChineseInformal);
case ListStyle::TradChineseFormal:
return CJKIdeographicToText(aOrdinal, aResult, gDataTradChineseFormal);
case ListStyle::SimpChineseInformal:
return CJKIdeographicToText(aOrdinal, aResult, gDataSimpChineseInformal);
case ListStyle::SimpChineseFormal:
return CJKIdeographicToText(aOrdinal, aResult, gDataSimpChineseFormal);
case ListStyle::JapaneseInformal:
return CJKIdeographicToText(aOrdinal, aResult, gDataJapaneseInformal);
case ListStyle::JapaneseFormal:
return CJKIdeographicToText(aOrdinal, aResult, gDataJapaneseFormal);
case ListStyle::KoreanHangulFormal:
return CJKIdeographicToText(aOrdinal, aResult, gDataKoreanHangulFormal);
case ListStyle::KoreanHanjaInformal:
return CJKIdeographicToText(aOrdinal, aResult, gDataKoreanHanjaInformal);
case ListStyle::KoreanHanjaFormal:
return CJKIdeographicToText(aOrdinal, aResult, gDataKoreanHanjaFormal);
case ListStyle::Hebrew:
aIsRTL = true;
return HebrewToText(aOrdinal, aResult);
case ListStyle::EthiopicNumeric:
return EthiopicToText(aOrdinal, aResult);
default:
MOZ_ASSERT_UNREACHABLE("Unknown builtin counter style");
return false;
}
}
static constexpr BuiltinCounterStyle gBuiltinStyleTable[] = {
#define BUILTIN_COUNTER_STYLE(value_, atom_) \
{ListStyle::value_, nsGkAtoms::atom_},
#include "BuiltinCounterStyleList.h"
#undef BUILTIN_COUNTER_STYLE
};
#define BUILTIN_COUNTER_STYLE(value_, atom_) \
static_assert( \
gBuiltinStyleTable[static_cast<size_t>(ListStyle::value_)].GetStyle() == \
ListStyle::value_, \
"Builtin counter style " #atom_ " has unmatched index and value.");
#include "BuiltinCounterStyleList.h"
#undef BUILTIN_COUNTER_STYLE
class DependentBuiltinCounterStyle final : public BuiltinCounterStyle {
public:
DependentBuiltinCounterStyle(ListStyle aStyle, CounterStyleManager* aManager)
: BuiltinCounterStyle(gBuiltinStyleTable[static_cast<size_t>(aStyle)]),
mManager(aManager) {
NS_ASSERTION(IsDependentStyle(), "Not a dependent builtin style");
MOZ_ASSERT(!IsCustomStyle(), "Not a builtin style");
}
virtual CounterStyle* GetFallback() override;
void* operator new(size_t sz, nsPresContext* aPresContext) {
return aPresContext->PresShell()->AllocateByObjectID(
eArenaObjectID_DependentBuiltinCounterStyle, sz);
}
void Destroy() {
PresShell* presShell = mManager->PresContext()->PresShell();
this->~DependentBuiltinCounterStyle();
presShell->FreeByObjectID(eArenaObjectID_DependentBuiltinCounterStyle,
this);
}
private:
~DependentBuiltinCounterStyle() = default;
CounterStyleManager* mManager;
};
/* virtual */
CounterStyle* DependentBuiltinCounterStyle::GetFallback() {
switch (GetStyle()) {
case ListStyle::JapaneseInformal:
case ListStyle::JapaneseFormal:
case ListStyle::KoreanHangulFormal:
case ListStyle::KoreanHanjaInformal:
case ListStyle::KoreanHanjaFormal:
case ListStyle::SimpChineseInformal:
case ListStyle::SimpChineseFormal:
case ListStyle::TradChineseInformal:
case ListStyle::TradChineseFormal:
// These styles all have a larger range than cjk-decimal, so the
// only case fallback is accessed is that they are extended.
// Since extending styles will cache the data themselves, we need
// not cache it here.
return mManager->ResolveCounterStyle(nsGkAtoms::cjk_decimal);
default:
MOZ_ASSERT_UNREACHABLE("Not a valid dependent builtin style");
return BuiltinCounterStyle::GetFallback();
}
}
class CustomCounterStyle final : public CounterStyle {
public:
CustomCounterStyle(CounterStyleManager* aManager,
const StyleLockedCounterStyleRule* aRule)
: CounterStyle(ListStyle::Custom),
mManager(aManager),
mRule(aRule),
mRuleGeneration(Servo_CounterStyleRule_GetGeneration(aRule)),
mSystem(Servo_CounterStyleRule_GetSystem(aRule)),
mFlags(0),
mFallback(nullptr),
mSpeakAsCounter(nullptr),
mExtends(nullptr),
mExtendsRoot(nullptr) {}
// This method will clear all cached data in the style and update the
// generation number of the rule. It should be called when the rule of
// this style is changed.
void ResetCachedData();
// This method will reset all cached data which may depend on other
// counter style. It will reset all pointers to other counter styles.
// For counter style extends other, in addition, all fields will be
// reset to uninitialized state. This method should be called when any
// other counter style is added, removed, or changed.
void ResetDependentData();
const StyleLockedCounterStyleRule* GetRule() const { return mRule; }
uint32_t GetRuleGeneration() const { return mRuleGeneration; }
virtual void GetPrefix(nsAString& aResult) override;
virtual void GetSuffix(nsAString& aResult) override;
virtual void GetSpokenCounterText(CounterValue aOrdinal,
WritingMode aWritingMode,
nsAString& aResult,
bool& aIsBullet) override;
virtual bool IsBullet() override;
virtual void GetNegative(NegativeType& aResult) override;
virtual bool IsOrdinalInRange(CounterValue aOrdinal) override;
virtual bool IsOrdinalInAutoRange(CounterValue aOrdinal) override;
virtual void GetPad(PadType& aResult) override;
virtual CounterStyle* GetFallback() override;
virtual SpeakAs GetSpeakAs() override;
virtual bool UseNegativeSign() override;
virtual void CallFallbackStyle(CounterValue aOrdinal,
WritingMode aWritingMode, nsAString& aResult,
bool& aIsRTL) override;
virtual bool GetInitialCounterText(CounterValue aOrdinal,
WritingMode aWritingMode,
nsAString& aResult, bool& aIsRTL) override;
bool IsExtendsSystem() { return mSystem == StyleCounterSystem::Extends; }
void* operator new(size_t sz, nsPresContext* aPresContext) {
return aPresContext->PresShell()->AllocateByObjectID(
eArenaObjectID_CustomCounterStyle, sz);
}
void Destroy() {
PresShell* presShell = mManager->PresContext()->PresShell();
this->~CustomCounterStyle();
presShell->FreeByObjectID(eArenaObjectID_CustomCounterStyle, this);
}
private:
~CustomCounterStyle() = default;
Span<const nsString> GetSymbols();
Span<const AdditiveSymbol> GetAdditiveSymbols();
// The speak-as values of counter styles may form a loop, and the
// loops may have complex interaction with the loop formed by
// extending. To solve this problem, the computation of speak-as is
// divided into two phases:
// 1. figure out the raw value, by ComputeRawSpeakAs, and
// 2. eliminate loop, by ComputeSpeakAs.
// See comments before the definitions of these methods for details.
SpeakAs GetSpeakAsAutoValue();
void ComputeRawSpeakAs(SpeakAs& aSpeakAs, CounterStyle*& aSpeakAsCounter);
CounterStyle* ComputeSpeakAs();
CounterStyle* ComputeExtends();
CounterStyle* GetExtends();
CounterStyle* GetExtendsRoot();
// CounterStyleManager should always overlive any CounterStyle as it
// is owned by nsPresContext, and will be released after all nodes and
// frames are released.
CounterStyleManager* mManager;
RefPtr<const StyleLockedCounterStyleRule> mRule;
uint32_t mRuleGeneration;
StyleCounterSystem mSystem;
// GetSpeakAs will ensure that private member mSpeakAs is initialized before
// used
MOZ_INIT_OUTSIDE_CTOR SpeakAs mSpeakAs;
enum {
// loop detection
FLAG_EXTENDS_VISITED = 1 << 0,
FLAG_EXTENDS_LOOP = 1 << 1,
FLAG_SPEAKAS_VISITED = 1 << 2,
FLAG_SPEAKAS_LOOP = 1 << 3,
// field status
FLAG_NEGATIVE_INITED = 1 << 4,
FLAG_PREFIX_INITED = 1 << 5,
FLAG_SUFFIX_INITED = 1 << 6,
FLAG_PAD_INITED = 1 << 7,
FLAG_SPEAKAS_INITED = 1 << 8,
};
uint16_t mFlags;
// Fields below will be initialized when necessary.
StyleOwnedSlice<nsString> mSymbols;
StyleOwnedSlice<AdditiveSymbol> mAdditiveSymbols;
NegativeType mNegative;
nsString mPrefix, mSuffix;
PadType mPad;
// CounterStyleManager will guarantee that none of the pointers below
// refers to a freed CounterStyle. There are two possible cases where
// the manager will release its reference to a CounterStyle: 1. the
// manager itself is released, 2. a rule is invalidated. In the first
// case, all counter style are removed from the manager, and should
// also have been dereferenced from other objects. All styles will be
// released all together. In the second case, CounterStyleManager::
// NotifyRuleChanged will guarantee that all pointers will be reset
// before any CounterStyle is released.
CounterStyle* mFallback;
// This field refers to the last counter in a speak-as chain.
// That counter must not speak as another counter.
CounterStyle* mSpeakAsCounter;
CounterStyle* mExtends;
// This field refers to the last counter in the extends chain. The
// counter must be either a builtin style or a style whose system is
// not 'extends'.
CounterStyle* mExtendsRoot;
};
void CustomCounterStyle::ResetCachedData() {
mSymbols.Clear();
mAdditiveSymbols.Clear();
mFlags &= ~(FLAG_NEGATIVE_INITED | FLAG_PREFIX_INITED | FLAG_SUFFIX_INITED |
FLAG_PAD_INITED | FLAG_SPEAKAS_INITED);
mFallback = nullptr;
mSpeakAsCounter = nullptr;
mExtends = nullptr;
mExtendsRoot = nullptr;
mRuleGeneration = Servo_CounterStyleRule_GetGeneration(mRule);
}
void CustomCounterStyle::ResetDependentData() {
mFlags &= ~FLAG_SPEAKAS_INITED;
mSpeakAsCounter = nullptr;
mFallback = nullptr;
mExtends = nullptr;
mExtendsRoot = nullptr;
if (IsExtendsSystem()) {
mFlags &= ~(FLAG_NEGATIVE_INITED | FLAG_PREFIX_INITED | FLAG_SUFFIX_INITED |
FLAG_PAD_INITED);
}
}
/* virtual */
void CustomCounterStyle::GetPrefix(nsAString& aResult) {
if (!(mFlags & FLAG_PREFIX_INITED)) {
mFlags |= FLAG_PREFIX_INITED;
if (!Servo_CounterStyleRule_GetPrefix(mRule, &mPrefix)) {
if (IsExtendsSystem()) {
GetExtends()->GetPrefix(mPrefix);
} else {
mPrefix.Truncate();
}
}
}
aResult = mPrefix;
}
/* virtual */
void CustomCounterStyle::GetSuffix(nsAString& aResult) {
if (!(mFlags & FLAG_SUFFIX_INITED)) {
mFlags |= FLAG_SUFFIX_INITED;
if (!Servo_CounterStyleRule_GetSuffix(mRule, &mSuffix)) {
if (IsExtendsSystem()) {
GetExtends()->GetSuffix(mSuffix);
} else {
mSuffix.AssignLiteral(u". ");
}
}
}
aResult = mSuffix;
}
/* virtual */
void CustomCounterStyle::GetSpokenCounterText(CounterValue aOrdinal,
WritingMode aWritingMode,
nsAString& aResult,
bool& aIsBullet) {
if (GetSpeakAs() != SpeakAs::Other) {
CounterStyle::GetSpokenCounterText(aOrdinal, aWritingMode, aResult,
aIsBullet);
} else {
MOZ_ASSERT(mSpeakAsCounter,
"mSpeakAsCounter should have been initialized.");
mSpeakAsCounter->GetSpokenCounterText(aOrdinal, aWritingMode, aResult,
aIsBullet);
}
}
/* virtual */
bool CustomCounterStyle::IsBullet() {
switch (mSystem) {
case StyleCounterSystem::Cyclic:
// Only use ::-moz-list-bullet for cyclic system
return true;
case StyleCounterSystem::Extends:
return GetExtendsRoot()->IsBullet();
default:
return false;
}
}
/* virtual */
void CustomCounterStyle::GetNegative(NegativeType& aResult) {
if (!(mFlags & FLAG_NEGATIVE_INITED)) {
mFlags |= FLAG_NEGATIVE_INITED;
if (!Servo_CounterStyleRule_GetNegative(mRule, &mNegative.before,
&mNegative.after)) {
if (IsExtendsSystem()) {
GetExtends()->GetNegative(mNegative);
} else {
mNegative.before.AssignLiteral(u"-");
mNegative.after.Truncate();
}
}
}
aResult = mNegative;
}
/* virtual */
bool CustomCounterStyle::IsOrdinalInRange(CounterValue aOrdinal) {
auto inRange = Servo_CounterStyleRule_IsInRange(mRule, aOrdinal);
switch (inRange) {
case StyleIsOrdinalInRange::InRange:
return true;
case StyleIsOrdinalInRange::NotInRange:
return false;
case StyleIsOrdinalInRange::NoOrdinalSpecified:
if (IsExtendsSystem()) {
return GetExtends()->IsOrdinalInRange(aOrdinal);
}
break;
case StyleIsOrdinalInRange::Auto:
break;
default:
MOZ_ASSERT_UNREACHABLE("Unkown result from IsInRange?");
}
return IsOrdinalInAutoRange(aOrdinal);
}
/* virtual */
bool CustomCounterStyle::IsOrdinalInAutoRange(CounterValue aOrdinal) {
switch (mSystem) {
case StyleCounterSystem::Cyclic:
case StyleCounterSystem::Numeric:
case StyleCounterSystem::Fixed:
return true;
case StyleCounterSystem::Alphabetic:
case StyleCounterSystem::Symbolic:
return aOrdinal >= 1;
case StyleCounterSystem::Additive:
return aOrdinal >= 0;
case StyleCounterSystem::Extends:
return GetExtendsRoot()->IsOrdinalInAutoRange(aOrdinal);
default:
MOZ_ASSERT_UNREACHABLE("Invalid system for computing auto value.");
return false;
}
}
/* virtual */
void CustomCounterStyle::GetPad(PadType& aResult) {
if (!(mFlags & FLAG_PAD_INITED)) {
mFlags |= FLAG_PAD_INITED;
if (!Servo_CounterStyleRule_GetPad(mRule, &mPad.width, &mPad.symbol)) {
if (IsExtendsSystem()) {
GetExtends()->GetPad(mPad);
} else {
mPad.width = 0;
mPad.symbol.Truncate();
}
}
}
aResult = mPad;
}
/* virtual */
CounterStyle* CustomCounterStyle::GetFallback() {
if (!mFallback) {
mFallback = CounterStyleManager::GetDecimalStyle();
if (nsAtom* fallback = Servo_CounterStyleRule_GetFallback(mRule)) {
mFallback = mManager->ResolveCounterStyle(fallback);
} else if (IsExtendsSystem()) {
mFallback = GetExtends()->GetFallback();
}
}
return mFallback;
}
/* virtual */
SpeakAs CustomCounterStyle::GetSpeakAs() {
if (!(mFlags & FLAG_SPEAKAS_INITED)) {
ComputeSpeakAs();
}
return mSpeakAs;
}
/* virtual */
bool CustomCounterStyle::UseNegativeSign() {
if (mSystem == StyleCounterSystem::Extends) {
return GetExtendsRoot()->UseNegativeSign();
}
return SystemUsesNegativeSign(mSystem);
}
/* virtual */
void CustomCounterStyle::CallFallbackStyle(CounterValue aOrdinal,
WritingMode aWritingMode,
nsAString& aResult, bool& aIsRTL) {
CounterStyle* fallback = GetFallback();
// If it recursively falls back to this counter style again,
// it will then fallback to decimal to break the loop.
mFallback = CounterStyleManager::GetDecimalStyle();
fallback->GetCounterText(aOrdinal, aWritingMode, aResult, aIsRTL);
mFallback = fallback;
}
/* virtual */
bool CustomCounterStyle::GetInitialCounterText(CounterValue aOrdinal,
WritingMode aWritingMode,
nsAString& aResult,
bool& aIsRTL) {
switch (mSystem) {
case StyleCounterSystem::Cyclic:
return GetCyclicCounterText(aOrdinal, aResult, GetSymbols());
case StyleCounterSystem::Fixed: {
int32_t start = Servo_CounterStyleRule_GetFixedFirstValue(mRule);
return GetFixedCounterText(aOrdinal, aResult, start, GetSymbols());
}
case StyleCounterSystem::Symbolic:
return GetSymbolicCounterText(aOrdinal, aResult, GetSymbols());
case StyleCounterSystem::Alphabetic:
return GetAlphabeticCounterText(aOrdinal, aResult, GetSymbols());
case StyleCounterSystem::Numeric:
return GetNumericCounterText(aOrdinal, aResult, GetSymbols());
case StyleCounterSystem::Additive:
return GetAdditiveCounterText(aOrdinal, aResult, GetAdditiveSymbols());
case StyleCounterSystem::Extends:
return GetExtendsRoot()->GetInitialCounterText(aOrdinal, aWritingMode,
aResult, aIsRTL);
default:
MOZ_ASSERT_UNREACHABLE("Invalid system.");
return false;
}
}
Span<const nsString> CustomCounterStyle::GetSymbols() {
if (mSymbols.IsEmpty()) {
Servo_CounterStyleRule_GetSymbols(mRule, &mSymbols);
}
return mSymbols.AsSpan();
}
Span<const AdditiveSymbol> CustomCounterStyle::GetAdditiveSymbols() {
if (mAdditiveSymbols.IsEmpty()) {
Servo_CounterStyleRule_GetAdditiveSymbols(mRule, &mAdditiveSymbols);
}
return mAdditiveSymbols.AsSpan();
}
// This method is used to provide the computed value for 'auto'.
SpeakAs CustomCounterStyle::GetSpeakAsAutoValue() {
auto system = mSystem;
if (IsExtendsSystem()) {
CounterStyle* root = GetExtendsRoot();
if (!root->IsCustomStyle()) {
// It is safe to call GetSpeakAs on non-custom style.
return root->GetSpeakAs();
}
system = static_cast<CustomCounterStyle*>(root)->mSystem;
}
return GetDefaultSpeakAsForSystem(system);
}
// This method corresponds to the first stage of computation of the
// value of speak-as. It will extract the value from the rule and
// possibly recursively call itself on the extended style to figure
// out the raw value. To keep things clear, this method is designed to
// have no side effects (but functions it calls may still affect other
// fields in the style.)
void CustomCounterStyle::ComputeRawSpeakAs(SpeakAs& aSpeakAs,
CounterStyle*& aSpeakAsCounter) {
NS_ASSERTION(!(mFlags & FLAG_SPEAKAS_INITED),
"ComputeRawSpeakAs is called with speak-as inited.");
auto speakAs = StyleCounterSpeakAs::None();
Servo_CounterStyleRule_GetSpeakAs(mRule, &speakAs);
switch (speakAs.tag) {
case StyleCounterSpeakAs::Tag::Auto:
aSpeakAs = GetSpeakAsAutoValue();
break;
case StyleCounterSpeakAs::Tag::Bullets:
aSpeakAs = SpeakAs::Bullets;
break;
case StyleCounterSpeakAs::Tag::Numbers:
aSpeakAs = SpeakAs::Numbers;
break;
case StyleCounterSpeakAs::Tag::Words:
aSpeakAs = SpeakAs::Words;
break;
case StyleCounterSpeakAs::Tag::Ident:
aSpeakAs = SpeakAs::Other;
aSpeakAsCounter = mManager->ResolveCounterStyle(speakAs.AsIdent());
break;
case StyleCounterSpeakAs::Tag::None: {
if (!IsExtendsSystem()) {
aSpeakAs = GetSpeakAsAutoValue();
} else {
CounterStyle* extended = GetExtends();
if (!extended->IsCustomStyle()) {
// It is safe to call GetSpeakAs on non-custom style.
aSpeakAs = extended->GetSpeakAs();
} else {
CustomCounterStyle* custom =
static_cast<CustomCounterStyle*>(extended);
if (!(custom->mFlags & FLAG_SPEAKAS_INITED)) {
custom->ComputeRawSpeakAs(aSpeakAs, aSpeakAsCounter);
} else {
aSpeakAs = custom->mSpeakAs;
aSpeakAsCounter = custom->mSpeakAsCounter;
}
}
}
break;
}
default:
MOZ_ASSERT_UNREACHABLE("Invalid speak-as value");
}
}
// This method corresponds to the second stage of getting speak-as
// related values. It will recursively figure out the final value of
// mSpeakAs and mSpeakAsCounter. This method returns nullptr if the
// caller is in a loop, and the root counter style in the chain
// otherwise. It use the same loop detection algorithm as
// CustomCounterStyle::ComputeExtends, see comments before that
// method for more details.
CounterStyle* CustomCounterStyle::ComputeSpeakAs() {
if (mFlags & FLAG_SPEAKAS_INITED) {
if (mSpeakAs == SpeakAs::Other) {
return mSpeakAsCounter;
}
return this;
}
if (mFlags & FLAG_SPEAKAS_VISITED) {
// loop detected
mFlags |= FLAG_SPEAKAS_LOOP;
return nullptr;
}
CounterStyle* speakAsCounter;
ComputeRawSpeakAs(mSpeakAs, speakAsCounter);
bool inLoop = false;
if (mSpeakAs != SpeakAs::Other) {
mSpeakAsCounter = nullptr;
} else if (!speakAsCounter->IsCustomStyle()) {
mSpeakAsCounter = speakAsCounter;
} else {
mFlags |= FLAG_SPEAKAS_VISITED;
CounterStyle* target =
static_cast<CustomCounterStyle*>(speakAsCounter)->ComputeSpeakAs();
mFlags &= ~FLAG_SPEAKAS_VISITED;
if (target) {
NS_ASSERTION(!(mFlags & FLAG_SPEAKAS_LOOP),
"Invalid state for speak-as loop detecting");
mSpeakAsCounter = target;
} else {
mSpeakAs = GetSpeakAsAutoValue();
mSpeakAsCounter = nullptr;
if (mFlags & FLAG_SPEAKAS_LOOP) {
mFlags &= ~FLAG_SPEAKAS_LOOP;
} else {
inLoop = true;
}
}
}
mFlags |= FLAG_SPEAKAS_INITED;
if (inLoop) {
return nullptr;
}
return mSpeakAsCounter ? mSpeakAsCounter : this;
}
// This method will recursively figure out mExtends in the whole chain.
// It will return nullptr if the caller is in a loop, and return this
// otherwise. To detect the loop, this method marks the style VISITED
// before the recursive call. When a VISITED style is reached again, the
// loop is detected, and flag LOOP will be marked on the first style in
// loop. mExtends of all counter styles in loop will be set to decimal
// according to the spec.
CounterStyle* CustomCounterStyle::ComputeExtends() {
if (!IsExtendsSystem() || mExtends) {
return this;
}
if (mFlags & FLAG_EXTENDS_VISITED) {
// loop detected
mFlags |= FLAG_EXTENDS_LOOP;
return nullptr;
}
nsAtom* extended = Servo_CounterStyleRule_GetExtended(mRule);
CounterStyle* nextCounter = mManager->ResolveCounterStyle(extended);
CounterStyle* target = nextCounter;
if (nextCounter->IsCustomStyle()) {
mFlags |= FLAG_EXTENDS_VISITED;
target = static_cast<CustomCounterStyle*>(nextCounter)->ComputeExtends();
mFlags &= ~FLAG_EXTENDS_VISITED;
}
if (target) {
NS_ASSERTION(!(mFlags & FLAG_EXTENDS_LOOP),
"Invalid state for extends loop detecting");
mExtends = nextCounter;
return this;
} else {
mExtends = CounterStyleManager::GetDecimalStyle();
if (mFlags & FLAG_EXTENDS_LOOP) {
mFlags &= ~FLAG_EXTENDS_LOOP;
return this;
} else {
return nullptr;
}
}
}
CounterStyle* CustomCounterStyle::GetExtends() {
if (!mExtends) {
// Any extends loop will be eliminated in the method below.
ComputeExtends();
}
return mExtends;
}
CounterStyle* CustomCounterStyle::GetExtendsRoot() {
if (!mExtendsRoot) {
CounterStyle* extended = GetExtends();
mExtendsRoot = extended;
if (extended->IsCustomStyle()) {
CustomCounterStyle* custom = static_cast<CustomCounterStyle*>(extended);
if (custom->IsExtendsSystem()) {
// This will make mExtendsRoot in the whole extends chain be
// set recursively, which could save work when part of a chain
// is shared by multiple counter styles.
mExtendsRoot = custom->GetExtendsRoot();
}
}
}
return mExtendsRoot;
}
AnonymousCounterStyle::AnonymousCounterStyle(const nsAString& aContent)
: CounterStyle(ListStyle::Custom),
mSingleString(true),
mSymbolsType(StyleSymbolsType::Cyclic) {
mSymbols.SetCapacity(1);
mSymbols.AppendElement(aContent);
}
AnonymousCounterStyle::AnonymousCounterStyle(StyleSymbolsType aType,
nsTArray<nsString> aSymbols)
: CounterStyle(ListStyle::Custom),
mSingleString(false),
mSymbolsType(aType),
mSymbols(std::move(aSymbols)) {}
/* virtual */
void AnonymousCounterStyle::GetPrefix(nsAString& aResult) {
aResult.Truncate();
}
/* virtual */
void AnonymousCounterStyle::GetSuffix(nsAString& aResult) {
if (IsSingleString()) {
aResult.Truncate();
} else {
aResult = ' ';
}
}
/* virtual */
bool AnonymousCounterStyle::IsBullet() {
// Only use ::-moz-list-bullet for cyclic system
return mSymbolsType == StyleSymbolsType::Cyclic;
}
/* virtual */
void AnonymousCounterStyle::GetNegative(NegativeType& aResult) {
aResult.before.AssignLiteral(u"-");
aResult.after.Truncate();
}
/* virtual */
bool AnonymousCounterStyle::IsOrdinalInRange(CounterValue aOrdinal) {
switch (mSymbolsType) {
case StyleSymbolsType::Cyclic:
case StyleSymbolsType::Numeric:
case StyleSymbolsType::Fixed:
return true;
case StyleSymbolsType::Alphabetic:
case StyleSymbolsType::Symbolic:
return aOrdinal >= 1;
default:
MOZ_ASSERT_UNREACHABLE("Invalid system.");
return false;
}
}
/* virtual */
bool AnonymousCounterStyle::IsOrdinalInAutoRange(CounterValue aOrdinal) {
return AnonymousCounterStyle::IsOrdinalInRange(aOrdinal);
}
/* virtual */
void AnonymousCounterStyle::GetPad(PadType& aResult) {
aResult.width = 0;
aResult.symbol.Truncate();
}
/* virtual */
CounterStyle* AnonymousCounterStyle::GetFallback() {
return CounterStyleManager::GetDecimalStyle();
}
StyleCounterSystem AnonymousCounterStyle::GetSystem() const {
switch (mSymbolsType) {
case StyleSymbolsType::Cyclic:
return StyleCounterSystem::Cyclic;
case StyleSymbolsType::Numeric:
return StyleCounterSystem::Numeric;
case StyleSymbolsType::Fixed:
return StyleCounterSystem::Fixed;
case StyleSymbolsType::Alphabetic:
return StyleCounterSystem::Alphabetic;
case StyleSymbolsType::Symbolic:
return StyleCounterSystem::Symbolic;
}
MOZ_ASSERT_UNREACHABLE("Unknown symbols() type");
return StyleCounterSystem::Cyclic;
}
/* virtual */
SpeakAs AnonymousCounterStyle::GetSpeakAs() {
return GetDefaultSpeakAsForSystem(GetSystem());
}
/* virtual */
bool AnonymousCounterStyle::UseNegativeSign() {
return SystemUsesNegativeSign(GetSystem());
}
/* virtual */
bool AnonymousCounterStyle::GetInitialCounterText(CounterValue aOrdinal,
WritingMode aWritingMode,
nsAString& aResult,
bool& aIsRTL) {
switch (mSymbolsType) {
case StyleSymbolsType::Cyclic:
return GetCyclicCounterText(aOrdinal, aResult, mSymbols);
case StyleSymbolsType::Numeric:
return GetNumericCounterText(aOrdinal, aResult, mSymbols);
case StyleSymbolsType::Fixed:
return GetFixedCounterText(aOrdinal, aResult, 1, mSymbols);
case StyleSymbolsType::Alphabetic:
return GetAlphabeticCounterText(aOrdinal, aResult, mSymbols);
case StyleSymbolsType::Symbolic:
return GetSymbolicCounterText(aOrdinal, aResult, mSymbols);
}
MOZ_ASSERT_UNREACHABLE("Invalid system.");
return false;
}
bool CounterStyle::IsDependentStyle() const {
switch (mStyle) {
// CustomCounterStyle
case ListStyle::Custom:
// DependentBuiltinCounterStyle
case ListStyle::JapaneseInformal:
case ListStyle::JapaneseFormal:
case ListStyle::KoreanHangulFormal:
case ListStyle::KoreanHanjaInformal:
case ListStyle::KoreanHanjaFormal:
case ListStyle::SimpChineseInformal:
case ListStyle::SimpChineseFormal:
case ListStyle::TradChineseInformal:
case ListStyle::TradChineseFormal:
return true;
// BuiltinCounterStyle
default:
return false;
}
}
void CounterStyle::GetCounterText(CounterValue aOrdinal,
WritingMode aWritingMode, nsAString& aResult,
bool& aIsRTL) {
bool success = IsOrdinalInRange(aOrdinal);
aIsRTL = false;
if (success) {
// generate initial representation
bool useNegativeSign = UseNegativeSign();
nsAutoString initialText;
CounterValue ordinal;
if (!useNegativeSign) {
ordinal = aOrdinal;
} else {
CheckedInt<CounterValue> absolute(Abs(aOrdinal));
ordinal = absolute.isValid() ? absolute.value()
: std::numeric_limits<CounterValue>::max();
}
success = GetInitialCounterText(ordinal, aWritingMode, initialText, aIsRTL);
// add pad & negative, build the final result
if (success) {
aResult.Truncate();
if (useNegativeSign && aOrdinal < 0) {
NegativeType negative;
GetNegative(negative);
aResult.Append(negative.before);
// There is nothing between the suffix part of negative and initial
// representation, so we append it directly here.
initialText.Append(negative.after);
}
PadType pad;
GetPad(pad);
int32_t diff =
pad.width -
narrow_cast<int32_t>(unicode::CountGraphemeClusters(initialText) +
unicode::CountGraphemeClusters(aResult));
if (diff > 0) {
auto length = pad.symbol.Length();
if (diff > LENGTH_LIMIT || length > LENGTH_LIMIT ||
diff * length > LENGTH_LIMIT) {
success = false;
} else if (length > 0) {
for (int32_t i = 0; i < diff; ++i) {
aResult.Append(pad.symbol);
}
}
}
if (success) {
aResult.Append(initialText);
}
}
}
if (!success) {
CallFallbackStyle(aOrdinal, aWritingMode, aResult, aIsRTL);
}
}
/* virtual */
void CounterStyle::GetSpokenCounterText(CounterValue aOrdinal,
WritingMode aWritingMode,
nsAString& aResult, bool& aIsBullet) {
bool isRTL; // we don't care about direction for spoken text
aIsBullet = false;
switch (GetSpeakAs()) {
case SpeakAs::Bullets:
aResult.Assign(kDiscCharacter);
aIsBullet = true;
break;
case SpeakAs::Numbers:
DecimalToText(aOrdinal, aResult);
break;
case SpeakAs::Spellout:
// we currently do not actually support 'spell-out',
// so 'words' is used instead.
case SpeakAs::Words:
GetCounterText(aOrdinal, WritingMode(), aResult, isRTL);
break;
case SpeakAs::Other:
// This should be processed by CustomCounterStyle
MOZ_ASSERT_UNREACHABLE("Invalid speak-as value");
break;
default:
MOZ_ASSERT_UNREACHABLE("Unknown speak-as value");
break;
}
}
/* virtual */
void CounterStyle::CallFallbackStyle(CounterValue aOrdinal,
WritingMode aWritingMode,
nsAString& aResult, bool& aIsRTL) {
GetFallback()->GetCounterText(aOrdinal, aWritingMode, aResult, aIsRTL);
}
CounterStyleManager::CounterStyleManager(nsPresContext* aPresContext)
: mPresContext(aPresContext) {
// Insert the static styles into cache table
mStyles.InsertOrUpdate(nsGkAtoms::none, GetNoneStyle());
mStyles.InsertOrUpdate(nsGkAtoms::decimal, GetDecimalStyle());
mStyles.InsertOrUpdate(nsGkAtoms::disc, GetDiscStyle());
}
CounterStyleManager::~CounterStyleManager() {
MOZ_ASSERT(!mPresContext, "Disconnect should have been called");
}
void CounterStyleManager::DestroyCounterStyle(CounterStyle* aCounterStyle) {
if (aCounterStyle->IsCustomStyle()) {
MOZ_ASSERT(!aCounterStyle->AsAnonymous(),
"Anonymous counter styles "
"are not managed by CounterStyleManager");
static_cast<CustomCounterStyle*>(aCounterStyle)->Destroy();
} else if (aCounterStyle->IsDependentStyle()) {
static_cast<DependentBuiltinCounterStyle*>(aCounterStyle)->Destroy();
} else {
MOZ_ASSERT_UNREACHABLE("Builtin counter styles should not be destroyed");
}
}
void CounterStyleManager::Disconnect() {
CleanRetiredStyles();
for (CounterStyle* style : mStyles.Values()) {
if (style->IsDependentStyle()) {
DestroyCounterStyle(style);
}
}
mStyles.Clear();
mPresContext = nullptr;
}
CounterStyle* CounterStyleManager::ResolveCounterStyle(nsAtom* aName) {
MOZ_ASSERT(NS_IsMainThread());
CounterStyle* data = GetCounterStyle(aName);
if (data) {
return data;
}
// Names are compared case-sensitively here. Predefined names should
// have been lowercased by the parser.
ServoStyleSet* styleSet = mPresContext->StyleSet();
auto* rule = styleSet->CounterStyleRuleForName(aName);
if (rule) {
MOZ_ASSERT(Servo_CounterStyleRule_GetName(rule) == aName);
data = new (mPresContext) CustomCounterStyle(this, rule);
} else {
for (const BuiltinCounterStyle& item : gBuiltinStyleTable) {
if (item.GetStyleName() == aName) {
const auto style = item.GetStyle();
data = item.IsDependentStyle()
? new (mPresContext)
DependentBuiltinCounterStyle(style, this)
: GetBuiltinStyle(style);
break;
}
}
}
if (!data) {
data = GetDecimalStyle();
}
mStyles.InsertOrUpdate(aName, data);
return data;
}
/* static */
CounterStyle* CounterStyleManager::GetBuiltinStyle(ListStyle aStyle) {
MOZ_ASSERT(size_t(aStyle) < ArrayLength(gBuiltinStyleTable),
"Require a valid builtin style constant");
MOZ_ASSERT(!gBuiltinStyleTable[size_t(aStyle)].IsDependentStyle(),
"Cannot get dependent builtin style");
// No method of BuiltinCounterStyle mutates the struct itself, so it
// should be fine to cast const away.
return const_cast<BuiltinCounterStyle*>(&gBuiltinStyleTable[size_t(aStyle)]);
}
bool CounterStyleManager::NotifyRuleChanged() {
bool changed = false;
for (auto iter = mStyles.Iter(); !iter.Done(); iter.Next()) {
CounterStyle* style = iter.Data();
bool toBeUpdated = false;
bool toBeRemoved = false;
ServoStyleSet* styleSet = mPresContext->StyleSet();
auto* newRule = styleSet->CounterStyleRuleForName(iter.Key());
if (!newRule) {
if (style->IsCustomStyle()) {
toBeRemoved = true;
}
} else {
if (!style->IsCustomStyle()) {
toBeRemoved = true;
} else {
auto custom = static_cast<CustomCounterStyle*>(style);
if (custom->GetRule() != newRule) {
toBeRemoved = true;
} else {
auto generation = Servo_CounterStyleRule_GetGeneration(newRule);
if (custom->GetRuleGeneration() != generation) {
toBeUpdated = true;
custom->ResetCachedData();
}
}
}
}
changed = changed || toBeUpdated || toBeRemoved;
if (toBeRemoved) {
if (style->IsDependentStyle()) {
// Add object to retired list so we can clean them up later.
mRetiredStyles.AppendElement(style);
}
iter.Remove();
}
}
if (changed) {
for (CounterStyle* style : mStyles.Values()) {
if (style->IsCustomStyle()) {
CustomCounterStyle* custom = static_cast<CustomCounterStyle*>(style);
custom->ResetDependentData();
}
// There is no dependent data cached in DependentBuiltinCounterStyle
// instances, so we don't need to reset their data.
}
}
return changed;
}
void CounterStyleManager::CleanRetiredStyles() {
nsTArray<CounterStyle*> list(std::move(mRetiredStyles));
for (CounterStyle* style : list) {
DestroyCounterStyle(style);
}
}
} // namespace mozilla
View git blame Copy permalink