{
switch (type) {
case CSSPrimitiveValue::CSS_NUMBER:
- return CalcNumber;
+ return CalculationCategory::Number;
case CSSPrimitiveValue::CSS_EMS:
case CSSPrimitiveValue::CSS_EXS:
case CSSPrimitiveValue::CSS_PX:
case CSSPrimitiveValue::CSS_VH:
case CSSPrimitiveValue::CSS_VMIN:
case CSSPrimitiveValue::CSS_VMAX:
- return CalcLength;
+ return CalculationCategory::Length;
case CSSPrimitiveValue::CSS_PERCENTAGE:
- return CalcPercent;
+ return CalculationCategory::Percent;
case CSSPrimitiveValue::CSS_DEG:
case CSSPrimitiveValue::CSS_RAD:
case CSSPrimitiveValue::CSS_GRAD:
case CSSPrimitiveValue::CSS_TURN:
- return CalcAngle;
+ return CalculationCategory::Angle;
case CSSPrimitiveValue::CSS_MS:
case CSSPrimitiveValue::CSS_S:
- return CalcTime;
+ return CalculationCategory::Time;
case CSSPrimitiveValue::CSS_HZ:
case CSSPrimitiveValue::CSS_KHZ:
- return CalcFrequency;
+ return CalculationCategory::Frequency;
default:
- return CalcOther;
+ return CalculationCategory::Other;
}
}
std::unique_ptr<CalcExpressionNode> createCalcExpression(const CSSToLengthConversionData& conversionData) const final
{
switch (category()) {
- case CalcNumber:
+ case CalculationCategory::Number:
return std::make_unique<CalcExpressionNumber>(m_value->floatValue());
- case CalcLength:
+ case CalculationCategory::Length:
return std::make_unique<CalcExpressionLength>(Length(m_value->computeLength<float>(conversionData), WebCore::Fixed));
- case CalcPercent:
- case CalcPercentLength: {
+ case CalculationCategory::Percent:
+ case CalculationCategory::PercentLength: {
return std::make_unique<CalcExpressionLength>(m_value->convertToLength<FixedFloatConversion | PercentConversion>(conversionData));
}
// Only types that could be part of a Length expression can be converted
- // to a CalcExpressionNode. CalcPercentNumber makes no sense as a Length.
- case CalcPercentNumber:
- case CalcAngle:
- case CalcTime:
- case CalcFrequency:
- case CalcOther:
+ // to a CalcExpressionNode. CalculationCategory::PercentNumber makes no sense as a Length.
+ case CalculationCategory::PercentNumber:
+ case CalculationCategory::Angle:
+ case CalculationCategory::Time:
+ case CalculationCategory::Frequency:
+ case CalculationCategory::Other:
ASSERT_NOT_REACHED();
}
ASSERT_NOT_REACHED();
double computeLengthPx(const CSSToLengthConversionData& conversionData) const final
{
switch (category()) {
- case CalcLength:
+ case CalculationCategory::Length:
return m_value->computeLength<double>(conversionData);
- case CalcPercent:
- case CalcNumber:
+ case CalculationCategory::Percent:
+ case CalculationCategory::Number:
return m_value->doubleValue();
- case CalcPercentLength:
- case CalcPercentNumber:
- case CalcAngle:
- case CalcTime:
- case CalcFrequency:
- case CalcOther:
+ case CalculationCategory::PercentLength:
+ case CalculationCategory::PercentNumber:
+ case CalculationCategory::Angle:
+ case CalculationCategory::Time:
+ case CalculationCategory::Frequency:
+ case CalculationCategory::Other:
ASSERT_NOT_REACHED();
break;
}
Ref<CSSPrimitiveValue> m_value;
};
-static const CalculationCategory addSubtractResult[CalcAngle][CalcAngle] = {
-// CalcNumber CalcLength CalcPercent CalcPercentNumber CalcPercentLength
- { CalcNumber, CalcOther, CalcPercentNumber, CalcPercentNumber, CalcOther }, // CalcNumber
- { CalcOther, CalcLength, CalcPercentLength, CalcOther, CalcPercentLength }, // CalcLength
- { CalcPercentNumber, CalcPercentLength, CalcPercent, CalcPercentNumber, CalcPercentLength }, // CalcPercent
- { CalcPercentNumber, CalcOther, CalcPercentNumber, CalcPercentNumber, CalcOther }, // CalcPercentNumber
- { CalcOther, CalcPercentLength, CalcPercentLength, CalcOther, CalcPercentLength }, // CalcPercentLength
+static const CalculationCategory addSubtractResult[static_cast<unsigned>(CalculationCategory::Angle)][static_cast<unsigned>(CalculationCategory::Angle)] = {
+// CalculationCategory::Number CalculationCategory::Length CalculationCategory::Percent CalculationCategory::PercentNumber CalculationCategory::PercentLength
+ { CalculationCategory::Number, CalculationCategory::Other, CalculationCategory::PercentNumber, CalculationCategory::PercentNumber, CalculationCategory::Other }, // CalculationCategory::Number
+ { CalculationCategory::Other, CalculationCategory::Length, CalculationCategory::PercentLength, CalculationCategory::Other, CalculationCategory::PercentLength }, // CalculationCategory::Length
+ { CalculationCategory::PercentNumber, CalculationCategory::PercentLength, CalculationCategory::Percent, CalculationCategory::PercentNumber, CalculationCategory::PercentLength }, // CalculationCategory::Percent
+ { CalculationCategory::PercentNumber, CalculationCategory::Other, CalculationCategory::PercentNumber, CalculationCategory::PercentNumber, CalculationCategory::Other }, // CalculationCategory::PercentNumber
+ { CalculationCategory::Other, CalculationCategory::PercentLength, CalculationCategory::PercentLength, CalculationCategory::Other, CalculationCategory::PercentLength }, // CalculationCategory::PercentLength
};
static CalculationCategory determineCategory(const CSSCalcExpressionNode& leftSide, const CSSCalcExpressionNode& rightSide, CalcOperator op)
{
CalculationCategory leftCategory = leftSide.category();
CalculationCategory rightCategory = rightSide.category();
- ASSERT(leftCategory < CalcOther);
- ASSERT(rightCategory < CalcOther);
+ ASSERT(leftCategory < CalculationCategory::Other);
+ ASSERT(rightCategory < CalculationCategory::Other);
switch (op) {
- case CalcAdd:
- case CalcSubtract:
- if (leftCategory < CalcAngle && rightCategory < CalcAngle)
- return addSubtractResult[leftCategory][rightCategory];
+ case CalcOperator::Add:
+ case CalcOperator::Subtract:
+ if (leftCategory < CalculationCategory::Angle && rightCategory < CalculationCategory::Angle)
+ return addSubtractResult[static_cast<unsigned>(leftCategory)][static_cast<unsigned>(rightCategory)];
if (leftCategory == rightCategory)
return leftCategory;
- return CalcOther;
- case CalcMultiply:
- if (leftCategory != CalcNumber && rightCategory != CalcNumber)
- return CalcOther;
- return leftCategory == CalcNumber ? rightCategory : leftCategory;
- case CalcDivide:
- if (rightCategory != CalcNumber || rightSide.isZero())
- return CalcOther;
+ return CalculationCategory::Other;
+ case CalcOperator::Multiply:
+ if (leftCategory != CalculationCategory::Number && rightCategory != CalculationCategory::Number)
+ return CalculationCategory::Other;
+ return leftCategory == CalculationCategory::Number ? rightCategory : leftCategory;
+ case CalcOperator::Divide:
+ if (rightCategory != CalculationCategory::Number || rightSide.isZero())
+ return CalculationCategory::Other;
return leftCategory;
- case CalcMin:
- case CalcMax:
+ case CalcOperator::Min:
+ case CalcOperator::Max:
ASSERT_NOT_REACHED();
- return CalcOther;
+ return CalculationCategory::Other;
}
ASSERT_NOT_REACHED();
- return CalcOther;
+ return CalculationCategory::Other;
}
static CalculationCategory resolvedTypeForMinOrMax(CalculationCategory category, CalculationCategory destinationCategory)
{
switch (category) {
- case CalcNumber:
- case CalcLength:
- case CalcPercentNumber:
- case CalcPercentLength:
- case CalcAngle:
- case CalcTime:
- case CalcFrequency:
- case CalcOther:
+ case CalculationCategory::Number:
+ case CalculationCategory::Length:
+ case CalculationCategory::PercentNumber:
+ case CalculationCategory::PercentLength:
+ case CalculationCategory::Angle:
+ case CalculationCategory::Time:
+ case CalculationCategory::Frequency:
+ case CalculationCategory::Other:
return category;
- case CalcPercent:
- if (destinationCategory == CalcLength)
- return CalcPercentLength;
- if (destinationCategory == CalcNumber)
- return CalcPercentNumber;
+ case CalculationCategory::Percent:
+ if (destinationCategory == CalculationCategory::Length)
+ return CalculationCategory::PercentLength;
+ if (destinationCategory == CalculationCategory::Number)
+ return CalculationCategory::PercentNumber;
return category;
}
- return CalcOther;
+ return CalculationCategory::Other;
}
static inline bool isIntegerResult(CalcOperator op, const CSSCalcExpressionNode& leftSide, const CSSCalcExpressionNode& rightSide)
{
// Performs W3C spec's type checking for calc integers.
// http://www.w3.org/TR/css3-values/#calc-type-checking
- return op != CalcDivide && leftSide.isInteger() && rightSide.isInteger();
+ return op != CalcOperator::Divide && leftSide.isInteger() && rightSide.isInteger();
}
static inline bool isIntegerResult(CalcOperator op, const Vector<Ref<CSSCalcExpressionNode>>& nodes)
{
// Performs W3C spec's type checking for calc integers.
// http://www.w3.org/TR/css3-values/#calc-type-checking
- if (op == CalcDivide)
+ if (op == CalcOperator::Divide)
return false;
for (auto& node : nodes) {
if (!leftSide || !rightSide)
return nullptr;
- ASSERT(leftSide->category() < CalcOther);
- ASSERT(rightSide->category() < CalcOther);
+ ASSERT(leftSide->category() < CalculationCategory::Other);
+ ASSERT(rightSide->category() < CalculationCategory::Other);
auto newCategory = determineCategory(*leftSide, *rightSide, op);
- if (newCategory == CalcOther)
+ if (newCategory == CalculationCategory::Other)
return nullptr;
return adoptRef(new CSSCalcOperation(newCategory, op, leftSide.releaseNonNull(), rightSide.releaseNonNull()));
static RefPtr<CSSCalcOperation> createMinOrMax(CalcOperator op, Vector<Ref<CSSCalcExpressionNode>>&& values, CalculationCategory destinationCategory)
{
- ASSERT(op == CalcMin || op == CalcMax);
+ ASSERT(op == CalcOperator::Min || op == CalcOperator::Max);
std::optional<CalculationCategory> category = std::nullopt;
for (auto& value : values) {
auto valueCategory = resolvedTypeForMinOrMax(value->category(), destinationCategory);
- ASSERT(valueCategory < CalcOther);
+ ASSERT(valueCategory < CalculationCategory::Other);
if (!category) {
- if (valueCategory == CalcOther)
+ if (valueCategory == CalculationCategory::Other)
return nullptr;
category = valueCategory;
}
if (category != valueCategory) {
- if (isSamePair(category.value(), valueCategory, CalcLength, CalcPercentLength)) {
- category = CalcPercentLength;
+ if (isSamePair(category.value(), valueCategory, CalculationCategory::Length, CalculationCategory::PercentLength)) {
+ category = CalculationCategory::PercentLength;
continue;
}
- if (isSamePair(category.value(), valueCategory, CalcNumber, CalcPercentNumber)) {
- category = CalcPercentNumber;
+ if (isSamePair(category.value(), valueCategory, CalculationCategory::Number, CalculationCategory::PercentNumber)) {
+ category = CalculationCategory::PercentNumber;
continue;
}
return nullptr;
auto leftCategory = leftSide->category();
auto rightCategory = rightSide->category();
- ASSERT(leftCategory < CalcOther);
- ASSERT(rightCategory < CalcOther);
+ ASSERT(leftCategory < CalculationCategory::Other);
+ ASSERT(rightCategory < CalculationCategory::Other);
bool isInteger = isIntegerResult(op, *leftSide, *rightSide);
// Simplify numbers.
- if (leftCategory == CalcNumber && rightCategory == CalcNumber) {
+ if (leftCategory == CalculationCategory::Number && rightCategory == CalculationCategory::Number) {
CSSPrimitiveValue::UnitType evaluationType = CSSPrimitiveValue::CSS_NUMBER;
return CSSCalcPrimitiveValue::create(evaluateOperator(op, { leftSide->doubleValue(), rightSide->doubleValue() }), evaluationType, isInteger);
}
// Simplify addition and subtraction between same types.
- if (op == CalcAdd || op == CalcSubtract) {
+ if (op == CalcOperator::Add || op == CalcOperator::Subtract) {
if (leftCategory == rightSide->category()) {
CSSPrimitiveValue::UnitType leftType = leftSide->primitiveType();
if (hasDoubleValue(leftType)) {
}
} else {
// Simplify multiplying or dividing by a number for simplifiable types.
- ASSERT(op == CalcMultiply || op == CalcDivide);
+ ASSERT(op == CalcOperator::Multiply || op == CalcOperator::Divide);
auto* numberSide = getNumberSide(*leftSide, *rightSide);
if (!numberSide)
return create(op, leftSide.releaseNonNull(), rightSide.releaseNonNull());
- if (numberSide == leftSide && op == CalcDivide)
+ if (numberSide == leftSide && op == CalcOperator::Divide)
return nullptr;
auto& otherSide = leftSide == numberSide ? *rightSide : *leftSide;
double number = numberSide->doubleValue();
if (!std::isfinite(number))
return nullptr;
- if (op == CalcDivide && !number)
+ if (op == CalcOperator::Divide && !number)
return nullptr;
auto otherType = otherSide.primitiveType();
StringBuilder result;
result.append('(');
switch (op) {
- case CalcAdd:
- case CalcSubtract:
- case CalcMultiply:
- case CalcDivide:
+ case CalcOperator::Add:
+ case CalcOperator::Subtract:
+ case CalcOperator::Multiply:
+ case CalcOperator::Divide:
ASSERT(childExpressions.size() == 2);
result.append(childExpressions[0]);
result.append(' ');
result.append(' ');
result.append(childExpressions[1]);
break;
- case CalcMin:
- case CalcMax:
+ case CalcOperator::Min:
+ case CalcOperator::Max:
ASSERT(!childExpressions.isEmpty());
- const char* functionName = op == CalcMin ? "min(" : "max(";
+ const char* functionName = op == CalcOperator::Min ? "min(" : "max(";
result.append(functionName);
result.append(childExpressions[0]);
for (size_t i = 1; i < childExpressions.size(); ++i) {
CSSPrimitiveValue::UnitType primitiveType() const final
{
switch (category()) {
- case CalcNumber:
+ case CalculationCategory::Number:
#if !ASSERT_DISABLED
for (auto& child : m_children)
- ASSERT(child->category() == CalcNumber);
+ ASSERT(child->category() == CalculationCategory::Number);
#endif
return CSSPrimitiveValue::CSS_NUMBER;
- case CalcLength:
- case CalcPercent: {
+ case CalculationCategory::Length:
+ case CalculationCategory::Percent: {
if (m_children.isEmpty())
return CSSPrimitiveValue::CSS_UNKNOWN;
if (m_children.size() == 2) {
- if (m_children[0]->category() == CalcNumber)
+ if (m_children[0]->category() == CalculationCategory::Number)
return m_children[1]->primitiveType();
- if (m_children[1]->category() == CalcNumber)
+ if (m_children[1]->category() == CalculationCategory::Number)
return m_children[0]->primitiveType();
}
CSSPrimitiveValue::UnitType firstType = m_children[0]->primitiveType();
}
return firstType;
}
- case CalcAngle:
+ case CalculationCategory::Angle:
return CSSPrimitiveValue::CSS_DEG;
- case CalcTime:
+ case CalculationCategory::Time:
return CSSPrimitiveValue::CSS_MS;
- case CalcFrequency:
+ case CalculationCategory::Frequency:
return CSSPrimitiveValue::CSS_HZ;
- case CalcPercentLength:
- case CalcPercentNumber:
- case CalcOther:
+ case CalculationCategory::PercentLength:
+ case CalculationCategory::PercentNumber:
+ case CalculationCategory::Other:
return CSSPrimitiveValue::CSS_UNKNOWN;
}
ASSERT_NOT_REACHED();
CSSCalcOperation(CalculationCategory category, CalcOperator op, Vector<Ref<CSSCalcExpressionNode>>&& children)
: CSSCalcExpressionNode(category, isIntegerResult(op, children))
- , m_children(WTFMove(children))
, m_operator(op)
+ , m_children(WTFMove(children))
{
}
static CSSCalcExpressionNode* getNumberSide(CSSCalcExpressionNode& leftSide, CSSCalcExpressionNode& rightSide)
{
- if (leftSide.category() == CalcNumber)
+ if (leftSide.category() == CalculationCategory::Number)
return &leftSide;
- if (rightSide.category() == CalcNumber)
+ if (rightSide.category() == CalculationCategory::Number)
return &rightSide;
return nullptr;
}
static double evaluateOperator(CalcOperator op, const Vector<double>& children)
{
switch (op) {
- case CalcAdd:
+ case CalcOperator::Add:
ASSERT(children.size() == 2);
return children[0] + children[1];
- case CalcSubtract:
+ case CalcOperator::Subtract:
ASSERT(children.size() == 2);
return children[0] - children[1];
- case CalcMultiply:
+ case CalcOperator::Multiply:
ASSERT(children.size() == 2);
return children[0] * children[1];
- case CalcDivide:
+ case CalcOperator::Divide:
ASSERT(children.size() == 1 || children.size() == 2);
if (children.size() == 1)
return std::numeric_limits<double>::quiet_NaN();
return children[0] / children[1];
- case CalcMin: {
+ case CalcOperator::Min: {
if (children.isEmpty())
return std::numeric_limits<double>::quiet_NaN();
double minimum = children[0];
minimum = std::min(minimum, child);
return minimum;
}
- case CalcMax: {
+ case CalcOperator::Max: {
if (children.isEmpty())
return std::numeric_limits<double>::quiet_NaN();
double maximum = children[0];
return 0;
}
- Vector<Ref<CSSCalcExpressionNode>> m_children;
const CalcOperator m_operator;
+ Vector<Ref<CSSCalcExpressionNode>> m_children;
};
static ParseState checkDepthAndIndex(int* depth, CSSParserTokenRange tokens)
return false;
CSSPrimitiveValue::UnitType type = token.unitType();
- if (unitCategory(type) == CalcOther)
+ if (unitCategory(type) == CalculationCategory::Other)
return false;
bool isInteger = token.numericValueType() == IntegerValueType || (token.numericValueType() == NumberValueType && token.numericValue() == trunc(token.numericValue()));
while (!tokens.atEnd()) {
char operatorCharacter = operatorValue(tokens.peek());
- if (operatorCharacter != CalcMultiply && operatorCharacter != CalcDivide)
+ if (operatorCharacter != static_cast<char>(CalcOperator::Multiply) && operatorCharacter != static_cast<char>(CalcOperator::Divide))
break;
tokens.consumeIncludingWhitespace();
while (!tokens.atEnd()) {
char operatorCharacter = operatorValue(tokens.peek());
- if (operatorCharacter != CalcAdd && operatorCharacter != CalcSubtract)
+ if (operatorCharacter != static_cast<char>(CalcOperator::Add) && operatorCharacter != static_cast<char>(CalcOperator::Subtract))
break;
if ((&tokens.peek() - 1)->type() != WhitespaceToken)
return false; // calc(1px+ 2px) is invalid
if (checkDepthAndIndex(&depth, tokens) != OK)
return false;
- CalcOperator op = (minMaxFunction == CSSValueMin) ? CalcMin : CalcMax;
+ CalcOperator op = (minMaxFunction == CSSValueMin) ? CalcOperator::Min : CalcOperator::Max;
Value value;
if (!parseValueExpression(tokens, depth, &value))
static inline RefPtr<CSSCalcOperation> createBlendHalf(const Length& length, const RenderStyle& style, float progress)
{
- return CSSCalcOperation::create(CalcMultiply, createCSS(length, style),
+ return CSSCalcOperation::create(CalcOperator::Multiply, createCSS(length, style),
CSSCalcPrimitiveValue::create(CSSPrimitiveValue::create(progress, CSSPrimitiveValue::CSS_NUMBER), !progress || progress == 1));
}
static RefPtr<CSSCalcExpressionNode> createCSS(const CalcExpressionNode& node, const RenderStyle& style)
{
switch (node.type()) {
- case CalcExpressionNodeNumber: {
+ case CalcExpressionNodeType::Number: {
float value = toCalcExpressionNumber(node).value();
return CSSCalcPrimitiveValue::create(CSSPrimitiveValue::create(value, CSSPrimitiveValue::CSS_NUMBER), value == std::trunc(value));
}
- case CalcExpressionNodeLength:
+ case CalcExpressionNodeType::Length:
return createCSS(toCalcExpressionLength(node).length(), style);
- case CalcExpressionNodeOperation: {
+ case CalcExpressionNodeType::Operation: {
auto& operationNode = toCalcExpressionOperation(node);
auto& operationChildren = operationNode.children();
CalcOperator op = operationNode.getOperator();
- if (op == CalcMin || op == CalcMax) {
+ if (op == CalcOperator::Min || op == CalcOperator::Max) {
Vector<Ref<CSSCalcExpressionNode>> values;
values.reserveInitialCapacity(operationChildren.size());
for (auto& child : operationChildren) {
return nullptr;
values.uncheckedAppend(*cssNode);
}
- return CSSCalcOperation::createMinOrMax(operationNode.getOperator(), WTFMove(values), CalcOther);
+ return CSSCalcOperation::createMinOrMax(operationNode.getOperator(), WTFMove(values), CalculationCategory::Other);
}
if (operationChildren.size() == 2)
return nullptr;
}
- case CalcExpressionNodeBlendLength: {
+ case CalcExpressionNodeType::BlendLength: {
// FIXME: (http://webkit.org/b/122036) Create a CSSCalcExpressionNode equivalent of CalcExpressionBlendLength.
auto& blend = toCalcExpressionBlendLength(node);
float progress = blend.progress();
- return CSSCalcOperation::create(CalcAdd, createBlendHalf(blend.from(), style, 1 - progress), createBlendHalf(blend.to(), style, progress));
+ return CSSCalcOperation::create(CalcOperator::Add, createBlendHalf(blend.from(), style, 1 - progress), createBlendHalf(blend.to(), style, progress));
}
- case CalcExpressionNodeUndefined:
+ case CalcExpressionNodeType::Undefined:
ASSERT_NOT_REACHED();
}
return nullptr;
bool consumeNumberRaw(double& result)
{
- if (!m_calcValue || m_calcValue->category() != CalcNumber)
+ if (!m_calcValue || m_calcValue->category() != CalculationCategory::Number)
return false;
m_sourceRange = m_range;
result = m_calcValue->doubleValue();
bool consumePositiveIntegerRaw(int& result)
{
- if (!m_calcValue || m_calcValue->category() != CalcNumber || !m_calcValue->isInt())
+ if (!m_calcValue || m_calcValue->category() != CalculationCategory::Number || !m_calcValue->isInt())
return false;
result = static_cast<int>(m_calcValue->doubleValue());
if (result < 1)
return nullptr;
return CSSValuePool::singleton().createValue(range.consumeIncludingWhitespace().numericValue(), CSSPrimitiveValue::UnitType::CSS_NUMBER);
}
- CalcParser calcParser(range, CalcNumber);
+ CalcParser calcParser(range, CalculationCategory::Number);
if (const CSSCalcValue* calculation = calcParser.value()) {
- if (calculation->category() != CalcNumber || !calculation->isInt())
+ if (calculation->category() != CalculationCategory::Number || !calculation->isInt())
return nullptr;
double value = calculation->doubleValue();
if (value < minimumValue)
result = range.consumeIncludingWhitespace().numericValue();
return true;
}
- CalcParser calcParser(range, CalcNumber);
+ CalcParser calcParser(range, CalculationCategory::Number);
return calcParser.consumePositiveIntegerRaw(result);
}
result = range.consumeIncludingWhitespace().numericValue();
return true;
}
- CalcParser calcParser(range, CalcNumber, ValueRangeAll);
+ CalcParser calcParser(range, CalculationCategory::Number, ValueRangeAll);
return calcParser.consumeNumberRaw(result);
}
return nullptr;
return CSSValuePool::singleton().createValue(range.consumeIncludingWhitespace().numericValue(), token.unitType());
}
- CalcParser calcParser(range, CalcNumber, ValueRangeAll);
+ CalcParser calcParser(range, CalculationCategory::Number, ValueRangeAll);
if (const CSSCalcValue* calculation = calcParser.value()) {
// FIXME: Calcs should not be subject to parse time range checks.
// spec: https://drafts.csswg.org/css-values-3/#calc-range
- if (calculation->category() != CalcNumber || (valueRange == ValueRangeNonNegative && calculation->isNegative()))
+ if (calculation->category() != CalculationCategory::Number || (valueRange == ValueRangeNonNegative && calculation->isNegative()))
return nullptr;
return calcParser.consumeNumber();
}
return consumeNumber(range, ValueRangeAll);
// "[For calc()], the used value resulting from an expression must be clamped to the range allowed in the target context."
- CalcParser calcParser(range, CalcNumber, ValueRangeAll);
+ CalcParser calcParser(range, CalculationCategory::Number, ValueRangeAll);
double result;
if (calcParser.consumeNumberRaw(result)
#if !ENABLE(VARIATION_FONTS)
CSSPrimitiveValue::UnitType unitType = CSSPrimitiveValue::UnitType::CSS_PX;
return CSSValuePool::singleton().createValue(range.consumeIncludingWhitespace().numericValue(), unitType);
}
- CalcParser calcParser(range, CalcLength, valueRange);
- if (calcParser.value() && calcParser.value()->category() == CalcLength)
+ CalcParser calcParser(range, CalculationCategory::Length, valueRange);
+ if (calcParser.value() && calcParser.value()->category() == CalculationCategory::Length)
return calcParser.consumeValue();
return nullptr;
}
return nullptr;
return CSSValuePool::singleton().createValue(range.consumeIncludingWhitespace().numericValue(), CSSPrimitiveValue::UnitType::CSS_PERCENTAGE);
}
- CalcParser calcParser(range, CalcPercent, valueRange);
+ CalcParser calcParser(range, CalculationCategory::Percent, valueRange);
if (const CSSCalcValue* calculation = calcParser.value()) {
- if (calculation->category() == CalcPercent)
+ if (calculation->category() == CalculationCategory::Percent)
return calcParser.consumeValue();
}
return nullptr;
static bool canConsumeCalcValue(CalculationCategory category, CSSParserMode cssParserMode)
{
- if (category == CalcLength || category == CalcPercent || category == CalcPercentLength)
+ if (category == CalculationCategory::Length || category == CalculationCategory::Percent || category == CalculationCategory::PercentLength)
return true;
if (cssParserMode != SVGAttributeMode)
return false;
- if (category == CalcNumber || category == CalcPercentNumber)
+ if (category == CalculationCategory::Number || category == CalculationCategory::PercentNumber)
return true;
return false;
return consumeLength(range, cssParserMode, valueRange, unitless);
if (token.type() == PercentageToken)
return consumePercent(range, valueRange);
- CalcParser calcParser(range, CalcLength, valueRange);
+ CalcParser calcParser(range, CalculationCategory::Length, valueRange);
if (const CSSCalcValue* calculation = calcParser.value()) {
if (canConsumeCalcValue(calculation->category(), cssParserMode))
return calcParser.consumeValue();
return CSSValuePool::singleton().createValue(range.consumeIncludingWhitespace().numericValue(), CSSPrimitiveValue::UnitType::CSS_DEG);
}
- CalcParser calcParser(range, CalcAngle, ValueRangeAll);
+ CalcParser calcParser(range, CalculationCategory::Angle, ValueRangeAll);
if (const CSSCalcValue* calculation = calcParser.value()) {
- if (calculation->category() == CalcAngle)
+ if (calculation->category() == CalculationCategory::Angle)
return calcParser.consumeValue();
}
return nullptr;
if (token.type() == PercentageToken)
return consumePercent(range, valueRange);
- CalcParser calcParser(range, CalcAngle, valueRange);
+ CalcParser calcParser(range, CalculationCategory::Angle, valueRange);
if (const CSSCalcValue* calculation = calcParser.value()) {
- if (calculation->category() == CalcAngle)
+ if (calculation->category() == CalculationCategory::Angle)
return calcParser.consumeValue();
}
return nullptr;
return CSSValuePool::singleton().createValue(range.consumeIncludingWhitespace().numericValue(), unit);
return nullptr;
}
- CalcParser calcParser(range, CalcTime, valueRange);
+ CalcParser calcParser(range, CalculationCategory::Time, valueRange);
if (const CSSCalcValue* calculation = calcParser.value()) {
- if (calculation->category() == CalcTime)
+ if (calculation->category() == CalculationCategory::Time)
return calcParser.consumeValue();
}
return nullptr;
bool CalcExpressionNumber::operator==(const CalcExpressionNode& other) const
{
- return other.type() == CalcExpressionNodeNumber && *this == toCalcExpressionNumber(other);
+ return other.type() == CalcExpressionNodeType::Number && *this == toCalcExpressionNumber(other);
}
float CalculationValue::evaluate(float maxValue) const
float CalcExpressionOperation::evaluate(float maxValue) const
{
switch (m_operator) {
- case CalcAdd: {
+ case CalcOperator::Add: {
ASSERT(m_children.size() == 2);
float left = m_children[0]->evaluate(maxValue);
float right = m_children[1]->evaluate(maxValue);
return left + right;
}
- case CalcSubtract: {
+ case CalcOperator::Subtract: {
ASSERT(m_children.size() == 2);
float left = m_children[0]->evaluate(maxValue);
float right = m_children[1]->evaluate(maxValue);
return left - right;
}
- case CalcMultiply: {
+ case CalcOperator::Multiply: {
ASSERT(m_children.size() == 2);
float left = m_children[0]->evaluate(maxValue);
float right = m_children[1]->evaluate(maxValue);
return left * right;
}
- case CalcDivide: {
+ case CalcOperator::Divide: {
ASSERT(m_children.size() == 1 || m_children.size() == 2);
if (m_children.size() == 1)
return std::numeric_limits<float>::quiet_NaN();
float right = m_children[1]->evaluate(maxValue);
return left / right;
}
- case CalcMin: {
+ case CalcOperator::Min: {
if (m_children.isEmpty())
return std::numeric_limits<float>::quiet_NaN();
float minimum = m_children[0]->evaluate(maxValue);
minimum = std::min(minimum, child->evaluate(maxValue));
return minimum;
}
- case CalcMax: {
+ case CalcOperator::Max: {
if (m_children.isEmpty())
return std::numeric_limits<float>::quiet_NaN();
float maximum = m_children[0]->evaluate(maxValue);
bool CalcExpressionOperation::operator==(const CalcExpressionNode& other) const
{
- return other.type() == CalcExpressionNodeOperation && *this == toCalcExpressionOperation(other);
+ return other.type() == CalcExpressionNodeType::Operation && *this == toCalcExpressionOperation(other);
}
bool operator==(const CalcExpressionOperation& a, const CalcExpressionOperation& b)
void CalcExpressionOperation::dump(TextStream& ts) const
{
- if (m_operator == CalcMin || m_operator == CalcMax) {
+ if (m_operator == CalcOperator::Min || m_operator == CalcOperator::Max) {
ts << m_operator << "(";
size_t childrenCount = m_children.size();
for (size_t i = 0; i < childrenCount; i++) {
bool CalcExpressionLength::operator==(const CalcExpressionNode& other) const
{
- return other.type() == CalcExpressionNodeLength && *this == toCalcExpressionLength(other);
+ return other.type() == CalcExpressionNodeType::Length && *this == toCalcExpressionLength(other);
}
void CalcExpressionLength::dump(TextStream& ts) const
}
CalcExpressionBlendLength::CalcExpressionBlendLength(Length from, Length to, float progress)
- : CalcExpressionNode(CalcExpressionNodeBlendLength)
+ : CalcExpressionNode(CalcExpressionNodeType::BlendLength)
, m_from(from)
, m_to(to)
, m_progress(progress)
{
// Flatten nesting of CalcExpressionBlendLength as a speculative fix for rdar://problem/30533005.
// CalcExpressionBlendLength is only used as a result of animation and they don't nest in normal cases.
- if (m_from.isCalculated() && m_from.calculationValue().expression().type() == CalcExpressionNodeBlendLength)
+ if (m_from.isCalculated() && m_from.calculationValue().expression().type() == CalcExpressionNodeType::BlendLength)
m_from = toCalcExpressionBlendLength(m_from.calculationValue().expression()).from();
- if (m_to.isCalculated() && m_to.calculationValue().expression().type() == CalcExpressionNodeBlendLength)
+ if (m_to.isCalculated() && m_to.calculationValue().expression().type() == CalcExpressionNodeType::BlendLength)
m_to = toCalcExpressionBlendLength(m_to.calculationValue().expression()).to();
}
bool CalcExpressionBlendLength::operator==(const CalcExpressionNode& other) const
{
- return other.type() == CalcExpressionNodeBlendLength && *this == toCalcExpressionBlendLength(other);
+ return other.type() == CalcExpressionNodeType::BlendLength && *this == toCalcExpressionBlendLength(other);
}
void CalcExpressionBlendLength::dump(TextStream& ts) const
TextStream& operator<<(TextStream& ts, CalcOperator op)
{
switch (op) {
- case CalcAdd: ts << "+"; break;
- case CalcSubtract: ts << "-"; break;
- case CalcMultiply: ts << "*"; break;
- case CalcDivide: ts << "/"; break;
- case CalcMin: ts << "max"; break;
- case CalcMax: ts << "min"; break;
+ case CalcOperator::Add: ts << "+"; break;
+ case CalcOperator::Subtract: ts << "-"; break;
+ case CalcOperator::Multiply: ts << "*"; break;
+ case CalcOperator::Divide: ts << "/"; break;
+ case CalcOperator::Min: ts << "max"; break;
+ case CalcOperator::Max: ts << "min"; break;
}
return ts;
}
git://git.webkit.org / WebKit-https.git / commitdiff