Ambiente persistente para compilação Mx

Quando executo M-x compile, gera um novo subshell para executar meu comando de compilação. Assim que o comando de compilação retornar, o processo do shell será interrompido. Eu posso ver por que isso seria desejável na maioria dos casos, mas atualmente estou em uma situação em que não é útil.

Atualmente, estou trabalhando em um ambiente de compilação especializado, que exige algumas etapas iniciais para configurar a compilação antes de executar o compilador. Enquanto o ambiente persistir, só preciso executar as etapas de configuração uma vez. Mas quando eu uso, M-x compileisso significa que tenho que executar as etapas sempre que desejar compilar ou recompilar.

Existe uma maneira de gerar um subshell que persistirá em segundo plano? Um que M-x compilee M-x gdbpode usar cada vez que eles precisam para executar um processo shell?

Motivação:

Eu tenho um programa (que chamaremos xcc) que cria código C para plataformas especiais. Para criar meu código, começo primeiro xccpelo tcshprompt:

$ xcc

O programa leva mais de 10 segundos para carregar e, em seguida, posso inserir comandos no prompt interativo

xcc>> add target myprogram
xcc>> set source myprogram $PROJDIR/src/
xcc>> set includes myprogram $PROJDIR/include/
xcc>> set type myprogram primitive
xcc>> set inputs myprogram int8,int8
xcc>> set outputs myprogram fix16,fix16
xcc>> build myprogram

As etapas acima podem ser construídas em uma macro personalizada, buildmyprog.macropara que eu possa executá-la diretamente do shell ou do emacs comM-x compile

$ xcc buildmyprog.macro

O principal problema dessa abordagem é o fato de que o xccprograma leva 10 segundos para carregar, antes mesmo da compilação começar. Eu me cansei o suficiente de esperar os 10 segundos extras toda vez que compilei que comecei a correr xccem um ansi-termbuffer separado. Agora, depois de modificar e salvar o código, mudo para o ansi-termbuffer e corro

xcc>> build myprogram

Isso funciona bem, mas toda vez que eu mudo para esse buffer, penso: "Não seria ótimo se eu simplesmente pressionasse F7e meu comando de compilação fosse enviado para a instância já em execução do xcc?"

Você pode fazer a configuração no seu shell antes de iniciar o emacs? O compilesub-shell deve herdar o ambiente de seus avós via emacs.

Use um shell real dentro do Emacs, como eshellou ansi-term. Você deve usar compilepara compilar, embora possa ser usado para executar qualquer comando.

Não acho que seja possível com o comando compile, mas talvez esteja faltando alguma coisa. Caso contrário, você poderá colocar todas as etapas de configuração em um script de shell e executá-lo com M-x compile.

Uma solução possível seria ter um intérprete permanente vivendo em um buffer dedicado (mais ou menos como o *compilation*buffer, mas onde o processo subjacente nunca retornaria). Você pode ter um recompilecomando -like para enviar um comando de compilação predefinido ao intérprete e exibir os resultados.

Abaixo está uma implementação provisória de tal estratégia. O persistent-compilecomando cuida da inicialização do processo (quando é chamado pela primeira vez ou com um argumento de prefixo) e da recompilação (se o processo do intérprete já estiver em execução). Os resultados da compilação são exibidos em um *persistent-compilation*buffer, compilation-shell-minor-modeaproveitando os compilation-moderecursos usuais para navegar entre os erros.

Aqui está um exemplo de uso, junto com o conteúdo resultante do *persistent-compilation*buffer:

1. M-xpersistent-compileRET /bin/bashRET FOO=barRET echo $FOORET

   $ FOO=bar
   $ echo $FOO
   bar
   $
   

2. M-xpersistent-compileRET

   $ echo $FOO
   bar
   $
   

Cuidado, o código a seguir não foi muito testado. Por exemplo, não tenho certeza do que acontece quando você tenta recompilar antes do término da compilação anterior.

(defvar persistent-compile-interpreter "/bin/bash"
  "Interpreter to be used for persistent compilations.")

(defvar persistent-compile-init ""
  "Initialization command for persistent compilations.")

(defvar persistent-compile-command "make -k"
  "Compilation command for persistent compilations.")

;; Local variable in the persistent compilation buffer
(defvar persistent-compile--next-action)

(defun persistent-compile (&optional edit-command)
  "(Re-)run a persistent compilation.

The first time a persistent compilation is run, the user is asked
for an interpreter, an initialization command and a compilation
command.
The interpreter is started and optionally set up with the
initialization command.  The compilation command is then sent to
the interpreter.

All subsequent recompilations are sent to the same,
already-initialized interpreter, so as to keep the customized
environment.

If EDIT-COMMAND is non-nil, the user can edit the
parameters (interpreter, initialization command and compilation
command) and the interpreter is restarted."
  (interactive "P")
  (when (or edit-command
            (null (get-buffer "*persistent-compilation*"))
            (not persistent-compile-interpreter)
            (not persistent-compile-init)
            (not persistent-compile-command))
    (setq persistent-compile-interpreter (read-from-minibuffer "Interpreter: "
                                                               persistent-compile-interpreter)
          persistent-compile-init        (read-from-minibuffer "Initialization command: "
                                                               persistent-compile-init)
          persistent-compile-command     (read-from-minibuffer "Command: "
                                                               persistent-compile-command)))
  (with-current-buffer (get-buffer-create "*persistent-compilation*")
    (if (and edit-command
             (get-buffer-process (current-buffer)))
        ;; Kill an existing process and schedule for a recompilation with
        ;; the new parameters
        (progn
          (set-process-sentinel
           (get-buffer-process (current-buffer))
           (lambda (process event)
             (persistent-recompile nil)))
          (kill-process (get-buffer-process (current-buffer))))

      (if (not (get-buffer-process (current-buffer)))
          ;; Start and initialize a new process
          (progn
            (erase-buffer)
            (make-comint-in-buffer "persistent-compile" (current-buffer) persistent-compile-interpreter)
            (compilation-shell-minor-mode 1)
            (make-local-variable 'persistent-compile--next-action)
            (setq persistent-compile--next-action 'persistent-compile--initialize)
            (add-hook 'comint-output-filter-functions 'persistent-compile--at-prompt))

        ;; Run command
        (erase-buffer)
        (persistent-compile--send-command)))))

(defun persistent-compile--at-prompt (&optional output)
  (when persistent-compile--next-action
    ;; There is probably a better way of checking whether we are
    ;; just after a prompt, but I didn't find it...
    (let ((p1 (point))
          (p2 (save-excursion (comint-bol))))
      (unless (= p1 p2)
        (let ((action persistent-compile--next-action))
          (setq persistent-compile--next-action nil)
          (funcall action))))))

(defun persistent-compile--initialize ()
  (setq persistent-compile--next-action 'persistent-compile--send-command)
  (display-buffer (current-buffer))
  (insert persistent-compile-init)
  (comint-send-input nil t))

(defun persistent-compile--send-command ()
  (display-buffer (current-buffer))
  (insert persistent-compile-command)
  (comint-send-input nil t))