Make the reader accept bignums

* src/data.c (Fstring_to_number): Update.
* src/lisp.h (S2N_OVERFLOW_TO_FLOAT): Remove.
* src/lread.c (free_contents): New function.
(read_integer): Handle bignums.
(read1): Update.
(string_to_number): Handle bignums.
(syms_of_lread): Remove read-integer-overflow-as-float.
* src/process.c (Fsignal_process): Update.

diff --git a/src/data.c b/src/data.c
index efcffbbf6abaa40cf4de32f8775f562465c25d45..8ffed8bbb52d9f9705565f6356e80e79b33a180c 100644 (file)
--- a/src/data.c
+++ b/src/data.c
@@ -2727,8 +2727,7 @@ If the base used is not 10, STRING is always parsed as an integer.  */)
   while (*p == ' ' || *p == '\t')
     p++;
 
-  int flags = S2N_IGNORE_TRAILING | S2N_OVERFLOW_TO_FLOAT;
-  Lisp_Object val = string_to_number (p, b, flags);
+  Lisp_Object val = string_to_number (p, b, S2N_IGNORE_TRAILING);
   return NILP (val) ? make_fixnum (0) : val;
 }
 \f

diff --git a/src/lisp.h b/src/lisp.h
index 6a3db24949a9f60c7dc6f9607f8321060c0f22a9..be6793204942558f8858742269b4f5d46729bc91 100644 (file)
--- a/src/lisp.h
+++ b/src/lisp.h
@@ -3858,7 +3858,7 @@ LOADHIST_ATTACH (Lisp_Object x)
 }
 extern int openp (Lisp_Object, Lisp_Object, Lisp_Object,
                   Lisp_Object *, Lisp_Object, bool);
-enum { S2N_IGNORE_TRAILING = 1, S2N_OVERFLOW_TO_FLOAT = 2 };
+enum { S2N_IGNORE_TRAILING = 1 };
 extern Lisp_Object string_to_number (char const *, int, int);
 extern void map_obarray (Lisp_Object, void (*) (Lisp_Object, Lisp_Object),
                          Lisp_Object);

diff --git a/src/lread.c b/src/lread.c
index 49fa51d1a80b544882789efd3521bcec1ae63bd8..ff86c96c9b505da447f3de5b7fe06aec3d9f96d1 100644 (file)
--- a/src/lread.c
+++ b/src/lread.c
@@ -2631,6 +2631,13 @@ digit_to_number (int character, int base)
   return digit < base ? digit : -1;
 }
 
+static void
+free_contents (void *p)
+{
+  void **ptr = (void **) p;
+  xfree (*ptr);
+}
+
 /* Read an integer in radix RADIX using READCHARFUN to read
    characters.  RADIX must be in the interval [2..36]; if it isn't, a
    read error is signaled .  Value is the integer read.  Signals an
@@ -2642,17 +2649,24 @@ read_integer (Lisp_Object readcharfun, EMACS_INT radix)
 {
   /* Room for sign, leading 0, other digits, trailing null byte.
      Also, room for invalid syntax diagnostic.  */
-  char buf[max (1 + 1 + UINTMAX_WIDTH + 1,
-               sizeof "integer, radix " + INT_STRLEN_BOUND (EMACS_INT))];
+  size_t len = max (1 + 1 + UINTMAX_WIDTH + 1,
+                   sizeof "integer, radix " + INT_STRLEN_BOUND (EMACS_INT));
+  char *buf = NULL;
   char *p = buf;
   int valid = -1; /* 1 if valid, 0 if not, -1 if incomplete.  */
 
+  ptrdiff_t count = SPECPDL_INDEX ();
+
   if (radix < 2 || radix > 36)
     valid = 0;
   else
     {
       int c, digit;
 
+      buf = xmalloc (len);
+      record_unwind_protect_ptr (free_contents, &buf);
+      p = buf;
+
       c = READCHAR;
       if (c == '-' || c == '+')
        {
@@ -2678,8 +2692,15 @@ read_integer (Lisp_Object readcharfun, EMACS_INT radix)
            valid = 0;
          if (valid < 0)
            valid = 1;
-         if (p < buf + sizeof buf)
-           *p++ = c;
+         /* Allow 1 extra byte for the \0.  */
+         if (p + 1 == buf + len)
+           {
+             ptrdiff_t where = p - buf;
+             len *= 2;
+             buf = xrealloc (buf, len);
+             p = buf + where;
+           }
+         *p++ = c;
          c = READCHAR;
        }
 
@@ -2692,14 +2713,8 @@ read_integer (Lisp_Object readcharfun, EMACS_INT radix)
       invalid_syntax (buf);
     }
 
-  if (p == buf + sizeof buf)
-    {
-      memset (p - 3, '.', 3);
-      xsignal1 (Qoverflow_error, make_unibyte_string (buf, sizeof buf));
-    }
-
   *p = '\0';
-  return string_to_number (buf, radix, 0);
+  return unbind_to (count, string_to_number (buf, radix, 0));
 }
 
 
@@ -3508,9 +3523,7 @@ read1 (Lisp_Object readcharfun, int *pch, bool first_in_list)
 
        if (!quoted && !uninterned_symbol)
          {
-           int flags = (read_integer_overflow_as_float
-                        ? S2N_OVERFLOW_TO_FLOAT : 0);
-           Lisp_Object result = string_to_number (read_buffer, 10, flags);
+           Lisp_Object result = string_to_number (read_buffer, 10, 0);
            if (! NILP (result))
              return unbind_to (count, result);
          }
@@ -3677,12 +3690,10 @@ substitute_in_interval (INTERVAL interval, void *arg)
 \f
 /* Convert STRING to a number, assuming base BASE.  When STRING has
    floating point syntax and BASE is 10, return a nearest float.  When
-   STRING has integer syntax, return a fixnum if the integer fits, and
-   signal an overflow otherwise (unless BASE is 10 and STRING ends in
-   period or FLAGS & S2N_OVERFLOW_TO_FLOAT is nonzero; in this case,
-   return a nearest float instead).  Otherwise, return nil.  If FLAGS
-   & S2N_IGNORE_TRAILING is nonzero, consider just the longest prefix
-   of STRING that has valid syntax.  */
+   STRING has integer syntax, return a fixnum if the integer fits, or
+   else a bignum.  Otherwise, return nil.  If FLAGS &
+   S2N_IGNORE_TRAILING is nonzero, consider just the longest prefix of
+   STRING that has valid syntax.  */
 
 Lisp_Object
 string_to_number (char const *string, int base, int flags)
@@ -3796,13 +3807,7 @@ string_to_number (char const *string, int base, int flags)
       else
        value = n;
 
-      if (! (state & DOT_CHAR) && ! (flags & S2N_OVERFLOW_TO_FLOAT))
-       {
-         AUTO_STRING (fmt, ("%s is out of fixnum range; "
-                            "maybe set `read-integer-overflow-as-float'?"));
-         AUTO_STRING_WITH_LEN (arg, string, cp - string);
-         xsignal1 (Qoverflow_error, CALLN (Fformat_message, fmt, arg));
-       }
+      return make_bignum_str (string, base);
     }
 
   /* Either the number uses float syntax, or it does not fit into a fixnum.
@@ -4845,13 +4850,6 @@ were read in.  */);
               doc: /* Non-nil means read recursive structures using #N= and #N# syntax.  */);
   Vread_circle = Qt;
 
-  DEFVAR_BOOL ("read-integer-overflow-as-float",
-              read_integer_overflow_as_float,
-              doc: /* Non-nil means `read' quietly treats an out-of-range integer as floating point.
-Nil (the default) means signal an overflow unless the integer ends in `.'.
-This variable is experimental; email 30408@debbugs.gnu.org if you need it.  */);
-  read_integer_overflow_as_float = false;
-
   DEFVAR_LISP ("load-path", Vload_path,
               doc: /* List of directories to search for files to load.
 Each element is a string (directory file name) or nil (meaning

diff --git a/src/process.c b/src/process.c
index 10af79a015556cc234b19b24ed8b13a83f4921d4..350cfe0f80bc5ab4ef82c92fd62ce264871d9f3c 100644 (file)
--- a/src/process.c
+++ b/src/process.c
@@ -6842,7 +6842,7 @@ SIGCODE may be an integer, or a symbol whose name is a signal name.  */)
     {
       Lisp_Object tem = Fget_process (process);
       if (NILP (tem))
-       tem = string_to_number (SSDATA (process), 10, S2N_OVERFLOW_TO_FLOAT);
+       tem = string_to_number (SSDATA (process), 10, 0);
       process = tem;
     }
   else if (!FIXED_OR_FLOATP (process))