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 "CSSGradientValue.h" 27 #include "CSSParserValues.h" 28 #include "CSSPropertySourceData.h" 29 #include "CSSSelectorList.h" 30 #include "Color.h" 31 #include "MediaQuery.h" 32 #include <wtf/HashMap.h> 33 #include <wtf/HashSet.h> 34 #include <wtf/Vector.h> 35 #include <wtf/text/AtomicString.h> 36 37 namespace WebCore { 38 39 class CSSMutableStyleDeclaration; 40 class CSSPrimitiveValue; 41 class CSSPrimitiveValueCache; 42 class CSSProperty; 43 class CSSRule; 44 class CSSRuleList; 45 class CSSSelector; 46 class CSSStyleRule; 47 class CSSStyleSheet; 48 class CSSValue; 49 class CSSValueList; 50 class Document; 51 class MediaList; 52 class MediaQueryExp; 53 class StyleBase; 54 class StyleList; 55 class WebKitCSSKeyframeRule; 56 class WebKitCSSKeyframesRule; 57 58 class CSSParser { 59 public: 60 CSSParser(bool strictParsing = true); 61 ~CSSParser(); 62 63 void parseSheet(CSSStyleSheet*, const String&, int startLineNumber = 0, StyleRuleRangeMap* ruleRangeMap = 0); 64 PassRefPtr<CSSRule> parseRule(CSSStyleSheet*, const String&); 65 PassRefPtr<CSSRule> parseKeyframeRule(CSSStyleSheet*, const String&); 66 static bool parseValue(CSSMutableStyleDeclaration*, int propId, const String&, bool important, bool strict); 67 static bool parseColor(RGBA32& color, const String&, bool strict = false); 68 static bool parseSystemColor(RGBA32& color, const String&, Document*); 69 bool parseColor(CSSMutableStyleDeclaration*, const String&); 70 bool parseDeclaration(CSSMutableStyleDeclaration*, const String&, RefPtr<CSSStyleSourceData>* styleSourceData = 0); 71 bool parseMediaQuery(MediaList*, const String&); 72 73 Document* document() const; 74 primitiveValueCache()75 CSSPrimitiveValueCache* primitiveValueCache() const { return m_primitiveValueCache.get(); } 76 77 void addProperty(int propId, PassRefPtr<CSSValue>, bool important); 78 void rollbackLastProperties(int num); hasProperties()79 bool hasProperties() const { return m_numParsedProperties > 0; } 80 81 bool parseValue(int propId, bool important); 82 bool parseShorthand(int propId, const int* properties, int numProperties, bool important); 83 bool parse4Values(int propId, const int* properties, bool important); 84 bool parseContent(int propId, bool important); 85 bool parseQuotes(int propId, bool important); 86 87 PassRefPtr<CSSValue> parseAttr(CSSParserValueList* args); 88 89 PassRefPtr<CSSValue> parseBackgroundColor(); 90 91 bool parseFillImage(RefPtr<CSSValue>&); 92 93 enum FillPositionFlag { InvalidFillPosition = 0, AmbiguousFillPosition = 1, XFillPosition = 2, YFillPosition = 4 }; 94 PassRefPtr<CSSValue> parseFillPositionComponent(CSSParserValueList*, unsigned& cumulativeFlags, FillPositionFlag& individualFlag); 95 PassRefPtr<CSSValue> parseFillPositionX(CSSParserValueList*); 96 PassRefPtr<CSSValue> parseFillPositionY(CSSParserValueList*); 97 void parseFillPosition(CSSParserValueList*, RefPtr<CSSValue>&, RefPtr<CSSValue>&); 98 99 void parseFillRepeat(RefPtr<CSSValue>&, RefPtr<CSSValue>&); 100 PassRefPtr<CSSValue> parseFillSize(int propId, bool &allowComma); 101 102 bool parseFillProperty(int propId, int& propId1, int& propId2, RefPtr<CSSValue>&, RefPtr<CSSValue>&); 103 bool parseFillShorthand(int propId, const int* properties, int numProperties, bool important); 104 105 void addFillValue(RefPtr<CSSValue>& lval, PassRefPtr<CSSValue> rval); 106 107 void addAnimationValue(RefPtr<CSSValue>& lval, PassRefPtr<CSSValue> rval); 108 109 PassRefPtr<CSSValue> parseAnimationDelay(); 110 PassRefPtr<CSSValue> parseAnimationDirection(); 111 PassRefPtr<CSSValue> parseAnimationDuration(); 112 PassRefPtr<CSSValue> parseAnimationFillMode(); 113 PassRefPtr<CSSValue> parseAnimationIterationCount(); 114 PassRefPtr<CSSValue> parseAnimationName(); 115 PassRefPtr<CSSValue> parseAnimationPlayState(); 116 PassRefPtr<CSSValue> parseAnimationProperty(); 117 PassRefPtr<CSSValue> parseAnimationTimingFunction(); 118 119 bool parseTransformOriginShorthand(RefPtr<CSSValue>&, RefPtr<CSSValue>&, RefPtr<CSSValue>&); 120 bool parseCubicBezierTimingFunctionValue(CSSParserValueList*& args, double& result); 121 bool parseAnimationProperty(int propId, RefPtr<CSSValue>&); 122 bool parseTransitionShorthand(bool important); 123 bool parseAnimationShorthand(bool important); 124 125 bool parseDashboardRegions(int propId, bool important); 126 127 bool parseShape(int propId, bool important); 128 129 bool parseFont(bool important); 130 PassRefPtr<CSSValueList> parseFontFamily(); 131 132 bool parseCounter(int propId, int defaultValue, bool important); 133 PassRefPtr<CSSValue> parseCounterContent(CSSParserValueList* args, bool counters); 134 135 bool parseColorParameters(CSSParserValue*, int* colorValues, bool parseAlpha); 136 bool parseHSLParameters(CSSParserValue*, double* colorValues, bool parseAlpha); 137 PassRefPtr<CSSPrimitiveValue> parseColor(CSSParserValue* = 0); 138 bool parseColorFromValue(CSSParserValue*, RGBA32&); 139 void parseSelector(const String&, Document* doc, CSSSelectorList&); 140 141 static bool parseColor(const String&, RGBA32& rgb, bool strict); 142 143 bool parseFontStyle(bool important); 144 bool parseFontVariant(bool important); 145 bool parseFontWeight(bool important); 146 bool parseFontFaceSrc(); 147 bool parseFontFaceUnicodeRange(); 148 149 #if ENABLE(SVG) 150 bool parseSVGValue(int propId, bool important); 151 PassRefPtr<CSSValue> parseSVGPaint(); 152 PassRefPtr<CSSValue> parseSVGColor(); 153 PassRefPtr<CSSValue> parseSVGStrokeDasharray(); 154 #endif 155 156 #if ENABLE(WCSS) 157 PassRefPtr<CSSValue> parseWCSSInputProperty(); 158 #endif 159 160 // CSS3 Parsing Routines (for properties specific to CSS3) 161 bool parseShadow(int propId, bool important); 162 bool parseBorderImage(int propId, bool important, RefPtr<CSSValue>&); 163 bool parseBorderRadius(int propId, bool important); 164 165 bool parseReflect(int propId, bool important); 166 167 // Image generators 168 bool parseCanvas(RefPtr<CSSValue>&); 169 170 bool parseDeprecatedGradient(RefPtr<CSSValue>&); 171 bool parseLinearGradient(RefPtr<CSSValue>&, CSSGradientRepeat repeating); 172 bool parseRadialGradient(RefPtr<CSSValue>&, CSSGradientRepeat repeating); 173 bool parseGradientColorStops(CSSParserValueList*, CSSGradientValue*, bool expectComma); 174 175 PassRefPtr<CSSValueList> parseTransform(); 176 bool parseTransformOrigin(int propId, int& propId1, int& propId2, int& propId3, RefPtr<CSSValue>&, RefPtr<CSSValue>&, RefPtr<CSSValue>&); 177 bool parsePerspectiveOrigin(int propId, int& propId1, int& propId2, RefPtr<CSSValue>&, RefPtr<CSSValue>&); 178 179 bool parseTextEmphasisStyle(bool important); 180 181 bool parseLineBoxContain(bool important); 182 183 int yyparse(); 184 185 CSSParserSelector* createFloatingSelector(); 186 PassOwnPtr<CSSParserSelector> sinkFloatingSelector(CSSParserSelector*); 187 188 Vector<OwnPtr<CSSParserSelector> >* createFloatingSelectorVector(); 189 PassOwnPtr<Vector<OwnPtr<CSSParserSelector> > > sinkFloatingSelectorVector(Vector<OwnPtr<CSSParserSelector> >*); 190 191 CSSParserValueList* createFloatingValueList(); 192 CSSParserValueList* sinkFloatingValueList(CSSParserValueList*); 193 194 CSSParserFunction* createFloatingFunction(); 195 CSSParserFunction* sinkFloatingFunction(CSSParserFunction*); 196 197 CSSParserValue& sinkFloatingValue(CSSParserValue&); 198 199 MediaList* createMediaList(); 200 CSSRule* createCharsetRule(const CSSParserString&); 201 CSSRule* createImportRule(const CSSParserString&, MediaList*); 202 WebKitCSSKeyframeRule* createKeyframeRule(CSSParserValueList*); 203 WebKitCSSKeyframesRule* createKeyframesRule(); 204 CSSRule* createMediaRule(MediaList*, CSSRuleList*); 205 CSSRuleList* createRuleList(); 206 CSSRule* createStyleRule(Vector<OwnPtr<CSSParserSelector> >* selectors); 207 CSSRule* createFontFaceRule(); 208 CSSRule* createPageRule(PassOwnPtr<CSSParserSelector> pageSelector); 209 CSSRule* createMarginAtRule(CSSSelector::MarginBoxType marginBox); 210 void startDeclarationsForMarginBox(); 211 void endDeclarationsForMarginBox(); 212 213 MediaQueryExp* createFloatingMediaQueryExp(const AtomicString&, CSSParserValueList*); 214 PassOwnPtr<MediaQueryExp> sinkFloatingMediaQueryExp(MediaQueryExp*); 215 Vector<OwnPtr<MediaQueryExp> >* createFloatingMediaQueryExpList(); 216 PassOwnPtr<Vector<OwnPtr<MediaQueryExp> > > sinkFloatingMediaQueryExpList(Vector<OwnPtr<MediaQueryExp> >*); 217 MediaQuery* createFloatingMediaQuery(MediaQuery::Restrictor, const String&, PassOwnPtr<Vector<OwnPtr<MediaQueryExp> > >); 218 MediaQuery* createFloatingMediaQuery(PassOwnPtr<Vector<OwnPtr<MediaQueryExp> > >); 219 PassOwnPtr<MediaQuery> sinkFloatingMediaQuery(MediaQuery*); 220 221 void addNamespace(const AtomicString& prefix, const AtomicString& uri); 222 void updateSpecifiersWithElementName(const AtomicString& namespacePrefix, const AtomicString& elementName, CSSParserSelector*); 223 224 void invalidBlockHit(); 225 reusableSelectorVector()226 Vector<OwnPtr<CSSParserSelector> >* reusableSelectorVector() { return &m_reusableSelectorVector; } 227 228 void updateLastSelectorLineAndPosition(); 229 230 void clearProperties(); 231 232 bool m_strict; 233 bool m_important; 234 int m_id; 235 CSSStyleSheet* m_styleSheet; 236 RefPtr<CSSRule> m_rule; 237 RefPtr<CSSRule> m_keyframe; 238 OwnPtr<MediaQuery> m_mediaQuery; 239 CSSParserValueList* m_valueList; 240 CSSProperty** m_parsedProperties; 241 CSSSelectorList* m_selectorListForParseSelector; 242 RefPtr<CSSPrimitiveValueCache> m_primitiveValueCache; 243 unsigned m_numParsedProperties; 244 unsigned m_maxParsedProperties; 245 unsigned m_numParsedPropertiesBeforeMarginBox; 246 247 int m_inParseShorthand; 248 int m_currentShorthand; 249 bool m_implicitShorthand; 250 251 bool m_hasFontFaceOnlyValues; 252 bool m_hadSyntacticallyValidCSSRule; 253 254 AtomicString m_defaultNamespace; 255 256 // tokenizer methods and data 257 bool m_inStyleRuleOrDeclaration; 258 SourceRange m_selectorListRange; 259 SourceRange m_ruleBodyRange; 260 SourceRange m_propertyRange; 261 StyleRuleRangeMap* m_ruleRangeMap; 262 RefPtr<CSSRuleSourceData> m_currentRuleData; 263 void markSelectorListStart(); 264 void markSelectorListEnd(); 265 void markRuleBodyStart(); 266 void markRuleBodyEnd(); 267 void markPropertyStart(); 268 void markPropertyEnd(bool isImportantFound, bool isPropertyParsed); resetSelectorListMarks()269 void resetSelectorListMarks() { m_selectorListRange.start = m_selectorListRange.end = 0; } resetRuleBodyMarks()270 void resetRuleBodyMarks() { m_ruleBodyRange.start = m_ruleBodyRange.end = 0; } resetPropertyMarks()271 void resetPropertyMarks() { m_propertyRange.start = m_propertyRange.end = UINT_MAX; } 272 int lex(void* yylval); token()273 int token() { return yyTok; } 274 UChar* text(int* length); 275 void countLines(); 276 int lex(); 277 278 private: 279 void setStyleSheet(CSSStyleSheet*); 280 281 void recheckAtKeyword(const UChar* str, int len); 282 283 void setupParser(const char* prefix, const String&, const char* suffix); 284 inShorthand()285 bool inShorthand() const { return m_inParseShorthand; } 286 287 void checkForOrphanedUnits(); 288 289 void deleteFontFaceOnlyValues(); 290 291 bool isGeneratedImageValue(CSSParserValue*) const; 292 bool parseGeneratedImage(RefPtr<CSSValue>&); 293 294 bool parseValue(CSSMutableStyleDeclaration*, int propId, const String&, bool important); 295 296 enum SizeParameterType { 297 None, 298 Auto, 299 Length, 300 PageSize, 301 Orientation, 302 }; 303 304 bool parsePage(int propId, bool important); 305 bool parseSize(int propId, bool important); 306 SizeParameterType parseSizeParameter(CSSValueList* parsedValues, CSSParserValue* value, SizeParameterType prevParamType); 307 308 UChar* m_data; 309 UChar* yytext; 310 UChar* yy_c_buf_p; 311 UChar yy_hold_char; 312 int yy_last_accepting_state; 313 UChar* yy_last_accepting_cpos; 314 int yyleng; 315 int yyTok; 316 int yy_start; 317 int m_lineNumber; 318 int m_lastSelectorLineNumber; 319 320 bool m_allowImportRules; 321 bool m_allowNamespaceDeclarations; 322 323 Vector<RefPtr<StyleBase> > m_parsedStyleObjects; 324 Vector<RefPtr<CSSRuleList> > m_parsedRuleLists; 325 HashSet<CSSParserSelector*> m_floatingSelectors; 326 HashSet<Vector<OwnPtr<CSSParserSelector> >*> m_floatingSelectorVectors; 327 HashSet<CSSParserValueList*> m_floatingValueLists; 328 HashSet<CSSParserFunction*> m_floatingFunctions; 329 330 OwnPtr<MediaQuery> m_floatingMediaQuery; 331 OwnPtr<MediaQueryExp> m_floatingMediaQueryExp; 332 OwnPtr<Vector<OwnPtr<MediaQueryExp> > > m_floatingMediaQueryExpList; 333 334 Vector<OwnPtr<CSSParserSelector> > m_reusableSelectorVector; 335 336 // defines units allowed for a certain property, used in parseUnit 337 enum Units { 338 FUnknown = 0x0000, 339 FInteger = 0x0001, 340 FNumber = 0x0002, // Real Numbers 341 FPercent = 0x0004, 342 FLength = 0x0008, 343 FAngle = 0x0010, 344 FTime = 0x0020, 345 FFrequency = 0x0040, 346 FRelative = 0x0100, 347 FNonNeg = 0x0200 348 }; 349 350 friend inline Units operator|(Units a, Units b) 351 { 352 return static_cast<Units>(static_cast<unsigned>(a) | static_cast<unsigned>(b)); 353 } 354 355 static bool validUnit(CSSParserValue*, Units, bool strict); 356 357 friend class TransformOperationInfo; 358 }; 359 360 int cssPropertyID(const CSSParserString&); 361 int cssPropertyID(const String&); 362 int cssValueKeywordID(const CSSParserString&); 363 364 class ShorthandScope { 365 WTF_MAKE_FAST_ALLOCATED; 366 public: ShorthandScope(CSSParser * parser,int propId)367 ShorthandScope(CSSParser* parser, int propId) : m_parser(parser) 368 { 369 if (!(m_parser->m_inParseShorthand++)) 370 m_parser->m_currentShorthand = propId; 371 } ~ShorthandScope()372 ~ShorthandScope() 373 { 374 if (!(--m_parser->m_inParseShorthand)) 375 m_parser->m_currentShorthand = 0; 376 } 377 378 private: 379 CSSParser* m_parser; 380 }; 381 382 String quoteCSSString(const String&); 383 String quoteCSSStringIfNeeded(const String&); 384 String quoteCSSURLIfNeeded(const String&); 385 386 bool isValidNthToken(const CSSParserString&); 387 } // namespace WebCore 388 389 #endif // CSSParser_h 390