2006-05-13 Rob Buis <buis@kde.org>
[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 CSS_cssparser_h_
24 #define CSS_cssparser_h_
25
26 #include "AtomicString.h"
27 #include "Color.h"
28 #include <wtf/HashSet.h>
29 #include <wtf/Vector.h>
30
31 namespace WebCore {
32
33     class CSSMutableStyleDeclaration;
34     class CSSPrimitiveValue;
35     class CSSProperty;
36     class CSSRule;
37     class CSSRuleList;
38     class CSSSelector;
39     class CSSStyleSheet;
40     class CSSValue;
41     class CSSValueList;
42     class Document;
43     class MediaList;
44     class StyleBase;
45     class StyleList;
46
47     struct ParseString {
48         UChar* characters;
49         int length;
50         
51         void lower();
52     };
53
54     struct Function;
55     
56     struct Value {
57         int id;
58         bool isInt;
59         union {
60             double fValue;
61             int iValue;
62             ParseString string;
63             Function* function;
64         };
65         enum {
66             Operator = 0x100000,
67             Function = 0x100001,
68             Q_EMS    = 0x100002
69         };
70         int unit;
71     };
72
73     DeprecatedString deprecatedString(const ParseString&);
74     static inline String domString(const ParseString& ps) {
75         return String(ps.characters, ps.length);
76     }
77     static inline AtomicString atomicString(const ParseString& ps) {
78         return AtomicString(ps.characters, ps.length);
79     }
80
81     class ValueList {
82     public:
83         ValueList() : m_current(0) { }
84         ~ValueList();
85         void addValue(const Value& v) { m_values.append(v); }
86         unsigned size() const { return m_values.size(); }
87         Value* current() { return m_current < m_values.size() ? &m_values[m_current] : 0; }
88         Value* next() { ++m_current; return current(); }
89     private:
90         Vector<Value, 16> m_values;
91         unsigned m_current;
92     };
93
94     struct Function {
95         ParseString name;
96         ValueList* args;
97
98         ~Function() { delete args; }
99     };
100     
101     class CSSParser
102     {
103     public:
104         CSSParser(bool strictParsing = true);
105         ~CSSParser();
106
107         void parseSheet(CSSStyleSheet*, const String&);
108         PassRefPtr<CSSRule> parseRule(CSSStyleSheet*, const String&);
109         bool parseValue(CSSMutableStyleDeclaration*, int id, const String&, bool important);
110         static RGBA32 parseColor(const String&);
111         bool parseColor(CSSMutableStyleDeclaration*, const String&);
112         bool parseDeclaration(CSSMutableStyleDeclaration*, const String&);
113
114         static CSSParser* current() { return currentParser; }
115
116         Document* document() const;
117
118         void addProperty(int propId, CSSValue*, bool important);
119         void rollbackLastProperties(int num);
120         bool hasProperties() const { return numParsedProperties > 0; }
121
122         bool parseValue(int propId, bool important);
123         bool parseShorthand(int propId, const int* properties, int numProperties, bool important);
124         bool parse4Values(int propId, const int* properties, bool important);
125         bool parseContent(int propId, bool important);
126
127         CSSValue* parseBackgroundColor();
128         CSSValue* parseBackgroundImage();
129         CSSValue* parseBackgroundPositionXY(bool& xFound, bool& yFound);
130         void parseBackgroundPosition(CSSValue*& value1, CSSValue*& value2);
131         CSSValue* parseBackgroundSize();
132         
133         bool parseBackgroundProperty(int propId, int& propId1, int& propId2, CSSValue*& retValue1, CSSValue*& retValue2);
134         bool parseBackgroundShorthand(bool important);
135
136         void addBackgroundValue(CSSValue*& lval, CSSValue* rval);
137       
138 #if __APPLE__
139         bool parseDashboardRegions(int propId, bool important);
140 #endif
141
142         bool parseShape(int propId, bool important);
143         bool parseFont(bool important);
144         CSSValueList* parseFontFamily();
145         CSSPrimitiveValue* parseColor();
146         CSSPrimitiveValue* parseColorFromValue(Value*);
147         
148 #if SVG_SUPPORT
149         bool parseSVGValue(int propId, bool important);
150         CSSValue* parseSVGPaint();
151         CSSValue* parseSVGColor();
152         CSSValue* parseSVGStrokeDasharray();
153 #endif
154
155         static bool parseColor(const DeprecatedString&, RGBA32& rgb);
156
157         // CSS3 Parsing Routines (for properties specific to CSS3)
158         bool parseShadow(int propId, bool important);
159         bool parseBorderImage(int propId, bool important);
160
161         int yyparse();
162
163         CSSSelector* createFloatingSelector();
164         CSSSelector* sinkFloatingSelector(CSSSelector*);
165
166         ValueList* createFloatingValueList();
167         ValueList* sinkFloatingValueList(ValueList*);
168
169         Function* createFloatingFunction();
170         Function* sinkFloatingFunction(Function*);
171
172         Value& sinkFloatingValue(Value&);
173
174         MediaList* createMediaList();
175         CSSRule* createImportRule(const ParseString&, MediaList*);
176         CSSRule* createMediaRule(MediaList*, CSSRuleList*);
177         CSSRuleList* createRuleList();
178         CSSRule* createStyleRule(CSSSelector*);
179
180     public:
181         bool strict;
182         bool important;
183         int id;
184         StyleList* styleElement;
185         RefPtr<CSSRule> rule;
186         ValueList* valueList;
187         CSSProperty** parsedProperties;
188         int numParsedProperties;
189         int maxParsedProperties;
190         
191         int m_inParseShorthand;
192         int m_currentShorthand;
193         bool m_implicitShorthand;
194
195         AtomicString defaultNamespace;
196
197         static CSSParser* currentParser;
198
199         // tokenizer methods and data
200     public:
201         int lex(void* yylval);
202         int token() { return yyTok; }
203         UChar* text(int* length);
204         int lex();
205         
206     private:
207         void clearProperties();
208
209         void setupParser(const char* prefix, const String&, const char* suffix);
210
211         bool inShorthand() const { return m_inParseShorthand; }
212
213         UChar* data;
214         UChar* yytext;
215         UChar* yy_c_buf_p;
216         UChar yy_hold_char;
217         int yy_last_accepting_state;
218         UChar* yy_last_accepting_cpos;
219         int yyleng;
220         int yyTok;
221         int yy_start;
222
223         Vector<RefPtr<StyleBase> > m_parsedStyleObjects;
224         Vector<RefPtr<CSSRuleList> > m_parsedRuleLists;
225         HashSet<CSSSelector*> m_floatingSelectors;
226         HashSet<ValueList*> m_floatingValueLists;
227         HashSet<Function*> m_floatingFunctions;
228
229         // defines units allowed for a certain property, used in parseUnit
230         enum Units {
231             FUnknown   = 0x0000,
232             FInteger   = 0x0001,
233             FNumber    = 0x0002,  // Real Numbers
234             FPercent   = 0x0004,
235             FLength    = 0x0008,
236             FAngle     = 0x0010,
237             FTime      = 0x0020,
238             FFrequency = 0x0040,
239             FRelative  = 0x0100,
240             FNonNeg    = 0x0200
241         };
242
243         friend inline Units operator|(Units a, Units b)
244             { return static_cast<Units>(static_cast<unsigned>(a) | static_cast<unsigned>(b)); }
245
246         static bool validUnit(Value*, Units, bool strict);
247     };
248
249 } // namespace
250
251 #endif