BCI NET 2/BCI NET 2.iso/archives/programming/source/a2.0bemacs-src.lha/Emacs-19.25/lisp/compile.elc

Text File | 1994-11-03 | 24.9 KB | 393 lines

(defvar compilation-mode-hook nil "\
*List of hook functions run by `compilation-mode' (see `run-hooks').")

(defconst compilation-window-height nil "\
*Number of lines in a compilation window.  If nil, use Emacs default.")

(defvar compilation-error-list nil "\
List of error message descriptors for visiting erring functions.
Each error descriptor is a cons (or nil).  Its car is a marker pointing to
an error message.  If its cdr is a marker, it points to the text of the
line the message is about.  If its cdr is a cons, it is a list
((DIRECTORY . FILE) LINE [COLUMN]).  Or its cdr may be nil if that
error is not interesting.

The value may be t instead of a list; this means that the buffer of
error messages should be reparsed the next time the list of errors is wanted.

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

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

(defvar compilation-parse-errors-function (quote compilation-parse-errors) "\
Function to call to parse error messages from a compilation.
It takes args LIMIT-SEARCH and FIND-AT-LEAST.
If LIMIT-SEARCH is non-nil, don't bother parsing past that location.
If FIND-AT-LEAST is non-nil, don't bother parsing after finding that
many new errors.
It should read in the source files which have errors and set
`compilation-error-list' to a list with an element for each error message
found.  See that variable for more info.")

(defvar compilation-buffer-name-function nil "\
Function to compute the name of a compilation buffer.
The function receives one argument, the name of the major mode of the
compilation buffer.  It should return a string.
nil means compute the name with `(concat \"*\" (downcase major-mode) \"*\")'.")

(defvar compilation-finish-function nil "\
*Function to call when a compilation process finishes.
It is called with two arguments: the compilation buffer, and a string
describing how the process finished.")

(defvar compilation-last-buffer nil "\
The most recent compilation buffer.
A buffer becomes most recent when its compilation is started
or when it is used with \\[next-error] or \\[compile-goto-error].")

(defvar compilation-in-progress nil "\
List of compilation processes now running.")

(or (assq (quote compilation-in-progress) minor-mode-alist) (setq minor-mode-alist (cons (quote (compilation-in-progress " Compiling")) minor-mode-alist)))

(defvar compilation-parsing-end nil "\
Position of end of buffer when last error messages were parsed.")

(defvar compilation-error-message "No more errors" "\
Message to print when no more matches are found.")

(defvar compilation-num-errors-found)

(defvar compilation-error-regexp-alist (quote (("
\\([^:(
]+\\)[:(][     ]*\\([0-9]+\\)[:)     ]" 1 2) ("[     :]\\([^:(
]+\\)[:(](+[     ]*\\([0-9]+\\))[:)     ]*$" 1 2) ("([     ]*\\([^:(
]+\\)[:(][     ]*\\([0-9]+\\))" 1 2) ("
fort: [^:
]*: \\([^
]*\\), line \\([0-9]+\\):" 1 2) ("\\(
\\|on \\)[Ll]ine[     ]+\\([0-9]+\\)[     ]+of[     ]+\"?\\([^\":
]+\\)\"?:" 3 2) ("\"\\([^,\"
    ]+\\)\", lines? \\([0-9]+\\)[:., -]" 1 2) ("rror: \\([^,\"
    ]+\\)[,:] \\(line \\)?\\([0-9]+\\):" 1 3) ("in line \\([0-9]+\\) of file \\([^
]+[^.
]\\)\\.? " 2 1) ("
[EW], \\([^(
]*\\)(\\([0-9]+\\),[     ]*\\([0-9]+\\)" 1 2 3) ("
\\\"\\([^
\\\"]+\\)\\\",[ ]*\\([0-9]+\\),[ ]*\\([0-9]+\\): Error" 1 2 3) ("
\\\"\\([^
\\\"]+\\)\\\",[ ]*\\([0-9]+\\),[ ]*\\([0-9]+\\): Warning" 1 2 3) ("
\\([^
]+\\) \\([0-9]+\\) Warning" 1 2) ("
\\([^
]+\\) \\([0-9]+\\) Error" 1 2))) "Alist that specifies how to match errors in compiler output.
Each element has the form (REGEXP FILE-IDX LINE-IDX [COLUMN-IDX]).
If REGEXP matches, the FILE-IDX'th subexpression gives the file name, and
the LINE-IDX'th subexpression gives the line number.  If COLUMN-IDX is
given, the COLUMN-IDX'th subexpression gives the column number on that line.")

(defvar compilation-read-command t "\
If not nil, M-x compile reads the compilation command to use.
Otherwise, M-x compile just uses the value of `compile-command'.")

(defvar compilation-ask-about-save t "\
If not nil, M-x compile asks which buffers to save before compiling.
Otherwise, it saves all modified buffers without asking.")

(defvar grep-regexp-alist (quote (("^\\([^:(
]+\\)[:(     ]+\\([0-9]+\\)[:)     ]" 1 2))) "Regexp used to match grep hits.  See `compilation-error-regexp-alist'.")

(defvar grep-command "grep -n " "\
Last grep command used in \\{grep}; default for next grep.")

(defvar compilation-search-path (quote (nil)) "\
*List of directories to search for source files named in error messages.
Elements should be directory names, not file names of directories.
nil as an element means to try the default directory.")

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

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

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

(defconst compilation-enter-directory-regexp ": Entering directory `\\(.*\\)'$" "\
Regular expression matching lines that indicate a new current directory.
This must contain one \\(, \\) pair around the directory name.

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

(defconst compilation-leave-directory-regexp ": Leaving directory `\\(.*\\)'$" "\
Regular expression matching lines that indicate restoring current directory.
This may contain one \\(, \\) pair around the name of the directory
being moved from.  If it does not, the last directory entered (by a
line matching `compilation-enter-directory-regexp') is assumed.

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

(defvar compilation-directory-stack nil "\
Stack of previous directories for `compilation-leave-directory-regexp'.
The head element is the directory the compilation was started in.")

(defvar compile-history nil)

(defvar grep-history nil)

(defun compile (command) "\
Compile the program including the current buffer.  Default: run `make'.
Runs COMMAND, a shell command, in a separate process asynchronously
with output going to the buffer `*compilation*'.

You can then use the command \\[next-error] to find the next error message
and move to the source code that caused it.

To run more than one compilation at once, start one and rename the
`*compilation*' buffer to some other name with \\[rename-buffer].
Then start the next one.

The name used for the buffer is actually whatever is returned by
the function in `compilation-buffer-name-function', so you can set that
to a function that generates a unique name." (interactive (byte-code "ƒÃÄ    ÂÂÅ%C‚    C‡" [compilation-read-command compile-command nil read-from-minibuffer "Compile command: " (compile-history . 1)] 6)) (byte-code "ˆ‰ˆÅ?Â\"ˆÆ    Ç\"‡" [compilation-read-command compile-command nil command compilation-ask-about-save save-some-buffers compile-internal "No more errors"] 4))

(defun grep (command-args) "\
Run grep, with user-specified args, and collect output in a buffer.
While grep runs asynchronously, you can use the \\[next-error] command
to find the text that grep hits refer to.

This command uses a special history list for its arguments, so you can
easily repeat a grep command." (interactive (byte-code "ÂÃÁÁÄ%C‡" [grep-command nil read-from-minibuffer "Run grep (like this): " grep-history] 6)) (byte-code "ÁˆÅ
Æ=ƒǂÈPÉÊÁ%‡" [grep-command nil command-args system-type grep-regexp-alist compile-internal amigados " nil:" " /dev/null" "No more grep hits" "grep"] 6))

(defun compile-internal (command error-message &optional name-of-mode parser regexp-alist name-function) "\
Run compilation command COMMAND (low level interface).
ERROR-MESSAGE is a string to print if the user asks to see another error
and there are no more errors.  Third argument NAME-OF-MODE is the name
to display as the major mode in the compilation buffer.

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

Returns the compilation buffer created." (byte-code "ÍŠ    †
ىˆÚÛ
††Ü    \"!‰ˆqˆÝp!…EÞ!ß=?†6àáâ    \"!ƒ@Íã䏂Eåæç \")ˆè )ˆ
†Q†X
Í    ŠqˆÍ‰ˆé ˆ    ‰
ˆêë    ìì%ˆíÍ!)ˆp=…‹dbˆî!‰ˆŠqˆï ˆðp!ˆñÈ!Lˆñò!LˆñÆ!
Lˆ    

C‰ˆóe\"ˆ    ‰ˆô =†Õõe\"ˆ…ùö!÷ U…ùô øŽù!ˆúû Z!))ˆüý!ƒ8
þÿ!#@A\"ˆBC\"ˆDE!`#ˆB‰)‚c
FáG\"!ˆHÍ́I&Í)ˆFáJ\"!),ˆ‰)‡" [outbuf name-of-mode name-function compilation-buffer-name-function comp-proc regexp-alist compilation-error-regexp-alist parser compilation-parse-errors-function thisdir default-directory outwin buffer-read-only nil command error-message compilation-directory-stack mode-name compilation-window-height w proc compilation-in-progress status shell-file-name compilation-last-buffer "Compilation" get-buffer-create funcall (lambda (mode) (byte-code "ÁÂ!ÁQ‡" [mode "*" downcase] 4)) get-buffer-process process-status run yes-or-no-p format "A %s process is running; kill it? " (byte-code "Á!ˆÂÃ!ˆÄ!‡" [comp-proc interrupt-process sit-for 1 delete-process] 4) ((error (byte-code "À‡" [nil] 1))) error "Cannot have two processes in `%s' at once" buffer-name kill-all-local-variables erase-buffer insert "cd " "
" set-buffer-modified-p display-buffer compilation-mode buffer-disable-undo make-local-variable compilation-error-message set-window-start selected-window set-window-point window-width frame-width ((byte-code "Á!‡" [w select-window] 2)) select-window enlarge-window window-height fboundp start-process start-process-shell-command downcase set-process-sentinel compilation-sentinel set-process-filter compilation-filter set-marker process-mark message "Executing `%s'..." call-process "-c" "Executing `%s'...done"] 43))

(defvar compilation-minor-mode-map (let ((map (make-sparse-keymap))) (define-key map [mouse-2] (quote compile-mouse-goto-error)) (define-key map "" (quote compile-goto-error)) (define-key map "" (quote kill-compilation)) (define-key map "î" (quote compilation-next-error)) (define-key map "ð" (quote compilation-previous-error)) (define-key map "û" (quote compilation-previous-file)) (define-key map "ý" (quote compilation-next-file)) map) "\
Keymap for `compilation-minor-mode'.")

(defvar compilation-mode-map (let ((map (cons (quote keymap) compilation-minor-mode-map))) (define-key map " " (quote scroll-up)) (define-key map "" (quote scroll-down)) map) "\
Keymap for compilation log buffers.
`compilation-minor-mode-map' is a cdr of this.")

(defun compilation-mode nil "\
Major mode for compilation log buffers.
\\<compilation-mode-map>To visit the source for a line-numbered error,
move point to the error message line and type \\[compile-goto-error].
To kill the compilation, type \\[kill-compilation].

Runs `compilation-mode-hook' with `run-hooks' (which see)." (interactive) (byte-code "ÃˆÄ ˆÅ!ˆÆljˆÈ ˆÉÊ!‡" [compilation-mode-map major-mode mode-name nil fundamental-mode use-local-map compilation-mode "Compilation" compilation-setup run-hooks compilation-mode-hook] 5))

(defun compilation-setup nil (byte-code "ɈÄÅ!ÁLˆÄÆ!ÁLˆÄÇ!ÈLˆÄÉ!ÁLˆp‰‡" [mode-line-process nil compilation-last-buffer (":%s") make-local-variable compilation-error-list compilation-old-error-list compilation-parsing-end 1 compilation-directory-stack] 6))

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

(make-variable-buffer-local (quote compilation-minor-mode))

(or (assq (quote compilation-minor-mode) minor-mode-alist) (setq minor-mode-alist (cons (quote (compilation-minor-mode " Compilation")) minor-mode-alist)))

(or (assq (quote compilation-minor-mode) minor-mode-map-alist) (setq minor-mode-map-alist (cons (cons (quote compilation-minor-mode) compilation-minor-mode-map) minor-mode-map-alist)))

(defun compilation-minor-mode (&optional arg) "\
Toggle compilation minor mode.
With arg, turn compilation mode on if and only if arg is positive.
See `compilation-mode'." (interactive "P") (byte-code "ˆ    ?ƒ?‚à    !ÄV‰…Å ‡" [compilation-minor-mode arg nil prefix-numeric-value 0 compilation-setup] 3))

(defun compilation-sentinel (proc msg) "\
Sentinel for compilation buffers." (byte-code "Ì    !Í    !Î>…„Ï!?ƒÐ    Â\"‚{pÂÂюqˆÂd`‰ˆbˆÒÓÔ$ˆÕÖ!ˆÒ×Ø ÙÚO\"ˆÕÛ!ˆÜÝÍ    !!P‰    ˆÞ    !ˆßà !)ˆ
…g
W…l
bˆ
…yá
#)+ˆâ    \"‰)‡" [buffer proc nil obuf omax opoint buffer-read-only mode-name msg mode-line-process compilation-finish-function compilation-in-progress process-buffer process-status (signal exit) buffer-name set-process-buffer ((byte-code "q‡" [obuf] 1)) insert 10 " " forward-char -1 " at " current-time-string 0 19 1 ":" symbol-name delete-process set-buffer-modified-p buffer-modified-p funcall delq] 18))

(defun compilation-filter (proc string) "\
Process filter for compilation buffers.
Just inserts the text, but uses `insert-before-markers'." (byte-code "ŠÄ!qˆÂŠÅ!bˆÆ!ˆÇÅ!`\")))‡" [proc buffer-read-only nil string process-buffer process-mark insert-before-markers set-marker] 7))

(defun compile-error-at-point nil (byte-code "ÃÀ`\"ˆ
    …`    @@V…    A‰ˆ‚ˆ    )‡" [nil errors compilation-old-error-list compile-reinitialize-errors] 4))

(defsubst compilation-buffer-p (buffer) (assq (quote compilation-error-list) (buffer-local-variables buffer)))

(defun compilation-next-error (n) "\
Move point to the next error in the compilation buffer.
Does NOT find the source line like \\[next-error]." (interactive "p") (byte-code "LjÈp!†ÉÊ!ˆp‰ˆË 
ÌWƒFÌ
    =?…/TA‰ˆ‚ˆ
[Vƒ=ÉÍ!‚B
\\
8*‚a    AÎÇÇ
#ˆƒ]
S8‚`ÉÏ!)@b)‡" [compilation-last-buffer errors n i e compilation-old-error-list compilation-error-list nil compilation-buffer-p error "Not in a compilation buffer." compile-error-at-point 0 "Moved back past first error" compile-reinitialize-errors "Moved past last error"] 8))

(defun compilation-previous-error (n) "\
Move point to the previous error in the compilation buffer.
Does NOT find the source line like \\[next-error]." (interactive "p") (byte-code "ÁˆÂ[!‡" [n nil compilation-next-error] 2))

(defsubst compilation-error-filedata (data) (setq data (cdr data)) (if (markerp data) (marker-buffer data) (car data)))

(defsubst compilation-error-filedata-file-name (filedata) (if (bufferp filedata) (buffer-file-name filedata) (car filedata)))

(defun compilation-next-file (n) "\
Move point to the next error for a different file than the current one." (interactive "p") (byte-code "ňÈp!†ÉÊ!ˆp‰ˆ
ËWÅÅ    ?ƒ*Ì †%ÉÍ!‰‚MÎÅ`\"ˆÏ!
[‰ˆ…B`@@W…MA‰ˆ‚9ˆ
ËV…Ð@!‰ˆÑІ†    ƒoÉÒÓ!\"‚}ÅÎÅÅÔ#ˆ‰)††ÉÕÓ!\"@!\"…”A‰ˆ‚[ˆ
S‰ˆ‚Nˆ†¸    ƒ¬ÉÖ!‚¸ÅÎÅÅ×#ˆ)@@b+‡" [compilation-last-buffer reversed n errors filedata nil compilation-old-error-list compilation-error-list compilation-buffer-p error "Not in a compilation buffer." 0 compile-error-at-point "Moved past last error" compile-reinitialize-errors reverse compilation-error-filedata equal "%s the first erring file" compilation-error-filedata-file-name 2 "%s is the last erring file" "This is the first erring file" 1] 19))

(defun compilation-previous-file (n) "\
Move point to the previous error for a different file than the current one." (interactive "p") (byte-code "ÁˆÂ[!‡" [n nil compilation-next-file] 2))

(defun kill-compilation nil "\
Kill the process made by the \\[compile] command." (interactive) (byte-code "ÁˆÂ Ã!ƒÄÃ!!‚ÅÆ!)‡" [buffer nil compilation-find-buffer get-buffer-process interrupt-process error "The compilation process is not running."] 6))

(defun compile-reinitialize-errors (reparse &optional limit-search find-at-least) (byte-code "Šqˆ    Â=†…Ë ˆ    …+?†
V…+?†+    GYƒ2ǂbÌÇ!ˆ
dW…b    Í    …M    GZ#ˆÎ
    \"‰
ˆ…a‰))‡" [compilation-last-buffer compilation-error-list t reparse limit-search compilation-parsing-end find-at-least nil error-list-pos compilation-parse-errors-function compilation-old-error-list compilation-forget-errors set-buffer-modified-p funcall nconc] 7))

(defun compile-mouse-goto-error (event) (interactive "e") (byte-code "ˆŠÅÆÇ!!!qˆÈÇ!!bˆÉp!†ÊË!ˆp‰ˆÌÂ`\"ˆÍ ˆ‰ˆ…6`@@V…AA‰ˆ‚-ˆ†IÊÎ!)ˆÏÆÇ!!!ˆÐ †^ÑÒ!ˆ    qˆÓ ˆÔÕ!‡" [event compilation-last-buffer nil compilation-error-list compilation-old-error-list window-buffer posn-window event-end posn-point compilation-buffer-p error "Not in a compilation buffer." compile-reinitialize-errors beginning-of-line "No error to go to" select-window one-window-p other-window -1 push-mark next-error 1] 18))

(defun compile-goto-error (&optional argp) "\
Visit the source for the error message point is on.
Use this command in a compilation log buffer.  Sets the mark at point there.
\\[universal-argument] as a prefix arg means to reparse the buffer's error messages first;
other kinds of prefix arguments are ignored." (interactive "P") (byte-code "ĈÅp!†ÆÇ!ˆp‰ˆÈ    :`\"ˆÉ ˆ‰ˆ
…&`
@@V…1
A‰ˆ‚ˆÊ †=ËÌ!ˆqˆÍ ˆÎÏ!‡" [compilation-last-buffer argp compilation-error-list compilation-old-error-list nil compilation-buffer-p error "Not in a compilation buffer." compile-reinitialize-errors beginning-of-line one-window-p other-window -1 push-mark next-error 1] 9))

(defun compilation-find-buffer (&optional other-buffer) (byte-code "?…Ãp!ƒp‚o    …\"Ä    !…\"?†\"    p=?ƒ)    ‚oÅ 
…@Ã
@!?†@…@
@p=…K
A‰ˆ‚,ˆ
ƒU
@‚n…hÃp!…h…fÆÇ!ˆp†nÈÉ!)‡" [other-buffer compilation-last-buffer buffers compilation-buffer-p buffer-name buffer-list message "This is the only compilation buffer." error "No compilation started!"] 8))

(defun next-error (&optional argp) "\
Visit next compilation error message and corresponding source code.
This operates on the output from the \\[compile] command.
If all preparsed error messages have been processed,
the error message buffer is checked for new ones.

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

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

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

See variables `compilation-parse-errors-function' and
`compilation-error-regexp-alist' for customization ideas." (interactive "P") (byte-code "ˆà ‰ˆÄÅ    :?…Æ    !    :\"!‡" [compilation-last-buffer argp nil compilation-find-buffer compilation-goto-locus compilation-next-error-locus prefix-numeric-value] 6))

(defun compilation-next-error-locus (&optional move reparse) "\
Visit next compilation error and return locus in corresponding source code.
This operates on the output from the \\[compile] command.
If all preparsed error messages have been processed,
the error message buffer is checked for new ones.

Returns a cons (ERROR . SOURCE) of two markers: ERROR is a marker at the
location of the error message in the compilation buffer, and SOURCE is a
marker at the location in the source code indicated by the error message.

Optional first arg MOVE says how many error messages to move forwards (or
backwards, if negative); default is 1.  Optional second arg REPARSE, if
non-nil, says to reparse the error message buffer and reset to the first
error (plus MOVE - 1).

The current buffer should be the desired compilation output buffer." (byte-code "†ՉˆÖ        ?…ÕWƒׂS#ˆÂŠ
qˆ×Vƒ5ØS\"‚rS×
        =?…XT    A‰    ˆ‚@ˆ[VƒhÙÚ!‚qØ\\
\"+@‰ˆ?ƒ¯…’ÛÕ\"…’Ù×V…ÜÚ\"ˆÝ ˆÙÞp!…ªßÞp!!à=…ªáP!‚Ò
A‰ˆA?ƒ¿Ì‚Ò
âA!†Ä
A@
ã
A
@@#?ƒ

‰ˆ

@A:…
ä@A@
\"…
å@@Â\"ˆæ@Â\"ˆA‰ˆ‚âˆÌ‚Ã

ÕA8çA8qˆŠŒè ˆé!ˆƒ<
ê!‚>
ë ˆæì \"ˆ…À
@A:…µ
ä@A@
\"…µ
Õ@A8ç@A8ZÌ=ƒ˜
×WƒŽ
íîÂï[$‚•
ðîÂï$‚œ
ñ!ˆ…¦
ê!ˆ‰ˆæ@ì \"+ˆA‰ˆ‚E
))+*ˆâA!?†Ò
òA!?…à
@‰ˆ‚x)ˆ…ï
ä@AA\"…ü
A‰ˆ‚â
ˆ*‡" [move reparse nil next-errors next-error compilation-last-buffer compilation-error-list n i e compilation-old-error-list compilation-error-message t fileinfo buffer errors last-line column this lines selective-display 1 compile-reinitialize-errors 0 nthcdr error "Moved back past first error" /= "Moved past last error" compilation-forget-errors get-buffer-process process-status run " yet" markerp compilation-find-file equal set-marker setcdr 2 widen goto-line move-to-column beginning-of-line point-marker re-search-backward "[

]" end re-search-forward forward-line marker-buffer] 35))

(defun compilation-goto-locus (next-error) "\
Jump to an error locus returned by `compilation-next-error-locus'.
Takes one argument, a cons (ERROR . SOURCE) of two markers.
Selects a window with point at SOURCE, with another window displaying ERROR." (byte-code "ÄÅ !…Å Æ =ƒÇÈA!!‚ÉÈA!!ˆAbˆ`ÊA!U†2Ë ˆAbˆÂÌÈ@!!Í@\"ˆÎ@\"*‡" [next-error pop-up-windows t w window-dedicated-p selected-window frame-root-window switch-to-buffer-other-frame marker-buffer switch-to-buffer marker-position widen display-buffer set-window-point set-window-start] 16))

(defun compilation-find-file (filename dir marker) (byte-code "    ÊÊ
?…+Ë@†
\"Ì!…\"Í!A‰ˆ‚ˆ
†oÇÎÏ    !!Ð    \"ˆÑ    \"*ˆËÒÓÔ\"
Ç$!‰ˆÕ!…eÖ!P‰ˆÌ!…oÍ!+‡" [dirs compilation-search-path result name filename dir pop-up-windows t w marker nil expand-file-name file-exists-p find-file-noselect display-buffer marker-buffer set-window-point set-window-start read-file-name format "Find this error in: (default %s) " file-directory-p file-name-as-directory] 15))

(defun compilation-forget-errors nil (byte-code "…#@Æ    @Â\"ˆÇ    A!…Æ    AÂ\")ˆA‰ˆ‚ˆÂÂȉ‡" [compilation-old-error-list next-error nil compilation-error-list compilation-directory-stack compilation-parsing-end set-marker markerp 1] 6))

(defun count-regexp-groupings (regexp) "\
Return the number of \\( ... \\) groupings in REGEXP (a string)." (byte-code "Å
GÅÆ    W…[
HT‰ˆÇUƒ8    W…*
HÈU?…5T‰ˆ‚‚WÉU…W    W…W
HT‰ˆÊU…WT‰ˆ‚    ˆ,‡" [groupings len regexp i c 0 nil 91 93 92 41] 4))

(defun compilation-parse-errors (limit-search find-at-least) "\
Parse the current buffer as grep, cc or lint error messages.
See variable `compilation-parse-errors-function' for the interface it uses." (byte-code "Á‰ˆáâ!ˆÁÁÁÁÁÁÁÁÁÁÁÁã

    bˆo…:äå!ˆæç!ˆèéêéêéëìí#î&    ‰ˆïðñ!ï#ðñ!ï#‰    ˆ†uòó!
    T‰ˆ
…Æï
@8\\å
@8\\ô
@8…¥ô
@8\\FB‰ˆðïñ
@@!#‰ˆ
A‰
ˆ‚~ˆ‰ˆõ!‰ˆö÷\"‰ˆ
?…åøÁÔ#…üù!ƒ8
úöûùï\\!üï\\!\"!!ý
$‰ˆB‰ˆþ!…#
‰)ˆ…5
`Y…5
ԉ
‚Òù!ƒ´
ùï\\!…†
úöûüï\\!\"!!ý
$‰ˆ…x
ÿ@\"?……
A‰ˆ‚k
)ˆA‰ˆ@‰ˆ…Ÿ
‰*ˆ…±
`Y…±
ԉ
‚Òù    !ƒÍ‰
ˆ
…Í
ù
@@!?…Ú

A‰
ˆ‚Á
ˆ
Ď

@‰
‚î
ò@!ˆùã!ûùï
8!üï
8!\"Aûùå
8!üå
8!\"!ô
8…+Aûùô
8!üô
8!\"!BÞ!…LC!…LP‰ˆB‰ˆŠDï!ˆE EBFA@A\"ƒ|Á‚‰B‰ˆT‰))ˆ …– V†¢…¢`Y…ÉA…ɁFã8A@ï8A@\"?…ÉA‰ˆbˆÔ‰
,‚ÒòG!ˆáHIJK`\"d\"#ˆ…ø`Y…øԉ
ˆ‚Ùˆ
ƒ`‚d‰.
ˆL!‰ˆáM!‡" [compilation-error-list nil text-buffer orig orig-expanded parent-expanded regexp enter-group leave-group error-group alist subexpr error-regexp-groups found-desired compilation-num-errors-found compilation-parsing-end compilation-enter-directory-regexp compilation-leave-directory-regexp compilation-error-regexp-alist default-directory t dir compilation-directory-stack limit-search beg stack beginning-of-match filename linenum column comint-file-name-prefix this find-at-least message "Parsing error messages..." 0 forward-line 2 forward-char -1 concat "\\(" "\\)\\|" mapconcat (lambda (elt) (byte-code "Á@ÂQ‡" [elt "\\(" "\\)"] 3)) "\\|" "\\)" 1 + count-regexp-groupings error "compilation-error-regexp-alist is empty!" 3 file-truename expand-file-name "../" re-search-forward match-beginning file-name-as-directory buffer-substring match-end compile-abbreviate-directory file-directory-p string-equal "compilation-parse-errors: impossible regexp match!" string-to-int boundp file-name-absolute-p beginning-of-line point-marker equal "compilation-parse-errors: known groups didn't match!" "Parsing error messages...%d (%.0f%% of buffer)" / * 100.0 nreverse "Parsing error messages...done"] 61))

(defun compile-abbreviate-directory (dir orig orig-expanded parent-expanded) (byte-code "ÅÁ!…    P‰ˆG
GV…Æ
Ç
GO\"…(
GÈOP‰ˆGGV…9ÆÇGO\"…IÉÊ!!GÈOP‰ˆ‡" [dir comint-file-name-prefix orig-expanded orig parent-expanded boundp string= 0 nil file-name-directory directory-file-name] 9))

(provide (quote compile))