[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]
feature/bug#38796-lossage-limit 9723c26 1/2: Give Lisp control on the lo
From: |
Tino Calancha |
Subject: |
feature/bug#38796-lossage-limit 9723c26 1/2: Give Lisp control on the lossage size |
Date: |
Fri, 26 Jun 2020 13:21:11 -0400 (EDT) |
branch: feature/bug#38796-lossage-limit
commit 9723c2645c8f47e651a81a023e80f882d181cc3f
Author: Tino Calancha <tino.calancha@gmail.com>
Commit: Tino Calancha <tino.calancha@gmail.com>
Give Lisp control on the lossage size
Add an user option to control the maximum number of
recorded keystrokes (a.k.a lossage limit) (Bug#38796).
* src/keyboard.c (lossage-limit): Add new variable.
(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).
(update-lossage-limit): New function.
(update_recent_keys): Helper function.
(command_loop_1)
(record_char)
(recent-keys)
(syms_of_keyboard): Replace NUM_RECENT_KEYS with lossage_limit as
the vector size.
(clear-this-command-keys): Fix docstring.
* lisp/help.el (view-lossage): Mention lossage-limit in the docstring.
* lisp/cus-start.el (lossage-limit): Register it as an user option.
* lisp/edmacro.el (edit-kbd-macro): Update docstring and commentary header.
* etc/NEWS (Changes in Emacs 28.1): Announce the new option.
* doc/emacs/help.texi (Misc Help): Document it.
* test/src/keyboard-tests.el (keyboard-lossage-limit): Add test.
---
doc/emacs/help.texi | 7 ++-
etc/NEWS | 4 ++
lisp/cus-start.el | 2 +
lisp/edmacro.el | 6 +--
lisp/help.el | 3 +-
src/keyboard.c | 103 +++++++++++++++++++++++++++++++++++++--------
test/src/keyboard-tests.el | 11 +++++
7 files changed, 112 insertions(+), 24 deletions(-)
diff --git a/doc/emacs/help.texi b/doc/emacs/help.texi
index 167c32c..e2c0dc6 100644
--- a/doc/emacs/help.texi
+++ b/doc/emacs/help.texi
@@ -563,10 +563,13 @@ command works depend on the major mode.
@kindex C-h l
@findex view-lossage
+@vindex lossage-limit
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 events; if you wish, you can change this number
+with the option @code{lossage-limit}.
+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 d58a61b..da204c5 100644
--- a/etc/NEWS
+++ b/etc/NEWS
@@ -70,6 +70,10 @@ useful on systems such as FreeBSD which ships only with
"etc/termcap".
* Changes in Emacs 28.1
++++
+** The new option 'lossage-limit' controls the maximum number
+of keystrokes and commands recorded.
+
** Support for '(box . SIZE)' 'cursor-type'.
By default, 'box' cursor always has a filled box shape. But if you
specify 'cursor-type' to be '(box . SIZE)', the cursor becomes a hollow
diff --git a/lisp/cus-start.el b/lisp/cus-start.el
index 6632687..1ebf554 100644
--- a/lisp/cus-start.el
+++ b/lisp/cus-start.el
@@ -352,6 +352,8 @@ Leaving \"Default\" unchecked is equivalent with specifying
a default of
;; indent.c
(indent-tabs-mode indent boolean)
;; keyboard.c
+ (lossage-limit keyboard integer "28.1"
+ :set (lambda (_ val) (update-lossage-limit val)))
(meta-prefix-char keyboard character)
(auto-save-interval auto-save integer)
(auto-save-no-message auto-save boolean "27.1")
diff --git a/lisp/edmacro.el b/lisp/edmacro.el
index 71474c0..089fea1 100644
--- a/lisp/edmacro.el
+++ b/lisp/edmacro.el
@@ -35,8 +35,8 @@
;; * `M-x' followed by a command name, to edit a named command
;; whose definition is a keyboard macro.
;;
-;; * `C-h l' (view-lossage), to edit the 300 most recent keystrokes
-;; and install them as the "current" macro.
+;; * `C-h l' (view-lossage), to edit the `lossage-limit' most recent
+;; keystrokes and install them as the "current" macro.
;;
;; * any key sequence whose definition is a keyboard macro.
;;
@@ -88,7 +88,7 @@ Default nil means to write characters above \\177 in octal
notation."
"Edit a keyboard macro.
At the prompt, type any key sequence which is bound to a keyboard macro.
Or, type `\\[kmacro-end-and-call-macro]' or RET to edit the last
-keyboard macro, `\\[view-lossage]' to edit the last 300
+keyboard macro, `\\[view-lossage]' to edit the last `lossage-limit'
keystrokes as a keyboard macro, or `\\[execute-extended-command]'
to edit a macro by its command name.
With a prefix argument, format the macro in a more concise way."
diff --git a/lisp/help.el b/lisp/help.el
index b7d867e..9e3d092 100644
--- a/lisp/help.el
+++ b/lisp/help.el
@@ -456,9 +456,10 @@ the variable `message-log-max'."
(info "(efaq)Packages that do not come with Emacs"))
(defun view-lossage ()
- "Display last few input keystrokes and the commands run.
+ "Display last input keystrokes and the commands run.
For convenience this uses the same format as
`edit-last-kbd-macro'.
+See `lossage-limit' 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 f9b9399..a4d27c9 100644
--- a/src/keyboard.c
+++ b/src/keyboard.c
@@ -103,7 +103,7 @@ 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)
+#define MIN_NUM_RECENT_KEYS (100)
/* Index for storing next element into recent_keys. */
static int recent_keys_index;
@@ -111,7 +111,7 @@ 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. */
+/* This vector holds the last lossage_limit keystrokes. */
static Lisp_Object recent_keys;
/* Vector holding the key sequence that invoked the current command.
@@ -294,6 +294,7 @@ static union buffered_input_event *kbd_fetch_ptr;
/* Pointer to next place to store character in kbd_buffer. */
static union buffered_input_event *kbd_store_ptr;
+
/* The above pair of variables forms a "queue empty" flag. When we
enqueue a non-hook event, we increment kbd_store_ptr. When we
dequeue a non-hook event, we increment kbd_fetch_ptr. We say that
@@ -1421,10 +1422,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 +3249,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 +3308,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 +3327,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 +10411,55 @@ If CHECK-TIMERS is non-nil, timers that are ready to
run will do so. */)
? Qt : Qnil);
}
+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;
+
+}
+
+/* Reallocate recent_keys copying the keystrokes in the right order */
+DEFUN ("update-lossage-limit", Fupdate_lossage_limit,
+ Supdate_lossage_limit, 1, 1, 0,
+ doc: /* Update the maximum number of saved keystrokes to ARG.
+usage: (update-lossage-limit ARG) */)
+ (Lisp_Object arg)
+{
+ 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 Qnil;
+ 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 Qnil;
+}
+
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 +10469,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);
@@ -10531,8 +10581,8 @@ The value is always a vector. */)
DEFUN ("clear-this-command-keys", Fclear_this_command_keys,
Sclear_this_command_keys, 0, 1, 0,
doc: /* Clear out the vector that `this-command-keys' returns.
-Also clear the record of the last 100 events, unless optional arg
-KEEP-RECORD is non-nil. */)
+Also clear the record of the last `lossage-limit' keystroke events,
+unless optional arg KEEP-RECORD is non-nil. */)
(Lisp_Object keep_record)
{
int i;
@@ -11686,7 +11736,23 @@ syms_of_keyboard (void)
staticpro (&modifier_symbols);
}
- recent_keys = make_nil_vector (NUM_RECENT_KEYS);
+ DEFVAR_INT ("lossage-limit", lossage_limit,
+ doc: /* Maximum number of stored keyboard events and commands
run.
+
+Please, do not set this variable in Lisp with `setq' neither
+let-bind it, that will likely crash Emacs. This is because
+`setq' only changes the variable, but it doesn't update
+the size of the internal vector that holds the keystrokes.
+
+To update this variable use the customization menu, or
+call from Lisp the following expression:
+
+ (update-lossage-limit new-limit)
+
+That takes care of both, the variable and the internal vector.*/);
+ lossage_limit = 3 * MIN_NUM_RECENT_KEYS;
+
+ recent_keys = make_nil_vector (lossage_limit);
staticpro (&recent_keys);
this_command_keys = make_nil_vector (40);
@@ -11736,6 +11802,7 @@ syms_of_keyboard (void)
defsubr (&Srecursive_edit);
defsubr (&Sinternal_track_mouse);
defsubr (&Sinput_pending_p);
+ defsubr (&Supdate_lossage_limit);
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..017d239 100644
--- a/test/src/keyboard-tests.el
+++ b/test/src/keyboard-tests.el
@@ -32,5 +32,16 @@
(read-event nil nil 2))
?\C-b)))
+(ert-deftest keyboard-lossage-limit ()
+ "Test `lossage-limit' updates."
+ (dolist (val (list 100 100 200 500 300 1000 700))
+ (update-lossage-limit val)
+ (should (= val lossage-limit)))
+ (let ((current-limit lossage-limit))
+ (should-error (update-lossage-limit 5))
+ (should-error (update-lossage-limit "200"))
+ (should (= lossage-limit current-limit))))
+
+
(provide 'keyboard-tests)
;;; keyboard-tests.el ends here