[PATCH] Fix up COMPLEX_EXPR pretty-printing (PR c++/35334)

Jakub Jelinek jakub@redhat.com
Tue Nov 11 14:16:00 GMT 2008


Hi!

Currently, C++ FE doesn't handle COMPLEX_EXPR at all in diagnostics
and C FE always prints it in a compound literal style, even when
the COMPLEX_EXPR represents just a cast to a complex type.

The following patch handles both of these issues.

Ok for trunk?

2008-11-11  Jakub Jelinek  <jakub@redhat.com>

	PR c++/35334
	* c-pretty-print.c (pp_c_complex_expr): New function.
	(pp_c_postfix_expression) <case COMPLEX_EXPR>: Call it.

	* error.c (dump_expr): Handle COMPLEX_EXPR.

	* gcc.dg/pr35334.c: New test.
	* g++.dg/other/error29.C: New test.

--- gcc/c-pretty-print.c.jj	2008-10-23 13:21:40.000000000 +0200
+++ gcc/c-pretty-print.c	2008-11-11 14:40:36.000000000 +0100
@@ -975,6 +975,46 @@ pp_c_compound_literal (c_pretty_printer 
     }
 }
 
+/* Pretty-print a COMPLEX_EXPR expression.  */
+
+static void
+pp_c_complex_expr (c_pretty_printer *pp, tree e)
+{
+  /* Handle a few common special cases, otherwise fallback
+     to printing it as compound literal.  */
+  tree type = TREE_TYPE (e);
+  tree realexpr = TREE_OPERAND (e, 0);
+  tree imagexpr = TREE_OPERAND (e, 1);
+
+  /* Cast of an COMPLEX_TYPE expression to a different COMPLEX_TYPE.  */
+  if (TREE_CODE (realexpr) == NOP_EXPR
+      && TREE_CODE (imagexpr) == NOP_EXPR
+      && TREE_TYPE (realexpr) == TREE_TYPE (type)
+      && TREE_TYPE (imagexpr) == TREE_TYPE (type)
+      && TREE_CODE (TREE_OPERAND (realexpr, 0)) == REALPART_EXPR
+      && TREE_CODE (TREE_OPERAND (imagexpr, 0)) == IMAGPART_EXPR
+      && TREE_OPERAND (TREE_OPERAND (realexpr, 0), 0)
+	 == TREE_OPERAND (TREE_OPERAND (imagexpr, 0), 0))
+    {
+      pp_c_type_cast (pp, type);
+      pp_expression (pp, TREE_OPERAND (TREE_OPERAND (realexpr, 0), 0));
+      return;
+    }
+
+  /* Cast of an scalar expression to COMPLEX_TYPE.  */
+  if ((integer_zerop (imagexpr) || real_zerop (imagexpr))
+      && TREE_TYPE (realexpr) == TREE_TYPE (type))
+    {
+      pp_c_type_cast (pp, type);
+      if (TREE_CODE (realexpr) == NOP_EXPR)
+	realexpr = TREE_OPERAND (realexpr, 0);
+      pp_expression (pp, realexpr);
+      return;
+    }
+
+  pp_c_compound_literal (pp, e);
+}
+
 /* constant:
       integer-constant
       floating-constant
@@ -1406,10 +1446,13 @@ pp_c_postfix_expression (c_pretty_printe
 
     case COMPLEX_CST:
     case VECTOR_CST:
-    case COMPLEX_EXPR:
       pp_c_compound_literal (pp, e);
       break;
 
+    case COMPLEX_EXPR:
+      pp_c_complex_expr (pp, e);
+      break;
+
     case COMPOUND_LITERAL_EXPR:
       e = DECL_INITIAL (COMPOUND_LITERAL_EXPR_DECL (e));
       /* Fall through.  */
--- gcc/cp/error.c.jj	2008-10-23 13:21:09.000000000 +0200
+++ gcc/cp/error.c	2008-11-11 14:44:23.000000000 +0100
@@ -2068,6 +2068,7 @@ dump_expr (tree t, int flags)
     case UNGE_EXPR:
     case UNEQ_EXPR:
     case LTGT_EXPR:
+    case COMPLEX_EXPR:
       pp_expression (cxx_pp, t);
       break;
 
--- gcc/testsuite/gcc.dg/pr35334.c.jj	2008-11-11 14:50:43.000000000 +0100
+++ gcc/testsuite/gcc.dg/pr35334.c	2008-11-11 14:53:51.000000000 +0100
@@ -0,0 +1,21 @@
+/* PR c++/35334 */
+/* { dg-do compile } */
+/* { dg-options "-std=gnu99" } */
+
+__complex__ unsigned int i;
+int j;
+char k;
+__complex__ double l;
+double m;
+float n;
+
+void
+foo ()
+{
+  ((__complex__ int)i)();		/* { dg-error "is not a function" } */
+  ((__complex__ int)j)();		/* { dg-error "is not a function" } */
+  ((__complex__ int)k)();		/* { dg-error "is not a function" } */
+  ((__complex__ long double)l)();	/* { dg-error "is not a function" } */
+  ((__complex__ long double)m)();	/* { dg-error "is not a function" } */
+  ((__complex__ long double)n)();	/* { dg-error "is not a function" } */
+}
--- gcc/testsuite/g++.dg/other/error29.C.jj	2008-11-11 14:52:04.000000000 +0100
+++ gcc/testsuite/g++.dg/other/error29.C	2008-11-11 14:52:49.000000000 +0100
@@ -0,0 +1,20 @@
+// PR c++/35334
+// { dg-do compile }
+
+__complex__ unsigned int i;
+int j;
+char k;
+__complex__ double l;
+double m;
+float n;
+
+void
+foo ()
+{
+  ((__complex__ int)i)();		// { dg-error "cannot be used as a function" }
+  ((__complex__ int)j)();		// { dg-error "cannot be used as a function" }
+  ((__complex__ int)k)();		// { dg-error "cannot be used as a function" }
+  ((__complex__ long double)l)();	// { dg-error "cannot be used as a function" }
+  ((__complex__ long double)m)();	// { dg-error "cannot be used as a function" }
+  ((__complex__ long double)n)();	// { dg-error "cannot be used as a function" }
+}

	Jakub



More information about the Gcc-patches mailing list