c-common.c (lvalue_or_else): Replace by lvalue_error; only give diagnostic without...

	* c-common.c (lvalue_or_else): Replace by lvalue_error; only give
	diagnostic without checking whether an lvalue.
	* c-common.h (lvalue_p): Remove.
	(enum lvalue_use): Update comment.
	(lvalue_or_else): Replace by lvalue_error.
	* c-typeck.c (lvalue_p): Make static.
	(lvalue_or_else): New.  Call lvalue_error.

cp:
	* cp-tree.h (lvalue_or_else, lvalue_p): New.
	* typeck.c (lvalue_or_else): New.  Call lvalue_error.

From-SVN: r96776

diff --git a/gcc/ChangeLog b/gcc/ChangeLog
index d9355e4082aea687ee866d7202accff504624025..34e1a5ddbb2649a2084a95785b44294a5485e170 100644 (file)
--- a/gcc/ChangeLog
+++ b/gcc/ChangeLog
@@ -1,3 +1,13 @@
+2005-03-21  Joseph S. Myers  <joseph@codesourcery.com>
+
+       * c-common.c (lvalue_or_else): Replace by lvalue_error; only give
+       diagnostic without checking whether an lvalue.
+       * c-common.h (lvalue_p): Remove.
+       (enum lvalue_use): Update comment.
+       (lvalue_or_else): Replace by lvalue_error.
+       * c-typeck.c (lvalue_p): Make static.
+       (lvalue_or_else): New.  Call lvalue_error.
+
 2005-03-21  Alan Modra  <amodra@bigpond.net.au>
 
        * config/rs6000/rs6000.c (rs6000_parm_start): New function.

diff --git a/gcc/c-common.c b/gcc/c-common.c
index 1851836e9df326778d5a624b2f59cb766951ea6d..9c6a9d141afcfd68d034d9b03a94ae095a88c7ff 100644 (file)
--- a/gcc/c-common.c
+++ b/gcc/c-common.c
@@ -5721,40 +5721,32 @@ fold_offsetof (tree expr)
   return convert (size_type_node, fold_offsetof_1 (expr));
 }
 
-/* Return nonzero if REF is an lvalue valid for this language;
-   otherwise, print an error message and return zero.  USE says
+/* Print an error message for an invalid lvalue.  USE says
    how the lvalue is being used and so selects the error message.  */
 
-int
-lvalue_or_else (tree ref, enum lvalue_use use)
+void
+lvalue_error (enum lvalue_use use)
 {
-  int win = lvalue_p (ref);
-
-  if (!win)
+  switch (use)
     {
-      switch (use)
-       {
-       case lv_assign:
-         error ("invalid lvalue in assignment");
-         break;
-       case lv_increment:
-         error ("invalid lvalue in increment");
-         break;
-       case lv_decrement:
-         error ("invalid lvalue in decrement");
-         break;
-       case lv_addressof:
-         error ("invalid lvalue in unary %<&%>");
-         break;
-       case lv_asm:
-         error ("invalid lvalue in asm statement");
-         break;
-       default:
-         gcc_unreachable ();
-       }
+    case lv_assign:
+      error ("invalid lvalue in assignment");
+      break;
+    case lv_increment:
+      error ("invalid lvalue in increment");
+      break;
+    case lv_decrement:
+      error ("invalid lvalue in decrement");
+      break;
+    case lv_addressof:
+      error ("invalid lvalue in unary %<&%>");
+      break;
+    case lv_asm:
+      error ("invalid lvalue in asm statement");
+      break;
+    default:
+      gcc_unreachable ();
     }
-
-  return win;
 }
 
 #include "gt-c-common.h"

diff --git a/gcc/c-common.h b/gcc/c-common.h
index 91be602066b40d292ba6bd00495391e623390e84..64daf34b44094d0d06bb295caa50fdca2c7a7748 100644 (file)
--- a/gcc/c-common.h
+++ b/gcc/c-common.h
@@ -808,7 +808,6 @@ extern tree build_break_stmt (void);
 
 extern tree build_unary_op (enum tree_code, tree, int);
 extern tree build_binary_op (enum tree_code, tree, tree, int);
-extern int lvalue_p (tree);
 extern tree default_conversion (tree);
 
 /* Given two integer or real types, return the type for their sum.
@@ -877,7 +876,7 @@ extern void verify_sequence_points (tree);
 extern tree fold_offsetof (tree);
 
 /* Places where an lvalue, or modifiable lvalue, may be required.
-   Used to select diagnostic messages in lvalue_or_else and
+   Used to select diagnostic messages in lvalue_error and
    readonly_error.  */
 enum lvalue_use {
   lv_assign,
@@ -887,7 +886,7 @@ enum lvalue_use {
   lv_asm
 };
 
-extern int lvalue_or_else (tree, enum lvalue_use);
+extern void lvalue_error (enum lvalue_use);
 
 /* In c-gimplify.c  */
 extern void c_genericize (tree);

diff --git a/gcc/c-typeck.c b/gcc/c-typeck.c
index 0595b88b877f11396039617d217cb66ba63a7700..d5046d5f425ea133a4bc6645faf51821843f5784 100644 (file)
--- a/gcc/c-typeck.c
+++ b/gcc/c-typeck.c
@@ -100,6 +100,8 @@ static void set_nonincremental_init (void);
 static void set_nonincremental_init_from_string (tree);
 static tree find_init_member (tree);
 static void readonly_error (tree, enum lvalue_use);
+static int lvalue_or_else (tree, enum lvalue_use);
+static int lvalue_p (tree);
 static void record_maybe_used_decl (tree);
 \f
 /* Do `exp = require_complete_type (exp);' to make sure exp
@@ -2742,7 +2744,7 @@ build_unary_op (enum tree_code code, tree xarg, int flag)
    Lvalues can be assigned, unless their type has TYPE_READONLY.
    Lvalues can have their address taken, unless they have C_DECL_REGISTER.  */
 
-int
+static int
 lvalue_p (tree ref)
 {
   enum tree_code code = TREE_CODE (ref);
@@ -2807,6 +2809,22 @@ readonly_error (tree arg, enum lvalue_use use)
                         N_("increment of read-only location"),
                         N_("decrement of read-only location")));
 }
+
+
+/* Return nonzero if REF is an lvalue valid for this language;
+   otherwise, print an error message and return zero.  USE says
+   how the lvalue is being used and so selects the error message.  */
+
+static int
+lvalue_or_else (tree ref, enum lvalue_use use)
+{
+  int win = lvalue_p (ref);
+
+  if (!win)
+    lvalue_error (use);
+
+  return win;
+}
 \f
 /* Mark EXP saying that we need to be able to take the
    address of it; it should not be allocated in a register.

diff --git a/gcc/cp/ChangeLog b/gcc/cp/ChangeLog
index f43fe55e2755ae61d98e59866c159a6ce5494881..76c1305bea69e53262c822ce5f20dd3f346eafda 100644 (file)
--- a/gcc/cp/ChangeLog
+++ b/gcc/cp/ChangeLog
@@ -1,3 +1,8 @@
+2005-03-21  Joseph S. Myers  <joseph@codesourcery.com>
+
+       * cp-tree.h (lvalue_or_else, lvalue_p): New.
+       * typeck.c (lvalue_or_else): New.  Call lvalue_error.
+
 2005-03-19  Kriang Lerdsuwanakij  <lerdsuwa@users.sourceforge.net>
 
        PR c++/20240

diff --git a/gcc/cp/cp-tree.h b/gcc/cp/cp-tree.h
index 466d4dd8e8c21dadf32e63549db1994d3240bb6d..e76e216a065742f31fe9de951cba8ec1d7712798 100644 (file)
--- a/gcc/cp/cp-tree.h
+++ b/gcc/cp/cp-tree.h
@@ -4332,6 +4332,8 @@ extern tree lookup_anon_field                   (tree, tree);
 extern bool invalid_nonstatic_memfn_p           (tree);
 extern tree convert_member_func_to_ptr          (tree, tree);
 extern tree convert_ptrmem                      (tree, tree, bool, bool);
+extern int lvalue_or_else                       (tree, enum lvalue_use);
+extern int lvalue_p                             (tree);
 
 /* in typeck2.c */
 extern void require_complete_eh_spec_types     (tree, tree);

diff --git a/gcc/cp/typeck.c b/gcc/cp/typeck.c
index 1639b54532ba3415c4dcb32899bd3fa318e0113c..c2adb1c7fd469856d37702088f060698d92d060a 100644 (file)
--- a/gcc/cp/typeck.c
+++ b/gcc/cp/typeck.c
@@ -6513,3 +6513,19 @@ non_reference (tree t)
     t = TREE_TYPE (t);
   return t;
 }
+
+
+/* Return nonzero if REF is an lvalue valid for this language;
+   otherwise, print an error message and return zero.  USE says
+   how the lvalue is being used and so selects the error message.  */
+
+int
+lvalue_or_else (tree ref, enum lvalue_use use)
+{
+  int win = lvalue_p (ref);
+
+  if (!win)
+    lvalue_error (use);
+
+  return win;
+}