Skipping {}, () and [] blocks while error recovering in CSS.

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 33
+%expect 32
 
 %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> valid_calc_func_expr
 %type <valueList> calc_func_expr_list
 %type <valueList> calc_func_paren_expr
 %type <value> calc_function
 %type <string> min_or_max
 %type <value> min_or_max_function
 
 %type <string> element_name
 %type <string> attr_name
 
 %type <location> error_location
@@ skipping 1292 matching lines @@
         $$ = cssPropertyID($1);
     }
   ;
 
 prio:
     IMPORTANT_SYM maybe_space { $$ = true; }
     | /* empty */ { $$ = false; }
   ;
 
 expr:
+    valid_expr
+    | 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 expr_recovery {
-        $$ = 0;
-    }
   ;
 
 expr_recovery:
     error error_location error_recovery
   ;
 
 operator:
     '/' maybe_space {
         $$ = '/';
     }
@@ skipping 20 matching lines @@
   | 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 {
       $$.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 {
+  | function maybe_space {
       $$ = $1;
   }
-  | calc_function {
+  | calc_function maybe_space {
       $$ = $1;
   }
-  | min_or_max_function {
+  | min_or_max_function maybe_space {
       $$ = $1;
   }
   | '%' maybe_space { /* Handle width: %; */
       $$.id = 0; $$.unit = 0;
   }
   ;
 
 unary_term:
   INTEGER { $$.id = 0; $$.isInt = true; $$.fValue = $1; $$.unit = CSSPrimitiveValue::CSS_NUMBER; }
   | FLOATTOKEN { $$.id = 0; $$.isInt = false; $$.fValue = $1; $$.unit = CSSPrimitiveValue::CSS_NUMBER; }
@@ skipping 27 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 closing_parenthesis maybe_space {
+    FUNCTION maybe_space expr closing_parenthesis {
         CSSParserFunction* f = parser->createFloatingFunction();
         f->name = $1;
         f->args = parser->sinkFloatingValueList($3);
         $$.id = 0;
         $$.unit = CSSParserValue::Function;
         $$.function = f;
     } |
-    FUNCTION maybe_space closing_parenthesis maybe_space {
+    FUNCTION maybe_space closing_parenthesis {
         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 {
         CSSParserFunction* f = parser->createFloatingFunction();
         f->name = $1;
         f->args = nullptr;
         $$.id = 0;
         $$.unit = CSSParserValue::Function;
         $$.function = f;
   }
   ;
 
 calc_func_term:
@@ skipping 36 matching lines @@
             v.iValue = '(';
             $$->insertValueAt(0, v);
             v.iValue = ')';
             $$->addValue(v);
         } else
             $$ = 0;
     }
   ;
 
 calc_func_expr:
+    valid_calc_func_expr
+    | valid_calc_func_expr expr_recovery { $$ = 0; }
+  ;
+
+valid_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;
             v.id = 0;
             v.unit = CSSParserValue::Operator;
@@ skipping 10 matching lines @@
             CSSParserValue v;
             v.id = 0;
             v.unit = CSSParserValue::Operator;
             v.iValue = $2;
             $$->addValue(v);
             $$->extend(*($3));
         } else 
             $$ = 0;
     }
     | calc_func_paren_expr
-    | calc_func_expr error {
-        $$ = 0;
-    }
   ;
 
 calc_func_expr_list:
     calc_func_expr calc_maybe_space {
         $$ = $1;
     }    
     | calc_func_expr_list ',' maybe_space calc_func_expr calc_maybe_space {
         if ($1 && $4) {
             $$ = $1;
             CSSParserValue v;
             v.id = 0;
             v.unit = CSSParserValue::Operator;
             v.iValue = ',';
             $$->addValue(v);
             $$->extend(*($4));
         } else
             $$ = 0;
     }
   ;
 
 calc_function:
-    CALCFUNCTION maybe_space calc_func_expr calc_maybe_space ')' maybe_space {
+    CALCFUNCTION maybe_space calc_func_expr calc_maybe_space ')' {
         CSSParserFunction* f = parser->createFloatingFunction();
         f->name = $1;
         f->args = parser->sinkFloatingValueList($3);
         $$.id = 0;
         $$.unit = CSSParserValue::Function;
         $$.function = f;
     }
-    | CALCFUNCTION maybe_space error {
+    | CALCFUNCTION maybe_space expr_recovery closing_parenthesis {
         YYERROR;
     }
     ;
 
 
 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 ')' {
         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 {
+    | min_or_max maybe_space expr_recovery closing_parenthesis {
         YYERROR;
     }
     ;
 
 /* error handling rules */
 
 save_block:
     closing_brace {
         $$ = 0;
     }
@@ skipping 43 matching lines @@
   | invalid_block_list error invalid_block
 ;
 
 error_location: {
         $$ = parser->currentLocation();
     }
     ;
 
 error_recovery:
     /* empty */
-  | error_recovery invalid_block
   | error_recovery error
+  | error_recovery '{' error_recovery closing_brace { parser->invalidBlockHit(); }
+  | error_recovery '[' error_recovery ']'
+  | error_recovery '[' error_recovery TOKEN_EOF
+  | 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
     ;
 
 %%