fc9ff43a7bbf2ee298aee14eb65b836b4c681a2f
[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 #if ENABLE(CSS_SHAPES)
259     RefPtr<CSSValue> parseShapeProperty(CSSPropertyID);
260 #endif
261
262     RefPtr<CSSValueList> parseBasicShapeAndOrBox(CSSPropertyID propId);
263     RefPtr<CSSPrimitiveValue> parseBasicShape();
264     RefPtr<CSSPrimitiveValue> parseShapeRadius(CSSParserValue&);
265     RefPtr<CSSBasicShapeCircle> parseBasicShapeCircle(CSSParserValueList&);
266     RefPtr<CSSBasicShapeEllipse> parseBasicShapeEllipse(CSSParserValueList&);
267     RefPtr<CSSBasicShapePolygon> parseBasicShapePolygon(CSSParserValueList&);
268     RefPtr<CSSBasicShapePath> parseBasicShapePath(CSSParserValueList&);
269     RefPtr<CSSBasicShapeInset> parseBasicShapeInset(CSSParserValueList&);
270
271     bool parseFont(bool important);
272     void parseSystemFont(bool important);
273     RefPtr<CSSValueList> parseFontFamily();
274
275     bool parseCounter(CSSPropertyID, int defaultValue, bool important);
276     RefPtr<CSSPrimitiveValue> parseCounterContent(CSSParserValueList& args, bool counters);
277
278     bool parseRGBParameters(CSSParserValue&, int* colorValues, bool parseAlpha);
279     bool parseHSLParameters(CSSParserValue&, double* colorValues, bool parseAlpha);
280     RefPtr<CSSPrimitiveValue> parseColor(CSSParserValue* = nullptr);
281     Color parseColorFromValue(CSSParserValue&);
282     void parseSelector(const String&, CSSSelectorList&);
283
284     template<typename StringType>
285     static Color fastParseColor(const StringType&, bool strict);
286
287     bool parseLineHeight(bool important);
288     bool parseFontSize(bool important);
289     bool parseFontWeight(bool important);
290     bool parseFontSynthesis(bool important);
291     bool parseFontFaceSrc();
292     bool parseFontFaceUnicodeRange();
293
294     bool parseSVGValue(CSSPropertyID propId, bool important);
295     RefPtr<SVGPaint> parseSVGPaint();
296     RefPtr<SVGColor> parseSVGColor();
297     RefPtr<CSSValueList> parseSVGStrokeDasharray();
298     RefPtr<CSSValueList> parsePaintOrder();
299
300     // CSS3 Parsing Routines (for properties specific to CSS3)
301     RefPtr<CSSValueList> parseShadow(CSSParserValueList&, CSSPropertyID);
302     bool parseBorderImage(CSSPropertyID, RefPtr<CSSValue>&, bool important = false);
303     bool parseBorderImageRepeat(RefPtr<CSSValue>&);
304     bool parseBorderImageSlice(CSSPropertyID, RefPtr<CSSBorderImageSliceValue>&);
305     bool parseBorderImageWidth(RefPtr<CSSPrimitiveValue>&);
306     bool parseBorderImageOutset(RefPtr<CSSPrimitiveValue>&);
307     bool parseBorderRadius(CSSPropertyID, bool important);
308
309     bool parseAspectRatio(bool important);
310
311     bool parseReflect(CSSPropertyID, bool important);
312
313     bool parseFlex(CSSParserValueList& args, bool important);
314
315     // Image generators
316     bool parseCanvas(CSSParserValueList&, RefPtr<CSSValue>&);
317     bool parseNamedImage(CSSParserValueList&, RefPtr<CSSValue>&);
318
319     bool parseDeprecatedGradient(CSSParserValueList&, RefPtr<CSSValue>&);
320     bool parseDeprecatedLinearGradient(CSSParserValueList&, RefPtr<CSSValue>&, CSSGradientRepeat repeating);
321     bool parseDeprecatedRadialGradient(CSSParserValueList&, RefPtr<CSSValue>&, CSSGradientRepeat repeating);
322     bool parseLinearGradient(CSSParserValueList&, RefPtr<CSSValue>&, CSSGradientRepeat repeating);
323     bool parseRadialGradient(CSSParserValueList&, RefPtr<CSSValue>&, CSSGradientRepeat repeating);
324     bool parseGradientColorStops(CSSParserValueList&, CSSGradientValue&, bool expectComma);
325
326     bool parseCrossfade(CSSParserValueList&, RefPtr<CSSValue>&, bool prefixed);
327
328 #if ENABLE(CSS_IMAGE_RESOLUTION)
329     RefPtr<CSSValueList> parseImageResolution();
330 #endif
331
332     RefPtr<CSSImageSetValue> parseImageSet();
333
334     bool parseFilterImage(CSSParserValueList&, RefPtr<CSSValue>&);
335
336     bool parseFilter(CSSParserValueList&, RefPtr<CSSValueList>&);
337     RefPtr<WebKitCSSFilterValue> parseBuiltinFilterArguments(CSSParserValueList&, WebKitCSSFilterValue::FilterOperationType);
338
339     RefPtr<CSSValue> parseClipPath();
340
341     static bool isBlendMode(CSSValueID);
342     static bool isCompositeOperator(CSSValueID);
343
344     RefPtr<CSSValueList> parseTransform();
345     RefPtr<WebKitCSSTransformValue> parseTransformValue(CSSParserValue&);
346     bool parseTransformOrigin(CSSPropertyID propId, CSSPropertyID& propId1, CSSPropertyID& propId2, CSSPropertyID& propId3, RefPtr<CSSPrimitiveValue>&, RefPtr<CSSPrimitiveValue>&, RefPtr<CSSValue>&);
347     bool parsePerspectiveOrigin(CSSPropertyID propId, CSSPropertyID& propId1, CSSPropertyID& propId2,  RefPtr<CSSPrimitiveValue>&, RefPtr<CSSPrimitiveValue>&);
348
349     bool parseTextEmphasisStyle(bool important);
350     bool parseTextEmphasisPosition(bool important);
351
352     void addTextDecorationProperty(CSSPropertyID, RefPtr<CSSValue>&&, bool important);
353     bool parseTextDecoration(CSSPropertyID propId, bool important);
354     bool parseTextDecorationSkip(bool important);
355     bool parseTextUnderlinePosition(bool important);
356
357     RefPtr<CSSValueList> parseTextIndent();
358     
359     bool parseHangingPunctuation(bool important);
360
361     bool parseLineBoxContain(bool important);
362     RefPtr<CSSCalcValue> parseCalculation(CSSParserValue&, ValueRange);
363
364     bool parseFontFeatureTag(CSSValueList&);
365     bool parseFontFeatureSettings(bool important);
366
367     bool parseFontVariationTag(CSSValueList&);
368     bool parseFontVariationSettings(bool important);
369
370     bool parseFlowThread(CSSPropertyID, bool important);
371     bool parseRegionThread(CSSPropertyID, bool important);
372
373     bool parseFontVariantLigatures(bool important, bool unknownIsFailure, bool implicit);
374     bool parseFontVariantNumeric(bool important, bool unknownIsFailure, bool implicit);
375     bool parseFontVariantEastAsian(bool important, bool unknownIsFailure, bool implicit);
376     bool parseFontVariant(bool important);
377
378     bool parseWillChange(bool important);
379
380     // Faster than doing a new/delete each time since it keeps one vector.
381     std::unique_ptr<Vector<std::unique_ptr<CSSParserSelector>>> createSelectorVector();
382     void recycleSelectorVector(std::unique_ptr<Vector<std::unique_ptr<CSSParserSelector>>>);
383
384     RefPtr<StyleRuleImport> createImportRule(const CSSParserString&, RefPtr<MediaQuerySet>&&);
385     RefPtr<StyleKeyframe> createKeyframe(CSSParserValueList&);
386     Ref<StyleRuleKeyframes> createKeyframesRule(const String&, std::unique_ptr<Vector<RefPtr<StyleKeyframe>>>);
387
388     typedef Vector<RefPtr<StyleRuleBase>> RuleList;
389     Ref<StyleRuleMedia> createMediaRule(RefPtr<MediaQuerySet>&&, RuleList*);
390     Ref<StyleRuleMedia> createEmptyMediaRule(RuleList*);
391     RefPtr<StyleRule> createStyleRule(Vector<std::unique_ptr<CSSParserSelector>>* selectors);
392     RefPtr<StyleRuleFontFace> createFontFaceRule();
393     RefPtr<StyleRulePage> createPageRule(std::unique_ptr<CSSParserSelector> pageSelector);
394     RefPtr<StyleRuleRegion> createRegionRule(Vector<std::unique_ptr<CSSParserSelector>>* regionSelector, RuleList* rules);
395     void createMarginAtRule(CSSSelector::MarginBoxType);
396     Ref<StyleRuleSupports> createSupportsRule(bool conditionIsSupported, RuleList*);
397     void markSupportsRuleHeaderStart();
398     void markSupportsRuleHeaderEnd();
399     Ref<CSSRuleSourceData> popSupportsRuleData();
400
401     void startDeclarationsForMarginBox();
402     void endDeclarationsForMarginBox();
403
404     void addNamespace(const AtomicString& prefix, const AtomicString& uri);
405     QualifiedName determineNameInNamespace(const AtomicString& prefix, const AtomicString& localName);
406
407     void rewriteSpecifiersWithElementName(const AtomicString& namespacePrefix, const AtomicString& elementName, CSSParserSelector&);
408     void rewriteSpecifiersWithElementName(const QualifiedName& tagName, CSSParserSelector&, bool isNamespacePlaceholder = false);
409     void rewriteSpecifiersWithNamespaceIfNeeded(CSSParserSelector&);
410     std::unique_ptr<CSSParserSelector> rewriteSpecifiers(std::unique_ptr<CSSParserSelector>, std::unique_ptr<CSSParserSelector>);
411
412     void invalidBlockHit();
413
414     void updateLastSelectorLineAndPosition();
415     void updateLastMediaLine(MediaQuerySet&);
416
417     void clearProperties();
418
419     Ref<ImmutableStyleProperties> createStyleProperties();
420
421     static const unsigned invalidParsedPropertiesCount;
422
423     CSSParserContext m_context;
424
425     bool m_important { false };
426     CSSPropertyID m_id { CSSPropertyInvalid };
427     AtomicString m_customPropertyName;
428     StyleSheetContents* m_styleSheet { nullptr };
429     RefPtr<StyleRuleBase> m_rule;
430     RefPtr<StyleKeyframe> m_keyframe;
431     std::unique_ptr<MediaQuery> m_mediaQuery;
432     std::unique_ptr<CSSParserValueList> m_valueList;
433     bool m_supportsCondition { false };
434
435     ParsedPropertyVector m_parsedProperties;
436     CSSSelectorList* m_selectorListForParseSelector { nullptr };
437
438     unsigned m_numParsedPropertiesBeforeMarginBox { invalidParsedPropertiesCount };
439
440     int m_inParseShorthand { 0 };
441     CSSPropertyID m_currentShorthand { CSSPropertyInvalid };
442     bool m_implicitShorthand { false };
443
444     bool m_hadSyntacticallyValidCSSRule { false };
445     bool m_logErrors { false };
446     bool m_ignoreErrorsInDeclaration { false };
447
448     AtomicString m_defaultNamespace { starAtom };
449
450     // tokenizer methods and data
451     size_t m_parsedTextPrefixLength { 0 };
452     unsigned m_nestedSelectorLevel { 0 };
453     SourceRange m_selectorRange;
454     SourceRange m_propertyRange { std::numeric_limits<unsigned>::max(), std::numeric_limits<unsigned>::max() };
455     std::unique_ptr<RuleSourceDataList> m_currentRuleDataStack;
456     RefPtr<CSSRuleSourceData> m_currentRuleData;
457     RuleSourceDataList* m_ruleSourceDataResult { nullptr };
458
459     void fixUnparsedPropertyRanges(CSSRuleSourceData&);
460     void markRuleHeaderStart(CSSRuleSourceData::Type);
461     void markRuleHeaderEnd();
462
463     void startNestedSelectorList() { ++m_nestedSelectorLevel; }
464     void endNestedSelectorList() { --m_nestedSelectorLevel; }
465     void markSelectorStart();
466     void markSelectorEnd();
467
468     void markRuleBodyStart();
469     void markRuleBodyEnd();
470     void markPropertyStart();
471     void markPropertyEnd(bool isImportantFound, bool isPropertyParsed);
472     void processAndAddNewRuleToSourceTreeIfNeeded();
473     void addNewRuleToSourceTree(Ref<CSSRuleSourceData>&&);
474     RefPtr<CSSRuleSourceData> popRuleData();
475     void resetPropertyRange() { m_propertyRange.start = m_propertyRange.end = std::numeric_limits<unsigned>::max(); }
476     bool isExtractingSourceData() const { return !!m_currentRuleDataStack; }
477     void syntaxError(const Location&, SyntaxErrorType = GeneralSyntaxError);
478
479     inline int lex(void* yylval) { return (this->*m_lexFunc)(yylval); }
480
481     int token() { return m_token; }
482
483 #if ENABLE(CSS_DEVICE_ADAPTATION)
484     void markViewportRuleBodyStart() { m_inViewport = true; }
485     void markViewportRuleBodyEnd() { m_inViewport = false; }
486     Ref<StyleRuleViewport> createViewportRule();
487 #endif
488
489     Ref<CSSPrimitiveValue> createPrimitiveNumericValue(ValueWithCalculation&);
490     Ref<CSSPrimitiveValue> createPrimitiveStringValue(CSSParserValue&);
491
492     static URL completeURL(const CSSParserContext&, const String& url);
493
494     Location currentLocation();
495     static bool isCalculation(CSSParserValue&);
496
497     void setCustomPropertyName(const AtomicString& propertyName) { m_customPropertyName = propertyName; }
498
499     RefPtr<CSSValue> parseVariableDependentValue(CSSPropertyID, const CSSVariableDependentValue&, const CustomPropertyValueMap& customProperties, TextDirection, WritingMode);
500
501 private:
502     bool is8BitSource() { return m_is8BitSource; }
503
504     template <typename SourceCharacterType>
505     int realLex(void* yylval);
506
507     UChar*& currentCharacter16();
508
509     template <typename CharacterType>
510     inline CharacterType*& currentCharacter();
511
512     template <typename CharacterType>
513     inline CharacterType* tokenStart();
514
515     template <typename CharacterType>
516     inline void setTokenStart(CharacterType*);
517
518     inline unsigned tokenStartOffset();
519     inline UChar tokenStartChar();
520
521     inline unsigned currentCharacterOffset();
522
523     template <typename CharacterType>
524     inline bool isIdentifierStart();
525
526     template <typename CharacterType>
527     unsigned parseEscape(CharacterType*&);
528     template <typename DestCharacterType>
529     inline void UnicodeToChars(DestCharacterType*&, unsigned);
530     template <typename SrcCharacterType, typename DestCharacterType>
531     inline bool parseIdentifierInternal(SrcCharacterType*&, DestCharacterType*&, bool&);
532
533     template <typename CharacterType>
534     inline void parseIdentifier(CharacterType*&, CSSParserString&, bool&);
535
536     template <typename SrcCharacterType, typename DestCharacterType>
537     inline bool parseStringInternal(SrcCharacterType*&, DestCharacterType*&, UChar);
538
539     template <typename CharacterType>
540     inline void parseString(CharacterType*&, CSSParserString& resultString, UChar);
541
542     template <typename CharacterType>
543     inline bool findURI(CharacterType*& start, CharacterType*& end, UChar& quote);
544
545     template <typename SrcCharacterType, typename DestCharacterType>
546     inline bool parseURIInternal(SrcCharacterType*&, DestCharacterType*&, UChar quote);
547
548     template <typename CharacterType>
549     inline void parseURI(CSSParserString&);
550     template <typename CharacterType>
551     inline bool parseUnicodeRange();
552     template <typename CharacterType>
553     bool parseNthChild();
554     template <typename CharacterType>
555     bool parseNthChildExtra();
556     template <typename CharacterType>
557     inline bool detectFunctionTypeToken(int);
558     template <typename CharacterType>
559     inline void detectMediaQueryToken(int);
560     template <typename CharacterType>
561     inline void detectNumberToken(CharacterType*, int);
562     template <typename CharacterType>
563     inline void detectDashToken(int);
564     template <typename CharacterType>
565     inline void detectAtToken(int, bool);
566     template <typename CharacterType>
567     inline void detectSupportsToken(int);
568
569     template <typename CharacterType>
570     inline void setRuleHeaderEnd(const CharacterType*);
571
572     void setStyleSheet(StyleSheetContents* styleSheet) { m_styleSheet = styleSheet; }
573
574     inline bool inStrictMode() const { return m_context.mode == UASheetMode || m_context.mode == HTMLStandardMode || m_context.mode == SVGAttributeMode; }
575     inline bool inQuirksMode() const { return m_context.mode == HTMLQuirksMode; }
576     
577     URL completeURL(const String& url) const;
578
579     void recheckAtKeyword(const UChar* str, int len);
580
581     template<unsigned prefixLength, unsigned suffixLength>
582     void setupParser(const char (&prefix)[prefixLength], StringView string, const char (&suffix)[suffixLength])
583     {
584         setupParser(prefix, prefixLength - 1, string, suffix, suffixLength - 1);
585     }
586     void setupParser(const char* prefix, unsigned prefixLength, StringView, const char* suffix, unsigned suffixLength);
587     bool inShorthand() const { return m_inParseShorthand; }
588
589     bool isValidSize(ValueWithCalculation&);
590
591     bool isGeneratedImageValue(CSSParserValue&) const;
592     bool parseGeneratedImage(CSSParserValueList&, RefPtr<CSSValue>&);
593
594     ParseResult parseValue(MutableStyleProperties&, CSSPropertyID, const String&, bool important, StyleSheetContents* contextStyleSheet);
595     Ref<ImmutableStyleProperties> parseDeclaration(const String&, StyleSheetContents* contextStyleSheet);
596
597     RefPtr<CSSBasicShapeInset> parseInsetRoundedCorners(Ref<CSSBasicShapeInset>&&, CSSParserValueList&);
598
599     enum SizeParameterType {
600         None,
601         Auto,
602         Length,
603         PageSize,
604         Orientation,
605     };
606
607     bool parsePage(CSSPropertyID propId, bool important);
608     bool parseSize(CSSPropertyID propId, bool important);
609     SizeParameterType parseSizeParameter(CSSValueList& parsedValues, CSSParserValue&, SizeParameterType prevParamType);
610
611 #if ENABLE(CSS_SCROLL_SNAP)
612     bool parseNonElementSnapPoints(CSSPropertyID propId, bool important);
613     bool parseScrollSnapDestination(CSSPropertyID propId, bool important);
614     bool parseScrollSnapCoordinate(CSSPropertyID propId, bool important);
615     bool parseScrollSnapPositions(RefPtr<CSSValue>& cssValueX, RefPtr<CSSValue>& cssValueY);
616 #endif
617
618     bool parseFontFaceSrcURI(CSSValueList&);
619     bool parseFontFaceSrcLocal(CSSValueList&);
620
621     bool parseColorFromString(const String&);
622
623 #if ENABLE(CSS_GRID_LAYOUT)
624     bool parseIntegerOrCustomIdentFromGridPosition(RefPtr<CSSPrimitiveValue>& numericValue, RefPtr<CSSPrimitiveValue>& gridLineName);
625 #endif
626
627     enum ParsingMode {
628         NormalMode,
629         MediaQueryMode,
630         SupportsMode,
631         NthChildMode
632     };
633
634     ParsingMode m_parsingMode { NormalMode };
635     bool m_is8BitSource { false };
636     std::unique_ptr<LChar[]> m_dataStart8;
637     std::unique_ptr<UChar[]> m_dataStart16;
638     LChar* m_currentCharacter8 { nullptr };
639     UChar* m_currentCharacter16 { nullptr };
640     union {
641         LChar* ptr8;
642         UChar* ptr16;
643     } m_tokenStart { nullptr };
644     unsigned m_length { 0 };
645     int m_token { 0 };
646     int m_lineNumber { 0 };
647     int m_tokenStartLineNumber { 0 };
648     int m_tokenStartColumnNumber { 0 };
649     int m_lastSelectorLineNumber { 0 };
650     int m_columnOffsetForLine { 0 };
651
652     int m_sheetStartLineNumber { 0 };
653     int m_sheetStartColumnNumber { 0 };
654
655     bool m_allowImportRules { true };
656     bool m_allowNamespaceDeclarations { true };
657
658 #if ENABLE(CSS_DEVICE_ADAPTATION)
659     bool parseViewportProperty(CSSPropertyID propId, bool important);
660     bool parseViewportShorthand(CSSPropertyID propId, CSSPropertyID first, CSSPropertyID second, bool important);
661
662     bool inViewport() const { return m_inViewport; }
663     bool m_inViewport { false };
664 #endif
665
666     bool useLegacyBackgroundSizeShorthandBehavior() const;
667
668     int (CSSParser::*m_lexFunc)(void*);
669
670     std::unique_ptr<Vector<std::unique_ptr<CSSParserSelector>>> m_recycledSelectorVector;
671
672     std::unique_ptr<RuleSourceDataList> m_supportsRuleDataStack;
673
674     // defines units allowed for a certain property, used in parseUnit
675     enum Units {
676         FUnknown = 0x0000,
677         FInteger = 0x0001,
678         FNumber = 0x0002, // Real Numbers
679         FPercent = 0x0004,
680         FLength = 0x0008,
681         FAngle = 0x0010,
682         FTime = 0x0020,
683         FFrequency = 0x0040,
684         FPositiveInteger = 0x0080,
685         FRelative = 0x0100,
686 #if ENABLE(CSS_IMAGE_RESOLUTION) || ENABLE(RESOLUTION_MEDIA_QUERY)
687         FResolution = 0x0200,
688 #endif
689         FNonNeg = 0x0400
690     };
691
692     friend inline Units operator|(Units a, Units b)
693     {
694         return static_cast<Units>(static_cast<unsigned>(a) | static_cast<unsigned>(b));
695     }
696
697     enum ReleaseParsedCalcValueCondition {
698         ReleaseParsedCalcValue,
699         DoNotReleaseParsedCalcValue
700     };
701
702     bool isLoggingErrors();
703     void logError(const String& message, int lineNumber, int columnNumber);
704
705     bool validateCalculationUnit(ValueWithCalculation&, Units);
706
707     bool shouldAcceptUnitLessValues(CSSParserValue&, Units, CSSParserMode);
708
709     inline bool validateUnit(ValueWithCalculation& value, Units unitFlags) { return validateUnit(value, unitFlags, m_context.mode); }
710     bool validateUnit(ValueWithCalculation&, Units, CSSParserMode);
711
712     bool parseBorderImageQuad(Units, RefPtr<CSSPrimitiveValue>&);
713     int colorIntFromValue(ValueWithCalculation&);
714     double parsedDouble(ValueWithCalculation&);
715     
716     friend class TransformOperationInfo;
717     friend class FilterOperationInfo;
718 };
719
720 CSSPropertyID cssPropertyID(const CSSParserString&);
721 CSSPropertyID cssPropertyID(const String&);
722 CSSValueID cssValueKeywordID(const CSSParserString&);
723 #if PLATFORM(IOS)
724 void cssPropertyNameIOSAliasing(const char* propertyName, const char*& propertyNameAlias, unsigned& newLength);
725 #endif
726
727 class ShorthandScope {
728     WTF_MAKE_FAST_ALLOCATED;
729 public:
730     ShorthandScope(CSSParser* parser, CSSPropertyID propId) : m_parser(parser)
731     {
732         if (!(m_parser->m_inParseShorthand++))
733             m_parser->m_currentShorthand = propId;
734     }
735     ~ShorthandScope()
736     {
737         if (!(--m_parser->m_inParseShorthand))
738             m_parser->m_currentShorthand = CSSPropertyInvalid;
739     }
740
741 private:
742     CSSParser* m_parser;
743 };
744
745 struct CSSParser::Location {
746     int lineNumber;
747     int columnNumber;
748     CSSParserString token;
749 };
750
751 String quoteCSSString(const String&);
752 String quoteCSSStringIfNeeded(const String&);
753 String quoteCSSURLIfNeeded(const String&);
754
755 bool isValidNthToken(const CSSParserString&);
756
757 template <>
758 inline void CSSParser::setTokenStart<LChar>(LChar* tokenStart)
759 {
760     m_tokenStart.ptr8 = tokenStart;
761 }
762
763 template <>
764 inline void CSSParser::setTokenStart<UChar>(UChar* tokenStart)
765 {
766     m_tokenStart.ptr16 = tokenStart;
767 }
768
769 inline unsigned CSSParser::tokenStartOffset()
770 {
771     if (is8BitSource())
772         return m_tokenStart.ptr8 - m_dataStart8.get();
773     return m_tokenStart.ptr16 - m_dataStart16.get();
774 }
775
776 unsigned CSSParser::currentCharacterOffset()
777 {
778     if (is8BitSource())
779         return m_currentCharacter8 - m_dataStart8.get();
780     return m_currentCharacter16 - m_dataStart16.get();
781 }
782
783 inline UChar CSSParser::tokenStartChar()
784 {
785     if (is8BitSource())
786         return *m_tokenStart.ptr8;
787     return *m_tokenStart.ptr16;
788 }
789
790 inline bool isCustomPropertyName(const String& propertyName)
791 {
792     return propertyName.length() > 2 && propertyName.characterAt(0) == '-' && propertyName.characterAt(1) == '-';
793 }
794
795 inline int cssyylex(void* yylval, CSSParser* parser)
796 {
797     return parser->lex(yylval);
798 }
799
800 } // namespace WebCore