xemacs-beta: lisp/info.el comparison

comparison lisp/info.el @ 442:abe6d1db359e r21-2-36

Import from CVS: tag r21-2-36

author	cvs
date	Mon, 13 Aug 2007 11:35:02 +0200
parents	8de8e3f6228a
children	576fb035e263

comparison

equal deleted inserted replaced

-:72a7cfa4a488
+:abe6d1db359e
 ;; 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, Inc., 59 Temple Place - Suite 330,
 ;; Boston, MA 02111-1307, USA.
 ;;; Synched up with: Not synched with FSF.
 ;;
 ;; Added automatic dir/localdir (re)building capability for directories that
 ;; contain none or when it has become older than info files in the same
 ;; directory.
-;; Modified 1998-09-23 by Didier Verna <verna@inf.enst.fr>
+;; Modified 1998-09-23 by Didier Verna <didier@xemacs.org>
 ;;
 ;; Use the new macro `with-search-caps-disable-folding'
 ;; Code:
 (eval-when-compile
 use any existing `dir' or `localdir' file and ignore info
 directories containing none
 `always' auto-generate a directory listing ignoring existing
 `dir' and `localdir' files
 `if-missing', the default, auto-generates a directory listing
 if no `dir' or `localdir' file is present.  Otherwise the
 contents of any of these files is used instead.
 `if-outdated' auto-generates a directory listing if the `dir'
 and `localdir' are either inexistent or outdated (touched
 less recently than an info file in the same directory)."
 :type '(choice (const :tag "never" never)
 		 (const :tag "always" always)
 		 (const :tag "if-missing" if-missing)
 		 (const :tag "if-outdated" if-outdated))
 :group 'info)
-(defcustom Info-save-auto-generated-dir nil
+(defcustom Info-save-auto-generated-dir 'never
 "*Whether an auto-generated info directory listing should be saved.
 Possible values are:
 nil or `never', the default, auto-generated info directory
 information will never be saved.
 `always', auto-generated info directory information will be saved to
 a `dir' file in the same directory overwriting it if it exists
 `conservative', auto-generated info directory information will be saved
 to a `dir' file in the same directory but the user is asked before
 overwriting any existing file."
 :type '(choice (const :tag "never" never)
 		 (const :tag "always" always)
 		 (const :tag "conservative" conservative))
 :group 'info)
 (defface info-xref '((t (:bold t)))
 "Face used for cross-references in info."
 :group 'info-faces)
 ;; Is this right for NT?  .zip, with -c for to stdout, right?
 (defvar Info-suffix-list '( ("" . nil)
 			    (".info" . nil)
 			    (".info.bz2" . "bzip2 -dc %s")
 			    (".info.gz" . "gzip -dc %s")
 			    (".info-z" . "gzip -dc %s")
 			    (".info.Z" . "uncompress -c %s")
 or nil if current info file is not split into subfiles.")
 (defvar Info-current-node nil
 "Name of node that Info is now looking at, or nil.")
-(defvar Info-tag-table-marker (make-marker)
+(defvar Info-tag-table-marker nil
 "Marker pointing at beginning of current Info file's tag table.
 Marker points nowhere if file has no tag table.")
+(defvar Info-tag-table-buffer nil)
 (defvar Info-current-file-completions nil
 "Cached completion list for current Info file.")
 (defvar Info-current-annotation-completions nil
 This is the file .../info/dir, which contains the topmost node of the
 Info hierarchy.  The first time you invoke Info you start off
 looking at that node, which is (dir)Top.
 File: dir	Node: Top	This is the top of the INFO tree
 This (the Directory node) gives a menu of major topics.
 * Menu: The list of major topics begins on the next line.
 ")
 (while f
 (if (and (file-exists-p (car f)) (not (get-file-buffer (car f))))
 	  (bury-buffer (find-file-noselect (car f))))
 (setq f (cdr f)))))
+;;;###autoload
 (defun Info-find-node (filename &optional nodename no-going-back tryfile line)
 "Go to an info node specified as separate FILENAME and NODENAME.
 Look for a plausible filename, or if not found then look for URL's and
 dispatch to the appropriate fn.  NO-GOING-BACK is non-nil if
 recovering from an error in this function; it says do not attempt
 ;; empty filename is simple case
 ((null filename)
 (Info-find-file-node nil nodename no-going-back tryfile line))
 ;; Convert filename to lower case if not found as specified.
 ;; Expand it, look harder...
 ((let (temp temp-downcase found
 	       (fname (substitute-in-file-name filename)))
 (let ((dirs (cond
 		   ((string-match "^\\./" fname) ; If specified name starts with `./'
 		    (list default-directory)) ; then just try current directory.
 		   ((file-name-absolute-p fname)
 	  (if (equal temp-downcase temp) (setq temp-downcase nil))
 	  ;; Try several variants of specified name.
 	  ;; Try downcasing, appending a suffix, or both.
 	  (setq found (Info-suffixed-file temp temp-downcase))
 	  (setq dirs (cdr dirs)))
 	(if found
 	    (progn (setq filename (expand-file-name found))
 		   t))))
 (Info-find-file-node filename nodename no-going-back tryfile line))
 ;; Look for a URL.  This pattern is stolen from w3.el to prevent
 ;; loading it if we won't need it.
 				     &optional no-going-back tryfile line)
 ;; This is the guts of what was Info-find-node. Whoever wrote this
 ;; should be locked up where they can't do any more harm.
 ;; Go into info buffer.
-(switch-to-buffer "*info*")
+(or (eq major-mode 'Info-mode)
+(switch-to-buffer "*info*"))
 (buffer-disable-undo (current-buffer))
 (run-hooks 'Info-startup-hook)
 (or (eq major-mode 'Info-mode)
 (Info-mode))
 (or (null filename)
 (equal Info-current-file filename)
 (not Info-novice)
 (string= "dir" (file-name-nondirectory Info-current-file))
-(if (y-or-n-p-maybe-dialog-box
+(if (y-or-n-p
 	   (format "Leave Info file `%s'? "
 		   (file-name-nondirectory Info-current-file)))
 	  (message "")
 	(keyboard-quit)))
 ;; Record the node we are leaving.
 		    (if (save-excursion
 			  (forward-line 2)
 			  (looking-at "(Indirect)\n"))
 			;; It is indirect.  Copy it to another buffer
 			;; and record that the tag table is in that buffer.
-			(save-excursion
+			  (let ((buf (current-buffer))
-			  (let ((buf (current-buffer)))
+				(m Info-tag-table-marker))
-			    (set-buffer
+			    (or
-			     (get-buffer-create " *info tag table*"))
+			     Info-tag-table-buffer
-			    (buffer-disable-undo (current-buffer))
+			     (setq
-			    (setq case-fold-search t)
+			      Info-tag-table-buffer
-			    (erase-buffer)
+			      (generate-new-buffer " *info tag table*")))
-			    (insert-buffer-substring buf)
+			    (save-excursion
-			    (set-marker Info-tag-table-marker
+			      (set-buffer Info-tag-table-buffer)
-					(match-end 0))))
+			      (buffer-disable-undo (current-buffer))
+			      (setq case-fold-search t)
+			      (erase-buffer)
+			      (insert-buffer-substring buf)
+			      (set-marker m (match-end 0))))
 		     (set-marker Info-tag-table-marker pos))))
 	      (setq Info-current-file
 		    (file-name-sans-versions buffer-file-name))))
 	(if (equal nodename "*")
 	    (progn (setq Info-current-node nodename)
 		 (found t))
 	    ;; First get advice from tag table if file has one.
 	    ;; Also, if this is an indirect info file,
 	    ;; read the proper subfile into this buffer.
 	    (if (marker-position Info-tag-table-marker)
-		(save-excursion
+		(let (foun found-mode (m Info-tag-table-marker))
-		  (set-buffer (marker-buffer Info-tag-table-marker))
+		  (save-excursion
-		  (goto-char Info-tag-table-marker)
+		    (set-buffer (marker-buffer Info-tag-table-marker))
-		  (if (re-search-forward regexp nil t)
+		    (goto-char m)
-		      (progn
+		    (setq foun (re-search-forward regexp nil t))
-			(setq guesspos (read (current-buffer)))
+		    (if foun
-			;; If this is an indirect file,
+			(setq guesspos (read (current-buffer))))
-			;; determine which file really holds this node
+		    (setq found-mode major-mode))
-			;; and read it in.
+		  (if foun
-			(if (not (eq (current-buffer) (get-buffer "*info*")))
+		      ;; If this is an indirect file,
-			    (setq guesspos
+		      ;; determine which file really holds this node
-				  (Info-read-subfile guesspos)))))))
+		      ;; and read it in.
+		      (if (not (eq major-mode found-mode))
+			  (setq guesspos
+				(Info-read-subfile guesspos))))))
 	    (goto-char (max (point-min) (- guesspos 1000)))
 	    ;; Now search from our advised position (or from beg of buffer)
 	    ;; to find the actual node.
 	    (catch 'foo
 	      (while (search-forward "\n\^_" nil t)
 		      (set-buffer (or buf
 				      (generate-new-buffer
 				       (if (string-match "localdir" file)
 					   "localdir"
 					 "info dir"))))
 		      (if (not buf)
 			  (insert-file-contents file))
 		      (if (string-match "localdir" (buffer-name))
 			  (setq lbuffers (cons (current-buffer) lbuffers))
 			(setq buffers (cons (current-buffer) buffers)))
 		      (if attrs
 			  (setq Info-dir-file-attributes
 				(cons (cons file attrs)
 				      Info-dir-file-attributes)))))))
 	  (or (cdr dirs) (setq Info-dir-contents-directory (car dirs)))
 	  (setq dirs (cdr dirs))))
 ;; ensure that the localdir files are inserted last, and reverse
 ;; the list of them so that when they get pushed in, they appear
 ;; in the same order they got specified in the path, from top to
 ;; bottom.
 (nconc buffers (reverse lbuffers))
 (or buffers
 	  (error "Can't find the Info directory node"))
 ;; Distinguish the dir file that comes with Emacs from all the
 ;; others.  Yes, that is really what this is supposed to do.
 ;; If it doesn't work, fix it.
 		  (search-forward "\n\^_" nil 'move)
 		  (beginning-of-line)
 		  (setq end (point))
 		  (setq nodes (cons (list nodename other beg end) nodes))))))
 	  (setq others (cdr others))))
 ;; Add to the main menu a menu item for each other node.
 (re-search-forward "^\\* Menu:" nil t)
 (forward-line 1)
 (let ((menu-items '("top"))
 	    (nodes nodes)
 (unless (or (not (file-exists-p (file-name-directory file)))
 	      (null (directory-files (file-name-directory file) nil "\\.info")))
 (if (not (find-buffer-visiting file))
 	(if (not (file-exists-p file))
 	    (if (or (eq Info-auto-generate-directory 'always)
 		    (eq Info-auto-generate-directory 'if-missing))
 		(Info-build-dir-anew (file-name-directory file)))
 	  (if (or (eq Info-auto-generate-directory 'always)
 		  (and (eq Info-auto-generate-directory 'if-outdated)
 		       (Info-dir-outdated-p file)))
 	      (Info-rebuild-dir file))))))
 directory has been modified more recently."
 (let ((dir-mod-time (nth 5 (file-attributes file)))
 	f-mod-time
 	newer)
 (setq Info-dir-newer-info-files nil)
 (mapcar
 #'(lambda (f)
 	 (prog2
 	     (setq f-mod-time (nth 5 (file-attributes f)))
 	     (setq newer (or (> (car f-mod-time) (car dir-mod-time))
 			     (and (= (car f-mod-time) (car dir-mod-time))
 				  (> (car (cdr f-mod-time)) (car (cdr dir-mod-time))))))
 	   (if (and (file-readable-p f)
 		    newer)
 	       (setq Info-dir-newer-info-files
 		     (cons f Info-dir-newer-info-files)))))
 (directory-files (file-name-directory file)
 		      'fullname
 		      ".*\\.info\\(\\.gz\\|\\.bz2\\|\\.Z\\|-z\\|\\.zip\\)?$"
 		      'nosort
 	(while (re-search-forward "^\\* \\([^:]+\\):\\([ \t]*(\\([^)]*\\))\\w*\\.\\|:\\)" nil t)
 	  (setq entry (list (match-string 2)
 			    (match-string 1)
 			    (downcase (or (match-string 3)
 					  (match-string 1)))))
 	  (setq entry
 		(cons (nreverse
 		       (cdr
 			(nreverse
 			 (split-string
 			  (buffer-substring
 			   (re-search-forward "[ \t]*" nil t)
 			   (or (and (re-search-forward "^[^ \t]" nil t)
 				    (goto-char (match-beginning 0)))
 			       (point-max)))
 			  "[ \t]*\n[ \t]*"))))
 		(setq len (length (concat (car e)
 					  (car (cdr e)))))
 		(if (> len description-col)
 		    (setq description-col len)))
 	    entries)
 (setq description-col (+ 5 description-col))
 (mapcar #'(lambda (e)
 		(setq e (cdr e))	; Drop filename
 		(insert "* " (car e) ":" (car (cdr e)))
 		(setq e (car (cdr (cdr e))))
 		(while e
 (insert "\n")))
 (defun Info-build-dir-anew (directory)
 "Build info directory information for DIRECTORY.
 The generated directory listing may be saved to a `dir' according
 to the value of `Info-save-auto-generated-dir'"
 (save-excursion
 (let* ((dirfile (expand-file-name "dir" directory))
 	   (to-temp (or (null Info-save-auto-generated-dir)
 			(eq Info-save-auto-generated-dir 'never)
 			(and (not (file-writable-p dirfile))
 			     (message "File not writable %s. Using temporary." dirfile))))
 	   (info-files
 	    (directory-files directory
 			     'fullname
 			     ".*\\.info\\(.gz\\|.Z\\|-z\\|.zip\\)?$"
 			     nil
 			     t)))
 (set-buffer (find-file-noselect dirfile t))
 (setq buffer-read-only nil)
 (erase-buffer)
 (insert Info-dir-prologue
 	      "Info files in " directory ":\n\n")
 (Info-dump-dir-entries
 (mapcar
 	#'(lambda (f)
 	    (or (Info-extract-dir-entry-from f)
 		(list 'dummy
 		      (progn
 			(string-match "\\(.*\\)\\.info\\(.gz\\|.Z\\|-z\\|.zip\\)?$"
 				      (file-name-nondirectory f))
 			(capitalize (match-string 1 (file-name-nondirectory f))))
 		      ":"
 		      (list Info-no-description-string))))
 	info-files))
 	(message "Creating %s...done" dirfile)))))
 (defun Info-rebuild-dir (file)
 "Build info directory information in the directory of dir FILE.
 Description of info files are merged from the info files in the
 directory and the contents of FILE with the description in info files
 taking precedence over descriptions in FILE.
 The generated directory listing may be saved to a `dir' according to
 the value of `Info-save-auto-generated-dir' "
 (save-excursion
 (save-restriction
 (let (dir-section-contents dir-full-contents
 	    dir-entry
 	    file-dir-entry
 	    mark next-section
 	    not-first-section
 	    (to-temp
 	     (or (null Info-save-auto-generated-dir)
 		 (eq Info-save-auto-generated-dir 'never)
 		 (and (eq Info-save-auto-generated-dir 'always)
 		      (not (file-writable-p file))
 		      (message "File not writable %s. Using temporary." file))
 		 (and (eq Info-save-auto-generated-dir 'conservative)
 		      (or (and (not (file-writable-p file))
 			       (message "File not writable %s. Using temporary." file))
 			  (not (y-or-n-p
 				(message "%s is outdated. Overwrite ? "
 					 file))))))))
 	(set-buffer (find-file-noselect file t))
 	(setq buffer-read-only nil)
 	(if to-temp
 	    (message "Rebuilding temporary %s..." file)
 					(file-name-nondirectory file)))
 				      dir-full-contents))
 		     (if file-dir-entry
 			 (setq dir-section-contents (cons file-dir-entry
 							  dir-section-contents))
 		       (setq dir-section-contents
 			     (cons (list 'dummy
 					 (capitalize (file-name-sans-extension
 						      (file-name-nondirectory file)))
 					 ":"
 					 (list Info-no-description-string))
 				   dir-section-contents))))))
 	     Info-dir-newer-info-files)
 	    (delete-region (point-min) (point-max))
 	    (Info-dump-dir-entries (nreverse dir-section-contents))
 	    (widen)
 	      (set-buffer-modified-p nil)
 	      (message "Rebuilding temporary %s...done" file))
 	  (save-buffer)
 	  (message "Rebuilding %s...done" file))))))
 ;;;###autoload
 (defun Info-batch-rebuild-dir ()
 "(Re)build info `dir' files in the directories remaining on the command line.
 Use this from the command line, with `-batch';
 it won't work in an interactive Emacs.
 Each file is processed even if an error occurred previously.
 (if  (not (file-directory-p (car command-line-args-left)))
 	  (message "Warning: Skipped %s. Not a directory."
 		   (car command-line-args-left))
 	(setq dir (expand-file-name "dir" (car command-line-args-left)))
 	(setq localdir (expand-file-name "localdir" (car command-line-args-left)))
 	(cond
 	 ((file-exists-p dir)
 	  (Info-rebuild-dir dir))
 	 ((file-exists-p localdir)
 	  (Info-rebuild-dir localdir))
 	 (t
 (while (and p (not (equal (car p) dir)))
 (setq p (cdr p)))
 (if p (file-name-nondirectory file) file)))
 (defun Info-read-subfile (nodepos)
-(set-buffer (marker-buffer Info-tag-table-marker))
-(goto-char (point-min))
-(search-forward "\n\^_")
 (let (lastfilepos
 	lastfilename)
-(forward-line 2)
+(save-excursion
-(catch 'foo
+(set-buffer (marker-buffer Info-tag-table-marker))
-(while (not (looking-at "\^_"))
+(goto-char (point-min))
-	(if (not (eolp))
+(search-forward "\n\^_")
-	    (let ((beg (point))
+(forward-line 2)
-		  thisfilepos thisfilename)
+(catch 'foo
-	      (search-forward ": ")
+	(while (not (looking-at "\^_"))
-	      (setq thisfilename  (buffer-substring beg (- (point) 2)))
+	  (if (not (eolp))
-	      (setq thisfilepos (read (current-buffer)))
+	      (let ((beg (point))
-	      ;; read in version 19 stops at the end of number.
+		    thisfilepos thisfilename)
-	      ;; Advance to the next line.
+		(search-forward ": ")
-	      (if (eolp)
+		(setq thisfilename  (buffer-substring beg (- (point) 2)))
-		  (forward-line 1))
+		(setq thisfilepos (read (current-buffer)))
-	      (if (> thisfilepos nodepos)
+		;; read in version 19 stops at the end of number.
-		  (throw 'foo t))
+		;; Advance to the next line.
-	      (setq lastfilename thisfilename)
+		(if (eolp)
-	      (setq lastfilepos thisfilepos))
+		    (forward-line 1))
-	  (throw 'foo t))))
+		(if (> thisfilepos nodepos)
-(set-buffer (get-buffer "*info*"))
+		    (throw 'foo t))
+		(setq lastfilename thisfilename)
+		(setq lastfilepos thisfilepos))
+	    (throw 'foo t)))))
 (or (equal Info-current-subfile lastfilename)
 	(let ((buffer-read-only nil))
 	  (setq buffer-file-name nil)
 	  (widen)
 	  (erase-buffer)
 	    (setq bufs (cdr bufs)))
 	  (setq Info-current-annotation-completions compl)))))
 (defun Info-build-node-completions ()
 (or Info-current-file-completions
-(let ((compl (Info-build-annotation-completions)))
+(let ((m Info-tag-table-marker)
+	    (compl (Info-build-annotation-completions)))
 	(save-excursion
 	  (save-restriction
 	    (widen)
 	    (if (marker-buffer Info-tag-table-marker)
 		(progn
 		  (set-buffer (marker-buffer Info-tag-table-marker))
-		  (goto-char Info-tag-table-marker)
+		  (goto-char m)
 		  (while (re-search-forward "\nNode: \\(.*\\)\177" nil t)
 		    (setq compl
 			  (cons (list (buffer-substring (match-beginning 1)
 							(match-end 1)))
 				compl))))
 		(forward-line 1)
 		(let ((beg (point)))
 		  (forward-line 1)
 		  (if (re-search-backward "Node: *\\([^,\n]*\\) *[,\n\t]"
 					  beg t)
 		      (setq compl
 			    (cons (list (buffer-substring (match-beginning 1)
 							  (match-end 1)))
 				  compl))))))))
 	(setq Info-current-file-completions compl))))
 (progn (re-search-forward regexp) (setq found (point)))
 (search-failed nil)))))
 (if (not found)                   ;can only happen in subfile case -- else would have erred
 (unwind-protect
 (let ((list ()))
-(set-buffer (marker-buffer Info-tag-table-marker))
+(save-excursion
-(goto-char (point-min))
+		  (set-buffer (marker-buffer Info-tag-table-marker))
-(search-forward "\n\^_\nIndirect:")
+		  (goto-char (point-min))
-(save-restriction
+		  (search-forward "\n\^_\nIndirect:")
-(narrow-to-region (point)
+		  (save-restriction
-(progn (search-forward "\n\^_")
+		    (narrow-to-region (point)
-(1- (point))))
+				      (progn (search-forward "\n\^_")
-(goto-char (point-min))
+					     (1- (point))))
-(search-forward (concat "\n" osubfile ": "))
+		    (goto-char (point-min))
-(beginning-of-line)
+		    (search-forward (concat "\n" osubfile ": "))
-(while (not (eobp))
+		    (beginning-of-line)
-(re-search-forward "\\(^.*\\): [0-9]+$")
+		    (while (not (eobp))
-(goto-char (+ (match-end 1) 2))
+		      (re-search-forward "\\(^.*\\): [0-9]+$")
-(setq list (cons (cons (read (current-buffer))
+		      (goto-char (+ (match-end 1) 2))
-(buffer-substring (match-beginning 1)
+		      (setq list (cons (cons (read (current-buffer))
-(match-end 1)))
+					     (buffer-substring (match-beginning 1)
-list))
+							       (match-end 1)))
-(goto-char (1+ (match-end 0))))
+				       list))
-(setq list (nreverse list)
+		      (goto-char (1+ (match-end 0))))
-list (cdr list)))
+		    (setq list (nreverse list)
+			  list (cdr list))))
 (while list
 (message "Searching subfile %s..." (cdr (car list)))
 (Info-read-subfile (car (car list)))
 (setq list (cdr list))
 (goto-char (point-min))
 (or (and (equal onode Info-current-node)
 (equal ofile Info-current-file))
 (Info-history-add ofile onode opoint)))))
 ;; Extract the value of the node-pointer named NAME.
 ;; If there is none, use ERRORNAME in the error message;
 ;; if ERRORNAME is nil, just return nil.
 (defun Info-extract-pointer (name &optional errorname)
 (save-excursion
 (goto-char (point-min))
 (forward-line 4)
 	         (setq item nil))))
 (list item))))
 ;; there is a problem here in that if several menu items have the same
 ;; name you can only go to the node of the first with this command.
 (Info-goto-node (Info-extract-menu-item menu-item) nil t))
 (defun Info-extract-menu-item (menu-item &optional noerror)
 (save-excursion
 (goto-char (point-min))
 (if (let ((case-fold-search t))
 	  (search-forward "\n* menu:" nil t))
 ;;;###autoload
 (defun Info-elisp-ref (func)
 "Look up an Emacs Lisp function in the Elisp manual in the Info system.
 This command is designed to be used whether you are already in Info or not."
 (interactive (let ((fn (function-at-point))
 		     (enable-recursive-minibuffers t)
 		     val)
 		 (setq val (completing-read
 			    (format "Look up Emacs Lisp function%s: "
 				    (if fn
 					(format " (default %s)" fn)
 ;  (setq buffer-mouse-map Info-mode-mouse-map)
 (make-local-variable 'Info-current-file)
 (make-local-variable 'Info-current-subfile)
 (make-local-variable 'Info-current-node)
 (make-local-variable 'Info-tag-table-marker)
+(setq Info-tag-table-marker (make-marker))
+(make-local-variable 'Info-tag-table-buffer)
+(setq Info-tag-table-buffer nil)
 (make-local-variable 'Info-current-file-completions)
 (make-local-variable 'Info-current-annotation-completions)
 (make-local-variable 'Info-index-alternatives)
 (make-local-variable 'Info-history)
 ;; Faces are now defined by `defface'...
 (defun Info-cease-edit ()
 "Finish editing Info node; switch back to Info proper."
 (interactive)
 ;; Do this first, so nothing has changed if user C-g's at query.
 (and (buffer-modified-p)
-(y-or-n-p-maybe-dialog-box "Save the file? ")
+(y-or-n-p "Save the file? ")
 (save-buffer))
 (use-local-map Info-mode-map)
 (setq major-mode 'Info-mode)
 (setq mode-name "Info")
 (Info-set-mode-line)
 "Construct a menu of Info commands.
 Adds an entry for the node at EVENT, or under point if EVENT is omitted.
 Used to construct the menubar submenu and popup menu."
 (or event (setq event (point)))
 (let ((case-fold-search t)
 	(xref-regexp (concat "\\*"
 			     (regexp-quote Info-footnote-tag)
 			     "[ \n\t]*\\([^:]*\\):"))
 	up-p prev-p next-p menu xrefs subnodes in)
 (save-excursion
 ;; `one-space' fixes "Notes:" xrefs that are split across lines.

Mercurial > hg > xemacs-beta

comparison lisp/info.el @ 442:abe6d1db359e r21-2-36