;;; man.el --- browse UNIX manual pages -*- coding: iso-8859-1 -*-
;; Copyright (C) 1993, 1994, 1996, 1997, 2001, 2002, 2003,
-;; 2004, 2005, 2006, 2007 Free Software Foundation, Inc.
+;; 2004, 2005, 2006, 2007, 2008, 2009 Free Software Foundation, Inc.
;; Author: Barry A. Warsaw <bwarsaw@cen.com>
;; Maintainer: FSF
;; This file is part of GNU Emacs.
-;; GNU Emacs is free software; you can redistribute it and/or modify
+;; GNU Emacs is free software: you can redistribute it and/or modify
;; it under the terms of the GNU General Public License as published by
-;; the Free Software Foundation; either version 2, or (at your option)
-;; any later version.
+;; the Free Software Foundation, either version 3 of the License, or
+;; (at your option) any later version.
;; GNU Emacs is distributed in the hope that it will be useful,
;; but WITHOUT ANY WARRANTY; without even the implied warranty of
;; GNU General Public License for more details.
;; You should have received a copy of the GNU General Public License
-;; along with GNU Emacs; see the file COPYING. If not, write to the
-;; Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
-;; Boston, MA 02110-1301, USA.
+;; along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>.
;;; Commentary:
;; ========== Credits and History ==========
;; In mid 1991, several people posted some interesting improvements to
-;; man.el from the standard emacs 18.57 distribution. I liked many of
+;; man.el from the standard Emacs 18.57 distribution. I liked many of
;; these, but wanted everything in one single package, so I decided
;; to incorporate them into a single manual browsing mode. While
;; much of the code here has been rewritten, and some features added,
;; ========== Features ==========
;; + Runs "man" in the background and pipes the results through a
;; series of sed and awk scripts so that all retrieving and cleaning
-;; is done in the background. The cleaning commands are configurable.
+;; is done in the background. The cleaning commands are configurable.
;; + Syntax is the same as Un*x man
;; + Functionality is the same as Un*x man, including "man -k" and
;; "man <section>", etc.
;; ============= TODO ===========
;; - Add a command for printing.
-;; - The awk script deletes multiple blank lines. This behaviour does
+;; - The awk script deletes multiple blank lines. This behavior does
;; not allow to understand if there was indeed a blank line at the
;; end or beginning of a page (after the header, or before the
;; footer). A different algorithm should be used. It is easy to
(defvar Man-notify)
-(defvar Man-current-page)
-(defvar Man-page-list)
(defcustom Man-filter-list nil
- "*Manpage cleaning filter command phrases.
+ "Manpage cleaning filter command phrases.
This variable contains a list of the following form:
'((command-string phrase-string*)*)
(string :tag "Phrase String"))))
:group 'man)
-(defvar Man-original-frame)
-(defvar Man-arguments)
-(defvar Man-sections-alist)
-(defvar Man-refpages-alist)
(defvar Man-uses-untabify-flag t
"Non-nil means use `untabify' instead of `Man-untabify-command'.")
-(defvar Man-page-mode-string)
(defvar Man-sed-script nil
"Script for sed to nuke backspaces and ANSI codes from manpages.")
;; user variables
(defcustom Man-fontify-manpage-flag t
- "*Non-nil means make up the manpage with fonts."
+ "Non-nil means make up the manpage with fonts."
:type 'boolean
:group 'man)
(defcustom Man-overstrike-face 'bold
- "*Face to use when fontifying overstrike."
+ "Face to use when fontifying overstrike."
:type 'face
:group 'man)
(defcustom Man-underline-face 'underline
- "*Face to use when fontifying underlining."
+ "Face to use when fontifying underlining."
:type 'face
:group 'man)
(defcustom Man-reverse-face 'highlight
- "*Face to use when fontifying reverse video."
+ "Face to use when fontifying reverse video."
:type 'face
:group 'man)
;; Use the value of the obsolete user option Man-notify, if set.
(defcustom Man-notify-method (if (boundp 'Man-notify) Man-notify 'friendly)
- "*Selects the behavior when manpage is ready.
+ "Selects the behavior when manpage is ready.
This variable may have one of the following values, where (sf) means
that the frames are switched, so the manpage is displayed in the frame
where the man command was called from:
:group 'man)
(defcustom Man-width nil
- "*Number of columns for which manual pages should be formatted.
+ "Number of columns for which manual pages should be formatted.
If nil, the width of the window selected at the moment of man
invocation is used. If non-nil, the width of the frame selected
at the moment of man invocation is used. The value also can be a
:group 'man)
(defcustom Man-frame-parameters nil
- "*Frame parameter list for creating a new frame for a manual page."
+ "Frame parameter list for creating a new frame for a manual page."
:type 'sexp
:group 'man)
(defcustom Man-downcase-section-letters-flag t
- "*Non-nil means letters in sections are converted to lower case.
+ "Non-nil means letters in sections are converted to lower case.
Some Un*x man commands can't handle uppercase letters in sections, for
example \"man 2V chmod\", but they are often displayed in the manpage
with the upper case letter. When this variable is t, the section
:group 'man)
(defcustom Man-circular-pages-flag t
- "*Non-nil means the manpage list is treated as circular for traversal."
+ "Non-nil means the manpage list is treated as circular for traversal."
:type 'boolean
:group 'man)
;; '("3X" . "3") ; Xlib man pages
'("3X11" . "3")
'("1-UCB" . ""))
- "*Association list of bogus sections to real section numbers.
+ "Association list of bogus sections to real section numbers.
Some manpages (e.g. the Sun C++ 2.1 manpages) have section numbers in
their references which Un*x `man' does not recognize. This
association list is used to translate those sections, when found, to
(defvar Man-awk-command "awk"
"Command used for processing awk scripts.")
-(defvar Man-mode-map nil
- "Keymap for Man mode.")
-
(defvar Man-mode-hook nil
"Hook run when Man mode is enabled.")
"(\\(" Man-section-regexp "\\))\\).*\\1"))
"Regular expression describing the heading of a page.")
-(defvar Man-heading-regexp "^\\([A-Z][A-Z /-]+\\)$"
+(defvar Man-heading-regexp "^\\([A-Z][A-Z0-9 /-]+\\)$"
"Regular expression describing a manpage heading entry.")
(defvar Man-see-also-regexp "SEE ALSO"
"Regular expression for SEE ALSO heading (or your equivalent).
This regexp should not start with a `^' character.")
-(defvar Man-first-heading-regexp "^[ \t]*NAME$\\|^[ \t]*No manual entry fo.*$"
+;; This used to have leading space [ \t]*, but was removed because it
+;; causes false page splits on an occasional NAME with leading space
+;; inside a manpage. And `Man-heading-regexp' doesn't have [ \t]* anyway.
+(defvar Man-first-heading-regexp "^NAME$\\|^[ \t]*No manual entry fo.*$"
"Regular expression describing first heading on a manpage.
This regular expression should start with a `^' character.")
;; end user variables
\f
;; other variables and keymap initializations
+(defvar Man-original-frame)
+(make-variable-buffer-local 'Man-original-frame)
+(defvar Man-arguments)
+(make-variable-buffer-local 'Man-arguments)
+(put 'Man-arguments 'permanent-local t)
+
+(defvar Man-sections-alist nil)
(make-variable-buffer-local 'Man-sections-alist)
+(defvar Man-refpages-alist nil)
(make-variable-buffer-local 'Man-refpages-alist)
+(defvar Man-page-list nil)
(make-variable-buffer-local 'Man-page-list)
+(defvar Man-current-page 0)
(make-variable-buffer-local 'Man-current-page)
+(defvar Man-page-mode-string "1 of 1")
(make-variable-buffer-local 'Man-page-mode-string)
-(make-variable-buffer-local 'Man-original-frame)
-(make-variable-buffer-local 'Man-arguments)
-(put 'Man-arguments 'permanent-local t)
-
-(setq-default Man-sections-alist nil)
-(setq-default Man-refpages-alist nil)
-(setq-default Man-page-list nil)
-(setq-default Man-current-page 0)
-(setq-default Man-page-mode-string "1 of 1")
(defconst Man-sysv-sed-script "\
/\b/ { s/_\b//g
table)
"Syntax table used in Man mode buffers.")
-(unless Man-mode-map
- (setq Man-mode-map (make-sparse-keymap))
- (suppress-keymap Man-mode-map)
- (set-keymap-parent Man-mode-map button-buffer-map)
-
- (define-key Man-mode-map " " 'scroll-up)
- (define-key Man-mode-map "\177" 'scroll-down)
- (define-key Man-mode-map "n" 'Man-next-section)
- (define-key Man-mode-map "p" 'Man-previous-section)
- (define-key Man-mode-map "\en" 'Man-next-manpage)
- (define-key Man-mode-map "\ep" 'Man-previous-manpage)
- (define-key Man-mode-map ">" 'end-of-buffer)
- (define-key Man-mode-map "<" 'beginning-of-buffer)
- (define-key Man-mode-map "." 'beginning-of-buffer)
- (define-key Man-mode-map "r" 'Man-follow-manual-reference)
- (define-key Man-mode-map "g" 'Man-goto-section)
- (define-key Man-mode-map "s" 'Man-goto-see-also-section)
- (define-key Man-mode-map "k" 'Man-kill)
- (define-key Man-mode-map "q" 'Man-quit)
- (define-key Man-mode-map "m" 'man)
- ;; Not all the man references get buttons currently. The text in the
- ;; manual page can contain references to other man pages
- (define-key Man-mode-map "\r" 'man-follow)
- (define-key Man-mode-map "?" 'describe-mode))
+(defvar Man-mode-map
+ (let ((map (make-sparse-keymap)))
+ (suppress-keymap map)
+ (set-keymap-parent map button-buffer-map)
+
+ (define-key map " " 'scroll-up)
+ (define-key map "\177" 'scroll-down)
+ (define-key map "n" 'Man-next-section)
+ (define-key map "p" 'Man-previous-section)
+ (define-key map "\en" 'Man-next-manpage)
+ (define-key map "\ep" 'Man-previous-manpage)
+ (define-key map ">" 'end-of-buffer)
+ (define-key map "<" 'beginning-of-buffer)
+ (define-key map "." 'beginning-of-buffer)
+ (define-key map "r" 'Man-follow-manual-reference)
+ (define-key map "g" 'Man-goto-section)
+ (define-key map "s" 'Man-goto-see-also-section)
+ (define-key map "k" 'Man-kill)
+ (define-key map "q" 'Man-quit)
+ (define-key map "m" 'man)
+ ;; Not all the man references get buttons currently. The text in the
+ ;; manual page can contain references to other man pages
+ (define-key map "\r" 'man-follow)
+ (define-key map "?" 'describe-mode)
+ map)
+ "Keymap for Man mode.")
;; buttons
(define-button-type 'Man-abstract-xref-man-page
'func nil
'action #'Man-xref-button-action)
-(defun Man-xref-button-action (button)
+(defun Man-xref-button-action (button)
(let ((target (button-get button 'Man-target-string)))
- (funcall
+ (funcall
(button-get button 'func)
(cond ((null target)
(button-label button))
(funcall target (button-start button)))
(t target)))))
-(define-button-type 'Man-xref-man-page
+(define-button-type 'Man-xref-man-page
:supertype 'Man-abstract-xref-man-page
'func 'man-follow)
\f
;; ======================================================================
-;; default man entry: get word under point
+;; default man entry: get word near point
-(defsubst Man-default-man-entry (&optional pos)
- "Make a guess at a default manual entry based on the text at POS.
-If POS is nil, the current point is used."
- (let (word)
+(defun Man-default-man-entry (&optional pos)
+ "Guess default manual entry based on the text near position POS.
+POS defaults to `point'."
+ (let (word start pos column distance)
(save-excursion
- (if pos (goto-char pos))
- ;; Default man entry title is any word the cursor is on, or if
- ;; cursor not on a word, then nearest preceding word.
- (skip-chars-backward "-a-zA-Z0-9._+:")
- (let ((start (point)))
- (skip-chars-forward "-a-zA-Z0-9._+:")
- (setq word (buffer-substring-no-properties start (point))))
- (if (string-match "[._]+$" word)
- (setq word (substring word 0 (match-beginning 0))))
- ;; If looking at something like *strcat(... , remove the '*'
- (if (string-match "^*" word)
- (setq word (substring word 1)))
- ;; If looking at something like ioctl(2) or brc(1M), include the
- ;; section number in the returned value. Remove text properties.
- (concat word
- (if (looking-at
- (concat "[ \t]*([ \t]*\\(" Man-section-regexp "\\)[ \t]*)"))
- (format "(%s)" (match-string-no-properties 1)))))))
+ (when pos (goto-char pos))
+ (setq pos (point))
+ ;; The default title is the nearest entry-like object before or
+ ;; after POS.
+ (if (and (skip-chars-backward " \ta-zA-Z0-9+")
+ (not (zerop (skip-chars-backward "(")))
+ ;; Try to handle the special case where POS is on a
+ ;; section number.
+ (looking-at
+ (concat "([ \t]*\\(" Man-section-regexp "\\)[ \t]*)"))
+ ;; We skipped a valid section number backwards, look at
+ ;; preceding text.
+ (or (and (skip-chars-backward ",; \t")
+ (not (zerop (skip-chars-backward "-a-zA-Z0-9._+:"))))
+ ;; Not a valid entry, move POS after closing paren.
+ (not (setq pos (match-end 0)))))
+ ;; We have a candidate, make `start' record its starting
+ ;; position.
+ (setq start (point))
+ ;; Otherwise look at char before POS.
+ (goto-char pos)
+ (if (not (zerop (skip-chars-backward "-a-zA-Z0-9._+:")))
+ ;; Our candidate is just before or around POS.
+ (setq start (point))
+ ;; Otherwise record the current column and look backwards.
+ (setq column (current-column))
+ (skip-chars-backward ",; \t")
+ ;; Record the distance travelled.
+ (setq distance (- column (current-column)))
+ (when (looking-back
+ (concat "([ \t]*\\(?:" Man-section-regexp "\\)[ \t]*)"))
+ ;; Skip section number backwards.
+ (goto-char (match-beginning 0))
+ (skip-chars-backward " \t"))
+ (if (not (zerop (skip-chars-backward "-a-zA-Z0-9._+:")))
+ (progn
+ ;; We have a candidate before POS ...
+ (setq start (point))
+ (goto-char pos)
+ (if (and (skip-chars-forward ",; \t")
+ (< (- (current-column) column) distance)
+ (looking-at "[-a-zA-Z0-9._+:]"))
+ ;; ... but the one after POS is better.
+ (setq start (point))
+ ;; ... and anything after POS is worse.
+ (goto-char start)))
+ ;; No candidate before POS.
+ (goto-char pos)
+ (skip-chars-forward ",; \t")
+ (setq start (point)))))
+ ;; We have found a suitable starting point, try to skip at least
+ ;; one character.
+ (skip-chars-forward "-a-zA-Z0-9._+:")
+ (setq word (buffer-substring-no-properties start (point)))
+ ;; If there is a continuation at the end of line, check the
+ ;; following line too, eg:
+ ;; see this-
+ ;; command-here(1)
+ ;; Note: This code gets executed iff our entry is after POS.
+ (when (looking-at "[ \t\r\n]+\\([-a-zA-Z0-9._+:]+\\)([0-9])")
+ (setq word (concat word (match-string-no-properties 1)))
+ ;; Make sure the section number gets included by the code below.
+ (goto-char (match-end 1)))
+ (when (string-match "[._]+$" word)
+ (setq word (substring word 0 (match-beginning 0))))
+ ;; The following was commented out since the preceding code
+ ;; should not produce a leading "*" in the first place.
+;;; ;; If looking at something like *strcat(... , remove the '*'
+;;; (when (string-match "^*" word)
+;;; (setq word (substring word 1)))
+ (concat
+ word
+ (and (not (string-equal word ""))
+ ;; If looking at something like ioctl(2) or brc(1M),
+ ;; include the section number in the returned value.
+ (looking-at
+ (concat "[ \t]*([ \t]*\\(" Man-section-regexp "\\)[ \t]*)"))
+ (format "(%s)" (match-string-no-properties 1)))))))
\f
;; ======================================================================
(require 'env)
(message "Invoking %s %s in the background" manual-program man-args)
(setq buffer (generate-new-buffer bufname))
- (save-excursion
- (set-buffer buffer)
+ (with-current-buffer buffer
(setq buffer-undo-list t)
(setq Man-original-frame (selected-frame))
(setq Man-arguments man-args))
;; minal (using an ioctl(2) if available, the value of
;; $COLUMNS, or falling back to 80 characters if nei-
;; ther is available).
- (if window-system
- (unless (or (getenv "MANWIDTH") (getenv "COLUMNS"))
- ;; This isn't strictly correct, since we don't know how
- ;; the page will actually be displayed, but it seems
- ;; reasonable.
- (setenv "COLUMNS" (number-to-string
- (cond
- ((and (integerp Man-width) (> Man-width 0))
- Man-width)
- (Man-width (frame-width))
- ((window-width)))))))
+ (unless (or (getenv "MANWIDTH") (getenv "COLUMNS"))
+ ;; This isn't strictly correct, since we don't know how
+ ;; the page will actually be displayed, but it seems
+ ;; reasonable.
+ (setenv "COLUMNS" (number-to-string
+ (cond
+ ((and (integerp Man-width) (> Man-width 0))
+ Man-width)
+ (Man-width (frame-width))
+ ((window-width))))))
(setenv "GROFF_NO_SGR" "1")
+ ;; Since man-db 2.4.3-1, man writes plain text with no escape
+ ;; sequences when stdout is not a tty. In 2.5.0, the following
+ ;; env-var was added to allow control of this (see Debian Bug#340673).
+ (setenv "MAN_KEEP_FORMATTING" "1")
(if (fboundp 'start-process)
(set-process-sentinel
(start-process manual-program buffer
(defun Man-notify-when-ready (man-buffer)
"Notify the user when MAN-BUFFER is ready.
See the variable `Man-notify-method' for the different notification behaviors."
- (let ((saved-frame (save-excursion
- (set-buffer man-buffer)
+ (let ((saved-frame (with-current-buffer man-buffer
Man-original-frame)))
(cond
((eq Man-notify-method 'newframe)
(Man-highlight-references0 nil Man-apropos-regexp 1
'Man-default-man-entry
(or xref-man-type 'Man-xref-man-page)))
- (Man-highlight-references0 Man-see-also-regexp Man-reference-regexp 1
+ (Man-highlight-references0 Man-see-also-regexp Man-reference-regexp 1
'Man-default-man-entry
(or xref-man-type 'Man-xref-man-page))
(Man-highlight-references0 Man-synopsis-regexp Man-header-regexp 0 2
(Man-next-section 1)
(point)))
(goto-char (point-min))
- (point-max))))
+ nil)))
(while (re-search-forward regexp end t)
(make-text-button
(match-beginning button-pos)
(match-end button-pos)
'type type
'Man-target-string (cond
- ((numberp target)
+ ((numberp target)
(match-string target))
((functionp target)
target)
(or (stringp process)
(set-process-buffer process nil))
- (save-excursion
- (set-buffer Man-buffer)
+ (with-current-buffer Man-buffer
(let ((case-fold-search nil))
(goto-char (point-min))
(cond ((or (looking-at "No \\(manual \\)*entry for")
(Man-notify-when-ready Man-buffer))
(if err-mess
- (error err-mess))
+ (error "%s" err-mess))
))))
\f
(defun Man-strip-page-headers ()
"Strip all the page headers but the first from the manpage."
- (let ((buffer-read-only nil)
+ (let ((inhibit-read-only t)
(case-fold-search nil)
- (page-list Man-page-list)
- (page ())
(header ""))
- (while page-list
- (setq page (car page-list))
+ (dolist (page Man-page-list)
(and (nth 2 page)
(goto-char (car page))
(re-search-forward Man-first-heading-regexp nil t)
;; line.
;; (setq header (concat "\n" header)))
(while (search-forward header (nth 1 page) t)
- (replace-match "")))
- (setq page-list (cdr page-list)))))
+ (replace-match ""))))))
(defun Man-unindent ()
"Delete the leading spaces that indent the manpage."
- (let ((buffer-read-only nil)
- (case-fold-search nil)
- (page-list Man-page-list))
- (while page-list
- (let ((page (car page-list))
- (indent "")
+ (let ((inhibit-read-only t)
+ (case-fold-search nil))
+ (dolist (page Man-page-list)
+ (let ((indent "")
(nindent 0))
(narrow-to-region (car page) (car (cdr page)))
(if Man-uses-untabify-flag
(or (eolp)
(delete-char nindent))
(forward-line 1)))
- (setq page-list (cdr page-list))
))))
\f
(defun Man-next-section (n)
"Move point to Nth next section (default 1)."
(interactive "p")
- (let ((case-fold-search nil))
+ (let ((case-fold-search nil)
+ (start (point)))
(if (looking-at Man-heading-regexp)
(forward-line 1))
(if (re-search-forward Man-heading-regexp (point-max) t n)
(beginning-of-line)
(goto-char (point-max))
;; The last line doesn't belong to any section.
- (forward-line -1))))
+ (forward-line -1))
+ ;; But don't move back from the starting point (can happen if `start'
+ ;; is somewhere on the last line).
+ (if (< (point) start) (goto-char start))))
(defun Man-previous-section (n)
"Move point to Nth previous section (default 1)."
Actually the section moved to is described by `Man-see-also-regexp'."
(interactive)
(if (not (Man-find-section Man-see-also-regexp))
- (error (concat "No " Man-see-also-regexp
+ (error "%s" (concat "No " Man-see-also-regexp
" section found in the current manpage"))))
(defun Man-possibly-hyphenated-word ()
(interactive
(if (not Man-refpages-alist)
(error "There are no references in the current man page")
- (list (let* ((default (or
- (car (all-completions
- (let ((word
- (or (Man-possibly-hyphenated-word)
- "")))
- ;; strip a trailing '-':
- (if (string-match "-$" word)
- (substring word 0
- (match-beginning 0))
- word))
- Man-refpages-alist))
- (aheadsym Man-refpages-alist)))
- chosen
- (prompt (concat "Refer to (default " default "): ")))
- (setq chosen (completing-read prompt Man-refpages-alist))
- (if (or (not chosen)
- (string= chosen ""))
- default
- chosen)))))
+ (list
+ (let* ((default (or
+ (car (all-completions
+ (let ((word
+ (or (Man-possibly-hyphenated-word)
+ "")))
+ ;; strip a trailing '-':
+ (if (string-match "-$" word)
+ (substring word 0
+ (match-beginning 0))
+ word))
+ Man-refpages-alist))
+ (aheadsym Man-refpages-alist)))
+ (defaults
+ (mapcar 'substring-no-properties
+ (delete-dups
+ (delq nil (cons default
+ (mapcar 'car Man-refpages-alist))))))
+ chosen
+ (prompt (concat "Refer to (default " default "): ")))
+ (setq chosen (completing-read prompt Man-refpages-alist
+ nil nil nil nil defaults))
+ (if (or (not chosen)
+ (string= chosen ""))
+ default
+ chosen)))))
(if (not Man-refpages-alist)
(error "Can't find any references in the current manpage")
(aput 'Man-refpages-alist reference)
(let ((path Man-header-file-path)
complete-path)
(while path
- (setq complete-path (concat (car path) "/" file)
+ (setq complete-path (expand-file-name file (car path))
path (cdr path))
(if (file-readable-p complete-path)
(progn (view-file complete-path)
HCoop / bpt / emacs.git / blobdiff