app-editors/xemacs: patch for make problem in xemacs-21.5.34

Upstream found a problem that could explain the issues seen with
builds on tinderboxes with highly parallel builds.

Bug: https://bugs.gentoo.org/843236
Signed-off-by: Mats Lidell <matsl@gentoo.org>

2 files changed, 185 insertions, 0 deletions

diff --git a/app-editors/xemacs/files/xemacs-21.5.34-autoloads-parallell-make.patch b/app-editors/xemacs/files/xemacs-21.5.34-autoloads-parallell-make.patch
new file mode 100644
index 000000000000..9a86046be992
--- /dev/null
+++ b/app-editors/xemacs/files/xemacs-21.5.34-autoloads-parallell-make.patch
@@ -0,0 +1,184 @@
+--- 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) 
diff --git a/app-editors/xemacs/xemacs-21.5.34-r9.ebuild b/app-editors/xemacs/xemacs-21.5.34-r9.ebuild
index bba9dbfeb9b6..e0099ac478ba 100644
--- a/app-editors/xemacs/xemacs-21.5.34-r9.ebuild
+++ b/app-editors/xemacs/xemacs-21.5.34-r9.ebuild
@@ -67,6 +67,7 @@ src_prepare() {
 	eapply "${FILESDIR}/${P}-ar.patch"
 	eapply "${FILESDIR}/${P}-strsignal.patch"
 	eapply "${FILESDIR}/${P}-process-test-qa.patch"
+	eapply "${FILESDIR}/${P}-autoloads-parallell-make.patch"
 
 	eapply_user