compile.el 39.8 KB
Newer Older
Jim Blandy's avatar
Jim Blandy committed
1
;;; compile.el --- run compiler as inferior of Emacs, parse error messages.
Eric S. Raymond's avatar
Eric S. Raymond committed
2

3
;; Copyright (C) 1985, 86, 87, 93 Free Software Foundation, Inc.
Eric S. Raymond's avatar
Eric S. Raymond committed
4

Roland McGrath's avatar
Roland McGrath committed
5
;; Author: Roland McGrath <roland@prep.ai.mit.edu>
Eric S. Raymond's avatar
Eric S. Raymond committed
6
;; Maintainer: FSF
Eric S. Raymond's avatar
Eric S. Raymond committed
7
;; Keywords: tools, processes
Eric S. Raymond's avatar
Eric S. Raymond committed
8

Richard M. Stallman's avatar
Richard M. Stallman committed
9 10
;; This file is part of GNU Emacs.

Roland McGrath's avatar
Roland McGrath committed
11 12 13 14 15
;; GNU Emacs is free software; you can redistribute it and/or modify
;; it under the terms of the GNU General Public License as published by
;; the Free Software Foundation; either version 2, or (at your option)
;; any later version.

Richard M. Stallman's avatar
Richard M. Stallman committed
16
;; GNU Emacs is distributed in the hope that it will be useful,
Roland McGrath's avatar
Roland McGrath committed
17 18 19 20 21 22 23
;; but WITHOUT ANY WARRANTY; without even the implied warranty of
;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
;; GNU General Public License for more details.

;; You should have received a copy of the GNU General Public License
;; along with GNU Emacs; see the file COPYING.  If not, write to
;; the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
Richard M. Stallman's avatar
Richard M. Stallman committed
24

Eric S. Raymond's avatar
Eric S. Raymond committed
25 26 27 28 29
;;; Commentary:

;; This package provides the compile and grep facilities documented in
;; the Emacs user's manual.

Eric S. Raymond's avatar
Eric S. Raymond committed
30 31
;;; Code:

Roland McGrath's avatar
Roland McGrath committed
32 33
;;;###autoload
(defvar compilation-mode-hook nil
34
  "*List of hook functions run by `compilation-mode' (see `run-hooks').")
Roland McGrath's avatar
Roland McGrath committed
35 36

;;;###autoload
Roland McGrath's avatar
Roland McGrath committed
37 38 39
(defconst compilation-window-height nil
  "*Number of lines in a compilation window.  If nil, use Emacs default.")

Richard M. Stallman's avatar
Richard M. Stallman committed
40 41
(defvar compilation-error-list nil
  "List of error message descriptors for visiting erring functions.
42 43 44 45 46 47
Each error descriptor is a cons (or nil).  Its car is a marker
pointing to an error message.  If its cdr is a marker, it points to
the text of the line the message is about.  If its cdr is a cons, that
cons's car is the name of the file the message is about, and its cdr
is the number of the line the message is about.  Or its cdr may be nil
if that error is not interesting.
Roland McGrath's avatar
Roland McGrath committed
48 49

The value may be t instead of a list; this means that the buffer of
Jim Blandy's avatar
Jim Blandy committed
50 51 52 53 54 55
error messages should be reparsed the next time the list of errors is wanted.

Some other commands (like `diff') use this list to control the error
message tracking facilites; if you change its structure, you should make
sure you also change those packages.  Perhaps it is better not to change
it at all.")
Richard M. Stallman's avatar
Richard M. Stallman committed
56 57 58 59

(defvar compilation-old-error-list nil
  "Value of `compilation-error-list' after errors were parsed.")

Roland McGrath's avatar
Roland McGrath committed
60
(defvar compilation-parse-errors-function 'compilation-parse-errors 
Roland McGrath's avatar
Roland McGrath committed
61
  "Function to call to parse error messages from a compilation.
Roland McGrath's avatar
Roland McGrath committed
62 63 64 65
It takes args LIMIT-SEARCH and FIND-AT-LEAST.
If LIMIT-SEARCH is non-nil, don't bother parsing past that location.
If FIND-AT-LEAST is non-nil, don't bother parsing after finding that 
 many new erros.
Roland McGrath's avatar
Roland McGrath committed
66 67 68
It should read in the source files which have errors and set
`compilation-error-list' to a list with an element for each error message
found.  See that variable for more info.")
Richard M. Stallman's avatar
Richard M. Stallman committed
69

Jim Blandy's avatar
Jim Blandy committed
70
;;;###autoload
Roland McGrath's avatar
Roland McGrath committed
71
(defvar compilation-buffer-name-function nil
Richard M. Stallman's avatar
Richard M. Stallman committed
72 73 74 75
  "Function to compute the name of a compilation buffer.
The function receives one argument, the name of the major mode of the
compilation buffer.  It should return a string.
nil means compute the name with `(concat \"*\" (downcase major-mode) \"*\")'.")
Richard M. Stallman's avatar
Richard M. Stallman committed
76

Jim Blandy's avatar
Jim Blandy committed
77
;;;###autoload
Roland McGrath's avatar
Roland McGrath committed
78
(defvar compilation-finish-function nil
Jim Blandy's avatar
Jim Blandy committed
79
  "*Function to call when a compilation process finishes.
Roland McGrath's avatar
Roland McGrath committed
80 81
It is called with two arguments: the compilation buffer, and a string
describing how the process finished.")
Richard M. Stallman's avatar
Richard M. Stallman committed
82

Roland McGrath's avatar
Roland McGrath committed
83
(defvar compilation-last-buffer nil
Richard M. Stallman's avatar
Richard M. Stallman committed
84 85 86
  "The most recent compilation buffer.
A buffer becomes most recent when its compilation is started
or when it is used with \\[next-error] or \\[compile-goto-error].")
Richard M. Stallman's avatar
Richard M. Stallman committed
87

Roland McGrath's avatar
Roland McGrath committed
88 89 90 91 92 93
(defvar compilation-in-progress nil
  "List of compilation processes now running.")
(or (assq 'compilation-in-progress minor-mode-alist)
    (setq minor-mode-alist (cons '(compilation-in-progress " Compiling")
				 minor-mode-alist)))

Roland McGrath's avatar
Roland McGrath committed
94 95 96 97
(defvar compilation-parsing-end nil
  "Position of end of buffer when last error messages were parsed.")

(defvar compilation-error-message "No more errors"
Richard M. Stallman's avatar
Richard M. Stallman committed
98 99 100
  "Message to print when no more matches are found.")

(defvar compilation-num-errors-found)
Roland McGrath's avatar
Roland McGrath committed
101 102 103

(defvar compilation-error-regexp-alist
  '(
Roland McGrath's avatar
Roland McGrath committed
104
    ;; NOTE!  This first one is repeated in grep-regexp-alist, below.
105

Roland McGrath's avatar
Roland McGrath committed
106
    ;; 4.3BSD grep, cc, lint pass 1:
107 108 109 110 111
    ;; 	/usr/src/foo/foo.c(8): warning: w may be used before set
    ;; or GNU utilities:
    ;; 	foo.c:8: error message
    ;; or HP-UX 7.0 fc:
    ;; 	foo.f          :16    some horrible error message
112 113 114 115
    ;;
    ;; We'll insist that the number be followed by a colon or closing
    ;; paren, because otherwise this matches just about anything
    ;; containing a number with spaces around it.
116
    ("\n\\([^:( \t\n]+\\)[:(][ \t]*\\([0-9]+\\)[:) \t]" 1 2)
117

Roland McGrath's avatar
Roland McGrath committed
118
    ;; 4.3BSD lint pass 2
119
    ;; 	strcmp: variable # of args. llib-lc(359)  ::  /usr/src/foo/foo.c(8)
120
    ("[ \t:]\\([^:( \t\n]+\\)[:(](+[ \t]*\\([0-9]+\\))[:) \t]*$" 1 2)
121

Roland McGrath's avatar
Roland McGrath committed
122
    ;; 4.3BSD lint pass 3
123
    ;; 	bloofle defined( /users/wolfgang/foo.c(4) ), but never used
Jim Blandy's avatar
Jim Blandy committed
124 125 126
    ;; This used to be
    ;; ("[ \t(]+\\([^:( \t\n]+\\)[:( \t]+\\([0-9]+\\)[:) \t]+" 1 2)
    ;; which is regexp Impressionism - it matches almost anything!
127
    ("([ \t]*\\([^:( \t\n]+\\)[:(][ \t]*\\([0-9]+\\))" 1 2)
128

Roland McGrath's avatar
Roland McGrath committed
129
    ;; Line 45 of "foo.c": bloofel undefined (who does this?)
130
    ("\n[Ll]ine[ \t]+\\([0-9]+\\)[ \t]+of[ \t]+\"\\([^\"\n]+\\)\":" 2 1)
131 132 133

    ;; Apollo cc, 4.3BSD fc:
    ;;	"foo.f", line 3: Error: syntax error near end of statement
134 135 136
    ("\"\\([^,\" \n\t]+\\)\", line \\([0-9]+\\):" 1 2)

    ;; MIPS RISC CC - the one distributed with Ultrix:
137
    ;;	ccom: Error: foo.c, line 2: syntax error
138
    ("rror: \\([^,\" \n\t]+\\), line \\([0-9]+\\):" 1 2)
139 140 141

    ;; IBM AIX PS/2 C version 1.1:
    ;;	****** Error number 140 in line 8 of file errors.c ******
Jim Blandy's avatar
Jim Blandy committed
142
    ("in line \\([0-9]+\\) of file \\([^ \n]+[^. \n]\\)\\.? " 2 1)
Roland McGrath's avatar
Roland McGrath committed
143 144
    ;; IBM AIX lint is too painful to do right this way.  File name
    ;; prefixes entire sections rather than being on each line.
145

Roland McGrath's avatar
Roland McGrath committed
146
    )
Richard M. Stallman's avatar
Richard M. Stallman committed
147 148 149
  "Alist that specifies how to match errors in compiler output.
Each element has the form (REGEXP FILE-IDX LINE-IDX).
If REGEXP matches, the FILE-IDX'th subexpression gives the file
Roland McGrath's avatar
Roland McGrath committed
150
name, and the LINE-IDX'th subexpression gives the line number.")
Richard M. Stallman's avatar
Richard M. Stallman committed
151

Roland McGrath's avatar
Roland McGrath committed
152 153 154 155
(defvar grep-regexp-alist
  '(("^\\([^:( \t\n]+\\)[:( \t]+\\([0-9]+\\)[:) \t]" 1 2))
  "Regexp used to match grep hits.  See `compilation-error-regexp-alist'.")

Roland McGrath's avatar
Roland McGrath committed
156
;;;###autoload
Roland McGrath's avatar
Roland McGrath committed
157
(defvar compilation-search-path '(nil)
Roland McGrath's avatar
Roland McGrath committed
158
  "*List of directories to search for source files named in error messages.
Roland McGrath's avatar
Roland McGrath committed
159 160
Elements should be directory names, not file names of directories.
nil as an element means to try the default directory.")
Richard M. Stallman's avatar
Richard M. Stallman committed
161 162 163 164 165 166 167 168 169 170 171 172 173 174

(defvar compile-command "make -k "
  "Last shell command used to do a compilation; default for next compilation.

Sometimes it is useful for files to supply local values for this variable.
You might also use mode hooks to specify it in certain modes, like this:

    (setq c-mode-hook
      '(lambda () (or (file-exists-p \"makefile\") (file-exists-p \"Makefile\")
		      (progn (make-local-variable 'compile-command)
			     (setq compile-command
				    (concat \"make -k \"
					    buffer-file-name))))))")

Roland McGrath's avatar
Roland McGrath committed
175
(defconst compilation-enter-directory-regexp
Jim Blandy's avatar
Jim Blandy committed
176
  ": Entering directory `\\(.*\\)'$"
Richard M. Stallman's avatar
Richard M. Stallman committed
177 178
  "Regular expression matching lines that indicate a new current directory.
This must contain one \\(, \\) pair around the directory name.
Roland McGrath's avatar
Roland McGrath committed
179 180 181 182

The default value matches lines printed by the `-w' option of GNU Make.")

(defconst compilation-leave-directory-regexp
Jim Blandy's avatar
Jim Blandy committed
183
  ": Leaving directory `\\(.*\\)'$"
Richard M. Stallman's avatar
Richard M. Stallman committed
184 185 186 187
  "Regular expression matching lines that indicate restoring current directory.
This may contain one \\(, \\) pair around the name of the directory
being moved from.  If it does not, the last directory entered \(by a
line matching `compilation-enter-directory-regexp'\) is assumed.
Roland McGrath's avatar
Roland McGrath committed
188 189 190 191

The default value matches lines printed by the `-w' option of GNU Make.")

(defvar compilation-directory-stack nil
Richard M. Stallman's avatar
Richard M. Stallman committed
192 193
  "Stack of previous directories for `compilation-leave-directory-regexp'.
The head element is the directory the compilation was started in.")
Roland McGrath's avatar
Roland McGrath committed
194

195 196 197 198 199
;; History of compile commands.
(defvar compile-history nil)
;; History of grep commands.
(defvar grep-history nil)

Roland McGrath's avatar
Roland McGrath committed
200
;;;###autoload
Richard M. Stallman's avatar
Richard M. Stallman committed
201 202 203 204
(defun compile (command)
  "Compile the program including the current buffer.  Default: run `make'.
Runs COMMAND, a shell command, in a separate process asynchronously
with output going to the buffer `*compilation*'.
Roland McGrath's avatar
Roland McGrath committed
205

Richard M. Stallman's avatar
Richard M. Stallman committed
206 207 208 209
You can then use the command \\[next-error] to find the next error message
and move to the source code that caused it.

To run more than one compilation at once, start one and rename the
Roland McGrath's avatar
Roland McGrath committed
210 211 212 213 214 215
\`*compilation*' buffer to some other name with \\[rename-buffer].
Then start the next one.

The name used for the buffer is actually whatever is returned by
the function in `compilation-buffer-name-function', so you can set that
to a function that generates a unique name."
216
  (interactive (list (read-from-minibuffer "Compile command: "
217
					   compile-command nil nil
218
					   '(compile-history . 1))))
Richard M. Stallman's avatar
Richard M. Stallman committed
219 220
  (setq compile-command command)
  (save-some-buffers nil nil)
Roland McGrath's avatar
Roland McGrath committed
221
  (compile-internal compile-command "No more errors"))
Richard M. Stallman's avatar
Richard M. Stallman committed
222

Roland McGrath's avatar
Roland McGrath committed
223
;;;###autoload
Richard M. Stallman's avatar
Richard M. Stallman committed
224 225 226
(defun grep (command-args)
  "Run grep, with user-specified args, and collect output in a buffer.
While grep runs asynchronously, you can use the \\[next-error] command
Roland McGrath's avatar
Roland McGrath committed
227 228
to find the text that grep hits refer to.

229 230
This command uses a special history list for its arguments, so you can
easily repeat a grep command."
Richard M. Stallman's avatar
Richard M. Stallman committed
231
  (interactive
232 233 234
   (list (read-from-minibuffer "Run grep (like this): "
			       "grep -n " nil nil 'grep-history)))
  (compile-internal (concat command-args " /dev/null")
Roland McGrath's avatar
Roland McGrath committed
235 236 237
		    "No more grep hits" "grep"
		    ;; Give it a simpler regexp to match.
		    nil grep-regexp-alist))
Richard M. Stallman's avatar
Richard M. Stallman committed
238 239

(defun compile-internal (command error-message
Roland McGrath's avatar
Roland McGrath committed
240 241
				 &optional name-of-mode parser regexp-alist
				 name-function)
Richard M. Stallman's avatar
Richard M. Stallman committed
242 243 244
  "Run compilation command COMMAND (low level interface).
ERROR-MESSAGE is a string to print if the user asks to see another error
and there are no more errors.  Third argument NAME-OF-MODE is the name
Roland McGrath's avatar
Roland McGrath committed
245 246 247 248 249 250 251
to display as the major mode in the compilation buffer.

Fourth arg PARSER is the error parser function (nil means the default).  Fifth
arg REGEXP-ALIST is the error message regexp alist to use (nil means the
default).  Sixth arg NAME-FUNCTION is a function called to name the buffer (nil
means the default).  The defaults for these variables are the global values of
\`compilation-parse-errors-function', `compilation-error-regexp-alist', and
Roland McGrath's avatar
Roland McGrath committed
252 253 254
\`compilation-buffer-name-function', respectively.

Returns the compilation buffer created."
Roland McGrath's avatar
Roland McGrath committed
255
  (let (outbuf)
Richard M. Stallman's avatar
Richard M. Stallman committed
256
    (save-excursion
Roland McGrath's avatar
Roland McGrath committed
257 258 259 260 261 262 263 264 265 266 267 268 269
      (or name-of-mode
	  (setq name-of-mode "Compilation"))
      (setq outbuf
	    (get-buffer-create
	     (funcall (or name-function compilation-buffer-name-function
			  (function (lambda (mode)
				      (concat "*" (downcase mode) "*"))))
		      name-of-mode)))
      (set-buffer outbuf)
      (let ((comp-proc (get-buffer-process (current-buffer))))
	(if comp-proc
	    (if (or (not (eq (process-status comp-proc) 'run))
		    (yes-or-no-p
270 271
		     (format "A %s process is running; kill it? "
			     name-of-mode)))
Roland McGrath's avatar
Roland McGrath committed
272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303
		(condition-case ()
		    (progn
		      (interrupt-process comp-proc)
		      (sit-for 1)
		      (delete-process comp-proc))
		  (error nil))
	      (error "Cannot have two processes in `%s' at once"
		     (buffer-name))
	      )))
      ;; In case the compilation buffer is current, make sure we get the global
      ;; values of compilation-error-regexp-alist, etc.
      (kill-all-local-variables))
    (let ((regexp-alist (or regexp-alist compilation-error-regexp-alist))
	  (parser (or parser compilation-parse-errors-function))
	  (thisdir default-directory)
	  outwin) 
      (save-excursion
	;; Clear out the compilation buffer and make it writable.
	;; Change its default-directory to the directory where the compilation
	;; will happen, and insert a `cd' command to indicate this.
	(set-buffer outbuf)
	(setq buffer-read-only nil)
	(erase-buffer)
	(setq default-directory thisdir)
	(insert "cd " thisdir "\n" command "\n")
	(set-buffer-modified-p nil))
      ;; If we're already in the compilation buffer, go to the end
      ;; of the buffer, so point will track the compilation output.
      (if (eq outbuf (current-buffer))
	  (goto-char (point-max)))
      ;; Pop up the compilation buffer.
      (setq outwin (display-buffer outbuf))
304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334
      (save-excursion
	(set-buffer outbuf)
	(compilation-mode)
	(buffer-disable-undo (current-buffer))
	(setq buffer-read-only t)
	(set (make-local-variable 'compilation-parse-errors-function) parser)
	(set (make-local-variable 'compilation-error-message) error-message)
	(set (make-local-variable 'compilation-error-regexp-alist) regexp-alist)
	(setq default-directory thisdir
	      compilation-directory-stack (list default-directory))
	(set-window-start outwin (point-min))
	(setq mode-name name-of-mode)
	(or (eq outwin (selected-window))
	    (set-window-point outwin (point-min)))
	(and compilation-window-height
	     (= (window-width outwin) (frame-width))
	     (let ((w (selected-window)))
	       (unwind-protect
		   (progn
		     (select-window outwin)
		     (enlarge-window (- compilation-window-height
					(window-height))))
		 (select-window w))))
	;; Start the compilation.
	(let ((proc (start-process-shell-command (downcase mode-name)
						 outbuf
						 command)))
	  (set-process-sentinel proc 'compilation-sentinel)
	  (set-process-filter proc 'compilation-filter)
	  (set-marker (process-mark proc) (point) outbuf)
	  (setq compilation-in-progress (cons proc compilation-in-progress)))))
Roland McGrath's avatar
Roland McGrath committed
335 336
    ;; Make it so the next C-x ` will use this buffer.
    (setq compilation-last-buffer outbuf)))
Richard M. Stallman's avatar
Richard M. Stallman committed
337

338
(defvar compilation-minor-mode-map
Richard M. Stallman's avatar
Richard M. Stallman committed
339 340
  (let ((map (make-sparse-keymap)))
    (define-key map "\C-c\C-c" 'compile-goto-error)
Roland McGrath's avatar
Roland McGrath committed
341
    (define-key map "\C-c\C-k" 'kill-compilation)
Roland McGrath's avatar
Roland McGrath committed
342 343
    (define-key map "\M-n" 'compilation-next-error)
    (define-key map "\M-p" 'compilation-previous-error)
Roland McGrath's avatar
Roland McGrath committed
344 345
    (define-key map "\M-{" 'compilation-previous-file)
    (define-key map "\M-}" 'compilation-next-file)
Richard M. Stallman's avatar
Richard M. Stallman committed
346
    map)
347
  "Keymap for `compilation-minor-mode'.")
348 349 350 351 352 353 354

(defvar compilation-mode-map
  (let ((map (cons 'keymap compilation-minor-mode-map)))
    (define-key map " " 'scroll-up)
    (define-key map "\^?" 'scroll-down)
    map)
  "Keymap for compilation log buffers.
355
`compilation-minor-mode-map' is a cdr of this.")
Richard M. Stallman's avatar
Richard M. Stallman committed
356 357 358 359

(defun compilation-mode ()
  "Major mode for compilation log buffers.
\\<compilation-mode-map>To visit the source for a line-numbered error,
Roland McGrath's avatar
Roland McGrath committed
360
move point to the error message line and type \\[compile-goto-error].
Roland McGrath's avatar
Roland McGrath committed
361 362 363
To kill the compilation, type \\[kill-compilation].

Runs `compilation-mode-hook' with `run-hooks' (which see)."
Richard M. Stallman's avatar
Richard M. Stallman committed
364 365 366
  (interactive)
  (fundamental-mode)
  (use-local-map compilation-mode-map)
367 368 369 370 371 372 373 374
  (setq major-mode 'compilation-mode
	mode-name "Compilation")
  (compilation-setup)
  (run-hooks 'compilation-mode-hook))

;; Prepare the buffer for the compilation parsing commands to work.
(defun compilation-setup ()
  ;; Make the buffer's mode line show process state.
Roland McGrath's avatar
Roland McGrath committed
375 376 377 378 379
  (setq mode-line-process '(": %s"))
  (set (make-local-variable 'compilation-error-list) nil)
  (set (make-local-variable 'compilation-old-error-list) nil)
  (set (make-local-variable 'compilation-parsing-end) 1)
  (set (make-local-variable 'compilation-directory-stack) nil)
380 381 382 383 384 385 386 387 388 389 390
  (setq compilation-last-buffer (current-buffer)))

(defvar compilation-minor-mode nil
  "Non-nil when in compilation-minor-mode.
In this minor mode, all the error-parsing commands of the
Compilation major mode are available.")

(or (assq 'compilation-minor-mode minor-mode-alist)
    (setq minor-mode-alist (cons '(compilation-minor-mode " Compilation")
				 minor-mode-alist)))
(or (assq 'compilation-minor-mode minor-mode-map-alist)
391 392
    (setq minor-mode-map-alist (cons (cons 'compilation-minor-mode
					   compilation-minor-mode-map)
393 394 395 396 397 398 399 400 401 402 403
				     minor-mode-map-alist)))

(defun compilation-minor-mode (&optional arg)
  "Toggle compilation minor mode.
With arg, turn compilation mode on if and only if arg is positive.
See `compilation-mode'."
  (interactive "P")
  (if (setq compilation-minor-mode (if (null arg)
				       (null compilation-minor-mode)
				     (> (prefix-numeric-value arg) 0)))
      (compilation-setup)))
Richard M. Stallman's avatar
Richard M. Stallman committed
404 405 406

;; Called when compilation process changes state.
(defun compilation-sentinel (proc msg)
Roland McGrath's avatar
Roland McGrath committed
407 408
  "Sentinel for compilation buffers."
  (let ((buffer (process-buffer proc)))
Roland McGrath's avatar
Roland McGrath committed
409 410 411 412 413 414 415 416 417 418 419 420 421 422
    (if (memq (process-status proc) '(signal exit))
	(progn
	  (if (null (buffer-name buffer))
	      ;; buffer killed
	      (set-process-buffer proc nil)
	    (let ((obuf (current-buffer))
		  omax opoint)
	      ;; save-excursion isn't the right thing if
	      ;; process-buffer is current-buffer
	      (unwind-protect
		  (progn
		    ;; Write something in the compilation buffer
		    ;; and hack its mode line.
		    (set-buffer buffer)
423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441
		    (let ((buffer-read-only nil))
		      (setq omax (point-max)
			    opoint (point))
		      (goto-char omax)
		      ;; Record where we put the message, so we can ignore it
		      ;; later on.
		      (insert ?\n mode-name " " msg)
		      (forward-char -1)
		      (insert " at " (substring (current-time-string) 0 19))
		      (forward-char 1)
		      (setq mode-line-process
			    (concat ": "
				    (symbol-name (process-status proc))))
		      ;; Since the buffer and mode line will show that the
		      ;; process is dead, we can delete it now.  Otherwise it
		      ;; will stay around until M-x list-processes.
		      (delete-process proc)
		      ;; Force mode line redisplay soon.
		      (set-buffer-modified-p (buffer-modified-p)))
Roland McGrath's avatar
Roland McGrath committed
442
		    (if (and opoint (< opoint omax))
Richard M. Stallman's avatar
Richard M. Stallman committed
443 444 445 446
			(goto-char opoint))
		    (if compilation-finish-function
			(funcall compilation-finish-function buffer msg)))
		(set-buffer obuf))))
Roland McGrath's avatar
Roland McGrath committed
447 448
	  (setq compilation-in-progress (delq proc compilation-in-progress))
	  ))))
Richard M. Stallman's avatar
Richard M. Stallman committed
449

450 451
(defun compilation-filter (proc string)
  "Process filter for compilation buffers.
452
Just inserts the text, but uses `insert-before-markers'."
453 454 455 456 457 458 459 460
  (save-excursion
    (set-buffer (process-buffer proc))
    (let ((buffer-read-only nil))
      (save-excursion
	(goto-char (process-mark proc))
	(insert-before-markers string)
	(set-marker (process-mark proc) (point))))))

Roland McGrath's avatar
Roland McGrath committed
461 462 463 464 465 466 467 468 469
;; Return the cdr of compilation-old-error-list for the error containing point.
(defun compile-error-at-point ()
  (compile-reinitialize-errors nil (point))
  (let ((errors compilation-old-error-list))
    (while (and errors
		(> (point) (car (car errors))))
      (setq errors (cdr errors)))
    errors))

Roland McGrath's avatar
Roland McGrath committed
470 471 472 473 474 475 476
(defun compilation-next-error (n)
  "Move point to the next error in the compilation buffer.
Does NOT find the source line like \\[next-error]."
  (interactive "p")
  (or (compilation-buffer-p (current-buffer))
      (error "Not in a compilation buffer."))
  (setq compilation-last-buffer (current-buffer))
Roland McGrath's avatar
Roland McGrath committed
477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495

  (let ((errors (compile-error-at-point)))

    ;; Move to the error after the one containing point.
    (goto-char (car (if (< n 0)
			(let ((i 0)
			      (e compilation-old-error-list))
			  ;; See how many cdrs away ERRORS is from the start.
			  (while (not (eq e errors))
			    (setq i (1+ i)
				  e (cdr e)))
			  (if (> (- n) i)
			      (error "Moved back past first error")
			    (nth (+ i n) compilation-old-error-list)))
		      (let ((compilation-error-list (cdr errors)))
			(compile-reinitialize-errors nil nil n)
			(if compilation-error-list
			    (nth (1- n) compilation-error-list)
			  (error "Moved past last error"))))))))
Roland McGrath's avatar
Roland McGrath committed
496 497 498 499 500 501 502 503

(defun compilation-previous-error (n)
  "Move point to the previous error in the compilation buffer.
Does NOT find the source line like \\[next-error]."
  (interactive "p")
  (compilation-next-error (- n)))


Roland McGrath's avatar
Roland McGrath committed
504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543
(defun compile-file-of-error (data)
  (setq data (cdr data))
  (if (markerp data)
      (buffer-file-name (marker-buffer data))
    (setq data (car data))
    (expand-file-name (cdr data) (car data))))

(defun compilation-next-file (n)
  "Move point to the next error for a different file than the current one."
  (interactive "p")
  (or (compilation-buffer-p (current-buffer))
      (error "Not in a compilation buffer."))
  (setq compilation-last-buffer (current-buffer))

  (let ((reversed (< n 0))
	errors file)

    (if (not reversed)
	(setq errors (or (compile-error-at-point)
			 (error "Moved past last error")))

      ;; Get a reversed list of the errors up through the one containing point.
      (compile-reinitialize-errors nil (point))
      (setq errors (reverse compilation-old-error-list)
	    n (- n))

      ;; Ignore errors after point.  (car ERRORS) will be the error
      ;; containing point, (cadr ERRORS) the one before it.
      (while (and errors
		  (< (point) (car (car errors))))
	(setq errors (cdr errors))))

    (while (> n 0)
      (setq file (compile-file-of-error (car errors)))

      ;; Skip past the other errors for this file.
      (while (string= file
		      (compile-file-of-error
		       (car (or errors
				(if reversed
Roland McGrath's avatar
Roland McGrath committed
544
				    (error "%s the first erring file" file)
Roland McGrath's avatar
Roland McGrath committed
545 546 547 548
				  (let ((compilation-error-list nil))
				    ;; Parse some more.
				    (compile-reinitialize-errors nil nil 2)
				    (setq errors compilation-error-list)))
Roland McGrath's avatar
Roland McGrath committed
549
				(error "%s is the last erring file" file)))))
Roland McGrath's avatar
Roland McGrath committed
550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568
	(setq errors (cdr errors)))

      (setq n (1- n)))

    ;; Move to the following error.
    (goto-char (car (car (or errors
			     (if reversed
				 (error "This is the first erring file")
			       (let ((compilation-error-list nil))
				 ;; Parse the last one.
				 (compile-reinitialize-errors nil nil 1)
				 compilation-error-list))))))))

(defun compilation-previous-file (n)
  "Move point to the previous error for a different file than the current one."
  (interactive "p")
  (compilation-next-file (- n)))


Richard M. Stallman's avatar
Richard M. Stallman committed
569 570 571
(defun kill-compilation ()
  "Kill the process made by the \\[compile] command."
  (interactive)
Roland McGrath's avatar
Roland McGrath committed
572
  (let ((buffer (compilation-find-buffer)))
Richard M. Stallman's avatar
Richard M. Stallman committed
573
    (if (get-buffer-process buffer)
Roland McGrath's avatar
Roland McGrath committed
574 575 576
	(interrupt-process (get-buffer-process buffer))
      (error "The compilation process is not running."))))

Richard M. Stallman's avatar
Richard M. Stallman committed
577

Roland McGrath's avatar
Roland McGrath committed
578 579
;; Parse any new errors in the compilation buffer,
;; or reparse from the beginning if the user has asked for that.
Roland McGrath's avatar
Roland McGrath committed
580
(defun compile-reinitialize-errors (argp &optional limit-search find-at-least)
Roland McGrath's avatar
Roland McGrath committed
581 582 583 584 585 586 587 588
  (save-excursion
    (set-buffer compilation-last-buffer)
    ;; If we are out of errors, or if user says "reparse",
    ;; discard the info we have, to force reparsing.
    (if (or (eq compilation-error-list t)
	    (consp argp))
	(progn (compilation-forget-errors)
	       (setq compilation-parsing-end 1)))
Roland McGrath's avatar
Roland McGrath committed
589
    (if (and compilation-error-list
Roland McGrath's avatar
Roland McGrath committed
590 591
	     (or (not limit-search)
		 (> compilation-parsing-end limit-search))
Roland McGrath's avatar
Roland McGrath committed
592 593
	     (or (not find-at-least)
		 (> (length compilation-error-list) find-at-least)))
Roland McGrath's avatar
Roland McGrath committed
594 595 596 597
	;; Since compilation-error-list is non-nil, it points to a specific
	;; error the user wanted.  So don't move it around.
	nil
      (switch-to-buffer compilation-last-buffer)
Richard M. Stallman's avatar
Richard M. Stallman committed
598
      (set-buffer-modified-p nil)
Roland McGrath's avatar
Roland McGrath committed
599 600 601 602 603 604 605 606 607 608 609
      (if (< compilation-parsing-end (point-max))
	  (let ((at-start (= compilation-parsing-end 1)))
	    (funcall compilation-parse-errors-function
		     limit-search find-at-least)
	    ;; Remember the entire list for compilation-forget-errors.
	    ;; If this is an incremental parse, append to previous list.
	    (if at-start
		(setq compilation-old-error-list compilation-error-list)
	      (setq compilation-old-error-list
		    (nconc compilation-old-error-list compilation-error-list)))
	    )))))
Richard M. Stallman's avatar
Richard M. Stallman committed
610 611 612 613

(defun compile-goto-error (&optional argp)
  "Visit the source for the error message point is on.
Use this command in a compilation log buffer.
Roland McGrath's avatar
Roland McGrath committed
614
\\[universal-argument] as a prefix arg means to reparse the buffer's error messages first;
Richard M. Stallman's avatar
Richard M. Stallman committed
615 616
other kinds of prefix arguments are ignored."
  (interactive "P")
Roland McGrath's avatar
Roland McGrath committed
617 618 619
  (or (compilation-buffer-p (current-buffer))
      (error "Not in a compilation buffer."))
  (setq compilation-last-buffer (current-buffer))
Roland McGrath's avatar
Roland McGrath committed
620
  (compile-reinitialize-errors argp (point))
Roland McGrath's avatar
Roland McGrath committed
621

Roland McGrath's avatar
Roland McGrath committed
622 623 624
  ;; Move to bol; the marker for the error on this line will point there.
  (beginning-of-line)

Roland McGrath's avatar
Roland McGrath committed
625
  ;; Move compilation-error-list to the elt of compilation-old-error-list
Roland McGrath's avatar
Roland McGrath committed
626
  ;; we want.
Roland McGrath's avatar
Roland McGrath committed
627
  (setq compilation-error-list compilation-old-error-list)
Roland McGrath's avatar
Roland McGrath committed
628 629
  (while (and compilation-error-list
	      (> (point) (car (car compilation-error-list))))
Roland McGrath's avatar
Roland McGrath committed
630 631
    (setq compilation-error-list (cdr compilation-error-list)))

Richard M. Stallman's avatar
Richard M. Stallman committed
632 633 634
  ;; Move to another window, so that next-error's window changes
  ;; result in the desired setup.
  (or (one-window-p)
Roland McGrath's avatar
Roland McGrath committed
635 636 637 638 639 640
      (progn
	(other-window -1)
	;; other-window changed the selected buffer,
	;; but we didn't want to do that.
	(set-buffer compilation-last-buffer)))

Roland McGrath's avatar
Roland McGrath committed
641
  (next-error 1))
Richard M. Stallman's avatar
Richard M. Stallman committed
642

Roland McGrath's avatar
Roland McGrath committed
643 644 645 646 647 648 649 650
(defun compilation-buffer-p (buffer)
  (assq 'compilation-error-list (buffer-local-variables buffer)))

;; Return a compilation buffer.
;; If the current buffer is a compilation buffer, return it.
;; If compilation-last-buffer is set to a live buffer, use that.
;; Otherwise, look for a compilation buffer and signal an error
;; if there are none.
Jim Blandy's avatar
Jim Blandy committed
651 652 653
(defun compilation-find-buffer (&optional other-buffer)
  (if (and (not other-buffer)
	   (compilation-buffer-p (current-buffer)))
Roland McGrath's avatar
Roland McGrath committed
654 655
      ;; The current buffer is a compilation buffer.
      (current-buffer)
Jim Blandy's avatar
Jim Blandy committed
656 657 658
    (if (and compilation-last-buffer (buffer-name compilation-last-buffer)
	     (or (not other-buffer) (not (eq compilation-last-buffer
					     (current-buffer)))))
Roland McGrath's avatar
Roland McGrath committed
659 660
	compilation-last-buffer
      (let ((buffers (buffer-list)))
Jim Blandy's avatar
Jim Blandy committed
661 662 663
	(while (and buffers (or (not (compilation-buffer-p (car buffers)))
				(and other-buffer
				     (eq (car buffers) (current-buffer)))))
Roland McGrath's avatar
Roland McGrath committed
664 665 666
	  (setq buffers (cdr buffers)))
	(if buffers
	    (car buffers)
Jim Blandy's avatar
Jim Blandy committed
667 668 669 670 671 672 673 674
	  (or (and other-buffer
		   (compilation-buffer-p (current-buffer))
		   ;; The current buffer is a compilation buffer.
		   (progn
		     (if other-buffer
			 (message "This is the only compilation buffer."))
		     (current-buffer)))
	      (error "No compilation started!")))))))
Roland McGrath's avatar
Roland McGrath committed
675 676

;;;###autoload
Richard M. Stallman's avatar
Richard M. Stallman committed
677 678 679 680 681 682 683 684 685 686 687 688 689 690 691 692 693 694
(defun next-error (&optional argp)
  "Visit next compilation error message and corresponding source code.
This operates on the output from the \\[compile] command.
If all preparsed error messages have been processed,
the error message buffer is checked for new ones.

A prefix arg specifies how many error messages to move;
negative means move back to previous error messages.
Just C-u as a prefix means reparse the error message buffer
and start at the first error.

\\[next-error] normally applies to the most recent compilation started,
but as long as you are in the middle of parsing errors from one compilation
output buffer, you stay with that compilation output buffer.

Use \\[next-error] in a compilation output buffer to switch to
processing errors from that compilation.

Roland McGrath's avatar
Roland McGrath committed
695 696
See variables `compilation-parse-errors-function' and
\`compilation-error-regexp-alist' for customization ideas."
Richard M. Stallman's avatar
Richard M. Stallman committed
697
  (interactive "P")
Roland McGrath's avatar
Roland McGrath committed
698
  (setq compilation-last-buffer (compilation-find-buffer))
699 700 701 702 703
  (compile-reinitialize-errors argp nil
			       ;; We want to pass a number here only if
			       ;; we got a numeric prefix arg, not just C-u.
			       (and (not (consp argp))
				    (1- (prefix-numeric-value argp))))
Roland McGrath's avatar
Roland McGrath committed
704 705 706 707
  ;; Make ARGP nil if the prefix arg was just C-u,
  ;; since that means to reparse the errors, which the
  ;; compile-reinitialize-errors call just did.
  ;; Now we are only interested in a numeric prefix arg.
Richard M. Stallman's avatar
Richard M. Stallman committed
708 709
  (if (consp argp)
      (setq argp nil))
Roland McGrath's avatar
Roland McGrath committed
710 711 712
  (let (next-errors next-error)
    (save-excursion
      (set-buffer compilation-last-buffer)
Roland McGrath's avatar
Roland McGrath committed
713 714
      ;; compilation-error-list points to the "current" error.
      (setq next-errors (nthcdr (1- (prefix-numeric-value argp))
Roland McGrath's avatar
Roland McGrath committed
715
				compilation-error-list)
Roland McGrath's avatar
Roland McGrath committed
716 717
	    next-error (car next-errors))
      (while
Richard M. Stallman's avatar
Richard M. Stallman committed
718
	  (progn
Roland McGrath's avatar
Roland McGrath committed
719 720 721 722 723 724 725 726 727 728 729 730 731 732 733 734 735 736 737 738
	    (if (null next-error)
		(progn
		  (if argp (if (> (prefix-numeric-value argp) 0)
			       (error "Moved past last error")
			     (error "Moved back past first error")))
		  (compilation-forget-errors)
		  (error (concat compilation-error-message
				 (and (get-buffer-process (current-buffer))
				      (eq (process-status
					   (get-buffer-process
					    (current-buffer)))
					  'run)
				      " yet"))))
	      (setq compilation-error-list (cdr next-errors))
	      (if (null (cdr next-error))
		  ;; This error is boring.  Go to the next.
		  t
		(or (markerp (cdr next-error))
		    ;; This error has a filename/lineno pair.
		    ;; Find the file and turn it into a marker.
739 740 741 742
		    (let* ((fileinfo
			    (cons (file-name-directory (car (cdr next-error)))
				  (file-name-nondirectory
				   (car (cdr next-error)))))
Roland McGrath's avatar
Roland McGrath committed
743 744 745 746 747 748 749 750 751 752 753 754 755 756 757 758 759 760 761
			   (buffer (compilation-find-file (cdr fileinfo)
							  (car fileinfo)
							  (car next-error))))
		      (if (null buffer)
			  ;; We can't find this error's file.
			  ;; Remove all errors in the same file.
			  (progn
			    (setq next-errors compilation-old-error-list)
			    (while next-errors
			      (and (consp (cdr (car next-errors)))
				   (equal (car (cdr (car next-errors)))
					  fileinfo)
				   (progn
				     (set-marker (car (car next-errors)) nil)
				     (setcdr (car next-errors) nil)))
			      (setq next-errors (cdr next-errors)))
			    ;; Look for the next error.
			    t)
			;; We found the file.  Get a marker for this error.
762 763 764 765 766 767 768 769 770
			;; compilation-old-error-list is a buffer-local
			;; variable, so we must be careful to extract its value
			;; before switching to the source file buffer.
			(let ((errors compilation-old-error-list)
			      (last-line (cdr (cdr next-error))))
			  (set-buffer buffer)
			  (save-excursion
			    (save-restriction
			      (widen)
Roland McGrath's avatar
Roland McGrath committed
771 772 773 774 775 776 777 778 779 780 781 782 783 784 785 786 787 788 789 790 791 792 793 794 795 796 797 798 799 800 801 802 803 804 805 806 807 808 809 810 811 812 813 814 815
			      (goto-line last-line)
			      (beginning-of-line)
			      (setcdr next-error (point-marker))
			      ;; Make all the other error messages referring
			      ;; to the same file have markers into the buffer.
			      (while errors
				(and (consp (cdr (car errors)))
				     (equal (car (cdr (car errors))) fileinfo)
				     (let ((this (cdr (cdr (car errors))))
					   (lines (- (cdr (cdr (car errors)))
						     last-line)))
				       (if (eq selective-display t)
					   (if (< lines 0)
					       (re-search-backward "[\n\C-m]"
								   nil 'end
								   (- lines))
					     (re-search-forward "[\n\C-m]"
								nil 'end
								lines))
					 (forward-line lines))
				       (setq last-line this)
				       (setcdr (car errors) (point-marker))))
				(setq errors (cdr errors)))))))))
		;; If we didn't get a marker for this error,
		;; go on to the next one.
		(not (markerp (cdr next-error))))))
	(setq next-errors compilation-error-list
	      next-error (car next-errors))))

    ;; Skip over multiple error messages for the same source location,
    ;; so the next C-x ` won't go to an error in the same place.
    (while (and compilation-error-list
		(equal (cdr (car compilation-error-list)) (cdr next-error)))
      (setq compilation-error-list (cdr compilation-error-list)))

    ;; We now have a marker for the position of the error.
    (switch-to-buffer (marker-buffer (cdr next-error)))
    (goto-char (cdr next-error))
    ;; If narrowing got in the way of
    ;; going to the right place, widen.
    (or (= (point) (marker-position (cdr next-error)))
	(progn
	  (widen)
	  (goto-char (cdr next-error))))

Richard M. Stallman's avatar
Richard M. Stallman committed
816 817 818 819
    ;; Show compilation buffer in other window, scrolled to this error.
    (let* ((pop-up-windows t)
	   (w (display-buffer (marker-buffer (car next-error)))))
      (set-window-point w (car next-error))
Roland McGrath's avatar
Roland McGrath committed
820 821 822 823 824 825 826 827 828 829 830 831 832 833 834 835 836 837 838 839 840 841 842 843 844 845 846 847 848 849 850 851 852 853 854 855 856 857 858 859 860 861
      (set-window-start w (car next-error)))))

;;;###autoload
(define-key ctl-x-map "`" 'next-error)

;; Find a buffer for file FILENAME.
;; Search the directories in compilation-search-path.
;; A nil in compilation-search-path means to try the
;; current directory, which is passed in DIR.
;; If FILENAME is not found at all, ask the user where to find it.
;; Pop up the buffer containing MARKER and scroll to MARKER if we ask the user.
(defun compilation-find-file (filename dir marker)
  (let ((dirs compilation-search-path)
	result name)
    (while (and dirs (null result))
      (setq name (expand-file-name filename (or (car dirs) dir))
	    result (and (file-exists-p name)
			(find-file-noselect name))
	    dirs (cdr dirs)))
    (or result
	;; The file doesn't exist.
	;; Ask the user where to find it.
	;; If he hits C-g, then the next time he does
	;; next-error, he'll skip past it.
	(progn
	  (let* ((pop-up-windows t)
		 (w (display-buffer (marker-buffer marker))))
	    (set-window-point w marker)
	    (set-window-start w marker))
	  (setq name
		(expand-file-name
		 (read-file-name
		  (format "Find this error in: (default %s) "
			  filename) dir filename t)))
	  (if (file-directory-p name)
	      (setq name (concat (file-name-as-directory name) filename)))
	  (if (file-exists-p name)
	      (find-file-noselect name))))))

;; Set compilation-error-list to nil, and unchain the markers that point to the
;; error messages and their text, so that they no longer slow down gap motion.
;; This would happen anyway at the next garbage collection, but it is better to
Roland McGrath's avatar
Roland McGrath committed
862
;; do it right away.
Richard M. Stallman's avatar
Richard M. Stallman committed
863 864 865 866
(defun compilation-forget-errors ()
  (while compilation-old-error-list
    (let ((next-error (car compilation-old-error-list)))
      (set-marker (car next-error) nil)
Roland McGrath's avatar
Roland McGrath committed
867 868
      (if (markerp (cdr next-error))
	  (set-marker (cdr next-error) nil)))
Richard M. Stallman's avatar
Richard M. Stallman committed
869
    (setq compilation-old-error-list (cdr compilation-old-error-list)))
870 871
  (setq compilation-error-list nil
	compilation-directory-stack nil))
Roland McGrath's avatar
Roland McGrath committed
872 873 874 875 876 877 878 879 880 881 882 883 884 885 886 887 888 889 890 891 892 893 894 895 896 897


(defun count-regexp-groupings (regexp)
  "Return the number of \\( ... \\) groupings in REGEXP (a string)."
  (let ((groupings 0)
	(len (length regexp))
	(i 0)
	c)
    (while (< i len)
      (setq c (aref regexp i)
	    i (1+ i))
      (cond ((= c ?\[)
	     ;; Find the end of this [...].
	     (while (and (< i len)
			 (not (= (aref regexp i) ?\])))
	       (setq i (1+ i))))
	    ((= c ?\\)
	     (if (< i len)
		 (progn
		   (setq c (aref regexp i)
			 i (1+ i))
		   (if (= c ?\))
		       ;; We found the end of a grouping,
		       ;; so bump our counter.
		       (setq groupings (1+ groupings))))))))
    groupings))
Richard M. Stallman's avatar
Richard M. Stallman committed
898

Roland McGrath's avatar
Roland McGrath committed
899
(defun compilation-parse-errors (limit-search find-at-least)
Richard M. Stallman's avatar
Richard M. Stallman committed
900
  "Parse the current buffer as grep, cc or lint error messages.
Roland McGrath's avatar
Roland McGrath committed
901
See variable `compilation-parse-errors-function' for the interface it uses."
Richard M. Stallman's avatar
Richard M. Stallman committed
902 903 904
  (setq compilation-error-list nil)
  (message "Parsing error messages...")
  (let (text-buffer
Roland McGrath's avatar
Roland McGrath committed
905
	regexp enter-group leave-group error-group
Roland McGrath's avatar
Roland McGrath committed
906
	alist subexpr error-regexp-groups
Roland McGrath's avatar
Roland McGrath committed
907
	(found-desired nil)
Richard M. Stallman's avatar
Richard M. Stallman committed
908
	(compilation-num-errors-found 0))
Roland McGrath's avatar
Roland McGrath committed
909

Richard M. Stallman's avatar
Richard M. Stallman committed
910 911 912 913 914 915
    ;; Don't reparse messages already seen at last parse.
    (goto-char compilation-parsing-end)
    ;; Don't parse the first two lines as error messages.
    ;; This matters for grep.
    (if (bobp)
	(forward-line 2))
Roland McGrath's avatar
Roland McGrath committed
916 917 918 919 920 921 922 923 924 925 926 927 928 929 930 931 932 933 934 935 936 937 938 939 940 941 942

    ;; Compile all the regexps we want to search for into one.
    (setq regexp (concat "\\(" compilation-enter-directory-regexp "\\)\\|"
			 "\\(" compilation-leave-directory-regexp "\\)\\|"
			 "\\(" (mapconcat (function
					   (lambda (elt)
					     (concat "\\(" (car elt) "\\)")))
					  compilation-error-regexp-alist
					  "\\|") "\\)"))

    ;; Find out how many \(...\) groupings are in each of the regexps, and set
    ;; *-GROUP to the grouping containing each constituent regexp (whose
    ;; subgroups will come immediately thereafter) of the big regexp we have
    ;; just constructed.
    (setq enter-group 1
	  leave-group (+ enter-group
			 (count-regexp-groupings
			  compilation-enter-directory-regexp)
			 1)
	  error-group (+ leave-group
			 (count-regexp-groupings
			  compilation-leave-directory-regexp)
			 1))

    ;; Compile an alist (IDX FILE LINE), where IDX is the number of the
    ;; subexpression for an entire error-regexp, and FILE and LINE are the
    ;; numbers for the subexpressions giving the file name and line number.
943 944
    (setq alist (or compilation-error-regexp-alist
		    (error "compilation-error-regexp-alist is empty!"))
Roland McGrath's avatar
Roland McGrath committed
945 946 947 948 949 950 951 952 953
	  subexpr (1+ error-group))
    (while alist
      (setq error-regexp-groups (cons (list subexpr
					    (+ subexpr (nth 1 (car alist)))
					    (+ subexpr (nth 2 (car alist))))
				      error-regexp-groups))
      (setq subexpr (+ subexpr 1 (count-regexp-groupings (car (car alist)))))
      (setq alist (cdr alist)))

Roland McGrath's avatar
Roland McGrath committed
954
    (while (and (not found-desired)
Roland McGrath's avatar
Roland McGrath committed
955 956 957
		;; We don't just pass LIMIT-SEARCH to re-search-forward
		;; because we want to find matches containing LIMIT-SEARCH
		;; but which extend past it.
Roland McGrath's avatar
Roland McGrath committed
958
		(re-search-forward regexp nil t))
Roland McGrath's avatar
Roland McGrath committed
959

Roland McGrath's avatar
Roland McGrath committed
960 961 962 963 964 965 966 967 968 969 970 971 972 973 974 975 976 977 978 979 980 981 982 983 984 985 986 987 988 989 990 991 992 993 994 995 996 997 998 999 1000 1001
      ;; Figure out which constituent regexp matched.
      (cond ((match-beginning enter-group)
	     ;; The match was the enter-directory regexp.
	     (let ((dir
		    (file-name-as-directory
		     (expand-file-name
		      (buffer-substring (match-beginning (+ enter-group 1))
					(match-end (+ enter-group 1)))))))
	       (setq compilation-directory-stack
		     (cons dir compilation-directory-stack))
	       (and (file-directory-p dir)
		    (setq default-directory dir))))
	    
	    ((match-beginning leave-group)
	     ;; The match was the leave-directory regexp.
	     (let ((beg (match-beginning (+ leave-group 1)))
		   (stack compilation-directory-stack))
	       (if beg
		   (let ((dir
			  (file-name-as-directory
			   (expand-file-name
			    (buffer-substring beg
					      (match-end (+ leave-group
							    1)))))))
		     (while (and stack
				 (not (string-equal (car stack) dir)))
		       (setq stack (cdr stack)))))
	       (setq compilation-directory-stack (cdr stack))
	       (setq stack (car compilation-directory-stack))
	       (if stack
		   (setq default-directory stack))
	       ))
	    
	    ((match-beginning error-group)
	     ;; The match was the composite error regexp.
	     ;; Find out which individual regexp matched.
	     (setq alist error-regexp-groups)
	     (while (and alist
			 (null (match-beginning (car (car alist)))))
	       (setq alist (cdr alist)))
	     (if alist
		 (setq alist (car alist))
1002
	       (error "compilation-parse-errors: impossible regexp match!"))
Roland McGrath's avatar
Roland McGrath committed
1003 1004
	     
	     ;; Extract the file name and line number from the error message.
1005 1006
	     (let ((beginning-of-match (match-beginning 0)) ;looking-at nukes
		   (filename
1007 1008 1009 1010 1011 1012
		    (save-excursion
		      (goto-char (match-end (nth 1 alist)))
		      (skip-chars-backward " \t")
		      (let ((name (buffer-substring (match-beginning (nth 1 alist))
						    (point))))
			(expand-file-name name default-directory))))
Roland McGrath's avatar
Roland McGrath committed
1013 1014 1015 1016 1017 1018 1019 1020 1021 1022 1023 1024 1025 1026 1027 1028
		   (linenum (save-restriction
			      (narrow-to-region
			       (match-beginning (nth 2 alist))
			       (match-end (nth 2 alist)))
			      (goto-char (point-min))
			      (if (looking-at "[0-9]")
				  (read (current-buffer))))))
	       ;; Locate the erring file and line.
	       ;; Cons a new elt onto compilation-error-list,
	       ;; giving a marker for the current compilation buffer
	       ;; location, and the file and line number of the error.
	       (save-excursion
		 (beginning-of-line 1)
		 (setq compilation-error-list
		       (cons (cons (point-marker)
				   (cons filename linenum))
1029 1030 1031 1032 1033 1034 1035 1036 1037 1038 1039 1040 1041 1042 1043 1044 1045 1046 1047 1048 1049 1050 1051 1052
			     compilation-error-list)))
	       (setq compilation-num-errors-found
		     (1+ compilation-num-errors-found))
	       (and find-at-least (>= compilation-num-errors-found
				      find-at-least)
		    ;; We have found as many new errors as the user wants.
		    ;; We continue to parse until we have seen all
		    ;; the consecutive errors in the same file,
		    ;; so the error positions will be recorded as markers
		    ;; in this buffer that might change.
		    (cdr compilation-error-list) ; Must check at least two.
		    (not (equal (car (cdr (nth 0 compilation-error-list)))
				(car (cdr (nth 1 compilation-error-list)))))
		    (progn
		      ;; Discard the error just parsed, so that the next
		      ;; parsing run can get it and the following errors in
		      ;; the same file all at once.  If we didn't do this, we
		      ;; would have the same problem we are trying to avoid
		      ;; with the test above, just delayed until the next run!
		      (setq compilation-error-list
			    (cdr compilation-error-list))
		      (goto-char beginning-of-match)
		      (setq found-desired t)))
	       )
1053
	     )
Roland McGrath's avatar
Roland McGrath committed
1054
	    (t
1055
	     (error "compilation-parse-errors: known groups didn't match!")))
Roland McGrath's avatar
Roland McGrath committed
1056 1057

      (message "Parsing error messages...%d (%d%% of buffer)"
Richard M. Stallman's avatar
Richard M. Stallman committed
1058
	       compilation-num-errors-found
Roland McGrath's avatar
Roland McGrath committed
1059 1060
	       (/ (* 100 (point)) (point-max)))

Roland McGrath's avatar
Roland McGrath committed
1061 1062 1063
      (and limit-search (>= (point) limit-search)
	   ;; The user wanted a specific error, and we're past it.
	   (setq found-desired t)))
Roland McGrath's avatar
Roland McGrath committed
1064 1065 1066 1067 1068 1069
    (setq compilation-parsing-end (if found-desired
				      (point)
				    ;; We have searched the whole buffer.
				    (point-max))))
  (setq compilation-error-list (nreverse compilation-error-list))
  (message "Parsing error messages...done"))
Richard M. Stallman's avatar
Richard M. Stallman committed
1070

Jim Blandy's avatar
Jim Blandy committed
1071
(provide 'compile)
Eric S. Raymond's avatar
Eric S. Raymond committed
1072 1073

;;; compile.el ends here