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