1 ;;; compile.el --- run compiler as inferior of Emacs, parse error messages.
3 ;; Copyright (C) 1985, 86, 87, 93, 94, 1995 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 (defvar 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 pointing to
43 an error message. If its cdr is a marker, it points to the text of the
44 line the message is about. If its cdr is a cons, it is a list
45 \(\(DIRECTORY . FILE\) LINE [COLUMN]\). Or its cdr may be nil if that
46 error is not interesting.
48 The value may be t instead of a list; this means that the buffer of
49 error messages should be reparsed the next time the list of errors is wanted.
51 Some other commands (like `diff') use this list to control the error
52 message tracking facilities; if you change its structure, you should make
53 sure you also change those packages. Perhaps it is better not to change
56 (defvar compilation-old-error-list nil
57 "Value of `compilation-error-list' after errors were parsed.")
59 (defvar compilation-parse-errors-function 'compilation-parse-errors
60 "Function to call to parse error messages from a compilation.
61 It takes args LIMIT-SEARCH and FIND-AT-LEAST.
62 If LIMIT-SEARCH is non-nil, don't bother parsing past that location.
63 If FIND-AT-LEAST is non-nil, don't bother parsing after finding that
65 It should read in the source files which have errors and set
66 `compilation-error-list' to a list with an element for each error message
67 found. See that variable for more info.")
70 (defvar compilation-buffer-name-function nil
71 "Function to compute the name of a compilation buffer.
72 The function receives one argument, the name of the major mode of the
73 compilation buffer. It should return a string.
74 nil means compute the name with `(concat \"*\" (downcase major-mode) \"*\")'.")
77 (defvar compilation-finish-function nil
78 "*Function to call when a compilation process finishes.
79 It is called with two arguments: the compilation buffer, and a string
80 describing how the process finished.")
82 (defvar compilation-last-buffer nil
83 "The most recent compilation buffer.
84 A buffer becomes most recent when its compilation is started
85 or when it is used with \\[next-error] or \\[compile-goto-error].")
87 (defvar compilation-in-progress nil
88 "List of compilation processes now running.")
89 (or (assq 'compilation-in-progress minor-mode-alist)
90 (setq minor-mode-alist (cons '(compilation-in-progress " Compiling")
93 (defvar compilation-parsing-end nil
94 "Position of end of buffer when last error messages were parsed.")
96 (defvar compilation-error-message "No more errors"
97 "Message to print when no more matches are found.")
99 (defvar compilation-num-errors-found)
101 (defvar compilation-error-regexp-alist
103 ;; NOTE! See also grep-regexp-alist, below.
105 ;; 4.3BSD grep, cc, lint pass 1:
106 ;; /usr/src/foo/foo.c(8): warning: w may be used before set
108 ;; foo.c:8: error message
110 ;; foo.f :16 some horrible error message
111 ;; or GNU utilities with column (GNAT 1.82):
112 ;; foo.adb:2:1: Unit name does not match file name
114 ;; We'll insist that the number be followed by a colon or closing
115 ;; paren, because otherwise this matches just about anything
116 ;; containing a number with spaces around it.
118 \\([^:( \t\n]+\\)[:(][ \t]*\\([0-9]+\\)\\([) \t]\\|\
119 :\\([^0-9\n]\\|\\([0-9]+:\\)\\)\\)" 1 2 5)
122 ;; Error ping.c 15: Unable to open include file 'sys/types.h'
123 ;; Warning ping.c 68: Call to function 'func' with no prototype
124 ("\n\\(Error\\|Warning\\) \\([^:( \t\n]+\\)\
125 \\([0-9]+\\)\\([) \t]\\|:[^0-9\n]\\)" 2 3)
127 ;; 4.3BSD lint pass 2
128 ;; strcmp: variable # of args. llib-lc(359) :: /usr/src/foo/foo.c(8)
129 ("[ \t:]\\([^:( \t\n]+\\)[:(](+[ \t]*\\([0-9]+\\))[:) \t]*$" 1 2)
131 ;; 4.3BSD lint pass 3
132 ;; bloofle defined( /users/wolfgang/foo.c(4) ), but never used
134 ;; ("[ \t(]+\\([^:( \t\n]+\\)[:( \t]+\\([0-9]+\\)[:) \t]+" 1 2)
135 ;; which is regexp Impressionism - it matches almost anything!
136 ("([ \t]*\\([^:( \t\n]+\\)[:(][ \t]*\\([0-9]+\\))" 1 2)
139 ;; fort: Severe: addstf.f, line 82: Missing operator or delimiter symbol
140 ;; Some SGI cc version:
141 ;; cfe: Warning 835: foo.c, line 2: something
142 ("\n\\(cfe\\|fort\\): [^:\n]*: \\([^ \n]*\\), line \\([0-9]+\\):" 2 3)
143 ;; Error on line 3 of t.f: Execution error unclassifiable statement
144 ;; Unknown who does this:
145 ;; Line 45 of "foo.c": bloofle undefined
146 ;; Absoft FORTRAN 77 Compiler 3.1.3
147 ;; error on line 19 of fplot.f: spelling error?
148 ;; warning on line 17 of fplot.f: data type is undefined for variable d
149 ("\\(\n\\|on \\)[Ll]ine[ \t]+\\([0-9]+\\)[ \t]+\
150 of[ \t]+\"?\\([^\":\n]+\\)\"?:" 3 2)
152 ;; Apollo cc, 4.3BSD fc:
153 ;; "foo.f", line 3: Error: syntax error near end of statement
155 ;; "vvouch.c", line 19.5: 1506-046 (S) Syntax error.
157 ;; File "foobar.ml", lines 5-8, characters 20-155: blah blah
159 ;; "foo.c", line 32 pos 1; (E) syntax error; unexpected symbol: "lossage"
160 ;; GNAT (as of July 94):
161 ;; "foo.adb", line 2(11): warning: file name does not match ...
162 ("\"\\([^,\" \n\t]+\\)\", lines? \\([0-9]+\\)[:., (-]" 1 2)
164 ;; MIPS RISC CC - the one distributed with Ultrix:
165 ;; ccom: Error: foo.c, line 2: syntax error
167 ;; /usr/lib/cmplrs/cc/cfe: Error: foo.c: 1: blah blah
168 ("rror: \\([^,\" \n\t]+\\)[,:] \\(line \\)?\\([0-9]+\\):" 1 3)
170 ;; IBM AIX PS/2 C version 1.1:
171 ;; ****** Error number 140 in line 8 of file errors.c ******
172 ("in line \\([0-9]+\\) of file \\([^ \n]+[^. \n]\\)\\.? " 2 1)
173 ;; IBM AIX lint is too painful to do right this way. File name
174 ;; prefixes entire sections rather than being on each line.
176 ;; Lucid Compiler, lcc 3.x
177 ;; E, file.cc(35,52) Illegal operation on pointers
178 ("\n[EW], \\([^(\n]*\\)(\\([0-9]+\\),[ \t]*\\([0-9]+\\)" 1 2 3)
180 ;; GNU messages with program name and optional column number.
181 ("\n[^0-9 \n\t:]+:[ \t]*\\([^ \n\t:]+\\):\
182 \\([0-9]+\\):\\(\\([0-9]+\\)[: \t]\\)?" 1 2 4)
184 ;; Cray C compiler error messages
185 ("\n\\(cc\\| cft\\)-[0-9]+ c\\(c\\|f77\\): ERROR \\([^,\n]+, \\)* File = \\([^,\n]+\\), Line = \\([0-9]+\\)" 4 5)
187 ;; IBM C/C++ Tools 2.01:
188 ;; foo.c(2:0) : informational EDC0804: Function foo is not referenced.
189 ;; foo.c(3:8) : warning EDC0833: Implicit return statement encountered.
190 ;; foo.c(5:5) : error EDC0350: Syntax error.
191 ("\n\\([^( \n\t]+\\)(\\([0-9]+\\):\\([0-9]+\\)) : " 1 2 3)
193 ;; Sun ada (VADS, Solaris):
194 ;; /home3/xdhar/rcds_rc/main.a, line 361, char 6:syntax error: "," inserted
195 ("\n\\([^, ]+\\), line \\([0-9]+\\), char \\([0-9]+\\)[:., \(-]" 1 2 3)
197 "Alist that specifies how to match errors in compiler output.
198 Each elt has the form (REGEXP FILE-IDX LINE-IDX [COLUMN-IDX FILE-FORMAT...])
199 If REGEXP matches, the FILE-IDX'th subexpression gives the file name, and
200 the LINE-IDX'th subexpression gives the line number. If COLUMN-IDX is
201 given, the COLUMN-IDX'th subexpression gives the column number on that line.
202 If any FILE-FORMAT is given, each is a format string to produce a file name to
203 try; %s in the string is replaced by the text matching the FILE-IDX'th
206 (defvar compilation-read-command t
207 "If not nil, M-x compile reads the compilation command to use.
208 Otherwise, M-x compile just uses the value of `compile-command'.")
210 (defvar compilation-ask-about-save t
211 "If not nil, M-x compile asks which buffers to save before compiling.
212 Otherwise, it saves all modified buffers without asking.")
214 (defvar grep-regexp-alist
215 '(("^\\([^:( \t\n]+\\)[:( \t]+\\([0-9]+\\)[:) \t]" 1 2))
216 "Regexp used to match grep hits. See `compilation-error-regexp-alist'.")
218 (defvar grep-command "grep -n "
219 "Last grep command used in \\[grep]; default for next grep.")
222 (defvar compilation-search-path '(nil)
223 "*List of directories to search for source files named in error messages.
224 Elements should be directory names, not file names of directories.
225 nil as an element means to try the default directory.")
227 (defvar compile-command "make -k "
228 "Last shell command used to do a compilation; default for next compilation.
230 Sometimes it is useful for files to supply local values for this variable.
231 You might also use mode hooks to specify it in certain modes, like this:
234 '(lambda () (or (file-exists-p \"makefile\") (file-exists-p \"Makefile\")
235 (progn (make-local-variable 'compile-command)
236 (setq compile-command
238 buffer-file-name))))))")
240 (defvar compilation-enter-directory-regexp
241 ": Entering directory `\\(.*\\)'$"
242 "Regular expression matching lines that indicate a new current directory.
243 This must contain one \\(, \\) pair around the directory name.
245 The default value matches lines printed by the `-w' option of GNU Make.")
247 (defvar compilation-leave-directory-regexp
248 ": Leaving directory `\\(.*\\)'$"
249 "Regular expression matching lines that indicate restoring current directory.
250 This may contain one \\(, \\) pair around the name of the directory
251 being moved from. If it does not, the last directory entered \(by a
252 line matching `compilation-enter-directory-regexp'\) is assumed.
254 The default value matches lines printed by the `-w' option of GNU Make.")
256 (defvar compilation-directory-stack nil
257 "Stack of previous directories for `compilation-leave-directory-regexp'.
258 The head element is the directory the compilation was started in.")
260 (defvar compilation-exit-message-function nil "\
261 If non-nil, called when a compilation process dies to return a status message.
262 This should be a function a two arguments as passed to a process sentinel
263 \(see `set-process-sentinel\); it returns a cons (MESSAGE . MODELINE) of the
264 strings to write into the compilation buffer, and to put in its mode line.")
266 ;; History of compile commands.
267 (defvar compile-history nil)
268 ;; History of grep commands.
269 (defvar grep-history nil)
271 (defvar compilation-mode-font-lock-keywords
272 ;; This regexp needs a bit of rewriting. What is the third grouping for?
273 '(("^\\([^ \n:]*:\\([0-9]+:\\)+\\)\\(.*\\)$" 1 font-lock-function-name-face))
274 ;;; ("^\\([^\n:]*:\\([0-9]+:\\)+\\)\\(.*\\)$" 0 font-lock-keyword-face keep)
275 "Additional expressions to highlight in Compilation mode.")
278 (defun compile (command)
279 "Compile the program including the current buffer. Default: run `make'.
280 Runs COMMAND, a shell command, in a separate process asynchronously
281 with output going to the buffer `*compilation*'.
283 You can then use the command \\[next-error] to find the next error message
284 and move to the source code that caused it.
286 Interactively, prompts for the command if `compilation-read-command' is
287 non-nil; otherwise uses `compile-command'. With prefix arg, always prompts.
289 To run more than one compilation at once, start one and rename the
290 \`*compilation*' buffer to some other name with \\[rename-buffer].
291 Then start the next one.
293 The name used for the buffer is actually whatever is returned by
294 the function in `compilation-buffer-name-function', so you can set that
295 to a function that generates a unique name."
297 (if (or compilation-read-command current-prefix-arg)
298 (list (read-from-minibuffer "Compile command: "
299 compile-command nil nil
300 '(compile-history . 1)))
301 (list compile-command)))
302 (setq compile-command command)
303 (save-some-buffers (not compilation-ask-about-save) nil)
304 (compile-internal compile-command "No more errors"))
306 ;;; run compile with the default command line
308 "Re-compile the program including the current buffer."
310 (save-some-buffers (not compilation-ask-about-save) nil)
311 (compile-internal compile-command "No more errors"))
313 ;; The system null device. (Should reference NULL_DEVICE from C.)
314 (defvar grep-null-device "/dev/null" "The system null device.")
317 (defun grep (command-args)
318 "Run grep, with user-specified args, and collect output in a buffer.
319 While grep runs asynchronously, you can use the \\[next-error] command
320 to find the text that grep hits refer to.
322 This command uses a special history list for its arguments, so you can
323 easily repeat a grep command."
325 (list (read-from-minibuffer "Run grep (like this): "
326 grep-command nil nil 'grep-history)))
327 (let ((buf (compile-internal (concat command-args " " grep-null-device)
328 "No more grep hits" "grep"
329 ;; Give it a simpler regexp to match.
330 nil grep-regexp-alist)))
333 (set (make-local-variable 'compilation-exit-message-function)
335 (let ((code (process-exit-status proc)))
336 (if (eq (process-status proc) 'exit)
338 '("finished (matches found)\n" . "matched"))
340 '("finished with no matches found\n" . "no match"))
343 (cons msg code))))))))
345 (defun compile-internal (command error-message
346 &optional name-of-mode parser regexp-alist
348 "Run compilation command COMMAND (low level interface).
349 ERROR-MESSAGE is a string to print if the user asks to see another error
350 and there are no more errors. Third argument NAME-OF-MODE is the name
351 to display as the major mode in the compilation buffer.
353 Fourth arg PARSER is the error parser function (nil means the default). Fifth
354 arg REGEXP-ALIST is the error message regexp alist to use (nil means the
355 default). Sixth arg NAME-FUNCTION is a function called to name the buffer (nil
356 means the default). The defaults for these variables are the global values of
357 \`compilation-parse-errors-function', `compilation-error-regexp-alist', and
358 \`compilation-buffer-name-function', respectively.
360 Returns the compilation buffer created."
364 (setq name-of-mode "Compilation"))
367 (funcall (or name-function compilation-buffer-name-function
368 (function (lambda (mode)
369 (concat "*" (downcase mode) "*"))))
372 (let ((comp-proc (get-buffer-process (current-buffer))))
374 (if (or (not (eq (process-status comp-proc) 'run))
376 (format "A %s process is running; kill it? "
380 (interrupt-process comp-proc)
382 (delete-process comp-proc))
384 (error "Cannot have two processes in `%s' at once"
387 ;; In case the compilation buffer is current, make sure we get the global
388 ;; values of compilation-error-regexp-alist, etc.
389 (kill-all-local-variables))
390 (let ((regexp-alist (or regexp-alist compilation-error-regexp-alist))
391 (parser (or parser compilation-parse-errors-function))
392 (thisdir default-directory)
395 ;; Clear out the compilation buffer and make it writable.
396 ;; Change its default-directory to the directory where the compilation
397 ;; will happen, and insert a `cd' command to indicate this.
399 (setq buffer-read-only nil)
400 (buffer-disable-undo (current-buffer))
402 (buffer-enable-undo (current-buffer))
403 (setq default-directory thisdir)
404 (insert "cd " thisdir "\n" command "\n")
405 (set-buffer-modified-p nil))
406 ;; If we're already in the compilation buffer, go to the end
407 ;; of the buffer, so point will track the compilation output.
408 (if (eq outbuf (current-buffer))
409 (goto-char (point-max)))
410 ;; Pop up the compilation buffer.
411 (setq outwin (display-buffer outbuf))
415 ;; (setq buffer-read-only t) ;;; Non-ergonomic.
416 (set (make-local-variable 'compilation-parse-errors-function) parser)
417 (set (make-local-variable 'compilation-error-message) error-message)
418 (set (make-local-variable 'compilation-error-regexp-alist) regexp-alist)
419 (setq default-directory thisdir
420 compilation-directory-stack (list default-directory))
421 (set-window-start outwin (point-min))
422 (setq mode-name name-of-mode)
423 (or (eq outwin (selected-window))
424 (set-window-point outwin (point-min)))
425 (compilation-set-window-height outwin)
426 ;; Start the compilation.
427 (if (fboundp 'start-process)
428 (let* ((process-environment (cons "EMACS=t" process-environment))
429 (proc (start-process-shell-command (downcase mode-name)
432 (set-process-sentinel proc 'compilation-sentinel)
433 (set-process-filter proc 'compilation-filter)
434 (set-marker (process-mark proc) (point) outbuf)
435 (setq compilation-in-progress
436 (cons proc compilation-in-progress)))
437 ;; No asynchronous processes available
438 (message (format "Executing `%s'..." command))
439 ;; Fake modeline display as if `start-process' were run.
440 (setq mode-line-process ":run")
441 (sit-for 0) ;; Force redisplay
442 (let ((status (call-process shell-file-name nil outbuf nil "-c"
445 ;; Fake modeline after exit.
446 (setq mode-line-process
447 (cond ((numberp status) (format ":exit[%d]" status))
448 ((stringp status) (format ":exit[-1: %s]" status))
450 ;; Call `compilation-finish-function' as `compilation-sentinel'
451 ;; would, and finish up the compilation buffer with the same
452 ;; message we would get from `start-process'.
457 (format "exited abnormally with code %d\n" status))
458 "exited abnormally with code -1\n"))
459 (goto-char (point-max))
460 (insert "\nCompilation " finish-msg)
462 (insert " at " (substring (current-time-string) 0 19)) ; no year
464 (if compilation-finish-function
465 (funcall compilation-finish-function outbuf finish-msg)))
466 (message (format "Executing `%s'...done" command)))))
467 ;; Make it so the next C-x ` will use this buffer.
468 (setq compilation-last-buffer outbuf)))
470 ;; Set the height of WINDOW according to compilation-window-height.
471 (defun compilation-set-window-height (window)
472 (and compilation-window-height
473 (= (window-width window) (frame-width (window-frame window)))
474 ;; If window is alone in its frame, aside from a minibuffer,
475 ;; don't change its height.
476 (not (eq window (frame-root-window (window-frame window))))
477 ;; This save-excursion prevents us from changing the current buffer,
478 ;; which might not be the same as the selected window's buffer.
480 (let ((w (selected-window)))
483 (select-window window)
484 (enlarge-window (- compilation-window-height
486 (select-window w))))))
488 (defvar compilation-minor-mode-map
489 (let ((map (make-sparse-keymap)))
490 (define-key map [mouse-2] 'compile-mouse-goto-error)
491 (define-key map "\C-c\C-c" 'compile-goto-error)
492 (define-key map "\C-m" 'compile-goto-error)
493 (define-key map "\C-c\C-k" 'kill-compilation)
494 (define-key map "\M-n" 'compilation-next-error)
495 (define-key map "\M-p" 'compilation-previous-error)
496 (define-key map "\M-{" 'compilation-previous-file)
497 (define-key map "\M-}" 'compilation-next-file)
499 "Keymap for `compilation-minor-mode'.")
501 (defvar compilation-mode-map
502 (let ((map (cons 'keymap compilation-minor-mode-map)))
503 (define-key map " " 'scroll-up)
504 (define-key map "\^?" 'scroll-down)
505 ;; Set up the menu-bar
506 (define-key map [menu-bar compilation-menu]
507 (cons "Compile" (make-sparse-keymap "Compile")))
509 (define-key map [menu-bar compilation-menu compilation-mode-kill-compilation]
510 '("Stop Compilation" . kill-compilation))
511 (define-key map [menu-bar compilation-menu compilation-mode-separator2]
513 (define-key map [menu-bar compilation-menu compilation-mode-first-error]
514 '("First Error" . first-error))
515 (define-key map [menu-bar compilation-menu compilation-mode-previous-error]
516 '("Previous Error" . previous-error))
517 (define-key map [menu-bar compilation-menu compilation-mode-next-error]
518 '("Next Error" . next-error))
519 (define-key map [menu-bar compilation-menu compilation-separator2]
521 (define-key map [menu-bar compilation-menu compilation-mode-grep]
523 (define-key map [menu-bar compilation-menu compilation-mode-recompile]
524 '("Recompile" . recompile))
525 (define-key map [menu-bar compilation-menu compilation-mode-compile]
526 '("Compile" . compile))
528 "Keymap for compilation log buffers.
529 `compilation-minor-mode-map' is a cdr of this.")
532 (defun compilation-mode ()
533 "Major mode for compilation log buffers.
534 \\<compilation-mode-map>To visit the source for a line-numbered error,
535 move point to the error message line and type \\[compile-goto-error].
536 To kill the compilation, type \\[kill-compilation].
538 Runs `compilation-mode-hook' with `run-hooks' (which see)."
540 (kill-all-local-variables)
541 (use-local-map compilation-mode-map)
542 (setq major-mode 'compilation-mode
543 mode-name "Compilation")
545 (set (make-local-variable 'font-lock-defaults)
546 '(compilation-mode-font-lock-keywords t))
547 (run-hooks 'compilation-mode-hook))
549 ;; Prepare the buffer for the compilation parsing commands to work.
550 (defun compilation-setup ()
551 ;; Make the buffer's mode line show process state.
552 (setq mode-line-process '(":%s"))
553 (set (make-local-variable 'compilation-error-list) nil)
554 (set (make-local-variable 'compilation-old-error-list) nil)
555 (set (make-local-variable 'compilation-parsing-end) 1)
556 (set (make-local-variable 'compilation-directory-stack) nil)
557 (setq compilation-last-buffer (current-buffer)))
559 (defvar compilation-minor-mode nil
560 "Non-nil when in compilation-minor-mode.
561 In this minor mode, all the error-parsing commands of the
562 Compilation major mode are available.")
563 (make-variable-buffer-local 'compilation-minor-mode)
565 (or (assq 'compilation-minor-mode minor-mode-alist)
566 (setq minor-mode-alist (cons '(compilation-minor-mode " Compilation")
568 (or (assq 'compilation-minor-mode minor-mode-map-alist)
569 (setq minor-mode-map-alist (cons (cons 'compilation-minor-mode
570 compilation-minor-mode-map)
571 minor-mode-map-alist)))
574 (defun compilation-minor-mode (&optional arg)
575 "Toggle compilation minor mode.
576 With arg, turn compilation mode on if and only if arg is positive.
577 See `compilation-mode'."
579 (if (setq compilation-minor-mode (if (null arg)
580 (null compilation-minor-mode)
581 (> (prefix-numeric-value arg) 0)))
582 (compilation-setup)))
584 ;; Called when compilation process changes state.
585 (defun compilation-sentinel (proc msg)
586 "Sentinel for compilation buffers."
587 (let ((buffer (process-buffer proc)))
588 (if (memq (process-status proc) '(signal exit))
590 (if (null (buffer-name buffer))
592 (set-process-buffer proc nil)
593 (let ((obuf (current-buffer))
595 ;; save-excursion isn't the right thing if
596 ;; process-buffer is current-buffer
599 ;; Write something in the compilation buffer
600 ;; and hack its mode line.
602 (let ((buffer-read-only nil)
603 (status (if compilation-exit-message-function
604 (funcall compilation-exit-message-function
606 (cons msg (process-exit-status proc)))))
607 (setq omax (point-max)
610 ;; Record where we put the message, so we can ignore it
612 (insert ?\n mode-name " " (car status))
614 (insert " at " (substring (current-time-string) 0 19))
616 (setq mode-line-process
618 (process-status proc) (cdr status)))
619 ;; Since the buffer and mode line will show that the
620 ;; process is dead, we can delete it now. Otherwise it
621 ;; will stay around until M-x list-processes.
622 (delete-process proc)
623 ;; Force mode line redisplay soon.
624 (force-mode-line-update))
625 (if (and opoint (< opoint omax))
627 (if compilation-finish-function
628 (funcall compilation-finish-function buffer msg)))
630 (setq compilation-in-progress (delq proc compilation-in-progress))
633 (defun compilation-filter (proc string)
634 "Process filter for compilation buffers.
635 Just inserts the text, but uses `insert-before-markers'."
636 (if (buffer-name (process-buffer proc))
638 (set-buffer (process-buffer proc))
639 (let ((buffer-read-only nil))
641 (goto-char (process-mark proc))
642 (insert-before-markers string)
643 (set-marker (process-mark proc) (point)))))))
645 ;; Return the cdr of compilation-old-error-list for the error containing point.
646 (defun compile-error-at-point ()
647 (compile-reinitialize-errors nil (point))
648 (let ((errors compilation-old-error-list))
650 (> (point) (car (car errors))))
651 (setq errors (cdr errors)))
654 (defsubst compilation-buffer-p (buffer)
657 (or compilation-minor-mode (eq major-mode 'compilation-mode))))
659 (defun compilation-next-error (n)
660 "Move point to the next error in the compilation buffer.
661 Does NOT find the source line like \\[next-error]."
663 (or (compilation-buffer-p (current-buffer))
664 (error "Not in a compilation buffer."))
665 (setq compilation-last-buffer (current-buffer))
667 (let ((errors (compile-error-at-point)))
669 ;; Move to the error after the one containing point.
670 (goto-char (car (if (< n 0)
672 (e compilation-old-error-list))
673 ;; See how many cdrs away ERRORS is from the start.
674 (while (not (eq e errors))
678 (error "Moved back past first error")
679 (nth (+ i n) compilation-old-error-list)))
680 (let ((compilation-error-list (cdr errors)))
681 (compile-reinitialize-errors nil nil n)
682 (if compilation-error-list
683 (nth (1- n) compilation-error-list)
684 (error "Moved past last error"))))))))
686 (defun compilation-previous-error (n)
687 "Move point to the previous error in the compilation buffer.
688 Does NOT find the source line like \\[next-error]."
690 (compilation-next-error (- n)))
693 ;; Given an elt of `compilation-error-list', return an object representing
694 ;; the referenced file which is equal to (but not necessarily eq to) what
695 ;; this function would return for another error in the same file.
696 (defsubst compilation-error-filedata (data)
697 (setq data (cdr data))
702 ;; Return a string describing a value from compilation-error-filedata.
703 ;; This value is not necessarily useful as a file name, but should be
704 ;; indicative to the user of what file's errors are being referred to.
705 (defsubst compilation-error-filedata-file-name (filedata)
706 (if (bufferp filedata)
707 (buffer-file-name filedata)
710 (defun compilation-next-file (n)
711 "Move point to the next error for a different file than the current one."
713 (or (compilation-buffer-p (current-buffer))
714 (error "Not in a compilation buffer."))
715 (setq compilation-last-buffer (current-buffer))
717 (let ((reversed (< n 0))
721 (setq errors (or (compile-error-at-point)
722 (error "Moved past last error")))
724 ;; Get a reversed list of the errors up through the one containing point.
725 (compile-reinitialize-errors nil (point))
726 (setq errors (reverse compilation-old-error-list)
729 ;; Ignore errors after point. (car ERRORS) will be the error
730 ;; containing point, (cadr ERRORS) the one before it.
732 (< (point) (car (car errors))))
733 (setq errors (cdr errors))))
736 (setq filedata (compilation-error-filedata (car errors)))
738 ;; Skip past the following errors for this file.
739 (while (equal filedata
740 (compilation-error-filedata
743 (error "%s the first erring file"
744 (compilation-error-filedata-file-name
746 (let ((compilation-error-list nil))
748 (compile-reinitialize-errors nil nil 2)
749 (setq errors compilation-error-list)))
750 (error "%s is the last erring file"
751 (compilation-error-filedata-file-name
753 (setq errors (cdr errors)))
757 ;; Move to the following error.
758 (goto-char (car (car (or errors
760 (error "This is the first erring file")
761 (let ((compilation-error-list nil))
762 ;; Parse the last one.
763 (compile-reinitialize-errors nil nil 1)
764 compilation-error-list))))))))
766 (defun compilation-previous-file (n)
767 "Move point to the previous error for a different file than the current one."
769 (compilation-next-file (- n)))
772 (defun kill-compilation ()
773 "Kill the process made by the \\[compile] command."
775 (let ((buffer (compilation-find-buffer)))
776 (if (get-buffer-process buffer)
777 (interrupt-process (get-buffer-process buffer))
778 (error "The compilation process is not running."))))
781 ;; Parse any new errors in the compilation buffer,
782 ;; or reparse from the beginning if the user has asked for that.
783 (defun compile-reinitialize-errors (reparse
784 &optional limit-search find-at-least)
786 (set-buffer compilation-last-buffer)
787 ;; If we are out of errors, or if user says "reparse",
788 ;; discard the info we have, to force reparsing.
789 (if (or (eq compilation-error-list t)
791 (compilation-forget-errors))
792 (if (and compilation-error-list
793 (or (not limit-search)
794 (> compilation-parsing-end limit-search))
795 (or (not find-at-least)
796 (>= (length compilation-error-list) find-at-least)))
797 ;; Since compilation-error-list is non-nil, it points to a specific
798 ;; error the user wanted. So don't move it around.
800 ;; This was here for a long time (before my rewrite); why? --roland
801 ;;(switch-to-buffer compilation-last-buffer)
802 (set-buffer-modified-p nil)
803 (if (< compilation-parsing-end (point-max))
804 ;; compilation-error-list might be non-nil if we have a non-nil
805 ;; LIMIT-SEARCH or FIND-AT-LEAST arg. In that case its value
806 ;; records the current position in the error list, and we must
807 ;; preserve that after reparsing.
808 (let ((error-list-pos compilation-error-list))
809 (funcall compilation-parse-errors-function
812 ;; We only need enough new parsed errors to reach
813 ;; FIND-AT-LEAST errors past the current
815 (- find-at-least (length compilation-error-list))))
816 ;; Remember the entire list for compilation-forget-errors. If
817 ;; this is an incremental parse, append to previous list. If
818 ;; we are parsing anew, compilation-forget-errors cleared
819 ;; compilation-old-error-list above.
820 (setq compilation-old-error-list
821 (nconc compilation-old-error-list compilation-error-list))
823 ;; We started in the middle of an existing list of parsed
824 ;; errors before parsing more; restore that position.
825 (setq compilation-error-list error-list-pos))
828 (defun compile-mouse-goto-error (event)
831 (set-buffer (window-buffer (posn-window (event-end event))))
832 (goto-char (posn-point (event-end event)))
834 (or (compilation-buffer-p (current-buffer))
835 (error "Not in a compilation buffer."))
836 (setq compilation-last-buffer (current-buffer))
837 (compile-reinitialize-errors nil (point))
839 ;; Move to bol; the marker for the error on this line will point there.
842 ;; Move compilation-error-list to the elt of compilation-old-error-list
844 (setq compilation-error-list compilation-old-error-list)
845 (while (and compilation-error-list
846 (> (point) (car (car compilation-error-list))))
847 (setq compilation-error-list (cdr compilation-error-list)))
848 (or compilation-error-list
849 (error "No error to go to")))
850 (select-window (posn-window (event-end event)))
851 ;; Move to another window, so that next-error's window changes
852 ;; result in the desired setup.
856 ;; other-window changed the selected buffer,
857 ;; but we didn't want to do that.
858 (set-buffer compilation-last-buffer)))
863 (defun compile-goto-error (&optional argp)
864 "Visit the source for the error message point is on.
865 Use this command in a compilation log buffer. Sets the mark at point there.
866 \\[universal-argument] as a prefix arg means to reparse the buffer's error messages first;
867 other kinds of prefix arguments are ignored."
869 (or (compilation-buffer-p (current-buffer))
870 (error "Not in a compilation buffer."))
871 (setq compilation-last-buffer (current-buffer))
872 (compile-reinitialize-errors (consp argp) (point))
874 ;; Move to bol; the marker for the error on this line will point there.
877 ;; Move compilation-error-list to the elt of compilation-old-error-list
879 (setq compilation-error-list compilation-old-error-list)
880 (while (and compilation-error-list
881 (> (point) (car (car compilation-error-list))))
882 (setq compilation-error-list (cdr compilation-error-list)))
884 ;; Move to another window, so that next-error's window changes
885 ;; result in the desired setup.
889 ;; other-window changed the selected buffer,
890 ;; but we didn't want to do that.
891 (set-buffer compilation-last-buffer)))
896 ;; Return a compilation buffer.
897 ;; If the current buffer is a compilation buffer, return it.
898 ;; If compilation-last-buffer is set to a live buffer, use that.
899 ;; Otherwise, look for a compilation buffer and signal an error
900 ;; if there are none.
901 (defun compilation-find-buffer (&optional other-buffer)
902 (if (and (not other-buffer)
903 (compilation-buffer-p (current-buffer)))
904 ;; The current buffer is a compilation buffer.
906 (if (and compilation-last-buffer (buffer-name compilation-last-buffer)
907 (or (not other-buffer) (not (eq compilation-last-buffer
909 compilation-last-buffer
910 (let ((buffers (buffer-list)))
911 (while (and buffers (or (not (compilation-buffer-p (car buffers)))
913 (eq (car buffers) (current-buffer)))))
914 (setq buffers (cdr buffers)))
917 (or (and other-buffer
918 (compilation-buffer-p (current-buffer))
919 ;; The current buffer is a compilation buffer.
922 (message "This is the only compilation buffer."))
924 (error "No compilation started!")))))))
927 (defun next-error (&optional argp)
928 "Visit next compilation error message and corresponding source code.
929 This operates on the output from the \\[compile] command.
930 If all preparsed error messages have been processed,
931 the error message buffer is checked for new ones.
933 A prefix arg specifies how many error messages to move;
934 negative means move back to previous error messages.
935 Just C-u as a prefix means reparse the error message buffer
936 and start at the first error.
938 \\[next-error] normally applies to the most recent compilation started,
939 but as long as you are in the middle of parsing errors from one compilation
940 output buffer, you stay with that compilation output buffer.
942 Use \\[next-error] in a compilation output buffer to switch to
943 processing errors from that compilation.
945 See variables `compilation-parse-errors-function' and
946 \`compilation-error-regexp-alist' for customization ideas."
948 (setq compilation-last-buffer (compilation-find-buffer))
949 (compilation-goto-locus (compilation-next-error-locus
950 ;; We want to pass a number here only if
951 ;; we got a numeric prefix arg, not just C-u.
952 (and (not (consp argp))
953 (prefix-numeric-value argp))
955 ;;;###autoload (define-key ctl-x-map "`" 'next-error)
957 (defun previous-error ()
958 "Visit previous compilation error message and corresponding source code.
959 This operates on the output from the \\[compile] command."
963 (defun first-error ()
964 "Reparse the error message buffer and start at the first error
965 Visit corresponding source code.
966 This operates on the output from the \\[compile] command."
970 (defun compilation-next-error-locus (&optional move reparse silent)
971 "Visit next compilation error and return locus in corresponding source code.
972 This operates on the output from the \\[compile] command.
973 If all preparsed error messages have been processed,
974 the error message buffer is checked for new ones.
976 Returns a cons (ERROR . SOURCE) of two markers: ERROR is a marker at the
977 location of the error message in the compilation buffer, and SOURCE is a
978 marker at the location in the source code indicated by the error message.
980 Optional first arg MOVE says how many error messages to move forwards (or
981 backwards, if negative); default is 1. Optional second arg REPARSE, if
982 non-nil, says to reparse the error message buffer and reset to the first
983 error (plus MOVE - 1). If optional third argument SILENT is non-nil, return
984 nil instead of raising an error if there are no more errors.
986 The current buffer should be the desired compilation output buffer."
987 (or move (setq move 1))
988 (compile-reinitialize-errors reparse nil (and (not reparse)
989 (if (< move 1) 0 (1- move))))
990 (let (next-errors next-error)
991 (catch 'no-next-error
993 (set-buffer compilation-last-buffer)
994 ;; compilation-error-list points to the "current" error.
998 compilation-error-list)
999 ;; Zero or negative arg; we need to move back in the list.
1002 (e compilation-old-error-list))
1003 ;; See how many cdrs away the current error is from the start.
1004 (while (not (eq e compilation-error-list))
1008 (error "Moved back past first error")
1009 (nthcdr (+ i n) compilation-old-error-list))))
1010 next-error (car next-errors))
1012 (if (null next-error)
1014 (and move (/= move 1)
1015 (error (if (> move 0)
1016 "Moved past last error")
1017 "Moved back past first error"))
1018 ;; Forget existing error messages if compilation has finished.
1019 (if (not (and (get-buffer-process (current-buffer))
1024 (compilation-forget-errors))
1026 (throw 'no-next-error nil)
1027 (error (concat compilation-error-message
1028 (and (get-buffer-process (current-buffer))
1034 (setq compilation-error-list (cdr next-errors))
1035 (if (null (cdr next-error))
1036 ;; This error is boring. Go to the next.
1038 (or (markerp (cdr next-error))
1039 ;; This error has a filename/lineno pair.
1040 ;; Find the file and turn it into a marker.
1041 (let* ((fileinfo (car (cdr next-error)))
1042 (buffer (apply 'compilation-find-file
1043 (car next-error) fileinfo)))
1045 ;; We can't find this error's file.
1046 ;; Remove all errors in the same file.
1048 (setq next-errors compilation-old-error-list)
1050 (and (consp (cdr (car next-errors)))
1051 (equal (car (cdr (car next-errors)))
1054 (set-marker (car (car next-errors)) nil)
1055 (setcdr (car next-errors) nil)))
1056 (setq next-errors (cdr next-errors)))
1057 ;; Look for the next error.
1059 ;; We found the file. Get a marker for this error.
1060 ;; compilation-old-error-list is a buffer-local
1061 ;; variable, so we must be careful to extract its value
1062 ;; before switching to the source file buffer.
1063 (let ((errors compilation-old-error-list)
1064 (last-line (nth 1 (cdr next-error)))
1065 (column (nth 2 (cdr next-error))))
1070 (goto-line last-line)
1071 (if (and column (> column 0))
1072 ;; Columns in error msgs are 1-origin.
1073 (move-to-column (1- column))
1074 (beginning-of-line))
1075 (setcdr next-error (point-marker))
1076 ;; Make all the other error messages referring
1077 ;; to the same file have markers into the buffer.
1079 (and (consp (cdr (car errors)))
1080 (equal (car (cdr (car errors))) fileinfo)
1081 (let* ((this (nth 1 (cdr (car errors))))
1082 (column (nth 2 (cdr (car errors))))
1083 (lines (- this last-line)))
1084 (if (eq selective-display t)
1085 ;; When selective-display is t,
1086 ;; each C-m is a line boundary,
1087 ;; as well as each newline.
1089 (re-search-backward "[\n\C-m]"
1092 (re-search-forward "[\n\C-m]"
1095 (forward-line lines))
1096 (if (and column (> column 1))
1097 (move-to-column (1- column))
1098 (beginning-of-line))
1099 (setq last-line this)
1100 (setcdr (car errors) (point-marker))))
1101 (setq errors (cdr errors)))))))))
1102 ;; If we didn't get a marker for this error, or this
1103 ;; marker's buffer was killed, go on to the next one.
1104 (or (not (markerp (cdr next-error)))
1105 (not (marker-buffer (cdr next-error))))))
1106 (setq next-errors compilation-error-list
1107 next-error (car next-errors)))))
1109 ;; Skip over multiple error messages for the same source location,
1110 ;; so the next C-x ` won't go to an error in the same place.
1111 (while (and compilation-error-list
1112 (equal (cdr (car compilation-error-list)) (cdr next-error)))
1113 (setq compilation-error-list (cdr compilation-error-list)))
1115 ;; We now have a marker for the position of the error source code.
1116 ;; NEXT-ERROR is a cons (ERROR . SOURCE) of two markers.
1119 (defun compilation-goto-locus (next-error)
1120 "Jump to an error locus returned by `compilation-next-error-locus'.
1121 Takes one argument, a cons (ERROR . SOURCE) of two markers.
1122 Selects a window with point at SOURCE, with another window displaying ERROR."
1123 (if (and (window-dedicated-p (selected-window))
1124 (eq (selected-window) (frame-root-window)))
1125 (switch-to-buffer-other-frame (marker-buffer (cdr next-error)))
1126 (switch-to-buffer (marker-buffer (cdr next-error))))
1127 (goto-char (cdr next-error))
1128 ;; If narrowing got in the way of
1129 ;; going to the right place, widen.
1130 (or (= (point) (marker-position (cdr next-error)))
1133 (goto-char (cdr next-error))))
1135 ;; Show compilation buffer in other window, scrolled to this error.
1136 (let* ((pop-up-windows t)
1137 ;; Use an existing window if it is in a visible frame.
1138 (w (or (get-buffer-window (marker-buffer (car next-error)) 'visible)
1140 (display-buffer (marker-buffer (car next-error))))))
1141 (set-window-point w (car next-error))
1142 (set-window-start w (car next-error))
1143 (compilation-set-window-height w)))
1145 ;; Find a buffer for file FILENAME.
1146 ;; Search the directories in compilation-search-path.
1147 ;; A nil in compilation-search-path means to try the
1148 ;; current directory, which is passed in DIR.
1149 ;; If FILENAME is not found at all, ask the user where to find it.
1150 ;; Pop up the buffer containing MARKER and scroll to MARKER if we ask the user.
1151 (defun compilation-find-file (marker filename dir &rest formats)
1152 (or formats (setq formats '("%s")))
1153 (let ((dirs compilation-search-path)
1154 buffer thisdir fmts name)
1155 (if (file-name-absolute-p filename)
1156 ;; The file name is absolute. Use its explicit directory as
1157 ;; the first in the search path, and strip it from FILENAME.
1158 (setq filename (abbreviate-file-name (expand-file-name filename))
1159 dirs (cons (file-name-directory filename) dirs)
1160 filename (file-name-nondirectory filename)))
1161 ;; Now search the path.
1162 (while (and dirs (null buffer))
1163 (setq thisdir (or (car dirs) dir)
1165 ;; For each directory, try each format string.
1166 (while (and fmts (null buffer))
1167 (setq name (expand-file-name (format (car fmts) filename) thisdir)
1168 buffer (and (file-exists-p name)
1169 (find-file-noselect name))
1171 (setq dirs (cdr dirs)))
1173 ;; The file doesn't exist.
1174 ;; Ask the user where to find it.
1175 ;; If he hits C-g, then the next time he does
1176 ;; next-error, he'll skip past it.
1177 (let* ((pop-up-windows t)
1178 (w (display-buffer (marker-buffer marker))))
1179 (set-window-point w marker)
1180 (set-window-start w marker)
1181 (let ((name (expand-file-name
1183 (format "Find this error in: (default %s) "
1186 (if (file-directory-p name)
1187 (setq name (expand-file-name filename name)))
1188 (and (file-exists-p name)
1189 (find-file-noselect name)))))))
1191 ;; Set compilation-error-list to nil, and unchain the markers that point to the
1192 ;; error messages and their text, so that they no longer slow down gap motion.
1193 ;; This would happen anyway at the next garbage collection, but it is better to
1194 ;; do it right away.
1195 (defun compilation-forget-errors ()
1196 (while compilation-old-error-list
1197 (let ((next-error (car compilation-old-error-list)))
1198 (set-marker (car next-error) nil)
1199 (if (markerp (cdr next-error))
1200 (set-marker (cdr next-error) nil)))
1201 (setq compilation-old-error-list (cdr compilation-old-error-list)))
1202 (setq compilation-error-list nil
1203 compilation-directory-stack nil
1204 compilation-parsing-end 1))
1207 (defun count-regexp-groupings (regexp)
1208 "Return the number of \\( ... \\) groupings in REGEXP (a string)."
1210 (len (length regexp))
1214 (setq c (aref regexp i)
1217 ;; Find the end of this [...].
1218 (while (and (< i len)
1219 (not (= (aref regexp i) ?\])))
1224 (setq c (aref regexp i)
1227 ;; We found the end of a grouping,
1228 ;; so bump our counter.
1229 (setq groupings (1+ groupings))))))))
1232 (defun compilation-parse-errors (limit-search find-at-least)
1233 "Parse the current buffer as grep, cc or lint error messages.
1234 See variable `compilation-parse-errors-function' for the interface it uses."
1235 (setq compilation-error-list nil)
1236 (message "Parsing error messages...")
1237 (let (text-buffer orig orig-expanded parent-expanded
1238 regexp enter-group leave-group error-group
1239 alist subexpr error-regexp-groups
1241 (compilation-num-errors-found 0))
1243 ;; Don't reparse messages already seen at last parse.
1244 (goto-char compilation-parsing-end)
1245 ;; Don't parse the first two lines as error messages.
1246 ;; This matters for grep.
1250 ;; Move back so point is before the newline.
1251 ;; This matters because some error regexps use \n instead of ^
1255 ;; Compile all the regexps we want to search for into one.
1256 (setq regexp (concat "\\(" compilation-enter-directory-regexp "\\)\\|"
1257 "\\(" compilation-leave-directory-regexp "\\)\\|"
1258 "\\(" (mapconcat (function
1260 (concat "\\(" (car elt) "\\)")))
1261 compilation-error-regexp-alist
1264 ;; Find out how many \(...\) groupings are in each of the regexps, and set
1265 ;; *-GROUP to the grouping containing each constituent regexp (whose
1266 ;; subgroups will come immediately thereafter) of the big regexp we have
1267 ;; just constructed.
1269 leave-group (+ enter-group
1270 (count-regexp-groupings
1271 compilation-enter-directory-regexp)
1273 error-group (+ leave-group
1274 (count-regexp-groupings
1275 compilation-leave-directory-regexp)
1278 ;; Compile an alist (IDX FILE LINE [COL]), where IDX is the number of
1279 ;; the subexpression for an entire error-regexp, and FILE and LINE (and
1280 ;; possibly COL) are the numbers for the subexpressions giving the file
1281 ;; name and line number (and possibly column number).
1282 (setq alist (or compilation-error-regexp-alist
1283 (error "compilation-error-regexp-alist is empty!"))
1284 subexpr (1+ error-group))
1286 (setq error-regexp-groups
1288 (+ subexpr (nth 1 (car alist)))
1289 (+ subexpr (nth 2 (car alist)))
1290 (and (nth 3 (car alist))
1291 (+ subexpr (nth 3 (car alist)))))
1292 error-regexp-groups))
1293 (setq subexpr (+ subexpr 1 (count-regexp-groupings (car (car alist)))))
1294 (setq alist (cdr alist)))
1296 ;; Set up now the expanded, abbreviated directory variables
1297 ;; that compile-abbreviate-directory will need, so we can
1298 ;; compute them just once here.
1299 (setq orig (abbreviate-file-name default-directory)
1300 orig-expanded (abbreviate-file-name
1301 (file-truename default-directory))
1302 parent-expanded (abbreviate-file-name
1303 (expand-file-name "../" orig-expanded)))
1305 (while (and (not found-desired)
1306 ;; We don't just pass LIMIT-SEARCH to re-search-forward
1307 ;; because we want to find matches containing LIMIT-SEARCH
1308 ;; but which extend past it.
1309 (re-search-forward regexp nil t))
1311 ;; Figure out which constituent regexp matched.
1312 (cond ((match-beginning enter-group)
1313 ;; The match was the enter-directory regexp.
1315 (file-name-as-directory
1317 (buffer-substring (match-beginning (+ enter-group 1))
1318 (match-end (+ enter-group 1)))))))
1319 ;; The directory name in the "entering" message
1320 ;; is a truename. Try to convert it to a form
1321 ;; like what the user typed in.
1323 (compile-abbreviate-directory dir orig orig-expanded
1325 (setq compilation-directory-stack
1326 (cons dir compilation-directory-stack))
1327 (and (file-directory-p dir)
1328 (setq default-directory dir)))
1330 (and limit-search (>= (point) limit-search)
1331 ;; The user wanted a specific error, and we're past it.
1332 ;; We do this check here (and in the leave-group case)
1333 ;; rather than at the end of the loop because if the last
1334 ;; thing seen is an error message, we must carefully
1335 ;; discard the last error when it is the first in a new
1336 ;; file (see below in the error-group case).
1337 (setq found-desired t)))
1339 ((match-beginning leave-group)
1340 ;; The match was the leave-directory regexp.
1341 (let ((beg (match-beginning (+ leave-group 1)))
1342 (stack compilation-directory-stack))
1345 (file-name-as-directory
1347 (buffer-substring beg
1348 (match-end (+ leave-group
1350 ;; The directory name in the "leaving" message
1351 ;; is a truename. Try to convert it to a form
1352 ;; like what the user typed in.
1354 (compile-abbreviate-directory dir orig orig-expanded
1357 (not (string-equal (car stack) dir)))
1358 (setq stack (cdr stack)))))
1359 (setq compilation-directory-stack (cdr stack))
1360 (setq stack (car compilation-directory-stack))
1362 (setq default-directory stack))
1365 (and limit-search (>= (point) limit-search)
1366 ;; The user wanted a specific error, and we're past it.
1367 ;; We do this check here (and in the enter-group case)
1368 ;; rather than at the end of the loop because if the last
1369 ;; thing seen is an error message, we must carefully
1370 ;; discard the last error when it is the first in a new
1371 ;; file (see below in the error-group case).
1372 (setq found-desired t)))
1374 ((match-beginning error-group)
1375 ;; The match was the composite error regexp.
1376 ;; Find out which individual regexp matched.
1377 (setq alist error-regexp-groups)
1379 (null (match-beginning (car (car alist)))))
1380 (setq alist (cdr alist)))
1382 (setq alist (car alist))
1383 (error "compilation-parse-errors: impossible regexp match!"))
1385 ;; Extract the file name and line number from the error message.
1386 (let ((beginning-of-match (match-beginning 0)) ;looking-at nukes
1387 (filename (buffer-substring (match-beginning (nth 1 alist))
1388 (match-end (nth 1 alist))))
1389 (linenum (string-to-int
1391 (match-beginning (nth 2 alist))
1392 (match-end (nth 2 alist)))))
1393 (column (and (nth 3 alist)
1394 (match-beginning (nth 3 alist))
1397 (match-beginning (nth 3 alist))
1398 (match-end (nth 3 alist)))))))
1400 ;; Check for a comint-file-name-prefix and prepend it if
1401 ;; appropriate. (This is very useful for
1402 ;; compilation-minor-mode in an rlogin-mode buffer.)
1403 (and (boundp 'comint-file-name-prefix)
1404 ;; If the file name is relative, default-directory will
1405 ;; already contain the comint-file-name-prefix (done by
1406 ;; compile-abbreviate-directory).
1407 (file-name-absolute-p filename)
1408 (setq filename (concat comint-file-name-prefix filename)))
1409 (setq filename (cons filename (cons default-directory
1413 ;; Locate the erring file and line.
1414 ;; Cons a new elt onto compilation-error-list,
1415 ;; giving a marker for the current compilation buffer
1416 ;; location, and the file and line number of the error.
1418 ;; Save as the start of the error the beginning of the
1419 ;; line containing the match unless the match starts at a
1420 ;; newline, in which case the beginning of the next line.
1421 (goto-char beginning-of-match)
1422 (forward-line (if (eolp) 1 0))
1423 (let ((this (cons (point-marker)
1424 (list filename linenum column))))
1425 ;; Don't add the same source line more than once.
1426 (if (equal (cdr this) (cdr (car compilation-error-list)))
1428 (setq compilation-error-list
1430 compilation-error-list))
1431 (setq compilation-num-errors-found
1432 (1+ compilation-num-errors-found)))))
1433 (and (or (and find-at-least (> compilation-num-errors-found
1435 (and limit-search (>= (point) limit-search)))
1436 ;; We have found as many new errors as the user wants,
1437 ;; or past the buffer position he indicated. We
1438 ;; continue to parse until we have seen all the
1439 ;; consecutive errors in the same file, so the error
1440 ;; positions will be recorded as markers in this buffer
1441 ;; that might change.
1442 (cdr compilation-error-list) ; Must check at least two.
1443 (not (equal (car (cdr (nth 0 compilation-error-list)))
1444 (car (cdr (nth 1 compilation-error-list)))))
1446 ;; Discard the error just parsed, so that the next
1447 ;; parsing run can get it and the following errors in
1448 ;; the same file all at once. If we didn't do this, we
1449 ;; would have the same problem we are trying to avoid
1450 ;; with the test above, just delayed until the next run!
1451 (setq compilation-error-list
1452 (cdr compilation-error-list))
1453 (goto-char beginning-of-match)
1454 (setq found-desired t)))
1458 (error "compilation-parse-errors: known groups didn't match!")))
1460 (message "Parsing error messages...%d (%.0f%% of buffer)"
1461 compilation-num-errors-found
1462 ;; Use floating-point because (* 100 (point)) frequently
1463 ;; exceeds the range of Emacs Lisp integers.
1464 (/ (* 100.0 (point)) (point-max)))
1466 (and limit-search (>= (point) limit-search)
1467 ;; The user wanted a specific error, and we're past it.
1468 (setq found-desired t)))
1469 (setq compilation-parsing-end (if found-desired
1471 ;; We have searched the whole buffer.
1473 (setq compilation-error-list (nreverse compilation-error-list))
1474 (message "Parsing error messages...done"))
1476 ;; If directory DIR is a subdir of ORIG or of ORIG's parent,
1477 ;; return a relative name for it starting from ORIG or its parent.
1478 ;; ORIG-EXPANDED is an expanded version of ORIG.
1479 ;; PARENT-EXPANDED is an expanded version of ORIG's parent.
1480 ;; Those two args could be computed here, but we run faster by
1481 ;; having the caller compute them just once.
1482 (defun compile-abbreviate-directory (dir orig orig-expanded parent-expanded)
1483 ;; Apply canonical abbreviations to DIR first thing.
1484 ;; Those abbreviations are already done in the other arguments passed.
1485 (setq dir (abbreviate-file-name dir))
1487 ;; Check for a comint-file-name-prefix and prepend it if appropriate.
1488 ;; (This is very useful for compilation-minor-mode in an rlogin-mode
1490 (if (boundp 'comint-file-name-prefix)
1491 (setq dir (concat comint-file-name-prefix dir)))
1493 (if (and (> (length dir) (length orig-expanded))
1494 (string= orig-expanded
1495 (substring dir 0 (length orig-expanded))))
1498 (substring dir (length orig-expanded)))))
1499 (if (and (> (length dir) (length parent-expanded))
1500 (string= parent-expanded
1501 (substring dir 0 (length parent-expanded))))
1503 (concat (file-name-directory
1504 (directory-file-name orig))
1505 (substring dir (length parent-expanded)))))
1510 ;;; compile.el ends here