WebCore/css/CSSGrammar.y

   1 %{
   2
   3 /*
   4  *  This file is part of the KDE libraries
   5  *  Copyright (C) 2002-2003 Lars Knoll (knoll@kde.org)
   6  *  Copyright (C) 2004, 2005, 2006 Apple Computer, Inc.
   7  *  Copyright (C) 2006 Alexey Proskuryakov (ap@nypop.com)
   8  *
   9  *  This library is free software; you can redistribute it and/or
  10  *  modify it under the terms of the GNU Lesser General Public
  11  *  License as published by the Free Software Foundation; either
  12  *  version 2 of the License, or (at your option) any later version.
  13  *
  14  *  This library is distributed in the hope that it will be useful,
  15  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  17  *  Lesser General Public License for more details.
  18  *
  19  *  You should have received a copy of the GNU Lesser General Public
  20  *  License along with this library; if not, write to the Free Software
  21  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  22  *
  23  */
  24
  25 #include "config.h"
  26
  27 #include "CSSMediaRule.h"
  28 #include "CSSPrimitiveValue.h"
  29 #include "CSSRule.h"
  30 #include "CSSRuleList.h"
  31 #include "CSSSelector.h"
  32 #include "CSSStyleSheet.h"
  33 #include "Document.h"
  34 #include "HTMLNames.h"
  35 #include "MediaList.h"
  36 #include "MediaQuery.h"
  37 #include "MediaQueryExp.h"
  38 #include "PlatformString.h"
  39 #include "cssparser.h"
  40 #include <assert.h>
  41 #include <stdlib.h>
  42 #include <string.h>
  43
  44 #ifdef SVG_SUPPORT
  45 #include "ksvgcssproperties.h"
  46 #include "ksvgcssvalues.h"
  47 #endif
  48
  49 using namespace WebCore;
  50 using namespace HTMLNames;
  51
  52 // The following file defines the function
  53 //     const struct props *findProp(const char *word, int len)
  54 //
  55 // with 'props->id' a CSS property in the range from CSS_PROP_MIN to
  56 // (and including) CSS_PROP_TOTAL-1
  57
  58 #include "CSSPropertyNames.c"
  59 #include "CSSValueKeywords.c"
  60
  61 namespace WebCore {
  62
  63 int getPropertyID(const char* tagStr, int len)
  64 {
  65     DeprecatedString prop;
  66
  67     if (len && tagStr[0] == '-') {
  68         prop = DeprecatedString(tagStr, len);
  69         if (prop.startsWith("-apple-")) {
  70             prop = "-webkit-" + prop.mid(7);
  71             tagStr = prop.ascii();
  72             len++;
  73         } else if (prop.startsWith("-khtml-")) {
  74             prop = "-webkit-" + prop.mid(7);
  75             len++;
  76             tagStr = prop.ascii();
  77         }
  78
  79         // Honor the use of old-style opacity (for Safari 1.1).
  80         if (prop == "-webkit-opacity") {
  81             const char * const opacity = "opacity";
  82             tagStr = opacity;
  83             len = strlen(opacity);
  84         }
  85     }
  86
  87     const struct props* propsPtr = findProp(tagStr, len);
  88     if (!propsPtr)
  89         return 0;
  90
  91     return propsPtr->id;
  92 }
  93
  94 }
  95
  96 static inline int getValueID(const char* tagStr, int len)
  97 {
  98     DeprecatedString prop;
  99     if (len && tagStr[0] == '-') {
 100         prop = DeprecatedString(tagStr, len);
 101         if (prop.startsWith("-apple-")) {
 102             prop = "-webkit-" + prop.mid(7);
 103             tagStr = prop.ascii();
 104             len++;
 105         } else if (prop.startsWith("-khtml-")) {
 106             prop = "-webkit-" + prop.mid(7);
 107             len++;
 108             tagStr = prop.ascii();
 109         }
 110     }
 111
 112     const struct css_value *val = findValue(tagStr, len);
 113     if (!val)
 114         return 0;
 115
 116     return val->id;
 117 }
 118
 119 #define YYENABLE_NLS 0
 120 #define YYLTYPE_IS_TRIVIAL 1
 121 #define YYMAXDEPTH 10000
 122 #define YYDEBUG 0
 123 #define YYPARSE_PARAM parser
 124
 125 %}
 126
 127 %pure_parser
 128
 129 %union {
 130     CSSRule* rule;
 131     CSSSelector* selector;
 132     bool ok;
 133     MediaList *mediaList;
 134     CSSMediaRule* mediaRule;
 135     CSSRuleList* ruleList;
 136     ParseString string;
 137     float val;
 138     int prop_id;
 139     int attribute;
 140     CSSSelector::Relation relation;
 141     bool b;
 142     int i;
 143     char tok;
 144     Value value;
 145     ValueList* valueList;
 146
 147     MediaQuery* mediaQuery;
 148     MediaQueryExp* mediaQueryExp;
 149     Vector<MediaQueryExp*>* mediaQueryExpList;
 150     MediaQuery::Restrictor mediaQueryRestrictor;
 151 }
 152
 153 %{
 154
 155 static inline int cssyyerror(const char *) { return 1; }
 156 static int cssyylex(YYSTYPE *yylval) { return CSSParser::current()->lex(yylval); }
 157
 158 %}
 159
 160 //%expect 37
 161
 162 %left UNIMPORTANT_TOK
 163
 164 %token WHITESPACE SGML_CD
 165
 166 %token INCLUDES
 167 %token DASHMATCH
 168 %token BEGINSWITH
 169 %token ENDSWITH
 170 %token CONTAINS
 171
 172 %token <string> STRING
 173
 174 %right <string> IDENT
 175
 176 %nonassoc <string> HASH
 177 %nonassoc ':'
 178 %nonassoc '.'
 179 %nonassoc '['
 180 %nonassoc <string> '*'
 181 %nonassoc error
 182 %left '|'
 183
 184 %token IMPORT_SYM
 185 %token PAGE_SYM
 186 %token MEDIA_SYM
 187 %token FONT_FACE_SYM
 188 %token CHARSET_SYM
 189 %token NAMESPACE_SYM
 190 %token WEBKIT_RULE_SYM
 191 %token WEBKIT_DECLS_SYM
 192 %token WEBKIT_VALUE_SYM
 193 %token WEBKIT_MEDIAQUERY_SYM
 194
 195 %token IMPORTANT_SYM
 196 %token MEDIA_ONLY
 197 %token MEDIA_NOT
 198 %token MEDIA_AND
 199
 200 %token <val> QEMS
 201 %token <val> EMS
 202 %token <val> EXS
 203 %token <val> PXS
 204 %token <val> CMS
 205 %token <val> MMS
 206 %token <val> INS
 207 %token <val> PTS
 208 %token <val> PCS
 209 %token <val> DEGS
 210 %token <val> RADS
 211 %token <val> GRADS
 212 %token <val> MSECS
 213 %token <val> SECS
 214 %token <val> HERZ
 215 %token <val> KHERZ
 216 %token <string> DIMEN
 217 %token <val> PERCENTAGE
 218 %token <val> FLOAT
 219 %token <val> INTEGER
 220
 221 %token <string> URI
 222 %token <string> FUNCTION
 223 %token <string> NOTFUNCTION
 224
 225 %token <string> UNICODERANGE
 226
 227 %type <relation> combinator
 228
 229 %type <rule> charset
 230 %type <rule> ruleset
 231 %type <rule> ruleset_or_import
 232 %type <rule> media
 233 %type <rule> import
 234 %type <rule> page
 235 %type <rule> font_face
 236 %type <rule> invalid_rule
 237 %type <rule> invalid_at
 238 %type <rule> invalid_import
 239 %type <rule> rule
 240
 241 %type <string> maybe_ns_prefix
 242
 243 %type <string> namespace_selector
 244
 245 %type <string> string_or_uri
 246 %type <string> ident_or_string
 247 %type <string> medium
 248 %type <string> hexcolor
 249
 250 %type <string> media_feature
 251 %type <mediaList> media_list
 252 %type <mediaList> maybe_media_list
 253 %type <mediaQuery> media_query
 254 %type <mediaQueryRestrictor> maybe_media_restrictor
 255 %type <valueList> maybe_media_value
 256 %type <mediaQueryExp> media_query_exp
 257 %type <mediaQueryExpList> media_query_exp_list
 258 %type <mediaQueryExpList> maybe_media_query_exp_list
 259
 260 %type <ruleList> ruleset_list
 261
 262 %type <prop_id> property
 263
 264 %type <selector> specifier
 265 %type <selector> specifier_list
 266 %type <selector> simple_selector
 267 %type <selector> selector
 268 %type <selector> selector_list
 269 %type <selector> class
 270 %type <selector> attrib
 271 %type <selector> pseudo
 272
 273 %type <ok> declaration_list
 274 %type <ok> decl_list
 275 %type <ok> declaration
 276
 277 %type <b> prio
 278
 279 %type <i> match
 280 %type <i> unary_operator
 281 %type <tok> operator
 282
 283 %type <valueList> expr
 284 %type <value> term
 285 %type <value> unary_term
 286 %type <value> function
 287
 288 %type <string> element_name
 289 %type <string> attr_name
 290
 291 %%
 292
 293 stylesheet:
 294     maybe_charset maybe_sgml import_list namespace_list rule_list
 295   | webkit_rule maybe_space
 296   | webkit_decls maybe_space
 297   | webkit_value maybe_space
 298   | webkit_mediaquery maybe_space
 299   ;
 300
 301 ruleset_or_import:
 302    ruleset |
 303    import
 304 ;
 305
 306 webkit_rule:
 307     WEBKIT_RULE_SYM '{' maybe_space ruleset_or_import maybe_space '}' {
 308         static_cast<CSSParser*>(parser)->rule = $4;
 309     }
 310 ;
 311
 312 webkit_decls:
 313     WEBKIT_DECLS_SYM '{' maybe_space declaration_list '}' {
 314         /* can be empty */
 315     }
 316 ;
 317
 318 webkit_value:
 319     WEBKIT_VALUE_SYM '{' maybe_space expr '}' {
 320         CSSParser *p = static_cast<CSSParser *>(parser);
 321         if ($4) {
 322             p->valueList = p->sinkFloatingValueList($4);
 323             int oldParsedProperties = p->numParsedProperties;
 324             if (!p->parseValue(p->id, p->important))
 325                 p->rollbackLastProperties(p->numParsedProperties - oldParsedProperties);
 326             delete p->valueList;
 327             p->valueList = 0;
 328         }
 329     }
 330 ;
 331
 332 webkit_mediaquery:
 333      WEBKIT_MEDIAQUERY_SYM WHITESPACE maybe_space media_query '}' {
 334          CSSParser* p = static_cast<CSSParser*>(parser);
 335          p->mediaQuery = p->sinkFloatingMediaQuery($4);
 336      }
 337 ;
 338
 339 maybe_space:
 340     /* empty */ %prec UNIMPORTANT_TOK
 341   | maybe_space WHITESPACE
 342   ;
 343
 344 maybe_sgml:
 345     /* empty */
 346   | maybe_sgml SGML_CD
 347   | maybe_sgml WHITESPACE
 348   ;
 349
 350 maybe_charset:
 351    /* empty */
 352   | charset {
 353   }
 354 ;
 355
 356 charset:
 357   CHARSET_SYM maybe_space STRING maybe_space ';' {
 358      CSSParser* p = static_cast<CSSParser*>(parser);
 359      $$ = static_cast<CSSParser *>(parser)->createCharsetRule($3);
 360      if ($$ && p->styleElement && p->styleElement->isCSSStyleSheet())
 361          p->styleElement->append($$);
 362   }
 363   | CHARSET_SYM error invalid_block {
 364   }
 365   | CHARSET_SYM error ';' {
 366   }
 367 ;
 368
 369 import_list:
 370  /* empty */
 371  | import_list import maybe_sgml {
 372      CSSParser* p = static_cast<CSSParser*>(parser);
 373      if ($2 && p->styleElement && p->styleElement->isCSSStyleSheet())
 374          p->styleElement->append($2);
 375  }
 376  ;
 377
 378 namespace_list:
 379 /* empty */
 380 | namespace_list namespace maybe_sgml
 381 ;
 382
 383 rule_list:
 384    /* empty */
 385  | rule_list rule maybe_sgml {
 386      CSSParser* p = static_cast<CSSParser*>(parser);
 387      if ($2 && p->styleElement && p->styleElement->isCSSStyleSheet())
 388          p->styleElement->append($2);
 389  }
 390  ;
 391
 392 rule:
 393     ruleset
 394   | media
 395   | page
 396   | font_face
 397   | invalid_rule
 398   | invalid_at
 399   | invalid_import
 400     ;
 401
 402 import:
 403     IMPORT_SYM maybe_space string_or_uri maybe_space maybe_media_list ';' {
 404         $$ = static_cast<CSSParser *>(parser)->createImportRule($3, $5);
 405     }
 406   | IMPORT_SYM error invalid_block {
 407         $$ = 0;
 408     }
 409   | IMPORT_SYM error ';' {
 410         $$ = 0;
 411     }
 412   ;
 413
 414 namespace:
 415 NAMESPACE_SYM maybe_space maybe_ns_prefix string_or_uri maybe_space ';' {
 416     CSSParser *p = static_cast<CSSParser *>(parser);
 417     if (p->styleElement && p->styleElement->isCSSStyleSheet())
 418         static_cast<CSSStyleSheet*>(p->styleElement)->addNamespace(p, atomicString($3), atomicString($4));
 419 }
 420 | NAMESPACE_SYM error invalid_block
 421 | NAMESPACE_SYM error ';'
 422 ;
 423
 424 maybe_ns_prefix:
 425 /* empty */ { $$.characters = 0; }
 426 | IDENT WHITESPACE { $$ = $1; }
 427 ;
 428
 429 string_or_uri:
 430 STRING
 431 | URI
 432 ;
 433
 434 media_feature:
 435     IDENT maybe_space {
 436         $$ = $1;
 437     }
 438     ;
 439
 440 maybe_media_value:
 441     /*empty*/ {
 442         $$ = 0;
 443     }
 444     | ':' maybe_space expr maybe_space {
 445         $$ = $3;
 446     }
 447     ;
 448
 449 media_query_exp:
 450     MEDIA_AND maybe_space '(' maybe_space media_feature maybe_space maybe_media_value ')' maybe_space {
 451         $5.lower();
 452         $$ = static_cast<CSSParser*>(parser)->createFloatingMediaQueryExp(atomicString($5), $7);
 453     }
 454     ;
 455
 456 media_query_exp_list:
 457     media_query_exp {
 458       CSSParser* p = static_cast<CSSParser*>(parser);
 459       $$ = p->createFloatingMediaQueryExpList();
 460       $$->append(p->sinkFloatingMediaQueryExp($1));
 461     }
 462     | media_query_exp_list media_query_exp {
 463       $$ = $1;
 464       $$->append(static_cast<CSSParser*>(parser)->sinkFloatingMediaQueryExp($2));
 465     }
 466     ;
 467
 468 maybe_media_query_exp_list:
 469     /*empty*/ {
 470         $$ = static_cast<CSSParser*>(parser)->createFloatingMediaQueryExpList();
 471     }
 472     | media_query_exp_list
 473     ;
 474
 475 maybe_media_restrictor:
 476     /*empty*/ {
 477         $$ = MediaQuery::None;
 478     }
 479     | MEDIA_ONLY {
 480         $$ = MediaQuery::Only;
 481     }
 482     | MEDIA_NOT {
 483         $$ = MediaQuery::Not;
 484     }
 485     ;
 486
 487 media_query:
 488     maybe_media_restrictor maybe_space medium maybe_media_query_exp_list {
 489         CSSParser* p = static_cast<CSSParser*>(parser);
 490         $3.lower();
 491         $$ = p->createFloatingMediaQuery($1, domString($3), p->sinkFloatingMediaQueryExpList($4));
 492     }
 493     ;
 494
 495 maybe_media_list:
 496      /* empty */ {
 497         $$ = static_cast<CSSParser*>(parser)->createMediaList();
 498      }
 499      | media_list
 500      ;
 501
 502 media_list:
 503     media_query {
 504         CSSParser* p = static_cast<CSSParser*>(parser);
 505         $$ = p->createMediaList();
 506         $$->appendMediaQuery(p->sinkFloatingMediaQuery($1));
 507     }
 508     | media_list ',' maybe_space media_query {
 509         $$ = $1;
 510         if ($$)
 511             $$->appendMediaQuery(static_cast<CSSParser*>(parser)->sinkFloatingMediaQuery($4));
 512     }
 513     | media_list error {
 514         $$ = 0;
 515     }
 516     ;
 517
 518 media:
 519     MEDIA_SYM maybe_space media_list '{' maybe_space ruleset_list '}' {
 520         $$ = static_cast<CSSParser*>(parser)->createMediaRule($3, $6);
 521     }
 522     | MEDIA_SYM maybe_space '{' maybe_space ruleset_list '}' {
 523         $$ = static_cast<CSSParser*>(parser)->createMediaRule(0, $5);
 524     }
 525     ;
 526
 527 ruleset_list:
 528     /* empty */ { $$ = 0; }
 529     | ruleset_list ruleset maybe_space {
 530         $$ = $1;
 531         if ($2) {
 532             if (!$$)
 533                 $$ = static_cast<CSSParser*>(parser)->createRuleList();
 534             $$->append($2);
 535         }
 536     }
 537     ;
 538
 539 medium:
 540   IDENT maybe_space {
 541       $$ = $1;
 542   }
 543   ;
 544
 545 /*
 546 page:
 547     PAGE_SYM maybe_space IDENT? pseudo_page? maybe_space
 548     '{' maybe_space declaration [ ';' maybe_space declaration ]* '}' maybe_space
 549   ;
 550
 551 pseudo_page
 552   : ':' IDENT
 553   ;
 554
 555 font_face
 556   : FONT_FACE_SYM maybe_space
 557     '{' maybe_space declaration [ ';' maybe_space declaration ]* '}' maybe_space
 558   ;
 559 */
 560
 561 page:
 562     PAGE_SYM error invalid_block {
 563       $$ = 0;
 564     }
 565   | PAGE_SYM error ';' {
 566       $$ = 0;
 567     }
 568     ;
 569
 570 font_face:
 571     FONT_FACE_SYM error invalid_block {
 572       $$ = 0;
 573     }
 574   | FONT_FACE_SYM error ';' {
 575       $$ = 0;
 576     }
 577 ;
 578
 579 combinator:
 580     '+' maybe_space { $$ = CSSSelector::DirectAdjacent; }
 581   | '~' maybe_space { $$ = CSSSelector::IndirectAdjacent; }
 582   | '>' maybe_space { $$ = CSSSelector::Child; }
 583   | /* empty */ { $$ = CSSSelector::Descendant; }
 584   ;
 585
 586 unary_operator:
 587     '-' { $$ = -1; }
 588   | '+' { $$ = 1; }
 589   ;
 590
 591 ruleset:
 592     selector_list '{' maybe_space declaration_list '}' {
 593         $$ = static_cast<CSSParser*>(parser)->createStyleRule($1);
 594     }
 595   ;
 596
 597 selector_list:
 598     selector %prec UNIMPORTANT_TOK {
 599         $$ = $1;
 600     }
 601     | selector_list ',' maybe_space selector %prec UNIMPORTANT_TOK {
 602         if ($1 && $4) {
 603             CSSParser* p = static_cast<CSSParser*>(parser);
 604             $$ = $1;
 605             $$->append(p->sinkFloatingSelector($4));
 606         } else {
 607             $$ = 0;
 608         }
 609     }
 610   | selector_list error {
 611         $$ = 0;
 612     }
 613    ;
 614
 615 selector:
 616     simple_selector {
 617         $$ = $1;
 618     }
 619     | selector combinator simple_selector {
 620         $$ = $3;
 621         if (!$1) {
 622             $$ = 0;
 623         }
 624         else if ($$) {
 625             CSSParser* p = static_cast<CSSParser*>(parser);
 626             CSSSelector* end = $$;
 627             while (end->tagHistory)
 628                 end = end->tagHistory;
 629             end->m_relation = $2;
 630             end->tagHistory = p->sinkFloatingSelector($1);
 631             if ($2 == CSSSelector::Descendant || $2 == CSSSelector::Child) {
 632                 if (Document* doc = p->document())
 633                     doc->setUsesDescendantRules(true);
 634             } else if ($2 == CSSSelector::DirectAdjacent || $2 == CSSSelector::IndirectAdjacent) {
 635                 if (Document* doc = p->document())
 636                     doc->setUsesSiblingRules(true);
 637             }
 638         }
 639     }
 640     | selector error {
 641         $$ = 0;
 642     }
 643     ;
 644
 645 namespace_selector:
 646     /* empty */ '|' { $$.characters = 0; $$.length = 0; }
 647     | '*' '|' { static UChar star = '*'; $$.characters = &star; $$.length = 1; }
 648     | IDENT '|' { $$ = $1; }
 649 ;
 650
 651 simple_selector:
 652     element_name maybe_space {
 653         CSSParser *p = static_cast<CSSParser *>(parser);
 654         $$ = p->createFloatingSelector();
 655         $$->tag = QualifiedName(nullAtom, atomicString($1), p->defaultNamespace);
 656     }
 657     | element_name specifier_list maybe_space {
 658         $$ = $2;
 659         if ($$) {
 660             CSSParser *p = static_cast<CSSParser *>(parser);
 661             $$->tag = QualifiedName(nullAtom, atomicString($1), p->defaultNamespace);
 662         }
 663     }
 664     | specifier_list maybe_space {
 665         $$ = $1;
 666         CSSParser *p = static_cast<CSSParser *>(parser);
 667         if ($$ && p->defaultNamespace != starAtom)
 668             $$->tag = QualifiedName(nullAtom, starAtom, p->defaultNamespace);
 669     }
 670     | namespace_selector element_name maybe_space {
 671         AtomicString namespacePrefix = atomicString($1);
 672         CSSParser *p = static_cast<CSSParser *>(parser);
 673         $$ = p->createFloatingSelector();
 674         if (p->styleElement && p->styleElement->isCSSStyleSheet())
 675             $$->tag = QualifiedName(namespacePrefix,
 676                                     atomicString($2),
 677                                     static_cast<CSSStyleSheet*>(p->styleElement)->determineNamespace(namespacePrefix));
 678         else // FIXME: Shouldn't this case be an error?
 679             $$->tag = QualifiedName(nullAtom, atomicString($2), p->defaultNamespace);
 680     }
 681     | namespace_selector element_name specifier_list maybe_space {
 682         $$ = $3;
 683         if ($$) {
 684             AtomicString namespacePrefix = atomicString($1);
 685             CSSParser *p = static_cast<CSSParser *>(parser);
 686             if (p->styleElement && p->styleElement->isCSSStyleSheet())
 687                 $$->tag = QualifiedName(namespacePrefix,
 688                                         atomicString($2),
 689                                         static_cast<CSSStyleSheet*>(p->styleElement)->determineNamespace(namespacePrefix));
 690             else // FIXME: Shouldn't this case be an error?
 691                 $$->tag = QualifiedName(nullAtom, atomicString($2), p->defaultNamespace);
 692         }
 693     }
 694     | namespace_selector specifier_list maybe_space {
 695         $$ = $2;
 696         if ($$) {
 697             AtomicString namespacePrefix = atomicString($1);
 698             CSSParser *p = static_cast<CSSParser *>(parser);
 699             if (p->styleElement && p->styleElement->isCSSStyleSheet())
 700                 $$->tag = QualifiedName(namespacePrefix,
 701                                         starAtom,
 702                                         static_cast<CSSStyleSheet*>(p->styleElement)->determineNamespace(namespacePrefix));
 703         }
 704     }
 705   ;
 706
 707 element_name:
 708     IDENT {
 709         ParseString& str = $1;
 710         CSSParser *p = static_cast<CSSParser *>(parser);
 711         Document *doc = p->document();
 712         if (doc && doc->isHTMLDocument())
 713             str.lower();
 714         $$ = str;
 715     }
 716     | '*' {
 717         static UChar star = '*';
 718         $$.characters = &star;
 719         $$.length = 1;
 720     }
 721   ;
 722
 723 specifier_list:
 724     specifier {
 725         $$ = $1;
 726     }
 727     | specifier_list specifier {
 728         $$ = $1;
 729         if ($$) {
 730             CSSParser* p = static_cast<CSSParser*>(parser);
 731             CSSSelector* end = $1;
 732             while (end->tagHistory)
 733                 end = end->tagHistory;
 734             end->m_relation = CSSSelector::SubSelector;
 735             end->tagHistory = p->sinkFloatingSelector($2);
 736         }
 737     }
 738     | specifier_list error {
 739         $$ = 0;
 740     }
 741 ;
 742
 743 specifier:
 744     HASH {
 745         CSSParser *p = static_cast<CSSParser *>(parser);
 746         $$ = p->createFloatingSelector();
 747         $$->match = CSSSelector::Id;
 748         if (!p->strict)
 749             $1.lower();
 750         $$->attr = idAttr;
 751         $$->value = atomicString($1);
 752     }
 753   | class
 754   | attrib
 755   | pseudo
 756     ;
 757
 758 class:
 759     '.' IDENT {
 760         CSSParser *p = static_cast<CSSParser *>(parser);
 761         $$ = p->createFloatingSelector();
 762         $$->match = CSSSelector::Class;
 763         if (!p->strict)
 764             $2.lower();
 765         $$->attr = classAttr;
 766         $$->value = atomicString($2);
 767     }
 768   ;
 769
 770 attr_name:
 771     IDENT maybe_space {
 772         ParseString& str = $1;
 773         CSSParser *p = static_cast<CSSParser *>(parser);
 774         Document *doc = p->document();
 775         if (doc && doc->isHTMLDocument())
 776             str.lower();
 777         $$ = str;
 778     }
 779     ;
 780
 781 attrib:
 782     '[' maybe_space attr_name ']' {
 783         $$ = static_cast<CSSParser*>(parser)->createFloatingSelector();
 784         $$->attr = QualifiedName(nullAtom, atomicString($3), nullAtom);
 785         $$->match = CSSSelector::Set;
 786     }
 787     | '[' maybe_space attr_name match maybe_space ident_or_string maybe_space ']' {
 788         $$ = static_cast<CSSParser*>(parser)->createFloatingSelector();
 789         $$->attr = QualifiedName(nullAtom, atomicString($3), nullAtom);
 790         $$->match = (CSSSelector::Match)$4;
 791         $$->value = atomicString($6);
 792     }
 793     | '[' maybe_space namespace_selector attr_name ']' {
 794         AtomicString namespacePrefix = atomicString($3);
 795         CSSParser *p = static_cast<CSSParser *>(parser);
 796         $$ = p->createFloatingSelector();
 797         $$->attr = QualifiedName(namespacePrefix,
 798                                  atomicString($4),
 799                                  static_cast<CSSStyleSheet*>(p->styleElement)->determineNamespace(namespacePrefix));
 800         $$->match = CSSSelector::Set;
 801     }
 802     | '[' maybe_space namespace_selector attr_name match maybe_space ident_or_string maybe_space ']' {
 803         AtomicString namespacePrefix = atomicString($3);
 804         CSSParser *p = static_cast<CSSParser *>(parser);
 805         $$ = p->createFloatingSelector();
 806         $$->attr = QualifiedName(namespacePrefix,
 807                                  atomicString($4),
 808                                  static_cast<CSSStyleSheet*>(p->styleElement)->determineNamespace(namespacePrefix));
 809         $$->match = (CSSSelector::Match)$5;
 810         $$->value = atomicString($7);
 811     }
 812   ;
 813
 814 match:
 815     '=' {
 816         $$ = CSSSelector::Exact;
 817     }
 818     | INCLUDES {
 819         $$ = CSSSelector::List;
 820     }
 821     | DASHMATCH {
 822         $$ = CSSSelector::Hyphen;
 823     }
 824     | BEGINSWITH {
 825         $$ = CSSSelector::Begin;
 826     }
 827     | ENDSWITH {
 828         $$ = CSSSelector::End;
 829     }
 830     | CONTAINS {
 831         $$ = CSSSelector::Contain;
 832     }
 833     ;
 834
 835 ident_or_string:
 836     IDENT
 837   | STRING
 838     ;
 839
 840 pseudo:
 841     ':' IDENT {
 842         $$ = static_cast<CSSParser*>(parser)->createFloatingSelector();
 843         $$->match = CSSSelector::PseudoClass;
 844         $2.lower();
 845         $$->value = atomicString($2);
 846         if ($$->value == "empty" || $$->value == "only-child" ||
 847             $$->value == "first-child" || $$->value == "last-child") {
 848             CSSParser *p = static_cast<CSSParser *>(parser);
 849             Document *doc = p->document();
 850             if (doc)
 851                 doc->setUsesSiblingRules(true);
 852         }
 853     }
 854     | ':' ':' IDENT {
 855         $$ = static_cast<CSSParser*>(parser)->createFloatingSelector();
 856         $$->match = CSSSelector::PseudoElement;
 857         $3.lower();
 858         $$->value = atomicString($3);
 859     }
 860     // used by :lang
 861     | ':' FUNCTION IDENT ')' {
 862         $$ = static_cast<CSSParser*>(parser)->createFloatingSelector();
 863         $$->match = CSSSelector::PseudoClass;
 864         $$->argument = atomicString($3);
 865         $2.lower();
 866         $$->value = atomicString($2);
 867     }
 868     // used by :not
 869     | ':' NOTFUNCTION maybe_space simple_selector ')' {
 870         CSSParser* p = static_cast<CSSParser*>(parser);
 871         $$ = p->createFloatingSelector();
 872         $$->match = CSSSelector::PseudoClass;
 873         $$->simpleSelector = p->sinkFloatingSelector($4);
 874         $2.lower();
 875         $$->value = atomicString($2);
 876     }
 877   ;
 878
 879 declaration_list:
 880     declaration {
 881         $$ = $1;
 882     }
 883     | decl_list declaration {
 884         $$ = $1;
 885         if ( $2 )
 886             $$ = $2;
 887     }
 888     | decl_list {
 889         $$ = $1;
 890     }
 891     | error invalid_block_list error {
 892         $$ = false;
 893     }
 894     | error {
 895         $$ = false;
 896     }
 897     | decl_list error {
 898         $$ = $1;
 899     }
 900     ;
 901
 902 decl_list:
 903     declaration ';' maybe_space {
 904         $$ = $1;
 905     }
 906     | declaration invalid_block_list ';' maybe_space {
 907         $$ = false;
 908     }
 909     | error ';' maybe_space {
 910         $$ = false;
 911     }
 912     | error invalid_block_list error ';' maybe_space {
 913         $$ = false;
 914     }
 915     | decl_list declaration ';' maybe_space {
 916         $$ = $1;
 917         if ( $2 )
 918             $$ = $2;
 919     }
 920     | decl_list error ';' maybe_space {
 921         $$ = $1;
 922     }
 923     | decl_list error invalid_block_list error ';' maybe_space {
 924         $$ = $1;
 925     }
 926     ;
 927
 928 declaration:
 929     property ':' maybe_space expr prio {
 930         $$ = false;
 931         CSSParser *p = static_cast<CSSParser *>(parser);
 932         if ($1 && $4) {
 933             p->valueList = p->sinkFloatingValueList($4);
 934             int oldParsedProperties = p->numParsedProperties;
 935             $$ = p->parseValue($1, $5);
 936             if (!$$)
 937                 p->rollbackLastProperties(p->numParsedProperties - oldParsedProperties);
 938             delete p->valueList;
 939             p->valueList = 0;
 940         }
 941     }
 942     |
 943     property error {
 944         $$ = false;
 945     }
 946     |
 947     property ':' maybe_space error expr prio {
 948         /* The default movable type template has letter-spacing: .none;  Handle this by looking for
 949         error tokens at the start of an expr, recover the expr and then treat as an error, cleaning
 950         up and deleting the shifted expr.  */
 951         $$ = false;
 952     }
 953     |
 954     IMPORTANT_SYM maybe_space {
 955         /* Handle this case: div { text-align: center; !important } Just reduce away the stray !important. */
 956         $$ = false;
 957     }
 958     |
 959     property ':' maybe_space {
 960         /* div { font-family: } Just reduce away this property with no value. */
 961         $$ = false;
 962     }
 963   ;
 964
 965 property:
 966     IDENT maybe_space {
 967         $1.lower();
 968         DeprecatedString str = deprecatedString($1);
 969         const char* s = str.ascii();
 970         int l = str.length();
 971         $$ = getPropertyID(s, l);
 972 #ifdef SVG_SUPPORT
 973         if ($$ == 0)
 974             $$ = SVG::getSVGCSSPropertyID(s, l);
 975 #endif
 976     }
 977   ;
 978
 979 prio:
 980     IMPORTANT_SYM maybe_space { $$ = true; }
 981     | /* empty */ { $$ = false; }
 982   ;
 983
 984 expr:
 985     term {
 986         CSSParser* p = static_cast<CSSParser*>(parser);
 987         $$ = p->createFloatingValueList();
 988         $$->addValue(p->sinkFloatingValue($1));
 989     }
 990     | expr operator term {
 991         CSSParser* p = static_cast<CSSParser*>(parser);
 992         $$ = $1;
 993         if ($$) {
 994             if ($2) {
 995                 Value v;
 996                 v.id = 0;
 997                 v.unit = Value::Operator;
 998                 v.iValue = $2;
 999                 $$->addValue(v);
1000             }
1001             $$->addValue(p->sinkFloatingValue($3));
1002         }
1003     }
1004     | expr error {
1005         $$ = 0;
1006     }
1007   ;
1008
1009 operator:
1010     '/' maybe_space {
1011         $$ = '/';
1012     }
1013   | ',' maybe_space {
1014         $$ = ',';
1015     }
1016   | /* empty */ {
1017         $$ = 0;
1018   }
1019   ;
1020
1021 term:
1022   unary_term { $$ = $1; }
1023   | unary_operator unary_term { $$ = $2; $$.fValue *= $1; }
1024   | STRING maybe_space { $$.id = 0; $$.string = $1; $$.unit = CSSPrimitiveValue::CSS_STRING; }
1025   | IDENT maybe_space {
1026       DeprecatedString str = deprecatedString($1);
1027       $$.id = getValueID(str.lower().latin1(), str.length());
1028 #ifdef SVG_SUPPORT
1029       if ($$.id == 0)
1030           $$.id = SVG::getSVGCSSValueID(str.lower().latin1(), str.length());
1031 #endif
1032       $$.unit = CSSPrimitiveValue::CSS_IDENT;
1033       $$.string = $1;
1034   }
1035   /* We might need to actually parse the number from a dimension, but we can't just put something that uses $$.string into unary_term. */
1036   | DIMEN maybe_space { $$.id = 0; $$.string = $1; $$.unit = CSSPrimitiveValue::CSS_DIMENSION }
1037   | unary_operator DIMEN maybe_space { $$.id = 0; $$.string = $2; $$.unit = CSSPrimitiveValue::CSS_DIMENSION }
1038   | URI maybe_space { $$.id = 0; $$.string = $1; $$.unit = CSSPrimitiveValue::CSS_URI; }
1039   | UNICODERANGE maybe_space { $$.id = 0; $$.iValue = 0; $$.unit = CSSPrimitiveValue::CSS_UNKNOWN;/* ### */ }
1040   | hexcolor { $$.id = 0; $$.string = $1; $$.unit = CSSPrimitiveValue::CSS_RGBCOLOR; }
1041   | '#' maybe_space { $$.id = 0; $$.string = ParseString(); $$.unit = CSSPrimitiveValue::CSS_RGBCOLOR; } /* Handle error case: "color: #;" */
1042 /* ### according to the specs a function can have a unary_operator in front. I know no case where this makes sense */
1043   | function {
1044       $$ = $1;
1045   }
1046   ;
1047
1048 unary_term:
1049   INTEGER maybe_space { $$.id = 0; $$.isInt = true; $$.fValue = $1; $$.unit = CSSPrimitiveValue::CSS_NUMBER; }
1050   | FLOAT maybe_space { $$.id = 0; $$.isInt = false; $$.fValue = $1; $$.unit = CSSPrimitiveValue::CSS_NUMBER; }
1051   | PERCENTAGE maybe_space { $$.id = 0; $$.fValue = $1; $$.unit = CSSPrimitiveValue::CSS_PERCENTAGE; }
1052   | PXS maybe_space { $$.id = 0; $$.fValue = $1; $$.unit = CSSPrimitiveValue::CSS_PX; }
1053   | CMS maybe_space { $$.id = 0; $$.fValue = $1; $$.unit = CSSPrimitiveValue::CSS_CM; }
1054   | MMS maybe_space { $$.id = 0; $$.fValue = $1; $$.unit = CSSPrimitiveValue::CSS_MM; }
1055   | INS maybe_space { $$.id = 0; $$.fValue = $1; $$.unit = CSSPrimitiveValue::CSS_IN; }
1056   | PTS maybe_space { $$.id = 0; $$.fValue = $1; $$.unit = CSSPrimitiveValue::CSS_PT; }
1057   | PCS maybe_space { $$.id = 0; $$.fValue = $1; $$.unit = CSSPrimitiveValue::CSS_PC; }
1058   | DEGS maybe_space { $$.id = 0; $$.fValue = $1; $$.unit = CSSPrimitiveValue::CSS_DEG; }
1059   | RADS maybe_space { $$.id = 0; $$.fValue = $1; $$.unit = CSSPrimitiveValue::CSS_RAD; }
1060   | GRADS maybe_space { $$.id = 0; $$.fValue = $1; $$.unit = CSSPrimitiveValue::CSS_GRAD; }
1061   | MSECS maybe_space { $$.id = 0; $$.fValue = $1; $$.unit = CSSPrimitiveValue::CSS_MS; }
1062   | SECS maybe_space { $$.id = 0; $$.fValue = $1; $$.unit = CSSPrimitiveValue::CSS_S; }
1063   | HERZ maybe_space { $$.id = 0; $$.fValue = $1; $$.unit = CSSPrimitiveValue::CSS_HZ; }
1064   | KHERZ maybe_space { $$.id = 0; $$.fValue = $1; $$.unit = CSSPrimitiveValue::CSS_KHZ; }
1065   | EMS maybe_space { $$.id = 0; $$.fValue = $1; $$.unit = CSSPrimitiveValue::CSS_EMS; }
1066   | QEMS maybe_space { $$.id = 0; $$.fValue = $1; $$.unit = Value::Q_EMS; }
1067   | EXS maybe_space { $$.id = 0; $$.fValue = $1; $$.unit = CSSPrimitiveValue::CSS_EXS; }
1068     ;
1069
1070
1071 function:
1072     FUNCTION maybe_space expr ')' maybe_space {
1073         CSSParser* p = static_cast<CSSParser*>(parser);
1074         Function* f = p->createFloatingFunction();
1075         f->name = $1;
1076         f->args = p->sinkFloatingValueList($3);
1077         $$.id = 0;
1078         $$.unit = Value::Function;
1079         $$.function = f;
1080     } |
1081     FUNCTION maybe_space error {
1082         CSSParser* p = static_cast<CSSParser*>(parser);
1083         Function* f = p->createFloatingFunction();
1084         f->name = $1;
1085         f->args = 0;
1086         $$.id = 0;
1087         $$.unit = Value::Function;
1088         $$.function = f;
1089   }
1090   ;
1091 /*
1092  * There is a constraint on the color that it must
1093  * have either 3 or 6 hex-digits (i.e., [0-9a-fA-F])
1094  * after the "#"; e.g., "#000" is OK, but "#abcd" is not.
1095  */
1096 hexcolor:
1097   HASH maybe_space { $$ = $1; }
1098   ;
1099
1100
1101 /* error handling rules */
1102
1103 invalid_at:
1104     '@' error invalid_block {
1105         $$ = 0;
1106     }
1107   | '@' error ';' {
1108         $$ = 0;
1109     }
1110     ;
1111
1112 invalid_import:
1113     import {
1114         $$ = 0;
1115     }
1116     ;
1117
1118 invalid_rule:
1119     error invalid_block {
1120         $$ = 0;
1121     }
1122 /*
1123   Seems like the two rules below are trying too much and violating
1124   http://www.hixie.ch/tests/evil/mixed/csserrorhandling.html
1125
1126   | error ';' {
1127         $$ = 0;
1128     }
1129   | error '}' {
1130         $$ = 0;
1131     }
1132 */
1133     ;
1134
1135 invalid_block:
1136     '{' error invalid_block_list error '}'
1137   | '{' error '}'
1138     ;
1139
1140 invalid_block_list:
1141     invalid_block
1142   | invalid_block_list error invalid_block
1143 ;
1144
1145 %%