Change major mode for buffer without a corresponding file

Question

I want to change the major mode from fundamental-mode to compilation-mode for a buffer which contains some generated output named for eg. *results*. I've tried to add an entry to auto-mode-alist but if i understand correctly this works only with buffers which have a corresponding filename.

I've tried to add it in the list like this but this is not working.

(add-to-list 'auto-mode-alist '("\\*result\\*" . compilation-mode))

UPDATE:

After some digging in I found that this particular lisp snippet is filling the buffer with data.

(start-process "result" "*result*" "some_unix_command")

UPDATE:

This buffer is generated from a 3rd party plugin so i'd rather not start and change the src lisp code. I'd like to handle this on a different level.

I've already checked if I can attach a hook somewhere where the buffer is created and the answer is negative.

Anyone with some ideas on how I can do this?

Answer 1

The general answer to problems of this kind is given by user Lawlist. I consider in the following your special situation.

You stated in a comment that you want to use compilation-mode for cmake-ide.

The following code advises that package for that purpose probably with minimal impact on the package:

(defcustom my-cide-callback-functions
  '(my-cide-compilation-mode-activate)
  "Special hook for cide.
Each function registered here is run like a process sentinel
for the cmake process after cmake has finished."
  :type 'hook
  :group 'cmake-ide)

(defun my-cide-compilation-mode-activate (process _event)
  "Activate `compilation-mode' in PROCESS buffer after compilation.
This function can be used in `my-cide-callback-functions'."
  (let ((buf (process-buffer process)))
    (when (and (null (process-live-p process))
               (buffer-live-p buf))
      (with-current-buffer buf
        (compilation-mode)))))

(defun my-cide--register-a-callback (callback)
  "Register CALLBACK to be called when CMake finishes running."
  (set-process-sentinel
   (get-process "cmake")
   `(lambda (process event)
     (funcall ,callback process event)
     (run-hook-with-args 'my-cide-callback-functions process event))))

(advice-add 'cide--register-a-callback :override #'my-cide--register-a-callback)

Disclaimer: I do not have cmake-ide and do not want to install it if it is not necessary for debugging. Please test the code and report back whether it works or not.

Answer 2

Instead of running start-process and then calling compilation-mode on the output:

(start-process "result" "*result*" "some_unix_command")

... another option is to use the compile command, which automatically generates the output buffer in compilation-mode:

(compile "some_unix_command")

Alternatively, consider invoking compilation-mode after the process finishes running when using start-process by using a process-sentinel:

https://www.gnu.org/software/emacs/manual/html_node/elisp/Sentinels.html

This following linked thread contains a few examples of using a process sentinel:

https://stackoverflow.com/questions/24548536/penetrating-the-set-process-sentinel-hierarchy-with-let-bound-variables