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