Improved parse error handling for CSSMQ.

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 11
+%expect 3
 
 %nonassoc LOWEST_PREC
 
 %left UNIMPORTANT_TOK
 
 %token WHITESPACE SGML_CD
 %token TOKEN_EOF 0
 
 %token INCLUDES
 %token DASHMATCH
@@ skipping 140 matching lines @@
 
 %type <string> maybe_ns_prefix
 
 %type <string> namespace_selector
 
 %type <string> string_or_uri
 %type <string> ident_or_string
 %type <string> medium
 %type <marginBox> margin_sym
 
-%type <string> media_feature
 %type <mediaList> media_list
 %type <mediaList> maybe_media_list
+%type <mediaList> mq_list
 %type <mediaQuery> media_query
+%type <mediaQuery> media_query_or_null
 %type <mediaQueryRestrictor> maybe_media_restrictor
 %type <valueList> maybe_media_value
 %type <mediaQueryExp> media_query_exp
 %type <mediaQueryExpList> media_query_exp_list
 %type <mediaQueryExpList> maybe_and_media_query_exp_list
 
 %type <boolean> supports_condition
 %type <boolean> supports_condition_in_parens
 %type <boolean> supports_negation
 %type <boolean> supports_conjunction
@@ skipping 92 matching lines @@
             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 '}' {
-         parser->m_mediaQuery = parser->sinkFloatingMediaQuery($4);
+     WEBKIT_MEDIAQUERY_SYM maybe_space media_query_or_null '}' {
+         parser->m_mediaQuery = parser->sinkFloatingMediaQuery($3);
      }
 ;
 
 internal_selector:
     INTERNAL_SELECTOR_SYM '{' maybe_space selector_list '}' {
         if ($4) {
             if (parser->m_selectorListForParseSelector)
                 parser->m_selectorListForParseSelector->adoptSelectorVector(*$4);
         }
     }
@@ skipping 188 matching lines @@
 maybe_ns_prefix:
 /* empty */ { $$.clear(); }
 | IDENT maybe_space { $$ = $1; }
 ;
 
 string_or_uri:
 STRING
 | URI
 ;
 
-media_feature:
-    IDENT maybe_space {
-        $$ = $1;
-    }
-    ;
-
 maybe_media_value:
     /*empty*/ {
         $$ = 0;
     }
     | ':' maybe_space expr {
         $$ = $3;
     }
     ;
 
 media_query_exp:
-    maybe_media_restrictor maybe_space '(' maybe_space media_feature maybe_space maybe_media_value ')' 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 {
-            parser->tokenToLowerCase($5);
-            $$ = parser->createFloatingMediaQueryExp($5, $7);
-        }
+    '(' maybe_space IDENT maybe_space maybe_media_value closing_parenthesis maybe_space {
+        parser->tokenToLowerCase($3);
+        $$ = parser->createFloatingMediaQueryExp($3, $5);
     }
-    | maybe_media_restrictor maybe_space '(' error error_recovery ')' {
+    | '(' error error_recovery closing_parenthesis {
         YYERROR;
     }
     ;
 
 media_query_exp_list:
     media_query_exp {
         $$ = parser->createFloatingMediaQueryExpList();
         $$->append(parser->sinkFloatingMediaQueryExp($1));
     }
-    | media_query_exp_list maybe_space MEDIA_AND maybe_space media_query_exp {
+    | media_query_exp_list MEDIA_AND maybe_space media_query_exp {
         $$ = $1;
-        $$->append(parser->sinkFloatingMediaQueryExp($5));
+        $$->append(parser->sinkFloatingMediaQueryExp($4));
     }
     ;
 
 maybe_and_media_query_exp_list:
     /*empty*/ {
         $$ = parser->createFloatingMediaQueryExpList();
     }
     | MEDIA_AND maybe_space media_query_exp_list {
         $$ = $3;
     }
     ;
 
 maybe_media_restrictor:
     /*empty*/ {
         $$ = MediaQuery::None;
     }
-    | MEDIA_ONLY {
+    | MEDIA_ONLY maybe_space {
         $$ = MediaQuery::Only;
     }
-    | MEDIA_NOT {
+    | MEDIA_NOT maybe_space {
         $$ = MediaQuery::Not;
     }
     ;
 
-media_query:
+media_query_or_null:

[SeRya, 2013/06/03 11:31:27]

My suggestion is:

valid_media_query:
    ...;

media_query:
    valid_media_query
    | error rule_error_recovery { $$ = parser->createFloatingNotAllQuery() };

webkit_mediaquery: WEBKIT_MEDIAQUERY_SYM maybe_space valid_media_query '}';

I think it is better because reuse an existing pattern. webkit_mediaquery
doesn't need error recovery.

     media_query_exp_list {
         $$ = parser->createFloatingMediaQuery(parser->sinkFloatingMediaQueryExpList($1));
     }
-    |
-    maybe_media_restrictor maybe_space medium maybe_and_media_query_exp_list {
-        parser->tokenToLowerCase($3);
-        $$ = parser->createFloatingMediaQuery($1, $3, parser->sinkFloatingMediaQueryExpList($4));
+    | maybe_media_restrictor medium maybe_and_media_query_exp_list {
+        parser->tokenToLowerCase($2);
+        $$ = parser->createFloatingMediaQuery($1, $2, parser->sinkFloatingMediaQueryExpList($3));
+    }
+    | error rule_error_recovery {
+        $$ = 0;
+    }
+    ;
+
+media_query:
+    media_query_or_null {
+        $$ = $1;
+        if (!$$)
+            $$ = parser->createFloatingNotAllQuery();
     }
     ;
 
 maybe_media_list:
-     /* empty */ {
+    /* empty */ {
         $$ = parser->createMediaQuerySet();
-     }
-     | media_list
-     ;
+    }
+    | media_list
+    ;
 
 media_list:
     media_query {
         $$ = parser->createMediaQuerySet();
         $$->addMediaQuery(parser->sinkFloatingMediaQuery($1));
         parser->updateLastMediaLine($$);
     }
-    | media_list ',' maybe_space media_query {
+    | mq_list media_query {
         $$ = $1;
-        if ($$) {
-            $$->addMediaQuery(parser->sinkFloatingMediaQuery($4));
-            parser->updateLastMediaLine($$);
-        }
+        $$->addMediaQuery(parser->sinkFloatingMediaQuery($2));
+        parser->updateLastMediaLine($$);
     }
-    | media_list error {
-        $$ = 0;
+    | mq_list {
+        $$ = $1;
+        $$->addMediaQuery(parser->sinkFloatingMediaQuery(parser->createFloatingNotAllQuery()));
+        parser->updateLastMediaLine($$);
     }
     ;
 
+mq_list:
+    media_query ',' maybe_space {
+        $$ = parser->createMediaQuerySet();
+        $$->addMediaQuery(parser->sinkFloatingMediaQuery($1));
+    }
+    | mq_list media_query ',' maybe_space {
+        $$ = $1;
+        $$->addMediaQuery(parser->sinkFloatingMediaQuery($2));
+    }
+    ;
+
 at_rule_body_start:
     /* empty */ {
         parser->startRuleBody();
     }
     ;
 
 before_media_rule:
     /* empty */ {
         parser->startRuleHeader(CSSRuleSourceData::MEDIA_RULE);
     }
     ;
 
 at_rule_header_end_maybe_space:
     maybe_space {
         parser->endRuleHeader();
     }
     ;
 
 media:
     before_media_rule MEDIA_SYM maybe_space media_list at_rule_header_end '{' at_rule_body_start maybe_space block_rule_body closing_brace {
         $$ = parser->createMediaRule($4, $9);
     }
     | before_media_rule MEDIA_SYM at_rule_header_end_maybe_space '{' at_rule_body_start maybe_space block_rule_body closing_brace {
         $$ = parser->createMediaRule(0, $7);
     }
+    | before_media_rule MEDIA_SYM maybe_space media_list ';' {
+        $$ = 0;
+        parser->endRuleBody(true);
+    }
     | before_media_rule MEDIA_SYM at_rule_recovery {
         $$ = 0;
         parser->endRuleBody(true);
     }
     ;
 
 medium:
   IDENT maybe_space {
       $$ = $1;
   }
@@ skipping 1278 matching lines @@
 
 rule_error_recovery:
     /* empty */
   | rule_error_recovery error
   | rule_error_recovery invalid_square_brackets_block
   | rule_error_recovery invalid_parentheses_block
     ;
 
 %%