Fix for style regression caused by strictness checking of the number of prope...
[WebKit-https.git] / WebCore / css / cssparser.h
1 /*
2  * This file is part of the DOM implementation for KDE.
3  *
4  * Copyright (C) 2003 Lars Knoll (knoll@kde.org)
5  * Copyright (C) 2004, 2005, 2006 Apple Computer, Inc.
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., 59 Temple Place - Suite 330,
20  * Boston, MA 02111-1307, USA.
21  */
22
23 #ifndef cssparser_h
24 #define cssparser_h
25
26 #include "AtomicString.h"
27 #include "Color.h"
28 #include "MediaQuery.h"
29 #include <wtf/HashSet.h>
30 #include <wtf/Vector.h>
31
32 namespace WebCore {
33
34     class CSSMutableStyleDeclaration;
35     class CSSPrimitiveValue;
36     class CSSProperty;
37     class CSSRule;
38     class CSSRuleList;
39     class CSSSelector;
40     class CSSStyleSheet;
41     class CSSValue;
42     class CSSValueList;
43     class Document;
44     class MediaList;
45     class MediaList;
46     class MediaQueryExp;
47     class StyleBase;
48     class StyleList;
49     struct Function;
50
51     struct ParseString {
52         UChar* characters;
53         int length;
54
55         void lower();
56     };
57
58     struct Value {
59         int id;
60         bool isInt;
61         union {
62             double fValue;
63             int iValue;
64             ParseString string;
65             Function* function;
66         };
67         enum {
68             Operator = 0x100000,
69             Function = 0x100001,
70             Q_EMS    = 0x100002
71         };
72         int unit;
73     };
74
75     DeprecatedString deprecatedString(const ParseString&);
76
77     static inline String domString(const ParseString& ps)
78     {
79         return String(ps.characters, ps.length);
80     }
81
82     static inline AtomicString atomicString(const ParseString& ps)
83     {
84         return AtomicString(ps.characters, ps.length);
85     }
86
87     class ValueList {
88     public:
89         ValueList() : m_current(0) { }
90         ~ValueList();
91
92         void addValue(const Value& v) { m_values.append(v); }
93         unsigned size() const { return m_values.size(); }
94         Value* current() { return m_current < m_values.size() ? &m_values[m_current] : 0; }
95         Value* next() { ++m_current; return current(); }
96
97         Value* valueAt(unsigned i) { return i < m_values.size() ? &m_values[i] : 0; }
98         void deleteValueAt(unsigned i) { m_values.remove(i); }
99
100     private:
101         Vector<Value, 16> m_values;
102         unsigned m_current;
103     };
104
105     struct Function {
106         ParseString name;
107         ValueList* args;
108
109         ~Function() { delete args; }
110     };
111
112     class CSSParser {
113     public:
114         CSSParser(bool strictParsing = true);
115         ~CSSParser();
116
117         void parseSheet(CSSStyleSheet*, const String&);
118         PassRefPtr<CSSRule> parseRule(CSSStyleSheet*, const String&);
119         bool parseValue(CSSMutableStyleDeclaration*, int propId, const String&, bool important);
120         static RGBA32 parseColor(const String&, bool strict = false);
121         bool parseColor(CSSMutableStyleDeclaration*, const String&);
122         bool parseDeclaration(CSSMutableStyleDeclaration*, const String&);
123         bool parseMediaQuery(MediaList*, const String&);
124
125         static CSSParser* current() { return currentParser; }
126
127         Document* document() const;
128
129         void addProperty(int propId, PassRefPtr<CSSValue>, bool important);
130         void rollbackLastProperties(int num);
131         bool hasProperties() const { return numParsedProperties > 0; }
132
133         bool parseValue(int propId, bool important);
134         bool parseShorthand(int propId, const int* properties, int numProperties, bool important);
135         bool parse4Values(int propId, const int* properties, bool important);
136         bool parseContent(int propId, bool important);
137
138         CSSValue* parseBackgroundColor();
139         CSSValue* parseBackgroundImage();
140         CSSValue* parseBackgroundPositionXY(bool& xFound, bool& yFound);
141         void parseBackgroundPosition(CSSValue*&, CSSValue*&);
142         CSSValue* parseBackgroundSize();
143         
144         bool parseBackgroundProperty(int propId, int& propId1, int& propId2, CSSValue*&, CSSValue*&);
145         bool parseBackgroundShorthand(bool important);
146
147         void addBackgroundValue(CSSValue*& lval, CSSValue* rval);
148
149 #if PLATFORM(MAC)
150         bool parseDashboardRegions(int propId, bool important);
151 #endif
152
153         bool parseShape(int propId, bool important);
154
155         bool parseFont(bool important);
156         CSSValueList* parseFontFamily();
157
158         bool parseCounter(int propId, int defaultValue, bool important);
159         PassRefPtr<CSSValue> parseCounterContent(ValueList* args, bool counters);
160
161         bool parseColorParameters(Value*, int* colorValues, bool parseAlpha);
162         bool parseHSLParameters(Value*, double* colorValues, bool parseAlpha);
163         CSSPrimitiveValue* parseColor(Value* = 0);
164         bool parseColorFromValue(Value*, RGBA32&, bool = false);
165
166         static bool parseColor(const String&, RGBA32& rgb, bool strict);
167
168 #ifdef SVG_SUPPORT
169         bool parseSVGValue(int propId, bool important);
170         CSSValue* parseSVGPaint();
171         CSSValue* parseSVGColor();
172         CSSValue* parseSVGStrokeDasharray();
173 #endif
174
175         // CSS3 Parsing Routines (for properties specific to CSS3)
176         bool parseShadow(int propId, bool important);
177         bool parseBorderImage(int propId, bool important);
178
179         int yyparse();
180
181         CSSSelector* createFloatingSelector();
182         CSSSelector* sinkFloatingSelector(CSSSelector*);
183
184         ValueList* createFloatingValueList();
185         ValueList* sinkFloatingValueList(ValueList*);
186
187         Function* createFloatingFunction();
188         Function* sinkFloatingFunction(Function*);
189
190         Value& sinkFloatingValue(Value&);
191
192         MediaList* createMediaList();
193         CSSRule* createCharsetRule(const ParseString&);
194         CSSRule* createImportRule(const ParseString&, MediaList*);
195         CSSRule* createMediaRule(MediaList*, CSSRuleList*);
196         CSSRuleList* createRuleList();
197         CSSRule* createStyleRule(CSSSelector*);
198
199         MediaQueryExp* createFloatingMediaQueryExp(const AtomicString&, ValueList*);
200         MediaQueryExp* sinkFloatingMediaQueryExp(MediaQueryExp*);
201         Vector<MediaQueryExp*>* createFloatingMediaQueryExpList();
202         Vector<MediaQueryExp*>* sinkFloatingMediaQueryExpList(Vector<MediaQueryExp*>*);
203         MediaQuery* createFloatingMediaQuery(MediaQuery::Restrictor, const String&, Vector<MediaQueryExp*>*);
204         MediaQuery* sinkFloatingMediaQuery(MediaQuery*);
205
206     public:
207         bool strict;
208         bool important;
209         int id;
210         StyleList* styleElement;
211         RefPtr<CSSRule> rule;
212         MediaQuery* mediaQuery;
213         ValueList* valueList;
214         CSSProperty** parsedProperties;
215         int numParsedProperties;
216         int maxParsedProperties;
217
218         int m_inParseShorthand;
219         int m_currentShorthand;
220         bool m_implicitShorthand;
221
222         AtomicString defaultNamespace;
223
224         static CSSParser* currentParser;
225
226         // tokenizer methods and data
227     public:
228         int lex(void* yylval);
229         int token() { return yyTok; }
230         UChar* text(int* length);
231         int lex();
232         
233     private:
234         void clearProperties();
235
236         void setupParser(const char* prefix, const String&, const char* suffix);
237
238         bool inShorthand() const { return m_inParseShorthand; }
239
240         void checkForOrphanedUnits();
241         
242         UChar* data;
243         UChar* yytext;
244         UChar* yy_c_buf_p;
245         UChar yy_hold_char;
246         int yy_last_accepting_state;
247         UChar* yy_last_accepting_cpos;
248         int yyleng;
249         int yyTok;
250         int yy_start;
251
252         Vector<RefPtr<StyleBase> > m_parsedStyleObjects;
253         Vector<RefPtr<CSSRuleList> > m_parsedRuleLists;
254         HashSet<CSSSelector*> m_floatingSelectors;
255         HashSet<ValueList*> m_floatingValueLists;
256         HashSet<Function*> m_floatingFunctions;
257
258         MediaQuery* m_floatingMediaQuery;
259         MediaQueryExp* m_floatingMediaQueryExp;
260         Vector<MediaQueryExp*>* m_floatingMediaQueryExpList;
261
262         // defines units allowed for a certain property, used in parseUnit
263         enum Units {
264             FUnknown   = 0x0000,
265             FInteger   = 0x0001,
266             FNumber    = 0x0002,  // Real Numbers
267             FPercent   = 0x0004,
268             FLength    = 0x0008,
269             FAngle     = 0x0010,
270             FTime      = 0x0020,
271             FFrequency = 0x0040,
272             FRelative  = 0x0100,
273             FNonNeg    = 0x0200
274         };
275
276         friend inline Units operator|(Units a, Units b)
277         {
278             return static_cast<Units>(static_cast<unsigned>(a) | static_cast<unsigned>(b));
279         }
280
281         static bool validUnit(Value*, Units, bool strict);
282     };
283
284 } // namespace WebCore
285
286 #endif // cssparser_h