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