Merge branch 'feature/bignum'

1 files changed, 41 insertions, 35 deletions

diff --git a/src/bytecode.c b/src/bytecode.c
index 772cc982f9a..b27fa7c5c68 100644
--- a/src/bytecode.c
+++ b/src/bytecode.c
@@ -63,14 +63,14 @@ along with GNU Emacs.  If not, see <https://www.gnu.org/licenses/>.  */
 {                                                                       \
   if (byte_metering_on)                                                 \
     {                                                                   \
-      if (XFASTINT (METER_1 (this_code)) < MOST_POSITIVE_FIXNUM)        \
+      if (XFIXNAT (METER_1 (this_code)) < MOST_POSITIVE_FIXNUM) \
         XSETFASTINT (METER_1 (this_code),                               \
-                     XFASTINT (METER_1 (this_code)) + 1);               \
+                     XFIXNAT (METER_1 (this_code)) + 1);                \
       if (last_code                                                     \
-          && (XFASTINT (METER_2 (last_code, this_code))                 \
+          && (XFIXNAT (METER_2 (last_code, this_code))                  \
               < MOST_POSITIVE_FIXNUM))                                  \
         XSETFASTINT (METER_2 (last_code, this_code),                    \
-                     XFASTINT (METER_2 (last_code, this_code)) + 1);    \
+                     XFIXNAT (METER_2 (last_code, this_code)) + 1);     \
     }                                                                   \
 }
 
@@ -346,7 +346,7 @@ exec_byte_code (Lisp_Object bytestr, Lisp_Object vector, Lisp_Object maxdepth,
 
   CHECK_STRING (bytestr);
   CHECK_VECTOR (vector);
-  CHECK_NATNUM (maxdepth);
+  CHECK_FIXNAT (maxdepth);
 
   ptrdiff_t const_length = ASIZE (vector);
 
@@ -362,7 +362,7 @@ exec_byte_code (Lisp_Object bytestr, Lisp_Object vector, Lisp_Object maxdepth,
   Lisp_Object *vectorp = XVECTOR (vector)->contents;
 
   unsigned char quitcounter = 1;
-  EMACS_INT stack_items = XFASTINT (maxdepth) + 1;
+  EMACS_INT stack_items = XFIXNAT (maxdepth) + 1;
   USE_SAFE_ALLOCA;
   void *alloc;
   SAFE_ALLOCA_LISP_EXTRA (alloc, stack_items, bytestr_length);
@@ -378,16 +378,16 @@ exec_byte_code (Lisp_Object bytestr, Lisp_Object vector, Lisp_Object maxdepth,
 
   if (!NILP (args_template))
     {
-      eassert (INTEGERP (args_template));
-      ptrdiff_t at = XINT (args_template);
+      eassert (FIXNUMP (args_template));
+      ptrdiff_t at = XFIXNUM (args_template);
       bool rest = (at & 128) != 0;
       int mandatory = at & 127;
       ptrdiff_t nonrest = at >> 8;
       ptrdiff_t maxargs = rest ? PTRDIFF_MAX : nonrest;
       if (! (mandatory <= nargs && nargs <= maxargs))
         Fsignal (Qwrong_number_of_arguments,
-                 list2 (Fcons (make_number (mandatory), make_number (nonrest)),
-                        make_number (nargs)));
+                 list2 (Fcons (make_fixnum (mandatory), make_fixnum (nonrest)),
+                        make_fixnum (nargs)));
       ptrdiff_t pushedargs = min (nonrest, nargs);
       for (ptrdiff_t i = 0; i < pushedargs; i++, args++)
         PUSH (*args);
@@ -621,10 +621,10 @@ exec_byte_code (Lisp_Object bytestr, Lisp_Object vector, Lisp_Object maxdepth,
               {
                 Lisp_Object v1 = TOP;
                 Lisp_Object v2 = Fget (v1, Qbyte_code_meter);
-                if (INTEGERP (v2)
-                    && XINT (v2) < MOST_POSITIVE_FIXNUM)
+                if (FIXNUMP (v2)
+                    && XFIXNUM (v2) < MOST_POSITIVE_FIXNUM)
                   {
-                    XSETINT (v2, XINT (v2) + 1);
+                    XSETINT (v2, XFIXNUM (v2) + 1);
                     Fput (v1, Qbyte_code_meter, v2);
                   }
               }
@@ -832,8 +832,8 @@ exec_byte_code (Lisp_Object bytestr, Lisp_Object vector, Lisp_Object maxdepth,
         CASE (Bnth):
           {
             Lisp_Object v2 = POP, v1 = TOP;
-            CHECK_NUMBER (v1);
-            for (EMACS_INT n = XINT (v1); 0 < n && CONSP (v2); n--)
+            CHECK_FIXNUM (v1);
+            for (EMACS_INT n = XFIXNUM (v1); 0 < n && CONSP (v2); n--)
               {
                 v2 = XCDR (v2);
                 rarely_quit (n);
@@ -972,11 +972,15 @@ exec_byte_code (Lisp_Object bytestr, Lisp_Object vector, Lisp_Object maxdepth,
           NEXT;
 
         CASE (Bsub1):
-          TOP = INTEGERP (TOP) ? make_number (XINT (TOP) - 1) : Fsub1 (TOP);
+          TOP = (FIXNUMP (TOP) && XFIXNUM (TOP) != MOST_NEGATIVE_FIXNUM
+                 ? make_fixnum (XFIXNUM (TOP) - 1)
+                 : Fsub1 (TOP));
           NEXT;
 
         CASE (Badd1):
-          TOP = INTEGERP (TOP) ? make_number (XINT (TOP) + 1) : Fadd1 (TOP);
+          TOP = (FIXNUMP (TOP) && XFIXNUM (TOP) != MOST_POSITIVE_FIXNUM
+                 ? make_fixnum (XFIXNUM (TOP) + 1)
+                 : Fadd1 (TOP));
           NEXT;
 
         CASE (Beqlsign):
@@ -986,8 +990,8 @@ exec_byte_code (Lisp_Object bytestr, Lisp_Object vector, Lisp_Object maxdepth,
               TOP = arithcompare (v1, v2, ARITH_EQUAL);
             else
               {
-                CHECK_NUMBER_OR_FLOAT_COERCE_MARKER (v1);
-                CHECK_NUMBER_OR_FLOAT_COERCE_MARKER (v2);
+                CHECK_FIXNUM_OR_FLOAT_COERCE_MARKER (v1);
+                CHECK_FIXNUM_OR_FLOAT_COERCE_MARKER (v2);
                 TOP = EQ (v1, v2) ? Qt : Qnil;
               }
             NEXT;
@@ -1027,7 +1031,9 @@ exec_byte_code (Lisp_Object bytestr, Lisp_Object vector, Lisp_Object maxdepth,
           NEXT;
 
         CASE (Bnegate):
-          TOP = INTEGERP (TOP) ? make_number (- XINT (TOP)) : Fminus (1, &TOP);
+          TOP = (FIXNUMP (TOP) && XFIXNUM (TOP) != MOST_NEGATIVE_FIXNUM
+                 ? make_fixnum (- XFIXNUM (TOP))
+                 : Fminus (1, &TOP));
           NEXT;
 
         CASE (Bplus):
@@ -1063,7 +1069,7 @@ exec_byte_code (Lisp_Object bytestr, Lisp_Object vector, Lisp_Object maxdepth,
           }
 
         CASE (Bpoint):
-          PUSH (make_natnum (PT));
+          PUSH (make_fixed_natnum (PT));
           NEXT;
 
         CASE (Bgoto_char):
@@ -1089,7 +1095,7 @@ exec_byte_code (Lisp_Object bytestr, Lisp_Object vector, Lisp_Object maxdepth,
           }
 
         CASE (Bpoint_min):
-          PUSH (make_natnum (BEGV));
+          PUSH (make_fixed_natnum (BEGV));
           NEXT;
 
         CASE (Bchar_after):
@@ -1105,7 +1111,7 @@ exec_byte_code (Lisp_Object bytestr, Lisp_Object vector, Lisp_Object maxdepth,
           NEXT;
 
         CASE (Bcurrent_column):
-          PUSH (make_natnum (current_column ()));
+          PUSH (make_fixed_natnum (current_column ()));
           NEXT;
 
         CASE (Bindent_to):
@@ -1169,7 +1175,7 @@ exec_byte_code (Lisp_Object bytestr, Lisp_Object vector, Lisp_Object maxdepth,
         CASE (Bchar_syntax):
           {
             CHECK_CHARACTER (TOP);
-            int c = XFASTINT (TOP);
+            int c = XFIXNAT (TOP);
             if (NILP (BVAR (current_buffer, enable_multibyte_characters)))
               MAKE_CHAR_MULTIBYTE (c);
             XSETFASTINT (TOP, syntax_code_spec[SYNTAX (c)]);
@@ -1262,8 +1268,8 @@ exec_byte_code (Lisp_Object bytestr, Lisp_Object vector, Lisp_Object maxdepth,
               {
                 /* Exchange args and then do nth.  */
                 Lisp_Object v2 = POP, v1 = TOP;
-                CHECK_NUMBER (v2);
-                for (EMACS_INT n = XINT (v2); 0 < n && CONSP (v1); n--)
+                CHECK_FIXNUM (v2);
+                for (EMACS_INT n = XFIXNUM (v2); 0 < n && CONSP (v1); n--)
                   {
                     v1 = XCDR (v1);
                     rarely_quit (n);
@@ -1415,7 +1421,7 @@ exec_byte_code (Lisp_Object bytestr, Lisp_Object vector, Lisp_Object maxdepth,
               { /* Do a linear search if there are not many cases
                    FIXME: 5 is arbitrarily chosen.  */
                 Lisp_Object hash_code = h->test.cmpfn
-                  ? make_number (h->test.hashfn (&h->test, v1)) : Qnil;
+                  ? make_fixnum (h->test.hashfn (&h->test, v1)) : Qnil;
 
                 for (i = h->count; 0 <= --i; )
                   if (EQ (v1, HASH_KEY (h, i))
@@ -1431,9 +1437,9 @@ exec_byte_code (Lisp_Object bytestr, Lisp_Object vector, Lisp_Object maxdepth,
             if (i >= 0)
               {
                 Lisp_Object val = HASH_VALUE (h, i);
-                if (BYTE_CODE_SAFE && !INTEGERP (val))
+                if (BYTE_CODE_SAFE && !FIXNUMP (val))
                   emacs_abort ();
-                op = XINT (val);
+                op = XFIXNUM (val);
                 goto op_branch;
               }
           }
@@ -1468,14 +1474,14 @@ exec_byte_code (Lisp_Object bytestr, Lisp_Object vector, Lisp_Object maxdepth,
 Lisp_Object
 get_byte_code_arity (Lisp_Object args_template)
 {
-  eassert (NATNUMP (args_template));
-  EMACS_INT at = XINT (args_template);
+  eassert (FIXNATP (args_template));
+  EMACS_INT at = XFIXNUM (args_template);
   bool rest = (at & 128) != 0;
   int mandatory = at & 127;
   EMACS_INT nonrest = at >> 8;
 
-  return Fcons (make_number (mandatory),
-                rest ? Qmany : make_number (nonrest));
+  return Fcons (make_fixnum (mandatory),
+                rest ? Qmany : make_fixnum (nonrest));
 }
 
 void
@@ -1500,13 +1506,13 @@ If a symbol has a property named `byte-code-meter' whose value is an
 integer, it is incremented each time that symbol's function is called.  */);
 
   byte_metering_on = false;
-  Vbyte_code_meter = Fmake_vector (make_number (256), make_number (0));
+  Vbyte_code_meter = Fmake_vector (make_fixnum (256), make_fixnum (0));
   DEFSYM (Qbyte_code_meter, "byte-code-meter");
   {
     int i = 256;
     while (i--)
       ASET (Vbyte_code_meter, i,
-           Fmake_vector (make_number (256), make_number (0)));
+           Fmake_vector (make_fixnum (256), make_fixnum (0)));
   }
 #endif
 }