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