void MediaQueryParser::readMediaType(CSSParserTokenType type, const CSSParserToken& token)
{
    if (type == LeftParenthesisToken) {
        if (m_mediaQueryData.restrictor() != MediaQuery::None)
            m_state = SkipUntilComma;
        else
            m_state = ReadFeature;
    } else if (type == IdentToken) {
        if (m_state == ReadRestrictor && equalIgnoringCase(token.value(), "not")) {
            setStateAndRestrict(ReadMediaType, MediaQuery::Not);
        } else if (m_state == ReadRestrictor && equalIgnoringCase(token.value(), "only")) {
            setStateAndRestrict(ReadMediaType, MediaQuery::Only);
        } else if (m_mediaQueryData.restrictor() != MediaQuery::None
                   && isRestrictorOrLogicalOperator(token.value())) {
            m_state = SkipUntilComma;
        } else {
            m_mediaQueryData.setMediaType(token.value());
            m_state = ReadAnd;
        }
    } else if (type == EOFToken && (!m_querySet->queryVector().size() || m_state != ReadRestrictor)) {
        m_state = Done;
    } else {
        m_state = SkipUntilComma;
        if (type == CommaToken)
            skipUntilComma(type, token);
    }
}
Example #2
0
static bool isRestrictorOrLogicalOperator(const CSSParserToken& token)
{
    // FIXME: it would be more efficient to use lower-case always for tokenValue.
    return equalIgnoringASCIICase(token.value(), "not")
           || equalIgnoringASCIICase(token.value(), "and")
           || equalIgnoringASCIICase(token.value(), "or")
           || equalIgnoringASCIICase(token.value(), "only");
}
void MediaQueryParser::readMediaNot(CSSParserTokenType type, const CSSParserToken& token)
{
    if (type == IdentToken && equalIgnoringCase(token.value(), "not"))
        setStateAndRestrict(ReadFeatureStart, MediaQuery::Not);
    else
        readFeatureStart(type, token);
}
bool CSSVariableParser::isValidVariableName(const CSSParserToken& token)
{
    if (token.type() != IdentToken)
        return false;

    CSSParserString value = token.value();
    return value.length() >= 2 && value[0] == '-' && value[1] == '-';
}
void MediaQueryParser::readFeature(CSSParserTokenType type, const CSSParserToken& token)
{
    if (type == IdentToken) {
        m_mediaQueryData.setMediaFeature(token.value());
        m_state = ReadFeatureColon;
    } else {
        m_state = SkipUntilComma;
    }
}
Example #6
0
void MediaQueryParser::readFeature(CSSParserTokenType type, const CSSParserToken& token)
{
    if (type == IdentToken) {
        // FIXME-NEWPARSER: Find a way to avoid this.
        const_cast<CSSParserToken&>(token).convertToASCIILowercaseInPlace();
        m_mediaQueryData.setMediaFeature(token.value().toString());
        m_state = ReadFeatureColon;
    } else
        m_state = SkipUntilComma;
}
Example #7
0
void MediaQueryParser::readAnd(CSSParserTokenType type, const CSSParserToken& token)
{
    if (type == IdentToken && equalIgnoringASCIICase(token.value(), "and")) {
        m_state = ReadFeatureStart;
    } else if (type == CommaToken && m_parserType != MediaConditionParser) {
        commitMediaQuery();
        m_state = ReadRestrictor;
    } else if (type == EOFToken)
        m_state = Done;
    else
        m_state = SkipUntilComma;
}
Example #8
0
void compareTokens(const CSSParserToken& expected, const CSSParserToken& actual)
{
    ASSERT_EQ(expected.type(), actual.type());
    switch (expected.type()) {
    case DelimiterToken:
        ASSERT_EQ(expected.delimiter(), actual.delimiter());
        break;
    case IdentToken:
    case FunctionToken:
    case StringToken:
    case UrlToken:
        ASSERT_EQ(expected.value(), actual.value());
        break;
    case DimensionToken:
        ASSERT_EQ(expected.value(), actual.value());
        // fallthrough
    case NumberToken:
    case PercentageToken:
        ASSERT_EQ(expected.numericValueType(), actual.numericValueType());
        ASSERT_DOUBLE_EQ(expected.numericValue(), actual.numericValue());
        break;
    case UnicodeRangeToken:
        ASSERT_EQ(expected.unicodeRangeStart(), actual.unicodeRangeStart());
        ASSERT_EQ(expected.unicodeRangeEnd(), actual.unicodeRangeEnd());
        break;
    case HashToken:
        ASSERT_EQ(expected.value(), actual.value());
        ASSERT_EQ(expected.hashTokenType(), actual.hashTokenType());
        break;
    default:
        break;
    }
}
void MediaQueryParser::readAnd(CSSParserTokenType type, const CSSParserToken& token)
{
    if (type == IdentToken && equalIgnoringCase(token.value(), "and")) {
        m_state = ReadFeatureStart;
    } else if (type == CommaToken && m_parserType != MediaConditionParser) {
        m_querySet->addMediaQuery(m_mediaQueryData.takeMediaQuery());
        m_state = ReadRestrictor;
    } else if (type == EOFToken) {
        m_state = Done;
    } else {
        m_state = SkipUntilComma;
    }
}
Example #10
0
void CSSVariableData::consumeAndUpdateTokens(const CSSParserTokenRange& range)
{
    StringBuilder stringBuilder;
    CSSParserTokenRange localRange = range;

    while (!localRange.atEnd()) {
        CSSParserToken token = localRange.consume();
        if (token.hasStringBacking())
            stringBuilder.append(token.value());
    }
    m_backingString = stringBuilder.toString();
    if (m_backingString.is8Bit())
        updateTokens<LChar>(range);
    else
        updateTokens<UChar>(range);
}
Example #11
0
void MediaQueryData::addParserValue(CSSParserTokenType type, const CSSParserToken& token)
{
    CSSParserValue value;
    if (type == NumberToken || type == PercentageToken || type == DimensionToken) {
        value.setFromNumber(token.numericValue(), token.unitType());
        value.isInt = (token.numericValueType() == IntegerValueType);
    } else if (type == DelimiterToken) {
        value.unit = CSSParserValue::Operator;
        value.iValue = token.delimiter();
        value.id = CSSValueInvalid;
        value.isInt = false;
    } else {
        CSSParserString tokenValue;
        tokenValue.init(token.value());
        value.unit = CSSPrimitiveValue::CSS_IDENT;
        value.string = tokenValue;
        value.id = cssValueKeywordID(tokenValue);
        value.isInt = false;
    }
    m_valueList.addValue(value);
}