JavaScriptCore:
[WebKit-https.git] / WebCore / css / CSSParser.cpp
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) 2005 Allan Sandfeld Jensen (kde@carewolf.com)
6  * Copyright (C) 2004, 2005, 2006, 2007 Apple Inc. All rights reserved.
7  *
8  * This library is free software; you can redistribute it and/or
9  * modify it under the terms of the GNU Library General Public
10  * License as published by the Free Software Foundation; either
11  * version 2 of the License, or (at your option) any later version.
12  *
13  * This library is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
16  * Library General Public License for more details.
17  *
18  * You should have received a copy of the GNU Library General Public License
19  * along with this library; see the file COPYING.LIB.  If not, write to
20  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
21  * Boston, MA 02110-1301, USA.
22  */
23
24 #include "config.h"
25 #include "CSSParser.h"
26
27 #include "CSSBorderImageValue.h"
28 #include "CSSCharsetRule.h"
29 #include "CSSCursorImageValue.h"
30 #include "CSSHelper.h"
31 #include "CSSImageValue.h"
32 #include "CSSImportRule.h"
33 #include "CSSInheritedValue.h"
34 #include "CSSInitialValue.h"
35 #include "CSSMediaRule.h"
36 #include "CSSMutableStyleDeclaration.h"
37 #include "CSSPrimitiveValue.h"
38 #include "CSSProperty.h"
39 #include "CSSPropertyNames.h"
40 #include "CSSQuirkPrimitiveValue.h"
41 #include "CSSRuleList.h"
42 #include "CSSSelector.h"
43 #include "CSSStyleRule.h"
44 #include "CSSStyleSheet.h"
45 #include "CSSValueKeywords.h"
46 #include "CSSValueList.h"
47 #include "Counter.h"
48 #include "DashboardRegion.h"
49 #include "Document.h"
50 #include "FontFamilyValue.h"
51 #include "FontValue.h"
52 #include "KURL.h"
53 #include "MediaList.h"
54 #include "MediaQueryExp.h"
55 #include "Pair.h"
56 #include "ShadowValue.h"
57
58 #define YYDEBUG 0
59
60 #if YYDEBUG > 0
61 extern int cssyydebug;
62 #endif
63
64 extern int cssyyparse(void* parser);
65
66 using namespace std;
67 using namespace WTF;
68
69 namespace WebCore {
70
71 ValueList::~ValueList()
72 {
73      size_t numValues = m_values.size();
74      for (size_t i = 0; i < numValues; i++)
75          if (m_values[i].unit == Value::Function)
76              delete m_values[i].function;
77 }
78
79 namespace {
80     class ShorthandScope {
81     public:
82         ShorthandScope(CSSParser* parser, int propId) : m_parser(parser)
83         {
84             if (!(m_parser->m_inParseShorthand++))
85                 m_parser->m_currentShorthand = propId;
86         }
87         ~ShorthandScope()
88         {
89             if (!(--m_parser->m_inParseShorthand))
90                 m_parser->m_currentShorthand = 0;
91         }
92
93     private:
94         CSSParser* m_parser;
95     };
96 }
97
98 CSSParser* CSSParser::currentParser = 0;
99
100 CSSParser::CSSParser(bool strictParsing)
101     : m_floatingMediaQuery(0)
102     , m_floatingMediaQueryExp(0)
103     , m_floatingMediaQueryExpList(0)
104 {
105 #ifdef CSS_DEBUG
106     kdDebug(6080) << "CSSParser::CSSParser this=" << this << endl;
107 #endif
108     strict = strictParsing;
109
110     parsedProperties = (CSSProperty **)fastMalloc(32 * sizeof(CSSProperty *));
111     numParsedProperties = 0;
112     maxParsedProperties = 32;
113
114     data = 0;
115     valueList = 0;
116     id = 0;
117     important = false;
118     m_inParseShorthand = 0;
119     m_currentShorthand = 0;
120     m_implicitShorthand = false;
121
122     defaultNamespace = starAtom;
123     
124     yy_start = 1;
125
126 #if YYDEBUG > 0
127     cssyydebug = 1;
128 #endif
129 }
130
131 CSSParser::~CSSParser()
132 {
133     clearProperties();
134     fastFree(parsedProperties);
135
136     delete valueList;
137
138     fastFree(data);
139
140     if (m_floatingMediaQueryExpList) {
141         deleteAllValues(*m_floatingMediaQueryExpList);
142         delete m_floatingMediaQueryExpList;
143     }
144     delete m_floatingMediaQueryExp;
145     delete m_floatingMediaQuery;
146     deleteAllValues(m_floatingSelectors);
147     deleteAllValues(m_floatingValueLists);
148     deleteAllValues(m_floatingFunctions);
149 }
150
151 void ParseString::lower()
152 {
153     // Fast case for all-ASCII.
154     UChar ored = 0;
155     for (int i = 0; i < length; i++)
156         ored |= characters[i];
157     if (ored & ~0x7F)
158         for (int i = 0; i < length; i++)
159             characters[i] = Unicode::toLower(characters[i]);
160     else
161         for (int i = 0; i < length; i++)
162             characters[i] = tolower(characters[i]);
163 }
164
165 void CSSParser::setupParser(const char* prefix, const String& string, const char* suffix)
166 {
167     int length = string.length() + strlen(prefix) + strlen(suffix) + 2;
168
169     if (data)
170         fastFree(data);
171     
172     data = static_cast<UChar*>(fastMalloc(length * sizeof(UChar)));
173     for (unsigned i = 0; i < strlen(prefix); i++)
174         data[i] = prefix[i];
175     
176     memcpy(data + strlen(prefix), string.characters(), string.length() * sizeof(UChar));
177
178     unsigned start = strlen(prefix) + string.length();
179     unsigned end = start + strlen(suffix);
180     for (unsigned i = start; i < end; i++)
181         data[i] = suffix[i - start];
182
183     data[length - 1] = 0;
184     data[length - 2] = 0;
185
186     yy_hold_char = 0;
187     yyleng = 0;
188     yytext = yy_c_buf_p = data;
189     yy_hold_char = *yy_c_buf_p;
190 }
191
192 void CSSParser::parseSheet(CSSStyleSheet* sheet, const String& string)
193 {
194     styleElement = sheet;
195     defaultNamespace = starAtom; // Reset the default namespace.
196     
197     setupParser("", string, "");
198
199     CSSParser* old = currentParser;
200     currentParser = this;
201     cssyyparse(this);
202     currentParser = old;
203
204     rule = 0;
205 }
206
207 PassRefPtr<CSSRule> CSSParser::parseRule(CSSStyleSheet *sheet, const String &string)
208 {
209     styleElement = sheet;
210     
211     setupParser("@-webkit-rule{", string, "} ");
212
213     CSSParser* old = currentParser;
214     currentParser = this;
215     cssyyparse(this);
216     currentParser = old;
217
218     return rule.release();
219 }
220
221 bool CSSParser::parseValue(CSSMutableStyleDeclaration *declaration, int _id, const String &string, bool _important)
222 {
223     styleElement = declaration->stylesheet();
224
225     setupParser("@-webkit-value{", string, "} ");
226
227     id = _id;
228     important = _important;
229     
230     CSSParser* old = currentParser;
231     currentParser = this;
232     cssyyparse(this);
233     currentParser = old;
234     
235     rule = 0;
236
237     bool ok = false;
238     if (numParsedProperties) {
239         ok = true;
240         declaration->addParsedProperties(parsedProperties, numParsedProperties);
241         clearProperties();
242     }
243
244     return ok;
245 }
246
247 RGBA32 CSSParser::parseColor(const String &string, bool strict)
248 {
249     RGBA32 color = 0;
250     RefPtr<CSSMutableStyleDeclaration>dummyStyleDeclaration = new CSSMutableStyleDeclaration;
251
252     CSSParser parser(true);
253
254     // First try creating a color specified by name or the "#" syntax.
255     if (!parser.parseColor(string, color, strict)) {
256     
257         // Now try to create a color from the rgb() or rgba() syntax.
258         if (parser.parseColor(dummyStyleDeclaration.get(), string)) {
259             CSSValue* value = parser.parsedProperties[0]->value();
260             if (value->cssValueType() == CSSValue::CSS_PRIMITIVE_VALUE) {
261                 CSSPrimitiveValue *primitiveValue = static_cast<CSSPrimitiveValue *>(value);
262                 color = primitiveValue->getRGBColorValue();
263             }
264         }
265     }
266     
267     return color;
268 }
269
270 bool CSSParser::parseColor(CSSMutableStyleDeclaration *declaration, const String &string)
271 {
272     styleElement = declaration->stylesheet();
273
274     setupParser("@-webkit-decls{color:", string, "} ");
275
276     CSSParser* old = currentParser;
277     currentParser = this;
278     cssyyparse(this);
279     currentParser = old;
280
281     rule = 0;
282
283     bool ok = false;
284     if (numParsedProperties && parsedProperties[0]->m_id == CSS_PROP_COLOR)
285         ok = true;
286
287     return ok;
288 }
289
290 bool CSSParser::parseDeclaration(CSSMutableStyleDeclaration *declaration, const String &string)
291 {
292     styleElement = declaration->stylesheet();
293
294     setupParser("@-webkit-decls{", string, "} ");
295
296     CSSParser* old = currentParser;
297     currentParser = this;
298     cssyyparse(this);
299     currentParser = old;
300
301     rule = 0;
302
303     bool ok = false;
304     if (numParsedProperties) {
305         ok = true;
306         declaration->addParsedProperties(parsedProperties, numParsedProperties);
307         clearProperties();
308     }
309
310     return ok;
311 }
312
313 bool CSSParser::parseMediaQuery(MediaList* queries, const String& string)
314 {
315     if (string.isEmpty() || string.isNull()) {
316         return true;
317     }
318
319     mediaQuery = 0;
320     // can't use { because tokenizer state switches from mediaquery to initial state when it sees { token.
321     // instead insert one " " (which is WHITESPACE in CSSGrammar.y)
322     setupParser ("@-webkit-mediaquery ", string, "} ");
323
324     CSSParser* old = currentParser;
325     currentParser = this;
326     cssyyparse(this);
327     currentParser = old;
328
329     bool ok = false;
330     if (mediaQuery) {
331         ok = true;
332         queries->appendMediaQuery(mediaQuery);
333         mediaQuery = 0;
334     }
335
336     return ok;
337 }
338
339
340 void CSSParser::addProperty(int propId, PassRefPtr<CSSValue> value, bool important)
341 {
342     CSSProperty *prop = new CSSProperty(propId, value, important, m_currentShorthand, m_implicitShorthand);
343     if (numParsedProperties >= maxParsedProperties) {
344         maxParsedProperties += 32;
345         parsedProperties = (CSSProperty **)fastRealloc(parsedProperties,
346                                                        maxParsedProperties*sizeof(CSSProperty *));
347     }
348     parsedProperties[numParsedProperties++] = prop;
349 }
350
351 void CSSParser::rollbackLastProperties(int num)
352 {
353     ASSERT(num >= 0);
354     ASSERT(numParsedProperties >= num);
355
356     for (int i = 0; i < num; ++i)
357         delete parsedProperties[--numParsedProperties];
358 }
359
360 void CSSParser::clearProperties()
361 {
362     for (int i = 0; i < numParsedProperties; i++)
363         delete parsedProperties[i];
364     numParsedProperties = 0;
365 }
366
367 Document *CSSParser::document() const
368 {
369     StyleBase *root = styleElement;
370     Document *doc = 0;
371     while (root->parent())
372         root = root->parent();
373     if (root->isCSSStyleSheet())
374         doc = static_cast<CSSStyleSheet*>(root)->doc();
375     return doc;
376 }
377
378 bool CSSParser::validUnit(Value* value, Units unitflags, bool strict)
379 {
380     if (unitflags & FNonNeg && value->fValue < 0)
381         return false;
382
383     bool b = false;
384     switch(value->unit) {
385     case CSSPrimitiveValue::CSS_NUMBER:
386         b = (unitflags & FNumber);
387         if (!b && ((unitflags & FLength) && (value->fValue == 0 || !strict))) {
388             value->unit = CSSPrimitiveValue::CSS_PX;
389             b = true;
390         }
391         if (!b && (unitflags & FInteger) && value->isInt)
392             b = true;
393         break;
394     case CSSPrimitiveValue::CSS_PERCENTAGE:
395         b = (unitflags & FPercent);
396         break;
397     case Value::Q_EMS:
398     case CSSPrimitiveValue::CSS_EMS:
399     case CSSPrimitiveValue::CSS_EXS:
400     case CSSPrimitiveValue::CSS_PX:
401     case CSSPrimitiveValue::CSS_CM:
402     case CSSPrimitiveValue::CSS_MM:
403     case CSSPrimitiveValue::CSS_IN:
404     case CSSPrimitiveValue::CSS_PT:
405     case CSSPrimitiveValue::CSS_PC:
406         b = (unitflags & FLength);
407         break;
408     case CSSPrimitiveValue::CSS_MS:
409     case CSSPrimitiveValue::CSS_S:
410         b = (unitflags & FTime);
411         break;
412     case CSSPrimitiveValue::CSS_DEG:
413     case CSSPrimitiveValue::CSS_RAD:
414     case CSSPrimitiveValue::CSS_GRAD:
415     case CSSPrimitiveValue::CSS_HZ:
416     case CSSPrimitiveValue::CSS_KHZ:
417     case CSSPrimitiveValue::CSS_DIMENSION:
418     default:
419         break;
420     }
421     return b;
422 }
423
424 static int unitFromString(Value* value)
425 {
426     if (value->unit != CSSPrimitiveValue::CSS_IDENT || value->id)
427         return 0;
428
429     String str = domString(value->string);
430     if (str == "em")
431         return CSSPrimitiveValue::CSS_EMS;
432     if (str == "ex")
433         return CSSPrimitiveValue::CSS_EXS;
434     if (str == "px")
435         return CSSPrimitiveValue::CSS_PX;
436     if (str == "cm")
437         return CSSPrimitiveValue::CSS_CM;
438     if (str == "mm")
439         return CSSPrimitiveValue::CSS_MM;
440     if (str == "in")
441         return CSSPrimitiveValue::CSS_IN;
442     if (str == "pt")
443         return CSSPrimitiveValue::CSS_PT;
444     if (str == "pc")
445         return CSSPrimitiveValue::CSS_PC;
446     if (str == "deg")
447         return CSSPrimitiveValue::CSS_DEG;
448     if (str == "rad")
449         return CSSPrimitiveValue::CSS_RAD;
450     if (str == "grad")
451         return CSSPrimitiveValue::CSS_GRAD;
452     if (str == "ms")
453         return CSSPrimitiveValue::CSS_MS;
454     if (str == "s")
455         return CSSPrimitiveValue::CSS_S;
456     if (str == "Hz")
457         return CSSPrimitiveValue::CSS_HZ;
458     if (str == "kHz")
459         return CSSPrimitiveValue::CSS_KHZ;
460     
461     return 0;
462 }
463
464 void CSSParser::checkForOrphanedUnits()
465 {
466     if (strict || inShorthand())
467         return;
468         
469     // The purpose of this code is to implement the WinIE quirk that allows unit types to be separated from their numeric values
470     // by whitespace, so e.g., width: 20 px instead of width:20px.  This is invalid CSS, so we don't do this in strict mode.
471     Value* numericVal = 0;
472     unsigned size = valueList->size();
473     for (unsigned i = 0; i < size; i++) {
474         Value* value = valueList->valueAt(i);
475         if (numericVal) {
476             // Change the unit type of the numeric val to match.
477             int unit = unitFromString(value);
478             if (unit) {
479                 numericVal->unit = unit;
480                 numericVal = 0;
481
482                 // Now delete the bogus unit value.
483                 valueList->deleteValueAt(i);
484                 i--; // We're safe even though |i| is unsigned, since we only hit this code if we had a previous numeric value (so |i| is always > 0 here).
485                 size--;
486                 continue;
487             }
488         }
489         
490         numericVal = (value->unit == CSSPrimitiveValue::CSS_NUMBER) ? value : 0;
491     }
492 }
493
494 bool CSSParser::parseValue(int propId, bool important)
495 {
496     if (!valueList)
497         return false;
498
499     Value *value = valueList->current();
500
501     if (!value)
502         return false;
503
504     int id = value->id;
505
506     int num = inShorthand() ? 1 : valueList->size();
507
508     if (id == CSS_VAL_INHERIT) {
509         if (num != 1)
510             return false;
511         addProperty(propId, new CSSInheritedValue(), important);
512         return true;
513     }
514     else if (id == CSS_VAL_INITIAL) {
515         if (num != 1)
516             return false;
517         addProperty(propId, new CSSInitialValue(false), important);
518         return true;
519     }
520
521     bool valid_primitive = false;
522     CSSValue *parsedValue = 0;
523
524     // In quirks mode, we will look for units that have been incorrectly separated from the number they belong to
525     // by a space.  We go ahead and associate the unit with the number even though it is invalid CSS.
526     checkForOrphanedUnits();
527
528     switch (static_cast<CSSPropertyID>(propId)) {
529         /* The comment to the left defines all valid value of this properties as defined
530          * in CSS 2, Appendix F. Property index
531          */
532
533         /* All the CSS properties are not supported by the renderer at the moment.
534          * Note that all the CSS2 Aural properties are only checked, if CSS_AURAL is defined
535          * (see parseAuralValues). As we don't support them at all this seems reasonable.
536          */
537
538     case CSS_PROP_SIZE:                 // <length>{1,2} | auto | portrait | landscape | inherit
539     case CSS_PROP_QUOTES:               // [<string> <string>]+ | none | inherit
540         if (id)
541             valid_primitive = true;
542         break;
543     case CSS_PROP_UNICODE_BIDI:         // normal | embed | bidi-override | inherit
544         if (id == CSS_VAL_NORMAL ||
545              id == CSS_VAL_EMBED ||
546              id == CSS_VAL_BIDI_OVERRIDE)
547             valid_primitive = true;
548         break;
549
550     case CSS_PROP_POSITION:             // static | relative | absolute | fixed | inherit
551         if (id == CSS_VAL_STATIC ||
552              id == CSS_VAL_RELATIVE ||
553              id == CSS_VAL_ABSOLUTE ||
554              id == CSS_VAL_FIXED)
555             valid_primitive = true;
556         break;
557
558     case CSS_PROP_PAGE_BREAK_AFTER:     // auto | always | avoid | left | right | inherit
559     case CSS_PROP_PAGE_BREAK_BEFORE:
560     case CSS_PROP__WEBKIT_COLUMN_BREAK_AFTER:
561     case CSS_PROP__WEBKIT_COLUMN_BREAK_BEFORE:
562         if (id == CSS_VAL_AUTO ||
563              id == CSS_VAL_ALWAYS ||
564              id == CSS_VAL_AVOID ||
565              id == CSS_VAL_LEFT ||
566              id == CSS_VAL_RIGHT)
567             valid_primitive = true;
568         break;
569
570     case CSS_PROP_PAGE_BREAK_INSIDE:    // avoid | auto | inherit
571     case CSS_PROP__WEBKIT_COLUMN_BREAK_INSIDE:
572         if (id == CSS_VAL_AUTO || id == CSS_VAL_AVOID)
573             valid_primitive = true;
574         break;
575
576     case CSS_PROP_EMPTY_CELLS:          // show | hide | inherit
577         if (id == CSS_VAL_SHOW ||
578              id == CSS_VAL_HIDE)
579             valid_primitive = true;
580         break;
581
582     case CSS_PROP_CONTENT:              // [ <string> | <uri> | <counter> | attr(X) | open-quote |
583         // close-quote | no-open-quote | no-close-quote ]+ | inherit
584         return parseContent(propId, important);
585         break;
586
587     case CSS_PROP_WHITE_SPACE:          // normal | pre | nowrap | inherit
588         if (id == CSS_VAL_NORMAL ||
589             id == CSS_VAL_PRE ||
590             id == CSS_VAL_PRE_WRAP ||
591             id == CSS_VAL_PRE_LINE ||
592             id == CSS_VAL_NOWRAP)
593             valid_primitive = true;
594         break;
595
596     case CSS_PROP_CLIP:                 // <shape> | auto | inherit
597         if (id == CSS_VAL_AUTO)
598             valid_primitive = true;
599         else if (value->unit == Value::Function)
600             return parseShape(propId, important);
601         break;
602
603     /* Start of supported CSS properties with validation. This is needed for parseShorthand to work
604      * correctly and allows optimization in WebCore::applyRule(..)
605      */
606     case CSS_PROP_CAPTION_SIDE:         // top | bottom | left | right | inherit
607         if (id == CSS_VAL_LEFT || id == CSS_VAL_RIGHT ||
608             id == CSS_VAL_TOP || id == CSS_VAL_BOTTOM)
609             valid_primitive = true;
610         break;
611
612     case CSS_PROP_BORDER_COLLAPSE:      // collapse | separate | inherit
613         if (id == CSS_VAL_COLLAPSE || id == CSS_VAL_SEPARATE)
614             valid_primitive = true;
615         break;
616
617     case CSS_PROP_VISIBILITY:           // visible | hidden | collapse | inherit
618         if (id == CSS_VAL_VISIBLE || id == CSS_VAL_HIDDEN || id == CSS_VAL_COLLAPSE)
619             valid_primitive = true;
620         break;
621
622     case CSS_PROP_OVERFLOW: {
623         ShorthandScope scope(this, propId);
624         if (num != 1 || !parseValue(CSS_PROP_OVERFLOW_X, important))
625             return false;
626         CSSValue* value = parsedProperties[numParsedProperties - 1]->value();
627         addProperty(CSS_PROP_OVERFLOW_Y, value, important);
628         return true;
629     }
630     case CSS_PROP_OVERFLOW_X:
631     case CSS_PROP_OVERFLOW_Y:           // visible | hidden | scroll | auto | marquee | overlay | inherit
632         if (id == CSS_VAL_VISIBLE || id == CSS_VAL_HIDDEN || id == CSS_VAL_SCROLL || id == CSS_VAL_AUTO ||
633             id == CSS_VAL_OVERLAY || id == CSS_VAL__WEBKIT_MARQUEE)
634             valid_primitive = true;
635         break;
636
637     case CSS_PROP_LIST_STYLE_POSITION:  // inside | outside | inherit
638         if (id == CSS_VAL_INSIDE || id == CSS_VAL_OUTSIDE)
639             valid_primitive = true;
640         break;
641
642     case CSS_PROP_LIST_STYLE_TYPE:
643         // disc | circle | square | decimal | decimal-leading-zero | lower-roman |
644         // upper-roman | lower-greek | lower-alpha | lower-latin | upper-alpha |
645         // upper-latin | hebrew | armenian | georgian | cjk-ideographic | hiragana |
646         // katakana | hiragana-iroha | katakana-iroha | none | inherit
647         if ((id >= CSS_VAL_DISC && id <= CSS_VAL_KATAKANA_IROHA) || id == CSS_VAL_NONE)
648             valid_primitive = true;
649         break;
650
651     case CSS_PROP_DISPLAY:
652         // inline | block | list-item | run-in | inline-block | table |
653         // inline-table | table-row-group | table-header-group | table-footer-group | table-row |
654         // table-column-group | table-column | table-cell | table-caption | box | inline-box | none | inherit
655         if ((id >= CSS_VAL_INLINE && id <= CSS_VAL__WEBKIT_INLINE_BOX) || id == CSS_VAL_NONE)
656             valid_primitive = true;
657         break;
658
659     case CSS_PROP_DIRECTION:            // ltr | rtl | inherit
660         if (id == CSS_VAL_LTR || id == CSS_VAL_RTL)
661             valid_primitive = true;
662         break;
663
664     case CSS_PROP_TEXT_TRANSFORM:       // capitalize | uppercase | lowercase | none | inherit
665         if ((id >= CSS_VAL_CAPITALIZE && id <= CSS_VAL_LOWERCASE) || id == CSS_VAL_NONE)
666             valid_primitive = true;
667         break;
668
669     case CSS_PROP_FLOAT:                // left | right | none | inherit + center for buggy CSS
670         if (id == CSS_VAL_LEFT || id == CSS_VAL_RIGHT ||
671              id == CSS_VAL_NONE || id == CSS_VAL_CENTER)
672             valid_primitive = true;
673         break;
674
675     case CSS_PROP_CLEAR:                // none | left | right | both | inherit
676         if (id == CSS_VAL_NONE || id == CSS_VAL_LEFT ||
677              id == CSS_VAL_RIGHT|| id == CSS_VAL_BOTH)
678             valid_primitive = true;
679         break;
680
681     case CSS_PROP_TEXT_ALIGN:
682         // left | right | center | justify | webkit_left | webkit_right | webkit_center | <string> | inherit
683         if ((id >= CSS_VAL__WEBKIT_AUTO && id <= CSS_VAL__WEBKIT_CENTER) ||
684              value->unit == CSSPrimitiveValue::CSS_STRING)
685             valid_primitive = true;
686         break;
687
688     case CSS_PROP_OUTLINE_STYLE:        // <border-style> | auto | inherit
689         if (id == CSS_VAL_AUTO) {
690             valid_primitive = true;
691             break;
692         } // Fall through!
693     case CSS_PROP_BORDER_TOP_STYLE:     //// <border-style> | inherit
694     case CSS_PROP_BORDER_RIGHT_STYLE:   //   Defined as:    none | hidden | dotted | dashed |
695     case CSS_PROP_BORDER_BOTTOM_STYLE:  //   solid | double | groove | ridge | inset | outset
696     case CSS_PROP_BORDER_LEFT_STYLE:
697     case CSS_PROP__WEBKIT_COLUMN_RULE_STYLE:
698         if (id >= CSS_VAL_NONE && id <= CSS_VAL_DOUBLE)
699             valid_primitive = true;
700         break;
701
702     case CSS_PROP_FONT_WEIGHT:  // normal | bold | bolder | lighter | 100 | 200 | 300 | 400 |
703         // 500 | 600 | 700 | 800 | 900 | inherit
704         if (id >= CSS_VAL_NORMAL && id <= CSS_VAL_900) {
705             // Allready correct id
706             valid_primitive = true;
707         } else if (validUnit(value, FInteger|FNonNeg, false)) {
708             int weight = (int)value->fValue;
709             if ((weight % 100))
710                 break;
711             weight /= 100;
712             if (weight >= 1 && weight <= 9) {
713                 id = CSS_VAL_100 + weight - 1;
714                 valid_primitive = true;
715             }
716         }
717         break;
718
719     case CSS_PROP_BORDER_SPACING: {
720         const int properties[2] = { CSS_PROP__WEBKIT_BORDER_HORIZONTAL_SPACING,
721                                     CSS_PROP__WEBKIT_BORDER_VERTICAL_SPACING };
722         if (num == 1) {
723             ShorthandScope scope(this, CSS_PROP_BORDER_SPACING);
724             if (!parseValue(properties[0], important))
725                 return false;
726             CSSValue* value = parsedProperties[numParsedProperties-1]->value();
727             addProperty(properties[1], value, important);
728             return true;
729         }
730         else if (num == 2) {
731             ShorthandScope scope(this, CSS_PROP_BORDER_SPACING);
732             if (!parseValue(properties[0], important) || !parseValue(properties[1], important))
733                 return false;
734             return true;
735         }
736         return false;
737     }
738     case CSS_PROP__WEBKIT_BORDER_HORIZONTAL_SPACING:
739     case CSS_PROP__WEBKIT_BORDER_VERTICAL_SPACING:
740         valid_primitive = validUnit(value, FLength|FNonNeg, strict);
741         break;
742     case CSS_PROP_SCROLLBAR_FACE_COLOR:         // IE5.5
743     case CSS_PROP_SCROLLBAR_SHADOW_COLOR:       // IE5.5
744     case CSS_PROP_SCROLLBAR_HIGHLIGHT_COLOR:    // IE5.5
745     case CSS_PROP_SCROLLBAR_3DLIGHT_COLOR:      // IE5.5
746     case CSS_PROP_SCROLLBAR_DARKSHADOW_COLOR:   // IE5.5
747     case CSS_PROP_SCROLLBAR_TRACK_COLOR:        // IE5.5
748     case CSS_PROP_SCROLLBAR_ARROW_COLOR:        // IE5.5
749         if (strict)
750             break;
751         /* nobreak */
752     case CSS_PROP_OUTLINE_COLOR:        // <color> | invert | inherit
753         // Outline color has "invert" as additional keyword.
754         // Also, we want to allow the special focus color even in strict parsing mode.
755         if (propId == CSS_PROP_OUTLINE_COLOR && (id == CSS_VAL_INVERT || id == CSS_VAL__WEBKIT_FOCUS_RING_COLOR)) {
756             valid_primitive = true;
757             break;
758         }
759         /* nobreak */
760     case CSS_PROP_BACKGROUND_COLOR:     // <color> | inherit
761     case CSS_PROP_BORDER_TOP_COLOR:     // <color> | inherit
762     case CSS_PROP_BORDER_RIGHT_COLOR:   // <color> | inherit
763     case CSS_PROP_BORDER_BOTTOM_COLOR:  // <color> | inherit
764     case CSS_PROP_BORDER_LEFT_COLOR:    // <color> | inherit
765     case CSS_PROP_COLOR:                // <color> | inherit
766     case CSS_PROP_TEXT_LINE_THROUGH_COLOR: // CSS3 text decoration colors
767     case CSS_PROP_TEXT_UNDERLINE_COLOR:
768     case CSS_PROP_TEXT_OVERLINE_COLOR:
769     case CSS_PROP__WEBKIT_COLUMN_RULE_COLOR:
770     case CSS_PROP__WEBKIT_TEXT_FILL_COLOR:
771     case CSS_PROP__WEBKIT_TEXT_STROKE_COLOR:
772         if (id == CSS_VAL__WEBKIT_TEXT)
773             valid_primitive = true; // Always allow this, even when strict parsing is on,
774                                     // since we use this in our UA sheets.
775         else if (id >= CSS_VAL_AQUA && id <= CSS_VAL_WINDOWTEXT || id == CSS_VAL_MENU ||
776              (id >= CSS_VAL__WEBKIT_FOCUS_RING_COLOR && id < CSS_VAL__WEBKIT_TEXT && !strict)) {
777             valid_primitive = true;
778         } else {
779             parsedValue = parseColor();
780             if (parsedValue)
781                 valueList->next();
782         }
783         break;
784
785     case CSS_PROP_CURSOR: {
786         // [<uri>,]*  [ auto | crosshair | default | pointer | progress | move | e-resize | ne-resize |
787         // nw-resize | n-resize | se-resize | sw-resize | s-resize | w-resize | ew-resize | 
788         // ns-resize | nesw-resize | nwse-resize | col-resize | row-resize | text | wait | help ] ] | inherit
789         CSSValueList* list = 0;
790         while (value && value->unit == CSSPrimitiveValue::CSS_URI) {
791             if (!list)
792                 list = new CSSValueList; 
793             String uri = parseURL(domString(value->string));
794             Vector<int> coords;
795             value = valueList->next();
796             while (value && value->unit == CSSPrimitiveValue::CSS_NUMBER) {
797                 coords.append(int(value->fValue));
798                 value = valueList->next();
799             }
800             IntPoint hotspot;
801             int nrcoords = coords.size();
802             if (nrcoords > 0 && nrcoords != 2) {
803                 if (strict) { // only support hotspot pairs in strict mode
804                     delete list;
805                     return false;
806                 }
807             } else if(strict && nrcoords == 2)
808                 hotspot = IntPoint(coords[0], coords[1]);
809             if (strict || coords.size() == 0) {
810 #if ENABLE(SVG)
811                 if (uri.startsWith("#"))
812                     list->append(new CSSPrimitiveValue(uri, CSSPrimitiveValue::CSS_URI));
813                 else
814 #endif
815                 if (!uri.isEmpty()) {
816                     list->append(new CSSCursorImageValue(
817                                  String(KURL(styleElement->baseURL().deprecatedString(), uri.deprecatedString()).url()),
818                                  hotspot, styleElement));
819                 }
820             }
821             if ((strict && !value) || (value && !(value->unit == Value::Operator && value->iValue == ','))) {
822                 delete list;
823                 return false;
824             }
825             value = valueList->next(); // comma
826         }
827         if (list) {
828             if (!value) { // no value after url list (MSIE 5 compatibility)
829                 if (list->length() != 1) {
830                     delete list;
831                     return false;
832                 }
833             } else if (!strict && value->id == CSS_VAL_HAND) // MSIE 5 compatibility :/
834                 list->append(new CSSPrimitiveValue(CSS_VAL_POINTER));
835             else if (value && ((value->id >= CSS_VAL_AUTO && value->id <= CSS_VAL_ALL_SCROLL) || value->id == CSS_VAL_COPY || value->id == CSS_VAL_NONE))
836                 list->append(new CSSPrimitiveValue(value->id));
837             valueList->next();
838             parsedValue = list;
839             break;
840         }
841         id = value->id;
842         if (!strict && value->id == CSS_VAL_HAND) { // MSIE 5 compatibility :/
843             id = CSS_VAL_POINTER;
844             valid_primitive = true;
845         } else if ((value->id >= CSS_VAL_AUTO && value->id <= CSS_VAL_ALL_SCROLL) || value->id == CSS_VAL_COPY || value->id == CSS_VAL_NONE)
846             valid_primitive = true;
847         break;
848     }
849
850     case CSS_PROP_BACKGROUND_ATTACHMENT:
851     case CSS_PROP__WEBKIT_BACKGROUND_CLIP:
852     case CSS_PROP__WEBKIT_BACKGROUND_COMPOSITE:
853     case CSS_PROP_BACKGROUND_IMAGE:
854     case CSS_PROP__WEBKIT_BACKGROUND_ORIGIN:
855     case CSS_PROP_BACKGROUND_POSITION:
856     case CSS_PROP_BACKGROUND_POSITION_X:
857     case CSS_PROP_BACKGROUND_POSITION_Y:
858     case CSS_PROP__WEBKIT_BACKGROUND_SIZE:
859     case CSS_PROP_BACKGROUND_REPEAT: {
860         CSSValue *val1 = 0, *val2 = 0;
861         int propId1, propId2;
862         if (parseBackgroundProperty(propId, propId1, propId2, val1, val2)) {
863             addProperty(propId1, val1, important);
864             if (val2)
865                 addProperty(propId2, val2, important);
866             return true;
867         }
868         return false;
869     }
870     case CSS_PROP_LIST_STYLE_IMAGE:     // <uri> | none | inherit
871         if (id == CSS_VAL_NONE) {
872             parsedValue = new CSSImageValue();
873             valueList->next();
874         }
875         else if (value->unit == CSSPrimitiveValue::CSS_URI) {
876             // ### allow string in non strict mode?
877             String uri = parseURL(domString(value->string));
878             if (!uri.isEmpty()) {
879                 parsedValue = new CSSImageValue(
880                     String(KURL(styleElement->baseURL().deprecatedString(), uri.deprecatedString()).url()),
881                     styleElement);
882                 valueList->next();
883             }
884         }
885         break;
886
887     case CSS_PROP__WEBKIT_TEXT_STROKE_WIDTH:
888     case CSS_PROP_OUTLINE_WIDTH:        // <border-width> | inherit
889     case CSS_PROP_BORDER_TOP_WIDTH:     //// <border-width> | inherit
890     case CSS_PROP_BORDER_RIGHT_WIDTH:   //   Which is defined as
891     case CSS_PROP_BORDER_BOTTOM_WIDTH:  //   thin | medium | thick | <length>
892     case CSS_PROP_BORDER_LEFT_WIDTH:
893     case CSS_PROP__WEBKIT_COLUMN_RULE_WIDTH:
894         if (id == CSS_VAL_THIN || id == CSS_VAL_MEDIUM || id == CSS_VAL_THICK)
895             valid_primitive = true;
896         else
897             valid_primitive = validUnit(value, FLength, strict);
898         break;
899
900     case CSS_PROP_LETTER_SPACING:       // normal | <length> | inherit
901     case CSS_PROP_WORD_SPACING:         // normal | <length> | inherit
902         if (id == CSS_VAL_NORMAL)
903             valid_primitive = true;
904         else
905             valid_primitive = validUnit(value, FLength, strict);
906         break;
907
908     case CSS_PROP_WORD_BREAK:          // normal | break-all | break-word (this is a custom extension)
909         if (id == CSS_VAL_NORMAL || id == CSS_VAL_BREAK_ALL || id == CSS_VAL_BREAK_WORD)
910             valid_primitive = true;
911         break;
912
913     case CSS_PROP_WORD_WRAP:           // normal | break-word
914         if (id == CSS_VAL_NORMAL || id == CSS_VAL_BREAK_WORD)
915             valid_primitive = true;
916         break;
917
918     case CSS_PROP_TEXT_INDENT:          // <length> | <percentage> | inherit
919     case CSS_PROP_PADDING_TOP:          //// <padding-width> | inherit
920     case CSS_PROP_PADDING_RIGHT:        //   Which is defined as
921     case CSS_PROP_PADDING_BOTTOM:       //   <length> | <percentage>
922     case CSS_PROP_PADDING_LEFT:         ////
923     case CSS_PROP__WEBKIT_PADDING_START:
924         valid_primitive = (!id && validUnit(value, FLength|FPercent, strict));
925         break;
926
927     case CSS_PROP_MAX_HEIGHT:           // <length> | <percentage> | none | inherit
928     case CSS_PROP_MAX_WIDTH:            // <length> | <percentage> | none | inherit
929         if (id == CSS_VAL_NONE || id == CSS_VAL_INTRINSIC || id == CSS_VAL_MIN_INTRINSIC) {
930             valid_primitive = true;
931             break;
932         }
933         /* nobreak */
934     case CSS_PROP_MIN_HEIGHT:           // <length> | <percentage> | inherit
935     case CSS_PROP_MIN_WIDTH:            // <length> | <percentage> | inherit
936         if (id == CSS_VAL_INTRINSIC || id == CSS_VAL_MIN_INTRINSIC)
937             valid_primitive = true;
938         else
939             valid_primitive = (!id && validUnit(value, FLength|FPercent|FNonNeg, strict));
940         break;
941
942     case CSS_PROP_FONT_SIZE:
943         // <absolute-size> | <relative-size> | <length> | <percentage> | inherit
944         if (id >= CSS_VAL_XX_SMALL && id <= CSS_VAL_LARGER)
945             valid_primitive = true;
946         else
947             valid_primitive = (validUnit(value, FLength|FPercent, strict));
948         break;
949
950     case CSS_PROP_FONT_STYLE:           // normal | italic | oblique | inherit
951         if (id == CSS_VAL_NORMAL || id == CSS_VAL_ITALIC || id == CSS_VAL_OBLIQUE)
952             valid_primitive = true;
953         break;
954
955     case CSS_PROP_FONT_VARIANT:         // normal | small-caps | inherit
956         if (id == CSS_VAL_NORMAL || id == CSS_VAL_SMALL_CAPS)
957             valid_primitive = true;
958         break;
959
960     case CSS_PROP_VERTICAL_ALIGN:
961         // baseline | sub | super | top | text-top | middle | bottom | text-bottom |
962         // <percentage> | <length> | inherit
963
964         if (id >= CSS_VAL_BASELINE && id <= CSS_VAL__WEBKIT_BASELINE_MIDDLE)
965             valid_primitive = true;
966         else
967             valid_primitive = (!id && validUnit(value, FLength|FPercent, strict));
968         break;
969
970     case CSS_PROP_HEIGHT:               // <length> | <percentage> | auto | inherit
971     case CSS_PROP_WIDTH:                // <length> | <percentage> | auto | inherit
972         if (id == CSS_VAL_AUTO || id == CSS_VAL_INTRINSIC || id == CSS_VAL_MIN_INTRINSIC)
973             valid_primitive = true;
974         else
975             // ### handle multilength case where we allow relative units
976             valid_primitive = (!id && validUnit(value, FLength|FPercent|FNonNeg, strict));
977         break;
978
979     case CSS_PROP_BOTTOM:               // <length> | <percentage> | auto | inherit
980     case CSS_PROP_LEFT:                 // <length> | <percentage> | auto | inherit
981     case CSS_PROP_RIGHT:                // <length> | <percentage> | auto | inherit
982     case CSS_PROP_TOP:                  // <length> | <percentage> | auto | inherit
983     case CSS_PROP_MARGIN_TOP:           //// <margin-width> | inherit
984     case CSS_PROP_MARGIN_RIGHT:         //   Which is defined as
985     case CSS_PROP_MARGIN_BOTTOM:        //   <length> | <percentage> | auto | inherit
986     case CSS_PROP_MARGIN_LEFT:          ////
987     case CSS_PROP__WEBKIT_MARGIN_START:
988         if (id == CSS_VAL_AUTO)
989             valid_primitive = true;
990         else
991             valid_primitive = (!id && validUnit(value, FLength|FPercent, strict));
992         break;
993
994     case CSS_PROP_Z_INDEX:              // auto | <integer> | inherit
995         if (id == CSS_VAL_AUTO) {
996             valid_primitive = true;
997             break;
998         }
999         /* nobreak */
1000     case CSS_PROP_ORPHANS:              // <integer> | inherit
1001     case CSS_PROP_WIDOWS:               // <integer> | inherit
1002         // ### not supported later on
1003         valid_primitive = (!id && validUnit(value, FInteger, false));
1004         break;
1005
1006     case CSS_PROP_LINE_HEIGHT:          // normal | <number> | <length> | <percentage> | inherit
1007         if (id == CSS_VAL_NORMAL)
1008             valid_primitive = true;
1009         else
1010             valid_primitive = (!id && validUnit(value, FNumber|FLength|FPercent, strict));
1011         break;
1012     case CSS_PROP_COUNTER_INCREMENT:    // [ <identifier> <integer>? ]+ | none | inherit
1013         if (id != CSS_VAL_NONE)
1014             return parseCounter(propId, 1, important);
1015         valid_primitive = true;
1016         break;
1017      case CSS_PROP_COUNTER_RESET:        // [ <identifier> <integer>? ]+ | none | inherit
1018         if (id != CSS_VAL_NONE)
1019             return parseCounter(propId, 0, important);
1020         valid_primitive = true;
1021         break;
1022     case CSS_PROP_FONT_FAMILY:
1023         // [[ <family-name> | <generic-family> ],]* [<family-name> | <generic-family>] | inherit
1024     {
1025         parsedValue = parseFontFamily();
1026         break;
1027     }
1028
1029     case CSS_PROP_TEXT_DECORATION:
1030     case CSS_PROP__WEBKIT_TEXT_DECORATIONS_IN_EFFECT:
1031         // none | [ underline || overline || line-through || blink ] | inherit
1032         if (id == CSS_VAL_NONE) {
1033             valid_primitive = true;
1034         } else {
1035             CSSValueList *list = new CSSValueList;
1036             bool is_valid = true;
1037             while(is_valid && value) {
1038                 switch (value->id) {
1039                 case CSS_VAL_BLINK:
1040                     break;
1041                 case CSS_VAL_UNDERLINE:
1042                 case CSS_VAL_OVERLINE:
1043                 case CSS_VAL_LINE_THROUGH:
1044                     list->append(new CSSPrimitiveValue(value->id));
1045                     break;
1046                 default:
1047                     is_valid = false;
1048                 }
1049                 value = valueList->next();
1050             }
1051             if(list->length() && is_valid) {
1052                 parsedValue = list;
1053                 valueList->next();
1054             } else
1055                 delete list;
1056         }
1057         break;
1058
1059     case CSS_PROP_TABLE_LAYOUT:         // auto | fixed | inherit
1060         if (id == CSS_VAL_AUTO || id == CSS_VAL_FIXED)
1061             valid_primitive = true;
1062         break;
1063
1064     /* CSS3 properties */
1065     case CSS_PROP__WEBKIT_APPEARANCE:
1066         if ((id >= CSS_VAL_CHECKBOX && id <= CSS_VAL_TEXTAREA) || id == CSS_VAL_NONE)
1067             valid_primitive = true;
1068         break;
1069
1070     case CSS_PROP__WEBKIT_BINDING:
1071 #if ENABLE(XBL)
1072         if (id == CSS_VAL_NONE)
1073             valid_primitive = true;
1074         else {
1075             CSSValueList* values = new CSSValueList();
1076             Value* val;
1077             CSSValue* parsedValue = 0;
1078             while ((val = valueList->current())) {
1079                 if (val->unit == CSSPrimitiveValue::CSS_URI) {
1080                     String value = parseURL(domString(val->string));
1081                     parsedValue = new CSSPrimitiveValue(
1082                                     String(KURL(styleElement->baseURL().deprecatedString(), value.deprecatedString()).url()), 
1083                                     CSSPrimitiveValue::CSS_URI);
1084                 } 
1085                 
1086                 if (parsedValue)
1087                     values->append(parsedValue);
1088                 else
1089                     break;
1090                 valueList->next();
1091             }
1092             if (values->length()) {
1093                 addProperty(propId, values, important);
1094                 valueList->next();
1095                 return true;
1096             }
1097             delete values;
1098             return false;
1099         }
1100 #endif
1101         break;
1102     case CSS_PROP__WEBKIT_BORDER_IMAGE:
1103         if (id == CSS_VAL_NONE)
1104             valid_primitive = true;
1105         else
1106             return parseBorderImage(propId, important);
1107         break;
1108     case CSS_PROP__WEBKIT_BORDER_TOP_RIGHT_RADIUS:
1109     case CSS_PROP__WEBKIT_BORDER_TOP_LEFT_RADIUS:
1110     case CSS_PROP__WEBKIT_BORDER_BOTTOM_LEFT_RADIUS:
1111     case CSS_PROP__WEBKIT_BORDER_BOTTOM_RIGHT_RADIUS:
1112     case CSS_PROP__WEBKIT_BORDER_RADIUS: {
1113         if (num != 1 && num != 2)
1114             return false;
1115         valid_primitive = validUnit(value, FLength, strict);
1116         if (!valid_primitive)
1117             return false;
1118         CSSPrimitiveValue* parsedValue1 = new CSSPrimitiveValue(value->fValue,
1119                                                                         (CSSPrimitiveValue::UnitTypes)value->unit);
1120         CSSPrimitiveValue* parsedValue2 = parsedValue1;
1121         if (num == 2) {
1122             value = valueList->next();
1123             valid_primitive = validUnit(value, FLength, strict);
1124             if (!valid_primitive) {
1125                 delete parsedValue1;
1126                 return false;
1127             }
1128             parsedValue2 = new CSSPrimitiveValue(value->fValue, (CSSPrimitiveValue::UnitTypes)value->unit);
1129         }
1130         
1131         Pair* pair = new Pair(parsedValue1, parsedValue2);
1132         CSSPrimitiveValue* val = new CSSPrimitiveValue(pair);
1133         if (propId == CSS_PROP__WEBKIT_BORDER_RADIUS) {
1134             const int properties[4] = { CSS_PROP__WEBKIT_BORDER_TOP_RIGHT_RADIUS,
1135                                         CSS_PROP__WEBKIT_BORDER_TOP_LEFT_RADIUS,
1136                                         CSS_PROP__WEBKIT_BORDER_BOTTOM_LEFT_RADIUS,
1137                                         CSS_PROP__WEBKIT_BORDER_BOTTOM_RIGHT_RADIUS };
1138             for (int i = 0; i < 4; i++)
1139                 addProperty(properties[i], val, important);
1140         } else
1141             addProperty(propId, val, important);
1142         return true;
1143     }
1144     case CSS_PROP_OUTLINE_OFFSET:
1145         valid_primitive = validUnit(value, FLength, strict);
1146         break;
1147     case CSS_PROP_TEXT_SHADOW: // CSS2 property, dropped in CSS2.1, back in CSS3, so treat as CSS3
1148     case CSS_PROP__WEBKIT_BOX_SHADOW:
1149         if (id == CSS_VAL_NONE)
1150             valid_primitive = true;
1151         else
1152             return parseShadow(propId, important);
1153         break;
1154     case CSS_PROP_OPACITY:
1155         valid_primitive = validUnit(value, FNumber, strict);
1156         break;
1157     case CSS_PROP__WEBKIT_BOX_ALIGN:
1158         if (id == CSS_VAL_STRETCH || id == CSS_VAL_START || id == CSS_VAL_END ||
1159             id == CSS_VAL_CENTER || id == CSS_VAL_BASELINE)
1160             valid_primitive = true;
1161         break;
1162     case CSS_PROP__WEBKIT_BOX_DIRECTION:
1163         if (id == CSS_VAL_NORMAL || id == CSS_VAL_REVERSE)
1164             valid_primitive = true;
1165         break;
1166     case CSS_PROP__WEBKIT_BOX_LINES:
1167         if (id == CSS_VAL_SINGLE || id == CSS_VAL_MULTIPLE)
1168             valid_primitive = true;
1169         break;
1170     case CSS_PROP__WEBKIT_BOX_ORIENT:
1171         if (id == CSS_VAL_HORIZONTAL || id == CSS_VAL_VERTICAL ||
1172             id == CSS_VAL_INLINE_AXIS || id == CSS_VAL_BLOCK_AXIS)
1173             valid_primitive = true;
1174         break;
1175     case CSS_PROP__WEBKIT_BOX_PACK:
1176         if (id == CSS_VAL_START || id == CSS_VAL_END ||
1177             id == CSS_VAL_CENTER || id == CSS_VAL_JUSTIFY)
1178             valid_primitive = true;
1179         break;
1180     case CSS_PROP__WEBKIT_BOX_FLEX:
1181         valid_primitive = validUnit(value, FNumber, strict);
1182         break;
1183     case CSS_PROP__WEBKIT_BOX_FLEX_GROUP:
1184     case CSS_PROP__WEBKIT_BOX_ORDINAL_GROUP:
1185         valid_primitive = validUnit(value, FInteger|FNonNeg, true);
1186         break;
1187     case CSS_PROP__WEBKIT_BOX_SIZING:
1188         valid_primitive = id == CSS_VAL_BORDER_BOX || id == CSS_VAL_CONTENT_BOX;
1189         break;
1190     case CSS_PROP__WEBKIT_MARQUEE: {
1191         const int properties[5] = { CSS_PROP__WEBKIT_MARQUEE_DIRECTION, CSS_PROP__WEBKIT_MARQUEE_INCREMENT,
1192                                     CSS_PROP__WEBKIT_MARQUEE_REPETITION,
1193                                     CSS_PROP__WEBKIT_MARQUEE_STYLE, CSS_PROP__WEBKIT_MARQUEE_SPEED };
1194         return parseShorthand(propId, properties, 5, important);
1195     }
1196     case CSS_PROP__WEBKIT_MARQUEE_DIRECTION:
1197         if (id == CSS_VAL_FORWARDS || id == CSS_VAL_BACKWARDS || id == CSS_VAL_AHEAD ||
1198             id == CSS_VAL_REVERSE || id == CSS_VAL_LEFT || id == CSS_VAL_RIGHT || id == CSS_VAL_DOWN ||
1199             id == CSS_VAL_UP || id == CSS_VAL_AUTO)
1200             valid_primitive = true;
1201         break;
1202     case CSS_PROP__WEBKIT_MARQUEE_INCREMENT:
1203         if (id == CSS_VAL_SMALL || id == CSS_VAL_LARGE || id == CSS_VAL_MEDIUM)
1204             valid_primitive = true;
1205         else
1206             valid_primitive = validUnit(value, FLength|FPercent, strict);
1207         break;
1208     case CSS_PROP__WEBKIT_MARQUEE_STYLE:
1209         if (id == CSS_VAL_NONE || id == CSS_VAL_SLIDE || id == CSS_VAL_SCROLL || id == CSS_VAL_ALTERNATE)
1210             valid_primitive = true;
1211         break;
1212     case CSS_PROP__WEBKIT_MARQUEE_REPETITION:
1213         if (id == CSS_VAL_INFINITE)
1214             valid_primitive = true;
1215         else
1216             valid_primitive = validUnit(value, FInteger|FNonNeg, strict);
1217         break;
1218     case CSS_PROP__WEBKIT_MARQUEE_SPEED:
1219         if (id == CSS_VAL_NORMAL || id == CSS_VAL_SLOW || id == CSS_VAL_FAST)
1220             valid_primitive = true;
1221         else
1222             valid_primitive = validUnit(value, FTime|FInteger|FNonNeg, strict);
1223         break;
1224     case CSS_PROP__WEBKIT_USER_DRAG: // auto | none | element
1225         if (id == CSS_VAL_AUTO || id == CSS_VAL_NONE || id == CSS_VAL_ELEMENT)
1226             valid_primitive = true;
1227         break;
1228     case CSS_PROP__WEBKIT_USER_MODIFY: // read-only | read-write
1229         if (id == CSS_VAL_READ_ONLY || id == CSS_VAL_READ_WRITE || id == CSS_VAL_READ_WRITE_PLAINTEXT_ONLY)
1230             valid_primitive = true;
1231         break;
1232     case CSS_PROP__WEBKIT_USER_SELECT: // auto | none | text
1233         if (id == CSS_VAL_AUTO || id == CSS_VAL_NONE || id == CSS_VAL_TEXT)
1234             valid_primitive = true;
1235         break;
1236     case CSS_PROP_TEXT_OVERFLOW: // clip | ellipsis
1237         if (id == CSS_VAL_CLIP || id == CSS_VAL_ELLIPSIS)
1238             valid_primitive = true;
1239         break;
1240     case CSS_PROP__WEBKIT_MARGIN_COLLAPSE: {
1241         const int properties[2] = { CSS_PROP__WEBKIT_MARGIN_TOP_COLLAPSE,
1242             CSS_PROP__WEBKIT_MARGIN_BOTTOM_COLLAPSE };
1243         if (num == 1) {
1244             ShorthandScope scope(this, CSS_PROP__WEBKIT_MARGIN_COLLAPSE);
1245             if (!parseValue(properties[0], important))
1246                 return false;
1247             CSSValue* value = parsedProperties[numParsedProperties-1]->value();
1248             addProperty(properties[1], value, important);
1249             return true;
1250         }
1251         else if (num == 2) {
1252             ShorthandScope scope(this, CSS_PROP__WEBKIT_MARGIN_COLLAPSE);
1253             if (!parseValue(properties[0], important) || !parseValue(properties[1], important))
1254                 return false;
1255             return true;
1256         }
1257         return false;
1258     }
1259     case CSS_PROP__WEBKIT_MARGIN_TOP_COLLAPSE:
1260     case CSS_PROP__WEBKIT_MARGIN_BOTTOM_COLLAPSE:
1261         if (id == CSS_VAL_COLLAPSE || id == CSS_VAL_SEPARATE || id == CSS_VAL_DISCARD)
1262             valid_primitive = true;
1263         break;
1264     case CSS_PROP_TEXT_LINE_THROUGH_MODE:
1265     case CSS_PROP_TEXT_OVERLINE_MODE:
1266     case CSS_PROP_TEXT_UNDERLINE_MODE:
1267         if (id == CSS_VAL_CONTINUOUS || id == CSS_VAL_SKIP_WHITE_SPACE)
1268             valid_primitive = true;
1269         break;
1270     case CSS_PROP_TEXT_LINE_THROUGH_STYLE:
1271     case CSS_PROP_TEXT_OVERLINE_STYLE:
1272     case CSS_PROP_TEXT_UNDERLINE_STYLE:
1273         if (id == CSS_VAL_NONE || id == CSS_VAL_SOLID || id == CSS_VAL_DOUBLE ||
1274             id == CSS_VAL_DASHED || id == CSS_VAL_DOT_DASH || id == CSS_VAL_DOT_DOT_DASH ||
1275             id == CSS_VAL_WAVE)
1276             valid_primitive = true;
1277         break;
1278     case CSS_PROP_TEXT_LINE_THROUGH_WIDTH:
1279     case CSS_PROP_TEXT_OVERLINE_WIDTH:
1280     case CSS_PROP_TEXT_UNDERLINE_WIDTH:
1281         if (id == CSS_VAL_AUTO || id == CSS_VAL_NORMAL || id == CSS_VAL_THIN ||
1282             id == CSS_VAL_MEDIUM || id == CSS_VAL_THICK)
1283             valid_primitive = true;
1284         else
1285             valid_primitive = !id && validUnit(value, FNumber|FLength|FPercent, strict);
1286         break;
1287     case CSS_PROP_RESIZE: // none | both | horizontal | vertical | auto
1288         if (id == CSS_VAL_NONE || id == CSS_VAL_BOTH || id == CSS_VAL_HORIZONTAL || id == CSS_VAL_VERTICAL || id == CSS_VAL_AUTO)
1289             valid_primitive = true;
1290         break;
1291     case CSS_PROP__WEBKIT_COLUMN_COUNT:
1292         if (id == CSS_VAL_AUTO)
1293             valid_primitive = true;
1294         else
1295             valid_primitive = !id && validUnit(value, FInteger | FNonNeg, false);
1296         break;
1297     case CSS_PROP__WEBKIT_COLUMN_GAP:         // normal | <length>
1298         if (id == CSS_VAL_NORMAL)
1299             valid_primitive = true;
1300         else
1301             valid_primitive = validUnit(value, FLength, strict);
1302         break;
1303     case CSS_PROP__WEBKIT_COLUMN_WIDTH:         // auto | <length>
1304         if (id == CSS_VAL_AUTO)
1305             valid_primitive = true;
1306         else // Always parse this property in strict mode, since it would be ambiguous otherwise when used in the 'columns' shorthand property.
1307             valid_primitive = validUnit(value, FLength, true);
1308         break;
1309     // End of CSS3 properties
1310
1311     // Apple specific properties.  These will never be standardized and are purely to
1312     // support custom WebKit-based Apple applications.
1313     case CSS_PROP__WEBKIT_LINE_CLAMP:
1314         valid_primitive = (!id && validUnit(value, FPercent, false));
1315         break;
1316     case CSS_PROP__WEBKIT_TEXT_SIZE_ADJUST:
1317         if (id == CSS_VAL_AUTO || id == CSS_VAL_NONE)
1318             valid_primitive = true;
1319         break;
1320     case CSS_PROP__WEBKIT_RTL_ORDERING:
1321         if (id == CSS_VAL_LOGICAL || id == CSS_VAL_VISUAL)
1322             valid_primitive = true;
1323         break;
1324     
1325     case CSS_PROP__WEBKIT_FONT_SIZE_DELTA:           // <length>
1326         valid_primitive = validUnit(value, FLength, strict);
1327         break;
1328
1329     case CSS_PROP__WEBKIT_NBSP_MODE:     // normal | space
1330         if (id == CSS_VAL_NORMAL || id == CSS_VAL_SPACE)
1331             valid_primitive = true;
1332         break;
1333
1334     case CSS_PROP__WEBKIT_LINE_BREAK:   // normal | after-white-space
1335         if (id == CSS_VAL_NORMAL || id == CSS_VAL_AFTER_WHITE_SPACE)
1336             valid_primitive = true;
1337         break;
1338
1339     case CSS_PROP__WEBKIT_MATCH_NEAREST_MAIL_BLOCKQUOTE_COLOR:   // normal | match
1340         if (id == CSS_VAL_NORMAL || id == CSS_VAL_MATCH)
1341             valid_primitive = true;
1342         break;
1343
1344     case CSS_PROP__WEBKIT_HIGHLIGHT:
1345         if (id == CSS_VAL_NONE || value->unit == CSSPrimitiveValue::CSS_STRING)
1346             valid_primitive = true;
1347         break;
1348     
1349     case CSS_PROP__WEBKIT_BORDER_FIT:
1350         if (id == CSS_VAL_BORDER || id == CSS_VAL_LINES)
1351             valid_primitive = true;
1352         break;
1353         
1354     case CSS_PROP__WEBKIT_TEXT_SECURITY:
1355         // disc | circle | square | none | inherit
1356         if (id == CSS_VAL_DISC || id == CSS_VAL_CIRCLE || id == CSS_VAL_SQUARE|| id == CSS_VAL_NONE)
1357             valid_primitive = true;
1358         break;
1359
1360     case CSS_PROP__WEBKIT_DASHBOARD_REGION:                 // <dashboard-region> | <dashboard-region> 
1361         if (value->unit == Value::Function || id == CSS_VAL_NONE)
1362             return parseDashboardRegions(propId, important);
1363         break;
1364     // End Apple-specific properties
1365
1366         /* shorthand properties */
1367     case CSS_PROP_BACKGROUND:
1368         // ['background-color' || 'background-image' || 'background-size' || 'background-repeat' ||
1369         // 'background-attachment' || 'background-position'] | inherit
1370         return parseBackgroundShorthand(important);
1371     case CSS_PROP_BORDER:
1372         // [ 'border-width' || 'border-style' || <color> ] | inherit
1373     {
1374         const int properties[3] = { CSS_PROP_BORDER_WIDTH, CSS_PROP_BORDER_STYLE,
1375                                     CSS_PROP_BORDER_COLOR };
1376         return parseShorthand(propId, properties, 3, important);
1377     }
1378     case CSS_PROP_BORDER_TOP:
1379         // [ 'border-top-width' || 'border-style' || <color> ] | inherit
1380     {
1381         const int properties[3] = { CSS_PROP_BORDER_TOP_WIDTH, CSS_PROP_BORDER_TOP_STYLE,
1382                                     CSS_PROP_BORDER_TOP_COLOR};
1383         return parseShorthand(propId, properties, 3, important);
1384     }
1385     case CSS_PROP_BORDER_RIGHT:
1386         // [ 'border-right-width' || 'border-style' || <color> ] | inherit
1387     {
1388         const int properties[3] = { CSS_PROP_BORDER_RIGHT_WIDTH, CSS_PROP_BORDER_RIGHT_STYLE,
1389                                     CSS_PROP_BORDER_RIGHT_COLOR };
1390         return parseShorthand(propId, properties, 3, important);
1391     }
1392     case CSS_PROP_BORDER_BOTTOM:
1393         // [ 'border-bottom-width' || 'border-style' || <color> ] | inherit
1394     {
1395         const int properties[3] = { CSS_PROP_BORDER_BOTTOM_WIDTH, CSS_PROP_BORDER_BOTTOM_STYLE,
1396                                     CSS_PROP_BORDER_BOTTOM_COLOR };
1397         return parseShorthand(propId, properties, 3, important);
1398     }
1399     case CSS_PROP_BORDER_LEFT:
1400         // [ 'border-left-width' || 'border-style' || <color> ] | inherit
1401     {
1402         const int properties[3] = { CSS_PROP_BORDER_LEFT_WIDTH, CSS_PROP_BORDER_LEFT_STYLE,
1403                                     CSS_PROP_BORDER_LEFT_COLOR };
1404         return parseShorthand(propId, properties, 3, important);
1405     }
1406     case CSS_PROP_OUTLINE:
1407         // [ 'outline-color' || 'outline-style' || 'outline-width' ] | inherit
1408     {
1409         const int properties[3] = { CSS_PROP_OUTLINE_WIDTH, CSS_PROP_OUTLINE_STYLE,
1410                                     CSS_PROP_OUTLINE_COLOR };
1411         return parseShorthand(propId, properties, 3, important);
1412     }
1413     case CSS_PROP_BORDER_COLOR:
1414         // <color>{1,4} | inherit
1415     {
1416         const int properties[4] = { CSS_PROP_BORDER_TOP_COLOR, CSS_PROP_BORDER_RIGHT_COLOR,
1417                                     CSS_PROP_BORDER_BOTTOM_COLOR, CSS_PROP_BORDER_LEFT_COLOR };
1418         return parse4Values(propId, properties, important);
1419     }
1420     case CSS_PROP_BORDER_WIDTH:
1421         // <border-width>{1,4} | inherit
1422     {
1423         const int properties[4] = { CSS_PROP_BORDER_TOP_WIDTH, CSS_PROP_BORDER_RIGHT_WIDTH,
1424                                     CSS_PROP_BORDER_BOTTOM_WIDTH, CSS_PROP_BORDER_LEFT_WIDTH };
1425         return parse4Values(propId, properties, important);
1426     }
1427     case CSS_PROP_BORDER_STYLE:
1428         // <border-style>{1,4} | inherit
1429     {
1430         const int properties[4] = { CSS_PROP_BORDER_TOP_STYLE, CSS_PROP_BORDER_RIGHT_STYLE,
1431                                     CSS_PROP_BORDER_BOTTOM_STYLE, CSS_PROP_BORDER_LEFT_STYLE };
1432         return parse4Values(propId, properties, important);
1433     }
1434     case CSS_PROP_MARGIN:
1435         // <margin-width>{1,4} | inherit
1436     {
1437         const int properties[4] = { CSS_PROP_MARGIN_TOP, CSS_PROP_MARGIN_RIGHT,
1438                                     CSS_PROP_MARGIN_BOTTOM, CSS_PROP_MARGIN_LEFT };
1439         return parse4Values(propId, properties, important);
1440     }
1441     case CSS_PROP_PADDING:
1442         // <padding-width>{1,4} | inherit
1443     {
1444         const int properties[4] = { CSS_PROP_PADDING_TOP, CSS_PROP_PADDING_RIGHT,
1445                                     CSS_PROP_PADDING_BOTTOM, CSS_PROP_PADDING_LEFT };
1446         return parse4Values(propId, properties, important);
1447     }
1448     case CSS_PROP_FONT:
1449         // [ [ 'font-style' || 'font-variant' || 'font-weight' ]? 'font-size' [ / 'line-height' ]?
1450         // 'font-family' ] | caption | icon | menu | message-box | small-caption | status-bar | inherit
1451         if (id >= CSS_VAL_CAPTION && id <= CSS_VAL_STATUS_BAR)
1452             valid_primitive = true;
1453         else
1454             return parseFont(important);
1455         break;
1456     case CSS_PROP_LIST_STYLE:
1457     {
1458         const int properties[3] = { CSS_PROP_LIST_STYLE_TYPE, CSS_PROP_LIST_STYLE_POSITION,
1459                                     CSS_PROP_LIST_STYLE_IMAGE };
1460         return parseShorthand(propId, properties, 3, important);
1461     }
1462     case CSS_PROP__WEBKIT_COLUMNS: {
1463         const int properties[2] = { CSS_PROP__WEBKIT_COLUMN_WIDTH, CSS_PROP__WEBKIT_COLUMN_COUNT };
1464         return parseShorthand(propId, properties, 2, important);
1465     }
1466     case CSS_PROP__WEBKIT_COLUMN_RULE: {
1467         const int properties[3] = { CSS_PROP__WEBKIT_COLUMN_RULE_WIDTH, CSS_PROP__WEBKIT_COLUMN_RULE_STYLE,
1468                                     CSS_PROP__WEBKIT_COLUMN_RULE_COLOR };
1469         return parseShorthand(propId, properties, 3, important);
1470     }
1471     case CSS_PROP__WEBKIT_TEXT_STROKE: {
1472         const int properties[2] = { CSS_PROP__WEBKIT_TEXT_STROKE_WIDTH, CSS_PROP__WEBKIT_TEXT_STROKE_COLOR };
1473         return parseShorthand(propId, properties, 2, important);
1474     }
1475     case CSS_PROP_INVALID:
1476         return false;
1477     case CSS_PROP_FONT_STRETCH:
1478     case CSS_PROP_PAGE:
1479     case CSS_PROP_TEXT_LINE_THROUGH:
1480     case CSS_PROP_TEXT_OVERLINE:
1481     case CSS_PROP_TEXT_UNDERLINE:
1482         return false;
1483     }
1484
1485     if (valid_primitive) {
1486         if (id != 0)
1487             parsedValue = new CSSPrimitiveValue(id);
1488         else if (value->unit == CSSPrimitiveValue::CSS_STRING)
1489             parsedValue = new CSSPrimitiveValue(domString(value->string), (CSSPrimitiveValue::UnitTypes) value->unit);
1490         else if (value->unit >= CSSPrimitiveValue::CSS_NUMBER && value->unit <= CSSPrimitiveValue::CSS_KHZ)
1491             parsedValue = new CSSPrimitiveValue(value->fValue, (CSSPrimitiveValue::UnitTypes) value->unit);
1492         else if (value->unit >= Value::Q_EMS)
1493             parsedValue = new CSSQuirkPrimitiveValue(value->fValue, CSSPrimitiveValue::CSS_EMS);
1494         valueList->next();
1495     }
1496     if (parsedValue) {
1497         if (!valueList->current() || inShorthand()) {
1498             addProperty(propId, parsedValue, important);
1499             return true;
1500         }
1501         delete parsedValue;
1502     }
1503 #if ENABLE(SVG)
1504     if (parseSVGValue(propId, important))
1505         return true;
1506 #endif
1507     return false;
1508 }
1509
1510 void CSSParser::addBackgroundValue(CSSValue*& lval, CSSValue* rval)
1511 {
1512     if (lval) {
1513         if (lval->isValueList())
1514             static_cast<CSSValueList*>(lval)->append(rval);
1515         else {
1516             CSSValue* oldVal = lval;
1517             CSSValueList* list = new CSSValueList();
1518             lval = list;
1519             list->append(oldVal);
1520             list->append(rval);
1521         }
1522     }
1523     else
1524         lval = rval;
1525 }
1526
1527 bool CSSParser::parseBackgroundShorthand(bool important)
1528 {
1529     // Position must come before color in this array because a plain old "0" is a legal color
1530     // in quirks mode but it's usually the X coordinate of a position.
1531     // FIXME: Add CSS_PROP__KHTML_BACKGROUND_SIZE to the shorthand.
1532     const int properties[] = { CSS_PROP_BACKGROUND_IMAGE, CSS_PROP_BACKGROUND_REPEAT, 
1533         CSS_PROP_BACKGROUND_ATTACHMENT, CSS_PROP_BACKGROUND_POSITION, CSS_PROP__WEBKIT_BACKGROUND_CLIP,
1534         CSS_PROP__WEBKIT_BACKGROUND_ORIGIN, CSS_PROP_BACKGROUND_COLOR };
1535     const int numProperties = sizeof(properties) / sizeof(properties[0]);
1536     
1537     ShorthandScope scope(this, CSS_PROP_BACKGROUND);
1538
1539     bool parsedProperty[numProperties] = { false }; // compiler will repeat false as necessary
1540     CSSValue* values[numProperties] = { 0 }; // compiler will repeat 0 as necessary
1541     CSSValue* positionYValue = 0;
1542     int i;
1543
1544     while (valueList->current()) {
1545         Value* val = valueList->current();
1546         if (val->unit == Value::Operator && val->iValue == ',') {
1547             // We hit the end.  Fill in all remaining values with the initial value.
1548             valueList->next();
1549             for (i = 0; i < numProperties; ++i) {
1550                 if (properties[i] == CSS_PROP_BACKGROUND_COLOR && parsedProperty[i])
1551                     // Color is not allowed except as the last item in a list.  Reject the entire
1552                     // property.
1553                     goto fail;
1554
1555                 if (!parsedProperty[i] && properties[i] != CSS_PROP_BACKGROUND_COLOR) {
1556                     addBackgroundValue(values[i], new CSSInitialValue(true));
1557                     if (properties[i] == CSS_PROP_BACKGROUND_POSITION)
1558                         addBackgroundValue(positionYValue, new CSSInitialValue(true));
1559                 }
1560                 parsedProperty[i] = false;
1561             }
1562             if (!valueList->current())
1563                 break;
1564         }
1565         
1566         bool found = false;
1567         for (i = 0; !found && i < numProperties; ++i) {
1568             if (!parsedProperty[i]) {
1569                 CSSValue *val1 = 0, *val2 = 0;
1570                 int propId1, propId2;
1571                 if (parseBackgroundProperty(properties[i], propId1, propId2, val1, val2)) {
1572                     parsedProperty[i] = found = true;
1573                     addBackgroundValue(values[i], val1);
1574                     if (properties[i] == CSS_PROP_BACKGROUND_POSITION)
1575                         addBackgroundValue(positionYValue, val2);
1576                 }
1577             }
1578         }
1579
1580         // if we didn't find at least one match, this is an
1581         // invalid shorthand and we have to ignore it
1582         if (!found)
1583             goto fail;
1584     }
1585     
1586     // Fill in any remaining properties with the initial value.
1587     for (i = 0; i < numProperties; ++i) {
1588         if (!parsedProperty[i]) {
1589             addBackgroundValue(values[i], new CSSInitialValue(true));
1590             if (properties[i] == CSS_PROP_BACKGROUND_POSITION)
1591                 addBackgroundValue(positionYValue, new CSSInitialValue(true));
1592         }
1593     }
1594     
1595     // Now add all of the properties we found.
1596     for (i = 0; i < numProperties; i++) {
1597         if (properties[i] == CSS_PROP_BACKGROUND_POSITION) {
1598             addProperty(CSS_PROP_BACKGROUND_POSITION_X, values[i], important);
1599             addProperty(CSS_PROP_BACKGROUND_POSITION_Y, positionYValue, important);
1600         }
1601         else
1602             addProperty(properties[i], values[i], important);
1603     }
1604     
1605     return true;
1606
1607 fail:
1608     for (int k = 0; k < numProperties; k++)
1609         delete values[k];
1610     delete positionYValue;
1611     return false;
1612 }
1613
1614 bool CSSParser::parseShorthand(int propId, const int *properties, int numProperties, bool important)
1615 {
1616     // We try to match as many properties as possible
1617     // We set up an array of booleans to mark which property has been found,
1618     // and we try to search for properties until it makes no longer any sense.
1619     ShorthandScope scope(this, propId);
1620
1621     bool found = false;
1622     bool fnd[6]; // Trust me ;)
1623     for (int i = 0; i < numProperties; i++)
1624         fnd[i] = false;
1625
1626     while (valueList->current()) {
1627         found = false;
1628         for (int propIndex = 0; !found && propIndex < numProperties; ++propIndex) {
1629             if (!fnd[propIndex]) {
1630                 if (parseValue(properties[propIndex], important))
1631                     fnd[propIndex] = found = true;
1632             }
1633         }
1634
1635         // if we didn't find at least one match, this is an
1636         // invalid shorthand and we have to ignore it
1637         if (!found)
1638             return false;
1639     }
1640     
1641     // Fill in any remaining properties with the initial value.
1642     m_implicitShorthand = true;
1643     for (int i = 0; i < numProperties; ++i) {
1644         if (!fnd[i])
1645             addProperty(properties[i], new CSSInitialValue(true), important);
1646     }
1647     m_implicitShorthand = false;
1648
1649     return true;
1650 }
1651
1652 bool CSSParser::parse4Values(int propId, const int *properties,  bool important)
1653 {
1654     /* From the CSS 2 specs, 8.3
1655      * If there is only one value, it applies to all sides. If there are two values, the top and
1656      * bottom margins are set to the first value and the right and left margins are set to the second.
1657      * If there are three values, the top is set to the first value, the left and right are set to the
1658      * second, and the bottom is set to the third. If there are four values, they apply to the top,
1659      * right, bottom, and left, respectively.
1660      */
1661     
1662     int num = inShorthand() ? 1 : valueList->size();
1663     
1664     ShorthandScope scope(this, propId);
1665
1666     // the order is top, right, bottom, left
1667     switch (num) {
1668         case 1: {
1669             if (!parseValue(properties[0], important))
1670                 return false;
1671             CSSValue *value = parsedProperties[numParsedProperties-1]->value();
1672             m_implicitShorthand = true;
1673             addProperty(properties[1], value, important);
1674             addProperty(properties[2], value, important);
1675             addProperty(properties[3], value, important);
1676             m_implicitShorthand = false;
1677             break;
1678         }
1679         case 2: {
1680             if (!parseValue(properties[0], important) || !parseValue(properties[1], important))
1681                 return false;
1682             CSSValue *value = parsedProperties[numParsedProperties-2]->value();
1683             m_implicitShorthand = true;
1684             addProperty(properties[2], value, important);
1685             value = parsedProperties[numParsedProperties-2]->value();
1686             addProperty(properties[3], value, important);
1687             m_implicitShorthand = false;
1688             break;
1689         }
1690         case 3: {
1691             if (!parseValue(properties[0], important) || !parseValue(properties[1], important) || !parseValue(properties[2], important))
1692                 return false;
1693             CSSValue *value = parsedProperties[numParsedProperties-2]->value();
1694             m_implicitShorthand = true;
1695             addProperty(properties[3], value, important);
1696             m_implicitShorthand = false;
1697             break;
1698         }
1699         case 4: {
1700             if (!parseValue(properties[0], important) || !parseValue(properties[1], important) ||
1701                 !parseValue(properties[2], important) || !parseValue(properties[3], important))
1702                 return false;
1703             break;
1704         }
1705         default: {
1706             return false;
1707         }
1708     }
1709     
1710     return true;
1711 }
1712
1713 // [ <string> | <uri> | <counter> | attr(X) | open-quote | close-quote | no-open-quote | no-close-quote ]+ | inherit
1714 // in CSS 2.1 this got somewhat reduced:
1715 // [ <string> | attr(X) | open-quote | close-quote | no-open-quote | no-close-quote ]+ | inherit
1716 bool CSSParser::parseContent(int propId, bool important)
1717 {
1718     RefPtr<CSSValueList> values = new CSSValueList;
1719
1720     while (Value* val = valueList->current()) {
1721         RefPtr<CSSValue> parsedValue;
1722         if (val->unit == CSSPrimitiveValue::CSS_URI) {
1723             // url
1724             String value = parseURL(domString(val->string));
1725             parsedValue = new CSSImageValue(
1726                 String(KURL(styleElement->baseURL().deprecatedString(), value.deprecatedString()).url()), styleElement);
1727         } else if (val->unit == Value::Function) {
1728             // attr(X) | counter(X [,Y]) | counters(X, Y, [,Z])
1729             ValueList *args = val->function->args;
1730             String fname = domString(val->function->name).lower();
1731             if (!args)
1732                 return false;
1733             if (fname == "attr(") {
1734                 if (args->size() != 1)
1735                     return false;
1736                 Value* a = args->current();
1737                 String attrName = domString(a->string);
1738                 if (document()->isHTMLDocument())
1739                     attrName = attrName.lower();
1740                 parsedValue = new CSSPrimitiveValue(attrName, CSSPrimitiveValue::CSS_ATTR);
1741             } else if (fname == "counter(") {
1742                 parsedValue = parseCounterContent(args, false);
1743                 if (!parsedValue) return false;
1744             } else if (fname == "counters(") {
1745                 parsedValue = parseCounterContent(args, true);
1746                 if (!parsedValue)
1747                     return false;
1748             } else
1749                 return false;
1750         } else if (val->unit == CSSPrimitiveValue::CSS_IDENT) {
1751             // open-quote
1752             // close-quote
1753             // no-open-quote
1754             // no-close-quote
1755             // FIXME: These are not yet implemented (http://bugs.webkit.org/show_bug.cgi?id=6503).
1756         } else if (val->unit == CSSPrimitiveValue::CSS_STRING) {
1757             parsedValue = new CSSPrimitiveValue(domString(val->string), CSSPrimitiveValue::CSS_STRING);
1758         }
1759         if (!parsedValue)
1760             break;
1761         values->append(parsedValue.release());
1762         valueList->next();
1763     }
1764
1765     if (values->length()) {
1766         addProperty(propId, values.release(), important);
1767         valueList->next();
1768         return true;
1769     }
1770
1771     return false;
1772 }
1773
1774 CSSValue* CSSParser::parseBackgroundColor()
1775 {
1776     int id = valueList->current()->id;
1777     if (id == CSS_VAL__WEBKIT_TEXT || (id >= CSS_VAL_AQUA && id <= CSS_VAL_WINDOWTEXT) || id == CSS_VAL_MENU ||
1778         (id >= CSS_VAL_GREY && id < CSS_VAL__WEBKIT_TEXT && !strict))
1779        return new CSSPrimitiveValue(id);
1780     return parseColor();
1781 }
1782
1783 bool CSSParser::parseBackgroundImage(CSSValue*& value)
1784 {
1785     if (valueList->current()->id == CSS_VAL_NONE) {
1786         value = new CSSImageValue();
1787         return true;
1788     }
1789     if (valueList->current()->unit == CSSPrimitiveValue::CSS_URI) {
1790         String uri = parseURL(domString(valueList->current()->string));
1791         if (!uri.isEmpty())
1792             value = new CSSImageValue(String(KURL(styleElement->baseURL().deprecatedString(), uri.deprecatedString()).url()), 
1793                                          styleElement);
1794         return true;
1795     }
1796     return false;
1797 }
1798
1799 CSSValue* CSSParser::parseBackgroundPositionXY(bool& xFound, bool& yFound)
1800 {
1801     int id = valueList->current()->id;
1802     if (id == CSS_VAL_LEFT || id == CSS_VAL_TOP || id == CSS_VAL_RIGHT || id == CSS_VAL_BOTTOM || id == CSS_VAL_CENTER) {
1803         int percent = 0;
1804         if (id == CSS_VAL_LEFT || id == CSS_VAL_RIGHT) {
1805             if (xFound)
1806                 return 0;
1807             xFound = true;
1808             if (id == CSS_VAL_RIGHT)
1809                 percent = 100;
1810         }
1811         else if (id == CSS_VAL_TOP || id == CSS_VAL_BOTTOM) {
1812             if (yFound)
1813                 return 0;
1814             yFound = true;
1815             if (id == CSS_VAL_BOTTOM)
1816                 percent = 100;
1817         }
1818         else if (id == CSS_VAL_CENTER)
1819             // Center is ambiguous, so we're not sure which position we've found yet, an x or a y.
1820             percent = 50;
1821         return new CSSPrimitiveValue(percent, CSSPrimitiveValue::CSS_PERCENTAGE);
1822     }
1823     if (validUnit(valueList->current(), FPercent|FLength, strict))
1824         return new CSSPrimitiveValue(valueList->current()->fValue,
1825                                          (CSSPrimitiveValue::UnitTypes)valueList->current()->unit);
1826                 
1827     return 0;
1828 }
1829
1830 void CSSParser::parseBackgroundPosition(CSSValue*& value1, CSSValue*& value2)
1831 {
1832     value1 = value2 = 0;
1833     Value* value = valueList->current();
1834     
1835     // Parse the first value.  We're just making sure that it is one of the valid keywords or a percentage/length.
1836     bool value1IsX = false, value1IsY = false;
1837     value1 = parseBackgroundPositionXY(value1IsX, value1IsY);
1838     if (!value1)
1839         return;
1840     
1841     // It only takes one value for background-position to be correctly parsed if it was specified in a shorthand (since we
1842     // can assume that any other values belong to the rest of the shorthand).  If we're not parsing a shorthand, though, the
1843     // value was explicitly specified for our property.
1844     value = valueList->next();
1845     
1846     // First check for the comma.  If so, we are finished parsing this value or value pair.
1847     if (value && value->unit == Value::Operator && value->iValue == ',')
1848         value = 0;
1849     
1850     bool value2IsX = false, value2IsY = false;
1851     if (value) {
1852         value2 = parseBackgroundPositionXY(value2IsX, value2IsY);
1853         if (value2)
1854             valueList->next();
1855         else {
1856             if (!inShorthand()) {
1857                 delete value1;
1858                 value1 = 0;
1859                 return;
1860             }
1861         }
1862     }
1863     
1864     if (!value2)
1865         // Only one value was specified.  If that value was not a keyword, then it sets the x position, and the y position
1866         // is simply 50%.  This is our default.
1867         // For keywords, the keyword was either an x-keyword (left/right), a y-keyword (top/bottom), or an ambiguous keyword (center).
1868         // For left/right/center, the default of 50% in the y is still correct.
1869         value2 = new CSSPrimitiveValue(50, CSSPrimitiveValue::CSS_PERCENTAGE);
1870
1871     if (value1IsY || value2IsX) {
1872         // Swap our two values.
1873         CSSValue* val = value2;
1874         value2 = value1;
1875         value1 = val;
1876     }
1877 }
1878
1879 CSSValue* CSSParser::parseBackgroundSize()
1880 {
1881     Value* value = valueList->current();
1882     CSSPrimitiveValue* parsedValue1;
1883     
1884     if (value->id == CSS_VAL_AUTO)
1885         parsedValue1 = new CSSPrimitiveValue(0, CSSPrimitiveValue::CSS_UNKNOWN);
1886     else {
1887         if (!validUnit(value, FLength|FPercent, strict))
1888             return 0;
1889         parsedValue1 = new CSSPrimitiveValue(value->fValue, (CSSPrimitiveValue::UnitTypes)value->unit);
1890     }
1891     
1892     CSSPrimitiveValue* parsedValue2 = parsedValue1;
1893     if ((value = valueList->next())) {
1894         if (value->id == CSS_VAL_AUTO)
1895             parsedValue2 = new CSSPrimitiveValue(0, CSSPrimitiveValue::CSS_UNKNOWN);
1896         else {
1897             if (!validUnit(value, FLength|FPercent, strict)) {
1898                 delete parsedValue1;
1899                 return 0;
1900             }
1901             parsedValue2 = new CSSPrimitiveValue(value->fValue, (CSSPrimitiveValue::UnitTypes)value->unit);
1902         }
1903     }
1904     
1905     Pair* pair = new Pair(parsedValue1, parsedValue2);
1906     return new CSSPrimitiveValue(pair);
1907 }
1908
1909 bool CSSParser::parseBackgroundProperty(int propId, int& propId1, int& propId2, 
1910                                         CSSValue*& retValue1, CSSValue*& retValue2)
1911 {
1912     CSSValueList *values = 0, *values2 = 0;
1913     Value* val;
1914     CSSValue *value = 0, *value2 = 0;
1915     bool allowComma = false;
1916     
1917     retValue1 = retValue2 = 0;
1918     propId1 = propId;
1919     propId2 = propId;
1920     if (propId == CSS_PROP_BACKGROUND_POSITION) {
1921         propId1 = CSS_PROP_BACKGROUND_POSITION_X;
1922         propId2 = CSS_PROP_BACKGROUND_POSITION_Y;
1923     }
1924
1925     while ((val = valueList->current())) {
1926         CSSValue *currValue = 0, *currValue2 = 0;
1927         if (allowComma) {
1928             if (val->unit != Value::Operator || val->iValue != ',')
1929                 goto failed;
1930             valueList->next();
1931             allowComma = false;
1932         } else {
1933             switch (propId) {
1934                 case CSS_PROP_BACKGROUND_ATTACHMENT:
1935                     if (val->id == CSS_VAL_SCROLL || val->id == CSS_VAL_FIXED) {
1936                         currValue = new CSSPrimitiveValue(val->id);
1937                         valueList->next();
1938                     }
1939                     break;
1940                 case CSS_PROP_BACKGROUND_COLOR:
1941                     currValue = parseBackgroundColor();
1942                     if (currValue)
1943                         valueList->next();
1944                     break;
1945                 case CSS_PROP_BACKGROUND_IMAGE:
1946                     if (parseBackgroundImage(currValue))
1947                         valueList->next();
1948                     break;
1949                 case CSS_PROP__WEBKIT_BACKGROUND_CLIP:
1950                 case CSS_PROP__WEBKIT_BACKGROUND_ORIGIN:
1951                     if (val->id == CSS_VAL_BORDER || val->id == CSS_VAL_PADDING || val->id == CSS_VAL_CONTENT) {
1952                         currValue = new CSSPrimitiveValue(val->id);
1953                         valueList->next();
1954                     }
1955                     break;
1956                 case CSS_PROP_BACKGROUND_POSITION:
1957                     parseBackgroundPosition(currValue, currValue2);
1958                     // unlike the other functions, parseBackgroundPosition advances the valueList pointer
1959                     break;
1960                 case CSS_PROP_BACKGROUND_POSITION_X: {
1961                     bool xFound = false, yFound = true;
1962                     currValue = parseBackgroundPositionXY(xFound, yFound);
1963                     if (currValue)
1964                         valueList->next();
1965                     break;
1966                 }
1967                 case CSS_PROP_BACKGROUND_POSITION_Y: {
1968                     bool xFound = true, yFound = false;
1969                     currValue = parseBackgroundPositionXY(xFound, yFound);
1970                     if (currValue)
1971                         valueList->next();
1972                     break;
1973                 }
1974                 case CSS_PROP__WEBKIT_BACKGROUND_COMPOSITE:
1975                     if ((val->id >= CSS_VAL_CLEAR && val->id <= CSS_VAL_PLUS_LIGHTER) || val->id == CSS_VAL_HIGHLIGHT) {
1976                         currValue = new CSSPrimitiveValue(val->id);
1977                         valueList->next();
1978                     }
1979                     break;
1980                 case CSS_PROP_BACKGROUND_REPEAT:
1981                     if (val->id >= CSS_VAL_REPEAT && val->id <= CSS_VAL_NO_REPEAT) {
1982                         currValue = new CSSPrimitiveValue(val->id);
1983                         valueList->next();
1984                     }
1985                     break;
1986                 case CSS_PROP__WEBKIT_BACKGROUND_SIZE:
1987                     currValue = parseBackgroundSize();
1988                     if (currValue)
1989                         valueList->next();
1990                     break;
1991             }
1992             if (!currValue)
1993                 goto failed;
1994             
1995             if (value && !values) {
1996                 values = new CSSValueList();
1997                 values->append(value);
1998                 value = 0;
1999             }
2000             
2001             if (value2 && !values2) {
2002                 values2 = new CSSValueList();
2003                 values2->append(value2);
2004                 value2 = 0;
2005             }
2006             
2007             if (values)
2008                 values->append(currValue);
2009             else
2010                 value = currValue;
2011             if (currValue2) {
2012                 if (values2)
2013                     values2->append(currValue2);
2014                 else
2015                     value2 = currValue2;
2016             }
2017             allowComma = true;
2018         }
2019         
2020         // When parsing the 'background' shorthand property, we let it handle building up the lists for all
2021         // properties.
2022         if (inShorthand())
2023             break;
2024     }
2025
2026     if (values && values->length()) {
2027         retValue1 = values;
2028         if (values2 && values2->length())
2029             retValue2 = values2;
2030         return true;
2031     }
2032     if (value) {
2033         retValue1 = value;
2034         retValue2 = value2;
2035         return true;
2036     }
2037
2038 failed:
2039     delete values; delete values2;
2040     delete value; delete value2;
2041     return false;
2042 }
2043
2044 #define DASHBOARD_REGION_NUM_PARAMETERS  6
2045 #define DASHBOARD_REGION_SHORT_NUM_PARAMETERS  2
2046
2047 static Value *skipCommaInDashboardRegion (ValueList *args)
2048 {
2049     if (args->size() == (DASHBOARD_REGION_NUM_PARAMETERS*2-1) ||
2050          args->size() == (DASHBOARD_REGION_SHORT_NUM_PARAMETERS*2-1)) {
2051         Value *current = args->current();
2052         if (current->unit == Value::Operator && current->iValue == ',')
2053             return args->next();
2054     }
2055     return args->current();
2056 }
2057
2058 bool CSSParser::parseDashboardRegions(int propId, bool important)
2059 {
2060     bool valid = true;
2061     
2062     Value *value = valueList->current();
2063
2064     if (value->id == CSS_VAL_NONE) {
2065         if (valueList->next())
2066             return false;
2067         addProperty(propId, new CSSPrimitiveValue(value->id), important);
2068         return valid;
2069     }
2070         
2071     RefPtr<DashboardRegion> firstRegion = new DashboardRegion;
2072     DashboardRegion* region = 0;
2073
2074     while (value) {
2075         if (region == 0) {
2076             region = firstRegion.get();
2077         } else {
2078             RefPtr<DashboardRegion> nextRegion = new DashboardRegion();
2079             region->m_next = nextRegion;
2080             region = nextRegion.get();
2081         }
2082         
2083         if (value->unit != Value::Function) {
2084             valid = false;
2085             break;
2086         }
2087             
2088         // Commas count as values, so allow:
2089         // dashboard-region(label, type, t, r, b, l) or dashboard-region(label type t r b l)
2090         // dashboard-region(label, type, t, r, b, l) or dashboard-region(label type t r b l)
2091         // also allow
2092         // dashboard-region(label, type) or dashboard-region(label type)
2093         // dashboard-region(label, type) or dashboard-region(label type)
2094         ValueList* args = value->function->args;
2095         String fname = domString(value->function->name).lower();
2096         if (fname != "dashboard-region(" || !args) {
2097             valid = false;
2098             break;
2099         }
2100         
2101         int numArgs = args->size();
2102         if ((numArgs != DASHBOARD_REGION_NUM_PARAMETERS && numArgs != (DASHBOARD_REGION_NUM_PARAMETERS*2-1)) &&
2103             (numArgs != DASHBOARD_REGION_SHORT_NUM_PARAMETERS && numArgs != (DASHBOARD_REGION_SHORT_NUM_PARAMETERS*2-1))){
2104             valid = false;
2105             break;
2106         }
2107             
2108         // First arg is a label.
2109         Value* arg = args->current();
2110         if (arg->unit != CSSPrimitiveValue::CSS_IDENT) {
2111             valid = false;
2112             break;
2113         }
2114             
2115         region->m_label = domString(arg->string);
2116
2117         // Second arg is a type.
2118         arg = args->next();
2119         arg = skipCommaInDashboardRegion (args);
2120         if (arg->unit != CSSPrimitiveValue::CSS_IDENT) {
2121             valid = false;
2122             break;
2123         }
2124
2125         String geometryType = domString(arg->string).lower();
2126         if (geometryType == "circle")
2127             region->m_isCircle = true;
2128         else if (geometryType == "rectangle")
2129             region->m_isRectangle = true;
2130         else {
2131             valid = false;
2132             break;
2133         }
2134             
2135         region->m_geometryType = domString(arg->string);
2136
2137         if (numArgs == DASHBOARD_REGION_SHORT_NUM_PARAMETERS || numArgs == (DASHBOARD_REGION_SHORT_NUM_PARAMETERS*2-1)) {
2138             // This originally used CSS_VAL_INVALID by accident. It might be more logical to use something else.
2139             CSSPrimitiveValue *amount = new CSSPrimitiveValue(CSS_VAL_INVALID);
2140                 
2141             region->setTop(amount);
2142             region->setRight(amount);
2143             region->setBottom(amount);
2144             region->setLeft(amount);
2145         }
2146         else {
2147             // Next four arguments must be offset numbers
2148             int i;
2149             for (i = 0; i < 4; i++) {
2150                 arg = args->next();
2151                 arg = skipCommaInDashboardRegion (args);
2152
2153                 valid = arg->id == CSS_VAL_AUTO || validUnit(arg, FLength, strict);
2154                 if (!valid)
2155                     break;
2156                     
2157                 CSSPrimitiveValue *amount = arg->id == CSS_VAL_AUTO ?
2158                     new CSSPrimitiveValue(CSS_VAL_AUTO) :
2159                     new CSSPrimitiveValue(arg->fValue, (CSSPrimitiveValue::UnitTypes) arg->unit);
2160                     
2161                 if (i == 0)
2162                     region->setTop(amount);
2163                 else if (i == 1)
2164                     region->setRight(amount);
2165                 else if (i == 2)
2166                     region->setBottom(amount);
2167                 else
2168                     region->setLeft(amount);
2169             }
2170         }
2171
2172         if (args->next())
2173             return false;
2174
2175         value = valueList->next();
2176     }
2177
2178     if (valid)
2179         addProperty(propId, new CSSPrimitiveValue(firstRegion.release()), important);
2180         
2181     return valid;
2182 }
2183
2184 PassRefPtr<CSSValue> CSSParser::parseCounterContent(ValueList* args, bool counters)
2185 {
2186     unsigned numArgs = args->size();
2187     if (counters && numArgs != 3 && numArgs != 5)
2188         return 0;
2189     if (!counters && numArgs != 1 && numArgs != 3)
2190         return 0;
2191     
2192     Value* i = args->current();
2193     RefPtr<CSSPrimitiveValue> identifier = new CSSPrimitiveValue(domString(i->string),
2194         CSSPrimitiveValue::CSS_STRING);
2195
2196     RefPtr<CSSPrimitiveValue> separator;
2197     if (!counters)
2198         separator = new CSSPrimitiveValue(String(), CSSPrimitiveValue::CSS_STRING);
2199     else {
2200         i = args->next();
2201         if (i->unit != Value::Operator || i->iValue != ',')
2202             return 0;
2203         
2204         i = args->next();
2205         if (i->unit != CSSPrimitiveValue::CSS_STRING)
2206             return 0;
2207         
2208         separator = new CSSPrimitiveValue(domString(i->string), (CSSPrimitiveValue::UnitTypes) i->unit);
2209     }
2210
2211     RefPtr<CSSPrimitiveValue> listStyle;
2212     i = args->next();
2213     if (!i) // Make the list style default decimal
2214         listStyle = new CSSPrimitiveValue(CSS_VAL_DECIMAL - CSS_VAL_DISC, CSSPrimitiveValue::CSS_NUMBER);
2215     else {
2216         if (i->unit != Value::Operator || i->iValue != ',')
2217             return 0;
2218         
2219         i = args->next();
2220         if (i->unit != CSSPrimitiveValue::CSS_IDENT)
2221             return 0;
2222         
2223         short ls = 0;
2224         if (i->id == CSS_VAL_NONE)
2225             ls = CSS_VAL_KATAKANA_IROHA - CSS_VAL_DISC + 1;
2226         else if (i->id >= CSS_VAL_DISC && i->id <= CSS_VAL_KATAKANA_IROHA)
2227             ls = i->id - CSS_VAL_DISC;
2228         else
2229             return 0;
2230
2231         listStyle = new CSSPrimitiveValue(ls, (CSSPrimitiveValue::UnitTypes) i->unit);
2232     }
2233
2234     return new CSSPrimitiveValue(new Counter(identifier.release(), listStyle.release(), separator.release()));
2235 }
2236
2237 bool CSSParser::parseShape(int propId, bool important)
2238 {
2239     Value *value = valueList->current();
2240     ValueList *args = value->function->args;
2241     String fname = domString(value->function->name).lower();
2242     if (fname != "rect(" || !args)
2243         return false;
2244
2245     // rect(t, r, b, l) || rect(t r b l)
2246     if (args->size() != 4 && args->size() != 7)
2247         return false;
2248     Rect *rect = new Rect();
2249     bool valid = true;
2250     int i = 0;
2251     Value *a = args->current();
2252     while (a) {
2253         valid = a->id == CSS_VAL_AUTO || validUnit(a, FLength, strict);
2254         if (!valid)
2255             break;
2256         CSSPrimitiveValue *length = a->id == CSS_VAL_AUTO ?
2257             new CSSPrimitiveValue(CSS_VAL_AUTO) :
2258             new CSSPrimitiveValue(a->fValue, (CSSPrimitiveValue::UnitTypes) a->unit);
2259         if (i == 0)
2260             rect->setTop(length);
2261         else if (i == 1)
2262             rect->setRight(length);
2263         else if (i == 2)
2264             rect->setBottom(length);
2265         else
2266             rect->setLeft(length);
2267         a = args->next();
2268         if (a && args->size() == 7) {
2269             if (a->unit == Value::Operator && a->iValue == ',') {
2270                 a = args->next();
2271             } else {
2272                 valid = false;
2273                 break;
2274             }
2275         }
2276         i++;
2277     }
2278     if (valid) {
2279         addProperty(propId, new CSSPrimitiveValue(rect), important);
2280         valueList->next();
2281         return true;
2282     }
2283     delete rect;
2284     return false;
2285 }
2286
2287 // [ 'font-style' || 'font-variant' || 'font-weight' ]? 'font-size' [ / 'line-height' ]? 'font-family'
2288 bool CSSParser::parseFont(bool important)
2289 {
2290     bool valid = true;
2291     Value *value = valueList->current();
2292     FontValue *font = new FontValue;
2293     // optional font-style, font-variant and font-weight
2294     while (value) {
2295         int id = value->id;
2296         if (id) {
2297             if (id == CSS_VAL_NORMAL) {
2298                 // do nothing, it's the inital value for all three
2299             } else if (id == CSS_VAL_ITALIC || id == CSS_VAL_OBLIQUE) {
2300                 if (font->style)
2301                     goto invalid;
2302                 font->style = new CSSPrimitiveValue(id);
2303             } else if (id == CSS_VAL_SMALL_CAPS) {
2304                 if (font->variant)
2305                     goto invalid;
2306                 font->variant = new CSSPrimitiveValue(id);
2307             } else if (id >= CSS_VAL_BOLD && id <= CSS_VAL_LIGHTER) {
2308                 if (font->weight)
2309                     goto invalid;
2310                 font->weight = new CSSPrimitiveValue(id);
2311             } else {
2312                 valid = false;
2313             }
2314         } else if (!font->weight && validUnit(value, FInteger|FNonNeg, true)) {
2315             int weight = (int)value->fValue;
2316             int val = 0;
2317             if (weight == 100)
2318                 val = CSS_VAL_100;
2319             else if (weight == 200)
2320                 val = CSS_VAL_200;
2321             else if (weight == 300)
2322                 val = CSS_VAL_300;
2323             else if (weight == 400)
2324                 val = CSS_VAL_400;
2325             else if (weight == 500)
2326                 val = CSS_VAL_500;
2327             else if (weight == 600)
2328                 val = CSS_VAL_600;
2329             else if (weight == 700)
2330                 val = CSS_VAL_700;
2331             else if (weight == 800)
2332                 val = CSS_VAL_800;
2333             else if (weight == 900)
2334                 val = CSS_VAL_900;
2335
2336             if (val)
2337                 font->weight = new CSSPrimitiveValue(val);
2338             else
2339                 valid = false;
2340         } else {
2341             valid = false;
2342         }
2343         if (!valid)
2344             break;
2345         value = valueList->next();
2346     }
2347     if (!value)
2348         goto invalid;
2349
2350     // set undefined values to default
2351     if (!font->style)
2352         font->style = new CSSPrimitiveValue(CSS_VAL_NORMAL);
2353     if (!font->variant)
2354         font->variant = new CSSPrimitiveValue(CSS_VAL_NORMAL);
2355     if (!font->weight)
2356         font->weight = new CSSPrimitiveValue(CSS_VAL_NORMAL);
2357
2358     // now a font size _must_ come
2359     // <absolute-size> | <relative-size> | <length> | <percentage> | inherit
2360     if (value->id >= CSS_VAL_XX_SMALL && value->id <= CSS_VAL_LARGER)
2361         font->size = new CSSPrimitiveValue(value->id);
2362     else if (validUnit(value, FLength|FPercent, strict))
2363         font->size = new CSSPrimitiveValue(value->fValue, (CSSPrimitiveValue::UnitTypes) value->unit);
2364     value = valueList->next();
2365     if (!font->size || !value)
2366         goto invalid;
2367
2368     if (value->unit == Value::Operator && value->iValue == '/') {
2369         // line-height
2370         value = valueList->next();
2371         if (!value)
2372             goto invalid;
2373         if (value->id == CSS_VAL_NORMAL) {
2374             // default value, nothing to do
2375         } else if (validUnit(value, FNumber|FLength|FPercent, strict))
2376             font->lineHeight = new CSSPrimitiveValue(value->fValue, (CSSPrimitiveValue::UnitTypes) value->unit);
2377         else
2378             goto invalid;
2379         value = valueList->next();
2380         if (!value)
2381             goto invalid;
2382     }
2383     
2384     if (!font->lineHeight)
2385         font->lineHeight = new CSSPrimitiveValue(CSS_VAL_NORMAL);
2386
2387     // font family must come now
2388     font->family = parseFontFamily();
2389
2390     if (valueList->current() || !font->family)
2391         goto invalid;
2392
2393     addProperty(CSS_PROP_FONT, font, important);
2394     return true;
2395
2396  invalid:
2397     delete font;
2398     return false;
2399 }
2400
2401 CSSValueList* CSSParser::parseFontFamily()
2402 {
2403     CSSValueList* list = new CSSValueList;
2404     Value* value = valueList->current();
2405     FontFamilyValue* currFamily = 0;
2406     while (value) {
2407         Value* nextValue = valueList->next();
2408         bool nextValBreaksFont = !nextValue ||
2409                                  (nextValue->unit == Value::Operator && nextValue->iValue == ',');
2410         bool nextValIsFontName = nextValue &&
2411             ((nextValue->id >= CSS_VAL_SERIF && nextValue->id <= CSS_VAL__WEBKIT_BODY) ||
2412             (nextValue->unit == CSSPrimitiveValue::CSS_STRING || nextValue->unit == CSSPrimitiveValue::CSS_IDENT));
2413
2414         if (value->id >= CSS_VAL_SERIF && value->id <= CSS_VAL__WEBKIT_BODY) {
2415             if (currFamily) {
2416                 currFamily->parsedFontName += ' ';
2417                 currFamily->parsedFontName += deprecatedString(value->string);
2418             }
2419             else if (nextValBreaksFont || !nextValIsFontName)
2420                 list->append(new CSSPrimitiveValue(value->id));
2421             else
2422                 list->append(currFamily = new FontFamilyValue(deprecatedString(value->string)));
2423         }
2424         else if (value->unit == CSSPrimitiveValue::CSS_STRING) {
2425             // Strings never share in a family name.
2426             currFamily = 0;
2427             list->append(new FontFamilyValue(deprecatedString(value->string)));
2428         }
2429         else if (value->unit == CSSPrimitiveValue::CSS_IDENT) {
2430             if (currFamily) {
2431                 currFamily->parsedFontName += ' ';
2432                 currFamily->parsedFontName += deprecatedString(value->string);
2433             }
2434             else if (nextValBreaksFont || !nextValIsFontName)
2435                 list->append(new FontFamilyValue(deprecatedString(value->string)));
2436             else
2437                 list->append(currFamily = new FontFamilyValue(deprecatedString(value->string)));
2438         }
2439         else {
2440             break;
2441         }
2442         
2443         if (!nextValue)
2444             break;
2445
2446         if (nextValBreaksFont) {
2447             value = valueList->next();
2448             currFamily = 0;
2449         }
2450         else if (nextValIsFontName)
2451             value = nextValue;
2452         else
2453             break;
2454     }
2455     if (!list->length()) {
2456         delete list;
2457         list = 0;
2458     }
2459     return list;
2460 }
2461
2462 bool CSSParser::parseColor(const String &name, RGBA32& rgb, bool strict)
2463 {
2464     if (!strict && Color::parseHexColor(name, rgb))
2465         return true;
2466
2467     // try a little harder
2468     Color tc;
2469     tc.setNamedColor(name.lower());
2470     if (tc.isValid()) {
2471         rgb = tc.rgb();
2472         return true;
2473     }
2474
2475     return false;
2476 }
2477
2478 bool CSSParser::parseColorParameters(Value* value, int* colorArray, bool parseAlpha)
2479 {
2480     ValueList* args = value->function->args;
2481     Value* v = args->current();
2482     // Get the first value
2483     if (!validUnit(v, FInteger | FPercent, true))
2484         return false;
2485     colorArray[0] = static_cast<int>(v->fValue * (v->unit == CSSPrimitiveValue::CSS_PERCENTAGE ? 256.0 / 100.0 : 1.0));
2486     for (int i = 1; i < 3; i++) {
2487         v = args->next();
2488         if (v->unit != Value::Operator && v->iValue != ',')
2489             return false;
2490         v = args->next();
2491         if (!validUnit(v, FInteger | FPercent, true))
2492             return false;
2493         colorArray[i] = static_cast<int>(v->fValue * (v->unit == CSSPrimitiveValue::CSS_PERCENTAGE ? 256.0 / 100.0 : 1.0));
2494     }
2495     if (parseAlpha) {
2496         v = args->next();
2497         if (v->unit != Value::Operator && v->iValue != ',')
2498             return false;
2499         v = args->next();
2500         if (!validUnit(v, FNumber, true))
2501             return false;
2502         colorArray[3] = static_cast<int>(max(0.0, min(1.0, v->fValue)) * 255);
2503     }
2504     return true;
2505 }
2506
2507 // CSS3 sepcification defines the format of a HSL color as
2508 // hsl(<number>, <percent>, <percent>)
2509 // and with alpha, the format is
2510 // hsla(<number>, <percent>, <percent>, <number>)
2511 // The first value, HUE, is in an angle with a value between 0 and 360
2512 bool CSSParser::parseHSLParameters(Value* value, double* colorArray, bool parseAlpha)
2513 {
2514     ValueList* args = value->function->args;
2515     Value* v = args->current();
2516     // Get the first value
2517     if (!validUnit(v, FNumber, true))
2518         return false;
2519     // normalize the Hue value and change it to be between 0 and 1.0
2520     colorArray[0] = (((static_cast<int>(v->fValue) % 360) + 360) % 360) / 360.0;
2521     for (int i = 1; i < 3; i++) {
2522         v = args->next();
2523         if (v->unit != Value::Operator && v->iValue != ',')
2524             return false;
2525         v = args->next();
2526         if (!validUnit(v, FPercent, true))
2527             return false;
2528         colorArray[i] = max(0.0, min(100.0, v->fValue)) / 100.0; // needs to be value between 0 and 1.0
2529     }
2530     if (parseAlpha) {
2531         v = args->next();
2532         if (v->unit != Value::Operator && v->iValue != ',')
2533             return false;
2534         v = args->next();
2535         if (!validUnit(v, FNumber, true))
2536             return false;
2537         colorArray[3] = max(0.0, min(1.0, v->fValue));
2538     }
2539     return true;
2540 }
2541
2542 CSSPrimitiveValue *CSSParser::parseColor(Value* value)
2543 {
2544     RGBA32 c = Color::transparent;
2545     if (!parseColorFromValue(value ? value : valueList->current(), c))
2546         return 0;
2547     return new CSSPrimitiveValue(c);
2548 }
2549
2550 bool CSSParser::parseColorFromValue(Value* value, RGBA32& c, bool svg)
2551 {
2552     if (!strict && value->unit == CSSPrimitiveValue::CSS_NUMBER &&
2553         value->fValue >= 0. && value->fValue < 1000000.) {
2554         String str = String::format("%06d", (int)(value->fValue+.5));
2555         if (!CSSParser::parseColor(str, c, strict))
2556             return false;
2557     } else if (value->unit == CSSPrimitiveValue::CSS_RGBCOLOR ||
2558                 value->unit == CSSPrimitiveValue::CSS_IDENT ||
2559                 (!strict && value->unit == CSSPrimitiveValue::CSS_DIMENSION)) {
2560         if (!CSSParser::parseColor(domString(value->string), c, strict && value->unit == CSSPrimitiveValue::CSS_IDENT))
2561             return false;
2562     } else if (value->unit == Value::Function &&
2563                 value->function->args != 0 &&
2564                 value->function->args->size() == 5 /* rgb + two commas */ &&
2565                 domString(value->function->name).lower() == "rgb(") {
2566         int colorValues[3];
2567         if (!parseColorParameters(value, colorValues, false))
2568             return false;
2569         c = makeRGB(colorValues[0], colorValues[1], colorValues[2]);
2570     } else if (!svg) {
2571         if (value->unit == Value::Function &&
2572                 value->function->args != 0 &&
2573                 value->function->args->size() == 7 /* rgba + three commas */ &&
2574                 domString(value->function->name).lower() == "rgba(") {
2575             int colorValues[4];
2576             if (!parseColorParameters(value, colorValues, true))
2577                 return false;
2578             c = makeRGBA(colorValues[0], colorValues[1], colorValues[2], colorValues[3]);
2579         } else if (value->unit == Value::Function &&
2580                     value->function->args != 0 &&
2581                     value->function->args->size() == 5 /* hsl + two commas */ &&
2582                     domString(value->function->name).lower() == "hsl(") {
2583             double colorValues[3];
2584             if (!parseHSLParameters(value, colorValues, false))
2585                 return false;
2586             c = makeRGBAFromHSLA(colorValues[0], colorValues[1], colorValues[2], 1.0);
2587         } else if (value->unit == Value::Function &&
2588                     value->function->args != 0 &&
2589                     value->function->args->size() == 7 /* hsla + three commas */ &&
2590                     domString(value->function->name).lower() == "hsla(") {
2591             double colorValues[4];
2592             if (!parseHSLParameters(value, colorValues, true))
2593                 return false;
2594             c = makeRGBAFromHSLA(colorValues[0], colorValues[1], colorValues[2], colorValues[3]);
2595         } else
2596             return false;
2597     } else
2598         return false;
2599
2600     return true;
2601 }
2602
2603 // This class tracks parsing state for shadow values.  If it goes out of scope (e.g., due to an early return)
2604 // without the allowBreak bit being set, then it will clean up all of the objects and destroy them.
2605 struct ShadowParseContext {
2606     ShadowParseContext()
2607     :values(0), x(0), y(0), blur(0), color(0),
2608      allowX(true), allowY(false), allowBlur(false), allowColor(true),
2609      allowBreak(true)
2610     {}
2611
2612     bool allowLength() { return allowX || allowY || allowBlur; }
2613
2614     void commitValue() {
2615         // Handle the ,, case gracefully by doing nothing.
2616         if (x || y || blur || color) {
2617             if (!values)
2618                 values = new CSSValueList();
2619             
2620             // Construct the current shadow value and add it to the list.
2621             values->append(new ShadowValue(x.release(), y.release(), blur.release(), color.release()));
2622         }
2623         
2624         // Now reset for the next shadow value.
2625         x = y = blur = color = 0;
2626         allowX = allowColor = allowBreak = true;
2627         allowY = allowBlur = false;  
2628     }
2629
2630     void commitLength(Value* v) {
2631         RefPtr<CSSPrimitiveValue> val = new CSSPrimitiveValue(v->fValue, (CSSPrimitiveValue::UnitTypes)v->unit);
2632
2633         if (allowX) {
2634             x = val.release();
2635             allowX = false; allowY = true; allowColor = false; allowBreak = false;
2636         }
2637         else if (allowY) {
2638             y = val.release();
2639             allowY = false; allowBlur = true; allowColor = true; allowBreak = true;
2640         }
2641         else if (allowBlur) {
2642             blur = val.release();
2643             allowBlur = false;
2644         }
2645     }
2646
2647     void commitColor(CSSPrimitiveValue* val) {
2648         color = val;
2649         allowColor = false;
2650         if (allowX)
2651             allowBreak = false;
2652         else
2653             allowBlur = false;
2654     }
2655     
2656     RefPtr<CSSValueList> values;
2657     RefPtr<CSSPrimitiveValue> x;
2658     RefPtr<CSSPrimitiveValue> y;
2659     RefPtr<CSSPrimitiveValue> blur;
2660     RefPtr<CSSPrimitiveValue> color;
2661
2662     bool allowX;
2663     bool allowY;
2664     bool allowBlur;
2665     bool allowColor;
2666     bool allowBreak;
2667 };
2668
2669 bool CSSParser::parseShadow(int propId, bool important)
2670 {
2671     ShadowParseContext context;
2672     Value* val;
2673     while ((val = valueList->current())) {
2674         // Check for a comma break first.
2675         if (val->unit == Value::Operator) {
2676             if (val->iValue != ',' || !context.allowBreak)
2677                 // Other operators aren't legal or we aren't done with the current shadow
2678                 // value.  Treat as invalid.
2679                 return false;
2680             
2681             // The value is good.  Commit it.
2682             context.commitValue();
2683         }
2684         // Check to see if we're a length.
2685         else if (validUnit(val, FLength, true)) {
2686             // We required a length and didn't get one. Invalid.
2687             if (!context.allowLength())
2688                 return false;
2689
2690             // A length is allowed here.  Construct the value and add it.
2691             context.commitLength(val);
2692         }
2693         else {
2694             // The only other type of value that's ok is a color value.
2695             CSSPrimitiveValue* parsedColor = 0;
2696             bool isColor = (val->id >= CSS_VAL_AQUA && val->id <= CSS_VAL_WINDOWTEXT || val->id == CSS_VAL_MENU ||
2697                             (val->id >= CSS_VAL__WEBKIT_FOCUS_RING_COLOR && val->id <= CSS_VAL__WEBKIT_TEXT && !strict));
2698             if (isColor) {
2699                 if (!context.allowColor)
2700                     return false;
2701                 parsedColor = new CSSPrimitiveValue(val->id);
2702             }
2703
2704             if (!parsedColor)
2705                 // It's not built-in. Try to parse it as a color.
2706                 parsedColor = parseColor(val);
2707
2708             if (!parsedColor || !context.allowColor)
2709                 return false; // This value is not a color or length and is invalid or
2710                               // it is a color, but a color isn't allowed at this point.
2711             
2712             context.commitColor(parsedColor);
2713         }
2714         
2715         valueList->next();
2716     }
2717
2718     if (context.allowBreak) {
2719         context.commitValue();
2720         if (context.values->length()) {
2721             addProperty(propId, context.values.release(), important);
2722             valueList->next();
2723             return true;
2724         }
2725     }
2726     
2727     return false;
2728 }
2729
2730 struct BorderImageParseContext
2731 {
2732     BorderImageParseContext()
2733     :m_allowBreak(false), m_allowNumber(false), m_allowSlash(false), m_allowWidth(false),
2734      m_allowRule(false), m_image(0), m_top(0), m_right(0), m_bottom(0), m_left(0), m_borderTop(0), m_borderRight(0), m_borderBottom(0),
2735      m_borderLeft(0), m_horizontalRule(0), m_verticalRule(0)
2736     {}
2737     
2738     bool allowBreak() const { return m_allowBreak; }
2739     bool allowNumber() const { return m_allowNumber; }
2740     bool allowSlash() const { return m_allowSlash; }
2741     bool allowWidth() const { return m_allowWidth; }
2742     bool allowRule() const { return m_allowRule; }
2743
2744     void commitImage(CSSImageValue* image) { m_image = image; m_allowNumber = true; }
2745     void commitNumber(Value* v) {
2746         CSSPrimitiveValue* val = new CSSPrimitiveValue(v->fValue,
2747                                                                (CSSPrimitiveValue::UnitTypes)v->unit);
2748         if (!m_top)
2749             m_top = val;
2750         else if (!m_right)
2751             m_right = val;
2752         else if (!m_bottom)
2753             m_bottom = val;
2754         else {
2755             ASSERT(!m_left);
2756             m_left = val;
2757         }
2758         
2759         m_allowBreak = m_allowSlash = m_allowRule = true;
2760         m_allowNumber = !m_left;
2761     }
2762     void commitSlash() { m_allowBreak = m_allowSlash = m_allowNumber = false; m_allowWidth = true; }
2763     void commitWidth(Value* val) {
2764         if (!m_borderTop)
2765             m_borderTop.set(val);
2766         else if (!m_borderRight)
2767             m_borderRight.set(val);
2768         else if (!m_borderBottom)
2769             m_borderBottom.set(val);
2770         else {
2771             ASSERT(!m_borderLeft);
2772             m_borderLeft.set(val);
2773         }
2774
2775         m_allowBreak = m_allowRule = true;
2776         m_allowWidth = !m_borderLeft;
2777     }
2778     void commitRule(int keyword) {
2779         if (!m_horizontalRule)
2780             m_horizontalRule = keyword;
2781         else if (!m_verticalRule)
2782             m_verticalRule = keyword;
2783         m_allowRule = !m_verticalRule;
2784     }
2785     void commitBorderImage(CSSParser* p, int propId, bool important) {
2786         // We need to clone and repeat values for any omissions.
2787         if (!m_right) {
2788             m_right = new CSSPrimitiveValue(m_top->getDoubleValue(), (CSSPrimitiveValue::UnitTypes)m_top->primitiveType());
2789             m_bottom = new CSSPrimitiveValue(m_top->getDoubleValue(), (CSSPrimitiveValue::UnitTypes)m_top->primitiveType());
2790             m_left = new CSSPrimitiveValue(m_top->getDoubleValue(), (CSSPrimitiveValue::UnitTypes)m_top->primitiveType());
2791         }
2792         if (!m_bottom) {
2793             m_bottom = new CSSPrimitiveValue(m_top->getDoubleValue(), (CSSPrimitiveValue::UnitTypes)m_top->primitiveType());
2794             m_left = new CSSPrimitiveValue(m_right->getDoubleValue(), (CSSPrimitiveValue::UnitTypes)m_right->primitiveType());
2795         }
2796         if (!m_left)
2797              m_left = new CSSPrimitiveValue(m_top->getDoubleValue(), (CSSPrimitiveValue::UnitTypes)m_top->primitiveType());
2798              
2799         // Now build a rect value to hold all four of our primitive values.
2800         Rect* rect = new Rect;
2801         rect->setTop(m_top); rect->setRight(m_right); rect->setBottom(m_bottom); rect->setLeft(m_left);
2802
2803         // Fill in STRETCH as the default if it wasn't specified.
2804         if (!m_horizontalRule)
2805             m_horizontalRule = CSS_VAL_STRETCH;
2806             
2807         // The vertical rule should match the horizontal rule if unspecified.
2808         if (!m_verticalRule)
2809             m_verticalRule = m_horizontalRule;
2810
2811         // Make our new border image value now and add it as the result.
2812         CSSBorderImageValue* borderImage = new CSSBorderImageValue(m_image, rect, m_horizontalRule, m_verticalRule);
2813         p->addProperty(propId, borderImage, important);
2814             
2815         // Now we have to deal with the border widths.  The best way to deal with these is to actually put these values into a value
2816         // list and then make our parsing machinery do the parsing.
2817         if (m_borderTop) {
2818             ValueList newList;
2819             newList.addValue(*m_borderTop);
2820             if (m_borderRight)
2821                 newList.addValue(*m_borderRight);
2822             if (m_borderBottom)
2823                 newList.addValue(*m_borderBottom);
2824             if (m_borderLeft)
2825                 newList.addValue(*m_borderLeft);
2826             p->valueList = &newList;
2827             p->parseValue(CSS_PROP_BORDER_WIDTH, important);
2828             p->valueList = 0;
2829         }
2830     }
2831     
2832     bool m_allowBreak;
2833     bool m_allowNumber;
2834     bool m_allowSlash;
2835     bool m_allowWidth;
2836     bool m_allowRule;
2837     
2838     RefPtr<CSSImageValue> m_image;
2839     
2840     RefPtr<CSSPrimitiveValue> m_top;
2841     RefPtr<CSSPrimitiveValue> m_right;
2842     RefPtr<CSSPrimitiveValue> m_bottom;
2843     RefPtr<CSSPrimitiveValue> m_left;
2844     
2845     OwnPtr<Value> m_borderTop;
2846     OwnPtr<Value> m_borderRight;
2847     OwnPtr<Value> m_borderBottom;
2848     OwnPtr<Value> m_borderLeft;
2849     
2850     int m_horizontalRule;
2851     int m_verticalRule;
2852 };
2853
2854 bool CSSParser::parseBorderImage(int propId, bool important)
2855 {
2856     // Look for an image initially.  If the first value is not a URI, then we're done.
2857     BorderImageParseContext context;
2858     Value* val = valueList->current();
2859     if (val->unit != CSSPrimitiveValue::CSS_URI)
2860         return false;
2861         
2862     String uri = parseURL(domString(val->string));
2863     if (uri.isEmpty())
2864         return false;
2865     
2866     context.commitImage(new CSSImageValue(String(KURL(styleElement->baseURL().deprecatedString(), uri.deprecatedString()).url()),
2867                                                              styleElement));
2868     while ((val = valueList->next())) {
2869         if (context.allowNumber() && validUnit(val, FInteger|FNonNeg|FPercent, true)) {
2870             context.commitNumber(val);
2871         } else if (context.allowSlash() && val->unit == Value::Operator && val->iValue == '/') {
2872             context.commitSlash();
2873         } else if (context.allowWidth() &&
2874             (val->id == CSS_VAL_THIN || val->id == CSS_VAL_MEDIUM || val->id == CSS_VAL_THICK || validUnit(val, FLength, strict))) {
2875             context.commitWidth(val);
2876         } else if (context.allowRule() &&
2877             (val->id == CSS_VAL_STRETCH || val->id == CSS_VAL_ROUND || val->id == CSS_VAL_REPEAT)) {
2878             context.commitRule(val->id);
2879         } else {
2880             // Something invalid was encountered.
2881             return false;
2882         }
2883     }
2884     
2885     if (context.allowBreak()) {
2886         // Need to fully commit as a single value.
2887         context.commitBorderImage(this, propId, important);
2888         return true;
2889     }
2890     
2891     return false;
2892 }
2893
2894 bool CSSParser::parseCounter(int propId, int defaultValue, bool important)
2895 {
2896     enum { ID, VAL } state = ID;
2897
2898     RefPtr<CSSValueList> list = new CSSValueList;
2899     RefPtr<CSSPrimitiveValue> counterName;
2900     
2901     while (true) {
2902         Value* val = valueList->current();
2903         switch (state) {
2904             case ID:
2905                 if (val && val->unit == CSSPrimitiveValue::CSS_IDENT) {
2906                     counterName = new CSSPrimitiveValue(domString(val->string), CSSPrimitiveValue::CSS_STRING);
2907                     state = VAL;
2908                     valueList->next();
2909                     continue;
2910                 }
2911                 break;
2912             case VAL: {
2913                 int i = defaultValue;
2914                 if (val && val->unit == CSSPrimitiveValue::CSS_NUMBER) {
2915                     i = (int)val->fValue;
2916                     valueList->next();
2917                 }
2918
2919                 list->append(new CSSPrimitiveValue(new Pair(counterName.release(),
2920                     new CSSPrimitiveValue(i, CSSPrimitiveValue::CSS_NUMBER))));
2921                 state = ID;
2922                 continue;
2923             }
2924         }
2925         break;
2926     }
2927     
2928     if (list->length() > 0) {
2929         addProperty(propId, list.release(), important);
2930         return true;
2931     }
2932
2933     return false;
2934 }
2935
2936 #ifdef CSS_DEBUG
2937
2938 static inline int yyerror(const char *str)
2939 {
2940     kdDebug(6080) << "CSS parse error " << str << endl;
2941     return 1;
2942 }
2943
2944 #else
2945
2946 static inline int yyerror(const char*) { return 1; }
2947
2948 #endif
2949
2950 #define END_TOKEN 0
2951
2952 #include "CSSGrammar.h"
2953
2954 int CSSParser::lex(void* yylvalWithoutType)
2955 {
2956     YYSTYPE* yylval = static_cast<YYSTYPE*>(yylvalWithoutType);
2957     int token = lex();
2958     int length;
2959     UChar* t = text(&length);
2960
2961     switch(token) {
2962     case WHITESPACE:
2963     case SGML_CD:
2964     case INCLUDES:
2965     case DASHMATCH:
2966         break;
2967
2968     case URI:
2969     case STRING:
2970     case IDENT:
2971     case HEX:
2972     case IDSEL:
2973     case DIMEN:
2974     case UNICODERANGE:
2975     case FUNCTION:
2976     case NOTFUNCTION:
2977         yylval->string.characters = t;
2978         yylval->string.length = length;
2979         break;
2980
2981     case IMPORT_SYM:
2982     case PAGE_SYM:
2983     case MEDIA_SYM:
2984     case FONT_FACE_SYM:
2985     case CHARSET_SYM:
2986     case NAMESPACE_SYM:
2987
2988     case IMPORTANT_SYM:
2989         break;
2990
2991     case QEMS:
2992         length--;
2993     case GRADS:
2994         length--;
2995     case DEGS:
2996     case RADS:
2997     case KHERZ:
2998         length--;
2999     case MSECS:
3000     case HERZ:
3001     case EMS:
3002     case EXS:
3003     case PXS:
3004     case CMS:
3005     case MMS:
3006     case INS:
3007     case PTS:
3008     case PCS:
3009         length--;
3010     case SECS:
3011     case PERCENTAGE:
3012         length--;
3013     case FLOATTOKEN:
3014     case INTEGER:
3015         yylval->val = DeprecatedString((DeprecatedChar*)t, length).toFloat();
3016         break;
3017
3018     default:
3019         break;
3020     }
3021
3022     return token;
3023 }
3024
3025 static inline int toHex(char c)
3026 {
3027     if ('0' <= c && c <= '9')
3028         return c - '0';
3029     if ('a' <= c && c <= 'f')
3030         return c - 'a' + 10;
3031     if ('A' <= c && c<= 'F')
3032         return c - 'A' + 10;
3033     return 0;
3034 }
3035
3036 UChar* CSSParser::text(int *length)
3037 {
3038     UChar* start = yytext;
3039     int l = yyleng;
3040     switch(yyTok) {
3041     case STRING:
3042         l--;
3043         /* nobreak */
3044     case HEX:
3045     case IDSEL:
3046         start++;
3047         l--;
3048         break;
3049     case URI:
3050         // "url("{w}{string}{w}")"
3051         // "url("{w}{url}{w}")"
3052
3053         // strip "url(" and ")"
3054         start += 4;
3055         l -= 5;
3056         // strip {w}
3057         while (l &&
3058                 (*start == ' ' || *start == '\t' || *start == '\r' ||
3059                  *start == '\n' || *start == '\f')) {
3060             start++; l--;
3061         }
3062         if (*start == '"' || *start == '\'') {
3063             start++; l--;
3064         }
3065         while (l &&
3066                 (start[l-1] == ' ' || start[l-1] == '\t' || start[l-1] == '\r' ||
3067                  start[l-1] == '\n' || start[l-1] == '\f')) {
3068             l--;
3069         }
3070         if (l && (start[l-1] == '\"' || start[l-1] == '\''))
3071              l--;
3072
3073     default:
3074         break;
3075     }
3076
3077     // process escapes
3078     UChar* out = start;
3079     UChar* escape = 0;
3080
3081     for (int i = 0; i < l; i++) {
3082         UChar* current = start + i;
3083         if (escape == current - 1) {
3084             if ((*current >= '0' && *current <= '9') ||
3085                  (*current >= 'a' && *current <= 'f') ||
3086                  (*current >= 'A' && *current <= 'F'))
3087                 continue;
3088             if (yyTok == STRING &&
3089                  (*current == '\n' || *current == '\r' || *current == '\f')) {
3090                 // ### handle \r\n case
3091                 if (*current != '\r')
3092                     escape = 0;
3093                 continue;
3094             }
3095             // in all other cases copy the char to output
3096             // ###
3097             *out++ = *current;
3098             escape = 0;
3099             continue;
3100         }
3101         if (escape == current - 2 && yyTok == STRING &&
3102              *(current-1) == '\r' && *current == '\n') {
3103             escape = 0;
3104             continue;
3105         }
3106         if (escape > current - 7 &&
3107              ((*current >= '0' && *current <= '9') ||
3108                (*current >= 'a' && *current <= 'f') ||
3109                (*current >= 'A' && *current <= 'F')))
3110             continue;
3111         if (escape) {
3112             // add escaped char
3113             unsigned uc = 0;
3114             escape++;
3115             while (escape < current) {
3116                 uc *= 16;
3117                 uc += toHex(*escape);
3118                 escape++;
3119             }
3120             // can't handle chars outside ucs2
3121             if (uc > 0xffff)
3122                 uc = 0xfffd;
3123             *out++ = uc;
3124             escape = 0;
3125             if (*current == ' ' ||
3126                  *current == '\t' ||
3127                  *current == '\r' ||
3128                  *current == '\n' ||
3129                  *current == '\f')
3130                 continue;
3131         }
3132         if (!escape && *current == '\\') {
3133             escape = current;
3134             continue;
3135         }
3136         *out++ = *current;
3137     }
3138     if (escape) {
3139         // add escaped char
3140         unsigned uc = 0;
3141         escape++;
3142         while (escape < start+l) {
3143             uc *= 16;
3144             uc += toHex(*escape);
3145             escape++;
3146         }
3147         // can't handle chars outside ucs2
3148         if (uc > 0xffff)
3149             uc = 0xfffd;
3150         *out++ = uc;
3151     }
3152     
3153     *length = out - start;
3154     return start;
3155 }
3156
3157 CSSSelector* CSSParser::createFloatingSelector()
3158 {
3159     CSSSelector* selector = new CSSSelector;
3160     m_floatingSelectors.add(selector);
3161     return selector;
3162 }
3163
3164 CSSSelector* CSSParser::sinkFloatingSelector(CSSSelector* selector)
3165 {
3166     if (selector) {
3167         ASSERT(m_floatingSelectors.contains(selector));
3168         m_floatingSelectors.remove(selector);
3169     }
3170     return selector;
3171 }
3172
3173 ValueList* CSSParser::createFloatingValueList()
3174 {
3175     ValueList* list = new ValueList;
3176     m_floatingValueLists.add(list);
3177     return list;
3178 }
3179
3180 ValueList* CSSParser::sinkFloatingValueList(ValueList* list)
3181 {
3182     if (list) {
3183         ASSERT(m_floatingValueLists.contains(list));
3184         m_floatingValueLists.remove(list);
3185     }
3186     return list;
3187 }
3188
3189 Function* CSSParser::createFloatingFunction()
3190 {
3191     Function* function = new Function;
3192     m_floatingFunctions.add(function);
3193     return function;
3194 }
3195
3196 Function* CSSParser::sinkFloatingFunction(Function* function)
3197 {
3198     if (function) {
3199         ASSERT(m_floatingFunctions.contains(function));
3200         m_floatingFunctions.remove(function);
3201     }
3202     return function;
3203 }
3204
3205 Value& CSSParser::sinkFloatingValue(Value& value)
3206 {
3207     if (value.unit == Value::Function) {
3208         ASSERT(m_floatingFunctions.contains(value.function));
3209         m_floatingFunctions.remove(value.function);
3210     }
3211     return value;
3212 }
3213
3214 MediaQueryExp* CSSParser::createFloatingMediaQueryExp(const AtomicString& mediaFeature, ValueList* values)
3215 {
3216     delete m_floatingMediaQueryExp;
3217     m_floatingMediaQueryExp = new MediaQueryExp(mediaFeature, values);
3218     return m_floatingMediaQueryExp;
3219 }
3220
3221 MediaQueryExp* CSSParser::sinkFloatingMediaQueryExp(MediaQueryExp* e)
3222 {
3223     ASSERT(e == m_floatingMediaQueryExp);
3224     m_floatingMediaQueryExp = 0;
3225     return e;
3226 }
3227
3228 Vector<MediaQueryExp*>* CSSParser::createFloatingMediaQueryExpList()
3229 {
3230     if (m_floatingMediaQueryExpList) {
3231         deleteAllValues(*m_floatingMediaQueryExpList);
3232         delete m_floatingMediaQueryExpList;
3233     }
3234     m_floatingMediaQueryExpList = new Vector<MediaQueryExp*>;
3235     return m_floatingMediaQueryExpList;
3236 }
3237
3238 Vector<MediaQueryExp*>* CSSParser::sinkFloatingMediaQueryExpList(Vector<MediaQueryExp*>* l)
3239 {
3240     ASSERT(l == m_floatingMediaQueryExpList);
3241     m_floatingMediaQueryExpList = 0;
3242     return l;
3243 }
3244
3245 MediaQuery* CSSParser::createFloatingMediaQuery(MediaQuery::Restrictor r, const String& mediaType, Vector<MediaQueryExp*>* exprs)
3246 {
3247     delete m_floatingMediaQuery;
3248     m_floatingMediaQuery = new MediaQuery(r, mediaType, exprs);
3249     return m_floatingMediaQuery;
3250 }
3251
3252 MediaQuery* CSSParser::sinkFloatingMediaQuery(MediaQuery* mq)
3253 {
3254     ASSERT(mq == m_floatingMediaQuery);
3255     m_floatingMediaQuery = 0;
3256     return mq;
3257 }
3258
3259 MediaList* CSSParser::createMediaList()
3260 {
3261     MediaList* list = new MediaList;
3262     m_parsedStyleObjects.append(list);
3263     return list;
3264 }
3265
3266 CSSRule* CSSParser::createCharsetRule(const ParseString& charset)
3267 {
3268     if (!styleElement)
3269         return 0;
3270     if (!styleElement->isCSSStyleSheet())
3271         return 0;
3272     CSSCharsetRule* rule = new CSSCharsetRule(styleElement, domString(charset));
3273     m_parsedStyleObjects.append(rule);
3274     return rule;
3275 }
3276
3277 CSSRule* CSSParser::createImportRule(const ParseString& URL, MediaList* media)
3278 {
3279     if (!media)
3280         return 0;
3281     if (!styleElement)
3282         return 0;
3283     if (!styleElement->isCSSStyleSheet())
3284         return 0;
3285     CSSImportRule* rule = new CSSImportRule(styleElement, domString(URL), media);
3286     m_parsedStyleObjects.append(rule);
3287     return rule;
3288 }
3289
3290 CSSRule* CSSParser::createMediaRule(MediaList* media, CSSRuleList* rules)
3291 {
3292     if (!media)
3293         return 0;
3294     if (!rules)
3295         return 0;
3296     if (!styleElement)
3297         return 0;
3298     if (!styleElement->isCSSStyleSheet())
3299         return 0;
3300     CSSMediaRule* rule = new CSSMediaRule(styleElement, media, rules);
3301     m_parsedStyleObjects.append(rule);
3302     return rule;
3303 }
3304
3305 CSSRuleList* CSSParser::createRuleList()
3306 {
3307     CSSRuleList* list = new CSSRuleList;
3308     m_parsedRuleLists.append(list);
3309     return list;
3310 }
3311
3312 CSSRule* CSSParser::createStyleRule(CSSSelector* selector)
3313 {
3314     CSSStyleRule* rule = 0;
3315     if (selector) {
3316         rule = new CSSStyleRule(styleElement);
3317         m_parsedStyleObjects.append(rule);
3318         rule->setSelector(sinkFloatingSelector(selector));
3319         rule->setDeclaration(new CSSMutableStyleDeclaration(rule, parsedProperties, numParsedProperties));
3320     }
3321     clearProperties();
3322     return rule;
3323 }
3324
3325 DeprecatedString deprecatedString(const ParseString& ps)
3326 {
3327     return DeprecatedString(reinterpret_cast<const DeprecatedChar*>(ps.characters), ps.length);
3328 }
3329
3330 #define YY_DECL int CSSParser::lex()
3331 #define yyconst const
3332 typedef int yy_state_type;
3333 typedef unsigned YY_CHAR;
3334 // this line makes sure we treat all Unicode chars correctly.
3335 #define YY_SC_TO_UI(c) (c > 0xff ? 0xff : c)
3336 #define YY_DO_BEFORE_ACTION \
3337         yytext = yy_bp; \
3338         yyleng = (int) (yy_cp - yy_bp); \
3339         yy_hold_char = *yy_cp; \
3340         *yy_cp = 0; \
3341         yy_c_buf_p = yy_cp;
3342 #define YY_BREAK break;
3343 #define ECHO
3344 #define YY_RULE_SETUP
3345 #define INITIAL 0
3346 #define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)
3347 #define yyterminate() yyTok = END_TOKEN; return yyTok
3348 #define YY_FATAL_ERROR(a)
3349 // The line below is needed to build the tokenizer with conditon stack.
3350 // The macro is used in the tokenizer grammar with lines containing
3351 // BEGIN(mediaqueries) and BEGIN(initial). yy_start acts as index to
3352 // tokenizer transition table, and 'mediaqueries' and 'initial' are
3353 // offset multipliers that specify which transitions are active
3354 // in the tokenizer during in each condition (tokenizer state)
3355 #define BEGIN yy_start = 1 + 2 *
3356
3357 #include "tokenizer.cpp"
3358
3359 }