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