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