emacs: lisp/info.el comparison

comparison lisp/info.el @ 22692:578a6d997580

(Info-find-node): Handle cross references to an @anchor.

author	Richard M. Stallman <rms@gnu.org>
date	Sun, 05 Jul 1998 23:57:45 +0000
parents	4f99ccb85f3a
children	8d8e664f1f6c

comparison

equal deleted inserted replaced

-:ff0ed53342b3
+:578a6d997580
 (defun Info-find-node (filename nodename &optional no-going-back)
 ;; Convert filename to lower case if not found as specified.
 ;; Expand it.
 (if filename
 (let (temp temp-downcase found)
-	(setq filename (substitute-in-file-name filename))
+(setq filename (substitute-in-file-name filename))
-	(if (string= (downcase filename) "dir")
+(if (string= (downcase filename) "dir")
-	    (setq found t)
+(setq found t)
-	  (let ((dirs (if (string-match "^\\./" filename)
+(let ((dirs (if (string-match "^\\./" filename)
-			  ;; If specified name starts with `./'
+;; If specified name starts with `./'
-			  ;; then just try current directory.
+;; then just try current directory.
-			  '("./")
+'("./")
-			(if (file-name-absolute-p filename)
+(if (file-name-absolute-p filename)
-			    ;; No point in searching for an
+;; No point in searching for an
-			    ;; absolute file name
+;; absolute file name
-			    '(nil)
+'(nil)
-			  (if Info-additional-directory-list
+(if Info-additional-directory-list
-			      (append Info-directory-list
+(append Info-directory-list
-				      Info-additional-directory-list)
+Info-additional-directory-list)
-			    Info-directory-list)))))
+Info-directory-list)))))
-	    ;; Search the directory list for file FILENAME.
+;; Search the directory list for file FILENAME.
-	    (while (and dirs (not found))
+(while (and dirs (not found))
-	      (setq temp (expand-file-name filename (car dirs)))
+(setq temp (expand-file-name filename (car dirs)))
-	      (setq temp-downcase
+(setq temp-downcase
-		    (expand-file-name (downcase filename) (car dirs)))
+(expand-file-name (downcase filename) (car dirs)))
-	      ;; Try several variants of specified name.
+;; Try several variants of specified name.
-	      (let ((suffix-list Info-suffix-list))
+(let ((suffix-list Info-suffix-list))
-		(while (and suffix-list (not found))
+(while (and suffix-list (not found))
-		  (cond ((info-file-exists-p
+(cond ((info-file-exists-p
-			  (info-insert-file-contents-1
+(info-insert-file-contents-1
-			   temp (car (car suffix-list))))
+temp (car (car suffix-list))))
-			 (setq found temp))
+(setq found temp))
-			((info-file-exists-p
+((info-file-exists-p
-			  (info-insert-file-contents-1
+(info-insert-file-contents-1
-			   temp-downcase (car (car suffix-list))))
+temp-downcase (car (car suffix-list))))
-			 (setq found temp-downcase)))
+(setq found temp-downcase)))
-		  (setq suffix-list (cdr suffix-list))))
+(setq suffix-list (cdr suffix-list))))
-	      (setq dirs (cdr dirs)))))
+(setq dirs (cdr dirs)))))
-	(if found
+(if found
-	    (setq filename found)
+(setq filename found)
-	  (error "Info file %s does not exist" filename))))
+(error "Info file %s does not exist" filename))))
+;; Record the node we are leaving.
+(if (and Info-current-file (not no-going-back))
+(setq Info-history
+(cons (list Info-current-file Info-current-node (point))
+Info-history)))
 ;; Go into info buffer.
 (or (eq major-mode 'Info-mode) (pop-to-buffer "*info*"))
 (buffer-disable-undo (current-buffer))
 (or (eq major-mode 'Info-mode)
 (Info-mode))
-;; Record the node we are leaving.
-(if (and Info-current-file (not no-going-back))
-(setq Info-history
-	    (cons (list Info-current-file Info-current-node (point))
-		  Info-history)))
 (widen)
 (setq Info-current-node nil)
 (unwind-protect
 (progn
-	;; Switch files if necessary
+;; Switch files if necessary
-	(or (null filename)
+(or (null filename)
-	    (equal Info-current-file filename)
+(equal Info-current-file filename)
-	    (let ((buffer-read-only nil))
+(let ((buffer-read-only nil))
-	      (setq Info-current-file nil
+(setq Info-current-file nil
-		    Info-current-subfile nil
+Info-current-subfile nil
-		    Info-current-file-completions nil
+Info-current-file-completions nil
-		    buffer-file-name nil)
+buffer-file-name nil)
-	      (erase-buffer)
+(erase-buffer)
-	      (if (eq filename t)
+(if (eq filename t)
-		  (Info-insert-dir)
+(Info-insert-dir)
-		(info-insert-file-contents filename t)
+(info-insert-file-contents filename t)
-		(setq default-directory (file-name-directory filename)))
+(setq default-directory (file-name-directory filename)))
-	      (set-buffer-modified-p nil)
+(set-buffer-modified-p nil)
-	      ;; See whether file has a tag table.  Record the location if yes.
+;; See whether file has a tag table.  Record the location if yes.
-	      (goto-char (point-max))
+(goto-char (point-max))
-	      (forward-line -8)
+(forward-line -8)
-	      ;; Use string-equal, not equal, to ignore text props.
+;; Use string-equal, not equal, to ignore text props.
-	      (if (not (or (string-equal nodename "*")
+(if (not (or (string-equal nodename "*")
-			   (not
+(not
-			    (search-forward "\^_\nEnd tag table\n" nil t))))
+(search-forward "\^_\nEnd tag table\n" nil t))))
-		  (let (pos)
+(let (pos)
-		    ;; We have a tag table.  Find its beginning.
+;; We have a tag table.  Find its beginning.
-		    ;; Is this an indirect file?
+;; Is this an indirect file?
-		    (search-backward "\nTag table:\n")
+(search-backward "\nTag table:\n")
-		    (setq pos (point))
+(setq pos (point))
-		    (if (save-excursion
+(if (save-excursion
-			  (forward-line 2)
+(forward-line 2)
-			  (looking-at "(Indirect)\n"))
+(looking-at "(Indirect)\n"))
-			;; It is indirect.  Copy it to another buffer
+;; It is indirect.  Copy it to another buffer
-			;; and record that the tag table is in that buffer.
+;; and record that the tag table is in that buffer.
-			(let ((buf (current-buffer))
+(let ((buf (current-buffer))
-			      (tagbuf
+(tagbuf
-			       (or Info-tag-table-buffer
+(or Info-tag-table-buffer
-				   (generate-new-buffer " *info tag table*"))))
+(generate-new-buffer " *info tag table*"))))
-			  (setq Info-tag-table-buffer tagbuf)
+(setq Info-tag-table-buffer tagbuf)
-			  (save-excursion
+(save-excursion
-			    (set-buffer tagbuf)
+(set-buffer tagbuf)
 (buffer-disable-undo (current-buffer))
-			    (setq case-fold-search t)
+(setq case-fold-search t)
-			    (erase-buffer)
+(erase-buffer)
-			    (insert-buffer-substring buf))
+(insert-buffer-substring buf))
-			  (set-marker Info-tag-table-marker
+(set-marker Info-tag-table-marker
-				      (match-end 0) tagbuf))
+(match-end 0) tagbuf))
-		      (set-marker Info-tag-table-marker pos)))
+(set-marker Info-tag-table-marker pos)))
-		(set-marker Info-tag-table-marker nil))
+(set-marker Info-tag-table-marker nil))
-	      (setq Info-current-file
+(setq Info-current-file
-		    (if (eq filename t) "dir" filename))))
+(if (eq filename t) "dir" filename))))
-	;; Use string-equal, not equal, to ignore text props.
+;; Use string-equal, not equal, to ignore text props.
-	(if (string-equal nodename "*")
+(if (string-equal nodename "*")
-	    (progn (setq Info-current-node nodename)
+(progn (setq Info-current-node nodename)
-		   (Info-set-mode-line))
+(Info-set-mode-line))
-	  ;; Search file for a suitable node.
+;; Possibilities:
-	  (let ((guesspos (point-min))
+;;
-		(regexp (concat "Node: *" (regexp-quote nodename) " *[,\t\n\177]")))
+;; 1. Anchor found in tag table
-	    ;; First get advice from tag table if file has one.
+;; 2. Anchor *not* in tag table
-	    ;; Also, if this is an indirect info file,
+;;
-	    ;; read the proper subfile into this buffer.
+;; 3. Node found in tag table
-	    (if (marker-position Info-tag-table-marker)
+;; 4. Node *not* found in tag table, but found in file
-		(save-excursion
+;; 5. Node *not* in tag table, and *not* in file
-		  (let ((m Info-tag-table-marker)
+;;
-			found found-mode)
+;; *Or* the same, but in an indirect subfile.
-		    (save-excursion
-		      (set-buffer (marker-buffer m))
+;; Search file for a suitable node.
-		      (goto-char m)
+(let ((guesspos (point-min))
-		      (beginning-of-line) ;so re-search will work.
+(regexp
-		      (setq found (re-search-forward regexp nil t))
+(concat "\\(Node:\\|Ref:\\) *"
-		      (if found
+(regexp-quote nodename)
-			  (setq guesspos (read (current-buffer))))
+" *[,\t\n\177]")))
-		      (setq found-mode major-mode))
-		    (if found
+;; First, search a tag table, if any
-			(progn
+(if (marker-position Info-tag-table-marker)
-			  ;; If this is an indirect file, determine
-			  ;; which file really holds this node and
+(let (found-in-tag-table
-			  ;; read it in.
+found-mode
-			  (if (not (eq found-mode 'Info-mode))
+(m Info-tag-table-marker))
-			      ;; Note that the current buffer must be
+(save-excursion
-			      ;; the *info* buffer on entry to
+(set-buffer (marker-buffer m))
-			      ;; Info-read-subfile.  Thus the hackery
+(goto-char m)
-			      ;; above.
+(beginning-of-line) ; so re-search will work.
-			      (setq guesspos (Info-read-subfile guesspos))))
-		      (error "No such node: %s" nodename)))))
+;; Search tag table
-	    (goto-char (max (point-min) (- (byte-to-position guesspos) 1000)))
+(setq found-in-tag-table
-	    ;; Now search from our advised position (or from beg of buffer)
+(re-search-forward regexp nil t))
-	    ;; to find the actual node.
+(if found-in-tag-table
-	    (catch 'foo
+(setq guesspos (read (current-buffer))))
-	      (while (search-forward "\n\^_" nil t)
+(setq found-mode major-mode))
-		(forward-line 1)
-		(let ((beg (point)))
+;; Indirect file among split files
-		  (forward-line 1)
+(if found-in-tag-table
-		  (if (re-search-backward regexp beg t)
+(progn
-		      (throw 'foo t))))
+;; If this is an indirect file, determine
-	      (error "No such node: %s" nodename)))
+;; which file really holds this node and
-	  (Info-select-node)))
+;; read it in.
+(if (not (eq found-mode 'Info-mode))
+;; Note that the current buffer must be
+;; the *info* buffer on entry to
+;; Info-read-subfile.  Thus the hackery
+;; above.
+(setq guesspos (Info-read-subfile guesspos)))))
+;; Handle anchor
+(if (and found-in-tag-table
+(string-equal "Ref:" (match-string 1)))
+(goto-char guesspos)
+;; Else we may have a node, which we search for:
+(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)
+(forward-line 1)
+(let ((beg (point)))
+(forward-line 1)
+(if (re-search-backward regexp beg t)
+(progn
+(beginning-of-line)
+(throw 'foo t)))))
+(error
+"No such anchor in tag table or node in tag table or file: %s"
+nodename))))))
+(Info-select-node)))
 ;; If we did not finish finding the specified node,
 ;; go back to the previous one.
 (or Info-current-node no-going-back (null Info-history)
-	(let ((hist (car Info-history)))
+(let ((hist (car Info-history)))
-	  (setq Info-history (cdr Info-history))
+(setq Info-history (cdr Info-history))
-	  (Info-find-node (nth 0 hist) (nth 1 hist) t)
+(Info-find-node (nth 0 hist) (nth 1 hist) t)
-	  (goto-char (nth 2 hist)))))
+(goto-char (nth 2 hist))))))
-(goto-char (point-min)))
 ;; Cache the contents of the (virtual) dir file, once we have merged
 ;; it for the first time, so we can save time subsequently.
 (defvar Info-dir-contents nil)
 (setq Info-dir-contents (buffer-string)))
 (setq default-directory Info-dir-contents-directory))
 ;; Note that on entry to this function the current-buffer must be the
 ;; *info* buffer; not the info tags buffer.
-;; nodepos should be a byte-position such as is found in
-;; the Info file tags table.
 (defun Info-read-subfile (nodepos)
 ;; NODEPOS is either a position (in the Info file as a whole,
 ;; not relative to a subfile) or the name of a subfile.
 (let (lastfilepos
 	lastfilename)

Mercurial > emacs

comparison lisp/info.el @ 22692:578a6d997580