Re: compilation-forget-errors still used by tex-mode.el

[Markus Rost <rost@mathematik.uni-bielefeld.de>]

As for ideas:  What about having for tex compilation parses an option
like

(defcustom tex-plus-error-parse-level nil
  "*If non-nil, consider also over/underfull hbox messages as errors.
This enables you to jump to the corresponding source locations."
  :type 'boolean
  :group 'tex-run)

I once wrote a corresponding hack and use it a lot.

It seems however that one can't use it directly with the new
compile.el and I don't have the time to adjust it.  In case someone is
interested, I append here the file containing the code.


===File ~/emacs/lisp/emacs-21/tex-plus.el===================
(let ((l0 (car ispell-tex-skip-alists))
      (l1 (cadr ispell-tex-skip-alists)))
  (add-to-list 'l0 '("\\\\\\(eq\\)?ref" ispell-tex-arg-end))
  (add-to-list 'l0 '("\\\\label" ispell-tex-arg-end))
  (add-to-list 'l0 '("[^\\]%.*$"))
  (add-to-list 'l1 '("gather\\*?" . "\\\\end[ \t\n]*{[ \t\n]*gather\\*?[ \t\n]*}") t)
  (add-to-list 'l1 '("align\\*?" . "\\\\end[ \t\n]*{[ \t\n]*align\\*?[ \t\n]*}") t)
  (setcar ispell-tex-skip-alists l0)
  (setcar (cdr ispell-tex-skip-alists) l1))

(require 'tex-mode)

(if (string-lessp emacs-version "21.3.49")
    (defvar tex-compile-commands nil))

(defvar tex-compile-commands-0 tex-compile-commands
  "The original value of `tex-compile-commands'
Used in combination with `tex-compile-commands-1'
Don't set this variable yourself.")

(defcustom tex-compile-commands-1 nil
  "List of additional commands for `tex-compile'.
Prepended to `tex-compile-commands-0' to set `tex-compile-commands'.
Set this variable with customize.
See `tex-compile-commands' for the syntax."
  :type '(repeat (list
		  (radio  :tag "Commands"
			  string sexp)
		  (choice :tag "Input File"
			  (string :tag "String")
			  (const :tag "TeX files of the document" t)
			  (const :tag "Don't know" nil))
		  (choice :tag "Output File"
			  (string :tag "String")
			  (const :tag "No Output File" nil))))
  :set (lambda (symbol value)
	 (set-default symbol value)
	 (setq tex-compile-commands
	       (append value (copy-sequence tex-compile-commands-0))))
  :group 'tex-run)

;;; Customize the tex-shell.
;; I want it to use HISTFILE=~/.bash/.bash1_history

(defcustom tex-shell-hook nil
  "Hook for `tex-shell'."
  :type 'hook
  :group 'tex-run)

(defcustom tex-shell-file-name nil
  "*If non-nil, the shell file name to run in the subshell used to run TeX.
See also `tex-shell-arg-list'."
  :type '(choice (const :tag "None" nil)
		 string)
  :group 'tex-run)

(defcustom tex-shell-arg-list nil
  "*Alist of options passed to subshell used to run TeX.
See also `tex-shell-file-name'."
  :type '(repeat :tag "Option list" string)
  :group 'tex-run)

(defun tex-start-shell ()
  (with-current-buffer
      (apply 'make-comint
       "tex-shell"
       (or tex-shell-file-name explicit-shell-file-name
	   (getenv "ESHELL") (getenv "SHELL") "/bin/sh")
       nil (or tex-shell-arg-list '("-i")))
    (let ((proc (get-process "tex-shell")))
      (set-process-sentinel proc 'tex-shell-sentinel)
      (process-kill-without-query proc)
      (tex-shell)
      (while (zerop (buffer-size))
	(sleep-for 1)))))

;;; My error parsing.

(defadvice tex-send-tex-command (after tex-plus-compilation activate)
  (when (tex-shell-running)
    (with-current-buffer (process-buffer (tex-shell-running))
    (setq compilation-parse-errors-function
	  'tex-plus-compilation-parse-errors)
    ;; Clean up.
    (let ((buffer-undo-list t)
	  (inhibit-read-only t)
	  deactivate-mark)
      ;; Remove the text-properties added by
      ;; tex-plus-compilation-parse-errors.
      (if compilation-old-error-list
	  (remove-text-properties (point-min) (point-max)
				  '(syntax-table nil)))))))

(defvar tex-plus-start-tex-marker nil
  "Marker pointing after last TeX-running command in the TeX shell buffer.")

(defcustom tex-plus-error-parse-level nil
  "*If non-nil, consider also over/underfull hbox messages as errors.
This enables you to jump to the corresponding source locations."
  :type 'boolean
  :group 'tex-run)

;;; Error Parsing
(easy-mmode-defsyntax
 tex-plus-error-parse-syntax-table
 '((?\{ . "_")
   (?\} . "_")
   (?\[ . "_")
   (?\] . "_")
   (?\" . "_"))
 "A syntax table used by `tex-plus-compilation-parse-errors'.

Only \"(\" and \")\" are seen by backward-list.")

(easy-mmode-defsyntax
 tex-plus-error-skip-syntax-table
 '((?\( . "_")
   (?\) . "_")
   (?\{ . "_")
   (?\} . "_")
   (?\[ . "_")
   (?\] . "_")
   (?\" . "_"))
 "A syntax table used by `tex-plus-compilation-parse-errors'.

No characters are seen by backward-list.")

(defun tex-plus-compilation-parse-errors (limit-search find-at-least)
  "Parse the current buffer as TeX error messages.
See the variable `compilation-parse-errors-function' for the interface it uses.

This function parses only the last TeX compilation.

A special parsing routine is necessary, since TeX does not put file
names and line numbers on the same line as for the error messages."
  (require 'thingatpt)
  (setq compilation-error-list nil)
  (message "Parsing error messages...")
  (let (;; First a kind of buffer-save-state.
	(buffer-undo-list t) (inhibit-read-only t) deactivate-mark

	;; Dir may have changed.
	(default-directory
	  (file-name-directory (buffer-file-name tex-last-buffer-texed)))

	;; We use syntax-table text-properties.
	(parse-sexp-lookup-properties t)

	;; To restore it later.
	(err-buf (current-buffer))

	;; We need a table with only "(" and ")" seen by backward-list.
;; 	(tex-plus-error-parse-syntax-table
;; 	 (let ((table (copy-syntax-table)))
;; 	   (modify-syntax-entry ?\{ "_" table)
;; 	   (modify-syntax-entry ?\} "_" table)
;; 	   (modify-syntax-entry ?\[ "_" table)
;; 	   (modify-syntax-entry ?\] "_" table)
;; 	   (modify-syntax-entry ?\" "_" table)
;; 	   table))

	;; We need a table with no characters seen by backward-list.
;; 	(tex-plus-error-skip-syntax-table
;; 	 (let ((table (copy-syntax-table)))
;; 	   (modify-syntax-entry ?\( "_" table)
;; 	   (modify-syntax-entry ?\) "_" table)
;; 	   (modify-syntax-entry ?\{ "_" table)
;; 	   (modify-syntax-entry ?\} "_" table)
;; 	   (modify-syntax-entry ?\[ "_" table)
;; 	   (modify-syntax-entry ?\] "_" table)
;; 	   (modify-syntax-entry ?\" "_" table)
;; 	   table))

	;; We freeze point-max here to care about a running tex
	;; process.
	(current-point-max (point-max)) output-finished

	;; The variables to play with.
	(num-errors-found 0) parsing-end
	last-error last-linenum
	error-msg error-type error-start error-end error-text
	linenum filename error-source)

    ;; Do we reparse or parse the first time?
    (when (eq (marker-position compilation-parsing-end) 1)
      ;; If `compilation-forget-errors' would run a hook, that should
      ;; go there.  What about a compilation-forget-errors-function?
      (if (and (markerp tex-plus-start-tex-marker)
	       (eq (current-buffer) (marker-buffer tex-plus-start-tex-marker)))
	  (set-marker compilation-parsing-end tex-plus-start-tex-marker))
      (remove-text-properties (point-min) (point-max) '(syntax-table nil)))
    (goto-char compilation-parsing-end)

    ;; Is the tex run finished?
    (save-excursion
      (if (setq output-finished
		(re-search-forward
		 "^Transcript written on " nil t))
	  ;;  Then limit the parse to its output.
	  (setq current-point-max output-finished)))

    ;; Parse messages.

    ;; To determine the error file we use backward-list with
    ;; syntax-table tex-plus-error-parse-syntax-table.  The messages may
    ;; contain characters "(" and ")" which irritate the scanning.
    ;; Therefore the messages receive the syntax-table text-property
    ;; tex-plus-error-skip-syntax-table.

    ;; There are basically two types of messages:  (I) true tex errors
    ;; and (II) messages about overfull hboxes and similar things.

    ;; If the user option `tex-plus-error-parse-level' is nil, type (II)
    ;; errors are neglected by default for
    ;; `compilation-error-list'. Otherwise they are treated in the
    ;; same way as type (I) errors.

    (catch 'parsing-end
      (while t

	(unless
	    (re-search-forward
	     ;; A regexp for all relevant messages.
	     ;; It is probably incomplete.
	     "^\\(! \\|\\(Over\\|Under\\)full \\\\.*lines? \\([0-9]+\\)\\)"
	     current-point-max t)
	  ;; No more messages: exit.
	  (setq parsing-end current-point-max)
	  (throw 'parsing-end nil))

	(goto-char (match-beginning 0))
	(setq error-msg (point-marker))
	(setq error-start error-msg)

	(cond
	 ((looking-at "^! Emergency stop\\.")
	  ;; A special case:  We are at the end.
	  (setq parsing-end current-point-max)
	  (throw 'parsing-end nil))
	 ((looking-at "^! ")
	  ;; It is a type (I) error.
	  (setq error-type t)
	  ;; In a "Runaway argument?", the error lines start before the
	  ;; error message "! Paragraph ended..."
	  (if (looking-at "^! Paragraph ended before .* was complete.$")
	      (save-excursion
		(forward-line -2)
		(if (looking-at "^Runaway argument\\?\n ")
		    (setq error-start (point-marker)))))
	  (unless (re-search-forward
		   "^l\\.\\([0-9]+\\) \\(\\.\\.\\.\\)?\\(.*\\)$"
		   current-point-max t)
	    ;; The output is not finished: forget this error and exit.
	    (setq parsing-end error-msg)
	    (throw 'parsing-end nil))
	  ;; Find the end of this error.
	  (goto-char (match-end 0))
	  (forward-line)
	  (end-of-line)
	  (setq error-end (point))
	  ;; Get line number and text for searching the source.
	  (setq linenum (string-to-int (match-string 1)))
	  (setq error-text (regexp-quote (match-string 3))))

	 ((looking-at "^\\(Over\\|Under\\)full \\\\.*lines? \\([0-9]*\\)")
	  ;; It is a type (II) error.
	  (setq error-type tex-plus-error-parse-level)
	  ;; Find the end of this error.  Code in parts stolen from
	  ;; TeX-warning in tex-buf.el from AUC TeX.
	  (forward-line)
	  (end-of-line)
	  (while (or (equal (current-column) 79)
		     (save-excursion
		       (forward-line)
		       (save-match-data
			 ;; perhaps incomplete or/and incorrect.
			 ;; Maybe just exclude all lines with a \
			 ;; (except for "^! " lines)?
			 (looking-at "\\( \\\\\\|.*\\[\\]\\)"))))
	    (forward-line)
	    (end-of-line))
	  (setq error-end (point))
	  (when (>= error-end current-point-max)
	    ;; Output of this error is probably not finished:
	    ;; forget this error and exit.
	    (setq parsing-end error-msg)
	    (throw 'parsing-end nil))
	  ;; Get the line number of the source.
	  (setq linenum (string-to-int (match-string 2)))
	  ;; Getting the error-text is too hard.
	  ;; It is anyway not interesting if `tex-plus-error-parse-level' is nil.
	  (setq error-text nil)))

	;; Put appropriate syntax around the message.
	(add-text-properties
	 error-start error-end
	 (list 'syntax-table tex-plus-error-skip-syntax-table))

	(when error-type
	  ;; Search for and in the source.
	  (goto-char error-start)
	  (save-excursion
	    (with-syntax-table tex-plus-error-parse-syntax-table
	      (if (or (null last-error)
		      (save-restriction
			  (narrow-to-region (car last-error) (point))
			  (condition-case ()
			      (while (not (bobp)) (backward-list 1))
			    (error t))))
		    ;; Have to scan for the file.
		    (progn
		      (backward-up-list 1)
		      (skip-syntax-forward "(_")
		      (setq filename (thing-at-point 'filename))
		      (if (or (= 0 (length filename))
			      (not (file-exists-p filename)))
			  ;; We failed, but continue the parse.
			  ;; Here we could also give up with (error ...)
			  (message "Couldn't guess source file for error %s"
				   error-msg))
		      (if (equal filename (concat tex-zap-file ".tex"))
			  (set-buffer tex-last-buffer-texed)
			(set-buffer (find-file-noselect filename)))
		      (save-restriction
			(widen)
			(goto-line linenum)
			(or (null error-text)
			    (re-search-forward error-text nil t)
			    (re-search-backward error-text nil t))
			(setq error-source (point-marker))))
		  ;; No new file.
		  (set-buffer (marker-buffer (cdr last-error)))
		  (goto-char (cdr last-error))
		  (forward-line (- linenum last-linenum))
		  ;; First try a forward search for the error text,
		  ;; then a backward search limited by the last error
		  ;; in this file, if it exists.
		  (or (null error-text)
		      (re-search-forward error-text nil t)
		      (re-search-backward error-text (cdr last-error) t))
		  (setq error-source (point-marker)))
		(set-buffer err-buf)))

	  ;; Have we found more than enough errors?  Yes, if we are
	  ;; beyond the requirements, if there is a previous error,
	  ;; and if the following is true:  The error is in a new file
	  ;; or we have parsed already 50 errors.

	  ;; The limit 50 is a heuristic.  It avoids a long parse if
	  ;; something really bad happened with the tex run and one
	  ;; just wants to jump to the first few errors.

	  ;; Such a break should be allowed by compilation-mode:  An
	  ;; equivalent break happens once in a while when the grep
	  ;; process is running while parsing.

	  (when (and
		 (if limit-search
		     (>= error-msg limit-search) t)
		 (if find-at-least
		     (>= num-errors-found find-at-least) t)
		 compilation-error-list
		 (or (not (eq (marker-buffer error-source)
			      (marker-buffer (cdr last-error))))
		     (>= num-errors-found 50)))
	    ;; We forget this error and exit.
	    (setq parsing-end error-msg)
	    (throw 'parsing-end nil))

	  ;; Put it on the list and prepare for the next error.
	  (setq last-error (cons error-msg error-source)
		compilation-error-list (nconc compilation-error-list
					      (list last-error))
		num-errors-found (1+ num-errors-found)
		last-linenum linenum
		parsing-end error-end)

	  (if (>= num-errors-found 10)
	      (message "Parsing error messages...[%s]"
		       (+ num-errors-found
			  (length compilation-old-error-list)))))

	;; Go to the end of message and continue the loop.
	(goto-char error-end)))

    ;; Set `compilation-parsing-end' only here, in case of an error
    ;; while parsing.
    (if (and output-finished (eq parsing-end current-point-max))
	;; All errors are parsed.  Put compilation-parsing-end at the
	;; very end of buffer, moving with insertions.  This avoids
	;; unnecessary reparsing in some situations.
	(progn (set-marker compilation-parsing-end (point-max-marker))
	       (set-marker-insertion-type compilation-parsing-end t))
      (set-marker compilation-parsing-end parsing-end)))

  (message "Parsing error messages...done"))

(provide 'tex-plus)
============================================================