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