code.delx.au - gnu-emacs/blob - lisp/progmodes/compile.el

   1 ;;; compile.el --- run compiler as inferior of Emacs, parse error messages.
   2
   3 ;; Copyright (C) 1985, 86, 87, 93, 94, 95, 96, 1997 Free Software Foundation, Inc.
   4
   5 ;; Author: Roland McGrath <roland@prep.ai.mit.edu>
   6 ;; Maintainer: FSF
   7 ;; Keywords: tools, processes
   8
   9 ;; This file is part of GNU Emacs.
  10
  11 ;; GNU Emacs is free software; you can redistribute it and/or modify
  12 ;; it under the terms of the GNU General Public License as published by
  13 ;; the Free Software Foundation; either version 2, or (at your option)
  14 ;; any later version.
  15
  16 ;; GNU Emacs is distributed in the hope that it will be useful,
  17 ;; but WITHOUT ANY WARRANTY; without even the implied warranty of
  18 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19 ;; GNU General Public License for more details.
  20
  21 ;; You should have received a copy of the GNU General Public License
  22 ;; along with GNU Emacs; see the file COPYING.  If not, write to the
  23 ;; Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  24 ;; Boston, MA 02111-1307, USA.
  25
  26 ;;; Commentary:
  27
  28 ;; This package provides the compile and grep facilities documented in
  29 ;; the Emacs user's manual.
  30
  31 ;;; Code:
  32
  33 ;;;###autoload
  34 (defvar compilation-mode-hook nil
  35   "*List of hook functions run by `compilation-mode' (see `run-hooks').")
  36
  37 ;;;###autoload
  38 (defvar compilation-window-height nil
  39   "*Number of lines in a compilation window.  If nil, use Emacs default.")
  40
  41 (defvar compile-auto-highlight nil
  42   "*Specify how many compiler errors to highlight (and parse) initially.
  43 \(Highlighting applies to ean error message when the mouse is over it.)
  44 If this is a number N, all compiler error messages in the first N lines
  45 are highlighted and parsed as soon as they arrive in Emacs.
  46 If t, highlight and parse the whole compilation output as soon as it arrives.
  47 If nil, don't highlight or parse any of the buffer until you try to
  48 move to the error messages.
  49
  50 Those messages which are not parsed and highlighted initially
  51 will be parsed and highlighted as soon as you try to move to them.")
  52
  53 (defvar compilation-error-list nil
  54   "List of error message descriptors for visiting erring functions.
  55 Each error descriptor is a cons (or nil).  Its car is a marker pointing to
  56 an error message.  If its cdr is a marker, it points to the text of the
  57 line the message is about.  If its cdr is a cons, it is a list
  58 \(\(DIRECTORY . FILE\) LINE [COLUMN]\).  Or its cdr may be nil if that
  59 error is not interesting.
  60
  61 The value may be t instead of a list; this means that the buffer of
  62 error messages should be reparsed the next time the list of errors is wanted.
  63
  64 Some other commands (like `diff') use this list to control the error
  65 message tracking facilities; if you change its structure, you should make
  66 sure you also change those packages.  Perhaps it is better not to change
  67 it at all.")
  68
  69 (defvar compilation-old-error-list nil
  70   "Value of `compilation-error-list' after errors were parsed.")
  71
  72 (defvar compilation-parse-errors-function 'compilation-parse-errors
  73   "Function to call to parse error messages from a compilation.
  74 It takes args LIMIT-SEARCH and FIND-AT-LEAST.
  75 If LIMIT-SEARCH is non-nil, don't bother parsing past that location.
  76 If FIND-AT-LEAST is non-nil, don't bother parsing after finding that
  77 many new errors.
  78 It should read in the source files which have errors and set
  79 `compilation-error-list' to a list with an element for each error message
  80 found.  See that variable for more info.")
  81
  82 ;;;###autoload
  83 (defvar compilation-process-setup-function nil
  84   "*Function to call to customize the compilation process.
  85 This functions is called immediately before the compilation process is
  86 started.  It can be used to set any variables or functions that are used
  87 while processing the output of the compilation process.")
  88
  89 ;;;###autoload
  90 (defvar compilation-buffer-name-function nil
  91   "Function to compute the name of a compilation buffer.
  92 The function receives one argument, the name of the major mode of the
  93 compilation buffer.  It should return a string.
  94 nil means compute the name with `(concat \"*\" (downcase major-mode) \"*\")'.")
  95
  96 ;;;###autoload
  97 (defvar compilation-finish-function nil
  98   "*Function to call when a compilation process finishes.
  99 It is called with two arguments: the compilation buffer, and a string
 100 describing how the process finished.")
 101
 102 ;;;###autoload
 103 (defvar compilation-finish-functions nil
 104   "*Functions to call when a compilation process finishes.
 105 Each function is called with two arguments: the compilation buffer,
 106 and a string describing how the process finished.")
 107
 108 (defvar compilation-last-buffer nil
 109   "The most recent compilation buffer.
 110 A buffer becomes most recent when its compilation is started
 111 or when it is used with \\[next-error] or \\[compile-goto-error].")
 112
 113 (defvar compilation-in-progress nil
 114   "List of compilation processes now running.")
 115 (or (assq 'compilation-in-progress minor-mode-alist)
 116     (setq minor-mode-alist (cons '(compilation-in-progress " Compiling")
 117                                  minor-mode-alist)))
 118
 119 (defvar compilation-parsing-end nil
 120   "Position of end of buffer when last error messages were parsed.")
 121
 122 (defvar compilation-error-message "No more errors"
 123   "Message to print when no more matches are found.")
 124
 125 (defvar compilation-num-errors-found)
 126
 127 (defvar compilation-error-regexp-alist
 128   '(
 129     ;; NOTE!  See also grep-regexp-alist, below.
 130
 131     ;; 4.3BSD grep, cc, lint pass 1:
 132     ;;  /usr/src/foo/foo.c(8): warning: w may be used before set
 133     ;; or GNU utilities:
 134     ;;  foo.c:8: error message
 135     ;; or HP-UX 7.0 fc:
 136     ;;  foo.f          :16    some horrible error message
 137     ;; or GNU utilities with column (GNAT 1.82):
 138     ;;   foo.adb:2:1: Unit name does not match file name
 139     ;;
 140     ;; We'll insist that the number be followed by a colon or closing
 141     ;; paren, because otherwise this matches just about anything
 142     ;; containing a number with spaces around it.
 143     ("\
 144 \\([a-zA-Z]?:?[^:( \t\n]+\\)[:(][ \t]*\\([0-9]+\\)\\([) \t]\\|\
 145 :\\([^0-9\n]\\|\\([0-9]+:\\)\\)\\)" 1 2 5)
 146
 147     ;; Microsoft C/C++:
 148     ;;  keyboard.c(537) : warning C4005: 'min' : macro redefinition
 149     ;;  d:\tmp\test.c(23) : error C2143: syntax error : missing ';' before 'if'
 150     ("\\(\\([a-zA-Z]:\\)?[^:( \t\n-]+\\)[:(][ \t]*\\([0-9]+\\)[:) \t]" 1 3)
 151
 152     ;; Borland C++:
 153     ;;  Error ping.c 15: Unable to open include file 'sys/types.h'
 154     ;;  Warning ping.c 68: Call to function 'func' with no prototype
 155     ("\\(Error\\|Warning\\) \\([a-zA-Z]?:?[^:( \t\n]+\\)\
 156  \\([0-9]+\\)\\([) \t]\\|:[^0-9\n]\\)" 2 3)
 157
 158     ;; 4.3BSD lint pass 2
 159     ;;  strcmp: variable # of args. llib-lc(359)  ::  /usr/src/foo/foo.c(8)
 160     (".*[ \t:]\\([a-zA-Z]?:?[^:( \t\n]+\\)[:(](+[ \t]*\\([0-9]+\\))[:) \t]*$"
 161      1 2)
 162
 163     ;; 4.3BSD lint pass 3
 164     ;;  bloofle defined( /users/wolfgang/foo.c(4) ), but never used
 165     ;; This used to be
 166     ;; ("[ \t(]+\\([a-zA-Z]?:?[^:( \t\n]+\\)[:( \t]+\\([0-9]+\\)[:) \t]+" 1 2)
 167     ;; which is regexp Impressionism - it matches almost anything!
 168     (".*([ \t]*\\([a-zA-Z]?:?[^:( \t\n]+\\)[:(][ \t]*\\([0-9]+\\))" 1 2)
 169
 170     ;; MIPS lint pass<n>; looks good for SunPro lint also
 171     ;;  TrimMask (255) in solomon.c may be indistinguishable from TrimMasks (93) in solomon.c due to truncation
 172     ("[^\n ]+ (\\([0-9]+\\)) in \\([^ \n]+\\)" 2 1)
 173     ;;  name defined but never used: LinInt in cmap_calc.c(199)
 174     (".*in \\([^(\n]+\\)(\\([0-9]+\\))$" 1 2)
 175
 176     ;; Ultrix 3.0 f77:
 177     ;;  fort: Severe: addstf.f, line 82: Missing operator or delimiter symbol
 178     ;; Some SGI cc version:
 179     ;;  cfe: Warning 835: foo.c, line 2: something
 180     ("\\(cfe\\|fort\\): [^:\n]*: \\([^ \n]*\\), line \\([0-9]+\\):" 2 3)
 181     ;;  Error on line 3 of t.f: Execution error unclassifiable statement
 182     ;; Unknown who does this:
 183     ;;  Line 45 of "foo.c": bloofle undefined
 184     ;; Absoft FORTRAN 77 Compiler 3.1.3
 185     ;;  error on line 19 of fplot.f: spelling error?
 186     ;;  warning on line 17 of fplot.f: data type is undefined for variable d
 187     ("\\(\\|.* on \\)[Ll]ine[ \t]+\\([0-9]+\\)[ \t]+\
 188 of[ \t]+\"?\\([a-zA-Z]?:?[^\":\n]+\\)\"?:" 3 2)
 189
 190     ;; Apollo cc, 4.3BSD fc:
 191     ;;  "foo.f", line 3: Error: syntax error near end of statement
 192     ;; IBM RS6000:
 193     ;;  "vvouch.c", line 19.5: 1506-046 (S) Syntax error.
 194     ;; Unknown compiler:
 195     ;;  File "foobar.ml", lines 5-8, characters 20-155: blah blah
 196     ;; Microtec mcc68k:
 197     ;;  "foo.c", line 32 pos 1; (E) syntax error; unexpected symbol: "lossage"
 198     ;; GNAT (as of July 94):
 199     ;;  "foo.adb", line 2(11): warning: file name does not match ...
 200     ;; IBM AIX xlc compiler:
 201     ;;  "src/swapping.c", line 30.34: 1506-342 (W) "/*" detected in comment.
 202     (".*\"\\([^,\" \n\t]+\\)\", lines? \
 203 \\([0-9]+\\)\\([\(.]\\([0-9]+\\)\)?\\)?[:., (-]" 1 2 4)
 204
 205     ;; MIPS RISC CC - the one distributed with Ultrix:
 206     ;;  ccom: Error: foo.c, line 2: syntax error
 207     ;; DEC AXP OSF/1 cc
 208     ;;  /usr/lib/cmplrs/cc/cfe: Error: foo.c: 1: blah blah
 209     (".*rror: \\([^,\" \n\t]+\\)[,:] \\(line \\)?\\([0-9]+\\):" 1 3)
 210
 211     ;; IBM AIX PS/2 C version 1.1:
 212     ;;  ****** Error number 140 in line 8 of file errors.c ******
 213     (".*in line \\([0-9]+\\) of file \\([^ \n]+[^. \n]\\)\\.? " 2 1)
 214     ;; IBM AIX lint is too painful to do right this way.  File name
 215     ;; prefixes entire sections rather than being on each line.
 216
 217     ;; Lucid Compiler, lcc 3.x
 218     ;; E, file.cc(35,52) Illegal operation on pointers
 219     ("[EW], \\([^(\n]*\\)(\\([0-9]+\\),[ \t]*\\([0-9]+\\)" 1 2 3)
 220
 221     ;; GNU messages with program name and optional column number.
 222     ("[a-zA-Z]?:?[^0-9 \n\t:]+[^ \n\t:]*:[ \t]*\\([^ \n\t:]+\\):\
 223 \\([0-9]+\\):\\(\\([0-9]+\\)[: \t]\\)?" 1 2 4)
 224
 225     ;; Cray C compiler error messages
 226     ("\\(cc\\| cft\\)-[0-9]+ c\\(c\\|f77\\): ERROR \\([^,\n]+, \\)* File = \\([^,\n]+\\), Line = \\([0-9]+\\)" 4 5)
 227
 228     ;; IBM C/C++ Tools 2.01:
 229     ;;  foo.c(2:0) : informational EDC0804: Function foo is not referenced.
 230     ;;  foo.c(3:8) : warning EDC0833: Implicit return statement encountered.
 231     ;;  foo.c(5:5) : error EDC0350: Syntax error.
 232     ("\\([^( \n\t]+\\)(\\([0-9]+\\):\\([0-9]+\\)) : " 1 2 3)
 233
 234     ;; Sun ada (VADS, Solaris):
 235     ;;  /home3/xdhar/rcds_rc/main.a, line 361, char 6:syntax error: "," inserted
 236     ("\\([^, \n\t]+\\), line \\([0-9]+\\), char \\([0-9]+\\)[:., \(-]" 1 2 3)
 237     )
 238   "Alist that specifies how to match errors in compiler output.
 239 Each elt has the form (REGEXP FILE-IDX LINE-IDX [COLUMN-IDX FILE-FORMAT...])
 240 If REGEXP matches, the FILE-IDX'th subexpression gives the file name, and
 241 the LINE-IDX'th subexpression gives the line number.  If COLUMN-IDX is
 242 given, the COLUMN-IDX'th subexpression gives the column number on that line.
 243 If any FILE-FORMAT is given, each is a format string to produce a file name to
 244 try; %s in the string is replaced by the text matching the FILE-IDX'th
 245 subexpression.")
 246
 247 (defvar compilation-read-command t
 248   "If not nil, M-x compile reads the compilation command to use.
 249 Otherwise, M-x compile just uses the value of `compile-command'.")
 250
 251 (defvar compilation-ask-about-save t
 252   "If not nil, M-x compile asks which buffers to save before compiling.
 253 Otherwise, it saves all modified buffers without asking.")
 254
 255 (defvar grep-regexp-alist
 256   '(("^\\([a-zA-Z]?:?[^:( \t\n]+\\)[:( \t]+\\([0-9]+\\)[:) \t]" 1 2))
 257   "Regexp used to match grep hits.  See `compilation-error-regexp-alist'.")
 258
 259 ;; The system null device. (Should reference NULL_DEVICE from C.)
 260 (defvar grep-null-device "/dev/null" "The system null device.")
 261
 262 ;; Use zgrep if available, to work nicely with compressed files.
 263 ;; Otherwise, use ordinary grep.
 264 (defvar grep-program
 265   (if (equal (condition-case nil        ; in case "zgrep" isn't in exec-path
 266                  (call-process "zgrep" nil nil nil
 267                                "foo" grep-null-device)
 268                (error nil))
 269              1)
 270       "zgrep"
 271     "grep")
 272   "The default grep program for `grep-command' and `grep-find-command'.")
 273
 274 ;; Use -e if grep supports it,
 275 ;; because that avoids lossage if the pattern starts with `-'.
 276 (defvar grep-command
 277   (if (equal (condition-case nil        ; in case "grep" isn't in exec-path
 278                  (call-process grep-program nil nil nil
 279                                "-e" "foo" grep-null-device)
 280                (error nil))
 281              1)
 282       (format "%s -n -e " grep-program)
 283     (format "%s -n " grep-program))
 284   "The default grep command for \\[grep].")
 285
 286 (defvar grep-find-use-xargs
 287   (if (equal (call-process "find" nil nil nil
 288                            grep-null-device "-print0")
 289              0)
 290       'gnu)
 291   "Whether \\[grep-find] uses the `xargs' utility by default.
 292
 293 If nil, it uses `grep -exec'; if `gnu', it uses `find -print0' and `xargs -0';
 294 if not nil and not `gnu', it uses `find -print' and `xargs'.
 295
 296 This variable's value takes effect when `compile.el' is loaded
 297 by influencing the default value for the variable `grep-find-command'.")
 298
 299 (defvar grep-find-command
 300   (cond ((eq grep-find-use-xargs 'gnu)
 301          (format "find . -type f -print0 | xargs -0 -e %s" grep-command))
 302         (grep-find-use-xargs
 303          (format "find . -type f -print | xargs %s" grep-command))
 304         (t (cons (format "find . -type f -exec %s {} /dev/null \\;"
 305                          grep-command)
 306                  (+ 22 (length grep-command)))))
 307   "The default find command for \\[grep-find].")
 308
 309 ;;;###autoload
 310 (defvar compilation-search-path '(nil)
 311   "*List of directories to search for source files named in error messages.
 312 Elements should be directory names, not file names of directories.
 313 nil as an element means to try the default directory.")
 314
 315 (defvar compile-command "make -k "
 316   "Last shell command used to do a compilation; default for next compilation.
 317
 318 Sometimes it is useful for files to supply local values for this variable.
 319 You might also use mode hooks to specify it in certain modes, like this:
 320
 321     (setq c-mode-hook
 322       '(lambda () (or (file-exists-p \"makefile\") (file-exists-p \"Makefile\")
 323                       (progn (make-local-variable 'compile-command)
 324                              (setq compile-command
 325                                     (concat \"make -k \"
 326                                             buffer-file-name))))))")
 327
 328 (defvar compilation-enter-directory-regexp
 329   ".*: Entering directory `\\(.*\\)'$"
 330   "Regular expression matching lines that indicate a new current directory.
 331 This must contain one \\(, \\) pair around the directory name.
 332
 333 The default value matches lines printed by the `-w' option of GNU Make.")
 334
 335 (defvar compilation-leave-directory-regexp
 336   ".*: Leaving directory `\\(.*\\)'$"
 337   "Regular expression matching lines that indicate restoring current directory.
 338 This may contain one \\(, \\) pair around the name of the directory
 339 being moved from.  If it does not, the last directory entered \(by a
 340 line matching `compilation-enter-directory-regexp'\) is assumed.
 341
 342 The default value matches lines printed by the `-w' option of GNU Make.")
 343
 344 (defvar compilation-directory-stack nil
 345   "Stack of previous directories for `compilation-leave-directory-regexp'.
 346 The head element is the directory the compilation was started in.")
 347
 348 (defvar compilation-exit-message-function nil "\
 349 If non-nil, called when a compilation process dies to return a status message.
 350 This should be a function of three arguments: process status, exit status,
 351 and exit message; it returns a cons (MESSAGE . MODELINE) of the strings to
 352 write into the compilation buffer, and to put in its mode line.")
 353
 354 ;; History of compile commands.
 355 (defvar compile-history nil)
 356 ;; History of grep commands.
 357 (defvar grep-history nil)
 358 (defvar grep-find-history nil)
 359
 360 (defun compilation-mode-font-lock-keywords ()
 361   "Return expressions to highlight in Compilation mode."
 362   (nconc
 363    ;;
 364    ;; Compiler warning/error lines.
 365    (mapcar #'(lambda (item)
 366                (list (nth 0 item)
 367                      (list (nth 1 item) 'font-lock-warning-face nil t)
 368                      (list (nth 2 item) 'font-lock-variable-name-face nil t)))
 369            compilation-error-regexp-alist)
 370    (list
 371     ;;
 372     ;; Compiler output lines.  Recognise `make[n]:' lines too.
 373     '("^\\([A-Za-z_0-9/\.+-]+\\)\\(\\[\\([0-9]+\\)\\]\\)?[ \t]*:"
 374       (1 font-lock-function-name-face) (3 font-lock-comment-face nil t)))
 375    ))
 376 \f
 377 ;;;###autoload
 378 (defun compile (command)
 379   "Compile the program including the current buffer.  Default: run `make'.
 380 Runs COMMAND, a shell command, in a separate process asynchronously
 381 with output going to the buffer `*compilation*'.
 382
 383 You can then use the command \\[next-error] to find the next error message
 384 and move to the source code that caused it.
 385
 386 Interactively, prompts for the command if `compilation-read-command' is
 387 non-nil; otherwise uses `compile-command'.  With prefix arg, always prompts.
 388
 389 To run more than one compilation at once, start one and rename the
 390 \`*compilation*' buffer to some other name with \\[rename-buffer].
 391 Then start the next one.
 392
 393 The name used for the buffer is actually whatever is returned by
 394 the function in `compilation-buffer-name-function', so you can set that
 395 to a function that generates a unique name."
 396   (interactive
 397    (if (or compilation-read-command current-prefix-arg)
 398        (list (read-from-minibuffer "Compile command: "
 399                                  compile-command nil nil
 400                                  '(compile-history . 1)))
 401      (list compile-command)))
 402   (setq compile-command command)
 403   (save-some-buffers (not compilation-ask-about-save) nil)
 404   (compile-internal compile-command "No more errors"))
 405
 406 ;;; run compile with the default command line
 407 (defun recompile ()
 408   "Re-compile the program including the current buffer."
 409   (interactive)
 410   (save-some-buffers (not compilation-ask-about-save) nil)
 411   (compile-internal compile-command "No more errors"))
 412
 413 (defun grep-process-setup ()
 414   "Set up `compilation-exit-message-function' for `grep'."
 415   (set (make-local-variable 'compilation-exit-message-function)
 416        (lambda (status code msg)
 417          (if (eq status 'exit)
 418              (cond ((zerop code)
 419                     '("finished (matches found)\n" . "matched"))
 420                    ((= code 1)
 421                     '("finished with no matches found\n" . "no match"))
 422                    (t
 423                     (cons msg code)))
 424            (cons msg code)))))
 425
 426 ;;;###autoload
 427 (defun grep (command-args)
 428   "Run grep, with user-specified args, and collect output in a buffer.
 429 While grep runs asynchronously, you can use the \\[next-error] command
 430 to find the text that grep hits refer to.
 431
 432 This command uses a special history list for its arguments, so you can
 433 easily repeat a grep command."
 434   (interactive
 435    (list (read-from-minibuffer "Run grep (like this): "
 436                                grep-command nil nil 'grep-history)))
 437   ;; Setting process-setup-function makes exit-message-function work
 438   ;; even when async processes aren't supported.
 439   (let* ((compilation-process-setup-function 'grep-process-setup)
 440          (buf (compile-internal (if grep-null-device
 441                                     (concat command-args " " grep-null-device)
 442                                   command-args)
 443                                 "No more grep hits" "grep"
 444                                 ;; Give it a simpler regexp to match.
 445                                 nil grep-regexp-alist)))))
 446
 447
 448 ;;;###autoload
 449 (defun grep-find (command-args)
 450   "Run grep via find, with user-specified args, and collect output in a buffer.
 451 While find runs asynchronously, you can use the \\[next-error] command
 452 to find the text that grep hits refer to.
 453
 454 This command uses a special history list for its arguments, so you can
 455 easily repeat a find command."
 456   (interactive
 457    (list (read-from-minibuffer "Run find (like this): "
 458                                grep-find-command nil nil 'grep-find-history)))
 459   (let ((grep-null-device nil))         ; see grep
 460     (grep command-args)))
 461
 462 (defun compile-internal (command error-message
 463                                  &optional name-of-mode parser regexp-alist
 464                                  name-function)
 465   "Run compilation command COMMAND (low level interface).
 466 ERROR-MESSAGE is a string to print if the user asks to see another error
 467 and there are no more errors.  Third argument NAME-OF-MODE is the name
 468 to display as the major mode in the compilation buffer.
 469
 470 Fourth arg PARSER is the error parser function (nil means the default).  Fifth
 471 arg REGEXP-ALIST is the error message regexp alist to use (nil means the
 472 default).  Sixth arg NAME-FUNCTION is a function called to name the buffer (nil
 473 means the default).  The defaults for these variables are the global values of
 474 \`compilation-parse-errors-function', `compilation-error-regexp-alist', and
 475 \`compilation-buffer-name-function', respectively.
 476
 477 Returns the compilation buffer created."
 478   (let (outbuf)
 479     (save-excursion
 480       (or name-of-mode
 481           (setq name-of-mode "Compilation"))
 482       (setq outbuf
 483             (get-buffer-create
 484              (funcall (or name-function compilation-buffer-name-function
 485                           (function (lambda (mode)
 486                                       (concat "*" (downcase mode) "*"))))
 487                       name-of-mode)))
 488       (set-buffer outbuf)
 489       (let ((comp-proc (get-buffer-process (current-buffer))))
 490         (if comp-proc
 491             (if (or (not (eq (process-status comp-proc) 'run))
 492                     (yes-or-no-p
 493                      (format "A %s process is running; kill it? "
 494                              name-of-mode)))
 495                 (condition-case ()
 496                     (progn
 497                       (interrupt-process comp-proc)
 498                       (sit-for 1)
 499                       (delete-process comp-proc))
 500                   (error nil))
 501               (error "Cannot have two processes in `%s' at once"
 502                      (buffer-name))
 503               )))
 504       ;; In case the compilation buffer is current, make sure we get the global
 505       ;; values of compilation-error-regexp-alist, etc.
 506       (kill-all-local-variables))
 507     (let ((regexp-alist (or regexp-alist compilation-error-regexp-alist))
 508           (parser (or parser compilation-parse-errors-function))
 509           (thisdir default-directory)
 510           outwin)
 511       (save-excursion
 512         ;; Clear out the compilation buffer and make it writable.
 513         ;; Change its default-directory to the directory where the compilation
 514         ;; will happen, and insert a `cd' command to indicate this.
 515         (set-buffer outbuf)
 516         (setq buffer-read-only nil)
 517         (buffer-disable-undo (current-buffer))
 518         (erase-buffer)
 519         (buffer-enable-undo (current-buffer))
 520         (setq default-directory thisdir)
 521         (insert "cd " thisdir "\n" command "\n")
 522         (set-buffer-modified-p nil))
 523       ;; If we're already in the compilation buffer, go to the end
 524       ;; of the buffer, so point will track the compilation output.
 525       (if (eq outbuf (current-buffer))
 526           (goto-char (point-max)))
 527       ;; Pop up the compilation buffer.
 528       (setq outwin (display-buffer outbuf))
 529       (save-excursion
 530         (set-buffer outbuf)
 531         (compilation-mode)
 532         ;; (setq buffer-read-only t)  ;;; Non-ergonomic.
 533         (set (make-local-variable 'compilation-parse-errors-function) parser)
 534         (set (make-local-variable 'compilation-error-message) error-message)
 535         (set (make-local-variable 'compilation-error-regexp-alist) regexp-alist)
 536         (setq default-directory thisdir
 537               compilation-directory-stack (list default-directory))
 538         (set-window-start outwin (point-min))
 539         (setq mode-name name-of-mode)
 540         (or (eq outwin (selected-window))
 541             (set-window-point outwin (point-min)))
 542         (compilation-set-window-height outwin)
 543         (if compilation-process-setup-function
 544             (funcall compilation-process-setup-function))
 545         ;; Start the compilation.
 546         (if (fboundp 'start-process)
 547             (let* ((process-environment (cons "EMACS=t" process-environment))
 548                    (proc (start-process-shell-command (downcase mode-name)
 549                                                       outbuf
 550                                                       command)))
 551               (set-process-sentinel proc 'compilation-sentinel)
 552               (set-process-filter proc 'compilation-filter)
 553               (set-marker (process-mark proc) (point) outbuf)
 554               (setq compilation-in-progress
 555                     (cons proc compilation-in-progress)))
 556           ;; No asynchronous processes available.
 557           (message "Executing `%s'..." command)
 558           ;; Fake modeline display as if `start-process' were run.
 559           (setq mode-line-process ":run")
 560           (force-mode-line-update)
 561           (sit-for 0)                   ; Force redisplay
 562           (let ((status (call-process shell-file-name nil outbuf nil "-c"
 563                                       command)))
 564             (cond ((numberp status)
 565                    (compilation-handle-exit 'exit status
 566                                             (if (zerop status)
 567                                                 "finished\n"
 568                                               (format "\
 569 exited abnormally with code %d\n"
 570                                                       status))))
 571                   ((stringp status)
 572                    (compilation-handle-exit 'signal status
 573                                             (concat status "\n")))
 574                   (t
 575                    (compilation-handle-exit 'bizarre status status))))
 576           (message "Executing `%s'...done" command))))
 577     ;; Make it so the next C-x ` will use this buffer.
 578     (setq compilation-last-buffer outbuf)))
 579
 580 ;; Set the height of WINDOW according to compilation-window-height.
 581 (defun compilation-set-window-height (window)
 582   (and compilation-window-height
 583        (= (window-width window) (frame-width (window-frame window)))
 584        ;; If window is alone in its frame, aside from a minibuffer,
 585        ;; don't change its height.
 586        (not (eq window (frame-root-window (window-frame window))))
 587        ;; This save-excursion prevents us from changing the current buffer,
 588        ;; which might not be the same as the selected window's buffer.
 589        (save-excursion
 590          (let ((w (selected-window)))
 591            (unwind-protect
 592                (progn
 593                  (select-window window)
 594                  (enlarge-window (- compilation-window-height
 595                                     (window-height))))
 596              (select-window w))))))
 597
 598 (defvar compilation-minor-mode-map
 599   (let ((map (make-sparse-keymap)))
 600     (define-key map [mouse-2] 'compile-mouse-goto-error)
 601     (define-key map "\C-c\C-c" 'compile-goto-error)
 602     (define-key map "\C-m" 'compile-goto-error)
 603     (define-key map "\C-c\C-k" 'kill-compilation)
 604     (define-key map "\M-n" 'compilation-next-error)
 605     (define-key map "\M-p" 'compilation-previous-error)
 606     (define-key map "\M-{" 'compilation-previous-file)
 607     (define-key map "\M-}" 'compilation-next-file)
 608     map)
 609   "Keymap for `compilation-minor-mode'.")
 610
 611 (defvar compilation-mode-map
 612   (let ((map (cons 'keymap compilation-minor-mode-map)))
 613     (define-key map " " 'scroll-up)
 614     (define-key map "\^?" 'scroll-down)
 615     ;; Set up the menu-bar
 616     (define-key map [menu-bar compilation-menu]
 617       (cons "Compile" (make-sparse-keymap "Compile")))
 618
 619     (define-key map [menu-bar compilation-menu compilation-mode-kill-compilation]
 620       '("Stop Compilation" . kill-compilation))
 621     (define-key map [menu-bar compilation-menu compilation-mode-separator2]
 622       '("----" . nil))
 623     (define-key map [menu-bar compilation-menu compilation-mode-first-error]
 624       '("First Error" . first-error))
 625     (define-key map [menu-bar compilation-menu compilation-mode-previous-error]
 626       '("Previous Error" . previous-error))
 627     (define-key map [menu-bar compilation-menu compilation-mode-next-error]
 628       '("Next Error" . next-error))
 629     (define-key map [menu-bar compilation-menu compilation-separator2]
 630       '("----" . nil))
 631     (define-key map [menu-bar compilation-menu compilation-mode-grep]
 632       '("Grep" . grep))
 633     (define-key map [menu-bar compilation-menu compilation-mode-recompile]
 634       '("Recompile" . recompile))
 635     (define-key map [menu-bar compilation-menu compilation-mode-compile]
 636       '("Compile..." . compile))
 637     map)
 638   "Keymap for compilation log buffers.
 639 `compilation-minor-mode-map' is a cdr of this.")
 640
 641 ;;;###autoload
 642 (defun compilation-mode ()
 643   "Major mode for compilation log buffers.
 644 \\<compilation-mode-map>To visit the source for a line-numbered error,
 645 move point to the error message line and type \\[compile-goto-error].
 646 To kill the compilation, type \\[kill-compilation].
 647
 648 Runs `compilation-mode-hook' with `run-hooks' (which see)."
 649   (interactive)
 650   (kill-all-local-variables)
 651   (use-local-map compilation-mode-map)
 652   (setq major-mode 'compilation-mode
 653         mode-name "Compilation")
 654   (compilation-setup)
 655   (set (make-local-variable 'font-lock-defaults)
 656        '(compilation-mode-font-lock-keywords t))
 657   (run-hooks 'compilation-mode-hook))
 658
 659 ;; Prepare the buffer for the compilation parsing commands to work.
 660 (defun compilation-setup ()
 661   ;; Make the buffer's mode line show process state.
 662   (setq mode-line-process '(":%s"))
 663   (set (make-local-variable 'compilation-error-list) nil)
 664   (set (make-local-variable 'compilation-old-error-list) nil)
 665   (set (make-local-variable 'compilation-parsing-end) 1)
 666   (set (make-local-variable 'compilation-directory-stack) nil)
 667   (setq compilation-last-buffer (current-buffer)))
 668
 669 (defvar compilation-minor-mode nil
 670   "Non-nil when in compilation-minor-mode.
 671 In this minor mode, all the error-parsing commands of the
 672 Compilation major mode are available.")
 673 (make-variable-buffer-local 'compilation-minor-mode)
 674
 675 (or (assq 'compilation-minor-mode minor-mode-alist)
 676     (setq minor-mode-alist (cons '(compilation-minor-mode " Compilation")
 677                                  minor-mode-alist)))
 678 (or (assq 'compilation-minor-mode minor-mode-map-alist)
 679     (setq minor-mode-map-alist (cons (cons 'compilation-minor-mode
 680                                            compilation-minor-mode-map)
 681                                      minor-mode-map-alist)))
 682
 683 ;;;###autoload
 684 (defun compilation-minor-mode (&optional arg)
 685   "Toggle compilation minor mode.
 686 With arg, turn compilation mode on if and only if arg is positive.
 687 See `compilation-mode'.
 688 Turning the mode on runs the normal hook `compilation-minor-mode-hook'."
 689   (interactive "P")
 690   (if (setq compilation-minor-mode (if (null arg)
 691                                        (null compilation-minor-mode)
 692                                      (> (prefix-numeric-value arg) 0)))
 693       (progn
 694         (compilation-setup)
 695         (run-hooks 'compilation-minor-mode-hook))))
 696
 697 ;; Write msg in the current buffer and hack its mode-line-process.
 698 (defun compilation-handle-exit (process-status exit-status msg)
 699   (let ((buffer-read-only nil)
 700         (status (if compilation-exit-message-function
 701                     (funcall compilation-exit-message-function
 702                              process-status exit-status msg)
 703                   (cons msg exit-status)))
 704         (omax (point-max))
 705         (opoint (point)))
 706     ;; Record where we put the message, so we can ignore it
 707     ;; later on.
 708     (goto-char omax)
 709     (insert ?\n mode-name " " (car status))
 710     (forward-char -1)
 711     (insert " at " (substring (current-time-string) 0 19))
 712     (forward-char 1)
 713     (setq mode-line-process (format ":%s [%s]" process-status (cdr status)))
 714     ;; Force mode line redisplay soon.
 715     (force-mode-line-update)
 716     (if (and opoint (< opoint omax))
 717         (goto-char opoint))
 718     ;; Automatically parse (and mouse-highlight) error messages:
 719     (cond ((eq compile-auto-highlight t)
 720            (compile-reinitialize-errors nil (point-max)))
 721           ((numberp compile-auto-highlight)
 722            (compile-reinitialize-errors nil
 723                                         (save-excursion
 724                                           (goto-line compile-auto-highlight)
 725                                           (point)))))
 726     (if compilation-finish-function
 727         (funcall compilation-finish-function (current-buffer) msg))
 728     (let ((functions compilation-finish-functions))
 729       (while functions
 730         (funcall (car functions) (current-buffer) msg)
 731         (setq functions (cdr functions))))))
 732
 733 ;; Called when compilation process changes state.
 734 (defun compilation-sentinel (proc msg)
 735   "Sentinel for compilation buffers."
 736   (let ((buffer (process-buffer proc)))
 737     (if (memq (process-status proc) '(signal exit))
 738         (progn
 739           (if (null (buffer-name buffer))
 740               ;; buffer killed
 741               (set-process-buffer proc nil)
 742             (let ((obuf (current-buffer)))
 743               ;; save-excursion isn't the right thing if
 744               ;; process-buffer is current-buffer
 745               (unwind-protect
 746                   (progn
 747                     ;; Write something in the compilation buffer
 748                     ;; and hack its mode line.
 749                     (set-buffer buffer)
 750                     (compilation-handle-exit (process-status proc)
 751                                              (process-exit-status proc)
 752                                              msg)
 753                     ;; Since the buffer and mode line will show that the
 754                     ;; process is dead, we can delete it now.  Otherwise it
 755                     ;; will stay around until M-x list-processes.
 756                     (delete-process proc))
 757                 (set-buffer obuf))))
 758           (setq compilation-in-progress (delq proc compilation-in-progress))
 759           ))))
 760
 761 (defun compilation-filter (proc string)
 762   "Process filter for compilation buffers.
 763 Just inserts the text, but uses `insert-before-markers'."
 764   (if (buffer-name (process-buffer proc))
 765       (save-excursion
 766         (set-buffer (process-buffer proc))
 767         (let ((buffer-read-only nil))
 768           (save-excursion
 769             (goto-char (process-mark proc))
 770             (insert-before-markers string)
 771             (run-hooks 'compilation-filter-hook)
 772             (set-marker (process-mark proc) (point)))))))
 773
 774 ;; Return the cdr of compilation-old-error-list for the error containing point.
 775 (defun compile-error-at-point ()
 776   (compile-reinitialize-errors nil (point))
 777   (let ((errors compilation-old-error-list))
 778     (while (and errors
 779                 (> (point) (car (car errors))))
 780       (setq errors (cdr errors)))
 781     errors))
 782
 783 (defsubst compilation-buffer-p (buffer)
 784   (save-excursion
 785     (set-buffer buffer)
 786     (or compilation-minor-mode (eq major-mode 'compilation-mode))))
 787
 788 (defun compilation-next-error (n)
 789   "Move point to the next error in the compilation buffer.
 790 Does NOT find the source line like \\[next-error]."
 791   (interactive "p")
 792   (or (compilation-buffer-p (current-buffer))
 793       (error "Not in a compilation buffer."))
 794   (setq compilation-last-buffer (current-buffer))
 795
 796   (let ((errors (compile-error-at-point)))
 797
 798     ;; Move to the error after the one containing point.
 799     (goto-char (car (if (< n 0)
 800                         (let ((i 0)
 801                               (e compilation-old-error-list))
 802                           ;; See how many cdrs away ERRORS is from the start.
 803                           (while (not (eq e errors))
 804                             (setq i (1+ i)
 805                                   e (cdr e)))
 806                           (if (> (- n) i)
 807                               (error "Moved back past first error")
 808                             (nth (+ i n) compilation-old-error-list)))
 809                       (let ((compilation-error-list (cdr errors)))
 810                         (compile-reinitialize-errors nil nil n)
 811                         (if compilation-error-list
 812                             (nth (1- n) compilation-error-list)
 813                           (error "Moved past last error"))))))))
 814
 815 (defun compilation-previous-error (n)
 816   "Move point to the previous error in the compilation buffer.
 817 Does NOT find the source line like \\[next-error]."
 818   (interactive "p")
 819   (compilation-next-error (- n)))
 820
 821
 822 ;; Given an elt of `compilation-error-list', return an object representing
 823 ;; the referenced file which is equal to (but not necessarily eq to) what
 824 ;; this function would return for another error in the same file.
 825 (defsubst compilation-error-filedata (data)
 826   (setq data (cdr data))
 827   (if (markerp data)
 828       (marker-buffer data)
 829     (car data)))
 830
 831 ;; Return a string describing a value from compilation-error-filedata.
 832 ;; This value is not necessarily useful as a file name, but should be
 833 ;; indicative to the user of what file's errors are being referred to.
 834 (defsubst compilation-error-filedata-file-name (filedata)
 835   (if (bufferp filedata)
 836       (buffer-file-name filedata)
 837     (car filedata)))
 838
 839 (defun compilation-next-file (n)
 840   "Move point to the next error for a different file than the current one."
 841   (interactive "p")
 842   (or (compilation-buffer-p (current-buffer))
 843       (error "Not in a compilation buffer."))
 844   (setq compilation-last-buffer (current-buffer))
 845
 846   (let ((reversed (< n 0))
 847         errors filedata)
 848
 849     (if (not reversed)
 850         (setq errors (or (compile-error-at-point)
 851                          (error "Moved past last error")))
 852
 853       ;; Get a reversed list of the errors up through the one containing point.
 854       (compile-reinitialize-errors nil (point))
 855       (setq errors (reverse compilation-old-error-list)
 856             n (- n))
 857
 858       ;; Ignore errors after point.  (car ERRORS) will be the error
 859       ;; containing point, (cadr ERRORS) the one before it.
 860       (while (and errors
 861                   (< (point) (car (car errors))))
 862         (setq errors (cdr errors))))
 863
 864     (while (> n 0)
 865       (setq filedata (compilation-error-filedata (car errors)))
 866
 867       ;; Skip past the following errors for this file.
 868       (while (equal filedata
 869                     (compilation-error-filedata
 870                      (car (or errors
 871                               (if reversed
 872                                   (error "%s the first erring file"
 873                                          (compilation-error-filedata-file-name
 874                                           filedata))
 875                                 (let ((compilation-error-list nil))
 876                                   ;; Parse some more.
 877                                   (compile-reinitialize-errors nil nil 2)
 878                                   (setq errors compilation-error-list)))
 879                               (error "%s is the last erring file"
 880                                      (compilation-error-filedata-file-name
 881                                       filedata))))))
 882         (setq errors (cdr errors)))
 883
 884       (setq n (1- n)))
 885
 886     ;; Move to the following error.
 887     (goto-char (car (car (or errors
 888                              (if reversed
 889                                  (error "This is the first erring file")
 890                                (let ((compilation-error-list nil))
 891                                  ;; Parse the last one.
 892                                  (compile-reinitialize-errors nil nil 1)
 893                                  compilation-error-list))))))))
 894
 895 (defun compilation-previous-file (n)
 896   "Move point to the previous error for a different file than the current one."
 897   (interactive "p")
 898   (compilation-next-file (- n)))
 899
 900
 901 (defun kill-compilation ()
 902   "Kill the process made by the \\[compile] command."
 903   (interactive)
 904   (let ((buffer (compilation-find-buffer)))
 905     (if (get-buffer-process buffer)
 906         (interrupt-process (get-buffer-process buffer))
 907       (error "The compilation process is not running."))))
 908
 909
 910 ;; Parse any new errors in the compilation buffer,
 911 ;; or reparse from the beginning if the user has asked for that.
 912 (defun compile-reinitialize-errors (reparse
 913                                     &optional limit-search find-at-least)
 914   (save-excursion
 915     (set-buffer compilation-last-buffer)
 916     ;; If we are out of errors, or if user says "reparse",
 917     ;; discard the info we have, to force reparsing.
 918     (if (or (eq compilation-error-list t)
 919             reparse)
 920         (compilation-forget-errors))
 921     (if (and compilation-error-list
 922              (or (not limit-search)
 923                  (> compilation-parsing-end limit-search))
 924              (or (not find-at-least)
 925                  (>= (length compilation-error-list) find-at-least)))
 926         ;; Since compilation-error-list is non-nil, it points to a specific
 927         ;; error the user wanted.  So don't move it around.
 928         nil
 929       ;; This was here for a long time (before my rewrite); why? --roland
 930       ;;(switch-to-buffer compilation-last-buffer)
 931       (set-buffer-modified-p nil)
 932       (if (< compilation-parsing-end (point-max))
 933           ;; compilation-error-list might be non-nil if we have a non-nil
 934           ;; LIMIT-SEARCH or FIND-AT-LEAST arg.  In that case its value
 935           ;; records the current position in the error list, and we must
 936           ;; preserve that after reparsing.
 937           (let ((error-list-pos compilation-error-list))
 938             (funcall compilation-parse-errors-function
 939                      limit-search
 940                      (and find-at-least
 941                           ;; We only need enough new parsed errors to reach
 942                           ;; FIND-AT-LEAST errors past the current
 943                           ;; position.
 944                           (- find-at-least (length compilation-error-list))))
 945             ;; Remember the entire list for compilation-forget-errors.  If
 946             ;; this is an incremental parse, append to previous list.  If
 947             ;; we are parsing anew, compilation-forget-errors cleared
 948             ;; compilation-old-error-list above.
 949             (setq compilation-old-error-list
 950                   (nconc compilation-old-error-list compilation-error-list))
 951             (if error-list-pos
 952                 ;; We started in the middle of an existing list of parsed
 953                 ;; errors before parsing more; restore that position.
 954                 (setq compilation-error-list error-list-pos))
 955             ;; Mouse-Highlight (the first line of) each error message when the
 956             ;; mouse pointer moves over it:
 957             (let ((inhibit-read-only t)
 958                   (error-list compilation-error-list))
 959               (while error-list
 960                 (save-excursion
 961                   (put-text-property (goto-char (car (car error-list)))
 962                                      (progn (end-of-line) (point))
 963                                      'mouse-face 'highlight))
 964                 (setq error-list (cdr error-list))))
 965             )))))
 966
 967 (defun compile-mouse-goto-error (event)
 968   (interactive "e")
 969   (save-excursion
 970     (set-buffer (window-buffer (posn-window (event-end event))))
 971     (goto-char (posn-point (event-end event)))
 972
 973     (or (compilation-buffer-p (current-buffer))
 974         (error "Not in a compilation buffer."))
 975     (setq compilation-last-buffer (current-buffer))
 976     ;; `compile-reinitialize-errors' needs to see the complete filename
 977     ;; on the line where they clicked the mouse.  Since it only looks
 978     ;; upto point, moving point to eol makes sure the filename is
 979     ;; visible to `compile-reinitialize-errors'.
 980     (end-of-line)
 981     (compile-reinitialize-errors nil (point))
 982
 983     ;; Move to bol; the marker for the error on this line will point there.
 984     (beginning-of-line)
 985
 986     ;; Move compilation-error-list to the elt of compilation-old-error-list
 987     ;; we want.
 988     (setq compilation-error-list compilation-old-error-list)
 989     (while (and compilation-error-list
 990                 (> (point) (car (car compilation-error-list))))
 991       (setq compilation-error-list (cdr compilation-error-list)))
 992     (or compilation-error-list
 993         (error "No error to go to")))
 994   (select-window (posn-window (event-end event)))
 995   ;; Move to another window, so that next-error's window changes
 996   ;; result in the desired setup.
 997   (or (one-window-p)
 998       (progn
 999         (other-window -1)
1000         ;; other-window changed the selected buffer,
1001         ;; but we didn't want to do that.
1002         (set-buffer compilation-last-buffer)))
1003
1004   (push-mark)
1005   (next-error 1))
1006
1007 (defun compile-goto-error (&optional argp)
1008   "Visit the source for the error message point is on.
1009 Use this command in a compilation log buffer.  Sets the mark at point there.
1010 \\[universal-argument] as a prefix arg means to reparse the buffer's error messages first;
1011 other kinds of prefix arguments are ignored."
1012   (interactive "P")
1013   (or (compilation-buffer-p (current-buffer))
1014       (error "Not in a compilation buffer."))
1015   (setq compilation-last-buffer (current-buffer))
1016   (compile-reinitialize-errors (consp argp) (point))
1017
1018   ;; Move to bol; the marker for the error on this line will point there.
1019   (beginning-of-line)
1020
1021   ;; Move compilation-error-list to the elt of compilation-old-error-list
1022   ;; we want.
1023   (setq compilation-error-list compilation-old-error-list)
1024   (while (and compilation-error-list
1025               (> (point) (car (car compilation-error-list))))
1026     (setq compilation-error-list (cdr compilation-error-list)))
1027
1028   ;; Move to another window, so that next-error's window changes
1029   ;; result in the desired setup.
1030   (or (one-window-p)
1031       (progn
1032         (other-window -1)
1033         ;; other-window changed the selected buffer,
1034         ;; but we didn't want to do that.
1035         (set-buffer compilation-last-buffer)))
1036
1037   (push-mark)
1038   (next-error 1))
1039
1040 ;; Return a compilation buffer.
1041 ;; If the current buffer is a compilation buffer, return it.
1042 ;; If compilation-last-buffer is set to a live buffer, use that.
1043 ;; Otherwise, look for a compilation buffer and signal an error
1044 ;; if there are none.
1045 (defun compilation-find-buffer (&optional other-buffer)
1046   (if (and (not other-buffer)
1047            (compilation-buffer-p (current-buffer)))
1048       ;; The current buffer is a compilation buffer.
1049       (current-buffer)
1050     (if (and compilation-last-buffer (buffer-name compilation-last-buffer)
1051              (compilation-buffer-p compilation-last-buffer)
1052              (or (not other-buffer) (not (eq compilation-last-buffer
1053                                              (current-buffer)))))
1054         compilation-last-buffer
1055       (let ((buffers (buffer-list)))
1056         (while (and buffers (or (not (compilation-buffer-p (car buffers)))
1057                                 (and other-buffer
1058                                      (eq (car buffers) (current-buffer)))))
1059           (setq buffers (cdr buffers)))
1060         (if buffers
1061             (car buffers)
1062           (or (and other-buffer
1063                    (compilation-buffer-p (current-buffer))
1064                    ;; The current buffer is a compilation buffer.
1065                    (progn
1066                      (if other-buffer
1067                          (message "This is the only compilation buffer."))
1068                      (current-buffer)))
1069               (error "No compilation started!")))))))
1070
1071 ;;;###autoload
1072 (defun next-error (&optional argp)
1073   "Visit next compilation error message and corresponding source code.
1074 This operates on the output from the \\[compile] command.
1075 If all preparsed error messages have been processed,
1076 the error message buffer is checked for new ones.
1077
1078 A prefix arg specifies how many error messages to move;
1079 negative means move back to previous error messages.
1080 Just C-u as a prefix means reparse the error message buffer
1081 and start at the first error.
1082
1083 \\[next-error] normally applies to the most recent compilation started,
1084 but as long as you are in the middle of parsing errors from one compilation
1085 output buffer, you stay with that compilation output buffer.
1086
1087 Use \\[next-error] in a compilation output buffer to switch to
1088 processing errors from that compilation.
1089
1090 See variables `compilation-parse-errors-function' and
1091 \`compilation-error-regexp-alist' for customization ideas."
1092   (interactive "P")
1093   (setq compilation-last-buffer (compilation-find-buffer))
1094   (compilation-goto-locus (compilation-next-error-locus
1095                            ;; We want to pass a number here only if
1096                            ;; we got a numeric prefix arg, not just C-u.
1097                            (and (not (consp argp))
1098                                 (prefix-numeric-value argp))
1099                            (consp argp))))
1100 ;;;###autoload (define-key ctl-x-map "`" 'next-error)
1101
1102 (defun previous-error ()
1103   "Visit previous compilation error message and corresponding source code.
1104 This operates on the output from the \\[compile] command."
1105   (interactive)
1106   (next-error -1))
1107
1108 (defun first-error ()
1109   "Reparse the error message buffer and start at the first error.
1110 Visit corresponding source code.
1111 This operates on the output from the \\[compile] command."
1112   (interactive)
1113   (next-error '(4)))
1114
1115 (defvar compilation-skip-to-next-location nil
1116   "*If non-nil, skip multiple error messages for the same source location.")
1117
1118 (defun compilation-next-error-locus (&optional move reparse silent)
1119   "Visit next compilation error and return locus in corresponding source code.
1120 This operates on the output from the \\[compile] command.
1121 If all preparsed error messages have been processed,
1122 the error message buffer is checked for new ones.
1123
1124 Returns a cons (ERROR . SOURCE) of two markers: ERROR is a marker at the
1125 location of the error message in the compilation buffer, and SOURCE is a
1126 marker at the location in the source code indicated by the error message.
1127
1128 Optional first arg MOVE says how many error messages to move forwards (or
1129 backwards, if negative); default is 1.  Optional second arg REPARSE, if
1130 non-nil, says to reparse the error message buffer and reset to the first
1131 error (plus MOVE - 1).  If optional third argument SILENT is non-nil, return
1132 nil instead of raising an error if there are no more errors.
1133
1134 The current buffer should be the desired compilation output buffer."
1135   (or move (setq move 1))
1136   (compile-reinitialize-errors reparse nil (and (not reparse)
1137                                                 (if (< move 1) 0 (1- move))))
1138   (let (next-errors next-error)
1139     (catch 'no-next-error
1140       (save-excursion
1141         (set-buffer compilation-last-buffer)
1142         ;; compilation-error-list points to the "current" error.
1143         (setq next-errors
1144               (if (> move 0)
1145                   (nthcdr (1- move)
1146                           compilation-error-list)
1147                 ;; Zero or negative arg; we need to move back in the list.
1148                 (let ((n (1- move))
1149                       (i 0)
1150                       (e compilation-old-error-list))
1151                   ;; See how many cdrs away the current error is from the start.
1152                   (while (not (eq e compilation-error-list))
1153                     (setq i (1+ i)
1154                           e (cdr e)))
1155                   (if (> (- n) i)
1156                       (error "Moved back past first error")
1157                     (nthcdr (+ i n) compilation-old-error-list))))
1158               next-error (car next-errors))
1159         (while
1160             (if (null next-error)
1161                 (progn
1162                   (and move (/= move 1)
1163                        (error (if (> move 0)
1164                                   "Moved past last error")
1165                               "Moved back past first error"))
1166                   ;; Forget existing error messages if compilation has finished.
1167                   (if (not (and (get-buffer-process (current-buffer))
1168                                 (eq (process-status
1169                                      (get-buffer-process
1170                                       (current-buffer)))
1171                                     'run)))
1172                       (compilation-forget-errors))
1173                   (if silent
1174                       (throw 'no-next-error nil)
1175                     (error (concat compilation-error-message
1176                                    (and (get-buffer-process (current-buffer))
1177                                         (eq (process-status
1178                                              (get-buffer-process
1179                                               (current-buffer)))
1180                                             'run)
1181                                         " yet")))))
1182               (setq compilation-error-list (cdr next-errors))
1183               (if (null (cdr next-error))
1184                   ;; This error is boring.  Go to the next.
1185                   t
1186                 (or (markerp (cdr next-error))
1187                     ;; This error has a filename/lineno pair.
1188                     ;; Find the file and turn it into a marker.
1189                     (let* ((fileinfo (car (cdr next-error)))
1190                            (buffer (apply 'compilation-find-file
1191                                           (car next-error) fileinfo)))
1192                       (if (null buffer)
1193                           ;; We can't find this error's file.
1194                           ;; Remove all errors in the same file.
1195                           (progn
1196                             (setq next-errors compilation-old-error-list)
1197                             (while next-errors
1198                               (and (consp (cdr (car next-errors)))
1199                                    (equal (car (cdr (car next-errors)))
1200                                           fileinfo)
1201                                    (progn
1202                                      (set-marker (car (car next-errors)) nil)
1203                                      (setcdr (car next-errors) nil)))
1204                               (setq next-errors (cdr next-errors)))
1205                             ;; Look for the next error.
1206                             t)
1207                         ;; We found the file.  Get a marker for this error.
1208                         ;; compilation-old-error-list is a buffer-local
1209                         ;; variable, so we must be careful to extract its value
1210                         ;; before switching to the source file buffer.
1211                         (let ((errors compilation-old-error-list)
1212                               (last-line (nth 1 (cdr next-error)))
1213                               (column (nth 2 (cdr next-error))))
1214                           (set-buffer buffer)
1215                           (save-excursion
1216                             (save-restriction
1217                               (widen)
1218                               (goto-line last-line)
1219                               (if (and column (> column 0))
1220                                   ;; Columns in error msgs are 1-origin.
1221                                   (move-to-column (1- column))
1222                                 (beginning-of-line))
1223                               (setcdr next-error (point-marker))
1224                               ;; Make all the other error messages referring
1225                               ;; to the same file have markers into the buffer.
1226                               (while errors
1227                                 (and (consp (cdr (car errors)))
1228                                      (equal (car (cdr (car errors))) fileinfo)
1229                                      (let* ((this (nth 1 (cdr (car errors))))
1230                                             (column (nth 2 (cdr (car errors))))
1231                                             (lines (- this last-line)))
1232                                        (if (eq selective-display t)
1233                                            ;; When selective-display is t,
1234                                            ;; each C-m is a line boundary,
1235                                            ;; as well as each newline.
1236                                            (if (< lines 0)
1237                                                (re-search-backward "[\n\C-m]"
1238                                                                    nil 'end
1239                                                                    (- lines))
1240                                              (re-search-forward "[\n\C-m]"
1241                                                                 nil 'end
1242                                                                 lines))
1243                                          (forward-line lines))
1244                                        (if (and column (> column 1))
1245                                            (move-to-column (1- column))
1246                                          (beginning-of-line))
1247                                        (setq last-line this)
1248                                        (setcdr (car errors) (point-marker))))
1249                                 (setq errors (cdr errors)))))))))
1250                 ;; If we didn't get a marker for this error, or this
1251                 ;; marker's buffer was killed, go on to the next one.
1252                 (or (not (markerp (cdr next-error)))
1253                     (not (marker-buffer (cdr next-error))))))
1254           (setq next-errors compilation-error-list
1255                 next-error (car next-errors)))))
1256
1257     (if compilation-skip-to-next-location
1258         ;; Skip over multiple error messages for the same source location,
1259         ;; so the next C-x ` won't go to an error in the same place.
1260         (while (and compilation-error-list
1261                     (equal (cdr (car compilation-error-list)) (cdr next-error)))
1262           (setq compilation-error-list (cdr compilation-error-list))))
1263
1264     ;; We now have a marker for the position of the error source code.
1265     ;; NEXT-ERROR is a cons (ERROR . SOURCE) of two markers.
1266     next-error))
1267
1268 (defun compilation-goto-locus (next-error)
1269   "Jump to an error locus returned by `compilation-next-error-locus'.
1270 Takes one argument, a cons (ERROR . SOURCE) of two markers.
1271 Selects a window with point at SOURCE, with another window displaying ERROR."
1272   (if (and (window-dedicated-p (selected-window))
1273            (eq (selected-window) (frame-root-window)))
1274       (switch-to-buffer-other-frame (marker-buffer (cdr next-error)))
1275     (switch-to-buffer (marker-buffer (cdr next-error))))
1276   (goto-char (cdr next-error))
1277   ;; If narrowing got in the way of
1278   ;; going to the right place, widen.
1279   (or (= (point) (marker-position (cdr next-error)))
1280       (progn
1281         (widen)
1282         (goto-char (cdr next-error))))
1283
1284   ;; Show compilation buffer in other window, scrolled to this error.
1285   (let* ((pop-up-windows t)
1286          ;; Use an existing window if it is in a visible frame.
1287          (w (or (get-buffer-window (marker-buffer (car next-error)) 'visible)
1288                 ;; Pop up a window.
1289                 (display-buffer (marker-buffer (car next-error))))))
1290     (set-window-point w (car next-error))
1291     (set-window-start w (car next-error))
1292     (compilation-set-window-height w)))
1293 \f
1294 ;; Find a buffer for file FILENAME.
1295 ;; Search the directories in compilation-search-path.
1296 ;; A nil in compilation-search-path means to try the
1297 ;; current directory, which is passed in DIR.
1298 ;; If FILENAME is not found at all, ask the user where to find it.
1299 ;; Pop up the buffer containing MARKER and scroll to MARKER if we ask the user.
1300 (defun compilation-find-file (marker filename dir &rest formats)
1301   (or formats (setq formats '("%s")))
1302   (let ((dirs compilation-search-path)
1303         buffer thisdir fmts name)
1304     (if (file-name-absolute-p filename)
1305         ;; The file name is absolute.  Use its explicit directory as
1306         ;; the first in the search path, and strip it from FILENAME.
1307         (setq filename (abbreviate-file-name (expand-file-name filename))
1308               dirs (cons (file-name-directory filename) dirs)
1309               filename (file-name-nondirectory filename)))
1310     ;; Now search the path.
1311     (while (and dirs (null buffer))
1312       (setq thisdir (or (car dirs) dir)
1313             fmts formats)
1314       ;; For each directory, try each format string.
1315       (while (and fmts (null buffer))
1316         (setq name (expand-file-name (format (car fmts) filename) thisdir)
1317               buffer (and (file-exists-p name)
1318                           (find-file-noselect name))
1319               fmts (cdr fmts)))
1320       (setq dirs (cdr dirs)))
1321     (or buffer
1322         ;; The file doesn't exist.
1323         ;; Ask the user where to find it.
1324         ;; If he hits C-g, then the next time he does
1325         ;; next-error, he'll skip past it.
1326         (let* ((pop-up-windows t)
1327                (w (display-buffer (marker-buffer marker))))
1328           (set-window-point w marker)
1329           (set-window-start w marker)
1330           (let ((name (expand-file-name
1331                        (read-file-name
1332                         (format "Find this error in: (default %s) "
1333                                 filename)
1334                         dir filename t))))
1335             (if (file-directory-p name)
1336                 (setq name (expand-file-name filename name)))
1337             (and (file-exists-p name)
1338                  (find-file-noselect name)))))))
1339
1340 ;; Set compilation-error-list to nil, and unchain the markers that point to the
1341 ;; error messages and their text, so that they no longer slow down gap motion.
1342 ;; This would happen anyway at the next garbage collection, but it is better to
1343 ;; do it right away.
1344 (defun compilation-forget-errors ()
1345   (while compilation-old-error-list
1346     (let ((next-error (car compilation-old-error-list)))
1347       (set-marker (car next-error) nil)
1348       (if (markerp (cdr next-error))
1349           (set-marker (cdr next-error) nil)))
1350     (setq compilation-old-error-list (cdr compilation-old-error-list)))
1351   (setq compilation-error-list nil
1352         compilation-directory-stack nil
1353         compilation-parsing-end 1)
1354   ;; Remove the highlighting added by compile-reinitialize-errors:
1355   (let ((inhibit-read-only t))
1356     (remove-text-properties (point-min) (point-max) '(mouse-face highlight)))
1357   )
1358
1359
1360 (defun count-regexp-groupings (regexp)
1361   "Return the number of \\( ... \\) groupings in REGEXP (a string)."
1362   (let ((groupings 0)
1363         (len (length regexp))
1364         (i 0)
1365         c)
1366     (while (< i len)
1367       (setq c (aref regexp i)
1368             i (1+ i))
1369       (cond ((= c ?\[)
1370              ;; Find the end of this [...].
1371              (while (and (< i len)
1372                          (not (= (aref regexp i) ?\])))
1373                (setq i (1+ i))))
1374             ((= c ?\\)
1375              (if (< i len)
1376                  (progn
1377                    (setq c (aref regexp i)
1378                          i (1+ i))
1379                    (if (= c ?\))
1380                        ;; We found the end of a grouping,
1381                        ;; so bump our counter.
1382                        (setq groupings (1+ groupings))))))))
1383     groupings))
1384
1385 (defun compilation-parse-errors (limit-search find-at-least)
1386   "Parse the current buffer as grep, cc or lint error messages.
1387 See variable `compilation-parse-errors-function' for the interface it uses."
1388   (setq compilation-error-list nil)
1389   (message "Parsing error messages...")
1390   (let (text-buffer orig orig-expanded parent-expanded
1391         regexp enter-group leave-group error-group
1392         alist subexpr error-regexp-groups
1393         (found-desired nil)
1394         (compilation-num-errors-found 0))
1395
1396     ;; Don't reparse messages already seen at last parse.
1397     (goto-char compilation-parsing-end)
1398     ;; Don't parse the first two lines as error messages.
1399     ;; This matters for grep.
1400     (if (bobp)
1401         (progn
1402           (forward-line 2)
1403           ;; Move back so point is before the newline.
1404           ;; This matters because some error regexps use \n instead of ^
1405           ;; to be faster.
1406           (forward-char -1)))
1407
1408     ;; Compile all the regexps we want to search for into one.
1409     (setq regexp (concat "\\(" compilation-enter-directory-regexp "\\)\\|"
1410                          "\\(" compilation-leave-directory-regexp "\\)\\|"
1411                          "\\(" (mapconcat (function
1412                                            (lambda (elt)
1413                                              (concat "\\(" (car elt) "\\)")))
1414                                           compilation-error-regexp-alist
1415                                           "\\|") "\\)"))
1416
1417     ;; Find out how many \(...\) groupings are in each of the regexps, and set
1418     ;; *-GROUP to the grouping containing each constituent regexp (whose
1419     ;; subgroups will come immediately thereafter) of the big regexp we have
1420     ;; just constructed.
1421     (setq enter-group 1
1422           leave-group (+ enter-group
1423                          (count-regexp-groupings
1424                           compilation-enter-directory-regexp)
1425                          1)
1426           error-group (+ leave-group
1427                          (count-regexp-groupings
1428                           compilation-leave-directory-regexp)
1429                          1))
1430
1431     ;; Compile an alist (IDX FILE LINE [COL]), where IDX is the number of
1432     ;; the subexpression for an entire error-regexp, and FILE and LINE (and
1433     ;; possibly COL) are the numbers for the subexpressions giving the file
1434     ;; name and line number (and possibly column number).
1435     (setq alist (or compilation-error-regexp-alist
1436                     (error "compilation-error-regexp-alist is empty!"))
1437           subexpr (1+ error-group))
1438     (while alist
1439       (setq error-regexp-groups
1440             (cons (list subexpr
1441                         (+ subexpr (nth 1 (car alist)))
1442                         (+ subexpr (nth 2 (car alist)))
1443                         (and (nth 3 (car alist))
1444                              (+ subexpr (nth 3 (car alist)))))
1445                   error-regexp-groups))
1446       (setq subexpr (+ subexpr 1 (count-regexp-groupings (car (car alist)))))
1447       (setq alist (cdr alist)))
1448
1449     ;; Set up now the expanded, abbreviated directory variables
1450     ;; that compile-abbreviate-directory will need, so we can
1451     ;; compute them just once here.
1452     (setq orig (abbreviate-file-name default-directory)
1453           orig-expanded (abbreviate-file-name
1454                          (file-truename default-directory))
1455           parent-expanded (abbreviate-file-name
1456                            (expand-file-name "../" orig-expanded)))
1457
1458     (while (and (not found-desired)
1459                 ;; Instead of using re-search-forward,
1460                 ;; we use this loop which tries only at each line.
1461                 (progn
1462                   (while (and (not (eobp))
1463                               (not (looking-at regexp)))
1464                     (forward-line 1))
1465                   (not (eobp))))
1466
1467       ;; Move to the end of the match we just found.
1468       (goto-char (match-end 0))
1469
1470       ;; Figure out which constituent regexp matched.
1471       (cond ((match-beginning enter-group)
1472              ;; The match was the enter-directory regexp.
1473              (let ((dir
1474                     (file-name-as-directory
1475                      (expand-file-name
1476                       (buffer-substring (match-beginning (+ enter-group 1))
1477                                         (match-end (+ enter-group 1)))))))
1478                ;; The directory name in the "entering" message
1479                ;; is a truename.  Try to convert it to a form
1480                ;; like what the user typed in.
1481                (setq dir
1482                      (compile-abbreviate-directory dir orig orig-expanded
1483                                                    parent-expanded))
1484                (setq compilation-directory-stack
1485                      (cons dir compilation-directory-stack))
1486                (and (file-directory-p dir)
1487                     (setq default-directory dir)))
1488
1489              (and limit-search (>= (point) limit-search)
1490                   ;; The user wanted a specific error, and we're past it.
1491                   ;; We do this check here (and in the leave-group case)
1492                   ;; rather than at the end of the loop because if the last
1493                   ;; thing seen is an error message, we must carefully
1494                   ;; discard the last error when it is the first in a new
1495                   ;; file (see below in the error-group case).
1496                   (setq found-desired t)))
1497
1498             ((match-beginning leave-group)
1499              ;; The match was the leave-directory regexp.
1500              (let ((beg (match-beginning (+ leave-group 1)))
1501                    (stack compilation-directory-stack))
1502                (if beg
1503                    (let ((dir
1504                           (file-name-as-directory
1505                            (expand-file-name
1506                             (buffer-substring beg
1507                                               (match-end (+ leave-group
1508                                                             1)))))))
1509                      ;; The directory name in the "leaving" message
1510                      ;; is a truename.  Try to convert it to a form
1511                      ;; like what the user typed in.
1512                      (setq dir
1513                            (compile-abbreviate-directory dir orig orig-expanded
1514                                                          parent-expanded))
1515                      (while (and stack
1516                                  (not (string-equal (car stack) dir)))
1517                        (setq stack (cdr stack)))))
1518                (setq compilation-directory-stack (cdr stack))
1519                (setq stack (car compilation-directory-stack))
1520                (if stack
1521                    (setq default-directory stack))
1522                )
1523
1524              (and limit-search (>= (point) limit-search)
1525                   ;; The user wanted a specific error, and we're past it.
1526                   ;; We do this check here (and in the enter-group case)
1527                   ;; rather than at the end of the loop because if the last
1528                   ;; thing seen is an error message, we must carefully
1529                   ;; discard the last error when it is the first in a new
1530                   ;; file (see below in the error-group case).
1531                   (setq found-desired t)))
1532
1533             ((match-beginning error-group)
1534              ;; The match was the composite error regexp.
1535              ;; Find out which individual regexp matched.
1536              (setq alist error-regexp-groups)
1537              (while (and alist
1538                          (null (match-beginning (car (car alist)))))
1539                (setq alist (cdr alist)))
1540              (if alist
1541                  (setq alist (car alist))
1542                (error "compilation-parse-errors: impossible regexp match!"))
1543
1544              ;; Extract the file name and line number from the error message.
1545              (let ((beginning-of-match (match-beginning 0)) ;looking-at nukes
1546                    (filename (buffer-substring (match-beginning (nth 1 alist))
1547                                                (match-end (nth 1 alist))))
1548                    (linenum (string-to-int
1549                              (buffer-substring
1550                               (match-beginning (nth 2 alist))
1551                               (match-end (nth 2 alist)))))
1552                    (column (and (nth 3 alist)
1553                                 (match-beginning (nth 3 alist))
1554                                 (string-to-int
1555                                  (buffer-substring
1556                                   (match-beginning (nth 3 alist))
1557                                   (match-end (nth 3 alist)))))))
1558
1559                ;; Check for a comint-file-name-prefix and prepend it if
1560                ;; appropriate.  (This is very useful for
1561                ;; compilation-minor-mode in an rlogin-mode buffer.)
1562                (and (boundp 'comint-file-name-prefix)
1563                     ;; If the file name is relative, default-directory will
1564                     ;; already contain the comint-file-name-prefix (done by
1565                     ;; compile-abbreviate-directory).
1566                     (file-name-absolute-p filename)
1567                     (setq filename (concat comint-file-name-prefix filename)))
1568
1569                ;; Some compilers (e.g. Sun's java compiler, reportedly)
1570                ;; produce bogus file names like "./bar//foo.c" for the file
1571                ;; "bar/foo.c"; expand-file-name will collapse these into
1572                ;; "/foo.c" and fail to find the appropriate file.  So we look
1573                ;; for doubled slashes in the file name and fix them up in the
1574                ;; buffer.
1575                (setq filename (command-line-normalize-file-name filename))
1576                (setq filename (cons filename (cons default-directory
1577                                                    (nthcdr 4 alist))))
1578
1579
1580                ;; Locate the erring file and line.
1581                ;; Cons a new elt onto compilation-error-list,
1582                ;; giving a marker for the current compilation buffer
1583                ;; location, and the file and line number of the error.
1584                (save-excursion
1585                  ;; Save as the start of the error the beginning of the
1586                  ;; line containing the match unless the match starts at a
1587                  ;; newline, in which case the beginning of the next line.
1588                  (goto-char beginning-of-match)
1589                  (forward-line (if (eolp) 1 0))
1590                  (let ((this (cons (point-marker)
1591                                    (list filename linenum column))))
1592                    ;; Don't add the same source line more than once.
1593                    (if (and compilation-skip-to-next-location
1594                             (equal (cdr this)
1595                                    (cdr (car compilation-error-list))))
1596                        nil
1597                      (setq compilation-error-list
1598                            (cons this
1599                                  compilation-error-list))
1600                      (setq compilation-num-errors-found
1601                            (1+ compilation-num-errors-found)))))
1602                (and (or (and find-at-least (> compilation-num-errors-found
1603                                               find-at-least))
1604                         (and limit-search (>= (point) limit-search)))
1605                     ;; We have found as many new errors as the user wants,
1606                     ;; or past the buffer position he indicated.  We
1607                     ;; continue to parse until we have seen all the
1608                     ;; consecutive errors in the same file, so the error
1609                     ;; positions will be recorded as markers in this buffer
1610                     ;; that might change.
1611                     (cdr compilation-error-list) ; Must check at least two.
1612                     (not (equal (car (cdr (nth 0 compilation-error-list)))
1613                                 (car (cdr (nth 1 compilation-error-list)))))
1614                     (progn
1615                       ;; Discard the error just parsed, so that the next
1616                       ;; parsing run can get it and the following errors in
1617                       ;; the same file all at once.  If we didn't do this, we
1618                       ;; would have the same problem we are trying to avoid
1619                       ;; with the test above, just delayed until the next run!
1620                       (setq compilation-error-list
1621                             (cdr compilation-error-list))
1622                       (goto-char beginning-of-match)
1623                       (setq found-desired t)))
1624                )
1625              )
1626             (t
1627              (error "compilation-parse-errors: known groups didn't match!")))
1628
1629       (message "Parsing error messages...%d (%.0f%% of buffer)"
1630                compilation-num-errors-found
1631                ;; Use floating-point because (* 100 (point)) frequently
1632                ;; exceeds the range of Emacs Lisp integers.
1633                (/ (* 100.0 (point)) (point-max)))
1634
1635       (and limit-search (>= (point) limit-search)
1636            ;; The user wanted a specific error, and we're past it.
1637            (setq found-desired t)))
1638     (setq compilation-parsing-end (if found-desired
1639                                       (point)
1640                                     ;; We have searched the whole buffer.
1641                                     (point-max))))
1642   (setq compilation-error-list (nreverse compilation-error-list))
1643   (message "Parsing error messages...done"))
1644
1645 ;; If directory DIR is a subdir of ORIG or of ORIG's parent,
1646 ;; return a relative name for it starting from ORIG or its parent.
1647 ;; ORIG-EXPANDED is an expanded version of ORIG.
1648 ;; PARENT-EXPANDED is an expanded version of ORIG's parent.
1649 ;; Those two args could be computed here, but we run faster by
1650 ;; having the caller compute them just once.
1651 (defun compile-abbreviate-directory (dir orig orig-expanded parent-expanded)
1652   ;; Apply canonical abbreviations to DIR first thing.
1653   ;; Those abbreviations are already done in the other arguments passed.
1654   (setq dir (abbreviate-file-name dir))
1655
1656   ;; Check for a comint-file-name-prefix and prepend it if appropriate.
1657   ;; (This is very useful for compilation-minor-mode in an rlogin-mode
1658   ;; buffer.)
1659   (if (boundp 'comint-file-name-prefix)
1660       (setq dir (concat comint-file-name-prefix dir)))
1661
1662   (if (and (> (length dir) (length orig-expanded))
1663            (string= orig-expanded
1664                     (substring dir 0 (length orig-expanded))))
1665       (setq dir
1666             (concat orig
1667                     (substring dir (length orig-expanded)))))
1668   (if (and (> (length dir) (length parent-expanded))
1669            (string= parent-expanded
1670                     (substring dir 0 (length parent-expanded))))
1671     (setq dir
1672           (concat (file-name-directory
1673                    (directory-file-name orig))
1674                   (substring dir (length parent-expanded)))))
1675   dir)
1676
1677 (provide 'compile)
1678
1679 ;;; compile.el ends here