|
0
|
1 ;;; tex-mode.el --- TeX, LaTeX, and SliTeX mode commands.
|
|
|
2
|
|
|
3 ;; Copyright (C) 1985-1992 Free Software Foundation, Inc.
|
|
|
4 ;; Contributions over the years by William F. Schelter, Dick King,
|
|
|
5 ;; Stephen Gildea, Michael Prange, and Edward M. Reingold.
|
|
|
6
|
|
|
7 ;; Latest revision (1992) by Edward M. Reingold <reingold@cs.uiuc.edu>.
|
|
|
8
|
|
|
9 ;; This file is part of XEmacs.
|
|
|
10
|
|
|
11 ;; XEmacs is free software; you can redistribute it and/or modify it
|
|
|
12 ;; under the terms of the GNU General Public License as published by
|
|
|
13 ;; the Free Software Foundation; either version 2, or (at your option)
|
|
|
14 ;; any later version.
|
|
|
15
|
|
|
16 ;; XEmacs is distributed in the hope that it will be useful, but
|
|
|
17 ;; WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
18 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
|
19 ;; General Public License for more details.
|
|
|
20
|
|
|
21 ;; You should have received a copy of the GNU General Public License
|
|
|
22 ;; along with XEmacs; see the file COPYING. If not, write to the Free
|
|
|
23 ;; Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
|
|
|
24
|
|
|
25 (require 'comint)
|
|
|
26
|
|
|
27 (defvar tex-shell-file-name nil
|
|
|
28 "*If non-nil, is file name to use for the subshell in which TeX is run.")
|
|
|
29
|
|
|
30 (defvar tex-directory "."
|
|
|
31 "*Directory in which temporary files are left.
|
|
|
32 You can make this /tmp if your TEXINPUTS has no relative directories in it
|
|
|
33 and you don't try to apply \\[tex-region] or \\[tex-buffer] when there are
|
|
|
34 \\input commands with relative directories.")
|
|
|
35
|
|
|
36 (defvar tex-offer-save t
|
|
|
37 "*If non-nil, ask about saving modified buffers before \\[tex-file] is run.")
|
|
|
38
|
|
|
39 (defvar tex-run-command "tex"
|
|
|
40 "*Command used to run TeX subjob.
|
|
|
41 If this string contains an asterisk (*), it will be replaced by the
|
|
|
42 filename; if not, the name of the file, preceded by blank, will be added to
|
|
|
43 this string.")
|
|
|
44
|
|
|
45 (defvar latex-run-command "latex"
|
|
|
46 "*Command used to run LaTeX subjob.
|
|
|
47 If this string contains an asterisk (*), it will be replaced by the
|
|
|
48 filename; if not, the name of the file, preceded by blank, will be added to
|
|
|
49 this string.")
|
|
|
50
|
|
|
51 (defvar standard-latex-block-names
|
|
|
52 '("abstract" "array" "center" "description"
|
|
|
53 "displaymath" "document" "enumerate" "eqnarray"
|
|
|
54 "eqnarray*" "equation" "figure" "figure*"
|
|
|
55 "flushleft" "flushright" "itemize" "letter"
|
|
|
56 "list" "minipage" "picture" "quotation"
|
|
|
57 "quote" "slide" "sloppypar" "tabbing"
|
|
|
58 "table" "table*" "tabular" "tabular*"
|
|
|
59 "thebibliography" "theindex*" "titlepage" "trivlist"
|
|
|
60 "verbatim" "verbatim*" "verse")
|
|
|
61 "Standard LaTeX block names.")
|
|
|
62
|
|
|
63 (defvar latex-block-names nil
|
|
|
64 "*User defined LaTeX block names.
|
|
|
65 Combined with `standard-latex-block-names' for minibuffer completion.")
|
|
|
66
|
|
|
67 (defvar slitex-run-command "slitex"
|
|
|
68 "*Command used to run SliTeX subjob.
|
|
|
69 If this string contains an asterisk (*), it will be replaced by the
|
|
|
70 filename; if not, the name of the file, preceded by blank, will be added to
|
|
|
71 this string.")
|
|
|
72
|
|
|
73 (defvar tex-bibtex-command "bibtex"
|
|
|
74 "*Command used by `tex-bibtex-file' to gather bibliographic data.
|
|
|
75 If this string contains an asterisk (*), it will be replaced by the
|
|
|
76 filename; if not, the name of the file, preceded by blank, will be added to
|
|
|
77 this string.")
|
|
|
78
|
|
|
79 (defvar tex-dvi-print-command "lpr -d"
|
|
|
80 "*Command used by \\[tex-print] to print a .dvi file.
|
|
|
81 If this string contains an asterisk (*), it will be replaced by the
|
|
|
82 filename; if not, the name of the file, preceded by blank, will be added to
|
|
|
83 this string.")
|
|
|
84
|
|
|
85 (defvar tex-alt-dvi-print-command "lpr -d"
|
|
|
86 "*Command used by \\[tex-print] with a prefix arg to print a .dvi file.
|
|
|
87 If this string contains an asterisk (*), it will be replaced by the
|
|
|
88 filename; if not, the name of the file, preceded by blank, will be added to
|
|
|
89 this string.
|
|
|
90
|
|
|
91 If two printers are not enough of a choice, you can define the value
|
|
|
92 of tex-alt-dvi-print-command to be an expression that asks what you want;
|
|
|
93 for example,
|
|
|
94
|
|
|
95 (setq tex-alt-dvi-print-command
|
|
|
96 '(format \"lpr -P%s\" (read-string \"Use printer: \")))
|
|
|
97
|
|
|
98 would tell \\[tex-print] with a prefix argument to ask you which printer to
|
|
|
99 use.")
|
|
|
100
|
|
|
101 (defvar tex-dvi-view-command nil
|
|
|
102 "*Command used by \\[tex-view] to display a .dvi file.
|
|
|
103 If this string contains an asterisk (*), it will be replaced by the
|
|
|
104 filename; if not, the name of the file, preceded by blank, will be added to
|
|
|
105 this string.
|
|
|
106
|
|
|
107 This can be set conditionally so that the previewer used is suitable for the
|
|
|
108 window system being used. For example,
|
|
|
109
|
|
|
110 (setq tex-dvi-view-command
|
|
|
111 (if (eq window-system 'x) \"xdvi\" \"dvi2tty * | cat -s\"))
|
|
|
112
|
|
|
113 would tell \\[tex-view] use xdvi under X windows and to use dvi2tty
|
|
|
114 otherwise.")
|
|
|
115
|
|
|
116 (defvar tex-show-queue-command "lpq"
|
|
|
117 "*Command used by \\[tex-show-print-queue] to show the print queue.
|
|
|
118 Should show the queue(s) that \\[tex-print] puts jobs on.")
|
|
|
119
|
|
|
120 (defvar tex-default-mode 'plain-tex-mode
|
|
|
121 "*Mode to enter for a new file that might be either TeX or LaTeX.
|
|
|
122 This variable is used when it can't be determined whether the file
|
|
|
123 is plain TeX or LaTeX or what because the file contains no commands.
|
|
|
124 Normally set to either 'plain-tex-mode or 'latex-mode.")
|
|
|
125
|
|
|
126 (defvar tex-open-quote "``"
|
|
|
127 "*String inserted by typing \\[tex-insert-quote] to open a quotation.")
|
|
|
128
|
|
|
129 (defvar tex-close-quote "''"
|
|
|
130 "*String inserted by typing \\[tex-insert-quote] to close a quotation.")
|
|
|
131
|
|
|
132 (defvar tex-last-temp-file nil
|
|
|
133 "Latest temporary file generated by \\[tex-region] and \\[tex-buffer].
|
|
|
134 Deleted when the \\[tex-region] or \\[tex-buffer] is next run, or when the
|
|
|
135 tex-shell goes away.")
|
|
|
136
|
|
|
137 (defvar tex-command nil
|
|
|
138 "Command to run TeX.
|
|
|
139 The name of the file, preceded by a blank, will be added to this string.")
|
|
|
140
|
|
|
141 (defvar tex-trailer nil
|
|
|
142 "String appended after the end of a region sent to TeX by \\[tex-region].")
|
|
|
143
|
|
|
144 (defvar tex-start-of-header nil
|
|
|
145 "String used by \\[tex-region] to delimit the start of the file's header.")
|
|
|
146
|
|
|
147 (defvar tex-end-of-header nil
|
|
|
148 "String used by \\[tex-region] to delimit the end of the file's header.")
|
|
|
149
|
|
|
150 (defvar tex-shell-cd-command "cd"
|
|
|
151 "Command to give to shell running TeX to change directory.
|
|
|
152 The value of tex-directory will be appended to this, separated by a space.")
|
|
|
153
|
|
|
154 (defvar tex-zap-file nil
|
|
|
155 "Temporary file name used for text being sent as input to TeX.
|
|
|
156 Should be a simple file name with no extension or directory specification.")
|
|
|
157
|
|
|
158 (defvar tex-last-buffer-texed nil
|
|
|
159 "Buffer which was last TeXed.")
|
|
|
160
|
|
|
161 (defvar tex-print-file nil
|
|
|
162 "File name that \\[tex-print] prints.
|
|
|
163 Set by \\[tex-region], \\[tex-buffer], and \\[tex-file].")
|
|
|
164
|
|
|
165 (defvar tex-mode-syntax-table nil
|
|
|
166 "Syntax table used while in TeX mode.")
|
|
|
167
|
|
|
168 (defun tex-define-common-keys (keymap)
|
|
|
169 "Define the keys that we want defined both in TeX mode and in the tex-shell."
|
|
|
170 (define-key keymap "\C-c\C-k" 'tex-kill-job)
|
|
|
171 (define-key keymap "\C-c\C-l" 'tex-recenter-output-buffer)
|
|
|
172 (define-key keymap "\C-c\C-q" 'tex-show-print-queue)
|
|
|
173 (define-key keymap "\C-c\C-p" 'tex-print)
|
|
|
174 (define-key keymap "\C-c\C-v" 'tex-view)
|
|
|
175 )
|
|
|
176
|
|
|
177 (defvar tex-mode-map nil "Keymap for TeX mode.")
|
|
|
178
|
|
|
179 (if tex-mode-map
|
|
|
180 nil
|
|
|
181 (setq tex-mode-map (make-sparse-keymap))
|
|
|
182 (tex-define-common-keys tex-mode-map)
|
|
|
183 (define-key tex-mode-map "\"" 'tex-insert-quote)
|
|
|
184 (define-key tex-mode-map "\n" 'tex-terminate-paragraph)
|
|
|
185 (define-key tex-mode-map "\C-c}" 'up-list)
|
|
|
186 (define-key tex-mode-map "\C-c{" 'tex-insert-braces)
|
|
|
187 (define-key tex-mode-map "\C-c\C-r" 'tex-region)
|
|
|
188 (define-key tex-mode-map "\C-c\C-b" 'tex-buffer)
|
|
|
189 (define-key tex-mode-map "\C-c\C-f" 'tex-file)
|
|
|
190 (define-key tex-mode-map "\C-c\C-i" 'tex-bibtex-file)
|
|
|
191 (define-key tex-mode-map "\C-c\C-o" 'tex-latex-block)
|
|
|
192 (define-key tex-mode-map "\C-c\C-e" 'tex-close-latex-block))
|
|
|
193
|
|
|
194 (defvar tex-shell-map nil
|
|
|
195 "Keymap for the tex-shell. A comint-mode-map with a few additions.")
|
|
|
196
|
|
|
197 ;;; This would be a lot simpler if we just used a regexp search,
|
|
|
198 ;;; but then it would be too slow.
|
|
|
199 ;;;###autoload
|
|
|
200 (defun tex-mode ()
|
|
|
201 "Major mode for editing files of input for TeX, LaTeX, or SliTeX.
|
|
|
202 Tries to determine (by looking at the beginning of the file) whether
|
|
|
203 this file is for plain TeX, LaTeX, or SliTeX and calls plain-tex-mode,
|
|
|
204 latex-mode, or slitex-mode, respectively. If it cannot be determined,
|
|
|
205 such as if there are no commands in the file, the value of tex-default-mode
|
|
|
206 is used."
|
|
|
207 (interactive)
|
|
|
208 (let (mode slash comment)
|
|
|
209 (save-excursion
|
|
|
210 (goto-char (point-min))
|
|
|
211 (while (and (setq slash (search-forward "\\" nil t))
|
|
|
212 (setq comment (let ((search-end (point)))
|
|
|
213 (save-excursion
|
|
|
214 (beginning-of-line)
|
|
|
215 (search-forward "%" search-end t))))))
|
|
|
216 (if (and slash (not comment))
|
|
|
217 (setq mode (if (looking-at "documentstyle")
|
|
|
218 (if (looking-at "documentstyle{slides}")
|
|
|
219 'slitex-mode
|
|
|
220 'latex-mode)
|
|
|
221 'plain-tex-mode))))
|
|
|
222 (if mode (funcall mode)
|
|
|
223 (funcall tex-default-mode))))
|
|
|
224 ;;;###autoload
|
|
|
225 (fset 'TeX-mode 'tex-mode)
|
|
|
226 ;;;###autoload
|
|
|
227 (fset 'LaTeX-mode 'latex-mode)
|
|
|
228
|
|
|
229 ;;;###autoload
|
|
|
230 (defun plain-tex-mode ()
|
|
|
231 "Major mode for editing files of input for plain TeX.
|
|
|
232 Makes $ and } display the characters they match.
|
|
|
233 Makes \" insert `` when it seems to be the beginning of a quotation,
|
|
|
234 and '' when it appears to be the end; it inserts \" only after a \\.
|
|
|
235
|
|
|
236 Use \\[tex-region] to run TeX on the current region, plus a \"header\"
|
|
|
237 copied from the top of the file (containing macro definitions, etc.),
|
|
|
238 running TeX under a special subshell. \\[tex-buffer] does the whole buffer.
|
|
|
239 \\[tex-file] saves the buffer and then processes the file.
|
|
|
240 \\[tex-print] prints the .dvi file made by any of these.
|
|
|
241 \\[tex-view] previews the .dvi file made by any of these.
|
|
|
242 \\[tex-bibtex-file] runs bibtex on the file of the current buffer.
|
|
|
243
|
|
|
244 Use \\[validate-tex-buffer] to check buffer for paragraphs containing
|
|
|
245 mismatched $'s or braces.
|
|
|
246
|
|
|
247 Special commands:
|
|
|
248 \\{tex-mode-map}
|
|
|
249
|
|
|
250 Mode variables:
|
|
|
251 tex-run-command
|
|
|
252 Command string used by \\[tex-region] or \\[tex-buffer].
|
|
|
253 tex-directory
|
|
|
254 Directory in which to create temporary files for TeX jobs
|
|
|
255 run by \\[tex-region] or \\[tex-buffer].
|
|
|
256 tex-dvi-print-command
|
|
|
257 Command string used by \\[tex-print] to print a .dvi file.
|
|
|
258 tex-alt-dvi-print-command
|
|
|
259 Alternative command string used by \\[tex-print] (when given a prefix
|
|
|
260 argument) to print a .dvi file.
|
|
|
261 tex-dvi-view-command
|
|
|
262 Command string used by \\[tex-view] to preview a .dvi file.
|
|
|
263 tex-show-queue-command
|
|
|
264 Command string used by \\[tex-show-print-queue] to show the print
|
|
|
265 queue that \\[tex-print] put your job on.
|
|
|
266
|
|
|
267 Entering Plain-tex mode calls the value of text-mode-hook, then the value of
|
|
|
268 tex-mode-hook, and then the value of plain-tex-mode-hook. When the special
|
|
|
269 subshell is initiated, the value of tex-shell-hook is called."
|
|
|
270 (interactive)
|
|
|
271 (tex-common-initialization)
|
|
|
272 (setq mode-name "TeX")
|
|
|
273 (setq major-mode 'plain-tex-mode)
|
|
|
274 (setq tex-command tex-run-command)
|
|
|
275 (setq tex-start-of-header "%**start of header")
|
|
|
276 (setq tex-end-of-header "%**end of header")
|
|
|
277 (setq tex-trailer "\\bye\n")
|
|
|
278 (run-hooks 'text-mode-hook 'tex-mode-hook 'plain-tex-mode-hook))
|
|
|
279 ;;;###autoload
|
|
|
280 (fset 'plain-TeX-mode 'plain-tex-mode)
|
|
|
281
|
|
|
282 ;;;###autoload
|
|
|
283 (defun latex-mode ()
|
|
|
284 "Major mode for editing files of input for LaTeX.
|
|
|
285 Makes $ and } display the characters they match.
|
|
|
286 Makes \" insert `` when it seems to be the beginning of a quotation,
|
|
|
287 and '' when it appears to be the end; it inserts \" only after a \\.
|
|
|
288
|
|
|
289 Use \\[tex-region] to run LaTeX on the current region, plus the preamble
|
|
|
290 copied from the top of the file (containing \\documentstyle, etc.),
|
|
|
291 running LaTeX under a special subshell. \\[tex-buffer] does the whole buffer.
|
|
|
292 \\[tex-file] saves the buffer and then processes the file.
|
|
|
293 \\[tex-print] prints the .dvi file made by any of these.
|
|
|
294 \\[tex-view] previews the .dvi file made by any of these.
|
|
|
295 \\[tex-bibtex-file] runs bibtex on the file of the current buffer.
|
|
|
296
|
|
|
297 Use \\[validate-tex-buffer] to check buffer for paragraphs containing
|
|
|
298 mismatched $'s or braces.
|
|
|
299
|
|
|
300 Special commands:
|
|
|
301 \\{tex-mode-map}
|
|
|
302
|
|
|
303 Mode variables:
|
|
|
304 latex-run-command
|
|
|
305 Command string used by \\[tex-region] or \\[tex-buffer].
|
|
|
306 tex-directory
|
|
|
307 Directory in which to create temporary files for LaTeX jobs
|
|
|
308 run by \\[tex-region] or \\[tex-buffer].
|
|
|
309 tex-dvi-print-command
|
|
|
310 Command string used by \\[tex-print] to print a .dvi file.
|
|
|
311 tex-alt-dvi-print-command
|
|
|
312 Alternative command string used by \\[tex-print] (when given a prefix
|
|
|
313 argument) to print a .dvi file.
|
|
|
314 tex-dvi-view-command
|
|
|
315 Command string used by \\[tex-view] to preview a .dvi file.
|
|
|
316 tex-show-queue-command
|
|
|
317 Command string used by \\[tex-show-print-queue] to show the print
|
|
|
318 queue that \\[tex-print] put your job on.
|
|
|
319
|
|
|
320 Entering Latex mode calls the value of text-mode-hook, then the value of
|
|
|
321 tex-mode-hook, and then the value of latex-mode-hook. When the special
|
|
|
322 subshell is initiated, the value of tex-shell-hook is called."
|
|
|
323 (interactive)
|
|
|
324 (tex-common-initialization)
|
|
|
325 (setq mode-name "LaTeX")
|
|
|
326 (setq major-mode 'latex-mode)
|
|
|
327 (setq tex-command latex-run-command)
|
|
|
328 (setq tex-start-of-header "\\documentstyle")
|
|
|
329 (setq tex-end-of-header "\\begin{document}")
|
|
|
330 (setq tex-trailer "\\end{document}\n")
|
|
|
331 (run-hooks 'text-mode-hook 'tex-mode-hook 'latex-mode-hook))
|
|
|
332
|
|
|
333 (defun slitex-mode ()
|
|
|
334 "Major mode for editing files of input for SliTeX.
|
|
|
335 Makes $ and } display the characters they match.
|
|
|
336 Makes \" insert `` when it seems to be the beginning of a quotation,
|
|
|
337 and '' when it appears to be the end; it inserts \" only after a \\.
|
|
|
338
|
|
|
339 Use \\[tex-region] to run SliTeX on the current region, plus the preamble
|
|
|
340 copied from the top of the file (containing \\documentstyle, etc.),
|
|
|
341 running SliTeX under a special subshell. \\[tex-buffer] does the whole buffer.
|
|
|
342 \\[tex-file] saves the buffer and then processes the file.
|
|
|
343 \\[tex-print] prints the .dvi file made by any of these.
|
|
|
344 \\[tex-view] previews the .dvi file made by any of these.
|
|
|
345 \\[tex-bibtex-file] runs bibtex on the file of the current buffer.
|
|
|
346
|
|
|
347 Use \\[validate-tex-buffer] to check buffer for paragraphs containing
|
|
|
348 mismatched $'s or braces.
|
|
|
349
|
|
|
350 Special commands:
|
|
|
351 \\{tex-mode-map}
|
|
|
352
|
|
|
353 Mode variables:
|
|
|
354 slitex-run-command
|
|
|
355 Command string used by \\[tex-region] or \\[tex-buffer].
|
|
|
356 tex-directory
|
|
|
357 Directory in which to create temporary files for SliTeX jobs
|
|
|
358 run by \\[tex-region] or \\[tex-buffer].
|
|
|
359 tex-dvi-print-command
|
|
|
360 Command string used by \\[tex-print] to print a .dvi file.
|
|
|
361 tex-alt-dvi-print-command
|
|
|
362 Alternative command string used by \\[tex-print] (when given a prefix
|
|
|
363 argument) to print a .dvi file.
|
|
|
364 tex-dvi-view-command
|
|
|
365 Command string used by \\[tex-view] to preview a .dvi file.
|
|
|
366 tex-show-queue-command
|
|
|
367 Command string used by \\[tex-show-print-queue] to show the print
|
|
|
368 queue that \\[tex-print] put your job on.
|
|
|
369
|
|
|
370 Entering SliTeX mode calls the value of text-mode-hook, then the value of
|
|
|
371 tex-mode-hook, then the value of latex-mode-hook, and then the value of
|
|
|
372 slitex-mode-hook. When the special subshell is initiated, the value of
|
|
|
373 tex-shell-hook is called."
|
|
|
374 (interactive)
|
|
|
375 (tex-common-initialization)
|
|
|
376 (setq mode-name "SliTeX")
|
|
|
377 (setq major-mode 'slitex-mode)
|
|
|
378 (setq tex-command slitex-run-command)
|
|
|
379 (setq tex-start-of-header "\\documentstyle{slides}")
|
|
|
380 (setq tex-end-of-header "\\begin{document}")
|
|
|
381 (setq tex-trailer "\\end{document}\n")
|
|
|
382 (run-hooks
|
|
|
383 'text-mode-hook 'tex-mode-hook 'latex-mode-hook 'slitex-mode-hook))
|
|
|
384
|
|
|
385 (defun tex-common-initialization ()
|
|
|
386 (kill-all-local-variables)
|
|
|
387 (use-local-map tex-mode-map)
|
|
|
388 (setq local-abbrev-table text-mode-abbrev-table)
|
|
|
389 (if (null tex-mode-syntax-table)
|
|
|
390 (let ((char 0))
|
|
|
391 (setq tex-mode-syntax-table (make-syntax-table))
|
|
|
392 (set-syntax-table tex-mode-syntax-table)
|
|
|
393 (while (< char ? )
|
|
|
394 (modify-syntax-entry char ".")
|
|
|
395 (setq char (1+ char)))
|
|
|
396 (modify-syntax-entry ?\C-@ "w")
|
|
|
397 (modify-syntax-entry ?\t " ")
|
|
|
398 (modify-syntax-entry ?\n ">")
|
|
|
399 (modify-syntax-entry ?\f ">")
|
|
|
400 (modify-syntax-entry ?$ "$$")
|
|
|
401 (modify-syntax-entry ?% "<")
|
|
|
402 (modify-syntax-entry ?\\ "/")
|
|
|
403 (modify-syntax-entry ?\" ".")
|
|
|
404 (modify-syntax-entry ?& ".")
|
|
|
405 (modify-syntax-entry ?_ ".")
|
|
|
406 (modify-syntax-entry ?@ "_")
|
|
|
407 (modify-syntax-entry ?~ " ")
|
|
|
408 (modify-syntax-entry ?' "w"))
|
|
|
409 (set-syntax-table tex-mode-syntax-table))
|
|
|
410 (make-local-variable 'paragraph-start)
|
|
|
411 (setq paragraph-start "^[ \t]*$\\|^[\f\\\\%]")
|
|
|
412 (make-local-variable 'paragraph-separate)
|
|
|
413 (setq paragraph-separate paragraph-start)
|
|
|
414 (make-local-variable 'comment-start)
|
|
|
415 (setq comment-start "%")
|
|
|
416 (make-local-variable 'comment-start-skip)
|
|
|
417 (setq comment-start-skip "\\(\\(^\\|[^\\]\\)\\(\\\\\\\\\\)*\\)\\(%+ *\\)")
|
|
|
418 (make-local-variable 'comment-indent-function)
|
|
|
419 (setq comment-indent-function 'tex-comment-indent)
|
|
|
420 (make-local-variable 'compare-windows-whitespace)
|
|
|
421 (setq compare-windows-whitespace 'tex-categorize-whitespace)
|
|
|
422 (make-local-variable 'tex-command)
|
|
|
423 (make-local-variable 'tex-start-of-header)
|
|
|
424 (make-local-variable 'tex-end-of-header)
|
|
|
425 (make-local-variable 'tex-trailer))
|
|
|
426
|
|
|
427 (defun tex-comment-indent ()
|
|
|
428 (if (looking-at "%%%")
|
|
|
429 (current-column)
|
|
|
430 (skip-chars-backward " \t")
|
|
|
431 (max (if (bolp) 0 (1+ (current-column)))
|
|
|
432 comment-column)))
|
|
|
433
|
|
|
434 (defun tex-categorize-whitespace (backward-limit)
|
|
|
435 ;; compare-windows-whitespace is set to this.
|
|
|
436 ;; This is basically a finite-state machine.
|
|
|
437 ;; Returns a symbol telling how TeX would treat
|
|
|
438 ;; the whitespace we are looking at: null, space, or par.
|
|
|
439 (let ((category 'null)
|
|
|
440 (not-finished t))
|
|
|
441 (skip-chars-backward " \t\n\f" backward-limit)
|
|
|
442 (while not-finished
|
|
|
443 (cond ((looking-at "[ \t]+")
|
|
|
444 (goto-char (match-end 0))
|
|
|
445 (if (eql category 'null)
|
|
|
446 (setq category 'space)))
|
|
|
447 ((looking-at "\n")
|
|
|
448 (cond ((eql category 'newline)
|
|
|
449 (setq category 'par)
|
|
|
450 (setq not-finished nil))
|
|
|
451 (t
|
|
|
452 (setq category 'newline) ;a strictly internal state
|
|
|
453 (goto-char (match-end 0)))))
|
|
|
454 ((looking-at "\f+")
|
|
|
455 (setq category 'par)
|
|
|
456 (setq not-finished nil))
|
|
|
457 (t
|
|
|
458 (setq not-finished nil))))
|
|
|
459 (skip-chars-forward " \t\n\f")
|
|
|
460 (if (eql category 'newline)
|
|
|
461 'space ;TeX doesn't distinguish
|
|
|
462 category)))
|
|
|
463
|
|
|
464 (defun tex-insert-quote (arg)
|
|
|
465 "Insert the appropriate quote marks for TeX.
|
|
|
466 Inserts the value of tex-open-quote (normally ``) or tex-close-quote
|
|
|
467 (normally '') depending on the context. With prefix argument, always
|
|
|
468 inserts \" characters."
|
|
|
469 (interactive "*P")
|
|
|
470 (if arg
|
|
|
471 (self-insert-command (prefix-numeric-value arg))
|
|
|
472 (insert
|
|
|
473 (cond ((or (bobp)
|
|
|
474 (save-excursion
|
|
|
475 (forward-char -1)
|
|
|
476 (looking-at "\\s(\\|\\s \\|\\s>")))
|
|
|
477 tex-open-quote)
|
|
|
478 ((= (preceding-char) ?\\)
|
|
|
479 ?\")
|
|
|
480 (t
|
|
|
481 tex-close-quote)))))
|
|
|
482
|
|
|
483 (defun validate-tex-buffer ()
|
|
|
484 "Check current buffer for paragraphs containing mismatched $'s.
|
|
|
485 As each such paragraph is found, a mark is pushed at its beginning,
|
|
|
486 and the location is displayed for a few seconds."
|
|
|
487 (interactive)
|
|
|
488 (let ((opoint (point)))
|
|
|
489 (goto-char (point-max))
|
|
|
490 ;; Does not use save-excursion
|
|
|
491 ;; because we do not want to save the mark.
|
|
|
492 (unwind-protect
|
|
|
493 (while (and (not (input-pending-p)) (not (bobp)))
|
|
|
494 (let ((end (point)))
|
|
|
495 (search-backward "\n\n" nil 'move)
|
|
|
496 (or (tex-validate-region (point) end)
|
|
|
497 (progn
|
|
|
498 (push-mark (point))
|
|
|
499 (message "Mismatch found in pararaph starting here")
|
|
|
500 (sit-for 4)))))
|
|
|
501 (goto-char opoint))))
|
|
|
502
|
|
|
503 (defun tex-validate-region (start end)
|
|
|
504 "Check for mismatched braces or $'s in region.
|
|
|
505 Returns t if no mismatches. Returns nil and moves point to suspect
|
|
|
506 area if a mismatch is found."
|
|
|
507 (interactive "r")
|
|
|
508 (let ((failure-point nil) (max-possible-sexps (- end start)))
|
|
|
509 (save-excursion
|
|
|
510 (condition-case ()
|
|
|
511 (save-restriction
|
|
|
512 (narrow-to-region start end)
|
|
|
513 (goto-char start)
|
|
|
514 (while (< 0 (setq max-possible-sexps (1- max-possible-sexps)))
|
|
|
515 (forward-sexp 1)))
|
|
|
516 (error
|
|
|
517 (setq failure-point (point)))))
|
|
|
518 (if failure-point
|
|
|
519 (progn
|
|
|
520 (goto-char failure-point)
|
|
|
521 nil)
|
|
|
522 t)))
|
|
|
523
|
|
|
524 (defun tex-terminate-paragraph (inhibit-validation)
|
|
|
525 "Insert two newlines, breaking a paragraph for TeX.
|
|
|
526 Check for mismatched braces/$'s in paragraph being terminated.
|
|
|
527 A prefix arg inhibits the checking."
|
|
|
528 (interactive "*P")
|
|
|
529 (or inhibit-validation
|
|
|
530 (save-excursion
|
|
|
531 (tex-validate-region
|
|
|
532 (save-excursion
|
|
|
533 (search-backward "\n\n" nil 'move)
|
|
|
534 (point))
|
|
|
535 (point)))
|
|
|
536 (message "Paragraph being closed appears to contain a mismatch"))
|
|
|
537 (insert "\n\n"))
|
|
|
538
|
|
|
539 (defun tex-insert-braces ()
|
|
|
540 "Make a pair of braces and be poised to type inside of them."
|
|
|
541 (interactive "*")
|
|
|
542 (insert ?\{)
|
|
|
543 (save-excursion
|
|
|
544 (insert ?})))
|
|
|
545
|
|
|
546 ;;; Like tex-insert-braces, but for LaTeX.
|
|
|
547 (defun tex-latex-block (name)
|
|
|
548 "Creates a matching pair of lines \\begin{NAME} and \\end{NAME} at point.
|
|
|
549 Puts point on a blank line between them."
|
|
|
550 (interactive
|
|
|
551 (prog2
|
|
|
552 (barf-if-buffer-read-only)
|
|
|
553 (list
|
|
|
554 (completing-read "LaTeX block name: "
|
|
|
555 (mapcar 'list
|
|
|
556 (append standard-latex-block-names
|
|
|
557 latex-block-names))))))
|
|
|
558 (let ((col (current-column)))
|
|
|
559 (insert (format "\\begin{%s}\n" name))
|
|
|
560 (indent-to col)
|
|
|
561 (save-excursion
|
|
|
562 (insert ?\n)
|
|
|
563 (indent-to col)
|
|
|
564 (insert (format "\\end{%s}" name))
|
|
|
565 (if (eobp) (insert ?\n)))))
|
|
|
566
|
|
|
567 (defun tex-last-unended-begin ()
|
|
|
568 "Leave point at the beginning of the last \\begin{...} that is unended."
|
|
|
569 (while (and (re-search-backward "\\(\\\\begin\\s *{\\)\\|\\(\\\\end\\s *{\\)")
|
|
|
570 (looking-at "\\\\end{"))
|
|
|
571 (tex-last-unended-begin)))
|
|
|
572
|
|
|
573 (defun tex-close-latex-block ()
|
|
|
574 "Creates an \\end{...} to match the last unclosed \\begin{...}."
|
|
|
575 (interactive "*")
|
|
|
576 (let ((new-line-needed (bolp))
|
|
|
577 text indentation)
|
|
|
578 (save-excursion
|
|
|
579 (condition-case nil
|
|
|
580 (tex-last-unended-begin)
|
|
|
581 (error (error "Couldn't find unended \\begin")))
|
|
|
582 (setq indentation (current-column))
|
|
|
583 (re-search-forward "\\\\begin\\(\\s *{[^}\n]*}\\)")
|
|
|
584 (setq text (buffer-substring (match-beginning 1) (match-end 1))))
|
|
|
585 (indent-to indentation)
|
|
|
586 (insert "\\end" text)
|
|
|
587 (if new-line-needed (insert ?\n))))
|
|
|
588
|
|
|
589 ;;; Invoking TeX in an inferior shell.
|
|
|
590
|
|
|
591 ;;; Why use a shell instead of running TeX directly? Because if TeX
|
|
|
592 ;;; gets stuck, the user can switch to the shell window and type at it.
|
|
|
593
|
|
|
594 ;;; The utility functions:
|
|
|
595
|
|
|
596 (defun tex-start-shell ()
|
|
|
597 (save-excursion
|
|
|
598 (set-buffer
|
|
|
599 (make-comint
|
|
|
600 "tex-shell"
|
|
|
601 (or tex-shell-file-name (getenv "ESHELL") (getenv "SHELL") "/bin/sh")
|
|
|
602 nil "-v"))
|
|
|
603 (let ((proc (get-process "tex-shell")))
|
|
|
604 (set-process-sentinel proc 'tex-shell-sentinel)
|
|
|
605 (process-kill-without-query proc)
|
|
|
606 (setq tex-shell-map (copy-keymap comint-mode-map))
|
|
|
607 (tex-define-common-keys tex-shell-map)
|
|
|
608 (use-local-map tex-shell-map)
|
|
|
609 (run-hooks 'tex-shell-hook)
|
|
|
610 (while (zerop (buffer-size))
|
|
|
611 (sleep-for 1)))))
|
|
|
612
|
|
|
613 (defun tex-shell-sentinel (proc msg)
|
|
|
614 (cond ((null (buffer-name (process-buffer proc)))
|
|
|
615 ;; buffer killed
|
|
|
616 (set-process-buffer proc nil)
|
|
|
617 (tex-delete-last-temp-files))
|
|
|
618 ((memq (process-status proc) '(signal exit))
|
|
|
619 (tex-delete-last-temp-files))))
|
|
|
620
|
|
|
621 (defun tex-set-buffer-directory (buffer directory)
|
|
|
622 "Set BUFFER's default directory to be DIRECTORY."
|
|
|
623 (setq directory (file-name-as-directory (expand-file-name directory)))
|
|
|
624 (if (not (file-directory-p directory))
|
|
|
625 (error "%s is not a directory" directory)
|
|
|
626 (save-excursion
|
|
|
627 (set-buffer buffer)
|
|
|
628 (setq default-directory directory))))
|
|
|
629
|
|
|
630 (defun tex-send-command (command &optional file background)
|
|
|
631 "Send COMMAND to tex-shell, substituting optional FILE for *; in background
|
|
|
632 if optional BACKGROUND is t. If COMMAND has no *, FILE will be appended,
|
|
|
633 preceded by a blank, to COMMAND. If FILE is nil, no substitution will be made
|
|
|
634 in COMMAND. COMMAND can be any expression that evaluates to a command string."
|
|
|
635 (save-excursion
|
|
|
636 (let* ((cmd (eval command))
|
|
|
637 (star (string-match "\\*" cmd)))
|
|
|
638 (comint-proc-query (get-process "tex-shell")
|
|
|
639 (concat (substring cmd 0 star)
|
|
|
640 (if file (concat " " file) "")
|
|
|
641 (if star (substring cmd (1+ star) nil) "")
|
|
|
642 (if background "&\n" "\n"))))))
|
|
|
643
|
|
|
644 (defun tex-delete-last-temp-files ()
|
|
|
645 "Delete any junk files from last temp file."
|
|
|
646 (if tex-last-temp-file
|
|
|
647 (let* ((dir (file-name-directory tex-last-temp-file))
|
|
|
648 (list (file-name-all-completions
|
|
|
649 (file-name-nondirectory tex-last-temp-file) dir)))
|
|
|
650 (while list
|
|
|
651 (delete-file (concat dir (car list)))
|
|
|
652 (setq list (cdr list))))))
|
|
|
653
|
|
|
654 (add-hook 'kill-emacs-hook 'tex-delete-last-temp-files)
|
|
|
655
|
|
|
656 ;;; The commands:
|
|
|
657
|
|
|
658 (defun tex-region (beg end)
|
|
|
659 "Run TeX on the current region, via a temporary file.
|
|
|
660 The file's name comes from the variable `tex-zap-file' and the
|
|
|
661 variable `tex-directory' says where to put it.
|
|
|
662
|
|
|
663 If the buffer has a header, the header is given to TeX before the
|
|
|
664 region itself. The buffer's header is all lines between the strings
|
|
|
665 defined by `tex-start-of-header' and `tex-end-of-header' inclusive.
|
|
|
666 The header must start in the first 100 lines of the buffer.
|
|
|
667
|
|
|
668 The value of `tex-trailer' is given to TeX as input after the region.
|
|
|
669
|
|
|
670 The value of `tex-command' specifies the command to use to run TeX."
|
|
|
671 (interactive "r")
|
|
|
672 (if (tex-shell-running)
|
|
|
673 (tex-kill-job)
|
|
|
674 (tex-start-shell))
|
|
|
675 (or tex-zap-file
|
|
|
676 (setq tex-zap-file (tex-generate-zap-file-name)))
|
|
|
677 (let* ((temp-buffer (get-buffer-create " TeX-Output-Buffer"))
|
|
|
678 ; Temp file will be written and TeX will be run in zap-directory.
|
|
|
679 ; If the TEXINPUTS file has relative directories or if the region has
|
|
|
680 ; \input of files, this must be the same directory as the file for
|
|
|
681 ; TeX to access the correct inputs. That's why it's safest if
|
|
|
682 ; tex-directory is ".".
|
|
|
683 (zap-directory
|
|
|
684 (file-name-as-directory (expand-file-name tex-directory)))
|
|
|
685 (tex-out-file (concat zap-directory tex-zap-file)))
|
|
|
686 (tex-delete-last-temp-files)
|
|
|
687 ;; Write the new temp file.
|
|
|
688 (save-excursion
|
|
|
689 (save-restriction
|
|
|
690 (widen)
|
|
|
691 (goto-char (point-min))
|
|
|
692 (forward-line 100)
|
|
|
693 (let ((search-end (point))
|
|
|
694 (hbeg (point-min)) (hend (point-min))
|
|
|
695 (default-directory zap-directory))
|
|
|
696 (goto-char (point-min))
|
|
|
697 ;; Initialize the temp file with either the header or nothing
|
|
|
698 (if (search-forward tex-start-of-header search-end t)
|
|
|
699 (progn
|
|
|
700 (beginning-of-line)
|
|
|
701 (setq hbeg (point)) ;mark beginning of header
|
|
|
702 (if (search-forward tex-end-of-header nil t)
|
|
|
703 (progn (forward-line 1)
|
|
|
704 (setq hend (point))) ;mark end of header
|
|
|
705 (setq hbeg (point-min))))) ;no header
|
|
|
706 (write-region (min hbeg beg) hend
|
|
|
707 (concat tex-out-file ".tex") nil nil)
|
|
|
708 (write-region (max beg hend) end (concat tex-out-file ".tex") t nil))
|
|
|
709 (let ((local-tex-trailer tex-trailer))
|
|
|
710 (set-buffer temp-buffer)
|
|
|
711 (erase-buffer)
|
|
|
712 ;; make sure trailer isn't hidden by a comment
|
|
|
713 (insert ?\n)
|
|
|
714 (if local-tex-trailer (insert local-tex-trailer))
|
|
|
715 (tex-set-buffer-directory temp-buffer zap-directory)
|
|
|
716 (write-region (point-min) (point-max)
|
|
|
717 (concat tex-out-file ".tex") t nil))))
|
|
|
718 ;; Record the file name to be deleted afterward.
|
|
|
719 (setq tex-last-temp-file tex-out-file)
|
|
|
720 (tex-send-command tex-shell-cd-command zap-directory)
|
|
|
721 (tex-send-command tex-command tex-out-file)
|
|
|
722 (setq tex-print-file tex-out-file)
|
|
|
723 (setq tex-last-buffer-texed (current-buffer))))
|
|
|
724
|
|
|
725 (defun tex-buffer ()
|
|
|
726 "Run TeX on current buffer. See \\[tex-region] for more information.
|
|
|
727 Does not save the buffer, so it's useful for trying experimental versions.
|
|
|
728 See \\[tex-file] for an alternative."
|
|
|
729 (interactive)
|
|
|
730 (tex-region (point-min) (point-max)))
|
|
|
731
|
|
|
732 (defun tex-file ()
|
|
|
733 "Prompt to save all buffers and run TeX (or LaTeX) on current buffer's file.
|
|
|
734 This function is more useful than \\[tex-buffer] when you need the
|
|
|
735 `.aux' file of LaTeX to have the correct name."
|
|
|
736 (interactive)
|
|
|
737 (let ((tex-out-file
|
|
|
738 (if (buffer-file-name)
|
|
|
739 (file-name-nondirectory (buffer-file-name))
|
|
|
740 (error "Buffer does not seem to be associated with any file")))
|
|
|
741 (file-dir (file-name-directory (buffer-file-name))))
|
|
|
742 (save-some-buffers)
|
|
|
743 (if (tex-shell-running)
|
|
|
744 (tex-kill-job)
|
|
|
745 (tex-start-shell))
|
|
|
746 (tex-send-command tex-shell-cd-command file-dir)
|
|
|
747 (tex-send-command tex-command tex-out-file))
|
|
|
748 (setq tex-last-buffer-texed (current-buffer))
|
|
|
749 (setq tex-print-file (buffer-file-name)))
|
|
|
750
|
|
|
751 (defun tex-generate-zap-file-name ()
|
|
|
752 "Generate a unique name suitable for use as a file name."
|
|
|
753 ;; Include the shell process number and host name
|
|
|
754 ;; in case there are multiple shells (for same or different user).
|
|
|
755 (format "#tz%d%s"
|
|
|
756 (process-id (get-buffer-process "*tex-shell*"))
|
|
|
757 (tex-strip-dots (system-name))))
|
|
|
758
|
|
|
759 (defun tex-strip-dots (s)
|
|
|
760 (setq s (copy-sequence s))
|
|
|
761 (while (string-match "\\." s)
|
|
|
762 (aset s (match-beginning 0) ?-))
|
|
|
763 s)
|
|
|
764
|
|
|
765 ;; This will perhaps be useful for modifying TEXINPUTS.
|
|
|
766 ;; Expand each file name, separated by colons, in the string S.
|
|
|
767 (defun tex-expand-files (s)
|
|
|
768 (let (elts (start 0))
|
|
|
769 (while (string-match ":" s start)
|
|
|
770 (setq elts (cons (substring s start (match-beginning 0)) elts))
|
|
|
771 (setq start (match-end 0)))
|
|
|
772 (or (= start 0)
|
|
|
773 (setq elts (cons (substring s start) elts)))
|
|
|
774 (mapconcat 'expand-file-name (nreverse elts) ":")))
|
|
|
775
|
|
|
776 (defun tex-shell-running ()
|
|
|
777 (and (get-process "tex-shell")
|
|
|
778 (eq (process-status (get-process "tex-shell")) 'run)))
|
|
|
779
|
|
|
780 (defun tex-kill-job ()
|
|
|
781 "Kill the currently running TeX job."
|
|
|
782 (interactive)
|
|
|
783 (quit-process (get-process "tex-shell") t))
|
|
|
784
|
|
|
785 (defun tex-recenter-output-buffer (linenum)
|
|
|
786 "Redisplay buffer of TeX job output so that most recent output can be seen.
|
|
|
787 The last line of the buffer is displayed on
|
|
|
788 line LINE of the window, or centered if LINE is nil."
|
|
|
789 (interactive "P")
|
|
|
790 (let ((tex-shell (get-buffer "*tex-shell*"))
|
|
|
791 (old-buffer (current-buffer)))
|
|
|
792 (if (null tex-shell)
|
|
|
793 (message "No TeX output buffer")
|
|
|
794 (pop-to-buffer tex-shell)
|
|
|
795 (bury-buffer tex-shell)
|
|
|
796 (goto-char (point-max))
|
|
|
797 (recenter (if linenum
|
|
|
798 (prefix-numeric-value linenum)
|
|
|
799 (/ (window-height) 2)))
|
|
|
800 (pop-to-buffer old-buffer))))
|
|
|
801
|
|
|
802 (defun tex-print (&optional alt)
|
|
|
803 "Print the .dvi file made by \\[tex-region], \\[tex-buffer] or \\[tex-file].
|
|
|
804 Runs the shell command defined by tex-dvi-print-command. If prefix argument
|
|
|
805 is provided, use the alternative command, tex-alt-dvi-print-command."
|
|
|
806 (interactive "P")
|
|
|
807 (let ((print-file-name-dvi (tex-append tex-print-file ".dvi"))
|
|
|
808 test-name)
|
|
|
809 (if (and (not (equal (current-buffer) tex-last-buffer-texed))
|
|
4
|
810 (buffer-file-name)
|
|
|
811 ;; Check that this buffer's printed file is up to date.
|
|
0
|
812 (file-newer-than-file-p
|
|
|
813 (setq test-name (tex-append (buffer-file-name) ".dvi"))
|
|
4
|
814 (buffer-file-name)))
|
|
0
|
815 (setq print-file-name-dvi test-name))
|
|
|
816 (if (not (file-exists-p print-file-name-dvi))
|
|
|
817 (error "No appropriate `.dvi' file could be found")
|
|
|
818 (tex-send-command
|
|
|
819 (if alt tex-alt-dvi-print-command tex-dvi-print-command)
|
|
|
820 print-file-name-dvi t))))
|
|
|
821
|
|
|
822 (defun tex-view ()
|
|
|
823 "Preview the last `.dvi' file made by running TeX under Emacs.
|
|
|
824 This means, made using \\[tex-region], \\[tex-buffer] or \\[tex-file].
|
|
|
825 The variable `tex-dvi-view-command' specifies the shell command for preview."
|
|
|
826 (interactive)
|
|
|
827 (let ((tex-dvi-print-command tex-dvi-view-command))
|
|
|
828 (tex-print)))
|
|
|
829
|
|
|
830 (defun tex-append (file-name suffix)
|
|
|
831 "Append to FILENAME the suffix SUFFIX, using same algorithm TeX uses.
|
|
|
832 Scans for the first (not last) period.
|
|
|
833 No period is retained immediately before SUFFIX,
|
|
|
834 so normally SUFFIX starts with one."
|
|
|
835 (if (stringp file-name)
|
|
|
836 (let ((file (file-name-nondirectory file-name)))
|
|
|
837 (concat (file-name-directory file-name)
|
|
|
838 (substring file 0
|
|
|
839 (string-match "\\." file))
|
|
|
840 suffix))
|
|
|
841 " "))
|
|
|
842
|
|
|
843 (defun tex-show-print-queue ()
|
|
|
844 "Show the print queue that \\[tex-print] put your job on.
|
|
|
845 Runs the shell command defined by tex-show-queue-command."
|
|
|
846 (interactive)
|
|
|
847 (if (tex-shell-running)
|
|
|
848 (tex-kill-job)
|
|
|
849 (tex-start-shell))
|
|
|
850 (tex-send-command tex-show-queue-command))
|
|
|
851
|
|
|
852 (defun tex-bibtex-file ()
|
|
|
853 "Run BibTeX on the current buffer's file."
|
|
|
854 (interactive)
|
|
|
855 (if (tex-shell-running)
|
|
|
856 (tex-kill-job)
|
|
|
857 (tex-start-shell))
|
|
|
858 (let ((tex-out-file
|
|
|
859 (tex-append (file-name-nondirectory (buffer-file-name)) ""))
|
|
|
860 (file-dir (file-name-directory (buffer-file-name))))
|
|
|
861 (tex-send-command tex-shell-cd-command file-dir)
|
|
|
862 (tex-send-command bibtex-command tex-out-file)))
|
|
|
863
|
|
|
864 (run-hooks 'tex-mode-load-hook)
|
|
|
865
|
|
|
866 (provide 'tex-mode)
|
