;;; info-xref.el --- Cross references in an Info document -*- lexical-binding:  t -*-

;; Copyright (C) 2003-2023 Free Software Foundation, Inc.

;; Author: Kevin Ryde <user42@zip.com.au>
;; Keywords: docs
;; Version: 3

;; This file is part of GNU Emacs.

;; GNU Emacs 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 3 of the License, or
;; (at your option) any later version.

;; 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
;; along with GNU Emacs.  If not, see <https://www.gnu.org/licenses/>.

;;; Commentary:

;; This is some simple checking of external cross references in info files,
;; docstrings and custom-links by attempting to visit the nodes specified.
;;
;; `M-x info-xref-check' checks a single info file.  See the docstring for
;; details.
;;
;; `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.
;;
;; `M-x info-xref-check-all-custom' loads up all defcustom variables and
;; checks any info references in them.
;;
;; `M-x info-xref-docstrings' checks docstring "Info node ..." hyperlinks in
;; source files (and other files).

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

;; This library provides links of symbols (functions, variables,
;; faces) within Emacs' Info viewer to their builtin help
;; documentation.  This linking is done, when the symbol names in
;; texinfo documentations (like the Emacs- and Elisp manual) are

;; 1. Quoted symbol names like `quoted-symbol' or:

;; 2. Function names are prefixed by M-x, for example M-x
;; function-name or are quoted and prefixed like `M-x function-name'.

;; 3. Function names appearing behind the following forms, which
;; occur, for example, in the Elisp manual:

;;   -- Special Form: function-name
;;   -- Command:
;;   -- Function:
;;   -- Macro:

;; 4. And variables names behind the following text:

;;   -- User Option: variable-name
;;   -- Variable:

;; In any case all symbol names must be known to Emacs, i.e. their
;; names are found in the variable `obarray'.

;; You can follow the additional links with the usual Info
;; keybindings.  The customisation variable
;; `mouse-1-click-follows-link' is influencing the clicking behavior
;; (and the tooltips) of the links, the variable's default is 450
;; (milli seconds) setting it to nil means only clicking with mouse-2
;; is following the link (hint: Drew Adams).

;; The link color of symbols - referencing their builtin documentation
;; - is distinct from links which are referencing further Info
;; documentation.

;; Inform is checking if the Info documents are relevant Elisp and
;; Emacs related files to avoid false positives.  Please see the
;; customization variable `inform-none-emacs-or-elisp-documents'.

;; The code uses mostly mechanisms from Emacs' lisp/help-mode.el file.

;;; Change Log:

;; 1.3:

;; Inform is checking if the Info documents are relevant Elisp and
;; Emacs related files to avoid false positives.

;; 1.2:

;; Link Elisp descriptions of symbols to their help documentation,
;; like the following function example: -- Function: eval form

;; Distinguish color of texinfo links (`link' type) and Help links
;; (`font-lock-function-name-face')

;;; TODO:

;; Currently inconsistent link colors to help buffers: In *info*
;; different as in *Help* buffers!

;; Check the application `inform-xref-symbol-regexp' for additional
;; symbol prefixes without quoting of symbol-names

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; Does the following belong to customize.el?

;; Generalise linking to "customization buffers" for the "easy
;; customization" info documentation see also the customization
;; section in the elisp manual

;; - distinguish the Customization-links from Help- and Info-links
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

;;; Ideas:

;; Link the help buffers back to higher level info manual subjects,
;; similar to help-fns+.el from Drew Adams.

;; Twice clicking or RETurning removes *Help* buffer (idea: Drew
;; Adams)

;; Different colors for different symbol types (idea: Drew Adams) see
;; package helpful and info+ / info-colors on Melpa and see
;; font-lock.el for common faces.

;; - Do we need to indicate an already visited Help link with a
;;   different color?

;; - Would it be be good to overtake all colors of package
;;   "info-colors"?

;; - Do we need to distinguish the link FONTS? No, difficult to read!

;; Back / Forward button in help buffer - back to info buffer or
;; remain in help mode?

;; Linking of standard symbol properties?

;; - (info "(elisp) Standard Properties")

;;  Elisp manual examples:
;;       (symbol-name 'car) ... ?

;; Shortening the verbose texinfo URLs?  But how to handle the changed
;; indentation?

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

;;; History:

;; Version 3 - new M-x info-xref-docstrings, use compilation-mode

;;; Code:

(require 'info)
(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")


;;-----------------------------------------------------------------------------
;; 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'."
  (string-match "\\(\\`\\|/\\)\\.#" filename))

(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 (form def-body)) (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

(defconst info-xref-output-buffer "*info-xref results*"
  "Name of the buffer for info-xref results.")

(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))))

(defun info-xref-output (fmt &rest args)
  "Emit a `format-message'-ed message FMT+ARGS to the `info-xref-output-buffer'."
  (with-current-buffer info-xref-output-buffer
    (save-excursion
      (goto-char (point-max))
      (let ((inhibit-read-only t))
        (insert info-xref-output-heading
                (apply #'format-message fmt args)
                "\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
            (condition-case nil
                (progn
                  (Info-goto-node node
                                  (when (get-buffer "*info*")
                                    (set-buffer "*info*")
                                    "xref - temporary")
                                  (not info-xref-case-fold))
                  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)))
               (cl-incf info-xref-unavail))
              ((info-xref-goto-node-p node)
               (cl-incf info-xref-good))
              (t
               (cl-incf info-xref-bad)
               (info-xref-output-error "No such node: %s" node)))))))


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

;;;###autoload
(defun info-xref-check (filename)
  "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."

  (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]*"
                          (line-beginning-position 100) t)
                         (expand-file-name (match-string 1)))))))
           (prompt (if default-filename
                       (format "Info file (%s): " default-filename)
                     "Info file: ")))
      (read-file-name prompt nil default-filename t))))

  (info-xref-check-list (list filename)))

;;;###autoload
(defun info-xref-check-all ()
  "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."

  (interactive)
  (info-xref-check-list (info-xref-all-info-files)))

;; An alternative for getting only top-level files here would be to simply
;; 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.

(defun info-xref-all-info-files ()
  "Return a list of all available info files.
Only top level files are returned, subfiles are excluded.

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."

  (info-initialize) ;; establish Info-directory-list
  (apply 'nconc
         (mapcar
          (lambda (dir)
            (let ((result nil))
              (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)))
		  (push name result)))
              (nreverse result)))
          (append Info-directory-list Info-additional-directory-list))))

(defun info-xref-check-list (filename-list)
  "Check external references in info documents in FILENAME-LIST."
  (info-xref-with-output
   (dolist (info-xref-filename filename-list)
     (setq info-xref-xfile-alist nil)
     (let ((info-xref-output-heading
            (format "Info file %s\n" info-xref-filename)))
       (with-temp-message (format "Looking at %s" info-xref-filename)
         (with-temp-buffer
           (info-insert-file-contents info-xref-filename)
           (goto-char (point-min))
           (if (search-forward "\^_\nIndirect:\n" nil t)
               (let ((dir (file-name-directory info-xref-filename)))
                 (while (looking-at "\\(.*\\): [0-9]+\n")
                   (let ((info-xref-filename
                          (expand-file-name (match-string 1) dir)))
                     (with-temp-buffer
                       (info-insert-file-contents info-xref-filename)
                       (info-xref-check-buffer)))
                   (forward-line)))
             (info-xref-check-buffer))))))))

(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.")

(defun info-xref-check-buffer ()
  "Check external references in the info file in the current buffer.
This should be the raw file contents, not `Info-mode'."
  (goto-char (point-min))
  (while (re-search-forward info-xref-note-re nil t)
    (save-excursion
      (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)

;;;###autoload
(defun info-xref-check-all-custom ()
  "Check info references in all customize groups and variables.
Info references can be in `custom-manual' or `info-link' entries
of the `custom-links' for a variable.

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."

  (interactive)
  (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)
     (setq gnus-registry-install nil))  ;; avoid gnus-registry.el querying

   (mapatoms
    (lambda (symbol)
      (dolist (load (get symbol 'custom-loads))
        (cond ((symbolp load)
               (condition-case cause (require load)
                 (error
                  (info-xref-output "Symbol `%s': cannot require `%s': %s"
                                    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))
              (cl-incf info-xref-good)
            (cl-incf info-xref-bad)
            ;; 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
   (let* ((default (and buffer-file-name
                        (file-relative-name buffer-file-name)))
          (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)
                 (file-directory-p file)
                 (push file newlist))))
     (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-search "%" 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)))))))))

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

(require 'button)
(require 'cl-lib)
(require 'help-mode)                   ;redundant?

;; activate inform without manually loading it. Is there a better way?
;; ;;;###autoload (require 'info-xref)

;; this is spawning lisp/info-xref.el's definition to 'info! This
;; group is sorted now in 'docs and 'info! -FIXME-
(defgroup info-xref nil
  "Customisation 'info-xref' subgroup of info.
Check external cross-references in Info documents and provide
hyperlinks from symbols to their help documentation."
  :group 'info)

;;;###autoload
(defcustom info-xref-make-xref-flag t
  "Non-nil means create symbol links in info buffers."
  :type '(choice (const :tag "Create links" t)
                 (const :tag "Do not link" nil))
  :group 'info-xref)

(require 'cl-seq)
;; Info-director-list must be initialised
(info-initialize)
(defvar Info-xref-emacs-info-dir-content
  (mapcar 'file-name-nondirectory ;'file-name-sans-extension
          (directory-files
           (car
            ;; search for the main Emacs' info/ directory
            (cl-member "[^.]emacs" Info-directory-list :test 'string-match-p))
           ;; don't list "." and ".."
           t  "[^.]$"))
  "List of file names in Emacs' own info/ directory.")

;; Turn into regexp list necessary? Stefan
;; Switch to alist with explanation of file name?
(defcustom info-xref-none-emacs-or-elisp-documents
  '("aarm2012" ; Stefan: Ada manual, Elpa archive
    "arm2012"  ; Stefan: Ada manual
    "sicp"   ; T.V: Structure and Interpretation of Computer Programs,
                                        ; Melpa archive
    )
  "List of all none GNU-Emacs or Elisp documentation.
Or other documents not to be checked for linking to their help
documentation.  The list must contains only the base name of the
files (without their file name extension \".info\")."
  :type '(repeat string)
  :group 'info-xref)

(defun Info-xref-check-docu-p ()
  "Check if the current info file is relevant to Emacs.
That means `Info-current-file' is either found in Emacs' info/
directory or in `package-user-dir' and is not included in the
`info-xref-none-emacs-or-elisp-documents' list."
  (let* ((ifile Info-current-file)
         (ifi (when ifile
                (file-name-sans-extension
                 (file-name-nondirectory ifile))))
         (pdir (when (boundp 'package-user-dir)
                 (expand-file-name
                  package-user-dir)))
         (ifiles Info-xref-emacs-info-dir-content)
         (ndocu info-xref-none-emacs-or-elisp-documents))
    (and ifile
         (or (assoc-string (concat ifi ".info") ifiles)
             ;; info files might be archived!
             (assoc-string (concat ifi ".info.gz") ifiles)
             (when pdir (string-match pdir ifile)))
         (not (assoc-string ifi ndocu)))))

(defvar describe-symbol-backends)      ;from help-mode.el
(defvar help-xref-following)           ;dito

;; this toggles the complete linking process
;;;###autoload
(when info-xref-make-xref-flag
  (add-hook 'Info-selection-hook 'Info-xref-make-xrefs))

(defface Info-xref-color
  '((t (:inherit font-lock-doc-face
                 ;; font-lock-preprocessor-face ; similar to link face (default)
                 ;; font-lock-builtin-face ; similar (default Emacs)
                 ;; font-lock-function-name-face ; similar (default)
                 ;; Info-xref-face
                 )))
  "Face for the `symbol' reference items in `info' nodes."
  :group 'info-colors)

;; Button types

(define-button-type 'Info-xref
  'link t                         ;for Info-next-reference-or-link
  'follow-link t
  'face 'Info-xref-color
  'action #'Info-xref-button-action)

(define-button-type 'Info-xref-function
  :supertype 'Info-xref
  'Info-xref-function 'describe-function
  'Info-xref-echo (purecopy "mouse-2, RET: describe this function"))

(define-button-type 'Info-xref-variable
  :supertype 'Info-xref
  'Info-xref-function 'describe-variable
  'Info-xref-echo (purecopy "mouse-2, RET: describe this variable"))

(define-button-type 'Info-xref-face
  :supertype 'Info-xref
  'Info-xref-function 'describe-face
  'Info-xref-echo (purecopy "mouse-2, RET: describe this face"))

(define-button-type 'Info-xref-symbol
  :supertype 'Info-xref
  'Info-xref-function #'describe-symbol
  'Info-xref-echo (purecopy "mouse-2, RET: describe this symbol"))

(define-button-type 'Info-xref-function-def
  :supertype 'Info-xref
  'Info-xref-function (lambda (fun &optional file type)
                        (or file
                            (setq file (find-lisp-object-file-name fun type)))
                        (if (not file)
                            (message "Unable to find defining file")
                          (require 'find-func)
                          (when (eq file 'C-source)
                            (setq file
                                  (help-C-file-name (indirect-function fun) 'fun)))
                          ;; Don't use find-function-noselect because it follows
                          ;; aliases (which fails for built-in functions).
                          (let ((location
                                 (find-function-search-for-symbol fun type file)))
                            (pop-to-buffer (car location))
                            (run-hooks 'find-function-after-hook)
                            (if (cdr location)
                                (goto-char (cdr location))
                              (message "Unable to find location in file")))))
  'Info-xref-echo (purecopy "mouse-2, RET: find function's definition"))

;; Functions

(defun Info-xref-button-action (button)
  "Call BUTTON's help function."
  (Info-xref-do-xref nil
                     (button-get button 'Info-xref-function)
                     (button-get button 'Info-xref-args)))

(defun Info-xref-do-xref (_pos function args)
  "Call the help cross-reference function FUNCTION with args ARGS.
Things are set up properly so that the resulting `help-buffer' has
a proper [back] button."
  ;; There is a reference at point.  Follow it.
  (let ((help-xref-following nil))
    (apply
     function (if (eq function 'info)
                  (append args (list (generate-new-buffer-name "*info*")))args))))

(defun Info-xref-button (match-number type &rest args)
  "Make a hyperlink for cross-reference text previously matched.
MATCH-NUMBER is the subexpression of interest in the last matched
regexp.  TYPE is the type of button to use.  Any remaining arguments are
passed to the button's Info-xref-function when it is invoked.
See `Info-xref-make-xrefs' Don't forget ARGS." ; -TODO-
  ;; Don't mung properties we've added specially in some instances.
  (unless (button-at (match-beginning match-number))
    ;; (message "Creating button: %s." args)
    (make-text-button (match-beginning match-number)
                      (match-end match-number)
                      'type type 'Info-xref-args args)))

(defconst Info-xref-symbol-regexp
  (purecopy (concat "\\(\\<\\(\\(variable\\|option\\)\\|"  ; Link to var
                    "\\(function\\|command\\|call\\)\\|"   ; Link to function
                    "\\(face\\)\\|"                       ; Link to face
                    "\\(symbol\\|program\\|property\\)\\|" ; Don't link
                    "\\(source \\(?:code \\)?\\(?:of\\|for\\)\\)\\)"
                    "[ \t\n]+\\)?"
                    ;; Note starting with word-syntax character:
                    "['`‘]\\(\\sw\\(\\sw\\|\\s_\\)+\\|`\\)['’]"))
  "Regexp matching doc string references to symbols.

The words preceding the quoted symbol can be used in doc strings to
distinguish references to variables, functions and symbols.")

;;;###autoload
(defun Info-xref-make-xrefs (&optional buffer)
  "Parse and hyperlink documentation cross-references in the given BUFFER.

Find cross-reference information in a buffer and activate such cross
references for selection with `help-follow'.  Cross-references have
the canonical form `...'  and the type of reference may be
disambiguated by the preceding word(s) used in
`Info-xref-symbol-regexp'.

Function names are also prefixed by \"M-x\", for example \"M-x
function-name\" or are quoted and prefixed like `M-x
function-name'.

Also Function names appearing behind the following forms, which
occur, for example, in the Elisp manual:

 -- Special Form: function-name
 -- Command:
 -- Function:
 -- Macro:

And variables names behind the following text:

 -- User Option: variable-name
 -- Variable:

Faces only get cross-referenced if preceded or followed by the
word `face'.  Variables without variable documentation do not get
cross-referenced, unless preceded by the word `variable' or
`option'."
  (interactive "b")
  (when (Info-xref-check-docu-p)
    (with-current-buffer (or buffer (current-buffer))
      (save-excursion
        (goto-char (point-min))
        ;; Skip the header-type info, though it might be useful to parse
        ;; it at some stage (e.g. "function in `library'").
        ;;      (forward-paragraph)
        (with-silent-modifications      ;from Stefan
          (let (;(stab (syntax-table))
                (case-fold-search t)
                (inhibit-read-only t))
            (with-syntax-table emacs-lisp-mode-syntax-table
              ;; Quoted symbols
              (save-excursion
                (while (re-search-forward Info-xref-symbol-regexp nil t)
                  (let* ((data (match-string 8))
                         (sym (intern-soft data)))
                    (if sym
                        (cond
                         ((match-string 3) ; `variable' &c
                          (and (or (boundp sym) ; `variable' doesn't ensure
                                        ; it's actually bound
                                   (get sym 'variable-documentation))
                               (Info-xref-button 8 'Info-xref-variable sym)))
                         ((match-string 4) ; `function' &c
                          (and (fboundp sym) ; similarly
                               (Info-xref-button 8 'Info-xref-function sym)))
                         ((match-string 5) ; `face'
                          (and (facep sym)
                               (Info-xref-button 8 'Info-xref-face sym)))
                         ((match-string 6)) ; nothing for `symbol'
                         ((match-string 7)
                          (Info-xref-button 8 'Info-xref-function-def sym))
                         ((cl-some (lambda (x) (funcall (nth 1 x) sym))
                                   describe-symbol-backends)
                          (Info-xref-button 8 'Info-xref-symbol sym)))))))

              ;; (info "(elisp) Eval")
              ;; Elisp manual      -- Special Form:
              ;;                   -- Command:
              ;;                   -- Function: function-name function
              ;;                   -- Macro:
              (save-excursion
                (while (re-search-forward
                        "-- \\(Special Form:\\|Command:\\|Function:\\|Macro:\\) "
                        nil t)
                  (looking-at "\\(\\sw\\|\\s_\\)+")
                  (let ((sym (intern-soft (match-string 0))))
                    (if (fboundp sym)
                        (Info-xref-button 0 'Info-xref-function sym)))))

              ;;              -- User Option:
              ;;              -- Variable: variable-name
              (save-excursion
                (while (re-search-forward
                        "-- \\(User Option:\\|Variable:\\) "
                        nil t)
                  (looking-at "\\(\\sw\\|\\s_\\)+")
                  (let ((sym (intern-soft (match-string 0))))
                    (if (boundp sym)
                        (Info-xref-button 0 'Info-xref-variable sym)))))

              ;; M-x prefixed functions
              (save-excursion
                (while (re-search-forward
                        ;; Assume command name is only word and symbol
                        ;; characters to get things like `use M-x foo->bar'.
                        ;; Command required to end with word constituent
                        ;; to avoid `.' at end of a sentence.
                        ;; "\\<M-x\\s-+\\(\\sw\\(\\sw\\|\\s_\\)*\\sw\\)" nil t)
                        ;; include M-x and quotes
                        "['`‘]?M-x\\s-*\n?\\(\\sw\\(\\sw\\|\\s_\\)*\\sw\\)['’]?" nil t)
                  (let ((sym (intern-soft (match-string 1))))
                    ;; (message "found %s" sym)
                    (if (fboundp sym)
                        (Info-xref-button 1 'Info-xref-function sym))))))))))))
;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

(provide 'info-xref)

;;; info-xref.el ends here