https://bugs.webkit.org/show_bug.cgi?id=80322
[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 "CSSParserValues.h"
29 #include "CSSProperty.h"
30 #include "CSSPropertySourceData.h"
31 #include "CSSSelector.h"
32 #include "Color.h"
33 #include "MediaQuery.h"
34 #include <wtf/HashMap.h>
35 #include <wtf/HashSet.h>
36 #include <wtf/OwnArrayPtr.h>
37 #include <wtf/Vector.h>
38 #include <wtf/text/AtomicString.h>
39
40 #if ENABLE(CSS_FILTERS)
41 #include "WebKitCSSFilterValue.h"
42 #endif
43
44 namespace WebCore {
45
46 class CSSBorderImageSliceValue;
47 class CSSPrimitiveValue;
48 class CSSValuePool;
49 class CSSProperty;
50 class CSSRule;
51 class CSSRuleList;
52 class CSSSelectorList;
53 class CSSStyleSheet;
54 class CSSValue;
55 class CSSValueList;
56 class CSSWrapShape;
57 class Document;
58 class MediaList;
59 class MediaQueryExp;
60 class StylePropertySet;
61 class StyledElement;
62 class WebKitCSSKeyframeRule;
63 class WebKitCSSKeyframesRule;
64
65 class CSSParser {
66 public:
67     CSSParser(bool strictParsing = true);
68     ~CSSParser();
69
70     void parseSheet(CSSStyleSheet*, const String&, int startLineNumber = 0, StyleRuleRangeMap* ruleRangeMap = 0);
71     PassRefPtr<CSSRule> parseRule(CSSStyleSheet*, const String&);
72     PassRefPtr<WebKitCSSKeyframeRule> parseKeyframeRule(CSSStyleSheet*, const String&);
73     static bool parseValue(StylePropertySet*, int propId, const String&, bool important, bool strict, CSSStyleSheet* contextStyleSheet);
74     static bool parseColor(RGBA32& color, const String&, bool strict = false);
75     static bool parseSystemColor(RGBA32& color, const String&, Document*);
76     static PassRefPtr<CSSValueList> parseFontFaceValue(const AtomicString&, CSSStyleSheet* contextStyleSheet);
77     PassRefPtr<CSSPrimitiveValue> parseValidPrimitive(int propId, CSSParserValue*);
78     bool parseDeclaration(StylePropertySet*, const String&, RefPtr<CSSStyleSourceData>*, CSSStyleSheet* contextStyleSheet);
79     bool parseMediaQuery(MediaList*, const String&);
80
81     Document* findDocument() const;
82
83     CSSValuePool* cssValuePool() const { return m_cssValuePool.get(); }
84
85     void addProperty(int propId, PassRefPtr<CSSValue>, bool important, bool implicit = false);
86     void rollbackLastProperties(int num);
87     bool hasProperties() const { return !m_parsedProperties.isEmpty(); }
88
89     bool parseValue(int propId, bool important);
90     bool parseShorthand(int propId, const int* properties, int numProperties, bool important);
91     bool parse4Values(int propId, const int* properties, bool important);
92     bool parseContent(int propId, bool important);
93     bool parseQuotes(int propId, bool important);
94
95     PassRefPtr<CSSValue> parseAttr(CSSParserValueList* args);
96
97     PassRefPtr<CSSValue> parseBackgroundColor();
98
99     bool parseFillImage(CSSParserValueList*, RefPtr<CSSValue>&);
100
101     enum FillPositionFlag { InvalidFillPosition = 0, AmbiguousFillPosition = 1, XFillPosition = 2, YFillPosition = 4 };
102     PassRefPtr<CSSValue> parseFillPositionComponent(CSSParserValueList*, unsigned& cumulativeFlags, FillPositionFlag& individualFlag);
103     PassRefPtr<CSSValue> parseFillPositionX(CSSParserValueList*);
104     PassRefPtr<CSSValue> parseFillPositionY(CSSParserValueList*);
105     void parseFillPosition(CSSParserValueList*, RefPtr<CSSValue>&, RefPtr<CSSValue>&);
106
107     void parseFillRepeat(RefPtr<CSSValue>&, RefPtr<CSSValue>&);
108     PassRefPtr<CSSValue> parseFillSize(int propId, bool &allowComma);
109
110     bool parseFillProperty(int propId, int& propId1, int& propId2, RefPtr<CSSValue>&, RefPtr<CSSValue>&);
111     bool parseFillShorthand(int propId, const int* properties, int numProperties, bool important);
112
113     void addFillValue(RefPtr<CSSValue>& lval, PassRefPtr<CSSValue> rval);
114
115     void addAnimationValue(RefPtr<CSSValue>& lval, PassRefPtr<CSSValue> rval);
116
117     PassRefPtr<CSSValue> parseAnimationDelay();
118     PassRefPtr<CSSValue> parseAnimationDirection();
119     PassRefPtr<CSSValue> parseAnimationDuration();
120     PassRefPtr<CSSValue> parseAnimationFillMode();
121     PassRefPtr<CSSValue> parseAnimationIterationCount();
122     PassRefPtr<CSSValue> parseAnimationName();
123     PassRefPtr<CSSValue> parseAnimationPlayState();
124     PassRefPtr<CSSValue> parseAnimationProperty();
125     PassRefPtr<CSSValue> parseAnimationTimingFunction();
126
127     bool parseTransformOriginShorthand(RefPtr<CSSValue>&, RefPtr<CSSValue>&, RefPtr<CSSValue>&);
128     bool parseCubicBezierTimingFunctionValue(CSSParserValueList*& args, double& result);
129     bool parseAnimationProperty(int propId, RefPtr<CSSValue>&);
130     bool parseTransitionShorthand(bool important);
131     bool parseAnimationShorthand(bool important);
132
133 #if ENABLE(CSS_GRID_LAYOUT)
134     bool parseGridTrackList(int propId, bool important);
135 #endif
136
137     bool parseDashboardRegions(int propId, bool important);
138
139     bool parseShape(int propId, bool important);
140
141     bool parseWrapShape(bool shapeInside, bool important);
142     PassRefPtr<CSSWrapShape> parseWrapShapeRect(CSSParserValueList* args);
143     PassRefPtr<CSSWrapShape> parseWrapShapeCircle(CSSParserValueList* args);
144     PassRefPtr<CSSWrapShape> parseWrapShapeEllipse(CSSParserValueList* args);
145     PassRefPtr<CSSWrapShape> parseWrapShapePolygon(CSSParserValueList* args);
146
147     bool parseFont(bool important);
148     PassRefPtr<CSSValueList> parseFontFamily();
149
150     bool parseCounter(int propId, int defaultValue, bool important);
151     PassRefPtr<CSSValue> parseCounterContent(CSSParserValueList* args, bool counters);
152
153     bool parseColorParameters(CSSParserValue*, int* colorValues, bool parseAlpha);
154     bool parseHSLParameters(CSSParserValue*, double* colorValues, bool parseAlpha);
155     PassRefPtr<CSSPrimitiveValue> parseColor(CSSParserValue* = 0);
156     bool parseColorFromValue(CSSParserValue*, RGBA32&);
157     void parseSelector(const String&, Document* doc, CSSSelectorList&);
158
159     static bool fastParseColor(RGBA32&, const String&, bool strict);
160
161     bool parseFontVariant(bool important);
162     bool parseFontWeight(bool important);
163     bool parseFontFaceSrc();
164     bool parseFontFaceUnicodeRange();
165
166 #if ENABLE(SVG)
167     bool parseSVGValue(int propId, bool important);
168     PassRefPtr<CSSValue> parseSVGPaint();
169     PassRefPtr<CSSValue> parseSVGColor();
170     PassRefPtr<CSSValue> parseSVGStrokeDasharray();
171 #endif
172
173     // CSS3 Parsing Routines (for properties specific to CSS3)
174     PassRefPtr<CSSValueList> parseShadow(CSSParserValueList*, int propId);
175     bool parseBorderImage(int propId, RefPtr<CSSValue>&, bool important = false);
176     bool parseBorderImageRepeat(RefPtr<CSSValue>&);
177     bool parseBorderImageSlice(int propId, RefPtr<CSSBorderImageSliceValue>&);
178     bool parseBorderImageWidth(RefPtr<CSSPrimitiveValue>&);
179     bool parseBorderImageOutset(RefPtr<CSSPrimitiveValue>&);
180     bool parseBorderRadius(int propId, bool important);
181
182     bool parseAspectRatio(bool important);
183
184     bool parseReflect(int propId, bool important);
185
186     bool parseFlex(int propId, bool important);
187
188     // Image generators
189     bool parseCanvas(CSSParserValueList*, RefPtr<CSSValue>&);
190
191     bool parseDeprecatedGradient(CSSParserValueList*, RefPtr<CSSValue>&);
192     bool parseLinearGradient(CSSParserValueList*, RefPtr<CSSValue>&, CSSGradientRepeat repeating);
193     bool parseRadialGradient(CSSParserValueList*, RefPtr<CSSValue>&, CSSGradientRepeat repeating);
194     bool parseGradientColorStops(CSSParserValueList*, CSSGradientValue*, bool expectComma);
195
196     bool parseCrossfade(CSSParserValueList*, RefPtr<CSSValue>&);
197
198 #if ENABLE(CSS_IMAGE_SET)
199     PassRefPtr<CSSValue> parseImageSet(CSSParserValueList*);
200 #endif
201
202 #if ENABLE(CSS_FILTERS)
203     PassRefPtr<CSSValueList> parseFilter();
204     PassRefPtr<WebKitCSSFilterValue> parseBuiltinFilterArguments(CSSParserValueList*, WebKitCSSFilterValue::FilterOperationType);
205 #if ENABLE(CSS_SHADERS)
206     PassRefPtr<WebKitCSSFilterValue> parseCustomFilter(CSSParserValue*);
207 #endif
208 #endif
209
210     PassRefPtr<CSSValueList> parseTransform();
211     bool parseTransformOrigin(int propId, int& propId1, int& propId2, int& propId3, RefPtr<CSSValue>&, RefPtr<CSSValue>&, RefPtr<CSSValue>&);
212     bool parsePerspectiveOrigin(int propId, int& propId1, int& propId2,  RefPtr<CSSValue>&, RefPtr<CSSValue>&);
213
214     bool parseTextEmphasisStyle(bool important);
215
216     bool parseLineBoxContain(bool important);
217     bool parseCalculation(CSSParserValue*, CalculationPermittedValueRange);
218
219     bool parseFontFeatureTag(CSSValueList*);
220     bool parseFontFeatureSettings(bool important);
221
222     bool cssRegionsEnabled() const;
223     bool parseFlowThread(const String& flowName, Document*);
224     bool parseFlowThread(int propId, bool important);
225     bool parseRegionThread(int propId, bool important);
226
227     bool parseFontVariantLigatures(bool important);
228
229     int yyparse();
230
231     CSSParserSelector* createFloatingSelector();
232     PassOwnPtr<CSSParserSelector> sinkFloatingSelector(CSSParserSelector*);
233
234     Vector<OwnPtr<CSSParserSelector> >* createFloatingSelectorVector();
235     PassOwnPtr<Vector<OwnPtr<CSSParserSelector> > > sinkFloatingSelectorVector(Vector<OwnPtr<CSSParserSelector> >*);
236
237     CSSParserValueList* createFloatingValueList();
238     PassOwnPtr<CSSParserValueList> sinkFloatingValueList(CSSParserValueList*);
239
240     CSSParserFunction* createFloatingFunction();
241     PassOwnPtr<CSSParserFunction> sinkFloatingFunction(CSSParserFunction*);
242
243     CSSParserValue& sinkFloatingValue(CSSParserValue&);
244
245     MediaList* createMediaList();
246     CSSRule* createCharsetRule(const CSSParserString&);
247     CSSRule* createImportRule(const CSSParserString&, MediaList*);
248     WebKitCSSKeyframeRule* createKeyframeRule(CSSParserValueList*);
249     WebKitCSSKeyframesRule* createKeyframesRule();
250     CSSRule* createMediaRule(MediaList*, CSSRuleList*);
251     CSSRuleList* createRuleList();
252     CSSRule* createStyleRule(Vector<OwnPtr<CSSParserSelector> >* selectors);
253     CSSRule* createFontFaceRule();
254     CSSRule* createPageRule(PassOwnPtr<CSSParserSelector> pageSelector);
255     CSSRule* createRegionRule(Vector<OwnPtr<CSSParserSelector> >* regionSelector, CSSRuleList* rules);
256     CSSRule* createMarginAtRule(CSSSelector::MarginBoxType marginBox);
257     void startDeclarationsForMarginBox();
258     void endDeclarationsForMarginBox();
259
260     MediaQueryExp* createFloatingMediaQueryExp(const AtomicString&, CSSParserValueList*);
261     PassOwnPtr<MediaQueryExp> sinkFloatingMediaQueryExp(MediaQueryExp*);
262     Vector<OwnPtr<MediaQueryExp> >* createFloatingMediaQueryExpList();
263     PassOwnPtr<Vector<OwnPtr<MediaQueryExp> > > sinkFloatingMediaQueryExpList(Vector<OwnPtr<MediaQueryExp> >*);
264     MediaQuery* createFloatingMediaQuery(MediaQuery::Restrictor, const String&, PassOwnPtr<Vector<OwnPtr<MediaQueryExp> > >);
265     MediaQuery* createFloatingMediaQuery(PassOwnPtr<Vector<OwnPtr<MediaQueryExp> > >);
266     PassOwnPtr<MediaQuery> sinkFloatingMediaQuery(MediaQuery*);
267
268     void addNamespace(const AtomicString& prefix, const AtomicString& uri);
269     void updateSpecifiersWithElementName(const AtomicString& namespacePrefix, const AtomicString& elementName, CSSParserSelector*);
270     CSSParserSelector* updateSpecifiers(CSSParserSelector*, CSSParserSelector*);
271
272     void invalidBlockHit();
273
274     Vector<OwnPtr<CSSParserSelector> >* reusableSelectorVector() { return &m_reusableSelectorVector; }
275
276     void setReusableRegionSelectorVector(Vector<OwnPtr<CSSParserSelector> >* selectors);
277     Vector<OwnPtr<CSSParserSelector> >* reusableRegionSelectorVector() { return &m_reusableRegionSelectorVector; }
278
279     void updateLastSelectorLineAndPosition();
280     void updateLastMediaLine(MediaList*);
281
282     void clearProperties();
283
284     bool m_strict;
285     bool m_important;
286     int m_id;
287     CSSStyleSheet* m_styleSheet;
288     RefPtr<CSSRule> m_rule;
289     RefPtr<WebKitCSSKeyframeRule> m_keyframe;
290     OwnPtr<MediaQuery> m_mediaQuery;
291     OwnPtr<CSSParserValueList> m_valueList;
292     Vector<CSSProperty, 256> m_parsedProperties;
293     CSSSelectorList* m_selectorListForParseSelector;
294
295     RefPtr<CSSValuePool> m_cssValuePool;
296     unsigned m_numParsedPropertiesBeforeMarginBox;
297
298     int m_inParseShorthand;
299     int m_currentShorthand;
300     bool m_implicitShorthand;
301
302     bool m_hasFontFaceOnlyValues;
303     bool m_hadSyntacticallyValidCSSRule;
304
305     AtomicString m_defaultNamespace;
306
307     // tokenizer methods and data
308     bool m_inStyleRuleOrDeclaration;
309     SourceRange m_selectorListRange;
310     SourceRange m_ruleBodyRange;
311     SourceRange m_propertyRange;
312     StyleRuleRangeMap* m_ruleRangeMap;
313     RefPtr<CSSRuleSourceData> m_currentRuleData;
314     void markSelectorListStart();
315     void markSelectorListEnd();
316     void markRuleBodyStart();
317     void markRuleBodyEnd();
318     void markPropertyStart();
319     void markPropertyEnd(bool isImportantFound, bool isPropertyParsed);
320     void resetSelectorListMarks() { m_selectorListRange.start = m_selectorListRange.end = 0; }
321     void resetRuleBodyMarks() { m_ruleBodyRange.start = m_ruleBodyRange.end = 0; }
322     void resetPropertyMarks() { m_propertyRange.start = m_propertyRange.end = UINT_MAX; }
323     int lex(void* yylval);
324     int token() { return m_token; }
325
326     PassRefPtr<CSSPrimitiveValue> createPrimitiveNumericValue(CSSParserValue*);
327     PassRefPtr<CSSPrimitiveValue> createPrimitiveStringValue(CSSParserValue*);
328         
329 private:
330     inline bool isIdentifierStart();
331
332     static inline UChar* checkAndSkipString(UChar*, UChar);
333
334     void parseEscape(UChar*&);
335     inline void parseIdentifier(UChar*&, bool&);
336     inline void parseString(UChar*&, UChar);
337     inline void parseURI(UChar*&, UChar*&);
338     inline bool parseUnicodeRange();
339     bool parseNthChild();
340     bool parseNthChildExtra();
341     inline void detectFunctionTypeToken(int);
342     inline void detectMediaQueryToken(int);
343     inline void detectNumberToken(UChar*, int);
344     inline void detectDashToken(int);
345     inline void detectAtToken(int, bool);
346
347     void setStyleSheet(CSSStyleSheet*);
348     void ensureCSSValuePool();
349
350     void recheckAtKeyword(const UChar* str, int len);
351
352     void setupParser(const char* prefix, const String&, const char* suffix);
353
354     bool inShorthand() const { return m_inParseShorthand; }
355
356     void checkForOrphanedUnits();
357
358     void deleteFontFaceOnlyValues();
359
360     bool isGeneratedImageValue(CSSParserValue*) const;
361     bool parseGeneratedImage(CSSParserValueList*, RefPtr<CSSValue>&);
362
363     bool parseValue(StylePropertySet*, int propId, const String&, bool important, CSSStyleSheet* contextStyleSheet);
364
365     enum SizeParameterType {
366         None,
367         Auto,
368         Length,
369         PageSize,
370         Orientation,
371     };
372
373     bool parsePage(int propId, bool important);
374     bool parseSize(int propId, bool important);
375     SizeParameterType parseSizeParameter(CSSValueList* parsedValues, CSSParserValue* value, SizeParameterType prevParamType);
376
377     bool parseFontFaceSrcURI(CSSValueList*);
378     bool parseFontFaceSrcLocal(CSSValueList*);
379
380     bool parseColor(const String&);
381
382     enum ParsingMode {
383         NormalMode,
384         MediaQueryMode,
385         NthChildMode
386     };
387
388     ParsingMode m_parsingMode;
389     OwnArrayPtr<UChar> m_dataStart;
390     UChar* m_currentCharacter;
391     UChar* m_tokenStart;
392     int m_token;
393     int m_lineNumber;
394     int m_lastSelectorLineNumber;
395
396     bool m_allowImportRules;
397     bool m_allowNamespaceDeclarations;
398
399     Vector<RefPtr<CSSRule> > m_parsedRules;
400     Vector<RefPtr<MediaList> > m_parsedMediaLists;
401     Vector<RefPtr<CSSRuleList> > m_parsedRuleLists;
402     HashSet<CSSParserSelector*> m_floatingSelectors;
403     HashSet<Vector<OwnPtr<CSSParserSelector> >*> m_floatingSelectorVectors;
404     HashSet<CSSParserValueList*> m_floatingValueLists;
405     HashSet<CSSParserFunction*> m_floatingFunctions;
406
407     OwnPtr<MediaQuery> m_floatingMediaQuery;
408     OwnPtr<MediaQueryExp> m_floatingMediaQueryExp;
409     OwnPtr<Vector<OwnPtr<MediaQueryExp> > > m_floatingMediaQueryExpList;
410
411     Vector<OwnPtr<CSSParserSelector> > m_reusableSelectorVector;
412     Vector<OwnPtr<CSSParserSelector> > m_reusableRegionSelectorVector;
413
414     RefPtr<CSSCalcValue> m_parsedCalculation;
415
416     // defines units allowed for a certain property, used in parseUnit
417     enum Units {
418         FUnknown   = 0x0000,
419         FInteger   = 0x0001,
420         FNumber    = 0x0002,  // Real Numbers
421         FPercent   = 0x0004,
422         FLength    = 0x0008,
423         FAngle     = 0x0010,
424         FTime      = 0x0020,
425         FFrequency = 0x0040,
426         FRelative  = 0x0100,
427         FNonNeg    = 0x0200
428     };
429
430     friend inline Units operator|(Units a, Units b)
431     {
432         return static_cast<Units>(static_cast<unsigned>(a) | static_cast<unsigned>(b));
433     }
434
435     bool validCalculationUnit(CSSParserValue*, Units);
436     bool validUnit(CSSParserValue*, Units, bool strict);
437
438     bool parseBorderImageQuad(Units, RefPtr<CSSPrimitiveValue>&);
439     int colorIntFromValue(CSSParserValue*);
440
441     enum ReleaseParsedCalcValueCondition {
442         ReleaseParsedCalcValue,
443         DoNotReleaseParsedCalcValue
444     };    
445     double parsedDouble(CSSParserValue*, ReleaseParsedCalcValueCondition releaseCalc = DoNotReleaseParsedCalcValue);
446     bool isCalculation(CSSParserValue*);
447     
448     friend class TransformOperationInfo;
449 #if ENABLE(CSS_FILTERS)
450     friend class FilterOperationInfo;
451 #endif
452 };
453
454 int cssPropertyID(const CSSParserString&);
455 int cssPropertyID(const String&);
456 int cssValueKeywordID(const CSSParserString&);
457 #if PLATFORM(IOS)
458 void cssPropertyNameIOSAliasing(const char* propertyName, const char*& propertyNameAlias, unsigned& newLength);
459 #endif
460
461 class ShorthandScope {
462     WTF_MAKE_FAST_ALLOCATED;
463 public:
464     ShorthandScope(CSSParser* parser, int propId) : m_parser(parser)
465     {
466         if (!(m_parser->m_inParseShorthand++))
467             m_parser->m_currentShorthand = propId;
468     }
469     ~ShorthandScope()
470     {
471         if (!(--m_parser->m_inParseShorthand))
472             m_parser->m_currentShorthand = 0;
473     }
474
475 private:
476     CSSParser* m_parser;
477 };
478
479 String quoteCSSString(const String&);
480 String quoteCSSStringIfNeeded(const String&);
481 String quoteCSSURLIfNeeded(const String&);
482
483 bool isValidNthToken(const CSSParserString&);
484 } // namespace WebCore
485
486 #endif // CSSParser_h