This source file includes following definitions.
- createRareData
- specificity
- specificityForOneSelector
- specificityForPage
- pseudoId
- nameToPseudoTypeMap
- show
- show
- parsePseudoType
- extractPseudoType
- selectorText
- setAttribute
- setArgument
- setSelectorList
- validateSubSelector
- isCompound
- parseNth
- matchNth
- m_argument
- parseNth
- matchNth
#include "config.h"
#include "core/css/CSSSelector.h"
#include "HTMLNames.h"
#include "RuntimeEnabledFeatures.h"
#include "core/css/CSSOMUtils.h"
#include "core/css/CSSSelectorList.h"
#include "wtf/Assertions.h"
#include "wtf/HashMap.h"
#include "wtf/StdLibExtras.h"
#include "wtf/text/StringBuilder.h"
#include "wtf/text/StringHash.h"
#ifndef NDEBUG
#include <stdio.h>
#endif
namespace WebCore {
using namespace HTMLNames;
struct SameSizeAsCSSSelector {
unsigned bitfields;
void *pointers[1];
};
COMPILE_ASSERT(sizeof(CSSSelector) == sizeof(SameSizeAsCSSSelector), CSSSelectorShouldStaySmall);
void CSSSelector::createRareData()
{
ASSERT(m_match != Tag);
if (m_hasRareData)
return;
AtomicString value(m_data.m_value);
if (m_data.m_value)
m_data.m_value->deref();
m_data.m_rareData = RareData::create(value).leakRef();
m_hasRareData = true;
}
unsigned CSSSelector::specificity() const
{
static const unsigned maxValueMask = 0xffffff;
static const unsigned idMask = 0xff0000;
static const unsigned classMask = 0xff00;
static const unsigned elementMask = 0xff;
if (isForPage())
return specificityForPage() & maxValueMask;
unsigned total = 0;
unsigned temp = 0;
for (const CSSSelector* selector = this; selector; selector = selector->tagHistory()) {
temp = total + selector->specificityForOneSelector();
if ((temp & idMask) < (total & idMask))
total |= idMask;
else if ((temp & classMask) < (total & classMask))
total |= classMask;
else if ((temp & elementMask) < (total & elementMask))
total |= elementMask;
else
total = temp;
}
return total;
}
inline unsigned CSSSelector::specificityForOneSelector() const
{
switch (m_match) {
case Id:
return 0x10000;
case PseudoClass:
if (pseudoType() == PseudoHost || pseudoType() == PseudoHostContext)
return 0;
case Exact:
case Class:
case Set:
case List:
case Hyphen:
case PseudoElement:
case Contain:
case Begin:
case End:
if (pseudoType() == PseudoNot) {
ASSERT(selectorList());
return selectorList()->first()->specificityForOneSelector();
}
return 0x100;
case Tag:
return (tagQName().localName() != starAtom) ? 1 : 0;
case Unknown:
return 0;
}
ASSERT_NOT_REACHED();
return 0;
}
unsigned CSSSelector::specificityForPage() const
{
unsigned s = 0;
for (const CSSSelector* component = this; component; component = component->tagHistory()) {
switch (component->m_match) {
case Tag:
s += tagQName().localName() == starAtom ? 0 : 4;
break;
case PagePseudoClass:
switch (component->pseudoType()) {
case PseudoFirstPage:
s += 2;
break;
case PseudoLeftPage:
case PseudoRightPage:
s += 1;
break;
case PseudoNotParsed:
break;
default:
ASSERT_NOT_REACHED();
}
break;
default:
break;
}
}
return s;
}
PseudoId CSSSelector::pseudoId(PseudoType type)
{
switch (type) {
case PseudoFirstLine:
return FIRST_LINE;
case PseudoFirstLetter:
return FIRST_LETTER;
case PseudoSelection:
return SELECTION;
case PseudoBefore:
return BEFORE;
case PseudoAfter:
return AFTER;
case PseudoBackdrop:
return BACKDROP;
case PseudoScrollbar:
return SCROLLBAR;
case PseudoScrollbarButton:
return SCROLLBAR_BUTTON;
case PseudoScrollbarCorner:
return SCROLLBAR_CORNER;
case PseudoScrollbarThumb:
return SCROLLBAR_THUMB;
case PseudoScrollbarTrack:
return SCROLLBAR_TRACK;
case PseudoScrollbarTrackPiece:
return SCROLLBAR_TRACK_PIECE;
case PseudoResizer:
return RESIZER;
case PseudoUnknown:
case PseudoEmpty:
case PseudoFirstChild:
case PseudoFirstOfType:
case PseudoLastChild:
case PseudoLastOfType:
case PseudoOnlyChild:
case PseudoOnlyOfType:
case PseudoNthChild:
case PseudoNthOfType:
case PseudoNthLastChild:
case PseudoNthLastOfType:
case PseudoLink:
case PseudoVisited:
case PseudoAny:
case PseudoAnyLink:
case PseudoAutofill:
case PseudoHover:
case PseudoDrag:
case PseudoFocus:
case PseudoActive:
case PseudoChecked:
case PseudoEnabled:
case PseudoFullPageMedia:
case PseudoDefault:
case PseudoDisabled:
case PseudoOptional:
case PseudoRequired:
case PseudoReadOnly:
case PseudoReadWrite:
case PseudoValid:
case PseudoInvalid:
case PseudoIndeterminate:
case PseudoTarget:
case PseudoLang:
case PseudoNot:
case PseudoRoot:
case PseudoScope:
case PseudoScrollbarBack:
case PseudoScrollbarForward:
case PseudoWindowInactive:
case PseudoCornerPresent:
case PseudoDecrement:
case PseudoIncrement:
case PseudoHorizontal:
case PseudoVertical:
case PseudoStart:
case PseudoEnd:
case PseudoDoubleButton:
case PseudoSingleButton:
case PseudoNoButton:
case PseudoFirstPage:
case PseudoLeftPage:
case PseudoRightPage:
case PseudoInRange:
case PseudoOutOfRange:
case PseudoUserAgentCustomElement:
case PseudoWebKitCustomElement:
case PseudoCue:
case PseudoFutureCue:
case PseudoPastCue:
case PseudoUnresolved:
case PseudoContent:
case PseudoHost:
case PseudoHostContext:
case PseudoShadow:
case PseudoFullScreen:
case PseudoFullScreenDocument:
case PseudoFullScreenAncestor:
return NOPSEUDO;
case PseudoNotParsed:
ASSERT_NOT_REACHED();
return NOPSEUDO;
}
ASSERT_NOT_REACHED();
return NOPSEUDO;
}
struct NameToPseudoStruct {
const char* string;
unsigned type:8;
};
const static NameToPseudoStruct pseudoTypeMap[] = {
{"active", CSSSelector::PseudoActive},
{"after", CSSSelector::PseudoAfter},
{"-webkit-any(", CSSSelector::PseudoAny},
{"-webkit-any-link", CSSSelector::PseudoAnyLink},
{"-webkit-autofill", CSSSelector::PseudoAutofill},
{"backdrop", CSSSelector::PseudoBackdrop},
{"before", CSSSelector::PseudoBefore},
{"checked", CSSSelector::PseudoChecked},
{"default", CSSSelector::PseudoDefault},
{"disabled", CSSSelector::PseudoDisabled},
{"read-only", CSSSelector::PseudoReadOnly},
{"read-write", CSSSelector::PseudoReadWrite},
{"valid", CSSSelector::PseudoValid},
{"invalid", CSSSelector::PseudoInvalid},
{"-webkit-drag", CSSSelector::PseudoDrag},
{"empty", CSSSelector::PseudoEmpty},
{"enabled", CSSSelector::PseudoEnabled},
{"first-child", CSSSelector::PseudoFirstChild},
{"first-letter", CSSSelector::PseudoFirstLetter},
{"first-line", CSSSelector::PseudoFirstLine},
{"first-of-type", CSSSelector::PseudoFirstOfType},
{"-webkit-full-page-media", CSSSelector::PseudoFullPageMedia},
{"nth-child(", CSSSelector::PseudoNthChild},
{"nth-of-type(", CSSSelector::PseudoNthOfType},
{"nth-last-child(", CSSSelector::PseudoNthLastChild},
{"nth-last-of-type(", CSSSelector::PseudoNthLastOfType},
{"focus", CSSSelector::PseudoFocus},
{"hover", CSSSelector::PseudoHover},
{"indeterminate", CSSSelector::PseudoIndeterminate},
{"last-child", CSSSelector::PseudoLastChild},
{"last-of-type", CSSSelector::PseudoLastOfType},
{"link", CSSSelector::PseudoLink},
{"lang(", CSSSelector::PseudoLang},
{"not(", CSSSelector::PseudoNot},
{"only-child", CSSSelector::PseudoOnlyChild},
{"only-of-type", CSSSelector::PseudoOnlyOfType},
{"optional", CSSSelector::PseudoOptional},
{"required", CSSSelector::PseudoRequired},
{"-webkit-resizer", CSSSelector::PseudoResizer},
{"root", CSSSelector::PseudoRoot},
{"-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},
{"selection", CSSSelector::PseudoSelection},
{"target", CSSSelector::PseudoTarget},
{"visited", CSSSelector::PseudoVisited},
{"window-inactive", CSSSelector::PseudoWindowInactive},
{"decrement", CSSSelector::PseudoDecrement},
{"increment", CSSSelector::PseudoIncrement},
{"start", CSSSelector::PseudoStart},
{"end", CSSSelector::PseudoEnd},
{"horizontal", CSSSelector::PseudoHorizontal},
{"vertical", CSSSelector::PseudoVertical},
{"double-button", CSSSelector::PseudoDoubleButton},
{"single-button", CSSSelector::PseudoSingleButton},
{"no-button", CSSSelector::PseudoNoButton},
{"corner-present", CSSSelector::PseudoCornerPresent},
{"first", CSSSelector::PseudoFirstPage},
{"left", CSSSelector::PseudoLeftPage},
{"right", CSSSelector::PseudoRightPage},
{"-webkit-full-screen", CSSSelector::PseudoFullScreen},
{"-webkit-full-screen-document", CSSSelector::PseudoFullScreenDocument},
{"-webkit-full-screen-ancestor", CSSSelector::PseudoFullScreenAncestor},
{"cue(", CSSSelector::PseudoCue},
{"cue", CSSSelector::PseudoWebKitCustomElement},
{"future", CSSSelector::PseudoFutureCue},
{"past", CSSSelector::PseudoPastCue},
{"in-range", CSSSelector::PseudoInRange},
{"out-of-range", CSSSelector::PseudoOutOfRange},
{"scope", CSSSelector::PseudoScope},
{"unresolved", CSSSelector::PseudoUnresolved},
{"host", CSSSelector::PseudoHost},
{"host(", CSSSelector::PseudoHost},
{"host-context(", CSSSelector::PseudoHostContext},
{"content", CSSSelector::PseudoContent},
{"shadow", CSSSelector::PseudoShadow},
};
static HashMap<StringImpl*, CSSSelector::PseudoType>* nameToPseudoTypeMap()
{
static HashMap<StringImpl*, CSSSelector::PseudoType>* nameToPseudoType = 0;
if (!nameToPseudoType) {
nameToPseudoType = new HashMap<StringImpl*, CSSSelector::PseudoType>;
size_t pseudoCount = WTF_ARRAY_LENGTH(pseudoTypeMap);
for (size_t i = 0; i < pseudoCount; i++) {
const char* str = pseudoTypeMap[i].string;
CSSSelector::PseudoType type;
type = static_cast<CSSSelector::PseudoType>(pseudoTypeMap[i].type);
AtomicString* name = new AtomicString(str, strlen(str), AtomicString::ConstructFromLiteral);
nameToPseudoType->set(name->impl(), type);
}
}
return nameToPseudoType;
}
#ifndef NDEBUG
void CSSSelector::show(int indent) const
{
printf("%*sselectorText(): %s\n", indent, "", selectorText().ascii().data());
printf("%*sm_match: %d\n", indent, "", m_match);
printf("%*sisCustomPseudoElement(): %d\n", indent, "", isCustomPseudoElement());
if (m_match != Tag)
printf("%*svalue(): %s\n", indent, "", value().ascii().data());
printf("%*spseudoType(): %d\n", indent, "", pseudoType());
if (m_match == Tag)
printf("%*stagQName().localName: %s\n", indent, "", tagQName().localName().ascii().data());
printf("%*sisAttributeSelector(): %d\n", indent, "", isAttributeSelector());
if (isAttributeSelector())
printf("%*sattribute(): %s\n", indent, "", attribute().localName().ascii().data());
printf("%*sargument(): %s\n", indent, "", argument().ascii().data());
printf("%*sspecificity(): %u\n", indent, "", specificity());
if (tagHistory()) {
printf("\n%*s--> (relation == %d)\n", indent, "", relation());
tagHistory()->show(indent + 2);
} else {
printf("\n%*s--> (relation == %d)\n", indent, "", relation());
}
}
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)
{
if (name.isNull())
return PseudoUnknown;
HashMap<StringImpl*, CSSSelector::PseudoType>* nameToPseudoType = nameToPseudoTypeMap();
HashMap<StringImpl*, CSSSelector::PseudoType>::iterator slot = nameToPseudoType->find(name.impl());
if (slot != nameToPseudoType->end())
return slot->value;
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());
bool element = false;
bool compat = false;
bool isPagePseudoClass = false;
switch (m_pseudoType) {
case PseudoAfter:
case PseudoBefore:
case PseudoCue:
case PseudoFirstLetter:
case PseudoFirstLine:
compat = true;
case PseudoBackdrop:
case PseudoResizer:
case PseudoScrollbar:
case PseudoScrollbarCorner:
case PseudoScrollbarButton:
case PseudoScrollbarThumb:
case PseudoScrollbarTrack:
case PseudoScrollbarTrackPiece:
case PseudoSelection:
case PseudoUserAgentCustomElement:
case PseudoWebKitCustomElement:
case PseudoContent:
case PseudoShadow:
element = true;
break;
case PseudoUnknown:
case PseudoEmpty:
case PseudoFirstChild:
case PseudoFirstOfType:
case PseudoLastChild:
case PseudoLastOfType:
case PseudoOnlyChild:
case PseudoOnlyOfType:
case PseudoNthChild:
case PseudoNthOfType:
case PseudoNthLastChild:
case PseudoNthLastOfType:
case PseudoLink:
case PseudoVisited:
case PseudoAny:
case PseudoAnyLink:
case PseudoAutofill:
case PseudoHover:
case PseudoDrag:
case PseudoFocus:
case PseudoActive:
case PseudoChecked:
case PseudoEnabled:
case PseudoFullPageMedia:
case PseudoDefault:
case PseudoDisabled:
case PseudoOptional:
case PseudoRequired:
case PseudoReadOnly:
case PseudoReadWrite:
case PseudoScope:
case PseudoValid:
case PseudoInvalid:
case PseudoIndeterminate:
case PseudoTarget:
case PseudoLang:
case PseudoNot:
case PseudoRoot:
case PseudoScrollbarBack:
case PseudoScrollbarForward:
case PseudoWindowInactive:
case PseudoCornerPresent:
case PseudoDecrement:
case PseudoIncrement:
case PseudoHorizontal:
case PseudoVertical:
case PseudoStart:
case PseudoEnd:
case PseudoDoubleButton:
case PseudoSingleButton:
case PseudoNoButton:
case PseudoNotParsed:
case PseudoFullScreen:
case PseudoFullScreenDocument:
case PseudoFullScreenAncestor:
case PseudoInRange:
case PseudoOutOfRange:
case PseudoFutureCue:
case PseudoPastCue:
case PseudoHost:
case PseudoHostContext:
case PseudoUnresolved:
break;
case PseudoFirstPage:
case PseudoLeftPage:
case PseudoRightPage:
isPagePseudoClass = true;
break;
}
bool matchPagePseudoClass = (m_match == PagePseudoClass);
if (matchPagePseudoClass != isPagePseudoClass)
m_pseudoType = PseudoUnknown;
else if (m_match == PseudoClass && element) {
if (!compat)
m_pseudoType = PseudoUnknown;
else
m_match = PseudoElement;
} else if (m_match == PseudoElement && !element)
m_pseudoType = PseudoUnknown;
}
bool CSSSelector::operator==(const CSSSelector& other) const
{
const CSSSelector* sel1 = this;
const CSSSelector* sel2 = &other;
while (sel1 && sel2) {
if (sel1->attribute() != sel2->attribute()
|| sel1->relation() != sel2->relation()
|| sel1->m_match != sel2->m_match
|| sel1->value() != sel2->value()
|| sel1->pseudoType() != sel2->pseudoType()
|| sel1->argument() != sel2->argument()) {
return false;
}
if (sel1->m_match == Tag) {
if (sel1->tagQName() != sel2->tagQName())
return false;
}
sel1 = sel1->tagHistory();
sel2 = sel2->tagHistory();
}
if (sel1 || sel2)
return false;
return true;
}
String CSSSelector::selectorText(const String& rightSide) const
{
StringBuilder str;
if (m_match == CSSSelector::Tag && !m_tagIsForNamespaceRule) {
if (tagQName().prefix().isNull())
str.append(tagQName().localName());
else {
str.append(tagQName().prefix().string());
str.append('|');
str.append(tagQName().localName());
}
}
const CSSSelector* cs = this;
while (true) {
if (cs->m_match == CSSSelector::Id) {
str.append('#');
serializeIdentifier(cs->value(), str);
} 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(cs->selectorList()->first()->selectorText());
str.append(')');
break;
case PseudoLang:
case PseudoNthChild:
case PseudoNthLastChild:
case PseudoNthOfType:
case PseudoNthLastOfType:
str.append(cs->argument());
str.append(')');
break;
case PseudoAny: {
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()) {
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;
}
default:
break;
}
} else if (cs->m_match == CSSSelector::PseudoElement) {
str.appendLiteral("::");
str.append(cs->value());
if (cs->pseudoType() == PseudoContent) {
if (cs->relation() == CSSSelector::SubSelector && cs->tagHistory())
return cs->tagHistory()->selectorText() + str.toString() + rightSide;
}
} else if (cs->isAttributeSelector()) {
str.append('[');
const AtomicString& prefix = cs->attribute().prefix();
if (!prefix.isNull()) {
str.append(prefix);
str.append("|");
}
str.append(cs->attribute().localName());
switch (cs->m_match) {
case CSSSelector::Exact:
str.append('=');
break;
case CSSSelector::Set:
str.append(']');
break;
case CSSSelector::List:
str.appendLiteral("~=");
break;
case CSSSelector::Hyphen:
str.appendLiteral("|=");
break;
case CSSSelector::Begin:
str.appendLiteral("^=");
break;
case CSSSelector::End:
str.appendLiteral("$=");
break;
case CSSSelector::Contain:
str.appendLiteral("*=");
break;
default:
break;
}
if (cs->m_match != CSSSelector::Set) {
serializeString(cs->value(), str);
str.append(']');
}
}
if (cs->relation() != CSSSelector::SubSelector || !cs->tagHistory())
break;
cs = cs->tagHistory();
}
if (const CSSSelector* tagHistory = cs->tagHistory()) {
switch (cs->relation()) {
case CSSSelector::Descendant:
return tagHistory->selectorText(" " + str.toString() + rightSide);
case CSSSelector::Child:
return tagHistory->selectorText(" > " + str.toString() + rightSide);
case CSSSelector::ShadowDeep:
return tagHistory->selectorText(" /deep/ " + str.toString() + rightSide);
case CSSSelector::DirectAdjacent:
return tagHistory->selectorText(" + " + str.toString() + rightSide);
case CSSSelector::IndirectAdjacent:
return tagHistory->selectorText(" ~ " + str.toString() + rightSide);
case CSSSelector::SubSelector:
ASSERT_NOT_REACHED();
case CSSSelector::ShadowPseudo:
return tagHistory->selectorText(str.toString() + rightSide);
}
}
return str.toString() + rightSide;
}
void CSSSelector::setAttribute(const QualifiedName& value)
{
createRareData();
m_data.m_rareData->m_attribute = value;
}
void CSSSelector::setArgument(const AtomicString& value)
{
createRareData();
m_data.m_rareData->m_argument = value;
}
void CSSSelector::setSelectorList(PassOwnPtr<CSSSelectorList> selectorList)
{
createRareData();
m_data.m_rareData->m_selectorList = selectorList;
}
static bool validateSubSelector(const CSSSelector* selector)
{
switch (selector->m_match) {
case CSSSelector::Tag:
case CSSSelector::Id:
case CSSSelector::Class:
case CSSSelector::Exact:
case CSSSelector::Set:
case CSSSelector::List:
case CSSSelector::Hyphen:
case CSSSelector::Contain:
case CSSSelector::Begin:
case CSSSelector::End:
return true;
case CSSSelector::PseudoElement:
return false;
case CSSSelector::PagePseudoClass:
case CSSSelector::PseudoClass:
break;
}
switch (selector->pseudoType()) {
case CSSSelector::PseudoEmpty:
case CSSSelector::PseudoLink:
case CSSSelector::PseudoVisited:
case CSSSelector::PseudoTarget:
case CSSSelector::PseudoEnabled:
case CSSSelector::PseudoDisabled:
case CSSSelector::PseudoChecked:
case CSSSelector::PseudoIndeterminate:
case CSSSelector::PseudoNthChild:
case CSSSelector::PseudoNthLastChild:
case CSSSelector::PseudoNthOfType:
case CSSSelector::PseudoNthLastOfType:
case CSSSelector::PseudoFirstChild:
case CSSSelector::PseudoLastChild:
case CSSSelector::PseudoFirstOfType:
case CSSSelector::PseudoLastOfType:
case CSSSelector::PseudoOnlyOfType:
case CSSSelector::PseudoHost:
case CSSSelector::PseudoHostContext:
return true;
default:
return false;
}
}
bool CSSSelector::isCompound() const
{
if (!validateSubSelector(this))
return false;
const CSSSelector* prevSubSelector = this;
const CSSSelector* subSelector = tagHistory();
while (subSelector) {
if (prevSubSelector->relation() != CSSSelector::SubSelector)
return false;
if (!validateSubSelector(subSelector))
return false;
prevSubSelector = subSelector;
subSelector = subSelector->tagHistory();
}
return true;
}
bool CSSSelector::parseNth() const
{
if (!m_hasRareData)
return false;
if (m_parsedNth)
return true;
m_parsedNth = m_data.m_rareData->parseNth();
return m_parsedNth;
}
bool CSSSelector::matchNth(int count) const
{
ASSERT(m_hasRareData);
return m_data.m_rareData->matchNth(count);
}
CSSSelector::RareData::RareData(const AtomicString& value)
: m_value(value)
, m_a(0)
, m_b(0)
, m_attribute(anyQName())
, m_argument(nullAtom)
{
}
CSSSelector::RareData::~RareData()
{
}
bool CSSSelector::RareData::parseNth()
{
String argument = m_argument.lower();
if (argument.isEmpty())
return false;
m_a = 0;
m_b = 0;
if (argument == "odd") {
m_a = 2;
m_b = 1;
} else if (argument == "even") {
m_a = 2;
m_b = 0;
} else {
size_t n = argument.find('n');
if (n != kNotFound) {
if (argument[0] == '-') {
if (n == 1)
m_a = -1;
else
m_a = argument.substring(0, n).toInt();
} else if (!n)
m_a = 1;
else
m_a = argument.substring(0, n).toInt();
size_t p = argument.find('+', n);
if (p != kNotFound)
m_b = argument.substring(p + 1, argument.length() - p - 1).toInt();
else {
p = argument.find('-', n);
if (p != kNotFound)
m_b = -argument.substring(p + 1, argument.length() - p - 1).toInt();
}
} else
m_b = argument.toInt();
}
return true;
}
bool CSSSelector::RareData::matchNth(int count)
{
if (!m_a)
return count == m_b;
else if (m_a > 0) {
if (count < m_b)
return false;
return (count - m_b) % m_a == 0;
} else {
if (count > m_b)
return false;
return (m_b - count) % (-m_a) == 0;
}
}
}