;;; autoload.el --- maintain autoloads in loaddefs.el.
-;;; Copyright (C) 1991, 1992, 1993 Free Software Foundation, Inc.
-;;;
+;; Copyright (C) 1991, 92, 93, 94, 95, 96, 97 Free Software Foundation, Inc.
+
;; Author: Roland McGrath <roland@gnu.ai.mit.edu>
;; Keywords: maint
-;;; This program 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 2, or (at your option)
-;;; any later version.
-;;;
-;;; This program 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.
-;;;
-;;; A copy of the GNU General Public License can be obtained from this
-;;; program's author (send electronic mail to roland@ai.mit.edu) or from
-;;; the Free Software Foundation, Inc., 675 Mass Ave, Cambridge, MA
-;;; 02139, USA.
-;;;
+;; This file is part of GNU Emacs.
-;;; Commentary;:
+;; 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 2, or (at your option)
+;; any later version.
-;; This code helps GNU Emacs maintainers keep the autoload.el file up to
+;; 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; see the file COPYING. If not, write to the
+;; Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+;; Boston, MA 02111-1307, USA.
+
+;;; Commentary:
+
+;; This code helps GNU Emacs maintainers keep the loaddefs.el file up to
;; date. It interprets magic cookies of the form ";;;###autoload" in
;; lisp source files in various useful ways. To learn more, read the
;; source; if you're going to use this, you'd better be able to.
;;; Code:
-(defun make-autoload (form file)
- "Turn FORM, a defun or defmacro, into an autoload for source file FILE.
-Returns nil if FORM is not a defun or defmacro."
- (let ((car (car-safe form)))
- (if (or (eq car 'defun) (eq car 'defmacro))
- (let (name doc macrop)
- (setq macrop (eq car 'defmacro))
- (setq form (cdr form))
- (setq name (car form))
- ;; Ignore the arguments.
- (setq form (cdr (cdr form)))
- (setq doc (car form))
- (if (stringp doc)
- (setq form (cdr form))
- (setq doc nil))
- (list 'autoload (list 'quote name) file doc
- (eq (car-safe (car form)) 'interactive)
- (if macrop (list 'quote 'macro) nil)))
- nil)))
+(defvar generated-autoload-file "loaddefs.el"
+ "*File \\[update-file-autoloads] puts autoloads into.
+A `.el' file can set this in its local variables section to make its
+autoloads go somewhere else.")
(defconst generate-autoload-cookie ";;;###autoload"
- "Magic comment that tells \\[update-file-autoloads]
-to make the following form into an autoload. This string should be
+ "Magic comment indicating the following form should be autoloaded.
+Used by \\[update-file-autoloads]. This string should be
meaningless to Lisp (e.g., a comment).
This string is used:
that text will be copied verbatim to `generated-autoload-file'.")
(defconst generate-autoload-section-header "\f\n;;;### "
- "String inserted before the form identifying
-the section of autoloads for a file.")
+ "String that marks the form at the start of a new file's autoload section.")
(defconst generate-autoload-section-trailer "\n;;;***\n"
"String which indicates the end of the section of autoloads for a file.")
+(defconst generate-autoload-section-continuation ";;;;;; "
+ "String to add on each continuation of the section header form.")
+
+(defun make-autoload (form file)
+ "Turn FORM into an autoload or defvar for source file FILE.
+Returns nil if FORM is not a `defun', `define-skeleton',
+`define-derived-mode', `define-generic-mode', `defmacro', `defcustom'
+or `easy-mmode-define-minor-mode'."
+ (let ((car (car-safe form)))
+ (if (memq car '(defun define-skeleton defmacro define-derived-mode
+ define-generic-mode easy-mmode-define-minor-mode))
+ (let ((macrop (eq car 'defmacro))
+ name doc)
+ (setq form (cdr form)
+ name (car form)
+ ;; Ignore the arguments.
+ form (cdr (cond
+ ((memq car '(define-skeleton
+ easy-mmode-define-minor-mode)) form)
+ ((eq car 'define-derived-mode) (cdr (cdr form)))
+ ((eq car 'define-generic-mode)
+ (cdr (cdr (cdr (cdr (cdr form))))))
+ (t (cdr form))))
+ doc (car form))
+ (if (stringp doc)
+ (setq form (cdr form))
+ (setq doc nil))
+ ;; `define-generic-mode' quotes the name, so take care of that
+ (list 'autoload (if (listp name) name (list 'quote name)) file doc
+ (or (eq car 'define-skeleton) (eq car 'define-derived-mode)
+ (eq car 'define-generic-mode)
+ (eq car 'easy-mmode-define-minor-mode)
+ (eq (car-safe (car form)) 'interactive))
+ (if macrop (list 'quote 'macro) nil)))
+ ;; Convert defcustom to a simpler (and less space-consuming) defvar,
+ ;; but add some extra stuff if it uses :require.
+ (if (eq car 'defcustom)
+ (let ((varname (car-safe (cdr-safe form)))
+ (init (car-safe (cdr-safe (cdr-safe form))))
+ (doc (car-safe (cdr-safe (cdr-safe (cdr-safe form)))))
+ (rest (cdr-safe (cdr-safe (cdr-safe (cdr-safe form))))))
+ (if (not (plist-get rest :require))
+ `(defvar ,varname ,init ,doc)
+ `(progn
+ (defvar ,varname ,init ,doc)
+ (custom-add-to-group ,(plist-get rest :group)
+ ',varname 'custom-variable)
+ (custom-add-load ',varname
+ ,(plist-get rest :require)))))
+ nil))))
+
;;; Forms which have doc-strings which should be printed specially.
;;; A doc-string-elt property of ELT says that (nth ELT FORM) is
;;; the doc-string in FORM.
(put 'autoload 'doc-string-elt 3)
(put 'defun 'doc-string-elt 3)
(put 'defvar 'doc-string-elt 3)
+(put 'defcustom 'doc-string-elt 3)
(put 'defconst 'doc-string-elt 3)
(put 'defmacro 'doc-string-elt 3)
+(put 'define-skeleton 'doc-string-elt 3)
+(put 'define-derived-mode 'doc-string-elt 3)
+(put 'easy-mmode-define-minor-mode 'doc-string-elt 3)
+(put 'define-generic-mode 'doc-string-elt 3)
+
+
+(defun autoload-trim-file-name (file)
+ ;; Returns a relative pathname of FILE
+ ;; starting from the directory that loaddefs.el is in.
+ ;; That is normally a directory in load-path,
+ ;; which means Emacs will be able to find FILE when it looks.
+ ;; Any extra directory names here would prevent finding the file.
+ (setq file (expand-file-name file))
+ (file-relative-name file
+ (file-name-directory generated-autoload-file)))
+
+(defun autoload-read-section-header ()
+ "Read a section header form.
+Since continuation lines have been marked as comments,
+we must copy the text of the form and remove those comment
+markers before we call `read'."
+ (save-match-data
+ (let ((beginning (point))
+ string)
+ (forward-line 1)
+ (while (looking-at generate-autoload-section-continuation)
+ (forward-line 1))
+ (setq string (buffer-substring beginning (point)))
+ (with-current-buffer (get-buffer-create " *autoload*")
+ (erase-buffer)
+ (insert string)
+ (goto-char (point-min))
+ (while (search-forward generate-autoload-section-continuation nil t)
+ (replace-match " "))
+ (goto-char (point-min))
+ (read (current-buffer))))))
(defun generate-file-autoloads (file)
"Insert at point a loaddefs autoload section for FILE.
autoloads are generated for defuns and defmacros in FILE
-marked by `generate-autoload-regexp' (which see).
+marked by `generate-autoload-cookie' (which see).
If FILE is being visited in a buffer, the contents of the buffer
are used."
(interactive "fGenerate autoloads for file: ")
(substring name 0 (match-beginning 0))
name)))
(print-length nil)
- (floating-output-format "%20e")
+ (print-readably t) ; This does something in Lucid Emacs.
+ (float-output-format nil)
(done-any nil)
(visited (get-file-buffer file))
output-end)
;; subdirectory of the current buffer's directory, we'll make it
;; relative to the current buffer's directory.
(setq file (expand-file-name file))
- (if (and (< (length default-directory) (length file))
- (string= default-directory
- (substring file 0 (length default-directory))))
- (progn
- (setq file (substring file (length default-directory)))))
+ (let* ((source-truename (file-truename file))
+ (dir-truename (file-name-as-directory
+ (file-truename default-directory)))
+ (len (length dir-truename)))
+ (if (and (< len (length source-truename))
+ (string= dir-truename (substring source-truename 0 len)))
+ (setq file (substring source-truename len))))
(message "Generating autoloads for %s..." file)
(save-excursion
(unwind-protect
(progn
- (set-buffer (find-file-noselect file))
+ (if visited
+ (set-buffer visited)
+ ;; It is faster to avoid visiting the file.
+ (set-buffer (get-buffer-create " *generate-autoload-file*"))
+ (kill-all-local-variables)
+ (erase-buffer)
+ (setq buffer-undo-list t
+ buffer-read-only nil)
+ (emacs-lisp-mode)
+ (insert-file-contents file nil))
(save-excursion
(save-restriction
(widen)
(if (eolp)
;; Read the next form and make an autoload.
(let* ((form (prog1 (read (current-buffer))
- (forward-line 1)))
- (autoload (make-autoload form load-name))
+ (or (bolp) (forward-line 1))))
+ (autoload-1 (make-autoload form load-name))
+ (autoload (if (eq (car autoload-1) 'progn)
+ (cadr autoload-1)
+ autoload-1))
(doc-string-elt (get (car-safe form)
'doc-string-elt)))
(if autoload
(elt (cdr p)))
(setcdr p nil)
(princ "\n(" outbuf)
- (mapcar (function (lambda (elt)
- (prin1 elt outbuf)
- (princ " " outbuf)))
- autoload)
+ (let ((print-escape-newlines t)
+ (print-escape-nonascii t))
+ (mapcar (function (lambda (elt)
+ (prin1 elt outbuf)
+ (princ " " outbuf)))
+ autoload))
(princ "\"\\\n" outbuf)
- (princ (substring
- (prin1-to-string (car elt)) 1)
- outbuf)
- (if (null (cdr elt))
- (princ ")" outbuf)
- (princ " " outbuf)
+ (let ((begin (save-excursion
+ (set-buffer outbuf)
+ (point))))
(princ (substring
- (prin1-to-string (cdr elt))
- 1)
- outbuf))
- (terpri outbuf))
- (print autoload outbuf)))
- ;; Copy the rest of the line to the output.
- (let ((begin (point)))
- (forward-line 1)
- (princ (buffer-substring begin (point)) outbuf))))
- ((looking-at ";")
- ;; Don't read the comment.
- (forward-line 1))
- (t
- (forward-sexp 1)
- (forward-line 1)))))))
+ (prin1-to-string (car elt)) 1)
+ outbuf)
+ ;; Insert a backslash before each ( that
+ ;; appears at the beginning of a line in
+ ;; the doc string.
+ (save-excursion
+ (set-buffer outbuf)
+ (save-excursion
+ (while (search-backward "\n(" begin t)
+ (forward-char 1)
+ (insert "\\"))))
+ (if (null (cdr elt))
+ (princ ")" outbuf)
+ (princ " " outbuf)
+ (princ (substring
+ (prin1-to-string (cdr elt))
+ 1)
+ outbuf))
+ (terpri outbuf)))
+ (let ((print-escape-newlines t)
+ (print-escape-nonascii t))
+ (print autoload outbuf)))
+ (if (eq (car autoload-1) 'progn)
+ ;; Print the rest of the form
+ (let ((print-escape-newlines t)
+ (print-escape-nonascii t))
+ (mapcar (function (lambda (elt)
+ (print elt outbuf)))
+ (cddr autoload-1)))))
+ ;; Copy the rest of the line to the output.
+ (princ (buffer-substring
+ (progn
+ ;; Back up over whitespace, to preserve it.
+ (skip-chars-backward " \f\t")
+ (if (= (char-after (1+ (point))) ? )
+ ;; Eat one space.
+ (forward-char 1))
+ (point))
+ (progn (forward-line 1) (point)))
+ outbuf)))
+ ((looking-at ";")
+ ;; Don't read the comment.
+ (forward-line 1))
+ (t
+ (forward-sexp 1)
+ (forward-line 1)))))))
(or visited
;; We created this buffer, so we should kill it.
(kill-buffer (current-buffer)))
(setq output-end (point-marker))))
(if done-any
(progn
+ ;; Insert the section-header line
+ ;; which lists the file name and which functions are in it, etc.
(insert generate-autoload-section-header)
- (prin1 (list 'autoloads autoloads-done load-name file
+ (prin1 (list 'autoloads autoloads-done load-name
+ (autoload-trim-file-name file)
(nth 5 (file-attributes file)))
outbuf)
(terpri outbuf)
- (insert ";;; Generated autoloads from " file "\n")
+ ;; Break that line at spaces, to avoid very long lines.
+ ;; Make each sub-line into a comment.
+ (with-current-buffer outbuf
+ (save-excursion
+ (forward-line -1)
+ (while (not (eolp))
+ (move-to-column 64)
+ (skip-chars-forward "^ \n")
+ (or (eolp)
+ (insert "\n" generate-autoload-section-continuation)))))
+ (insert ";;; Generated autoloads from "
+ (autoload-trim-file-name file) "\n")
+ ;; Warn if we put a line in loaddefs.el
+ ;; that is long enough to cause trouble.
+ (while (< (point) output-end)
+ (let ((beg (point)))
+ (end-of-line)
+ (if (> (- (point) beg) 900)
+ (progn
+ (message "A line is too long--over 900 characters")
+ (sleep-for 2)
+ (goto-char output-end))))
+ (forward-line 1))
(goto-char output-end)
(insert generate-autoload-section-trailer)))
(message "Generating autoloads for %s...done" file)))
-
-(defconst generated-autoload-file "loaddefs.el"
- "*File \\[update-file-autoloads] puts autoloads into.
-A .el file can set this in its local variables section to make its
-autoloads go somewhere else.")
-
+\f
;;;###autoload
(defun update-file-autoloads (file)
"Update the autoloads for FILE in `generated-autoload-file'
(if (string-match "\\.elc?$" name)
(substring name 0 (match-beginning 0))
name)))
- (done nil)
+ (found nil)
(existing-buffer (get-file-buffer file)))
(save-excursion
;; We want to get a value for generated-autoload-file from
;; the local variables section if it's there.
- (set-buffer (find-file-noselect file))
- (set-buffer (find-file-noselect generated-autoload-file))
+ (if existing-buffer
+ (set-buffer existing-buffer))
+ ;; We must read/write the file without any code conversion.
+ (let ((coding-system-for-read 'no-conversion))
+ (set-buffer (find-file-noselect
+ (expand-file-name generated-autoload-file
+ (expand-file-name "lisp"
+ source-directory)))))
+ (or (> (buffer-size) 0)
+ (error "Autoloads file %s does not exist" buffer-file-name))
+ (or (file-writable-p buffer-file-name)
+ (error "Autoloads file %s is not writable" buffer-file-name))
(save-excursion
(save-restriction
(widen)
(goto-char (point-min))
- (while (search-forward generate-autoload-section-header nil t)
- (let ((form (condition-case ()
- (read (current-buffer))
- (end-of-file nil))))
- (if (string= (nth 2 form) load-name)
- (let ((begin (match-beginning 0))
- (last-time (nth 4 form))
- (file-time (nth 5 (file-attributes file))))
- (if (and (or (null existing-buffer)
- (not (buffer-modified-p existing-buffer)))
- (listp last-time) (= (length last-time) 2)
- (or (> (car last-time) (car file-time))
- (and (= (car last-time) (car file-time))
- (>= (nth 1 last-time)
- (nth 1 file-time)))))
- (message "Autoload section for %s is up to date."
- file)
- (search-forward generate-autoload-section-trailer)
- (delete-region begin (point))
- (generate-file-autoloads file))
- (setq done t))))))
- (if done
- ()
- ;; Have the user tell us where to put the section.
- (save-window-excursion
- (switch-to-buffer (current-buffer))
- (with-output-to-temp-buffer "*Help*"
- (princ (substitute-command-keys
- (format "\
-Move point to where the autoload section
-for %s should be inserted.
-Then do \\[exit-recursive-edit]."
- file))))
- (recursive-edit)
- (beginning-of-line))
- (generate-file-autoloads file)))
- (if (and (null existing-buffer)
- (setq existing-buffer (get-file-buffer file)))
- (kill-buffer existing-buffer)))))
+ ;; Look for the section for LOAD-NAME.
+ (while (and (not found)
+ (search-forward generate-autoload-section-header nil t))
+ (let ((form (autoload-read-section-header)))
+ (cond ((string= (nth 2 form) load-name)
+ ;; We found the section for this file.
+ ;; Check if it is up to date.
+ (let ((begin (match-beginning 0))
+ (last-time (nth 4 form))
+ (file-time (nth 5 (file-attributes file))))
+ (if (and (or (null existing-buffer)
+ (not (buffer-modified-p existing-buffer)))
+ (listp last-time) (= (length last-time) 2)
+ (or (> (car last-time) (car file-time))
+ (and (= (car last-time) (car file-time))
+ (>= (nth 1 last-time)
+ (nth 1 file-time)))))
+ (progn
+ (if (interactive-p)
+ (message "\
+Autoload section for %s is up to date."
+ file))
+ (setq found 'up-to-date))
+ (search-forward generate-autoload-section-trailer)
+ (delete-region begin (point))
+ (setq found t))))
+ ((string< load-name (nth 2 form))
+ ;; We've come to a section alphabetically later than
+ ;; LOAD-NAME. We assume the file is in order and so
+ ;; there must be no section for LOAD-NAME. We will
+ ;; insert one before the section here.
+ (goto-char (match-beginning 0))
+ (setq found 'new)))))
+ (or found
+ (progn
+ (setq found 'new)
+ ;; No later sections in the file. Put before the last page.
+ (goto-char (point-max))
+ (search-backward "\f" nil t)))
+ (or (eq found 'up-to-date)
+ (and (eq found 'new)
+ ;; Check that FILE has any cookies before generating a
+ ;; new section for it.
+ (save-excursion
+ (if existing-buffer
+ (set-buffer existing-buffer)
+ ;; It is faster to avoid visiting the file.
+ (set-buffer (get-buffer-create " *autoload-file*"))
+ (kill-all-local-variables)
+ (erase-buffer)
+ (setq buffer-undo-list t
+ buffer-read-only nil)
+ (emacs-lisp-mode)
+ (insert-file-contents file nil))
+ (save-excursion
+ (save-restriction
+ (widen)
+ (goto-char (point-min))
+ (prog1
+ (if (re-search-forward
+ (concat "^" (regexp-quote
+ generate-autoload-cookie))
+ nil t)
+ nil
+ (if (interactive-p)
+ (message "%s has no autoloads" file))
+ t)
+ (or existing-buffer
+ (kill-buffer (current-buffer))))))))
+ (generate-file-autoloads file))))
+ (and (interactive-p)
+ (buffer-modified-p)
+ (save-buffer)))))
;;;###autoload
-(defun update-autoloads-here ()
- "Update the sections of the current buffer generated by
-\\[update-file-autoloads]."
- (interactive)
- (let ((generated-autoload-file (buffer-file-name)))
+(defun update-autoloads-from-directories (&rest dirs)
+ "\
+Update loaddefs.el with all the current autoloads from DIRS, and no old ones.
+This uses `update-file-autoloads' (which see) do its work."
+ (interactive "DUpdate autoloads from directory: ")
+ (let ((files (apply 'nconc
+ (mapcar (function (lambda (dir)
+ (directory-files (expand-file-name dir)
+ t
+ "^[^=.].*\\.el$")))
+ dirs)))
+ autoloads-file
+ top-dir)
+ (setq autoloads-file
+ (expand-file-name generated-autoload-file
+ (expand-file-name "lisp"
+ source-directory)))
+ (setq top-dir (file-name-directory autoloads-file))
(save-excursion
- (goto-char (point-min))
- (while (search-forward generate-autoload-section-header nil t)
- (let* ((form (condition-case ()
- (read (current-buffer))
- (end-of-file nil)))
- (file (nth 3 form)))
- (if (and (stringp file)
- (or (get-file-buffer file)
- (file-exists-p file)))
- ()
- (setq file (if (y-or-n-p (format "Library \"%s\" (load \
-file \"%s\") doesn't exist. Remove its autoload section? "
- (nth 2 form) file))
- t
- (condition-case ()
- (read-file-name (format "Find \"%s\" load file: "
- (nth 2 form))
- nil nil t)
- (quit nil)))))
- (if file
- (let ((begin (match-beginning 0)))
- (search-forward generate-autoload-section-trailer)
- (delete-region begin (point))))
- (if (stringp file)
- (generate-file-autoloads file)))))))
-
-;;;###autoload
-(defun update-directory-autoloads (dir)
- "Run \\[update-file-autoloads] on each .el file in DIR."
- (interactive "DUpdate autoloads for directory: ")
- (mapcar 'update-file-autoloads
- (directory-files dir nil "\\.el$")))
+ (set-buffer (find-file-noselect autoloads-file))
+ (save-excursion
+ (goto-char (point-min))
+ (while (search-forward generate-autoload-section-header nil t)
+ (let* ((form (autoload-read-section-header))
+ (file (nth 3 form)))
+ (cond ((not (stringp file)))
+ ((not (file-exists-p (expand-file-name file top-dir)))
+ ;; Remove the obsolete section.
+ (let ((begin (match-beginning 0)))
+ (search-forward generate-autoload-section-trailer)
+ (delete-region begin (point))))
+ (t
+ (update-file-autoloads file)))
+ (setq files (delete file files)))))
+ ;; Elements remaining in FILES have no existing autoload sections.
+ (mapcar 'update-file-autoloads files)
+ (save-buffer))))
;;;###autoload
(defun batch-update-autoloads ()
- "Update the autoloads for the files or directories on the command line.
-Runs \\[update-file-autoloads] on files and \\[update-directory-autoloads]
-on directories. Must be used only with -batch, and kills Emacs on completion.
-Each file will be processed even if an error occurred previously.
-For example, invoke \"emacs -batch -f batch-update-autoloads *.el\""
- (if (not noninteractive)
- (error "batch-update-file-autoloads is to be used only with -batch"))
- (let ((lost nil)
- (args command-line-args-left))
- (while args
- (catch 'file
- (condition-case lossage
- (if (file-directory-p (expand-file-name (car args)))
- (update-directory-autoloads (car args))
- (update-file-autoloads (car args)))
- (error (progn (message ">>Error processing %s: %s"
- (car args) lossage)
- (setq lost t)
- (throw 'file nil)))))
- (setq args (cdr args)))
- (save-some-buffers t)
- (message "Done")
- (kill-emacs (if lost 1 0))))
+ "Update loaddefs.el autoloads in batch mode.
+Calls `update-autoloads-from-directories' on the command line arguments."
+ (apply 'update-autoloads-from-directories command-line-args-left)
+ (setq command-line-args-left nil))
(provide 'autoload)