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