45961226871f72936a9971b4fe3887da2c57fc3a
[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     private:
98         Vector<Value, 16> m_values;
99         unsigned m_current;
100     };
101
102     struct Function {
103         ParseString name;
104         ValueList* args;
105
106         ~Function() { delete args; }
107     };
108
109     class CSSParser {
110     public:
111         CSSParser(bool strictParsing = true);
112         ~CSSParser();
113
114         void parseSheet(CSSStyleSheet*, const String&);
115         PassRefPtr<CSSRule> parseRule(CSSStyleSheet*, const String&);
116         bool parseValue(CSSMutableStyleDeclaration*, int propId, const String&, bool important);
117         static RGBA32 parseColor(const String&, bool strict = false);
118         bool parseColor(CSSMutableStyleDeclaration*, const String&);
119         bool parseDeclaration(CSSMutableStyleDeclaration*, const String&);
120         bool parseMediaQuery(MediaList*, const String&);
121
122         static CSSParser* current() { return currentParser; }
123
124         Document* document() const;
125
126         void addProperty(int propId, PassRefPtr<CSSValue>, bool important);
127         void rollbackLastProperties(int num);
128         bool hasProperties() const { return numParsedProperties > 0; }
129
130         bool parseValue(int propId, bool important);
131         bool parseShorthand(int propId, const int* properties, int numProperties, bool important);
132         bool parse4Values(int propId, const int* properties, bool important);
133         bool parseContent(int propId, bool important);
134
135         CSSValue* parseBackgroundColor();
136         CSSValue* parseBackgroundImage();
137         CSSValue* parseBackgroundPositionXY(bool& xFound, bool& yFound);
138         void parseBackgroundPosition(CSSValue*&, CSSValue*&);
139         CSSValue* parseBackgroundSize();
140         
141         bool parseBackgroundProperty(int propId, int& propId1, int& propId2, CSSValue*&, CSSValue*&);
142         bool parseBackgroundShorthand(bool important);
143
144         void addBackgroundValue(CSSValue*& lval, CSSValue* rval);
145
146 #if PLATFORM(MAC)
147         bool parseDashboardRegions(int propId, bool important);
148 #endif
149
150         bool parseShape(int propId, bool important);
151
152         bool parseFont(bool important);
153         CSSValueList* parseFontFamily();
154
155         bool parseCounter(int propId, int defaultValue, bool important);
156         PassRefPtr<CSSValue> parseCounterContent(ValueList* args, bool counters);
157
158         bool parseColorParameters(Value*, int* colorValues, bool parseAlpha);
159         bool parseHSLParameters(Value*, double* colorValues, bool parseAlpha);
160         CSSPrimitiveValue* parseColor(Value* = 0);
161         bool parseColorFromValue(Value*, RGBA32&, bool = false);
162
163         static bool parseColor(const String&, RGBA32& rgb, bool strict);
164
165 #ifdef SVG_SUPPORT
166         bool parseSVGValue(int propId, bool important);
167         CSSValue* parseSVGPaint();
168         CSSValue* parseSVGColor();
169         CSSValue* parseSVGStrokeDasharray();
170 #endif
171
172         // CSS3 Parsing Routines (for properties specific to CSS3)
173         bool parseShadow(int propId, bool important);
174         bool parseBorderImage(int propId, bool important);
175
176         int yyparse();
177
178         CSSSelector* createFloatingSelector();
179         CSSSelector* sinkFloatingSelector(CSSSelector*);
180
181         ValueList* createFloatingValueList();
182         ValueList* sinkFloatingValueList(ValueList*);
183
184         Function* createFloatingFunction();
185         Function* sinkFloatingFunction(Function*);
186
187         Value& sinkFloatingValue(Value&);
188
189         MediaList* createMediaList();
190         CSSRule* createCharsetRule(const ParseString&);
191         CSSRule* createImportRule(const ParseString&, MediaList*);
192         CSSRule* createMediaRule(MediaList*, CSSRuleList*);
193         CSSRuleList* createRuleList();
194         CSSRule* createStyleRule(CSSSelector*);
195
196         MediaQueryExp* createFloatingMediaQueryExp(const AtomicString&, ValueList*);
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* sinkFloatingMediaQuery(MediaQuery*);
202
203     public:
204         bool strict;
205         bool important;
206         int id;
207         StyleList* styleElement;
208         RefPtr<CSSRule> rule;
209         MediaQuery* mediaQuery;
210         ValueList* valueList;
211         CSSProperty** parsedProperties;
212         int numParsedProperties;
213         int maxParsedProperties;
214
215         int m_inParseShorthand;
216         int m_currentShorthand;
217         bool m_implicitShorthand;
218
219         AtomicString defaultNamespace;
220
221         static CSSParser* currentParser;
222
223         // tokenizer methods and data
224     public:
225         int lex(void* yylval);
226         int token() { return yyTok; }
227         UChar* text(int* length);
228         int lex();
229         
230     private:
231         void clearProperties();
232
233         void setupParser(const char* prefix, const String&, const char* suffix);
234
235         bool inShorthand() const { return m_inParseShorthand; }
236
237         UChar* data;
238         UChar* yytext;
239         UChar* yy_c_buf_p;
240         UChar yy_hold_char;
241         int yy_last_accepting_state;
242         UChar* yy_last_accepting_cpos;
243         int yyleng;
244         int yyTok;
245         int yy_start;
246
247         Vector<RefPtr<StyleBase> > m_parsedStyleObjects;
248         Vector<RefPtr<CSSRuleList> > m_parsedRuleLists;
249         HashSet<CSSSelector*> m_floatingSelectors;
250         HashSet<ValueList*> m_floatingValueLists;
251         HashSet<Function*> m_floatingFunctions;
252
253         MediaQuery* m_floatingMediaQuery;
254         MediaQueryExp* m_floatingMediaQueryExp;
255         Vector<MediaQueryExp*>* m_floatingMediaQueryExpList;
256
257         // defines units allowed for a certain property, used in parseUnit
258         enum Units {
259             FUnknown   = 0x0000,
260             FInteger   = 0x0001,
261             FNumber    = 0x0002,  // Real Numbers
262             FPercent   = 0x0004,
263             FLength    = 0x0008,
264             FAngle     = 0x0010,
265             FTime      = 0x0020,
266             FFrequency = 0x0040,
267             FRelative  = 0x0100,
268             FNonNeg    = 0x0200
269         };
270
271         friend inline Units operator|(Units a, Units b)
272         {
273             return static_cast<Units>(static_cast<unsigned>(a) | static_cast<unsigned>(b));
274         }
275
276         static bool validUnit(Value*, Units, bool strict);
277     };
278
279 } // namespace WebCore
280
281 #endif // cssparser_h