master 23a3333: Give Lisp control on the lossage size

[Tino Calancha]

branch: master
commit 23a3333b3ef0768f48f64f382ee899050b6103be
Author: Tino Calancha <ccalancha@suse.com>
Commit: Tino Calancha <ccalancha@suse.com>

    Give Lisp control on the lossage size
    
    Add a command 'lossage-size' to set the maximum
    number or recorded keystrokes (Bug#38796).
    
    * src/keyboard.c (lossage_limit):
    Static variable with the current lossage size limit.
    (MIN_NUM_RECENT_KEYS): Renamed from NUM_RECENT_KEYS.
    Set it as 100 and use it as the minimum value for lossage_limit.
    Keep the same default for the vector size as before (300).
    (lossage-size): New command.
    (update_recent_keys): Helper function.
    (command_loop_1)
    (record_char)
    (recent-keys)
    (syms_of_keyboard): Use lossage_limit as the vector size.
    
    * lisp/help.el (view-lossage): Mention the new command in the docstring.
    * etc/NEWS (Changes in Emacs 28.1): Announce this change.
    * doc/emacs/help.texi (Misc Help): Update manual.
    * test/src/keyboard-tests.el (keyboard-lossage-size): Add test.
---
 doc/emacs/help.texi        |  7 +++-
 etc/NEWS                   |  4 ++
 lisp/help.el               |  1 +
 src/keyboard.c             | 93 ++++++++++++++++++++++++++++++++++++++--------
 test/src/keyboard-tests.el | 15 ++++++++
 5 files changed, 102 insertions(+), 18 deletions(-)

diff --git a/doc/emacs/help.texi b/doc/emacs/help.texi
index 06ad5a5..232b611 100644
--- a/doc/emacs/help.texi
+++ b/doc/emacs/help.texi
@@ -573,10 +573,13 @@ command works depend on the major mode.
 
 @kindex C-h l
 @findex view-lossage
+@findex lossage-size
   If something surprising happens, and you are not sure what you typed,
 use @kbd{C-h l} (@code{view-lossage}).  @kbd{C-h l} displays your last
-300 input keystrokes and the commands they invoked.  If you see
-commands that you are not familiar with, you can use @kbd{C-h k} or
+input keystrokes and the commands they invoked.  By default, Emacs
+stores the last 300 keystrokes; if you wish, you can change this number with
+the command @code{lossage-size}.
+If you see commands that you are not familiar with, you can use @kbd{C-h k} or
 @kbd{C-h f} to find out what they do.
 
 @kindex C-h e
diff --git a/etc/NEWS b/etc/NEWS
index e46b348..721da44 100644
--- a/etc/NEWS
+++ b/etc/NEWS
@@ -86,6 +86,10 @@ useful on systems such as FreeBSD which ships only with 
"etc/termcap".
 * Changes in Emacs 28.1
 
 +++
+** The new command 'lossage-size' allow users to set the maximum
+number of keystrokes and commands recorded.
+
++++
 *** Emacs now defaults to UTF-8 instead of ISO-8859-1.
 This is only for the default, where the user has set no 'LANG' (or
 similar) variable or environment.  This change should lead to no
diff --git a/lisp/help.el b/lisp/help.el
index 729684a..edef78d 100644
--- a/lisp/help.el
+++ b/lisp/help.el
@@ -458,6 +458,7 @@ the variable `message-log-max'."
   "Display last few input keystrokes and the commands run.
 For convenience this uses the same format as
 `edit-last-kbd-macro'.
+See `lossage-size' to update the number of recorded keystrokes.
 
 To record all your input, use `open-dribble-file'."
   (interactive)
diff --git a/src/keyboard.c b/src/keyboard.c
index 590d183..c0a41e6 100644
--- a/src/keyboard.c
+++ b/src/keyboard.c
@@ -103,7 +103,8 @@ static KBOARD *all_kboards;
 /* True in the single-kboard state, false in the any-kboard state.  */
 static bool single_kboard;
 
-#define NUM_RECENT_KEYS (300)
+/* Minimum allowed size of the recent_keys vector.  */
+#define MIN_NUM_RECENT_KEYS (100)
 
 /* Index for storing next element into recent_keys.  */
 static int recent_keys_index;
@@ -111,7 +112,10 @@ static int recent_keys_index;
 /* Total number of elements stored into recent_keys.  */
 static int total_keys;
 
-/* This vector holds the last NUM_RECENT_KEYS keystrokes.  */
+/* Size of the recent_keys vector.  */
+static int lossage_limit = 3 * MIN_NUM_RECENT_KEYS;
+
+/* This vector holds the last lossage_limit keystrokes.  */
 static Lisp_Object recent_keys;
 
 /* Vector holding the key sequence that invoked the current command.
@@ -1421,10 +1425,10 @@ command_loop_1 (void)
       /* Execute the command.  */
 
       {
-       total_keys += total_keys < NUM_RECENT_KEYS;
+       total_keys += total_keys < lossage_limit;
        ASET (recent_keys, recent_keys_index,
              Fcons (Qnil, cmd));
-       if (++recent_keys_index >= NUM_RECENT_KEYS)
+       if (++recent_keys_index >= lossage_limit)
          recent_keys_index = 0;
       }
       Vthis_command = cmd;
@@ -3248,15 +3252,15 @@ record_char (Lisp_Object c)
       int ix1, ix2, ix3;
 
       if ((ix1 = recent_keys_index - 1) < 0)
-       ix1 = NUM_RECENT_KEYS - 1;
+       ix1 = lossage_limit - 1;
       ev1 = AREF (recent_keys, ix1);
 
       if ((ix2 = ix1 - 1) < 0)
-       ix2 = NUM_RECENT_KEYS - 1;
+       ix2 = lossage_limit - 1;
       ev2 = AREF (recent_keys, ix2);
 
       if ((ix3 = ix2 - 1) < 0)
-       ix3 = NUM_RECENT_KEYS - 1;
+       ix3 = lossage_limit - 1;
       ev3 = AREF (recent_keys, ix3);
 
       if (EQ (XCAR (c), Qhelp_echo))
@@ -3307,12 +3311,12 @@ record_char (Lisp_Object c)
     {
       if (!recorded)
        {
-         total_keys += total_keys < NUM_RECENT_KEYS;
+         total_keys += total_keys < lossage_limit;
          ASET (recent_keys, recent_keys_index,
                 /* Copy the event, in case it gets modified by side-effect
                    by some remapping function (bug#30955).  */
                 CONSP (c) ? Fcopy_sequence (c) : c);
-         if (++recent_keys_index >= NUM_RECENT_KEYS)
+         if (++recent_keys_index >= lossage_limit)
            recent_keys_index = 0;
        }
       else if (recorded < 0)
@@ -3326,10 +3330,10 @@ record_char (Lisp_Object c)
 
          while (recorded++ < 0 && total_keys > 0)
            {
-             if (total_keys < NUM_RECENT_KEYS)
+             if (total_keys < lossage_limit)
                total_keys--;
              if (--recent_keys_index < 0)
-               recent_keys_index = NUM_RECENT_KEYS - 1;
+               recent_keys_index = lossage_limit - 1;
              ASET (recent_keys, recent_keys_index, Qnil);
            }
        }
@@ -10410,6 +10414,62 @@ If CHECK-TIMERS is non-nil, timers that are ready to 
run will do so.  */)
          ? Qt : Qnil);
 }
 
+/* Reallocate recent_keys copying the keystrokes in the right order */
+static void
+update_recent_keys (int new_size, int kept_keys)
+{
+  int osize = ASIZE (recent_keys);
+  eassert (recent_keys_index < osize);
+  eassert (kept_keys <= min (osize, new_size));
+  Lisp_Object v = make_nil_vector (new_size);
+  int i, idx;
+  for (i = 0; i < kept_keys; ++i)
+    {
+      idx = recent_keys_index - kept_keys + i;
+      while (idx < 0)
+        idx += osize;
+      ASET (v, i, AREF (recent_keys, idx));
+    }
+  recent_keys = v;
+  total_keys = kept_keys;
+  recent_keys_index = total_keys % new_size;
+  lossage_limit = new_size;
+
+}
+
+DEFUN ("lossage-size", Flossage_size, Slossage_size, 0, 1,
+       "(list (read-number \"new-size: \" (lossage-size)))",
+       doc: /* Return the maximum number of saved keystrokes.
+Called with ARG, then set this limit to ARG and return it.
+
+The saved keystrokes are the records shown by `view-lossage'.  */)
+  (Lisp_Object arg)
+{
+  if (NILP(arg))
+    return make_fixnum (lossage_limit);
+
+  if (!FIXNATP (arg))
+    user_error ("Value must be a positive integer");
+  int osize = ASIZE (recent_keys);
+  eassert (lossage_limit == osize);
+  int min_size = MIN_NUM_RECENT_KEYS;
+  int new_size = XFIXNAT (arg);
+
+  if (new_size == osize)
+    return make_fixnum (lossage_limit);
+
+  if (new_size < min_size)
+    {
+      AUTO_STRING (fmt, "Value must be >= %d");
+      Fsignal (Quser_error, list1 (CALLN (Fformat, fmt, make_fixnum 
(min_size))));
+    }
+
+  int kept_keys = new_size > osize ? total_keys : min (new_size, total_keys);
+  update_recent_keys (new_size, kept_keys);
+
+  return make_fixnum (lossage_limit);
+}
+
 DEFUN ("recent-keys", Frecent_keys, Srecent_keys, 0, 1, 0,
        doc: /* Return vector of last few events, not counting those from 
keyboard macros.
 If INCLUDE-CMDS is non-nil, include the commands that were run,
@@ -10419,21 +10479,21 @@ represented as pseudo-events of the form (nil . 
COMMAND).  */)
   bool cmds = !NILP (include_cmds);
 
   if (!total_keys
-      || (cmds && total_keys < NUM_RECENT_KEYS))
+      || (cmds && total_keys < lossage_limit))
     return Fvector (total_keys,
                    XVECTOR (recent_keys)->contents);
   else
     {
       Lisp_Object es = Qnil;
-      int i = (total_keys < NUM_RECENT_KEYS
+      int i = (total_keys < lossage_limit
               ? 0 : recent_keys_index);
-      eassert (recent_keys_index < NUM_RECENT_KEYS);
+      eassert (recent_keys_index < lossage_limit);
       do
        {
          Lisp_Object e = AREF (recent_keys, i);
          if (cmds || !CONSP (e) || !NILP (XCAR (e)))
            es = Fcons (e, es);
-         if (++i >= NUM_RECENT_KEYS)
+         if (++i >= lossage_limit)
            i = 0;
        } while (i != recent_keys_index);
       es = Fnreverse (es);
@@ -11686,7 +11746,7 @@ syms_of_keyboard (void)
     staticpro (&modifier_symbols);
   }
 
-  recent_keys = make_nil_vector (NUM_RECENT_KEYS);
+  recent_keys = make_nil_vector (lossage_limit);
   staticpro (&recent_keys);
 
   this_command_keys = make_nil_vector (40);
@@ -11736,6 +11796,7 @@ syms_of_keyboard (void)
   defsubr (&Srecursive_edit);
   defsubr (&Sinternal_track_mouse);
   defsubr (&Sinput_pending_p);
+  defsubr (&Slossage_size);
   defsubr (&Srecent_keys);
   defsubr (&Sthis_command_keys);
   defsubr (&Sthis_command_keys_vector);
diff --git a/test/src/keyboard-tests.el b/test/src/keyboard-tests.el
index 1988ba5..970a535 100644
--- a/test/src/keyboard-tests.el
+++ b/test/src/keyboard-tests.el
@@ -32,5 +32,20 @@
                         (read-event nil nil 2))
                  ?\C-b)))
 
+(ert-deftest keyboard-lossage-size ()
+  "Test `lossage-size'."
+  (let ((min-value 100)
+        (lossage-orig (lossage-size)))
+    (dolist (factor (list 1 3 4 5 10 7 3))
+      (let ((new-lossage (* factor min-value)))
+        (should (= new-lossage (lossage-size new-lossage)))))
+    ;; Wrong type
+    (should-error (lossage-size -5))
+    (should-error (lossage-size "200"))
+    ;; Less that minimum value
+    (should-error (lossage-size (1- min-value)))
+    (should (= lossage-orig (lossage-size lossage-orig)))))
+
+
 (provide 'keyboard-tests)
 ;;; keyboard-tests.el ends here