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