393885b1d39a1f84acb282981555388ba285b82e
[WebKit-https.git] / Source / WebCore / css / CSSParser.h
1 /*
2  * Copyright (C) 2003 Lars Knoll (knoll@kde.org)
3  * Copyright (C) 2004, 2005, 2006, 2008, 2009, 2010 Apple Inc. All rights reserved.
4  * Copyright (C) 2008 Eric Seidel <eric@webkit.org>
5  * Copyright (C) 2009 - 2010  Torch Mobile (Beijing) Co. Ltd. All rights reserved.
6  *
7  * This library is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU Library General Public
9  * License as published by the Free Software Foundation; either
10  * version 2 of the License, or (at your option) any later version.
11  *
12  * This library is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
15  * Library General Public License for more details.
16  *
17  * You should have received a copy of the GNU Library General Public License
18  * along with this library; see the file COPYING.LIB.  If not, write to
19  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
20  * Boston, MA 02110-1301, USA.
21  */
22
23 #ifndef CSSParser_h
24 #define CSSParser_h
25
26 #include "CSSCalculationValue.h"
27 #include "CSSGradientValue.h"
28 #include "CSSParserMode.h"
29 #include "CSSParserValues.h"
30 #include "CSSProperty.h"
31 #include "CSSPropertyNames.h"
32 #include "CSSPropertySourceData.h"
33 #include "CSSSelector.h"
34 #include "Color.h"
35 #include "MediaQuery.h"
36 #include <wtf/HashMap.h>
37 #include <wtf/HashSet.h>
38 #include <wtf/OwnArrayPtr.h>
39 #include <wtf/Vector.h>
40 #include <wtf/text/AtomicString.h>
41
42 #if ENABLE(CSS_FILTERS)
43 #include "WebKitCSSFilterValue.h"
44 #endif
45
46 namespace WebCore {
47
48 class CSSBorderImageSliceValue;
49 class CSSPrimitiveValue;
50 class CSSProperty;
51 class CSSSelectorList;
52 class CSSValue;
53 class CSSValueList;
54 class CSSWrapShape;
55 class Document;
56 class MediaQueryExp;
57 class MediaQuerySet;
58 class StyleKeyframe;
59 class StylePropertySet;
60 class StylePropertyShorthand;
61 class StyleRuleBase;
62 class StyleRuleKeyframes;
63 class StyleKeyframe;
64 class StyleSheetInternal;
65 class StyledElement;
66
67 class CSSParser {
68 public:
69     CSSParser(const CSSParserContext&);
70
71     ~CSSParser();
72
73     void parseSheet(StyleSheetInternal*, const String&, int startLineNumber = 0, StyleRuleRangeMap* = 0);
74     PassRefPtr<StyleRuleBase> parseRule(StyleSheetInternal*, const String&);
75     PassRefPtr<StyleKeyframe> parseKeyframeRule(StyleSheetInternal*, const String&);
76     static bool parseValue(StylePropertySet*, CSSPropertyID, const String&, bool important, CSSParserMode, StyleSheetInternal*);
77     static bool parseColor(RGBA32& color, const String&, bool strict = false);
78     static bool parseSystemColor(RGBA32& color, const String&, Document*);
79     static PassRefPtr<CSSValueList> parseFontFaceValue(const AtomicString&);
80     PassRefPtr<CSSPrimitiveValue> parseValidPrimitive(int ident, CSSParserValue*);
81     bool parseDeclaration(StylePropertySet*, const String&, RefPtr<CSSStyleSourceData>*, StyleSheetInternal* contextStyleSheet);
82     PassOwnPtr<MediaQuery> parseMediaQuery(const String&);
83
84     void addProperty(CSSPropertyID, PassRefPtr<CSSValue>, bool important, bool implicit = false);
85     void rollbackLastProperties(int num);
86     bool hasProperties() const { return !m_parsedProperties.isEmpty(); }
87
88     bool parseValue(CSSPropertyID, bool important);
89     bool parseShorthand(CSSPropertyID, const StylePropertyShorthand&, bool important);
90     bool parse4Values(CSSPropertyID, const CSSPropertyID* properties, bool important);
91     bool parseContent(CSSPropertyID, bool important);
92     bool parseQuotes(CSSPropertyID, bool important);
93
94     PassRefPtr<CSSValue> parseAttr(CSSParserValueList* args);
95
96     PassRefPtr<CSSValue> parseBackgroundColor();
97
98     bool parseFillImage(CSSParserValueList*, RefPtr<CSSValue>&);
99
100     enum FillPositionFlag { InvalidFillPosition = 0, AmbiguousFillPosition = 1, XFillPosition = 2, YFillPosition = 4 };
101     PassRefPtr<CSSValue> parseFillPositionComponent(CSSParserValueList*, unsigned& cumulativeFlags, FillPositionFlag& individualFlag);
102     PassRefPtr<CSSValue> parseFillPositionX(CSSParserValueList*);
103     PassRefPtr<CSSValue> parseFillPositionY(CSSParserValueList*);
104     void parseFillPosition(CSSParserValueList*, RefPtr<CSSValue>&, RefPtr<CSSValue>&);
105
106     void parseFillRepeat(RefPtr<CSSValue>&, RefPtr<CSSValue>&);
107     PassRefPtr<CSSValue> parseFillSize(CSSPropertyID, bool &allowComma);
108
109     bool parseFillProperty(CSSPropertyID propId, CSSPropertyID& propId1, CSSPropertyID& propId2, RefPtr<CSSValue>&, RefPtr<CSSValue>&);
110     bool parseFillShorthand(CSSPropertyID, const CSSPropertyID* properties, int numProperties, bool important);
111
112     void addFillValue(RefPtr<CSSValue>& lval, PassRefPtr<CSSValue> rval);
113
114     void addAnimationValue(RefPtr<CSSValue>& lval, PassRefPtr<CSSValue> rval);
115
116     PassRefPtr<CSSValue> parseAnimationDelay();
117     PassRefPtr<CSSValue> parseAnimationDirection();
118     PassRefPtr<CSSValue> parseAnimationDuration();
119     PassRefPtr<CSSValue> parseAnimationFillMode();
120     PassRefPtr<CSSValue> parseAnimationIterationCount();
121     PassRefPtr<CSSValue> parseAnimationName();
122     PassRefPtr<CSSValue> parseAnimationPlayState();
123     PassRefPtr<CSSValue> parseAnimationProperty();
124     PassRefPtr<CSSValue> parseAnimationTimingFunction();
125
126     bool parseTransformOriginShorthand(RefPtr<CSSValue>&, RefPtr<CSSValue>&, RefPtr<CSSValue>&);
127     bool parseCubicBezierTimingFunctionValue(CSSParserValueList*& args, double& result);
128     bool parseAnimationProperty(CSSPropertyID, RefPtr<CSSValue>&);
129     bool parseTransitionShorthand(bool important);
130     bool parseAnimationShorthand(bool important);
131
132 #if ENABLE(CSS_GRID_LAYOUT)
133     bool parseGridTrackList(CSSPropertyID, bool important);
134 #endif
135
136     bool parseDashboardRegions(CSSPropertyID, bool important);
137
138     bool parseClipShape(CSSPropertyID, bool important);
139
140     bool parseExclusionShape(bool shapeInside, bool important);
141     PassRefPtr<CSSWrapShape> parseExclusionShapeRectangle(CSSParserValueList* args);
142     PassRefPtr<CSSWrapShape> parseExclusionShapeCircle(CSSParserValueList* args);
143     PassRefPtr<CSSWrapShape> parseExclusionShapeEllipse(CSSParserValueList* args);
144     PassRefPtr<CSSWrapShape> parseExclusionShapePolygon(CSSParserValueList* args);
145
146     bool parseFont(bool important);
147     PassRefPtr<CSSValueList> parseFontFamily();
148
149     bool parseCounter(CSSPropertyID, int defaultValue, bool important);
150     PassRefPtr<CSSValue> parseCounterContent(CSSParserValueList* args, bool counters);
151
152     bool parseColorParameters(CSSParserValue*, int* colorValues, bool parseAlpha);
153     bool parseHSLParameters(CSSParserValue*, double* colorValues, bool parseAlpha);
154     PassRefPtr<CSSPrimitiveValue> parseColor(CSSParserValue* = 0);
155     bool parseColorFromValue(CSSParserValue*, RGBA32&);
156     void parseSelector(const String&, CSSSelectorList&);
157
158     static bool fastParseColor(RGBA32&, const String&, bool strict);
159
160     bool parseFontVariant(bool important);
161     bool parseFontWeight(bool important);
162     bool parseFontFaceSrc();
163     bool parseFontFaceUnicodeRange();
164
165 #if ENABLE(SVG)
166     bool parseSVGValue(CSSPropertyID propId, bool important);
167     PassRefPtr<CSSValue> parseSVGPaint();
168     PassRefPtr<CSSValue> parseSVGColor();
169     PassRefPtr<CSSValue> parseSVGStrokeDasharray();
170 #endif
171
172     // CSS3 Parsing Routines (for properties specific to CSS3)
173     PassRefPtr<CSSValueList> parseShadow(CSSParserValueList*, CSSPropertyID);
174     bool parseBorderImage(CSSPropertyID, RefPtr<CSSValue>&, bool important = false);
175     bool parseBorderImageRepeat(RefPtr<CSSValue>&);
176     bool parseBorderImageSlice(CSSPropertyID, RefPtr<CSSBorderImageSliceValue>&);
177     bool parseBorderImageWidth(RefPtr<CSSPrimitiveValue>&);
178     bool parseBorderImageOutset(RefPtr<CSSPrimitiveValue>&);
179     bool parseBorderRadius(CSSPropertyID, bool important);
180
181     bool parseAspectRatio(bool important);
182
183     bool parseReflect(CSSPropertyID, bool important);
184
185     PassRefPtr<CSSValue> parseFlex(CSSParserValueList* args);
186
187     // Image generators
188     bool parseCanvas(CSSParserValueList*, RefPtr<CSSValue>&);
189
190     bool parseDeprecatedGradient(CSSParserValueList*, RefPtr<CSSValue>&);
191     bool parseLinearGradient(CSSParserValueList*, RefPtr<CSSValue>&, CSSGradientRepeat repeating);
192     bool parseRadialGradient(CSSParserValueList*, RefPtr<CSSValue>&, CSSGradientRepeat repeating);
193     bool parseGradientColorStops(CSSParserValueList*, CSSGradientValue*, bool expectComma);
194
195     bool parseCrossfade(CSSParserValueList*, RefPtr<CSSValue>&);
196
197 #if ENABLE(CSS_IMAGE_SET)
198     PassRefPtr<CSSValue> parseImageSet(CSSParserValueList*);
199 #endif
200
201 #if ENABLE(CSS_FILTERS)
202     PassRefPtr<CSSValueList> parseFilter();
203     PassRefPtr<WebKitCSSFilterValue> parseBuiltinFilterArguments(CSSParserValueList*, WebKitCSSFilterValue::FilterOperationType);
204 #if ENABLE(CSS_SHADERS)
205     PassRefPtr<WebKitCSSFilterValue> parseCustomFilter(CSSParserValue*);
206 #endif
207 #endif
208
209     PassRefPtr<CSSValueList> parseTransform();
210     bool parseTransformOrigin(CSSPropertyID propId, CSSPropertyID& propId1, CSSPropertyID& propId2, CSSPropertyID& propId3, RefPtr<CSSValue>&, RefPtr<CSSValue>&, RefPtr<CSSValue>&);
211     bool parsePerspectiveOrigin(CSSPropertyID propId, CSSPropertyID& propId1, CSSPropertyID& propId2,  RefPtr<CSSValue>&, RefPtr<CSSValue>&);
212
213     bool parseTextEmphasisStyle(bool important);
214
215     bool parseLineBoxContain(bool important);
216     bool parseCalculation(CSSParserValue*, CalculationPermittedValueRange);
217
218     bool parseFontFeatureTag(CSSValueList*);
219     bool parseFontFeatureSettings(bool important);
220
221     bool cssRegionsEnabled() const;
222     bool parseFlowThread(const String& flowName);
223     bool parseFlowThread(CSSPropertyID, bool important);
224     bool parseRegionThread(CSSPropertyID, bool important);
225
226     bool parseFontVariantLigatures(bool important);
227
228     int yyparse();
229
230     CSSParserSelector* createFloatingSelector();
231     PassOwnPtr<CSSParserSelector> sinkFloatingSelector(CSSParserSelector*);
232
233     Vector<OwnPtr<CSSParserSelector> >* createFloatingSelectorVector();
234     PassOwnPtr<Vector<OwnPtr<CSSParserSelector> > > sinkFloatingSelectorVector(Vector<OwnPtr<CSSParserSelector> >*);
235
236     CSSParserValueList* createFloatingValueList();
237     PassOwnPtr<CSSParserValueList> sinkFloatingValueList(CSSParserValueList*);
238
239     CSSParserFunction* createFloatingFunction();
240     PassOwnPtr<CSSParserFunction> sinkFloatingFunction(CSSParserFunction*);
241
242     CSSParserValue& sinkFloatingValue(CSSParserValue&);
243
244     MediaQuerySet* createMediaQuerySet();
245     StyleRuleBase* createImportRule(const CSSParserString&, MediaQuerySet*);
246     StyleKeyframe* createKeyframe(CSSParserValueList*);
247     StyleRuleKeyframes* createKeyframesRule();
248
249     typedef Vector<RefPtr<StyleRuleBase> > RuleList;
250     StyleRuleBase* createMediaRule(MediaQuerySet*, RuleList*);
251     RuleList* createRuleList();
252     StyleRuleBase* createStyleRule(Vector<OwnPtr<CSSParserSelector> >* selectors);
253     StyleRuleBase* createFontFaceRule();
254     StyleRuleBase* createPageRule(PassOwnPtr<CSSParserSelector> pageSelector);
255     StyleRuleBase* createRegionRule(Vector<OwnPtr<CSSParserSelector> >* regionSelector, RuleList* rules);
256     StyleRuleBase* createMarginAtRule(CSSSelector::MarginBoxType);
257     void startDeclarationsForMarginBox();
258     void endDeclarationsForMarginBox();
259
260     MediaQueryExp* createFloatingMediaQueryExp(const AtomicString&, CSSParserValueList*);
261     PassOwnPtr<MediaQueryExp> sinkFloatingMediaQueryExp(MediaQueryExp*);
262     Vector<OwnPtr<MediaQueryExp> >* createFloatingMediaQueryExpList();
263     PassOwnPtr<Vector<OwnPtr<MediaQueryExp> > > sinkFloatingMediaQueryExpList(Vector<OwnPtr<MediaQueryExp> >*);
264     MediaQuery* createFloatingMediaQuery(MediaQuery::Restrictor, const String&, PassOwnPtr<Vector<OwnPtr<MediaQueryExp> > >);
265     MediaQuery* createFloatingMediaQuery(PassOwnPtr<Vector<OwnPtr<MediaQueryExp> > >);
266     PassOwnPtr<MediaQuery> sinkFloatingMediaQuery(MediaQuery*);
267
268     void addNamespace(const AtomicString& prefix, const AtomicString& uri);
269     void updateSpecifiersWithElementName(const AtomicString& namespacePrefix, const AtomicString& elementName, CSSParserSelector*);
270     CSSParserSelector* updateSpecifiers(CSSParserSelector*, CSSParserSelector*);
271
272     void invalidBlockHit();
273
274     Vector<OwnPtr<CSSParserSelector> >* reusableSelectorVector() { return &m_reusableSelectorVector; }
275
276     void setReusableRegionSelectorVector(Vector<OwnPtr<CSSParserSelector> >* selectors);
277     Vector<OwnPtr<CSSParserSelector> >* reusableRegionSelectorVector() { return &m_reusableRegionSelectorVector; }
278
279     void updateLastSelectorLineAndPosition();
280     void updateLastMediaLine(MediaQuerySet*);
281
282     void clearProperties();
283
284     CSSParserContext m_context;
285
286     bool m_important;
287     CSSPropertyID m_id;
288     StyleSheetInternal* m_styleSheet;
289     RefPtr<StyleRuleBase> m_rule;
290     RefPtr<StyleKeyframe> m_keyframe;
291     OwnPtr<MediaQuery> m_mediaQuery;
292     OwnPtr<CSSParserValueList> m_valueList;
293     Vector<CSSProperty, 256> m_parsedProperties;
294     CSSSelectorList* m_selectorListForParseSelector;
295
296     unsigned m_numParsedPropertiesBeforeMarginBox;
297
298     int m_inParseShorthand;
299     CSSPropertyID m_currentShorthand;
300     bool m_implicitShorthand;
301
302     bool m_hasFontFaceOnlyValues;
303     bool m_hadSyntacticallyValidCSSRule;
304
305     AtomicString m_defaultNamespace;
306
307     // tokenizer methods and data
308     bool m_inStyleRuleOrDeclaration;
309     SourceRange m_selectorListRange;
310     SourceRange m_ruleBodyRange;
311     SourceRange m_propertyRange;
312     StyleRuleRangeMap* m_ruleRangeMap;
313     RefPtr<CSSRuleSourceData> m_currentRuleData;
314     void markSelectorListStart();
315     void markSelectorListEnd();
316     void markRuleBodyStart();
317     void markRuleBodyEnd();
318     void markPropertyStart();
319     void markPropertyEnd(bool isImportantFound, bool isPropertyParsed);
320     void resetSelectorListMarks() { m_selectorListRange.start = m_selectorListRange.end = 0; }
321     void resetRuleBodyMarks() { m_ruleBodyRange.start = m_ruleBodyRange.end = 0; }
322     void resetPropertyMarks() { m_propertyRange.start = m_propertyRange.end = UINT_MAX; }
323     int lex(void* yylval);
324     int token() { return m_token; }
325
326     PassRefPtr<CSSPrimitiveValue> createPrimitiveNumericValue(CSSParserValue*);
327     PassRefPtr<CSSPrimitiveValue> createPrimitiveStringValue(CSSParserValue*);
328
329     static KURL completeURL(const CSSParserContext&, const String& url);
330
331 private:
332     inline bool isIdentifierStart();
333
334     static inline UChar* checkAndSkipString(UChar*, UChar);
335
336     void parseEscape(UChar*&);
337     inline void parseIdentifier(UChar*&, bool&);
338     inline void parseString(UChar*&, UChar);
339     inline void parseURI(UChar*&, UChar*&);
340     inline bool parseUnicodeRange();
341     bool parseNthChild();
342     bool parseNthChildExtra();
343     inline void detectFunctionTypeToken(int);
344     inline void detectMediaQueryToken(int);
345     inline void detectNumberToken(UChar*, int);
346     inline void detectDashToken(int);
347     inline void detectAtToken(int, bool);
348
349     void setStyleSheet(StyleSheetInternal*);
350
351     inline bool inStrictMode() const { return m_context.mode == CSSStrictMode || m_context.mode == SVGAttributeMode; }
352     inline bool inQuirksMode() const { return m_context.mode == CSSQuirksMode; }
353     
354     KURL completeURL(const String& url) const;
355
356     void recheckAtKeyword(const UChar* str, int len);
357
358     void setupParser(const char* prefix, const String&, const char* suffix);
359
360     bool inShorthand() const { return m_inParseShorthand; }
361
362     void checkForOrphanedUnits();
363
364     void deleteFontFaceOnlyValues();
365
366     bool isGeneratedImageValue(CSSParserValue*) const;
367     bool parseGeneratedImage(CSSParserValueList*, RefPtr<CSSValue>&);
368
369     bool parseValue(StylePropertySet*, CSSPropertyID, const String&, bool important, StyleSheetInternal* contextStyleSheet);
370
371     enum SizeParameterType {
372         None,
373         Auto,
374         Length,
375         PageSize,
376         Orientation,
377     };
378
379     bool parsePage(CSSPropertyID propId, bool important);
380     bool parseSize(CSSPropertyID propId, bool important);
381     SizeParameterType parseSizeParameter(CSSValueList* parsedValues, CSSParserValue* value, SizeParameterType prevParamType);
382
383     bool parseFontFaceSrcURI(CSSValueList*);
384     bool parseFontFaceSrcLocal(CSSValueList*);
385
386     bool parseColor(const String&);
387
388     enum ParsingMode {
389         NormalMode,
390         MediaQueryMode,
391         NthChildMode
392     };
393
394     ParsingMode m_parsingMode;
395     OwnArrayPtr<UChar> m_dataStart;
396     UChar* m_currentCharacter;
397     UChar* m_tokenStart;
398     int m_token;
399     int m_lineNumber;
400     int m_lastSelectorLineNumber;
401
402     bool m_allowImportRules;
403     bool m_allowNamespaceDeclarations;
404
405     Vector<RefPtr<StyleRuleBase> > m_parsedRules;
406     Vector<RefPtr<StyleKeyframe> > m_parsedKeyframes;
407     Vector<RefPtr<MediaQuerySet> > m_parsedMediaQuerySets;
408     Vector<OwnPtr<RuleList> > m_parsedRuleLists;
409     HashSet<CSSParserSelector*> m_floatingSelectors;
410     HashSet<Vector<OwnPtr<CSSParserSelector> >*> m_floatingSelectorVectors;
411     HashSet<CSSParserValueList*> m_floatingValueLists;
412     HashSet<CSSParserFunction*> m_floatingFunctions;
413
414     OwnPtr<MediaQuery> m_floatingMediaQuery;
415     OwnPtr<MediaQueryExp> m_floatingMediaQueryExp;
416     OwnPtr<Vector<OwnPtr<MediaQueryExp> > > m_floatingMediaQueryExpList;
417
418     Vector<OwnPtr<CSSParserSelector> > m_reusableSelectorVector;
419     Vector<OwnPtr<CSSParserSelector> > m_reusableRegionSelectorVector;
420
421     RefPtr<CSSCalcValue> m_parsedCalculation;
422
423     // defines units allowed for a certain property, used in parseUnit
424     enum Units {
425         FUnknown   = 0x0000,
426         FInteger   = 0x0001,
427         FNumber    = 0x0002,  // Real Numbers
428         FPercent   = 0x0004,
429         FLength    = 0x0008,
430         FAngle     = 0x0010,
431         FTime      = 0x0020,
432         FFrequency = 0x0040,
433         FRelative  = 0x0100,
434         FNonNeg    = 0x0200
435     };
436
437     friend inline Units operator|(Units a, Units b)
438     {
439         return static_cast<Units>(static_cast<unsigned>(a) | static_cast<unsigned>(b));
440     }
441
442     bool validCalculationUnit(CSSParserValue*, Units);
443
444     bool shouldAcceptUnitLessValues(CSSParserValue*, Units, CSSParserMode);
445
446     inline bool validUnit(CSSParserValue* value, Units unitflags) { return validUnit(value, unitflags, m_context.mode); }
447     bool validUnit(CSSParserValue*, Units, CSSParserMode);
448
449     bool parseBorderImageQuad(Units, RefPtr<CSSPrimitiveValue>&);
450     int colorIntFromValue(CSSParserValue*);
451
452     enum ReleaseParsedCalcValueCondition {
453         ReleaseParsedCalcValue,
454         DoNotReleaseParsedCalcValue
455     };    
456     double parsedDouble(CSSParserValue*, ReleaseParsedCalcValueCondition releaseCalc = DoNotReleaseParsedCalcValue);
457     bool isCalculation(CSSParserValue*);
458     
459     friend class TransformOperationInfo;
460 #if ENABLE(CSS_FILTERS)
461     friend class FilterOperationInfo;
462 #endif
463 };
464
465 CSSPropertyID cssPropertyID(const CSSParserString&);
466 CSSPropertyID cssPropertyID(const String&);
467 int cssValueKeywordID(const CSSParserString&);
468 #if PLATFORM(IOS)
469 void cssPropertyNameIOSAliasing(const char* propertyName, const char*& propertyNameAlias, unsigned& newLength);
470 #endif
471
472 class ShorthandScope {
473     WTF_MAKE_FAST_ALLOCATED;
474 public:
475     ShorthandScope(CSSParser* parser, CSSPropertyID propId) : m_parser(parser)
476     {
477         if (!(m_parser->m_inParseShorthand++))
478             m_parser->m_currentShorthand = propId;
479     }
480     ~ShorthandScope()
481     {
482         if (!(--m_parser->m_inParseShorthand))
483             m_parser->m_currentShorthand = CSSPropertyInvalid;
484     }
485
486 private:
487     CSSParser* m_parser;
488 };
489
490 String quoteCSSString(const String&);
491 String quoteCSSStringIfNeeded(const String&);
492 String quoteCSSURLIfNeeded(const String&);
493
494 bool isValidNthToken(const CSSParserString&);
495 } // namespace WebCore
496
497 #endif // CSSParser_h