kmacro: Simplify register code and recent change

While reviewing uses of `last-kbd-macro` for more problems like
those of bug#61700 I noticed that we don't need the `kmacro-register`
type any more (we can directly use the new `kmacro` type instead).
Also `macros.el` requires `kmacro` so rather than autoload
`macro--string-to-vector` it's simpler to move the function to
`kmacro.el`.  And while at it fold into it the `stringp` test that's used
before every call to that function.

* lisp/kmacro.el (kmacro--to-vector): Rename from
`macro--string-to-vector`, move from `mcros.el`, and make it work for
vectors.
(kmacro-ring-head, kmacro-lambda-form): Simplify accordingly.
(cl-print-object): Remove unused declaration.
(kmacro-register): Delete type.  Use `kmacro` objects instead.
(register-val-jump-to, register-val-describe, register-val-insert):
Rewrite accordingly.
(kmacro-to-register): Put the `kmacro` object.

* lisp/macros.el (macro--string-to-vector): Move to `kmacro.el`.
(insert-kbd-macro): Use `kmacro--to-vector`.

* src/macros.c (end_kbd_macro): Always generate a vector.

3 files changed, 27 insertions, 40 deletions

diff --git a/lisp/kmacro.el b/lisp/kmacro.el
index aec4b805474..64aa7a27bde 100644
--- a/lisp/kmacro.el
+++ b/lisp/kmacro.el
@@ -376,14 +376,22 @@ and `kmacro-counter-format'.")
 (defvar kmacro-view-last-item nil)
 (defvar kmacro-view-item-no 0)
 
+(defun kmacro--to-vector (object)
+  "Normalize an old-style key sequence to the vector form."
+  (if (not (stringp object))
+      object
+    (let ((vec (string-to-vector object)))
+      (unless (multibyte-string-p object)
+        (dotimes (i (length vec))
+          (let ((k (aref vec i)))
+            (when (> k 127)
+              (setf (aref vec i) (+ k ?\M-\C-@ -128))))))
+      vec)))
 
-(autoload 'macro--string-to-vector "macros")
 (defun kmacro-ring-head ()
   "Return pseudo head element in macro ring."
   (and last-kbd-macro
-       (kmacro (if (stringp last-kbd-macro)
-                   (macro--string-to-vector last-kbd-macro)
-                 last-kbd-macro)
+       (kmacro (kmacro--to-vector last-kbd-macro)
                kmacro-counter kmacro-counter-format-start)))
 
 
@@ -843,10 +851,8 @@ KEYS should be a vector or a string that obeys `key-valid-p'."
       (setq format  (nth 2 mac))
       (setq counter (nth 1 mac))
       (setq mac     (nth 0 mac)))
-    (when (stringp mac)
-      ;; `kmacro' interprets a string according to `key-parse'.
-      (setq mac (macro--string-to-vector mac)))
-    (kmacro mac counter format)))
+    ;; `kmacro' interprets a string according to `key-parse'.
+    (kmacro (kmacro--to-vector mac) counter format)))
 
 (defun kmacro-extract-lambda (mac)
   "Extract kmacro from a kmacro lambda form."
@@ -862,8 +868,6 @@ KEYS should be a vector or a string that obeys `key-valid-p'."
 
 (cl-defmethod cl-print-object ((object kmacro) stream)
   (princ "#f(kmacro " stream)
-  (require 'macros)
-  (declare-function macros--insert-vector-macro "macros" (definition))
   (let ((vecdef  (kmacro--keys     object))
         (counter (kmacro--counter object))
         (format  (kmacro--format  object)))
@@ -945,20 +949,15 @@ Such a \"function\" cannot be called from Lisp, but it is a valid editor command
   (put symbol 'kmacro t))
 
 
-(cl-defstruct (kmacro-register
-               (:constructor nil)
-               (:constructor kmacro-make-register (macro)))
-  macro)
+(cl-defmethod register-val-jump-to ((km kmacro) arg)
+  (funcall km arg))                     ;FIXME: η-reduce?
 
-(cl-defmethod register-val-jump-to ((data kmacro-register) _arg)
-  (kmacro-call-macro current-prefix-arg nil nil (kmacro-register-macro data)))
+(cl-defmethod register-val-describe ((km kmacro) _verbose)
+  (princ (format "a keyboard macro:\n    %s"
+                 (key-description (kmacro--keys km)))))
 
-(cl-defmethod register-val-describe ((data kmacro-register) _verbose)
-  (princ (format "a keyboard macro:\n   %s"
-                 (key-description (kmacro-register-macro data)))))
-
-(cl-defmethod register-val-insert ((data kmacro-register))
-  (insert (format-kbd-macro (kmacro-register-macro data))))
+(cl-defmethod register-val-insert ((km kmacro))
+  (insert (key-description (kmacro--keys km))))
 
 (defun kmacro-to-register (r)
   "Store the last keyboard macro in register R.
@@ -968,7 +967,7 @@ Interactively, reads the register using `register-read-with-preview'."
    (progn
      (or last-kbd-macro (error "No keyboard macro defined"))
      (list (register-read-with-preview "Save to register: "))))
-  (set-register r (kmacro-make-register last-kbd-macro)))
+  (set-register r (kmacro-ring-head)))
 
 
 (defun kmacro-view-macro (&optional _arg)
diff --git a/lisp/macros.el b/lisp/macros.el
index 59c7796551f..98ee3dc52f9 100644
--- a/lisp/macros.el
+++ b/lisp/macros.el
@@ -46,16 +46,6 @@
                      " ")
           ?\]))
 
-(defun macro--string-to-vector (str)
-  "Convert an old-style string key sequence to the vector form."
-  (let ((vec (string-to-vector str)))
-    (unless (multibyte-string-p str)
-      (dotimes (i (length vec))
-        (let ((k (aref vec i)))
-          (when (> k 127)
-            (setf (aref vec i) (+ k ?\M-\C-@ -128))))))
-    vec))
-
 ;;;###autoload
 (defun insert-kbd-macro (macroname &optional keys)
   "Insert in buffer the definition of kbd macro MACRONAME, as Lisp code.
@@ -88,10 +78,8 @@ use this command, and then save the file."
       (insert "(defalias '"))
     (prin1 macroname (current-buffer))
     (insert "\n   ")
-    (when (stringp definition)
-      (setq definition (macro--string-to-vector definition)))
-    (if (vectorp definition)
-        (setq definition (kmacro definition)))
+    (when (or (stringp definition) (vectorp definition))
+      (setq definition (kmacro (kmacro--to-vector definition))))
     (if (kmacro-p definition)
         (let ((vecdef  (kmacro--keys     definition))
               (counter (kmacro--counter definition))
diff --git a/src/macros.c b/src/macros.c
index 0db0af89a71..d1541d2817f 100644
--- a/src/macros.c
+++ b/src/macros.c
@@ -128,9 +128,9 @@ end_kbd_macro (void)
   update_mode_lines = 20;
   kset_last_kbd_macro
     (current_kboard,
-     make_event_array ((current_kboard->kbd_macro_end
-                        - current_kboard->kbd_macro_buffer),
-                       current_kboard->kbd_macro_buffer));
+     Fvector ((current_kboard->kbd_macro_end
+               - current_kboard->kbd_macro_buffer),
+              current_kboard->kbd_macro_buffer));
 }
 
 DEFUN ("end-kbd-macro", Fend_kbd_macro, Send_kbd_macro, 0, 2, "p",