Merge branch 'feature/bignum'

1 files changed, 209 insertions, 209 deletions

diff --git a/src/coding.c b/src/coding.c
index 8ce902b06d5..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)))
 
@@ -620,18 +620,18 @@ inhibit_flag (int encoded_flag, bool var)
   } while (0)
 
 static void
-CHECK_NATNUM_CAR (Lisp_Object x)
+CHECK_FIXNAT_CAR (Lisp_Object x)
 {
   Lisp_Object tmp = XCAR (x);
-  CHECK_NATNUM (tmp);
+  CHECK_FIXNAT (tmp);
   XSETCAR (x, tmp);
 }
 
 static void
-CHECK_NATNUM_CDR (Lisp_Object x)
+CHECK_FIXNAT_CDR (Lisp_Object x)
 {
   Lisp_Object tmp = XCDR (x);
-  CHECK_NATNUM (tmp);
+  CHECK_FIXNAT (tmp);
   XSETCDR (x, tmp);
 }
 
@@ -2622,7 +2622,7 @@ encode_coding_emacs_mule (struct coding_system *coding)
             case CODING_ANNOTATE_CHARSET_MASK:
               preferred_charset_id = charbuf[3];
               if (preferred_charset_id >= 0
-                  && NILP (Fmemq (make_number (preferred_charset_id),
+                  && NILP (Fmemq (make_fixnum (preferred_charset_id),
                                   charset_list)))
                 preferred_charset_id = -1;
               break;
@@ -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);
@@ -4459,7 +4459,7 @@ encode_coding_iso_2022 (struct coding_system *coding)
             case CODING_ANNOTATE_CHARSET_MASK:
               preferred_charset_id = charbuf[2];
               if (preferred_charset_id >= 0
-                  && NILP (Fmemq (make_number (preferred_charset_id),
+                  && NILP (Fmemq (make_fixnum (preferred_charset_id),
                                   charset_list)))
                 preferred_charset_id = -1;
               break;
@@ -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)
@@ -5440,9 +5440,9 @@ detect_coding_charset (struct coding_system *coding,
             break;
           found = CATEGORY_MASK_CHARSET;
         }
-      if (INTEGERP (val))
+      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)
                 {
@@ -5551,11 +5551,11 @@ decode_coding_charset (struct coding_system *coding)
       code = c;
 
       val = AREF (valids, c);
-      if (! INTEGERP (val) && ! CONSP (val))
+      if (! FIXNUMP (val) && ! CONSP (val))
         goto invalid_code;
-      if (INTEGERP (val))
+      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 (NATNUMP (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 (NATNUMP (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;                                          \
             }                                                   \
@@ -6981,7 +6981,7 @@ get_translation_table (Lisp_Object attrs, bool encodep, int *max_lookup)
 static Lisp_Object
 get_translation (Lisp_Object trans, int *buf, int *buf_end, ptrdiff_t *nchars)
 {
-  if (INTEGERP (trans) || VECTORP (trans))
+  if (FIXNUMP (trans) || VECTORP (trans))
     {
       *nchars = 1;
       return trans;
@@ -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)
@@ -7048,12 +7048,12 @@ produce_chars (struct coding_system *coding, Lisp_Object translation_table,
               if (! NILP (trans))
                 {
                   trans = get_translation (trans, buf, buf_end, &from_nchars);
-                  if (INTEGERP (trans))
-                    c = XINT (trans);
+                  if (FIXNUMP (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);
@@ -7239,11 +7239,11 @@ produce_composition (struct coding_system *coding, int *charbuf, ptrdiff_t pos)
       for (i = j = 0; i < len && charbuf[i] != -1; i++, j++)
         {
           if (charbuf[i] >= 0)
-            args[j] = make_number (charbuf[i]);
+            args[j] = make_fixnum (charbuf[i]);
           else
             {
               i++;
-              args[j] = make_number (charbuf[i] % 0x100);
+              args[j] = make_fixnum (charbuf[i] % 0x100);
             }
         }
       components = (i == j ? Fstring (j, args) : Fvector (j, args));
@@ -7263,7 +7263,7 @@ produce_charset (struct coding_system *coding, int *charbuf, ptrdiff_t pos)
   ptrdiff_t from = pos - charbuf[2];
   struct charset *charset = CHARSET_FROM_ID (charbuf[3]);
 
-  Fput_text_property (make_number (from), make_number (pos),
+  Fput_text_property (make_fixnum (from), make_fixnum (pos),
                       Qcharset, CHARSET_NAME (charset),
                       coding->dst_object);
 }
@@ -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))
                 {
@@ -7546,16 +7546,16 @@ handle_composition_annotation (ptrdiff_t pos, ptrdiff_t limit,
                       buf++;
                     }
                 }
-              else if (INTEGERP (components))
+              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 ();
@@ -7591,16 +7591,16 @@ handle_charset_annotation (ptrdiff_t pos, ptrdiff_t limit,
   Lisp_Object val, next;
   int id;
 
-  val = Fget_text_property (make_number (pos), Qcharset, coding->src_object);
+  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_number (pos), Qcharset,
+  next = Fnext_single_property_change (make_fixnum (pos), Qcharset,
                                        coding->src_object,
-                                       make_number (limit));
-  *stop = XINT (next);
+                                       make_fixnum (limit));
+  *stop = XFIXNUM (next);
   return buf;
 }
 
@@ -7709,20 +7709,20 @@ consume_chars (struct coding_system *coding, Lisp_Object translation_table,
           lookup_buf_end = lookup_buf + i;
           trans = get_translation (trans, lookup_buf, lookup_buf_end,
                                    &from_nchars);
-          if (INTEGERP (trans))
-            c = XINT (trans);
+          if (FIXNUMP (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);
         }
@@ -8011,8 +8011,8 @@ decode_coding_gap (struct coding_system *coding,
       bset_undo_list (current_buffer, Qt);
       TEMP_SET_PT_BOTH (coding->dst_pos, coding->dst_pos_byte);
       val = call1 (CODING_ATTR_POST_READ (attrs),
-                   make_number (coding->produced_char));
-      CHECK_NATNUM (val);
+                   make_fixnum (coding->produced_char));
+      CHECK_FIXNAT (val);
       coding->produced_char += Z - prev_Z;
       coding->produced += Z_BYTE - prev_Z_BYTE;
     }
@@ -8163,8 +8163,8 @@ decode_coding_object (struct coding_system *coding,
       bset_undo_list (current_buffer, Qt);
       TEMP_SET_PT_BOTH (coding->dst_pos, coding->dst_pos_byte);
       val = safe_call1 (CODING_ATTR_POST_READ (attrs),
-                        make_number (coding->produced_char));
-      CHECK_NATNUM (val);
+                        make_fixnum (coding->produced_char));
+      CHECK_FIXNAT (val);
       coding->produced_char += Z - prev_Z;
       coding->produced += Z_BYTE - prev_Z_BYTE;
       unbind_to (count1, Qnil);
@@ -8293,7 +8293,7 @@ encode_coding_object (struct coding_system *coding,
         }
 
       safe_call2 (CODING_ATTR_PRE_WRITE (attrs),
-                  make_number (BEG), make_number (Z));
+                  make_fixnum (BEG), make_fixnum (Z));
       if (XBUFFER (coding->src_object) != current_buffer)
         kill_src_buffer = 1;
       coding->src_object = Fcurrent_buffer ();
@@ -8459,7 +8459,7 @@ from_unicode (Lisp_Object str)
   if (!STRING_MULTIBYTE (str) &&
       SBYTES (str) & 1)
     {
-      str = Fsubstring (str, make_number (0), make_number (-1));
+      str = Fsubstring (str, make_fixnum (0), make_fixnum (-1));
     }
 
   return code_convert_string_norecord (str, Qutf_16le, 0);
@@ -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;
@@ -8741,20 +8741,20 @@ detect_coding_system (const unsigned char *src,
         {
           detect_info.found = CATEGORY_MASK_RAW_TEXT;
           id = CODING_SYSTEM_ID (Qno_conversion);
-          val = list1 (make_number (id));
+          val = list1 (make_fixnum (id));
         }
       else if (! detect_info.rejected && ! detect_info.found)
         {
           detect_info.found = CATEGORY_MASK_ANY;
           id = coding_categories[coding_category_undecided].id;
-          val = list1 (make_number (id));
+          val = list1 (make_fixnum (id));
         }
       else if (highest)
         {
           if (detect_info.found)
             {
               detect_info.found = 1 << category;
-              val = list1 (make_number (this->id));
+              val = list1 (make_fixnum (this->id));
             }
           else
             for (i = 0; i < coding_category_raw_text; i++)
@@ -8762,7 +8762,7 @@ detect_coding_system (const unsigned char *src,
                 {
                   detect_info.found = 1 << coding_priorities[i];
                   id = coding_categories[coding_priorities[i]].id;
-                  val = list1 (make_number (id));
+                  val = list1 (make_fixnum (id));
                   break;
                 }
         }
@@ -8779,7 +8779,7 @@ detect_coding_system (const unsigned char *src,
                   found |= 1 << category;
                   id = coding_categories[category].id;
                   if (id >= 0)
-                    val = list1 (make_number (id));
+                    val = list1 (make_fixnum (id));
                 }
             }
           for (i = coding_category_raw_text - 1; i >= 0; i--)
@@ -8788,7 +8788,7 @@ detect_coding_system (const unsigned char *src,
               if (detect_info.found & (1 << category))
                 {
                   id = coding_categories[category].id;
-                  val = Fcons (make_number (id), val);
+                  val = Fcons (make_fixnum (id), val);
                 }
             }
           detect_info.found |= found;
@@ -8804,7 +8804,7 @@ detect_coding_system (const unsigned char *src,
             this = coding_categories + coding_category_utf_8_sig;
           else
             this = coding_categories + coding_category_utf_8_nosig;
-          val = list1 (make_number (this->id));
+          val = list1 (make_fixnum (this->id));
         }
     }
   else if (base_category == coding_category_utf_16_auto)
@@ -8821,13 +8821,13 @@ detect_coding_system (const unsigned char *src,
             this = coding_categories + coding_category_utf_16_be_nosig;
           else
             this = coding_categories + coding_category_utf_16_le_nosig;
-          val = list1 (make_number (this->id));
+          val = list1 (make_fixnum (this->id));
         }
     }
   else
     {
-      detect_info.found = 1 << XINT (CODING_ATTR_CATEGORY (attrs));
-      val = list1 (make_number (coding.id));
+      detect_info.found = 1 << XFIXNUM (CODING_ATTR_CATEGORY (attrs));
+      val = list1 (make_fixnum (coding.id));
     }
 
   /* Then, detect eol-format if necessary.  */
@@ -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;
     }
@@ -9011,23 +9011,23 @@ DEFUN ("find-coding-systems-region-internal",
     }
   else
     {
-      CHECK_NUMBER_COERCE_MARKER (start);
-      CHECK_NUMBER_COERCE_MARKER (end);
-      if (XINT (start) < BEG || XINT (end) > Z || XINT (start) > XINT (end))
+      CHECK_FIXNUM_COERCE_MARKER (start);
+      CHECK_FIXNUM_COERCE_MARKER (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)))))
@@ -9175,8 +9175,8 @@ to the string and treated as in `substring'.  */)
     n = 1;
   else
     {
-      CHECK_NATNUM (count);
-      n = XINT (count);
+      CHECK_FIXNAT (count);
+      n = XFIXNUM (count);
     }
 
   positions = Qnil;
@@ -9201,7 +9201,7 @@ to the string and treated as in `substring'.  */)
           && ! char_charset (translate_char (translation_table, c),
                              charset_list, NULL))
         {
-          positions = Fcons (make_number (from), positions);
+          positions = Fcons (make_fixnum (from), positions);
           n--;
           if (n == 0)
             break;
@@ -9265,25 +9265,25 @@ is nil.  */)
     }
   else
     {
-      CHECK_NUMBER_COERCE_MARKER (start);
-      CHECK_NUMBER_COERCE_MARKER (end);
-      if (XINT (start) < BEG || XINT (end) > Z || XINT (start) > XINT (end))
+      CHECK_FIXNUM_COERCE_MARKER (start);
+      CHECK_FIXNUM_COERCE_MARKER (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;
@@ -9318,7 +9318,7 @@ is nil.  */)
             {
               elt = XCDR (XCAR (tail));
               if (! char_encodable_p (c, XCAR (elt)))
-                XSETCDR (elt, Fcons (make_number (pos), XCDR (elt)));
+                XSETCDR (elt, Fcons (make_fixnum (pos), XCDR (elt)));
             }
           if (charset_map_loaded)
             {
@@ -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);
@@ -9395,7 +9395,7 @@ code_convert_region (Lisp_Object start, Lisp_Object end,
     Vlast_coding_system_used = CODING_ID_NAME (coding.id);
 
   return (BUFFERP (dst_object)
-          ? make_number (coding.produced_char)
+          ? make_fixnum (coding.produced_char)
           : coding.dst_object);
 }
 
@@ -9491,7 +9491,7 @@ code_convert_string (Lisp_Object string, Lisp_Object coding_system,
     Vlast_coding_system_used = CODING_ID_NAME (coding.id);
 
   return (BUFFERP (dst_object)
-          ? make_number (coding.produced_char)
+          ? make_fixnum (coding.produced_char)
           : coding.dst_object);
 }
 
@@ -9610,8 +9610,8 @@ Return the corresponding character.  */)
   EMACS_INT ch;
   int c;
 
-  CHECK_NATNUM (code);
-  ch = XFASTINT (code);
+  CHECK_FIXNAT (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)
     {
@@ -9649,7 +9649,7 @@ Return the corresponding character.  */)
   c = DECODE_CHAR (charset, c);
   if (c < 0)
     error ("Invalid code: %"pI"d", ch);
-  return make_number (c);
+  return make_fixnum (c);
 }
 
 
@@ -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);
 
@@ -9678,7 +9678,7 @@ Return the corresponding code in SJIS.  */)
     error ("Can't encode by shift_jis encoding: %c", c);
   JIS_TO_SJIS (code);
 
-  return make_number (code);
+  return make_fixnum (code);
 }
 
 DEFUN ("decode-big5-char", Fdecode_big5_char, Sdecode_big5_char, 1, 1, 0,
@@ -9691,8 +9691,8 @@ Return the corresponding character.  */)
   EMACS_INT ch;
   int c;
 
-  CHECK_NATNUM (code);
-  ch = XFASTINT (code);
+  CHECK_FIXNAT (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)
     {
@@ -9722,7 +9722,7 @@ Return the corresponding character.  */)
   c = DECODE_CHAR (charset, c);
   if (c < 0)
     error ("Invalid code: %"pI"d", ch);
-  return make_number (c);
+  return make_fixnum (c);
 }
 
 DEFUN ("encode-big5-char", Fencode_big5_char, Sencode_big5_char, 1, 1, 0,
@@ -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)
@@ -9748,7 +9748,7 @@ Return the corresponding character code in Big5.  */)
   if (code == CHARSET_INVALID_CODE (charset))
     error ("Can't encode by Big5 encoding: %c", c);
 
-  return make_number (code);
+  return make_fixnum (code);
 }
 
 
@@ -9770,7 +9770,7 @@ DEFUN ("set-terminal-coding-system-internal", Fset_terminal_coding_system_intern
   tset_charset_list
     (term, (terminal_coding->common_flags & CODING_REQUIRE_ENCODING_MASK
             ? coding_charset_list (terminal_coding)
-            : list1 (make_number (charset_ascii))));
+            : list1 (make_fixnum (charset_ascii))));
   return Qnil;
 }
 
@@ -9883,19 +9883,19 @@ usage: (find-operation-coding-system OPERATION ARGUMENTS...)  */)
     error ("Too few arguments");
   operation = args[0];
   if (!SYMBOLP (operation)
-      || (target_idx = Fget (operation, Qtarget_idx), !NATNUMP (target_idx)))
+      || (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)
-            && (INTEGERP (target) || EQ (target, Qt)))))
+            && (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);
 
@@ -9917,7 +9917,7 @@ usage: (find-operation-coding-system OPERATION ARGUMENTS...)  */)
           && ((STRINGP (target)
                && STRINGP (XCAR (elt))
                && fast_string_match (XCAR (elt), target) >= 0)
-              || (INTEGERP (target) && EQ (target, XCAR (elt)))))
+              || (FIXNUMP (target) && EQ (target, XCAR (elt)))))
         {
           val = XCDR (elt);
           /* Here, if VAL is both a valid coding system and a valid
@@ -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.  */
@@ -10076,7 +10076,7 @@ usage: (define-coding-system-internal ...)  */)
   if (nargs < coding_arg_max)
     goto short_args;
 
-  attrs = Fmake_vector (make_number (coding_attr_last_index), Qnil);
+  attrs = Fmake_vector (make_fixnum (coding_attr_last_index), Qnil);
 
   name = args[coding_arg_name];
   CHECK_SYMBOL (name);
@@ -10108,10 +10108,10 @@ usage: (define-coding-system-internal ...)  */)
         }
       for (tail = charset_list; CONSP (tail); tail = XCDR (tail))
         {
-          if (! RANGED_INTEGERP (0, XCAR (tail), INT_MAX - 1))
+          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
@@ -10131,7 +10131,7 @@ usage: (define-coding-system-internal ...)  */)
             error ("Can't handle charset `%s'",
                    SDATA (SYMBOL_NAME (CHARSET_NAME (charset))));
 
-          XSETCAR (tail, make_number (charset->id));
+          XSETCAR (tail, make_fixnum (charset->id));
           if (max_charset_id < charset->id)
             max_charset_id = charset->id;
         }
@@ -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]);
@@ -10166,7 +10166,7 @@ usage: (define-coding-system-internal ...)  */)
 
   val = args[coding_arg_default_char];
   if (NILP (val))
-    ASET (attrs, coding_attr_default_char, make_number (' '));
+    ASET (attrs, coding_attr_default_char, make_fixnum (' '));
   else
     {
       CHECK_CHARACTER (val);
@@ -10194,11 +10194,11 @@ usage: (define-coding-system-internal ...)  */)
          If Nth element is a list of charset IDs, N is the first byte
          of one of them.  The list is sorted by dimensions of the
          charsets.  A charset of smaller dimension comes first. */
-      val = Fmake_vector (make_number (256), Qnil);
+      val = Fmake_vector (make_fixnum (256), Qnil);
 
       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;
 
@@ -10214,9 +10214,9 @@ usage: (define-coding-system-internal ...)  */)
               tmp = AREF (val, i);
               if (NILP (tmp))
                 tmp = XCAR (tail);
-              else if (NUMBERP (tmp))
+              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;
                     }
@@ -10264,31 +10264,31 @@ usage: (define-coding-system-internal ...)  */)
       ASET (attrs, coding_attr_ccl_encoder, val);
 
       val = args[coding_arg_ccl_valids];
-      valids = Fmake_string (make_number (256), make_number (0), Qnil);
+      valids = Fmake_string (make_fixnum (256), make_fixnum (0), Qnil);
       for (tail = val; CONSP (tail); tail = XCDR (tail))
         {
           int from, to;
 
           val = XCAR (tail);
-          if (INTEGERP (val))
+          if (FIXNUMP (val))
             {
-              if (! (0 <= XINT (val) && XINT (val) <= 255))
-                args_out_of_range_3 (val, make_number (0), make_number (255));
-              from = to = XINT (val);
+              if (! (0 <= XFIXNUM (val) && XFIXNUM (val) <= 255))
+                args_out_of_range_3 (val, make_fixnum (0), make_fixnum (255));
+              from = to = XFIXNUM (val);
             }
           else
             {
               CHECK_CONS (val);
-              CHECK_NATNUM_CAR (val);
-              CHECK_NUMBER_CDR (val);
-              if (XINT (XCAR (val)) > 255)
+              CHECK_FIXNAT_CAR (val);
+              CHECK_FIXNUM_CDR (val);
+              if (XFIXNUM (XCAR (val)) > 255)
                 args_out_of_range_3 (XCAR (val),
-                                     make_number (0), make_number (255));
-              from = XINT (XCAR (val));
-              if (! (from <= XINT (XCDR (val)) && XINT (XCDR (val)) <= 255))
+                                     make_fixnum (0), make_fixnum (255));
+              from = XFIXNUM (XCAR (val));
+              if (! (from <= XFIXNUM (XCDR (val)) && XFIXNUM (XCDR (val)) <= 255))
                 args_out_of_range_3 (XCDR (val),
-                                     XCAR (val), make_number (255));
-              to = XINT (XCDR (val));
+                                     XCAR (val), make_fixnum (255));
+              to = XFIXNUM (XCDR (val));
             }
           for (i = from; i <= to; i++)
             SSET (valids, i, 1);
@@ -10352,18 +10352,18 @@ usage: (define-coding-system-internal ...)  */)
               struct charset *charset;
 
               CHECK_CHARSET_GET_CHARSET (val, charset);
-              ASET (initial, i, make_number (CHARSET_ID (charset)));
+              ASET (initial, i, make_fixnum (CHARSET_ID (charset)));
               if (i == 0 && CHARSET_ASCII_COMPATIBLE_P (charset))
                 ASET (attrs, coding_attr_ascii_compat, Qt);
             }
           else
-            ASET (initial, i, make_number (-1));
+            ASET (initial, i, make_fixnum (-1));
         }
 
       reg_usage = args[coding_arg_iso2022_reg_usage];
       CHECK_CONS (reg_usage);
-      CHECK_NUMBER_CAR (reg_usage);
-      CHECK_NUMBER_CDR (reg_usage);
+      CHECK_FIXNUM_CAR (reg_usage);
+      CHECK_FIXNUM_CDR (reg_usage);
 
       request = Fcopy_sequence (args[coding_arg_iso2022_request]);
       for (tail = request; CONSP (tail); tail = XCDR (tail))
@@ -10375,18 +10375,18 @@ usage: (define-coding-system-internal ...)  */)
           CHECK_CONS (val);
           tmp1 = XCAR (val);
           CHECK_CHARSET_GET_ID (tmp1, id);
-          CHECK_NATNUM_CDR (val);
-          if (XINT (XCDR (val)) >= 4)
-            error ("Invalid graphic register number: %"pI"d", XINT (XCDR (val)));
-          XSETCAR (val, make_number (id));
+          CHECK_FIXNAT_CDR (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_NATNUM (flags);
-      i = XINT (flags) & INT_MAX;
+      CHECK_FIXNAT (flags);
+      i = XFIXNUM (flags) & INT_MAX;
       if (EQ (args[coding_arg_charset_list], Qiso_2022))
         i |= CODING_ISO_FLAG_FULL_SUPPORT;
-      flags = make_number (i);
+      flags = make_fixnum (i);
 
       ASET (attrs, coding_attr_iso_initial, initial);
       ASET (attrs, coding_attr_iso_usage, reg_usage);
@@ -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))));
@@ -10532,7 +10532,7 @@ usage: (define-coding-system-internal ...)  */)
     error ("Invalid coding system type: %s",
            SDATA (SYMBOL_NAME (coding_type)));
 
-  ASET (attrs, coding_attr_category, make_number (category));
+  ASET (attrs, coding_attr_category, make_fixnum (category));
   ASET (attrs, coding_attr_plist,
         Fcons (QCcategory,
                Fcons (AREF (Vcoding_category_table, category),
@@ -10599,7 +10599,7 @@ usage: (define-coding-system-internal ...)  */)
  short_args:
   Fsignal (Qwrong_number_of_arguments,
            Fcons (intern ("define-coding-system-internal"),
-                  make_number (nargs)));
+                  make_fixnum (nargs)));
 }
 
 
@@ -10621,7 +10621,7 @@ DEFUN ("coding-system-put", Fcoding_system_put, Scoding_system_put,
   else if (EQ (prop, QCdefault_char))
     {
       if (NILP (val))
-        val = make_number (' ');
+        val = make_fixnum (' ');
       else
         CHECK_CHARACTER (val);
       ASET (attrs, coding_attr_default_char, val);
@@ -10766,7 +10766,7 @@ coding system whose eol-type is N.  */)
   if (VECTORP (eol_type))
     return Fcopy_sequence (eol_type);
   n = EQ (eol_type, Qunix) ? 0 : EQ (eol_type, Qdos) ? 1 : 2;
-  return make_number (n);
+  return make_fixnum (n);
 }
 
 #endif /* emacs */
@@ -10842,25 +10842,25 @@ syms_of_coding (void)
   Fset (Qcoding_system_history, Qnil);
 
   /* Target FILENAME is the first argument.  */
-  Fput (Qinsert_file_contents, Qtarget_idx, make_number (0));
+  Fput (Qinsert_file_contents, Qtarget_idx, make_fixnum (0));
   /* Target FILENAME is the third argument.  */
-  Fput (Qwrite_region, Qtarget_idx, make_number (2));
+  Fput (Qwrite_region, Qtarget_idx, make_fixnum (2));
 
   DEFSYM (Qcall_process, "call-process");
   /* Target PROGRAM is the first argument.  */
-  Fput (Qcall_process, Qtarget_idx, make_number (0));
+  Fput (Qcall_process, Qtarget_idx, make_fixnum (0));
 
   DEFSYM (Qcall_process_region, "call-process-region");
   /* Target PROGRAM is the third argument.  */
-  Fput (Qcall_process_region, Qtarget_idx, make_number (2));
+  Fput (Qcall_process_region, Qtarget_idx, make_fixnum (2));
 
   DEFSYM (Qstart_process, "start-process");
   /* Target PROGRAM is the third argument.  */
-  Fput (Qstart_process, Qtarget_idx, make_number (2));
+  Fput (Qstart_process, Qtarget_idx, make_fixnum (2));
 
   DEFSYM (Qopen_network_stream, "open-network-stream");
   /* Target SERVICE is the fourth argument.  */
-  Fput (Qopen_network_stream, Qtarget_idx, make_number (3));
+  Fput (Qopen_network_stream, Qtarget_idx, make_fixnum (3));
 
   DEFSYM (Qunix, "unix");
   DEFSYM (Qdos, "dos");
@@ -10899,7 +10899,7 @@ syms_of_coding (void)
         build_pure_c_string ("Invalid coding system"));
 
   DEFSYM (Qtranslation_table, "translation-table");
-  Fput (Qtranslation_table, Qchar_table_extra_slots, make_number (2));
+  Fput (Qtranslation_table, Qchar_table_extra_slots, make_fixnum (2));
   DEFSYM (Qtranslation_table_id, "translation-table-id");
 
   /* Coding system emacs-mule and raw-text are for converting only
@@ -10916,7 +10916,7 @@ syms_of_coding (void)
   DEFSYM (QCascii_compatible_p, ":ascii-compatible-p");
 
   Vcoding_category_table
-    = Fmake_vector (make_number (coding_category_max), Qnil);
+    = Fmake_vector (make_fixnum (coding_category_max), Qnil);
   staticpro (&Vcoding_category_table);
   /* Followings are target of code detection.  */
   ASET (Vcoding_category_table, coding_category_iso_7,
@@ -11220,7 +11220,7 @@ a coding system of ISO 2022 variant which has a flag
 `accept-latin-extra-code' t (e.g. iso-latin-1) on reading a file
 or reading output of a subprocess.
 Only 128th through 159th elements have a meaning.  */);
-  Vlatin_extra_code_table = Fmake_vector (make_number (256), Qnil);
+  Vlatin_extra_code_table = Fmake_vector (make_fixnum (256), Qnil);
 
   DEFVAR_LISP ("select-safe-coding-system-function",
                Vselect_safe_coding_system_function,
@@ -11309,13 +11309,13 @@ internal character representation.  */);
       QCname,
       args[coding_arg_name] = Qno_conversion,
       QCmnemonic,
-      args[coding_arg_mnemonic] = make_number ('='),
+      args[coding_arg_mnemonic] = make_fixnum ('='),
       intern_c_string (":coding-type"),
       args[coding_arg_coding_type] = Qraw_text,
       QCascii_compatible_p,
       args[coding_arg_ascii_compatible_p] = Qt,
       QCdefault_char,
-      args[coding_arg_default_char] = make_number (0),
+      args[coding_arg_default_char] = make_fixnum (0),
       intern_c_string (":for-unibyte"),
       args[coding_arg_for_unibyte] = Qt,
       intern_c_string (":docstring"),
@@ -11332,7 +11332,7 @@ internal character representation.  */);
   Fdefine_coding_system_internal (coding_arg_max, args);
 
   plist[1] = args[coding_arg_name] = Qundecided;
-  plist[3] = args[coding_arg_mnemonic] = make_number ('-');
+  plist[3] = args[coding_arg_mnemonic] = make_fixnum ('-');
   plist[5] = args[coding_arg_coding_type] = Qundecided;
   /* This is already set.
      plist[7] = args[coding_arg_ascii_compatible_p] = Qt; */
@@ -11343,8 +11343,8 @@ internal character representation.  */);
                                    "automatic conversion on decoding.");
   plist[15] = args[coding_arg_eol_type] = Qnil;
   args[coding_arg_plist] = CALLMANY (Flist, plist);
-  args[coding_arg_undecided_inhibit_null_byte_detection] = make_number (0);
-  args[coding_arg_undecided_inhibit_iso_escape_detection] = make_number (0);
+  args[coding_arg_undecided_inhibit_null_byte_detection] = make_fixnum (0);
+  args[coding_arg_undecided_inhibit_iso_escape_detection] = make_fixnum (0);
   Fdefine_coding_system_internal (coding_arg_undecided_max, args);
 
   setup_coding_system (Qno_conversion, &safe_terminal_coding);