Changeset 30069 in webkit

Timestamp:

Feb 7, 2008 12:13:24 PM (16 years ago)

Author:

hyatt@apple.com

Message:

Fix for bug 6248, implement the nth-* CSS3 selectors. Patch based on original KHTML work from Allan Jensen
and improved upon by Nick Shanks.

Reviewed by Eric

• css/CSSGrammar.y:
• css/CSSParser.cpp: (WebCore::CSSParser::lex):
• css/CSSSelector.cpp: (WebCore::CSSSelector::extractPseudoType):
• css/CSSSelector.h: (WebCore::CSSSelector::):
• css/CSSStyleSelector.cpp: (WebCore::parseNth): (WebCore::matchNth): (WebCore::CSSStyleSelector::checkOneSelector):
• css/tokenizer.flex:
• rendering/RenderStyle.cpp: (WebCore::RenderStyle::RenderStyle):
• rendering/RenderStyle.h: (WebCore::RenderStyle::childIndex): (WebCore::RenderStyle::setChildIndex):

Location:

trunk/WebCore

Files:

• ChangeLog (modified) (1 diff)
• css/CSSGrammar.y (modified) (2 diffs)
• css/CSSParser.cpp (modified) (1 diff)
• css/CSSSelector.cpp (modified) (2 diffs)
• css/CSSSelector.h (modified) (1 diff)
• css/CSSStyleSelector.cpp (modified) (3 diffs)
• css/tokenizer.flex (modified) (2 diffs)
• rendering/RenderStyle.cpp (modified) (3 diffs)
• rendering/RenderStyle.h (modified) (3 diffs)

trunk/WebCore/ChangeLog

@@ +1 @@
+2008-02-07  David Hyatt  <hyatt@apple.com>
+
+        Fix for bug 6248, implement the nth-* CSS3 selectors.  Patch based on original KHTML work from Allan Jensen
+        and improved upon by Nick Shanks.
+
+        Reviewed by Eric
+
+        * css/CSSGrammar.y:
+        * css/CSSParser.cpp:
+        (WebCore::CSSParser::lex):
+        * css/CSSSelector.cpp:
+        (WebCore::CSSSelector::extractPseudoType):
+        * css/CSSSelector.h:
+        (WebCore::CSSSelector::):
+        * css/CSSStyleSelector.cpp:
+        (WebCore::parseNth):
+        (WebCore::matchNth):
+        (WebCore::CSSStyleSelector::checkOneSelector):
+        * css/tokenizer.flex:
+        * rendering/RenderStyle.cpp:
+        (WebCore::RenderStyle::RenderStyle):
+        * rendering/RenderStyle.h:
+        (WebCore::RenderStyle::childIndex):
+        (WebCore::RenderStyle::setChildIndex):
+
 2008-02-07  Dan Bernstein  <mitz@apple.com>
 

trunk/WebCore/css/CSSGrammar.y

@@ -166 +166 @@
 
 %token <string> STRING
-
 %right <string> IDENT
+%token <string> NTH
 
 %nonassoc <string> HEX
@@ -908 +908 @@
         }
     }
-    // used by :lang
+    // used by :nth-*(ax+b)
+    | ':' FUNCTION NTH ')' {
+        CSSParser *p = static_cast<CSSParser*>(parser);
+        $$ = p->createFloatingSelector();
+        $$->m_match = CSSSelector::PseudoClass;
+        $$->m_argument = atomicString($3);
+        $$->m_value = atomicString($2);
+        CSSSelector::PseudoType type = $$->pseudoType();
+        if (type == CSSSelector::PseudoUnknown)
+            $$ = 0;
+        else if (type == CSSSelector::PseudoNthChild || type == CSSSelector::PseudoNthOfType) {
+            if (p->document())
+                p->document()->setUsesSiblingRules(true);
+        }
+    }
+    // used by :nth-*
+    | ':' FUNCTION INTEGER ')' {
+        CSSParser *p = static_cast<CSSParser*>(parser);
+        $$ = p->createFloatingSelector();
+        $$->m_match = CSSSelector::PseudoClass;
+        $$->m_argument = String::number($3);
+        $$->m_value = atomicString($2);
+        CSSSelector::PseudoType type = $$->pseudoType();
+        if (type == CSSSelector::PseudoUnknown)
+            $$ = 0;
+        else if (type == CSSSelector::PseudoNthChild || type == CSSSelector::PseudoNthOfType) {
+            if (p->document())
+                p->document()->setUsesSiblingRules(true);
+        }
+    }
+    // used by :nth-*(odd/even) and :lang
     | ':' FUNCTION IDENT ')' {
-        $$ = static_cast<CSSParser*>(parser)->createFloatingSelector();
+        CSSParser *p = static_cast<CSSParser*>(parser);
+        $$ = p->createFloatingSelector();
         $$->m_match = CSSSelector::PseudoClass;
         $$->m_argument = atomicString($3);
         $2.lower();
         $$->m_value = atomicString($2);
-        if ($$->pseudoType() == CSSSelector::PseudoUnknown)
+        CSSSelector::PseudoType type = $$->pseudoType();
+        if (type == CSSSelector::PseudoUnknown)
             $$ = 0;
+        else if (type == CSSSelector::PseudoNthChild || type == CSSSelector::PseudoNthOfType) {
+            if (p->document())
+                p->document()->setUsesSiblingRules(true);
+        }
     }
     // used by :not

trunk/WebCore/css/CSSParser.cpp

@@ -3562 +3562 @@
     case STRING:
     case IDENT:
+    case NTH:
     case HEX:
     case IDSEL:

trunk/WebCore/css/CSSSelector.cpp

@@ -85 +85 @@
     static AtomicString firstLine("first-line");
     static AtomicString firstOfType("first-of-type");
+    static AtomicString nthChild("nth-child(");
+    static AtomicString nthOfType("nth-of-type(");
+    static AtomicString nthLastChild("nth-last-child(");
+    static AtomicString nthLastOfType("nth-last-of-type(");
     static AtomicString focus("focus");
     static AtomicString hover("hover");
@@ -200 +204 @@
     } else if (m_value == notStr)
         m_pseudoType = PseudoNot;
+    else if (m_value == nthChild)
+        m_pseudoType = PseudoNthChild;
+    else if (m_value == nthOfType)
+        m_pseudoType = PseudoNthOfType;
+    else if (m_value == nthLastChild)
+        m_pseudoType = PseudoNthLastChild;
+    else if (m_value == nthLastOfType)
+        m_pseudoType = PseudoNthLastOfType;
     else if (m_value == root)
         m_pseudoType = PseudoRoot;

trunk/WebCore/css/CSSSelector.h

@@ -128 +128 @@
             PseudoFirstLine,
             PseudoFirstLetter,
+            PseudoNthChild,
+            PseudoNthOfType,
+            PseudoNthLastChild,
+            PseudoNthLastOfType,
             PseudoLink,
             PseudoVisited,

trunk/WebCore/css/CSSStyleSelector.cpp

@@ -713 +713 @@
         ? PseudoVisited : PseudoLink;
 }
+
+// a helper function for parsing nth-arguments
+static bool parseNth(const String& nth, int &a, int &b)
+{
+    if (nth.isEmpty())
+        return false;
+    a = 0;
+    b = 0;
+    if (nth == "odd") {
+        a = 2;
+        b = 1;
+    } else if (nth == "even") {
+        a = 2;
+        b = 0;
+    } else {
+        int n = nth.find('n');
+        if (n != -1) {
+            if (nth[0] == '-') {
+                if (n == 1)
+                    a = -1; // -n == -1n
+                else
+                    a = nth.substring(1, n - 1).toInt();
+            } else if (!n)
+                a = 1; // n == 1n
+            else
+                a = nth.substring(0, n).toInt();
+
+            int p = nth.find('+', n);
+            if (p != -1)
+                b = nth.substring(p + 1, nth.length() - p - 1).toInt();
+            else {
+                p = nth.find('-', n);
+                b = -nth.substring(p + 1, nth.length() - p - 1).toInt();
+            }
+        } else
+            b = nth.toInt();
+    }
+    return true;
+}
+
+// a helper function for checking nth-arguments
+static bool matchNth(int count, int a, int b)
+{
+    if (!a)
+        return count == b;
+    else if (a > 0) {
+        if (count < b)
+            return false;
+        return (count - b) % a == 0;
+    } else {
+        if (count > b)
+            return false;
+        return (b - count) % (-a) == 0;
+    }
+}
+
 
 #ifdef STYLE_SHARING_STATS
@@ -1722 +1778 @@
             }
             case CSSSelector::PseudoOnlyOfType: {
+                // FIXME: This selector is very slow.
                 if (e->parentNode() && e->parentNode()->isElementNode()) {
                     bool firstChild = false;
@@ -1750 +1807 @@
                     }
                     return firstChild && lastChild;
+                }
+                break;
+            }
+            case CSSSelector::PseudoNthChild: {
+                int a, b;
+                // calculate a and b every time we run through checkOneSelector
+                // this should probably be saved after we calculate it once, but currently
+                // would require increasing the size of CSSSelector
+                if (!parseNth(sel->m_argument, a, b))
+                    break;
+                if (e->parentNode() && e->parentNode()->isElementNode()) {
+                    int count = 1;
+                    Node* n = e->previousSibling();
+                    while (n) {
+                        if (n->isElementNode()) {
+                            RenderStyle* s = n->renderStyle();
+                            unsigned index = s ? s->childIndex() : 0;
+                            if (index) {
+                                count += index;
+                                break;
+                            }
+                            count++;
+                        }
+                        n = n->previousSibling();
+                    }
+                    
+                    if (!m_collectRulesOnly) {
+                        RenderStyle* childStyle = (m_element == e) ? m_style : e->renderStyle();
+                        RenderStyle* parentStyle = (m_element == e) ? m_parentStyle : e->parentNode()->renderStyle();
+                        if (childStyle)
+                            childStyle->setChildIndex(count);
+                        if (parentStyle)
+                            parentStyle->setChildrenAffectedByPositionalRules();
+                    }
+                    
+                    if (matchNth(count, a, b))
+                        return true;
+                }
+                break;
+            }
+            case CSSSelector::PseudoNthOfType: {
+                // FIXME: This selector is very slow.
+                int a, b;
+                // calculate a and b every time we run through checkOneSelector (see above)
+                if (!parseNth(sel->m_argument, a, b))
+                    break;
+                if (e->parentNode() && e->parentNode()->isElementNode()) {
+                    int count = 1;
+                    const QualifiedName& type = e->tagQName();
+                    Node* n = e->previousSibling();
+                    while (n) {
+                        if (n->isElementNode() && static_cast<Element*>(n)->hasTagName(type))
+                            count++;
+                        n = n->previousSibling();
+                    }
+                    
+                    if (!m_collectRulesOnly) {
+                        RenderStyle* parentStyle = (m_element == e) ? m_parentStyle : e->parentNode()->renderStyle();
+                        if (parentStyle)
+                            parentStyle->setChildrenAffectedByPositionalRules();
+                    }
+
+                    if (matchNth(count, a, b))
+                        return true;
+                }
+                break;
+            }
+            case CSSSelector::PseudoNthLastChild: {
+                int a, b;
+                // calculate a and b every time we run through checkOneSelector
+                // this should probably be saved after we calculate it once, but currently
+                // would require increasing the size of CSSSelector
+                if (!parseNth(sel->m_argument, a, b))
+                    break;
+                if (e->parentNode() && e->parentNode()->isElementNode()) {
+                    int count = 1;
+                    Node* n = e->nextSibling();
+                    while (n) {
+                        if (n->isElementNode())
+                            count++;
+                        n = n->nextSibling();
+                    }
+                    
+                    if (!m_collectRulesOnly) {
+                        RenderStyle* parentStyle = (m_element == e) ? m_parentStyle : e->parentNode()->renderStyle();
+                        if (parentStyle)
+                            parentStyle->setChildrenAffectedByPositionalRules();
+                    }
+                    
+                    if (matchNth(count, a, b))
+                        return true;
+                }
+                break;
+            }
+            case CSSSelector::PseudoNthLastOfType: {
+                // FIXME: This selector is very slow.
+                int a, b;
+                // calculate a and b every time we run through checkOneSelector (see above)
+                if (!parseNth(sel->m_argument, a, b))
+                    break;
+                if (e->parentNode() && e->parentNode()->isElementNode()) {
+                    int count = 1;
+                    const QualifiedName& type = e->tagQName();
+                    Node* n = e->nextSibling();
+                    while (n) {
+                        if (n->isElementNode() && static_cast<Element*>(n)->hasTagName(type))
+                            count++;
+                        n = n->nextSibling();
+                    }
+                    
+                    if (!m_collectRulesOnly) {
+                        RenderStyle* parentStyle = (m_element == e) ? m_parentStyle : e->parentNode()->renderStyle();
+                        if (parentStyle)
+                            parentStyle->setChildrenAffectedByPositionalRules();
+                    }
+
+                    if (matchNth(count, a, b))
+                        return true;
                 }
                 break;

trunk/WebCore/css/tokenizer.flex

@@ -24 +24 @@
 nl              \n|\r\n|\r|\f
 range           \?{1,6}|{h}(\?{0,5}|{h}(\?{0,4}|{h}(\?{0,3}|{h}(\?{0,2}|{h}(\??|{h})))))
+nth             (-?[0-9]*n[\+-][0-9]+)|(-?[0-9]*n)
 
 %%
@@ -43 +44 @@
 
 {string}                {yyTok = STRING; return yyTok;}
-
 {ident}                 {yyTok = IDENT; return yyTok;}
+{nth}                   {yyTok = NTH; return yyTok;}
 
 "#"{hexcolor}           {yyTok = HEX; return yyTok;}

trunk/WebCore/rendering/RenderStyle.cpp

@@ -938 +938 @@
     , m_firstChildState(false)
     , m_lastChildState(false)
+    , m_childIndex(0)
     , m_ref(0)
 #if ENABLE(SVG)
@@ -958 +959 @@
     , m_firstChildState(false)
     , m_lastChildState(false)
+    , m_childIndex(0)
     , m_ref(1)
 {
@@ -1000 +1002 @@
     , m_firstChildState(false)
     , m_lastChildState(false)
+    , m_childIndex(0)
     , m_ref(0)
 #if ENABLE(SVG)

trunk/WebCore/rendering/RenderStyle.h

@@ -1462 +1462 @@
 // list of associated pseudo styles
     RenderStyle* pseudoStyle;
-    
+
     unsigned m_pseudoState : 3; // PseudoState
     bool m_affectedByAttributeSelectors : 1;
@@ -1478 +1478 @@
     bool m_firstChildState : 1;
     bool m_lastChildState : 1;
+    unsigned m_childIndex : 20; // Plenty of bits to cache an index.
 
     int m_ref;
@@ -2135 +2136 @@
     bool lastChildState() const { return m_lastChildState; }
     void setLastChildState() { m_lastChildState = true; }
+    unsigned childIndex() const { return m_childIndex; }
+    void setChildIndex(unsigned index) { m_childIndex = index; }
 
     // Initial values for all the properties