Como posso simular um evento de chave arbitrária do Elisp?

É possível simular um evento-chave arbitrário do elisp? Estou ciente das maneiras pelas quais posso encontrar a ligação para uma determinada chave e, em seguida, chamar esse comando interativamente, mas e se esse evento de chave não estiver vinculado a um comando?

Como exemplo , e se eu quisesse ligar C-`para me comportar da mesma forma que a ESCchave em todos os contextos ?

Você pode alimentar eventos arbitrários (pressionamentos de tecla, cliques do mouse etc.) no loop de comando, colocando-os em unread-command-events. Por exemplo, o seguinte fará com que o loop de comando execute uma interrupção na próxima vez em que for executado:

(setq unread-command-events (listify-key-sequence "\C-g"))

Observe que isso apenas alimenta eventos para o loop de comando, portanto, não fará nada de interessante se você estiver repetindo seu próprio código.

Uma abordagem diferente, da qual você parece estar ciente, é encontrar a função à qual uma determinada chave está vinculada e executá-la:

(funcall (global-key-binding "\C-g"))

Isso executará o comando imediatamente. Cuidado, no entanto, que alguns comandos têm um comportamento diferente, dependendo de serem chamados interativamente, como argumentos padrão. Você deseja compensar isso usando call-interactively:

(call-interactively (global-key-binding "\C-g"))

A maneira mais simples que conheço é apenas usar execute-kbd-macro:

(defun foo () (interactive) (execute-kbd-macro (kbd "<escape>")))
(global-set-key (kbd "C-`") 'foo)

Retirado desta resposta , você pode usar global-set-key como este

(global-set-key (kbd "C-`") (kbd "<escape>"))

Que tratará C-`comoescape

Isso parece ter alguns problemas, se a segunda combinação não executar uma função. Portanto, se escapeestiver sendo usado como Meta, então não funcionará corretamente. Mas parece funcionar para comandos vinculados a funções.

Depois de ler a sugestão de jch para usar unread-command-events, pude criar uma solução que fizesse algumas das coisas que eu estava procurando.

(defun my-simulate-key-event (event &optional N)
  "Simulate an arbitrary keypress event.

This function sets the `unread-command-events' variable in order to simulate a
series of key events given by EVENT. Can also For negative N, simulate the
specified key EVENT directly.  For positive N, removes the last N elements from
the list of key events in `this-command-keys' and then appends EVENT.  For N nil,
treat as N=1."
  (let ((prefix (listify-key-sequence (this-command-keys)))
         (key (listify-key-sequence event))
         (n (prefix-numeric-value N)))
     (if (< n 0)
         (setq prefix key)
       (nbutlast prefix n)
       (nconc prefix key))
       (setq unread-command-events prefix)))

Ainda há uma série de dobras para resolver. Ou seja, não obtenho o resultado correto se eu chamar essa função duas vezes seguidas em uma única defun.

Nota:

Depois de verificar a sugestão de uso do phils,key-translation-map consegui descobrir o local-function-key-mapque também é muito útil para alcançar alguns dos meus objetivos mais amplos.