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