More macro renamings for bignum

* src/alloc.c, src/bidi.c, src/buffer.c, src/buffer.h, src/bytecode.c,
src/callint.c, src/callproc.c, src/casefiddle.c, src/casetab.c,
src/category.c, src/ccl.c, src/character.c, src/character.h,
src/charset.c, src/charset.h, src/chartab.c, src/cmds.c, src/coding.c,
src/composite.c, src/composite.h, src/data.c, src/dbusbind.c,
src/decompress.c, src/dired.c, src/dispextern.h, src/dispnew.c,
src/disptab.h, src/doc.c, src/dosfns.c, src/editfns.c,
src/emacs-module.c, src/emacs.c, src/eval.c, src/fileio.c,
src/floatfns.c, src/fns.c, src/font.c, src/font.h, src/fontset.c,
src/frame.c, src/frame.h, src/fringe.c, src/ftcrfont.c, src/ftfont.c,
src/gfilenotify.c, src/gnutls.c, src/gtkutil.c, src/image.c,
src/indent.c, src/insdel.c, src/intervals.c, src/json.c,
src/keyboard.c, src/keymap.c, src/kqueue.c, src/lcms.c, src/lisp.h,
src/lread.c, src/macros.c, src/marker.c, src/menu.c, src/minibuf.c,
src/msdos.c, src/print.c, src/process.c, src/profiler.c, src/search.c,
src/sound.c, src/syntax.c, src/syntax.h, src/sysdep.c, src/term.c,
src/termhooks.h, src/textprop.c, src/undo.c, src/w32.c,
src/w32console.c, src/w32fns.c, src/w32font.c, src/w32inevt.c,
src/w32proc.c, src/w32select.c, src/w32term.c, src/w32term.h,
src/w32uniscribe.c, src/window.c, src/xdisp.c, src/xfaces.c,
src/xfns.c, src/xfont.c, src/xftfont.c, src/xmenu.c, src/xml.c,
src/xrdb.c, src/xselect.c, src/xsettings.c, src/xterm.c, src/xwidget.c
Rename XINT->XFIXNUM, XFASTINT->XFIXNAT, XUINT->XUFIXNUM.

98 files changed, 1972 insertions, 1972 deletions

diff --git a/src/alloc.c b/src/alloc.c
index 367bb73fc15..512fdadfb2e 100644
--- a/src/alloc.c
+++ b/src/alloc.c
@@ -2324,10 +2324,10 @@ a multibyte string even if INIT is an ASCII character.  */)
   CHECK_FIXNAT (length);
   CHECK_CHARACTER (init);
 
-  c = XFASTINT (init);
+  c = XFIXNAT (init);
   if (ASCII_CHAR_P (c) && NILP (multibyte))
     {
-      nbytes = XINT (length);
+      nbytes = XFIXNUM (length);
       val = make_uninit_string (nbytes);
       if (nbytes)
         {
@@ -2339,7 +2339,7 @@ a multibyte string even if INIT is an ASCII character.  */)
     {
       unsigned char str[MAX_MULTIBYTE_LENGTH];
       ptrdiff_t len = CHAR_STRING (c, str);
-      EMACS_INT string_len = XINT (length);
+      EMACS_INT string_len = XFIXNUM (length);
       unsigned char *p, *beg, *end;
 
       if (INT_MULTIPLY_WRAPV (len, string_len, &nbytes))
@@ -2416,7 +2416,7 @@ LENGTH must be a number.  INIT matters only in whether it is t or nil.  */)
   Lisp_Object val;
 
   CHECK_FIXNAT (length);
-  val = make_uninit_bool_vector (XFASTINT (length));
+  val = make_uninit_bool_vector (XFIXNAT (length));
   return bool_vector_fill (val, init);
 }
 
@@ -2896,7 +2896,7 @@ DEFUN ("make-list", Fmake_list, Smake_list, 2, 2, 0,
   Lisp_Object val = Qnil;
   CHECK_FIXNAT (length);
 
-  for (EMACS_INT size = XFASTINT (length); 0 < size; size--)
+  for (EMACS_INT size = XFIXNAT (length); 0 < size; size--)
     {
       val = Fcons (init, val);
       rarely_quit (size);
@@ -3440,7 +3440,7 @@ each initialized to INIT.  */)
   (Lisp_Object type, Lisp_Object slots, Lisp_Object init)
 {
   CHECK_FIXNAT (slots);
-  EMACS_INT size = XFASTINT (slots) + 1;
+  EMACS_INT size = XFIXNAT (slots) + 1;
   struct Lisp_Vector *p = allocate_record (size);
   p->contents[0] = type;
   for (ptrdiff_t i = 1; i < size; i++)
@@ -3469,8 +3469,8 @@ See also the function `vector'.  */)
   (Lisp_Object length, Lisp_Object init)
 {
   CHECK_FIXNAT (length);
-  struct Lisp_Vector *p = allocate_vector (XFASTINT (length));
-  for (ptrdiff_t i = 0; i < XFASTINT (length); i++)
+  struct Lisp_Vector *p = allocate_vector (XFIXNAT (length));
+  for (ptrdiff_t i = 0; i < XFIXNAT (length); i++)
     p->contents[i] = init;
   return make_lisp_ptr (p, Lisp_Vectorlike);
 }
@@ -3899,7 +3899,7 @@ make_event_array (ptrdiff_t nargs, Lisp_Object *args)
        are characters that are in 0...127,
        after discarding the meta bit and all the bits above it.  */
     if (!FIXNUMP (args[i])
-        || (XINT (args[i]) & ~(-CHAR_META)) >= 0200)
+        || (XFIXNUM (args[i]) & ~(-CHAR_META)) >= 0200)
       return Fvector (nargs, args);
 
   /* Since the loop exited, we know that all the things in it are
@@ -3910,9 +3910,9 @@ make_event_array (ptrdiff_t nargs, Lisp_Object *args)
     result = Fmake_string (make_fixnum (nargs), make_fixnum (0), Qnil);
     for (i = 0; i < nargs; i++)
       {
-        SSET (result, i, XINT (args[i]));
+        SSET (result, i, XFIXNUM (args[i]));
         /* Move the meta bit to the right place for a string char.  */
-        if (XINT (args[i]) & CHAR_META)
+        if (XFIXNUM (args[i]) & CHAR_META)
           SSET (result, i, SREF (result, i) | 0x80);
       }
 
diff --git a/src/bidi.c b/src/bidi.c
index 30a7d6673ea..a53a2295c09 100644
--- a/src/bidi.c
+++ b/src/bidi.c
@@ -280,7 +280,7 @@ bidi_get_type (int ch, bidi_dir_t override)
   if (ch < 0 || ch > MAX_CHAR)
     emacs_abort ();
 
-  default_type = (bidi_type_t) XINT (CHAR_TABLE_REF (bidi_type_table, ch));
+  default_type = (bidi_type_t) XFIXNUM (CHAR_TABLE_REF (bidi_type_table, ch));
   /* Every valid character code, even those that are unassigned by the
      UCD, have some bidi-class property, according to
      DerivedBidiClass.txt file.  Therefore, if we ever get UNKNOWN_BT
@@ -385,9 +385,9 @@ bidi_mirror_char (int c)
 
       /* When debugging, check before assigning to V, so that the check
          isn't broken by undefined behavior due to int overflow.  */
-      eassert (CHAR_VALID_P (XINT (val)));
+      eassert (CHAR_VALID_P (XFIXNUM (val)));
 
-      v = XINT (val);
+      v = XFIXNUM (val);
 
       /* Minimal test we must do in optimized builds, to prevent weird
          crashes further down the road.  */
@@ -409,7 +409,7 @@ bidi_paired_bracket_type (int c)
   if (c < 0 || c > MAX_CHAR)
     emacs_abort ();
 
-  return (bidi_bracket_type_t) XINT (CHAR_TABLE_REF (bidi_brackets_table, c));
+  return (bidi_bracket_type_t) XFIXNUM (CHAR_TABLE_REF (bidi_brackets_table, c));
 }
 
 /* Determine the start-of-sequence (sos) directional type given the two
@@ -1805,7 +1805,7 @@ bidi_explicit_dir_char (int ch)
       eassert (ch == BIDI_EOB);
       return false;
     }
-  ch_type = (bidi_type_t) XINT (CHAR_TABLE_REF (bidi_type_table, ch));
+  ch_type = (bidi_type_t) XFIXNUM (CHAR_TABLE_REF (bidi_type_table, ch));
   return (ch_type == LRE || ch_type == LRO
           || ch_type == RLE || ch_type == RLO
           || ch_type == PDF);
diff --git a/src/buffer.c b/src/buffer.c
index 2a165c5f547..ec6f4647119 100644
--- a/src/buffer.c
+++ b/src/buffer.c
@@ -1102,8 +1102,8 @@ is first appended to NAME, to speed up finding a non-existent buffer.  */)
     {
       char number[sizeof "-999999"];
 
-      /* Use XINT instead of XFASTINT to work around GCC bug 80776.  */
-      int i = XINT (Frandom (make_fixnum (1000000)));
+      /* Use XFIXNUM instead of XFIXNAT to work around GCC bug 80776.  */
+      int i = XFIXNUM (Frandom (make_fixnum (1000000)));
       eassume (0 <= i && i < 1000000);
 
       AUTO_STRING_WITH_LEN (lnumber, number, sprintf (number, "-%d", i));
@@ -2236,13 +2236,13 @@ validate_region (register Lisp_Object *b, register Lisp_Object *e)
   CHECK_FIXNUM_COERCE_MARKER (*b);
   CHECK_FIXNUM_COERCE_MARKER (*e);
 
-  if (XINT (*b) > XINT (*e))
+  if (XFIXNUM (*b) > XFIXNUM (*e))
     {
       Lisp_Object tem;
       tem = *b;  *b = *e;  *e = tem;
     }
 
-  if (! (BEGV <= XINT (*b) && XINT (*e) <= ZV))
+  if (! (BEGV <= XFIXNUM (*b) && XFIXNUM (*e) <= ZV))
     args_out_of_range_3 (Fcurrent_buffer (), *b, *e);
 }
 
@@ -3214,15 +3214,15 @@ sort_overlays (Lisp_Object *overlay_vec, ptrdiff_t noverlays, struct window *w)
             }
           else if (FIXNUMP (tem))
             {
-              sortvec[j].priority = XINT (tem);
+              sortvec[j].priority = XFIXNUM (tem);
               sortvec[j].spriority = 0;
             }
           else if (CONSP (tem))
             {
               Lisp_Object car = XCAR (tem);
               Lisp_Object cdr = XCDR (tem);
-              sortvec[j].priority  = FIXNUMP (car) ? XINT (car) : 0;
-              sortvec[j].spriority = FIXNUMP (cdr) ? XINT (cdr) : 0;
+              sortvec[j].priority  = FIXNUMP (car) ? XFIXNUM (car) : 0;
+              sortvec[j].spriority = FIXNUMP (cdr) ? XFIXNUM (cdr) : 0;
             }
           j++;
         }
@@ -3290,7 +3290,7 @@ record_overlay_string (struct sortstrlist *ssl, Lisp_Object str,
   ssl->buf[ssl->used].string = str;
   ssl->buf[ssl->used].string2 = str2;
   ssl->buf[ssl->used].size = size;
-  ssl->buf[ssl->used].priority = (FIXNUMP (pri) ? XINT (pri) : 0);
+  ssl->buf[ssl->used].priority = (FIXNUMP (pri) ? XFIXNUM (pri) : 0);
   ssl->used++;
 
   if (NILP (BVAR (current_buffer, enable_multibyte_characters)))
@@ -3870,7 +3870,7 @@ for the rear of the overlay advance when text is inserted there
   CHECK_FIXNUM_COERCE_MARKER (beg);
   CHECK_FIXNUM_COERCE_MARKER (end);
 
-  if (XINT (beg) > XINT (end))
+  if (XFIXNUM (beg) > XFIXNUM (end))
     {
       Lisp_Object temp;
       temp = beg; beg = end; end = temp;
@@ -3990,7 +3990,7 @@ buffer.  */)
   CHECK_FIXNUM_COERCE_MARKER (beg);
   CHECK_FIXNUM_COERCE_MARKER (end);
 
-  if (XINT (beg) > XINT (end))
+  if (XFIXNUM (beg) > XFIXNUM (end))
     {
       Lisp_Object temp;
       temp = beg; beg = end; end = temp;
@@ -4167,7 +4167,7 @@ If SORTED is non-nil, then sort them by decreasing priority.  */)
 
   /* Put all the overlays we want in a vector in overlay_vec.
      Store the length in len.  */
-  noverlays = overlays_at (XINT (pos), 1, &overlay_vec, &len,
+  noverlays = overlays_at (XFIXNUM (pos), 1, &overlay_vec, &len,
                            NULL, NULL, 0);
 
   if (!NILP (sorted))
@@ -4211,7 +4211,7 @@ end of the buffer.  */)
 
   /* Put all the overlays we want in a vector in overlay_vec.
      Store the length in len.  */
-  noverlays = overlays_in (XINT (beg), XINT (end), 1, &overlay_vec, &len,
+  noverlays = overlays_in (XFIXNUM (beg), XFIXNUM (end), 1, &overlay_vec, &len,
                            NULL, NULL);
 
   /* Make a list of them all.  */
@@ -4243,7 +4243,7 @@ the value is (point-max).  */)
   /* Put all the overlays we want in a vector in overlay_vec.
      Store the length in len.
      endpos gets the position where the next overlay starts.  */
-  noverlays = overlays_at (XINT (pos), 1, &overlay_vec, &len,
+  noverlays = overlays_at (XFIXNUM (pos), 1, &overlay_vec, &len,
                            &endpos, 0, 1);
 
   /* If any of these overlays ends before endpos,
@@ -4281,7 +4281,7 @@ the value is (point-min).  */)
 
   /* At beginning of buffer, we know the answer;
      avoid bug subtracting 1 below.  */
-  if (XINT (pos) == BEGV)
+  if (XFIXNUM (pos) == BEGV)
     return pos;
 
   len = 10;
@@ -4290,7 +4290,7 @@ the value is (point-min).  */)
   /* Put all the overlays we want in a vector in overlay_vec.
      Store the length in len.
      prevpos gets the position of the previous change.  */
-  overlays_at (XINT (pos), 1, &overlay_vec, &len,
+  overlays_at (XFIXNUM (pos), 1, &overlay_vec, &len,
                0, &prevpos, 1);
 
   xfree (overlay_vec);
@@ -4334,7 +4334,7 @@ for positions far away from POS).  */)
   ptrdiff_t p;
   CHECK_FIXNUM_COERCE_MARKER (pos);
 
-  p = clip_to_bounds (PTRDIFF_MIN, XINT (pos), PTRDIFF_MAX);
+  p = clip_to_bounds (PTRDIFF_MIN, XFIXNUM (pos), PTRDIFF_MAX);
   recenter_overlay_lists (current_buffer, p);
   return Qnil;
 }
@@ -4442,7 +4442,7 @@ report_overlay_modification (Lisp_Object start, Lisp_Object end, bool after,
   Lisp_Object prop, overlay;
   struct Lisp_Overlay *tail;
   /* True if this change is an insertion.  */
-  bool insertion = (after ? XFASTINT (arg3) == 0 : EQ (start, end));
+  bool insertion = (after ? XFIXNAT (arg3) == 0 : EQ (start, end));
 
   overlay = Qnil;
   tail = NULL;
@@ -4470,18 +4470,18 @@ report_overlay_modification (Lisp_Object start, Lisp_Object end, bool after,
           ostart = OVERLAY_START (overlay);
           oend = OVERLAY_END (overlay);
           endpos = OVERLAY_POSITION (oend);
-          if (XFASTINT (start) > endpos)
+          if (XFIXNAT (start) > endpos)
             break;
           startpos = OVERLAY_POSITION (ostart);
-          if (insertion && (XFASTINT (start) == startpos
-                            || XFASTINT (end) == startpos))
+          if (insertion && (XFIXNAT (start) == startpos
+                            || XFIXNAT (end) == startpos))
             {
               prop = Foverlay_get (overlay, Qinsert_in_front_hooks);
               if (!NILP (prop))
                 add_overlay_mod_hooklist (prop, overlay);
             }
-          if (insertion && (XFASTINT (start) == endpos
-                            || XFASTINT (end) == endpos))
+          if (insertion && (XFIXNAT (start) == endpos
+                            || XFIXNAT (end) == endpos))
             {
               prop = Foverlay_get (overlay, Qinsert_behind_hooks);
               if (!NILP (prop))
@@ -4489,7 +4489,7 @@ report_overlay_modification (Lisp_Object start, Lisp_Object end, bool after,
             }
           /* Test for intersecting intervals.  This does the right thing
              for both insertion and deletion.  */
-          if (XFASTINT (end) > startpos && XFASTINT (start) < endpos)
+          if (XFIXNAT (end) > startpos && XFIXNAT (start) < endpos)
             {
               prop = Foverlay_get (overlay, Qmodification_hooks);
               if (!NILP (prop))
@@ -4508,17 +4508,17 @@ report_overlay_modification (Lisp_Object start, Lisp_Object end, bool after,
           oend = OVERLAY_END (overlay);
           startpos = OVERLAY_POSITION (ostart);
           endpos = OVERLAY_POSITION (oend);
-          if (XFASTINT (end) < startpos)
+          if (XFIXNAT (end) < startpos)
             break;
-          if (insertion && (XFASTINT (start) == startpos
-                            || XFASTINT (end) == startpos))
+          if (insertion && (XFIXNAT (start) == startpos
+                            || XFIXNAT (end) == startpos))
             {
               prop = Foverlay_get (overlay, Qinsert_in_front_hooks);
               if (!NILP (prop))
                 add_overlay_mod_hooklist (prop, overlay);
             }
-          if (insertion && (XFASTINT (start) == endpos
-                            || XFASTINT (end) == endpos))
+          if (insertion && (XFIXNAT (start) == endpos
+                            || XFIXNAT (end) == endpos))
             {
               prop = Foverlay_get (overlay, Qinsert_behind_hooks);
               if (!NILP (prop))
@@ -4526,7 +4526,7 @@ report_overlay_modification (Lisp_Object start, Lisp_Object end, bool after,
             }
           /* Test for intersecting intervals.  This does the right thing
              for both insertion and deletion.  */
-          if (XFASTINT (end) > startpos && XFASTINT (start) < endpos)
+          if (XFIXNAT (end) > startpos && XFIXNAT (start) < endpos)
             {
               prop = Foverlay_get (overlay, Qmodification_hooks);
               if (!NILP (prop))
diff --git a/src/buffer.h b/src/buffer.h
index c97e3d8fa51..c6247506d7a 100644
--- a/src/buffer.h
+++ b/src/buffer.h
@@ -1349,7 +1349,7 @@ extern int last_per_buffer_idx;
 
 
 #define PER_BUFFER_IDX(OFFSET) \
-      XINT (*(Lisp_Object *)((OFFSET) + (char *) &buffer_local_flags))
+      XFIXNUM (*(Lisp_Object *)((OFFSET) + (char *) &buffer_local_flags))
 
 /* Functions to get and set default value of the per-buffer
    variable at offset OFFSET in the buffer structure.  */
@@ -1387,7 +1387,7 @@ downcase (int c)
 {
   Lisp_Object downcase_table = BVAR (current_buffer, downcase_table);
   Lisp_Object down = CHAR_TABLE_REF (downcase_table, c);
-  return FIXNATP (down) ? XFASTINT (down) : c;
+  return FIXNATP (down) ? XFIXNAT (down) : c;
 }
 
 /* Upcase a character C, or make no change if that cannot be done. */
@@ -1396,7 +1396,7 @@ upcase (int c)
 {
   Lisp_Object upcase_table = BVAR (current_buffer, upcase_table);
   Lisp_Object up = CHAR_TABLE_REF (upcase_table, c);
-  return FIXNATP (up) ? XFASTINT (up) : c;
+  return FIXNATP (up) ? XFIXNAT (up) : c;
 }
 
 /* True if C is upper case.  */
diff --git a/src/bytecode.c b/src/bytecode.c
index f87983a59c0..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);     \
     }                                                                   \
 }
 
@@ -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);
@@ -379,7 +379,7 @@ exec_byte_code (Lisp_Object bytestr, Lisp_Object vector, Lisp_Object maxdepth,
   if (!NILP (args_template))
     {
       eassert (FIXNUMP (args_template));
-      ptrdiff_t at = XINT (args_template);
+      ptrdiff_t at = XFIXNUM (args_template);
       bool rest = (at & 128) != 0;
       int mandatory = at & 127;
       ptrdiff_t nonrest = at >> 8;
@@ -622,9 +622,9 @@ 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 (FIXNUMP (v2)
-                    && XINT (v2) < MOST_POSITIVE_FIXNUM)
+                    && XFIXNUM (v2) < MOST_POSITIVE_FIXNUM)
                   {
-                    XSETINT (v2, XINT (v2) + 1);
+                    XSETINT (v2, XFIXNUM (v2) + 1);
                     Fput (v1, Qbyte_code_meter, v2);
                   }
               }
@@ -833,7 +833,7 @@ exec_byte_code (Lisp_Object bytestr, Lisp_Object vector, Lisp_Object maxdepth,
           {
             Lisp_Object v2 = POP, v1 = TOP;
             CHECK_FIXNUM (v1);
-            for (EMACS_INT n = XINT (v1); 0 < n && CONSP (v2); n--)
+            for (EMACS_INT n = XFIXNUM (v1); 0 < n && CONSP (v2); n--)
               {
                 v2 = XCDR (v2);
                 rarely_quit (n);
@@ -972,14 +972,14 @@ exec_byte_code (Lisp_Object bytestr, Lisp_Object vector, Lisp_Object maxdepth,
           NEXT;
 
         CASE (Bsub1):
-          TOP = (FIXNUMP (TOP) && XINT (TOP) != MOST_NEGATIVE_FIXNUM
-                 ? make_fixnum (XINT (TOP) - 1)
+          TOP = (FIXNUMP (TOP) && XFIXNUM (TOP) != MOST_NEGATIVE_FIXNUM
+                 ? make_fixnum (XFIXNUM (TOP) - 1)
                  : Fsub1 (TOP));
           NEXT;
 
         CASE (Badd1):
-          TOP = (FIXNUMP (TOP) && XINT (TOP) != MOST_POSITIVE_FIXNUM
-                 ? make_fixnum (XINT (TOP) + 1)
+          TOP = (FIXNUMP (TOP) && XFIXNUM (TOP) != MOST_POSITIVE_FIXNUM
+                 ? make_fixnum (XFIXNUM (TOP) + 1)
                  : Fadd1 (TOP));
           NEXT;
 
@@ -1031,8 +1031,8 @@ exec_byte_code (Lisp_Object bytestr, Lisp_Object vector, Lisp_Object maxdepth,
           NEXT;
 
         CASE (Bnegate):
-          TOP = (FIXNUMP (TOP) && XINT (TOP) != MOST_NEGATIVE_FIXNUM
-                 ? make_fixnum (- XINT (TOP))
+          TOP = (FIXNUMP (TOP) && XFIXNUM (TOP) != MOST_NEGATIVE_FIXNUM
+                 ? make_fixnum (- XFIXNUM (TOP))
                  : Fminus (1, &TOP));
           NEXT;
 
@@ -1175,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)]);
@@ -1269,7 +1269,7 @@ 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_FIXNUM (v2);
-                for (EMACS_INT n = XINT (v2); 0 < n && CONSP (v1); n--)
+                for (EMACS_INT n = XFIXNUM (v2); 0 < n && CONSP (v1); n--)
                   {
                     v1 = XCDR (v1);
                     rarely_quit (n);
@@ -1439,7 +1439,7 @@ exec_byte_code (Lisp_Object bytestr, Lisp_Object vector, Lisp_Object maxdepth,
                 Lisp_Object val = HASH_VALUE (h, i);
                 if (BYTE_CODE_SAFE && !FIXNUMP (val))
                   emacs_abort ();
-                op = XINT (val);
+                op = XFIXNUM (val);
                 goto op_branch;
               }
           }
@@ -1475,7 +1475,7 @@ Lisp_Object
 get_byte_code_arity (Lisp_Object args_template)
 {
   eassert (FIXNATP (args_template));
-  EMACS_INT at = XINT (args_template);
+  EMACS_INT at = XFIXNUM (args_template);
   bool rest = (at & 128) != 0;
   int mandatory = at & 127;
   EMACS_INT nonrest = at >> 8;
diff --git a/src/callint.c b/src/callint.c
index c18eab488d4..c8b75859e60 100644
--- a/src/callint.c
+++ b/src/callint.c
@@ -542,7 +542,7 @@ invoke it.  If KEYS is omitted or nil, the return value of
             /* If the key sequence ends with a down-event,
                discard the following up-event.  */
             Lisp_Object teml
-              = Faref (args[i], make_fixnum (XINT (Flength (args[i])) - 1));
+              = Faref (args[i], make_fixnum (XFIXNUM (Flength (args[i])) - 1));
             if (CONSP (teml))
               teml = XCAR (teml);
             if (SYMBOLP (teml))
@@ -572,7 +572,7 @@ invoke it.  If KEYS is omitted or nil, the return value of
             /* If the key sequence ends with a down-event,
                discard the following up-event.  */
             Lisp_Object teml
-              = Faref (args[i], make_fixnum (XINT (Flength (args[i])) - 1));
+              = Faref (args[i], make_fixnum (XFIXNUM (Flength (args[i])) - 1));
             if (CONSP (teml))
               teml = XCAR (teml);
             if (SYMBOLP (teml))
@@ -796,7 +796,7 @@ Its numeric meaning is what you would get from `(interactive "p")'.  */)
   else if (EQ (raw, Qminus))
     XSETINT (val, -1);
   else if (CONSP (raw) && FIXNUMP (XCAR (raw)))
-    XSETINT (val, XINT (XCAR (raw)));
+    XSETINT (val, XFIXNUM (XCAR (raw)));
   else if (FIXNUMP (raw))
     val = raw;
   else
diff --git a/src/callproc.c b/src/callproc.c
index f959927d37a..e6a81802936 100644
--- a/src/callproc.c
+++ b/src/callproc.c
@@ -1066,7 +1066,7 @@ usage: (call-process-region START END PROGRAM &optional DELETE BUFFER DISPLAY &r
       validate_region (&args[0], &args[1]);
       start = args[0];
       end = args[1];
-      empty_input = XINT (start) == XINT (end);
+      empty_input = XFIXNUM (start) == XFIXNUM (end);
     }
 
   if (!empty_input)
diff --git a/src/casefiddle.c b/src/casefiddle.c
index a6656b1e683..95857d6f361 100644
--- a/src/casefiddle.c
+++ b/src/casefiddle.c
@@ -152,7 +152,7 @@ case_character_impl (struct casing_str_buf *buf,
           prop = CHAR_TABLE_REF (ctx->titlecase_char_table, ch);
           if (CHARACTERP (prop))
             {
-              cased = XFASTINT (prop);
+              cased = XFIXNAT (prop);
               cased_is_set = true;
             }
         }
@@ -225,7 +225,7 @@ do_casify_natnum (struct casing_context *ctx, Lisp_Object obj)
 {
   int flagbits = (CHAR_ALT | CHAR_SUPER | CHAR_HYPER
                   | CHAR_SHIFT | CHAR_CTL | CHAR_META);
-  int ch = XFASTINT (obj);
+  int ch = XFIXNAT (obj);
 
   /* If the character has higher bits set above the flags, return it unchanged.
      It is not a real character.  */
@@ -485,8 +485,8 @@ casify_region (enum case_action flag, Lisp_Object b, Lisp_Object e)
   struct casing_context ctx;
 
   validate_region (&b, &e);
-  ptrdiff_t start = XFASTINT (b);
-  ptrdiff_t end = XFASTINT (e);
+  ptrdiff_t start = XFIXNAT (b);
+  ptrdiff_t end = XFIXNAT (e);
   if (start == end)
     /* Not modifying because nothing marked.  */
     return end;
@@ -602,9 +602,9 @@ static Lisp_Object
 casify_word (enum case_action flag, Lisp_Object arg)
 {
   CHECK_FIXNUM (arg);
-  ptrdiff_t farend = scan_words (PT, XINT (arg));
+  ptrdiff_t farend = scan_words (PT, XFIXNUM (arg));
   if (!farend)
-    farend = XINT (arg) <= 0 ? BEGV : ZV;
+    farend = XFIXNUM (arg) <= 0 ? BEGV : ZV;
   SET_PT (casify_region (flag, make_fixnum (PT), make_fixnum (farend)));
   return Qnil;
 }
diff --git a/src/casetab.c b/src/casetab.c
index 58847fc330a..6b1c64f89e4 100644
--- a/src/casetab.c
+++ b/src/casetab.c
@@ -196,11 +196,11 @@ set_identity (Lisp_Object table, Lisp_Object c, Lisp_Object elt)
 
       if (CONSP (c))
         {
-          from = XINT (XCAR (c));
-          to = XINT (XCDR (c));
+          from = XFIXNUM (XCAR (c));
+          to = XFIXNUM (XCDR (c));
         }
       else
-        from = to = XINT (c);
+        from = to = XFIXNUM (c);
 
       to++;
       for (; from < to; from++)
@@ -222,11 +222,11 @@ shuffle (Lisp_Object table, Lisp_Object c, Lisp_Object elt)
 
       if (CONSP (c))
         {
-          from = XINT (XCAR (c));
-          to = XINT (XCDR (c));
+          from = XFIXNUM (XCAR (c));
+          to = XFIXNUM (XCDR (c));
         }
       else
-        from = to = XINT (c);
+        from = to = XFIXNUM (c);
 
       to++;
       for (; from < to; from++)
diff --git a/src/category.c b/src/category.c
index 72b589c7902..d6ccde5369b 100644
--- a/src/category.c
+++ b/src/category.c
@@ -130,11 +130,11 @@ the current buffer's category table.  */)
   CHECK_STRING (docstring);
   table = check_category_table (table);
 
-  if (!NILP (CATEGORY_DOCSTRING (table, XFASTINT (category))))
-    error ("Category `%c' is already defined", (int) XFASTINT (category));
+  if (!NILP (CATEGORY_DOCSTRING (table, XFIXNAT (category))))
+    error ("Category `%c' is already defined", (int) XFIXNAT (category));
   if (!NILP (Vpurify_flag))
     docstring = Fpurecopy (docstring);
-  SET_CATEGORY_DOCSTRING (table, XFASTINT (category), docstring);
+  SET_CATEGORY_DOCSTRING (table, XFIXNAT (category), docstring);
 
   return Qnil;
 }
@@ -148,7 +148,7 @@ category table.  */)
   CHECK_CATEGORY (category);
   table = check_category_table (table);
 
-  return CATEGORY_DOCSTRING (table, XFASTINT (category));
+  return CATEGORY_DOCSTRING (table, XFIXNAT (category));
 }
 
 DEFUN ("get-unused-category", Fget_unused_category, Sget_unused_category,
@@ -220,9 +220,9 @@ copy_category_entry (Lisp_Object table, Lisp_Object c, Lisp_Object val)
 {
   val = Fcopy_sequence (val);
   if (CONSP (c))
-    char_table_set_range (table, XINT (XCAR (c)), XINT (XCDR (c)), val);
+    char_table_set_range (table, XFIXNUM (XCAR (c)), XFIXNUM (XCDR (c)), val);
   else
-    char_table_set (table, XINT (c), val);
+    char_table_set (table, XFIXNUM (c), val);
 }
 
 /* Return a copy of category table TABLE.  We can't simply use the
@@ -303,7 +303,7 @@ usage: (char-category-set CHAR)  */)
   (Lisp_Object ch)
 {
   CHECK_CHARACTER (ch);
-  return CATEGORY_SET (XFASTINT (ch));
+  return CATEGORY_SET (XFIXNAT (ch));
 }
 
 DEFUN ("category-set-mnemonics", Fcategory_set_mnemonics,
@@ -349,22 +349,22 @@ then delete CATEGORY from the category set instead of adding it.  */)
   if (FIXNUMP (character))
     {
       CHECK_CHARACTER (character);
-      start = end = XFASTINT (character);
+      start = end = XFIXNAT (character);
     }
   else
     {
       CHECK_CONS (character);
       CHECK_CHARACTER_CAR (character);
       CHECK_CHARACTER_CDR (character);
-      start = XFASTINT (XCAR (character));
-      end = XFASTINT (XCDR (character));
+      start = XFIXNAT (XCAR (character));
+      end = XFIXNAT (XCDR (character));
     }
 
   CHECK_CATEGORY (category);
   table = check_category_table (table);
 
-  if (NILP (CATEGORY_DOCSTRING (table, XFASTINT (category))))
-    error ("Undefined category: %c", (int) XFASTINT (category));
+  if (NILP (CATEGORY_DOCSTRING (table, XFIXNAT (category))))
+    error ("Undefined category: %c", (int) XFIXNAT (category));
 
   set_value = NILP (reset);
 
@@ -372,10 +372,10 @@ then delete CATEGORY from the category set instead of adding it.  */)
     {
       from = start, to = end;
       category_set = char_table_ref_and_range (table, start, &from, &to);
-      if (CATEGORY_MEMBER (XFASTINT (category), category_set) != NILP (reset))
+      if (CATEGORY_MEMBER (XFIXNAT (category), category_set) != NILP (reset))
         {
           category_set = Fcopy_sequence (category_set);
-          set_category_set (category_set, XFASTINT (category), set_value);
+          set_category_set (category_set, XFIXNAT (category), set_value);
           category_set = hash_get_category_set (table, category_set);
           char_table_set_range (table, start, to, category_set);
         }
@@ -423,12 +423,12 @@ word_boundary_p (int c1, int c2)
       if (CONSP (elt)
           && (NILP (XCAR (elt))
               || (CATEGORYP (XCAR (elt))
-                  && CATEGORY_MEMBER (XFASTINT (XCAR (elt)), category_set1)
-                  && ! CATEGORY_MEMBER (XFASTINT (XCAR (elt)), category_set2)))
+                  && CATEGORY_MEMBER (XFIXNAT (XCAR (elt)), category_set1)
+                  && ! CATEGORY_MEMBER (XFIXNAT (XCAR (elt)), category_set2)))
           && (NILP (XCDR (elt))
               || (CATEGORYP (XCDR (elt))
-                  && ! CATEGORY_MEMBER (XFASTINT (XCDR (elt)), category_set1)
-                  && CATEGORY_MEMBER (XFASTINT (XCDR (elt)), category_set2))))
+                  && ! CATEGORY_MEMBER (XFIXNAT (XCDR (elt)), category_set1)
+                  && CATEGORY_MEMBER (XFIXNAT (XCDR (elt)), category_set2))))
         return !default_result;
     }
   return default_result;
diff --git a/src/ccl.c b/src/ccl.c
index 529b302ed98..31d0a28c5aa 100644
--- a/src/ccl.c
+++ b/src/ccl.c
@@ -629,7 +629,7 @@ do								\
     stack_idx++;                                                \
     ccl_prog = called_ccl.prog;                                 \
     ic = CCL_HEADER_MAIN;                                       \
-    eof_ic = XFASTINT (ccl_prog[CCL_HEADER_EOF]);               \
+    eof_ic = XFIXNAT (ccl_prog[CCL_HEADER_EOF]);                \
     goto ccl_repeat;                                            \
   }                                                             \
 while (0)
@@ -736,7 +736,7 @@ while (0)
 #define GET_CCL_RANGE(var, ccl_prog, ic, lo, hi)                \
   do                                                            \
     {                                                           \
-      EMACS_INT prog_word = XINT ((ccl_prog)[ic]);              \
+      EMACS_INT prog_word = XFIXNUM ((ccl_prog)[ic]);           \
       if (! ASCENDING_ORDER (lo, prog_word, hi))                \
         CCL_INVALID_CMD;                                        \
       (var) = prog_word;                                        \
@@ -769,12 +769,12 @@ while (0)
       CCL_INVALID_CMD;                                          \
     else if (dst + len <= dst_end)                              \
       {                                                         \
-        if (XFASTINT (ccl_prog[ic]) & 0x1000000)                \
+        if (XFIXNAT (ccl_prog[ic]) & 0x1000000)         \
           for (ccli = 0; ccli < len; ccli++)                    \
-            *dst++ = XFASTINT (ccl_prog[ic + ccli]) & 0xFFFFFF; \
+            *dst++ = XFIXNAT (ccl_prog[ic + ccli]) & 0xFFFFFF;  \
         else                                                    \
           for (ccli = 0; ccli < len; ccli++)                    \
-            *dst++ = ((XFASTINT (ccl_prog[ic + (ccli / 3)]))    \
+            *dst++ = ((XFIXNAT (ccl_prog[ic + (ccli / 3)]))     \
                       >> ((2 - (ccli % 3)) * 8)) & 0xFF;        \
       }                                                         \
     else                                                        \
@@ -926,14 +926,14 @@ ccl_driver (struct ccl_program *ccl, int *source, int *destination, int src_size
           break;
 
         case CCL_SetConst:      /* 00000000000000000000rrrXXXXX */
-          reg[rrr] = XINT (ccl_prog[ic++]);
+          reg[rrr] = XFIXNUM (ccl_prog[ic++]);
           break;
 
         case CCL_SetArray:      /* CCCCCCCCCCCCCCCCCCCCRRRrrrXXXXX */
           i = reg[RRR];
           j = field1 >> 3;
           if (0 <= i && i < j)
-            reg[rrr] = XINT (ccl_prog[ic + i]);
+            reg[rrr] = XFIXNUM (ccl_prog[ic + i]);
           ic += j;
           break;
 
@@ -961,13 +961,13 @@ ccl_driver (struct ccl_program *ccl, int *source, int *destination, int src_size
           break;
 
         case CCL_WriteConstJump: /* A--D--D--R--E--S--S-000XXXXX */
-          i = XINT (ccl_prog[ic]);
+          i = XFIXNUM (ccl_prog[ic]);
           CCL_WRITE_CHAR (i);
           ic += ADDR;
           break;
 
         case CCL_WriteConstReadJump: /* A--D--D--R--E--S--S-rrrXXXXX */
-          i = XINT (ccl_prog[ic]);
+          i = XFIXNUM (ccl_prog[ic]);
           CCL_WRITE_CHAR (i);
           ic++;
           CCL_READ_CHAR (reg[rrr]);
@@ -975,17 +975,17 @@ ccl_driver (struct ccl_program *ccl, int *source, int *destination, int src_size
           break;
 
         case CCL_WriteStringJump: /* A--D--D--R--E--S--S-000XXXXX */
-          j = XINT (ccl_prog[ic++]);
+          j = XFIXNUM (ccl_prog[ic++]);
           CCL_WRITE_STRING (j);
           ic += ADDR - 1;
           break;
 
         case CCL_WriteArrayReadJump: /* A--D--D--R--E--S--S-rrrXXXXX */
           i = reg[rrr];
-          j = XINT (ccl_prog[ic]);
+          j = XFIXNUM (ccl_prog[ic]);
           if (0 <= i && i < j)
             {
-              i = XINT (ccl_prog[ic + 1 + i]);
+              i = XFIXNUM (ccl_prog[ic + 1 + i]);
               CCL_WRITE_CHAR (i);
             }
           ic += j + 2;
@@ -1004,7 +1004,7 @@ ccl_driver (struct ccl_program *ccl, int *source, int *destination, int src_size
         case CCL_Branch:        /* CCCCCCCCCCCCCCCCCCCCrrrXXXXX */
         {
           int ioff = 0 <= reg[rrr] && reg[rrr] < field1 ? reg[rrr] : field1;
-          int incr = XINT (ccl_prog[ic + ioff]);
+          int incr = XFIXNUM (ccl_prog[ic + ioff]);
           ic += incr;
         }
           break;
@@ -1023,7 +1023,7 @@ ccl_driver (struct ccl_program *ccl, int *source, int *destination, int src_size
         case CCL_WriteExprConst:  /* 1:00000OPERATION000RRR000XXXXX */
           rrr = 7;
           i = reg[RRR];
-          j = XINT (ccl_prog[ic]);
+          j = XFIXNUM (ccl_prog[ic]);
           op = field1 >> 6;
           jump_address = ic + 1;
           goto ccl_set_expr;
@@ -1056,7 +1056,7 @@ ccl_driver (struct ccl_program *ccl, int *source, int *destination, int src_size
             /* If FFF is nonzero, the CCL program ID is in the
                following code.  */
             if (rrr)
-              prog_id = XINT (ccl_prog[ic++]);
+              prog_id = XFIXNUM (ccl_prog[ic++]);
             else
               prog_id = field1;
 
@@ -1081,7 +1081,7 @@ ccl_driver (struct ccl_program *ccl, int *source, int *destination, int src_size
             stack_idx++;
             ccl_prog = XVECTOR (AREF (slot, 1))->contents;
             ic = CCL_HEADER_MAIN;
-            eof_ic = XFASTINT (ccl_prog[CCL_HEADER_EOF]);
+            eof_ic = XFIXNAT (ccl_prog[CCL_HEADER_EOF]);
           }
           break;
 
@@ -1099,7 +1099,7 @@ ccl_driver (struct ccl_program *ccl, int *source, int *destination, int src_size
           i = reg[rrr];
           if (0 <= i && i < field1)
             {
-              j = XINT (ccl_prog[ic + i]);
+              j = XFIXNUM (ccl_prog[ic + i]);
               CCL_WRITE_CHAR (j);
             }
           ic += field1;
@@ -1124,7 +1124,7 @@ ccl_driver (struct ccl_program *ccl, int *source, int *destination, int src_size
           CCL_SUCCESS;
 
         case CCL_ExprSelfConst: /* 00000OPERATION000000rrrXXXXX */
-          i = XINT (ccl_prog[ic++]);
+          i = XFIXNUM (ccl_prog[ic++]);
           op = field1 >> 6;
           goto ccl_expr_self;
 
@@ -1160,7 +1160,7 @@ ccl_driver (struct ccl_program *ccl, int *source, int *destination, int src_size
 
         case CCL_SetExprConst:  /* 00000OPERATION000RRRrrrXXXXX */
           i = reg[RRR];
-          j = XINT (ccl_prog[ic++]);
+          j = XFIXNUM (ccl_prog[ic++]);
           op = field1 >> 6;
           jump_address = ic;
           goto ccl_set_expr;
@@ -1178,8 +1178,8 @@ ccl_driver (struct ccl_program *ccl, int *source, int *destination, int src_size
         case CCL_JumpCondExprConst: /* A--D--D--R--E--S--S-rrrXXXXX */
           i = reg[rrr];
           jump_address = ic + ADDR;
-          op = XINT (ccl_prog[ic++]);
-          j = XINT (ccl_prog[ic++]);
+          op = XFIXNUM (ccl_prog[ic++]);
+          j = XFIXNUM (ccl_prog[ic++]);
           rrr = 7;
           goto ccl_set_expr;
 
@@ -1189,7 +1189,7 @@ ccl_driver (struct ccl_program *ccl, int *source, int *destination, int src_size
         case CCL_JumpCondExprReg:
           i = reg[rrr];
           jump_address = ic + ADDR;
-          op = XINT (ccl_prog[ic++]);
+          op = XFIXNUM (ccl_prog[ic++]);
           GET_CCL_RANGE (j, ccl_prog, ic++, 0, 7);
           j = reg[j];
           rrr = 7;
@@ -1323,9 +1323,9 @@ ccl_driver (struct ccl_program *ccl, int *source, int *destination, int src_size
                   {
                     Lisp_Object opl;
                     opl = HASH_VALUE (h, eop);
-                    if (! (FIXNUMP (opl) && IN_INT_RANGE (XINT (opl))))
+                    if (! (FIXNUMP (opl) && IN_INT_RANGE (XFIXNUM (opl))))
                       CCL_INVALID_CMD;
-                    reg[RRR] = XINT (opl);
+                    reg[RRR] = XFIXNUM (opl);
                     reg[7] = 1; /* r7 true for success */
                   }
                 else
@@ -1340,7 +1340,7 @@ ccl_driver (struct ccl_program *ccl, int *source, int *destination, int src_size
                 ptrdiff_t size;
                 int fin_ic;
 
-                j = XINT (ccl_prog[ic++]); /* number of maps. */
+                j = XFIXNUM (ccl_prog[ic++]); /* number of maps. */
                 fin_ic = ic + j;
                 op = reg[rrr];
                 if ((j > reg[RRR]) && (j >= 0))
@@ -1359,7 +1359,7 @@ ccl_driver (struct ccl_program *ccl, int *source, int *destination, int src_size
                   {
                     if (!VECTORP (Vcode_conversion_map_vector)) continue;
                     size = ASIZE (Vcode_conversion_map_vector);
-                    point = XINT (ccl_prog[ic++]);
+                    point = XFIXNUM (ccl_prog[ic++]);
                     if (! (0 <= point && point < size)) continue;
                     map = AREF (Vcode_conversion_map_vector, point);
 
@@ -1377,7 +1377,7 @@ ccl_driver (struct ccl_program *ccl, int *source, int *destination, int src_size
                        [t ELEMENT STARTPOINT ENDPOINT]  */
                     if (FIXNUMP (content))
                       {
-                        point = XINT (content);
+                        point = XFIXNUM (content);
                         if (!(point <= op && op - point + 1 < size)) continue;
                         content = AREF (map, op - point + 1);
                       }
@@ -1385,9 +1385,9 @@ ccl_driver (struct ccl_program *ccl, int *source, int *destination, int src_size
                       {
                         if (size != 4) continue;
                         if (FIXNUMP (AREF (map, 2))
-                            && XINT (AREF (map, 2)) <= op
+                            && XFIXNUM (AREF (map, 2)) <= op
                             && FIXNUMP (AREF (map, 3))
-                            && op < XINT (AREF (map, 3)))
+                            && op < XFIXNUM (AREF (map, 3)))
                           content = AREF (map, 1);
                         else
                           continue;
@@ -1397,10 +1397,10 @@ ccl_driver (struct ccl_program *ccl, int *source, int *destination, int src_size
 
                     if (NILP (content))
                       continue;
-                    else if (FIXNUMP (content) && IN_INT_RANGE (XINT (content)))
+                    else if (FIXNUMP (content) && IN_INT_RANGE (XFIXNUM (content)))
                       {
                         reg[RRR] = i;
-                        reg[rrr] = XINT (content);
+                        reg[rrr] = XFIXNUM (content);
                         break;
                       }
                     else if (EQ (content, Qt) || EQ (content, Qlambda))
@@ -1413,10 +1413,10 @@ ccl_driver (struct ccl_program *ccl, int *source, int *destination, int src_size
                         attrib = XCAR (content);
                         value = XCDR (content);
                         if (! (FIXNUMP (attrib) && FIXNUMP (value)
-                               && IN_INT_RANGE (XINT (value))))
+                               && IN_INT_RANGE (XFIXNUM (value))))
                           continue;
                         reg[RRR] = i;
-                        reg[rrr] = XINT (value);
+                        reg[rrr] = XFIXNUM (value);
                         break;
                       }
                     else if (SYMBOLP (content))
@@ -1453,7 +1453,7 @@ ccl_driver (struct ccl_program *ccl, int *source, int *destination, int src_size
                 stack_idx_of_map_multiple = 0;
 
                 /* Get number of maps and separators.  */
-                map_set_rest_length = XINT (ccl_prog[ic++]);
+                map_set_rest_length = XFIXNUM (ccl_prog[ic++]);
 
                 fin_ic = ic + map_set_rest_length;
                 op = reg[rrr];
@@ -1524,7 +1524,7 @@ ccl_driver (struct ccl_program *ccl, int *source, int *destination, int src_size
                 do {
                   for (;map_set_rest_length > 0;i++, ic++, map_set_rest_length--)
                     {
-                      point = XINT (ccl_prog[ic]);
+                      point = XFIXNUM (ccl_prog[ic]);
                       if (point < 0)
                         {
                           /* +1 is for including separator. */
@@ -1556,7 +1556,7 @@ ccl_driver (struct ccl_program *ccl, int *source, int *destination, int src_size
                          [t ELEMENT STARTPOINT ENDPOINT]  */
                       if (FIXNUMP (content))
                         {
-                          point = XINT (content);
+                          point = XFIXNUM (content);
                           if (!(point <= op && op - point + 1 < size)) continue;
                           content = AREF (map, op - point + 1);
                         }
@@ -1564,9 +1564,9 @@ ccl_driver (struct ccl_program *ccl, int *source, int *destination, int src_size
                         {
                           if (size != 4) continue;
                           if (FIXNUMP (AREF (map, 2))
-                              && XINT (AREF (map, 2)) <= op
+                              && XFIXNUM (AREF (map, 2)) <= op
                               && FIXNUMP (AREF (map, 3))
-                              && op < XINT (AREF (map, 3)))
+                              && op < XFIXNUM (AREF (map, 3)))
                             content = AREF (map, 1);
                           else
                             continue;
@@ -1578,9 +1578,9 @@ ccl_driver (struct ccl_program *ccl, int *source, int *destination, int src_size
                         continue;
 
                       reg[RRR] = i;
-                      if (FIXNUMP (content) && IN_INT_RANGE (XINT (content)))
+                      if (FIXNUMP (content) && IN_INT_RANGE (XFIXNUM (content)))
                         {
-                          op = XINT (content);
+                          op = XFIXNUM (content);
                           i += map_set_rest_length - 1;
                           ic += map_set_rest_length - 1;
                           POP_MAPPING_STACK (map_set_rest_length, reg[rrr]);
@@ -1591,9 +1591,9 @@ ccl_driver (struct ccl_program *ccl, int *source, int *destination, int src_size
                           attrib = XCAR (content);
                           value = XCDR (content);
                           if (! (FIXNUMP (attrib) && FIXNUMP (value)
-                                 && IN_INT_RANGE (XINT (value))))
+                                 && IN_INT_RANGE (XFIXNUM (value))))
                             continue;
-                          op = XINT (value);
+                          op = XFIXNUM (value);
                           i += map_set_rest_length - 1;
                           ic += map_set_rest_length - 1;
                           POP_MAPPING_STACK (map_set_rest_length, reg[rrr]);
@@ -1639,7 +1639,7 @@ ccl_driver (struct ccl_program *ccl, int *source, int *destination, int src_size
               {
                 Lisp_Object map, attrib, value, content;
                 int point;
-                j = XINT (ccl_prog[ic++]); /* map_id */
+                j = XFIXNUM (ccl_prog[ic++]); /* map_id */
                 op = reg[rrr];
                 if (! (VECTORP (Vcode_conversion_map_vector)
                        && j < ASIZE (Vcode_conversion_map_vector)))
@@ -1657,19 +1657,19 @@ ccl_driver (struct ccl_program *ccl, int *source, int *destination, int src_size
                 if (! (VECTORP (map)
                        && 0 < ASIZE (map)
                        && FIXNUMP (AREF (map, 0))
-                       && XINT (AREF (map, 0)) <= op
-                       && op - XINT (AREF (map, 0)) + 1 < ASIZE (map)))
+                       && XFIXNUM (AREF (map, 0)) <= op
+                       && op - XFIXNUM (AREF (map, 0)) + 1 < ASIZE (map)))
                   {
                     reg[RRR] = -1;
                     break;
                   }
-                point = op - XINT (AREF (map, 0)) + 1;
+                point = op - XFIXNUM (AREF (map, 0)) + 1;
                 reg[RRR] = 0;
                 content = AREF (map, point);
                 if (NILP (content))
                   reg[RRR] = -1;
                 else if (TYPE_RANGED_FIXNUMP (int, content))
-                  reg[rrr] = XINT (content);
+                  reg[rrr] = XFIXNUM (content);
                 else if (EQ (content, Qt));
                 else if (CONSP (content))
                   {
@@ -1678,7 +1678,7 @@ ccl_driver (struct ccl_program *ccl, int *source, int *destination, int src_size
                     if (!FIXNUMP (attrib)
                         || !TYPE_RANGED_FIXNUMP (int, value))
                       continue;
-                    reg[rrr] = XINT (value);
+                    reg[rrr] = XFIXNUM (value);
                     break;
                   }
                 else if (SYMBOLP (content))
@@ -1852,8 +1852,8 @@ resolve_symbol_ccl_program (Lisp_Object ccl)
       return Qnil;
     }
 
-  if (! (0 <= XINT (AREF (result, CCL_HEADER_BUF_MAG))
-         && ASCENDING_ORDER (0, XINT (AREF (result, CCL_HEADER_EOF)),
+  if (! (0 <= XFIXNUM (AREF (result, CCL_HEADER_BUF_MAG))
+         && ASCENDING_ORDER (0, XFIXNUM (AREF (result, CCL_HEADER_EOF)),
                              ASIZE (ccl))))
     return Qnil;
 
@@ -1882,14 +1882,14 @@ ccl_get_compiled_code (Lisp_Object ccl_prog, ptrdiff_t *idx)
 
   val = Fget (ccl_prog, Qccl_program_idx);
   if (! FIXNATP (val)
-      || XINT (val) >= ASIZE (Vccl_program_table))
+      || XFIXNUM (val) >= ASIZE (Vccl_program_table))
     return Qnil;
-  slot = AREF (Vccl_program_table, XINT (val));
+  slot = AREF (Vccl_program_table, XFIXNUM (val));
   if (! VECTORP (slot)
       || ASIZE (slot) != 4
       || ! VECTORP (AREF (slot, 1)))
     return Qnil;
-  *idx = XINT (val);
+  *idx = XFIXNUM (val);
   if (NILP (AREF (slot, 2)))
     {
       val = resolve_symbol_ccl_program (AREF (slot, 1));
@@ -1920,8 +1920,8 @@ setup_ccl_program (struct ccl_program *ccl, Lisp_Object ccl_prog)
       vp = XVECTOR (ccl_prog);
       ccl->size = vp->header.size;
       ccl->prog = vp->contents;
-      ccl->eof_ic = XINT (vp->contents[CCL_HEADER_EOF]);
-      ccl->buf_magnification = XINT (vp->contents[CCL_HEADER_BUF_MAG]);
+      ccl->eof_ic = XFIXNUM (vp->contents[CCL_HEADER_EOF]);
+      ccl->buf_magnification = XFIXNUM (vp->contents[CCL_HEADER_BUF_MAG]);
       if (ccl->idx >= 0)
         {
           Lisp_Object slot;
@@ -1957,7 +1957,7 @@ See the documentation of `define-ccl-program' for the detail of CCL program.  */
 
   val = Fget (object, Qccl_program_idx);
   return ((! FIXNATP (val)
-           || XINT (val) >= ASIZE (Vccl_program_table))
+           || XFIXNUM (val) >= ASIZE (Vccl_program_table))
           ? Qnil : Qt);
 }
 
@@ -1991,7 +1991,7 @@ programs.  */)
 
   for (i = 0; i < 8; i++)
     ccl.reg[i] = (TYPE_RANGED_FIXNUMP (int, AREF (reg, i))
-                  ? XINT (AREF (reg, i))
+                  ? XFIXNUM (AREF (reg, i))
                   : 0);
 
   ccl_driver (&ccl, NULL, NULL, 0, 0, Qnil);
@@ -2060,11 +2060,11 @@ usage: (ccl-execute-on-string CCL-PROGRAM STATUS STRING &optional CONTINUE UNIBY
       if (NILP (AREF (status, i)))
         ASET (status, i, make_fixnum (0));
       if (TYPE_RANGED_FIXNUMP (int, AREF (status, i)))
-        ccl.reg[i] = XINT (AREF (status, i));
+        ccl.reg[i] = XFIXNUM (AREF (status, i));
     }
   if (FIXNUMP (AREF (status, i)))
     {
-      i = XFASTINT (AREF (status, 8));
+      i = XFIXNAT (AREF (status, 8));
       if (ccl.ic < i && i < ccl.size)
         ccl.ic = i;
     }
diff --git a/src/character.c b/src/character.c
index f9b32e7a5b2..97698d77890 100644
--- a/src/character.c
+++ b/src/character.c
@@ -206,7 +206,7 @@ translate_char (Lisp_Object table, int c)
 
       ch = CHAR_TABLE_REF (table, c);
       if (CHARACTERP (ch))
-        c = XINT (ch);
+        c = XFIXNUM (ch);
     }
   else
     {
@@ -244,7 +244,7 @@ DEFUN ("unibyte-char-to-multibyte", Funibyte_char_to_multibyte,
   int c;
 
   CHECK_CHARACTER (ch);
-  c = XFASTINT (ch);
+  c = XFIXNAT (ch);
   if (c >= 0x100)
     error ("Not a unibyte character: %d", c);
   MAKE_CHAR_MULTIBYTE (c);
@@ -260,7 +260,7 @@ If the multibyte character does not represent a byte, return -1.  */)
   int cm;
 
   CHECK_CHARACTER (ch);
-  cm = XFASTINT (ch);
+  cm = XFIXNAT (ch);
   if (cm < 256)
     /* Can't distinguish a byte read from a unibyte buffer from
        a latin1 char, so let's let it slide.  */
@@ -291,7 +291,7 @@ char_width (int c, struct Lisp_Char_Table *dp)
             ch = AREF (disp, i);
             if (CHARACTERP (ch))
               {
-                int w = CHARACTER_WIDTH (XFASTINT (ch));
+                int w = CHARACTER_WIDTH (XFIXNAT (ch));
                 if (INT_ADD_WRAPV (width, w, &width))
                   string_overflow ();
               }
@@ -312,7 +312,7 @@ usage: (char-width CHAR)  */)
   ptrdiff_t width;
 
   CHECK_CHARACTER (ch);
-  c = XINT (ch);
+  c = XFIXNUM (ch);
   width = char_width (c, buffer_display_table ());
   return make_fixnum (width);
 }
@@ -855,7 +855,7 @@ usage: (string &rest CHARACTERS)  */)
   for (i = 0; i < n; i++)
     {
       CHECK_CHARACTER (args[i]);
-      c = XINT (args[i]);
+      c = XFIXNUM (args[i]);
       p += CHAR_STRING (c, p);
     }
 
@@ -878,7 +878,7 @@ usage: (unibyte-string &rest BYTES)  */)
   for (i = 0; i < n; i++)
     {
       CHECK_RANGED_INTEGER (args[i], 0, 255);
-      *p++ = XINT (args[i]);
+      *p++ = XFIXNUM (args[i]);
     }
 
   str = make_string_from_bytes ((char *) buf, n, p - buf);
@@ -897,7 +897,7 @@ usage: (char-resolve-modifiers CHAR)  */)
   EMACS_INT c;
 
   CHECK_FIXNUM (character);
-  c = XINT (character);
+  c = XFIXNUM (character);
   return make_fixnum (char_resolve_modifier_mask (c));
 }
 
@@ -926,9 +926,9 @@ character is not ASCII nor 8-bit character, an error is signaled.  */)
       else
         {
           CHECK_FIXNUM_COERCE_MARKER (position);
-          if (XINT (position) < BEGV || XINT (position) >= ZV)
+          if (XFIXNUM (position) < BEGV || XFIXNUM (position) >= ZV)
             args_out_of_range_3 (position, make_fixnum (BEGV), make_fixnum (ZV));
-          pos = XFASTINT (position);
+          pos = XFIXNAT (position);
           p = CHAR_POS_ADDR (pos);
         }
       if (NILP (BVAR (current_buffer, enable_multibyte_characters)))
@@ -944,9 +944,9 @@ character is not ASCII nor 8-bit character, an error is signaled.  */)
       else
         {
           CHECK_FIXNAT (position);
-          if (XINT (position) >= SCHARS (string))
+          if (XFIXNUM (position) >= SCHARS (string))
             args_out_of_range (string, position);
-          pos = XFASTINT (position);
+          pos = XFIXNAT (position);
           p = SDATA (string) + string_char_to_byte (string, pos);
         }
       if (! STRING_MULTIBYTE (string))
@@ -967,7 +967,7 @@ alphabeticp (int c)
   Lisp_Object category = CHAR_TABLE_REF (Vunicode_category_table, c);
   if (! FIXNUMP (category))
     return false;
-  EMACS_INT gen_cat = XINT (category);
+  EMACS_INT gen_cat = XFIXNUM (category);
 
   /* See UTS #18.  There are additional characters that should be
      here, those designated as Other_uppercase, Other_lowercase,
@@ -990,7 +990,7 @@ alphanumericp (int c)
   Lisp_Object category = CHAR_TABLE_REF (Vunicode_category_table, c);
   if (! FIXNUMP (category))
     return false;
-  EMACS_INT gen_cat = XINT (category);
+  EMACS_INT gen_cat = XFIXNUM (category);
 
   /* See UTS #18.  Same comment as for alphabeticp applies.  FIXME. */
   return (gen_cat == UNICODE_CATEGORY_Lu
@@ -1012,7 +1012,7 @@ graphicp (int c)
   Lisp_Object category = CHAR_TABLE_REF (Vunicode_category_table, c);
   if (! FIXNUMP (category))
     return false;
-  EMACS_INT gen_cat = XINT (category);
+  EMACS_INT gen_cat = XFIXNUM (category);
 
   /* See UTS #18.  */
   return (!(gen_cat == UNICODE_CATEGORY_Zs /* space separator */
@@ -1030,7 +1030,7 @@ printablep (int c)
   Lisp_Object category = CHAR_TABLE_REF (Vunicode_category_table, c);
   if (! FIXNUMP (category))
     return false;
-  EMACS_INT gen_cat = XINT (category);
+  EMACS_INT gen_cat = XFIXNUM (category);
 
   /* See UTS #18.  */
   return (!(gen_cat == UNICODE_CATEGORY_Cc /* control */
@@ -1047,7 +1047,7 @@ blankp (int c)
   if (! FIXNUMP (category))
     return false;
 
-  return XINT (category) == UNICODE_CATEGORY_Zs; /* separator, space */
+  return XFIXNUM (category) == UNICODE_CATEGORY_Zs; /* separator, space */
 }
 
 
diff --git a/src/character.h b/src/character.h
index 78b84870f52..5dff85aed47 100644
--- a/src/character.h
+++ b/src/character.h
@@ -123,7 +123,7 @@ enum
 #define MAX_MULTIBYTE_LENGTH 5
 
 /* Nonzero iff X is a character.  */
-#define CHARACTERP(x) (FIXNATP (x) && XFASTINT (x) <= MAX_CHAR)
+#define CHARACTERP(x) (FIXNATP (x) && XFIXNAT (x) <= MAX_CHAR)
 
 /* Nonzero iff C is valid as a character code.  */
 #define CHAR_VALID_P(c) UNSIGNED_CMP (c, <=, MAX_CHAR)
@@ -559,7 +559,7 @@ enum
 /* Return a non-outlandish value for the tab width.  */
 
 #define SANE_TAB_WIDTH(buf) \
-  sanitize_tab_width (XFASTINT (BVAR (buf, tab_width)))
+  sanitize_tab_width (XFIXNAT (BVAR (buf, tab_width)))
 INLINE int
 sanitize_tab_width (EMACS_INT width)
 {
@@ -595,7 +595,7 @@ sanitize_char_width (EMACS_INT width)
 #define CHARACTER_WIDTH(c)      \
   (ASCII_CHAR_P (c)             \
    ? ASCII_CHAR_WIDTH (c)       \
-   : sanitize_char_width (XINT (CHAR_TABLE_REF (Vchar_width_table, c))))
+   : sanitize_char_width (XFIXNUM (CHAR_TABLE_REF (Vchar_width_table, c))))
 
 /* If C is a variation selector, return the index of the
    variation selector (1..256).  Otherwise, return 0.  */
@@ -700,7 +700,7 @@ char_table_translate (Lisp_Object obj, int ch)
   eassert (CHAR_VALID_P (ch));
   eassert (CHAR_TABLE_P (obj));
   obj = CHAR_TABLE_REF (obj, ch);
-  return CHARACTERP (obj) ? XINT (obj) : ch;
+  return CHARACTERP (obj) ? XFIXNUM (obj) : ch;
 }
 
 #if defined __GNUC__ && !defined __STRICT_ANSI__
diff --git a/src/charset.c b/src/charset.c
index 8d957abeb54..e77a3900b8b 100644
--- a/src/charset.c
+++ b/src/charset.c
@@ -587,14 +587,14 @@ load_charset_map_from_vector (struct charset *charset, Lisp_Object vec, int cont
         {
           val2 = XCDR (val);
           val = XCAR (val);
-          from = XFASTINT (val);
-          to = XFASTINT (val2);
+          from = XFIXNAT (val);
+          to = XFIXNAT (val2);
         }
       else
-        from = to = XFASTINT (val);
+        from = to = XFIXNAT (val);
       val = AREF (vec, i + 1);
       CHECK_FIXNAT (val);
-      c = XFASTINT (val);
+      c = XFIXNAT (val);
 
       if (from < min_code || to > max_code || from > to || c > MAX_CHAR)
         continue;
@@ -757,14 +757,14 @@ map_charset_chars (void (*c_function)(Lisp_Object, Lisp_Object), Lisp_Object fun
       int offset;
 
       subset_info = CHARSET_SUBSET (charset);
-      charset = CHARSET_FROM_ID (XFASTINT (AREF (subset_info, 0)));
-      offset = XINT (AREF (subset_info, 3));
+      charset = CHARSET_FROM_ID (XFIXNAT (AREF (subset_info, 0)));
+      offset = XFIXNUM (AREF (subset_info, 3));
       from -= offset;
-      if (from < XFASTINT (AREF (subset_info, 1)))
-        from = XFASTINT (AREF (subset_info, 1));
+      if (from < XFIXNAT (AREF (subset_info, 1)))
+        from = XFIXNAT (AREF (subset_info, 1));
       to -= offset;
-      if (to > XFASTINT (AREF (subset_info, 2)))
-        to = XFASTINT (AREF (subset_info, 2));
+      if (to > XFIXNAT (AREF (subset_info, 2)))
+        to = XFIXNAT (AREF (subset_info, 2));
       map_charset_chars (c_function, function, arg, charset, from, to);
     }
   else                          /* i.e. CHARSET_METHOD_SUPERSET */
@@ -777,8 +777,8 @@ map_charset_chars (void (*c_function)(Lisp_Object, Lisp_Object), Lisp_Object fun
           int offset;
           unsigned this_from, this_to;
 
-          charset = CHARSET_FROM_ID (XFASTINT (XCAR (XCAR (parents))));
-          offset = XINT (XCDR (XCAR (parents)));
+          charset = CHARSET_FROM_ID (XFIXNAT (XCAR (XCAR (parents))));
+          offset = XFIXNUM (XCDR (XCAR (parents)));
           this_from = from > offset ? from - offset : 0;
           this_to = to > offset ? to - offset : 0;
           if (this_from < CHARSET_MIN_CODE (charset))
@@ -811,7 +811,7 @@ range of code points (in CHARSET) of target characters.  */)
     from = CHARSET_MIN_CODE (cs);
   else
     {
-      from = XINT (from_code);
+      from = XFIXNUM (from_code);
       if (from < CHARSET_MIN_CODE (cs))
         from = CHARSET_MIN_CODE (cs);
     }
@@ -819,7 +819,7 @@ range of code points (in CHARSET) of target characters.  */)
     to = CHARSET_MAX_CODE (cs);
   else
     {
-      to = XINT (to_code);
+      to = XFIXNUM (to_code);
       if (to > CHARSET_MAX_CODE (cs))
         to = CHARSET_MAX_CODE (cs);
     }
@@ -870,9 +870,9 @@ usage: (define-charset-internal ...)  */)
       min_byte_obj = Faref (val, make_fixnum (i * 2));
       max_byte_obj = Faref (val, make_fixnum (i * 2 + 1));
       CHECK_RANGED_INTEGER (min_byte_obj, 0, 255);
-      min_byte = XINT (min_byte_obj);
+      min_byte = XFIXNUM (min_byte_obj);
       CHECK_RANGED_INTEGER (max_byte_obj, min_byte, 255);
-      max_byte = XINT (max_byte_obj);
+      max_byte = XFIXNUM (max_byte_obj);
       charset.code_space[i * 4] = min_byte;
       charset.code_space[i * 4 + 1] = max_byte;
       charset.code_space[i * 4 + 2] = max_byte - min_byte + 1;
@@ -890,7 +890,7 @@ usage: (define-charset-internal ...)  */)
   else
     {
       CHECK_RANGED_INTEGER (val, 1, 4);
-      charset.dimension = XINT (val);
+      charset.dimension = XFIXNUM (val);
     }
 
   charset.code_linear_p
@@ -971,9 +971,9 @@ usage: (define-charset-internal ...)  */)
   else
     {
       CHECK_FIXNUM (val);
-      if (XINT (val) < '0' || XINT (val) > 127)
-        error ("Invalid iso-final-char: %"pI"d", XINT (val));
-      charset.iso_final = XINT (val);
+      if (XFIXNUM (val) < '0' || XFIXNUM (val) > 127)
+        error ("Invalid iso-final-char: %"pI"d", XFIXNUM (val));
+      charset.iso_final = XFIXNUM (val);
     }
 
   val = args[charset_arg_iso_revision];
@@ -982,7 +982,7 @@ usage: (define-charset-internal ...)  */)
   else
     {
       CHECK_RANGED_INTEGER (val, -1, 63);
-      charset.iso_revision = XINT (val);
+      charset.iso_revision = XFIXNUM (val);
     }
 
   val = args[charset_arg_emacs_mule_id];
@@ -991,9 +991,9 @@ usage: (define-charset-internal ...)  */)
   else
     {
       CHECK_FIXNAT (val);
-      if ((XINT (val) > 0 && XINT (val) <= 128) || XINT (val) >= 256)
-        error ("Invalid emacs-mule-id: %"pI"d", XINT (val));
-      charset.emacs_mule_id = XINT (val);
+      if ((XFIXNUM (val) > 0 && XFIXNUM (val) <= 128) || XFIXNUM (val) >= 256)
+        error ("Invalid emacs-mule-id: %"pI"d", XFIXNUM (val));
+      charset.emacs_mule_id = XFIXNUM (val);
     }
 
   charset.ascii_compatible_p = ! NILP (args[charset_arg_ascii_compatible_p]);
@@ -1010,7 +1010,7 @@ usage: (define-charset-internal ...)  */)
       CHECK_CHARACTER (val);
 
       charset.method = CHARSET_METHOD_OFFSET;
-      charset.code_offset = XINT (val);
+      charset.code_offset = XFIXNUM (val);
 
       i = CODE_POINT_TO_INDEX (&charset, charset.max_code);
       if (MAX_CHAR - charset.code_offset < i)
@@ -1089,7 +1089,7 @@ usage: (define-charset-internal ...)  */)
               cdr_part = XCDR (elt);
               CHECK_CHARSET_GET_ID (car_part, this_id);
               CHECK_TYPE_RANGED_INTEGER (int, cdr_part);
-              offset = XINT (cdr_part);
+              offset = XFIXNUM (cdr_part);
             }
           else
             {
@@ -1123,7 +1123,7 @@ usage: (define-charset-internal ...)  */)
   if (charset.hash_index >= 0)
     {
       new_definition_p = 0;
-      id = XFASTINT (CHARSET_SYMBOL_ID (args[charset_arg_name]));
+      id = XFIXNAT (CHARSET_SYMBOL_ID (args[charset_arg_name]));
       set_hash_value_slot (hash_table, charset.hash_index, attrs);
     }
   else
@@ -1209,7 +1209,7 @@ usage: (define-charset-internal ...)  */)
 
           for (tail = Vcharset_ordered_list; CONSP (tail); tail = XCDR (tail))
             {
-              struct charset *cs = CHARSET_FROM_ID (XINT (XCAR (tail)));
+              struct charset *cs = CHARSET_FROM_ID (XFIXNUM (XCAR (tail)));
 
               if (cs->supplementary_p)
                 break;
@@ -1293,7 +1293,7 @@ define_charset_internal (Lisp_Object name,
            args[charset_arg_code_offset]);
   Fdefine_charset_internal (charset_arg_max, args);
 
-  return XINT (CHARSET_SYMBOL_ID (name));
+  return XFIXNUM (CHARSET_SYMBOL_ID (name));
 }
 
 
@@ -1400,15 +1400,15 @@ check_iso_charset_parameter (Lisp_Object dimension, Lisp_Object chars,
   CHECK_FIXNUM (chars);
   CHECK_CHARACTER (final_char);
 
-  if (! (1 <= XINT (dimension) && XINT (dimension) <= 3))
+  if (! (1 <= XFIXNUM (dimension) && XFIXNUM (dimension) <= 3))
     error ("Invalid DIMENSION %"pI"d, it should be 1, 2, or 3",
-           XINT (dimension));
+           XFIXNUM (dimension));
 
-  bool chars_flag = XINT (chars) == 96;
-  if (! (chars_flag || XINT (chars) == 94))
-    error ("Invalid CHARS %"pI"d, it should be 94 or 96", XINT (chars));
+  bool chars_flag = XFIXNUM (chars) == 96;
+  if (! (chars_flag || XFIXNUM (chars) == 94))
+    error ("Invalid CHARS %"pI"d, it should be 94 or 96", XFIXNUM (chars));
 
-  int final_ch = XFASTINT (final_char);
+  int final_ch = XFIXNAT (final_char);
   if (! ('0' <= final_ch && final_ch <= '~'))
     error ("Invalid FINAL-CHAR `%c', it should be `0'..`~'", final_ch);
 
@@ -1430,7 +1430,7 @@ return nil.  */)
   bool chars_flag = check_iso_charset_parameter (dimension, chars,
                                                  make_fixnum ('0'));
   for (int final_char = '0'; final_char <= '?'; final_char++)
-    if (ISO_CHARSET_TABLE (XINT (dimension), chars_flag, final_char) < 0)
+    if (ISO_CHARSET_TABLE (XFIXNUM (dimension), chars_flag, final_char) < 0)
       return make_fixnum (final_char);
   return Qnil;
 }
@@ -1449,7 +1449,7 @@ if CHARSET is designated instead.  */)
 
   CHECK_CHARSET_GET_ID (charset, id);
   bool chars_flag = check_iso_charset_parameter (dimension, chars, final_char);
-  ISO_CHARSET_TABLE (XINT (dimension), chars_flag, XFASTINT (final_char)) = id;
+  ISO_CHARSET_TABLE (XFIXNUM (dimension), chars_flag, XFIXNAT (final_char)) = id;
   return Qnil;
 }
 
@@ -1550,8 +1550,8 @@ only `ascii', `eight-bit-control', and `eight-bit-graphic'.  */)
   bool multibyte = ! NILP (BVAR (current_buffer, enable_multibyte_characters));
 
   validate_region (&beg, &end);
-  from = XFASTINT (beg);
-  stop = to = XFASTINT (end);
+  from = XFIXNAT (beg);
+  stop = to = XFIXNAT (end);
 
   if (from < GPT && GPT < to)
     {
@@ -1622,7 +1622,7 @@ maybe_unify_char (int c, Lisp_Object val)
   struct charset *charset;
 
   if (FIXNUMP (val))
-    return XFASTINT (val);
+    return XFIXNAT (val);
   if (NILP (val))
     return c;
 
@@ -1638,7 +1638,7 @@ maybe_unify_char (int c, Lisp_Object val)
     {
       val = CHAR_TABLE_REF (Vchar_unify_table, c);
       if (! NILP (val))
-        c = XFASTINT (val);
+        c = XFIXNAT (val);
     }
   else
     {
@@ -1672,10 +1672,10 @@ decode_char (struct charset *charset, unsigned int code)
       Lisp_Object subset_info;
 
       subset_info = CHARSET_SUBSET (charset);
-      charset = CHARSET_FROM_ID (XFASTINT (AREF (subset_info, 0)));
-      code -= XINT (AREF (subset_info, 3));
-      if (code < XFASTINT (AREF (subset_info, 1))
-          || code > XFASTINT (AREF (subset_info, 2)))
+      charset = CHARSET_FROM_ID (XFIXNAT (AREF (subset_info, 0)));
+      code -= XFIXNUM (AREF (subset_info, 3));
+      if (code < XFIXNAT (AREF (subset_info, 1))
+          || code > XFIXNAT (AREF (subset_info, 2)))
         c = -1;
       else
         c = DECODE_CHAR (charset, code);
@@ -1688,8 +1688,8 @@ decode_char (struct charset *charset, unsigned int code)
       c = -1;
       for (; CONSP (parents); parents = XCDR (parents))
         {
-          int id = XINT (XCAR (XCAR (parents)));
-          int code_offset = XINT (XCDR (XCAR (parents)));
+          int id = XFIXNUM (XCAR (XCAR (parents)));
+          int code_offset = XFIXNUM (XCDR (XCAR (parents)));
           unsigned this_code = code - code_offset;
 
           charset = CHARSET_FROM_ID (id);
@@ -1714,7 +1714,7 @@ decode_char (struct charset *charset, unsigned int code)
               decoder = CHARSET_DECODER (charset);
             }
           if (VECTORP (decoder))
-            c = XINT (AREF (decoder, char_index));
+            c = XFIXNUM (AREF (decoder, char_index));
           else
             c = GET_TEMP_CHARSET_WORK_DECODER (char_index);
         }
@@ -1763,7 +1763,7 @@ encode_char (struct charset *charset, int c)
           Lisp_Object deunified = CHAR_TABLE_REF (deunifier, c);
 
           if (FIXNUMP (deunified))
-            code_index = XINT (deunified);
+            code_index = XFIXNUM (deunified);
         }
       else
         {
@@ -1779,13 +1779,13 @@ encode_char (struct charset *charset, int c)
       struct charset *this_charset;
 
       subset_info = CHARSET_SUBSET (charset);
-      this_charset = CHARSET_FROM_ID (XFASTINT (AREF (subset_info, 0)));
+      this_charset = CHARSET_FROM_ID (XFIXNAT (AREF (subset_info, 0)));
       code = ENCODE_CHAR (this_charset, c);
       if (code == CHARSET_INVALID_CODE (this_charset)
-          || code < XFASTINT (AREF (subset_info, 1))
-          || code > XFASTINT (AREF (subset_info, 2)))
+          || code < XFIXNAT (AREF (subset_info, 1))
+          || code > XFIXNAT (AREF (subset_info, 2)))
         return CHARSET_INVALID_CODE (charset);
-      code += XINT (AREF (subset_info, 3));
+      code += XFIXNUM (AREF (subset_info, 3));
       return code;
     }
 
@@ -1796,8 +1796,8 @@ encode_char (struct charset *charset, int c)
       parents = CHARSET_SUPERSET (charset);
       for (; CONSP (parents); parents = XCDR (parents))
         {
-          int id = XINT (XCAR (XCAR (parents)));
-          int code_offset = XINT (XCDR (XCAR (parents)));
+          int id = XFIXNUM (XCAR (XCAR (parents)));
+          int code_offset = XFIXNUM (XCDR (XCAR (parents)));
           struct charset *this_charset = CHARSET_FROM_ID (id);
 
           code = ENCODE_CHAR (this_charset, c);
@@ -1827,7 +1827,7 @@ encode_char (struct charset *charset, int c)
           val = CHAR_TABLE_REF (encoder, c);
           if (NILP (val))
             return CHARSET_INVALID_CODE (charset);
-          code = XINT (val);
+          code = XFIXNUM (val);
           if (! CHARSET_COMPACT_CODES_P (charset))
             code = INDEX_TO_CODE_POINT (charset, code);
         }
@@ -1878,7 +1878,7 @@ Return nil if CHARSET doesn't include CH.  */)
 
   CHECK_CHARSET_GET_ID (charset, id);
   CHECK_CHARACTER (ch);
-  c = XFASTINT (ch);
+  c = XFIXNAT (ch);
   charsetp = CHARSET_FROM_ID (id);
   code = ENCODE_CHAR (charsetp, c);
   if (code == CHARSET_INVALID_CODE (charsetp))
@@ -1911,9 +1911,9 @@ is specified.  */)
   else
     {
       CHECK_FIXNAT (code1);
-      if (XFASTINT (code1) >= 0x100)
+      if (XFIXNAT (code1) >= 0x100)
         args_out_of_range (make_fixnum (0xFF), code1);
-      code = XFASTINT (code1);
+      code = XFIXNAT (code1);
 
       if (dimension > 1)
         {
@@ -1923,9 +1923,9 @@ is specified.  */)
           else
             {
               CHECK_FIXNAT (code2);
-              if (XFASTINT (code2) >= 0x100)
+              if (XFIXNAT (code2) >= 0x100)
                 args_out_of_range (make_fixnum (0xFF), code2);
-              code |= XFASTINT (code2);
+              code |= XFIXNAT (code2);
             }
 
           if (dimension > 2)
@@ -1936,9 +1936,9 @@ is specified.  */)
               else
                 {
                   CHECK_FIXNAT (code3);
-                  if (XFASTINT (code3) >= 0x100)
+                  if (XFIXNAT (code3) >= 0x100)
                     args_out_of_range (make_fixnum (0xFF), code3);
-                  code |= XFASTINT (code3);
+                  code |= XFIXNAT (code3);
                 }
 
               if (dimension > 3)
@@ -1949,9 +1949,9 @@ is specified.  */)
                   else
                     {
                       CHECK_FIXNAT (code4);
-                      if (XFASTINT (code4) >= 0x100)
+                      if (XFIXNAT (code4) >= 0x100)
                         args_out_of_range (make_fixnum (0xFF), code4);
-                      code |= XFASTINT (code4);
+                      code |= XFIXNAT (code4);
                     }
                 }
             }
@@ -1983,7 +1983,7 @@ char_charset (int c, Lisp_Object charset_list, unsigned int *code_return)
 
   while (CONSP (charset_list))
     {
-      struct charset *charset = CHARSET_FROM_ID (XINT (XCAR (charset_list)));
+      struct charset *charset = CHARSET_FROM_ID (XFIXNUM (XCAR (charset_list)));
       unsigned code = ENCODE_CHAR (charset, c);
 
       if (code != CHARSET_INVALID_CODE (charset))
@@ -2018,7 +2018,7 @@ CH in the charset.  */)
   Lisp_Object val;
 
   CHECK_CHARACTER (ch);
-  c = XFASTINT (ch);
+  c = XFIXNAT (ch);
   charset = CHAR_CHARSET (c);
   if (! charset)
     emacs_abort ();
@@ -2048,12 +2048,12 @@ that case, find the charset from what supported by that coding system.  */)
 
   CHECK_CHARACTER (ch);
   if (NILP (restriction))
-    charset = CHAR_CHARSET (XINT (ch));
+    charset = CHAR_CHARSET (XFIXNUM (ch));
   else
     {
       if (CONSP (restriction))
         {
-          int c = XFASTINT (ch);
+          int c = XFIXNAT (ch);
 
           for (; CONSP (restriction); restriction = XCDR (restriction))
             {
@@ -2066,7 +2066,7 @@ that case, find the charset from what supported by that coding system.  */)
           return Qnil;
         }
       restriction = coding_system_charset_list (restriction);
-      charset = char_charset (XINT (ch), restriction, NULL);
+      charset = char_charset (XFIXNUM (ch), restriction, NULL);
       if (! charset)
         return Qnil;
     }
@@ -2087,7 +2087,7 @@ If POS is out of range, the value is nil.  */)
   ch = Fchar_after (pos);
   if (! FIXNUMP (ch))
     return ch;
-  charset = CHAR_CHARSET (XINT (ch));
+  charset = CHAR_CHARSET (XFIXNUM (ch));
   return (CHARSET_NAME (charset));
 }
 
@@ -2104,8 +2104,8 @@ DIMENSION, CHARS, and FINAL-CHAR.  */)
   (Lisp_Object dimension, Lisp_Object chars, Lisp_Object final_char)
 {
   bool chars_flag = check_iso_charset_parameter (dimension, chars, final_char);
-  int id = ISO_CHARSET_TABLE (XINT (dimension), chars_flag,
-                              XFASTINT (final_char));
+  int id = ISO_CHARSET_TABLE (XFIXNUM (dimension), chars_flag,
+                              XFIXNAT (final_char));
   return (id >= 0 ? CHARSET_NAME (CHARSET_FROM_ID (id)) : Qnil);
 }
 
@@ -2139,11 +2139,11 @@ HIGHESTP non-nil means just return the highest priority one.  */)
   Lisp_Object val = Qnil, list = Vcharset_ordered_list;
 
   if (!NILP (highestp))
-    return CHARSET_NAME (CHARSET_FROM_ID (XINT (Fcar (list))));
+    return CHARSET_NAME (CHARSET_FROM_ID (XFIXNUM (Fcar (list))));
 
   while (!NILP (list))
     {
-      val = Fcons (CHARSET_NAME (CHARSET_FROM_ID (XINT (XCAR (list)))), val);
+      val = Fcons (CHARSET_NAME (CHARSET_FROM_ID (XFIXNUM (XCAR (list)))), val);
       list = XCDR (list);
     }
   return Fnreverse (val);
@@ -2186,7 +2186,7 @@ usage: (set-charset-priority &rest charsets)  */)
         list_emacs_mule = Fcons (XCAR (old_list), list_emacs_mule);
       if (charset_unibyte < 0)
         {
-          struct charset *charset = CHARSET_FROM_ID (XINT (XCAR (old_list)));
+          struct charset *charset = CHARSET_FROM_ID (XFIXNUM (XCAR (old_list)));
 
           if (CHARSET_DIMENSION (charset) == 1
               && CHARSET_ASCII_COMPATIBLE_P (charset)
@@ -2237,7 +2237,7 @@ See also `charset-priority-list' and `set-charset-priority'.  */)
      (Lisp_Object charsets)
 {
   Lisp_Object len = Flength (charsets);
-  ptrdiff_t n = XFASTINT (len), i, j;
+  ptrdiff_t n = XFIXNAT (len), i, j;
   int done;
   Lisp_Object tail, elt, attrs;
   struct charset_sort_data *sort_data;
@@ -2252,7 +2252,7 @@ See also `charset-priority-list' and `set-charset-priority'.  */)
       elt = XCAR (tail);
       CHECK_CHARSET_GET_ATTR (elt, attrs);
       sort_data[i].charset = elt;
-      sort_data[i].id = id = XINT (CHARSET_ATTR_ID (attrs));
+      sort_data[i].id = id = XFIXNUM (CHARSET_ATTR_ID (attrs));
       if (id < min_id)
         min_id = id;
       if (id > max_id)
@@ -2262,7 +2262,7 @@ See also `charset-priority-list' and `set-charset-priority'.  */)
        done < n && CONSP (tail); tail = XCDR (tail), i++)
     {
       elt = XCAR (tail);
-      id = XFASTINT (elt);
+      id = XFIXNAT (elt);
       if (id >= min_id && id <= max_id)
         for (j = 0; j < n; j++)
           if (sort_data[j].id == id)
diff --git a/src/charset.h b/src/charset.h
index 8832af40d4f..7b85a1a4e31 100644
--- a/src/charset.h
+++ b/src/charset.h
@@ -355,7 +355,7 @@ set_charset_attr (struct charset *charset, enum charset_attr_index idx,
                                                                         \
     if (! SYMBOLP (x) || (idx = CHARSET_SYMBOL_HASH_INDEX (x)) < 0)     \
       wrong_type_argument (Qcharsetp, (x));                             \
-    id = XINT (AREF (HASH_VALUE (XHASH_TABLE (Vcharset_hash_table), idx), \
+    id = XFIXNUM (AREF (HASH_VALUE (XHASH_TABLE (Vcharset_hash_table), idx), \
                      charset_id));                                      \
   } while (false)
 
@@ -416,7 +416,7 @@ extern Lisp_Object Vchar_charset_set;
    : (charset)->method == CHARSET_METHOD_MAP                            \
    ? (((charset)->code_linear_p                                         \
        && VECTORP (CHARSET_DECODER (charset)))                          \
-      ? XINT (AREF (CHARSET_DECODER (charset),                          \
+      ? XFIXNUM (AREF (CHARSET_DECODER (charset),                               \
                     (code) - (charset)->min_code))                      \
       : decode_char ((charset), (code)))                                \
    : decode_char ((charset), (code)))
@@ -447,7 +447,7 @@ extern Lisp_Object charset_work;
         ? (charset_work = CHAR_TABLE_REF (CHARSET_ENCODER (charset), c), \
            (NILP (charset_work)                                         \
             ? (charset)->invalid_code                                   \
-            : (unsigned) XFASTINT (charset_work)))                      \
+            : (unsigned) XFIXNAT (charset_work)))                       \
         : encode_char (charset, c))                                     \
      : encode_char (charset, c))))
 
diff --git a/src/chartab.c b/src/chartab.c
index f09e9738a5d..0383a84a04d 100644
--- a/src/chartab.c
+++ b/src/chartab.c
@@ -119,9 +119,9 @@ the char-table has no extra slot.  */)
   else
     {
       CHECK_FIXNAT (n);
-      if (XINT (n) > 10)
+      if (XFIXNUM (n) > 10)
         args_out_of_range (n, Qnil);
-      n_extras = XINT (n);
+      n_extras = XFIXNUM (n);
     }
 
   size = CHAR_TABLE_STANDARD_SLOTS + n_extras;
@@ -572,11 +572,11 @@ DEFUN ("char-table-extra-slot", Fchar_table_extra_slot, Schar_table_extra_slot,
 {
   CHECK_CHAR_TABLE (char_table);
   CHECK_FIXNUM (n);
-  if (XINT (n) < 0
-      || XINT (n) >= CHAR_TABLE_EXTRA_SLOTS (XCHAR_TABLE (char_table)))
+  if (XFIXNUM (n) < 0
+      || XFIXNUM (n) >= CHAR_TABLE_EXTRA_SLOTS (XCHAR_TABLE (char_table)))
     args_out_of_range (char_table, n);
 
-  return XCHAR_TABLE (char_table)->extras[XINT (n)];
+  return XCHAR_TABLE (char_table)->extras[XFIXNUM (n)];
 }
 
 DEFUN ("set-char-table-extra-slot", Fset_char_table_extra_slot,
@@ -587,11 +587,11 @@ DEFUN ("set-char-table-extra-slot", Fset_char_table_extra_slot,
 {
   CHECK_CHAR_TABLE (char_table);
   CHECK_FIXNUM (n);
-  if (XINT (n) < 0
-      || XINT (n) >= CHAR_TABLE_EXTRA_SLOTS (XCHAR_TABLE (char_table)))
+  if (XFIXNUM (n) < 0
+      || XFIXNUM (n) >= CHAR_TABLE_EXTRA_SLOTS (XCHAR_TABLE (char_table)))
     args_out_of_range (char_table, n);
 
-  set_char_table_extras (char_table, XINT (n), value);
+  set_char_table_extras (char_table, XFIXNUM (n), value);
   return value;
 }
 
@@ -608,15 +608,15 @@ a cons of character codes (for characters in the range), or a character code.  *
   if (EQ (range, Qnil))
     val = XCHAR_TABLE (char_table)->defalt;
   else if (CHARACTERP (range))
-    val = CHAR_TABLE_REF (char_table, XFASTINT (range));
+    val = CHAR_TABLE_REF (char_table, XFIXNAT (range));
   else if (CONSP (range))
     {
       int from, to;
 
       CHECK_CHARACTER_CAR (range);
       CHECK_CHARACTER_CDR (range);
-      from = XFASTINT (XCAR (range));
-      to = XFASTINT (XCDR (range));
+      from = XFIXNAT (XCAR (range));
+      to = XFIXNAT (XCDR (range));
       val = char_table_ref_and_range (char_table, from, &from, &to);
       /* Not yet implemented. */
     }
@@ -645,13 +645,13 @@ or a character code.  Return VALUE.  */)
   else if (EQ (range, Qnil))
     set_char_table_defalt (char_table, value);
   else if (CHARACTERP (range))
-    char_table_set (char_table, XINT (range), value);
+    char_table_set (char_table, XFIXNUM (range), value);
   else if (CONSP (range))
     {
       CHECK_CHARACTER_CAR (range);
       CHECK_CHARACTER_CDR (range);
       char_table_set_range (char_table,
-                            XINT (XCAR (range)), XINT (XCDR (range)), value);
+                            XFIXNUM (XCAR (range)), XFIXNUM (XCDR (range)), value);
     }
   else
     error ("Invalid RANGE argument to `set-char-table-range'");
@@ -742,7 +742,7 @@ map_sub_char_table (void (*c_function) (Lisp_Object, Lisp_Object, Lisp_Object),
   int min_char, max_char;
   /* Number of characters covered by one element of TABLE.  */
   int chars_in_block;
-  int from = XINT (XCAR (range)), to = XINT (XCDR (range));
+  int from = XFIXNUM (XCAR (range)), to = XFIXNUM (XCDR (range));
   int i, c;
   bool is_uniprop = UNIPROP_TABLE_P (top);
   uniprop_decoder_t decoder = UNIPROP_GET_DECODER (top);
@@ -878,7 +878,7 @@ map_char_table (void (*c_function) (Lisp_Object, Lisp_Object, Lisp_Object),
   while (NILP (val) && ! NILP (XCHAR_TABLE (table)->parent))
     {
       Lisp_Object temp;
-      int from = XINT (XCAR (range));
+      int from = XFIXNUM (XCAR (range));
 
       parent = XCHAR_TABLE (table)->parent;
       temp = XCHAR_TABLE (parent)->parent;
@@ -1174,8 +1174,8 @@ uniprop_decode_value_run_length (Lisp_Object table, Lisp_Object value)
     {
       Lisp_Object valvec = XCHAR_TABLE (table)->extras[4];
 
-      if (XINT (value) >= 0 && XINT (value) < ASIZE (valvec))
-        value = AREF (valvec, XINT (value));
+      if (XFIXNUM (value) >= 0 && XFIXNUM (value) < ASIZE (valvec))
+        value = AREF (valvec, XFIXNUM (value));
     }
   return value;
 }
@@ -1194,7 +1194,7 @@ uniprop_get_decoder (Lisp_Object table)
 
   if (! FIXNUMP (XCHAR_TABLE (table)->extras[1]))
     return NULL;
-  i = XINT (XCHAR_TABLE (table)->extras[1]);
+  i = XFIXNUM (XCHAR_TABLE (table)->extras[1]);
   if (i < 0 || i >= uniprop_decoder_count)
     return NULL;
   return uniprop_decoder[i];
@@ -1269,7 +1269,7 @@ uniprop_get_encoder (Lisp_Object table)
 
   if (! FIXNUMP (XCHAR_TABLE (table)->extras[2]))
     return NULL;
-  i = XINT (XCHAR_TABLE (table)->extras[2]);
+  i = XFIXNUM (XCHAR_TABLE (table)->extras[2]);
   if (i < 0 || i >= uniprop_encoder_count)
     return NULL;
   return uniprop_encoder[i];
@@ -1301,7 +1301,7 @@ uniprop_table (Lisp_Object prop)
     return Qnil;
   val = XCHAR_TABLE (table)->extras[1];
   if (FIXNUMP (val)
-      ? (XINT (val) < 0 || XINT (val) >= uniprop_decoder_count)
+      ? (XFIXNUM (val) < 0 || XFIXNUM (val) >= uniprop_decoder_count)
       : ! NILP (val))
     return Qnil;
   /* Prepare ASCII values in advance for CHAR_TABLE_REF.  */
@@ -1337,7 +1337,7 @@ CHAR-TABLE must be what returned by `unicode-property-table-internal'. */)
   CHECK_CHARACTER (ch);
   if (! UNIPROP_TABLE_P (char_table))
     error ("Invalid Unicode property table");
-  val = CHAR_TABLE_REF (char_table, XINT (ch));
+  val = CHAR_TABLE_REF (char_table, XFIXNUM (ch));
   decoder = uniprop_get_decoder (char_table);
   return (decoder ? decoder (char_table, val) : val);
 }
@@ -1357,7 +1357,7 @@ CHAR-TABLE must be what returned by `unicode-property-table-internal'. */)
   encoder = uniprop_get_encoder (char_table);
   if (encoder)
     value = encoder (char_table, value);
-  CHAR_TABLE_SET (char_table, XINT (ch), value);
+  CHAR_TABLE_SET (char_table, XFIXNUM (ch), value);
   return Qnil;
 }
 
diff --git a/src/cmds.c b/src/cmds.c
index 857197cf9b1..1616efbb446 100644
--- a/src/cmds.c
+++ b/src/cmds.c
@@ -37,7 +37,7 @@ DEFUN ("forward-point", Fforward_point, Sforward_point, 1, 1, 0,
 {
   CHECK_FIXNUM (n);
 
-  return make_fixnum (PT + XINT (n));
+  return make_fixnum (PT + XFIXNUM (n));
 }
 
 /* Add N to point; or subtract N if FORWARD is false.  N defaults to 1.
@@ -45,7 +45,7 @@ DEFUN ("forward-point", Fforward_point, Sforward_point, 1, 1, 0,
 static Lisp_Object
 move_point (Lisp_Object n, bool forward)
 {
-  /* This used to just set point to point + XINT (n), and then check
+  /* This used to just set point to point + XFIXNUM (n), and then check
      to see if it was within boundaries.  But now that SET_PT can
      potentially do a lot of stuff (calling entering and exiting
      hooks, etcetera), that's not a good approach.  So we validate the
@@ -58,7 +58,7 @@ move_point (Lisp_Object n, bool forward)
   else
     CHECK_FIXNUM (n);
 
-  new_point = PT + (forward ? XINT (n) : - XINT (n));
+  new_point = PT + (forward ? XFIXNUM (n) : - XFIXNUM (n));
 
   if (new_point < BEGV)
     {
@@ -128,7 +128,7 @@ go to its beginning.  */)
   else
     {
       CHECK_FIXNUM (n);
-      count = XINT (n);
+      count = XFIXNUM (n);
     }
 
   shortage = scan_newline_from_point (count, &pos, &pos_byte);
@@ -164,7 +164,7 @@ instead.  For instance, `(forward-line 0)' does the same thing as
   else
     CHECK_FIXNUM (n);
 
-  SET_PT (XINT (Fline_beginning_position (n)));
+  SET_PT (XFIXNUM (Fline_beginning_position (n)));
 
   return Qnil;
 }
@@ -191,7 +191,7 @@ to t.  */)
 
   while (1)
     {
-      newpos = XINT (Fline_end_position (n));
+      newpos = XFIXNUM (Fline_end_position (n));
       SET_PT (newpos);
 
       if (PT > newpos
@@ -232,13 +232,13 @@ because it respects values of `delete-active-region' and `overwrite-mode'.  */)
 
   CHECK_FIXNUM (n);
 
-  if (eabs (XINT (n)) < 2)
+  if (eabs (XFIXNUM (n)) < 2)
     call0 (Qundo_auto_amalgamate);
 
-  pos = PT + XINT (n);
+  pos = PT + XFIXNUM (n);
   if (NILP (killflag))
     {
-      if (XINT (n) < 0)
+      if (XFIXNUM (n) < 0)
         {
           if (pos < BEGV)
             xsignal0 (Qbeginning_of_buffer);
@@ -276,10 +276,10 @@ a non-nil value for the inserted character.  At the end, it runs
 {
   CHECK_FIXNUM (n);
 
-  if (XINT (n) < 0)
-    error ("Negative repetition argument %"pI"d", XINT (n));
+  if (XFIXNUM (n) < 0)
+    error ("Negative repetition argument %"pI"d", XFIXNUM (n));
 
-  if (XFASTINT (n) < 2)
+  if (XFIXNAT (n) < 2)
     call0 (Qundo_auto_amalgamate);
 
   /* Barf if the key that invoked this was not a character.  */
@@ -287,8 +287,8 @@ a non-nil value for the inserted character.  At the end, it runs
     bitch_at_user ();
   else {
     int character = translate_char (Vtranslation_table_for_input,
-                                    XINT (last_command_event));
-    int val = internal_self_insert (character, XFASTINT (n));
+                                    XFIXNUM (last_command_event));
+    int val = internal_self_insert (character, XFIXNAT (n));
     if (val == 2)
       Fset (Qundo_auto__this_command_amalgamating, Qnil);
     frame_make_pointer_invisible (SELECTED_FRAME ());
@@ -360,7 +360,7 @@ internal_self_insert (int c, EMACS_INT n)
       if (EQ (overwrite, Qoverwrite_mode_binary))
         chars_to_delete = min (n, PTRDIFF_MAX);
       else if (c != '\n' && c2 != '\n'
-               && (cwidth = XFASTINT (Fchar_width (make_fixnum (c)))) != 0)
+               && (cwidth = XFIXNAT (Fchar_width (make_fixnum (c)))) != 0)
         {
           ptrdiff_t pos = PT;
           ptrdiff_t pos_byte = PT_BYTE;
@@ -378,7 +378,7 @@ internal_self_insert (int c, EMACS_INT n)
                  character.  In that case, the new point is set after
                  that character.  */
               ptrdiff_t actual_clm
-                = XFASTINT (Fmove_to_column (make_fixnum (target_clm), Qnil));
+                = XFIXNAT (Fmove_to_column (make_fixnum (target_clm), Qnil));
 
               chars_to_delete = PT - pos;
 
@@ -408,8 +408,8 @@ internal_self_insert (int c, EMACS_INT n)
       && NILP (BVAR (current_buffer, read_only))
       && PT > BEGV
       && (SYNTAX (!NILP (BVAR (current_buffer, enable_multibyte_characters))
-                  ? XFASTINT (Fprevious_char ())
-                  : UNIBYTE_TO_CHAR (XFASTINT (Fprevious_char ())))
+                  ? XFIXNAT (Fprevious_char ())
+                  : UNIBYTE_TO_CHAR (XFIXNAT (Fprevious_char ())))
           == Sword))
     {
       EMACS_INT modiff = MODIFF;
diff --git a/src/coding.c b/src/coding.c
index a4bb45f350c..53e98f89811 100644
--- a/src/coding.c
+++ b/src/coding.c
@@ -324,7 +324,7 @@ static Lisp_Object Vbig5_coding_system;
 /* ISO2022 section */
 
 #define CODING_ISO_INITIAL(coding, reg)                 \
-  (XINT (AREF (AREF (CODING_ID_ATTRS ((coding)->id),    \
+  (XFIXNUM (AREF (AREF (CODING_ID_ATTRS ((coding)->id), \
                      coding_attr_iso_initial),          \
                reg)))
 
@@ -2888,7 +2888,7 @@ setup_iso_safe_charsets (Lisp_Object attrs)
   Lisp_Object reg_usage;
   Lisp_Object tail;
   EMACS_INT reg94, reg96;
-  int flags = XINT (AREF (attrs, coding_attr_iso_flags));
+  int flags = XFIXNUM (AREF (attrs, coding_attr_iso_flags));
   int max_charset_id;
 
   charset_list = CODING_ATTR_CHARSET_LIST (attrs);
@@ -2906,7 +2906,7 @@ setup_iso_safe_charsets (Lisp_Object attrs)
   max_charset_id = 0;
   for (tail = charset_list; CONSP (tail); tail = XCDR (tail))
     {
-      int id = XINT (XCAR (tail));
+      int id = XFIXNUM (XCAR (tail));
       if (max_charset_id < id)
         max_charset_id = id;
     }
@@ -2915,8 +2915,8 @@ setup_iso_safe_charsets (Lisp_Object attrs)
   memset (SDATA (safe_charsets), 255, max_charset_id + 1);
   request = AREF (attrs, coding_attr_iso_request);
   reg_usage = AREF (attrs, coding_attr_iso_usage);
-  reg94 = XINT (XCAR (reg_usage));
-  reg96 = XINT (XCDR (reg_usage));
+  reg94 = XFIXNUM (XCAR (reg_usage));
+  reg96 = XFIXNUM (XCDR (reg_usage));
 
   for (tail = charset_list; CONSP (tail); tail = XCDR (tail))
     {
@@ -2925,19 +2925,19 @@ setup_iso_safe_charsets (Lisp_Object attrs)
       struct charset *charset;
 
       id = XCAR (tail);
-      charset = CHARSET_FROM_ID (XINT (id));
+      charset = CHARSET_FROM_ID (XFIXNUM (id));
       reg = Fcdr (Fassq (id, request));
       if (! NILP (reg))
-        SSET (safe_charsets, XINT (id), XINT (reg));
+        SSET (safe_charsets, XFIXNUM (id), XFIXNUM (reg));
       else if (charset->iso_chars_96)
         {
           if (reg96 < 4)
-            SSET (safe_charsets, XINT (id), reg96);
+            SSET (safe_charsets, XFIXNUM (id), reg96);
         }
       else
         {
           if (reg94 < 4)
-            SSET (safe_charsets, XINT (id), reg94);
+            SSET (safe_charsets, XFIXNUM (id), reg94);
         }
     }
   ASET (attrs, coding_attr_safe_charsets, safe_charsets);
@@ -4612,7 +4612,7 @@ detect_coding_sjis (struct coding_system *coding,
 
   CODING_GET_INFO (coding, attrs, charset_list);
   max_first_byte_of_2_byte_code
-    = (XINT (Flength (charset_list)) > 3 ? 0xFC : 0xEF);
+    = (XFIXNUM (Flength (charset_list)) > 3 ? 0xFC : 0xEF);
 
   detect_info->checked |= CATEGORY_MASK_SJIS;
   /* A coding system of this category is always ASCII compatible.  */
@@ -4725,10 +4725,10 @@ decode_coding_sjis (struct coding_system *coding)
   CODING_GET_INFO (coding, attrs, charset_list);
 
   val = charset_list;
-  charset_roman = CHARSET_FROM_ID (XINT (XCAR (val))), val = XCDR (val);
-  charset_kana = CHARSET_FROM_ID (XINT (XCAR (val))), val = XCDR (val);
-  charset_kanji = CHARSET_FROM_ID (XINT (XCAR (val))), val = XCDR (val);
-  charset_kanji2 = NILP (val) ? NULL : CHARSET_FROM_ID (XINT (XCAR (val)));
+  charset_roman = CHARSET_FROM_ID (XFIXNUM (XCAR (val))), val = XCDR (val);
+  charset_kana = CHARSET_FROM_ID (XFIXNUM (XCAR (val))), val = XCDR (val);
+  charset_kanji = CHARSET_FROM_ID (XFIXNUM (XCAR (val))), val = XCDR (val);
+  charset_kanji2 = NILP (val) ? NULL : CHARSET_FROM_ID (XFIXNUM (XCAR (val)));
 
   while (1)
     {
@@ -4840,8 +4840,8 @@ decode_coding_big5 (struct coding_system *coding)
 
   CODING_GET_INFO (coding, attrs, charset_list);
   val = charset_list;
-  charset_roman = CHARSET_FROM_ID (XINT (XCAR (val))), val = XCDR (val);
-  charset_big5 = CHARSET_FROM_ID (XINT (XCAR (val)));
+  charset_roman = CHARSET_FROM_ID (XFIXNUM (XCAR (val))), val = XCDR (val);
+  charset_big5 = CHARSET_FROM_ID (XFIXNUM (XCAR (val)));
 
   while (1)
     {
@@ -4936,9 +4936,9 @@ encode_coding_sjis (struct coding_system *coding)
 
   CODING_GET_INFO (coding, attrs, charset_list);
   val = XCDR (charset_list);
-  charset_kana = CHARSET_FROM_ID (XINT (XCAR (val))), val = XCDR (val);
-  charset_kanji = CHARSET_FROM_ID (XINT (XCAR (val))), val = XCDR (val);
-  charset_kanji2 = NILP (val) ? NULL : CHARSET_FROM_ID (XINT (XCAR (val)));
+  charset_kana = CHARSET_FROM_ID (XFIXNUM (XCAR (val))), val = XCDR (val);
+  charset_kanji = CHARSET_FROM_ID (XFIXNUM (XCAR (val))), val = XCDR (val);
+  charset_kanji2 = NILP (val) ? NULL : CHARSET_FROM_ID (XFIXNUM (XCAR (val)));
 
   ascii_compatible = ! NILP (CODING_ATTR_ASCII_COMPAT (attrs));
 
@@ -5029,7 +5029,7 @@ encode_coding_big5 (struct coding_system *coding)
 
   CODING_GET_INFO (coding, attrs, charset_list);
   val = XCDR (charset_list);
-  charset_big5 = CHARSET_FROM_ID (XINT (XCAR (val)));
+  charset_big5 = CHARSET_FROM_ID (XFIXNUM (XCAR (val)));
   ascii_compatible = ! NILP (CODING_ATTR_ASCII_COMPAT (attrs));
 
   while (charbuf < charbuf_end)
@@ -5442,7 +5442,7 @@ detect_coding_charset (struct coding_system *coding,
         }
       if (FIXNUMP (val))
         {
-          charset = CHARSET_FROM_ID (XFASTINT (val));
+          charset = CHARSET_FROM_ID (XFIXNAT (val));
           dim = CHARSET_DIMENSION (charset);
           for (idx = 1; idx < dim; idx++)
             {
@@ -5461,7 +5461,7 @@ detect_coding_charset (struct coding_system *coding,
           idx = 1;
           for (; CONSP (val); val = XCDR (val))
             {
-              charset = CHARSET_FROM_ID (XFASTINT (XCAR (val)));
+              charset = CHARSET_FROM_ID (XFIXNAT (XCAR (val)));
               dim = CHARSET_DIMENSION (charset);
               while (idx < dim)
                 {
@@ -5555,7 +5555,7 @@ decode_coding_charset (struct coding_system *coding)
         goto invalid_code;
       if (FIXNUMP (val))
         {
-          charset = CHARSET_FROM_ID (XFASTINT (val));
+          charset = CHARSET_FROM_ID (XFIXNAT (val));
           dim = CHARSET_DIMENSION (charset);
           while (len < dim)
             {
@@ -5573,7 +5573,7 @@ decode_coding_charset (struct coding_system *coding)
              comes first).  */
           while (CONSP (val))
             {
-              charset = CHARSET_FROM_ID (XFASTINT (XCAR (val)));
+              charset = CHARSET_FROM_ID (XFIXNAT (XCAR (val)));
               dim = CHARSET_DIMENSION (charset);
               while (len < dim)
                 {
@@ -5726,7 +5726,7 @@ setup_coding_system (Lisp_Object coding_system, struct coding_system *coding)
   val = CODING_ATTR_SAFE_CHARSETS (attrs);
   coding->max_charset_id = SCHARS (val) - 1;
   coding->safe_charsets = SDATA (val);
-  coding->default_char = XINT (CODING_ATTR_DEFAULT_CHAR (attrs));
+  coding->default_char = XFIXNUM (CODING_ATTR_DEFAULT_CHAR (attrs));
   coding->carryover_bytes = 0;
   coding->raw_destination = 0;
 
@@ -5749,7 +5749,7 @@ setup_coding_system (Lisp_Object coding_system, struct coding_system *coding)
   else if (EQ (coding_type, Qiso_2022))
     {
       int i;
-      int flags = XINT (AREF (attrs, coding_attr_iso_flags));
+      int flags = XFIXNUM (AREF (attrs, coding_attr_iso_flags));
 
       /* Invoke graphic register 0 to plane 0.  */
       CODING_ISO_INVOCATION (coding, 0) = 0;
@@ -5852,13 +5852,13 @@ setup_coding_system (Lisp_Object coding_system, struct coding_system *coding)
 
           for (tail = Vemacs_mule_charset_list; CONSP (tail);
                tail = XCDR (tail))
-            if (max_charset_id < XFASTINT (XCAR (tail)))
-              max_charset_id = XFASTINT (XCAR (tail));
+            if (max_charset_id < XFIXNAT (XCAR (tail)))
+              max_charset_id = XFIXNAT (XCAR (tail));
           safe_charsets = make_uninit_string (max_charset_id + 1);
           memset (SDATA (safe_charsets), 255, max_charset_id + 1);
           for (tail = Vemacs_mule_charset_list; CONSP (tail);
                tail = XCDR (tail))
-            SSET (safe_charsets, XFASTINT (XCAR (tail)), 0);
+            SSET (safe_charsets, XFIXNAT (XCAR (tail)), 0);
           coding->max_charset_id = max_charset_id;
           coding->safe_charsets = SDATA (safe_charsets);
         }
@@ -5908,7 +5908,7 @@ coding_charset_list (struct coding_system *coding)
   CODING_GET_INFO (coding, attrs, charset_list);
   if (EQ (CODING_ATTR_TYPE (attrs), Qiso_2022))
     {
-      int flags = XINT (AREF (attrs, coding_attr_iso_flags));
+      int flags = XFIXNUM (AREF (attrs, coding_attr_iso_flags));
 
       if (flags & CODING_ISO_FLAG_FULL_SUPPORT)
         charset_list = Viso_2022_charset_list;
@@ -5934,7 +5934,7 @@ coding_system_charset_list (Lisp_Object coding_system)
 
   if (EQ (CODING_ATTR_TYPE (attrs), Qiso_2022))
     {
-      int flags = XINT (AREF (attrs, coding_attr_iso_flags));
+      int flags = XFIXNUM (AREF (attrs, coding_attr_iso_flags));
 
       if (flags & CODING_ISO_FLAG_FULL_SUPPORT)
         charset_list = Viso_2022_charset_list;
@@ -6714,7 +6714,7 @@ detect_coding (struct coding_system *coding)
                 }
         }
     }
-  else if (XINT (CODING_ATTR_CATEGORY (CODING_ID_ATTRS (coding->id)))
+  else if (XFIXNUM (CODING_ATTR_CATEGORY (CODING_ID_ATTRS (coding->id)))
            == coding_category_utf_8_auto)
     {
       Lisp_Object coding_systems;
@@ -6740,7 +6740,7 @@ detect_coding (struct coding_system *coding)
             }
         }
     }
-  else if (XINT (CODING_ATTR_CATEGORY (CODING_ID_ATTRS (coding->id)))
+  else if (XFIXNUM (CODING_ATTR_CATEGORY (CODING_ID_ATTRS (coding->id)))
            == coding_category_utf_16_auto)
     {
       Lisp_Object coding_systems;
@@ -6924,8 +6924,8 @@ get_translation_table (Lisp_Object attrs, bool encodep, int *max_lookup)
           && CHAR_TABLE_EXTRA_SLOTS (XCHAR_TABLE (translation_table)) > 1)
         {
           val = XCHAR_TABLE (translation_table)->extras[1];
-          if (FIXNATP (val) && *max_lookup < XFASTINT (val))
-            *max_lookup = min (XFASTINT (val), MAX_LOOKUP_MAX);
+          if (FIXNATP (val) && *max_lookup < XFIXNAT (val))
+            *max_lookup = min (XFIXNAT (val), MAX_LOOKUP_MAX);
         }
       else if (CONSP (translation_table))
         {
@@ -6936,8 +6936,8 @@ get_translation_table (Lisp_Object attrs, bool encodep, int *max_lookup)
                 && CHAR_TABLE_EXTRA_SLOTS (XCHAR_TABLE (XCAR (tail))) > 1)
               {
                 Lisp_Object tailval = XCHAR_TABLE (XCAR (tail))->extras[1];
-                if (FIXNATP (tailval) && *max_lookup < XFASTINT (tailval))
-                  *max_lookup = min (XFASTINT (tailval), MAX_LOOKUP_MAX);
+                if (FIXNATP (tailval) && *max_lookup < XFIXNAT (tailval))
+                  *max_lookup = min (XFIXNAT (tailval), MAX_LOOKUP_MAX);
               }
         }
     }
@@ -6951,7 +6951,7 @@ get_translation_table (Lisp_Object attrs, bool encodep, int *max_lookup)
       {                                                         \
         trans = CHAR_TABLE_REF (table, c);                      \
         if (CHARACTERP (trans))                                 \
-          c = XFASTINT (trans), trans = Qnil;                   \
+          c = XFIXNAT (trans), trans = Qnil;                    \
       }                                                         \
     else if (CONSP (table))                                     \
       {                                                         \
@@ -6962,7 +6962,7 @@ get_translation_table (Lisp_Object attrs, bool encodep, int *max_lookup)
             {                                                   \
               trans = CHAR_TABLE_REF (XCAR (tail), c);          \
               if (CHARACTERP (trans))                           \
-                c = XFASTINT (trans), trans = Qnil;             \
+                c = XFIXNAT (trans), trans = Qnil;              \
               else if (! NILP (trans))                          \
                 break;                                          \
             }                                                   \
@@ -6997,7 +6997,7 @@ get_translation (Lisp_Object trans, int *buf, int *buf_end, ptrdiff_t *nchars)
         {
           if (buf + i == buf_end)
             return Qt;
-          if (XINT (AREF (from, i)) != buf[i])
+          if (XFIXNUM (AREF (from, i)) != buf[i])
             break;
         }
       if (i == len)
@@ -7049,11 +7049,11 @@ produce_chars (struct coding_system *coding, Lisp_Object translation_table,
                 {
                   trans = get_translation (trans, buf, buf_end, &from_nchars);
                   if (FIXNUMP (trans))
-                    c = XINT (trans);
+                    c = XFIXNUM (trans);
                   else if (VECTORP (trans))
                     {
                       to_nchars = ASIZE (trans);
-                      c = XINT (AREF (trans, 0));
+                      c = XFIXNUM (AREF (trans, 0));
                     }
                   else if (EQ (trans, Qt) && ! last_block)
                     break;
@@ -7081,7 +7081,7 @@ produce_chars (struct coding_system *coding, Lisp_Object translation_table,
               for (i = 0; i < to_nchars; i++)
                 {
                   if (i > 0)
-                    c = XINT (AREF (trans, i));
+                    c = XFIXNUM (AREF (trans, i));
                   if (coding->dst_multibyte
                       || ! CHAR_BYTE8_P (c))
                     CHAR_STRING_ADVANCE_NO_UNIFY (c, dst);
@@ -7534,7 +7534,7 @@ handle_composition_annotation (ptrdiff_t pos, ptrdiff_t limit,
                 {
                   len = ASIZE (components);
                   for (i = 0; i < len; i++)
-                    *buf++ = XINT (AREF (components, i));
+                    *buf++ = XFIXNUM (AREF (components, i));
                 }
               else if (STRINGP (components))
                 {
@@ -7549,13 +7549,13 @@ handle_composition_annotation (ptrdiff_t pos, ptrdiff_t limit,
               else if (FIXNUMP (components))
                 {
                   len = 1;
-                  *buf++ = XINT (components);
+                  *buf++ = XFIXNUM (components);
                 }
               else if (CONSP (components))
                 {
                   for (len = 0; CONSP (components);
                        len++, components = XCDR (components))
-                    *buf++ = XINT (XCAR (components));
+                    *buf++ = XFIXNUM (XCAR (components));
                 }
               else
                 emacs_abort ();
@@ -7593,14 +7593,14 @@ handle_charset_annotation (ptrdiff_t pos, ptrdiff_t limit,
 
   val = Fget_text_property (make_fixnum (pos), Qcharset, coding->src_object);
   if (! NILP (val) && CHARSETP (val))
-    id = XINT (CHARSET_SYMBOL_ID (val));
+    id = XFIXNUM (CHARSET_SYMBOL_ID (val));
   else
     id = -1;
   ADD_CHARSET_DATA (buf, 0, id);
   next = Fnext_single_property_change (make_fixnum (pos), Qcharset,
                                        coding->src_object,
                                        make_fixnum (limit));
-  *stop = XINT (next);
+  *stop = XFIXNUM (next);
   return buf;
 }
 
@@ -7710,19 +7710,19 @@ consume_chars (struct coding_system *coding, Lisp_Object translation_table,
           trans = get_translation (trans, lookup_buf, lookup_buf_end,
                                    &from_nchars);
           if (FIXNUMP (trans))
-            c = XINT (trans);
+            c = XFIXNUM (trans);
           else if (VECTORP (trans))
             {
               to_nchars = ASIZE (trans);
               if (buf_end - buf < to_nchars)
                 break;
-              c = XINT (AREF (trans, 0));
+              c = XFIXNUM (AREF (trans, 0));
             }
           else
             break;
           *buf++ = c;
           for (i = 1; i < to_nchars; i++)
-            *buf++ = XINT (AREF (trans, i));
+            *buf++ = XFIXNUM (AREF (trans, i));
           for (i = 1; i < from_nchars; i++, pos++)
             src += MULTIBYTE_LENGTH_NO_CHECK (src);
         }
@@ -8618,7 +8618,7 @@ detect_coding_system (const unsigned char *src,
   detect_info.checked = detect_info.found = detect_info.rejected = 0;
 
   /* At first, detect text-format if necessary.  */
-  base_category = XINT (CODING_ATTR_CATEGORY (attrs));
+  base_category = XFIXNUM (CODING_ATTR_CATEGORY (attrs));
   if (base_category == coding_category_undecided)
     {
       enum coding_category category UNINIT;
@@ -8826,7 +8826,7 @@ detect_coding_system (const unsigned char *src,
     }
   else
     {
-      detect_info.found = 1 << XINT (CODING_ATTR_CATEGORY (attrs));
+      detect_info.found = 1 << XFIXNUM (CODING_ATTR_CATEGORY (attrs));
       val = list1 (make_fixnum (coding.id));
     }
 
@@ -8869,9 +8869,9 @@ detect_coding_system (const unsigned char *src,
         enum coding_category category;
         int this_eol;
 
-        id = XINT (XCAR (tail));
+        id = XFIXNUM (XCAR (tail));
         attrs = CODING_ID_ATTRS (id);
-        category = XINT (CODING_ATTR_CATEGORY (attrs));
+        category = XFIXNUM (CODING_ATTR_CATEGORY (attrs));
         eol_type = CODING_ID_EOL_TYPE (id);
         if (VECTORP (eol_type))
           {
@@ -8922,7 +8922,7 @@ highest priority.  */)
   ptrdiff_t from_byte, to_byte;
 
   validate_region (&start, &end);
-  from = XINT (start), to = XINT (end);
+  from = XFIXNUM (start), to = XFIXNUM (end);
   from_byte = CHAR_TO_BYTE (from);
   to_byte = CHAR_TO_BYTE (to);
 
@@ -8975,7 +8975,7 @@ char_encodable_p (int c, Lisp_Object attrs)
   for (tail = CODING_ATTR_CHARSET_LIST (attrs);
        CONSP (tail); tail = XCDR (tail))
     {
-      charset = CHARSET_FROM_ID (XINT (XCAR (tail)));
+      charset = CHARSET_FROM_ID (XFIXNUM (XCAR (tail)));
       if (CHAR_CHARSET_P (c, charset))
         break;
     }
@@ -9013,21 +9013,21 @@ DEFUN ("find-coding-systems-region-internal",
     {
       CHECK_FIXNUM_COERCE_MARKER (start);
       CHECK_FIXNUM_COERCE_MARKER (end);
-      if (XINT (start) < BEG || XINT (end) > Z || XINT (start) > XINT (end))
+      if (XFIXNUM (start) < BEG || XFIXNUM (end) > Z || XFIXNUM (start) > XFIXNUM (end))
         args_out_of_range (start, end);
       if (NILP (BVAR (current_buffer, enable_multibyte_characters)))
         return Qt;
-      start_byte = CHAR_TO_BYTE (XINT (start));
-      end_byte = CHAR_TO_BYTE (XINT (end));
-      if (XINT (end) - XINT (start) == end_byte - start_byte)
+      start_byte = CHAR_TO_BYTE (XFIXNUM (start));
+      end_byte = CHAR_TO_BYTE (XFIXNUM (end));
+      if (XFIXNUM (end) - XFIXNUM (start) == end_byte - start_byte)
         return Qt;
 
-      if (XINT (start) < GPT && XINT (end) > GPT)
+      if (XFIXNUM (start) < GPT && XFIXNUM (end) > GPT)
         {
-          if ((GPT - XINT (start)) < (XINT (end) - GPT))
-            move_gap_both (XINT (start), start_byte);
+          if ((GPT - XFIXNUM (start)) < (XFIXNUM (end) - GPT))
+            move_gap_both (XFIXNUM (start), start_byte);
           else
-            move_gap_both (XINT (end), end_byte);
+            move_gap_both (XFIXNUM (end), end_byte);
         }
     }
 
@@ -9146,8 +9146,8 @@ to the string and treated as in `substring'.  */)
   if (NILP (string))
     {
       validate_region (&start, &end);
-      from = XINT (start);
-      to = XINT (end);
+      from = XFIXNUM (start);
+      to = XFIXNUM (end);
       if (NILP (BVAR (current_buffer, enable_multibyte_characters))
           || (ascii_compatible
               && (to - from) == (CHAR_TO_BYTE (to) - (CHAR_TO_BYTE (from)))))
@@ -9176,7 +9176,7 @@ to the string and treated as in `substring'.  */)
   else
     {
       CHECK_FIXNAT (count);
-      n = XINT (count);
+      n = XFIXNUM (count);
     }
 
   positions = Qnil;
@@ -9267,23 +9267,23 @@ is nil.  */)
     {
       CHECK_FIXNUM_COERCE_MARKER (start);
       CHECK_FIXNUM_COERCE_MARKER (end);
-      if (XINT (start) < BEG || XINT (end) > Z || XINT (start) > XINT (end))
+      if (XFIXNUM (start) < BEG || XFIXNUM (end) > Z || XFIXNUM (start) > XFIXNUM (end))
         args_out_of_range (start, end);
       if (NILP (BVAR (current_buffer, enable_multibyte_characters)))
         return Qnil;
-      start_byte = CHAR_TO_BYTE (XINT (start));
-      end_byte = CHAR_TO_BYTE (XINT (end));
-      if (XINT (end) - XINT (start) == end_byte - start_byte)
+      start_byte = CHAR_TO_BYTE (XFIXNUM (start));
+      end_byte = CHAR_TO_BYTE (XFIXNUM (end));
+      if (XFIXNUM (end) - XFIXNUM (start) == end_byte - start_byte)
         return Qnil;
 
-      if (XINT (start) < GPT && XINT (end) > GPT)
+      if (XFIXNUM (start) < GPT && XFIXNUM (end) > GPT)
         {
-          if ((GPT - XINT (start)) < (XINT (end) - GPT))
-            move_gap_both (XINT (start), start_byte);
+          if ((GPT - XFIXNUM (start)) < (XFIXNUM (end) - GPT))
+            move_gap_both (XFIXNUM (start), start_byte);
           else
-            move_gap_both (XINT (end), end_byte);
+            move_gap_both (XFIXNUM (end), end_byte);
         }
-      pos = XINT (start);
+      pos = XFIXNUM (start);
     }
 
   list = Qnil;
@@ -9369,9 +9369,9 @@ code_convert_region (Lisp_Object start, Lisp_Object end,
     CHECK_BUFFER (dst_object);
 
   validate_region (&start, &end);
-  from = XFASTINT (start);
+  from = XFIXNAT (start);
   from_byte = CHAR_TO_BYTE (from);
-  to = XFASTINT (end);
+  to = XFIXNAT (end);
   to_byte = CHAR_TO_BYTE (to);
 
   setup_coding_system (coding_system, &coding);
@@ -9611,7 +9611,7 @@ Return the corresponding character.  */)
   int c;
 
   CHECK_FIXNAT (code);
-  ch = XFASTINT (code);
+  ch = XFIXNAT (code);
   CHECK_CODING_SYSTEM_GET_SPEC (Vsjis_coding_system, spec);
   attrs = AREF (spec, 0);
 
@@ -9620,9 +9620,9 @@ Return the corresponding character.  */)
     return code;
 
   val = CODING_ATTR_CHARSET_LIST (attrs);
-  charset_roman = CHARSET_FROM_ID (XINT (XCAR (val))), val = XCDR (val);
-  charset_kana = CHARSET_FROM_ID (XINT (XCAR (val))), val = XCDR (val);
-  charset_kanji = CHARSET_FROM_ID (XINT (XCAR (val)));
+  charset_roman = CHARSET_FROM_ID (XFIXNUM (XCAR (val))), val = XCDR (val);
+  charset_kana = CHARSET_FROM_ID (XFIXNUM (XCAR (val))), val = XCDR (val);
+  charset_kanji = CHARSET_FROM_ID (XFIXNUM (XCAR (val)));
 
   if (ch <= 0x7F)
     {
@@ -9664,7 +9664,7 @@ Return the corresponding code in SJIS.  */)
   unsigned code;
 
   CHECK_CHARACTER (ch);
-  c = XFASTINT (ch);
+  c = XFIXNAT (ch);
   CHECK_CODING_SYSTEM_GET_SPEC (Vsjis_coding_system, spec);
   attrs = AREF (spec, 0);
 
@@ -9692,7 +9692,7 @@ Return the corresponding character.  */)
   int c;
 
   CHECK_FIXNAT (code);
-  ch = XFASTINT (code);
+  ch = XFIXNAT (code);
   CHECK_CODING_SYSTEM_GET_SPEC (Vbig5_coding_system, spec);
   attrs = AREF (spec, 0);
 
@@ -9701,8 +9701,8 @@ Return the corresponding character.  */)
     return code;
 
   val = CODING_ATTR_CHARSET_LIST (attrs);
-  charset_roman = CHARSET_FROM_ID (XINT (XCAR (val))), val = XCDR (val);
-  charset_big5 = CHARSET_FROM_ID (XINT (XCAR (val)));
+  charset_roman = CHARSET_FROM_ID (XFIXNUM (XCAR (val))), val = XCDR (val);
+  charset_big5 = CHARSET_FROM_ID (XFIXNUM (XCAR (val)));
 
   if (ch <= 0x7F)
     {
@@ -9736,7 +9736,7 @@ Return the corresponding character code in Big5.  */)
   unsigned code;
 
   CHECK_CHARACTER (ch);
-  c = XFASTINT (ch);
+  c = XFIXNAT (ch);
   CHECK_CODING_SYSTEM_GET_SPEC (Vbig5_coding_system, spec);
   attrs = AREF (spec, 0);
   if (ASCII_CHAR_P (c)
@@ -9885,17 +9885,17 @@ usage: (find-operation-coding-system OPERATION ARGUMENTS...)  */)
   if (!SYMBOLP (operation)
       || (target_idx = Fget (operation, Qtarget_idx), !FIXNATP (target_idx)))
     error ("Invalid first argument");
-  if (nargs <= 1 + XFASTINT (target_idx))
+  if (nargs <= 1 + XFIXNAT (target_idx))
     error ("Too few arguments for operation `%s'",
            SDATA (SYMBOL_NAME (operation)));
-  target = args[XFASTINT (target_idx) + 1];
+  target = args[XFIXNAT (target_idx) + 1];
   if (!(STRINGP (target)
         || (EQ (operation, Qinsert_file_contents) && CONSP (target)
             && STRINGP (XCAR (target)) && BUFFERP (XCDR (target)))
         || (EQ (operation, Qopen_network_stream)
             && (FIXNUMP (target) || EQ (target, Qt)))))
     error ("Invalid argument %"pI"d of operation `%s'",
-           XFASTINT (target_idx) + 1, SDATA (SYMBOL_NAME (operation)));
+           XFIXNAT (target_idx) + 1, SDATA (SYMBOL_NAME (operation)));
   if (CONSP (target))
     target = XCAR (target);
 
@@ -9967,7 +9967,7 @@ usage: (set-coding-system-priority &rest coding-systems)  */)
 
       CHECK_CODING_SYSTEM_GET_SPEC (args[i], spec);
       attrs = AREF (spec, 0);
-      category = XINT (CODING_ATTR_CATEGORY (attrs));
+      category = XFIXNUM (CODING_ATTR_CATEGORY (attrs));
       if (changed[category])
         /* Ignore this coding system because a coding system of the
            same category already had a higher priority.  */
@@ -10110,8 +10110,8 @@ usage: (define-coding-system-internal ...)  */)
         {
           if (! RANGED_FIXNUMP (0, XCAR (tail), INT_MAX - 1))
             error ("Invalid charset-list");
-          if (max_charset_id < XFASTINT (XCAR (tail)))
-            max_charset_id = XFASTINT (XCAR (tail));
+          if (max_charset_id < XFIXNAT (XCAR (tail)))
+            max_charset_id = XFIXNAT (XCAR (tail));
         }
     }
   else
@@ -10141,7 +10141,7 @@ usage: (define-coding-system-internal ...)  */)
   safe_charsets = make_uninit_string (max_charset_id + 1);
   memset (SDATA (safe_charsets), 255, max_charset_id + 1);
   for (tail = charset_list; CONSP (tail); tail = XCDR (tail))
-    SSET (safe_charsets, XFASTINT (XCAR (tail)), 0);
+    SSET (safe_charsets, XFIXNAT (XCAR (tail)), 0);
   ASET (attrs, coding_attr_safe_charsets, safe_charsets);
 
   ASET (attrs, coding_attr_ascii_compat, args[coding_arg_ascii_compatible_p]);
@@ -10198,7 +10198,7 @@ usage: (define-coding-system-internal ...)  */)
 
       for (tail = charset_list; CONSP (tail); tail = XCDR (tail))
         {
-          struct charset *charset = CHARSET_FROM_ID (XFASTINT (XCAR (tail)));
+          struct charset *charset = CHARSET_FROM_ID (XFIXNAT (XCAR (tail)));
           int dim = CHARSET_DIMENSION (charset);
           int idx = (dim - 1) * 4;
 
@@ -10216,7 +10216,7 @@ usage: (define-coding-system-internal ...)  */)
                 tmp = XCAR (tail);
               else if (FIXED_OR_FLOATP (tmp))
                 {
-                  dim2 = CHARSET_DIMENSION (CHARSET_FROM_ID (XFASTINT (tmp)));
+                  dim2 = CHARSET_DIMENSION (CHARSET_FROM_ID (XFIXNAT (tmp)));
                   if (dim < dim2)
                     tmp = list2 (XCAR (tail), tmp);
                   else
@@ -10226,7 +10226,7 @@ usage: (define-coding-system-internal ...)  */)
                 {
                   for (tmp2 = tmp; CONSP (tmp2); tmp2 = XCDR (tmp2))
                     {
-                      dim2 = CHARSET_DIMENSION (CHARSET_FROM_ID (XFASTINT (XCAR (tmp2))));
+                      dim2 = CHARSET_DIMENSION (CHARSET_FROM_ID (XFIXNAT (XCAR (tmp2))));
                       if (dim < dim2)
                         break;
                     }
@@ -10272,23 +10272,23 @@ usage: (define-coding-system-internal ...)  */)
           val = XCAR (tail);
           if (FIXNUMP (val))
             {
-              if (! (0 <= XINT (val) && XINT (val) <= 255))
+              if (! (0 <= XFIXNUM (val) && XFIXNUM (val) <= 255))
                 args_out_of_range_3 (val, make_fixnum (0), make_fixnum (255));
-              from = to = XINT (val);
+              from = to = XFIXNUM (val);
             }
           else
             {
               CHECK_CONS (val);
               CHECK_FIXNAT_CAR (val);
               CHECK_FIXNUM_CDR (val);
-              if (XINT (XCAR (val)) > 255)
+              if (XFIXNUM (XCAR (val)) > 255)
                 args_out_of_range_3 (XCAR (val),
                                      make_fixnum (0), make_fixnum (255));
-              from = XINT (XCAR (val));
-              if (! (from <= XINT (XCDR (val)) && XINT (XCDR (val)) <= 255))
+              from = XFIXNUM (XCAR (val));
+              if (! (from <= XFIXNUM (XCDR (val)) && XFIXNUM (XCDR (val)) <= 255))
                 args_out_of_range_3 (XCDR (val),
                                      XCAR (val), make_fixnum (255));
-              to = XINT (XCDR (val));
+              to = XFIXNUM (XCDR (val));
             }
           for (i = from; i <= to; i++)
             SSET (valids, i, 1);
@@ -10376,14 +10376,14 @@ usage: (define-coding-system-internal ...)  */)
           tmp1 = XCAR (val);
           CHECK_CHARSET_GET_ID (tmp1, id);
           CHECK_FIXNAT_CDR (val);
-          if (XINT (XCDR (val)) >= 4)
-            error ("Invalid graphic register number: %"pI"d", XINT (XCDR (val)));
+          if (XFIXNUM (XCDR (val)) >= 4)
+            error ("Invalid graphic register number: %"pI"d", XFIXNUM (XCDR (val)));
           XSETCAR (val, make_fixnum (id));
         }
 
       flags = args[coding_arg_iso2022_flags];
       CHECK_FIXNAT (flags);
-      i = XINT (flags) & INT_MAX;
+      i = XFIXNUM (flags) & INT_MAX;
       if (EQ (args[coding_arg_charset_list], Qiso_2022))
         i |= CODING_ISO_FLAG_FULL_SUPPORT;
       flags = make_fixnum (i);
@@ -10403,7 +10403,7 @@ usage: (define-coding-system-internal ...)  */)
                     : coding_category_iso_7_tight);
       else
         {
-          int id = XINT (AREF (initial, 1));
+          int id = XFIXNUM (AREF (initial, 1));
 
           category = (((i & CODING_ISO_FLAG_LOCKING_SHIFT)
                        || EQ (args[coding_arg_charset_list], Qiso_2022)
@@ -10429,11 +10429,11 @@ usage: (define-coding-system-internal ...)  */)
 
       struct charset *charset;
 
-      if (XINT (Flength (charset_list)) != 3
-          && XINT (Flength (charset_list)) != 4)
+      if (XFIXNUM (Flength (charset_list)) != 3
+          && XFIXNUM (Flength (charset_list)) != 4)
         error ("There should be three or four charsets");
 
-      charset = CHARSET_FROM_ID (XINT (XCAR (charset_list)));
+      charset = CHARSET_FROM_ID (XFIXNUM (XCAR (charset_list)));
       if (CHARSET_DIMENSION (charset) != 1)
         error ("Dimension of charset %s is not one",
                SDATA (SYMBOL_NAME (CHARSET_NAME (charset))));
@@ -10441,13 +10441,13 @@ usage: (define-coding-system-internal ...)  */)
         ASET (attrs, coding_attr_ascii_compat, Qt);
 
       charset_list = XCDR (charset_list);
-      charset = CHARSET_FROM_ID (XINT (XCAR (charset_list)));
+      charset = CHARSET_FROM_ID (XFIXNUM (XCAR (charset_list)));
       if (CHARSET_DIMENSION (charset) != 1)
         error ("Dimension of charset %s is not one",
                SDATA (SYMBOL_NAME (CHARSET_NAME (charset))));
 
       charset_list = XCDR (charset_list);
-      charset = CHARSET_FROM_ID (XINT (XCAR (charset_list)));
+      charset = CHARSET_FROM_ID (XFIXNUM (XCAR (charset_list)));
       if (CHARSET_DIMENSION (charset) != 2)
         error ("Dimension of charset %s is not two",
                SDATA (SYMBOL_NAME (CHARSET_NAME (charset))));
@@ -10455,7 +10455,7 @@ usage: (define-coding-system-internal ...)  */)
       charset_list = XCDR (charset_list);
       if (! NILP (charset_list))
         {
-          charset = CHARSET_FROM_ID (XINT (XCAR (charset_list)));
+          charset = CHARSET_FROM_ID (XFIXNUM (XCAR (charset_list)));
           if (CHARSET_DIMENSION (charset) != 2)
             error ("Dimension of charset %s is not two",
                    SDATA (SYMBOL_NAME (CHARSET_NAME (charset))));
@@ -10468,10 +10468,10 @@ usage: (define-coding-system-internal ...)  */)
     {
       struct charset *charset;
 
-      if (XINT (Flength (charset_list)) != 2)
+      if (XFIXNUM (Flength (charset_list)) != 2)
         error ("There should be just two charsets");
 
-      charset = CHARSET_FROM_ID (XINT (XCAR (charset_list)));
+      charset = CHARSET_FROM_ID (XFIXNUM (XCAR (charset_list)));
       if (CHARSET_DIMENSION (charset) != 1)
         error ("Dimension of charset %s is not one",
                SDATA (SYMBOL_NAME (CHARSET_NAME (charset))));
@@ -10479,7 +10479,7 @@ usage: (define-coding-system-internal ...)  */)
         ASET (attrs, coding_attr_ascii_compat, Qt);
 
       charset_list = XCDR (charset_list);
-      charset = CHARSET_FROM_ID (XINT (XCAR (charset_list)));
+      charset = CHARSET_FROM_ID (XFIXNUM (XCAR (charset_list)));
       if (CHARSET_DIMENSION (charset) != 2)
         error ("Dimension of charset %s is not two",
                SDATA (SYMBOL_NAME (CHARSET_NAME (charset))));
diff --git a/src/composite.c b/src/composite.c
index f5e05d68755..39c54fcfab3 100644
--- a/src/composite.c
+++ b/src/composite.c
@@ -196,9 +196,9 @@ get_composition_id (ptrdiff_t charpos, ptrdiff_t bytepos, ptrdiff_t nchars,
   if (FIXNUMP (id))
     {
       /* PROP should be Form-B.  */
-      if (XINT (id) < 0 || XINT (id) >= n_compositions)
+      if (XFIXNUM (id) < 0 || XFIXNUM (id) >= n_compositions)
         goto invalid_composition;
-      return XINT (id);
+      return XFIXNUM (id);
     }
 
   /* PROP should be Form-A.
@@ -206,7 +206,7 @@ get_composition_id (ptrdiff_t charpos, ptrdiff_t bytepos, ptrdiff_t nchars,
   if (!CONSP (id))
     goto invalid_composition;
   length = XCAR (id);
-  if (!FIXNUMP (length) || XINT (length) != nchars)
+  if (!FIXNUMP (length) || XFIXNUM (length) != nchars)
     goto invalid_composition;
 
   components = XCDR (id);
@@ -251,7 +251,7 @@ get_composition_id (ptrdiff_t charpos, ptrdiff_t bytepos, ptrdiff_t nchars,
       id = HASH_VALUE (hash_table, hash_index);
       XSETCAR (prop, id);
       XSETCDR (prop, Fcons (make_fixnum (nchars), Fcons (key, XCDR (prop))));
-      return XINT (id);
+      return XFIXNUM (id);
     }
 
   /* This composition is a new one.  We must register it.  */
@@ -332,7 +332,7 @@ get_composition_id (ptrdiff_t charpos, ptrdiff_t bytepos, ptrdiff_t nchars,
       for (i = 0; i < glyph_len; i++)
         {
           int this_width;
-          ch = XINT (key_contents[i]);
+          ch = XFIXNUM (key_contents[i]);
           /* TAB in a composition means display glyphs with padding
              space on the left or right.  */
           this_width = (ch == '\t' ? 1 : CHARACTER_WIDTH (ch));
@@ -345,7 +345,7 @@ get_composition_id (ptrdiff_t charpos, ptrdiff_t bytepos, ptrdiff_t nchars,
       /* Rule-base composition.  */
       double leftmost = 0.0, rightmost;
 
-      ch = XINT (key_contents[0]);
+      ch = XFIXNUM (key_contents[0]);
       rightmost = ch != '\t' ? CHARACTER_WIDTH (ch) : 1;
 
       for (i = 1; i < glyph_len; i += 2)
@@ -354,8 +354,8 @@ get_composition_id (ptrdiff_t charpos, ptrdiff_t bytepos, ptrdiff_t nchars,
           int this_width;
           double this_left;
 
-          rule = XINT (key_contents[i]);
-          ch = XINT (key_contents[i + 1]);
+          rule = XFIXNUM (key_contents[i]);
+          ch = XFIXNUM (key_contents[i + 1]);
           this_width = ch != '\t' ? CHARACTER_WIDTH (ch) : 1;
 
           /* A composition rule is specified by an integer value
@@ -433,7 +433,7 @@ find_composition (ptrdiff_t pos, ptrdiff_t limit,
     {
       val = Fnext_single_property_change (make_fixnum (pos), Qcomposition,
                                           object, make_fixnum (limit));
-      pos = XINT (val);
+      pos = XFIXNUM (val);
       if (pos == limit)
         return 0;
     }
@@ -444,7 +444,7 @@ find_composition (ptrdiff_t pos, ptrdiff_t limit,
         return 1;
       val = Fprevious_single_property_change (make_fixnum (pos), Qcomposition,
                                               object, make_fixnum (limit));
-      pos = XINT (val);
+      pos = XFIXNUM (val);
       if (pos == limit)
         return 0;
       pos--;
@@ -836,7 +836,7 @@ fill_gstring_body (Lisp_Object gstring)
   for (i = 0; i < len; i++)
     {
       Lisp_Object g = LGSTRING_GLYPH (gstring, i);
-      int c = XFASTINT (AREF (header, i + 1));
+      int c = XFIXNAT (AREF (header, i + 1));
 
       if (NILP (g))
         {
@@ -852,7 +852,7 @@ fill_gstring_body (Lisp_Object gstring)
         }
       else
         {
-          int width = XFASTINT (CHAR_TABLE_REF (Vchar_width_table, c));
+          int width = XFIXNAT (CHAR_TABLE_REF (Vchar_width_table, c));
 
           LGLYPH_SET_CODE (g, c);
           LGLYPH_SET_LBEARING (g, 0);
@@ -941,7 +941,7 @@ char_composable_p (int c)
   return (c > ' '
           && (c == ZERO_WIDTH_NON_JOINER || c == ZERO_WIDTH_JOINER
               || (val = CHAR_TABLE_REF (Vunicode_category_table, c),
-                  (FIXNUMP (val) && (XINT (val) <= UNICODE_CATEGORY_So)))));
+                  (FIXNUMP (val) && (XFIXNUM (val) <= UNICODE_CATEGORY_So)))));
 }
 
 /* Update cmp_it->stop_pos to the next position after CHARPOS (and
@@ -1031,10 +1031,10 @@ composition_compute_stop_pos (struct composition_it *cmp_it, ptrdiff_t charpos,
                   Lisp_Object elt = XCAR (val);
                   if (VECTORP (elt) && ASIZE (elt) == 3
                       && FIXNATP (AREF (elt, 1))
-                      && charpos - 1 - XFASTINT (AREF (elt, 1)) >= start)
+                      && charpos - 1 - XFIXNAT (AREF (elt, 1)) >= start)
                     {
                       cmp_it->rule_idx = ridx;
-                      cmp_it->lookback = XFASTINT (AREF (elt, 1));
+                      cmp_it->lookback = XFIXNAT (AREF (elt, 1));
                       cmp_it->stop_pos = charpos - 1 - cmp_it->lookback;
                       cmp_it->ch = c;
                       return;
@@ -1082,9 +1082,9 @@ composition_compute_stop_pos (struct composition_it *cmp_it, ptrdiff_t charpos,
               Lisp_Object elt = XCAR (val);
               if (VECTORP (elt) && ASIZE (elt) == 3
                   && FIXNATP (AREF (elt, 1))
-                  && charpos - XFASTINT (AREF (elt, 1)) > endpos)
+                  && charpos - XFIXNAT (AREF (elt, 1)) > endpos)
                 {
-                  ptrdiff_t back = XFASTINT (AREF (elt, 1));
+                  ptrdiff_t back = XFIXNAT (AREF (elt, 1));
                   ptrdiff_t cpos = charpos - back, bpos;
 
                   if (back == 0)
@@ -1223,7 +1223,7 @@ composition_reseat_it (struct composition_it *cmp_it, ptrdiff_t charpos,
               if (! VECTORP (elt) || ASIZE (elt) != 3
                   || ! FIXNUMP (AREF (elt, 1)))
                 continue;
-              if (XFASTINT (AREF (elt, 1)) != cmp_it->lookback)
+              if (XFIXNAT (AREF (elt, 1)) != cmp_it->lookback)
                 goto no_composition;
               lgstring = autocmp_chars (elt, charpos, bytepos, endpos,
                                         w, face, string);
@@ -1262,7 +1262,7 @@ composition_reseat_it (struct composition_it *cmp_it, ptrdiff_t charpos,
         goto no_composition;
       if (NILP (LGSTRING_ID (lgstring)))
         lgstring = composition_gstring_put_cache (lgstring, -1);
-      cmp_it->id = XINT (LGSTRING_ID (lgstring));
+      cmp_it->id = XFIXNUM (LGSTRING_ID (lgstring));
       int i;
       for (i = 0; i < LGSTRING_GLYPH_LEN (lgstring); i++)
         if (NILP (LGSTRING_GLYPH (lgstring, i)))
@@ -1391,7 +1391,7 @@ composition_update_it (struct composition_it *cmp_it, ptrdiff_t charpos, ptrdiff
       cmp_it->width = 0;
       for (i = cmp_it->nchars - 1; i >= 0; i--)
         {
-          c = XINT (LGSTRING_CHAR (gstring, from + i));
+          c = XFIXNUM (LGSTRING_CHAR (gstring, from + i));
           cmp_it->nbytes += CHAR_BYTES (c);
           cmp_it->width += CHARACTER_WIDTH (c);
         }
@@ -1561,7 +1561,7 @@ find_automatic_composition (ptrdiff_t pos, ptrdiff_t limit,
 
               if (VECTORP (elt) && ASIZE (elt) == 3 && FIXNATP (AREF (elt, 1)))
                 {
-                  EMACS_INT check_pos = cur.pos - XFASTINT (AREF (elt, 1));
+                  EMACS_INT check_pos = cur.pos - XFIXNAT (AREF (elt, 1));
                   struct position_record check;
 
                   if (check_pos < head
@@ -1739,8 +1739,8 @@ should be ignored.  */)
       if (NILP (BVAR (current_buffer, enable_multibyte_characters)))
         error ("Attempt to shape unibyte text");
       validate_region (&from, &to);
-      frompos = XFASTINT (from);
-      topos = XFASTINT (to);
+      frompos = XFIXNAT (from);
+      topos = XFIXNAT (to);
       frombyte = CHAR_TO_BYTE (frompos);
     }
   else
@@ -1785,7 +1785,7 @@ for the composition.  See `compose-region' for more details.  */)
       && !STRINGP (components))
     CHECK_VECTOR (components);
 
-  compose_text (XINT (start), XINT (end), components, modification_func, Qnil);
+  compose_text (XFIXNUM (start), XFIXNUM (end), components, modification_func, Qnil);
   return Qnil;
 }
 
@@ -1824,7 +1824,7 @@ See `find-composition' for more details.  */)
   if (!NILP (limit))
     {
       CHECK_FIXNUM_COERCE_MARKER (limit);
-      to = min (XINT (limit), ZV);
+      to = min (XFIXNUM (limit), ZV);
     }
   else
     to = -1;
@@ -1832,15 +1832,15 @@ See `find-composition' for more details.  */)
   if (!NILP (string))
     {
       CHECK_STRING (string);
-      if (XINT (pos) < 0 || XINT (pos) > SCHARS (string))
+      if (XFIXNUM (pos) < 0 || XFIXNUM (pos) > SCHARS (string))
         args_out_of_range (string, pos);
     }
   else
     {
-      if (XINT (pos) < BEGV || XINT (pos) > ZV)
+      if (XFIXNUM (pos) < BEGV || XFIXNUM (pos) > ZV)
         args_out_of_range (Fcurrent_buffer (), pos);
     }
-  from = XINT (pos);
+  from = XFIXNUM (pos);
 
   if (!find_composition (from, to, &start, &end, &prop, string))
     {
@@ -1851,12 +1851,12 @@ See `find-composition' for more details.  */)
         return list3 (make_fixnum (start), make_fixnum (end), gstring);
       return Qnil;
     }
-  if ((end <= XINT (pos) || start > XINT (pos)))
+  if ((end <= XFIXNUM (pos) || start > XFIXNUM (pos)))
     {
       ptrdiff_t s, e;
 
       if (find_automatic_composition (from, to, &s, &e, &gstring, string)
-          && (e <= XINT (pos) ? e > end : s < start))
+          && (e <= XFIXNUM (pos) ? e > end : s < start))
         return list3 (make_fixnum (s), make_fixnum (e), gstring);
     }
   if (!composition_valid_p (start, end, prop))
diff --git a/src/composite.h b/src/composite.h
index 175381fad00..2d03e48ecc5 100644
--- a/src/composite.h
+++ b/src/composite.h
@@ -63,13 +63,13 @@ composition_registered_p (Lisp_Object prop)
 }
 
 /* Return ID number of the already registered composition.  */
-#define COMPOSITION_ID(prop) XINT (XCAR (prop))
+#define COMPOSITION_ID(prop) XFIXNUM (XCAR (prop))
 
 /* Return length of the composition.  */
 #define COMPOSITION_LENGTH(prop)        \
   (composition_registered_p (prop)      \
-   ? XINT (XCAR (XCDR (prop)))          \
-   : XINT (XCAR (XCAR (prop))))
+   ? XFIXNUM (XCAR (XCDR (prop)))               \
+   : XFIXNUM (XCAR (XCAR (prop))))
 
 /* Return components of the composition.  */
 #define COMPOSITION_COMPONENTS(prop)    \
@@ -86,7 +86,7 @@ composition_registered_p (Lisp_Object prop)
 /* Return the Nth glyph of composition specified by CMP.  CMP is a
    pointer to `struct composition'.  */
 #define COMPOSITION_GLYPH(cmp, n)                                       \
-  XINT (XVECTOR (XVECTOR (XHASH_TABLE (composition_hash_table)          \
+  XFIXNUM (XVECTOR (XVECTOR (XHASH_TABLE (composition_hash_table)               \
                           ->key_and_value)                              \
                  ->contents[cmp->hash_index * 2])                       \
         ->contents[cmp->method == COMPOSITION_WITH_RULE_ALTCHARS        \
@@ -96,7 +96,7 @@ composition_registered_p (Lisp_Object prop)
    rule-base composition specified by CMP.  CMP is a pointer to
    `struct composition'. */
 #define COMPOSITION_RULE(cmp, n)                                \
-  XINT (XVECTOR (XVECTOR (XHASH_TABLE (composition_hash_table)  \
+  XFIXNUM (XVECTOR (XVECTOR (XHASH_TABLE (composition_hash_table)       \
                           ->key_and_value)                      \
                  ->contents[cmp->hash_index * 2])               \
         ->contents[(n) * 2 - 1])
@@ -275,18 +275,18 @@ enum lglyph_indices
   };
 
 #define LGLYPH_NEW() Fmake_vector (make_fixnum (LGLYPH_SIZE), Qnil)
-#define LGLYPH_FROM(g) XINT (AREF ((g), LGLYPH_IX_FROM))
-#define LGLYPH_TO(g) XINT (AREF ((g), LGLYPH_IX_TO))
-#define LGLYPH_CHAR(g) XINT (AREF ((g), LGLYPH_IX_CHAR))
+#define LGLYPH_FROM(g) XFIXNUM (AREF ((g), LGLYPH_IX_FROM))
+#define LGLYPH_TO(g) XFIXNUM (AREF ((g), LGLYPH_IX_TO))
+#define LGLYPH_CHAR(g) XFIXNUM (AREF ((g), LGLYPH_IX_CHAR))
 #define LGLYPH_CODE(g)                                          \
   (NILP (AREF ((g), LGLYPH_IX_CODE))                            \
    ? FONT_INVALID_CODE                                          \
    : cons_to_unsigned (AREF (g, LGLYPH_IX_CODE), TYPE_MAXIMUM (unsigned)))
-#define LGLYPH_WIDTH(g) XINT (AREF ((g), LGLYPH_IX_WIDTH))
-#define LGLYPH_LBEARING(g) XINT (AREF ((g), LGLYPH_IX_LBEARING))
-#define LGLYPH_RBEARING(g) XINT (AREF ((g), LGLYPH_IX_RBEARING))
-#define LGLYPH_ASCENT(g) XINT (AREF ((g), LGLYPH_IX_ASCENT))
-#define LGLYPH_DESCENT(g) XINT (AREF ((g), LGLYPH_IX_DESCENT))
+#define LGLYPH_WIDTH(g) XFIXNUM (AREF ((g), LGLYPH_IX_WIDTH))
+#define LGLYPH_LBEARING(g) XFIXNUM (AREF ((g), LGLYPH_IX_LBEARING))
+#define LGLYPH_RBEARING(g) XFIXNUM (AREF ((g), LGLYPH_IX_RBEARING))
+#define LGLYPH_ASCENT(g) XFIXNUM (AREF ((g), LGLYPH_IX_ASCENT))
+#define LGLYPH_DESCENT(g) XFIXNUM (AREF ((g), LGLYPH_IX_DESCENT))
 #define LGLYPH_ADJUSTMENT(g) AREF ((g), LGLYPH_IX_ADJUSTMENT)
 #define LGLYPH_SET_FROM(g, val) ASET ((g), LGLYPH_IX_FROM, make_fixnum (val))
 #define LGLYPH_SET_TO(g, val) ASET ((g), LGLYPH_IX_TO, make_fixnum (val))
@@ -304,11 +304,11 @@ enum lglyph_indices
 #define LGLYPH_SET_ADJUSTMENT(g, val) ASET ((g), LGLYPH_IX_ADJUSTMENT, (val))
 
 #define LGLYPH_XOFF(g) (VECTORP (LGLYPH_ADJUSTMENT (g)) \
-                        ? XINT (AREF (LGLYPH_ADJUSTMENT (g), 0)) : 0)
+                        ? XFIXNUM (AREF (LGLYPH_ADJUSTMENT (g), 0)) : 0)
 #define LGLYPH_YOFF(g) (VECTORP (LGLYPH_ADJUSTMENT (g)) \
-                        ? XINT (AREF (LGLYPH_ADJUSTMENT (g), 1)) : 0)
+                        ? XFIXNUM (AREF (LGLYPH_ADJUSTMENT (g), 1)) : 0)
 #define LGLYPH_WADJUST(g) (VECTORP (LGLYPH_ADJUSTMENT (g)) \
-                           ? XINT (AREF (LGLYPH_ADJUSTMENT (g), 2)) : 0)
+                           ? XFIXNUM (AREF (LGLYPH_ADJUSTMENT (g), 2)) : 0)
 
 extern Lisp_Object composition_gstring_put_cache (Lisp_Object, ptrdiff_t);
 extern Lisp_Object composition_gstring_from_id (ptrdiff_t);
diff --git a/src/data.c b/src/data.c
index 4388a2b0ffc..6512e7e6706 100644
--- a/src/data.c
+++ b/src/data.c
@@ -74,7 +74,7 @@ XKBOARD_OBJFWD (union Lisp_Fwd *a)
   return &a->u_kboard_objfwd;
 }
 static struct Lisp_Intfwd *
-XINTFWD (union Lisp_Fwd *a)
+XFIXNUMFWD (union Lisp_Fwd *a)
 {
   eassert (INTFWDP (a));
   return &a->u_intfwd;
@@ -1013,7 +1013,7 @@ do_symval_forwarding (register union Lisp_Fwd *valcontents)
   switch (XFWDTYPE (valcontents))
     {
     case Lisp_Fwd_Int:
-      XSETINT (val, *XINTFWD (valcontents)->intvar);
+      XSETINT (val, *XFIXNUMFWD (valcontents)->intvar);
       return val;
 
     case Lisp_Fwd_Bool:
@@ -1050,7 +1050,7 @@ do_symval_forwarding (register union Lisp_Fwd *valcontents)
 void
 wrong_choice (Lisp_Object choice, Lisp_Object wrong)
 {
-  ptrdiff_t i = 0, len = XINT (Flength (choice));
+  ptrdiff_t i = 0, len = XFIXNUM (Flength (choice));
   Lisp_Object obj, *args;
   AUTO_STRING (one_of, "One of ");
   AUTO_STRING (comma, ", ");
@@ -1106,7 +1106,7 @@ store_symval_forwarding (union Lisp_Fwd *valcontents, register Lisp_Object newva
     {
     case Lisp_Fwd_Int:
       CHECK_FIXNUM (newval);
-      *XINTFWD (valcontents)->intvar = XINT (newval);
+      *XFIXNUMFWD (valcontents)->intvar = XFIXNUM (newval);
       break;
 
     case Lisp_Fwd_Bool:
@@ -2254,7 +2254,7 @@ or a byte-code object.  IDX starts at 0.  */)
   register EMACS_INT idxval;
 
   CHECK_FIXNUM (idx);
-  idxval = XINT (idx);
+  idxval = XFIXNUM (idx);
   if (STRINGP (array))
     {
       int c;
@@ -2305,7 +2305,7 @@ bool-vector.  IDX starts at 0.  */)
   register EMACS_INT idxval;
 
   CHECK_FIXNUM (idx);
-  idxval = XINT (idx);
+  idxval = XFIXNUM (idx);
   if (! RECORDP (array))
     CHECK_ARRAY (array, Qarrayp);
 
@@ -2341,7 +2341,7 @@ bool-vector.  IDX starts at 0.  */)
       if (idxval < 0 || idxval >= SCHARS (array))
         args_out_of_range (array, idx);
       CHECK_CHARACTER (newelt);
-      c = XFASTINT (newelt);
+      c = XFIXNAT (newelt);
 
       if (STRING_MULTIBYTE (array))
         {
@@ -2420,16 +2420,16 @@ bignumcompare (Lisp_Object num1, Lisp_Object num2,
         }
       else if (FIXNUMP (num2))
         {
-          if (sizeof (EMACS_INT) > sizeof (long) && XINT (num2) > LONG_MAX)
+          if (sizeof (EMACS_INT) > sizeof (long) && XFIXNUM (num2) > LONG_MAX)
             {
               mpz_t tem;
               mpz_init (tem);
-              mpz_set_intmax (tem, XINT (num2));
+              mpz_set_intmax (tem, XFIXNUM (num2));
               cmp = mpz_cmp (XBIGNUM (num1)->value, tem);
               mpz_clear (tem);
             }
           else
-            cmp = mpz_cmp_si (XBIGNUM (num1)->value, XINT (num2));
+            cmp = mpz_cmp_si (XBIGNUM (num1)->value, XFIXNUM (num2));
         }
       else
         {
@@ -2451,16 +2451,16 @@ bignumcompare (Lisp_Object num1, Lisp_Object num2,
       else
         {
           eassume (FIXNUMP (num1));
-          if (sizeof (EMACS_INT) > sizeof (long) && XINT (num1) > LONG_MAX)
+          if (sizeof (EMACS_INT) > sizeof (long) && XFIXNUM (num1) > LONG_MAX)
             {
               mpz_t tem;
               mpz_init (tem);
-              mpz_set_intmax (tem, XINT (num1));
+              mpz_set_intmax (tem, XFIXNUM (num1));
               cmp = - mpz_cmp (XBIGNUM (num2)->value, tem);
               mpz_clear (tem);
             }
           else
-            cmp = - mpz_cmp_si (XBIGNUM (num2)->value, XINT (num1));
+            cmp = - mpz_cmp_si (XBIGNUM (num2)->value, XFIXNUM (num1));
         }
     }
 
@@ -2537,13 +2537,13 @@ arithcompare (Lisp_Object num1, Lisp_Object num2,
              floating-point comparison reports a tie, NUM1 = F1 = F2 = I1
              (exactly) so I1 - I2 = NUM1 - NUM2 (exactly), so comparing I1
              to I2 will break the tie correctly.  */
-          i1 = f2 = i2 = XINT (num2);
+          i1 = f2 = i2 = XFIXNUM (num2);
         }
       fneq = f1 != f2;
     }
   else
     {
-      i1 = XINT (num1);
+      i1 = XFIXNUM (num1);
       if (FLOATP (num2))
         {
           /* Compare an integer NUM1 to a float NUM2.  This is the
@@ -2554,7 +2554,7 @@ arithcompare (Lisp_Object num1, Lisp_Object num2,
         }
       else
         {
-          i2 = XINT (num2);
+          i2 = XFIXNUM (num2);
           fneq = false;
         }
     }
@@ -2687,8 +2687,8 @@ cons_to_unsigned (Lisp_Object c, uintmax_t max)
   uintmax_t val UNINIT;
   if (FIXNUMP (c))
     {
-      valid = XINT (c) >= 0;
-      val = XINT (c);
+      valid = XFIXNUM (c) >= 0;
+      val = XFIXNUM (c);
     }
   else if (FLOATP (c))
     {
@@ -2701,24 +2701,24 @@ cons_to_unsigned (Lisp_Object c, uintmax_t max)
     }
   else if (CONSP (c) && FIXNATP (XCAR (c)))
     {
-      uintmax_t top = XFASTINT (XCAR (c));
+      uintmax_t top = XFIXNAT (XCAR (c));
       Lisp_Object rest = XCDR (c);
       if (top <= UINTMAX_MAX >> 24 >> 16
           && CONSP (rest)
-          && FIXNATP (XCAR (rest)) && XFASTINT (XCAR (rest)) < 1 << 24
-          && FIXNATP (XCDR (rest)) && XFASTINT (XCDR (rest)) < 1 << 16)
+          && FIXNATP (XCAR (rest)) && XFIXNAT (XCAR (rest)) < 1 << 24
+          && FIXNATP (XCDR (rest)) && XFIXNAT (XCDR (rest)) < 1 << 16)
         {
-          uintmax_t mid = XFASTINT (XCAR (rest));
-          val = top << 24 << 16 | mid << 16 | XFASTINT (XCDR (rest));
+          uintmax_t mid = XFIXNAT (XCAR (rest));
+          val = top << 24 << 16 | mid << 16 | XFIXNAT (XCDR (rest));
           valid = true;
         }
       else if (top <= UINTMAX_MAX >> 16)
         {
           if (CONSP (rest))
             rest = XCAR (rest);
-          if (FIXNATP (rest) && XFASTINT (rest) < 1 << 16)
+          if (FIXNATP (rest) && XFIXNAT (rest) < 1 << 16)
             {
-              val = top << 16 | XFASTINT (rest);
+              val = top << 16 | XFIXNAT (rest);
               valid = true;
             }
         }
@@ -2741,7 +2741,7 @@ cons_to_signed (Lisp_Object c, intmax_t min, intmax_t max)
   intmax_t val UNINIT;
   if (FIXNUMP (c))
     {
-      val = XINT (c);
+      val = XFIXNUM (c);
       valid = true;
     }
   else if (FLOATP (c))
@@ -2755,24 +2755,24 @@ cons_to_signed (Lisp_Object c, intmax_t min, intmax_t max)
     }
   else if (CONSP (c) && FIXNUMP (XCAR (c)))
     {
-      intmax_t top = XINT (XCAR (c));
+      intmax_t top = XFIXNUM (XCAR (c));
       Lisp_Object rest = XCDR (c);
       if (top >= INTMAX_MIN >> 24 >> 16 && top <= INTMAX_MAX >> 24 >> 16
           && CONSP (rest)
-          && FIXNATP (XCAR (rest)) && XFASTINT (XCAR (rest)) < 1 << 24
-          && FIXNATP (XCDR (rest)) && XFASTINT (XCDR (rest)) < 1 << 16)
+          && FIXNATP (XCAR (rest)) && XFIXNAT (XCAR (rest)) < 1 << 24
+          && FIXNATP (XCDR (rest)) && XFIXNAT (XCDR (rest)) < 1 << 16)
         {
-          intmax_t mid = XFASTINT (XCAR (rest));
-          val = top << 24 << 16 | mid << 16 | XFASTINT (XCDR (rest));
+          intmax_t mid = XFIXNAT (XCAR (rest));
+          val = top << 24 << 16 | mid << 16 | XFIXNAT (XCDR (rest));
           valid = true;
         }
       else if (top >= INTMAX_MIN >> 16 && top <= INTMAX_MAX >> 16)
         {
           if (CONSP (rest))
             rest = XCAR (rest);
-          if (FIXNATP (rest) && XFASTINT (rest) < 1 << 16)
+          if (FIXNATP (rest) && XFIXNAT (rest) < 1 << 16)
             {
-              val = top << 16 | XFASTINT (rest);
+              val = top << 16 | XFIXNAT (rest);
               valid = true;
             }
         }
@@ -2805,7 +2805,7 @@ NUMBER may be an integer or a floating point number.  */)
   if (FLOATP (number))
     len = float_to_string (buffer, XFLOAT_DATA (number));
   else
-    len = sprintf (buffer, "%"pI"d", XINT (number));
+    len = sprintf (buffer, "%"pI"d", XFIXNUM (number));
 
   return make_unibyte_string (buffer, len);
 }
@@ -2829,9 +2829,9 @@ If the base used is not 10, STRING is always parsed as an integer.  */)
   else
     {
       CHECK_FIXNUM (base);
-      if (! (XINT (base) >= 2 && XINT (base) <= 16))
+      if (! (XFIXNUM (base) >= 2 && XFIXNUM (base) <= 16))
         xsignal1 (Qargs_out_of_range, base);
-      b = XINT (base);
+      b = XFIXNUM (base);
     }
 
   char *p = SSDATA (string);
@@ -2911,14 +2911,14 @@ arith_driver (enum arithop code, ptrdiff_t nargs, Lisp_Object *args)
             {
               mpz_t tem;
               mpz_init (tem);
-              mpz_set_intmax (tem, XINT (val));
+              mpz_set_intmax (tem, XFIXNUM (val));
               mpz_add (accum, accum, tem);
               mpz_clear (tem);
             }
-          else if (XINT (val) < 0)
-            mpz_sub_ui (accum, accum, - XINT (val));
+          else if (XFIXNUM (val) < 0)
+            mpz_sub_ui (accum, accum, - XFIXNUM (val));
           else
-            mpz_add_ui (accum, accum, XINT (val));
+            mpz_add_ui (accum, accum, XFIXNUM (val));
           break;
         case Asub:
           if (! argnum)
@@ -2926,7 +2926,7 @@ arith_driver (enum arithop code, ptrdiff_t nargs, Lisp_Object *args)
               if (BIGNUMP (val))
                 mpz_set (accum, XBIGNUM (val)->value);
               else
-                mpz_set_intmax (accum, XINT (val));
+                mpz_set_intmax (accum, XFIXNUM (val));
               if (nargs == 1)
                 mpz_neg (accum, accum);
             }
@@ -2936,14 +2936,14 @@ arith_driver (enum arithop code, ptrdiff_t nargs, Lisp_Object *args)
             {
               mpz_t tem;
               mpz_init (tem);
-              mpz_set_intmax (tem, XINT (val));
+              mpz_set_intmax (tem, XFIXNUM (val));
               mpz_sub (accum, accum, tem);
               mpz_clear (tem);
             }
-          else if (XINT (val) < 0)
-            mpz_add_ui (accum, accum, - XINT (val));
+          else if (XFIXNUM (val) < 0)
+            mpz_add_ui (accum, accum, - XFIXNUM (val));
           else
-            mpz_sub_ui (accum, accum, XINT (val));
+            mpz_sub_ui (accum, accum, XFIXNUM (val));
           break;
         case Amult:
           if (BIGNUMP (val))
@@ -2952,12 +2952,12 @@ arith_driver (enum arithop code, ptrdiff_t nargs, Lisp_Object *args)
             {
               mpz_t tem;
               mpz_init (tem);
-              mpz_set_intmax (tem, XINT (val));
+              mpz_set_intmax (tem, XFIXNUM (val));
               mpz_mul (accum, accum, tem);
               mpz_clear (tem);
             }
           else
-            mpz_mul_si (accum, accum, XINT (val));
+            mpz_mul_si (accum, accum, XFIXNUM (val));
           break;
         case Adiv:
           if (! (argnum || nargs == 1))
@@ -2965,13 +2965,13 @@ arith_driver (enum arithop code, ptrdiff_t nargs, Lisp_Object *args)
               if (BIGNUMP (val))
                 mpz_set (accum, XBIGNUM (val)->value);
               else
-                mpz_set_intmax (accum, XINT (val));
+                mpz_set_intmax (accum, XFIXNUM (val));
             }
           else
             {
               /* Note that a bignum can never be 0, so we don't need
                  to check that case.  */
-              if (FIXNUMP (val) && XINT (val) == 0)
+              if (FIXNUMP (val) && XFIXNUM (val) == 0)
                 xsignal0 (Qarith_error);
               if (BIGNUMP (val))
                 mpz_tdiv_q (accum, accum, XBIGNUM (val)->value);
@@ -2979,13 +2979,13 @@ arith_driver (enum arithop code, ptrdiff_t nargs, Lisp_Object *args)
                 {
                   mpz_t tem;
                   mpz_init (tem);
-                  mpz_set_intmax (tem, XINT (val));
+                  mpz_set_intmax (tem, XFIXNUM (val));
                   mpz_tdiv_q (accum, accum, tem);
                   mpz_clear (tem);
                 }
               else
                 {
-                  EMACS_INT value = XINT (val);
+                  EMACS_INT value = XFIXNUM (val);
                   bool negate = value < 0;
                   if (negate)
                     value = -value;
@@ -3002,7 +3002,7 @@ arith_driver (enum arithop code, ptrdiff_t nargs, Lisp_Object *args)
             {
               mpz_t tem;
               mpz_init (tem);
-              mpz_set_uintmax (tem, XUINT (val));
+              mpz_set_uintmax (tem, XUFIXNUM (val));
               mpz_and (accum, accum, tem);
               mpz_clear (tem);
             }
@@ -3014,7 +3014,7 @@ arith_driver (enum arithop code, ptrdiff_t nargs, Lisp_Object *args)
             {
               mpz_t tem;
               mpz_init (tem);
-              mpz_set_uintmax (tem, XUINT (val));
+              mpz_set_uintmax (tem, XUFIXNUM (val));
               mpz_ior (accum, accum, tem);
               mpz_clear (tem);
             }
@@ -3026,7 +3026,7 @@ arith_driver (enum arithop code, ptrdiff_t nargs, Lisp_Object *args)
             {
               mpz_t tem;
               mpz_init (tem);
-              mpz_set_uintmax (tem, XUINT (val));
+              mpz_set_uintmax (tem, XUFIXNUM (val));
               mpz_xor (accum, accum, tem);
               mpz_clear (tem);
             }
@@ -3059,7 +3059,7 @@ float_arith_driver (double accum, ptrdiff_t argnum, enum arithop code,
       else
         {
           args[argnum] = val;    /* runs into a compiler bug. */
-          next = XINT (args[argnum]);
+          next = XFIXNUM (args[argnum]);
         }
       switch (code)
         {
@@ -3146,11 +3146,11 @@ Both must be integers or markers.  */)
 
   /* Note that a bignum can never be 0, so we don't need to check that
      case.  */
-  if (FIXNUMP (y) && XINT (y) == 0)
+  if (FIXNUMP (y) && XFIXNUM (y) == 0)
     xsignal0 (Qarith_error);
 
   if (FIXNUMP (x) && FIXNUMP (y))
-    XSETINT (val, XINT (x) % XINT (y));
+    XSETINT (val, XFIXNUM (x) % XFIXNUM (y));
   else
     {
       mpz_t xm, ym, *xmp, *ymp;
@@ -3161,7 +3161,7 @@ Both must be integers or markers.  */)
       else
         {
           mpz_init (xm);
-          mpz_set_intmax (xm, XINT (x));
+          mpz_set_intmax (xm, XFIXNUM (x));
           xmp = &xm;
         }
 
@@ -3170,7 +3170,7 @@ Both must be integers or markers.  */)
       else
         {
           mpz_init (ym);
-          mpz_set_intmax (ym, XINT (y));
+          mpz_set_intmax (ym, XFIXNUM (y));
           ymp = &ym;
         }
 
@@ -3201,7 +3201,7 @@ Both X and Y must be numbers or markers.  */)
 
   /* Note that a bignum can never be 0, so we don't need to check that
      case.  */
-  if (FIXNUMP (y) && XINT (y) == 0)
+  if (FIXNUMP (y) && XFIXNUM (y) == 0)
     xsignal0 (Qarith_error);
 
   if (FLOATP (x) || FLOATP (y))
@@ -3209,8 +3209,8 @@ Both X and Y must be numbers or markers.  */)
 
   if (FIXNUMP (x) && FIXNUMP (y))
     {
-      i1 = XINT (x);
-      i2 = XINT (y);
+      i1 = XFIXNUM (x);
+      i2 = XFIXNUM (y);
 
       if (i2 == 0)
         xsignal0 (Qarith_error);
@@ -3234,7 +3234,7 @@ Both X and Y must be numbers or markers.  */)
       else
         {
           mpz_init (xm);
-          mpz_set_intmax (xm, XINT (x));
+          mpz_set_intmax (xm, XFIXNUM (x));
           xmp = &xm;
         }
 
@@ -3243,7 +3243,7 @@ Both X and Y must be numbers or markers.  */)
       else
         {
           mpz_init (ym);
-          mpz_set_intmax (ym, XINT (y));
+          mpz_set_intmax (ym, XFIXNUM (y));
           ymp = &ym;
         }
 
@@ -3354,7 +3354,7 @@ representation.  */)
     }
 
   eassume (FIXNUMP (value));
-  EMACS_INT v = XINT (value) < 0 ? -1 - XINT (value) : XINT (value);
+  EMACS_INT v = XFIXNUM (value) < 0 ? -1 - XFIXNUM (value) : XFIXNUM (value);
   return make_fixnum (EMACS_UINT_WIDTH <= UINT_WIDTH
                       ? count_one_bits (v)
                       : EMACS_UINT_WIDTH <= ULONG_WIDTH
@@ -3377,12 +3377,12 @@ ash_lsh_impl (Lisp_Object value, Lisp_Object count, bool lsh)
     {
       mpz_t result;
       mpz_init (result);
-      if (XINT (count) >= 0)
-        mpz_mul_2exp (result, XBIGNUM (value)->value, XINT (count));
+      if (XFIXNUM (count) >= 0)
+        mpz_mul_2exp (result, XBIGNUM (value)->value, XFIXNUM (count));
       else if (lsh)
-        mpz_tdiv_q_2exp (result, XBIGNUM (value)->value, - XINT (count));
+        mpz_tdiv_q_2exp (result, XBIGNUM (value)->value, - XFIXNUM (count));
       else
-        mpz_fdiv_q_2exp (result, XBIGNUM (value)->value, - XINT (count));
+        mpz_fdiv_q_2exp (result, XBIGNUM (value)->value, - XFIXNUM (count));
       val = make_number (result);
       mpz_clear (result);
     }
@@ -3393,19 +3393,19 @@ ash_lsh_impl (Lisp_Object value, Lisp_Object count, bool lsh)
       eassume (FIXNUMP (value));
       mpz_init (result);
 
-      mpz_set_intmax (result, XINT (value));
+      mpz_set_intmax (result, XFIXNUM (value));
 
-      if (XINT (count) >= 0)
-        mpz_mul_2exp (result, result, XINT (count));
+      if (XFIXNUM (count) >= 0)
+        mpz_mul_2exp (result, result, XFIXNUM (count));
       else if (lsh)
         {
           if (mpz_sgn (result) > 0)
-            mpz_fdiv_q_2exp (result, result, - XINT (count));
+            mpz_fdiv_q_2exp (result, result, - XFIXNUM (count));
           else
-            mpz_fdiv_q_2exp (result, result, - XINT (count));
+            mpz_fdiv_q_2exp (result, result, - XFIXNUM (count));
         }
       else /* ash */
-        mpz_fdiv_q_2exp (result, result, - XINT (count));
+        mpz_fdiv_q_2exp (result, result, - XFIXNUM (count));
 
       val = make_number (result);
       mpz_clear (result);
@@ -3453,13 +3453,13 @@ Markers are converted to integers.  */)
   else
     {
       eassume (FIXNUMP (number));
-      if (XINT (number) < MOST_POSITIVE_FIXNUM)
-        XSETINT (number, XINT (number) + 1);
+      if (XFIXNUM (number) < MOST_POSITIVE_FIXNUM)
+        XSETINT (number, XFIXNUM (number) + 1);
       else
         {
           mpz_t num;
           mpz_init (num);
-          mpz_set_intmax (num, XINT (number) + 1);
+          mpz_set_intmax (num, XFIXNUM (number) + 1);
           number = make_number (num);
           mpz_clear (num);
         }
@@ -3488,13 +3488,13 @@ Markers are converted to integers.  */)
   else
     {
       eassume (FIXNUMP (number));
-      if (XINT (number) > MOST_NEGATIVE_FIXNUM)
-        XSETINT (number, XINT (number) - 1);
+      if (XFIXNUM (number) > MOST_NEGATIVE_FIXNUM)
+        XSETINT (number, XFIXNUM (number) - 1);
       else
         {
           mpz_t num;
           mpz_init (num);
-          mpz_set_intmax (num, XINT (number) - 1);
+          mpz_set_intmax (num, XFIXNUM (number) - 1);
           number = make_number (num);
           mpz_clear (num);
         }
@@ -3518,7 +3518,7 @@ DEFUN ("lognot", Flognot, Slognot, 1, 1, 0,
   else
     {
       eassume (FIXNUMP (number));
-      XSETINT (number, ~XINT (number));
+      XSETINT (number, ~XFIXNUM (number));
     }
   return number;
 }
@@ -3908,13 +3908,13 @@ A is a bool vector, B is t or nil, and I is an index into A.  */)
   CHECK_FIXNAT (i);
 
   nr_bits = bool_vector_size (a);
-  if (XFASTINT (i) > nr_bits) /* Allow one past the end for convenience */
+  if (XFIXNAT (i) > nr_bits) /* Allow one past the end for convenience */
     args_out_of_range (a, i);
 
   adata = bool_vector_data (a);
   nr_words = bool_vector_words (nr_bits);
-  pos = XFASTINT (i) / BITS_PER_BITS_WORD;
-  offset = XFASTINT (i) % BITS_PER_BITS_WORD;
+  pos = XFIXNAT (i) / BITS_PER_BITS_WORD;
+  offset = XFIXNAT (i) % BITS_PER_BITS_WORD;
   count = 0;
 
   /* By XORing with twiddle, we transform the problem of "count
diff --git a/src/dbusbind.c b/src/dbusbind.c
index ac3e0626000..4cf5604d745 100644
--- a/src/dbusbind.c
+++ b/src/dbusbind.c
@@ -522,8 +522,8 @@ xd_extract_signed (Lisp_Object x, intmax_t lo, intmax_t hi)
   CHECK_FIXNUM_OR_FLOAT (x);
   if (FIXNUMP (x))
     {
-      if (lo <= XINT (x) && XINT (x) <= hi)
-        return XINT (x);
+      if (lo <= XFIXNUM (x) && XFIXNUM (x) <= hi)
+        return XFIXNUM (x);
     }
   else
     {
@@ -550,8 +550,8 @@ xd_extract_unsigned (Lisp_Object x, uintmax_t hi)
   CHECK_FIXNUM_OR_FLOAT (x);
   if (FIXNUMP (x))
     {
-      if (0 <= XINT (x) && XINT (x) <= hi)
-        return XINT (x);
+      if (0 <= XFIXNUM (x) && XFIXNUM (x) <= hi)
+        return XFIXNUM (x);
     }
   else
     {
@@ -586,7 +586,7 @@ xd_append_arg (int dtype, Lisp_Object object, DBusMessageIter *iter)
       case DBUS_TYPE_BYTE:
         CHECK_FIXNAT (object);
         {
-          unsigned char val = XFASTINT (object) & 0xFF;
+          unsigned char val = XFIXNAT (object) & 0xFF;
           XD_DEBUG_MESSAGE ("%c %u", dtype, val);
           if (!dbus_message_iter_append_basic (iter, dtype, &val))
             XD_SIGNAL2 (build_string ("Unable to append argument"), object);
@@ -1276,10 +1276,10 @@ usage: (dbus-message-internal &rest REST)  */)
   handler = Qnil;
 
   CHECK_FIXNAT (message_type);
-  if (! (DBUS_MESSAGE_TYPE_INVALID < XFASTINT (message_type)
-         && XFASTINT (message_type) < DBUS_NUM_MESSAGE_TYPES))
+  if (! (DBUS_MESSAGE_TYPE_INVALID < XFIXNAT (message_type)
+         && XFIXNAT (message_type) < DBUS_NUM_MESSAGE_TYPES))
     XD_SIGNAL2 (build_string ("Invalid message type"), message_type);
-  mtype = XFASTINT (message_type);
+  mtype = XFIXNAT (message_type);
 
   if ((mtype == DBUS_MESSAGE_TYPE_METHOD_CALL)
       || (mtype == DBUS_MESSAGE_TYPE_SIGNAL))
@@ -1410,7 +1410,7 @@ usage: (dbus-message-internal &rest REST)  */)
   if ((count + 2 <= nargs) && EQ (args[count], QCtimeout))
     {
       CHECK_FIXNAT (args[count+1]);
-      timeout = min (XFASTINT (args[count+1]), INT_MAX);
+      timeout = min (XFIXNAT (args[count+1]), INT_MAX);
       count = count+2;
     }
 
diff --git a/src/decompress.c b/src/decompress.c
index 6f75f821c40..9f7fbe41952 100644
--- a/src/decompress.c
+++ b/src/decompress.c
@@ -149,8 +149,8 @@ This function can be called only in unibyte buffers.  */)
 
   /* This is a unibyte buffer, so character positions and bytes are
      the same.  */
-  istart = XINT (start);
-  iend = XINT (end);
+  istart = XFIXNUM (start);
+  iend = XFIXNUM (end);
 
   /* Do the following before manipulating the gap. */
   modify_text (istart, iend);
diff --git a/src/dired.c b/src/dired.c
index a0b10d070ec..3bb5997bd69 100644
--- a/src/dired.c
+++ b/src/dired.c
@@ -704,7 +704,7 @@ file_name_completion (Lisp_Object file, Lisp_Object dirname, bool all_flag,
             = Fcompare_strings (bestmatch, zero, make_fixnum (compare),
                                 name, zero, make_fixnum (compare),
                                 completion_ignore_case ? Qt : Qnil);
-          ptrdiff_t matchsize = EQ (cmp, Qt) ? compare : eabs (XINT (cmp)) - 1;
+          ptrdiff_t matchsize = EQ (cmp, Qt) ? compare : eabs (XFIXNUM (cmp)) - 1;
 
           if (completion_ignore_case)
             {
diff --git a/src/dispextern.h b/src/dispextern.h
index 0e70b3f7247..944a37d4889 100644
--- a/src/dispextern.h
+++ b/src/dispextern.h
@@ -306,24 +306,24 @@ INLINE int
 GLYPH_CODE_CHAR (Lisp_Object gc)
 {
   return (CONSP (gc)
-          ? XINT (XCAR (gc))
-          : XINT (gc) & MAX_CHAR);
+          ? XFIXNUM (XCAR (gc))
+          : XFIXNUM (gc) & MAX_CHAR);
 }
 
 INLINE int
 GLYPH_CODE_FACE (Lisp_Object gc)
 {
-  return CONSP (gc) ? XINT (XCDR (gc)) : XINT (gc) >> CHARACTERBITS;
+  return CONSP (gc) ? XFIXNUM (XCDR (gc)) : XFIXNUM (gc) >> CHARACTERBITS;
 }
 
 #define SET_GLYPH_FROM_GLYPH_CODE(glyph, gc)                            \
   do                                                                    \
     {                                                                   \
       if (CONSP (gc))                                                   \
-        SET_GLYPH (glyph, XINT (XCAR (gc)), XINT (XCDR (gc)));          \
+        SET_GLYPH (glyph, XFIXNUM (XCAR (gc)), XFIXNUM (XCDR (gc)));            \
       else                                                              \
-        SET_GLYPH (glyph, (XINT (gc) & ((1 << CHARACTERBITS)-1)),       \
-                   (XINT (gc) >> CHARACTERBITS));                       \
+        SET_GLYPH (glyph, (XFIXNUM (gc) & ((1 << CHARACTERBITS)-1)),    \
+                   (XFIXNUM (gc) >> CHARACTERBITS));                    \
     }                                                                   \
   while (false)
 
diff --git a/src/dispnew.c b/src/dispnew.c
index 0daa23e700d..b54ae883649 100644
--- a/src/dispnew.c
+++ b/src/dispnew.c
@@ -5718,7 +5718,7 @@ additional wait period, in milliseconds; this is for backwards compatibility.
   if (!NILP (milliseconds))
     {
       CHECK_FIXNUM (milliseconds);
-      duration += XINT (milliseconds) / 1000.0;
+      duration += XFIXNUM (milliseconds) / 1000.0;
     }
 
   if (duration > 0)
@@ -5768,7 +5768,7 @@ sit_for (Lisp_Object timeout, bool reading, int display_option)
 
   if (FIXNUMP (timeout))
     {
-      sec = XINT (timeout);
+      sec = XFIXNUM (timeout);
       if (sec <= 0)
         return Qt;
       nsec = 0;
diff --git a/src/disptab.h b/src/disptab.h
index 3911efcf4f6..c8de011f7d6 100644
--- a/src/disptab.h
+++ b/src/disptab.h
@@ -79,7 +79,7 @@ extern struct Lisp_Char_Table *buffer_display_table (void);
 #define GLYPH_FOLLOW_ALIASES(base, length, g)                   \
   do {                                                          \
     while (GLYPH_ALIAS_P ((base), (length), (g)))               \
-      SET_GLYPH_CHAR ((g), XINT ((base)[GLYPH_CHAR (g)]));      \
+      SET_GLYPH_CHAR ((g), XFIXNUM ((base)[GLYPH_CHAR (g)]));   \
     if (!GLYPH_CHAR_VALID_P (g))                                \
       SET_GLYPH_CHAR (g, ' ');                                  \
   } while (false)
diff --git a/src/doc.c b/src/doc.c
index a71c81b4e96..343734637fc 100644
--- a/src/doc.c
+++ b/src/doc.c
@@ -102,7 +102,7 @@ get_doc_string (Lisp_Object filepos, bool unibyte, bool definition)
   else
     return Qnil;
 
-  position = eabs (XINT (pos));
+  position = eabs (XFIXNUM (pos));
 
   if (!STRINGP (Vdoc_directory))
     return Qnil;
diff --git a/src/dosfns.c b/src/dosfns.c
index e68c1a71354..25932ff1e1c 100644
--- a/src/dosfns.c
+++ b/src/dosfns.c
@@ -67,21 +67,21 @@ REGISTERS should be a vector produced by `make-register' and
   union REGS inregs, outregs;
 
   CHECK_FIXNUM (interrupt);
-  no = (unsigned long) XINT (interrupt);
+  no = (unsigned long) XFIXNUM (interrupt);
   CHECK_VECTOR (registers);
   if (no < 0 || no > 0xff || ASIZE (registers) != 8)
     return Qnil;
   for (i = 0; i < 8; i++)
     CHECK_FIXNUM (AREF (registers, i));
 
-  inregs.x.ax    = (unsigned long) XFASTINT (AREF (registers, 0));
-  inregs.x.bx    = (unsigned long) XFASTINT (AREF (registers, 1));
-  inregs.x.cx    = (unsigned long) XFASTINT (AREF (registers, 2));
-  inregs.x.dx    = (unsigned long) XFASTINT (AREF (registers, 3));
-  inregs.x.si    = (unsigned long) XFASTINT (AREF (registers, 4));
-  inregs.x.di    = (unsigned long) XFASTINT (AREF (registers, 5));
-  inregs.x.cflag = (unsigned long) XFASTINT (AREF (registers, 6));
-  inregs.x.flags = (unsigned long) XFASTINT (AREF (registers, 7));
+  inregs.x.ax    = (unsigned long) XFIXNAT (AREF (registers, 0));
+  inregs.x.bx    = (unsigned long) XFIXNAT (AREF (registers, 1));
+  inregs.x.cx    = (unsigned long) XFIXNAT (AREF (registers, 2));
+  inregs.x.dx    = (unsigned long) XFIXNAT (AREF (registers, 3));
+  inregs.x.si    = (unsigned long) XFIXNAT (AREF (registers, 4));
+  inregs.x.di    = (unsigned long) XFIXNAT (AREF (registers, 5));
+  inregs.x.cflag = (unsigned long) XFIXNAT (AREF (registers, 6));
+  inregs.x.flags = (unsigned long) XFIXNAT (AREF (registers, 7));
 
   int86 (no, &inregs, &outregs);
 
@@ -107,7 +107,7 @@ Return the updated VECTOR.  */)
   char *buf;
 
   CHECK_FIXNUM (address);
-  offs = (unsigned long) XINT (address);
+  offs = (unsigned long) XFIXNUM (address);
   CHECK_VECTOR (vector);
   len = ASIZE (vector);
   if (len < 1 || len > 2048 || offs < 0 || offs > 0xfffff - len)
@@ -130,7 +130,7 @@ DEFUN ("msdos-memput", Fdos_memput, Sdos_memput, 2, 2, 0,
   char *buf;
 
   CHECK_FIXNUM (address);
-  offs = (unsigned long) XINT (address);
+  offs = (unsigned long) XFIXNUM (address);
   CHECK_VECTOR (vector);
   len = ASIZE (vector);
   if (len < 1 || len > 2048 || offs < 0 || offs > 0xfffff - len)
@@ -140,7 +140,7 @@ DEFUN ("msdos-memput", Fdos_memput, Sdos_memput, 2, 2, 0,
   for (i = 0; i < len; i++)
     {
       CHECK_FIXNUM (AREF (vector, i));
-      buf[i] = (unsigned char) XFASTINT (AREF (vector, i)) & 0xFF;
+      buf[i] = (unsigned char) XFIXNAT (AREF (vector, i)) & 0xFF;
     }
 
   dosmemput (buf, len, offs);
@@ -155,7 +155,7 @@ The current keyboard layout is available in dos-keyboard-code.  */)
   (Lisp_Object country_code, Lisp_Object allkeys)
 {
   CHECK_FIXNUM (country_code);
-  if (!dos_set_keyboard (XINT (country_code), !NILP (allkeys)))
+  if (!dos_set_keyboard (XFIXNUM (country_code), !NILP (allkeys)))
     return Qnil;
   return Qt;
 }
@@ -521,7 +521,7 @@ system_process_attributes (Lisp_Object pid)
   Lisp_Object attrs = Qnil;
 
   CHECK_FIXNUM_OR_FLOAT (pid);
-  proc_id = FLOATP (pid) ? XFLOAT_DATA (pid) : XINT (pid);
+  proc_id = FLOATP (pid) ? XFLOAT_DATA (pid) : XFIXNUM (pid);
 
   if (proc_id == getpid ())
     {
diff --git a/src/editfns.c b/src/editfns.c
index 09c17cbd926..f9157cd8449 100644
--- a/src/editfns.c
+++ b/src/editfns.c
@@ -181,7 +181,7 @@ tzlookup (Lisp_Object zone, bool settz)
               zone = XCAR (zone);
             }
 
-          EMACS_INT abszone = eabs (XINT (zone)), hour = abszone / (60 * 60);
+          EMACS_INT abszone = eabs (XFIXNUM (zone)), hour = abszone / (60 * 60);
           int hour_remainder = abszone % (60 * 60);
           int min = hour_remainder / 60, sec = hour_remainder % 60;
 
@@ -196,8 +196,8 @@ tzlookup (Lisp_Object zone, bool settz)
                     prec += 2, numzone = 100 * numzone + sec;
                 }
               sprintf (tzbuf, tzbuf_format, prec,
-                       XINT (zone) < 0 ? -numzone : numzone,
-                       &"-"[XINT (zone) < 0], hour, min, sec);
+                       XFIXNUM (zone) < 0 ? -numzone : numzone,
+                       &"-"[XFIXNUM (zone) < 0], hour, min, sec);
               zone_string = tzbuf;
             }
           else
@@ -205,7 +205,7 @@ tzlookup (Lisp_Object zone, bool settz)
               AUTO_STRING (leading, "<");
               AUTO_STRING_WITH_LEN (trailing, tzbuf,
                                     sprintf (tzbuf, trailing_tzbuf_format,
-                                             &"-"[XINT (zone) < 0],
+                                             &"-"[XFIXNUM (zone) < 0],
                                              hour, min, sec));
               zone_string = SSDATA (concat3 (leading, ENCODE_SYSTEM (abbr),
                                              trailing));
@@ -217,11 +217,11 @@ tzlookup (Lisp_Object zone, bool settz)
       new_tz = tzalloc (zone_string);
 
       if (HAVE_TZALLOC_BUG && !new_tz && errno != ENOMEM && plain_integer
-          && XINT (zone) % (60 * 60) == 0)
+          && XFIXNUM (zone) % (60 * 60) == 0)
         {
           /* tzalloc mishandles POSIX strings; fall back on tzdb if
              possible (Bug#30738).  */
-          sprintf (tzbuf, "Etc/GMT%+"pI"d", - (XINT (zone) / (60 * 60)));
+          sprintf (tzbuf, "Etc/GMT%+"pI"d", - (XFIXNUM (zone) / (60 * 60)));
           new_tz = tzalloc (zone_string);
         }
 
@@ -359,7 +359,7 @@ usage: (char-to-string CHAR)  */)
   unsigned char str[MAX_MULTIBYTE_LENGTH];
 
   CHECK_CHARACTER (character);
-  c = XFASTINT (character);
+  c = XFIXNAT (character);
 
   len = CHAR_STRING (c, str);
   return make_string_from_bytes ((char *) str, 1, len);
@@ -371,9 +371,9 @@ DEFUN ("byte-to-string", Fbyte_to_string, Sbyte_to_string, 1, 1, 0,
 {
   unsigned char b;
   CHECK_FIXNUM (byte);
-  if (XINT (byte) < 0 || XINT (byte) > 255)
+  if (XFIXNUM (byte) < 0 || XFIXNUM (byte) > 255)
     error ("Invalid byte");
-  b = XINT (byte);
+  b = XFIXNUM (byte);
   return make_string_from_bytes ((char *) &b, 1, 1);
 }
 
@@ -422,7 +422,7 @@ The return value is POSITION.  */)
   if (MARKERP (position))
     set_point_from_marker (position);
   else if (FIXNUMP (position))
-    SET_PT (clip_to_bounds (BEGV, XINT (position), ZV));
+    SET_PT (clip_to_bounds (BEGV, XFIXNUM (position), ZV));
   else
     wrong_type_argument (Qinteger_or_marker_p, position);
   return position;
@@ -448,9 +448,9 @@ region_limit (bool beginningp)
     error ("The mark is not set now, so there is no region");
 
   /* Clip to the current narrowing (bug#11770).  */
-  return make_fixnum ((PT < XFASTINT (m)) == beginningp
+  return make_fixnum ((PT < XFIXNAT (m)) == beginningp
                       ? PT
-                      : clip_to_bounds (BEGV, XFASTINT (m), ZV));
+                      : clip_to_bounds (BEGV, XFIXNAT (m), ZV));
 }
 
 DEFUN ("region-beginning", Fregion_beginning, Sregion_beginning, 0, 0, 0,
@@ -553,7 +553,7 @@ at POSITION.  */)
     return Fget_text_property (position, prop, object);
   else
     {
-      EMACS_INT posn = XINT (position);
+      EMACS_INT posn = XFIXNUM (position);
       ptrdiff_t noverlays;
       Lisp_Object *overlay_vec, tem;
       struct buffer *obuf = current_buffer;
@@ -606,8 +606,8 @@ at POSITION.  */)
         if (stickiness > 0)
           return Fget_text_property (position, prop, object);
         else if (stickiness < 0
-                 && XINT (position) > BUF_BEGV (XBUFFER (object)))
-          return Fget_text_property (make_fixnum (XINT (position) - 1),
+                 && XFIXNUM (position) > BUF_BEGV (XBUFFER (object)))
+          return Fget_text_property (make_fixnum (XFIXNUM (position) - 1),
                                      prop, object);
         else
           return Qnil;
@@ -655,8 +655,8 @@ find_field (Lisp_Object pos, Lisp_Object merge_at_boundary,
   after_field
     = get_char_property_and_overlay (pos, Qfield, Qnil, NULL);
   before_field
-    = (XFASTINT (pos) > BEGV
-       ? get_char_property_and_overlay (make_fixnum (XINT (pos) - 1),
+    = (XFIXNAT (pos) > BEGV
+       ? get_char_property_and_overlay (make_fixnum (XFIXNUM (pos) - 1),
                                         Qfield, Qnil, NULL)
        /* Using nil here would be a more obvious choice, but it would
           fail when the buffer starts with a non-sticky field.  */
@@ -710,7 +710,7 @@ find_field (Lisp_Object pos, Lisp_Object merge_at_boundary,
       if (at_field_start)
         /* POS is at the edge of a field, and we should consider it as
            the beginning of the following field.  */
-        *beg = XFASTINT (pos);
+        *beg = XFIXNAT (pos);
       else
         /* Find the previous field boundary.  */
         {
@@ -722,7 +722,7 @@ find_field (Lisp_Object pos, Lisp_Object merge_at_boundary,
 
           p = Fprevious_single_char_property_change (p, Qfield, Qnil,
                                                      beg_limit);
-          *beg = NILP (p) ? BEGV : XFASTINT (p);
+          *beg = NILP (p) ? BEGV : XFIXNAT (p);
         }
     }
 
@@ -731,7 +731,7 @@ find_field (Lisp_Object pos, Lisp_Object merge_at_boundary,
       if (at_field_end)
         /* POS is at the edge of a field, and we should consider it as
            the end of the previous field.  */
-        *end = XFASTINT (pos);
+        *end = XFIXNAT (pos);
       else
         /* Find the next field boundary.  */
         {
@@ -742,7 +742,7 @@ find_field (Lisp_Object pos, Lisp_Object merge_at_boundary,
 
           pos = Fnext_single_char_property_change (pos, Qfield, Qnil,
                                                    end_limit);
-          *end = NILP (pos) ? ZV : XFASTINT (pos);
+          *end = NILP (pos) ? ZV : XFIXNAT (pos);
         }
     }
 }
@@ -859,10 +859,10 @@ Field boundaries are not noticed if `inhibit-field-text-motion' is non-nil.  */)
   CHECK_FIXNUM_COERCE_MARKER (new_pos);
   CHECK_FIXNUM_COERCE_MARKER (old_pos);
 
-  fwd = (XINT (new_pos) > XINT (old_pos));
+  fwd = (XFIXNUM (new_pos) > XFIXNUM (old_pos));
 
-  prev_old = make_fixnum (XINT (old_pos) - 1);
-  prev_new = make_fixnum (XINT (new_pos) - 1);
+  prev_old = make_fixnum (XFIXNUM (old_pos) - 1);
+  prev_new = make_fixnum (XFIXNUM (new_pos) - 1);
 
   if (NILP (Vinhibit_field_text_motion)
       && !EQ (new_pos, old_pos)
@@ -872,16 +872,16 @@ Field boundaries are not noticed if `inhibit-field-text-motion' is non-nil.  */)
              previous positions; we could use `Fget_pos_property'
              instead, but in itself that would fail inside non-sticky
              fields (like comint prompts).  */
-          || (XFASTINT (new_pos) > BEGV
+          || (XFIXNAT (new_pos) > BEGV
               && !NILP (Fget_char_property (prev_new, Qfield, Qnil)))
-          || (XFASTINT (old_pos) > BEGV
+          || (XFIXNAT (old_pos) > BEGV
               && !NILP (Fget_char_property (prev_old, Qfield, Qnil))))
       && (NILP (inhibit_capture_property)
           /* Field boundaries are again a problem; but now we must
              decide the case exactly, so we need to call
              `get_pos_property' as well.  */
           || (NILP (Fget_pos_property (old_pos, inhibit_capture_property, Qnil))
-              && (XFASTINT (old_pos) <= BEGV
+              && (XFIXNAT (old_pos) <= BEGV
                   || NILP (Fget_char_property
                            (old_pos, inhibit_capture_property, Qnil))
                   || NILP (Fget_char_property
@@ -901,7 +901,7 @@ Field boundaries are not noticed if `inhibit-field-text-motion' is non-nil.  */)
              other side of NEW_POS, which would mean that NEW_POS is
              already acceptable, and it's not necessary to constrain it
              to FIELD_BOUND.  */
-          ((XFASTINT (field_bound) < XFASTINT (new_pos)) ? fwd : !fwd)
+          ((XFIXNAT (field_bound) < XFIXNAT (new_pos)) ? fwd : !fwd)
           /* NEW_POS should be constrained, but only if either
              ONLY_IN_LINE is nil (in which case any constraint is OK),
              or NEW_POS and FIELD_BOUND are on the same line (in which
@@ -910,16 +910,16 @@ Field boundaries are not noticed if `inhibit-field-text-motion' is non-nil.  */)
               /* This is the ONLY_IN_LINE case, check that NEW_POS and
                  FIELD_BOUND are on the same line by seeing whether
                  there's an intervening newline or not.  */
-              || (find_newline (XFASTINT (new_pos), -1,
-                                XFASTINT (field_bound), -1,
+              || (find_newline (XFIXNAT (new_pos), -1,
+                                XFIXNAT (field_bound), -1,
                                 fwd ? -1 : 1, &shortage, NULL, 1),
                   shortage != 0)))
         /* Constrain NEW_POS to FIELD_BOUND.  */
         new_pos = field_bound;
 
-      if (orig_point && XFASTINT (new_pos) != orig_point)
+      if (orig_point && XFIXNAT (new_pos) != orig_point)
         /* The NEW_POS argument was originally nil, so automatically set PT. */
-        SET_PT (XFASTINT (new_pos));
+        SET_PT (XFIXNAT (new_pos));
     }
 
   return new_pos;
@@ -952,11 +952,11 @@ This function does not move point.  */)
   else
     CHECK_FIXNUM (n);
 
-  scan_newline_from_point (XINT (n) - 1, &charpos, &bytepos);
+  scan_newline_from_point (XFIXNUM (n) - 1, &charpos, &bytepos);
 
   /* Return END constrained to the current input field.  */
   return Fconstrain_to_field (make_fixnum (charpos), make_fixnum (PT),
-                              XINT (n) != 1 ? Qt : Qnil,
+                              XFIXNUM (n) != 1 ? Qt : Qnil,
                               Qt, Qnil);
 }
 
@@ -987,7 +987,7 @@ This function does not move point.  */)
   else
     CHECK_FIXNUM (n);
 
-  clipped_n = clip_to_bounds (PTRDIFF_MIN + 1, XINT (n), PTRDIFF_MAX);
+  clipped_n = clip_to_bounds (PTRDIFF_MIN + 1, XFIXNUM (n), PTRDIFF_MAX);
   end_pos = find_before_next_newline (orig, 0, clipped_n - (clipped_n <= 0),
                                       NULL);
 
@@ -1161,9 +1161,9 @@ If POSITION is out of range, the value is nil.  */)
   (Lisp_Object position)
 {
   CHECK_FIXNUM_COERCE_MARKER (position);
-  if (XINT (position) < BEG || XINT (position) > Z)
+  if (XFIXNUM (position) < BEG || XFIXNUM (position) > Z)
     return Qnil;
-  return make_fixnum (CHAR_TO_BYTE (XINT (position)));
+  return make_fixnum (CHAR_TO_BYTE (XFIXNUM (position)));
 }
 
 DEFUN ("byte-to-position", Fbyte_to_position, Sbyte_to_position, 1, 1, 0,
@@ -1174,7 +1174,7 @@ If BYTEPOS is out of range, the value is nil.  */)
   ptrdiff_t pos_byte;
 
   CHECK_FIXNUM (bytepos);
-  pos_byte = XINT (bytepos);
+  pos_byte = XFIXNUM (bytepos);
   if (pos_byte < BEG_BYTE || pos_byte > Z_BYTE)
     return Qnil;
   if (Z != Z_BYTE)
@@ -1281,10 +1281,10 @@ If POS is out of range, the value is nil.  */)
   else
     {
       CHECK_FIXNUM_COERCE_MARKER (pos);
-      if (XINT (pos) < BEGV || XINT (pos) >= ZV)
+      if (XFIXNUM (pos) < BEGV || XFIXNUM (pos) >= ZV)
         return Qnil;
 
-      pos_byte = CHAR_TO_BYTE (XINT (pos));
+      pos_byte = CHAR_TO_BYTE (XFIXNUM (pos));
     }
 
   return make_fixnum (FETCH_CHAR (pos_byte));
@@ -1316,10 +1316,10 @@ If POS is out of range, the value is nil.  */)
     {
       CHECK_FIXNUM_COERCE_MARKER (pos);
 
-      if (XINT (pos) <= BEGV || XINT (pos) > ZV)
+      if (XFIXNUM (pos) <= BEGV || XFIXNUM (pos) > ZV)
         return Qnil;
 
-      pos_byte = CHAR_TO_BYTE (XINT (pos));
+      pos_byte = CHAR_TO_BYTE (XFIXNUM (pos));
     }
 
   if (!NILP (BVAR (current_buffer, enable_multibyte_characters)))
@@ -1847,10 +1847,10 @@ decode_time_components (Lisp_Object high, Lisp_Object low, Lisp_Object usec,
         return 0;
     }
 
-  hi = XINT (high);
-  lo = XINT (low);
-  us = XINT (usec);
-  ps = XINT (psec);
+  hi = XFIXNUM (high);
+  lo = XFIXNUM (low);
+  us = XFIXNUM (usec);
+  ps = XFIXNUM (psec);
 
   /* Normalize out-of-range lower-order components by carrying
      each overflow into the next higher-order component.  */
@@ -2207,7 +2207,7 @@ static int
 check_tm_member (Lisp_Object obj, int offset)
 {
   CHECK_FIXNUM (obj);
-  EMACS_INT n = XINT (obj);
+  EMACS_INT n = XFIXNUM (obj);
   int result;
   if (INT_SUBTRACT_WRAPV (n, offset, &result))
     time_overflow ();
@@ -2532,7 +2532,7 @@ general_insert_function (void (*insert_func)
       val = args[argnum];
       if (CHARACTERP (val))
         {
-          int c = XFASTINT (val);
+          int c = XFIXNAT (val);
           unsigned char str[MAX_MULTIBYTE_LENGTH];
           int len;
 
@@ -2689,17 +2689,17 @@ called interactively, INHERIT is t.  */)
   if (NILP (count))
     XSETFASTINT (count, 1);
   CHECK_FIXNUM (count);
-  c = XFASTINT (character);
+  c = XFIXNAT (character);
 
   if (!NILP (BVAR (current_buffer, enable_multibyte_characters)))
     len = CHAR_STRING (c, str);
   else
     str[0] = c, len = 1;
-  if (XINT (count) <= 0)
+  if (XFIXNUM (count) <= 0)
     return Qnil;
-  if (BUF_BYTES_MAX / len < XINT (count))
+  if (BUF_BYTES_MAX / len < XFIXNUM (count))
     buffer_overflow ();
-  n = XINT (count) * len;
+  n = XFIXNUM (count) * len;
   stringlen = min (n, sizeof string - sizeof string % len);
   for (i = 0; i < stringlen; i++)
     string[i] = str[i % len];
@@ -2733,11 +2733,11 @@ from adjoining text, if those properties are sticky.  */)
   (Lisp_Object byte, Lisp_Object count, Lisp_Object inherit)
 {
   CHECK_FIXNUM (byte);
-  if (XINT (byte) < 0 || XINT (byte) > 255)
+  if (XFIXNUM (byte) < 0 || XFIXNUM (byte) > 255)
     args_out_of_range_3 (byte, make_fixnum (0), make_fixnum (255));
-  if (XINT (byte) >= 128
+  if (XFIXNUM (byte) >= 128
       && ! NILP (BVAR (current_buffer, enable_multibyte_characters)))
-    XSETFASTINT (byte, BYTE8_TO_CHAR (XINT (byte)));
+    XSETFASTINT (byte, BYTE8_TO_CHAR (XFIXNUM (byte)));
   return Finsert_char (byte, count, inherit);
 }
 
@@ -2823,7 +2823,7 @@ make_buffer_string_both (ptrdiff_t start, ptrdiff_t start_byte,
       tem = Fnext_property_change (make_fixnum (start), Qnil, make_fixnum (end));
       tem1 = Ftext_properties_at (make_fixnum (start), Qnil);
 
-      if (XINT (tem) != end || !NILP (tem1))
+      if (XFIXNUM (tem) != end || !NILP (tem1))
         copy_intervals_to_string (result, current_buffer, start,
                                   end - start);
     }
@@ -2872,8 +2872,8 @@ use `buffer-substring-no-properties' instead.  */)
   register ptrdiff_t b, e;
 
   validate_region (&start, &end);
-  b = XINT (start);
-  e = XINT (end);
+  b = XFIXNUM (start);
+  e = XFIXNUM (end);
 
   return make_buffer_string (b, e, 1);
 }
@@ -2888,8 +2888,8 @@ they can be in either order.  */)
   register ptrdiff_t b, e;
 
   validate_region (&start, &end);
-  b = XINT (start);
-  e = XINT (end);
+  b = XFIXNUM (start);
+  e = XFIXNUM (end);
 
   return make_buffer_string (b, e, 0);
 }
@@ -2935,14 +2935,14 @@ using `string-make-multibyte' or `string-make-unibyte', which see.  */)
   else
     {
       CHECK_FIXNUM_COERCE_MARKER (start);
-      b = XINT (start);
+      b = XFIXNUM (start);
     }
   if (NILP (end))
     e = BUF_ZV (bp);
   else
     {
       CHECK_FIXNUM_COERCE_MARKER (end);
-      e = XINT (end);
+      e = XFIXNUM (end);
     }
 
   if (b > e)
@@ -3003,14 +3003,14 @@ determines whether case is significant or ignored.  */)
   else
     {
       CHECK_FIXNUM_COERCE_MARKER (start1);
-      begp1 = XINT (start1);
+      begp1 = XFIXNUM (start1);
     }
   if (NILP (end1))
     endp1 = BUF_ZV (bp1);
   else
     {
       CHECK_FIXNUM_COERCE_MARKER (end1);
-      endp1 = XINT (end1);
+      endp1 = XFIXNUM (end1);
     }
 
   if (begp1 > endp1)
@@ -3041,14 +3041,14 @@ determines whether case is significant or ignored.  */)
   else
     {
       CHECK_FIXNUM_COERCE_MARKER (start2);
-      begp2 = XINT (start2);
+      begp2 = XFIXNUM (start2);
     }
   if (NILP (end2))
     endp2 = BUF_ZV (bp2);
   else
     {
       CHECK_FIXNUM_COERCE_MARKER (end2);
-      endp2 = XINT (end2);
+      endp2 = XFIXNUM (end2);
     }
 
   if (begp2 > endp2)
@@ -3439,8 +3439,8 @@ Both characters must have the same length of multi-byte form.  */)
   validate_region (&start, &end);
   CHECK_CHARACTER (fromchar);
   CHECK_CHARACTER (tochar);
-  fromc = XFASTINT (fromchar);
-  toc = XFASTINT (tochar);
+  fromc = XFIXNAT (fromchar);
+  toc = XFIXNAT (tochar);
 
   if (multibyte_p)
     {
@@ -3466,9 +3466,9 @@ Both characters must have the same length of multi-byte form.  */)
       tostr[0] = toc;
     }
 
-  pos = XINT (start);
+  pos = XFIXNUM (start);
   pos_byte = CHAR_TO_BYTE (pos);
-  stop = CHAR_TO_BYTE (XINT (end));
+  stop = CHAR_TO_BYTE (XFIXNUM (end));
   end_byte = stop;
 
   /* If we don't want undo, turn off putting stuff on the list.
@@ -3516,7 +3516,7 @@ Both characters must have the same length of multi-byte form.  */)
           else if (!changed)
             {
               changed = -1;
-              modify_text (pos, XINT (end));
+              modify_text (pos, XFIXNUM (end));
 
               if (! NILP (noundo))
                 {
@@ -3639,7 +3639,7 @@ check_translation (ptrdiff_t pos, ptrdiff_t pos_byte, ptrdiff_t end,
                   buf[buf_used++] = STRING_CHAR_AND_LENGTH (p, len1);
                   pos_byte += len1;
                 }
-              if (XINT (AREF (elt, i)) != buf[i])
+              if (XFIXNUM (AREF (elt, i)) != buf[i])
                 break;
             }
           if (i == len)
@@ -3691,9 +3691,9 @@ It returns the number of characters changed.  */)
       tt = SDATA (table);
     }
 
-  pos = XINT (start);
+  pos = XFIXNUM (start);
   pos_byte = CHAR_TO_BYTE (pos);
-  end_pos = XINT (end);
+  end_pos = XFIXNUM (end);
   modify_text (pos, end_pos);
 
   cnt = 0;
@@ -3742,7 +3742,7 @@ It returns the number of characters changed.  */)
               val = CHAR_TABLE_REF (table, oc);
               if (CHARACTERP (val))
                 {
-                  nc = XFASTINT (val);
+                  nc = XFIXNAT (val);
                   str_len = CHAR_STRING (nc, buf);
                   str = buf;
                 }
@@ -3827,7 +3827,7 @@ This command deletes buffer text without modifying the kill ring.  */)
   (Lisp_Object start, Lisp_Object end)
 {
   validate_region (&start, &end);
-  del_range (XINT (start), XINT (end));
+  del_range (XFIXNUM (start), XFIXNUM (end));
   return Qnil;
 }
 
@@ -3837,9 +3837,9 @@ DEFUN ("delete-and-extract-region", Fdelete_and_extract_region,
   (Lisp_Object start, Lisp_Object end)
 {
   validate_region (&start, &end);
-  if (XINT (start) == XINT (end))
+  if (XFIXNUM (start) == XFIXNUM (end))
     return empty_unibyte_string;
-  return del_range_1 (XINT (start), XINT (end), 1, 1);
+  return del_range_1 (XFIXNUM (start), XFIXNUM (end), 1, 1);
 }
 
 DEFUN ("widen", Fwiden, Swiden, 0, 0, "",
@@ -3871,24 +3871,24 @@ or markers) bounding the text that should remain visible.  */)
   CHECK_FIXNUM_COERCE_MARKER (start);
   CHECK_FIXNUM_COERCE_MARKER (end);
 
-  if (XINT (start) > XINT (end))
+  if (XFIXNUM (start) > XFIXNUM (end))
     {
       Lisp_Object tem;
       tem = start; start = end; end = tem;
     }
 
-  if (!(BEG <= XINT (start) && XINT (start) <= XINT (end) && XINT (end) <= Z))
+  if (!(BEG <= XFIXNUM (start) && XFIXNUM (start) <= XFIXNUM (end) && XFIXNUM (end) <= Z))
     args_out_of_range (start, end);
 
-  if (BEGV != XFASTINT (start) || ZV != XFASTINT (end))
+  if (BEGV != XFIXNAT (start) || ZV != XFIXNAT (end))
     current_buffer->clip_changed = 1;
 
-  SET_BUF_BEGV (current_buffer, XFASTINT (start));
-  SET_BUF_ZV (current_buffer, XFASTINT (end));
-  if (PT < XFASTINT (start))
-    SET_PT (XFASTINT (start));
-  if (PT > XFASTINT (end))
-    SET_PT (XFASTINT (end));
+  SET_BUF_BEGV (current_buffer, XFIXNAT (start));
+  SET_BUF_ZV (current_buffer, XFIXNAT (end));
+  if (PT < XFIXNAT (start))
+    SET_PT (XFIXNAT (start));
+  if (PT > XFIXNAT (end))
+    SET_PT (XFIXNAT (end));
   /* Changing the buffer bounds invalidates any recorded current column.  */
   invalidate_current_column ();
   return Qnil;
@@ -4475,7 +4475,7 @@ styled_format (ptrdiff_t nargs, Lisp_Object *args, bool message)
             }
           else if (conversion == 'c')
             {
-              if (FIXNUMP (arg) && ! ASCII_CHAR_P (XINT (arg)))
+              if (FIXNUMP (arg) && ! ASCII_CHAR_P (XFIXNUM (arg)))
                 {
                   if (!multibyte)
                     {
@@ -4717,7 +4717,7 @@ styled_format (ptrdiff_t nargs, Lisp_Object *args, bool message)
                       /* Although long double may have a rounding error if
                          DIG_BITS_LBOUND * LDBL_MANT_DIG < FIXNUM_BITS - 1,
                          it is more accurate than plain 'double'.  */
-                      long double x = XINT (arg);
+                      long double x = XFIXNUM (arg);
                       sprintf_bytes = sprintf (sprintf_buf, convspec, prec, x);
                     }
                   else
@@ -4727,7 +4727,7 @@ styled_format (ptrdiff_t nargs, Lisp_Object *args, bool message)
               else if (conversion == 'c')
                 {
                   /* Don't use sprintf here, as it might mishandle prec.  */
-                  sprintf_buf[0] = XINT (arg);
+                  sprintf_buf[0] = XFIXNUM (arg);
                   sprintf_bytes = prec != 0;
                   sprintf_buf[sprintf_bytes] = '\0';
                 }
@@ -4735,7 +4735,7 @@ styled_format (ptrdiff_t nargs, Lisp_Object *args, bool message)
                 {
                   if (FIXNUMP (arg))
                     {
-                      printmax_t x = XINT (arg);
+                      printmax_t x = XFIXNUM (arg);
                       sprintf_bytes = sprintf (sprintf_buf, convspec, prec, x);
                     }
                   else
@@ -4759,7 +4759,7 @@ styled_format (ptrdiff_t nargs, Lisp_Object *args, bool message)
                   /* Don't sign-extend for octal or hex printing.  */
                   uprintmax_t x;
                   if (FIXNUMP (arg))
-                    x = XUINT (arg);
+                    x = XUFIXNUM (arg);
                   else
                     {
                       double d = XFLOAT_DATA (arg);
@@ -5016,7 +5016,7 @@ styled_format (ptrdiff_t nargs, Lisp_Object *args, bool message)
               Lisp_Object item = XCAR (list);
 
               /* First adjust the property start position.  */
-              ptrdiff_t pos = XINT (XCAR (item));
+              ptrdiff_t pos = XFIXNUM (XCAR (item));
 
               /* Advance BYTEPOS, POSITION, TRANSLATED and ARGN
                  up to this position.  */
@@ -5038,7 +5038,7 @@ styled_format (ptrdiff_t nargs, Lisp_Object *args, bool message)
               XSETCAR (item, make_fixnum (translated));
 
               /* Likewise adjust the property end position.  */
-              pos = XINT (XCAR (XCDR (item)));
+              pos = XFIXNUM (XCAR (XCDR (item)));
 
               for (; position < pos; bytepos++)
                 {
@@ -5099,13 +5099,13 @@ Case is ignored if `case-fold-search' is non-nil in the current buffer.  */)
   CHECK_CHARACTER (c1);
   CHECK_CHARACTER (c2);
 
-  if (XINT (c1) == XINT (c2))
+  if (XFIXNUM (c1) == XFIXNUM (c2))
     return Qt;
   if (NILP (BVAR (current_buffer, case_fold_search)))
     return Qnil;
 
-  i1 = XFASTINT (c1);
-  i2 = XFASTINT (c2);
+  i1 = XFIXNAT (c1);
+  i2 = XFIXNAT (c2);
 
   /* FIXME: It is possible to compare multibyte characters even when
      the current buffer is unibyte.  Unfortunately this is ambiguous
@@ -5249,10 +5249,10 @@ ring.  */)
   validate_region (&startr1, &endr1);
   validate_region (&startr2, &endr2);
 
-  start1 = XFASTINT (startr1);
-  end1 = XFASTINT (endr1);
-  start2 = XFASTINT (startr2);
-  end2 = XFASTINT (endr2);
+  start1 = XFIXNAT (startr1);
+  end1 = XFIXNAT (endr1);
+  start2 = XFIXNAT (startr2);
+  end2 = XFIXNAT (endr2);
   gap = GPT;
 
   /* Swap the regions if they're reversed.  */
diff --git a/src/emacs-module.c b/src/emacs-module.c
index 39150f6f67b..e7ba17426bf 100644
--- a/src/emacs-module.c
+++ b/src/emacs-module.c
@@ -302,7 +302,7 @@ module_make_global_ref (emacs_env *env, emacs_value ref)
   if (i >= 0)
     {
       Lisp_Object value = HASH_VALUE (h, i);
-      EMACS_INT refcount = XFASTINT (value) + 1;
+      EMACS_INT refcount = XFIXNAT (value) + 1;
       if (MOST_POSITIVE_FIXNUM < refcount)
         xsignal0 (Qoverflow_error);
       value = make_fixed_natnum (refcount);
@@ -329,7 +329,7 @@ module_free_global_ref (emacs_env *env, emacs_value ref)
 
   if (i >= 0)
     {
-      EMACS_INT refcount = XFASTINT (HASH_VALUE (h, i)) - 1;
+      EMACS_INT refcount = XFIXNAT (HASH_VALUE (h, i)) - 1;
       if (refcount > 0)
         set_hash_value_slot (h, i, make_fixed_natnum (refcount));
       else
@@ -525,7 +525,7 @@ module_extract_integer (emacs_env *env, emacs_value n)
         xsignal1 (Qoverflow_error, l);
       return mpz_get_si (XBIGNUM (l)->value);
     }
-  return XINT (l);
+  return XFIXNUM (l);
 }
 
 static emacs_value
diff --git a/src/emacs.c b/src/emacs.c
index aef4f93d02b..dc62ce80667 100644
--- a/src/emacs.c
+++ b/src/emacs.c
@@ -2065,9 +2065,9 @@ all of which are called before Emacs is actually killed.  */
     }
 
   if (FIXNUMP (arg))
-    exit_code = (XINT (arg) < 0
-                 ? XINT (arg) | INT_MIN
-                 : XINT (arg) & INT_MAX);
+    exit_code = (XFIXNUM (arg) < 0
+                 ? XFIXNUM (arg) | INT_MIN
+                 : XFIXNUM (arg) & INT_MAX);
   else
     exit_code = EXIT_SUCCESS;
   exit (exit_code);
diff --git a/src/eval.c b/src/eval.c
index 800d7f2afb8..f7d4d5be2aa 100644
--- a/src/eval.c
+++ b/src/eval.c
@@ -264,8 +264,8 @@ init_eval (void)
 static void
 restore_stack_limits (Lisp_Object data)
 {
-  max_specpdl_size = XINT (XCAR (data));
-  max_lisp_eval_depth = XINT (XCDR (data));
+  max_specpdl_size = XFIXNUM (XCAR (data));
+  max_lisp_eval_depth = XFIXNUM (XCDR (data));
 }
 
 static void grow_specpdl (void);
@@ -938,7 +938,7 @@ usage: (let VARLIST BODY...)  */)
   CHECK_LIST (varlist);
 
   /* Make space to hold the values to give the bound variables.  */
-  EMACS_INT varlist_len = XFASTINT (Flength (varlist));
+  EMACS_INT varlist_len = XFIXNAT (Flength (varlist));
   SAFE_ALLOCA_LISP (temps, varlist_len);
   ptrdiff_t nvars = varlist_len;
 
@@ -2246,9 +2246,9 @@ eval_sub (Lisp_Object form)
 
       check_cons_list ();
 
-      if (XINT (numargs) < XSUBR (fun)->min_args
+      if (XFIXNUM (numargs) < XSUBR (fun)->min_args
           || (XSUBR (fun)->max_args >= 0
-              && XSUBR (fun)->max_args < XINT (numargs)))
+              && XSUBR (fun)->max_args < XFIXNUM (numargs)))
         xsignal2 (Qwrong_number_of_arguments, original_fun, numargs);
 
       else if (XSUBR (fun)->max_args == UNEVALLED)
@@ -2260,9 +2260,9 @@ eval_sub (Lisp_Object form)
           ptrdiff_t argnum = 0;
           USE_SAFE_ALLOCA;
 
-          SAFE_ALLOCA_LISP (vals, XINT (numargs));
+          SAFE_ALLOCA_LISP (vals, XFIXNUM (numargs));
 
-          while (CONSP (args_left) && argnum < XINT (numargs))
+          while (CONSP (args_left) && argnum < XFIXNUM (numargs))
             {
               Lisp_Object arg = XCAR (args_left);
               args_left = XCDR (args_left);
@@ -2292,7 +2292,7 @@ eval_sub (Lisp_Object form)
               args_left = Fcdr (args_left);
             }
 
-          set_backtrace_args (specpdl + count, argvals, XINT (numargs));
+          set_backtrace_args (specpdl + count, argvals, XFIXNUM (numargs));
 
           switch (i)
             {
@@ -2405,7 +2405,7 @@ usage: (apply FUNCTION &rest ARGUMENTS)  */)
 
   CHECK_LIST (spread_arg);
 
-  numargs = XINT (Flength (spread_arg));
+  numargs = XFIXNUM (Flength (spread_arg));
 
   if (numargs == 0)
     return Ffuncall (nargs - 1, args);
@@ -2960,7 +2960,7 @@ apply_lambda (Lisp_Object fun, Lisp_Object args, ptrdiff_t count)
   Lisp_Object tem;
   USE_SAFE_ALLOCA;
 
-  numargs = XFASTINT (Flength (args));
+  numargs = XFIXNAT (Flength (args));
   SAFE_ALLOCA_LISP (arg_vector, numargs);
   args_left = args;
 
@@ -3667,7 +3667,7 @@ get_backtrace_frame (Lisp_Object nframes, Lisp_Object base)
   union specbinding *pdl = get_backtrace_starting_at (base);
 
   /* Find the frame requested.  */
-  for (i = XFASTINT (nframes); i > 0 && backtrace_p (pdl); i--)
+  for (i = XFIXNAT (nframes); i > 0 && backtrace_p (pdl); i--)
     pdl = backtrace_next (pdl);
 
   return pdl;
@@ -3868,7 +3868,7 @@ NFRAMES and BASE specify the activation frame to use, as in `backtrace-frame'.
 {
   union specbinding *frame = get_backtrace_frame (nframes, base);
   union specbinding *prevframe
-    = get_backtrace_frame (make_fixnum (XFASTINT (nframes) - 1), base);
+    = get_backtrace_frame (make_fixnum (XFIXNAT (nframes) - 1), base);
   ptrdiff_t distance = specpdl_ptr - frame;
   Lisp_Object result = Qnil;
   eassert (distance >= 0);
diff --git a/src/fileio.c b/src/fileio.c
index b8809853e00..14089dcf49a 100644
--- a/src/fileio.c
+++ b/src/fileio.c
@@ -3195,7 +3195,7 @@ symbolic notation, like the `chmod' command from GNU Coreutils.  */)
 
   encoded_absname = ENCODE_FILE (absname);
 
-  if (chmod (SSDATA (encoded_absname), XINT (mode) & 07777) < 0)
+  if (chmod (SSDATA (encoded_absname), XFIXNUM (mode) & 07777) < 0)
     report_file_error ("Doing chmod", absname);
 
   return Qnil;
@@ -3218,7 +3218,7 @@ by having the corresponding bit in the mask reset.  */)
   mode_t oldrealmask, oldumask, newumask;
   CHECK_FIXNUM (mode);
   oldrealmask = realmask;
-  newumask = ~ XINT (mode) & 0777;
+  newumask = ~ XFIXNUM (mode) & 0777;
 
   block_input ();
   realmask = newumask;
@@ -3378,7 +3378,7 @@ verify (alignof (union read_non_regular) % GCALIGNMENT == 0);
 static Lisp_Object
 read_non_regular (Lisp_Object state)
 {
-  union read_non_regular *data = XINTPTR (state);
+  union read_non_regular *data = XFIXNUMPTR (state);
   int nbytes = emacs_read_quit (data->s.fd,
                                 ((char *) BEG_ADDR + PT_BYTE - BEG_BYTE
                                  + data->s.inserted),
@@ -3402,7 +3402,7 @@ static off_t
 file_offset (Lisp_Object val)
 {
   if (RANGED_FIXNUMP (0, val, TYPE_MAXIMUM (off_t)))
-    return XINT (val);
+    return XFIXNUM (val);
 
   if (FLOATP (val))
     {
@@ -3462,14 +3462,14 @@ restore_window_points (Lisp_Object window_markers, ptrdiff_t inserted,
         Lisp_Object marker = XCAR (car);
         Lisp_Object oldpos = XCDR (car);
         if (MARKERP (marker) && FIXNUMP (oldpos)
-            && XINT (oldpos) > same_at_start
-            && XINT (oldpos) < same_at_end)
+            && XFIXNUM (oldpos) > same_at_start
+            && XFIXNUM (oldpos) < same_at_end)
           {
             ptrdiff_t oldsize = same_at_end - same_at_start;
             ptrdiff_t newsize = inserted;
             double growth = newsize / (double)oldsize;
             ptrdiff_t newpos
-              = same_at_start + growth * (XINT (oldpos) - same_at_start);
+              = same_at_start + growth * (XFIXNUM (oldpos) - same_at_start);
             Fset_marker (marker, make_fixnum (newpos), Qnil);
           }
       }
@@ -3584,7 +3584,7 @@ by calling `format-decode', which see.  */)
                    visit, beg, end, replace);
       if (CONSP (val) && CONSP (XCDR (val))
           && RANGED_FIXNUMP (0, XCAR (XCDR (val)), ZV - PT))
-        inserted = XINT (XCAR (XCDR (val)));
+        inserted = XFIXNUM (XCAR (XCDR (val)));
       goto handled;
     }
 
@@ -4248,7 +4248,7 @@ by calling `format-decode', which see.  */)
                 break;
               }
 
-            this = XINT (nbytes);
+            this = XFIXNUM (nbytes);
           }
         else
           {
@@ -4469,7 +4469,7 @@ by calling `format-decode', which see.  */)
         {
           if (! RANGED_FIXNUMP (0, insval, ZV - PT))
             wrong_type_argument (intern ("inserted-chars"), insval);
-          inserted = XFASTINT (insval);
+          inserted = XFIXNAT (insval);
         }
     }
 
@@ -4492,7 +4492,7 @@ by calling `format-decode', which see.  */)
                           Qnil, make_fixnum (inserted), visit);
           if (! RANGED_FIXNUMP (0, insval, ZV - PT))
             wrong_type_argument (intern ("inserted-chars"), insval);
-          inserted = XFASTINT (insval);
+          inserted = XFIXNAT (insval);
         }
       else
         {
@@ -4523,7 +4523,7 @@ by calling `format-decode', which see.  */)
           else
             /* format_decode modified buffer's characters => consider
                entire buffer changed and leave point at point-min.  */
-            inserted = XFASTINT (insval);
+            inserted = XFIXNAT (insval);
         }
 
       /* For consistency with format-decode call these now iff inserted > 0
@@ -4538,7 +4538,7 @@ by calling `format-decode', which see.  */)
                 {
                   if (! RANGED_FIXNUMP (0, insval, ZV - PT))
                     wrong_type_argument (intern ("inserted-chars"), insval);
-                  inserted = XFASTINT (insval);
+                  inserted = XFIXNAT (insval);
                 }
             }
           else
@@ -4566,7 +4566,7 @@ by calling `format-decode', which see.  */)
                     /* after_insert_file_functions did modify buffer's
                        characters => consider entire buffer changed and
                        leave point at point-min.  */
-                    inserted = XFASTINT (insval);
+                    inserted = XFIXNAT (insval);
                 }
             }
 
@@ -4584,7 +4584,7 @@ by calling `format-decode', which see.  */)
               Lisp_Object tem = XCAR (old_undo);
               if (CONSP (tem) && FIXNUMP (XCAR (tem))
                   && FIXNUMP (XCDR (tem))
-                  && XFASTINT (XCDR (tem)) == PT + old_inserted)
+                  && XFIXNAT (XCDR (tem)) == PT + old_inserted)
                 XSETCDR (tem, make_fixnum (PT + inserted));
             }
         }
@@ -4962,14 +4962,14 @@ write_region (Lisp_Object start, Lisp_Object end, Lisp_Object filename,
 
   if (STRINGP (start))
     ok = a_write (desc, start, 0, SCHARS (start), &annotations, &coding);
-  else if (XINT (start) != XINT (end))
-    ok = a_write (desc, Qnil, XINT (start), XINT (end) - XINT (start),
+  else if (XFIXNUM (start) != XFIXNUM (end))
+    ok = a_write (desc, Qnil, XFIXNUM (start), XFIXNUM (end) - XFIXNUM (start),
                   &annotations, &coding);
   else
     {
       /* If file was empty, still need to write the annotations.  */
       coding.mode |= CODING_MODE_LAST_BLOCK;
-      ok = a_write (desc, Qnil, XINT (end), 0, &annotations, &coding);
+      ok = a_write (desc, Qnil, XFIXNUM (end), 0, &annotations, &coding);
     }
   save_errno = errno;
 
@@ -5256,7 +5256,7 @@ a_write (int desc, Lisp_Object string, ptrdiff_t pos,
       tem = Fcar_safe (Fcar (*annot));
       nextpos = pos - 1;
       if (FIXNUMP (tem))
-        nextpos = XFASTINT (tem);
+        nextpos = XFIXNAT (tem);
 
       /* If there are no more annotations in this range,
          output the rest of the range all at once.  */
@@ -5458,7 +5458,7 @@ An argument specifies the modification time value to use
       if (FIXNUMP (time_flag))
         {
           CHECK_RANGED_INTEGER (time_flag, -1, 0);
-          mtime = make_timespec (0, UNKNOWN_MODTIME_NSECS - XINT (time_flag));
+          mtime = make_timespec (0, UNKNOWN_MODTIME_NSECS - XFIXNUM (time_flag));
         }
       else
         mtime = lisp_time_argument (time_flag);
@@ -5526,7 +5526,7 @@ auto_save_1 (void)
       else if (modes = Ffile_modes (BVAR (current_buffer, filename)),
                FIXNUMP (modes))
         /* Remote files don't cooperate with stat.  */
-        auto_save_mode_bits = (XINT (modes) | 0600) & 0777;
+        auto_save_mode_bits = (XFIXNUM (modes) | 0600) & 0777;
     }
 
   return
@@ -5693,7 +5693,7 @@ A non-nil CURRENT-ONLY argument means save only current buffer.  */)
             && BUF_SAVE_MODIFF (b) < BUF_MODIFF (b)
             && BUF_AUTOSAVE_MODIFF (b) < BUF_MODIFF (b)
             /* -1 means we've turned off autosaving for a while--see below.  */
-            && XINT (BVAR (b, save_length)) >= 0
+            && XFIXNUM (BVAR (b, save_length)) >= 0
             && (do_handled_files
                 || NILP (Ffind_file_name_handler (BVAR (b, auto_save_file_name),
                                                   Qwrite_region))))
@@ -5708,11 +5708,11 @@ A non-nil CURRENT-ONLY argument means save only current buffer.  */)
 
             set_buffer_internal (b);
             if (NILP (Vauto_save_include_big_deletions)
-                && (XFASTINT (BVAR (b, save_length)) * 10
+                && (XFIXNAT (BVAR (b, save_length)) * 10
                     > (BUF_Z (b) - BUF_BEG (b)) * 13)
                 /* A short file is likely to change a large fraction;
                    spare the user annoying messages.  */
-                && XFASTINT (BVAR (b, save_length)) > 5000
+                && XFIXNAT (BVAR (b, save_length)) > 5000
                 /* These messages are frequent and annoying for `*mail*'.  */
                 && !EQ (BVAR (b, filename), Qnil)
                 && NILP (no_message))
diff --git a/src/floatfns.c b/src/floatfns.c
index 563c65f827a..f8463f32445 100644
--- a/src/floatfns.c
+++ b/src/floatfns.c
@@ -194,7 +194,7 @@ EXPONENT must be an integer.   */)
   (Lisp_Object sgnfcand, Lisp_Object exponent)
 {
   CHECK_FIXNUM (exponent);
-  int e = min (max (INT_MIN, XINT (exponent)), INT_MAX);
+  int e = min (max (INT_MIN, XFIXNUM (exponent)), INT_MAX);
   return make_float (ldexp (extract_float (sgnfcand), e));
 }
 
@@ -215,14 +215,14 @@ DEFUN ("expt", Fexpt, Sexpt, 2, 2, 0,
   CHECK_FIXNUM_OR_FLOAT (arg2);
   if (FIXNUMP (arg1)     /* common lisp spec */
       && FIXNUMP (arg2)   /* don't promote, if both are ints, and */
-      && XINT (arg2) >= 0) /* we are sure the result is not fractional */
+      && XFIXNUM (arg2) >= 0) /* we are sure the result is not fractional */
     {                           /* this can be improved by pre-calculating */
       EMACS_INT y;              /* some binary powers of x then accumulating */
       EMACS_UINT acc, x;  /* Unsigned so that overflow is well defined.  */
       Lisp_Object val;
 
-      x = XINT (arg1);
-      y = XINT (arg2);
+      x = XFIXNUM (arg1);
+      y = XFIXNUM (arg2);
       acc = (y & 1 ? x : 1);
 
       while ((y >>= 1) != 0)
@@ -285,7 +285,7 @@ DEFUN ("abs", Fabs, Sabs, 1, 1, 0,
       arg = make_number (val);
       mpz_clear (val);
     }
-  else if (FIXNUMP (arg) && XINT (arg) == MOST_NEGATIVE_FIXNUM)
+  else if (FIXNUMP (arg) && XFIXNUM (arg) == MOST_NEGATIVE_FIXNUM)
     {
       mpz_t val;
       mpz_init (val);
@@ -295,8 +295,8 @@ DEFUN ("abs", Fabs, Sabs, 1, 1, 0,
     }
   else if (FLOATP (arg))
     arg = make_float (fabs (XFLOAT_DATA (arg)));
-  else if (XINT (arg) < 0)
-    XSETINT (arg, - XINT (arg));
+  else if (XFIXNUM (arg) < 0)
+    XSETINT (arg, - XFIXNUM (arg));
 
   return arg;
 }
@@ -310,7 +310,7 @@ DEFUN ("float", Ffloat, Sfloat, 1, 1, 0,
   if (BIGNUMP (arg))
     return make_float (mpz_get_d (XBIGNUM (arg)->value));
   if (FIXNUMP (arg))
-    return make_float ((double) XINT (arg));
+    return make_float ((double) XFIXNUM (arg));
   else                          /* give 'em the same float back */
     return arg;
 }
@@ -351,7 +351,7 @@ This is the same as the exponent of a float.  */)
   else
     {
       eassert (FIXNUMP (arg));
-      EMACS_INT i = eabs (XINT (arg));
+      EMACS_INT i = eabs (XFIXNUM (arg));
       value = (i == 0
                ? MOST_NEGATIVE_FIXNUM
                : EMACS_UINT_WIDTH - 1 - ecount_leading_zeros (i));
@@ -383,13 +383,13 @@ rounding_driver (Lisp_Object arg, Lisp_Object divisor,
       CHECK_FIXNUM_OR_FLOAT (divisor);
       if (!FLOATP (arg) && !FLOATP (divisor))
         {
-          if (XINT (divisor) == 0)
+          if (XFIXNUM (divisor) == 0)
             xsignal0 (Qarith_error);
-          return make_fixnum (int_round2 (XINT (arg), XINT (divisor)));
+          return make_fixnum (int_round2 (XFIXNUM (arg), XFIXNUM (divisor)));
         }
 
-      double f1 = FLOATP (arg) ? XFLOAT_DATA (arg) : XINT (arg);
-      double f2 = FLOATP (divisor) ? XFLOAT_DATA (divisor) : XINT (divisor);
+      double f1 = FLOATP (arg) ? XFLOAT_DATA (arg) : XFIXNUM (arg);
+      double f2 = FLOATP (divisor) ? XFLOAT_DATA (divisor) : XFIXNUM (divisor);
       if (! IEEE_FLOATING_POINT && f2 == 0)
         xsignal0 (Qarith_error);
       d = f1 / f2;
@@ -510,8 +510,8 @@ fmod_float (Lisp_Object x, Lisp_Object y)
 {
   double f1, f2;
 
-  f1 = FLOATP (x) ? XFLOAT_DATA (x) : XINT (x);
-  f2 = FLOATP (y) ? XFLOAT_DATA (y) : XINT (y);
+  f1 = FLOATP (x) ? XFLOAT_DATA (x) : XFIXNUM (x);
+  f2 = FLOATP (y) ? XFLOAT_DATA (y) : XFIXNUM (y);
 
   f1 = fmod (f1, f2);
 
diff --git a/src/fns.c b/src/fns.c
index ac93a2f6d81..92a853e1755 100644
--- a/src/fns.c
+++ b/src/fns.c
@@ -77,14 +77,14 @@ See Info node `(elisp)Random Numbers' for more details.  */)
     seed_random (SSDATA (limit), SBYTES (limit));
 
   val = get_random ();
-  if (FIXNUMP (limit) && 0 < XINT (limit))
+  if (FIXNUMP (limit) && 0 < XFIXNUM (limit))
     while (true)
       {
         /* Return the remainder, except reject the rare case where
            get_random returns a number so close to INTMASK that the
            remainder isn't random.  */
-        EMACS_INT remainder = val % XINT (limit);
-        if (val - remainder <= INTMASK - XINT (limit) + 1)
+        EMACS_INT remainder = val % XFIXNUM (limit);
+        if (val - remainder <= INTMASK - XFIXNUM (limit) + 1)
           return make_fixnum (remainder);
         val = get_random ();
       }
@@ -270,9 +270,9 @@ If string STR1 is greater, the value is a positive number N;
 
   /* For backward compatibility, silently bring too-large positive end
      values into range.  */
-  if (FIXNUMP (end1) && SCHARS (str1) < XINT (end1))
+  if (FIXNUMP (end1) && SCHARS (str1) < XFIXNUM (end1))
     end1 = make_fixnum (SCHARS (str1));
-  if (FIXNUMP (end2) && SCHARS (str2) < XINT (end2))
+  if (FIXNUMP (end2) && SCHARS (str2) < XFIXNUM (end2))
     end2 = make_fixnum (SCHARS (str2));
 
   validate_subarray (str1, start1, end1, SCHARS (str1), &from1, &to1);
@@ -298,8 +298,8 @@ If string STR1 is greater, the value is a positive number N;
 
       if (! NILP (ignore_case))
         {
-          c1 = XINT (Fupcase (make_fixnum (c1)));
-          c2 = XINT (Fupcase (make_fixnum (c2)));
+          c1 = XFIXNUM (Fupcase (make_fixnum (c1)));
+          c2 = XFIXNUM (Fupcase (make_fixnum (c2)));
         }
 
       if (c1 == c2)
@@ -645,7 +645,7 @@ concat (ptrdiff_t nargs, Lisp_Object *args,
     {
       EMACS_INT len;
       this = args[argnum];
-      len = XFASTINT (Flength (this));
+      len = XFIXNAT (Flength (this));
       if (target_type == Lisp_String)
         {
           /* We must count the number of bytes needed in the string
@@ -660,7 +660,7 @@ concat (ptrdiff_t nargs, Lisp_Object *args,
               {
                 ch = AREF (this, i);
                 CHECK_CHARACTER (ch);
-                c = XFASTINT (ch);
+                c = XFIXNAT (ch);
                 this_len_byte = CHAR_BYTES (c);
                 if (STRING_BYTES_BOUND - result_len_byte < this_len_byte)
                   string_overflow ();
@@ -675,7 +675,7 @@ concat (ptrdiff_t nargs, Lisp_Object *args,
               {
                 ch = XCAR (this);
                 CHECK_CHARACTER (ch);
-                c = XFASTINT (ch);
+                c = XFIXNAT (ch);
                 this_len_byte = CHAR_BYTES (c);
                 if (STRING_BYTES_BOUND - result_len_byte < this_len_byte)
                   string_overflow ();
@@ -740,7 +740,7 @@ concat (ptrdiff_t nargs, Lisp_Object *args,
 
       this = args[argnum];
       if (!CONSP (this))
-        thislen = Flength (this), thisleni = XINT (thislen);
+        thislen = Flength (this), thisleni = XFIXNUM (thislen);
 
       /* Between strings of the same kind, copy fast.  */
       if (STRINGP (this) && STRINGP (val)
@@ -827,7 +827,7 @@ concat (ptrdiff_t nargs, Lisp_Object *args,
               {
                 int c;
                 CHECK_CHARACTER (elt);
-                c = XFASTINT (elt);
+                c = XFIXNAT (elt);
                 if (some_multibyte)
                   toindex_byte += CHAR_STRING (c, SDATA (val) + toindex_byte);
                 else
@@ -1260,7 +1260,7 @@ validate_subarray (Lisp_Object array, Lisp_Object from, Lisp_Object to,
 
   if (FIXNUMP (from))
     {
-      f = XINT (from);
+      f = XFIXNUM (from);
       if (f < 0)
         f += size;
     }
@@ -1271,7 +1271,7 @@ validate_subarray (Lisp_Object array, Lisp_Object from, Lisp_Object to,
 
   if (FIXNUMP (to))
     {
-      t = XINT (to);
+      t = XFIXNUM (to);
       if (t < 0)
         t += size;
     }
@@ -1385,7 +1385,7 @@ DEFUN ("nthcdr", Fnthcdr, Snthcdr, 2, 2, 0,
 {
   CHECK_FIXNUM (n);
   Lisp_Object tail = list;
-  for (EMACS_INT num = XINT (n); 0 < num; num--)
+  for (EMACS_INT num = XFIXNUM (n); 0 < num; num--)
     {
       if (! CONSP (tail))
         {
@@ -1645,7 +1645,7 @@ changing the value of a sequence `foo'.  */)
               cbytes = 1;
             }
 
-          if (!FIXNUMP (elt) || c != XINT (elt))
+          if (!FIXNUMP (elt) || c != XFIXNUM (elt))
             {
               ++nchars;
               nbytes += cbytes;
@@ -1675,7 +1675,7 @@ changing the value of a sequence `foo'.  */)
                   cbytes = 1;
                 }
 
-              if (!FIXNUMP (elt) || c != XINT (elt))
+              if (!FIXNUMP (elt) || c != XFIXNUM (elt))
                 {
                   unsigned char *from = SDATA (seq) + ibyte;
                   unsigned char *to   = SDATA (tem) + nbytes;
@@ -1846,7 +1846,7 @@ sort_list (Lisp_Object list, Lisp_Object predicate)
 
   front = list;
   len = Flength (list);
-  length = XINT (len);
+  length = XFIXNUM (len);
   if (length < 2)
     return list;
 
@@ -2417,7 +2417,7 @@ ARRAY is a vector, string, char-table, or bool-vector.  */)
       register unsigned char *p = SDATA (array);
       int charval;
       CHECK_CHARACTER (item);
-      charval = XFASTINT (item);
+      charval = XFIXNAT (item);
       size = SCHARS (array);
       if (STRING_MULTIBYTE (array))
         {
@@ -2569,7 +2569,7 @@ SEQUENCE may be a list, a vector, a bool-vector, or a string.  */)
   (Lisp_Object function, Lisp_Object sequence, Lisp_Object separator)
 {
   USE_SAFE_ALLOCA;
-  EMACS_INT leni = XFASTINT (Flength (sequence));
+  EMACS_INT leni = XFIXNAT (Flength (sequence));
   if (CHAR_TABLE_P (sequence))
     wrong_type_argument (Qlistp, sequence);
   EMACS_INT args_alloc = 2 * leni - 1;
@@ -2598,7 +2598,7 @@ SEQUENCE may be a list, a vector, a bool-vector, or a string.  */)
   (Lisp_Object function, Lisp_Object sequence)
 {
   USE_SAFE_ALLOCA;
-  EMACS_INT leni = XFASTINT (Flength (sequence));
+  EMACS_INT leni = XFIXNAT (Flength (sequence));
   if (CHAR_TABLE_P (sequence))
     wrong_type_argument (Qlistp, sequence);
   Lisp_Object *args;
@@ -2617,7 +2617,7 @@ SEQUENCE may be a list, a vector, a bool-vector, or a string.  */)
 {
   register EMACS_INT leni;
 
-  leni = XFASTINT (Flength (sequence));
+  leni = XFIXNAT (Flength (sequence));
   if (CHAR_TABLE_P (sequence))
     wrong_type_argument (Qlistp, sequence);
   mapcar1 (leni, 0, function, sequence);
@@ -2632,7 +2632,7 @@ SEQUENCE may be a list, a vector, a bool-vector, or a string. */)
      (Lisp_Object function, Lisp_Object sequence)
 {
   USE_SAFE_ALLOCA;
-  EMACS_INT leni = XFASTINT (Flength (sequence));
+  EMACS_INT leni = XFIXNAT (Flength (sequence));
   if (CHAR_TABLE_P (sequence))
     wrong_type_argument (Qlistp, sequence);
   Lisp_Object *args;
@@ -3159,9 +3159,9 @@ into shorter lines.  */)
 
   validate_region (&beg, &end);
 
-  ibeg = CHAR_TO_BYTE (XFASTINT (beg));
-  iend = CHAR_TO_BYTE (XFASTINT (end));
-  move_gap_both (XFASTINT (beg), ibeg);
+  ibeg = CHAR_TO_BYTE (XFIXNAT (beg));
+  iend = CHAR_TO_BYTE (XFIXNAT (end));
+  move_gap_both (XFIXNAT (beg), ibeg);
 
   /* We need to allocate enough room for encoding the text.
      We need 33 1/3% more space, plus a newline every 76
@@ -3186,17 +3186,17 @@ into shorter lines.  */)
 
   /* Now we have encoded the region, so we insert the new contents
      and delete the old.  (Insert first in order to preserve markers.)  */
-  SET_PT_BOTH (XFASTINT (beg), ibeg);
+  SET_PT_BOTH (XFIXNAT (beg), ibeg);
   insert (encoded, encoded_length);
   SAFE_FREE ();
   del_range_byte (ibeg + encoded_length, iend + encoded_length);
 
   /* If point was outside of the region, restore it exactly; else just
      move to the beginning of the region.  */
-  if (old_pos >= XFASTINT (end))
-    old_pos += encoded_length - (XFASTINT (end) - XFASTINT (beg));
-  else if (old_pos > XFASTINT (beg))
-    old_pos = XFASTINT (beg);
+  if (old_pos >= XFIXNAT (end))
+    old_pos += encoded_length - (XFIXNAT (end) - XFIXNAT (beg));
+  else if (old_pos > XFIXNAT (beg))
+    old_pos = XFIXNAT (beg);
   SET_PT (old_pos);
 
   /* We return the length of the encoded text. */
@@ -3359,8 +3359,8 @@ If the region can't be decoded, signal an error and don't modify the buffer.  */
 
   validate_region (&beg, &end);
 
-  ibeg = CHAR_TO_BYTE (XFASTINT (beg));
-  iend = CHAR_TO_BYTE (XFASTINT (end));
+  ibeg = CHAR_TO_BYTE (XFIXNAT (beg));
+  iend = CHAR_TO_BYTE (XFIXNAT (end));
 
   length = iend - ibeg;
 
@@ -3370,7 +3370,7 @@ If the region can't be decoded, signal an error and don't modify the buffer.  */
   allength = multibyte ? length * 2 : length;
   decoded = SAFE_ALLOCA (allength);
 
-  move_gap_both (XFASTINT (beg), ibeg);
+  move_gap_both (XFIXNAT (beg), ibeg);
   decoded_length = base64_decode_1 ((char *) BYTE_POS_ADDR (ibeg),
                                     decoded, length,
                                     multibyte, &inserted_chars);
@@ -3385,21 +3385,21 @@ If the region can't be decoded, signal an error and don't modify the buffer.  */
 
   /* Now we have decoded the region, so we insert the new contents
      and delete the old.  (Insert first in order to preserve markers.)  */
-  TEMP_SET_PT_BOTH (XFASTINT (beg), ibeg);
+  TEMP_SET_PT_BOTH (XFIXNAT (beg), ibeg);
   insert_1_both (decoded, inserted_chars, decoded_length, 0, 1, 0);
-  signal_after_change (XFASTINT (beg), 0, inserted_chars);
+  signal_after_change (XFIXNAT (beg), 0, inserted_chars);
   SAFE_FREE ();
 
   /* Delete the original text.  */
-  del_range_both (PT, PT_BYTE, XFASTINT (end) + inserted_chars,
+  del_range_both (PT, PT_BYTE, XFIXNAT (end) + inserted_chars,
                   iend + decoded_length, 1);
 
   /* If point was outside of the region, restore it exactly; else just
      move to the beginning of the region.  */
-  if (old_pos >= XFASTINT (end))
-    old_pos += inserted_chars - (XFASTINT (end) - XFASTINT (beg));
-  else if (old_pos > XFASTINT (beg))
-    old_pos = XFASTINT (beg);
+  if (old_pos >= XFIXNAT (end))
+    old_pos += inserted_chars - (XFIXNAT (end) - XFIXNAT (beg));
+  else if (old_pos > XFIXNAT (beg))
+    old_pos = XFIXNAT (beg);
   SET_PT (old_pos > ZV ? ZV : old_pos);
 
   return make_fixnum (inserted_chars);
@@ -3696,7 +3696,7 @@ larger_vector (Lisp_Object vec, ptrdiff_t incr_min, ptrdiff_t nitems_max)
 static ptrdiff_t
 HASH_NEXT (struct Lisp_Hash_Table *h, ptrdiff_t idx)
 {
-  return XINT (AREF (h->next, idx));
+  return XFIXNUM (AREF (h->next, idx));
 }
 
 /* Return the index of the element in hash table H that is the start
@@ -3705,7 +3705,7 @@ HASH_NEXT (struct Lisp_Hash_Table *h, ptrdiff_t idx)
 static ptrdiff_t
 HASH_INDEX (struct Lisp_Hash_Table *h, ptrdiff_t idx)
 {
-  return XINT (AREF (h->index, idx));
+  return XFIXNUM (AREF (h->index, idx));
 }
 
 /* Compare KEY1 which has hash code HASH1 and KEY2 with hash code
@@ -4008,7 +4008,7 @@ maybe_resize_hash_table (struct Lisp_Hash_Table *h)
       for (i = 0; i < old_size; ++i)
         if (!NILP (HASH_HASH (h, i)))
           {
-            EMACS_UINT hash_code = XUINT (HASH_HASH (h, i));
+            EMACS_UINT hash_code = XUFIXNUM (HASH_HASH (h, i));
             ptrdiff_t start_of_bucket = hash_code % ASIZE (h->index);
             set_hash_next_slot (h, i, HASH_INDEX (h, start_of_bucket));
             set_hash_index_slot (h, start_of_bucket, i);
@@ -4037,7 +4037,7 @@ hash_lookup (struct Lisp_Hash_Table *h, Lisp_Object key, EMACS_UINT *hash)
   for (i = HASH_INDEX (h, start_of_bucket); 0 <= i; i = HASH_NEXT (h, i))
     if (EQ (key, HASH_KEY (h, i))
         || (h->test.cmpfn
-            && hash_code == XUINT (HASH_HASH (h, i))
+            && hash_code == XUFIXNUM (HASH_HASH (h, i))
             && h->test.cmpfn (&h->test, key, HASH_KEY (h, i))))
       break;
 
@@ -4094,7 +4094,7 @@ hash_remove_from_table (struct Lisp_Hash_Table *h, Lisp_Object key)
     {
       if (EQ (key, HASH_KEY (h, i))
           || (h->test.cmpfn
-              && hash_code == XUINT (HASH_HASH (h, i))
+              && hash_code == XUFIXNUM (HASH_HASH (h, i))
               && h->test.cmpfn (&h->test, key, HASH_KEY (h, i))))
         {
           /* Take entry out of collision chain.  */
@@ -4444,7 +4444,7 @@ sxhash (Lisp_Object obj, int depth)
   switch (XTYPE (obj))
     {
     case_Lisp_Int:
-      hash = XUINT (obj);
+      hash = XUFIXNUM (obj);
       break;
 
     case Lisp_Misc:
@@ -4607,7 +4607,7 @@ usage: (make-hash-table &rest KEYWORD-ARGS)  */)
   if (NILP (size_arg))
     size = DEFAULT_HASH_SIZE;
   else if (FIXNATP (size_arg))
-    size = XFASTINT (size_arg);
+    size = XFIXNAT (size_arg);
   else
     signal_error ("Invalid hash table size", size_arg);
 
@@ -4616,8 +4616,8 @@ usage: (make-hash-table &rest KEYWORD-ARGS)  */)
   i = get_key_arg (QCrehash_size, nargs, args, used);
   if (!i)
     rehash_size = DEFAULT_REHASH_SIZE;
-  else if (FIXNUMP (args[i]) && 0 < XINT (args[i]))
-    rehash_size = - XINT (args[i]);
+  else if (FIXNUMP (args[i]) && 0 < XFIXNUM (args[i]))
+    rehash_size = - XFIXNUM (args[i]);
   else if (FLOATP (args[i]) && 0 < (float) (XFLOAT_DATA (args[i]) - 1))
     rehash_size = (float) (XFLOAT_DATA (args[i]) - 1);
   else
@@ -4932,7 +4932,7 @@ extract_data_from_object (Lisp_Object spec,
       else
         {
           CHECK_FIXNUM_COERCE_MARKER (start);
-          b = XINT (start);
+          b = XFIXNUM (start);
         }
 
       if (NILP (end))
@@ -4940,7 +4940,7 @@ extract_data_from_object (Lisp_Object spec,
       else
         {
           CHECK_FIXNUM_COERCE_MARKER (end);
-          e = XINT (end);
+          e = XFIXNUM (end);
         }
 
       if (b > e)
@@ -5033,7 +5033,7 @@ extract_data_from_object (Lisp_Object spec,
         error ("Without a length, `iv-auto' can't be used; see ELisp manual");
       else
         {
-          EMACS_INT start_hold = XFASTINT (start);
+          EMACS_INT start_hold = XFIXNAT (start);
           object = make_uninit_string (start_hold);
           gnutls_rnd (GNUTLS_RND_NONCE, SSDATA (object), start_hold);
 
diff --git a/src/font.c b/src/font.c
index 382cd78a230..f31d9c21e71 100644
--- a/src/font.c
+++ b/src/font.c
@@ -303,7 +303,7 @@ font_pixel_size (struct frame *f, Lisp_Object spec)
   Lisp_Object val;
 
   if (FIXNUMP (size))
-    return XINT (size);
+    return XFIXNUM (size);
   if (NILP (size))
     return 0;
   if (FRAME_WINDOW_P (f))
@@ -312,7 +312,7 @@ font_pixel_size (struct frame *f, Lisp_Object spec)
       point_size = XFLOAT_DATA (size);
       val = AREF (spec, FONT_DPI_INDEX);
       if (FIXNUMP (val))
-        dpi = XINT (val);
+        dpi = XFIXNUM (val);
       else
         dpi = FRAME_RES_Y (f);
       pixel_size = POINT_TO_PIXEL (point_size, dpi);
@@ -354,7 +354,7 @@ font_style_to_value (enum font_property_index prop, Lisp_Object val,
             if (EQ (val, AREF (AREF (table, i), j)))
               {
                 CHECK_FIXNUM (AREF (AREF (table, i), 0));
-                return ((XINT (AREF (AREF (table, i), 0)) << 8)
+                return ((XFIXNUM (AREF (AREF (table, i), 0)) << 8)
                         | (i << 4) | (j - 1));
               }
         }
@@ -367,7 +367,7 @@ font_style_to_value (enum font_property_index prop, Lisp_Object val,
             if (xstrcasecmp (s, SSDATA (SYMBOL_NAME (elt))) == 0)
               {
                 CHECK_FIXNUM (AREF (AREF (table, i), 0));
-                return ((XINT (AREF (AREF (table, i), 0)) << 8)
+                return ((XFIXNUM (AREF (AREF (table, i), 0)) << 8)
                         | (i << 4) | (j - 1));
               }
           }
@@ -383,7 +383,7 @@ font_style_to_value (enum font_property_index prop, Lisp_Object val,
   else
     {
       int i, last_n;
-      EMACS_INT numeric = XINT (val);
+      EMACS_INT numeric = XFIXNUM (val);
 
       for (i = 0, last_n = -1; i < len; i++)
         {
@@ -391,7 +391,7 @@ font_style_to_value (enum font_property_index prop, Lisp_Object val,
 
           CHECK_VECTOR (AREF (table, i));
           CHECK_FIXNUM (AREF (AREF (table, i), 0));
-          n = XINT (AREF (AREF (table, i), 0));
+          n = XFIXNUM (AREF (AREF (table, i), 0));
           if (numeric == n)
             return (n << 8) | (i << 4);
           if (numeric < n)
@@ -421,7 +421,7 @@ font_style_symbolic (Lisp_Object font, enum font_property_index prop,
     return Qnil;
   table = AREF (font_style_table, prop - FONT_WEIGHT_INDEX);
   CHECK_VECTOR (table);
-  i = XINT (val) & 0xFF;
+  i = XFIXNUM (val) & 0xFF;
   eassert (((i >> 4) & 0xF) < ASIZE (table));
   elt = AREF (table, ((i >> 4) & 0xF));
   CHECK_VECTOR (elt);
@@ -470,28 +470,28 @@ font_registry_charsets (Lisp_Object registry, struct charset **encoding, struct
       val = XCDR (val);
       if (NILP (val))
         return -1;
-      encoding_id = XINT (XCAR (val));
-      repertory_id = XINT (XCDR (val));
+      encoding_id = XFIXNUM (XCAR (val));
+      repertory_id = XFIXNUM (XCDR (val));
     }
   else
     {
       val = find_font_encoding (SYMBOL_NAME (registry));
       if (SYMBOLP (val) && CHARSETP (val))
         {
-          encoding_id = repertory_id = XINT (CHARSET_SYMBOL_ID (val));
+          encoding_id = repertory_id = XFIXNUM (CHARSET_SYMBOL_ID (val));
         }
       else if (CONSP (val))
         {
           if (! CHARSETP (XCAR (val)))
             goto invalid_entry;
-          encoding_id = XINT (CHARSET_SYMBOL_ID (XCAR (val)));
+          encoding_id = XFIXNUM (CHARSET_SYMBOL_ID (XCAR (val)));
           if (NILP (XCDR (val)))
             repertory_id = -1;
           else
             {
               if (! CHARSETP (XCDR (val)))
                 goto invalid_entry;
-              repertory_id = XINT (CHARSET_SYMBOL_ID (XCDR (val)));
+              repertory_id = XFIXNUM (CHARSET_SYMBOL_ID (XCDR (val)));
             }
         }
       else
@@ -545,7 +545,7 @@ font_prop_validate_style (Lisp_Object style, Lisp_Object val)
                                    : FONT_WIDTH_INDEX);
   if (FIXNUMP (val))
     {
-      EMACS_INT n = XINT (val);
+      EMACS_INT n = XFIXNUM (val);
       CHECK_VECTOR (AREF (font_style_table, prop - FONT_WEIGHT_INDEX));
       if (((n >> 4) & 0xF)
           >= ASIZE (AREF (font_style_table, prop - FONT_WEIGHT_INDEX)))
@@ -560,7 +560,7 @@ font_prop_validate_style (Lisp_Object style, Lisp_Object val)
           else
             {
               CHECK_FIXNUM (AREF (elt, 0));
-              if (XINT (AREF (elt, 0)) != (n >> 8))
+              if (XFIXNUM (AREF (elt, 0)) != (n >> 8))
                 val = Qerror;
             }
         }
@@ -586,7 +586,7 @@ font_prop_validate_non_neg (Lisp_Object prop, Lisp_Object val)
 static Lisp_Object
 font_prop_validate_spacing (Lisp_Object prop, Lisp_Object val)
 {
-  if (NILP (val) || (FIXNATP (val) && XINT (val) <= FONT_SPACING_CHARCELL))
+  if (NILP (val) || (FIXNATP (val) && XFIXNUM (val) <= FONT_SPACING_CHARCELL))
     return val;
   if (SYMBOLP (val) && SBYTES (SYMBOL_NAME (val)) == 1)
     {
@@ -877,7 +877,7 @@ font_expand_wildcards (Lisp_Object *field, int n)
 
           if (FIXNUMP (val))
             {
-              EMACS_INT numeric = XINT (val);
+              EMACS_INT numeric = XFIXNUM (val);
 
               if (i + 1 == n)
                 from = to = XLFD_ENCODING_INDEX,
@@ -1185,7 +1185,7 @@ font_parse_xlfd (char *name, ptrdiff_t len, Lisp_Object font)
         ASET (font, FONT_SIZE_INDEX, prop[XLFD_PIXEL_INDEX]);
       else if (FIXNUMP (prop[XLFD_POINT_INDEX]))
         {
-          double point_size = XINT (prop[XLFD_POINT_INDEX]);
+          double point_size = XFIXNUM (prop[XLFD_POINT_INDEX]);
 
           ASET (font, FONT_SIZE_INDEX, make_float (point_size / 10));
         }
@@ -1289,7 +1289,7 @@ font_unparse_xlfd (Lisp_Object font, int pixel_size, char *name, int nbytes)
                                   1 + DBL_MAX_10_EXP + 1)];
   if (FIXNUMP (val))
     {
-      EMACS_INT v = XINT (val);
+      EMACS_INT v = XFIXNUM (val);
       if (v <= 0)
         v = pixel_size;
       if (v > 0)
@@ -1312,7 +1312,7 @@ font_unparse_xlfd (Lisp_Object font, int pixel_size, char *name, int nbytes)
   char dpi_index_buf[sizeof "-" + 2 * INT_STRLEN_BOUND (EMACS_INT)];
   if (FIXNUMP (AREF (font, FONT_DPI_INDEX)))
     {
-      EMACS_INT v = XINT (AREF (font, FONT_DPI_INDEX));
+      EMACS_INT v = XFIXNUM (AREF (font, FONT_DPI_INDEX));
       f[XLFD_RESX_INDEX] = p = dpi_index_buf;
       sprintf (p, "%"pI"d-%"pI"d", v, v);
     }
@@ -1321,7 +1321,7 @@ font_unparse_xlfd (Lisp_Object font, int pixel_size, char *name, int nbytes)
 
   if (FIXNUMP (AREF (font, FONT_SPACING_INDEX)))
     {
-      EMACS_INT spacing = XINT (AREF (font, FONT_SPACING_INDEX));
+      EMACS_INT spacing = XFIXNUM (AREF (font, FONT_SPACING_INDEX));
 
       f[XLFD_SPACING_INDEX] = (spacing <= FONT_SPACING_PROPORTIONAL ? "p"
                                : spacing <= FONT_SPACING_DUAL ? "d"
@@ -1335,7 +1335,7 @@ font_unparse_xlfd (Lisp_Object font, int pixel_size, char *name, int nbytes)
   if (FIXNUMP (AREF (font,  FONT_AVGWIDTH_INDEX)))
     {
       f[XLFD_AVGWIDTH_INDEX] = p = avgwidth_index_buf;
-      sprintf (p, "%"pI"d", XINT (AREF (font, FONT_AVGWIDTH_INDEX)));
+      sprintf (p, "%"pI"d", XFIXNUM (AREF (font, FONT_AVGWIDTH_INDEX)));
     }
   else
     f[XLFD_AVGWIDTH_INDEX] = "*";
@@ -1623,8 +1623,8 @@ font_unparse_fcname (Lisp_Object font, int pixel_size, char *name, int nbytes)
   val = AREF (font, FONT_SIZE_INDEX);
   if (FIXNUMP (val))
     {
-      if (XINT (val) != 0)
-        pixel_size = XINT (val);
+      if (XFIXNUM (val) != 0)
+        pixel_size = XFIXNUM (val);
       point_size = -1;
     }
   else
@@ -1691,7 +1691,7 @@ font_unparse_fcname (Lisp_Object font, int pixel_size, char *name, int nbytes)
   if (FIXNUMP (AREF (font, FONT_DPI_INDEX)))
     {
       int len = snprintf (p, lim - p, ":dpi=%"pI"d",
-                          XINT (AREF (font, FONT_DPI_INDEX)));
+                          XFIXNUM (AREF (font, FONT_DPI_INDEX)));
       if (! (0 <= len && len < lim - p))
         return -1;
       p += len;
@@ -1700,7 +1700,7 @@ font_unparse_fcname (Lisp_Object font, int pixel_size, char *name, int nbytes)
   if (FIXNUMP (AREF (font, FONT_SPACING_INDEX)))
     {
       int len = snprintf (p, lim - p, ":spacing=%"pI"d",
-                          XINT (AREF (font, FONT_SPACING_INDEX)));
+                          XFIXNUM (AREF (font, FONT_SPACING_INDEX)));
       if (! (0 <= len && len < lim - p))
         return -1;
       p += len;
@@ -1709,7 +1709,7 @@ font_unparse_fcname (Lisp_Object font, int pixel_size, char *name, int nbytes)
   if (FIXNUMP (AREF (font, FONT_AVGWIDTH_INDEX)))
     {
       int len = snprintf (p, lim - p,
-                          (XINT (AREF (font, FONT_AVGWIDTH_INDEX)) == 0
+                          (XFIXNUM (AREF (font, FONT_AVGWIDTH_INDEX)) == 0
                            ? ":scalable=true"
                            : ":scalable=false"));
       if (! (0 <= len && len < lim - p))
@@ -2134,20 +2134,20 @@ font_score (Lisp_Object entity, Lisp_Object *spec_prop)
   for (i = FONT_WEIGHT_INDEX; i <= FONT_WIDTH_INDEX; i++)
     if (! NILP (spec_prop[i]) && ! EQ (AREF (entity, i), spec_prop[i]))
       {
-        EMACS_INT diff = ((XINT (AREF (entity, i)) >> 8)
-                          - (XINT (spec_prop[i]) >> 8));
+        EMACS_INT diff = ((XFIXNUM (AREF (entity, i)) >> 8)
+                          - (XFIXNUM (spec_prop[i]) >> 8));
         score |= min (eabs (diff), 127) << sort_shift_bits[i];
       }
 
   /* Score the size.  Maximum difference is 127.  */
   if (! NILP (spec_prop[FONT_SIZE_INDEX])
-      && XINT (AREF (entity, FONT_SIZE_INDEX)) > 0)
+      && XFIXNUM (AREF (entity, FONT_SIZE_INDEX)) > 0)
     {
       /* We use the higher 6-bit for the actual size difference.  The
          lowest bit is set if the DPI is different.  */
       EMACS_INT diff;
-      EMACS_INT pixel_size = XINT (spec_prop[FONT_SIZE_INDEX]);
-      EMACS_INT entity_size = XINT (AREF (entity, FONT_SIZE_INDEX));
+      EMACS_INT pixel_size = XFIXNUM (spec_prop[FONT_SIZE_INDEX]);
+      EMACS_INT entity_size = XFIXNUM (AREF (entity, FONT_SIZE_INDEX));
 
       if (CONSP (Vface_font_rescale_alist))
         pixel_size *= font_rescale_ratio (entity);
@@ -2174,7 +2174,7 @@ font_score (Lisp_Object entity, Lisp_Object *spec_prop)
 static Lisp_Object
 font_vconcat_entity_vectors (Lisp_Object list)
 {
-  EMACS_INT nargs = XFASTINT (Flength (list));
+  EMACS_INT nargs = XFIXNAT (Flength (list));
   Lisp_Object *args;
   USE_SAFE_ALLOCA;
   SAFE_ALLOCA_LISP (args, nargs);
@@ -2492,7 +2492,7 @@ font_match_p (Lisp_Object spec, Lisp_Object font)
                     {
                       if (! CHARACTERP (XCAR (val2)))
                         continue;
-                      if (font_encode_char (font, XFASTINT (XCAR (val2)))
+                      if (font_encode_char (font, XFIXNAT (XCAR (val2)))
                           == FONT_INVALID_CODE)
                         return 0;
                     }
@@ -2504,7 +2504,7 @@ font_match_p (Lisp_Object spec, Lisp_Object font)
                     {
                       if (! CHARACTERP (AREF (val2, i)))
                         continue;
-                      if (font_encode_char (font, XFASTINT (AREF (val2, i)))
+                      if (font_encode_char (font, XFIXNAT (AREF (val2, i)))
                           != FONT_INVALID_CODE)
                         break;
                     }
@@ -2565,7 +2565,7 @@ font_prepare_cache (struct frame *f, struct font_driver const *driver)
   else
     {
       val = XCDR (XCAR (val));
-      XSETCAR (val, make_fixnum (XINT (XCAR (val)) + 1));
+      XSETCAR (val, make_fixnum (XFIXNUM (XCAR (val)) + 1));
     }
 }
 
@@ -2582,8 +2582,8 @@ font_finish_cache (struct frame *f, struct font_driver const *driver)
     cache = val, val = XCDR (val);
   eassert (! NILP (val));
   tmp = XCDR (XCAR (val));
-  XSETCAR (tmp, make_fixnum (XINT (XCAR (tmp)) - 1));
-  if (XINT (XCAR (tmp)) == 0)
+  XSETCAR (tmp, make_fixnum (XFIXNUM (XCAR (tmp)) - 1));
+  if (XFIXNUM (XCAR (tmp)) == 0)
     {
       font_clear_cache (f, XCAR (val), driver);
       XSETCDR (cache, XCDR (val));
@@ -2699,14 +2699,14 @@ font_delete_unmatched (Lisp_Object vec, Lisp_Object spec, int size)
         }
       for (prop = FONT_WEIGHT_INDEX; prop < FONT_SIZE_INDEX; prop++)
         if (FIXNUMP (AREF (spec, prop))
-            && ((XINT (AREF (spec, prop)) >> 8)
-                != (XINT (AREF (entity, prop)) >> 8)))
+            && ((XFIXNUM (AREF (spec, prop)) >> 8)
+                != (XFIXNUM (AREF (entity, prop)) >> 8)))
           prop = FONT_SPEC_MAX;
       if (prop < FONT_SPEC_MAX
           && size
-          && XINT (AREF (entity, FONT_SIZE_INDEX)) > 0)
+          && XFIXNUM (AREF (entity, FONT_SIZE_INDEX)) > 0)
         {
-          int diff = XINT (AREF (entity, FONT_SIZE_INDEX)) - size;
+          int diff = XFIXNUM (AREF (entity, FONT_SIZE_INDEX)) - size;
 
           if (eabs (diff) > FONT_PIXEL_SIZE_QUANTUM)
             prop = FONT_SPEC_MAX;
@@ -2714,13 +2714,13 @@ font_delete_unmatched (Lisp_Object vec, Lisp_Object spec, int size)
       if (prop < FONT_SPEC_MAX
           && FIXNUMP (AREF (spec, FONT_DPI_INDEX))
           && FIXNUMP (AREF (entity, FONT_DPI_INDEX))
-          && XINT (AREF (entity, FONT_DPI_INDEX)) != 0
+          && XFIXNUM (AREF (entity, FONT_DPI_INDEX)) != 0
           && ! EQ (AREF (spec, FONT_DPI_INDEX), AREF (entity, FONT_DPI_INDEX)))
         prop = FONT_SPEC_MAX;
       if (prop < FONT_SPEC_MAX
           && FIXNUMP (AREF (spec, FONT_AVGWIDTH_INDEX))
           && FIXNUMP (AREF (entity, FONT_AVGWIDTH_INDEX))
-          && XINT (AREF (entity, FONT_AVGWIDTH_INDEX)) != 0
+          && XFIXNUM (AREF (entity, FONT_AVGWIDTH_INDEX)) != 0
           && ! EQ (AREF (spec, FONT_AVGWIDTH_INDEX),
                    AREF (entity, FONT_AVGWIDTH_INDEX)))
         prop = FONT_SPEC_MAX;
@@ -2748,7 +2748,7 @@ font_list_entities (struct frame *f, Lisp_Object spec)
   eassert (FONT_SPEC_P (spec));
 
   if (FIXNUMP (AREF (spec, FONT_SIZE_INDEX)))
-    size = XINT (AREF (spec, FONT_SIZE_INDEX));
+    size = XFIXNUM (AREF (spec, FONT_SIZE_INDEX));
   else if (FLOATP (AREF (spec, FONT_SIZE_INDEX)))
     size = font_pixel_size (f, spec);
   else
@@ -2873,8 +2873,8 @@ font_open_entity (struct frame *f, Lisp_Object entity, int pixel_size)
 
   eassert (FONT_ENTITY_P (entity));
   size = AREF (entity, FONT_SIZE_INDEX);
-  if (XINT (size) != 0)
-    pixel_size = XINT (size);
+  if (XFIXNUM (size) != 0)
+    pixel_size = XFIXNUM (size);
 
   val = AREF (entity, FONT_TYPE_INDEX);
   for (driver_list = f->font_driver_list;
@@ -3181,7 +3181,7 @@ font_find_for_lface (struct frame *f, Lisp_Object *attrs, Lisp_Object spec, int
   pixel_size = font_pixel_size (f, spec);
   if (pixel_size == 0 && FIXNUMP (attrs[LFACE_HEIGHT_INDEX]))
     {
-      double pt = XINT (attrs[LFACE_HEIGHT_INDEX]);
+      double pt = XFIXNUM (attrs[LFACE_HEIGHT_INDEX]);
 
       pixel_size = POINT_TO_PIXEL (pt / 10, FRAME_RES_Y (f));
       if (pixel_size < 1)
@@ -3241,7 +3241,7 @@ font_find_for_lface (struct frame *f, Lisp_Object *attrs, Lisp_Object spec, int
 
       if (! NILP (alters))
         {
-          EMACS_INT alterslen = XFASTINT (Flength (alters));
+          EMACS_INT alterslen = XFIXNAT (Flength (alters));
           SAFE_ALLOCA_LISP (family, alterslen + 2);
           for (i = 0; CONSP (alters); i++, alters = XCDR (alters))
             family[i] = XCAR (alters);
@@ -3299,8 +3299,8 @@ font_open_for_lface (struct frame *f, Lisp_Object entity, Lisp_Object *attrs, Li
   int size;
 
   if (FIXNUMP (AREF (entity, FONT_SIZE_INDEX))
-      && XINT (AREF (entity, FONT_SIZE_INDEX)) > 0)
-    size = XINT (AREF (entity, FONT_SIZE_INDEX));
+      && XFIXNUM (AREF (entity, FONT_SIZE_INDEX)) > 0)
+    size = XFIXNUM (AREF (entity, FONT_SIZE_INDEX));
   else
     {
       if (FONT_SPEC_P (spec) && ! NILP (AREF (spec, FONT_SIZE_INDEX)))
@@ -3309,13 +3309,13 @@ font_open_for_lface (struct frame *f, Lisp_Object entity, Lisp_Object *attrs, Li
         {
           double pt;
           if (FIXNUMP (attrs[LFACE_HEIGHT_INDEX]))
-            pt = XINT (attrs[LFACE_HEIGHT_INDEX]);
+            pt = XFIXNUM (attrs[LFACE_HEIGHT_INDEX]);
           else
             {
               struct face *def = FACE_FROM_ID (f, DEFAULT_FACE_ID);
               Lisp_Object height = def->lface[LFACE_HEIGHT_INDEX];
               eassert (FIXNUMP (height));
-              pt = XINT (height);
+              pt = XFIXNUM (height);
             }
 
           pt /= 10;
@@ -3325,7 +3325,7 @@ font_open_for_lface (struct frame *f, Lisp_Object entity, Lisp_Object *attrs, Li
             {
               Lisp_Object ffsize = get_frame_param (f, Qfontsize);
               size = (FIXED_OR_FLOATP (ffsize)
-                      ? POINT_TO_PIXEL (XINT (ffsize), FRAME_RES_Y (f)) : 0);
+                      ? POINT_TO_PIXEL (XFIXNUM (ffsize), FRAME_RES_Y (f)) : 0);
             }
 #endif
         }
@@ -3372,7 +3372,7 @@ font_load_for_lface (struct frame *f, Lisp_Object *attrs, Lisp_Object spec)
                       Lisp_Object lsize = Ffont_get (spec, QCsize);
 
                       if ((FLOATP (lsize) && XFLOAT_DATA (lsize) == font_size)
-                          || (FIXNUMP (lsize) && XINT (lsize) == font_size))
+                          || (FIXNUMP (lsize) && XFIXNUM (lsize) == font_size))
                         {
                           ASET (spec, FONT_FAMILY_INDEX,
                                 font_intern_prop (p, tail - p, 1));
@@ -3673,7 +3673,7 @@ font_filter_properties (Lisp_Object font,
 
         if (strcmp (boolean_properties[i], keystr) == 0)
           {
-            const char *str = FIXNUMP (val) ? (XINT (val) ? "true" : "false")
+            const char *str = FIXNUMP (val) ? (XFIXNUM (val) ? "true" : "false")
               : SYMBOLP (val) ? SSDATA (SYMBOL_NAME (val))
               : "true";
 
@@ -3828,7 +3828,7 @@ font_range (ptrdiff_t pos, ptrdiff_t pos_byte, ptrdiff_t *limit,
         FETCH_STRING_CHAR_ADVANCE_NO_CHECK (c, string, pos, pos_byte);
       category = CHAR_TABLE_REF (Vunicode_category_table, c);
       if (FIXNUMP (category)
-          && (XINT (category) == UNICODE_CATEGORY_Cf
+          && (XFIXNUM (category) == UNICODE_CATEGORY_Cf
               || CHAR_VARIATION_SELECTOR_P (c)))
         continue;
       if (NILP (font_object))
@@ -4145,9 +4145,9 @@ are to be displayed on.  If omitted, the selected frame is used.  */)
   if (FIXNUMP (val))
     {
       Lisp_Object font_dpi = AREF (font, FONT_DPI_INDEX);
-      int dpi = FIXNUMP (font_dpi) ? XINT (font_dpi) : FRAME_RES_Y (f);
+      int dpi = FIXNUMP (font_dpi) ? XFIXNUM (font_dpi) : FRAME_RES_Y (f);
       plist[n++] = QCheight;
-      plist[n++] = make_fixnum (PIXEL_TO_POINT (XINT (val) * 10, dpi));
+      plist[n++] = make_fixnum (PIXEL_TO_POINT (XFIXNUM (val) * 10, dpi));
     }
   else if (FLOATP (val))
     {
@@ -4232,7 +4232,7 @@ how close they are to PREFER.  */)
   if (! NILP (num))
     {
       CHECK_FIXNUM (num);
-      n = XINT (num);
+      n = XFIXNUM (num);
       if (n <= 0)
         return Qnil;
     }
@@ -4358,7 +4358,7 @@ clear_font_cache (struct frame *f)
                ! EQ (XCAR (XCAR (val)), driver_list->driver->type))
           val = XCDR (val);
         tmp = XCDR (XCAR (val));
-        if (XINT (XCAR (tmp)) == 0)
+        if (XFIXNUM (XCAR (tmp)) == 0)
           {
             font_clear_cache (f, XCAR (val), driver_list->driver);
             XSETCDR (cache, XCDR (val));
@@ -4432,10 +4432,10 @@ GSTRING.  */)
       gstring = larger_vector (gstring,
                                LGSTRING_GLYPH_LEN (gstring), -1);
     }
-  if (i == 3 || XINT (n) == 0)
+  if (i == 3 || XFIXNUM (n) == 0)
     return Qnil;
-  if (XINT (n) < LGSTRING_GLYPH_LEN (gstring))
-    LGSTRING_SET_GLYPH (gstring, XINT (n), Qnil);
+  if (XFIXNUM (n) < LGSTRING_GLYPH_LEN (gstring))
+    LGSTRING_SET_GLYPH (gstring, XFIXNUM (n), Qnil);
 
   /* Check FROM_IDX and TO_IDX of each GLYPH in GSTRING to assure that
      GLYPHS covers all characters (except for the last few ones) in
@@ -4469,7 +4469,7 @@ GSTRING.  */)
       from = LGLYPH_FROM (glyph);
       to = LGLYPH_TO (glyph);
     }
-  return composition_gstring_put_cache (gstring, XINT (n));
+  return composition_gstring_put_cache (gstring, XFIXNUM (n));
 
  shaper_error:
   return Qnil;
@@ -4495,7 +4495,7 @@ where
   font = XFONT_OBJECT (font_object);
   if (! font->driver->get_variation_glyphs)
     return Qnil;
-  n = font->driver->get_variation_glyphs (font, XINT (character), variations);
+  n = font->driver->get_variation_glyphs (font, XFIXNUM (character), variations);
   if (! n)
     return Qnil;
   val = Qnil;
@@ -4556,7 +4556,7 @@ DEFUN ("internal-char-font", Finternal_char_font, Sinternal_char_font, 1, 2, 0,
   if (NILP (position))
     {
       CHECK_CHARACTER (ch);
-      c = XINT (ch);
+      c = XFIXNUM (ch);
       f = XFRAME (selected_frame);
       face_id = lookup_basic_face (NULL, f, DEFAULT_FACE_ID);
       pos = -1;
@@ -4567,16 +4567,16 @@ DEFUN ("internal-char-font", Finternal_char_font, Sinternal_char_font, 1, 2, 0,
       struct window *w;
 
       CHECK_FIXNUM_COERCE_MARKER (position);
-      if (! (BEGV <= XINT (position) && XINT (position) < ZV))
+      if (! (BEGV <= XFIXNUM (position) && XFIXNUM (position) < ZV))
         args_out_of_range_3 (position, make_fixnum (BEGV), make_fixnum (ZV));
-      pos = XINT (position);
+      pos = XFIXNUM (position);
       pos_byte = CHAR_TO_BYTE (pos);
       if (NILP (ch))
         c = FETCH_CHAR (pos_byte);
       else
         {
           CHECK_FIXNAT (ch);
-          c = XINT (ch);
+          c = XFIXNUM (ch);
         }
       window = Fget_buffer_window (Fcurrent_buffer (), Qnil);
       if (NILP (window))
@@ -4669,13 +4669,13 @@ glyph-string.  */)
   CHECK_FIXNAT (to);
   CHECK_FIXNAT (index);
 
-  if (XINT (from) >= XINT (to) || XINT (to) > len)
+  if (XFIXNUM (from) >= XFIXNUM (to) || XFIXNUM (to) > len)
     args_out_of_range_3 (from, to, make_fixnum (len));
-  if (XINT (index) >= ASIZE (gstring_out))
+  if (XFIXNUM (index) >= ASIZE (gstring_out))
     args_out_of_range (index, make_fixnum (ASIZE (gstring_out)));
   num = font->driver->otf_drive (font, otf_features,
-                                 gstring_in, XINT (from), XINT (to),
-                                 gstring_out, XINT (index), 0);
+                                 gstring_in, XFIXNUM (from), XFIXNUM (to),
+                                 gstring_out, XFIXNUM (index), 0);
   if (num < 0)
     return Qnil;
   return make_fixnum (num);
@@ -4708,7 +4708,7 @@ corresponding character.  */)
 
   gstring_in = Ffont_make_gstring (font_object, make_fixnum (1));
   g = LGSTRING_GLYPH (gstring_in, 0);
-  LGLYPH_SET_CHAR (g, XINT (character));
+  LGLYPH_SET_CHAR (g, XFIXNUM (character));
   gstring_out = Ffont_make_gstring (font_object, make_fixnum (10));
   while ((num = font->driver->otf_drive (font, otf_features, gstring_in, 0, 1,
                                          gstring_out, 0, 1)) < 0)
@@ -4741,14 +4741,14 @@ DEFUN ("open-font", Fopen_font, Sopen_font, 1, 3, 0,
   CHECK_FONT_ENTITY (font_entity);
 
   if (NILP (size))
-    isize = XINT (AREF (font_entity, FONT_SIZE_INDEX));
+    isize = XFIXNUM (AREF (font_entity, FONT_SIZE_INDEX));
   else
     {
       CHECK_FIXNUM_OR_FLOAT (size);
       if (FLOATP (size))
         isize = POINT_TO_PIXEL (XFLOAT_DATA (size), FRAME_RES_Y (f));
       else
-        isize = XINT (size);
+        isize = XFIXNUM (size);
       if (! (INT_MIN <= isize && isize <= INT_MAX))
         args_out_of_range (font_entity, size);
       if (isize == 0)
@@ -4862,11 +4862,11 @@ the corresponding element is nil.  */)
       validate_region (&from, &to);
       if (EQ (from, to))
         return Qnil;
-      len = XFASTINT (to) - XFASTINT (from);
+      len = XFIXNAT (to) - XFIXNAT (from);
       SAFE_ALLOCA_LISP (chars, len);
-      charpos = XFASTINT (from);
+      charpos = XFIXNAT (from);
       bytepos = CHAR_TO_BYTE (charpos);
-      for (i = 0; charpos < XFASTINT (to); i++)
+      for (i = 0; charpos < XFIXNAT (to); i++)
         {
           int c;
           FETCH_CHAR_ADVANCE (c, charpos, bytepos);
@@ -4925,7 +4925,7 @@ the corresponding element is nil.  */)
   for (i = 0; i < len; i++)
     {
       Lisp_Object g;
-      int c = XFASTINT (chars[i]);
+      int c = XFIXNAT (chars[i]);
       unsigned code;
       struct font_metrics metrics;
 
@@ -4979,18 +4979,18 @@ character at index specified by POSITION.  */)
       if (XBUFFER (w->contents) != current_buffer)
         error ("Specified window is not displaying the current buffer");
       CHECK_FIXNUM_COERCE_MARKER (position);
-      if (! (BEGV <= XINT (position) && XINT (position) < ZV))
+      if (! (BEGV <= XFIXNUM (position) && XFIXNUM (position) < ZV))
         args_out_of_range_3 (position, make_fixnum (BEGV), make_fixnum (ZV));
     }
   else
     {
       CHECK_FIXNUM (position);
       CHECK_STRING (string);
-      if (! (0 <= XINT (position) && XINT (position) < SCHARS (string)))
+      if (! (0 <= XFIXNUM (position) && XFIXNUM (position) < SCHARS (string)))
         args_out_of_range (string, position);
     }
 
-  return font_at (-1, XINT (position), NULL, w, string);
+  return font_at (-1, XFIXNUM (position), NULL, w, string);
 }
 
 #if 0
@@ -5015,7 +5015,7 @@ Type C-l to recover what previously shown.  */)
     {
       Lisp_Object ch = Faref (string, make_fixnum (i));
       Lisp_Object val;
-      int c = XINT (ch);
+      int c = XFIXNUM (ch);
 
       code[i] = font->driver->encode_char (font, c);
       if (code[i] == FONT_INVALID_CODE)
diff --git a/src/font.h b/src/font.h
index 62a9920e597..1741b3f3964 100644
--- a/src/font.h
+++ b/src/font.h
@@ -186,15 +186,15 @@ enum font_property_index
 /* Return the numeric weight value of FONT.  */
 #define FONT_WEIGHT_NUMERIC(font)               \
   (FIXNUMP (AREF ((font), FONT_WEIGHT_INDEX))   \
-   ? (XINT (AREF ((font), FONT_WEIGHT_INDEX)) >> 8) : -1)
+   ? (XFIXNUM (AREF ((font), FONT_WEIGHT_INDEX)) >> 8) : -1)
 /* Return the numeric slant value of FONT.  */
 #define FONT_SLANT_NUMERIC(font)                \
   (FIXNUMP (AREF ((font), FONT_SLANT_INDEX))    \
-   ? (XINT (AREF ((font), FONT_SLANT_INDEX)) >> 8) : -1)
+   ? (XFIXNUM (AREF ((font), FONT_SLANT_INDEX)) >> 8) : -1)
 /* Return the numeric width value of FONT.  */
 #define FONT_WIDTH_NUMERIC(font)                \
   (FIXNUMP (AREF ((font), FONT_WIDTH_INDEX))    \
-   ? (XINT (AREF ((font), FONT_WIDTH_INDEX)) >> 8) : -1)
+   ? (XFIXNUM (AREF ((font), FONT_WIDTH_INDEX)) >> 8) : -1)
 /* Return the symbolic weight value of FONT.  */
 #define FONT_WEIGHT_SYMBOLIC(font)      \
   font_style_symbolic (font, FONT_WEIGHT_INDEX, false)
diff --git a/src/fontset.c b/src/fontset.c
index d4a2e4ea5b8..0dbc54efd08 100644
--- a/src/fontset.c
+++ b/src/fontset.c
@@ -276,7 +276,7 @@ set_fontset_fallback (Lisp_Object fontset, Lisp_Object fallback)
    the order of listing by font backends, the higher bits represents
    the order given by charset priority list.  The smaller value is
    preferable.  */
-#define RFONT_DEF_SCORE(rfont_def) XINT (AREF (rfont_def, 3))
+#define RFONT_DEF_SCORE(rfont_def) XFIXNUM (AREF (rfont_def, 3))
 #define RFONT_DEF_SET_SCORE(rfont_def, score) \
   ASET ((rfont_def), 3, make_fixnum (score))
 #define RFONT_DEF_NEW(rfont_def, font_def)              \
@@ -344,8 +344,8 @@ fontset_add (Lisp_Object fontset, Lisp_Object range, Lisp_Object elt, Lisp_Objec
 
   if (CONSP (range))
     {
-      int from = XINT (XCAR (range));
-      int to = XINT (XCDR (range));
+      int from = XFIXNUM (XCAR (range));
+      int to = XFIXNUM (XCDR (range));
       int from1, to1;
 
       do {
@@ -561,7 +561,7 @@ fontset_find_font (Lisp_Object fontset, int c, struct face *face,
 
   if (ASIZE (vec) > 1)
     {
-      if (XINT (XCAR (font_group)) != charset_ordered_list_tick)
+      if (XFIXNUM (XCAR (font_group)) != charset_ordered_list_tick)
         /* We have just created the font-group,
            or the charset priorities were changed.  */
         reorder_font_vector (font_group, face->ascii_face->font);
@@ -577,7 +577,7 @@ fontset_find_font (Lisp_Object fontset, int c, struct face *face,
               break;
             repertory = FONT_DEF_REPERTORY (RFONT_DEF_FONT_DEF (rfont_def));
 
-            if (XINT (repertory) == charset_id)
+            if (XFIXNUM (repertory) == charset_id)
               {
                 charset_matched = i;
                 break;
@@ -634,7 +634,7 @@ fontset_find_font (Lisp_Object fontset, int c, struct face *face,
           return Qt;
         }
       if (FIXNUMP (RFONT_DEF_FACE (rfont_def))
-          && XINT (RFONT_DEF_FACE (rfont_def)) < 0)
+          && XFIXNUM (RFONT_DEF_FACE (rfont_def)) < 0)
         /* We couldn't open this font last time.  */
         continue;
 
@@ -892,7 +892,7 @@ free_face_fontset (struct frame *f, struct face *face)
     next_fontset_id = face->fontset;
   if (! NILP (FONTSET_DEFAULT (fontset)))
     {
-      int id = XINT (FONTSET_ID (FONTSET_DEFAULT (fontset)));
+      int id = XFIXNUM (FONTSET_ID (FONTSET_DEFAULT (fontset)));
 
       fontset = AREF (Vfontset_table, id);
       eassert (!NILP (fontset) && ! BASE_FONTSET_P (fontset));
@@ -981,7 +981,7 @@ face_for_char (struct frame *f, struct face *face, int c,
           val = assq_no_quit (charset, Vfont_encoding_charset_alist);
           if (CONSP (val) && CHARSETP (XCDR (val)))
             charset = XCDR (val);
-          id = XINT (CHARSET_SYMBOL_ID (charset));
+          id = XFIXNUM (CHARSET_SYMBOL_ID (charset));
         }
       else
         id = -1;
@@ -991,7 +991,7 @@ face_for_char (struct frame *f, struct face *face, int c,
   if (VECTORP (rfont_def))
     {
       if (FIXNUMP (RFONT_DEF_FACE (rfont_def)))
-        face_id = XINT (RFONT_DEF_FACE (rfont_def));
+        face_id = XFIXNUM (RFONT_DEF_FACE (rfont_def));
       else
         {
           Lisp_Object font_object;
@@ -1004,7 +1004,7 @@ face_for_char (struct frame *f, struct face *face, int c,
   else
     {
       if (FIXNUMP (FONTSET_NOFONT_FACE (fontset)))
-        face_id = XINT (FONTSET_NOFONT_FACE (fontset));
+        face_id = XFIXNUM (FONTSET_NOFONT_FACE (fontset));
       else
         {
           face_id = face_for_font (f, Qnil, face);
@@ -1048,7 +1048,7 @@ font_for_char (struct face *face, int c, ptrdiff_t pos, Lisp_Object object)
           val = assq_no_quit (charset, Vfont_encoding_charset_alist);
           if (CONSP (val) && CHARSETP (XCDR (val)))
             charset = XCDR (val);
-          id = XINT (CHARSET_SYMBOL_ID (charset));
+          id = XFIXNUM (CHARSET_SYMBOL_ID (charset));
         }
       else
         id = -1;
@@ -1083,7 +1083,7 @@ make_fontset_for_ascii_face (struct frame *f, int base_fontset_id, struct face *
     base_fontset = Vdefault_fontset;
 
   fontset = make_fontset (frame, Qnil, base_fontset);
-  return XINT (FONTSET_ID (fontset));
+  return XFIXNUM (FONTSET_ID (fontset));
 }
 
 
@@ -1306,7 +1306,7 @@ free_realized_fontsets (Lisp_Object base)
                tail = XCDR (tail))
             {
               struct frame *f = XFRAME (FONTSET_FRAME (this));
-              int face_id = XINT (XCDR (XCAR (tail)));
+              int face_id = XFIXNUM (XCDR (XCAR (tail)));
               struct face *face = FACE_FROM_ID_OR_NULL (f, face_id);
 
               /* Face THIS itself is also freed by the following call.  */
@@ -1399,7 +1399,7 @@ static void
 set_fontset_font (Lisp_Object arg, Lisp_Object range)
 {
   Lisp_Object fontset, font_def, add, ascii, script_range_list;
-  int from = XINT (XCAR (range)), to = XINT (XCDR (range));
+  int from = XFIXNUM (XCAR (range)), to = XFIXNUM (XCDR (range));
 
   fontset = AREF (arg, 0);
   font_def = AREF (arg, 1);
@@ -1415,8 +1415,8 @@ set_fontset_font (Lisp_Object arg, Lisp_Object range)
       range = Fcons (make_fixnum (0x80), XCDR (range));
     }
 
-#define SCRIPT_FROM XINT (XCAR (XCAR (script_range_list)))
-#define SCRIPT_TO XINT (XCDR (XCAR (script_range_list)))
+#define SCRIPT_FROM XFIXNUM (XCAR (XCAR (script_range_list)))
+#define SCRIPT_TO XFIXNUM (XCDR (XCAR (script_range_list)))
 #define POP_SCRIPT_RANGE() script_range_list = XCDR (script_range_list)
 
   for (; CONSP (script_range_list) && SCRIPT_TO < from; POP_SCRIPT_RANGE ())
@@ -1544,7 +1544,7 @@ appended.  By default, FONT-SPEC overrides the previous settings.  */)
 
   if (CHARACTERP (target))
     {
-      if (XFASTINT (target) < 0x80)
+      if (XFIXNAT (target) < 0x80)
         error ("Can't set a font for partial ASCII range");
       range_list = list1 (Fcons (target, target));
     }
@@ -1556,9 +1556,9 @@ appended.  By default, FONT-SPEC overrides the previous settings.  */)
       to = Fcdr (target);
       CHECK_CHARACTER (from);
       CHECK_CHARACTER (to);
-      if (XFASTINT (from) < 0x80)
+      if (XFIXNAT (from) < 0x80)
         {
-          if (XFASTINT (from) != 0 || XFASTINT (to) < 0x7F)
+          if (XFIXNAT (from) != 0 || XFIXNAT (to) < 0x7F)
             error ("Can't set a font for partial ASCII range");
           ascii_changed = 1;
         }
@@ -1629,7 +1629,7 @@ appended.  By default, FONT-SPEC overrides the previous settings.  */)
   if (ascii_changed)
     {
       Lisp_Object tail, fr;
-      int fontset_id = XINT (FONTSET_ID (fontset));
+      int fontset_id = XFIXNUM (FONTSET_ID (fontset));
 
       set_fontset_ascii (fontset, fontname);
       name = FONTSET_NAME (fontset);
@@ -1762,7 +1762,7 @@ fontset_from_font (Lisp_Object font_object)
 
   val = assoc_no_quit (font_spec, auto_fontset_alist);
   if (CONSP (val))
-    return XINT (FONTSET_ID (XCDR (val)));
+    return XFIXNUM (FONTSET_ID (XCDR (val)));
   if (num_auto_fontsets++ == 0)
     alias = intern ("fontset-startup");
   else
@@ -1797,7 +1797,7 @@ fontset_from_font (Lisp_Object font_object)
 
   set_fontset_ascii (fontset, font_name);
 
-  return XINT (FONTSET_ID (fontset));
+  return XFIXNUM (FONTSET_ID (fontset));
 }
 
 
@@ -1985,7 +1985,7 @@ patterns.  */)
   fontset = check_fontset_name (name, &frame);
 
   CHECK_CHARACTER (ch);
-  c = XINT (ch);
+  c = XFIXNUM (ch);
   list = Qnil;
   while (1)
     {
@@ -2002,7 +2002,7 @@ patterns.  */)
               repertory = AREF (val, 1);
               if (FIXNUMP (repertory))
                 {
-                  struct charset *charset = CHARSET_FROM_ID (XINT (repertory));
+                  struct charset *charset = CHARSET_FROM_ID (XFIXNUM (repertory));
 
                   if (! CHAR_CHARSET_P (c, charset))
                     continue;
diff --git a/src/frame.c b/src/frame.c
index e13b392eca6..c2e3d4b6190 100644
--- a/src/frame.c
+++ b/src/frame.c
@@ -159,9 +159,9 @@ frame_size_history_add (struct frame *f, Lisp_Object fun_symbol,
   XSETFRAME (frame, f);
   if (CONSP (frame_size_history)
       && FIXNUMP (XCAR (frame_size_history))
-      && 0 < XINT (XCAR (frame_size_history)))
+      && 0 < XFIXNUM (XCAR (frame_size_history)))
     frame_size_history =
-      Fcons (make_fixnum (XINT (XCAR (frame_size_history)) - 1),
+      Fcons (make_fixnum (XFIXNUM (XCAR (frame_size_history)) - 1),
              Fcons (list4
                     (frame, fun_symbol,
                      ((width > 0)
@@ -220,7 +220,7 @@ set_menu_bar_lines (struct frame *f, Lisp_Object value, Lisp_Object oldval)
     return;
 
   if (TYPE_RANGED_FIXNUMP (int, value))
-    nlines = XINT (value);
+    nlines = XFIXNUM (value);
   else
     nlines = 0;
 
@@ -359,7 +359,7 @@ frame_windows_min_size (Lisp_Object frame, Lisp_Object horizontal,
       || (NILP (horizontal)
           && FIXED_OR_FLOATP (par_size = get_frame_param (f, Qmin_height))))
     {
-      int min_size = XINT (par_size);
+      int min_size = XFIXNUM (par_size);
 
       /* Don't allow phantom frames.  */
       if (min_size < 1)
@@ -372,7 +372,7 @@ frame_windows_min_size (Lisp_Object frame, Lisp_Object horizontal,
                               : FRAME_COLUMN_WIDTH (f)));
     }
   else
-    retval = XINT (call4 (Qframe_windows_min_size, frame, horizontal,
+    retval = XFIXNUM (call4 (Qframe_windows_min_size, frame, horizontal,
                           ignore, pixelwise));
   /* Don't allow too small height of text-mode frames, or else cm.c
      might abort in cmcheckmagic.  */
@@ -1598,7 +1598,7 @@ candidate_frame (Lisp_Object candidate, Lisp_Object frame, Lisp_Object minibuf)
                      FRAME_FOCUS_FRAME (c)))
             return candidate;
         }
-      else if (FIXNUMP (minibuf) && XINT (minibuf) == 0)
+      else if (FIXNUMP (minibuf) && XFIXNUM (minibuf) == 0)
         {
           if (FRAME_VISIBLE_P (c) || FRAME_ICONIFIED_P (c))
             return candidate;
@@ -2320,8 +2320,8 @@ and returns whatever that function returns.  */)
 
   if (! NILP (x))
     {
-      int col = XINT (x);
-      int row = XINT (y);
+      int col = XFIXNUM (x);
+      int row = XFIXNUM (y);
       pixel_to_glyph_coords (f, col, row, &col, &row, NULL, 1);
       XSETINT (x, col);
       XSETINT (y, row);
@@ -2430,19 +2430,19 @@ before calling this function on it, like this.
 #ifdef HAVE_WINDOW_SYSTEM
   if (FRAME_WINDOW_P (XFRAME (frame)))
     /* Warping the mouse will cause enternotify and focus events.  */
-    frame_set_mouse_position (XFRAME (frame), XINT (x), XINT (y));
+    frame_set_mouse_position (XFRAME (frame), XFIXNUM (x), XFIXNUM (y));
 #else
 #if defined (MSDOS)
   if (FRAME_MSDOS_P (XFRAME (frame)))
     {
       Fselect_frame (frame, Qnil);
-      mouse_moveto (XINT (x), XINT (y));
+      mouse_moveto (XFIXNUM (x), XFIXNUM (y));
     }
 #else
 #ifdef HAVE_GPM
     {
       Fselect_frame (frame, Qnil);
-      term_mouse_moveto (XINT (x), XINT (y));
+      term_mouse_moveto (XFIXNUM (x), XFIXNUM (y));
     }
 #endif
 #endif
@@ -2471,19 +2471,19 @@ before calling this function on it, like this.
 #ifdef HAVE_WINDOW_SYSTEM
   if (FRAME_WINDOW_P (XFRAME (frame)))
     /* Warping the mouse will cause enternotify and focus events.  */
-    frame_set_mouse_pixel_position (XFRAME (frame), XINT (x), XINT (y));
+    frame_set_mouse_pixel_position (XFRAME (frame), XFIXNUM (x), XFIXNUM (y));
 #else
 #if defined (MSDOS)
   if (FRAME_MSDOS_P (XFRAME (frame)))
     {
       Fselect_frame (frame, Qnil);
-      mouse_moveto (XINT (x), XINT (y));
+      mouse_moveto (XFIXNUM (x), XFIXNUM (y));
     }
 #else
 #ifdef HAVE_GPM
     {
       Fselect_frame (frame, Qnil);
-      term_mouse_moveto (XINT (x), XINT (y));
+      term_mouse_moveto (XFIXNUM (x), XFIXNUM (y));
     }
 #endif
 #endif
@@ -3193,7 +3193,7 @@ list, but are otherwise ignored.  */)
 #endif
 
     {
-      EMACS_INT length = XFASTINT (Flength (alist));
+      EMACS_INT length = XFIXNAT (Flength (alist));
       ptrdiff_t i;
       Lisp_Object *parms;
       Lisp_Object *values;
@@ -3428,8 +3428,8 @@ multiple of the default frame font height.  */)
   CHECK_TYPE_RANGED_INTEGER (int, height);
 
   pixel_height = (!NILP (pixelwise)
-                  ? XINT (height)
-                  : XINT (height) * FRAME_LINE_HEIGHT (f));
+                  ? XFIXNUM (height)
+                  : XFIXNUM (height) * FRAME_LINE_HEIGHT (f));
   adjust_frame_size (f, -1, pixel_height, 1, !NILP (pretend), Qheight);
 
   return Qnil;
@@ -3453,8 +3453,8 @@ multiple of the default frame font width.  */)
   CHECK_TYPE_RANGED_INTEGER (int, width);
 
   pixel_width = (!NILP (pixelwise)
-                 ? XINT (width)
-                 : XINT (width) * FRAME_COLUMN_WIDTH (f));
+                 ? XFIXNUM (width)
+                 : XFIXNUM (width) * FRAME_COLUMN_WIDTH (f));
   adjust_frame_size (f, pixel_width, -1, 1, !NILP (pretend), Qwidth);
 
   return Qnil;
@@ -3476,11 +3476,11 @@ font height.  */)
   CHECK_TYPE_RANGED_INTEGER (int, height);
 
   pixel_width = (!NILP (pixelwise)
-                 ? XINT (width)
-                 : XINT (width) * FRAME_COLUMN_WIDTH (f));
+                 ? XFIXNUM (width)
+                 : XFIXNUM (width) * FRAME_COLUMN_WIDTH (f));
   pixel_height = (!NILP (pixelwise)
-                  ? XINT (height)
-                  : XINT (height) * FRAME_LINE_HEIGHT (f));
+                  ? XFIXNUM (height)
+                  : XFIXNUM (height) * FRAME_LINE_HEIGHT (f));
   adjust_frame_size (f, pixel_width, pixel_height, 1, 0, Qsize);
 
   return Qnil;
@@ -3520,7 +3520,7 @@ bottom edge of FRAME's display.  */)
   if (FRAME_WINDOW_P (f))
     {
 #ifdef HAVE_WINDOW_SYSTEM
-      x_set_offset (f, XINT (x), XINT (y), 1);
+      x_set_offset (f, XFIXNUM (x), XFIXNUM (y), 1);
 #endif
     }
 
@@ -3689,10 +3689,10 @@ frame_float (struct frame *f, Lisp_Object val, enum frame_float_type what,
                 }
 
               /* Workarea available.  */
-              parent_left = XINT (Fnth (make_fixnum (0), workarea));
-              parent_top = XINT (Fnth (make_fixnum (1), workarea));
-              parent_width = XINT (Fnth (make_fixnum (2), workarea));
-              parent_height = XINT (Fnth (make_fixnum (3), workarea));
+              parent_left = XFIXNUM (Fnth (make_fixnum (0), workarea));
+              parent_top = XFIXNUM (Fnth (make_fixnum (1), workarea));
+              parent_width = XFIXNUM (Fnth (make_fixnum (2), workarea));
+              parent_height = XFIXNUM (Fnth (make_fixnum (3), workarea));
               *parent_done = 1;
             }
         }
@@ -3720,12 +3720,12 @@ frame_float (struct frame *f, Lisp_Object val, enum frame_float_type what,
           if (!NILP (outer_edges))
             {
               outer_minus_text_width
-                = (XINT (Fnth (make_fixnum (2), outer_edges))
-                   - XINT (Fnth (make_fixnum (0), outer_edges))
+                = (XFIXNUM (Fnth (make_fixnum (2), outer_edges))
+                   - XFIXNUM (Fnth (make_fixnum (0), outer_edges))
                    - FRAME_TEXT_WIDTH (f));
               outer_minus_text_height
-                = (XINT (Fnth (make_fixnum (3), outer_edges))
-                   - XINT (Fnth (make_fixnum (1), outer_edges))
+                = (XFIXNUM (Fnth (make_fixnum (3), outer_edges))
+                   - XFIXNUM (Fnth (make_fixnum (1), outer_edges))
                    - FRAME_TEXT_HEIGHT (f));
             }
           else
@@ -3875,10 +3875,10 @@ x_set_frame_parameters (struct frame *f, Lisp_Object alist)
       if (EQ (prop, Qwidth))
         {
           if (RANGED_FIXNUMP (0, val, INT_MAX))
-            width = XFASTINT (val) * FRAME_COLUMN_WIDTH (f) ;
+            width = XFIXNAT (val) * FRAME_COLUMN_WIDTH (f) ;
           else if (CONSP (val) && EQ (XCAR (val), Qtext_pixels)
                    && RANGED_FIXNUMP (0, XCDR (val), INT_MAX))
-            width = XFASTINT (XCDR (val));
+            width = XFIXNAT (XCDR (val));
           else if (FLOATP (val))
             width = frame_float (f, val, FRAME_FLOAT_WIDTH, &parent_done,
                                  &outer_done, -1);
@@ -3886,10 +3886,10 @@ x_set_frame_parameters (struct frame *f, Lisp_Object alist)
       else if (EQ (prop, Qheight))
         {
           if (RANGED_FIXNUMP (0, val, INT_MAX))
-            height = XFASTINT (val) * FRAME_LINE_HEIGHT (f);
+            height = XFIXNAT (val) * FRAME_LINE_HEIGHT (f);
           else if (CONSP (val) && EQ (XCAR (val), Qtext_pixels)
                    && RANGED_FIXNUMP (0, XCDR (val), INT_MAX))
-            height = XFASTINT (XCDR (val));
+            height = XFIXNAT (XCDR (val));
           else if (FLOATP (val))
             height = frame_float (f, val, FRAME_FLOAT_HEIGHT, &parent_done,
                                  &outer_done, -1);
@@ -3917,9 +3917,9 @@ x_set_frame_parameters (struct frame *f, Lisp_Object alist)
 
           param_index = Fget (prop, Qx_frame_parameter);
           if (FIXNATP (param_index)
-              && XFASTINT (param_index) < ARRAYELTS (frame_parms)
-              && FRAME_RIF (f)->frame_parm_handlers[XINT (param_index)])
-            (*(FRAME_RIF (f)->frame_parm_handlers[XINT (param_index)])) (f, val, old_value);
+              && XFIXNAT (param_index) < ARRAYELTS (frame_parms)
+              && FRAME_RIF (f)->frame_parm_handlers[XFIXNUM (param_index)])
+            (*(FRAME_RIF (f)->frame_parm_handlers[XFIXNUM (param_index)])) (f, val, old_value);
         }
     }
 
@@ -3981,8 +3981,8 @@ x_set_frame_parameters (struct frame *f, Lisp_Object alist)
 
   if ((!NILP (left) || !NILP (top))
       && ! (left_no_change && top_no_change)
-      && ! (FIXED_OR_FLOATP (left) && XINT (left) == f->left_pos
-            && FIXED_OR_FLOATP (top) && XINT (top) == f->top_pos))
+      && ! (FIXED_OR_FLOATP (left) && XFIXNUM (left) == f->left_pos
+            && FIXED_OR_FLOATP (top) && XFIXNUM (top) == f->top_pos))
     {
       int leftpos = 0;
       int toppos = 0;
@@ -3993,7 +3993,7 @@ x_set_frame_parameters (struct frame *f, Lisp_Object alist)
         f->size_hint_flags |= XNegative;
       else if (TYPE_RANGED_FIXNUMP (int, left))
         {
-          leftpos = XINT (left);
+          leftpos = XFIXNUM (left);
           if (leftpos < 0)
             f->size_hint_flags |= XNegative;
         }
@@ -4001,13 +4001,13 @@ x_set_frame_parameters (struct frame *f, Lisp_Object alist)
                && CONSP (XCDR (left))
                && RANGED_FIXNUMP (-INT_MAX, XCAR (XCDR (left)), INT_MAX))
         {
-          leftpos = - XINT (XCAR (XCDR (left)));
+          leftpos = - XFIXNUM (XCAR (XCDR (left)));
           f->size_hint_flags |= XNegative;
         }
       else if (CONSP (left) && EQ (XCAR (left), Qplus)
                && CONSP (XCDR (left))
                && TYPE_RANGED_FIXNUMP (int, XCAR (XCDR (left))))
-        leftpos = XINT (XCAR (XCDR (left)));
+        leftpos = XFIXNUM (XCAR (XCDR (left)));
       else if (FLOATP (left))
         leftpos = frame_float (f, left, FRAME_FLOAT_LEFT, &parent_done,
                                &outer_done, 0);
@@ -4016,7 +4016,7 @@ x_set_frame_parameters (struct frame *f, Lisp_Object alist)
         f->size_hint_flags |= YNegative;
       else if (TYPE_RANGED_FIXNUMP (int, top))
         {
-          toppos = XINT (top);
+          toppos = XFIXNUM (top);
           if (toppos < 0)
             f->size_hint_flags |= YNegative;
         }
@@ -4024,13 +4024,13 @@ x_set_frame_parameters (struct frame *f, Lisp_Object alist)
                && CONSP (XCDR (top))
                && RANGED_FIXNUMP (-INT_MAX, XCAR (XCDR (top)), INT_MAX))
         {
-          toppos = - XINT (XCAR (XCDR (top)));
+          toppos = - XFIXNUM (XCAR (XCDR (top)));
           f->size_hint_flags |= YNegative;
         }
       else if (CONSP (top) && EQ (XCAR (top), Qplus)
                && CONSP (XCDR (top))
                && TYPE_RANGED_FIXNUMP (int, XCAR (XCDR (top))))
-        toppos = XINT (XCAR (XCDR (top)));
+        toppos = XFIXNUM (XCAR (XCDR (top)));
       else if (FLOATP (top))
         toppos = frame_float (f, top, FRAME_FLOAT_TOP, &parent_done,
                               &outer_done, 0);
@@ -4061,7 +4061,7 @@ x_set_frame_parameters (struct frame *f, Lisp_Object alist)
 #ifdef HAVE_X_WINDOWS
   if ((!NILP (icon_left) || !NILP (icon_top))
       && ! (icon_left_no_change && icon_top_no_change))
-    x_wm_set_icon_position (f, XINT (icon_left), XINT (icon_top));
+    x_wm_set_icon_position (f, XFIXNUM (icon_left), XFIXNUM (icon_top));
 #endif /* HAVE_X_WINDOWS */
 
   SAFE_FREE ();
@@ -4188,7 +4188,7 @@ x_set_line_spacing (struct frame *f, Lisp_Object new_value, Lisp_Object old_valu
   if (NILP (new_value))
     f->extra_line_spacing = 0;
   else if (RANGED_FIXNUMP (0, new_value, INT_MAX))
-    f->extra_line_spacing = XFASTINT (new_value);
+    f->extra_line_spacing = XFIXNAT (new_value);
   else if (FLOATP (new_value))
     {
       int new_spacing = XFLOAT_DATA (new_value) * FRAME_LINE_HEIGHT (f) + 0.5;
@@ -4227,9 +4227,9 @@ x_set_screen_gamma (struct frame *f, Lisp_Object new_value, Lisp_Object old_valu
     {
       Lisp_Object parm_index = Fget (Qbackground_color, Qx_frame_parameter);
       if (FIXNATP (parm_index)
-          && XFASTINT (parm_index) < ARRAYELTS (frame_parms)
-          && FRAME_RIF (f)->frame_parm_handlers[XFASTINT (parm_index)])
-          (*FRAME_RIF (f)->frame_parm_handlers[XFASTINT (parm_index)])
+          && XFIXNAT (parm_index) < ARRAYELTS (frame_parms)
+          && FRAME_RIF (f)->frame_parm_handlers[XFIXNAT (parm_index)])
+          (*FRAME_RIF (f)->frame_parm_handlers[XFIXNAT (parm_index)])
             (f, bgcolor, Qnil);
     }
 
@@ -4415,7 +4415,7 @@ x_set_left_fringe (struct frame *f, Lisp_Object new_value, Lisp_Object old_value
   int new_width;
 
   new_width = (RANGED_FIXNUMP (-INT_MAX, new_value, INT_MAX)
-               ? eabs (XINT (new_value)) : 8);
+               ? eabs (XFIXNUM (new_value)) : 8);
 
   if (new_width != old_width)
     {
@@ -4439,7 +4439,7 @@ x_set_right_fringe (struct frame *f, Lisp_Object new_value, Lisp_Object old_valu
   int new_width;
 
   new_width = (RANGED_FIXNUMP (-INT_MAX, new_value, INT_MAX)
-               ? eabs (XINT (new_value)) : 8);
+               ? eabs (XFIXNUM (new_value)) : 8);
 
   if (new_width != old_width)
     {
@@ -4460,13 +4460,13 @@ x_set_border_width (struct frame *f, Lisp_Object arg, Lisp_Object oldval)
 {
   CHECK_TYPE_RANGED_INTEGER (int, arg);
 
-  if (XINT (arg) == f->border_width)
+  if (XFIXNUM (arg) == f->border_width)
     return;
 
   if (FRAME_X_WINDOW (f) != 0)
     error ("Cannot change the border width of a frame");
 
-  f->border_width = XINT (arg);
+  f->border_width = XFIXNUM (arg);
 }
 
 void
@@ -4474,7 +4474,7 @@ x_set_right_divider_width (struct frame *f, Lisp_Object arg, Lisp_Object oldval)
 {
   int old = FRAME_RIGHT_DIVIDER_WIDTH (f);
   CHECK_TYPE_RANGED_INTEGER (int, arg);
-  int new = max (0, XINT (arg));
+  int new = max (0, XFIXNUM (arg));
   if (new != old)
     {
       f->right_divider_width = new;
@@ -4489,7 +4489,7 @@ x_set_bottom_divider_width (struct frame *f, Lisp_Object arg, Lisp_Object oldval
 {
   int old = FRAME_BOTTOM_DIVIDER_WIDTH (f);
   CHECK_TYPE_RANGED_INTEGER (int, arg);
-  int new = max (0, XINT (arg));
+  int new = max (0, XFIXNUM (arg));
   if (new != old)
     {
       f->bottom_divider_width = new;
@@ -4599,10 +4599,10 @@ x_set_scroll_bar_width (struct frame *f, Lisp_Object arg, Lisp_Object oldval)
       SET_FRAME_GARBAGED (f);
     }
   else if (RANGED_FIXNUMP (1, arg, INT_MAX)
-           && XFASTINT (arg) != FRAME_CONFIG_SCROLL_BAR_WIDTH (f))
+           && XFIXNAT (arg) != FRAME_CONFIG_SCROLL_BAR_WIDTH (f))
     {
-      FRAME_CONFIG_SCROLL_BAR_WIDTH (f) = XFASTINT (arg);
-      FRAME_CONFIG_SCROLL_BAR_COLS (f) = (XFASTINT (arg) + unit - 1) / unit;
+      FRAME_CONFIG_SCROLL_BAR_WIDTH (f) = XFIXNAT (arg);
+      FRAME_CONFIG_SCROLL_BAR_COLS (f) = (XFIXNAT (arg) + unit - 1) / unit;
       if (FRAME_X_WINDOW (f))
         adjust_frame_size (f, -1, -1, 3, 0, Qscroll_bar_width);
 
@@ -4629,10 +4629,10 @@ x_set_scroll_bar_height (struct frame *f, Lisp_Object arg, Lisp_Object oldval)
       SET_FRAME_GARBAGED (f);
     }
   else if (RANGED_FIXNUMP (1, arg, INT_MAX)
-           && XFASTINT (arg) != FRAME_CONFIG_SCROLL_BAR_HEIGHT (f))
+           && XFIXNAT (arg) != FRAME_CONFIG_SCROLL_BAR_HEIGHT (f))
     {
-      FRAME_CONFIG_SCROLL_BAR_HEIGHT (f) = XFASTINT (arg);
-      FRAME_CONFIG_SCROLL_BAR_LINES (f) = (XFASTINT (arg) + unit - 1) / unit;
+      FRAME_CONFIG_SCROLL_BAR_HEIGHT (f) = XFIXNAT (arg);
+      FRAME_CONFIG_SCROLL_BAR_LINES (f) = (XFIXNAT (arg) + unit - 1) / unit;
       if (FRAME_X_WINDOW (f))
         adjust_frame_size (f, -1, -1, 3, 0, Qscroll_bar_height);
 
@@ -4673,7 +4673,7 @@ x_set_alpha (struct frame *f, Lisp_Object arg, Lisp_Object oldval)
         }
       else if (FIXNUMP (item))
         {
-          EMACS_INT ialpha = XINT (item);
+          EMACS_INT ialpha = XFIXNUM (item);
           if (! (0 <= ialpha && ialpha <= 100))
             args_out_of_range (make_fixnum (0), make_fixnum (100));
           alpha = ialpha / 100.0;
@@ -5303,10 +5303,10 @@ x_figure_window_size (struct frame *f, Lisp_Object parms, bool toolbar_p, int *x
                     : DEFAULT_TOOL_BAR_BUTTON_RELIEF);
 
           if (RANGED_FIXNUMP (1, Vtool_bar_button_margin, INT_MAX))
-            margin = XFASTINT (Vtool_bar_button_margin);
+            margin = XFIXNAT (Vtool_bar_button_margin);
           else if (CONSP (Vtool_bar_button_margin)
                    && RANGED_FIXNUMP (1, XCDR (Vtool_bar_button_margin), INT_MAX))
-            margin = XFASTINT (XCDR (Vtool_bar_button_margin));
+            margin = XFIXNAT (XCDR (Vtool_bar_button_margin));
           else
             margin = 0;
 
@@ -5328,12 +5328,12 @@ x_figure_window_size (struct frame *f, Lisp_Object parms, bool toolbar_p, int *x
           if (CONSP (width) && EQ (XCAR (width), Qtext_pixels))
             {
               CHECK_FIXNUM (XCDR (width));
-              if ((XINT (XCDR (width)) < 0 || XINT (XCDR (width)) > INT_MAX))
+              if ((XFIXNUM (XCDR (width)) < 0 || XFIXNUM (XCDR (width)) > INT_MAX))
                 xsignal1 (Qargs_out_of_range, XCDR (width));
 
-              SET_FRAME_WIDTH (f, XINT (XCDR (width)));
+              SET_FRAME_WIDTH (f, XFIXNUM (XCDR (width)));
               f->inhibit_horizontal_resize = true;
-              *x_width = XINT (XCDR (width));
+              *x_width = XFIXNUM (XCDR (width));
             }
           else if (FLOATP (width))
             {
@@ -5353,10 +5353,10 @@ x_figure_window_size (struct frame *f, Lisp_Object parms, bool toolbar_p, int *x
           else
             {
               CHECK_FIXNUM (width);
-              if ((XINT (width) < 0 || XINT (width) > INT_MAX))
+              if ((XFIXNUM (width) < 0 || XFIXNUM (width) > INT_MAX))
                 xsignal1 (Qargs_out_of_range, width);
 
-              SET_FRAME_WIDTH (f, XINT (width) * FRAME_COLUMN_WIDTH (f));
+              SET_FRAME_WIDTH (f, XFIXNUM (width) * FRAME_COLUMN_WIDTH (f));
             }
         }
 
@@ -5365,12 +5365,12 @@ x_figure_window_size (struct frame *f, Lisp_Object parms, bool toolbar_p, int *x
           if (CONSP (height) && EQ (XCAR (height), Qtext_pixels))
             {
               CHECK_FIXNUM (XCDR (height));
-              if ((XINT (XCDR (height)) < 0 || XINT (XCDR (height)) > INT_MAX))
+              if ((XFIXNUM (XCDR (height)) < 0 || XFIXNUM (XCDR (height)) > INT_MAX))
                 xsignal1 (Qargs_out_of_range, XCDR (height));
 
-              SET_FRAME_HEIGHT (f, XINT (XCDR (height)));
+              SET_FRAME_HEIGHT (f, XFIXNUM (XCDR (height)));
               f->inhibit_vertical_resize = true;
-              *x_height = XINT (XCDR (height));
+              *x_height = XFIXNUM (XCDR (height));
             }
           else if (FLOATP (height))
             {
@@ -5390,10 +5390,10 @@ x_figure_window_size (struct frame *f, Lisp_Object parms, bool toolbar_p, int *x
           else
             {
               CHECK_FIXNUM (height);
-              if ((XINT (height) < 0) || (XINT (height) > INT_MAX))
+              if ((XFIXNUM (height) < 0) || (XFIXNUM (height) > INT_MAX))
                 xsignal1 (Qargs_out_of_range, height);
 
-              SET_FRAME_HEIGHT (f, XINT (height) * FRAME_LINE_HEIGHT (f));
+              SET_FRAME_HEIGHT (f, XFIXNUM (height) * FRAME_LINE_HEIGHT (f));
             }
         }
 
@@ -5418,14 +5418,14 @@ x_figure_window_size (struct frame *f, Lisp_Object parms, bool toolbar_p, int *x
                && CONSP (XCDR (top))
                && RANGED_FIXNUMP (-INT_MAX, XCAR (XCDR (top)), INT_MAX))
         {
-          f->top_pos = - XINT (XCAR (XCDR (top)));
+          f->top_pos = - XFIXNUM (XCAR (XCDR (top)));
           window_prompting |= YNegative;
         }
       else if (CONSP (top) && EQ (XCAR (top), Qplus)
                && CONSP (XCDR (top))
                && TYPE_RANGED_FIXNUMP (int, XCAR (XCDR (top))))
         {
-          f->top_pos = XINT (XCAR (XCDR (top)));
+          f->top_pos = XFIXNUM (XCAR (XCDR (top)));
         }
       else if (FLOATP (top))
         f->top_pos = frame_float (f, top, FRAME_FLOAT_TOP, &parent_done,
@@ -5435,7 +5435,7 @@ x_figure_window_size (struct frame *f, Lisp_Object parms, bool toolbar_p, int *x
       else
         {
           CHECK_TYPE_RANGED_INTEGER (int, top);
-          f->top_pos = XINT (top);
+          f->top_pos = XFIXNUM (top);
           if (f->top_pos < 0)
             window_prompting |= YNegative;
         }
@@ -5449,14 +5449,14 @@ x_figure_window_size (struct frame *f, Lisp_Object parms, bool toolbar_p, int *x
                && CONSP (XCDR (left))
                && RANGED_FIXNUMP (-INT_MAX, XCAR (XCDR (left)), INT_MAX))
         {
-          f->left_pos = - XINT (XCAR (XCDR (left)));
+          f->left_pos = - XFIXNUM (XCAR (XCDR (left)));
           window_prompting |= XNegative;
         }
       else if (CONSP (left) && EQ (XCAR (left), Qplus)
                && CONSP (XCDR (left))
                && TYPE_RANGED_FIXNUMP (int, XCAR (XCDR (left))))
         {
-          f->left_pos = XINT (XCAR (XCDR (left)));
+          f->left_pos = XFIXNUM (XCAR (XCDR (left)));
         }
       else if (FLOATP (left))
         f->left_pos = frame_float (f, left, FRAME_FLOAT_LEFT, &parent_done,
@@ -5466,7 +5466,7 @@ x_figure_window_size (struct frame *f, Lisp_Object parms, bool toolbar_p, int *x
       else
         {
           CHECK_TYPE_RANGED_INTEGER (int, left);
-          f->left_pos = XINT (left);
+          f->left_pos = XFIXNUM (left);
           if (f->left_pos < 0)
             window_prompting |= XNegative;
         }
diff --git a/src/frame.h b/src/frame.h
index 03e23027ece..87d0d5a3411 100644
--- a/src/frame.h
+++ b/src/frame.h
@@ -1361,7 +1361,7 @@ FRAME_BOTTOM_DIVIDER_WIDTH (struct frame *f)
    float.  Value is a C integer.  */
 #define FRAME_PIXEL_X_FROM_CANON_X(F, X)                \
   (FIXNUMP (X)                                          \
-   ? XINT (X) * FRAME_COLUMN_WIDTH (F)                  \
+   ? XFIXNUM (X) * FRAME_COLUMN_WIDTH (F)                       \
    : (int) (XFLOAT_DATA (X) * FRAME_COLUMN_WIDTH (F)))
 
 /* Convert canonical value Y to pixels.  F is the frame whose
@@ -1369,7 +1369,7 @@ FRAME_BOTTOM_DIVIDER_WIDTH (struct frame *f)
    or float.  Value is a C integer.  */
 #define FRAME_PIXEL_Y_FROM_CANON_Y(F, Y)                \
   (FIXNUMP (Y)                                          \
-   ? XINT (Y) * FRAME_LINE_HEIGHT (F)                   \
+   ? XFIXNUM (Y) * FRAME_LINE_HEIGHT (F)                        \
    : (int) (XFLOAT_DATA (Y) * FRAME_LINE_HEIGHT (F)))
 
 /* Convert pixel-value X to canonical units.  F is the frame whose
diff --git a/src/fringe.c b/src/fringe.c
index c1784c01b9e..583bba4e510 100644
--- a/src/fringe.c
+++ b/src/fringe.c
@@ -491,7 +491,7 @@ lookup_fringe_bitmap (Lisp_Object bitmap)
   if (!FIXNUMP (bitmap))
     return 0;
 
-  bn = XINT (bitmap);
+  bn = XFIXNUM (bitmap);
   if (bn > NO_FRINGE_BITMAP
       && bn < max_used_fringe_bitmap
       && (bn < MAX_STANDARD_FRINGE_BITMAPS
@@ -743,7 +743,7 @@ get_logical_fringe_bitmap (struct window *w, Lisp_Object bitmap, int right_p, in
             return NO_FRINGE_BITMAP;
           if (CONSP (bm1))
             {
-              ln1 = XINT (Flength (bm1));
+              ln1 = XFIXNUM (Flength (bm1));
               if (partial_p)
                 {
                   if (ln1 > ix2)
@@ -778,7 +778,7 @@ get_logical_fringe_bitmap (struct window *w, Lisp_Object bitmap, int right_p, in
             {
               if (CONSP (bm2))
                 {
-                  ln2 = XINT (Flength (bm2));
+                  ln2 = XFIXNUM (Flength (bm2));
                   if (partial_p)
                     {
                       if (ln2 > ix2)
@@ -1510,7 +1510,7 @@ If BITMAP already exists, the existing definition is replaced.  */)
   else
     {
       CHECK_FIXNUM (height);
-      fb.height = max (0, min (XINT (height), 255));
+      fb.height = max (0, min (XFIXNUM (height), 255));
       if (fb.height > h)
         {
           fill1 = (fb.height - h) / 2;
@@ -1523,7 +1523,7 @@ If BITMAP already exists, the existing definition is replaced.  */)
   else
     {
       CHECK_FIXNUM (width);
-      fb.width = max (0, min (XINT (width), 255));
+      fb.width = max (0, min (XFIXNUM (width), 255));
     }
 
   fb.period = 0;
@@ -1605,7 +1605,7 @@ If BITMAP already exists, the existing definition is replaced.  */)
       for (i = 0; i < h && j < fb.height; i++)
         {
           Lisp_Object elt = Faref (bits, make_fixnum (i));
-          b[j++] = FIXED_OR_FLOATP (elt) ? XINT (elt) : 0;
+          b[j++] = FIXED_OR_FLOATP (elt) ? XFIXNUM (elt) : 0;
         }
       for (i = 0; i < fill2 && j < fb.height; i++)
         b[j++] = 0;
@@ -1662,9 +1662,9 @@ Return nil if POS is not visible in WINDOW.  */)
   if (!NILP (pos))
     {
       CHECK_FIXNUM_COERCE_MARKER (pos);
-      if (! (BEGV <= XINT (pos) && XINT (pos) <= ZV))
+      if (! (BEGV <= XFIXNUM (pos) && XFIXNUM (pos) <= ZV))
         args_out_of_range (window, pos);
-      textpos = XINT (pos);
+      textpos = XFIXNUM (pos);
     }
   else if (w == XWINDOW (selected_window))
     textpos = PT;
diff --git a/src/ftcrfont.c b/src/ftcrfont.c
index 425250e2297..dc1a389c607 100644
--- a/src/ftcrfont.c
+++ b/src/ftcrfont.c
@@ -137,7 +137,7 @@ ftcrfont_open (struct frame *f, Lisp_Object entity, int pixel_size)
   FT_UInt size;
 
   block_input ();
-  size = XINT (AREF (entity, FONT_SIZE_INDEX));
+  size = XFIXNUM (AREF (entity, FONT_SIZE_INDEX));
   if (size == 0)
     size = pixel_size;
   font_object = font_build_object (VECSIZE (struct ftcrfont_info),
diff --git a/src/ftfont.c b/src/ftfont.c
index 741a592c0b1..e83eff3ad08 100644
--- a/src/ftfont.c
+++ b/src/ftfont.c
@@ -390,7 +390,7 @@ ftfont_lookup_cache (Lisp_Object key, enum ftfont_cache_for cache_for)
       ? ! cache_data->ft_face : ! cache_data->fc_charset)
     {
       char *filename = SSDATA (XCAR (key));
-      int idx = XINT (XCDR (key));
+      int idx = XFIXNUM (XCDR (key));
 
       if (cache_for == FTFONT_CACHE_FOR_FACE)
         {
@@ -600,9 +600,9 @@ ftfont_get_open_type_spec (Lisp_Object otf_spec)
         continue;
       len = Flength (val);
       spec->features[i] =
-        (min (PTRDIFF_MAX, SIZE_MAX) / sizeof (int) < XINT (len)
+        (min (PTRDIFF_MAX, SIZE_MAX) / sizeof (int) < XFIXNUM (len)
          ? 0
-         : malloc (XINT (len) * sizeof *spec->features[i]));
+         : malloc (XFIXNUM (len) * sizeof *spec->features[i]));
       if (! spec->features[i])
         {
           if (i > 0 && spec->features[0])
@@ -647,9 +647,9 @@ ftfont_spec_pattern (Lisp_Object spec, char *otlayout, struct OpenTypeSpec **ots
     return NULL;
 
   if (FIXNUMP (AREF (spec, FONT_DPI_INDEX)))
-    dpi = XINT (AREF (spec, FONT_DPI_INDEX));
+    dpi = XFIXNUM (AREF (spec, FONT_DPI_INDEX));
   if (FIXNUMP (AREF (spec, FONT_AVGWIDTH_INDEX))
-      && XINT (AREF (spec, FONT_AVGWIDTH_INDEX)) == 0)
+      && XFIXNUM (AREF (spec, FONT_AVGWIDTH_INDEX)) == 0)
     scalable = 1;
 
   registry = AREF (spec, FONT_REGISTRY_INDEX);
@@ -687,7 +687,7 @@ ftfont_spec_pattern (Lisp_Object spec, char *otlayout, struct OpenTypeSpec **ots
       if (EQ (key, QCdpi))
         {
           if (FIXNUMP (val))
-            dpi = XINT (val);
+            dpi = XFIXNUM (val);
         }
       else if (EQ (key, QClang))
         {
@@ -735,7 +735,7 @@ ftfont_spec_pattern (Lisp_Object spec, char *otlayout, struct OpenTypeSpec **ots
             goto err;
           for (chars = XCDR (chars); CONSP (chars); chars = XCDR (chars))
             if (CHARACTERP (XCAR (chars))
-                && ! FcCharSetAddChar (charset, XFASTINT (XCAR (chars))))
+                && ! FcCharSetAddChar (charset, XFIXNAT (XCAR (chars))))
               goto err;
         }
     }
@@ -833,7 +833,7 @@ ftfont_list (struct frame *f, Lisp_Object spec)
       val = Qnil;
     }
   if (FIXNUMP (AREF (spec, FONT_SPACING_INDEX)))
-    spacing = XINT (AREF (spec, FONT_SPACING_INDEX));
+    spacing = XFIXNUM (AREF (spec, FONT_SPACING_INDEX));
   family = AREF (spec, FONT_FAMILY_INDEX);
   if (! NILP (family))
     {
@@ -956,7 +956,7 @@ ftfont_list (struct frame *f, Lisp_Object spec)
             continue;
           for (j = 0; j < ASIZE (chars); j++)
             if (TYPE_RANGED_FIXNUMP (FcChar32, AREF (chars, j))
-                && FcCharSetHasChar (charset, XFASTINT (AREF (chars, j))))
+                && FcCharSetHasChar (charset, XFIXNAT (AREF (chars, j))))
               break;
           if (j == ASIZE (chars))
             continue;
@@ -1021,7 +1021,7 @@ ftfont_match (struct frame *f, Lisp_Object spec)
       FcValue value;
 
       value.type = FcTypeDouble;
-      value.u.d = XINT (AREF (spec, FONT_SIZE_INDEX));
+      value.u.d = XFIXNUM (AREF (spec, FONT_SIZE_INDEX));
       FcPatternAdd (pattern, FC_PIXEL_SIZE, value, FcFalse);
     }
   if (FcConfigSubstitute (NULL, pattern, FcMatchPattern) == FcTrue)
@@ -1130,7 +1130,7 @@ ftfont_open2 (struct frame *f,
           return Qnil;
         }
     }
-  size = XINT (AREF (entity, FONT_SIZE_INDEX));
+  size = XFIXNUM (AREF (entity, FONT_SIZE_INDEX));
   if (size == 0)
     size = pixel_size;
   if (FT_Set_Pixel_Sizes (ft_face, size, size) != 0)
@@ -1148,7 +1148,7 @@ ftfont_open2 (struct frame *f,
   font = XFONT_OBJECT (font_object);
   ftfont_info = (struct ftfont_info *) font;
   ftfont_info->ft_size = ft_face->size;
-  ftfont_info->index = XINT (idx);
+  ftfont_info->index = XFIXNUM (idx);
 #ifdef HAVE_LIBOTF
   ftfont_info->maybe_otf = (ft_face->face_flags & FT_FACE_FLAG_SFNT) != 0;
   ftfont_info->otf = NULL;
@@ -1161,7 +1161,7 @@ ftfont_open2 (struct frame *f,
 
   upEM = ft_face->units_per_EM;
   scalable = (FIXNUMP (AREF (entity, FONT_AVGWIDTH_INDEX))
-              && XINT (AREF (entity, FONT_AVGWIDTH_INDEX)) == 0);
+              && XFIXNUM (AREF (entity, FONT_AVGWIDTH_INDEX)) == 0);
   if (scalable)
     {
       font->ascent = ft_face->ascender * size / upEM + 0.5;
@@ -1175,7 +1175,7 @@ ftfont_open2 (struct frame *f,
       font->height = ft_face->size->metrics.height >> 6;
     }
   if (FIXNUMP (AREF (entity, FONT_SPACING_INDEX)))
-    spacing = XINT (AREF (entity, FONT_SPACING_INDEX));
+    spacing = XFIXNUM (AREF (entity, FONT_SPACING_INDEX));
   else
     spacing = FC_PROPORTIONAL;
   if (spacing != FC_PROPORTIONAL
@@ -1233,7 +1233,7 @@ ftfont_open (struct frame *f, Lisp_Object entity, int pixel_size)
 {
   Lisp_Object font_object;
   FT_UInt size;
-  size = XINT (AREF (entity, FONT_SIZE_INDEX));
+  size = XFIXNUM (AREF (entity, FONT_SIZE_INDEX));
   if (size == 0)
     size = pixel_size;
   font_object = font_build_object (VECSIZE (struct ftfont_info),
diff --git a/src/gfilenotify.c b/src/gfilenotify.c
index 674ae069f6e..7eea2cfac1c 100644
--- a/src/gfilenotify.c
+++ b/src/gfilenotify.c
@@ -240,7 +240,7 @@ WATCH-DESCRIPTOR should be an object returned by `gfile-add-watch'.  */)
               watch_descriptor);
 
   eassert (FIXNUMP (watch_descriptor));
-  GFileMonitor *monitor = XINTPTR (watch_descriptor);
+  GFileMonitor *monitor = XFIXNUMPTR (watch_descriptor);
   if (!g_file_monitor_is_cancelled (monitor) &&
       !g_file_monitor_cancel (monitor))
       xsignal2 (Qfile_notify_error, build_string ("Could not rm watch"),
@@ -271,7 +271,7 @@ invalid.  */)
     return Qnil;
   else
     {
-      GFileMonitor *monitor = XINTPTR (watch_descriptor);
+      GFileMonitor *monitor = XFIXNUMPTR (watch_descriptor);
       return g_file_monitor_is_cancelled (monitor) ? Qnil : Qt;
     }
 }
@@ -290,7 +290,7 @@ If WATCH-DESCRIPTOR is not valid, nil is returned.  */)
     return Qnil;
   else
     {
-      GFileMonitor *monitor = XINTPTR (watch_descriptor);
+      GFileMonitor *monitor = XFIXNUMPTR (watch_descriptor);
       return intern (G_OBJECT_TYPE_NAME (monitor));
     }
 }
diff --git a/src/gnutls.c b/src/gnutls.c
index 337b3d65cec..111dc612483 100644
--- a/src/gnutls.c
+++ b/src/gnutls.c
@@ -936,7 +936,7 @@ Usage: (gnutls-error-fatalp ERROR)  */)
   if (! TYPE_RANGED_FIXNUMP (int, err))
     error ("Not an error symbol or code");
 
-  if (0 == gnutls_error_is_fatal (XINT (err)))
+  if (0 == gnutls_error_is_fatal (XFIXNUM (err)))
     return Qnil;
 
   return Qt;
@@ -968,7 +968,7 @@ usage: (gnutls-error-string ERROR)  */)
   if (! TYPE_RANGED_FIXNUMP (int, err))
     return build_string ("Not an error symbol or code");
 
-  return build_string (emacs_gnutls_strerror (XINT (err)));
+  return build_string (emacs_gnutls_strerror (XFIXNUM (err)));
 }
 
 DEFUN ("gnutls-deinit", Fgnutls_deinit, Sgnutls_deinit, 1, 1, 0,
@@ -1656,8 +1656,8 @@ one trustfile (usually a CA bundle).  */)
 # ifdef HAVE_GNUTLS3
       gnutls_global_set_audit_log_function (gnutls_audit_log_function);
 # endif
-      gnutls_global_set_log_level (XINT (loglevel));
-      max_log_level = XINT (loglevel);
+      gnutls_global_set_log_level (XFIXNUM (loglevel));
+      max_log_level = XFIXNUM (loglevel);
       XPROCESS (proc)->gnutls_log_level = max_log_level;
     }
 
@@ -1692,7 +1692,7 @@ one trustfile (usually a CA bundle).  */)
       verify_flags = Fplist_get (proplist, QCverify_flags);
       if (TYPE_RANGED_FIXNUMP (unsigned int, verify_flags))
         {
-          gnutls_verify_flags = XFASTINT (verify_flags);
+          gnutls_verify_flags = XFIXNAT (verify_flags);
           GNUTLS_LOG (2, max_log_level, "setting verification flags");
         }
       else if (NILP (verify_flags))
@@ -1852,7 +1852,7 @@ one trustfile (usually a CA bundle).  */)
   GNUTLS_INITSTAGE (proc) = GNUTLS_STAGE_PRIORITY;
 
   if (FIXNUMP (prime_bits))
-    gnutls_dh_set_prime_bits (state, XUINT (prime_bits));
+    gnutls_dh_set_prime_bits (state, XUFIXNUM (prime_bits));
 
   ret = EQ (type, Qgnutls_x509pki)
     ? gnutls_credentials_set (state, GNUTLS_CRD_CERTIFICATE, x509_cred)
@@ -2073,7 +2073,7 @@ gnutls_symmetric (bool encrypting, Lisp_Object cipher,
   if (SYMBOLP (cipher))
     info = XCDR (Fassq (cipher, Fgnutls_ciphers ()));
   else if (TYPE_RANGED_FIXNUMP (gnutls_cipher_algorithm_t, cipher))
-    gca = XINT (cipher);
+    gca = XFIXNUM (cipher);
   else
     info = cipher;
 
@@ -2081,7 +2081,7 @@ gnutls_symmetric (bool encrypting, Lisp_Object cipher,
     {
       Lisp_Object v = Fplist_get (info, QCcipher_id);
       if (TYPE_RANGED_FIXNUMP (gnutls_cipher_algorithm_t, v))
-        gca = XINT (v);
+        gca = XFIXNUM (v);
     }
 
   ptrdiff_t key_size = gnutls_cipher_get_key_size (gca);
@@ -2344,7 +2344,7 @@ itself. */)
   if (SYMBOLP (hash_method))
     info = XCDR (Fassq (hash_method, Fgnutls_macs ()));
   else if (TYPE_RANGED_FIXNUMP (gnutls_mac_algorithm_t, hash_method))
-    gma = XINT (hash_method);
+    gma = XFIXNUM (hash_method);
   else
     info = hash_method;
 
@@ -2352,7 +2352,7 @@ itself. */)
     {
       Lisp_Object v = Fplist_get (info, QCmac_algorithm_id);
       if (TYPE_RANGED_FIXNUMP (gnutls_mac_algorithm_t, v))
-        gma = XINT (v);
+        gma = XFIXNUM (v);
     }
 
   ptrdiff_t digest_length = gnutls_hmac_get_len (gma);
@@ -2425,7 +2425,7 @@ the number itself. */)
   if (SYMBOLP (digest_method))
     info = XCDR (Fassq (digest_method, Fgnutls_digests ()));
   else if (TYPE_RANGED_FIXNUMP (gnutls_digest_algorithm_t, digest_method))
-    gda = XINT (digest_method);
+    gda = XFIXNUM (digest_method);
   else
     info = digest_method;
 
@@ -2433,7 +2433,7 @@ the number itself. */)
     {
       Lisp_Object v = Fplist_get (info, QCdigest_algorithm_id);
       if (TYPE_RANGED_FIXNUMP (gnutls_digest_algorithm_t, v))
-        gda = XINT (v);
+        gda = XFIXNUM (v);
     }
 
   ptrdiff_t digest_length = gnutls_hash_get_len (gda);
diff --git a/src/gtkutil.c b/src/gtkutil.c
index 79b453d2a53..4250355a2f6 100644
--- a/src/gtkutil.c
+++ b/src/gtkutil.c
@@ -4296,7 +4296,7 @@ xg_print_frames_dialog (Lisp_Object frames)
     gtk_print_operation_set_print_settings (print, print_settings);
   if (page_setup != NULL)
     gtk_print_operation_set_default_page_setup (print, page_setup);
-  gtk_print_operation_set_n_pages (print, XINT (Flength (frames)));
+  gtk_print_operation_set_n_pages (print, XFIXNUM (Flength (frames)));
   g_signal_connect (print, "draw-page", G_CALLBACK (draw_page), &frames);
   res = gtk_print_operation_run (print, GTK_PRINT_OPERATION_ACTION_PRINT_DIALOG,
                                  NULL, NULL);
@@ -4891,16 +4891,16 @@ update_frame_tool_bar (struct frame *f)
 
   if (RANGED_FIXNUMP (1, Vtool_bar_button_margin, INT_MAX))
     {
-      hmargin = XFASTINT (Vtool_bar_button_margin);
-      vmargin = XFASTINT (Vtool_bar_button_margin);
+      hmargin = XFIXNAT (Vtool_bar_button_margin);
+      vmargin = XFIXNAT (Vtool_bar_button_margin);
     }
   else if (CONSP (Vtool_bar_button_margin))
     {
       if (RANGED_FIXNUMP (1, XCAR (Vtool_bar_button_margin), INT_MAX))
-        hmargin = XFASTINT (XCAR (Vtool_bar_button_margin));
+        hmargin = XFIXNAT (XCAR (Vtool_bar_button_margin));
 
       if (RANGED_FIXNUMP (1, XCDR (Vtool_bar_button_margin), INT_MAX))
-        vmargin = XFASTINT (XCDR (Vtool_bar_button_margin));
+        vmargin = XFIXNAT (XCDR (Vtool_bar_button_margin));
     }
 
   /* The natural size (i.e. when GTK uses 0 as margin) looks best,
diff --git a/src/image.c b/src/image.c
index 980911e0d16..78eaf8a7598 100644
--- a/src/image.c
+++ b/src/image.c
@@ -785,7 +785,7 @@ parse_image_spec (Lisp_Object spec, struct image_keyword *keywords,
           /* Unlike the other integer-related cases, this one does not
              verify that VALUE fits in 'int'.  This is because callers
              want EMACS_INT.  */
-          if (!FIXNUMP (value) || XINT (value) < 0)
+          if (!FIXNUMP (value) || XFIXNUM (value) < 0)
             return 0;
           break;
 
@@ -1005,8 +1005,8 @@ check_image_size (struct frame *f, int width, int height)
     return 0;
 
   if (FIXNUMP (Vmax_image_size))
-    return (width <= XINT (Vmax_image_size)
-            && height <= XINT (Vmax_image_size));
+    return (width <= XFIXNUM (Vmax_image_size)
+            && height <= XFIXNUM (Vmax_image_size));
   else if (FLOATP (Vmax_image_size))
     {
       if (f != NULL)
@@ -1547,7 +1547,7 @@ clear_image_cache (struct frame *f, Lisp_Object filter)
 
           /* If the number of cached images has grown unusually large,
              decrease the cache eviction delay (Bug#6230).  */
-          delay = XINT (Vimage_cache_eviction_delay);
+          delay = XFIXNUM (Vimage_cache_eviction_delay);
           if (nimages > 40)
             delay = 1600 * delay / nimages / nimages;
           delay = max (delay, 1);
@@ -1762,10 +1762,10 @@ lookup_image (struct frame *f, Lisp_Object spec)
 
           value = image_spec_value (spec, QCwidth, NULL);
           img->width = (FIXNUMP (value)
-                        ? XFASTINT (value) : DEFAULT_IMAGE_WIDTH);
+                        ? XFIXNAT (value) : DEFAULT_IMAGE_WIDTH);
           value = image_spec_value (spec, QCheight, NULL);
           img->height = (FIXNUMP (value)
-                         ? XFASTINT (value) : DEFAULT_IMAGE_HEIGHT);
+                         ? XFIXNAT (value) : DEFAULT_IMAGE_HEIGHT);
         }
       else
         {
@@ -1777,24 +1777,24 @@ lookup_image (struct frame *f, Lisp_Object spec)
 
           ascent = image_spec_value (spec, QCascent, NULL);
           if (FIXNUMP (ascent))
-            img->ascent = XFASTINT (ascent);
+            img->ascent = XFIXNAT (ascent);
           else if (EQ (ascent, Qcenter))
             img->ascent = CENTERED_IMAGE_ASCENT;
 
           margin = image_spec_value (spec, QCmargin, NULL);
           if (FIXNUMP (margin))
-            img->vmargin = img->hmargin = XFASTINT (margin);
+            img->vmargin = img->hmargin = XFIXNAT (margin);
           else if (CONSP (margin))
             {
-              img->hmargin = XFASTINT (XCAR (margin));
-              img->vmargin = XFASTINT (XCDR (margin));
+              img->hmargin = XFIXNAT (XCAR (margin));
+              img->vmargin = XFIXNAT (XCDR (margin));
             }
 
           relief = image_spec_value (spec, QCrelief, NULL);
           relief_bound = INT_MAX - max (img->hmargin, img->vmargin);
           if (RANGED_FIXNUMP (- relief_bound, relief, relief_bound))
             {
-              img->relief = XINT (relief);
+              img->relief = XFIXNUM (relief);
               img->hmargin += eabs (img->relief);
               img->vmargin += eabs (img->relief);
             }
@@ -2512,8 +2512,8 @@ xbm_image_p (Lisp_Object object)
         return 0;
 
       data = kw[XBM_DATA].value;
-      width = XFASTINT (kw[XBM_WIDTH].value);
-      height = XFASTINT (kw[XBM_HEIGHT].value);
+      width = XFIXNAT (kw[XBM_WIDTH].value);
+      height = XFIXNAT (kw[XBM_HEIGHT].value);
 
       /* Check type of data, and width and height against contents of
          data.  */
@@ -3061,8 +3061,8 @@ xbm_load (struct frame *f, struct image *img)
       /* Get specified width, and height.  */
       if (!in_memory_file_p)
         {
-          img->width = XFASTINT (fmt[XBM_WIDTH].value);
-          img->height = XFASTINT (fmt[XBM_HEIGHT].value);
+          img->width = XFIXNAT (fmt[XBM_WIDTH].value);
+          img->height = XFIXNAT (fmt[XBM_HEIGHT].value);
           eassert (img->width > 0 && img->height > 0);
           if (!check_image_size (f, img->width, img->height))
             {
@@ -4168,7 +4168,7 @@ xpm_load_image (struct frame *f,
   if (!NILP (Fxw_display_color_p (frame)))
     best_key = XPM_COLOR_KEY_C;
   else if (!NILP (Fx_display_grayscale_p (frame)))
-    best_key = (XFASTINT (Fx_display_planes (frame)) > 2
+    best_key = (XFIXNAT (Fx_display_planes (frame)) > 2
                 ? XPM_COLOR_KEY_G : XPM_COLOR_KEY_G4);
   else
     best_key = XPM_COLOR_KEY_M;
@@ -4267,7 +4267,7 @@ xpm_load_image (struct frame *f,
             (*get_color_table) (color_table, str, chars_per_pixel);
 
           XPutPixel (ximg, x, y,
-                     (FIXNUMP (color_val) ? XINT (color_val)
+                     (FIXNUMP (color_val) ? XFIXNUM (color_val)
                       : FRAME_FOREGROUND_PIXEL (f)));
 #ifndef HAVE_NS
           XPutPixel (mask_img, x, y,
@@ -5095,7 +5095,7 @@ x_build_heuristic_mask (struct frame *f, struct image *img, Lisp_Object how)
 
       for (i = 0; i < 3 && CONSP (how) && FIXNATP (XCAR (how)); ++i)
         {
-          rgb[i] = XFASTINT (XCAR (how)) & 0xffff;
+          rgb[i] = XFIXNAT (XCAR (how)) & 0xffff;
           how = XCDR (how);
         }
 
@@ -7282,7 +7282,7 @@ tiff_load (struct frame *f, struct image *img)
   image = image_spec_value (img->spec, QCindex, NULL);
   if (FIXNUMP (image))
     {
-      EMACS_INT ino = XFASTINT (image);
+      EMACS_INT ino = XFIXNAT (image);
       if (! (TYPE_MINIMUM (tdir_t) <= ino && ino <= TYPE_MAXIMUM (tdir_t)
              && TIFFSetDirectory (tiff, ino)))
         {
@@ -7746,7 +7746,7 @@ gif_load (struct frame *f, struct image *img)
   /* Which sub-image are we to display?  */
   {
     Lisp_Object image_number = image_spec_value (img->spec, QCindex, NULL);
-    idx = FIXNUMP (image_number) ? XFASTINT (image_number) : 0;
+    idx = FIXNUMP (image_number) ? XFIXNAT (image_number) : 0;
     if (idx < 0 || idx >= gif->ImageCount)
       {
         image_error ("Invalid image number `%s' in image `%s'",
@@ -8107,11 +8107,11 @@ compute_image_size (size_t width, size_t height,
 
   value = image_spec_value (spec, QCmax_width, NULL);
   if (FIXNATP (value))
-    max_width = min (XFASTINT (value), INT_MAX);
+    max_width = min (XFIXNAT (value), INT_MAX);
 
   value = image_spec_value (spec, QCmax_height, NULL);
   if (FIXNATP (value))
-    max_height = min (XFASTINT (value), INT_MAX);
+    max_height = min (XFIXNAT (value), INT_MAX);
 
   /* If width and/or height is set in the display spec assume we want
      to scale to those values.  If either h or w is unspecified, the
@@ -8120,7 +8120,7 @@ compute_image_size (size_t width, size_t height,
   value = image_spec_value (spec, QCwidth, NULL);
   if (FIXNATP (value))
     {
-      desired_width = min (XFASTINT (value) * scale, INT_MAX);
+      desired_width = min (XFIXNAT (value) * scale, INT_MAX);
       /* :width overrides :max-width. */
       max_width = -1;
     }
@@ -8128,7 +8128,7 @@ compute_image_size (size_t width, size_t height,
   value = image_spec_value (spec, QCheight, NULL);
   if (FIXNATP (value))
     {
-      desired_height = min (XFASTINT (value) * scale, INT_MAX);
+      desired_height = min (XFIXNAT (value) * scale, INT_MAX);
       /* :height overrides :max-height. */
       max_height = -1;
     }
@@ -8573,7 +8573,7 @@ imagemagick_load_image (struct frame *f, struct image *img,
      find out things about it.  */
 
   image = image_spec_value (img->spec, QCindex, NULL);
-  ino = FIXNUMP (image) ? XFASTINT (image) : 0;
+  ino = FIXNUMP (image) ? XFIXNAT (image) : 0;
   image_wand = NewMagickWand ();
 
   if (filename)
@@ -8585,7 +8585,7 @@ imagemagick_load_image (struct frame *f, struct image *img,
 
       if (FIXNATP (lwidth) && FIXNATP (lheight))
         {
-          MagickSetSize (image_wand, XFASTINT (lwidth), XFASTINT (lheight));
+          MagickSetSize (image_wand, XFIXNAT (lwidth), XFIXNAT (lheight));
           MagickSetDepth (image_wand, 8);
         }
       filename_hint = imagemagick_filename_hint (img->spec, hint_buffer);
@@ -8685,19 +8685,19 @@ imagemagick_load_image (struct frame *f, struct image *img,
          than the alternatives, but it still reads the entire image into memory
          before cropping, which is apparently difficult to avoid when using
          imagemagick.  */
-      size_t crop_width = XINT (XCAR (crop));
+      size_t crop_width = XFIXNUM (XCAR (crop));
       crop = XCDR (crop);
       if (CONSP (crop) && TYPE_RANGED_FIXNUMP (size_t, XCAR (crop)))
         {
-          size_t crop_height = XINT (XCAR (crop));
+          size_t crop_height = XFIXNUM (XCAR (crop));
           crop = XCDR (crop);
           if (CONSP (crop) && TYPE_RANGED_FIXNUMP (ssize_t, XCAR (crop)))
             {
-              ssize_t crop_x = XINT (XCAR (crop));
+              ssize_t crop_x = XFIXNUM (XCAR (crop));
               crop = XCDR (crop);
               if (CONSP (crop) && TYPE_RANGED_FIXNUMP (ssize_t, XCAR (crop)))
                 {
-                  ssize_t crop_y = XINT (XCAR (crop));
+                  ssize_t crop_y = XFIXNUM (XCAR (crop));
                   MagickCropImage (image_wand, crop_width, crop_height,
                                    crop_x, crop_y);
                 }
@@ -9589,10 +9589,10 @@ gs_load (struct frame *f, struct image *img)
      = 1/72 in, xdpi and ydpi are stored in the frame's X display
      info.  */
   pt_width = image_spec_value (img->spec, QCpt_width, NULL);
-  in_width = FIXNUMP (pt_width) ? XFASTINT (pt_width) / 72.0 : 0;
+  in_width = FIXNUMP (pt_width) ? XFIXNAT (pt_width) / 72.0 : 0;
   in_width *= FRAME_RES_X (f);
   pt_height = image_spec_value (img->spec, QCpt_height, NULL);
-  in_height = FIXNUMP (pt_height) ? XFASTINT (pt_height) / 72.0 : 0;
+  in_height = FIXNUMP (pt_height) ? XFIXNAT (pt_height) / 72.0 : 0;
   in_height *= FRAME_RES_Y (f);
 
   if (! (in_width <= INT_MAX && in_height <= INT_MAX
diff --git a/src/indent.c b/src/indent.c
index fd505bceebc..18855768d37 100644
--- a/src/indent.c
+++ b/src/indent.c
@@ -116,7 +116,7 @@ disptab_matches_widthtab (struct Lisp_Char_Table *disptab, struct Lisp_Vector *w
 
   for (i = 0; i < 256; i++)
     if (character_width (i, disptab)
-        != XFASTINT (widthtab->contents[i]))
+        != XFIXNAT (widthtab->contents[i]))
       return 0;
 
   return 1;
@@ -235,24 +235,24 @@ skip_invisible (ptrdiff_t pos, ptrdiff_t *next_boundary_p, ptrdiff_t to, Lisp_Ob
   /* As for text properties, this gives a lower bound
      for where the invisible text property could change.  */
   proplimit = Fnext_property_change (position, buffer, Qt);
-  if (XFASTINT (overlay_limit) < XFASTINT (proplimit))
+  if (XFIXNAT (overlay_limit) < XFIXNAT (proplimit))
     proplimit = overlay_limit;
   /* PROPLIMIT is now a lower bound for the next change
      in invisible status.  If that is plenty far away,
      use that lower bound.  */
-  if (XFASTINT (proplimit) > pos + 100 || XFASTINT (proplimit) >= to)
-    *next_boundary_p = XFASTINT (proplimit);
+  if (XFIXNAT (proplimit) > pos + 100 || XFIXNAT (proplimit) >= to)
+    *next_boundary_p = XFIXNAT (proplimit);
   /* Otherwise, scan for the next `invisible' property change.  */
   else
     {
       /* Don't scan terribly far.  */
       XSETFASTINT (proplimit, min (pos + 100, to));
       /* No matter what, don't go past next overlay change.  */
-      if (XFASTINT (overlay_limit) < XFASTINT (proplimit))
+      if (XFIXNAT (overlay_limit) < XFIXNAT (proplimit))
         proplimit = overlay_limit;
       tmp = Fnext_single_property_change (position, Qinvisible,
                                           buffer, proplimit);
-      end = XFASTINT (tmp);
+      end = XFIXNAT (tmp);
 #if 0
       /* Don't put the boundary in the middle of multibyte form if
          there is no actual property change.  */
@@ -486,13 +486,13 @@ check_display_width (ptrdiff_t pos, ptrdiff_t col, ptrdiff_t *endpos)
            RANGED_FIXNUMP (0, prop, INT_MAX))
           || (prop = Fplist_get (plist, QCrelative_width),
               RANGED_FIXNUMP (0, prop, INT_MAX)))
-        width = XINT (prop);
+        width = XFIXNUM (prop);
       else if (FLOATP (prop) && 0 <= XFLOAT_DATA (prop)
                && XFLOAT_DATA (prop) <= INT_MAX)
         width = (int)(XFLOAT_DATA (prop) + 0.5);
       else if ((prop = Fplist_get (plist, QCalign_to),
                 RANGED_FIXNUMP (col, prop, align_to_max)))
-        width = XINT (prop) - col;
+        width = XFIXNUM (prop) - col;
       else if (FLOATP (prop) && col <= XFLOAT_DATA (prop)
                && (XFLOAT_DATA (prop) <= align_to_max))
         width = (int)(XFLOAT_DATA (prop) + 0.5) - col;
@@ -752,7 +752,7 @@ string_display_width (Lisp_Object string, Lisp_Object beg, Lisp_Object end)
   else
     {
       CHECK_FIXNUM (end);
-      e = XINT (end);
+      e = XFIXNUM (end);
     }
 
   if (NILP (beg))
@@ -760,7 +760,7 @@ string_display_width (Lisp_Object string, Lisp_Object beg, Lisp_Object end)
   else
     {
       CHECK_FIXNUM (beg);
-      b = XINT (beg);
+      b = XFIXNUM (beg);
     }
 
   /* Make a pointer for decrementing through the chars before point.  */
@@ -826,8 +826,8 @@ The return value is the column where the insertion ends.  */)
   CHECK_FIXNUM (minimum);
 
   fromcol = current_column ();
-  mincol = fromcol + XINT (minimum);
-  if (mincol < XINT (column)) mincol = XINT (column);
+  mincol = fromcol + XFIXNUM (minimum);
+  if (mincol < XFIXNUM (column)) mincol = XFIXNUM (column);
 
   if (fromcol == mincol)
     return make_fixnum (mincol);
@@ -836,7 +836,7 @@ The return value is the column where the insertion ends.  */)
     {
       Lisp_Object n;
       XSETFASTINT (n, mincol / tab_width - fromcol / tab_width);
-      if (XFASTINT (n) != 0)
+      if (XFIXNAT (n) != 0)
         {
           Finsert_char (make_fixnum ('\t'), n, Qt);
 
@@ -995,7 +995,7 @@ The return value is the current column.  */)
   EMACS_INT goal;
 
   CHECK_FIXNAT (column);
-  goal = XINT (column);
+  goal = XFIXNUM (column);
 
   col = goal;
   pos = ZV;
@@ -1129,7 +1129,7 @@ compute_motion (ptrdiff_t from, ptrdiff_t frombyte, EMACS_INT fromvpos,
   struct Lisp_Char_Table *dp = window_display_table (win);
   EMACS_INT selective
     = (FIXNUMP (BVAR (current_buffer, selective_display))
-       ? XINT (BVAR (current_buffer, selective_display))
+       ? XFIXNUM (BVAR (current_buffer, selective_display))
        : !NILP (BVAR (current_buffer, selective_display)) ? -1 : 0);
   ptrdiff_t selective_rlen
     = (selective && dp && VECTORP (DISP_INVIS_VECTOR (dp))
@@ -1340,7 +1340,7 @@ compute_motion (ptrdiff_t from, ptrdiff_t frombyte, EMACS_INT fromvpos,
             {
               if (FIXNUMP (Vtruncate_partial_width_windows))
                 truncate
-                  = total_width < XFASTINT (Vtruncate_partial_width_windows);
+                  = total_width < XFIXNAT (Vtruncate_partial_width_windows);
               else
                 truncate = 1;
             }
@@ -1533,7 +1533,7 @@ compute_motion (ptrdiff_t from, ptrdiff_t frombyte, EMACS_INT fromvpos,
               /* Is this character part of the current run?  If so, extend
                  the run.  */
               if (pos - 1 == width_run_end
-                  && XFASTINT (width_table[c]) == width_run_width)
+                  && XFIXNAT (width_table[c]) == width_run_width)
                 width_run_end = pos;
 
               /* The previous run is over, since this is a character at a
@@ -1548,7 +1548,7 @@ compute_motion (ptrdiff_t from, ptrdiff_t frombyte, EMACS_INT fromvpos,
                                        width_run_start, width_run_end);
 
                   /* Start recording a new width run.  */
-                  width_run_width = XFASTINT (width_table[c]);
+                  width_run_width = XFIXNAT (width_table[c]);
                   width_run_start = pos - 1;
                   width_run_end = pos;
                 }
@@ -1773,29 +1773,29 @@ visible section of the buffer, and pass LINE and COL as TOPOS.  */)
       CHECK_CONS (offsets);
       CHECK_FIXNUM_CAR (offsets);
       CHECK_FIXNUM_CDR (offsets);
-      if (! (0 <= XINT (XCAR (offsets)) && XINT (XCAR (offsets)) <= PTRDIFF_MAX
-             && 0 <= XINT (XCDR (offsets)) && XINT (XCDR (offsets)) <= INT_MAX))
+      if (! (0 <= XFIXNUM (XCAR (offsets)) && XFIXNUM (XCAR (offsets)) <= PTRDIFF_MAX
+             && 0 <= XFIXNUM (XCDR (offsets)) && XFIXNUM (XCDR (offsets)) <= INT_MAX))
         args_out_of_range (XCAR (offsets), XCDR (offsets));
-      hscroll = XINT (XCAR (offsets));
-      tab_offset = XINT (XCDR (offsets));
+      hscroll = XFIXNUM (XCAR (offsets));
+      tab_offset = XFIXNUM (XCDR (offsets));
     }
   else
     hscroll = tab_offset = 0;
 
   w = decode_live_window (window);
 
-  if (XINT (from) < BEGV || XINT (from) > ZV)
+  if (XFIXNUM (from) < BEGV || XFIXNUM (from) > ZV)
     args_out_of_range_3 (from, make_fixnum (BEGV), make_fixnum (ZV));
-  if (XINT (to) < BEGV || XINT (to) > ZV)
+  if (XFIXNUM (to) < BEGV || XFIXNUM (to) > ZV)
     args_out_of_range_3 (to, make_fixnum (BEGV), make_fixnum (ZV));
 
-  pos = compute_motion (XINT (from), CHAR_TO_BYTE (XINT (from)),
-                        XINT (XCDR (frompos)),
-                        XINT (XCAR (frompos)), 0,
-                        XINT (to),
+  pos = compute_motion (XFIXNUM (from), CHAR_TO_BYTE (XFIXNUM (from)),
+                        XFIXNUM (XCDR (frompos)),
+                        XFIXNUM (XCAR (frompos)), 0,
+                        XFIXNUM (to),
                         (NILP (topos)
                          ? window_internal_height (w)
-                         : XINT (XCDR (topos))),
+                         : XFIXNUM (XCDR (topos))),
                         (NILP (topos)
                          ? (window_body_width (w, 0)
                             - (
@@ -1803,8 +1803,8 @@ visible section of the buffer, and pass LINE and COL as TOPOS.  */)
                                FRAME_WINDOW_P (XFRAME (w->frame)) ? 0 :
 #endif
                                1))
-                         : XINT (XCAR (topos))),
-                        (NILP (width) ? -1 : XINT (width)),
+                         : XFIXNUM (XCAR (topos))),
+                        (NILP (width) ? -1 : XFIXNUM (width)),
                         hscroll, tab_offset, w);
 
   XSETFASTINT (bufpos, pos->bufpos);
@@ -1832,7 +1832,7 @@ vmotion (register ptrdiff_t from, register ptrdiff_t from_byte,
   ptrdiff_t lmargin = hscroll > 0 ? 1 - hscroll : 0;
   ptrdiff_t selective
     = (FIXNUMP (BVAR (current_buffer, selective_display))
-       ? clip_to_bounds (-1, XINT (BVAR (current_buffer, selective_display)),
+       ? clip_to_bounds (-1, XFIXNUM (BVAR (current_buffer, selective_display)),
                          PTRDIFF_MAX)
        : !NILP (BVAR (current_buffer, selective_display)) ? -1 : 0);
   Lisp_Object window;
@@ -2045,8 +2045,8 @@ restore_window_buffer (Lisp_Object list)
   wset_buffer (w, XCAR (list));
   list = XCDR (list);
   set_marker_both (w->pointm, w->contents,
-                   XFASTINT (XCAR (list)),
-                   XFASTINT (XCAR (XCDR (list))));
+                   XFIXNAT (XCAR (list)),
+                   XFIXNAT (XCAR (XCDR (list))));
 }
 
 DEFUN ("vertical-motion", Fvertical_motion, Svertical_motion, 1, 3, 0,
@@ -2118,7 +2118,7 @@ whether or not it is currently displayed in some window.  */)
   if (noninteractive)
     {
       struct position pos;
-      pos = *vmotion (PT, PT_BYTE, XINT (lines), w);
+      pos = *vmotion (PT, PT_BYTE, XFIXNUM (lines), w);
       SET_PT_BOTH (pos.bufpos, pos.bytepos);
       it.vpos = pos.vpos;
     }
@@ -2128,7 +2128,7 @@ whether or not it is currently displayed in some window.  */)
       int first_x;
       bool overshoot_handled = 0;
       bool disp_string_at_start_p = 0;
-      ptrdiff_t nlines = XINT (lines);
+      ptrdiff_t nlines = XFIXNUM (lines);
       int vpos_init = 0;
       double start_col UNINIT;
       int start_x UNINIT;
diff --git a/src/insdel.c b/src/insdel.c
index a365b95fc18..70cebc0d2cc 100644
--- a/src/insdel.c
+++ b/src/insdel.c
@@ -2287,17 +2287,17 @@ DEFUN ("combine-after-change-execute", Fcombine_after_change_execute,
       elt = XCAR (tail);
       if (! CONSP (elt))
         continue;
-      thisbeg = XINT (XCAR (elt));
+      thisbeg = XFIXNUM (XCAR (elt));
 
       elt = XCDR (elt);
       if (! CONSP (elt))
         continue;
-      thisend = XINT (XCAR (elt));
+      thisend = XFIXNUM (XCAR (elt));
 
       elt = XCDR (elt);
       if (! CONSP (elt))
         continue;
-      thischange = XINT (XCAR (elt));
+      thischange = XFIXNUM (XCAR (elt));
 
       /* Merge this range into the accumulated range.  */
       change += thischange;
diff --git a/src/intervals.c b/src/intervals.c
index 90ec4bd0537..af27afea0dc 100644
--- a/src/intervals.c
+++ b/src/intervals.c
@@ -1926,8 +1926,8 @@ set_point_both (ptrdiff_t charpos, ptrdiff_t bytepos)
 
           if (! NILP (intangible_propval))
             {
-              while (XINT (pos) > BEGV
-                     && EQ (Fget_char_property (make_fixnum (XINT (pos) - 1),
+              while (XFIXNUM (pos) > BEGV
+                     && EQ (Fget_char_property (make_fixnum (XFIXNUM (pos) - 1),
                                                 Qintangible, Qnil),
                             intangible_propval))
                 pos = Fprevious_char_property_change (pos, Qnil);
@@ -1937,7 +1937,7 @@ set_point_both (ptrdiff_t charpos, ptrdiff_t bytepos)
                  property is `front-sticky', perturb it to be one character
                  earlier -- this ensures that point can never move to the
                  beginning of an invisible/intangible/front-sticky region.  */
-              charpos = adjust_for_invis_intang (XINT (pos), 0, -1, 0);
+              charpos = adjust_for_invis_intang (XFIXNUM (pos), 0, -1, 0);
             }
         }
       else
@@ -1959,7 +1959,7 @@ set_point_both (ptrdiff_t charpos, ptrdiff_t bytepos)
 
           if (! NILP (intangible_propval))
             {
-              while (XINT (pos) < ZV
+              while (XFIXNUM (pos) < ZV
                      && EQ (Fget_char_property (pos, Qintangible, Qnil),
                             intangible_propval))
                 pos = Fnext_char_property_change (pos, Qnil);
@@ -1969,7 +1969,7 @@ set_point_both (ptrdiff_t charpos, ptrdiff_t bytepos)
                  property is `rear-sticky', perturb it to be one character
                  later -- this ensures that point can never move to the
                  end of an invisible/intangible/rear-sticky region.  */
-              charpos = adjust_for_invis_intang (XINT (pos), -1, 1, 0);
+              charpos = adjust_for_invis_intang (XFIXNUM (pos), -1, 1, 0);
             }
         }
 
@@ -2055,7 +2055,7 @@ move_if_not_intangible (ptrdiff_t position)
   if (! NILP (Vinhibit_point_motion_hooks))
     /* If intangible is inhibited, always move point to POSITION.  */
     ;
-  else if (PT < position && XINT (pos) < ZV)
+  else if (PT < position && XFIXNUM (pos) < ZV)
     {
       /* We want to move forward, so check the text before POSITION.  */
 
@@ -2065,23 +2065,23 @@ move_if_not_intangible (ptrdiff_t position)
       /* If following char is intangible,
          skip back over all chars with matching intangible property.  */
       if (! NILP (intangible_propval))
-        while (XINT (pos) > BEGV
-               && EQ (Fget_char_property (make_fixnum (XINT (pos) - 1),
+        while (XFIXNUM (pos) > BEGV
+               && EQ (Fget_char_property (make_fixnum (XFIXNUM (pos) - 1),
                                           Qintangible, Qnil),
                       intangible_propval))
           pos = Fprevious_char_property_change (pos, Qnil);
     }
-  else if (XINT (pos) > BEGV)
+  else if (XFIXNUM (pos) > BEGV)
     {
       /* We want to move backward, so check the text after POSITION.  */
 
-      intangible_propval = Fget_char_property (make_fixnum (XINT (pos) - 1),
+      intangible_propval = Fget_char_property (make_fixnum (XFIXNUM (pos) - 1),
                                                Qintangible, Qnil);
 
       /* If following char is intangible,
          skip forward over all chars with matching intangible property.  */
       if (! NILP (intangible_propval))
-        while (XINT (pos) < ZV
+        while (XFIXNUM (pos) < ZV
                && EQ (Fget_char_property (pos, Qintangible, Qnil),
                       intangible_propval))
           pos = Fnext_char_property_change (pos, Qnil);
@@ -2096,7 +2096,7 @@ move_if_not_intangible (ptrdiff_t position)
      try moving to POSITION (which means we actually move farther
      if POSITION is inside of intangible text).  */
 
-  if (XINT (pos) != PT)
+  if (XFIXNUM (pos) != PT)
     SET_PT (position);
 }
 
diff --git a/src/json.c b/src/json.c
index da6e34d89c1..17edb4140e0 100644
--- a/src/json.c
+++ b/src/json.c
@@ -485,7 +485,7 @@ lisp_to_json (Lisp_Object lisp, struct json_configuration *conf)
   else if (FIXNUMP (lisp))
     {
       CHECK_TYPE_RANGED_INTEGER (json_int_t, lisp);
-      return json_check (json_integer (XINT (lisp)));
+      return json_check (json_integer (XFIXNUM (lisp)));
     }
   else if (FLOATP (lisp))
     return json_check (json_real (XFLOAT_DATA (lisp)));
diff --git a/src/keyboard.c b/src/keyboard.c
index 25864b5b5f5..4c8807d6801 100644
--- a/src/keyboard.c
+++ b/src/keyboard.c
@@ -441,7 +441,7 @@ static bool
 echo_keystrokes_p (void)
 {
   return (FLOATP (Vecho_keystrokes) ? XFLOAT_DATA (Vecho_keystrokes) > 0.0
-          : FIXNUMP (Vecho_keystrokes) ? XINT (Vecho_keystrokes) > 0
+          : FIXNUMP (Vecho_keystrokes) ? XFIXNUM (Vecho_keystrokes) > 0
           : false);
 }
 
@@ -467,7 +467,7 @@ echo_add_key (Lisp_Object c)
   c = EVENT_HEAD (c);
 
   if (FIXNUMP (c))
-    ptr = push_key_description (XINT (c), ptr);
+    ptr = push_key_description (XFIXNUM (c), ptr);
   else if (SYMBOLP (c))
     {
       Lisp_Object name = SYMBOL_NAME (c);
@@ -541,7 +541,7 @@ echo_dash (void)
       idx = make_fixnum (SCHARS (KVAR (current_kboard, echo_string)) - 1);
       last_char = Faref (KVAR (current_kboard, echo_string), idx);
 
-      if (XINT (last_char) == '-' && XINT (prev_char) != ' ')
+      if (XFIXNUM (last_char) == '-' && XFIXNUM (prev_char) != ' ')
         return;
     }
 
@@ -1525,7 +1525,7 @@ command_loop_1 (void)
                 {
                   Lisp_Object txt
                     = call1 (Fsymbol_value (Qregion_extract_function), Qnil);
-                  if (XINT (Flength (txt)) > 0)
+                  if (XFIXNUM (Flength (txt)) > 0)
                     /* Don't set empty selections.  */
                     call2 (Qgui_set_selection, QPRIMARY, txt);
                 }
@@ -1677,7 +1677,7 @@ adjust_point_for_property (ptrdiff_t last_pt, bool modified)
                         || !NILP (Foverlay_get (overlay, Qbefore_string))));
               tmp = Fnext_single_char_property_change
                 (make_fixnum (end), Qinvisible, Qnil, Qnil);
-              end = FIXNATP (tmp) ? XFASTINT (tmp) : ZV;
+              end = FIXNATP (tmp) ? XFIXNAT (tmp) : ZV;
             }
           while (beg > BEGV
 #if 0
@@ -1695,7 +1695,7 @@ adjust_point_for_property (ptrdiff_t last_pt, bool modified)
                         || !NILP (Foverlay_get (overlay, Qbefore_string))));
               tmp = Fprevious_single_char_property_change
                 (make_fixnum (beg), Qinvisible, Qnil, Qnil);
-              beg = FIXNATP (tmp) ? XFASTINT (tmp) : BEGV;
+              beg = FIXNATP (tmp) ? XFIXNAT (tmp) : BEGV;
             }
 
           /* Move away from the inside area.  */
@@ -2145,7 +2145,7 @@ read_event_from_main_queue (struct timespec *end_time,
     }
 
   /* Terminate Emacs in batch mode if at eof.  */
-  if (noninteractive && FIXNUMP (c) && XINT (c) < 0)
+  if (noninteractive && FIXNUMP (c) && XFIXNUM (c) < 0)
     Fkill_emacs (make_fixnum (1));
 
   if (FIXNUMP (c))
@@ -2154,12 +2154,12 @@ read_event_from_main_queue (struct timespec *end_time,
       if ((extra_keyboard_modifiers & CHAR_CTL)
           || ((extra_keyboard_modifiers & 0177) < ' '
               && (extra_keyboard_modifiers & 0177) != 0))
-        XSETINT (c, make_ctrl_char (XINT (c)));
+        XSETINT (c, make_ctrl_char (XFIXNUM (c)));
 
       /* Transfer any other modifier bits directly from
          extra_keyboard_modifiers to c.  Ignore the actual character code
          in the low 16 bits of extra_keyboard_modifiers.  */
-      XSETINT (c, XINT (c) | (extra_keyboard_modifiers & ~0xff7f & ~CHAR_CTL));
+      XSETINT (c, XFIXNUM (c) | (extra_keyboard_modifiers & ~0xff7f & ~CHAR_CTL));
     }
 
   return c;
@@ -2208,7 +2208,7 @@ read_decoded_event_from_main_queue (struct timespec *end_time,
           eassert (n < MAX_ENCODED_BYTES);
           events[n++] = nextevt;
           if (FIXNATP (nextevt)
-              && XINT (nextevt) < (meta_key == 1 ? 0x80 : 0x100))
+              && XFIXNUM (nextevt) < (meta_key == 1 ? 0x80 : 0x100))
             { /* An encoded byte sequence, let's try to decode it.  */
               struct coding_system *coding
                 = TERMINAL_KEYBOARD_CODING (terminal);
@@ -2218,7 +2218,7 @@ read_decoded_event_from_main_queue (struct timespec *end_time,
                   int i;
                   if (meta_key != 2)
                     for (i = 0; i < n; i++)
-                      events[i] = make_fixnum (XINT (events[i]) & ~0x80);
+                      events[i] = make_fixnum (XFIXNUM (events[i]) & ~0x80);
                 }
               else
                 {
@@ -2226,7 +2226,7 @@ read_decoded_event_from_main_queue (struct timespec *end_time,
                   unsigned char dest[MAX_ENCODED_BYTES * MAX_MULTIBYTE_LENGTH];
                   int i;
                   for (i = 0; i < n; i++)
-                    src[i] = XINT (events[i]);
+                    src[i] = XFIXNUM (events[i]);
                   if (meta_key != 2)
                     for (i = 0; i < n; i++)
                       src[i] &= ~0x80;
@@ -2403,7 +2403,7 @@ read_char (int commandflag, Lisp_Object map,
          Also, some things replace the macro with t
          to force an early exit.  */
       if (EQ (Vexecuting_kbd_macro, Qt)
-          || executing_kbd_macro_index >= XFASTINT (Flength (Vexecuting_kbd_macro)))
+          || executing_kbd_macro_index >= XFIXNAT (Flength (Vexecuting_kbd_macro)))
         {
           XSETINT (c, -1);
           goto exit;
@@ -2411,8 +2411,8 @@ read_char (int commandflag, Lisp_Object map,
 
       c = Faref (Vexecuting_kbd_macro, make_fixnum (executing_kbd_macro_index));
       if (STRINGP (Vexecuting_kbd_macro)
-          && (XFASTINT (c) & 0x80) && (XFASTINT (c) <= 0xff))
-        XSETFASTINT (c, CHAR_META | (XFASTINT (c) & ~0x80));
+          && (XFIXNAT (c) & 0x80) && (XFIXNAT (c) <= 0xff))
+        XSETFASTINT (c, CHAR_META | (XFIXNAT (c) & ~0x80));
 
       executing_kbd_macro_index++;
 
@@ -2516,7 +2516,7 @@ read_char (int commandflag, Lisp_Object map,
     {
       c = read_char_minibuf_menu_prompt (commandflag, map);
 
-      if (FIXNUMP (c) && XINT (c) == -2)
+      if (FIXNUMP (c) && XFIXNUM (c) == -2)
         return c;               /* wrong_kboard_jmpbuf */
 
       if (! NILP (c))
@@ -2676,10 +2676,10 @@ read_char (int commandflag, Lisp_Object map,
       if (commandflag != 0 && commandflag != -2
           && num_nonmacro_input_events > last_auto_save
           && FIXNUMP (Vauto_save_timeout)
-          && XINT (Vauto_save_timeout) > 0)
+          && XFIXNUM (Vauto_save_timeout) > 0)
         {
           Lisp_Object tem0;
-          EMACS_INT timeout = XFASTINT (Vauto_save_timeout);
+          EMACS_INT timeout = XFIXNAT (Vauto_save_timeout);
 
           timeout = min (timeout, MOST_POSITIVE_FIXNUM / delay_level * 4);
           timeout = delay_level * timeout / 4;
@@ -2852,15 +2852,15 @@ read_char (int commandflag, Lisp_Object map,
   if (FIXNUMP (c))
     {
       /* If kbd_buffer_get_event gave us an EOF, return that.  */
-      if (XINT (c) == -1)
+      if (XFIXNUM (c) == -1)
         goto exit;
 
       if ((STRINGP (KVAR (current_kboard, Vkeyboard_translate_table))
-           && UNSIGNED_CMP (XFASTINT (c), <,
+           && UNSIGNED_CMP (XFIXNAT (c), <,
                             SCHARS (KVAR (current_kboard,
                                           Vkeyboard_translate_table))))
           || (VECTORP (KVAR (current_kboard, Vkeyboard_translate_table))
-              && UNSIGNED_CMP (XFASTINT (c), <,
+              && UNSIGNED_CMP (XFIXNAT (c), <,
                                ASIZE (KVAR (current_kboard,
                                             Vkeyboard_translate_table))))
           || (CHAR_TABLE_P (KVAR (current_kboard, Vkeyboard_translate_table))
@@ -2910,7 +2910,7 @@ read_char (int commandflag, Lisp_Object map,
      save the echo area contents for it to refer to.  */
   if (FIXNUMP (c)
       && ! NILP (Vinput_method_function)
-      && ' ' <= XINT (c) && XINT (c) < 256 && XINT (c) != 127)
+      && ' ' <= XFIXNUM (c) && XFIXNUM (c) < 256 && XFIXNUM (c) != 127)
     {
       previous_echo_area_message = Fcurrent_message ();
       Vinput_method_previous_message = previous_echo_area_message;
@@ -2940,7 +2940,7 @@ read_char (int commandflag, Lisp_Object map,
       /* Don't run the input method within a key sequence,
          after the first event of the key sequence.  */
       && NILP (prev_event)
-      && ' ' <= XINT (c) && XINT (c) < 256 && XINT (c) != 127)
+      && ' ' <= XFIXNUM (c) && XFIXNUM (c) < 256 && XFIXNUM (c) != 127)
     {
       Lisp_Object keys;
       ptrdiff_t key_count;
@@ -3261,10 +3261,10 @@ record_char (Lisp_Object c)
       block_input ();
       if (FIXNUMP (c))
         {
-          if (XUINT (c) < 0x100)
-            putc_unlocked (XUINT (c), dribble);
+          if (XUFIXNUM (c) < 0x100)
+            putc_unlocked (XUFIXNUM (c), dribble);
           else
-            fprintf (dribble, " 0x%"pI"x", XUINT (c));
+            fprintf (dribble, " 0x%"pI"x", XUFIXNUM (c));
         }
       else
         {
@@ -5009,7 +5009,7 @@ make_lispy_position (struct frame *f, Lisp_Object x, Lisp_Object y,
   int xret = 0, yret = 0;
   /* The window or frame under frame pixel coordinates (x,y)  */
   Lisp_Object window_or_frame = f
-    ? window_from_coordinates (f, XINT (x), XINT (y), &part, 0)
+    ? window_from_coordinates (f, XFIXNUM (x), XFIXNUM (y), &part, 0)
     : Qnil;
 
   if (WINDOWP (window_or_frame))
@@ -5024,15 +5024,15 @@ make_lispy_position (struct frame *f, Lisp_Object x, Lisp_Object y,
       Lisp_Object object = Qnil;
 
       /* Pixel coordinates relative to the window corner.  */
-      int wx = XINT (x) - WINDOW_LEFT_EDGE_X (w);
-      int wy = XINT (y) - WINDOW_TOP_EDGE_Y (w);
+      int wx = XFIXNUM (x) - WINDOW_LEFT_EDGE_X (w);
+      int wy = XFIXNUM (y) - WINDOW_TOP_EDGE_Y (w);
 
       /* For text area clicks, return X, Y relative to the corner of
          this text area.  Note that dX, dY etc are set below, by
          buffer_posn_from_coords.  */
       if (part == ON_TEXT)
         {
-          xret = XINT (x) - window_box_left (w, TEXT_AREA);
+          xret = XFIXNUM (x) - window_box_left (w, TEXT_AREA);
           yret = wy - WINDOW_HEADER_LINE_HEIGHT (w);
         }
       /* For mode line and header line clicks, return X, Y relative to
@@ -5152,7 +5152,7 @@ make_lispy_position (struct frame *f, Lisp_Object x, Lisp_Object y,
             : (part == ON_RIGHT_FRINGE || part == ON_RIGHT_MARGIN
                || (part == ON_VERTICAL_SCROLL_BAR
                    && WINDOW_HAS_VERTICAL_SCROLL_BAR_ON_RIGHT (w)))
-            ? (XINT (x) - window_box_left (w, TEXT_AREA))
+            ? (XFIXNUM (x) - window_box_left (w, TEXT_AREA))
             : 0;
           int y2 = wy;
 
@@ -5210,8 +5210,8 @@ make_lispy_position (struct frame *f, Lisp_Object x, Lisp_Object y,
     {
       /* Return mouse pixel coordinates here.  */
       XSETFRAME (window_or_frame, f);
-      xret = XINT (x);
-      yret = XINT (y);
+      xret = XFIXNUM (x);
+      yret = XFIXNUM (y);
 
       if (FRAME_LIVE_P (f)
           && FRAME_INTERNAL_BORDER_WIDTH (f) > 0
@@ -5530,7 +5530,7 @@ make_lispy_event (struct input_event *event)
                in a menu (non-toolkit version).  */
             if (!toolkit_menubar_in_use (f))
               {
-                pixel_to_glyph_coords (f, XINT (event->x), XINT (event->y),
+                pixel_to_glyph_coords (f, XFIXNUM (event->x), XFIXNUM (event->y),
                                        &column, &row, NULL, 1);
 
                 /* In the non-toolkit version, clicks on the menu bar
@@ -5555,8 +5555,8 @@ make_lispy_event (struct input_event *event)
                         pos = AREF (items, i + 3);
                         if (NILP (string))
                           break;
-                        if (column >= XINT (pos)
-                            && column < XINT (pos) + SCHARS (string))
+                        if (column >= XFIXNUM (pos)
+                            && column < XFIXNUM (pos) + SCHARS (string))
                           {
                             item = AREF (items, i);
                             break;
@@ -5616,18 +5616,18 @@ make_lispy_event (struct input_event *event)
             fuzz = double_click_fuzz / 8;
 
           is_double = (button == last_mouse_button
-                       && (eabs (XINT (event->x) - last_mouse_x) <= fuzz)
-                       && (eabs (XINT (event->y) - last_mouse_y) <= fuzz)
+                       && (eabs (XFIXNUM (event->x) - last_mouse_x) <= fuzz)
+                       && (eabs (XFIXNUM (event->y) - last_mouse_y) <= fuzz)
                        && button_down_time != 0
                        && (EQ (Vdouble_click_time, Qt)
                            || (FIXNATP (Vdouble_click_time)
                                && (event->timestamp - button_down_time
-                                   < XFASTINT (Vdouble_click_time)))));
+                                   < XFIXNAT (Vdouble_click_time)))));
         }
 
         last_mouse_button = button;
-        last_mouse_x = XINT (event->x);
-        last_mouse_y = XINT (event->y);
+        last_mouse_x = XFIXNUM (event->x);
+        last_mouse_y = XFIXNUM (event->y);
 
         /* If this is a button press, squirrel away the location, so
            we can decide later whether it was a click or a drag.  */
@@ -5674,8 +5674,8 @@ make_lispy_event (struct input_event *event)
                 if (CONSP (down)
                     && FIXNUMP (XCAR (down)) && FIXNUMP (XCDR (down)))
                   {
-                    xdiff = XINT (XCAR (new_down)) - XINT (XCAR (down));
-                    ydiff = XINT (XCDR (new_down)) - XINT (XCDR (down));
+                    xdiff = XFIXNUM (XCAR (new_down)) - XFIXNUM (XCAR (down));
+                    ydiff = XFIXNUM (XCDR (new_down)) - XFIXNUM (XCDR (down));
                   }
 
                 if (ignore_mouse_drag_p)
@@ -5794,13 +5794,13 @@ make_lispy_event (struct input_event *event)
             symbol_num += 2;
 
           is_double = (last_mouse_button == - (1 + symbol_num)
-                       && (eabs (XINT (event->x) - last_mouse_x) <= fuzz)
-                       && (eabs (XINT (event->y) - last_mouse_y) <= fuzz)
+                       && (eabs (XFIXNUM (event->x) - last_mouse_x) <= fuzz)
+                       && (eabs (XFIXNUM (event->y) - last_mouse_y) <= fuzz)
                        && button_down_time != 0
                        && (EQ (Vdouble_click_time, Qt)
                            || (FIXNATP (Vdouble_click_time)
                                && (event->timestamp - button_down_time
-                                   < XFASTINT (Vdouble_click_time)))));
+                                   < XFIXNAT (Vdouble_click_time)))));
           if (is_double)
             {
               double_click_count++;
@@ -5817,8 +5817,8 @@ make_lispy_event (struct input_event *event)
           button_down_time = event->timestamp;
           /* Use a negative value to distinguish wheel from mouse button.  */
           last_mouse_button = - (1 + symbol_num);
-          last_mouse_x = XINT (event->x);
-          last_mouse_y = XINT (event->y);
+          last_mouse_x = XFIXNUM (event->x);
+          last_mouse_y = XFIXNUM (event->y);
 
           /* Get the symbol we should use for the wheel event.  */
           head = modify_event_symbol (symbol_num,
@@ -6260,7 +6260,7 @@ lispy_modifier_list (int modifiers)
    SYMBOL's Qevent_symbol_element_mask property, and maintains the
    Qevent_symbol_elements property.  */
 
-#define KEY_TO_CHAR(k) (XINT (k) & ((1 << CHARACTERBITS) - 1))
+#define KEY_TO_CHAR(k) (XFIXNUM (k) & ((1 << CHARACTERBITS) - 1))
 
 Lisp_Object
 parse_modifiers (Lisp_Object symbol)
@@ -6268,7 +6268,7 @@ parse_modifiers (Lisp_Object symbol)
   Lisp_Object elements;
 
   if (FIXNUMP (symbol))
-    return list2i (KEY_TO_CHAR (symbol), XINT (symbol) & CHAR_MODIFIER_MASK);
+    return list2i (KEY_TO_CHAR (symbol), XFIXNUM (symbol) & CHAR_MODIFIER_MASK);
   else if (!SYMBOLP (symbol))
     return Qnil;
 
@@ -6336,7 +6336,7 @@ apply_modifiers (int modifiers, Lisp_Object base)
   modifiers &= INTMASK;
 
   if (FIXNUMP (base))
-    return make_fixnum (XINT (base) | modifiers);
+    return make_fixnum (XFIXNUM (base) | modifiers);
 
   /* The click modifier never figures into cache indices.  */
   cache = Fget (base, Qmodifier_cache);
@@ -6404,7 +6404,7 @@ reorder_modifiers (Lisp_Object symbol)
   Lisp_Object parsed;
 
   parsed = parse_modifiers (symbol);
-  return apply_modifiers (XFASTINT (XCAR (XCDR (parsed))),
+  return apply_modifiers (XFIXNAT (XCAR (XCDR (parsed))),
                           XCAR (parsed));
 }
 
@@ -6491,7 +6491,7 @@ modify_event_symbol (ptrdiff_t symbol_num, int modifiers, Lisp_Object symbol_kin
           USE_SAFE_ALLOCA;
           buf = SAFE_ALLOCA (len);
           esprintf (buf, "%s-%"pI"d", SDATA (name_alist_or_stem),
-                    XINT (symbol_int) + 1);
+                    XFIXNUM (symbol_int) + 1);
           value = intern (buf);
           SAFE_FREE ();
         }
@@ -6578,18 +6578,18 @@ has the same base event type and all the specified modifiers.  */)
     {
       /* Turn (shift a) into A.  */
       if ((modifiers & shift_modifier) != 0
-          && (XINT (base) >= 'a' && XINT (base) <= 'z'))
+          && (XFIXNUM (base) >= 'a' && XFIXNUM (base) <= 'z'))
         {
-          XSETINT (base, XINT (base) - ('a' - 'A'));
+          XSETINT (base, XFIXNUM (base) - ('a' - 'A'));
           modifiers &= ~shift_modifier;
         }
 
       /* Turn (control a) into C-a.  */
       if (modifiers & ctrl_modifier)
         return make_fixnum ((modifiers & ~ctrl_modifier)
-                            | make_ctrl_char (XINT (base)));
+                            | make_ctrl_char (XFIXNUM (base)));
       else
-        return make_fixnum (modifiers | XINT (base));
+        return make_fixnum (modifiers | XFIXNUM (base));
     }
   else if (SYMBOLP (base))
     return apply_modifiers (modifiers, base);
@@ -8527,8 +8527,8 @@ read_char_minibuf_menu_prompt (int commandflag,
 
                   upcased_event = Fupcase (event);
                   downcased_event = Fdowncase (event);
-                  char_matches = (XINT (upcased_event) == SREF (s, 0)
-                                  || XINT (downcased_event) == SREF (s, 0));
+                  char_matches = (XFIXNUM (upcased_event) == SREF (s, 0)
+                                  || XFIXNUM (downcased_event) == SREF (s, 0));
                   if (! char_matches)
                     desc = Fsingle_key_description (event, Qnil);
 
@@ -8633,10 +8633,10 @@ read_char_minibuf_menu_prompt (int commandflag,
       while (BUFFERP (obj));
       kset_defining_kbd_macro (current_kboard, orig_defn_macro);
 
-      if (!FIXNUMP (obj) || XINT (obj) == -2
+      if (!FIXNUMP (obj) || XFIXNUM (obj) == -2
           || (! EQ (obj, menu_prompt_more_char)
               && (!FIXNUMP (menu_prompt_more_char)
-                  || ! EQ (obj, make_fixnum (Ctl (XINT (menu_prompt_more_char)))))))
+                  || ! EQ (obj, make_fixnum (Ctl (XFIXNUM (menu_prompt_more_char)))))))
         {
           if (!NILP (KVAR (current_kboard, defining_kbd_macro)))
             store_kbd_macro_char (obj);
@@ -8757,7 +8757,7 @@ keyremap_step (Lisp_Object *keybuf, volatile keyremap *fkey,
      the binding and restart with fkey->start at the end.  */
   if ((VECTORP (next) || STRINGP (next)) && doit)
     {
-      int len = XFASTINT (Flength (next));
+      int len = XFIXNAT (Flength (next));
       int i;
 
       *diff = len - (fkey->end - fkey->start);
@@ -9105,7 +9105,7 @@ read_key_sequence (Lisp_Object *keybuf, Lisp_Object prompt,
                              current_binding, last_nonmenu_event,
                              &used_mouse_menu, NULL);
             used_mouse_menu_history[t] = used_mouse_menu;
-            if ((FIXNUMP (key) && XINT (key) == -2) /* wrong_kboard_jmpbuf */
+            if ((FIXNUMP (key) && XFIXNUM (key) == -2) /* wrong_kboard_jmpbuf */
                 /* When switching to a new tty (with a new keyboard),
                    read_char returns the new buffer, rather than -2
                    (Bug#5095).  This is because `terminal-init-xterm'
@@ -9173,7 +9173,7 @@ read_key_sequence (Lisp_Object *keybuf, Lisp_Object prompt,
           /* read_char returns -1 at the end of a macro.
              Emacs 18 handles this by returning immediately with a
              zero, so that's what we'll do.  */
-          if (FIXNUMP (key) && XINT (key) == -1)
+          if (FIXNUMP (key) && XFIXNUM (key) == -1)
             {
               t = 0;
               /* The Microsoft C compiler can't handle the goto that
@@ -9209,7 +9209,7 @@ read_key_sequence (Lisp_Object *keybuf, Lisp_Object prompt,
              quit_throw_to_read_char switched buffers,
              replay to get the right keymap.  */
           if (FIXNUMP (key)
-              && XINT (key) == quit_char
+              && XFIXNUM (key) == quit_char
               && current_buffer != starting_buffer)
             {
               GROW_RAW_KEYBUF;
@@ -9409,7 +9409,7 @@ read_key_sequence (Lisp_Object *keybuf, Lisp_Object prompt,
               int modifiers;
 
               breakdown = parse_modifiers (head);
-              modifiers = XINT (XCAR (XCDR (breakdown)));
+              modifiers = XFIXNUM (XCAR (XCDR (breakdown)));
               /* Attempt to reduce an unbound mouse event to a simpler
                  event that is bound:
                    Drags reduce to clicks.
@@ -9642,7 +9642,7 @@ read_key_sequence (Lisp_Object *keybuf, Lisp_Object prompt,
           && FIXNUMP (key))
         {
           Lisp_Object new_key;
-          EMACS_INT k = XINT (key);
+          EMACS_INT k = XFIXNUM (key);
 
           if (k & shift_modifier)
             XSETINT (new_key, k & ~shift_modifier);
@@ -9689,7 +9689,7 @@ read_key_sequence (Lisp_Object *keybuf, Lisp_Object prompt,
         {
           Lisp_Object breakdown = parse_modifiers (key);
           int modifiers
-            = CONSP (breakdown) ? (XINT (XCAR (XCDR (breakdown)))) : 0;
+            = CONSP (breakdown) ? (XFIXNUM (XCAR (XCDR (breakdown)))) : 0;
 
           if (modifiers & shift_modifier
               /* Treat uppercase keys as shifted.  */
@@ -10655,7 +10655,7 @@ See also `current-input-mode'.  */)
     return Qnil;
   tty = t->display_info.tty;
 
-  if (NILP (quit) || !FIXNUMP (quit) || XINT (quit) < 0 || XINT (quit) > 0400)
+  if (NILP (quit) || !FIXNUMP (quit) || XFIXNUM (quit) < 0 || XFIXNUM (quit) > 0400)
     error ("QUIT must be an ASCII character");
 
 #ifndef DOS_NT
@@ -10664,7 +10664,7 @@ See also `current-input-mode'.  */)
 #endif
 
   /* Don't let this value be out of range.  */
-  quit_char = XINT (quit) & (tty->meta_key == 0 ? 0177 : 0377);
+  quit_char = XFIXNUM (quit) & (tty->meta_key == 0 ? 0177 : 0377);
 
 #ifndef DOS_NT
   init_sys_modes (tty);
@@ -10747,7 +10747,7 @@ The `posn-' functions access elements of such lists.  */)
   CHECK_FIXNUM (x);
   /* We allow X of -1, for the newline in a R2L line that overflowed
      into the left fringe.  */
-  if (XINT (x) != -1)
+  if (XFIXNUM (x) != -1)
     CHECK_FIXNAT (x);
   CHECK_FIXNAT (y);
 
@@ -10758,12 +10758,12 @@ The `posn-' functions access elements of such lists.  */)
     {
       struct window *w = decode_live_window (frame_or_window);
 
-      XSETINT (x, (XINT (x)
+      XSETINT (x, (XFIXNUM (x)
                    + WINDOW_LEFT_EDGE_X (w)
                    + (NILP (whole)
                       ? window_box_left_offset (w, TEXT_AREA)
                       : 0)));
-      XSETINT (y, WINDOW_TO_FRAME_PIXEL_Y (w, XINT (y)));
+      XSETINT (y, WINDOW_TO_FRAME_PIXEL_Y (w, XFIXNUM (y)));
       frame_or_window = w->frame;
     }
 
@@ -10796,15 +10796,15 @@ The `posn-' functions access elements of such lists.  */)
       Lisp_Object x = XCAR (tem);
       Lisp_Object y = XCAR (XCDR (tem));
       Lisp_Object aux_info = XCDR (XCDR (tem));
-      int y_coord = XINT (y);
+      int y_coord = XFIXNUM (y);
 
       /* Point invisible due to hscrolling?  X can be -1 when a
          newline in a R2L line overflows into the left fringe.  */
-      if (XINT (x) < -1)
+      if (XFIXNUM (x) < -1)
         return Qnil;
       if (!NILP (aux_info) && y_coord < 0)
         {
-          int rtop = XINT (XCAR (aux_info));
+          int rtop = XFIXNUM (XCAR (aux_info));
 
           y = make_fixnum (y_coord + rtop);
         }
diff --git a/src/keymap.c b/src/keymap.c
index a7e0557ebde..bdd3af2cdcc 100644
--- a/src/keymap.c
+++ b/src/keymap.c
@@ -382,17 +382,17 @@ access_keymap_1 (Lisp_Object map, Lisp_Object idx,
   else if (FIXNUMP (idx))
     /* Clobber the high bits that can be present on a machine
        with more than 24 bits of integer.  */
-    XSETFASTINT (idx, XINT (idx) & (CHAR_META | (CHAR_META - 1)));
+    XSETFASTINT (idx, XFIXNUM (idx) & (CHAR_META | (CHAR_META - 1)));
 
   /* Handle the special meta -> esc mapping.  */
-  if (FIXNUMP (idx) && XFASTINT (idx) & meta_modifier)
+  if (FIXNUMP (idx) && XFIXNAT (idx) & meta_modifier)
     {
       /* See if there is a meta-map.  If there's none, there is
          no binding for IDX, unless a default binding exists in MAP.  */
       Lisp_Object event_meta_binding, event_meta_map;
       /* A strange value in which Meta is set would cause
          infinite recursion.  Protect against that.  */
-      if (XINT (meta_prefix_char) & CHAR_META)
+      if (XFIXNUM (meta_prefix_char) & CHAR_META)
         meta_prefix_char = make_fixnum (27);
       event_meta_binding = access_keymap_1 (map, meta_prefix_char, t_ok,
                                             noinherit, autoload);
@@ -400,7 +400,7 @@ access_keymap_1 (Lisp_Object map, Lisp_Object idx,
       if (CONSP (event_meta_map))
         {
           map = event_meta_map;
-          idx = make_fixnum (XFASTINT (idx) & ~meta_modifier);
+          idx = make_fixnum (XFIXNAT (idx) & ~meta_modifier);
         }
       else if (t_ok)
         /* Set IDX to t, so that we only find a default binding.  */
@@ -473,15 +473,15 @@ access_keymap_1 (Lisp_Object map, Lisp_Object idx,
           }
         else if (VECTORP (binding))
           {
-            if (FIXNUMP (idx) && XFASTINT (idx) < ASIZE (binding))
-              val = AREF (binding, XFASTINT (idx));
+            if (FIXNUMP (idx) && XFIXNAT (idx) < ASIZE (binding))
+              val = AREF (binding, XFIXNAT (idx));
           }
         else if (CHAR_TABLE_P (binding))
           {
             /* Character codes with modifiers
                are not included in a char-table.
                All character codes without modifiers are included.  */
-            if (FIXNUMP (idx) && (XFASTINT (idx) & CHAR_MODIFIER_MASK) == 0)
+            if (FIXNUMP (idx) && (XFIXNAT (idx) & CHAR_MODIFIER_MASK) == 0)
               {
                 val = Faref (binding, idx);
                 /* nil has a special meaning for char-tables, so
@@ -567,7 +567,7 @@ map_keymap_char_table_item (Lisp_Object args, Lisp_Object key, Lisp_Object val)
          it in place.  */
       if (CONSP (key))
         key = Fcons (XCAR (key), XCDR (key));
-      union map_keymap *md = XINTPTR (args);
+      union map_keymap *md = XFIXNUMPTR (args);
       map_keymap_item (md->s.fun, md->s.args, key, val, md->s.data);
     }
 }
@@ -785,7 +785,7 @@ store_in_keymap (Lisp_Object keymap, register Lisp_Object idx, Lisp_Object def)
   else if (FIXNUMP (idx))
     /* Clobber the high bits that can be present on a machine
        with more than 24 bits of integer.  */
-    XSETFASTINT (idx, XINT (idx) & (CHAR_META | (CHAR_META - 1)));
+    XSETFASTINT (idx, XFIXNUM (idx) & (CHAR_META | (CHAR_META - 1)));
 
   /* Scan the keymap for a binding of idx.  */
   {
@@ -807,22 +807,22 @@ store_in_keymap (Lisp_Object keymap, register Lisp_Object idx, Lisp_Object def)
         elt = XCAR (tail);
         if (VECTORP (elt))
           {
-            if (FIXNATP (idx) && XFASTINT (idx) < ASIZE (elt))
+            if (FIXNATP (idx) && XFIXNAT (idx) < ASIZE (elt))
               {
                 CHECK_IMPURE (elt, XVECTOR (elt));
-                ASET (elt, XFASTINT (idx), def);
+                ASET (elt, XFIXNAT (idx), def);
                 return def;
               }
             else if (CONSP (idx) && CHARACTERP (XCAR (idx)))
               {
-                int from = XFASTINT (XCAR (idx));
-                int to = XFASTINT (XCDR (idx));
+                int from = XFIXNAT (XCAR (idx));
+                int to = XFIXNAT (XCDR (idx));
 
                 if (to >= ASIZE (elt))
                   to = ASIZE (elt) - 1;
                 for (; from <= to; from++)
                   ASET (elt, from, def);
-                if (to == XFASTINT (XCDR (idx)))
+                if (to == XFIXNAT (XCDR (idx)))
                   /* We have defined all keys in IDX.  */
                   return def;
               }
@@ -833,7 +833,7 @@ store_in_keymap (Lisp_Object keymap, register Lisp_Object idx, Lisp_Object def)
             /* Character codes with modifiers
                are not included in a char-table.
                All character codes without modifiers are included.  */
-            if (FIXNATP (idx) && !(XFASTINT (idx) & CHAR_MODIFIER_MASK))
+            if (FIXNATP (idx) && !(XFIXNAT (idx) & CHAR_MODIFIER_MASK))
               {
                 Faset (elt, idx,
                        /* nil has a special meaning for char-tables, so
@@ -870,11 +870,11 @@ store_in_keymap (Lisp_Object keymap, register Lisp_Object idx, Lisp_Object def)
                      && CHARACTERP (XCAR (idx))
                      && CHARACTERP (XCAR (elt)))
               {
-                int from = XFASTINT (XCAR (idx));
-                int to = XFASTINT (XCDR (idx));
+                int from = XFIXNAT (XCAR (idx));
+                int to = XFIXNAT (XCDR (idx));
 
-                if (from <= XFASTINT (XCAR (elt))
-                    && to >= XFASTINT (XCAR (elt)))
+                if (from <= XFIXNAT (XCAR (elt))
+                    && to >= XFIXNAT (XCAR (elt)))
                   {
                     XSETCDR (elt, def);
                     if (from == to)
@@ -1124,7 +1124,7 @@ binding KEY to DEF is added at the front of KEYMAP.  */)
         silly_event_symbol_error (c);
 
       if (FIXNUMP (c)
-          && (XINT (c) & meta_bit)
+          && (XFIXNUM (c) & meta_bit)
           && !metized)
         {
           c = meta_prefix_char;
@@ -1133,7 +1133,7 @@ binding KEY to DEF is added at the front of KEYMAP.  */)
       else
         {
           if (FIXNUMP (c))
-            XSETINT (c, XINT (c) & ~meta_bit);
+            XSETINT (c, XFIXNUM (c) & ~meta_bit);
 
           metized = 0;
           idx++;
@@ -1246,8 +1246,8 @@ recognize the default bindings, just as `read-key-sequence' does.  */)
         c = Fevent_convert_list (c);
 
       /* Turn the 8th bit of string chars into a meta modifier.  */
-      if (STRINGP (key) && XINT (c) & 0x80 && !STRING_MULTIBYTE (key))
-        XSETINT (c, (XINT (c) | meta_modifier) & ~0x80);
+      if (STRINGP (key) && XFIXNUM (c) & 0x80 && !STRING_MULTIBYTE (key))
+        XSETINT (c, (XFIXNUM (c) | meta_modifier) & ~0x80);
 
       /* Allow string since binding for `menu-bar-select-buffer'
          includes the buffer name in the key sequence.  */
@@ -1300,7 +1300,7 @@ silly_event_symbol_error (Lisp_Object c)
   int modifiers;
 
   parsed = parse_modifiers (c);
-  modifiers = XFASTINT (XCAR (XCDR (parsed)));
+  modifiers = XFIXNAT (XCAR (XCDR (parsed)));
   base = XCAR (parsed);
   name = Fsymbol_name (base);
   /* This alist includes elements such as ("RET" . "\\r").  */
@@ -1474,7 +1474,7 @@ current_minor_maps (Lisp_Object **modeptr, Lisp_Object **mapptr)
 static ptrdiff_t
 click_position (Lisp_Object position)
 {
-  EMACS_INT pos = (FIXNUMP (position) ? XINT (position)
+  EMACS_INT pos = (FIXNUMP (position) ? XFIXNUM (position)
                    : MARKERP (position) ? marker_position (position)
                    : PT);
   if (! (BEGV <= pos && pos <= ZV))
@@ -1553,12 +1553,12 @@ like in the respective argument of `key-binding'.  */)
 
               pos = POSN_BUFFER_POSN (position);
               if (FIXNUMP (pos)
-                  && XINT (pos) >= BEG && XINT (pos) <= Z)
+                  && XFIXNUM (pos) >= BEG && XFIXNUM (pos) <= Z)
                 {
-                  local_map = get_local_map (XINT (pos),
+                  local_map = get_local_map (XFIXNUM (pos),
                                              current_buffer, Qlocal_map);
 
-                  keymap = get_local_map (XINT (pos),
+                  keymap = get_local_map (XFIXNUM (pos),
                                           current_buffer, Qkeymap);
                 }
             }
@@ -1576,8 +1576,8 @@ like in the respective argument of `key-binding'.  */)
               pos = XCDR (string);
               string = XCAR (string);
               if (FIXNUMP (pos)
-                  && XINT (pos) >= 0
-                  && XINT (pos) < SCHARS (string))
+                  && XFIXNUM (pos) >= 0
+                  && XFIXNUM (pos) < SCHARS (string))
                 {
                   map = Fget_text_property (pos, Qlocal_map, string);
                   if (!NILP (map))
@@ -1854,8 +1854,8 @@ accessible_keymaps_1 (Lisp_Object key, Lisp_Object cmd, Lisp_Object args, void *
   while (!NILP (tem = Frassq (cmd, maps)))
     {
       Lisp_Object prefix = XCAR (tem);
-      ptrdiff_t lim = XINT (Flength (XCAR (tem)));
-      if (lim <= XINT (Flength (thisseq)))
+      ptrdiff_t lim = XFIXNUM (Flength (XCAR (tem)));
+      if (lim <= XFIXNUM (Flength (thisseq)))
         { /* This keymap was already seen with a smaller prefix.  */
           ptrdiff_t i = 0;
           while (i < lim && EQ (Faref (prefix, make_fixnum (i)),
@@ -1879,10 +1879,10 @@ accessible_keymaps_1 (Lisp_Object key, Lisp_Object cmd, Lisp_Object args, void *
   if (is_metized)
     {
       int meta_bit = meta_modifier;
-      Lisp_Object last = make_fixnum (XINT (Flength (thisseq)) - 1);
+      Lisp_Object last = make_fixnum (XFIXNUM (Flength (thisseq)) - 1);
       tem = Fcopy_sequence (thisseq);
 
-      Faset (tem, last, make_fixnum (XINT (key) | meta_bit));
+      Faset (tem, last, make_fixnum (XFIXNUM (key) | meta_bit));
 
       /* This new sequence is the same length as
          thisseq, so stick it in the list right
@@ -1910,7 +1910,7 @@ then the value includes only maps for prefixes that start with PREFIX.  */)
   (Lisp_Object keymap, Lisp_Object prefix)
 {
   Lisp_Object maps, tail;
-  EMACS_INT prefixlen = XFASTINT (Flength (prefix));
+  EMACS_INT prefixlen = XFIXNAT (Flength (prefix));
 
   if (!NILP (prefix))
     {
@@ -1969,11 +1969,11 @@ then the value includes only maps for prefixes that start with PREFIX.  */)
       data.thisseq = Fcar (XCAR (tail));
       data.maps = maps;
       data.tail = tail;
-      last = make_fixnum (XINT (Flength (data.thisseq)) - 1);
+      last = make_fixnum (XFIXNUM (Flength (data.thisseq)) - 1);
       /* Does the current sequence end in the meta-prefix-char?  */
-      data.is_metized = (XINT (last) >= 0
+      data.is_metized = (XFIXNUM (last) >= 0
                     /* Don't metize the last char of PREFIX.  */
-                    && XINT (last) >= prefixlen
+                    && XFIXNUM (last) >= prefixlen
                     && EQ (Faref (data.thisseq, last), meta_prefix_char));
 
       /* Since we can't run lisp code, we can't scan autoloaded maps.  */
@@ -1997,7 +1997,7 @@ For an approximate inverse of this, see `kbd'.  */)
   EMACS_INT i;
   ptrdiff_t i_byte;
   Lisp_Object *args;
-  EMACS_INT size = XINT (Flength (keys));
+  EMACS_INT size = XFIXNUM (Flength (keys));
   Lisp_Object list;
   Lisp_Object sep = build_string (" ");
   Lisp_Object key;
@@ -2006,7 +2006,7 @@ For an approximate inverse of this, see `kbd'.  */)
   USE_SAFE_ALLOCA;
 
   if (!NILP (prefix))
-    size += XINT (Flength (prefix));
+    size += XFIXNUM (Flength (prefix));
 
   /* This has one extra element at the end that we don't pass to Fconcat.  */
   EMACS_INT size4;
@@ -2043,7 +2043,7 @@ For an approximate inverse of this, see `kbd'.  */)
   else if (VECTORP (list))
     size = ASIZE (list);
   else if (CONSP (list))
-    size = XINT (Flength (list));
+    size = XFIXNUM (Flength (list));
   else
     wrong_type_argument (Qarrayp, list);
 
@@ -2074,7 +2074,7 @@ For an approximate inverse of this, see `kbd'.  */)
         {
           if (!FIXNUMP (key)
               || EQ (key, meta_prefix_char)
-              || (XINT (key) & meta_modifier))
+              || (XFIXNUM (key) & meta_modifier))
             {
               args[len++] = Fsingle_key_description (meta_prefix_char, Qnil);
               args[len++] = sep;
@@ -2082,7 +2082,7 @@ For an approximate inverse of this, see `kbd'.  */)
                 continue;
             }
           else
-            XSETINT (key, XINT (key) | meta_modifier);
+            XSETINT (key, XFIXNUM (key) | meta_modifier);
           add_meta = 0;
         }
       else if (EQ (key, meta_prefix_char))
@@ -2240,7 +2240,7 @@ around function keys and event symbols.  */)
   if (FIXNUMP (key))            /* Normal character.  */
     {
       char tem[KEY_DESCRIPTION_SIZE];
-      char *p = push_key_description (XINT (key), tem);
+      char *p = push_key_description (XFIXNUM (key), tem);
       *p = 0;
       return make_specified_string (tem, -1, p - tem, 1);
     }
@@ -2306,7 +2306,7 @@ See Info node `(elisp)Describing Characters' for examples.  */)
 
   CHECK_CHARACTER (character);
 
-  c = XINT (character);
+  c = XFIXNUM (character);
   if (!ASCII_CHAR_P (c))
     {
       int len = CHAR_STRING (c, (unsigned char *) str);
@@ -2328,7 +2328,7 @@ static int
 preferred_sequence_p (Lisp_Object seq)
 {
   EMACS_INT i;
-  EMACS_INT len = XFASTINT (Flength (seq));
+  EMACS_INT len = XFIXNAT (Flength (seq));
   int result = 1;
 
   for (i = 0; i < len; i++)
@@ -2342,7 +2342,7 @@ preferred_sequence_p (Lisp_Object seq)
         return 0;
       else
         {
-          int modifiers = XINT (elt) & (CHAR_MODIFIER_MASK & ~CHAR_META);
+          int modifiers = XFIXNUM (elt) & (CHAR_MODIFIER_MASK & ~CHAR_META);
           if (modifiers == where_is_preferred_modifier)
             result = 2;
           else if (modifiers)
@@ -2463,12 +2463,12 @@ where_is_internal (Lisp_Object definition, Lisp_Object keymaps,
 
       this = Fcar (XCAR (maps));
       map  = Fcdr (XCAR (maps));
-      last = make_fixnum (XINT (Flength (this)) - 1);
-      last_is_meta = (XINT (last) >= 0
+      last = make_fixnum (XFIXNUM (Flength (this)) - 1);
+      last_is_meta = (XFIXNUM (last) >= 0
                       && EQ (Faref (this, last), meta_prefix_char));
 
       /* if (nomenus && !preferred_sequence_p (this)) */
-      if (nomenus && XINT (last) >= 0
+      if (nomenus && XFIXNUM (last) >= 0
           && SYMBOLP (tem = Faref (this, make_fixnum (0)))
           && !NILP (Fmemq (XCAR (parse_modifiers (tem)), Vmouse_events)))
         /* If no menu entries should be returned, skip over the
@@ -2720,7 +2720,7 @@ where_is_internal_1 (Lisp_Object key, Lisp_Object binding, Lisp_Object args, voi
   if (FIXNUMP (key) && last_is_meta)
     {
       sequence = Fcopy_sequence (this);
-      Faset (sequence, last, make_fixnum (XINT (key) | meta_modifier));
+      Faset (sequence, last, make_fixnum (XFIXNUM (key) | meta_modifier));
     }
   else
     {
@@ -3126,8 +3126,8 @@ describe_map_compare (const void *aa, const void *bb)
 {
   const struct describe_map_elt *a = aa, *b = bb;
   if (FIXNUMP (a->event) && FIXNUMP (b->event))
-    return ((XINT (a->event) > XINT (b->event))
-            - (XINT (a->event) < XINT (b->event)));
+    return ((XFIXNUM (a->event) > XFIXNUM (b->event))
+            - (XFIXNUM (a->event) < XFIXNUM (b->event)));
   if (!FIXNUMP (a->event) && FIXNUMP (b->event))
     return 1;
   if (FIXNUMP (a->event) && !FIXNUMP (b->event))
@@ -3285,7 +3285,7 @@ describe_map (Lisp_Object map, Lisp_Object prefix,
       if (FIXNUMP (vect[i].event))
         {
           while (i + 1 < slots_used
-                 && EQ (vect[i+1].event, make_fixnum (XINT (vect[i].event) + 1))
+                 && EQ (vect[i+1].event, make_fixnum (XFIXNUM (vect[i].event) + 1))
                  && !NILP (Fequal (vect[i + 1].definition, definition))
                  && vect[i].shadowed == vect[i + 1].shadowed)
             i++;
@@ -3407,7 +3407,7 @@ describe_vector (Lisp_Object vector, Lisp_Object prefix, Lisp_Object args,
   if (!keymap_p)
     {
       /* Call Fkey_description first, to avoid GC bug for the other string.  */
-      if (!NILP (prefix) && XFASTINT (Flength (prefix)) > 0)
+      if (!NILP (prefix) && XFIXNAT (Flength (prefix)) > 0)
         {
           Lisp_Object tem = Fkey_description (prefix, Qnil);
           AUTO_STRING (space, " ");
diff --git a/src/kqueue.c b/src/kqueue.c
index b45c316b93b..bc01ab5062c 100644
--- a/src/kqueue.c
+++ b/src/kqueue.c
@@ -234,7 +234,7 @@ kqueue_compare_dir_list (Lisp_Object watch_object)
 
     /* Check size of that file.  */
     Lisp_Object size = Fnth (make_fixnum (4), entry);
-    if (FLOATP (size) || (XINT (size) > 0))
+    if (FLOATP (size) || (XFIXNUM (size) > 0))
       kqueue_generate_event
         (watch_object, Fcons (Qwrite, Qnil), XCAR (XCDR (entry)), Qnil);
 
@@ -395,7 +395,7 @@ only when the upper directory of the renamed file is watched.  */)
     maxfd = 256;
 
   /* We assume 50 file descriptors are sufficient for the rest of Emacs.  */
-  if ((maxfd - 50) < XINT (Flength (watch_list)))
+  if ((maxfd - 50) < XFIXNUM (Flength (watch_list)))
     xsignal2
       (Qfile_notify_error,
        build_string ("File watching not possible, no file descriptor left"),
@@ -474,7 +474,7 @@ WATCH-DESCRIPTOR should be an object returned by `kqueue-add-watch'.  */)
               watch_descriptor);
 
   eassert (FIXNUMP (watch_descriptor));
-  int fd = XINT (watch_descriptor);
+  int fd = XFIXNUM (watch_descriptor);
   if ( fd >= 0)
     emacs_close (fd);
 
diff --git a/src/lcms.c b/src/lcms.c
index 9df85c2c180..a3a98223060 100644
--- a/src/lcms.c
+++ b/src/lcms.c
@@ -254,7 +254,7 @@ parse_viewing_conditions (Lisp_Object view, const cmsCIEXYZ *wp,
   if (CONSP (view) && FIXNATP (XCAR (view)))                            \
     {                                                                   \
       CHECK_RANGED_INTEGER (XCAR (view), 1, 4);                         \
-      vc->field = XINT (XCAR (view));                                   \
+      vc->field = XFIXNUM (XCAR (view));                                        \
       view = XCDR (view);                                               \
     }                                                                   \
   else                                                                  \
diff --git a/src/lisp.h b/src/lisp.h
index b404f9d89aa..9047d217249 100644
--- a/src/lisp.h
+++ b/src/lisp.h
@@ -382,15 +382,15 @@ typedef EMACS_INT Lisp_Word;
 #define lisp_h_XCDR(c) XCONS (c)->u.s.u.cdr
 #define lisp_h_XCONS(a) \
    (eassert (CONSP (a)), XUNTAG (a, Lisp_Cons, struct Lisp_Cons))
-#define lisp_h_XHASH(a) XUINT (a)
+#define lisp_h_XHASH(a) XUFIXNUM (a)
 #ifndef GC_CHECK_CONS_LIST
 # define lisp_h_check_cons_list() ((void) 0)
 #endif
 #if USE_LSB_TAG
 # define lisp_h_make_fixnum(n) \
     XIL ((EMACS_INT) (((EMACS_UINT) (n) << INTTYPEBITS) + Lisp_Int0))
-# define lisp_h_XFASTINT(a) XINT (a)
-# define lisp_h_XINT(a) (XLI (a) >> INTTYPEBITS)
+# define lisp_h_XFIXNAT(a) XFIXNUM (a)
+# define lisp_h_XFIXNUM(a) (XLI (a) >> INTTYPEBITS)
 # ifdef __CHKP__
 #  define lisp_h_XSYMBOL(a) \
     (eassert (SYMBOLP (a)), \
@@ -448,8 +448,8 @@ typedef EMACS_INT Lisp_Word;
 # endif
 # if USE_LSB_TAG
 #  define make_fixnum(n) lisp_h_make_fixnum (n)
-#  define XFASTINT(a) lisp_h_XFASTINT (a)
-#  define XINT(a) lisp_h_XINT (a)
+#  define XFIXNAT(a) lisp_h_XFIXNAT (a)
+#  define XFIXNUM(a) lisp_h_XFIXNUM (a)
 #  define XSYMBOL(a) lisp_h_XSYMBOL (a)
 #  define XTYPE(a) lisp_h_XTYPE (a)
 # endif
@@ -486,7 +486,7 @@ enum Lisp_Type
        whose first member indicates the subtype.  */
     Lisp_Misc = 1,
 
-    /* Integer.  XINT (obj) is the integer value.  */
+    /* Integer.  XFIXNUM (obj) is the integer value.  */
     Lisp_Int0 = 2,
     Lisp_Int1 = USE_LSB_TAG ? 6 : 3,
 
@@ -1038,15 +1038,15 @@ INLINE Lisp_Object
 }
 
 INLINE EMACS_INT
-(XINT) (Lisp_Object a)
+(XFIXNUM) (Lisp_Object a)
 {
-  return lisp_h_XINT (a);
+  return lisp_h_XFIXNUM (a);
 }
 
 INLINE EMACS_INT
-(XFASTINT) (Lisp_Object a)
+(XFIXNAT) (Lisp_Object a)
 {
-  EMACS_INT n = lisp_h_XFASTINT (a);
+  EMACS_INT n = lisp_h_XFIXNAT (a);
   eassume (0 <= n);
   return n;
 }
@@ -1079,7 +1079,7 @@ make_fixnum (EMACS_INT n)
 
 /* Extract A's value as a signed integer.  */
 INLINE EMACS_INT
-XINT (Lisp_Object a)
+XFIXNUM (Lisp_Object a)
 {
   EMACS_INT i = XLI (a);
   if (! USE_LSB_TAG)
@@ -1090,14 +1090,14 @@ XINT (Lisp_Object a)
   return i >> INTTYPEBITS;
 }
 
-/* Like XINT (A), but may be faster.  A must be nonnegative.
+/* Like XFIXNUM (A), but may be faster.  A must be nonnegative.
    If ! USE_LSB_TAG, this takes advantage of the fact that Lisp
    integers have zero-bits in their tags.  */
 INLINE EMACS_INT
-XFASTINT (Lisp_Object a)
+XFIXNAT (Lisp_Object a)
 {
   EMACS_INT int0 = Lisp_Int0;
-  EMACS_INT n = USE_LSB_TAG ? XINT (a) : XLI (a) - (int0 << VALBITS);
+  EMACS_INT n = USE_LSB_TAG ? XFIXNUM (a) : XLI (a) - (int0 << VALBITS);
   eassume (0 <= n);
   return n;
 }
@@ -1106,14 +1106,14 @@ XFASTINT (Lisp_Object a)
 
 /* Extract A's value as an unsigned integer.  */
 INLINE EMACS_UINT
-XUINT (Lisp_Object a)
+XUFIXNUM (Lisp_Object a)
 {
   EMACS_UINT i = XLI (a);
   return USE_LSB_TAG ? i >> INTTYPEBITS : i & INTMASK;
 }
 
-/* Return A's (Lisp-integer sized) hash.  Happens to be like XUINT
-   right now, but XUINT should only be applied to objects we know are
+/* Return A's (Lisp-integer sized) hash.  Happens to be like XUFIXNUM
+   right now, but XUFIXNUM should only be applied to objects we know are
    integers.  */
 
 INLINE EMACS_INT
@@ -1218,7 +1218,7 @@ INLINE bool
    bits set, which makes this conversion inherently unportable.  */
 
 INLINE void *
-XINTPTR (Lisp_Object a)
+XFIXNUMPTR (Lisp_Object a)
 {
   return XUNTAG (a, Lisp_Int0, char);
 }
@@ -1227,7 +1227,7 @@ INLINE Lisp_Object
 make_pointer_integer (void *p)
 {
   Lisp_Object a = TAG_PTR (Lisp_Int0, p);
-  eassert (FIXNUMP (a) && XINTPTR (a) == p);
+  eassert (FIXNUMP (a) && XFIXNUMPTR (a) == p);
   return a;
 }
 
@@ -2378,10 +2378,10 @@ extern Lisp_Object make_misc_ptr (void *);
 
 /* A mint_ptr object OBJ represents a C-language pointer P efficiently.
    Preferably (and typically), OBJ is a Lisp integer I such that
-   XINTPTR (I) == P, as this represents P within a single Lisp value
+   XFIXNUMPTR (I) == P, as this represents P within a single Lisp value
    without requiring any auxiliary memory.  However, if P would be
    damaged by being tagged as an integer and then untagged via
-   XINTPTR, then OBJ is a Lisp_Misc_Ptr with pointer component P.
+   XFIXNUMPTR, then OBJ is a Lisp_Misc_Ptr with pointer component P.
 
    mint_ptr objects are efficiency hacks intended for C code.
    Although xmint_ptr can be given any mint_ptr generated by non-buggy
@@ -2395,7 +2395,7 @@ INLINE Lisp_Object
 make_mint_ptr (void *a)
 {
   Lisp_Object val = TAG_PTR (Lisp_Int0, a);
-  return FIXNUMP (val) && XINTPTR (val) == a ? val : make_misc_ptr (a);
+  return FIXNUMP (val) && XFIXNUMPTR (val) == a ? val : make_misc_ptr (a);
 }
 
 INLINE bool
@@ -2409,7 +2409,7 @@ xmint_pointer (Lisp_Object a)
 {
   eassert (mint_ptrp (a));
   if (FIXNUMP (a))
-    return XINTPTR (a);
+    return XFIXNUMPTR (a);
   return XUNTAG (a, Lisp_Misc, struct Lisp_Misc_Ptr)->pointer;
 }
 
@@ -2766,14 +2766,14 @@ FIXED_OR_FLOATP (Lisp_Object x)
 INLINE bool
 FIXNATP (Lisp_Object x)
 {
-  return FIXNUMP (x) && 0 <= XINT (x);
+  return FIXNUMP (x) && 0 <= XFIXNUM (x);
 }
 INLINE bool
 NATNUMP (Lisp_Object x)
 {
   if (BIGNUMP (x))
     return mpz_cmp_si (XBIGNUM (x)->value, 0) >= 0;
-  return FIXNUMP (x) && 0 <= XINT (x);
+  return FIXNUMP (x) && 0 <= XFIXNUM (x);
 }
 INLINE bool
 NUMBERP (Lisp_Object x)
@@ -2784,13 +2784,13 @@ NUMBERP (Lisp_Object x)
 INLINE bool
 RANGED_FIXNUMP (intmax_t lo, Lisp_Object x, intmax_t hi)
 {
-  return FIXNUMP (x) && lo <= XINT (x) && XINT (x) <= hi;
+  return FIXNUMP (x) && lo <= XFIXNUM (x) && XFIXNUM (x) <= hi;
 }
 
 #define TYPE_RANGED_FIXNUMP(type, x) \
   (FIXNUMP (x)                        \
-   && (TYPE_SIGNED (type) ? TYPE_MINIMUM (type) <= XINT (x) : 0 <= XINT (x)) \
-   && XINT (x) <= TYPE_MAXIMUM (type))
+   && (TYPE_SIGNED (type) ? TYPE_MINIMUM (type) <= XFIXNUM (x) : 0 <= XFIXNUM (x)) \
+   && XFIXNUM (x) <= TYPE_MAXIMUM (type))
 
 INLINE bool
 AUTOLOADP (Lisp_Object x)
@@ -2892,7 +2892,7 @@ CHECK_FIXNAT (Lisp_Object x)
 #define CHECK_RANGED_INTEGER(x, lo, hi)                                 \
   do {                                                                  \
     CHECK_FIXNUM (x);                                                   \
-    if (! ((lo) <= XINT (x) && XINT (x) <= (hi)))                       \
+    if (! ((lo) <= XFIXNUM (x) && XFIXNUM (x) <= (hi)))                 \
       args_out_of_range_3                                               \
         (x,                                                             \
          make_fixnum ((lo) < 0 && (lo) < MOST_NEGATIVE_FIXNUM           \
@@ -2921,7 +2921,7 @@ XFLOATINT (Lisp_Object n)
 {
   if (BIGNUMP (n))
     return mpz_get_d (XBIGNUM (n)->value);
-  return FLOATP (n) ? XFLOAT_DATA (n) : XINT (n);
+  return FLOATP (n) ? XFLOAT_DATA (n) : XFIXNUM (n);
 }
 
 INLINE void
diff --git a/src/lread.c b/src/lread.c
index ff86c96c9b5..bcb695c3dae 100644
--- a/src/lread.c
+++ b/src/lread.c
@@ -331,7 +331,7 @@ readchar (Lisp_Object readcharfun, bool *multibyte)
 
   if (NILP (tem))
     return -1;
-  return XINT (tem);
+  return XFIXNUM (tem);
 
  read_multibyte:
   if (unread_char >= 0)
@@ -673,7 +673,7 @@ read_filtered_event (bool no_switch_frame, bool ascii_required,
   do
     val = read_char (0, Qnil, (input_method ? Qnil : Qt), 0,
                      FIXED_OR_FLOATP (seconds) ? &end_time : NULL);
-  while (FIXNUMP (val) && XINT (val) == -2); /* wrong_kboard_jmpbuf */
+  while (FIXNUMP (val) && XFIXNUM (val) == -2); /* wrong_kboard_jmpbuf */
 
   if (BUFFERP (val))
     goto retry;
@@ -704,7 +704,7 @@ read_filtered_event (bool no_switch_frame, bool ascii_required,
               /* Merge this symbol's modifier bits
                  with the ASCII equivalent of its basic code.  */
               if (!NILP (tem1))
-                XSETFASTINT (val, XINT (tem1) | XINT (Fcar (Fcdr (tem))));
+                XSETFASTINT (val, XFIXNUM (tem1) | XFIXNUM (Fcar (Fcdr (tem))));
             }
         }
 
@@ -766,7 +766,7 @@ floating-point value.  */)
   val = read_filtered_event (1, 1, 1, ! NILP (inherit_input_method), seconds);
 
   return (NILP (val) ? Qnil
-          : make_fixnum (char_resolve_modifier_mask (XINT (val))));
+          : make_fixnum (char_resolve_modifier_mask (XFIXNUM (val))));
 }
 
 DEFUN ("read-event", Fread_event, Sread_event, 0, 3, 0,
@@ -810,7 +810,7 @@ floating-point value.  */)
   val = read_filtered_event (1, 1, 0, ! NILP (inherit_input_method), seconds);
 
   return (NILP (val) ? Qnil
-          : make_fixnum (char_resolve_modifier_mask (XINT (val))));
+          : make_fixnum (char_resolve_modifier_mask (XFIXNUM (val))));
 }
 
 DEFUN ("get-file-char", Fget_file_char, Sget_file_char, 0, 0, 0,
@@ -1702,9 +1702,9 @@ openp (Lisp_Object path, Lisp_Object str, Lisp_Object suffixes,
             if (FIXNATP (predicate))
               {
                 fd = -1;
-                if (INT_MAX < XFASTINT (predicate))
+                if (INT_MAX < XFIXNAT (predicate))
                   last_errno = EINVAL;
-                else if (faccessat (AT_FDCWD, pfn, XFASTINT (predicate),
+                else if (faccessat (AT_FDCWD, pfn, XFIXNAT (predicate),
                                     AT_EACCESS)
                          == 0)
                   {
@@ -2348,14 +2348,14 @@ character_name_to_code (char const *name, ptrdiff_t name_len)
        : call2 (Qchar_from_name, make_unibyte_string (name, name_len), Qt));
 
   if (! RANGED_FIXNUMP (0, code, MAX_UNICODE_CHAR)
-      || char_surrogate_p (XINT (code)))
+      || char_surrogate_p (XFIXNUM (code)))
     {
       AUTO_STRING (format, "\\N{%s}");
       AUTO_STRING_WITH_LEN (namestr, name, name_len);
       xsignal1 (Qinvalid_read_syntax, CALLN (Fformat, format, namestr));
     }
 
-  return XINT (code);
+  return XFIXNUM (code);
 }
 
 /* Bound on the length of a Unicode character name.  As of
@@ -2779,7 +2779,7 @@ read1 (Lisp_Object readcharfun, int *pch, bool first_in_list)
 
               if (!EQ (head, Qhash_table))
                 {
-                  ptrdiff_t size = XINT (Flength (tmp));
+                  ptrdiff_t size = XFIXNUM (Flength (tmp));
                   Lisp_Object record = Fmake_record (CAR_SAFE (tmp),
                                                      make_fixnum (size - 1),
                                                      Qnil);
@@ -2866,7 +2866,7 @@ read1 (Lisp_Object readcharfun, int *pch, bool first_in_list)
                   /* Sub char-table can't be read as a regular
                      vector because of a two C integer fields.  */
                   Lisp_Object tbl, tmp = read_list (1, readcharfun);
-                  ptrdiff_t size = XINT (Flength (tmp));
+                  ptrdiff_t size = XFIXNUM (Flength (tmp));
                   int i, depth, min_char;
                   struct Lisp_Cons *cell;
 
@@ -2875,7 +2875,7 @@ read1 (Lisp_Object readcharfun, int *pch, bool first_in_list)
 
                   if (! RANGED_FIXNUMP (1, XCAR (tmp), 3))
                     error ("Invalid depth in sub char-table");
-                  depth = XINT (XCAR (tmp));
+                  depth = XFIXNUM (XCAR (tmp));
                   if (chartab_size[depth] != size - 2)
                     error ("Invalid size in sub char-table");
                   cell = XCONS (tmp), tmp = XCDR (tmp), size--;
@@ -2883,7 +2883,7 @@ read1 (Lisp_Object readcharfun, int *pch, bool first_in_list)
 
                   if (! RANGED_FIXNUMP (0, XCAR (tmp), MAX_CHAR))
                     error ("Invalid minimum character in sub-char-table");
-                  min_char = XINT (XCAR (tmp));
+                  min_char = XFIXNUM (XCAR (tmp));
                   cell = XCONS (tmp), tmp = XCDR (tmp), size--;
                   free_cons (cell);
 
@@ -2908,7 +2908,7 @@ read1 (Lisp_Object readcharfun, int *pch, bool first_in_list)
           if (c == '"')
             {
               Lisp_Object tmp, val;
-              EMACS_INT size_in_chars = bool_vector_bytes (XFASTINT (length));
+              EMACS_INT size_in_chars = bool_vector_bytes (XFIXNAT (length));
               unsigned char *data;
 
               UNREAD (c);
@@ -2919,17 +2919,17 @@ read1 (Lisp_Object readcharfun, int *pch, bool first_in_list)
                          when the number of bits was a multiple of 8.
                          Accept such input in case it came from an old
                          version.  */
-                      && ! (XFASTINT (length)
+                      && ! (XFIXNAT (length)
                             == (SCHARS (tmp) - 1) * BOOL_VECTOR_BITS_PER_CHAR)))
                 invalid_syntax ("#&...");
 
-              val = make_uninit_bool_vector (XFASTINT (length));
+              val = make_uninit_bool_vector (XFIXNAT (length));
               data = bool_vector_uchar_data (val);
               memcpy (data, SDATA (tmp), size_in_chars);
               /* Clear the extraneous bits in the last byte.  */
-              if (XINT (length) != size_in_chars * BOOL_VECTOR_BITS_PER_CHAR)
+              if (XFIXNUM (length) != size_in_chars * BOOL_VECTOR_BITS_PER_CHAR)
                 data[size_in_chars - 1]
-                  &= (1 << (XINT (length) % BOOL_VECTOR_BITS_PER_CHAR)) - 1;
+                  &= (1 << (XFIXNUM (length) % BOOL_VECTOR_BITS_PER_CHAR)) - 1;
               return val;
             }
           invalid_syntax ("#&...");
@@ -3832,11 +3832,11 @@ read_vector (Lisp_Object readcharfun, bool bytecodeflag)
 
   tem = read_list (1, readcharfun);
   len = Flength (tem);
-  if (bytecodeflag && XFASTINT (len) <= COMPILED_STACK_DEPTH)
+  if (bytecodeflag && XFIXNAT (len) <= COMPILED_STACK_DEPTH)
     error ("Invalid byte code");
   vector = Fmake_vector (len, Qnil);
 
-  size = XFASTINT (len);
+  size = XFIXNAT (len);
   ptr = XVECTOR (vector)->contents;
   for (i = 0; i < size; i++)
     {
@@ -3990,7 +3990,7 @@ read_list (bool flag, Lisp_Object readcharfun)
                          multibyte.  */
 
                       /* Position is negative for user variables.  */
-                      EMACS_INT pos = eabs (XINT (XCDR (val)));
+                      EMACS_INT pos = eabs (XFIXNUM (XCDR (val)));
                       if (pos >= saved_doc_string_position
                           && pos < (saved_doc_string_position
                                     + saved_doc_string_length))
@@ -4095,7 +4095,7 @@ intern_sym (Lisp_Object sym, Lisp_Object obarray, Lisp_Object index)
       SET_SYMBOL_VAL (XSYMBOL (sym), sym);
     }
 
-  ptr = aref_addr (obarray, XINT (index));
+  ptr = aref_addr (obarray, XFIXNUM (index));
   set_symbol_next (sym, SYMBOLP (*ptr) ? XSYMBOL (*ptr) : NULL);
   *ptr = sym;
   return sym;
diff --git a/src/macros.c b/src/macros.c
index be841069927..0677021bfd2 100644
--- a/src/macros.c
+++ b/src/macros.c
@@ -98,8 +98,8 @@ macro before appending to it.  */)
         {
           Lisp_Object c;
           c = Faref (KVAR (current_kboard, Vlast_kbd_macro), make_fixnum (i));
-          if (cvt && FIXNATP (c) && (XFASTINT (c) & 0x80))
-            XSETFASTINT (c, CHAR_META | (XFASTINT (c) & ~0x80));
+          if (cvt && FIXNATP (c) && (XFIXNAT (c) & 0x80))
+            XSETFASTINT (c, CHAR_META | (XFIXNAT (c) & ~0x80));
           current_kboard->kbd_macro_buffer[i] = c;
         }
 
@@ -162,11 +162,11 @@ each iteration of the macro.  Iteration stops if LOOPFUNC returns nil.  */)
       message1 ("Keyboard macro defined");
     }
 
-  if (XFASTINT (repeat) == 0)
+  if (XFIXNAT (repeat) == 0)
     Fexecute_kbd_macro (KVAR (current_kboard, Vlast_kbd_macro), repeat, loopfunc);
-  else if (XINT (repeat) > 1)
+  else if (XFIXNUM (repeat) > 1)
     {
-      XSETINT (repeat, XINT (repeat) - 1);
+      XSETINT (repeat, XFIXNUM (repeat) - 1);
       Fexecute_kbd_macro (KVAR (current_kboard, Vlast_kbd_macro),
                           repeat, loopfunc);
     }
@@ -267,7 +267,7 @@ pop_kbd_macro (Lisp_Object info)
   Lisp_Object tem;
   Vexecuting_kbd_macro = XCAR (info);
   tem = XCDR (info);
-  executing_kbd_macro_index = XINT (XCAR (tem));
+  executing_kbd_macro_index = XFIXNUM (XCAR (tem));
   Vreal_this_command = XCDR (tem);
   run_hook (Qkbd_macro_termination_hook);
 }
@@ -293,7 +293,7 @@ each iteration of the macro.  Iteration stops if LOOPFUNC returns nil.  */)
   if (!NILP (count))
     {
       count = Fprefix_numeric_value (count);
-      repeat = XINT (count);
+      repeat = XFIXNUM (count);
     }
 
   final = indirect_function (macro);
diff --git a/src/marker.c b/src/marker.c
index ab1eb9f5bfe..b9ea5c59824 100644
--- a/src/marker.c
+++ b/src/marker.c
@@ -525,7 +525,7 @@ set_marker_internal (Lisp_Object marker, Lisp_Object position,
          don't want to call buf_charpos_to_bytepos if POSITION
          is a marker and so we know the bytepos already.  */
       if (FIXNUMP (position))
-        charpos = XINT (position), bytepos = -1;
+        charpos = XFIXNUM (position), bytepos = -1;
       else if (MARKERP (position))
         {
           charpos = XMARKER (position)->charpos;
@@ -752,7 +752,7 @@ DEFUN ("buffer-has-markers-at", Fbuffer_has_markers_at, Sbuffer_has_markers_at,
   register struct Lisp_Marker *tail;
   register ptrdiff_t charpos;
 
-  charpos = clip_to_bounds (BEG, XINT (position), Z);
+  charpos = clip_to_bounds (BEG, XFIXNUM (position), Z);
 
   for (tail = BUF_MARKERS (current_buffer); tail; tail = tail->next)
     if (tail->charpos == charpos)
diff --git a/src/menu.c b/src/menu.c
index 1d0ba3c258f..eac82017d3e 100644
--- a/src/menu.c
+++ b/src/menu.c
@@ -134,11 +134,11 @@ restore_menu_items (Lisp_Object saved)
   menu_items_inuse = (! NILP (menu_items) ? Qt : Qnil);
   menu_items_allocated = (VECTORP (menu_items) ? ASIZE (menu_items) : 0);
   saved = XCDR (saved);
-  menu_items_used = XINT (XCAR (saved));
+  menu_items_used = XFIXNUM (XCAR (saved));
   saved = XCDR (saved);
-  menu_items_n_panes = XINT (XCAR (saved));
+  menu_items_n_panes = XFIXNUM (XCAR (saved));
   saved = XCDR (saved);
-  menu_items_submenu_depth = XINT (XCAR (saved));
+  menu_items_submenu_depth = XFIXNUM (XCAR (saved));
 }
 
 /* Push the whole state of menu_items processing onto the specpdl.
@@ -532,7 +532,7 @@ parse_single_submenu (Lisp_Object item_key, Lisp_Object item_name,
   USE_SAFE_ALLOCA;
 
   length = Flength (maps);
-  len = XINT (length);
+  len = XFIXNUM (length);
 
   /* Convert the list MAPS into a vector MAPVEC.  */
   SAFE_ALLOCA_LISP (mapvec, len);
@@ -1079,7 +1079,7 @@ into menu items.  */)
   if (!FRAME_LIVE_P (f))
     return Qnil;
 
-  pixel_to_glyph_coords (f, XINT (x), XINT (y), &col, &row, NULL, 1);
+  pixel_to_glyph_coords (f, XFIXNUM (x), XFIXNUM (y), &col, &row, NULL, 1);
   if (0 <= row && row < FRAME_MENU_BAR_LINES (f))
     {
       Lisp_Object items, item;
@@ -1099,10 +1099,10 @@ into menu items.  */)
           pos = AREF (items, i + 3);
           if (NILP (str))
             return item;
-          if (XINT (pos) <= col
+          if (XFIXNUM (pos) <= col
               /* We use <= so the blank between 2 items on a TTY is
                  considered part of the previous item.  */
-              && col <= XINT (pos) + menu_item_width (SDATA (str)))
+              && col <= XFIXNUM (pos) + menu_item_width (SDATA (str)))
             {
               item = AREF (items, i);
               return item;
@@ -1268,8 +1268,8 @@ x_popup_menu_1 (Lisp_Object position, Lisp_Object menu)
                            ? (EMACS_INT) INT_MIN - ypos
                            : MOST_NEGATIVE_FIXNUM),
                           INT_MAX - ypos);
-    xpos += XINT (x);
-    ypos += XINT (y);
+    xpos += XFIXNUM (x);
+    ypos += XFIXNUM (y);
 
     XSETFRAME (Vmenu_updating_frame, f);
   }
@@ -1309,7 +1309,7 @@ x_popup_menu_1 (Lisp_Object position, Lisp_Object menu)
   else if (CONSP (menu) && KEYMAPP (XCAR (menu)))
     {
       /* We were given a list of keymaps.  */
-      EMACS_INT nmaps = XFASTINT (Flength (menu));
+      EMACS_INT nmaps = XFIXNAT (Flength (menu));
       Lisp_Object *maps;
       ptrdiff_t i;
       USE_SAFE_ALLOCA;
diff --git a/src/minibuf.c b/src/minibuf.c
index a6d03b2cb50..751d6bda168 100644
--- a/src/minibuf.c
+++ b/src/minibuf.c
@@ -157,7 +157,7 @@ string_to_object (Lisp_Object val, Lisp_Object defalt)
     }
 
   expr_and_pos = Fread_from_string (val, Qnil, Qnil);
-  pos = XINT (Fcdr (expr_and_pos));
+  pos = XFIXNUM (Fcdr (expr_and_pos));
   if (pos != SCHARS (val))
     {
       /* Ignore trailing whitespace; any other trailing junk
@@ -198,7 +198,7 @@ read_minibuf_noninteractive (Lisp_Object map, Lisp_Object initial,
 
   /* Check, whether we need to suppress echoing.  */
   if (CHARACTERP (Vread_hide_char))
-    hide_char = XFASTINT (Vread_hide_char);
+    hide_char = XFIXNAT (Vread_hide_char);
 
   /* Manipulate tty.  */
   if (hide_char)
@@ -299,7 +299,7 @@ Return (point-min) if current buffer is not a minibuffer.  */)
 
   end = Ffield_end (beg, Qnil, Qnil);
 
-  if (XINT (end) == ZV && NILP (Fget_char_property (beg, Qfield, Qnil)))
+  if (XFIXNUM (end) == ZV && NILP (Fget_char_property (beg, Qfield, Qnil)))
     return beg;
   else
     return end;
@@ -311,7 +311,7 @@ DEFUN ("minibuffer-contents", Fminibuffer_contents,
 If the current buffer is not a minibuffer, return its entire contents.  */)
   (void)
 {
-  ptrdiff_t prompt_end = XINT (Fminibuffer_prompt_end ());
+  ptrdiff_t prompt_end = XFIXNUM (Fminibuffer_prompt_end ());
   return make_buffer_string (prompt_end, ZV, 1);
 }
 
@@ -321,7 +321,7 @@ DEFUN ("minibuffer-contents-no-properties", Fminibuffer_contents_no_properties,
 If the current buffer is not a minibuffer, return its entire contents.  */)
   (void)
 {
-  ptrdiff_t prompt_end = XINT (Fminibuffer_prompt_end ());
+  ptrdiff_t prompt_end = XFIXNUM (Fminibuffer_prompt_end ());
   return make_buffer_string (prompt_end, ZV, 0);
 }
 
@@ -395,11 +395,11 @@ read_minibuf (Lisp_Object map, Lisp_Object initial, Lisp_Object prompt,
             {
               CHECK_FIXNUM (backup_n);
               /* Convert to distance from end of input.  */
-              if (XINT (backup_n) < 1)
+              if (XFIXNUM (backup_n) < 1)
                 /* A number too small means the beginning of the string.  */
                 pos =  - SCHARS (initial);
               else
-                pos = XINT (backup_n) - 1 - SCHARS (initial);
+                pos = XFIXNUM (backup_n) - 1 - SCHARS (initial);
             }
         }
       else
@@ -788,12 +788,12 @@ read_minibuf_unwind (void)
   /* Restore prompt, etc, from outer minibuffer level.  */
   Lisp_Object key_vec = Fcar (minibuf_save_list);
   eassert (VECTORP (key_vec));
-  this_command_key_count = XFASTINT (Flength (key_vec));
+  this_command_key_count = XFIXNAT (Flength (key_vec));
   this_command_keys = key_vec;
   minibuf_save_list = Fcdr (minibuf_save_list);
   minibuf_prompt = Fcar (minibuf_save_list);
   minibuf_save_list = Fcdr (minibuf_save_list);
-  minibuf_prompt_width = XFASTINT (Fcar (minibuf_save_list));
+  minibuf_prompt_width = XFIXNAT (Fcar (minibuf_save_list));
   minibuf_save_list = Fcdr (minibuf_save_list);
   Vhelp_form = Fcar (minibuf_save_list);
   minibuf_save_list = Fcdr (minibuf_save_list);
@@ -1327,7 +1327,7 @@ is used to further constrain the set of candidates.  */)
                                       eltstring, zero,
                                       make_fixnum (compare),
                                       completion_ignore_case ? Qt : Qnil);
-              matchsize = EQ (tem, Qt) ? compare : eabs (XINT (tem)) - 1;
+              matchsize = EQ (tem, Qt) ? compare : eabs (XFIXNUM (tem)) - 1;
 
               if (completion_ignore_case)
                 {
diff --git a/src/msdos.c b/src/msdos.c
index 4f38b1de7d3..4031c579df8 100644
--- a/src/msdos.c
+++ b/src/msdos.c
@@ -224,7 +224,7 @@ them.  This happens with wheeled mice on Windows 9X, for example.  */)
   int n;
 
   CHECK_FIXNUM (nbuttons);
-  n = XINT (nbuttons);
+  n = XFIXNUM (nbuttons);
   if (n < 2 || n > 3)
     xsignal2 (Qargs_out_of_range,
               build_string ("only 2 or 3 mouse buttons are supported"),
@@ -540,7 +540,7 @@ dos_set_window_size (int *rows, int *cols)
                                     *rows, *cols), Qnil));
 
   if (FIXNUMP (video_mode)
-      && (video_mode_value = XINT (video_mode)) > 0)
+      && (video_mode_value = XFIXNUM (video_mode)) > 0)
     {
       regs.x.ax = video_mode_value;
       int86 (0x10, &regs, &regs);
@@ -746,7 +746,7 @@ IT_set_cursor_type (struct frame *f, Lisp_Object cursor_type)
         {
           /* Feature: negative WIDTH means cursor at the top
              of the character cell, zero means invisible cursor.  */
-          width = XINT (bar_parms);
+          width = XFIXNUM (bar_parms);
           msdos_set_cursor_shape (f, width >= 0 ? DEFAULT_CURSOR_START : 0,
                                   width);
         }
@@ -754,9 +754,9 @@ IT_set_cursor_type (struct frame *f, Lisp_Object cursor_type)
                && FIXNUMP (XCAR (bar_parms))
                && FIXNUMP (XCDR (bar_parms)))
         {
-          int start_line = XINT (XCDR (bar_parms));
+          int start_line = XFIXNUM (XCDR (bar_parms));
 
-          width = XINT (XCAR (bar_parms));
+          width = XFIXNUM (XCAR (bar_parms));
           msdos_set_cursor_shape (f, start_line, width);
         }
     }
@@ -1564,7 +1564,7 @@ void
 IT_set_frame_parameters (struct frame *f, Lisp_Object alist)
 {
   Lisp_Object tail;
-  int i, j, length = XINT (Flength (alist));
+  int i, j, length = XFIXNUM (Flength (alist));
   Lisp_Object *parms
     = (Lisp_Object *) alloca (length * word_size);
   Lisp_Object *values
diff --git a/src/print.c b/src/print.c
index 2b1d1fec726..998ff2dc0c6 100644
--- a/src/print.c
+++ b/src/print.c
@@ -261,7 +261,7 @@ printchar_to_stream (unsigned int ch, FILE *stream)
           break;
       if (! (i < n))
         break;
-      ch = XFASTINT (AREF (dv, i));
+      ch = XFIXNAT (AREF (dv, i));
     }
 }
 
@@ -522,7 +522,7 @@ PRINTCHARFUN defaults to the value of `standard-output' (which see).  */)
     printcharfun = Vstandard_output;
   CHECK_FIXNUM (character);
   PRINTPREPARE;
-  printchar (XINT (character), printcharfun);
+  printchar (XFIXNUM (character), printcharfun);
   PRINTFINISH;
   return character;
 }
@@ -772,7 +772,7 @@ to make it write to the debugging output.  */)
   (Lisp_Object character)
 {
   CHECK_FIXNUM (character);
-  printchar_to_stream (XINT (character), stderr);
+  printchar_to_stream (XFIXNUM (character), stderr);
   return character;
 }
 
@@ -1408,8 +1408,8 @@ print_vectorlike (Lisp_Object obj, Lisp_Object printcharfun, bool escapeflag,
            Negative values of print-length are invalid.  Treat them
            like a print-length of nil.  */
         if (FIXNATP (Vprint_length)
-            && XFASTINT (Vprint_length) < size_in_bytes)
-          size_in_bytes = XFASTINT (Vprint_length);
+            && XFIXNAT (Vprint_length) < size_in_bytes)
+          size_in_bytes = XFIXNAT (Vprint_length);
 
         for (ptrdiff_t i = 0; i < size_in_bytes; i++)
           {
@@ -1521,8 +1521,8 @@ print_vectorlike (Lisp_Object obj, Lisp_Object printcharfun, bool escapeflag,
         ptrdiff_t size = real_size;
 
         /* Don't print more elements than the specified maximum.  */
-        if (FIXNATP (Vprint_length) && XFASTINT (Vprint_length) < size)
-          size = XFASTINT (Vprint_length);
+        if (FIXNATP (Vprint_length) && XFIXNAT (Vprint_length) < size)
+          size = XFIXNAT (Vprint_length);
 
         printchar ('(', printcharfun);
         for (ptrdiff_t i = 0; i < size; i++)
@@ -1652,8 +1652,8 @@ print_vectorlike (Lisp_Object obj, Lisp_Object printcharfun, bool escapeflag,
 
         /* Don't print more elements than the specified maximum.  */
         ptrdiff_t n
-          = (FIXNATP (Vprint_length) && XFASTINT (Vprint_length) < size
-             ? XFASTINT (Vprint_length) : size);
+          = (FIXNATP (Vprint_length) && XFIXNAT (Vprint_length) < size
+             ? XFIXNAT (Vprint_length) : size);
 
         print_c_string ("#s(", printcharfun);
         for (ptrdiff_t i = 0; i < n; i ++)
@@ -1714,8 +1714,8 @@ print_vectorlike (Lisp_Object obj, Lisp_Object printcharfun, bool escapeflag,
 
         /* Don't print more elements than the specified maximum.  */
         if (FIXNATP (Vprint_length)
-            && XFASTINT (Vprint_length) < size)
-          size = XFASTINT (Vprint_length);
+            && XFIXNAT (Vprint_length) < size)
+          size = XFIXNAT (Vprint_length);
 
         for (int i = idx; i < size; i++)
           {
@@ -1807,7 +1807,7 @@ print_object (Lisp_Object obj, Lisp_Object printcharfun, bool escapeflag)
       Lisp_Object num = Fgethash (obj, Vprint_number_table, Qnil);
       if (FIXNUMP (num))
         {
-          EMACS_INT n = XINT (num);
+          EMACS_INT n = XFIXNUM (num);
           if (n < 0)
             { /* Add a prefix #n= if OBJ has not yet been printed;
                  that is, its status field is nil.  */
@@ -1832,7 +1832,7 @@ print_object (Lisp_Object obj, Lisp_Object printcharfun, bool escapeflag)
     {
     case_Lisp_Int:
       {
-        int len = sprintf (buf, "%"pI"d", XINT (obj));
+        int len = sprintf (buf, "%"pI"d", XFIXNUM (obj));
         strout (buf, len, len, printcharfun);
       }
       break;
@@ -2008,7 +2008,7 @@ print_object (Lisp_Object obj, Lisp_Object printcharfun, bool escapeflag)
     case Lisp_Cons:
       /* If deeper than spec'd depth, print placeholder.  */
       if (FIXNUMP (Vprint_level)
-          && print_depth > XINT (Vprint_level))
+          && print_depth > XFIXNUM (Vprint_level))
         print_c_string ("...", printcharfun);
       else if (print_quoted && CONSP (XCDR (obj)) && NILP (XCDR (XCDR (obj)))
                && EQ (XCAR (obj), Qquote))
@@ -2050,7 +2050,7 @@ print_object (Lisp_Object obj, Lisp_Object printcharfun, bool escapeflag)
           /* Negative values of print-length are invalid in CL.
              Treat them like nil, as CMUCL does.  */
           printmax_t print_length = (FIXNATP (Vprint_length)
-                                     ? XFASTINT (Vprint_length)
+                                     ? XFIXNAT (Vprint_length)
                                      : TYPE_MAXIMUM (printmax_t));
 
           printmax_t i = 0;
diff --git a/src/process.c b/src/process.c
index 350cfe0f80b..698a2c3ac02 100644
--- a/src/process.c
+++ b/src/process.c
@@ -747,7 +747,7 @@ status_message (struct Lisp_Process *p)
     {
       char const *signame;
       synchronize_system_messages_locale ();
-      signame = strsignal (XFASTINT (code));
+      signame = strsignal (XFIXNAT (code));
       if (signame == 0)
         string = build_string ("unknown");
       else
@@ -769,10 +769,10 @@ status_message (struct Lisp_Process *p)
   else if (EQ (symbol, Qexit))
     {
       if (NETCONN1_P (p))
-        return build_string (XFASTINT (code) == 0
+        return build_string (XFIXNAT (code) == 0
                              ? "deleted\n"
                              : "connection broken by remote peer\n");
-      if (XFASTINT (code) == 0)
+      if (XFIXNAT (code) == 0)
         return build_string ("finished\n");
       AUTO_STRING (prefix, "exited abnormally with code ");
       string = Fnumber_to_string (code);
@@ -1383,7 +1383,7 @@ nil otherwise.  */)
   if (NETCONN_P (process)
       || XPROCESS (process)->infd < 0
       || (set_window_size (XPROCESS (process)->infd,
-                           XINT (height), XINT (width))
+                           XFIXNUM (height), XFIXNUM (width))
           < 0))
     return Qnil;
   else
@@ -1589,7 +1589,7 @@ Return nil if format of ADDRESS is invalid.  */)
 
           if (nargs <= 5         /* IPv4 */
               && i < 4           /* host, not port */
-              && XINT (p->contents[i]) > 255)
+              && XFIXNUM (p->contents[i]) > 255)
             return Qnil;
 
           args[i + 1] = p->contents[i];
@@ -1789,7 +1789,7 @@ usage: (make-process &rest ARGS)  */)
       val = Vcoding_system_for_read;
     if (NILP (val))
       {
-        ptrdiff_t nargs2 = 3 + XINT (Flength (command));
+        ptrdiff_t nargs2 = 3 + XFIXNUM (Flength (command));
         Lisp_Object tem2;
         SAFE_ALLOCA_LISP (args2, nargs2);
         ptrdiff_t i = 0;
@@ -1819,7 +1819,7 @@ usage: (make-process &rest ARGS)  */)
       {
         if (EQ (coding_systems, Qt))
           {
-            ptrdiff_t nargs2 = 3 + XINT (Flength (command));
+            ptrdiff_t nargs2 = 3 + XFIXNUM (Flength (command));
             Lisp_Object tem2;
             SAFE_ALLOCA_LISP (args2, nargs2);
             ptrdiff_t i = 0;
@@ -2567,7 +2567,7 @@ static Lisp_Object
 conv_addrinfo_to_lisp (struct addrinfo *res)
 {
   Lisp_Object protocol = make_fixnum (res->ai_protocol);
-  eassert (XINT (protocol) == res->ai_protocol);
+  eassert (XFIXNUM (protocol) == res->ai_protocol);
   return Fcons (protocol, conv_sockaddr_to_lisp (res->ai_addr, res->ai_addrlen));
 }
 
@@ -2609,7 +2609,7 @@ get_lisp_to_sockaddr_size (Lisp_Object address, int *familyp)
       p = XVECTOR (XCDR (address));
       if (MAX_ALLOCA - sizeof sa->sa_family < p->header.size)
         return 0;
-      *familyp = XINT (XCAR (address));
+      *familyp = XFIXNUM (XCAR (address));
       return p->header.size + sizeof (sa->sa_family);
     }
   return 0;
@@ -2639,7 +2639,7 @@ conv_lisp_to_sockaddr (int family, Lisp_Object address, struct sockaddr *sa, int
         {
           DECLARE_POINTER_ALIAS (sin, struct sockaddr_in, sa);
           len = sizeof (sin->sin_addr) + 1;
-          hostport = XINT (p->contents[--len]);
+          hostport = XFIXNUM (p->contents[--len]);
           sin->sin_port = htons (hostport);
           cp = (unsigned char *)&sin->sin_addr;
           sa->sa_family = family;
@@ -2650,12 +2650,12 @@ conv_lisp_to_sockaddr (int family, Lisp_Object address, struct sockaddr *sa, int
           DECLARE_POINTER_ALIAS (sin6, struct sockaddr_in6, sa);
           DECLARE_POINTER_ALIAS (ip6, uint16_t, &sin6->sin6_addr);
           len = sizeof (sin6->sin6_addr) / 2 + 1;
-          hostport = XINT (p->contents[--len]);
+          hostport = XFIXNUM (p->contents[--len]);
           sin6->sin6_port = htons (hostport);
           for (i = 0; i < len; i++)
             if (FIXNUMP (p->contents[i]))
               {
-                int j = XFASTINT (p->contents[i]) & 0xffff;
+                int j = XFIXNAT (p->contents[i]) & 0xffff;
                 ip6[i] = ntohs (j);
               }
           sa->sa_family = family;
@@ -2687,7 +2687,7 @@ conv_lisp_to_sockaddr (int family, Lisp_Object address, struct sockaddr *sa, int
 
   for (i = 0; i < len; i++)
     if (FIXNUMP (p->contents[i]))
-      *cp++ = XFASTINT (p->contents[i]) & 0xff;
+      *cp++ = XFIXNAT (p->contents[i]) & 0xff;
 }
 
 #ifdef DATAGRAM_SOCKETS
@@ -2819,7 +2819,7 @@ set_socket_option (int s, Lisp_Object opt, Lisp_Object val)
       {
         int optval;
         if (TYPE_RANGED_FIXNUMP (int, val))
-          optval = XINT (val);
+          optval = XFIXNUM (val);
         else
           error ("Bad option value for %s", name);
         ret = setsockopt (s, sopt->optlevel, sopt->optnum,
@@ -2858,7 +2858,7 @@ set_socket_option (int s, Lisp_Object opt, Lisp_Object val)
         linger.l_onoff = 1;
         linger.l_linger = 0;
         if (TYPE_RANGED_FIXNUMP (int, val))
-          linger.l_linger = XINT (val);
+          linger.l_linger = XFIXNUM (val);
         else
           linger.l_onoff = NILP (val) ? 0 : 1;
         ret = setsockopt (s, sopt->optlevel, sopt->optnum,
@@ -3357,7 +3357,7 @@ connect_network_socket (Lisp_Object proc, Lisp_Object addrinfos,
     {
       Lisp_Object addrinfo = XCAR (addrinfos);
       addrinfos = XCDR (addrinfos);
-      int protocol = XINT (XCAR (addrinfo));
+      int protocol = XFIXNUM (XCAR (addrinfo));
       Lisp_Object ip_address = XCDR (addrinfo);
 
 #ifdef WINDOWSNT
@@ -3941,7 +3941,7 @@ usage: (make-network-process &rest ARGS)  */)
   else if (EQ (tem, Qipv4))
     family = AF_INET;
   else if (TYPE_RANGED_FIXNUMP (int, tem))
-    family = XINT (tem);
+    family = XFIXNUM (tem);
   else
     error ("Unknown address family");
 
@@ -4010,7 +4010,7 @@ usage: (make-network-process &rest ARGS)  */)
       else if (FIXNUMP (service))
         {
           portstring = portbuf;
-          portstringlen = sprintf (portbuf, "%"pI"d", XINT (service));
+          portstringlen = sprintf (portbuf, "%"pI"d", XFIXNUM (service));
         }
       else
         {
@@ -4096,7 +4096,7 @@ usage: (make-network-process &rest ARGS)  */)
   if (EQ (service, Qt))
     port = 0;
   else if (FIXNUMP (service))
-    port = XINT (service);
+    port = XFIXNUM (service);
   else
     {
       CHECK_STRING (service);
@@ -4170,7 +4170,7 @@ usage: (make-network-process &rest ARGS)  */)
   /* :server QLEN */
   p->is_server = !NILP (server);
   if (TYPE_RANGED_FIXNUMP (int, server))
-    p->backlog = XINT (server);
+    p->backlog = XFIXNUM (server);
 
   /* :nowait BOOL */
   if (!p->is_server && socktype != SOCK_DGRAM && nowait)
@@ -4627,11 +4627,11 @@ is nil, from any process) before the timeout expired.  */)
     { /* Obsolete calling convention using integers rather than floats.  */
       CHECK_FIXNUM (millisec);
       if (NILP (seconds))
-        seconds = make_float (XINT (millisec) / 1000.0);
+        seconds = make_float (XFIXNUM (millisec) / 1000.0);
       else
         {
           CHECK_FIXNUM (seconds);
-          seconds = make_float (XINT (millisec) / 1000.0 + XINT (seconds));
+          seconds = make_float (XFIXNUM (millisec) / 1000.0 + XFIXNUM (seconds));
         }
     }
 
@@ -4642,9 +4642,9 @@ is nil, from any process) before the timeout expired.  */)
     {
       if (FIXNUMP (seconds))
         {
-          if (XINT (seconds) > 0)
+          if (XFIXNUM (seconds) > 0)
             {
-              secs = XINT (seconds);
+              secs = XFIXNUM (seconds);
               nsecs = 0;
             }
         }
@@ -6196,8 +6196,8 @@ write_queue_pop (struct Lisp_Process *p, Lisp_Object *obj,
   *obj = XCAR (entry);
   offset_length = XCDR (entry);
 
-  *len = XINT (XCDR (offset_length));
-  offset = XINT (XCAR (offset_length));
+  *len = XFIXNUM (XCDR (offset_length));
+  offset = XFIXNUM (XCAR (offset_length));
   *buf = SSDATA (*obj) + offset;
 
   return 1;
@@ -6451,11 +6451,11 @@ set up yet, this function will block until socket setup has completed.  */)
 
   validate_region (&start, &end);
 
-  start_byte = CHAR_TO_BYTE (XINT (start));
-  end_byte = CHAR_TO_BYTE (XINT (end));
+  start_byte = CHAR_TO_BYTE (XFIXNUM (start));
+  end_byte = CHAR_TO_BYTE (XFIXNUM (end));
 
-  if (XINT (start) < GPT && XINT (end) > GPT)
-    move_gap_both (XINT (start), start_byte);
+  if (XFIXNUM (start) < GPT && XFIXNUM (end) > GPT)
+    move_gap_both (XFIXNUM (start), start_byte);
 
   if (NETCONN_P (proc))
     wait_while_connecting (proc);
@@ -6864,7 +6864,7 @@ SIGCODE may be an integer, or a symbol whose name is a signal name.  */)
   if (FIXNUMP (sigcode))
     {
       CHECK_TYPE_RANGED_INTEGER (int, sigcode);
-      signo = XINT (sigcode);
+      signo = XFIXNUM (sigcode);
     }
   else
     {
@@ -7052,7 +7052,7 @@ handle_child_signal (int sig)
         {
           pid_t deleted_pid;
           if (FIXNUMP (xpid))
-            deleted_pid = XINT (xpid);
+            deleted_pid = XFIXNUM (xpid);
           else
             deleted_pid = XFLOAT_DATA (xpid);
           if (child_status_changed (deleted_pid, 0, 0))
diff --git a/src/profiler.c b/src/profiler.c
index 4c7812aa778..7330f8861fc 100644
--- a/src/profiler.c
+++ b/src/profiler.c
@@ -80,12 +80,12 @@ static EMACS_INT approximate_median (log_t *log,
 {
   eassert (size > 0);
   if (size < 2)
-    return XINT (HASH_VALUE (log, start));
+    return XFIXNUM (HASH_VALUE (log, start));
   if (size < 3)
     /* Not an actual median, but better for our application than
        choosing either of the two numbers.  */
-    return ((XINT (HASH_VALUE (log, start))
-             + XINT (HASH_VALUE (log, start + 1)))
+    return ((XFIXNUM (HASH_VALUE (log, start))
+             + XFIXNUM (HASH_VALUE (log, start + 1)))
             / 2);
   else
     {
@@ -110,7 +110,7 @@ static void evict_lower_half (log_t *log)
   for (i = 0; i < size; i++)
     /* Evict not only values smaller but also values equal to the median,
        so as to make sure we evict something no matter what.  */
-    if (XINT (HASH_VALUE (log, i)) <= median)
+    if (XFIXNUM (HASH_VALUE (log, i)) <= median)
       {
         Lisp_Object key = HASH_KEY (log, i);
         { /* FIXME: we could make this more efficient.  */
@@ -156,7 +156,7 @@ record_backtrace (log_t *log, EMACS_INT count)
     ptrdiff_t j = hash_lookup (log, backtrace, &hash);
     if (j >= 0)
       {
-        EMACS_INT old_val = XINT (HASH_VALUE (log, j));
+        EMACS_INT old_val = XFIXNUM (HASH_VALUE (log, j));
         EMACS_INT new_val = saturated_add (old_val, count);
         set_hash_value_slot (log, j, make_fixnum (new_val));
       }
@@ -273,7 +273,7 @@ setup_cpu_timer (Lisp_Object sampling_interval)
                           : EMACS_INT_MAX)))
     return -1;
 
-  current_sampling_interval = XINT (sampling_interval);
+  current_sampling_interval = XFIXNUM (sampling_interval);
   interval = make_timespec (current_sampling_interval / billion,
                             current_sampling_interval % billion);
   emacs_sigaction_init (&action, deliver_profiler_signal);
diff --git a/src/search.c b/src/search.c
index 72374c8b9b4..5385c890f98 100644
--- a/src/search.c
+++ b/src/search.c
@@ -402,7 +402,7 @@ string_match_1 (Lisp_Object regexp, Lisp_Object string, Lisp_Object start,
       ptrdiff_t len = SCHARS (string);
 
       CHECK_FIXNUM (start);
-      pos = XINT (start);
+      pos = XFIXNUM (start);
       if (pos < 0 && -pos <= len)
         pos = len + pos;
       else if (0 > pos || pos > len)
@@ -1037,7 +1037,7 @@ search_command (Lisp_Object string, Lisp_Object bound, Lisp_Object noerror,
   if (!NILP (count))
     {
       CHECK_FIXNUM (count);
-      n *= XINT (count);
+      n *= XFIXNUM (count);
     }
 
   CHECK_STRING (string);
@@ -1051,7 +1051,7 @@ search_command (Lisp_Object string, Lisp_Object bound, Lisp_Object noerror,
   else
     {
       CHECK_FIXNUM_COERCE_MARKER (bound);
-      lim = XINT (bound);
+      lim = XFIXNUM (bound);
       if (n > 0 ? lim < PT : lim > PT)
         error ("Invalid search bound (wrong side of point)");
       if (lim > ZV)
@@ -1153,7 +1153,7 @@ do						\
         Lisp_Object temp;                       \
         temp = Faref (trt, make_fixnum (d));    \
         if (FIXNUMP (temp))                     \
-          out = XINT (temp);                    \
+          out = XFIXNUM (temp);                 \
         else                                    \
           out = d;                              \
       }                                         \
@@ -2421,9 +2421,9 @@ since only regular expressions have distinguished subexpressions.  */)
   else
     {
       CHECK_FIXNUM (subexp);
-      if (! (0 <= XINT (subexp) && XINT (subexp) < search_regs.num_regs))
+      if (! (0 <= XFIXNUM (subexp) && XFIXNUM (subexp) < search_regs.num_regs))
         args_out_of_range (subexp, make_fixnum (search_regs.num_regs));
-      sub = XINT (subexp);
+      sub = XFIXNUM (subexp);
     }
 
   if (NILP (string))
@@ -2810,7 +2810,7 @@ match_limit (Lisp_Object num, bool beginningp)
   EMACS_INT n;
 
   CHECK_FIXNUM (num);
-  n = XINT (num);
+  n = XFIXNUM (num);
   if (n < 0)
     args_out_of_range (num, make_fixnum (0));
   if (search_regs.num_regs <= 0)
@@ -2989,7 +2989,7 @@ If optional arg RESEAT is non-nil, make markers on LIST point nowhere.  */)
 
   /* Allocate registers if they don't already exist.  */
   {
-    EMACS_INT length = XFASTINT (Flength (list)) / 2;
+    EMACS_INT length = XFIXNAT (Flength (list)) / 2;
 
     if (length > search_regs.num_regs)
       {
@@ -3055,15 +3055,15 @@ If optional arg RESEAT is non-nil, make markers on LIST point nowhere.  */)
               XSETFASTINT (marker, 0);
 
             CHECK_FIXNUM_COERCE_MARKER (marker);
-            if ((XINT (from) < 0
-                 ? TYPE_MINIMUM (regoff_t) <= XINT (from)
-                 : XINT (from) <= TYPE_MAXIMUM (regoff_t))
-                && (XINT (marker) < 0
-                    ? TYPE_MINIMUM (regoff_t) <= XINT (marker)
-                    : XINT (marker) <= TYPE_MAXIMUM (regoff_t)))
+            if ((XFIXNUM (from) < 0
+                 ? TYPE_MINIMUM (regoff_t) <= XFIXNUM (from)
+                 : XFIXNUM (from) <= TYPE_MAXIMUM (regoff_t))
+                && (XFIXNUM (marker) < 0
+                    ? TYPE_MINIMUM (regoff_t) <= XFIXNUM (marker)
+                    : XFIXNUM (marker) <= TYPE_MAXIMUM (regoff_t)))
               {
-                search_regs.start[i] = XINT (from);
-                search_regs.end[i] = XINT (marker);
+                search_regs.start[i] = XFIXNUM (from);
+                search_regs.end[i] = XFIXNUM (marker);
               }
             else
               {
diff --git a/src/sound.c b/src/sound.c
index ea57dc43bcb..6f15f5dab6d 100644
--- a/src/sound.c
+++ b/src/sound.c
@@ -387,7 +387,7 @@ parse_sound (Lisp_Object sound, Lisp_Object *attrs)
     {
       if (FIXNUMP (attrs[SOUND_VOLUME]))
         {
-          EMACS_INT volume = XINT (attrs[SOUND_VOLUME]);
+          EMACS_INT volume = XFIXNUM (attrs[SOUND_VOLUME]);
           if (! (0 <= volume && volume <= 100))
             return 0;
         }
@@ -1401,7 +1401,7 @@ Internal use only, use `play-sound' instead.  */)
   current_sound_device->file = attrs[SOUND_DEVICE];
 
   if (FIXNUMP (attrs[SOUND_VOLUME]))
-    current_sound_device->volume = XFASTINT (attrs[SOUND_VOLUME]);
+    current_sound_device->volume = XFIXNAT (attrs[SOUND_VOLUME]);
   else if (FLOATP (attrs[SOUND_VOLUME]))
     current_sound_device->volume = XFLOAT_DATA (attrs[SOUND_VOLUME]) * 100;
 
@@ -1425,7 +1425,7 @@ Internal use only, use `play-sound' instead.  */)
   file = ENCODE_FILE (file);
   if (FIXNUMP (attrs[SOUND_VOLUME]))
     {
-      ui_volume_tmp = XFASTINT (attrs[SOUND_VOLUME]);
+      ui_volume_tmp = XFIXNAT (attrs[SOUND_VOLUME]);
     }
   else if (FLOATP (attrs[SOUND_VOLUME]))
     {
diff --git a/src/syntax.c b/src/syntax.c
index 8434f47a5f7..ee83ed070a0 100644
--- a/src/syntax.c
+++ b/src/syntax.c
@@ -615,7 +615,7 @@ find_defun_start (ptrdiff_t pos, ptrdiff_t pos_byte)
       Lisp_Object boc = Fnth (make_fixnum (8), ppss);
       if (FIXED_OR_FLOATP (boc))
         {
-          find_start_value = XINT (boc);
+          find_start_value = XFIXNUM (boc);
           find_start_value_byte = CHAR_TO_BYTE (find_start_value);
         }
       else
@@ -952,7 +952,7 @@ back_comment (ptrdiff_t from, ptrdiff_t from_byte, ptrdiff_t stop,
             {
               adjusted = true;
               find_start_value
-                = CONSP (state.levelstarts) ? XINT (XCAR (state.levelstarts))
+                = CONSP (state.levelstarts) ? XFIXNUM (XCAR (state.levelstarts))
                 : state.thislevelstart >= 0 ? state.thislevelstart
                 : find_start_value;
               find_start_value_byte = CHAR_TO_BYTE (find_start_value);
@@ -1118,7 +1118,7 @@ this is probably the wrong function to use, because it can't take
 {
   int char_int;
   CHECK_CHARACTER (character);
-  char_int = XINT (character);
+  char_int = XFIXNUM (character);
   SETUP_BUFFER_SYNTAX_TABLE ();
   return make_fixnum (syntax_code_spec[SYNTAX (char_int)]);
 }
@@ -1130,7 +1130,7 @@ DEFUN ("matching-paren", Fmatching_paren, Smatching_paren, 1, 1, 0,
   int char_int;
   enum syntaxcode code;
   CHECK_CHARACTER (character);
-  char_int = XINT (character);
+  char_int = XFIXNUM (character);
   SETUP_BUFFER_SYNTAX_TABLE ();
   code = SYNTAX (char_int);
   if (code == Sopen || code == Sclose)
@@ -1165,7 +1165,7 @@ the value of a `syntax-table' text property.  */)
       int len;
       int character = STRING_CHAR_AND_LENGTH (p, len);
       XSETINT (match, character);
-      if (XFASTINT (match) == ' ')
+      if (XFIXNAT (match) == ' ')
         match = Qnil;
       p += len;
     }
@@ -1277,7 +1277,7 @@ usage: (modify-syntax-entry CHAR NEWENTRY &optional SYNTAX-TABLE)  */)
   if (CONSP (c))
     SET_RAW_SYNTAX_ENTRY_RANGE (syntax_table, c, newentry);
   else
-    SET_RAW_SYNTAX_ENTRY (syntax_table, XINT (c), newentry);
+    SET_RAW_SYNTAX_ENTRY (syntax_table, XFIXNUM (c), newentry);
 
   /* We clear the regexp cache, since character classes can now have
      different values from those in the compiled regexps.*/
@@ -1325,7 +1325,7 @@ DEFUN ("internal-describe-syntax-value", Finternal_describe_syntax_value,
       return syntax;
     }
 
-  syntax_code = XINT (first) & INT_MAX;
+  syntax_code = XFIXNUM (first) & INT_MAX;
   code = syntax_code & 0377;
   start1 = SYNTAX_FLAGS_COMSTART_FIRST (syntax_code);
   start2 = SYNTAX_FLAGS_COMSTART_SECOND (syntax_code);
@@ -1348,7 +1348,7 @@ DEFUN ("internal-describe-syntax-value", Finternal_describe_syntax_value,
   if (NILP (match_lisp))
     insert (" ", 1);
   else
-    insert_char (XINT (match_lisp));
+    insert_char (XFIXNUM (match_lisp));
 
   if (start1)
     insert ("1", 1);
@@ -1413,7 +1413,7 @@ DEFUN ("internal-describe-syntax-value", Finternal_describe_syntax_value,
   if (!NILP (match_lisp))
     {
       insert_string (", matches ");
-      insert_char (XINT (match_lisp));
+      insert_char (XFIXNUM (match_lisp));
     }
 
   if (start1)
@@ -1481,9 +1481,9 @@ scan_words (ptrdiff_t from, EMACS_INT count)
       if (! NILP (Ffboundp (func)))
         {
           pos = call2 (func, make_fixnum (from - 1), make_fixnum (end));
-          if (FIXNUMP (pos) && from < XINT (pos) && XINT (pos) <= ZV)
+          if (FIXNUMP (pos) && from < XFIXNUM (pos) && XFIXNUM (pos) <= ZV)
             {
-              from = XINT (pos);
+              from = XFIXNUM (pos);
               from_byte = CHAR_TO_BYTE (from);
             }
         }
@@ -1530,9 +1530,9 @@ scan_words (ptrdiff_t from, EMACS_INT count)
       if (! NILP (Ffboundp (func)))
         {
           pos = call2 (func, make_fixnum (from), make_fixnum (beg));
-          if (FIXNUMP (pos) && BEGV <= XINT (pos) && XINT (pos) < from)
+          if (FIXNUMP (pos) && BEGV <= XFIXNUM (pos) && XFIXNUM (pos) < from)
             {
-              from = XINT (pos);
+              from = XFIXNUM (pos);
               from_byte = CHAR_TO_BYTE (from);
             }
         }
@@ -1588,14 +1588,14 @@ instead.  See Info node `(elisp) Word Motion' for details.  */)
   else
     CHECK_FIXNUM (arg);
 
-  val = orig_val = scan_words (PT, XINT (arg));
+  val = orig_val = scan_words (PT, XFIXNUM (arg));
   if (! orig_val)
-    val = XINT (arg) > 0 ? ZV : BEGV;
+    val = XFIXNUM (arg) > 0 ? ZV : BEGV;
 
   /* Avoid jumping out of an input field.  */
   tmp = Fconstrain_to_field (make_fixnum (val), make_fixnum (PT),
                              Qnil, Qnil, Qnil);
-  val = XFASTINT (tmp);
+  val = XFIXNAT (tmp);
 
   SET_PT (val);
   return val == orig_val ? Qt : Qnil;
@@ -1679,13 +1679,13 @@ skip_chars (bool forwardp, Lisp_Object string, Lisp_Object lim,
     CHECK_FIXNUM_COERCE_MARKER (lim);
 
   /* In any case, don't allow scan outside bounds of buffer.  */
-  if (XINT (lim) > ZV)
+  if (XFIXNUM (lim) > ZV)
     XSETFASTINT (lim, ZV);
-  if (XINT (lim) < BEGV)
+  if (XFIXNUM (lim) < BEGV)
     XSETFASTINT (lim, BEGV);
 
   multibyte = (!NILP (BVAR (current_buffer, enable_multibyte_characters))
-               && (XINT (lim) - PT != CHAR_TO_BYTE (XINT (lim)) - PT_BYTE));
+               && (XFIXNUM (lim) - PT != CHAR_TO_BYTE (XFIXNUM (lim)) - PT_BYTE));
   string_multibyte = SBYTES (string) > SCHARS (string);
 
   memset (fastmap, 0, sizeof fastmap);
@@ -1936,13 +1936,13 @@ skip_chars (bool forwardp, Lisp_Object string, Lisp_Object lim,
 
     if (forwardp)
       {
-        endp = (XINT (lim) == GPT) ? GPT_ADDR : CHAR_POS_ADDR (XINT (lim));
-        stop = (pos < GPT && GPT < XINT (lim)) ? GPT_ADDR : endp;
+        endp = (XFIXNUM (lim) == GPT) ? GPT_ADDR : CHAR_POS_ADDR (XFIXNUM (lim));
+        stop = (pos < GPT && GPT < XFIXNUM (lim)) ? GPT_ADDR : endp;
       }
     else
       {
-        endp = CHAR_POS_ADDR (XINT (lim));
-        stop = (pos >= GPT && GPT > XINT (lim)) ? GAP_END_ADDR : endp;
+        endp = CHAR_POS_ADDR (XFIXNUM (lim));
+        stop = (pos >= GPT && GPT > XFIXNUM (lim)) ? GAP_END_ADDR : endp;
       }
 
     /* This code may look up syntax tables using functions that rely on the
@@ -2118,16 +2118,16 @@ skip_syntaxes (bool forwardp, Lisp_Object string, Lisp_Object lim)
     CHECK_FIXNUM_COERCE_MARKER (lim);
 
   /* In any case, don't allow scan outside bounds of buffer.  */
-  if (XINT (lim) > ZV)
+  if (XFIXNUM (lim) > ZV)
     XSETFASTINT (lim, ZV);
-  if (XINT (lim) < BEGV)
+  if (XFIXNUM (lim) < BEGV)
     XSETFASTINT (lim, BEGV);
 
-  if (forwardp ? (PT >= XFASTINT (lim)) : (PT <= XFASTINT (lim)))
+  if (forwardp ? (PT >= XFIXNAT (lim)) : (PT <= XFIXNAT (lim)))
     return make_fixnum (0);
 
   multibyte = (!NILP (BVAR (current_buffer, enable_multibyte_characters))
-               && (XINT (lim) - PT != CHAR_TO_BYTE (XINT (lim)) - PT_BYTE));
+               && (XFIXNUM (lim) - PT != CHAR_TO_BYTE (XFIXNUM (lim)) - PT_BYTE));
 
   memset (fastmap, 0, sizeof fastmap);
 
@@ -2172,8 +2172,8 @@ skip_syntaxes (bool forwardp, Lisp_Object string, Lisp_Object lim)
         while (true)
           {
             p = BYTE_POS_ADDR (pos_byte);
-            endp = XINT (lim) == GPT ? GPT_ADDR : CHAR_POS_ADDR (XINT (lim));
-            stop = pos < GPT && GPT < XINT (lim) ? GPT_ADDR : endp;
+            endp = XFIXNUM (lim) == GPT ? GPT_ADDR : CHAR_POS_ADDR (XFIXNUM (lim));
+            stop = pos < GPT && GPT < XFIXNUM (lim) ? GPT_ADDR : endp;
 
             do
               {
@@ -2205,8 +2205,8 @@ skip_syntaxes (bool forwardp, Lisp_Object string, Lisp_Object lim)
     else
       {
         p = BYTE_POS_ADDR (pos_byte);
-        endp = CHAR_POS_ADDR (XINT (lim));
-        stop = pos >= GPT && GPT > XINT (lim) ? GAP_END_ADDR : endp;
+        endp = CHAR_POS_ADDR (XFIXNUM (lim));
+        stop = pos >= GPT && GPT > XFIXNUM (lim) ? GAP_END_ADDR : endp;
 
         if (multibyte)
           {
@@ -2275,7 +2275,7 @@ in_classes (int c, Lisp_Object iso_classes)
       elt = XCAR (iso_classes);
       iso_classes = XCDR (iso_classes);
 
-      if (re_iswctype (c, XFASTINT (elt)))
+      if (re_iswctype (c, XFIXNAT (elt)))
         fits_class = 1;
     }
 
@@ -2443,7 +2443,7 @@ between them, return t; otherwise return nil.  */)
   unsigned short int quit_count = 0;
 
   CHECK_FIXNUM (count);
-  count1 = XINT (count);
+  count1 = XFIXNUM (count);
   stop = count1 > 0 ? ZV : BEGV;
 
   from = PT;
@@ -3057,7 +3057,7 @@ that point is zero, and signal an error if the depth is nonzero.  */)
   CHECK_FIXNUM (count);
   CHECK_FIXNUM (depth);
 
-  return scan_lists (XINT (from), XINT (count), XINT (depth), 0);
+  return scan_lists (XFIXNUM (from), XFIXNUM (count), XFIXNUM (depth), 0);
 }
 
 DEFUN ("scan-sexps", Fscan_sexps, Sscan_sexps, 2, 2, 0,
@@ -3076,7 +3076,7 @@ but before count is used up, nil is returned.  */)
   CHECK_FIXNUM (from);
   CHECK_FIXNUM (count);
 
-  return scan_lists (XINT (from), XINT (count), 0, 1);
+  return scan_lists (XFIXNUM (from), XFIXNUM (count), 0, 1);
 }
 
 DEFUN ("backward-prefix-chars", Fbackward_prefix_chars, Sbackward_prefix_chars,
@@ -3217,7 +3217,7 @@ do { prev_from = from;				\
     {
       Lisp_Object temhd = Fcar (tem);
       if (RANGED_FIXNUMP (PTRDIFF_MIN, temhd, PTRDIFF_MAX))
-        curlevel->last = XINT (temhd);
+        curlevel->last = XFIXNUM (temhd);
       if (++curlevel == endlevel)
         curlevel--; /* error ("Nesting too deep for parser"); */
       curlevel->prev = -1;
@@ -3490,7 +3490,7 @@ internalize_parse_state (Lisp_Object external, struct lisp_parse_state *state)
     {
       tem = Fcar (external);
       if (!NILP (tem))
-        state->depth = XINT (tem);
+        state->depth = XFIXNUM (tem);
       else
         state->depth = 0;
 
@@ -3500,13 +3500,13 @@ internalize_parse_state (Lisp_Object external, struct lisp_parse_state *state)
       tem = Fcar (external);
       /* Check whether we are inside string_fence-style string: */
       state->instring = (!NILP (tem)
-                         ? (CHARACTERP (tem) ? XFASTINT (tem) : ST_STRING_STYLE)
+                         ? (CHARACTERP (tem) ? XFIXNAT (tem) : ST_STRING_STYLE)
                          : -1);
 
       external = Fcdr (external);
       tem = Fcar (external);
       state->incomment = (!NILP (tem)
-                          ? (FIXNUMP (tem) ? XINT (tem) : -1)
+                          ? (FIXNUMP (tem) ? XFIXNUM (tem) : -1)
                           : 0);
 
       external = Fcdr (external);
@@ -3521,20 +3521,20 @@ internalize_parse_state (Lisp_Object external, struct lisp_parse_state *state)
       state->comstyle = (NILP (tem)
                          ? 0
                          : (RANGED_FIXNUMP (0, tem, ST_COMMENT_STYLE)
-                            ? XINT (tem)
+                            ? XFIXNUM (tem)
                             : ST_COMMENT_STYLE));
 
       external = Fcdr (external);
       tem = Fcar (external);
       state->comstr_start =
-        RANGED_FIXNUMP (PTRDIFF_MIN, tem, PTRDIFF_MAX) ? XINT (tem) : -1;
+        RANGED_FIXNUMP (PTRDIFF_MIN, tem, PTRDIFF_MAX) ? XFIXNUM (tem) : -1;
       external = Fcdr (external);
       tem = Fcar (external);
       state->levelstarts = tem;
 
       external = Fcdr (external);
       tem = Fcar (external);
-      state->prev_syntax = NILP (tem) ? Smax : XINT (tem);
+      state->prev_syntax = NILP (tem) ? Smax : XFIXNUM (tem);
     }
 }
 
@@ -3584,15 +3584,15 @@ Sixth arg COMMENTSTOP non-nil means stop after the start of a comment.
   if (!NILP (targetdepth))
     {
       CHECK_FIXNUM (targetdepth);
-      target = XINT (targetdepth);
+      target = XFIXNUM (targetdepth);
     }
   else
     target = TYPE_MINIMUM (EMACS_INT);  /* We won't reach this depth.  */
 
   validate_region (&from, &to);
   internalize_parse_state (oldstate, &state);
-  scan_sexps_forward (&state, XINT (from), CHAR_TO_BYTE (XINT (from)),
-                      XINT (to),
+  scan_sexps_forward (&state, XFIXNUM (from), CHAR_TO_BYTE (XFIXNUM (from)),
+                      XFIXNUM (to),
                       target, !NILP (stopbefore),
                       (NILP (commentstop)
                        ? 0 : (EQ (commentstop, Qsyntax_table) ? -1 : 1)));
diff --git a/src/syntax.h b/src/syntax.h
index f02a17ce8d6..d971c747539 100644
--- a/src/syntax.h
+++ b/src/syntax.h
@@ -118,7 +118,7 @@ INLINE int
 syntax_property_with_flags (int c, bool via_property)
 {
   Lisp_Object ent = syntax_property_entry (c, via_property);
-  return CONSP (ent) ? XINT (XCAR (ent)) : Swhitespace;
+  return CONSP (ent) ? XFIXNUM (XCAR (ent)) : Swhitespace;
 }
 INLINE int
 SYNTAX_WITH_FLAGS (int c)
diff --git a/src/sysdep.c b/src/sysdep.c
index 3bc7adcc89b..cf2982bca11 100644
--- a/src/sysdep.c
+++ b/src/sysdep.c
@@ -2851,7 +2851,7 @@ serial_configure (struct Lisp_Process *p,
   else
     tem = Fplist_get (p->childp, QCspeed);
   CHECK_FIXNUM (tem);
-  err = cfsetspeed (&attr, XINT (tem));
+  err = cfsetspeed (&attr, XFIXNUM (tem));
   if (err != 0)
     report_file_error ("Failed cfsetspeed", tem);
   childp2 = Fplist_put (childp2, QCspeed, tem);
@@ -2864,15 +2864,15 @@ serial_configure (struct Lisp_Process *p,
   if (NILP (tem))
     tem = make_fixnum (8);
   CHECK_FIXNUM (tem);
-  if (XINT (tem) != 7 && XINT (tem) != 8)
+  if (XFIXNUM (tem) != 7 && XFIXNUM (tem) != 8)
     error (":bytesize must be nil (8), 7, or 8");
-  summary[0] = XINT (tem) + '0';
+  summary[0] = XFIXNUM (tem) + '0';
 #if defined (CSIZE) && defined (CS7) && defined (CS8)
   attr.c_cflag &= ~CSIZE;
-  attr.c_cflag |= ((XINT (tem) == 7) ? CS7 : CS8);
+  attr.c_cflag |= ((XFIXNUM (tem) == 7) ? CS7 : CS8);
 #else
   /* Don't error on bytesize 8, which should be set by cfmakeraw.  */
-  if (XINT (tem) != 8)
+  if (XFIXNUM (tem) != 8)
     error ("Bytesize cannot be changed");
 #endif
   childp2 = Fplist_put (childp2, QCbytesize, tem);
@@ -2918,16 +2918,16 @@ serial_configure (struct Lisp_Process *p,
   if (NILP (tem))
     tem = make_fixnum (1);
   CHECK_FIXNUM (tem);
-  if (XINT (tem) != 1 && XINT (tem) != 2)
+  if (XFIXNUM (tem) != 1 && XFIXNUM (tem) != 2)
     error (":stopbits must be nil (1 stopbit), 1, or 2");
-  summary[2] = XINT (tem) + '0';
+  summary[2] = XFIXNUM (tem) + '0';
 #if defined (CSTOPB)
   attr.c_cflag &= ~CSTOPB;
-  if (XINT (tem) == 2)
+  if (XFIXNUM (tem) == 2)
     attr.c_cflag |= CSTOPB;
 #else
   /* Don't error on 1 stopbit, which should be set by cfmakeraw.  */
-  if (XINT (tem) != 1)
+  if (XFIXNUM (tem) != 1)
     error ("Stopbits cannot be configured");
 #endif
   childp2 = Fplist_put (childp2, QCstopbits, tem);
diff --git a/src/term.c b/src/term.c
index 026ead3f9a7..ce24f6915fc 100644
--- a/src/term.c
+++ b/src/term.c
@@ -2147,7 +2147,7 @@ set_tty_color_mode (struct tty_display_info *tty, struct frame *f)
   else
     color_mode = Qnil;
 
-  mode = TYPE_RANGED_FIXNUMP (int, color_mode) ? XINT (color_mode) : 0;
+  mode = TYPE_RANGED_FIXNUMP (int, color_mode) ? XFIXNUM (color_mode) : 0;
 
   if (mode != tty->previous_color_mode)
     {
@@ -2805,8 +2805,8 @@ mouse_get_xy (int *x, int *y)
                                                  &time_dummy);
   if (!NILP (lmx))
     {
-      *x = XINT (lmx);
-      *y = XINT (lmy);
+      *x = XFIXNUM (lmx);
+      *y = XFIXNUM (lmy);
     }
 }
 
@@ -3477,7 +3477,7 @@ tty_menu_new_item_coords (struct frame *f, int which, int *x, int *y)
           pos = AREF (items, i + 3);
           if (NILP (str))
             return;
-          ix = XINT (pos);
+          ix = XFIXNUM (pos);
           if (ix <= *x
               /* We use <= so the blank between 2 items on a TTY is
                  considered part of the previous item.  */
@@ -3488,14 +3488,14 @@ tty_menu_new_item_coords (struct frame *f, int which, int *x, int *y)
               if (which == TTYM_NEXT)
                 {
                   if (i < last_i)
-                    *x = XINT (AREF (items, i + 4 + 3));
+                    *x = XFIXNUM (AREF (items, i + 4 + 3));
                   else
                     *x = 0;     /* Wrap around to the first item.  */
                 }
               else if (prev_x < 0)
                 {
                   /* Wrap around to the last item.  */
-                  *x = XINT (AREF (items, last_i + 3));
+                  *x = XFIXNUM (AREF (items, last_i + 3));
                 }
               else
                 *x = prev_x;
diff --git a/src/termhooks.h b/src/termhooks.h
index d8c5edc948e..160bd2f4803 100644
--- a/src/termhooks.h
+++ b/src/termhooks.h
@@ -346,7 +346,7 @@ enum {
      FIXNUM_BITS, so using it to represent a modifier key means that
      characters thus modified have different integer equivalents
      depending on the architecture they're running on.  Oh, and
-     applying XINT to a character whose 2^28 bit is set might sign-extend
+     applying XFIXNUM to a character whose 2^28 bit is set might sign-extend
      it, so you get a bunch of bits in the mask you didn't want.
 
      The CHAR_ macros are defined in lisp.h.  */
diff --git a/src/textprop.c b/src/textprop.c
index 3f636a125ab..4bd4892b730 100644
--- a/src/textprop.c
+++ b/src/textprop.c
@@ -79,7 +79,7 @@ text_read_only (Lisp_Object propval)
 static void
 modify_text_properties (Lisp_Object buffer, Lisp_Object start, Lisp_Object end)
 {
-  ptrdiff_t b = XINT (start), e = XINT (end);
+  ptrdiff_t b = XFIXNUM (start), e = XFIXNUM (end);
   struct buffer *buf = XBUFFER (buffer), *old = current_buffer;
 
   set_buffer_internal (buf);
@@ -145,7 +145,7 @@ validate_interval_range (Lisp_Object object, Lisp_Object *begin,
   if (EQ (*begin, *end) && begin != end)
     return NULL;
 
-  if (XINT (*begin) > XINT (*end))
+  if (XFIXNUM (*begin) > XFIXNUM (*end))
     {
       Lisp_Object n;
       n = *begin;
@@ -157,8 +157,8 @@ validate_interval_range (Lisp_Object object, Lisp_Object *begin,
     {
       register struct buffer *b = XBUFFER (object);
 
-      if (!(BUF_BEGV (b) <= XINT (*begin) && XINT (*begin) <= XINT (*end)
-            && XINT (*end) <= BUF_ZV (b)))
+      if (!(BUF_BEGV (b) <= XFIXNUM (*begin) && XFIXNUM (*begin) <= XFIXNUM (*end)
+            && XFIXNUM (*end) <= BUF_ZV (b)))
         args_out_of_range (*begin, *end);
       i = buffer_intervals (b);
 
@@ -166,24 +166,24 @@ validate_interval_range (Lisp_Object object, Lisp_Object *begin,
       if (BUF_BEGV (b) == BUF_ZV (b))
         return NULL;
 
-      searchpos = XINT (*begin);
+      searchpos = XFIXNUM (*begin);
     }
   else
     {
       ptrdiff_t len = SCHARS (object);
 
-      if (! (0 <= XINT (*begin) && XINT (*begin) <= XINT (*end)
-             && XINT (*end) <= len))
+      if (! (0 <= XFIXNUM (*begin) && XFIXNUM (*begin) <= XFIXNUM (*end)
+             && XFIXNUM (*end) <= len))
         args_out_of_range (*begin, *end);
-      XSETFASTINT (*begin, XFASTINT (*begin));
+      XSETFASTINT (*begin, XFIXNAT (*begin));
       if (begin != end)
-        XSETFASTINT (*end, XFASTINT (*end));
+        XSETFASTINT (*end, XFIXNAT (*end));
       i = string_intervals (object);
 
       if (len == 0)
         return NULL;
 
-      searchpos = XINT (*begin);
+      searchpos = XFIXNUM (*begin);
     }
 
   if (!i)
@@ -572,7 +572,7 @@ If POSITION is at the end of OBJECT, the value is nil.  */)
      it means it's the end of OBJECT.
      There are no properties at the very end,
      since no character follows.  */
-  if (XINT (position) == LENGTH (i) + i->position)
+  if (XFIXNUM (position) == LENGTH (i) + i->position)
     return Qnil;
 
   return i->plist;
@@ -621,14 +621,14 @@ get_char_property_and_overlay (Lisp_Object position, register Lisp_Object prop,
       Lisp_Object *overlay_vec;
       struct buffer *obuf = current_buffer;
 
-      if (XINT (position) < BUF_BEGV (XBUFFER (object))
-          || XINT (position) > BUF_ZV (XBUFFER (object)))
+      if (XFIXNUM (position) < BUF_BEGV (XBUFFER (object))
+          || XFIXNUM (position) > BUF_ZV (XBUFFER (object)))
         xsignal1 (Qargs_out_of_range, position);
 
       set_buffer_temp (XBUFFER (object));
 
       USE_SAFE_ALLOCA;
-      GET_OVERLAYS_AT (XINT (position), overlay_vec, noverlays, NULL, false);
+      GET_OVERLAYS_AT (XFIXNUM (position), overlay_vec, noverlays, NULL, false);
       noverlays = sort_overlays (overlay_vec, noverlays, w);
 
       set_buffer_temp (obuf);
@@ -715,7 +715,7 @@ before LIMIT.  LIMIT is a no-op if it is greater than (point-max).  */)
   if (! NILP (limit))
     {
       CHECK_FIXNUM_COERCE_MARKER (limit);
-      if (XINT (limit) < XINT (temp))
+      if (XFIXNUM (limit) < XFIXNUM (temp))
         temp = limit;
     }
   return Fnext_property_change (position, Qnil, temp);
@@ -741,7 +741,7 @@ before LIMIT.  LIMIT is a no-op if it is less than (point-min).  */)
   if (! NILP (limit))
     {
       CHECK_FIXNUM_COERCE_MARKER (limit);
-      if (XINT (limit) > XINT (temp))
+      if (XFIXNUM (limit) > XFIXNUM (temp))
         temp = limit;
     }
   return Fprevious_property_change (position, Qnil, temp);
@@ -805,17 +805,17 @@ last valid position in OBJECT.  */)
       else
         CHECK_FIXNUM_COERCE_MARKER (limit);
 
-      if (XFASTINT (position) >= XFASTINT (limit))
+      if (XFIXNAT (position) >= XFIXNAT (limit))
         {
           position = limit;
-          if (XFASTINT (position) > ZV)
+          if (XFIXNAT (position) > ZV)
             XSETFASTINT (position, ZV);
         }
       else
         while (true)
           {
             position = Fnext_char_property_change (position, limit);
-            if (XFASTINT (position) >= XFASTINT (limit))
+            if (XFIXNAT (position) >= XFIXNAT (limit))
               {
                 position = limit;
                 break;
@@ -887,23 +887,23 @@ first valid position in OBJECT.  */)
       else
         CHECK_FIXNUM_COERCE_MARKER (limit);
 
-      if (XFASTINT (position) <= XFASTINT (limit))
+      if (XFIXNAT (position) <= XFIXNAT (limit))
         {
           position = limit;
-          if (XFASTINT (position) < BEGV)
+          if (XFIXNAT (position) < BEGV)
             XSETFASTINT (position, BEGV);
         }
       else
         {
           Lisp_Object initial_value
-            = Fget_char_property (make_fixnum (XFASTINT (position) - 1),
+            = Fget_char_property (make_fixnum (XFIXNAT (position) - 1),
                                   prop, object);
 
           while (true)
             {
               position = Fprevious_char_property_change (position, limit);
 
-              if (XFASTINT (position) <= XFASTINT (limit))
+              if (XFIXNAT (position) <= XFIXNAT (limit))
                 {
                   position = limit;
                   break;
@@ -911,7 +911,7 @@ first valid position in OBJECT.  */)
               else
                 {
                   Lisp_Object value
-                    = Fget_char_property (make_fixnum (XFASTINT (position) - 1),
+                    = Fget_char_property (make_fixnum (XFIXNAT (position) - 1),
                                           prop, object);
 
                   if (!EQ (value, initial_value))
@@ -976,13 +976,13 @@ past position LIMIT; return LIMIT if nothing is found before LIMIT.  */)
   next = next_interval (i);
 
   while (next && intervals_equal (i, next)
-         && (NILP (limit) || next->position < XFASTINT (limit)))
+         && (NILP (limit) || next->position < XFIXNAT (limit)))
     next = next_interval (next);
 
   if (!next
       || (next->position
           >= (FIXNUMP (limit)
-              ? XFASTINT (limit)
+              ? XFIXNAT (limit)
               : (STRINGP (object)
                  ? SCHARS (object)
                  : BUF_ZV (XBUFFER (object))))))
@@ -1025,13 +1025,13 @@ past position LIMIT; return LIMIT if nothing is found before LIMIT.  */)
   next = next_interval (i);
   while (next
          && EQ (here_val, textget (next->plist, prop))
-         && (NILP (limit) || next->position < XFASTINT (limit)))
+         && (NILP (limit) || next->position < XFIXNAT (limit)))
     next = next_interval (next);
 
   if (!next
       || (next->position
           >= (FIXNUMP (limit)
-              ? XFASTINT (limit)
+              ? XFIXNAT (limit)
               : (STRINGP (object)
                  ? SCHARS (object)
                  : BUF_ZV (XBUFFER (object))))))
@@ -1069,19 +1069,19 @@ back past position LIMIT; return LIMIT if nothing is found until LIMIT.  */)
     return limit;
 
   /* Start with the interval containing the char before point.  */
-  if (i->position == XFASTINT (position))
+  if (i->position == XFIXNAT (position))
     i = previous_interval (i);
 
   previous = previous_interval (i);
   while (previous && intervals_equal (previous, i)
          && (NILP (limit)
-             || (previous->position + LENGTH (previous) > XFASTINT (limit))))
+             || (previous->position + LENGTH (previous) > XFIXNAT (limit))))
     previous = previous_interval (previous);
 
   if (!previous
       || (previous->position + LENGTH (previous)
           <= (FIXNUMP (limit)
-              ? XFASTINT (limit)
+              ? XFIXNAT (limit)
               : (STRINGP (object) ? 0 : BUF_BEGV (XBUFFER (object))))))
     return limit;
   else
@@ -1117,7 +1117,7 @@ back past position LIMIT; return LIMIT if nothing is found until LIMIT.  */)
   i = validate_interval_range (object, &position, &position, soft);
 
   /* Start with the interval containing the char before point.  */
-  if (i && i->position == XFASTINT (position))
+  if (i && i->position == XFIXNAT (position))
     i = previous_interval (i);
 
   if (!i)
@@ -1128,13 +1128,13 @@ back past position LIMIT; return LIMIT if nothing is found until LIMIT.  */)
   while (previous
          && EQ (here_val, textget (previous->plist, prop))
          && (NILP (limit)
-             || (previous->position + LENGTH (previous) > XFASTINT (limit))))
+             || (previous->position + LENGTH (previous) > XFIXNAT (limit))))
     previous = previous_interval (previous);
 
   if (!previous
       || (previous->position + LENGTH (previous)
           <= (FIXNUMP (limit)
-              ? XFASTINT (limit)
+              ? XFIXNAT (limit)
               : (STRINGP (object) ? 0 : BUF_BEGV (XBUFFER (object))))))
     return limit;
   else
@@ -1164,8 +1164,8 @@ add_text_properties_1 (Lisp_Object start, Lisp_Object end,
   if (!i)
     return Qnil;
 
-  s = XINT (start);
-  len = XINT (end) - s;
+  s = XFIXNUM (start);
+  len = XFIXNUM (end) - s;
 
   /* If this interval already has the properties, we can skip it.  */
   if (interval_has_all_properties (properties, i))
@@ -1221,8 +1221,8 @@ add_text_properties_1 (Lisp_Object start, Lisp_Object end,
           if (interval_has_all_properties (properties, i))
             {
               if (BUFFERP (object))
-                signal_after_change (XINT (start), XINT (end) - XINT (start),
-                                     XINT (end) - XINT (start));
+                signal_after_change (XFIXNUM (start), XFIXNUM (end) - XFIXNUM (start),
+                                     XFIXNUM (end) - XFIXNUM (start));
 
               eassert (modified);
               return Qt;
@@ -1232,8 +1232,8 @@ add_text_properties_1 (Lisp_Object start, Lisp_Object end,
             {
               add_properties (properties, i, object, set_type);
               if (BUFFERP (object))
-                signal_after_change (XINT (start), XINT (end) - XINT (start),
-                                     XINT (end) - XINT (start));
+                signal_after_change (XFIXNUM (start), XFIXNUM (end) - XFIXNUM (start),
+                                     XFIXNUM (end) - XFIXNUM (start));
               return Qt;
             }
 
@@ -1243,8 +1243,8 @@ add_text_properties_1 (Lisp_Object start, Lisp_Object end,
           copy_properties (unchanged, i);
           add_properties (properties, i, object, set_type);
           if (BUFFERP (object))
-            signal_after_change (XINT (start), XINT (end) - XINT (start),
-                                 XINT (end) - XINT (start));
+            signal_after_change (XFIXNUM (start), XFIXNUM (end) - XFIXNUM (start),
+                                 XFIXNUM (end) - XFIXNUM (start));
           return Qt;
         }
 
@@ -1362,8 +1362,8 @@ set_text_properties (Lisp_Object start, Lisp_Object end, Lisp_Object properties,
   /* If we want no properties for a whole string,
      get rid of its intervals.  */
   if (NILP (properties) && STRINGP (object)
-      && XFASTINT (start) == 0
-      && XFASTINT (end) == SCHARS (object))
+      && XFIXNAT (start) == 0
+      && XFIXNAT (end) == SCHARS (object))
     {
       if (!string_intervals (object))
         return Qnil;
@@ -1397,8 +1397,8 @@ set_text_properties (Lisp_Object start, Lisp_Object end, Lisp_Object properties,
   set_text_properties_1 (start, end, properties, object, i);
 
   if (BUFFERP (object) && !NILP (coherent_change_p))
-    signal_after_change (XINT (start), XINT (end) - XINT (start),
-                         XINT (end) - XINT (start));
+    signal_after_change (XFIXNUM (start), XFIXNUM (end) - XFIXNUM (start),
+                         XFIXNUM (end) - XFIXNUM (start));
   return Qt;
 }
 
@@ -1415,15 +1415,15 @@ set_text_properties_1 (Lisp_Object start, Lisp_Object end, Lisp_Object propertie
   register ptrdiff_t s, len;
   INTERVAL unchanged;
 
-  if (XINT (start) < XINT (end))
+  if (XFIXNUM (start) < XFIXNUM (end))
     {
-      s = XINT (start);
-      len = XINT (end) - s;
+      s = XFIXNUM (start);
+      len = XFIXNUM (end) - s;
     }
-  else if (XINT (end) < XINT (start))
+  else if (XFIXNUM (end) < XFIXNUM (start))
     {
-      s = XINT (end);
-      len = XINT (start) - s;
+      s = XFIXNUM (end);
+      len = XFIXNUM (start) - s;
     }
   else
     return;
@@ -1515,8 +1515,8 @@ Use `set-text-properties' if you want to remove all text properties.  */)
   if (!i)
     return Qnil;
 
-  s = XINT (start);
-  len = XINT (end) - s;
+  s = XFIXNUM (start);
+  len = XFIXNUM (end) - s;
 
   /* If there are no properties on this entire interval, return.  */
   if (! interval_has_some_properties (properties, i))
@@ -1573,8 +1573,8 @@ Use `set-text-properties' if you want to remove all text properties.  */)
             {
               eassert (modified);
               if (BUFFERP (object))
-                signal_after_change (XINT (start), XINT (end) - XINT (start),
-                                     XINT (end) - XINT (start));
+                signal_after_change (XFIXNUM (start), XFIXNUM (end) - XFIXNUM (start),
+                                     XFIXNUM (end) - XFIXNUM (start));
               return Qt;
             }
 
@@ -1582,8 +1582,8 @@ Use `set-text-properties' if you want to remove all text properties.  */)
             {
               remove_properties (properties, Qnil, i, object);
               if (BUFFERP (object))
-                signal_after_change (XINT (start), XINT (end) - XINT (start),
-                                     XINT (end) - XINT (start));
+                signal_after_change (XFIXNUM (start), XFIXNUM (end) - XFIXNUM (start),
+                                     XFIXNUM (end) - XFIXNUM (start));
               return Qt;
             }
 
@@ -1593,8 +1593,8 @@ Use `set-text-properties' if you want to remove all text properties.  */)
           copy_properties (unchanged, i);
           remove_properties (properties, Qnil, i, object);
           if (BUFFERP (object))
-            signal_after_change (XINT (start), XINT (end) - XINT (start),
-                                 XINT (end) - XINT (start));
+            signal_after_change (XFIXNUM (start), XFIXNUM (end) - XFIXNUM (start),
+                                 XFIXNUM (end) - XFIXNUM (start));
           return Qt;
         }
 
@@ -1627,8 +1627,8 @@ Return t if any property was actually removed, nil otherwise.  */)
   if (!i)
     return Qnil;
 
-  s = XINT (start);
-  len = XINT (end) - s;
+  s = XFIXNUM (start);
+  len = XFIXNUM (end) - s;
 
   /* If there are no properties on the interval, return.  */
   if (! interval_has_some_properties_list (properties, i))
@@ -1671,9 +1671,9 @@ Return t if any property was actually removed, nil otherwise.  */)
               if (modified)
                 {
                   if (BUFFERP (object))
-                    signal_after_change (XINT (start),
-                                         XINT (end) - XINT (start),
-                                         XINT (end) - XINT (start));
+                    signal_after_change (XFIXNUM (start),
+                                         XFIXNUM (end) - XFIXNUM (start),
+                                         XFIXNUM (end) - XFIXNUM (start));
                   return Qt;
                 }
               else
@@ -1685,8 +1685,8 @@ Return t if any property was actually removed, nil otherwise.  */)
                 modify_text_properties (object, start, end);
               remove_properties (Qnil, properties, i, object);
               if (BUFFERP (object))
-                signal_after_change (XINT (start), XINT (end) - XINT (start),
-                                     XINT (end) - XINT (start));
+                signal_after_change (XFIXNUM (start), XFIXNUM (end) - XFIXNUM (start),
+                                     XFIXNUM (end) - XFIXNUM (start));
               return Qt;
             }
           else
@@ -1698,8 +1698,8 @@ Return t if any property was actually removed, nil otherwise.  */)
                 modify_text_properties (object, start, end);
               remove_properties (Qnil, properties, i, object);
               if (BUFFERP (object))
-                signal_after_change (XINT (start), XINT (end) - XINT (start),
-                                     XINT (end) - XINT (start));
+                signal_after_change (XFIXNUM (start), XFIXNUM (end) - XFIXNUM (start),
+                                     XFIXNUM (end) - XFIXNUM (start));
               return Qt;
             }
         }
@@ -1717,9 +1717,9 @@ Return t if any property was actually removed, nil otherwise.  */)
           if (modified)
             {
               if (BUFFERP (object))
-                signal_after_change (XINT (start),
-                                     XINT (end) - XINT (start),
-                                     XINT (end) - XINT (start));
+                signal_after_change (XFIXNUM (start),
+                                     XFIXNUM (end) - XFIXNUM (start),
+                                     XFIXNUM (end) - XFIXNUM (start));
               return Qt;
             }
           else
@@ -1746,7 +1746,7 @@ markers).  If OBJECT is a string, START and END are 0-based indices into it.  */
   i = validate_interval_range (object, &start, &end, soft);
   if (!i)
     return (!NILP (value) || EQ (start, end) ? Qnil : start);
-  e = XINT (end);
+  e = XFIXNUM (end);
 
   while (i)
     {
@@ -1755,8 +1755,8 @@ markers).  If OBJECT is a string, START and END are 0-based indices into it.  */
       if (EQ (textget (i->plist, property), value))
         {
           pos = i->position;
-          if (pos < XINT (start))
-            pos = XINT (start);
+          if (pos < XFIXNUM (start))
+            pos = XFIXNUM (start);
           return make_fixnum (pos);
         }
       i = next_interval (i);
@@ -1782,8 +1782,8 @@ markers).  If OBJECT is a string, START and END are 0-based indices into it.  */
   i = validate_interval_range (object, &start, &end, soft);
   if (!i)
     return (NILP (value) || EQ (start, end)) ? Qnil : start;
-  s = XINT (start);
-  e = XINT (end);
+  s = XFIXNUM (start);
+  e = XFIXNUM (end);
 
   while (i)
     {
@@ -1811,7 +1811,7 @@ int
 text_property_stickiness (Lisp_Object prop, Lisp_Object pos, Lisp_Object buffer)
 {
   bool ignore_previous_character;
-  Lisp_Object prev_pos = make_fixnum (XINT (pos) - 1);
+  Lisp_Object prev_pos = make_fixnum (XFIXNUM (pos) - 1);
   Lisp_Object front_sticky;
   bool is_rear_sticky = true, is_front_sticky = false; /* defaults */
   Lisp_Object defalt = Fassq (prop, Vtext_property_default_nonsticky);
@@ -1819,7 +1819,7 @@ text_property_stickiness (Lisp_Object prop, Lisp_Object pos, Lisp_Object buffer)
   if (NILP (buffer))
     XSETBUFFER (buffer, current_buffer);
 
-  ignore_previous_character = XINT (pos) <= BUF_BEGV (XBUFFER (buffer));
+  ignore_previous_character = XFIXNUM (pos) <= BUF_BEGV (XBUFFER (buffer));
 
   if (ignore_previous_character || (CONSP (defalt) && !NILP (XCDR (defalt))))
     is_rear_sticky = false;
@@ -1895,7 +1895,7 @@ copy_text_properties (Lisp_Object start, Lisp_Object end, Lisp_Object src,
   {
     Lisp_Object dest_start, dest_end;
 
-    e = XINT (pos) + (XINT (end) - XINT (start));
+    e = XFIXNUM (pos) + (XFIXNUM (end) - XFIXNUM (start));
     if (MOST_POSITIVE_FIXNUM < e)
       args_out_of_range (pos, end);
     dest_start = pos;
@@ -1905,9 +1905,9 @@ copy_text_properties (Lisp_Object start, Lisp_Object end, Lisp_Object src,
     validate_interval_range (dest, &dest_start, &dest_end, soft);
   }
 
-  s = XINT (start);
-  e = XINT (end);
-  p = XINT (pos);
+  s = XFIXNUM (start);
+  e = XFIXNUM (end);
+  p = XFIXNUM (pos);
 
   stuff = Qnil;
 
@@ -1975,8 +1975,8 @@ text_property_list (Lisp_Object object, Lisp_Object start, Lisp_Object end, Lisp
   i = validate_interval_range (object, &start, &end, soft);
   if (i)
     {
-      ptrdiff_t s = XINT (start);
-      ptrdiff_t e = XINT (end);
+      ptrdiff_t s = XFIXNUM (start);
+      ptrdiff_t e = XFIXNUM (end);
 
       while (s < e)
         {
@@ -2027,8 +2027,8 @@ add_text_properties_from_list (Lisp_Object object, Lisp_Object list, Lisp_Object
       Lisp_Object item, start, end, plist;
 
       item = XCAR (list);
-      start = make_fixnum (XINT (XCAR (item)) + XINT (delta));
-      end = make_fixnum (XINT (XCAR (XCDR (item))) + XINT (delta));
+      start = make_fixnum (XFIXNUM (XCAR (item)) + XFIXNUM (delta));
+      end = make_fixnum (XFIXNUM (XCAR (XCDR (item))) + XFIXNUM (delta));
       plist = XCAR (XCDR (XCDR (item)));
 
       Fadd_text_properties (start, end, plist, object);
@@ -2046,7 +2046,7 @@ Lisp_Object
 extend_property_ranges (Lisp_Object list, Lisp_Object old_end, Lisp_Object new_end)
 {
   Lisp_Object prev = Qnil, head = list;
-  ptrdiff_t max = XINT (new_end);
+  ptrdiff_t max = XFIXNUM (new_end);
 
   for (; CONSP (list); prev = list, list = XCDR (list))
     {
@@ -2055,9 +2055,9 @@ extend_property_ranges (Lisp_Object list, Lisp_Object old_end, Lisp_Object new_e
 
       item = XCAR (list);
       beg = XCAR (item);
-      end = XINT (XCAR (XCDR (item)));
+      end = XFIXNUM (XCAR (XCDR (item)));
 
-      if (XINT (beg) >= max)
+      if (XFIXNUM (beg) >= max)
         {
           /* The start-point is past the end of the new string.
              Discard this property.  */
@@ -2066,7 +2066,7 @@ extend_property_ranges (Lisp_Object list, Lisp_Object old_end, Lisp_Object new_e
           else
             XSETCDR (prev, XCDR (list));
         }
-      else if ((end == XINT (old_end) && end != max)
+      else if ((end == XFIXNUM (old_end) && end != max)
                || end > max)
         {
           /* Either the end-point is past the end of the new string,
diff --git a/src/undo.c b/src/undo.c
index 7d2402fda38..e80ec58ab09 100644
--- a/src/undo.c
+++ b/src/undo.c
@@ -104,7 +104,7 @@ record_insert (ptrdiff_t beg, ptrdiff_t length)
       if (CONSP (elt)
           && FIXNUMP (XCAR (elt))
           && FIXNUMP (XCDR (elt))
-          && XINT (XCDR (elt)) == beg)
+          && XFIXNUM (XCDR (elt)) == beg)
         {
           XSETCDR (elt, make_fixnum (beg + length));
           return;
@@ -353,7 +353,7 @@ truncate_undo_list (struct buffer *b)
   /* If by the first boundary we have already passed undo_outer_limit,
      we're heading for memory full, so offer to clear out the list.  */
   if (FIXNUMP (Vundo_outer_limit)
-      && size_so_far > XINT (Vundo_outer_limit)
+      && size_so_far > XFIXNUM (Vundo_outer_limit)
       && !NILP (Vundo_outer_limit_function))
     {
       Lisp_Object tem;
diff --git a/src/w32.c b/src/w32.c
index 6eb6b0bbee9..299bba7be4a 100644
--- a/src/w32.c
+++ b/src/w32.c
@@ -7043,7 +7043,7 @@ system_process_attributes (Lisp_Object pid)
   BOOL result = FALSE;
 
   CHECK_FIXNUM_OR_FLOAT (pid);
-  proc_id = FLOATP (pid) ? XFLOAT_DATA (pid) : XINT (pid);
+  proc_id = FLOATP (pid) ? XFLOAT_DATA (pid) : XFIXNUM (pid);
 
   h_snapshot = create_toolhelp32_snapshot (TH32CS_SNAPPROCESS, 0);
 
@@ -10107,7 +10107,7 @@ serial_configure (struct Lisp_Process *p, Lisp_Object contact)
   else
     tem = Fplist_get (p->childp, QCspeed);
   CHECK_FIXNUM (tem);
-  dcb.BaudRate = XINT (tem);
+  dcb.BaudRate = XFIXNUM (tem);
   childp2 = Fplist_put (childp2, QCspeed, tem);
 
   /* Configure bytesize.  */
@@ -10118,10 +10118,10 @@ serial_configure (struct Lisp_Process *p, Lisp_Object contact)
   if (NILP (tem))
     tem = make_fixnum (8);
   CHECK_FIXNUM (tem);
-  if (XINT (tem) != 7 && XINT (tem) != 8)
+  if (XFIXNUM (tem) != 7 && XFIXNUM (tem) != 8)
     error (":bytesize must be nil (8), 7, or 8");
-  dcb.ByteSize = XINT (tem);
-  summary[0] = XINT (tem) + '0';
+  dcb.ByteSize = XFIXNUM (tem);
+  summary[0] = XFIXNUM (tem) + '0';
   childp2 = Fplist_put (childp2, QCbytesize, tem);
 
   /* Configure parity.  */
@@ -10162,12 +10162,12 @@ serial_configure (struct Lisp_Process *p, Lisp_Object contact)
   if (NILP (tem))
     tem = make_fixnum (1);
   CHECK_FIXNUM (tem);
-  if (XINT (tem) != 1 && XINT (tem) != 2)
+  if (XFIXNUM (tem) != 1 && XFIXNUM (tem) != 2)
     error (":stopbits must be nil (1 stopbit), 1, or 2");
-  summary[2] = XINT (tem) + '0';
-  if (XINT (tem) == 1)
+  summary[2] = XFIXNUM (tem) + '0';
+  if (XFIXNUM (tem) == 1)
     dcb.StopBits = ONESTOPBIT;
-  else if (XINT (tem) == 2)
+  else if (XFIXNUM (tem) == 2)
     dcb.StopBits = TWOSTOPBITS;
   childp2 = Fplist_put (childp2, QCstopbits, tem);
 
diff --git a/src/w32console.c b/src/w32console.c
index c322a8e6998..6c3cf06bfd3 100644
--- a/src/w32console.c
+++ b/src/w32console.c
@@ -791,7 +791,7 @@ DEFUN ("set-screen-color", Fset_screen_color, Sset_screen_color, 2, 2, 0,
 Arguments should be indices between 0 and 15, see w32console.el.  */)
   (Lisp_Object foreground, Lisp_Object background)
 {
-  char_attr_normal = XFASTINT (foreground) + (XFASTINT (background) << 4);
+  char_attr_normal = XFIXNAT (foreground) + (XFIXNAT (background) << 4);
 
   Frecenter (Qnil, Qt);
   return Qt;
@@ -814,7 +814,7 @@ DEFUN ("set-cursor-size", Fset_cursor_size, Sset_cursor_size, 1, 1, 0,
   (Lisp_Object size)
 {
   CONSOLE_CURSOR_INFO cci;
-  cci.dwSize = XFASTINT (size);
+  cci.dwSize = XFIXNAT (size);
   cci.bVisible = TRUE;
   (void) SetConsoleCursorInfo (cur_screen, &cci);
 
diff --git a/src/w32fns.c b/src/w32fns.c
index e8962b491fe..8d5293c1af0 100644
--- a/src/w32fns.c
+++ b/src/w32fns.c
@@ -462,7 +462,7 @@ if the entry is new.  */)
   CHECK_FIXNUM (blue);
   CHECK_STRING (name);
 
-  XSETINT (rgb, RGB (XUINT (red), XUINT (green), XUINT (blue)));
+  XSETINT (rgb, RGB (XUFIXNUM (red), XUFIXNUM (green), XUFIXNUM (blue)));
 
   block_input ();
 
@@ -1182,7 +1182,7 @@ w32_defined_color (struct frame *f, const char *color, XColor *color_def,
       if (f)
         {
           /* Apply gamma correction.  */
-          w32_color_ref = XUINT (tem);
+          w32_color_ref = XUFIXNUM (tem);
           gamma_correct (f, &w32_color_ref);
           XSETINT (tem, w32_color_ref);
         }
@@ -1198,7 +1198,7 @@ w32_defined_color (struct frame *f, const char *color, XColor *color_def,
           /* check if color is already mapped */
           while (entry)
             {
-              if (W32_COLOR (entry->entry) == XUINT (tem))
+              if (W32_COLOR (entry->entry) == XUFIXNUM (tem))
                 break;
               prev = &entry->next;
               entry = entry->next;
@@ -1208,7 +1208,7 @@ w32_defined_color (struct frame *f, const char *color, XColor *color_def,
             {
               /* not already mapped, so add to list */
               entry = xmalloc (sizeof (struct w32_palette_entry));
-              SET_W32_COLOR (entry->entry, XUINT (tem));
+              SET_W32_COLOR (entry->entry, XUFIXNUM (tem));
               entry->next = NULL;
               *prev = entry;
               one_w32_display_info.num_colors++;
@@ -1220,7 +1220,7 @@ w32_defined_color (struct frame *f, const char *color, XColor *color_def,
       /* Ensure COLORREF value is snapped to nearest color in (default)
          palette by simulating the PALETTERGB macro.  This works whether
          or not the display device has a palette. */
-      w32_color_ref = XUINT (tem) | 0x2000000;
+      w32_color_ref = XUFIXNUM (tem) | 0x2000000;
 
       color_def->pixel = w32_color_ref;
       color_def->red = GetRValue (w32_color_ref) * 256;
@@ -1344,7 +1344,7 @@ x_set_mouse_color (struct frame *f, Lisp_Object arg, Lisp_Object oldval)
   if (!EQ (Qnil, Vx_pointer_shape))
     {
       CHECK_FIXNUM (Vx_pointer_shape);
-      cursor = XCreateFontCursor (FRAME_W32_DISPLAY (f), XINT (Vx_pointer_shape));
+      cursor = XCreateFontCursor (FRAME_W32_DISPLAY (f), XFIXNUM (Vx_pointer_shape));
     }
   else
     cursor = XCreateFontCursor (FRAME_W32_DISPLAY (f), XC_xterm);
@@ -1354,7 +1354,7 @@ x_set_mouse_color (struct frame *f, Lisp_Object arg, Lisp_Object oldval)
     {
       CHECK_FIXNUM (Vx_nontext_pointer_shape);
       nontext_cursor = XCreateFontCursor (FRAME_W32_DISPLAY (f),
-                                          XINT (Vx_nontext_pointer_shape));
+                                          XFIXNUM (Vx_nontext_pointer_shape));
     }
   else
     nontext_cursor = XCreateFontCursor (FRAME_W32_DISPLAY (f), XC_left_ptr);
@@ -1364,7 +1364,7 @@ x_set_mouse_color (struct frame *f, Lisp_Object arg, Lisp_Object oldval)
     {
       CHECK_FIXNUM (Vx_hourglass_pointer_shape);
       hourglass_cursor = XCreateFontCursor (FRAME_W32_DISPLAY (f),
-                                            XINT (Vx_hourglass_pointer_shape));
+                                            XFIXNUM (Vx_hourglass_pointer_shape));
     }
   else
     hourglass_cursor = XCreateFontCursor (FRAME_W32_DISPLAY (f), XC_watch);
@@ -1375,7 +1375,7 @@ x_set_mouse_color (struct frame *f, Lisp_Object arg, Lisp_Object oldval)
     {
       CHECK_FIXNUM (Vx_mode_pointer_shape);
       mode_cursor = XCreateFontCursor (FRAME_W32_DISPLAY (f),
-                                       XINT (Vx_mode_pointer_shape));
+                                       XFIXNUM (Vx_mode_pointer_shape));
     }
   else
     mode_cursor = XCreateFontCursor (FRAME_W32_DISPLAY (f), XC_xterm);
@@ -1386,7 +1386,7 @@ x_set_mouse_color (struct frame *f, Lisp_Object arg, Lisp_Object oldval)
       CHECK_FIXNUM (Vx_sensitive_text_pointer_shape);
       hand_cursor
         = XCreateFontCursor (FRAME_W32_DISPLAY (f),
-                             XINT (Vx_sensitive_text_pointer_shape));
+                             XFIXNUM (Vx_sensitive_text_pointer_shape));
     }
   else
     hand_cursor = XCreateFontCursor (FRAME_W32_DISPLAY (f), XC_crosshair);
@@ -1396,7 +1396,7 @@ x_set_mouse_color (struct frame *f, Lisp_Object arg, Lisp_Object oldval)
       CHECK_FIXNUM (Vx_window_horizontal_drag_shape);
       horizontal_drag_cursor
         = XCreateFontCursor (FRAME_W32_DISPLAY (f),
-                             XINT (Vx_window_horizontal_drag_shape));
+                             XFIXNUM (Vx_window_horizontal_drag_shape));
     }
   else
     horizontal_drag_cursor
@@ -1407,7 +1407,7 @@ x_set_mouse_color (struct frame *f, Lisp_Object arg, Lisp_Object oldval)
       CHECK_FIXNUM (Vx_window_vertical_drag_shape);
       vertical_drag_cursor
         = XCreateFontCursor (FRAME_W32_DISPLAY (f),
-                             XINT (Vx_window_vertical_drag_shape));
+                             XFIXNUM (Vx_window_vertical_drag_shape));
     }
   else
     vertical_drag_cursor
@@ -1689,7 +1689,7 @@ x_set_internal_border_width (struct frame *f, Lisp_Object arg, Lisp_Object oldva
   int border;
 
   CHECK_TYPE_RANGED_INTEGER (int, arg);
-  border = max (XINT (arg), 0);
+  border = max (XFIXNUM (arg), 0);
 
   if (border != FRAME_INTERNAL_BORDER_WIDTH (f))
     {
@@ -1725,7 +1725,7 @@ x_set_menu_bar_lines (struct frame *f, Lisp_Object value, Lisp_Object oldval)
   if (!FRAME_MINIBUF_ONLY_P (f) && !FRAME_PARENT_FRAME (f))
     {
       boolean old = FRAME_EXTERNAL_MENU_BAR (f);
-      boolean new = (FIXNUMP (value) && XINT (value) > 0) ? true : false;
+      boolean new = (FIXNUMP (value) && XFIXNUM (value) > 0) ? true : false;
 
       FRAME_MENU_BAR_LINES (f) = 0;
       FRAME_MENU_BAR_HEIGHT (f) = 0;
@@ -1780,8 +1780,8 @@ x_set_tool_bar_lines (struct frame *f, Lisp_Object value, Lisp_Object oldval)
     return;
 
   /* Use VALUE only if an integer >= 0.  */
-  if (FIXNUMP (value) && XINT (value) >= 0)
-    nlines = XFASTINT (value);
+  if (FIXNUMP (value) && XFIXNUM (value) >= 0)
+    nlines = XFIXNAT (value);
   else
     nlines = 0;
 
@@ -2027,7 +2027,7 @@ x_set_undecorated (struct frame *f, Lisp_Object new_value, Lisp_Object old_value
   if (!NILP (new_value) && !FRAME_UNDECORATED (f))
     {
       dwStyle = ((dwStyle & ~WS_THICKFRAME & ~WS_CAPTION)
-                 | ((FIXED_OR_FLOATP (border_width) && (XINT (border_width) > 0))
+                 | ((FIXED_OR_FLOATP (border_width) && (XFIXNUM (border_width) > 0))
                     ? WS_BORDER : false));
       SetWindowLong (hwnd, GWL_STYLE, dwStyle);
       SetWindowPos (hwnd, HWND_TOP, 0, 0, 0, 0,
@@ -2334,7 +2334,7 @@ w32_createwindow (struct frame *f, int *coords)
       if (FRAME_UNDECORATED (f))
         {
           /* If we want a thin border, specify it here.  */
-          if (FIXED_OR_FLOATP (border_width) && (XINT (border_width) > 0))
+          if (FIXED_OR_FLOATP (border_width) && (XFIXNUM (border_width) > 0))
             f->output_data.w32->dwStyle |= WS_BORDER;
         }
       else
@@ -2350,7 +2350,7 @@ w32_createwindow (struct frame *f, int *coords)
       f->output_data.w32->dwStyle = WS_POPUP;
 
       /* If we want a thin border, specify it here.  */
-      if (FIXED_OR_FLOATP (border_width) && (XINT (border_width) > 0))
+      if (FIXED_OR_FLOATP (border_width) && (XFIXNUM (border_width) > 0))
         f->output_data.w32->dwStyle |= WS_BORDER;
     }
   else
@@ -3117,9 +3117,9 @@ map_keypad_keys (unsigned int virt_key, unsigned int extended)
 static Lisp_Object w32_grabbed_keys;
 
 #define HOTKEY(vk, mods)      make_fixnum (((vk) & 255) | ((mods) << 8))
-#define HOTKEY_ID(k)          (XFASTINT (k) & 0xbfff)
-#define HOTKEY_VK_CODE(k)     (XFASTINT (k) & 255)
-#define HOTKEY_MODIFIERS(k)   (XFASTINT (k) >> 8)
+#define HOTKEY_ID(k)          (XFIXNAT (k) & 0xbfff)
+#define HOTKEY_VK_CODE(k)     (XFIXNAT (k) & 255)
+#define HOTKEY_MODIFIERS(k)   (XFIXNAT (k) >> 8)
 
 #define RAW_HOTKEY_ID(k)        ((k) & 0xbfff)
 #define RAW_HOTKEY_VK_CODE(k)   ((k) & 255)
@@ -4200,7 +4200,7 @@ w32_wnd_proc (HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
               if (GetAsyncKeyState (wParam) & 1)
                 {
                   if (FIXED_OR_FLOATP (Vw32_phantom_key_code))
-                    key = XUINT (Vw32_phantom_key_code) & 255;
+                    key = XUFIXNUM (Vw32_phantom_key_code) & 255;
                   else
                     key = VK_SPACE;
                   dpyinfo->faked_key = key;
@@ -4216,7 +4216,7 @@ w32_wnd_proc (HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
               if (GetAsyncKeyState (wParam) & 1)
                 {
                   if (FIXED_OR_FLOATP (Vw32_phantom_key_code))
-                    key = XUINT (Vw32_phantom_key_code) & 255;
+                    key = XUFIXNUM (Vw32_phantom_key_code) & 255;
                   else
                     key = VK_SPACE;
                   dpyinfo->faked_key = key;
@@ -5413,11 +5413,11 @@ my_create_window (struct frame * f)
   if (EQ (left, Qunbound))
     coords[0] = CW_USEDEFAULT;
   else
-    coords[0] = XINT (left);
+    coords[0] = XFIXNUM (left);
   if (EQ (top, Qunbound))
     coords[1] = CW_USEDEFAULT;
   else
-    coords[1] = XINT (top);
+    coords[1] = XFIXNUM (top);
 
   if (!PostThreadMessage (dwWindowsThreadId, WM_EMACS_CREATEWINDOW,
                           (WPARAM)f, (LPARAM)coords))
@@ -5809,7 +5809,7 @@ DEFUN ("x-create-frame", Fx_create_frame, Sx_create_frame,
     {
       /* Cast to UINT_PTR shuts up compiler warnings about cast to
          pointer from integer of different size.  */
-      f->output_data.w32->parent_desc = (Window) (UINT_PTR) XFASTINT (parent);
+      f->output_data.w32->parent_desc = (Window) (UINT_PTR) XFIXNAT (parent);
       f->output_data.w32->explicit_parent = true;
     }
   else
@@ -7105,33 +7105,33 @@ compute_tip_xy (struct frame *f,
     }
 
   if (FIXNUMP (top))
-    *root_y = XINT (top);
+    *root_y = XFIXNUM (top);
   else if (FIXNUMP (bottom))
-    *root_y = XINT (bottom) - height;
-  else if (*root_y + XINT (dy) <= min_y)
+    *root_y = XFIXNUM (bottom) - height;
+  else if (*root_y + XFIXNUM (dy) <= min_y)
     *root_y = min_y; /* Can happen for negative dy */
-  else if (*root_y + XINT (dy) + height <= max_y)
+  else if (*root_y + XFIXNUM (dy) + height <= max_y)
     /* It fits below the pointer */
-      *root_y += XINT (dy);
-  else if (height + XINT (dy) + min_y <= *root_y)
+      *root_y += XFIXNUM (dy);
+  else if (height + XFIXNUM (dy) + min_y <= *root_y)
     /* It fits above the pointer.  */
-    *root_y -= height + XINT (dy);
+    *root_y -= height + XFIXNUM (dy);
   else
     /* Put it on the top.  */
     *root_y = min_y;
 
   if (FIXNUMP (left))
-    *root_x = XINT (left);
+    *root_x = XFIXNUM (left);
   else if (FIXNUMP (right))
-    *root_x = XINT (right) - width;
-  else if (*root_x + XINT (dx) <= min_x)
+    *root_x = XFIXNUM (right) - width;
+  else if (*root_x + XFIXNUM (dx) <= min_x)
     *root_x = 0; /* Can happen for negative dx */
-  else if (*root_x + XINT (dx) + width <= max_x)
+  else if (*root_x + XFIXNUM (dx) + width <= max_x)
     /* It fits to the right of the pointer.  */
-    *root_x += XINT (dx);
-  else if (width + XINT (dx) + min_x <= *root_x)
+    *root_x += XFIXNUM (dx);
+  else if (width + XFIXNUM (dx) + min_x <= *root_x)
     /* It fits to the left of the pointer.  */
-    *root_x -= width + XINT (dx);
+    *root_x -= width + XFIXNUM (dx);
   else
     /* Put it left justified on the screen -- it ought to fit that way.  */
     *root_x = min_x;
@@ -7389,8 +7389,8 @@ DEFUN ("x-show-tip", Fx_show_tip, Sx_show_tip, 1, 6, 0,
       && RANGED_FIXNUMP (1, XCAR (Vx_max_tooltip_size), INT_MAX)
       && RANGED_FIXNUMP (1, XCDR (Vx_max_tooltip_size), INT_MAX))
     {
-      w->total_cols = XFASTINT (XCAR (Vx_max_tooltip_size));
-      w->total_lines = XFASTINT (XCDR (Vx_max_tooltip_size));
+      w->total_cols = XFIXNAT (XCAR (Vx_max_tooltip_size));
+      w->total_lines = XFIXNAT (XCDR (Vx_max_tooltip_size));
     }
   else
     {
@@ -7422,8 +7422,8 @@ DEFUN ("x-show-tip", Fx_show_tip, Sx_show_tip, 1, 6, 0,
   size = Fwindow_text_pixel_size (window, Qnil, Qnil, Qnil,
                                   make_fixnum (w->pixel_height), Qnil);
   /* Add the frame's internal border to calculated size.  */
-  width = XINT (Fcar (size)) + 2 * FRAME_INTERNAL_BORDER_WIDTH (tip_f);
-  height = XINT (Fcdr (size)) + 2 * FRAME_INTERNAL_BORDER_WIDTH (tip_f);
+  width = XFIXNUM (Fcar (size)) + 2 * FRAME_INTERNAL_BORDER_WIDTH (tip_f);
+  height = XFIXNUM (Fcdr (size)) + 2 * FRAME_INTERNAL_BORDER_WIDTH (tip_f);
   /* Calculate position of tooltip frame.  */
   compute_tip_xy (tip_f, parms, dx, dy, width, height, &root_x, &root_y);
 
@@ -7431,7 +7431,7 @@ DEFUN ("x-show-tip", Fx_show_tip, Sx_show_tip, 1, 6, 0,
   {
     RECT rect;
     int pad = (FIXED_OR_FLOATP (Vw32_tooltip_extra_pixels)
-               ? max (0, XINT (Vw32_tooltip_extra_pixels))
+               ? max (0, XFIXNUM (Vw32_tooltip_extra_pixels))
                : FRAME_COLUMN_WIDTH (tip_f));
 
     rect.left = rect.top = 0;
@@ -8036,7 +8036,7 @@ If optional parameter FRAME is not specified, use selected frame.  */)
   CHECK_FIXNUM (command);
 
   if (FRAME_W32_P (f))
-    PostMessage (FRAME_W32_WINDOW (f), WM_SYSCOMMAND, XINT (command), 0);
+    PostMessage (FRAME_W32_WINDOW (f), WM_SYSCOMMAND, XFIXNUM (command), 0);
 
   return Qnil;
 }
@@ -8144,7 +8144,7 @@ a ShowWindow flag:
   result = (intptr_t) ShellExecuteW (NULL, ops_w, doc_w, params_w,
                                      GUI_SDATA (current_dir),
                                      (FIXNUMP (show_flag)
-                                      ? XINT (show_flag) : SW_SHOWDEFAULT));
+                                      ? XFIXNUM (show_flag) : SW_SHOWDEFAULT));
 
   if (result > 32)
     return Qt;
@@ -8301,7 +8301,7 @@ a ShowWindow flag:
       shexinfo_w.lpParameters = params_w;
       shexinfo_w.lpDirectory = current_dir_w;
       shexinfo_w.nShow =
-        (FIXNUMP (show_flag) ? XINT (show_flag) : SW_SHOWDEFAULT);
+        (FIXNUMP (show_flag) ? XFIXNUM (show_flag) : SW_SHOWDEFAULT);
       success = ShellExecuteExW (&shexinfo_w);
       xfree (doc_w);
     }
@@ -8336,7 +8336,7 @@ a ShowWindow flag:
       shexinfo_a.lpParameters = params_a;
       shexinfo_a.lpDirectory = current_dir_a;
       shexinfo_a.nShow =
-        (FIXNUMP (show_flag) ? XINT (show_flag) : SW_SHOWDEFAULT);
+        (FIXNUMP (show_flag) ? XFIXNUM (show_flag) : SW_SHOWDEFAULT);
       success = ShellExecuteExA (&shexinfo_a);
       xfree (doc_w);
       xfree (doc_a);
@@ -8419,7 +8419,7 @@ w32_parse_and_hook_hot_key (Lisp_Object key, int hook)
   if (SYMBOLP (c))
     {
       c = parse_modifiers (c);
-      lisp_modifiers = XINT (Fcar (Fcdr (c)));
+      lisp_modifiers = XFIXNUM (Fcar (Fcdr (c)));
       c = Fcar (c);
       if (!SYMBOLP (c))
         emacs_abort ();
@@ -8432,9 +8432,9 @@ w32_parse_and_hook_hot_key (Lisp_Object key, int hook)
     }
   else if (FIXNUMP (c))
     {
-      lisp_modifiers = XINT (c) & ~CHARACTERBITS;
+      lisp_modifiers = XFIXNUM (c) & ~CHARACTERBITS;
       /* Many ascii characters are their own virtual key code.  */
-      vk_code = XINT (c) & CHARACTERBITS;
+      vk_code = XFIXNUM (c) & CHARACTERBITS;
     }
 
   if (vk_code < 0 || vk_code > 255)
@@ -8534,7 +8534,7 @@ any key combinations, otherwise nil.  */)
       /* Notify input thread about new hot-key definition, so that it
          takes effect without needing to switch focus.  */
       PostThreadMessage (dwWindowsThreadId, WM_EMACS_REGISTER_HOT_KEY,
-                         (WPARAM) XINT (key), 0);
+                         (WPARAM) XFIXNUM (key), 0);
     }
 
   return key;
@@ -8567,7 +8567,7 @@ DEFUN ("w32-unregister-hot-key", Fw32_unregister_hot_key,
       /* Notify input thread about hot-key definition being removed, so
          that it takes effect without needing focus switch.  */
       if (PostThreadMessage (dwWindowsThreadId, WM_EMACS_UNREGISTER_HOT_KEY,
-                             (WPARAM) XINT (XCAR (item)), lparam))
+                             (WPARAM) XFIXNUM (XCAR (item)), lparam))
         {
           MSG msg;
           GetMessage (&msg, NULL, WM_EMACS_DONE, WM_EMACS_DONE);
@@ -8647,7 +8647,7 @@ to change the state.  */)
   if (NILP (new_state))
     lparam = -1;
   else
-    lparam = (XUINT (new_state)) & 1;
+    lparam = (XUFIXNUM (new_state)) & 1;
   if (PostThreadMessage (dwWindowsThreadId, WM_EMACS_TOGGLE_LOCK_KEY,
                          (WPARAM) vk_code, lparam))
     {
@@ -9071,7 +9071,7 @@ The coordinates X and Y are interpreted in pixels relative to a position
   if (os_subtype == OS_NT
       && w32_major_version + w32_minor_version >= 6)
     ret = SystemParametersInfo (SPI_GETMOUSETRAILS, 0, &trail_num, 0);
-  SetCursorPos (XINT (x), XINT (y));
+  SetCursorPos (XFIXNUM (x), XFIXNUM (y));
   if (ret)
     SystemParametersInfo (SPI_SETMOUSETRAILS, trail_num, NULL, 0);
   unblock_input ();
@@ -9432,7 +9432,7 @@ w32_console_toggle_lock_key (int vk_code, Lisp_Object new_state)
 
   if (NILP (new_state)
       || (FIXED_OR_FLOATP (new_state)
-          && ((XUINT (new_state)) & 1) != cur_state))
+          && ((XUFIXNUM (new_state)) & 1) != cur_state))
     {
 #ifdef WINDOWSNT
       faked_key = vk_code;
@@ -10071,7 +10071,7 @@ DEFUN ("w32-notification-close",
   struct frame *f = SELECTED_FRAME ();
 
   if (FIXNUMP (id))
-    delete_tray_notification (f, XINT (id));
+    delete_tray_notification (f, XFIXNUM (id));
 
   return Qnil;
 }
diff --git a/src/w32font.c b/src/w32font.c
index ed68656a006..c2f5dc3746d 100644
--- a/src/w32font.c
+++ b/src/w32font.c
@@ -920,7 +920,7 @@ w32font_open_internal (struct frame *f, Lisp_Object font_entity,
   if (!EQ (val, Qraster))
     logfont.lfOutPrecision = OUT_TT_PRECIS;
 
-  size = XINT (AREF (font_entity, FONT_SIZE_INDEX));
+  size = XFIXNUM (AREF (font_entity, FONT_SIZE_INDEX));
   if (!size)
     size = pixel_size;
 
@@ -1231,7 +1231,7 @@ font_matches_spec (DWORD type, NEWTEXTMETRICEX *font,
   val = AREF (spec, FONT_SPACING_INDEX);
   if (FIXNUMP (val))
     {
-      int spacing = XINT (val);
+      int spacing = XFIXNUM (val);
       int proportional = (spacing < FONT_SPACING_MONO);
 
       if ((proportional && !(font->ntmTm.tmPitchAndFamily & 0x01))
@@ -1822,8 +1822,8 @@ w32_to_x_charset (int fncharset, char *matching)
         /* Look for Same charset and a valid codepage (or non-int
            which means ignore).  */
         if (EQ (w32_charset, charset_type)
-            && (!FIXNUMP (codepage) || XINT (codepage) == CP_DEFAULT
-                || IsValidCodePage (XINT (codepage))))
+            && (!FIXNUMP (codepage) || XFIXNUM (codepage) == CP_DEFAULT
+                || IsValidCodePage (XFIXNUM (codepage))))
           {
             /* If we don't have a match already, then this is the
                best.  */
@@ -1957,7 +1957,7 @@ fill_in_logfont (struct frame *f, LOGFONT *logfont, Lisp_Object font_spec)
   tmp = AREF (font_spec, FONT_DPI_INDEX);
   if (FIXNUMP (tmp))
     {
-      dpi = XINT (tmp);
+      dpi = XFIXNUM (tmp);
     }
   else if (FLOATP (tmp))
     {
@@ -1967,7 +1967,7 @@ fill_in_logfont (struct frame *f, LOGFONT *logfont, Lisp_Object font_spec)
   /* Height  */
   tmp = AREF (font_spec, FONT_SIZE_INDEX);
   if (FIXNUMP (tmp))
-    logfont->lfHeight = -1 * XINT (tmp);
+    logfont->lfHeight = -1 * XFIXNUM (tmp);
   else if (FLOATP (tmp))
     logfont->lfHeight = (int) (-1.0 *  dpi * XFLOAT_DATA (tmp) / 72.27 + 0.5);
 
@@ -2038,7 +2038,7 @@ fill_in_logfont (struct frame *f, LOGFONT *logfont, Lisp_Object font_spec)
   tmp = AREF (font_spec, FONT_SPACING_INDEX);
   if (FIXNUMP (tmp))
     {
-      int spacing = XINT (tmp);
+      int spacing = XFIXNUM (tmp);
       if (spacing < FONT_SPACING_MONO)
         logfont->lfPitchAndFamily
           = (logfont->lfPitchAndFamily & 0xF0) | VARIABLE_PITCH;
diff --git a/src/w32inevt.c b/src/w32inevt.c
index 6c5a1c6d47a..e8494c88bc1 100644
--- a/src/w32inevt.c
+++ b/src/w32inevt.c
@@ -182,7 +182,7 @@ key_event (KEY_EVENT_RECORD *event, struct input_event *emacs_ev, int *isdead)
           if ((mod_key_state & LEFT_WIN_PRESSED) == 0)
             {
               if (FIXED_OR_FLOATP (Vw32_phantom_key_code))
-                faked_key = XUINT (Vw32_phantom_key_code) & 255;
+                faked_key = XUFIXNUM (Vw32_phantom_key_code) & 255;
               else
                 faked_key = VK_SPACE;
               keybd_event (faked_key, (BYTE) MapVirtualKey (faked_key, 0), 0, 0);
@@ -199,7 +199,7 @@ key_event (KEY_EVENT_RECORD *event, struct input_event *emacs_ev, int *isdead)
           if ((mod_key_state & RIGHT_WIN_PRESSED) == 0)
             {
               if (FIXED_OR_FLOATP (Vw32_phantom_key_code))
-                faked_key = XUINT (Vw32_phantom_key_code) & 255;
+                faked_key = XUFIXNUM (Vw32_phantom_key_code) & 255;
               else
                 faked_key = VK_SPACE;
               keybd_event (faked_key, (BYTE) MapVirtualKey (faked_key, 0), 0, 0);
diff --git a/src/w32proc.c b/src/w32proc.c
index 4cffdd0d9d7..61ce157b558 100644
--- a/src/w32proc.c
+++ b/src/w32proc.c
@@ -1890,7 +1890,7 @@ sys_spawnve (int mode, char *cmdname, char **argv, char **envp)
       /* Override escape char by binding w32-quote-process-args to
          desired character, or use t for auto-selection.  */
       if (FIXNUMP (Vw32_quote_process_args))
-        escape_char = XINT (Vw32_quote_process_args);
+        escape_char = XFIXNUM (Vw32_quote_process_args);
       else
         escape_char = (is_cygnus_app || is_msys_app) ? '"' : '\\';
     }
@@ -3023,7 +3023,7 @@ If successful, the return value is t, otherwise nil.  */)
          externally.  This is necessary because real pids on Windows 95 are
          negative.  */
 
-      pid = XINT (process);
+      pid = XFIXNUM (process);
       cp = find_child_pid (pid);
       if (cp != NULL)
         pid = cp->procinfo.dwProcessId;
@@ -3188,12 +3188,12 @@ If LCID (a 16-bit number) is not a valid locale, the result is nil.  */)
 
   CHECK_FIXNUM (lcid);
 
-  if (!IsValidLocale (XINT (lcid), LCID_SUPPORTED))
+  if (!IsValidLocale (XFIXNUM (lcid), LCID_SUPPORTED))
     return Qnil;
 
   if (NILP (longform))
     {
-      got_abbrev = GetLocaleInfo (XINT (lcid),
+      got_abbrev = GetLocaleInfo (XFIXNUM (lcid),
                                   LOCALE_SABBREVLANGNAME | LOCALE_USE_CP_ACP,
                                   abbrev_name, sizeof (abbrev_name));
       if (got_abbrev)
@@ -3201,7 +3201,7 @@ If LCID (a 16-bit number) is not a valid locale, the result is nil.  */)
     }
   else if (EQ (longform, Qt))
     {
-      got_full = GetLocaleInfo (XINT (lcid),
+      got_full = GetLocaleInfo (XFIXNUM (lcid),
                                 LOCALE_SLANGUAGE | LOCALE_USE_CP_ACP,
                                 full_name, sizeof (full_name));
       if (got_full)
@@ -3209,8 +3209,8 @@ If LCID (a 16-bit number) is not a valid locale, the result is nil.  */)
     }
   else if (FIXED_OR_FLOATP (longform))
     {
-      got_full = GetLocaleInfo (XINT (lcid),
-                                XINT (longform),
+      got_full = GetLocaleInfo (XFIXNUM (lcid),
+                                XFIXNUM (longform),
                                 full_name, sizeof (full_name));
       /* GetLocaleInfo's return value includes the terminating null
          character, when the returned information is a string, whereas
@@ -3301,16 +3301,16 @@ If successful, the new locale id is returned, otherwise nil.  */)
 {
   CHECK_FIXNUM (lcid);
 
-  if (!IsValidLocale (XINT (lcid), LCID_SUPPORTED))
+  if (!IsValidLocale (XFIXNUM (lcid), LCID_SUPPORTED))
     return Qnil;
 
-  if (!SetThreadLocale (XINT (lcid)))
+  if (!SetThreadLocale (XFIXNUM (lcid)))
     return Qnil;
 
   /* Need to set input thread locale if present.  */
   if (dwWindowsThreadId)
     /* Reply is not needed.  */
-    PostThreadMessage (dwWindowsThreadId, WM_EMACS_SETLOCALE, XINT (lcid), 0);
+    PostThreadMessage (dwWindowsThreadId, WM_EMACS_SETLOCALE, XFIXNUM (lcid), 0);
 
   return make_fixnum (GetThreadLocale ());
 }
@@ -3360,10 +3360,10 @@ If successful, the new CP is returned, otherwise nil.  */)
 {
   CHECK_FIXNUM (cp);
 
-  if (!IsValidCodePage (XINT (cp)))
+  if (!IsValidCodePage (XFIXNUM (cp)))
     return Qnil;
 
-  if (!SetConsoleCP (XINT (cp)))
+  if (!SetConsoleCP (XFIXNUM (cp)))
     return Qnil;
 
   return make_fixnum (GetConsoleCP ());
@@ -3388,10 +3388,10 @@ If successful, the new CP is returned, otherwise nil.  */)
 {
   CHECK_FIXNUM (cp);
 
-  if (!IsValidCodePage (XINT (cp)))
+  if (!IsValidCodePage (XFIXNUM (cp)))
     return Qnil;
 
-  if (!SetConsoleOutputCP (XINT (cp)))
+  if (!SetConsoleOutputCP (XFIXNUM (cp)))
     return Qnil;
 
   return make_fixnum (GetConsoleOutputCP ());
@@ -3414,13 +3414,13 @@ yield nil.  */)
 
   CHECK_FIXNUM (cp);
 
-  if (!IsValidCodePage (XINT (cp)))
+  if (!IsValidCodePage (XFIXNUM (cp)))
     return Qnil;
 
   /* Going through a temporary DWORD_PTR variable avoids compiler warning
      about cast to pointer from integer of different size, when
      building --with-wide-int or building for 64bit.  */
-  dwcp = XINT (cp);
+  dwcp = XFIXNUM (cp);
   if (TranslateCharsetInfo ((DWORD *) dwcp, &info, TCI_SRCCODEPAGE))
     return make_fixnum (info.ciCharset);
 
@@ -3480,8 +3480,8 @@ If successful, the new layout id is returned, otherwise nil.  */)
   CHECK_FIXNUM_CAR (layout);
   CHECK_FIXNUM_CDR (layout);
 
-  kl = (HKL) (UINT_PTR) ((XINT (XCAR (layout)) & 0xffff)
-                         | (XINT (XCDR (layout)) << 16));
+  kl = (HKL) (UINT_PTR) ((XFIXNUM (XCAR (layout)) & 0xffff)
+                         | (XFIXNUM (XCDR (layout)) << 16));
 
   /* Synchronize layout with input thread.  */
   if (dwWindowsThreadId)
diff --git a/src/w32select.c b/src/w32select.c
index 9255bf068ad..dc568d47f27 100644
--- a/src/w32select.c
+++ b/src/w32select.c
@@ -241,7 +241,7 @@ static Lisp_Object
 render (Lisp_Object oformat)
 {
   HGLOBAL htext = NULL;
-  UINT format = XFASTINT (oformat);
+  UINT format = XFIXNAT (oformat);
 
   ONTRACE (fprintf (stderr, "render\n"));
 
diff --git a/src/w32term.c b/src/w32term.c
index cf6d516d583..9d224fe9b46 100644
--- a/src/w32term.c
+++ b/src/w32term.c
@@ -479,7 +479,7 @@ x_set_frame_alpha (struct frame *f)
   if (FLOATP (Vframe_alpha_lower_limit))
     alpha_min = XFLOAT_DATA (Vframe_alpha_lower_limit);
   else if (FIXNUMP (Vframe_alpha_lower_limit))
-    alpha_min = (XINT (Vframe_alpha_lower_limit)) / 100.0;
+    alpha_min = (XFIXNUM (Vframe_alpha_lower_limit)) / 100.0;
 
   if (alpha < 0.0)
     return;
@@ -1982,11 +1982,11 @@ x_draw_image_relief (struct glyph_string *s)
           && FIXNUMP (XCAR (Vtool_bar_button_margin))
           && FIXNUMP (XCDR (Vtool_bar_button_margin)))
         {
-          extra_x = XINT (XCAR (Vtool_bar_button_margin));
-          extra_y = XINT (XCDR (Vtool_bar_button_margin));
+          extra_x = XFIXNUM (XCAR (Vtool_bar_button_margin));
+          extra_y = XFIXNUM (XCDR (Vtool_bar_button_margin));
         }
       else if (FIXNUMP (Vtool_bar_button_margin))
-        extra_x = extra_y = XINT (Vtool_bar_button_margin);
+        extra_x = extra_y = XFIXNUM (Vtool_bar_button_margin);
     }
 
   top_p = bot_p = left_p = right_p = 0;
@@ -2482,7 +2482,7 @@ x_draw_glyph_string (struct glyph_string *s)
                     = buffer_local_value (Qunderline_minimum_offset,
                                         s->w->contents);
                   if (FIXNUMP (val))
-                    minimum_offset = XFASTINT (val);
+                    minimum_offset = XFIXNAT (val);
                   else
                     minimum_offset = 1;
                   val = buffer_local_value (Qx_underline_at_descent_line,
@@ -3573,8 +3573,8 @@ w32_mouse_position (struct frame **fp, int insist, Lisp_Object *bar_window,
 static void
 w32_handle_tool_bar_click (struct frame *f, struct input_event *button_event)
 {
-  int x = XFASTINT (button_event->x);
-  int y = XFASTINT (button_event->y);
+  int x = XFIXNAT (button_event->x);
+  int y = XFIXNAT (button_event->y);
 
   if (button_event->modifiers & down_modifier)
     handle_tool_bar_click (f, x, y, 1, 0);
@@ -4996,8 +4996,8 @@ w32_read_socket (struct terminal *terminal,
                     && WINDOW_TOTAL_LINES (XWINDOW (f->tool_bar_window)))
                   {
                     Lisp_Object window;
-                    int x = XFASTINT (inev.x);
-                    int y = XFASTINT (inev.y);
+                    int x = XFIXNAT (inev.x);
+                    int y = XFIXNAT (inev.y);
 
                     window = window_from_coordinates (f, x, y, 0, 1);
 
@@ -6145,8 +6145,8 @@ x_calc_absolute_position (struct frame *f)
               monitor_left = Fnth (make_fixnum (1), geometry);
               monitor_top  = Fnth (make_fixnum (2), geometry);
 
-              display_left = min (display_left, XINT (monitor_left));
-              display_top  = min (display_top,  XINT (monitor_top));
+              display_left = min (display_left, XFIXNUM (monitor_left));
+              display_top  = min (display_top,  XFIXNUM (monitor_top));
             }
         }
     }
diff --git a/src/w32term.h b/src/w32term.h
index c69bebeebdd..ebdab040fbc 100644
--- a/src/w32term.h
+++ b/src/w32term.h
@@ -478,7 +478,7 @@ struct scroll_bar {
 
 #ifdef _WIN64
 /* Building a 64-bit C integer from two 32-bit lisp integers.  */
-#define SCROLL_BAR_PACK(low, high) (XINT (high) << 32 | XINT (low))
+#define SCROLL_BAR_PACK(low, high) (XFIXNUM (high) << 32 | XFIXNUM (low))
 
 /* Setting two lisp integers to the low and high words of a 64-bit C int.  */
 #define SCROLL_BAR_UNPACK(low, high, int64) \
@@ -486,7 +486,7 @@ struct scroll_bar {
    XSETINT ((high), ((DWORDLONG)(int64) >> 32) & 0xffffffff))
 #else  /* not _WIN64 */
 /* Building a 32-bit C unsigned integer from two 16-bit lisp integers.  */
-#define SCROLL_BAR_PACK(low, high) ((UINT_PTR)(XINT (high) << 16 | XINT (low)))
+#define SCROLL_BAR_PACK(low, high) ((UINT_PTR)(XFIXNUM (high) << 16 | XFIXNUM (low)))
 
 /* Setting two lisp integers to the low and high words of a 32-bit C int.  */
 #define SCROLL_BAR_UNPACK(low, high, int32) \
diff --git a/src/w32uniscribe.c b/src/w32uniscribe.c
index 149f03d6acc..11bfa5490b8 100644
--- a/src/w32uniscribe.c
+++ b/src/w32uniscribe.c
@@ -879,7 +879,7 @@ uniscribe_check_otf (LOGFONT *font, Lisp_Object otf_spec)
   int i, retval = 0;
 
   /* Check the spec is in the right format.  */
-  if (!CONSP (otf_spec) || XINT (Flength (otf_spec)) < 3)
+  if (!CONSP (otf_spec) || XFIXNUM (Flength (otf_spec)) < 3)
     return 0;
 
   /* Break otf_spec into its components.  */
diff --git a/src/window.c b/src/window.c
index e3b0c3a66a5..67cfdc12b5d 100644
--- a/src/window.c
+++ b/src/window.c
@@ -1118,7 +1118,7 @@ window so that the location of point moves off-window.  */)
   (Lisp_Object window, Lisp_Object ncol)
 {
   CHECK_FIXNUM (ncol);
-  return set_window_hscroll (decode_live_window (window), XINT (ncol));
+  return set_window_hscroll (decode_live_window (window), XFIXNUM (ncol));
 }
 
 DEFUN ("window-redisplay-end-trigger", Fwindow_redisplay_end_trigger,
@@ -1764,7 +1764,7 @@ POS, ROWH is the visible height of that row, and VPOS is the row number
   else if (!NILP (pos))
     {
       CHECK_FIXNUM_COERCE_MARKER (pos);
-      posint = XINT (pos);
+      posint = XFIXNUM (pos);
     }
   else if (w == XWINDOW (selected_window))
     posint = PT;
@@ -1870,7 +1870,7 @@ Return nil if window display is not up-to-date.  In that case, use
     }
 
   CHECK_FIXNUM (line);
-  n = XINT (line);
+  n = XFIXNUM (line);
 
   row = MATRIX_FIRST_TEXT_ROW (w->current_matrix);
   end_row = MATRIX_BOTTOM_TEXT_ROW (w->current_matrix, w);
@@ -1975,7 +1975,7 @@ though when run from an idle timer with a delay of zero seconds.  */)
   else if (FIXED_OR_FLOATP (first))
     {
       CHECK_RANGED_INTEGER (first, 0, w->current_matrix->nrows);
-      row = MATRIX_ROW (w->current_matrix, XINT (first));
+      row = MATRIX_ROW (w->current_matrix, XFIXNUM (first));
     }
   else
     error ("Invalid specification of first line");
@@ -1988,7 +1988,7 @@ though when run from an idle timer with a delay of zero seconds.  */)
   else if (FIXED_OR_FLOATP (last))
     {
       CHECK_RANGED_INTEGER (last, 0, w->current_matrix->nrows);
-      end_row = MATRIX_ROW (w->current_matrix, XINT (last));
+      end_row = MATRIX_ROW (w->current_matrix, XFIXNUM (last));
     }
   else
     error ("Invalid specification of last line");
@@ -2492,7 +2492,7 @@ candidate_window_p (Lisp_Object window, Lisp_Object owindow,
             == FRAME_TERMINAL (XFRAME (selected_frame)));
 
     }
-  else if (FIXNUMP (all_frames) && XINT (all_frames) == 0)
+  else if (FIXNUMP (all_frames) && XFIXNUM (all_frames) == 0)
     {
       candidate_p = (FRAME_VISIBLE_P (f) || FRAME_ICONIFIED_P (f)
 #ifdef HAVE_X_WINDOWS
@@ -3495,7 +3495,7 @@ set_window_buffer (Lisp_Object window, Lisp_Object buffer,
 
   /* Update time stamps of buffer display.  */
   if (FIXNUMP (BVAR (b, display_count)))
-    bset_display_count (b, make_fixnum (XINT (BVAR (b, display_count)) + 1));
+    bset_display_count (b, make_fixnum (XFIXNUM (BVAR (b, display_count)) + 1));
   bset_display_time (b, Fcurrent_time ());
 
   w->window_end_pos = 0;
@@ -3820,14 +3820,14 @@ Note: This function does not operate on any child windows of WINDOW.  */)
   (Lisp_Object window, Lisp_Object size, Lisp_Object add)
 {
   struct window *w = decode_valid_window (window);
-  EMACS_INT size_min = NILP (add) ? 0 : - XINT (w->new_pixel);
+  EMACS_INT size_min = NILP (add) ? 0 : - XFIXNUM (w->new_pixel);
   EMACS_INT size_max = size_min + min (INT_MAX, MOST_POSITIVE_FIXNUM);
 
   CHECK_RANGED_INTEGER (size, size_min, size_max);
   if (NILP (add))
     wset_new_pixel (w, size);
   else
-    wset_new_pixel (w, make_fixnum (XINT (w->new_pixel) + XINT (size)));
+    wset_new_pixel (w, make_fixnum (XFIXNUM (w->new_pixel) + XFIXNUM (size)));
 
   return w->new_pixel;
 }
@@ -3853,7 +3853,7 @@ Note: This function does not operate on any child windows of WINDOW.  */)
   if (NILP (add))
     wset_new_total (w, size);
   else
-    wset_new_total (w, make_fixnum (XINT (w->new_total) + XINT (size)));
+    wset_new_total (w, make_fixnum (XFIXNUM (w->new_total) + XFIXNUM (size)));
 
   return w->new_total;
 }
@@ -3895,7 +3895,7 @@ window_resize_check (struct window *w, bool horflag)
         {
           while (c)
             {
-              if (XINT (c->new_pixel) != XINT (w->new_pixel)
+              if (XFIXNUM (c->new_pixel) != XFIXNUM (w->new_pixel)
                   || !window_resize_check (c, horflag))
                 return false;
 
@@ -3908,14 +3908,14 @@ window_resize_check (struct window *w, bool horflag)
         /* The sum of the heights of the child windows of W must equal
            W's height.  */
         {
-          int remaining_pixels = XINT (w->new_pixel);
+          int remaining_pixels = XFIXNUM (w->new_pixel);
 
           while (c)
             {
               if (!window_resize_check (c, horflag))
                 return false;
 
-              remaining_pixels -= XINT (c->new_pixel);
+              remaining_pixels -= XFIXNUM (c->new_pixel);
               if (remaining_pixels < 0)
                 return false;
               c = NILP (c->next) ? 0 : XWINDOW (c->next);
@@ -3932,14 +3932,14 @@ window_resize_check (struct window *w, bool horflag)
         /* The sum of the widths of the child windows of W must equal W's
            width.  */
         {
-          int remaining_pixels = XINT (w->new_pixel);
+          int remaining_pixels = XFIXNUM (w->new_pixel);
 
           while (c)
             {
               if (!window_resize_check (c, horflag))
                 return false;
 
-              remaining_pixels -= XINT (c->new_pixel);
+              remaining_pixels -= XFIXNUM (c->new_pixel);
               if (remaining_pixels < 0)
                 return false;
               c = NILP (c->next) ? 0 : XWINDOW (c->next);
@@ -3952,7 +3952,7 @@ window_resize_check (struct window *w, bool horflag)
         {
           while (c)
             {
-              if (XINT (c->new_pixel) != XINT (w->new_pixel)
+              if (XFIXNUM (c->new_pixel) != XFIXNUM (w->new_pixel)
                   || !window_resize_check (c, horflag))
                 return false;
 
@@ -3966,7 +3966,7 @@ window_resize_check (struct window *w, bool horflag)
     /* A leaf window.  Make sure it's not too small.  The following
        hardcodes the values of `window-safe-min-width' (2) and
        `window-safe-min-height' (1) which are defined in window.el.  */
-    return (XINT (w->new_pixel) >= (horflag
+    return (XFIXNUM (w->new_pixel) >= (horflag
                                     ? (2 * FRAME_COLUMN_WIDTH (f))
                                     : FRAME_LINE_HEIGHT (f)));
 }
@@ -3992,7 +3992,7 @@ window_resize_apply (struct window *w, bool horflag)
      parent window has been set *before*.  */
   if (horflag)
     {
-      w->pixel_width = XFASTINT (w->new_pixel);
+      w->pixel_width = XFIXNAT (w->new_pixel);
       w->total_cols = w->pixel_width / unit;
       if (FIXED_OR_FLOATP (w->new_normal))
         wset_normal_cols (w, w->new_normal);
@@ -4001,7 +4001,7 @@ window_resize_apply (struct window *w, bool horflag)
     }
   else
     {
-      w->pixel_height = XFASTINT (w->new_pixel);
+      w->pixel_height = XFIXNAT (w->new_pixel);
       w->total_lines = w->pixel_height / unit;
       if (FIXED_OR_FLOATP (w->new_normal))
         wset_normal_lines (w, w->new_normal);
@@ -4076,12 +4076,12 @@ window_resize_apply_total (struct window *w, bool horflag)
      parent window has been set *before*.  */
   if (horflag)
     {
-      w->total_cols = XFASTINT (w->new_total);
+      w->total_cols = XFIXNAT (w->new_total);
       edge = w->left_col;
     }
   else
     {
-      w->total_lines = XFASTINT (w->new_total);
+      w->total_lines = XFIXNAT (w->new_total);
       edge = w->top_line;
     }
 
@@ -4149,7 +4149,7 @@ be applied on the Elisp level.  */)
   bool horflag = !NILP (horizontal);
 
   if (!window_resize_check (r, horflag)
-      || (XINT (r->new_pixel)
+      || (XFIXNUM (r->new_pixel)
           != (horflag ? r->pixel_width : r->pixel_height)))
     return Qnil;
 
@@ -4193,10 +4193,10 @@ values.  */)
       if (NILP (horizontal))
         {
           m->top_line = r->top_line + r->total_lines;
-          m->total_lines = XFASTINT (m->new_total);
+          m->total_lines = XFIXNAT (m->new_total);
         }
       else
-        m->total_cols = XFASTINT (m->new_total);
+        m->total_cols = XFIXNAT (m->new_total);
     }
 
   unblock_input ();
@@ -4286,7 +4286,7 @@ resize_frame_windows (struct frame *f, int size, bool horflag, bool pixelwise)
       resize_root_window (root, delta, horflag ? Qt : Qnil, Qnil,
                           pixelwise ? Qt : Qnil);
       if (window_resize_check (r, horflag)
-          && new_pixel_size == XINT (r->new_pixel))
+          && new_pixel_size == XFIXNUM (r->new_pixel))
         {
           window_resize_apply (r, horflag);
           window_pixel_to_total (r->frame, horflag ? Qt : Qnil);
@@ -4297,7 +4297,7 @@ resize_frame_windows (struct frame *f, int size, bool horflag, bool pixelwise)
           resize_root_window (root, delta, horflag ? Qt : Qnil, Qt,
                               pixelwise ? Qt : Qnil);
           if (window_resize_check (r, horflag)
-              && new_pixel_size == XINT (r->new_pixel))
+              && new_pixel_size == XFIXNUM (r->new_pixel))
             {
               window_resize_apply (r, horflag);
               window_pixel_to_total (r->frame, horflag ? Qt : Qnil);
@@ -4371,7 +4371,7 @@ set correctly.  See the code of `split-window' for how this is done.  */)
 
   CHECK_FIXNUM (pixel_size);
   EMACS_INT total_size
-    = XINT (pixel_size) / (horflag
+    = XFIXNUM (pixel_size) / (horflag
                            ? FRAME_COLUMN_WIDTH (f)
                            : FRAME_LINE_HEIGHT (f));
 
@@ -4407,7 +4407,7 @@ set correctly.  See the code of `split-window' for how this is done.  */)
       /* Temporarily pretend we split the parent window.  */
       wset_new_pixel
         (p, make_fixnum ((horflag ? p->pixel_width : p->pixel_height)
-                         - XINT (pixel_size)));
+                         - XFIXNUM (pixel_size)));
       if (!window_resize_check (p, horflag))
         error ("Window sizes don't fit");
       else
@@ -4418,7 +4418,7 @@ set correctly.  See the code of `split-window' for how this is done.  */)
     {
       if (!window_resize_check (o, horflag))
         error ("Resizing old window failed");
-      else if (XINT (pixel_size) + XINT (o->new_pixel)
+      else if (XFIXNUM (pixel_size) + XFIXNUM (o->new_pixel)
                != (horflag ? o->pixel_width : o->pixel_height))
         error ("Sum of sizes of old and new window don't fit");
     }
@@ -4511,7 +4511,7 @@ set correctly.  See the code of `split-window' for how this is done.  */)
   while (c)
     {
       if (c != n)
-        sum = sum + XINT (c->new_total);
+        sum = sum + XFIXNUM (c->new_total);
       c = NILP (c->next) ? 0 : XWINDOW (c->next);
     }
   wset_new_total (n, make_fixnum ((horflag
@@ -4596,7 +4596,7 @@ Signal an error when WINDOW is the only window on its frame.  */)
     }
 
   if (window_resize_check (r, horflag)
-      && (XINT (r->new_pixel)
+      && (XFIXNUM (r->new_pixel)
           == (horflag ? r->pixel_width : r->pixel_height)))
     /* We can delete WINDOW now.  */
     {
@@ -4735,12 +4735,12 @@ grow_mini_window (struct window *w, int delta, bool pixelwise)
 
           if (pixelwise)
             {
-              pixel_height = min (-XINT (height), INT_MAX - w->pixel_height);
+              pixel_height = min (-XFIXNUM (height), INT_MAX - w->pixel_height);
               line_height = pixel_height / FRAME_LINE_HEIGHT (f);
             }
           else
             {
-              line_height = min (-XINT (height),
+              line_height = min (-XFIXNUM (height),
                                  ((INT_MAX - w->pixel_height)
                                   / FRAME_LINE_HEIGHT (f)));
               pixel_height = line_height * FRAME_LINE_HEIGHT (f);
@@ -4831,13 +4831,13 @@ DEFUN ("resize-mini-window-internal", Fresize_mini_window_internal, Sresize_mini
   r = XWINDOW (FRAME_ROOT_WINDOW (f));
   height = r->pixel_height + w->pixel_height;
   if (window_resize_check (r, false)
-      && XINT (w->new_pixel) > 0
-      && height == XINT (r->new_pixel) + XINT (w->new_pixel))
+      && XFIXNUM (w->new_pixel) > 0
+      && height == XFIXNUM (r->new_pixel) + XFIXNUM (w->new_pixel))
     {
       block_input ();
       window_resize_apply (r, false);
 
-      w->pixel_height = XFASTINT (w->new_pixel);
+      w->pixel_height = XFIXNAT (w->new_pixel);
       w->total_lines = w->pixel_height / FRAME_LINE_HEIGHT (f);
       w->pixel_top = r->pixel_top + r->pixel_height;
       w->top_line = r->top_line + r->total_lines;
@@ -5128,9 +5128,9 @@ window_scroll_pixel_based (Lisp_Object window, int n, bool whole, bool noerror)
                   /* If there are other text lines above the current row,
                      move window start to current row.  Else to next row. */
                   if (rbot > 0)
-                    spos = XINT (Fline_beginning_position (Qnil));
+                    spos = XFIXNUM (Fline_beginning_position (Qnil));
                   else
-                    spos = min (XINT (Fline_end_position (Qnil)) + 1, ZV);
+                    spos = min (XFIXNUM (Fline_end_position (Qnil)) + 1, ZV);
                   set_marker_restricted (w->start, make_fixnum (spos),
                                          w->contents);
                   w->start_at_line_beg = true;
@@ -5589,7 +5589,7 @@ window_scroll_line_based (Lisp_Object window, int n, bool whole, bool noerror)
           SET_PT_BOTH (pos, pos_byte);
           tem = Fvertical_motion (make_fixnum (ht - this_scroll_margin), window,
                                   Qnil);
-          if (XFASTINT (tem) == ht - this_scroll_margin)
+          if (XFIXNAT (tem) == ht - this_scroll_margin)
             bottom_margin = PT;
           else
             bottom_margin = PT + 1;
@@ -5680,7 +5680,7 @@ scroll_command (Lisp_Object window, Lisp_Object n, int direction)
   else
     {
       n = Fprefix_numeric_value (n);
-      window_scroll (window, XINT (n) * direction, false, false);
+      window_scroll (window, XFIXNUM (n) * direction, false, false);
     }
 
   if (other_window)
@@ -5804,7 +5804,7 @@ by this function.  This happens in an interactive call.  */)
   struct window *w = XWINDOW (selected_window);
   EMACS_INT requested_arg = (NILP (arg)
                              ? window_body_width (w, 0) - 2
-                             : XINT (Fprefix_numeric_value (arg)));
+                             : XFIXNUM (Fprefix_numeric_value (arg)));
   Lisp_Object result = set_window_hscroll (w, w->hscroll + requested_arg);
 
   if (!NILP (set_minimum))
@@ -5829,7 +5829,7 @@ by this function.  This happens in an interactive call.  */)
   struct window *w = XWINDOW (selected_window);
   EMACS_INT requested_arg = (NILP (arg)
                              ? window_body_width (w, 0) - 2
-                             : XINT (Fprefix_numeric_value (arg)));
+                             : XFIXNUM (Fprefix_numeric_value (arg)));
   Lisp_Object result = set_window_hscroll (w, w->hscroll - requested_arg);
 
   if (!NILP (set_minimum))
@@ -5962,7 +5962,7 @@ and redisplay normally--don't erase and redraw the frame.  */)
     {
       arg = Fprefix_numeric_value (arg);
       CHECK_FIXNUM (arg);
-      iarg = XINT (arg);
+      iarg = XFIXNUM (arg);
     }
 
   /* Do this after making BUF current
@@ -6210,7 +6210,7 @@ from the top of the window.  */)
     XSETFASTINT (arg, lines / 2);
   else
     {
-      EMACS_INT iarg = XINT (Fprefix_numeric_value (arg));
+      EMACS_INT iarg = XFIXNUM (Fprefix_numeric_value (arg));
 
       if (iarg < 0)
         iarg = iarg + lines;
@@ -6233,7 +6233,7 @@ from the top of the window.  */)
 
   /* Skip past a partially visible first line.  */
   if (w->vscroll)
-    XSETINT (arg, XINT (arg) + 1);
+    XSETINT (arg, XFIXNUM (arg) + 1);
 
   return Fvertical_motion (arg, window, Qnil);
 }
@@ -6471,14 +6471,14 @@ the return value is nil.  Otherwise the value is t.  */)
 
           if (!NILP (p->parent))
             wset_parent
-              (w, SAVED_WINDOW_N (saved_windows, XFASTINT (p->parent))->window);
+              (w, SAVED_WINDOW_N (saved_windows, XFIXNAT (p->parent))->window);
           else
             wset_parent (w, Qnil);
 
           if (!NILP (p->prev))
             {
               wset_prev
-                (w, SAVED_WINDOW_N (saved_windows, XFASTINT (p->prev))->window);
+                (w, SAVED_WINDOW_N (saved_windows, XFIXNAT (p->prev))->window);
               wset_next (XWINDOW (w->prev), p->window);
             }
           else
@@ -6486,7 +6486,7 @@ the return value is nil.  Otherwise the value is t.  */)
               wset_prev (w, Qnil);
               if (!NILP (w->parent))
                 wset_combination (XWINDOW (w->parent),
-                                  (XINT (p->total_cols)
+                                  (XFIXNUM (p->total_cols)
                                    != XWINDOW (w->parent)->total_cols),
                                   p->window);
             }
@@ -6494,32 +6494,32 @@ the return value is nil.  Otherwise the value is t.  */)
           /* If we squirreled away the buffer, restore it now.  */
           if (BUFFERP (w->combination_limit))
             wset_buffer (w, w->combination_limit);
-          w->pixel_left = XFASTINT (p->pixel_left);
-          w->pixel_top = XFASTINT (p->pixel_top);
-          w->pixel_width = XFASTINT (p->pixel_width);
-          w->pixel_height = XFASTINT (p->pixel_height);
+          w->pixel_left = XFIXNAT (p->pixel_left);
+          w->pixel_top = XFIXNAT (p->pixel_top);
+          w->pixel_width = XFIXNAT (p->pixel_width);
+          w->pixel_height = XFIXNAT (p->pixel_height);
           w->pixel_width_before_size_change
-            = XFASTINT (p->pixel_width_before_size_change);
+            = XFIXNAT (p->pixel_width_before_size_change);
           w->pixel_height_before_size_change
-            = XFASTINT (p->pixel_height_before_size_change);
-          w->left_col = XFASTINT (p->left_col);
-          w->top_line = XFASTINT (p->top_line);
-          w->total_cols = XFASTINT (p->total_cols);
-          w->total_lines = XFASTINT (p->total_lines);
+            = XFIXNAT (p->pixel_height_before_size_change);
+          w->left_col = XFIXNAT (p->left_col);
+          w->top_line = XFIXNAT (p->top_line);
+          w->total_cols = XFIXNAT (p->total_cols);
+          w->total_lines = XFIXNAT (p->total_lines);
           wset_normal_cols (w, p->normal_cols);
           wset_normal_lines (w, p->normal_lines);
-          w->hscroll = XFASTINT (p->hscroll);
+          w->hscroll = XFIXNAT (p->hscroll);
           w->suspend_auto_hscroll = !NILP (p->suspend_auto_hscroll);
-          w->min_hscroll = XFASTINT (p->min_hscroll);
-          w->hscroll_whole = XFASTINT (p->hscroll_whole);
+          w->min_hscroll = XFIXNAT (p->min_hscroll);
+          w->hscroll_whole = XFIXNAT (p->hscroll_whole);
           wset_display_table (w, p->display_table);
-          w->left_margin_cols = XINT (p->left_margin_cols);
-          w->right_margin_cols = XINT (p->right_margin_cols);
-          w->left_fringe_width = XINT (p->left_fringe_width);
-          w->right_fringe_width = XINT (p->right_fringe_width);
+          w->left_margin_cols = XFIXNUM (p->left_margin_cols);
+          w->right_margin_cols = XFIXNUM (p->right_margin_cols);
+          w->left_fringe_width = XFIXNUM (p->left_fringe_width);
+          w->right_fringe_width = XFIXNUM (p->right_fringe_width);
           w->fringes_outside_margins = !NILP (p->fringes_outside_margins);
-          w->scroll_bar_width = XINT (p->scroll_bar_width);
-          w->scroll_bar_height = XINT (p->scroll_bar_height);
+          w->scroll_bar_width = XFIXNUM (p->scroll_bar_width);
+          w->scroll_bar_height = XFIXNUM (p->scroll_bar_height);
           wset_vertical_scroll_bar_type (w, p->vertical_scroll_bar_type);
           wset_horizontal_scroll_bar_type (w, p->horizontal_scroll_bar_type);
           wset_dedicated (w, p->dedicated);
@@ -7042,7 +7042,7 @@ extract_dimension (Lisp_Object dimension)
   if (NILP (dimension))
     return -1;
   CHECK_RANGED_INTEGER (dimension, 0, INT_MAX);
-  return XINT (dimension);
+  return XFIXNUM (dimension);
 }
 
 static struct window *
diff --git a/src/xdisp.c b/src/xdisp.c
index 4af0a6d2e3f..e30f800b7ee 100644
--- a/src/xdisp.c
+++ b/src/xdisp.c
@@ -1251,7 +1251,7 @@ default_line_pixel_height (struct window *w)
       if (!NILP (val))
         {
           if (RANGED_FIXNUMP (0, val, INT_MAX))
-            height += XFASTINT (val);
+            height += XFIXNAT (val);
           else if (FLOATP (val))
             {
               int addon = XFLOAT_DATA (val) * height + 0.5;
@@ -1550,8 +1550,8 @@ pos_visible_p (struct window *w, ptrdiff_t charpos, int *x, int *y,
                   startpos =
                     Fprevious_single_char_property_change (endpos, Qdisplay,
                                                            Qnil, Qnil);
-                  start = XFASTINT (startpos);
-                  end = XFASTINT (endpos);
+                  start = XFIXNAT (startpos);
+                  end = XFIXNAT (endpos);
                   /* Move to the last buffer position before the
                      display property.  */
                   start_display (&it3, w, top);
@@ -2843,7 +2843,7 @@ init_iterator (struct it *it, struct window *w,
       && FRAME_WINDOW_P (it->f))
     {
       if (FIXNATP (BVAR (current_buffer, extra_line_spacing)))
-        it->extra_line_spacing = XFASTINT (BVAR (current_buffer, extra_line_spacing));
+        it->extra_line_spacing = XFIXNAT (BVAR (current_buffer, extra_line_spacing));
       else if (FLOATP (BVAR (current_buffer, extra_line_spacing)))
         it->extra_line_spacing = (XFLOAT_DATA (BVAR (current_buffer, extra_line_spacing))
                                   * FRAME_LINE_HEIGHT (it->f));
@@ -2870,7 +2870,7 @@ init_iterator (struct it *it, struct window *w,
      invisible.  */
   it->selective = (FIXNUMP (BVAR (current_buffer, selective_display))
                    ? (clip_to_bounds
-                      (-1, XINT (BVAR (current_buffer, selective_display)),
+                      (-1, XFIXNUM (BVAR (current_buffer, selective_display)),
                        PTRDIFF_MAX))
                    : (!NILP (BVAR (current_buffer, selective_display))
                       ? -1 : 0));
@@ -2891,7 +2891,7 @@ init_iterator (struct it *it, struct window *w,
       = marker_position (w->redisplay_end_trigger);
   else if (FIXNUMP (w->redisplay_end_trigger))
     it->redisplay_end_trigger_charpos
-      = clip_to_bounds (PTRDIFF_MIN, XINT (w->redisplay_end_trigger),
+      = clip_to_bounds (PTRDIFF_MIN, XFIXNUM (w->redisplay_end_trigger),
                         PTRDIFF_MAX);
 
   it->tab_width = SANE_TAB_WIDTH (current_buffer);
@@ -2905,7 +2905,7 @@ init_iterator (struct it *it, struct window *w,
           || NILP (Vtruncate_partial_width_windows)
           || (FIXNUMP (Vtruncate_partial_width_windows)
               /* PXW: Shall we do something about this?  */
-              && (XINT (Vtruncate_partial_width_windows)
+              && (XFIXNUM (Vtruncate_partial_width_windows)
                   <= WINDOW_TOTAL_COLS (it->w))))
       && NILP (BVAR (current_buffer, truncate_lines)))
     it->line_wrap = NILP (BVAR (current_buffer, word_wrap))
@@ -3599,7 +3599,7 @@ compute_stop_pos (struct it *it)
       for (next_iv = next_interval (iv);
            (next_iv
             && (NILP (limit)
-                || XFASTINT (limit) > next_iv->position));
+                || XFIXNAT (limit) > next_iv->position));
            next_iv = next_interval (next_iv))
         {
           for (p = it_props; p->handler; ++p)
@@ -3617,9 +3617,9 @@ compute_stop_pos (struct it *it)
       if (next_iv)
         {
           if (FIXNUMP (limit)
-              && next_iv->position >= XFASTINT (limit))
+              && next_iv->position >= XFIXNAT (limit))
             /* No text property change up to limit.  */
-            it->stop_charpos = min (XFASTINT (limit), it->stop_charpos);
+            it->stop_charpos = min (XFIXNAT (limit), it->stop_charpos);
           else
             /* Text properties change in next_iv.  */
             it->stop_charpos = min (it->stop_charpos, next_iv->position);
@@ -3758,7 +3758,7 @@ compute_display_string_pos (struct text_pos *position,
   limpos = make_fixnum (lim);
   do {
     pos = Fnext_single_char_property_change (pos, Qdisplay, object1, limpos);
-    CHARPOS (tpos) = XFASTINT (pos);
+    CHARPOS (tpos) = XFIXNAT (pos);
     if (CHARPOS (tpos) >= lim)
       {
         *disp_prop = 0;
@@ -3819,7 +3819,7 @@ compute_display_string_end (ptrdiff_t charpos, struct bidi_string_data *string)
      changes.  */
   pos = Fnext_single_char_property_change (pos, Qdisplay, object, Qnil);
 
-  return XFASTINT (pos);
+  return XFIXNAT (pos);
 }
 
 
@@ -4376,7 +4376,7 @@ handle_invisible_prop (struct it *it)
               eassert (FIXNUMP (end_charpos));
               if (FIXNUMP (end_charpos))
                 {
-                  endpos = XFASTINT (end_charpos);
+                  endpos = XFIXNAT (end_charpos);
                   prop = Fget_text_property (end_charpos, Qinvisible, it->string);
                   invis = TEXT_PROP_MEANS_INVISIBLE (prop);
                   if (invis == 2)
@@ -4863,11 +4863,11 @@ display_prop_end (struct it *it, Lisp_Object object, struct text_pos start_pos)
 
   end = Fnext_single_char_property_change (make_fixnum (CHARPOS (start_pos)),
                                            Qdisplay, object, Qnil);
-  CHARPOS (end_pos) = XFASTINT (end);
+  CHARPOS (end_pos) = XFIXNAT (end);
   if (STRINGP (object))
     compute_string_pos (&end_pos, start_pos, it->string);
   else
-    BYTEPOS (end_pos) = CHAR_TO_BYTE (XFASTINT (end));
+    BYTEPOS (end_pos) = CHAR_TO_BYTE (XFIXNAT (end));
 
   return end_pos;
 }
@@ -4965,7 +4965,7 @@ handle_single_display_spec (struct it *it, Lisp_Object spec, Lisp_Object object,
                   && RANGED_FIXNUMP (0, XCAR (XCDR (it->font_height)), INT_MAX))
                 {
                   /* `(+ N)' or `(- N)' where N is an integer.  */
-                  int steps = XINT (XCAR (XCDR (it->font_height)));
+                  int steps = XFIXNUM (XCAR (XCDR (it->font_height)));
                   if (EQ (XCAR (it->font_height), Qplus))
                     steps = - steps;
                   it->face_id = smaller_face (it->f, it->face_id, steps);
@@ -4989,7 +4989,7 @@ handle_single_display_spec (struct it *it, Lisp_Object spec, Lisp_Object object,
                   f = FACE_FROM_ID (it->f,
                                     lookup_basic_face (it->w, it->f, DEFAULT_FACE_ID));
                   new_height = (XFLOATINT (it->font_height)
-                                * XINT (f->lface[LFACE_HEIGHT_INDEX]));
+                                * XFIXNUM (f->lface[LFACE_HEIGHT_INDEX]));
                 }
               else if (enable_eval_p)
                 {
@@ -5517,7 +5517,7 @@ string_buffer_position_lim (Lisp_Object string,
         }
     }
 
-  return found ? XINT (pos) : 0;
+  return found ? XFIXNUM (pos) : 0;
 }
 
 /* Determine which buffer position in current buffer STRING comes from.
@@ -5852,7 +5852,7 @@ load_overlay_strings (struct it *it, ptrdiff_t charpos)
       entries[n].string = (STRING);                                     \
       entries[n].overlay = (OVERLAY);                                   \
       priority = Foverlay_get ((OVERLAY), Qpriority);                   \
-      entries[n].priority = FIXNUMP (priority) ? XINT (priority) : 0;  \
+      entries[n].priority = FIXNUMP (priority) ? XFIXNUM (priority) : 0;  \
       entries[n].after_string_p = (AFTER_P);                            \
       ++n;                                                              \
     }                                                                   \
@@ -10144,7 +10144,7 @@ include the height of both, if present, in the return value.  */)
   else
     {
       CHECK_FIXNUM_COERCE_MARKER (from);
-      start = min (max (XINT (from), BEGV), ZV);
+      start = min (max (XFIXNUM (from), BEGV), ZV);
     }
 
   if (NILP (to))
@@ -10161,16 +10161,16 @@ include the height of both, if present, in the return value.  */)
   else
     {
       CHECK_FIXNUM_COERCE_MARKER (to);
-      end = max (start, min (XINT (to), ZV));
+      end = max (start, min (XFIXNUM (to), ZV));
     }
 
   if (!NILP (x_limit) && RANGED_FIXNUMP (0, x_limit, INT_MAX))
-    max_x = XINT (x_limit);
+    max_x = XFIXNUM (x_limit);
 
   if (NILP (y_limit))
     max_y = INT_MAX;
   else if (RANGED_FIXNUMP (0, y_limit, INT_MAX))
-    max_y = XINT (y_limit);
+    max_y = XFIXNUM (y_limit);
 
   itdata = bidi_shelve_cache ();
   SET_TEXT_POS (startp, start, CHAR_TO_BYTE (start));
@@ -10460,7 +10460,7 @@ message_dolog (const char *m, ptrdiff_t nbytes, bool nlflag, bool multibyte)
           if (FIXNATP (Vmessage_log_max))
             {
               scan_newline (Z, Z_BYTE, BEG, BEG_BYTE,
-                            -XFASTINT (Vmessage_log_max) - 1, false);
+                            -XFIXNAT (Vmessage_log_max) - 1, false);
               del_range_both (BEG, BEG_BYTE, PT, PT_BYTE, false);
             }
         }
@@ -11000,7 +11000,7 @@ unwind_with_echo_area_buffer (Lisp_Object vector)
 {
   set_buffer_internal_1 (XBUFFER (AREF (vector, 0)));
   Vdeactivate_mark = AREF (vector, 1);
-  windows_or_buffers_changed = XFASTINT (AREF (vector, 2));
+  windows_or_buffers_changed = XFIXNAT (AREF (vector, 2));
 
   if (WINDOWP (AREF (vector, 3)))
     {
@@ -11012,14 +11012,14 @@ unwind_with_echo_area_buffer (Lisp_Object vector)
 
       wset_buffer (w, buffer);
       set_marker_both (w->pointm, buffer,
-                       XFASTINT (AREF (vector, 5)),
-                       XFASTINT (AREF (vector, 6)));
+                       XFIXNAT (AREF (vector, 5)),
+                       XFIXNAT (AREF (vector, 6)));
       set_marker_both (w->old_pointm, buffer,
-                       XFASTINT (AREF (vector, 7)),
-                       XFASTINT (AREF (vector, 8)));
+                       XFIXNAT (AREF (vector, 7)),
+                       XFIXNAT (AREF (vector, 8)));
       set_marker_both (w->start, buffer,
-                       XFASTINT (AREF (vector, 9)),
-                       XFASTINT (AREF (vector, 10)));
+                       XFIXNAT (AREF (vector, 9)),
+                       XFIXNAT (AREF (vector, 10)));
     }
 
   Vwith_echo_area_save_vector = vector;
@@ -11280,7 +11280,7 @@ resize_mini_window (struct window *w, bool exact_p)
       if (FLOATP (Vmax_mini_window_height))
         max_height = XFLOAT_DATA (Vmax_mini_window_height) * total_height;
       else if (FIXNUMP (Vmax_mini_window_height))
-        max_height = XINT (Vmax_mini_window_height) * unit;
+        max_height = XFIXNUM (Vmax_mini_window_height) * unit;
       else
         max_height = total_height / 4;
 
@@ -11871,8 +11871,8 @@ unwind_format_mode_line (Lisp_Object vector)
   Lisp_Object target_frame_window = AREF (vector, 8);
   Lisp_Object old_top_frame = AREF (vector, 9);
 
-  mode_line_target = XINT (AREF (vector, 0));
-  mode_line_noprop_ptr = mode_line_noprop_buf + XINT (AREF (vector, 1));
+  mode_line_target = XFIXNUM (AREF (vector, 0));
+  mode_line_noprop_ptr = mode_line_noprop_buf + XFIXNUM (AREF (vector, 1));
   mode_line_string_list = AREF (vector, 2);
   if (! EQ (AREF (vector, 3), Qt))
     mode_line_proptrans_alist = AREF (vector, 3);
@@ -12488,18 +12488,18 @@ build_desired_tool_bar_string (struct frame *f)
       if (RANGED_FIXNUMP (1, Vtool_bar_button_margin,
                            INT_MAX - max (hmargin, vmargin)))
         {
-          hmargin += XFASTINT (Vtool_bar_button_margin);
-          vmargin += XFASTINT (Vtool_bar_button_margin);
+          hmargin += XFIXNAT (Vtool_bar_button_margin);
+          vmargin += XFIXNAT (Vtool_bar_button_margin);
         }
       else if (CONSP (Vtool_bar_button_margin))
         {
           if (RANGED_FIXNUMP (1, XCAR (Vtool_bar_button_margin),
                                INT_MAX - hmargin))
-            hmargin += XFASTINT (XCAR (Vtool_bar_button_margin));
+            hmargin += XFIXNAT (XCAR (Vtool_bar_button_margin));
 
           if (RANGED_FIXNUMP (1, XCDR (Vtool_bar_button_margin),
                                INT_MAX - vmargin))
-            vmargin += XFASTINT (XCDR (Vtool_bar_button_margin));
+            vmargin += XFIXNAT (XCDR (Vtool_bar_button_margin));
         }
 
       if (auto_raise_tool_bar_buttons_p)
@@ -12836,7 +12836,7 @@ redisplay_tool_bar (struct frame *f)
       int border, rows, height, extra;
 
       if (TYPE_RANGED_FIXNUMP (int, Vtool_bar_border))
-        border = XINT (Vtool_bar_border);
+        border = XFIXNUM (Vtool_bar_border);
       else if (EQ (Vtool_bar_border, Qinternal_border_width))
         border = FRAME_INTERNAL_BORDER_WIDTH (f);
       else if (EQ (Vtool_bar_border, Qborder_width))
@@ -12958,7 +12958,7 @@ tool_bar_item_info (struct frame *f, struct glyph *glyph, int *prop_idx)
                              Qmenu_item, f->current_tool_bar_string);
   if (! FIXNUMP (prop))
     return false;
-  *prop_idx = XINT (prop);
+  *prop_idx = XFIXNUM (prop);
   return true;
 }
 
@@ -13205,7 +13205,7 @@ hscroll_window_tree (Lisp_Object window)
     }
   else if (TYPE_RANGED_FIXNUMP (int, Vhscroll_step))
     {
-      hscroll_step_abs = XINT (Vhscroll_step);
+      hscroll_step_abs = XFIXNUM (Vhscroll_step);
       if (hscroll_step_abs < 0)
         hscroll_step_abs = 0;
     }
@@ -13562,7 +13562,7 @@ text_outside_line_unchanged_p (struct window *w,
          beginning of the line.  */
       if (unchanged_p
           && FIXNUMP (BVAR (current_buffer, selective_display))
-          && XINT (BVAR (current_buffer, selective_display)) > 0
+          && XFIXNUM (BVAR (current_buffer, selective_display)) > 0
           && (BEG_UNCHANGED < start || GPT <= start))
         unchanged_p = false;
 
@@ -14144,7 +14144,7 @@ redisplay_internal (void)
   {                                                                     \
     Lisp_Object entry = Fgethash (make_fixnum (i), a, make_fixnum (0)); \
     if (FIXNUMP (entry))                                                \
-      Fputhash (make_fixnum (i), make_fixnum (1 + XINT (entry)), a);    \
+      Fputhash (make_fixnum (i), make_fixnum (1 + XFIXNUM (entry)), a); \
   }
 
   AINC (Vredisplay__all_windows_cause, windows_or_buffers_changed);
@@ -15136,7 +15136,7 @@ set_cursor_from_row (struct window *w, struct glyph_row *row,
               }
             if (FIXNUMP (chprop))
               {
-                bpos_covered = bpos_max + XINT (chprop);
+                bpos_covered = bpos_max + XFIXNUM (chprop);
                 /* If the `cursor' property covers buffer positions up
                    to and including point, we should display cursor on
                    this glyph.  Note that, if a `cursor' property on one
@@ -15210,7 +15210,7 @@ set_cursor_from_row (struct window *w, struct glyph_row *row,
               }
             if (FIXNUMP (chprop))
               {
-                bpos_covered = bpos_max + XINT (chprop);
+                bpos_covered = bpos_max + XFIXNUM (chprop);
                 /* If the `cursor' property covers buffer positions up
                    to and including point, we should display cursor on
                    this glyph.  */
@@ -16943,7 +16943,7 @@ redisplay_window (Lisp_Object window, bool just_this_one_p)
                                                    Qnil, Qnil);
 
               if (FIXNATP (invprop_end))
-                alt_pt = XFASTINT (invprop_end);
+                alt_pt = XFIXNAT (invprop_end);
               else
                 alt_pt = ZV;
               r = row_containing_pos (w, alt_pt, w->desired_matrix->rows,
@@ -17475,7 +17475,7 @@ redisplay_window (Lisp_Object window, bool just_this_one_p)
                                                    Qnil, Qnil);
 
               if (FIXNATP (invis_end))
-                alt_pos = XFASTINT (invis_end);
+                alt_pos = XFIXNAT (invis_end);
               else
                 alt_pos = ZV;
               row = row_containing_pos (w, alt_pos, matrix->rows, NULL, 0);
@@ -19584,7 +19584,7 @@ with numeric argument, its value is passed as the GLYPHS flag.  */)
            w->cursor.x, w->cursor.y, w->cursor.hpos, w->cursor.vpos);
   fprintf (stderr, "=============================================\n");
   dump_glyph_matrix (w->current_matrix,
-                     TYPE_RANGED_FIXNUMP (int, glyphs) ? XINT (glyphs) : 0);
+                     TYPE_RANGED_FIXNUMP (int, glyphs) ? XFIXNUM (glyphs) : 0);
   return Qnil;
 }
 
@@ -19629,13 +19629,13 @@ GLYPHS > 1 or omitted means dump glyphs in long form.  */)
   else
     {
       CHECK_FIXNUM (row);
-      vpos = XINT (row);
+      vpos = XFIXNUM (row);
     }
   matrix = XWINDOW (selected_window)->current_matrix;
   if (vpos >= 0 && vpos < matrix->nrows)
     dump_glyph_row (MATRIX_ROW (matrix, vpos),
                     vpos,
-                    TYPE_RANGED_FIXNUMP (int, glyphs) ? XINT (glyphs) : 2);
+                    TYPE_RANGED_FIXNUMP (int, glyphs) ? XFIXNUM (glyphs) : 2);
   return Qnil;
 }
 
@@ -19661,11 +19661,11 @@ do nothing.  */)
   else
     {
       CHECK_FIXNUM (row);
-      vpos = XINT (row);
+      vpos = XFIXNUM (row);
     }
   if (vpos >= 0 && vpos < m->nrows)
     dump_glyph_row (MATRIX_ROW (m, vpos), vpos,
-                    TYPE_RANGED_FIXNUMP (int, glyphs) ? XINT (glyphs) : 2);
+                    TYPE_RANGED_FIXNUMP (int, glyphs) ? XFIXNUM (glyphs) : 2);
 #endif
   return Qnil;
 }
@@ -19681,7 +19681,7 @@ With ARG, turn tracing on if and only if ARG is positive.  */)
   else
     {
       arg = Fprefix_numeric_value (arg);
-      trace_redisplay_p = XINT (arg) > 0;
+      trace_redisplay_p = XFIXNUM (arg) > 0;
     }
 
   return Qnil;
@@ -20147,8 +20147,8 @@ append_space_for_newline (struct it *it, bool default_face_p)
                   it->phys_ascent = it->ascent;
                   it->phys_descent = it->descent;
                   if (!NILP (height)
-                      && XINT (height) > it->ascent + it->descent)
-                    it->ascent = XINT (height) - it->descent;
+                      && XFIXNUM (height) > it->ascent + it->descent)
+                    it->ascent = XFIXNUM (height) - it->descent;
 
                   if (!NILP (total_height))
                     spacing = calc_line_height_property (it, total_height, font,
@@ -20161,7 +20161,7 @@ append_space_for_newline (struct it *it, bool default_face_p)
                     }
                   if (FIXNUMP (spacing))
                     {
-                      extra_line_spacing = XINT (spacing);
+                      extra_line_spacing = XFIXNUM (spacing);
                       if (!NILP (total_height))
                         extra_line_spacing -= (it->phys_ascent + it->phys_descent);
                     }
@@ -21129,7 +21129,7 @@ maybe_produce_line_number (struct it *it)
   if (!it->lnum_width)
     {
       if (FIXNATP (Vdisplay_line_numbers_width))
-        it->lnum_width = XFASTINT (Vdisplay_line_numbers_width);
+        it->lnum_width = XFIXNAT (Vdisplay_line_numbers_width);
 
       /* Max line number to be displayed cannot be more than the one
          corresponding to the last row of the desired matrix.  */
@@ -22186,7 +22186,7 @@ display_line (struct it *it, int cursor_vpos)
       else
         {
           eassert (FIXNUMP (overlay_arrow_string));
-          row->overlay_arrow_bitmap = XINT (overlay_arrow_string);
+          row->overlay_arrow_bitmap = XFIXNUM (overlay_arrow_string);
         }
       overlay_arrow_seen = true;
     }
@@ -22449,8 +22449,8 @@ the `bidi-class' property of a character.  */)
 
       set_buffer_temp (buf);
       validate_region (&from, &to);
-      from_pos = XINT (from);
-      to_pos = XINT (to);
+      from_pos = XFIXNUM (from);
+      to_pos = XFIXNUM (to);
       if (from_pos >= ZV)
         return Qnil;
 
@@ -22519,7 +22519,7 @@ Value is the new character position of point.  */)
    && !(GLYPH)->avoid_cursor_p)
 
   CHECK_FIXNUM (direction);
-  dir = XINT (direction);
+  dir = XFIXNUM (direction);
   if (dir > 0)
     dir = 1;
   else
@@ -22990,7 +22990,7 @@ Emacs UBA implementation, in particular with the test suite.  */)
   else
     {
       CHECK_FIXNUM_COERCE_MARKER (vpos);
-      nrow = XINT (vpos);
+      nrow = XFIXNUM (vpos);
     }
 
   /* We require up-to-date glyph matrix for this window.  */
@@ -23912,7 +23912,7 @@ display_mode_element (struct it *it, int depth, int field_width, int precision,
           }
         else if (FIXNUMP (car))
           {
-            register int lim = XINT (car);
+            register int lim = XFIXNUM (car);
             elt = XCDR (elt);
             if (lim < 0)
               {
@@ -24032,7 +24032,7 @@ store_mode_line_string (const char *string, Lisp_Object lisp_string,
     }
   else
     {
-      len = XFASTINT (Flength (lisp_string));
+      len = XFIXNAT (Flength (lisp_string));
       if (precision > 0 && len > precision)
         {
           len = precision;
@@ -24362,7 +24362,7 @@ decode_mode_spec_coding (Lisp_Object coding_system, char *buf, bool eol_flag)
       eolvalue = AREF (val, 2);
 
       *buf++ = multibyte
-        ? XFASTINT (CODING_ATTR_MNEMONIC (attrs))
+        ? XFIXNAT (CODING_ATTR_MNEMONIC (attrs))
         : ' ';
 
       if (eol_flag)
@@ -24391,7 +24391,7 @@ decode_mode_spec_coding (Lisp_Object coding_system, char *buf, bool eol_flag)
         }
       else if (CHARACTERP (eoltype))
         {
-          int c = XFASTINT (eoltype);
+          int c = XFIXNAT (eoltype);
           return buf + CHAR_STRING (c, (unsigned char *) buf);
         }
       else
@@ -24598,7 +24598,7 @@ decode_mode_spec (struct window *w, register int c, int field_width,
 
         /* If the buffer is very big, don't waste time.  */
         if (FIXNUMP (Vline_number_display_limit)
-            && BUF_ZV (b) - BUF_BEGV (b) > XINT (Vline_number_display_limit))
+            && BUF_ZV (b) - BUF_BEGV (b) > XFIXNUM (Vline_number_display_limit))
           {
             w->base_line_pos = 0;
             w->base_line_number = 0;
@@ -27191,22 +27191,22 @@ produce_image_glyph (struct it *it)
   slice.height = img->height;
 
   if (FIXNUMP (it->slice.x))
-    slice.x = XINT (it->slice.x);
+    slice.x = XFIXNUM (it->slice.x);
   else if (FLOATP (it->slice.x))
     slice.x = XFLOAT_DATA (it->slice.x) * img->width;
 
   if (FIXNUMP (it->slice.y))
-    slice.y = XINT (it->slice.y);
+    slice.y = XFIXNUM (it->slice.y);
   else if (FLOATP (it->slice.y))
     slice.y = XFLOAT_DATA (it->slice.y) * img->height;
 
   if (FIXNUMP (it->slice.width))
-    slice.width = XINT (it->slice.width);
+    slice.width = XFIXNUM (it->slice.width);
   else if (FLOATP (it->slice.width))
     slice.width = XFLOAT_DATA (it->slice.width) * img->width;
 
   if (FIXNUMP (it->slice.height))
-    slice.height = XINT (it->slice.height);
+    slice.height = XFIXNUM (it->slice.height);
   else if (FLOATP (it->slice.height))
     slice.height = XFLOAT_DATA (it->slice.height) * img->height;
 
@@ -27886,7 +27886,7 @@ calc_line_height_property (struct it *it, Lisp_Object val, struct font *font,
   if (FLOATP (val))
     height = (int)(XFLOAT_DATA (val) * height);
   else if (FIXNUMP (val))
-    height *= XINT (val);
+    height *= XFIXNUM (val);
 
   return make_fixnum (height);
 }
@@ -28376,8 +28376,8 @@ x_produce_glyphs (struct it *it)
                   it->descent += face->box_line_width;
                 }
               if (!NILP (height)
-                  && XINT (height) > it->ascent + it->descent)
-                it->ascent = XINT (height) - it->descent;
+                  && XFIXNUM (height) > it->ascent + it->descent)
+                it->ascent = XFIXNUM (height) - it->descent;
 
               if (!NILP (total_height))
                 spacing = calc_line_height_property (it, total_height, font,
@@ -28390,7 +28390,7 @@ x_produce_glyphs (struct it *it)
                 }
               if (FIXNUMP (spacing))
                 {
-                  extra_line_spacing = XINT (spacing);
+                  extra_line_spacing = XFIXNUM (spacing);
                   if (!NILP (total_height))
                     extra_line_spacing -= (it->phys_ascent + it->phys_descent);
                 }
@@ -29096,7 +29096,7 @@ get_specified_cursor_type (Lisp_Object arg, int *width)
       && EQ (XCAR (arg), Qbar)
       && RANGED_FIXNUMP (0, XCDR (arg), INT_MAX))
     {
-      *width = XINT (XCDR (arg));
+      *width = XFIXNUM (XCDR (arg));
       return BAR_CURSOR;
     }
 
@@ -29110,7 +29110,7 @@ get_specified_cursor_type (Lisp_Object arg, int *width)
       && EQ (XCAR (arg), Qhbar)
       && RANGED_FIXNUMP (0, XCDR (arg), INT_MAX))
     {
-      *width = XINT (XCDR (arg));
+      *width = XFIXNUM (XCDR (arg));
       return HBAR_CURSOR;
     }
 
@@ -30733,13 +30733,13 @@ on_hot_spot_p (Lisp_Object hot_spot, int x, int y)
         return false;
       if (!CONSP (XCDR (rect)))
         return false;
-      if (!(tem = XCAR (XCAR (rect)), FIXNUMP (tem) && x >= XINT (tem)))
+      if (!(tem = XCAR (XCAR (rect)), FIXNUMP (tem) && x >= XFIXNUM (tem)))
         return false;
-      if (!(tem = XCDR (XCAR (rect)), FIXNUMP (tem) && y >= XINT (tem)))
+      if (!(tem = XCDR (XCAR (rect)), FIXNUMP (tem) && y >= XFIXNUM (tem)))
         return false;
-      if (!(tem = XCAR (XCDR (rect)), FIXNUMP (tem) && x <= XINT (tem)))
+      if (!(tem = XCAR (XCDR (rect)), FIXNUMP (tem) && x <= XFIXNUM (tem)))
         return false;
-      if (!(tem = XCDR (XCDR (rect)), FIXNUMP (tem) && y <= XINT (tem)))
+      if (!(tem = XCDR (XCDR (rect)), FIXNUMP (tem) && y <= XFIXNUM (tem)))
         return false;
       return true;
     }
@@ -30755,8 +30755,8 @@ on_hot_spot_p (Lisp_Object hot_spot, int x, int y)
           && (ly0 = XCDR (XCAR (circ)), FIXNUMP (ly0)))
         {
           double r = XFLOATINT (lr);
-          double dx = XINT (lx0) - x;
-          double dy = XINT (ly0) - y;
+          double dx = XFIXNUM (lx0) - x;
+          double dy = XFIXNUM (ly0) - y;
           return (dx * dx + dy * dy <= r * r);
         }
     }
@@ -30784,14 +30784,14 @@ on_hot_spot_p (Lisp_Object hot_spot, int x, int y)
           if ((lx = poly[n-2], !FIXNUMP (lx))
               || (ly = poly[n-1], !FIXNUMP (lx)))
             return false;
-          x0 = XINT (lx), y0 = XINT (ly);
+          x0 = XFIXNUM (lx), y0 = XFIXNUM (ly);
           for (i = 0; i < n; i += 2)
             {
               int x1 = x0, y1 = y0;
               if ((lx = poly[i], !FIXNUMP (lx))
                   || (ly = poly[i+1], !FIXNUMP (ly)))
                 return false;
-              x0 = XINT (lx), y0 = XINT (ly);
+              x0 = XFIXNUM (lx), y0 = XFIXNUM (ly);
 
               /* Does this segment cross the X line?  */
               if (x0 >= x)
@@ -30847,8 +30847,8 @@ Returns the alist element for the first matching AREA in MAP.  */)
   CHECK_FIXNUM (y);
 
   return find_hot_spot (map,
-                        clip_to_bounds (INT_MIN, XINT (x), INT_MAX),
-                        clip_to_bounds (INT_MIN, XINT (y), INT_MAX));
+                        clip_to_bounds (INT_MIN, XFIXNUM (x), INT_MAX),
+                        clip_to_bounds (INT_MIN, XFIXNUM (y), INT_MAX));
 }
 #endif  /* HAVE_WINDOW_SYSTEM */
 
@@ -31090,13 +31090,13 @@ note_mode_line_or_margin_highlight (Lisp_Object window, int x, int y,
           if (NILP (b))
             begpos = 0;
           else
-            begpos = XINT (b);
+            begpos = XFIXNUM (b);
 
           e = Fnext_single_property_change (pos, Qmouse_face, string, Qnil);
           if (NILP (e))
             endpos = SCHARS (string);
           else
-            endpos = XINT (e);
+            endpos = XFIXNUM (e);
 
           /* Calculate the glyph position GPOS of GLYPH in the
              displayed string, relative to the beginning of the
@@ -31573,7 +31573,7 @@ note_mouse_highlight (struct frame *f, int x, int y)
               if (NILP (e))
                 e = make_fixnum (SCHARS (object));
               mouse_face_from_string_pos (w, hlinfo, object,
-                                          XINT (s), XINT (e));
+                                          XFIXNUM (s), XFIXNUM (e));
               hlinfo->mouse_face_past_end = false;
               hlinfo->mouse_face_window = window;
               hlinfo->mouse_face_face_id
@@ -31658,10 +31658,10 @@ note_mouse_highlight (struct frame *f, int x, int y)
                   mouse_face_from_buffer_pos (window, hlinfo, pos,
                                               NILP (before)
                                               ? 1
-                                              : XFASTINT (before),
+                                              : XFIXNAT (before),
                                               NILP (after)
                                               ? BUF_Z (XBUFFER (buffer))
-                                              : XFASTINT (after),
+                                              : XFIXNAT (after),
                                               before_string, after_string,
                                               disp_string);
                   cursor = No_Cursor;
@@ -33316,8 +33316,8 @@ start_hourglass (void)
   cancel_hourglass ();
 
   if (FIXNUMP (Vhourglass_delay)
-      && XINT (Vhourglass_delay) > 0)
-    delay = make_timespec (min (XINT (Vhourglass_delay),
+      && XFIXNUM (Vhourglass_delay) > 0)
+    delay = make_timespec (min (XFIXNUM (Vhourglass_delay),
                                   TYPE_MAXIMUM (time_t)),
                            0);
   else if (FLOATP (Vhourglass_delay)
diff --git a/src/xfaces.c b/src/xfaces.c
index f87eb66b3ab..29168e23205 100644
--- a/src/xfaces.c
+++ b/src/xfaces.c
@@ -739,8 +739,8 @@ the pixmap.  Bits are stored row by row, each row occupies
           && RANGED_FIXNUMP (1, width, INT_MAX)
           && RANGED_FIXNUMP (1, height, INT_MAX))
         {
-          int bytes_per_row = (XINT (width) + CHAR_BIT - 1) / CHAR_BIT;
-          if (XINT (height) <= SBYTES (data) / bytes_per_row)
+          int bytes_per_row = (XFIXNUM (width) + CHAR_BIT - 1) / CHAR_BIT;
+          if (XFIXNUM (height) <= SBYTES (data) / bytes_per_row)
             pixmap_p = true;
         }
     }
@@ -773,8 +773,8 @@ load_pixmap (struct frame *f, Lisp_Object name)
       int h, w;
       Lisp_Object bits;
 
-      w = XINT (Fcar (name));
-      h = XINT (Fcar (Fcdr (name)));
+      w = XFIXNUM (Fcar (name));
+      h = XFIXNUM (Fcar (Fcdr (name)));
       bits = Fcar (Fcdr (Fcdr (name)));
 
       bitmap_id = x_create_bitmap_from_data (f, SSDATA (bits),
@@ -820,7 +820,7 @@ parse_rgb_list (Lisp_Object rgb_list, XColor *color)
 #define PARSE_RGB_LIST_FIELD(field)                                     \
   if (CONSP (rgb_list) && FIXNUMP (XCAR (rgb_list)))                    \
     {                                                                   \
-      color->field = XINT (XCAR (rgb_list));                            \
+      color->field = XFIXNUM (XCAR (rgb_list));                         \
       rgb_list = XCDR (rgb_list);                                       \
     }                                                                   \
   else                                                                  \
@@ -858,7 +858,7 @@ tty_lookup_color (struct frame *f, Lisp_Object color, XColor *tty_color,
       if (! FIXNUMP (XCAR (XCDR (color_desc))))
         return false;
 
-      tty_color->pixel = XINT (XCAR (XCDR (color_desc)));
+      tty_color->pixel = XFIXNUM (XCAR (XCDR (color_desc)));
 
       rgb = XCDR (XCDR (color_desc));
       if (! parse_rgb_list (rgb, tty_color))
@@ -1391,8 +1391,8 @@ compare_fonts_by_sort_order (const void *v1, const void *v2)
       else
         {
           if (FIXNUMP (val1))
-            result = (FIXNUMP (val2) && XINT (val1) >= XINT (val2)
-                      ? XINT (val1) > XINT (val2)
+            result = (FIXNUMP (val2) && XFIXNUM (val1) >= XFIXNUM (val2)
+                      ? XFIXNUM (val1) > XFIXNUM (val2)
                       : -1);
           else
             result = FIXNUMP (val2) ? 1 : 0;
@@ -1457,7 +1457,7 @@ the face font sort order.  */)
   font_props_for_sorting[i++] = FONT_ADSTYLE_INDEX;
   font_props_for_sorting[i++] = FONT_REGISTRY_INDEX;
 
-  ndrivers = XINT (Flength (list));
+  ndrivers = XFIXNUM (Flength (list));
   SAFE_ALLOCA_LISP (drivers, ndrivers);
   for (i = 0; i < ndrivers; i++, list = XCDR (list))
     drivers[i] = XCAR (list);
@@ -1477,7 +1477,7 @@ the face font sort order.  */)
 
       ASET (v, 0, AREF (font, FONT_FAMILY_INDEX));
       ASET (v, 1, FONT_WIDTH_SYMBOLIC (font));
-      point = PIXEL_TO_POINT (XINT (AREF (font, FONT_SIZE_INDEX)) * 10,
+      point = PIXEL_TO_POINT (XFIXNUM (AREF (font, FONT_SIZE_INDEX)) * 10,
                               FRAME_RES_Y (f));
       ASET (v, 2, make_fixnum (point));
       ASET (v, 3, FONT_WEIGHT_SYMBOLIC (font));
@@ -1566,7 +1566,7 @@ the WIDTH times as wide as FACE on FRAME.  */)
           avgwidth = FRAME_FONT (f)->average_width;
         }
       if (!NILP (width))
-        avgwidth *= XINT (width);
+        avgwidth *= XFIXNUM (width);
     }
 
   Lisp_Object font_spec = font_spec_from_name (pattern);
@@ -1585,7 +1585,7 @@ the WIDTH times as wide as FACE on FRAME.  */)
 
       font_entity = XCAR (tail);
       if ((NILP (AREF (font_entity, FONT_SIZE_INDEX))
-           || XINT (AREF (font_entity, FONT_SIZE_INDEX)) == 0)
+           || XFIXNUM (AREF (font_entity, FONT_SIZE_INDEX)) == 0)
           && ! NILP (AREF (font_spec, FONT_SIZE_INDEX)))
         {
           /* This is a scalable font.  For backward compatibility,
@@ -2051,7 +2051,7 @@ merge_face_heights (Lisp_Object from, Lisp_Object to, Lisp_Object invalid)
     {
       if (FIXNUMP (to))
         /* relative X absolute => absolute */
-        result = make_fixnum (XFLOAT_DATA (from) * XINT (to));
+        result = make_fixnum (XFLOAT_DATA (from) * XFIXNUM (to));
       else if (FLOATP (to))
         /* relative X relative => relative */
         result = make_float (XFLOAT_DATA (from) * XFLOAT_DATA (to));
@@ -2792,7 +2792,7 @@ FRAME 0 means change the face on all frames, and change the default
 
   /* If FRAME is 0, change face on all frames, and change the
      default for new frames.  */
-  if (FIXNUMP (frame) && XINT (frame) == 0)
+  if (FIXNUMP (frame) && XFIXNUM (frame) == 0)
     {
       Lisp_Object tail;
       Finternal_set_lisp_face_attribute (face, attr, value, Qt);
@@ -2862,7 +2862,7 @@ FRAME 0 means change the face on all frames, and change the default
           if (EQ (face, Qdefault))
             {
               /* The default face must have an absolute size.  */
-              if (!FIXNUMP (value) || XINT (value) <= 0)
+              if (!FIXNUMP (value) || XFIXNUM (value) <= 0)
                 signal_error ("Default face height not absolute and positive",
                               value);
             }
@@ -2873,7 +2873,7 @@ FRAME 0 means change the face on all frames, and change the default
               Lisp_Object test = merge_face_heights (value,
                                                      make_fixnum (10),
                                                      Qnil);
-              if (!FIXNUMP (test) || XINT (test) <= 0)
+              if (!FIXNUMP (test) || XFIXNUM (test) <= 0)
                 signal_error ("Face height does not produce a positive integer",
                               value);
             }
@@ -3008,7 +3008,7 @@ FRAME 0 means change the face on all frames, and change the default
       else if (NILP (value))
         valid_p = true;
       else if (FIXNUMP (value))
-        valid_p = XINT (value) != 0;
+        valid_p = XFIXNUM (value) != 0;
       else if (STRINGP (value))
         valid_p = SCHARS (value) > 0;
       else if (CONSP (value))
@@ -3029,7 +3029,7 @@ FRAME 0 means change the face on all frames, and change the default
 
               if (EQ (k, QCline_width))
                 {
-                  if (!FIXNUMP (v) || XINT (v) == 0)
+                  if (!FIXNUMP (v) || XFIXNUM (v) == 0)
                     break;
                 }
               else if (EQ (k, QCcolor))
@@ -3538,7 +3538,7 @@ DEFUN ("internal-set-lisp-face-attribute-from-resource",
   else if (EQ (attr, QCheight))
     {
       value = Fstring_to_number (value, Qnil);
-      if (!FIXNUMP (value) || XINT (value) <= 0)
+      if (!FIXNUMP (value) || XFIXNUM (value) <= 0)
         signal_error ("Invalid face height from X resource", value);
     }
   else if (EQ (attr, QCbold) || EQ (attr, QCitalic))
@@ -3928,7 +3928,7 @@ return the font name used for CHARACTER.  */)
       if (FRAME_WINDOW_P (f) && !NILP (character))
         {
           CHECK_CHARACTER (character);
-          face_id = FACE_FOR_CHAR (f, fface, XINT (character), -1, Qnil);
+          face_id = FACE_FOR_CHAR (f, fface, XFIXNUM (character), -1, Qnil);
           fface = FACE_FROM_ID_OR_NULL (f, face_id);
         }
       return ((fface && fface->font)
@@ -4685,7 +4685,7 @@ smaller_face (struct frame *f, int face_id, int steps)
 
   face = FACE_FROM_ID (f, face_id);
   memcpy (attrs, face->lface, sizeof attrs);
-  pt = last_pt = XFASTINT (attrs[LFACE_HEIGHT_INDEX]);
+  pt = last_pt = XFIXNAT (attrs[LFACE_HEIGHT_INDEX]);
   new_face_id = face_id;
   last_height = FONT_HEIGHT (face->font);
 
@@ -5679,9 +5679,9 @@ realize_x_face (struct face_cache *cache, Lisp_Object attrs[LFACE_VECTOR_SIZE])
     {
       /* Simple box of specified line width in foreground color of the
          face.  */
-      eassert (XINT (box) != 0);
+      eassert (XFIXNUM (box) != 0);
       face->box = FACE_SIMPLE_BOX;
-      face->box_line_width = XINT (box);
+      face->box_line_width = XFIXNUM (box);
       face->box_color = face->foreground;
       face->box_color_defaulted_p = true;
     }
@@ -5708,8 +5708,8 @@ realize_x_face (struct face_cache *cache, Lisp_Object attrs[LFACE_VECTOR_SIZE])
 
           if (EQ (keyword, QCline_width))
             {
-              if (FIXNUMP (value) && XINT (value) != 0)
-                face->box_line_width = XINT (value);
+              if (FIXNUMP (value) && XFIXNUM (value) != 0)
+                face->box_line_width = XFIXNUM (value);
             }
           else if (EQ (keyword, QCcolor))
             {
@@ -5875,7 +5875,7 @@ map_tty_color (struct frame *f, struct face *face,
     {
       /* Associations in tty-defined-color-alist are of the form
          (NAME INDEX R G B).  We need the INDEX part.  */
-      pixel = XINT (XCAR (XCDR (def)));
+      pixel = XFIXNUM (XCAR (XCDR (def)));
     }
 
   if (pixel == default_pixel && STRINGP (color))
@@ -6075,7 +6075,7 @@ face_at_buffer_position (struct window *w, ptrdiff_t pos,
   XSETFASTINT (limit1, (limit < endpos ? limit : endpos));
   end = Fnext_single_property_change (position, propname, w->contents, limit1);
   if (FIXNUMP (end))
-    endpos = XINT (end);
+    endpos = XFIXNUM (end);
 
   /* Look at properties from overlays.  */
   USE_SAFE_ALLOCA;
@@ -6204,7 +6204,7 @@ face_for_overlay_string (struct window *w, ptrdiff_t pos,
   XSETFASTINT (limit1, (limit < endpos ? limit : endpos));
   end = Fnext_single_property_change (position, propname, w->contents, limit1);
   if (FIXNUMP (end))
-    endpos = XINT (end);
+    endpos = XFIXNUM (end);
 
   *endptr = endpos;
 
@@ -6277,7 +6277,7 @@ face_at_string_position (struct window *w, Lisp_Object string,
   XSETFASTINT (limit, SCHARS (string));
   end = Fnext_single_property_change (position, prop_name, string, limit);
   if (FIXNUMP (end))
-    *endptr = XFASTINT (end);
+    *endptr = XFIXNAT (end);
   else
     *endptr = -1;
 
@@ -6477,7 +6477,7 @@ DEFUN ("dump-face", Fdump_face, Sdump_face, 0, 1, 0, doc: /* */)
     {
       struct face *face;
       CHECK_FIXNUM (n);
-      face = FACE_FROM_ID_OR_NULL (SELECTED_FRAME (), XINT (n));
+      face = FACE_FROM_ID_OR_NULL (SELECTED_FRAME (), XFIXNUM (n));
       if (face == NULL)
         error ("Not a valid face");
       dump_realized_face (face);
diff --git a/src/xfns.c b/src/xfns.c
index 224e090ebcf..d9df03e7ef3 100644
--- a/src/xfns.c
+++ b/src/xfns.c
@@ -1233,7 +1233,7 @@ x_set_mouse_color (struct frame *f, Lisp_Object arg, Lisp_Object oldval)
       if (!NILP (shape_var))
         {
           CHECK_TYPE_RANGED_INTEGER (unsigned, shape_var);
-          cursor_data.cursor_num[i] = XINT (shape_var);
+          cursor_data.cursor_num[i] = XFIXNUM (shape_var);
         }
       else
         cursor_data.cursor_num[i] = mouse_cursor_types[i].default_shape;
@@ -1532,7 +1532,7 @@ x_set_menu_bar_lines (struct frame *f, Lisp_Object value, Lisp_Object oldval)
     return;
 
   if (TYPE_RANGED_FIXNUMP (int, value))
-    nlines = XINT (value);
+    nlines = XFIXNUM (value);
   else
     nlines = 0;
 
@@ -1619,7 +1619,7 @@ x_set_tool_bar_lines (struct frame *f, Lisp_Object value, Lisp_Object oldval)
 
   /* Use VALUE only if an int >= 0.  */
   if (RANGED_FIXNUMP (0, value, INT_MAX))
-    nlines = XFASTINT (value);
+    nlines = XFIXNAT (value);
   else
     nlines = 0;
 
@@ -1716,7 +1716,7 @@ x_set_internal_border_width (struct frame *f, Lisp_Object arg, Lisp_Object oldva
   int border;
 
   CHECK_TYPE_RANGED_INTEGER (int, arg);
-  border = max (XINT (arg), 0);
+  border = max (XFIXNUM (arg), 0);
 
   if (border != FRAME_INTERNAL_BORDER_WIDTH (f))
     {
@@ -3292,7 +3292,7 @@ x_icon (struct frame *f, Lisp_Object parms)
   block_input ();
 
   if (! EQ (icon_x, Qunbound))
-    x_wm_set_icon_position (f, XINT (icon_x), XINT (icon_y));
+    x_wm_set_icon_position (f, XFIXNUM (icon_x), XFIXNUM (icon_y));
 
 #if false /* x_get_arg removes the visibility parameter as a side effect,
              but x_create_frame still needs it.  */
@@ -3725,7 +3725,7 @@ This function is an internal primitive--use `make-frame' instead.  */)
   /* Specify the parent under which to make this X window.  */
   if (!NILP (parent))
     {
-      f->output_data.x->parent_desc = (Window) XFASTINT (parent);
+      f->output_data.x->parent_desc = (Window) XFIXNAT (parent);
       f->output_data.x->explicit_parent = true;
     }
   else
@@ -5099,8 +5099,8 @@ frame_geometry (Lisp_Object frame, Lisp_Object attribute)
       edges = Fx_frame_edges (parent, Qnative_edges);
       if (!NILP (edges))
         {
-          x_native += XINT (Fnth (make_fixnum (0), edges));
-          y_native += XINT (Fnth (make_fixnum (1), edges));
+          x_native += XFIXNUM (Fnth (make_fixnum (0), edges));
+          y_native += XFIXNUM (Fnth (make_fixnum (1), edges));
         }
 
       outer_left = x_native;
@@ -5476,7 +5476,7 @@ The coordinates X and Y are interpreted in pixels relative to a position
 
   block_input ();
   XWarpPointer (FRAME_X_DISPLAY (f), None, DefaultRootWindow (FRAME_X_DISPLAY (f)),
-                0, 0, 0, 0, XINT (x), XINT (y));
+                0, 0, 0, 0, XFIXNUM (x), XFIXNUM (y));
   unblock_input ();
 
   return Qnil;
@@ -5776,10 +5776,10 @@ FRAME.  Default is to change on the edit X window.  */)
     {
       CHECK_FIXNUM (format);
 
-      if (XINT (format) != 8 && XINT (format) != 16
-          && XINT (format) != 32)
+      if (XFIXNUM (format) != 8 && XFIXNUM (format) != 16
+          && XFIXNUM (format) != 32)
         error ("FORMAT must be one of 8, 16 or 32");
-      element_format = XINT (format);
+      element_format = XFIXNUM (format);
     }
 
   if (CONSP (value))
@@ -6484,10 +6484,10 @@ compute_tip_xy (struct frame *f,
           geometry = Fassq (Qgeometry, monitor);
           if (CONSP (geometry))
             {
-              min_x = XINT (Fnth (make_fixnum (1), geometry));
-              min_y = XINT (Fnth (make_fixnum (2), geometry));
-              max_x = min_x + XINT (Fnth (make_fixnum (3), geometry));
-              max_y = min_y + XINT (Fnth (make_fixnum (4), geometry));
+              min_x = XFIXNUM (Fnth (make_fixnum (1), geometry));
+              min_y = XFIXNUM (Fnth (make_fixnum (2), geometry));
+              max_x = min_x + XFIXNUM (Fnth (make_fixnum (3), geometry));
+              max_y = min_y + XFIXNUM (Fnth (make_fixnum (4), geometry));
               if (min_x <= *root_x && *root_x < max_x
                   && min_y <= *root_y && *root_y < max_y)
                 {
@@ -6511,33 +6511,33 @@ compute_tip_xy (struct frame *f,
     }
 
   if (FIXNUMP (top))
-    *root_y = XINT (top);
+    *root_y = XFIXNUM (top);
   else if (FIXNUMP (bottom))
-    *root_y = XINT (bottom) - height;
-  else if (*root_y + XINT (dy) <= min_y)
+    *root_y = XFIXNUM (bottom) - height;
+  else if (*root_y + XFIXNUM (dy) <= min_y)
     *root_y = min_y; /* Can happen for negative dy */
-  else if (*root_y + XINT (dy) + height <= max_y)
+  else if (*root_y + XFIXNUM (dy) + height <= max_y)
     /* It fits below the pointer */
-    *root_y += XINT (dy);
-  else if (height + XINT (dy) + min_y <= *root_y)
+    *root_y += XFIXNUM (dy);
+  else if (height + XFIXNUM (dy) + min_y <= *root_y)
     /* It fits above the pointer.  */
-    *root_y -= height + XINT (dy);
+    *root_y -= height + XFIXNUM (dy);
   else
     /* Put it on the top.  */
     *root_y = min_y;
 
   if (FIXNUMP (left))
-    *root_x = XINT (left);
+    *root_x = XFIXNUM (left);
   else if (FIXNUMP (right))
-    *root_x = XINT (right) - width;
-  else if (*root_x + XINT (dx) <= min_x)
+    *root_x = XFIXNUM (right) - width;
+  else if (*root_x + XFIXNUM (dx) <= min_x)
     *root_x = 0; /* Can happen for negative dx */
-  else if (*root_x + XINT (dx) + width <= max_x)
+  else if (*root_x + XFIXNUM (dx) + width <= max_x)
     /* It fits to the right of the pointer.  */
-    *root_x += XINT (dx);
-  else if (width + XINT (dx) + min_x <= *root_x)
+    *root_x += XFIXNUM (dx);
+  else if (width + XFIXNUM (dx) + min_x <= *root_x)
     /* It fits to the left of the pointer.  */
-    *root_x -= width + XINT (dx);
+    *root_x -= width + XFIXNUM (dx);
   else
     /* Put it left justified on the screen -- it ought to fit that way.  */
     *root_x = min_x;
@@ -6925,8 +6925,8 @@ Text larger than the specified size is clipped.  */)
       && RANGED_FIXNUMP (1, XCAR (Vx_max_tooltip_size), INT_MAX)
       && RANGED_FIXNUMP (1, XCDR (Vx_max_tooltip_size), INT_MAX))
     {
-      w->total_cols = XFASTINT (XCAR (Vx_max_tooltip_size));
-      w->total_lines = XFASTINT (XCDR (Vx_max_tooltip_size));
+      w->total_cols = XFIXNAT (XCAR (Vx_max_tooltip_size));
+      w->total_lines = XFIXNAT (XCDR (Vx_max_tooltip_size));
     }
   else
     {
@@ -6958,8 +6958,8 @@ Text larger than the specified size is clipped.  */)
   size = Fwindow_text_pixel_size (window, Qnil, Qnil, Qnil,
                                   make_fixnum (w->pixel_height), Qnil);
   /* Add the frame's internal border to calculated size.  */
-  width = XINT (Fcar (size)) + 2 * FRAME_INTERNAL_BORDER_WIDTH (tip_f);
-  height = XINT (Fcdr (size)) + 2 * FRAME_INTERNAL_BORDER_WIDTH (tip_f);
+  width = XFIXNUM (Fcar (size)) + 2 * FRAME_INTERNAL_BORDER_WIDTH (tip_f);
+  height = XFIXNUM (Fcdr (size)) + 2 * FRAME_INTERNAL_BORDER_WIDTH (tip_f);
 
   /* Calculate position of tooltip frame.  */
   compute_tip_xy (tip_f, parms, dx, dy, width, height, &root_x, &root_y);
diff --git a/src/xfont.c b/src/xfont.c
index 53f7070a643..73caa705890 100644
--- a/src/xfont.c
+++ b/src/xfont.c
@@ -190,7 +190,7 @@ xfont_chars_supported (Lisp_Object chars, XFontStruct *xfont,
     {
       for (; CONSP (chars); chars = XCDR (chars))
         {
-          int c = XINT (XCAR (chars));
+          int c = XFIXNUM (XCAR (chars));
           unsigned code = ENCODE_CHAR (charset, c);
           XChar2b char2b;
 
@@ -213,7 +213,7 @@ xfont_chars_supported (Lisp_Object chars, XFontStruct *xfont,
 
       for (i = ASIZE (chars) - 1; i >= 0; i--)
         {
-          int c = XINT (AREF (chars, i));
+          int c = XFIXNUM (AREF (chars, i));
           unsigned code = ENCODE_CHAR (charset, c);
           XChar2b char2b;
 
@@ -378,8 +378,8 @@ xfont_list_pattern (Display *display, const char *pattern,
             /* Avoid auto-scaled fonts.  */
             if (FIXNUMP (AREF (entity, FONT_DPI_INDEX))
                 && FIXNUMP (AREF (entity, FONT_AVGWIDTH_INDEX))
-                && XINT (AREF (entity, FONT_DPI_INDEX)) != 0
-                && XINT (AREF (entity, FONT_AVGWIDTH_INDEX)) == 0)
+                && XFIXNUM (AREF (entity, FONT_DPI_INDEX)) != 0
+                && XFIXNUM (AREF (entity, FONT_AVGWIDTH_INDEX)) == 0)
               continue;
             /* Avoid not-allowed scalable fonts.  */
             if (NILP (Vscalable_fonts_allowed))
@@ -387,7 +387,7 @@ xfont_list_pattern (Display *display, const char *pattern,
                 int size = 0;
 
                 if (FIXNUMP (AREF (entity, FONT_SIZE_INDEX)))
-                  size = XINT (AREF (entity, FONT_SIZE_INDEX));
+                  size = XFIXNUM (AREF (entity, FONT_SIZE_INDEX));
                 else if (FLOATP (AREF (entity, FONT_SIZE_INDEX)))
                   size = XFLOAT_DATA (AREF (entity, FONT_SIZE_INDEX));
                 if (size == 0 && i_pass == 0)
@@ -672,8 +672,8 @@ xfont_open (struct frame *f, Lisp_Object entity, int pixel_size)
       return Qnil;
     }
 
-  if (XINT (AREF (entity, FONT_SIZE_INDEX)) != 0)
-    pixel_size = XINT (AREF (entity, FONT_SIZE_INDEX));
+  if (XFIXNUM (AREF (entity, FONT_SIZE_INDEX)) != 0)
+    pixel_size = XFIXNUM (AREF (entity, FONT_SIZE_INDEX));
   else if (pixel_size == 0)
     {
       if (FRAME_FONT (f))
@@ -812,7 +812,7 @@ xfont_open (struct frame *f, Lisp_Object entity, int pixel_size)
 
       val = Ffont_get (font_object, QCavgwidth);
       if (FIXNUMP (val))
-        font->average_width = XINT (val) / 10;
+        font->average_width = XFIXNUM (val) / 10;
       if (font->average_width < 0)
         font->average_width = - font->average_width;
       else
diff --git a/src/xftfont.c b/src/xftfont.c
index b5749add668..85df0d857a2 100644
--- a/src/xftfont.c
+++ b/src/xftfont.c
@@ -220,7 +220,7 @@ xftfont_add_rendering_parameters (FcPattern *pat, Lisp_Object entity)
       else if (EQ (key, QChintstyle))
         {
           if (FIXNUMP (val))
-            FcPatternAddInteger (pat, FC_HINT_STYLE, XINT (val));
+            FcPatternAddInteger (pat, FC_HINT_STYLE, XFIXNUM (val));
           else if (SYMBOLP (val)
                    && FcNameConstant (SDATA (SYMBOL_NAME (val)), &ival))
             FcPatternAddInteger (pat, FC_HINT_STYLE, ival);
@@ -228,7 +228,7 @@ xftfont_add_rendering_parameters (FcPattern *pat, Lisp_Object entity)
       else if (EQ (key, QCrgba))
         {
           if (FIXNUMP (val))
-            FcPatternAddInteger (pat, FC_RGBA, XINT (val));
+            FcPatternAddInteger (pat, FC_RGBA, XFIXNUM (val));
           else if (SYMBOLP (val)
                    && FcNameConstant (SDATA (SYMBOL_NAME (val)), &ival))
             FcPatternAddInteger (pat, FC_RGBA, ival);
@@ -236,7 +236,7 @@ xftfont_add_rendering_parameters (FcPattern *pat, Lisp_Object entity)
       else if (EQ (key, QClcdfilter))
         {
           if (FIXNUMP (val))
-            FcPatternAddInteger (pat, FC_LCD_FILTER, ival = XINT (val));
+            FcPatternAddInteger (pat, FC_LCD_FILTER, ival = XFIXNUM (val));
           else if (SYMBOLP (val)
                    && FcNameConstant (SDATA (SYMBOL_NAME (val)), &ival))
             FcPatternAddInteger (pat, FC_LCD_FILTER, ival);
@@ -271,7 +271,7 @@ xftfont_open (struct frame *f, Lisp_Object entity, int pixel_size)
   val = XCDR (val);
   filename = XCAR (val);
   idx = XCDR (val);
-  size = XINT (AREF (entity, FONT_SIZE_INDEX));
+  size = XFIXNUM (AREF (entity, FONT_SIZE_INDEX));
   if (size == 0)
     size = pixel_size;
   pat = FcPatternCreate ();
@@ -289,16 +289,16 @@ xftfont_open (struct frame *f, Lisp_Object entity, int pixel_size)
     FcPatternAddString (pat, FC_FOUNDRY, (FcChar8 *) SDATA (SYMBOL_NAME (val)));
   val = AREF (entity, FONT_SPACING_INDEX);
   if (! NILP (val))
-    FcPatternAddInteger (pat, FC_SPACING, XINT (val));
+    FcPatternAddInteger (pat, FC_SPACING, XFIXNUM (val));
   val = AREF (entity, FONT_DPI_INDEX);
   if (! NILP (val))
     {
-      double dbl = XINT (val);
+      double dbl = XFIXNUM (val);
 
       FcPatternAddDouble (pat, FC_DPI, dbl);
     }
   val = AREF (entity, FONT_AVGWIDTH_INDEX);
-  if (FIXNUMP (val) && XINT (val) == 0)
+  if (FIXNUMP (val) && XFIXNUM (val) == 0)
     FcPatternAddBool (pat, FC_SCALABLE, FcTrue);
   /* This is necessary to identify the exact font (e.g. 10x20.pcf.gz
      over 10x20-ISO8859-1.pcf.gz).  */
@@ -307,7 +307,7 @@ xftfont_open (struct frame *f, Lisp_Object entity, int pixel_size)
   xftfont_add_rendering_parameters (pat, entity);
 
   FcPatternAddString (pat, FC_FILE, (FcChar8 *) SDATA (filename));
-  FcPatternAddInteger (pat, FC_INDEX, XINT (idx));
+  FcPatternAddInteger (pat, FC_INDEX, XFIXNUM (idx));
 
 
   block_input ();
@@ -353,7 +353,7 @@ xftfont_open (struct frame *f, Lisp_Object entity, int pixel_size)
       xftfont_info->matrix.yx = 0x10000L * matrix->yx;
     }
   if (FIXNUMP (AREF (entity, FONT_SPACING_INDEX)))
-    spacing = XINT (AREF (entity, FONT_SPACING_INDEX));
+    spacing = XFIXNUM (AREF (entity, FONT_SPACING_INDEX));
   else
     spacing = FC_PROPORTIONAL;
   if (! ascii_printable[0])
@@ -412,7 +412,7 @@ xftfont_open (struct frame *f, Lisp_Object entity, int pixel_size)
     }
   font->height = font->ascent + font->descent;
 
-  if (XINT (AREF (entity, FONT_SIZE_INDEX)) == 0)
+  if (XFIXNUM (AREF (entity, FONT_SIZE_INDEX)) == 0)
     {
       int upEM = ft_face->units_per_EM;
 
diff --git a/src/xmenu.c b/src/xmenu.c
index f51e46fb276..e6740af7ca6 100644
--- a/src/xmenu.c
+++ b/src/xmenu.c
@@ -1180,10 +1180,10 @@ menu_position_func (GtkMenu *menu, gint *x, gint *y, gboolean *push_in, gpointer
     {
       int min_x, min_y;
 
-      min_x = XINT (XCAR (workarea));
-      min_y = XINT (Fnth (make_fixnum (1), workarea));
-      max_x = min_x + XINT (Fnth (make_fixnum (2), workarea));
-      max_y = min_y + XINT (Fnth (make_fixnum (3), workarea));
+      min_x = XFIXNUM (XCAR (workarea));
+      min_y = XFIXNUM (Fnth (make_fixnum (1), workarea));
+      max_x = min_x + XFIXNUM (Fnth (make_fixnum (2), workarea));
+      max_y = min_y + XFIXNUM (Fnth (make_fixnum (3), workarea));
     }
 
   if (max_x < 0 || max_y < 0)
diff --git a/src/xml.c b/src/xml.c
index 3674e320ef6..5f3ccc85c86 100644
--- a/src/xml.c
+++ b/src/xml.c
@@ -187,8 +187,8 @@ parse_region (Lisp_Object start, Lisp_Object end, Lisp_Object base_url,
 
   validate_region (&start, &end);
 
-  istart = XINT (start);
-  iend = XINT (end);
+  istart = XFIXNUM (start);
+  iend = XFIXNUM (end);
   istart_byte = CHAR_TO_BYTE (istart);
   iend_byte = CHAR_TO_BYTE (iend);
 
diff --git a/src/xrdb.c b/src/xrdb.c
index ce0e1cce072..4abf1ad84ed 100644
--- a/src/xrdb.c
+++ b/src/xrdb.c
@@ -474,13 +474,13 @@ x_load_resources (Display *display, const char *xrm_string,
 
   /* Set double click time of list boxes in the file selection
      dialog from `double-click-time'.  */
-  if (FIXNUMP (Vdouble_click_time) && XINT (Vdouble_click_time) > 0)
+  if (FIXNUMP (Vdouble_click_time) && XFIXNUM (Vdouble_click_time) > 0)
     {
       sprintf (line, "%s*fsb*DirList.doubleClickInterval: %"pI"d",
-               myclass, XFASTINT (Vdouble_click_time));
+               myclass, XFIXNAT (Vdouble_click_time));
       XrmPutLineResource (&rdb, line);
       sprintf (line, "%s*fsb*ItemsList.doubleClickInterval: %"pI"d",
-               myclass, XFASTINT (Vdouble_click_time));
+               myclass, XFIXNAT (Vdouble_click_time));
       XrmPutLineResource (&rdb, line);
     }
 
diff --git a/src/xselect.c b/src/xselect.c
index d24a493294e..984d95d7483 100644
--- a/src/xselect.c
+++ b/src/xselect.c
@@ -1693,7 +1693,7 @@ static unsigned long
 cons_to_x_long (Lisp_Object obj)
 {
   if (X_ULONG_MAX <= INTMAX_MAX
-      || XINT (FIXNUMP (obj) ? obj : XCAR (obj)) < 0)
+      || XFIXNUM (FIXNUMP (obj) ? obj : XCAR (obj)) < 0)
     return cons_to_signed (obj, X_LONG_MIN, min (X_ULONG_MAX, INTMAX_MAX));
   else
     return cons_to_unsigned (obj, X_ULONG_MAX);
@@ -1756,7 +1756,7 @@ lisp_data_to_selection_data (struct x_display_info *dpyinfo,
       cs->format = 16;
       cs->size = 1;
       cs->data[sizeof (short)] = 0;
-      *short_ptr = XINT (obj);
+      *short_ptr = XFIXNUM (obj);
       if (NILP (type)) type = QINTEGER;
     }
   else if (FIXNUMP (obj)
@@ -1832,7 +1832,7 @@ lisp_data_to_selection_data (struct x_display_info *dpyinfo,
               if (format == 32)
                 x_atoms[i] = cons_to_x_long (AREF (obj, i));
               else
-                shorts[i] = XINT (AREF (obj, i));
+                shorts[i] = XFIXNUM (AREF (obj, i));
             }
         }
     }
@@ -1856,10 +1856,10 @@ clean_local_selection_data (Lisp_Object obj)
       && FIXNUMP (XCAR (obj))
       && FIXNUMP (XCDR (obj)))
     {
-      if (XINT (XCAR (obj)) == 0)
+      if (XFIXNUM (XCAR (obj)) == 0)
         return XCDR (obj);
-      if (XINT (XCAR (obj)) == -1)
-        return make_fixnum (- XINT (XCDR (obj)));
+      if (XFIXNUM (XCAR (obj)) == -1)
+        return make_fixnum (- XFIXNUM (XCDR (obj)));
     }
   if (VECTORP (obj))
     {
@@ -2313,8 +2313,8 @@ x_fill_property_data (Display *dpy, Lisp_Object data, void *ret, int format)
                  For XDnd, v2 might be y of a window, and can be negative.
                  The XDnd spec. is not explicit about negative values,
                  but let's assume negative v2 is sent modulo 2**16.  */
-              unsigned long v1 = XINT (XCAR (o)) & 0xffff;
-              unsigned long v2 = XINT (XCDR (o)) & 0xffff;
+              unsigned long v1 = XFIXNUM (XCAR (o)) & 0xffff;
+              unsigned long v2 = XFIXNUM (XCDR (o)) & 0xffff;
               val = (v1 << 16) | v2;
             }
           else
@@ -2560,11 +2560,11 @@ x_send_client_event (Lisp_Object display, Lisp_Object dest, Lisp_Object from,
   if (x_check_property_data (values) == -1)
     error ("Bad data in VALUES, must be number, cons or string");
 
-  if (XINT (format) != 8 && XINT (format) != 16 && XINT (format) != 32)
+  if (XFIXNUM (format) != 8 && XFIXNUM (format) != 16 && XFIXNUM (format) != 32)
     error ("FORMAT must be one of 8, 16 or 32");
 
   event.xclient.type = ClientMessage;
-  event.xclient.format = XINT (format);
+  event.xclient.format = XFIXNUM (format);
 
   if (FRAMEP (dest) || NILP (dest))
     {
diff --git a/src/xsettings.c b/src/xsettings.c
index 81c8f9b2919..0b67db30746 100644
--- a/src/xsettings.c
+++ b/src/xsettings.c
@@ -393,7 +393,7 @@ parse_settings (unsigned char *prop,
                 struct xsettings *settings)
 {
   Lisp_Object byteorder = Fbyteorder ();
-  int my_bo = XFASTINT (byteorder) == 'B' ? MSBFirst : LSBFirst;
+  int my_bo = XFIXNAT (byteorder) == 'B' ? MSBFirst : LSBFirst;
   int that_bo = prop[0];
   CARD32 n_settings;
   int bytes_parsed = 0;
diff --git a/src/xterm.c b/src/xterm.c
index f83f054802e..be8e3da3721 100644
--- a/src/xterm.c
+++ b/src/xterm.c
@@ -918,7 +918,7 @@ x_set_frame_alpha (struct frame *f)
   if (FLOATP (Vframe_alpha_lower_limit))
     alpha_min = XFLOAT_DATA (Vframe_alpha_lower_limit);
   else if (FIXNUMP (Vframe_alpha_lower_limit))
-    alpha_min = (XINT (Vframe_alpha_lower_limit)) / 100.0;
+    alpha_min = (XFIXNUM (Vframe_alpha_lower_limit)) / 100.0;
 
   if (alpha < 0.0)
     return;
@@ -3109,11 +3109,11 @@ x_draw_image_relief (struct glyph_string *s)
           && FIXNUMP (XCAR (Vtool_bar_button_margin))
           && FIXNUMP (XCDR (Vtool_bar_button_margin)))
         {
-          extra_x = XINT (XCAR (Vtool_bar_button_margin));
-          extra_y = XINT (XCDR (Vtool_bar_button_margin));
+          extra_x = XFIXNUM (XCAR (Vtool_bar_button_margin));
+          extra_y = XFIXNUM (XCDR (Vtool_bar_button_margin));
         }
       else if (FIXNUMP (Vtool_bar_button_margin))
-        extra_x = extra_y = XINT (Vtool_bar_button_margin);
+        extra_x = extra_y = XFIXNUM (Vtool_bar_button_margin);
     }
 
   top_p = bot_p = left_p = right_p = false;
@@ -3705,7 +3705,7 @@ x_draw_glyph_string (struct glyph_string *s)
                     = buffer_local_value (Qunderline_minimum_offset,
                                           s->w->contents);
                   if (FIXNUMP (val))
-                    minimum_offset = XFASTINT (val);
+                    minimum_offset = XFIXNAT (val);
                   else
                     minimum_offset = 1;
                   val = buffer_local_value (Qx_underline_at_descent_line,
@@ -4824,15 +4824,15 @@ x_x_to_emacs_modifiers (struct x_display_info *dpyinfo, int state)
   Lisp_Object tem;
 
   tem = Fget (Vx_ctrl_keysym, Qmodifier_value);
-  if (FIXNUMP (tem)) mod_ctrl = XINT (tem) & INT_MAX;
+  if (FIXNUMP (tem)) mod_ctrl = XFIXNUM (tem) & INT_MAX;
   tem = Fget (Vx_alt_keysym, Qmodifier_value);
-  if (FIXNUMP (tem)) mod_alt = XINT (tem) & INT_MAX;
+  if (FIXNUMP (tem)) mod_alt = XFIXNUM (tem) & INT_MAX;
   tem = Fget (Vx_meta_keysym, Qmodifier_value);
-  if (FIXNUMP (tem)) mod_meta = XINT (tem) & INT_MAX;
+  if (FIXNUMP (tem)) mod_meta = XFIXNUM (tem) & INT_MAX;
   tem = Fget (Vx_hyper_keysym, Qmodifier_value);
-  if (FIXNUMP (tem)) mod_hyper = XINT (tem) & INT_MAX;
+  if (FIXNUMP (tem)) mod_hyper = XFIXNUM (tem) & INT_MAX;
   tem = Fget (Vx_super_keysym, Qmodifier_value);
-  if (FIXNUMP (tem)) mod_super = XINT (tem) & INT_MAX;
+  if (FIXNUMP (tem)) mod_super = XFIXNUM (tem) & INT_MAX;
 
   return (  ((state & (ShiftMask | dpyinfo->shift_lock_mask)) ? shift_modifier : 0)
             | ((state & ControlMask)                    ? mod_ctrl      : 0)
@@ -4854,15 +4854,15 @@ x_emacs_to_x_modifiers (struct x_display_info *dpyinfo, EMACS_INT state)
   Lisp_Object tem;
 
   tem = Fget (Vx_ctrl_keysym, Qmodifier_value);
-  if (FIXNUMP (tem)) mod_ctrl = XINT (tem);
+  if (FIXNUMP (tem)) mod_ctrl = XFIXNUM (tem);
   tem = Fget (Vx_alt_keysym, Qmodifier_value);
-  if (FIXNUMP (tem)) mod_alt = XINT (tem);
+  if (FIXNUMP (tem)) mod_alt = XFIXNUM (tem);
   tem = Fget (Vx_meta_keysym, Qmodifier_value);
-  if (FIXNUMP (tem)) mod_meta = XINT (tem);
+  if (FIXNUMP (tem)) mod_meta = XFIXNUM (tem);
   tem = Fget (Vx_hyper_keysym, Qmodifier_value);
-  if (FIXNUMP (tem)) mod_hyper = XINT (tem);
+  if (FIXNUMP (tem)) mod_hyper = XFIXNUM (tem);
   tem = Fget (Vx_super_keysym, Qmodifier_value);
-  if (FIXNUMP (tem)) mod_super = XINT (tem);
+  if (FIXNUMP (tem)) mod_super = XFIXNUM (tem);
 
 
   return (  ((state & mod_alt)          ? dpyinfo->alt_mod_mask   : 0)
@@ -8363,10 +8363,10 @@ handle_one_xevent (struct x_display_info *dpyinfo,
                                 Qnil),
                   FIXNATP (c)))
             {
-              inev.ie.kind = (SINGLE_BYTE_CHAR_P (XFASTINT (c))
+              inev.ie.kind = (SINGLE_BYTE_CHAR_P (XFIXNAT (c))
                               ? ASCII_KEYSTROKE_EVENT
                               : MULTIBYTE_CHAR_KEYSTROKE_EVENT);
-              inev.ie.code = XFASTINT (c);
+              inev.ie.code = XFIXNAT (c);
               goto done_keysym;
             }
 
@@ -10254,8 +10254,8 @@ x_calc_absolute_position (struct frame *f)
           XSETFRAME (frame, f);
           edges = Fx_frame_edges (frame, Qouter_edges);
           if (!NILP (edges))
-            width = (XINT (Fnth (make_fixnum (2), edges))
-                     - XINT (Fnth (make_fixnum (0), edges)));
+            width = (XFIXNUM (Fnth (make_fixnum (2), edges))
+                     - XFIXNUM (Fnth (make_fixnum (0), edges)));
         }
 
       if (p)
@@ -10296,8 +10296,8 @@ x_calc_absolute_position (struct frame *f)
           if (NILP (edges))
             edges = Fx_frame_edges (frame, Qouter_edges);
           if (!NILP (edges))
-            height = (XINT (Fnth (make_fixnum (3), edges))
-                      - XINT (Fnth (make_fixnum (1), edges)));
+            height = (XFIXNUM (Fnth (make_fixnum (3), edges))
+                      - XFIXNUM (Fnth (make_fixnum (1), edges)));
         }
 
       if (p)
diff --git a/src/xwidget.c b/src/xwidget.c
index dc1b888280f..d6b39fe4105 100644
--- a/src/xwidget.c
+++ b/src/xwidget.c
@@ -87,8 +87,8 @@ Returns the newly constructed xwidget, or nil if construction fails.  */)
   xw->type = type;
   xw->title = title;
   xw->buffer = NILP (buffer) ? Fcurrent_buffer () : Fget_buffer_create (buffer);
-  xw->height = XFASTINT (height);
-  xw->width = XFASTINT (width);
+  xw->height = XFIXNAT (height);
+  xw->width = XFIXNAT (width);
   xw->kill_without_query = false;
   XSETXWIDGET (val, xw);
   Vxwidget_list = Fcons (val, Vxwidget_list);
@@ -767,8 +767,8 @@ DEFUN ("xwidget-resize", Fxwidget_resize, Sxwidget_resize, 3, 3, 0,
   CHECK_RANGED_INTEGER (new_width, 0, INT_MAX);
   CHECK_RANGED_INTEGER (new_height, 0, INT_MAX);
   struct xwidget *xw = XXWIDGET (xwidget);
-  int w = XFASTINT (new_width);
-  int h = XFASTINT (new_height);
+  int w = XFIXNAT (new_width);
+  int h = XFIXNAT (new_height);
 
   xw->width = w;
   xw->height = h;