info-xref.el 22 KB
Newer Older
Mark Oteiza's avatar
Mark Oteiza committed
1
;;; info-xref.el --- check external references in an Info document -*- lexical-binding: t -*-
Juri Linkov's avatar
Juri Linkov committed
2

Paul Eggert's avatar
Paul Eggert committed
3
;; Copyright (C) 2003-2019 Free Software Foundation, Inc.
Juanma Barranquero's avatar
Juanma Barranquero committed
4 5 6

;; Author: Kevin Ryde <user42@zip.com.au>
;; Keywords: docs
Kevin Ryde's avatar
Kevin Ryde committed
7
;; Version: 3
Juanma Barranquero's avatar
Juanma Barranquero committed
8

Juri Linkov's avatar
Juri Linkov committed
9 10
;; This file is part of GNU Emacs.

11
;; GNU Emacs is free software: you can redistribute it and/or modify
Juri Linkov's avatar
Juri Linkov committed
12
;; it under the terms of the GNU General Public License as published by
13 14
;; the Free Software Foundation, either version 3 of the License, or
;; (at your option) any later version.
Juri Linkov's avatar
Juri Linkov committed
15 16 17 18 19 20 21

;; GNU Emacs is distributed in the hope that it will be useful,
;; but WITHOUT ANY WARRANTY; without even the implied warranty of
;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
;; GNU General Public License for more details.

;; You should have received a copy of the GNU General Public License
22
;; along with GNU Emacs.  If not, see <https://www.gnu.org/licenses/>.
Juanma Barranquero's avatar
Juanma Barranquero committed
23 24 25

;;; Commentary:

Kevin Ryde's avatar
Kevin Ryde committed
26 27
;; This is some simple checking of external cross references in info files,
;; docstrings and custom-links by attempting to visit the nodes specified.
Juanma Barranquero's avatar
Juanma Barranquero committed
28
;;
Kevin Ryde's avatar
Kevin Ryde committed
29 30
;; `M-x info-xref-check' checks a single info file.  See the docstring for
;; details.
Juanma Barranquero's avatar
Juanma Barranquero committed
31
;;
Kevin Ryde's avatar
Kevin Ryde committed
32 33
;; `M-x info-xref-check-all' checks all info files in Info-directory-list.
;; This is a good way to check the consistency of the whole system.
Juanma Barranquero's avatar
Juanma Barranquero committed
34
;;
Kevin Ryde's avatar
Kevin Ryde committed
35 36
;; `M-x info-xref-check-all-custom' loads up all defcustom variables and
;; checks any info references in them.
Juanma Barranquero's avatar
Juanma Barranquero committed
37
;;
Kevin Ryde's avatar
Kevin Ryde committed
38 39 40 41 42 43
;; `M-x info-xref-docstrings' checks docstring "Info node ..." hyperlinks in
;; source files (and other files).

;;; History:

;; Version 3 - new M-x info-xref-docstrings, use compilation-mode
Juanma Barranquero's avatar
Juanma Barranquero committed
44 45 46 47

;;; Code:

(require 'info)
48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66
(eval-when-compile (require 'cl-lib))   ; for `cl-incf'

(defgroup info-xref nil
  "Check external cross-references in Info documents."
  :group 'docs)                         ; FIXME right parent?

;; Should this even be an option?
(defcustom info-xref-case-fold nil
  "Non-nil means node checks should ignore case.
When following cross-references, the Emacs Info reader first tries a
case-sensitive match, then if that fails a case-insensitive one.
The standalone Info reader does not do this, nor does this work
for links in the html versions of Texinfo manuals.  Therefore
to ensure your cross-references work on the widest range of platforms,
you should set this variable to nil."
  :group 'info-xref
  :type 'boolean
  :version "24.4")

Kevin Ryde's avatar
Kevin Ryde committed
67 68 69 70 71 72 73

;;-----------------------------------------------------------------------------
;; vaguely generic

(defun info-xref-lock-file-p (filename)
  "Return non-nil if FILENAME is an Emacs lock file.
A lock file is \".#foo.txt\" etc per `lock-buffer'."
74
  (string-match "\\(\\`\\|/\\)\\.#" filename))
Kevin Ryde's avatar
Kevin Ryde committed
75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113

(defun info-xref-subfile-p (filename)
  "Return t if FILENAME is an info subfile.
If removing the last \"-<NUM>\" from the filename gives a file
which exists, then consider FILENAME a subfile.  This is an
imperfect test, probably ought to open up the purported top file
and see what subfiles it says."
  (and (string-match "\\`\\(\\([^-]*-\\)*[^-]*\\)-[0-9]+\\(.*\\)\\'" filename)
       (file-exists-p (concat (match-string 1 filename)
                              (match-string 3 filename)))))

(defmacro info-xref-with-file (filename &rest body)
  ;; checkdoc-params: (filename body)
  "Evaluate BODY in a buffer containing the contents of FILENAME.
If FILENAME is already in a buffer then that's used, otherwise a
temporary buffer.

The current implementation uses `insert-file-contents' rather
than `find-file-noselect' so as not to be held up by queries
about local variables or possible weirdness in a major mode.
`lm-with-file' does a similar thing, but it sets
`emacs-lisp-mode' which is not wanted here."

  (declare (debug t) (indent 1))
  `(let* ((info-xref-with-file--filename ,filename)
          (info-xref-with-file--body     (lambda () ,@body))
          (info-xref-with-file--existing
           (find-buffer-visiting info-xref-with-file--filename)))
     (if info-xref-with-file--existing
         (with-current-buffer info-xref-with-file--existing
           (save-excursion
             (funcall info-xref-with-file--body)))
       (with-temp-buffer
         (insert-file-contents ,filename)
         (funcall info-xref-with-file--body)))))


;;-----------------------------------------------------------------------------
;; output buffer
Juanma Barranquero's avatar
Juanma Barranquero committed
114

Kevin Ryde's avatar
Kevin Ryde committed
115
(defconst info-xref-output-buffer "*info-xref results*"
Juanma Barranquero's avatar
Juanma Barranquero committed
116 117
  "Name of the buffer for info-xref results.")

Kevin Ryde's avatar
Kevin Ryde committed
118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170
(defvar info-xref-good 0
  "Count of good cross references, during info-xref processing.")
(defvar info-xref-bad 0
  "Count of bad cross references, during info-xref processing.")
(defvar info-xref-unavail 0
  "Count of unavailable cross references, during info-xref processing.")

(defvar info-xref-output-heading ""
  "A heading string, during info-xref processing.
This is shown if there's an error, but not if successful.")

(defvar info-xref-filename nil
  "The current buffer's filename, during info-xref processing.
When looking at file contents in a temp buffer there's no
`buffer-file-name', hence this variable.")

(defvar info-xref-xfile-alist nil
  "Info files found or not found, during info-xref processing.
Key is \"(foo)\" etc and value nil or t according to whether info
manual \"(foo)\" exists or not.  This is used to suppress
duplicate messages about foo not being available.  (Duplicates
within one top-level file that is.)")

(defvar info-xref-in-progress nil)
(defmacro info-xref-with-output (&rest body)
  "Run BODY with an info-xref output buffer.
This is meant to nest, so you can wrap it around a set of
different info-xref checks and have them write to the one output
buffer created by the outermost `info-xref-with-output', with an
overall good/bad count summary inserted at the very end."

  (declare (debug t))
  `(save-excursion
     (unless info-xref-in-progress
       (display-buffer (get-buffer-create info-xref-output-buffer))
       (set-buffer info-xref-output-buffer)
       (setq buffer-read-only nil)
       (fundamental-mode)
       (erase-buffer)
       (insert ";; info-xref output -*- mode: compilation -*-\n\n")
       (compilation-mode)
       (setq info-xref-good    0
             info-xref-bad     0
             info-xref-unavail 0
             info-xref-xfile-alist nil))

     (let ((info-xref-in-progress t)
           (info-xref-output-heading ""))
       ,@body)

     (unless info-xref-in-progress
       (info-xref-output "done, %d good, %d bad, %d unavailable"
                         info-xref-good info-xref-bad info-xref-unavail))))
171

Kevin Ryde's avatar
Kevin Ryde committed
172
(defun info-xref-output (fmt &rest args)
173
  "Emit a `format-message'-ed message FMT+ARGS to the `info-xref-output-buffer'."
Kevin Ryde's avatar
Kevin Ryde committed
174 175 176 177 178
  (with-current-buffer info-xref-output-buffer
    (save-excursion
      (goto-char (point-max))
      (let ((inhibit-read-only t))
        (insert info-xref-output-heading
179
                (apply #'format-message fmt args)
Kevin Ryde's avatar
Kevin Ryde committed
180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219
                "\n")))
    (setq info-xref-output-heading "")
    ;; all this info-xref can be pretty slow, display now so the user sees
    ;; some progress
    (sit-for 0)))
(put 'info-xref-output 'byte-compile-format-like t)

(defun info-xref-output-error (fmt &rest args)
  "Emit a `format'-ed error FMT+ARGS to the `info-xref-output-buffer'.
The error is attributed to `info-xref-filename' and the current
buffer's line and column of point."
  (apply 'info-xref-output
         (concat "%s:%s:%s: " fmt)
         info-xref-filename
         (1+ (count-lines (point-min) (line-beginning-position)))
         (1+ (current-column))
         args))
(put 'info-xref-output-error 'byte-compile-format-like t)


;;-----------------------------------------------------------------------------
;; node checking

;; When asking Info-goto-node to fork, *info* needs to be the current
;; buffer, otherwise it seems to clone the current buffer but then do the
;; goto-node in plain *info*.
;;
;; We only fork if *info* already exists, if it doesn't then can create and
;; destroy just that instead of a new name.
;;
;; If Info-goto-node can't find the file, then no new buffer is created.  If
;; it finds the file but not the node, then a buffer is created.  Handle
;; this difference by checking before killing.
;;
(defun info-xref-goto-node-p (node)
  "Return t if it's possible to go to the given NODE."
  (let ((oldbuf (current-buffer)))
    (save-excursion
      (save-window-excursion
        (prog1
220
            (condition-case nil
Kevin Ryde's avatar
Kevin Ryde committed
221 222 223 224
                (progn
                  (Info-goto-node node
                                  (when (get-buffer "*info*")
                                    (set-buffer "*info*")
225 226
                                    "xref - temporary")
                                  (not info-xref-case-fold))
Kevin Ryde's avatar
Kevin Ryde committed
227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259
                  t)
              (error nil))
          (unless (equal (current-buffer) oldbuf)
            (kill-buffer)))))))

(defun info-xref-check-node (node)

  ;; Collapse spaces as per info.el and `help-make-xrefs'.
  ;; Note defcustom :info-link nodes don't get this whitespace collapsing,
  ;; they should be the exact node name ready to visit.
  ;; `info-xref-check-all-custom' uses `info-xref-goto-node-p' and so
  ;; doesn't come through here.
  ;;
  ;; Could use "[\t\n ]+" but try to avoid uselessly replacing " " with " ".
  (setq node (replace-regexp-in-string "[\t\n][\t\n ]*\\| [\t\n ]+" " "
                                       node t t))

  (if (not (string-match "\\`([^)]*)" node))
      (info-xref-output-error "no `(file)' part at start of node: %s\n" node)
    (let ((file (match-string 0 node)))

      (if (string-equal "()" file)
          (info-xref-output-error "empty filename part: %s" node)

        ;; see if the file exists, if haven't looked before
        (unless (assoc file info-xref-xfile-alist)
          (let ((found (info-xref-goto-node-p file)))
            (push (cons file found) info-xref-xfile-alist)
            (unless found
              (info-xref-output-error "not available to check: %s\n    (this reported once per file)" file))))

        ;; if the file exists, try the node
        (cond ((not (cdr (assoc file info-xref-xfile-alist)))
Stefan Monnier's avatar
Stefan Monnier committed
260
               (cl-incf info-xref-unavail))
Kevin Ryde's avatar
Kevin Ryde committed
261
              ((info-xref-goto-node-p node)
Stefan Monnier's avatar
Stefan Monnier committed
262
               (cl-incf info-xref-good))
Kevin Ryde's avatar
Kevin Ryde committed
263
              (t
Stefan Monnier's avatar
Stefan Monnier committed
264
               (cl-incf info-xref-bad)
Kevin Ryde's avatar
Kevin Ryde committed
265 266 267 268 269
               (info-xref-output-error "no such node: %s" node)))))))


;;-----------------------------------------------------------------------------

Juanma Barranquero's avatar
Juanma Barranquero committed
270 271
;;;###autoload
(defun info-xref-check (filename)
Kevin Ryde's avatar
Kevin Ryde committed
272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296
  "Check external references in FILENAME, an info document.
Interactively from an `Info-mode' or `texinfo-mode' buffer the
current info file is the default.

Results are shown in a `compilation-mode' buffer.  The format is
a bit rough, but there shouldn't be many problems normally.  The
file:line:column: is the info document, but of course normally
any correction should be made in the original .texi file.
Finding the right place in the .texi is a manual process.

When a target info file doesn't exist there's obviously no way to
validate node references within it.  A message is given for
missing target files once per source document.  It could be
simply that you don't have the target installed, or it could be a
mistake in the reference.

Indirect info files are understood, just pass the top-level
foo.info to `info-xref-check' and it traverses all sub-files.
Compressed info files are accepted too as usual for `Info-mode'.

\"makeinfo\" checks references internal to an info document, but
not external references, which makes it rather easy for mistakes
to creep in or node name changes to go unnoticed.
`Info-validate' doesn't check external references either."

Juanma Barranquero's avatar
Juanma Barranquero committed
297 298 299 300 301 302 303 304 305 306 307
  (interactive
   (list
    (let* ((default-filename
             (cond ((eq major-mode 'Info-mode)
                    Info-current-file)
                   ((eq major-mode 'texinfo-mode)
                    ;; look for @setfilename like makeinfo.el does
                    (save-excursion
                      (goto-char (point-min))
                      (if (re-search-forward
                           "^@setfilename[ \t]+\\([^ \t\n]+\\)[ \t]*"
308
                           (line-beginning-position 100) t)
Juanma Barranquero's avatar
Juanma Barranquero committed
309 310 311 312
                          (expand-file-name (match-string 1)))))))
           (prompt (if default-filename
                       (format "Info file (%s): " default-filename)
                     "Info file: ")))
313
      (read-file-name prompt nil default-filename t))))
Kevin Ryde's avatar
Kevin Ryde committed
314

Juanma Barranquero's avatar
Juanma Barranquero committed
315 316 317 318
  (info-xref-check-list (list filename)))

;;;###autoload
(defun info-xref-check-all ()
Kevin Ryde's avatar
Kevin Ryde committed
319 320 321 322 323 324 325 326 327 328 329 330
  "Check external references in all info documents in the info path.
`Info-directory-list' and `Info-additional-directory-list' are
the info paths.  See `info-xref-check' for how each file is
checked.

The search for \"all\" info files is rather permissive, since
info files don't necessarily have a \".info\" extension and in
particular the Emacs manuals normally don't.  If you have a
source code directory in `Info-directory-list' then a lot of
extraneous files might be read.  This will be time consuming but
should be harmless."

Juanma Barranquero's avatar
Juanma Barranquero committed
331 332 333
  (interactive)
  (info-xref-check-list (info-xref-all-info-files)))

Paul Eggert's avatar
Paul Eggert committed
334
;; An alternative for getting only top-level files here would be to simply
Kevin Ryde's avatar
Kevin Ryde committed
335 336 337 338
;; return all files and have info-xref-check-list not follow "Indirect:".
;; The current way seems better because it (potentially) gets the proper
;; top-level filename into the error messages, and suppresses duplicate "not
;; available" messages for all subfiles of a single document.
Juanma Barranquero's avatar
Juanma Barranquero committed
339 340 341

(defun info-xref-all-info-files ()
  "Return a list of all available info files.
Kevin Ryde's avatar
Kevin Ryde committed
342
Only top level files are returned, subfiles are excluded.
Juanma Barranquero's avatar
Juanma Barranquero committed
343

Kevin Ryde's avatar
Kevin Ryde committed
344 345 346 347
Since info files don't have to have a .info suffix, all files in
the relevant directories are considered, which might mean a lot
of extraneous things if for instance a source code directory is
in the path."
Juanma Barranquero's avatar
Juanma Barranquero committed
348 349

  (info-initialize) ;; establish Info-directory-list
350
  (apply 'nconc
Juanma Barranquero's avatar
Juanma Barranquero committed
351 352 353
         (mapcar
          (lambda (dir)
            (let ((result nil))
Kevin Ryde's avatar
Kevin Ryde committed
354 355 356 357 358 359 360 361 362
              (dolist (name (directory-files
                             dir
                             t           ;; absolute filenames
                             "\\`[^.]")) ;; not dotfiles, nor .# lockfiles
                (when (and (file-exists-p name) ;; ignore broken symlinks
                           (not (string-match "\\.te?xi\\'" name)) ;; not .texi
                           (not (backup-file-name-p name))
                           (not (file-directory-p name))
                           (not (info-xref-subfile-p name)))
363 364
		  (push name result)))
              (nreverse result)))
Juanma Barranquero's avatar
Juanma Barranquero committed
365 366 367 368
          (append Info-directory-list Info-additional-directory-list))))

(defun info-xref-check-list (filename-list)
  "Check external references in info documents in FILENAME-LIST."
Kevin Ryde's avatar
Kevin Ryde committed
369
  (info-xref-with-output
Juanma Barranquero's avatar
Juanma Barranquero committed
370
    (dolist (info-xref-filename filename-list)
Kevin Ryde's avatar
Kevin Ryde committed
371 372 373
      (setq info-xref-xfile-alist nil)
      (let ((info-xref-output-heading
             (format "Info file %s\n" info-xref-filename)))
Juanma Barranquero's avatar
Juanma Barranquero committed
374 375 376 377
        (with-temp-message (format "Looking at %s" info-xref-filename)
          (with-temp-buffer
            (info-insert-file-contents info-xref-filename)
            (goto-char (point-min))
Kevin Ryde's avatar
Kevin Ryde committed
378
            (if (search-forward "\^_\nIndirect:\n" nil t)
Juanma Barranquero's avatar
Juanma Barranquero committed
379 380
                (let ((dir (file-name-directory info-xref-filename)))
                  (while (looking-at "\\(.*\\): [0-9]+\n")
Kevin Ryde's avatar
Kevin Ryde committed
381 382
                    (let ((info-xref-filename
                           (expand-file-name (match-string 1) dir)))
Juanma Barranquero's avatar
Juanma Barranquero committed
383
                      (with-temp-buffer
Kevin Ryde's avatar
Kevin Ryde committed
384
                        (info-insert-file-contents info-xref-filename)
Juanma Barranquero's avatar
Juanma Barranquero committed
385 386
                        (info-xref-check-buffer)))
                    (forward-line)))
Kevin Ryde's avatar
Kevin Ryde committed
387
              (info-xref-check-buffer))))))))
Juanma Barranquero's avatar
Juanma Barranquero committed
388

389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405
(defconst info-xref-node-re "\\(?1:\\(([^)]*)\\)[^.,]+\\)"
  "Regexp with subexp 1 matching (manual)node.")

;; "@xref{node,crossref,manual}." produces:
;; texinfo 4 or 5:
;; *Note crossref: (manual)node.
;; "@xref{node,,manual}." produces:
;; texinfo 4:
;; *Note node: (manual)node.
;; texinfo 5:
;; *Note (manual)node::.
(defconst info-xref-note-re
  (concat "\\*[Nn]ote[ \n\t]+\\(?:"
          "[^:]*:[ \n\t]+" info-xref-node-re "\\|"
          info-xref-node-re "::\\)[.,]")
  "Regexp matching a \"*note...\" link.")

Juanma Barranquero's avatar
Juanma Barranquero committed
406 407
(defun info-xref-check-buffer ()
  "Check external references in the info file in the current buffer.
408
This should be the raw file contents, not `Info-mode'."
Juanma Barranquero's avatar
Juanma Barranquero committed
409
  (goto-char (point-min))
410
  (while (re-search-forward info-xref-note-re nil t)
Juanma Barranquero's avatar
Juanma Barranquero committed
411
    (save-excursion
Kevin Ryde's avatar
Kevin Ryde committed
412 413 414 415 416
      (goto-char (match-beginning 1)) ;; start of nodename as error position
      (info-xref-check-node (match-string 1)))))

(defvar viper-mode) ;; quieten the byte compiler
(defvar gnus-registry-install)
Juanma Barranquero's avatar
Juanma Barranquero committed
417

418 419 420
;;;###autoload
(defun info-xref-check-all-custom ()
  "Check info references in all customize groups and variables.
Kevin Ryde's avatar
Kevin Ryde committed
421 422
Info references can be in `custom-manual' or `info-link' entries
of the `custom-links' for a variable.
423

Kevin Ryde's avatar
Kevin Ryde committed
424 425 426
Any `custom-load' autoloads in variables are loaded in order to
get full link information.  This will be a lot of Lisp packages
and can take a long time."
427 428

  (interactive)
Kevin Ryde's avatar
Kevin Ryde committed
429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448
  (info-xref-with-output

   ;; `custom-load-symbol' is not used, since it quietly ignores errors, but
   ;; we want to show them since they mean incomplete checking.
   ;;
   ;; Just one pass through mapatoms is made.  There shouldn't be any new
   ;; custom-loads setup by packages loaded.
   ;;
   (info-xref-output "Loading custom-load autoloads ...")
   (require 'cus-start)
   (require 'cus-load)

   ;; These are `setq' rather than `let' since a let would unbind the
   ;; variables after viper.el/gnus-registry.el have loaded, defeating the
   ;; defvars in those files.  Of course it'd be better if those files
   ;; didn't make interactive queries on loading at all, to allow for
   ;; programmatic loading like here.
   (unless (boundp 'viper-mode)
     (setq viper-mode nil))  ;; avoid viper.el ask about viperizing
   (unless (boundp 'gnus-registry-install)
Paul Eggert's avatar
Paul Eggert committed
449
     (setq gnus-registry-install nil))  ;; avoid gnus-registry.el querying
Kevin Ryde's avatar
Kevin Ryde committed
450 451 452 453 454 455 456

   (mapatoms
    (lambda (symbol)
      (dolist (load (get symbol 'custom-loads))
        (cond ((symbolp load)
               (condition-case cause (require load)
                 (error
457
                  (info-xref-output "Symbol `%s': cannot require `%s': %s"
Kevin Ryde's avatar
Kevin Ryde committed
458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482
                                    symbol load cause))))
              ;; skip if previously loaded
              ((assoc load load-history))
              ((assoc (locate-library load) load-history))
              (t
               (condition-case err
                   (load load)
                 (error
                  (info-xref-output "Symbol `%s': cannot load \"%s\": %s"
                                    symbol load
                                    (error-message-string err)))))))))

   ;; Don't bother to check whether the info file exists as opposed to just
   ;; a missing node.  If you have the code then you should have the
   ;; documentation, so a wrong node name will be the usual fault.
   ;;
   (info-xref-output "\nChecking custom-links references ...")
   (mapatoms
    (lambda (symbol)
      (dolist (link (get symbol 'custom-links))
        (when (memq (car link) '(custom-manual info-link))
          ;; skip :tag part of (custom-manual :tag "Foo" "(foo)Node")
          (if (eq :tag (cadr link))
              (setq link (cddr link)))
          (if (info-xref-goto-node-p (cadr link))
Stefan Monnier's avatar
Stefan Monnier committed
483 484
              (cl-incf info-xref-good)
            (cl-incf info-xref-bad)
Kevin Ryde's avatar
Kevin Ryde committed
485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514
            ;; symbol-file gives nil for preloaded variables, would need
            ;; to copy what describe-variable does to show the right place
            (info-xref-output "Symbol `%s' (file %s): cannot goto node: %s"
                              symbol
                              (symbol-file symbol 'defvar)
                              (cadr link)))))))))

;;;###autoload
(defun info-xref-docstrings (filename-list)
  ;; checkdoc-params: (filename-list)
  "Check docstring info node references in source files.
The given files are searched for docstring hyperlinks like

    Info node `(elisp)Documentation Tips'

and those links checked by attempting to visit the target nodes
as per `info-xref-check' does.

Interactively filenames are read as a wildcard pattern like
\"foo*.el\", with the current file as a default.  Usually this
will be lisp sources, but anything with such hyperlinks can be
checked, including the Emacs .c sources (or the etc/DOC file of
all builtins).

Because info node hyperlinks are found by a simple regexp search
in the files, the Lisp code checked doesn't have to be loaded,
and links can be in the file commentary or elsewhere too.  Even
.elc files can usually be checked successfully if you don't have
the sources handy."
  (interactive
515
   (let* ((default (and buffer-file-name
Kevin Ryde's avatar
Kevin Ryde committed
516
                              (file-relative-name buffer-file-name)))
517 518 519 520 521 522 523 524 525 526 527
          (prompt (if default
                      (format "Filename with wildcards (%s): "
                              default)
                    "Filename with wildcards: "))
          (pattern (read-file-name prompt nil default))
          ;; absolute filenames
          (filename-list (file-expand-wildcards pattern t))
          newlist)
     (setq filename-list
           (dolist (file filename-list (nreverse newlist))
             (or (info-xref-lock-file-p file)
528
                 (file-directory-p file)
529
                 (push file newlist))))
Kevin Ryde's avatar
Kevin Ryde committed
530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558
     (unless filename-list
       (error "No files: %S" pattern))
     (list filename-list)))

  (eval-and-compile
    (require 'help-mode)) ;; for `help-xref-info-regexp'

  (info-xref-with-output
   (dolist (info-xref-filename filename-list)
     (setq info-xref-xfile-alist nil)  ;; "not found"s once per file

     (info-xref-with-file info-xref-filename
       (goto-char (point-min))
       (while (re-search-forward help-xref-info-regexp nil t)
         (let ((node (match-string 2)))
           (save-excursion
             (goto-char (match-beginning 2)) ;; start of node as error position

             ;; skip nodes with "%" as probably `format' strings such as in
             ;; info-look.el
             (unless (string-match "%" node)

               ;; "(emacs)" is the default manual for docstring hyperlinks,
               ;; per `help-make-xrefs'
               (unless (string-match "\\`(" node)
                 (setq node (concat "(emacs)" node)))

               (info-xref-check-node node)))))))))

559

Juanma Barranquero's avatar
Juanma Barranquero committed
560 561 562
(provide 'info-xref)

;;; info-xref.el ends here