1 /*

     2  * Copyright (C) 2003 Lars Knoll (knoll@kde.org)

     3  * Copyright (C) 2004, 2005, 2006, 2008 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 "AtomicString.h"

    27 #include "Color.h"

    28 #include "CSSParserValues.h"

    29 #include "CSSSelectorList.h"

    30 #include "MediaQuery.h"

    31 #include <wtf/HashMap.h>

    32 #include <wtf/HashSet.h>

    33 #include <wtf/Vector.h>

    34 

    35 namespace WebCore {

    36 

    37     class CSSMutableStyleDeclaration;

    38     class CSSPrimitiveValue;

    39     class CSSProperty;

    40     class CSSRule;

    41     class CSSRuleList;

    42     class CSSSelector;

    43     class CSSStyleRule;

    44     class CSSStyleSheet;

    45     class CSSValue;

    46     class CSSValueList;

    47     class CSSVariablesDeclaration;

    48     class Document;

    49     class MediaList;

    50     class MediaQueryExp;

    51     class StyleBase;

    52     class StyleList;

    53     class WebKitCSSKeyframeRule;

    54     class WebKitCSSKeyframesRule;

    55 

    56     class CSSParser {

    57     public:

    58         typedef HashMap<CSSStyleRule*, std::pair<unsigned, unsigned> > StyleRuleRanges;

    59 

    60         CSSParser(bool strictParsing = true);

    61         ~CSSParser();

    62 

    63         void parseSheet(CSSStyleSheet*, const String&, int startLineNumber = 0, StyleRuleRanges* ruleRangeMap = 0);

    64         PassRefPtr<CSSRule> parseRule(CSSStyleSheet*, const String&);

    65         PassRefPtr<CSSRule> parseKeyframeRule(CSSStyleSheet*, const String&);

    66         bool parseValue(CSSMutableStyleDeclaration*, int propId, const String&, bool important);

    67         static bool parseColor(RGBA32& color, const String&, bool strict = false);

    68         bool parseColor(CSSMutableStyleDeclaration*, const String&);

    69         bool parseDeclaration(CSSMutableStyleDeclaration*, const String&);

    70         bool parseMediaQuery(MediaList*, const String&);

    71 

    72         Document* document() const;

    73 

    74         void addProperty(int propId, PassRefPtr<CSSValue>, bool important);

    75         void rollbackLastProperties(int num);

    76         bool hasProperties() const { return m_numParsedProperties > 0; }

    77 

    78         bool parseValue(int propId, bool important);

    79         bool parseShorthand(int propId, const int* properties, int numProperties, bool important);

    80         bool parse4Values(int propId, const int* properties, bool important);

    81         bool parseContent(int propId, bool important);

    82 

    83         PassRefPtr<CSSValue> parseAttr(CSSParserValueList* args);

    84 

    85         PassRefPtr<CSSValue> parseBackgroundColor();

    86 

    87         bool parseFillImage(RefPtr<CSSValue>&);

    88         PassRefPtr<CSSValue> parseFillPositionXY(bool& xFound, bool& yFound);

    89         void parseFillPosition(RefPtr<CSSValue>&, RefPtr<CSSValue>&);

    90         void parseFillRepeat(RefPtr<CSSValue>&, RefPtr<CSSValue>&);

    91         PassRefPtr<CSSValue> parseFillSize(int propId, bool &allowComma);

    92 

    93         bool parseFillProperty(int propId, int& propId1, int& propId2, RefPtr<CSSValue>&, RefPtr<CSSValue>&);

    94         bool parseFillShorthand(int propId, const int* properties, int numProperties, bool important);

    95 

    96         void addFillValue(RefPtr<CSSValue>& lval, PassRefPtr<CSSValue> rval);

    97 

    98         void addAnimationValue(RefPtr<CSSValue>& lval, PassRefPtr<CSSValue> rval);

    99 

   100         PassRefPtr<CSSValue> parseAnimationDelay();

   101         PassRefPtr<CSSValue> parseAnimationDirection();

   102         PassRefPtr<CSSValue> parseAnimationDuration();

   103         PassRefPtr<CSSValue> parseAnimationFillMode();

   104         PassRefPtr<CSSValue> parseAnimationIterationCount();

   105         PassRefPtr<CSSValue> parseAnimationName();

   106         PassRefPtr<CSSValue> parseAnimationPlayState();

   107         PassRefPtr<CSSValue> parseAnimationProperty();

   108         PassRefPtr<CSSValue> parseAnimationTimingFunction();

   109 

   110         void parseTransformOriginShorthand(RefPtr<CSSValue>&, RefPtr<CSSValue>&, RefPtr<CSSValue>&);

   111         bool parseTimingFunctionValue(CSSParserValueList*& args, double& result);

   112         bool parseAnimationProperty(int propId, RefPtr<CSSValue>&);

   113         bool parseTransitionShorthand(bool important);

   114         bool parseAnimationShorthand(bool important);

   115 

   116         bool parseDashboardRegions(int propId, bool important);

   117 

   118         bool parseShape(int propId, bool important);

   119 

   120         bool parseFont(bool important);

   121         PassRefPtr<CSSValueList> parseFontFamily();

   122 

   123         bool parseCounter(int propId, int defaultValue, bool important);

   124         PassRefPtr<CSSValue> parseCounterContent(CSSParserValueList* args, bool counters);

   125 

   126         bool parseColorParameters(CSSParserValue*, int* colorValues, bool parseAlpha);

   127         bool parseHSLParameters(CSSParserValue*, double* colorValues, bool parseAlpha);

   128         PassRefPtr<CSSPrimitiveValue> parseColor(CSSParserValue* = 0);

   129         bool parseColorFromValue(CSSParserValue*, RGBA32&);

   130         void parseSelector(const String&, Document* doc, CSSSelectorList&);

   131 

   132         static bool parseColor(const String&, RGBA32& rgb, bool strict);

   133 

   134         bool parseFontStyle(bool important);

   135         bool parseFontVariant(bool important);

   136         bool parseFontWeight(bool important);

   137         bool parseFontFaceSrc();

   138         bool parseFontFaceUnicodeRange();

   139 

   140 #if ENABLE(SVG)

   141         bool parseSVGValue(int propId, bool important);

   142         PassRefPtr<CSSValue> parseSVGPaint();

   143         PassRefPtr<CSSValue> parseSVGColor();

   144         PassRefPtr<CSSValue> parseSVGStrokeDasharray();

   145 #endif

   146 

   147 #if ENABLE(WCSS)

   148         PassRefPtr<CSSValue> parseWCSSInputProperty();

   149 #endif

   150 

   151         // CSS3 Parsing Routines (for properties specific to CSS3)

   152         bool parseShadow(int propId, bool important);

   153         bool parseBorderImage(int propId, bool important, RefPtr<CSSValue>&);

   154         bool parseBorderRadius(int propId, bool important);

   155 

   156         bool parseReflect(int propId, bool important);

   157 

   158         // Image generators

   159         bool parseCanvas(RefPtr<CSSValue>&);

   160         bool parseGradient(RefPtr<CSSValue>&);

   161 

   162         PassRefPtr<CSSValueList> parseTransform();

   163         bool parseTransformOrigin(int propId, int& propId1, int& propId2, int& propId3, RefPtr<CSSValue>&, RefPtr<CSSValue>&, RefPtr<CSSValue>&);

   164         bool parsePerspectiveOrigin(int propId, int& propId1, int& propId2,  RefPtr<CSSValue>&, RefPtr<CSSValue>&);

   165         bool parseVariable(CSSVariablesDeclaration*, const String& variableName, const String& variableValue);

   166         void parsePropertyWithResolvedVariables(int propId, bool important, CSSMutableStyleDeclaration*, CSSParserValueList*);

   167 

   168         int yyparse();

   169 

   170         CSSSelector* createFloatingSelector();

   171         CSSSelector* sinkFloatingSelector(CSSSelector*);

   172 

   173         CSSParserValueList* createFloatingValueList();

   174         CSSParserValueList* sinkFloatingValueList(CSSParserValueList*);

   175 

   176         CSSParserFunction* createFloatingFunction();

   177         CSSParserFunction* sinkFloatingFunction(CSSParserFunction*);

   178 

   179         CSSParserValue& sinkFloatingValue(CSSParserValue&);

   180 

   181         MediaList* createMediaList();

   182         CSSRule* createCharsetRule(const CSSParserString&);

   183         CSSRule* createImportRule(const CSSParserString&, MediaList*);

   184         WebKitCSSKeyframeRule* createKeyframeRule(CSSParserValueList*);

   185         WebKitCSSKeyframesRule* createKeyframesRule();

   186         CSSRule* createMediaRule(MediaList*, CSSRuleList*);

   187         CSSRuleList* createRuleList();

   188         CSSRule* createStyleRule(Vector<CSSSelector*>* selectors);

   189         CSSRule* createFontFaceRule();

   190         CSSRule* createVariablesRule(MediaList*, bool variablesKeyword);

   191         CSSRule* createPageRule(CSSSelector* pageSelector);

   192         CSSRule* createMarginAtRule(CSSSelector::MarginBoxType marginBox);

   193         void startDeclarationsForMarginBox();

   194         void endDeclarationsForMarginBox();

   195 

   196         MediaQueryExp* createFloatingMediaQueryExp(const AtomicString&, CSSParserValueList*);

   197         MediaQueryExp* sinkFloatingMediaQueryExp(MediaQueryExp*);

   198         Vector<MediaQueryExp*>* createFloatingMediaQueryExpList();

   199         Vector<MediaQueryExp*>* sinkFloatingMediaQueryExpList(Vector<MediaQueryExp*>*);

   200         MediaQuery* createFloatingMediaQuery(MediaQuery::Restrictor, const String&, Vector<MediaQueryExp*>*);

   201         MediaQuery* createFloatingMediaQuery(Vector<MediaQueryExp*>*);

   202         MediaQuery* sinkFloatingMediaQuery(MediaQuery*);

   203 

   204         void addNamespace(const AtomicString& prefix, const AtomicString& uri);

   205 

   206         bool addVariable(const CSSParserString&, CSSParserValueList*);

   207         bool addVariableDeclarationBlock(const CSSParserString&);

   208         bool checkForVariables(CSSParserValueList*);

   209         void addUnresolvedProperty(int propId, bool important);

   210         void invalidBlockHit();

   211 

   212         Vector<CSSSelector*>* reusableSelectorVector() { return &m_reusableSelectorVector; }

   213 

   214         void updateLastSelectorLineAndPosition();

   215 

   216         void clearProperties();

   217 

   218         bool m_strict;

   219         bool m_important;

   220         int m_id;

   221         CSSStyleSheet* m_styleSheet;

   222         RefPtr<CSSRule> m_rule;

   223         RefPtr<CSSRule> m_keyframe;

   224         MediaQuery* m_mediaQuery;

   225         CSSParserValueList* m_valueList;

   226         CSSProperty** m_parsedProperties;

   227         CSSSelectorList* m_selectorListForParseSelector;

   228         unsigned m_numParsedProperties;

   229         unsigned m_maxParsedProperties;

   230         unsigned m_numParsedPropertiesBeforeMarginBox;

   231 

   232         int m_inParseShorthand;

   233         int m_currentShorthand;

   234         bool m_implicitShorthand;

   235 

   236         bool m_hasFontFaceOnlyValues;

   237         bool m_hadSyntacticallyValidCSSRule;

   238 

   239         Vector<String> m_variableNames;

   240         Vector<RefPtr<CSSValue> > m_variableValues;

   241 

   242         AtomicString m_defaultNamespace;

   243 

   244         // tokenizer methods and data

   245         unsigned m_ruleBodyStartOffset;

   246         unsigned m_ruleBodyEndOffset;

   247         StyleRuleRanges* m_ruleRanges;

   248         void markRuleBodyStart();

   249         void markRuleBodyEnd();

   250         void resetRuleBodyMarks() { m_ruleBodyStartOffset = m_ruleBodyEndOffset = 0; }

   251         int lex(void* yylval);

   252         int token() { return yyTok; }

   253         UChar* text(int* length);

   254         void countLines();

   255         int lex();

   256 

   257     private:

   258         void recheckAtKeyword(const UChar* str, int len);

   259 

   260         void setupParser(const char* prefix, const String&, const char* suffix);

   261 

   262         bool inShorthand() const { return m_inParseShorthand; }

   263 

   264         void checkForOrphanedUnits();

   265 

   266         void clearVariables();

   267 

   268         void deleteFontFaceOnlyValues();

   269 

   270         enum SizeParameterType {

   271             None,

   272             Auto,

   273             Length,

   274             PageSize,

   275             Orientation,

   276         };

   277 

   278         bool parsePage(int propId, bool important);

   279         bool parseSize(int propId, bool important);

   280         SizeParameterType parseSizeParameter(CSSValueList* parsedValues, CSSParserValue* value, SizeParameterType prevParamType);

   281 

   282         UChar* m_data;

   283         UChar* yytext;

   284         UChar* yy_c_buf_p;

   285         UChar yy_hold_char;

   286         int yy_last_accepting_state;

   287         UChar* yy_last_accepting_cpos;

   288         int yyleng;

   289         int yyTok;

   290         int yy_start;

   291         int m_lineNumber;

   292         int m_lastSelectorLineNumber;

   293 

   294         bool m_allowImportRules;

   295         bool m_allowVariablesRules;

   296         bool m_allowNamespaceDeclarations;

   297 

   298         Vector<RefPtr<StyleBase> > m_parsedStyleObjects;

   299         Vector<RefPtr<CSSRuleList> > m_parsedRuleLists;

   300         HashSet<CSSSelector*> m_floatingSelectors;

   301         HashSet<CSSParserValueList*> m_floatingValueLists;

   302         HashSet<CSSParserFunction*> m_floatingFunctions;

   303 

   304         MediaQuery* m_floatingMediaQuery;

   305         MediaQueryExp* m_floatingMediaQueryExp;

   306         Vector<MediaQueryExp*>* m_floatingMediaQueryExpList;

   307 

   308         Vector<CSSSelector*> m_reusableSelectorVector;

   309 

   310         // defines units allowed for a certain property, used in parseUnit

   311         enum Units {

   312             FUnknown   = 0x0000,

   313             FInteger   = 0x0001,

   314             FNumber    = 0x0002,  // Real Numbers

   315             FPercent   = 0x0004,

   316             FLength    = 0x0008,

   317             FAngle     = 0x0010,

   318             FTime      = 0x0020,

   319             FFrequency = 0x0040,

   320             FRelative  = 0x0100,

   321             FNonNeg    = 0x0200

   322         };

   323 

   324         friend inline Units operator|(Units a, Units b)

   325         {

   326             return static_cast<Units>(static_cast<unsigned>(a) | static_cast<unsigned>(b));

   327         }

   328 

   329         static bool validUnit(CSSParserValue*, Units, bool strict);

   330 

   331         friend class TransformOperationInfo;

   332     };

   333 

   334     int cssPropertyID(const CSSParserString&);

   335     int cssPropertyID(const String&);

   336     int cssValueKeywordID(const CSSParserString&);

   337 

   338     class ShorthandScope : public FastAllocBase {

   339     public:

   340         ShorthandScope(CSSParser* parser, int propId) : m_parser(parser)

   341         {

   342             if (!(m_parser->m_inParseShorthand++))

   343                 m_parser->m_currentShorthand = propId;

   344         }

   345         ~ShorthandScope()

   346         {

   347             if (!(--m_parser->m_inParseShorthand))

   348                 m_parser->m_currentShorthand = 0;

   349         }

   350 

   351     private:

   352         CSSParser* m_parser;

   353     };

   354 

   355     String quoteCSSString(const String&);

   356     String quoteCSSStringIfNeeded(const String&);

   357     String quoteCSSURLIfNeeded(const String&);

   358 

   359 } // namespace WebCore

   360 

   361 #endif // CSSParser_h