(internal_equal): Delete redundant tests.

Mask size field when comparing pseudovectors.
(Frandom): Use VALBITS instead of hardcoded constants.

1 files changed, 57 insertions, 59 deletions

diff --git a/src/fns.c b/src/fns.c
index 7af6cbbed0a..71c7243d706 100644
--- a/src/fns.c
+++ b/src/fns.c
@@ -49,8 +49,8 @@ DEFUN ("identity", Fidentity, Sidentity, 1, 1, 0,
 
 DEFUN ("random", Frandom, Srandom, 0, 1, 0,
   "Return a pseudo-random number.\n\
-On most systems all integers representable in Lisp are equally likely.\n\
-  This is 24 bits' worth.\n\
+All integers representable in Lisp are equally likely.\n\
+  On most systems, this is 28 bits' worth.\n\
 With argument N, return random number in interval [0,N).\n\
 With argument t, set the random number seed from the current time and pid.")
   (limit)
@@ -64,25 +64,19 @@ With argument t, set the random number seed from the current time and pid.")
 
   if (EQ (limit, Qt))
     srandom (getpid () + time (0));
-  if (INTEGERP (limit) && XINT (limit) > 0)
+  if (NATNUMP (limit) && XFASTINT (limit) != 0)
     {
-      if (XFASTINT (limit) >= 0x40000000)
-        /* This case may occur on 64-bit machines.  */
-        val = random () % XFASTINT (limit);
-      else
-        {
-          /* Try to take our random number from the higher bits of VAL,
-             not the lower, since (says Gentzel) the low bits of `random'
-             are less random than the higher ones.  We do this by using the
-             quotient rather than the remainder.  At the high end of the RNG
-             it's possible to get a quotient larger than limit; discarding
-             these values eliminates the bias that would otherwise appear
-             when using a large limit.  */
-          denominator = (unsigned long)0x40000000 / XFASTINT (limit);
-          do
-            val = (random () & 0x3fffffff) / denominator;
-          while (val >= XFASTINT (limit));
-        }
+      /* Try to take our random number from the higher bits of VAL,
+         not the lower, since (says Gentzel) the low bits of `random'
+         are less random than the higher ones.  We do this by using the
+         quotient rather than the remainder.  At the high end of the RNG
+         it's possible to get a quotient larger than limit; discarding
+         these values eliminates the bias that would otherwise appear
+         when using a large limit.  */
+      denominator = ((unsigned long)1 << VALBITS) / XFASTINT (limit);
+      do
+        val = (random () & (((unsigned long)1 << VALBITS) - 1)) / denominator;
+      while (val >= XFASTINT (limit));
     }
   else
     val = random ();
@@ -895,16 +889,14 @@ internal_equal (o1, o2, depth)
 #endif
 
     case Lisp_Cons:
-      {
-        if (!internal_equal (XCONS (o1)->car, XCONS (o2)->car, depth + 1))
-          return 0;
-        o1 = XCONS (o1)->cdr;
-        o2 = XCONS (o2)->cdr;
-        goto tail_recurse;
-      }
+      if (!internal_equal (XCONS (o1)->car, XCONS (o2)->car, depth + 1))
+        return 0;
+      o1 = XCONS (o1)->cdr;
+      o2 = XCONS (o2)->cdr;
+      goto tail_recurse;
 
     case Lisp_Misc:
-      if (MISCP (o1) && XMISC (o1)->type != XMISC (o2)->type)
+      if (XMISC (o1)->type != XMISC (o2)->type)
         return 0;
       if (OVERLAYP (o1))
         {
@@ -926,42 +918,48 @@ internal_equal (o1, o2, depth)
       break;
 
     case Lisp_Vectorlike:
-      if ((VECTORP (o1) && VECTORP (o2))
-          ||
-          (COMPILEDP (o1) && COMPILEDP (o2)))
-        {
-          register int index;
-          if (XVECTOR (o1)->size != XVECTOR (o2)->size)
-            return 0;
-          for (index = 0; index < XVECTOR (o1)->size; index++)
-            {
-              Lisp_Object v1, v2;
-              v1 = XVECTOR (o1)->contents [index];
-              v2 = XVECTOR (o2)->contents [index];
-              if (!internal_equal (v1, v2, depth + 1))
-                return 0;
-            }
-          return 1;
-        }
+      {
+        register int i, size;
+        size = XVECTOR (o1)->size;
+        /* Pseudovectors have the type encoded in the size field, so this test
+           actually checks that the objects have the same type as well as the
+           same size.  */
+        if (XVECTOR (o2)->size != size)
+          return 0;
+        /* But only true vectors and compiled functions are actually sensible
+           to compare, so eliminate the others now.  */
+        if (size & PSEUDOVECTOR_FLAG)
+          {
+            if (!(size & PVEC_COMPILED))
+              return 0;
+            size &= PSEUDOVECTOR_SIZE_MASK;
+          }
+        for (i = 0; i < size; i++)
+          {
+            Lisp_Object v1, v2;
+            v1 = XVECTOR (o1)->contents [i];
+            v2 = XVECTOR (o2)->contents [i];
+            if (!internal_equal (v1, v2, depth + 1))
+              return 0;
+          }
+        return 1;
+      }
       break;
 
     case Lisp_String:
-      if (STRINGP (o1))
-        {
-          if (XSTRING (o1)->size != XSTRING (o2)->size)
-            return 0;
-          if (bcmp (XSTRING (o1)->data, XSTRING (o2)->data,
-                    XSTRING (o1)->size))
-            return 0;
+      if (XSTRING (o1)->size != XSTRING (o2)->size)
+        return 0;
+      if (bcmp (XSTRING (o1)->data, XSTRING (o2)->data,
+                XSTRING (o1)->size))
+        return 0;
 #ifdef USE_TEXT_PROPERTIES
-          /* If the strings have intervals, verify they match;
-             if not, they are unequal.  */
-          if ((XSTRING (o1)->intervals != 0 || XSTRING (o2)->intervals != 0)
-              && ! compare_string_intervals (o1, o2))
-            return 0;
+      /* If the strings have intervals, verify they match;
+         if not, they are unequal.  */
+      if ((XSTRING (o1)->intervals != 0 || XSTRING (o2)->intervals != 0)
+          && ! compare_string_intervals (o1, o2))
+        return 0;
 #endif
-          return 1;
-        }
+      return 1;
     }
   return 0;
 }