* typeck2.c (readonly_error): Always emit a hard error.

	Remove last argument.
	* cp-tree.h (readonly_error): Adjust prototype.
	* semantics.c (finish_asm_stmt): Adjust call to readonly_error.
	* typeck.c (build_unary_op): Likewise.
	(build_modify_expr): Likewise.

git-svn-id: svn+ssh://gcc.gnu.org/svn/gcc/trunk@122541 138bc75d-0d04-0410-961f-82ee72b054a4

diff --git a/gcc/cp/ChangeLog b/gcc/cp/ChangeLog
index 8f6d6de..2db8d9c 100644 (file)
--- a/gcc/cp/ChangeLog
+++ b/gcc/cp/ChangeLog
@@ -1,3 +1,12 @@
+2007-03-05  Volker Reichelt  <reichelt@netcologne.de>
+
+       * typeck2.c (readonly_error): Always emit a hard error.
+       Remove last argument.
+       * cp-tree.h (readonly_error): Adjust prototype.
+       * semantics.c (finish_asm_stmt): Adjust call to readonly_error.
+       * typeck.c (build_unary_op): Likewise.
+       (build_modify_expr): Likewise.
+
 2007-03-04  Simon Martin  <simartin@users.sourceforge.net>
 
        PR c++/30895

diff --git a/gcc/cp/cp-tree.h b/gcc/cp/cp-tree.h
index 6c4d7ee..95e278c 100644 (file)
--- a/gcc/cp/cp-tree.h
+++ b/gcc/cp/cp-tree.h
@@ -4602,7 +4602,7 @@ extern void cxx_incomplete_type_error             (tree, tree);
   (cxx_incomplete_type_diagnostic ((V), (T), 0))
 extern tree error_not_base_type                        (tree, tree);
 extern tree binfo_or_else                      (tree, tree);
-extern void readonly_error                     (tree, const char *, int);
+extern void readonly_error                     (tree, const char *);
 extern void complete_type_check_abstract       (tree);
 extern int abstract_virtuals_error             (tree, tree);
 

diff --git a/gcc/cp/semantics.c b/gcc/cp/semantics.c
index 6ffc965..c21fd2c 100644 (file)
--- a/gcc/cp/semantics.c
+++ b/gcc/cp/semantics.c
@@ -1246,7 +1246,7 @@ finish_asm_stmt (int volatile_p, tree string, tree output_operands,
                     effectively const.  */
                  || (CLASS_TYPE_P (TREE_TYPE (operand))
                      && C_TYPE_FIELDS_READONLY (TREE_TYPE (operand)))))
-           readonly_error (operand, "assignment (via 'asm' output)", 0);
+           readonly_error (operand, "assignment (via 'asm' output)");
 
          constraint = TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (t)));
          oconstraints[i] = constraint;

diff --git a/gcc/cp/typeck.c b/gcc/cp/typeck.c
index 81fe195..404117c 100644 (file)
--- a/gcc/cp/typeck.c
+++ b/gcc/cp/typeck.c
@@ -4205,8 +4205,7 @@ build_unary_op (enum tree_code code, tree xarg, int noconvert)
          || TREE_READONLY (arg))
        readonly_error (arg, ((code == PREINCREMENT_EXPR
                               || code == POSTINCREMENT_EXPR)
-                             ? "increment" : "decrement"),
-                       0);
+                             ? "increment" : "decrement"));
 
       {
        tree inc;
@@ -5780,7 +5779,7 @@ build_modify_expr (tree lhs, enum tree_code modifycode, tree rhs)
             effectively const.  */
          || (CLASS_TYPE_P (lhstype)
              && C_TYPE_FIELDS_READONLY (lhstype))))
-    readonly_error (lhs, "assignment", 0);
+    readonly_error (lhs, "assignment");
 
   /* If storing into a structure or union member, it has probably been
      given type `int'.  Compute the type that would go with the actual

diff --git a/gcc/cp/typeck2.c b/gcc/cp/typeck2.c
index e31d87b..5f6cf0d 100644 (file)
--- a/gcc/cp/typeck2.c
+++ b/gcc/cp/typeck2.c
@@ -68,20 +68,12 @@ binfo_or_else (tree base, tree type)
 }
 
 /* According to ARM $7.1.6, "A `const' object may be initialized, but its
-   value may not be changed thereafter.  Thus, we emit hard errors for these,
-   rather than just pedwarns.  If `SOFT' is 1, then we just pedwarn.  (For
-   example, conversions to references.)  */
+   value may not be changed thereafter.  */
 
 void
-readonly_error (tree arg, const char* string, int soft)
+readonly_error (tree arg, const char* string)
 {
   const char *fmt;
-  void (*fn) (const char *, ...) ATTRIBUTE_GCC_CXXDIAG(1,2);
-
-  if (soft)
-    fn = pedwarn;
-  else
-    fn = error;
 
   if (TREE_CODE (arg) == COMPONENT_REF)
     {
@@ -89,7 +81,7 @@ readonly_error (tree arg, const char* string, int soft)
        fmt = "%s of data-member %qD in read-only structure";
       else
        fmt = "%s of read-only data-member %qD";
-      (*fn) (fmt, string, TREE_OPERAND (arg, 1));
+      error (fmt, string, TREE_OPERAND (arg, 1));
     }
   else if (TREE_CODE (arg) == VAR_DECL)
     {
@@ -99,21 +91,21 @@ readonly_error (tree arg, const char* string, int soft)
        fmt = "%s of constant field %qD";
       else
        fmt = "%s of read-only variable %qD";
-      (*fn) (fmt, string, arg);
+      error (fmt, string, arg);
     }
   else if (TREE_CODE (arg) == PARM_DECL)
-    (*fn) ("%s of read-only parameter %qD", string, arg);
+    error ("%s of read-only parameter %qD", string, arg);
   else if (TREE_CODE (arg) == INDIRECT_REF
           && TREE_CODE (TREE_TYPE (TREE_OPERAND (arg, 0))) == REFERENCE_TYPE
           && (TREE_CODE (TREE_OPERAND (arg, 0)) == VAR_DECL
               || TREE_CODE (TREE_OPERAND (arg, 0)) == PARM_DECL))
-    (*fn) ("%s of read-only reference %qD", string, TREE_OPERAND (arg, 0));
+    error ("%s of read-only reference %qD", string, TREE_OPERAND (arg, 0));
   else if (TREE_CODE (arg) == RESULT_DECL)
-    (*fn) ("%s of read-only named return value %qD", string, arg);
+    error ("%s of read-only named return value %qD", string, arg);
   else if (TREE_CODE (arg) == FUNCTION_DECL)
-    (*fn) ("%s of function %qD", string, arg);
+    error ("%s of function %qD", string, arg);
   else
-    (*fn) ("%s of read-only location", string);
+    error ("%s of read-only location", string);
 }
 
 \f