Fix mishandling of symbols that look like numbers

* src/bignum.c (make_neg_biguint): New function.
* src/lread.c (read1): Do not mishandle an unquoted symbol
with name equal to something like "1\0x", i.e., a string
of numeric form followed by a NUL byte.
Formerly these symbols were misread as numbers.
(string_to_number): Change last argument from an integer flag
to a pointer to the length.  This lets the caller figure out
how much of the prefix was used.  All callers changed.
Add a fast path if the integer (sans sign) fits in uintmax_t.
Update comments and simplify now that bignums are present.
* src/print.c (print_object): Fix quoting of symbols that look
like numbers, by relying on string_to_number for the tricky
cases rather than trying to redo its logic, incorrectly.  For
example, (read (prin1-to-string '\1e+NaN)) formerly returned
"1e+NaN", which was wrong: a backslash is needed in the output
to prevent it from being read as a NaN.  Escape NO_BREAK_SPACE
too, since lread.c treats it like SPACE.
* test/src/print-tests.el (print-read-roundtrip):
Add tests illustrating the abovementioned bugs.

1 files changed, 15 insertions, 34 deletions

diff --git a/src/print.c b/src/print.c
index c0c90bc7e9a..d15ff97b00c 100644
--- a/src/print.c
+++ b/src/print.c
@@ -1993,39 +1993,17 @@ print_object (Lisp_Object obj, Lisp_Object printcharfun, bool escapeflag)
 
     case Lisp_Symbol:
       {
-        bool confusing;
-        unsigned char *p = SDATA (SYMBOL_NAME (obj));
-        unsigned char *end = p + SBYTES (SYMBOL_NAME (obj));
-        int c;
-        ptrdiff_t i, i_byte;
-        ptrdiff_t size_byte;
-        Lisp_Object name;
-
-        name = SYMBOL_NAME (obj);
-
-        if (p != end && (*p == '-' || *p == '+')) p++;
-        if (p == end)
-          confusing = 0;
-        /* If symbol name begins with a digit, and ends with a digit,
-           and contains nothing but digits and `e', it could be treated
-           as a number.  So set CONFUSING.
-
-           Symbols that contain periods could also be taken as numbers,
-           but periods are always escaped, so we don't have to worry
-           about them here.  */
-        else if (*p >= '0' && *p <= '9'
-                 && end[-1] >= '0' && end[-1] <= '9')
-          {
-            while (p != end && ((*p >= '0' && *p <= '9')
-                                /* Needed for \2e10.  */
-                                || *p == 'e' || *p == 'E'))
-              p++;
-            confusing = (end == p);
-          }
-        else
-          confusing = 0;
-
-        size_byte = SBYTES (name);
+        Lisp_Object name = SYMBOL_NAME (obj);
+        ptrdiff_t size_byte = SBYTES (name);
+
+        /* Set CONFUSING if NAME looks like a number, calling
+           string_to_number for non-obvious cases.  */
+        char *p = SSDATA (name);
+        bool signedp = *p == '-' || *p == '+';
+        ptrdiff_t len;
+        bool confusing = ((c_isdigit (p[signedp]) || p[signedp] == '.')
+                          && !NILP (string_to_number (p, 10, &len))
+                          && len == size_byte);
 
         if (! NILP (Vprint_gensym)
             && !SYMBOL_INTERNED_IN_INITIAL_OBARRAY_P (obj))
@@ -2036,10 +2014,12 @@ print_object (Lisp_Object obj, Lisp_Object printcharfun, bool escapeflag)
             break;
           }
 
-        for (i = 0, i_byte = 0; i_byte < size_byte;)
+        ptrdiff_t i = 0;
+        for (ptrdiff_t i_byte = 0; i_byte < size_byte; )
           {
             /* Here, we must convert each multi-byte form to the
                corresponding character code before handing it to PRINTCHAR.  */
+            int c;
             FETCH_STRING_CHAR_ADVANCE (c, name, i, i_byte);
             maybe_quit ();
 
@@ -2049,6 +2029,7 @@ print_object (Lisp_Object obj, Lisp_Object printcharfun, bool escapeflag)
                     || c == ';' || c == '#' || c == '(' || c == ')'
                     || c == ',' || c == '.' || c == '`'
                     || c == '[' || c == ']' || c == '?' || c <= 040
+                    || c == NO_BREAK_SPACE
                     || confusing
                     || (i == 1 && confusable_symbol_character_p (c)))
                   {