Re: Native compilation of Keyboard Macros

[Philip Kaludercic <philipk@posteo.net>]

Juri Linkov <juri@linkov.net> writes:

>> So, I think you should focus on the problem of turning a keyboard macro
>> into code.  We know it's impossible in general, so it has to be
>> "user-visible" (i.e. the user specifically asks for it and is made aware
>> that the result is a chunk of code which will not always run the same
>> commands as the keyboard macro).
>>
>> You could have a "run kmacro and turn *this* execution into ELisp code".
>> IIUC some people tried to do that already, but I can't remember where
>> I saw that and my search-fu is weak right now.
>
> The last executed commands are already remembered at different levels,
> so the hard task is to decide at what level to turn them to code:
>
> 1. at level of complex command execution, such as from the history
>    retrieved by `repeat-complex-command` (C-x ESC ESC), for example:
>
>    (rgrep "macro" "* .*" "emacs/lisp/")
>
> 2. at level of commands corresponding to all typed keys,
>    such as retrieved by `view-lossage` (C-h l),
>    for example, for the same as above:
>
>    M-x                ;; execute-extended-command
>    r                  ;; self-insert-command
>    g                  ;; self-insert-command
>    r                  ;; self-insert-command
>    <tab>              ;; minibuffer-complete
>    <return>           ;; minibuffer-complete-and-exit
>    m                  ;; self-insert-command
>    a                  ;; self-insert-command
>    c                  ;; self-insert-command
>    r                  ;; self-insert-command
>    o                  ;; self-insert-command
>    <return>           ;; exit-minibuffer
>    <return>           ;; exit-minibuffer
>    <return>           ;; minibuffer-complete-and-exit

Intuitively I would expect the first level to make more sense, though I
see that when considering commands like `self-insert-command' you
couldn't just deduce all the command invocations and wrap them in a
`progn' body.  At the same time, what is there to compile on the second
level?  You still need to look up all the commands and invoke them.  As
Stefan said, it is perhaps necessary to either detect what commands can
be safely converted into repeat-complex-command'-esque representations
(and what commands can be assisted/transformed), and only optimise if
that is possible.