Changed version to 1.2.1.

[gnu-emacs] / lisp / emacs-lisp / autoload.el

diff --git a/lisp/emacs-lisp/autoload.el b/lisp/emacs-lisp/autoload.el
index 1bce589cc8c1dec0c3984ba716e0c94f8cbf20b4..95201694fb162c42fc4e2a0a9f0e02b071c0185a 100644 (file)
--- a/lisp/emacs-lisp/autoload.el
+++ b/lisp/emacs-lisp/autoload.el
@@ -61,23 +61,33 @@ that text will be copied verbatim to `generated-autoload-file'.")
 
 (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, defmacro or defcustom."
+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))
+    (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 (if (eq car 'define-skeleton)
-                             form
-                           (cdr form)))
+               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))
-         (list 'autoload (list 'quote name) file doc
-               (or (eq car 'define-skeleton)
+         ;; `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,
@@ -97,8 +107,6 @@ Returns nil if FORM is not a defun, define-skeleton, defmacro or defcustom."
                                  ,(plist-get rest :require)))))
        nil))))
 
-(put 'define-skeleton 'doc-string-elt 3)
-
 ;;; 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.
@@ -123,6 +131,11 @@ Returns nil if FORM is not a defun, define-skeleton, defmacro or defcustom."
 (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
@@ -220,7 +233,10 @@ are used."
                        ;; Read the next form and make an autoload.
                        (let* ((form (prog1 (read (current-buffer))
                                       (or (bolp) (forward-line 1))))
-                              (autoload (make-autoload form load-name))
+                              (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
@@ -237,7 +253,8 @@ are used."
                                     (elt (cdr p)))
                                (setcdr p nil)
                                (princ "\n(" outbuf)
-                               (let ((print-escape-newlines t))
+                               (let ((print-escape-newlines t)
+                                     (print-escape-nonascii t))
                                  (mapcar (function (lambda (elt)
                                                      (prin1 elt outbuf)
                                                      (princ " " outbuf)))
@@ -266,8 +283,16 @@ are used."
                                            1)
                                           outbuf))
                                  (terpri outbuf)))
-                           (let ((print-escape-newlines t))
-                             (print autoload 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