diff options
Diffstat (limited to 'app-editors/xemacs/files')
| -rw-r--r-- | app-editors/xemacs/files/xemacs-21.5.34-autoloads-parallell-make.patch | 184 | ||||
| -rw-r--r-- | app-editors/xemacs/files/xemacs-21.5.34-no-lock-on-finder-inf.patch | 99 |
2 files changed, 283 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/files/xemacs-21.5.34-no-lock-on-finder-inf.patch b/app-editors/xemacs/files/xemacs-21.5.34-no-lock-on-finder-inf.patch new file mode 100644 index 000000000000..a37fc5e95fe0 --- /dev/null +++ b/app-editors/xemacs/files/xemacs-21.5.34-no-lock-on-finder-inf.patch @@ -0,0 +1,99 @@ +# HG changeset patch +# User Aidan Kehoe <kehoea@parhasard.net> +# Date 1656333099 -3600 +# Mon Jun 27 13:31:39 2022 +0100 +# Node ID c6966a009d0dc3b546c9d843141c1fb5daa89b9e +# Parent 16e37125d7ea85048e89197ce8fe83f44b00ccc5 +Don't create a lock file when generating finder-inf.el + +lisp/ChangeLog addition: + +2022-06-27 Aidan Kehoe <kehoea@parhasard.net> + + * finder.el (finder-compile-keywords): + Don't use the save-buffer infrastructure when generating + finder-inf.el, since that leads to lock files, making parallel + builds less likely to work. Thank you Mats Lidell and the Gentoo + users! + +src/ChangeLog addition: + +2022-06-27 Aidan Kehoe <kehoea@parhasard.net> + + * Makefile.in.in ($(LISP)/finder-inf.el): + Don't remove finder-inf.el before regenerating it, Lisp will + overwrite it. + +diff -r 16e37125d7ea -r c6966a009d0d lisp/finder.el +--- a/lisp/finder.el Sun Jun 26 19:14:02 2022 +0300 ++++ b/lisp/finder.el Mon Jun 27 13:31:39 2022 +0100 +@@ -151,7 +151,7 @@ + arguments compiles from `load-path'." + (save-excursion + ;; XEmacs change +- (find-file (expand-file-name "finder-inf.el" lisp-directory)) ++ (set-buffer (generate-new-buffer "finder-inf.el")) + (let ((processed nil) + (directory-abbrev-alist + (append +@@ -160,11 +160,12 @@ + ""))) + finder-abbreviate-directory-list) + directory-abbrev-alist)) +- (using-load-path)) ++ using-load-path second-line-marker finder-scratch) + (or dirs (setq dirs load-path)) + (setq using-load-path (equal dirs load-path)) + (erase-buffer) + (insert ";;; finder-inf.el --- keyword-to-package mapping\n") ++ (setq second-line-marker (point-marker)) + (insert ";; Keywords: help\n") + (insert ";;; Commentary:\n") + (insert ";; Don't edit this file. It's generated by finder.el\n\n") +@@ -180,7 +181,8 @@ + (if (not finder-compile-keywords-quiet) + (message "Processing %s ..." f)) + (save-excursion +- (set-buffer (get-buffer-create "*finder-scratch*")) ++ (set-buffer (setq finder-scratch ++ (get-buffer-create "*finder-scratch*"))) + (buffer-disable-undo (current-buffer)) + (erase-buffer) + (insert-file-contents (expand-file-name f d)) +@@ -210,10 +212,23 @@ + (directory-files d nil "^[^=].*\\.el$")))) + dirs) + (insert "))\n\n(provide 'finder-inf)\n\n;;; finder-inf.el ends here\n") +- (kill-buffer "*finder-scratch*") ++ (if finder-scratch (kill-buffer finder-scratch)) + (unless noninteractive + (eval-current-buffer)) ; So we get the new keyword list immediately +- (basic-save-buffer)))) ++ (goto-char (point-min)) ++ (if (re-search-forward "[^\x00-\x7f]" nil t) ++ (progn ++ (goto-char (point-min)) ++ (if (re-search-forward "[^\x00-\xff]" nil t) ++ (progn (goto-char second-line-marker) ++ (insert ";;; -*- coding: escape-quoted -*-\n") ++ (setq buffer-file-coding-system 'iso-8859-1-unix)) ++ (goto-char second-line-marker) ++ (insert ";;; -*- coding: iso-8859-1 -*-\n") ++ (setq buffer-file-coding-system 'escape-quoted-unix))) ++ (setq buffer-file-coding-system 'no-conversion-unix)) ++ (write-region (point-min) (point-max) ++ (expand-file-name "finder-inf.el" lisp-directory))))) + + (defun finder-compile-keywords-make-dist () + "Regenerate `finder-inf.el' for the Emacs distribution." +diff -r 16e37125d7ea -r c6966a009d0d src/Makefile.in.in +--- a/src/Makefile.in.in Sun Jun 26 19:14:02 2022 +0300 ++++ b/src/Makefile.in.in Mon Jun 27 13:31:39 2022 +0100 +@@ -590,7 +590,6 @@ + + $(LISP)/finder-inf.el: update-elc-2 + @echo "Building finder database ..." +- $(RM) $(LISP)/finder-inf.el + $(XEMACS_BATCH) -eval "(setq finder-compile-keywords-quiet t)" \ + -eval "(setq lisp-directory \"$(LISP)\")" \ + -l finder -f finder-compile-keywords |