Don't add '(' to FUNCTION token names

Source/core/css/CSSSelector.cpp

 /*
  * Copyright (C) 1999-2003 Lars Knoll (knoll@kde.org)
  *               1999 Waldo Bastian (bastian@kde.org)
  *               2001 Andreas Schlapbach (schlpbch@iam.unibe.ch)
  *               2001-2003 Dirk Mueller (mueller@kde.org)
  * Copyright (C) 2002, 2006, 2007, 2008, 2009, 2010 Apple Inc. All rights reserved.
  * Copyright (C) 2008 David Smith (catfish.man@gmail.com)
  * Copyright (C) 2010 Google Inc. All rights reserved.
  *
  * This library is free software; you can redistribute it and/or
@@ skipping 259 matching lines @@
 }
 
 // Could be made smaller and faster by replacing pointer with an
 // offset into a string buffer and making the bit fields smaller but
 // that could not be maintained by hand.
 struct NameToPseudoStruct {
     const char* string;
     unsigned type:8;
 };
 
-// This table should be kept sorted.
-const static NameToPseudoStruct pseudoTypeMap[] = {
+// These tables should be kept sorted.
+const static NameToPseudoStruct pseudoTypeWithoutArgumentsMap[] = {
 {"-internal-list-box",            CSSSelector::PseudoListBox},
 {"-internal-media-controls-cast-button", CSSSelector::PseudoWebKitCustomElement},
 {"-internal-media-controls-overlay-cast-button", CSSSelector::PseudoWebKitCustomElement},
 {"-internal-spatial-navigation-focus", CSSSelector::PseudoSpatialNavigationFocus},
-{"-webkit-any(",                  CSSSelector::PseudoAny},
 {"-webkit-any-link",              CSSSelector::PseudoAnyLink},
 {"-webkit-autofill",              CSSSelector::PseudoAutofill},
 {"-webkit-drag",                  CSSSelector::PseudoDrag},
 {"-webkit-full-page-media",       CSSSelector::PseudoFullPageMedia},
 {"-webkit-full-screen",           CSSSelector::PseudoFullScreen},
 {"-webkit-full-screen-ancestor",  CSSSelector::PseudoFullScreenAncestor},
 {"-webkit-full-screen-document",  CSSSelector::PseudoFullScreenDocument},
 {"-webkit-resizer",               CSSSelector::PseudoResizer},
 {"-webkit-scrollbar",             CSSSelector::PseudoScrollbar},
 {"-webkit-scrollbar-button",      CSSSelector::PseudoScrollbarButton},
 {"-webkit-scrollbar-corner",      CSSSelector::PseudoScrollbarCorner},
 {"-webkit-scrollbar-thumb",       CSSSelector::PseudoScrollbarThumb},
 {"-webkit-scrollbar-track",       CSSSelector::PseudoScrollbarTrack},
 {"-webkit-scrollbar-track-piece", CSSSelector::PseudoScrollbarTrackPiece},
 {"active",                        CSSSelector::PseudoActive},
 {"after",                         CSSSelector::PseudoAfter},
 {"backdrop",                      CSSSelector::PseudoBackdrop},
 {"before",                        CSSSelector::PseudoBefore},
 {"checked",                       CSSSelector::PseudoChecked},
 {"content",                       CSSSelector::PseudoContent},
 {"corner-present",                CSSSelector::PseudoCornerPresent},
 {"cue",                           CSSSelector::PseudoWebKitCustomElement},
-{"cue(",                          CSSSelector::PseudoCue},
 {"decrement",                     CSSSelector::PseudoDecrement},
 {"default",                       CSSSelector::PseudoDefault},
 {"disabled",                      CSSSelector::PseudoDisabled},
 {"double-button",                 CSSSelector::PseudoDoubleButton},
 {"empty",                         CSSSelector::PseudoEmpty},
 {"enabled",                       CSSSelector::PseudoEnabled},
 {"end",                           CSSSelector::PseudoEnd},
 {"first",                         CSSSelector::PseudoFirstPage},
 {"first-child",                   CSSSelector::PseudoFirstChild},
 {"first-letter",                  CSSSelector::PseudoFirstLetter},
 {"first-line",                    CSSSelector::PseudoFirstLine},
 {"first-of-type",                 CSSSelector::PseudoFirstOfType},
 {"focus",                         CSSSelector::PseudoFocus},
 {"future",                        CSSSelector::PseudoFutureCue},
 {"horizontal",                    CSSSelector::PseudoHorizontal},
 {"host",                          CSSSelector::PseudoHost},
-{"host(",                         CSSSelector::PseudoHost},
-{"host-context(",                 CSSSelector::PseudoHostContext},
 {"hover",                         CSSSelector::PseudoHover},
 {"in-range",                      CSSSelector::PseudoInRange},
 {"increment",                     CSSSelector::PseudoIncrement},
 {"indeterminate",                 CSSSelector::PseudoIndeterminate},
 {"invalid",                       CSSSelector::PseudoInvalid},
-{"lang(",                         CSSSelector::PseudoLang},
 {"last-child",                    CSSSelector::PseudoLastChild},
 {"last-of-type",                  CSSSelector::PseudoLastOfType},
 {"left",                          CSSSelector::PseudoLeftPage},
 {"link",                          CSSSelector::PseudoLink},
 {"no-button",                     CSSSelector::PseudoNoButton},
-{"not(",                          CSSSelector::PseudoNot},
-{"nth-child(",                    CSSSelector::PseudoNthChild},
-{"nth-last-child(",               CSSSelector::PseudoNthLastChild},
-{"nth-last-of-type(",             CSSSelector::PseudoNthLastOfType},
-{"nth-of-type(",                  CSSSelector::PseudoNthOfType},
 {"only-child",                    CSSSelector::PseudoOnlyChild},
 {"only-of-type",                  CSSSelector::PseudoOnlyOfType},
 {"optional",                      CSSSelector::PseudoOptional},
 {"out-of-range",                  CSSSelector::PseudoOutOfRange},
 {"past",                          CSSSelector::PseudoPastCue},
 {"read-only",                     CSSSelector::PseudoReadOnly},
 {"read-write",                    CSSSelector::PseudoReadWrite},
 {"required",                      CSSSelector::PseudoRequired},
 {"right",                         CSSSelector::PseudoRightPage},
 {"root",                          CSSSelector::PseudoRoot},
 {"scope",                         CSSSelector::PseudoScope},
 {"selection",                     CSSSelector::PseudoSelection},
 {"shadow",                        CSSSelector::PseudoShadow},
 {"single-button",                 CSSSelector::PseudoSingleButton},
 {"start",                         CSSSelector::PseudoStart},
 {"target",                        CSSSelector::PseudoTarget},
 {"unresolved",                    CSSSelector::PseudoUnresolved},
 {"valid",                         CSSSelector::PseudoValid},
 {"vertical",                      CSSSelector::PseudoVertical},
 {"visited",                       CSSSelector::PseudoVisited},
 {"window-inactive",               CSSSelector::PseudoWindowInactive},
 };
 
+const static NameToPseudoStruct pseudoTypeWithArgumentsMap[] = {
+{"-webkit-any",      CSSSelector::PseudoAny},
+{"cue",              CSSSelector::PseudoCue},
+{"host",             CSSSelector::PseudoHost},
+{"host-context",     CSSSelector::PseudoHostContext},
+{"lang",             CSSSelector::PseudoLang},
+{"not",              CSSSelector::PseudoNot},
+{"nth-child",        CSSSelector::PseudoNthChild},
+{"nth-last-child",   CSSSelector::PseudoNthLastChild},
+{"nth-last-of-type", CSSSelector::PseudoNthLastOfType},
+{"nth-of-type",      CSSSelector::PseudoNthOfType},
+};
+
 class NameToPseudoCompare {
 public:
     NameToPseudoCompare(const AtomicString& key) : m_key(key) { ASSERT(m_key.is8Bit()); }
 
     bool operator()(const NameToPseudoStruct& entry, const NameToPseudoStruct&)
     {
         ASSERT(entry.string);
         const char* key = reinterpret_cast<const char*>(m_key.characters8());
         // If strncmp returns 0, then either the keys are equal, or |m_key| sorts before |entry|.
         return strncmp(entry.string, key, m_key.length()) < 0;
     }
 
 private:
     const AtomicString& m_key;
 };
 
-static CSSSelector::PseudoType nameToPseudoType(const AtomicString& name)
+static CSSSelector::PseudoType nameToPseudoType(const AtomicString& name, bool hasArguments)
 {
     if (name.isNull() || !name.is8Bit())
         return CSSSelector::PseudoUnknown;
 
-    const NameToPseudoStruct* pseudoTypeMapEnd = pseudoTypeMap + WTF_ARRAY_LENGTH(pseudoTypeMap);
+    const NameToPseudoStruct* pseudoTypeMap;
+    const NameToPseudoStruct* pseudoTypeMapEnd;
+    if (hasArguments) {
+        pseudoTypeMap = pseudoTypeWithArgumentsMap;
+        pseudoTypeMapEnd = pseudoTypeWithArgumentsMap + WTF_ARRAY_LENGTH(pseudoTypeWithArgumentsMap);
+    } else {
+        pseudoTypeMap = pseudoTypeWithoutArgumentsMap;
+        pseudoTypeMapEnd = pseudoTypeWithoutArgumentsMap + WTF_ARRAY_LENGTH(pseudoTypeWithoutArgumentsMap);
+    }
     NameToPseudoStruct dummyKey = { 0, CSSSelector::PseudoUnknown };
     const NameToPseudoStruct* match = std::lower_bound(pseudoTypeMap, pseudoTypeMapEnd, dummyKey, NameToPseudoCompare(name));
     if (match == pseudoTypeMapEnd || match->string != name.string())
         return CSSSelector::PseudoUnknown;
 
     return static_cast<CSSSelector::PseudoType>(match->type);
 }
 
 #ifndef NDEBUG
 void CSSSelector::show(int indent) const
@@ skipping 20 matching lines @@
 }
 
 void CSSSelector::show() const
 {
     printf("\n******* CSSSelector::show(\"%s\") *******\n", selectorText().ascii().data());
     show(2);
     printf("******* end *******\n");
 }
 #endif
 
-CSSSelector::PseudoType CSSSelector::parsePseudoType(const AtomicString& name)
+CSSSelector::PseudoType CSSSelector::parsePseudoType(const AtomicString& name, bool hasArguments)
 {
-    CSSSelector::PseudoType pseudoType = nameToPseudoType(name);
+    CSSSelector::PseudoType pseudoType = nameToPseudoType(name, hasArguments);
     if (pseudoType != PseudoUnknown)
         return pseudoType;
 
     if (name.startsWith("-webkit-"))
         return PseudoWebKitCustomElement;
     if (name.startsWith("cue"))
         return PseudoUserAgentCustomElement;
 
     return PseudoUnknown;
 }
 
 void CSSSelector::extractPseudoType() const
 {
     if (m_match != PseudoClass && m_match != PseudoElement && m_match != PagePseudoClass)
         return;
 
-    m_pseudoType = parsePseudoType(value());
+    m_pseudoType = parsePseudoType(value(), !argument().isNull() || selectorList());
 
     bool element = false; // pseudo-element
     bool compat = false; // single colon compatbility mode
     bool isPagePseudoClass = false; // Page pseudo-class
 
     switch (m_pseudoType) {
     case PseudoAfter:
     case PseudoBefore:
     case PseudoCue:
     case PseudoFirstLetter:
@@ skipping 148 matching lines @@
         } else if (cs->m_match == CSSSelector::Class) {
             str.append('.');
             serializeIdentifier(cs->value(), str);
         } else if (cs->m_match == CSSSelector::PseudoClass || cs->m_match == CSSSelector::PagePseudoClass) {
             str.append(':');
             str.append(cs->value());
 
             switch (cs->pseudoType()) {
             case PseudoNot:
                 ASSERT(cs->selectorList());
+                str.append('(');
                 str.append(cs->selectorList()->first()->selectorText());
                 str.append(')');
                 break;
             case PseudoLang:
             case PseudoNthChild:
             case PseudoNthLastChild:
             case PseudoNthOfType:
             case PseudoNthLastOfType:
+                str.append('(');
                 str.append(cs->argument());
                 str.append(')');
                 break;
             case PseudoAny: {
+                str.append('(');
                 const CSSSelector* firstSubSelector = cs->selectorList()->first();
                 for (const CSSSelector* subSelector = firstSubSelector; subSelector; subSelector = CSSSelectorList::next(*subSelector)) {
                     if (subSelector != firstSubSelector)
                         str.append(',');
                     str.append(subSelector->selectorText());
                 }
                 str.append(')');
                 break;
             }
             case PseudoHost:
             case PseudoHostContext: {
                 if (cs->selectorList()) {
+                    str.append('(');
                     const CSSSelector* firstSubSelector = cs->selectorList()->first();
                     for (const CSSSelector* subSelector = firstSubSelector; subSelector; subSelector = CSSSelectorList::next(*subSelector)) {
                         if (subSelector != firstSubSelector)
                             str.append(',');
                         str.append(subSelector->selectorText());
                     }
                     str.append(')');
                 }
                 break;
             }
@@ skipping 250 matching lines @@
         if (count < nthBValue())
             return false;
         return (count - nthBValue()) % nthAValue() == 0;
     }
     if (count > nthBValue())
         return false;
     return (nthBValue() - count) % (-nthAValue()) == 0;
 }
 
 } // namespace blink