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.

1 files changed, 30 insertions, 30 deletions

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