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