Rename IOS_TEXT_AUTOSIZING to TEXT_AUTOSIZING
[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, CSSParserMode, StyleSheetContents*);
135     static ParseResult parseCustomPropertyValue(MutableStyleProperties&, const AtomicString& propertyName, const String&, bool important, CSSParserMode, StyleSheetContents* contextStyleSheet);
136
137     static bool parseColor(RGBA32& color, const String&, bool strict = false);
138     static bool isValidSystemColorValue(CSSValueID);
139     static bool parseSystemColor(RGBA32& color, 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     bool parseColorFromValue(CSSParserValue&, RGBA32&);
282     void parseSelector(const String&, CSSSelectorList&);
283
284     template<typename StringType>
285     static bool fastParseColor(RGBA32&, 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 parseFlowThread(CSSPropertyID, bool important);
368     bool parseRegionThread(CSSPropertyID, bool important);
369
370     bool parseFontVariantLigatures(bool important, bool unknownIsFailure, bool implicit);
371     bool parseFontVariantNumeric(bool important, bool unknownIsFailure, bool implicit);
372     bool parseFontVariantEastAsian(bool important, bool unknownIsFailure, bool implicit);
373     bool parseFontVariant(bool important);
374
375     bool parseWillChange(bool important);
376
377     // Faster than doing a new/delete each time since it keeps one vector.
378     std::unique_ptr<Vector<std::unique_ptr<CSSParserSelector>>> createSelectorVector();
379     void recycleSelectorVector(std::unique_ptr<Vector<std::unique_ptr<CSSParserSelector>>>);
380
381     RefPtr<StyleRuleImport> createImportRule(const CSSParserString&, RefPtr<MediaQuerySet>&&);
382     RefPtr<StyleKeyframe> createKeyframe(CSSParserValueList&);
383     Ref<StyleRuleKeyframes> createKeyframesRule(const String&, std::unique_ptr<Vector<RefPtr<StyleKeyframe>>>);
384
385     typedef Vector<RefPtr<StyleRuleBase>> RuleList;
386     Ref<StyleRuleMedia> createMediaRule(RefPtr<MediaQuerySet>&&, RuleList*);
387     Ref<StyleRuleMedia> createEmptyMediaRule(RuleList*);
388     RefPtr<StyleRule> createStyleRule(Vector<std::unique_ptr<CSSParserSelector>>* selectors);
389     RefPtr<StyleRuleFontFace> createFontFaceRule();
390     RefPtr<StyleRulePage> createPageRule(std::unique_ptr<CSSParserSelector> pageSelector);
391     RefPtr<StyleRuleRegion> createRegionRule(Vector<std::unique_ptr<CSSParserSelector>>* regionSelector, RuleList* rules);
392     void createMarginAtRule(CSSSelector::MarginBoxType);
393     Ref<StyleRuleSupports> createSupportsRule(bool conditionIsSupported, RuleList*);
394     void markSupportsRuleHeaderStart();
395     void markSupportsRuleHeaderEnd();
396     Ref<CSSRuleSourceData> popSupportsRuleData();
397
398     void startDeclarationsForMarginBox();
399     void endDeclarationsForMarginBox();
400
401     void addNamespace(const AtomicString& prefix, const AtomicString& uri);
402     QualifiedName determineNameInNamespace(const AtomicString& prefix, const AtomicString& localName);
403
404     void rewriteSpecifiersWithElementName(const AtomicString& namespacePrefix, const AtomicString& elementName, CSSParserSelector&);
405     void rewriteSpecifiersWithElementName(const QualifiedName& tagName, CSSParserSelector&, bool isNamespacePlaceholder = false);
406     void rewriteSpecifiersWithNamespaceIfNeeded(CSSParserSelector&);
407     std::unique_ptr<CSSParserSelector> rewriteSpecifiers(std::unique_ptr<CSSParserSelector>, std::unique_ptr<CSSParserSelector>);
408
409     void invalidBlockHit();
410
411     void updateLastSelectorLineAndPosition();
412     void updateLastMediaLine(MediaQuerySet&);
413
414     void clearProperties();
415
416     Ref<ImmutableStyleProperties> createStyleProperties();
417
418     static const unsigned invalidParsedPropertiesCount;
419
420     CSSParserContext m_context;
421
422     bool m_important { false };
423     CSSPropertyID m_id { CSSPropertyInvalid };
424     AtomicString m_customPropertyName;
425     StyleSheetContents* m_styleSheet { nullptr };
426     RefPtr<StyleRuleBase> m_rule;
427     RefPtr<StyleKeyframe> m_keyframe;
428     std::unique_ptr<MediaQuery> m_mediaQuery;
429     std::unique_ptr<CSSParserValueList> m_valueList;
430     bool m_supportsCondition { false };
431
432     ParsedPropertyVector m_parsedProperties;
433     CSSSelectorList* m_selectorListForParseSelector { nullptr };
434
435     unsigned m_numParsedPropertiesBeforeMarginBox { invalidParsedPropertiesCount };
436
437     int m_inParseShorthand { 0 };
438     CSSPropertyID m_currentShorthand { CSSPropertyInvalid };
439     bool m_implicitShorthand { false };
440
441     bool m_hadSyntacticallyValidCSSRule { false };
442     bool m_logErrors { false };
443     bool m_ignoreErrorsInDeclaration { false };
444
445     AtomicString m_defaultNamespace { starAtom };
446
447     // tokenizer methods and data
448     size_t m_parsedTextPrefixLength { 0 };
449     unsigned m_nestedSelectorLevel { 0 };
450     SourceRange m_selectorRange;
451     SourceRange m_propertyRange { std::numeric_limits<unsigned>::max(), std::numeric_limits<unsigned>::max() };
452     std::unique_ptr<RuleSourceDataList> m_currentRuleDataStack;
453     RefPtr<CSSRuleSourceData> m_currentRuleData;
454     RuleSourceDataList* m_ruleSourceDataResult { nullptr };
455
456     void fixUnparsedPropertyRanges(CSSRuleSourceData&);
457     void markRuleHeaderStart(CSSRuleSourceData::Type);
458     void markRuleHeaderEnd();
459
460     void startNestedSelectorList() { ++m_nestedSelectorLevel; }
461     void endNestedSelectorList() { --m_nestedSelectorLevel; }
462     void markSelectorStart();
463     void markSelectorEnd();
464
465     void markRuleBodyStart();
466     void markRuleBodyEnd();
467     void markPropertyStart();
468     void markPropertyEnd(bool isImportantFound, bool isPropertyParsed);
469     void processAndAddNewRuleToSourceTreeIfNeeded();
470     void addNewRuleToSourceTree(Ref<CSSRuleSourceData>&&);
471     RefPtr<CSSRuleSourceData> popRuleData();
472     void resetPropertyRange() { m_propertyRange.start = m_propertyRange.end = std::numeric_limits<unsigned>::max(); }
473     bool isExtractingSourceData() const { return !!m_currentRuleDataStack; }
474     void syntaxError(const Location&, SyntaxErrorType = GeneralSyntaxError);
475
476     inline int lex(void* yylval) { return (this->*m_lexFunc)(yylval); }
477
478     int token() { return m_token; }
479
480 #if ENABLE(CSS_DEVICE_ADAPTATION)
481     void markViewportRuleBodyStart() { m_inViewport = true; }
482     void markViewportRuleBodyEnd() { m_inViewport = false; }
483     Ref<StyleRuleViewport> createViewportRule();
484 #endif
485
486     Ref<CSSPrimitiveValue> createPrimitiveNumericValue(ValueWithCalculation&);
487     Ref<CSSPrimitiveValue> createPrimitiveStringValue(CSSParserValue&);
488
489     static URL completeURL(const CSSParserContext&, const String& url);
490
491     Location currentLocation();
492     static bool isCalculation(CSSParserValue&);
493
494     void setCustomPropertyName(const AtomicString& propertyName) { m_customPropertyName = propertyName; }
495
496     RefPtr<CSSValue> parseVariableDependentValue(CSSPropertyID, const CSSVariableDependentValue&, const CustomPropertyValueMap& customProperties, TextDirection, WritingMode);
497
498 private:
499     bool is8BitSource() { return m_is8BitSource; }
500
501     template <typename SourceCharacterType>
502     int realLex(void* yylval);
503
504     UChar*& currentCharacter16();
505
506     template <typename CharacterType>
507     inline CharacterType*& currentCharacter();
508
509     template <typename CharacterType>
510     inline CharacterType* tokenStart();
511
512     template <typename CharacterType>
513     inline void setTokenStart(CharacterType*);
514
515     inline unsigned tokenStartOffset();
516     inline UChar tokenStartChar();
517
518     inline unsigned currentCharacterOffset();
519
520     template <typename CharacterType>
521     inline bool isIdentifierStart();
522
523     template <typename CharacterType>
524     unsigned parseEscape(CharacterType*&);
525     template <typename DestCharacterType>
526     inline void UnicodeToChars(DestCharacterType*&, unsigned);
527     template <typename SrcCharacterType, typename DestCharacterType>
528     inline bool parseIdentifierInternal(SrcCharacterType*&, DestCharacterType*&, bool&);
529
530     template <typename CharacterType>
531     inline void parseIdentifier(CharacterType*&, CSSParserString&, bool&);
532
533     template <typename SrcCharacterType, typename DestCharacterType>
534     inline bool parseStringInternal(SrcCharacterType*&, DestCharacterType*&, UChar);
535
536     template <typename CharacterType>
537     inline void parseString(CharacterType*&, CSSParserString& resultString, UChar);
538
539     template <typename CharacterType>
540     inline bool findURI(CharacterType*& start, CharacterType*& end, UChar& quote);
541
542     template <typename SrcCharacterType, typename DestCharacterType>
543     inline bool parseURIInternal(SrcCharacterType*&, DestCharacterType*&, UChar quote);
544
545     template <typename CharacterType>
546     inline void parseURI(CSSParserString&);
547     template <typename CharacterType>
548     inline bool parseUnicodeRange();
549     template <typename CharacterType>
550     bool parseNthChild();
551     template <typename CharacterType>
552     bool parseNthChildExtra();
553     template <typename CharacterType>
554     inline bool detectFunctionTypeToken(int);
555     template <typename CharacterType>
556     inline void detectMediaQueryToken(int);
557     template <typename CharacterType>
558     inline void detectNumberToken(CharacterType*, int);
559     template <typename CharacterType>
560     inline void detectDashToken(int);
561     template <typename CharacterType>
562     inline void detectAtToken(int, bool);
563     template <typename CharacterType>
564     inline void detectSupportsToken(int);
565
566     template <typename CharacterType>
567     inline void setRuleHeaderEnd(const CharacterType*);
568
569     void setStyleSheet(StyleSheetContents* styleSheet) { m_styleSheet = styleSheet; }
570
571     inline bool inStrictMode() const { return m_context.mode == UASheetMode || m_context.mode == HTMLStandardMode || m_context.mode == SVGAttributeMode; }
572     inline bool inQuirksMode() const { return m_context.mode == HTMLQuirksMode; }
573     
574     URL completeURL(const String& url) const;
575
576     void recheckAtKeyword(const UChar* str, int len);
577
578     template<unsigned prefixLength, unsigned suffixLength>
579     void setupParser(const char (&prefix)[prefixLength], StringView string, const char (&suffix)[suffixLength])
580     {
581         setupParser(prefix, prefixLength - 1, string, suffix, suffixLength - 1);
582     }
583     void setupParser(const char* prefix, unsigned prefixLength, StringView, const char* suffix, unsigned suffixLength);
584     bool inShorthand() const { return m_inParseShorthand; }
585
586     bool isValidSize(ValueWithCalculation&);
587
588     bool isGeneratedImageValue(CSSParserValue&) const;
589     bool parseGeneratedImage(CSSParserValueList&, RefPtr<CSSValue>&);
590
591     ParseResult parseValue(MutableStyleProperties&, CSSPropertyID, const String&, bool important, StyleSheetContents* contextStyleSheet);
592     Ref<ImmutableStyleProperties> parseDeclaration(const String&, StyleSheetContents* contextStyleSheet);
593
594     RefPtr<CSSBasicShapeInset> parseInsetRoundedCorners(Ref<CSSBasicShapeInset>&&, CSSParserValueList&);
595
596     enum SizeParameterType {
597         None,
598         Auto,
599         Length,
600         PageSize,
601         Orientation,
602     };
603
604     bool parsePage(CSSPropertyID propId, bool important);
605     bool parseSize(CSSPropertyID propId, bool important);
606     SizeParameterType parseSizeParameter(CSSValueList& parsedValues, CSSParserValue&, SizeParameterType prevParamType);
607
608 #if ENABLE(CSS_SCROLL_SNAP)
609     bool parseNonElementSnapPoints(CSSPropertyID propId, bool important);
610     bool parseScrollSnapDestination(CSSPropertyID propId, bool important);
611     bool parseScrollSnapCoordinate(CSSPropertyID propId, bool important);
612     bool parseScrollSnapPositions(RefPtr<CSSValue>& cssValueX, RefPtr<CSSValue>& cssValueY);
613 #endif
614
615     bool parseFontFaceSrcURI(CSSValueList&);
616     bool parseFontFaceSrcLocal(CSSValueList&);
617
618     bool parseColor(const String&);
619
620 #if ENABLE(CSS_GRID_LAYOUT)
621     bool parseIntegerOrCustomIdentFromGridPosition(RefPtr<CSSPrimitiveValue>& numericValue, RefPtr<CSSPrimitiveValue>& gridLineName);
622 #endif
623
624     enum ParsingMode {
625         NormalMode,
626         MediaQueryMode,
627         SupportsMode,
628         NthChildMode
629     };
630
631     ParsingMode m_parsingMode { NormalMode };
632     bool m_is8BitSource { false };
633     std::unique_ptr<LChar[]> m_dataStart8;
634     std::unique_ptr<UChar[]> m_dataStart16;
635     LChar* m_currentCharacter8 { nullptr };
636     UChar* m_currentCharacter16 { nullptr };
637     union {
638         LChar* ptr8;
639         UChar* ptr16;
640     } m_tokenStart { nullptr };
641     unsigned m_length { 0 };
642     int m_token { 0 };
643     int m_lineNumber { 0 };
644     int m_tokenStartLineNumber { 0 };
645     int m_tokenStartColumnNumber { 0 };
646     int m_lastSelectorLineNumber { 0 };
647     int m_columnOffsetForLine { 0 };
648
649     int m_sheetStartLineNumber { 0 };
650     int m_sheetStartColumnNumber { 0 };
651
652     bool m_allowImportRules { true };
653     bool m_allowNamespaceDeclarations { true };
654
655 #if ENABLE(CSS_DEVICE_ADAPTATION)
656     bool parseViewportProperty(CSSPropertyID propId, bool important);
657     bool parseViewportShorthand(CSSPropertyID propId, CSSPropertyID first, CSSPropertyID second, bool important);
658
659     bool inViewport() const { return m_inViewport; }
660     bool m_inViewport { false };
661 #endif
662
663     bool useLegacyBackgroundSizeShorthandBehavior() const;
664
665     int (CSSParser::*m_lexFunc)(void*);
666
667     std::unique_ptr<Vector<std::unique_ptr<CSSParserSelector>>> m_recycledSelectorVector;
668
669     std::unique_ptr<RuleSourceDataList> m_supportsRuleDataStack;
670
671     // defines units allowed for a certain property, used in parseUnit
672     enum Units {
673         FUnknown = 0x0000,
674         FInteger = 0x0001,
675         FNumber = 0x0002, // Real Numbers
676         FPercent = 0x0004,
677         FLength = 0x0008,
678         FAngle = 0x0010,
679         FTime = 0x0020,
680         FFrequency = 0x0040,
681         FPositiveInteger = 0x0080,
682         FRelative = 0x0100,
683 #if ENABLE(CSS_IMAGE_RESOLUTION) || ENABLE(RESOLUTION_MEDIA_QUERY)
684         FResolution = 0x0200,
685 #endif
686         FNonNeg = 0x0400
687     };
688
689     friend inline Units operator|(Units a, Units b)
690     {
691         return static_cast<Units>(static_cast<unsigned>(a) | static_cast<unsigned>(b));
692     }
693
694     enum ReleaseParsedCalcValueCondition {
695         ReleaseParsedCalcValue,
696         DoNotReleaseParsedCalcValue
697     };
698
699     bool isLoggingErrors();
700     void logError(const String& message, int lineNumber, int columnNumber);
701
702     bool validateCalculationUnit(ValueWithCalculation&, Units);
703
704     bool shouldAcceptUnitLessValues(CSSParserValue&, Units, CSSParserMode);
705
706     inline bool validateUnit(ValueWithCalculation& value, Units unitFlags) { return validateUnit(value, unitFlags, m_context.mode); }
707     bool validateUnit(ValueWithCalculation&, Units, CSSParserMode);
708
709     bool parseBorderImageQuad(Units, RefPtr<CSSPrimitiveValue>&);
710     int colorIntFromValue(ValueWithCalculation&);
711     double parsedDouble(ValueWithCalculation&);
712     
713     friend class TransformOperationInfo;
714     friend class FilterOperationInfo;
715 };
716
717 CSSPropertyID cssPropertyID(const CSSParserString&);
718 CSSPropertyID cssPropertyID(const String&);
719 CSSValueID cssValueKeywordID(const CSSParserString&);
720 #if PLATFORM(IOS)
721 void cssPropertyNameIOSAliasing(const char* propertyName, const char*& propertyNameAlias, unsigned& newLength);
722 #endif
723
724 class ShorthandScope {
725     WTF_MAKE_FAST_ALLOCATED;
726 public:
727     ShorthandScope(CSSParser* parser, CSSPropertyID propId) : m_parser(parser)
728     {
729         if (!(m_parser->m_inParseShorthand++))
730             m_parser->m_currentShorthand = propId;
731     }
732     ~ShorthandScope()
733     {
734         if (!(--m_parser->m_inParseShorthand))
735             m_parser->m_currentShorthand = CSSPropertyInvalid;
736     }
737
738 private:
739     CSSParser* m_parser;
740 };
741
742 struct CSSParser::Location {
743     int lineNumber;
744     int columnNumber;
745     CSSParserString token;
746 };
747
748 String quoteCSSString(const String&);
749 String quoteCSSStringIfNeeded(const String&);
750 String quoteCSSURLIfNeeded(const String&);
751
752 bool isValidNthToken(const CSSParserString&);
753
754 template <>
755 inline void CSSParser::setTokenStart<LChar>(LChar* tokenStart)
756 {
757     m_tokenStart.ptr8 = tokenStart;
758 }
759
760 template <>
761 inline void CSSParser::setTokenStart<UChar>(UChar* tokenStart)
762 {
763     m_tokenStart.ptr16 = tokenStart;
764 }
765
766 inline unsigned CSSParser::tokenStartOffset()
767 {
768     if (is8BitSource())
769         return m_tokenStart.ptr8 - m_dataStart8.get();
770     return m_tokenStart.ptr16 - m_dataStart16.get();
771 }
772
773 unsigned CSSParser::currentCharacterOffset()
774 {
775     if (is8BitSource())
776         return m_currentCharacter8 - m_dataStart8.get();
777     return m_currentCharacter16 - m_dataStart16.get();
778 }
779
780 inline UChar CSSParser::tokenStartChar()
781 {
782     if (is8BitSource())
783         return *m_tokenStart.ptr8;
784     return *m_tokenStart.ptr16;
785 }
786
787 inline bool isCustomPropertyName(const String& propertyName)
788 {
789     return propertyName.length() > 2 && propertyName.characterAt(0) == '-' && propertyName.characterAt(1) == '-';
790 }
791
792 inline int cssyylex(void* yylval, CSSParser* parser)
793 {
794     return parser->lex(yylval);
795 }
796
797 } // namespace WebCore