(update-file-autoloads): Fix placement of new sections.
[bpt/emacs.git] / lisp / progmodes / compile.el
CommitLineData
daa37602 1;;; compile.el --- run compiler as inferior of Emacs, parse error messages.
fad160d5 2
8fca6c30 3;; Copyright (C) 1985, 86, 87, 93, 94, 1995 Free Software Foundation, Inc.
3a801d0c 4
29add8b9 5;; Author: Roland McGrath <roland@prep.ai.mit.edu>
d1c7011d 6;; Maintainer: FSF
e9571d2a 7;; Keywords: tools, processes
d1c7011d 8
55dfd2c4
RS
9;; This file is part of GNU Emacs.
10
29add8b9
RM
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)
14;; any later version.
15
55dfd2c4 16;; GNU Emacs is distributed in the hope that it will be useful,
29add8b9
RM
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.
20
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.
55dfd2c4 24
5cc57841
ER
25;;; Commentary:
26
27;; This package provides the compile and grep facilities documented in
28;; the Emacs user's manual.
29
d1c7011d
ER
30;;; Code:
31
7c163413
RM
32;;;###autoload
33(defvar compilation-mode-hook nil
4f6e4ad6 34 "*List of hook functions run by `compilation-mode' (see `run-hooks').")
7c163413
RM
35
36;;;###autoload
6e1dbafa 37(defvar compilation-window-height nil
d3cb357b
RM
38 "*Number of lines in a compilation window. If nil, use Emacs default.")
39
55dfd2c4
RS
40(defvar compilation-error-list nil
41 "List of error message descriptors for visiting erring functions.
fc0094d7
RM
42Each error descriptor is a cons (or nil). Its car is a marker pointing to
43an error message. If its cdr is a marker, it points to the text of the
533304f8
RM
44line 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
46error is not interesting.
d3cb357b
RM
47
48The value may be t instead of a list; this means that the buffer of
29478cc5
JB
49error messages should be reparsed the next time the list of errors is wanted.
50
51Some other commands (like `diff') use this list to control the error
9c09c008 52message tracking facilities; if you change its structure, you should make
29478cc5
JB
53sure you also change those packages. Perhaps it is better not to change
54it at all.")
55dfd2c4
RS
55
56(defvar compilation-old-error-list nil
57 "Value of `compilation-error-list' after errors were parsed.")
58
501cf428 59(defvar compilation-parse-errors-function 'compilation-parse-errors
b2bb6ec8 60 "Function to call to parse error messages from a compilation.
c540863c
RM
61It takes args LIMIT-SEARCH and FIND-AT-LEAST.
62If LIMIT-SEARCH is non-nil, don't bother parsing past that location.
501cf428 63If FIND-AT-LEAST is non-nil, don't bother parsing after finding that
e78e10ca 64many new errors.
d3cb357b
RM
65It 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
67found. See that variable for more info.")
55dfd2c4 68
aa228418 69;;;###autoload
d3cb357b 70(defvar compilation-buffer-name-function nil
6c43f2f9
RS
71 "Function to compute the name of a compilation buffer.
72The function receives one argument, the name of the major mode of the
73compilation buffer. It should return a string.
74nil means compute the name with `(concat \"*\" (downcase major-mode) \"*\")'.")
55dfd2c4 75
aa228418 76;;;###autoload
d3cb357b 77(defvar compilation-finish-function nil
aa228418 78 "*Function to call when a compilation process finishes.
d3cb357b
RM
79It is called with two arguments: the compilation buffer, and a string
80describing how the process finished.")
55dfd2c4 81
d3cb357b 82(defvar compilation-last-buffer nil
6c43f2f9
RS
83 "The most recent compilation buffer.
84A buffer becomes most recent when its compilation is started
85or when it is used with \\[next-error] or \\[compile-goto-error].")
55dfd2c4 86
ebff767c
RM
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")
91 minor-mode-alist)))
92
d3cb357b
RM
93(defvar compilation-parsing-end nil
94 "Position of end of buffer when last error messages were parsed.")
95
96(defvar compilation-error-message "No more errors"
6c43f2f9
RS
97 "Message to print when no more matches are found.")
98
99(defvar compilation-num-errors-found)
d3cb357b
RM
100
101(defvar compilation-error-regexp-alist
102 '(
d86bdede 103 ;; NOTE! See also grep-regexp-alist, below.
7ee790ac 104
d3cb357b 105 ;; 4.3BSD grep, cc, lint pass 1:
7ee790ac
RM
106 ;; /usr/src/foo/foo.c(8): warning: w may be used before set
107 ;; or GNU utilities:
108 ;; foo.c:8: error message
109 ;; or HP-UX 7.0 fc:
110 ;; foo.f :16 some horrible error message
08b1edf4
RM
111 ;; or GNU utilities with column (GNAT 1.82):
112 ;; foo.adb:2:1: Unit name does not match file name
501cf428 113 ;;
57c8389c
JB
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.
08b1edf4
RM
117 ("\n\
118\\([^:( \t\n]+\\)[:(][ \t]*\\([0-9]+\\)\\([) \t]\\|\
119:\\([^0-9\n]\\|\\([0-9]+:\\)\\)\\)" 1 2 5)
69d4d27f
RS
120
121 ;; Borland C++:
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)
7ee790ac 126
d3cb357b 127 ;; 4.3BSD lint pass 2
7ee790ac 128 ;; strcmp: variable # of args. llib-lc(359) :: /usr/src/foo/foo.c(8)
18710add 129 ("[ \t:]\\([^:( \t\n]+\\)[:(](+[ \t]*\\([0-9]+\\))[:) \t]*$" 1 2)
7ee790ac 130
d3cb357b 131 ;; 4.3BSD lint pass 3
7ee790ac 132 ;; bloofle defined( /users/wolfgang/foo.c(4) ), but never used
daa37602
JB
133 ;; This used to be
134 ;; ("[ \t(]+\\([^:( \t\n]+\\)[:( \t]+\\([0-9]+\\)[:) \t]+" 1 2)
135 ;; which is regexp Impressionism - it matches almost anything!
18710add 136 ("([ \t]*\\([^:( \t\n]+\\)[:(][ \t]*\\([0-9]+\\))" 1 2)
7ee790ac 137
ff735134 138 ;; Ultrix 3.0 f77:
f89fdaed 139 ;; fort: Severe: addstf.f, line 82: Missing operator or delimiter symbol
984ae4ed
RM
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)
501cf428 143 ;; Error on line 3 of t.f: Execution error unclassifiable statement
ff735134 144 ;; Unknown who does this:
9c09c008 145 ;; Line 45 of "foo.c": bloofle undefined
5ff3b093
RM
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]+\
9481474b 150of[ \t]+\"?\\([^\":\n]+\\)\"?:" 3 2)
7ee790ac
RM
151
152 ;; Apollo cc, 4.3BSD fc:
153 ;; "foo.f", line 3: Error: syntax error near end of statement
6d68d793
RS
154 ;; IBM RS6000:
155 ;; "vvouch.c", line 19.5: 1506-046 (S) Syntax error.
cacf1905
RM
156 ;; Unknown compiler:
157 ;; File "foobar.ml", lines 5-8, characters 20-155: blah blah
a0c567b5
RM
158 ;; Microtec mcc68k:
159 ;; "foo.c", line 32 pos 1; (E) syntax error; unexpected symbol: "lossage"
501cf428 160 ;; GNAT (as of July 94):
37fd2208
RS
161 ;; "foo.adb", line 2(11): warning: file name does not match ...
162 ("\"\\([^,\" \n\t]+\\)\", lines? \\([0-9]+\\)[:., (-]" 1 2)
18710add
JB
163
164 ;; MIPS RISC CC - the one distributed with Ultrix:
7ee790ac 165 ;; ccom: Error: foo.c, line 2: syntax error
dfb89664 166 ;; DEC AXP OSF/1 cc
501cf428 167 ;; /usr/lib/cmplrs/cc/cfe: Error: foo.c: 1: blah blah
dfb89664 168 ("rror: \\([^,\" \n\t]+\\)[,:] \\(line \\)?\\([0-9]+\\):" 1 3)
7ee790ac
RM
169
170 ;; IBM AIX PS/2 C version 1.1:
171 ;; ****** Error number 140 in line 8 of file errors.c ******
daa37602 172 ("in line \\([0-9]+\\) of file \\([^ \n]+[^. \n]\\)\\.? " 2 1)
d3cb357b
RM
173 ;; IBM AIX lint is too painful to do right this way. File name
174 ;; prefixes entire sections rather than being on each line.
57c8389c 175
72244bea
RM
176 ;; Lucid Compiler, lcc 3.x
177 ;; E, file.cc(35,52) Illegal operation on pointers
c021b7a5 178 ("\n[EW], \\([^(\n]*\\)(\\([0-9]+\\),[ \t]*\\([0-9]+\\)" 1 2 3)
72244bea 179
08b1edf4
RM
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)
4dbf8a2c
RM
183
184 ;; Cray C compiler error messages
19ae9cb0 185 ("\n\\(cc\\| cft\\)-[0-9]+ c\\(c\\|f77\\): ERROR \\([^,\n]+, \\)* File = \\([^,\n]+\\), Line = \\([0-9]+\\)" 4 5)
4dbf8a2c
RM
186
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.
54de3248 191 ("\n\\([^( \n\t]+\\)(\\([0-9]+\\):\\([0-9]+\\)) : " 1 2 3)
cfda7e6d
RM
192
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)
d3cb357b 196 )
6c43f2f9 197 "Alist that specifies how to match errors in compiler output.
20c1daec 198Each elt has the form (REGEXP FILE-IDX LINE-IDX [COLUMN-IDX FILE-FORMAT...])
72244bea
RM
199If REGEXP matches, the FILE-IDX'th subexpression gives the file name, and
200the LINE-IDX'th subexpression gives the line number. If COLUMN-IDX is
20c1daec
RM
201given, the COLUMN-IDX'th subexpression gives the column number on that line.
202If any FILE-FORMAT is given, each is a format string to produce a file name to
203try; %s in the string is replaced by the text matching the FILE-IDX'th
204subexpression.")
55dfd2c4 205
90016295
RS
206(defvar compilation-read-command t
207 "If not nil, M-x compile reads the compilation command to use.
208Otherwise, M-x compile just uses the value of `compile-command'.")
209
210(defvar compilation-ask-about-save t
211 "If not nil, M-x compile asks which buffers to save before compiling.
212Otherwise, it saves all modified buffers without asking.")
213
15d1a8da
RM
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'.")
217
98b63c41 218(defvar grep-command "grep -n "
203a5711 219 "Last grep command used in \\[grep]; default for next grep.")
98b63c41 220
7c163413 221;;;###autoload
d3cb357b 222(defvar compilation-search-path '(nil)
7c163413 223 "*List of directories to search for source files named in error messages.
d3cb357b
RM
224Elements should be directory names, not file names of directories.
225nil as an element means to try the default directory.")
55dfd2c4
RS
226
227(defvar compile-command "make -k "
228 "Last shell command used to do a compilation; default for next compilation.
229
230Sometimes it is useful for files to supply local values for this variable.
231You might also use mode hooks to specify it in certain modes, like this:
232
233 (setq c-mode-hook
234 '(lambda () (or (file-exists-p \"makefile\") (file-exists-p \"Makefile\")
235 (progn (make-local-variable 'compile-command)
236 (setq compile-command
237 (concat \"make -k \"
238 buffer-file-name))))))")
239
6e1dbafa 240(defvar compilation-enter-directory-regexp
daa37602 241 ": Entering directory `\\(.*\\)'$"
6c43f2f9
RS
242 "Regular expression matching lines that indicate a new current directory.
243This must contain one \\(, \\) pair around the directory name.
d3cb357b
RM
244
245The default value matches lines printed by the `-w' option of GNU Make.")
246
6e1dbafa 247(defvar compilation-leave-directory-regexp
daa37602 248 ": Leaving directory `\\(.*\\)'$"
6c43f2f9
RS
249 "Regular expression matching lines that indicate restoring current directory.
250This may contain one \\(, \\) pair around the name of the directory
251being moved from. If it does not, the last directory entered \(by a
252line matching `compilation-enter-directory-regexp'\) is assumed.
d3cb357b
RM
253
254The default value matches lines printed by the `-w' option of GNU Make.")
255
256(defvar compilation-directory-stack nil
6c43f2f9
RS
257 "Stack of previous directories for `compilation-leave-directory-regexp'.
258The head element is the directory the compilation was started in.")
d3cb357b 259
01f89d11
RM
260(defvar compilation-exit-message-function nil "\
261If non-nil, called when a compilation process dies to return a status message.
262This 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
264strings to write into the compilation buffer, and to put in its mode line.")
265
770970cb
RS
266;; History of compile commands.
267(defvar compile-history nil)
268;; History of grep commands.
269(defvar grep-history nil)
270
9af0d309 271(defvar compilation-mode-font-lock-keywords
c81b38d3
SM
272 ;; This regexp needs a bit of rewriting. What is the third grouping for?
273 '(("^\\([^ \n:]*:\\([0-9]+:\\)+\\)\\(.*\\)$" 1 font-lock-function-name-face))
9af0d309
RS
274;;; ("^\\([^\n:]*:\\([0-9]+:\\)+\\)\\(.*\\)$" 0 font-lock-keyword-face keep)
275 "Additional expressions to highlight in Compilation mode.")
01f89d11 276\f
d3cb357b 277;;;###autoload
55dfd2c4
RS
278(defun compile (command)
279 "Compile the program including the current buffer. Default: run `make'.
280Runs COMMAND, a shell command, in a separate process asynchronously
281with output going to the buffer `*compilation*'.
d3cb357b 282
55dfd2c4
RS
283You can then use the command \\[next-error] to find the next error message
284and move to the source code that caused it.
285
08b1edf4
RM
286Interactively, prompts for the command if `compilation-read-command' is
287non-nil; otherwise uses `compile-command'. With prefix arg, always prompts.
288
55dfd2c4 289To run more than one compilation at once, start one and rename the
d3cb357b
RM
290\`*compilation*' buffer to some other name with \\[rename-buffer].
291Then start the next one.
292
293The name used for the buffer is actually whatever is returned by
294the function in `compilation-buffer-name-function', so you can set that
295to a function that generates a unique name."
90016295 296 (interactive
08b1edf4 297 (if (or compilation-read-command current-prefix-arg)
90016295
RS
298 (list (read-from-minibuffer "Compile command: "
299 compile-command nil nil
300 '(compile-history . 1)))
301 (list compile-command)))
55dfd2c4 302 (setq compile-command command)
90016295 303 (save-some-buffers (not compilation-ask-about-save) nil)
d3cb357b 304 (compile-internal compile-command "No more errors"))
55dfd2c4 305
e60476ca
RS
306;;; run compile with the default command line
307(defun recompile ()
308 "Re-compile the program including the current buffer."
309 (interactive)
310 (save-some-buffers (not compilation-ask-about-save) nil)
311 (compile-internal compile-command "No more errors"))
09843b4a
RS
312
313;; The system null device. (Should reference NULL_DEVICE from C.)
314(defvar grep-null-device "/dev/null" "The system null device.")
315
d3cb357b 316;;;###autoload
55dfd2c4
RS
317(defun grep (command-args)
318 "Run grep, with user-specified args, and collect output in a buffer.
319While grep runs asynchronously, you can use the \\[next-error] command
d3cb357b
RM
320to find the text that grep hits refer to.
321
770970cb
RS
322This command uses a special history list for its arguments, so you can
323easily repeat a grep command."
55dfd2c4 324 (interactive
770970cb 325 (list (read-from-minibuffer "Run grep (like this): "
98b63c41 326 grep-command nil nil 'grep-history)))
01f89d11
RM
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)))
331 (save-excursion
332 (set-buffer buf)
333 (set (make-local-variable 'compilation-exit-message-function)
334 (lambda (proc msg)
335 (let ((code (process-exit-status proc)))
336 (if (eq (process-status proc) 'exit)
337 (cond ((zerop code)
338 '("finished (matches found)\n" . "matched"))
339 ((= code 1)
340 '("finished with no matches found\n" . "no match"))
341 (t
342 (cons msg code)))
343 (cons msg code))))))))
55dfd2c4
RS
344
345(defun compile-internal (command error-message
d3cb357b
RM
346 &optional name-of-mode parser regexp-alist
347 name-function)
55dfd2c4
RS
348 "Run compilation command COMMAND (low level interface).
349ERROR-MESSAGE is a string to print if the user asks to see another error
350and there are no more errors. Third argument NAME-OF-MODE is the name
d3cb357b
RM
351to display as the major mode in the compilation buffer.
352
353Fourth arg PARSER is the error parser function (nil means the default). Fifth
354arg REGEXP-ALIST is the error message regexp alist to use (nil means the
355default). Sixth arg NAME-FUNCTION is a function called to name the buffer (nil
356means the default). The defaults for these variables are the global values of
357\`compilation-parse-errors-function', `compilation-error-regexp-alist', and
646bd331
RM
358\`compilation-buffer-name-function', respectively.
359
360Returns the compilation buffer created."
d3cb357b 361 (let (outbuf)
55dfd2c4 362 (save-excursion
d3cb357b
RM
363 (or name-of-mode
364 (setq name-of-mode "Compilation"))
365 (setq outbuf
366 (get-buffer-create
367 (funcall (or name-function compilation-buffer-name-function
368 (function (lambda (mode)
369 (concat "*" (downcase mode) "*"))))
370 name-of-mode)))
371 (set-buffer outbuf)
372 (let ((comp-proc (get-buffer-process (current-buffer))))
373 (if comp-proc
374 (if (or (not (eq (process-status comp-proc) 'run))
375 (yes-or-no-p
bea1d57a
JB
376 (format "A %s process is running; kill it? "
377 name-of-mode)))
d3cb357b
RM
378 (condition-case ()
379 (progn
380 (interrupt-process comp-proc)
381 (sit-for 1)
382 (delete-process comp-proc))
383 (error nil))
384 (error "Cannot have two processes in `%s' at once"
385 (buffer-name))
386 )))
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)
501cf428 393 outwin)
d3cb357b
RM
394 (save-excursion
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.
398 (set-buffer outbuf)
399 (setq buffer-read-only nil)
5d5ab7ac 400 (buffer-disable-undo (current-buffer))
d3cb357b 401 (erase-buffer)
5d5ab7ac 402 (buffer-enable-undo (current-buffer))
d3cb357b
RM
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))
d4ece679
RS
412 (save-excursion
413 (set-buffer outbuf)
414 (compilation-mode)
a72ba929 415 ;; (setq buffer-read-only t) ;;; Non-ergonomic.
d4ece679
RS
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)))
c94b02d6 425 (compilation-set-window-height outwin)
d4ece679 426 ;; Start the compilation.
35f7e85b 427 (if (fboundp 'start-process)
2bb240a9
RS
428 (let* ((process-environment (cons "EMACS=t" process-environment))
429 (proc (start-process-shell-command (downcase mode-name)
430 outbuf
431 command)))
35f7e85b
RS
432 (set-process-sentinel proc 'compilation-sentinel)
433 (set-process-filter proc 'compilation-filter)
434 (set-marker (process-mark proc) (point) outbuf)
501cf428 435 (setq compilation-in-progress
35f7e85b
RS
436 (cons proc compilation-in-progress)))
437 ;; No asynchronous processes available
438 (message (format "Executing `%s'..." command))
d3e56891
RS
439 ;; Fake modeline display as if `start-process' were run.
440 (setq mode-line-process ":run")
4dba7b41 441 (sit-for 0) ;; Force redisplay
35f7e85b 442 (let ((status (call-process shell-file-name nil outbuf nil "-c"
d3e56891
RS
443 command))
444 finish-msg)
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))
449 (t ":exit[???]")))
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'.
453 (setq finish-msg
454 (if (numberp status)
455 (if (zerop status)
456 "finished\n"
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)
461 (forward-char -1)
462 (insert " at " (substring (current-time-string) 0 19)) ; no year
463 (forward-char 1)
464 (if compilation-finish-function
465 (funcall compilation-finish-function outbuf finish-msg)))
466 (message (format "Executing `%s'...done" command)))))
d3cb357b
RM
467 ;; Make it so the next C-x ` will use this buffer.
468 (setq compilation-last-buffer outbuf)))
55dfd2c4 469
c94b02d6
RS
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))))
8205cbfc
RS
477 ;; This save-excursion prevents us from changing the current buffer,
478 ;; which might not be the same as the selected window's buffer.
479 (save-excursion
480 (let ((w (selected-window)))
481 (unwind-protect
482 (progn
483 (select-window window)
484 (enlarge-window (- compilation-window-height
485 (window-height))))
486 (select-window w))))))
c94b02d6 487
0b18a8f6 488(defvar compilation-minor-mode-map
55dfd2c4 489 (let ((map (make-sparse-keymap)))
f98494a4 490 (define-key map [mouse-2] 'compile-mouse-goto-error)
55dfd2c4 491 (define-key map "\C-c\C-c" 'compile-goto-error)
4e7ce12e 492 (define-key map "\C-m" 'compile-goto-error)
d3cb357b 493 (define-key map "\C-c\C-k" 'kill-compilation)
646bd331
RM
494 (define-key map "\M-n" 'compilation-next-error)
495 (define-key map "\M-p" 'compilation-previous-error)
d1ed4475
RM
496 (define-key map "\M-{" 'compilation-previous-file)
497 (define-key map "\M-}" 'compilation-next-file)
55dfd2c4 498 map)
4f6e4ad6 499 "Keymap for `compilation-minor-mode'.")
0b18a8f6
RM
500
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)
e60476ca
RS
505 ;; Set up the menu-bar
506 (define-key map [menu-bar compilation-menu]
507 (cons "Compile" (make-sparse-keymap "Compile")))
508
509 (define-key map [menu-bar compilation-menu compilation-mode-kill-compilation]
0949ba2b 510 '("Stop Compilation" . kill-compilation))
e60476ca
RS
511 (define-key map [menu-bar compilation-menu compilation-mode-separator2]
512 '("----" . nil))
513 (define-key map [menu-bar compilation-menu compilation-mode-first-error]
0949ba2b 514 '("First Error" . first-error))
e60476ca 515 (define-key map [menu-bar compilation-menu compilation-mode-previous-error]
0949ba2b 516 '("Previous Error" . previous-error))
e60476ca 517 (define-key map [menu-bar compilation-menu compilation-mode-next-error]
0949ba2b 518 '("Next Error" . next-error))
e60476ca
RS
519 (define-key map [menu-bar compilation-menu compilation-separator2]
520 '("----" . nil))
521 (define-key map [menu-bar compilation-menu compilation-mode-grep]
522 '("Grep" . 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))
0b18a8f6
RM
527 map)
528 "Keymap for compilation log buffers.
4f6e4ad6 529`compilation-minor-mode-map' is a cdr of this.")
55dfd2c4 530
501cf428 531;;;###autoload
55dfd2c4
RS
532(defun compilation-mode ()
533 "Major mode for compilation log buffers.
534\\<compilation-mode-map>To visit the source for a line-numbered error,
d3cb357b 535move point to the error message line and type \\[compile-goto-error].
7c163413
RM
536To kill the compilation, type \\[kill-compilation].
537
538Runs `compilation-mode-hook' with `run-hooks' (which see)."
55dfd2c4 539 (interactive)
9af0d309 540 (kill-all-local-variables)
55dfd2c4 541 (use-local-map compilation-mode-map)
0b18a8f6
RM
542 (setq major-mode 'compilation-mode
543 mode-name "Compilation")
544 (compilation-setup)
63a2daf6
SM
545 (set (make-local-variable 'font-lock-defaults)
546 '(compilation-mode-font-lock-keywords t))
0b18a8f6
RM
547 (run-hooks 'compilation-mode-hook))
548
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.
ebf0b439 552 (setq mode-line-process '(":%s"))
d3cb357b
RM
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)
0b18a8f6
RM
557 (setq compilation-last-buffer (current-buffer)))
558
559(defvar compilation-minor-mode nil
560 "Non-nil when in compilation-minor-mode.
561In this minor mode, all the error-parsing commands of the
562Compilation major mode are available.")
d6bd8dca 563(make-variable-buffer-local 'compilation-minor-mode)
0b18a8f6
RM
564
565(or (assq 'compilation-minor-mode minor-mode-alist)
566 (setq minor-mode-alist (cons '(compilation-minor-mode " Compilation")
567 minor-mode-alist)))
568(or (assq 'compilation-minor-mode minor-mode-map-alist)
4f6e4ad6
RS
569 (setq minor-mode-map-alist (cons (cons 'compilation-minor-mode
570 compilation-minor-mode-map)
0b18a8f6
RM
571 minor-mode-map-alist)))
572
d6bd8dca 573;;;###autoload
0b18a8f6
RM
574(defun compilation-minor-mode (&optional arg)
575 "Toggle compilation minor mode.
576With arg, turn compilation mode on if and only if arg is positive.
577See `compilation-mode'."
578 (interactive "P")
579 (if (setq compilation-minor-mode (if (null arg)
580 (null compilation-minor-mode)
581 (> (prefix-numeric-value arg) 0)))
582 (compilation-setup)))
55dfd2c4
RS
583
584;; Called when compilation process changes state.
55dfd2c4 585(defun compilation-sentinel (proc msg)
d3cb357b
RM
586 "Sentinel for compilation buffers."
587 (let ((buffer (process-buffer proc)))
ebff767c
RM
588 (if (memq (process-status proc) '(signal exit))
589 (progn
590 (if (null (buffer-name buffer))
591 ;; buffer killed
592 (set-process-buffer proc nil)
593 (let ((obuf (current-buffer))
256e4874 594 omax opoint)
ebff767c
RM
595 ;; save-excursion isn't the right thing if
596 ;; process-buffer is current-buffer
597 (unwind-protect
598 (progn
599 ;; Write something in the compilation buffer
600 ;; and hack its mode line.
601 (set-buffer buffer)
256e4874
RS
602 (let ((buffer-read-only nil)
603 (status (if compilation-exit-message-function
604 (funcall compilation-exit-message-function
605 proc msg)
606 (cons msg (process-exit-status proc)))))
fdcba502
RS
607 (setq omax (point-max)
608 opoint (point))
609 (goto-char omax)
610 ;; Record where we put the message, so we can ignore it
611 ;; later on.
01f89d11 612 (insert ?\n mode-name " " (car status))
fdcba502
RS
613 (forward-char -1)
614 (insert " at " (substring (current-time-string) 0 19))
615 (forward-char 1)
616 (setq mode-line-process
01f89d11
RM
617 (format ":%s [%s]"
618 (process-status proc) (cdr status)))
fdcba502
RS
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.
5d5ab7ac 624 (force-mode-line-update))
ebff767c 625 (if (and opoint (< opoint omax))
6c43f2f9
RS
626 (goto-char opoint))
627 (if compilation-finish-function
628 (funcall compilation-finish-function buffer msg)))
629 (set-buffer obuf))))
ebff767c
RM
630 (setq compilation-in-progress (delq proc compilation-in-progress))
631 ))))
55dfd2c4 632
ad62b7f1
RM
633(defun compilation-filter (proc string)
634 "Process filter for compilation buffers.
4f6e4ad6 635Just inserts the text, but uses `insert-before-markers'."
991c70f8 636 (if (buffer-name (process-buffer proc))
ad62b7f1 637 (save-excursion
991c70f8
RS
638 (set-buffer (process-buffer proc))
639 (let ((buffer-read-only nil))
640 (save-excursion
641 (goto-char (process-mark proc))
642 (insert-before-markers string)
643 (set-marker (process-mark proc) (point)))))))
ad62b7f1 644
b5bb472e
RM
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))
649 (while (and errors
650 (> (point) (car (car errors))))
651 (setq errors (cdr errors)))
652 errors))
653
51ba27e7 654(defsubst compilation-buffer-p (buffer)
20c1daec
RM
655 (save-excursion
656 (set-buffer buffer)
657 (or compilation-minor-mode (eq major-mode 'compilation-mode))))
51ba27e7 658
646bd331
RM
659(defun compilation-next-error (n)
660 "Move point to the next error in the compilation buffer.
661Does NOT find the source line like \\[next-error]."
662 (interactive "p")
663 (or (compilation-buffer-p (current-buffer))
664 (error "Not in a compilation buffer."))
665 (setq compilation-last-buffer (current-buffer))
b5bb472e
RM
666
667 (let ((errors (compile-error-at-point)))
668
669 ;; Move to the error after the one containing point.
670 (goto-char (car (if (< n 0)
671 (let ((i 0)
672 (e compilation-old-error-list))
673 ;; See how many cdrs away ERRORS is from the start.
674 (while (not (eq e errors))
675 (setq i (1+ i)
676 e (cdr e)))
677 (if (> (- n) i)
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"))))))))
646bd331
RM
685
686(defun compilation-previous-error (n)
687 "Move point to the previous error in the compilation buffer.
688Does NOT find the source line like \\[next-error]."
689 (interactive "p")
690 (compilation-next-error (- n)))
691
692
fc0094d7
RM
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)
b5bb472e
RM
697 (setq data (cdr data))
698 (if (markerp data)
fc0094d7 699 (marker-buffer data)
aead2f9f 700 (car data)))
b5bb472e 701
fc0094d7
RM
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)
708 (car filedata)))
709
b5bb472e
RM
710(defun compilation-next-file (n)
711 "Move point to the next error for a different file than the current one."
712 (interactive "p")
713 (or (compilation-buffer-p (current-buffer))
714 (error "Not in a compilation buffer."))
715 (setq compilation-last-buffer (current-buffer))
716
717 (let ((reversed (< n 0))
fc0094d7 718 errors filedata)
b5bb472e
RM
719
720 (if (not reversed)
721 (setq errors (or (compile-error-at-point)
722 (error "Moved past last error")))
723
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)
727 n (- n))
728
729 ;; Ignore errors after point. (car ERRORS) will be the error
730 ;; containing point, (cadr ERRORS) the one before it.
731 (while (and errors
732 (< (point) (car (car errors))))
733 (setq errors (cdr errors))))
734
735 (while (> n 0)
fc0094d7
RM
736 (setq filedata (compilation-error-filedata (car errors)))
737
738 ;; Skip past the following errors for this file.
739 (while (equal filedata
740 (compilation-error-filedata
741 (car (or errors
742 (if reversed
743 (error "%s the first erring file"
744 (compilation-error-filedata-file-name
745 filedata))
746 (let ((compilation-error-list nil))
747 ;; Parse some more.
748 (compile-reinitialize-errors nil nil 2)
749 (setq errors compilation-error-list)))
501cf428 750 (error "%s is the last erring file"
fc0094d7
RM
751 (compilation-error-filedata-file-name
752 filedata))))))
b5bb472e
RM
753 (setq errors (cdr errors)))
754
755 (setq n (1- n)))
756
757 ;; Move to the following error.
758 (goto-char (car (car (or errors
759 (if reversed
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))))))))
765
766(defun compilation-previous-file (n)
767 "Move point to the previous error for a different file than the current one."
768 (interactive "p")
769 (compilation-next-file (- n)))
770
771
55dfd2c4
RS
772(defun kill-compilation ()
773 "Kill the process made by the \\[compile] command."
774 (interactive)
d3cb357b 775 (let ((buffer (compilation-find-buffer)))
55dfd2c4 776 (if (get-buffer-process buffer)
d3cb357b
RM
777 (interrupt-process (get-buffer-process buffer))
778 (error "The compilation process is not running."))))
779
55dfd2c4 780
d3cb357b
RM
781;; Parse any new errors in the compilation buffer,
782;; or reparse from the beginning if the user has asked for that.
eaa3cac5
RM
783(defun compile-reinitialize-errors (reparse
784 &optional limit-search find-at-least)
d3cb357b
RM
785 (save-excursion
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)
eaa3cac5 790 reparse)
51ba27e7 791 (compilation-forget-errors))
c540863c 792 (if (and compilation-error-list
b5bb472e
RM
793 (or (not limit-search)
794 (> compilation-parsing-end limit-search))
c540863c 795 (or (not find-at-least)
a72ba929 796 (>= (length compilation-error-list) find-at-least)))
d3cb357b
RM
797 ;; Since compilation-error-list is non-nil, it points to a specific
798 ;; error the user wanted. So don't move it around.
799 nil
51ba27e7
RM
800 ;; This was here for a long time (before my rewrite); why? --roland
801 ;;(switch-to-buffer compilation-last-buffer)
55dfd2c4 802 (set-buffer-modified-p nil)
b5bb472e 803 (if (< compilation-parsing-end (point-max))
51ba27e7 804 ;; compilation-error-list might be non-nil if we have a non-nil
676a14e1 805 ;; LIMIT-SEARCH or FIND-AT-LEAST arg. In that case its value
51ba27e7
RM
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))
b5bb472e 809 (funcall compilation-parse-errors-function
51ba27e7
RM
810 limit-search
811 (and find-at-least
812 ;; We only need enough new parsed errors to reach
813 ;; FIND-AT-LEAST errors past the current
814 ;; position.
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))
822 (if error-list-pos
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))
b5bb472e 826 )))))
55dfd2c4 827
f98494a4
RS
828(defun compile-mouse-goto-error (event)
829 (interactive "e")
e78e10ca
KH
830 (save-excursion
831 (set-buffer (window-buffer (posn-window (event-end event))))
832 (goto-char (posn-point (event-end event)))
833
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))
838
839 ;; Move to bol; the marker for the error on this line will point there.
840 (beginning-of-line)
841
842 ;; Move compilation-error-list to the elt of compilation-old-error-list
843 ;; we want.
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.
853 (or (one-window-p)
854 (progn
855 (other-window -1)
856 ;; other-window changed the selected buffer,
857 ;; but we didn't want to do that.
858 (set-buffer compilation-last-buffer)))
859
860 (push-mark)
861 (next-error 1))
f98494a4 862
55dfd2c4
RS
863(defun compile-goto-error (&optional argp)
864 "Visit the source for the error message point is on.
31efa7c9 865Use this command in a compilation log buffer. Sets the mark at point there.
b2bb6ec8 866\\[universal-argument] as a prefix arg means to reparse the buffer's error messages first;
55dfd2c4
RS
867other kinds of prefix arguments are ignored."
868 (interactive "P")
d3cb357b
RM
869 (or (compilation-buffer-p (current-buffer))
870 (error "Not in a compilation buffer."))
871 (setq compilation-last-buffer (current-buffer))
eaa3cac5 872 (compile-reinitialize-errors (consp argp) (point))
646bd331 873
15d1a8da
RM
874 ;; Move to bol; the marker for the error on this line will point there.
875 (beginning-of-line)
876
646bd331 877 ;; Move compilation-error-list to the elt of compilation-old-error-list
643f763f 878 ;; we want.
646bd331 879 (setq compilation-error-list compilation-old-error-list)
643f763f
RM
880 (while (and compilation-error-list
881 (> (point) (car (car compilation-error-list))))
646bd331
RM
882 (setq compilation-error-list (cdr compilation-error-list)))
883
55dfd2c4
RS
884 ;; Move to another window, so that next-error's window changes
885 ;; result in the desired setup.
886 (or (one-window-p)
646bd331
RM
887 (progn
888 (other-window -1)
889 ;; other-window changed the selected buffer,
890 ;; but we didn't want to do that.
891 (set-buffer compilation-last-buffer)))
892
31efa7c9 893 (push-mark)
643f763f 894 (next-error 1))
55dfd2c4 895
d3cb357b
RM
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.
4746118a
JB
901(defun compilation-find-buffer (&optional other-buffer)
902 (if (and (not other-buffer)
903 (compilation-buffer-p (current-buffer)))
d3cb357b
RM
904 ;; The current buffer is a compilation buffer.
905 (current-buffer)
4746118a
JB
906 (if (and compilation-last-buffer (buffer-name compilation-last-buffer)
907 (or (not other-buffer) (not (eq compilation-last-buffer
908 (current-buffer)))))
d3cb357b
RM
909 compilation-last-buffer
910 (let ((buffers (buffer-list)))
4746118a
JB
911 (while (and buffers (or (not (compilation-buffer-p (car buffers)))
912 (and other-buffer
913 (eq (car buffers) (current-buffer)))))
d3cb357b
RM
914 (setq buffers (cdr buffers)))
915 (if buffers
916 (car buffers)
4746118a
JB
917 (or (and other-buffer
918 (compilation-buffer-p (current-buffer))
919 ;; The current buffer is a compilation buffer.
920 (progn
921 (if other-buffer
922 (message "This is the only compilation buffer."))
923 (current-buffer)))
924 (error "No compilation started!")))))))
d3cb357b
RM
925
926;;;###autoload
55dfd2c4
RS
927(defun next-error (&optional argp)
928 "Visit next compilation error message and corresponding source code.
929This operates on the output from the \\[compile] command.
930If all preparsed error messages have been processed,
931the error message buffer is checked for new ones.
932
933A prefix arg specifies how many error messages to move;
934negative means move back to previous error messages.
935Just C-u as a prefix means reparse the error message buffer
936and start at the first error.
937
938\\[next-error] normally applies to the most recent compilation started,
939but as long as you are in the middle of parsing errors from one compilation
940output buffer, you stay with that compilation output buffer.
941
942Use \\[next-error] in a compilation output buffer to switch to
943processing errors from that compilation.
944
d3cb357b
RM
945See variables `compilation-parse-errors-function' and
946\`compilation-error-regexp-alist' for customization ideas."
55dfd2c4 947 (interactive "P")
d3cb357b 948 (setq compilation-last-buffer (compilation-find-buffer))
eaa3cac5
RM
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))
954 (consp argp))))
955;;;###autoload (define-key ctl-x-map "`" 'next-error)
956
e60476ca
RS
957(defun previous-error ()
958 "Visit previous compilation error message and corresponding source code.
959This operates on the output from the \\[compile] command."
960 (interactive)
eae2c972 961 (next-error -1))
e60476ca
RS
962
963(defun first-error ()
964 "Reparse the error message buffer and start at the first error
965Visit corresponding source code.
966This operates on the output from the \\[compile] command."
967 (interactive)
eae2c972 968 (next-error '(4)))
e60476ca 969
b4300a1a 970(defun compilation-next-error-locus (&optional move reparse silent)
eaa3cac5
RM
971 "Visit next compilation error and return locus in corresponding source code.
972This operates on the output from the \\[compile] command.
973If all preparsed error messages have been processed,
974the error message buffer is checked for new ones.
975
976Returns a cons (ERROR . SOURCE) of two markers: ERROR is a marker at the
977location of the error message in the compilation buffer, and SOURCE is a
978marker at the location in the source code indicated by the error message.
979
980Optional first arg MOVE says how many error messages to move forwards (or
981backwards, if negative); default is 1. Optional second arg REPARSE, if
982non-nil, says to reparse the error message buffer and reset to the first
501cf428 983error (plus MOVE - 1). If optional third argument SILENT is non-nil, return
b4300a1a 984nil instead of raising an error if there are no more errors.
eaa3cac5
RM
985
986The 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))))
d3cb357b 990 (let (next-errors next-error)
7fb63acd
RS
991 (catch 'no-next-error
992 (save-excursion
993 (set-buffer compilation-last-buffer)
994 ;; compilation-error-list points to the "current" error.
501cf428 995 (setq next-errors
7fb63acd
RS
996 (if (> move 0)
997 (nthcdr (1- move)
998 compilation-error-list)
999 ;; Zero or negative arg; we need to move back in the list.
1000 (let ((n (1- move))
1001 (i 0)
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))
1005 (setq i (1+ i)
1006 e (cdr e)))
1007 (if (> (- n) i)
1008 (error "Moved back past first error")
1009 (nthcdr (+ i n) compilation-old-error-list))))
1010 next-error (car next-errors))
1011 (while
1012 (if (null next-error)
1013 (progn
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))
1020 (eq (process-status
1021 (get-buffer-process
1022 (current-buffer)))
1023 'run)))
1024 (compilation-forget-errors))
1025 (if silent
1026 (throw 'no-next-error nil)
1027 (error (concat compilation-error-message
1028 (and (get-buffer-process (current-buffer))
1029 (eq (process-status
1030 (get-buffer-process
1031 (current-buffer)))
1032 'run)
b4300a1a 1033 " yet")))))
7fb63acd
RS
1034 (setq compilation-error-list (cdr next-errors))
1035 (if (null (cdr next-error))
1036 ;; This error is boring. Go to the next.
1037 t
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)))
20c1daec
RM
1042 (buffer (apply 'compilation-find-file
1043 (car next-error) fileinfo)))
7fb63acd
RS
1044 (if (null buffer)
1045 ;; We can't find this error's file.
1046 ;; Remove all errors in the same file.
1047 (progn
1048 (setq next-errors compilation-old-error-list)
1049 (while next-errors
1050 (and (consp (cdr (car next-errors)))
1051 (equal (car (cdr (car next-errors)))
1052 fileinfo)
1053 (progn
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.
1058 t)
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))))
1066 (set-buffer buffer)
1067 (save-excursion
1068 (save-restriction
1069 (widen)
1070 (goto-line last-line)
4dbf8a2c 1071 (if (and column (> column 0))
4ad26d84
RM
1072 ;; Columns in error msgs are 1-origin.
1073 (move-to-column (1- column))
7fb63acd
RS
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.
1078 (while errors
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.
1088 (if (< lines 0)
1089 (re-search-backward "[\n\C-m]"
1090 nil 'end
1091 (- lines))
1092 (re-search-forward "[\n\C-m]"
1093 nil 'end
1094 lines))
1095 (forward-line lines))
eae2c972
RM
1096 (if (and column (> column 1))
1097 (move-to-column (1- column))
1098 (beginning-of-line))
7fb63acd
RS
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
b4300a1a 1107 next-error (car next-errors)))))
d3cb357b
RM
1108
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)))
1114
eaa3cac5
RM
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.
1117 next-error))
1118
1119(defun compilation-goto-locus (next-error)
1120 "Jump to an error locus returned by `compilation-next-error-locus'.
1121Takes one argument, a cons (ERROR . SOURCE) of two markers.
1122Selects a window with point at SOURCE, with another window displaying ERROR."
e89a7d77
RS
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))))
eaa3cac5
RM
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)))
1131 (progn
1132 (widen)
1133 (goto-char (cdr next-error))))
1134
1135 ;; Show compilation buffer in other window, scrolled to this error.
1136 (let* ((pop-up-windows t)
eae2c972 1137 ;; Use an existing window if it is in a visible frame.
c94b02d6 1138 (w (or (get-buffer-window (marker-buffer (car next-error)) 'visible)
eae2c972 1139 ;; Pop up a window.
c94b02d6 1140 (display-buffer (marker-buffer (car next-error))))))
eaa3cac5 1141 (set-window-point w (car next-error))
c94b02d6
RS
1142 (set-window-start w (car next-error))
1143 (compilation-set-window-height w)))
eaa3cac5 1144\f
d3cb357b
RM
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.
20c1daec
RM
1151(defun compilation-find-file (marker filename dir &rest formats)
1152 (or formats (setq formats '("%s")))
d3cb357b 1153 (let ((dirs compilation-search-path)
cd494de4
RM
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))
20c1daec
RM
1163 (setq thisdir (or (car dirs) dir)
1164 fmts formats)
cd494de4
RM
1165 ;; For each directory, try each format string.
1166 (while (and fmts (null buffer))
20c1daec 1167 (setq name (expand-file-name (format (car fmts) filename) thisdir)
cd494de4 1168 buffer (and (file-exists-p name)
20c1daec
RM
1169 (find-file-noselect name))
1170 fmts (cdr fmts)))
1171 (setq dirs (cdr dirs)))
cd494de4 1172 (or buffer
d3cb357b
RM
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.
cd494de4
RM
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
1182 (read-file-name
1183 (format "Find this error in: (default %s) "
1184 filename)
1185 dir filename t))))
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)))))))
d3cb357b
RM
1190
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
646bd331 1194;; do it right away.
55dfd2c4
RS
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)
d3cb357b
RM
1199 (if (markerp (cdr next-error))
1200 (set-marker (cdr next-error) nil)))
55dfd2c4 1201 (setq compilation-old-error-list (cdr compilation-old-error-list)))
bd3910fe 1202 (setq compilation-error-list nil
51ba27e7
RM
1203 compilation-directory-stack nil
1204 compilation-parsing-end 1))
d3cb357b
RM
1205
1206
1207(defun count-regexp-groupings (regexp)
1208 "Return the number of \\( ... \\) groupings in REGEXP (a string)."
1209 (let ((groupings 0)
1210 (len (length regexp))
1211 (i 0)
1212 c)
1213 (while (< i len)
1214 (setq c (aref regexp i)
1215 i (1+ i))
1216 (cond ((= c ?\[)
1217 ;; Find the end of this [...].
1218 (while (and (< i len)
1219 (not (= (aref regexp i) ?\])))
1220 (setq i (1+ i))))
1221 ((= c ?\\)
1222 (if (< i len)
1223 (progn
1224 (setq c (aref regexp i)
1225 i (1+ i))
1226 (if (= c ?\))
1227 ;; We found the end of a grouping,
1228 ;; so bump our counter.
1229 (setq groupings (1+ groupings))))))))
1230 groupings))
55dfd2c4 1231
c540863c 1232(defun compilation-parse-errors (limit-search find-at-least)
55dfd2c4 1233 "Parse the current buffer as grep, cc or lint error messages.
d3cb357b 1234See variable `compilation-parse-errors-function' for the interface it uses."
55dfd2c4
RS
1235 (setq compilation-error-list nil)
1236 (message "Parsing error messages...")
51501e54 1237 (let (text-buffer orig orig-expanded parent-expanded
d3cb357b 1238 regexp enter-group leave-group error-group
b2bb6ec8 1239 alist subexpr error-regexp-groups
c540863c 1240 (found-desired nil)
6c43f2f9 1241 (compilation-num-errors-found 0))
d3cb357b 1242
55dfd2c4
RS
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.
1247 (if (bobp)
2e4301ef
RM
1248 (progn
1249 (forward-line 2)
1250 ;; Move back so point is before the newline.
1251 ;; This matters because some error regexps use \n instead of ^
1252 ;; to be faster.
1253 (forward-char -1)))
d3cb357b
RM
1254
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
1259 (lambda (elt)
1260 (concat "\\(" (car elt) "\\)")))
1261 compilation-error-regexp-alist
1262 "\\|") "\\)"))
1263
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.
1268 (setq enter-group 1
1269 leave-group (+ enter-group
1270 (count-regexp-groupings
1271 compilation-enter-directory-regexp)
1272 1)
1273 error-group (+ leave-group
1274 (count-regexp-groupings
1275 compilation-leave-directory-regexp)
1276 1))
1277
72244bea
RM
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).
d4035a26
RM
1282 (setq alist (or compilation-error-regexp-alist
1283 (error "compilation-error-regexp-alist is empty!"))
d3cb357b
RM
1284 subexpr (1+ error-group))
1285 (while alist
72244bea
RM
1286 (setq error-regexp-groups
1287 (cons (list subexpr
1288 (+ subexpr (nth 1 (car alist)))
1289 (+ subexpr (nth 2 (car alist)))
8425a49a
RM
1290 (and (nth 3 (car alist))
1291 (+ subexpr (nth 3 (car alist)))))
72244bea 1292 error-regexp-groups))
d3cb357b
RM
1293 (setq subexpr (+ subexpr 1 (count-regexp-groupings (car (car alist)))))
1294 (setq alist (cdr alist)))
1295
cd494de4
RM
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)))
51501e54 1304
646bd331 1305 (while (and (not found-desired)
b2bb6ec8
RM
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.
646bd331 1309 (re-search-forward regexp nil t))
dadb11fb 1310
d3cb357b
RM
1311 ;; Figure out which constituent regexp matched.
1312 (cond ((match-beginning enter-group)
1313 ;; The match was the enter-directory regexp.
1314 (let ((dir
1315 (file-name-as-directory
1316 (expand-file-name
1317 (buffer-substring (match-beginning (+ enter-group 1))
1318 (match-end (+ enter-group 1)))))))
51501e54
RS
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.
1322 (setq dir
1323 (compile-abbreviate-directory dir orig orig-expanded
1324 parent-expanded))
d3cb357b
RM
1325 (setq compilation-directory-stack
1326 (cons dir compilation-directory-stack))
1327 (and (file-directory-p dir)
51ba27e7
RM
1328 (setq default-directory dir)))
1329
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)))
1338
d3cb357b
RM
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))
1343 (if beg
1344 (let ((dir
1345 (file-name-as-directory
1346 (expand-file-name
1347 (buffer-substring beg
1348 (match-end (+ leave-group
1349 1)))))))
cd494de4 1350 ;; The directory name in the "leaving" message
51501e54
RS
1351 ;; is a truename. Try to convert it to a form
1352 ;; like what the user typed in.
1353 (setq dir
1354 (compile-abbreviate-directory dir orig orig-expanded
1355 parent-expanded))
d3cb357b
RM
1356 (while (and stack
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))
1361 (if stack
1362 (setq default-directory stack))
51ba27e7
RM
1363 )
1364
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)))
1373
d3cb357b
RM
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)
1378 (while (and alist
1379 (null (match-beginning (car (car alist)))))
1380 (setq alist (cdr alist)))
1381 (if alist
1382 (setq alist (car alist))
d4035a26 1383 (error "compilation-parse-errors: impossible regexp match!"))
501cf428 1384
d3cb357b 1385 ;; Extract the file name and line number from the error message.
1f82d0e4 1386 (let ((beginning-of-match (match-beginning 0)) ;looking-at nukes
1e0e614d
RM
1387 (filename (buffer-substring (match-beginning (nth 1 alist))
1388 (match-end (nth 1 alist))))
72244bea
RM
1389 (linenum (string-to-int
1390 (buffer-substring
1391 (match-beginning (nth 2 alist))
1392 (match-end (nth 2 alist)))))
1393 (column (and (nth 3 alist)
08b1edf4 1394 (match-beginning (nth 3 alist))
72244bea
RM
1395 (string-to-int
1396 (buffer-substring
1397 (match-beginning (nth 3 alist))
1398 (match-end (nth 3 alist)))))))
1399
1e0e614d
RM
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)))
20c1daec
RM
1409 (setq filename (cons filename (cons default-directory
1410 (nthcdr 4 alist))))
501cf428 1411
1e0e614d 1412
d3cb357b
RM
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.
1417 (save-excursion
eae2c972
RM
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))
ba2700db 1423 (let ((this (cons (point-marker)
533304f8 1424 (list filename linenum column))))
ba2700db
RS
1425 ;; Don't add the same source line more than once.
1426 (if (equal (cdr this) (cdr (car compilation-error-list)))
1427 nil
1428 (setq compilation-error-list
1429 (cons this
1430 compilation-error-list))
1431 (setq compilation-num-errors-found
1432 (1+ compilation-num-errors-found)))))
51ba27e7
RM
1433 (and (or (and find-at-least (> compilation-num-errors-found
1434 find-at-least))
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.
1f82d0e4
RM
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)))))
1445 (progn
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)))
1455 )
41acdfa9 1456 )
d3cb357b 1457 (t
d4035a26 1458 (error "compilation-parse-errors: known groups didn't match!")))
dadb11fb 1459
51ba27e7 1460 (message "Parsing error messages...%d (%.0f%% of buffer)"
6c43f2f9 1461 compilation-num-errors-found
51ba27e7
RM
1462 ;; Use floating-point because (* 100 (point)) frequently
1463 ;; exceeds the range of Emacs Lisp integers.
1464 (/ (* 100.0 (point)) (point-max)))
dadb11fb 1465
b2bb6ec8
RM
1466 (and limit-search (>= (point) limit-search)
1467 ;; The user wanted a specific error, and we're past it.
1468 (setq found-desired t)))
c540863c
RM
1469 (setq compilation-parsing-end (if found-desired
1470 (point)
1471 ;; We have searched the whole buffer.
1472 (point-max))))
1473 (setq compilation-error-list (nreverse compilation-error-list))
1474 (message "Parsing error messages...done"))
55dfd2c4 1475
51501e54
RS
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)
cd494de4
RM
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))
1486
1e0e614d
RM
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
1489 ;; buffer.)
1490 (if (boundp 'comint-file-name-prefix)
1491 (setq dir (concat comint-file-name-prefix dir)))
1492
51501e54
RS
1493 (if (and (> (length dir) (length orig-expanded))
1494 (string= orig-expanded
1495 (substring dir 0 (length orig-expanded))))
1496 (setq dir
1497 (concat orig
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))))
1502 (setq dir
1503 (concat (file-name-directory
1504 (directory-file-name orig))
1505 (substring dir (length parent-expanded)))))
1506 dir)
1507
4746118a 1508(provide 'compile)
fad160d5
ER
1509
1510;;; compile.el ends here