Remove CSS_SHAPES feature definition. This should always be on.
[WebKit-https.git] / Source / WebCore / css / parser / CSSParser.h
1 /*
2  * Copyright (C) 2003 Lars Knoll (knoll@kde.org)
3  * Copyright (C) 2004-2010, 2015 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 #pragma once
24
25 #include "CSSCalculationValue.h"
26 #include "CSSGradientValue.h"
27 #include "CSSParserMode.h"
28 #include "CSSParserValues.h"
29 #include "CSSProperty.h"
30 #include "CSSPropertyNames.h"
31 #include "CSSPropertySourceData.h"
32 #include "CSSValueKeywords.h"
33 #include "Color.h"
34 #include "MediaQuery.h"
35 #include "StyleRuleImport.h"
36 #include "WebKitCSSFilterValue.h"
37 #include <memory>
38 #include <wtf/HashMap.h>
39 #include <wtf/Vector.h>
40 #include <wtf/text/AtomicString.h>
41 #include <wtf/text/TextPosition.h>
42
43 #if ENABLE(CSS_GRID_LAYOUT)
44 #include "GridArea.h"
45 #endif
46
47 namespace WebCore {
48
49 class AnimationParseContext;
50 class CSSBorderImageSliceValue;
51 class CSSContentDistributionValue;
52 class CSSPrimitiveValue;
53 class CSSSelectorList;
54 class CSSValue;
55 class CSSValueList;
56 class CSSBasicShape;
57 class CSSBasicShapeCircle;
58 class CSSBasicShapeEllipse;
59 class CSSBasicShapeInset;
60 class CSSBasicShapePath;
61 class CSSBasicShapePolygon;
62 class CSSGridLineNamesValue;
63 class CSSImageSetValue;
64 class CSSVariableDependentValue;
65 class Document;
66 class Element;
67 class ImmutableStyleProperties;
68 class MediaQueryExpression;
69 class MediaQuerySet;
70 class MutableStyleProperties;
71 class SVGColor;
72 class SVGPaint;
73 class StyleKeyframe;
74 class StylePropertyShorthand;
75 class StyleRule;
76 class StyleRuleBase;
77 class StyleRuleFontFace;
78 class StyleRuleKeyframes;
79 class StyleRuleMedia;
80 class StyleRulePage;
81 class StyleRuleRegion;
82 class StyleRuleSupports;
83 class StyleRuleViewport;
84 class StyleKeyframe;
85 class StyleSheetContents;
86 class StyledElement;
87 class WebKitCSSTransformValue;
88
89 class CSSParser {
90     friend inline int cssyylex(void*, CSSParser*);
91
92 public:
93     struct Location;
94     enum SyntaxErrorType {
95         PropertyDeclarationError,
96         GeneralSyntaxError
97     };
98
99     enum class ParseResult {
100         Changed,
101         Unchanged,
102         Error
103     };
104
105     class ValueWithCalculation {
106     public:
107         explicit ValueWithCalculation(CSSParserValue& value)
108             : m_value(value)
109         { }
110
111         CSSParserValue& value() const { return m_value; }
112         operator CSSParserValue&() { return m_value; }
113
114         RefPtr<CSSCalcValue> calculation() const { return m_calculation; }
115         void setCalculation(RefPtr<CSSCalcValue>&& calculation)
116         {
117             ASSERT(isCalculation(m_value));
118             m_calculation = calculation;
119         }
120
121     private:
122         CSSParserValue& m_value;
123         RefPtr<CSSCalcValue> m_calculation;
124     };
125
126     WEBCORE_EXPORT CSSParser(const CSSParserContext&);
127     WEBCORE_EXPORT ~CSSParser();
128
129     void parseSheet(StyleSheetContents*, const String&, const TextPosition&, RuleSourceDataList*, bool logErrors);
130     RefPtr<StyleRuleBase> parseRule(StyleSheetContents*, const String&);
131     RefPtr<StyleKeyframe> parseKeyframeRule(StyleSheetContents*, const String&);
132     bool parseSupportsCondition(const String&);
133
134     static ParseResult parseValue(MutableStyleProperties&, CSSPropertyID, const String&, bool important, const CSSParserContext&, StyleSheetContents*);
135     static ParseResult parseCustomPropertyValue(MutableStyleProperties&, const AtomicString& propertyName, const String&, bool important, const CSSParserContext&, StyleSheetContents* contextStyleSheet);
136
137     static Color parseColor(const String&, bool strict = false);
138     static bool isValidSystemColorValue(CSSValueID);
139     static Color parseSystemColor(const String&, Document*);
140     static RefPtr<CSSValueList> parseFontFaceValue(const AtomicString&);
141     RefPtr<CSSPrimitiveValue> parseValidPrimitive(CSSValueID ident, ValueWithCalculation&);
142
143     WEBCORE_EXPORT bool parseDeclaration(MutableStyleProperties&, const String&, RefPtr<CSSRuleSourceData>&&, StyleSheetContents* contextStyleSheet);
144     static Ref<ImmutableStyleProperties> parseInlineStyleDeclaration(const String&, Element*);
145     std::unique_ptr<MediaQuery> parseMediaQuery(const String&);
146
147     void addProperty(CSSPropertyID, RefPtr<CSSValue>&&, bool important, bool implicit = false);
148     void rollbackLastProperties(int num);
149     bool hasProperties() const { return !m_parsedProperties.isEmpty(); }
150     void addExpandedPropertyForValue(CSSPropertyID propId, Ref<CSSValue>&&, bool);
151
152     bool parseValue(CSSPropertyID, bool important);
153     bool parseShorthand(CSSPropertyID, const StylePropertyShorthand&, bool important);
154     bool parse4Values(CSSPropertyID, const CSSPropertyID* properties, bool important);
155     bool parseContent(CSSPropertyID, bool important);
156     bool parseQuotes(CSSPropertyID, bool important);
157     bool parseAlt(CSSPropertyID, bool important);
158     
159     bool parseCustomPropertyDeclaration(bool important, CSSValueID);
160     
161     RefPtr<CSSPrimitiveValue> parseAttr(CSSParserValueList& args);
162
163     RefPtr<CSSPrimitiveValue> parseBackgroundColor();
164
165     struct SourceSize {
166         MediaQueryExpression expression;
167         Ref<CSSValue> length;
168
169         SourceSize(SourceSize&&);
170         SourceSize(MediaQueryExpression&&, Ref<CSSValue>&&);
171     };
172     Vector<SourceSize> parseSizesAttribute(StringView);
173     Optional<SourceSize> sourceSize(MediaQueryExpression&&, CSSParserValue&);
174
175     bool parseFillImage(CSSParserValueList&, RefPtr<CSSValue>&);
176
177     enum FillPositionFlag { InvalidFillPosition = 0, AmbiguousFillPosition = 1, XFillPosition = 2, YFillPosition = 4 };
178     enum FillPositionParsingMode { ResolveValuesAsPercent = 0, ResolveValuesAsKeyword = 1 };
179     RefPtr<CSSPrimitiveValue> parseFillPositionComponent(CSSParserValueList&, unsigned& cumulativeFlags, FillPositionFlag& individualFlag, FillPositionParsingMode = ResolveValuesAsPercent);
180     RefPtr<CSSPrimitiveValue> parsePositionX(CSSParserValueList&);
181     RefPtr<CSSPrimitiveValue> parsePositionY(CSSParserValueList&);
182     void parse2ValuesFillPosition(CSSParserValueList&, RefPtr<CSSPrimitiveValue>&, RefPtr<CSSPrimitiveValue>&);
183     bool isPotentialPositionValue(CSSParserValue&);
184     void parseFillPosition(CSSParserValueList&, RefPtr<CSSPrimitiveValue>&, RefPtr<CSSPrimitiveValue>&);
185     void parse3ValuesFillPosition(CSSParserValueList&, RefPtr<CSSPrimitiveValue>&, RefPtr<CSSPrimitiveValue>&, Ref<CSSPrimitiveValue>&&, Ref<CSSPrimitiveValue>&&);
186     void parse4ValuesFillPosition(CSSParserValueList&, RefPtr<CSSPrimitiveValue>&, RefPtr<CSSPrimitiveValue>&, Ref<CSSPrimitiveValue>&&, Ref<CSSPrimitiveValue>&&);
187
188     void parseFillRepeat(RefPtr<CSSValue>&, RefPtr<CSSValue>&);
189     RefPtr<CSSPrimitiveValue> parseFillSize(CSSPropertyID, bool &allowComma);
190
191     bool parseFillProperty(CSSPropertyID propId, CSSPropertyID& propId1, CSSPropertyID& propId2, RefPtr<CSSValue>&, RefPtr<CSSValue>&);
192     bool parseFillShorthand(CSSPropertyID, const CSSPropertyID* properties, int numProperties, bool important);
193
194     void addFillValue(RefPtr<CSSValue>& lval, Ref<CSSValue>&& rval);
195     void addAnimationValue(RefPtr<CSSValue>& lval, Ref<CSSValue>&& rval);
196
197     RefPtr<CSSPrimitiveValue> parseAnimationDelay();
198     RefPtr<CSSPrimitiveValue> parseAnimationDirection();
199     RefPtr<CSSPrimitiveValue> parseAnimationDuration();
200     RefPtr<CSSPrimitiveValue> parseAnimationFillMode();
201     RefPtr<CSSPrimitiveValue> parseAnimationIterationCount();
202     RefPtr<CSSPrimitiveValue> parseAnimationName();
203     RefPtr<CSSPrimitiveValue> parseAnimationPlayState();
204     RefPtr<CSSPrimitiveValue> parseAnimationProperty(AnimationParseContext&);
205     RefPtr<CSSValue> parseAnimationTimingFunction();
206 #if ENABLE(CSS_ANIMATIONS_LEVEL_2)
207     RefPtr<CSSValue> parseAnimationTrigger();
208 #endif
209     static Vector<double> parseKeyframeSelector(const String&);
210
211     bool parseTransformOriginShorthand(RefPtr<CSSPrimitiveValue>&, RefPtr<CSSPrimitiveValue>&, RefPtr<CSSValue>&);
212     Optional<double> parseCubicBezierTimingFunctionValue(CSSParserValueList&);
213     Optional<double> parseSpringTimingFunctionValue(CSSParserValueList&);
214     bool parseAnimationProperty(CSSPropertyID, RefPtr<CSSValue>&, AnimationParseContext&);
215     bool parseTransitionShorthand(CSSPropertyID, bool important);
216     bool parseAnimationShorthand(CSSPropertyID, bool important);
217
218     bool isSpringTimingFunctionEnabled() const;
219
220     RefPtr<CSSPrimitiveValue> parseColumnWidth();
221     RefPtr<CSSPrimitiveValue> parseColumnCount();
222     bool parseColumnsShorthand(bool important);
223
224 #if ENABLE(TEXT_AUTOSIZING)
225     bool isTextAutosizingEnabled() const;
226 #endif
227
228 #if ENABLE(CSS_GRID_LAYOUT)
229     bool isCSSGridLayoutEnabled() const;
230     RefPtr<CSSValue> parseGridPosition();
231     bool parseGridItemPositionShorthand(CSSPropertyID, bool important);
232     enum TrackListType { GridTemplate, GridTemplateNoRepeat, GridAuto };
233     RefPtr<CSSValue> parseGridTemplateColumns(TrackListType = GridTemplate);
234     bool parseGridTemplateRowsAndAreasAndColumns(bool important);
235     bool parseGridTemplateShorthand(bool important);
236     bool parseGridShorthand(bool important);
237     bool parseGridAreaShorthand(bool important);
238     bool parseGridGapShorthand(bool important);
239     bool parseSingleGridAreaLonghand(RefPtr<CSSValue>&);
240     RefPtr<CSSValue> parseGridTrackList(TrackListType);
241     bool parseGridTrackRepeatFunction(CSSValueList&, bool& isAutoRepeat, bool& allTracksAreFixedSized);
242     RefPtr<CSSValue> parseGridTrackSize(CSSParserValueList& inputList);
243     RefPtr<CSSPrimitiveValue> parseGridBreadth(CSSParserValue&);
244     bool parseGridTemplateAreasRow(NamedGridAreaMap&, const unsigned, unsigned&);
245     RefPtr<CSSValue> parseGridTemplateAreas();
246     bool parseGridLineNames(CSSParserValueList&, CSSValueList&, CSSGridLineNamesValue* = nullptr);
247     RefPtr<CSSValue> parseGridAutoFlow(CSSParserValueList&);
248 #endif
249
250     bool parseDashboardRegions(CSSPropertyID, bool important);
251
252     bool parseClipShape(CSSPropertyID, bool important);
253
254     bool parseLegacyPosition(CSSPropertyID, bool important);
255     bool parseItemPositionOverflowPosition(CSSPropertyID, bool important);
256     RefPtr<CSSContentDistributionValue> parseContentDistributionOverflowPosition();
257
258     RefPtr<CSSValue> parseShapeProperty(CSSPropertyID);
259
260     RefPtr<CSSValueList> parseBasicShapeAndOrBox(CSSPropertyID propId);
261     RefPtr<CSSPrimitiveValue> parseBasicShape();
262     RefPtr<CSSPrimitiveValue> parseShapeRadius(CSSParserValue&);
263     RefPtr<CSSBasicShapeCircle> parseBasicShapeCircle(CSSParserValueList&);
264     RefPtr<CSSBasicShapeEllipse> parseBasicShapeEllipse(CSSParserValueList&);
265     RefPtr<CSSBasicShapePolygon> parseBasicShapePolygon(CSSParserValueList&);
266     RefPtr<CSSBasicShapePath> parseBasicShapePath(CSSParserValueList&);
267     RefPtr<CSSBasicShapeInset> parseBasicShapeInset(CSSParserValueList&);
268
269     bool parseFont(bool important);
270     void parseSystemFont(bool important);
271     RefPtr<CSSValueList> parseFontFamily();
272
273     bool parseCounter(CSSPropertyID, int defaultValue, bool important);
274     RefPtr<CSSPrimitiveValue> parseCounterContent(CSSParserValueList& args, bool counters);
275
276     bool parseRGBParameters(CSSParserValue&, int* colorValues, bool parseAlpha);
277     bool parseHSLParameters(CSSParserValue&, double* colorValues, bool parseAlpha);
278     RefPtr<CSSPrimitiveValue> parseColor(CSSParserValue* = nullptr);
279     Color parseColorFromValue(CSSParserValue&);
280     void parseSelector(const String&, CSSSelectorList&);
281
282     template<typename StringType>
283     static Color fastParseColor(const StringType&, bool strict);
284
285     bool parseLineHeight(bool important);
286     bool parseFontSize(bool important);
287     bool parseFontWeight(bool important);
288     bool parseFontSynthesis(bool important);
289     bool parseFontFaceSrc();
290     bool parseFontFaceUnicodeRange();
291
292     bool parseSVGValue(CSSPropertyID propId, bool important);
293     RefPtr<SVGPaint> parseSVGPaint();
294     RefPtr<SVGColor> parseSVGColor();
295     RefPtr<CSSValueList> parseSVGStrokeDasharray();
296     RefPtr<CSSValueList> parsePaintOrder();
297
298     // CSS3 Parsing Routines (for properties specific to CSS3)
299     RefPtr<CSSValueList> parseShadow(CSSParserValueList&, CSSPropertyID);
300     bool parseBorderImage(CSSPropertyID, RefPtr<CSSValue>&, bool important = false);
301     bool parseBorderImageRepeat(RefPtr<CSSValue>&);
302     bool parseBorderImageSlice(CSSPropertyID, RefPtr<CSSBorderImageSliceValue>&);
303     bool parseBorderImageWidth(RefPtr<CSSPrimitiveValue>&);
304     bool parseBorderImageOutset(RefPtr<CSSPrimitiveValue>&);
305     bool parseBorderRadius(CSSPropertyID, bool important);
306
307     bool parseAspectRatio(bool important);
308
309     bool parseReflect(CSSPropertyID, bool important);
310
311     bool parseFlex(CSSParserValueList& args, bool important);
312
313     // Image generators
314     bool parseCanvas(CSSParserValueList&, RefPtr<CSSValue>&);
315     bool parseNamedImage(CSSParserValueList&, RefPtr<CSSValue>&);
316
317     bool parseDeprecatedGradient(CSSParserValueList&, RefPtr<CSSValue>&);
318     bool parseDeprecatedLinearGradient(CSSParserValueList&, RefPtr<CSSValue>&, CSSGradientRepeat repeating);
319     bool parseDeprecatedRadialGradient(CSSParserValueList&, RefPtr<CSSValue>&, CSSGradientRepeat repeating);
320     bool parseLinearGradient(CSSParserValueList&, RefPtr<CSSValue>&, CSSGradientRepeat repeating);
321     bool parseRadialGradient(CSSParserValueList&, RefPtr<CSSValue>&, CSSGradientRepeat repeating);
322     bool parseGradientColorStops(CSSParserValueList&, CSSGradientValue&, bool expectComma);
323
324     bool parseCrossfade(CSSParserValueList&, RefPtr<CSSValue>&, bool prefixed);
325
326 #if ENABLE(CSS_IMAGE_RESOLUTION)
327     RefPtr<CSSValueList> parseImageResolution();
328 #endif
329
330     RefPtr<CSSImageSetValue> parseImageSet();
331
332     bool parseFilterImage(CSSParserValueList&, RefPtr<CSSValue>&);
333
334     bool parseFilter(CSSParserValueList&, RefPtr<CSSValueList>&);
335     RefPtr<WebKitCSSFilterValue> parseBuiltinFilterArguments(CSSParserValueList&, WebKitCSSFilterValue::FilterOperationType);
336
337     RefPtr<CSSValue> parseClipPath();
338
339     static bool isBlendMode(CSSValueID);
340     static bool isCompositeOperator(CSSValueID);
341
342     RefPtr<CSSValueList> parseTransform();
343     RefPtr<WebKitCSSTransformValue> parseTransformValue(CSSParserValue&);
344     bool parseTransformOrigin(CSSPropertyID propId, CSSPropertyID& propId1, CSSPropertyID& propId2, CSSPropertyID& propId3, RefPtr<CSSPrimitiveValue>&, RefPtr<CSSPrimitiveValue>&, RefPtr<CSSValue>&);
345     bool parsePerspectiveOrigin(CSSPropertyID propId, CSSPropertyID& propId1, CSSPropertyID& propId2,  RefPtr<CSSPrimitiveValue>&, RefPtr<CSSPrimitiveValue>&);
346
347     bool parseTextEmphasisStyle(bool important);
348     bool parseTextEmphasisPosition(bool important);
349
350     void addTextDecorationProperty(CSSPropertyID, RefPtr<CSSValue>&&, bool important);
351     bool parseTextDecoration(CSSPropertyID propId, bool important);
352     bool parseTextDecorationSkip(bool important);
353     bool parseTextUnderlinePosition(bool important);
354
355     RefPtr<CSSValueList> parseTextIndent();
356     
357     bool parseHangingPunctuation(bool important);
358
359     bool parseLineBoxContain(bool important);
360     RefPtr<CSSCalcValue> parseCalculation(CSSParserValue&, ValueRange);
361
362     bool parseFontFeatureTag(CSSValueList&);
363     bool parseFontFeatureSettings(bool important);
364
365     bool parseFontVariationTag(CSSValueList&);
366     bool parseFontVariationSettings(bool important);
367
368     bool parseFlowThread(CSSPropertyID, bool important);
369     bool parseRegionThread(CSSPropertyID, bool important);
370
371     bool parseFontVariantLigatures(bool important, bool unknownIsFailure, bool implicit);
372     bool parseFontVariantNumeric(bool important, bool unknownIsFailure, bool implicit);
373     bool parseFontVariantEastAsian(bool important, bool unknownIsFailure, bool implicit);
374     bool parseFontVariant(bool important);
375
376     bool parseWillChange(bool important);
377
378     // Faster than doing a new/delete each time since it keeps one vector.
379     std::unique_ptr<Vector<std::unique_ptr<CSSParserSelector>>> createSelectorVector();
380     void recycleSelectorVector(std::unique_ptr<Vector<std::unique_ptr<CSSParserSelector>>>);
381
382     RefPtr<StyleRuleImport> createImportRule(const CSSParserString&, RefPtr<MediaQuerySet>&&);
383     RefPtr<StyleKeyframe> createKeyframe(CSSParserValueList&);
384     Ref<StyleRuleKeyframes> createKeyframesRule(const String&, std::unique_ptr<Vector<RefPtr<StyleKeyframe>>>);
385
386     typedef Vector<RefPtr<StyleRuleBase>> RuleList;
387     Ref<StyleRuleMedia> createMediaRule(RefPtr<MediaQuerySet>&&, RuleList*);
388     Ref<StyleRuleMedia> createEmptyMediaRule(RuleList*);
389     RefPtr<StyleRule> createStyleRule(Vector<std::unique_ptr<CSSParserSelector>>* selectors);
390     RefPtr<StyleRuleFontFace> createFontFaceRule();
391     RefPtr<StyleRulePage> createPageRule(std::unique_ptr<CSSParserSelector> pageSelector);
392     RefPtr<StyleRuleRegion> createRegionRule(Vector<std::unique_ptr<CSSParserSelector>>* regionSelector, RuleList* rules);
393     void createMarginAtRule(CSSSelector::MarginBoxType);
394     Ref<StyleRuleSupports> createSupportsRule(bool conditionIsSupported, RuleList*);
395     void markSupportsRuleHeaderStart();
396     void markSupportsRuleHeaderEnd();
397     Ref<CSSRuleSourceData> popSupportsRuleData();
398
399     void startDeclarationsForMarginBox();
400     void endDeclarationsForMarginBox();
401
402     void addNamespace(const AtomicString& prefix, const AtomicString& uri);
403     QualifiedName determineNameInNamespace(const AtomicString& prefix, const AtomicString& localName);
404
405     void rewriteSpecifiersWithElementName(const AtomicString& namespacePrefix, const AtomicString& elementName, CSSParserSelector&);
406     void rewriteSpecifiersWithElementName(const QualifiedName& tagName, CSSParserSelector&, bool isNamespacePlaceholder = false);
407     void rewriteSpecifiersWithNamespaceIfNeeded(CSSParserSelector&);
408     std::unique_ptr<CSSParserSelector> rewriteSpecifiers(std::unique_ptr<CSSParserSelector>, std::unique_ptr<CSSParserSelector>);
409
410     void invalidBlockHit();
411
412     void updateLastSelectorLineAndPosition();
413     void updateLastMediaLine(MediaQuerySet&);
414
415     void clearProperties();
416
417     Ref<ImmutableStyleProperties> createStyleProperties();
418
419     static const unsigned invalidParsedPropertiesCount;
420
421     CSSParserContext m_context;
422
423     bool m_important { false };
424     CSSPropertyID m_id { CSSPropertyInvalid };
425     AtomicString m_customPropertyName;
426     StyleSheetContents* m_styleSheet { nullptr };
427     RefPtr<StyleRuleBase> m_rule;
428     RefPtr<StyleKeyframe> m_keyframe;
429     std::unique_ptr<MediaQuery> m_mediaQuery;
430     std::unique_ptr<CSSParserValueList> m_valueList;
431     bool m_supportsCondition { false };
432
433     ParsedPropertyVector m_parsedProperties;
434     CSSSelectorList* m_selectorListForParseSelector { nullptr };
435
436     unsigned m_numParsedPropertiesBeforeMarginBox { invalidParsedPropertiesCount };
437
438     int m_inParseShorthand { 0 };
439     CSSPropertyID m_currentShorthand { CSSPropertyInvalid };
440     bool m_implicitShorthand { false };
441
442     bool m_hadSyntacticallyValidCSSRule { false };
443     bool m_logErrors { false };
444     bool m_ignoreErrorsInDeclaration { false };
445
446     AtomicString m_defaultNamespace { starAtom };
447
448     // tokenizer methods and data
449     size_t m_parsedTextPrefixLength { 0 };
450     unsigned m_nestedSelectorLevel { 0 };
451     SourceRange m_selectorRange;
452     SourceRange m_propertyRange { std::numeric_limits<unsigned>::max(), std::numeric_limits<unsigned>::max() };
453     std::unique_ptr<RuleSourceDataList> m_currentRuleDataStack;
454     RefPtr<CSSRuleSourceData> m_currentRuleData;
455     RuleSourceDataList* m_ruleSourceDataResult { nullptr };
456
457     void fixUnparsedPropertyRanges(CSSRuleSourceData&);
458     void markRuleHeaderStart(CSSRuleSourceData::Type);
459     void markRuleHeaderEnd();
460
461     void startNestedSelectorList() { ++m_nestedSelectorLevel; }
462     void endNestedSelectorList() { --m_nestedSelectorLevel; }
463     void markSelectorStart();
464     void markSelectorEnd();
465
466     void markRuleBodyStart();
467     void markRuleBodyEnd();
468     void markPropertyStart();
469     void markPropertyEnd(bool isImportantFound, bool isPropertyParsed);
470     void processAndAddNewRuleToSourceTreeIfNeeded();
471     void addNewRuleToSourceTree(Ref<CSSRuleSourceData>&&);
472     RefPtr<CSSRuleSourceData> popRuleData();
473     void resetPropertyRange() { m_propertyRange.start = m_propertyRange.end = std::numeric_limits<unsigned>::max(); }
474     bool isExtractingSourceData() const { return !!m_currentRuleDataStack; }
475     void syntaxError(const Location&, SyntaxErrorType = GeneralSyntaxError);
476
477     inline int lex(void* yylval) { return (this->*m_lexFunc)(yylval); }
478
479     int token() { return m_token; }
480
481 #if ENABLE(CSS_DEVICE_ADAPTATION)
482     void markViewportRuleBodyStart() { m_inViewport = true; }
483     void markViewportRuleBodyEnd() { m_inViewport = false; }
484     Ref<StyleRuleViewport> createViewportRule();
485 #endif
486
487     Ref<CSSPrimitiveValue> createPrimitiveNumericValue(ValueWithCalculation&);
488     Ref<CSSPrimitiveValue> createPrimitiveStringValue(CSSParserValue&);
489
490     static URL completeURL(const CSSParserContext&, const String& url);
491
492     Location currentLocation();
493     static bool isCalculation(CSSParserValue&);
494
495     void setCustomPropertyName(const AtomicString& propertyName) { m_customPropertyName = propertyName; }
496
497     RefPtr<CSSValue> parseVariableDependentValue(CSSPropertyID, const CSSVariableDependentValue&, const CustomPropertyValueMap& customProperties, TextDirection, WritingMode);
498
499 private:
500     bool is8BitSource() { return m_is8BitSource; }
501
502     template <typename SourceCharacterType>
503     int realLex(void* yylval);
504
505     UChar*& currentCharacter16();
506
507     template <typename CharacterType>
508     inline CharacterType*& currentCharacter();
509
510     template <typename CharacterType>
511     inline CharacterType* tokenStart();
512
513     template <typename CharacterType>
514     inline void setTokenStart(CharacterType*);
515
516     inline unsigned tokenStartOffset();
517     inline UChar tokenStartChar();
518
519     inline unsigned currentCharacterOffset();
520
521     template <typename CharacterType>
522     inline bool isIdentifierStart();
523
524     template <typename CharacterType>
525     unsigned parseEscape(CharacterType*&);
526     template <typename DestCharacterType>
527     inline void UnicodeToChars(DestCharacterType*&, unsigned);
528     template <typename SrcCharacterType, typename DestCharacterType>
529     inline bool parseIdentifierInternal(SrcCharacterType*&, DestCharacterType*&, bool&);
530
531     template <typename CharacterType>
532     inline void parseIdentifier(CharacterType*&, CSSParserString&, bool&);
533
534     template <typename SrcCharacterType, typename DestCharacterType>
535     inline bool parseStringInternal(SrcCharacterType*&, DestCharacterType*&, UChar);
536
537     template <typename CharacterType>
538     inline void parseString(CharacterType*&, CSSParserString& resultString, UChar);
539
540     template <typename CharacterType>
541     inline bool findURI(CharacterType*& start, CharacterType*& end, UChar& quote);
542
543     template <typename SrcCharacterType, typename DestCharacterType>
544     inline bool parseURIInternal(SrcCharacterType*&, DestCharacterType*&, UChar quote);
545
546     template <typename CharacterType>
547     inline void parseURI(CSSParserString&);
548     template <typename CharacterType>
549     inline bool parseUnicodeRange();
550     template <typename CharacterType>
551     bool parseNthChild();
552     template <typename CharacterType>
553     bool parseNthChildExtra();
554     template <typename CharacterType>
555     inline bool detectFunctionTypeToken(int);
556     template <typename CharacterType>
557     inline void detectMediaQueryToken(int);
558     template <typename CharacterType>
559     inline void detectNumberToken(CharacterType*, int);
560     template <typename CharacterType>
561     inline void detectDashToken(int);
562     template <typename CharacterType>
563     inline void detectAtToken(int, bool);
564     template <typename CharacterType>
565     inline void detectSupportsToken(int);
566
567     template <typename CharacterType>
568     inline void setRuleHeaderEnd(const CharacterType*);
569
570     void setStyleSheet(StyleSheetContents* styleSheet) { m_styleSheet = styleSheet; }
571
572     inline bool inStrictMode() const { return m_context.mode == UASheetMode || m_context.mode == HTMLStandardMode || m_context.mode == SVGAttributeMode; }
573     inline bool inQuirksMode() const { return m_context.mode == HTMLQuirksMode; }
574     
575     URL completeURL(const String& url) const;
576
577     void recheckAtKeyword(const UChar* str, int len);
578
579     template<unsigned prefixLength, unsigned suffixLength>
580     void setupParser(const char (&prefix)[prefixLength], StringView string, const char (&suffix)[suffixLength])
581     {
582         setupParser(prefix, prefixLength - 1, string, suffix, suffixLength - 1);
583     }
584     void setupParser(const char* prefix, unsigned prefixLength, StringView, const char* suffix, unsigned suffixLength);
585     bool inShorthand() const { return m_inParseShorthand; }
586
587     bool isValidSize(ValueWithCalculation&);
588
589     bool isGeneratedImageValue(CSSParserValue&) const;
590     bool parseGeneratedImage(CSSParserValueList&, RefPtr<CSSValue>&);
591
592     ParseResult parseValue(MutableStyleProperties&, CSSPropertyID, const String&, bool important, StyleSheetContents* contextStyleSheet);
593     Ref<ImmutableStyleProperties> parseDeclaration(const String&, StyleSheetContents* contextStyleSheet);
594
595     RefPtr<CSSBasicShapeInset> parseInsetRoundedCorners(Ref<CSSBasicShapeInset>&&, CSSParserValueList&);
596
597     enum SizeParameterType {
598         None,
599         Auto,
600         Length,
601         PageSize,
602         Orientation,
603     };
604
605     bool parsePage(CSSPropertyID propId, bool important);
606     bool parseSize(CSSPropertyID propId, bool important);
607     SizeParameterType parseSizeParameter(CSSValueList& parsedValues, CSSParserValue&, SizeParameterType prevParamType);
608
609 #if ENABLE(CSS_SCROLL_SNAP)
610     bool parseNonElementSnapPoints(CSSPropertyID propId, bool important);
611     bool parseScrollSnapDestination(CSSPropertyID propId, bool important);
612     bool parseScrollSnapCoordinate(CSSPropertyID propId, bool important);
613     bool parseScrollSnapPositions(RefPtr<CSSValue>& cssValueX, RefPtr<CSSValue>& cssValueY);
614 #endif
615
616     bool parseFontFaceSrcURI(CSSValueList&);
617     bool parseFontFaceSrcLocal(CSSValueList&);
618
619     bool parseColorFromString(const String&);
620
621 #if ENABLE(CSS_GRID_LAYOUT)
622     bool parseIntegerOrCustomIdentFromGridPosition(RefPtr<CSSPrimitiveValue>& numericValue, RefPtr<CSSPrimitiveValue>& gridLineName);
623 #endif
624
625     enum ParsingMode {
626         NormalMode,
627         MediaQueryMode,
628         SupportsMode,
629         NthChildMode
630     };
631
632     ParsingMode m_parsingMode { NormalMode };
633     bool m_is8BitSource { false };
634     std::unique_ptr<LChar[]> m_dataStart8;
635     std::unique_ptr<UChar[]> m_dataStart16;
636     LChar* m_currentCharacter8 { nullptr };
637     UChar* m_currentCharacter16 { nullptr };
638     union {
639         LChar* ptr8;
640         UChar* ptr16;
641     } m_tokenStart { nullptr };
642     unsigned m_length { 0 };
643     int m_token { 0 };
644     int m_lineNumber { 0 };
645     int m_tokenStartLineNumber { 0 };
646     int m_tokenStartColumnNumber { 0 };
647     int m_lastSelectorLineNumber { 0 };
648     int m_columnOffsetForLine { 0 };
649
650     int m_sheetStartLineNumber { 0 };
651     int m_sheetStartColumnNumber { 0 };
652
653     bool m_allowImportRules { true };
654     bool m_allowNamespaceDeclarations { true };
655
656 #if ENABLE(CSS_DEVICE_ADAPTATION)
657     bool parseViewportProperty(CSSPropertyID propId, bool important);
658     bool parseViewportShorthand(CSSPropertyID propId, CSSPropertyID first, CSSPropertyID second, bool important);
659
660     bool inViewport() const { return m_inViewport; }
661     bool m_inViewport { false };
662 #endif
663
664     bool useLegacyBackgroundSizeShorthandBehavior() const;
665
666     int (CSSParser::*m_lexFunc)(void*);
667
668     std::unique_ptr<Vector<std::unique_ptr<CSSParserSelector>>> m_recycledSelectorVector;
669
670     std::unique_ptr<RuleSourceDataList> m_supportsRuleDataStack;
671
672     // defines units allowed for a certain property, used in parseUnit
673     enum Units {
674         FUnknown = 0x0000,
675         FInteger = 0x0001,
676         FNumber = 0x0002, // Real Numbers
677         FPercent = 0x0004,
678         FLength = 0x0008,
679         FAngle = 0x0010,
680         FTime = 0x0020,
681         FFrequency = 0x0040,
682         FPositiveInteger = 0x0080,
683         FRelative = 0x0100,
684 #if ENABLE(CSS_IMAGE_RESOLUTION) || ENABLE(RESOLUTION_MEDIA_QUERY)
685         FResolution = 0x0200,
686 #endif
687         FNonNeg = 0x0400
688     };
689
690     friend inline Units operator|(Units a, Units b)
691     {
692         return static_cast<Units>(static_cast<unsigned>(a) | static_cast<unsigned>(b));
693     }
694
695     enum ReleaseParsedCalcValueCondition {
696         ReleaseParsedCalcValue,
697         DoNotReleaseParsedCalcValue
698     };
699
700     bool isLoggingErrors();
701     void logError(const String& message, int lineNumber, int columnNumber);
702
703     bool validateCalculationUnit(ValueWithCalculation&, Units);
704
705     bool shouldAcceptUnitLessValues(CSSParserValue&, Units, CSSParserMode);
706
707     inline bool validateUnit(ValueWithCalculation& value, Units unitFlags) { return validateUnit(value, unitFlags, m_context.mode); }
708     bool validateUnit(ValueWithCalculation&, Units, CSSParserMode);
709
710     bool parseBorderImageQuad(Units, RefPtr<CSSPrimitiveValue>&);
711     int colorIntFromValue(ValueWithCalculation&);
712     double parsedDouble(ValueWithCalculation&);
713     
714     friend class TransformOperationInfo;
715     friend class FilterOperationInfo;
716 };
717
718 CSSPropertyID cssPropertyID(const CSSParserString&);
719 CSSPropertyID cssPropertyID(const String&);
720 CSSValueID cssValueKeywordID(const CSSParserString&);
721 #if PLATFORM(IOS)
722 void cssPropertyNameIOSAliasing(const char* propertyName, const char*& propertyNameAlias, unsigned& newLength);
723 #endif
724
725 class ShorthandScope {
726     WTF_MAKE_FAST_ALLOCATED;
727 public:
728     ShorthandScope(CSSParser* parser, CSSPropertyID propId) : m_parser(parser)
729     {
730         if (!(m_parser->m_inParseShorthand++))
731             m_parser->m_currentShorthand = propId;
732     }
733     ~ShorthandScope()
734     {
735         if (!(--m_parser->m_inParseShorthand))
736             m_parser->m_currentShorthand = CSSPropertyInvalid;
737     }
738
739 private:
740     CSSParser* m_parser;
741 };
742
743 struct CSSParser::Location {
744     int lineNumber;
745     int columnNumber;
746     CSSParserString token;
747 };
748
749 String quoteCSSString(const String&);
750 String quoteCSSStringIfNeeded(const String&);
751 String quoteCSSURLIfNeeded(const String&);
752
753 bool isValidNthToken(const CSSParserString&);
754
755 template <>
756 inline void CSSParser::setTokenStart<LChar>(LChar* tokenStart)
757 {
758     m_tokenStart.ptr8 = tokenStart;
759 }
760
761 template <>
762 inline void CSSParser::setTokenStart<UChar>(UChar* tokenStart)
763 {
764     m_tokenStart.ptr16 = tokenStart;
765 }
766
767 inline unsigned CSSParser::tokenStartOffset()
768 {
769     if (is8BitSource())
770         return m_tokenStart.ptr8 - m_dataStart8.get();
771     return m_tokenStart.ptr16 - m_dataStart16.get();
772 }
773
774 unsigned CSSParser::currentCharacterOffset()
775 {
776     if (is8BitSource())
777         return m_currentCharacter8 - m_dataStart8.get();
778     return m_currentCharacter16 - m_dataStart16.get();
779 }
780
781 inline UChar CSSParser::tokenStartChar()
782 {
783     if (is8BitSource())
784         return *m_tokenStart.ptr8;
785     return *m_tokenStart.ptr16;
786 }
787
788 inline bool isCustomPropertyName(const String& propertyName)
789 {
790     return propertyName.length() > 2 && propertyName.characterAt(0) == '-' && propertyName.characterAt(1) == '-';
791 }
792
793 inline int cssyylex(void* yylval, CSSParser* parser)
794 {
795     return parser->lex(yylval);
796 }
797
798 } // namespace WebCore