1 %{
2
3 /*
4 * Copyright (C) 2002-2003 Lars Knoll (knoll@kde.org)
5 * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2010 Apple Inc. All rights reserved.
6 * Copyright (C) 2006 Alexey Proskuryakov (ap@nypop.com)
7 * Copyright (C) 2008 Eric Seidel <eric@webkit.org>
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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
22 *
23 */
24
25 #include "config.h"
26
27 #include "CSSMediaRule.h"
28 #include "CSSParser.h"
29 #include "CSSPrimitiveValue.h"
30 #include "CSSPropertyNames.h"
31 #include "CSSRuleList.h"
32 #include "CSSSelector.h"
33 #include "CSSStyleSheet.h"
34 #include "Document.h"
35 #include "HTMLNames.h"
36 #include "MediaList.h"
37 #include "MediaQueryExp.h"
38 #include "WebKitCSSKeyframeRule.h"
39 #include "WebKitCSSKeyframesRule.h"
40 #include <wtf/FastMalloc.h>
41 #include <stdlib.h>
42 #include <string.h>
43
44 using namespace WebCore;
45 using namespace HTMLNames;
46
47 #define YYMALLOC fastMalloc
48 #define YYFREE fastFree
49
50 #define YYENABLE_NLS 0
51 #define YYLTYPE_IS_TRIVIAL 1
52 #define YYMAXDEPTH 10000
53 #define YYDEBUG 0
54
55 // FIXME: Replace with %parse-param { CSSParser* parser } once we can depend on bison 2.x
56 #define YYPARSE_PARAM parser
57 #define YYLEX_PARAM parser
58
59 %}
60
61 %pure_parser
62
63 %union {
64 bool boolean;
65 char character;
66 int integer;
67 double number;
68 CSSParserString string;
69
70 CSSRule* rule;
71 CSSRuleList* ruleList;
72 CSSParserSelector* selector;
73 Vector<OwnPtr<CSSParserSelector> >* selectorList;
74 CSSSelector::MarginBoxType marginBox;
75 CSSSelector::Relation relation;
76 MediaList* mediaList;
77 MediaQuery* mediaQuery;
78 MediaQuery::Restrictor mediaQueryRestrictor;
79 MediaQueryExp* mediaQueryExp;
80 CSSParserValue value;
81 CSSParserValueList* valueList;
82 Vector<OwnPtr<MediaQueryExp> >* mediaQueryExpList;
83 WebKitCSSKeyframeRule* keyframeRule;
84 WebKitCSSKeyframesRule* keyframesRule;
85 float val;
86 }
87
88 %{
89
cssyyerror(const char *)90 static inline int cssyyerror(const char*)
91 {
92 return 1;
93 }
94
cssyylex(YYSTYPE * yylval,void * parser)95 static int cssyylex(YYSTYPE* yylval, void* parser)
96 {
97 return static_cast<CSSParser*>(parser)->lex(yylval);
98 }
99
100 %}
101
102 %expect 54
103
104 %nonassoc LOWEST_PREC
105
106 %left UNIMPORTANT_TOK
107
108 %token WHITESPACE SGML_CD
109 %token TOKEN_EOF 0
110
111 %token INCLUDES
112 %token DASHMATCH
113 %token BEGINSWITH
114 %token ENDSWITH
115 %token CONTAINS
116
117 %token <string> STRING
118 %right <string> IDENT
119 %token <string> NTH
120
121 %nonassoc <string> HEX
122 %nonassoc <string> IDSEL
123 %nonassoc ':'
124 %nonassoc '.'
125 %nonassoc '['
126 %nonassoc <string> '*'
127 %nonassoc error
128 %left '|'
129
130 %token IMPORT_SYM
131 %token PAGE_SYM
132 %token MEDIA_SYM
133 %token FONT_FACE_SYM
134 %token CHARSET_SYM
135 %token NAMESPACE_SYM
136 %token WEBKIT_RULE_SYM
137 %token WEBKIT_DECLS_SYM
138 %token WEBKIT_KEYFRAME_RULE_SYM
139 %token WEBKIT_KEYFRAMES_SYM
140 %token WEBKIT_VALUE_SYM
141 %token WEBKIT_MEDIAQUERY_SYM
142 %token WEBKIT_SELECTOR_SYM
143 %token <marginBox> TOPLEFTCORNER_SYM
144 %token <marginBox> TOPLEFT_SYM
145 %token <marginBox> TOPCENTER_SYM
146 %token <marginBox> TOPRIGHT_SYM
147 %token <marginBox> TOPRIGHTCORNER_SYM
148 %token <marginBox> BOTTOMLEFTCORNER_SYM
149 %token <marginBox> BOTTOMLEFT_SYM
150 %token <marginBox> BOTTOMCENTER_SYM
151 %token <marginBox> BOTTOMRIGHT_SYM
152 %token <marginBox> BOTTOMRIGHTCORNER_SYM
153 %token <marginBox> LEFTTOP_SYM
154 %token <marginBox> LEFTMIDDLE_SYM
155 %token <marginBox> LEFTBOTTOM_SYM
156 %token <marginBox> RIGHTTOP_SYM
157 %token <marginBox> RIGHTMIDDLE_SYM
158 %token <marginBox> RIGHTBOTTOM_SYM
159
160 %token ATKEYWORD
161
162 %token IMPORTANT_SYM
163 %token MEDIA_ONLY
164 %token MEDIA_NOT
165 %token MEDIA_AND
166
167 %token <number> REMS
168 %token <number> QEMS
169 %token <number> EMS
170 %token <number> EXS
171 %token <number> PXS
172 %token <number> CMS
173 %token <number> MMS
174 %token <number> INS
175 %token <number> PTS
176 %token <number> PCS
177 %token <number> DEGS
178 %token <number> RADS
179 %token <number> GRADS
180 %token <number> TURNS
181 %token <number> MSECS
182 %token <number> SECS
183 %token <number> HERTZ
184 %token <number> KHERTZ
185 %token <string> DIMEN
186 %token <string> INVALIDDIMEN
187 %token <number> PERCENTAGE
188 %token <number> FLOATTOKEN
189 %token <number> INTEGER
190
191 %token <string> URI
192 %token <string> FUNCTION
193 %token <string> ANYFUNCTION
194 %token <string> NOTFUNCTION
195 %token <string> CALCFUNCTION
196 %token <string> MINFUNCTION
197 %token <string> MAXFUNCTION
198
199 %token <string> UNICODERANGE
200
201 %type <relation> combinator
202
203 %type <rule> charset
204 %type <rule> ignored_charset
205 %type <rule> ruleset
206 %type <rule> media
207 %type <rule> import
208 %type <rule> namespace
209 %type <rule> page
210 %type <rule> margin_box
211 %type <rule> font_face
212 %type <rule> keyframes
213 %type <rule> invalid_rule
214 %type <rule> save_block
215 %type <rule> invalid_at
216 %type <rule> rule
217 %type <rule> valid_rule
218 %type <ruleList> block_rule_list
219 %type <rule> block_rule
220 %type <rule> block_valid_rule
221
222 %type <string> maybe_ns_prefix
223
224 %type <string> namespace_selector
225
226 %type <string> string_or_uri
227 %type <string> ident_or_string
228 %type <string> medium
229 %type <marginBox> margin_sym
230
231 %type <string> media_feature
232 %type <mediaList> media_list
233 %type <mediaList> maybe_media_list
234 %type <mediaQuery> media_query
235 %type <mediaQueryRestrictor> maybe_media_restrictor
236 %type <valueList> maybe_media_value
237 %type <mediaQueryExp> media_query_exp
238 %type <mediaQueryExpList> media_query_exp_list
239 %type <mediaQueryExpList> maybe_and_media_query_exp_list
240
241 %type <string> keyframe_name
242 %type <keyframeRule> keyframe_rule
243 %type <keyframesRule> keyframes_rule
244 %type <valueList> key_list
245 %type <value> key
246
247 %type <integer> property
248
249 %type <selector> specifier
250 %type <selector> specifier_list
251 %type <selector> simple_selector
252 %type <selector> selector
253 %type <selectorList> selector_list
254 %type <selectorList> simple_selector_list
255 %type <selector> selector_with_trailing_whitespace
256 %type <selector> class
257 %type <selector> attrib
258 %type <selector> pseudo
259 %type <selector> pseudo_page
260 %type <selector> page_selector
261
262 %type <boolean> declaration_list
263 %type <boolean> decl_list
264 %type <boolean> declaration
265 %type <boolean> declarations_and_margins
266
267 %type <boolean> prio
268
269 %type <integer> match
270 %type <integer> unary_operator
271 %type <integer> maybe_unary_operator
272 %type <character> operator
273
274 %type <valueList> expr
275 %type <value> term
276 %type <value> unary_term
277 %type <value> function
278 %type <value> calc_func_term
279 %type <character> calc_func_operator
280 %type <valueList> calc_func_expr
281 %type <valueList> calc_func_expr_list
282 %type <valueList> calc_func_paren_expr
283 %type <value> calc_function
284 %type <string> min_or_max
285 %type <value> min_or_max_function
286
287 %type <string> element_name
288 %type <string> attr_name
289
290 %%
291
292 stylesheet:
293 maybe_space maybe_charset maybe_sgml rule_list
294 | webkit_rule maybe_space
295 | webkit_decls maybe_space
296 | webkit_value maybe_space
297 | webkit_mediaquery maybe_space
298 | webkit_selector maybe_space
299 | webkit_keyframe_rule maybe_space
300 ;
301
302 webkit_rule:
303 WEBKIT_RULE_SYM '{' maybe_space valid_rule maybe_space '}' {
304 static_cast<CSSParser*>(parser)->m_rule = $4;
305 }
306 ;
307
308 webkit_keyframe_rule:
309 WEBKIT_KEYFRAME_RULE_SYM '{' maybe_space keyframe_rule maybe_space '}' {
310 static_cast<CSSParser*>(parser)->m_keyframe = $4;
311 }
312 ;
313
314 webkit_decls:
315 WEBKIT_DECLS_SYM '{' maybe_space_before_declaration declaration_list '}' {
316 /* can be empty */
317 }
318 ;
319
320 webkit_value:
321 WEBKIT_VALUE_SYM '{' maybe_space expr '}' {
322 CSSParser* p = static_cast<CSSParser*>(parser);
323 if ($4) {
324 p->m_valueList = p->sinkFloatingValueList($4);
325 int oldParsedProperties = p->m_numParsedProperties;
326 if (!p->parseValue(p->m_id, p->m_important))
327 p->rollbackLastProperties(p->m_numParsedProperties - oldParsedProperties);
328 delete p->m_valueList;
329 p->m_valueList = 0;
330 }
331 }
332 ;
333
334 webkit_mediaquery:
335 WEBKIT_MEDIAQUERY_SYM WHITESPACE maybe_space media_query '}' {
336 CSSParser* p = static_cast<CSSParser*>(parser);
337 p->m_mediaQuery = p->sinkFloatingMediaQuery($4);
338 }
339 ;
340
341 webkit_selector:
342 WEBKIT_SELECTOR_SYM '{' maybe_space selector_list '}' {
343 if ($4) {
344 CSSParser* p = static_cast<CSSParser*>(parser);
345 if (p->m_selectorListForParseSelector)
346 p->m_selectorListForParseSelector->adoptSelectorVector(*$4);
347 }
348 }
349 ;
350
351 maybe_space:
352 /* empty */ %prec UNIMPORTANT_TOK
353 | maybe_space WHITESPACE
354 ;
355
356 maybe_sgml:
357 /* empty */
358 | maybe_sgml SGML_CD
359 | maybe_sgml WHITESPACE
360 ;
361
362 maybe_charset:
363 /* empty */
364 | charset {
365 }
366 ;
367
368 closing_brace:
369 '}'
370 | %prec LOWEST_PREC TOKEN_EOF
371 ;
372
373 charset:
374 CHARSET_SYM maybe_space STRING maybe_space ';' {
375 CSSParser* p = static_cast<CSSParser*>(parser);
376 $$ = static_cast<CSSParser*>(parser)->createCharsetRule($3);
377 if ($$ && p->m_styleSheet)
378 p->m_styleSheet->append($$);
379 }
380 | CHARSET_SYM error invalid_block {
381 }
382 | CHARSET_SYM error ';' {
383 }
384 ;
385
386 ignored_charset:
387 CHARSET_SYM maybe_space STRING maybe_space ';' {
388 // Ignore any @charset rule not at the beginning of the style sheet.
389 $$ = 0;
390 }
391 ;
392
393 rule_list:
394 /* empty */
395 | rule_list rule maybe_sgml {
396 CSSParser* p = static_cast<CSSParser*>(parser);
397 if ($2 && p->m_styleSheet)
398 p->m_styleSheet->append($2);
399 }
400 ;
401
402 valid_rule:
403 before_ruleset ruleset {
404 $$ = $2;
405 }
406 | media
407 | page
408 | font_face
409 | keyframes
410 | namespace
411 | import
412 ;
413
414 rule:
415 valid_rule {
416 static_cast<CSSParser*>(parser)->m_hadSyntacticallyValidCSSRule = true;
417 }
418 | ignored_charset
419 | invalid_rule
420 | invalid_at
421 ;
422
423 block_rule_list:
424 /* empty */ { $$ = 0; }
425 | block_rule_list block_rule maybe_sgml {
426 $$ = $1;
427 if ($2) {
428 if (!$$)
429 $$ = static_cast<CSSParser*>(parser)->createRuleList();
430 $$->append($2);
431 }
432 }
433 ;
434
435 block_valid_rule:
436 ruleset
437 | page
438 | font_face
439 | keyframes
440 ;
441
442 block_rule:
443 block_valid_rule
444 | invalid_rule
445 | invalid_at
446 | namespace
447 | import
448 | media
449 ;
450
451
452 import:
453 IMPORT_SYM maybe_space string_or_uri maybe_space maybe_media_list ';' {
454 $$ = static_cast<CSSParser*>(parser)->createImportRule($3, $5);
455 }
456 | IMPORT_SYM maybe_space string_or_uri maybe_space maybe_media_list invalid_block {
457 $$ = 0;
458 }
459 | IMPORT_SYM error ';' {
460 $$ = 0;
461 }
462 | IMPORT_SYM error invalid_block {
463 $$ = 0;
464 }
465 ;
466
467 namespace:
468 NAMESPACE_SYM maybe_space maybe_ns_prefix string_or_uri maybe_space ';' {
469 static_cast<CSSParser*>(parser)->addNamespace($3, $4);
470 $$ = 0;
471 }
472 | NAMESPACE_SYM maybe_space maybe_ns_prefix string_or_uri maybe_space invalid_block {
473 $$ = 0;
474 }
475 | NAMESPACE_SYM error invalid_block {
476 $$ = 0;
477 }
478 | NAMESPACE_SYM error ';' {
479 $$ = 0;
480 }
481 ;
482
483 maybe_ns_prefix:
484 /* empty */ { $$.characters = 0; }
485 | IDENT maybe_space { $$ = $1; }
486 ;
487
488 string_or_uri:
489 STRING
490 | URI
491 ;
492
493 media_feature:
494 IDENT maybe_space {
495 $$ = $1;
496 }
497 ;
498
499 maybe_media_value:
500 /*empty*/ {
501 $$ = 0;
502 }
503 | ':' maybe_space expr maybe_space {
504 $$ = $3;
505 }
506 ;
507
508 media_query_exp:
509 '(' maybe_space media_feature maybe_space maybe_media_value ')' maybe_space {
510 $3.lower();
511 $$ = static_cast<CSSParser*>(parser)->createFloatingMediaQueryExp($3, $5);
512 }
513 ;
514
515 media_query_exp_list:
516 media_query_exp {
517 CSSParser* p = static_cast<CSSParser*>(parser);
518 $$ = p->createFloatingMediaQueryExpList();
519 $$->append(p->sinkFloatingMediaQueryExp($1));
520 }
521 | media_query_exp_list maybe_space MEDIA_AND maybe_space media_query_exp {
522 $$ = $1;
523 $$->append(static_cast<CSSParser*>(parser)->sinkFloatingMediaQueryExp($5));
524 }
525 ;
526
527 maybe_and_media_query_exp_list:
528 /*empty*/ {
529 $$ = static_cast<CSSParser*>(parser)->createFloatingMediaQueryExpList();
530 }
531 | MEDIA_AND maybe_space media_query_exp_list {
532 $$ = $3;
533 }
534 ;
535
536 maybe_media_restrictor:
537 /*empty*/ {
538 $$ = MediaQuery::None;
539 }
540 | MEDIA_ONLY {
541 $$ = MediaQuery::Only;
542 }
543 | MEDIA_NOT {
544 $$ = MediaQuery::Not;
545 }
546 ;
547
548 media_query:
549 media_query_exp_list {
550 CSSParser* p = static_cast<CSSParser*>(parser);
551 $$ = p->createFloatingMediaQuery(p->sinkFloatingMediaQueryExpList($1));
552 }
553 |
554 maybe_media_restrictor maybe_space medium maybe_and_media_query_exp_list {
555 CSSParser* p = static_cast<CSSParser*>(parser);
556 $3.lower();
557 $$ = p->createFloatingMediaQuery($1, $3, p->sinkFloatingMediaQueryExpList($4));
558 }
559 ;
560
561 maybe_media_list:
562 /* empty */ {
563 $$ = static_cast<CSSParser*>(parser)->createMediaList();
564 }
565 | media_list
566 ;
567
568 media_list:
569 media_query {
570 CSSParser* p = static_cast<CSSParser*>(parser);
571 $$ = p->createMediaList();
572 $$->appendMediaQuery(p->sinkFloatingMediaQuery($1));
573 }
574 | media_list ',' maybe_space media_query {
575 $$ = $1;
576 if ($$)
577 $$->appendMediaQuery(static_cast<CSSParser*>(parser)->sinkFloatingMediaQuery($4));
578 }
579 | media_list error {
580 $$ = 0;
581 }
582 ;
583
584 media:
585 MEDIA_SYM maybe_space media_list '{' maybe_space block_rule_list save_block {
586 $$ = static_cast<CSSParser*>(parser)->createMediaRule($3, $6);
587 }
588 | MEDIA_SYM maybe_space '{' maybe_space block_rule_list save_block {
589 $$ = static_cast<CSSParser*>(parser)->createMediaRule(0, $5);
590 }
591 ;
592
593 medium:
594 IDENT maybe_space {
595 $$ = $1;
596 }
597 ;
598
599 keyframes:
600 WEBKIT_KEYFRAMES_SYM maybe_space keyframe_name maybe_space '{' maybe_space keyframes_rule '}' {
601 $$ = $7;
602 $7->setNameInternal($3);
603 }
604 ;
605
606 keyframe_name:
607 IDENT
608 | STRING
609 ;
610
611 keyframes_rule:
612 /* empty */ { $$ = static_cast<CSSParser*>(parser)->createKeyframesRule(); }
613 | keyframes_rule keyframe_rule maybe_space {
614 $$ = $1;
615 if ($2)
616 $$->append($2);
617 }
618 ;
619
620 keyframe_rule:
621 key_list maybe_space '{' maybe_space declaration_list '}' {
622 $$ = static_cast<CSSParser*>(parser)->createKeyframeRule($1);
623 }
624 ;
625
626 key_list:
627 key {
628 CSSParser* p = static_cast<CSSParser*>(parser);
629 $$ = p->createFloatingValueList();
630 $$->addValue(p->sinkFloatingValue($1));
631 }
632 | key_list maybe_space ',' maybe_space key {
633 CSSParser* p = static_cast<CSSParser*>(parser);
634 $$ = $1;
635 if ($$)
636 $$->addValue(p->sinkFloatingValue($5));
637 }
638 ;
639
640 key:
641 PERCENTAGE { $$.id = 0; $$.isInt = false; $$.fValue = $1; $$.unit = CSSPrimitiveValue::CSS_NUMBER; }
642 | IDENT {
643 $$.id = 0; $$.isInt = false; $$.unit = CSSPrimitiveValue::CSS_NUMBER;
644 CSSParserString& str = $1;
645 if (equalIgnoringCase("from", str.characters, str.length))
646 $$.fValue = 0;
647 else if (equalIgnoringCase("to", str.characters, str.length))
648 $$.fValue = 100;
649 else
650 YYERROR;
651 }
652 ;
653
654 page:
655 PAGE_SYM maybe_space page_selector maybe_space
656 '{' maybe_space declarations_and_margins closing_brace {
657 CSSParser* p = static_cast<CSSParser*>(parser);
658 if ($3)
659 $$ = p->createPageRule(p->sinkFloatingSelector($3));
660 else {
661 // Clear properties in the invalid @page rule.
662 p->clearProperties();
663 // Also clear margin at-rules here once we fully implement margin at-rules parsing.
664 $$ = 0;
665 }
666 }
667 | PAGE_SYM error invalid_block {
668 $$ = 0;
669 }
670 | PAGE_SYM error ';' {
671 $$ = 0;
672 }
673 ;
674
675 page_selector:
676 IDENT {
677 CSSParser* p = static_cast<CSSParser*>(parser);
678 $$ = p->createFloatingSelector();
679 $$->setTag(QualifiedName(nullAtom, $1, p->m_defaultNamespace));
680 $$->setForPage();
681 }
682 | IDENT pseudo_page {
683 CSSParser* p = static_cast<CSSParser*>(parser);
684 $$ = $2;
685 if ($$) {
686 $$->setTag(QualifiedName(nullAtom, $1, p->m_defaultNamespace));
687 $$->setForPage();
688 }
689 }
690 | pseudo_page {
691 $$ = $1;
692 if ($$)
693 $$->setForPage();
694 }
695 | /* empty */ {
696 CSSParser* p = static_cast<CSSParser*>(parser);
697 $$ = p->createFloatingSelector();
698 $$->setForPage();
699 }
700 ;
701
702 declarations_and_margins:
703 declaration_list
704 | declarations_and_margins margin_box maybe_space declaration_list
705 ;
706
707 margin_box:
708 margin_sym {
709 static_cast<CSSParser*>(parser)->startDeclarationsForMarginBox();
710 } maybe_space '{' maybe_space declaration_list closing_brace {
711 $$ = static_cast<CSSParser*>(parser)->createMarginAtRule($1);
712 }
713 ;
714
715 margin_sym :
716 TOPLEFTCORNER_SYM {
717 $$ = CSSSelector::TopLeftCornerMarginBox;
718 }
719 | TOPLEFT_SYM {
720 $$ = CSSSelector::TopLeftMarginBox;
721 }
722 | TOPCENTER_SYM {
723 $$ = CSSSelector::TopCenterMarginBox;
724 }
725 | TOPRIGHT_SYM {
726 $$ = CSSSelector::TopRightMarginBox;
727 }
728 | TOPRIGHTCORNER_SYM {
729 $$ = CSSSelector::TopRightCornerMarginBox;
730 }
731 | BOTTOMLEFTCORNER_SYM {
732 $$ = CSSSelector::BottomLeftCornerMarginBox;
733 }
734 | BOTTOMLEFT_SYM {
735 $$ = CSSSelector::BottomLeftMarginBox;
736 }
737 | BOTTOMCENTER_SYM {
738 $$ = CSSSelector::BottomCenterMarginBox;
739 }
740 | BOTTOMRIGHT_SYM {
741 $$ = CSSSelector::BottomRightMarginBox;
742 }
743 | BOTTOMRIGHTCORNER_SYM {
744 $$ = CSSSelector::BottomRightCornerMarginBox;
745 }
746 | LEFTTOP_SYM {
747 $$ = CSSSelector::LeftTopMarginBox;
748 }
749 | LEFTMIDDLE_SYM {
750 $$ = CSSSelector::LeftMiddleMarginBox;
751 }
752 | LEFTBOTTOM_SYM {
753 $$ = CSSSelector::LeftBottomMarginBox;
754 }
755 | RIGHTTOP_SYM {
756 $$ = CSSSelector::RightTopMarginBox;
757 }
758 | RIGHTMIDDLE_SYM {
759 $$ = CSSSelector::RightMiddleMarginBox;
760 }
761 | RIGHTBOTTOM_SYM {
762 $$ = CSSSelector::RightBottomMarginBox;
763 }
764 ;
765
766 font_face:
767 FONT_FACE_SYM maybe_space
768 '{' maybe_space declaration_list '}' maybe_space {
769 $$ = static_cast<CSSParser*>(parser)->createFontFaceRule();
770 }
771 | FONT_FACE_SYM error invalid_block {
772 $$ = 0;
773 }
774 | FONT_FACE_SYM error ';' {
775 $$ = 0;
776 }
777 ;
778
779 combinator:
780 '+' maybe_space { $$ = CSSSelector::DirectAdjacent; }
781 | '~' maybe_space { $$ = CSSSelector::IndirectAdjacent; }
782 | '>' maybe_space { $$ = CSSSelector::Child; }
783 ;
784
785 maybe_unary_operator:
786 unary_operator { $$ = $1; }
787 | { $$ = 1; }
788 ;
789
790 unary_operator:
791 '-' { $$ = -1; }
792 | '+' { $$ = 1; }
793 ;
794
795 maybe_space_before_declaration:
796 maybe_space {
797 CSSParser* p = static_cast<CSSParser*>(parser);
798 p->markPropertyStart();
799 }
800 ;
801
802 before_ruleset:
803 /* empty */ {
804 CSSParser* p = static_cast<CSSParser*>(parser);
805 p->markSelectorListStart();
806 }
807 ;
808
809 before_rule_opening_brace:
810 /* empty */ {
811 CSSParser* p = static_cast<CSSParser*>(parser);
812 p->markSelectorListEnd();
813 }
814 ;
815
816 ruleset:
817 selector_list before_rule_opening_brace '{' maybe_space_before_declaration declaration_list closing_brace {
818 CSSParser* p = static_cast<CSSParser*>(parser);
819 $$ = p->createStyleRule($1);
820 }
821 ;
822
823 selector_list:
824 selector %prec UNIMPORTANT_TOK {
825 if ($1) {
826 CSSParser* p = static_cast<CSSParser*>(parser);
827 $$ = p->reusableSelectorVector();
828 $$->shrink(0);
829 $$->append(p->sinkFloatingSelector($1));
830 p->updateLastSelectorLineAndPosition();
831 }
832 }
833 | selector_list ',' maybe_space selector %prec UNIMPORTANT_TOK {
834 if ($1 && $4) {
835 CSSParser* p = static_cast<CSSParser*>(parser);
836 $$ = $1;
837 $$->append(p->sinkFloatingSelector($4));
838 p->updateLastSelectorLineAndPosition();
839 } else
840 $$ = 0;
841 }
842 | selector_list error {
843 $$ = 0;
844 }
845 ;
846
847 selector_with_trailing_whitespace:
848 selector WHITESPACE {
849 $$ = $1;
850 }
851 ;
852
853 selector:
854 simple_selector {
855 $$ = $1;
856 }
857 | selector_with_trailing_whitespace
858 {
859 $$ = $1;
860 }
861 | selector_with_trailing_whitespace simple_selector
862 {
863 $$ = $2;
864 if (!$1)
865 $$ = 0;
866 else if ($$) {
867 CSSParser* p = static_cast<CSSParser*>(parser);
868 CSSParserSelector* end = $$;
869 while (end->tagHistory())
870 end = end->tagHistory();
871 end->setRelation(CSSSelector::Descendant);
872 end->setTagHistory(p->sinkFloatingSelector($1));
873 }
874 }
875 | selector combinator simple_selector {
876 $$ = $3;
877 if (!$1)
878 $$ = 0;
879 else if ($$) {
880 CSSParser* p = static_cast<CSSParser*>(parser);
881 CSSParserSelector* end = $$;
882 while (end->tagHistory())
883 end = end->tagHistory();
884 end->setRelation($2);
885 end->setTagHistory(p->sinkFloatingSelector($1));
886 }
887 }
888 | selector error {
889 $$ = 0;
890 }
891 ;
892
893 namespace_selector:
894 /* empty */ '|' { $$.characters = 0; $$.length = 0; }
895 | '*' '|' { static UChar star = '*'; $$.characters = ☆ $$.length = 1; }
896 | IDENT '|' { $$ = $1; }
897 ;
898
899 simple_selector:
900 element_name {
901 CSSParser* p = static_cast<CSSParser*>(parser);
902 $$ = p->createFloatingSelector();
903 $$->setTag(QualifiedName(nullAtom, $1, p->m_defaultNamespace));
904 }
905 | element_name specifier_list {
906 $$ = $2;
907 if ($$)
908 static_cast<CSSParser*>(parser)->updateSpecifiersWithElementName(nullAtom, $1, $$);
909 }
910 | specifier_list {
911 $$ = $1;
912 if ($$)
913 static_cast<CSSParser*>(parser)->updateSpecifiersWithElementName(nullAtom, starAtom, $$);
914 }
915 | namespace_selector element_name {
916 AtomicString namespacePrefix = $1;
917 CSSParser* p = static_cast<CSSParser*>(parser);
918 $$ = p->createFloatingSelector();
919 if (p->m_styleSheet)
920 $$->setTag(QualifiedName(namespacePrefix, $2,
921 p->m_styleSheet->determineNamespace(namespacePrefix)));
922 else // FIXME: Shouldn't this case be an error?
923 $$->setTag(QualifiedName(nullAtom, $2, p->m_defaultNamespace));
924 }
925 | namespace_selector element_name specifier_list {
926 $$ = $3;
927 if ($$)
928 static_cast<CSSParser*>(parser)->updateSpecifiersWithElementName($1, $2, $$);
929 }
930 | namespace_selector specifier_list {
931 $$ = $2;
932 if ($$)
933 static_cast<CSSParser*>(parser)->updateSpecifiersWithElementName($1, starAtom, $$);
934 }
935 ;
936
937 simple_selector_list:
938 simple_selector %prec UNIMPORTANT_TOK {
939 if ($1) {
940 CSSParser* p = static_cast<CSSParser*>(parser);
941 $$ = p->createFloatingSelectorVector();
942 $$->append(p->sinkFloatingSelector($1));
943 } else
944 $$ = 0
945 }
946 | simple_selector_list maybe_space ',' maybe_space simple_selector %prec UNIMPORTANT_TOK {
947 if ($1 && $5) {
948 CSSParser* p = static_cast<CSSParser*>(parser);
949 $$ = $1;
950 $$->append(p->sinkFloatingSelector($5));
951 } else
952 $$ = 0;
953 }
954 | simple_selector_list error {
955 $$ = 0;
956 }
957 ;
958
959 element_name:
960 IDENT {
961 CSSParserString& str = $1;
962 CSSParser* p = static_cast<CSSParser*>(parser);
963 Document* doc = p->document();
964 if (doc && doc->isHTMLDocument())
965 str.lower();
966 $$ = str;
967 }
968 | '*' {
969 static UChar star = '*';
970 $$.characters = ☆
971 $$.length = 1;
972 }
973 ;
974
975 specifier_list:
976 specifier {
977 $$ = $1;
978 }
979 | specifier_list specifier {
980 if (!$2)
981 $$ = 0;
982 else if ($1) {
983 CSSParser* p = static_cast<CSSParser*>(parser);
984 CSSParserSelector* end;
985 CSSParserSelector* history;
986 // Ensure that unknown pseudo element always stays at the top of selector chain.
987 if ($2->isUnknownPseudoElement()) {
988 end = $2;
989 history = $1;
990 } else {
991 end = $1;
992 history = $2;
993 }
994 $$ = end;
995 while(end->tagHistory())
996 end = end->tagHistory();
997 end->setRelation(CSSSelector::SubSelector);
998 end->setTagHistory(p->sinkFloatingSelector(history));
999 }
1000 }
1001 | specifier_list error {
1002 $$ = 0;
1003 }
1004 ;
1005
1006 specifier:
1007 IDSEL {
1008 CSSParser* p = static_cast<CSSParser*>(parser);
1009 $$ = p->createFloatingSelector();
1010 $$->setMatch(CSSSelector::Id);
1011 if (!p->m_strict)
1012 $1.lower();
1013 $$->setValue($1);
1014 }
1015 | HEX {
1016 if ($1.characters[0] >= '0' && $1.characters[0] <= '9') {
1017 $$ = 0;
1018 } else {
1019 CSSParser* p = static_cast<CSSParser*>(parser);
1020 $$ = p->createFloatingSelector();
1021 $$->setMatch(CSSSelector::Id);
1022 if (!p->m_strict)
1023 $1.lower();
1024 $$->setValue($1);
1025 }
1026 }
1027 | class
1028 | attrib
1029 | pseudo
1030 ;
1031
1032 class:
1033 '.' IDENT {
1034 CSSParser* p = static_cast<CSSParser*>(parser);
1035 $$ = p->createFloatingSelector();
1036 $$->setMatch(CSSSelector::Class);
1037 if (!p->m_strict)
1038 $2.lower();
1039 $$->setValue($2);
1040 }
1041 ;
1042
1043 attr_name:
1044 IDENT maybe_space {
1045 CSSParserString& str = $1;
1046 CSSParser* p = static_cast<CSSParser*>(parser);
1047 Document* doc = p->document();
1048 if (doc && doc->isHTMLDocument())
1049 str.lower();
1050 $$ = str;
1051 }
1052 ;
1053
1054 attrib:
1055 '[' maybe_space attr_name ']' {
1056 $$ = static_cast<CSSParser*>(parser)->createFloatingSelector();
1057 $$->setAttribute(QualifiedName(nullAtom, $3, nullAtom));
1058 $$->setMatch(CSSSelector::Set);
1059 }
1060 | '[' maybe_space attr_name match maybe_space ident_or_string maybe_space ']' {
1061 $$ = static_cast<CSSParser*>(parser)->createFloatingSelector();
1062 $$->setAttribute(QualifiedName(nullAtom, $3, nullAtom));
1063 $$->setMatch((CSSSelector::Match)$4);
1064 $$->setValue($6);
1065 }
1066 | '[' maybe_space namespace_selector attr_name ']' {
1067 AtomicString namespacePrefix = $3;
1068 CSSParser* p = static_cast<CSSParser*>(parser);
1069 $$ = p->createFloatingSelector();
1070 $$->setAttribute(QualifiedName(namespacePrefix, $4,
1071 p->m_styleSheet->determineNamespace(namespacePrefix)));
1072 $$->setMatch(CSSSelector::Set);
1073 }
1074 | '[' maybe_space namespace_selector attr_name match maybe_space ident_or_string maybe_space ']' {
1075 AtomicString namespacePrefix = $3;
1076 CSSParser* p = static_cast<CSSParser*>(parser);
1077 $$ = p->createFloatingSelector();
1078 $$->setAttribute(QualifiedName(namespacePrefix, $4,
1079 p->m_styleSheet->determineNamespace(namespacePrefix)));
1080 $$->setMatch((CSSSelector::Match)$5);
1081 $$->setValue($7);
1082 }
1083 ;
1084
1085 match:
1086 '=' {
1087 $$ = CSSSelector::Exact;
1088 }
1089 | INCLUDES {
1090 $$ = CSSSelector::List;
1091 }
1092 | DASHMATCH {
1093 $$ = CSSSelector::Hyphen;
1094 }
1095 | BEGINSWITH {
1096 $$ = CSSSelector::Begin;
1097 }
1098 | ENDSWITH {
1099 $$ = CSSSelector::End;
1100 }
1101 | CONTAINS {
1102 $$ = CSSSelector::Contain;
1103 }
1104 ;
1105
1106 ident_or_string:
1107 IDENT
1108 | STRING
1109 ;
1110
1111 pseudo_page:
1112 ':' IDENT {
1113 $$ = static_cast<CSSParser*>(parser)->createFloatingSelector();
1114 $$->setMatch(CSSSelector::PagePseudoClass);
1115 $2.lower();
1116 $$->setValue($2);
1117 CSSSelector::PseudoType type = $$->pseudoType();
1118 if (type == CSSSelector::PseudoUnknown)
1119 $$ = 0;
1120 }
1121
1122 pseudo:
1123 ':' IDENT {
1124 $$ = static_cast<CSSParser*>(parser)->createFloatingSelector();
1125 $$->setMatch(CSSSelector::PseudoClass);
1126 $2.lower();
1127 $$->setValue($2);
1128 CSSSelector::PseudoType type = $$->pseudoType();
1129 if (type == CSSSelector::PseudoUnknown)
1130 $$ = 0;
1131 }
1132 | ':' ':' IDENT {
1133 $$ = static_cast<CSSParser*>(parser)->createFloatingSelector();
1134 $$->setMatch(CSSSelector::PseudoElement);
1135 $3.lower();
1136 $$->setValue($3);
1137 // FIXME: This call is needed to force selector to compute the pseudoType early enough.
1138 $$->pseudoType();
1139 }
1140 // use by :-webkit-any.
1141 // FIXME: should we support generic selectors here or just simple_selectors?
1142 // Use simple_selector_list for now to match -moz-any.
1143 // See http://lists.w3.org/Archives/Public/www-style/2010Sep/0566.html for some
1144 // related discussion with respect to :not.
1145 | ':' ANYFUNCTION maybe_space simple_selector_list maybe_space ')' {
1146 if ($4) {
1147 CSSParser *p = static_cast<CSSParser*>(parser);
1148 $$ = p->createFloatingSelector();
1149 $$->setMatch(CSSSelector::PseudoClass);
1150 $$->adoptSelectorVector(*p->sinkFloatingSelectorVector($4));
1151 $2.lower();
1152 $$->setValue($2);
1153 CSSSelector::PseudoType type = $$->pseudoType();
1154 if (type != CSSSelector::PseudoAny)
1155 $$ = 0;
1156 } else
1157 $$ = 0;
1158 }
1159 // used by :nth-*(ax+b)
1160 | ':' FUNCTION maybe_space NTH maybe_space ')' {
1161 CSSParser *p = static_cast<CSSParser*>(parser);
1162 $$ = p->createFloatingSelector();
1163 $$->setMatch(CSSSelector::PseudoClass);
1164 $$->setArgument($4);
1165 $$->setValue($2);
1166 CSSSelector::PseudoType type = $$->pseudoType();
1167 if (type == CSSSelector::PseudoUnknown)
1168 $$ = 0;
1169 }
1170 // used by :nth-*
1171 | ':' FUNCTION maybe_space maybe_unary_operator INTEGER maybe_space ')' {
1172 CSSParser *p = static_cast<CSSParser*>(parser);
1173 $$ = p->createFloatingSelector();
1174 $$->setMatch(CSSSelector::PseudoClass);
1175 $$->setArgument(String::number($4 * $5));
1176 $$->setValue($2);
1177 CSSSelector::PseudoType type = $$->pseudoType();
1178 if (type == CSSSelector::PseudoUnknown)
1179 $$ = 0;
1180 }
1181 // used by :nth-*(odd/even) and :lang
1182 | ':' FUNCTION maybe_space IDENT maybe_space ')' {
1183 CSSParser *p = static_cast<CSSParser*>(parser);
1184 $$ = p->createFloatingSelector();
1185 $$->setMatch(CSSSelector::PseudoClass);
1186 $$->setArgument($4);
1187 $2.lower();
1188 $$->setValue($2);
1189 CSSSelector::PseudoType type = $$->pseudoType();
1190 if (type == CSSSelector::PseudoUnknown)
1191 $$ = 0;
1192 else if (type == CSSSelector::PseudoNthChild ||
1193 type == CSSSelector::PseudoNthOfType ||
1194 type == CSSSelector::PseudoNthLastChild ||
1195 type == CSSSelector::PseudoNthLastOfType) {
1196 if (!isValidNthToken($4))
1197 $$ = 0;
1198 }
1199 }
1200 // used by :not
1201 | ':' NOTFUNCTION maybe_space simple_selector maybe_space ')' {
1202 if (!$4 || !$4->isSimple())
1203 $$ = 0;
1204 else {
1205 CSSParser* p = static_cast<CSSParser*>(parser);
1206 $$ = p->createFloatingSelector();
1207 $$->setMatch(CSSSelector::PseudoClass);
1208
1209 Vector<OwnPtr<CSSParserSelector> > selectorVector;
1210 selectorVector.append(p->sinkFloatingSelector($4));
1211 $$->adoptSelectorVector(selectorVector);
1212
1213 $2.lower();
1214 $$->setValue($2);
1215 }
1216 }
1217 ;
1218
1219 declaration_list:
1220 declaration {
1221 $$ = $1;
1222 }
1223 | decl_list declaration {
1224 $$ = $1;
1225 if ( $2 )
1226 $$ = $2;
1227 }
1228 | decl_list {
1229 $$ = $1;
1230 }
1231 | error invalid_block_list error {
1232 $$ = false;
1233 }
1234 | error {
1235 $$ = false;
1236 }
1237 | decl_list error {
1238 $$ = $1;
1239 }
1240 | decl_list invalid_block_list {
1241 $$ = $1;
1242 }
1243 ;
1244
1245 decl_list:
1246 declaration ';' maybe_space {
1247 CSSParser* p = static_cast<CSSParser*>(parser);
1248 p->markPropertyStart();
1249 $$ = $1;
1250 }
1251 | declaration invalid_block_list maybe_space {
1252 $$ = false;
1253 }
1254 | declaration invalid_block_list ';' maybe_space {
1255 $$ = false;
1256 }
1257 | error ';' maybe_space {
1258 CSSParser* p = static_cast<CSSParser*>(parser);
1259 p->markPropertyStart();
1260 $$ = false;
1261 }
1262 | error invalid_block_list error ';' maybe_space {
1263 $$ = false;
1264 }
1265 | decl_list declaration ';' maybe_space {
1266 CSSParser* p = static_cast<CSSParser*>(parser);
1267 p->markPropertyStart();
1268 $$ = $1;
1269 if ($2)
1270 $$ = $2;
1271 }
1272 | decl_list error ';' maybe_space {
1273 CSSParser* p = static_cast<CSSParser*>(parser);
1274 p->markPropertyStart();
1275 $$ = $1;
1276 }
1277 | decl_list error invalid_block_list error ';' maybe_space {
1278 CSSParser* p = static_cast<CSSParser*>(parser);
1279 p->markPropertyStart();
1280 $$ = $1;
1281 }
1282 ;
1283
1284 declaration:
1285 property ':' maybe_space expr prio {
1286 $$ = false;
1287 CSSParser* p = static_cast<CSSParser*>(parser);
1288 bool isPropertyParsed = false;
1289 if ($1 && $4) {
1290 p->m_valueList = p->sinkFloatingValueList($4);
1291 int oldParsedProperties = p->m_numParsedProperties;
1292 $$ = p->parseValue($1, $5);
1293 if (!$$)
1294 p->rollbackLastProperties(p->m_numParsedProperties - oldParsedProperties);
1295 else
1296 isPropertyParsed = true;
1297 delete p->m_valueList;
1298 p->m_valueList = 0;
1299 }
1300 p->markPropertyEnd($5, isPropertyParsed);
1301 }
1302 |
1303 property error {
1304 $$ = false;
1305 }
1306 |
1307 property ':' maybe_space error expr prio {
1308 /* The default movable type template has letter-spacing: .none; Handle this by looking for
1309 error tokens at the start of an expr, recover the expr and then treat as an error, cleaning
1310 up and deleting the shifted expr. */
1311 CSSParser* p = static_cast<CSSParser*>(parser);
1312 p->markPropertyEnd(false, false);
1313 $$ = false;
1314 }
1315 |
1316 property ':' maybe_space expr prio error {
1317 /* When we encounter something like p {color: red !important fail;} we should drop the declaration */
1318 CSSParser* p = static_cast<CSSParser*>(parser);
1319 p->markPropertyEnd(false, false);
1320 $$ = false;
1321 }
1322 |
1323 IMPORTANT_SYM maybe_space {
1324 /* Handle this case: div { text-align: center; !important } Just reduce away the stray !important. */
1325 $$ = false;
1326 }
1327 |
1328 property ':' maybe_space {
1329 /* div { font-family: } Just reduce away this property with no value. */
1330 CSSParser* p = static_cast<CSSParser*>(parser);
1331 p->markPropertyEnd(false, false);
1332 $$ = false;
1333 }
1334 |
1335 property ':' maybe_space error {
1336 /* if we come across rules with invalid values like this case: p { weight: *; }, just discard the rule */
1337 CSSParser* p = static_cast<CSSParser*>(parser);
1338 p->markPropertyEnd(false, false);
1339 $$ = false;
1340 }
1341 |
1342 property invalid_block {
1343 /* if we come across: div { color{;color:maroon} }, ignore everything within curly brackets */
1344 $$ = false;
1345 }
1346 ;
1347
1348 property:
1349 IDENT maybe_space {
1350 $$ = cssPropertyID($1);
1351 }
1352 ;
1353
1354 prio:
1355 IMPORTANT_SYM maybe_space { $$ = true; }
1356 | /* empty */ { $$ = false; }
1357 ;
1358
1359 expr:
1360 term {
1361 CSSParser* p = static_cast<CSSParser*>(parser);
1362 $$ = p->createFloatingValueList();
1363 $$->addValue(p->sinkFloatingValue($1));
1364 }
1365 | expr operator term {
1366 CSSParser* p = static_cast<CSSParser*>(parser);
1367 $$ = $1;
1368 if ($$) {
1369 if ($2) {
1370 CSSParserValue v;
1371 v.id = 0;
1372 v.unit = CSSParserValue::Operator;
1373 v.iValue = $2;
1374 $$->addValue(v);
1375 }
1376 $$->addValue(p->sinkFloatingValue($3));
1377 }
1378 }
1379 | expr invalid_block_list {
1380 $$ = 0;
1381 }
1382 | expr invalid_block_list error {
1383 $$ = 0;
1384 }
1385 | expr error {
1386 $$ = 0;
1387 }
1388 ;
1389
1390 operator:
1391 '/' maybe_space {
1392 $$ = '/';
1393 }
1394 | ',' maybe_space {
1395 $$ = ',';
1396 }
1397 | /* empty */ {
1398 $$ = 0;
1399 }
1400 ;
1401
1402 term:
1403 unary_term { $$ = $1; }
1404 | unary_operator unary_term { $$ = $2; $$.fValue *= $1; }
1405 | STRING maybe_space { $$.id = 0; $$.string = $1; $$.unit = CSSPrimitiveValue::CSS_STRING; }
1406 | IDENT maybe_space {
1407 $$.id = cssValueKeywordID($1);
1408 $$.unit = CSSPrimitiveValue::CSS_IDENT;
1409 $$.string = $1;
1410 }
1411 /* We might need to actually parse the number from a dimension, but we can't just put something that uses $$.string into unary_term. */
1412 | DIMEN maybe_space { $$.id = 0; $$.string = $1; $$.unit = CSSPrimitiveValue::CSS_DIMENSION; }
1413 | unary_operator DIMEN maybe_space { $$.id = 0; $$.string = $2; $$.unit = CSSPrimitiveValue::CSS_DIMENSION; }
1414 | URI maybe_space { $$.id = 0; $$.string = $1; $$.unit = CSSPrimitiveValue::CSS_URI; }
1415 | UNICODERANGE maybe_space { $$.id = 0; $$.string = $1; $$.unit = CSSPrimitiveValue::CSS_UNICODE_RANGE; }
1416 | HEX maybe_space { $$.id = 0; $$.string = $1; $$.unit = CSSPrimitiveValue::CSS_PARSER_HEXCOLOR; }
1417 | '#' maybe_space { $$.id = 0; $$.string = CSSParserString(); $$.unit = CSSPrimitiveValue::CSS_PARSER_HEXCOLOR; } /* Handle error case: "color: #;" */
1418 /* FIXME: according to the specs a function can have a unary_operator in front. I know no case where this makes sense */
1419 | function {
1420 $$ = $1;
1421 }
1422 | calc_function {
1423 $$ = $1;
1424 }
1425 | min_or_max_function {
1426 $$ = $1;
1427 }
1428 | '%' maybe_space { /* Handle width: %; */
1429 $$.id = 0; $$.unit = 0;
1430 }
1431 ;
1432
1433 unary_term:
1434 INTEGER maybe_space { $$.id = 0; $$.isInt = true; $$.fValue = $1; $$.unit = CSSPrimitiveValue::CSS_NUMBER; }
1435 | FLOATTOKEN maybe_space { $$.id = 0; $$.isInt = false; $$.fValue = $1; $$.unit = CSSPrimitiveValue::CSS_NUMBER; }
1436 | PERCENTAGE maybe_space { $$.id = 0; $$.fValue = $1; $$.unit = CSSPrimitiveValue::CSS_PERCENTAGE; }
1437 | PXS maybe_space { $$.id = 0; $$.fValue = $1; $$.unit = CSSPrimitiveValue::CSS_PX; }
1438 | CMS maybe_space { $$.id = 0; $$.fValue = $1; $$.unit = CSSPrimitiveValue::CSS_CM; }
1439 | MMS maybe_space { $$.id = 0; $$.fValue = $1; $$.unit = CSSPrimitiveValue::CSS_MM; }
1440 | INS maybe_space { $$.id = 0; $$.fValue = $1; $$.unit = CSSPrimitiveValue::CSS_IN; }
1441 | PTS maybe_space { $$.id = 0; $$.fValue = $1; $$.unit = CSSPrimitiveValue::CSS_PT; }
1442 | PCS maybe_space { $$.id = 0; $$.fValue = $1; $$.unit = CSSPrimitiveValue::CSS_PC; }
1443 | DEGS maybe_space { $$.id = 0; $$.fValue = $1; $$.unit = CSSPrimitiveValue::CSS_DEG; }
1444 | RADS maybe_space { $$.id = 0; $$.fValue = $1; $$.unit = CSSPrimitiveValue::CSS_RAD; }
1445 | GRADS maybe_space { $$.id = 0; $$.fValue = $1; $$.unit = CSSPrimitiveValue::CSS_GRAD; }
1446 | TURNS maybe_space { $$.id = 0; $$.fValue = $1; $$.unit = CSSPrimitiveValue::CSS_TURN; }
1447 | MSECS maybe_space { $$.id = 0; $$.fValue = $1; $$.unit = CSSPrimitiveValue::CSS_MS; }
1448 | SECS maybe_space { $$.id = 0; $$.fValue = $1; $$.unit = CSSPrimitiveValue::CSS_S; }
1449 | HERTZ maybe_space { $$.id = 0; $$.fValue = $1; $$.unit = CSSPrimitiveValue::CSS_HZ; }
1450 | KHERTZ maybe_space { $$.id = 0; $$.fValue = $1; $$.unit = CSSPrimitiveValue::CSS_KHZ; }
1451 | EMS maybe_space { $$.id = 0; $$.fValue = $1; $$.unit = CSSPrimitiveValue::CSS_EMS; }
1452 | QEMS maybe_space { $$.id = 0; $$.fValue = $1; $$.unit = CSSParserValue::Q_EMS; }
1453 | EXS maybe_space { $$.id = 0; $$.fValue = $1; $$.unit = CSSPrimitiveValue::CSS_EXS; }
1454 | REMS maybe_space {
1455 $$.id = 0;
1456 $$.fValue = $1;
1457 $$.unit = CSSPrimitiveValue::CSS_REMS;
1458 CSSParser* p = static_cast<CSSParser*>(parser);
1459 if (Document* doc = p->document())
1460 doc->setUsesRemUnits(true);
1461 }
1462 ;
1463
1464 function:
1465 FUNCTION maybe_space expr ')' maybe_space {
1466 CSSParser* p = static_cast<CSSParser*>(parser);
1467 CSSParserFunction* f = p->createFloatingFunction();
1468 f->name = $1;
1469 f->args = p->sinkFloatingValueList($3);
1470 $$.id = 0;
1471 $$.unit = CSSParserValue::Function;
1472 $$.function = f;
1473 } |
1474 FUNCTION maybe_space error {
1475 CSSParser* p = static_cast<CSSParser*>(parser);
1476 CSSParserFunction* f = p->createFloatingFunction();
1477 f->name = $1;
1478 f->args = 0;
1479 $$.id = 0;
1480 $$.unit = CSSParserValue::Function;
1481 $$.function = f;
1482 }
1483 ;
1484
1485 calc_func_term:
1486 unary_term { $$ = $1; }
1487 | unary_operator unary_term { $$ = $2; $$.fValue *= $1; }
1488 ;
1489
1490 calc_func_operator:
1491 '+' WHITESPACE {
1492 $$ = '+';
1493 }
1494 | '-' WHITESPACE {
1495 $$ = '-';
1496 }
1497 | '*' maybe_space {
1498 $$ = '*';
1499 }
1500 | '/' maybe_space {
1501 $$ = '/';
1502 }
1503 | IDENT maybe_space {
1504 if (equalIgnoringCase("mod", $1.characters, $1.length))
1505 $$ = '%';
1506 else
1507 $$ = 0;
1508 }
1509 ;
1510
1511 calc_func_paren_expr:
1512 '(' maybe_space calc_func_expr maybe_space ')' maybe_space {
1513 if ($3) {
1514 $$ = $3;
1515 CSSParserValue v;
1516 v.id = 0;
1517 v.unit = CSSParserValue::Operator;
1518 v.iValue = '(';
1519 $$->insertValueAt(0, v);
1520 v.iValue = ')';
1521 $$->addValue(v);
1522 } else
1523 $$ = 0;
1524 }
1525
1526 calc_func_expr:
1527 calc_func_term maybe_space {
1528 CSSParser* p = static_cast<CSSParser*>(parser);
1529 $$ = p->createFloatingValueList();
1530 $$->addValue(p->sinkFloatingValue($1));
1531 }
1532 | calc_func_expr calc_func_operator calc_func_term {
1533 CSSParser* p = static_cast<CSSParser*>(parser);
1534 if ($1 && $2) {
1535 $$ = $1;
1536 CSSParserValue v;
1537 v.id = 0;
1538 v.unit = CSSParserValue::Operator;
1539 v.iValue = $2;
1540 $$->addValue(v);
1541 $$->addValue(p->sinkFloatingValue($3));
1542 } else
1543 $$ = 0;
1544
1545 }
1546 | calc_func_expr calc_func_operator calc_func_paren_expr {
1547 if ($1 && $2 && $3) {
1548 $$ = $1;
1549 CSSParserValue v;
1550 v.id = 0;
1551 v.unit = CSSParserValue::Operator;
1552 v.iValue = $2;
1553 $$->addValue(v);
1554 $$->extend(*($3));
1555 } else
1556 $$ = 0;
1557 }
1558 | calc_func_paren_expr
1559 | calc_func_expr error {
1560 $$ = 0;
1561 }
1562 ;
1563
1564 calc_func_expr_list:
1565 calc_func_expr {
1566 $$ = $1;
1567 }
1568 | calc_func_expr_list ',' maybe_space calc_func_expr {
1569 if ($1 && $4) {
1570 $$ = $1;
1571 CSSParserValue v;
1572 v.id = 0;
1573 v.unit = CSSParserValue::Operator;
1574 v.iValue = ',';
1575 $$->addValue(v);
1576 $$->extend(*($4));
1577 } else
1578 $$ = 0;
1579 }
1580
1581
1582 calc_function:
1583 CALCFUNCTION maybe_space calc_func_expr ')' maybe_space {
1584 CSSParser* p = static_cast<CSSParser*>(parser);
1585 CSSParserFunction* f = p->createFloatingFunction();
1586 f->name = $1;
1587 f->args = p->sinkFloatingValueList($3);
1588 $$.id = 0;
1589 $$.unit = CSSParserValue::Function;
1590 $$.function = f;
1591 }
1592 | CALCFUNCTION maybe_space error {
1593 YYERROR;
1594 }
1595 ;
1596
1597
1598 min_or_max:
1599 MINFUNCTION {
1600 $$ = $1;
1601 }
1602 | MAXFUNCTION {
1603 $$ = $1;
1604 }
1605 ;
1606
1607 min_or_max_function:
1608 min_or_max maybe_space calc_func_expr_list ')' maybe_space {
1609 CSSParser* p = static_cast<CSSParser*>(parser);
1610 CSSParserFunction* f = p->createFloatingFunction();
1611 f->name = $1;
1612 f->args = p->sinkFloatingValueList($3);
1613 $$.id = 0;
1614 $$.unit = CSSParserValue::Function;
1615 $$.function = f;
1616 }
1617 | min_or_max maybe_space error {
1618 YYERROR;
1619 }
1620 ;
1621
1622 /* error handling rules */
1623
1624 save_block:
1625 closing_brace {
1626 $$ = 0;
1627 }
1628 | error closing_brace {
1629 $$ = 0;
1630 }
1631 ;
1632
1633 invalid_at:
1634 ATKEYWORD error invalid_block {
1635 $$ = 0;
1636 }
1637 | ATKEYWORD error ';' {
1638 $$ = 0;
1639 }
1640 ;
1641
1642 invalid_rule:
1643 error invalid_block {
1644 $$ = 0;
1645 }
1646
1647 /*
1648 Seems like the two rules below are trying too much and violating
1649 http://www.hixie.ch/tests/evil/mixed/csserrorhandling.html
1650
1651 | error ';' {
1652 $$ = 0;
1653 }
1654 | error '}' {
1655 $$ = 0;
1656 }
1657 */
1658 ;
1659
1660 invalid_block:
1661 '{' error invalid_block_list error closing_brace {
1662 static_cast<CSSParser*>(parser)->invalidBlockHit();
1663 }
1664 | '{' error closing_brace {
1665 static_cast<CSSParser*>(parser)->invalidBlockHit();
1666 }
1667 ;
1668
1669 invalid_block_list:
1670 invalid_block
1671 | invalid_block_list error invalid_block
1672 ;
1673
1674 %%
1675