OLD | NEW |
---|---|
1 /* | 1 /* |
2 * Copyright (C) 2011, 2012 Google Inc. All rights reserved. | 2 * Copyright (C) 2011, 2012 Google Inc. All rights reserved. |
3 * | 3 * |
4 * Redistribution and use in source and binary forms, with or without | 4 * Redistribution and use in source and binary forms, with or without |
5 * modification, are permitted provided that the following conditions are | 5 * modification, are permitted provided that the following conditions are |
6 * met: | 6 * met: |
7 * | 7 * |
8 * * Redistributions of source code must retain the above copyright | 8 * * Redistributions of source code must retain the above copyright |
9 * notice, this list of conditions and the following disclaimer. | 9 * notice, this list of conditions and the following disclaimer. |
10 * * Redistributions in binary form must reproduce the above | 10 * * Redistributions in binary form must reproduce the above |
(...skipping 574 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
585 return std::numeric_limits<double>::quiet_NaN(); | 585 return std::numeric_limits<double>::quiet_NaN(); |
586 } | 586 } |
587 return 0; | 587 return 0; |
588 } | 588 } |
589 | 589 |
590 const RefPtrWillBeMember<CSSCalcExpressionNode> m_leftSide; | 590 const RefPtrWillBeMember<CSSCalcExpressionNode> m_leftSide; |
591 const RefPtrWillBeMember<CSSCalcExpressionNode> m_rightSide; | 591 const RefPtrWillBeMember<CSSCalcExpressionNode> m_rightSide; |
592 const CalcOperator m_operator; | 592 const CalcOperator m_operator; |
593 }; | 593 }; |
594 | 594 |
595 static ParseState checkDepthAndIndex(int* depth, unsigned index, CSSParserValueL ist* tokens) | 595 static ParseState checkDepthAndIndex(int* depth, CSSParserTokenRange tokens) |
596 { | 596 { |
597 (*depth)++; | 597 (*depth)++; |
598 if (tokens.atEnd()) | |
599 return NoMoreTokens; | |
598 if (*depth > maxExpressionDepth) | 600 if (*depth > maxExpressionDepth) |
599 return TooDeep; | 601 return TooDeep; |
600 if (index >= tokens->size()) | |
601 return NoMoreTokens; | |
602 return OK; | 602 return OK; |
603 } | 603 } |
604 | 604 |
605 class CSSCalcExpressionNodeParser { | 605 class CSSCalcExpressionNodeParser { |
606 STACK_ALLOCATED(); | 606 STACK_ALLOCATED(); |
607 public: | 607 public: |
608 PassRefPtrWillBeRawPtr<CSSCalcExpressionNode> parseCalc(CSSParserValueList* tokens) | 608 PassRefPtrWillBeRawPtr<CSSCalcExpressionNode> parseCalc(CSSParserTokenRange tokens) |
609 { | 609 { |
610 unsigned index = 0; | |
611 Value result; | 610 Value result; |
Timothy Loh
2015/07/28 08:17:41
tokens.consumeWhitespace();
| |
612 bool ok = parseValueExpression(tokens, 0, &index, &result); | 611 bool ok = parseValueExpression(tokens, 0, &result); |
613 ASSERT_WITH_SECURITY_IMPLICATION(index <= tokens->size()); | 612 if (!ok || !tokens.atEnd()) |
614 if (!ok || index != tokens->size()) | |
615 return nullptr; | 613 return nullptr; |
616 return result.value; | 614 return result.value; |
617 } | 615 } |
618 | 616 |
619 private: | 617 private: |
620 struct Value { | 618 struct Value { |
621 STACK_ALLOCATED(); | 619 STACK_ALLOCATED(); |
622 public: | 620 public: |
623 RefPtrWillBeMember<CSSCalcExpressionNode> value; | 621 RefPtrWillBeMember<CSSCalcExpressionNode> value; |
624 }; | 622 }; |
625 | 623 |
626 char operatorValue(CSSParserValueList* tokens, unsigned index) | 624 char operatorValue(CSSParserTokenRange& tokens) |
627 { | 625 { |
628 if (index >= tokens->size()) | 626 tokens.consumeWhitespace(); |
629 return 0; | 627 // Use peek since we do not want to consume in case |
630 CSSParserValue* value = tokens->valueAt(index); | 628 // the operator is not the expected mult/add operation. |
631 if (value->unit != CSSParserValue::Operator) | 629 CSSParserToken value = tokens.peek(); |
632 return 0; | 630 if (value.type() == DelimiterToken) |
633 | 631 return value.delimiter(); |
634 return value->iValue; | 632 if (value.type() == LeftParenthesisToken) |
633 return '('; | |
634 if (value.type() == RightParenthesisToken) | |
635 return ')'; | |
636 return 0; | |
635 } | 637 } |
636 | 638 |
637 bool parseValue(CSSParserValueList* tokens, unsigned* index, Value* result) | 639 bool parseValue(CSSParserTokenRange& tokens, Value* result) |
638 { | 640 { |
639 CSSParserValue* parserValue = tokens->valueAt(*index); | 641 CSSParserToken token = tokens.consumeSkippingWhitespace(); |
640 if (parserValue->unit >= CSSParserValue::Operator) | 642 if (!(token.type() == NumberToken || token.type() == PercentageToken || token.type() == DimensionToken)) |
641 return false; | 643 return false; |
642 | 644 |
643 CSSPrimitiveValue::UnitType type = static_cast<CSSPrimitiveValue::UnitTy pe>(parserValue->unit); | 645 CSSPrimitiveValue::UnitType type = token.unitType(); |
644 if (unitCategory(type) == CalcOther) | 646 if (unitCategory(type) == CalcOther) |
645 return false; | 647 return false; |
646 | 648 |
647 result->value = CSSCalcPrimitiveValue::create( | 649 result->value = CSSCalcPrimitiveValue::create( |
648 CSSPrimitiveValue::create(parserValue->fValue, type), parserValue->i sInt); | 650 CSSPrimitiveValue::create(token.numericValue(), type), token.numeric ValueType() == IntegerValueType); |
649 | 651 |
650 ++*index; | |
651 return true; | 652 return true; |
652 } | 653 } |
653 | 654 |
654 bool parseValueTerm(CSSParserValueList* tokens, int depth, unsigned* index, Value* result) | 655 bool parseValueTerm(CSSParserTokenRange& tokens, int depth, Value* result) |
655 { | 656 { |
656 if (checkDepthAndIndex(&depth, *index, tokens) != OK) | 657 if (checkDepthAndIndex(&depth, tokens) != OK) |
657 return false; | 658 return false; |
658 | 659 |
659 if (operatorValue(tokens, *index) == '(') { | 660 if (operatorValue(tokens) == '(') { |
Timothy Loh
2015/07/28 08:17:41
tokens.peek().type() == LeftParenthesisToken
Usin
| |
660 unsigned currentIndex = *index + 1; | 661 tokens.consume(); |
Timothy Loh
2015/07/28 08:17:40
consumeIncludingWhitespace
| |
661 if (!parseValueExpression(tokens, depth, ¤tIndex, result)) | 662 if (!parseValueExpression(tokens, depth, result)) |
662 return false; | 663 return false; |
663 | 664 |
664 if (operatorValue(tokens, currentIndex) != ')') | 665 if (tokens.atEnd()) |
666 return true; | |
667 | |
668 if (operatorValue(tokens) != ')') | |
Timothy Loh
2015/07/28 08:17:40
tokens.peek().type() == RightParenthesisToken
| |
665 return false; | 669 return false; |
666 *index = currentIndex + 1; | 670 tokens.consume(); |
Timothy Loh
2015/07/28 08:17:41
consumeIncludingWhitespace
| |
667 return true; | 671 return true; |
668 } | 672 } |
669 | 673 |
670 return parseValue(tokens, index, result); | 674 return parseValue(tokens, result); |
671 } | 675 } |
672 | 676 |
673 bool parseValueMultiplicativeExpression(CSSParserValueList* tokens, int dept h, unsigned* index, Value* result) | 677 bool parseValueMultiplicativeExpression(CSSParserTokenRange& tokens, int dep th, Value* result) |
674 { | 678 { |
675 if (checkDepthAndIndex(&depth, *index, tokens) != OK) | 679 if (checkDepthAndIndex(&depth, tokens) != OK) |
676 return false; | 680 return false; |
677 | 681 |
678 if (!parseValueTerm(tokens, depth, index, result)) | 682 if (!parseValueTerm(tokens, depth, result)) |
679 return false; | 683 return false; |
680 | 684 |
681 while (*index < tokens->size() - 1) { | 685 while (!tokens.atEnd()) { |
682 char operatorCharacter = operatorValue(tokens, *index); | 686 char operatorCharacter = operatorValue(tokens); |
683 if (operatorCharacter != CalcMultiply && operatorCharacter != CalcDi vide) | 687 if (operatorCharacter != CalcMultiply && operatorCharacter != CalcDi vide) |
684 break; | 688 break; |
685 ++*index; | 689 tokens.consume(); |
Timothy Loh
2015/07/28 08:17:41
consumeIncludingWhitespace
| |
686 | 690 |
687 Value rhs; | 691 Value rhs; |
688 if (!parseValueTerm(tokens, depth, index, &rhs)) | 692 if (!parseValueTerm(tokens, depth, &rhs)) |
689 return false; | 693 return false; |
690 | 694 |
691 result->value = CSSCalcBinaryOperation::createSimplified(result->val ue, rhs.value, static_cast<CalcOperator>(operatorCharacter)); | 695 result->value = CSSCalcBinaryOperation::createSimplified(result->val ue, rhs.value, static_cast<CalcOperator>(operatorCharacter)); |
692 if (!result->value) | 696 if (!result->value) |
693 return false; | 697 return false; |
694 } | 698 } |
695 | 699 |
696 ASSERT_WITH_SECURITY_IMPLICATION(*index <= tokens->size()); | |
697 return true; | 700 return true; |
698 } | 701 } |
699 | 702 |
700 bool parseAdditiveValueExpression(CSSParserValueList* tokens, int depth, uns igned* index, Value* result) | 703 bool parseAdditiveValueExpression(CSSParserTokenRange& tokens, int depth, Va lue* result) |
701 { | 704 { |
702 if (checkDepthAndIndex(&depth, *index, tokens) != OK) | 705 if (checkDepthAndIndex(&depth, tokens) != OK) |
703 return false; | 706 return false; |
704 | 707 |
705 if (!parseValueMultiplicativeExpression(tokens, depth, index, result)) | 708 if (!parseValueMultiplicativeExpression(tokens, depth, result)) |
706 return false; | 709 return false; |
707 | 710 |
708 while (*index < tokens->size() - 1) { | 711 while (!tokens.atEnd()) { |
709 char operatorCharacter = operatorValue(tokens, *index); | 712 char operatorCharacter = operatorValue(tokens); |
710 if (operatorCharacter != CalcAdd && operatorCharacter != CalcSubtrac t) | 713 if (operatorCharacter != CalcAdd && operatorCharacter != CalcSubtrac t) |
711 break; | 714 break; |
712 ++*index; | 715 if (operatorCharacter == CalcAdd && (&tokens.peek() - 1)->type() != WhitespaceToken) |
716 return false; // calc(1px+ 2px) is invalid | |
717 tokens.consume(); | |
Timothy Loh
2015/07/28 08:17:40
consumeIncludingWhitespace
| |
713 | 718 |
714 Value rhs; | 719 Value rhs; |
715 if (!parseValueMultiplicativeExpression(tokens, depth, index, &rhs)) | 720 if (!parseValueMultiplicativeExpression(tokens, depth, &rhs)) |
716 return false; | 721 return false; |
717 | 722 |
718 result->value = CSSCalcBinaryOperation::createSimplified(result->val ue, rhs.value, static_cast<CalcOperator>(operatorCharacter)); | 723 result->value = CSSCalcBinaryOperation::createSimplified(result->val ue, rhs.value, static_cast<CalcOperator>(operatorCharacter)); |
719 if (!result->value) | 724 if (!result->value) |
720 return false; | 725 return false; |
721 } | 726 } |
722 | 727 |
723 ASSERT_WITH_SECURITY_IMPLICATION(*index <= tokens->size()); | |
724 return true; | 728 return true; |
725 } | 729 } |
726 | 730 |
727 bool parseValueExpression(CSSParserValueList* tokens, int depth, unsigned* i ndex, Value* result) | 731 bool parseValueExpression(CSSParserTokenRange& tokens, int depth, Value* res ult) |
728 { | 732 { |
729 return parseAdditiveValueExpression(tokens, depth, index, result); | 733 return parseAdditiveValueExpression(tokens, depth, result); |
730 } | 734 } |
731 }; | 735 }; |
732 | 736 |
733 PassRefPtrWillBeRawPtr<CSSCalcExpressionNode> CSSCalcValue::createExpressionNode (PassRefPtrWillBeRawPtr<CSSPrimitiveValue> value, bool isInteger) | 737 PassRefPtrWillBeRawPtr<CSSCalcExpressionNode> CSSCalcValue::createExpressionNode (PassRefPtrWillBeRawPtr<CSSPrimitiveValue> value, bool isInteger) |
734 { | 738 { |
735 return CSSCalcPrimitiveValue::create(value, isInteger); | 739 return CSSCalcPrimitiveValue::create(value, isInteger); |
736 } | 740 } |
737 | 741 |
738 PassRefPtrWillBeRawPtr<CSSCalcExpressionNode> CSSCalcValue::createExpressionNode (PassRefPtrWillBeRawPtr<CSSCalcExpressionNode> leftSide, PassRefPtrWillBeRawPtr< CSSCalcExpressionNode> rightSide, CalcOperator op) | 742 PassRefPtrWillBeRawPtr<CSSCalcExpressionNode> CSSCalcValue::createExpressionNode (PassRefPtrWillBeRawPtr<CSSCalcExpressionNode> leftSide, PassRefPtrWillBeRawPtr< CSSCalcExpressionNode> rightSide, CalcOperator op) |
739 { | 743 { |
740 return CSSCalcBinaryOperation::create(leftSide, rightSide, op); | 744 return CSSCalcBinaryOperation::create(leftSide, rightSide, op); |
741 } | 745 } |
742 | 746 |
743 PassRefPtrWillBeRawPtr<CSSCalcExpressionNode> CSSCalcValue::createExpressionNode (double pixels, double percent) | 747 PassRefPtrWillBeRawPtr<CSSCalcExpressionNode> CSSCalcValue::createExpressionNode (double pixels, double percent) |
744 { | 748 { |
745 return createExpressionNode( | 749 return createExpressionNode( |
746 createExpressionNode(CSSPrimitiveValue::create(pixels, CSSPrimitiveValue ::CSS_PX), pixels == trunc(pixels)), | 750 createExpressionNode(CSSPrimitiveValue::create(pixels, CSSPrimitiveValue ::CSS_PX), pixels == trunc(pixels)), |
747 createExpressionNode(CSSPrimitiveValue::create(percent, CSSPrimitiveValu e::CSS_PERCENTAGE), percent == trunc(percent)), | 751 createExpressionNode(CSSPrimitiveValue::create(percent, CSSPrimitiveValu e::CSS_PERCENTAGE), percent == trunc(percent)), |
748 CalcAdd); | 752 CalcAdd); |
749 } | 753 } |
750 | 754 |
751 PassRefPtrWillBeRawPtr<CSSCalcValue> CSSCalcValue::create(CSSParserValueList* pa rserValueList, ValueRange range) | 755 PassRefPtrWillBeRawPtr<CSSCalcValue> CSSCalcValue::create(const CSSParserTokenRa nge& tokens, ValueRange range) |
752 { | 756 { |
753 CSSCalcExpressionNodeParser parser; | 757 CSSCalcExpressionNodeParser parser; |
754 RefPtrWillBeRawPtr<CSSCalcExpressionNode> expression = parser.parseCalc(pars erValueList); | 758 RefPtrWillBeRawPtr<CSSCalcExpressionNode> expression = parser.parseCalc(toke ns); |
755 | 759 |
756 return expression ? adoptRefWillBeNoop(new CSSCalcValue(expression, range)) : nullptr; | 760 return expression ? adoptRefWillBeNoop(new CSSCalcValue(expression, range)) : nullptr; |
757 } | 761 } |
758 | 762 |
759 PassRefPtrWillBeRawPtr<CSSCalcValue> CSSCalcValue::create(PassRefPtrWillBeRawPtr <CSSCalcExpressionNode> expression, ValueRange range) | 763 PassRefPtrWillBeRawPtr<CSSCalcValue> CSSCalcValue::create(PassRefPtrWillBeRawPtr <CSSCalcExpressionNode> expression, ValueRange range) |
760 { | 764 { |
761 return adoptRefWillBeNoop(new CSSCalcValue(expression, range)); | 765 return adoptRefWillBeNoop(new CSSCalcValue(expression, range)); |
762 } | 766 } |
763 | 767 |
764 DEFINE_TRACE_AFTER_DISPATCH(CSSCalcValue) | 768 DEFINE_TRACE_AFTER_DISPATCH(CSSCalcValue) |
765 { | 769 { |
766 visitor->trace(m_expression); | 770 visitor->trace(m_expression); |
767 CSSValue::traceAfterDispatch(visitor); | 771 CSSValue::traceAfterDispatch(visitor); |
768 } | 772 } |
769 | 773 |
770 } // namespace blink | 774 } // namespace blink |
OLD | NEW |