mirror of
https://github.com/facebook/react-native.git
synced 2026-11-18 20:19:07 +00:00
Replace CSSSyntaxParser with CSSValueParser in data type sinks
Summary: Previously, CSSDataTypeParser sinks received a raw CSSSyntaxParser& reference, which exposed low-level tokenization APIs (consumeComponentValue with lambdas, consumeToken, etc.) that data type parsers should not use directly. This made it unclear what operations are appropriate when implementing a new CSS data type. This change promotes detail::CSSValueParser to a public CSSValueParser class that wraps CSSSyntaxParser and exposes only value-level parsing operations: parseNextValue, peekNextValue, consumeWhitespace, consumeDelimiter, isFinished, peekNextTokenIs, and saveState/restoreState for lookahead patterns. All CSSDataTypeParser sink methods now receive CSSValueParser& instead of CSSSyntaxParser&, and use parser.parseNextValue<T>() instead of the free function parseNextCSSValue<T>(parser). Direct consumeComponentValue calls in gradient parsers (CSSBackgroundImage.h) are replaced with keyword set parsing via parseNextValue<KeywordEnum>, with new To/At keywords added to CSSKeyword. The free functions parseCSSProperty, parseNextCSSValue, and peekNextCSSValue remain as convenience wrappers for backward compatibility. Changelog: [Internal] Reviewed By: jorge-cab Differential Revision: D94357104 fbshipit-source-id: 3ba2ba236c9c6e82673e2759a6c7af803599b7f0
This commit is contained in:
1 parent
36212c248b
commit
4d66a26a67
15 files changed
+310
-308
No files matched your search
@@ -25,6 +25,37 @@
|
||||
|
||||
namespace facebook::react {
|
||||
|
||||
enum class CSSGradientToKeyword : std::underlying_type_t<CSSKeyword> {
|
||||
To = to_underlying(CSSKeyword::To),
|
||||
};
|
||||
|
||||
static_assert(CSSDataType<CSSGradientToKeyword>);
|
||||
|
||||
enum class CSSGradientDirectionKeyword : std::underlying_type_t<CSSKeyword> {
|
||||
Top = to_underlying(CSSKeyword::Top),
|
||||
Bottom = to_underlying(CSSKeyword::Bottom),
|
||||
Left = to_underlying(CSSKeyword::Left),
|
||||
Right = to_underlying(CSSKeyword::Right),
|
||||
};
|
||||
|
||||
static_assert(CSSDataType<CSSGradientDirectionKeyword>);
|
||||
|
||||
enum class CSSGradientAtKeyword : std::underlying_type_t<CSSKeyword> {
|
||||
At = to_underlying(CSSKeyword::At),
|
||||
};
|
||||
|
||||
static_assert(CSSDataType<CSSGradientAtKeyword>);
|
||||
|
||||
enum class CSSGradientPositionKeyword : std::underlying_type_t<CSSKeyword> {
|
||||
Top = to_underlying(CSSKeyword::Top),
|
||||
Bottom = to_underlying(CSSKeyword::Bottom),
|
||||
Left = to_underlying(CSSKeyword::Left),
|
||||
Right = to_underlying(CSSKeyword::Right),
|
||||
Center = to_underlying(CSSKeyword::Center),
|
||||
};
|
||||
|
||||
static_assert(CSSDataType<CSSGradientPositionKeyword>);
|
||||
|
||||
enum class CSSLinearGradientDirectionKeyword : uint8_t {
|
||||
ToTopLeft,
|
||||
ToTopRight,
|
||||
@@ -41,115 +72,81 @@ struct CSSLinearGradientDirection {
|
||||
|
||||
template <>
|
||||
struct CSSDataTypeParser<CSSLinearGradientDirection> {
|
||||
static constexpr auto consume(CSSSyntaxParser &parser) -> std::optional<CSSLinearGradientDirection>
|
||||
static constexpr auto consume(CSSValueParser &parser) -> std::optional<CSSLinearGradientDirection>
|
||||
{
|
||||
return parseLinearGradientDirection(parser);
|
||||
}
|
||||
|
||||
private:
|
||||
static constexpr std::optional<CSSLinearGradientDirection> parseLinearGradientDirection(CSSSyntaxParser &parser)
|
||||
static constexpr std::optional<CSSLinearGradientDirection> parseLinearGradientDirection(CSSValueParser &parser)
|
||||
{
|
||||
auto angle = parseNextCSSValue<CSSAngle>(parser);
|
||||
auto angle = parser.parseNextValue<CSSAngle>();
|
||||
if (std::holds_alternative<CSSAngle>(angle)) {
|
||||
return CSSLinearGradientDirection{std::get<CSSAngle>(angle)};
|
||||
}
|
||||
auto toResult = parser.consumeComponentValue<bool>([](const CSSPreservedToken &token) -> bool {
|
||||
return token.type() == CSSTokenType::Ident && fnv1aLowercase(token.stringValue()) == fnv1a("to");
|
||||
});
|
||||
|
||||
if (!toResult) {
|
||||
auto toResult = parser.parseNextValue<CSSGradientToKeyword>();
|
||||
if (!std::holds_alternative<CSSGradientToKeyword>(toResult)) {
|
||||
// no direction found, default to 180 degrees (to bottom)
|
||||
return CSSLinearGradientDirection{CSSAngle{180.0f}};
|
||||
}
|
||||
|
||||
parser.consumeWhitespace();
|
||||
parser.syntaxParser().consumeWhitespace();
|
||||
|
||||
std::optional<CSSKeyword> primaryDir;
|
||||
auto primaryResult = parser.consumeComponentValue<std::optional<CSSKeyword>>(
|
||||
[](const CSSPreservedToken &token) -> std::optional<CSSKeyword> {
|
||||
if (token.type() == CSSTokenType::Ident) {
|
||||
switch (fnv1aLowercase(token.stringValue())) {
|
||||
case fnv1a("top"):
|
||||
return CSSKeyword::Top;
|
||||
case fnv1a("bottom"):
|
||||
return CSSKeyword::Bottom;
|
||||
case fnv1a("left"):
|
||||
return CSSKeyword::Left;
|
||||
case fnv1a("right"):
|
||||
return CSSKeyword::Right;
|
||||
}
|
||||
}
|
||||
return {};
|
||||
});
|
||||
|
||||
if (!primaryResult) {
|
||||
auto primaryResult = parser.parseNextValue<CSSGradientDirectionKeyword>();
|
||||
if (std::holds_alternative<std::monostate>(primaryResult)) {
|
||||
return {};
|
||||
}
|
||||
auto primaryDir = std::get<CSSGradientDirectionKeyword>(primaryResult);
|
||||
|
||||
primaryDir = primaryResult;
|
||||
parser.consumeWhitespace();
|
||||
parser.syntaxParser().consumeWhitespace();
|
||||
|
||||
std::optional<CSSKeyword> secondaryDir;
|
||||
auto secondaryResult = parser.consumeComponentValue<std::optional<CSSKeyword>>(
|
||||
[&](const CSSPreservedToken &token) -> std::optional<CSSKeyword> {
|
||||
if (token.type() == CSSTokenType::Ident) {
|
||||
auto hash = fnv1aLowercase(token.stringValue());
|
||||
// validate compatible combinations
|
||||
if (primaryDir == CSSKeyword::Top || primaryDir == CSSKeyword::Bottom) {
|
||||
if (hash == fnv1a("left")) {
|
||||
return CSSKeyword::Left;
|
||||
}
|
||||
if (hash == fnv1a("right")) {
|
||||
return CSSKeyword::Right;
|
||||
}
|
||||
}
|
||||
if (primaryDir == CSSKeyword::Left || primaryDir == CSSKeyword::Right) {
|
||||
if (hash == fnv1a("top")) {
|
||||
return CSSKeyword::Top;
|
||||
}
|
||||
if (hash == fnv1a("bottom")) {
|
||||
return CSSKeyword::Bottom;
|
||||
}
|
||||
}
|
||||
}
|
||||
return {};
|
||||
});
|
||||
|
||||
if (secondaryResult) {
|
||||
secondaryDir = secondaryResult;
|
||||
auto secondaryPeek = parser.peekNextValue<CSSGradientDirectionKeyword>();
|
||||
std::optional<CSSGradientDirectionKeyword> secondaryDir;
|
||||
if (std::holds_alternative<CSSGradientDirectionKeyword>(secondaryPeek)) {
|
||||
auto kw = std::get<CSSGradientDirectionKeyword>(secondaryPeek);
|
||||
bool isCompatible = false;
|
||||
if (primaryDir == CSSGradientDirectionKeyword::Top || primaryDir == CSSGradientDirectionKeyword::Bottom) {
|
||||
isCompatible = (kw == CSSGradientDirectionKeyword::Left || kw == CSSGradientDirectionKeyword::Right);
|
||||
} else if (primaryDir == CSSGradientDirectionKeyword::Left || primaryDir == CSSGradientDirectionKeyword::Right) {
|
||||
isCompatible = (kw == CSSGradientDirectionKeyword::Top || kw == CSSGradientDirectionKeyword::Bottom);
|
||||
}
|
||||
if (isCompatible) {
|
||||
parser.parseNextValue<CSSGradientDirectionKeyword>();
|
||||
secondaryDir = kw;
|
||||
}
|
||||
}
|
||||
|
||||
if (primaryDir == CSSKeyword::Top) {
|
||||
if (secondaryDir == CSSKeyword::Left) {
|
||||
if (primaryDir == CSSGradientDirectionKeyword::Top) {
|
||||
if (secondaryDir == CSSGradientDirectionKeyword::Left) {
|
||||
return CSSLinearGradientDirection{CSSLinearGradientDirectionKeyword::ToTopLeft};
|
||||
} else if (secondaryDir == CSSKeyword::Right) {
|
||||
} else if (secondaryDir == CSSGradientDirectionKeyword::Right) {
|
||||
return CSSLinearGradientDirection{CSSLinearGradientDirectionKeyword::ToTopRight};
|
||||
} else {
|
||||
// "to top" = 0 degrees
|
||||
return CSSLinearGradientDirection{CSSAngle{0.0f}};
|
||||
}
|
||||
} else if (primaryDir == CSSKeyword::Bottom) {
|
||||
if (secondaryDir == CSSKeyword::Left) {
|
||||
} else if (primaryDir == CSSGradientDirectionKeyword::Bottom) {
|
||||
if (secondaryDir == CSSGradientDirectionKeyword::Left) {
|
||||
return CSSLinearGradientDirection{CSSLinearGradientDirectionKeyword::ToBottomLeft};
|
||||
} else if (secondaryDir == CSSKeyword::Right) {
|
||||
} else if (secondaryDir == CSSGradientDirectionKeyword::Right) {
|
||||
return CSSLinearGradientDirection{CSSLinearGradientDirectionKeyword::ToBottomRight};
|
||||
} else {
|
||||
// "to bottom" = 180 degrees
|
||||
return CSSLinearGradientDirection{CSSAngle{180.0f}};
|
||||
}
|
||||
} else if (primaryDir == CSSKeyword::Left) {
|
||||
if (secondaryDir == CSSKeyword::Top) {
|
||||
} else if (primaryDir == CSSGradientDirectionKeyword::Left) {
|
||||
if (secondaryDir == CSSGradientDirectionKeyword::Top) {
|
||||
return CSSLinearGradientDirection{CSSLinearGradientDirectionKeyword::ToTopLeft};
|
||||
} else if (secondaryDir == CSSKeyword::Bottom) {
|
||||
} else if (secondaryDir == CSSGradientDirectionKeyword::Bottom) {
|
||||
return CSSLinearGradientDirection{CSSLinearGradientDirectionKeyword::ToBottomLeft};
|
||||
} else {
|
||||
// "to left" = 270 degrees
|
||||
return CSSLinearGradientDirection{CSSAngle{270.0f}};
|
||||
}
|
||||
} else if (primaryDir == CSSKeyword::Right) {
|
||||
if (secondaryDir == CSSKeyword::Top) {
|
||||
} else if (primaryDir == CSSGradientDirectionKeyword::Right) {
|
||||
if (secondaryDir == CSSGradientDirectionKeyword::Top) {
|
||||
return CSSLinearGradientDirection{CSSLinearGradientDirectionKeyword::ToTopRight};
|
||||
} else if (secondaryDir == CSSKeyword::Bottom) {
|
||||
} else if (secondaryDir == CSSGradientDirectionKeyword::Bottom) {
|
||||
return CSSLinearGradientDirection{CSSLinearGradientDirectionKeyword::ToBottomRight};
|
||||
} else {
|
||||
// "to right" = 90 degrees
|
||||
@@ -174,15 +171,15 @@ struct CSSColorHint {
|
||||
|
||||
template <>
|
||||
struct CSSDataTypeParser<CSSColorHint> {
|
||||
static auto consume(CSSSyntaxParser &parser) -> std::optional<CSSColorHint>
|
||||
static auto consume(CSSValueParser &parser) -> std::optional<CSSColorHint>
|
||||
{
|
||||
return parseCSSColorHint(parser);
|
||||
}
|
||||
|
||||
private:
|
||||
static std::optional<CSSColorHint> parseCSSColorHint(CSSSyntaxParser &parser)
|
||||
static std::optional<CSSColorHint> parseCSSColorHint(CSSValueParser &parser)
|
||||
{
|
||||
auto position = parseNextCSSValue<CSSLengthPercentage>(parser);
|
||||
auto position = parser.parseNextValue<CSSLengthPercentage>();
|
||||
if (std::holds_alternative<CSSLength>(position)) {
|
||||
return CSSColorHint{std::get<CSSLength>(position)};
|
||||
} else if (std::holds_alternative<CSSPercentage>(position)) {
|
||||
@@ -235,15 +232,15 @@ struct CSSColorStop {
|
||||
|
||||
template <>
|
||||
struct CSSDataTypeParser<CSSColorStop> {
|
||||
static constexpr auto consume(CSSSyntaxParser &parser) -> std::optional<CSSColorStop>
|
||||
static constexpr auto consume(CSSValueParser &parser) -> std::optional<CSSColorStop>
|
||||
{
|
||||
return parseCSSColorStop(parser);
|
||||
}
|
||||
|
||||
private:
|
||||
static constexpr std::optional<CSSColorStop> parseCSSColorStop(CSSSyntaxParser &parser)
|
||||
static constexpr std::optional<CSSColorStop> parseCSSColorStop(CSSValueParser &parser)
|
||||
{
|
||||
auto color = parseNextCSSValue<CSSColor>(parser);
|
||||
auto color = parser.parseNextValue<CSSColor>();
|
||||
if (!std::holds_alternative<CSSColor>(color)) {
|
||||
return {};
|
||||
}
|
||||
@@ -251,7 +248,7 @@ struct CSSDataTypeParser<CSSColorStop> {
|
||||
CSSColorStop colorStop;
|
||||
colorStop.color = std::get<CSSColor>(color);
|
||||
|
||||
auto startPosition = parseNextCSSValue<CSSLengthPercentage>(parser, CSSDelimiter::Whitespace);
|
||||
auto startPosition = parser.parseNextValue<CSSLengthPercentage>(CSSDelimiter::Whitespace);
|
||||
if (std::holds_alternative<CSSLength>(startPosition)) {
|
||||
colorStop.startPosition = std::get<CSSLength>(startPosition);
|
||||
} else if (std::holds_alternative<CSSPercentage>(startPosition)) {
|
||||
@@ -261,7 +258,7 @@ struct CSSDataTypeParser<CSSColorStop> {
|
||||
if (colorStop.startPosition) {
|
||||
// Try to parse second optional position (supports both lengths and
|
||||
// percentages)
|
||||
auto endPosition = parseNextCSSValue<CSSLengthPercentage>(parser, CSSDelimiter::Whitespace);
|
||||
auto endPosition = parser.parseNextValue<CSSLengthPercentage>(CSSDelimiter::Whitespace);
|
||||
if (std::holds_alternative<CSSLength>(endPosition)) {
|
||||
colorStop.endPosition = std::get<CSSLength>(endPosition);
|
||||
} else if (std::holds_alternative<CSSPercentage>(endPosition)) {
|
||||
@@ -281,27 +278,27 @@ struct CSSLinearGradientFunction {
|
||||
bool operator==(const CSSLinearGradientFunction &rhs) const = default;
|
||||
|
||||
static std::pair<std::vector<std::variant<CSSColorStop, CSSColorHint>>, int> parseGradientColorStopsAndHints(
|
||||
CSSSyntaxParser &parser)
|
||||
CSSValueParser &parser)
|
||||
{
|
||||
std::vector<std::variant<CSSColorStop, CSSColorHint>> items;
|
||||
int colorStopCount = 0;
|
||||
|
||||
std::optional<CSSColorStop> prevColorStop = std::nullopt;
|
||||
do {
|
||||
auto colorStop = parseNextCSSValue<CSSColorStop>(parser);
|
||||
auto colorStop = parser.parseNextValue<CSSColorStop>();
|
||||
if (std::holds_alternative<CSSColorStop>(colorStop)) {
|
||||
auto parsedColorStop = std::get<CSSColorStop>(colorStop);
|
||||
items.emplace_back(parsedColorStop);
|
||||
prevColorStop = parsedColorStop;
|
||||
colorStopCount++;
|
||||
} else {
|
||||
auto colorHint = parseNextCSSValue<CSSColorHint>(parser);
|
||||
auto colorHint = parser.parseNextValue<CSSColorHint>();
|
||||
if (std::holds_alternative<CSSColorHint>(colorHint)) {
|
||||
// color hint must be between two color stops
|
||||
if (!prevColorStop) {
|
||||
return {};
|
||||
}
|
||||
auto nextColorStop = peekNextCSSValue<CSSColorStop>(parser, CSSDelimiter::Comma);
|
||||
auto nextColorStop = parser.peekNextValue<CSSColorStop>(CSSDelimiter::Comma);
|
||||
if (!std::holds_alternative<CSSColorStop>(nextColorStop)) {
|
||||
return {};
|
||||
}
|
||||
@@ -310,7 +307,7 @@ struct CSSLinearGradientFunction {
|
||||
break; // No more valid items
|
||||
}
|
||||
}
|
||||
} while (parser.consumeDelimiter(CSSDelimiter::Comma));
|
||||
} while (parser.syntaxParser().consumeDelimiter(CSSDelimiter::Comma));
|
||||
|
||||
return {items, colorStopCount};
|
||||
}
|
||||
@@ -378,16 +375,16 @@ struct CSSRadialGradientExplicitSize {
|
||||
|
||||
template <>
|
||||
struct CSSDataTypeParser<CSSRadialGradientExplicitSize> {
|
||||
static auto consume(CSSSyntaxParser &syntaxParser) -> std::optional<CSSRadialGradientExplicitSize>
|
||||
static auto consume(CSSValueParser &syntaxParser) -> std::optional<CSSRadialGradientExplicitSize>
|
||||
{
|
||||
auto sizeX = parseNextCSSValue<CSSLengthPercentage>(syntaxParser);
|
||||
auto sizeX = syntaxParser.parseNextValue<CSSLengthPercentage>();
|
||||
if (std::holds_alternative<std::monostate>(sizeX)) {
|
||||
return {};
|
||||
}
|
||||
|
||||
syntaxParser.consumeWhitespace();
|
||||
syntaxParser.syntaxParser().consumeWhitespace();
|
||||
|
||||
auto sizeY = parseNextCSSValue<CSSLengthPercentage>(syntaxParser);
|
||||
auto sizeY = syntaxParser.parseNextValue<CSSLengthPercentage>();
|
||||
|
||||
CSSRadialGradientExplicitSize result;
|
||||
if (std::holds_alternative<CSSLength>(sizeX)) {
|
||||
@@ -434,7 +431,7 @@ struct CSSRadialGradientFunction {
|
||||
|
||||
template <>
|
||||
struct CSSDataTypeParser<CSSRadialGradientFunction> {
|
||||
static auto consumeFunctionBlock(const CSSFunctionBlock &func, CSSSyntaxParser &parser)
|
||||
static auto consumeFunctionBlock(const CSSFunctionBlock &func, CSSValueParser &parser)
|
||||
-> std::optional<CSSRadialGradientFunction>
|
||||
{
|
||||
if (!iequals(func.name, "radial-gradient")) {
|
||||
@@ -445,20 +442,20 @@ struct CSSDataTypeParser<CSSRadialGradientFunction> {
|
||||
|
||||
auto hasExplicitShape = false;
|
||||
auto hasExplicitSingleSize = false;
|
||||
auto shapeResult = parseNextCSSValue<CSSRadialGradientShape>(parser);
|
||||
auto shapeResult = parser.parseNextValue<CSSRadialGradientShape>();
|
||||
if (std::holds_alternative<CSSRadialGradientShape>(shapeResult)) {
|
||||
parser.consumeWhitespace();
|
||||
parser.syntaxParser().consumeWhitespace();
|
||||
}
|
||||
|
||||
std::optional<CSSRadialGradientSize> sizeResult;
|
||||
|
||||
auto sizeKeywordResult = parseNextCSSValue<CSSRadialGradientSizeKeyword>(parser);
|
||||
auto sizeKeywordResult = parser.parseNextValue<CSSRadialGradientSizeKeyword>();
|
||||
|
||||
if (std::holds_alternative<CSSRadialGradientSizeKeyword>(sizeKeywordResult)) {
|
||||
sizeResult = CSSRadialGradientSize{std::get<CSSRadialGradientSizeKeyword>(sizeKeywordResult)};
|
||||
parser.consumeWhitespace();
|
||||
parser.syntaxParser().consumeWhitespace();
|
||||
} else {
|
||||
auto explicitSizeResult = parseNextCSSValue<CSSRadialGradientExplicitSize>(parser);
|
||||
auto explicitSizeResult = parser.parseNextValue<CSSRadialGradientExplicitSize>();
|
||||
if (std::holds_alternative<CSSRadialGradientExplicitSize>(explicitSizeResult)) {
|
||||
auto explicitSize = std::get<CSSRadialGradientExplicitSize>(explicitSizeResult);
|
||||
// negative value validation
|
||||
@@ -492,7 +489,7 @@ struct CSSDataTypeParser<CSSRadialGradientFunction> {
|
||||
}
|
||||
|
||||
sizeResult = CSSRadialGradientSize{explicitSize};
|
||||
parser.consumeWhitespace();
|
||||
parser.syntaxParser().consumeWhitespace();
|
||||
}
|
||||
}
|
||||
|
||||
@@ -521,38 +518,24 @@ struct CSSDataTypeParser<CSSRadialGradientFunction> {
|
||||
return {};
|
||||
}
|
||||
|
||||
auto atResult = parser.consumeComponentValue<bool>([](const CSSPreservedToken &token) -> bool {
|
||||
return token.type() == CSSTokenType::Ident && fnv1aLowercase(token.stringValue()) == fnv1a("at");
|
||||
});
|
||||
auto atResult = parser.parseNextValue<CSSGradientAtKeyword>();
|
||||
bool hasAtKeyword = std::holds_alternative<CSSGradientAtKeyword>(atResult);
|
||||
|
||||
CSSRadialGradientPosition position;
|
||||
|
||||
if (atResult) {
|
||||
parser.consumeWhitespace();
|
||||
if (hasAtKeyword) {
|
||||
parser.syntaxParser().consumeWhitespace();
|
||||
std::vector<std::variant<CSSLength, CSSPercentage, CSSKeyword>> positionKeywordValues;
|
||||
for (int i = 0; i < 2; i++) {
|
||||
auto keywordFound = false;
|
||||
auto valueFound = false;
|
||||
|
||||
auto positionKeyword = parser.consumeComponentValue<std::optional<CSSKeyword>>(
|
||||
[](const CSSPreservedToken &token) -> std::optional<CSSKeyword> {
|
||||
if (token.type() == CSSTokenType::Ident) {
|
||||
auto keyword = std::string(token.stringValue());
|
||||
auto hash = fnv1aLowercase(keyword);
|
||||
if (hash == fnv1a("top")) {
|
||||
return CSSKeyword::Top;
|
||||
} else if (hash == fnv1a("bottom")) {
|
||||
return CSSKeyword::Bottom;
|
||||
} else if (hash == fnv1a("left")) {
|
||||
return CSSKeyword::Left;
|
||||
} else if (hash == fnv1a("right")) {
|
||||
return CSSKeyword::Right;
|
||||
} else if (hash == fnv1a("center")) {
|
||||
return CSSKeyword::Center;
|
||||
}
|
||||
}
|
||||
return {};
|
||||
});
|
||||
auto positionKeywordResult = parser.parseNextValue<CSSGradientPositionKeyword>();
|
||||
std::optional<CSSKeyword> positionKeyword;
|
||||
if (std::holds_alternative<CSSGradientPositionKeyword>(positionKeywordResult)) {
|
||||
positionKeyword =
|
||||
static_cast<CSSKeyword>(to_underlying(std::get<CSSGradientPositionKeyword>(positionKeywordResult)));
|
||||
}
|
||||
|
||||
if (positionKeyword) {
|
||||
// invalid position declaration of same keyword "at top 10% top 20%"
|
||||
@@ -567,9 +550,9 @@ struct CSSDataTypeParser<CSSRadialGradientFunction> {
|
||||
keywordFound = true;
|
||||
}
|
||||
|
||||
parser.consumeWhitespace();
|
||||
parser.syntaxParser().consumeWhitespace();
|
||||
|
||||
auto lengthPercentageValue = parseNextCSSValue<CSSLengthPercentage>(parser);
|
||||
auto lengthPercentageValue = parser.parseNextValue<CSSLengthPercentage>();
|
||||
|
||||
std::optional<decltype(positionKeywordValues)::value_type> value;
|
||||
if (std::holds_alternative<CSSLength>(lengthPercentageValue)) {
|
||||
@@ -582,7 +565,7 @@ struct CSSDataTypeParser<CSSRadialGradientFunction> {
|
||||
valueFound = true;
|
||||
}
|
||||
|
||||
parser.consumeWhitespace();
|
||||
parser.syntaxParser().consumeWhitespace();
|
||||
|
||||
if (!keywordFound && !valueFound) {
|
||||
break;
|
||||
@@ -791,7 +774,7 @@ struct CSSDataTypeParser<CSSRadialGradientFunction> {
|
||||
gradient.position = position;
|
||||
}
|
||||
|
||||
parser.consumeDelimiter(CSSDelimiter::Comma);
|
||||
parser.syntaxParser().consumeDelimiter(CSSDelimiter::Comma);
|
||||
auto [items, colorStopCount] = CSSLinearGradientFunction::parseGradientColorStopsAndHints(parser);
|
||||
|
||||
if (items.empty() || colorStopCount < 2) {
|
||||
@@ -807,7 +790,7 @@ static_assert(CSSDataType<CSSRadialGradientFunction>);
|
||||
|
||||
template <>
|
||||
struct CSSDataTypeParser<CSSLinearGradientFunction> {
|
||||
static auto consumeFunctionBlock(const CSSFunctionBlock &func, CSSSyntaxParser &parser)
|
||||
static auto consumeFunctionBlock(const CSSFunctionBlock &func, CSSValueParser &parser)
|
||||
-> std::optional<CSSLinearGradientFunction>
|
||||
{
|
||||
if (!iequals(func.name, "linear-gradient")) {
|
||||
@@ -816,12 +799,12 @@ struct CSSDataTypeParser<CSSLinearGradientFunction> {
|
||||
|
||||
CSSLinearGradientFunction gradient;
|
||||
|
||||
auto parsedDirection = parseNextCSSValue<CSSLinearGradientDirection>(parser);
|
||||
auto parsedDirection = parser.parseNextValue<CSSLinearGradientDirection>();
|
||||
if (!std::holds_alternative<CSSLinearGradientDirection>(parsedDirection)) {
|
||||
return {};
|
||||
}
|
||||
|
||||
parser.consumeDelimiter(CSSDelimiter::Comma);
|
||||
parser.syntaxParser().consumeDelimiter(CSSDelimiter::Comma);
|
||||
|
||||
gradient.direction = std::get<CSSLinearGradientDirection>(parsedDirection);
|
||||
|
||||
|
||||
@@ -47,7 +47,7 @@ struct CSSDataTypeParser<CSSColor> {
|
||||
return {};
|
||||
}
|
||||
|
||||
static constexpr auto consumeFunctionBlock(const CSSFunctionBlock &func, CSSSyntaxParser &parser)
|
||||
static constexpr auto consumeFunctionBlock(const CSSFunctionBlock &func, CSSValueParser &parser)
|
||||
-> std::optional<CSSColor>
|
||||
{
|
||||
return parseCSSColorFunction<CSSColor>(func.name, parser);
|
||||
|
||||
@@ -17,7 +17,6 @@
|
||||
#include <react/renderer/css/CSSAngle.h>
|
||||
#include <react/renderer/css/CSSNumber.h>
|
||||
#include <react/renderer/css/CSSPercentage.h>
|
||||
#include <react/renderer/css/CSSSyntaxParser.h>
|
||||
#include <react/renderer/css/CSSValueParser.h>
|
||||
#include <react/utils/PackTraits.h>
|
||||
#include <react/utils/fnv1a.h>
|
||||
@@ -154,16 +153,19 @@ constexpr std::optional<float> normalizeComponent(
|
||||
}
|
||||
|
||||
template <CSSDataType... FirstComponentAllowedTypesT>
|
||||
constexpr bool isLegacyColorFunction(CSSSyntaxParser &parser)
|
||||
constexpr bool isLegacyColorFunction(CSSValueParser &parser)
|
||||
{
|
||||
auto lookahead = parser;
|
||||
auto next = parseNextCSSValue<FirstComponentAllowedTypesT...>(lookahead);
|
||||
auto saved = parser.syntaxParser();
|
||||
auto next = parser.parseNextValue<FirstComponentAllowedTypesT...>();
|
||||
if (std::holds_alternative<std::monostate>(next)) {
|
||||
parser.syntaxParser() = saved;
|
||||
return false;
|
||||
}
|
||||
|
||||
return lookahead.consumeComponentValue<bool>(
|
||||
CSSDelimiter::OptionalWhitespace, [](CSSPreservedToken token) { return token.type() == CSSTokenType::Comma; });
|
||||
parser.syntaxParser().consumeWhitespace();
|
||||
bool isLegacy = parser.syntaxParser().peek().type() == CSSTokenType::Comma;
|
||||
parser.syntaxParser() = saved;
|
||||
return isLegacy;
|
||||
}
|
||||
|
||||
/**
|
||||
@@ -172,9 +174,9 @@ constexpr bool isLegacyColorFunction(CSSSyntaxParser &parser)
|
||||
* https://www.w3.org/TR/css-color-4/#typedef-legacy-rgb-syntax
|
||||
*/
|
||||
template <typename CSSColor>
|
||||
constexpr std::optional<CSSColor> parseLegacyRgbFunction(CSSSyntaxParser &parser)
|
||||
constexpr std::optional<CSSColor> parseLegacyRgbFunction(CSSValueParser &parser)
|
||||
{
|
||||
auto rawRed = parseNextCSSValue<CSSNumber, CSSPercentage>(parser);
|
||||
auto rawRed = parser.parseNextValue<CSSNumber, CSSPercentage>();
|
||||
bool usesNumber = std::holds_alternative<CSSNumber>(rawRed);
|
||||
|
||||
auto red = normalizeComponent(rawRed, 255.0f);
|
||||
@@ -182,19 +184,19 @@ constexpr std::optional<CSSColor> parseLegacyRgbFunction(CSSSyntaxParser &parser
|
||||
return {};
|
||||
}
|
||||
|
||||
auto green = usesNumber ? normalizeNumberComponent(parseNextCSSValue<CSSNumber>(parser, CSSDelimiter::Comma))
|
||||
: normalizeComponent(parseNextCSSValue<CSSPercentage>(parser, CSSDelimiter::Comma), 255.0f);
|
||||
auto green = usesNumber ? normalizeNumberComponent(parser.parseNextValue<CSSNumber>(CSSDelimiter::Comma))
|
||||
: normalizeComponent(parser.parseNextValue<CSSPercentage>(CSSDelimiter::Comma), 255.0f);
|
||||
if (!green.has_value()) {
|
||||
return {};
|
||||
}
|
||||
|
||||
auto blue = usesNumber ? normalizeNumberComponent(parseNextCSSValue<CSSNumber>(parser, CSSDelimiter::Comma))
|
||||
: normalizeComponent(parseNextCSSValue<CSSPercentage>(parser, CSSDelimiter::Comma), 255.0f);
|
||||
auto blue = usesNumber ? normalizeNumberComponent(parser.parseNextValue<CSSNumber>(CSSDelimiter::Comma))
|
||||
: normalizeComponent(parser.parseNextValue<CSSPercentage>(CSSDelimiter::Comma), 255.0f);
|
||||
if (!blue.has_value()) {
|
||||
return {};
|
||||
}
|
||||
|
||||
auto alpha = normalizeComponent(parseNextCSSValue<CSSNumber, CSSPercentage>(parser, CSSDelimiter::Comma), 1.0f);
|
||||
auto alpha = normalizeComponent(parser.parseNextValue<CSSNumber, CSSPercentage>(CSSDelimiter::Comma), 1.0f);
|
||||
|
||||
return CSSColor{
|
||||
.r = clamp255Component(*red),
|
||||
@@ -210,26 +212,25 @@ constexpr std::optional<CSSColor> parseLegacyRgbFunction(CSSSyntaxParser &parser
|
||||
* https://www.w3.org/TR/css-color-4/#typedef-modern-rgb-syntax
|
||||
*/
|
||||
template <typename CSSColor>
|
||||
constexpr std::optional<CSSColor> parseModernRgbFunction(CSSSyntaxParser &parser)
|
||||
constexpr std::optional<CSSColor> parseModernRgbFunction(CSSValueParser &parser)
|
||||
{
|
||||
auto red = normalizeComponent(parseNextCSSValue<CSSNumber, CSSPercentage>(parser), 255.0f);
|
||||
auto red = normalizeComponent(parser.parseNextValue<CSSNumber, CSSPercentage>(), 255.0f);
|
||||
if (!red.has_value()) {
|
||||
return {};
|
||||
}
|
||||
|
||||
auto green =
|
||||
normalizeComponent(parseNextCSSValue<CSSNumber, CSSPercentage>(parser, CSSDelimiter::Whitespace), 255.0f);
|
||||
auto green = normalizeComponent(parser.parseNextValue<CSSNumber, CSSPercentage>(CSSDelimiter::Whitespace), 255.0f);
|
||||
if (!green.has_value()) {
|
||||
return {};
|
||||
}
|
||||
|
||||
auto blue = normalizeComponent(parseNextCSSValue<CSSNumber, CSSPercentage>(parser, CSSDelimiter::Whitespace), 255.0f);
|
||||
auto blue = normalizeComponent(parser.parseNextValue<CSSNumber, CSSPercentage>(CSSDelimiter::Whitespace), 255.0f);
|
||||
if (!blue.has_value()) {
|
||||
return {};
|
||||
}
|
||||
|
||||
auto alpha =
|
||||
normalizeComponent(parseNextCSSValue<CSSNumber, CSSPercentage>(parser, CSSDelimiter::SolidusOrWhitespace), 1.0f);
|
||||
normalizeComponent(parser.parseNextValue<CSSNumber, CSSPercentage>(CSSDelimiter::SolidusOrWhitespace), 1.0f);
|
||||
|
||||
return CSSColor{
|
||||
.r = clamp255Component(*red),
|
||||
@@ -244,7 +245,7 @@ constexpr std::optional<CSSColor> parseModernRgbFunction(CSSSyntaxParser &parser
|
||||
* https://www.w3.org/TR/css-color-4/#funcdef-rgb
|
||||
*/
|
||||
template <typename CSSColor>
|
||||
constexpr std::optional<CSSColor> parseRgbFunction(CSSSyntaxParser &parser)
|
||||
constexpr std::optional<CSSColor> parseRgbFunction(CSSValueParser &parser)
|
||||
{
|
||||
if (isLegacyColorFunction<CSSNumber, CSSPercentage>(parser)) {
|
||||
return parseLegacyRgbFunction<CSSColor>(parser);
|
||||
@@ -259,24 +260,24 @@ constexpr std::optional<CSSColor> parseRgbFunction(CSSSyntaxParser &parser)
|
||||
* https://www.w3.org/TR/css-color-4/#typedef-legacy-hsl-syntax
|
||||
*/
|
||||
template <typename CSSColor>
|
||||
inline std::optional<CSSColor> parseLegacyHslFunction(CSSSyntaxParser &parser)
|
||||
inline std::optional<CSSColor> parseLegacyHslFunction(CSSValueParser &parser)
|
||||
{
|
||||
auto h = normalizeHueComponent(parseNextCSSValue<CSSNumber, CSSAngle>(parser));
|
||||
auto h = normalizeHueComponent(parser.parseNextValue<CSSNumber, CSSAngle>());
|
||||
if (!h.has_value()) {
|
||||
return {};
|
||||
}
|
||||
|
||||
auto s = normalizeComponent(parseNextCSSValue<CSSPercentage>(parser, CSSDelimiter::Comma), 100.0f);
|
||||
auto s = normalizeComponent(parser.parseNextValue<CSSPercentage>(CSSDelimiter::Comma), 100.0f);
|
||||
if (!s.has_value()) {
|
||||
return {};
|
||||
}
|
||||
|
||||
auto l = normalizeComponent(parseNextCSSValue<CSSPercentage>(parser, CSSDelimiter::Comma), 100.0f);
|
||||
auto l = normalizeComponent(parser.parseNextValue<CSSPercentage>(CSSDelimiter::Comma), 100.0f);
|
||||
if (!l.has_value()) {
|
||||
return {};
|
||||
}
|
||||
|
||||
auto a = normalizeComponent(parseNextCSSValue<CSSNumber, CSSPercentage>(parser, CSSDelimiter::Comma), 1.0f);
|
||||
auto a = normalizeComponent(parser.parseNextValue<CSSNumber, CSSPercentage>(CSSDelimiter::Comma), 1.0f);
|
||||
|
||||
auto [r, g, b] = hslToRgb(*h, *s, *l);
|
||||
|
||||
@@ -293,25 +294,24 @@ inline std::optional<CSSColor> parseLegacyHslFunction(CSSSyntaxParser &parser)
|
||||
* it is valid. https://www.w3.org/TR/css-color-4/#typedef-modern-hsl-syntax
|
||||
*/
|
||||
template <typename CSSColor>
|
||||
inline std::optional<CSSColor> parseModernHslFunction(CSSSyntaxParser &parser)
|
||||
inline std::optional<CSSColor> parseModernHslFunction(CSSValueParser &parser)
|
||||
{
|
||||
auto h = normalizeHueComponent(parseNextCSSValue<CSSNumber, CSSAngle>(parser));
|
||||
auto h = normalizeHueComponent(parser.parseNextValue<CSSNumber, CSSAngle>());
|
||||
if (!h.has_value()) {
|
||||
return {};
|
||||
}
|
||||
|
||||
auto s = normalizeComponent(parseNextCSSValue<CSSNumber, CSSPercentage>(parser, CSSDelimiter::Whitespace), 100.0f);
|
||||
auto s = normalizeComponent(parser.parseNextValue<CSSNumber, CSSPercentage>(CSSDelimiter::Whitespace), 100.0f);
|
||||
if (!s.has_value()) {
|
||||
return {};
|
||||
}
|
||||
|
||||
auto l = normalizeComponent(parseNextCSSValue<CSSNumber, CSSPercentage>(parser, CSSDelimiter::Whitespace), 100.0f);
|
||||
auto l = normalizeComponent(parser.parseNextValue<CSSNumber, CSSPercentage>(CSSDelimiter::Whitespace), 100.0f);
|
||||
if (!l.has_value()) {
|
||||
return {};
|
||||
}
|
||||
|
||||
auto a =
|
||||
normalizeComponent(parseNextCSSValue<CSSNumber, CSSPercentage>(parser, CSSDelimiter::SolidusOrWhitespace), 1.0f);
|
||||
auto a = normalizeComponent(parser.parseNextValue<CSSNumber, CSSPercentage>(CSSDelimiter::SolidusOrWhitespace), 1.0f);
|
||||
|
||||
auto [r, g, b] = hslToRgb(*h, *s, *l);
|
||||
|
||||
@@ -328,7 +328,7 @@ inline std::optional<CSSColor> parseModernHslFunction(CSSSyntaxParser &parser)
|
||||
* https://www.w3.org/TR/css-color-4/#funcdef-hsl
|
||||
*/
|
||||
template <typename CSSColor>
|
||||
inline std::optional<CSSColor> parseHslFunction(CSSSyntaxParser &parser)
|
||||
inline std::optional<CSSColor> parseHslFunction(CSSValueParser &parser)
|
||||
{
|
||||
if (isLegacyColorFunction<CSSNumber, CSSAngle>(parser)) {
|
||||
return parseLegacyHslFunction<CSSColor>(parser);
|
||||
@@ -342,25 +342,24 @@ inline std::optional<CSSColor> parseHslFunction(CSSSyntaxParser &parser)
|
||||
* https://www.w3.org/TR/css-color-4/#funcdef-hwb
|
||||
*/
|
||||
template <typename CSSColor>
|
||||
inline std::optional<CSSColor> parseHwbFunction(CSSSyntaxParser &parser)
|
||||
inline std::optional<CSSColor> parseHwbFunction(CSSValueParser &parser)
|
||||
{
|
||||
auto h = normalizeHueComponent(parseNextCSSValue<CSSNumber, CSSAngle>(parser));
|
||||
auto h = normalizeHueComponent(parser.parseNextValue<CSSNumber, CSSAngle>());
|
||||
if (!h.has_value()) {
|
||||
return {};
|
||||
}
|
||||
|
||||
auto w = normalizeComponent(parseNextCSSValue<CSSNumber, CSSPercentage>(parser, CSSDelimiter::Whitespace), 100.0f);
|
||||
auto w = normalizeComponent(parser.parseNextValue<CSSNumber, CSSPercentage>(CSSDelimiter::Whitespace), 100.0f);
|
||||
if (!w.has_value()) {
|
||||
return {};
|
||||
}
|
||||
|
||||
auto b = normalizeComponent(parseNextCSSValue<CSSNumber, CSSPercentage>(parser, CSSDelimiter::Whitespace), 100.0f);
|
||||
auto b = normalizeComponent(parser.parseNextValue<CSSNumber, CSSPercentage>(CSSDelimiter::Whitespace), 100.0f);
|
||||
if (!b.has_value()) {
|
||||
return {};
|
||||
}
|
||||
|
||||
auto a =
|
||||
normalizeComponent(parseNextCSSValue<CSSNumber, CSSPercentage>(parser, CSSDelimiter::SolidusOrWhitespace), 1.0f);
|
||||
auto a = normalizeComponent(parser.parseNextValue<CSSNumber, CSSPercentage>(CSSDelimiter::SolidusOrWhitespace), 1.0f);
|
||||
|
||||
auto [red, green, blue] = hwbToRgb(*h, *w, *b);
|
||||
|
||||
@@ -380,7 +379,7 @@ inline std::optional<CSSColor> parseHwbFunction(CSSSyntaxParser &parser)
|
||||
* https://www.w3.org/TR/css-color-4/#typedef-color-function
|
||||
*/
|
||||
template <typename CSSColor>
|
||||
constexpr std::optional<CSSColor> parseCSSColorFunction(std::string_view colorFunction, CSSSyntaxParser &parser)
|
||||
constexpr std::optional<CSSColor> parseCSSColorFunction(std::string_view colorFunction, CSSValueParser &parser)
|
||||
{
|
||||
switch (fnv1aLowercase(colorFunction)) {
|
||||
// CSS Color Module Level 4 treats the alpha variants of functions as the
|
||||
|
||||
@@ -16,6 +16,8 @@
|
||||
|
||||
namespace facebook::react {
|
||||
|
||||
class CSSValueParser;
|
||||
|
||||
/**
|
||||
* May be specialized to instruct the CSS value parser how to parse a given data
|
||||
* type, according to CSSValidDataTypeParser.
|
||||
@@ -24,26 +26,28 @@ template <typename CSSDataTypeT>
|
||||
struct CSSDataTypeParser {};
|
||||
|
||||
/**
|
||||
* Accepts a CSS function block and may parse it (and future syntax) into a
|
||||
* concrete representation.
|
||||
* Accepts a CSS function block and may parse it into a concrete representation.
|
||||
* The CSSValueParser provides methods for parsing sub-values within the
|
||||
* function block scope.
|
||||
*/
|
||||
template <typename T, typename ReturnT = std::any>
|
||||
concept CSSFunctionBlockSink = requires(const CSSFunctionBlock &func, CSSSyntaxParser &parser) {
|
||||
concept CSSFunctionBlockSink = requires(const CSSFunctionBlock &func, CSSValueParser &parser) {
|
||||
{ T::consumeFunctionBlock(func, parser) } -> std::convertible_to<ReturnT>;
|
||||
};
|
||||
|
||||
/**
|
||||
* Accepts a CSS simple block and may parse it (and future syntax) into a
|
||||
* concrete representation.
|
||||
* Accepts a CSS simple block and may parse it into a concrete representation.
|
||||
* The CSSValueParser provides methods for parsing sub-values within the
|
||||
* block scope.
|
||||
*/
|
||||
template <typename T, typename ReturnT = std::any>
|
||||
concept CSSSimpleBlockSink = requires(const CSSSimpleBlock &block, CSSSyntaxParser &parser) {
|
||||
concept CSSSimpleBlockSink = requires(const CSSSimpleBlock &block, CSSValueParser &parser) {
|
||||
{ T::consumeSimpleBlock(block, parser) } -> std::convertible_to<ReturnT>;
|
||||
};
|
||||
|
||||
/**
|
||||
* Accepts a CSS preserved token and may parse it (and future syntax) into a
|
||||
* concrete representation.
|
||||
* Accepts a CSS preserved token and may parse it into a concrete
|
||||
* representation.
|
||||
*/
|
||||
template <typename T, typename ReturnT = std::any>
|
||||
concept CSSPreservedTokenSink = requires(const CSSPreservedToken &token) {
|
||||
@@ -51,10 +55,11 @@ concept CSSPreservedTokenSink = requires(const CSSPreservedToken &token) {
|
||||
};
|
||||
|
||||
/**
|
||||
* Accepts a raw syntax parser, to be able to parse compounded values
|
||||
* Accepts a CSSValueParser to be able to parse compounded values spanning
|
||||
* multiple component values.
|
||||
*/
|
||||
template <typename T, typename ReturnT = std::any>
|
||||
concept CSSParserSink = requires(CSSSyntaxParser &parser) {
|
||||
concept CSSParserSink = requires(CSSValueParser &parser) {
|
||||
{ T::consume(parser) } -> std::convertible_to<ReturnT>;
|
||||
};
|
||||
|
||||
|
||||
@@ -28,14 +28,14 @@ namespace detail {
|
||||
template <typename DataT, TemplateStringLiteral Name>
|
||||
requires(std::is_same_v<decltype(DataT::amount), float>)
|
||||
struct CSSFilterSimpleAmountParser {
|
||||
static constexpr auto consumeFunctionBlock(const CSSFunctionBlock &func, CSSSyntaxParser &parser)
|
||||
static constexpr auto consumeFunctionBlock(const CSSFunctionBlock &func, CSSValueParser &parser)
|
||||
-> std::optional<DataT>
|
||||
{
|
||||
if (!iequals(func.name, Name)) {
|
||||
return {};
|
||||
}
|
||||
|
||||
auto amount = parseNextCSSValue<CSSNumber, CSSPercentage>(parser);
|
||||
auto amount = parser.parseNextValue<CSSNumber, CSSPercentage>();
|
||||
if (std::holds_alternative<CSSNumber>(amount)) {
|
||||
if (std::get<CSSNumber>(amount).value < 0.0f) {
|
||||
return {};
|
||||
@@ -65,14 +65,14 @@ struct CSSBlurFilter {
|
||||
|
||||
template <>
|
||||
struct CSSDataTypeParser<CSSBlurFilter> {
|
||||
static constexpr auto consumeFunctionBlock(const CSSFunctionBlock &func, CSSSyntaxParser &parser)
|
||||
static constexpr auto consumeFunctionBlock(const CSSFunctionBlock &func, CSSValueParser &parser)
|
||||
-> std::optional<CSSBlurFilter>
|
||||
{
|
||||
if (!iequals(func.name, "blur")) {
|
||||
return {};
|
||||
}
|
||||
|
||||
auto len = parseNextCSSValue<CSSLength>(parser);
|
||||
auto len = parser.parseNextValue<CSSLength>();
|
||||
return CSSBlurFilter{std::holds_alternative<CSSLength>(len) ? std::get<CSSLength>(len) : CSSLength{}};
|
||||
}
|
||||
};
|
||||
@@ -123,7 +123,7 @@ struct CSSDropShadowFilter {
|
||||
|
||||
template <>
|
||||
struct CSSDataTypeParser<CSSDropShadowFilter> {
|
||||
static constexpr auto consumeFunctionBlock(const CSSFunctionBlock &func, CSSSyntaxParser &parser)
|
||||
static constexpr auto consumeFunctionBlock(const CSSFunctionBlock &func, CSSValueParser &parser)
|
||||
-> std::optional<CSSDropShadowFilter>
|
||||
{
|
||||
if (!iequals(func.name, "drop-shadow")) {
|
||||
@@ -133,7 +133,7 @@ struct CSSDataTypeParser<CSSDropShadowFilter> {
|
||||
std::optional<CSSColor> color{};
|
||||
std::optional<std::array<CSSLength, 3>> lengths{};
|
||||
|
||||
auto firstVal = parseNextCSSValue<CSSColor, CSSLength>(parser);
|
||||
auto firstVal = parser.parseNextValue<CSSColor, CSSLength>();
|
||||
if (std::holds_alternative<std::monostate>(firstVal)) {
|
||||
return {};
|
||||
}
|
||||
@@ -147,7 +147,7 @@ struct CSSDataTypeParser<CSSDropShadowFilter> {
|
||||
}
|
||||
}
|
||||
|
||||
auto secondVal = parseNextCSSValue<CSSColor, CSSLength>(parser, CSSDelimiter::Whitespace);
|
||||
auto secondVal = parser.parseNextValue<CSSColor, CSSLength>(CSSDelimiter::Whitespace);
|
||||
if (std::holds_alternative<CSSColor>(secondVal)) {
|
||||
if (color.has_value()) {
|
||||
return {};
|
||||
@@ -173,14 +173,14 @@ struct CSSDataTypeParser<CSSDropShadowFilter> {
|
||||
}
|
||||
|
||||
private:
|
||||
static constexpr std::optional<std::array<CSSLength, 3>> parseLengths(CSSLength offsetX, CSSSyntaxParser &parser)
|
||||
static constexpr std::optional<std::array<CSSLength, 3>> parseLengths(CSSLength offsetX, CSSValueParser &parser)
|
||||
{
|
||||
auto offsetY = parseNextCSSValue<CSSLength>(parser, CSSDelimiter::Whitespace);
|
||||
auto offsetY = parser.parseNextValue<CSSLength>(CSSDelimiter::Whitespace);
|
||||
if (!std::holds_alternative<CSSLength>(offsetY)) {
|
||||
return {};
|
||||
}
|
||||
|
||||
auto standardDeviation = parseNextCSSValue<CSSLength>(parser, CSSDelimiter::Whitespace);
|
||||
auto standardDeviation = parser.parseNextValue<CSSLength>(CSSDelimiter::Whitespace);
|
||||
if (std::holds_alternative<CSSLength>(standardDeviation) && std::get<CSSLength>(standardDeviation).value < 0.0f) {
|
||||
return {};
|
||||
}
|
||||
@@ -220,14 +220,14 @@ struct CSSHueRotateFilter {
|
||||
|
||||
template <>
|
||||
struct CSSDataTypeParser<CSSHueRotateFilter> {
|
||||
static constexpr auto consumeFunctionBlock(const CSSFunctionBlock &func, CSSSyntaxParser &parser)
|
||||
static constexpr auto consumeFunctionBlock(const CSSFunctionBlock &func, CSSValueParser &parser)
|
||||
-> std::optional<CSSHueRotateFilter>
|
||||
{
|
||||
if (!iequals(func.name, "hue-rotate")) {
|
||||
return {};
|
||||
}
|
||||
|
||||
auto angle = parseNextCSSValue<CSSAngle, CSSZero>(parser);
|
||||
auto angle = parser.parseNextValue<CSSAngle, CSSZero>();
|
||||
return CSSHueRotateFilter{std::holds_alternative<CSSAngle>(angle) ? std::get<CSSAngle>(angle).degrees : 0.0f};
|
||||
}
|
||||
};
|
||||
|
||||
@@ -23,6 +23,7 @@ namespace facebook::react {
|
||||
*/
|
||||
enum class CSSKeyword : uint8_t {
|
||||
Absolute,
|
||||
At,
|
||||
Auto,
|
||||
Baseline,
|
||||
Block,
|
||||
@@ -110,6 +111,7 @@ enum class CSSKeyword : uint8_t {
|
||||
TabularNums,
|
||||
Thick,
|
||||
Thin,
|
||||
To,
|
||||
Top,
|
||||
Unset,
|
||||
Visible,
|
||||
@@ -143,6 +145,7 @@ enum class CSSWideKeyword : std::underlying_type_t<CSSKeyword> {
|
||||
}
|
||||
|
||||
CSS_DEFINE_KEYWORD(Absolute, "absolute")
|
||||
CSS_DEFINE_KEYWORD(At, "at")
|
||||
CSS_DEFINE_KEYWORD(Auto, "auto")
|
||||
CSS_DEFINE_KEYWORD(Baseline, "baseline")
|
||||
CSS_DEFINE_KEYWORD(Block, "block")
|
||||
@@ -230,6 +233,7 @@ CSS_DEFINE_KEYWORD(StylisticTwo, "stylistic-two")
|
||||
CSS_DEFINE_KEYWORD(TabularNums, "tabular-nums")
|
||||
CSS_DEFINE_KEYWORD(Thick, "thick")
|
||||
CSS_DEFINE_KEYWORD(Thin, "thin")
|
||||
CSS_DEFINE_KEYWORD(To, "to")
|
||||
CSS_DEFINE_KEYWORD(Top, "top")
|
||||
CSS_DEFINE_KEYWORD(Unset, "unset")
|
||||
CSS_DEFINE_KEYWORD(Visible, "visible")
|
||||
@@ -254,6 +258,7 @@ constexpr std::optional<KeywordT> parseCSSKeyword(std::string_view ident)
|
||||
{
|
||||
switch (fnv1aLowercase(ident)) {
|
||||
CSS_HANDLE_KEYWORD(Absolute)
|
||||
CSS_HANDLE_KEYWORD(At)
|
||||
CSS_HANDLE_KEYWORD(Auto)
|
||||
CSS_HANDLE_KEYWORD(Baseline)
|
||||
CSS_HANDLE_KEYWORD(Block)
|
||||
@@ -341,6 +346,7 @@ constexpr std::optional<KeywordT> parseCSSKeyword(std::string_view ident)
|
||||
CSS_HANDLE_KEYWORD(TabularNums)
|
||||
CSS_HANDLE_KEYWORD(Thick)
|
||||
CSS_HANDLE_KEYWORD(Thin)
|
||||
CSS_HANDLE_KEYWORD(To)
|
||||
CSS_HANDLE_KEYWORD(Top)
|
||||
CSS_HANDLE_KEYWORD(Unset)
|
||||
CSS_HANDLE_KEYWORD(Visible)
|
||||
|
||||
@@ -28,11 +28,11 @@ struct CSSList<AllowedTypesT, Delim> : public std::vector<AllowedTypesT> {};
|
||||
|
||||
template <CSSMaybeCompoundDataType AllowedTypeT, CSSDelimiter Delim>
|
||||
struct CSSDataTypeParser<CSSList<AllowedTypeT, Delim>> {
|
||||
static inline auto consume(CSSSyntaxParser &parser) -> std::optional<CSSList<AllowedTypeT, Delim>>
|
||||
static inline auto consume(CSSValueParser &parser) -> std::optional<CSSList<AllowedTypeT, Delim>>
|
||||
{
|
||||
CSSList<AllowedTypeT, Delim> result;
|
||||
for (auto nextValue = parseNextCSSValue<AllowedTypeT>(parser); !std::holds_alternative<std::monostate>(nextValue);
|
||||
nextValue = parseNextCSSValue<AllowedTypeT>(parser, Delim)) {
|
||||
for (auto nextValue = parser.parseNextValue<AllowedTypeT>(); !std::holds_alternative<std::monostate>(nextValue);
|
||||
nextValue = parser.parseNextValue<AllowedTypeT>(Delim)) {
|
||||
// Copy from the variant of possible values to the element (either the
|
||||
// concrete type, or a variant of compound types which exlcudes the
|
||||
// possibility of std::monostate for parse error)
|
||||
|
||||
@@ -38,20 +38,20 @@ struct CSSRatio {
|
||||
|
||||
template <>
|
||||
struct CSSDataTypeParser<CSSRatio> {
|
||||
static constexpr auto consume(CSSSyntaxParser &parser) -> std::optional<CSSRatio>
|
||||
static constexpr auto consume(CSSValueParser &parser) -> std::optional<CSSRatio>
|
||||
{
|
||||
// <ratio> = <number [0,∞]> [ / <number [0,∞]> ]?
|
||||
// https://www.w3.org/TR/css-values-4/#ratio
|
||||
auto numerator = parseNextCSSValue<CSSNumber>(parser);
|
||||
auto numerator = parser.parseNextValue<CSSNumber>();
|
||||
if (!std::holds_alternative<CSSNumber>(numerator)) {
|
||||
return {};
|
||||
}
|
||||
|
||||
auto numeratorValue = std::get<CSSNumber>(numerator).value;
|
||||
if (numeratorValue >= 0) {
|
||||
auto denominator = peekNextCSSValue<CSSNumber>(parser, CSSDelimiter::Solidus);
|
||||
auto denominator = parser.peekNextValue<CSSNumber>(CSSDelimiter::Solidus);
|
||||
if (std::holds_alternative<CSSNumber>(denominator) && std::get<CSSNumber>(denominator).value >= 0) {
|
||||
parseNextCSSValue<CSSNumber>(parser, CSSDelimiter::Solidus);
|
||||
parser.parseNextValue<CSSNumber>(CSSDelimiter::Solidus);
|
||||
return CSSRatio{.numerator = numeratorValue, .denominator = std::get<CSSNumber>(denominator).value};
|
||||
}
|
||||
|
||||
|
||||
@@ -46,15 +46,15 @@ static_assert(CSSDataType<CSSInsetShadowKeyword>);
|
||||
|
||||
template <>
|
||||
struct CSSDataTypeParser<CSSShadow> {
|
||||
static constexpr auto consume(CSSSyntaxParser &parser) -> std::optional<CSSShadow>
|
||||
static constexpr auto consume(CSSValueParser &parser) -> std::optional<CSSShadow>
|
||||
{
|
||||
std::optional<CSSColor> color{};
|
||||
bool inset{false};
|
||||
std::optional<std::tuple<CSSLength, CSSLength, CSSLength, CSSLength>> lengths{};
|
||||
|
||||
for (auto nextValue = parseNextCSSValue<CSSLength, CSSColor, CSSInsetShadowKeyword>(parser);
|
||||
for (auto nextValue = parser.parseNextValue<CSSLength, CSSColor, CSSInsetShadowKeyword>();
|
||||
!std::holds_alternative<std::monostate>(nextValue);
|
||||
nextValue = parseNextCSSValue<CSSLength, CSSColor, CSSInsetShadowKeyword>(parser, CSSDelimiter::Whitespace)) {
|
||||
nextValue = parser.parseNextValue<CSSLength, CSSColor, CSSInsetShadowKeyword>(CSSDelimiter::Whitespace)) {
|
||||
if (std::holds_alternative<CSSLength>(nextValue)) {
|
||||
if (lengths.has_value()) {
|
||||
return {};
|
||||
@@ -98,15 +98,15 @@ struct CSSDataTypeParser<CSSShadow> {
|
||||
}
|
||||
|
||||
private:
|
||||
static constexpr auto parseRestLengths(CSSLength offsetX, CSSSyntaxParser &parser)
|
||||
static constexpr auto parseRestLengths(CSSLength offsetX, CSSValueParser &parser)
|
||||
-> std::optional<std::tuple<CSSLength, CSSLength, CSSLength, CSSLength>>
|
||||
{
|
||||
auto offsetY = parseNextCSSValue<CSSLength>(parser, CSSDelimiter::Whitespace);
|
||||
auto offsetY = parser.parseNextValue<CSSLength>(CSSDelimiter::Whitespace);
|
||||
if (std::holds_alternative<std::monostate>(offsetY)) {
|
||||
return {};
|
||||
}
|
||||
|
||||
auto blurRadius = parseNextCSSValue<CSSLength>(parser, CSSDelimiter::Whitespace);
|
||||
auto blurRadius = parser.parseNextValue<CSSLength>(CSSDelimiter::Whitespace);
|
||||
if (std::holds_alternative<std::monostate>(blurRadius)) {
|
||||
return std::make_tuple(offsetX, std::get<CSSLength>(offsetY), CSSLength{}, CSSLength{});
|
||||
}
|
||||
@@ -114,7 +114,7 @@ struct CSSDataTypeParser<CSSShadow> {
|
||||
return {};
|
||||
}
|
||||
|
||||
auto spreadDistance = parseNextCSSValue<CSSLength>(parser, CSSDelimiter::Whitespace);
|
||||
auto spreadDistance = parser.parseNextValue<CSSLength>(CSSDelimiter::Whitespace);
|
||||
if (std::holds_alternative<std::monostate>(spreadDistance)) {
|
||||
return std::make_tuple(offsetX, std::get<CSSLength>(offsetY), std::get<CSSLength>(blurRadius), CSSLength{});
|
||||
}
|
||||
|
||||
@@ -113,6 +113,7 @@ enum class CSSDelimiter {
|
||||
class CSSSyntaxParser {
|
||||
template <CSSSyntaxVisitorReturn ReturnT, CSSComponentValueVisitor<ReturnT>... VisitorsT>
|
||||
friend struct CSSComponentValueVisitorDispatcher;
|
||||
friend class CSSValueParser;
|
||||
|
||||
public:
|
||||
/**
|
||||
@@ -231,17 +232,20 @@ class CSSSyntaxParser {
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the current token without consuming it.
|
||||
*/
|
||||
constexpr const CSSToken &peek() const
|
||||
{
|
||||
return currentToken_;
|
||||
}
|
||||
|
||||
private:
|
||||
constexpr CSSSyntaxParser(CSSSyntaxParser &parser, CSSTokenType terminator)
|
||||
: tokenizer_{parser.tokenizer_}, currentToken_{parser.currentToken_}, terminator_{terminator}
|
||||
{
|
||||
}
|
||||
|
||||
constexpr const CSSToken &peek() const
|
||||
{
|
||||
return currentToken_;
|
||||
}
|
||||
|
||||
constexpr CSSToken consumeToken()
|
||||
{
|
||||
auto prevToken = currentToken_;
|
||||
|
||||
@@ -29,14 +29,14 @@ namespace detail {
|
||||
template <typename DataT, TemplateStringLiteral Name, CSSDataType... AllowedComponentsT>
|
||||
requires(std::is_same_v<decltype(DataT::value), std::variant<AllowedComponentsT...>>)
|
||||
struct CSSVariantComponentTransformParser {
|
||||
static constexpr auto consumeFunctionBlock(const CSSFunctionBlock &func, CSSSyntaxParser &parser)
|
||||
static constexpr auto consumeFunctionBlock(const CSSFunctionBlock &func, CSSValueParser &parser)
|
||||
-> std::optional<DataT>
|
||||
{
|
||||
if (!iequals(func.name, Name)) {
|
||||
return {};
|
||||
}
|
||||
|
||||
auto val = parseNextCSSValue<AllowedComponentsT...>(parser);
|
||||
auto val = parser.parseNextValue<AllowedComponentsT...>();
|
||||
|
||||
return std::visit(
|
||||
[&](auto &&v) -> std::optional<DataT> {
|
||||
@@ -53,14 +53,14 @@ struct CSSVariantComponentTransformParser {
|
||||
template <typename DataT, TemplateStringLiteral Name>
|
||||
requires(std::is_same_v<decltype(DataT::value), float>)
|
||||
struct CSSNumberPercentTransformParser {
|
||||
static constexpr auto consumeFunctionBlock(const CSSFunctionBlock &func, CSSSyntaxParser &parser)
|
||||
static constexpr auto consumeFunctionBlock(const CSSFunctionBlock &func, CSSValueParser &parser)
|
||||
-> std::optional<DataT>
|
||||
{
|
||||
if (!iequals(func.name, Name)) {
|
||||
return {};
|
||||
}
|
||||
|
||||
auto val = parseNextCSSValue<CSSNumber, CSSPercentage>(parser);
|
||||
auto val = parser.parseNextValue<CSSNumber, CSSPercentage>();
|
||||
if (std::holds_alternative<std::monostate>(val)) {
|
||||
return {};
|
||||
}
|
||||
@@ -74,14 +74,14 @@ struct CSSNumberPercentTransformParser {
|
||||
template <typename DataT, TemplateStringLiteral Name>
|
||||
requires(std::is_same_v<decltype(DataT::degrees), float>)
|
||||
struct CSSAngleTransformParser {
|
||||
static constexpr auto consumeFunctionBlock(const CSSFunctionBlock &func, CSSSyntaxParser &parser)
|
||||
static constexpr auto consumeFunctionBlock(const CSSFunctionBlock &func, CSSValueParser &parser)
|
||||
-> std::optional<DataT>
|
||||
{
|
||||
if (!iequals(func.name, Name)) {
|
||||
return {};
|
||||
}
|
||||
|
||||
auto value = parseNextCSSValue<CSSAngle, CSSZero>(parser);
|
||||
auto value = parser.parseNextValue<CSSAngle, CSSZero>();
|
||||
if (std::holds_alternative<std::monostate>(value)) {
|
||||
return {};
|
||||
}
|
||||
@@ -105,7 +105,7 @@ struct CSSMatrix {
|
||||
|
||||
template <>
|
||||
struct CSSDataTypeParser<CSSMatrix> {
|
||||
static constexpr auto consumeFunctionBlock(const CSSFunctionBlock &func, CSSSyntaxParser &parser)
|
||||
static constexpr auto consumeFunctionBlock(const CSSFunctionBlock &func, CSSValueParser &parser)
|
||||
-> std::optional<CSSMatrix>
|
||||
{
|
||||
if (!iequals(func.name, "matrix")) {
|
||||
@@ -114,7 +114,7 @@ struct CSSDataTypeParser<CSSMatrix> {
|
||||
|
||||
CSSMatrix matrix{};
|
||||
for (int i = 0; i < 6; i++) {
|
||||
auto value = parseNextCSSValue<CSSNumber>(parser, i == 0 ? CSSDelimiter::None : CSSDelimiter::Comma);
|
||||
auto value = parser.parseNextValue<CSSNumber>(i == 0 ? CSSDelimiter::None : CSSDelimiter::Comma);
|
||||
if (std::holds_alternative<std::monostate>(value)) {
|
||||
return {};
|
||||
}
|
||||
@@ -139,19 +139,19 @@ struct CSSTranslate {
|
||||
|
||||
template <>
|
||||
struct CSSDataTypeParser<CSSTranslate> {
|
||||
static constexpr auto consumeFunctionBlock(const CSSFunctionBlock &func, CSSSyntaxParser &parser)
|
||||
static constexpr auto consumeFunctionBlock(const CSSFunctionBlock &func, CSSValueParser &parser)
|
||||
-> std::optional<CSSTranslate>
|
||||
{
|
||||
if (!iequals(func.name, "translate")) {
|
||||
return {};
|
||||
}
|
||||
|
||||
auto x = parseNextCSSValue<CSSLengthPercentage>(parser);
|
||||
auto x = parser.parseNextValue<CSSLengthPercentage>();
|
||||
if (std::holds_alternative<std::monostate>(x)) {
|
||||
return {};
|
||||
}
|
||||
|
||||
auto y = parseNextCSSValue<CSSLengthPercentage>(parser, CSSDelimiter::Comma);
|
||||
auto y = parser.parseNextValue<CSSLengthPercentage>(CSSDelimiter::Comma);
|
||||
|
||||
CSSTranslate translate{};
|
||||
translate.x = std::holds_alternative<CSSLength>(x)
|
||||
@@ -183,24 +183,24 @@ struct CSSTranslate3D {
|
||||
|
||||
template <>
|
||||
struct CSSDataTypeParser<CSSTranslate3D> {
|
||||
static constexpr auto consumeFunctionBlock(const CSSFunctionBlock &func, CSSSyntaxParser &parser)
|
||||
static constexpr auto consumeFunctionBlock(const CSSFunctionBlock &func, CSSValueParser &parser)
|
||||
-> std::optional<CSSTranslate3D>
|
||||
{
|
||||
if (!iequals(func.name, "translate3d")) {
|
||||
return {};
|
||||
}
|
||||
|
||||
auto x = parseNextCSSValue<CSSLengthPercentage>(parser);
|
||||
auto x = parser.parseNextValue<CSSLengthPercentage>();
|
||||
if (std::holds_alternative<std::monostate>(x)) {
|
||||
return {};
|
||||
}
|
||||
|
||||
auto y = parseNextCSSValue<CSSLengthPercentage>(parser, CSSDelimiter::Comma);
|
||||
auto y = parser.parseNextValue<CSSLengthPercentage>(CSSDelimiter::Comma);
|
||||
if (std::holds_alternative<std::monostate>(y)) {
|
||||
return {};
|
||||
}
|
||||
|
||||
auto z = parseNextCSSValue<CSSLength>(parser, CSSDelimiter::Comma);
|
||||
auto z = parser.parseNextValue<CSSLength>(CSSDelimiter::Comma);
|
||||
if (std::holds_alternative<std::monostate>(z)) {
|
||||
return {};
|
||||
}
|
||||
@@ -259,7 +259,7 @@ struct CSSScale {
|
||||
|
||||
template <>
|
||||
struct CSSDataTypeParser<CSSScale> {
|
||||
static constexpr auto consumeFunctionBlock(const CSSFunctionBlock &func, CSSSyntaxParser &parser)
|
||||
static constexpr auto consumeFunctionBlock(const CSSFunctionBlock &func, CSSValueParser &parser)
|
||||
-> std::optional<CSSScale>
|
||||
{
|
||||
if (!iequals(func.name, "scale")) {
|
||||
@@ -268,12 +268,12 @@ struct CSSDataTypeParser<CSSScale> {
|
||||
|
||||
// Transforms module level 2 allows percentage syntax
|
||||
// https://drafts.csswg.org/css-transforms-2/#transform-functions
|
||||
auto x = parseNextCSSValue<CSSNumber, CSSPercentage>(parser);
|
||||
auto x = parser.parseNextValue<CSSNumber, CSSPercentage>();
|
||||
if (std::holds_alternative<std::monostate>(x)) {
|
||||
return {};
|
||||
}
|
||||
|
||||
auto y = parseNextCSSValue<CSSNumber, CSSPercentage>(parser, CSSDelimiter::Comma);
|
||||
auto y = parser.parseNextValue<CSSNumber, CSSPercentage>(CSSDelimiter::Comma);
|
||||
|
||||
auto normX =
|
||||
std::holds_alternative<CSSNumber>(x) ? std::get<CSSNumber>(x).value : std::get<CSSPercentage>(x).value / 100.0f;
|
||||
@@ -411,14 +411,14 @@ struct CSSPerspective {
|
||||
|
||||
template <>
|
||||
struct CSSDataTypeParser<CSSPerspective> {
|
||||
static constexpr auto consumeFunctionBlock(const CSSFunctionBlock &func, CSSSyntaxParser &parser)
|
||||
static constexpr auto consumeFunctionBlock(const CSSFunctionBlock &func, CSSValueParser &parser)
|
||||
-> std::optional<CSSPerspective>
|
||||
{
|
||||
if (!iequals(func.name, "perspective")) {
|
||||
return {};
|
||||
}
|
||||
|
||||
auto value = parseNextCSSValue<CSSLength>(parser);
|
||||
auto value = parser.parseNextValue<CSSLength>();
|
||||
if (std::holds_alternative<std::monostate>(value) || std::get<CSSLength>(value).value < 0) {
|
||||
return {};
|
||||
}
|
||||
|
||||
@@ -45,7 +45,7 @@ struct CSSTransformOrigin {
|
||||
|
||||
template <>
|
||||
struct CSSDataTypeParser<CSSTransformOrigin> {
|
||||
static constexpr auto consume(CSSSyntaxParser &parser) -> std::optional<CSSTransformOrigin>
|
||||
static constexpr auto consume(CSSValueParser &parser) -> std::optional<CSSTransformOrigin>
|
||||
{
|
||||
// [ left | center | right | top | bottom | <length-percentage> ]
|
||||
// |
|
||||
@@ -54,19 +54,18 @@ struct CSSDataTypeParser<CSSTransformOrigin> {
|
||||
// |
|
||||
// [ [ center | left | right ] && [ center | top | bottom ] ] <length>?
|
||||
|
||||
auto firstValue = parseNextCSSValue<CSSLengthPercentage, CSSTransformOriginKeyword>(parser);
|
||||
auto firstValue = parser.parseNextValue<CSSLengthPercentage, CSSTransformOriginKeyword>();
|
||||
if (std::holds_alternative<std::monostate>(firstValue)) {
|
||||
return {};
|
||||
}
|
||||
|
||||
auto secondValue =
|
||||
parseNextCSSValue<CSSLengthPercentage, CSSTransformOriginKeyword>(parser, CSSDelimiter::Whitespace);
|
||||
auto secondValue = parser.parseNextValue<CSSLengthPercentage, CSSTransformOriginKeyword>(CSSDelimiter::Whitespace);
|
||||
|
||||
if (std::holds_alternative<std::monostate>(secondValue)) {
|
||||
return singleValue(firstValue);
|
||||
}
|
||||
|
||||
auto thirdValue = parseNextCSSValue<CSSLength>(parser, CSSDelimiter::Whitespace);
|
||||
auto thirdValue = parser.parseNextValue<CSSLength>(CSSDelimiter::Whitespace);
|
||||
|
||||
if (std::holds_alternative<CSSLength>(firstValue) || std::holds_alternative<CSSPercentage>(firstValue) ||
|
||||
std::holds_alternative<CSSLength>(secondValue) || std::holds_alternative<CSSPercentage>(secondValue)) {
|
||||
|
||||
@@ -18,12 +18,54 @@
|
||||
|
||||
namespace facebook::react {
|
||||
|
||||
namespace detail {
|
||||
|
||||
class CSSValueParser {
|
||||
public:
|
||||
explicit constexpr CSSValueParser(CSSSyntaxParser &parser) : parser_{parser} {}
|
||||
explicit constexpr CSSValueParser(CSSSyntaxParser &parser) : parser_{&parser} {}
|
||||
|
||||
constexpr CSSValueParser(const CSSValueParser &) = default;
|
||||
constexpr CSSValueParser &operator=(const CSSValueParser &) = default;
|
||||
|
||||
/**
|
||||
* Attempts to parse the next CSS value of a given set of data types, at the
|
||||
* current location of the parser, advancing the parser.
|
||||
*/
|
||||
template <CSSMaybeCompoundDataType... AllowedTypesT>
|
||||
constexpr auto parseNextValue(CSSDelimiter delimiter = CSSDelimiter::None)
|
||||
-> CSSVariantWithTypes<CSSMergedDataTypes<AllowedTypesT...>, std::monostate>
|
||||
{
|
||||
return consumeValue(delimiter, CSSMergedDataTypes<AllowedTypesT...>{});
|
||||
}
|
||||
|
||||
/**
|
||||
* Attempts to parse the next CSS value of a given set of data types, at the
|
||||
* current location of the parser, without advancing the parser.
|
||||
*/
|
||||
template <CSSMaybeCompoundDataType... AllowedTypesT>
|
||||
constexpr auto peekNextValue(CSSDelimiter delimiter = CSSDelimiter::None)
|
||||
-> CSSVariantWithTypes<CSSMergedDataTypes<AllowedTypesT...>, std::monostate>
|
||||
{
|
||||
auto savedParser = *parser_;
|
||||
auto ret = consumeValue(delimiter, CSSMergedDataTypes<AllowedTypesT...>{});
|
||||
*parser_ = savedParser;
|
||||
return ret;
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns a reference to the underlying CSSSyntaxParser. Use this for
|
||||
* syntax-level operations like consumeWhitespace(), consumeDelimiter(),
|
||||
* and isFinished().
|
||||
*/
|
||||
constexpr CSSSyntaxParser &syntaxParser()
|
||||
{
|
||||
return *parser_;
|
||||
}
|
||||
|
||||
constexpr const CSSSyntaxParser &syntaxParser() const
|
||||
{
|
||||
return *parser_;
|
||||
}
|
||||
|
||||
private:
|
||||
/*
|
||||
* Attempts to parse the characters starting at the current component value
|
||||
* into one of the given data types. Types are attempted in order, which the
|
||||
@@ -32,41 +74,32 @@ class CSSValueParser {
|
||||
*/
|
||||
template <CSSDataType... AllowedTypesT>
|
||||
constexpr std::variant<std::monostate, AllowedTypesT...> consumeValue(
|
||||
CSSDelimiter delimeter,
|
||||
CSSDelimiter delimiter,
|
||||
std::variant<AllowedTypesT...> /*unused*/)
|
||||
{
|
||||
using ReturnT = std::variant<std::monostate, AllowedTypesT...>;
|
||||
|
||||
auto consumedValue = tryConsumeParser<ReturnT, CSSDataTypeParser<AllowedTypesT>...>(delimeter);
|
||||
auto consumedValue = tryConsumeParser<ReturnT, CSSDataTypeParser<AllowedTypesT>...>(delimiter);
|
||||
|
||||
if (!std::holds_alternative<std::monostate>(consumedValue)) {
|
||||
return consumedValue;
|
||||
}
|
||||
|
||||
return parser_.consumeComponentValue<ReturnT>(
|
||||
delimeter,
|
||||
return parser_->consumeComponentValue<ReturnT>(
|
||||
delimiter,
|
||||
[&](const CSSPreservedToken &token) {
|
||||
return tryConsumePreservedToken<ReturnT, CSSDataTypeParser<AllowedTypesT>...>(token);
|
||||
},
|
||||
[&](const CSSSimpleBlock &block, CSSSyntaxParser &blockParser) {
|
||||
return tryConsumeSimpleBlock<ReturnT, CSSDataTypeParser<AllowedTypesT>...>(block, blockParser);
|
||||
CSSValueParser valueParser(blockParser);
|
||||
return tryConsumeSimpleBlock<ReturnT, CSSDataTypeParser<AllowedTypesT>...>(block, valueParser);
|
||||
},
|
||||
[&](const CSSFunctionBlock &func, CSSSyntaxParser &blockParser) {
|
||||
return tryConsumeFunctionBlock<ReturnT, CSSDataTypeParser<AllowedTypesT>...>(func, blockParser);
|
||||
CSSValueParser valueParser(blockParser);
|
||||
return tryConsumeFunctionBlock<ReturnT, CSSDataTypeParser<AllowedTypesT>...>(func, valueParser);
|
||||
});
|
||||
}
|
||||
|
||||
constexpr bool isFinished() const
|
||||
{
|
||||
return parser_.isFinished();
|
||||
}
|
||||
|
||||
constexpr void consumeWhitespace()
|
||||
{
|
||||
parser_.consumeWhitespace();
|
||||
}
|
||||
|
||||
private:
|
||||
template <typename ReturnT>
|
||||
constexpr ReturnT tryConsumePreservedToken(const CSSPreservedToken & /*token*/)
|
||||
{
|
||||
@@ -86,13 +119,13 @@ class CSSValueParser {
|
||||
}
|
||||
|
||||
template <typename ReturnT>
|
||||
constexpr ReturnT tryConsumeSimpleBlock(const CSSSimpleBlock & /*token*/, CSSSyntaxParser & /*blockParser*/)
|
||||
constexpr ReturnT tryConsumeSimpleBlock(const CSSSimpleBlock & /*token*/, CSSValueParser & /*blockParser*/)
|
||||
{
|
||||
return {};
|
||||
}
|
||||
|
||||
template <typename ReturnT, CSSValidDataTypeParser ParserT, CSSValidDataTypeParser... RestParserT>
|
||||
constexpr ReturnT tryConsumeSimpleBlock(const CSSSimpleBlock &block, CSSSyntaxParser &blockParser)
|
||||
constexpr ReturnT tryConsumeSimpleBlock(const CSSSimpleBlock &block, CSSValueParser &blockParser)
|
||||
{
|
||||
if constexpr (CSSSimpleBlockSink<ParserT>) {
|
||||
auto currentParser = blockParser;
|
||||
@@ -106,13 +139,13 @@ class CSSValueParser {
|
||||
}
|
||||
|
||||
template <typename ReturnT>
|
||||
constexpr ReturnT tryConsumeFunctionBlock(const CSSFunctionBlock & /*func*/, CSSSyntaxParser & /*blockParser*/)
|
||||
constexpr ReturnT tryConsumeFunctionBlock(const CSSFunctionBlock & /*func*/, CSSValueParser & /*blockParser*/)
|
||||
{
|
||||
return {};
|
||||
}
|
||||
|
||||
template <typename ReturnT, CSSValidDataTypeParser ParserT, CSSValidDataTypeParser... RestParserT>
|
||||
constexpr ReturnT tryConsumeFunctionBlock(const CSSFunctionBlock &func, CSSSyntaxParser &blockParser)
|
||||
constexpr ReturnT tryConsumeFunctionBlock(const CSSFunctionBlock &func, CSSValueParser &blockParser)
|
||||
{
|
||||
if constexpr (CSSFunctionBlockSink<ParserT>) {
|
||||
auto currentParser = blockParser;
|
||||
@@ -126,32 +159,30 @@ class CSSValueParser {
|
||||
}
|
||||
|
||||
template <typename ReturnT>
|
||||
constexpr ReturnT tryConsumeParser(CSSDelimiter /*delimeter*/)
|
||||
constexpr ReturnT tryConsumeParser(CSSDelimiter /*delimiter*/)
|
||||
{
|
||||
return {};
|
||||
}
|
||||
|
||||
template <typename ReturnT, CSSValidDataTypeParser ParserT, CSSValidDataTypeParser... RestParserT>
|
||||
constexpr ReturnT tryConsumeParser(CSSDelimiter delimeter)
|
||||
constexpr ReturnT tryConsumeParser(CSSDelimiter delimiter)
|
||||
{
|
||||
if constexpr (CSSParserSink<ParserT>) {
|
||||
auto originalParser = parser_;
|
||||
if (parser_.consumeDelimiter(delimeter)) {
|
||||
if (auto ret = ParserT::consume(parser_)) {
|
||||
auto originalParser = *parser_;
|
||||
if (parser_->consumeDelimiter(delimiter)) {
|
||||
if (auto ret = ParserT::consume(*this)) {
|
||||
return *ret;
|
||||
}
|
||||
}
|
||||
parser_ = originalParser;
|
||||
*parser_ = originalParser;
|
||||
}
|
||||
|
||||
return tryConsumeParser<ReturnT, RestParserT...>(delimeter);
|
||||
return tryConsumeParser<ReturnT, RestParserT...>(delimiter);
|
||||
}
|
||||
|
||||
CSSSyntaxParser &parser_;
|
||||
CSSSyntaxParser *parser_;
|
||||
};
|
||||
|
||||
} // namespace detail
|
||||
|
||||
/**
|
||||
* Parse a single CSS property value. Returns a variant holding std::monostate
|
||||
* on syntax error.
|
||||
@@ -161,44 +192,17 @@ constexpr auto parseCSSProperty(std::string_view css)
|
||||
-> CSSVariantWithTypes<CSSMergedDataTypes<CSSWideKeyword, AllowedTypesT...>, std::monostate>
|
||||
{
|
||||
CSSSyntaxParser syntaxParser(css);
|
||||
detail::CSSValueParser parser(syntaxParser);
|
||||
CSSValueParser parser(syntaxParser);
|
||||
|
||||
parser.consumeWhitespace();
|
||||
auto value = parser.consumeValue(CSSDelimiter::None, CSSMergedDataTypes<CSSWideKeyword, AllowedTypesT...>{});
|
||||
parser.consumeWhitespace();
|
||||
syntaxParser.consumeWhitespace();
|
||||
auto value = parser.parseNextValue<CSSWideKeyword, AllowedTypesT...>();
|
||||
syntaxParser.consumeWhitespace();
|
||||
|
||||
if (parser.isFinished()) {
|
||||
if (syntaxParser.isFinished()) {
|
||||
return value;
|
||||
}
|
||||
|
||||
return {};
|
||||
};
|
||||
|
||||
/**
|
||||
* Attempts to parse the next CSS value of a given set of data types, at the
|
||||
* current location of the syntax parser, advancing the syntax parser
|
||||
*/
|
||||
template <CSSMaybeCompoundDataType... AllowedTypesT>
|
||||
constexpr auto parseNextCSSValue(CSSSyntaxParser &syntaxParser, CSSDelimiter delimeter = CSSDelimiter::None)
|
||||
-> CSSVariantWithTypes<CSSMergedDataTypes<AllowedTypesT...>, std::monostate>
|
||||
{
|
||||
detail::CSSValueParser valueParser(syntaxParser);
|
||||
return valueParser.consumeValue(delimeter, CSSMergedDataTypes<AllowedTypesT...>{});
|
||||
}
|
||||
|
||||
/**
|
||||
* Attempts to parse the next CSS value of a given set of data types, at the
|
||||
* current location of the syntax parser, without advancing the syntax parser
|
||||
*/
|
||||
template <CSSMaybeCompoundDataType... AllowedTypesT>
|
||||
constexpr auto peekNextCSSValue(CSSSyntaxParser &syntaxParser, CSSDelimiter delimeter = CSSDelimiter::None)
|
||||
-> CSSVariantWithTypes<CSSMergedDataTypes<AllowedTypesT...>, std::monostate>
|
||||
{
|
||||
auto savedParser = syntaxParser;
|
||||
detail::CSSValueParser valueParser(syntaxParser);
|
||||
auto ret = valueParser.consumeValue(delimeter, CSSMergedDataTypes<AllowedTypesT...>{});
|
||||
syntaxParser = savedParser;
|
||||
return ret;
|
||||
}
|
||||
|
||||
} // namespace facebook::react
|
||||
@@ -21,8 +21,8 @@ struct ConsumeDataType {
|
||||
template <>
|
||||
struct CSSDataTypeParser<ConsumeDataType> {
|
||||
constexpr static std::optional<ConsumeDataType> consume(
|
||||
CSSSyntaxParser& parser) {
|
||||
auto val = parseNextCSSValue<CSSNumber>(parser);
|
||||
CSSValueParser& parser) {
|
||||
auto val = parser.parseNextValue<CSSNumber>();
|
||||
if (std::holds_alternative<CSSNumber>(val)) {
|
||||
return ConsumeDataType{std::get<CSSNumber>(val).value};
|
||||
}
|
||||
@@ -34,32 +34,33 @@ struct CSSDataTypeParser<ConsumeDataType> {
|
||||
static_assert(CSSDataType<ConsumeDataType>);
|
||||
|
||||
TEST(CSSValueParser, consume_multiple_with_delimeter) {
|
||||
CSSSyntaxParser parser{"1 2, 3, 4 / 5"};
|
||||
CSSSyntaxParser syntaxParser{"1 2, 3, 4 / 5"};
|
||||
CSSValueParser parser{syntaxParser};
|
||||
|
||||
auto next = parseNextCSSValue<ConsumeDataType>(parser);
|
||||
auto next = parser.parseNextValue<ConsumeDataType>();
|
||||
EXPECT_TRUE(std::holds_alternative<ConsumeDataType>(next));
|
||||
EXPECT_EQ(std::get<ConsumeDataType>(next).number, 1);
|
||||
|
||||
next = parseNextCSSValue<ConsumeDataType>(parser, CSSDelimiter::None);
|
||||
next = parser.parseNextValue<ConsumeDataType>(CSSDelimiter::None);
|
||||
EXPECT_FALSE(std::holds_alternative<ConsumeDataType>(next));
|
||||
|
||||
next = parseNextCSSValue<ConsumeDataType>(parser, CSSDelimiter::Whitespace);
|
||||
next = parser.parseNextValue<ConsumeDataType>(CSSDelimiter::Whitespace);
|
||||
EXPECT_TRUE(std::holds_alternative<ConsumeDataType>(next));
|
||||
EXPECT_EQ(std::get<ConsumeDataType>(next).number, 2);
|
||||
|
||||
next = parseNextCSSValue<ConsumeDataType>(parser, CSSDelimiter::Comma);
|
||||
next = parser.parseNextValue<ConsumeDataType>(CSSDelimiter::Comma);
|
||||
EXPECT_TRUE(std::holds_alternative<ConsumeDataType>(next));
|
||||
EXPECT_EQ(std::get<ConsumeDataType>(next).number, 3);
|
||||
|
||||
next = parseNextCSSValue<ConsumeDataType>(parser, CSSDelimiter::Comma);
|
||||
next = parser.parseNextValue<ConsumeDataType>(CSSDelimiter::Comma);
|
||||
EXPECT_TRUE(std::holds_alternative<ConsumeDataType>(next));
|
||||
EXPECT_EQ(std::get<ConsumeDataType>(next).number, 4);
|
||||
|
||||
next = parseNextCSSValue<ConsumeDataType>(parser, CSSDelimiter::Solidus);
|
||||
next = parser.parseNextValue<ConsumeDataType>(CSSDelimiter::Solidus);
|
||||
EXPECT_TRUE(std::holds_alternative<ConsumeDataType>(next));
|
||||
EXPECT_EQ(std::get<ConsumeDataType>(next).number, 5);
|
||||
|
||||
next = parseNextCSSValue<ConsumeDataType>(parser);
|
||||
next = parser.parseNextValue<ConsumeDataType>();
|
||||
EXPECT_FALSE(std::holds_alternative<ConsumeDataType>(next));
|
||||
}
|
||||
|
||||
|
||||
+2
-1
@@ -32,6 +32,7 @@ std::vector<MarginValue> parseNormalizedRootMargin(
|
||||
|
||||
std::vector<MarginValue> values;
|
||||
CSSSyntaxParser syntaxParser(marginStr);
|
||||
CSSValueParser valueParser(syntaxParser);
|
||||
|
||||
// Parse exactly 4 space-separated values
|
||||
while (!syntaxParser.isFinished() && values.size() < 4) {
|
||||
@@ -40,7 +41,7 @@ std::vector<MarginValue> parseNormalizedRootMargin(
|
||||
break;
|
||||
}
|
||||
|
||||
auto parsed = parseNextCSSValue<CSSLength, CSSPercentage>(syntaxParser);
|
||||
auto parsed = valueParser.parseNextValue<CSSLength, CSSPercentage>();
|
||||
|
||||
if (std::holds_alternative<CSSLength>(parsed)) {
|
||||
auto length = std::get<CSSLength>(parsed);
|
||||
|
||||
Reference in new issue
Block a user