Cleanup in CSSGrammar.y.in

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 217 matching lines @@
 %type <rule> namespace
 %type <rule> page
 %type <rule> margin_box
 %type <rule> font_face
 %type <rule> host
 %type <rule> keyframes
 %type <rule> invalid_rule
 %type <rule> rule
 %type <rule> valid_rule
 %type <ruleList> block_rule_body
-%type <ruleList> block_rule_list 
+%type <ruleList> block_rule_list
 %type <ruleList> region_block_rule_body
 %type <ruleList> region_block_rule_list
 %type <rule> block_rule
 %type <rule> block_valid_rule
 %type <rule> region
 %type <rule> supports
 %type <rule> viewport
 %type <rule> filter
 
 %type <string> maybe_ns_prefix
@@ skipping 212 matching lines @@
         parser->m_hadSyntacticallyValidCSSRule = true;
     }
   | invalid_rule
   ;
 
 block_rule_body:
     block_rule_list
   | block_rule_list error error_location rule_error_recovery {
         parser->reportError($3, CSSParser::InvalidRuleError);
     }
-    ; 
+    ;
 
-block_rule_list: 
+block_rule_list:
     /* empty */ { $$ = 0; }
   | block_rule_list block_rule maybe_sgml {
       $$ = $1;
       if ($2) {
           if (!$$)
               $$ = parser->createRuleList();
           $$->append($2);
       }
     }
     ;
@@ skipping 77 matching lines @@
   | 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;
     }
   ;
 
 maybe_ns_prefix:
 /* empty */ { $$.clear(); }
-| IDENT maybe_space { $$ = $1; }
+| IDENT maybe_space
 ;
 
 string_or_uri:
 STRING
 | URI
 ;
 
 maybe_media_value:
     /*empty*/ {
         $$ = 0;
@@ skipping 130 matching lines @@
         $$ = 0;
         parser->endRuleBody(true);
     }
     | before_media_rule MEDIA_SYM at_rule_recovery {
         $$ = 0;
         parser->endRuleBody(true);
     }
     ;
 
 medium:
-  IDENT maybe_space {
-      $$ = $1;
-  }
+  IDENT maybe_space
   ;
 
 supports:
     before_supports_rule SUPPORTS_SYM maybe_space supports_condition at_supports_rule_header_end '{' at_rule_body_start maybe_space block_rule_body closing_brace {
         $$ = parser->createSupportsRule($4, $9);
     }
     | before_supports_rule SUPPORTS_SYM error error_location rule_error_recovery at_rule_end {
         $$ = 0;
         parser->reportError($4, CSSParser::InvalidSupportsConditionError);
         parser->endRuleBody(true);
@@ skipping 86 matching lines @@
 
 keyframes:
     before_keyframes_rule WEBKIT_KEYFRAMES_SYM maybe_space keyframe_name at_rule_header_end_maybe_space '{' at_rule_body_start maybe_space keyframes_rule closing_brace {
         $$ = parser->createKeyframesRule($4, parser->sinkFloatingKeyframeVector($9));
     }
   | before_keyframes_rule WEBKIT_KEYFRAMES_SYM at_rule_recovery {
         $$ = 0;
         parser->endRuleBody(true);
     }
     ;
-  
+
 keyframe_name:
     IDENT
     | STRING
     ;
 
 keyframes_rule:
     keyframe_rule_list
     | keyframe_rule_list keyframes_error_recovery {
         parser->clearProperties();
     };
@@ skipping 73 matching lines @@
     }
     ;
 
 page_selector:
     IDENT maybe_space {
         $$ = parser->createFloatingSelectorWithTagName(QualifiedName(nullAtom, $1, parser->m_defaultNamespace));
         $$->setForPage();
     }
     | IDENT pseudo_page maybe_space {
         $$ = $2;
-        if ($$) {
-            $$->prependTagSelector(QualifiedName(nullAtom, $1, parser->m_defaultNamespace));
-            $$->setForPage();
-        }
+        $$->prependTagSelector(QualifiedName(nullAtom, $1, parser->m_defaultNamespace));
+        $$->setForPage();
     }
     | pseudo_page maybe_space {
         $$ = $1;
-        if ($$)
-            $$->setForPage();
+        $$->setForPage();
     }
     | /* empty */ {
         $$ = parser->createFloatingSelector();
         $$->setForPage();
     }
     ;
 
 declarations_and_margins:
     declaration_list
     | declarations_and_margins margin_box maybe_space declaration_list
@@ skipping 153 matching lines @@
     }
     ;
 
 combinator:
     '+' maybe_space { $$ = CSSSelector::DirectAdjacent; }
   | '~' maybe_space { $$ = CSSSelector::IndirectAdjacent; }
   | '>' maybe_space { $$ = CSSSelector::Child; }
   ;
 
 maybe_unary_operator:
-    unary_operator { $$ = $1; }
-    | { $$ = 1; }
+    unary_operator
+    | /* empty */ { $$ = 1; }
     ;
 
 unary_operator:
     '-' { $$ = -1; }
   | '+' { $$ = 1; }
   ;
 
 maybe_space_before_declaration:
     maybe_space {
         parser->startProperty();
@@ skipping 73 matching lines @@
         while (end->tagHistory())
             end = end->tagHistory();
         end->setRelation($2);
         end->setTagHistory(parser->sinkFloatingSelector($1));
     }
     ;
 
 namespace_selector:
     /* empty */ '|' { $$.clear(); }
     | '*' '|' { static LChar star = '*'; $$.init(&star, 1); }
-    | IDENT '|' { $$ = $1; }
-;
-    
+    | IDENT '|'
+    ;
+
 simple_selector:
     element_name {
         $$ = parser->createFloatingSelectorWithTagName(QualifiedName(nullAtom, $1, parser->m_defaultNamespace));
     }
     | element_name specifier_list {
         $$ = parser->rewriteSpecifiersWithElementName(nullAtom, $1, $2);
         if (!$$)
             YYERROR;
     }
     | specifier_list {
@@ skipping 35 matching lines @@
             parser->tokenToLowerCase($1);
         $$ = $1;
     }
     | '*' {
         static LChar star = '*';
         $$.init(&star, 1);
     }
   ;
 
 specifier_list:
-    specifier {
-        $$ = $1;
-    }
+    specifier
     | specifier_list specifier {
         $$ = parser->rewriteSpecifiers($1, $2);
     }
 ;
 
 specifier:
     IDSEL {
         $$ = parser->createFloatingSelector();
         $$->setMatch(CSSSelector::Id);
         if (parser->m_context.mode == CSSQuirksMode)
@@ skipping 220 matching lines @@
     | ':' NOTFUNCTION selector_recovery closing_parenthesis {
         YYERROR;
     }
   ;
 
 selector_recovery:
     error error_location error_recovery;
 
 declaration_list:
     /* empty */ { $$ = false; }
-    | declaration {
-        $$ = $1;
+    | declaration
+    | decl_list declaration {
+        $$ = $1 || $2;
     }
-    | decl_list declaration {
-        $$ = $1;
-        if ( $2 )
-            $$ = $2;
-    }
-    | decl_list {
-        $$ = $1;
-    }
+    | decl_list
     ;
 
 decl_list:
     declaration ';' maybe_space {
         parser->startProperty();
         $$ = $1;
     }
     | decl_list declaration ';' maybe_space {
         parser->startProperty();
-        $$ = $1;
-        if ($2)
-            $$ = $2;
+        $$ = $1 || $2;
     }
     ;
 
 declaration:
     VAR_DEFINITION maybe_space ':' maybe_space expr prio {
         parser->storeVariableDeclaration($1, parser->sinkFloatingValueList($5), $6);
         $$ = true;
         parser->endProperty($6, true);
     }
     |
@@ skipping 53 matching lines @@
     | /* empty */ { $$ = false; }
   ;
 
 expr:
     term {
         $$ = parser->createFloatingValueList();
         $$->addValue(parser->sinkFloatingValue($1));
     }
     | expr operator term {
         $$ = $1;
-        if ($2)
-            $$->addValue(makeOperatorValue($2));
+        $$->addValue(makeOperatorValue($2));
         $$->addValue(parser->sinkFloatingValue($3));
     }
+    | expr term {
+        $$ = $1;
+        $$->addValue(parser->sinkFloatingValue($2));
+    }
   ;
 
 expr_recovery:
     error error_location error_recovery {
         parser->reportError($2, CSSParser::PropertyDeclarationError);
     }
   ;
 
 operator:
     '/' maybe_space {
         $$ = '/';
     }
   | ',' maybe_space {
         $$ = ',';
     }
-  | /* empty */ {
-        $$ = 0;
-  }
   ;
 
 term:
-  unary_term maybe_space { $$ = $1; }
+  unary_term maybe_space
   | unary_operator unary_term maybe_space { $$ = $2; $$.fValue *= $1; }
   | STRING maybe_space { $$.id = CSSValueInvalid; $$.string = $1; $$.unit = CSSPrimitiveValue::CSS_STRING; }
   | IDENT maybe_space {
       $$.id = cssValueKeywordID($1);
       $$.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 = CSSValueInvalid; $$.string = $1; $$.unit = CSSPrimitiveValue::CSS_DIMENSION; }
   | unary_operator DIMEN maybe_space { $$.id = CSSValueInvalid; $$.string = $2; $$.unit = CSSPrimitiveValue::CSS_DIMENSION; }
   | URI maybe_space { $$.id = CSSValueInvalid; $$.string = $1; $$.unit = CSSPrimitiveValue::CSS_URI; }
   | UNICODERANGE maybe_space { $$.id = CSSValueInvalid; $$.string = $1; $$.unit = CSSPrimitiveValue::CSS_UNICODE_RANGE; }
   | HEX maybe_space { $$.id = CSSValueInvalid; $$.string = $1; $$.unit = CSSPrimitiveValue::CSS_PARSER_HEXCOLOR; }
   | '#' maybe_space { $$.id = CSSValueInvalid; $$.string = CSSParserString(); $$.unit = CSSPrimitiveValue::CSS_PARSER_HEXCOLOR; } /* Handle error case: "color: #;" */
   | VARFUNCTION maybe_space IDENT closing_parenthesis maybe_space {
       $$.id = CSSValueInvalid;
       $$.string = $3;
       $$.unit = CSSPrimitiveValue::CSS_VARIABLE_NAME;
   }
   | VARFUNCTION maybe_space expr_recovery closing_parenthesis {
       YYERROR;
   }
   /* FIXME: according to the specs a function can have a unary_operator in front. I know no case where this makes sense */
-  | function maybe_space {
-      $$ = $1;
-  }
-  | calc_function maybe_space {
-      $$ = $1;
-  }
-  | min_or_max_function maybe_space {
-      $$ = $1;
-  }
+  | function maybe_space
+  | calc_function maybe_space
+  | min_or_max_function maybe_space
   | '%' maybe_space { /* Handle width: %; */
       $$.id = CSSValueInvalid; $$.unit = 0;
   }
   ;
 
 unary_term:
   INTEGER { $$.setFromNumber($1); $$.isInt = true; }
   | FLOATTOKEN { $$.setFromNumber($1); }
   | PERCENTAGE { $$.setFromNumber($1, CSSPrimitiveValue::CSS_PERCENTAGE); }
   | PXS { $$.setFromNumber($1, CSSPrimitiveValue::CSS_PX); }
@@ skipping 35 matching lines @@
     } |
     FUNCTION maybe_space closing_parenthesis {
         $$.setFromFunction(parser->createFloatingFunction($1, parser->sinkFloatingValueList(parser->createFloatingValueList())));
     } |
     FUNCTION maybe_space expr_recovery closing_parenthesis {
         YYERROR;
     }
   ;
 
 calc_func_term:
-  unary_term { $$ = $1; }
+  unary_term
   | VARFUNCTION maybe_space IDENT closing_parenthesis {
       $$.id = CSSValueInvalid;
       $$.string = $3;
       $$.unit = CSSPrimitiveValue::CSS_VARIABLE_NAME;
   }
   | unary_operator unary_term { $$ = $2; $$.fValue *= $1; }
   ;
 
 calc_func_operator:
     WHITESPACE '+' WHITESPACE {
@@ skipping 38 matching lines @@
     }
     | calc_func_expr calc_func_operator calc_func_paren_expr {
         $$ = $1;
         $$->addValue(makeOperatorValue($2));
         $$->extend(*($3));
     }
     | calc_func_paren_expr
   ;
 
 calc_func_expr_list:
-    calc_func_expr calc_maybe_space {
-        $$ = $1;
-    }    
+    calc_func_expr calc_maybe_space
     | calc_func_expr_list ',' maybe_space calc_func_expr calc_maybe_space {
         $$ = $1;
         $$->addValue(makeOperatorValue(','));
         $$->extend(*($4));
     }
   ;
 
 calc_function:
     CALCFUNCTION maybe_space calc_func_expr calc_maybe_space closing_parenthesis {
         $$.setFromFunction(parser->createFloatingFunction($1, parser->sinkFloatingValueList($3)));
     }
     | CALCFUNCTION maybe_space expr_recovery closing_parenthesis {
         YYERROR;
     }
     ;
 
 
 min_or_max:
-    MINFUNCTION {
-        $$ = $1;
-    }
-    | MAXFUNCTION {
-        $$ = $1;
-    }
+    MINFUNCTION
+    | MAXFUNCTION
     ;
 
 min_or_max_function:
     min_or_max maybe_space calc_func_expr_list closing_parenthesis {
         $$.setFromFunction(parser->createFloatingFunction($1, parser->sinkFloatingValueList($3)));
-    } 
+    }
     | min_or_max maybe_space expr_recovery closing_parenthesis {
         YYERROR;
     }
     ;
 
 invalid_at:
     ATKEYWORD
-  | margin_sym 
+  | margin_sym
     ;
 
 at_rule_recovery:
     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);
     }
@@ skipping 54 matching lines @@
 
 rule_error_recovery:
     /* empty */
   | rule_error_recovery error
   | rule_error_recovery invalid_square_brackets_block
   | rule_error_recovery invalid_parentheses_block
     ;
 
 %%