2007-02-06 Mark Rowe <mrowe@apple.com>
[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., 59 Temple Place - Suite 330,
21  * Boston, MA 02111-1307, USA.
22  */
23
24 #include "config.h"
25 #include "cssparser.h"
26
27 #include "CSSBorderImageValue.h"
28 #include "CSSCursorImageValue.h"
29 #include "CSSImageValue.h"
30 #include "CSSCharsetRule.h"
31 #include "CSSImportRule.h"
32 #include "CSSInheritedValue.h"
33 #include "CSSInitialValue.h"
34 #include "CSSMediaRule.h"
35 #include "CSSMutableStyleDeclaration.h"
36 #include "CSSPrimitiveValue.h"
37 #include "CSSProperty.h"
38 #include "CSSPropertyNames.h"
39 #include "CSSRuleList.h"
40 #include "CSSSelector.h"
41 #include "CSSStyleRule.h"
42 #include "CSSStyleSheet.h"
43 #include "CSSQuirkPrimitiveValue.h"
44 #include "CSSValueKeywords.h"
45 #include "CSSValueList.h"
46 #include "Counter.h"
47 #include "DashboardRegion.h"
48 #include "Document.h"
49 #include "FontFamilyValue.h"
50 #include "FontValue.h"
51 #include "KURL.h"
52 #include "MediaList.h"
53 #include "Pair.h"
54 #include "ShadowValue.h"
55 #include "csshelper.h"
56 #include "MediaQueryExp.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(), 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 | khtml_left | khtml_right | khtml_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 #ifdef SVG_SUPPORT
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_WRAP:           // normal | break-word
909         if (id == CSS_VAL_NORMAL || id == CSS_VAL_BREAK_WORD)
910             valid_primitive = true;
911         break;
912
913     case CSS_PROP_TEXT_INDENT:          // <length> | <percentage> | inherit
914     case CSS_PROP_PADDING_TOP:          //// <padding-width> | inherit
915     case CSS_PROP_PADDING_RIGHT:        //   Which is defined as
916     case CSS_PROP_PADDING_BOTTOM:       //   <length> | <percentage>
917     case CSS_PROP_PADDING_LEFT:         ////
918     case CSS_PROP__WEBKIT_PADDING_START:
919         valid_primitive = (!id && validUnit(value, FLength|FPercent, strict));
920         break;
921
922     case CSS_PROP_MAX_HEIGHT:           // <length> | <percentage> | none | inherit
923     case CSS_PROP_MAX_WIDTH:            // <length> | <percentage> | none | inherit
924         if (id == CSS_VAL_NONE || id == CSS_VAL_INTRINSIC || id == CSS_VAL_MIN_INTRINSIC) {
925             valid_primitive = true;
926             break;
927         }
928         /* nobreak */
929     case CSS_PROP_MIN_HEIGHT:           // <length> | <percentage> | inherit
930     case CSS_PROP_MIN_WIDTH:            // <length> | <percentage> | inherit
931         if (id == CSS_VAL_INTRINSIC || id == CSS_VAL_MIN_INTRINSIC)
932             valid_primitive = true;
933         else
934             valid_primitive = (!id && validUnit(value, FLength|FPercent|FNonNeg, strict));
935         break;
936
937     case CSS_PROP_FONT_SIZE:
938         // <absolute-size> | <relative-size> | <length> | <percentage> | inherit
939         if (id >= CSS_VAL_XX_SMALL && id <= CSS_VAL_LARGER)
940             valid_primitive = true;
941         else
942             valid_primitive = (validUnit(value, FLength|FPercent, strict));
943         break;
944
945     case CSS_PROP_FONT_STYLE:           // normal | italic | oblique | inherit
946         if (id == CSS_VAL_NORMAL || id == CSS_VAL_ITALIC || id == CSS_VAL_OBLIQUE)
947             valid_primitive = true;
948         break;
949
950     case CSS_PROP_FONT_VARIANT:         // normal | small-caps | inherit
951         if (id == CSS_VAL_NORMAL || id == CSS_VAL_SMALL_CAPS)
952             valid_primitive = true;
953         break;
954
955     case CSS_PROP_VERTICAL_ALIGN:
956         // baseline | sub | super | top | text-top | middle | bottom | text-bottom |
957         // <percentage> | <length> | inherit
958
959         if (id >= CSS_VAL_BASELINE && id <= CSS_VAL__WEBKIT_BASELINE_MIDDLE)
960             valid_primitive = true;
961         else
962             valid_primitive = (!id && validUnit(value, FLength|FPercent, strict));
963         break;
964
965     case CSS_PROP_HEIGHT:               // <length> | <percentage> | auto | inherit
966     case CSS_PROP_WIDTH:                // <length> | <percentage> | auto | inherit
967         if (id == CSS_VAL_AUTO || id == CSS_VAL_INTRINSIC || id == CSS_VAL_MIN_INTRINSIC)
968             valid_primitive = true;
969         else
970             // ### handle multilength case where we allow relative units
971             valid_primitive = (!id && validUnit(value, FLength|FPercent|FNonNeg, strict));
972         break;
973
974     case CSS_PROP_BOTTOM:               // <length> | <percentage> | auto | inherit
975     case CSS_PROP_LEFT:                 // <length> | <percentage> | auto | inherit
976     case CSS_PROP_RIGHT:                // <length> | <percentage> | auto | inherit
977     case CSS_PROP_TOP:                  // <length> | <percentage> | auto | inherit
978     case CSS_PROP_MARGIN_TOP:           //// <margin-width> | inherit
979     case CSS_PROP_MARGIN_RIGHT:         //   Which is defined as
980     case CSS_PROP_MARGIN_BOTTOM:        //   <length> | <percentage> | auto | inherit
981     case CSS_PROP_MARGIN_LEFT:          ////
982     case CSS_PROP__WEBKIT_MARGIN_START:
983         if (id == CSS_VAL_AUTO)
984             valid_primitive = true;
985         else
986             valid_primitive = (!id && validUnit(value, FLength|FPercent, strict));
987         break;
988
989     case CSS_PROP_Z_INDEX:              // auto | <integer> | inherit
990         if (id == CSS_VAL_AUTO) {
991             valid_primitive = true;
992             break;
993         }
994         /* nobreak */
995     case CSS_PROP_ORPHANS:              // <integer> | inherit
996     case CSS_PROP_WIDOWS:               // <integer> | inherit
997         // ### not supported later on
998         valid_primitive = (!id && validUnit(value, FInteger, false));
999         break;
1000
1001     case CSS_PROP_LINE_HEIGHT:          // normal | <number> | <length> | <percentage> | inherit
1002         if (id == CSS_VAL_NORMAL)
1003             valid_primitive = true;
1004         else
1005             valid_primitive = (!id && validUnit(value, FNumber|FLength|FPercent, strict));
1006         break;
1007     case CSS_PROP_COUNTER_INCREMENT:    // [ <identifier> <integer>? ]+ | none | inherit
1008         if (id != CSS_VAL_NONE)
1009             return parseCounter(propId, 1, important);
1010         valid_primitive = true;
1011         break;
1012      case CSS_PROP_COUNTER_RESET:        // [ <identifier> <integer>? ]+ | none | inherit
1013         if (id != CSS_VAL_NONE)
1014             return parseCounter(propId, 0, important);
1015         valid_primitive = true;
1016         break;
1017     case CSS_PROP_FONT_FAMILY:
1018         // [[ <family-name> | <generic-family> ],]* [<family-name> | <generic-family>] | inherit
1019     {
1020         parsedValue = parseFontFamily();
1021         break;
1022     }
1023
1024     case CSS_PROP_TEXT_DECORATION:
1025     case CSS_PROP__WEBKIT_TEXT_DECORATIONS_IN_EFFECT:
1026         // none | [ underline || overline || line-through || blink ] | inherit
1027         if (id == CSS_VAL_NONE) {
1028             valid_primitive = true;
1029         } else {
1030             CSSValueList *list = new CSSValueList;
1031             bool is_valid = true;
1032             while(is_valid && value) {
1033                 switch (value->id) {
1034                 case CSS_VAL_BLINK:
1035                     break;
1036                 case CSS_VAL_UNDERLINE:
1037                 case CSS_VAL_OVERLINE:
1038                 case CSS_VAL_LINE_THROUGH:
1039                     list->append(new CSSPrimitiveValue(value->id));
1040                     break;
1041                 default:
1042                     is_valid = false;
1043                 }
1044                 value = valueList->next();
1045             }
1046             if(list->length() && is_valid) {
1047                 parsedValue = list;
1048                 valueList->next();
1049             } else
1050                 delete list;
1051         }
1052         break;
1053
1054     case CSS_PROP_TABLE_LAYOUT:         // auto | fixed | inherit
1055         if (id == CSS_VAL_AUTO || id == CSS_VAL_FIXED)
1056             valid_primitive = true;
1057         break;
1058
1059     /* CSS3 properties */
1060     case CSS_PROP__WEBKIT_APPEARANCE:
1061         if ((id >= CSS_VAL_CHECKBOX && id <= CSS_VAL_TEXTAREA) || id == CSS_VAL_NONE)
1062             valid_primitive = true;
1063         break;
1064
1065     case CSS_PROP__WEBKIT_BINDING:
1066 #ifdef XBL_SUPPORT
1067         if (id == CSS_VAL_NONE)
1068             valid_primitive = true;
1069         else {
1070             CSSValueList* values = new CSSValueList();
1071             Value* val;
1072             CSSValue* parsedValue = 0;
1073             while ((val = valueList->current())) {
1074                 if (val->unit == CSSPrimitiveValue::CSS_URI) {
1075                     String value = parseURL(domString(val->string));
1076                     parsedValue = new CSSPrimitiveValue(
1077                                     String(KURL(styleElement->baseURL().deprecatedString(), value.deprecatedString()).url()), 
1078                                     CSSPrimitiveValue::CSS_URI);
1079                 } 
1080                 
1081                 if (parsedValue)
1082                     values->append(parsedValue);
1083                 else
1084                     break;
1085                 valueList->next();
1086             }
1087             if (values->length()) {
1088                 addProperty(propId, values, important);
1089                 valueList->next();
1090                 return true;
1091             }
1092             delete values;
1093             return false;
1094         }
1095 #endif
1096         break;
1097     case CSS_PROP__WEBKIT_BORDER_IMAGE:
1098         if (id == CSS_VAL_NONE)
1099             valid_primitive = true;
1100         else
1101             return parseBorderImage(propId, important);
1102         break;
1103     case CSS_PROP__WEBKIT_BORDER_TOP_RIGHT_RADIUS:
1104     case CSS_PROP__WEBKIT_BORDER_TOP_LEFT_RADIUS:
1105     case CSS_PROP__WEBKIT_BORDER_BOTTOM_LEFT_RADIUS:
1106     case CSS_PROP__WEBKIT_BORDER_BOTTOM_RIGHT_RADIUS:
1107     case CSS_PROP__WEBKIT_BORDER_RADIUS: {
1108         if (num != 1 && num != 2)
1109             return false;
1110         valid_primitive = validUnit(value, FLength, strict);
1111         if (!valid_primitive)
1112             return false;
1113         CSSPrimitiveValue* parsedValue1 = new CSSPrimitiveValue(value->fValue,
1114                                                                         (CSSPrimitiveValue::UnitTypes)value->unit);
1115         CSSPrimitiveValue* parsedValue2 = parsedValue1;
1116         if (num == 2) {
1117             value = valueList->next();
1118             valid_primitive = validUnit(value, FLength, strict);
1119             if (!valid_primitive) {
1120                 delete parsedValue1;
1121                 return false;
1122             }
1123             parsedValue2 = new CSSPrimitiveValue(value->fValue, (CSSPrimitiveValue::UnitTypes)value->unit);
1124         }
1125         
1126         Pair* pair = new Pair(parsedValue1, parsedValue2);
1127         CSSPrimitiveValue* val = new CSSPrimitiveValue(pair);
1128         if (propId == CSS_PROP__WEBKIT_BORDER_RADIUS) {
1129             const int properties[4] = { CSS_PROP__WEBKIT_BORDER_TOP_RIGHT_RADIUS,
1130                                         CSS_PROP__WEBKIT_BORDER_TOP_LEFT_RADIUS,
1131                                         CSS_PROP__WEBKIT_BORDER_BOTTOM_LEFT_RADIUS,
1132                                         CSS_PROP__WEBKIT_BORDER_BOTTOM_RIGHT_RADIUS };
1133             for (int i = 0; i < 4; i++)
1134                 addProperty(properties[i], val, important);
1135         } else
1136             addProperty(propId, val, important);
1137         return true;
1138     }
1139     case CSS_PROP_OUTLINE_OFFSET:
1140         valid_primitive = validUnit(value, FLength, strict);
1141         break;
1142     case CSS_PROP_TEXT_SHADOW: // CSS2 property, dropped in CSS2.1, back in CSS3, so treat as CSS3
1143     case CSS_PROP__WEBKIT_BOX_SHADOW:
1144         if (id == CSS_VAL_NONE)
1145             valid_primitive = true;
1146         else
1147             return parseShadow(propId, important);
1148         break;
1149     case CSS_PROP_OPACITY:
1150         valid_primitive = validUnit(value, FNumber, strict);
1151         break;
1152     case CSS_PROP__WEBKIT_BOX_ALIGN:
1153         if (id == CSS_VAL_STRETCH || id == CSS_VAL_START || id == CSS_VAL_END ||
1154             id == CSS_VAL_CENTER || id == CSS_VAL_BASELINE)
1155             valid_primitive = true;
1156         break;
1157     case CSS_PROP__WEBKIT_BOX_DIRECTION:
1158         if (id == CSS_VAL_NORMAL || id == CSS_VAL_REVERSE)
1159             valid_primitive = true;
1160         break;
1161     case CSS_PROP__WEBKIT_BOX_LINES:
1162         if (id == CSS_VAL_SINGLE || id == CSS_VAL_MULTIPLE)
1163             valid_primitive = true;
1164         break;
1165     case CSS_PROP__WEBKIT_BOX_ORIENT:
1166         if (id == CSS_VAL_HORIZONTAL || id == CSS_VAL_VERTICAL ||
1167             id == CSS_VAL_INLINE_AXIS || id == CSS_VAL_BLOCK_AXIS)
1168             valid_primitive = true;
1169         break;
1170     case CSS_PROP__WEBKIT_BOX_PACK:
1171         if (id == CSS_VAL_START || id == CSS_VAL_END ||
1172             id == CSS_VAL_CENTER || id == CSS_VAL_JUSTIFY)
1173             valid_primitive = true;
1174         break;
1175     case CSS_PROP__WEBKIT_BOX_FLEX:
1176         valid_primitive = validUnit(value, FNumber, strict);
1177         break;
1178     case CSS_PROP__WEBKIT_BOX_FLEX_GROUP:
1179     case CSS_PROP__WEBKIT_BOX_ORDINAL_GROUP:
1180         valid_primitive = validUnit(value, FInteger|FNonNeg, true);
1181         break;
1182     case CSS_PROP_BOX_SIZING: {
1183         // We don't preface this with -webkit, since MacIE defined this property without the prefix.
1184         // Thus the damage has been done, and it's known that this property's definition isn't going
1185         // to fluctuate.
1186         if (id == CSS_VAL_BORDER_BOX || id == CSS_VAL_CONTENT_BOX)
1187             valid_primitive = true;
1188         break;
1189     }
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 || 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 || id == CSS_VAL_IGNORE)
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_TEXT_SECURITY:
1350         // disc | circle | square | none | inherit
1351         if (id == CSS_VAL_DISC || id == CSS_VAL_CIRCLE || id == CSS_VAL_SQUARE|| id == CSS_VAL_NONE)
1352             valid_primitive = true;
1353         break;
1354
1355 #if PLATFORM(MAC)
1356     case CSS_PROP__WEBKIT_DASHBOARD_REGION:                 // <dashboard-region> | <dashboard-region> 
1357         if (value->unit == Value::Function || id == CSS_VAL_NONE)
1358             return parseDashboardRegions(propId, important);
1359         break;
1360 #endif
1361     // End Apple-specific properties
1362
1363         /* shorthand properties */
1364     case CSS_PROP_BACKGROUND:
1365         // ['background-color' || 'background-image' || 'background-size' || 'background-repeat' ||
1366         // 'background-attachment' || 'background-position'] | inherit
1367         return parseBackgroundShorthand(important);
1368     case CSS_PROP_BORDER:
1369         // [ 'border-width' || 'border-style' || <color> ] | inherit
1370     {
1371         const int properties[3] = { CSS_PROP_BORDER_WIDTH, CSS_PROP_BORDER_STYLE,
1372                                     CSS_PROP_BORDER_COLOR };
1373         return parseShorthand(propId, properties, 3, important);
1374     }
1375     case CSS_PROP_BORDER_TOP:
1376         // [ 'border-top-width' || 'border-style' || <color> ] | inherit
1377     {
1378         const int properties[3] = { CSS_PROP_BORDER_TOP_WIDTH, CSS_PROP_BORDER_TOP_STYLE,
1379                                     CSS_PROP_BORDER_TOP_COLOR};
1380         return parseShorthand(propId, properties, 3, important);
1381     }
1382     case CSS_PROP_BORDER_RIGHT:
1383         // [ 'border-right-width' || 'border-style' || <color> ] | inherit
1384     {
1385         const int properties[3] = { CSS_PROP_BORDER_RIGHT_WIDTH, CSS_PROP_BORDER_RIGHT_STYLE,
1386                                     CSS_PROP_BORDER_RIGHT_COLOR };
1387         return parseShorthand(propId, properties, 3, important);
1388     }
1389     case CSS_PROP_BORDER_BOTTOM:
1390         // [ 'border-bottom-width' || 'border-style' || <color> ] | inherit
1391     {
1392         const int properties[3] = { CSS_PROP_BORDER_BOTTOM_WIDTH, CSS_PROP_BORDER_BOTTOM_STYLE,
1393                                     CSS_PROP_BORDER_BOTTOM_COLOR };
1394         return parseShorthand(propId, properties, 3, important);
1395     }
1396     case CSS_PROP_BORDER_LEFT:
1397         // [ 'border-left-width' || 'border-style' || <color> ] | inherit
1398     {
1399         const int properties[3] = { CSS_PROP_BORDER_LEFT_WIDTH, CSS_PROP_BORDER_LEFT_STYLE,
1400                                     CSS_PROP_BORDER_LEFT_COLOR };
1401         return parseShorthand(propId, properties, 3, important);
1402     }
1403     case CSS_PROP_OUTLINE:
1404         // [ 'outline-color' || 'outline-style' || 'outline-width' ] | inherit
1405     {
1406         const int properties[3] = { CSS_PROP_OUTLINE_WIDTH, CSS_PROP_OUTLINE_STYLE,
1407                                     CSS_PROP_OUTLINE_COLOR };
1408         return parseShorthand(propId, properties, 3, important);
1409     }
1410     case CSS_PROP_BORDER_COLOR:
1411         // <color>{1,4} | inherit
1412     {
1413         const int properties[4] = { CSS_PROP_BORDER_TOP_COLOR, CSS_PROP_BORDER_RIGHT_COLOR,
1414                                     CSS_PROP_BORDER_BOTTOM_COLOR, CSS_PROP_BORDER_LEFT_COLOR };
1415         return parse4Values(propId, properties, important);
1416     }
1417     case CSS_PROP_BORDER_WIDTH:
1418         // <border-width>{1,4} | inherit
1419     {
1420         const int properties[4] = { CSS_PROP_BORDER_TOP_WIDTH, CSS_PROP_BORDER_RIGHT_WIDTH,
1421                                     CSS_PROP_BORDER_BOTTOM_WIDTH, CSS_PROP_BORDER_LEFT_WIDTH };
1422         return parse4Values(propId, properties, important);
1423     }
1424     case CSS_PROP_BORDER_STYLE:
1425         // <border-style>{1,4} | inherit
1426     {
1427         const int properties[4] = { CSS_PROP_BORDER_TOP_STYLE, CSS_PROP_BORDER_RIGHT_STYLE,
1428                                     CSS_PROP_BORDER_BOTTOM_STYLE, CSS_PROP_BORDER_LEFT_STYLE };
1429         return parse4Values(propId, properties, important);
1430     }
1431     case CSS_PROP_MARGIN:
1432         // <margin-width>{1,4} | inherit
1433     {
1434         const int properties[4] = { CSS_PROP_MARGIN_TOP, CSS_PROP_MARGIN_RIGHT,
1435                                     CSS_PROP_MARGIN_BOTTOM, CSS_PROP_MARGIN_LEFT };
1436         return parse4Values(propId, properties, important);
1437     }
1438     case CSS_PROP_PADDING:
1439         // <padding-width>{1,4} | inherit
1440     {
1441         const int properties[4] = { CSS_PROP_PADDING_TOP, CSS_PROP_PADDING_RIGHT,
1442                                     CSS_PROP_PADDING_BOTTOM, CSS_PROP_PADDING_LEFT };
1443         return parse4Values(propId, properties, important);
1444     }
1445     case CSS_PROP_FONT:
1446         // [ [ 'font-style' || 'font-variant' || 'font-weight' ]? 'font-size' [ / 'line-height' ]?
1447         // 'font-family' ] | caption | icon | menu | message-box | small-caption | status-bar | inherit
1448         if (id >= CSS_VAL_CAPTION && id <= CSS_VAL_STATUS_BAR)
1449             valid_primitive = true;
1450         else
1451             return parseFont(important);
1452         break;
1453     case CSS_PROP_LIST_STYLE:
1454     {
1455         const int properties[3] = { CSS_PROP_LIST_STYLE_TYPE, CSS_PROP_LIST_STYLE_POSITION,
1456                                     CSS_PROP_LIST_STYLE_IMAGE };
1457         return parseShorthand(propId, properties, 3, important);
1458     }
1459     case CSS_PROP__WEBKIT_COLUMNS: {
1460         const int properties[2] = { CSS_PROP__WEBKIT_COLUMN_WIDTH, CSS_PROP__WEBKIT_COLUMN_COUNT };
1461         return parseShorthand(propId, properties, 2, important);
1462     }
1463     case CSS_PROP__WEBKIT_COLUMN_RULE: {
1464         const int properties[3] = { CSS_PROP__WEBKIT_COLUMN_RULE_WIDTH, CSS_PROP__WEBKIT_COLUMN_RULE_STYLE,
1465                                     CSS_PROP__WEBKIT_COLUMN_RULE_COLOR };
1466         return parseShorthand(propId, properties, 3, important);
1467     }
1468     case CSS_PROP__WEBKIT_TEXT_STROKE: {
1469         const int properties[2] = { CSS_PROP__WEBKIT_TEXT_STROKE_WIDTH, CSS_PROP__WEBKIT_TEXT_STROKE_COLOR };
1470         return parseShorthand(propId, properties, 2, important);
1471     }
1472     case CSS_PROP_INVALID:
1473         return false;
1474     case CSS_PROP_FONT_STRETCH:
1475     case CSS_PROP_PAGE:
1476     case CSS_PROP_TEXT_LINE_THROUGH:
1477     case CSS_PROP_TEXT_OVERLINE:
1478     case CSS_PROP_TEXT_UNDERLINE:
1479         return false;
1480     }
1481
1482     if (valid_primitive) {
1483         if (id != 0)
1484             parsedValue = new CSSPrimitiveValue(id);
1485         else if (value->unit == CSSPrimitiveValue::CSS_STRING)
1486             parsedValue = new CSSPrimitiveValue(domString(value->string), (CSSPrimitiveValue::UnitTypes) value->unit);
1487         else if (value->unit >= CSSPrimitiveValue::CSS_NUMBER && value->unit <= CSSPrimitiveValue::CSS_KHZ)
1488             parsedValue = new CSSPrimitiveValue(value->fValue, (CSSPrimitiveValue::UnitTypes) value->unit);
1489         else if (value->unit >= Value::Q_EMS)
1490             parsedValue = new CSSQuirkPrimitiveValue(value->fValue, CSSPrimitiveValue::CSS_EMS);
1491         valueList->next();
1492     }
1493     if (parsedValue) {
1494         if (!valueList->current() || inShorthand()) {
1495             addProperty(propId, parsedValue, important);
1496             return true;
1497         }
1498         delete parsedValue;
1499     }
1500 #ifdef SVG_SUPPORT
1501     if (parseSVGValue(propId, important))
1502         return true;
1503 #endif
1504     return false;
1505 }
1506
1507 void CSSParser::addBackgroundValue(CSSValue*& lval, CSSValue* rval)
1508 {
1509     if (lval) {
1510         if (lval->isValueList())
1511             static_cast<CSSValueList*>(lval)->append(rval);
1512         else {
1513             CSSValue* oldVal = lval;
1514             CSSValueList* list = new CSSValueList();
1515             lval = list;
1516             list->append(oldVal);
1517             list->append(rval);
1518         }
1519     }
1520     else
1521         lval = rval;
1522 }
1523
1524 bool CSSParser::parseBackgroundShorthand(bool important)
1525 {
1526     // Position must come before color in this array because a plain old "0" is a legal color
1527     // in quirks mode but it's usually the X coordinate of a position.
1528     // FIXME: Add CSS_PROP__KHTML_BACKGROUND_SIZE to the shorthand.
1529     const int properties[] = { CSS_PROP_BACKGROUND_IMAGE, CSS_PROP_BACKGROUND_REPEAT, 
1530         CSS_PROP_BACKGROUND_ATTACHMENT, CSS_PROP_BACKGROUND_POSITION, CSS_PROP__WEBKIT_BACKGROUND_CLIP,
1531         CSS_PROP__WEBKIT_BACKGROUND_ORIGIN, CSS_PROP_BACKGROUND_COLOR };
1532     const int numProperties = sizeof(properties) / sizeof(properties[0]);
1533     
1534     ShorthandScope scope(this, CSS_PROP_BACKGROUND);
1535
1536     bool parsedProperty[numProperties] = { false }; // compiler will repeat false as necessary
1537     CSSValue* values[numProperties] = { 0 }; // compiler will repeat 0 as necessary
1538     CSSValue* positionYValue = 0;
1539     int i;
1540
1541     while (valueList->current()) {
1542         Value* val = valueList->current();
1543         if (val->unit == Value::Operator && val->iValue == ',') {
1544             // We hit the end.  Fill in all remaining values with the initial value.
1545             valueList->next();
1546             for (i = 0; i < numProperties; ++i) {
1547                 if (properties[i] == CSS_PROP_BACKGROUND_COLOR && parsedProperty[i])
1548                     // Color is not allowed except as the last item in a list.  Reject the entire
1549                     // property.
1550                     goto fail;
1551
1552                 if (!parsedProperty[i] && properties[i] != CSS_PROP_BACKGROUND_COLOR) {
1553                     addBackgroundValue(values[i], new CSSInitialValue());
1554                     if (properties[i] == CSS_PROP_BACKGROUND_POSITION)
1555                         addBackgroundValue(positionYValue, new CSSInitialValue());
1556                 }
1557                 parsedProperty[i] = false;
1558             }
1559             if (!valueList->current())
1560                 break;
1561         }
1562         
1563         bool found = false;
1564         for (i = 0; !found && i < numProperties; ++i) {
1565             if (!parsedProperty[i]) {
1566                 CSSValue *val1 = 0, *val2 = 0;
1567                 int propId1, propId2;
1568                 if (parseBackgroundProperty(properties[i], propId1, propId2, val1, val2)) {
1569                     parsedProperty[i] = found = true;
1570                     addBackgroundValue(values[i], val1);
1571                     if (properties[i] == CSS_PROP_BACKGROUND_POSITION)
1572                         addBackgroundValue(positionYValue, val2);
1573                 }
1574             }
1575         }
1576
1577         // if we didn't find at least one match, this is an
1578         // invalid shorthand and we have to ignore it
1579         if (!found)
1580             goto fail;
1581     }
1582     
1583     // Fill in any remaining properties with the initial value.
1584     for (i = 0; i < numProperties; ++i) {
1585         if (!parsedProperty[i]) {
1586             addBackgroundValue(values[i], new CSSInitialValue());
1587             if (properties[i] == CSS_PROP_BACKGROUND_POSITION)
1588                 addBackgroundValue(positionYValue, new CSSInitialValue());
1589         }
1590     }
1591     
1592     // Now add all of the properties we found.
1593     for (i = 0; i < numProperties; i++) {
1594         if (properties[i] == CSS_PROP_BACKGROUND_POSITION) {
1595             addProperty(CSS_PROP_BACKGROUND_POSITION_X, values[i], important);
1596             addProperty(CSS_PROP_BACKGROUND_POSITION_Y, positionYValue, important);
1597         }
1598         else
1599             addProperty(properties[i], values[i], important);
1600     }
1601     
1602     return true;
1603
1604 fail:
1605     for (int k = 0; k < numProperties; k++)
1606         delete values[k];
1607     delete positionYValue;
1608     return false;
1609 }
1610
1611 bool CSSParser::parseShorthand(int propId, const int *properties, int numProperties, bool important)
1612 {
1613     // We try to match as many properties as possible
1614     // We set up an array of booleans to mark which property has been found,
1615     // and we try to search for properties until it makes no longer any sense.
1616     ShorthandScope scope(this, propId);
1617
1618     bool found = false;
1619     bool fnd[6]; // Trust me ;)
1620     for (int i = 0; i < numProperties; i++)
1621         fnd[i] = false;
1622
1623     while (valueList->current()) {
1624         found = false;
1625         for (int propIndex = 0; !found && propIndex < numProperties; ++propIndex) {
1626             if (!fnd[propIndex]) {
1627                 if (parseValue(properties[propIndex], important))
1628                     fnd[propIndex] = found = true;
1629             }
1630         }
1631
1632         // if we didn't find at least one match, this is an
1633         // invalid shorthand and we have to ignore it
1634         if (!found)
1635             return false;
1636     }
1637     
1638     // Fill in any remaining properties with the initial value.
1639     m_implicitShorthand = true;
1640     for (int i = 0; i < numProperties; ++i) {
1641         if (!fnd[i])
1642             addProperty(properties[i], new CSSInitialValue(), important);
1643     }
1644     m_implicitShorthand = false;
1645
1646     return true;
1647 }
1648
1649 bool CSSParser::parse4Values(int propId, const int *properties,  bool important)
1650 {
1651     /* From the CSS 2 specs, 8.3
1652      * If there is only one value, it applies to all sides. If there are two values, the top and
1653      * bottom margins are set to the first value and the right and left margins are set to the second.
1654      * If there are three values, the top is set to the first value, the left and right are set to the
1655      * second, and the bottom is set to the third. If there are four values, they apply to the top,
1656      * right, bottom, and left, respectively.
1657      */
1658     
1659     int num = inShorthand() ? 1 : valueList->size();
1660     
1661     ShorthandScope scope(this, propId);
1662
1663     // the order is top, right, bottom, left
1664     switch (num) {
1665         case 1: {
1666             if (!parseValue(properties[0], important))
1667                 return false;
1668             CSSValue *value = parsedProperties[numParsedProperties-1]->value();
1669             m_implicitShorthand = true;
1670             addProperty(properties[1], value, important);
1671             addProperty(properties[2], value, important);
1672             addProperty(properties[3], value, important);
1673             m_implicitShorthand = false;
1674             break;
1675         }
1676         case 2: {
1677             if (!parseValue(properties[0], important) || !parseValue(properties[1], important))
1678                 return false;
1679             CSSValue *value = parsedProperties[numParsedProperties-2]->value();
1680             m_implicitShorthand = true;
1681             addProperty(properties[2], value, important);
1682             value = parsedProperties[numParsedProperties-2]->value();
1683             addProperty(properties[3], value, important);
1684             m_implicitShorthand = false;
1685             break;
1686         }
1687         case 3: {
1688             if (!parseValue(properties[0], important) || !parseValue(properties[1], important) || !parseValue(properties[2], important))
1689                 return false;
1690             CSSValue *value = parsedProperties[numParsedProperties-2]->value();
1691             m_implicitShorthand = true;
1692             addProperty(properties[3], value, important);
1693             m_implicitShorthand = false;
1694             break;
1695         }
1696         case 4: {
1697             if (!parseValue(properties[0], important) || !parseValue(properties[1], important) ||
1698                 !parseValue(properties[2], important) || !parseValue(properties[3], important))
1699                 return false;
1700             break;
1701         }
1702         default: {
1703             return false;
1704         }
1705     }
1706     
1707     return true;
1708 }
1709
1710 // [ <string> | <uri> | <counter> | attr(X) | open-quote | close-quote | no-open-quote | no-close-quote ]+ | inherit
1711 // in CSS 2.1 this got somewhat reduced:
1712 // [ <string> | attr(X) | open-quote | close-quote | no-open-quote | no-close-quote ]+ | inherit
1713 bool CSSParser::parseContent(int propId, bool important)
1714 {
1715     RefPtr<CSSValueList> values = new CSSValueList;
1716
1717     while (Value* val = valueList->current()) {
1718         RefPtr<CSSValue> parsedValue;
1719         if (val->unit == CSSPrimitiveValue::CSS_URI) {
1720             // url
1721             String value = parseURL(domString(val->string));
1722             parsedValue = new CSSImageValue(
1723                 String(KURL(styleElement->baseURL().deprecatedString(), value.deprecatedString()).url()), styleElement);
1724         } else if (val->unit == Value::Function) {
1725             // attr(X) | counter(X [,Y]) | counters(X, Y, [,Z])
1726             ValueList *args = val->function->args;
1727             String fname = domString(val->function->name).lower();
1728             if (!args)
1729                 return false;
1730             if (fname == "attr(") {
1731                 if (args->size() != 1)
1732                     return false;
1733                 Value* a = args->current();
1734                 String attrName = domString(a->string);
1735                 if (document()->isHTMLDocument())
1736                     attrName = attrName.lower();
1737                 parsedValue = new CSSPrimitiveValue(attrName, CSSPrimitiveValue::CSS_ATTR);
1738             } else if (fname == "counter(") {
1739                 parsedValue = parseCounterContent(args, false);
1740                 if (!parsedValue) return false;
1741             } else if (fname == "counters(") {
1742                 parsedValue = parseCounterContent(args, true);
1743                 if (!parsedValue)
1744                     return false;
1745             } else
1746                 return false;
1747         } else if (val->unit == CSSPrimitiveValue::CSS_IDENT) {
1748             // open-quote
1749             // close-quote
1750             // no-open-quote
1751             // no-close-quote
1752             // FIXME: These are not yet implemented (http://bugs.webkit.org/show_bug.cgi?id=6503).
1753         } else if (val->unit == CSSPrimitiveValue::CSS_STRING) {
1754             parsedValue = new CSSPrimitiveValue(domString(val->string), CSSPrimitiveValue::CSS_STRING);
1755         }
1756         if (!parsedValue)
1757             break;
1758         values->append(parsedValue.release());
1759         valueList->next();
1760     }
1761
1762     if (values->length()) {
1763         addProperty(propId, values.release(), important);
1764         valueList->next();
1765         return true;
1766     }
1767
1768     return false;
1769 }
1770
1771 CSSValue* CSSParser::parseBackgroundColor()
1772 {
1773     int id = valueList->current()->id;
1774     if (id == CSS_VAL__WEBKIT_TEXT || (id >= CSS_VAL_AQUA && id <= CSS_VAL_WINDOWTEXT) || id == CSS_VAL_MENU ||
1775         (id >= CSS_VAL_GREY && id < CSS_VAL__WEBKIT_TEXT && !strict))
1776        return new CSSPrimitiveValue(id);
1777     return parseColor();
1778 }
1779
1780 CSSValue* CSSParser::parseBackgroundImage()
1781 {
1782     if (valueList->current()->id == CSS_VAL_NONE)
1783         return new CSSImageValue();
1784     if (valueList->current()->unit == CSSPrimitiveValue::CSS_URI) {
1785         String uri = parseURL(domString(valueList->current()->string));
1786         if (!uri.isEmpty())
1787             return new CSSImageValue(String(KURL(styleElement->baseURL().deprecatedString(), uri.deprecatedString()).url()), 
1788                                          styleElement);
1789     }
1790     return 0;
1791 }
1792
1793 CSSValue* CSSParser::parseBackgroundPositionXY(bool& xFound, bool& yFound)
1794 {
1795     int id = valueList->current()->id;
1796     if (id == CSS_VAL_LEFT || id == CSS_VAL_TOP || id == CSS_VAL_RIGHT || id == CSS_VAL_BOTTOM || id == CSS_VAL_CENTER) {
1797         int percent = 0;
1798         if (id == CSS_VAL_LEFT || id == CSS_VAL_RIGHT) {
1799             if (xFound)
1800                 return 0;
1801             xFound = true;
1802             if (id == CSS_VAL_RIGHT)
1803                 percent = 100;
1804         }
1805         else if (id == CSS_VAL_TOP || id == CSS_VAL_BOTTOM) {
1806             if (yFound)
1807                 return 0;
1808             yFound = true;
1809             if (id == CSS_VAL_BOTTOM)
1810                 percent = 100;
1811         }
1812         else if (id == CSS_VAL_CENTER)
1813             // Center is ambiguous, so we're not sure which position we've found yet, an x or a y.
1814             percent = 50;
1815         return new CSSPrimitiveValue(percent, CSSPrimitiveValue::CSS_PERCENTAGE);
1816     }
1817     if (validUnit(valueList->current(), FPercent|FLength, strict))
1818         return new CSSPrimitiveValue(valueList->current()->fValue,
1819                                          (CSSPrimitiveValue::UnitTypes)valueList->current()->unit);
1820                 
1821     return 0;
1822 }
1823
1824 void CSSParser::parseBackgroundPosition(CSSValue*& value1, CSSValue*& value2)
1825 {
1826     value1 = value2 = 0;
1827     Value* value = valueList->current();
1828     
1829     // Parse the first value.  We're just making sure that it is one of the valid keywords or a percentage/length.
1830     bool value1IsX = false, value1IsY = false;
1831     value1 = parseBackgroundPositionXY(value1IsX, value1IsY);
1832     if (!value1)
1833         return;
1834     
1835     // It only takes one value for background-position to be correctly parsed if it was specified in a shorthand (since we
1836     // can assume that any other values belong to the rest of the shorthand).  If we're not parsing a shorthand, though, the
1837     // value was explicitly specified for our property.
1838     value = valueList->next();
1839     
1840     // First check for the comma.  If so, we are finished parsing this value or value pair.
1841     if (value && value->unit == Value::Operator && value->iValue == ',')
1842         value = 0;
1843     
1844     bool value2IsX = false, value2IsY = false;
1845     if (value) {
1846         value2 = parseBackgroundPositionXY(value2IsX, value2IsY);
1847         if (value2)
1848             valueList->next();
1849         else {
1850             if (!inShorthand()) {
1851                 delete value1;
1852                 value1 = 0;
1853                 return;
1854             }
1855         }
1856     }
1857     
1858     if (!value2)
1859         // Only one value was specified.  If that value was not a keyword, then it sets the x position, and the y position
1860         // is simply 50%.  This is our default.
1861         // For keywords, the keyword was either an x-keyword (left/right), a y-keyword (top/bottom), or an ambiguous keyword (center).
1862         // For left/right/center, the default of 50% in the y is still correct.
1863         value2 = new CSSPrimitiveValue(50, CSSPrimitiveValue::CSS_PERCENTAGE);
1864
1865     if (value1IsY || value2IsX) {
1866         // Swap our two values.
1867         CSSValue* val = value2;
1868         value2 = value1;
1869         value1 = val;
1870     }
1871 }
1872
1873 CSSValue* CSSParser::parseBackgroundSize()
1874 {
1875     Value* value = valueList->current();
1876     CSSPrimitiveValue* parsedValue1;
1877     
1878     if (value->id == CSS_VAL_AUTO)
1879         parsedValue1 = new CSSPrimitiveValue(0, CSSPrimitiveValue::CSS_UNKNOWN);
1880     else {
1881         if (!validUnit(value, FLength|FPercent, strict))
1882             return 0;
1883         parsedValue1 = new CSSPrimitiveValue(value->fValue, (CSSPrimitiveValue::UnitTypes)value->unit);
1884     }
1885     
1886     CSSPrimitiveValue* parsedValue2 = parsedValue1;
1887     if ((value = valueList->next())) {
1888         if (value->id == CSS_VAL_AUTO)
1889             parsedValue2 = new CSSPrimitiveValue(0, CSSPrimitiveValue::CSS_UNKNOWN);
1890         else {
1891             if (!validUnit(value, FLength|FPercent, strict)) {
1892                 delete parsedValue1;
1893                 return 0;
1894             }
1895             parsedValue2 = new CSSPrimitiveValue(value->fValue, (CSSPrimitiveValue::UnitTypes)value->unit);
1896         }
1897     }
1898     
1899     Pair* pair = new Pair(parsedValue1, parsedValue2);
1900     return new CSSPrimitiveValue(pair);
1901 }
1902
1903 bool CSSParser::parseBackgroundProperty(int propId, int& propId1, int& propId2, 
1904                                         CSSValue*& retValue1, CSSValue*& retValue2)
1905 {
1906     CSSValueList *values = 0, *values2 = 0;
1907     Value* val;
1908     CSSValue *value = 0, *value2 = 0;
1909     bool allowComma = false;
1910     
1911     retValue1 = retValue2 = 0;
1912     propId1 = propId;
1913     propId2 = propId;
1914     if (propId == CSS_PROP_BACKGROUND_POSITION) {
1915         propId1 = CSS_PROP_BACKGROUND_POSITION_X;
1916         propId2 = CSS_PROP_BACKGROUND_POSITION_Y;
1917     }
1918
1919     while ((val = valueList->current())) {
1920         CSSValue *currValue = 0, *currValue2 = 0;
1921         if (allowComma) {
1922             if (val->unit != Value::Operator || val->iValue != ',')
1923                 goto failed;
1924             valueList->next();
1925             allowComma = false;
1926         }
1927         else {
1928             switch (propId) {
1929                 case CSS_PROP_BACKGROUND_ATTACHMENT:
1930                     if (val->id == CSS_VAL_SCROLL || val->id == CSS_VAL_FIXED) {
1931                         currValue = new CSSPrimitiveValue(val->id);
1932                         valueList->next();
1933                     }
1934                     break;
1935                 case CSS_PROP_BACKGROUND_COLOR:
1936                     currValue = parseBackgroundColor();
1937                     if (currValue)
1938                         valueList->next();
1939                     break;
1940                 case CSS_PROP_BACKGROUND_IMAGE:
1941                     currValue = parseBackgroundImage();
1942                     if (currValue)
1943                         valueList->next();
1944                     break;
1945                 case CSS_PROP__WEBKIT_BACKGROUND_CLIP:
1946                 case CSS_PROP__WEBKIT_BACKGROUND_ORIGIN:
1947                     if (val->id == CSS_VAL_BORDER || val->id == CSS_VAL_PADDING || val->id == CSS_VAL_CONTENT) {
1948                         currValue = new CSSPrimitiveValue(val->id);
1949                         valueList->next();
1950                     }
1951                     break;
1952                 case CSS_PROP_BACKGROUND_POSITION:
1953                     parseBackgroundPosition(currValue, currValue2);
1954                     // unlike the other functions, parseBackgroundPosition advances the valueList pointer
1955                     break;
1956                 case CSS_PROP_BACKGROUND_POSITION_X: {
1957                     bool xFound = false, yFound = true;
1958                     currValue = parseBackgroundPositionXY(xFound, yFound);
1959                     if (currValue)
1960                         valueList->next();
1961                     break;
1962                 }
1963                 case CSS_PROP_BACKGROUND_POSITION_Y: {
1964                     bool xFound = true, yFound = false;
1965                     currValue = parseBackgroundPositionXY(xFound, yFound);
1966                     if (currValue)
1967                         valueList->next();
1968                     break;
1969                 }
1970                 case CSS_PROP__WEBKIT_BACKGROUND_COMPOSITE:
1971                     if ((val->id >= CSS_VAL_CLEAR && val->id <= CSS_VAL_PLUS_LIGHTER) || val->id == CSS_VAL_HIGHLIGHT) {
1972                         currValue = new CSSPrimitiveValue(val->id);
1973                         valueList->next();
1974                     }
1975                     break;
1976                 case CSS_PROP_BACKGROUND_REPEAT:
1977                     if (val->id >= CSS_VAL_REPEAT && val->id <= CSS_VAL_NO_REPEAT) {
1978                         currValue = new CSSPrimitiveValue(val->id);
1979                         valueList->next();
1980                     }
1981                     break;
1982                 case CSS_PROP__WEBKIT_BACKGROUND_SIZE:
1983                     currValue = parseBackgroundSize();
1984                     if (currValue)
1985                         valueList->next();
1986                     break;
1987             }
1988             
1989             if (!currValue)
1990                 goto failed;
1991             
1992             if (value && !values) {
1993                 values = new CSSValueList();
1994                 values->append(value);
1995                 value = 0;
1996             }
1997             
1998             if (value2 && !values2) {
1999                 values2 = new CSSValueList();
2000                 values2->append(value2);
2001                 value2 = 0;
2002             }
2003             
2004             if (values)
2005                 values->append(currValue);
2006             else
2007                 value = currValue;
2008             if (currValue2) {
2009                 if (values2)
2010                     values2->append(currValue2);
2011                 else
2012                     value2 = currValue2;
2013             }
2014             allowComma = true;
2015         }
2016         
2017         // When parsing the 'background' shorthand property, we let it handle building up the lists for all
2018         // properties.
2019         if (inShorthand())
2020             break;
2021     }
2022     
2023     if (values && values->length()) {
2024         retValue1 = values;
2025         if (values2 && values2->length())
2026             retValue2 = values2;
2027         return true;
2028     }
2029     if (value) {
2030         retValue1 = value;
2031         retValue2 = value2;
2032         return true;
2033     }
2034
2035 failed:
2036     delete values; delete values2;
2037     delete value; delete value2;
2038     return false;
2039 }
2040
2041 #if PLATFORM(MAC)
2042
2043 #define DASHBOARD_REGION_NUM_PARAMETERS  6
2044 #define DASHBOARD_REGION_SHORT_NUM_PARAMETERS  2
2045
2046 static Value *skipCommaInDashboardRegion (ValueList *args)
2047 {
2048     if (args->size() == (DASHBOARD_REGION_NUM_PARAMETERS*2-1) ||
2049          args->size() == (DASHBOARD_REGION_SHORT_NUM_PARAMETERS*2-1)) {
2050         Value *current = args->current();
2051         if (current->unit == Value::Operator && current->iValue == ',')
2052             return args->next();
2053     }
2054     return args->current();
2055 }
2056
2057 bool CSSParser::parseDashboardRegions(int propId, bool important)
2058 {
2059     bool valid = true;
2060     
2061     Value *value = valueList->current();
2062
2063     if (value->id == CSS_VAL_NONE) {
2064         addProperty(propId, new CSSPrimitiveValue(value->id), important);
2065         return valid;
2066     }
2067         
2068     RefPtr<DashboardRegion> firstRegion = new DashboardRegion;
2069     DashboardRegion* region = 0;
2070
2071     while (value) {
2072         if (region == 0) {
2073             region = firstRegion.get();
2074         } else {
2075             RefPtr<DashboardRegion> nextRegion = new DashboardRegion();
2076             region->m_next = nextRegion;
2077             region = nextRegion.get();
2078         }
2079         
2080         if (value->unit != Value::Function) {
2081             valid = false;
2082             break;
2083         }
2084             
2085         // Commas count as values, so allow:
2086         // dashboard-region(label, type, t, r, b, l) or dashboard-region(label type t r b l)
2087         // dashboard-region(label, type, t, r, b, l) or dashboard-region(label type t r b l)
2088         // also allow
2089         // dashboard-region(label, type) or dashboard-region(label type)
2090         // dashboard-region(label, type) or dashboard-region(label type)
2091         ValueList* args = value->function->args;
2092         String fname = domString(value->function->name).lower();
2093         if (fname != "dashboard-region(" || !args) {
2094             valid = false;
2095             break;
2096         }
2097         
2098         int numArgs = args->size();
2099         if ((numArgs != DASHBOARD_REGION_NUM_PARAMETERS && numArgs != (DASHBOARD_REGION_NUM_PARAMETERS*2-1)) &&
2100             (numArgs != DASHBOARD_REGION_SHORT_NUM_PARAMETERS && numArgs != (DASHBOARD_REGION_SHORT_NUM_PARAMETERS*2-1))){
2101             valid = false;
2102             break;
2103         }
2104             
2105         // First arg is a label.
2106         Value* arg = args->current();
2107         if (arg->unit != CSSPrimitiveValue::CSS_IDENT) {
2108             valid = false;
2109             break;
2110         }
2111             
2112         region->m_label = domString(arg->string);
2113
2114         // Second arg is a type.
2115         arg = args->next();
2116         arg = skipCommaInDashboardRegion (args);
2117         if (arg->unit != CSSPrimitiveValue::CSS_IDENT) {
2118             valid = false;
2119             break;
2120         }
2121
2122         String geometryType = domString(arg->string).lower();
2123         if (geometryType == "circle")
2124             region->m_isCircle = true;
2125         else if (geometryType == "rectangle")
2126             region->m_isRectangle = true;
2127         else {
2128             valid = false;
2129             break;
2130         }
2131             
2132         region->m_geometryType = domString(arg->string);
2133
2134         if (numArgs == DASHBOARD_REGION_SHORT_NUM_PARAMETERS || numArgs == (DASHBOARD_REGION_SHORT_NUM_PARAMETERS*2-1)) {
2135             CSSPrimitiveValue *amount = arg->id == CSS_VAL_AUTO ?
2136                 new CSSPrimitiveValue(CSS_VAL_AUTO) :
2137                 new CSSPrimitiveValue((double)0, (CSSPrimitiveValue::UnitTypes) arg->unit);
2138                 
2139             region->setTop(amount);
2140             region->setRight(amount);
2141             region->setBottom(amount);
2142             region->setLeft(amount);
2143         }
2144         else {
2145             // Next four arguments must be offset numbers
2146             int i;
2147             for (i = 0; i < 4; i++) {
2148                 arg = args->next();
2149                 arg = skipCommaInDashboardRegion (args);
2150
2151                 valid = arg->id == CSS_VAL_AUTO || validUnit(arg, FLength, strict);
2152                 if (!valid)
2153                     break;
2154                     
2155                 CSSPrimitiveValue *amount = arg->id == CSS_VAL_AUTO ?
2156                     new CSSPrimitiveValue(CSS_VAL_AUTO) :
2157                     new CSSPrimitiveValue(arg->fValue, (CSSPrimitiveValue::UnitTypes) arg->unit);
2158                     
2159                 if (i == 0)
2160                     region->setTop(amount);
2161                 else if (i == 1)
2162                     region->setRight(amount);
2163                 else if (i == 2)
2164                     region->setBottom(amount);
2165                 else
2166                     region->setLeft(amount);
2167             }
2168         }
2169
2170         value = valueList->next();
2171     }
2172
2173     if (valid)
2174         addProperty(propId, new CSSPrimitiveValue(firstRegion.release()), important);
2175         
2176     return valid;
2177 }
2178 #endif
2179
2180 PassRefPtr<CSSValue> CSSParser::parseCounterContent(ValueList* args, bool counters)
2181 {
2182     unsigned numArgs = args->size();
2183     if (counters && numArgs != 3 && numArgs != 5)
2184         return 0;
2185     if (!counters && numArgs != 1 && numArgs != 3)
2186         return 0;
2187     
2188     Value* i = args->current();
2189     RefPtr<CSSPrimitiveValue> identifier = new CSSPrimitiveValue(domString(i->string),
2190         CSSPrimitiveValue::CSS_STRING);
2191
2192     RefPtr<CSSPrimitiveValue> separator;
2193     if (!counters)
2194         separator = new CSSPrimitiveValue(String(), CSSPrimitiveValue::CSS_STRING);
2195     else {
2196         i = args->next();
2197         if (i->unit != Value::Operator || i->iValue != ',')
2198             return 0;
2199         
2200         i = args->next();
2201         if (i->unit != CSSPrimitiveValue::CSS_STRING)
2202             return 0;
2203         
2204         separator = new CSSPrimitiveValue(domString(i->string), (CSSPrimitiveValue::UnitTypes) i->unit);
2205     }
2206
2207     RefPtr<CSSPrimitiveValue> listStyle;
2208     i = args->next();
2209     if (!i) // Make the list style default decimal
2210         listStyle = new CSSPrimitiveValue(CSS_VAL_DECIMAL - CSS_VAL_DISC, CSSPrimitiveValue::CSS_NUMBER);
2211     else {
2212         if (i->unit != Value::Operator || i->iValue != ',')
2213             return 0;
2214         
2215         i = args->next();
2216         if (i->unit != CSSPrimitiveValue::CSS_IDENT)
2217             return 0;
2218         
2219         short ls = 0;
2220         if (i->id == CSS_VAL_NONE)
2221             ls = CSS_VAL_KATAKANA_IROHA - CSS_VAL_DISC + 1;
2222         else if (i->id >= CSS_VAL_DISC && i->id <= CSS_VAL_KATAKANA_IROHA)
2223             ls = i->id - CSS_VAL_DISC;
2224         else
2225             return 0;
2226
2227         listStyle = new CSSPrimitiveValue(ls, (CSSPrimitiveValue::UnitTypes) i->unit);
2228     }
2229
2230     return new CSSPrimitiveValue(new Counter(identifier.release(), listStyle.release(), separator.release()));
2231 }
2232
2233 bool CSSParser::parseShape(int propId, bool important)
2234 {
2235     Value *value = valueList->current();
2236     ValueList *args = value->function->args;
2237     String fname = domString(value->function->name).lower();
2238     if (fname != "rect(" || !args)
2239         return false;
2240
2241     // rect(t, r, b, l) || rect(t r b l)
2242     if (args->size() != 4 && args->size() != 7)
2243         return false;
2244     RectImpl *rect = new RectImpl();
2245     bool valid = true;
2246     int i = 0;
2247     Value *a = args->current();
2248     while (a) {
2249         valid = a->id == CSS_VAL_AUTO || validUnit(a, FLength, strict);
2250         if (!valid)
2251             break;
2252         CSSPrimitiveValue *length = a->id == CSS_VAL_AUTO ?
2253             new CSSPrimitiveValue(CSS_VAL_AUTO) :
2254             new CSSPrimitiveValue(a->fValue, (CSSPrimitiveValue::UnitTypes) a->unit);
2255         if (i == 0)
2256             rect->setTop(length);
2257         else if (i == 1)
2258             rect->setRight(length);
2259         else if (i == 2)
2260             rect->setBottom(length);
2261         else
2262             rect->setLeft(length);
2263         a = args->next();
2264         if (a && args->size() == 7) {
2265             if (a->unit == Value::Operator && a->iValue == ',') {
2266                 a = args->next();
2267             } else {
2268                 valid = false;
2269                 break;
2270             }
2271         }
2272         i++;
2273     }
2274     if (valid) {
2275         addProperty(propId, new CSSPrimitiveValue(rect), important);
2276         valueList->next();
2277         return true;
2278     }
2279     delete rect;
2280     return false;
2281 }
2282
2283 // [ 'font-style' || 'font-variant' || 'font-weight' ]? 'font-size' [ / 'line-height' ]? 'font-family'
2284 bool CSSParser::parseFont(bool important)
2285 {
2286     bool valid = true;
2287     Value *value = valueList->current();
2288     FontValue *font = new FontValue;
2289     // optional font-style, font-variant and font-weight
2290     while (value) {
2291         int id = value->id;
2292         if (id) {
2293             if (id == CSS_VAL_NORMAL) {
2294                 // do nothing, it's the inital value for all three
2295             } else if (id == CSS_VAL_ITALIC || id == CSS_VAL_OBLIQUE) {
2296                 if (font->style)
2297                     goto invalid;
2298                 font->style = new CSSPrimitiveValue(id);
2299             } else if (id == CSS_VAL_SMALL_CAPS) {
2300                 if (font->variant)
2301                     goto invalid;
2302                 font->variant = new CSSPrimitiveValue(id);
2303             } else if (id >= CSS_VAL_BOLD && id <= CSS_VAL_LIGHTER) {
2304                 if (font->weight)
2305                     goto invalid;
2306                 font->weight = new CSSPrimitiveValue(id);
2307             } else {
2308                 valid = false;
2309             }
2310         } else if (!font->weight && validUnit(value, FInteger|FNonNeg, true)) {
2311             int weight = (int)value->fValue;
2312             int val = 0;
2313             if (weight == 100)
2314                 val = CSS_VAL_100;
2315             else if (weight == 200)
2316                 val = CSS_VAL_200;
2317             else if (weight == 300)
2318                 val = CSS_VAL_300;
2319             else if (weight == 400)
2320                 val = CSS_VAL_400;
2321             else if (weight == 500)
2322                 val = CSS_VAL_500;
2323             else if (weight == 600)
2324                 val = CSS_VAL_600;
2325             else if (weight == 700)
2326                 val = CSS_VAL_700;
2327             else if (weight == 800)
2328                 val = CSS_VAL_800;
2329             else if (weight == 900)
2330                 val = CSS_VAL_900;
2331
2332             if (val)
2333                 font->weight = new CSSPrimitiveValue(val);
2334             else
2335                 valid = false;
2336         } else {
2337             valid = false;
2338         }
2339         if (!valid)
2340             break;
2341         value = valueList->next();
2342     }
2343     if (!value)
2344         goto invalid;
2345
2346     // set undefined values to default
2347     if (!font->style)
2348         font->style = new CSSPrimitiveValue(CSS_VAL_NORMAL);
2349     if (!font->variant)
2350         font->variant = new CSSPrimitiveValue(CSS_VAL_NORMAL);
2351     if (!font->weight)
2352         font->weight = new CSSPrimitiveValue(CSS_VAL_NORMAL);
2353
2354     // now a font size _must_ come
2355     // <absolute-size> | <relative-size> | <length> | <percentage> | inherit
2356     if (value->id >= CSS_VAL_XX_SMALL && value->id <= CSS_VAL_LARGER)
2357         font->size = new CSSPrimitiveValue(value->id);
2358     else if (validUnit(value, FLength|FPercent, strict))
2359         font->size = new CSSPrimitiveValue(value->fValue, (CSSPrimitiveValue::UnitTypes) value->unit);
2360     value = valueList->next();
2361     if (!font->size || !value)
2362         goto invalid;
2363
2364     if (value->unit == Value::Operator && value->iValue == '/') {
2365         // line-height
2366         value = valueList->next();
2367         if (!value)
2368             goto invalid;
2369         if (value->id == CSS_VAL_NORMAL) {
2370             // default value, nothing to do
2371         } else if (validUnit(value, FNumber|FLength|FPercent, strict))
2372             font->lineHeight = new CSSPrimitiveValue(value->fValue, (CSSPrimitiveValue::UnitTypes) value->unit);
2373         else
2374             goto invalid;
2375         value = valueList->next();
2376         if (!value)
2377             goto invalid;
2378     }
2379     
2380     if (!font->lineHeight)
2381         font->lineHeight = new CSSPrimitiveValue(CSS_VAL_NORMAL);
2382
2383     // font family must come now
2384     font->family = parseFontFamily();
2385
2386     if (valueList->current() || !font->family)
2387         goto invalid;
2388
2389     addProperty(CSS_PROP_FONT, font, important);
2390     return true;
2391
2392  invalid:
2393     delete font;
2394     return false;
2395 }
2396
2397 CSSValueList* CSSParser::parseFontFamily()
2398 {
2399     CSSValueList* list = new CSSValueList;
2400     Value* value = valueList->current();
2401     FontFamilyValue* currFamily = 0;
2402     while (value) {
2403         Value* nextValue = valueList->next();
2404         bool nextValBreaksFont = !nextValue ||
2405                                  (nextValue->unit == Value::Operator && nextValue->iValue == ',');
2406         bool nextValIsFontName = nextValue &&
2407             ((nextValue->id >= CSS_VAL_SERIF && nextValue->id <= CSS_VAL__WEBKIT_BODY) ||
2408             (nextValue->unit == CSSPrimitiveValue::CSS_STRING || nextValue->unit == CSSPrimitiveValue::CSS_IDENT));
2409
2410         if (value->id >= CSS_VAL_SERIF && value->id <= CSS_VAL__WEBKIT_BODY) {
2411             if (currFamily) {
2412                 currFamily->parsedFontName += ' ';
2413                 currFamily->parsedFontName += deprecatedString(value->string);
2414             }
2415             else if (nextValBreaksFont || !nextValIsFontName)
2416                 list->append(new CSSPrimitiveValue(value->id));
2417             else
2418                 list->append(currFamily = new FontFamilyValue(deprecatedString(value->string)));
2419         }
2420         else if (value->unit == CSSPrimitiveValue::CSS_STRING) {
2421             // Strings never share in a family name.
2422             currFamily = 0;
2423             list->append(new FontFamilyValue(deprecatedString(value->string)));
2424         }
2425         else if (value->unit == CSSPrimitiveValue::CSS_IDENT) {
2426             if (currFamily) {
2427                 currFamily->parsedFontName += ' ';
2428                 currFamily->parsedFontName += deprecatedString(value->string);
2429             }
2430             else if (nextValBreaksFont || !nextValIsFontName)
2431                 list->append(new FontFamilyValue(deprecatedString(value->string)));
2432             else
2433                 list->append(currFamily = new FontFamilyValue(deprecatedString(value->string)));
2434         }
2435         else {
2436             break;
2437         }
2438         
2439         if (!nextValue)
2440             break;
2441
2442         if (nextValBreaksFont) {
2443             value = valueList->next();
2444             currFamily = 0;
2445         }
2446         else if (nextValIsFontName)
2447             value = nextValue;
2448         else
2449             break;
2450     }
2451     if (!list->length()) {
2452         delete list;
2453         list = 0;
2454     }
2455     return list;
2456 }
2457
2458 bool CSSParser::parseColor(const String &name, RGBA32& rgb, bool strict)
2459 {
2460     if (!strict && Color::parseHexColor(name, rgb))
2461         return true;
2462
2463     // try a little harder
2464     Color tc;
2465     tc.setNamedColor(name.lower());
2466     if (tc.isValid()) {
2467         rgb = tc.rgb();
2468         return true;
2469     }
2470
2471     return false;
2472 }
2473
2474 bool CSSParser::parseColorParameters(Value* value, int* colorArray, bool parseAlpha)
2475 {
2476     ValueList* args = value->function->args;
2477     Value* v = args->current();
2478     // Get the first value
2479     if (!validUnit(v, FInteger | FPercent, true))
2480         return false;
2481     colorArray[0] = static_cast<int>(v->fValue * (v->unit == CSSPrimitiveValue::CSS_PERCENTAGE ? 256.0 / 100.0 : 1.0));
2482     for (int i = 1; i < 3; i++) {
2483         v = args->next();
2484         if (v->unit != Value::Operator && v->iValue != ',')
2485             return false;
2486         v = args->next();
2487         if (!validUnit(v, FInteger | FPercent, true))
2488             return false;
2489         colorArray[i] = static_cast<int>(v->fValue * (v->unit == CSSPrimitiveValue::CSS_PERCENTAGE ? 256.0 / 100.0 : 1.0));
2490     }
2491     if (parseAlpha) {
2492         v = args->next();
2493         if (v->unit != Value::Operator && v->iValue != ',')
2494             return false;
2495         v = args->next();
2496         if (!validUnit(v, FNumber, true))
2497             return false;
2498         colorArray[3] = static_cast<int>(max(0.0, min(1.0, v->fValue)) * 255);
2499     }
2500     return true;
2501 }
2502
2503 // CSS3 sepcification defines the format of a HSL color as
2504 // hsl(<number>, <percent>, <percent>)
2505 // and with alpha, the format is
2506 // hsla(<number>, <percent>, <percent>, <number>)
2507 // The first value, HUE, is in an angle with a value between 0 and 360
2508 bool CSSParser::parseHSLParameters(Value* value, double* colorArray, bool parseAlpha)
2509 {
2510     ValueList* args = value->function->args;
2511     Value* v = args->current();
2512     // Get the first value
2513     if (!validUnit(v, FInteger, true))
2514         return false;
2515     // normalize the Hue value and change it to be between 0 and 1.0
2516     colorArray[0] = (((static_cast<int>(v->fValue) % 360) + 360) % 360) / 360.0;
2517     for (int i = 1; i < 3; i++) {
2518         v = args->next();
2519         if (v->unit != Value::Operator && v->iValue != ',')
2520             return false;
2521         v = args->next();
2522         if (!validUnit(v, FPercent, true))
2523             return false;
2524         colorArray[i] = max(0.0, min(100.0, v->fValue)) / 100.0; // needs to be value between 0 and 1.0
2525     }
2526     if (parseAlpha) {
2527         v = args->next();
2528         if (v->unit != Value::Operator && v->iValue != ',')
2529             return false;
2530         v = args->next();
2531         if (!validUnit(v, FNumber, true))
2532             return false;
2533         colorArray[3] = max(0.0, min(1.0, v->fValue));
2534     }
2535     return true;
2536 }
2537
2538 CSSPrimitiveValue *CSSParser::parseColor(Value* value)
2539 {
2540     RGBA32 c = Color::transparent;
2541     if (!parseColorFromValue(value ? value : valueList->current(), c))
2542         return 0;
2543     return new CSSPrimitiveValue(c);
2544 }
2545
2546 bool CSSParser::parseColorFromValue(Value* value, RGBA32& c, bool svg)
2547 {
2548     if (!strict && value->unit == CSSPrimitiveValue::CSS_NUMBER &&
2549         value->fValue >= 0. && value->fValue < 1000000.) {
2550         String str = String::format("%06d", (int)(value->fValue+.5));
2551         if (!CSSParser::parseColor(str, c, strict))
2552             return false;
2553     } else if (value->unit == CSSPrimitiveValue::CSS_RGBCOLOR ||
2554                 value->unit == CSSPrimitiveValue::CSS_IDENT ||
2555                 (!strict && value->unit == CSSPrimitiveValue::CSS_DIMENSION)) {
2556         if (!CSSParser::parseColor(domString(value->string), c, strict && value->unit == CSSPrimitiveValue::CSS_IDENT))
2557             return false;
2558     } else if (value->unit == Value::Function &&
2559                 value->function->args != 0 &&
2560                 value->function->args->size() == 5 /* rgb + two commas */ &&
2561                 domString(value->function->name).lower() == "rgb(") {
2562         int colorValues[3];
2563         if (!parseColorParameters(value, colorValues, false))
2564             return false;
2565         c = makeRGB(colorValues[0], colorValues[1], colorValues[2]);
2566     } else if (!svg) {
2567         if (value->unit == Value::Function &&
2568                 value->function->args != 0 &&
2569                 value->function->args->size() == 7 /* rgba + three commas */ &&
2570                 domString(value->function->name).lower() == "rgba(") {
2571             int colorValues[4];
2572             if (!parseColorParameters(value, colorValues, true))
2573                 return false;
2574             c = makeRGBA(colorValues[0], colorValues[1], colorValues[2], colorValues[3]);
2575         } else if (value->unit == Value::Function &&
2576                     value->function->args != 0 &&
2577                     value->function->args->size() == 5 /* hsl + two commas */ &&
2578                     domString(value->function->name).lower() == "hsl(") {
2579             double colorValues[3];
2580             if (!parseHSLParameters(value, colorValues, false))
2581                 return false;
2582             c = makeRGBAFromHSLA(colorValues[0], colorValues[1], colorValues[2], 1.0);
2583         } else if (value->unit == Value::Function &&
2584                     value->function->args != 0 &&
2585                     value->function->args->size() == 7 /* hsla + three commas */ &&
2586                     domString(value->function->name).lower() == "hsla(") {
2587             double colorValues[4];
2588             if (!parseHSLParameters(value, colorValues, true))
2589                 return false;
2590             c = makeRGBAFromHSLA(colorValues[0], colorValues[1], colorValues[2], colorValues[3]);
2591         } else
2592             return false;
2593     } else
2594         return false;
2595
2596     return true;
2597 }
2598
2599 // This class tracks parsing state for shadow values.  If it goes out of scope (e.g., due to an early return)
2600 // without the allowBreak bit being set, then it will clean up all of the objects and destroy them.
2601 struct ShadowParseContext {
2602     ShadowParseContext()
2603     :values(0), x(0), y(0), blur(0), color(0),
2604      allowX(true), allowY(false), allowBlur(false), allowColor(true),
2605      allowBreak(true)
2606     {}
2607
2608     ~ShadowParseContext() {
2609         if (!allowBreak) {
2610             delete values;
2611             delete x;
2612             delete y;
2613             delete blur;
2614             delete color;
2615         }
2616     }
2617
2618     bool allowLength() { return allowX || allowY || allowBlur; }
2619
2620     bool failed() { return allowBreak = false; }
2621     
2622     void commitValue() {
2623         // Handle the ,, case gracefully by doing nothing.
2624         if (x || y || blur || color) {
2625             if (!values)
2626                 values = new CSSValueList();
2627             
2628             // Construct the current shadow value and add it to the list.
2629             values->append(new ShadowValue(x, y, blur, color));
2630         }
2631         
2632         // Now reset for the next shadow value.
2633         x = y = blur = color = 0;
2634         allowX = allowColor = allowBreak = true;
2635         allowY = allowBlur = false;  
2636     }
2637
2638     void commitLength(Value* v) {
2639         CSSPrimitiveValue* val = new CSSPrimitiveValue(v->fValue,
2640                                                                (CSSPrimitiveValue::UnitTypes)v->unit);
2641         if (allowX) {
2642             x = val;
2643             allowX = false; allowY = true; allowColor = false; allowBreak = false;
2644         }
2645         else if (allowY) {
2646             y = val;
2647             allowY = false; allowBlur = true; allowColor = true; allowBreak = true;
2648         }
2649         else if (allowBlur) {
2650             blur = val;
2651             allowBlur = false;
2652         }
2653     }
2654
2655     void commitColor(CSSPrimitiveValue* val) {
2656         color = val;
2657         allowColor = false;
2658         if (allowX)
2659             allowBreak = false;
2660         else
2661             allowBlur = false;
2662     }
2663     
2664     CSSValueList* values;
2665     CSSPrimitiveValue* x;
2666     CSSPrimitiveValue* y;
2667     CSSPrimitiveValue* blur;
2668     CSSPrimitiveValue* color;
2669
2670     bool allowX;
2671     bool allowY;
2672     bool allowBlur;
2673     bool allowColor;
2674     bool allowBreak;
2675 };
2676
2677 bool CSSParser::parseShadow(int propId, bool important)
2678 {
2679     ShadowParseContext context;
2680     Value* val;
2681     while ((val = valueList->current())) {
2682         // Check for a comma break first.
2683         if (val->unit == Value::Operator) {
2684             if (val->iValue != ',' || !context.allowBreak)
2685                 // Other operators aren't legal or we aren't done with the current shadow
2686                 // value.  Treat as invalid.
2687                 return context.failed();
2688             
2689             // The value is good.  Commit it.
2690             context.commitValue();
2691         }
2692         // Check to see if we're a length.
2693         else if (validUnit(val, FLength, true)) {
2694             // We required a length and didn't get one. Invalid.
2695             if (!context.allowLength())
2696                 return context.failed();
2697
2698             // A length is allowed here.  Construct the value and add it.
2699             context.commitLength(val);
2700         }
2701         else {
2702             // The only other type of value that's ok is a color value.
2703             CSSPrimitiveValue* parsedColor = 0;
2704             bool isColor = (val->id >= CSS_VAL_AQUA && val->id <= CSS_VAL_WINDOWTEXT || val->id == CSS_VAL_MENU ||
2705                             (val->id >= CSS_VAL__WEBKIT_FOCUS_RING_COLOR && val->id <= CSS_VAL__WEBKIT_TEXT && !strict));
2706             if (isColor) {
2707                 if (!context.allowColor)
2708                     return context.failed();
2709                 parsedColor = new CSSPrimitiveValue(val->id);
2710             }
2711
2712             if (!parsedColor)
2713                 // It's not built-in. Try to parse it as a color.
2714                 parsedColor = parseColor(val);
2715
2716             if (!parsedColor || !context.allowColor)
2717                 return context.failed(); // This value is not a color or length and is invalid or
2718                                          // it is a color, but a color isn't allowed at this point.
2719             
2720             context.commitColor(parsedColor);
2721         }
2722         
2723         valueList->next();
2724     }
2725
2726     if (context.allowBreak) {
2727         context.commitValue();
2728         if (context.values->length()) {
2729             addProperty(propId, context.values, important);
2730             valueList->next();
2731             return true;
2732         }
2733     }
2734     
2735     return context.failed();
2736 }
2737
2738 struct BorderImageParseContext
2739 {
2740     BorderImageParseContext()
2741     :m_allowBreak(false), m_allowNumber(false), m_allowSlash(false), m_allowWidth(false),
2742      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),
2743      m_borderLeft(0), m_horizontalRule(0), m_verticalRule(0)
2744     {}
2745     
2746     ~BorderImageParseContext() {
2747         if (!m_allowBreak) {
2748             delete m_image;
2749             delete m_top; delete m_right; delete m_bottom; delete m_left;
2750             delete m_borderTop; delete m_borderRight; delete m_borderBottom; delete m_borderLeft;
2751         }
2752     }
2753
2754     bool failed() { return m_allowBreak = false; }
2755     bool allowBreak() const { return m_allowBreak; }
2756     bool allowNumber() const { return m_allowNumber; }
2757     bool allowSlash() const { return m_allowSlash; }
2758     bool allowWidth() const { return m_allowWidth; }
2759     bool allowRule() const { return m_allowRule; }
2760
2761     void commitImage(CSSImageValue* image) { m_image = image; m_allowNumber = true; }
2762     void commitNumber(Value* v) {
2763         CSSPrimitiveValue* val = new CSSPrimitiveValue(v->fValue,
2764                                                                (CSSPrimitiveValue::UnitTypes)v->unit);
2765         if (!m_top)
2766             m_top = val;
2767         else if (!m_right)
2768             m_right = val;
2769         else if (!m_bottom)
2770             m_bottom = val;
2771         else {
2772             assert(!m_left);
2773             m_left = val;
2774         }
2775         
2776         m_allowBreak = m_allowSlash = m_allowRule = true;
2777         m_allowNumber = !m_left;
2778     }
2779     void commitSlash() { m_allowBreak = m_allowSlash = m_allowNumber = false; m_allowWidth = true; }
2780     void commitWidth(Value* val) {
2781         if (!m_borderTop)
2782             m_borderTop = val;
2783         else if (!m_borderRight)
2784             m_borderRight = val;
2785         else if (!m_borderBottom)
2786             m_borderBottom = val;
2787         else {
2788             assert(!m_borderLeft);
2789             m_borderLeft = val;
2790         }
2791
2792         m_allowBreak = m_allowRule = true;
2793         m_allowWidth = !m_borderLeft;
2794     }
2795     void commitRule(int keyword) {
2796         if (!m_horizontalRule)
2797             m_horizontalRule = keyword;
2798         else if (!m_verticalRule)
2799             m_verticalRule = keyword;
2800         m_allowRule = !m_verticalRule;
2801     }
2802     void commitBorderImage(CSSParser* p, int propId, bool important) {
2803         // We need to clone and repeat values for any omissions.
2804         if (!m_right) {
2805             m_right = new CSSPrimitiveValue(m_top->getFloatValue(), (CSSPrimitiveValue::UnitTypes)m_top->primitiveType());
2806             m_bottom = new CSSPrimitiveValue(m_top->getFloatValue(), (CSSPrimitiveValue::UnitTypes)m_top->primitiveType());
2807             m_left = new CSSPrimitiveValue(m_top->getFloatValue(), (CSSPrimitiveValue::UnitTypes)m_top->primitiveType());
2808         }
2809         if (!m_bottom) {
2810             m_bottom = new CSSPrimitiveValue(m_top->getFloatValue(), (CSSPrimitiveValue::UnitTypes)m_top->primitiveType());
2811             m_left = new CSSPrimitiveValue(m_right->getFloatValue(), (CSSPrimitiveValue::UnitTypes)m_right->primitiveType());
2812         }
2813         if (!m_left)
2814              m_left = new CSSPrimitiveValue(m_top->getFloatValue(), (CSSPrimitiveValue::UnitTypes)m_top->primitiveType());
2815              
2816         // Now build a rect value to hold all four of our primitive values.
2817         RectImpl* rect = new RectImpl;
2818         rect->setTop(m_top); rect->setRight(m_right); rect->setBottom(m_bottom); rect->setLeft(m_left);
2819
2820         // Fill in STRETCH as the default if it wasn't specified.
2821         if (!m_horizontalRule)
2822             m_horizontalRule = CSS_VAL_STRETCH;
2823         if (!m_verticalRule)
2824             m_verticalRule = CSS_VAL_STRETCH;
2825
2826         // Make our new border image value now and add it as the result.
2827         CSSBorderImageValue* borderImage = new CSSBorderImageValue(m_image, rect, m_horizontalRule, m_verticalRule);
2828         p->addProperty(propId, borderImage, important);
2829             
2830         // 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
2831         // list and then make our parsing machinery do the parsing.
2832         if (m_borderTop) {
2833             ValueList newList;
2834             newList.addValue(*m_borderTop);
2835             if (m_borderRight)
2836                 newList.addValue(*m_borderRight);
2837             if (m_borderBottom)
2838                 newList.addValue(*m_borderBottom);
2839             if (m_borderLeft)
2840                 newList.addValue(*m_borderLeft);
2841             p->valueList = &newList;
2842             p->parseValue(CSS_PROP_BORDER_WIDTH, important);
2843             p->valueList = 0;
2844         }
2845     }
2846     
2847     bool m_allowBreak;
2848     bool m_allowNumber;
2849     bool m_allowSlash;
2850     bool m_allowWidth;
2851     bool m_allowRule;
2852     
2853     CSSImageValue* m_image;
2854     
2855     CSSPrimitiveValue* m_top;
2856     CSSPrimitiveValue* m_right;
2857     CSSPrimitiveValue* m_bottom;
2858     CSSPrimitiveValue* m_left;
2859     
2860     Value* m_borderTop;
2861     Value* m_borderRight;
2862     Value* m_borderBottom;
2863     Value* m_borderLeft;
2864     
2865     int m_horizontalRule;
2866     int m_verticalRule;
2867 };
2868
2869 bool CSSParser::parseBorderImage(int propId, bool important)
2870 {
2871     // Look for an image initially.  If the first value is not a URI, then we're done.
2872     BorderImageParseContext context;
2873     Value* val = valueList->current();
2874     if (val->unit != CSSPrimitiveValue::CSS_URI)
2875         return context.failed();
2876         
2877     String uri = parseURL(domString(val->string));
2878     if (uri.isEmpty())
2879         return context.failed();
2880     
2881     context.commitImage(new CSSImageValue(String(KURL(styleElement->baseURL().deprecatedString(), uri.deprecatedString()).url()),
2882                                                              styleElement));
2883     while ((val = valueList->next())) {
2884         if (context.allowNumber() && validUnit(val, FInteger|FNonNeg|FPercent, true)) {
2885             context.commitNumber(val);
2886         } else if (context.allowSlash() && val->unit == Value::Operator && val->iValue == '/') {
2887             context.commitSlash();
2888         } else if (context.allowWidth() &&
2889             (val->id == CSS_VAL_THIN || val->id == CSS_VAL_MEDIUM || val->id == CSS_VAL_THICK || validUnit(val, FLength, strict))) {
2890             context.commitWidth(val);
2891         } else if (context.allowRule() &&
2892             (val->id == CSS_VAL_STRETCH || val->id == CSS_VAL_ROUND || val->id == CSS_VAL_REPEAT)) {
2893             context.commitRule(val->id);
2894         } else {
2895             // Something invalid was encountered.
2896             return context.failed();
2897         }
2898     }
2899     
2900     if (context.allowBreak()) {
2901         // Need to fully commit as a single value.
2902         context.commitBorderImage(this, propId, important);
2903         return true;
2904     }
2905     
2906     return context.failed();
2907 }
2908
2909 bool CSSParser::parseCounter(int propId, int defaultValue, bool important)
2910 {
2911     enum { ID, VAL } state = ID;
2912
2913     RefPtr<CSSValueList> list = new CSSValueList;
2914     RefPtr<CSSPrimitiveValue> counterName;
2915     
2916     while (true) {
2917         Value* val = valueList->current();
2918         switch (state) {
2919             case ID:
2920                 if (val && val->unit == CSSPrimitiveValue::CSS_IDENT) {
2921                     counterName = new CSSPrimitiveValue(domString(val->string), CSSPrimitiveValue::CSS_STRING);
2922                     state = VAL;
2923                     valueList->next();
2924                     continue;
2925                 }
2926                 break;
2927             case VAL: {
2928                 int i = defaultValue;
2929                 if (val && val->unit == CSSPrimitiveValue::CSS_NUMBER) {
2930                     i = (int)val->fValue;
2931                     valueList->next();
2932                 }
2933
2934                 list->append(new CSSPrimitiveValue(new Pair(counterName.release(),
2935                     new CSSPrimitiveValue(i, CSSPrimitiveValue::CSS_NUMBER))));
2936                 state = ID;
2937                 continue;
2938             }
2939         }
2940         break;
2941     }
2942     
2943     if (list->length() > 0) {
2944         addProperty(propId, list.release(), important);
2945         return true;
2946     }
2947
2948     return false;
2949 }
2950
2951 #ifdef CSS_DEBUG
2952
2953 static inline int yyerror(const char *str)
2954 {
2955     kdDebug(6080) << "CSS parse error " << str << endl;
2956     return 1;
2957 }
2958
2959 #else
2960
2961 static inline int yyerror(const char*) { return 1; }
2962
2963 #endif
2964
2965 #define END_TOKEN 0
2966
2967 #include "CSSGrammar.h"
2968
2969 int CSSParser::lex(void* yylvalWithoutType)
2970 {
2971     YYSTYPE* yylval = static_cast<YYSTYPE*>(yylvalWithoutType);
2972     int token = lex();
2973     int length;
2974     UChar* t = text(&length);
2975
2976     switch(token) {
2977     case WHITESPACE:
2978     case SGML_CD:
2979     case INCLUDES:
2980     case DASHMATCH:
2981         break;
2982
2983     case URI:
2984     case STRING:
2985     case IDENT:
2986     case HASH:
2987     case DIMEN:
2988     case UNICODERANGE:
2989     case FUNCTION:
2990     case NOTFUNCTION:
2991         yylval->string.characters = t;
2992         yylval->string.length = length;
2993         break;
2994
2995     case IMPORT_SYM:
2996     case PAGE_SYM:
2997     case MEDIA_SYM:
2998     case FONT_FACE_SYM:
2999     case CHARSET_SYM:
3000     case NAMESPACE_SYM:
3001
3002     case IMPORTANT_SYM:
3003         break;
3004
3005     case QEMS:
3006         length--;
3007     case GRADS:
3008         length--;
3009     case DEGS:
3010     case RADS:
3011     case KHERZ:
3012         length--;
3013     case MSECS:
3014     case HERZ:
3015     case EMS:
3016     case EXS:
3017     case PXS:
3018     case CMS:
3019     case MMS:
3020     case INS:
3021     case PTS:
3022     case PCS:
3023         length--;
3024     case SECS:
3025     case PERCENTAGE:
3026         length--;
3027     case FLOAT:
3028     case INTEGER:
3029         yylval->val = DeprecatedString((DeprecatedChar *)t, length).toDouble();
3030         break;
3031
3032     default:
3033         break;
3034     }
3035
3036     return token;
3037 }
3038
3039 static inline int toHex(char c)
3040 {
3041     if ('0' <= c && c <= '9')
3042         return c - '0';
3043     if ('a' <= c && c <= 'f')
3044         return c - 'a' + 10;
3045     if ('A' <= c && c<= 'F')
3046         return c - 'A' + 10;
3047     return 0;
3048 }
3049
3050 UChar* CSSParser::text(int *length)
3051 {
3052     UChar* start = yytext;
3053     int l = yyleng;
3054     switch(yyTok) {
3055     case STRING:
3056         l--;
3057         /* nobreak */
3058     case HASH:
3059         start++;
3060         l--;
3061         break;
3062     case URI:
3063         // "url("{w}{string}{w}")"
3064         // "url("{w}{url}{w}")"
3065
3066         // strip "url(" and ")"
3067         start += 4;
3068         l -= 5;
3069         // strip {w}
3070         while (l &&
3071                 (*start == ' ' || *start == '\t' || *start == '\r' ||
3072                  *start == '\n' || *start == '\f')) {
3073             start++; l--;
3074         }
3075         if (*start == '"' || *start == '\'') {
3076             start++; l--;
3077         }
3078         while (l &&
3079                 (start[l-1] == ' ' || start[l-1] == '\t' || start[l-1] == '\r' ||
3080                  start[l-1] == '\n' || start[l-1] == '\f')) {
3081             l--;
3082         }
3083         if (l && (start[l-1] == '\"' || start[l-1] == '\''))
3084              l--;
3085
3086     default:
3087         break;
3088     }
3089
3090     // process escapes
3091     UChar* out = start;
3092     UChar* escape = 0;
3093
3094     for (int i = 0; i < l; i++) {
3095         UChar* current = start + i;
3096         if (escape == current - 1) {
3097             if ((*current >= '0' && *current <= '9') ||
3098                  (*current >= 'a' && *current <= 'f') ||
3099                  (*current >= 'A' && *current <= 'F'))
3100                 continue;
3101             if (yyTok == STRING &&
3102                  (*current == '\n' || *current == '\r' || *current == '\f')) {
3103                 // ### handle \r\n case
3104                 if (*current != '\r')
3105                     escape = 0;
3106                 continue;
3107             }
3108             // in all other cases copy the char to output
3109             // ###
3110             *out++ = *current;
3111             escape = 0;
3112             continue;
3113         }
3114         if (escape == current - 2 && yyTok == STRING &&
3115              *(current-1) == '\r' && *current == '\n') {
3116             escape = 0;
3117             continue;
3118         }
3119         if (escape > current - 7 &&
3120              ((*current >= '0' && *current <= '9') ||
3121                (*current >= 'a' && *current <= 'f') ||
3122                (*current >= 'A' && *current <= 'F')))
3123             continue;
3124         if (escape) {
3125             // add escaped char
3126             unsigned uc = 0;
3127             escape++;
3128             while (escape < current) {
3129                 uc *= 16;
3130                 uc += toHex(*escape);
3131                 escape++;
3132             }
3133             // can't handle chars outside ucs2
3134             if (uc > 0xffff)
3135                 uc = 0xfffd;
3136             *out++ = uc;
3137             escape = 0;
3138             if (*current == ' ' ||
3139                  *current == '\t' ||
3140                  *current == '\r' ||
3141                  *current == '\n' ||
3142                  *current == '\f')
3143                 continue;
3144         }
3145         if (!escape && *current == '\\') {
3146             escape = current;
3147             continue;
3148         }
3149         *out++ = *current;
3150     }
3151     if (escape) {
3152         // add escaped char
3153         unsigned uc = 0;
3154         escape++;
3155         while (escape < start+l) {
3156             uc *= 16;
3157             uc += toHex(*escape);
3158             escape++;
3159         }
3160         // can't handle chars outside ucs2
3161         if (uc > 0xffff)
3162             uc = 0xfffd;
3163         *out++ = uc;
3164     }
3165     
3166     *length = out - start;
3167     return start;
3168 }
3169
3170 CSSSelector* CSSParser::createFloatingSelector()
3171 {
3172     CSSSelector* selector = new CSSSelector;
3173     m_floatingSelectors.add(selector);
3174     return selector;
3175 }
3176
3177 CSSSelector* CSSParser::sinkFloatingSelector(CSSSelector* selector)
3178 {
3179     if (selector) {
3180         ASSERT(m_floatingSelectors.contains(selector));
3181         m_floatingSelectors.remove(selector);
3182     }
3183     return selector;
3184 }
3185
3186 ValueList* CSSParser::createFloatingValueList()
3187 {
3188     ValueList* list = new ValueList;
3189     m_floatingValueLists.add(list);
3190     return list;
3191 }
3192
3193 ValueList* CSSParser::sinkFloatingValueList(ValueList* list)
3194 {
3195     if (list) {
3196         ASSERT(m_floatingValueLists.contains(list));
3197         m_floatingValueLists.remove(list);
3198     }
3199     return list;
3200 }
3201
3202 Function* CSSParser::createFloatingFunction()
3203 {
3204     Function* function = new Function;
3205     m_floatingFunctions.add(function);
3206     return function;
3207 }
3208
3209 Function* CSSParser::sinkFloatingFunction(Function* function)
3210 {
3211     if (function) {
3212         ASSERT(m_floatingFunctions.contains(function));
3213         m_floatingFunctions.remove(function);
3214     }
3215     return function;
3216 }
3217
3218 Value& CSSParser::sinkFloatingValue(Value& value)
3219 {
3220     if (value.unit == Value::Function) {
3221         ASSERT(m_floatingFunctions.contains(value.function));
3222         m_floatingFunctions.remove(value.function);
3223     }
3224     return value;
3225 }
3226
3227 MediaQueryExp* CSSParser::createFloatingMediaQueryExp(const AtomicString& mediaFeature, ValueList* values)
3228 {
3229     delete m_floatingMediaQueryExp;
3230     m_floatingMediaQueryExp = new MediaQueryExp(mediaFeature, values);
3231     return m_floatingMediaQueryExp;
3232 }
3233
3234 MediaQueryExp* CSSParser::sinkFloatingMediaQueryExp(MediaQueryExp* e)
3235 {
3236     ASSERT(e == m_floatingMediaQueryExp);
3237     m_floatingMediaQueryExp = 0;
3238     return e;
3239 }
3240
3241 Vector<MediaQueryExp*>* CSSParser::createFloatingMediaQueryExpList()
3242 {
3243     if (m_floatingMediaQueryExpList) {
3244         deleteAllValues(*m_floatingMediaQueryExpList);
3245         delete m_floatingMediaQueryExpList;
3246     }
3247     m_floatingMediaQueryExpList = new Vector<MediaQueryExp*>;
3248     return m_floatingMediaQueryExpList;
3249 }
3250
3251 Vector<MediaQueryExp*>* CSSParser::sinkFloatingMediaQueryExpList(Vector<MediaQueryExp*>* l)
3252 {
3253     ASSERT(l == m_floatingMediaQueryExpList);
3254     m_floatingMediaQueryExpList = 0;
3255     return l;
3256 }
3257
3258 MediaQuery* CSSParser::createFloatingMediaQuery(MediaQuery::Restrictor r, const String& mediaType, Vector<MediaQueryExp*>* exprs)
3259 {
3260     delete m_floatingMediaQuery;
3261     m_floatingMediaQuery = new MediaQuery(r, mediaType, exprs);
3262     return m_floatingMediaQuery;
3263 }
3264
3265 MediaQuery* CSSParser::sinkFloatingMediaQuery(MediaQuery* mq)
3266 {
3267     ASSERT(mq == m_floatingMediaQuery);
3268     m_floatingMediaQuery = 0;
3269     return mq;
3270 }
3271
3272 MediaList* CSSParser::createMediaList()
3273 {
3274     MediaList* list = new MediaList;
3275     m_parsedStyleObjects.append(list);
3276     return list;
3277 }
3278
3279 CSSRule* CSSParser::createCharsetRule(const ParseString& charset)
3280 {
3281     if (!styleElement)
3282         return 0;
3283     if (!styleElement->isCSSStyleSheet())
3284         return 0;
3285     CSSCharsetRule* rule = new CSSCharsetRule(styleElement, domString(charset));
3286     m_parsedStyleObjects.append(rule);
3287     return rule;
3288 }
3289
3290 CSSRule* CSSParser::createImportRule(const ParseString& URL, MediaList* media)
3291 {
3292     if (!media)
3293         return 0;
3294     if (!styleElement)
3295         return 0;
3296     if (!styleElement->isCSSStyleSheet())
3297         return 0;
3298     CSSImportRule* rule = new CSSImportRule(styleElement, domString(URL), media);
3299     m_parsedStyleObjects.append(rule);
3300     return rule;
3301 }
3302
3303 CSSRule* CSSParser::createMediaRule(MediaList* media, CSSRuleList* rules)
3304 {
3305     if (!media)
3306         return 0;
3307     if (!rules)
3308         return 0;
3309     if (!styleElement)
3310         return 0;
3311     if (!styleElement->isCSSStyleSheet())
3312         return 0;
3313     CSSMediaRule* rule = new CSSMediaRule(styleElement, media, rules);
3314     m_parsedStyleObjects.append(rule);
3315     return rule;
3316 }
3317
3318 CSSRuleList* CSSParser::createRuleList()
3319 {
3320     CSSRuleList* list = new CSSRuleList;
3321     m_parsedRuleLists.append(list);
3322     return list;
3323 }
3324
3325 CSSRule* CSSParser::createStyleRule(CSSSelector* selector)
3326 {
3327     CSSStyleRule* rule = 0;
3328     if (selector) {
3329         rule = new CSSStyleRule(styleElement);
3330         m_parsedStyleObjects.append(rule);
3331         rule->setSelector(sinkFloatingSelector(selector));
3332         rule->setDeclaration(new CSSMutableStyleDeclaration(rule, parsedProperties, numParsedProperties));
3333     }
3334     clearProperties();
3335     return rule;
3336 }
3337
3338 DeprecatedString deprecatedString(const ParseString& ps)
3339 {
3340     return DeprecatedString(reinterpret_cast<const DeprecatedChar*>(ps.characters), ps.length);
3341 }
3342
3343 #define YY_DECL int CSSParser::lex()
3344 #define yyconst const
3345 typedef int yy_state_type;
3346 typedef unsigned YY_CHAR;
3347 // this line makes sure we treat all Unicode chars correctly.
3348 #define YY_SC_TO_UI(c) (c > 0xff ? 0xff : c)
3349 #define YY_DO_BEFORE_ACTION \
3350         yytext = yy_bp; \
3351         yyleng = (int) (yy_cp - yy_bp); \
3352         yy_hold_char = *yy_cp; \
3353         *yy_cp = 0; \
3354         yy_c_buf_p = yy_cp;
3355 #define YY_BREAK break;
3356 #define ECHO
3357 #define YY_RULE_SETUP
3358 #define INITIAL 0
3359 #define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)
3360 #define yyterminate() yyTok = END_TOKEN; return yyTok
3361 #define YY_FATAL_ERROR(a)
3362 // The line below is needed to build the tokenizer with conditon stack.
3363 // The macro is used in the tokenizer grammar with lines containing
3364 // BEGIN(mediaqueries) and BEGIN(initial). yy_start acts as index to
3365 // tokenizer transition table, and 'mediaqueries' and 'initial' are
3366 // offset multipliers that specify which transitions are active
3367 // in the tokenizer during in each condition (tokenizer state)
3368 #define BEGIN yy_start = 1 + 2 *
3369
3370 #include "tokenizer.cpp"
3371
3372 }