CRLF -> CR correction

From-SVN: r85246

diff --git a/gcc/cp/call.c b/gcc/cp/call.c
index 313460b69845ac6d21b3575a11a7649a6edd85d0..727698a0d10604fb74d2fa4e657a7b23b996309a 100644 (file)
--- a/gcc/cp/call.c
+++ b/gcc/cp/call.c
@@ -4328,20 +4328,20 @@ convert_arg_to_ellipsis (arg)
 
   arg = require_complete_type (arg);
   
-  if (arg != error_mark_node\r
-      && !pod_type_p (TREE_TYPE (arg)))\r
-    {\r
-      /* Undefined behavior [expr.call] 5.2.2/7.  We used to just warn\r
-        here and do a bitwise copy, but now cp_expr_size will abort if we\r
-        try to do that.\r
-        If the call appears in the context of a sizeof expression,\r
-        there is no need to emit a warning, since the expression won't be\r
-        evaluated. We keep the builtin_trap just as a safety check.  */\r
-      if (!skip_evaluation)\r
-       warning ("cannot pass objects of non-POD type `%#T' through `...'; "\r
-                "call will abort at runtime", TREE_TYPE (arg));\r
-      arg = call_builtin_trap ();\r
-    }\r
+  if (arg != error_mark_node
+      && !pod_type_p (TREE_TYPE (arg)))
+    {
+      /* Undefined behavior [expr.call] 5.2.2/7.  We used to just warn
+        here and do a bitwise copy, but now cp_expr_size will abort if we
+        try to do that.
+        If the call appears in the context of a sizeof expression,
+        there is no need to emit a warning, since the expression won't be
+        evaluated. We keep the builtin_trap just as a safety check.  */
+      if (!skip_evaluation)
+       warning ("cannot pass objects of non-POD type `%#T' through `...'; "
+                "call will abort at runtime", TREE_TYPE (arg));
+      arg = call_builtin_trap ();
+    }
 
   return arg;
 }

diff --git a/gcc/cp/decl.c b/gcc/cp/decl.c
index 7cdf893527112a38920e0255fc5387f9889622da..dfdeb1e51712f4facfaa0ab70e02e689c3d78937 100644 (file)
--- a/gcc/cp/decl.c
+++ b/gcc/cp/decl.c
@@ -4940,10 +4940,10 @@ push_overloaded_decl (decl, flags)
     }
 
   if (old || TREE_CODE (decl) == TEMPLATE_DECL
-      /* If it's a using declaration, we always need to build an OVERLOAD,\r
-        because it's the only way to remember that the declaration comes\r
-        from 'using', and have the lookup behave correctly.  */\r
-      || (flags & PUSH_USING))\r
+      /* If it's a using declaration, we always need to build an OVERLOAD,
+        because it's the only way to remember that the declaration comes
+        from 'using', and have the lookup behave correctly.  */
+      || (flags & PUSH_USING))
     {
       if (old && TREE_CODE (old) != OVERLOAD)
        new_binding = ovl_cons (decl, ovl_cons (old, NULL_TREE));

diff --git a/gcc/cp/init.c b/gcc/cp/init.c
index 5a408030d7d96b38bebf0bb684eed5c7f26c12d3..f2959b6c808b4a720c0e99495a9283064b01e6fa 100644 (file)
--- a/gcc/cp/init.c
+++ b/gcc/cp/init.c
@@ -3123,8 +3123,8 @@ build_delete (type, addr, auto_delete, flags, use_global_delete)
              warning ("possible problem detected in invocation of "
                       "delete operator:");
              cxx_incomplete_type_diagnostic (addr, type, 1);
-             inform ("neither the destructor nor the class-specific "\r
-                     "operator delete will be called, even if they are "\r
+             inform ("neither the destructor nor the class-specific "
+                     "operator delete will be called, even if they are "
                      "declared when the class is defined.");
              complete_p = false;
            }