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