--- a/lisp/update-elc-2.el.orig 2022-06-16 21:58:48.748641021 +0200 +++ b/lisp/update-elc-2.el 2022-06-16 21:58:48.748641021 +0200 @@ -137,37 +137,10 @@ (let ((dir (car command-line-args-left))) ;; don't depend on being able to autoload `update-autoload-files'! (load "autoload") - (autoload 'cl-compile-time-init "cl-macs") (load "bytecomp") (load "byte-optimize") - ;; #### the API used here is deprecated, convert to one with explicit - ;; arguments when it is available - ;; update-elc.el signals us to rebuild the autoloads when necessary. - ;; in some cases it will rebuild the autoloads itself, but doing it this - ;; way is slow, so we avoid it when possible. - (when (file-exists-p (expand-file-name "REBUILD_AUTOLOADS" - invocation-directory)) - ;; if we were instructed to rebuild the autoloads, force the file - ;; to be touched even w/o changes; otherwise, we won't ever stop - ;; being told to rebuild them. - (update-autoload-files dir "auto" nil t) - (byte-recompile-file (expand-file-name "auto-autoloads.el" dir) 0) - (when (featurep 'mule) - (let ((muledir (expand-file-name "../lisp/mule" (file-truename dir)))) - ;; force here just like above. - (update-autoload-files muledir "mule" nil t) - (byte-recompile-file (expand-file-name "auto-autoloads.el" dir) 0)))) - (when (featurep 'modules) - (let* ((moddir (expand-file-name "../modules" (file-truename dir))) - (autofile (expand-file-name "auto-autoloads.el" moddir))) - (update-autoload-files - (delete (concat (file-name-as-directory moddir) ".") - (delete (concat (file-name-as-directory moddir) "..") - (directory-files moddir t nil nil 0))) - "modules" autofile) - (byte-recompile-file autofile 0))) - ;; now load the (perhaps newly rebuilt) autoloads; we were called with - ;; -no-autoloads so they're not already loaded. + ;; now load the autoloads; we were called with -no-autoloads so they're not + ;; already loaded. (load (expand-file-name "auto-autoloads" lisp-directory)) (when (featurep 'mule) (load (expand-file-name "mule/auto-autoloads" lisp-directory))) @@ -175,6 +148,8 @@ ;; there may be dependencies between one .el and another (even across ;; directories), and we don't want to load an out-of-date .elc while ;; byte-compiling a file. + (when (featurep 'modules) + (load (expand-file-name "auto-autoloads" module-directory))) (message "Removing old or spurious .elcs in directory tree `%s'..." dir) (do-update-elc-2 dir nil nil) (message "Removing old or spurious .elcs in directory tree `%s'...done" --- a/lisp/update-elc.el.orig 2022-06-16 21:58:48.748641021 +0200 +++ b/lisp/update-elc.el 2022-06-16 21:58:48.748641021 +0200 @@ -54,8 +54,11 @@ (defvar update-elc-files-to-compile nil) (defvar need-to-rebuild-autoloads nil) (defvar need-to-rebuild-mule-autoloads nil) +(defvar need-to-rebuild-module-autoloads nil) (defvar need-to-recompile-autoloads nil) (defvar need-to-recompile-mule-autoloads nil) +(defvar need-to-recompile-module-autoloads nil) + (defvar exe-target nil) (defvar dump-target nil) (defvar dump-target-out-of-date-wrt-dump-files nil) @@ -84,10 +87,14 @@ (defvar source-lisp-mule (expand-file-name "mule" source-lisp)) (defvar source-directory (expand-file-name ".." source-lisp)) +(defconst module-directory (expand-file-name "modules" source-directory)) + (defvar aa-lisp (expand-file-name "auto-autoloads.el" source-lisp)) (defvar aac-lisp (expand-file-name "auto-autoloads.elc" source-lisp)) (defvar aa-lisp-mule (expand-file-name "auto-autoloads.el" source-lisp-mule)) (defvar aac-lisp-mule (expand-file-name "auto-autoloads.elc" source-lisp-mule)) +(defvar aa-modules (expand-file-name "auto-autoloads.el" module-directory)) +(defvar aac-modules (expand-file-name "auto-autoloads.elc" module-directory)) (setq load-path (list source-lisp)) @@ -130,7 +137,8 @@ (defvar lisp-files-ignored-when-checking-for-autoload-updating '("custom-load.el" - "auto-autoloads.el") + "auto-autoloads.el" + "finder-inf.el") "Lisp files that should not trigger auto-autoloads rebuilding.") (defun update-elc-chop-extension (file) @@ -270,6 +278,18 @@ (setq all-files-in-dir (cdr all-files-in-dir)))) (setq dirs-to-check (cdr dirs-to-check)))) + ;; Check for the module autoloads separately, given the need to run + ;; directory-files on subdirectories. + (let ((autoload-file + (expand-file-name "auto-autoloads.el" module-directory))) + (mapc + #'(lambda (full-dir) + (mapc #'(lambda (full-arg) + (when (file-newer-than-file-p full-arg autoload-file) + (setq need-to-rebuild-module-autoloads t))) + (directory-files full-dir t "\\.c$" nil t))) + (directory-files module-directory t nil t 'subdirs))) + (if dump-target-out-of-date-wrt-dump-files (condition-case nil (write-region-internal @@ -297,6 +317,14 @@ (file-newer-than-file-p aa-lisp-mule aac-lisp-mule)) (setq need-to-recompile-mule-autoloads t)) +(when (or need-to-rebuild-module-autoloads + ;; not necessary but ... see comment above. + (eq (file-exists-p aa-modules) nil) + ;; no need to check for file-exists of .elc due to definition + ;; of file-newer-than-file-p + (file-newer-than-file-p aa-modules aac-modules)) + (setq need-to-recompile-module-autoloads t)) + (when (not (featurep 'mule)) ;; sorry charlie. (setq need-to-rebuild-mule-autoloads nil @@ -318,15 +346,18 @@ (if need-to-rebuild-mule-autoloads (list "-f" "batch-update-directory-autoloads" "mule" source-lisp-mule)) + (if need-to-rebuild-module-autoloads + (list "-f" "batch-update-directory-autoloads" + "auto" module-directory)) (if need-to-recompile-autoloads (list "-f" "batch-byte-compile-one-file" aa-lisp)) (if need-to-recompile-mule-autoloads (list "-f" "batch-byte-compile-one-file" - aa-lisp-mule))))) - (condition-case nil - (delete-file (expand-file-name "src/REBUILD_AUTOLOADS" build-directory)) - (file-error nil)) + aa-lisp-mule)) + (if need-to-recompile-module-autoloads + (list "-f" "batch-byte-compile-one-file" + aa-modules))))) (cond ((and (not update-elc-files-to-compile) (not need-to-rebuild-autoloads) (not need-to-rebuild-mule-autoloads) @@ -335,17 +366,25 @@ ;; (1) Nothing to do at all. ) ((not update-elc-files-to-compile) - ;; (2) We have no files to byte-compile, but we do need to - ;; regenerate and compile the auto-autoloads file, so signal - ;; update-elc-2 to do it. This is much faster than loading - ;; all the .el's and doing it here. (We only need to rebuild - ;; the autoloads here when we have files to compile, since - ;; they may depend on the updated autoloads.) - (condition-case nil - (write-region-internal - "foo" nil (expand-file-name "src/REBUILD_AUTOLOADS" build-directory)) - (file-error nil)) - ) + ;; (2) We have no files to byte-compile, but we do need to regenerate + ;; and compile the auto-autoloads file. Don't pass this on to + ;; update-elc-2.el to do, since that gives dependency problems + ;; with parallel builds (make -j and friends). Completely fine to + ;; use the compiled Lisp infrastructure for this, though, since we + ;; know it's up to date. + (setq command-line-args + (append + '("-l" "loadup-el.el" "run-temacs" + "-batch" "-no-packages" "-no-autoloads" + "-eval" "(setq stack-trace-on-error t)" + "-eval" "(setq load-always-display-messages t)" + "-l" "bytecomp.elc" "-l" "autoload.elc") + do-autoload-commands)) + (write-sequence "\nNeed to regenerate auto-autoload files... " + 'external-debugging-output) + (let ((load-ignore-elc-files nil) + (purify-flag nil)) + (load "loadup.el"))) (t (let ((bc-bootstrap (mapcar #'(lambda (arg)