Merge from origin/emacs-25
[emacs.git] / lisp / woman.el
bloba4a0da209cb0a61bcbea37cf680d08d946769935
1 ;;; woman.el --- browse UN*X manual pages `wo (without) man'
3 ;; Copyright (C) 2000-2016 Free Software Foundation, Inc.
5 ;; Author: Francis J. Wright <F.J.Wright@qmul.ac.uk>
6 ;; Maintainer: emacs-devel@gnu.org
7 ;; Keywords: help, unix
8 ;; Adapted-By: Eli Zaretskii <eliz@gnu.org>
9 ;; Version: 0.551
10 ;; URL: http://centaur.maths.qmul.ac.uk/Emacs/WoMan/
12 ;; This file is part of GNU Emacs.
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 3 of the License, or
17 ;; (at your option) any later version.
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.
24 ;; You should have received a copy of the GNU General Public License
25 ;; along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>.
27 ;;; Commentary:
29 ;; WoMan implements a subset of the formatting performed by the Emacs
30 ;; `man' (or `manual-entry') command to format a UN*X manual `page'
31 ;; for display, but without calling any external programs. It is
32 ;; intended to emulate the whole of the -man macro package, plus those
33 ;; ?roff requests that are most commonly used in man pages. However,
34 ;; the emulation is modified to include the reformatting done by the
35 ;; Emacs `man' command. No hyphenation is performed.
37 ;; Advantages
39 ;; Much more direct, does not require any external programs.
40 ;; Supports completion on man page names.
42 ;; Disadvantages
44 ;; Not a complete emulation. Currently no support for eqn or tbl.
45 ;; Slightly slower for large man pages (but usually faster for
46 ;; small- and medium-size pages).
48 ;; This browser works quite well on simple well-written man files. It
49 ;; works less well on idiosyncratic files that `break the rules' or
50 ;; use the more obscure ?roff requests directly. Current test results
51 ;; are available in the file woman.status.
53 ;; WoMan supports the use of compressed man files via
54 ;; `auto-compression-mode' by turning it on if necessary. But you may
55 ;; need to adjust the user option `woman-file-compression-regexp'.
57 ;; Read on for (currently) the only documentation for WoMan!
59 ;; See also the documentation for the WoMan interactive commands and
60 ;; user option variables, all of which begin with the prefix `woman-'.
61 ;; This can be done most easily by loading WoMan and then running the
62 ;; command `woman-mini-help', or selecting the WoMan menu option `Mini
63 ;; Help' when WoMan is running.
65 ;; WoMan is still under development! Please let me know what doesn't
66 ;; work -- I am adding and improving functionality as testing shows
67 ;; that it is necessary. See below for guidance on reporting bugs.
69 ;; Recommended use
70 ;; ===============
72 ;; Put this in your .emacs:
73 ;; (autoload 'woman "woman"
74 ;; "Decode and browse a UN*X man page." t)
75 ;; (autoload 'woman-find-file "woman"
76 ;; "Find, decode and browse a specific UN*X man-page file." t)
78 ;; Then either (1 -- *RECOMMENDED*): If the `MANPATH' environment
79 ;; variable is set then WoMan will use it; otherwise you may need to
80 ;; reset the Lisp variable `woman-manpath', and you may also want to
81 ;; set the Lisp variable `woman-path'. Please see the online
82 ;; documentation for these variables. Now you can execute the
83 ;; extended command `woman', enter or select a manual entry topic,
84 ;; using completion, and if necessary select a filename, using
85 ;; completion. By default, WoMan suggests the word nearest to the
86 ;; cursor in the current buffer as the topic.
88 ;; Or (2): Execute the extended command `woman-find-file' and enter a
89 ;; filename, using completion. This mode of execution may be useful
90 ;; for temporary files outside the standard UN*X manual directory
91 ;; structure.
93 ;; Or (3): Put the next two sexpr's in your .emacs:
94 ;; (autoload 'woman-dired-find-file "woman"
95 ;; "In dired, run the WoMan man-page browser on this file." t)
96 ;; (add-hook 'dired-mode-hook
97 ;; (lambda ()
98 ;; (define-key dired-mode-map "W" 'woman-dired-find-file)))
99 ;; and open the directory containing the man page file using dired,
100 ;; put the cursor on the file, and press `W'.
102 ;; In each case, the result should (!) be a buffer in Man mode showing
103 ;; a formatted manual entry. When called from WoMan, Man mode should
104 ;; work as advertised, but modified where necessary in the context of
105 ;; WoMan. (However, `Man' will still invoke the standard Emacs
106 ;; manual-browsing facility rather than `WoMan' -- this is
107 ;; intentional!)
109 ;; (By default, WoMan will automatically define the dired keys "W" and
110 ;; "w" when it loads, but only if they are not already defined. This
111 ;; behavior is controlled by the user option `woman-dired-keys'.
112 ;; Note that the `dired-x' (dired extra) package binds
113 ;; `dired-copy-filename-as-kill' to the key "w" (as pointed out by Jim
114 ;; Davidson), although "W" appears to be really unused. The `dired-x'
115 ;; package will over-write the WoMan binding to "w", whereas (by
116 ;; default) WoMan will not overwrite the `dired-x' binding.)
118 ;; Using the word at point as the default topic
119 ;; ============================================
121 ;; The `woman' command uses the word nearest to point in the current
122 ;; buffer as the default topic to look up if it matches the name of a
123 ;; manual page installed on the system. The default topic can also be
124 ;; used without confirmation by setting the user-option
125 ;; `woman-use-topic-at-point' to t; thanks to Benjamin Riefenstahl for
126 ;; suggesting this functionality.
128 ;; The variable `woman-use-topic-at-point' can be rebound locally,
129 ;; which may be useful to provide special private key bindings, e.g.
131 ;; (global-set-key "\C-cw"
132 ;; (lambda ()
133 ;; (interactive)
134 ;; (let ((woman-use-topic-at-point t))
135 ;; (woman)))))
138 ;; Customization, Hooks and Imenu
139 ;; ==============================
141 ;; WoMan supports the GNU Emacs 20+ customization facility, and puts
142 ;; a customization group called `WoMan' in the `Help' group under the
143 ;; top-level `Emacs' group. In order to be able to customize WoMan
144 ;; without first loading it, add the following sexp to your .emacs:
146 ;; (defgroup woman nil
147 ;; "Browse UNIX manual pages `wo (without) man'."
148 ;; :tag "WoMan" :group 'help :load "woman")
151 ;; WoMan currently runs two hooks: `woman-pre-format-hook' immediately
152 ;; before formatting a buffer and `woman-post-format-hook' immediately
153 ;; after formatting a buffer. These hooks can be used for special
154 ;; customizations that require code to be executed, etc., although
155 ;; most customization should be possible by setting WoMan user option
156 ;; variables, e.g. in `.emacs' and should NOT require the use of the
157 ;; hooks. `woman-pre-format-hook' might be appropriate for face
158 ;; customization, whereas `woman-post-format-hook' might be
159 ;; appropriate for installing a dynamic menu using `imenu' (although
160 ;; it is better to use the built-in WoMan imenu support).
162 ;; The WoMan menu provides an option to make a contents menu for the
163 ;; current man page (using imenu). Alternatively, if you set the
164 ;; variable `woman-imenu' to t then WoMan will do it automatically
165 ;; for every man page. The menu title is the value of the variable
166 ;; `woman-imenu-title', which is "CONTENTS" by default. By default,
167 ;; the menu shows manual sections and subsections, but you can change
168 ;; this by changing the value of `woman-imenu-generic-expression'.
169 ;; This facility is not yet widely tested and may be fooled by obscure
170 ;; man pages that `break the rules'.
172 ;; WoMan is configured not to replace spaces in an imenu *Completion*
173 ;; buffer. For further documentation of the use of imenu, such as
174 ;; menu sorting, see the source file imenu.el, which is distributed
175 ;; with GNU Emacs.
177 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
179 ;; Howard Melman made (essentially) the following suggestions, which
180 ;; are slightly different from the expression that I currently use.
181 ;; You may prefer one of Howard's suggestions, which I think assume
182 ;; that `case-fold-search' is t (which it is by default):
184 ;; (setq woman-imenu-generic-expression
185 ;; '((nil "^\\( \\)?\\([A-Z][A-Z ]+[A-Z]\\)[ \t]*$" 2)))
187 ;; will give support for .SH and .SS, though it won't show the heading
188 ;; name hierarchy. If you just want .SH in the imenu then use:
190 ;; (setq woman-imenu-generic-expression
191 ;; '((nil "^\\([A-Z][A-Z ]+[A-Z]\\)[ \t]*$" 1)))
193 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
196 ;; Vertical spacing and blank lines
197 ;; ================================
199 ;; The number of consecutive blank lines in the formatted buffer
200 ;; should be either 0 or 1. A blank line should leave a space like
201 ;; .sp 1 (p. 14). Current policy is to output vertical space only
202 ;; immediately before text is output.
205 ;; Horizontal and vertical spacing and resolution
206 ;; ==============================================
208 ;; WoMan currently assumes 10 characters per inch horizontally, hence
209 ;; a horizontal resolution of 24 basic units, and 5 lines per inch
210 ;; vertically, hence a vertical resolution of 48 basic units. (nroff
211 ;; uses 240 per inch).
214 ;; The *WoMan-Log* buffer
215 ;; ======================
217 ;; This is modeled on the byte-compiler. It logs all files formatted
218 ;; by WoMan, and if WoMan finds anything that it cannot handle then it
219 ;; writes a warning to this buffer. If the variable `woman-show-log'
220 ;; is non-nil (by default it is nil) then WoMan automatically
221 ;; displays this buffer. Many WoMan warnings can be completely
222 ;; ignored, because they are reporting the fact that WoMan has ignored
223 ;; requests that it is correct to ignore. In some future version this
224 ;; level of paranoia will be reduced, but not until WoMan is more
225 ;; reliable. At present, all warnings should be treated with some
226 ;; suspicion. Uninterpreted escape sequences are also logged (in some
227 ;; cases).
229 ;; Uninterpreted ?roff requests can optionally be left in the
230 ;; formatted buffer to indicate precisely where they occur by
231 ;; resetting the variable `woman-ignore' to nil (by default it is
232 ;; t).
234 ;; Automatic initiation of woman decoding
236 ;; (Probably not a good idea. If you use it, be careful!)
238 ;; Put something like this in your .emacs. The call to
239 ;; set-visited-file-name is to avoid font-locking triggered by
240 ;; automatic major mode selection.
242 ;; (autoload 'woman-decode-region "woman")
244 ;; (setq format-alist
245 ;; (cons
246 ;; '(man "UN*X man-page source format" "\\.\\(TH\\|ig\\) "
247 ;; woman-decode-region nil nil
248 ;; (lambda (arg)
249 ;; set-visited-file-name
250 ;; (file-name-sans-extension buffer-file-name)))))
251 ;; format-alist))
254 ;; Reporting Bugs
255 ;; ==============
257 ;; If WoMan fails completely, or formats a file incorrectly
258 ;; (i.e. obviously wrongly or significantly differently from man) or
259 ;; inelegantly, then please
261 ;; (a) check that you are running the latest version of woman.el
262 ;; available from my web site (see above),
264 ;; (b) check that the problem is not already described in the file
265 ;; woman.status, also available from my web site.
267 ;; If both of the above are true then please email me the entry from
268 ;; the *WoMan-Log* buffer relating to the problem file, together with
269 ;; a brief description of the problem. Please indicate where you got
270 ;; the source file from, but do not send it to me unless I ask you to!
271 ;; Thanks. (There is at present no automated bug-reporting facility
272 ;; for WoMan.)
274 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
276 ;; NOTE:
278 ;; CASE-DEPENDENCE OF FILENAMES. By default, WoMan ignores case in
279 ;; file pathnames only when it seems appropriate. MS-Windows users
280 ;; who want complete case independence should set the NTEmacs variable
281 ;; `w32-downcase-file-names' to t and use all lower case when
282 ;; setting WoMan file paths.
284 ;; (1) INCOMPATIBLE CHANGE! WoMan no longer uses a persistent topic
285 ;; cache by default. (It caused too much confusion!) Explicitly set
286 ;; the variable `woman-cache-filename' to save the cache between Emacs
287 ;; sessions. This is recommended only if the command `woman' is too
288 ;; slow the first time that it is run in an Emacs session, while it
289 ;; builds its cache in main memory, which MAY be VERY slow.
291 ;; (2) The user option `woman-cache-level' controls the amount of
292 ;; information cached (in main memory and, optionally, saved to disc).
294 ;; (3) UPDATING THE CACHE. A prefix argument always causes the
295 ;; `woman' command (only) to rebuild its topic cache, and to re-save
296 ;; it to `woman-cache-filename' if this variable has a non-nil value.
297 ;; This is necessary if the NAMES (not contents) of any of the
298 ;; directories or files in the paths specified by `woman-manpath' or
299 ;; `woman-path' change. If WoMan user options that affect the cache
300 ;; are changed then WoMan will automatically update its cache file on
301 ;; disc (if one is in use) the next time it is run in a new Emacs
302 ;; session.
304 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
307 ;; TO DO
308 ;; =====
310 ;; Reconsider case sensitivity of file names.
311 ;; MUST PROCESS .if, .nr IN ORDER ENCOUNTERED IN FILE! (rcsfile, mf).
312 ;; Allow general delimiter in `\v', cf. `\h'.
313 ;; Improve major-mode documentation.
314 ;; Pre-process conditionals in macro bodies if possible for speed?
315 ;; Emulate more complete preprocessor support for tbl (.TS/.TE)
316 ;; Emulate some preprocessor support for eqn (.EQ/.EN)
317 ;; Re-write filling and adjusting code!
318 ;; Allow word wrap at comma (for long option lists)?
319 ;; Buffer list handling not quite right.
320 ;; Make 10 or 12 pitch (cpi) optional -- 12 => ll = 78
321 ;; Use unpaddable space for tabbing?
322 ;; Tidy up handling of fonts when filling and adjusting
323 ;; -- see text/text properties?
324 ;; Improve speed
325 ;; Add font-lock support (for quoted strings, etc.)?
326 ;; Optionally save large files in enriched format?
327 ;; Add apropos facility by searching NAME (?) entry in man files?
328 ;; Documentation -- optional auto-display of formatted WoMan man page?
329 ;; Implement a bug reporter?
330 ;; Support diversion and traps (to some extent) - for Tcl/tk pages?
331 ;; Add a menu of WoMan buffers?
332 ;; Fix .fc properly?
335 ;; Implementation strategy [this description is now well out of date!]
336 ;; -- three main passes, each to process respectively:
338 ;; 1) non-breaking `.' requests including font macros
339 ;; 2) \ escape sequences, mainly special characters and font changes
340 ;; 3) breaking `.' requests, mainly filling and justification
342 ;; For each pass, a control function finds and pre-processes the
343 ;; escape or request and then calls the appropriate function to
344 ;; perform the required formatting. Based originally on enriched.el
345 ;; and format.el.
347 ;; The background information that made this project possible is
348 ;; freely available courtesy of Bell Labs from
349 ;; http://cm.bell-labs.com/7thEdMan/
352 ;; Acknowledgments
353 ;; ===============
355 ;; For Heather, Kathryn and Madelyn, the women in my life
356 ;; (although they will probably never use it)!
358 ;; I also thank the following for helpful suggestions, bug reports,
359 ;; code fragments, general interest, etc.:
360 ;; Jari Aalto <jari.aalto@cs.tpu.fi>
361 ;; Dean Andrews <dean@dra.com>
362 ;; Juanma Barranquero <lekktu@gmail.com>
363 ;; Karl Berry <kb@cs.umb.edu>
364 ;; Jim Chapman <jchapman@netcomuk.co.uk>
365 ;; Kin Cho <kin@neoscale.com>
366 ;; Frederic Corne <frederic.corne@erli.fr>
367 ;; Peter Craft <craft@alacritech.com>
368 ;; Charles Curley <ccurley@trib.com>
369 ;; Jim Davidson <jdavidso@teknowledge.com>
370 ;; Kevin D'Elia <Kevin.DElia@mci.com>
371 ;; John Fitch <jpff@maths.bath.ac.uk>
372 ;; Hans Frosch <jwfrosch@rish.b17c.ingr.com>
373 ;; Guy Gascoigne-Piggford <ggp@informix.com>
374 ;; Brian Gorka <gorkab@sanchez.com>
375 ;; Nicolai Henriksen <nhe@lyngso-industri.dk>
376 ;; Thomas Herchenroeder <the@software-ag.de>
377 ;; Alexander Hinds <ahinds@thegrid.net>
378 ;; Stefan Hornburg <sth@hacon.de>
379 ;; Theodore Jump <tjump@cais.com>
380 ;; David Kastrup <dak@gnu.org>
381 ;; Paul Kinnucan <paulk@mathworks.com>
382 ;; Jonas Linde <jonas@init.se>
383 ;; Andrew McRae <andrewm@optimation.co.nz>
384 ;; Howard Melman <howard@silverstream.com>
385 ;; Dennis Pixton <dennis@math.binghamton.edu>
386 ;; T. V. Raman <raman@Adobe.COM>
387 ;; Bruce Ravel <bruce.ravel@nist.gov>
388 ;; Benjamin Riefenstahl <benny@crocodial.de>
389 ;; Kevin Ruland <kruland@seistl.com>
390 ;; Tom Schutter <tom@platte.com>
391 ;; Wei-Xue Shi <wxshi@ma.neweb.ne.jp>
392 ;; Fabio Somenzi <fabio@joplin.colorado.edu>
393 ;; Karel Sprenger <ks@ic.uva.nl>
394 ;; Chris Szurgot <szurgot@itribe.net>
395 ;; Paul A. Thompson <pat@po.cwru.edu>
396 ;; Arrigo Triulzi <arrigo@maths.qmw.ac.uk>
397 ;; Geoff Voelker <voelker@cs.washington.edu>
398 ;; Eli Zaretskii <eliz@gnu.org>
401 ;;; Code:
403 (defvar woman-version "0.551 (beta)" "WoMan version information.")
405 (require 'man)
406 (require 'button)
407 (define-button-type 'WoMan-xref-man-page
408 :supertype 'Man-abstract-xref-man-page
409 'func (lambda (arg)
410 (woman
411 ;; `woman' cannot deal with arguments that contain a
412 ;; section name, like close(2), so strip the section name.
413 (if (string-match Man-reference-regexp arg)
414 (substring arg 0 (match-end 1))
415 arg))))
417 (require 'cl-lib)
419 (eval-when-compile ; to avoid compiler warnings
420 (require 'dired)
421 (require 'apropos))
423 (defun woman-parse-colon-path (paths)
424 "Explode search path string PATHS into a list of directory names.
425 Allow Cygwin colon-separated search paths on Microsoft platforms.
426 Replace null components by calling `woman-parse-man.conf'.
427 As a special case, if PATHS is nil then replace it by calling
428 `woman-parse-man.conf'."
429 ;; Based on suggestions by Jari Aalto and Eli Zaretskii.
430 ;; parse-colon-path returns nil for a null path component and
431 ;; an empty substring of MANPATH denotes the default list.
432 (if (memq system-type '(windows-nt ms-dos))
433 (cond ((null paths)
434 (mapcar 'woman-Cyg-to-Win (woman-parse-man.conf)))
435 ((string-match-p ";" paths)
436 ;; Assume DOS-style path-list...
437 (cl-mapcan ; splice list into list
438 (lambda (x)
439 (if x
440 (list x)
441 (mapcar 'woman-Cyg-to-Win (woman-parse-man.conf))))
442 (parse-colon-path paths)))
443 ((string-match-p "\\`[a-zA-Z]:" paths)
444 ;; Assume single DOS-style path...
445 (list paths))
447 ;; Assume UNIX/Cygwin-style path-list...
448 (cl-mapcan ; splice list into list
449 (lambda (x)
450 (mapcar 'woman-Cyg-to-Win
451 (if x (list x) (woman-parse-man.conf))))
452 (let ((path-separator ":"))
453 (parse-colon-path paths)))))
454 ;; Assume host-default-style path-list...
455 (cl-mapcan ; splice list into list
456 (lambda (x) (if x (list x) (woman-parse-man.conf)))
457 (parse-colon-path (or paths "")))))
459 (defun woman-Cyg-to-Win (file)
460 "Convert an absolute filename FILE from Cygwin to Windows form."
461 ;; MANPATH_MAP conses are not converted since they presumably map
462 ;; Cygwin to Cygwin form.
463 (if (consp file)
464 file
465 ;; Code taken from w32-symlinks.el
466 (if (eq (aref file 0) ?/)
467 ;; Try to use Cygwin mount table via `cygpath.exe'.
468 (condition-case nil
469 (with-temp-buffer
470 ;; cygpath -m file
471 (call-process "cygpath" nil t nil "-m" file)
472 (buffer-substring 1 (buffer-size)))
473 (error
474 ;; Assume no `cygpath' program available.
475 ;; Hack /cygdrive/x/ or /x/ or (obsolete) //x/ to x:/
476 (when (string-match "\\`\\(/cygdrive\\|/\\)?/./" file)
477 (if (match-beginning 1) ; /cygdrive/x/ or //x/ -> /x/
478 (setq file (substring file (match-end 1))))
479 (aset file 0 (aref file 1)) ; /x/ -> xx/
480 (aset file 1 ?:)) ; xx/ -> x:/
481 file))
482 file)))
485 ;;; User options:
487 ;; NB: Group identifiers must be lowercase!
489 (defgroup woman nil
490 "Browse UNIX manual pages `wo (without) man'."
491 :tag "WoMan"
492 :link '(custom-manual "(woman) Top")
493 :link '(emacs-commentary-link :tag "Commentary" "woman.el")
494 :group 'help)
496 (defcustom woman-show-log nil
497 "If non-nil then show the *WoMan-Log* buffer if appropriate.
498 I.e. if any warning messages are written to it. Default is nil."
499 :type 'boolean
500 :group 'woman)
502 (defcustom woman-pre-format-hook nil
503 "Hook run by WoMan immediately before formatting a buffer.
504 Change only via `Customization' or the function `add-hook'."
505 :type 'hook
506 :group 'woman)
508 (defcustom woman-post-format-hook nil
509 "Hook run by WoMan immediately after formatting a buffer.
510 Change only via `Customization' or the function `add-hook'."
511 :type 'hook
512 :group 'woman)
515 ;; Interface options
517 (defgroup woman-interface nil
518 "Interface options for browsing UNIX manual pages `wo (without) man'."
519 :tag "WoMan Interface"
520 :group 'woman)
522 (defcustom woman-man.conf-path
523 (let ((path '("/usr/lib" "/etc")))
524 (cond ((eq system-type 'windows-nt)
525 (mapcar 'woman-Cyg-to-Win path))
526 ((eq system-type 'darwin)
527 (cons "/usr/share/misc" path))
528 (t path)))
529 "List of dirs to search and/or files to try for man config file.
530 A trailing separator (`/' for UNIX etc.) on directories is
531 optional, and the filename is used if a directory specified is
532 the first to start with \"man\" and has an extension starting
533 with \".conf\". If MANPATH is not set but a config file is found
534 then it is parsed instead to provide a default value for
535 `woman-manpath'."
536 :type '(repeat string)
537 :group 'woman-interface)
539 (defun woman-parse-man.conf ()
540 "Parse if possible configuration file for man command.
541 Used only if MANPATH is not set or contains null components.
542 Look in `woman-man.conf-path' and return a value for `woman-manpath'.
543 Concatenate data from all lines in the config file of the form
544 MANPATH /usr/man
546 MANDATORY_MANPATH /usr/man
548 OPTIONAL_MANPATH /usr/man
550 MANPATH_MAP /opt/bin /opt/man"
551 ;; Functionality suggested by Charles Curley.
552 (let ((path woman-man.conf-path)
553 file manpath)
554 (while (and
555 path
556 (not (and
557 (file-readable-p (setq file (car path)))
558 ;; If not a file then find the file:
559 (or (not (file-directory-p file))
560 (and
561 (setq file
562 (directory-files file t "\\`man.*\\.conf[a-z]*\\'" t))
563 (file-readable-p (setq file (car file)))))
564 ;; Parse the file -- if no MANPATH data ignore it:
565 (with-temp-buffer
566 (insert-file-contents file)
567 (while (re-search-forward
568 ;; `\(?: ... \)' is a "shy group"
570 ^[ \t]*\\(?:\\(?:MANDATORY_\\|OPTIONAL_\\)?MANPATH[ \t]+\\(\\S-+\\)\\|\
571 MANPATH_MAP[ \t]+\\(\\S-+\\)[ \t]+\\(\\S-+\\)\\)" nil t)
572 (add-to-list 'manpath
573 (if (match-beginning 1)
574 (match-string 1)
575 (cons (match-string 2)
576 (match-string 3)))))
577 manpath))
579 (setq path (cdr path)))
580 (nreverse manpath)))
582 ;; Autoload so set-locale-environment can operate on it.
583 ;;;###autoload
584 (defcustom woman-locale nil
585 "String specifying a manual page locale, or nil.
586 If a manual page is available in the specified locale
587 \(e.g. \"sv_SE.ISO8859-1\"), it will be offered in preference to the
588 default version. Normally, `set-locale-environment' sets this at startup."
589 :type '(choice string (const nil))
590 :group 'woman-interface
591 :version "23.1")
593 ;; FIXME Is this a sensible list of alternatives?
594 (defun woman-expand-locale (locale)
595 "Expand a locale into a list suitable for man page lookup.
596 Expands a locale of the form LANGUAGE_TERRITORY.CHARSET into the list:
597 LANGUAGE_TERRITORY.CHARSET LANGUAGE_TERRITORY LANGUAGE.CHARSET LANGUAGE.
598 The TERRITORY and CHARSET portions may be absent."
599 (string-match "\\([^._]*\\)\\(_[^.]*\\)?\\(\\..*\\)?" locale)
600 (let ((lang (match-string 1 locale))
601 (terr (match-string 2 locale))
602 (charset (match-string 3 locale)))
603 (delq nil (list locale
604 (and charset terr (concat lang terr))
605 (and charset terr (concat lang charset))
606 (if (or charset terr) lang)))))
608 (defun woman-manpath-add-locales (manpath)
609 "Add locale-specific subdirectories to the elements of MANPATH.
610 MANPATH is a list of the form of `woman-manpath'. Returns a list
611 with those locale-specific subdirectories specified by the action
612 of `woman-expand-locale' on `woman-locale' added, where they exist."
613 (if (zerop (length woman-locale))
614 manpath
615 (let ((subdirs (woman-expand-locale woman-locale))
616 lst dir)
617 (dolist (elem manpath (nreverse lst))
618 (dolist (sub subdirs)
619 (when (file-directory-p
620 (setq dir
621 ;; Use f-n-a-d because parse-colon-path does.
622 (file-name-as-directory
623 (expand-file-name sub (substitute-in-file-name
624 (if (consp elem)
625 (cdr elem)
626 elem))))))
627 (add-to-list 'lst (if (consp elem)
628 (cons (car elem) dir)
629 dir))))
630 ;; Non-locale-specific has lowest precedence.
631 (add-to-list 'lst elem)))))
633 (defcustom woman-manpath
634 ;; Locales could also be added in woman-expand-directory-path.
635 (or (woman-manpath-add-locales
636 (woman-parse-colon-path (getenv "MANPATH")))
637 '("/usr/man" "/usr/share/man" "/usr/local/man"))
638 "List of DIRECTORY TREES to search for UN*X manual files.
639 Each element should be the name of a directory that contains
640 subdirectories of the form `man?', or more precisely subdirectories
641 selected by the value of `woman-manpath-man-regexp'. Non-directory
642 and unreadable files are ignored.
644 Elements can also be a cons cell indicating a mapping from PATH
645 to manual trees: if such an element's car is equal to a path
646 element of the environment variable PATH, the cdr of the cons
647 cell is included in the directory tree search.
649 If not set then the environment variable MANPATH is used. If no such
650 environment variable is found, the default list is determined by
651 consulting the man configuration file if found, which is determined by
652 the user option `woman-man.conf-path'. An empty substring of MANPATH
653 denotes the default list.
655 Any environment variables (names must have the UN*X-style form $NAME,
656 e.g. $HOME, $EMACSDATA, $emacs_dir) are evaluated first but each
657 element must evaluate to a SINGLE directory name. Trailing `/'s are
658 ignored. (Specific directories in `woman-path' are also searched.)
660 Microsoft platforms:
661 I recommend including drive letters explicitly, e.g.
663 (\"C:/Cygwin/usr/man/\" \"C:/Cygwin/usr/local/man\").
665 The MANPATH environment variable may be set using DOS semi-colon-
666 separated or UN*X/Cygwin colon-separated syntax (but not mixed)."
667 :type '(repeat (choice string (cons string string)))
668 :version "23.1" ; added woman-manpath-add-locales
669 :group 'woman-interface)
671 (defcustom woman-manpath-man-regexp "[Mm][Aa][Nn]"
672 "Regexp to match man directories UNDER `woman-manpath' directories.
673 These normally have names of the form `man?'. Its default value is
674 \"[Mm][Aa][Nn]\", which is case-insensitive mainly for the benefit of
675 Microsoft platforms. Its purpose is to avoid `cat?', `.', `..', etc."
676 ;; Based on a suggestion by Wei-Xue Shi.
677 :type 'string
678 :group 'woman-interface)
680 (defcustom woman-path
681 (if (eq system-type 'ms-dos) '("$DJDIR/info" "$DJDIR/man/cat[1-9onlp]"))
682 "List of SPECIFIC DIRECTORIES to search for UN*X manual files.
683 For example
685 (\"/emacs/etc\").
687 These directories are searched in addition to the directory trees
688 specified in `woman-manpath'. Each element should be a directory
689 string or nil, which represents the current directory when the path is
690 expanded and cached. However, the last component (only) of each
691 directory string is treated as a regexp \(Emacs, not shell) and the
692 string is expanded into a list of matching directories. Non-directory
693 and unreadable files are ignored. The default value is nil.
695 Any environment variables (which must have the UN*X-style form $NAME,
696 e.g. $HOME, $EMACSDATA, $emacs_dir) are evaluated first but each
697 element must evaluate to a SINGLE directory name (regexp, see above).
698 For example
700 (\"$EMACSDATA\") [or equivalently (\"$emacs_dir/etc\")].
702 Trailing `/'s are discarded. (The directory trees in `woman-manpath'
703 are also searched.) On Microsoft platforms I recommend including
704 drive letters explicitly."
705 :type '(repeat (choice string (const nil)))
706 :group 'woman-interface)
708 (defcustom woman-cache-level 2
709 "The level of topic caching.
710 1 - cache only the topic and directory lists
711 (the only level before version 0.34 - only for compatibility);
712 2 - cache also the directories for each topic
713 (faster, without using much more memory);
714 3 - cache also the actual filenames for each topic
715 (fastest, but uses twice as much memory).
716 The default value is currently 2, a good general compromise.
717 If the `woman' command is slow to find files then try 3, which may be
718 particularly beneficial with large remote-mounted man directories.
719 Run the `woman' command with a prefix argument or delete the cache
720 file `woman-cache-filename' for a change to take effect.
721 \(Values < 1 behave like 1; values > 3 behave like 3.)"
722 :type '(choice (const :tag "Minimal" 1)
723 (const :tag "Default" 2)
724 (const :tag "Maximal" 3))
725 :group 'woman-interface)
727 (defcustom woman-cache-filename nil
728 "The full pathname of the WoMan directory and topic cache file.
729 It is used to save and restore the cache between sessions. This is
730 especially useful with remote-mounted man page files! The default
731 value of nil suppresses this action. The `standard' non-nil
732 filename is \"~/.wmncach.el\". Remember that a prefix argument forces
733 the `woman' command to update and re-write the cache."
734 :type '(choice (const :tag "None" nil)
735 (const :tag "~/.wmncach.el" "~/.wmncach.el")
736 file)
737 :group 'woman-interface)
739 (defcustom woman-dired-keys t
740 "List of `dired' mode keys to define to run WoMan on current file.
741 E.g. (\"w\" \"W\"), or any non-null atom to automatically define
742 \"w\" and \"W\" if they are unbound, or nil to do nothing.
743 Default is t."
744 :type '(choice (const :tag "None" nil)
745 (repeat string)
746 (other :tag "Auto" t))
747 :group 'woman-interface)
749 (defcustom woman-imenu-generic-expression
750 '((nil "\n\\([A-Z].*\\)" 1) ; SECTION, but not TITLE
751 ("*Subsections*" "^ \\([A-Z].*\\)" 1))
752 "Imenu support for Sections and Subsections.
753 An alist with elements of the form (MENU-TITLE REGEXP INDEX) --
754 see the documentation for `imenu-generic-expression'."
755 :type '(alist :key-type (choice :tag "Title" (const nil) string)
756 :value-type (group (choice (string :tag "Regexp")
757 function)
758 integer))
759 :group 'woman-interface)
761 (defcustom woman-imenu nil
762 "If non-nil then WoMan adds a Contents menu to the menubar.
763 It does this by calling `imenu-add-to-menubar'. Default is nil."
764 :type 'boolean
765 :group 'woman-interface)
767 (defcustom woman-imenu-title "CONTENTS"
768 "The title to use if WoMan adds a Contents menu to the menubar.
769 Default is \"CONTENTS\"."
770 :type 'string
771 :group 'woman-interface)
773 (defcustom woman-use-topic-at-point-default nil
774 ;; `woman-use-topic-at-point' may be let-bound when woman is loaded,
775 ;; in which case its global value does not get defined.
776 ;; `woman-file-name' sets it to this value if it is unbound.
777 "Default value for `woman-use-topic-at-point'."
778 :type '(choice (const :tag "Yes" t)
779 (const :tag "No" nil))
780 :group 'woman-interface)
782 (defcustom woman-use-topic-at-point woman-use-topic-at-point-default
783 "Control use of the word at point as the default topic.
784 If non-nil the `woman' command uses the word at point automatically,
785 without interactive confirmation, if it exists as a topic."
786 :type '(choice (const :tag "Yes" t)
787 (const :tag "No" nil))
788 :group 'woman-interface)
790 (defvar woman-file-regexp nil
791 "Regexp used to select (possibly compressed) man source files, e.g.
792 \"\\.\\([0-9lmnt]\\w*\\)\\(\\.\\(g?z\\|bz2\\|xz\\)\\)?\\\\='\".
793 Built automatically from the customizable user options
794 `woman-uncompressed-file-regexp' and `woman-file-compression-regexp'.")
796 (defvar woman-uncompressed-file-regexp) ; for the compiler
797 (defvar woman-file-compression-regexp) ; for the compiler
799 (defun set-woman-file-regexp (symbol value)
800 "Bind SYMBOL to VALUE and set `woman-file-regexp' as per user customizations.
801 Used as :set cookie by Customize when customizing the user options
802 `woman-uncompressed-file-regexp' and `woman-file-compression-regexp'."
803 (set-default symbol value)
804 (and (boundp 'woman-uncompressed-file-regexp)
805 (boundp 'woman-file-compression-regexp)
806 (setq woman-file-regexp
807 (concat woman-uncompressed-file-regexp
808 "\\("
809 (substring woman-file-compression-regexp 0 -2)
810 "\\)?\\'"))))
812 (defcustom woman-uncompressed-file-regexp
813 "\\.\\([0-9lmnt]\\w*\\)" ; disallow no extension
814 "Do not change this unless you are sure you know what you are doing!
815 Regexp used to select man source files (ignoring any compression extension).
817 The SysV standard man pages use two character suffixes, and this is
818 becoming more common in the GNU world. For example, the man pages
819 in the ncurses package include `toe.1m', `form.3x', etc.
821 Note: an optional compression regexp will be appended, so this regexp
822 MUST NOT end with any kind of string terminator such as $ or \\\\='."
823 :type 'regexp
824 :set 'set-woman-file-regexp
825 :group 'woman-interface)
827 (defcustom woman-file-compression-regexp
828 "\\.\\(g?z\\|bz2\\|xz\\)\\'"
829 "Do not change this unless you are sure you know what you are doing!
830 Regexp used to match compressed man file extensions for which
831 decompressors are available and handled by auto-compression mode,
832 e.g. \"\\\\.\\\\(g?z\\\\|bz2\\\\|xz\\\\)\\\\\\='\" for `gzip', `bzip2', or `xz'.
833 Should begin with \\. and end with \\\\=' and MUST NOT be optional."
834 ;; Should be compatible with car of
835 ;; `jka-compr-file-name-handler-entry', but that is unduly
836 ;; complicated, includes an inappropriate extension (.tgz) and is
837 ;; not loaded by default!
838 :version "24.1" ; added xz
839 :type 'regexp
840 :set 'set-woman-file-regexp
841 :group 'woman-interface)
843 (defcustom woman-use-own-frame nil
844 "If non-nil then use a dedicated frame for displaying WoMan windows.
845 Only useful when run on a graphic display such as X or MS-Windows."
846 :type 'boolean
847 :group 'woman-interface)
850 ;; Formatting options
852 (defgroup woman-formatting nil
853 "Formatting options for browsing UNIX manual pages `wo (without) man'."
854 :tag "WoMan Formatting"
855 :group 'woman)
857 (defcustom woman-fill-column 65
858 "Right margin for formatted text -- default is 65."
859 :type 'integer
860 :group 'woman-formatting)
862 (defcustom woman-fill-frame nil
863 ;; Based loosely on a suggestion by Theodore Jump:
864 "If non-nil then most of the window width is used."
865 :type 'boolean
866 :group 'woman-formatting)
868 (defcustom woman-default-indent 5
869 "Default prevailing indent set by -man macros -- default is 5.
870 Set this variable to 7 to emulate GNU man formatting."
871 :type 'integer
872 :group 'woman-formatting)
874 (defcustom woman-bold-headings t
875 "If non-nil then embolden section and subsection headings. Default is t.
876 Heading emboldening is NOT standard `man' behavior."
877 :type 'boolean
878 :group 'woman-formatting)
880 (defcustom woman-ignore t
881 "If non-nil then unrecognized requests etc. are ignored. Default is t.
882 This gives the standard ?roff behavior. If nil then they are left in
883 the buffer, which may aid debugging."
884 :type 'boolean
885 :group 'woman-formatting)
887 (defcustom woman-preserve-ascii t
888 "If non-nil, preserve ASCII characters in the WoMan buffer.
889 Otherwise, to save time, some backslashes and spaces may be
890 represented differently (as the values of the variables
891 `woman-escaped-escape-char' and `woman-unpadded-space-char'
892 respectively) so that the buffer content is strictly wrong even though
893 it should display correctly. This should be irrelevant unless the
894 buffer text is searched, copied or saved to a file."
895 ;; This option should probably be removed!
896 :type 'boolean
897 :group 'woman-formatting)
899 (defcustom woman-emulation 'nroff
900 "WoMan emulation, currently either nroff or troff. Default is nroff.
901 Troff emulation is experimental and largely untested.
902 \(Add groff later?)"
903 :type '(choice (const nroff) (const troff))
904 :group 'woman-formatting)
907 ;; Faces:
909 (defgroup woman-faces nil
910 "Face options for browsing UNIX manual pages `wo (without) man'."
911 :tag "WoMan Faces"
912 :group 'woman
913 :group 'faces)
915 (defcustom woman-fontify
916 (or (and (fboundp 'display-color-p) (display-color-p))
917 (and (fboundp 'display-graphic-p) (display-graphic-p))
918 (x-display-color-p))
919 "If non-nil then WoMan assumes that face support is available.
920 It defaults to a non-nil value if the display supports either colors
921 or different fonts."
922 :type 'boolean
923 :group 'woman-faces)
925 (defface woman-italic
926 '((t :inherit italic))
927 "Face for italic font in man pages."
928 :group 'woman-faces)
929 (define-obsolete-face-alias 'woman-italic-face 'woman-italic "22.1")
931 (defface woman-bold
932 '((t :inherit bold))
933 "Face for bold font in man pages."
934 :group 'woman-faces)
935 (define-obsolete-face-alias 'woman-bold-face 'woman-bold "22.1")
937 (defface woman-unknown
938 '((t :inherit font-lock-warning-face))
939 "Face for all unknown fonts in man pages."
940 :group 'woman-faces)
941 (define-obsolete-face-alias 'woman-unknown-face 'woman-unknown "22.1")
943 (defface woman-addition
944 '((t :inherit font-lock-builtin-face))
945 "Face for all WoMan additions to man pages."
946 :group 'woman-faces)
947 (define-obsolete-face-alias 'woman-addition-face 'woman-addition "22.1")
949 (defun woman-default-faces ()
950 "Set foreground colors of italic and bold faces to their default values."
951 (declare (obsolete "customize the woman-* faces instead." "24.4"))
952 (interactive)
953 (face-spec-set 'woman-italic (face-user-default-spec 'woman-italic))
954 (face-spec-set 'woman-bold (face-user-default-spec 'woman-bold)))
956 (defun woman-monochrome-faces ()
957 "Set foreground colors of italic and bold faces to that of the default face.
958 This is usually either black or white."
959 (declare (obsolete "customize the woman-* faces instead." "24.4"))
960 (interactive)
961 (set-face-foreground 'woman-italic 'unspecified)
962 (set-face-foreground 'woman-bold 'unspecified))
964 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
965 ;; Experimental font support, initially only for MS-Windows.
966 (defconst woman-font-support
967 (eq window-system 'w32) ; Support X later!
968 "If non-nil then non-ASCII characters and symbol font supported.")
970 (defun woman-select-symbol-fonts (fonts)
971 "Select symbol fonts from a list FONTS of font name strings."
972 (let (symbol-fonts)
973 ;; With NTEmacs 20.5, the PATTERN option to `x-list-fonts' does
974 ;; not seem to work and fonts may be repeated, so ...
975 (dolist (font fonts)
976 (and (string-match-p "-Symbol-" font)
977 (not (member font symbol-fonts))
978 (setq symbol-fonts (cons font symbol-fonts))))
979 symbol-fonts))
981 (declare-function x-list-fonts "xfaces.c"
982 (pattern &optional face frame maximum width))
984 (when woman-font-support
985 (make-face 'woman-symbol)
987 ;; Set the symbol font only if `woman-use-symbol-font' is true, to
988 ;; avoid unnecessarily upsetting the line spacing in NTEmacs 20.5!
990 (defcustom woman-use-extended-font t
991 "If non-nil then may use non-ASCII characters from the default font."
992 :type 'boolean
993 :group 'woman-faces)
995 (defcustom woman-use-symbol-font nil
996 "If non-nil then may use the symbol font.
997 It is off by default, mainly because it may change the line spacing
998 \(in NTEmacs 20.5)."
999 :type 'boolean
1000 :group 'woman-faces)
1002 (defconst woman-symbol-font-list
1003 (or (woman-select-symbol-fonts (x-list-fonts "*" 'default))
1004 (woman-select-symbol-fonts (x-list-fonts "*")))
1005 "Symbol font(s), preferably same size as default when WoMan was loaded.")
1007 (defcustom woman-symbol-font (car woman-symbol-font-list)
1008 "A string describing the symbol font to use for special characters.
1009 It should be compatible with, and the same size as, the default text font.
1010 Under MS-Windows, the default is
1011 \"-*-Symbol-normal-r-*-*-*-*-96-96-p-*-ms-symbol\"."
1012 :type `(choice
1013 ,@(mapcar (lambda (x) (list 'const x))
1014 woman-symbol-font-list)
1015 string)
1016 :group 'woman-faces)
1020 ;; For non windows-nt ...
1021 (defvar woman-use-extended-font nil)
1022 (defvar woman-use-symbol-font nil)
1023 (defvar woman-symbol-font nil)
1024 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
1027 ;;; Internal variables:
1029 (defconst woman-justify-list
1030 '(left right center full)
1031 "Justify styles for `fill-region-as-paragraph'.")
1032 (defconst woman-adjust-left 0 ; == adjust off, noadjust
1033 "Adjustment indicator `l' -- adjust left margin only.")
1034 (defconst woman-adjust-right 1
1035 "Adjustment indicator `r' -- adjust right margin only.")
1036 (defconst woman-adjust-center 2
1037 "Adjustment indicator `c' -- center.")
1038 (defconst woman-adjust-both 3 ; default -- adj,both
1039 "Adjustment indicator `b' or `n' -- adjust both margins.")
1041 (defvar woman-adjust woman-adjust-both
1042 "Current adjustment number-register value.")
1043 (defvar woman-adjust-previous woman-adjust
1044 "Previous adjustment number-register value.")
1045 (defvar woman-justify
1046 (nth woman-adjust woman-justify-list) ; use vector?
1047 "Current justification style for `fill-region-as-paragraph'.")
1048 (defvar woman-justify-previous woman-justify
1049 "Previous justification style for `fill-region-as-paragraph'.")
1051 (defvar woman-left-margin woman-default-indent
1052 "Current left margin.")
1053 (defvar woman-prevailing-indent woman-default-indent
1054 "Current prevailing indent.")
1055 (defvar woman-interparagraph-distance 1
1056 "Interparagraph distance in lines.
1057 Set by .PD; used by .SH, .SS, .TP, .LP, .PP, .P, .IP, .HP.")
1058 (defvar woman-leave-blank-lines nil
1059 "Blank lines to leave as vertical space.")
1060 (defconst woman-tab-width 5
1061 "Default tab width set by -man macros.")
1062 (defvar woman-nofill nil
1063 "Current fill mode: nil for filling.")
1064 (defvar woman-RS-left-margin nil
1065 "Left margin stack for nested use of `.RS/.RE'.")
1066 (defvar woman-RS-prevailing-indent nil
1067 "Prevailing indent stack for nested use of `.RS/.RE'.")
1068 (defvar woman-nospace nil
1069 "Current no-space mode: nil for normal spacing.
1070 Set by `.ns' request; reset by any output or `.rs' request")
1071 ;; Used for message logging
1072 (defvar WoMan-current-file nil) ; bound in woman-really-find-file
1073 (defvar WoMan-Log-header-point-max nil)
1075 (defsubst woman-reset-nospace ()
1076 "Set `woman-nospace' to nil."
1077 (setq woman-nospace nil))
1079 (defconst woman-request-regexp "^[.'][ \t]*\\(\\S +\\) *"
1080 ;; Was "^\\.[ \t]*\\([a-z0-9]+\\) *" but cvs.1 uses a macro named
1081 ;; "`" and CGI.man uses a macro named "''"!
1082 ;; CGI.man uses ' as control character in places -- it *should*
1083 ;; suppress breaks!
1084 ;; Could end with "\\( +\\|$\\)" instead of " *"
1085 "Regexp to match a ?roff request plus trailing white space.")
1087 (defvar woman-imenu-done nil
1088 "Buffer-local: set to true if function `woman-imenu' has been called.")
1089 (make-variable-buffer-local 'woman-imenu-done)
1091 ;; From imenu.el -- needed when reformatting a file in its old buffer.
1092 ;; The latest buffer index used to update the menu bar menu.
1093 (eval-when-compile
1094 (require 'imenu))
1095 (make-variable-buffer-local 'imenu--last-menubar-index-alist)
1097 (defvar woman-buffer-alist nil
1098 "An alist representing WoMan buffers that are already decoded.
1099 Each element is of the form (FILE-NAME . BUFFER-NAME).")
1101 (defvar woman-buffer-number 0
1102 "Ordinal number of current buffer entry in `woman-buffer-alist'.
1103 The ordinal numbers start from 0.")
1105 (defvar woman-if-conditions-true '(?n ?e ?o)
1106 "List of one-character built-in condition names that are true.
1107 Should include ?e, ?o (page even/odd) and either ?n (nroff) or ?t (troff).
1108 Default is (?n ?e ?o). Set via `woman-emulation'.")
1111 ;;; Specialized utility functions:
1113 ;;; Fast deletion without saving on the kill ring (cf. simple.el):
1115 (defun woman-delete-line (&optional arg)
1116 "Delete rest of current line; if all blank then delete thru newline.
1117 With a numeric argument ARG, delete that many lines from point.
1118 Negative arguments delete lines backward."
1119 ;; This is a non-interactive version of kill-line in simple.el that
1120 ;; deletes instead of killing and assumes kill-whole-line is nil,
1121 ;; which is essential!
1122 (delete-region (point)
1123 (progn
1124 (if arg
1125 (forward-line arg)
1126 (if (eobp)
1127 (signal 'end-of-buffer nil))
1128 (if (looking-at "[ \t]*$")
1129 (forward-line 1)
1130 (end-of-line)))
1131 (point))))
1133 (defsubst woman-delete-whole-line ()
1134 "Delete current line from beginning including eol."
1135 (beginning-of-line)
1136 (woman-delete-line 1))
1138 (defsubst woman-delete-following-space ()
1139 "Delete all spaces and tabs FOLLOWING point (cf. `delete-horizontal-space')."
1140 ;; cf. delete-horizontal-space in simple.el:
1141 (delete-region (point) (progn (skip-chars-forward " \t") (point))))
1143 (defsubst woman-delete-match (subexp)
1144 "Delete subexpression SUBEXP of buffer text matched by last search."
1145 (delete-region (match-beginning subexp) (match-end subexp)))
1147 ;; delete-char does not kill by default
1148 ;; delete-backward-char does not kill by default
1149 ;; delete-horizontal-space does not kill
1150 ;; delete-blank-lines does not kill
1153 ;;; File handling:
1155 (defvar woman-expanded-directory-path nil
1156 "Expanded directory list cache. Resetting to nil forces update.")
1158 (defvar woman-topic-all-completions nil
1159 "Expanded topic alist cache. Resetting to nil forces update.")
1161 ;;;###autoload
1162 (defun woman (&optional topic re-cache)
1163 "Browse UN*X man page for TOPIC (Without using external Man program).
1164 The major browsing mode used is essentially the standard Man mode.
1165 Choose the filename for the man page using completion, based on the
1166 topic selected from the directories specified in `woman-manpath' and
1167 `woman-path'. The directory expansions and topics are cached for
1168 speed, but a non-nil interactive argument forces the caches to be
1169 updated (e.g. to re-interpret the current directory).
1171 Used non-interactively, arguments are optional: if given then TOPIC
1172 should be a topic string and non-nil RE-CACHE forces re-caching."
1173 (interactive (list nil current-prefix-arg))
1174 ;; The following test is for non-interactive calls via gnudoit etc.
1175 (if (or (not (stringp topic)) (string-match-p "\\S " topic))
1176 (let ((file-name (woman-file-name topic re-cache)))
1177 (if file-name
1178 (woman-find-file file-name)
1179 (message
1180 "WoMan Error: No matching manual files found in search path")
1181 (ding)))
1182 (message "WoMan Error: No topic specified in non-interactive call")
1183 (ding)))
1185 ;; Allow WoMan to be called via the standard Help menu:
1186 (define-key-after menu-bar-manuals-menu [woman]
1187 '(menu-item "Read Man Page (WoMan)..." woman
1188 :help "Man-page documentation Without Man") t)
1190 (defvar woman-cached-data nil
1191 "A list of cached data used to determine cache validity.
1192 Set from the cache by `woman-read-directory-cache'.")
1194 (defun woman-cached-data ()
1195 "Generate a list of data used to determine cache validity.
1196 Called both to generate and to check the cache!"
1197 ;; Must use substituted paths because values of env vars may change!
1198 (list woman-cache-level
1199 (let (lst path)
1200 (dolist (dir woman-manpath (nreverse lst))
1201 (when (consp dir)
1202 (unless path
1203 (setq path
1204 (split-string (getenv "PATH") path-separator t)))
1205 (setq dir (and (member (car dir) path) (cdr dir))))
1206 (when dir (add-to-list 'lst (substitute-in-file-name dir)))))
1207 (mapcar 'substitute-in-file-name woman-path)))
1209 (defun woman-read-directory-cache ()
1210 "Load the directory and topic cache.
1211 It is loaded from the file named by the variable `woman-cache-filename'.
1212 Return t if the file exists, nil otherwise."
1213 (and
1214 woman-cache-filename
1215 (load woman-cache-filename t nil t) ; file exists
1216 (equal woman-cached-data (woman-cached-data)))) ; cache valid
1218 (defun woman-write-directory-cache ()
1219 "Save the directory and topic cache.
1220 It is saved to the file named by the variable `woman-cache-filename'."
1221 (if woman-cache-filename
1222 (with-current-buffer (generate-new-buffer "WoMan tmp buffer")
1223 ;; Make a temporary buffer; name starting with space "hides" it.
1224 (let ((standard-output (current-buffer))
1225 (backup-inhibited t))
1226 ;; (switch-to-buffer standard-output t) ; only for debugging
1227 (buffer-disable-undo standard-output)
1228 (princ
1229 ";;; WoMan directory and topic cache -- generated automatically\n")
1230 (print
1231 ;; For data validity check:
1232 `(setq woman-cached-data ',(woman-cached-data)))
1233 (print
1234 `(setq woman-expanded-directory-path
1235 ',woman-expanded-directory-path))
1236 (print
1237 `(setq woman-topic-all-completions
1238 ',woman-topic-all-completions))
1239 (write-file woman-cache-filename) ; write CURRENT buffer
1240 (kill-buffer standard-output)
1241 ))))
1243 (defvaralias 'woman-topic-history 'Man-topic-history)
1244 (defvar woman-file-history nil "File-name read history.")
1246 (defun woman-file-name (topic &optional re-cache)
1247 "Get the name of the UN*X man-page file describing a chosen TOPIC.
1248 When `woman' is called interactively, the word at point may be
1249 automatically used as the topic, if the value of the user option
1250 `woman-use-topic-at-point' is non-nil. Return nil if no file can
1251 be found. Optional argument RE-CACHE, if non-nil, forces the
1252 cache to be re-read."
1253 ;; Handle the caching of the directory and topic lists:
1254 (unless (and (not re-cache)
1256 (and woman-expanded-directory-path woman-topic-all-completions)
1257 (woman-read-directory-cache)))
1258 (message "Building list of manual directory expansions...")
1259 (setq woman-expanded-directory-path
1260 (woman-expand-directory-path woman-manpath woman-path))
1261 (message "Building completion list of all manual topics...")
1262 (setq woman-topic-all-completions
1263 (woman-topic-all-completions woman-expanded-directory-path))
1264 (woman-write-directory-cache))
1265 ;; There is a problem in that I want to offer case-insensitive
1266 ;; completions, but to return only a case-sensitive match. This
1267 ;; does not seem to work properly by default, so I re-do the
1268 ;; completion if necessary.
1269 (let (files)
1270 (or (stringp topic)
1271 (and (if (boundp 'woman-use-topic-at-point)
1272 woman-use-topic-at-point
1273 ;; Was let-bound when file loaded, so ...
1274 (setq woman-use-topic-at-point woman-use-topic-at-point-default))
1275 (setq topic (or (current-word t) "")) ; only within or adjacent to word
1276 (test-completion topic woman-topic-all-completions))
1277 (setq topic
1278 (let* ((word-at-point (current-word))
1279 (default
1280 (when (and word-at-point
1281 (test-completion
1282 word-at-point woman-topic-all-completions))
1283 word-at-point)))
1284 (completing-read
1285 (if default
1286 (format "Manual entry (default %s): " default)
1287 "Manual entry: ")
1288 woman-topic-all-completions nil 1
1290 'woman-topic-history
1291 default))))
1292 ;; Note that completing-read always returns a string.
1293 (unless (= (length topic) 0)
1294 (cond
1295 ((setq files (woman-file-name-all-completions topic)))
1296 ;; Complete topic more carefully, i.e. use the completion
1297 ;; rather than the string entered by the user:
1298 ((setq files (all-completions topic woman-topic-all-completions))
1299 (while (/= (length topic) (length (car files)))
1300 (setq files (cdr files)))
1301 (setq files (woman-file-name-all-completions (car files)))))
1302 (cond
1303 ((null files) nil) ; no file found for topic.
1304 ((null (cdr files)) (car (car files))) ; only 1 file for topic.
1306 ;; Multiple files for topic, so must select 1.
1307 ;; Run the command `minibuffer-complete' in order to automatically
1308 ;; complete the minibuffer contents as far as possible.
1309 (minibuffer-with-setup-hook
1310 (lambda () (let ((this-command this-command)) (minibuffer-complete)))
1311 (completing-read "Manual file: " files nil 1
1312 (try-completion "" files) 'woman-file-history)))))))
1314 (defun woman-select (predicate list)
1315 "Select unique elements for which PREDICATE is true in LIST.
1316 \(Note that this function changes the value of LIST.)"
1317 ;; Intended to be fast by avoiding recursion and list copying.
1318 (while (and list
1320 (member (car list) (cdr list))
1321 (not (funcall predicate (car list)))))
1322 (setq list (cdr list)))
1323 (if list
1324 (let ((newlist list) cdr_list)
1325 (while (setq cdr_list (cdr list))
1326 (if (and
1327 (not (member (car cdr_list) (cdr cdr_list)))
1328 (funcall predicate (car cdr_list)))
1329 (setq list cdr_list)
1330 (setcdr list (cdr cdr_list))))
1331 newlist)))
1333 (defun woman-file-readable-p (dir)
1334 "Return t if DIR is readable, otherwise log a warning."
1335 (or (file-readable-p dir)
1336 (WoMan-warn "Ignoring unreadable `manpath' directory tree `%s'!" dir)))
1338 (defun woman-directory-files (head dir)
1339 "Return a sorted list of files in directory HEAD matching regexp in DIR.
1340 Value is a sorted list of the absolute pathnames of all the files in
1341 directory HEAD, or the current directory if HEAD is nil, that match the
1342 regexp that is the final component of DIR. Log a warning if list is empty."
1343 (or (directory-files
1344 (or head (directory-file-name default-directory)) ; was "."
1346 (file-name-nondirectory dir))
1347 (WoMan-warn "No directories match `woman-path' entry `%s'!" dir)))
1349 (defun woman-file-accessible-directory-p (dir)
1350 "Return t if DIR is accessible, otherwise log a warning."
1351 (or (file-accessible-directory-p dir)
1352 (WoMan-warn "Ignoring inaccessible `man-page' directory `%s'!" dir)))
1354 (defun woman-expand-directory-path (path-dirs path-regexps)
1355 "Expand the manual directories in PATH-DIRS and PATH-REGEXPS.
1356 PATH-DIRS should be a list of general manual directories (like
1357 `woman-manpath'), while PATH-REGEXPS should be a list of specific
1358 manual directory regexps (like `woman-path').
1359 Ignore any paths that are unreadable or not directories."
1360 ;; Allow each path to be a single string or a list of strings:
1361 (if (not (listp path-dirs)) (setq path-dirs (list path-dirs)))
1362 (if (not (listp path-regexps)) (setq path-regexps (list path-regexps)))
1363 (let (head dirs path)
1364 (dolist (dir path-dirs)
1365 (when (consp dir)
1366 (unless path
1367 (setq path (split-string (getenv "PATH") path-separator t)))
1368 (setq dir (and (member (car dir) path)
1369 (cdr dir))))
1370 (if (and dir (woman-file-readable-p dir))
1371 ;; NB: `parse-colon-path' creates null elements for
1372 ;; redundant (semi-)colons and trailing `/'s!
1373 ;; If does not actually matter here if dir ends with `/'.
1374 ;; Need regexp "man" here to avoid "cat?", `.', `..', etc.
1375 (setq dir (woman-canonicalize-dir dir)
1376 dirs (nconc dirs (directory-files
1377 dir t woman-manpath-man-regexp)))))
1378 (dolist (dir path-regexps)
1379 (if (or (null dir)
1380 (null (setq dir (woman-canonicalize-dir dir)
1381 head (file-name-directory dir)))
1382 (woman-file-readable-p head))
1383 (setq dirs
1384 (if dir
1385 (nconc dirs (woman-directory-files head dir))
1386 (cons (directory-file-name default-directory) dirs))
1387 ;; was "." -- at head of list for later filtering
1389 (woman-select 'woman-file-accessible-directory-p dirs)))
1391 (defun woman-canonicalize-dir (dir)
1392 "Canonicalize the directory name DIR.
1393 Any UN*X-style environment variables are evaluated first."
1394 (setq dir (expand-file-name (substitute-in-file-name dir)))
1395 ;; A path that ends with / matches all directories in it,
1396 ;; including `.' and `..', so remove any trailing / !!!
1397 (if (string= (substring dir -1) "/")
1398 (setq dir (substring dir 0 -1)))
1399 (if (memq system-type '(windows-nt ms-dos cygwin)) ; what else?
1400 ;; Match capitalization used by `file-name-directory':
1401 (setq dir (concat (file-name-directory dir)
1402 (file-name-nondirectory dir))))
1403 dir)
1405 (defsubst woman-not-member (dir path)
1406 "Return t if DIR is not a member of the list PATH, nil otherwise.
1407 If DIR is `.' it is first replaced by the current directory."
1408 (not (member dir path)))
1410 (defun woman-topic-all-completions (path)
1411 "Return an alist of the man files in all man directories in the list PATH.
1412 The cdr of each alist element is the path-index / filename."
1413 ;; Support 3 levels of caching: each element of the alist `files'
1414 ;; will be a list of the first `woman-cache-level' elements of the
1415 ;; following list: (topic path-index filename). This alist `files'
1416 ;; is re-processed by `woman-topic-all-completions-merge'.
1417 (let (dir files (path-index 0)) ; indexing starts at zero
1418 (while path
1419 (setq dir (pop path))
1420 (if (woman-not-member dir path) ; use each directory only once!
1421 (push (woman-topic-all-completions-1 dir path-index)
1422 files))
1423 (setq path-index (1+ path-index)))
1424 ;; Uniquify topics:
1425 ;; Concatenate all lists with a single nconc call to
1426 ;; avoid retraversing the first lists repeatedly -- dak
1427 (woman-topic-all-completions-merge
1428 (apply #'nconc files))))
1430 (defun woman-topic-all-completions-1 (dir path-index)
1431 "Return an alist of the man topics in directory DIR with index PATH-INDEX.
1432 A topic is a filename sans type-related extensions.
1433 Support 3 levels of caching: each element of the alist will be a list
1434 of the first `woman-cache-level' elements from the following list:
1435 \(topic path-index filename)."
1436 ;; This function used to check that each file in the directory was
1437 ;; not itself a directory, but this is very slow and should be
1438 ;; unnecessary. So let us assume that `woman-file-regexp' will
1439 ;; filter out any directories, which probably should not be there
1440 ;; anyway, i.e. it is a user error!
1442 ;; Don't sort files: we do that when merging, anyway. -- dak
1443 (let (newlst (lst (directory-files dir nil woman-file-regexp t))
1444 ;; Make an explicit regexp for stripping extension and
1445 ;; compression extension: file-name-sans-extension is a
1446 ;; far too costly function. -- dak
1447 (ext (format "\\(\\.[^.\\/]*\\)?\\(%s\\)?\\'"
1448 woman-file-compression-regexp)))
1449 ;; Use a loop instead of mapcar in order to avoid the speed
1450 ;; penalty of binding function arguments. -- dak
1451 (dolist (file lst newlst)
1452 (push
1453 (cons
1454 (if (string-match ext file)
1455 (substring file 0 (match-beginning 0))
1456 file)
1457 (and (> woman-cache-level 1)
1458 (cons
1459 path-index
1460 (and (> woman-cache-level 2)
1461 (list file)))))
1462 newlst))))
1464 (defun woman-topic-all-completions-merge (alist)
1465 "Merge the alist ALIST so that the keys are unique.
1466 Also make each path-info component into a list.
1467 \(Note that this function changes the value of ALIST.)"
1468 ;; Replaces unreadably "optimized" O(n^2) implementation.
1469 ;; Instead we use sorting to merge stuff efficiently. -- dak
1470 (let (newalist)
1471 ;; Sort list into reverse order
1472 (setq alist (sort alist (lambda(x y) (string< (car y) (car x)))))
1473 ;; merge duplicate keys.
1474 (if (> woman-cache-level 1)
1475 (dolist (elt alist)
1476 (if (equal (car elt) (caar newalist))
1477 (unless (member (cdr elt) (cdar newalist))
1478 (setcdr (car newalist) (cons (cdr elt)
1479 (cdar newalist))))
1480 (setcdr elt (list (cdr elt)))
1481 (push elt newalist)))
1482 ;; woman-cache-level = 1 => elements are single-element lists ...
1483 (dolist (elt alist)
1484 (unless (equal (car elt) (caar newalist))
1485 (push elt newalist))))
1486 newalist))
1488 (defun woman-file-name-all-completions (topic)
1489 "Return an alist of the files in all man directories that match TOPIC."
1490 ;; Support 3 levels of caching: each element of
1491 ;; woman-topic-all-completions is a list of one of the forms:
1492 ;; (topic)
1493 ;; (topic (path-index) (path-index) ... )
1494 ;; (topic (path-index filename) (path-index filename) ... )
1495 ;; where there are no duplicates in the value lists.
1496 ;; Topic must match first `word' of filename, so ...
1497 (let ((topic-regexp
1498 (concat
1499 "\\`" (regexp-quote topic) ; first `word'
1500 "\\(\\..+\\)*" ; optional subsequent `words'
1501 woman-file-regexp)) ; extension
1502 (topics woman-topic-all-completions)
1503 (path woman-expanded-directory-path)
1504 dir files)
1505 (if (cdr (car topics))
1506 ;; Use cached path-info to locate files for each topic:
1507 (let ((path-info (cdr (assoc topic topics)))
1508 filename)
1509 (dolist (elt path-info)
1510 (setq dir (nth (car elt) path)
1511 filename (car (cdr elt))
1512 files (nconc files
1513 ;; Find the actual file name:
1514 (if filename
1515 (list (concat dir "/" filename))
1516 (directory-files dir t topic-regexp)
1517 )))))
1518 ;; Search path for the files for each topic:
1519 (while path
1520 (setq dir (car path)
1521 path (cdr path))
1522 (if (woman-not-member dir path) ; use each directory only once!
1523 (setq files (nconc files
1524 (directory-files dir t topic-regexp))))))
1525 (mapcar 'list files)))
1528 ;;; dired support
1530 (defun woman-dired-define-key (key)
1531 "Bind the argument KEY to the command `woman-dired-find-file'."
1532 (define-key dired-mode-map key 'woman-dired-find-file))
1534 (defsubst woman-dired-define-key-maybe (key)
1535 "If KEY is undefined in Dired, bind it to command `woman-dired-find-file'."
1536 (if (or (eq (lookup-key dired-mode-map key) 'undefined)
1537 (null (lookup-key dired-mode-map key)))
1538 (woman-dired-define-key key)))
1540 (defun woman-dired-define-keys ()
1541 "Define dired keys to run WoMan according to `woman-dired-keys'."
1542 (if woman-dired-keys
1543 (if (listp woman-dired-keys)
1544 (mapc 'woman-dired-define-key woman-dired-keys)
1545 (woman-dired-define-key-maybe "w")
1546 (woman-dired-define-key-maybe "W")))
1547 (define-key-after (lookup-key dired-mode-map [menu-bar immediate])
1548 [woman] '("Read Man Page (WoMan)" . woman-dired-find-file) 'view))
1550 (if (featurep 'dired)
1551 (woman-dired-define-keys)
1552 (add-hook 'dired-mode-hook 'woman-dired-define-keys))
1554 (declare-function dired-get-filename "dired"
1555 (&optional localp no-error-if-not-filep))
1557 ;;;###autoload
1558 (defun woman-dired-find-file ()
1559 "In dired, run the WoMan man-page browser on this file."
1560 (interactive)
1561 (woman-find-file (dired-get-filename)))
1564 ;;; tar-mode support
1566 (defvar global-font-lock-mode) ; defined in font-core.el
1568 (defun woman-tar-extract-file ()
1569 "In tar mode, run the WoMan man-page browser on this file."
1570 (interactive)
1571 (or (eq major-mode 'tar-mode)
1572 (error "`woman-tar-extract-file' can be used only in `tar-mode'"))
1573 (buffer-disable-undo)
1574 (let (global-font-lock-mode)
1575 (funcall (symbol-function 'tar-extract)) ; defined in tar-mode
1576 (let ((WoMan-current-file buffer-file-name)) ; used for message logging
1577 (rename-buffer
1578 (woman-make-bufname (file-name-nondirectory buffer-file-name)))
1579 (woman-process-buffer)
1580 (goto-char (point-min)))))
1582 (defvar woman-last-file-name nil
1583 "The full pathname of the last file formatted by WoMan.")
1585 (defun woman-reformat-last-file ()
1586 "Reformat last file, e.g. after changing fill column."
1587 (interactive)
1588 (if woman-last-file-name
1589 (woman-find-file woman-last-file-name t)
1590 (call-interactively 'woman-find-file)))
1592 ;;;###autoload
1593 (defun woman-find-file (file-name &optional reformat)
1594 "Find, decode and browse a specific UN*X man-page source file FILE-NAME.
1595 Use existing buffer if possible; reformat only if prefix arg given.
1596 When called interactively, optional argument REFORMAT forces reformatting
1597 of an existing WoMan buffer formatted earlier.
1598 No external programs are used, except that `gunzip' will be used to
1599 decompress the file if appropriate. See the documentation for the
1600 `woman' command for further details."
1601 (interactive "fBrowse UN*X manual file: \nP")
1602 (setq woman-last-file-name
1603 (setq file-name (expand-file-name file-name))) ; to canonicalize
1604 (let ((alist-tail woman-buffer-alist) exists)
1605 (setq woman-buffer-number 0)
1606 (while (and alist-tail (not (string= file-name (car (car alist-tail)))))
1607 (setq alist-tail (cdr alist-tail)
1608 woman-buffer-number (1+ woman-buffer-number)))
1609 (or (and (setq exists
1610 (and alist-tail (WoMan-find-buffer))) ; buffer exists
1611 (not reformat))
1612 ;; Format new buffer or reformat current buffer:
1613 (let* ((bufname (file-name-nondirectory file-name))
1614 (case-fold-search t)
1615 (compressed
1616 (and (string-match-p woman-file-compression-regexp bufname) t)))
1617 (if compressed
1618 (setq bufname (file-name-sans-extension bufname)))
1619 (setq bufname (if exists
1620 (buffer-name)
1621 (woman-make-bufname bufname)))
1622 (woman-really-find-file file-name compressed bufname)
1623 (or exists
1624 (setq woman-buffer-alist
1625 (cons (cons file-name bufname) woman-buffer-alist)
1626 woman-buffer-number 0)))))
1627 (Man-build-section-alist)
1628 (Man-build-references-alist)
1629 (goto-char (point-min)))
1631 (defun woman-make-bufname (bufname)
1632 "Create an unambiguous buffer name from BUFNAME."
1633 ;; See Bug#5038. Any compression extension has already been removed.
1634 ;; Go from eg "host.conf.5" to "5 host.conf".
1635 (let ((dot (string-match "\\.[^.]*\\'" bufname)))
1636 (if dot (setq bufname (concat
1637 (substring bufname (1+ dot)) " "
1638 (substring bufname 0 dot))))
1639 (generate-new-buffer-name ; ensure uniqueness
1640 (concat "*WoMan " bufname "*"))))
1642 (defvar woman-frame nil
1643 "Dedicated frame used for displaying WoMan windows.")
1645 (defun woman-really-find-file (filename compressed bufname)
1646 "Find, decompress, and decode a UN*X man page FILENAME.
1647 If COMPRESSED is non-nil, turn on auto-compression mode to decompress
1648 the file if necessary. Set buffer name BUFNAME and major mode.
1649 Do not call directly!"
1650 (let ((WoMan-current-file filename)) ; used for message logging
1651 (if woman-use-own-frame
1652 (select-frame
1653 (or (and (frame-live-p woman-frame) woman-frame)
1654 (setq woman-frame (make-frame)))))
1655 (set-buffer (get-buffer-create bufname))
1656 (condition-case nil
1657 (pop-to-buffer-same-window (current-buffer))
1658 (error (pop-to-buffer (current-buffer))))
1659 (buffer-disable-undo)
1660 (setq buffer-read-only nil)
1661 (erase-buffer) ; NEEDED for reformat
1662 (woman-insert-file-contents filename compressed)
1663 ;; Set buffer's default directory to that of the file.
1664 (setq default-directory (file-name-directory filename))
1665 (set (make-local-variable 'backup-inhibited) t)
1666 (set-visited-file-name "")
1667 (woman-process-buffer)))
1669 (defun woman-process-buffer ()
1670 "The second half of `woman-really-find-file'!"
1671 (interactive)
1672 ;; Check (crudely) that this really is likely to be in UN*X
1673 ;; man-page source format, assuming we are at point-min:
1674 (goto-char (point-min))
1675 (if (re-search-forward "^[.']" 1000 t)
1676 (woman-decode-buffer)
1677 (message
1678 "File appears to be pre-formatted -- using source file may be better.")
1679 (woman-man-buffer))
1680 (woman-mode))
1682 (defun woman-man-buffer ()
1683 "Post-process an nroff-preformatted man buffer."
1684 ;; Kill all leading whitespace:
1685 (if (looking-at "\\s-+") (woman-delete-match 0))
1686 ;; Delete all page footer/header pairs:
1687 (re-search-forward ".*") ; match header
1688 ;; Footer conventionally has page number at right, so ...
1689 (let ((regex (concat
1690 "^.*[0-9]\n\\s-*" ; footer and following blank lines
1691 (regexp-quote (match-string 0)) ; header
1692 "\\s-*\n"))) ; following blank lines
1693 (while (re-search-forward regex nil 1) ; finish at eob
1694 (woman-delete-match 0)))
1695 ;; Delete last text line (footer) and all following blank lines:
1696 (re-search-backward "\\S-")
1697 (beginning-of-line)
1698 (if (looking-at ".*[0-9]$")
1699 (delete-region (point) (point-max)))
1701 ;; Squeeze multiple blank lines:
1702 (goto-char (point-min))
1703 (while (re-search-forward "^[ \t]*\n\\([ \t]*\n\\)+" nil t)
1704 (replace-match "\n" t t))
1706 ;; CJK characters are underlined by double-sized "__".
1707 ;; (Code lifted from man.el, with trivial changes.)
1708 (if (< (buffer-size) (position-bytes (point-max)))
1709 ;; Multibyte characters exist.
1710 (progn
1711 (goto-char (point-min))
1712 (while (search-forward "__\b\b" nil t)
1713 (backward-delete-char 4)
1714 (woman-set-face (point) (1+ (point)) 'woman-italic))
1715 (goto-char (point-min))
1716 (while (search-forward "\b\b__" nil t)
1717 (backward-delete-char 4)
1718 (woman-set-face (1- (point)) (point) 'woman-italic))))
1720 ;; Interpret overprinting to indicate bold face:
1721 (goto-char (point-min))
1722 (while (re-search-forward "\\(.\\)\\(\\(\b+\\1\\)+\\)" nil t)
1723 (woman-delete-match 2)
1724 (woman-set-face (1- (point)) (point) 'woman-bold))
1726 ;; Interpret underlining to indicate italic face:
1727 ;; (Must be AFTER emboldening to interpret bold _ correctly!)
1728 (goto-char (point-min))
1729 (while (search-forward "_\b" nil t)
1730 (delete-char -2)
1731 (woman-set-face (point) (1+ (point)) 'woman-italic))
1733 ;; Leave any other uninterpreted ^H's in the buffer for now! (They
1734 ;; might indicate composite special characters, which could be
1735 ;; interpreted if I knew what to expect.)
1737 ;; Optionally embolden section and subsection headings
1738 ;; (cf. `woman-imenu-generic-expression'):
1739 (cond
1740 (woman-bold-headings
1741 (goto-char (point-min))
1742 (forward-line)
1743 (while (re-search-forward "^\\( \\)?\\([A-Z].*\\)" nil t)
1744 (woman-set-face (match-beginning 2) (match-end 2) 'woman-bold)))))
1746 (defun woman-insert-file-contents (filename compressed)
1747 "Insert file FILENAME into the current buffer.
1748 If COMPRESSED is t, or is non-nil and the filename implies compression,
1749 then turn on auto-compression mode to decompress the file.
1750 Leave point at end of new text. Return length of inserted text."
1751 ;; Leaves point at end of inserted text in GNU Emacs 20.3, but at
1752 ;; start in 19.34!
1753 (save-excursion
1754 (let ((case-fold-search t))
1755 ;; Cooperate with auto-compression mode:
1756 (if (and compressed
1757 (or (eq compressed t)
1758 (string-match-p woman-file-compression-regexp filename))
1759 ;; (not auto-compression-mode)
1760 (not (rassq 'jka-compr-handler file-name-handler-alist)) )
1761 ;; (error "Compressed file requires Auto File Decompression turned on")
1762 (auto-compression-mode 1))
1763 (nth 1
1764 (condition-case ()
1765 (insert-file-contents filename nil)
1766 (file-error
1767 ;; Run find-file-not-found-hooks until one returns non-nil.
1768 ;; (run-hook-with-args-until-success 'find-file-not-found-hooks)
1769 (insert "\n***** File " filename " not found! *****\n\n")))))))
1772 ;;; Major mode (Man) interface:
1774 (defvar woman-mode-map
1775 (let ((map (make-sparse-keymap)))
1776 (set-keymap-parent map Man-mode-map)
1778 (define-key map "R" 'woman-reformat-last-file)
1779 (define-key map "w" 'woman)
1780 (define-key map "\en" 'WoMan-next-manpage)
1781 (define-key map "\ep" 'WoMan-previous-manpage)
1782 (define-key map [M-mouse-2] 'woman-follow-word)
1784 ;; We don't need to call `man' when we are in `woman-mode'.
1785 (define-key map [remap man] 'woman)
1786 (define-key map [remap man-follow] 'woman-follow)
1787 map)
1788 "Keymap for woman mode.")
1790 (defun woman-follow (topic)
1791 "Get a Un*x manual page of the item under point and put it in a buffer."
1792 (interactive (list (Man-default-man-entry)))
1793 (if (or (not topic)
1794 (string= topic ""))
1795 (error "No item under point")
1796 (woman (if (string-match Man-reference-regexp topic)
1797 (substring topic 0 (match-end 1))
1798 topic))))
1800 (defun woman-follow-word (event)
1801 "Run WoMan with word under mouse as topic.
1802 Argument EVENT is the invoking mouse event."
1803 (interactive "e") ; mouse event
1804 (goto-char (posn-point (event-start event)))
1805 (woman (or (current-word t) "")))
1807 ;; WoMan menu bar and pop-up menu:
1808 (easy-menu-define
1809 woman-menu ; (SYMBOL MAPS DOC MENU)
1810 ;; That comment was moved after the symbol `woman-menu' to make
1811 ;; find-function-search-for-symbol work. -- rost
1812 woman-mode-map
1813 "WoMan Menu"
1814 `("WoMan"
1815 ["WoMan..." woman t] ; [NAME CALLBACK ENABLE]
1816 "--"
1817 ["Next Section" Man-next-section t]
1818 ["Previous Section" Man-previous-section t]
1819 ["Goto Section..." Man-goto-section t]
1820 ["Goto See-Also Section" Man-goto-see-also-section t]
1821 ["Follow Reference..." Man-follow-manual-reference t]
1822 "--"
1823 ["Previous WoMan Buffer" WoMan-previous-manpage t]
1824 ["Next WoMan Buffer" WoMan-next-manpage t]
1825 ["Bury WoMan Buffer" Man-quit t]
1826 ["Kill WoMan Buffer" Man-kill t]
1827 "--"
1828 ;; ["Toggle Fill Frame Width" woman-toggle-fill-frame t]
1829 ["Use Full Frame Width" woman-toggle-fill-frame
1830 :active t :style toggle :selected woman-fill-frame]
1831 ["Reformat Last Man Page" woman-reformat-last-file t]
1832 ["Make Contents Menu" (woman-imenu t) (not woman-imenu-done)]
1833 "--"
1834 ["Describe (Wo)Man Mode" describe-mode t]
1835 ["Mini Help" woman-mini-help t]
1836 ,@(if (fboundp 'customize-group)
1837 '(["Customize..." (customize-group 'woman) t]))
1838 ["Show Version" (message "WoMan %s" woman-version) t]
1839 "--"
1840 ("Advanced"
1841 ["View Source" (view-file woman-last-file-name) woman-last-file-name]
1842 ["Show Log" (switch-to-buffer-other-window "*WoMan-Log*" t) t]
1843 ["Extended Font" woman-toggle-use-extended-font
1844 :included woman-font-support
1845 :active t :style toggle :selected woman-use-extended-font]
1846 ["Symbol Font" woman-toggle-use-symbol-font
1847 :included woman-font-support
1848 :active t :style toggle :selected woman-use-symbol-font]
1849 ["Font Map" woman-display-extended-fonts
1850 :included woman-font-support
1851 :active woman-use-symbol-font]
1852 "--"
1853 "Emulation"
1854 ["nroff" (woman-reset-emulation 'nroff)
1855 :active t :style radio :selected (eq woman-emulation 'nroff)]
1856 ["troff" (woman-reset-emulation 'troff)
1857 :active t :style radio :selected (eq woman-emulation 'troff)]
1861 (defun woman-toggle-use-extended-font ()
1862 "Toggle `woman-use-extended-font' and reformat, for menu use."
1863 (interactive)
1864 (setq woman-use-extended-font (not woman-use-extended-font))
1865 (woman-reformat-last-file))
1867 (defun woman-toggle-use-symbol-font ()
1868 "Toggle `woman-use-symbol-font' and reformat, for menu use."
1869 (interactive)
1870 (setq woman-use-symbol-font (not woman-use-symbol-font))
1871 (woman-reformat-last-file))
1873 (defun woman-reset-emulation (value)
1874 "Reset `woman-emulation' to VALUE and reformat, for menu use."
1875 (interactive)
1876 (setq woman-emulation value)
1877 (woman-reformat-last-file))
1879 (defvar bookmark-make-record-function)
1880 (put 'woman-mode 'mode-class 'special)
1882 (defun woman-mode ()
1883 "Turn on (most of) Man mode to browse a buffer formatted by WoMan.
1884 WoMan is an ELisp emulation of much of the functionality of the Emacs
1885 `man' command running the standard UN*X man and ?roff programs.
1886 WoMan author: F.J.Wright@Maths.QMW.ac.uk
1887 WoMan version: see `woman-version'.
1888 See `Man-mode' for additional details."
1889 (let ((Man-build-page-list (symbol-function 'Man-build-page-list))
1890 (Man-strip-page-headers (symbol-function 'Man-strip-page-headers))
1891 (Man-unindent (symbol-function 'Man-unindent))
1892 (Man-goto-page (symbol-function 'Man-goto-page)))
1893 ;; Prevent inappropriate operations:
1894 (fset 'Man-build-page-list 'ignore)
1895 (fset 'Man-strip-page-headers 'ignore)
1896 (fset 'Man-unindent 'ignore)
1897 (fset 'Man-goto-page 'ignore)
1898 (unwind-protect
1899 (delay-mode-hooks (Man-mode))
1900 ;; Restore the status quo:
1901 (fset 'Man-build-page-list Man-build-page-list)
1902 (fset 'Man-strip-page-headers Man-strip-page-headers)
1903 (fset 'Man-unindent Man-unindent)
1904 (fset 'Man-goto-page Man-goto-page)
1905 (setq tab-width woman-tab-width)))
1906 (setq major-mode 'woman-mode
1907 mode-name "WoMan")
1908 ;; Don't show page numbers like Man-mode does. (Online documents do
1909 ;; not have pages)
1910 (kill-local-variable 'mode-line-buffer-identification)
1911 (use-local-map woman-mode-map)
1912 ;; Imenu support:
1913 (set (make-local-variable 'imenu-generic-expression)
1914 ;; `make-local-variable' in case imenu not yet loaded!
1915 woman-imenu-generic-expression)
1916 (set (make-local-variable 'imenu-space-replacement) " ")
1917 ;; Bookmark support.
1918 (set (make-local-variable 'bookmark-make-record-function)
1919 'woman-bookmark-make-record)
1920 ;; For reformat ...
1921 ;; necessary when reformatting a file in its old buffer:
1922 (setq imenu--last-menubar-index-alist nil)
1923 ;; necessary to avoid re-installing the same imenu:
1924 (setq woman-imenu-done nil)
1925 (if woman-imenu (woman-imenu))
1926 (let ((inhibit-read-only t))
1927 (Man-highlight-references 'WoMan-xref-man-page))
1928 (set-buffer-modified-p nil)
1929 (run-mode-hooks 'woman-mode-hook))
1931 (defun woman-imenu (&optional redraw)
1932 "Add a \"Contents\" menu to the menubar.
1933 Optional argument REDRAW, if non-nil, forces mode line to be updated."
1934 (interactive)
1935 (if woman-imenu-done
1936 ;; This is PRIMARILY to avoid a bug in imenu-add-to-menubar that
1937 ;; causes it to corrupt the menu bar if it is run more than once
1938 ;; in the same buffer.
1940 (setq woman-imenu-done t)
1941 (imenu-add-to-menubar woman-imenu-title)
1942 (if redraw (force-mode-line-update))))
1944 (defun woman-toggle-fill-frame ()
1945 "Toggle formatting to fill (most of) the width of the current frame."
1946 (interactive)
1947 (setq woman-fill-frame (not woman-fill-frame))
1948 (message "Woman fill column set to %s."
1949 (if woman-fill-frame "frame width" woman-fill-column)))
1951 (declare-function apropos-print "apropos"
1952 (do-keys spacing &optional text nosubst))
1954 (defun woman-mini-help ()
1955 "Display WoMan commands and user options in an `apropos' buffer."
1956 ;; Based on apropos-command in apropos.el
1957 (interactive)
1958 (require 'apropos)
1959 (let ((message
1960 (let ((standard-output (get-buffer-create "*Apropos*")))
1961 (help-print-return-message 'identity))))
1962 (setq apropos-accumulator
1963 (apropos-internal "woman"
1964 (lambda (symbol)
1965 (and
1966 (or (commandp symbol)
1967 (custom-variable-p symbol))
1968 (not (get symbol 'apropos-inhibit))))))
1969 ;; Find documentation strings:
1970 (let ((p apropos-accumulator)
1971 doc symbol)
1972 (while p
1973 (setcar p (list ; must have 3 elements:
1974 (setq symbol (car p)) ; 1. name
1975 (if (functionp symbol) ; 2. command doc
1976 (if (setq doc (documentation symbol t))
1977 (substring doc 0 (string-match "\n" doc))
1978 "(not documented)"))
1979 (if (custom-variable-p symbol) ; 3. variable doc
1980 (if (setq doc (documentation-property
1981 symbol 'variable-documentation t))
1982 (substring doc 0 (string-match "\n" doc))))))
1983 (setq p (cdr p))))
1984 ;; Output the result:
1985 (and (apropos-print t nil)
1986 message
1987 (message "%s" message))))
1990 (defun WoMan-getpage-in-background (topic)
1991 "Use TOPIC to start WoMan from `Man-follow-manual-reference'."
1992 ;; topic is a string, generally of the form "section topic"
1993 (let ((s (string-match " " topic)))
1994 (if s (setq topic (substring topic (1+ s))))
1995 (woman topic)))
1997 (defvar WoMan-Man-start-time nil
1998 "Used to record formatting time used by the `man' command.")
2000 ;; Both advices are disabled because "a file in Emacs should not put
2001 ;; advice on a function in Emacs" (see Info node "(elisp)Advising
2002 ;; Functions"). Counting the formatting time is useful for
2003 ;; developing, but less applicable for daily use. The advice for
2004 ;; `Man-getpage-in-background' can be discarded, because the
2005 ;; key-binding in `woman-mode-map' has been remapped to call `woman'
2006 ;; but `man'. Michael Albinus <michael.albinus@gmx.de>
2008 ;; (defadvice Man-getpage-in-background
2009 ;; (around Man-getpage-in-background-advice (topic) activate)
2010 ;; "Use WoMan unless invoked outside a WoMan buffer or invoked explicitly.
2011 ;; Otherwise use Man and record start of formatting time."
2012 ;; (if (and (eq major-mode 'woman-mode)
2013 ;; (not (eq (caar command-history) 'man)))
2014 ;; (WoMan-getpage-in-background topic)
2015 ;; ;; Initiates man processing
2016 ;; (setq WoMan-Man-start-time (current-time))
2017 ;; ad-do-it))
2019 ;; (defadvice Man-bgproc-sentinel
2020 ;; (after Man-bgproc-sentinel-advice activate)
2021 ;; ;; Terminates man processing
2022 ;; "Report formatting time."
2023 ;; (let* ((time (current-time))
2024 ;; (time (+ (* (- (car time) (car WoMan-Man-start-time)) 65536)
2025 ;; (- (cadr time) (cadr WoMan-Man-start-time)))))
2026 ;; (message "Man formatting done in %d seconds" time)))
2029 ;;; Buffer handling:
2031 (defun WoMan-previous-manpage ()
2032 "Find the previous WoMan buffer."
2033 ;; Assumes currently in a WoMan buffer!
2034 (interactive)
2035 (WoMan-find-buffer) ; find current existing buffer
2036 (if (null (cdr woman-buffer-alist))
2037 (error "No previous WoMan buffer"))
2038 (if (>= (setq woman-buffer-number (1+ woman-buffer-number))
2039 (length woman-buffer-alist))
2040 (setq woman-buffer-number 0))
2041 (if (WoMan-find-buffer)
2043 (if (< (setq woman-buffer-number (1- woman-buffer-number)) 0)
2044 (setq woman-buffer-number (1- (length woman-buffer-alist))))
2045 (WoMan-previous-manpage)))
2047 (defun WoMan-next-manpage ()
2048 "Find the next WoMan buffer."
2049 ;; Assumes currently in a WoMan buffer!
2050 (interactive)
2051 (WoMan-find-buffer) ; find current existing buffer
2052 (if (null (cdr woman-buffer-alist))
2053 (error "No next WoMan buffer"))
2054 (if (< (setq woman-buffer-number (1- woman-buffer-number)) 0)
2055 (setq woman-buffer-number (1- (length woman-buffer-alist))))
2056 (if (WoMan-find-buffer)
2058 (WoMan-next-manpage)))
2060 (defun WoMan-find-buffer ()
2061 "Switch to buffer corresponding to `woman-buffer-number' and return it.
2062 If such a buffer does not exist then remove its association from the
2063 alist in `woman-buffer-alist' and return nil."
2064 (if (zerop woman-buffer-number)
2065 (let ((buffer (get-buffer (cdr (car woman-buffer-alist)))))
2066 (if buffer
2067 (pop-to-buffer-same-window buffer)
2068 ;; Delete alist element:
2069 (setq woman-buffer-alist (cdr woman-buffer-alist))
2070 nil))
2071 (let* ((prev-ptr (nthcdr (1- woman-buffer-number) woman-buffer-alist))
2072 (buffer (get-buffer (cdr (car (cdr prev-ptr))))))
2073 (if buffer
2074 (pop-to-buffer-same-window buffer)
2075 ;; Delete alist element:
2076 (setcdr prev-ptr (cdr (cdr prev-ptr)))
2077 (if (>= woman-buffer-number (length woman-buffer-alist))
2078 (setq woman-buffer-number 0))
2079 nil))))
2082 ;;; Syntax and display tables:
2084 (defconst woman-escaped-escape-char ?\x1c
2085 ;; An arbitrary unused control character
2086 "Internal character representation of escaped escape characters.")
2087 (defconst woman-escaped-escape-string
2088 (char-to-string woman-escaped-escape-char)
2089 "Internal string representation of escaped escape characters.")
2091 (defconst woman-unpadded-space-char ?\x1d
2092 ;; An arbitrary unused control character
2093 "Internal character representation of unpadded space characters.")
2094 (defconst woman-unpadded-space-string
2095 (char-to-string woman-unpadded-space-char)
2096 "Internal string representation of unpadded space characters.")
2098 (defvar woman-syntax-table
2099 (let ((st (make-syntax-table)))
2100 ;; The following internal chars must NOT have whitespace syntax:
2101 (modify-syntax-entry woman-unpadded-space-char "." st)
2102 (modify-syntax-entry woman-escaped-escape-char "." st)
2104 "Syntax table to support special characters used internally by WoMan.")
2106 (defun woman-set-buffer-display-table ()
2107 "Set up a display table for a WoMan buffer.
2108 This display table is used for displaying internal special characters, but
2109 does not interfere with any existing display table, e.g. for displaying
2110 European characters."
2111 (setq buffer-display-table
2112 ;; The following test appears to be necessary on some
2113 ;; non-Windows platforms, e.g. Solaris 2.6 when running on a
2114 ;; tty. Thanks to T. V. Raman <raman@Adobe.COM>.
2115 ;; The MS-DOS terminal also sets standard-display-table to
2116 ;; a non-nil value.
2117 (if standard-display-table ; default is nil !!!
2118 (copy-sequence standard-display-table)
2119 (make-display-table)))
2120 ;; Display the following internal chars correctly:
2121 (aset buffer-display-table woman-unpadded-space-char [?\s])
2122 (aset buffer-display-table woman-escaped-escape-char [?\\]))
2125 ;;; The main decoding driver:
2127 (defvar font-lock-mode) ; for the compiler
2129 (defun woman-decode-buffer ()
2130 "Decode a buffer in UN*X man-page source format.
2131 No external programs are used."
2132 (interactive) ; mainly for testing
2133 (WoMan-log-begin)
2134 (run-hooks 'woman-pre-format-hook)
2135 (and (boundp 'font-lock-mode) font-lock-mode (font-lock-mode -1))
2136 ;; (fundamental-mode)
2137 (let ((start-time (current-time))
2138 time)
2139 (message "WoMan formatting buffer...")
2140 ; (goto-char (point-min))
2141 ; (cond
2142 ; ((re-search-forward "^\\.[ \t]*TH" nil t) ; wrong format if not found?
2143 ; (beginning-of-line)
2144 ; (delete-region (point-min) (point))) ; potentially dangerous!
2145 ; (t (message "WARNING: .TH request not found -- not man-page format?")))
2146 (woman-decode-region (point-min) (point-max))
2147 (setq time (float-time (time-since start-time)))
2148 (message "WoMan formatting buffer...done in %g seconds" time)
2149 (WoMan-log-end time))
2150 (run-hooks 'woman-post-format-hook))
2152 (defvar woman-string-alist ; rebound in woman-decode-region
2153 '(("S" . "") ("R" . "(Reg.)") ("Tm" . "(TM)")
2154 ("lq" . "\"") ("rq" . "\"")
2155 ("''" . "\"") ; needed for gcc.1
2156 (".T" . "") ; output device from -T option?
2158 "Alist of strings predefined in the -man macro package `tmac.an'.")
2160 (defvar woman-negative-vertical-space nil ; rebound in woman-decode-region
2161 "Set to t if .sp N with N < 0 encountered.")
2163 (defun woman-pre-process-region (from to)
2164 "Pre-process escapes and comments in the region of text between FROM and TO.
2165 To be called on original buffer and any .so insertions."
2166 ;; Hide escaped escapes \\ and printable escapes \e very early
2167 ;; (to be re-instated as just \ very late!):
2168 (goto-char from)
2169 ;; .eo turns off escape character processing
2170 (while (re-search-forward "\\(\\\\[\\e]\\)\\|^\\.eo" to t) ; \\
2171 (if (match-beginning 1)
2172 (replace-match woman-escaped-escape-string t t)
2173 (woman-delete-whole-line)
2174 ;; .ec turns on escape character processing (and sets the
2175 ;; escape character to its argument, if any, which I'm ignoring
2176 ;; for now!)
2177 (while (and (re-search-forward "\\(\\\\\\)\\|^\\.ec" to t) ; \
2178 (match-beginning 1))
2179 (replace-match woman-escaped-escape-string t t))
2180 ;; ***** Need test for .ec arg and warning here! *****
2181 (woman-delete-whole-line)))
2183 ;; Delete comments .\"<anything>, \"<anything> and null requests.
2184 ;; (However, should null . requests cause a break?)
2185 (goto-char from)
2186 (while (re-search-forward "^[.'][ \t]*\\(\\\\\".*\\)?\n\\|\\\\\".*" to t)
2187 (woman-delete-match 0)))
2189 (defun woman-non-underline-faces ()
2190 "Prepare non-underlined versions of underlined faces."
2191 (let ((face-list (face-list)))
2192 (dolist (face face-list)
2193 (let ((face-name (symbol-name face)))
2194 (if (and (string-match-p "\\`woman-" face-name)
2195 (face-underline-p face))
2196 (let ((face-no-ul (intern (concat face-name "-no-ul"))))
2197 (copy-face face face-no-ul)
2198 (set-face-underline face-no-ul nil)))))))
2200 ;; Preprocessors
2201 ;; =============
2203 ;; This information is based on documentation for the man command by
2204 ;; Graeme W. Wilford <G.Wilford@ee.surrey.ac.uk>
2206 ;; First, the environment variable $MANROFFSEQ is interrogated, and if
2207 ;; not set then the initial line of the nroff file is parsed for a
2208 ;; preprocessor string. To contain a valid preprocessor string, the
2209 ;; first line must resemble
2211 ;; '\" <string>
2213 ;; where string can be any combination of the following letters that
2214 ;; specify the sequence of preprocessors to run before nroff or
2215 ;; troff/groff. Not all installations will have a full set of
2216 ;; preprocessors. Some of the preprocessors and the letters used to
2217 ;; designate them are: eqn (e), grap (g), pic (p), tbl (t), vgrind
2218 ;; (v), refer (r). This option overrides the $MANROFFSEQ environment
2219 ;; variable. zsoelim is always run as the very first preprocessor.
2221 (defvar woman-emulate-tbl nil
2222 "True if WoMan should emulate the tbl preprocessor.
2223 This applies to text between .TE and .TS directives.
2224 Currently set only from \\='\\\" t in the first line of the source file.")
2226 (defun woman-decode-region (from _to)
2227 "Decode the region between FROM and TO in UN*X man-page source format."
2228 ;; Suitable for use in format-alist.
2229 ;; But this requires care to control major mode implied font locking.
2230 ;; Must return the new end of file. See format.el for details.
2231 ;; NB: The `to' argument is bogus: it is not currently used, and if
2232 ;; it were it would need to be a marker rather than a position!
2233 ;; First force the correct environment:
2234 (let ((case-fold-search nil) ; This is necessary!
2235 (woman-string-alist woman-string-alist)
2236 (woman-fill-column woman-fill-column)
2237 woman-negative-vertical-space)
2238 (setq woman-left-margin woman-default-indent
2239 woman-prevailing-indent woman-default-indent
2240 woman-interparagraph-distance 1
2241 woman-leave-blank-lines nil
2242 woman-RS-left-margin nil
2243 woman-RS-prevailing-indent nil
2244 woman-adjust woman-adjust-both
2245 woman-justify (nth woman-adjust woman-justify-list)
2246 woman-nofill nil)
2248 (setq woman-if-conditions-true
2249 (cons (string-to-char (symbol-name woman-emulation)) '(?e ?o)))
2251 ;; Prepare non-underlined versions of underlined faces:
2252 (woman-non-underline-faces)
2253 ;; Set font of `woman-symbol' face to `woman-symbol-font' if
2254 ;; `woman-symbol-font' is well defined.
2255 (and woman-use-symbol-font
2256 (stringp woman-symbol-font)
2257 (set-face-font 'woman-symbol woman-symbol-font
2258 (and (frame-live-p woman-frame) woman-frame)))
2260 (setq-local adaptive-fill-mode nil) ; No special "%" "#" etc filling.
2262 ;; Set syntax and display tables:
2263 (set-syntax-table woman-syntax-table)
2264 (woman-set-buffer-display-table)
2266 ;; Based loosely on a suggestion by Theodore Jump:
2267 (if (or woman-fill-frame
2268 (not (and (integerp woman-fill-column) (> woman-fill-column 0))))
2269 (setq woman-fill-column (- (window-width) woman-default-indent)))
2271 ;; Check for preprocessor requests:
2272 (goto-char from)
2273 (if (looking-at "'\\\\\"[ \t]*\\([a-z]+\\)")
2274 (let ((letters (append (match-string 1) nil)))
2275 (if (memq ?t letters)
2276 (setq woman-emulate-tbl t
2277 letters (delete ?t letters)))
2278 (if letters
2279 (WoMan-warn "Unhandled preprocessor request letters %s"
2280 (concat letters)))
2281 (woman-delete-line 1)))
2283 (woman-pre-process-region from nil)
2284 ;; Process ignore requests, macro definitions,
2285 ;; conditionals and switch source requests:
2286 (woman0-roff-buffer from)
2288 ;; Check for macro sets that woman cannot handle. We can only
2289 ;; because do this after processing source-switch directives.
2290 (goto-char (point-min))
2291 (let ((case-fold-search nil))
2292 (unless (and (re-search-forward "^\\.SH[ \n]" (point-max) t)
2293 (progn (goto-char (point-min))
2294 (re-search-forward "^\\.TH[ \n]" (point-max) t))
2295 (progn (goto-char (point-min))
2296 (not (re-search-forward "^\\.\\([pnil]p\\|sh\\)[ \n]"
2297 (point-max) t))))
2298 (error "WoMan can only format man pages written with the usual `-man' macros")))
2300 ;; Process \k escapes BEFORE changing tab width (?):
2301 (goto-char from)
2302 (woman-mark-horizontal-position)
2304 ;; Set buffer-local variables:
2305 (setq fill-column woman-fill-column
2306 tab-width woman-tab-width)
2308 ;; Hide unpaddable and digit-width spaces \(space) and \0:
2309 (goto-char from)
2310 (while (re-search-forward "\\\\[ 0]" nil t)
2311 (replace-match woman-unpadded-space-string t t))
2313 ;; Discard optional hyphen \%; concealed newlines \<newline>;
2314 ;; point-size change function \sN,\s+N, \s-N:
2315 (goto-char from)
2316 (while (re-search-forward "\\\\\\([%\n]\\|s[-+]?[0-9]+\\)" nil t)
2317 (woman-delete-match 0))
2319 ;; BEWARE: THIS SHOULD PROBABLY ALL BE DONE MUCH LATER!!!!!
2320 ;; Process trivial escapes \-, \`, \.
2321 ;; (\' must be done after tab processing!):
2322 (goto-char from)
2323 (while (re-search-forward "\\\\\\([-`.]\\)" nil t)
2324 (replace-match "\\1"))
2325 ;; NB: Must keep ALL zero-width characters \&, \|, and \^ until
2326 ;; ALL requests processed!
2328 ;; Process no-break requests and macros (including font-change macros):
2329 (goto-char from)
2330 (woman1-roff-buffer)
2332 ;; Process strings and special character escapes \(xx:
2333 ;; (Must do this BEFORE fontifying!)
2334 (goto-char from)
2335 (woman-strings)
2336 ;; Special chars moved after translation in
2337 ;; `woman2-process-escapes' (for pic.1):
2338 ; (goto-char from)
2339 ; (woman-special-characters)
2341 ;; Process standard font-change requests and escapes:
2342 (goto-char from)
2343 (woman-change-fonts)
2345 ;; 1/2 em vertical motion \d, \u and general local vertical motion
2346 ;; \v'+/-N' simulated using TeX ^ and _ symbols for now.
2347 (goto-char from)
2348 (let ((first t)) ; assume no nesting!
2349 (while (re-search-forward "\\\\\\([du]\\|v'[^']*'\\)" nil t)
2350 (let* ((esc (match-string 1))
2351 (repl (if (or (= (aref esc 0) ?u)
2352 (and (>= (length esc) 2) (= (aref esc 2) ?-)))
2353 "^" "_")))
2354 (cond (first
2355 (replace-match repl nil t)
2356 (put-text-property (1- (point)) (point) 'face 'woman-addition)
2357 (WoMan-warn
2358 "Initial vertical motion escape \\%s simulated" esc)
2359 (WoMan-log
2360 " by TeX `%s' in woman-addition-face!" repl))
2362 (woman-delete-match 0)
2363 (WoMan-warn
2364 "Terminal vertical motion escape \\%s ignored!" esc)))
2365 (setq first (not first)))))
2367 ;; Process formatting macros
2368 (goto-char from)
2369 (woman2-roff-buffer)
2371 ;; Go back and process negative vertical space if necessary:
2372 (if woman-negative-vertical-space
2373 (woman-negative-vertical-space from))
2375 (when woman-preserve-ascii
2376 ;; Re-instate escaped escapes to just `\' and unpaddable spaces
2377 ;; to just `space'. This is not necessary for display since
2378 ;; there are display table entries for the escaped chars, but it
2379 ;; is necessary if the buffer might be saved as ASCII.
2381 ;; `subst-char-in-region' preserves text properties on the
2382 ;; characters, which is necessary for bold, underline, etc on
2383 ;; \e. There's usually no face on spaces, but if there is then
2384 ;; it's good to keep that too.
2385 (subst-char-in-region from (point-max)
2386 woman-escaped-escape-char ?\\)
2387 (subst-char-in-region from (point-max)
2388 woman-unpadded-space-char ?\s))
2390 ;; Must return the new end of file if used in format-alist.
2391 (point-max)))
2393 (defun woman-horizontal-escapes (to)
2394 "Process \\h'+/-N' local horizontal motion escapes upto TO.
2395 Implements arbitrary forward and non-overlapping backward motion.
2396 Preserves location of `point'."
2397 ;; Moved from `woman-decode-region' for version 0.50.
2398 ;; N may include width escape \w'...' (but may already be processed!
2399 (let ((from (point)))
2400 (while (re-search-forward
2401 ;; Delimiter can be a special char escape sequence \(.. or
2402 ;; a single normal char (usually '):
2403 "\\\\h\\(\\\\(..\\|.\\)\\(|\\)?"
2404 to t)
2405 (let ((from (match-beginning 0))
2406 (delim (regexp-quote (match-string 1)))
2407 (absolute (match-beginning 2)) ; absolute position?
2408 (N (woman-parse-numeric-arg)) ; distance
2410 msg) ; for warning
2411 (if (not (looking-at delim))
2412 ;; Warn but leave escape in buffer unprocessed:
2413 (WoMan-warn
2414 "Local horizontal motion (%s) delimiter error!"
2415 (buffer-substring from (1+ (point)))) ; point at end of arg
2416 (setq to (match-end 0)
2417 ;; For possible warning -- save before deleting:
2418 msg (buffer-substring from to))
2419 (delete-region from to)
2420 (if absolute ; make relative
2421 (setq N (- N (current-column))))
2422 (if (>= N 0)
2423 ;; Move forward by inserting hard spaces:
2424 (insert-char woman-unpadded-space-char N)
2425 ;; Move backwards by deleting space,
2426 ;; first backwards then forwards:
2427 (while (and
2428 (<= (setq N (1+ N)) 0)
2429 (cond ((memq (preceding-char) '(?\s ?\t))
2430 (delete-char -1) t)
2431 ((memq (following-char) '(?\s ?\t))
2432 (delete-char 1) t)
2433 (t nil))))
2434 (if (<= N 0)
2435 (WoMan-warn
2436 "Negative horizontal motion (%s) would overwrite!" msg))))))
2437 (goto-char from)))
2441 ;; Process ignore requests (.ig), conditionals (.if etc.),
2442 ;; source-switch (.so), macro definitions (.de etc.) and macro
2443 ;; expansions.
2445 (defvar woman0-if-to) ; marker bound in woman0-roff-buffer
2446 (defvar woman0-macro-alist) ; bound in woman0-roff-buffer
2447 (defvar woman0-search-regex) ; bound in woman0-roff-buffer
2448 (defvar woman0-search-regex-start ; bound in woman0-roff-buffer
2449 "^[.'][ \t]*\\(ig\\|if\\|ie\\|el\\|so\\|rn\\|de\\|am")
2450 (defconst woman0-search-regex-end "\\)\\([ \t]+\\|$\\)")
2451 ;; May need other terminal characters, e.g. \, but NOT \n!
2452 ;; Alternatively, force maximal match (Posix?)
2454 (defvar woman0-rename-alist) ; bound in woman0-roff-buffer
2456 (defun woman0-roff-buffer (from)
2457 "Process conditional-type requests and user-defined macros.
2458 Start at FROM and re-scan new text as appropriate."
2459 (goto-char from)
2460 (let ((woman0-if-to (make-marker))
2461 woman-request woman0-macro-alist
2462 (woman0-search-regex-start woman0-search-regex-start)
2463 (woman0-search-regex
2464 (concat woman0-search-regex-start woman0-search-regex-end))
2465 processed-first-hunk
2466 woman0-rename-alist)
2467 (set-marker-insertion-type woman0-if-to t)
2468 (while (re-search-forward woman0-search-regex nil t)
2469 (setq woman-request (match-string 1))
2471 ;; Process escape sequences prior to first request (Bug#7843).
2472 (unless processed-first-hunk
2473 (setq processed-first-hunk t)
2474 (let ((process-escapes-to-marker (point-marker)))
2475 (set-marker-insertion-type process-escapes-to-marker t)
2476 (save-match-data
2477 (save-excursion
2478 (goto-char from)
2479 (woman2-process-escapes process-escapes-to-marker)))))
2481 (cond ((string= woman-request "ig") (woman0-ig))
2482 ((string= woman-request "if") (woman0-if "if"))
2483 ((string= woman-request "ie") (woman0-if "ie"))
2484 ((string= woman-request "el") (woman0-el))
2485 ((string= woman-request "so") (woman0-so))
2486 ((string= woman-request "rn") (woman0-rn))
2487 ((string= woman-request "de") (woman0-de))
2488 ((string= woman-request "am") (woman0-de 'append))
2489 (t (woman0-macro woman-request))))
2490 (set-marker woman0-if-to nil)
2491 (woman0-rename)
2492 ;; Should now re-run `woman0-roff-buffer' if any renaming was
2493 ;; done, but let's just hope this is not necessary for now!
2496 (defun woman0-ig ()
2497 ".ig yy -- Discard input up to `.yy', which defaults to `..')."
2498 ;; The terminal request MUST begin with . (not ')!
2499 (looking-at "\\(\\S +\\)?")
2500 (beginning-of-line)
2501 (let ((yy (or (match-string 1) "."))
2502 (from (point)))
2503 (if (re-search-forward
2504 (concat "^\\.[ \t]*" (regexp-quote yy) ".*\n") nil t)
2505 (delete-region from (point))
2506 (WoMan-warn
2507 "ig request ignored -- terminator `.%s' not found!" yy)
2508 (woman-delete-line 1))))
2510 (defsubst woman0-process-escapes (from to)
2511 "Process escapes within an if/ie condition between FROM and TO."
2512 (woman-strings to)
2513 (goto-char from) ; necessary!
2514 ;; Strip font-change escapes:
2515 (while (re-search-forward "\\\\f\\(\\[[^]]+\\]\\|(..\\|.\\)" to t)
2516 (woman-delete-match 0))
2517 (goto-char from) ; necessary!
2518 (woman2-process-escapes to 'numeric))
2520 ;; request does not appear to be used dynamically by any callees.
2521 (defun woman0-if (request)
2522 ".if/ie c anything -- Discard unless c evaluates to true.
2523 Remember condition for use by a subsequent `.el'.
2524 REQUEST is the invoking directive without the leading dot."
2525 ;; c evaluates to a one-character built-in condition name or
2526 ;; 'string1'string2' or a number > 0, prefix ! negates.
2527 ;; \{ ... \} for multi-line use.
2528 ;; Leaves point at start of new text.
2529 (woman-delete-match 0)
2530 ;; (delete-horizontal-space)
2531 ;; Process escapes in condition:
2532 (let ((from (point)) negated n (c 0))
2533 (set-marker woman0-if-to
2534 (save-excursion (skip-syntax-forward "^ ") (point)))
2535 ;; Process condition:
2536 (if (setq negated (= (following-char) ?!)) (delete-char 1))
2537 (cond
2538 ;; ((looking-at "[no]") (setq c t)) ; accept n(roff) and o(dd page)
2539 ;; ((looking-at "[te]") (setq c nil)) ; reject t(roff) and e(ven page)
2540 ;; Per groff ".if v" is recognized as false (it means -Tversatec).
2541 ((looking-at "[ntoev]")
2542 (setq c (memq (following-char) woman-if-conditions-true)))
2543 ;; Unrecognized letter so reject:
2544 ((looking-at "[A-Za-z]") (setq c nil)
2545 (WoMan-warn "%s %s -- unrecognized condition name rejected!"
2546 request (match-string 0)))
2547 ;; Accept strings if identical:
2548 ((save-restriction
2549 (narrow-to-region from woman0-if-to)
2550 ;; String delimiter can be any non-numeric character,
2551 ;; including a special character escape:
2552 (looking-at "\\(\\\\(..\\|[^0-9]\\)\\(.*\\)\\1\\(.*\\)\\1\\'"))
2553 (let ((end1 (copy-marker (match-end 2) t))) ; End of first string.
2554 ;; Delete 2nd and 3rd delimiters to avoid processing them:
2555 (delete-region (match-end 3) woman0-if-to)
2556 (delete-region (match-end 2) (match-beginning 3))
2557 (goto-char (match-end 1))
2558 (woman0-process-escapes (point) woman0-if-to)
2559 (setq c (string= (buffer-substring (point) end1)
2560 (buffer-substring end1 woman0-if-to)))
2561 (set-marker end1 nil)
2562 (goto-char from)))
2563 ;; Accept numeric value if > 0:
2564 ((numberp (setq n (progn
2565 (woman0-process-escapes from woman0-if-to)
2566 (woman-parse-numeric-arg))))
2567 (setq c (> n 0))
2568 (goto-char from)))
2569 (if (eq c 0)
2570 (woman-if-ignore woman0-if-to request) ; ERROR!
2571 (woman-if-body request woman0-if-to (eq c negated)))))
2573 ;; request is not used dynamically by any callees.
2574 (defun woman-if-body (request to delete) ; should be reversed as `accept'?
2575 "Process if-body, including \\{ ... \\}.
2576 REQUEST is the invoking directive without the leading dot.
2577 If TO is non-nil then delete the if-body.
2578 If DELETE is non-nil then delete from point."
2579 ;; Assume concealed newlines already processed.
2580 (let ((from (point)))
2581 (if to (delete-region (point) to))
2582 (delete-horizontal-space)
2583 (cond (;;(looking-at "[^{\n]*\\\\{\\s *") ; multi-line
2584 ;; allow escaped newlines:
2585 (looking-at "[^{\n]*\\(\\\\\n\\)*\\\\{\\s *\\(\\\\\n\\)*") ; multi-line
2586 ;; including preceding .if(s) and following newline
2587 (let ((from (point)))
2588 (woman-delete-match 0)
2589 ;; Allow for nested \{ ... \} -- BUT BEWARE that this
2590 ;; algorithm only supports one level of nesting!
2591 (while
2592 (and (re-search-forward
2593 ;; "\\(\\\\{\\)\\|\\(\n[.']\\)?[ \t]*\\\\}[ \t]*"
2594 ;; Interpret bogus `el \}' as `el \{',
2595 ;; especially for Tcl/Tk man pages:
2596 "\\(\\\\{\\|el[ \t]*\\\\}\\)\\|\\(\n[.']\\)?[ \t]*\\\\}[ \t]*")
2597 (match-beginning 1))
2598 (re-search-forward "\\\\}"))
2599 (delete-region (if delete from (match-beginning 0)) (point))
2600 (if (looking-at "^$") (delete-char 1))
2602 (delete (woman-delete-line 1))) ; single-line
2603 ;; Process matching .el anything:
2604 (cond ((string= request "ie")
2605 ;; Discard unless previous .ie c `evaluated to false'.
2606 ;; IIUC, an .ie must be followed by an .el.
2607 ;; (An if with no else uses .if rather than .ie.)
2608 ;; TODO warn if no .el found?
2609 ;; The .el should come immediately after the .ie (modulo
2610 ;; comments etc), but this searches to eob.
2611 (cond ((re-search-forward "^[.'][ \t]*el[ \t]*" nil t)
2612 (woman-delete-match 0)
2613 (woman-if-body "el" nil (not delete)))))
2614 ;;; FIXME neither the comment nor the code here make sense to me.
2615 ;;; This branch was executed for an else (any else, AFAICS).
2616 ;;; At this point, the else in question has already been processed above.
2617 ;;; The re-search will find the _next_ else, if there is one, and
2618 ;;; delete it. If there is one, it belongs to another if block. (Bug#9447)
2619 ;;; woman0-el does not need this bit either.
2620 ;; Got here after processing a single-line `.ie' as a body
2621 ;; clause to be discarded:
2622 ;;; ((string= request "el")
2623 ;;; (cond ((re-search-forward "^[.'][ \t]*el[ \t]*" nil t)
2624 ;;; (woman-delete-match 0)
2625 ;;; (woman-if-body "el" nil t)))))
2627 (goto-char from)))
2629 (defun woman0-el ()
2630 "Isolated .el request -- should not happen!"
2631 (WoMan-warn "el request without matching `ie' rejected!")
2632 (cond (woman-ignore
2633 (woman-delete-match 0)
2634 (delete-horizontal-space)
2635 (woman-if-body "el" nil t))
2636 (t ; Ignore -- leave in buffer
2637 ;; This does not work too well, but it's only for debugging!
2638 (skip-chars-forward "^ \t")
2639 (if (looking-at "[ \t]*\\{") (search-forward "\\}"))
2640 (forward-line 1))))
2642 ;; request is not used dynamically by any callees.
2643 (defun woman-if-ignore (to request)
2644 "Ignore but warn about an if request ending at TO, named REQUEST."
2645 (WoMan-warn-ignored request "ignored -- condition not handled!")
2646 (if woman-ignore
2647 (woman-if-body request to t)
2648 ;; Ignore -- leave in buffer
2649 ;; This does not work too well, but it's only for debugging!
2650 (skip-chars-forward "^ \t")
2651 (if (looking-at "[ \t]*\\{") (search-forward "\\}"))
2652 (forward-line 1)))
2654 (defun woman0-so ()
2655 ".so filename -- Switch source file. `.so' requests may be nested."
2656 ;; Leaves point at start of new text.
2657 ;; (skip-chars-forward " \t")
2658 (let* ((beg (point))
2659 (end (progn (woman-forward-arg 'unquote) (point)))
2660 (name (buffer-substring beg end))
2661 (filename name))
2662 ;; If the specified file does not exist in this ...
2663 (or (file-exists-p filename)
2664 ;; or the parent directory ...
2665 (file-exists-p
2666 (setq filename (concat "../" name)))
2667 ;; then use the WoMan search mechanism to find the filename ...
2668 (setq filename
2669 (woman-file-name
2670 (file-name-base name)))
2671 ;; Cannot find the file, so ...
2672 (kill-buffer (current-buffer))
2673 (error "File `%s' not found" name))
2674 (beginning-of-line)
2675 (woman-delete-line 1)
2676 (let* ((from (point))
2677 (length (woman-insert-file-contents filename 0))
2678 (to (copy-marker (+ from length) t)))
2679 (woman-pre-process-region from to)
2680 (set-marker to nil)
2681 (goto-char from))))
2684 ;;; Process macro definitions:
2686 (defun woman0-rn ()
2687 "Process .rn xx yy -- rename macro xx to yy."
2688 ;; For now, done backwards AFTER all macro expansion.
2689 ;; Should also allow requests and strings to be renamed!
2690 (if (eolp) ; ignore if no argument
2692 (let* ((beg (point))
2693 (end (progn (woman-forward-arg 'unquote 'concat) (point)))
2694 (old (buffer-substring beg end))
2695 new)
2696 (if (eolp) ; ignore if no argument
2698 (setq beg (point)
2699 end (progn (woman-forward-arg 'unquote) (point))
2700 new (buffer-substring beg end)
2701 woman0-rename-alist (cons (cons new old) woman0-rename-alist)))))
2702 (woman-delete-whole-line))
2704 (defun woman0-rename ()
2705 "Effect renaming required by .rn requests."
2706 ;; For now, do this backwards AFTER all macro expansion.
2707 (dolist (new woman0-rename-alist)
2708 (let ((old (cdr new))
2709 (new (car new)))
2710 (goto-char (point-min))
2711 (setq new (concat "^[.'][ \t]*" (regexp-quote new)))
2712 (setq old (concat "." old))
2713 (while (re-search-forward new nil t)
2714 (replace-match old nil t)))))
2716 (defconst woman-unescape-regex
2717 (concat woman-escaped-escape-string
2718 "\\(" woman-escaped-escape-string "\\)?"))
2720 (defsubst woman-unescape (macro)
2721 "Replace escape sequences in the body of MACRO.
2722 Replaces || by |, but | by \\, where | denotes the internal escape."
2723 (let (start)
2724 (while (setq start (string-match woman-unescape-regex macro start))
2725 (setq macro
2726 (if (match-beginning 1)
2727 (replace-match "" t t macro 1)
2728 (replace-match "\\" t t macro))
2729 start (1+ start)))
2730 macro))
2732 (defun woman0-de (&optional append)
2733 "Process .de/am xx yy -- (re)define/append macro xx; end at `..'.
2734 \(Should be up to call of yy, which defaults to `.')
2735 Optional argument APPEND, if non-nil, means append macro."
2736 ;; Modeled on woman-strings. BEWARE: Processing of .am is a hack!
2737 ;; Add support for .rm?
2738 ;; (skip-chars-forward " \t")
2739 (if (eolp) ; ignore if no argument
2741 (looking-at "[^ \t\n]+") ; macro name
2742 (let* ((macro (match-string 0)) from
2743 (previous (assoc macro woman0-macro-alist)))
2744 (if (not previous)
2745 (setq woman0-search-regex-start
2746 (concat woman0-search-regex-start "\\|" (regexp-quote macro))
2747 woman0-search-regex
2748 (concat woman0-search-regex-start woman0-search-regex-end)
2750 ;; Macro body runs from start of next line to line
2751 ;; beginning with `..'."
2752 ;; The terminal request MUST begin with `.' (not ')!
2753 (forward-line)
2754 (setq from (point))
2755 (re-search-forward "^\\.[ \t]*\\.")
2756 (beginning-of-line)
2757 (let ((body (woman-unescape (buffer-substring from (point)))))
2758 (if (and append previous)
2759 (setq previous (cdr previous)
2760 body (concat body (cdr previous))
2761 append (car previous)
2763 (setq macro (cons macro (cons append body))))
2764 ;; This should be an update, but consing a new string
2765 ;; onto the front of the alist has the same effect:
2766 (setq woman0-macro-alist (cons macro woman0-macro-alist))
2767 (forward-line)
2768 (delete-region from (point))
2769 (backward-char))) ; return to end of .de/am line
2770 (beginning-of-line) ; delete .de/am line
2771 (woman-delete-line 1))
2773 ;; request may be used dynamically (woman-interpolate-macro calls
2774 ;; woman-forward-arg).
2775 (defun woman0-macro (woman-request)
2776 "Process the macro call named WOMAN-REQUEST."
2777 ;; Leaves point at start of new text.
2778 (let ((macro (assoc woman-request woman0-macro-alist)))
2779 (if macro
2780 (woman-interpolate-macro (cdr macro))
2781 ;; SHOULD DELETE THE UNINTERPRETED REQUEST!!!!!
2782 ;; Output this message once only per call (cf. strings)?
2783 (WoMan-warn "Undefined macro %s not interpolated!" woman-request))))
2785 (defun woman-interpolate-macro (macro)
2786 "Interpolate (.de) or append (.am) expansion of MACRO into the buffer."
2787 ;; Could make this more efficient by checking which arguments are
2788 ;; actually used in the expansion!
2789 (skip-chars-forward " \t")
2790 ;; Process arguments:
2791 (let ((argno 0) (append (car macro))
2792 argno-string formal-arg from actual-arg start)
2793 (setq macro (cdr macro))
2794 (while (not (eolp))
2795 ;; Get next actual arg:
2796 (setq argno (1+ argno))
2797 (setq argno-string (format "%d" argno))
2798 (setq formal-arg (concat "\\\\\\$" argno-string)) ; regexp
2799 (setq from (point))
2800 (woman-forward-arg 'unquote 'noskip)
2801 (setq actual-arg (buffer-substring from (point)))
2802 (skip-chars-forward " \t") ; now skip following whitespace!
2803 ;; Replace formal arg with actual arg:
2804 (setq start nil)
2805 (while (setq start (string-match formal-arg macro start))
2806 (setq macro (replace-match actual-arg t t macro))))
2807 ;; Delete any remaining formal arguments:
2808 (setq start nil)
2809 (while
2810 (setq start (string-match "\\\\\\$." macro start))
2811 (setq macro (replace-match "" t t macro)))
2812 ;; Replace .$ number register with actual arg:
2813 ;; (Do this properly via register mechanism later!)
2814 (setq start nil)
2815 (while
2816 (setq start (string-match "\\\\n(\\.\\$" macro start)) ; regexp
2817 (setq macro (replace-match argno-string t t macro)))
2818 (if append
2819 (forward-char)
2820 (beginning-of-line)
2821 (woman-delete-line 1))
2822 (save-excursion ; leave point at start of new text
2823 (insert macro))))
2826 ;;; Process strings:
2828 (defun woman-match-name ()
2829 "Match and move over name of form: x, (xx or [xxx...].
2830 Applies to number registers, fonts, strings/macros/diversions, and
2831 special characters."
2832 (cond ((= (following-char) ?\[ )
2833 (forward-char)
2834 (re-search-forward "[^]]+")
2835 (forward-char)) ; skip closing ]
2836 ((= (following-char) ?\( )
2837 (forward-char)
2838 (re-search-forward ".."))
2839 (t (re-search-forward "."))))
2841 (defun woman-strings (&optional to)
2842 "Process ?roff string requests and escape sequences up to buffer position TO.
2843 Strings are defined/updated by `.ds xx string' requests and
2844 interpolated by `\\*x' and `\\*(xx' escapes."
2845 ;; Add support for .as and .rm?
2846 (while
2847 ;; Find .ds requests and \* escapes:
2848 (re-search-forward "\\(^[.'][ \t]*ds\\)\\|\\\\\\*" to t)
2849 (cond ((match-beginning 1) ; .ds
2850 (skip-chars-forward " \t")
2851 (if (eolp) ; ignore if no argument
2853 (re-search-forward "[^ \t\n]+")
2854 (let ((string (match-string 0)))
2855 (skip-chars-forward " \t")
2856 (if (= ?\" (following-char))
2857 ;; Double-quote starts a string, eg.
2858 ;; .ds foo "blah...
2859 ;; is value blah... through to newline. There's no
2860 ;; closing " (per the groff manual), but rather any
2861 ;; further " is included literally in the string. Eg.
2862 ;; .ds foo ""
2863 ;; sets foo to a single " character.
2864 (forward-char))
2865 (setq string (cons string
2866 (buffer-substring (point)
2867 (line-end-position))))
2868 ;; This should be an update, but consing a new string
2869 ;; onto the front of the alist has the same effect:
2870 (setq woman-string-alist (cons string woman-string-alist))
2872 (beginning-of-line)
2873 (woman-delete-line 1))
2874 (t ; \*
2875 (let ((beg (match-beginning 0)))
2876 (woman-match-name)
2877 (let* ((stringname (match-string 0))
2878 (string (assoc stringname woman-string-alist)))
2879 (cond (string
2880 (delete-region beg (point))
2881 ;; Temporary hack in case string starts with a
2882 ;; control character:
2883 (if (bolp) (insert-before-markers "\\&"))
2884 (insert-before-markers (cdr string)))
2886 (WoMan-warn "Undefined string %s not interpolated!"
2887 stringname)
2888 (cond (woman-ignore
2889 ;; Output above message once only per call
2890 (delete-region beg (point))
2891 (setq woman-string-alist
2892 (cons (cons stringname "")
2893 woman-string-alist))))))))))))
2896 ;;; Process special character escapes \(xx:
2898 (defconst woman-special-characters
2899 ;; To be built heuristically as required!
2900 ;; MUST insert all characters as strings for correct conversion to
2901 ;; multibyte representation!
2902 '(("em" "--" "\276" . t) ; 3/4 Em dash
2903 ("bu" "*" "\267" . t) ; bullet
2904 ("fm" "'") ; foot mark
2905 ("co" "(C)" "\251") ; copyright
2907 ("pl" "+" "+" . t) ; math plus
2908 ("mi" "-" "-" . t) ; math minus
2909 ("**" "*" "*" . t) ; math star
2910 ("aa" "'" "\242" . t) ; acute accent
2911 ("ul" "_") ; underrule
2913 ("*S" "Sigma" "S" . t) ; Sigma
2915 (">=" ">=" "\263" . t) ; >=
2916 ("<=" "<=" "\243" . t) ; <=
2917 ("->" "->" "\256" . t) ; right arrow
2918 ("<-" "<-" "\254" . t) ; left arrow
2919 ("mu" " x " "\264" . t) ; multiply
2920 ("+-" "+/-" "\261" . t) ; plus-minus
2921 ("bv" "|") ; bold vertical
2923 ;; groff etc. extensions:
2924 ;; List these via eg man -Tdvi groff_char > groff_char.dvi.
2925 ("lq" "\"")
2926 ("rq" "\"")
2927 ("aq" "'")
2928 ("ha" "^")
2929 ("ti" "~")
2930 ("oq" "‘") ; u2018
2931 ("cq" "’") ; u2019
2932 ("hy" "‐") ; u2010
2934 "Alist of special character codes with ASCII and extended-font equivalents.
2935 Each alist elements has the form
2936 (input-string ascii-string extended-font-string . use-symbol-font)
2937 where
2938 * `\\(input-string' is the ?roff encoding,
2939 * `ascii-string' is the (multi-character) ASCII simulation,
2940 * `extended-font-string' is the single-character string representing
2941 the character position in the extended 256-character font, and
2942 * `use-symbol-font' is t to indicate use of the symbol font or nil,
2943 i.e. omitted, to indicate use of the default font.
2944 Any element may be nil. Avoid control character codes (0 to \\37, \\180
2945 to \\237) in `extended-font-string' for now, since they can be
2946 displayed only with a modified display table.
2948 Use the WoMan command `woman-display-extended-fonts' or a character
2949 map accessory to help construct this alist.")
2951 (defsubst woman-replace-match (newtext &optional face)
2952 "Replace text matched by last search with NEWTEXT and return t.
2953 Set NEWTEXT in face FACE if specified."
2954 (woman-delete-match 0)
2955 (insert-before-markers newtext)
2956 (if face (put-text-property (1- (point)) (point) 'face 'woman-symbol))
2959 (defun woman-special-characters (to)
2960 "Process special character escapes \\(xx, \\[xxx] up to buffer position TO.
2961 \(This must be done AFTER translation, which may use special characters.)"
2962 (while (re-search-forward "\\\\\\(?:(\\(..\\)\\|\\[\\([[^]]+\\)\\]\\)" to t)
2963 (let* ((name (or (match-string-no-properties 1)
2964 (match-string-no-properties 2)))
2965 (replacement (assoc name woman-special-characters)))
2966 (unless
2967 (and
2968 replacement
2969 (cond ((and (cddr replacement)
2970 (if (nthcdr 3 replacement)
2971 ;; Need symbol font:
2972 (if woman-use-symbol-font
2973 (woman-replace-match (nth 2 replacement)
2974 'woman-symbol))
2975 ;; Need extended font:
2976 (if woman-use-extended-font
2977 (woman-replace-match (nth 2 replacement))))))
2978 ((cadr replacement) ; Use ASCII simulation
2979 (woman-replace-match (cadr replacement)))))
2980 (WoMan-warn (concat "Special character "
2981 (if (match-beginning 1) "\\(%s" "\\[%s]")
2982 " not interpolated!") name)
2983 (if woman-ignore (woman-delete-match 0))))))
2985 (defun woman-display-extended-fonts ()
2986 "Display table of glyphs of graphic characters and their octal codes.
2987 All the octal codes in the ranges [32..127] and [160..255] are displayed
2988 together with the corresponding glyphs from the default and symbol fonts.
2989 Useful for constructing the alist variable `woman-special-characters'."
2990 (interactive)
2991 (with-output-to-temp-buffer "*WoMan Extended Font Map*"
2992 (with-current-buffer standard-output
2993 (let ((i 32))
2994 (while (< i 256)
2995 (insert (format "\\%03o " i) (string i) " " (string i))
2996 (put-text-property (1- (point)) (point)
2997 'face 'woman-symbol)
2998 (insert " ")
2999 (setq i (1+ i))
3000 (when (= i 128) (setq i 160) (insert "\n"))
3001 (if (zerop (% i 8)) (insert "\n")))))
3002 (help-print-return-message)))
3005 ;;; Formatting macros that do not cause a break:
3007 ;; Bound locally by woman[012]-roff-buffer, and also, annoyingly and
3008 ;; confusingly, as a function argument. Use dynamically in
3009 ;; woman-unquote and woman-forward-arg.
3010 (defvar woman-request)
3012 (defun woman-unquote (to)
3013 "Delete any double-quote characters between point and TO.
3014 Leave point at TO (which should be a marker)."
3015 (let (in-quote)
3016 (while (search-forward "\"" to 1)
3017 (if (and in-quote (looking-at "\""))
3018 ;; Repeated double-quote represents single double-quote
3019 (delete-char 1)
3020 (if (or in-quote (looking-at ".*\"")) ; paired
3021 (delete-char -1))
3022 (setq in-quote (not in-quote))
3024 (if in-quote
3025 (WoMan-warn "Unpaired \" in .%s arguments." woman-request))))
3027 (defsubst woman-unquote-args ()
3028 "Delete any double-quote characters up to the end of the line."
3029 (woman-unquote (save-excursion (end-of-line) (point-marker))))
3031 (defvar woman1-unquote) ; bound locally by woman1-roff-buffer
3033 (defun woman1-roff-buffer ()
3034 "Process non-breaking requests."
3035 (let ((case-fold-search t)
3036 woman-request fn woman1-unquote)
3037 (while
3038 ;; Find next control line:
3039 (re-search-forward woman-request-regexp nil t)
3040 (cond
3041 ;; Construct woman function to call:
3042 ((setq fn (intern-soft
3043 (concat "woman1-"
3044 (setq woman-request (match-string 1)))))
3045 (if (get fn 'notfont) ; not a font-change request
3046 (funcall fn)
3047 ;; Delete request or macro name:
3048 (woman-delete-match 0)
3049 ;; If no args then apply to next line else unquote args
3050 ;; (woman1-unquote is used by called function):
3051 (setq woman1-unquote (not (eolp)))
3052 (if (eolp) (delete-char 1))
3053 ; ;; Hide leading control character in unquoted argument:
3054 ; (cond ((memq (following-char) '(?. ?'))
3055 ; (insert "\\&")
3056 ; (beginning-of-line)))
3057 ;; Call the appropriate function:
3058 (funcall fn)
3059 ;; Hide leading control character in quoted argument (only):
3060 (if (and woman1-unquote (memq (following-char) '(?. ?')))
3061 (insert "\\&"))))))))
3063 ;;; Font-changing macros:
3065 (defun woman1-B ()
3066 ".B -- Set words of current line in bold font."
3067 (woman1-B-or-I ".ft B\n"))
3069 (defun woman1-I ()
3070 ".I -- Set words of current line in italic font."
3071 (woman1-B-or-I ".ft I\n"))
3073 (defun woman1-B-or-I (B-or-I)
3074 ".B/I -- Set words of current line in bold/italic font.
3075 B-OR-I is the appropriate complete control line."
3076 ;; Should NOT concatenate the arguments!
3077 (insert B-or-I) ; because it might be a control line
3078 ;; Return to bol to process .SM/.B, .B/.if etc.
3079 ;; or start of first arg to hide leading control char.
3080 (save-excursion
3081 (if woman1-unquote
3082 (woman-unquote-args)
3083 (while (looking-at "^[.']") (forward-line))
3084 (end-of-line)
3085 (delete-horizontal-space))
3086 (insert "\\fR")))
3088 (defun woman1-SM ()
3089 ".SM -- Set the current line in small font, i.e. IGNORE!"
3090 nil)
3092 (defalias 'woman1-SB 'woman1-B)
3093 ;; .SB -- Set the current line in small bold font, i.e. just embolden!
3094 ;; (This is what /usr/local/share/groff/tmac/tmac.an does. The
3095 ;; Linux man.7 is wrong about this!)
3097 (defun woman1-BI ()
3098 ".BI -- Join words of current line alternating bold and italic fonts."
3099 (woman1-alt-fonts (list "\\fB" "\\fI")))
3101 (defun woman1-BR ()
3102 ".BR -- Join words of current line alternating bold and Roman fonts."
3103 (woman1-alt-fonts (list "\\fB" "\\fR")))
3105 (defun woman1-IB ()
3106 ".IB -- Join words of current line alternating italic and bold fonts."
3107 (woman1-alt-fonts (list "\\fI" "\\fB")))
3109 (defun woman1-IR ()
3110 ".IR -- Join words of current line alternating italic and Roman fonts."
3111 (woman1-alt-fonts (list "\\fI" "\\fR")))
3113 (defun woman1-RB ()
3114 ".RB -- Join words of current line alternating Roman and bold fonts."
3115 (woman1-alt-fonts (list "\\fR" "\\fB")))
3117 (defun woman1-RI ()
3118 ".RI -- Join words of current line alternating Roman and italic fonts."
3119 (woman1-alt-fonts (list "\\fR" "\\fI")))
3121 (defun woman1-alt-fonts (fonts)
3122 "Join words using alternating fonts in FONTS, which MUST be a dynamic list."
3123 (nconc fonts fonts) ; circular list!
3124 (insert (car fonts))
3125 ;; Return to start of first arg to hide leading control char:
3126 (save-excursion
3127 (setq fonts (cdr fonts))
3128 ;; woman1-unquote is bound in woman1-roff-buffer.
3129 (woman-forward-arg woman1-unquote 'concat)
3130 (while (not (eolp))
3131 (insert (car fonts))
3132 (setq fonts (cdr fonts))
3133 (woman-forward-arg woman1-unquote 'concat))
3134 (insert "\\fR")))
3136 (defun woman-forward-arg (&optional unquote concat)
3137 "Move forward over one ?roff argument, optionally unquoting and/or joining.
3138 If optional arg UNQUOTE is non-nil then delete any argument quotes.
3139 If optional arg CONCAT is non-nil then join arguments."
3140 (if (eq (following-char) ?\")
3141 (progn
3142 (if unquote (delete-char 1) (forward-char))
3143 (re-search-forward "\"\\|$")
3144 ;; Repeated double-quote represents single double-quote
3145 (while (eq (following-char) ?\") ; paired
3146 (if unquote (delete-char 1) (forward-char))
3147 (re-search-forward "\"\\|$"))
3148 (if (eq (preceding-char) ?\")
3149 (if unquote (delete-char -1))
3150 (WoMan-warn "Unpaired \" in .%s arguments." woman-request)))
3151 ;; (re-search-forward "[^\\\n] \\|$") ; inconsistent
3152 (skip-syntax-forward "^ "))
3153 (cond ((null concat) (skip-chars-forward " \t")) ; don't skip eol!
3154 ((eq concat 'noskip)) ; do not skip following whitespace
3155 (t (woman-delete-following-space))))
3158 ;; The following requests are not explicit font-change requests and
3159 ;; so are flagged `notfont' to turn off automatic request deletion
3160 ;; and further processing.
3162 (put 'woman1-TP 'notfont t)
3163 (defun woman1-TP ()
3164 ".TP -- After tag line, reset font to Roman for paragraph body."
3165 ;; Same for .IP, but forward only 1 line?
3166 (save-excursion
3167 ;; May be an `irrelevant' control line in the way, so ...
3168 (forward-line)
3169 (forward-line (if (looking-at "\\.\\S-+[ \t]*$") 2 1))
3170 ;; May be looking at control line, so ...
3171 (insert ".ft R\n")))
3173 (put 'woman1-ul 'notfont t)
3174 (defun woman1-ul ()
3175 ".ul N -- Underline (italicize) the next N input lines, default N = 1."
3176 (let ((N (if (eolp) 1 (woman-parse-numeric-arg)))) ; woman-get-numeric-arg ?
3177 (woman-delete-whole-line)
3178 (insert ".ft I\n")
3179 (forward-line N)
3180 (insert ".ft R\n")))
3182 ;;; Other non-breaking requests:
3184 ;; Hyphenation
3185 ;; Warnings commented out.
3187 (put 'woman1-nh 'notfont t)
3188 (defun woman1-nh ()
3189 ".nh -- No hyphenation, i.e. IGNORE!"
3190 ;; Must be handled here to avoid breaking!
3191 ;; (WoMan-log-1 ".nh request ignored -- hyphenation not supported!")
3192 (woman-delete-whole-line))
3194 (put 'woman1-hy 'notfont t)
3195 (defun woman1-hy ()
3196 ".hy N -- Set hyphenation mode to N, i.e. IGNORE!"
3197 ;; (WoMan-log-1 ".hy request ignored -- hyphenation not supported!")
3198 (woman-delete-whole-line))
3200 (put 'woman1-hc 'notfont t)
3201 (defun woman1-hc ()
3202 ".hc c -- Set hyphenation character to c, i.e. delete it!"
3203 (let ((c (char-to-string (following-char))))
3204 ;; (WoMan-log
3205 ;; "Hyphenation character %s deleted -- hyphenation not supported!" c)
3206 (woman-delete-whole-line)
3207 (setq c (concat "\\(" c "\\)\\|^[.'][ \t]*hc"))
3208 (save-excursion
3209 (while (and (re-search-forward c nil t)
3210 (match-beginning 1))
3211 (delete-char -1)))))
3213 (put 'woman1-hw 'notfont t)
3214 (defun woman1-hw ()
3215 ".hw words -- Set hyphenation exception words, i.e. IGNORE!"
3216 ;; (WoMan-log-1 ".hw request ignored -- hyphenation not supported!")
3217 (woman-delete-whole-line))
3219 ;;; Other non-breaking requests correctly ignored by nroff:
3221 (put 'woman1-ps 'notfont t)
3222 (defalias 'woman1-ps 'woman-delete-whole-line)
3223 ;; .ps -- Point size -- IGNORE!
3225 (put 'woman1-ss 'notfont t)
3226 (defalias 'woman1-ss 'woman-delete-whole-line)
3227 ;; .ss -- Space-character size -- IGNORE!
3229 (put 'woman1-cs 'notfont t)
3230 (defalias 'woman1-cs 'woman-delete-whole-line)
3231 ;; .cs -- Constant character space (width) mode -- IGNORE!
3233 (put 'woman1-ne 'notfont t)
3234 (defalias 'woman1-ne 'woman-delete-whole-line)
3235 ;; .ne -- Need vertical space -- IGNORE!
3237 (put 'woman1-vs 'notfont t)
3238 (defalias 'woman1-vs 'woman-delete-whole-line)
3239 ;; .vs -- Vertical base line spacing -- IGNORE!
3241 (put 'woman1-bd 'notfont t)
3242 (defalias 'woman1-bd 'woman-delete-whole-line)
3243 ;; .bd -- Embolden font -- IGNORE!
3245 ;;; Non-breaking SunOS-specific macros:
3247 (defun woman1-TX ()
3248 ".TX t p -- Resolve SunOS abbrev t and join to p (usually punctuation)."
3249 (insert "SunOS ")
3250 (woman-forward-arg 'unquote 'concat))
3252 (put 'woman1-IX 'notfont t)
3253 (defalias 'woman1-IX 'woman-delete-whole-line)
3254 ;; .IX -- Index macro, for Sun internal use -- IGNORE!
3257 ;;; Direct font selection:
3259 (defconst woman-font-alist
3260 '(("R" . default)
3261 ("I" . woman-italic)
3262 ("B" . woman-bold)
3263 ("P" . previous)
3264 ("1" . default)
3265 ("2" . woman-italic)
3266 ("3" . woman-bold) ; used in bash.1
3268 "Alist of ?roff font indicators and woman font variables and names.")
3270 (defun woman-change-fonts ()
3271 "Process font changes."
3272 ;; ***** NEEDS REVISING IF IT WORKS OK *****
3273 ;; Paragraph .LP/PP/HP/IP/TP and font .B/.BI etc. macros reset font.
3274 ;; Should .SH/.SS reset font?
3275 ;; Font size setting macros (?) should reset font.
3276 (let ((font-alist woman-font-alist) ; for local updating
3277 (previous-pos (point))
3278 (previous-font 'default)
3279 (current-font 'default))
3280 (while
3281 ;; Find font requests, paragraph macros and font escapes:
3282 (re-search-forward
3283 "^[.'][ \t]*\\(\\(\\ft\\)\\|\\(.P\\)\\)\\|\\(\\\\f\\)" nil 1)
3284 (let (font beg notfont fescape)
3285 ;; Match font indicator and leave point at end of sequence:
3286 (cond ((match-beginning 2)
3287 ;; .ft request found
3288 (setq beg (match-beginning 0))
3289 (skip-chars-forward " \t")
3290 (if (eolp) ; default is previous font
3291 (setq font previous-font)
3292 (looking-at "[^ \t\n]+"))
3293 (forward-line)) ; end of control line and \n
3294 ((match-beginning 3)
3295 ;; Macro that resets font found
3296 (setq font 'default))
3297 ((match-beginning 4)
3298 ;; \f escape found
3299 (setq beg (match-beginning 0)
3300 fescape t)
3301 (woman-match-name))
3302 (t (setq notfont t)))
3303 (unless notfont
3304 ;; Get font name:
3305 (or font
3306 (let ((fontstring (match-string 0)))
3307 (setq font (assoc fontstring font-alist)
3308 ;; NB: font-alist contains VARIABLE NAMES.
3309 font (if font
3310 (cdr font)
3311 (WoMan-warn "Unknown font %s." fontstring)
3312 ;; Output this message once only per call ...
3313 (setq font-alist
3314 (cons (cons fontstring 'woman-unknown)
3315 font-alist))
3316 'woman-unknown)
3318 ;; Delete font control line or escape sequence:
3319 (cond (beg (delete-region beg (point))
3320 (if (eq font 'previous) (setq font previous-font))))
3321 ;; Deal with things like \fB.cvsrc\fR at the start of a line.
3322 ;; After removing the font control codes, this would
3323 ;; otherwise match woman-request-regexp. The "\\&" which is
3324 ;; inserted to prevent this is removed by woman2-process-escapes.
3325 (and fescape
3326 (looking-at woman-request-regexp)
3327 (insert "\\&"))
3328 (woman-set-face previous-pos (point) current-font)
3329 (if beg
3330 ;; Explicit font control
3331 (setq previous-pos (point)
3332 previous-font current-font)
3333 ;; Macro that resets font
3334 ;; (forward-line) ; DOES NOT WORK! but unnecessary?
3335 ;; Must process font changes in any paragraph tag!
3336 (setq previous-pos (point)
3337 previous-font 'default))
3338 (setq current-font font)
3340 ;; Set font after last request up to eob:
3341 (woman-set-face previous-pos (point) current-font)))
3343 (defun woman-set-face (from to face)
3344 "Set the face of the text from FROM to TO to face FACE.
3345 Ignore the default face and underline only word characters."
3346 (or (eq face 'default) ; ignore
3347 (not woman-fontify)
3348 (if (face-underline-p face)
3349 (save-excursion
3350 (let ((face-no-ul (intern (concat (symbol-name face) "-no-ul"))))
3351 (goto-char from)
3352 (while (< (point) to)
3353 (skip-syntax-forward "w" to)
3354 (put-text-property from (point) 'face face)
3355 (setq from (point))
3356 (skip-syntax-forward "^w" to)
3357 (put-text-property from (point) 'face face-no-ul)
3358 (setq from (point))
3360 (put-text-property from to 'face face))))
3363 ;;; Output translation:
3365 ;; This is only set by woman2-tr. It is bound locally in woman2-roff-buffer.
3366 ;; It is also used by woman-translate. woman-translate may be called
3367 ;; outside the scope of woman2-roff-buffer (by experiment). Therefore
3368 ;; this used to be globally bound to nil, to avoid an error. Instead
3369 ;; we can use bound-and-true-p in woman-translate.
3370 (defvar woman-translations)
3371 ;; A list of the form (\"[ace]\" (a . b) (c . d) (e . ?\s)) or nil.
3373 (defun woman-get-next-char ()
3374 "Return and delete next char in buffer, including special chars."
3375 (if ;;(looking-at "\\\\(\\(..\\)")
3376 ;; Match special \(xx and strings \*[xxx], \*(xx, \*x:
3377 (looking-at "\\\\\\((..\\|\\*\\(\\[[^]]+\\]\\|(..\\|.\\)\\)")
3378 (prog1 (match-string 0)
3379 (woman-delete-match 0))
3380 (prog1 (char-to-string (following-char))
3381 (delete-char 1))))
3383 (defun woman2-tr (to)
3384 ".tr abcde -- Translate a -> b, c -> d, ..., e -> space.
3385 Format paragraphs upto TO. Supports special chars.
3386 \(Breaks, but should not.)"
3387 ;; This should be an update, but consing onto the front of the alist
3388 ;; has the same effect and match duplicates should not matter.
3389 ;; Initialize translation data structures:
3390 (let ((matches (car woman-translations))
3391 (alist (cdr woman-translations))
3392 a b)
3393 ;; `matches' must be a string:
3394 (setq matches
3395 (concat (if matches (substring matches 1 -1)) "]"))
3396 ;; Process .tr arguments:
3397 (while (not (eolp)) ; (looking-at "[ \t]*$") ???
3398 (setq a (woman-get-next-char))
3399 (if (eolp)
3400 (setq b " ")
3401 (setq b (woman-get-next-char)))
3402 (setq matches
3403 (if (= (length a) 1)
3404 (concat a matches)
3405 (concat matches "\\|\\" a))
3406 alist (cons (cons a b) alist)))
3407 (delete-char 1) ; no blank line
3408 ;; Rebuild translations list:
3409 (setq matches
3410 (if (= (string-to-char matches) ?\])
3411 (substring matches 3)
3412 (concat "[" matches))
3413 woman-translations (cons matches alist))
3414 ;; Format any following text:
3415 (woman2-format-paragraphs to)))
3417 (defsubst woman-translate (to)
3418 "Translate up to marker TO. Do this last of all transformations."
3419 (if (bound-and-true-p woman-translations)
3420 (let ((matches (car woman-translations))
3421 (alist (cdr woman-translations))
3422 ;; Translations are case-sensitive, eg ".tr ab" does not
3423 ;; affect "A" (bug#6849).
3424 (case-fold-search nil))
3425 (while (re-search-forward matches to t)
3426 ;; Done like this to retain text properties and
3427 ;; support translation of special characters:
3428 (insert-before-markers-and-inherit
3429 (cdr (assoc
3430 (buffer-substring-no-properties
3431 (match-beginning 0) (match-end 0))
3432 alist)))
3433 (woman-delete-match 0)))))
3436 ;;; Registers:
3438 (defvar woman-registers ; these are all read-only
3439 '((".H" 24) (".V" 48) ; resolution in basic units
3440 (".g" 0) ; not groff
3441 ;; (Iff emulating groff need to implement groff italic correction
3442 ;; \/, e.g. for pic.1)
3443 (".i" left-margin) ; current indent
3444 (".j" woman-adjust) ; current adjustment
3445 (".l" fill-column) ; current line length
3446 (".s" 12) ; current point size
3447 (".u" (if woman-nofill 0 1)) ; 1/0 in fill/nofill mode
3448 (".v" 48) ; current vertical line spacing
3450 "Register alist: the key is the register name as a string.
3451 Each element has the form (KEY VALUE . INC) -- inc may be nil.
3452 Also bound locally in `woman2-roff-buffer'.")
3454 (defun woman-mark-horizontal-position ()
3455 "\\kx -- Store current horizontal position in INPUT LINE in register x."
3456 (while (re-search-forward "\\\\k\\(.\\)" nil t)
3457 (goto-char (match-beginning 0))
3458 (setq woman-registers
3459 (cons (list (match-string 1) (current-column))
3460 woman-registers))
3461 (woman-delete-match 0)))
3463 (defsubst woman2-process-escapes-to-eol (&optional numeric)
3464 "Process remaining escape sequences up to eol.
3465 Handle numeric arguments specially if optional argument NUMERIC is non-nil."
3466 (woman2-process-escapes (copy-marker (line-end-position) t) numeric))
3468 (defun woman2-nr (to)
3469 ".nr R +/-N M -- Assign +/-N (wrt to previous value, if any) to register R.
3470 The increment for auto-incrementing is set to M.
3471 Format paragraphs upto TO. (Breaks, but should not!)"
3472 (let* ((name (buffer-substring
3473 (point)
3474 (progn (skip-syntax-forward "^ ") (point))))
3475 (pm (progn ; increment
3476 (skip-chars-forward " \t")
3477 (when (memq (char-after) '(?+ ?-))
3478 (forward-char) (char-before))))
3479 (value (if (eolp) ; no value
3480 nil ; to be interpreted as zero
3481 (woman2-process-escapes-to-eol 'numeric)
3482 (woman-parse-numeric-arg)))
3483 (inc (progn ; auto-increment
3484 (skip-chars-forward " \t")
3485 (if (eolp) ; no value
3486 nil ; to be interpreted as zero ???
3487 (woman-parse-numeric-arg))))
3488 (oldvalue (assoc name woman-registers)))
3489 (when oldvalue
3490 (setq oldvalue (cdr oldvalue)) ; (value . inc)
3491 (unless inc (setq inc (cdr oldvalue))))
3492 (cond ((null value)
3493 (setq value 0) ; correct?
3494 (WoMan-warn "nr %s -- null value assigned as zero!" name))
3495 ((symbolp value)
3496 (setq value (list 'quote value))))
3497 (if pm ; increment old value
3498 (setq oldvalue (if oldvalue (car oldvalue) 0)
3499 value (if (eq pm ?+)
3500 (+ oldvalue value)
3501 (- oldvalue value))))
3502 (setq woman-registers
3503 (cons (cons name (cons value inc)) woman-registers))
3504 (woman-delete-whole-line)
3505 (woman2-format-paragraphs to)))
3508 ;;; Numeric (and "non-text") request arguments:
3510 (defsubst woman-get-numeric-arg ()
3511 "Get the value of a numeric argument at or after point.
3512 The argument can include the width function and scale indicators.
3513 Assumes 10 characters per inch. Does not move point."
3514 (woman2-process-escapes-to-eol 'numeric)
3515 (save-excursion (woman-parse-numeric-arg)))
3517 (defun woman-parse-numeric-arg ()
3518 "Get the value of a numeric expression at or after point.
3519 Unlike `woman-get-numeric-arg', leaves point after the argument.
3520 The expression may be an argument in quotes."
3521 (if (= (following-char) ?\") (forward-char))
3522 ;; Allow leading +/-:
3523 (let ((value (if (looking-at "[+-]") 0 (woman-parse-numeric-value)))
3525 (while (cond
3526 ((looking-at "[+-/*%]") ; arithmetic operators
3527 (forward-char)
3528 (setq op (intern-soft (match-string 0)))
3529 (setq value (funcall op value (woman-parse-numeric-value))))
3530 ((looking-at "[<=>]=?") ; relational operators
3531 (goto-char (match-end 0))
3532 (setq op (intern-soft
3533 (if (string-equal (match-string 0) "==")
3535 (match-string 0))))
3536 (setq value (if (funcall op value (woman-parse-numeric-value))
3537 1 0)))
3538 ((memq (setq op (following-char)) '(?& ?:)) ; Boolean and / or
3539 (forward-char)
3540 (setq value
3541 ;; and / or are special forms, not functions, in ELisp
3542 (if (eq op ?&)
3543 ;; and
3544 (if (> value 0)
3545 (if (> (woman-parse-numeric-value) 0) 1 0)
3546 ;; skip second operand
3547 (prog1 0 (woman-parse-numeric-value)))
3548 ;; or
3549 (if (> value 0)
3550 ;; skip second operand
3551 (prog1 1 (woman-parse-numeric-value))
3552 (if (> (woman-parse-numeric-value) 0) 1 0))
3555 ; (if (looking-at "[ \t\nRC)\"]") ; R, C are tab types
3556 ; ()
3557 ; (WoMan-warn "Unimplemented numerical operator `%c' in %s"
3558 ; (following-char)
3559 ; (buffer-substring
3560 ; (line-beginning-position)
3561 ; (line-end-position)))
3562 ; (skip-syntax-forward "^ "))
3563 value
3566 (defun woman-parse-numeric-value ()
3567 "Get a single numeric value at or after point.
3568 The value can be a number register or width function (which assumes 10
3569 characters per inch) and can include scale indicators. It may be an
3570 expression in parentheses. Leaves point after the value."
3571 ;; Must replace every \' by some different single character first
3572 ;; before calling this function by calling
3573 ;; (woman2-process-escapes-to-eol 'numeric)
3574 (if (eq (following-char) ?\()
3575 ;; Treat parenthesized expression as a single value.
3576 (let (n)
3577 (forward-char)
3578 (setq n (woman-parse-numeric-arg))
3579 (skip-syntax-forward " " (line-end-position))
3580 (if (eq (following-char) ?\))
3581 (forward-char)
3582 (WoMan-warn "Parenthesis confusion in numeric expression!"))
3584 (let ((n (cond ((looking-at "[-+]?[.0-9]+") ; single number
3585 ;; currently needed to set match-end, even though
3586 ;; string-to-number returns 0 if number not parsed.
3587 (string-to-number (match-string 0)))
3588 ((looking-at "\\\\n\\([-+]\\)?\\(?:\
3589 \\[\\([^]]+\\)\\]\\|(\\(..\\)\\|\\(.\\)\\)")
3590 ;; interpolate number register, maybe auto-incremented
3591 (let* ((pm (match-string-no-properties 1))
3592 (name (or (match-string-no-properties 2)
3593 (match-string-no-properties 3)
3594 (match-string-no-properties 4)))
3595 (value (assoc name woman-registers)))
3596 (if value
3597 (let (inc)
3598 (setq value (cdr value) ; (value . inc)
3599 inc (cdr value)
3600 ;; eval internal (.X) registers
3601 ;; stored as lisp variable names:
3602 value (eval (car value)))
3603 (if (and pm inc) ; auto-increment
3604 (setq value
3605 (funcall (intern-soft pm) value inc)
3606 woman-registers
3607 (cons (cons name (cons value inc))
3608 woman-registers)))
3609 value)
3610 (WoMan-warn "Undefined register %s defaulted to 0."
3611 name)
3612 0) ; default to zero
3614 ((re-search-forward
3615 ;; Delimiter can be special char escape \[xxx],
3616 ;; \(xx or single normal char (usually '):
3617 "\\=\\\\w\\(\\\\\\[[^]]+\\]\\|\\\\(..\\|.\\)" nil t)
3618 (let ((from (match-end 0))
3619 (delim (regexp-quote (match-string 1))))
3620 (if (re-search-forward delim nil t)
3621 ;; Return width of string:
3622 (- (match-beginning 0) from)
3623 (WoMan-warn "Width escape delimiter error!")))))))
3624 (if (null n)
3625 ;; ERROR -- should handle this better!
3626 (progn
3627 (WoMan-warn "Numeric/register argument error: %s"
3628 (buffer-substring
3629 (point)
3630 (line-end-position)))
3631 (skip-syntax-forward "^ " (line-end-position))
3633 (goto-char (match-end 0))
3634 ;; Check for scale factor:
3636 (cond
3637 ((looking-at "\\s ") nil) ; stay put!
3638 ((looking-at "[mnuv]")) ; ignore for now
3639 ((looking-at "i") (setq n (* n 10))) ; inch
3640 ((looking-at "c") (setq n (* n 3.9))) ; cm
3641 ((let ((case-fold-search nil))
3642 (looking-at "P"))
3643 (setq n (* n 1.7))) ; Pica
3644 ((looking-at "p") (setq n (* n 0.14))) ; point
3645 ;; NB: May be immediately followed by + or -, etc.,
3646 ;; in which case do nothing and return nil.
3648 (goto-char (match-end 0)))
3649 (if (numberp n) (round n) n)))))
3652 ;;; VERTICAL FORMATTING -- Formatting macros that cause a break:
3654 ;; Vertical spacing philosophy:
3655 ;; Delete all vertical space as it is encountered. Then insert
3656 ;; vertical space only before text, as required.
3658 (defun woman2-roff-buffer ()
3659 "Process breaks. Format paragraphs and headings."
3660 (let ((case-fold-search t)
3661 (to (make-marker))
3662 (canonically-space-region
3663 (symbol-function 'canonically-space-region))
3664 (insert-and-inherit (symbol-function 'insert-and-inherit))
3665 (set-text-properties (symbol-function 'set-text-properties))
3666 (woman-registers woman-registers)
3667 fn woman-request woman-translations
3668 tab-stop-list)
3669 (set-marker-insertion-type to t)
3670 ;; ?roff does not squeeze multiple spaces, but does fill, so...
3671 (fset 'canonically-space-region 'ignore)
3672 ;; Try to avoid spaces inheriting underlines from preceding text!
3673 (fset 'insert-and-inherit (symbol-function 'insert))
3674 (fset 'set-text-properties 'ignore)
3675 (unwind-protect
3676 (while
3677 ;; Find next control line:
3678 (re-search-forward woman-request-regexp nil t)
3679 (cond
3680 ;; Construct woman function to call:
3681 ((setq fn (intern-soft
3682 (concat "woman2-"
3683 (setq woman-request (match-string 1)))))
3684 ;; Delete request or macro name:
3685 (woman-delete-match 0))
3686 ;; Unrecognized request:
3687 ((prog1 nil
3688 ;; (WoMan-warn ".%s request ignored!" woman-request)
3689 (WoMan-warn-ignored woman-request "ignored!")
3690 ;; (setq fn 'woman2-LP)
3691 ;; AVOID LEAVING A BLANK LINE!
3692 ;; (setq fn 'woman2-format-paragraphs)
3694 ;; .LP assumes it is at eol and leaves a (blank) line,
3695 ;; so leave point at end of line before paragraph:
3696 ((or (looking-at "[ \t]*$") ; no argument
3697 woman-ignore) ; ignore all
3698 ;; (beginning-of-line) (kill-line)
3699 ;; AVOID LEAVING A BLANK LINE!
3700 (beginning-of-line) (woman-delete-line 1))
3701 (t (end-of-line) (insert ?\n))
3703 (if (not (or fn
3704 (and (not (memq (following-char) '(?. ?')))
3705 (setq fn 'woman2-format-paragraphs))))
3707 ;; Find next control line:
3708 (if (equal woman-request "TS")
3709 (set-marker to (woman-find-next-control-line "TE"))
3710 (set-marker to (woman-find-next-control-line)))
3711 ;; Call the appropriate function:
3712 (funcall fn to)))
3713 (if (not (eobp)) ; This should not happen, but ...
3714 (woman2-format-paragraphs (copy-marker (point-max) t)
3715 woman-left-margin))
3716 (fset 'canonically-space-region canonically-space-region)
3717 (fset 'set-text-properties set-text-properties)
3718 (fset 'insert-and-inherit insert-and-inherit)
3719 (set-marker to nil))))
3721 (defun woman-find-next-control-line (&optional pat)
3722 "Find and return start of next control line.
3723 PAT, if non-nil, specifies an additional component of the control
3724 line regexp to search for, which is appended to the default
3725 regexp, \"\\(\\\\c\\)?\\n[.\\=']\"."
3726 (let ((pattern (concat "\\(\\\\c\\)?\n[.']" pat))
3728 (save-excursion
3729 ;; Must handle
3730 ;; ...\c
3731 ;; .br (and other requests?)
3732 ;; by deleting both the \c and the following request.
3733 ;; BEWARE THAT THIS CODE MAY BE UNRELIABLE!!!!!
3734 (while
3735 (and
3736 (setq to (re-search-forward pattern nil t))
3737 (match-beginning 1)
3738 (looking-at "br"))
3739 (goto-char (match-beginning 0))
3740 (woman-delete-line 2)))
3741 (if to
3742 (- to (+ 1 (length pat)))
3743 (point-max))))
3745 (defun woman2-PD (to)
3746 ".PD d -- Set the interparagraph distance to d.
3747 Round to whole lines, default 1 line. Format paragraphs upto TO.
3748 \(Breaks, but should not.)"
3749 ;; .ie \\n[.$] .nr PD (v;\\$1)
3750 ;; .el .nr PD .4v>?\n[.V]
3751 (woman-set-interparagraph-distance)
3752 (woman2-format-paragraphs to))
3754 (defun woman-set-interparagraph-distance ()
3755 "Set the interparagraph distance from a .PD request at point."
3756 (setq woman-interparagraph-distance
3757 (if (eolp) 1 (woman-get-numeric-arg)))
3758 ;; Should allow .PD 0 to set zero line spacing
3759 (woman-delete-line 1)) ; ignore remaining args
3761 (defsubst woman-interparagraph-space ()
3762 "Set variable `woman-leave-blank-lines' from `woman-interparagraph-distance'."
3763 (setq woman-leave-blank-lines woman-interparagraph-distance))
3765 (defun woman2-TH (to)
3766 ".TH n c x v m -- Begin a man page. Format paragraphs upto TO.
3767 n is the name of the page in chapter c; x is extra commentary;
3768 v alters page foot left; m alters page head center.
3769 \(Should set prevailing indent and tabs to 5.)"
3770 (woman-forward-arg 'unquote 'concat)
3771 (insert ?\()
3772 (woman-forward-arg 'unquote 'concat)
3773 (insert ?\))
3774 (let ((start (point)) here)
3775 (while (not (eolp))
3776 (cond ((looking-at "\"\"[ \t]")
3777 (delete-char 2)))
3778 (delete-horizontal-space)
3779 (setq here (point))
3780 (insert " -- ")
3781 (woman-forward-arg 'unquote 'concat)
3782 ;; Delete repeated arguments:
3783 (if (string-equal (buffer-substring here (point))
3784 (buffer-substring start here))
3785 (delete-region here (point)))))
3786 ;; Embolden heading (point is at end of heading):
3787 (woman-set-face (line-beginning-position) (point) 'woman-bold)
3788 (forward-line)
3789 (delete-blank-lines)
3790 (setq woman-left-margin woman-default-indent)
3791 (setq woman-prevailing-indent woman-default-indent)
3792 (woman2-format-paragraphs to woman-left-margin))
3794 (defun woman2-SH (to)
3795 ".SH -- Sub-head. Leave blank line and subhead.
3796 Format paragraphs upto TO. Set prevailing indent to 5."
3797 (if (eolp) ; If no args then
3798 (delete-char 1) ; apply to next line
3799 (woman-unquote-args) ; else unquote to end of heading
3800 (beginning-of-line))
3801 (woman2-process-escapes-to-eol)
3802 (woman-leave-blank-lines woman-interparagraph-distance)
3803 (setq woman-leave-blank-lines nil)
3804 ;; Optionally embolden heading (point is at beginning of heading):
3805 (if woman-bold-headings
3806 (woman-set-face (point) (line-end-position) 'woman-bold))
3807 (forward-line)
3808 (setq woman-left-margin woman-default-indent
3809 woman-nofill nil) ; fill output lines
3810 (setq woman-prevailing-indent woman-default-indent)
3811 (woman2-format-paragraphs to woman-left-margin))
3813 (defun woman2-SS (to)
3814 ".SS -- Sub-sub-head. Like .SH but indent heading 3 spaces.
3815 Format paragraphs upto TO."
3816 (if (eolp) ; If no args then
3817 (delete-char 1)) ; apply to next line.
3818 (insert " ")
3819 (beginning-of-line)
3820 (woman2-SH to))
3822 (defun woman2-LP (to)
3823 ".LP,.PP -- Begin paragraph. Set prevailing indent to 5.
3824 Leave 1 blank line. Format paragraphs upto TO."
3825 (woman-delete-line 1) ; ignore any arguments
3826 (woman-interparagraph-space)
3827 (setq woman-prevailing-indent woman-default-indent)
3828 (woman2-format-paragraphs to woman-left-margin))
3830 (defalias 'woman2-PP 'woman2-LP)
3831 (defalias 'woman2-P 'woman2-LP)
3833 (defun woman2-ns (to)
3834 ".ns -- Turn on no-space mode. Format paragraphs upto TO."
3835 ;; Should not cause a break!
3836 (woman-delete-line 1) ; ignore argument(s)
3837 (setq woman-nospace t)
3838 (woman2-format-paragraphs to))
3840 (defun woman2-rs (to)
3841 ".rs -- Turn off no-space mode. Format paragraphs upto TO."
3842 ;; Should not cause a break!
3843 (woman-delete-line 1) ; ignore argument(s)
3844 (setq woman-nospace nil)
3845 (woman2-format-paragraphs to))
3847 (defun woman2-sp (to)
3848 ".sp N -- If N > 0 then leave 1 blank line. Format paragraphs upto TO."
3849 (let ((N (if (eolp) 1 (woman-get-numeric-arg))))
3850 (if (>= N 0)
3851 (woman-delete-line 1) ; ignore argument(s)
3852 (setq woman-negative-vertical-space t)
3853 (insert ".sp ")
3854 (forward-line))
3855 (setq woman-leave-blank-lines N)
3856 (woman2-format-paragraphs to)))
3858 (defun woman-negative-vertical-space (from)
3859 ".sp N with N < 0 => overlap following with preceding lines at FROM."
3860 ;; Run by woman-decode-region if necessary -- not usually required.
3861 (WoMan-warn "Negative vertical spacing support is experimental!")
3862 (goto-char from)
3863 (while
3864 ;; Find next control line:
3865 (re-search-forward "^\\.sp " nil t)
3866 (let ((N (woman-get-numeric-arg))
3867 overlap overwritten)
3868 (woman-delete-whole-line)
3869 (setq from (point)
3870 overlap (buffer-substring from
3871 (progn (forward-line (- N)) (point))))
3872 (delete-region from (point))
3873 (forward-line N)
3874 (let ((imax (length overlap))
3875 (i 0) c)
3876 (while (< i imax)
3877 (setq c (aref overlap i))
3878 (cond ((eq c ?\n) ; skip
3879 (forward-line))
3880 ((eolp) ; extend line
3881 ;; Insert character INCLUDING TEXT PROPERTIES:
3882 ;; (insert (substring overlap i (1+ i)))
3883 (let ((eol (string-match "\n" overlap i)))
3884 (insert (substring overlap i eol))
3885 (setq i (or eol imax)))
3887 ((eq c ?\s) ; skip
3888 (forward-char))
3889 ((eq c ?\t) ; skip
3890 (if (eq (following-char) ?\t)
3891 (forward-char) ; both tabs, just skip
3892 (dotimes (i woman-tab-width)
3893 (if (eolp)
3894 (insert ?\s) ; extend line
3895 (forward-char)) ; skip
3898 (if (or (eq (following-char) ?\s) ; overwrite OK
3899 overwritten) ; warning only once per ".sp -"
3901 (setq overwritten t)
3902 (WoMan-warn
3903 "Character(s) overwritten by negative vertical spacing in line %d"
3904 (count-lines 1 (point))))
3905 (delete-char 1) (insert (substring overlap i (1+ i)))))
3906 (setq i (1+ i)))))))
3909 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
3910 ;; The following function should probably do ALL width and number
3911 ;; register interpolation.
3912 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
3914 (defun woman2-process-escapes (to &optional numeric)
3915 "Process remaining escape sequences up to marker TO, preserving point.
3916 Optional argument NUMERIC, if non-nil, means the argument is numeric."
3917 (cl-assert (and (markerp to) (marker-insertion-type to)))
3918 ;; The first two cases below could be merged (maybe)!
3919 (let ((from (point)))
3920 ;; Discard zero width filler character used to hide leading dots
3921 ;; and zero width characters.
3922 (while (re-search-forward "\\\\[&|^]" to t)
3923 (woman-delete-match 0)
3924 ;; If on a line by itself, consume newline as well (Bug#3651).
3925 ;; But not in a .nf region, preserve all newlines in that case.
3926 (and (not woman-nofill)
3927 (eq (char-before (match-beginning 0)) ?\n)
3928 (eq (char-after (match-beginning 0)) ?\n)
3929 (delete-char 1)))
3931 (goto-char from)
3932 ;; Interrupt text processing -- CONTINUE current text with the
3933 ;; next text line (after any control lines, unless processing to
3934 ;; eol):
3935 (while (re-search-forward "\\\\c.*\n?" to t)
3936 (woman-delete-match 0))
3937 ;; but do not delete the final newline ...
3938 (if (and (or (eobp) (= (point) to)) (not (bolp)))
3939 (insert-before-markers ?\n))
3940 (goto-char from)
3941 (woman-translate to)
3942 (goto-char from)
3943 (woman-special-characters to)
3944 (goto-char from)
3945 ;; Printable version of the current escape character, ASSUMED to be `\'
3946 ;; This must be done LAST of all escape processing!
3947 ;; Done like this to preserve any text properties of the `\'
3948 (while (search-forward "\\" to t)
3949 (let ((c (following-char)))
3950 ;; Some other escapes, such as \f, are handled in
3951 ;; `woman0-process-escapes'.
3952 (cond ((eq c ?') ; \' -> '
3953 (delete-char -1)
3954 (cond (numeric ; except in numeric args, \' -> `
3955 (delete-char 1)
3956 (insert ?`))))
3957 ((eq c ?\( )) ; uninterpreted special character
3958 ; \(.. -- do nothing
3959 ((eq c ?t) ; non-interpreted tab \t
3960 (delete-char 1)
3961 (delete-char -1)
3962 (insert "\t"))
3963 ((and numeric
3964 (memq c '(?w ?n ?h)))) ; leave \w, \n, \h (?????)
3965 ((eq c ?l) (woman-horizontal-line)))))
3966 (goto-char from)
3967 ;; Process non-default tab settings:
3968 (cond (tab-stop-list
3969 (while (search-forward "\t" to t)
3970 (woman-tab-to-tab-stop))
3971 (goto-char from)))
3973 ;; Must replace \' by something before processing \w, done above.
3975 ;; Replace all `\w' and `\n' escapes:
3976 ;; (This may be a bit too recursive!)
3977 (while (re-search-forward "\\\\[nw]" to t)
3978 (let ((from (match-beginning 0)) N)
3979 (goto-char from)
3980 (setq N (woman-parse-numeric-value))
3981 (delete-region from (point))
3982 ;; Interpolate value:
3983 (insert-before-markers (number-to-string N))))
3984 (goto-char from)))
3986 (defun woman-horizontal-line ()
3987 "\\l\\='Nc\\=' -- Draw a horizontal line of length N using character c, default _."
3988 (delete-char -1)
3989 (delete-char 1)
3990 (looking-at "\\(.\\)\\(.*\\)\\1")
3991 (forward-char 1)
3992 (let* ((to (match-end 2))
3993 (from (match-beginning 0))
3994 (N (woman-parse-numeric-arg))
3995 (c (if (< (point) to) (following-char) ?_)))
3996 (delete-region from to)
3997 (delete-char 1)
3998 (insert (make-string N c))))
4000 ;;; 4. Text Filling, Adjusting, and Centering
4002 (defun woman2-br (to)
4003 ".br -- Break. Leave no blank line. Format paragraphs upto TO."
4004 (woman-delete-line 1) ; ignore any arguments
4005 (woman2-format-paragraphs to))
4007 (defun woman2-fi (to)
4008 ".fi -- Fill subsequent output lines. Leave no blank line.
4009 Format paragraphs upto TO."
4010 (setq woman-nofill nil)
4011 (woman-delete-line 1) ; ignore any arguments
4012 ;; Preserve any final blank line in the nofill region:
4013 (save-excursion
4014 (forward-line -1)
4015 (if (looking-at "[ \t]*$") (setq woman-leave-blank-lines 1)))
4016 (woman2-format-paragraphs to))
4018 (defun woman2-nf (to)
4019 ".nf -- Nofill. Subsequent lines are neither filled nor adjusted.
4020 Input text lines are copied directly to output lines without regard
4021 for the current line length. Format paragraphs up to TO."
4022 (setq woman-nofill t)
4023 (woman-delete-line 1) ; ignore any arguments
4024 (woman2-format-paragraphs to))
4026 (defun woman2-ad (to)
4027 ".ad c -- Line adjustment is begun (once fill mode is on).
4028 Set justification mode to c if specified.
4029 Format paragraphs upto TO. (Breaks, but should not.)"
4030 ;; c = l -- left, r -- right, c -- center, b or n -- both,
4031 ;; absent -- unchanged. Initial mode adj,both.
4032 (setq woman-adjust
4033 (cond ((eolp) woman-adjust-previous)
4034 ((eq (following-char) ?l) woman-adjust-left)
4035 ((eq (following-char) ?r) woman-adjust-right)
4036 ((eq (following-char) ?c) woman-adjust-center)
4037 ((memq (following-char) '(?b ?n)) woman-adjust-both)
4038 (t (woman-get-numeric-arg))
4040 woman-justify (nth woman-adjust woman-justify-list))
4041 (woman-delete-line 1) ; ignore any remaining arguments
4042 (woman2-format-paragraphs to))
4044 (defun woman2-na (to)
4045 ".na -- No adjusting. Format paragraphs upto TO.
4046 \(Breaks, but should not.)"
4047 (setq woman-adjust-previous woman-adjust
4048 woman-justify-previous woman-justify
4049 woman-adjust woman-adjust-left ; fill but do not adjust
4050 woman-justify (nth woman-adjust woman-justify-list))
4051 (woman-delete-line 1) ; ignore any arguments
4052 (woman2-format-paragraphs to))
4054 ;;; The main formatting functions:
4056 (defun woman-leave-blank-lines (&optional leave)
4057 "Delete all blank lines around point.
4058 Leave one blank line if optional argument LEAVE is non-nil and
4059 non-zero, or if LEAVE is nil and variable `woman-leave-blank-lines' is
4060 non-nil and non-zero."
4061 ;; ***** It may suffice to delete only lines ABOVE point! *****
4062 ;; NOTE: Function arguments are evaluated left to right
4063 ;; (*note (elisp)Function Forms::.).
4064 (delete-region
4065 (save-excursion
4066 (if (not (eq (skip-syntax-backward " ") 0))
4067 (forward-line)) ; forward-char ?
4068 (point))
4069 (progn (skip-syntax-forward " ")
4070 (beginning-of-line)
4071 (point)))
4072 (unless woman-nospace
4073 (if (or (null leave) (eq leave 0))
4074 ;; output any `pending' vertical space ...
4075 (setq leave woman-leave-blank-lines))
4076 (if (and leave (> leave 0)) (insert-before-markers ?\n)))
4077 (setq woman-leave-blank-lines nil))
4079 ;; `fill-region-as-paragraph' in `fill.el' appears to be the principal
4080 ;; text filling function, so that is what I use here.
4082 (defvar woman-temp-indent nil)
4084 (defun woman2-format-paragraphs (to &optional new-left)
4085 "Indent, fill and adjust paragraphs upto TO to current left margin.
4086 If optional arg NEW-LEFT is non-nil then reset current left margin.
4087 If `woman-nofill' is non-nil then indent without filling or adjusting."
4088 ;; Blank space should only ever be output before text.
4089 (if new-left (setq left-margin new-left))
4090 (if (looking-at "^\\s *$")
4091 ;; A blank line should leave a space like .sp 1 (p. 14).
4092 (setq woman-leave-blank-lines 1))
4093 (skip-syntax-forward " ")
4094 ;; Successive control lines are sufficiently common to be worth a
4095 ;; special case (maybe):
4096 (unless (>= (point) to)
4097 (woman-reset-nospace)
4098 (woman2-process-escapes to 'numeric)
4099 (if woman-nofill
4100 ;; Indent without filling or adjusting ...
4101 (progn
4102 (woman-leave-blank-lines)
4103 (when woman-temp-indent
4104 (indent-to woman-temp-indent)
4105 (forward-line))
4106 (indent-rigidly (point) to left-margin)
4107 (woman-horizontal-escapes to))
4108 ;; Fill and justify ...
4109 ;; Blank lines and initial spaces cause a break.
4110 (while (< (point) to)
4111 (woman-leave-blank-lines)
4112 (let ((from (point)))
4113 ;; Indent first lin of paragraph:
4114 (indent-to (or woman-temp-indent left-margin))
4115 (woman-horizontal-escapes to) ; 7 October 1999
4116 ;; Find the beginning of the next paragraph:
4117 (forward-line)
4118 (and (re-search-forward "\\(^\\s *$\\)\\|\\(^\\s +\\)" to 1)
4119 ;; A blank line should leave a space like .sp 1 (p. 14).
4120 (eolp)
4121 (skip-syntax-forward " ")
4122 (setq woman-leave-blank-lines 1))
4123 ;; This shouldn't happen, but in case it does (e.g. for
4124 ;; badly-formatted manfiles with no terminating newline),
4125 ;; avoid an infinite loop.
4126 (unless (and (eolp) (eobp))
4127 (beginning-of-line))
4128 ;; If a single short line then just leave it.
4129 ;; This is necessary to preserve some table layouts.
4130 ;; PROBABLY NOT NECESSARY WITH SQUEEZE MODIFICATION !!!!!
4131 (when (or (> (count-lines from (point)) 1)
4132 (save-excursion
4133 (backward-char)
4134 (> (current-column) fill-column)))
4135 ;; NOSQUEEZE has no effect if JUSTIFY is full, so redefine
4136 ;; canonically-space-region, see above.
4137 (if (and woman-temp-indent (< woman-temp-indent left-margin))
4138 (let ((left-margin woman-temp-indent))
4139 (fill-region-as-paragraph from (point) woman-justify)
4140 (save-excursion
4141 (goto-char from)
4142 (forward-line)
4143 (setq from (point)))))
4144 (fill-region-as-paragraph from (point) woman-justify)))))
4145 (setq woman-temp-indent nil)))
4148 ;;; Tagged, indented and hanging paragraphs:
4150 (defun woman2-TP (to)
4151 ".TP i -- Set prevailing indent to i. Format paragraphs upto TO.
4152 Begin indented paragraph with hanging tag given by next text line.
4153 If tag doesn't fit, place it on a separate line."
4154 (let ((i (woman2-get-prevailing-indent)))
4155 (woman-leave-blank-lines woman-interparagraph-distance)
4156 (woman2-tagged-paragraph to i)))
4158 (defun woman2-IP (to)
4159 ".IP x i -- Same as .TP with tag x. Format paragraphs upto TO."
4160 (woman-interparagraph-space)
4161 (if (eolp) ; no args
4162 ;; Like LP without resetting prevailing indent
4163 (woman2-format-paragraphs to (+ woman-left-margin
4164 woman-prevailing-indent))
4165 (woman-forward-arg 'unquote)
4166 (let ((i (woman2-get-prevailing-indent 'leave-eol)))
4167 (beginning-of-line)
4168 (woman-leave-blank-lines) ; must be here,
4170 ;; The cvs.1 manpage contains some (possibly buggy) syntax that
4171 ;; confuses woman, although the man program displays it ok.
4172 ;; Most problems are caused by IP followed by another request on
4173 ;; the next line. Without the following hack, the second request
4174 ;; gets displayed raw in the output. Note that
4175 ;; woman2-tagged-paragraph also contains a hack for similar
4176 ;; issues (eg IP followed by SP).
4178 ;; i) For IP followed by one or more IPs, we ignore all but the
4179 ;; last (mimic man). The hack in w-t-p would only work for two
4180 ;; consecutive IPs, and would use the first.
4181 ;; ii) For IP followed by SP followed by one or more requests,
4182 ;; do nothing. At least in cvs.1, there is usually another IP in
4183 ;; there somewhere.
4184 (unless (or (looking-at "^\\.IP")
4185 (and (looking-at "^\\.sp")
4186 (save-excursion
4187 (and (zerop (forward-line 1))
4188 (looking-at woman-request-regexp)))))
4189 (woman2-tagged-paragraph to i)))))
4191 (defun woman-find-next-control-line-carefully ()
4192 "Find and return start of next control line, even if already there!"
4193 (if (looking-at "^[.']")
4194 (point)
4195 (woman-find-next-control-line)))
4197 (defun woman2-tagged-paragraph (to i)
4198 "Begin indented paragraph with hanging tag given by current text line.
4199 If tag doesn't fit, leave it on separate line.
4200 Format paragraphs upto TO. Set prevailing indent to I."
4201 (if (not (looking-at "\\s *$")) ; non-empty tag
4202 (setq woman-leave-blank-lines nil))
4204 ;; Temporary hack for bash.1, cvs.1 and groff_mmse.7 until code is revised
4205 ;; to process all requests uniformly.
4206 ;; This hack deals with IP requests followed by other requests (eg
4207 ;; SP) on the very next line. We skip over the SP, otherwise it gets
4208 ;; inserted raw in the rendered output.
4209 (cond ((and (= (point) to)
4210 (looking-at "^[.'][ \t]*\\(PD\\|br\\|ta\\|sp\\) *"))
4211 (if (member (match-string 1) '("br" "sp"))
4212 (woman-delete-line 1)
4213 (woman-delete-match 0)
4214 (if (string= (match-string 1) "ta") ; for GetInt.3
4215 (woman2-ta to)
4216 (woman-set-interparagraph-distance)))
4217 (set-marker to (woman-find-next-control-line-carefully))))
4219 (let ((tag (point)))
4220 (woman-reset-nospace)
4221 ;; Format the tag:
4222 (woman2-process-escapes-to-eol)
4223 ;; TIDY UP THE FOLLOWING CODE
4224 ;; (indent-to woman-left-margin)
4225 (setq left-margin woman-left-margin)
4226 (forward-line)
4227 (fill-region-as-paragraph (save-excursion (forward-line -1) (point))
4228 (point) woman-justify)
4230 ;; Temporary hack for bash.1 until all requests processed uniformly:
4231 (cond ((and (= (point) to) (looking-at "^[.'][ \t]*PD *"))
4232 (woman-delete-match 0)
4233 (woman-set-interparagraph-distance)
4234 (set-marker to (woman-find-next-control-line-carefully))
4237 ;; Format the paragraph body, if there is one! Set indented left
4238 ;; margin anyway, because the paragraph body may begin with a
4239 ;; control line:
4240 (setq left-margin (+ woman-left-margin i))
4241 (cond ((< (point) to)
4242 (woman2-format-paragraphs to)
4243 (goto-char tag) (end-of-line)
4244 (cond ((> (setq i (- left-margin (current-column))) 0)
4245 (delete-char 1)
4246 (delete-horizontal-space)
4247 ;; Necessary to avoid spaces inheriting underlines.
4248 ;; Cannot simply delete (current-column) whitespace
4249 ;; characters because some may be tabs!
4250 (insert-char ?\s i)))
4251 (goto-char to)))))
4253 (defun woman2-HP (to)
4254 ".HP i -- Set prevailing indent to i. Format paragraphs upto TO.
4255 Begin paragraph with hanging indent."
4256 (let ((i (woman2-get-prevailing-indent)))
4257 (woman-interparagraph-space)
4258 (setq woman-temp-indent woman-left-margin)
4259 (woman2-format-paragraphs to (+ woman-left-margin i))))
4261 (defun woman2-get-prevailing-indent (&optional leave-eol)
4262 "Set prevailing indent to integer argument at point, and return it.
4263 If no argument then return the existing prevailing indent.
4264 Delete line from point and eol unless LEAVE-EOL is non-nil."
4265 (if (eolp)
4266 (or leave-eol (delete-char 1))
4267 (let ((i (woman-get-numeric-arg)))
4268 (woman-delete-line) (or leave-eol (delete-char 1))
4269 ;; i = 0 if the argument was not a number
4270 ;; FIXME should this be >= 0? How else to reset to 0 indent?
4271 (if (> i 0) (setq woman-prevailing-indent i))))
4272 woman-prevailing-indent)
4274 (defmacro woman-push (value stack)
4275 "Push VALUE onto STACK."
4276 `(setq ,stack (cons ,value ,stack)))
4278 (defmacro woman-pop (variable stack)
4279 "Pop into VARIABLE the value at the top of STACK.
4280 Allow for mismatched requests!"
4281 `(if ,stack
4282 (setq ,variable (car ,stack)
4283 ,stack (cdr ,stack))))
4285 (defun woman2-RS (to)
4286 ".RS i -- Start relative indent, move left margin in distance i.
4287 Set prevailing indent to 5 for nested indents. Format paragraphs upto TO."
4288 (woman-push woman-left-margin woman-RS-left-margin)
4289 (woman-push woman-prevailing-indent woman-RS-prevailing-indent)
4290 (setq woman-left-margin (+ woman-left-margin
4291 (woman2-get-prevailing-indent))
4292 woman-prevailing-indent woman-default-indent)
4293 (woman2-format-paragraphs to woman-left-margin))
4295 (defun woman2-RE (to)
4296 ".RE -- End of relative indent. Format paragraphs upto TO.
4297 Set prevailing indent to amount of starting .RS."
4298 (woman-pop woman-left-margin woman-RS-left-margin)
4299 (woman-pop woman-prevailing-indent woman-RS-prevailing-indent)
4300 (woman-delete-line 1) ; ignore any arguments
4301 (woman2-format-paragraphs to woman-left-margin))
4304 ;;; Line Length and Indenting:
4306 (defun woman-set-arg (arg &optional previous)
4307 "Reset, increment or decrement argument ARG, which must be quoted.
4308 If no argument then use value of optional arg PREVIOUS if non-nil,
4309 otherwise set PREVIOUS. Delete the whole remaining control line."
4310 (if (eolp) ; space already skipped
4311 (set arg (if previous (eval previous) 0))
4312 (if previous (set previous (eval arg)))
4313 (woman2-process-escapes-to-eol 'numeric)
4314 (let ((pm (if (looking-at "[+-]")
4315 (prog1 (following-char)
4316 (forward-char 1))))
4317 (i (woman-parse-numeric-arg)))
4318 (cond ((null pm) (set arg i))
4319 ((= pm ?+) (set arg (+ (eval arg) i)))
4320 ((= pm ?-) (set arg (- (eval arg) i)))
4322 (beginning-of-line))
4323 (woman-delete-line 1)) ; ignore any remaining arguments
4325 ;; NEED TO RATIONALIZE NAMES FOR PREVIOUS VALUES!
4326 (defvar woman-ll-fill-column woman-fill-column)
4327 (defvar woman-in-left-margin woman-left-margin)
4329 (defun woman2-ll (to)
4330 ".ll +/-N -- Set, increment or decrement line length.
4331 Format paragraphs upto TO. (Breaks, but should not.)"
4332 (woman-set-arg 'fill-column 'woman-ll-fill-column)
4333 (woman2-format-paragraphs to))
4335 (defun woman2-in (to)
4336 ".in +/-N -- Set, increment or decrement the indent.
4337 Format paragraphs upto TO."
4338 (woman-set-arg 'left-margin 'woman-in-left-margin)
4339 (woman2-format-paragraphs to))
4341 (defun woman2-ti (to)
4342 ".ti +/-N -- Temporary indent. Format paragraphs upto TO."
4343 ;; Ignore if no argument.
4344 ;; Indent next output line only wrt current indent.
4345 ;; Current indent is not changed.
4346 (setq woman-temp-indent left-margin)
4347 (woman-set-arg 'woman-temp-indent)
4348 (woman2-format-paragraphs to nil))
4351 ;;; Tabs, Leaders, and Fields:
4353 (defun woman2-ta (to)
4354 ".ta Nt ... -- Set tabs, left type, unless t=R(right), C(centered).
4355 \(Breaks, but should not.) The tab stops are separated by spaces;
4356 a value preceded by + represents an increment to the previous stop value.
4357 Format paragraphs upto TO."
4358 (setq tab-stop-list nil)
4359 (woman2-process-escapes-to-eol 'numeric)
4360 (save-excursion
4361 (let ((tab-stop 0))
4362 (while (not (eolp))
4363 (let ((plus (cond ((eq (following-char) ?+) (forward-char 1) t)))
4364 (i (woman-parse-numeric-arg)))
4365 (setq tab-stop (if plus (+ tab-stop i) i)))
4366 (if (memq (following-char) '(?R ?C))
4367 (setq tab-stop (cons tab-stop (following-char))))
4368 (setq tab-stop-list (cons tab-stop tab-stop-list))
4369 (skip-syntax-forward "^ ") ; skip following R, C, `;', etc.
4370 (skip-chars-forward " \t")
4372 (woman-delete-line 1) ; ignore any remaining arguments
4373 (setq tab-stop-list (reverse tab-stop-list))
4374 (woman2-format-paragraphs to))
4376 (defsubst woman-get-tab-stop (tab-stops)
4377 "If TAB-STOPS is a cons, return its car, else return TAB-STOPS."
4378 (if (consp tab-stops) (car tab-stops) tab-stops))
4380 (defun woman-tab-to-tab-stop ()
4381 "Insert spaces to next defined tab-stop column.
4382 The variable `tab-stop-list' is a list whose elements are either left
4383 tab stop columns or pairs (COLUMN . TYPE) where TYPE is R or C."
4384 ;; Based on tab-to-tab-stop in indent.el.
4385 ;; R & C tabs probably not quite right!
4386 (delete-char -1)
4387 (let ((tabs tab-stop-list))
4388 (while (and tabs (>= (current-column)
4389 (woman-get-tab-stop (car tabs))))
4390 (setq tabs (cdr tabs)))
4391 (if tabs
4392 (let* ((tab (car tabs))
4393 (type (and (consp tab) (cdr tab)))
4394 eol n)
4395 (if type
4396 (setq tab (woman-get-tab-stop tab)
4397 eol (line-end-position)
4398 n (save-excursion
4399 (search-forward "\t" eol t))
4400 n (- (if n (1- n) eol) (point))
4401 tab (- tab (if (eq type ?C) (/ n 2) n))) )
4402 (setq n (- tab (current-column)))
4403 (insert-char ?\s n))
4404 (insert ?\s))))
4406 (defun woman2-DT (to)
4407 ".DT -- Restore default tabs. Format paragraphs upto TO.
4408 \(Breaks, but should not.)"
4409 ;; Currently just terminates special tab processing.
4410 (setq tab-stop-list nil)
4411 (woman-delete-line 1) ; ignore any arguments
4412 (woman2-format-paragraphs to))
4414 (defun woman2-fc (to)
4415 ".fc a b -- Set field delimiter a and pad character b.
4416 Format paragraphs upto TO.
4417 A VERY FIRST ATTEMPT to make fields at least readable!
4418 Needs doing properly!"
4419 (if (eolp)
4420 (woman-delete-whole-line) ; ignore!
4421 (let ((delim (following-char))
4422 (pad ?\s) end) ; pad defaults to space
4423 (forward-char)
4424 (skip-chars-forward " \t")
4425 (or (eolp) (setq pad (following-char)))
4426 (woman-delete-whole-line)
4427 (save-excursion
4428 (if (re-search-forward "^[.'][ \t]*fc\\s " nil t)
4429 (setq end (match-beginning 0))))
4430 ;; A field is contained between a pair of field delimiter
4431 ;; characters and consists of sub-strings separated by padding
4432 ;; indicator characters:
4433 (setq delim (string delim ?[ ?^ delim ?] ?* delim))
4434 (save-excursion
4435 (while (re-search-forward delim end t)
4436 (goto-char (match-beginning 0))
4437 (delete-char 1)
4438 (insert woman-unpadded-space-char)
4439 (goto-char (match-end 0))
4440 (delete-char -1)
4441 (insert-before-markers woman-unpadded-space-char)
4442 (subst-char-in-region
4443 (match-beginning 0) (match-end 0)
4444 pad woman-unpadded-space-char t)))))
4445 (woman2-format-paragraphs to))
4448 ;;; Preliminary table support (.TS/.TE)
4450 (defun woman2-TS (to)
4451 ".TS -- Start of table code for the tbl processor.
4452 Format paragraphs upto TO."
4453 (when woman-emulate-tbl
4454 ;; Assumes column separator is \t and intercolumn spacing is 3.
4455 ;; The first line may optionally be a list of options terminated by
4456 ;; a semicolon. Currently, just delete it:
4457 (if (looking-at ".*;[ \t]*$") (woman-delete-line 1)) ;
4458 ;; The following lines must specify the format of each line of the
4459 ;; table and end with a period. Currently, just delete them:
4460 (while (not (looking-at ".*\\.[ \t]*$")) (woman-delete-line 1))
4461 (woman-delete-line 1)
4462 ;; For each column, find its width and align it:
4463 (let ((start (point)) (col 1))
4464 (WoMan-log "%s" (buffer-substring start (+ start 40)))
4465 ;; change T{ T} to tabs
4466 (while (search-forward "T{\n" to t)
4467 (replace-match "")
4468 (catch 'end
4469 (while (search-forward "\n" to t)
4470 (replace-match " ")
4471 (if (looking-at "T}")
4472 (progn
4473 (delete-char 2)
4474 (throw 'end t))))))
4475 (goto-char start)
4476 ;; strip space and headers
4477 (while (re-search-forward "^\\.TH\\|\\.sp" to t)
4478 (woman-delete-whole-line))
4479 (goto-char start)
4480 (while (prog1 (search-forward "\t" to t) (goto-char start))
4481 ;; Find current column width:
4482 (while (< (point) to)
4483 (when (search-forward "\t" to t)
4484 (backward-char)
4485 (if (> (current-column) col) (setq col (current-column))))
4486 (forward-line))
4487 ;; Align current column:
4488 (goto-char start)
4489 (setq col (+ col 3)) ; intercolumn space
4490 (while (< (point) to)
4491 (when (search-forward "\t" to t)
4492 (delete-char -1)
4493 (insert-char ?\s (- col (current-column))))
4494 (forward-line))
4495 (goto-char start))
4496 ;; find maximum width
4497 (let ((max-col 0))
4498 (while (search-forward "\n" to t)
4499 (backward-char)
4500 (if (> (current-column) max-col)
4501 (setq max-col (current-column)))
4502 (forward-char))
4503 (goto-char start)
4504 ;; break lines if they are too long
4505 (when (and (> max-col woman-fill-column)
4506 (> woman-fill-column col))
4507 (setq max-col woman-fill-column)
4508 (woman-break-table col to start)
4509 (goto-char start))
4510 (while (re-search-forward "^_$" to t)
4511 (replace-match (make-string max-col ?_)))
4512 (goto-char start))))
4513 ;; Format table with no filling or adjusting (cf. woman2-nf):
4514 (setq woman-nofill t)
4515 (woman2-format-paragraphs to))
4517 (defalias 'woman2-TE 'woman2-fi)
4518 ;; ".TE -- End of table code for the tbl processor."
4519 ;; Turn filling and adjusting back on.
4521 (defun woman-break-table (start-column to start)
4522 (while (< (point) to)
4523 (move-to-column woman-fill-column)
4524 (if (eolp)
4525 (forward-line)
4526 (if (and (search-backward " " start t)
4527 (> (current-column) start-column))
4528 (progn
4529 (insert-char ?\n 1)
4530 (insert-char ?\s (- start-column 5)))
4531 (forward-line)))))
4533 ;;; WoMan message logging:
4535 ;; The basis for this logging code was shamelessly pirated from bytecomp.el
4536 ;; by Jamie Zawinski <jwz@lucid.com> & Hallvard Furuseth <hbf@ulrik.uio.no>
4538 (defun WoMan-log-begin ()
4539 "Log the beginning of formatting in *WoMan-Log*."
4540 (let ((WoMan-current-buffer (buffer-name)))
4541 (with-current-buffer (get-buffer-create "*WoMan-Log*")
4542 (or (eq major-mode 'view-mode) (view-mode 1))
4543 (setq buffer-read-only nil)
4544 (goto-char (point-max))
4545 (insert "\n\^L\nFormatting "
4546 (if (stringp WoMan-current-file)
4547 (concat "file " WoMan-current-file)
4548 (concat "buffer " WoMan-current-buffer))
4549 " at " (current-time-string) "\n")
4550 (setq WoMan-Log-header-point-max (point-max)))))
4552 (defun WoMan-log (format &rest args)
4553 "Log a message out of FORMAT control string and optional ARGS."
4554 (WoMan-log-1 (apply #'format-message format args)))
4556 (defun WoMan-warn (format &rest args)
4557 "Log a warning message out of FORMAT control string and optional ARGS."
4558 (setq format (apply #'format-message format args))
4559 (WoMan-log-1 (concat "** " format)))
4561 ;; request is not used dynamically by any callees.
4562 (defun WoMan-warn-ignored (request ignored)
4563 "Log a warning message about ignored directive REQUEST.
4564 IGNORED is a string appended to the log message."
4565 (let ((tail
4566 (buffer-substring (point)
4567 (line-end-position))))
4568 (if (and (> (length tail) 0)
4569 (/= (string-to-char tail) ?\s))
4570 (setq tail (concat " " tail)))
4571 (WoMan-log-1
4572 (concat "** " request tail " request " ignored))))
4574 (defun WoMan-log-end (time)
4575 "Log the end of formatting in *WoMan-Log*.
4576 TIME specifies the time it took to format the man page, to be printed
4577 with the message."
4578 (WoMan-log-1 (format "Formatting time %g seconds." time) 'end))
4580 (defun WoMan-log-1 (string &optional end)
4581 "Log a message STRING in *WoMan-Log*.
4582 If optional argument END is non-nil then make buffer read-only after
4583 logging the message."
4584 (with-current-buffer (get-buffer-create "*WoMan-Log*")
4585 (setq buffer-read-only nil)
4586 (goto-char (point-max))
4587 (or end (insert " ")) (insert string "\n")
4588 (if end
4589 (setq buffer-read-only t)
4590 (if woman-show-log
4591 (select-window ; to return to
4592 (prog1 (selected-window) ; WoMan window
4593 (select-window (display-buffer (current-buffer)))
4594 (cond (WoMan-Log-header-point-max
4595 (goto-char WoMan-Log-header-point-max)
4596 (forward-line -1)
4597 (recenter 0))))))))
4598 nil) ; for woman-file-readable-p etc.
4600 ;;; Bookmark Woman support.
4601 (declare-function bookmark-make-record-default
4602 "bookmark" (&optional no-file no-context posn))
4603 (declare-function bookmark-prop-get "bookmark" (bookmark prop))
4604 (declare-function bookmark-default-handler "bookmark" (bmk))
4605 (declare-function bookmark-get-bookmark-record "bookmark" (bmk))
4607 ;; FIXME: woman.el and man.el should be better integrated so, for
4608 ;; example, bookmarks of one can be used with the other.
4610 (defun woman-bookmark-make-record ()
4611 "Make a bookmark entry for a Woman buffer."
4612 `(,(Man-default-bookmark-title)
4613 ,@(bookmark-make-record-default 'no-file)
4614 (location . ,(concat "woman " woman-last-file-name))
4615 ;; Use the same form as man's bookmarks, as much as possible.
4616 (man-args . ,woman-last-file-name)
4617 (handler . woman-bookmark-jump)))
4619 ;;;###autoload
4620 (defun woman-bookmark-jump (bookmark)
4621 "Default bookmark handler for Woman buffers."
4622 (let* ((file (bookmark-prop-get bookmark 'man-args))
4623 ;; FIXME: we need woman-find-file-noselect, since
4624 ;; save-window-excursion can't protect us from the case where
4625 ;; woman-find-file creates a new frame.
4626 (buf (save-window-excursion
4627 (woman-find-file file) (current-buffer))))
4628 (bookmark-default-handler
4629 `("" (buffer . ,buf) . ,(bookmark-get-bookmark-record bookmark)))))
4631 (provide 'woman)
4633 ;;; woman.el ends here