Improve r136754 by hardening checks of expected values for background-position.
[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 CSSSelectorList;
51 class CSSValue;
52 class CSSValueList;
53 class CSSBasicShape;
54 class Document;
55 class Element;
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 StyleSheetContents;
65 class StyledElement;
66
67 #if ENABLE(CSS_SHADERS)
68 class WebKitCSSArrayFunctionValue;
69 class WebKitCSSMixFunctionValue;
70 #endif
71
72 class CSSParser {
73     friend inline int cssyylex(void*, CSSParser*);
74
75 public:
76     CSSParser(const CSSParserContext&);
77
78     ~CSSParser();
79
80     void parseSheet(StyleSheetContents*, const String&, int startLineNumber = 0, RuleSourceDataList* = 0);
81     PassRefPtr<StyleRuleBase> parseRule(StyleSheetContents*, const String&);
82     PassRefPtr<StyleKeyframe> parseKeyframeRule(StyleSheetContents*, const String&);
83     static bool parseValue(StylePropertySet*, CSSPropertyID, const String&, bool important, CSSParserMode, StyleSheetContents*);
84     static bool parseColor(RGBA32& color, const String&, bool strict = false);
85     static bool parseSystemColor(RGBA32& color, const String&, Document*);
86     static PassRefPtr<CSSValueList> parseFontFaceValue(const AtomicString&);
87     PassRefPtr<CSSPrimitiveValue> parseValidPrimitive(int ident, CSSParserValue*);
88     bool parseDeclaration(StylePropertySet*, const String&, PassRefPtr<CSSRuleSourceData>, StyleSheetContents* contextStyleSheet);
89     static PassRefPtr<StylePropertySet> parseInlineStyleDeclaration(const String&, Element*);
90     PassOwnPtr<MediaQuery> parseMediaQuery(const String&);
91
92     void addProperty(CSSPropertyID, PassRefPtr<CSSValue>, bool important, bool implicit = false);
93     void rollbackLastProperties(int num);
94     bool hasProperties() const { return !m_parsedProperties.isEmpty(); }
95     void addExpandedPropertyForValue(CSSPropertyID propId, PassRefPtr<CSSValue>, bool);
96
97     bool parseValue(CSSPropertyID, bool important);
98     bool parseShorthand(CSSPropertyID, const StylePropertyShorthand&, bool important);
99     bool parse4Values(CSSPropertyID, const CSSPropertyID* properties, bool important);
100     bool parseContent(CSSPropertyID, bool important);
101     bool parseQuotes(CSSPropertyID, bool important);
102
103 #if ENABLE(CSS_VARIABLES)
104     static bool parseValue(StylePropertySet*, CSSPropertyID, const String&, bool important, Document*);
105     bool cssVariablesEnabled() const;
106     void storeVariableDeclaration(const CSSParserString&, PassOwnPtr<CSSParserValueList>, bool important);
107 #endif
108
109     PassRefPtr<CSSValue> parseAttr(CSSParserValueList* args);
110
111     PassRefPtr<CSSValue> parseBackgroundColor();
112
113     bool parseFillImage(CSSParserValueList*, RefPtr<CSSValue>&);
114
115     enum FillPositionFlag { InvalidFillPosition = 0, AmbiguousFillPosition = 1, XFillPosition = 2, YFillPosition = 4 };
116     enum FillPositionParsingMode { ResolveValuesAsPercent = 0, ResolveValuesAsKeyword = 1 };
117     PassRefPtr<CSSPrimitiveValue> parseFillPositionComponent(CSSParserValueList*, unsigned& cumulativeFlags, FillPositionFlag& individualFlag, FillPositionParsingMode = ResolveValuesAsPercent);
118     PassRefPtr<CSSValue> parseFillPositionX(CSSParserValueList*);
119     PassRefPtr<CSSValue> parseFillPositionY(CSSParserValueList*);
120     void parseFillPosition(CSSParserValueList*, RefPtr<CSSValue>&, RefPtr<CSSValue>&);
121 #if ENABLE(CSS3_BACKGROUND)
122     bool isPotentialPositionValue(CSSParserValue*);
123     void parseFillBackgroundPosition(CSSParserValueList*, RefPtr<CSSValue>&, RefPtr<CSSValue>&);
124     void parse3ValuesBackgroundPosition(CSSParserValueList*, RefPtr<CSSValue>&, RefPtr<CSSValue>&, PassRefPtr<CSSPrimitiveValue>, PassRefPtr<CSSPrimitiveValue>);
125     void parse4ValuesBackgroundPosition(CSSParserValueList*, RefPtr<CSSValue>&, RefPtr<CSSValue>&, PassRefPtr<CSSPrimitiveValue>, PassRefPtr<CSSPrimitiveValue>);
126 #endif
127
128     void parseFillRepeat(RefPtr<CSSValue>&, RefPtr<CSSValue>&);
129     PassRefPtr<CSSValue> parseFillSize(CSSPropertyID, bool &allowComma);
130
131     bool parseFillProperty(CSSPropertyID propId, CSSPropertyID& propId1, CSSPropertyID& propId2, RefPtr<CSSValue>&, RefPtr<CSSValue>&);
132     bool parseFillShorthand(CSSPropertyID, const CSSPropertyID* properties, int numProperties, bool important);
133
134     void addFillValue(RefPtr<CSSValue>& lval, PassRefPtr<CSSValue> rval);
135
136     void addAnimationValue(RefPtr<CSSValue>& lval, PassRefPtr<CSSValue> rval);
137
138     PassRefPtr<CSSValue> parseAnimationDelay();
139     PassRefPtr<CSSValue> parseAnimationDirection();
140     PassRefPtr<CSSValue> parseAnimationDuration();
141     PassRefPtr<CSSValue> parseAnimationFillMode();
142     PassRefPtr<CSSValue> parseAnimationIterationCount();
143     PassRefPtr<CSSValue> parseAnimationName();
144     PassRefPtr<CSSValue> parseAnimationPlayState();
145     PassRefPtr<CSSValue> parseAnimationProperty();
146     PassRefPtr<CSSValue> parseAnimationTimingFunction();
147
148     bool parseTransformOriginShorthand(RefPtr<CSSValue>&, RefPtr<CSSValue>&, RefPtr<CSSValue>&);
149     bool parseCubicBezierTimingFunctionValue(CSSParserValueList*& args, double& result);
150     bool parseAnimationProperty(CSSPropertyID, RefPtr<CSSValue>&);
151     bool parseTransitionShorthand(bool important);
152     bool parseAnimationShorthand(bool important);
153
154     bool cssGridLayoutEnabled() const;
155     bool parseGridTrackList(CSSPropertyID, bool important);
156     bool parseGridTrackGroup(CSSValueList*);
157     bool parseGridTrackMinMax(CSSValueList*);
158     PassRefPtr<CSSPrimitiveValue> parseGridBreadth(CSSParserValue*);
159
160     bool parseDashboardRegions(CSSPropertyID, bool important);
161
162     bool parseClipShape(CSSPropertyID, bool important);
163
164     bool parseBasicShape(CSSPropertyID, bool important);
165     PassRefPtr<CSSBasicShape> parseBasicShapeRectangle(CSSParserValueList* args);
166     PassRefPtr<CSSBasicShape> parseBasicShapeCircle(CSSParserValueList* args);
167     PassRefPtr<CSSBasicShape> parseBasicShapeEllipse(CSSParserValueList* args);
168     PassRefPtr<CSSBasicShape> parseBasicShapePolygon(CSSParserValueList* args);
169
170     bool parseFont(bool important);
171     PassRefPtr<CSSValueList> parseFontFamily();
172
173     bool parseCounter(CSSPropertyID, int defaultValue, bool important);
174     PassRefPtr<CSSValue> parseCounterContent(CSSParserValueList* args, bool counters);
175
176     bool parseColorParameters(CSSParserValue*, int* colorValues, bool parseAlpha);
177     bool parseHSLParameters(CSSParserValue*, double* colorValues, bool parseAlpha);
178     PassRefPtr<CSSPrimitiveValue> parseColor(CSSParserValue* = 0);
179     bool parseColorFromValue(CSSParserValue*, RGBA32&);
180     void parseSelector(const String&, CSSSelectorList&);
181
182     static bool fastParseColor(RGBA32&, const String&, bool strict);
183
184     bool parseLineHeight(bool important);
185     bool parseFontSize(bool important);
186     bool parseFontVariant(bool important);
187     bool parseFontWeight(bool important);
188     bool parseFontFaceSrc();
189     bool parseFontFaceUnicodeRange();
190
191 #if ENABLE(SVG)
192     bool parseSVGValue(CSSPropertyID propId, bool important);
193     PassRefPtr<CSSValue> parseSVGPaint();
194     PassRefPtr<CSSValue> parseSVGColor();
195     PassRefPtr<CSSValue> parseSVGStrokeDasharray();
196 #endif
197
198     // CSS3 Parsing Routines (for properties specific to CSS3)
199     PassRefPtr<CSSValueList> parseShadow(CSSParserValueList*, CSSPropertyID);
200     bool parseBorderImage(CSSPropertyID, RefPtr<CSSValue>&, bool important = false);
201     bool parseBorderImageRepeat(RefPtr<CSSValue>&);
202     bool parseBorderImageSlice(CSSPropertyID, RefPtr<CSSBorderImageSliceValue>&);
203     bool parseBorderImageWidth(RefPtr<CSSPrimitiveValue>&);
204     bool parseBorderImageOutset(RefPtr<CSSPrimitiveValue>&);
205     bool parseBorderRadius(CSSPropertyID, bool important);
206
207     bool parseAspectRatio(bool important);
208
209     bool parseReflect(CSSPropertyID, bool important);
210
211     bool parseFlex(CSSParserValueList* args, bool important);
212
213     // Image generators
214     bool parseCanvas(CSSParserValueList*, RefPtr<CSSValue>&);
215
216     bool parseDeprecatedGradient(CSSParserValueList*, RefPtr<CSSValue>&);
217     bool parseLinearGradient(CSSParserValueList*, RefPtr<CSSValue>&, CSSGradientRepeat repeating);
218     bool parseRadialGradient(CSSParserValueList*, RefPtr<CSSValue>&, CSSGradientRepeat repeating);
219     bool parseGradientColorStops(CSSParserValueList*, CSSGradientValue*, bool expectComma);
220
221     bool parseCrossfade(CSSParserValueList*, RefPtr<CSSValue>&);
222
223 #if ENABLE(CSS_IMAGE_RESOLUTION)
224     PassRefPtr<CSSValue> parseImageResolution(CSSParserValueList*);
225 #endif
226
227 #if ENABLE(CSS_IMAGE_SET)
228     PassRefPtr<CSSValue> parseImageSet(CSSParserValueList*);
229 #endif
230
231 #if ENABLE(CSS_FILTERS)
232     PassRefPtr<CSSValueList> parseFilter();
233     PassRefPtr<WebKitCSSFilterValue> parseBuiltinFilterArguments(CSSParserValueList*, WebKitCSSFilterValue::FilterOperationType);
234 #if ENABLE(CSS_SHADERS)
235     PassRefPtr<WebKitCSSArrayFunctionValue> parseCustomFilterArrayFunction(CSSParserValue*);
236     PassRefPtr<WebKitCSSMixFunctionValue> parseMixFunction(CSSParserValue*);
237     PassRefPtr<WebKitCSSFilterValue> parseCustomFilter(CSSParserValue*);
238     PassRefPtr<CSSValueList> parseCustomFilterTransform(CSSParserValueList*);
239 #endif
240 #endif
241
242     static bool isBlendMode(int ident);
243     static bool isCompositeOperator(int ident);
244
245     PassRefPtr<CSSValueList> parseTransform();
246     PassRefPtr<CSSValue> parseTransformValue(CSSParserValue*);
247     bool parseTransformOrigin(CSSPropertyID propId, CSSPropertyID& propId1, CSSPropertyID& propId2, CSSPropertyID& propId3, RefPtr<CSSValue>&, RefPtr<CSSValue>&, RefPtr<CSSValue>&);
248     bool parsePerspectiveOrigin(CSSPropertyID propId, CSSPropertyID& propId1, CSSPropertyID& propId2,  RefPtr<CSSValue>&, RefPtr<CSSValue>&);
249
250     bool parseTextEmphasisStyle(bool important);
251
252     void addTextDecorationProperty(CSSPropertyID, PassRefPtr<CSSValue>, bool important);
253     bool parseTextDecoration(CSSPropertyID propId, bool important);
254
255     bool parseLineBoxContain(bool important);
256     bool parseCalculation(CSSParserValue*, CalculationPermittedValueRange);
257
258     bool parseFontFeatureTag(CSSValueList*);
259     bool parseFontFeatureSettings(bool important);
260
261     bool cssRegionsEnabled() const;
262     bool parseFlowThread(const String& flowName);
263     bool parseFlowThread(CSSPropertyID, bool important);
264     bool parseRegionThread(CSSPropertyID, bool important);
265
266     bool parseFontVariantLigatures(bool important);
267
268     CSSParserSelector* createFloatingSelector();
269     PassOwnPtr<CSSParserSelector> sinkFloatingSelector(CSSParserSelector*);
270
271     Vector<OwnPtr<CSSParserSelector> >* createFloatingSelectorVector();
272     PassOwnPtr<Vector<OwnPtr<CSSParserSelector> > > sinkFloatingSelectorVector(Vector<OwnPtr<CSSParserSelector> >*);
273
274     CSSParserValueList* createFloatingValueList();
275     PassOwnPtr<CSSParserValueList> sinkFloatingValueList(CSSParserValueList*);
276
277     CSSParserFunction* createFloatingFunction();
278     PassOwnPtr<CSSParserFunction> sinkFloatingFunction(CSSParserFunction*);
279
280     CSSParserValue& sinkFloatingValue(CSSParserValue&);
281
282     MediaQuerySet* createMediaQuerySet();
283     StyleRuleBase* createImportRule(const CSSParserString&, MediaQuerySet*);
284     StyleKeyframe* createKeyframe(CSSParserValueList*);
285     StyleRuleKeyframes* createKeyframesRule(const String&, PassOwnPtr<Vector<RefPtr<StyleKeyframe> > >);
286
287     typedef Vector<RefPtr<StyleRuleBase> > RuleList;
288     StyleRuleBase* createMediaRule(MediaQuerySet*, RuleList*);
289     RuleList* createRuleList();
290     StyleRuleBase* createStyleRule(Vector<OwnPtr<CSSParserSelector> >* selectors);
291     StyleRuleBase* createFontFaceRule();
292     StyleRuleBase* createPageRule(PassOwnPtr<CSSParserSelector> pageSelector);
293     StyleRuleBase* createRegionRule(Vector<OwnPtr<CSSParserSelector> >* regionSelector, RuleList* rules);
294     StyleRuleBase* createMarginAtRule(CSSSelector::MarginBoxType);
295 #if ENABLE(SHADOW_DOM)
296     StyleRuleBase* createHostRule(RuleList* rules);
297 #endif
298     void startDeclarationsForMarginBox();
299     void endDeclarationsForMarginBox();
300
301     MediaQueryExp* createFloatingMediaQueryExp(const AtomicString&, CSSParserValueList*);
302     PassOwnPtr<MediaQueryExp> sinkFloatingMediaQueryExp(MediaQueryExp*);
303     Vector<OwnPtr<MediaQueryExp> >* createFloatingMediaQueryExpList();
304     PassOwnPtr<Vector<OwnPtr<MediaQueryExp> > > sinkFloatingMediaQueryExpList(Vector<OwnPtr<MediaQueryExp> >*);
305     MediaQuery* createFloatingMediaQuery(MediaQuery::Restrictor, const String&, PassOwnPtr<Vector<OwnPtr<MediaQueryExp> > >);
306     MediaQuery* createFloatingMediaQuery(PassOwnPtr<Vector<OwnPtr<MediaQueryExp> > >);
307     PassOwnPtr<MediaQuery> sinkFloatingMediaQuery(MediaQuery*);
308
309     Vector<RefPtr<StyleKeyframe> >* createFloatingKeyframeVector();
310     PassOwnPtr<Vector<RefPtr<StyleKeyframe> > > sinkFloatingKeyframeVector(Vector<RefPtr<StyleKeyframe> >*);
311
312     void addNamespace(const AtomicString& prefix, const AtomicString& uri);
313     QualifiedName determineNameInNamespace(const AtomicString& prefix, const AtomicString& localName);
314     void updateSpecifiersWithElementName(const AtomicString& namespacePrefix, const AtomicString& elementName, CSSParserSelector*);
315     CSSParserSelector* updateSpecifiers(CSSParserSelector*, CSSParserSelector*);
316
317     void invalidBlockHit();
318
319     Vector<OwnPtr<CSSParserSelector> >* reusableSelectorVector() { return &m_reusableSelectorVector; }
320
321     void setReusableRegionSelectorVector(Vector<OwnPtr<CSSParserSelector> >* selectors);
322     Vector<OwnPtr<CSSParserSelector> >* reusableRegionSelectorVector() { return &m_reusableRegionSelectorVector; }
323
324     void updateLastSelectorLineAndPosition();
325     void updateLastMediaLine(MediaQuerySet*);
326
327     void clearProperties();
328
329     PassRefPtr<StylePropertySet> createStylePropertySet();
330
331     CSSParserContext m_context;
332
333     bool m_important;
334     CSSPropertyID m_id;
335     StyleSheetContents* m_styleSheet;
336     RefPtr<StyleRuleBase> m_rule;
337     RefPtr<StyleKeyframe> m_keyframe;
338     OwnPtr<MediaQuery> m_mediaQuery;
339     OwnPtr<CSSParserValueList> m_valueList;
340     typedef Vector<CSSProperty, 256> ParsedPropertyVector;
341     ParsedPropertyVector m_parsedProperties;
342     CSSSelectorList* m_selectorListForParseSelector;
343
344     unsigned m_numParsedPropertiesBeforeMarginBox;
345
346     int m_inParseShorthand;
347     CSSPropertyID m_currentShorthand;
348     bool m_implicitShorthand;
349
350     bool m_hasFontFaceOnlyValues;
351     bool m_hadSyntacticallyValidCSSRule;
352
353     AtomicString m_defaultNamespace;
354
355     // tokenizer methods and data
356     size_t m_parsedTextPrefixLength;
357     SourceRange m_selectorRange;
358     SourceRange m_propertyRange;
359     OwnPtr<RuleSourceDataList> m_currentRuleDataStack;
360     RefPtr<CSSRuleSourceData> m_currentRuleData;
361     RuleSourceDataList* m_ruleSourceDataResult;
362
363     void fixUnparsedPropertyRanges(CSSRuleSourceData*);
364     void markRuleHeaderStart(CSSRuleSourceData::Type);
365     void markRuleHeaderEnd();
366     void markSelectorStart();
367     void markSelectorEnd();
368     void markRuleBodyStart();
369     void markRuleBodyEnd();
370     void markPropertyStart();
371     void markPropertyEnd(bool isImportantFound, bool isPropertyParsed);
372     void processAndAddNewRuleToSourceTreeIfNeeded();
373     void addNewRuleToSourceTree(PassRefPtr<CSSRuleSourceData>);
374     PassRefPtr<CSSRuleSourceData> popRuleData();
375     void resetPropertyRange() { m_propertyRange.start = m_propertyRange.end = UINT_MAX; }
376     bool isExtractingSourceData() const { return !!m_currentRuleDataStack; }
377
378     inline int lex(void* yylval) { return (this->*m_lexFunc)(yylval); }
379
380     int token() { return m_token; }
381
382 #if ENABLE(CSS_DEVICE_ADAPTATION)
383     void markViewportRuleBodyStart() { m_inViewport = true; }
384     void markViewportRuleBodyEnd() { m_inViewport = false; }
385     StyleRuleBase* createViewportRule();
386 #endif
387
388     PassRefPtr<CSSPrimitiveValue> createPrimitiveNumericValue(CSSParserValue*);
389     PassRefPtr<CSSPrimitiveValue> createPrimitiveStringValue(CSSParserValue*);
390 #if ENABLE(CSS_VARIABLES)
391     PassRefPtr<CSSPrimitiveValue> createPrimitiveVariableNameValue(CSSParserValue*);
392 #endif
393
394     static KURL completeURL(const CSSParserContext&, const String& url);
395
396 private:
397     bool is8BitSource() { return m_is8BitSource; }
398
399     template <typename SourceCharacterType>
400     int realLex(void* yylval);
401
402     UChar*& currentCharacter16();
403
404     template <typename CharacterType>
405     inline CharacterType*& currentCharacter();
406
407     template <typename CharacterType>
408     inline CharacterType* tokenStart();
409
410     template <typename CharacterType>
411     inline void setTokenStart(CharacterType*);
412
413     inline unsigned tokenStartOffset();
414     inline UChar tokenStartChar();
415
416     template <typename CharacterType>
417     inline bool isIdentifierStart();
418
419     template <typename CharacterType>
420     static inline CharacterType* checkAndSkipString(CharacterType*, int);
421
422     template <typename CharacterType>
423     unsigned parseEscape(CharacterType*&);
424     template <typename DestCharacterType>
425     inline void UnicodeToChars(DestCharacterType*&, unsigned);
426     template <typename SrcCharacterType, typename DestCharacterType>
427     inline bool parseIdentifierInternal(SrcCharacterType*&, DestCharacterType*&, bool&);
428
429     template <typename CharacterType>
430     inline void parseIdentifier(CharacterType*&, CSSParserString&, bool&);
431
432     template <typename SrcCharacterType, typename DestCharacterType>
433     inline bool parseStringInternal(SrcCharacterType*&, DestCharacterType*&, UChar);
434
435     template <typename CharacterType>
436     inline void parseString(CharacterType*&, CSSParserString& resultString, UChar);
437
438     template <typename CharacterType>
439     inline bool parseURIInternal(CharacterType*&, CharacterType*&);
440
441     template <typename CharacterType>
442     inline void parseURI(CSSParserString&);
443     template <typename CharacterType>
444     inline bool parseUnicodeRange();
445     template <typename CharacterType>
446     bool parseNthChild();
447     template <typename CharacterType>
448     bool parseNthChildExtra();
449     template <typename CharacterType>
450     inline void detectFunctionTypeToken(int);
451     template <typename CharacterType>
452     inline void detectMediaQueryToken(int);
453     template <typename CharacterType>
454     inline void detectNumberToken(CharacterType*, int);
455     template <typename CharacterType>
456     inline void detectDashToken(int);
457     template <typename CharacterType>
458     inline void detectAtToken(int, bool);
459 #if ENABLE(CSS3_CONDITIONAL_RULES)
460     template <typename CharacterType>
461     inline void detectSupportsToken(int);
462 #endif
463
464     template <typename CharacterType>
465     inline void setRuleHeaderEnd(const CharacterType*);
466
467     void setStyleSheet(StyleSheetContents* styleSheet) { m_styleSheet = styleSheet; }
468
469     inline bool inStrictMode() const { return m_context.mode == CSSStrictMode || m_context.mode == SVGAttributeMode; }
470     inline bool inQuirksMode() const { return m_context.mode == CSSQuirksMode; }
471     
472     KURL completeURL(const String& url) const;
473
474     void recheckAtKeyword(const UChar* str, int len);
475
476     template<unsigned prefixLength, unsigned suffixLength>
477     inline void setupParser(const char (&prefix)[prefixLength], const String& string, const char (&suffix)[suffixLength])
478     {
479         setupParser(prefix, prefixLength - 1, string, suffix, suffixLength - 1);
480     }
481     void setupParser(const char* prefix, unsigned prefixLength, const String&, const char* suffix, unsigned suffixLength);
482     bool inShorthand() const { return m_inParseShorthand; }
483
484     bool validWidth(CSSParserValue*);
485     bool validHeight(CSSParserValue*);
486
487     void deleteFontFaceOnlyValues();
488
489     bool isGeneratedImageValue(CSSParserValue*) const;
490     bool parseGeneratedImage(CSSParserValueList*, RefPtr<CSSValue>&);
491
492     bool parseValue(StylePropertySet*, CSSPropertyID, const String&, bool important, StyleSheetContents* contextStyleSheet);
493     PassRefPtr<StylePropertySet> parseDeclaration(const String&, StyleSheetContents* contextStyleSheet);
494
495     enum SizeParameterType {
496         None,
497         Auto,
498         Length,
499         PageSize,
500         Orientation,
501     };
502
503     bool parsePage(CSSPropertyID propId, bool important);
504     bool parseSize(CSSPropertyID propId, bool important);
505     SizeParameterType parseSizeParameter(CSSValueList* parsedValues, CSSParserValue* value, SizeParameterType prevParamType);
506
507     bool parseFontFaceSrcURI(CSSValueList*);
508     bool parseFontFaceSrcLocal(CSSValueList*);
509
510     bool parseColor(const String&);
511
512     enum ParsingMode {
513         NormalMode,
514         MediaQueryMode,
515 #if ENABLE(CSS3_CONDITIONAL_RULES)
516         SupportsMode,
517 #endif
518         NthChildMode
519     };
520
521     ParsingMode m_parsingMode;
522     bool m_is8BitSource;
523     OwnArrayPtr<LChar> m_dataStart8;
524     OwnArrayPtr<UChar> m_dataStart16;
525     LChar* m_currentCharacter8;
526     UChar* m_currentCharacter16;
527     union {
528         LChar* ptr8;
529         UChar* ptr16;
530     } m_tokenStart;
531     unsigned m_length;
532     int m_token;
533     int m_lineNumber;
534     int m_lastSelectorLineNumber;
535
536     bool m_allowImportRules;
537     bool m_allowNamespaceDeclarations;
538
539 #if ENABLE(CSS_DEVICE_ADAPTATION)
540     bool parseViewportProperty(CSSPropertyID propId, bool important);
541     bool parseViewportShorthand(CSSPropertyID propId, CSSPropertyID first, CSSPropertyID second, bool important);
542
543     bool inViewport() const { return m_inViewport; }
544     bool m_inViewport;
545 #endif
546
547     int (CSSParser::*m_lexFunc)(void*);
548
549     Vector<RefPtr<StyleRuleBase> > m_parsedRules;
550     Vector<RefPtr<StyleKeyframe> > m_parsedKeyframes;
551     Vector<RefPtr<MediaQuerySet> > m_parsedMediaQuerySets;
552     Vector<OwnPtr<RuleList> > m_parsedRuleLists;
553     HashSet<CSSParserSelector*> m_floatingSelectors;
554     HashSet<Vector<OwnPtr<CSSParserSelector> >*> m_floatingSelectorVectors;
555     HashSet<CSSParserValueList*> m_floatingValueLists;
556     HashSet<CSSParserFunction*> m_floatingFunctions;
557
558     OwnPtr<MediaQuery> m_floatingMediaQuery;
559     OwnPtr<MediaQueryExp> m_floatingMediaQueryExp;
560     OwnPtr<Vector<OwnPtr<MediaQueryExp> > > m_floatingMediaQueryExpList;
561
562     OwnPtr<Vector<RefPtr<StyleKeyframe> > > m_floatingKeyframeVector;
563
564     Vector<OwnPtr<CSSParserSelector> > m_reusableSelectorVector;
565     Vector<OwnPtr<CSSParserSelector> > m_reusableRegionSelectorVector;
566
567     RefPtr<CSSCalcValue> m_parsedCalculation;
568
569     // defines units allowed for a certain property, used in parseUnit
570     enum Units {
571         FUnknown = 0x0000,
572         FInteger = 0x0001,
573         FNumber = 0x0002, // Real Numbers
574         FPercent = 0x0004,
575         FLength = 0x0008,
576         FAngle = 0x0010,
577         FTime = 0x0020,
578         FFrequency = 0x0040,
579         FPositiveInteger = 0x0080,
580         FRelative = 0x0100,
581 #if ENABLE(CSS_IMAGE_RESOLUTION) || ENABLE(RESOLUTION_MEDIA_QUERY)
582         FResolution = 0x0200,
583 #endif
584         FNonNeg = 0x0400
585     };
586
587     friend inline Units operator|(Units a, Units b)
588     {
589         return static_cast<Units>(static_cast<unsigned>(a) | static_cast<unsigned>(b));
590     }
591
592     enum ReleaseParsedCalcValueCondition {
593         ReleaseParsedCalcValue,
594         DoNotReleaseParsedCalcValue
595     };
596
597     bool validCalculationUnit(CSSParserValue*, Units, ReleaseParsedCalcValueCondition releaseCalc = DoNotReleaseParsedCalcValue);
598
599     bool shouldAcceptUnitLessValues(CSSParserValue*, Units, CSSParserMode);
600
601     inline bool validUnit(CSSParserValue* value, Units unitflags, ReleaseParsedCalcValueCondition releaseCalc = DoNotReleaseParsedCalcValue) { return validUnit(value, unitflags, m_context.mode, releaseCalc); }
602     bool validUnit(CSSParserValue*, Units, CSSParserMode, ReleaseParsedCalcValueCondition releaseCalc = DoNotReleaseParsedCalcValue);
603
604     bool parseBorderImageQuad(Units, RefPtr<CSSPrimitiveValue>&);
605     int colorIntFromValue(CSSParserValue*);
606     double parsedDouble(CSSParserValue*, ReleaseParsedCalcValueCondition releaseCalc = DoNotReleaseParsedCalcValue);
607     bool isCalculation(CSSParserValue*);
608     
609     friend class TransformOperationInfo;
610 #if ENABLE(CSS_FILTERS)
611     friend class FilterOperationInfo;
612 #endif
613 };
614
615 CSSPropertyID cssPropertyID(const CSSParserString&);
616 CSSPropertyID cssPropertyID(const String&);
617 int cssValueKeywordID(const CSSParserString&);
618 #if PLATFORM(IOS)
619 void cssPropertyNameIOSAliasing(const char* propertyName, const char*& propertyNameAlias, unsigned& newLength);
620 #endif
621
622 class ShorthandScope {
623     WTF_MAKE_FAST_ALLOCATED;
624 public:
625     ShorthandScope(CSSParser* parser, CSSPropertyID propId) : m_parser(parser)
626     {
627         if (!(m_parser->m_inParseShorthand++))
628             m_parser->m_currentShorthand = propId;
629     }
630     ~ShorthandScope()
631     {
632         if (!(--m_parser->m_inParseShorthand))
633             m_parser->m_currentShorthand = CSSPropertyInvalid;
634     }
635
636 private:
637     CSSParser* m_parser;
638 };
639
640 String quoteCSSString(const String&);
641 String quoteCSSStringIfNeeded(const String&);
642 String quoteCSSURLIfNeeded(const String&);
643
644 bool isValidNthToken(const CSSParserString&);
645
646 template <>
647 inline void CSSParser::setTokenStart<LChar>(LChar* tokenStart)
648 {
649     m_tokenStart.ptr8 = tokenStart;
650 }
651
652 template <>
653 inline void CSSParser::setTokenStart<UChar>(UChar* tokenStart)
654 {
655     m_tokenStart.ptr16 = tokenStart;
656 }
657
658 inline unsigned CSSParser::tokenStartOffset()
659 {
660     if (is8BitSource())
661         return m_tokenStart.ptr8 - m_dataStart8.get();
662     return m_tokenStart.ptr16 - m_dataStart16.get();
663 }
664
665 inline UChar CSSParser::tokenStartChar()
666 {
667     if (is8BitSource())
668         return *m_tokenStart.ptr8;
669     return *m_tokenStart.ptr16;
670 }
671
672 inline int cssyylex(void* yylval, CSSParser* parser)
673 {
674     return parser->lex(yylval);
675 }
676
677 } // namespace WebCore
678
679 #endif // CSSParser_h