c-tree.h (parser_build_unary_op): New prototype.

	* c-tree.h (parser_build_unary_op): New prototype.
	* c-typeck.c (parser_build_unary_op): New function to construct
	a unary operation in the C parser.
	* c-parser.c (c_parser_unary_expression):  Use the new function
	parser_build_unary_op when appropriate.

From-SVN: r99471

gcc/ChangeLog

+2005-05-09  Roger Sayle  <roger@eyesopen.com>
+
+	* c-tree.h (parser_build_unary_op): New prototype.
+	* c-typeck.c (parser_build_unary_op): New function to construct
+	a unary operation in the C parser.
+	* c-parser.c (c_parser_unary_expression):  Use the new function
+	parser_build_unary_op when appropriate.
+
 2005-05-09  Mark Mitchell  <mark@codesourcery.com>
 
 	PR 18655

gcc/c-parser.c

@@ -4495,66 +4495,45 @@ c_parser_unary_expression (c_parser *parser)
 {
   int ext;
   struct c_expr ret;
-  ret.original_code = ERROR_MARK;
   switch (c_parser_peek_token (parser)->type)
     {
     case CPP_PLUS_PLUS:
       c_parser_consume_token (parser);
-      ret.value
-	= build_unary_op (PREINCREMENT_EXPR,
-			  c_parser_cast_expression (parser, NULL).value, 0);
-      overflow_warning (ret.value);
-      return ret;
+      return parser_build_unary_op (PREINCREMENT_EXPR,
+				    c_parser_cast_expression (parser, NULL));
     case CPP_MINUS_MINUS:
       c_parser_consume_token (parser);
-      ret.value
-	= build_unary_op (PREDECREMENT_EXPR,
-			  c_parser_cast_expression (parser, NULL).value, 0);
-      overflow_warning (ret.value);
-      return ret;
+      return parser_build_unary_op (PREDECREMENT_EXPR,
+				    c_parser_cast_expression (parser, NULL));
     case CPP_AND:
       c_parser_consume_token (parser);
-      ret.value
-	= build_unary_op (ADDR_EXPR,
-			  c_parser_cast_expression (parser, NULL).value, 0);
-      overflow_warning (ret.value);
-      return ret;
+      return parser_build_unary_op (ADDR_EXPR,
+				    c_parser_cast_expression (parser, NULL));
     case CPP_MULT:
       c_parser_consume_token (parser);
       ret.value
 	= build_indirect_ref (c_parser_cast_expression (parser, NULL).value,
 			      "unary *");
+      ret.original_code = ERROR_MARK;
       return ret;
     case CPP_PLUS:
       c_parser_consume_token (parser);
       if (!c_dialect_objc () && warn_traditional && !in_system_header)
 	warning (0, "traditional C rejects the unary plus operator");
-      ret.value
-	= build_unary_op (CONVERT_EXPR,
-			  c_parser_cast_expression (parser, NULL).value, 0);
-      overflow_warning (ret.value);
-      return ret;
+      return parser_build_unary_op (CONVERT_EXPR,
+				    c_parser_cast_expression (parser, NULL));
     case CPP_MINUS:
       c_parser_consume_token (parser);
-      ret.value
-	= build_unary_op (NEGATE_EXPR,
-			  c_parser_cast_expression (parser, NULL).value, 0);
-      overflow_warning (ret.value);
-      return ret;
+      return parser_build_unary_op (NEGATE_EXPR,
+				    c_parser_cast_expression (parser, NULL));
     case CPP_COMPL:
       c_parser_consume_token (parser);
-      ret.value
-	= build_unary_op (BIT_NOT_EXPR,
-			  c_parser_cast_expression (parser, NULL).value, 0);
-      overflow_warning (ret.value);
-      return ret;
+      return parser_build_unary_op (BIT_NOT_EXPR,
+				    c_parser_cast_expression (parser, NULL));
     case CPP_NOT:
       c_parser_consume_token (parser);
-      ret.value
-	= build_unary_op (TRUTH_NOT_EXPR,
-			  c_parser_cast_expression (parser, NULL).value, 0);
-      overflow_warning (ret.value);
-      return ret;
+      return parser_build_unary_op (TRUTH_NOT_EXPR,
+				    c_parser_cast_expression (parser, NULL));
     case CPP_AND_AND:
       /* Refer to the address of a label as a pointer.  */
       c_parser_consume_token (parser);
@@ -4563,14 +4542,14 @@ c_parser_unary_expression (c_parser *parser)
 	  ret.value = finish_label_address_expr
 	    (c_parser_peek_token (parser)->value);
 	  c_parser_consume_token (parser);
-	  return ret;
 	}
       else
 	{
 	  c_parser_error (parser, "expected identifier");
 	  ret.value = error_mark_node;
-	  return ret;
 	}
+	ret.original_code = ERROR_MARK;
+	return ret;
     case CPP_KEYWORD:
       switch (c_parser_peek_token (parser)->keyword)
 	{
@@ -4586,18 +4565,14 @@ c_parser_unary_expression (c_parser *parser)
 	  return ret;
 	case RID_REALPART:
 	  c_parser_consume_token (parser);
-	  ret.value
-	    = build_unary_op (REALPART_EXPR,
-			      c_parser_cast_expression (parser, NULL).value,
-			      0);
-	  return ret;
+	  return parser_build_unary_op (REALPART_EXPR,
+					c_parser_cast_expression (parser,
+								  NULL));
 	case RID_IMAGPART:
 	  c_parser_consume_token (parser);
-	  ret.value
-	    = build_unary_op (IMAGPART_EXPR,
-			      c_parser_cast_expression (parser, NULL).value,
-			      0);
-	  return ret;
+	  return parser_build_unary_op (IMAGPART_EXPR,
+					c_parser_cast_expression (parser,
+								  NULL));
 	default:
 	  return c_parser_postfix_expression (parser);
 	}

gcc/c-tree.h

@@ -531,6 +531,7 @@ extern tree build_external_ref (tree, int, location_t);
 extern void pop_maybe_used (bool);
 extern struct c_expr c_expr_sizeof_expr (struct c_expr);
 extern struct c_expr c_expr_sizeof_type (struct c_type_name *);
+extern struct c_expr parser_build_unary_op (enum tree_code, struct c_expr);
 extern struct c_expr parser_build_binary_op (enum tree_code, struct c_expr,
 					     struct c_expr);
 extern tree build_conditional_expr (tree, tree, tree);

gcc/c-typeck.c

@@ -2312,11 +2312,27 @@ convert_arguments (tree typelist, tree values, tree function, tree fundecl)
   return nreverse (result);
 }
 
-/* This is the entry point used by the parser
-   for binary operators in the input.
-   In addition to constructing the expression,
-   we check for operands that were written with other binary operators
-   in a way that is likely to confuse the user.  */
+/* This is the entry point used by the parser to build unary operators
+   in the input.  CODE, a tree_code, specifies the unary operator, and
+   ARG is the operand.  For unary plus, the C parser currently uses
+   CONVERT_EXPR for code.  */
+
+struct c_expr
+parser_build_unary_op (enum tree_code code, struct c_expr arg)
+{
+  struct c_expr result;
+
+  result.original_code = ERROR_MARK;
+  result.value = build_unary_op (code, arg.value, 0);
+  overflow_warning (result.value);
+  return result;
+}
+
+/* This is the entry point used by the parser to build binary operators
+   in the input.  CODE, a tree_code, specifies the binary operator, and
+   ARG1 and ARG2 are the operands.  In addition to constructing the
+   expression, we check for operands that were written with other binary
+   operators in a way that is likely to confuse the user.  */
 
 struct c_expr
 parser_build_binary_op (enum tree_code code, struct c_expr arg1,