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