(Info-find-node-2): Restructure [following "Vadim S. Solomin"

<sovs@uic.nnov.ru>].

diff --git a/lisp/info.el b/lisp/info.el
index 8b4efe5887a87591deaaf231e87b6e62c1de0b5f..c8115ce957b6b8e39aa3fc35560fa4a7eba6cd9c 100644 (file)
--- a/lisp/info.el
+++ b/lisp/info.el
@@ -510,106 +510,70 @@ else defaults to `Top'."
                         "\\) *[,\t\n\177]"))
                (nodepos nil))
 
-            ;; First, search a tag table, if any
-            (if (marker-position Info-tag-table-marker)
-               (let ((found-in-tag-table t)
-                     found-anchor
-                     found-mode
-                     (m Info-tag-table-marker))
-                  (save-excursion
-                    (set-buffer (marker-buffer m))
-                    (goto-char m)
-                    (beginning-of-line) ; so re-search will work.
-
-                    ;; Search tag table
-                   (catch 'foo
-                     (while (re-search-forward regexp nil t)
-                       (setq found-anchor
-                             (string-equal "Ref:" (match-string 1)))
-                       (or nodepos (setq nodepos (point))
-                       (if (string-equal (match-string 2) nodename)
-                           (throw 'foo t))))
-                     (if nodepos
-                         (goto-char nodepos)
-                       (setq found-in-tag-table nil)))
-                    (if found-in-tag-table
-                        (setq guesspos (1+ (read (current-buffer)))))
-                    (setq found-mode major-mode))
-
-                  ;; Indirect file among split files
-                  (if found-in-tag-table
-                      (progn
-                        ;; If this is an indirect file, determine
-                        ;; which file really holds this node and
-                        ;; 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 found-anchor
-                     (goto-char (setq anchorpos guesspos))
-
-                    ;; Else we may have a node, which we search for:
-                   (let ((guesschar
-                          (or (byte-to-position guesspos)
-                              (if (< (position-bytes (point-max)) guesspos)
-                                  (point-max)
-                                (point-min)))))
-                     (goto-char (max (point-min)
-                                     (- guesschar 1000))))
-                    ;; Now search from our advised position
-                    ;; (or from beg of buffer)
-                    ;; to find the actual node.
-                   ;; First, check whether the node is right
-                   ;; where we are, in case the buffer begins
-                   ;; with a node.
-                   (setq nodepos nil)
-                   (or (Info-node-at-bob-matching regexp)
-                       (catch 'foo
-                         (while (search-forward "\n\^_" nil t)
-                           (forward-line 1)
-                           (let ((beg (point)))
-                             (forward-line 1)
-                             (if (re-search-backward regexp beg t)
-                                 (if (string-equal (match-string 2) nodename)
-                                     (progn
-                                       (beginning-of-line)
-                                       (throw 'foo t))
-                                   (or nodepos
-                                     (setq nodepos (point)))))))
-                         (if nodepos
-                             (progn
-                               (goto-char nodepos)
-                               (beginning-of-line))
-                           (error
-                            "No such anchor in tag table or node in tag table or file: %s"
-                            nodename))))))
-             (goto-char (max (point-min) (- guesspos 1000)))
-             ;; Now search from our advised position (or from beg of buffer)
+           (catch 'foo
+             ;; First, search a tag table, if any
+             (if (marker-position Info-tag-table-marker)
+                 (let (found-in-tag-table
+                       found-anchor
+                       found-mode
+                       (m Info-tag-table-marker))
+                   (save-excursion
+                     (set-buffer (marker-buffer m))
+                     (goto-char m)
+                     (beginning-of-line) ; so re-search will work.
+
+                     ;; Search tag table
+                     (setq found-in-tag-table
+                           (re-search-forward regexp nil t)
+                           found-anchor
+                           (string-equal "Ref:" (match-string 1)))
+                     (if found-in-tag-table
+                         (setq guesspos (1+ (read (current-buffer)))))
+                     (setq found-mode major-mode))
+
+                   ;; Indirect file among split files
+                   (if found-in-tag-table
+                       (progn
+                         ;; If this is an indirect file, determine
+                         ;; which file really holds this node and
+                         ;; 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 found-anchor
+                       (progn
+                         (goto-char (setq anchorpos guesspos))
+                         (throw 'foo t)))))
+
+             ;; Else we may have a node, which we search for:
+             (goto-char (max (point-min)
+                             (- (byte-to-position guesspos) 1000)))
+             ;; Now search from our advised position
+             ;; (or from beg of buffer)
              ;; to find the actual node.
-             ;; First, check whether the node is right where we are, in case
-             ;; the buffer begins with a node.
-             (setq nodepos nil)
+             ;; First, check whether the node is right
+             ;; where we are, in case the buffer begins
+             ;; with a node.
              (or (Info-node-at-bob-matching regexp)
-                 (catch 'foo
-                   (while (search-forward "\n\^_" nil t)
+                 (while (search-forward "\n\^_" nil t)
+                   (forward-line 1)
+                   (let ((beg (point)))
                      (forward-line 1)
-                     (let ((beg (point)))
-                       (forward-line 1)
-                       (if (re-search-backward regexp beg t)
-                           (if (string-equal (match-string 2) nodename)
-                               (throw 'foo t)
-                             (or nodepos
-                                 (setq nodepos (point)))))))
-                   (if nodepos
-                       (goto-char nodepos)
-                     (error "No such node: %s" nodename))))))
-          (Info-select-node)
-         (goto-char (or anchorpos (point-min)))))
+                     (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)
+           (goto-char (or anchorpos (point-min))))))
     ;; 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)