;;; man.el --- browse UNIX manual pages;; Copyright (C) 1993, 1994 Free Software Foundation, Inc.;; Author: Barry A. Warsaw <bwarsaw@cen.com>;; Keywords: help;; Adapted-By: ESR, pot;; This file is part of GNU Emacs.;; 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.;; GNU Emacs is distributed in the hope that it will be useful,;; but WITHOUT ANY WARRANTY; without even the implied warranty of;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the;; 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, 675 Mass Ave, Cambridge, MA 02139, USA.;;; Commentary:;; This code provides a function, `man', with which you can browse;; UNIX manual pages. Formatting is done in background so that you;; can continue to use your Emacs while processing is going on.;;;; The mode also supports hypertext-like following of manual page SEE;; ALSO references, and other features. See below or do `?' in a;; manual page buffer for details.;; ========== 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;; these, but wanted everthing 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,;; these folks deserve lots of credit for providing the initial;; excellent packages on which this one is based.;; Nick Duffek <duffek@chaos.cs.brandeis.edu>, posted a very nice;; improvement which retrieved and cleaned the manpages in a;; background process, and which correctly deciphered such options as;; man -k.;; Eric Rose <erose@jessica.stanford.edu>, submitted manual.el which;; provided a very nice manual browsing mode.;; This package was available as `superman.el' from the LCD package;; for some time before it was accepted into Emacs 19. The entry;; point and some other names have been changed to make it a drop-in;; replacement for the old man.el package.;; Francesco Potorti` <pot@cnuce.cnr.it> cleaned it up thoroughly,;; making it faster, more robust and more tolerant of different;; systems' man idiosynchrasies.;; ========== 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.;; + Syntax is the same as Un*x man;; + Functionality is the same as Un*x man, including "man -k" and;; "man <section>", etc.;; + Provides a manual browsing mode with keybindings for traversing;; the sections of a manpage, following references in the SEE ALSO;; section, and more.;; + Multiple manpages created with the same man command are put into;; a narrowed buffer circular list.;; ============= TODO ===========;; - Add a command for printing.;; - The awk script deletes multiple blank lines. This behaviour 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;; compute how many blank lines there are before and after the page;; headers, and after the page footer. But it is possible to compute;; the number of blank lines before the page footer by euristhics;; only. Is it worth doing?;; - Allow a user option to mean that all the manpages should go in;; the same buffer, where they can be browsed with M-n and M-p.;; - Allow completion on the manpage name when calling man. This;; requires a reliable list of places where manpages can be found. The;; drawback would be that if the list is not complete, the user might;; be led to believe that the manpages in the missing directories do;; not exist.;;; Code:(require'assoc);; vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv;; empty defvars (keep the compiler quiet)(defvarMan-notify)(defvarMan-current-page)(defvarMan-page-list)(defvarMan-filter-list)(defvarMan-original-frame)(defvarMan-arguments)(defvarMan-sections-alist)(defvarMan-refpages-alist)(defvarMan-uses-untabify-flag)(defvarMan-page-mode-string)(defvarMan-sed-script);; vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv;; user variables(defvarMan-fontify-manpage-flagt"*Make up the manpage with fonts.")(defvarMan-overstrike-face'bold"*Face to use when fontifying overstrike.")(defvarMan-underline-face'underline"*Face to use when fontifying underlining.");; Use the value of the obsolete user option Man-notify, if set.(defvarMan-notify-method(if(boundp'Man-notify)Man-notify'friendly)"*Selects the behavior when manpage is ready.This variable may have one of the following values, where (sf) meansthat the frames are switched, so the manpage is displayed in the framewhere the man command was called from:newframe -- put the manpage in its own frame (see `Man-frame-parameters')pushy -- make the manpage the current buffer in the current windowbully -- make the manpage the current buffer and only window (sf)aggressive -- make the manpage the current buffer in the other window (sf)friendly -- display manpage in the other window but don't make current (sf)polite -- don't display manpage, but prints message and beep when readyquiet -- like `polite', but don't beepmeek -- make no indication that the manpage is readyAny other value of `Man-notify-method' is equivalent to `meek'.")(defvarMan-frame-parametersnil"*Frame parameter list for creating a new frame for a manual page.")(defvarMan-downcase-section-letters-flagt"*Letters in sections are converted to lower case.Some Un*x man commands can't handle uppercase letters in sections, forexample \"man 2V chmod\", but they are often displayed in the manpagewith the upper case letter. When this variable is t, the sectionletter (e.g., \"2V\") is converted to lowercase (e.g., \"2v\") beforebeing sent to the man background process.")(defvarMan-circular-pages-flagt"*If t, the manpage list is treated as circular for traversal.")(defvarMan-section-translations-alist(list'("3C++"."3");; Some systems have a real 3x man section, so let's comment this.;; '("3X" . "3") ; Xlib man pages'("3X11"."3")'("1-UCB".""))"*Association list of bogus sections to real section numbers.Some manpages (e.g. the Sun C++ 2.1 manpages) have section numbers intheir references which Un*x `man' does not recognize. Thisassociation list is used to translate those sections, when found, tothe associated section number.")(defvarmanual-program"man""The name of the program that produces man pages.")(defvarMan-untabify-command"pr""Command used for untabifying.")(defvarMan-untabify-command-args(list"-t""-e")"List of arguments to be passed to Man-untabify-command (which see).")(defvarMan-sed-command"sed""Command used for processing sed scripts.")(defvarMan-awk-command"awk""Command used for processing awk scripts.")(defvarMan-mode-line-format'(""mode-line-modifiedmode-line-buffer-identification" "global-mode-string" "Man-page-mode-string" %[("mode-namemode-line-processminor-mode-alist")%]----"(-3."%p")"-%-")"Mode line format for manual mode buffer.")(defvarMan-mode-mapnil"Keymap for Man mode.")(defvarMan-mode-hooknil"Hook run when Man mode is enabled.")(defvarMan-cooked-hooknil"Hook run after removing backspaces but before Man-mode processing.")(defvarMan-name-regexp"[-a-zA-Z0-9_][-a-zA-Z0-9_.]*""Regular expression describing the name of a manpage (without section).")(defvarMan-section-regexp"[0-9][a-zA-Z+]*\\|[LNln]""Regular expression describing a manpage section within parentheses.")(defvarMan-page-header-regexp(concat"^[ \t]*\\("Man-name-regexp"(\\("Man-section-regexp"\\))\\).*\\1")"Regular expression describing the heading of a page.")(defvarMan-heading-regexp"^\\([A-Z][A-Z ]+\\)$""Regular expression describing a manpage heading entry.")(defvarMan-see-also-regexp"SEE ALSO""Regular expression for SEE ALSO heading (or your equivalent).This regexp should not start with a `^' character.")(defvarMan-first-heading-regexp"^[ \t]*NAME$\\|^[ \t]*No manual entry fo.*$""Regular expression describing first heading on a manpage.This regular expression should start with a `^' character.")(defvarMan-reference-regexp(concat"\\("Man-name-regexp"\\)(\\("Man-section-regexp"\\))")"Regular expression describing a reference in the SEE ALSO section.")(defvarMan-switches"""Switches passed to the man command, as a single string.")(defvarMan-specified-section-option(if(string-match"-solaris[0-9.]*$"system-configuration)"-s""")"Option that indicates a specified a manual section name.");; ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^;; end user variables;; other variables and keymap initializations(make-variable-buffer-local'Man-sections-alist)(make-variable-buffer-local'Man-refpages-alist)(make-variable-buffer-local'Man-page-list)(make-variable-buffer-local'Man-current-page)(make-variable-buffer-local'Man-page-mode-string)(make-variable-buffer-local'Man-original-frame)(make-variable-buffer-local'Man-arguments)(setq-defaultMan-sections-alistnil)(setq-defaultMan-refpages-alistnil)(setq-defaultMan-page-listnil)(setq-defaultMan-current-page0)(setq-defaultMan-page-mode-string"1 of 1")(defconstMan-sysv-sed-script"\/\b/ { s/_\b//g s/\b_//g s/o\b+/o/g s/+\bo/o/g :ovstrk s/\\(.\\)\b\\1/\\1/g t ovstrk }/\e\\[[0-9][0-9]*m/ s///g""Script for sysV-like sed to nuke backspaces and ANSI codes from manpages.")(defconstMan-berkeley-sed-script"\/\b/ { s/_\b//g\\ s/\b_//g\\ s/o\b+/o/g\\ s/+\bo/o/g\\ :ovstrk\\ s/\\(.\\)\b\\1/\\1/g\\ t ovstrk\\ }\\/\e\\[[0-9][0-9]*m/ s///g""Script for berkeley-like sed to nuke backspaces and ANSI codes from manpages.")(ifMan-mode-mapnil(setqMan-mode-map(make-keymap))(suppress-keymapMan-mode-map)(define-keyMan-mode-map" "'scroll-up)(define-keyMan-mode-map"\177"'scroll-down)(define-keyMan-mode-map"n"'Man-next-section)(define-keyMan-mode-map"p"'Man-previous-section)(define-keyMan-mode-map"\en"'Man-next-manpage)(define-keyMan-mode-map"\ep"'Man-previous-manpage)(define-keyMan-mode-map">"'end-of-buffer)(define-keyMan-mode-map"<"'beginning-of-buffer)(define-keyMan-mode-map"."'beginning-of-buffer)(define-keyMan-mode-map"r"'Man-follow-manual-reference)(define-keyMan-mode-map"t"'toggle-truncate-lines)(define-keyMan-mode-map"g"'Man-goto-section)(define-keyMan-mode-map"s"'Man-goto-see-also-section)(define-keyMan-mode-map"k"'Man-kill)(define-keyMan-mode-map"q"'Man-quit)(define-keyMan-mode-map"m"'man)(define-keyMan-mode-map"?"'describe-mode));; ======================================================================;; utilities(defsubstMan-init-defvars()"Used for initialising variables based on the value of window-system.This is necessary if one wants to dump man.el with emacs.";; The following is necessary until fonts are implemented on;; terminals.(setqMan-fontify-manpage-flag(andMan-fontify-manpage-flagwindow-system))(defconstMan-uses-untabify-flagt;; don't use pr: it is buggy;; (or (not (file-readable-p "/etc/passwd"));; (/= 0 (apply 'call-process;; Man-untabify-command nil nil nil;; (append Man-untabify-command-args;; (list "/etc/passwd")))))"When non-nil use `untabify' instead of Man-untabify-command.")(defconstMan-sed-script(cond(Man-fontify-manpage-flagnil)((=0(call-processMan-sed-commandnilnilnilMan-sysv-sed-script))Man-sysv-sed-script)((=0(call-processMan-sed-commandnilnilnilMan-berkeley-sed-script))Man-berkeley-sed-script)(tnil))"Script for sed to nuke backspaces and ANSI codes from manpages.")(defvarMan-filter-list(list(consMan-sed-command(list(ifMan-sed-script(concat"-e '"Man-sed-script"'")"")"-e '/^[\001-\032][\001-\032]*$/d'""-e '/\e[789]/s///g'""-e '/Reformatting page. Wait/d'""-e '/Reformatting entry. Wait/d'""-e '/^[ \t]*Hewlett-Packard[ \t]Company[ \t]*-[ \t][0-9]*[ \t]-/d'""-e '/^[ \t]*Hewlett-Packard[ \t]*-[ \t][0-9]*[ \t]-.*$/d'""-e '/^[ \t][ \t]*-[ \t][0-9]*[ \t]-[ \t]*Formatted:.*[0-9]$/d'""-e '/^[ \t]*Page[ \t][0-9]*.*(printed[ \t][0-9\\/]*)$/d'""-e '/^Printed[ \t][0-9].*[0-9]$/d'""-e '/^[ \t]*X[ \t]Version[ \t]1[01].*Release[ \t][0-9]/d'""-e '/^[A-za-z].*Last[ \t]change:/d'""-e '/^Sun[ \t]Release[ \t][0-9].*[0-9]$/d'""-e '/[ \t]*Copyright [0-9]* UNIX System Laboratories, Inc.$/d'"))(consMan-awk-command(list"'\n""BEGIN { blankline=0; anonblank=0; }\n""/^$/ { if (anonblank==0) next; }\n""{ anonblank=1; }\n""/^$/ { blankline++; next; }\n""{ if (blankline>0) { print \"\"; blankline=0; } print $0; }\n""'"))(if(notMan-uses-untabify-flag)(consMan-untabify-commandMan-untabify-command-args)))"*Manpage cleaning filter command phrases.This variable contains a list of the following form:'((command-string phrase-string*)*)Each phrase-string is concatenated onto the command-string to form acommand filter. The (standard) output (and standard error) of the Un*xman command is piped through each command filter in the order thecommands appear in the association list. The final output is placed inthe manpage buffer."))(defsubstMan-match-substring(&optionalnstring)"Return the substring matched by the last search.Optional arg N means return the substring matched by the Nth parengrouping. Optional second arg STRING means return a substring fromthat string instead of from the current buffer."(if(nulln)(setqn0))(ifstring(substringstring(match-beginningn)(match-endn))(buffer-substring(match-beginningn)(match-endn))))(defsubstMan-make-page-mode-string()"Formats part of the mode line for Man mode."(format"%s page %d of %d"(or(nth2(nth(1-Man-current-page)Man-page-list))"")Man-current-page(lengthMan-page-list)))(defsubstMan-build-man-command()"Builds the entire background manpage and cleaning command."(let((command(concatmanual-program" "Man-switches" %s 2>/dev/null"))(flistMan-filter-list))(while(andflist(carflist))(let((pcom(car(carflist)))(pargs(cdr(carflist))))(setqcommand(concatcommand" | "pcom" "(mapconcat'(lambda(phrase)(if(not(stringpphrase))(error"Malformed Man-filter-list"))phrase)pargs" ")))(setqflist(cdrflist))))command))(defunMan-translate-references(ref)"Translates REF from \"chmod(2V)\" to \"2v chmod\" style.Leave it as is if already in that style. Possibly downcase andtranslate the section (see the Man-downcase-section-letters-flagand the Man-section-translations-alist variables)."(let((name"")(section"")(slistMan-section-translations-alist))(cond;; "chmod(2V)" case ?((string-match(concat"^"Man-reference-regexp"$")ref)(setqname(Man-match-substring1ref)section(Man-match-substring2ref)));; "2v chmod" case ?((string-match(concat"^\\("Man-section-regexp"\\) +\\("Man-name-regexp"\\)$")ref)(setqname(Man-match-substring2ref)section(Man-match-substring1ref))))(if(string=name"")ref; Return the reference as is(ifMan-downcase-section-letters-flag(setqsection(downcasesection)))(whileslist(let((s1(car(carslist)))(s2(cdr(carslist))))(setqslist(cdrslist))(ifMan-downcase-section-letters-flag(setqs1(downcases1)))(if(not(string=s1section))nil(setqsection(ifMan-downcase-section-letters-flag(downcases2)s2)slistnil))))(concatMan-specified-section-optionsection" "name))));; ======================================================================;; default man entry: get word under point(defsubstMan-default-man-entry()"Make a guess at a default manual entry.This guess is based on the text surrounding the cursor, and thedefault section number is selected from `Man-auto-section-alist'."(let(default-title)(save-excursion;; Default man entry title is any word the cursor is on, or if;; cursor not on a word, then nearest preceding word. Cannot;; use the current-word function because it skips the dots.(if(not(looking-at"[-a-zA-Z_.]"))(skip-chars-backward"^a-zA-Z"))(skip-chars-backward"-(a-zA-Z_0-9_.")(if(looking-at"(")(forward-char1))(setqdefault-title(buffer-substring(point)(progn(skip-chars-forward"-a-zA-Z0-9_.")(point))));; If looking at something like ioctl(2) or brc(1M), include the;; section number in the returned value. Remove text properties.(let((result(concatdefault-title(if(looking-at(concat"[ \t]*([ \t]*\\("Man-section-regexp"\\)[ \t]*)"))(format"(%s)"(Man-match-substring1))))))(set-text-properties0(lengthresult)nilresult)result))));; ======================================================================;; Top level command and background process sentinel;; For compatibility with older versions.;;;###autoload(defalias'manual-entry'man);;;###autoload(defunman(man-args)"Get a Un*x manual page and put it in a buffer.This command is the top-level command in the man package. It runs a Un*xcommand to retrieve and clean a manpage in the background and places theresults in a Man mode (manpage browsing) buffer. See variable`Man-notify-method' for what happens when the buffer is ready.If a buffer already exists for this man page, it will display immediately."(interactive(list(let*((default-entry(Man-default-man-entry))(input(read-string(format"Manual entry%s: "(if(string=default-entry"")""(format" (default %s)"default-entry))))))(if(string=input"")(if(string=default-entry"")(error"No man args given")default-entry)input))));; Init the man package variables, if not already done.(Man-init-defvars);; Possibly translate the "subject(section)" syntax into the;; "section subject" syntax and possibly downcase the section.(setqman-args(Man-translate-referencesman-args))(Man-getpage-in-backgroundman-args))(defunMan-getpage-in-background(topic)"Uses TOPIC to build and fire off the manpage and cleaning command."(let*((man-argstopic)(bufname(concat"*Man "man-args"*"))(buffer(get-bufferbufname)))(ifbuffer(Man-notify-when-readybuffer)(require'env)(message"Invoking %s %s in the background"manual-programman-args)(setqbuffer(generate-new-bufferbufname))(save-excursion(set-bufferbuffer)(setqMan-original-frame(selected-frame))(setqMan-argumentsman-args))(let((process-environment(copy-sequenceprocess-environment)));; Prevent any attempt to use display terminal fanciness.(setenv"TERM""dumb")(set-process-sentinel(start-processmanual-programbuffer"sh""-c"(format(Man-build-man-command)man-args))'Man-bgproc-sentinel)))))(defunMan-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-bufferman-buffer)Man-original-frame)))(cond((eqMan-notify-method'newframe);; Since we run asynchronously, perhaps while Emacs is waiting;; for input, we must not leave a different buffer current. We;; can't rely on the editor command loop to reselect the;; selected window's buffer.(save-excursion(set-bufferman-buffer)(make-frameMan-frame-parameters)))((eqMan-notify-method'pushy)(switch-to-bufferman-buffer))((eqMan-notify-method'bully)(andwindow-system(frame-live-psaved-frame)(select-framesaved-frame))(pop-to-bufferman-buffer)(delete-other-windows))((eqMan-notify-method'aggressive)(andwindow-system(frame-live-psaved-frame)(select-framesaved-frame))(pop-to-bufferman-buffer))((eqMan-notify-method'friendly)(andwindow-system(frame-live-psaved-frame)(select-framesaved-frame))(display-bufferman-buffer'not-this-window))((eqMan-notify-method'polite)(beep)(message"Manual buffer %s is ready"(buffer-nameman-buffer)))((eqMan-notify-method'quiet)(message"Manual buffer %s is ready"(buffer-nameman-buffer)))((or(eqMan-notify-method'meek)t)(message"")))))(defunMan-fontify-manpage()"Convert overstriking and underlining to the correct fonts.Same for the ANSI bold and normal escape sequences."(interactive)(message"Please wait: making up the %s man page..."Man-arguments)(goto-char(point-min))(while(search-forward"\e[1m"nilt)(delete-backward-char4)(put-text-property(point)(progn(if(search-forward"\e[0m"nil'move)(delete-backward-char4))(point))'faceMan-overstrike-face))(goto-char(point-min))(while(search-forward"_\b"nilt)(backward-delete-char2)(put-text-property(point)(1+(point))'faceMan-underline-face))(goto-char(point-min))(while(search-forward"\b_"nilt)(backward-delete-char2)(put-text-property(1-(point))(point)'faceMan-underline-face))(goto-char(point-min))(while(re-search-forward"\\(.\\)\\(\b\\1\\)+"nilt)(replace-match"\\1")(put-text-property(1-(point))(point)'faceMan-overstrike-face))(goto-char(point-min))(while(re-search-forward"o\b\\+\\|\\+\bo"nilt)(replace-match"o")(put-text-property(1-(point))(point)'face'bold))(goto-char(point-min))(while(re-search-forward"[-|]\\(\b[-|]\\)+"nilt)(replace-match"+")(put-text-property(1-(point))(point)'face'bold));; \255 is some kind of dash in Latin-1.(goto-char(point-min))(while(search-forward"\255"nilt)(replace-match"-"))(message"%s man page made up"Man-arguments))(defunMan-cleanup-manpage()"Remove overstriking and underlining from the current buffer."(interactive)(message"Please wait: cleaning up the %s man page..."Man-arguments)(if(or(interactive-p)(notMan-sed-script))(progn(goto-char(point-min))(while(search-forward"_\b"nilt)(backward-delete-char2))(goto-char(point-min))(while(search-forward"\b_"nilt)(backward-delete-char2))(goto-char(point-min))(while(re-search-forward"\\(.\\)\\(\b\\1\\)+"nilt)(replace-match"\\1"))(goto-char(point-min))(while(re-search-forward"\e\\[[0-9]+m"nilt)(replace-match""))(goto-char(point-min))(while(re-search-forward"o\b\\+\\|\\+\bo"nilt)(replace-match"o"))))(goto-char(point-min))(while(re-search-forward"[-|]\\(\b[-|]\\)+"nilt)(replace-match"+"));; \255 is some kind of dash in Latin-1.(goto-char(point-min))(while(search-forward"\255"nilt)(replace-match"-"))(message"%s man page cleaned up"Man-arguments))(defunMan-bgproc-sentinel(processmsg)"Manpage background process sentinel."(let((Man-buffer(process-bufferprocess))(delete-buffnil)(err-messnil))(if(null(buffer-nameMan-buffer));; deleted buffer(set-process-bufferprocessnil)(save-excursion(set-bufferMan-buffer)(let((case-fold-searchnil))(goto-char(point-min))(cond((or(looking-at"No \\(manual \\)*entry for")(looking-at"[^\n]*: nothing appropriate$"))(setqerr-mess(buffer-substring(point)(progn(end-of-line)(point)))delete-bufft))((not(and(eq(process-statusprocess)'exit)(=(process-exit-statusprocess)0)))(setqerr-mess(concat(buffer-nameMan-buffer)": process "(let((eos(1-(lengthmsg))))(if(=(arefmsgeos)?\n)(substringmsg0eos)msg))))(goto-char(point-max))(insert(format"\nprocess %s"msg))))(ifdelete-buff(kill-bufferMan-buffer)(ifMan-fontify-manpage-flag(Man-fontify-manpage)(Man-cleanup-manpage))(run-hooks'Man-cooked-hook)(Man-mode)(set-buffer-modified-pnil)));; Restore case-fold-search before calling;; Man-notify-when-ready because it may switch buffers.(if(notdelete-buff)(Man-notify-when-readyMan-buffer))(iferr-mess(errorerr-mess))))));; ======================================================================;; set up manual mode in buffer and build alists(defunMan-mode()"A mode for browsing Un*x manual pages.The following man commands are available in the buffer. Try\"\\[describe-key] <key> RET\" for more information:\\[man] Prompt to retrieve a new manpage.\\[Man-follow-manual-reference] Retrieve reference in SEE ALSO section.\\[Man-next-manpage] Jump to next manpage in circular list.\\[Man-previous-manpage] Jump to previous manpage in circular list.\\[Man-next-section] Jump to next manpage section.\\[Man-previous-section] Jump to previous manpage section.\\[Man-goto-section] Go to a manpage section.\\[Man-goto-see-also-section] Jumps to the SEE ALSO manpage section.\\[Man-quit] Deletes the manpage window, bury its buffer.\\[Man-kill] Deletes the manpage window, kill its buffer.\\[describe-mode] Prints this help text.The following variables may be of some use. Try\"\\[describe-variable] <variable-name> RET\" for more information:Man-notify-method What happens when manpage formatting is done.Man-downcase-section-letters-flag Force section letters to lower case.Man-circular-pages-flag Treat multiple manpage list as circular.Man-auto-section-alist List of major modes and their section numbers.Man-section-translations-alist List of section numbers and their Un*x equiv.Man-filter-list Background manpage filter command.Man-mode-line-format Mode line format for Man mode buffers.Man-mode-map Keymap bindings for Man mode buffers.Man-mode-hook Normal hook run on entry to Man mode.Man-section-regexp Regexp describing manpage section letters.Man-heading-regexp Regexp describing section headers.Man-see-also-regexp Regexp for SEE ALSO section (or your equiv).Man-first-heading-regexp Regexp for first heading on a manpage.Man-reference-regexp Regexp matching a references in SEE ALSO.Man-switches Background `man' command switches.The following key bindings are currently in effect in the buffer:\\{Man-mode-map}"(interactive)(setqmajor-mode'Man-modemode-name"Man"buffer-auto-save-file-namenilmode-line-formatMan-mode-line-formattruncate-linestbuffer-read-onlyt)(buffer-disable-undo(current-buffer))(auto-fill-mode-1)(use-local-mapMan-mode-map)(Man-build-page-list)(Man-strip-page-headers)(Man-unindent)(Man-goto-page1)(run-hooks'Man-mode-hook))(defsubstMan-build-section-alist()"Build the association list of manpage sections."(setqMan-sections-alistnil)(goto-char(point-min))(let((case-fold-searchnil))(while(re-search-forwardMan-heading-regexp(point-max)t)(aput'Man-sections-alist(Man-match-substring1))(forward-line1))))(defsubstMan-build-references-alist()"Build the association list of references (in the SEE ALSO section)."(setqMan-refpages-alistnil)(save-excursion(if(Man-find-sectionMan-see-also-regexp)(let((start(progn(forward-line1)(point)))(end(progn(Man-next-section1)(point)))hyphenated(runningpoint-1))(save-restriction(narrow-to-regionstartend)(goto-char(point-min))(back-to-indentation)(while(and(not(eobp))(/=(point)runningpoint))(setqrunningpoint(point))(if(re-search-forwardMan-reference-regexpendt)(let*((word(Man-match-substring0))(len(1-(lengthword))))(ifhyphenated(setqword(concathyphenatedword)hyphenatednil))(if(=(arefwordlen)?-)(setqhyphenated(substringword0len))(aput'Man-refpages-alistword))))(skip-chars-forward" \t\n,")))))))(defunMan-build-page-list()"Build the list of separate manpages in the buffer."(setqMan-page-listnil)(let((page-start(point-min))(page-end(point-max))(header""))(goto-charpage-start);; (switch-to-buffer (current-buffer))(debug)(while(not(eobp))(setqheader(if(looking-atMan-page-header-regexp)(Man-match-substring1)nil));; Go past both the current and the next Man-first-heading-regexp(if(re-search-forwardMan-first-heading-regexpnil'move2)(let((p(progn(beginning-of-line)(point))));; We assume that the page header is delimited by blank;; lines and that it contains at most one blank line. So;; if we back by three blank lines we will be sure to be;; before the page header but not before the possible;; previous page header.(search-backward"\n\n"nilt3)(if(re-search-forwardMan-page-header-regexpp'move)(beginning-of-line))))(setqpage-end(point))(setqMan-page-list(appendMan-page-list(list(list(copy-markerpage-start)(copy-markerpage-end)header))))(setqpage-startpage-end))))(defunMan-strip-page-headers()"Strip all the page headers but the first from the manpage."(let((buffer-read-onlynil)(case-fold-searchnil)(page-listMan-page-list)(page())(header""))(whilepage-list(setqpage(carpage-list))(and(nth2page)(goto-char(carpage))(re-search-forwardMan-first-heading-regexpnilt)(setqheader(buffer-substring(carpage)(match-beginning0)));; Since the awk script collapses all successive blank;; lines into one, and since we don't want to get rid of;; the fast awk script, one must choose between adding;; spare blank lines between pages when there were none and;; deleting blank lines at page boundaries when there were;; some. We choose the first, so we comment the following;; line.;; (setq header (concat "\n" header)))(while(search-forwardheader(nth1page)t)(replace-match"")))(setqpage-list(cdrpage-list)))))(defunMan-unindent()"Delete the leading spaces that indent the manpage."(let((buffer-read-onlynil)(case-fold-searchnil)(page-listMan-page-list))(whilepage-list(let((page(carpage-list))(indent"")(nindent0))(narrow-to-region(carpage)(car(cdrpage)))(ifMan-uses-untabify-flag(untabify(point-min)(point-max)))(if(catch'unindent(goto-char(point-min))(if(not(re-search-forwardMan-first-heading-regexpnilt))(throw'unindentnil))(beginning-of-line)(setqindent(buffer-substring(point)(progn(skip-chars-forward" ")(point))))(setqnindent(lengthindent))(if(zeropnindent)(throw'unindentnil))(setqindent(concatindent"\\|$"))(goto-char(point-min))(while(not(eobp))(if(looking-atindent)(forward-line1)(throw'unindentnil)))(goto-char(point-min)))(while(not(eobp))(or(eolp)(delete-charnindent))(forward-line1)))(setqpage-list(cdrpage-list))))));; ======================================================================;; Man mode commands(defunMan-next-section(n)"Move point to Nth next section (default 1)."(interactive"p")(let((case-fold-searchnil))(if(looking-atMan-heading-regexp)(forward-line1))(if(re-search-forwardMan-heading-regexp(point-max)tn)(beginning-of-line)(goto-char(point-max)))))(defunMan-previous-section(n)"Move point to Nth previous section (default 1)."(interactive"p")(let((case-fold-searchnil))(if(looking-atMan-heading-regexp)(forward-line-1))(if(re-search-backwardMan-heading-regexp(point-min)tn)(beginning-of-line)(goto-char(point-min)))))(defunMan-find-section(section)"Move point to SECTION if it exists, otherwise don't move point.Returns t if section is found, nil otherwise."(let((curpos(point))(case-fold-searchnil))(goto-char(point-min))(if(re-search-forward(concat"^"section)(point-max)t)(progn(beginning-of-line)t)(goto-charcurpos)nil)))(defunMan-goto-section()"Query for section to move point to."(interactive)(aput'Man-sections-alist(let*((default(aheadsymMan-sections-alist))(completion-ignore-caset)chosen(prompt(concat"Go to section: (default "default") ")))(setqchosen(completing-readpromptMan-sections-alist))(if(or(notchosen)(string=chosen""))defaultchosen)))(Man-find-section(aheadsymMan-sections-alist)))(defunMan-goto-see-also-section()"Move point the the \"SEE ALSO\" section.Actually the section moved to is described by `Man-see-also-regexp'."(interactive)(if(not(Man-find-sectionMan-see-also-regexp))(error(concat"No "Man-see-also-regexp" section found in the current manpage"))))(defunMan-follow-manual-reference(reference)"Get one of the manpages referred to in the \"SEE ALSO\" section.Specify which reference to use; default is based on word at point."(interactive(if(notMan-refpages-alist)(error"There are no references in the current man page")(list(let*((default(or(car(all-completions(save-excursion(skip-syntax-backward"w()")(skip-chars-forward" \t")(let((word(current-word)));; strip a trailing '-':(if(string-match"-$"word)(substringword0(match-beginning0))word)))Man-refpages-alist))(aheadsymMan-refpages-alist)))chosen(prompt(concat"Refer to: (default "default") ")))(setqchosen(completing-readpromptMan-refpages-alistnilt))(if(or(notchosen)(string=chosen""))defaultchosen)))))(if(notMan-refpages-alist)(error"Can't find any references in the current manpage")(aput'Man-refpages-alistreference)(Man-getpage-in-background(Man-translate-references(aheadsymMan-refpages-alist)))))(defunMan-kill()"Kill the buffer containing the manpage."(interactive)(let((buff(current-buffer)))(delete-windows-onbuff)(kill-bufferbuff))(if(andwindow-system(or(eqMan-notify-method'newframe)(andpop-up-frames(eqMan-notify-method'bully))))(delete-frame)))(defunMan-quit()"Bury the buffer containing the manpage."(interactive)(let((buff(current-buffer)))(delete-windows-onbuff)(bury-bufferbuff))(if(andwindow-system(or(eqMan-notify-method'newframe)(andpop-up-frames(eqMan-notify-method'bully))))(delete-frame)))(defunMan-goto-page(page)"Go to the manual page on page PAGE."(interactive(if(notMan-page-list)(let((argsMan-arguments))(kill-buffer(current-buffer))(error"Can't find the %s manpage"args))(if(=(lengthMan-page-list)1)(error"You're looking at the only manpage in the buffer")(list(read-minibuffer(format"Go to manpage [1-%d]: "(lengthMan-page-list)))))))(if(notMan-page-list)(let((argsMan-arguments))(kill-buffer(current-buffer))(error"Can't find the %s manpage"args)))(if(or(<page1)(>page(lengthMan-page-list)))(error"No manpage %d found"page))(let*((page-range(nth(1-page)Man-page-list))(page-start(carpage-range))(page-end(car(cdrpage-range))))(setqMan-current-pagepageMan-page-mode-string(Man-make-page-mode-string))(widen)(goto-charpage-start)(narrow-to-regionpage-startpage-end)(Man-build-section-alist)(Man-build-references-alist)(goto-char(point-min))))(defunMan-next-manpage()"Find the next manpage entry in the buffer."(interactive)(if(=(lengthMan-page-list)1)(error"This is the only manpage in the buffer"))(if(<Man-current-page(lengthMan-page-list))(Man-goto-page(1+Man-current-page))(ifMan-circular-pages-flag(Man-goto-page1)(error"You're looking at the last manpage in the buffer"))))(defunMan-previous-manpage()"Find the previous manpage entry in the buffer."(interactive)(if(=(lengthMan-page-list)1)(error"This is the only manpage in the buffer"))(if(>Man-current-page1)(Man-goto-page(1-Man-current-page))(ifMan-circular-pages-flag(Man-goto-page(lengthMan-page-list))(error"You're looking at the first manpage in the buffer"))))(provide'man);;; man.el ends here