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