CSSSupportsParser.cpp [plain text]
#include "config.h"
#include "CSSSupportsParser.h"
#include "CSSParserImpl.h"
namespace WebCore {
CSSSupportsParser::SupportsResult CSSSupportsParser::supportsCondition(CSSParserTokenRange range, CSSParserImpl& parser, SupportsParsingMode mode)
{
range.consumeWhitespace();
CSSSupportsParser supportsParser(parser);
auto result = supportsParser.consumeCondition(range);
if (mode != ForWindowCSS || result != Invalid)
return result;
return supportsParser.consumeDeclarationConditionOrGeneralEnclosed(range);
}
enum ClauseType { Unresolved, Conjunction, Disjunction };
CSSSupportsParser::SupportsResult CSSSupportsParser::consumeCondition(CSSParserTokenRange range)
{
if (range.peek().type() == IdentToken || range.peek().type() == FunctionToken)
return consumeNegation(range);
bool result;
ClauseType clauseType = Unresolved;
auto previousTokenType = IdentToken;
while (true) {
SupportsResult nextResult = consumeConditionInParenthesis(range, previousTokenType);
if (nextResult == Invalid)
return Invalid;
bool nextSupported = nextResult;
if (clauseType == Unresolved)
result = nextSupported;
else if (clauseType == Conjunction)
result &= nextSupported;
else
result |= nextSupported;
if (range.atEnd())
break;
range.consumeWhitespace();
if (range.atEnd())
break;
const CSSParserToken& token = range.peek();
if (token.type() != IdentToken && token.type() != FunctionToken)
return Invalid;
previousTokenType = token.type();
if (clauseType == Unresolved)
clauseType = token.value().length() == 3 ? Conjunction : Disjunction;
if ((clauseType == Conjunction && !equalIgnoringASCIICase(token.value(), "and"))
|| (clauseType == Disjunction && !equalIgnoringASCIICase(token.value(), "or")))
return Invalid;
if (token.type() == IdentToken)
range.consumeIncludingWhitespace();
}
return result ? Supported : Unsupported;
}
CSSSupportsParser::SupportsResult CSSSupportsParser::consumeNegation(CSSParserTokenRange range)
{
ASSERT(range.peek().type() == IdentToken || range.peek().type() == FunctionToken);
auto tokenType = range.peek().type();
if (!equalIgnoringASCIICase(range.peek().value(), "not"))
return Invalid;
if (range.peek().type() == IdentToken)
range.consumeIncludingWhitespace();
SupportsResult result = consumeConditionInParenthesis(range, tokenType);
range.consumeWhitespace();
if (!range.atEnd() || result == Invalid)
return Invalid;
return result ? Unsupported : Supported;
}
CSSSupportsParser::SupportsResult CSSSupportsParser::consumeDeclarationConditionOrGeneralEnclosed(CSSParserTokenRange& range)
{
if (range.peek().type() == FunctionToken) {
range.consumeComponentValue();
return Unsupported;
}
return range.peek().type() == IdentToken && m_parser.supportsDeclaration(range) ? Supported : Unsupported;
}
CSSSupportsParser::SupportsResult CSSSupportsParser::consumeConditionInParenthesis(CSSParserTokenRange& range, CSSParserTokenType startTokenType)
{
if (startTokenType == IdentToken && range.peek().type() != LeftParenthesisToken)
return Invalid;
CSSParserTokenRange innerRange = range.consumeBlock();
innerRange.consumeWhitespace();
SupportsResult result = consumeCondition(innerRange);
if (result != Invalid)
return result;
return consumeDeclarationConditionOrGeneralEnclosed(innerRange);
}
}