Omit needless "\ " after multibyte then newline

* src/print.c: Include <c-ctype.h>, for c_isxdigit.
(print_object): When print-escape-multibyte is non-nil and a
multibyte character is followed by a newline or formfeed, followed
by a hex digit, don't output a needless "\ " before the hex digit.
* test/automated/print-tests.el (print-hex-backslash): New test.

diff --git a/src/lread.c b/src/lread.c
index fa9a63e63a9fc279c9180848b03025c330b75ea2..a84450a4364c1b0afbd63fa1c7e0526fb018ddbd 100644 (file)
--- a/src/lread.c
+++ b/src/lread.c
@@ -3024,7 +3024,7 @@ read1 (Lisp_Object readcharfun, int *pch, bool first_in_list)
 
                ch = read_escape (readcharfun, 1);
 
-               /* CH is -1 if \ newline has just been seen.  */
+               /* CH is -1 if \ newline or \ space has just been seen.  */
                if (ch == -1)
                  {
                    if (p == read_buffer)

diff --git a/src/print.c b/src/print.c
index 916276bc961426b454a932c729845e81870e956c..bff5932c1d1c3fac54265784a0b4cd6c22be7771 100644 (file)
--- a/src/print.c
+++ b/src/print.c
@@ -37,6 +37,7 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 #include "termhooks.h"         /* For struct terminal.  */
 #include "font.h"
 
+#include <c-ctype.h>
 #include <float.h>
 #include <ftoastr.h>
 
@@ -1385,9 +1386,9 @@ print_object (Lisp_Object obj, Lisp_Object printcharfun, bool escapeflag)
          register ptrdiff_t i, i_byte;
          struct gcpro gcpro1;
          ptrdiff_t size_byte;
-         /* 1 means we must ensure that the next character we output
+         /* True means we must ensure that the next character we output
             cannot be taken as part of a hex character escape.  */
-         bool need_nonhex = 0;
+         bool need_nonhex = false;
          bool multibyte = STRING_MULTIBYTE (obj);
 
          GCPRO1 (obj);
@@ -1411,60 +1412,46 @@ print_object (Lisp_Object obj, Lisp_Object printcharfun, bool escapeflag)
 
              QUIT;
 
-             if (c == '\n' && print_escape_newlines)
-               print_c_string ("\\n", printcharfun);
-             else if (c == '\f' && print_escape_newlines)
-               print_c_string ("\\f", printcharfun);
-             else if (multibyte
-                      && (CHAR_BYTE8_P (c)
-                          || (! ASCII_CHAR_P (c) && print_escape_multibyte)))
-               {
-                 /* When multibyte is disabled,
-                    print multibyte string chars using hex escapes.
-                    For a char code that could be in a unibyte string,
-                    when found in a multibyte string, always use a hex escape
-                    so it reads back as multibyte.  */
-                 char outbuf[50];
-                 int len;
-
-                 if (CHAR_BYTE8_P (c))
-                   len = sprintf (outbuf, "\\%03o", CHAR_TO_BYTE8 (c));
-                 else
-                   {
-                     len = sprintf (outbuf, "\\x%04x", c);
-                     need_nonhex = 1;
-                   }
-                 strout (outbuf, len, len, printcharfun);
-               }
-             else if (! multibyte
-                      && SINGLE_BYTE_CHAR_P (c) && ! ASCII_CHAR_P (c)
-                      && print_escape_nonascii)
+             if (multibyte
+                 ? (CHAR_BYTE8_P (c) && (c = CHAR_TO_BYTE8 (c), true))
+                 : (SINGLE_BYTE_CHAR_P (c) && ! ASCII_CHAR_P (c)
+                    && print_escape_nonascii))
                {
-                 /* When printing in a multibyte buffer
-                    or when explicitly requested,
+                 /* When printing a raw 8-bit byte in a multibyte buffer, or
+                    (when requested) a non-ASCII character in a unibyte buffer,
                     print single-byte non-ASCII string chars
                     using octal escapes.  */
                  char outbuf[5];
                  int len = sprintf (outbuf, "\\%03o", c);
                  strout (outbuf, len, len, printcharfun);
+                 need_nonhex = false;
+               }
+             else if (multibyte
+                      && ! ASCII_CHAR_P (c) && print_escape_multibyte)
+               {
+                 /* When requested, print multibyte chars using hex escapes.  */
+                 char outbuf[sizeof "\\x" + INT_STRLEN_BOUND (c)];
+                 int len = sprintf (outbuf, "\\x%04x", c);
+                 strout (outbuf, len, len, printcharfun);
+                 need_nonhex = true;
                }
              else
                {
                  /* If we just had a hex escape, and this character
                     could be taken as part of it,
                     output `\ ' to prevent that.  */
-                 if (need_nonhex)
-                   {
-                     need_nonhex = 0;
-                     if ((c >= 'a' && c <= 'f')
-                         || (c >= 'A' && c <= 'F')
-                         || (c >= '0' && c <= '9'))
-                       print_c_string ("\\ ", printcharfun);
-                   }
-
-                 if (c == '\"' || c == '\\')
+                 if (need_nonhex && c_isxdigit (c))
+                   print_c_string ("\\ ", printcharfun);
+
+                 if (c == '\n' && print_escape_newlines
+                     ? (c = 'n', true)
+                     : c == '\f' && print_escape_newlines
+                     ? (c = 'f', true)
+                     : c == '\"' || c == '\\')
                    printchar ('\\', printcharfun);
+
                  printchar (c, printcharfun);
+                 need_nonhex = false;
                }
            }
          printchar ('\"', printcharfun);

diff --git a/test/automated/print-tests.el b/test/automated/print-tests.el
index 2761109d2d5aa8f9bf61b6d4f4b286ff471bbf4e..fe8c56553a8250e79d844c06f0f656ccf20e3411 100644 (file)
--- a/test/automated/print-tests.el
+++ b/test/automated/print-tests.el
@@ -21,6 +21,12 @@
 
 (require 'ert)
 
+(ert-deftest print-hex-backslash ()
+  (should (string= (let ((print-escape-multibyte t)
+                         (print-escape-newlines t))
+                     (prin1-to-string "\u00A2\ff"))
+                   "\"\\x00a2\\ff\"")))
+
 (ert-deftest terpri ()
   (should (string= (with-output-to-string
                      (princ 'abc)