Rename integerp->fixnum, etc, in preparation for bignums

* src/json.c, src/keyboard.c, src/keyboard.h, 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/sysdep.c, src/term.c, src/terminal.c,
src/textprop.c, src/undo.c, src/w16select.c, src/w32.c,
src/w32console.c, src/w32cygwinx.c, src/w32fns.c, src/w32font.c,
src/w32inevt.c, src/w32proc.c, src/w32select.c, src/w32term.c,
src/w32uniscribe.c, src/widget.c, src/window.c, src/xdisp.c,
src/xfaces.c, src/xfns.c, src/xfont.c, src/xftfont.c, src/xmenu.c,
src/xrdb.c, src/xselect.c, src/xterm.c, src/xwidget.c: Rename
INTEGERP->FIXNUM, make_number->make_fixnum, CHECK_NUMBER->CHECK_FIXNUM,
make_natnum->make_fixed_natum, NUMBERP->FIXED_OR_FLOATP,
NATNUMP->FIXNATP, CHECK_NATNUM->CHECK_FIXNAT.

1 files changed, 67 insertions, 67 deletions

diff --git a/src/keymap.c b/src/keymap.c
index fcee788e6f9..a7e0557ebde 100644
--- a/src/keymap.c
+++ b/src/keymap.c
@@ -159,7 +159,7 @@ in case you use it as a menu with `x-popup-menu'.  */)
 void
 initial_define_key (Lisp_Object keymap, int key, const char *defname)
 {
-  store_in_keymap (keymap, make_number (key), intern_c_string (defname));
+  store_in_keymap (keymap, make_fixnum (key), intern_c_string (defname));
 }
 
 void
@@ -248,7 +248,7 @@ get_keymap (Lisp_Object object, bool error_if_not_keymap, bool autoload)
         {
           Lisp_Object tail;
 
-          tail = Fnth (make_number (4), tem);
+          tail = Fnth (make_fixnum (4), tem);
           if (EQ (tail, Qkeymap))
             {
               if (autoload)
@@ -379,13 +379,13 @@ access_keymap_1 (Lisp_Object map, Lisp_Object idx,
      be put in the canonical order.  */
   if (SYMBOLP (idx))
     idx = reorder_modifiers (idx);
-  else if (INTEGERP (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)));
 
   /* Handle the special meta -> esc mapping.  */
-  if (INTEGERP (idx) && XFASTINT (idx) & meta_modifier)
+  if (FIXNUMP (idx) && XFASTINT (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.  */
@@ -393,14 +393,14 @@ access_keymap_1 (Lisp_Object map, Lisp_Object idx,
       /* A strange value in which Meta is set would cause
          infinite recursion.  Protect against that.  */
       if (XINT (meta_prefix_char) & CHAR_META)
-        meta_prefix_char = make_number (27);
+        meta_prefix_char = make_fixnum (27);
       event_meta_binding = access_keymap_1 (map, meta_prefix_char, t_ok,
                                             noinherit, autoload);
       event_meta_map = get_keymap (event_meta_binding, 0, autoload);
       if (CONSP (event_meta_map))
         {
           map = event_meta_map;
-          idx = make_number (XFASTINT (idx) & ~meta_modifier);
+          idx = make_fixnum (XFASTINT (idx) & ~meta_modifier);
         }
       else if (t_ok)
         /* Set IDX to t, so that we only find a default binding.  */
@@ -473,7 +473,7 @@ access_keymap_1 (Lisp_Object map, Lisp_Object idx,
           }
         else if (VECTORP (binding))
           {
-            if (INTEGERP (idx) && XFASTINT (idx) < ASIZE (binding))
+            if (FIXNUMP (idx) && XFASTINT (idx) < ASIZE (binding))
               val = AREF (binding, XFASTINT (idx));
           }
         else if (CHAR_TABLE_P (binding))
@@ -481,7 +481,7 @@ access_keymap_1 (Lisp_Object map, Lisp_Object idx,
             /* Character codes with modifiers
                are not included in a char-table.
                All character codes without modifiers are included.  */
-            if (INTEGERP (idx) && (XFASTINT (idx) & CHAR_MODIFIER_MASK) == 0)
+            if (FIXNUMP (idx) && (XFASTINT (idx) & CHAR_MODIFIER_MASK) == 0)
               {
                 val = Faref (binding, idx);
                 /* nil has a special meaning for char-tables, so
@@ -782,7 +782,7 @@ store_in_keymap (Lisp_Object keymap, register Lisp_Object idx, Lisp_Object def)
      be put in the canonical order.  */
   if (SYMBOLP (idx))
     idx = reorder_modifiers (idx);
-  else if (INTEGERP (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)));
@@ -807,7 +807,7 @@ store_in_keymap (Lisp_Object keymap, register Lisp_Object idx, Lisp_Object def)
         elt = XCAR (tail);
         if (VECTORP (elt))
           {
-            if (NATNUMP (idx) && XFASTINT (idx) < ASIZE (elt))
+            if (FIXNATP (idx) && XFASTINT (idx) < ASIZE (elt))
               {
                 CHECK_IMPURE (elt, XVECTOR (elt));
                 ASET (elt, XFASTINT (idx), 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 (NATNUMP (idx) && !(XFASTINT (idx) & CHAR_MODIFIER_MASK))
+            if (FIXNATP (idx) && !(XFASTINT (idx) & CHAR_MODIFIER_MASK))
               {
                 Faset (elt, idx,
                        /* nil has a special meaning for char-tables, so
@@ -1093,7 +1093,7 @@ binding KEY to DEF is added at the front of KEYMAP.  */)
 
   if (VECTORP (def) && ASIZE (def) > 0 && CONSP (AREF (def, 0)))
     { /* DEF is apparently an XEmacs-style keyboard macro.  */
-      Lisp_Object tmp = Fmake_vector (make_number (ASIZE (def)), Qnil);
+      Lisp_Object tmp = Fmake_vector (make_fixnum (ASIZE (def)), Qnil);
       ptrdiff_t i = ASIZE (def);
       while (--i >= 0)
         {
@@ -1108,7 +1108,7 @@ binding KEY to DEF is added at the front of KEYMAP.  */)
   idx = 0;
   while (1)
     {
-      c = Faref (key, make_number (idx));
+      c = Faref (key, make_fixnum (idx));
 
       if (CONSP (c))
         {
@@ -1123,7 +1123,7 @@ binding KEY to DEF is added at the front of KEYMAP.  */)
       if (SYMBOLP (c))
         silly_event_symbol_error (c);
 
-      if (INTEGERP (c)
+      if (FIXNUMP (c)
           && (XINT (c) & meta_bit)
           && !metized)
         {
@@ -1132,17 +1132,17 @@ binding KEY to DEF is added at the front of KEYMAP.  */)
         }
       else
         {
-          if (INTEGERP (c))
+          if (FIXNUMP (c))
             XSETINT (c, XINT (c) & ~meta_bit);
 
           metized = 0;
           idx++;
         }
 
-      if (!INTEGERP (c) && !SYMBOLP (c)
+      if (!FIXNUMP (c) && !SYMBOLP (c)
           && (!CONSP (c)
               /* If C is a range, it must be a leaf.  */
-              || (INTEGERP (XCAR (c)) && idx != length)))
+              || (FIXNUMP (XCAR (c)) && idx != length)))
         message_with_string ("Key sequence contains invalid event %s", c, 1);
 
       if (idx == length)
@@ -1165,8 +1165,8 @@ binding KEY to DEF is added at the front of KEYMAP.  */)
              error; key might be a vector, not a string.  */
           error ("Key sequence %s starts with non-prefix key %s%s",
                  SDATA (Fkey_description (key, Qnil)),
-                 SDATA (Fkey_description (Fsubstring (key, make_number (0),
-                                                      make_number (idx)),
+                 SDATA (Fkey_description (Fsubstring (key, make_fixnum (0),
+                                                      make_fixnum (idx)),
                                           Qnil)),
                  trailing_esc);
         }
@@ -1201,7 +1201,7 @@ remapping in all currently active keymaps.  */)
   else
     command = Flookup_key (Fcons (Qkeymap, keymaps),
                            command_remapping_vector, Qnil);
-  return INTEGERP (command) ? Qnil : command;
+  return FIXNUMP (command) ? Qnil : command;
 }
 
 /* Value is number if KEY is too long; nil if valid but has no definition.  */
@@ -1240,7 +1240,7 @@ recognize the default bindings, just as `read-key-sequence' does.  */)
   idx = 0;
   while (1)
     {
-      c = Faref (key, make_number (idx++));
+      c = Faref (key, make_fixnum (idx++));
 
       if (CONSP (c) && lucid_event_type_list_p (c))
         c = Fevent_convert_list (c);
@@ -1251,7 +1251,7 @@ recognize the default bindings, just as `read-key-sequence' does.  */)
 
       /* Allow string since binding for `menu-bar-select-buffer'
          includes the buffer name in the key sequence.  */
-      if (!INTEGERP (c) && !SYMBOLP (c) && !CONSP (c) && !STRINGP (c))
+      if (!FIXNUMP (c) && !SYMBOLP (c) && !CONSP (c) && !STRINGP (c))
         message_with_string ("Key sequence contains invalid event %s", c, 1);
 
       cmd = access_keymap (keymap, c, t_ok, 0, 1);
@@ -1260,7 +1260,7 @@ recognize the default bindings, just as `read-key-sequence' does.  */)
 
       keymap = get_keymap (cmd, 0, 1);
       if (!CONSP (keymap))
-        return make_number (idx);
+        return make_fixnum (idx);
 
       maybe_quit ();
     }
@@ -1474,7 +1474,7 @@ current_minor_maps (Lisp_Object **modeptr, Lisp_Object **mapptr)
 static ptrdiff_t
 click_position (Lisp_Object position)
 {
-  EMACS_INT pos = (INTEGERP (position) ? XINT (position)
+  EMACS_INT pos = (FIXNUMP (position) ? XINT (position)
                    : MARKERP (position) ? marker_position (position)
                    : PT);
   if (! (BEGV <= pos && pos <= ZV))
@@ -1552,7 +1552,7 @@ like in the respective argument of `key-binding'.  */)
               Lisp_Object pos;
 
               pos = POSN_BUFFER_POSN (position);
-              if (INTEGERP (pos)
+              if (FIXNUMP (pos)
                   && XINT (pos) >= BEG && XINT (pos) <= Z)
                 {
                   local_map = get_local_map (XINT (pos),
@@ -1575,7 +1575,7 @@ like in the respective argument of `key-binding'.  */)
 
               pos = XCDR (string);
               string = XCAR (string);
-              if (INTEGERP (pos)
+              if (FIXNUMP (pos)
                   && XINT (pos) >= 0
                   && XINT (pos) < SCHARS (string))
                 {
@@ -1667,7 +1667,7 @@ specified buffer position instead of point are used.
   value = Flookup_key (Fcons (Qkeymap, Fcurrent_active_maps (Qt, position)),
                        key, accept_default);
 
-  if (NILP (value) || INTEGERP (value))
+  if (NILP (value) || FIXNUMP (value))
     return Qnil;
 
   /* If the result of the ordinary keymap lookup is an interactive
@@ -1745,7 +1745,7 @@ bindings; see the description of `lookup-key' for more details about this.  */)
   for (i = j = 0; i < nmaps; i++)
     if (!NILP (maps[i])
         && !NILP (binding = Flookup_key (maps[i], key, accept_default))
-        && !INTEGERP (binding))
+        && !FIXNUMP (binding))
       {
         if (KEYMAPP (binding))
           maps[j++] = Fcons (modes[i], binding);
@@ -1843,7 +1843,7 @@ accessible_keymaps_1 (Lisp_Object key, Lisp_Object cmd, Lisp_Object args, void *
   Lisp_Object maps = d->maps;
   Lisp_Object tail = d->tail;
   Lisp_Object thisseq = d->thisseq;
-  bool is_metized = d->is_metized && INTEGERP (key);
+  bool is_metized = d->is_metized && FIXNUMP (key);
   Lisp_Object tem;
 
   cmd = get_keymap (get_keyelt (cmd, 0), 0, 0);
@@ -1858,8 +1858,8 @@ accessible_keymaps_1 (Lisp_Object key, Lisp_Object cmd, Lisp_Object args, void *
       if (lim <= XINT (Flength (thisseq)))
         { /* This keymap was already seen with a smaller prefix.  */
           ptrdiff_t i = 0;
-          while (i < lim && EQ (Faref (prefix, make_number (i)),
-                                Faref (thisseq, make_number (i))))
+          while (i < lim && EQ (Faref (prefix, make_fixnum (i)),
+                                Faref (thisseq, make_fixnum (i))))
             i++;
           if (i >= lim)
             /* `prefix' is a prefix of `thisseq' => there's a cycle.  */
@@ -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_number (XINT (Flength (thisseq)) - 1);
+      Lisp_Object last = make_fixnum (XINT (Flength (thisseq)) - 1);
       tem = Fcopy_sequence (thisseq);
 
-      Faset (tem, last, make_number (XINT (key) | meta_bit));
+      Faset (tem, last, make_fixnum (XINT (key) | meta_bit));
 
       /* This new sequence is the same length as
          thisseq, so stick it in the list right
@@ -1933,7 +1933,7 @@ then the value includes only maps for prefixes that start with PREFIX.  */)
               int i, i_byte, c;
               Lisp_Object copy;
 
-              copy = Fmake_vector (make_number (SCHARS (prefix)), Qnil);
+              copy = Fmake_vector (make_fixnum (SCHARS (prefix)), Qnil);
               for (i = 0, i_byte = 0; i < SCHARS (prefix);)
                 {
                   int i_before = i;
@@ -1941,7 +1941,7 @@ then the value includes only maps for prefixes that start with PREFIX.  */)
                   FETCH_STRING_CHAR_ADVANCE (c, prefix, i, i_byte);
                   if (SINGLE_BYTE_CHAR_P (c) && (c & 0200))
                     c ^= 0200 | meta_modifier;
-                  ASET (copy, i_before, make_number (c));
+                  ASET (copy, i_before, make_fixnum (c));
                 }
               prefix = copy;
             }
@@ -1969,7 +1969,7 @@ 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_number (XINT (Flength (data.thisseq)) - 1);
+      last = make_fixnum (XINT (Flength (data.thisseq)) - 1);
       /* Does the current sequence end in the meta-prefix-char?  */
       data.is_metized = (XINT (last) >= 0
                     /* Don't metize the last char of PREFIX.  */
@@ -2072,7 +2072,7 @@ For an approximate inverse of this, see `kbd'.  */)
 
       if (add_meta)
         {
-          if (!INTEGERP (key)
+          if (!FIXNUMP (key)
               || EQ (key, meta_prefix_char)
               || (XINT (key) & meta_modifier))
             {
@@ -2108,7 +2108,7 @@ push_key_description (EMACS_INT ch, char *p)
   c2 = c & ~(alt_modifier | ctrl_modifier | hyper_modifier
              | meta_modifier | shift_modifier | super_modifier);
 
-  if (! CHARACTERP (make_number (c2)))
+  if (! CHARACTERP (make_fixnum (c2)))
     {
       /* KEY_DESCRIPTION_SIZE is large enough for this.  */
       p += sprintf (p, "[%d]", c);
@@ -2226,7 +2226,7 @@ around function keys and event symbols.  */)
   if (CONSP (key) && lucid_event_type_list_p (key))
     key = Fevent_convert_list (key);
 
-  if (CONSP (key) && INTEGERP (XCAR (key)) && INTEGERP (XCDR (key)))
+  if (CONSP (key) && FIXNUMP (XCAR (key)) && FIXNUMP (XCDR (key)))
     /* An interval from a map-char-table.  */
     {
       AUTO_STRING (dot_dot, "..");
@@ -2237,7 +2237,7 @@ around function keys and event symbols.  */)
 
   key = EVENT_HEAD (key);
 
-  if (INTEGERP (key))           /* Normal character.  */
+  if (FIXNUMP (key))            /* Normal character.  */
     {
       char tem[KEY_DESCRIPTION_SIZE];
       char *p = push_key_description (XINT (key), tem);
@@ -2338,7 +2338,7 @@ preferred_sequence_p (Lisp_Object seq)
       XSETFASTINT (ii, i);
       elt = Faref (seq, ii);
 
-      if (!INTEGERP (elt))
+      if (!FIXNUMP (elt))
         return 0;
       else
         {
@@ -2373,10 +2373,10 @@ shadow_lookup (Lisp_Object shadow, Lisp_Object key, Lisp_Object flag,
   for (tail = shadow; CONSP (tail); tail = XCDR (tail))
     {
       value = Flookup_key (XCAR (tail), key, flag);
-      if (NATNUMP (value))
+      if (FIXNATP (value))
         {
           value = Flookup_key (XCAR (tail),
-                               Fsubstring (key, make_number (0), value), flag);
+                               Fsubstring (key, make_fixnum (0), value), flag);
           if (!NILP (value))
             return Qnil;
         }
@@ -2463,13 +2463,13 @@ where_is_internal (Lisp_Object definition, Lisp_Object keymaps,
 
       this = Fcar (XCAR (maps));
       map  = Fcdr (XCAR (maps));
-      last = make_number (XINT (Flength (this)) - 1);
+      last = make_fixnum (XINT (Flength (this)) - 1);
       last_is_meta = (XINT (last) >= 0
                       && EQ (Faref (this, last), meta_prefix_char));
 
       /* if (nomenus && !preferred_sequence_p (this)) */
       if (nomenus && XINT (last) >= 0
-          && SYMBOLP (tem = Faref (this, make_number (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
            keymaps bound to `menu-bar' and `tool-bar' and other
@@ -2646,9 +2646,9 @@ The optional 5th arg NO-REMAP alters how command remapping is handled:
       if (! NILP (sequence))
         {
           Lisp_Object tem1;
-          tem1 = Faref (sequence, make_number (ASIZE (sequence) - 1));
+          tem1 = Faref (sequence, make_fixnum (ASIZE (sequence) - 1));
           if (STRINGP (tem1))
-            Faset (sequence, make_number (ASIZE (sequence) - 1),
+            Faset (sequence, make_fixnum (ASIZE (sequence) - 1),
                    build_string ("(any string)"));
         }
 
@@ -2717,10 +2717,10 @@ where_is_internal_1 (Lisp_Object key, Lisp_Object binding, Lisp_Object args, voi
     return;
 
   /* We have found a match.  Construct the key sequence where we found it.  */
-  if (INTEGERP (key) && last_is_meta)
+  if (FIXNUMP (key) && last_is_meta)
     {
       sequence = Fcopy_sequence (this);
-      Faset (sequence, last, make_number (XINT (key) | meta_modifier));
+      Faset (sequence, last, make_fixnum (XINT (key) | meta_modifier));
     }
   else
     {
@@ -2786,7 +2786,7 @@ You type        Translation\n\
 
             bufend = push_key_description (translate[c], buf);
             insert (buf, bufend - buf);
-            Findent_to (make_number (16), make_number (1));
+            Findent_to (make_fixnum (16), make_fixnum (1));
             bufend = push_key_description (c, buf);
             insert (buf, bufend - buf);
 
@@ -2962,7 +2962,7 @@ key             binding\n\
           elt_prefix = Fcar (elt);
           if (ASIZE (elt_prefix) >= 1)
             {
-              tem = Faref (elt_prefix, make_number (0));
+              tem = Faref (elt_prefix, make_fixnum (0));
               if (EQ (tem, Qmenu_bar))
                 maps = Fdelq (elt, maps);
             }
@@ -3011,7 +3011,7 @@ key             binding\n\
           else
             {
               shmap = Flookup_key (shmap, Fcar (elt), Qt);
-              if (INTEGERP (shmap))
+              if (FIXNUMP (shmap))
                 shmap = Qnil;
             }
 
@@ -3066,7 +3066,7 @@ describe_command (Lisp_Object definition, Lisp_Object args)
   else
     description_column = 16;
 
-  Findent_to (make_number (description_column), make_number (1));
+  Findent_to (make_fixnum (description_column), make_fixnum (1));
   previous_description_column = description_column;
 
   if (SYMBOLP (definition))
@@ -3088,7 +3088,7 @@ describe_translation (Lisp_Object definition, Lisp_Object args)
 {
   register Lisp_Object tem1;
 
-  Findent_to (make_number (16), make_number (1));
+  Findent_to (make_fixnum (16), make_fixnum (1));
 
   if (SYMBOLP (definition))
     {
@@ -3125,12 +3125,12 @@ static int
 describe_map_compare (const void *aa, const void *bb)
 {
   const struct describe_map_elt *a = aa, *b = bb;
-  if (INTEGERP (a->event) && INTEGERP (b->event))
+  if (FIXNUMP (a->event) && FIXNUMP (b->event))
     return ((XINT (a->event) > XINT (b->event))
             - (XINT (a->event) < XINT (b->event)));
-  if (!INTEGERP (a->event) && INTEGERP (b->event))
+  if (!FIXNUMP (a->event) && FIXNUMP (b->event))
     return 1;
-  if (INTEGERP (a->event) && !INTEGERP (b->event))
+  if (FIXNUMP (a->event) && !FIXNUMP (b->event))
     return -1;
   if (SYMBOLP (a->event) && SYMBOLP (b->event))
     return (!NILP (Fstring_lessp (a->event, b->event)) ? -1
@@ -3170,7 +3170,7 @@ describe_map (Lisp_Object map, Lisp_Object prefix,
   /* This vector gets used to present single keys to Flookup_key.  Since
      that is done once per keymap element, we don't want to cons up a
      fresh vector every time.  */
-  kludge = Fmake_vector (make_number (1), Qnil);
+  kludge = Fmake_vector (make_fixnum (1), Qnil);
   definition = Qnil;
 
   map = call1 (Qkeymap_canonicalize, map);
@@ -3198,7 +3198,7 @@ describe_map (Lisp_Object map, Lisp_Object prefix,
 
           /* Ignore bindings whose "prefix" are not really valid events.
              (We get these in the frames and buffers menu.)  */
-          if (!(SYMBOLP (event) || INTEGERP (event)))
+          if (!(SYMBOLP (event) || FIXNUMP (event)))
             continue;
 
           if (nomenu && EQ (event, Qmenu_bar))
@@ -3282,10 +3282,10 @@ describe_map (Lisp_Object map, Lisp_Object prefix,
       definition = vect[i].definition;
 
       /* Find consecutive chars that are identically defined.  */
-      if (INTEGERP (vect[i].event))
+      if (FIXNUMP (vect[i].event))
         {
           while (i + 1 < slots_used
-                 && EQ (vect[i+1].event, make_number (XINT (vect[i].event) + 1))
+                 && EQ (vect[i+1].event, make_fixnum (XINT (vect[i].event) + 1))
                  && !NILP (Fequal (vect[i + 1].definition, definition))
                  && vect[i].shadowed == vect[i + 1].shadowed)
             i++;
@@ -3328,7 +3328,7 @@ describe_map (Lisp_Object map, Lisp_Object prefix,
 static void
 describe_vector_princ (Lisp_Object elt, Lisp_Object fun)
 {
-  Findent_to (make_number (16), make_number (1));
+  Findent_to (make_fixnum (16), make_fixnum (1));
   call1 (fun, elt);
   Fterpri (Qnil, Qnil);
 }
@@ -3419,7 +3419,7 @@ describe_vector (Lisp_Object vector, Lisp_Object prefix, Lisp_Object args,
   /* This vector gets used to present single keys to Flookup_key.  Since
      that is done once per vector element, we don't want to cons up a
      fresh vector every time.  */
-  kludge = Fmake_vector (make_number (1), Qnil);
+  kludge = Fmake_vector (make_fixnum (1), Qnil);
 
   if (partial)
     suppress = intern ("suppress-keymap");
@@ -3469,7 +3469,7 @@ describe_vector (Lisp_Object vector, Lisp_Object prefix, Lisp_Object args,
           if (!NILP (tem)) continue;
         }
 
-      character = make_number (starting_i);
+      character = make_fixnum (starting_i);
       ASET (kludge, 0, character);
 
       /* If this binding is shadowed by some other map, ignore it.  */
@@ -3541,7 +3541,7 @@ describe_vector (Lisp_Object vector, Lisp_Object prefix, Lisp_Object args,
         {
           insert (" .. ", 4);
 
-          ASET (kludge, 0, make_number (i));
+          ASET (kludge, 0, make_fixnum (i));
 
           if (!NILP (elt_prefix))
             insert1 (elt_prefix);
@@ -3618,7 +3618,7 @@ syms_of_keymap (void)
 
   /* Now we are ready to set up this property, so we can
      create char tables.  */
-  Fput (Qkeymap, Qchar_table_extra_slots, make_number (0));
+  Fput (Qkeymap, Qchar_table_extra_slots, make_fixnum (0));
 
   /* Initialize the keymaps standardly used.
      Each one is the value of a Lisp variable, and is also
@@ -3719,7 +3719,7 @@ be preferred.  */);
   DEFSYM (Qremap, "remap");
   DEFSYM (QCadvertised_binding, ":advertised-binding");
 
-  command_remapping_vector = Fmake_vector (make_number (2), Qremap);
+  command_remapping_vector = Fmake_vector (make_fixnum (2), Qremap);
   staticpro (&command_remapping_vector);
 
   where_is_cache_keymaps = Qt;