1 %{ 2 3 /* 4 * Copyright (C) 2002-2003 Lars Knoll (knoll (at) kde.org) 5 * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012, 2013 Apple Inc. All rights reserved. 6 * Copyright (C) 2006 Alexey Proskuryakov (ap (at) nypop.com) 7 * Copyright (C) 2008 Eric Seidel <eric (at) webkit.org> 8 * Copyright (C) 2012 Intel Corporation. All rights reserved. 9 * 10 * This library is free software; you can redistribute it and/or 11 * modify it under the terms of the GNU Lesser General Public 12 * License as published by the Free Software Foundation; either 13 * version 2 of the License, or (at your option) any later version. 14 * 15 * This library is distributed in the hope that it will be useful, 16 * but WITHOUT ANY WARRANTY; without even the implied warranty of 17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 18 * Lesser General Public License for more details. 19 * 20 * You should have received a copy of the GNU Lesser General Public 21 * License along with this library; if not, write to the Free Software 22 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA 23 * 24 */ 25 26 #include "config.h" 27 28 #include "CSSPropertyNames.h" 29 #include "HTMLNames.h" 30 #include "core/css/CSSKeyframeRule.h" 31 #include "core/css/CSSKeyframesRule.h" 32 #include "core/css/parser/BisonCSSParser.h" 33 #include "core/css/parser/CSSParserMode.h" 34 #include "core/css/CSSPrimitiveValue.h" 35 #include "core/css/CSSSelector.h" 36 #include "core/css/CSSSelectorList.h" 37 #include "core/css/MediaList.h" 38 #include "core/css/MediaQueryExp.h" 39 #include "core/css/StyleRule.h" 40 #include "core/css/StyleSheetContents.h" 41 #include "core/dom/Document.h" 42 #include "wtf/FastMalloc.h" 43 #include <stdlib.h> 44 #include <string.h> 45 46 using namespace blink; 47 using namespace HTMLNames; 48 49 #define YYMALLOC fastMalloc 50 #define YYFREE fastFree 51 52 #define YYENABLE_NLS 0 53 #define YYLTYPE_IS_TRIVIAL 1 54 #define YYMAXDEPTH 10000 55 #define YYDEBUG 0 56 57 #if YYDEBUG > 0 58 #define YYPRINT(File,Type,Value) if (isCSSTokenAString(Type)) YYFPRINTF(File, "%s", String((Value).string).utf8().data()) 59 #endif 60 61 %} 62 63 %pure-parser 64 65 %parse-param { BisonCSSParser* parser } 66 %lex-param { BisonCSSParser* parser } 67 68 %union { 69 bool boolean; 70 char character; 71 int integer; 72 double number; 73 CSSParserString string; 74 75 StyleRuleBase* rule; 76 // The content of the three below HeapVectors are guaranteed to be kept alive by 77 // the corresponding m_parsedRules, m_floatingMediaQueryExpList, and m_parsedKeyFrames 78 // lists in BisonCSSParser.h. 79 WillBeHeapVector<RefPtrWillBeMember<StyleRuleBase> >* ruleList; 80 WillBeHeapVector<OwnPtrWillBeMember<MediaQueryExp> >* mediaQueryExpList; 81 WillBeHeapVector<RefPtrWillBeMember<StyleKeyframe> >* keyframeRuleList; 82 CSSParserSelector* selector; 83 Vector<OwnPtr<CSSParserSelector> >* selectorList; 84 CSSSelector::MarginBoxType marginBox; 85 CSSSelector::Relation relation; 86 CSSSelector::AttributeMatchType attributeMatchType; 87 MediaQuerySet* mediaList; 88 MediaQuery* mediaQuery; 89 MediaQuery::Restrictor mediaQueryRestrictor; 90 MediaQueryExp* mediaQueryExp; 91 CSSParserValue value; 92 CSSParserValueList* valueList; 93 StyleKeyframe* keyframe; 94 float val; 95 CSSPropertyID id; 96 CSSParserLocation location; 97 } 98 99 %{ 100 101 static inline int cssyyerror(void*, const char*) 102 { 103 return 1; 104 } 105 106 #if YYDEBUG > 0 107 static inline bool isCSSTokenAString(int yytype) 108 { 109 switch (yytype) { 110 case IDENT: 111 case STRING: 112 case NTH: 113 case HEX: 114 case IDSEL: 115 case DIMEN: 116 case INVALIDDIMEN: 117 case URI: 118 case FUNCTION: 119 case ANYFUNCTION: 120 case HOSTFUNCTION: 121 case HOSTCONTEXTFUNCTION: 122 case NOTFUNCTION: 123 case CALCFUNCTION: 124 case UNICODERANGE: 125 return true; 126 default: 127 return false; 128 } 129 } 130 #endif 131 132 inline static CSSParserValue makeOperatorValue(int value) 133 { 134 CSSParserValue v; 135 v.id = CSSValueInvalid; 136 v.isInt = false; 137 v.unit = CSSParserValue::Operator; 138 v.iValue = value; 139 return v; 140 } 141 142 inline static CSSParserValue makeIdentValue(CSSParserString string) 143 { 144 CSSParserValue v; 145 v.id = cssValueKeywordID(string); 146 v.isInt = false; 147 v.unit = CSSPrimitiveValue::CSS_IDENT; 148 v.string = string; 149 return v; 150 } 151 152 %} 153 154 %expect 0 155 156 %nonassoc LOWEST_PREC 157 158 %left UNIMPORTANT_TOK 159 160 %token WHITESPACE SGML_CD 161 %token TOKEN_EOF 0 162 163 %token INCLUDES 164 %token DASHMATCH 165 %token BEGINSWITH 166 %token ENDSWITH 167 %token CONTAINS 168 169 %token <string> STRING 170 %right <string> IDENT 171 %token <string> NTH 172 173 %nonassoc <string> HEX 174 %nonassoc <string> IDSEL 175 %nonassoc ':' 176 %nonassoc '.' 177 %nonassoc '[' 178 %nonassoc <string> '*' 179 %nonassoc error 180 %left '|' 181 182 %token IMPORT_SYM 183 %token PAGE_SYM 184 %token MEDIA_SYM 185 %token SUPPORTS_SYM 186 %token FONT_FACE_SYM 187 %token CHARSET_SYM 188 %token NAMESPACE_SYM 189 %token VIEWPORT_RULE_SYM 190 %token INTERNAL_DECLS_SYM 191 %token INTERNAL_RULE_SYM 192 %token INTERNAL_SELECTOR_SYM 193 %token INTERNAL_VALUE_SYM 194 %token INTERNAL_KEYFRAME_RULE_SYM 195 %token INTERNAL_KEYFRAME_KEY_LIST_SYM 196 %token INTERNAL_SUPPORTS_CONDITION_SYM 197 %token KEYFRAMES_SYM 198 %token WEBKIT_KEYFRAMES_SYM 199 %token <marginBox> TOPLEFTCORNER_SYM 200 %token <marginBox> TOPLEFT_SYM 201 %token <marginBox> TOPCENTER_SYM 202 %token <marginBox> TOPRIGHT_SYM 203 %token <marginBox> TOPRIGHTCORNER_SYM 204 %token <marginBox> BOTTOMLEFTCORNER_SYM 205 %token <marginBox> BOTTOMLEFT_SYM 206 %token <marginBox> BOTTOMCENTER_SYM 207 %token <marginBox> BOTTOMRIGHT_SYM 208 %token <marginBox> BOTTOMRIGHTCORNER_SYM 209 %token <marginBox> LEFTTOP_SYM 210 %token <marginBox> LEFTMIDDLE_SYM 211 %token <marginBox> LEFTBOTTOM_SYM 212 %token <marginBox> RIGHTTOP_SYM 213 %token <marginBox> RIGHTMIDDLE_SYM 214 %token <marginBox> RIGHTBOTTOM_SYM 215 216 %token ATKEYWORD 217 218 %token IMPORTANT_SYM 219 %token MEDIA_ONLY 220 %token MEDIA_NOT 221 %token MEDIA_AND 222 %token MEDIA_OR 223 224 %token SUPPORTS_NOT 225 %token SUPPORTS_AND 226 %token SUPPORTS_OR 227 228 %token <number> REMS 229 %token <number> CHS 230 %token <number> QEMS 231 %token <number> EMS 232 %token <number> EXS 233 %token <number> PXS 234 %token <number> CMS 235 %token <number> MMS 236 %token <number> INS 237 %token <number> PTS 238 %token <number> PCS 239 %token <number> DEGS 240 %token <number> RADS 241 %token <number> GRADS 242 %token <number> TURNS 243 %token <number> MSECS 244 %token <number> SECS 245 %token <number> HERTZ 246 %token <number> KHERTZ 247 %token <string> DIMEN 248 %token <string> INVALIDDIMEN 249 %token <number> PERCENTAGE 250 %token <number> FLOATTOKEN 251 %token <number> INTEGER 252 %token <number> VW 253 %token <number> VH 254 %token <number> VMIN 255 %token <number> VMAX 256 %token <number> DPPX 257 %token <number> DPI 258 %token <number> DPCM 259 %token <number> FR 260 261 %token <string> URI 262 %token <string> FUNCTION 263 %token <string> ANYFUNCTION 264 %token <string> CUEFUNCTION 265 %token <string> NOTFUNCTION 266 %token <string> DISTRIBUTEDFUNCTION 267 %token <string> CALCFUNCTION 268 %token <string> HOSTFUNCTION 269 %token <string> HOSTCONTEXTFUNCTION 270 271 %token <string> UNICODERANGE 272 273 %type <relation> combinator 274 275 %type <rule> ruleset 276 %type <rule> media 277 %type <rule> import 278 %type <rule> namespace 279 %type <rule> page 280 %type <rule> margin_box 281 %type <rule> font_face 282 %type <rule> keyframes 283 %type <rule> rule 284 %type <rule> valid_rule 285 %type <ruleList> block_rule_body 286 %type <ruleList> block_rule_list 287 %type <rule> block_rule 288 %type <rule> block_valid_rule 289 %type <rule> supports 290 %type <rule> viewport 291 %type <boolean> keyframes_rule_start 292 293 %type <string> maybe_ns_prefix 294 295 %type <string> namespace_selector 296 297 %type <string> string_or_uri 298 %type <string> ident_or_string 299 %type <string> medium 300 %type <marginBox> margin_sym 301 302 %type <mediaList> media_list 303 %type <mediaList> maybe_media_list 304 %type <mediaList> mq_list 305 %type <mediaQuery> media_query 306 %type <mediaQuery> valid_media_query 307 %type <mediaQueryRestrictor> maybe_media_restrictor 308 %type <valueList> maybe_media_value 309 %type <mediaQueryExp> media_query_exp 310 %type <mediaQueryExpList> media_query_exp_list 311 %type <mediaQueryExpList> maybe_and_media_query_exp_list 312 313 %type <boolean> supports_condition 314 %type <boolean> supports_condition_in_parens 315 %type <boolean> supports_negation 316 %type <boolean> supports_conjunction 317 %type <boolean> supports_disjunction 318 %type <boolean> supports_declaration_condition 319 320 %type <string> keyframe_name 321 %type <keyframe> keyframe_rule 322 %type <keyframeRuleList> keyframes_rule 323 %type <keyframeRuleList> keyframe_rule_list 324 %type <valueList> key_list 325 %type <value> key 326 327 %type <id> property 328 329 %type <selector> specifier 330 %type <selector> specifier_list 331 %type <selector> simple_selector 332 %type <selector> selector 333 %type <selectorList> selector_list 334 %type <selectorList> simple_selector_list 335 %type <selector> class 336 %type <selector> attrib 337 %type <selector> pseudo 338 %type <selector> pseudo_page 339 %type <selector> page_selector 340 341 %type <boolean> declaration_list 342 %type <boolean> decl_list 343 %type <boolean> declaration 344 %type <boolean> declarations_and_margins 345 346 %type <boolean> prio 347 348 %type <integer> match 349 %type <integer> unary_operator 350 %type <integer> maybe_unary_operator 351 %type <character> operator 352 353 %type <valueList> expr 354 %type <value> term 355 %type <value> unary_term 356 %type <value> function 357 %type <value> calc_func_term 358 %type <character> calc_func_operator 359 %type <valueList> calc_func_expr 360 %type <valueList> calc_func_paren_expr 361 %type <value> calc_function 362 363 %type <string> element_name 364 %type <string> attr_name 365 366 %type <attributeMatchType> attr_match_type 367 %type <attributeMatchType> maybe_attr_match_type 368 369 %type <location> error_location 370 371 %type <valueList> ident_list 372 %type <value> track_names_list 373 374 %% 375 376 stylesheet: 377 maybe_charset maybe_sgml rule_list 378 | internal_decls 379 | internal_rule 380 | internal_selector 381 | internal_value 382 | internal_keyframe_rule 383 | internal_keyframe_key_list 384 | internal_supports_condition 385 ; 386 387 internal_rule: 388 INTERNAL_RULE_SYM maybe_space valid_rule maybe_space TOKEN_EOF { 389 parser->m_rule = $3; 390 } 391 ; 392 393 internal_keyframe_rule: 394 INTERNAL_KEYFRAME_RULE_SYM maybe_space keyframe_rule maybe_space TOKEN_EOF { 395 parser->m_keyframe = $3; 396 } 397 ; 398 399 internal_keyframe_key_list: 400 INTERNAL_KEYFRAME_KEY_LIST_SYM maybe_space key_list TOKEN_EOF { 401 parser->m_valueList = parser->sinkFloatingValueList($3); 402 } 403 ; 404 405 internal_decls: 406 INTERNAL_DECLS_SYM maybe_space_before_declaration declaration_list TOKEN_EOF { 407 /* can be empty */ 408 } 409 ; 410 411 internal_value: 412 INTERNAL_VALUE_SYM maybe_space expr TOKEN_EOF { 413 parser->m_valueList = parser->sinkFloatingValueList($3); 414 int oldParsedProperties = parser->m_parsedProperties.size(); 415 if (!parser->parseValue(parser->m_id, parser->m_important)) 416 parser->rollbackLastProperties(parser->m_parsedProperties.size() - oldParsedProperties); 417 parser->m_valueList = nullptr; 418 } 419 ; 420 421 internal_selector: 422 INTERNAL_SELECTOR_SYM maybe_space selector_list TOKEN_EOF { 423 if (parser->m_selectorListForParseSelector) 424 parser->m_selectorListForParseSelector->adoptSelectorVector(*$3); 425 } 426 ; 427 428 internal_supports_condition: 429 INTERNAL_SUPPORTS_CONDITION_SYM maybe_space supports_condition TOKEN_EOF { 430 parser->m_supportsCondition = $3; 431 } 432 ; 433 434 space: 435 WHITESPACE 436 | space WHITESPACE 437 ; 438 439 maybe_space: 440 /* empty */ %prec UNIMPORTANT_TOK 441 | space 442 ; 443 444 maybe_sgml: 445 /* empty */ 446 | maybe_sgml SGML_CD 447 | maybe_sgml WHITESPACE 448 ; 449 450 closing_brace: 451 '}' 452 | %prec LOWEST_PREC TOKEN_EOF 453 ; 454 455 closing_parenthesis: 456 ')' 457 | %prec LOWEST_PREC TOKEN_EOF 458 ; 459 460 closing_square_bracket: 461 ']' 462 | %prec LOWEST_PREC TOKEN_EOF 463 ; 464 465 semi_or_eof: 466 ';' 467 | TOKEN_EOF 468 ; 469 470 before_charset_rule: 471 /* empty */ { 472 parser->startRule(); 473 parser->startRuleHeader(CSSRuleSourceData::CHARSET_RULE); 474 } 475 476 maybe_charset: 477 /* empty */ 478 | before_charset_rule CHARSET_SYM maybe_space STRING maybe_space semi_or_eof { 479 if (parser->m_styleSheet) 480 parser->m_styleSheet->parserSetEncodingFromCharsetRule($4); 481 parser->endRuleHeader(); 482 parser->startRuleBody(); 483 parser->endRule(true); 484 } 485 | before_charset_rule CHARSET_SYM at_rule_recovery { 486 parser->endRule(false); 487 } 488 ; 489 490 rule_list: 491 /* empty */ 492 | rule_list rule maybe_sgml { 493 if ($2 && parser->m_styleSheet) 494 parser->m_styleSheet->parserAppendRule($2); 495 } 496 ; 497 498 valid_rule: 499 ruleset 500 | media 501 | page 502 | font_face 503 | keyframes 504 | namespace 505 | import 506 | supports 507 | viewport 508 ; 509 510 before_rule: 511 /* empty */ { 512 parser->startRule(); 513 } 514 ; 515 516 rule: 517 before_rule valid_rule { 518 $$ = $2; 519 parser->m_hadSyntacticallyValidCSSRule = true; 520 parser->endRule(!!$$); 521 } 522 | before_rule invalid_rule { 523 $$ = 0; 524 parser->endRule(false); 525 } 526 ; 527 528 block_rule_body: 529 block_rule_list 530 | block_rule_list block_rule_recovery 531 ; 532 533 block_rule_list: 534 /* empty */ { $$ = 0; } 535 | block_rule_list block_rule maybe_sgml { 536 $$ = parser->appendRule($1, $2); 537 } 538 ; 539 540 block_rule_recovery: 541 before_rule invalid_rule_header { 542 parser->endRule(false); 543 } 544 ; 545 546 block_valid_rule: 547 ruleset 548 | page 549 | font_face 550 | media 551 | keyframes 552 | supports 553 | viewport 554 | namespace 555 ; 556 557 block_rule: 558 before_rule block_valid_rule { 559 $$ = $2; 560 parser->endRule(!!$$); 561 } 562 | before_rule invalid_rule { 563 $$ = 0; 564 parser->endRule(false); 565 } 566 ; 567 568 before_import_rule: 569 /* empty */ { 570 parser->startRuleHeader(CSSRuleSourceData::IMPORT_RULE); 571 } 572 ; 573 574 import_rule_start: 575 before_import_rule IMPORT_SYM maybe_space { 576 parser->endRuleHeader(); 577 parser->startRuleBody(); 578 } 579 ; 580 581 import: 582 import_rule_start string_or_uri maybe_space location_label maybe_media_list semi_or_eof { 583 $$ = parser->createImportRule($2, $5); 584 } 585 | import_rule_start string_or_uri maybe_space location_label maybe_media_list invalid_block { 586 $$ = 0; 587 } 588 ; 589 590 namespace: 591 NAMESPACE_SYM maybe_space maybe_ns_prefix string_or_uri maybe_space semi_or_eof { 592 parser->addNamespace($3, $4); 593 $$ = 0; 594 } 595 ; 596 597 maybe_ns_prefix: 598 /* empty */ { $$.clear(); } 599 | IDENT maybe_space 600 ; 601 602 string_or_uri: 603 STRING 604 | URI 605 ; 606 607 maybe_media_value: 608 /*empty*/ { 609 $$ = 0; 610 } 611 | ':' maybe_space expr { 612 $$ = $3; 613 } 614 ; 615 616 media_query_exp: 617 '(' maybe_space IDENT maybe_space maybe_media_value closing_parenthesis { 618 parser->tokenToLowerCase($3); 619 $$ = parser->createFloatingMediaQueryExp($3, $5); 620 if (!$$) 621 YYERROR; 622 } 623 | '(' error error_recovery closing_parenthesis { 624 YYERROR; 625 } 626 ; 627 628 media_query_exp_list: 629 media_query_exp { 630 $$ = parser->createFloatingMediaQueryExpList(); 631 $$->append(parser->sinkFloatingMediaQueryExp($1)); 632 } 633 | media_query_exp_list maybe_space MEDIA_AND maybe_space media_query_exp { 634 $$ = $1; 635 $$->append(parser->sinkFloatingMediaQueryExp($5)); 636 } 637 ; 638 639 maybe_and_media_query_exp_list: 640 maybe_space { 641 $$ = parser->createFloatingMediaQueryExpList(); 642 } 643 | maybe_space MEDIA_AND maybe_space media_query_exp_list maybe_space { 644 $$ = $4; 645 } 646 ; 647 648 maybe_media_restrictor: 649 /*empty*/ { 650 $$ = MediaQuery::None; 651 } 652 | MEDIA_ONLY maybe_space { 653 $$ = MediaQuery::Only; 654 } 655 | MEDIA_NOT maybe_space { 656 $$ = MediaQuery::Not; 657 } 658 ; 659 660 valid_media_query: 661 media_query_exp_list maybe_space { 662 $$ = parser->createFloatingMediaQuery(parser->sinkFloatingMediaQueryExpList($1)); 663 } 664 | maybe_media_restrictor medium maybe_and_media_query_exp_list { 665 parser->tokenToLowerCase($2); 666 $$ = parser->createFloatingMediaQuery($1, $2, parser->sinkFloatingMediaQueryExpList($3)); 667 } 668 ; 669 670 media_query: 671 valid_media_query 672 | valid_media_query error error_location rule_error_recovery { 673 parser->reportError(parser->lastLocationLabel(), InvalidMediaQueryCSSError); 674 $$ = parser->createFloatingNotAllQuery(); 675 } 676 | error error_location rule_error_recovery { 677 parser->reportError(parser->lastLocationLabel(), InvalidMediaQueryCSSError); 678 $$ = parser->createFloatingNotAllQuery(); 679 } 680 ; 681 682 maybe_media_list: 683 /* empty */ { 684 $$ = parser->createMediaQuerySet(); 685 } 686 | media_list 687 ; 688 689 media_list: 690 media_query { 691 $$ = parser->createMediaQuerySet(); 692 $$->addMediaQuery(parser->sinkFloatingMediaQuery($1)); 693 } 694 | mq_list media_query { 695 $$ = $1; 696 $$->addMediaQuery(parser->sinkFloatingMediaQuery($2)); 697 } 698 | mq_list { 699 $$ = $1; 700 $$->addMediaQuery(parser->sinkFloatingMediaQuery(parser->createFloatingNotAllQuery())); 701 } 702 ; 703 704 mq_list: 705 media_query ',' maybe_space location_label { 706 $$ = parser->createMediaQuerySet(); 707 $$->addMediaQuery(parser->sinkFloatingMediaQuery($1)); 708 } 709 | mq_list media_query ',' maybe_space location_label { 710 $$ = $1; 711 $$->addMediaQuery(parser->sinkFloatingMediaQuery($2)); 712 } 713 ; 714 715 at_rule_body_start: 716 /* empty */ { 717 parser->startRuleBody(); 718 } 719 ; 720 721 before_media_rule: 722 /* empty */ { 723 parser->startRuleHeader(CSSRuleSourceData::MEDIA_RULE); 724 } 725 ; 726 727 at_rule_header_end_maybe_space: 728 maybe_space { 729 parser->endRuleHeader(); 730 } 731 ; 732 733 media_rule_start: 734 before_media_rule MEDIA_SYM maybe_space; 735 736 media: 737 media_rule_start maybe_media_list '{' at_rule_header_end at_rule_body_start maybe_space block_rule_body closing_brace { 738 $$ = parser->createMediaRule($2, $7); 739 } 740 ; 741 742 medium: 743 IDENT 744 ; 745 746 supports: 747 before_supports_rule SUPPORTS_SYM maybe_space supports_condition at_supports_rule_header_end '{' at_rule_body_start maybe_space block_rule_body closing_brace { 748 $$ = parser->createSupportsRule($4, $9); 749 } 750 ; 751 752 before_supports_rule: 753 /* empty */ { 754 parser->startRuleHeader(CSSRuleSourceData::SUPPORTS_RULE); 755 parser->markSupportsRuleHeaderStart(); 756 } 757 ; 758 759 at_supports_rule_header_end: 760 /* empty */ { 761 parser->endRuleHeader(); 762 parser->markSupportsRuleHeaderEnd(); 763 } 764 ; 765 766 supports_condition: 767 supports_condition_in_parens 768 | supports_negation 769 | supports_conjunction 770 | supports_disjunction 771 ; 772 773 supports_negation: 774 SUPPORTS_NOT maybe_space supports_condition_in_parens { 775 $$ = !$3; 776 } 777 ; 778 779 supports_conjunction: 780 supports_condition_in_parens SUPPORTS_AND maybe_space supports_condition_in_parens { 781 $$ = $1 && $4; 782 } 783 | supports_conjunction SUPPORTS_AND maybe_space supports_condition_in_parens { 784 $$ = $1 && $4; 785 } 786 ; 787 788 supports_disjunction: 789 supports_condition_in_parens SUPPORTS_OR maybe_space supports_condition_in_parens { 790 $$ = $1 || $4; 791 } 792 | supports_disjunction SUPPORTS_OR maybe_space supports_condition_in_parens { 793 $$ = $1 || $4; 794 } 795 ; 796 797 supports_condition_in_parens: 798 '(' maybe_space supports_condition closing_parenthesis maybe_space { 799 $$ = $3; 800 } 801 | supports_declaration_condition 802 | '(' error error_location error_recovery closing_parenthesis maybe_space { 803 parser->reportError($3, InvalidSupportsConditionCSSError); 804 $$ = false; 805 } 806 ; 807 808 supports_declaration_condition: 809 '(' maybe_space IDENT maybe_space ':' maybe_space expr prio closing_parenthesis maybe_space { 810 $$ = false; 811 CSSPropertyID id = cssPropertyID($3); 812 if (id != CSSPropertyInvalid) { 813 parser->m_valueList = parser->sinkFloatingValueList($7); 814 int oldParsedProperties = parser->m_parsedProperties.size(); 815 $$ = parser->parseValue(id, $8); 816 // We just need to know if the declaration is supported as it is written. Rollback any additions. 817 if ($$) 818 parser->rollbackLastProperties(parser->m_parsedProperties.size() - oldParsedProperties); 819 } 820 parser->m_valueList = nullptr; 821 parser->endProperty($8, false); 822 } 823 | '(' maybe_space IDENT maybe_space ':' maybe_space error error_recovery closing_parenthesis maybe_space { 824 $$ = false; 825 parser->endProperty(false, false, GeneralCSSError); 826 } 827 ; 828 829 before_keyframes_rule: 830 /* empty */ { 831 parser->startRuleHeader(CSSRuleSourceData::KEYFRAMES_RULE); 832 } 833 ; 834 835 keyframes_rule_start: 836 before_keyframes_rule KEYFRAMES_SYM maybe_space { 837 $$ = false; 838 } 839 | before_keyframes_rule WEBKIT_KEYFRAMES_SYM maybe_space { 840 $$ = true; 841 } 842 ; 843 844 keyframes: 845 keyframes_rule_start keyframe_name at_rule_header_end_maybe_space '{' at_rule_body_start maybe_space location_label keyframes_rule closing_brace { 846 $$ = parser->createKeyframesRule($2, parser->sinkFloatingKeyframeVector($8), $1 /* isPrefixed */); 847 } 848 ; 849 850 keyframe_name: 851 IDENT 852 | STRING 853 ; 854 855 keyframes_rule: 856 keyframe_rule_list 857 | keyframe_rule_list keyframes_error_recovery { 858 parser->clearProperties(); 859 }; 860 861 keyframe_rule_list: 862 /* empty */ { 863 $$ = parser->createFloatingKeyframeVector(); 864 parser->resumeErrorLogging(); 865 } 866 | keyframe_rule_list keyframe_rule maybe_space location_label { 867 $$ = $1; 868 $$->append($2); 869 } 870 | keyframe_rule_list keyframes_error_recovery invalid_block maybe_space location_label { 871 parser->clearProperties(); 872 parser->resumeErrorLogging(); 873 } 874 ; 875 876 keyframe_rule: 877 key_list '{' maybe_space declaration_list closing_brace { 878 $$ = parser->createKeyframe($1); 879 } 880 ; 881 882 key_list: 883 key maybe_space { 884 $$ = parser->createFloatingValueList(); 885 $$->addValue(parser->sinkFloatingValue($1)); 886 } 887 | key_list ',' maybe_space key maybe_space { 888 $$ = $1; 889 $$->addValue(parser->sinkFloatingValue($4)); 890 } 891 ; 892 893 key: 894 maybe_unary_operator PERCENTAGE { 895 $$.setFromNumber($1 * $2); 896 } 897 | IDENT { 898 if ($1.equalIgnoringCase("from")) 899 $$.setFromNumber(0); 900 else if ($1.equalIgnoringCase("to")) 901 $$.setFromNumber(100); 902 else { 903 YYERROR; 904 } 905 } 906 ; 907 908 keyframes_error_recovery: 909 error rule_error_recovery { 910 parser->reportError(parser->lastLocationLabel(), InvalidKeyframeSelectorCSSError); 911 } 912 ; 913 914 before_page_rule: 915 /* empty */ { 916 parser->startRuleHeader(CSSRuleSourceData::PAGE_RULE); 917 } 918 ; 919 920 page: 921 before_page_rule PAGE_SYM maybe_space page_selector at_rule_header_end 922 '{' at_rule_body_start maybe_space_before_declaration declarations_and_margins closing_brace { 923 if ($4) 924 $$ = parser->createPageRule(parser->sinkFloatingSelector($4)); 925 else { 926 // Clear properties in the invalid @page rule. 927 parser->clearProperties(); 928 // Also clear margin at-rules here once we fully implement margin at-rules parsing. 929 $$ = 0; 930 } 931 } 932 ; 933 934 page_selector: 935 IDENT maybe_space { 936 $$ = parser->createFloatingSelectorWithTagName(QualifiedName(nullAtom, $1, parser->m_defaultNamespace)); 937 $$->setForPage(); 938 } 939 | IDENT pseudo_page maybe_space { 940 $$ = $2; 941 $$->prependTagSelector(QualifiedName(nullAtom, $1, parser->m_defaultNamespace)); 942 $$->setForPage(); 943 } 944 | pseudo_page maybe_space { 945 $$ = $1; 946 $$->setForPage(); 947 } 948 | /* empty */ { 949 $$ = parser->createFloatingSelector(); 950 $$->setForPage(); 951 } 952 ; 953 954 declarations_and_margins: 955 declaration_list 956 | declarations_and_margins margin_box maybe_space declaration_list 957 ; 958 959 margin_box: 960 margin_sym { 961 parser->startDeclarationsForMarginBox(); 962 } maybe_space '{' maybe_space declaration_list closing_brace { 963 $$ = parser->createMarginAtRule($1); 964 } 965 ; 966 967 margin_sym : 968 TOPLEFTCORNER_SYM { 969 $$ = CSSSelector::TopLeftCornerMarginBox; 970 } 971 | TOPLEFT_SYM { 972 $$ = CSSSelector::TopLeftMarginBox; 973 } 974 | TOPCENTER_SYM { 975 $$ = CSSSelector::TopCenterMarginBox; 976 } 977 | TOPRIGHT_SYM { 978 $$ = CSSSelector::TopRightMarginBox; 979 } 980 | TOPRIGHTCORNER_SYM { 981 $$ = CSSSelector::TopRightCornerMarginBox; 982 } 983 | BOTTOMLEFTCORNER_SYM { 984 $$ = CSSSelector::BottomLeftCornerMarginBox; 985 } 986 | BOTTOMLEFT_SYM { 987 $$ = CSSSelector::BottomLeftMarginBox; 988 } 989 | BOTTOMCENTER_SYM { 990 $$ = CSSSelector::BottomCenterMarginBox; 991 } 992 | BOTTOMRIGHT_SYM { 993 $$ = CSSSelector::BottomRightMarginBox; 994 } 995 | BOTTOMRIGHTCORNER_SYM { 996 $$ = CSSSelector::BottomRightCornerMarginBox; 997 } 998 | LEFTTOP_SYM { 999 $$ = CSSSelector::LeftTopMarginBox; 1000 } 1001 | LEFTMIDDLE_SYM { 1002 $$ = CSSSelector::LeftMiddleMarginBox; 1003 } 1004 | LEFTBOTTOM_SYM { 1005 $$ = CSSSelector::LeftBottomMarginBox; 1006 } 1007 | RIGHTTOP_SYM { 1008 $$ = CSSSelector::RightTopMarginBox; 1009 } 1010 | RIGHTMIDDLE_SYM { 1011 $$ = CSSSelector::RightMiddleMarginBox; 1012 } 1013 | RIGHTBOTTOM_SYM { 1014 $$ = CSSSelector::RightBottomMarginBox; 1015 } 1016 ; 1017 1018 before_font_face_rule: 1019 /* empty */ { 1020 parser->startRuleHeader(CSSRuleSourceData::FONT_FACE_RULE); 1021 } 1022 ; 1023 1024 font_face: 1025 before_font_face_rule FONT_FACE_SYM at_rule_header_end_maybe_space 1026 '{' at_rule_body_start maybe_space_before_declaration declaration_list closing_brace { 1027 $$ = parser->createFontFaceRule(); 1028 } 1029 ; 1030 1031 before_viewport_rule: 1032 /* empty */ { 1033 parser->markViewportRuleBodyStart(); 1034 parser->startRuleHeader(CSSRuleSourceData::VIEWPORT_RULE); 1035 } 1036 ; 1037 1038 viewport: 1039 before_viewport_rule VIEWPORT_RULE_SYM at_rule_header_end_maybe_space 1040 '{' at_rule_body_start maybe_space_before_declaration declaration_list closing_brace { 1041 $$ = parser->createViewportRule(); 1042 parser->markViewportRuleBodyEnd(); 1043 } 1044 ; 1045 1046 combinator: 1047 '+' maybe_space { $$ = CSSSelector::DirectAdjacent; } 1048 | '~' maybe_space { $$ = CSSSelector::IndirectAdjacent; } 1049 | '>' maybe_space { $$ = CSSSelector::Child; } 1050 | '/' IDENT '/' maybe_space { 1051 if ($2.equalIgnoringCase("deep")) 1052 $$ = CSSSelector::ShadowDeep; 1053 else 1054 YYERROR; 1055 } 1056 ; 1057 1058 maybe_unary_operator: 1059 unary_operator 1060 | /* empty */ { $$ = 1; } 1061 ; 1062 1063 unary_operator: 1064 '-' { $$ = -1; } 1065 | '+' { $$ = 1; } 1066 ; 1067 1068 maybe_space_before_declaration: 1069 maybe_space { 1070 parser->startProperty(); 1071 } 1072 ; 1073 1074 before_selector_list: 1075 /* empty */ { 1076 parser->startRuleHeader(CSSRuleSourceData::STYLE_RULE); 1077 parser->startSelector(); 1078 } 1079 ; 1080 1081 at_rule_header_end: 1082 /* empty */ { 1083 parser->endRuleHeader(); 1084 } 1085 ; 1086 1087 at_selector_end: 1088 /* empty */ { 1089 parser->endSelector(); 1090 } 1091 ; 1092 1093 ruleset: 1094 before_selector_list selector_list at_selector_end at_rule_header_end '{' at_rule_body_start maybe_space_before_declaration declaration_list closing_brace { 1095 $$ = parser->createStyleRule($2); 1096 } 1097 ; 1098 1099 before_selector_group_item: 1100 /* empty */ { 1101 parser->startSelector(); 1102 } 1103 1104 selector_list: 1105 selector %prec UNIMPORTANT_TOK { 1106 $$ = parser->reusableSelectorVector(); 1107 $$->shrink(0); 1108 $$->append(parser->sinkFloatingSelector($1)); 1109 } 1110 | selector_list at_selector_end ',' maybe_space before_selector_group_item selector %prec UNIMPORTANT_TOK { 1111 $$ = $1; 1112 $$->append(parser->sinkFloatingSelector($6)); 1113 } 1114 ; 1115 1116 selector: 1117 simple_selector 1118 | selector WHITESPACE 1119 | selector WHITESPACE simple_selector 1120 { 1121 $$ = $3; 1122 CSSParserSelector* end = $$; 1123 while (end->tagHistory()) 1124 end = end->tagHistory(); 1125 end->setRelation(CSSSelector::Descendant); 1126 if ($1->isContentPseudoElement()) 1127 end->setRelationIsAffectedByPseudoContent(); 1128 end->setTagHistory(parser->sinkFloatingSelector($1)); 1129 } 1130 | selector combinator simple_selector { 1131 $$ = $3; 1132 CSSParserSelector* end = $$; 1133 while (end->tagHistory()) 1134 end = end->tagHistory(); 1135 end->setRelation($2); 1136 if ($1->isContentPseudoElement()) 1137 end->setRelationIsAffectedByPseudoContent(); 1138 end->setTagHistory(parser->sinkFloatingSelector($1)); 1139 } 1140 ; 1141 1142 namespace_selector: 1143 /* empty */ '|' { $$.clear(); } 1144 | '*' '|' { static const LChar star = '*'; $$.init(&star, 1); } 1145 | IDENT '|' 1146 ; 1147 1148 simple_selector: 1149 element_name { 1150 $$ = parser->createFloatingSelectorWithTagName(QualifiedName(nullAtom, $1, parser->m_defaultNamespace)); 1151 } 1152 | element_name specifier_list { 1153 $$ = parser->rewriteSpecifiersWithElementName(nullAtom, $1, $2); 1154 if (!$$) 1155 YYERROR; 1156 } 1157 | specifier_list { 1158 $$ = parser->rewriteSpecifiersWithNamespaceIfNeeded($1); 1159 if (!$$) 1160 YYERROR; 1161 } 1162 | namespace_selector element_name { 1163 $$ = parser->createFloatingSelectorWithTagName(parser->determineNameInNamespace($1, $2)); 1164 if (!$$) 1165 YYERROR; 1166 } 1167 | namespace_selector element_name specifier_list { 1168 $$ = parser->rewriteSpecifiersWithElementName($1, $2, $3); 1169 if (!$$) 1170 YYERROR; 1171 } 1172 | namespace_selector specifier_list { 1173 $$ = parser->rewriteSpecifiersWithElementName($1, starAtom, $2); 1174 if (!$$) 1175 YYERROR; 1176 } 1177 ; 1178 1179 simple_selector_list: 1180 simple_selector %prec UNIMPORTANT_TOK { 1181 $$ = parser->createFloatingSelectorVector(); 1182 $$->append(parser->sinkFloatingSelector($1)); 1183 } 1184 | simple_selector_list maybe_space ',' maybe_space simple_selector %prec UNIMPORTANT_TOK { 1185 $$ = $1; 1186 $$->append(parser->sinkFloatingSelector($5)); 1187 } 1188 ; 1189 1190 element_name: 1191 IDENT { 1192 if (parser->m_context.isHTMLDocument()) 1193 parser->tokenToLowerCase($1); 1194 $$ = $1; 1195 } 1196 | '*' { 1197 static const LChar star = '*'; 1198 $$.init(&star, 1); 1199 } 1200 ; 1201 1202 specifier_list: 1203 specifier 1204 | specifier_list specifier { 1205 $$ = parser->rewriteSpecifiers($1, $2); 1206 } 1207 ; 1208 1209 specifier: 1210 IDSEL { 1211 $$ = parser->createFloatingSelector(); 1212 $$->setMatch(CSSSelector::Id); 1213 if (isQuirksModeBehavior(parser->m_context.mode())) 1214 parser->tokenToLowerCase($1); 1215 $$->setValue($1); 1216 } 1217 | HEX { 1218 if ($1[0] >= '0' && $1[0] <= '9') { 1219 YYERROR; 1220 } else { 1221 $$ = parser->createFloatingSelector(); 1222 $$->setMatch(CSSSelector::Id); 1223 if (isQuirksModeBehavior(parser->m_context.mode())) 1224 parser->tokenToLowerCase($1); 1225 $$->setValue($1); 1226 } 1227 } 1228 | class 1229 | attrib 1230 | pseudo 1231 ; 1232 1233 class: 1234 '.' IDENT { 1235 $$ = parser->createFloatingSelector(); 1236 $$->setMatch(CSSSelector::Class); 1237 if (isQuirksModeBehavior(parser->m_context.mode())) 1238 parser->tokenToLowerCase($2); 1239 $$->setValue($2); 1240 } 1241 ; 1242 1243 attr_name: 1244 IDENT maybe_space { 1245 if (parser->m_context.isHTMLDocument()) 1246 parser->tokenToLowerCase($1); 1247 $$ = $1; 1248 } 1249 ; 1250 1251 attr_match_type: 1252 IDENT maybe_space { 1253 CSSSelector::AttributeMatchType attrMatchType = CSSSelector::CaseSensitive; 1254 if (!parser->parseAttributeMatchType(attrMatchType, $1)) 1255 YYERROR; 1256 $$ = attrMatchType; 1257 } 1258 ; 1259 1260 maybe_attr_match_type: 1261 attr_match_type 1262 | /* empty */ { $$ = CSSSelector::CaseSensitive; } 1263 ; 1264 1265 attrib: 1266 '[' maybe_space attr_name closing_square_bracket { 1267 $$ = parser->createFloatingSelector(); 1268 $$->setAttribute(QualifiedName(nullAtom, $3, nullAtom), CSSSelector::CaseSensitive); 1269 $$->setMatch(CSSSelector::Set); 1270 } 1271 | '[' maybe_space attr_name match maybe_space ident_or_string maybe_space maybe_attr_match_type closing_square_bracket { 1272 $$ = parser->createFloatingSelector(); 1273 $$->setAttribute(QualifiedName(nullAtom, $3, nullAtom), $8); 1274 $$->setMatch((CSSSelector::Match)$4); 1275 $$->setValue($6); 1276 } 1277 | '[' maybe_space namespace_selector attr_name closing_square_bracket { 1278 $$ = parser->createFloatingSelector(); 1279 $$->setAttribute(parser->determineNameInNamespace($3, $4), CSSSelector::CaseSensitive); 1280 $$->setMatch(CSSSelector::Set); 1281 } 1282 | '[' maybe_space namespace_selector attr_name match maybe_space ident_or_string maybe_space maybe_attr_match_type closing_square_bracket { 1283 $$ = parser->createFloatingSelector(); 1284 $$->setAttribute(parser->determineNameInNamespace($3, $4), $9); 1285 $$->setMatch((CSSSelector::Match)$5); 1286 $$->setValue($7); 1287 } 1288 | '[' selector_recovery closing_square_bracket { 1289 YYERROR; 1290 } 1291 ; 1292 1293 match: 1294 '=' { 1295 $$ = CSSSelector::Exact; 1296 } 1297 | INCLUDES { 1298 $$ = CSSSelector::List; 1299 } 1300 | DASHMATCH { 1301 $$ = CSSSelector::Hyphen; 1302 } 1303 | BEGINSWITH { 1304 $$ = CSSSelector::Begin; 1305 } 1306 | ENDSWITH { 1307 $$ = CSSSelector::End; 1308 } 1309 | CONTAINS { 1310 $$ = CSSSelector::Contain; 1311 } 1312 ; 1313 1314 ident_or_string: 1315 IDENT 1316 | STRING 1317 ; 1318 1319 pseudo_page: 1320 ':' IDENT { 1321 if ($2.isFunction()) 1322 YYERROR; 1323 $$ = parser->createFloatingSelector(); 1324 $$->setMatch(CSSSelector::PagePseudoClass); 1325 parser->tokenToLowerCase($2); 1326 $$->setValue($2); 1327 CSSSelector::PseudoType type = $$->pseudoType(); 1328 if (type == CSSSelector::PseudoUnknown) 1329 YYERROR; 1330 } 1331 1332 pseudo: 1333 ':' error_location IDENT { 1334 if ($3.isFunction()) 1335 YYERROR; 1336 $$ = parser->createFloatingSelector(); 1337 $$->setMatch(CSSSelector::PseudoClass); 1338 parser->tokenToLowerCase($3); 1339 $$->setValue($3); 1340 CSSSelector::PseudoType type = $$->pseudoType(); 1341 if (type == CSSSelector::PseudoUnknown) { 1342 parser->reportError($2, InvalidSelectorPseudoCSSError); 1343 YYERROR; 1344 } 1345 } 1346 | ':' ':' error_location IDENT { 1347 if ($4.isFunction()) 1348 YYERROR; 1349 $$ = parser->createFloatingSelector(); 1350 $$->setMatch(CSSSelector::PseudoElement); 1351 parser->tokenToLowerCase($4); 1352 $$->setValue($4); 1353 // FIXME: This call is needed to force selector to compute the pseudoType early enough. 1354 CSSSelector::PseudoType type = $$->pseudoType(); 1355 if (type == CSSSelector::PseudoUnknown) { 1356 parser->reportError($3, InvalidSelectorPseudoCSSError); 1357 YYERROR; 1358 } 1359 } 1360 // used by ::cue(:past/:future) 1361 | ':' ':' CUEFUNCTION maybe_space simple_selector_list maybe_space closing_parenthesis { 1362 $$ = parser->createFloatingSelector(); 1363 $$->setMatch(CSSSelector::PseudoElement); 1364 $$->adoptSelectorVector(*parser->sinkFloatingSelectorVector($5)); 1365 $$->setValue($3); 1366 CSSSelector::PseudoType type = $$->pseudoType(); 1367 if (type != CSSSelector::PseudoCue) 1368 YYERROR; 1369 } 1370 | ':' ':' CUEFUNCTION selector_recovery closing_parenthesis { 1371 YYERROR; 1372 } 1373 // use by :-webkit-any. 1374 // FIXME: should we support generic selectors here or just simple_selectors? 1375 // Use simple_selector_list for now to match -moz-any. 1376 // See http://lists.w3.org/Archives/Public/www-style/2010Sep/0566.html for some 1377 // related discussion with respect to :not. 1378 | ':' ANYFUNCTION maybe_space simple_selector_list maybe_space closing_parenthesis { 1379 $$ = parser->createFloatingSelector(); 1380 $$->setMatch(CSSSelector::PseudoClass); 1381 $$->adoptSelectorVector(*parser->sinkFloatingSelectorVector($4)); 1382 parser->tokenToLowerCase($2); 1383 $$->setValue($2); 1384 CSSSelector::PseudoType type = $$->pseudoType(); 1385 if (type != CSSSelector::PseudoAny) 1386 YYERROR; 1387 } 1388 | ':' ANYFUNCTION selector_recovery closing_parenthesis { 1389 YYERROR; 1390 } 1391 // used by :nth-*(ax+b) 1392 | ':' FUNCTION maybe_space NTH maybe_space closing_parenthesis { 1393 $$ = parser->createFloatingSelector(); 1394 $$->setMatch(CSSSelector::PseudoClass); 1395 $$->setArgument($4); 1396 $$->setValue($2); 1397 CSSSelector::PseudoType type = $$->pseudoType(); 1398 if (type == CSSSelector::PseudoUnknown) 1399 YYERROR; 1400 } 1401 // used by :nth-* 1402 | ':' FUNCTION maybe_space maybe_unary_operator INTEGER maybe_space closing_parenthesis { 1403 $$ = parser->createFloatingSelector(); 1404 $$->setMatch(CSSSelector::PseudoClass); 1405 $$->setArgument(AtomicString::number($4 * $5)); 1406 $$->setValue($2); 1407 CSSSelector::PseudoType type = $$->pseudoType(); 1408 if (type == CSSSelector::PseudoUnknown) 1409 YYERROR; 1410 } 1411 // used by :nth-*(odd/even) and :lang 1412 | ':' FUNCTION maybe_space IDENT maybe_space closing_parenthesis { 1413 $$ = parser->createFloatingSelector(); 1414 $$->setMatch(CSSSelector::PseudoClass); 1415 $$->setArgument($4); 1416 parser->tokenToLowerCase($2); 1417 $$->setValue($2); 1418 CSSSelector::PseudoType type = $$->pseudoType(); 1419 if (type == CSSSelector::PseudoUnknown) 1420 YYERROR; 1421 else if (type == CSSSelector::PseudoNthChild || 1422 type == CSSSelector::PseudoNthOfType || 1423 type == CSSSelector::PseudoNthLastChild || 1424 type == CSSSelector::PseudoNthLastOfType) { 1425 if (!isValidNthToken($4)) 1426 YYERROR; 1427 } 1428 } 1429 | ':' FUNCTION selector_recovery closing_parenthesis { 1430 YYERROR; 1431 } 1432 // used by :not 1433 | ':' NOTFUNCTION maybe_space simple_selector maybe_space closing_parenthesis { 1434 if (!$4->isSimple()) 1435 YYERROR; 1436 else { 1437 $$ = parser->createFloatingSelector(); 1438 $$->setMatch(CSSSelector::PseudoClass); 1439 1440 Vector<OwnPtr<CSSParserSelector> > selectorVector; 1441 selectorVector.append(parser->sinkFloatingSelector($4)); 1442 $$->adoptSelectorVector(selectorVector); 1443 1444 parser->tokenToLowerCase($2); 1445 $$->setValue($2); 1446 } 1447 } 1448 | ':' NOTFUNCTION selector_recovery closing_parenthesis { 1449 YYERROR; 1450 } 1451 | ':' HOSTFUNCTION maybe_space simple_selector_list maybe_space closing_parenthesis { 1452 $$ = parser->createFloatingSelector(); 1453 $$->setMatch(CSSSelector::PseudoClass); 1454 $$->adoptSelectorVector(*parser->sinkFloatingSelectorVector($4)); 1455 parser->tokenToLowerCase($2); 1456 $$->setValue($2); 1457 CSSSelector::PseudoType type = $$->pseudoType(); 1458 if (type != CSSSelector::PseudoHost) 1459 YYERROR; 1460 } 1461 | ':' HOSTFUNCTION selector_recovery closing_parenthesis { 1462 YYERROR; 1463 } 1464 // used by :host-context() 1465 | ':' HOSTCONTEXTFUNCTION maybe_space simple_selector_list maybe_space closing_parenthesis { 1466 $$ = parser->createFloatingSelector(); 1467 $$->setMatch(CSSSelector::PseudoClass); 1468 $$->adoptSelectorVector(*parser->sinkFloatingSelectorVector($4)); 1469 parser->tokenToLowerCase($2); 1470 $$->setValue($2); 1471 CSSSelector::PseudoType type = $$->pseudoType(); 1472 if (type != CSSSelector::PseudoHostContext) 1473 YYERROR; 1474 } 1475 | ':' HOSTCONTEXTFUNCTION selector_recovery closing_parenthesis { 1476 YYERROR; 1477 } 1478 ; 1479 1480 selector_recovery: 1481 error error_location error_recovery; 1482 1483 declaration_list: 1484 /* empty */ { $$ = false; } 1485 | declaration 1486 | decl_list declaration { 1487 $$ = $1 || $2; 1488 } 1489 | decl_list 1490 ; 1491 1492 decl_list: 1493 declaration ';' maybe_space { 1494 parser->startProperty(); 1495 $$ = $1; 1496 } 1497 | decl_list declaration ';' maybe_space { 1498 parser->startProperty(); 1499 $$ = $1 || $2; 1500 } 1501 ; 1502 1503 declaration: 1504 property ':' maybe_space error_location expr prio { 1505 $$ = false; 1506 bool isPropertyParsed = false; 1507 if ($1 != CSSPropertyInvalid) { 1508 parser->m_valueList = parser->sinkFloatingValueList($5); 1509 int oldParsedProperties = parser->m_parsedProperties.size(); 1510 $$ = parser->parseValue($1, $6); 1511 if (!$$) { 1512 parser->rollbackLastProperties(parser->m_parsedProperties.size() - oldParsedProperties); 1513 parser->reportError($4, InvalidPropertyValueCSSError); 1514 } else 1515 isPropertyParsed = true; 1516 parser->m_valueList = nullptr; 1517 } 1518 parser->endProperty($6, isPropertyParsed); 1519 } 1520 | 1521 property ':' maybe_space error_location expr prio error error_recovery { 1522 /* When we encounter something like p {color: red !important fail;} we should drop the declaration */ 1523 parser->reportError($4, InvalidPropertyValueCSSError); 1524 parser->endProperty(false, false); 1525 $$ = false; 1526 } 1527 | 1528 property ':' maybe_space error_location error error_recovery { 1529 parser->reportError($4, InvalidPropertyValueCSSError); 1530 parser->endProperty(false, false); 1531 $$ = false; 1532 } 1533 | 1534 property error error_location error_recovery { 1535 parser->reportError($3, PropertyDeclarationCSSError); 1536 parser->endProperty(false, false, GeneralCSSError); 1537 $$ = false; 1538 } 1539 | 1540 error error_location error_recovery { 1541 parser->reportError($2, PropertyDeclarationCSSError); 1542 $$ = false; 1543 } 1544 ; 1545 1546 property: 1547 error_location IDENT maybe_space { 1548 $$ = cssPropertyID($2); 1549 parser->setCurrentProperty($$); 1550 if ($$ == CSSPropertyInvalid) 1551 parser->reportError($1, InvalidPropertyCSSError); 1552 } 1553 ; 1554 1555 prio: 1556 IMPORTANT_SYM maybe_space { $$ = true; } 1557 | /* empty */ { $$ = false; } 1558 ; 1559 1560 ident_list: 1561 IDENT maybe_space { 1562 $$ = parser->createFloatingValueList(); 1563 $$->addValue(makeIdentValue($1)); 1564 } 1565 | ident_list IDENT maybe_space { 1566 $$ = $1; 1567 $$->addValue(makeIdentValue($2)); 1568 } 1569 ; 1570 1571 track_names_list: 1572 '(' maybe_space closing_parenthesis { 1573 $$.setFromValueList(parser->sinkFloatingValueList(parser->createFloatingValueList())); 1574 } 1575 | '(' maybe_space ident_list closing_parenthesis { 1576 $$.setFromValueList(parser->sinkFloatingValueList($3)); 1577 } 1578 | '(' maybe_space expr_recovery closing_parenthesis { 1579 YYERROR; 1580 } 1581 ; 1582 1583 expr: 1584 term { 1585 $$ = parser->createFloatingValueList(); 1586 $$->addValue(parser->sinkFloatingValue($1)); 1587 } 1588 | expr operator term { 1589 $$ = $1; 1590 $$->addValue(makeOperatorValue($2)); 1591 $$->addValue(parser->sinkFloatingValue($3)); 1592 } 1593 | expr term { 1594 $$ = $1; 1595 $$->addValue(parser->sinkFloatingValue($2)); 1596 } 1597 ; 1598 1599 expr_recovery: 1600 error error_location error_recovery { 1601 parser->reportError($2, PropertyDeclarationCSSError); 1602 } 1603 ; 1604 1605 operator: 1606 '/' maybe_space { 1607 $$ = '/'; 1608 } 1609 | ',' maybe_space { 1610 $$ = ','; 1611 } 1612 ; 1613 1614 term: 1615 unary_term maybe_space 1616 | unary_operator unary_term maybe_space { $$ = $2; $$.fValue *= $1; } 1617 | STRING maybe_space { $$.id = CSSValueInvalid; $$.isInt = false; $$.string = $1; $$.unit = CSSPrimitiveValue::CSS_STRING; } 1618 | IDENT maybe_space { $$ = makeIdentValue($1); } 1619 /* We might need to actually parse the number from a dimension, but we can't just put something that uses $$.string into unary_term. */ 1620 | DIMEN maybe_space { $$.id = CSSValueInvalid; $$.string = $1; $$.isInt = false; $$.unit = CSSPrimitiveValue::CSS_DIMENSION; } 1621 | unary_operator DIMEN maybe_space { $$.id = CSSValueInvalid; $$.string = $2; $$.isInt = false; $$.unit = CSSPrimitiveValue::CSS_DIMENSION; } 1622 | URI maybe_space { $$.id = CSSValueInvalid; $$.string = $1; $$.isInt = false; $$.unit = CSSPrimitiveValue::CSS_URI; } 1623 | UNICODERANGE maybe_space { $$.id = CSSValueInvalid; $$.string = $1; $$.isInt = false; $$.unit = CSSPrimitiveValue::CSS_UNICODE_RANGE; } 1624 | HEX maybe_space { $$.id = CSSValueInvalid; $$.string = $1; $$.isInt = false; $$.unit = CSSPrimitiveValue::CSS_PARSER_HEXCOLOR; } 1625 | '#' maybe_space { $$.id = CSSValueInvalid; $$.string = CSSParserString(); $$.isInt = false; $$.unit = CSSPrimitiveValue::CSS_PARSER_HEXCOLOR; } /* Handle error case: "color: #;" */ 1626 /* FIXME: according to the specs a function can have a unary_operator in front. I know no case where this makes sense */ 1627 | function maybe_space 1628 | calc_function maybe_space 1629 | '%' maybe_space { /* Handle width: %; */ 1630 $$.id = CSSValueInvalid; $$.isInt = false; $$.unit = 0; 1631 } 1632 | track_names_list maybe_space 1633 ; 1634 1635 unary_term: 1636 INTEGER { $$.setFromNumber($1); $$.isInt = true; } 1637 | FLOATTOKEN { $$.setFromNumber($1); } 1638 | PERCENTAGE { $$.setFromNumber($1, CSSPrimitiveValue::CSS_PERCENTAGE); } 1639 | PXS { $$.setFromNumber($1, CSSPrimitiveValue::CSS_PX); } 1640 | CMS { $$.setFromNumber($1, CSSPrimitiveValue::CSS_CM); } 1641 | MMS { $$.setFromNumber($1, CSSPrimitiveValue::CSS_MM); } 1642 | INS { $$.setFromNumber($1, CSSPrimitiveValue::CSS_IN); } 1643 | PTS { $$.setFromNumber($1, CSSPrimitiveValue::CSS_PT); } 1644 | PCS { $$.setFromNumber($1, CSSPrimitiveValue::CSS_PC); } 1645 | DEGS { $$.setFromNumber($1, CSSPrimitiveValue::CSS_DEG); } 1646 | RADS { $$.setFromNumber($1, CSSPrimitiveValue::CSS_RAD); } 1647 | GRADS { $$.setFromNumber($1, CSSPrimitiveValue::CSS_GRAD); } 1648 | TURNS { $$.setFromNumber($1, CSSPrimitiveValue::CSS_TURN); } 1649 | MSECS { $$.setFromNumber($1, CSSPrimitiveValue::CSS_MS); } 1650 | SECS { $$.setFromNumber($1, CSSPrimitiveValue::CSS_S); } 1651 | HERTZ { $$.setFromNumber($1, CSSPrimitiveValue::CSS_HZ); } 1652 | KHERTZ { $$.setFromNumber($1, CSSPrimitiveValue::CSS_KHZ); } 1653 | EMS { $$.setFromNumber($1, CSSPrimitiveValue::CSS_EMS); } 1654 | QEMS { $$.setFromNumber($1, CSSParserValue::Q_EMS); } 1655 | EXS { $$.setFromNumber($1, CSSPrimitiveValue::CSS_EXS); } 1656 | REMS { 1657 $$.setFromNumber($1, CSSPrimitiveValue::CSS_REMS); 1658 if (parser->m_styleSheet) 1659 parser->m_styleSheet->parserSetUsesRemUnits(true); 1660 } 1661 | CHS { $$.setFromNumber($1, CSSPrimitiveValue::CSS_CHS); } 1662 | VW { $$.setFromNumber($1, CSSPrimitiveValue::CSS_VW); } 1663 | VH { $$.setFromNumber($1, CSSPrimitiveValue::CSS_VH); } 1664 | VMIN { $$.setFromNumber($1, CSSPrimitiveValue::CSS_VMIN); } 1665 | VMAX { $$.setFromNumber($1, CSSPrimitiveValue::CSS_VMAX); } 1666 | DPPX { $$.setFromNumber($1, CSSPrimitiveValue::CSS_DPPX); } 1667 | DPI { $$.setFromNumber($1, CSSPrimitiveValue::CSS_DPI); } 1668 | DPCM { $$.setFromNumber($1, CSSPrimitiveValue::CSS_DPCM); } 1669 | FR { $$.setFromNumber($1, CSSPrimitiveValue::CSS_FR); } 1670 ; 1671 1672 function: 1673 FUNCTION maybe_space expr closing_parenthesis { 1674 $$.setFromFunction(parser->createFloatingFunction($1, parser->sinkFloatingValueList($3))); 1675 } | 1676 FUNCTION maybe_space closing_parenthesis { 1677 $$.setFromFunction(parser->createFloatingFunction($1, parser->sinkFloatingValueList(parser->createFloatingValueList()))); 1678 } | 1679 FUNCTION maybe_space expr_recovery closing_parenthesis { 1680 YYERROR; 1681 } 1682 ; 1683 1684 calc_func_term: 1685 unary_term 1686 | unary_operator unary_term { $$ = $2; $$.fValue *= $1; } 1687 ; 1688 1689 calc_func_operator: 1690 space '+' space { 1691 $$ = '+'; 1692 } 1693 | space '-' space { 1694 $$ = '-'; 1695 } 1696 | calc_maybe_space '*' maybe_space { 1697 $$ = '*'; 1698 } 1699 | calc_maybe_space '/' maybe_space { 1700 $$ = '/'; 1701 } 1702 ; 1703 1704 calc_maybe_space: 1705 /* empty */ 1706 | WHITESPACE 1707 ; 1708 1709 calc_func_paren_expr: 1710 '(' maybe_space calc_func_expr calc_maybe_space closing_parenthesis { 1711 $$ = $3; 1712 $$->insertValueAt(0, makeOperatorValue('(')); 1713 $$->addValue(makeOperatorValue(')')); 1714 } 1715 | '(' maybe_space expr_recovery closing_parenthesis { 1716 YYERROR; 1717 } 1718 ; 1719 1720 calc_func_expr: 1721 calc_func_term { 1722 $$ = parser->createFloatingValueList(); 1723 $$->addValue(parser->sinkFloatingValue($1)); 1724 } 1725 | calc_func_expr calc_func_operator calc_func_term { 1726 $$ = $1; 1727 $$->addValue(makeOperatorValue($2)); 1728 $$->addValue(parser->sinkFloatingValue($3)); 1729 } 1730 | calc_func_expr calc_func_operator calc_func_paren_expr { 1731 $$ = $1; 1732 $$->addValue(makeOperatorValue($2)); 1733 $$->stealValues(*($3)); 1734 } 1735 | calc_func_paren_expr 1736 ; 1737 1738 calc_function: 1739 CALCFUNCTION maybe_space calc_func_expr calc_maybe_space closing_parenthesis { 1740 $$.setFromFunction(parser->createFloatingFunction($1, parser->sinkFloatingValueList($3))); 1741 } 1742 | CALCFUNCTION maybe_space expr_recovery closing_parenthesis { 1743 YYERROR; 1744 } 1745 ; 1746 1747 1748 invalid_at: 1749 ATKEYWORD 1750 | margin_sym 1751 ; 1752 1753 at_rule_recovery: 1754 at_rule_header_recovery at_invalid_rule_header_end at_rule_end 1755 ; 1756 1757 at_rule_header_recovery: 1758 error error_location rule_error_recovery { 1759 parser->reportError($2, InvalidRuleCSSError); 1760 } 1761 ; 1762 1763 at_rule_end: 1764 at_invalid_rule_header_end semi_or_eof 1765 | at_invalid_rule_header_end invalid_block 1766 ; 1767 1768 regular_invalid_at_rule_header: 1769 keyframes_rule_start at_rule_header_recovery 1770 | before_page_rule PAGE_SYM at_rule_header_recovery 1771 | before_font_face_rule FONT_FACE_SYM at_rule_header_recovery 1772 | before_supports_rule SUPPORTS_SYM error error_location rule_error_recovery { 1773 parser->reportError($4, InvalidSupportsConditionCSSError); 1774 parser->popSupportsRuleData(); 1775 } 1776 | before_viewport_rule VIEWPORT_RULE_SYM at_rule_header_recovery { 1777 parser->markViewportRuleBodyEnd(); 1778 } 1779 | import_rule_start at_rule_header_recovery 1780 | NAMESPACE_SYM at_rule_header_recovery 1781 | error_location invalid_at at_rule_header_recovery { 1782 parser->resumeErrorLogging(); 1783 parser->reportError($1, InvalidRuleCSSError); 1784 } 1785 ; 1786 1787 invalid_rule: 1788 error error_location rule_error_recovery at_invalid_rule_header_end invalid_block { 1789 parser->reportError($2, InvalidRuleCSSError); 1790 } 1791 | regular_invalid_at_rule_header at_invalid_rule_header_end ';' 1792 | regular_invalid_at_rule_header at_invalid_rule_header_end invalid_block 1793 | media_rule_start maybe_media_list ';' 1794 ; 1795 1796 invalid_rule_header: 1797 error error_location rule_error_recovery at_invalid_rule_header_end { 1798 parser->reportError($2, InvalidRuleCSSError); 1799 } 1800 | regular_invalid_at_rule_header at_invalid_rule_header_end 1801 | media_rule_start maybe_media_list 1802 ; 1803 1804 at_invalid_rule_header_end: 1805 /* empty */ { 1806 parser->endInvalidRuleHeader(); 1807 } 1808 ; 1809 1810 invalid_block: 1811 '{' error_recovery closing_brace { 1812 parser->invalidBlockHit(); 1813 } 1814 ; 1815 1816 invalid_square_brackets_block: 1817 '[' error_recovery closing_square_bracket 1818 ; 1819 1820 invalid_parentheses_block: 1821 opening_parenthesis error_recovery closing_parenthesis; 1822 1823 opening_parenthesis: 1824 '(' | FUNCTION | CALCFUNCTION | ANYFUNCTION | NOTFUNCTION | CUEFUNCTION | DISTRIBUTEDFUNCTION | HOSTFUNCTION 1825 ; 1826 1827 error_location: { 1828 $$ = parser->currentLocation(); 1829 } 1830 ; 1831 1832 location_label: { 1833 parser->setLocationLabel(parser->currentLocation()); 1834 } 1835 ; 1836 1837 error_recovery: 1838 /* empty */ 1839 | error_recovery error 1840 | error_recovery invalid_block 1841 | error_recovery invalid_square_brackets_block 1842 | error_recovery invalid_parentheses_block 1843 ; 1844 1845 rule_error_recovery: 1846 /* empty */ 1847 | rule_error_recovery error 1848 | rule_error_recovery invalid_square_brackets_block 1849 | rule_error_recovery invalid_parentheses_block 1850 ; 1851 1852 %% 1853
