| blob | a1596617eea77996081c1401a02217a3be901edf |
1 ;;; compile.el --- run compiler as inferior of Emacs, parse error messages.
3 ;; Maintainer: FSF
4 ;; Last-Modified: 05 Jul 1992
6 ;;;!!! dup removal is broken.
8 ;; Copyright (C) 1985-1991 Free Software Foundation, Inc.
10 ;; This file is part of GNU Emacs.
12 ;; GNU Emacs is distributed in the hope that it will be useful,
13 ;; but WITHOUT ANY WARRANTY. No author or distributor
14 ;; accepts responsibility to anyone for the consequences of using it
15 ;; or for whether it serves any particular purpose or works at all,
16 ;; unless he says so in writing. Refer to the GNU Emacs General Public
17 ;; License for full details.
19 ;; Everyone is granted permission to copy, modify and redistribute
20 ;; GNU Emacs, but only under the conditions described in the
21 ;; GNU Emacs General Public License. A copy of this license is
22 ;; supposed to have been given to you along with GNU Emacs so you
23 ;; can know your rights and responsibilities. It should be in a
24 ;; file named COPYING. Among other things, the copyright notice
25 ;; and this notice must be preserved on all copies.
27 ;;; Code:
29 ;;;###autoload
33 ;;;###autoload
38 "List of error message descriptors for visiting erring functions.
39 Each error descriptor is a cons (or nil).
40 Its car is a marker pointing to an error message.
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.
46 The value may be t instead of a list; this means that the buffer of
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
58 ;;;###autoload
60 "*Function to call with one argument, the name of the major mode of the
61 compilation buffer, to give the buffer a name. It should return a string.
66 ;;;###autoload
68 "*Function to call when a compilation process finishes.
69 It is called with two arguments: the compilation buffer, and a string
73 "The buffer in which the last compilation was started,
80 minor-mode-alist)))
86 "Message to print when no more matches for `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
96 ;; 4.3BSD lint pass 2
97 ;; strcmp: variable # of args. llib-lc(359) :: /usr/src/foo/foo.c(8)
99 ;; 4.3BSD lint pass 3
100 ;; bloofle defined( /users/wolfgang/foo.c(4) ), but never used
101 ;; This used to be
102 ;; ("[ \t(]+\\([^:( \t\n]+\\)[:( \t]+\\([0-9]+\\)[:) \t]+" 1 2)
103 ;; which is regexp Impressionism - it matches almost anything!
105 ;; Line 45 of "foo.c": bloofel undefined (who does this?)
107 ;; Apollo cc, 4.3BSD fc
108 ;; "foo.f", line 3: Error: syntax error near end of statement
110 ;; HP-UX 7.0 fc
111 ;; foo.f :16 some horrible error message
113 ;; IBM AIX PS/2 C version 1.1
114 ;; ****** Error number 140 in line 8 of file errors.c ******
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
123 ;;;###autoload
125 "*List of directories to search for source files named in error messages.
126 Elements should be directory names, not file names of directories.
130 "Last shell command used to do a compilation; default for next compilation.
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:
135 (setq c-mode-hook
137 (progn (make-local-variable 'compile-command)
138 (setq compile-command
142 ;;;###autoload
144 "Last shell command used to do a grep search; default for next search.
150 "Regular expression for a line in the compilation log that
152 around the directory name.
158 "Regular expression for a line in the compilation log that
159 changes the current directory to a previous value. This may
161 being moved from. If it does not, the last directory entered
162 \(by a line matching `compilation-enter-directory-regexp'\) is assumed.
167 "Stack of directories entered by lines matching
168 \`compilation-enter-directory-regexp' and not yet left by lines matching
169 \`compilation-leave-directory-regexp'. The head element is the directory
172 ;;;###autoload
174 "Compile the program including the current buffer. Default: run `make'.
175 Runs COMMAND, a shell command, in a separate process asynchronously
176 with output going to the buffer `*compilation*'.
179 and move to the source code that caused it.
181 To run more than one compilation at once, start one and rename the
183 Then start the next one.
185 The name used for the buffer is actually whatever is returned by
186 the function in `compilation-buffer-name-function', so you can set that
187 to a function that generates a unique name."
193 ;;;###autoload
195 "Run grep, with user-specified args, and collect output in a buffer.
197 to find the text that grep hits refer to.
199 The variable `grep-command' holds the last grep command run,
200 and is the default for future runs. The command should use the `-n'
201 flag, so that line numbers are displayed for each match.
202 What the user enters in response to the prompt for grep args is
203 appended to everything up to and including the `-n' in `grep-command'."
212 ;; why a redundant string-match? It might not be interactive ...
222 &optional name-of-mode parser regexp-alist
223 name-function)
224 "Run compilation command COMMAND (low level interface).
225 ERROR-MESSAGE is a string to print if the user asks to see another error
226 and there are no more errors. Third argument NAME-OF-MODE is the name
227 to display as the major mode in the compilation buffer.
229 Fourth arg PARSER is the error parser function (nil means the default). Fifth
230 arg REGEXP-ALIST is the error message regexp alist to use (nil means the
231 default). Sixth arg NAME-FUNCTION is a function called to name the buffer (nil
232 means the default). The defaults for these variables are the global values of
233 \`compilation-parse-errors-function', `compilation-error-regexp-alist', and
234 \`compilation-buffer-name-function', respectively."
244 name-of-mode)))
259 )))
260 ;; In case the compilation buffer is current, make sure we get the global
261 ;; values of compilation-error-regexp-alist, etc.
266 outwin)
268 ;; Clear out the compilation buffer and make it writable.
269 ;; Change its default-directory to the directory where the compilation
270 ;; will happen, and insert a `cd' command to indicate this.
277 ;; If we're already in the compilation buffer, go to the end
278 ;; of the buffer, so point will track the compilation output.
281 ;; Pop up the compilation buffer.
305 ;; Start the compilation.
307 outbuf
308 command)))
311 ;; Make it so the next C-x ` will use this buffer.
318 map)
322 "Major mode for compilation log buffers.
327 Runs `compilation-mode-hook' with `run-hooks' (which see)."
333 ;; Make buffer's mode line show process state
342 ;; Called when compilation process changes state.
344 "Sentinel for compilation buffers."
349 ;; buffer killed
352 omax opoint)
353 ;; save-excursion isn't the right thing if
354 ;; process-buffer is current-buffer
357 ;; Write something in the compilation buffer
358 ;; and hack its mode line.
364 ;; Record where we put the message, so we can ignore it
365 ;; later on.
373 ;; Since the buffer and mode line will show that the
374 ;; process is dead, we can delete it now. Otherwise it
375 ;; will stay around until M-x list-processes.
377 ;; Force mode line redisplay soon.
385 ))
387 ))))
398 ;; Parse any new errors in the compilation buffer,
399 ;; or reparse from the beginning if the user has asked for that.
403 ;; If we are out of errors, or if user says "reparse",
404 ;; discard the info we have, to force reparsing.
410 ;; Since compilation-error-list is non-nil, it points to a specific
411 ;; error the user wanted. So don't move it around.
412 nil
417 ;; Remember the entire list for compilation-forget-errors.
418 ;; If this is an incremental parse, append to previous list.
425 "Visit the source for the error message point is on.
426 Use this command in a compilation log buffer.
427 C-u as a prefix arg means to reparse the buffer's error messages first;
428 other kinds of prefix arguments are ignored."
436 ;; Move compilation-error-list to the elt of
437 ;; compilation-old-error-list whose car is the error we want.
441 compilation-old-error-list))
443 ;; This line doesn't contain an error.
444 ;; Move forward a line and look again.
446 elt)
447 compilation-old-error-list)))
448 ;; Move to another window, so that next-error's window changes
449 ;; result in the desired setup.
457 ;; Return a compilation buffer.
458 ;; If the current buffer is a compilation buffer, return it.
459 ;; If compilation-last-buffer is set to a live buffer, use that.
460 ;; Otherwise, look for a compilation buffer and signal an error
461 ;; if there are none.
465 ;; The current buffer is a compilation buffer.
470 compilation-last-buffer
480 ;; The current buffer is a compilation buffer.
487 ;;;###autoload
489 "Visit next compilation error message and corresponding source code.
491 If all preparsed error messages have been processed,
492 the error message buffer is checked for new ones.
494 A prefix arg specifies how many error messages to move;
495 negative means move back to previous error messages.
496 Just C-u as a prefix means reparse the error message buffer
497 and start at the first error.
500 but as long as you are in the middle of parsing errors from one compilation
501 output buffer, you stay with that compilation output buffer.
504 processing errors from that compilation.
506 See variables `compilation-parse-errors-function' and
507 \`compilation-error-regexp-alist' for customization ideas."
511 ;; Make ARGP nil if the prefix arg was just C-u,
512 ;; since that means to reparse the errors, which the
513 ;; compile-reinitialize-errors call just did.
514 ;; Now we are only interested in a numeric prefix arg.
524 compilation-old-error-list)
543 ;; This error is boring. Go to the next.
544 t
546 ;; This error has a filename/lineno pair.
547 ;; Find the file and turn it into a marker.
553 ;; We can't find this error's file.
554 ;; Remove all errors in the same file.
560 fileinfo)
565 ;; Look for the next error.
566 t)
567 ;; We found the file. Get a marker for this error.
577 ;; Make all the other error messages referring
578 ;; to the same file have markers into the buffer.
584 last-line)))
588 nil 'end
591 nil 'end
592 lines))
597 ;; If we didn't get a marker for this error,
598 ;; go on to the next one.
603 ;; Skip over multiple error messages for the same source location,
604 ;; so the next C-x ` won't go to an error in the same place.
609 ;; We now have a marker for the position of the error.
612 ;; If narrowing got in the way of
613 ;; going to the right place, widen.
619 ;; Show compilation buffer in other window, scrolled to this error.
625 ;;;###autoload
628 ;; Find a buffer for file FILENAME.
629 ;; Search the directories in compilation-search-path.
630 ;; A nil in compilation-search-path means to try the
631 ;; current directory, which is passed in DIR.
632 ;; If FILENAME is not found at all, ask the user where to find it.
633 ;; Pop up the buffer containing MARKER and scroll to MARKER if we ask the user.
636 result name)
643 ;; The file doesn't exist.
644 ;; Ask the user where to find it.
645 ;; If he hits C-g, then the next time he does
646 ;; next-error, he'll skip past it.
662 ;; Set compilation-error-list to nil, and unchain the markers that point to the
663 ;; error messages and their text, so that they no longer slow down gap motion.
664 ;; This would happen anyway at the next garbage collection, but it is better to
665 ;; do it the right away.
683 c)
688 ;; Find the end of this [...].
698 ;; We found the end of a grouping,
699 ;; so bump our counter.
701 groupings))
704 "Parse the current buffer as grep, cc or lint error messages.
705 See variable `compilation-parse-errors-function' for the interface it uses."
709 regexp enter-group leave-group error-group
710 alist subexpr error-regexp-groups)
712 ;; Don't reparse messages already seen at last parse.
714 ;; Don't parse the first two lines as error messages.
715 ;; This matters for grep.
719 ;; Compile all the regexps we want to search for into one.
725 compilation-error-regexp-alist
728 ;; Find out how many \(...\) groupings are in each of the regexps, and set
729 ;; *-GROUP to the grouping containing each constituent regexp (whose
730 ;; subgroups will come immediately thereafter) of the big regexp we have
731 ;; just constructed.
733 leave-group (+ enter-group
735 compilation-enter-directory-regexp)
737 error-group (+ leave-group
739 compilation-leave-directory-regexp)
742 ;; Compile an alist (IDX FILE LINE), where IDX is the number of the
743 ;; subexpression for an entire error-regexp, and FILE and LINE are the
744 ;; numbers for the subexpressions giving the file name and line number.
751 error-regexp-groups))
756 ;; Figure out which constituent regexp matched.
758 ;; The match was the enter-directory regexp.
770 ;; The match was the leave-directory regexp.
787 ))
790 ;; The match was the composite error regexp.
791 ;; Find out which individual regexp matched.
800 ;; Extract the file name and line number from the error message.
812 ;; Locate the erring file and line.
813 ;; Cons a new elt onto compilation-error-list,
814 ;; giving a marker for the current compilation buffer
815 ;; location, and the file and line number of the error.
821 compilation-error-list)))))
832 ;;; compile.el ends here