1 ;;; compile.el --- run compiler as inferior of Emacs, parse error messages.
3 ;; Copyright (C) 1985, 86, 87, 93 Free Software Foundation, Inc.
5 ;; Author: Roland McGrath <roland@prep.ai.mit.edu>
7 ;; Keywords: tools, processes
9 ;; This file is part of GNU Emacs.
11 ;; GNU Emacs is free software; you can redistribute it and/or modify
12 ;; it under the terms of the GNU General Public License as published by
13 ;; the Free Software Foundation; either version 2, or (at your option)
16 ;; GNU Emacs is distributed in the hope that it will be useful,
17 ;; but WITHOUT ANY WARRANTY; without even the implied warranty of
18 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19 ;; GNU General Public License for more details.
21 ;; You should have received a copy of the GNU General Public License
22 ;; along with GNU Emacs; see the file COPYING. If not, write to
23 ;; the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
27 ;; This package provides the compile and grep facilities documented in
28 ;; the Emacs user's manual.
33 (defvar compilation-mode-hook nil
34 "*List of hook functions run by `compilation-mode' (see `run-hooks').")
37 (defconst compilation-window-height nil
38 "*Number of lines in a compilation window. If nil, use Emacs default.")
40 (defvar compilation-error-list nil
41 "List of error message descriptors for visiting erring functions.
42 Each error descriptor is a cons (or nil). Its car is a marker
43 pointing to an error message. If its cdr is a marker, it points to
44 the text of the line the message is about. If its cdr is a cons, that
45 cons's car is the name of the file the message is about, and its cdr
46 is the number of the line the message is about. Or its cdr may be nil
47 if that error is not interesting.
49 The value may be t instead of a list; this means that the buffer of
50 error messages should be reparsed the next time the list of errors is wanted.
52 Some other commands (like `diff') use this list to control the error
53 message tracking facilites; if you change its structure, you should make
54 sure you also change those packages. Perhaps it is better not to change
57 (defvar compilation-old-error-list nil
58 "Value of `compilation-error-list' after errors were parsed.")
60 (defvar compilation-parse-errors-function 'compilation-parse-errors
61 "Function to call to parse error messages from a compilation.
62 It takes args LIMIT-SEARCH and FIND-AT-LEAST.
63 If LIMIT-SEARCH is non-nil, don't bother parsing past that location.
64 If FIND-AT-LEAST is non-nil, don't bother parsing after finding that
66 It should read in the source files which have errors and set
67 `compilation-error-list' to a list with an element for each error message
68 found. See that variable for more info.")
71 (defvar compilation-buffer-name-function nil
72 "Function to compute the name of a compilation buffer.
73 The function receives one argument, the name of the major mode of the
74 compilation buffer. It should return a string.
75 nil means compute the name with `(concat \"*\" (downcase major-mode) \"*\")'.")
78 (defvar compilation-finish-function nil
79 "*Function to call when a compilation process finishes.
80 It is called with two arguments: the compilation buffer, and a string
81 describing how the process finished.")
83 (defvar compilation-last-buffer nil
84 "The most recent compilation buffer.
85 A buffer becomes most recent when its compilation is started
86 or when it is used with \\[next-error] or \\[compile-goto-error].")
88 (defvar compilation-in-progress nil
89 "List of compilation processes now running.")
90 (or (assq 'compilation-in-progress minor-mode-alist)
91 (setq minor-mode-alist (cons '(compilation-in-progress " Compiling")
94 (defvar compilation-parsing-end nil
95 "Position of end of buffer when last error messages were parsed.")
97 (defvar compilation-error-message "No more errors"
98 "Message to print when no more matches are found.")
100 (defvar compilation-num-errors-found)
102 (defvar compilation-error-regexp-alist
104 ;; NOTE! This first one is repeated in grep-regexp-alist, below.
106 ;; 4.3BSD grep, cc, lint pass 1:
107 ;; /usr/src/foo/foo.c(8): warning: w may be used before set
109 ;; foo.c:8: error message
111 ;; foo.f :16 some horrible error message
113 ;; We'll insist that the number be followed by a colon or closing
114 ;; paren, because otherwise this matches just about anything
115 ;; containing a number with spaces around it.
116 ("\n\\([^:( \t\n]+\\)[:(][ \t]*\\([0-9]+\\)[:) \t]" 1 2)
118 ;; 4.3BSD lint pass 2
119 ;; strcmp: variable # of args. llib-lc(359) :: /usr/src/foo/foo.c(8)
120 ("[ \t:]\\([^:( \t\n]+\\)[:(](+[ \t]*\\([0-9]+\\))[:) \t]*$" 1 2)
122 ;; 4.3BSD lint pass 3
123 ;; bloofle defined( /users/wolfgang/foo.c(4) ), but never used
125 ;; ("[ \t(]+\\([^:( \t\n]+\\)[:( \t]+\\([0-9]+\\)[:) \t]+" 1 2)
126 ;; which is regexp Impressionism - it matches almost anything!
127 ("([ \t]*\\([^:( \t\n]+\\)[:(][ \t]*\\([0-9]+\\))" 1 2)
129 ;; Line 45 of "foo.c": bloofel undefined (who does this?)
130 ("\n[Ll]ine[ \t]+\\([0-9]+\\)[ \t]+of[ \t]+\"\\([^\"\n]+\\)\":" 2 1)
132 ;; Apollo cc, 4.3BSD fc:
133 ;; "foo.f", line 3: Error: syntax error near end of statement
135 ;; "vvouch.c", line 19.5: 1506-046 (S) Syntax error.
136 ("\"\\([^,\" \n\t]+\\)\", line \\([0-9]+\\)[:.]" 1 2)
138 ;; MIPS RISC CC - the one distributed with Ultrix:
139 ;; ccom: Error: foo.c, line 2: syntax error
140 ("rror: \\([^,\" \n\t]+\\), line \\([0-9]+\\):" 1 2)
142 ;; IBM AIX PS/2 C version 1.1:
143 ;; ****** Error number 140 in line 8 of file errors.c ******
144 ("in line \\([0-9]+\\) of file \\([^ \n]+[^. \n]\\)\\.? " 2 1)
145 ;; IBM AIX lint is too painful to do right this way. File name
146 ;; prefixes entire sections rather than being on each line.
149 "Alist that specifies how to match errors in compiler output.
150 Each element has the form (REGEXP FILE-IDX LINE-IDX).
151 If REGEXP matches, the FILE-IDX'th subexpression gives the file
152 name, and the LINE-IDX'th subexpression gives the line number.")
154 (defvar grep-regexp-alist
155 '(("^\\([^:( \t\n]+\\)[:( \t]+\\([0-9]+\\)[:) \t]" 1 2))
156 "Regexp used to match grep hits. See `compilation-error-regexp-alist'.")
159 (defvar compilation-search-path '(nil)
160 "*List of directories to search for source files named in error messages.
161 Elements should be directory names, not file names of directories.
162 nil as an element means to try the default directory.")
164 (defvar compile-command "make -k "
165 "Last shell command used to do a compilation; default for next compilation.
167 Sometimes it is useful for files to supply local values for this variable.
168 You might also use mode hooks to specify it in certain modes, like this:
171 '(lambda () (or (file-exists-p \"makefile\") (file-exists-p \"Makefile\")
172 (progn (make-local-variable 'compile-command)
173 (setq compile-command
175 buffer-file-name))))))")
177 (defconst compilation-enter-directory-regexp
178 ": Entering directory `\\(.*\\)'$"
179 "Regular expression matching lines that indicate a new current directory.
180 This must contain one \\(, \\) pair around the directory name.
182 The default value matches lines printed by the `-w' option of GNU Make.")
184 (defconst compilation-leave-directory-regexp
185 ": Leaving directory `\\(.*\\)'$"
186 "Regular expression matching lines that indicate restoring current directory.
187 This may contain one \\(, \\) pair around the name of the directory
188 being moved from. If it does not, the last directory entered \(by a
189 line matching `compilation-enter-directory-regexp'\) is assumed.
191 The default value matches lines printed by the `-w' option of GNU Make.")
193 (defvar compilation-directory-stack nil
194 "Stack of previous directories for `compilation-leave-directory-regexp'.
195 The head element is the directory the compilation was started in.")
197 ;; History of compile commands.
198 (defvar compile-history nil)
199 ;; History of grep commands.
200 (defvar grep-history nil)
203 (defun compile (command)
204 "Compile the program including the current buffer. Default: run `make'.
205 Runs COMMAND, a shell command, in a separate process asynchronously
206 with output going to the buffer `*compilation*'.
208 You can then use the command \\[next-error] to find the next error message
209 and move to the source code that caused it.
211 To run more than one compilation at once, start one and rename the
212 \`*compilation*' buffer to some other name with \\[rename-buffer].
213 Then start the next one.
215 The name used for the buffer is actually whatever is returned by
216 the function in `compilation-buffer-name-function', so you can set that
217 to a function that generates a unique name."
218 (interactive (list (read-from-minibuffer "Compile command: "
219 compile-command nil nil
220 '(compile-history . 1))))
221 (setq compile-command command)
222 (save-some-buffers nil nil)
223 (compile-internal compile-command "No more errors"))
226 (defun grep (command-args)
227 "Run grep, with user-specified args, and collect output in a buffer.
228 While grep runs asynchronously, you can use the \\[next-error] command
229 to find the text that grep hits refer to.
231 This command uses a special history list for its arguments, so you can
232 easily repeat a grep command."
234 (list (read-from-minibuffer "Run grep (like this): "
235 "grep -n " nil nil 'grep-history)))
236 (compile-internal (concat command-args " /dev/null")
237 "No more grep hits" "grep"
238 ;; Give it a simpler regexp to match.
239 nil grep-regexp-alist))
241 (defun compile-internal (command error-message
242 &optional name-of-mode parser regexp-alist
244 "Run compilation command COMMAND (low level interface).
245 ERROR-MESSAGE is a string to print if the user asks to see another error
246 and there are no more errors. Third argument NAME-OF-MODE is the name
247 to display as the major mode in the compilation buffer.
249 Fourth arg PARSER is the error parser function (nil means the default). Fifth
250 arg REGEXP-ALIST is the error message regexp alist to use (nil means the
251 default). Sixth arg NAME-FUNCTION is a function called to name the buffer (nil
252 means the default). The defaults for these variables are the global values of
253 \`compilation-parse-errors-function', `compilation-error-regexp-alist', and
254 \`compilation-buffer-name-function', respectively.
256 Returns the compilation buffer created."
260 (setq name-of-mode "Compilation"))
263 (funcall (or name-function compilation-buffer-name-function
264 (function (lambda (mode)
265 (concat "*" (downcase mode) "*"))))
268 (let ((comp-proc (get-buffer-process (current-buffer))))
270 (if (or (not (eq (process-status comp-proc) 'run))
272 (format "A %s process is running; kill it? "
276 (interrupt-process comp-proc)
278 (delete-process comp-proc))
280 (error "Cannot have two processes in `%s' at once"
283 ;; In case the compilation buffer is current, make sure we get the global
284 ;; values of compilation-error-regexp-alist, etc.
285 (kill-all-local-variables))
286 (let ((regexp-alist (or regexp-alist compilation-error-regexp-alist))
287 (parser (or parser compilation-parse-errors-function))
288 (thisdir default-directory)
291 ;; Clear out the compilation buffer and make it writable.
292 ;; Change its default-directory to the directory where the compilation
293 ;; will happen, and insert a `cd' command to indicate this.
295 (setq buffer-read-only nil)
297 (setq default-directory thisdir)
298 (insert "cd " thisdir "\n" command "\n")
299 (set-buffer-modified-p nil))
300 ;; If we're already in the compilation buffer, go to the end
301 ;; of the buffer, so point will track the compilation output.
302 (if (eq outbuf (current-buffer))
303 (goto-char (point-max)))
304 ;; Pop up the compilation buffer.
305 (setq outwin (display-buffer outbuf))
309 (buffer-disable-undo (current-buffer))
310 (setq buffer-read-only t)
311 (set (make-local-variable 'compilation-parse-errors-function) parser)
312 (set (make-local-variable 'compilation-error-message) error-message)
313 (set (make-local-variable 'compilation-error-regexp-alist) regexp-alist)
314 (setq default-directory thisdir
315 compilation-directory-stack (list default-directory))
316 (set-window-start outwin (point-min))
317 (setq mode-name name-of-mode)
318 (or (eq outwin (selected-window))
319 (set-window-point outwin (point-min)))
320 (and compilation-window-height
321 (= (window-width outwin) (frame-width))
322 (let ((w (selected-window)))
325 (select-window outwin)
326 (enlarge-window (- compilation-window-height
329 ;; Start the compilation.
330 (let ((proc (start-process-shell-command (downcase mode-name)
333 (set-process-sentinel proc 'compilation-sentinel)
334 (set-process-filter proc 'compilation-filter)
335 (set-marker (process-mark proc) (point) outbuf)
336 (setq compilation-in-progress (cons proc compilation-in-progress)))))
337 ;; Make it so the next C-x ` will use this buffer.
338 (setq compilation-last-buffer outbuf)))
340 (defvar compilation-minor-mode-map
341 (let ((map (make-sparse-keymap)))
342 (define-key map "\C-c\C-c" 'compile-goto-error)
343 (define-key map "\C-c\C-k" 'kill-compilation)
344 (define-key map "\M-n" 'compilation-next-error)
345 (define-key map "\M-p" 'compilation-previous-error)
346 (define-key map "\M-{" 'compilation-previous-file)
347 (define-key map "\M-}" 'compilation-next-file)
349 "Keymap for `compilation-minor-mode'.")
351 (defvar compilation-mode-map
352 (let ((map (cons 'keymap compilation-minor-mode-map)))
353 (define-key map " " 'scroll-up)
354 (define-key map "\^?" 'scroll-down)
356 "Keymap for compilation log buffers.
357 `compilation-minor-mode-map' is a cdr of this.")
359 (defun compilation-mode ()
360 "Major mode for compilation log buffers.
361 \\<compilation-mode-map>To visit the source for a line-numbered error,
362 move point to the error message line and type \\[compile-goto-error].
363 To kill the compilation, type \\[kill-compilation].
365 Runs `compilation-mode-hook' with `run-hooks' (which see)."
368 (use-local-map compilation-mode-map)
369 (setq major-mode 'compilation-mode
370 mode-name "Compilation")
372 (run-hooks 'compilation-mode-hook))
374 ;; Prepare the buffer for the compilation parsing commands to work.
375 (defun compilation-setup ()
376 ;; Make the buffer's mode line show process state.
377 (setq mode-line-process '(": %s"))
378 (set (make-local-variable 'compilation-error-list) nil)
379 (set (make-local-variable 'compilation-old-error-list) nil)
380 (set (make-local-variable 'compilation-parsing-end) 1)
381 (set (make-local-variable 'compilation-directory-stack) nil)
382 (setq compilation-last-buffer (current-buffer)))
384 (defvar compilation-minor-mode nil
385 "Non-nil when in compilation-minor-mode.
386 In this minor mode, all the error-parsing commands of the
387 Compilation major mode are available.")
389 (or (assq 'compilation-minor-mode minor-mode-alist)
390 (setq minor-mode-alist (cons '(compilation-minor-mode " Compilation")
392 (or (assq 'compilation-minor-mode minor-mode-map-alist)
393 (setq minor-mode-map-alist (cons (cons 'compilation-minor-mode
394 compilation-minor-mode-map)
395 minor-mode-map-alist)))
397 (defun compilation-minor-mode (&optional arg)
398 "Toggle compilation minor mode.
399 With arg, turn compilation mode on if and only if arg is positive.
400 See `compilation-mode'."
402 (if (setq compilation-minor-mode (if (null arg)
403 (null compilation-minor-mode)
404 (> (prefix-numeric-value arg) 0)))
405 (compilation-setup)))
407 ;; Called when compilation process changes state.
408 (defun compilation-sentinel (proc msg)
409 "Sentinel for compilation buffers."
410 (let ((buffer (process-buffer proc)))
411 (if (memq (process-status proc) '(signal exit))
413 (if (null (buffer-name buffer))
415 (set-process-buffer proc nil)
416 (let ((obuf (current-buffer))
418 ;; save-excursion isn't the right thing if
419 ;; process-buffer is current-buffer
422 ;; Write something in the compilation buffer
423 ;; and hack its mode line.
425 (let ((buffer-read-only nil))
426 (setq omax (point-max)
429 ;; Record where we put the message, so we can ignore it
431 (insert ?\n mode-name " " msg)
433 (insert " at " (substring (current-time-string) 0 19))
435 (setq mode-line-process
437 (symbol-name (process-status proc))))
438 ;; Since the buffer and mode line will show that the
439 ;; process is dead, we can delete it now. Otherwise it
440 ;; will stay around until M-x list-processes.
441 (delete-process proc)
442 ;; Force mode line redisplay soon.
443 (set-buffer-modified-p (buffer-modified-p)))
444 (if (and opoint (< opoint omax))
446 (if compilation-finish-function
447 (funcall compilation-finish-function buffer msg)))
449 (setq compilation-in-progress (delq proc compilation-in-progress))
452 (defun compilation-filter (proc string)
453 "Process filter for compilation buffers.
454 Just inserts the text, but uses `insert-before-markers'."
456 (set-buffer (process-buffer proc))
457 (let ((buffer-read-only nil))
459 (goto-char (process-mark proc))
460 (insert-before-markers string)
461 (set-marker (process-mark proc) (point))))))
463 ;; Return the cdr of compilation-old-error-list for the error containing point.
464 (defun compile-error-at-point ()
465 (compile-reinitialize-errors nil (point))
466 (let ((errors compilation-old-error-list))
468 (> (point) (car (car errors))))
469 (setq errors (cdr errors)))
472 (defun compilation-next-error (n)
473 "Move point to the next error in the compilation buffer.
474 Does NOT find the source line like \\[next-error]."
476 (or (compilation-buffer-p (current-buffer))
477 (error "Not in a compilation buffer."))
478 (setq compilation-last-buffer (current-buffer))
480 (let ((errors (compile-error-at-point)))
482 ;; Move to the error after the one containing point.
483 (goto-char (car (if (< n 0)
485 (e compilation-old-error-list))
486 ;; See how many cdrs away ERRORS is from the start.
487 (while (not (eq e errors))
491 (error "Moved back past first error")
492 (nth (+ i n) compilation-old-error-list)))
493 (let ((compilation-error-list (cdr errors)))
494 (compile-reinitialize-errors nil nil n)
495 (if compilation-error-list
496 (nth (1- n) compilation-error-list)
497 (error "Moved past last error"))))))))
499 (defun compilation-previous-error (n)
500 "Move point to the previous error in the compilation buffer.
501 Does NOT find the source line like \\[next-error]."
503 (compilation-next-error (- n)))
506 (defun compile-file-of-error (data)
507 (setq data (cdr data))
509 (buffer-file-name (marker-buffer data))
512 (defun compilation-next-file (n)
513 "Move point to the next error for a different file than the current one."
515 (or (compilation-buffer-p (current-buffer))
516 (error "Not in a compilation buffer."))
517 (setq compilation-last-buffer (current-buffer))
519 (let ((reversed (< n 0))
523 (setq errors (or (compile-error-at-point)
524 (error "Moved past last error")))
526 ;; Get a reversed list of the errors up through the one containing point.
527 (compile-reinitialize-errors nil (point))
528 (setq errors (reverse compilation-old-error-list)
531 ;; Ignore errors after point. (car ERRORS) will be the error
532 ;; containing point, (cadr ERRORS) the one before it.
534 (< (point) (car (car errors))))
535 (setq errors (cdr errors))))
538 (setq file (compile-file-of-error (car errors)))
540 ;; Skip past the other errors for this file.
542 (compile-file-of-error
545 (error "%s the first erring file" file)
546 (let ((compilation-error-list nil))
548 (compile-reinitialize-errors nil nil 2)
549 (setq errors compilation-error-list)))
550 (error "%s is the last erring file" file)))))
551 (setq errors (cdr errors)))
555 ;; Move to the following error.
556 (goto-char (car (car (or errors
558 (error "This is the first erring file")
559 (let ((compilation-error-list nil))
560 ;; Parse the last one.
561 (compile-reinitialize-errors nil nil 1)
562 compilation-error-list))))))))
564 (defun compilation-previous-file (n)
565 "Move point to the previous error for a different file than the current one."
567 (compilation-next-file (- n)))
570 (defun kill-compilation ()
571 "Kill the process made by the \\[compile] command."
573 (let ((buffer (compilation-find-buffer)))
574 (if (get-buffer-process buffer)
575 (interrupt-process (get-buffer-process buffer))
576 (error "The compilation process is not running."))))
579 ;; Parse any new errors in the compilation buffer,
580 ;; or reparse from the beginning if the user has asked for that.
581 (defun compile-reinitialize-errors (argp &optional limit-search find-at-least)
583 (set-buffer compilation-last-buffer)
584 ;; If we are out of errors, or if user says "reparse",
585 ;; discard the info we have, to force reparsing.
586 (if (or (eq compilation-error-list t)
588 (progn (compilation-forget-errors)
589 (setq compilation-parsing-end 1)))
590 (if (and compilation-error-list
591 (or (not limit-search)
592 (> compilation-parsing-end limit-search))
593 (or (not find-at-least)
594 (> (length compilation-error-list) find-at-least)))
595 ;; Since compilation-error-list is non-nil, it points to a specific
596 ;; error the user wanted. So don't move it around.
598 (switch-to-buffer compilation-last-buffer)
599 (set-buffer-modified-p nil)
600 (if (< compilation-parsing-end (point-max))
601 (let ((at-start (= compilation-parsing-end 1)))
602 (funcall compilation-parse-errors-function
603 limit-search find-at-least)
604 ;; Remember the entire list for compilation-forget-errors.
605 ;; If this is an incremental parse, append to previous list.
607 (setq compilation-old-error-list compilation-error-list)
608 (setq compilation-old-error-list
609 (nconc compilation-old-error-list compilation-error-list)))
612 (defun compile-goto-error (&optional argp)
613 "Visit the source for the error message point is on.
614 Use this command in a compilation log buffer.
615 \\[universal-argument] as a prefix arg means to reparse the buffer's error messages first;
616 other kinds of prefix arguments are ignored."
618 (or (compilation-buffer-p (current-buffer))
619 (error "Not in a compilation buffer."))
620 (setq compilation-last-buffer (current-buffer))
621 (compile-reinitialize-errors argp (point))
623 ;; Move to bol; the marker for the error on this line will point there.
626 ;; Move compilation-error-list to the elt of compilation-old-error-list
628 (setq compilation-error-list compilation-old-error-list)
629 (while (and compilation-error-list
630 (> (point) (car (car compilation-error-list))))
631 (setq compilation-error-list (cdr compilation-error-list)))
633 ;; Move to another window, so that next-error's window changes
634 ;; result in the desired setup.
638 ;; other-window changed the selected buffer,
639 ;; but we didn't want to do that.
640 (set-buffer compilation-last-buffer)))
644 (defun compilation-buffer-p (buffer)
645 (assq 'compilation-error-list (buffer-local-variables buffer)))
647 ;; Return a compilation buffer.
648 ;; If the current buffer is a compilation buffer, return it.
649 ;; If compilation-last-buffer is set to a live buffer, use that.
650 ;; Otherwise, look for a compilation buffer and signal an error
651 ;; if there are none.
652 (defun compilation-find-buffer (&optional other-buffer)
653 (if (and (not other-buffer)
654 (compilation-buffer-p (current-buffer)))
655 ;; The current buffer is a compilation buffer.
657 (if (and compilation-last-buffer (buffer-name compilation-last-buffer)
658 (or (not other-buffer) (not (eq compilation-last-buffer
660 compilation-last-buffer
661 (let ((buffers (buffer-list)))
662 (while (and buffers (or (not (compilation-buffer-p (car buffers)))
664 (eq (car buffers) (current-buffer)))))
665 (setq buffers (cdr buffers)))
668 (or (and other-buffer
669 (compilation-buffer-p (current-buffer))
670 ;; The current buffer is a compilation buffer.
673 (message "This is the only compilation buffer."))
675 (error "No compilation started!")))))))
678 (defun next-error (&optional argp)
679 "Visit next compilation error message and corresponding source code.
680 This operates on the output from the \\[compile] command.
681 If all preparsed error messages have been processed,
682 the error message buffer is checked for new ones.
684 A prefix arg specifies how many error messages to move;
685 negative means move back to previous error messages.
686 Just C-u as a prefix means reparse the error message buffer
687 and start at the first error.
689 \\[next-error] normally applies to the most recent compilation started,
690 but as long as you are in the middle of parsing errors from one compilation
691 output buffer, you stay with that compilation output buffer.
693 Use \\[next-error] in a compilation output buffer to switch to
694 processing errors from that compilation.
696 See variables `compilation-parse-errors-function' and
697 \`compilation-error-regexp-alist' for customization ideas."
699 (setq compilation-last-buffer (compilation-find-buffer))
700 (compile-reinitialize-errors argp nil
701 ;; We want to pass a number here only if
702 ;; we got a numeric prefix arg, not just C-u.
703 (and (not (consp argp))
704 (1- (prefix-numeric-value argp))))
705 ;; Make ARGP nil if the prefix arg was just C-u,
706 ;; since that means to reparse the errors, which the
707 ;; compile-reinitialize-errors call just did.
708 ;; Now we are only interested in a numeric prefix arg.
711 (let (next-errors next-error)
713 (set-buffer compilation-last-buffer)
714 ;; compilation-error-list points to the "current" error.
715 (setq next-errors (nthcdr (1- (prefix-numeric-value argp))
716 compilation-error-list)
717 next-error (car next-errors))
720 (if (null next-error)
722 (if argp (if (> (prefix-numeric-value argp) 0)
723 (error "Moved past last error")
724 (error "Moved back past first error")))
725 (compilation-forget-errors)
726 (error (concat compilation-error-message
727 (and (get-buffer-process (current-buffer))
733 (setq compilation-error-list (cdr next-errors))
734 (if (null (cdr next-error))
735 ;; This error is boring. Go to the next.
737 (or (markerp (cdr next-error))
738 ;; This error has a filename/lineno pair.
739 ;; Find the file and turn it into a marker.
741 (cons (file-name-directory (car (cdr next-error)))
742 (file-name-nondirectory
743 (car (cdr next-error)))))
744 (buffer (compilation-find-file (cdr fileinfo)
748 ;; We can't find this error's file.
749 ;; Remove all errors in the same file.
751 (setq next-errors compilation-old-error-list)
753 (and (consp (cdr (car next-errors)))
754 (equal (car (cdr (car next-errors)))
757 (set-marker (car (car next-errors)) nil)
758 (setcdr (car next-errors) nil)))
759 (setq next-errors (cdr next-errors)))
760 ;; Look for the next error.
762 ;; We found the file. Get a marker for this error.
763 ;; compilation-old-error-list is a buffer-local
764 ;; variable, so we must be careful to extract its value
765 ;; before switching to the source file buffer.
766 (let ((errors compilation-old-error-list)
767 (last-line (cdr (cdr next-error))))
772 (goto-line last-line)
774 (setcdr next-error (point-marker))
775 ;; Make all the other error messages referring
776 ;; to the same file have markers into the buffer.
778 (and (consp (cdr (car errors)))
779 (equal (car (cdr (car errors))) fileinfo)
780 (let ((this (cdr (cdr (car errors))))
781 (lines (- (cdr (cdr (car errors)))
783 (if (eq selective-display t)
785 (re-search-backward "[\n\C-m]"
788 (re-search-forward "[\n\C-m]"
791 (forward-line lines))
792 (setq last-line this)
793 (setcdr (car errors) (point-marker))))
794 (setq errors (cdr errors)))))))))
795 ;; If we didn't get a marker for this error,
796 ;; go on to the next one.
797 (not (markerp (cdr next-error))))))
798 (setq next-errors compilation-error-list
799 next-error (car next-errors))))
801 ;; Skip over multiple error messages for the same source location,
802 ;; so the next C-x ` won't go to an error in the same place.
803 (while (and compilation-error-list
804 (equal (cdr (car compilation-error-list)) (cdr next-error)))
805 (setq compilation-error-list (cdr compilation-error-list)))
807 ;; We now have a marker for the position of the error.
808 (switch-to-buffer (marker-buffer (cdr next-error)))
809 (goto-char (cdr next-error))
810 ;; If narrowing got in the way of
811 ;; going to the right place, widen.
812 (or (= (point) (marker-position (cdr next-error)))
815 (goto-char (cdr next-error))))
817 ;; Show compilation buffer in other window, scrolled to this error.
818 (let* ((pop-up-windows t)
819 (w (display-buffer (marker-buffer (car next-error)))))
820 (set-window-point w (car next-error))
821 (set-window-start w (car next-error)))))
824 (define-key ctl-x-map "`" 'next-error)
826 ;; Find a buffer for file FILENAME.
827 ;; Search the directories in compilation-search-path.
828 ;; A nil in compilation-search-path means to try the
829 ;; current directory, which is passed in DIR.
830 ;; If FILENAME is not found at all, ask the user where to find it.
831 ;; Pop up the buffer containing MARKER and scroll to MARKER if we ask the user.
832 (defun compilation-find-file (filename dir marker)
833 (let ((dirs compilation-search-path)
835 (while (and dirs (null result))
836 (setq name (expand-file-name filename (or (car dirs) dir))
837 result (and (file-exists-p name)
838 (find-file-noselect name))
841 ;; The file doesn't exist.
842 ;; Ask the user where to find it.
843 ;; If he hits C-g, then the next time he does
844 ;; next-error, he'll skip past it.
846 (let* ((pop-up-windows t)
847 (w (display-buffer (marker-buffer marker))))
848 (set-window-point w marker)
849 (set-window-start w marker))
853 (format "Find this error in: (default %s) "
854 filename) dir filename t)))
855 (if (file-directory-p name)
856 (setq name (concat (file-name-as-directory name) filename)))
857 (if (file-exists-p name)
858 (find-file-noselect name))))))
860 ;; Set compilation-error-list to nil, and unchain the markers that point to the
861 ;; error messages and their text, so that they no longer slow down gap motion.
862 ;; This would happen anyway at the next garbage collection, but it is better to
864 (defun compilation-forget-errors ()
865 (while compilation-old-error-list
866 (let ((next-error (car compilation-old-error-list)))
867 (set-marker (car next-error) nil)
868 (if (markerp (cdr next-error))
869 (set-marker (cdr next-error) nil)))
870 (setq compilation-old-error-list (cdr compilation-old-error-list)))
871 (setq compilation-error-list nil
872 compilation-directory-stack nil))
875 (defun count-regexp-groupings (regexp)
876 "Return the number of \\( ... \\) groupings in REGEXP (a string)."
878 (len (length regexp))
882 (setq c (aref regexp i)
885 ;; Find the end of this [...].
886 (while (and (< i len)
887 (not (= (aref regexp i) ?\])))
892 (setq c (aref regexp i)
895 ;; We found the end of a grouping,
896 ;; so bump our counter.
897 (setq groupings (1+ groupings))))))))
900 (defun compilation-parse-errors (limit-search find-at-least)
901 "Parse the current buffer as grep, cc or lint error messages.
902 See variable `compilation-parse-errors-function' for the interface it uses."
903 (setq compilation-error-list nil)
904 (message "Parsing error messages...")
906 regexp enter-group leave-group error-group
907 alist subexpr error-regexp-groups
909 (compilation-num-errors-found 0))
911 ;; Don't reparse messages already seen at last parse.
912 (goto-char compilation-parsing-end)
913 ;; Don't parse the first two lines as error messages.
914 ;; This matters for grep.
918 ;; Compile all the regexps we want to search for into one.
919 (setq regexp (concat "\\(" compilation-enter-directory-regexp "\\)\\|"
920 "\\(" compilation-leave-directory-regexp "\\)\\|"
921 "\\(" (mapconcat (function
923 (concat "\\(" (car elt) "\\)")))
924 compilation-error-regexp-alist
927 ;; Find out how many \(...\) groupings are in each of the regexps, and set
928 ;; *-GROUP to the grouping containing each constituent regexp (whose
929 ;; subgroups will come immediately thereafter) of the big regexp we have
932 leave-group (+ enter-group
933 (count-regexp-groupings
934 compilation-enter-directory-regexp)
936 error-group (+ leave-group
937 (count-regexp-groupings
938 compilation-leave-directory-regexp)
941 ;; Compile an alist (IDX FILE LINE), where IDX is the number of the
942 ;; subexpression for an entire error-regexp, and FILE and LINE are the
943 ;; numbers for the subexpressions giving the file name and line number.
944 (setq alist (or compilation-error-regexp-alist
945 (error "compilation-error-regexp-alist is empty!"))
946 subexpr (1+ error-group))
948 (setq error-regexp-groups (cons (list subexpr
949 (+ subexpr (nth 1 (car alist)))
950 (+ subexpr (nth 2 (car alist))))
951 error-regexp-groups))
952 (setq subexpr (+ subexpr 1 (count-regexp-groupings (car (car alist)))))
953 (setq alist (cdr alist)))
955 (while (and (not found-desired)
956 ;; We don't just pass LIMIT-SEARCH to re-search-forward
957 ;; because we want to find matches containing LIMIT-SEARCH
958 ;; but which extend past it.
959 (re-search-forward regexp nil t))
961 ;; Figure out which constituent regexp matched.
962 (cond ((match-beginning enter-group)
963 ;; The match was the enter-directory regexp.
965 (file-name-as-directory
967 (buffer-substring (match-beginning (+ enter-group 1))
968 (match-end (+ enter-group 1)))))))
969 (setq compilation-directory-stack
970 (cons dir compilation-directory-stack))
971 (and (file-directory-p dir)
972 (setq default-directory dir))))
974 ((match-beginning leave-group)
975 ;; The match was the leave-directory regexp.
976 (let ((beg (match-beginning (+ leave-group 1)))
977 (stack compilation-directory-stack))
980 (file-name-as-directory
982 (buffer-substring beg
983 (match-end (+ leave-group
986 (not (string-equal (car stack) dir)))
987 (setq stack (cdr stack)))))
988 (setq compilation-directory-stack (cdr stack))
989 (setq stack (car compilation-directory-stack))
991 (setq default-directory stack))
994 ((match-beginning error-group)
995 ;; The match was the composite error regexp.
996 ;; Find out which individual regexp matched.
997 (setq alist error-regexp-groups)
999 (null (match-beginning (car (car alist)))))
1000 (setq alist (cdr alist)))
1002 (setq alist (car alist))
1003 (error "compilation-parse-errors: impossible regexp match!"))
1005 ;; Extract the file name and line number from the error message.
1006 (let ((beginning-of-match (match-beginning 0)) ;looking-at nukes
1009 (goto-char (match-end (nth 1 alist)))
1010 (skip-chars-backward " \t")
1011 (let ((name (buffer-substring (match-beginning (nth 1 alist))
1013 (expand-file-name name default-directory))))
1014 (linenum (save-restriction
1016 (match-beginning (nth 2 alist))
1017 (match-end (nth 2 alist)))
1018 (goto-char (point-min))
1019 (if (looking-at "[0-9]")
1020 (read (current-buffer))))))
1021 ;; Locate the erring file and line.
1022 ;; Cons a new elt onto compilation-error-list,
1023 ;; giving a marker for the current compilation buffer
1024 ;; location, and the file and line number of the error.
1026 (beginning-of-line 1)
1027 (setq compilation-error-list
1028 (cons (cons (point-marker)
1029 (cons filename linenum))
1030 compilation-error-list)))
1031 (setq compilation-num-errors-found
1032 (1+ compilation-num-errors-found))
1033 (and find-at-least (>= compilation-num-errors-found
1035 ;; We have found as many new errors as the user wants.
1036 ;; We continue to parse until we have seen all
1037 ;; the consecutive errors in the same file,
1038 ;; so the error positions will be recorded as markers
1039 ;; in this buffer that might change.
1040 (cdr compilation-error-list) ; Must check at least two.
1041 (not (equal (car (cdr (nth 0 compilation-error-list)))
1042 (car (cdr (nth 1 compilation-error-list)))))
1044 ;; Discard the error just parsed, so that the next
1045 ;; parsing run can get it and the following errors in
1046 ;; the same file all at once. If we didn't do this, we
1047 ;; would have the same problem we are trying to avoid
1048 ;; with the test above, just delayed until the next run!
1049 (setq compilation-error-list
1050 (cdr compilation-error-list))
1051 (goto-char beginning-of-match)
1052 (setq found-desired t)))
1056 (error "compilation-parse-errors: known groups didn't match!")))
1058 (message "Parsing error messages...%d (%d%% of buffer)"
1059 compilation-num-errors-found
1060 (/ (* 100 (point)) (point-max)))
1062 (and limit-search (>= (point) limit-search)
1063 ;; The user wanted a specific error, and we're past it.
1064 (setq found-desired t)))
1065 (setq compilation-parsing-end (if found-desired
1067 ;; We have searched the whole buffer.
1069 (setq compilation-error-list (nreverse compilation-error-list))
1070 (message "Parsing error messages...done"))
1074 ;;; compile.el ends here