Auto-closing at unexpected EOF for all entry points.

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 121 matching lines @@
 %token HOST_SYM
 %token CHARSET_SYM
 %token NAMESPACE_SYM
 %token VARFUNCTION
 %token VIEWPORT_RULE_SYM
 %token INTERNAL_DECLS_SYM
 %token INTERNAL_MEDIALIST_SYM
 %token INTERNAL_RULE_SYM
 %token INTERNAL_SELECTOR_SYM
 %token INTERNAL_VALUE_SYM
-%token WEBKIT_KEYFRAME_RULE_SYM
+%token INTERNAL_KEYFRAME_RULE_SYM
+%token INTERNAL_SUPPORTS_CONDITION_SYM
 %token WEBKIT_KEYFRAMES_SYM
 %token WEBKIT_REGION_RULE_SYM
-%token WEBKIT_SUPPORTS_CONDITION_SYM
 %token WEBKIT_FILTER_RULE_SYM
 %token <marginBox> TOPLEFTCORNER_SYM
 %token <marginBox> TOPLEFT_SYM
 %token <marginBox> TOPCENTER_SYM
 %token <marginBox> TOPRIGHT_SYM
 %token <marginBox> TOPRIGHTCORNER_SYM
 %token <marginBox> BOTTOMLEFTCORNER_SYM
 %token <marginBox> BOTTOMLEFT_SYM
 %token <marginBox> BOTTOMCENTER_SYM
 %token <marginBox> BOTTOMRIGHT_SYM
@@ skipping 165 matching lines @@
 
 %type <string> element_name
 %type <string> attr_name
 
 %type <location> error_location
 
 %%
 
 stylesheet:
     maybe_charset maybe_sgml rule_list
-  | internal_decls maybe_space
-  | internal_rule maybe_space
-  | internal_selector maybe_space
-  | internal_value maybe_space
+  | internal_decls
+  | internal_rule
+  | internal_selector
+  | internal_value
   | internal_medialist
-  | webkit_keyframe_rule maybe_space
-  | webkit_supports_condition maybe_space
+  | internal_keyframe_rule
+  | internal_supports_condition
   ;
 
 internal_rule:
-    INTERNAL_RULE_SYM '{' maybe_space valid_rule maybe_space '}' {
-        parser->m_rule = $4;
+    INTERNAL_RULE_SYM maybe_space valid_rule maybe_space TOKEN_EOF {
+        parser->m_rule = $3;
     }
 ;
 
-webkit_keyframe_rule:
-    WEBKIT_KEYFRAME_RULE_SYM '{' maybe_space keyframe_rule maybe_space '}' {
-        parser->m_keyframe = $4;
+internal_keyframe_rule:
+    INTERNAL_KEYFRAME_RULE_SYM maybe_space keyframe_rule maybe_space TOKEN_EOF {
+        parser->m_keyframe = $3;
     }
 ;
 
 internal_decls:
-    INTERNAL_DECLS_SYM '{' maybe_space_before_declaration declaration_list '}' {
+    INTERNAL_DECLS_SYM maybe_space_before_declaration declaration_list TOKEN_EOF {
         /* can be empty */
     }
 ;
 
 internal_value:
-    INTERNAL_VALUE_SYM '{' maybe_space expr '}' {
-        parser->m_valueList = parser->sinkFloatingValueList($4);
+    INTERNAL_VALUE_SYM maybe_space expr TOKEN_EOF {
+        parser->m_valueList = parser->sinkFloatingValueList($3);
         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;
     }
 ;
 
 internal_medialist:
     INTERNAL_MEDIALIST_SYM maybe_space maybe_media_list TOKEN_EOF {
         parser->m_mediaList = $3;
     }
 ;
 
 internal_selector:
-    INTERNAL_SELECTOR_SYM '{' maybe_space selector_list '}' {
+    INTERNAL_SELECTOR_SYM maybe_space selector_list TOKEN_EOF {
         if (parser->m_selectorListForParseSelector)
-            parser->m_selectorListForParseSelector->adoptSelectorVector(*$4);
+            parser->m_selectorListForParseSelector->adoptSelectorVector(*$3);
     }
 ;
 
-webkit_supports_condition:
-    WEBKIT_SUPPORTS_CONDITION_SYM '{' maybe_space supports_condition '}' {
-        parser->m_supportsCondition = $4;
+internal_supports_condition:
+    INTERNAL_SUPPORTS_CONDITION_SYM maybe_space supports_condition TOKEN_EOF {
+        parser->m_supportsCondition = $3;
     }
 ;
 
 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
   ;
 
+closing_square_bracket:
+    ']'
+  | %prec LOWEST_PREC TOKEN_EOF
+  ;
+
+semi_or_eof:
+    ';'
+  | TOKEN_EOF
+  ;
+
 charset:
-  CHARSET_SYM maybe_space STRING maybe_space ';' {
+  CHARSET_SYM maybe_space STRING maybe_space semi_or_eof {
      if (parser->m_styleSheet)
          parser->m_styleSheet->parserSetEncodingFromCharsetRule($3);
      parser->startEndUnknownRule();
      $$ = 0;
   }
   | CHARSET_SYM at_rule_recovery {
      $$ = 0;
   }
   ;
 
@@ skipping 91 matching lines @@
     }
     ;
 
 before_import_rule:
     /* empty */ {
         parser->startRuleHeader(CSSRuleSourceData::IMPORT_RULE);
     }
     ;
 
 import:
-    before_import_rule IMPORT_SYM at_import_header_end_maybe_space string_or_uri maybe_space maybe_media_list ';' {
-        $$ = parser->createImportRule($4, $6);
-    }
-  | before_import_rule IMPORT_SYM at_import_header_end_maybe_space string_or_uri maybe_space maybe_media_list TOKEN_EOF {
+    before_import_rule IMPORT_SYM at_import_header_end_maybe_space string_or_uri maybe_space maybe_media_list semi_or_eof {
         $$ = parser->createImportRule($4, $6);
     }
   | before_import_rule IMPORT_SYM at_import_header_end_maybe_space string_or_uri maybe_space maybe_media_list invalid_block {
         $$ = 0;
         parser->endRuleBody(true);
     }
   | before_import_rule IMPORT_SYM at_rule_recovery {
         $$ = 0;
         parser->endRuleBody(true);
     }
   ;
 
 before_namespace_rule:
     /* empty */ {
         // FIXME: There should be parser->startRuleHeader.
     }
     ;
 
 namespace:
-    before_namespace_rule NAMESPACE_SYM maybe_space maybe_ns_prefix string_or_uri maybe_space ';' {
+    before_namespace_rule NAMESPACE_SYM maybe_space maybe_ns_prefix string_or_uri maybe_space semi_or_eof {
         parser->addNamespace($4, $5);
         $$ = 0;
     }
   | before_namespace_rule NAMESPACE_SYM maybe_space maybe_ns_prefix string_or_uri maybe_space invalid_block {
         $$ = 0;
     }
   | before_namespace_rule NAMESPACE_SYM at_rule_recovery {
         $$ = 0;
     }
   ;
@@ skipping 136 matching lines @@
     }
     ;
 
 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 ';' {
+    | before_media_rule MEDIA_SYM maybe_space media_list semi_or_eof {
         $$ = 0;
         parser->endRuleBody(true);
     }
     | before_media_rule MEDIA_SYM at_rule_recovery {
         $$ = 0;
         parser->endRuleBody(true);
     }
     ;
 
 medium:
@@ skipping 53 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_location error_recovery ')' maybe_space {
+    | '(' error error_location error_recovery closing_parenthesis maybe_space {
         parser->reportError($3, CSSParser::InvalidSupportsConditionError);
         $$ = false;
     }
     ;
 
 supports_declaration_condition:
-    '(' maybe_space IDENT maybe_space ':' maybe_space expr prio ')' maybe_space {
+    '(' maybe_space IDENT maybe_space ':' maybe_space expr prio closing_parenthesis maybe_space {
         $$ = false;
         CSSPropertyID id = cssPropertyID($3);
         if (id != CSSPropertyInvalid) {
             parser->m_valueList = parser->sinkFloatingValueList($7);
             int oldParsedProperties = parser->m_parsedProperties.size();
             $$ = parser->parseValue(id, $8);
             // We just need to know if the declaration is supported as it is written. Rollback any additions.
             if ($$)
                 parser->rollbackLastProperties(parser->m_parsedProperties.size() - oldParsedProperties);
         }
         parser->m_valueList = nullptr;
         parser->endProperty($8, false);
     }
-    | '(' maybe_space IDENT maybe_space ':' maybe_space error error_recovery ')' maybe_space {
+    | '(' maybe_space IDENT maybe_space ':' maybe_space error error_recovery closing_parenthesis maybe_space {
         $$ = false;
         parser->endProperty(false, false, CSSParser::GeneralError);
     }
     ;
 
 before_keyframes_rule:
     /* empty */ {
         parser->startRuleHeader(CSSRuleSourceData::KEYFRAMES_RULE);
     }
     ;
@@ skipping 480 matching lines @@
 
 attr_name:
     IDENT maybe_space {
         if (parser->m_context.isHTMLDocument)
             parser->tokenToLowerCase($1);
         $$ = $1;
     }
     ;
 
 attrib:
-    '[' maybe_space attr_name ']' {
+    '[' maybe_space attr_name closing_square_bracket {
         $$ = parser->createFloatingSelector();
         $$->setAttribute(QualifiedName(nullAtom, $3, nullAtom));
         $$->setMatch(CSSSelector::Set);
     }
-    | '[' maybe_space attr_name match maybe_space ident_or_string maybe_space ']' {
+    | '[' maybe_space attr_name match maybe_space ident_or_string maybe_space closing_square_bracket {
         $$ = parser->createFloatingSelector();
         $$->setAttribute(QualifiedName(nullAtom, $3, nullAtom));
         $$->setMatch((CSSSelector::Match)$4);
         $$->setValue($6);
     }
-    | '[' maybe_space namespace_selector attr_name ']' {
+    | '[' maybe_space namespace_selector attr_name closing_square_bracket {
         $$ = parser->createFloatingSelector();
         $$->setAttribute(parser->determineNameInNamespace($3, $4));
         $$->setMatch(CSSSelector::Set);
     }
-    | '[' maybe_space namespace_selector attr_name match maybe_space ident_or_string maybe_space ']' {
+    | '[' maybe_space namespace_selector attr_name match maybe_space ident_or_string maybe_space closing_square_bracket {
         $$ = parser->createFloatingSelector();
         $$->setAttribute(parser->determineNameInNamespace($3, $4));
         $$->setMatch((CSSSelector::Match)$5);
         $$->setValue($7);
     }
-    | '[' selector_recovery ']' {
+    | '[' selector_recovery closing_square_bracket {
         YYERROR;
     }
   ;
 
 match:
     '=' {
         $$ = CSSSelector::Exact;
     }
     | INCLUDES {
         $$ = CSSSelector::List;
@@ skipping 42 matching lines @@
         $$ = parser->createFloatingSelector();
         $$->setMatch(CSSSelector::PseudoElement);
         parser->tokenToLowerCase($3);
         $$->setValue($3);
         // FIXME: This call is needed to force selector to compute the pseudoType early enough.
         CSSSelector::PseudoType type = $$->pseudoType();
         if (type == CSSSelector::PseudoUnknown)
             YYERROR;
     }
     // used by ::cue(:past/:future)
-    | ':' ':' CUEFUNCTION maybe_space simple_selector_list maybe_space ')' {
+    | ':' ':' CUEFUNCTION maybe_space simple_selector_list maybe_space closing_parenthesis {
         $$ = parser->createFloatingSelector();
         $$->setMatch(CSSSelector::PseudoClass);
         $$->adoptSelectorVector(*parser->sinkFloatingSelectorVector($5));
         $$->setValue($3);
         CSSSelector::PseudoType type = $$->pseudoType();
         if (type != CSSSelector::PseudoCue)
             YYERROR;
     }
-    | ':' ':' CUEFUNCTION selector_recovery ')' {
+    | ':' ':' CUEFUNCTION selector_recovery closing_parenthesis {
         YYERROR;
     }
-    | ':' ':' DISTRIBUTEDFUNCTION maybe_space relative_selector ')' {
+    | ':' ':' DISTRIBUTEDFUNCTION maybe_space relative_selector closing_parenthesis {
         $$ = parser->createFloatingSelector();
         $$->setMatch(CSSSelector::PseudoElement);
         $$->setFunctionArgumentSelector($5);
         parser->tokenToLowerCase($3);
         $$->setValue($3);
     }
-    | ':' ':' DISTRIBUTEDFUNCTION selector_recovery ')' {
+    | ':' ':' DISTRIBUTEDFUNCTION selector_recovery closing_parenthesis {
         YYERROR;
     }
     // 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 {
         $$ = parser->createFloatingSelector();
         $$->setMatch(CSSSelector::PseudoClass);
         $$->adoptSelectorVector(*parser->sinkFloatingSelectorVector($4));
         parser->tokenToLowerCase($2);
         $$->setValue($2);
         CSSSelector::PseudoType type = $$->pseudoType();
         if (type != CSSSelector::PseudoAny)
             YYERROR;
     }
-    | ':' ANYFUNCTION selector_recovery ')' {
+    | ':' ANYFUNCTION selector_recovery closing_parenthesis {
         YYERROR;
     }
     // 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)
             YYERROR;
     }
     // 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)
             YYERROR;
     }
     // 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);
         parser->tokenToLowerCase($2);
         $$->setValue($2);
         CSSSelector::PseudoType type = $$->pseudoType();
         if (type == CSSSelector::PseudoUnknown)
             YYERROR;
         else if (type == CSSSelector::PseudoNthChild ||
                  type == CSSSelector::PseudoNthOfType ||
                  type == CSSSelector::PseudoNthLastChild ||
                  type == CSSSelector::PseudoNthLastOfType) {
             if (!isValidNthToken($4))
                 YYERROR;
         }
     }
-    | ':' FUNCTION selector_recovery ')' {
+    | ':' FUNCTION selector_recovery closing_parenthesis {
         YYERROR;
     }
     // used by :not
-    | ':' NOTFUNCTION maybe_space simple_selector maybe_space ')' {
+    | ':' NOTFUNCTION maybe_space simple_selector maybe_space closing_parenthesis {
         if (!$4->isSimple())
             YYERROR;
         else {
             $$ = parser->createFloatingSelector();
             $$->setMatch(CSSSelector::PseudoClass);
 
             Vector<OwnPtr<CSSParserSelector> > selectorVector;
             selectorVector.append(parser->sinkFloatingSelector($4));
             $$->adoptSelectorVector(selectorVector);
 
             parser->tokenToLowerCase($2);
             $$->setValue($2);
         }
     }
-    | ':' NOTFUNCTION selector_recovery ')' {
+    | ':' NOTFUNCTION selector_recovery closing_parenthesis {
         YYERROR;
     }
   ;
 
 selector_recovery:
     error error_location error_recovery;
 
 declaration_list:
     /* empty */ { $$ = false; }
     | declaration {
@@ skipping 308 matching lines @@
     at_rule_header_recovery at_invalid_rule_header_end at_rule_end
     ;
 
 at_rule_header_recovery:
     error error_location rule_error_recovery {
         parser->reportError($2, CSSParser::InvalidRuleError);
     }
     ;
 
 at_rule_end:
-    at_invalid_rule_header_end ';'
+    at_invalid_rule_header_end semi_or_eof
   | at_invalid_rule_header_end invalid_block
     ;
 
 invalid_rule:
     error error_location rule_error_recovery at_invalid_rule_header_end invalid_block {
         parser->reportError($2, CSSParser::InvalidRuleError);
         $$ = 0;
     }
   | error_location invalid_at rule_error_recovery at_invalid_rule_header_end at_rule_end {
         parser->resumeErrorLogging();
         parser->reportError($1, CSSParser::InvalidRuleError);
         $$ = 0;
     }
     ;
 
 at_invalid_rule_header_end:
    /* empty */ {
        parser->endInvalidRuleHeader();
    }
    ;
 
 invalid_block:
     '{' error_recovery closing_brace {
         parser->invalidBlockHit();
     }
     ;
 
 invalid_square_brackets_block:
-    '[' error_recovery ']'
-  | '[' error_recovery TOKEN_EOF
+    '[' error_recovery closing_square_bracket
     ;
 
 invalid_parentheses_block:
     opening_parenthesis error_recovery closing_parenthesis;
 
 opening_parenthesis:
     '(' | FUNCTION | CALCFUNCTION | VARFUNCTION | MINFUNCTION | MAXFUNCTION | ANYFUNCTION | NOTFUNCTION | CUEFUNCTION | DISTRIBUTEDFUNCTION
     ;
 
 error_location: {
@@ skipping 11 matching lines @@
 
 rule_error_recovery:
     /* empty */
   | rule_error_recovery error
   | rule_error_recovery invalid_square_brackets_block
   | rule_error_recovery invalid_parentheses_block
     ;
 
 %%