master 57f5a63: Refactor and fix typo in CHECK_*_COERCE_MARKER

[Paul Eggert]

branch: master
commit 57f5a63d85f6c3ea1d8b428b12a8db743de3b0bc
Author: Paul Eggert <address@hidden>
Commit: Paul Eggert <address@hidden>

    Refactor and fix typo in CHECK_*_COERCE_MARKER
    
    * src/data.c (check_integer_coerce_marker)
    (check_number_coerce_marker): New functions.
    Also, fix a typo in the former, by having it use
    Qinteger_or_marker_p not Qnumber_or_marker_p.
    (arithcompare, floatop_arith_driver, bignum_arith_driver)
    (arith_driver, Fplus, Fminus, Ftimes, Fquo, Frem, Fmod)
    (minmax_driver, Flogand, Flogior, Flogxor, Fadd1, Fsub1):
    Use them in place of the similarly-named macros.
    * src/lisp.h (CHECK_NUMBER_COERCE_MARKER)
    (CHECK_INTEGER_COERCE_MARKER): Remove; no longer used.
---
 src/data.c | 77 +++++++++++++++++++++++++++++++++-----------------------------
 src/lisp.h | 16 -------------
 2 files changed, 41 insertions(+), 52 deletions(-)

diff --git a/src/data.c b/src/data.c
index b0d438e..bce2e53 100644
--- a/src/data.c
+++ b/src/data.c
@@ -2333,6 +2333,24 @@ bool-vector.  IDX starts at 0.  */)
 
 /* Arithmetic functions */
 
+static Lisp_Object
+check_integer_coerce_marker (Lisp_Object x)
+{
+  if (MARKERP (x))
+    return make_fixnum (marker_position (x));
+  CHECK_TYPE (INTEGERP (x), Qinteger_or_marker_p, x);
+  return x;
+}
+
+static Lisp_Object
+check_number_coerce_marker (Lisp_Object x)
+{
+  if (MARKERP (x))
+    return make_fixnum (marker_position (x));
+  CHECK_TYPE (NUMBERP (x), Qnumber_or_marker_p, x);
+  return x;
+}
+
 Lisp_Object
 arithcompare (Lisp_Object num1, Lisp_Object num2,
              enum Arith_Comparison comparison)
@@ -2341,8 +2359,8 @@ arithcompare (Lisp_Object num1, Lisp_Object num2,
   bool lt, eq = true, gt;
   bool test;
 
-  CHECK_NUMBER_COERCE_MARKER (num1);
-  CHECK_NUMBER_COERCE_MARKER (num2);
+  num1 = check_number_coerce_marker (num1);
+  num2 = check_number_coerce_marker (num2);
 
   /* If the comparison is mostly done by comparing two doubles,
      set LT, EQ, and GT to the <, ==, > results of that comparison,
@@ -2744,9 +2762,7 @@ floatop_arith_driver (enum arithop code, ptrdiff_t nargs, 
Lisp_Object *args,
       argnum++;
       if (argnum == nargs)
        return make_float (accum);
-      Lisp_Object val = args[argnum];
-      CHECK_NUMBER_COERCE_MARKER (val);
-      next = XFLOATINT (val);
+      next = XFLOATINT (check_number_coerce_marker (args[argnum]));
     }
 }
 
@@ -2808,8 +2824,7 @@ bignum_arith_driver (enum arithop code, ptrdiff_t nargs, 
Lisp_Object *args,
       argnum++;
       if (argnum == nargs)
        return make_integer_mpz ();
-      val = args[argnum];
-      CHECK_NUMBER_COERCE_MARKER (val);
+      val = check_number_coerce_marker (args[argnum]);
       if (FLOATP (val))
        return float_arith_driver (code, nargs, args, argnum,
                                   mpz_get_d_rounded (*accum), val);
@@ -2838,8 +2853,7 @@ arith_driver (enum arithop code, ptrdiff_t nargs, 
Lisp_Object *args,
        argnum++;
        if (argnum == nargs)
          return make_int (accum);
-       val = args[argnum];
-       CHECK_NUMBER_COERCE_MARKER (val);
+       val = check_number_coerce_marker (args[argnum]);
 
        /* Set NEXT to the next value if it fits, else exit the loop.  */
        intmax_t next;
@@ -2886,8 +2900,7 @@ usage: (+ &rest NUMBERS-OR-MARKERS)  */)
 {
   if (nargs == 0)
     return make_fixnum (0);
-  Lisp_Object a = args[0];
-  CHECK_NUMBER_COERCE_MARKER (a);
+  Lisp_Object a = check_number_coerce_marker (args[0]);
   return nargs == 1 ? a : arith_driver (Aadd, nargs, args, a);
 }
 
@@ -2900,8 +2913,7 @@ usage: (- &optional NUMBER-OR-MARKER &rest 
MORE-NUMBERS-OR-MARKERS)  */)
 {
   if (nargs == 0)
     return make_fixnum (0);
-  Lisp_Object a = args[0];
-  CHECK_NUMBER_COERCE_MARKER (a);
+  Lisp_Object a = check_number_coerce_marker (args[0]);
   if (nargs == 1)
     {
       if (FIXNUMP (a))
@@ -2921,8 +2933,7 @@ usage: (* &rest NUMBERS-OR-MARKERS)  */)
 {
   if (nargs == 0)
     return make_fixnum (1);
-  Lisp_Object a = args[0];
-  CHECK_NUMBER_COERCE_MARKER (a);
+  Lisp_Object a = check_number_coerce_marker (args[0]);
   return nargs == 1 ? a : arith_driver (Amult, nargs, args, a);
 }
 
@@ -2934,8 +2945,7 @@ The arguments must be numbers or markers.
 usage: (/ NUMBER &rest DIVISORS)  */)
   (ptrdiff_t nargs, Lisp_Object *args)
 {
-  Lisp_Object a = args[0];
-  CHECK_NUMBER_COERCE_MARKER (a);
+  Lisp_Object a = check_number_coerce_marker (args[0]);
   if (nargs == 1)
     {
       if (FIXNUMP (a))
@@ -3017,10 +3027,10 @@ integer_remainder (Lisp_Object num, Lisp_Object den, 
bool modulo)
 DEFUN ("%", Frem, Srem, 2, 2, 0,
        doc: /* Return remainder of X divided by Y.
 Both must be integers or markers.  */)
-  (register Lisp_Object x, Lisp_Object y)
+  (Lisp_Object x, Lisp_Object y)
 {
-  CHECK_INTEGER_COERCE_MARKER (x);
-  CHECK_INTEGER_COERCE_MARKER (y);
+  x = check_integer_coerce_marker (x);
+  y = check_integer_coerce_marker (y);
   return integer_remainder (x, y, false);
 }
 
@@ -3030,8 +3040,8 @@ The result falls between zero (inclusive) and Y 
(exclusive).
 Both X and Y must be numbers or markers.  */)
   (Lisp_Object x, Lisp_Object y)
 {
-  CHECK_NUMBER_COERCE_MARKER (x);
-  CHECK_NUMBER_COERCE_MARKER (y);
+  x = check_number_coerce_marker (x);
+  y = check_number_coerce_marker (y);
   if (FLOATP (x) || FLOATP (y))
     return fmod_float (x, y);
   return integer_remainder (x, y, true);
@@ -3041,12 +3051,10 @@ static Lisp_Object
 minmax_driver (ptrdiff_t nargs, Lisp_Object *args,
               enum Arith_Comparison comparison)
 {
-  Lisp_Object accum = args[0];
-  CHECK_NUMBER_COERCE_MARKER (accum);
+  Lisp_Object accum = check_number_coerce_marker (args[0]);
   for (ptrdiff_t argnum = 1; argnum < nargs; argnum++)
     {
-      Lisp_Object val = args[argnum];
-      CHECK_NUMBER_COERCE_MARKER (val);
+      Lisp_Object val = check_number_coerce_marker (args[argnum]);
       if (!NILP (arithcompare (val, accum, comparison)))
        accum = val;
       else if (FLOATP (val) && isnan (XFLOAT_DATA (val)))
@@ -3081,8 +3089,7 @@ usage: (logand &rest INTS-OR-MARKERS)  */)
 {
   if (nargs == 0)
     return make_fixnum (-1);
-  Lisp_Object a = args[0];
-  CHECK_INTEGER_COERCE_MARKER (a);
+  Lisp_Object a = check_integer_coerce_marker (args[0]);
   return nargs == 1 ? a : arith_driver (Alogand, nargs, args, a);
 }
 
@@ -3094,8 +3101,7 @@ usage: (logior &rest INTS-OR-MARKERS)  */)
 {
   if (nargs == 0)
     return make_fixnum (0);
-  Lisp_Object a = args[0];
-  CHECK_INTEGER_COERCE_MARKER (a);
+  Lisp_Object a = check_integer_coerce_marker (args[0]);
   return nargs == 1 ? a : arith_driver (Alogior, nargs, args, a);
 }
 
@@ -3107,8 +3113,7 @@ usage: (logxor &rest INTS-OR-MARKERS)  */)
 {
   if (nargs == 0)
     return make_fixnum (0);
-  Lisp_Object a = args[0];
-  CHECK_INTEGER_COERCE_MARKER (a);
+  Lisp_Object a = check_integer_coerce_marker (args[0]);
   return nargs == 1 ? a : arith_driver (Alogxor, nargs, args, a);
 }
 
@@ -3227,9 +3232,9 @@ expt_integer (Lisp_Object x, Lisp_Object y)
 DEFUN ("1+", Fadd1, Sadd1, 1, 1, 0,
        doc: /* Return NUMBER plus one.  NUMBER may be a number or a marker.
 Markers are converted to integers.  */)
-  (register Lisp_Object number)
+  (Lisp_Object number)
 {
-  CHECK_NUMBER_COERCE_MARKER (number);
+  number = check_number_coerce_marker (number);
 
   if (FIXNUMP (number))
     return make_int (XFIXNUM (number) + 1);
@@ -3242,9 +3247,9 @@ Markers are converted to integers.  */)
 DEFUN ("1-", Fsub1, Ssub1, 1, 1, 0,
        doc: /* Return NUMBER minus one.  NUMBER may be a number or a marker.
 Markers are converted to integers.  */)
-  (register Lisp_Object number)
+  (Lisp_Object number)
 {
-  CHECK_NUMBER_COERCE_MARKER (number);
+  number = check_number_coerce_marker (number);
 
   if (FIXNUMP (number))
     return make_int (XFIXNUM (number) - 1);
diff --git a/src/lisp.h b/src/lisp.h
index cd62823..49923be 100644
--- a/src/lisp.h
+++ b/src/lisp.h
@@ -3039,22 +3039,6 @@ CHECK_INTEGER (Lisp_Object x)
 {
   CHECK_TYPE (INTEGERP (x), Qnumberp, x);
 }
-
-#define CHECK_NUMBER_COERCE_MARKER(x)                                  \
-  do {                                                                 \
-    if (MARKERP (x))                                                   \
-      XSETFASTINT (x, marker_position (x));                            \
-    else                                                               \
-      CHECK_TYPE (NUMBERP (x), Qnumber_or_marker_p, x);                        
\
-  } while (false)
-
-#define CHECK_INTEGER_COERCE_MARKER(x)                                 \
-  do {                                                                 \
-    if (MARKERP (x))                                                   \
-      XSETFASTINT (x, marker_position (x));                            \
-    else                                                               \
-      CHECK_TYPE (INTEGERP (x), Qnumber_or_marker_p, x);               \
-  } while (false)
 
 
 /* If we're not dumping using the legacy dumper and we might be using