Anonymous avatar Anonymous committed 27bc7f2

Import from CVS: tag r19-15b4

Comments (0)

Files changed (35)

 							-*- indented-text -*-
+to 19.15 beta4
+-- Default JPEG image loading is now old tempfile code, but should work again.
+-- Miscellaneous bug fixes courtesy of Christoph Wedler
+-- mic-paren.el courtesy of Mikael Sjödin
+-- lpr.el/ps-print.el - Allow dynamic expansion of
+   lpr-switches/ps-lpr-switches.
+-- Lisp Bug fixes
+-- Install info files compressed (courtesy of Joseph J Nuspl)
+-- Default locking for Linux is now .lock locking
+
 to 19.15 beta3
 
 -- EDT/TPU modes synched from GNU Emacs, should actually work for the first
                     vm* w3* xemacs* ; do \
 	     ${INSTALL_DATA} ${srcdir}/info/$$f ${infodir}/$$f ; \
 	     chmod 0644 ${infodir}/$$f; \
+	     gzip -9 ${infodir}/$$f; \
 	   done); \
 	else true; fi
 	cd ${srcdir}/etc; for page in xemacs etags ctags gnuserv \
 
 if [ "${dynamic}" = "yes" ]; then
   case "${opsys}" in
-    hpux8		) opsys=hpux8shr ;;
-    hpux9		) opsys=hpux9shr ;;
-    hpux10		) opsys=hpux10shr ;;
-    sunos4-0		) opsys=sunos4-0shr ;;
-    sunos4-1		) opsys=sunos4-1shr ;;
-    sunos4-1-2		) opsys=sunos4-1-2shr ;;
-    sunos4-1-3		) opsys=sunos4-1-3shr ;;
+    hpux8		) opsys=hpux8-shr ;;
+    hpux9		) opsys=hpux9-shr ;;
+    hpux10		) opsys=hpux10-shr ;;
+    sunos4-0		) opsys=sunos4-0-shr ;;
+    sunos4-1		) opsys=sunos4-1-shr ;;
+    sunos4-1-2		) opsys=sunos4-1-2-shr ;;
+    sunos4-1-3		) opsys=sunos4-1-3-shr ;;
     sco5		) opsys=sco5-shr ;;
   esac
 elif [ "${dynamic}" = "no" ]; then
 #### Some systems specify a CPP to use unless we are using GCC.
 #### Now that we know whether we are using GCC, we can decide whether
 #### to use that one.
-if [ "x$NON_GNU_CPP" = x ] || [ x$GCC = x1 ]
-then true
+
+#### Also, GNU CPP by default defines certain add'l macros that could
+#### hurt us when generating makefiles. We want to switch off these
+#### add'l macros for the purpose of generating makefiles.
+
+CPPFLAGS_MAKEFILEGEN=""
+if [ "x$GCC" = x1 ] ; then
+  CPPFLAGS_MAKEFILEGEN=" -undef "
+elif [ "x$NON_GNU_CPP" = x ] ; then
+  true
 else
   if [ "x$CPP" = x ]; then
     if [ "${with_lcc}" = "yes" ] && [ "${NON_GNU_CPP}" = "yes" ] ; then
 ( cd ./src;
   rm -f junk.c;
   sed -e '\''s/^# Generated.*//'\'' -e '\''s%/\*\*/#.*%%'\'' < Makefile.in > junk.c;
-  eval `echo ${CPP} -I. -I${topsrcdir}/src ${CPPFLAGS} junk.c \>junk.cpp`;
+  eval `echo ${CPP} ${CPPFLAGS_MAKEFILEGEN} -I. -I${topsrcdir}/src ${CPPFLAGS} junk.c \>junk.cpp`;
   < junk.cpp							'\
 '    sed -e '\''s/^#.*//'\''					'\
 '	-e '\''s/^[ \f\t][ \f\t]*$//'\''			'\
 ( cd ./lwlib;
   rm -f junk.c;
   sed -e '\''s/^# Generated.*//'\'' -e '\''s%/\*\*/#.*%%'\'' < Makefile.in > junk.c;
-  eval `echo ${CPP} -I. -I${topsrcdir}/src ${CPPFLAGS} junk.c \>junk.cpp`;
+  eval `echo ${CPP} ${CPPFLAGS_MAKEFILEGEN} -I. -I${topsrcdir}/src ${CPPFLAGS} junk.c \>junk.cpp`;
   < junk.cpp							'\
 '    sed -e '\''s/^#.*//'\''					'\
 '	-e '\''s/^[ \f\t][ \f\t]*$//'\''			'\
 ( cd ./lib-src;
   rm -f junk.c;
   sed -e '\''s/^# Generated.*//'\'' -e '\''s%/\*\*/#.*%%'\'' < Makefile.in > junk.c;
-  eval `echo ${CPP} -I. -I${topsrcdir}/src ${CPPFLAGS} junk.c \>junk.cpp`;
+  eval `echo ${CPP} ${CPPFLAGS_MAKEFILEGEN} -I. -I${topsrcdir}/src ${CPPFLAGS} junk.c \>junk.cpp`;
   < junk.cpp							'\
 '    sed -e '\''s/^#.*//'\''					'\
 '	-e '\''s/^[ \f\t][ \f\t]*$//'\''			'\
 ( cd ./dynodump;
   rm -f junk.c;
   sed -e '\''s/^# Generated.*//'\'' -e '\''s%/\*\*/#.*%%'\'' < Makefile.in > junk.c;
-  eval `echo ${CPP} -I. -I${topsrcdir}/src ${CPPFLAGS} junk.c \>junk.cpp`;
+  eval `echo ${CPP} ${CPPFLAGS_MAKEFILEGEN} -I. -I${topsrcdir}/src ${CPPFLAGS} junk.c \>junk.cpp`;
   < junk.cpp							'\
 '    sed -e '\''s/^#.*//'\''					'\
 '	-e '\''s/^[ \f\t][ \f\t]*$//'\''			'\
 ( cd ./man;
   rm -f junk.c;
   sed -e '\''s/^# Generated.*//'\'' -e '\''s%/\*\*/#.*%%'\'' < Makefile.in > junk.c;
-  eval `echo ${CPP} -I. -I${topsrcdir}/src ${CPPFLAGS} junk.c \>junk.cpp`;
+  eval `echo ${CPP} ${CPPFLAGS_MAKEFILEGEN} -I. -I${topsrcdir}/src ${CPPFLAGS} junk.c \>junk.cpp`;
   < junk.cpp							'\
 '    sed -e '\''s/^#.*//'\''					'\
 '	-e '\''s/^[ \f\t][ \f\t]*$//'\''			'\
 ( cd ./lwlib/energize;
   rm -f junk.c;
   sed -e '\''s/^# Generated.*//'\'' -e '\''s%/\*\*/#.*%%'\'' < Makefile.in > junk.c;
-  eval `echo ${CPP} -I. -I${topsrcdir}/src ${CPPFLAGS} junk.c \>junk.cpp`;
+  eval `echo ${CPP} ${CPPFLAGS_MAKEFILEGEN} -I. -I${topsrcdir}/src ${CPPFLAGS} junk.c \>junk.cpp`;
   < junk.cpp							'\
 '    sed -e '\''s/^#.*//'\''					'\
 '	-e '\''s/^[ \f\t][ \f\t]*$//'\''			'\

lisp/comint/telnet.el

 ; initialization on first load.
 (if telnet-mode-map
     nil
-  (setq telnet-mode-map (nconc (make-sparse-keymap) comint-mode-map))
+  ;; FSF
+  ;; (setq telnet-mode-map (nconc (make-sparse-keymap) comint-mode-map))
+  (setq telnet-mode-map (make-sparse-keymap))
+  (set-keymap-parents telnet-mode-map (list comint-mode-map))
   (define-key telnet-mode-map "\C-m" 'telnet-send-input)
 ;  (define-key telnet-mode-map "\C-j" 'telnet-send-input)
   (define-key telnet-mode-map "\C-c\C-q" 'send-process-next-char)

lisp/electric/ebuff-menu.el

 (defvar electric-buffer-menu-mode-map nil)
 
 ;;;###autoload
-(defun electric-buffer-list (arg)
+(defun electric-buffer-list (&optional files-only)
   "Pops up a buffer describing the set of Emacs buffers.
 Vaguely like ITS lunar select buffer; combining typeoutoid buffer
 listing with menuoid buffer selection.
 
 Calls value of `electric-buffer-menu-mode-hook' on entry if non-nil.
 
+Non-null optional arg FILES-ONLY means mention only file buffers.
+When called from Lisp code, FILES-ONLY may be a regular expression,
+in which case only buffers whose names match that expression are listed,
+or an arbitrary predicate function.
+
 \\{electric-buffer-menu-mode-map}" 
-  (interactive "P")
+  (interactive (list (if current-prefix-arg t nil)))
   (let (select buffer)
     (save-window-excursion
-      (save-window-excursion (list-buffers arg))
+      (save-window-excursion (list-buffers files-only))
       (setq buffer (window-buffer (Electric-pop-up-window "*Buffer List*")))
       (unwind-protect
 	  (progn

lisp/ilisp/ilisp-out.el

   "Find the window directly below us, if any.  This is probably the 
  window from which enlarge-window would steal lines."
   (if (or (not (string-match "XEmacs" emacs-version))
-	  (< emacs-minor-version 12))
+	  (and (= emacs-major-version 19)
+	       (< emacs-minor-version 12)))
       (let* ((bottom (nth 3 (window-edges window)))
 	     (window* nil)
 	     (win window))
 (defun ilisp-find-top-left-most-window ()
   "Return the leftmost topmost window on the current screen."
   (if (or (not (string-match "XEmacs" emacs-version))
-	  (< emacs-minor-version 12))
+	  (and (= emacs-major-version 19)
+	       (< emacs-minor-version 12)))
       (let* ((window* (selected-window))
 	     (edges* (window-edges window*))
 	     (win nil)

lisp/modes/cc-mode.el

 ;; cmacexp is lame because it uses no preprocessor symbols.
 ;; It isn't very extensible either -- hardcodes /lib/cpp.
 ;; [I add it here only because c-mode has it -- BAW]
-;(autoload 'c-macro-expand "cmacexp"
-;  "Display the result of expanding all C macros occurring in the region.
-;The expansion is entirely correct because it uses the C preprocessor."
-;  t)
+(autoload 'c-macro-expand "cmacexp"
+  "Display the result of expanding all C macros occurring in the region.
+The expansion is entirely correct because it uses the C preprocessor."
+  t)
 
 
 ;; constant regular expressions for looking at various constructs
 ;; main entry points for the modes
 (defconst c-list-of-mode-names nil)
 
+;;;###autoload
 (defun c-mode ()
   "Major mode for editing K&R and ANSI C code.
 To submit a problem report, enter `\\[c-submit-bug-report]' from a
   (run-hooks 'c-mode-hook))
 (setq c-list-of-mode-names (cons "C" c-list-of-mode-names))
 
+;;;###autoload
 (defun c++-mode ()
   "Major mode for editing C++ code.
 To submit a problem report, enter `\\[c-submit-bug-report]' from a
   (run-hooks 'c++-mode-hook))
 (setq c-list-of-mode-names (cons "C++" c-list-of-mode-names))
 
+;;;###autoload
 (defun objc-mode ()
   "Major mode for editing Objective C code.
 To submit a problem report, enter `\\[c-submit-bug-report]' from an
   (run-hooks 'objc-mode-hook))
 (setq c-list-of-mode-names (cons "ObjC" c-list-of-mode-names))
 
+;;;###autoload
 (defun java-mode ()
   "Major mode for editing Java code.
 To submit a problem report, enter `\\[c-submit-bug-report]' from an
 	)))
    stylevars))
 
+;;;###autoload
 (defun c-set-style (stylename)
   "Set cc-mode variables to use one of several different indentation styles.
 STYLENAME is a string representing the desired style from the list of

lisp/modes/eiffel3.el

-;;; $Id: eiffel3.el,v 1.1.1.2 1996/12/18 03:44:36 steve Exp $
+;;; $Id: eiffel3.el,v 1.1.1.3 1996/12/18 04:03:07 steve Exp $
 ;;;--------------------------------------------------------------------------
 ;;; TowerEiffel -- Copyright (c) 1993-1996 Tower Technology Corporation. 
 ;;; All Rights Reserved.
     (modify-syntax-entry ?> "." table)
     (modify-syntax-entry ?& "." table)
     (modify-syntax-entry ?| "." table)
-    (modify-syntax-entry ?; "." table)
+    (modify-syntax-entry ?\; "." table)
     (modify-syntax-entry ?: "." table)
     (modify-syntax-entry ?! "." table)
     (modify-syntax-entry ?. "." table)

lisp/packages/buff-menu.el

   (define-key Buffer-menu-mode-map "t" 'Buffer-menu-visit-tags-table)
   (define-key Buffer-menu-mode-map "%" 'Buffer-menu-toggle-read-only)
   (define-key Buffer-menu-mode-map "g" 'revert-buffer)
-  (define-key Buffer-menu-mode-map [mouse-2] 'Buffer-menu-mouse-select)
-  (define-key Buffer-menu-mode-map [mouse-3] 'Buffer-menu-popup-menu)
+  (define-key Buffer-menu-mode-map 'button2 'Buffer-menu-mouse-select)
+  (define-key Buffer-menu-mode-map 'button3 'Buffer-menu-popup-menu)
   )
 
 ;; Buffer Menu mode is suitable only for specially formatted data.
 (make-variable-buffer-local 'list-buffers-identification)
 
 ;; XEmacs
+;;;###autoload
 (defvar list-buffers-directory)
+
+;;;###autoload
 (make-variable-buffer-local 'list-buffers-directory)
 
 ;; #### not synched

lisp/packages/compile.el

 (defvar grep-history nil)
 
 ;; XEmacs
-(defconst compilation-font-lock-keywords (purecopy
+(defvar compilation-font-lock-keywords (purecopy
   (list
    '("^[-_.\"A-Za-z0-9/+]+\\(:\\|, line \\)[0-9]+: \\([wW]arning:\\).*$" .
      font-lock-keyword-face)

lisp/packages/jwz-man.el

-;;; man.el --- browse UNIX manual pages
-;; Keywords: help
-
-;; Copyright (C) 1985, 1993, 1994, 1996 Free Software Foundation, Inc.
-;;
-;; This file is part of XEmacs.
-
-;; XEmacs 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.
-
-;; XEmacs 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 XEmacs; see the file COPYING.  If not, write to the Free
-;; Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
-
-;; This file defines "manual-entry", and the remaining definitions all
-;; begin with "Manual-".  This makes the autocompletion on "M-x man" work.
-;; 
-;; Eviscerated 26-Jun-96 by Jamie Zawinski <jwz@netscape.com>.
-;; All that stuff about looking at $MANPATH and building up lists of 
-;; directories was bullshit.  Now we just invoke "man" and format the
-;; output, end of story.
-;;
-;; [ older changelog entries removed, since they're all about code that
-;;   I've deleted. ]
-
-(defvar Manual-program "man" "\
-*Name of the program to invoke in order to format the source man pages.")
-
-(defvar Manual-buffer-view-mode t "\
-*Whether manual buffers should be placed in view-mode.
-nil means leave the buffer in fundamental-mode in another window.
-t means use `view-buffer' to display the man page in the current window.
-Any other value means use `view-buffer-other-window'.")
-
-(defvar Manual-mode-hook nil
-  "Function or functions run on entry to Manual-mode.")
-
-(defvar Manual-page-history nil "\
-A list of names of previously visited man page buffers.")
-
-
-;; New variables.
-
-(make-face 'man-italic)
-(or (face-differs-from-default-p 'man-italic)
-    (copy-face 'italic 'man-italic))
-;; XEmacs (from Darrell Kindred): underlining is annoying due to
-;; large blank spaces in this face.
-;; (or (face-differs-from-default-p 'man-italic)
-;;    (set-face-underline-p 'man-italic t))
-
-(make-face 'man-bold)
-(or (face-differs-from-default-p 'man-bold)
-    (copy-face 'bold 'man-bold))
-(or (face-differs-from-default-p 'man-bold)
-    (copy-face 'man-italic 'man-bold))
-
-(make-face 'man-heading)
-(or (face-differs-from-default-p 'man-heading)
-    (copy-face 'man-bold 'man-heading))
-
-(make-face 'man-xref)
-(or (face-differs-from-default-p 'man-xref)
-    (set-face-underline-p 'man-xref t))
-
-(defvar Manual-mode-map
-  (let ((m (make-sparse-keymap)))
-    (set-keymap-name m 'Manual-mode-map)
-    (define-key m "l" 'Manual-last-page)
-    (define-key m 'button2 'Manual-follow-xref)
-    (define-key m 'button3 'Manual-popup-menu)
-    m))
-
-;;;###autoload
-(defun manual-entry (topic &optional arg silent)
-  "Display the Unix manual entry (or entries) for TOPIC."
-  (interactive
-   (list (let* ((fmh "-A-Za-z0-9_.")
-		(default (save-excursion
-			   (buffer-substring
-			    (progn
-			      (re-search-backward "\\sw" nil t)
-			      (skip-chars-backward fmh) (point))
-			    (progn (skip-chars-forward fmh) (point)))))
-		(thing (read-string
-			(if (equal default "") "Manual entry: "
-			  (concat "Manual entry: (default " default ") ")))))
-	   (if (equal thing "") default thing))
-	 (prefix-numeric-value current-prefix-arg)))
-  ;;(interactive "sManual entry (topic): \np")
-  (or arg (setq arg 1))
-  (let (section apropos-mode)
-    (let ((case-fold-search nil))
-      (if (and (null section)
-	       (string-match "\\`[ \t]*\\([^( \t]+\\)[ \t]*(\\(.+\\))[ \t]*\\'"
-			     topic))
-	  (setq section (substring topic (match-beginning 2)
-				   (match-end 2))
-		topic (substring topic (match-beginning 1)
-				 (match-end 1)))
-	(if (string-match "\\`[ \t]*-k[ \t]+\\([^ \t]+\\)\\'" topic)
-	    (setq section "-k"
-		  topic (substring topic (match-beginning 1))))))
-
-    ;; jwz: turn section "3x11" and "3n" into "3".
-    (if (and section (string-match "\\`\\([0-9]+\\)[^0-9]" section))
-	(setq section (substring section 0 (match-end 1))))
-    (if (equal section "-k")
-	(setq apropos-mode t))
-
-    (let ((bufname (cond (apropos-mode
-			  (concat "*man apropos " topic "*"))
-			 (t
-			  (concat "*man " topic
-				  (if section (concat "." section) "")
-				  "*"))))
-	  (temp-buffer-show-function 
-	   (cond ((eq 't Manual-buffer-view-mode)
-		  'view-buffer)
-		 ((eq 'nil Manual-buffer-view-mode)
-		  temp-buffer-show-function)
-		 (t
-		  'view-buffer-other-window))))
-
-      (cond ((get-buffer bufname)
-	     ;; reselect an old man page buffer if it exists already.
-	     (save-excursion
-	       (set-buffer (get-buffer bufname))
-	       (Manual-mode))
-	     (if temp-buffer-show-function
-		 (funcall temp-buffer-show-function (get-buffer bufname))
-	       (display-buffer bufname)))
-	    (t
-	     (with-output-to-temp-buffer bufname
-	       (buffer-disable-undo standard-output)
-	       (save-excursion
-		 (set-buffer standard-output)
-		 (setq buffer-read-only nil)
-		 (erase-buffer)
-
-		 (let ((args (list topic))
-		       args-string)
-		   (if section
-		       (setq args
-			     (if (eq system-type 'usg-unix-v)
-				 (cons "-s" (cons section args))
-			       (cons section args))))
-		   (setq args-string
-			 (mapconcat 'identity (cons Manual-program args) " "))
-		   (if (string-match "\\`\\([^ \t/]*/\\)+" args-string)
-		       (setq args-string
-			     (substring args-string (match-end 0))))
-
-		   (message "%s (running...)" args-string)
-		   (apply 'call-process Manual-program nil t nil args)
-
-		   (if (< (buffer-size) 200)
-		       (progn
-			 (goto-char (point-min))
-			 (error (buffer-substring (point)
-						  (progn (end-of-line)
-							 (point))))))
-
-		   (message "%s (cleaning...)" args-string)
-		   (Manual-nuke-nroff-bs apropos-mode)
-		   (message "%s (done.)" args-string)
-		   )
-
-		 (set-buffer-modified-p nil)
-		 (Manual-mode)
-		 ))))
-      (setq Manual-page-history
-	    (cons (buffer-name)
-		  (delete (buffer-name) Manual-page-history)))))
-  (message nil)
-  t)
-
-(defun Manual-mode ()
-  (kill-all-local-variables)
-  (setq buffer-read-only t)
-  (use-local-map Manual-mode-map)
-  (setq major-mode 'Manual-mode
-	mode-name "Manual")
-  ;; man pages with long lines are buggy!
-  ;; This looks slightly better if they only
-  ;; overran by a couple of chars.
-  (setq truncate-lines t)
-  ;; turn off horizontal scrollbars in this buffer
-  (set-specifier scrollbar-height (cons (current-buffer) 0))
-  (run-hooks 'Manual-mode-hook))
-
-(defun Manual-last-page ()
-  (interactive)
-  (while (or (not (get-buffer (car (or Manual-page-history
-				       (error "No more history.")))))
-	     (eq (get-buffer (car Manual-page-history)) (current-buffer)))
-    (setq Manual-page-history (cdr Manual-page-history)))
-  (switch-to-buffer (car Manual-page-history)))
-
-
-(defmacro Manual-delete-char (n)
-  ;; in v19, delete-char is compiled as a function call, but delete-region
-  ;; is byte-coded, so it's much faster.  (We were spending 40% of our time
-  ;; in delete-char alone.)
-  (list 'delete-region '(point) (list '+ '(point) n)))
-
-;; Hint: BS stands form more things than "back space"
-(defun Manual-nuke-nroff-bs (&optional apropos-mode)
-  (interactive "*")
-  ;;
-  ;; turn underlining into italics
-  ;;
-  (goto-char (point-min))
-  (while (search-forward "_\b" nil t)
-    ;; searching for underscore-backspace and then comparing the following
-    ;; chars until the sequence ends turns out to be much faster than searching
-    ;; for a regexp which matches the whole sequence.
-    (let ((s (match-beginning 0)))
-      (goto-char s)
-      (while (and (= (following-char) ?_)
-		  (= (char-after (1+ (point))) ?\b))
-	(Manual-delete-char 2)
-	(forward-char 1))
-      (set-extent-face (make-extent s (point)) 'man-italic)))
-  ;;
-  ;; turn overstriking into bold
-  ;;
-  (goto-char (point-min))
-  (while (re-search-forward "\\([^\n]\\)\\(\b\\1\\)" nil t)
-    ;; Surprisingly, searching for the above regexp is faster than searching
-    ;; for a backspace and then comparing the preceding and following chars,
-    ;; I presume because there are many false matches, meaning more funcalls
-    ;; to re-search-forward.
-    (let ((s (match-beginning 0)))
-      (goto-char s)
-      ;; Some systems (SGI) overstrike multiple times, eg, "M\bM\bM\bM".
-      (while (looking-at "\\([^\n]\\)\\(\b\\1\\)+")
-	(delete-region (+ (point) 1) (match-end 0))
-	(forward-char 1))
-      (set-extent-face (make-extent s (point)) 'man-bold)))
-  ;;
-  ;; hack bullets: o^H+ --> +
-  (goto-char (point-min))
-  (while (search-forward "\b" nil t)
-    (Manual-delete-char -2))
-
-  (if (> (buffer-size) 100) ; minor kludge
-      (Manual-nuke-nroff-bs-footers))
-  ;;
-  ;; turn subsection header lines into bold
-  ;;
-  (goto-char (point-min))
-  (if apropos-mode
-      (while (re-search-forward "[a-zA-Z0-9] ([0-9]" nil t)
-	(forward-char -2)
-	(delete-backward-char 1))
-
-    ;;    (while (re-search-forward "^[^ \t\n]" nil t)
-    ;;      (set-extent-face (make-extent (match-beginning 0)
-    ;;                                   (progn (end-of-line) (point)))
-    ;;                      'man-heading))
-
-    ;; boldface the first line
-    (if (looking-at "[^ \t\n].*$")
-	(set-extent-face (make-extent (match-beginning 0) (match-end 0))
-			 'man-bold))
-
-    ;; boldface subsequent title lines
-    ;; Regexp to match section headers changed to match a non-indented
-    ;; line preceded by a blank line and followed by an indented line. 
-    ;; This seems to work ok for manual pages but gives better results
-    ;; with other nroff'd files
-    (while (re-search-forward "\n\n\\([^ \t\n].*\\)\n[ \t]+[^ \t\n]" nil t)
-      (goto-char (match-end 1))
-      (set-extent-face (make-extent (match-beginning 1) (match-end 1))
-		       'man-heading)
-      (forward-line 1))
-    )
-
-  ;; Zap ESC7,  ESC8, and ESC9
-  ;; This is for Sun man pages like "man 1 csh"
-  (goto-char (point-min))
-  (while (re-search-forward "\e[789]" nil t)
-    (replace-match ""))
-  
-  ;; Nuke blanks lines at start.
-  ;;  (goto-char (point-min))
-  ;;  (skip-chars-forward "\n")
-  ;;  (delete-region (point-min) (point))
-
-  (Manual-mouseify-xrefs)
-  )
-
-(fset 'nuke-nroff-bs 'Manual-nuke-nroff-bs) ; use old name
-
-
-(defun Manual-nuke-nroff-bs-footers ()
-  ;; Nuke headers and footers.
-  ;;
-  ;; nroff assumes pages are 66 lines high.  We assume that, and that the
-  ;; first and last line on each page is expendible.  There is no way to
-  ;; tell the difference between a page break in the middle of a paragraph
-  ;; and a page break between paragraphs (the amount of extra whitespace
-  ;; that nroff inserts is the same in both cases) so this might strip out
-  ;; a blank line were one should remain.  I think that's better than
-  ;; leaving in a blank line where there shouldn't be one.  (Need I say
-  ;; it: FMH.)
-  ;;
-  ;; Note that if nroff spits out error messages, pages will be more than
-  ;; 66 lines high, and we'll lose badly.  That's ok because standard
-  ;; nroff doesn't do any diagnostics, and the "gnroff" wrapper for groff
-  ;; turns off error messages for compatibility.  (At least, it's supposed
-  ;; to.)
-  ;; 
-  (goto-char (point-min))
-  ;; first lose the status output
-  (let ((case-fold-search t))
-    (if (and (not (looking-at "[^\n]*warning"))
-	     (looking-at "Reformatting.*\n"))
-	(delete-region (match-beginning 0) (match-end 0))))
-
-  ;; kludge around a groff bug where it won't keep quiet about some
-  ;; warnings even with -Wall or -Ww.
-  (cond ((looking-at "grotty:")
-	 (while (looking-at "grotty:")
-	   (delete-region (point) (progn (forward-line 1) (point))))
-	 (if (looking-at " *done\n")
-	     (delete-region (point) (match-end 0)))))
-
-  (let ((pages '())
-	p)
-    ;; collect the page boundary markers before we start deleting, to make
-    ;; it easier to strip things out without changing the page sizes.
-    (while (not (eobp))
-      (forward-line 66)
-      (setq pages (cons (point-marker) pages)))
-    (setq pages (nreverse pages))
-    (while pages
-      (goto-char (car pages))
-      (set-marker (car pages) nil)
-      ;;
-      ;; The lines are: 3 blank; footer; 6 blank; header; 3 blank.
-      ;; We're in between the previous footer and the following header,
-      ;;
-      ;; First lose 3 blank lines, the header, and then 3 more.
-      ;;
-      (setq p (point))
-      (skip-chars-forward "\n")
-      (delete-region p (point))
-      (and (looking-at "[^\n]+\n\n?\n?\n?")
-	   (delete-region (match-beginning 0) (match-end 0)))
-      ;;
-      ;; Next lose the footer, and the 3 blank lines after, and before it.
-      ;; But don't lose the last footer of the manual entry; that contains
-      ;; the "last change" date, so it's not completely uninteresting.
-      ;; (Actually lose all blank lines before it; sh(1) needs this.)
-      ;;
-      (skip-chars-backward "\n")
-      (beginning-of-line)
-      (if (null (cdr pages))
-	  nil
-	(and (looking-at "[^\n]+\n\n?\n?\n?")
-	     (delete-region (match-beginning 0) (match-end 0))))
-      (setq p (point))
-      (skip-chars-backward "\n")
-      (if (> (- p (point)) 4)
-	  (delete-region (+ 2 (point)) p)
-	(delete-region (1+ (point)) p))
-;      (and (looking-at "\n\n?\n?")
-;	   (delete-region (match-beginning 0) (match-end 0)))
-
-      (setq pages (cdr pages)))
-    ;;
-    ;; Now nuke the extra blank lines at the beginning and end.
-    (goto-char (point-min))
-    (if (looking-at "\n+")
-	(delete-region (match-beginning 0) (match-end 0)))
-    (forward-line 1)
-    (if (looking-at "\n\n+")
-	(delete-region (1+ (match-beginning 0)) (match-end 0)))
-    (goto-char (point-max))
-    (skip-chars-backward "\n")
-    (delete-region (point) (point-max))
-    (beginning-of-line)
-    (forward-char -1)
-    (setq p (point))
-    (skip-chars-backward "\n")
-    (if (= ?\n (following-char)) (forward-char 1))
-    (if (> (point) (1+ p))
-	(delete-region (point) p))
-    ))
-
-(defun Manual-mouseify-xrefs ()
-  (goto-char (point-min))
-  (forward-line 1)
-  (let ((case-fold-search nil)
-	s e name extent)
-    ;; possibly it would be faster to rewrite this expression to search for
-    ;; a less common sequence first (like "([0-9]") and then back up to see
-    ;; if it's really a match.  This function is 15% of the total time, 13%
-    ;; of which is this call to re-search-forward.
-    (while (re-search-forward "[a-zA-Z_][-a-zA-Z0-9_.]*([0-9][a-zA-Z0-9]*)"
-			      nil t)
-      (setq s (match-beginning 0)
-	    e (match-end 0)
-	    name (buffer-substring s e))
-      (goto-char s)
-      (skip-chars-backward " \t")
-      (if (and (bolp)
-	       (progn (backward-char 1) (= (preceding-char) ?-)))
-	  (progn
-	    (setq s (point))
-	    (skip-chars-backward "-a-zA-Z0-9_.")
-	    (setq name (concat (buffer-substring (point) (1- s)) name))
-	    (setq s (point))))
-      ;; if there are upper case letters in the section, downcase them.
-      (if (string-match "(.*[A-Z]+.*)$" name)
-	  (setq name (concat (substring name 0 (match-beginning 0))
-			     (downcase (substring name (match-beginning 0))))))
-      ;; (setq already-fontified (extent-at s))
-      (setq extent (make-extent s e))
-      (set-extent-property extent 'man (list 'Manual-follow-xref name))
-      (set-extent-property extent 'highlight t)
-      ;; (if (not already-fontified)...
-      (set-extent-face extent 'man-xref)
-      (goto-char e))))
-
-(defun Manual-follow-xref (&optional name-or-event)
-  "Invoke `manual-entry' on the cross-reference under the mouse.
-When invoked noninteractively, the arg may be an xref string to parse instead."
-  (interactive "e")
-  (if (eventp name-or-event)
-      (let* ((p (event-point name-or-event))
-	     (extent (and p (extent-at p
-			     (event-buffer name-or-event)
-			     'highlight)))
-	     (data (and extent (extent-property extent 'man))))
-	(if (eq (car-safe data) 'Manual-follow-xref)
-	    (eval data)
-	  (error "no manual cross-reference there.")))
-    (or (manual-entry name-or-event)
-	;; If that didn't work, maybe it's in a different section than the
-	;; man page writer expected.  For example, man pages tend assume
-	;; that all user programs are in section 1, but X tends to generate
-	;; makefiles that put things in section "n" instead...
-	(and (string-match "[ \t]*([^)]+)\\'" name-or-event)
-	     (progn
-	       (message "No entries found for %s; checking other sections..."
-			name-or-event)
-	       (manual-entry
-		(substring name-or-event 0 (match-beginning 0))
-		nil t))))))
-
-(defun Manual-popup-menu (&optional event)
-  "Pops up a menu of cross-references in this manual page.
-If there is a cross-reference under the mouse button which invoked this
-command, it will be the first item on the menu.  Otherwise, they are
-on the menu in the order in which they appear in the buffer."
-  (interactive "e")
-  (let ((buffer (current-buffer))
-	(sep "---")
-	(prefix "Show Manual Page for ")
-	xref items)
-    (cond (event
-	   (setq buffer (event-buffer event))
-	   (let* ((p (event-point event))
-		  (extent (and p (extent-at p buffer 'highlight)))
-		  (data (and extent (extent-property extent 'man))))
-	     (if (eq (car-safe data) 'Manual-follow-xref)
-		 (setq xref (nth 1 data))))))
-    (if xref (setq items (list sep xref)))
-    (map-extents #'(lambda (extent ignore)
-		     (let ((data (extent-property extent 'man)))
-		       (if (and (eq (car-safe data) 'Manual-follow-xref)
-				(not (member (nth 1 data) items)))
-			   (setq items (cons (nth 1 data) items)))
-		    nil))
-		 buffer)
-    (if (eq sep (car items)) (setq items (cdr items)))
-    (let ((popup-menu-titles nil))
-      (popup-menu
-       (cons "Manual Entry"
-	     (mapcar #'(lambda (item)
-			 (if (eq item sep)
-			     item
-                           (vector (concat prefix item)
-                                   (list 'Manual-follow-xref item) t)))
-		     (nreverse items)))))))
-
-(defun pager-cleanup-hook ()
-  "cleanup man page if called via $PAGER"
-  (let ((buf-name (or buffer-file-name (buffer-name))))
-	(if (or (string-match "^/tmp/man[0-9]+" buf-name)
-		(string-match ".*/man/\\(man\\|cat\\)[1-9a-z]/" buf-name))
-	    (let (buffer manpage)
-	      (require 'man)
-	      (goto-char (point-min))
-	      (setq buffer-read-only nil)
-	      (Manual-nuke-nroff-bs)
-	      (goto-char (point-min))
-	      (if (re-search-forward "[^ \t]")
-		  (goto-char (- (point) 1)))
-	      (if (looking-at "\\([a-zA-Z0-9]+\\)[ \t]*(")
-		  (setq manpage (buffer-substring (match-beginning 1)
-						  (match-end 1)))
-		(setq manpage "???"))
-	      (setq buffer
-		    (rename-buffer
-		     (generate-new-buffer-name (concat "*man " manpage "*"))))
-	      (setq buffer-file-name nil)
-	      (goto-char (point-min))
-	      (insert (format "%s\n" buf-name))
-	      (goto-char (point-min))
-	      (buffer-disable-undo buffer)
-	      (set-buffer-modified-p nil)
-	      (Manual-mode)
-	      ))))
-
-(add-hook 'server-visit-hook 'pager-cleanup-hook)
-(provide 'man)
-
-;;; man.el ends here

lisp/packages/lpr.el

   (interactive "r")
   (print-region-1 start end lpr-switches t))
 
+;; XEmacs change
+(require 'message)	; Until We can get some sensible autoloads, or
+			; message-flatten-list gets put somewhere decent.
 (defun print-region-1 (start end switches page-headers)
   ;; On some MIPS system, having a space in the job name
   ;; crashes the printer demon.  But using dashes looks ugly
 	(binary-process-input buffer-file-type)
 	(binary-process-output buffer-file-type)
 	(width tab-width)
+	nswitches
 	switch-string)
     (save-excursion
       (if page-headers
 					 (list lpr-headers-switches)
 				        lpr-headers-switches)
 				     switches))))
+      (setq nswitches (message-flatten-list    ; XEmacs
+		       (mapcar '(lambda (arg)  ; Dynamic evaluation
+				  (cond ((stringp arg) arg)
+					((functionp arg) (apply arg nil))
+					((symbolp arg) (eval arg))
+					((consp arg) (apply (car arg)
+							    (cdr arg)))
+					(t nil)))
+			       switches)))
       (setq switch-string
-	    (if switches (concat " with options "
-				 (mapconcat 'identity switches " "))
+	    (if nswitches (concat " with options "
+				 (mapconcat 'identity nswitches " "))
 	      ""))
       (message "Spooling%s..." switch-string)
       (if (/= tab-width 8)
 			   ;; These belong in pr if we are using that.
 			   (and lpr-add-switches lpr-headers-switches
 				(list "-T" title))
-			   switches)))
+			   nswitches)))
       (if (markerp end)
 	  (set-marker end nil))
       (message "Spooling%s...done" switch-string))))

lisp/packages/mic-paren.el

+;;; mic-paren.el --- highlight matching paren.
+;;; Version 1.0 - 96-08-16
+;;; Copyright (C) 1996 Mikael Sjödin (mic@docs.uu.se)
+;;;
+;;; Author: Mikael Sjödin  --  mic@docs.uu.se
+;;; Keywords: languages, faces
+;;;
+;;; This file is NOT part of GNU Emacs.
+;;; You may however 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.
+;;;
+;;; mic-paren 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.
+
+;;; ----------------------------------------------------------------------
+;;; Short Description:
+;;;
+;;; Load this file and Emacs will display highlighting on whatever
+;;; parenthesis matches the one before or after point.  This is an extension to
+;;; the paren.el file distributed with Emacs.  The default behaviour is similar
+;;; to paren.el but try the authors favourite options:
+;;;   (setq paren-face 'bold)
+;;;   (setq paren-sexp-mode t)
+
+;;; ----------------------------------------------------------------------
+;;; Installation:
+;;;
+;;; o Place this file in a directory in your 'load-path.
+;;; o Put the following in your .emacs file:
+;;;     (if window-system
+;;;         (require 'mic-paren))
+;;; o Restart your Emacs. mic-paren is now installed and activated!
+;;; o To list the possible customisation enter `C-h f paren-activate'
+
+;;; ----------------------------------------------------------------------
+;;; Long Description:
+;;;
+;;; mic-paren.el is an extension to the packages paren.el and stig-paren.el for
+;;; Emacs.  When mic-paren is active (it is activated when loaded) Emacs normal
+;;; parenthesis matching is deactivated.  Instead parenthesis matching will be
+;;; performed as soon as the cursor is positioned at a parenthesis.  The
+;;; matching parenthesis (or the entire expression between the parenthesises)
+;;; is highlighted until the cursor is moved away from the parenthesis.
+;;; Features include:
+;;; o Both forward and backward parenthesis matching (_simultaneously_ if
+;;;   cursor is between two expressions).
+;;; o Indication of mismatched parenthesises.
+;;; o Option to select if only the matching parenthesis or the entire
+;;;   expression should be highlighted.
+;;; o Message describing the match when the matching parenthesis is
+;;;   off-screen. 
+;;; o Optional delayed highlighting (useful on slow systems), 
+;;; o Functions to activate/deactivate mic-paren.el is provided.
+;;; o Numerous options to control the behaviour and appearance of
+;;;   mic-paren.el. 
+;;;
+;;; mic-paren.el is developed and tested under Emacs 19.28 - 19.31.  It should
+;;; work on earlier and forthcoming Emacs versions.
+;;;
+;;; This file can be obtained from http://www.docs.uu.se/~mic/emacs.html
+
+;; Ported to XEmacs 15-September, 1996 Steve Baur <steve@miranova.com>
+;;; ======================================================================
+;;; User Options:
+
+(defvar paren-priority nil
+  "*Defines the behaviour of mic-paren when point is between a closing and an
+  opening parenthesis.
+
+A value of 'close means highlight the parenthesis matching the
+close-parenthesis before the point.
+
+A value of 'open means highlight the parenthesis matching the open-parenthesis
+after the point.
+
+Any other value means highlight both parenthesis matching the parenthesis
+beside the point.")
+
+
+;;; ------------------------------
+
+(defvar paren-sexp-mode nil
+  "*If nil only the matching parenthesis is highlighted.
+If non-nil the whole s-expression between the matching parenthesis is
+highlighted.")
+
+;;; ------------------------------
+
+(defvar paren-highlight-at-point t
+  "*If non-nil and point is after a close parenthesis, both the close and
+open parenthesis is highlighted. If nil, only the open parenthesis is
+highlighted.")
+
+;;; ------------------------------
+
+(defvar paren-highlight-offscreen nil
+  "*If non-nil stig-paren will highlight text which is not visible in the
+current buffer.  
+
+This is useful if you regularly display the current buffer in multiple windows
+or frames. For instance if you use follow-mode (by andersl@csd.uu.se), however
+it may slow down your Emacs.
+
+(This variable is ignored (treated as non-nil) if you set paren-sexp-mode to
+non-nil.)")
+
+;;; ------------------------------
+
+(defvar paren-message-offscreen t
+  "*Display message if matching parenthesis is off-screen.")
+
+;;; ------------------------------
+
+(defvar paren-message-no-match t
+  "*Display message if no matching parenthesis is found.")
+
+;;; ------------------------------
+
+(defvar paren-ding-unmatched nil
+  "*Make noise if the cursor is at an unmatched parenthesis or no matching
+parenthesis is found.
+
+Even if nil, typing an unmatched parenthesis produces a ding.")
+
+;;; ------------------------------
+
+(defvar paren-delay nil
+  "*This variable controls when highlighting is done.  The variable has
+different meaning in different versions of Emacs.
+
+In Emacs 19.29 and below: 
+  This variable is ignored.
+
+In Emacs 19.30:
+  A value of nil will make highlighting happen immediately (this may slow down
+  your Emacs if running on a slow system).  Any non-nil value will delay
+  highlighting for the time specified by post-command-idle-delay.  
+
+In Emacs 19.31 and above:
+  A value of nil will make highlighting happen immediately (this may slow down
+  your Emacs if running on a slow system).  If not nil, the value should be a
+  number (possible a floating point number if your Emacs support floating point
+  numbers).  The number is the delay before mic-paren performs highlighting.
+
+If you change this variable when mic-paren is active you have to re-activate
+(with M-x paren-activate) mic-paren for the change to take effect.")
+
+
+;;; ------------------------------
+
+(defvar paren-dont-touch-blink nil
+  "*If non-nil mic-paren will not change the value of blink-matching-paren when
+activated of deactivated.
+
+If nil mic-paren turns of blinking when activated and turns on blinking when
+deactivated.")
+
+;;; ------------------------------
+
+(defvar paren-dont-activate-on-load nil
+ "*If non-nil mic-paren will not activate itself when loaded.")
+
+;;; ------------------------------
+
+(defvar paren-face (if (x-display-color-p) 'highlight 'underline)
+  "*Face to use for showing the matching parenthesis.")
+
+;;; ------------------------------
+
+(defvar paren-mismatch-face (if (x-display-color-p)
+				(let ((fn 'paren-mismatch-face))
+				  (copy-face 'default fn)
+				  (set-face-background fn "DeepPink")
+				  fn)
+			      'modeline)
+  "*Face to use when highlighting a mismatched parenthesis.")
+
+;;; ======================================================================
+;;; User Functions:
+
+;; XEmacs compatibility
+(eval-and-compile
+  (if (fboundp 'make-extent)
+      (progn
+	(fset 'mic-make-overlay 'make-extent)
+	(fset 'mic-delete-overlay 'delete-extent)
+	(fset 'mic-overlay-put 'set-extent-property)
+	(defun mic-cancel-timer (timer) (delete-itimer timer))
+	(defun mic-run-with-idle-timer (secs repeat function &rest args)
+	  (start-itimer "mic-paren-idle" function secs nil))
+	)
+    (fset 'mic-make-overlay 'make-overlay)
+    (fset 'mic-delete-overlay 'delete-overlay)
+    (fset 'mic-overlay-put 'overlay-put)
+    (fset 'mic-cancel-timer 'cancel-timer)
+    (fset 'mic-run-with-idle-timer 'run-with-idle-timer)
+    ))
+
+
+(defun paren-activate ()
+  "Activates mic-paren parenthesis highlighting.
+paren-activate deactivates the paren.el and stig-paren.el packages if they are
+active 
+Options:
+  paren-priority
+  paren-sexp-mode
+  paren-highlight-at-point
+  paren-highlight-offscreen
+  paren-message-offscreen
+  paren-message-no-match
+  paren-ding-unmatched
+  paren-delay
+  paren-dont-touch-blink
+  paren-dont-activate-on-load
+  paren-face
+  paren-mismatch-face"
+  (interactive)
+  ;; Deactivate mic-paren.el (To remove redundant hooks)
+  (paren-deactivate)
+  ;; Deactivate paren.el if loaded
+  (if (boundp 'post-command-idle-hook)
+      (remove-hook 'post-command-idle-hook 'show-paren-command-hook))
+  (remove-hook 'post-command-hook 'show-paren-command-hook)
+  (and (boundp 'show-paren-overlay)
+       show-paren-overlay
+       (mic-delete-overlay show-paren-overlay))
+  (and (boundp 'show-paren-overlay-1)
+       show-paren-overlay-1
+       (mic-delete-overlay show-paren-overlay-1))
+  ;; Deactivate stig-paren.el if loaded
+  (if (boundp 'post-command-idle-hook)
+      (remove-hook 'post-command-idle-hook 'stig-paren-command-hook))
+  (remove-hook 'post-command-hook 'stig-paren-command-hook)
+  (remove-hook 'post-command-hook 'stig-paren-safe-command-hook)
+  (remove-hook 'pre-command-hook 'stig-paren-delete-overlay)
+  ;; Deactivate Emacs standard parenthesis blinking
+  (or paren-dont-touch-blink
+      (setq blink-matching-paren nil))
+
+  (cond
+	;; If timers are available use them
+	;; (Emacs 19.31 and above)
+	((or (featurep 'timer) (featurep 'itimer))
+	 (if (numberp paren-delay)
+	     (setq mic-paren-idle-timer 
+		   (mic-run-with-idle-timer paren-delay t
+					    'mic-paren-command-idle-hook))
+	   (add-hook 'post-command-hook 'mic-paren-command-hook)))
+       ;; If the idle hook exists assume it is functioning and use it 
+       ;; (Emacs 19.30)
+       ((and (boundp 'post-command-idle-hook) 
+	     (boundp 'post-command-idle-delay))
+	(if paren-delay
+	    (add-hook 'post-command-idle-hook 'mic-paren-command-idle-hook)
+	  (add-hook 'post-command-hook 'mic-paren-command-hook)))
+       ;; Check if we (at least) have a post-comand-hook, and use it
+       ;; (Emacs 19.29 and below)
+       ((boundp 'post-command-hook) 
+	(add-hook 'post-command-hook 'mic-paren-command-hook))
+       ;; Not possible to install mic-paren hooks
+       (t (error "Cannot activate mic-paren in this Emacs version"))))
+
+
+
+(defun paren-deactivate ()
+  "Deactivates mic-paren parenthesis highlighting"
+  (interactive)
+  ;; Deactivate (don't bother to check where/if mic-paren is acivte, just
+  ;; delete all possible hooks and timers)
+  (if (boundp 'post-command-idle-hook)
+      (remove-hook 'post-command-idle-hook 'mic-paren-command-idle-hook))
+  (if mic-paren-idle-timer
+      (mic-cancel-timer mic-paren-idle-timer))
+  (remove-hook 'post-command-hook 'mic-paren-command-hook)
+
+  ;; Remove any old highlighs
+  (mic-delete-overlay mic-paren-backw-overlay)
+  (mic-delete-overlay mic-paren-point-overlay)
+  (mic-delete-overlay mic-paren-forw-overlay)
+
+  ;; Reactivate Emacs standard parenthesis blinking
+  (or paren-dont-touch-blink
+      (setq blink-matching-paren t))
+  )
+
+;;; ======================================================================
+;;; Internal variables:
+
+(defvar mic-paren-backw-overlay (mic-make-overlay (point-min) (point-min))
+  "Overlay for the open-paren which matches the close-paren before
+point. When in sexp-mode this is the overlay for the expression before point.")
+
+(defvar mic-paren-point-overlay (mic-make-overlay (point-min) (point-min))
+  "Overlay for the close-paren before point.
+(Not used when is sexp-mode.)")
+
+(defvar mic-paren-forw-overlay (mic-make-overlay (point-min) (point-min))
+  "Overlay for the close-paren which matches the open-paren after
+point. When in sexp-mode this is the overlay for the expression after point.")
+
+(defvar mic-paren-idle-timer nil
+  "Idle-timer.  Used only in Emacs 19.31 and above (and if paren-delay is nil)")
+
+
+
+
+;;; ======================================================================
+;;; Internal function:
+
+
+
+(defun mic-paren-command-hook ()
+  (or executing-kbd-macro
+      (input-pending-p)			;[This might cause trouble since the
+                                        ; function is unreliable]
+      (condition-case paren-error
+	  (mic-paren-highligt)
+	(error 
+	 (if (not (window-minibuffer-p (selected-window)))
+	     (message "mic-paren catched error (please report): %s"
+		      paren-error))))))
+
+(defun mic-paren-command-idle-hook ()
+  (condition-case paren-error
+      (mic-paren-highligt)
+    (error 
+     (if (not (window-minibuffer-p (selected-window)))
+	 (message "mic-paren catched error (please report): %s" 
+		  paren-error)))))
+
+
+(defun mic-paren-highligt ()
+  "The main-function of mic-paren. Does all highlighting, dinging, messages,
+cleaning-up."
+  ;; Remove any old highlighting
+  (mic-delete-overlay mic-paren-forw-overlay)
+  (mic-delete-overlay mic-paren-point-overlay)
+  (mic-delete-overlay mic-paren-backw-overlay)
+
+  ;; Handle backward highlighting (when after a close-paren):
+  ;; If positioned after a close-paren, and
+  ;;    not before an open-paren when priority=open, and
+  ;;    the close-paren is not escaped then
+  ;;      perform highlighting
+  ;; else
+  ;;      remove any old backward highlights
+  (if (and (eq (char-syntax (preceding-char)) ?\))
+	   (not (and (eq (char-syntax (following-char)) ?\()
+		     (eq paren-priority 'open)))
+	   (paren-evenp (paren-backslashes-before-char (1- (point)))))
+       (let (open)
+	 ;; Find the position for the open-paren
+	 (save-excursion
+	   (save-restriction
+	     (if blink-matching-paren-distance
+		 (narrow-to-region 
+		  (max (point-min)
+		       (- (point) blink-matching-paren-distance))
+		  (point-max)))
+	     (condition-case ()
+		 (setq open (scan-sexps (point) -1))
+	       (error nil))))
+
+	 ;; If match found
+	 ;;    highlight and/or print messages
+	 ;; else
+	 ;;    print no-match message
+	 ;;    remove any old highlights
+	 (if open
+	     (let ((mismatch (/= (matching-paren (preceding-char)) 
+				 (char-after open)))
+		   (visible (pos-visible-in-window-p open)))
+	       ;; If highlight is appropriate
+	       ;;    highligt
+	       ;; else
+	       ;;    remove any old highlight
+	       (if (or visible paren-highlight-offscreen paren-sexp-mode)
+		   ;; If sexp-mode
+		   ;;    highlight sexp
+		   ;; else
+		   ;;    highlight the two parens
+		   (if paren-sexp-mode
+		       (progn
+			 (setq mic-paren-backw-overlay
+			       (mic-make-overlay open (point)))
+			 (if mismatch
+			     (mic-overlay-put mic-paren-backw-overlay 
+					      'face paren-mismatch-face)
+			   (mic-overlay-put mic-paren-backw-overlay 
+					    'face paren-face)))
+		     (setq mic-paren-backw-overlay
+			   (mic-make-overlay open (1+ open)))
+		     (and paren-highlight-at-point
+			  (setq mic-paren-point-overlay
+				(mic-make-overlay (1- (point)) (point))))
+		     (if mismatch
+			 (progn
+			   (mic-overlay-put mic-paren-backw-overlay 
+					    'face paren-mismatch-face)
+			   (and paren-highlight-at-point
+				(mic-overlay-put mic-paren-point-overlay 
+						 'face paren-mismatch-face)))
+		       (mic-overlay-put mic-paren-backw-overlay 
+					'face paren-face)
+		       (and paren-highlight-at-point 
+			    (mic-overlay-put mic-paren-point-overlay 
+					     'face paren-face)))))
+	       ;; Print messages if match is offscreen
+	       (and paren-message-offscreen
+		    (not visible)
+		    (not (window-minibuffer-p (selected-window)))
+		    (message "%s %s" 
+			     (if mismatch "MISMATCH:" "Matches")
+			     (mic-paren-get-matching-open-text open)))
+	       ;; Ding if mismatch
+	       (and mismatch
+		    paren-ding-unmatched
+		    (ding)))
+	   (and paren-message-no-match
+		(not (window-minibuffer-p (selected-window)))
+		(message "No opening parenthesis found"))
+	   (and paren-message-no-match
+		paren-ding-unmatched
+		(ding)))))
+
+  ;; Handle forward highlighting (when before an open-paren):
+  ;; If positioned before an open-paren, and
+  ;;    not after a close-paren when priority=close, and
+  ;;    the open-paren is not escaped then
+  ;;      perform highlighting
+  ;; else
+  ;;      remove any old forward highlights
+  (if (and (eq (char-syntax (following-char)) ?\()
+	   (not (and (eq (char-syntax (preceding-char)) ?\))
+		     (eq paren-priority 'close)))
+	   (paren-evenp (paren-backslashes-before-char (point))))
+       (let (close)
+	 ;; Find the position for the close-paren
+	 (save-excursion
+	   (save-restriction
+	     (if blink-matching-paren-distance
+		 (narrow-to-region 
+		  (point-min)
+		  (min (point-max)
+		       (+ (point) blink-matching-paren-distance))))
+      	     (condition-case ()
+		 (setq close (scan-sexps (point) 1))
+	       (error nil))))
+	 ;; If match found
+	 ;;    highlight and/or print messages
+	 ;; else
+	 ;;    print no-match message
+	 ;;    remove any old highlights
+	 (if close
+	     (let ((mismatch (/= (matching-paren (following-char)) 
+				 (char-after (1- close))))
+		   (visible (pos-visible-in-window-p close)))
+	       ;; If highlight is appropriate
+	       ;;    highligt
+	       ;; else
+	       ;;    remove any old highlight
+	       (if (or visible paren-highlight-offscreen paren-sexp-mode)
+		   ;; If sexp-mode
+		   ;;    highlight sexp
+		   ;; else
+		   ;;    highlight the two parens
+		   (if paren-sexp-mode
+		       (progn
+			 (setq mic-paren-forw-overlay
+			       (mic-make-overlay (point) close))
+			 (if mismatch
+			     (mic-overlay-put mic-paren-forw-overlay 
+					      'face paren-mismatch-face)
+			   (mic-overlay-put mic-paren-forw-overlay 
+					    'face paren-face)))
+		     (setq mic-paren-forw-overlay
+			   (mic-make-overlay (1- close) close))
+		     (if mismatch
+			 (mic-overlay-put mic-paren-forw-overlay 
+					  'face paren-mismatch-face)
+		       (mic-overlay-put mic-paren-forw-overlay 
+					'face paren-face))))
+
+	       ;; Print messages if match is offscreen
+	       (and paren-message-offscreen
+		    (not visible)
+		    (not (window-minibuffer-p (selected-window)))
+		    (message "%s %s" 
+			     (if mismatch "MISMATCH:" "Matches")
+			     (mic-paren-get-matching-close-text close)))
+	       ;; Ding if mismatch
+	       (and mismatch
+		    paren-ding-unmatched
+		    (ding)))
+	   (and paren-message-no-match
+		(not (window-minibuffer-p (selected-window)))
+		(message "No closing parenthesis found"))
+	   (and paren-message-no-match
+		paren-ding-unmatched
+		(ding))))))
+
+;;; --------------------------------------------------
+
+(defun mic-paren-get-matching-open-text (open)
+  "Returns a string with the context around OPEN-paren."
+  ;; If there's stuff on this line preceding the paren, then display text from
+  ;; beginning of line to paren.
+  ;;
+  ;; If, however, the paren is at the beginning of a line, then skip whitespace
+  ;; forward and display text from paren to end of the next line containing
+  ;; non-space text.
+  ;;
+  ;; (Same as in stig-paren.el)
+  (save-excursion
+    (goto-char open)
+    (if (save-excursion
+	  (skip-chars-backward " \t")
+	  (not (bolp)))
+	(progn
+	  (beginning-of-line)
+	  (concat (buffer-substring (point) (1+ open)) "..."))
+      (forward-char 1)			;From the beginning-of-line
+      (skip-chars-forward "\n \t")
+      (end-of-line)
+      (buffer-substring open (point)))))
+
+
+(defun mic-paren-get-matching-close-text (close)
+  "Returns a string with the context around CLOSE-paren."
+  ;; The whole line up until the close-paren with "..." appended if there are
+  ;; more text after the close-paren
+  (save-excursion
+    (goto-char close)
+    (beginning-of-line)
+    (concat
+     (buffer-substring (point) close)
+     (progn 
+       (goto-char close)
+       (if (looking-at "[ \t]*$")
+	   ""
+	 "...")))))
+  
+
+(defun paren-evenp (number)
+  "Returns t if NUMBER is an even number, nil otherwise"
+  (eq 0 (% number 2)))
+
+(defun paren-backslashes-before-char (pnt)
+  (setq pnt (1- pnt))
+  (let ((n 0))
+    (while (and (>= pnt (point-min))
+		(eq (char-syntax (char-after pnt)) ?\\))
+      (setq n (1+ n))
+      (setq pnt (1- pnt)))
+    n))
+
+    
+
+;;; ======================================================================
+;;; Initialisation when loading:
+
+
+(or paren-dont-activate-on-load
+    (paren-activate))
+
+;;; This is in case mic-paren.el is preloaded. [Does this work? /Mic]
+(add-hook 'window-setup-hook
+	  (function (lambda ()
+		      (and window-system
+			   (not paren-dont-activate-on-load)
+			   (paren-activate)))))
+
+(provide 'mic-paren)
+(provide 'paren)

lisp/packages/old-man.el

-;;; man.el --- browse UNIX manual pages
-;; Keywords: help
-
-;; Copyright (C) 1985, 1993, 1994 Free Software Foundation, Inc.
-;;
-;; This file is part of XEmacs.
-
-;; XEmacs 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.
-
-;; XEmacs 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 XEmacs; see the file COPYING.  If not, write to the Free
-;; Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
-
-;;; Synched up with: Not synched with FSF.
-;;; ICK!  This file is almost completely different from FSF.
-;;; Someone clarify please.
-
-;; Mostly rewritten by Alan K. Stebbens <aks@hub.ucsb.edu> 11-apr-90.
-;;
-;;  o  Match multiple man pages using TOPIC as a simple pattern
-;;  o  Search unformatted pages, even when formatted matches are found
-;;  o  Query the user as to which pages are desired
-;;  o  Use of the prefix arg to toggle/bypass the above features
-;;  o  Buffers named by the first topic in the buffer
-;;  o  Automatic uncompress for compressed man pages (.Z, .z, and .gz)
-;;  o  View the resulting buffer using M-x view mode
-;;
-;; Modified 16-mar-91 by Jamie Zawinski <jwz@lucid.com> to default the 
-;; manual topic to the symbol at point, just like find-tag does.
-;;
-;; Modified 22-mar-93 by jwz to use multiple fonts and follow xrefs with mouse.
-;;
-;; Modified 16-apr-93 by Dave Gillespie <daveg@synaptics.com> to make
-;; apropos work nicely; work correctly when bold or italic is unavailable; 
-;; reuse old buffer if topic is re-selected (in Manual-topic-buffer mode).
-;;
-;; Modified 4-apr-94 by jwz: merged in Tibor Polgar's code for manpath.conf.
-;;
-;; Modified 19-apr-94 by Tibor Polgar <tlp00@spg.amdahl.com> to add support for
-;; $PAGER variable to be emacsclient and properly process man pages (assuming
-;; the man pages were built by man in /tmp.  also fixed bug with man list being
-;; backwards.
-;;
-;; Modified 23-aug-94 by Tibor Polgar <tlp00@spg.amdahl.com> to add support for
-;; displaying only one instance of a man page (Manual-unique-man-sections-only)
-;; Fixed some more man page ordering bugs, bug with Manual-query-multiple-pages.
-;;
-;; Modified 29-nov-94 by Ben Wing <wing@spg.amdahl.com>: small fixes
-;; that should hopefully make things work under HPUX and IRIX.; 
-;;
-;; Modified 15-jul-95 by Dale Atems <atems@physics.wayne.edu>:
-;; some extensive rewriting to make things work right (more or less)
-;; under IRIX.
-;;
-;; Modified 08-mar-96 by Hubert Palme <palme@wrcs3.urz.uni-wuppertal.de>:
-;; added /usr/share/catman to the manual directory list for IRIX (5.3)
-;; 
-;; This file defines "manual-entry", and the remaining definitions all
-;; begin with "Manual-".  This makes the autocompletion on "M-x man" work.
-;;
-;; Variables of interest:
-;;
-;;	Manual-program
-;;	Manual-topic-buffer
-;;	Manual-buffer-view-mode
-;;	Manual-directory-list
-;;	Manual-formatted-directory-list
-;;	Manual-match-topic-exactly
-;;	Manual-query-multiple-pages
-;;	Manual-page-history
-;;	Manual-subdirectory-list
-;;	Manual-man-page-section-ids
-;;	Manual-formatted-page-prefix
-;;	Manual-unformatted-page-prefix
-;;	Manual-use-full-section-ids
-
-(defvar Manual-program "man" "\
-*Name of the program to invoke in order to format the source man pages.")
-
-(defvar Manual-section-switch (if (eq system-type 'usg-unix-v) "-s" nil)
-  "SysV needs this to work right.")
-
-(defvar Manual-topic-buffer t "\
-*Non-nil means \\[Manual-entry] should output the manual entry for TOPIC into
-a buffer named *man TOPIC*, otherwise, it should name the buffer
-*Manual Entry*.")
-
-(defvar Manual-buffer-view-mode t "\
-*Whether manual buffers should be placed in view-mode.
-nil means leave the buffer in fundamental-mode in another window.
-t means use `view-buffer' to display the man page in the current window.
-Any other value means use `view-buffer-other-window'.")
-
-(defvar Manual-match-topic-exactly t "\
-*Non-nil means that \\[manual-entry] will match the given TOPIC exactly, rather
-apply it as a pattern.  When this is nil, and \"Manual-query-multiple-pages\"
-is non-nil, then \\[manual-entry] will query you for all matching TOPICs.
-This variable only has affect on the preformatted man pages (the \"cat\" files),
-since the \"man\" command always does exact topic matches.")
-
-(defvar Manual-query-multiple-pages nil "\
-*Non-nil means that \\[manual-entry] will query the user about multiple man
-pages which match the given topic.  The query is done using the function 
-\"y-or-n-p\".  If this variable is nil, all man pages with topics matching the
-topic given to \\[manual-entry] will be inserted into the temporary buffer.
-See the variable \"Manual-match-topic-exactly\" to control the matching.")
-
-(defvar Manual-unique-man-sections-only nil
-  "*Only present one man page per section.  This variable is useful if the same or
-up/down level man pages for the same entry are present in mulitple man paths.
-When set to t, only the first entry found in a section is displayed, the others
-are ignored without any messages or warnings.  Note that duplicates can occur if
-the system has both formatted and unformatted version of the same page.")
-
-(defvar Manual-mode-hook nil
-  "Function or functions run on entry to Manual-mode.")
-
-(defvar Manual-directory-list nil "\
-*A list of directories used with the \"man\" command, where each directory
-contains a set of \"man?\" and \"cat?\" subdirectories.  If this variable is nil,
-it is initialized by \\[Manual-directory-list-init].")
-
-(defvar Manual-formatted-directory-list nil "\
-A list of directories containing formatted man pages.  Initialized by
-\\[Manual-directory-list-init].")
-
-(defvar Manual-unformatted-directory-list nil "\
-A list of directories containing the unformatted (source) man pages.  
-Initialized by \\[Manual-directory-list-init].")
-
-(defvar Manual-page-history nil "\
-A list of names of previously visited man page buffers.")
-
-(defvar Manual-manpath-config-file "/usr/lib/manpath.config"
-  "*Location of the manpath.config file, if any.")
-
-(defvar Manual-apropos-switch "-k"
-  "*Man apropos switch")
-
-;; New variables.
-
-(defvar Manual-subdirectory-list nil "\
-A list of all the subdirectories in which man pages may be found.
-Iniialized by Manual-directory-list-init.")
-
-;; This is for SGI systems; don't know what it should be otherwise.
-(defvar Manual-man-page-section-ids "1nl6823457poD" "\
-String containing all suffix characters for \"cat\" and \"man\"
-that identify valid sections of the Un*x manual.") 
-
-(defvar Manual-formatted-page-prefix "cat" "\
-Prefix for directories where formatted man pages are to be found.
-Defaults to \"cat\".")
-
-(defvar Manual-unformatted-page-prefix "man" "\
-Prefix for directories where unformatted man pages are to be found.
-Defaults to \"man\".")
-
-(defvar Manual-leaf-signature "" "\
-Regexp for identifying \"leaf\" subdirectories in the search path.
-If empty, initialized by Manual-directory-list-init.")
-
-(defvar Manual-use-full-section-ids t "\
-If non-nil, pass full section ids to Manual-program, otherwise pass
-only the first character. Defaults to 't'.")
-
-(defvar Manual-use-subdirectory-list (eq system-type 'irix) "\
-This makes manual-entry work correctly on SGI machines but it
-imposes a large startup cost which is why it is not simply on by
-default on all systems.")
-
-(defvar Manual-use-rosetta-man (not (null (locate-file "rman" exec-path))) "\
-If non-nil, use RosettaMan (rman) to filter man pages.
-This makes man-page cleanup virtually instantaneous, instead of
-potentially taking a long time.
-
-Here is information on RosettaMan, from Neal.Becker@comsat.com (Neal Becker):
-
-RosettaMan is a filter for UNIX manual pages.  It takes as input man
-pages formatted for a variety of UNIX flavors (not [tn]roff source)
-and produces as output a variety of file formats.  Currently
-RosettaMan accepts man pages as formatted by the following flavors of
-UNIX: Hewlett-Packard HP-UX, AT&T System V, SunOS, Sun Solaris, OSF/1,
-DEC Ultrix, SGI IRIX, Linux, SCO; and produces output for the following
-formats: printable ASCII only (stripping page headers and footers),
-section and subsection headers only, TkMan, [tn]roff, Ensemble, RTF,
-SGML (soon--I finally found a DTD), HTML, MIME, LaTeX, LaTeX 2e, Perl 5's pod.
-
-RosettaMan improves on other man page filters in several ways: (1) its
-analysis recognizes the structural pieces of man pages, enabling high
-quality output, (2) its modular structure permits easy augmentation of
-output formats, (3) it accepts man pages formatted with the varient
-macros of many different flavors of UNIX, and (4) it doesn't require
-modification or cooperation with any other program.
-
-RosettaMan is a rewrite of TkMan's man page filter, called bs2tk.  (If
-you haven't heard about TkMan, a hypertext man page browser, you
-should grab it via anonymous ftp from ftp.cs.berkeley.edu:
-/ucb/people/phelps/tkman.tar.Z.)  Whereas bs2tk generated output only for
-TkMan, RosettaMan generalizes the process so that the analysis can be
-leveraged to new output formats.  A single analysis engine recognizes
-section heads, subsection heads, body text, lists, references to other
-man pages, boldface, italics, bold italics, special characters (like
-bullets), tables (to a degree) and strips out page headers and
-footers.  The engine sends signals to the selected output functions so
-that an enhancement in the engine improves the quality of output of
-all of them.  Output format functions are easy to add, and thus far
-average about about 75 lines of C code each.
-
-
-
-*** NOTES ON CURRENT VERSION ***
-
-Help!  I'm looking for people to help with the following projects.
-\(1) Better RTF output format.  The current one works, but could be
-made better.  (2) Roff macros that produce text that is easily
-parsable.  RosettaMan handles a great variety, but some things, like
-H-P's tables, are intractable.  If you write an output format or
-otherwise improve RosettaMan, please send in your code so that I may
-share the wealth in future releases.
-
-This version can try to identify tables (turn this on with the -T
-switch) by looking for lines with a large amount of interword spacing,
-reasoning that this is space between columns of a table.  This
-heuristic doesn't always work and sometimes misidentifies ordinary
-text as tables.  In general I think it is impossible to perfectly
-identify tables from nroff formatted text.  However, I do think the
-heuristics can be tuned, so if you have a collection of manual pages
-with unrecognized tables, send me the lot, in formatted form (i.e.,
-after formatting with nroff -man), and uuencode them to preserve the
-control characters.  Better, if you can think of heuristics that
-distinguish tables from ordinary text, I'd like to hear them.
-
-
-Notes for HTML consumers: This filter does real (heuristic)
-parsing--no <PRE>!  Man page references are turned into hypertext links.")
-
-(make-face 'man-italic)
-(or (face-differs-from-default-p 'man-italic)
-    (copy-face 'italic 'man-italic))
-;; XEmacs (from Darrell Kindred): underlining is annoying due to
-;; large blank spaces in this face.
-;; (or (face-differs-from-default-p 'man-italic)
-;;    (set-face-underline-p 'man-italic t))
-
-(make-face 'man-bold)
-(or (face-differs-from-default-p 'man-bold)
-    (copy-face 'bold 'man-bold))
-(or (face-differs-from-default-p 'man-bold)
-    (copy-face 'man-italic 'man-bold))
-
-(make-face 'man-heading)
-(or (face-differs-from-default-p 'man-heading)
-    (copy-face 'man-bold 'man-heading))
-
-(make-face 'man-xref)
-(or (face-differs-from-default-p 'man-xref)
-    (set-face-underline-p 'man-xref t))
-
-;; Manual-directory-list-init
-;; Initialize the directory lists.
-
-(defun Manual-directory-list-init (&optional arg) 
-  "Initialize the Manual-directory-list variable from $MANPATH
-if it is not already set, or if a prefix argument is provided."
-  (interactive "P")
-  (if arg (setq Manual-directory-list nil))
-  (if (null Manual-directory-list)
-      (let ((manpath (getenv "MANPATH"))
-	    (global (Manual-manpath-config-contents))
-	    (dirlist nil)
-	    dir)
-	(cond ((and manpath global)
-	       (setq manpath (concat manpath ":" global)))
-	      (global
-	       (setq manpath global))
-	      ((not manpath)
-	       ;; XEmacs - (bpw/stig) Unix-specifix hack for lusers w/ no manpath
-	       (setq manpath "/usr/local/man:/usr/share/man:/usr/share/catman:/usr/contrib/man:/usr/X11/man:/usr/man:/usr/catman")))
-	;; Make sure that any changes we've made internally are seen by man.
-	(setenv "MANPATH" manpath)
-	(while (string-match "\\`:*\\([^:]+\\)" manpath)
-	  (setq dir (substring manpath (match-beginning 1) (match-end 1)))
-	  (and (not (member dir dirlist))
-	       (setq dirlist (cons dir dirlist)))
-	  (setq manpath (substring manpath (match-end 0))))
-	(setq dirlist (nreverse dirlist))
-	(setq Manual-directory-list dirlist)
-	(setq Manual-subdirectory-list nil)
-	(setq Manual-formatted-directory-list nil)
-	(setq Manual-unformatted-directory-list nil)))
-  (if (string-equal Manual-leaf-signature "")
-      (setq Manual-leaf-signature
-	    (concat "/\\("
-		    Manual-formatted-page-prefix
-		    "\\|" Manual-unformatted-page-prefix
-		    "\\)"
-		    "[" Manual-man-page-section-ids
-		    "].?/.")))
-  (if Manual-use-subdirectory-list
-      (progn
-	(if (null Manual-subdirectory-list)
-	    (setq Manual-subdirectory-list
-		  (Manual-all-subdirectories Manual-directory-list
-					     Manual-leaf-signature nil)))
-	(if (null Manual-formatted-directory-list)
-	    (setq Manual-formatted-directory-list
-		  (Manual-filter-subdirectories Manual-subdirectory-list
-						Manual-formatted-page-prefix)))
-	(if (null Manual-unformatted-directory-list)
-	    (setq Manual-unformatted-directory-list
-		  (Manual-filter-subdirectories Manual-subdirectory-list
-						Manual-unformatted-page-prefix))))
-    (if (null Manual-formatted-directory-list)
-        (setq Manual-formatted-directory-list
-	      (Manual-select-subdirectories Manual-directory-list
-					    Manual-formatted-page-prefix)))
-    (if (null Manual-unformatted-directory-list)
-        (setq Manual-unformatted-directory-list
-	      (Manual-select-subdirectories Manual-directory-list
-					    Manual-unformatted-page-prefix)))))
-
-
-(defun Manual-manpath-config-contents ()
-  "Parse the `Manual-manpath-config-file' file, if any.
-Returns a string like in $MANPATH."
-  (if (and Manual-manpath-config-file
-	   (file-readable-p Manual-manpath-config-file))
-      (let ((buf (get-buffer-create " *Manual-config*"))
-	    path)
-	(set-buffer buf)
-	(buffer-disable-undo buf)
-	(erase-buffer)
-	(insert-file-contents Manual-manpath-config-file)
-	(while (re-search-forward "^\\(MANDATORY_MANPATH\\|MANPATH_MAP\\)"
-				  nil t)
-	  (and (re-search-forward "\\(/[^ \t\n]+\\)[ \t]*$")
-	       (setq path (concat path (buffer-substring (match-beginning 1)
-							 (match-end 1))
-				  ":"))))
-	(kill-buffer buf)
-	path)))
-;;
-;; manual-entry  -- The "main" user function
-;;
-
-;;;###autoload
-(defun manual-entry (topic &optional arg silent)
-  "Display the Unix manual entry (or entries) for TOPIC.
-If prefix arg is given, modify the search according to the value:
-  2 = complement default exact matching of the TOPIC name;
-      exact matching default is specified by `Manual-match-topic-exactly'
-  3 = force a search of the unformatted man directories
-  4 = both 2 and 3
-The manual entries are searched according to the variable
-Manual-directory-list, which should be a list of directories.  If
-Manual-directory-list is nil, \\[Manual-directory-list-init] is
-invoked to create this list from the MANPATH environment variable.
-See the variable Manual-topic-buffer which controls how the buffer
-is named.  See also the variables Manual-match-topic-exactly,
-Manual-query-multiple-pages, and Manual-buffer-view-mode."
-  (interactive
-   (list (let* ((fmh "-A-Za-z0-9_.")
-		(default (save-excursion
-			   (buffer-substring
-			    (progn
-			      (re-search-backward "\\sw" nil t)
-			      (skip-chars-backward fmh) (point))
-			    (progn (skip-chars-forward fmh) (point)))))
-		(thing (read-string
-			(if (equal default "") "Manual entry: "
-			  (concat "Manual entry: (default " default ") ")))))
-	   (if (equal thing "") default thing))
-	 (prefix-numeric-value current-prefix-arg)))
-  ;;(interactive "sManual entry (topic): \np")
-  (or arg (setq arg 1))
-  (Manual-directory-list-init nil)
-  (let ((exact (if (or (= arg 2) (= arg 4))
-		   (not Manual-match-topic-exactly)
-		 Manual-match-topic-exactly))
-	(force (if (>= arg 3)
-                   t
-                   nil))
-	section fmtlist manlist apropos-mode)
-    (let ((case-fold-search nil))
-      (if (and (null section)
-	       (string-match
-		"\\`[ \t]*\\([^( \t]+\\)[ \t]*(\\(.+\\))[ \t]*\\'" topic))
-	  (setq section (substring topic (match-beginning 2)
-				   (match-end 2))
-		topic (substring topic (match-beginning 1)
-				 (match-end 1)))
-	(if (string-match "\\`[ \t]*-k[ \t]+\\([^ \t]+\\)\\'" topic)
-	    (setq section "-k"
-		  topic (substring topic (match-beginning 1))))))
-    (if (equal section "-k")
-	(setq apropos-mode t)
-      (or silent
-	  (message "Looking for formatted entry for %s%s..."
-		   topic (if section (concat "(" section ")") "")))
-      (setq fmtlist (Manual-select-man-pages
-                      Manual-formatted-directory-list
-                      topic section exact '()))
-      (if (or force (not section) (null fmtlist))
-	  (progn
-	    (or silent
-		(message "%sooking for unformatted entry for %s%s..."
-			 (if fmtlist "L" "No formatted entry, l")
-			 topic (if section (concat "(" section ")") "")))
-	    (setq manlist (Manual-select-man-pages
-                            Manual-unformatted-directory-list
-                            topic section exact (if force '() fmtlist))))))
-
-    ;; Delete duplicate man pages (a file of the same name in multiple
-    ;; directories.)
-    (or nil ;force
-        (let ((rest (append fmtlist manlist)))
-          (while rest
-            (let ((rest2 (cdr rest)))
-              (while rest2
-                (if (equal (file-name-nondirectory (car rest))
-                           (file-name-nondirectory (car rest2)))
-                    (setq fmtlist (delq (car rest2) fmtlist)
-                          manlist (delq (car rest2) manlist)))
-                (setq rest2 (cdr rest2))))
-            (setq rest (cdr rest)))))
-
-    (if (not (or fmtlist manlist apropos-mode))
-        (progn
-          (message "No entries found for %s%s" topic
-                   (if section (concat "(" section ")") ""))
-          nil)
-      (let ((bufname (cond ((not Manual-topic-buffer)
-                            ;; What's the point of retaining this?
-                            (if apropos-mode
-                                "*Manual Apropos*"
-                                "*Manual Entry*"))
-                           (apropos-mode
-                            (concat "*man apropos " topic "*"))
-                           (t
-                            (concat "*man "
-                                    (cond (exact
-                                           (if section
-                                               (concat topic "." section)
-                                               topic))
-                                          ((or (cdr fmtlist) (cdr manlist)
-                                               (and fmtlist manlist))
-                                           ;; more than one entry found
-                                           (concat topic "..."))
-                                          (t
-                                           (file-name-nondirectory
-                                            (car (or fmtlist manlist)))))
-                                    "*"))))
-            (temp-buffer-show-function 
-             (cond ((eq 't Manual-buffer-view-mode) 'view-buffer)
-                   ((eq 'nil Manual-buffer-view-mode)
-                    temp-buffer-show-function)
-                   (t 'view-buffer-other-window))))
-
-        (if apropos-mode
-            (setq manlist (list (format "%s.%s" topic section))))
-
-        (cond
-          ((and Manual-topic-buffer (get-buffer bufname))
-           ;; reselect an old man page buffer if it exists already.
-           (save-excursion
-             (set-buffer (get-buffer bufname))
-             (Manual-mode))
-           (if temp-buffer-show-function
-               (funcall temp-buffer-show-function (get-buffer bufname))
-               (display-buffer bufname)))
-          (t
-           (with-output-to-temp-buffer bufname
-             (buffer-disable-undo standard-output)
-             (save-excursion
-               (set-buffer standard-output)
-               (setq buffer-read-only nil)
-               (erase-buffer)
-	       (Manual-insert-pages fmtlist manlist apropos-mode)
-               (set-buffer-modified-p nil)
-               (Manual-mode)
-               ))))
-        (setq Manual-page-history
-              (cons (buffer-name)
-                    (delete (buffer-name) Manual-page-history)))
-        (message nil)
-        t))))
-
-(defun Manpage-apropos (topic &optional arg silent)
-  "Apropos on Unix manual pages for TOPIC.
-It calls the function `manual-entry'. Look at this function for
-further description. Look also at the variable `Manual-apropos-switch',
-if this function doesn't work on your system."
-  (interactive
-   (list (let* ((fmh "-A-Za-z0-9_.")
-		(default (save-excursion
-			   (buffer-substring
-			    (progn
-			      (re-search-backward "\\sw" nil t)
-			      (skip-chars-backward fmh) (point))
-			    (progn (skip-chars-forward fmh) (point)))))
-		(thing (read-string
-			(if (equal default "") "Manual entry: "
-			  (concat "Manual entry: (default " default ") ")))))
-	   (if (equal thing "") default thing))
-	 (prefix-numeric-value current-prefix-arg)))
-  (manual-entry (concat Manual-apropos-switch " " topic) arg silent))
-
-(defun Manual-insert-pages (fmtlist manlist apropos-mode)
-  (let ((sep (make-string 65 ?-))
-	name start end topic section)
-    (while fmtlist			; insert any formatted files
-      (setq name (car fmtlist))
-      (goto-char (point-max))
-      (setq start (point))
-      ;; In case the file can't be read or uncompressed or
-      ;; something like that.
-      (condition-case ()
-	  (Manual-insert-man-file name)
-	(file-error nil))
-      (goto-char (point-max))
-      (setq end (point))
-      (save-excursion
-	(save-restriction
-	  (message "Cleaning manual entry for %s..."
-		   (file-name-nondirectory name))
-	  (narrow-to-region start end)
-	  (Manual-nuke-nroff-bs)
-	  (goto-char (point-min))
-	  (insert "File: " name "\n")
-	  (goto-char (point-max))
-	  ))
-      (if (or (cdr fmtlist) manlist)
-	  (insert "\n\n" sep "\n"))
-      (setq fmtlist (cdr fmtlist)))
-
-    (while manlist			; process any unformatted files
-      (setq name (car manlist))
-      (or (string-match "\\([^/]+\\)\\.\\([^./]+\\)\\(\\.gz\\'\\)" name)
-	  (string-match "\\([^/]+\\)\\.\\([^./]+\\)\\'" name))
-      (setq topic (substring name (match-beginning 1) (match-end 1)))
-      (setq section (substring name (match-beginning 2) (match-end 2)))
-      ;; This won't work under IRIX, because SGI man accepts only the
-      ;; "main" (one-character) section id, not full section ids
-      ;; like 1M, 3X, etc. Put (setq Manual-use-full-section-ids nil)
-      ;; in your .emacs to work around this problem.
-      (if (not (or Manual-use-full-section-ids (string-equal section "")))
-	  (setq section (substring section 0 1)))
-      (message "Invoking man %s%s %s..."
-	       (if Manual-section-switch
-		   (concat Manual-section-switch " ")
-		 "")
-	       section topic)
-      (setq start (point))
-      (Manual-run-formatter name topic section)
-      (setq end (point))
-      (save-excursion
-	(save-restriction
-	  (message "Cleaning manual entry for %s(%s)..." topic section)
-	  (narrow-to-region start end)
-	  (Manual-nuke-nroff-bs apropos-mode)
-	  (goto-char (point-min))
-	  (insert "File: " name "\n")
-	  (goto-char (point-max))
-	  ))
-      (if (cdr manlist)
-	  (insert "\n\n" sep "\n"))
-      (setq manlist (cdr manlist))))
-  (if (< (buffer-size) 200)
-      (progn
-	(goto-char (point-min))
-	(if (looking-at "^File: ")
-	    (forward-line 1))
-	(error (buffer-substring (point) (progn (end-of-line) (point))))))
-  nil)
-
-
-(defun Manual-run-formatter (name topic section)
-  (cond
-   ((string-match "roff\\'" Manual-program)
-    ;; kludge kludge
-    (call-process Manual-program nil t nil "-Tman" "-man" name))
-
-   (t
-    (call-process Manual-program nil t nil
-                  (concat Manual-section-switch section) topic))))
-
-   ;(Manual-use-rosetta-man
-   ; (call-process "/bin/sh" nil t nil "-c"
-   ;               (format "man %s %s | rman" section topic)))
-
-
-(defvar Manual-mode-map
-  (let ((m (make-sparse-keymap)))
-    (set-keymap-name m 'Manual-mode-map)
-    (define-key m "l" 'Manual-last-page)
-    (define-key m 'button2 'Manual-follow-xref)
-    (define-key m 'button3 'Manual-popup-menu)
-    m))
-
-(defun Manual-mode ()
-  (kill-all-local-variables)
-  (setq buffer-read-only t)
-  (use-local-map Manual-mode-map)
-  (setq major-mode 'Manual-mode
-	mode-name "Manual")
-  ;; man pages with long lines are buggy!
-  ;; This looks slightly better if they only
-  ;; overran by a couple of chars.
-  (setq truncate-lines t)
-  (if (featurep 'scrollbar)
-      ;; turn off horizontal scrollbars in this buffer
-      (set-specifier scrollbar-height (cons (current-buffer) 0)))
-  (run-hooks 'Manual-mode-hook))
-
-(defun Manual-last-page ()
-  (interactive)
-  (while (or (not (get-buffer (car (or Manual-page-history
-				       (error "No more history.")))))
-	     (eq (get-buffer (car Manual-page-history)) (current-buffer)))
-    (setq Manual-page-history (cdr Manual-page-history)))
-  (switch-to-buffer (car Manual-page-history)))
-
-
-;; Manual-select-subdirectories
-;; Given a DIRLIST and a SUBDIR name, return all subdirectories of the former which
-;; match the latter.
-
-(defun Manual-select-subdirectories (dirlist subdir)
-  (let ((dirs '())
-        (case-fold-search nil)
-        (match (concat "\\`" (regexp-quote subdir)))
-        d)
-    (while dirlist
-      (setq d (car dirlist) dirlist (cdr dirlist))
-      (if (file-directory-p d)
-          (let ((files (directory-files d t match nil 'dirs-only))
-		(dir-temp '()))
-            (while files
-              (if (file-executable-p (car files))
-                  (setq dir-temp (cons (file-name-as-directory (car files))
-                                   dir-temp)))
-              (setq files (cdr files)))
-	    (and dir-temp
-		 (setq dirs (append dirs (nreverse dir-temp)))))))
-    dirs))
-
-
-;; Manual-filter-subdirectories
-;; Given a DIRLIST and a SUBDIR name, return all members of the former
-;; which match the latter.
-
-(defun Manual-filter-subdirectories (dirlist subdir)
-  (let ((match (concat
-		"/"
-		(regexp-quote subdir)
-		"[" Manual-man-page-section-ids "]"))
-	slist dir)
-    (while dirlist
-      (setq dir (car dirlist) dirlist (cdr dirlist))
-      (if (and (file-executable-p dir) (string-match match dir))
-	    (setq slist (cons dir slist))))
-    (nreverse slist)))
-
-
-(defun Manual-all-subdirectories (dirlist leaf-signature dirs &optional silent) "\
-Given a DIRLIST, return a backward-sorted list of all subdirectories
-thereof, prepended to DIRS if non-nil. This function calls itself
-recursively until subdirectories matching LEAF-SIGNATURE are reached,
-or the hierarchy has been thoroughly searched. This code is a modified
-version of a function written by Tim Bradshaw (tfb@ed.ac.uk)."
-  (Manual-all-subdirectories-noloop dirlist leaf-signature dirs nil silent))
-
-(defun Manual-all-subdirectories-noloop (dirlist leaf-signature dirs been &optional silent) "\
-Does the job of manual-all-subdirectories and keeps track of where it
-has been to avoid loops."
-  (let (dir)
-    (while dirlist
-      (setq dir (car dirlist) dirlist (cdr dirlist))
-      (if (file-directory-p dir)
-	  (let ((dir-temp (cons (file-name-as-directory dir) dirs)))
-	    ;; Without feedback the user might wonder about the delay!
-	    (or silent (message
-			"Building list of search directories... %s"
-			(car dir-temp)))
-	    (if (member (file-truename dir) been)
-		()		 ; Ignore. We have been here before
-	      (setq been (cons (file-truename dir) been))
-	      (setq dirs
-		    (if (string-match leaf-signature dir)
-			dir-temp
-		      (Manual-all-subdirectories-noloop
-		       (directory-files dir t "[^.]$" nil 'dirs-only)
-		       leaf-signature dir-temp been silent))))))))
-  dirs)
-
-
-(defvar Manual-bogus-file-pattern "\\.\\(lpr\\|ps\\|PS\\)\\'"
-  "Some systems have files in the man/man*/ directories which aren't man pages.
-This pattern is used to prune those files.")
-
-;; Manual-select-man-pages
-;;
-;; Given a DIRLIST, discover all filenames which complete given the TOPIC</