| OLD | NEW |
|---|
| (Empty) |
| 1 /* | |
| 2 * Copyright (C) 2003 Lars Knoll (knoll@kde.org) | |
| 3 * Copyright (C) 2004, 2005, 2006, 2008, 2009, 2010 Apple Inc. All rights reserv
ed. | |
| 4 * | |
| 5 * This library is free software; you can redistribute it and/or | |
| 6 * modify it under the terms of the GNU Library General Public | |
| 7 * License as published by the Free Software Foundation; either | |
| 8 * version 2 of the License, or (at your option) any later version. | |
| 9 * | |
| 10 * This library is distributed in the hope that it will be useful, | |
| 11 * but WITHOUT ANY WARRANTY; without even the implied warranty of | |
| 12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | |
| 13 * Library General Public License for more details. | |
| 14 * | |
| 15 * You should have received a copy of the GNU Library General Public License | |
| 16 * along with this library; see the file COPYING.LIB. If not, write to | |
| 17 * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, | |
| 18 * Boston, MA 02110-1301, USA. | |
| 19 */ | |
| 20 | |
| 21 #ifndef CSSParserValues_h | |
| 22 #define CSSParserValues_h | |
| 23 | |
| 24 #include "core/CSSValueKeywords.h" | |
| 25 #include "core/css/CSSPrimitiveValue.h" | |
| 26 #include "core/css/CSSSelector.h" | |
| 27 #include "core/css/CSSValueList.h" | |
| 28 #include "wtf/text/AtomicString.h" | |
| 29 #include "wtf/text/WTFString.h" | |
| 30 | |
| 31 namespace blink { | |
| 32 | |
| 33 class CSSValue; | |
| 34 class QualifiedName; | |
| 35 | |
| 36 struct CSSParserString { | |
| 37 void init(const LChar* characters, unsigned length) | |
| 38 { | |
| 39 m_data.characters8 = characters; | |
| 40 m_length = length; | |
| 41 m_is8Bit = true; | |
| 42 } | |
| 43 | |
| 44 void init(const UChar* characters, unsigned length) | |
| 45 { | |
| 46 m_data.characters16 = characters; | |
| 47 m_length = length; | |
| 48 m_is8Bit = false; | |
| 49 } | |
| 50 | |
| 51 void init(const String& string) | |
| 52 { | |
| 53 init(string, 0, string.length()); | |
| 54 } | |
| 55 | |
| 56 void init(const String& string, unsigned startOffset, unsigned length) | |
| 57 { | |
| 58 m_length = length; | |
| 59 if (!m_length) { | |
| 60 m_data.characters8 = 0; | |
| 61 m_is8Bit = true; | |
| 62 return; | |
| 63 } | |
| 64 if (string.is8Bit()) { | |
| 65 m_data.characters8 = const_cast<LChar*>(string.characters8()) + star
tOffset; | |
| 66 m_is8Bit = true; | |
| 67 } else { | |
| 68 m_data.characters16 = const_cast<UChar*>(string.characters16()) + st
artOffset; | |
| 69 m_is8Bit = false; | |
| 70 } | |
| 71 } | |
| 72 | |
| 73 void clear() | |
| 74 { | |
| 75 m_data.characters8 = 0; | |
| 76 m_length = 0; | |
| 77 m_is8Bit = true; | |
| 78 } | |
| 79 | |
| 80 bool is8Bit() const { return m_is8Bit; } | |
| 81 const LChar* characters8() const { ASSERT(is8Bit()); return m_data.character
s8; } | |
| 82 const UChar* characters16() const { ASSERT(!is8Bit()); return m_data.charact
ers16; } | |
| 83 template <typename CharacterType> | |
| 84 const CharacterType* characters() const; | |
| 85 | |
| 86 unsigned length() const { return m_length; } | |
| 87 void setLength(unsigned length) { m_length = length; } | |
| 88 | |
| 89 UChar operator[](unsigned i) const | |
| 90 { | |
| 91 ASSERT_WITH_SECURITY_IMPLICATION(i < m_length); | |
| 92 if (is8Bit()) | |
| 93 return m_data.characters8[i]; | |
| 94 return m_data.characters16[i]; | |
| 95 } | |
| 96 | |
| 97 bool equalIgnoringCase(const char* str) const | |
| 98 { | |
| 99 bool match = is8Bit() ? WTF::equalIgnoringCase(str, characters8(), lengt
h()) : WTF::equalIgnoringCase(str, characters16(), length()); | |
| 100 if (!match) | |
| 101 return false; | |
| 102 ASSERT(strlen(str) >= length()); | |
| 103 return str[length()] == '\0'; | |
| 104 } | |
| 105 | |
| 106 template <size_t strLength> | |
| 107 bool startsWithIgnoringCase(const char (&str)[strLength]) const | |
| 108 { | |
| 109 return startsWithIgnoringCase(str, strLength - 1); | |
| 110 } | |
| 111 | |
| 112 bool startsWithIgnoringCase(const char* str, size_t strLength) const | |
| 113 { | |
| 114 if (length() < strLength) | |
| 115 return false; | |
| 116 return is8Bit() ? WTF::equalIgnoringCase(str, characters8(), strLength)
: WTF::equalIgnoringCase(str, characters16(), strLength); | |
| 117 } | |
| 118 | |
| 119 operator String() const { return is8Bit() ? String(m_data.characters8, m_len
gth) : StringImpl::create8BitIfPossible(m_data.characters16, m_length); } | |
| 120 operator AtomicString() const { return is8Bit() ? AtomicString(m_data.charac
ters8, m_length) : AtomicString(m_data.characters16, m_length); } | |
| 121 | |
| 122 bool isFunction() const { return length() > 0 && (*this)[length() - 1] == '(
'; } | |
| 123 | |
| 124 union { | |
| 125 const LChar* characters8; | |
| 126 const UChar* characters16; | |
| 127 } m_data; | |
| 128 unsigned m_length; | |
| 129 bool m_is8Bit; | |
| 130 }; | |
| 131 | |
| 132 template <> | |
| 133 inline const LChar* CSSParserString::characters<LChar>() const { return characte
rs8(); } | |
| 134 | |
| 135 template <> | |
| 136 inline const UChar* CSSParserString::characters<UChar>() const { return characte
rs16(); } | |
| 137 | |
| 138 struct CSSParserFunction; | |
| 139 | |
| 140 struct CSSParserValue { | |
| 141 CSSValueID id; | |
| 142 bool isInt; | |
| 143 union { | |
| 144 double fValue; | |
| 145 int iValue; | |
| 146 CSSParserString string; | |
| 147 CSSParserFunction* function; | |
| 148 CSSParserValueList* valueList; | |
| 149 }; | |
| 150 enum { | |
| 151 Operator = 0x100000, | |
| 152 Function = 0x100001, | |
| 153 ValueList = 0x100002, | |
| 154 Q_EMS = 0x100003, | |
| 155 }; | |
| 156 int unit; | |
| 157 | |
| 158 inline void setFromNumber(double value, int unit = CSSPrimitiveValue::CSS_NU
MBER); | |
| 159 inline void setFromFunction(CSSParserFunction*); | |
| 160 inline void setFromValueList(PassOwnPtr<CSSParserValueList>); | |
| 161 | |
| 162 PassRefPtrWillBeRawPtr<CSSValue> createCSSValue(); | |
| 163 }; | |
| 164 | |
| 165 class CSSParserValueList { | |
| 166 WTF_MAKE_FAST_ALLOCATED; | |
| 167 public: | |
| 168 CSSParserValueList() | |
| 169 : m_current(0) | |
| 170 { | |
| 171 } | |
| 172 ~CSSParserValueList(); | |
| 173 | |
| 174 void addValue(const CSSParserValue&); | |
| 175 void insertValueAt(unsigned, const CSSParserValue&); | |
| 176 void stealValues(CSSParserValueList&); | |
| 177 | |
| 178 unsigned size() const { return m_values.size(); } | |
| 179 unsigned currentIndex() { return m_current; } | |
| 180 CSSParserValue* current() { return m_current < m_values.size() ? &m_values[m
_current] : 0; } | |
| 181 CSSParserValue* next() { ++m_current; return current(); } | |
| 182 CSSParserValue* previous() | |
| 183 { | |
| 184 if (!m_current) | |
| 185 return 0; | |
| 186 --m_current; | |
| 187 return current(); | |
| 188 } | |
| 189 void setCurrentIndex(unsigned index) | |
| 190 { | |
| 191 ASSERT(index < m_values.size()); | |
| 192 if (index < m_values.size()) | |
| 193 m_current = index; | |
| 194 } | |
| 195 | |
| 196 CSSParserValue* valueAt(unsigned i) { return i < m_values.size() ? &m_values
[i] : 0; } | |
| 197 | |
| 198 void clearAndLeakValues() { m_values.clear(); m_current = 0;} | |
| 199 void destroyAndClear(); | |
| 200 | |
| 201 private: | |
| 202 unsigned m_current; | |
| 203 Vector<CSSParserValue, 4> m_values; | |
| 204 }; | |
| 205 | |
| 206 struct CSSParserFunction { | |
| 207 WTF_MAKE_FAST_ALLOCATED; | |
| 208 public: | |
| 209 CSSParserString name; | |
| 210 OwnPtr<CSSParserValueList> args; | |
| 211 }; | |
| 212 | |
| 213 class CSSParserSelector { | |
| 214 WTF_MAKE_NONCOPYABLE(CSSParserSelector); WTF_MAKE_FAST_ALLOCATED; | |
| 215 public: | |
| 216 CSSParserSelector(); | |
| 217 explicit CSSParserSelector(const QualifiedName&); | |
| 218 ~CSSParserSelector(); | |
| 219 | |
| 220 PassOwnPtr<CSSSelector> releaseSelector() { return m_selector.release(); } | |
| 221 | |
| 222 CSSSelector::Relation relation() const { return m_selector->relation(); } | |
| 223 void setValue(const AtomicString& value) { m_selector->setValue(value); } | |
| 224 void setAttribute(const QualifiedName& value, CSSSelector::AttributeMatchTyp
e matchType) { m_selector->setAttribute(value, matchType); } | |
| 225 void setArgument(const AtomicString& value) { m_selector->setArgument(value)
; } | |
| 226 void setMatch(CSSSelector::Match value) { m_selector->setMatch(value); } | |
| 227 void setRelation(CSSSelector::Relation value) { m_selector->setRelation(valu
e); } | |
| 228 void setForPage() { m_selector->setForPage(); } | |
| 229 void setRelationIsAffectedByPseudoContent() { m_selector->setRelationIsAffec
tedByPseudoContent(); } | |
| 230 bool relationIsAffectedByPseudoContent() const { return m_selector->relation
IsAffectedByPseudoContent(); } | |
| 231 | |
| 232 void adoptSelectorVector(Vector<OwnPtr<CSSParserSelector> >& selectorVector)
; | |
| 233 | |
| 234 bool hasHostPseudoSelector() const; | |
| 235 bool isContentPseudoElement() const { return m_selector->isContentPseudoElem
ent(); } | |
| 236 | |
| 237 CSSSelector::PseudoType pseudoType() const { return m_selector->pseudoType()
; } | |
| 238 bool isCustomPseudoElement() const { return m_selector->isCustomPseudoElemen
t(); } | |
| 239 bool crossesTreeScopes() const { return isCustomPseudoElement() || pseudoTyp
e() == CSSSelector::PseudoCue || pseudoType() == CSSSelector::PseudoShadow; } | |
| 240 | |
| 241 bool isSimple() const; | |
| 242 bool hasShadowPseudo() const; | |
| 243 | |
| 244 CSSParserSelector* tagHistory() const { return m_tagHistory.get(); } | |
| 245 void setTagHistory(PassOwnPtr<CSSParserSelector> selector) { m_tagHistory =
selector; } | |
| 246 void clearTagHistory() { m_tagHistory.clear(); } | |
| 247 void insertTagHistory(CSSSelector::Relation before, PassOwnPtr<CSSParserSele
ctor>, CSSSelector::Relation after); | |
| 248 void appendTagHistory(CSSSelector::Relation, PassOwnPtr<CSSParserSelector>); | |
| 249 void prependTagSelector(const QualifiedName&, bool tagIsForNamespaceRule = f
alse); | |
| 250 | |
| 251 private: | |
| 252 OwnPtr<CSSSelector> m_selector; | |
| 253 OwnPtr<CSSParserSelector> m_tagHistory; | |
| 254 }; | |
| 255 | |
| 256 inline bool CSSParserSelector::hasShadowPseudo() const | |
| 257 { | |
| 258 return m_selector->relation() == CSSSelector::ShadowPseudo; | |
| 259 } | |
| 260 | |
| 261 inline void CSSParserValue::setFromNumber(double value, int unit) | |
| 262 { | |
| 263 id = CSSValueInvalid; | |
| 264 isInt = false; | |
| 265 if (std::isfinite(value)) | |
| 266 fValue = value; | |
| 267 else | |
| 268 fValue = 0; | |
| 269 this->unit = unit; | |
| 270 } | |
| 271 | |
| 272 inline void CSSParserValue::setFromFunction(CSSParserFunction* function) | |
| 273 { | |
| 274 id = CSSValueInvalid; | |
| 275 this->function = function; | |
| 276 unit = Function; | |
| 277 isInt = false; | |
| 278 } | |
| 279 | |
| 280 inline void CSSParserValue::setFromValueList(PassOwnPtr<CSSParserValueList> valu
eList) | |
| 281 { | |
| 282 id = CSSValueInvalid; | |
| 283 this->valueList = valueList.leakPtr(); | |
| 284 unit = ValueList; | |
| 285 isInt = false; | |
| 286 } | |
| 287 | |
| 288 } | |
| 289 | |
| 290 #endif | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 469183002:
Move parser-related files in core/css to core/css/parser (Closed)
Base URL: https://chromium.googlesource.com/chromium/blink.git@pp2