* lisp/progmodes/compile.el (compilation-parse-errors-function): Remove.
(compilation--parse-region): Simplify accordingly.
(compilation--compat-parse-errors): Remove function, not used any more.
(compilation-error-list, compilation-parsing-end)
(compilation-old-error-list): Remove vars, not used any more.
(compilation-last-buffer): Mark as obsolete (sadly, forgot to do that
back in Emacs-22).
* lisp/textmodes/tex-mode.el: Remove old code that was needed for
Emacs<24.
* lisp/progmodes/prolog.el (prolog-consult-compile): Remove long-dead code.
(compilation-parse-errors-function): Remove declaration, not used any more.
(prolog-parse-sicstus-compilation-errors): Remove function, not used any more.
** 'insert-directory' alternatives should not change the free disk space line.
This change is now applied in 'dired-insert-directory'.
+---
+** 'compilation-last-buffer' is (finally) declared obsolete.
+It's been obsolete since Emacs-22.1, actually.
+
---
** Some functions and variables obsolete since Emacs 24 have been removed:
'Info-edit-map', 'allout-abbreviate-flattened-numbering',
'chart-map', 'comint-dynamic-complete',
'comint-dynamic-complete-as-filename',
'comint-dynamic-simple-complete', 'command-history-map',
+'compilation-parse-errors-function',
'completion-annotate-function', 'condition-case-no-debug',
'count-lines-region', 'data-debug-map', 'deferred-action-list',
'deferred-action-function', 'dired-x-submit-report',
(compilation-start compile-command)
;; Set comint-file-name-prefix in the compilation buffer so
;; compilation-parse-errors will find referenced files by Tramp.
- (with-current-buffer compilation-last-buffer
+ (with-current-buffer next-error-last-buffer
(when (fboundp 'tramp-make-tramp-file-name)
(set (make-local-variable 'comint-file-name-prefix)
(funcall
(defvar compilation-leave-directory-face 'font-lock-builtin-face
"Face name to use for leaving directory messages.")
-;; Used for compatibility with the old compile.el.
-(defvar compilation-parse-errors-function nil)
-(make-obsolete-variable 'compilation-parse-errors-function
- 'compilation-error-regexp-alist "24.1")
-
(defcustom compilation-auto-jump-to-first-error nil
"If non-nil, automatically jump to the first error during compilation."
:type '(choice (const :tag "Never" nil)
(and proc (memq (process-status proc) '(run open))))
(setq end (line-beginning-position))))
(compilation--remove-properties start end)
- (if compilation-parse-errors-function
- ;; An old package! Try the compatibility code.
- (progn
- (goto-char start)
- (compilation--compat-parse-errors end))
-
- ;; compilation-directory-matcher is the only part that really needs to be
- ;; parsed sequentially. So we could split it out, handle directories
- ;; like syntax-propertize, and the rest as font-lock-keywords. But since
- ;; we want to have it work even when font-lock is off, we'd then need to
- ;; use our own compilation-parsed text-property to keep track of the parts
- ;; that have already been parsed.
- (goto-char start)
- (while (re-search-forward (car compilation-directory-matcher)
- end t)
- (compilation--flush-directory-cache (match-beginning 0) (match-end 0))
- (when compilation-debug
- (font-lock-append-text-property
- (match-beginning 0) (match-end 0)
- 'compilation-debug
- (vector 'directory compilation-directory-matcher)))
- (dolist (elt (cdr compilation-directory-matcher))
- (add-text-properties (match-beginning (car elt))
- (match-end (car elt))
- (compilation-directory-properties
- (car elt) (cdr elt)))))
-
- (compilation-parse-errors start end)))
+ ;; compilation-directory-matcher is the only part that really needs to be
+ ;; parsed sequentially. So we could split it out, handle directories
+ ;; like syntax-propertize, and the rest as font-lock-keywords. But since
+ ;; we want to have it work even when font-lock is off, we'd then need to
+ ;; use our own compilation-parsed text-property to keep track of the parts
+ ;; that have already been parsed.
+ (goto-char start)
+ (while (re-search-forward (car compilation-directory-matcher)
+ end t)
+ (compilation--flush-directory-cache (match-beginning 0) (match-end 0))
+ (when compilation-debug
+ (font-lock-append-text-property
+ (match-beginning 0) (match-end 0)
+ 'compilation-debug
+ (vector 'directory compilation-directory-matcher)))
+ (dolist (elt (cdr compilation-directory-matcher))
+ (add-text-properties (match-beginning (car elt))
+ (match-end (car elt))
+ (compilation-directory-properties
+ (car elt) (cdr elt)))))
+
+ (compilation-parse-errors start end))
(defun compilation--note-type (type)
"Note that a new message with severity TYPE was seen.
(if (eq v fs) (remhash k compilation-locs)))
compilation-locs)))
-;;; Compatibility with the old compile.el.
-
-(defvaralias 'compilation-last-buffer 'next-error-last-buffer)
-(defvar compilation-parsing-end (make-marker))
-(defvar compilation-error-list nil)
-(defvar compilation-old-error-list nil)
-
-(defun compilation--compat-parse-errors (limit)
- (when compilation-parse-errors-function
- ;; FIXME: We should remove the rest of the compilation keywords
- ;; but we can't do that from here because font-lock is using
- ;; the value right now. --Stef
- (save-excursion
- (setq compilation-error-list nil)
- ;; Reset compilation-parsing-end each time because font-lock
- ;; might force us the re-parse many times (typically because
- ;; some code adds some text-property to the output that we
- ;; already parsed). You might say "why reparse", well:
- ;; because font-lock has just removed the `compilation-message' property
- ;; so have to do it all over again.
- (if compilation-parsing-end
- (set-marker compilation-parsing-end (point))
- (setq compilation-parsing-end (point-marker)))
- (condition-case nil
- ;; Ignore any error: we're calling this function earlier than
- ;; in the old compile.el so things might not all be setup yet.
- (funcall compilation-parse-errors-function limit nil)
- (error nil))
- (dolist (err (if (listp compilation-error-list) compilation-error-list))
- (let* ((src (car err))
- (dst (cdr err))
- (loc (cond ((markerp dst)
- (cons nil
- (compilation--make-cdrloc nil nil dst)))
- ((consp dst)
- (cons (nth 2 dst)
- (compilation--make-cdrloc
- (nth 1 dst)
- (cons (cdar dst) (caar dst))
- nil))))))
- (when loc
- (goto-char src)
- ;; (put-text-property src (line-end-position)
- ;; 'font-lock-face 'font-lock-warning-face)
- (put-text-property src (line-end-position)
- 'compilation-message
- (compilation--make-message loc 2 nil nil)))))))
- (goto-char limit)
- nil)
-
-;; Beware! this is not only compatibility code. New code also uses it. --Stef
(defun compilation-forget-errors ()
;; In case we hit the same file/line specs, we want to recompute a new
;; marker for them, so flush our cache.
(clrhash compilation-locs)
(setq compilation-gcpro nil)
- ;; FIXME: the old code reset the directory-stack, so maybe we should
- ;; put a `directory change' marker of some sort, but where? -stef
- ;;
- ;; FIXME: The old code moved compilation-current-error (which was
- ;; virtually represented by a mix of compilation-parsing-end and
- ;; compilation-error-list) to point-min, but that was only meaningful for
- ;; the internal uses of compilation-forget-errors: all calls from external
- ;; packages seem to be followed by a move of compilation-parsing-end to
- ;; something equivalent to point-max. So we heuristically move
- ;; compilation-current-error to point-max (since the external package
- ;; won't know that it should do it). --Stef
(setq compilation-current-error nil)
(let* ((proc (get-buffer-process (current-buffer)))
(mark (if proc (process-mark proc)))
(or compilation-auto-jump-to-first-error
(eq compilation-scroll-output 'first-error))))
+(define-obsolete-variable-alias 'compilation-last-buffer
+ ;; Sadly, we forgot to declare this obsolete back then :-(
+ 'next-error-last-buffer "29.1 (tho really since 22.1)")
+
(provide 'compile)
;;; compile.el ends here
(defalias 'kill-grep #'kill-compilation)
-;; override compilation-last-buffer
+;; override next-error-last-buffer
(defvar grep-last-buffer nil
"The most recent grep buffer.
A grep buffer becomes most recent when you select Grep mode in it.
Notice that using \\[next-error] or \\[compile-goto-error] modifies
-`compilation-last-buffer' rather than `grep-last-buffer'.")
+`next-error-last-buffer' rather than `grep-last-buffer'.")
(defvar grep-match-face 'match
"Face name to use for grep matches.")
(defvar prolog-consult-compile-real-file nil
"The file name of the buffer to compile/consult.")
-(defvar compilation-parse-errors-function)
-
(defun prolog-consult-compile (compilep file &optional first-line)
"Consult/compile FILE.
If COMPILEP is non-nil, perform compilation, otherwise perform CONSULTING.
;; Setting up font-locking for this buffer
(setq-local font-lock-defaults
'(prolog-font-lock-keywords nil nil ((?_ . "w"))))
- (if (eq prolog-system 'sicstus)
- ;; FIXME: This looks really problematic: not only is this using
- ;; the old compilation-parse-errors-function, but
- ;; prolog-parse-sicstus-compilation-errors only accepts one argument
- ;; whereas compile.el calls it with 2 (and did so at least since
- ;; Emacs-20).
- (setq-local compilation-parse-errors-function
- 'prolog-parse-sicstus-compilation-errors))
+ ;; (if (eq prolog-system 'sicstus)
+ ;; ;; FIXME: This looks really problematic: not only is this using
+ ;; ;; the old compilation-parse-errors-function, but
+ ;; ;; prolog-parse-sicstus-compilation-errors only accepts one
+ ;; ;; argument whereas compile.el calls it with 2 (and did so at
+ ;; ;; least since Emacs-20).
+ ;; (setq-local compilation-parse-errors-function
+ ;; #'prolog-parse-sicstus-compilation-errors))
(setq buffer-read-only nil)
(insert command-string "\n"))
(display-buffer buffer)
(defvar compilation-error-list)
-(defun prolog-parse-sicstus-compilation-errors (limit)
- "Parse the prolog compilation buffer for errors.
-Argument LIMIT is a buffer position limiting searching.
-For use with the `compilation-parse-errors-function' variable."
- (setq compilation-error-list nil)
- (message "Parsing SICStus error messages...")
- (let (filepath dir file errorline)
- (while
- (re-search-backward
- "{\\([a-zA-Z ]* ERROR\\|Warning\\):.* in line[s ]*\\([0-9]+\\)"
- limit t)
- (setq errorline (string-to-number (match-string 2)))
- (save-excursion
- (re-search-backward
- "{\\(consulting\\|compiling\\|processing\\) \\(.*\\)\\.\\.\\.}"
- limit t)
- (setq filepath (match-string 2)))
-
- ;; ###### Does this work with SICStus under Windows
- ;; (i.e. backslashes and stuff?)
- (if (string-match "\\(.*/\\)\\([^/]*\\)$" filepath)
- (progn
- (setq dir (match-string 1 filepath))
- (setq file (match-string 2 filepath))))
-
- (setq compilation-error-list
- (cons
- (cons (save-excursion
- (beginning-of-line)
- (point-marker))
- (list (list file dir) errorline))
- compilation-error-list)
- ))
- ))
+;; FIXME: This has been obsolete since Emacs-20!
+;; (defun prolog-parse-sicstus-compilation-errors (limit)
+;; "Parse the prolog compilation buffer for errors.
+;; Argument LIMIT is a buffer position limiting searching.
+;; For use with the `compilation-parse-errors-function' variable."
+;; (setq compilation-error-list nil)
+;; (message "Parsing SICStus error messages...")
+;; (let (filepath dir file errorline)
+;; (while
+;; (re-search-backward
+;; "{\\([a-zA-Z ]* ERROR\\|Warning\\):.* in line[s ]*\\([0-9]+\\)"
+;; limit t)
+;; (setq errorline (string-to-number (match-string 2)))
+;; (save-excursion
+;; (re-search-backward
+;; "{\\(consulting\\|compiling\\|processing\\) \\(.*\\)\\.\\.\\.}"
+;; limit t)
+;; (setq filepath (match-string 2)))
+
+;; ;; ###### Does this work with SICStus under Windows
+;; ;; (i.e. backslashes and stuff?)
+;; (if (string-match "\\(.*/\\)\\([^/]*\\)$" filepath)
+;; (progn
+;; (setq dir (match-string 1 filepath))
+;; (setq file (match-string 2 filepath))))
+
+;; (setq compilation-error-list
+;; (cons
+;; (cons (save-excursion
+;; (beginning-of-line)
+;; (point-marker))
+;; (list (list file dir) errorline))
+;; compilation-error-list)
+;; ))
+;; ))
(defun prolog-consult-compile-filter (process output)
"Filter function for Prolog compilation PROCESS.
becomes:
// surefire lint_line_off UDDONX"
(interactive)
- (let ((buff (if (boundp 'next-error-last-buffer)
+ (let ((buff (if (boundp 'next-error-last-buffer) ;Added to Emacs-22.1
next-error-last-buffer
compilation-last-buffer)))
(when (buffer-live-p buff)
(let (shell-dirtrack-verbose)
(tex-send-command tex-shell-cd-command dir)))
(with-current-buffer (process-buffer (tex-send-command cmd))
- (setq compilation-last-buffer (current-buffer))
- (compilation-forget-errors)
- ;; Don't parse previous compilations.
- (set-marker compilation-parsing-end (1- (point-max))))
+ (setq next-error-last-buffer (current-buffer))
+ (compilation-forget-errors))
(tex-display-shell)
(setq tex-last-buffer-texed (current-buffer)))
\f
projects / emacs.git / commitdiff