code.delx.au - gnu-emacs/blob - lisp/textmodes/tex-mode.el

   1 ;;; tex-mode.el --- TeX, LaTeX, and SliTeX mode commands.
   2
   3 ;; Copyright (C) 1985, 86, 89, 92, 94, 95, 96, 97, 98, 1999
   4 ;;       Free Software Foundation, Inc.
   5
   6 ;; Maintainer: FSF
   7 ;; Keywords: tex
   8
   9 ;; Contributions over the years by William F. Schelter, Dick King,
  10 ;; Stephen Gildea, Michael Prange, Jacob Gore, and Edward M. Reingold.
  11
  12 ;; This file is part of GNU Emacs.
  13
  14 ;; GNU Emacs is free software; you can redistribute it and/or modify
  15 ;; it under the terms of the GNU General Public License as published by
  16 ;; the Free Software Foundation; either version 2, or (at your option)
  17 ;; any later version.
  18
  19 ;; GNU Emacs is distributed in the hope that it will be useful,
  20 ;; but WITHOUT ANY WARRANTY; without even the implied warranty of
  21 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  22 ;; GNU General Public License for more details.
  23
  24 ;; You should have received a copy of the GNU General Public License
  25 ;; along with GNU Emacs; see the file COPYING.  If not, write to the
  26 ;; Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  27 ;; Boston, MA 02111-1307, USA.
  28
  29 ;;; Code:
  30
  31 ;; Pacify the byte-compiler
  32 (eval-when-compile
  33   (require 'compare-w)
  34   (require 'cl)
  35   (require 'skeleton))
  36
  37 (require 'shell)
  38 (require 'compile)
  39
  40 (defgroup tex-file nil
  41   "TeX files and directories"
  42   :prefix "tex-"
  43   :group 'tex)
  44
  45 (defgroup tex-run nil
  46   "Running external commands from TeX mode"
  47   :prefix "tex-"
  48   :group 'tex)
  49
  50 (defgroup tex-view nil
  51   "Viewing and printing TeX files"
  52   :prefix "tex-"
  53   :group 'tex)
  54
  55 ;;;###autoload
  56 (defcustom tex-shell-file-name nil
  57   "*If non-nil, the shell file name to run in the subshell used to run TeX."
  58   :type '(choice (const :tag "None" nil)
  59                  string)
  60   :group 'tex-run)
  61
  62 ;;;###autoload
  63 (defcustom tex-directory "."
  64   "*Directory in which temporary files are written.
  65 You can make this `/tmp' if your TEXINPUTS has no relative directories in it
  66 and you don't try to apply \\[tex-region] or \\[tex-buffer] when there are
  67 `\\input' commands with relative directories."
  68   :type 'directory
  69   :group 'tex-file)
  70
  71 ;;;###autoload
  72 (defcustom tex-first-line-header-regexp nil
  73   "Regexp for matching a first line which `tex-region' should include.
  74 If this is non-nil, it should be a regular expression string;
  75 if it matches the first line of the file,
  76 `tex-region' always includes the first line in the TeX run."
  77   :type '(choice (const :tag "None" nil)
  78                  regexp)
  79   :group 'tex-file)
  80
  81 ;;;###autoload
  82 (defcustom tex-main-file nil
  83   "*The main TeX source file which includes this buffer's file.
  84 The command `tex-file' runs TeX on the file specified by `tex-main-file'
  85 if the variable is non-nil."
  86   :type '(choice (const :tag "None" nil)
  87                  file)
  88   :group 'tex-file)
  89
  90 ;;;###autoload
  91 (defcustom tex-offer-save t
  92   "*If non-nil, ask about saving modified buffers before \\[tex-file] is run."
  93   :type 'boolean
  94   :group 'tex-file)
  95
  96 ;;;###autoload
  97 (defcustom tex-run-command "tex"
  98   "*Command used to run TeX subjob.
  99 TeX Mode sets `tex-command' to this string.
 100 See the documentation of that variable."
 101   :type 'string
 102   :group 'tex-run)
 103
 104 ;;;###autoload
 105 (defcustom latex-run-command "latex"
 106   "*Command used to run LaTeX subjob.
 107 LaTeX Mode sets `tex-command' to this string.
 108 See the documentation of that variable."
 109   :type 'string
 110   :group 'tex-run)
 111
 112 ;;;###autoload
 113 (defcustom slitex-run-command "slitex"
 114   "*Command used to run SliTeX subjob.
 115 SliTeX Mode sets `tex-command' to this string.
 116 See the documentation of that variable."
 117   :type 'string
 118   :group 'tex-run)
 119
 120 ;;;###autoload
 121 (defcustom tex-start-options-string "\\nonstopmode\\input"
 122   "*TeX options to use when running TeX.
 123 These precede the input file name. If nil, TeX runs without option.
 124 See the documentation of `tex-command'."
 125   :type '(radio (const :tag "Interactive \(nil\)" nil)
 126                 (const :tag "Nonstop \(\"\\nonstopmode\\input\"\)"
 127                        "\\nonstopmode\\input")
 128                 (string :tag "String at your choice"))
 129   :group 'tex-run
 130   :version "20.4")
 131
 132 (defvar standard-latex-block-names
 133   '("abstract"          "array"         "center"        "description"
 134     "displaymath"       "document"      "enumerate"     "eqnarray"
 135     "eqnarray*"         "equation"      "figure"        "figure*"
 136     "flushleft"         "flushright"    "itemize"       "letter"
 137     "list"              "minipage"      "picture"       "quotation"
 138     "quote"             "slide"         "sloppypar"     "tabbing"
 139     "table"             "table*"        "tabular"       "tabular*"
 140     "thebibliography"   "theindex*"     "titlepage"     "trivlist"
 141     "verbatim"          "verbatim*"     "verse"         "math")
 142   "Standard LaTeX block names.")
 143
 144 ;;;###autoload
 145 (defcustom latex-block-names nil
 146   "*User defined LaTeX block names.
 147 Combined with `standard-latex-block-names' for minibuffer completion."
 148   :type '(repeat string)
 149   :group 'tex-run)
 150
 151 ;;;###autoload
 152 (defcustom tex-bibtex-command "bibtex"
 153   "*Command used by `tex-bibtex-file' to gather bibliographic data.
 154 If this string contains an asterisk (`*'), that is replaced by the file name;
 155 otherwise, the file name, preceded by blank, is added at the end."
 156   :type 'string
 157   :group 'tex-run)
 158
 159 ;;;###autoload
 160 (defcustom tex-dvi-print-command "lpr -d"
 161   "*Command used by \\[tex-print] to print a .dvi file.
 162 If this string contains an asterisk (`*'), that is replaced by the file name;
 163 otherwise, the file name, preceded by blank, is added at the end."
 164   :type 'string
 165   :group 'tex-view)
 166
 167 ;;;###autoload
 168 (defcustom tex-alt-dvi-print-command "lpr -d"
 169   "*Command used by \\[tex-print] with a prefix arg to print a .dvi file.
 170 If this string contains an asterisk (`*'), that is replaced by the file name;
 171 otherwise, the file name, preceded by blank, is added at the end.
 172
 173 If two printers are not enough of a choice, you can set the variable
 174 `tex-alt-dvi-print-command' to an expression that asks what you want;
 175 for example,
 176
 177     (setq tex-alt-dvi-print-command
 178          '(format \"lpr -P%s\" (read-string \"Use printer: \")))
 179
 180 would tell \\[tex-print] with a prefix argument to ask you which printer to
 181 use."
 182   :type '(choice (string :tag "Command")
 183                  (sexp :tag "Expression"))
 184   :group 'tex-view)
 185
 186 ;;;###autoload
 187 (defcustom tex-dvi-view-command nil
 188   "*Command used by \\[tex-view] to display a `.dvi' file.
 189 If this string contains an asterisk (`*'), that is replaced by the file name;
 190 otherwise, the file name, preceded by blank, is added at the end.
 191
 192 This can be set conditionally so that the previewer used is suitable for the
 193 window system being used.  For example,
 194
 195     (setq tex-dvi-view-command
 196           (if (eq window-system 'x) \"xdvi\" \"dvi2tty * | cat -s\"))
 197
 198 would tell \\[tex-view] to use xdvi under X windows and to use dvi2tty
 199 otherwise."
 200   :type '(choice (const nil) string)
 201   :group 'tex-view)
 202
 203 ;;;###autoload
 204 (defcustom tex-show-queue-command "lpq"
 205   "*Command used by \\[tex-show-print-queue] to show the print queue.
 206 Should show the queue(s) that \\[tex-print] puts jobs on."
 207   :type 'string
 208   :group 'tex-view)
 209
 210 ;;;###autoload
 211 (defcustom tex-default-mode 'latex-mode
 212   "*Mode to enter for a new file that might be either TeX or LaTeX.
 213 This variable is used when it can't be determined whether the file
 214 is plain TeX or LaTeX or what because the file contains no commands.
 215 Normally set to either `plain-tex-mode' or `latex-mode'."
 216   :type 'function
 217   :group 'tex)
 218
 219 ;;;###autoload
 220 (defcustom tex-open-quote "``"
 221   "*String inserted by typing \\[tex-insert-quote] to open a quotation."
 222   :type 'string
 223   :group 'tex)
 224
 225 ;;;###autoload
 226 (defcustom tex-close-quote "''"
 227   "*String inserted by typing \\[tex-insert-quote] to close a quotation."
 228   :type 'string
 229   :group 'tex)
 230
 231 (defvar tex-last-temp-file nil
 232   "Latest temporary file generated by \\[tex-region] and \\[tex-buffer].
 233 Deleted when the \\[tex-region] or \\[tex-buffer] is next run, or when the
 234 tex shell terminates.")
 235
 236 (defvar tex-command nil
 237   "*Command to run TeX.
 238 If this string contains an asterisk \(`*'\), that is replaced by the file name\;
 239 otherwise the \(shell-quoted\) value of `tex-start-options-string' and
 240 the file name are added at the end, with blanks as separators.
 241
 242 In TeX, LaTeX, and SliTeX Mode this variable becomes buffer local.
 243 In these modes, use \\[set-variable] if you want to change it for the
 244 current buffer.")
 245
 246 (defvar tex-trailer nil
 247   "String appended after the end of a region sent to TeX by \\[tex-region].")
 248
 249 (defvar tex-start-of-header nil
 250   "Regular expression used by \\[tex-region] to find start of file's header.")
 251
 252 (defvar tex-end-of-header nil
 253   "Regular expression used by \\[tex-region] to find end of file's header.")
 254
 255 (defvar tex-shell-cd-command "cd"
 256   "Command to give to shell running TeX to change directory.
 257 The value of `tex-directory' is appended to this, separated by a space.")
 258
 259 (defvar tex-zap-file nil
 260   "Temporary file name used for text being sent as input to TeX.
 261 Should be a simple file name with no extension or directory specification.")
 262
 263 (defvar tex-last-buffer-texed nil
 264   "Buffer which was last TeXed.")
 265
 266 (defvar tex-print-file nil
 267   "File name that \\[tex-print] prints.
 268 Set by \\[tex-region], \\[tex-buffer], and \\[tex-file].")
 269
 270 (easy-mmode-defsyntax tex-mode-syntax-table
 271   '((?% . "<")
 272     (?\n . ">")
 273     (?\f . ">")
 274     (?\C-@ . "w")
 275     (?' . "w")
 276     (?@ . "_")
 277     (?* . "_")
 278     (?\t . " ")
 279     (?~ . " ")
 280     (?$ . "$$")
 281     (?\\ . "/")
 282     (?\" . ".")
 283     (?& . ".")
 284     (?_ . "."))
 285   "Syntax table used while in TeX mode.")
 286 \f
 287 ;;;;
 288 ;;;; Imenu support
 289 ;;;;
 290
 291 (defcustom latex-imenu-indent-string ". "
 292   "*String to add repeated in front of nested sectional units for Imenu.
 293 An alternative value is \" . \", if you use a font with a narrow period."
 294   :type 'string
 295   :group 'tex)
 296
 297 (defvar latex-section-alist
 298   '(("part" . 0) ("chapter" . 1)
 299     ("section" . 2) ("subsection" . 3)
 300     ("subsubsection" . 4)
 301     ("paragraph" . 5) ("subparagraph" . 6)))
 302
 303 (defvar latex-metasection-list
 304   '("documentstyle" "documentclass"
 305     "begin{document}" "end{document}"
 306     "appendix" "frontmatter" "mainmatter" "backmatter"))
 307
 308 (defun latex-imenu-create-index ()
 309   "Generate an alist for imenu from a LaTeX buffer."
 310   (let ((section-regexp
 311          (concat "\\\\" (regexp-opt (mapcar 'car latex-section-alist) t)
 312                  "\\*?[ \t]*{"))
 313         (metasection-regexp
 314          (concat "\\\\" (regexp-opt latex-metasection-list t)))
 315         i0 menu case-fold-search)
 316     (save-excursion
 317       ;; Find the top-most level in this file but don't allow it to be
 318       ;; any deeper than "section" (which is top-level in an article).
 319       (goto-char (point-min))
 320       (if (search-forward-regexp "\\\\part\\*?[ \t]*{" nil t)
 321           (setq i0 0)
 322         (if (search-forward-regexp "\\\\chapter\\*?[ \t]*{" nil t)
 323             (setq i0 1)
 324           (setq i0 2)))
 325
 326       ;; Look for chapters and sections.
 327       (goto-char (point-min))
 328       (while (search-forward-regexp section-regexp nil t)
 329         (let ((start (match-beginning 0))
 330               (here (point))
 331               (i (cdr (assoc (buffer-substring-no-properties
 332                               (match-beginning 1)
 333                               (match-end 1))
 334                              latex-section-alist))))
 335           (backward-char 1)
 336           (condition-case err
 337               (progn
 338                 ;; Using sexps allows some use of matching {...} inside
 339                 ;; titles.
 340                 (forward-sexp 1)
 341                 (push (cons (concat (apply 'concat
 342                                            (make-list
 343                                             (max 0 (- i i0))
 344                                             latex-imenu-indent-string))
 345                                     (buffer-substring-no-properties
 346                                      here (1- (point))))
 347                             start)
 348                       menu))
 349             (error nil))))
 350
 351       ;; Look for included material.
 352       (goto-char (point-min))
 353       (while (search-forward-regexp
 354               "\\\\\\(include\\|input\\|verbatiminput\\|bibliography\\)\
 355 \[ \t]*{\\([^}\n]+\\)}"
 356               nil t)
 357         (push (cons (concat "<<" (buffer-substring-no-properties
 358                                   (match-beginning 2)
 359                                   (match-end 2))
 360                             (if (= (char-after (match-beginning 1)) ?b)
 361                                 ".bbl"
 362                               ".tex"))
 363                     (match-beginning 0))
 364               menu))
 365
 366       ;; Look for \frontmatter, \mainmatter, \backmatter, and \appendix.
 367       (goto-char (point-min))
 368       (while (search-forward-regexp metasection-regexp nil t)
 369         (push (cons "--" (match-beginning 0)) menu))
 370
 371       ;; Sort in increasing buffer position order.
 372       (sort menu (function (lambda (a b) (< (cdr a) (cdr b))))))))
 373 \f
 374 ;;;;
 375 ;;;; Outline support
 376 ;;;;
 377
 378 (defvar latex-outline-regexp
 379   (concat "\\\\"
 380           (regexp-opt (append latex-metasection-list
 381                               (mapcar 'car latex-section-alist)) t)))
 382
 383 (defun latex-outline-level ()
 384   (if (looking-at latex-outline-regexp)
 385       (1+ (or (cdr (assoc (match-string 1) latex-section-alist)) -1))
 386     1000))
 387 \f
 388 ;;;;
 389 ;;;; Font-Lock support
 390 ;;;;
 391
 392 ;(defvar tex-font-lock-keywords
 393 ;  ;; Regexps updated with help from Ulrik Dickow <dickow@nbi.dk>.
 394 ;  '(("\\\\\\(begin\\|end\\|newcommand\\){\\([a-zA-Z0-9\\*]+\\)}"
 395 ;     2 font-lock-function-name-face)
 396 ;    ("\\\\\\(cite\\|label\\|pageref\\|ref\\){\\([^} \t\n]+\\)}"
 397 ;     2 font-lock-constant-face)
 398 ;    ;; It seems a bit dubious to use `bold' and `italic' faces since we might
 399 ;    ;; not be able to display those fonts.
 400 ;    ("{\\\\bf\\([^}]+\\)}" 1 'bold keep)
 401 ;    ("{\\\\\\(em\\|it\\|sl\\)\\([^}]+\\)}" 2 'italic keep)
 402 ;    ("\\\\\\([a-zA-Z@]+\\|.\\)" . font-lock-keyword-face)
 403 ;    ("^[ \t\n]*\\\\def[\\\\@]\\(\\w+\\)" 1 font-lock-function-name-face keep))
 404 ;  ;; Rewritten and extended for LaTeX2e by Ulrik Dickow <dickow@nbi.dk>.
 405 ;  '(("\\\\\\(begin\\|end\\|newcommand\\){\\([a-zA-Z0-9\\*]+\\)}"
 406 ;     2 font-lock-function-name-face)
 407 ;    ("\\\\\\(cite\\|label\\|pageref\\|ref\\){\\([^} \t\n]+\\)}"
 408 ;     2 font-lock-constant-face)
 409 ;    ("^[ \t]*\\\\def\\\\\\(\\(\\w\\|@\\)+\\)" 1 font-lock-function-name-face)
 410 ;    "\\\\\\([a-zA-Z@]+\\|.\\)"
 411 ;    ;; It seems a bit dubious to use `bold' and `italic' faces since we might
 412 ;    ;; not be able to display those fonts.
 413 ;    ;; LaTeX2e: \emph{This is emphasized}.
 414 ;    ("\\\\emph{\\([^}]+\\)}" 1 'italic keep)
 415 ;    ;; LaTeX2e: \textbf{This is bold}, \textit{...}, \textsl{...}
 416 ;    ("\\\\text\\(\\(bf\\)\\|it\\|sl\\){\\([^}]+\\)}"
 417 ;     3 (if (match-beginning 2) 'bold 'italic) keep)
 418 ;    ;; Old-style bf/em/it/sl.  Stop at `\\' and un-escaped `&', for tables.
 419 ;    ("\\\\\\(\\(bf\\)\\|em\\|it\\|sl\\)\\>\\(\\([^}&\\]\\|\\\\[^\\]\\)+\\)"
 420 ;     3 (if (match-beginning 2) 'bold 'italic) keep))
 421
 422 ;; Rewritten with the help of Alexandra Bac <abac@welcome.disi.unige.it>.
 423 (defconst tex-font-lock-keywords-1
 424   (eval-when-compile
 425     (let* (;; Names of commands whose arg should be fontified as heading, etc.
 426            (headings (regexp-opt
 427                       '("title"  "begin" "end" "chapter" "part"
 428                         "section" "subsection" "subsubsection"
 429                         "paragraph" "subparagraph" "subsubparagraph"
 430                         "newcommand" "renewcommand" "newenvironment"
 431                         "newtheorem")
 432                       t))
 433            (variables (regexp-opt
 434                        '("newcounter" "newcounter*" "setcounter" "addtocounter"
 435                          "setlength" "addtolength" "settowidth")
 436                        t))
 437            (includes (regexp-opt
 438                       '("input" "include" "includeonly" "bibliography"
 439                         "epsfig" "psfig" "epsf" "nofiles" "usepackage"
 440                         "includegraphics" "includegraphics*")
 441                       t))
 442            ;; Miscellany.
 443            (slash "\\\\")
 444            (opt "\\(\\[[^]]*\\]\\)?")
 445            (arg "{\\(\\(?:[^{}\\]+\\|\\\\.\\|{[^}]*}\\)+\\)"))
 446       (list
 447        ;; Heading args.
 448        (list (concat slash headings "\\*?" opt arg)
 449              ;; If ARG ends up matching too much (if the {} don't match, f.ex)
 450              ;; jit-lock will do funny things: when updating the buffer
 451              ;; the re-highlighting is only done locally so it will just
 452              ;; match the local line, but defer-contextually will
 453              ;; match more lines at a time, so ARG will end up matching
 454              ;; a lot more, which might suddenly include a comment
 455              ;; so you get things highlighted bold when you type them
 456              ;; but they get turned back to normal a little while later
 457              ;; because "there's already a face there".
 458              ;; Using `keep' works around this un-intuitive behavior as well
 459              ;; as improves the behavior in the very rare case where you do have
 460              ;; a comment in ARG.
 461              3 'font-lock-function-name-face 'keep)
 462        ;; Variable args.
 463        (list (concat slash variables arg) 2 'font-lock-variable-name-face)
 464        ;; Include args.
 465        (list (concat slash includes opt arg) 3 'font-lock-builtin-face)
 466        ;; Definitions.  I think.
 467        '("^[ \t]*\\\\def\\\\\\(\\(\\w\\|@\\)+\\)"
 468          1 font-lock-function-name-face))))
 469   "Subdued expressions to highlight in TeX modes.")
 470
 471 (defconst tex-font-lock-keywords-2
 472   (append tex-font-lock-keywords-1
 473    (eval-when-compile
 474      (let* (;;
 475             ;; Names of commands whose arg should be fontified with fonts.
 476             (bold (regexp-opt '("textbf" "textsc" "textup"
 477                                 "boldsymbol" "pmb") t))
 478             (italic (regexp-opt '("textit" "textsl" "emph") t))
 479             (type (regexp-opt '("texttt" "textmd" "textrm" "textsf") t))
 480             ;;
 481             ;; Names of commands whose arg should be fontified as a citation.
 482             (citations (regexp-opt
 483                         '("label" "ref" "pageref" "vref" "eqref"
 484                           "cite" "nocite" "index" "glossary"
 485                           ;; These are text, rather than citations.
 486                           ;; "caption" "footnote" "footnotemark" "footnotetext"
 487                           )
 488                         t))
 489             ;;
 490             ;; Names of commands that should be fontified.
 491             (specials (regexp-opt
 492                        '("\\"
 493                          "linebreak" "nolinebreak" "pagebreak" "nopagebreak"
 494                          "newline" "newpage" "clearpage" "cleardoublepage"
 495                          "displaybreak" "allowdisplaybreaks" "enlargethispage")
 496                        t))
 497             (general "\\([a-zA-Z@]+\\**\\|[^ \t\n]\\)")
 498             ;;
 499             ;; Miscellany.
 500             (slash "\\\\")
 501             (opt "\\(\\[[^]]*\\]\\)?")
 502             (arg "{\\(\\(?:[^{}\\]+\\|\\\\.\\|{[^}]*}\\)+\\)"))
 503        (list
 504         ;;
 505         ;; Citation args.
 506         (list (concat slash citations opt arg) 3 'font-lock-constant-face)
 507         ;;
 508         ;; Command names, special and general.
 509         (cons (concat slash specials) 'font-lock-warning-face)
 510         (concat slash general)
 511         ;;
 512         ;; Font environments.  It seems a bit dubious to use `bold' etc. faces
 513         ;; since we might not be able to display those fonts.
 514         (list (concat slash bold arg) 2 '(quote bold) 'append)
 515         (list (concat slash italic arg) 2 '(quote italic) 'append)
 516         ;; (list (concat slash type arg) 2 '(quote bold-italic) 'append)
 517         ;;
 518         ;; Old-style bf/em/it/sl.  Stop at `\\' and un-escaped `&', for tables.
 519         (list (concat "\\\\\\(\\(bf\\)\\|em\\|it\\|sl\\)\\>"
 520                       "\\(\\([^}&\\]\\|\\\\[^\\]\\)+\\)")
 521               3 '(if (match-beginning 2) 'bold 'italic) 'append)))))
 522    "Gaudy expressions to highlight in TeX modes.")
 523
 524 (defvar tex-font-lock-keywords tex-font-lock-keywords-1
 525   "Default expressions to highlight in TeX modes.")
 526
 527
 528 (defface tex-math-face
 529   '((t :inherit font-lock-string-face))
 530   "Face used to highlight TeX math expressions.")
 531 (defvar tex-math-face 'tex-math-face)
 532
 533 ;; Use string syntax but math face for $...$.
 534 (defun tex-font-lock-syntactic-face-function (state)
 535   (if (nth 3 state) tex-math-face font-lock-comment-face))
 536
 537 \f
 538 (defun tex-define-common-keys (keymap)
 539   "Define the keys that we want defined both in TeX mode and in the TeX shell."
 540   (define-key keymap "\C-c\C-k" 'tex-kill-job)
 541   (define-key keymap "\C-c\C-l" 'tex-recenter-output-buffer)
 542   (define-key keymap "\C-c\C-q" 'tex-show-print-queue)
 543   (define-key keymap "\C-c\C-p" 'tex-print)
 544   (define-key keymap "\C-c\C-v" 'tex-view)
 545
 546   (define-key keymap [menu-bar tex] (cons "TeX" (make-sparse-keymap "TeX")))
 547
 548   (define-key keymap [menu-bar tex tex-kill-job]
 549     '(menu-item "Tex Kill" tex-kill-job :enable (tex-shell-running)))
 550   (define-key keymap [menu-bar tex tex-recenter-output-buffer]
 551     '(menu-item "Tex Recenter" tex-recenter-output-buffer
 552                 :enable (get-buffer "*tex-shell*")))
 553   (define-key keymap [menu-bar tex tex-show-print-queue]
 554     '("Show Print Queue" . tex-show-print-queue))
 555   (define-key keymap [menu-bar tex tex-alt-print]
 556     '(menu-item "Tex Print (alt printer)" tex-alt-print
 557                 :enable (stringp tex-print-file)))
 558   (define-key keymap [menu-bar tex tex-print]
 559     '(menu-item "Tex Print" tex-print :enable (stringp tex-print-file)))
 560   (define-key keymap [menu-bar tex tex-view]
 561     '(menu-item "Tex View" tex-view :enable (stringp tex-print-file))))
 562
 563 (defvar tex-mode-map
 564   (let ((map (make-sparse-keymap)))
 565     (tex-define-common-keys map)
 566     (define-key map "\"" 'tex-insert-quote)
 567     (define-key map "(" 'skeleton-pair-insert-maybe)
 568     (define-key map "{" 'skeleton-pair-insert-maybe)
 569     (define-key map "[" 'skeleton-pair-insert-maybe)
 570     (define-key map "$" 'skeleton-pair-insert-maybe)
 571     (define-key map "\n" 'tex-terminate-paragraph)
 572     (define-key map "\M-\r" 'latex-insert-item)
 573     (define-key map "\C-c}" 'up-list)
 574     (define-key map "\C-c{" 'tex-insert-braces)
 575     (define-key map "\C-c\C-r" 'tex-region)
 576     (define-key map "\C-c\C-b" 'tex-buffer)
 577     (define-key map "\C-c\C-f" 'tex-file)
 578     (define-key map "\C-c\C-i" 'tex-bibtex-file)
 579     (define-key map "\C-c\C-o" 'tex-latex-block)
 580     (define-key map "\C-c\C-e" 'tex-close-latex-block)
 581     (define-key map "\C-c\C-u" 'tex-goto-last-unclosed-latex-block)
 582     (define-key map "\C-c\C-m" 'tex-feed-input)
 583     (define-key map [(control return)] 'tex-feed-input)
 584     (define-key map [menu-bar tex tex-bibtex-file]
 585       '("BibTeX File" . tex-bibtex-file))
 586     (define-key map [menu-bar tex tex-validate-region]
 587       '(menu-item "Validate Region" tex-validate-region :enable mark-active))
 588     (define-key map [menu-bar tex tex-validate-buffer]
 589       '("Validate Buffer" . tex-validate-buffer))
 590     (define-key map [menu-bar tex tex-region]
 591       '(menu-item "TeX Region" tex-region :enable mark-active))
 592     (define-key map [menu-bar tex tex-buffer]
 593       '("TeX Buffer" . tex-buffer))
 594     (define-key map [menu-bar tex tex-file] '("TeX File" . tex-file))
 595     map)
 596  "Keymap for TeX modes.")
 597
 598 (defvar tex-shell-map
 599   (let ((m (make-sparse-keymap)))
 600     (set-keymap-parent m shell-mode-map)
 601     (tex-define-common-keys m)
 602     m)
 603   "Keymap for the TeX shell.
 604 Inherits `shell-mode-map' with a few additions.")
 605
 606 (defvar tex-face-alist
 607   '((bold . "{\\bf ")
 608     (italic . "{\\it ")
 609     (bold-italic . "{\\bi ")            ; hypothetical
 610     (underline . "\\underline{")
 611     (default . "{\\rm "))
 612   "Alist of face and TeX font name for facemenu.")
 613
 614 (defvar tex-latex-face-alist
 615   `((italic . "{\\em ")
 616     ,@tex-face-alist)
 617   "Alist of face and LaTeX font name for facemenu.")
 618
 619 ;;; This would be a lot simpler if we just used a regexp search,
 620 ;;; but then it would be too slow.
 621 ;;;###autoload
 622 (defun tex-mode ()
 623   "Major mode for editing files of input for TeX, LaTeX, or SliTeX.
 624 Tries to determine (by looking at the beginning of the file) whether
 625 this file is for plain TeX, LaTeX, or SliTeX and calls `plain-tex-mode',
 626 `latex-mode', or `slitex-mode', respectively.  If it cannot be determined,
 627 such as if there are no commands in the file, the value of `tex-default-mode'
 628 says which mode to use."
 629   (interactive)
 630   (let ((mode tex-default-mode) slash comment)
 631     (save-excursion
 632       (goto-char (point-min))
 633       (while (and (setq slash (search-forward "\\" nil t))
 634                   (setq comment (let ((search-end (point)))
 635                                   (save-excursion
 636                                     (beginning-of-line)
 637                                     (search-forward "%" search-end t))))))
 638       (when (and slash (not comment))
 639         (setq mode
 640               (if (looking-at
 641                    (eval-when-compile
 642                      (concat
 643                       (regexp-opt '("documentstyle" "documentclass"
 644                                     "begin" "section" "part" "chapter") 'words)
 645                       "\\|NeedsTeXFormat{LaTeX")))
 646                   (if (looking-at
 647                        "document\\(style\\|class\\)\\(\\[.*\\]\\)?{slides}")
 648                       'slitex-mode
 649                     'latex-mode)
 650                 'plain-tex-mode))))
 651     (funcall mode)))
 652
 653 ;;;###autoload
 654 (defalias 'TeX-mode 'tex-mode)
 655 ;;;###autoload
 656 (defalias 'plain-TeX-mode 'plain-tex-mode)
 657 ;;;###autoload
 658 (defalias 'LaTeX-mode 'latex-mode)
 659
 660 ;;;###autoload
 661 (define-derived-mode plain-tex-mode text-mode "TeX"
 662   "Major mode for editing files of input for plain TeX.
 663 Makes $ and } display the characters they match.
 664 Makes \" insert `` when it seems to be the beginning of a quotation,
 665 and '' when it appears to be the end; it inserts \" only after a \\.
 666
 667 Use \\[tex-region] to run TeX on the current region, plus a \"header\"
 668 copied from the top of the file (containing macro definitions, etc.),
 669 running TeX under a special subshell.  \\[tex-buffer] does the whole buffer.
 670 \\[tex-file] saves the buffer and then processes the file.
 671 \\[tex-print] prints the .dvi file made by any of these.
 672 \\[tex-view] previews the .dvi file made by any of these.
 673 \\[tex-bibtex-file] runs bibtex on the file of the current buffer.
 674
 675 Use \\[tex-validate-buffer] to check buffer for paragraphs containing
 676 mismatched $'s or braces.
 677
 678 Special commands:
 679 \\{tex-mode-map}
 680
 681 Mode variables:
 682 tex-run-command
 683         Command string used by \\[tex-region] or \\[tex-buffer].
 684 tex-directory
 685         Directory in which to create temporary files for TeX jobs
 686         run by \\[tex-region] or \\[tex-buffer].
 687 tex-dvi-print-command
 688         Command string used by \\[tex-print] to print a .dvi file.
 689 tex-alt-dvi-print-command
 690         Alternative command string used by \\[tex-print] (when given a prefix
 691         argument) to print a .dvi file.
 692 tex-dvi-view-command
 693         Command string used by \\[tex-view] to preview a .dvi file.
 694 tex-show-queue-command
 695         Command string used by \\[tex-show-print-queue] to show the print
 696         queue that \\[tex-print] put your job on.
 697
 698 Entering Plain-tex mode runs the hook `text-mode-hook', then the hook
 699 `tex-mode-hook', and finally the hook `plain-tex-mode-hook'.  When the
 700 special subshell is initiated, the hook `tex-shell-hook' is run."
 701   (tex-common-initialization)
 702   (setq tex-command tex-run-command)
 703   (setq tex-start-of-header "%\\*\\*start of header")
 704   (setq tex-end-of-header "%\\*\\*end of header")
 705   (setq tex-trailer "\\bye\n")
 706   (run-hooks 'tex-mode-hook))
 707
 708 ;;;###autoload
 709 (define-derived-mode latex-mode text-mode "LaTeX"
 710   "Major mode for editing files of input for LaTeX.
 711 Makes $ and } display the characters they match.
 712 Makes \" insert `` when it seems to be the beginning of a quotation,
 713 and '' when it appears to be the end; it inserts \" only after a \\.
 714
 715 Use \\[tex-region] to run LaTeX on the current region, plus the preamble
 716 copied from the top of the file (containing \\documentstyle, etc.),
 717 running LaTeX under a special subshell.  \\[tex-buffer] does the whole buffer.
 718 \\[tex-file] saves the buffer and then processes the file.
 719 \\[tex-print] prints the .dvi file made by any of these.
 720 \\[tex-view] previews the .dvi file made by any of these.
 721 \\[tex-bibtex-file] runs bibtex on the file of the current buffer.
 722
 723 Use \\[tex-validate-buffer] to check buffer for paragraphs containing
 724 mismatched $'s or braces.
 725
 726 Special commands:
 727 \\{tex-mode-map}
 728
 729 Mode variables:
 730 latex-run-command
 731         Command string used by \\[tex-region] or \\[tex-buffer].
 732 tex-directory
 733         Directory in which to create temporary files for LaTeX jobs
 734         run by \\[tex-region] or \\[tex-buffer].
 735 tex-dvi-print-command
 736         Command string used by \\[tex-print] to print a .dvi file.
 737 tex-alt-dvi-print-command
 738         Alternative command string used by \\[tex-print] (when given a prefix
 739         argument) to print a .dvi file.
 740 tex-dvi-view-command
 741         Command string used by \\[tex-view] to preview a .dvi file.
 742 tex-show-queue-command
 743         Command string used by \\[tex-show-print-queue] to show the print
 744         queue that \\[tex-print] put your job on.
 745
 746 Entering Latex mode runs the hook `text-mode-hook', then
 747 `tex-mode-hook', and finally `latex-mode-hook'.  When the special
 748 subshell is initiated, `tex-shell-hook' is run."
 749   (tex-common-initialization)
 750   (setq tex-command latex-run-command)
 751   (setq tex-start-of-header "\\\\document\\(style\\|class\\)")
 752   (setq tex-end-of-header "\\\\begin\\s-*{document}")
 753   (setq tex-trailer "\\end\\s-*{document}\n")
 754   ;; A line containing just $$ is treated as a paragraph separator.
 755   ;; A line starting with $$ starts a paragraph,
 756   ;; but does not separate paragraphs if it has more stuff on it.
 757   (setq paragraph-start
 758         (concat "[\f%]\\|[ \t]*\\($\\|\\$\\$\\|"
 759                 "\\\\[][]\\|"
 760                 "\\\\" (regexp-opt (append
 761                                     (mapcar 'car latex-section-alist)
 762                                     '("begin" "label" "end"
 763                                       "item" "bibitem" "newline" "noindent"
 764                                       "newpage" "footnote" "marginpar"
 765                                       "parbox" "caption")) t)
 766                 "\\>\\|\\\\[a-z]*" (regexp-opt '("space" "skip" "page") t)
 767                 "\\>\\)"))
 768   (setq paragraph-separate
 769         (concat "[\f%]\\|[ \t]*\\($\\|"
 770                 "\\\\[][]\\|"
 771                 "\\\\" (regexp-opt (append
 772                                     (mapcar 'car latex-section-alist)
 773                                     '("begin" "label" "end" )) t)
 774                 "\\>\\|\\\\\\(" (regexp-opt '("item" "bibitem" "newline"
 775                                               "noindent" "newpage" "footnote"
 776                                               "marginpar" "parbox" "caption"))
 777                 "\\|\\$\\$\\|[a-z]*\\(space\\|skip\\|page[a-z]*\\)"
 778                 "\\>\\)[ \t]*\\($\\|%\\)\\)"))
 779   (set (make-local-variable 'imenu-create-index-function)
 780        'latex-imenu-create-index)
 781   (set (make-local-variable 'tex-face-alist) tex-latex-face-alist)
 782   (set (make-local-variable 'fill-nobreak-predicate)
 783        'latex-fill-nobreak-predicate)
 784   (set (make-local-variable 'indent-line-function) 'latex-indent)
 785   (set (make-local-variable 'fill-indent-according-to-mode) t)
 786   (set (make-local-variable 'outline-regexp) latex-outline-regexp)
 787   (set (make-local-variable 'outline-level) 'latex-outline-level)
 788   (set (make-local-variable 'forward-sexp-function) 'latex-forward-sexp)
 789   (set (make-local-variable 'skeleton-end-hook) 'latex-skeleton-end-hook)
 790   (run-hooks 'tex-mode-hook))
 791
 792 ;;;###autoload
 793 (define-derived-mode slitex-mode latex-mode "SliTeX"
 794   "Major mode for editing files of input for SliTeX.
 795 Makes $ and } display the characters they match.
 796 Makes \" insert `` when it seems to be the beginning of a quotation,
 797 and '' when it appears to be the end; it inserts \" only after a \\.
 798
 799 Use \\[tex-region] to run SliTeX on the current region, plus the preamble
 800 copied from the top of the file (containing \\documentstyle, etc.),
 801 running SliTeX under a special subshell.  \\[tex-buffer] does the whole buffer.
 802 \\[tex-file] saves the buffer and then processes the file.
 803 \\[tex-print] prints the .dvi file made by any of these.
 804 \\[tex-view] previews the .dvi file made by any of these.
 805 \\[tex-bibtex-file] runs bibtex on the file of the current buffer.
 806
 807 Use \\[tex-validate-buffer] to check buffer for paragraphs containing
 808 mismatched $'s or braces.
 809
 810 Special commands:
 811 \\{tex-mode-map}
 812
 813 Mode variables:
 814 slitex-run-command
 815         Command string used by \\[tex-region] or \\[tex-buffer].
 816 tex-directory
 817         Directory in which to create temporary files for SliTeX jobs
 818         run by \\[tex-region] or \\[tex-buffer].
 819 tex-dvi-print-command
 820         Command string used by \\[tex-print] to print a .dvi file.
 821 tex-alt-dvi-print-command
 822         Alternative command string used by \\[tex-print] (when given a prefix
 823         argument) to print a .dvi file.
 824 tex-dvi-view-command
 825         Command string used by \\[tex-view] to preview a .dvi file.
 826 tex-show-queue-command
 827         Command string used by \\[tex-show-print-queue] to show the print
 828         queue that \\[tex-print] put your job on.
 829
 830 Entering SliTeX mode runs the hook `text-mode-hook', then the hook
 831 `tex-mode-hook', then the hook `latex-mode-hook', and finally the hook
 832 `slitex-mode-hook'.  When the special subshell is initiated, the hook
 833 `tex-shell-hook' is run."
 834   (setq tex-command slitex-run-command)
 835   (setq tex-start-of-header "\\\\documentstyle{slides}\\|\\\\documentclass{slides}"))
 836
 837 (defun tex-common-initialization ()
 838   (use-local-map tex-mode-map)
 839   (set-syntax-table tex-mode-syntax-table)
 840   ;; Regexp isearch should accept newline and formfeed as whitespace.
 841   (set (make-local-variable 'search-whitespace-regexp) "[ \t\r\n\f]+")
 842   ;; A line containing just $$ is treated as a paragraph separator.
 843   (set (make-local-variable 'paragraph-start)
 844        "[ \t]*$\\|[\f\\\\%]\\|[ \t]*\\$\\$")
 845   ;; A line starting with $$ starts a paragraph,
 846   ;; but does not separate paragraphs if it has more stuff on it.
 847   (set (make-local-variable 'paragraph-separate)
 848         "[ \t]*$\\|[\f\\\\%]\\|[ \t]*\\$\\$[ \t]*$")
 849   (set (make-local-variable 'comment-start) "%")
 850   (set (make-local-variable 'comment-add) 1)
 851   (set (make-local-variable 'comment-start-skip)
 852        "\\(\\(^\\|[^\\]\\)\\(\\\\\\\\\\)*\\)\\(%+ *\\)")
 853   (set (make-local-variable 'parse-sexp-ignore-comments) t)
 854   (set (make-local-variable 'compare-windows-whitespace)
 855        'tex-categorize-whitespace)
 856   (set (make-local-variable 'facemenu-add-face-function)
 857        (lambda (face end)
 858          (let ((face-text (cdr (assq face tex-face-alist))))
 859            (if face-text
 860                face-text
 861              (error "Face %s not configured for %s mode" face mode-name)))))
 862   (set (make-local-variable 'facemenu-end-add-face) "}")
 863   (set (make-local-variable 'facemenu-remove-face-function) t)
 864   (set (make-local-variable 'font-lock-defaults)
 865        '((tex-font-lock-keywords
 866           tex-font-lock-keywords-1 tex-font-lock-keywords-2)
 867          nil nil ((?$ . "\"")) nil
 868          ;; Who ever uses that anyway ???
 869          (font-lock-mark-block-function . mark-paragraph)
 870          (font-lock-syntactic-face-function
 871           . tex-font-lock-syntactic-face-function)))
 872   (make-local-variable 'tex-command)
 873   (make-local-variable 'tex-start-of-header)
 874   (make-local-variable 'tex-end-of-header)
 875   (make-local-variable 'tex-trailer))
 876
 877 (defun tex-categorize-whitespace (backward-limit)
 878   ;; compare-windows-whitespace is set to this.
 879   ;; This is basically a finite-state machine.
 880   ;; Returns a symbol telling how TeX would treat
 881   ;; the whitespace we are looking at: null, space, or par.
 882   (let ((category 'null)
 883         (not-finished t))
 884     (skip-chars-backward " \t\n\f" backward-limit)
 885     (while not-finished
 886       (cond ((looking-at "[ \t]+")
 887              (goto-char (match-end 0))
 888              (if (eq category 'null)
 889                  (setq category 'space)))
 890             ((looking-at "\n")
 891              (cond ((eq category 'newline)
 892                     (setq category 'par)
 893                     (setq not-finished nil))
 894                    (t
 895                     (setq category 'newline) ;a strictly internal state
 896                     (goto-char (match-end 0)))))
 897             ((looking-at "\f+")
 898              (setq category 'par)
 899              (setq not-finished nil))
 900             (t
 901              (setq not-finished nil))))
 902     (skip-chars-forward " \t\n\f")
 903     (if (eq category 'newline)
 904         'space                          ;TeX doesn't distinguish
 905       category)))
 906
 907 (defun tex-insert-quote (arg)
 908   "Insert the appropriate quote marks for TeX.
 909 Inserts the value of `tex-open-quote' (normally ``) or `tex-close-quote'
 910 \(normally '') depending on the context.  With prefix argument, always
 911 inserts \" characters."
 912   (interactive "*P")
 913   (if arg
 914       (self-insert-command (prefix-numeric-value arg))
 915     (insert
 916      (cond ((= (preceding-char) ?\\) ?\")
 917            ((memq (char-syntax (preceding-char)) '(?\( ?> ?\ )) tex-open-quote)
 918            (t tex-close-quote)))))
 919
 920 (defun tex-validate-buffer ()
 921   "Check current buffer for paragraphs containing mismatched braces or $s.
 922 Their positions are recorded in the buffer `*Occur*'.
 923 To find a particular invalidity from `*Occur*', switch to that buffer
 924 and type C-c C-c or click with mouse-2
 925 on the line for the invalidity you want to see."
 926   (interactive)
 927   (let ((buffer (current-buffer))
 928         (prevpos (point-min))
 929         (linenum nil)
 930         (num-matches 0))
 931     (with-output-to-temp-buffer "*Occur*"
 932       (princ "Mismatches:\n")
 933       (save-excursion
 934         (set-buffer standard-output)
 935         (occur-mode)
 936         (setq occur-buffer buffer)
 937         (setq occur-nlines 0))
 938       (save-excursion
 939         (goto-char (point-max))
 940         (while (and (not (input-pending-p)) (not (bobp)))
 941           (let ((end (point))
 942                 prev-end)
 943             ;; Scan the previous paragraph for invalidities.
 944             (if (search-backward "\n\n" nil t)
 945                 (progn
 946                   (setq prev-end (point))
 947                   (forward-char 2))
 948               (goto-char (setq prev-end (point-min))))
 949             (or (tex-validate-region (point) end)
 950                 (let* ((oend end)
 951                        (end (save-excursion (forward-line 1) (point)))
 952                        start tem)
 953                   (beginning-of-line)
 954                   (setq start (point))
 955                   ;; Keep track of line number as we scan,
 956                   ;; in a cumulative fashion.
 957                   (if linenum
 958                       (setq linenum (- linenum (count-lines prevpos (point))))
 959                     (setq linenum (1+ (count-lines 1 start))))
 960                   (setq prevpos (point))
 961                   ;; Mention this mismatch in *Occur*.
 962                   ;; Since we scan from end of buffer to beginning,
 963                   ;; add each mismatch at the beginning of *Occur*.
 964                   (save-excursion
 965                     (setq tem (point-marker))
 966                     (set-buffer standard-output)
 967                     (goto-char (point-min))
 968                     ;; Skip "Mismatches:" header line.
 969                     (forward-line 1)
 970                     (setq num-matches (1+ num-matches))
 971                     (insert-buffer-substring buffer start end)
 972                     (let (text-beg (text-end (point-marker)))
 973                       (forward-char (- start end))
 974                       (setq text-beg (point-marker))
 975                       (insert (format "%3d: " linenum))
 976                       (put-text-property text-beg (- text-end 1)
 977                                          'mouse-face 'highlight)
 978                       (put-text-property text-beg (- text-end 1)
 979                                          'occur tem)))))
 980             (goto-char prev-end))))
 981       (with-current-buffer standard-output
 982         (if (eq num-matches 0)
 983             (insert "None!\n"))
 984         (if (interactive-p)
 985             (message "%d mismatches found" num-matches))))))
 986
 987 (defun tex-validate-region (start end)
 988   "Check for mismatched braces or $'s in region.
 989 Returns t if no mismatches.  Returns nil and moves point to suspect
 990 area if a mismatch is found."
 991   (interactive "r")
 992   (let ((failure-point nil) (max-possible-sexps (- end start)))
 993     (save-excursion
 994       (condition-case ()
 995           (save-restriction
 996             (narrow-to-region start end)
 997             ;; First check that the open and close parens balance in numbers.
 998             (goto-char start)
 999             (while (<= 0 (setq max-possible-sexps (1- max-possible-sexps)))
1000               (forward-sexp 1))
1001             ;; Now check that like matches like.
1002             (goto-char start)
1003             (while (progn (skip-syntax-forward "^(")
1004                           (not (eobp)))
1005               (let ((match (matching-paren (following-char))))
1006                 (save-excursion
1007                   (forward-sexp 1)
1008                   (or (= (preceding-char) match)
1009                       (error "Mismatched parentheses"))))
1010               (forward-char 1)))
1011         (error
1012          (skip-syntax-forward " .>")
1013          (setq failure-point (point)))))
1014     (if failure-point (goto-char failure-point))
1015     (not failure-point)))
1016
1017 (defun tex-terminate-paragraph (inhibit-validation)
1018   "Insert two newlines, breaking a paragraph for TeX.
1019 Check for mismatched braces or $s in paragraph being terminated.
1020 A prefix arg inhibits the checking."
1021   (interactive "*P")
1022   (or inhibit-validation
1023       (save-excursion
1024         (tex-validate-region
1025          (save-excursion
1026            (search-backward "\n\n" nil 'move)
1027            (point))
1028          (point)))
1029       (message "Paragraph being closed appears to contain a mismatch"))
1030   (insert "\n\n"))
1031
1032 (defun tex-insert-braces ()
1033   "Make a pair of braces and be poised to type inside of them."
1034   (interactive "*")
1035   (insert ?\{)
1036   (save-excursion
1037     (insert ?})))
1038
1039 ;; This function is used as the value of fill-nobreak-predicate
1040 ;; in LaTeX mode.  Its job is to prevent line-breaking inside
1041 ;; of a \verb construct.
1042 (defun latex-fill-nobreak-predicate ()
1043   (let ((opoint (point))
1044         inside)
1045     (save-excursion
1046       (save-restriction
1047         (beginning-of-line)
1048         (narrow-to-region (point) opoint)
1049         (while (re-search-forward "\\\\verb\\(.\\)" nil t)
1050           (unless (re-search-forward (regexp-quote (match-string 1)) nil t)
1051             (setq inside t)))))
1052     inside))
1053
1054 (defvar latex-block-default "enumerate")
1055
1056 (defun latex-skeleton-end-hook ()
1057   (unless (or (eolp) (save-excursion (move-to-left-margin)
1058                                      (not (looking-at paragraph-separate))))
1059     (newline-and-indent)))
1060
1061 ;;; Like tex-insert-braces, but for LaTeX.
1062 (define-skeleton tex-latex-block
1063   "Create a matching pair of lines \\begin[OPT]{NAME} and \\end{NAME} at point.
1064 Puts point on a blank line between them."
1065   (let ((choice (completing-read (format "LaTeX block name [%s]: "
1066                                          latex-block-default)
1067                                  (mapcar 'list
1068                                          (append standard-latex-block-names
1069                                                  latex-block-names))
1070                                  nil nil nil nil latex-block-default)))
1071     (setq latex-block-default choice)
1072     (unless (or (member choice standard-latex-block-names)
1073                 (member choice latex-block-names))
1074       ;; Remember new block names for later completion.
1075       (push choice latex-block-names))
1076     choice)
1077   (unless (save-excursion (beginning-of-line) (looking-at "[ \t]*$")) '\n)
1078   "\\begin{" str ?\}
1079   ?\[ (skeleton-read "[options]: ") & ?\] | -1
1080   > \n _ \n
1081   "\\end{" str ?\} >)
1082
1083 (define-skeleton latex-insert-item
1084   "Insert a \item macro."
1085   nil
1086   (unless (save-excursion (beginning-of-line) (looking-at "[ \t]*$")) '\n)
1087   "\\item " >)
1088
1089 \f
1090 ;;;;
1091 ;;;; LaTeX syntax navigation
1092 ;;;;
1093
1094 (defun tex-last-unended-begin ()
1095   "Leave point at the beginning of the last `\\begin{...}' that is unended."
1096   (while (and (re-search-backward "\\\\\\(begin\\|end\\)\\s *{")
1097               (looking-at "\\\\end"))
1098     (tex-last-unended-begin)))
1099
1100 (defun tex-next-unmatched-end ()
1101   "Leave point at the end of the next `\\end' that is unended."
1102   (while (and (re-search-forward "\\\\\\(begin\\|end\\)\\s *{[^}]+}")
1103               (save-excursion (goto-char (match-beginning 0))
1104                               (looking-at "\\\\begin")))
1105     (tex-next-unmatched-end)))
1106
1107 (defun tex-goto-last-unclosed-latex-block ()
1108   "Move point to the last unclosed \\begin{...}.
1109 Mark is left at original location."
1110   (interactive)
1111   (let ((spot))
1112     (save-excursion
1113       (condition-case nil
1114           (tex-last-unended-begin)
1115         (error (error "Couldn't find unended \\begin")))
1116       (setq spot (point)))
1117     (push-mark)
1118     (goto-char spot)))
1119
1120 (defun latex-backward-sexp-1 ()
1121   "Like (backward-sexp 1) but aware of multi-char elements."
1122   (let ((pos (point))
1123         (forward-sexp-function))
1124     (backward-sexp 1)
1125     (if (looking-at "\\\\begin\\>")
1126         (signal 'scan-error
1127                 (list "Containing expression ends prematurely"
1128                       (point) (prog1 (point) (goto-char pos))))
1129       (when (eq (char-after) ?{)
1130         (let ((newpos (point)))
1131           (when (ignore-errors (backward-sexp 1) t)
1132             (if (looking-at "\\\\end\\>")
1133                 (tex-last-unended-begin)
1134               (goto-char newpos))))))))
1135
1136 (defun latex-forward-sexp-1 ()
1137   "Like (forward-sexp 1) but aware of multi-char elements."
1138   (let ((pos (point))
1139         (forward-sexp-function))
1140     (forward-sexp 1)
1141     (let ((newpos (point)))
1142       (skip-syntax-backward "/w")
1143       (cond
1144        ((looking-at "\\\\end\\>")
1145         (signal 'scan-error
1146                 (list "Containing expression ends prematurely"
1147                       (point)
1148                       (prog1
1149                           (progn (ignore-errors (forward-sexp 2)) (point))
1150                         (goto-char pos)))))
1151        ((looking-at "\\\\begin\\>")
1152         (goto-char (match-end 0))
1153         (tex-next-unmatched-end))
1154        (t (goto-char newpos))))))
1155
1156 (defun latex-forward-sexp (&optional arg)
1157   "Like `forward-sexp' but aware of multi-char elements."
1158   (interactive "P")
1159   (unless arg (setq arg 1))
1160   (let ((pos (point)))
1161     (condition-case err
1162         (while (/= arg 0)
1163           (setq arg
1164                 (if (> arg 0)
1165                     (progn (latex-forward-sexp-1) (1- arg))
1166                   (progn (latex-backward-sexp-1) (1+ arg)))))
1167       (scan-error
1168        (goto-char pos)
1169        (signal (car err) (cdr err))))))
1170
1171 (defun latex-syntax-after ()
1172   "Like (char-syntax (char-after)) but aware of multi-char elements."
1173   (if (looking-at "\\\\end\\>") ?\) (char-syntax (char-after))))
1174
1175 (defun latex-skip-close-parens ()
1176   "Like (skip-syntax-forward \" )\") but aware of multi-char elements."
1177   (let ((forward-sexp-function nil))
1178     (while (progn (skip-syntax-forward " )")
1179                   (looking-at "\\\\end\\>"))
1180       (forward-sexp 2))))
1181
1182 (defun latex-down-list ()
1183   "Like (down-list 1) but aware of multi-char elements."
1184   (forward-comment (point-max))
1185   (let ((forward-sexp-function nil))
1186     (if (not (looking-at "\\\\begin\\>"))
1187         (down-list 1)
1188       (forward-sexp 1)
1189       ;; Skip arguments.
1190       (while (looking-at "[ \t]*\\s(") (forward-sexp)))))
1191
1192 (defun tex-close-latex-block ()
1193   "Creates an \\end{...} to match the last unclosed \\begin{...}."
1194   (interactive "*")
1195   (let ((new-line-needed (bolp))
1196         text indentation)
1197     (save-excursion
1198       (condition-case nil
1199           (tex-last-unended-begin)
1200         (error (error "Couldn't find unended \\begin")))
1201       (setq indentation (current-column))
1202       (re-search-forward "\\\\begin\\(\\s *{[^}\n]*}\\)")
1203       (setq text (buffer-substring (match-beginning 1) (match-end 1))))
1204     (indent-to indentation)
1205     (insert "\\end" text)
1206     (if new-line-needed (insert ?\n))))
1207 \f
1208 ;;; Invoking TeX in an inferior shell.
1209
1210 ;;; Why use a shell instead of running TeX directly?  Because if TeX
1211 ;;; gets stuck, the user can switch to the shell window and type at it.
1212
1213 ;;; The utility functions:
1214
1215 (define-derived-mode tex-shell shell-mode "TeX-Shell"
1216   (compilation-shell-minor-mode t))
1217
1218 ;;;###autoload
1219 (defun tex-start-shell ()
1220   (with-current-buffer
1221       (make-comint
1222        "tex-shell"
1223        (or tex-shell-file-name (getenv "ESHELL") (getenv "SHELL") "/bin/sh")
1224        nil)
1225     (let ((proc (get-process "tex-shell")))
1226       (set-process-sentinel proc 'tex-shell-sentinel)
1227       (process-kill-without-query proc)
1228       (tex-shell)
1229       (while (zerop (buffer-size))
1230         (sleep-for 1)))))
1231
1232 (defun tex-feed-input ()
1233   "Send input to the tex shell process.
1234 In the tex buffer this can be used to continue an interactive tex run.
1235 In the tex shell buffer this command behaves like `comint-send-input'."
1236   (interactive)
1237   (set-buffer (process-buffer (get-process "tex-shell")))
1238   (comint-send-input)
1239   (tex-recenter-output-buffer nil))
1240
1241 (defun tex-display-shell ()
1242   "Make the TeX shell buffer visible in a window."
1243   (display-buffer (process-buffer (get-process "tex-shell")))
1244   (tex-recenter-output-buffer nil))
1245
1246 (defun tex-shell-sentinel (proc msg)
1247   (cond ((null (buffer-name (process-buffer proc)))
1248          ;; buffer killed
1249          (set-process-buffer proc nil)
1250          (tex-delete-last-temp-files))
1251         ((memq (process-status proc) '(signal exit))
1252          (tex-delete-last-temp-files))))
1253
1254 (defun tex-set-buffer-directory (buffer directory)
1255   "Set BUFFER's default directory to be DIRECTORY."
1256   (setq directory (file-name-as-directory (expand-file-name directory)))
1257   (if (not (file-directory-p directory))
1258       (error "%s is not a directory" directory)
1259     (save-excursion
1260       (set-buffer buffer)
1261       (setq default-directory directory))))
1262
1263 (defvar tex-send-command-modified-tick 0)
1264 (make-variable-buffer-local 'tex-send-command-modified-tick)
1265
1266 (defun tex-shell-proc ()
1267   (or (get-process "tex-shell") (error "No TeX subprocess")))
1268 (defun tex-shell-buf ()
1269   (process-buffer (tex-shell-proc)))
1270
1271 (defun tex-send-command (command &optional file background)
1272   "Send COMMAND to TeX shell process, substituting optional FILE for *.
1273 Do this in background if optional BACKGROUND is t.  If COMMAND has no *,
1274 FILE will be appended, preceded by a blank, to COMMAND.  If FILE is nil, no
1275 substitution will be made in COMMAND.  COMMAND can be any expression that
1276 evaluates to a command string.
1277
1278 Return the process in which TeX is running."
1279   (save-excursion
1280     (let* ((cmd (eval command))
1281            (proc (tex-shell-proc))
1282            (buf (process-buffer proc))
1283            (star (string-match "\\*" cmd))
1284            (string
1285             (concat
1286              (if file
1287                  (if star (concat (substring cmd 0 star)
1288                                   file (substring cmd (1+ star)))
1289                    (concat cmd " " file))
1290                cmd)
1291              (if background "&" ""))))
1292       ;; Switch to buffer before checking for subproc output in it.
1293       (set-buffer buf)
1294       ;; If text is unchanged since previous tex-send-command,
1295       ;; we haven't got any output.  So wait for output now.
1296       (if (= (buffer-modified-tick buf) tex-send-command-modified-tick)
1297           (accept-process-output proc))
1298       (goto-char (process-mark proc))
1299       (insert string)
1300       (comint-send-input)
1301       (setq tex-send-command-modified-tick (buffer-modified-tick buf))
1302       proc)))
1303
1304 (defun tex-delete-last-temp-files (&optional not-all)
1305   "Delete any junk files from last temp file.
1306 If NOT-ALL is non-nil, save the `.dvi' file."
1307   (if tex-last-temp-file
1308       (let* ((dir (file-name-directory tex-last-temp-file))
1309              (list (and (file-directory-p dir)
1310                         (file-name-all-completions
1311                          (file-name-sans-extension
1312                           (file-name-nondirectory tex-last-temp-file))
1313                          dir))))
1314         (while list
1315           (if not-all
1316               (and
1317                ;; If arg is non-nil, don't delete the .dvi file.
1318                (not (string-match "\\.dvi$" (car list)))
1319                (delete-file (concat dir (car list))))
1320             (delete-file (concat dir (car list))))
1321           (setq list (cdr list))))))
1322
1323 (add-hook 'kill-emacs-hook 'tex-delete-last-temp-files)
1324
1325 (defun tex-guess-main-file (&optional all)
1326   "Find a likely `tex-main-file'.
1327 Looks for hints in other buffers in the same directory or in
1328 ALL other buffers."
1329   (let ((dir default-directory)
1330         (header-re tex-start-of-header))
1331     (catch 'found
1332       ;; Look for a buffer with `tex-main-file' set.
1333       (dolist (buf (if (consp all) all (buffer-list)))
1334         (with-current-buffer buf
1335           (when (and (or all (equal dir default-directory))
1336                      (stringp tex-main-file))
1337             (throw 'found (expand-file-name tex-main-file)))))
1338       ;; Look for a buffer containing the magic `tex-start-of-header'.
1339       (dolist (buf (if (consp all) all (buffer-list)))
1340         (with-current-buffer buf
1341           (when (and (or all (equal dir default-directory))
1342                      buffer-file-name
1343                      ;; (or (easy-mmode-derived-mode-p 'latex-mode)
1344                      ;;          (easy-mmode-derived-mode-p 'plain-tex-mode))
1345                      (save-excursion
1346                        (goto-char (point-min))
1347                        (re-search-forward header-re 10000 t)))
1348             (throw 'found (expand-file-name buffer-file-name))))))))
1349
1350 (defun tex-main-file (&optional realfile)
1351   "Return the name of the main file with the `.tex' extension stripped.
1352 If REALFILE is non-nil, return the pair (FILE . REALFILE) where FILE
1353 is the filename without the extension while REALFILE is the filename
1354 with extension."
1355   (let* ((file (or tex-main-file
1356                    ;; Compatibility with AUCTeX.
1357                    (and (boundp 'TeX-master) (stringp TeX-master)
1358                         (set (make-local-variable 'tex-main-file) TeX-master))
1359                    ;; Try to guess the main file.
1360                    (if (not buffer-file-name)
1361                        (error "Buffer is not associated with any file")
1362                      (file-relative-name
1363                       (if (save-excursion
1364                             (goto-char (point-min))
1365                             (re-search-forward tex-start-of-header 10000 t))
1366                           ;; This is the main file.
1367                           buffer-file-name
1368                         ;; This isn't the main file, let's try to find better,
1369                         (or (tex-guess-main-file)
1370                             ;; (tex-guess-main-file t)
1371                             buffer-file-name))))))
1372          (real (if (file-exists-p file) file (concat file ".tex"))))
1373     (when (string-match "\\.tex\\'" file)
1374       (setq file (substring file 0 (match-beginning 0))))
1375     (if realfile (cons file real) file)))
1376
1377
1378 (defun tex-start-tex (command file &optional dir)
1379   "Start a TeX run, using COMMAND on FILE."
1380   (let* ((star (string-match "\\*" command))
1381          (compile-command
1382           (if star
1383               (concat (substring command 0 star)
1384                       (comint-quote-filename file)
1385                       (substring command (1+ star)))
1386             (concat command " "
1387                     (if (< 0 (length tex-start-options-string))
1388                         (concat
1389                          (shell-quote-argument tex-start-options-string) " "))
1390                     (comint-quote-filename file)))))
1391     (tex-send-tex-command compile-command dir)))
1392
1393 (defun tex-send-tex-command (cmd &optional dir)
1394   (unless (or (equal dir (with-current-buffer (tex-shell-buf)
1395                            default-directory))
1396               (not dir))
1397     (let (shell-dirtrack-verbose)
1398       (tex-send-command tex-shell-cd-command dir)))
1399   (with-current-buffer (process-buffer (tex-send-command cmd))
1400     (make-local-variable 'compilation-parse-errors-function)
1401     (setq compilation-parse-errors-function 'tex-compilation-parse-errors)
1402     (setq compilation-last-buffer (current-buffer))
1403     (compilation-forget-errors)
1404     ;; Don't parse previous compilations.
1405     (set-marker compilation-parsing-end (1- (point-max))))
1406   (tex-display-shell)
1407   (setq tex-last-buffer-texed (current-buffer)))
1408 \f
1409 (defvar tex-error-parse-syntax-table
1410   (let ((st (make-syntax-table)))
1411     (modify-syntax-entry ?\( "()" st)
1412     (modify-syntax-entry ?\) ")(" st)
1413     (modify-syntax-entry ?\\ "\\" st)
1414     (modify-syntax-entry ?\{ "_" st)
1415     (modify-syntax-entry ?\} "_" st)
1416     (modify-syntax-entry ?\[ "_" st)
1417     (modify-syntax-entry ?\] "_" st)
1418     ;; Single quotations may appear in errors
1419     (modify-syntax-entry ?\" "_" st)
1420     st)
1421   "Syntax-table used while parsing TeX error messages.")
1422
1423 (defun tex-compilation-parse-errors (limit-search find-at-least)
1424   "Parse the current buffer as TeX error messages.
1425 See the variable `compilation-parse-errors-function' for the interface it uses.
1426
1427 This function parses only the last TeX compilation.
1428 It works on TeX compilations only.  It is necessary for that purpose,
1429 since TeX does not put file names and line numbers on the same line as
1430 for the error messages."
1431   (require 'thingatpt)
1432   (setq compilation-error-list nil)
1433   (message "Parsing error messages...")
1434   (let ((default-directory              ; Perhaps dir has changed meanwhile.
1435           (file-name-directory (buffer-file-name tex-last-buffer-texed)))
1436         found-desired (num-errors-found 0)
1437         last-filename last-linenum last-position
1438         begin-of-error end-of-error)
1439     ;; Don't reparse messages already seen at last parse.
1440     (goto-char compilation-parsing-end)
1441     ;; Parse messages.
1442     (while (and (not (or found-desired (eobp)))
1443                 (prog1 (re-search-forward "^! " nil 'move)
1444                   (setq begin-of-error (match-beginning 0)
1445                         end-of-error (match-end 0)))
1446                 (re-search-forward
1447                  "^l\\.\\([0-9]+\\) \\(\\.\\.\\.\\)?\\(.*\\)$" nil 'move))
1448       (let* ((this-error (set-marker (make-marker) begin-of-error))
1449              (linenum (string-to-int (match-string 1)))
1450              (error-text (regexp-quote (match-string 3)))
1451              (filename
1452               (save-excursion
1453                 (with-syntax-table tex-error-parse-syntax-table
1454                   (backward-up-list 1)
1455                   (skip-syntax-forward "(_")
1456                   (while (not (file-readable-p (thing-at-point 'filename)))
1457                     (skip-syntax-backward "(_")
1458                     (backward-up-list 1)
1459                     (skip-syntax-forward "(_"))
1460                   (thing-at-point 'filename))))
1461              (new-file
1462               (or (null last-filename)
1463                   (not (string-equal last-filename filename))))
1464              (error-location
1465               (save-excursion
1466                 (if (equal filename (concat tex-zap-file ".tex"))
1467                     (set-buffer tex-last-buffer-texed)
1468                   (set-buffer (find-file-noselect filename)))
1469                 (if new-file
1470                     (progn (goto-line linenum) (setq last-position nil))
1471                   (goto-char last-position)
1472                   (forward-line (- linenum last-linenum)))
1473                 ;; first try a forward search for the error text,
1474                 ;; then a backward search limited by the last error.
1475                 (let ((starting-point (point)))
1476                   (or (re-search-forward error-text nil t)
1477                       (re-search-backward error-text last-position t)
1478                       (goto-char starting-point)))
1479                 (point-marker))))
1480         (goto-char this-error)
1481         (if (and compilation-error-list
1482                  (or (and find-at-least
1483                           (>= num-errors-found
1484                               find-at-least))
1485                      (and limit-search
1486                           (>= end-of-error limit-search)))
1487                  new-file)
1488             (setq found-desired t)
1489           (setq num-errors-found (1+ num-errors-found)
1490                 last-filename filename
1491                 last-linenum linenum
1492                 last-position error-location
1493                 compilation-error-list  ; Add the new error
1494                 (cons (cons this-error error-location)
1495                       compilation-error-list))
1496           (goto-char end-of-error)))))
1497   (set-marker compilation-parsing-end (point))
1498   (setq compilation-error-list (nreverse compilation-error-list))
1499   (message "Parsing error messages...done"))
1500 \f
1501 ;;; The commands:
1502
1503 (defun tex-region (beg end)
1504   "Run TeX on the current region, via a temporary file.
1505 The file's name comes from the variable `tex-zap-file' and the
1506 variable `tex-directory' says where to put it.
1507
1508 If the buffer has a header, the header is given to TeX before the
1509 region itself.  The buffer's header is all lines between the strings
1510 defined by `tex-start-of-header' and `tex-end-of-header' inclusive.
1511 The header must start in the first 100 lines of the buffer.
1512
1513 The value of `tex-trailer' is given to TeX as input after the region.
1514
1515 The value of `tex-command' specifies the command to use to run TeX."
1516   (interactive "r")
1517   (if (tex-shell-running)
1518       (tex-kill-job)
1519     (tex-start-shell))
1520   (or tex-zap-file
1521       (setq tex-zap-file (tex-generate-zap-file-name)))
1522   ;; Temp file will be written and TeX will be run in zap-directory.
1523   ;; If the TEXINPUTS file has relative directories or if the region has
1524   ;; \input of files, this must be the same directory as the file for
1525   ;; TeX to access the correct inputs.  That's why it's safest if
1526   ;; tex-directory is ".".
1527   (let* ((zap-directory
1528           (file-name-as-directory (expand-file-name tex-directory)))
1529          (tex-out-file (expand-file-name (concat tex-zap-file ".tex")
1530                                          zap-directory)))
1531     ;; Don't delete temp files if we do the same buffer twice in a row.
1532     (or (eq (current-buffer) tex-last-buffer-texed)
1533         (tex-delete-last-temp-files t))
1534     ;; Write the new temp file.
1535     (save-excursion
1536       (save-restriction
1537         (widen)
1538         (goto-char (point-min))
1539         (forward-line 100)
1540         (let ((search-end (point))
1541               (default-directory zap-directory)
1542               (already-output 0))
1543           (goto-char (point-min))
1544
1545           ;; Maybe copy first line, such as `\input texinfo', to temp file.
1546           (and tex-first-line-header-regexp
1547                (looking-at tex-first-line-header-regexp)
1548                (write-region (point)
1549                              (progn (forward-line 1)
1550                                     (setq already-output (point)))
1551                              tex-out-file nil nil))
1552
1553           ;; Write out the header, if there is one,
1554           ;; and any of the specified region which extends before it.
1555           ;; But don't repeat anything already written.
1556           (if (re-search-forward tex-start-of-header search-end t)
1557               (let (hbeg)
1558                 (beginning-of-line)
1559                 (setq hbeg (point))     ;mark beginning of header
1560                 (if (re-search-forward tex-end-of-header nil t)
1561                     (let (hend)
1562                       (forward-line 1)
1563                       (setq hend (point)) ;mark end of header
1564                       (write-region (max (min hbeg beg) already-output)
1565                                     hend
1566                                     tex-out-file
1567                                     (not (zerop already-output)) nil)
1568                       (setq already-output hend)))))
1569
1570           ;; Write out the specified region
1571           ;; (but don't repeat anything already written).
1572           (write-region (max beg already-output) end
1573                         tex-out-file
1574                         (not (zerop already-output)) nil))
1575         ;; Write the trailer, if any.
1576         ;; Precede it with a newline to make sure it
1577         ;; is not hidden in a comment.
1578         (if tex-trailer
1579             (write-region (concat "\n" tex-trailer) nil
1580                           tex-out-file t nil))))
1581     ;; Record the file name to be deleted afterward.
1582     (setq tex-last-temp-file tex-out-file)
1583     ;; Use a relative file name here because (1) the proper dir
1584     ;; is already current, and (2) the abs file name is sometimes
1585     ;; too long and can make tex crash.
1586     (tex-start-tex tex-command (concat tex-zap-file ".tex") zap-directory)
1587     (setq tex-print-file tex-out-file)))
1588
1589 (defun tex-buffer ()
1590   "Run TeX on current buffer.  See \\[tex-region] for more information.
1591 Does not save the buffer, so it's useful for trying experimental versions.
1592 See \\[tex-file] for an alternative."
1593   (interactive)
1594   (tex-region (point-min) (point-max)))
1595
1596 (defun tex-file ()
1597   "Prompt to save all buffers and run TeX (or LaTeX) on current buffer's file.
1598 This function is more useful than \\[tex-buffer] when you need the
1599 `.aux' file of LaTeX to have the correct name."
1600   (interactive)
1601   (let* ((source-file (tex-main-file))
1602          (file-dir (expand-file-name (or (file-name-directory source-file)
1603                                          default-directory))))
1604     (if tex-offer-save
1605         (save-some-buffers))
1606     (if (tex-shell-running)
1607         (tex-kill-job)
1608       (tex-start-shell))
1609     (tex-start-tex tex-command source-file file-dir)
1610     (setq tex-print-file (expand-file-name source-file))))
1611
1612 (defun tex-generate-zap-file-name ()
1613   "Generate a unique name suitable for use as a file name."
1614   ;; Include the shell process number and host name
1615   ;; in case there are multiple shells (for same or different user).
1616   ;; Dec 1998: There is a report that some versions of xdvi
1617   ;; don't work with file names that start with #.
1618   (format "_TZ_%d-%s"
1619           (process-id (get-buffer-process "*tex-shell*"))
1620           (tex-strip-dots (system-name))))
1621
1622 (defun tex-strip-dots (s)
1623   (setq s (copy-sequence s))
1624   (while (string-match "\\." s)
1625     (aset s (match-beginning 0) ?-))
1626   s)
1627
1628 ;; This will perhaps be useful for modifying TEXINPUTS.
1629 ;; Expand each file name, separated by colons, in the string S.
1630 (defun tex-expand-files (s)
1631   (let (elts (start 0))
1632     (while (string-match ":" s start)
1633       (setq elts (cons (substring s start (match-beginning 0)) elts))
1634       (setq start (match-end 0)))
1635     (or (= start 0)
1636         (setq elts (cons (substring s start) elts)))
1637     (mapconcat (lambda (elt)
1638                  (if (= (length elt) 0) elt (expand-file-name elt)))
1639                (nreverse elts) ":")))
1640
1641 (defun tex-shell-running ()
1642   (and (get-process "tex-shell")
1643        (eq (process-status (get-process "tex-shell")) 'run)))
1644
1645 (defun tex-kill-job ()
1646   "Kill the currently running TeX job."
1647   (interactive)
1648   ;; quit-process leads to core dumps of the tex process (except if
1649   ;; coredumpsize has limit 0kb as on many environments).  One would
1650   ;; like to use (kill-process proc 'lambda), however that construct
1651   ;; does not work on some systems and kills the shell itself.
1652   (quit-process (get-process "tex-shell") t))
1653
1654 (defun tex-recenter-output-buffer (linenum)
1655   "Redisplay buffer of TeX job output so that most recent output can be seen.
1656 The last line of the buffer is displayed on
1657 line LINE of the window, or centered if LINE is nil."
1658   (interactive "P")
1659   (let ((tex-shell (get-buffer "*tex-shell*"))
1660         (old-buffer (current-buffer))
1661         (window))
1662     (if (null tex-shell)
1663         (message "No TeX output buffer")
1664       (setq window (display-buffer tex-shell))
1665       (save-selected-window
1666         (select-window window)
1667         (bury-buffer tex-shell)
1668         (goto-char (point-max))
1669         (recenter (if linenum
1670                       (prefix-numeric-value linenum)
1671                     (/ (window-height) 2)))))))
1672
1673 (defun tex-print (&optional alt)
1674   "Print the .dvi file made by \\[tex-region], \\[tex-buffer] or \\[tex-file].
1675 Runs the shell command defined by `tex-dvi-print-command'.  If prefix argument
1676 is provided, use the alternative command, `tex-alt-dvi-print-command'."
1677   (interactive "P")
1678   (let ((print-file-name-dvi (tex-append tex-print-file ".dvi"))
1679         test-name)
1680     (if (and (not (equal (current-buffer) tex-last-buffer-texed))
1681              (buffer-file-name)
1682              ;; Check that this buffer's printed file is up to date.
1683              (file-newer-than-file-p
1684               (setq test-name (tex-append (buffer-file-name) ".dvi"))
1685               (buffer-file-name)))
1686         (setq print-file-name-dvi test-name))
1687     (if (not (file-exists-p print-file-name-dvi))
1688         (error "No appropriate `.dvi' file could be found")
1689       (if (tex-shell-running)
1690           (tex-kill-job)
1691         (tex-start-shell))
1692       (tex-send-command
1693        (if alt tex-alt-dvi-print-command tex-dvi-print-command)
1694        print-file-name-dvi t))))
1695
1696 (defun tex-alt-print ()
1697   "Print the .dvi file made by \\[tex-region], \\[tex-buffer] or \\[tex-file].
1698 Runs the shell command defined by `tex-alt-dvi-print-command'."
1699   (interactive)
1700   (tex-print t))
1701
1702 (defun tex-view ()
1703   "Preview the last `.dvi' file made by running TeX under Emacs.
1704 This means, made using \\[tex-region], \\[tex-buffer] or \\[tex-file].
1705 The variable `tex-dvi-view-command' specifies the shell command for preview.
1706 You must set that variable yourself before using this command,
1707 because there is no standard value that would generally work."
1708   (interactive)
1709   (or tex-dvi-view-command
1710       (error "You must set `tex-dvi-view-command'"))
1711   (let ((tex-dvi-print-command tex-dvi-view-command))
1712     (tex-print)))
1713
1714 (defun tex-append (file-name suffix)
1715   "Append to FILENAME the suffix SUFFIX, using same algorithm TeX uses.
1716 Pascal-based TeX scans for the first period, C TeX uses the last.
1717 No period is retained immediately before SUFFIX,
1718 so normally SUFFIX starts with one."
1719   (if (stringp file-name)
1720       (let ((file (file-name-nondirectory file-name))
1721             trial-name)
1722         ;; Try splitting on last period.
1723         ;; The first-period split can get fooled when two files
1724         ;; named a.tex and a.b.tex are both tex'd;
1725         ;; the last-period split must be right if it matches at all.
1726         (setq trial-name
1727               (concat (file-name-directory file-name)
1728                       (substring file 0
1729                                  (string-match "\\.[^.]*$" file))
1730                       suffix))
1731         (if (or (file-exists-p trial-name)
1732                 (file-exists-p (concat trial-name ".aux"))) ;for BibTeX files
1733             trial-name
1734           ;; Not found, so split on first period.
1735           (concat (file-name-directory file-name)
1736                   (substring file 0
1737                              (string-match "\\." file))
1738                   suffix)))
1739     " "))
1740
1741 (defun tex-show-print-queue ()
1742   "Show the print queue that \\[tex-print] put your job on.
1743 Runs the shell command defined by `tex-show-queue-command'."
1744   (interactive)
1745   (if (tex-shell-running)
1746       (tex-kill-job)
1747     (tex-start-shell))
1748   (tex-send-command tex-show-queue-command)
1749   (tex-display-shell))
1750
1751 (defun tex-bibtex-file ()
1752   "Run BibTeX on the current buffer's file."
1753   (interactive)
1754   (if (tex-shell-running)
1755       (tex-kill-job)
1756     (tex-start-shell))
1757   (let (shell-dirtrack-verbose
1758         (tex-out-file
1759          (tex-append (file-name-nondirectory (buffer-file-name)) ""))
1760         (file-dir (file-name-directory (buffer-file-name))))
1761     (tex-send-command tex-shell-cd-command file-dir)
1762     (tex-send-command tex-bibtex-command tex-out-file))
1763   (tex-display-shell))
1764 \f
1765 ;;;;
1766 ;;;; LaTeX indentation
1767 ;;;;
1768
1769 (defvar tex-indent-allhanging t)
1770 (defvar tex-indent-arg 4)
1771 (defvar tex-indent-basic 2)
1772 (defvar tex-indent-item tex-indent-basic)
1773 (defvar tex-indent-item-re "\\\\\\(bib\\)?item\\>")
1774
1775 (easy-mmode-defsyntax tex-latex-indent-syntax-table
1776   '((?$ . ".")
1777     (?\( . ".")
1778     (?\) . "."))
1779   "Syntax table used while computing indentation."
1780   :copy tex-mode-syntax-table)
1781
1782 (defun latex-indent (&optional arg)
1783   (with-syntax-table tex-latex-indent-syntax-table
1784     ;; TODO: Rather than ignore $, we should try to be more clever about it.
1785     (let ((indent
1786            (save-excursion
1787              (beginning-of-line)
1788              (latex-find-indent))))
1789       (if (< indent 0) (setq indent 0))
1790       (if (<= (current-column) (current-indentation))
1791           (indent-line-to indent)
1792         (save-excursion (indent-line-to indent))))))
1793
1794 (defun latex-find-indent (&optional virtual)
1795   "Find the proper indentation of text after point.
1796 VIRTUAL if non-nil indicates that we're only trying to find the indentation
1797   in order to determine the indentation of something else.
1798 There might be text before point."
1799   (save-excursion
1800     (skip-chars-forward " \t")
1801     (or
1802      ;; Trust the current indentation, if such info is applicable.
1803      (and virtual (>= (current-indentation) (current-column))
1804           (current-indentation))
1805      ;; Put leading close-paren where the matching open brace would be.
1806      (and (eq (latex-syntax-after) ?\))
1807           (ignore-errors
1808             (save-excursion
1809               (latex-skip-close-parens)
1810               (latex-backward-sexp-1)
1811               (latex-find-indent 'virtual))))
1812      ;; Default (maybe an argument)
1813      (let ((pos (point))
1814            (char (char-after))
1815            ;; Outdent \item if necessary.
1816            (indent (if (looking-at tex-indent-item-re) (- tex-indent-item) 0))
1817            up-list-pos)
1818        ;; Find the previous point which determines our current indentation.
1819        (condition-case err
1820            (progn
1821              (latex-backward-sexp-1)
1822              (while (> (current-column) (current-indentation))
1823                (latex-backward-sexp-1)))
1824          (scan-error
1825           (setq up-list-pos (nth 2 err))))
1826        (if (integerp up-list-pos)
1827            ;; Have to indent relative to the open-paren.
1828            (progn
1829              (goto-char up-list-pos)
1830              (if (and (not tex-indent-allhanging)
1831                       (> pos (progn (latex-down-list)
1832                                     (forward-comment (point-max))
1833                                     (point))))
1834                  ;; Align with the first element after the open-paren.
1835                  (current-column)
1836                ;; We're the first element after a hanging brace.
1837                (goto-char up-list-pos)
1838                (+ indent tex-indent-basic (latex-find-indent 'virtual))))
1839          ;; We're now at the beginning of a line.
1840          (if (not (and (not virtual) (eq (char-after) ?\\)))
1841              ;; Nothing particular here: just keep the same indentation.
1842              (+ indent (current-column))
1843            ;; We're now looking at a macro call.
1844            (if (looking-at tex-indent-item-re)
1845                ;; Indenting relative to an item, have to re-add the outdenting.
1846                (+ indent (current-column) tex-indent-item)
1847              (let ((col (current-column)))
1848                (if (not (eq (char-syntax char) ?\())
1849                    ;; If the first char was not an open-paren, there's
1850                    ;; a risk that this is really not an argument to the
1851                    ;; macro at all.
1852                    (+ indent col)
1853                  (forward-sexp 1)
1854                  (if (< (line-end-position)
1855                         (save-excursion (forward-comment (point-max))
1856                                         (point)))
1857                      ;; we're indenting the first argument.
1858                      (min (current-column) (+ tex-indent-arg col))
1859                    (skip-syntax-forward " ")
1860                    (current-column)))))))))))
1861
1862 (run-hooks 'tex-mode-load-hook)
1863
1864 (provide 'tex-mode)
1865
1866 ;;; tex-mode.el ends here