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