Taking parentheses into account while CSS error recovering.

Source/core/css/CSSGrammar.y.in

 /*
  *  Copyright (C) 2002-2003 Lars Knoll (knoll@kde.org)
  *  Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012, 2013 Apple Inc. All rights reserved.
  *  Copyright (C) 2006 Alexey Proskuryakov (ap@nypop.com)
  *  Copyright (C) 2008 Eric Seidel <eric@webkit.org>
  *  Copyright (C) 2012 Intel Corporation. All rights reserved.
  *
  *  This library is free software; you can redistribute it and/or
  *  modify it under the terms of the GNU Lesser General Public
  *  License as published by the Free Software Foundation; either
@@ skipping 69 matching lines @@
     case VAR_DEFINITION:
     case UNICODERANGE:
         return true;
     default:
         return false;
     }
 }
 
 %}
 
-%expect 35
+%expect 34
 
 %nonassoc LOWEST_PREC
 
 %left UNIMPORTANT_TOK
 
 %token WHITESPACE SGML_CD
 %token TOKEN_EOF 0
 
 %token INCLUDES
 %token DASHMATCH
@@ skipping 192 matching lines @@
 %type <boolean> declarations_and_margins
 
 %type <boolean> prio
 
 %type <integer> match
 %type <integer> unary_operator
 %type <integer> maybe_unary_operator
 %type <character> operator
 
 %type <valueList> expr
+%type <valueList> valid_expr
 %type <value> term
 %type <value> unary_term
 %type <value> function
 %type <value> calc_func_term
 %type <character> calc_func_operator
 %type <valueList> calc_func_expr
 %type <valueList> calc_func_expr_list
 %type <valueList> calc_func_paren_expr
 %type <value> calc_function
 %type <string> min_or_max
@@ skipping 11 matching lines @@
   | internal_decls maybe_space
   | internal_rule maybe_space
   | internal_selector maybe_space
   | internal_value maybe_space
   | webkit_mediaquery maybe_space
   | webkit_keyframe_rule maybe_space
   | webkit_supports_condition maybe_space
   ;
 
 internal_rule:
-    INTERNAL_RULE_SYM '{' maybe_space valid_rule maybe_space '}' {
+    INTERNAL_RULE_SYM '{' maybe_space valid_rule maybe_space closing_brace {
         parser->m_rule = $4;
     }
 ;
 
 webkit_keyframe_rule:
-    WEBKIT_KEYFRAME_RULE_SYM '{' maybe_space keyframe_rule maybe_space '}' {
+    WEBKIT_KEYFRAME_RULE_SYM '{' maybe_space keyframe_rule maybe_space closing_brace{
         parser->m_keyframe = $4;
     }
 ;
 
 internal_decls:
-    INTERNAL_DECLS_SYM '{' maybe_space_before_declaration declaration_list '}' {
+    INTERNAL_DECLS_SYM '{' maybe_space_before_declaration declaration_list closing_brace {
         /* can be empty */
     }
 ;
 
 internal_value:
-    INTERNAL_VALUE_SYM '{' maybe_space expr '}' {
+    INTERNAL_VALUE_SYM '{' maybe_space expr closing_brace {
         if ($4) {
             parser->m_valueList = parser->sinkFloatingValueList($4);
             int oldParsedProperties = parser->m_parsedProperties.size();
             if (!parser->parseValue(parser->m_id, parser->m_important))
                 parser->rollbackLastProperties(parser->m_parsedProperties.size() - oldParsedProperties);
             parser->m_valueList = nullptr;
         }
     }
 ;
 
 webkit_mediaquery:
-     WEBKIT_MEDIAQUERY_SYM WHITESPACE maybe_space media_query '}' {
+     WEBKIT_MEDIAQUERY_SYM WHITESPACE maybe_space media_query closing_brace {
          parser->m_mediaQuery = parser->sinkFloatingMediaQuery($4);
      }
 ;
 
 internal_selector:
-    INTERNAL_SELECTOR_SYM '{' maybe_space selector_list '}' {
+    INTERNAL_SELECTOR_SYM '{' maybe_space selector_list closing_brace {
         if ($4) {
             if (parser->m_selectorListForParseSelector)
                 parser->m_selectorListForParseSelector->adoptSelectorVector(*$4);
         }
     }
 ;
 
 webkit_supports_condition:
-    WEBKIT_SUPPORTS_CONDITION_SYM '{' maybe_space supports_condition '}' {
+    WEBKIT_SUPPORTS_CONDITION_SYM '{' maybe_space supports_condition closing_brace {
         parser->m_supportsCondition = $4;
     }
 ;
 
 maybe_space:
     /* empty */ %prec UNIMPORTANT_TOK
   | maybe_space WHITESPACE
   ;
 
 maybe_sgml:
     /* empty */
   | maybe_sgml SGML_CD
   | maybe_sgml WHITESPACE
   ;
 
 maybe_charset:
    /* empty */
   | charset {
   }
   ;
 
 closing_brace:
     '}'
   | %prec LOWEST_PREC TOKEN_EOF
   ;
 
+closing_parenthesis:
+    ')'
+  | %prec LOWEST_PREC TOKEN_EOF
+  ;
+
 charset:
   CHARSET_SYM maybe_space STRING maybe_space ';' {
      if (parser->m_styleSheet)
          parser->m_styleSheet->parserSetEncodingFromCharsetRule($3);
      parser->startEndUnknownRule();
      $$ = 0;
   }
   | CHARSET_SYM error invalid_block {
   }
   | CHARSET_SYM error ';' {
@@ skipping 159 matching lines @@
 maybe_media_value:
     /*empty*/ {
         $$ = 0;
     }
     | ':' maybe_space expr maybe_space {
         $$ = $3;
     }
     ;
 
 media_query_exp:
-    maybe_media_restrictor maybe_space '(' maybe_space media_feature maybe_space maybe_media_value ')' maybe_space {
+    maybe_media_restrictor maybe_space '(' maybe_space media_feature maybe_space maybe_media_value closing_parenthesis maybe_space {
         // If restrictor is specified, media query expression is invalid.
         // Create empty media query expression and continue parsing media query.
         if ($1 != MediaQuery::None)
             $$ = parser->createFloatingMediaQueryExp("", 0);
         else {
             $5.lower();
             $$ = parser->createFloatingMediaQueryExp($5, $7);
         }
     }
     ;
@@ skipping 160 matching lines @@
 supports_disjunction:
     supports_condition_in_parens SUPPORTS_OR maybe_space supports_condition_in_parens {
         $$ = $1 || $4;
     }
     | supports_disjunction SUPPORTS_OR maybe_space supports_condition_in_parens {
         $$ = $1 || $4;
     }
     ;
 
 supports_condition_in_parens:
-    '(' maybe_space supports_condition ')' maybe_space {
+    '(' maybe_space supports_condition closing_parenthesis maybe_space {
         $$ = $3;
     }
     | supports_declaration_condition
-    | '(' error ')' {
+    | '(' error closing_parenthesis {
         $$ = false;
     }
     ;
 
 supports_declaration_condition:
-    '(' maybe_space property ':' maybe_space expr prio ')' maybe_space {
+    '(' maybe_space property ':' maybe_space expr prio closing_parenthesis maybe_space {
         $$ = false;
         CSSParser* p = static_cast<CSSParser*>(parser);
         if ($3 && $6) {
             p->m_valueList = p->sinkFloatingValueList($6);
             int oldParsedProperties = p->m_parsedProperties.size();
             $$ = p->parseValue(static_cast<CSSPropertyID>($3), $7);
             // We just need to know if the declaration is supported as it is written. Rollback any additions.
             if ($$)
                 p->rollbackLastProperties(p->m_parsedProperties.size() - oldParsedProperties);
             p->m_valueList = nullptr;
@@ skipping 22 matching lines @@
 keyframes_rule:
     /* empty */ { $$ = parser->createFloatingKeyframeVector(); }
     | keyframes_rule keyframe_rule maybe_space {
         $$ = $1;
         if ($2)
             $$->append($2);
     }
     ;
 
 keyframe_rule:
-    key_list maybe_space '{' maybe_space declaration_list '}' {
+    key_list maybe_space '{' maybe_space declaration_list closing_brace {
         $$ = parser->createKeyframe($1);
     }
     ;
 
 key_list:
     key {
         $$ = parser->createFloatingValueList();
         $$->addValue(parser->sinkFloatingValue($1));
     }
     | key_list maybe_space ',' maybe_space key {
@@ skipping 566 matching lines @@
         $$ = parser->createFloatingSelector();
         $$->setMatch(CSSSelector::PseudoElement);
         $3.lower();
         $$->setValue($3);
         // FIXME: This call is needed to force selector to compute the pseudoType early enough.
         CSSSelector::PseudoType type = $$->pseudoType();
         if (type == CSSSelector::PseudoUnknown)
             $$ = 0;
     }
     // used by ::cue(:past/:future)
-    | ':' ':' CUEFUNCTION maybe_space simple_selector_list maybe_space ')' {
+    | ':' ':' CUEFUNCTION maybe_space simple_selector_list maybe_space closing_parenthesis {
         if ($5) {
             $$ = parser->createFloatingSelector();
             $$->setMatch(CSSSelector::PseudoClass);
             $$->adoptSelectorVector(*parser->sinkFloatingSelectorVector($5));
             $$->setValue($3);
             CSSSelector::PseudoType type = $$->pseudoType();
             if (type != CSSSelector::PseudoCue)
                 $$ = 0;
         } else
             $$ = 0;
     }
-    | ':' ':' DISTRIBUTEDFUNCTION maybe_space selector maybe_space ')' {
+    | ':' ':' DISTRIBUTEDFUNCTION maybe_space selector maybe_space closing_parenthesis {
         if (!$5)
             $$ = 0;
         else {
             $$ = parser->createFloatingSelector();
             $$->setMatch(CSSSelector::PseudoElement);
             $$->setFunctionArgumentSelector($5);
             $3.lower();
             $$->setValue($3);
         }
     }
     // use by :-webkit-any.
     // FIXME: should we support generic selectors here or just simple_selectors?
     // Use simple_selector_list for now to match -moz-any.
     // See http://lists.w3.org/Archives/Public/www-style/2010Sep/0566.html for some
     // related discussion with respect to :not.
-    | ':' ANYFUNCTION maybe_space simple_selector_list maybe_space ')' {
+    | ':' ANYFUNCTION maybe_space simple_selector_list maybe_space closing_parenthesis {
         if ($4) {
             $$ = parser->createFloatingSelector();
             $$->setMatch(CSSSelector::PseudoClass);
             $$->adoptSelectorVector(*parser->sinkFloatingSelectorVector($4));
             $2.lower();
             $$->setValue($2);
             CSSSelector::PseudoType type = $$->pseudoType();
             if (type != CSSSelector::PseudoAny)
                 $$ = 0;
         } else
             $$ = 0;
     }
     // used by :nth-*(ax+b)
-    | ':' FUNCTION maybe_space NTH maybe_space ')' {
+    | ':' FUNCTION maybe_space NTH maybe_space closing_parenthesis {
         $$ = parser->createFloatingSelector();
         $$->setMatch(CSSSelector::PseudoClass);
         $$->setArgument($4);
         $$->setValue($2);
         CSSSelector::PseudoType type = $$->pseudoType();
         if (type == CSSSelector::PseudoUnknown)
             $$ = 0;
     }
     // used by :nth-*
-    | ':' FUNCTION maybe_space maybe_unary_operator INTEGER maybe_space ')' {
+    | ':' FUNCTION maybe_space maybe_unary_operator INTEGER maybe_space closing_parenthesis {
         $$ = parser->createFloatingSelector();
         $$->setMatch(CSSSelector::PseudoClass);
         $$->setArgument(String::number($4 * $5));
         $$->setValue($2);
         CSSSelector::PseudoType type = $$->pseudoType();
         if (type == CSSSelector::PseudoUnknown)
             $$ = 0;
     }
     // used by :nth-*(odd/even) and :lang
-    | ':' FUNCTION maybe_space IDENT maybe_space ')' {
+    | ':' FUNCTION maybe_space IDENT maybe_space closing_parenthesis {
         $$ = parser->createFloatingSelector();
         $$->setMatch(CSSSelector::PseudoClass);
         $$->setArgument($4);
         $2.lower();
         $$->setValue($2);
         CSSSelector::PseudoType type = $$->pseudoType();
         if (type == CSSSelector::PseudoUnknown)
             $$ = 0;
         else if (type == CSSSelector::PseudoNthChild ||
                  type == CSSSelector::PseudoNthOfType ||
                  type == CSSSelector::PseudoNthLastChild ||
                  type == CSSSelector::PseudoNthLastOfType) {
             if (!isValidNthToken($4))
                 $$ = 0;
         }
     }
     // used by :not
-    | ':' NOTFUNCTION maybe_space simple_selector maybe_space ')' {
+    | ':' NOTFUNCTION maybe_space simple_selector maybe_space closing_parenthesis {
         if (!$4 || !$4->isSimple())
             $$ = 0;
         else {
             $$ = parser->createFloatingSelector();
             $$->setMatch(CSSSelector::PseudoClass);
 
             Vector<OwnPtr<CSSParserSelector> > selectorVector;
             selectorVector.append(parser->sinkFloatingSelector($4));
             $$->adoptSelectorVector(selectorVector);
 
@@ skipping 39 matching lines @@
         if ($2)
             $$ = $2;
     }
     | decl_list decl_list_recovery ';' maybe_space {
         parser->startProperty();
         $$ = $1;
     }
     ;
 
 decl_list_recovery:
-    error error_location {
+    error error_location error_recovery {
         parser->syntaxError($2, CSSParser::PropertyDeclarationError);
     }
-    | decl_list_recovery invalid_block
-    | decl_list_recovery error
     ;
 
 declaration:
     VAR_DEFINITION ':' maybe_space expr prio {
         parser->storeVariableDeclaration($1, parser->sinkFloatingValueList($4), $5);
         $$ = true;
         parser->endProperty($5, true);
     }
     |
     property ':' maybe_space expr prio {
@@ skipping 30 matching lines @@
     }
     |
     property ':' maybe_space declaration_recovery {
         /* if we come across rules with invalid values like this case: p { weight: *; }, just discard the rule */
         parser->endProperty(false, false);
         $$ = false;
     }
   ;
 
 declaration_recovery:
-    error error_location {
+    error error_location error_recovery {
         parser->syntaxError($2);
     }
-    | declaration_recovery invalid_block
-    | declaration_recovery error
   ;
 
 property:
     IDENT maybe_space {
         $$ = cssPropertyID($1);
     }
   ;
 
 prio:
     IMPORTANT_SYM maybe_space { $$ = true; }
     | /* empty */ { $$ = false; }
   ;
 
 expr:
+    valid_expr {
+        $$ = $1;
+    }
+    | valid_expr expr_recovery {
+        $$ = 0;
+    }
+  ;
+
+valid_expr:
     term {
         $$ = parser->createFloatingValueList();
         $$->addValue(parser->sinkFloatingValue($1));
     }
-    | expr operator term {
+    | valid_expr operator term {
         $$ = $1;
         if ($$) {
             if ($2) {
                 CSSParserValue v;
                 v.id = 0;
                 v.unit = CSSParserValue::Operator;
                 v.iValue = $2;
                 $$->addValue(v);
             }
             $$->addValue(parser->sinkFloatingValue($3));
         }
     }
-    | expr invalid_block_list {
-        $$ = 0;
-    }
-    | expr invalid_block_list error {
-        $$ = 0;
-    }
-    | expr error {
-        $$ = 0;
-    }
+  ;
+
+expr_recovery:
+    error error_location error_recovery
   ;
 
 operator:
     '/' maybe_space {
         $$ = '/';
     }
   | ',' maybe_space {
         $$ = ',';
     }
   | /* empty */ {
@@ skipping 10 matching lines @@
       $$.unit = CSSPrimitiveValue::CSS_IDENT;
       $$.string = $1;
   }
   /* We might need to actually parse the number from a dimension, but we can't just put something that uses $$.string into unary_term. */
   | DIMEN maybe_space { $$.id = 0; $$.string = $1; $$.unit = CSSPrimitiveValue::CSS_DIMENSION; }
   | unary_operator DIMEN maybe_space { $$.id = 0; $$.string = $2; $$.unit = CSSPrimitiveValue::CSS_DIMENSION; }
   | URI maybe_space { $$.id = 0; $$.string = $1; $$.unit = CSSPrimitiveValue::CSS_URI; }
   | UNICODERANGE maybe_space { $$.id = 0; $$.string = $1; $$.unit = CSSPrimitiveValue::CSS_UNICODE_RANGE; }
   | HEX maybe_space { $$.id = 0; $$.string = $1; $$.unit = CSSPrimitiveValue::CSS_PARSER_HEXCOLOR; }
   | '#' maybe_space { $$.id = 0; $$.string = CSSParserString(); $$.unit = CSSPrimitiveValue::CSS_PARSER_HEXCOLOR; } /* Handle error case: "color: #;" */
-  | VARFUNCTION maybe_space IDENT ')' maybe_space {
+  | VARFUNCTION maybe_space IDENT closing_parenthesis maybe_space {
       $$.id = 0;
       $$.string = $3;
       $$.unit = CSSPrimitiveValue::CSS_VARIABLE_NAME;
   }
   /* FIXME: according to the specs a function can have a unary_operator in front. I know no case where this makes sense */
   | function {
       $$ = $1;
   }
   | calc_function {
       $$ = $1;
@@ skipping 39 matching lines @@
   | VH { $$.id = 0; $$.fValue = $1; $$.unit = CSSPrimitiveValue::CSS_VH; }
   | VMIN { $$.id = 0; $$.fValue = $1; $$.unit = CSSPrimitiveValue::CSS_VMIN; }
   | VMAX { $$.id = 0; $$.fValue = $1; $$.unit = CSSPrimitiveValue::CSS_VMAX; }
   | DPPX { $$.id = 0; $$.fValue = $1; $$.unit = CSSPrimitiveValue::CSS_DPPX; }
   | DPI { $$.id = 0; $$.fValue = $1; $$.unit = CSSPrimitiveValue::CSS_DPI; }
   | DPCM { $$.id = 0; $$.fValue = $1; $$.unit = CSSPrimitiveValue::CSS_DPCM; }
   | FR { $$.id = 0; $$.fValue = $1; $$.unit = CSSPrimitiveValue::CSS_FR; }
   ;
 
 function:
-    FUNCTION maybe_space expr ')' maybe_space {
+    FUNCTION maybe_space expr closing_parenthesis maybe_space {
         CSSParserFunction* f = parser->createFloatingFunction();
         f->name = $1;
         f->args = parser->sinkFloatingValueList($3);
-        $$.id = 0;
-        $$.unit = CSSParserValue::Function;
-        $$.function = f;
-    } |
-    FUNCTION maybe_space expr TOKEN_EOF {
-        CSSParserFunction* f = parser->createFloatingFunction();
-        f->name = $1;
-        f->args = parser->sinkFloatingValueList($3);
         $$.id = 0;
         $$.unit = CSSParserValue::Function;
         $$.function = f;
     } |
-    FUNCTION maybe_space ')' maybe_space {
+    FUNCTION maybe_space closing_parenthesis maybe_space {
         CSSParserFunction* f = parser->createFloatingFunction();
         f->name = $1;
         CSSParserValueList* valueList = parser->createFloatingValueList();
         f->args = parser->sinkFloatingValueList(valueList);
         $$.id = 0;
         $$.unit = CSSParserValue::Function;
         $$.function = f;
     } |
-    FUNCTION maybe_space error {
+    FUNCTION maybe_space expr_recovery closing_parenthesis maybe_space {
         CSSParserFunction* f = parser->createFloatingFunction();
         f->name = $1;
         f->args = nullptr;
         $$.id = 0;
         $$.unit = CSSParserValue::Function;
         $$.function = f;
   }
   ;
- 
+
 calc_func_term:
   unary_term { $$ = $1; }
-  | VARFUNCTION maybe_space IDENT ')' {
+  | VARFUNCTION maybe_space IDENT closing_parenthesis {
       $$.id = 0;
       $$.string = $3;
       $$.unit = CSSPrimitiveValue::CSS_VARIABLE_NAME;
   }
   | unary_operator unary_term { $$ = $2; $$.fValue *= $1; }
   ;
 
 calc_func_operator:
     WHITESPACE '+' WHITESPACE {
         $$ = '+';
@@ skipping 24 matching lines @@
             v.unit = CSSParserValue::Operator;
             v.iValue = '(';
             $$->insertValueAt(0, v);
             v.iValue = ')';
             $$->addValue(v);
         } else
             $$ = 0;
     }
 
 calc_closing_paren:
-    WHITESPACE ')'
-    | ')'
+    WHITESPACE closing_parenthesis
+    | closing_parenthesis
 
 calc_func_expr:
     calc_func_term {
         $$ = parser->createFloatingValueList();
         $$->addValue(parser->sinkFloatingValue($1));
     }
     | calc_func_expr calc_func_operator calc_func_term {
         if ($1 && $2) {
             $$ = $1;
             CSSParserValue v;
@@ skipping 75 matching lines @@
 min_or_max:
     MINFUNCTION {
         $$ = $1;
     }
     | MAXFUNCTION {
         $$ = $1;
     }
     ;
 
 min_or_max_function:
-    min_or_max maybe_space calc_func_expr_list ')' maybe_space {
+    min_or_max maybe_space calc_func_expr_list closing_parenthesis maybe_space {
         CSSParserFunction* f = parser->createFloatingFunction();
         f->name = $1;
         f->args = parser->sinkFloatingValueList($3);
         $$.id = 0;
         $$.unit = CSSParserValue::Function;
         $$.function = f;
     } 
     | min_or_max maybe_space error {
         YYERROR;
     }
@@ skipping 49 matching lines @@
 invalid_block_list:
     invalid_block
   | invalid_block_list error invalid_block
 ;
 
 error_location: {
         $$ = parser->currentLocation();
     }
     ;
 
+error_recovery:
+    /* empty */
+  | error_recovery error
+  | error_recovery '{' error_recovery closing_brace
+  | error_recovery '(' error_recovery closing_parenthesis
+  | error_recovery FUNCTION error_recovery closing_parenthesis
+  | error_recovery CALCFUNCTION error_recovery closing_parenthesis
+  | error_recovery VARFUNCTION error_recovery closing_parenthesis
+  | error_recovery MINFUNCTION error_recovery closing_parenthesis
+  | error_recovery MAXFUNCTION error_recovery closing_parenthesis
+  | error_recovery ANYFUNCTION error_recovery closing_parenthesis
+  | error_recovery NOTFUNCTION error_recovery closing_parenthesis
+    ;
+
 %%