Commit | Line | Data |
---|---|---|
daa37602 | 1 | ;;; compile.el --- run compiler as inferior of Emacs, parse error messages. |
fad160d5 | 2 | |
3a801d0c ER |
3 | ;; Copyright (C) 1985, 86, 87, 92 Free Software Foundation, Inc. |
4 | ||
29add8b9 | 5 | ;; Author: Roland McGrath <roland@prep.ai.mit.edu> |
d1c7011d | 6 | ;; Maintainer: FSF |
fd7fa35a | 7 | ;; Keyword: tools, processes |
d1c7011d | 8 | |
d3cb357b | 9 | ;;;!!! dup removal is broken. |
fad160d5 | 10 | |
55dfd2c4 RS |
11 | ;; This file is part of GNU Emacs. |
12 | ||
29add8b9 RM |
13 | ;; GNU Emacs is free software; you can redistribute it and/or modify |
14 | ;; it under the terms of the GNU General Public License as published by | |
15 | ;; the Free Software Foundation; either version 2, or (at your option) | |
16 | ;; any later version. | |
17 | ||
55dfd2c4 | 18 | ;; GNU Emacs is distributed in the hope that it will be useful, |
29add8b9 RM |
19 | ;; but WITHOUT ANY WARRANTY; without even the implied warranty of |
20 | ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
21 | ;; GNU General Public License for more details. | |
22 | ||
23 | ;; You should have received a copy of the GNU General Public License | |
24 | ;; along with GNU Emacs; see the file COPYING. If not, write to | |
25 | ;; the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. | |
55dfd2c4 | 26 | |
d1c7011d ER |
27 | ;;; Code: |
28 | ||
7c163413 RM |
29 | ;;;###autoload |
30 | (defvar compilation-mode-hook nil | |
31 | "*List of hook functions run by compilation-mode (see `run-hooks').") | |
32 | ||
33 | ;;;###autoload | |
d3cb357b RM |
34 | (defconst compilation-window-height nil |
35 | "*Number of lines in a compilation window. If nil, use Emacs default.") | |
36 | ||
55dfd2c4 RS |
37 | (defvar compilation-error-list nil |
38 | "List of error message descriptors for visiting erring functions. | |
d3cb357b | 39 | Each error descriptor is a cons (or nil). |
55dfd2c4 | 40 | Its car is a marker pointing to an error message. |
d3cb357b RM |
41 | If its cdr is a marker, it points to the text of the line the message is about. |
42 | If its cdr is a cons, that cons's car is a cons (DIRECTORY . FILE), specifying | |
43 | file the message is about, and its cdr is the number of the line the message | |
44 | is about. Or its cdr may be nil if that error is not interesting. | |
45 | ||
46 | The value may be t instead of a list; this means that the buffer of | |
47 | error messages should be reparsed the next time the list of errors is wanted.") | |
55dfd2c4 RS |
48 | |
49 | (defvar compilation-old-error-list nil | |
50 | "Value of `compilation-error-list' after errors were parsed.") | |
51 | ||
d3cb357b RM |
52 | (defvar compilation-parse-errors-function 'compilation-parse-errors |
53 | "Function to call (with no args) to parse error messages from a compilation. | |
54 | It should read in the source files which have errors and set | |
55 | `compilation-error-list' to a list with an element for each error message | |
56 | found. See that variable for more info.") | |
55dfd2c4 | 57 | |
aa228418 | 58 | ;;;###autoload |
d3cb357b | 59 | (defvar compilation-buffer-name-function nil |
aa228418 | 60 | "*Function to call with one argument, the name of the major mode of the |
d3cb357b RM |
61 | compilation buffer, to give the buffer a name. It should return a string. |
62 | If nil, the name \"*compilation*\" is used for compilation buffers, | |
63 | and the name \"*grep*\" is used for grep buffers. | |
aa228418 | 64 | \(Actually, the name (concat \"*\" (downcase major-mode) \"*\") is used.)") |
55dfd2c4 | 65 | |
aa228418 | 66 | ;;;###autoload |
d3cb357b | 67 | (defvar compilation-finish-function nil |
aa228418 | 68 | "*Function to call when a compilation process finishes. |
d3cb357b RM |
69 | It is called with two arguments: the compilation buffer, and a string |
70 | describing how the process finished.") | |
55dfd2c4 | 71 | |
d3cb357b RM |
72 | (defvar compilation-last-buffer nil |
73 | "The buffer in which the last compilation was started, | |
74 | or which was used by the last \\[next-error] or \\[compile-goto-error].") | |
55dfd2c4 | 75 | |
ebff767c RM |
76 | (defvar compilation-in-progress nil |
77 | "List of compilation processes now running.") | |
78 | (or (assq 'compilation-in-progress minor-mode-alist) | |
79 | (setq minor-mode-alist (cons '(compilation-in-progress " Compiling") | |
80 | minor-mode-alist))) | |
81 | ||
d3cb357b RM |
82 | (defvar compilation-parsing-end nil |
83 | "Position of end of buffer when last error messages were parsed.") | |
84 | ||
85 | (defvar compilation-error-message "No more errors" | |
86 | "Message to print when no more matches for `compilation-error-regexp-alist' | |
87 | are found.") | |
88 | ||
89 | (defvar compilation-error-regexp-alist | |
90 | '( | |
91 | ;; 4.3BSD grep, cc, lint pass 1: | |
92 | ;; /usr/src/foo/foo.c(8): warning: w may be used before set | |
93 | ;; or GNU utilities | |
94 | ;; foo.c:8: error message | |
95 | ("^\\([^:( \t\n]+\\)[:( \t]+\\([0-9]+\\)[:) \t]" 1 2) | |
96 | ;; 4.3BSD lint pass 2 | |
97 | ;; strcmp: variable # of args. llib-lc(359) :: /usr/src/foo/foo.c(8) | |
daa37602 | 98 | ("[ \t:]+\\([^:( \t\n]+\\)[ \t]*[:(]*(+[ \t]*\\([0-9]+\\))[:) \t]*$" 1 2) |
d3cb357b RM |
99 | ;; 4.3BSD lint pass 3 |
100 | ;; bloofle defined( /users/wolfgang/foo.c(4) ), but never used | |
daa37602 JB |
101 | ;; This used to be |
102 | ;; ("[ \t(]+\\([^:( \t\n]+\\)[:( \t]+\\([0-9]+\\)[:) \t]+" 1 2) | |
103 | ;; which is regexp Impressionism - it matches almost anything! | |
104 | ("([ \t]*\\([^:( \t\n]+\\)[ \t]*[:(][ \t]*\\([0-9]+\\))" 1 2) | |
d3cb357b | 105 | ;; Line 45 of "foo.c": bloofel undefined (who does this?) |
daa37602 | 106 | ("^[Ll]ine[ \t]+\\([0-9]+\\)[ \t]+of[ \t]+\"\\([^\"\n]+\\)\":" 2 1) |
d3cb357b RM |
107 | ;; Apollo cc, 4.3BSD fc |
108 | ;; "foo.f", line 3: Error: syntax error near end of statement | |
daa37602 | 109 | ("^\"\\([^\"\n]+\\)\", line \\([0-9]+\\):" 1 2) |
d3cb357b RM |
110 | ;; HP-UX 7.0 fc |
111 | ;; foo.f :16 some horrible error message | |
daa37602 | 112 | ("^\\([^ \t\n:]+\\)[ \t]*:\\([0-9]+\\)" 1 2) |
d3cb357b RM |
113 | ;; IBM AIX PS/2 C version 1.1 |
114 | ;; ****** Error number 140 in line 8 of file errors.c ****** | |
daa37602 | 115 | ("in line \\([0-9]+\\) of file \\([^ \n]+[^. \n]\\)\\.? " 2 1) |
d3cb357b RM |
116 | ;; IBM AIX lint is too painful to do right this way. File name |
117 | ;; prefixes entire sections rather than being on each line. | |
118 | ) | |
119 | "Alist (REGEXP FILE-IDX LINE-IDX) of regular expressions to match errors in | |
120 | compilation. If REGEXP matches, the FILE-IDX'th subexpression gives the file | |
121 | name, and the LINE-IDX'th subexpression gives the line number.") | |
55dfd2c4 | 122 | |
7c163413 | 123 | ;;;###autoload |
d3cb357b | 124 | (defvar compilation-search-path '(nil) |
7c163413 | 125 | "*List of directories to search for source files named in error messages. |
d3cb357b RM |
126 | Elements should be directory names, not file names of directories. |
127 | nil as an element means to try the default directory.") | |
55dfd2c4 RS |
128 | |
129 | (defvar compile-command "make -k " | |
130 | "Last shell command used to do a compilation; default for next compilation. | |
131 | ||
132 | Sometimes it is useful for files to supply local values for this variable. | |
133 | You might also use mode hooks to specify it in certain modes, like this: | |
134 | ||
135 | (setq c-mode-hook | |
136 | '(lambda () (or (file-exists-p \"makefile\") (file-exists-p \"Makefile\") | |
137 | (progn (make-local-variable 'compile-command) | |
138 | (setq compile-command | |
139 | (concat \"make -k \" | |
140 | buffer-file-name))))))") | |
141 | ||
d3cb357b | 142 | (defconst compilation-enter-directory-regexp |
daa37602 | 143 | ": Entering directory `\\(.*\\)'$" |
d3cb357b | 144 | "Regular expression for a line in the compilation log that |
daa37602 | 145 | changes the current directory. This must contain one \\(, \\) pair |
d3cb357b RM |
146 | around the directory name. |
147 | ||
148 | The default value matches lines printed by the `-w' option of GNU Make.") | |
149 | ||
150 | (defconst compilation-leave-directory-regexp | |
daa37602 | 151 | ": Leaving directory `\\(.*\\)'$" |
d3cb357b RM |
152 | "Regular expression for a line in the compilation log that |
153 | changes the current directory to a previous value. This may | |
daa37602 | 154 | contain one \\(, \\) pair around the name of the directory |
d3cb357b RM |
155 | being moved from. If it does not, the last directory entered |
156 | \(by a line matching `compilation-enter-directory-regexp'\) is assumed. | |
157 | ||
158 | The default value matches lines printed by the `-w' option of GNU Make.") | |
159 | ||
160 | (defvar compilation-directory-stack nil | |
161 | "Stack of directories entered by lines matching | |
162 | \`compilation-enter-directory-regexp' and not yet left by lines matching | |
163 | \`compilation-leave-directory-regexp'. The head element is the directory | |
164 | the compilation was started in.") | |
165 | ||
770970cb RS |
166 | ;; History of compile commands. |
167 | (defvar compile-history nil) | |
168 | ;; History of grep commands. | |
169 | (defvar grep-history nil) | |
170 | ||
d3cb357b | 171 | ;;;###autoload |
55dfd2c4 RS |
172 | (defun compile (command) |
173 | "Compile the program including the current buffer. Default: run `make'. | |
174 | Runs COMMAND, a shell command, in a separate process asynchronously | |
175 | with output going to the buffer `*compilation*'. | |
d3cb357b | 176 | |
55dfd2c4 RS |
177 | You can then use the command \\[next-error] to find the next error message |
178 | and move to the source code that caused it. | |
179 | ||
180 | To run more than one compilation at once, start one and rename the | |
d3cb357b RM |
181 | \`*compilation*' buffer to some other name with \\[rename-buffer]. |
182 | Then start the next one. | |
183 | ||
184 | The name used for the buffer is actually whatever is returned by | |
185 | the function in `compilation-buffer-name-function', so you can set that | |
186 | to a function that generates a unique name." | |
770970cb RS |
187 | (interactive (list (read-from-minibuffer "Compile command: " |
188 | compile-command nil | |
189 | '(compile-history . 1)))) | |
55dfd2c4 RS |
190 | (setq compile-command command) |
191 | (save-some-buffers nil nil) | |
d3cb357b | 192 | (compile-internal compile-command "No more errors")) |
55dfd2c4 | 193 | |
d3cb357b | 194 | ;;;###autoload |
55dfd2c4 RS |
195 | (defun grep (command-args) |
196 | "Run grep, with user-specified args, and collect output in a buffer. | |
197 | While grep runs asynchronously, you can use the \\[next-error] command | |
d3cb357b RM |
198 | to find the text that grep hits refer to. |
199 | ||
770970cb RS |
200 | This command uses a special history list for its arguments, so you can |
201 | easily repeat a grep command." | |
55dfd2c4 | 202 | (interactive |
770970cb RS |
203 | (list (read-from-minibuffer "Run grep (like this): " |
204 | "grep -n " nil nil 'grep-history))) | |
205 | (compile-internal (concat command-args " /dev/null") | |
55dfd2c4 RS |
206 | "No more grep hits" "grep")) |
207 | ||
208 | (defun compile-internal (command error-message | |
d3cb357b RM |
209 | &optional name-of-mode parser regexp-alist |
210 | name-function) | |
55dfd2c4 RS |
211 | "Run compilation command COMMAND (low level interface). |
212 | ERROR-MESSAGE is a string to print if the user asks to see another error | |
213 | and there are no more errors. Third argument NAME-OF-MODE is the name | |
d3cb357b RM |
214 | to display as the major mode in the compilation buffer. |
215 | ||
216 | Fourth arg PARSER is the error parser function (nil means the default). Fifth | |
217 | arg REGEXP-ALIST is the error message regexp alist to use (nil means the | |
218 | default). Sixth arg NAME-FUNCTION is a function called to name the buffer (nil | |
219 | means the default). The defaults for these variables are the global values of | |
220 | \`compilation-parse-errors-function', `compilation-error-regexp-alist', and | |
221 | \`compilation-buffer-name-function', respectively." | |
222 | (let (outbuf) | |
55dfd2c4 | 223 | (save-excursion |
d3cb357b RM |
224 | (or name-of-mode |
225 | (setq name-of-mode "Compilation")) | |
226 | (setq outbuf | |
227 | (get-buffer-create | |
228 | (funcall (or name-function compilation-buffer-name-function | |
229 | (function (lambda (mode) | |
230 | (concat "*" (downcase mode) "*")))) | |
231 | name-of-mode))) | |
232 | (set-buffer outbuf) | |
233 | (let ((comp-proc (get-buffer-process (current-buffer)))) | |
234 | (if comp-proc | |
235 | (if (or (not (eq (process-status comp-proc) 'run)) | |
236 | (yes-or-no-p | |
237 | "A compilation process is running; kill it? ")) | |
238 | (condition-case () | |
239 | (progn | |
240 | (interrupt-process comp-proc) | |
241 | (sit-for 1) | |
242 | (delete-process comp-proc)) | |
243 | (error nil)) | |
244 | (error "Cannot have two processes in `%s' at once" | |
245 | (buffer-name)) | |
246 | ))) | |
247 | ;; In case the compilation buffer is current, make sure we get the global | |
248 | ;; values of compilation-error-regexp-alist, etc. | |
249 | (kill-all-local-variables)) | |
250 | (let ((regexp-alist (or regexp-alist compilation-error-regexp-alist)) | |
251 | (parser (or parser compilation-parse-errors-function)) | |
252 | (thisdir default-directory) | |
253 | outwin) | |
254 | (save-excursion | |
255 | ;; Clear out the compilation buffer and make it writable. | |
256 | ;; Change its default-directory to the directory where the compilation | |
257 | ;; will happen, and insert a `cd' command to indicate this. | |
258 | (set-buffer outbuf) | |
259 | (setq buffer-read-only nil) | |
260 | (erase-buffer) | |
261 | (setq default-directory thisdir) | |
262 | (insert "cd " thisdir "\n" command "\n") | |
263 | (set-buffer-modified-p nil)) | |
264 | ;; If we're already in the compilation buffer, go to the end | |
265 | ;; of the buffer, so point will track the compilation output. | |
266 | (if (eq outbuf (current-buffer)) | |
267 | (goto-char (point-max))) | |
268 | ;; Pop up the compilation buffer. | |
269 | (setq outwin (display-buffer outbuf)) | |
55dfd2c4 | 270 | (set-buffer outbuf) |
55dfd2c4 | 271 | (compilation-mode) |
fad160d5 | 272 | (buffer-disable-undo (current-buffer)) |
e5d77022 | 273 | (setq buffer-read-only t) |
d3cb357b RM |
274 | (set (make-local-variable 'compilation-parse-errors-function) parser) |
275 | (set (make-local-variable 'compilation-error-message) error-message) | |
276 | (set (make-local-variable 'compilation-error-regexp-alist) regexp-alist) | |
277 | (setq default-directory thisdir | |
278 | compilation-directory-stack (list default-directory)) | |
55dfd2c4 | 279 | (set-window-start outwin (point-min)) |
d3cb357b | 280 | (setq mode-name name-of-mode) |
55dfd2c4 | 281 | (or (eq outwin (selected-window)) |
d3cb357b RM |
282 | (set-window-point outwin (point-min))) |
283 | (and compilation-window-height | |
f98955ea | 284 | (= (window-width outwin) (frame-width)) |
d3cb357b RM |
285 | (let ((w (selected-window))) |
286 | (unwind-protect | |
287 | (progn | |
288 | (select-window outwin) | |
289 | (enlarge-window (- compilation-window-height | |
290 | (window-height)))) | |
291 | (select-window w)))) | |
292 | ;; Start the compilation. | |
ebff767c RM |
293 | (let ((proc (start-process-shell-command (downcase mode-name) |
294 | outbuf | |
295 | command))) | |
296 | (set-process-sentinel proc 'compilation-sentinel) | |
297 | (setq compilation-in-progress (cons proc compilation-in-progress)))) | |
d3cb357b RM |
298 | ;; Make it so the next C-x ` will use this buffer. |
299 | (setq compilation-last-buffer outbuf))) | |
55dfd2c4 RS |
300 | |
301 | (defvar compilation-mode-map | |
302 | (let ((map (make-sparse-keymap))) | |
303 | (define-key map "\C-c\C-c" 'compile-goto-error) | |
d3cb357b | 304 | (define-key map "\C-c\C-k" 'kill-compilation) |
55dfd2c4 RS |
305 | map) |
306 | "Keymap for compilation log buffers.") | |
307 | ||
308 | (defun compilation-mode () | |
309 | "Major mode for compilation log buffers. | |
310 | \\<compilation-mode-map>To visit the source for a line-numbered error, | |
d3cb357b | 311 | move point to the error message line and type \\[compile-goto-error]. |
7c163413 RM |
312 | To kill the compilation, type \\[kill-compilation]. |
313 | ||
314 | Runs `compilation-mode-hook' with `run-hooks' (which see)." | |
55dfd2c4 RS |
315 | (interactive) |
316 | (fundamental-mode) | |
317 | (use-local-map compilation-mode-map) | |
55dfd2c4 RS |
318 | (setq major-mode 'compilation-mode) |
319 | (setq mode-name "Compilation") | |
d3cb357b RM |
320 | ;; Make buffer's mode line show process state |
321 | (setq mode-line-process '(": %s")) | |
322 | (set (make-local-variable 'compilation-error-list) nil) | |
323 | (set (make-local-variable 'compilation-old-error-list) nil) | |
324 | (set (make-local-variable 'compilation-parsing-end) 1) | |
325 | (set (make-local-variable 'compilation-directory-stack) nil) | |
7c163413 RM |
326 | (setq compilation-last-buffer (current-buffer)) |
327 | (run-hooks 'compilation-mode-hook)) | |
55dfd2c4 RS |
328 | |
329 | ;; Called when compilation process changes state. | |
55dfd2c4 | 330 | (defun compilation-sentinel (proc msg) |
d3cb357b RM |
331 | "Sentinel for compilation buffers." |
332 | (let ((buffer (process-buffer proc))) | |
ebff767c RM |
333 | (if (memq (process-status proc) '(signal exit)) |
334 | (progn | |
335 | (if (null (buffer-name buffer)) | |
336 | ;; buffer killed | |
337 | (set-process-buffer proc nil) | |
338 | (let ((obuf (current-buffer)) | |
339 | omax opoint) | |
340 | ;; save-excursion isn't the right thing if | |
341 | ;; process-buffer is current-buffer | |
342 | (unwind-protect | |
343 | (progn | |
344 | ;; Write something in the compilation buffer | |
345 | ;; and hack its mode line. | |
346 | (set-buffer buffer) | |
347 | (setq buffer-read-only nil) | |
348 | (setq omax (point-max) | |
349 | opoint (point)) | |
350 | (goto-char omax) | |
351 | ;; Record where we put the message, so we can ignore it | |
352 | ;; later on. | |
353 | (insert ?\n mode-name " " msg) | |
354 | (forward-char -1) | |
355 | (insert " at " (substring (current-time-string) 0 19)) | |
356 | (forward-char 1) | |
357 | (setq mode-line-process | |
358 | (concat ": " | |
359 | (symbol-name (process-status proc)))) | |
360 | ;; Since the buffer and mode line will show that the | |
361 | ;; process is dead, we can delete it now. Otherwise it | |
362 | ;; will stay around until M-x list-processes. | |
363 | (delete-process proc) | |
364 | ;; Force mode line redisplay soon. | |
365 | (set-buffer-modified-p (buffer-modified-p)) | |
366 | (setq buffer-read-only t) ;I think is this wrong --roland | |
367 | (if (and opoint (< opoint omax)) | |
368 | (goto-char opoint))) | |
369 | (set-buffer obuf)) | |
370 | (if compilation-finish-function | |
371 | (funcall compilation-finish-function buffer msg)) | |
372 | )) | |
373 | (setq compilation-in-progress (delq proc compilation-in-progress)) | |
374 | )))) | |
55dfd2c4 RS |
375 | |
376 | (defun kill-compilation () | |
377 | "Kill the process made by the \\[compile] command." | |
378 | (interactive) | |
d3cb357b | 379 | (let ((buffer (compilation-find-buffer))) |
55dfd2c4 | 380 | (if (get-buffer-process buffer) |
d3cb357b RM |
381 | (interrupt-process (get-buffer-process buffer)) |
382 | (error "The compilation process is not running.")))) | |
383 | ||
55dfd2c4 | 384 | |
d3cb357b RM |
385 | ;; Parse any new errors in the compilation buffer, |
386 | ;; or reparse from the beginning if the user has asked for that. | |
55dfd2c4 | 387 | (defun compile-reinitialize-errors (argp) |
d3cb357b RM |
388 | (save-excursion |
389 | (set-buffer compilation-last-buffer) | |
390 | ;; If we are out of errors, or if user says "reparse", | |
391 | ;; discard the info we have, to force reparsing. | |
392 | (if (or (eq compilation-error-list t) | |
393 | (consp argp)) | |
394 | (progn (compilation-forget-errors) | |
395 | (setq compilation-parsing-end 1))) | |
396 | (if compilation-error-list | |
397 | ;; Since compilation-error-list is non-nil, it points to a specific | |
398 | ;; error the user wanted. So don't move it around. | |
399 | nil | |
400 | (switch-to-buffer compilation-last-buffer) | |
55dfd2c4 RS |
401 | (set-buffer-modified-p nil) |
402 | (let ((at-start (= compilation-parsing-end 1))) | |
d3cb357b | 403 | (funcall compilation-parse-errors-function) |
55dfd2c4 RS |
404 | ;; Remember the entire list for compilation-forget-errors. |
405 | ;; If this is an incremental parse, append to previous list. | |
406 | (if at-start | |
407 | (setq compilation-old-error-list compilation-error-list) | |
408 | (setq compilation-old-error-list | |
409 | (nconc compilation-old-error-list compilation-error-list))))))) | |
410 | ||
411 | (defun compile-goto-error (&optional argp) | |
412 | "Visit the source for the error message point is on. | |
413 | Use this command in a compilation log buffer. | |
414 | C-u as a prefix arg means to reparse the buffer's error messages first; | |
415 | other kinds of prefix arguments are ignored." | |
416 | (interactive "P") | |
d3cb357b RM |
417 | (or (compilation-buffer-p (current-buffer)) |
418 | (error "Not in a compilation buffer.")) | |
419 | (setq compilation-last-buffer (current-buffer)) | |
55dfd2c4 RS |
420 | (compile-reinitialize-errors argp) |
421 | (save-excursion | |
422 | (beginning-of-line) | |
d3cb357b RM |
423 | ;; Move compilation-error-list to the elt of |
424 | ;; compilation-old-error-list whose car is the error we want. | |
55dfd2c4 | 425 | (setq compilation-error-list |
d3cb357b RM |
426 | (memq (let (elt) |
427 | (while (not (or (setq elt (assoc (point-marker) | |
428 | compilation-old-error-list)) | |
429 | (eobp))) | |
430 | ;; This line doesn't contain an error. | |
431 | ;; Move forward a line and look again. | |
432 | (forward-line 1)) | |
433 | elt) | |
55dfd2c4 RS |
434 | compilation-old-error-list))) |
435 | ;; Move to another window, so that next-error's window changes | |
436 | ;; result in the desired setup. | |
437 | (or (one-window-p) | |
438 | (other-window -1)) | |
439 | (next-error 1)) | |
440 | ||
d3cb357b RM |
441 | (defun compilation-buffer-p (buffer) |
442 | (assq 'compilation-error-list (buffer-local-variables buffer))) | |
443 | ||
444 | ;; Return a compilation buffer. | |
445 | ;; If the current buffer is a compilation buffer, return it. | |
446 | ;; If compilation-last-buffer is set to a live buffer, use that. | |
447 | ;; Otherwise, look for a compilation buffer and signal an error | |
448 | ;; if there are none. | |
4746118a JB |
449 | (defun compilation-find-buffer (&optional other-buffer) |
450 | (if (and (not other-buffer) | |
451 | (compilation-buffer-p (current-buffer))) | |
d3cb357b RM |
452 | ;; The current buffer is a compilation buffer. |
453 | (current-buffer) | |
4746118a JB |
454 | (if (and compilation-last-buffer (buffer-name compilation-last-buffer) |
455 | (or (not other-buffer) (not (eq compilation-last-buffer | |
456 | (current-buffer))))) | |
d3cb357b RM |
457 | compilation-last-buffer |
458 | (let ((buffers (buffer-list))) | |
4746118a JB |
459 | (while (and buffers (or (not (compilation-buffer-p (car buffers))) |
460 | (and other-buffer | |
461 | (eq (car buffers) (current-buffer))))) | |
d3cb357b RM |
462 | (setq buffers (cdr buffers))) |
463 | (if buffers | |
464 | (car buffers) | |
4746118a JB |
465 | (or (and other-buffer |
466 | (compilation-buffer-p (current-buffer)) | |
467 | ;; The current buffer is a compilation buffer. | |
468 | (progn | |
469 | (if other-buffer | |
470 | (message "This is the only compilation buffer.")) | |
471 | (current-buffer))) | |
472 | (error "No compilation started!"))))))) | |
d3cb357b RM |
473 | |
474 | ;;;###autoload | |
55dfd2c4 RS |
475 | (defun next-error (&optional argp) |
476 | "Visit next compilation error message and corresponding source code. | |
477 | This operates on the output from the \\[compile] command. | |
478 | If all preparsed error messages have been processed, | |
479 | the error message buffer is checked for new ones. | |
480 | ||
481 | A prefix arg specifies how many error messages to move; | |
482 | negative means move back to previous error messages. | |
483 | Just C-u as a prefix means reparse the error message buffer | |
484 | and start at the first error. | |
485 | ||
486 | \\[next-error] normally applies to the most recent compilation started, | |
487 | but as long as you are in the middle of parsing errors from one compilation | |
488 | output buffer, you stay with that compilation output buffer. | |
489 | ||
490 | Use \\[next-error] in a compilation output buffer to switch to | |
491 | processing errors from that compilation. | |
492 | ||
d3cb357b RM |
493 | See variables `compilation-parse-errors-function' and |
494 | \`compilation-error-regexp-alist' for customization ideas." | |
55dfd2c4 | 495 | (interactive "P") |
d3cb357b | 496 | (setq compilation-last-buffer (compilation-find-buffer)) |
55dfd2c4 | 497 | (compile-reinitialize-errors argp) |
d3cb357b RM |
498 | ;; Make ARGP nil if the prefix arg was just C-u, |
499 | ;; since that means to reparse the errors, which the | |
500 | ;; compile-reinitialize-errors call just did. | |
501 | ;; Now we are only interested in a numeric prefix arg. | |
55dfd2c4 RS |
502 | (if (consp argp) |
503 | (setq argp nil)) | |
d3cb357b RM |
504 | (let (next-errors next-error) |
505 | (save-excursion | |
506 | (set-buffer compilation-last-buffer) | |
507 | (setq next-errors (nthcdr (+ (- (length compilation-old-error-list) | |
508 | (length compilation-error-list) | |
509 | 1) | |
510 | (prefix-numeric-value argp)) | |
511 | compilation-old-error-list) | |
512 | next-error (car next-errors)) | |
513 | (while | |
55dfd2c4 | 514 | (progn |
d3cb357b RM |
515 | (if (null next-error) |
516 | (progn | |
517 | (if argp (if (> (prefix-numeric-value argp) 0) | |
518 | (error "Moved past last error") | |
519 | (error "Moved back past first error"))) | |
520 | (compilation-forget-errors) | |
521 | (error (concat compilation-error-message | |
522 | (and (get-buffer-process (current-buffer)) | |
523 | (eq (process-status | |
524 | (get-buffer-process | |
525 | (current-buffer))) | |
526 | 'run) | |
527 | " yet")))) | |
528 | (setq compilation-error-list (cdr next-errors)) | |
529 | (if (null (cdr next-error)) | |
530 | ;; This error is boring. Go to the next. | |
531 | t | |
532 | (or (markerp (cdr next-error)) | |
533 | ;; This error has a filename/lineno pair. | |
534 | ;; Find the file and turn it into a marker. | |
535 | (let* ((fileinfo (car (cdr next-error))) | |
536 | (buffer (compilation-find-file (cdr fileinfo) | |
537 | (car fileinfo) | |
538 | (car next-error)))) | |
539 | (if (null buffer) | |
540 | ;; We can't find this error's file. | |
541 | ;; Remove all errors in the same file. | |
542 | (progn | |
543 | (setq next-errors compilation-old-error-list) | |
544 | (while next-errors | |
545 | (and (consp (cdr (car next-errors))) | |
546 | (equal (car (cdr (car next-errors))) | |
547 | fileinfo) | |
548 | (progn | |
549 | (set-marker (car (car next-errors)) nil) | |
550 | (setcdr (car next-errors) nil))) | |
551 | (setq next-errors (cdr next-errors))) | |
552 | ;; Look for the next error. | |
553 | t) | |
554 | ;; We found the file. Get a marker for this error. | |
555 | (set-buffer buffer) | |
556 | (save-excursion | |
557 | (save-restriction | |
558 | (widen) | |
559 | (let ((errors compilation-old-error-list) | |
560 | (last-line (cdr (cdr next-error)))) | |
561 | (goto-line last-line) | |
562 | (beginning-of-line) | |
563 | (setcdr next-error (point-marker)) | |
564 | ;; Make all the other error messages referring | |
565 | ;; to the same file have markers into the buffer. | |
566 | (while errors | |
567 | (and (consp (cdr (car errors))) | |
568 | (equal (car (cdr (car errors))) fileinfo) | |
569 | (let ((this (cdr (cdr (car errors)))) | |
570 | (lines (- (cdr (cdr (car errors))) | |
571 | last-line))) | |
572 | (if (eq selective-display t) | |
573 | (if (< lines 0) | |
574 | (re-search-backward "[\n\C-m]" | |
575 | nil 'end | |
576 | (- lines)) | |
577 | (re-search-forward "[\n\C-m]" | |
578 | nil 'end | |
579 | lines)) | |
580 | (forward-line lines)) | |
581 | (setq last-line this) | |
582 | (setcdr (car errors) (point-marker)))) | |
583 | (setq errors (cdr errors))))))))) | |
584 | ;; If we didn't get a marker for this error, | |
585 | ;; go on to the next one. | |
586 | (not (markerp (cdr next-error)))))) | |
587 | (setq next-errors compilation-error-list | |
588 | next-error (car next-errors)))) | |
589 | ||
590 | ;; Skip over multiple error messages for the same source location, | |
591 | ;; so the next C-x ` won't go to an error in the same place. | |
592 | (while (and compilation-error-list | |
593 | (equal (cdr (car compilation-error-list)) (cdr next-error))) | |
594 | (setq compilation-error-list (cdr compilation-error-list))) | |
595 | ||
596 | ;; We now have a marker for the position of the error. | |
597 | (switch-to-buffer (marker-buffer (cdr next-error))) | |
598 | (goto-char (cdr next-error)) | |
599 | ;; If narrowing got in the way of | |
600 | ;; going to the right place, widen. | |
601 | (or (= (point) (marker-position (cdr next-error))) | |
602 | (progn | |
603 | (widen) | |
604 | (goto-char (cdr next-error)))) | |
605 | ||
55dfd2c4 RS |
606 | ;; Show compilation buffer in other window, scrolled to this error. |
607 | (let* ((pop-up-windows t) | |
608 | (w (display-buffer (marker-buffer (car next-error))))) | |
609 | (set-window-point w (car next-error)) | |
d3cb357b RM |
610 | (set-window-start w (car next-error))))) |
611 | ||
612 | ;;;###autoload | |
613 | (define-key ctl-x-map "`" 'next-error) | |
614 | ||
615 | ;; Find a buffer for file FILENAME. | |
616 | ;; Search the directories in compilation-search-path. | |
617 | ;; A nil in compilation-search-path means to try the | |
618 | ;; current directory, which is passed in DIR. | |
619 | ;; If FILENAME is not found at all, ask the user where to find it. | |
620 | ;; Pop up the buffer containing MARKER and scroll to MARKER if we ask the user. | |
621 | (defun compilation-find-file (filename dir marker) | |
622 | (let ((dirs compilation-search-path) | |
623 | result name) | |
624 | (while (and dirs (null result)) | |
625 | (setq name (expand-file-name filename (or (car dirs) dir)) | |
626 | result (and (file-exists-p name) | |
627 | (find-file-noselect name)) | |
628 | dirs (cdr dirs))) | |
629 | (or result | |
630 | ;; The file doesn't exist. | |
631 | ;; Ask the user where to find it. | |
632 | ;; If he hits C-g, then the next time he does | |
633 | ;; next-error, he'll skip past it. | |
634 | (progn | |
635 | (let* ((pop-up-windows t) | |
636 | (w (display-buffer (marker-buffer marker)))) | |
637 | (set-window-point w marker) | |
638 | (set-window-start w marker)) | |
639 | (setq name | |
640 | (expand-file-name | |
641 | (read-file-name | |
642 | (format "Find this error in: (default %s) " | |
643 | filename) dir filename t))) | |
644 | (if (file-directory-p name) | |
645 | (setq name (concat (file-name-as-directory name) filename))) | |
646 | (if (file-exists-p name) | |
647 | (find-file-noselect name)))))) | |
648 | ||
649 | ;; Set compilation-error-list to nil, and unchain the markers that point to the | |
650 | ;; error messages and their text, so that they no longer slow down gap motion. | |
651 | ;; This would happen anyway at the next garbage collection, but it is better to | |
652 | ;; do it the right away. | |
55dfd2c4 RS |
653 | (defun compilation-forget-errors () |
654 | (while compilation-old-error-list | |
655 | (let ((next-error (car compilation-old-error-list))) | |
656 | (set-marker (car next-error) nil) | |
d3cb357b RM |
657 | (if (markerp (cdr next-error)) |
658 | (set-marker (cdr next-error) nil))) | |
55dfd2c4 | 659 | (setq compilation-old-error-list (cdr compilation-old-error-list))) |
d3cb357b RM |
660 | (setq compilation-error-list nil) |
661 | (while (cdr compilation-directory-stack) | |
662 | (setq compilation-directory-stack (cdr compilation-directory-stack)))) | |
663 | ||
664 | ||
665 | (defun count-regexp-groupings (regexp) | |
666 | "Return the number of \\( ... \\) groupings in REGEXP (a string)." | |
667 | (let ((groupings 0) | |
668 | (len (length regexp)) | |
669 | (i 0) | |
670 | c) | |
671 | (while (< i len) | |
672 | (setq c (aref regexp i) | |
673 | i (1+ i)) | |
674 | (cond ((= c ?\[) | |
675 | ;; Find the end of this [...]. | |
676 | (while (and (< i len) | |
677 | (not (= (aref regexp i) ?\]))) | |
678 | (setq i (1+ i)))) | |
679 | ((= c ?\\) | |
680 | (if (< i len) | |
681 | (progn | |
682 | (setq c (aref regexp i) | |
683 | i (1+ i)) | |
684 | (if (= c ?\)) | |
685 | ;; We found the end of a grouping, | |
686 | ;; so bump our counter. | |
687 | (setq groupings (1+ groupings)))))))) | |
688 | groupings)) | |
55dfd2c4 RS |
689 | |
690 | (defun compilation-parse-errors () | |
691 | "Parse the current buffer as grep, cc or lint error messages. | |
d3cb357b | 692 | See variable `compilation-parse-errors-function' for the interface it uses." |
55dfd2c4 RS |
693 | (setq compilation-error-list nil) |
694 | (message "Parsing error messages...") | |
695 | (let (text-buffer | |
d3cb357b RM |
696 | regexp enter-group leave-group error-group |
697 | alist subexpr error-regexp-groups) | |
698 | ||
55dfd2c4 RS |
699 | ;; Don't reparse messages already seen at last parse. |
700 | (goto-char compilation-parsing-end) | |
701 | ;; Don't parse the first two lines as error messages. | |
702 | ;; This matters for grep. | |
703 | (if (bobp) | |
704 | (forward-line 2)) | |
d3cb357b RM |
705 | |
706 | ;; Compile all the regexps we want to search for into one. | |
707 | (setq regexp (concat "\\(" compilation-enter-directory-regexp "\\)\\|" | |
708 | "\\(" compilation-leave-directory-regexp "\\)\\|" | |
709 | "\\(" (mapconcat (function | |
710 | (lambda (elt) | |
711 | (concat "\\(" (car elt) "\\)"))) | |
712 | compilation-error-regexp-alist | |
713 | "\\|") "\\)")) | |
714 | ||
715 | ;; Find out how many \(...\) groupings are in each of the regexps, and set | |
716 | ;; *-GROUP to the grouping containing each constituent regexp (whose | |
717 | ;; subgroups will come immediately thereafter) of the big regexp we have | |
718 | ;; just constructed. | |
719 | (setq enter-group 1 | |
720 | leave-group (+ enter-group | |
721 | (count-regexp-groupings | |
722 | compilation-enter-directory-regexp) | |
723 | 1) | |
724 | error-group (+ leave-group | |
725 | (count-regexp-groupings | |
726 | compilation-leave-directory-regexp) | |
727 | 1)) | |
728 | ||
729 | ;; Compile an alist (IDX FILE LINE), where IDX is the number of the | |
730 | ;; subexpression for an entire error-regexp, and FILE and LINE are the | |
731 | ;; numbers for the subexpressions giving the file name and line number. | |
732 | (setq alist compilation-error-regexp-alist | |
733 | subexpr (1+ error-group)) | |
734 | (while alist | |
735 | (setq error-regexp-groups (cons (list subexpr | |
736 | (+ subexpr (nth 1 (car alist))) | |
737 | (+ subexpr (nth 2 (car alist)))) | |
738 | error-regexp-groups)) | |
739 | (setq subexpr (+ subexpr 1 (count-regexp-groupings (car (car alist))))) | |
740 | (setq alist (cdr alist))) | |
741 | ||
742 | (while (re-search-forward regexp nil t) | |
743 | ;; Figure out which constituent regexp matched. | |
744 | (cond ((match-beginning enter-group) | |
745 | ;; The match was the enter-directory regexp. | |
746 | (let ((dir | |
747 | (file-name-as-directory | |
748 | (expand-file-name | |
749 | (buffer-substring (match-beginning (+ enter-group 1)) | |
750 | (match-end (+ enter-group 1))))))) | |
751 | (setq compilation-directory-stack | |
752 | (cons dir compilation-directory-stack)) | |
753 | (and (file-directory-p dir) | |
754 | (setq default-directory dir)))) | |
755 | ||
756 | ((match-beginning leave-group) | |
757 | ;; The match was the leave-directory regexp. | |
758 | (let ((beg (match-beginning (+ leave-group 1))) | |
759 | (stack compilation-directory-stack)) | |
760 | (if beg | |
761 | (let ((dir | |
762 | (file-name-as-directory | |
763 | (expand-file-name | |
764 | (buffer-substring beg | |
765 | (match-end (+ leave-group | |
766 | 1))))))) | |
767 | (while (and stack | |
768 | (not (string-equal (car stack) dir))) | |
769 | (setq stack (cdr stack))))) | |
770 | (setq compilation-directory-stack (cdr stack)) | |
771 | (setq stack (car compilation-directory-stack)) | |
772 | (if stack | |
773 | (setq default-directory stack)) | |
774 | )) | |
775 | ||
776 | ((match-beginning error-group) | |
777 | ;; The match was the composite error regexp. | |
778 | ;; Find out which individual regexp matched. | |
779 | (setq alist error-regexp-groups) | |
780 | (while (and alist | |
781 | (null (match-beginning (car (car alist))))) | |
782 | (setq alist (cdr alist))) | |
783 | (if alist | |
784 | (setq alist (car alist)) | |
785 | (error "Impossible regexp match!")) | |
786 | ||
787 | ;; Extract the file name and line number from the error message. | |
788 | (let ((filename | |
789 | (cons default-directory | |
790 | (buffer-substring (match-beginning (nth 1 alist)) | |
791 | (match-end (nth 1 alist))))) | |
792 | (linenum (save-restriction | |
793 | (narrow-to-region | |
794 | (match-beginning (nth 2 alist)) | |
795 | (match-end (nth 2 alist))) | |
796 | (goto-char (point-min)) | |
797 | (if (looking-at "[0-9]") | |
798 | (read (current-buffer)))))) | |
799 | ;; Locate the erring file and line. | |
800 | ;; Cons a new elt onto compilation-error-list, | |
801 | ;; giving a marker for the current compilation buffer | |
802 | ;; location, and the file and line number of the error. | |
803 | (save-excursion | |
804 | (beginning-of-line 1) | |
805 | (setq compilation-error-list | |
806 | (cons (cons (point-marker) | |
807 | (cons filename linenum)) | |
808 | compilation-error-list))))) | |
809 | (t | |
810 | (error "Impossible regexp match!")))) | |
55dfd2c4 RS |
811 | (setq compilation-parsing-end (point-max))) |
812 | (message "Parsing error messages...done") | |
813 | (setq compilation-error-list (nreverse compilation-error-list))) | |
814 | ||
55dfd2c4 | 815 | (define-key ctl-x-map "`" 'next-error) |
4746118a JB |
816 | |
817 | (provide 'compile) | |
fad160d5 ER |
818 | |
819 | ;;; compile.el ends here |