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