Merge branch 'master' into feature/byte-switch

10 files changed, 272 insertions, 269 deletions

diff --git a/src/composite.c b/src/composite.c
index f23bb17c57a..b673c53ac83 100644
--- a/src/composite.c
+++ b/src/composite.c
@@ -1012,7 +1012,7 @@ composition_compute_stop_pos (struct composition_it *cmp_it, ptrdiff_t charpos,
           val = CHAR_TABLE_REF (Vcomposition_function_table, c);
           if (! NILP (val))
             {
-              for (int ridx = 0; CONSP (val); val = XCDR (val), ridx++)
+              for (EMACS_INT ridx = 0; CONSP (val); val = XCDR (val), ridx++)
                 {
                   Lisp_Object elt = XCAR (val);
                   if (VECTORP (elt) && ASIZE (elt) == 3
@@ -1063,54 +1063,48 @@ composition_compute_stop_pos (struct composition_it *cmp_it, ptrdiff_t charpos,
       while (char_composable_p (c))
         {
           val = CHAR_TABLE_REF (Vcomposition_function_table, c);
-          if (! NILP (val))
+          for (EMACS_INT ridx = 0; CONSP (val); val = XCDR (val), ridx++)
             {
-              Lisp_Object elt;
-              int ridx, blen;
-
-              for (ridx = 0; CONSP (val); val = XCDR (val), ridx++)
+              Lisp_Object elt = XCAR (val);
+              if (VECTORP (elt) && ASIZE (elt) == 3
+                  && NATNUMP (AREF (elt, 1))
+                  && charpos - XFASTINT (AREF (elt, 1)) > endpos)
                 {
-                  elt = XCAR (val);
-                  if (VECTORP (elt) && ASIZE (elt) == 3
-                      && NATNUMP (AREF (elt, 1))
-                      && charpos - XFASTINT (AREF (elt, 1)) > endpos)
-                    {
-                      ptrdiff_t back = XFASTINT (AREF (elt, 1));
-                      ptrdiff_t cpos = charpos - back, bpos;
+                  ptrdiff_t back = XFASTINT (AREF (elt, 1));
+                  ptrdiff_t cpos = charpos - back, bpos;
 
-                      if (back == 0)
-                        bpos = bytepos;
-                      else
-                        bpos = (NILP (string) ? CHAR_TO_BYTE (cpos)
-                                : string_char_to_byte (string, cpos));
-                      if (STRINGP (AREF (elt, 0)))
-                        blen = fast_looking_at (AREF (elt, 0), cpos, bpos,
-                                                start + 1, limit, string);
-                      else
-                        blen = 1;
-                      if (blen > 0)
+                  if (back == 0)
+                    bpos = bytepos;
+                  else
+                    bpos = (NILP (string) ? CHAR_TO_BYTE (cpos)
+                            : string_char_to_byte (string, cpos));
+                  ptrdiff_t blen
+                    = (STRINGP (AREF (elt, 0))
+                       ? fast_looking_at (AREF (elt, 0), cpos, bpos,
+                                          start + 1, limit, string)
+                       : 1);
+                  if (blen > 0)
+                    {
+                      /* Make CPOS point to the last character of
+                         match.  Note that BLEN is byte-length.  */
+                      if (blen > 1)
+                        {
+                          bpos += blen;
+                          if (NILP (string))
+                            cpos = BYTE_TO_CHAR (bpos) - 1;
+                          else
+                            cpos = string_byte_to_char (string, bpos) - 1;
+                        }
+                      back = cpos - (charpos - back);
+                      if (cmp_it->stop_pos < cpos
+                          || (cmp_it->stop_pos == cpos
+                              && cmp_it->lookback < back))
                         {
-                          /* Make CPOS point to the last character of
-                             match.  Note that BLEN is byte-length.  */
-                          if (blen > 1)
-                            {
-                              bpos += blen;
-                              if (NILP (string))
-                                cpos = BYTE_TO_CHAR (bpos) - 1;
-                              else
-                                cpos = string_byte_to_char (string, bpos) - 1;
-                            }
-                          back = cpos - (charpos - back);
-                          if (cmp_it->stop_pos < cpos
-                              || (cmp_it->stop_pos == cpos
-                                  && cmp_it->lookback < back))
-                            {
-                              cmp_it->rule_idx = ridx;
-                              cmp_it->stop_pos = cpos;
-                              cmp_it->ch = c;
-                              cmp_it->lookback = back;
-                              cmp_it->nchars = back + 1;
-                            }
+                          cmp_it->rule_idx = ridx;
+                          cmp_it->stop_pos = cpos;
+                          cmp_it->ch = c;
+                          cmp_it->lookback = back;
+                          cmp_it->nchars = back + 1;
                         }
                     }
                 }
@@ -1203,10 +1197,10 @@ composition_reseat_it (struct composition_it *cmp_it, ptrdiff_t charpos,
     {
       Lisp_Object lgstring = Qnil;
       Lisp_Object val, elt;
-      ptrdiff_t i;
 
       val = CHAR_TABLE_REF (Vcomposition_function_table, cmp_it->ch);
-      for (i = 0; i < cmp_it->rule_idx; i++, val = XCDR (val));
+      for (EMACS_INT i = 0; i < cmp_it->rule_idx; i++, val = XCDR (val))
+        continue;
       if (charpos < endpos)
         {
           for (; CONSP (val); val = XCDR (val))
@@ -1255,6 +1249,7 @@ composition_reseat_it (struct composition_it *cmp_it, ptrdiff_t charpos,
       if (NILP (LGSTRING_ID (lgstring)))
         lgstring = composition_gstring_put_cache (lgstring, -1);
       cmp_it->id = XINT (LGSTRING_ID (lgstring));
+      int i;
       for (i = 0; i < LGSTRING_GLYPH_LEN (lgstring); i++)
         if (NILP (LGSTRING_GLYPH (lgstring, i)))
           break;
diff --git a/src/data.c b/src/data.c
index 8e07bf01b44..12dc2df0bac 100644
--- a/src/data.c
+++ b/src/data.c
@@ -170,6 +170,12 @@ args_out_of_range_3 (Lisp_Object a1, Lisp_Object a2, Lisp_Object a3)
   xsignal3 (Qargs_out_of_range, a1, a2, a3);
 }
 
+void
+circular_list (Lisp_Object list)
+{
+  xsignal1 (Qcircular_list, list);
+}
+
 
 /* Data type predicates.  */
 
diff --git a/src/dispextern.h b/src/dispextern.h
index eb71a82311c..e030618a9b7 100644
--- a/src/dispextern.h
+++ b/src/dispextern.h
@@ -2215,7 +2215,7 @@ struct composition_it
      the automatic composition.  Provided that ELT is an element of
      Vcomposition_function_table for CH, (nth ELT RULE_IDX) is the
      rule for the composition.  */
-  int rule_idx;
+  EMACS_INT rule_idx;
   /* If this is an automatic composition, how many characters to look
      back from the position where a character triggering the
      composition exists.  */
diff --git a/src/fns.c b/src/fns.c
index ac7c1f265a4..ffe3218ca7d 100644
--- a/src/fns.c
+++ b/src/fns.c
@@ -108,23 +108,12 @@ To get the number of bytes, use `string-bytes'.  */)
     XSETFASTINT (val, ASIZE (sequence) & PSEUDOVECTOR_SIZE_MASK);
   else if (CONSP (sequence))
     {
-      EMACS_INT i = 0;
-
-      do
-        {
-          ++i;
-          if ((i & (QUIT_COUNT_HEURISTIC - 1)) == 0)
-            {
-              if (MOST_POSITIVE_FIXNUM < i)
-                error ("List too long");
-              maybe_quit ();
-            }
-          sequence = XCDR (sequence);
-        }
-      while (CONSP (sequence));
-
+      intptr_t i = 0;
+      FOR_EACH_TAIL (sequence)
+        i++;
       CHECK_LIST_END (sequence, sequence);
-
+      if (MOST_POSITIVE_FIXNUM < i)
+        error ("List too long");
       val = make_number (i);
     }
   else if (NILP (sequence))
@@ -142,38 +131,10 @@ it returns 0.  If LIST is circular, it returns a finite value
 which is at least the number of distinct elements.  */)
   (Lisp_Object list)
 {
-  Lisp_Object tail, halftail;
-  double hilen = 0;
-  uintmax_t lolen = 1;
-
-  if (! CONSP (list))
-    return make_number (0);
-
-  /* halftail is used to detect circular lists.  */
-  for (tail = halftail = list; ; )
-    {
-      tail = XCDR (tail);
-      if (! CONSP (tail))
-        break;
-      if (EQ (tail, halftail))
-        break;
-      lolen++;
-      if ((lolen & 1) == 0)
-        {
-          halftail = XCDR (halftail);
-          if ((lolen & (QUIT_COUNT_HEURISTIC - 1)) == 0)
-            {
-              maybe_quit ();
-              if (lolen == 0)
-                hilen += UINTMAX_MAX + 1.0;
-            }
-        }
-    }
-
-  /* If the length does not fit into a fixnum, return a float.
-     On all known practical machines this returns an upper bound on
-     the true length.  */
-  return hilen ? make_float (hilen + lolen) : make_fixnum_or_float (lolen);
+  intptr_t len = 0;
+  FOR_EACH_TAIL_SAFE (list)
+    len++;
+  return make_fixnum_or_float (len);
 }
 
 DEFUN ("string-bytes", Fstring_bytes, Sstring_bytes, 1, 1, 0,
@@ -1383,14 +1344,10 @@ DEFUN ("member", Fmember, Smember, 2, 2, 0,
 The value is actually the tail of LIST whose car is ELT.  */)
   (Lisp_Object elt, Lisp_Object list)
 {
-  unsigned short int quit_count = 0;
-  Lisp_Object tail;
-  for (tail = list; CONSP (tail); tail = XCDR (tail))
-    {
-      if (! NILP (Fequal (elt, XCAR (tail))))
-        return tail;
-      rarely_quit (++quit_count);
-    }
+  Lisp_Object tail = list;
+  FOR_EACH_TAIL (tail)
+    if (! NILP (Fequal (elt, XCAR (tail))))
+      return tail;
   CHECK_LIST_END (tail, list);
   return Qnil;
 }
@@ -1400,14 +1357,10 @@ DEFUN ("memq", Fmemq, Smemq, 2, 2, 0,
 The value is actually the tail of LIST whose car is ELT.  */)
   (Lisp_Object elt, Lisp_Object list)
 {
-  unsigned short int quit_count = 0;
-  Lisp_Object tail;
-  for (tail = list; CONSP (tail); tail = XCDR (tail))
-    {
-      if (EQ (XCAR (tail), elt))
-        return tail;
-      rarely_quit (++quit_count);
-    }
+  Lisp_Object tail = list;
+  FOR_EACH_TAIL (tail)
+    if (EQ (XCAR (tail), elt))
+      return tail;
   CHECK_LIST_END (tail, list);
   return Qnil;
 }
@@ -1420,14 +1373,12 @@ The value is actually the tail of LIST whose car is ELT.  */)
   if (!FLOATP (elt))
     return Fmemq (elt, list);
 
-  unsigned short int quit_count = 0;
-  Lisp_Object tail;
-  for (tail = list; CONSP (tail); tail = XCDR (tail))
+  Lisp_Object tail = list;
+  FOR_EACH_TAIL (tail)
     {
       Lisp_Object tem = XCAR (tail);
       if (FLOATP (tem) && internal_equal (elt, tem, 0, 0, Qnil))
         return tail;
-      rarely_quit (++quit_count);
     }
   CHECK_LIST_END (tail, list);
   return Qnil;
@@ -1439,14 +1390,10 @@ The value is actually the first element of LIST whose car is KEY.
 Elements of LIST that are not conses are ignored.  */)
   (Lisp_Object key, Lisp_Object list)
 {
-  unsigned short int quit_count = 0;
-  Lisp_Object tail;
-  for (tail = list; CONSP (tail); tail = XCDR (tail))
-    {
-      if (CONSP (XCAR (tail)) && EQ (XCAR (XCAR (tail)), key))
-        return XCAR (tail);
-      rarely_quit (++quit_count);
-    }
+  Lisp_Object tail = list;
+  FOR_EACH_TAIL (tail)
+    if (CONSP (XCAR (tail)) && EQ (XCAR (XCAR (tail)), key))
+      return XCAR (tail);
   CHECK_LIST_END (tail, list);
   return Qnil;
 }
@@ -1468,15 +1415,13 @@ DEFUN ("assoc", Fassoc, Sassoc, 2, 2, 0,
 The value is actually the first element of LIST whose car equals KEY.  */)
   (Lisp_Object key, Lisp_Object list)
 {
-  unsigned short int quit_count = 0;
-  Lisp_Object tail;
-  for (tail = list; CONSP (tail); tail = XCDR (tail))
+  Lisp_Object tail = list;
+  FOR_EACH_TAIL (tail)
     {
       Lisp_Object car = XCAR (tail);
       if (CONSP (car)
           && (EQ (XCAR (car), key) || !NILP (Fequal (XCAR (car), key))))
         return car;
-      rarely_quit (++quit_count);
     }
   CHECK_LIST_END (tail, list);
   return Qnil;
@@ -1503,14 +1448,10 @@ DEFUN ("rassq", Frassq, Srassq, 2, 2, 0,
 The value is actually the first element of LIST whose cdr is KEY.  */)
   (Lisp_Object key, Lisp_Object list)
 {
-  unsigned short int quit_count = 0;
-  Lisp_Object tail;
-  for (tail = list; CONSP (tail); tail = XCDR (tail))
-    {
-      if (CONSP (XCAR (tail)) && EQ (XCDR (XCAR (tail)), key))
-        return XCAR (tail);
-      rarely_quit (++quit_count);
-    }
+  Lisp_Object tail = list;
+  FOR_EACH_TAIL (tail)
+    if (CONSP (XCAR (tail)) && EQ (XCDR (XCAR (tail)), key))
+      return XCAR (tail);
   CHECK_LIST_END (tail, list);
   return Qnil;
 }
@@ -1520,15 +1461,13 @@ DEFUN ("rassoc", Frassoc, Srassoc, 2, 2, 0,
 The value is actually the first element of LIST whose cdr equals KEY.  */)
   (Lisp_Object key, Lisp_Object list)
 {
-  unsigned short int quit_count = 0;
-  Lisp_Object tail;
-  for (tail = list; CONSP (tail); tail = XCDR (tail))
+  Lisp_Object tail = list;
+  FOR_EACH_TAIL (tail)
     {
       Lisp_Object car = XCAR (tail);
       if (CONSP (car)
           && (EQ (XCDR (car), key) || !NILP (Fequal (XCDR (car), key))))
         return car;
-      rarely_quit (++quit_count);
     }
   CHECK_LIST_END (tail, list);
   return Qnil;
@@ -1544,12 +1483,11 @@ list.
 Write `(setq foo (delq element foo))' to be sure of correctly changing
 the value of a list `foo'.  See also `remq', which does not modify the
 argument.  */)
-  (register Lisp_Object elt, Lisp_Object list)
+  (Lisp_Object elt, Lisp_Object list)
 {
-  Lisp_Object tail, tortoise, prev = Qnil;
-  bool skip;
+  Lisp_Object prev = Qnil, tail = list;
 
-  FOR_EACH_TAIL (tail, list, tortoise, skip)
+  FOR_EACH_TAIL (tail)
     {
       Lisp_Object tem = XCAR (tail);
       if (EQ (elt, tem))
@@ -1670,10 +1608,9 @@ changing the value of a sequence `foo'.  */)
     }
   else
     {
-      unsigned short int quit_count = 0;
-      Lisp_Object tail, prev;
+      Lisp_Object prev = Qnil, tail = seq;
 
-      for (tail = seq, prev = Qnil; CONSP (tail); tail = XCDR (tail))
+      FOR_EACH_TAIL (tail)
         {
           if (!NILP (Fequal (elt, XCAR (tail))))
             {
@@ -1684,7 +1621,6 @@ changing the value of a sequence `foo'.  */)
             }
           else
             prev = tail;
-          rarely_quit (++quit_count);
         }
       CHECK_LIST_END (tail, seq);
     }
@@ -1704,15 +1640,17 @@ This function may destructively modify SEQ to produce the value.  */)
     return Freverse (seq);
   else if (CONSP (seq))
     {
-      unsigned short int quit_count = 0;
       Lisp_Object prev, tail, next;
 
       for (prev = Qnil, tail = seq; CONSP (tail); tail = next)
         {
           next = XCDR (tail);
+          /* If SEQ contains a cycle, attempting to reverse it
+             in-place will inevitably come back to SEQ.  */
+          if (EQ (next, seq))
+            circular_list (seq);
           Fsetcdr (tail, prev);
           prev = tail;
-          rarely_quit (++quit_count);
         }
       CHECK_LIST_END (tail, seq);
       seq = prev;
@@ -1755,12 +1693,9 @@ See also the function `nreverse', which is used more often.  */)
     return Qnil;
   else if (CONSP (seq))
     {
-      unsigned short int quit_count = 0;
-      for (new = Qnil; CONSP (seq); seq = XCDR (seq))
-        {
-          new = Fcons (XCAR (seq), new);
-          rarely_quit (++quit_count);
-        }
+      new = Qnil;
+      FOR_EACH_TAIL (seq)
+        new = Fcons (XCAR (seq), new);
       CHECK_LIST_END (seq, seq);
     }
   else if (VECTORP (seq))
@@ -2013,18 +1948,15 @@ corresponding to the given PROP, or nil if PROP is not one of the
 properties on the list.  This function never signals an error.  */)
   (Lisp_Object plist, Lisp_Object prop)
 {
-  Lisp_Object tail, halftail;
-
-  /* halftail is used to detect circular lists.  */
-  tail = halftail = plist;
-  while (CONSP (tail) && CONSP (XCDR (tail)))
+  Lisp_Object tail = plist;
+  FOR_EACH_TAIL_SAFE (tail)
     {
+      if (! CONSP (XCDR (tail)))
+        break;
       if (EQ (prop, XCAR (tail)))
         return XCAR (XCDR (tail));
-
-      tail = XCDR (XCDR (tail));
-      halftail = XCDR (halftail);
-      if (EQ (tail, halftail))
+      tail = XCDR (tail);
+      if (EQ (tail, li.tortoise))
         break;
     }
 
@@ -2050,11 +1982,12 @@ use `(setq x (plist-put x prop val))' to be sure to use the new value.
 The PLIST is modified by side effects.  */)
   (Lisp_Object plist, Lisp_Object prop, Lisp_Object val)
 {
-  unsigned short int quit_count = 0;
-  Lisp_Object prev = Qnil;
-  for (Lisp_Object tail = plist; CONSP (tail) && CONSP (XCDR (tail));
-       tail = XCDR (XCDR (tail)))
+  Lisp_Object prev = Qnil, tail = plist;
+  FOR_EACH_TAIL (tail)
     {
+      if (! CONSP (XCDR (tail)))
+        break;
+
       if (EQ (prop, XCAR (tail)))
         {
           Fsetcar (XCDR (tail), val);
@@ -2062,8 +1995,11 @@ The PLIST is modified by side effects.  */)
         }
 
       prev = tail;
-      rarely_quit (++quit_count);
+      tail = XCDR (tail);
+      if (EQ (tail, li.tortoise))
+        circular_list (plist);
     }
+  CHECK_LIST_END (tail, plist);
   Lisp_Object newcell
     = Fcons (prop, Fcons (val, NILP (prev) ? plist : XCDR (XCDR (prev))));
   if (NILP (prev))
@@ -2091,19 +2027,19 @@ corresponding to the given PROP, or nil if PROP is not
 one of the properties on the list.  */)
   (Lisp_Object plist, Lisp_Object prop)
 {
-  unsigned short int quit_count = 0;
-  Lisp_Object tail;
-
-  for (tail = plist;
-       CONSP (tail) && CONSP (XCDR (tail));
-       tail = XCDR (XCDR (tail)))
+  Lisp_Object tail = plist;
+  FOR_EACH_TAIL (tail)
     {
+      if (! CONSP (XCDR (tail)))
+        break;
       if (! NILP (Fequal (prop, XCAR (tail))))
         return XCAR (XCDR (tail));
-      rarely_quit (++quit_count);
+      tail = XCDR (tail);
+      if (EQ (tail, li.tortoise))
+        circular_list (plist);
     }
 
-  CHECK_LIST_END (tail, prop);
+  CHECK_LIST_END (tail, plist);
 
   return Qnil;
 }
@@ -2118,11 +2054,12 @@ use `(setq x (lax-plist-put x prop val))' to be sure to use the new value.
 The PLIST is modified by side effects.  */)
   (Lisp_Object plist, Lisp_Object prop, Lisp_Object val)
 {
-  unsigned short int quit_count = 0;
-  Lisp_Object prev = Qnil;
-  for (Lisp_Object tail = plist; CONSP (tail) && CONSP (XCDR (tail));
-       tail = XCDR (XCDR (tail)))
+  Lisp_Object prev = Qnil, tail = plist;
+  FOR_EACH_TAIL (tail)
     {
+      if (! CONSP (XCDR (tail)))
+        break;
+
       if (! NILP (Fequal (prop, XCAR (tail))))
         {
           Fsetcar (XCDR (tail), val);
@@ -2130,8 +2067,11 @@ The PLIST is modified by side effects.  */)
         }
 
       prev = tail;
-      rarely_quit (++quit_count);
+      tail = XCDR (tail);
+      if (EQ (tail, li.tortoise))
+        circular_list (plist);
     }
+  CHECK_LIST_END (tail, plist);
   Lisp_Object newcell = list2 (prop, val);
   if (NILP (prev))
     return newcell;
@@ -2180,6 +2120,7 @@ static bool
 internal_equal (Lisp_Object o1, Lisp_Object o2, int depth, bool props,
                 Lisp_Object ht)
 {
+ tail_recurse:
   if (depth > 10)
     {
       if (depth > 200)
@@ -2208,9 +2149,6 @@ internal_equal (Lisp_Object o1, Lisp_Object o2, int depth, bool props,
         }
     }
 
-  unsigned short int quit_count = 0;
- tail_recurse:
-  rarely_quit (++quit_count);
   if (EQ (o1, o2))
     return 1;
   if (XTYPE (o1) != XTYPE (o2))
@@ -2230,12 +2168,20 @@ internal_equal (Lisp_Object o1, Lisp_Object o2, int depth, bool props,
       }
 
     case Lisp_Cons:
-      if (!internal_equal (XCAR (o1), XCAR (o2), depth + 1, props, ht))
-        return 0;
-      o1 = XCDR (o1);
-      o2 = XCDR (o2);
-      /* FIXME: This inf-loops in a circular list!  */
-      goto tail_recurse;
+      {
+        FOR_EACH_TAIL (o1)
+          {
+            if (! CONSP (o2))
+              return false;
+            if (! internal_equal (XCAR (o1), XCAR (o2), depth + 1, props, ht))
+              return false;
+            o2 = XCDR (o2);
+            if (EQ (XCDR (o1), o2))
+              return true;
+          }
+        depth++;
+        goto tail_recurse;
+      }
 
     case Lisp_Misc:
       if (XMISCTYPE (o1) != XMISCTYPE (o2))
@@ -2249,6 +2195,7 @@ internal_equal (Lisp_Object o1, Lisp_Object o2, int depth, bool props,
             return 0;
           o1 = XOVERLAY (o1)->plist;
           o2 = XOVERLAY (o2)->plist;
+          depth++;
           goto tail_recurse;
         }
       if (MARKERP (o1))
@@ -2399,7 +2346,6 @@ Only the last argument is not altered, and need not be a list.
 usage: (nconc &rest LISTS)  */)
   (ptrdiff_t nargs, Lisp_Object *args)
 {
-  unsigned short int quit_count = 0;
   Lisp_Object val = Qnil;
 
   for (ptrdiff_t argnum = 0; argnum < nargs; argnum++)
@@ -2415,13 +2361,8 @@ usage: (nconc &rest LISTS)  */)
       CHECK_CONS (tem);
 
       Lisp_Object tail;
-      do
-        {
-          tail = tem;
-          tem = XCDR (tail);
-          rarely_quit (++quit_count);
-        }
-      while (CONSP (tem));
+      FOR_EACH_TAIL (tem)
+        tail = tem;
 
       tem = args[argnum + 1];
       Fsetcdr (tail, tem);
@@ -2843,14 +2784,19 @@ property and a property with the value nil.
 The value is actually the tail of PLIST whose car is PROP.  */)
   (Lisp_Object plist, Lisp_Object prop)
 {
-  unsigned short int quit_count = 0;
-  while (CONSP (plist) && !EQ (XCAR (plist), prop))
+  Lisp_Object tail = plist;
+  FOR_EACH_TAIL (tail)
     {
-      plist = XCDR (plist);
-      plist = CDR (plist);
-      rarely_quit (++quit_count);
+      if (EQ (XCAR (tail), prop))
+        return tail;
+      tail = XCDR (tail);
+      if (! CONSP (tail))
+        break;
+      if (EQ (tail, li.tortoise))
+        circular_list (tail);
     }
-  return plist;
+  CHECK_LIST_END (tail, plist);
+  return Qnil;
 }
 
 DEFUN ("widget-put", Fwidget_put, Swidget_put, 3, 3, 0,
diff --git a/src/image.c b/src/image.c
index ad0143be48b..1e8ebfd40d5 100644
--- a/src/image.c
+++ b/src/image.c
@@ -3110,8 +3110,8 @@ xbm_load (struct frame *f, struct image *img)
             int nbytes, i;
             /* Windows mono bitmaps are reversed compared with X.  */
             invertedBits = bits;
-            nbytes = (img->width + CHAR_BIT - 1) / CHAR_BIT;
-            SAFE_NALLOCA (bits, nbytes, img->height);
+            nbytes = (img->width + CHAR_BIT - 1) / CHAR_BIT * img->height;
+            SAFE_NALLOCA (bits, 1, nbytes);
             for (i = 0; i < nbytes; i++)
               bits[i] = XBM_BIT_SHUFFLE (invertedBits[i]);
           }
@@ -5465,7 +5465,17 @@ pbm_load (struct frame *f, struct image *img)
                 c <<= 1;
               }
             else
-              g = pbm_scan_number (&p, end);
+              {
+                int c = 0;
+                /* Skip white-space and comments.  */
+                while ((c = pbm_next_char (&p, end)) != -1 && c_isspace (c))
+                  ;
+
+                if (c == '0' || c == '1')
+                  g = c - '0';
+                else
+                  g = 0;
+              }
 
 #ifdef USE_CAIRO
             *dataptr++ = g ? fga32 : bga32;
diff --git a/src/keyboard.c b/src/keyboard.c
index a86e7c5f8e4..ed8e71fd0a7 100644
--- a/src/keyboard.c
+++ b/src/keyboard.c
@@ -10001,6 +10001,30 @@ See also `this-command-keys-vector'.  */)
                            XVECTOR (this_command_keys)->contents);
 }
 
+DEFUN ("set--this-command-keys", Fset__this_command_keys,
+       Sset__this_command_keys, 1, 1, 0,
+       doc: /* Set the vector to be returned by `this-command-keys'.
+The argument KEYS must be a string.
+Internal use only.  */)
+  (Lisp_Object keys)
+{
+  CHECK_STRING (keys);
+
+  this_command_key_count = 0;
+  this_single_command_key_start = 0;
+  int key0 = SREF (keys, 0);
+
+  /* Kludge alert: this makes M-x be in the form expected by
+     novice.el.  Any better ideas?  */
+  if (key0 == 248)
+    add_command_key (make_number ('x' | meta_modifier));
+  else
+    add_command_key (make_number (key0));
+  for (ptrdiff_t i = 1; i < SCHARS (keys); i++)
+    add_command_key (make_number (SREF (keys, i)));
+  return Qnil;
+}
+
 DEFUN ("this-command-keys-vector", Fthis_command_keys_vector, Sthis_command_keys_vector, 0, 0, 0,
        doc: /* Return the key sequence that invoked this command, as a vector.
 However, if the command has called `read-key-sequence', it returns
@@ -11211,6 +11235,7 @@ syms_of_keyboard (void)
   defsubr (&Sthis_command_keys_vector);
   defsubr (&Sthis_single_command_keys);
   defsubr (&Sthis_single_command_raw_keys);
+  defsubr (&Sset__this_command_keys);
   defsubr (&Sclear_this_command_keys);
   defsubr (&Ssuspend_emacs);
   defsubr (&Sabort_recursive_edit);
diff --git a/src/lisp.h b/src/lisp.h
index a9011b4a8be..f1e2685702d 100644
--- a/src/lisp.h
+++ b/src/lisp.h
@@ -3129,20 +3129,14 @@ extern void maybe_quit (void);
 
 #define QUITP (!NILP (Vquit_flag) && NILP (Vinhibit_quit))
 
-/* Heuristic on how many iterations of a tight loop can be safely done
-   before it's time to do a quit.  This must be a power of 2.  It
-   is nice but not necessary for it to equal USHRT_MAX + 1.  */
-
-enum { QUIT_COUNT_HEURISTIC = 1 << 16 };
-
 /* Process a quit rarely, based on a counter COUNT, for efficiency.
-   "Rarely" means once per QUIT_COUNT_HEURISTIC or per USHRT_MAX + 1
-   times, whichever is smaller (somewhat arbitrary, but often faster).  */
+   "Rarely" means once per USHRT_MAX + 1 times; this is somewhat
+   arbitrary, but efficient.  */
 
 INLINE void
 rarely_quit (unsigned short int count)
 {
-  if (! (count & (QUIT_COUNT_HEURISTIC - 1)))
+  if (! count)
     maybe_quit ();
 }
 
@@ -3317,6 +3311,7 @@ extern struct Lisp_Symbol *indirect_variable (struct Lisp_Symbol *);
 extern _Noreturn void args_out_of_range (Lisp_Object, Lisp_Object);
 extern _Noreturn void args_out_of_range_3 (Lisp_Object, Lisp_Object,
                                            Lisp_Object);
+extern _Noreturn void circular_list (Lisp_Object);
 extern Lisp_Object do_symval_forwarding (union Lisp_Fwd *);
 enum Set_Internal_Bind {
   SET_INTERNAL_SET,
@@ -4585,20 +4580,54 @@ enum
          Lisp_String))                                                  \
      : make_unibyte_string (str, len))
 
-/* Loop over all tails of a list, checking for cycles.
-   FIXME: Make tortoise and n internal declarations.
-   FIXME: Unroll the loop body so we don't need `n'.  */
-#define FOR_EACH_TAIL(hare, list, tortoise, n)  \
-  for ((tortoise) = (hare) = (list), (n) = true;                \
-       CONSP (hare);                                            \
-       (hare = XCDR (hare), (n) = !(n),                         \
-        ((n)                                                    \
-         ? (EQ (hare, tortoise)                                 \
-            ? xsignal1 (Qcircular_list, list)                   \
-            : (void) 0)                                         \
-         /* Move tortoise before the next iteration, in case */ \
-         /* the next iteration does an Fsetcdr.  */             \
-         : (void) ((tortoise) = XCDR (tortoise)))))
+/* Loop over conses of the list TAIL, signaling if a cycle is found,
+   and possibly quitting after each loop iteration.  In the loop body,
+   set TAIL to the current cons.  If the loop exits normally,
+   set TAIL to the terminating non-cons, typically nil.  The loop body
+   should not modify the list’s top level structure other than by
+   perhaps deleting the current cons.  */
+
+#define FOR_EACH_TAIL(tail) \
+  FOR_EACH_TAIL_INTERNAL (tail, circular_list (tail), true)
+
+/* Like FOR_EACH_TAIL (LIST), except do not signal or quit.
+   If the loop exits due to a cycle, TAIL’s value is undefined.  */
+
+#define FOR_EACH_TAIL_SAFE(tail) \
+  FOR_EACH_TAIL_INTERNAL (tail, (void) ((tail) = Qnil), false)
+
+/* Iterator intended for use only within FOR_EACH_TAIL_INTERNAL.  */
+struct for_each_tail_internal
+{
+  Lisp_Object tortoise;
+  intptr_t max, n;
+  unsigned short int q;
+};
+
+/* Like FOR_EACH_TAIL (LIST), except evaluate CYCLE if a cycle is
+   found, and check for quit if CHECK_QUIT.  This is an internal macro
+   intended for use only by the above macros.
+
+   Use Brent’s teleporting tortoise-hare algorithm.  See:
+   Brent RP. BIT. 1980;20(2):176-84. doi:10.1007/BF01933190
+   http://maths-people.anu.edu.au/~brent/pd/rpb051i.pdf
+
+   This macro uses maybe_quit because of an excess of caution.  The
+   call to maybe_quit should not be needed in practice, as a very long
+   list, whether circular or not, will cause Emacs to be so slow in
+   other noninterruptible areas (e.g., garbage collection) that there
+   is little point to calling maybe_quit here.  */
+
+#define FOR_EACH_TAIL_INTERNAL(tail, cycle, check_quit)                 \
+  for (struct for_each_tail_internal li = { tail, 2, 0, 2 };            \
+       CONSP (tail);                                                    \
+       ((tail) = XCDR (tail),                                           \
+        ((--li.q != 0                                                   \
+          || ((check_quit) ? maybe_quit () : (void) 0, 0 < --li.n)      \
+          || (li.q = li.n = li.max <<= 1, li.n >>= USHRT_WIDTH,         \
+              li.tortoise = (tail), false))                             \
+         && EQ (tail, li.tortoise))                                     \
+        ? (cycle) : (void) 0))
 
 /* Do a `for' loop over alist values.  */
 
diff --git a/src/xdisp.c b/src/xdisp.c
index 0e329dfe6e9..e59934d2d5a 100644
--- a/src/xdisp.c
+++ b/src/xdisp.c
@@ -18972,7 +18972,7 @@ dump_glyph (struct glyph_row *row, struct glyph *glyph, int area)
                glyph->pixel_width,
                glyph->u.ch,
                (glyph->u.ch < 0x80 && glyph->u.ch >= ' '
-                ? glyph->u.ch
+                ? (int) glyph->u.ch
                 : '.'),
                glyph->face_id,
                glyph->left_box_line_p,
@@ -18993,7 +18993,7 @@ dump_glyph (struct glyph_row *row, struct glyph *glyph, int area)
                       ? '0'
                       : '-'))),
                glyph->pixel_width,
-               0,
+               0u,
                ' ',
                glyph->face_id,
                glyph->left_box_line_p,
@@ -19014,7 +19014,7 @@ dump_glyph (struct glyph_row *row, struct glyph *glyph, int area)
                       ? '0'
                       : '-'))),
                glyph->pixel_width,
-               glyph->u.img_id,
+               (unsigned int) glyph->u.img_id,
                '.',
                glyph->face_id,
                glyph->left_box_line_p,
@@ -19035,7 +19035,7 @@ dump_glyph (struct glyph_row *row, struct glyph *glyph, int area)
                       ? '0'
                       : '-'))),
                glyph->pixel_width,
-               glyph->u.cmp.id);
+               (unsigned int) glyph->u.cmp.id);
       if (glyph->u.cmp.automatic)
         fprintf (stderr,
                  "[%d-%d]",
@@ -20995,7 +20995,10 @@ display_line (struct it *it)
                          up to the right margin of the window.  */
                       extend_face_to_end_of_line (it);
                     }
-                  else if (it->c == '\t' && FRAME_WINDOW_P (it->f))
+                  else if ((it->what == IT_CHARACTER
+                            || it->what == IT_STRETCH
+                            || it->what == IT_COMPOSITION)
+                           && it->c == '\t' && FRAME_WINDOW_P (it->f))
                     {
                       /* A TAB that extends past the right edge of the
                          window.  This produces a single glyph on
@@ -23033,30 +23036,19 @@ display_mode_element (struct it *it, int depth, int field_width, int precision,
             goto tail_recurse;
           }
         else if (STRINGP (car) || CONSP (car))
-          {
-            Lisp_Object halftail = elt;
-            int len = 0;
-
-            while (CONSP (elt)
-                   && (precision <= 0 || n < precision))
-              {
-                n += display_mode_element (it, depth,
-                                           /* Do padding only after the last
-                                              element in the list.  */
-                                           (! CONSP (XCDR (elt))
-                                            ? field_width - n
-                                            : 0),
-                                           precision - n, XCAR (elt),
-                                           props, risky);
-                elt = XCDR (elt);
-                len++;
-                if ((len & 1) == 0)
-                  halftail = XCDR (halftail);
-                /* Check for cycle.  */
-                if (EQ (halftail, elt))
-                  break;
-              }
-          }
+          FOR_EACH_TAIL_SAFE (elt)
+            {
+              if (0 < precision && precision <= n)
+                break;
+              n += display_mode_element (it, depth,
+                                         /* Pad after only the last
+                                            list element.  */
+                                         (! CONSP (XCDR (elt))
+                                          ? field_width - n
+                                          : 0),
+                                         precision - n, XCAR (elt),
+                                         props, risky);
+            }
       }
       break;
 
@@ -24624,7 +24616,7 @@ dump_glyph_string (struct glyph_string *s)
   fprintf (stderr, "  x, y, w, h = %d, %d, %d, %d\n",
            s->x, s->y, s->width, s->height);
   fprintf (stderr, "  ybase = %d\n", s->ybase);
-  fprintf (stderr, "  hl = %d\n", s->hl);
+  fprintf (stderr, "  hl = %u\n", s->hl);
   fprintf (stderr, "  left overhang = %d, right = %d\n",
            s->left_overhang, s->right_overhang);
   fprintf (stderr, "  nchars = %d\n", s->nchars);
diff --git a/src/xfaces.c b/src/xfaces.c
index 830106d64c0..b5dbb53ca20 100644
--- a/src/xfaces.c
+++ b/src/xfaces.c
@@ -6251,7 +6251,7 @@ dump_realized_face (struct face *face)
   fprintf (stderr, "underline: %d (%s)\n",
            face->underline_p,
            SDATA (Fsymbol_name (face->lface[LFACE_UNDERLINE_INDEX])));
-  fprintf (stderr, "hash: %d\n", face->hash);
+  fprintf (stderr, "hash: %u\n", face->hash);
 }
 
 
diff --git a/src/xwidget.c b/src/xwidget.c
index 4ba1617d8df..5c276b1371c 100644
--- a/src/xwidget.c
+++ b/src/xwidget.c
@@ -301,13 +301,13 @@ webkit_js_to_lisp (JSContextRef context, JSValueRef value)
           {
             JSStringRef pname = JSStringCreateWithUTF8CString("length");
             JSValueRef len = JSObjectGetProperty (context, (JSObjectRef) value, pname, NULL);
-            int n = JSValueToNumber (context, len, NULL);
+            EMACS_INT n = JSValueToNumber (context, len, NULL);
             JSStringRelease(pname);
 
             Lisp_Object obj;
             struct Lisp_Vector *p = allocate_vector (n);
 
-            for (int i = 0; i < n; ++i)
+            for (ptrdiff_t i = 0; i < n; ++i)
               {
                 p->contents[i] =
                   webkit_js_to_lisp (context,
@@ -323,13 +323,13 @@ webkit_js_to_lisp (JSContextRef context, JSValueRef value)
             JSPropertyNameArrayRef properties =
               JSObjectCopyPropertyNames (context, (JSObjectRef) value);
 
-            int n = JSPropertyNameArrayGetCount (properties);
+            ptrdiff_t n = JSPropertyNameArrayGetCount (properties);
             Lisp_Object obj;
 
             /* TODO: can we use a regular list here?  */
             struct Lisp_Vector *p = allocate_vector (n);
 
-            for (int i = 0; i < n; ++i)
+            for (ptrdiff_t i = 0; i < n; ++i)
               {
                 JSStringRef name = JSPropertyNameArrayGetNameAtIndex (properties, i);
                 JSValueRef property = JSObjectGetProperty (context,
@@ -733,8 +733,8 @@ DEFUN ("xwidget-resize", Fxwidget_resize, Sxwidget_resize, 3, 3, 0,
   (Lisp_Object xwidget, Lisp_Object new_width, Lisp_Object new_height)
 {
   CHECK_XWIDGET (xwidget);
-  CHECK_NATNUM (new_width);
-  CHECK_NATNUM (new_height);
+  CHECK_RANGED_INTEGER (new_width, 0, INT_MAX);
+  CHECK_RANGED_INTEGER (new_height, 0, INT_MAX);
   struct xwidget *xw = XXWIDGET (xwidget);
   int w = XFASTINT (new_width);
   int h = XFASTINT (new_height);