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