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