diff mbox

[C++] Add default arguments to cp_parser_assignment_expression and cp_parser_constant_expression

Message ID 53F340A6.4080900@oracle.com
State New
Headers show

Commit Message

Paolo Carlini Aug. 19, 2014, 12:18 p.m. UTC 
Hi,

two more functions. Tested x86_64-linux.

Thanks,
Paolo.

///////////////////////
2014-08-19  Paolo Carlini  <paolo.carlini@oracle.com>

	* parser.c (cp_parser_assignment_expression,
	cp_parser_constant_expression): Add default arguments.
	(cp_parser_primary_expression,
	cp_parser_postfix_open_square_expression,
	cp_parser_parenthesized_expression_list,
	cp_parser_question_colon_clause,
	cp_parser_expression, cp_parser_constant_expression,
	cp_parser_label_for_labeled_statement, cp_parser_static_assert,
	cp_parser_template_argument, cp_parser_enumerator_definition,
	cp_parser_member_declaration, cp_parser_constant_initializer,
	cp_parser_noexcept_specification_opt, cp_parser_throw_expression,
	cp_parser_std_attribute_spec, cp_parser_objc_message_args,
	cp_parser_objc_class_ivars, cp_parser_omp_clause_collapse,
	cp_parser_omp_clause_aligned, cp_parser_omp_clause_safelen,
	cp_parser_omp_clause_simdlen, cp_parser_omp_clause_dist_schedule,
	cp_parser_omp_for_incr, cp_parser_omp_for_loop_init,
	cp_parser_cilk_simd_vectorlength, cp_parser_cilk_simd_linear): Adjust.

Comments

Paolo Carlini Sept. 10, 2014, 10:14 a.m. UTC | #1 
Hi,

On 08/19/2014 02:18 PM, Paolo Carlini wrote:
> Hi,
>
> two more functions. Tested x86_64-linux.
I'm pinging this.

     https://gcc.gnu.org/ml/gcc-patches/2014-08/msg01853.html

Frankly, the cp_parser_constant_expression bits seem rather 
straightforward to me. As regards the cp_parser_assignment_expression 
bits, I realize that it's debatable whether moving the cp_id_kind * 
parameter before the bool parameters is really an improvement from say 
the readibility point of view, but I did that already for 
cp_parser_expression, in case we should revert the latter change, for 
consistency.

Paolo.
Jason Merrill Oct. 2, 2014, 6:03 p.m. UTC | #2 
On 08/19/2014 08:18 AM, Paolo Carlini wrote:
> -                                   /*non_constant_p=*/&dummy);
> +                                   &dummy);

Why remove the comment?

The rest of the patch is OK.

Jason
Paolo Carlini Oct. 2, 2014, 6:11 p.m. UTC | #3 
Hi,

On 10/02/2014 08:03 PM, Jason Merrill wrote:
> On 08/19/2014 08:18 AM, Paolo Carlini wrote:
>> - /*non_constant_p=*/&dummy);
>> +                                   &dummy);
>
> Why remove the comment?
Oh well, the rationale was that normally we use that sort of comment 
only to explain integer literals, boolean literals. But I don't have a 
strong opinion ;)
> The rest of the patch is OK.
Good, thanks!

Paolo.
diff mbox

Patch

Index: parser.c
===================================================================
--- parser.c	(revision 214138)
+++ parser.c	(working copy)
@@ -1959,13 +1959,13 @@  static tree cp_parser_binary_expression
 static tree cp_parser_question_colon_clause
   (cp_parser *, tree);
 static tree cp_parser_assignment_expression
-  (cp_parser *, bool, cp_id_kind *);
+  (cp_parser *, cp_id_kind * = NULL, bool = false, bool = false);
 static enum tree_code cp_parser_assignment_operator_opt
   (cp_parser *);
 static tree cp_parser_expression
   (cp_parser *, cp_id_kind * = NULL, bool = false, bool = false);
 static tree cp_parser_constant_expression
-  (cp_parser *, bool, bool *);
+  (cp_parser *, bool = false, bool * = NULL);
 static tree cp_parser_builtin_offsetof
   (cp_parser *);
 static tree cp_parser_lambda_expression
@@ -4446,8 +4446,7 @@  cp_parser_primary_expression (cp_parser *parser,
 	    /* Look for the opening `('.  */
 	    cp_parser_require (parser, CPP_OPEN_PAREN, RT_OPEN_PAREN);
 	    /* Now, parse the assignment-expression.  */
-	    expression = cp_parser_assignment_expression (parser,
-							  /*cast_p=*/false, NULL);
+	    expression = cp_parser_assignment_expression (parser);
 	    /* Look for the `,'.  */
 	    cp_parser_require (parser, CPP_COMMA, RT_COMMA);
 	    type_location = cp_lexer_peek_token (parser->lexer)->location;
@@ -6415,7 +6411,7 @@  cp_parser_postfix_open_square_expression (cp_parse
      Rather than open the barn door too wide right away, allow only integer
      constant expressions here.  */
   if (for_offsetof)
-    index = cp_parser_constant_expression (parser, false, NULL);
+    index = cp_parser_constant_expression (parser);
   else
     {
       if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_BRACE))
@@ -6798,8 +6794,8 @@  cp_parser_parenthesized_expression_list (cp_parser
 		    break;
 		  }
 		if (expr == NULL_TREE)
-		  expr = cp_parser_assignment_expression (parser, cast_p,
-							  NULL);
+		  expr = cp_parser_assignment_expression (parser, /*pidk=*/NULL,
+							  cast_p);
 	      }
 
 	    if (fold_expr_p)
@@ -8229,7 +8220,7 @@  cp_parser_question_colon_clause (cp_parser* parser
   /* The next token should be a `:'.  */
   cp_parser_require (parser, CPP_COLON, RT_COLON);
   /* Parse the assignment-expression.  */
-  assignment_expr = cp_parser_assignment_expression (parser, /*cast_p=*/false, NULL);
+  assignment_expr = cp_parser_assignment_expression (parser);
   c_inhibit_evaluation_warnings -= logical_or_expr == truthvalue_true_node;
 
   /* Build the conditional-expression.  */
@@ -8252,8 +8243,8 @@  cp_parser_question_colon_clause (cp_parser* parser
    Returns a representation for the expression.  */
 
 static tree
-cp_parser_assignment_expression (cp_parser* parser, bool cast_p,
-				 bool decltype_p, cp_id_kind * pidk)
+cp_parser_assignment_expression (cp_parser* parser, cp_id_kind * pidk,
+				 bool cast_p, bool decltype_p)
 {
   tree expr;
 
@@ -8313,14 +8304,6 @@  static tree
   return expr;
 }
 
-static tree
-cp_parser_assignment_expression (cp_parser* parser, bool cast_p,
-				 cp_id_kind * pidk)
-{
-  return cp_parser_assignment_expression (parser, cast_p,
-					  /*decltype*/false, pidk);
-}
-
 /* Parse an (optional) assignment-operator.
 
    assignment-operator: one of
@@ -8430,7 +8413,7 @@  cp_parser_expression (cp_parser* parser, cp_id_kin
 
       /* Parse the next assignment-expression.  */
       assignment_expression
-	= cp_parser_assignment_expression (parser, cast_p, decltype_p, pidk);
+	= cp_parser_assignment_expression (parser, pidk, cast_p, decltype_p);
 
       /* We don't create a temporary for a call that is the immediate operand
 	 of decltype or on the RHS of a comma.  But when we see a comma, we
@@ -8522,7 +8505,7 @@  cp_parser_constant_expression (cp_parser* parser,
      For example, cp_parser_initializer_clauses uses this function to
      determine whether a particular assignment-expression is in fact
      constant.  */
-  expression = cp_parser_assignment_expression (parser, /*cast_p=*/false, NULL);
+  expression = cp_parser_assignment_expression (parser);
   /* Restore the old settings.  */
   parser->integral_constant_expression_p
     = saved_integral_constant_expression_p;
@@ -9708,9 +9691,7 @@  cp_parser_label_for_labeled_statement (cp_parser*
 	/* Consume the `case' token.  */
 	cp_lexer_consume_token (parser->lexer);
 	/* Parse the constant-expression.  */
-	expr = cp_parser_constant_expression (parser,
-					      /*allow_non_constant_p=*/false,
-					      NULL);
+	expr = cp_parser_constant_expression (parser);
 
 	ellipsis = cp_lexer_peek_token (parser->lexer);
 	if (ellipsis->type == CPP_ELLIPSIS)
@@ -9718,9 +9699,8 @@  cp_parser_label_for_labeled_statement (cp_parser*
 	    /* Consume the `...' token.  */
 	    cp_lexer_consume_token (parser->lexer);
 	    expr_hi =
-	      cp_parser_constant_expression (parser,
-					     /*allow_non_constant_p=*/false,
-					     NULL);
+	      cp_parser_constant_expression (parser);
+
 	    /* We don't need to emit warnings here, as the common code
 	       will do this for us.  */
 	  }
@@ -11999,7 +11979,7 @@  cp_parser_static_assert(cp_parser *parser, bool me
   condition = 
     cp_parser_constant_expression (parser,
                                    /*allow_non_constant_p=*/true,
-                                   /*non_constant_p=*/&dummy);
+                                   &dummy);
 
   /* Parse the separating `,'.  */
   cp_parser_require (parser, CPP_COMMA, RT_COMMA);
@@ -14198,9 +14175,8 @@  cp_parser_template_argument (cp_parser* parser)
      because the argument could really be a type-id.  */
   if (maybe_type_id)
     cp_parser_parse_tentatively (parser);
-  argument = cp_parser_constant_expression (parser,
-					    /*allow_non_constant_p=*/false,
-					    /*non_constant_p=*/NULL);
+  argument = cp_parser_constant_expression (parser);
+
   if (!maybe_type_id)
     return argument;
   if (!cp_parser_next_token_ends_template_argument_p (parser))
@@ -15861,9 +15837,7 @@  cp_parser_enumerator_definition (cp_parser* parser
       /* Consume the `=' token.  */
       cp_lexer_consume_token (parser->lexer);
       /* Parse the value.  */
-      value = cp_parser_constant_expression (parser,
-					     /*allow_non_constant_p=*/false,
-					     NULL);
+      value = cp_parser_constant_expression (parser);
     }
   else
     value = NULL_TREE;
@@ -20611,9 +20586,7 @@  cp_parser_member_declaration (cp_parser* parser)
 	      cp_lexer_consume_token (parser->lexer);
 	      /* Get the width of the bitfield.  */
 	      width
-		= cp_parser_constant_expression (parser,
-						 /*allow_non_constant=*/false,
-						 NULL);
+		= cp_parser_constant_expression (parser);
 
 	      /* Look for attributes that apply to the bitfield.  */
 	      attributes = cp_parser_attributes_opt (parser);
@@ -20938,9 +20911,7 @@  cp_parser_constant_initializer (cp_parser* parser)
       return error_mark_node;
     }
 
-  return cp_parser_constant_expression (parser,
-					/*allow_non_constant=*/false,
-					NULL);
+  return cp_parser_constant_expression (parser);
 }
 
 /* Derived classes [gram.class.derived] */
@@ -21200,7 +21171,7 @@  cp_parser_noexcept_specification_opt (cp_parser* p
 	      parser->type_definition_forbidden_message
 	      = G_("types may not be defined in an exception-specification");
 
-	      expr = cp_parser_constant_expression (parser, false, NULL);
+	      expr = cp_parser_constant_expression (parser);
 
 	      /* Restore the saved message.  */
 	      parser->type_definition_forbidden_message = saved_message;
@@ -21511,8 +21482,7 @@  cp_parser_throw_expression (cp_parser* parser)
       || token->type == CPP_COLON)
     expression = NULL_TREE;
   else
-    expression = cp_parser_assignment_expression (parser,
-						  /*cast_p=*/false, NULL);
+    expression = cp_parser_assignment_expression (parser);
 
   return build_throw (expression);
 }
@@ -22236,8 +22202,7 @@  cp_parser_std_attribute_spec (cp_parser *parser)
 		      || alignas_expr == NULL_TREE);
 
 	  alignas_expr =
-	    cp_parser_assignment_expression (parser, /*cast_p=*/false,
-					     /**cp_id_kind=*/NULL);
+	    cp_parser_assignment_expression (parser);
 	  if (alignas_expr == error_mark_node)
 	    cp_parser_skip_to_end_of_statement (parser);
 	  if (alignas_expr == NULL_TREE
@@ -25430,7 +25393,7 @@  cp_parser_objc_message_args (cp_parser* parser)
 
       maybe_unary_selector_p = false;
       cp_parser_require (parser, CPP_COLON, RT_COLON);
-      arg = cp_parser_assignment_expression (parser, false, NULL);
+      arg = cp_parser_assignment_expression (parser);
 
       sel_args
 	= chainon (sel_args,
@@ -25445,7 +25408,7 @@  cp_parser_objc_message_args (cp_parser* parser)
       tree arg;
 
       cp_lexer_consume_token (parser->lexer);
-      arg = cp_parser_assignment_expression (parser, false, NULL);
+      arg = cp_parser_assignment_expression (parser);
 
       addl_args
 	= chainon (addl_args,
@@ -26309,9 +26272,7 @@  cp_parser_objc_class_ivars (cp_parser* parser)
 	      cp_lexer_consume_token (parser->lexer);  /* Eat ':'.  */
 	      /* Get the width of the bitfield.  */
 	      width
-		= cp_parser_constant_expression (parser,
-						 /*allow_non_constant=*/false,
-						 NULL);
+		= cp_parser_constant_expression (parser);
 	    }
 	  else
 	    {
@@ -27511,7 +27472,7 @@  cp_parser_omp_clause_collapse (cp_parser *parser,
   if (!cp_parser_require (parser, CPP_OPEN_PAREN, RT_OPEN_PAREN))
     return list;
 
-  num = cp_parser_constant_expression (parser, false, NULL);
+  num = cp_parser_constant_expression (parser);
 
   if (!cp_parser_require (parser, CPP_CLOSE_PAREN, RT_CLOSE_PAREN))
     cp_parser_skip_to_closing_parenthesis (parser, /*recovering=*/true,
@@ -27901,7 +27862,7 @@  cp_parser_omp_clause_schedule (cp_parser *parser,
       cp_lexer_consume_token (parser->lexer);
 
       token = cp_lexer_peek_token (parser->lexer);
-      t = cp_parser_assignment_expression (parser, false, NULL);
+      t = cp_parser_assignment_expression (parser);
 
       if (t == error_mark_node)
 	goto resync_fail;
@@ -28057,7 +28018,7 @@  cp_parser_omp_clause_aligned (cp_parser *parser, t
 
   if (colon)
     {
-      alignment = cp_parser_constant_expression (parser, false, NULL);
+      alignment = cp_parser_constant_expression (parser);
 
       if (!cp_parser_require (parser, CPP_CLOSE_PAREN, RT_CLOSE_PAREN))
 	cp_parser_skip_to_closing_parenthesis (parser, /*recovering=*/true,
@@ -28127,7 +28088,7 @@  cp_parser_omp_clause_safelen (cp_parser *parser, t
   if (!cp_parser_require (parser, CPP_OPEN_PAREN, RT_OPEN_PAREN))
     return list;
 
-  t = cp_parser_constant_expression (parser, false, NULL);
+  t = cp_parser_constant_expression (parser);
 
   if (t == error_mark_node
       || !cp_parser_require (parser, CPP_CLOSE_PAREN, RT_CLOSE_PAREN))
@@ -28156,7 +28117,7 @@  cp_parser_omp_clause_simdlen (cp_parser *parser, t
   if (!cp_parser_require (parser, CPP_OPEN_PAREN, RT_OPEN_PAREN))
     return list;
 
-  t = cp_parser_constant_expression (parser, false, NULL);
+  t = cp_parser_constant_expression (parser);
 
   if (t == error_mark_node
       || !cp_parser_require (parser, CPP_CLOSE_PAREN, RT_CLOSE_PAREN))
@@ -28330,7 +28291,7 @@  cp_parser_omp_clause_dist_schedule (cp_parser *par
     {
       cp_lexer_consume_token (parser->lexer);
 
-      t = cp_parser_assignment_expression (parser, false, NULL);
+      t = cp_parser_assignment_expression (parser);
 
       if (t == error_mark_node)
 	goto resync_fail;
@@ -29280,7 +29241,7 @@  cp_parser_omp_for_incr (cp_parser *parser, tree de
 
   if (op != NOP_EXPR)
     {
-      rhs = cp_parser_assignment_expression (parser, false, NULL);
+      rhs = cp_parser_assignment_expression (parser);
       rhs = build2 (op, TREE_TYPE (decl), decl, rhs);
       return build2 (MODIFY_EXPR, TREE_TYPE (decl), decl, rhs);
     }
@@ -29456,7 +29417,7 @@  cp_parser_omp_for_loop_init (cp_parser *parser,
 	    {
 	      /* Consume '='.  */
 	      cp_lexer_consume_token (parser->lexer);
-	      init = cp_parser_assignment_expression (parser, false, NULL);
+	      init = cp_parser_assignment_expression (parser);
 
 	    non_class:
 	      if (TREE_CODE (TREE_TYPE (decl)) == REFERENCE_TYPE)
@@ -29489,7 +29450,7 @@  cp_parser_omp_for_loop_init (cp_parser *parser,
 
 	  cp_parser_parse_definitely (parser);
 	  cp_parser_require (parser, CPP_EQ, RT_EQ);
-	  rhs = cp_parser_assignment_expression (parser, false, NULL);
+	  rhs = cp_parser_assignment_expression (parser);
 	  finish_expr_stmt (build_x_modify_expr (EXPR_LOCATION (rhs),
 						 decl, NOP_EXPR,
 						 rhs,
@@ -31957,8 +31916,8 @@  cp_parser_cilk_simd_vectorlength (cp_parser *parse
 
   if (!cp_parser_require (parser, CPP_OPEN_PAREN, RT_OPEN_PAREN))
     return error_mark_node;
-  
-  expr = cp_parser_constant_expression (parser, false, NULL);
+
+  expr = cp_parser_constant_expression (parser);
   expr = maybe_constant_value (expr);
   
   /* If expr == error_mark_node, then don't emit any errors nor
@@ -32059,7 +32018,7 @@  cp_parser_cilk_simd_linear (cp_parser *parser, tre
 	    {
 	      cp_lexer_consume_token (parser->lexer);
 
-	      e = cp_parser_assignment_expression (parser, false, NULL);
+	      e = cp_parser_assignment_expression (parser);
 	      e = maybe_constant_value (e);
 
 	      if (e == error_mark_node)