Môi trường bền bỉ cho biên dịch Mx

Khi tôi chạy M-x compilenó sẽ sinh ra một lớp con mới để thực thi lệnh biên dịch của tôi. Ngay khi lệnh biên dịch trở lại, tiến trình shell bị hủy. Tôi có thể thấy lý do tại sao điều này sẽ được mong muốn trong hầu hết các trường hợp, nhưng tôi hiện đang ở trong một tình huống mà nó không hữu ích.

Tôi đang làm việc trong một môi trường xây dựng chuyên biệt ngay bây giờ đòi hỏi tôi phải thực hiện một số bước ban đầu để thiết lập bản dựng trước khi chạy trình biên dịch. Miễn là môi trường vẫn tồn tại, tôi chỉ cần thực hiện các bước thiết lập một lần. Nhưng khi tôi sử dụng M-x compilenó có nghĩa là tôi phải thực hiện các bước mỗi lần tôi muốn biên dịch hoặc biên dịch lại.

Có cách nào để tôi có thể sinh ra một lớp con sẽ tồn tại trong nền không? Một cái M-x compilevà M-x gdbcó thể sử dụng mỗi lần họ cần chạy tiến trình shell?

Động lực:

Tôi có một chương trình (mà chúng tôi sẽ gọi xcc) xây dựng mã C cho các nền tảng đặc biệt. Để xây dựng mã của tôi, trước tiên tôi bắt đầu xcctừ tcshdấu nhắc:

$ xcc

Chương trình mất hơn 10 giây để tải và sau đó tôi có thể nhập các lệnh tại dấu nhắc tương tác của nó

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

Các bước trên có thể được xây dựng thành một macro tùy chỉnh buildmyprog.macrođể tôi có thể chạy nó trực tiếp từ trình bao hoặc từ emacs vớiM-x compile

$ xcc buildmyprog.macro

Vấn đề chính với cách tiếp cận này là thực tế là phải mất xcc10 giây để tải chương trình, trước khi quá trình biên dịch bắt đầu. Tôi đã quá mệt mỏi khi phải chờ thêm 10 giây mỗi lần tôi biên dịch rằng tôi đã bắt đầu chạy xcctrong một ansi-termbộ đệm riêng. Bây giờ sau khi tôi sửa đổi và lưu mã, tôi chuyển sang ansi-termbộ đệm và chạy

xcc>> build myprogram

Điều này hoạt động tốt, nhưng mỗi khi tôi chuyển sang bộ đệm đó, tôi nghĩ, "Sẽ không hay nếu tôi có thể đẩy F7và lệnh biên dịch của tôi sẽ được gửi đến phiên bản đã chạy của xcc?"

Bạn có thể thực hiện thiết lập trong shell của bạn trước khi bạn bắt đầu emacs không? Vỏ compilephụ nên kế thừa môi trường từ ông bà của nó thông qua emacs.

Sử dụng một vỏ thực tế bên trong Emacs sau đó, như eshellhoặc ansi-term. Bạn nên sử dụng compileđể biên dịch, mặc dù nó có thể được sử dụng để thực thi bất kỳ lệnh nào.

Tôi không nghĩ rằng nó có thể với lệnh biên dịch, nhưng có lẽ tôi đang thiếu một cái gì đó. Nếu không, bạn có thể đặt mọi bước thiết lập vào tập lệnh shell và thực thi tập lệnh đó với M-x compile.

Một giải pháp khả thi là có một trình thông dịch cố định sống trong một bộ đệm chuyên dụng (giống như *compilation*bộ đệm, nhưng trong đó quy trình cơ bản sẽ không bao giờ quay trở lại). Sau đó, bạn có thể có một recompilelệnh giống như để gửi một lệnh biên dịch được xác định trước cho trình thông dịch và hiển thị kết quả.

Dưới đây là một thực hiện dự kiến ​​của một chiến lược như vậy. Các persistent-compilelệnh cần chăm sóc cả hai khởi của quá trình này (khi nó được gọi là lần đầu tiên hoặc với một đối số tiền tố), và biên dịch lại (nếu quá trình thông dịch viên đã được lên và chạy). Kết quả biên dịch được hiển thị trong *persistent-compilation*bộ đệm, đưa vào compilation-shell-minor-modeđể hưởng lợi từ các compilation-modetính năng thông thường để điều hướng giữa các lỗi.

Dưới đây là một ví dụ sử dụng, cùng với nội dung kết quả của *persistent-compilation*bộ đệm:

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

   $ FOO=bar
   $ echo $FOO
   bar
   $
   

2. M-xpersistent-compileRET

   $ echo $FOO
   bar
   $
   

Coi chừng, đoạn mã sau không được kiểm tra nhiều. Ví dụ: tôi không chắc điều gì sẽ xảy ra khi bạn thử biên dịch lại trước khi kết thúc quá trình biên dịch trước đó.

(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))