master 2cb7e86: Port recent character.h changes to --with-wide-int

[Paul Eggert]

branch: master
commit 2cb7e8669c3cdd0f7f0687e01810a3160d6b5c5b
Author: Paul Eggert <address@hidden>
Commit: Paul Eggert <address@hidden>

    Port recent character.h changes to --with-wide-int
    
    * src/fns.c (mapcar1):
    * src/keymap.c (Fkey_description):
    * src/syntax.c (scan_lists):
    Prefer ptrdiff_t to EMACS_INT where either will do; this fixes
    newly-introduced type errors on --with-wide-int platforms where
    ptrdiff_t is narrower than EMACS_INT.
    * src/keymap.c (Fkey_description): Rework for clarity; remove goto.
    * src/syntax.c (scan_words, Fforward_comment, scan_lists)):
    Fix unlikely integer overflow problems that can occur on
    --with-wide-int platforms, and that were caught by the recent
    character.h changes.
---
 src/fns.c    |  24 +++++-----
 src/keymap.c | 144 +++++++++++++++++++++++++++--------------------------------
 src/syntax.c |  13 +++---
 3 files changed, 82 insertions(+), 99 deletions(-)

diff --git a/src/fns.c b/src/fns.c
index cefdf38..ec0004d 100644
--- a/src/fns.c
+++ b/src/fns.c
@@ -2600,49 +2600,45 @@ usage: (nconc &rest LISTS)  */)
 static EMACS_INT
 mapcar1 (EMACS_INT leni, Lisp_Object *vals, Lisp_Object fn, Lisp_Object seq)
 {
-  Lisp_Object tail, dummy;
-  EMACS_INT i;
-
   if (VECTORP (seq) || COMPILEDP (seq))
     {
-      for (i = 0; i < leni; i++)
+      for (ptrdiff_t i = 0; i < leni; i++)
        {
-         dummy = call1 (fn, AREF (seq, i));
+         Lisp_Object dummy = call1 (fn, AREF (seq, i));
          if (vals)
            vals[i] = dummy;
        }
     }
   else if (BOOL_VECTOR_P (seq))
     {
-      for (i = 0; i < leni; i++)
+      for (EMACS_INT i = 0; i < leni; i++)
        {
-         dummy = call1 (fn, bool_vector_ref (seq, i));
+         Lisp_Object dummy = call1 (fn, bool_vector_ref (seq, i));
          if (vals)
            vals[i] = dummy;
        }
     }
   else if (STRINGP (seq))
     {
-      ptrdiff_t i_byte;
+      ptrdiff_t i_byte = 0;
 
-      for (i = 0, i_byte = 0; i < leni;)
+      for (ptrdiff_t i = 0; i < leni;)
        {
          ptrdiff_t i_before = i;
          int c = fetch_string_char_advance (seq, &i, &i_byte);
-         XSETFASTINT (dummy, c);
-         dummy = call1 (fn, dummy);
+         Lisp_Object dummy = call1 (fn, make_fixnum (c));
          if (vals)
            vals[i_before] = dummy;
        }
     }
   else   /* Must be a list, since Flength did not get an error */
     {
-      tail = seq;
-      for (i = 0; i < leni; i++)
+      Lisp_Object tail = seq;
+      for (ptrdiff_t i = 0; i < leni; i++)
        {
          if (! CONSP (tail))
            return i;
-         dummy = call1 (fn, XCAR (tail));
+         Lisp_Object dummy = call1 (fn, XCAR (tail));
          if (vals)
            vals[i] = dummy;
          tail = XCDR (tail);
diff --git a/src/keymap.c b/src/keymap.c
index 8a6881a..51433e2 100644
--- a/src/keymap.c
+++ b/src/keymap.c
@@ -2005,23 +2005,16 @@ For an approximate inverse of this, see `kbd'.  */)
   (Lisp_Object keys, Lisp_Object prefix)
 {
   ptrdiff_t len = 0;
-  EMACS_INT i;
-  ptrdiff_t i_byte;
   Lisp_Object *args;
-  EMACS_INT size = XFIXNUM (Flength (keys));
-  Lisp_Object list;
+  EMACS_INT nkeys = XFIXNUM (Flength (keys));
+  EMACS_INT nprefix = XFIXNUM (Flength (prefix));
   Lisp_Object sep = build_string (" ");
-  Lisp_Object key;
-  Lisp_Object result;
-  bool add_meta = 0;
+  bool add_meta = false;
   USE_SAFE_ALLOCA;
 
-  if (!NILP (prefix))
-    size += XFIXNUM (Flength (prefix));
-
   /* This has one extra element at the end that we don't pass to Fconcat.  */
-  EMACS_INT size4;
-  if (INT_MULTIPLY_WRAPV (size, 4, &size4))
+  ptrdiff_t size4;
+  if (INT_MULTIPLY_WRAPV (nkeys + nprefix, 4, &size4))
     memory_full (SIZE_MAX);
   SAFE_ALLOCA_LISP (args, size4);
 
@@ -2029,81 +2022,76 @@ For an approximate inverse of this, see `kbd'.  */)
      (mapconcat 'single-key-description keys " ")
      but we shouldn't use mapconcat because it can do GC.  */
 
- next_list:
-  if (!NILP (prefix))
-    list = prefix, prefix = Qnil;
-  else if (!NILP (keys))
-    list = keys, keys = Qnil;
-  else
+  Lisp_Object lists[2] = { prefix, keys };
+  ptrdiff_t listlens[2] = { nprefix, nkeys };
+  for (int li = 0; li < ARRAYELTS (lists); li++)
     {
-      if (add_meta)
-       {
-         args[len] = Fsingle_key_description (meta_prefix_char, Qnil);
-         result = Fconcat (len + 1, args);
-       }
-      else if (len == 0)
-       result = empty_unibyte_string;
-      else
-       result = Fconcat (len - 1, args);
-      SAFE_FREE ();
-      return result;
-    }
-
-  if (STRINGP (list))
-    size = SCHARS (list);
-  else if (VECTORP (list))
-    size = ASIZE (list);
-  else if (CONSP (list))
-    size = list_length (list);
-  else
-    wrong_type_argument (Qarrayp, list);
-
-  i = i_byte = 0;
+      Lisp_Object list = lists[li];
+      ptrdiff_t listlen = listlens[li], i_byte = 0;
 
-  while (i < size)
-    {
-      if (STRINGP (list))
-       {
-         int c = fetch_string_char_advance (list, &i, &i_byte);
-         if (SINGLE_BYTE_CHAR_P (c) && (c & 0200))
-           c ^= 0200 | meta_modifier;
-         XSETFASTINT (key, c);
-       }
-      else if (VECTORP (list))
-       {
-         key = AREF (list, i); i++;
-       }
-      else
-       {
-         key = XCAR (list);
-         list = XCDR (list);
-         i++;
-       }
+      if (! (NILP (list) || STRINGP (list) || VECTORP (list) || CONSP (list)))
+       wrong_type_argument (Qarrayp, list);
 
-      if (add_meta)
+      for (ptrdiff_t i = 0; i < listlen; )
        {
-         if (!FIXNUMP (key)
-             || EQ (key, meta_prefix_char)
-             || (XFIXNUM (key) & meta_modifier))
+         Lisp_Object key;
+         if (STRINGP (list))
            {
-             args[len++] = Fsingle_key_description (meta_prefix_char, Qnil);
-             args[len++] = sep;
-             if (EQ (key, meta_prefix_char))
-               continue;
+             int c = fetch_string_char_advance (list, &i, &i_byte);
+             if (SINGLE_BYTE_CHAR_P (c) && (c & 0200))
+               c ^= 0200 | meta_modifier;
+             key = make_fixnum (c);
+           }
+         else if (VECTORP (list))
+           {
+             key = AREF (list, i);
+             i++;
            }
          else
-           XSETINT (key, XFIXNUM (key) | meta_modifier);
-         add_meta = 0;
-       }
-      else if (EQ (key, meta_prefix_char))
-       {
-         add_meta = 1;
-         continue;
+           {
+             key = XCAR (list);
+             list = XCDR (list);
+             i++;
+           }
+
+         if (add_meta)
+           {
+             if (!FIXNUMP (key)
+                 || EQ (key, meta_prefix_char)
+                 || (XFIXNUM (key) & meta_modifier))
+               {
+                 args[len++] = Fsingle_key_description (meta_prefix_char,
+                                                        Qnil);
+                 args[len++] = sep;
+                 if (EQ (key, meta_prefix_char))
+                   continue;
+               }
+             else
+               key = make_fixnum (XFIXNUM (key) | meta_modifier);
+             add_meta = false;
+           }
+         else if (EQ (key, meta_prefix_char))
+           {
+             add_meta = true;
+             continue;
+           }
+         args[len++] = Fsingle_key_description (key, Qnil);
+         args[len++] = sep;
        }
-      args[len++] = Fsingle_key_description (key, Qnil);
-      args[len++] = sep;
     }
-  goto next_list;
+
+  Lisp_Object result;
+  if (add_meta)
+    {
+      args[len] = Fsingle_key_description (meta_prefix_char, Qnil);
+      result = Fconcat (len + 1, args);
+    }
+  else if (len == 0)
+    result = empty_unibyte_string;
+  else
+    result = Fconcat (len - 1, args);
+  SAFE_FREE ();
+  return result;
 }
 
 
diff --git a/src/syntax.c b/src/syntax.c
index bcf4dc0..c765cc9 100644
--- a/src/syntax.c
+++ b/src/syntax.c
@@ -1441,7 +1441,7 @@ scan_words (ptrdiff_t from, EMACS_INT count)
   int ch0, ch1;
   Lisp_Object func, pos;
 
-  SETUP_SYNTAX_TABLE (from, count);
+  SETUP_SYNTAX_TABLE (from, clip_to_bounds (PTRDIFF_MIN, count, PTRDIFF_MAX));
 
   while (count > 0)
     {
@@ -2434,7 +2434,7 @@ between them, return t; otherwise return nil.  */)
   from = PT;
   from_byte = PT_BYTE;
 
-  SETUP_SYNTAX_TABLE (from, count1);
+  SETUP_SYNTAX_TABLE (from, clip_to_bounds (PTRDIFF_MIN, count1, PTRDIFF_MAX));
   while (count1 > 0)
     {
       do
@@ -2624,7 +2624,7 @@ syntax_multibyte (int c, bool multibyte_symbol_p)
 }
 
 static Lisp_Object
-scan_lists (EMACS_INT from, EMACS_INT count, EMACS_INT depth, bool sexpflag)
+scan_lists (EMACS_INT from0, EMACS_INT count, EMACS_INT depth, bool sexpflag)
 {
   Lisp_Object val;
   ptrdiff_t stop = count > 0 ? ZV : BEGV;
@@ -2637,7 +2637,7 @@ scan_lists (EMACS_INT from, EMACS_INT count, EMACS_INT 
depth, bool sexpflag)
   int comstyle = 0;            /* Style of comment encountered.  */
   bool comnested = 0;          /* Whether the comment is nestable or not.  */
   ptrdiff_t temp_pos;
-  EMACS_INT last_good = from;
+  EMACS_INT last_good = from0;
   bool found;
   ptrdiff_t from_byte;
   ptrdiff_t out_bytepos, out_charpos;
@@ -2648,14 +2648,13 @@ scan_lists (EMACS_INT from, EMACS_INT count, EMACS_INT 
depth, bool sexpflag)
 
   if (depth > 0) min_depth = 0;
 
-  if (from > ZV) from = ZV;
-  if (from < BEGV) from = BEGV;
+  ptrdiff_t from = clip_to_bounds (BEGV, from0, ZV);
 
   from_byte = CHAR_TO_BYTE (from);
 
   maybe_quit ();
 
-  SETUP_SYNTAX_TABLE (from, count);
+  SETUP_SYNTAX_TABLE (from, clip_to_bounds (PTRDIFF_MIN, count, PTRDIFF_MAX));
   while (count > 0)
     {
       while (from < stop)