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