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