--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/WebCore/css/CSSParser.h Fri Sep 17 09:02:29 2010 +0300
@@ -0,0 +1,361 @@
+/*
+ * Copyright (C) 2003 Lars Knoll (knoll@kde.org)
+ * Copyright (C) 2004, 2005, 2006, 2008 Apple Inc. All rights reserved.
+ * Copyright (C) 2008 Eric Seidel <eric@webkit.org>
+ * Copyright (C) 2009 - 2010 Torch Mobile (Beijing) Co. Ltd. All rights reserved.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public License
+ * along with this library; see the file COPYING.LIB. If not, write to
+ * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#ifndef CSSParser_h
+#define CSSParser_h
+
+#include "AtomicString.h"
+#include "Color.h"
+#include "CSSParserValues.h"
+#include "CSSSelectorList.h"
+#include "MediaQuery.h"
+#include <wtf/HashMap.h>
+#include <wtf/HashSet.h>
+#include <wtf/Vector.h>
+
+namespace WebCore {
+
+ class CSSMutableStyleDeclaration;
+ class CSSPrimitiveValue;
+ class CSSProperty;
+ class CSSRule;
+ class CSSRuleList;
+ class CSSSelector;
+ class CSSStyleRule;
+ class CSSStyleSheet;
+ class CSSValue;
+ class CSSValueList;
+ class CSSVariablesDeclaration;
+ class Document;
+ class MediaList;
+ class MediaQueryExp;
+ class StyleBase;
+ class StyleList;
+ class WebKitCSSKeyframeRule;
+ class WebKitCSSKeyframesRule;
+
+ class CSSParser {
+ public:
+ typedef HashMap<CSSStyleRule*, std::pair<unsigned, unsigned> > StyleRuleRanges;
+
+ CSSParser(bool strictParsing = true);
+ ~CSSParser();
+
+ void parseSheet(CSSStyleSheet*, const String&, int startLineNumber = 0, StyleRuleRanges* ruleRangeMap = 0);
+ PassRefPtr<CSSRule> parseRule(CSSStyleSheet*, const String&);
+ PassRefPtr<CSSRule> parseKeyframeRule(CSSStyleSheet*, const String&);
+ bool parseValue(CSSMutableStyleDeclaration*, int propId, const String&, bool important);
+ static bool parseColor(RGBA32& color, const String&, bool strict = false);
+ bool parseColor(CSSMutableStyleDeclaration*, const String&);
+ bool parseDeclaration(CSSMutableStyleDeclaration*, const String&);
+ bool parseMediaQuery(MediaList*, const String&);
+
+ Document* document() const;
+
+ void addProperty(int propId, PassRefPtr<CSSValue>, bool important);
+ void rollbackLastProperties(int num);
+ bool hasProperties() const { return m_numParsedProperties > 0; }
+
+ bool parseValue(int propId, bool important);
+ bool parseShorthand(int propId, const int* properties, int numProperties, bool important);
+ bool parse4Values(int propId, const int* properties, bool important);
+ bool parseContent(int propId, bool important);
+
+ PassRefPtr<CSSValue> parseAttr(CSSParserValueList* args);
+
+ PassRefPtr<CSSValue> parseBackgroundColor();
+
+ bool parseFillImage(RefPtr<CSSValue>&);
+ PassRefPtr<CSSValue> parseFillPositionXY(bool& xFound, bool& yFound);
+ void parseFillPosition(RefPtr<CSSValue>&, RefPtr<CSSValue>&);
+ void parseFillRepeat(RefPtr<CSSValue>&, RefPtr<CSSValue>&);
+ PassRefPtr<CSSValue> parseFillSize(int propId, bool &allowComma);
+
+ bool parseFillProperty(int propId, int& propId1, int& propId2, RefPtr<CSSValue>&, RefPtr<CSSValue>&);
+ bool parseFillShorthand(int propId, const int* properties, int numProperties, bool important);
+
+ void addFillValue(RefPtr<CSSValue>& lval, PassRefPtr<CSSValue> rval);
+
+ void addAnimationValue(RefPtr<CSSValue>& lval, PassRefPtr<CSSValue> rval);
+
+ PassRefPtr<CSSValue> parseAnimationDelay();
+ PassRefPtr<CSSValue> parseAnimationDirection();
+ PassRefPtr<CSSValue> parseAnimationDuration();
+ PassRefPtr<CSSValue> parseAnimationFillMode();
+ PassRefPtr<CSSValue> parseAnimationIterationCount();
+ PassRefPtr<CSSValue> parseAnimationName();
+ PassRefPtr<CSSValue> parseAnimationPlayState();
+ PassRefPtr<CSSValue> parseAnimationProperty();
+ PassRefPtr<CSSValue> parseAnimationTimingFunction();
+
+ void parseTransformOriginShorthand(RefPtr<CSSValue>&, RefPtr<CSSValue>&, RefPtr<CSSValue>&);
+ bool parseTimingFunctionValue(CSSParserValueList*& args, double& result);
+ bool parseAnimationProperty(int propId, RefPtr<CSSValue>&);
+ bool parseTransitionShorthand(bool important);
+ bool parseAnimationShorthand(bool important);
+
+ bool parseDashboardRegions(int propId, bool important);
+
+ bool parseShape(int propId, bool important);
+
+ bool parseFont(bool important);
+ PassRefPtr<CSSValueList> parseFontFamily();
+
+ bool parseCounter(int propId, int defaultValue, bool important);
+ PassRefPtr<CSSValue> parseCounterContent(CSSParserValueList* args, bool counters);
+
+ bool parseColorParameters(CSSParserValue*, int* colorValues, bool parseAlpha);
+ bool parseHSLParameters(CSSParserValue*, double* colorValues, bool parseAlpha);
+ PassRefPtr<CSSPrimitiveValue> parseColor(CSSParserValue* = 0);
+ bool parseColorFromValue(CSSParserValue*, RGBA32&);
+ void parseSelector(const String&, Document* doc, CSSSelectorList&);
+
+ static bool parseColor(const String&, RGBA32& rgb, bool strict);
+
+ bool parseFontStyle(bool important);
+ bool parseFontVariant(bool important);
+ bool parseFontWeight(bool important);
+ bool parseFontFaceSrc();
+ bool parseFontFaceUnicodeRange();
+
+#if ENABLE(SVG)
+ bool parseSVGValue(int propId, bool important);
+ PassRefPtr<CSSValue> parseSVGPaint();
+ PassRefPtr<CSSValue> parseSVGColor();
+ PassRefPtr<CSSValue> parseSVGStrokeDasharray();
+#endif
+
+#if ENABLE(WCSS)
+ PassRefPtr<CSSValue> parseWCSSInputProperty();
+#endif
+
+ // CSS3 Parsing Routines (for properties specific to CSS3)
+ bool parseShadow(int propId, bool important);
+ bool parseBorderImage(int propId, bool important, RefPtr<CSSValue>&);
+ bool parseBorderRadius(int propId, bool important);
+
+ bool parseReflect(int propId, bool important);
+
+ // Image generators
+ bool parseCanvas(RefPtr<CSSValue>&);
+ bool parseGradient(RefPtr<CSSValue>&);
+
+ PassRefPtr<CSSValueList> parseTransform();
+ bool parseTransformOrigin(int propId, int& propId1, int& propId2, int& propId3, RefPtr<CSSValue>&, RefPtr<CSSValue>&, RefPtr<CSSValue>&);
+ bool parsePerspectiveOrigin(int propId, int& propId1, int& propId2, RefPtr<CSSValue>&, RefPtr<CSSValue>&);
+ bool parseVariable(CSSVariablesDeclaration*, const String& variableName, const String& variableValue);
+ void parsePropertyWithResolvedVariables(int propId, bool important, CSSMutableStyleDeclaration*, CSSParserValueList*);
+
+ int yyparse();
+
+ CSSSelector* createFloatingSelector();
+ CSSSelector* sinkFloatingSelector(CSSSelector*);
+
+ CSSParserValueList* createFloatingValueList();
+ CSSParserValueList* sinkFloatingValueList(CSSParserValueList*);
+
+ CSSParserFunction* createFloatingFunction();
+ CSSParserFunction* sinkFloatingFunction(CSSParserFunction*);
+
+ CSSParserValue& sinkFloatingValue(CSSParserValue&);
+
+ MediaList* createMediaList();
+ CSSRule* createCharsetRule(const CSSParserString&);
+ CSSRule* createImportRule(const CSSParserString&, MediaList*);
+ WebKitCSSKeyframeRule* createKeyframeRule(CSSParserValueList*);
+ WebKitCSSKeyframesRule* createKeyframesRule();
+ CSSRule* createMediaRule(MediaList*, CSSRuleList*);
+ CSSRuleList* createRuleList();
+ CSSRule* createStyleRule(Vector<CSSSelector*>* selectors);
+ CSSRule* createFontFaceRule();
+ CSSRule* createVariablesRule(MediaList*, bool variablesKeyword);
+ CSSRule* createPageRule(CSSSelector* pageSelector);
+ CSSRule* createMarginAtRule(CSSSelector::MarginBoxType marginBox);
+ void startDeclarationsForMarginBox();
+ void endDeclarationsForMarginBox();
+
+ MediaQueryExp* createFloatingMediaQueryExp(const AtomicString&, CSSParserValueList*);
+ MediaQueryExp* sinkFloatingMediaQueryExp(MediaQueryExp*);
+ Vector<MediaQueryExp*>* createFloatingMediaQueryExpList();
+ Vector<MediaQueryExp*>* sinkFloatingMediaQueryExpList(Vector<MediaQueryExp*>*);
+ MediaQuery* createFloatingMediaQuery(MediaQuery::Restrictor, const String&, Vector<MediaQueryExp*>*);
+ MediaQuery* createFloatingMediaQuery(Vector<MediaQueryExp*>*);
+ MediaQuery* sinkFloatingMediaQuery(MediaQuery*);
+
+ void addNamespace(const AtomicString& prefix, const AtomicString& uri);
+
+ bool addVariable(const CSSParserString&, CSSParserValueList*);
+ bool addVariableDeclarationBlock(const CSSParserString&);
+ bool checkForVariables(CSSParserValueList*);
+ void addUnresolvedProperty(int propId, bool important);
+ void invalidBlockHit();
+
+ Vector<CSSSelector*>* reusableSelectorVector() { return &m_reusableSelectorVector; }
+
+ void updateLastSelectorLineAndPosition();
+
+ void clearProperties();
+
+ bool m_strict;
+ bool m_important;
+ int m_id;
+ CSSStyleSheet* m_styleSheet;
+ RefPtr<CSSRule> m_rule;
+ RefPtr<CSSRule> m_keyframe;
+ MediaQuery* m_mediaQuery;
+ CSSParserValueList* m_valueList;
+ CSSProperty** m_parsedProperties;
+ CSSSelectorList* m_selectorListForParseSelector;
+ unsigned m_numParsedProperties;
+ unsigned m_maxParsedProperties;
+ unsigned m_numParsedPropertiesBeforeMarginBox;
+
+ int m_inParseShorthand;
+ int m_currentShorthand;
+ bool m_implicitShorthand;
+
+ bool m_hasFontFaceOnlyValues;
+ bool m_hadSyntacticallyValidCSSRule;
+
+ Vector<String> m_variableNames;
+ Vector<RefPtr<CSSValue> > m_variableValues;
+
+ AtomicString m_defaultNamespace;
+
+ // tokenizer methods and data
+ unsigned m_ruleBodyStartOffset;
+ unsigned m_ruleBodyEndOffset;
+ StyleRuleRanges* m_ruleRanges;
+ void markRuleBodyStart();
+ void markRuleBodyEnd();
+ void resetRuleBodyMarks() { m_ruleBodyStartOffset = m_ruleBodyEndOffset = 0; }
+ int lex(void* yylval);
+ int token() { return yyTok; }
+ UChar* text(int* length);
+ void countLines();
+ int lex();
+
+ private:
+ void recheckAtKeyword(const UChar* str, int len);
+
+ void setupParser(const char* prefix, const String&, const char* suffix);
+
+ bool inShorthand() const { return m_inParseShorthand; }
+
+ void checkForOrphanedUnits();
+
+ void clearVariables();
+
+ void deleteFontFaceOnlyValues();
+
+ enum SizeParameterType {
+ None,
+ Auto,
+ Length,
+ PageSize,
+ Orientation,
+ };
+
+ bool parsePage(int propId, bool important);
+ bool parseSize(int propId, bool important);
+ SizeParameterType parseSizeParameter(CSSValueList* parsedValues, CSSParserValue* value, SizeParameterType prevParamType);
+
+ UChar* m_data;
+ UChar* yytext;
+ UChar* yy_c_buf_p;
+ UChar yy_hold_char;
+ int yy_last_accepting_state;
+ UChar* yy_last_accepting_cpos;
+ int yyleng;
+ int yyTok;
+ int yy_start;
+ int m_lineNumber;
+ int m_lastSelectorLineNumber;
+
+ bool m_allowImportRules;
+ bool m_allowVariablesRules;
+ bool m_allowNamespaceDeclarations;
+
+ Vector<RefPtr<StyleBase> > m_parsedStyleObjects;
+ Vector<RefPtr<CSSRuleList> > m_parsedRuleLists;
+ HashSet<CSSSelector*> m_floatingSelectors;
+ HashSet<CSSParserValueList*> m_floatingValueLists;
+ HashSet<CSSParserFunction*> m_floatingFunctions;
+
+ MediaQuery* m_floatingMediaQuery;
+ MediaQueryExp* m_floatingMediaQueryExp;
+ Vector<MediaQueryExp*>* m_floatingMediaQueryExpList;
+
+ Vector<CSSSelector*> m_reusableSelectorVector;
+
+ // defines units allowed for a certain property, used in parseUnit
+ enum Units {
+ FUnknown = 0x0000,
+ FInteger = 0x0001,
+ FNumber = 0x0002, // Real Numbers
+ FPercent = 0x0004,
+ FLength = 0x0008,
+ FAngle = 0x0010,
+ FTime = 0x0020,
+ FFrequency = 0x0040,
+ FRelative = 0x0100,
+ FNonNeg = 0x0200
+ };
+
+ friend inline Units operator|(Units a, Units b)
+ {
+ return static_cast<Units>(static_cast<unsigned>(a) | static_cast<unsigned>(b));
+ }
+
+ static bool validUnit(CSSParserValue*, Units, bool strict);
+
+ friend class TransformOperationInfo;
+ };
+
+ int cssPropertyID(const CSSParserString&);
+ int cssPropertyID(const String&);
+ int cssValueKeywordID(const CSSParserString&);
+
+ class ShorthandScope : public FastAllocBase {
+ public:
+ ShorthandScope(CSSParser* parser, int propId) : m_parser(parser)
+ {
+ if (!(m_parser->m_inParseShorthand++))
+ m_parser->m_currentShorthand = propId;
+ }
+ ~ShorthandScope()
+ {
+ if (!(--m_parser->m_inParseShorthand))
+ m_parser->m_currentShorthand = 0;
+ }
+
+ private:
+ CSSParser* m_parser;
+ };
+
+ String quoteCSSString(const String&);
+ String quoteCSSStringIfNeeded(const String&);
+ String quoteCSSURLIfNeeded(const String&);
+
+} // namespace WebCore
+
+#endif // CSSParser_h