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