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