how to make next-error work on non-grep non-compilation

how to make next-error work on non-grep non-compilation

[jimka]

Hi elisp experts,  I have a file which contains grep/compilation style
output.
I'd like to insert that into an emacs buffer and provide the next-
error capability to the user.
I can't seem to make it work, but I feel like I'm almost there.

Any suggestions?  I cannot use the normal compile nor grep interface,
because the information in the mini-buffer is precious and cannot be
changed.  the compile-interface prints something like "compilation
finished" in the mini-buffer.

Here is what I have so far, which displays the file in the perspecitve
buffer, and colorizes it but next-error doesn't do anything useful.

(defun skill-vlint-present (file-name)
  (let ((interesting-output nil)
        (buf (get-buffer-create " vlint")))
    (with-current-buffer buf
      (let ((inhibit-read-only t))
        (erase-buffer)
        (compilation-shell-minor-mode t)
        (setq compilation-auto-jump-to-first-error t)
        (setq next-error-function `(lambda (n &optional reset)
                                     (set-buffer ,buf)
                                     (setq next-error-last-
buffer ,buf)
                                     (compilation-next-error n
reset)))
        (insert "-*- mode: " "grep-mode"
                "; default-directory: " (prin1-to-string default-
directory)
                " -*-\n\n")
        (let ((pos (point-max)))
          (insert-file-contents-literally file-name)
          (setq interesting-output (not (equal pos (point-max)))))

        (font-lock-fontify-buffer)
        (goto-char 0)
        (compilation-compat-parse-errors (point-max))))
    (when interesting-output
      (display-buffer buf))))

Re: how to make next-error work on non-grep non-compilation

[Jim Newton]

here is the stacktrace I get from next-error.
It appears there is no 'message text property on the lines, but isn't this what the function compilation-compat-parse-errors does?

Debugger entered--Lisp error: (error "Moved past last grep hit")
  signal(error ("Moved past last grep hit"))
  error("Moved past last %s" "grep hit")
  (or (setq msg (get-text-property pt ...)) (if (setq pt ...) (setq msg ...)) (error (if ... "No more %ss yet" "Moved past last %s") compilation-error))
  (while (> n 0) (setq opt pt) (or (setq pt ...) (if ... ... ...)) (or (setq msg ...) (if ... ...) (error ... compilation-error)) (or (< ... compilation-skip-threshold) (if different-file ...) (if compilation-skip-visited ...) (if compilation-skip-to-next-location ...) (setq n ...)))
  (let (opt) (while (> n 0) (setq opt pt) (or ... ...) (or ... ... ...) (or ... ... ... ... ...)))
  (compilation-loop > next-single-property-change 1- (if (get-buffer-process ...) "No more %ss yet" "Moved past last %s") (point-max))
  (if (>= n 0) (compilation-loop > next-single-property-change 1- (if ... "No more %ss yet" "Moved past last %s") (point-max)) (setq pt (previous-single-property-change pt ... nil ...)) (compilation-loop < previous-single-property-change 1+ "Moved back before first %s" (point-min)))
  (if (zerop n) (unless (or msg ...) (setq pt ...) (unless ... ... ...)) (setq last (nth 2 ...)) (if (>= n 0) (compilation-loop > next-single-property-change 1- ... ...) (setq pt ...) (compilation-loop < previous-single-property-change 1+ "Moved back before first %s" ...)))
  (let* ((msg ...) (loc ...) last) (if (zerop n) (unless ... ... ...) (setq last ...) (if ... ... ... ...)) (goto-char pt) (or msg (error "No %s here" compilation-error)))
  compilation-next-error(1 nil #<marker at 343 in *grep*>)
  compilation-next-error-function(1 nil)
  funcall(compilation-next-error-function 1 nil)
  (save-current-buffer (set-buffer next-error-last-buffer) (funcall next-error-function (prefix-numeric-value arg) reset) (when next-error-recenter (recenter next-error-recenter)) (run-hooks (quote next-error-hook)))
  (with-current-buffer next-error-last-buffer (funcall next-error-function (prefix-numeric-value arg) reset) (when next-error-recenter (recenter next-error-recenter)) (run-hooks (quote next-error-hook)))
  (progn (with-current-buffer next-error-last-buffer (funcall next-error-function ... reset) (when next-error-recenter ...) (run-hooks ...)))
  (if (setq next-error-last-buffer (next-error-find-buffer)) (progn (with-current-buffer next-error-last-buffer ... ... ...)))
  (when (setq next-error-last-buffer (next-error-find-buffer)) (with-current-buffer next-error-last-buffer (funcall next-error-function ... reset) (when next-error-recenter ...) (run-hooks ...)))
  next-error(nil)
  call-interactively(next-error nil nil)

Re: how to make next-error work on non-grep non-compilation

[Stefan Monnier]

> Hi elisp experts,  I have a file which contains grep/compilation style
> output.

Does its name have something specific to its format (e.g. it uses
a particular extension)?

> I'd like to insert that into an Emacs buffer and provide the next-
> error capability to the user.

Do you also want it to be editable at the same time?

> I can't seem to make it work, but I feel like I'm almost there.

Maybe you need to set compilation-error-regexp-alist.

> Any suggestions?  I cannot use the normal compile nor grep interface,
> because the information in the mini-buffer is precious and cannot be
> changed.

Your code seems to add a "-*- grep -*-".  If it can be added to the file
rather than to the buffer, it can reduce the needed code even further.

> (defun skill-vlint-present (file-name)
>   (let ((interesting-output nil)
>         (buf (get-buffer-create " vlint")))
>     (with-current-buffer buf
>       (let ((inhibit-read-only t))
>         (erase-buffer)
>         (compilation-shell-minor-mode t)
>         (setq compilation-auto-jump-to-first-error t)
>         (setq next-error-function `(lambda (n &optional reset)
>                                      (set-buffer ,buf)
>                                      (setq next-error-last-
> buffer ,buf)
>                                      (compilation-next-error n
> reset)))
>         (insert "-*- mode: " "grep-mode"
>                 "; default-directory: " (prin1-to-string default-
> directory)
>                 " -*-\n\n")
>         (let ((pos (point-max)))
>           (insert-file-contents-literally file-name)
>           (setq interesting-output (not (equal pos (point-max)))))

>         (font-lock-fontify-buffer)
>         (goto-char 0)
>         (compilation-compat-parse-errors (point-max))))

Calling `compilation-compat-parse-errors' is a bad idea: just remove the
call, it should not make any difference.
I'd recommend you try something simpler based around something like:

 (let ((buf (find-file-noselect file-name)))
   (grep-mode))


-- Stefan

Re: how to make next-error work on non-grep non-compilation

[Jim Newton]

Hi Stefan, thanks for the suggestion,
but unfortunately the code you gave me coverts the current bugger to grep mode :-(

Re: how to make next-error work on non-grep non-compilation

[Stefan Monnier]

> but unfortunately the code you gave me coverts the current bugger to
> grep mode :-(

Why do you say "unfortunately"?


        Stefan

Re: how to make next-error work on non-grep non-compilation

[Jim Newton]

unfortunately because i want it to change the buffer which contains grep style output to grep-mode.  I don't want it to change the mode of my source code buffer.

Re: how to make next-error work on non-grep non-compilation

[Jim Newton]

> Does its name have something specific to its format (e.g. it uses
> a particular extension)?

No the file has no particular extension, but i can give it whatever extension it needs if that makes the job easier.

> Do you also want it to be editable at the same time?

It should not be editable.

> Maybe you need to set compilation-error-regexp-alist.

what should I set it to?  I'm trying to make the format of the file already compatible with grep.  I'm assuming that only the grep match lines are important and not the header lines which show the grep command line.  


> Calling `compilation-compat-parse-errors' is a bad idea: just remove the
> call, it should not make any difference.

okeydokey

> I'd recommend you try something simpler based around something like:
>
> (let ((buf (find-file-noselect file-name)))
>   (grep-mode))


Well I would like the buffer to have a more generic name so that if i run my function many times, it reuses the same buffer, thus destroying its old content.  So I'd rather not make the buffer simple a file-visiting buffer.

-jim

Re: how to make next-error work on non-grep non-compilation

[Jim Newton]

Here is what I settled on.  It seems to work.

(defun skill-vlint-present (file-name)
  (let (size
        (vlint (get-buffer-create "vlint")))
    (with-current-buffer vlint
      (let ((inhibit-read-only t))
        (erase-buffer)
        (insert-file-contents-literally file-name)
        (when (setq size (- (point-max) (point-min)))
          (grep-mode))))
    (when (plusp size)
      (switch-to-buffer-other-window vlint))))

Re: how to make next-error work on non-grep non-compilation

[Stefan Monnier]

> (defun skill-vlint-present (file-name)
>   (let (size
>         (vlint (get-buffer-create "vlint")))
>     (with-current-buffer vlint
>       (let ((inhibit-read-only t))
>         (erase-buffer)
>         (insert-file-contents-literally file-name)
>         (when (setq size (- (point-max) (point-min)))
>           (grep-mode))))
>     (when (plusp size)
>       (switch-to-buffer-other-window vlint))))

Looks much better than the code you sent before.  Note that 0 when
interpreted as a boolean in Elisp is the same as true, so the
"(when (setq size (- (point-max) (point-min)))" will always call the
`grep-mode'.  And you can use (buffer-size) instead of (- (point-max)
(point-min)).  Oh, and I'd use (unless (zerop size)...) since `plusp' is
not standard Elisp but only provided by the CL library.


        Stefan

Re: how to make next-error work on non-grep non-compilation

[Ted Zlatanov]

On Fri, 20 May 2011 04:41:54 -0700 (PDT) jimka <jimka.velizy@googlemail.com> wrote: 

j> Hi elisp experts, I have a file which contains grep/compilation style
j> output.  I'd like to insert that into an emacs buffer and provide the
j> next- error capability to the user.  I can't seem to make it work,
j> but I feel like I'm almost there.

You can make any buffer support `next-error' by binding
`next-error-function'.  See simple.el:

(defvar next-error-function nil
  "Function to use to find the next error in the current buffer.
The function is called with 2 parameters:
ARG is an integer specifying by how many errors to move.
RESET is a boolean which, if non-nil, says to go back to the beginning
of the errors before moving.
Major modes providing compile-like functionality should set this variable
to indicate to `next-error' that this is a candidate buffer and how
to navigate in it.")
(make-variable-buffer-local 'next-error-function)

The buffer doesn't have to be in any particular mode.

Ted