commit 9fc46f1fd9580c19656688e379e146401c19ef66 (HEAD, refs/remotes/origin/master)
Author: Elías Gabriel Pérez <eg642616@gmail.com>
Date:   Sun Nov 9 09:20:05 2025 +0200

    hideshow: Rework previous changes
    
    * lisp/progmodes/hideshow.el (hs-grok-mode-type): Improve 'hs--set-variable'.
    * lisp/progmodes/python.el (python-base-mode, python-ts-mode):
    Provide backward-compatibility for older versions.

diff --git a/lisp/progmodes/hideshow.el b/lisp/progmodes/hideshow.el
index 764fdb66848..c8b4e68f00f 100644
--- a/lisp/progmodes/hideshow.el
+++ b/lisp/progmodes/hideshow.el
@@ -1019,21 +1019,21 @@ Otherwise, return nil."
           (when (>= (point) q)
             (list (and hideable p) (point))))))))
 
-(defun hs--set-variable (var old-nth &optional default)
+(defun hs--set-variable (var nth &optional default)
   "Set Hideshow VAR if already not set.
 This function is meant to be used for backward compatibility with
 `hs-special-modes-alist'.
 
-OLD-NTH is a number indicating NTH element of `hs-special-modes-alist'.
+NTH must be a number indicating NTH element of
+`hs-special-modes-alist' or a function.
 
 DEFAULT is a value to use as fallback."
   (unless (local-variable-p var) ; Already set, nothing to do.
-    (if-let* (old-nth
-              (old-lookup (assoc major-mode hs-special-modes-alist)))
-        (set (make-local-variable var)
-             (if (integerp old-nth)
-                 (nth old-nth old-lookup)
-               (funcall old-nth old-lookup)))
+    (if-let* ((old-lookup (assoc major-mode hs-special-modes-alist))
+              (val (if (integerp nth)
+                       (nth nth old-lookup)
+                     (funcall nth old-lookup))))
+        (set (make-local-variable var) val)
       (when default
         (set (make-local-variable var) default)))))
 
@@ -1048,12 +1048,14 @@ If `hs-special-modes-alist' has information associated with the current
 buffer's major mode, use that.  Otherwise, guess start, end and
 `comment-start' regexps; `forward-sexp' function; and
 adjust-block-beginning function."
-  (hs--set-variable 'hs-block-start-regexp #'caadr)
-  (hs--set-variable 'hs-block-start-mdata-select #'cadadr)
+  (hs--set-variable 'hs-block-start-regexp
+                    (lambda (v) (car (ensure-list (nth 1 v)))))
+  (hs--set-variable 'hs-block-start-mdata-select
+                    (lambda (v) (cadr (ensure-list (nth 1 v)))))
   (hs--set-variable 'hs-block-end-regexp 2)
   (hs--set-variable 'hs-c-start-regexp 3
                     (string-trim-right (regexp-quote comment-start)))
-  (hs--set-variable 'hs-forward-sexp-function 4)
+  (hs--set-variable 'hs-forward-sexp-function 4 #'forward-sexp)
   (hs--set-variable 'hs-adjust-block-beginning-function 5)
   (hs--set-variable 'hs-find-block-beginning-function 6)
   (hs--set-variable 'hs-find-next-block-function 7)
diff --git a/lisp/progmodes/python.el b/lisp/progmodes/python.el
index 12557aecf4d..c4cf7ec46cf 100644
--- a/lisp/progmodes/python.el
+++ b/lisp/progmodes/python.el
@@ -7355,15 +7355,30 @@ implementations: `python-mode' and `python-ts-mode'."
                       #'python-eldoc-function))))
   (eldoc-add-command-completions "python-indent-dedent-line-backspace")
 
-  (setq-local hs-block-start-regexp python-nav-beginning-of-block-regexp)
-  ;; Use the empty string as end regexp so it doesn't default to
-  ;; "\\s)".  This way parens at end of defun are properly hidden.
-  (setq-local hs-block-end-regexp "")
-  (setq-local hs-c-start-regexp "#")
-  (setq-local hs-forward-sexp-function #'python-hideshow-forward-sexp-function)
-  (setq-local hs-find-block-beginning-function #'python-nav-beginning-of-block)
-  (setq-local hs-find-next-block-function #'python-hideshow-find-next-block)
-  (setq-local hs-looking-at-block-start-predicate #'python-info-looking-at-beginning-of-block)
+  (if (< emacs-major-version 31)
+      (dolist (mode '(python-mode python-ts-mode))
+        (add-to-list
+         'hs-special-modes-alist
+         `(,mode
+           ,python-nav-beginning-of-block-regexp
+           ;; Use the empty string as end regexp so it doesn't default to
+           ;; "\\s)".  This way parens at end of defun are properly hidden.
+           ""
+           "#"
+           python-hideshow-forward-sexp-function
+           nil
+           python-nav-beginning-of-block
+           python-hideshow-find-next-block
+           python-info-looking-at-beginning-of-block)))
+    (setq-local hs-block-start-regexp python-nav-beginning-of-block-regexp)
+    ;; Use the empty string as end regexp so it doesn't default to
+    ;; "\\s)".  This way parens at end of defun are properly hidden.
+    (setq-local hs-block-end-regexp "")
+    (setq-local hs-c-start-regexp "#")
+    (setq-local hs-forward-sexp-function #'python-hideshow-forward-sexp-function)
+    (setq-local hs-find-block-beginning-function #'python-nav-beginning-of-block)
+    (setq-local hs-find-next-block-function #'python-hideshow-find-next-block)
+    (setq-local hs-looking-at-block-start-predicate #'python-info-looking-at-beginning-of-block))
 
   (setq-local outline-regexp (python-rx (* space) block-start))
   (setq-local outline-level
@@ -7437,8 +7452,9 @@ implementations: `python-mode' and `python-ts-mode'."
     (setq-local forward-sexp-function #'treesit-forward-sexp
                 treesit-sexp-thing 'sexp)
 
-    (setq-local hs-treesit-things '(or defun sexp))
-    (setq-local hs-adjust-block-end-function #'python-ts-hs-adjust-block-end-fn)
+    (when (>= emacs-major-version 31)
+      (setq-local hs-treesit-things '(or defun sexp))
+      (setq-local hs-adjust-block-end-function #'python-ts-hs-adjust-block-end-fn))
 
     (setq-local syntax-propertize-function #'python--treesit-syntax-propertize)
 

commit f11349ea1a5f391a457da90a7a07af9ba7f47e6d
Author: Eli Zaretskii <eliz@gnu.org>
Date:   Sun Nov 9 08:58:15 2025 +0200

    Fix a crash in 'merge_face_ref'
    
    * src/xfaces.c (get_lface_attributes): Avoid crashes if F is NULL.
    This happens when 'face_inheritance_cycle' is for some reason
    called for the default attributes of a face (which are applicable
    to future frames).  We avoid the crashes by not consulting face
    remapping in that case, since face remapping is buffer-local, and
    therefore cannot possibly affect face defaults.  (Bug#79790)

diff --git a/src/xfaces.c b/src/xfaces.c
index 3a6d2aecba6..6189337ff68 100644
--- a/src/xfaces.c
+++ b/src/xfaces.c
@@ -2125,25 +2125,31 @@ get_lface_attributes (struct window *w,
 
   face_name = resolve_face_name (face_name, signal_p);
 
-  /* See if SYMBOL has been remapped to some other face (usually this
-     is done buffer-locally).  */
-  face_remapping = assq_no_quit (face_name, Vface_remapping_alist);
-  if (CONSP (face_remapping))
+  /* See if SYMBOL has been remapped to some other face (usually this is
+     done buffer-locally).  We only do that of F is non-NULL, because
+     face remapping is not relevant for default attributes of faces for
+     future frames, and because merge_face_ref cannot handle NULL frames
+     anyway.  */
+  if (f)
     {
-      struct named_merge_point named_merge_point;
-
-      if (push_named_merge_point (&named_merge_point,
-				  face_name, NAMED_MERGE_POINT_REMAP,
-				  &named_merge_points))
+      face_remapping = assq_no_quit (face_name, Vface_remapping_alist);
+      if (CONSP (face_remapping))
 	{
-	  int i;
+	  struct named_merge_point named_merge_point;
 
-	  for (i = 1; i < LFACE_VECTOR_SIZE; ++i)
-	    attrs[i] = Qunspecified;
+	  if (push_named_merge_point (&named_merge_point,
+				      face_name, NAMED_MERGE_POINT_REMAP,
+				      &named_merge_points))
+	    {
+	      int i;
+
+	      for (i = 1; i < LFACE_VECTOR_SIZE; ++i)
+		attrs[i] = Qunspecified;
 
-	  return merge_face_ref (w, f, XCDR (face_remapping), attrs,
-	                         signal_p, named_merge_points,
-	                         0);
+	      return merge_face_ref (w, f, XCDR (face_remapping), attrs,
+	                             signal_p, named_merge_points,
+	                             0);
+	    }
 	}
     }
 

commit 266335374e29cfd304838b2109af93ab22f6009f
Author: Wilson Snyder <wsnyder@wsnyder.org>
Date:   Sat Nov 8 18:33:58 2025 -0500

    verilog-mode: Make recent change backward-compatible and update from package upstream.
    
    * lisp/progmodes/verilog-mode.el (verilog-mode): Support Emacs 31.1
    'hs-forward-sexp-func in backward-compatible way.
    (verilog-submit-bug-report) Remove key binding.

diff --git a/lisp/progmodes/verilog-mode.el b/lisp/progmodes/verilog-mode.el
index 79b75c24db5..51e3270a58c 100644
--- a/lisp/progmodes/verilog-mode.el
+++ b/lisp/progmodes/verilog-mode.el
@@ -9,7 +9,7 @@
 ;; Keywords: languages
 ;; The "Version" is the date followed by the decimal rendition of the Git
 ;;     commit hex.
-;; Version: 2025.01.01.100165202
+;; Version: 2025.11.08.248496848
 
 ;; Yoni Rabkin <yoni@rabkins.net> contacted the maintainer of this
 ;; file on 19/3/2008, and the maintainer agreed that when a bug is
@@ -124,7 +124,7 @@
 ;;
 
 ;; This variable will always hold the version number of the mode
-(defconst verilog-mode-version "2025-01-01-5f86652-vpo-GNU"
+(defconst verilog-mode-version "2025-11-08-ecfc2d0-vpo-GNU"
   "Version of this Verilog mode.")
 (defconst verilog-mode-release-emacs t
   "If non-nil, this version of Verilog mode was released with Emacs itself.")
@@ -1586,7 +1586,6 @@ If set will become buffer local.")
     (define-key map "\C-c\C-r" #'verilog-label-be)
     (define-key map "\C-c\C-i" #'verilog-pretty-declarations)
     (define-key map "\C-c="    #'verilog-pretty-expr)
-    (define-key map "\C-c\C-b" #'verilog-submit-bug-report)
     (define-key map "\C-c/"    #'verilog-star-comment)
     (define-key map "\C-c\C-c" #'verilog-comment-region)
     (define-key map "\C-c\C-u" #'verilog-uncomment-region)
@@ -4363,9 +4362,16 @@ Key bindings specific to `verilog-mode-map' are:
   (when (and (boundp 'which-func-modes) (listp which-func-modes))
     (add-to-list 'which-func-modes 'verilog-mode))
   ;; hideshow support
-  (setq-local hs-block-start-regexp "\\<begin\\>")
-  (setq-local hs-block-end-regexp "\\<end\\>")
-  (setq-local hs-forward-sexp-function #'verilog-forward-sexp-function)
+  (cond ((boundp 'hs-forward-sexp-function)  ;; 31.1 and beyond
+         (setq-local hs-block-start-regexp "\\<begin\\>")
+         (setq-local hs-block-end-regexp "\\<end\\>")
+         (setq-local hs-forward-sexp-function #'verilog-forward-sexp-function))
+        ((boundp 'hs-special-modes-alist)  ;; pre 31.1, not XEmacs
+         (unless (assq 'verilog-mode hs-special-modes-alist)
+           (setq hs-special-modes-alist
+                 (cons '(verilog-mode "\\<begin\\>" "\\<end\\>" nil
+                                      verilog-forward-sexp-function)
+                       hs-special-modes-alist)))))
 
   (add-hook 'completion-at-point-functions
             #'verilog-completion-at-point nil 'local)

commit ef2584585b095fff1e045e58673d2a7c8f9af799
Author: Elías Gabriel Pérez <eg642616@gmail.com>
Date:   Sat Nov 8 20:04:30 2025 +0200

    hideshow: Rework previous changes
    
    * lisp/progmodes/hideshow.el: Set default values of buffer-local variables.
    (hs-inside-comment-p): Restore.
    (hs--set-variable): Rename from 'hs--get-mode-value'.
    (hs-grok-mode-type): Rework.
    * lisp/nxml/nxml-mode.el:
    * lisp/progmodes/f90.el:
    * lisp/progmodes/fortran.el:
    * lisp/progmodes/icon.el:
    * lisp/progmodes/lua-mode.el:
    * lisp/progmodes/python.el:
    * lisp/progmodes/verilog-mode.el:
    * lisp/progmodes/vhdl-mode.el:
    * lisp/textmodes/mhtml-mode.el:
    * lisp/textmodes/sgml-mode.el:
    * lisp/treesit.el (treesit-major-mode-setup): Rename
    'hs-forward-sexp-func' to 'hs-forward-sexp-function',
    'hs-adjust-block-beginning' to 'hs-adjust-block-beginning-function',
    'hs-find-block-beginning-func' to 'hs-find-block-beginning-function',
    'hs-find-next-block-func' to 'hs-find-next-block-function',
    'hs-looking-at-block-start-p-func' to 'hs-looking-at-block-start-predicate',
    'hs-inside-comment-p-func' to 'hs-inside-comment-predicate'.

diff --git a/lisp/nxml/nxml-mode.el b/lisp/nxml/nxml-mode.el
index 08c6c1b2fac..9b780a91721 100644
--- a/lisp/nxml/nxml-mode.el
+++ b/lisp/nxml/nxml-mode.el
@@ -535,7 +535,7 @@ Many aspects this mode can be customized using
   (setq-local hs-block-start-regexp "<[^/>]*?")
   (setq-local hs-block-end-regexp "</[^/>]*[^/]>")
   (setq-local hs-c-start-regexp "<!--")
-  (setq-local hs-forward-sexp-func #'sgml-skip-tag-forward)
+  (setq-local hs-forward-sexp-function #'sgml-skip-tag-forward)
   (save-excursion
     (save-restriction
       (widen)
diff --git a/lisp/progmodes/f90.el b/lisp/progmodes/f90.el
index d5cdbb3bf42..be9da4108a4 100644
--- a/lisp/progmodes/f90.el
+++ b/lisp/progmodes/f90.el
@@ -1187,7 +1187,7 @@ with no args, if that value is non-nil."
   (setq-local hs-block-start-regexp f90-start-block-re)
   (setq-local hs-block-end-regexp f90-end-block-re)
   (setq-local hs-c-start-regexp "!")
-  (setq-local hs-forward-sexp-func #'f90-end-of-block))
+  (setq-local hs-forward-sexp-function #'f90-end-of-block))
 
 
 ;; Inline-functions.
diff --git a/lisp/progmodes/fortran.el b/lisp/progmodes/fortran.el
index 18813257400..a232e1bb320 100644
--- a/lisp/progmodes/fortran.el
+++ b/lisp/progmodes/fortran.el
@@ -837,7 +837,7 @@ with no args, if that value is non-nil."
   (setq-local hs-block-start-regexp fortran-start-block-re)
   (setq-local hs-block-end-regexp fortran-end-block-re)
   (setq-local hs-c-start-regexp "^[cC*!]")
-  (setq-local hs-forward-sexp-func #' fortran-end-of-block))
+  (setq-local hs-forward-sexp-function #' fortran-end-of-block))
 
 
 (defun fortran-line-length (nchars &optional global)
@@ -1247,7 +1247,7 @@ Directive lines are treated as comments."
           (goto-char i)
           (= (line-beginning-position) p)))))
 
-;; Used in hs-forward-sexp-func.
+;; Used in hs-forward-sexp-function.
 (defun fortran-end-of-block (&optional num)
   "Move point forward to the end of the current code block.
 With optional argument NUM, go forward that many balanced blocks.
diff --git a/lisp/progmodes/hideshow.el b/lisp/progmodes/hideshow.el
index 89305a1d313..764fdb66848 100644
--- a/lisp/progmodes/hideshow.el
+++ b/lisp/progmodes/hideshow.el
@@ -106,7 +106,7 @@
 ;; nested level in addition to the top-level:
 ;;
 ;;     (defun ttn-hs-hide-level-1 ()
-;;       (when (funcall hs-looking-at-block-start-p-func)
+;;       (when (funcall hs-looking-at-block-start-predicate)
 ;;         (hs-hide-level 1))
 ;;       (forward-sexp 1))
 ;;     (setq hs-hide-all-non-comment-function 'ttn-hs-hide-level-1)
@@ -154,10 +154,10 @@
 ;; activate.  If you want to override this, you can set any of the
 ;; following variables: `hs-block-start-regexp',
 ;; `hs-block-start-mdata-select', `hs-block-end-regexp',
-;; `hs-c-start-regexp', `hs-forward-sexp-func',
-;; `hs-adjust-block-beginning', `hs-adjust-block-end',
-;; `hs-find-block-beginning-func', `hs-find-next-block-func',
-;; `hs-looking-at-block-start-p-func', `hs-inside-comment-p-func',
+;; `hs-c-start-regexp', `hs-forward-sexp-function',
+;; `hs-adjust-block-beginning-function', `hs-adjust-block-end-function',
+;; `hs-find-block-beginning-function', `hs-find-next-block-function',
+;; `hs-looking-at-block-start-predicate', `hs-inside-comment-predicate',
 ;; `hs-treesit-things'.
 ;;
 ;; These variables help hideshow know what is considered a block, which
@@ -167,7 +167,7 @@
 ;; `hs-block-end-regexp'.
 ;;
 ;; For some major modes, forward-sexp does not work properly.  In those
-;; cases, `hs-forward-sexp-func' specifies another function to use
+;; cases, `hs-forward-sexp-function' specifies another function to use
 ;; instead.
 
 ;; ** Tree-sitter support
@@ -178,7 +178,7 @@
 ;; However, for some modes the `list' thing is not enough for detecting
 ;; the proper code block and the range to hide, you can set the variable
 ;; `hs-treesit-things' to override this, but ensure you have the proper
-;; values in `hs-adjust-block-end' and `hs-adjust-block-beginning' to
+;; values in `hs-adjust-block-end-function' and `hs-adjust-block-beginning-function' to
 ;; properly hide the code block.
 
 ;; * Bugs
@@ -530,28 +530,16 @@ Note that `mode-line-format' is buffer-local.")
 ;;---------------------------------------------------------------------------
 ;; API variables
 
-(defvar-local hs-block-start-regexp nil
-  "Regexp for beginning of block.
+(defvar-local hs-block-start-regexp "\\s("
+  "Regexp for beginning of block.")
 
-It should not contain leading or trailing whitespace.
-Letter-case does not matter.
-
-If not bound, this will be set to \"\\s(\".")
-
-(defvar-local hs-block-start-mdata-select nil
+(defvar-local hs-block-start-mdata-select 0
   "Element in `hs-block-start-regexp' match data to consider as block start.
 The internal function `hs-forward-sexp' moves point to the beginning of this
-element (using `match-beginning') before calling `hs-forward-sexp-func'.
-
-If not bound, this will be set to 0")
-
-(defvar-local hs-block-end-regexp nil
-  "Regexp for end of block.
-
-It should not contain leading or trailing whitespace.
-Letter-case does not matter.
+element (using `match-beginning') before calling `hs-forward-sexp-function'.")
 
-If not bound, this will be set to \"\\s)\"")
+(defvar-local hs-block-end-regexp "\\s)"
+  "Regexp for end of block.")
 
 (defvar-local hs-c-start-regexp nil
   "Regexp for beginning of comments.
@@ -559,19 +547,27 @@ Differs from mode-specific comment regexps in that surrounding
 whitespace is stripped.
 
 If not bound, hideshow will use current `comment-start' value without
-any surrounding whitespace.")
+any trailing whitespace.")
 
-(defvar-local hs-forward-sexp-func nil
+(define-obsolete-variable-alias
+  'hs-forward-sexp-func
+  'hs-forward-sexp-function
+  "31.1")
+
+(defvar-local hs-forward-sexp-function #'forward-sexp
   "Function used to do a `forward-sexp'.
 Should change for Algol-ish modes.  For single-character block
 delimiters -- ie, the syntax table regexp for the character is
-either `(' or `)' -- `hs-forward-sexp-func' would just be
+either `(' or `)' -- `hs-forward-sexp-function' would just be
 `forward-sexp'.  For other modes such as simula, a more specialized
-function is necessary.
+function is necessary.")
 
-If not bound, this will be set to `forward-sexp'.")
+(define-obsolete-variable-alias
+  'hs-adjust-block-beginning
+  'hs-adjust-block-beginning-function
+  "31.1")
 
-(defvar-local hs-adjust-block-beginning nil
+(defvar-local hs-adjust-block-beginning-function nil
   "Function used to tweak the block beginning.
 The block is hidden from the position returned by this function,
 as opposed to hiding it from the position returned when searching
@@ -589,33 +585,37 @@ It should return the position from where we should start hiding.
 
 It should not move the point.
 
-See `hs-c-like-adjust-block-beginning' for an example of using this.
-
-If not bound, this will be set to nil.")
+See `hs-c-like-adjust-block-beginning' for an example of using this.")
 
-(defvar-local hs-adjust-block-end nil
+(defvar-local hs-adjust-block-end-function nil
   "Function used to tweak the block end.
 This is useful to ensure some characters such as parenthesis or curly
 braces get properly hidden in python-like modes.
 
 It is called with one argument, which is the start position where the
 overlay will be created, and should return either the last position to
-hide or nil.  If it returns nil, hideshow will guess the end position.
+hide or nil.  If it returns nil, hideshow will guess the end position.")
 
-If not bound, this will be set to nil.")
+(define-obsolete-variable-alias
+  'hs-find-block-beginning-func
+  'hs-find-block-beginning-function
+  "31.1")
 
-(defvar-local hs-find-block-beginning-func nil
+(defvar-local hs-find-block-beginning-function #'hs-find-block-beginning
   "Function used to do `hs-find-block-beginning'.
 It should reposition point at the beginning of the current block
 and return point, or nil if original point was not in a block.
 
 Specifying this function is necessary for languages such as
 Python, where regexp search and `syntax-ppss' check is not enough
-to find the beginning of the current block.
+to find the beginning of the current block.")
 
-If not bound, this will be set to `hs-find-block-beginning'.")
+(define-obsolete-variable-alias
+  'hs-find-next-block-func
+  'hs-find-next-block-function
+  "31.1")
 
-(defvar-local hs-find-next-block-func nil
+(defvar-local hs-find-next-block-function #'hs-find-next-block
   "Function used to do `hs-find-next-block'.
 It should reposition point at next block start.
 
@@ -629,21 +629,22 @@ this case, the function should find nearest block or comment.
 
 Specifying this function is necessary for languages such as
 Python, where regexp search is not enough to find the beginning
-of the next block.
+of the next block.")
 
-If not bound, this will be set to `hs-find-next-block'.")
+(define-obsolete-variable-alias
+  'hs-looking-at-block-start-p-func
+  'hs-looking-at-block-start-predicate
+  "31.1")
 
-(defvar-local hs-looking-at-block-start-p-func nil
+(defvar-local hs-looking-at-block-start-predicate #'hs-looking-at-block-start-p
   "Function used to do `hs-looking-at-block-start-p'.
 It should return non-nil if the point is at the block start.
 
 Specifying this function is necessary for languages such as
 Python, where `looking-at' and `syntax-ppss' check is not enough
-to check if the point is at the block start.
-
-If not bound, this will be set to `hs-looking-at-block-start-p'.")
+to check if the point is at the block start.")
 
-(defvar-local hs-inside-comment-p-func nil
+(defvar-local hs-inside-comment-predicate #'hs-inside-comment-p--default
   "Function used to check if point is inside a comment.
 If point is inside a comment, the function should return a list
 containing the buffer position of the start and the end of the
@@ -652,16 +653,12 @@ comment, otherwise it should return nil.
 A comment block can be hidden only if on its starting line there is only
 whitespace preceding the actual comment beginning.  If point is inside
 a comment but this condition is not met, the function can return a list
-having nil as its `car' and the end of comment position as its `cdr'.
+having nil as its `car' and the end of comment position as its `cdr'.")
 
-If not bound, this will be set to `hs-inside-comment-p--default'.")
-
-(defvar-local hs-treesit-things nil
+(defvar-local hs-treesit-things 'list
   "Treesit things to check if point is at a valid block.
 The value should be a thing defined in `treesit-thing-settings' for the
-current buffer's major mode.
-
-If not bound, this will be set to \\='list.")
+current buffer's major mode.")
 
 ;;---------------------------------------------------------------------------
 ;; support functions
@@ -686,9 +683,7 @@ Skip \"internal\" overlays if `hs-allow-nesting' is non-nil."
   "Return t if region in BEG and END can be hidden."
   ;; Check if BEG and END are not in the same line number,
   ;; since using `count-lines' is slow.
-  (save-excursion
-    (let ((pos2 (progn (goto-char end) (line-beginning-position))))
-      (< beg pos2))))
+  (< beg (save-excursion (goto-char end) (line-beginning-position))))
 
 (defun hs-make-overlay (b e kind &optional b-offset e-offset)
   "Return a new overlay in region defined by B and E with type KIND.
@@ -736,15 +731,15 @@ positions.  This does nothing if there is not a code block at current
 point."
   (save-match-data
     (save-excursion
-      (when (funcall hs-looking-at-block-start-p-func)
+      (when (funcall hs-looking-at-block-start-predicate)
         (let ((mdata (match-data t))
               (header-end (match-end 0))
               block-beg block-end)
           ;; `block-start' is the point at the end of the block
           ;; beginning, which may need to be adjusted
           (save-excursion
-            (when hs-adjust-block-beginning
-              (goto-char (funcall hs-adjust-block-beginning header-end)))
+            (when hs-adjust-block-beginning-function
+              (goto-char (funcall hs-adjust-block-beginning-function header-end)))
             (setq block-beg (line-end-position)))
           ;; `block-end' is the point at the end of the block
           (hs-forward-sexp mdata 1)
@@ -757,9 +752,9 @@ point."
                        (match-beginning 0))
                       (t (point))))
           ;; adjust block end (if needed)
-          (when hs-adjust-block-end
+          (when hs-adjust-block-end-function
             (setq block-end
-                  (or (funcall hs-adjust-block-end block-beg)
+                  (or (funcall hs-adjust-block-end-function block-beg)
                       block-end)))
           (cons block-beg block-end))))))
 
@@ -815,11 +810,11 @@ point."
   (goto-char beg)
   (remove-overlays beg end 'hs-indicator t)
 
-  (while (funcall hs-find-next-block-func hs-block-start-regexp end nil)
+  (while (funcall hs-find-next-block-function hs-block-start-regexp end nil)
     (when-let* ((b-beg (match-beginning 0))
                 (_ (save-excursion
                      (goto-char b-beg)
-                     (funcall hs-looking-at-block-start-p-func)))
+                     (funcall hs-looking-at-block-start-predicate)))
                 ;; `catch' is used here if the search fail due
                 ;; unbalanced parenthesis or any other unknown error
                 ;; caused in `hs-forward-sexp'.
@@ -827,7 +822,7 @@ point."
                          (save-excursion
                            (goto-char b-beg)
                            (condition-case _
-                               (funcall hs-forward-sexp-func 1)
+                               (funcall hs-forward-sexp-function 1)
                              (scan-error (throw 'hs-indicator-error nil)))
                            (point))))
                 ;; Check if block is longer than 1 line.
@@ -922,12 +917,12 @@ property of an overlay."
        (save-match-data (not (nth 8 (syntax-ppss))))))
 
 (defun hs-forward-sexp (match-data arg)
-  "Adjust point based on MATCH-DATA and call `hs-forward-sexp-func' with ARG.
+  "Adjust point based on MATCH-DATA and call `hs-forward-sexp-function' with ARG.
 Original match data is restored upon return."
   (save-match-data
     (set-match-data match-data)
     (goto-char (match-beginning hs-block-start-mdata-select))
-    (funcall hs-forward-sexp-func arg)))
+    (funcall hs-forward-sexp-function arg)))
 
 (defun hs-hide-comment-region (beg end &optional repos-end)
   "Hide a region from BEG to END, marking it as a comment.
@@ -947,7 +942,7 @@ Optional arg COMMENT-REG is a list of the form (BEGIN END) and
 specifies the limits of the comment, or nil if the block is not
 a comment.
 
-The block beginning is adjusted by `hs-adjust-block-beginning'
+The block beginning is adjusted by `hs-adjust-block-beginning-function'
 and then further adjusted to be at the end of the line.
 
 If hidding the block is successful, return non-nil.
@@ -969,6 +964,10 @@ Otherwise, return nil."
           (goto-char (if end q (min p (match-end 0))))
           nil)))))
 
+(defun hs-inside-comment-p ()
+  (declare (obsolete "Call `hs-inside-comment-predicate' instead." "31.1"))
+  (funcall hs-inside-comment-predicate))
+
 (defun hs-inside-comment-p--default ()
   (save-excursion
     ;; the idea is to look backwards for a comment start regexp, do a
@@ -1020,17 +1019,28 @@ Otherwise, return nil."
           (when (>= (point) q)
             (list (and hideable p) (point))))))))
 
-(defun hs--get-mode-value (var default &optional old-nth)
-  "Get VAR value for current major mode in `hs-special-modes-alist'.
-DEFAULT is a value to use as fallback.
-OLD-NTH is only used for backward compatibility with
-`hs-special-modes-alist'."
-  (if (local-variable-p var)
-      (symbol-value var)
+(defun hs--set-variable (var old-nth &optional default)
+  "Set Hideshow VAR if already not set.
+This function is meant to be used for backward compatibility with
+`hs-special-modes-alist'.
+
+OLD-NTH is a number indicating NTH element of `hs-special-modes-alist'.
+
+DEFAULT is a value to use as fallback."
+  (unless (local-variable-p var) ; Already set, nothing to do.
     (if-let* (old-nth
               (old-lookup (assoc major-mode hs-special-modes-alist)))
-        (nth old-nth old-lookup)
-      default)))
+        (set (make-local-variable var)
+             (if (integerp old-nth)
+                 (nth old-nth old-lookup)
+               (funcall old-nth old-lookup)))
+      (when default
+        (set (make-local-variable var) default)))))
+
+;; TODO: When `hs-special-modes-alist' is removed, `hs-grok-mode-type'
+;; and `hs--set-variable' will no longer be necessary, but
+;; `hs-c-start-regexp' will still have to be set manually after enabling
+;; `hs-minor-mode'.
 
 (defun hs-grok-mode-type ()
   "Set up hideshow variables for new buffers.
@@ -1038,71 +1048,16 @@ If `hs-special-modes-alist' has information associated with the current
 buffer's major mode, use that.  Otherwise, guess start, end and
 `comment-start' regexps; `forward-sexp' function; and
 adjust-block-beginning function."
-  (if (and (bound-and-true-p comment-start)
-           (bound-and-true-p comment-end))
-      (let ((start-elem (cadr (assoc major-mode hs-special-modes-alist))))
-        ;; If some these variables are already set, use them instead.
-        (setq
-         ;; handle (START-REGEXP MDATA-SELECT) and simple START-REGEXP
-         ;; TEMP: At the moment, we cannot use `hs--get-mode-value'
-         ;; here.
-         hs-block-start-regexp
-         (if (local-variable-p 'hs-block-start-regexp)
-             hs-block-start-regexp
-           (or (car start-elem) "\\s("))
-
-         hs-block-start-mdata-select
-         (if (local-variable-p 'hs-block-start-mdata-select)
-             hs-block-start-mdata-select
-           (or (cadr start-elem) 0))
-
-         hs-block-end-regexp
-         (hs--get-mode-value 'hs-block-end-regexp "\\s)" 2)
-
-         hs-c-start-regexp
-         (hs--get-mode-value
-          'hs-c-start-regexp
-          (let ((c-start-regexp
-                 (regexp-quote comment-start)))
-            (if (string-match " +$" c-start-regexp)
-                (substring c-start-regexp
-                           0 (1- (match-end 0)))
-              c-start-regexp))
-          3)
-
-         hs-forward-sexp-func
-         (hs--get-mode-value 'hs-forward-sexp-func #'forward-sexp 4)
-
-         hs-adjust-block-beginning
-         (hs--get-mode-value 'hs-adjust-block-beginning nil 5)
-
-         hs-adjust-block-end
-         (hs--get-mode-value 'hs-adjust-block-end nil)
-
-         hs-find-block-beginning-func
-         (hs--get-mode-value 'hs-find-block-beginning-func
-                             #'hs-find-block-beginning
-                             6)
-
-         hs-find-next-block-func
-         (hs--get-mode-value 'hs-find-next-block-func
-                             #'hs-find-next-block
-                             7)
-
-         hs-looking-at-block-start-p-func
-         (hs--get-mode-value 'hs-looking-at-block-start-p-func
-                             #'hs-looking-at-block-start-p
-                             8)
-
-         hs-inside-comment-p-func
-         (hs--get-mode-value 'hs-inside-comment-p-func
-                             #'hs-inside-comment-p--default)
-
-         hs-treesit-things
-         (hs--get-mode-value 'hs-treesit-things 'list)))
-
-    (setq hs-minor-mode nil)
-    (error "%S doesn't support Hideshow Minor Mode" major-mode)))
+  (hs--set-variable 'hs-block-start-regexp #'caadr)
+  (hs--set-variable 'hs-block-start-mdata-select #'cadadr)
+  (hs--set-variable 'hs-block-end-regexp 2)
+  (hs--set-variable 'hs-c-start-regexp 3
+                    (string-trim-right (regexp-quote comment-start)))
+  (hs--set-variable 'hs-forward-sexp-function 4)
+  (hs--set-variable 'hs-adjust-block-beginning-function 5)
+  (hs--set-variable 'hs-find-block-beginning-function 6)
+  (hs--set-variable 'hs-find-next-block-function 7)
+  (hs--set-variable 'hs-looking-at-block-start-predicate 8))
 
 (defun hs-find-block-beginning ()
   "Reposition point at block-start.
@@ -1110,7 +1065,7 @@ Return point, or nil if original point was not in a block."
   (let ((done nil)
         (here (point)))
     ;; look if current line is block start
-    (if (funcall hs-looking-at-block-start-p-func)
+    (if (funcall hs-looking-at-block-start-predicate)
         (point)
       ;; look backward for the start of a block that contains the cursor
       (while (and (re-search-backward hs-block-start-regexp nil t)
@@ -1136,14 +1091,14 @@ region (point MAXP)."
 
 (defun hs-hide-level-recursive (arg minp maxp)
   "Recursively hide blocks ARG levels below point in region (MINP MAXP)."
-  (when (funcall hs-find-block-beginning-func)
+  (when (funcall hs-find-block-beginning-function)
     (setq minp (1+ (point)))
-    (funcall hs-forward-sexp-func 1)
+    (funcall hs-forward-sexp-function 1)
     (setq maxp (1- (point))))
   (unless hs-allow-nesting
     (hs-discard-overlays minp maxp))
   (goto-char minp)
-  (while (funcall hs-find-next-block-func hs-block-start-regexp maxp nil)
+  (while (funcall hs-find-next-block-function hs-block-start-regexp maxp nil)
     (when (save-match-data
 	    (not (nth 8 (syntax-ppss)))) ; not inside comments or strings
       (if (> arg 1)
@@ -1164,8 +1119,8 @@ In the dynamic context of this macro, `case-fold-search' is t."
 (defun hs-find-block-beginning-match ()
   "Reposition point at the end of match of the block-start regexp.
 Return point, or nil if original point was not in a block."
-  (when (and (funcall hs-find-block-beginning-func)
-	     (funcall hs-looking-at-block-start-p-func))
+  (when (and (funcall hs-find-block-beginning-function)
+	     (funcall hs-looking-at-block-start-predicate))
     ;; point is inside a block
     (goto-char (match-end 0))))
 
@@ -1181,7 +1136,7 @@ Return point, or nil if original point was not in a block."
 (defun hs-already-hidden-p ()
   "Return non-nil if point is in an already-hidden block, otherwise nil."
   (save-excursion
-    (let ((c-reg (funcall hs-inside-comment-p-func)))
+    (let ((c-reg (funcall hs-inside-comment-predicate)))
       (if (and c-reg (nth 0 c-reg))
           ;; point is inside a comment, and that comment is hideable
           (goto-char (nth 0 c-reg))
@@ -1200,7 +1155,7 @@ Return point, or nil if original point was not in a block."
   "Adjust INITIAL, the buffer position after `hs-block-start-regexp'.
 Actually, point is never moved; a new position is returned that is
 the end of the C-function header.  This adjustment function is meant
-to be assigned to `hs-adjust-block-beginning' for C-like modes."
+to be assigned to `hs-adjust-block-beginning-function' for C-like modes."
   (save-excursion
     (goto-char (1- initial))
     (forward-comment (- (buffer-size)))
@@ -1233,7 +1188,7 @@ If `hs-hide-comments-when-hiding-all' is non-nil, also hide the comments."
                                      hs-c-start-regexp
                                      "\\)")
                            "")))))
-       (while (funcall hs-find-next-block-func re (point-max)
+       (while (funcall hs-find-next-block-function re (point-max)
                        hs-hide-comments-when-hiding-all)
          (if (match-beginning 1)
              ;; We have found a block beginning.
@@ -1249,7 +1204,7 @@ If `hs-hide-comments-when-hiding-all' is non-nil, also hide the comments."
                          (eq (point) (match-beginning 0)))
 		   (goto-char (match-end 0)))))
            ;; found a comment, probably
-           (let ((c-reg (funcall hs-inside-comment-p-func)))
+           (let ((c-reg (funcall hs-inside-comment-predicate)))
              (when (and c-reg (car c-reg))
                (if (hs-hideable-region-p (car c-reg) (nth 1 c-reg))
                    (hs-hide-block-at-point t c-reg)
@@ -1275,7 +1230,7 @@ Upon completion, point is repositioned and the normal hook
 `hs-hide-hook' is run.  See documentation for `run-hooks'."
   (interactive "P")
   (hs-life-goes-on
-   (let ((c-reg (funcall hs-inside-comment-p-func)))
+   (let ((c-reg (funcall hs-inside-comment-predicate)))
      (cond
       ((and c-reg (or (null (nth 0 c-reg))
                       (not (hs-hideable-region-p (car c-reg) (nth 1 c-reg)))))
@@ -1286,18 +1241,18 @@ Upon completion, point is repositioned and the normal hook
       ((or (and (eq hs-hide-block-behavior 'after-bol)
                 (save-excursion
                   (goto-char (line-beginning-position))
-                  (funcall hs-find-next-block-func hs-block-start-regexp
+                  (funcall hs-find-next-block-function hs-block-start-regexp
                            (line-end-position) nil))
                 (goto-char (match-beginning 0)))
-           (funcall hs-looking-at-block-start-p-func))
+           (funcall hs-looking-at-block-start-predicate))
        ;; If hidding the block fails (due the block is not hideable)
        ;; Then just hide the parent block (if possible)
        (unless (save-excursion (hs-hide-block-at-point end))
          (goto-char (1- (point)))
-         (funcall hs-find-block-beginning-func)
+         (funcall hs-find-block-beginning-function)
          (hs-hide-block-at-point end)))
 
-      ((funcall hs-find-block-beginning-func)
+      ((funcall hs-find-block-beginning-function)
        (hs-hide-block-at-point end)))
 
      (run-hooks 'hs-hide-hook))))
@@ -1325,15 +1280,15 @@ See documentation for functions `hs-hide-block' and `run-hooks'."
         (hs--refresh-indicators ov-start ov-end)
         t))
     ;; not immediately obvious, look for a suitable block
-    (let ((c-reg (funcall hs-inside-comment-p-func))
+    (let ((c-reg (funcall hs-inside-comment-predicate))
           p q)
       (cond (c-reg
              (when (car c-reg)
                (setq p (car c-reg)
                      q (cadr c-reg))))
-            ((and (funcall hs-find-block-beginning-func)
+            ((and (funcall hs-find-block-beginning-function)
                   ;; ugh, fresh match-data
-                  (funcall hs-looking-at-block-start-p-func))
+                  (funcall hs-looking-at-block-start-predicate))
              (setq p (point)
                    q (progn (hs-forward-sexp (match-data t) 1) (point)))))
       (when (and p q)
@@ -1389,7 +1344,7 @@ This can be useful if you have huge RCS logs in those comments."
    (let ((c-reg (save-excursion
                   (goto-char (point-min))
                   (skip-chars-forward " \t\n\f")
-                  (funcall hs-inside-comment-p-func))))
+                  (funcall hs-inside-comment-predicate))))
      (when c-reg
        (let ((beg (car c-reg)) (end (cadr c-reg)))
          ;; see if we have enough comment lines to hide
@@ -1419,6 +1374,11 @@ Key bindings:
   :lighter " hs"
   :keymap hs-minor-mode-map
   (setq hs-headline nil)
+
+  (unless (and comment-start comment-end)
+    (setq hs-minor-mode nil)
+    (user-error "%S doesn't support Hideshow Minor Mode" major-mode))
+
   (if hs-minor-mode
       (progn
         ;; Set the variables
diff --git a/lisp/progmodes/icon.el b/lisp/progmodes/icon.el
index fac7a92a5f5..ebd27bc54b6 100644
--- a/lisp/progmodes/icon.el
+++ b/lisp/progmodes/icon.el
@@ -169,7 +169,7 @@ with no args, if that value is non-nil."
   ;; hideshow support
   (setq-local hs-block-start-regexp "\\<procedure\\>")
   (setq-local hs-block-end-regexp "\\<end\\>")
-  (setq-local hs-forward-sexp-func #'icon-forward-sexp-function))
+  (setq-local hs-forward-sexp-function #'icon-forward-sexp-function))
 
 ;; This is used by indent-for-comment to decide how much to
 ;; indent a comment in Icon code based on its context.
diff --git a/lisp/progmodes/lua-mode.el b/lisp/progmodes/lua-mode.el
index ac71950988f..8f59e32e586 100644
--- a/lisp/progmodes/lua-mode.el
+++ b/lisp/progmodes/lua-mode.el
@@ -555,7 +555,7 @@ See `imenu-generic-expression'.")
   ;; Hide-show setup
   (setq-local hs-block-start-regexp (regexp-opt (mapcar 'car lua-sexp-alist) 'words))
   (setq-local hs-block-end-regexp (regexp-opt (mapcar 'cdr lua-sexp-alist) 'words))
-  (setq-local hs-forward-sexp-func #'lua-forward-sexp))
+  (setq-local hs-forward-sexp-function #'lua-forward-sexp))
 
 ;;;###autoload
 (add-to-list 'auto-mode-alist '("\\.lua\\'" . lua-mode))
diff --git a/lisp/progmodes/python.el b/lisp/progmodes/python.el
index f34fb28826f..12557aecf4d 100644
--- a/lisp/progmodes/python.el
+++ b/lisp/progmodes/python.el
@@ -5913,7 +5913,7 @@ are also searched.  REGEXP is passed to `looking-at' to set
         (looking-at regexp)))))
 
 (defun python-ts-hs-adjust-block-end-fn (block-beg)
-  "Python-ts-mode specific `hs-adjust-block-end' function for `hs-minor-mode'.
+  "Python-ts-mode specific `hs-adjust-block-end-function' function.
 
 BLOCK-BEG is the beginning position where the hiding will be performed.
 
@@ -7360,10 +7360,10 @@ implementations: `python-mode' and `python-ts-mode'."
   ;; "\\s)".  This way parens at end of defun are properly hidden.
   (setq-local hs-block-end-regexp "")
   (setq-local hs-c-start-regexp "#")
-  (setq-local hs-forward-sexp-func #'python-hideshow-forward-sexp-function)
-  (setq-local hs-find-block-beginning-func #'python-nav-beginning-of-block)
-  (setq-local hs-find-next-block-func #'python-hideshow-find-next-block)
-  (setq-local hs-looking-at-block-start-p-func #'python-info-looking-at-beginning-of-block)
+  (setq-local hs-forward-sexp-function #'python-hideshow-forward-sexp-function)
+  (setq-local hs-find-block-beginning-function #'python-nav-beginning-of-block)
+  (setq-local hs-find-next-block-function #'python-hideshow-find-next-block)
+  (setq-local hs-looking-at-block-start-predicate #'python-info-looking-at-beginning-of-block)
 
   (setq-local outline-regexp (python-rx (* space) block-start))
   (setq-local outline-level
@@ -7438,7 +7438,7 @@ implementations: `python-mode' and `python-ts-mode'."
                 treesit-sexp-thing 'sexp)
 
     (setq-local hs-treesit-things '(or defun sexp))
-    (setq-local hs-adjust-block-end #'python-ts-hs-adjust-block-end-fn)
+    (setq-local hs-adjust-block-end-function #'python-ts-hs-adjust-block-end-fn)
 
     (setq-local syntax-propertize-function #'python--treesit-syntax-propertize)
 
diff --git a/lisp/progmodes/verilog-mode.el b/lisp/progmodes/verilog-mode.el
index 09a3ec56899..79b75c24db5 100644
--- a/lisp/progmodes/verilog-mode.el
+++ b/lisp/progmodes/verilog-mode.el
@@ -4365,7 +4365,7 @@ Key bindings specific to `verilog-mode-map' are:
   ;; hideshow support
   (setq-local hs-block-start-regexp "\\<begin\\>")
   (setq-local hs-block-end-regexp "\\<end\\>")
-  (setq-local hs-forward-sexp-func #'verilog-forward-sexp-function)
+  (setq-local hs-forward-sexp-function #'verilog-forward-sexp-function)
 
   (add-hook 'completion-at-point-functions
             #'verilog-completion-at-point nil 'local)
diff --git a/lisp/progmodes/vhdl-mode.el b/lisp/progmodes/vhdl-mode.el
index 969ac78833a..9b12e084726 100644
--- a/lisp/progmodes/vhdl-mode.el
+++ b/lisp/progmodes/vhdl-mode.el
@@ -13284,7 +13284,7 @@ File statistics: \"%s\"\n\
     ;; initialize hideshow
     (setq-local hs-block-start-regexp vhdl-hs-start-regexp)
     (setq-local hs-c-start-regexp "--\\( \\|$\\)")
-    (setq-local hs-forward-sexp-func #'vhdl-hs-forward-sexp-func)
+    (setq-local hs-forward-sexp-function #'vhdl-hs-forward-sexp-func)
     (if (featurep 'xemacs) (make-local-hook 'hs-minor-mode-hook))
     (if vhdl-hide-all-init
 	(add-hook 'hs-minor-mode-hook #'hs-hide-all nil t)
diff --git a/lisp/textmodes/mhtml-mode.el b/lisp/textmodes/mhtml-mode.el
index e4fe383e149..6fc1c7c49fd 100644
--- a/lisp/textmodes/mhtml-mode.el
+++ b/lisp/textmodes/mhtml-mode.el
@@ -306,7 +306,7 @@ This is used by `mhtml--pre-command'.")
         (flyspell-generic-progmode-verify)
       t)))
 
-;; Support for hideshow.el (see `hs-forward-sexp-func').
+;; Support for hideshow.el (see `hs-forward-sexp-function').
 (defun mhtml-forward (arg)
   "Move point forward past a structured expression.
 If point is on a tag, move to the end of the tag.
@@ -331,7 +331,7 @@ the rules from `css-mode'."
               #'mhtml--submode-fontify-region)
   (setq-local hs-block-start-regexp "{\\|<[^/>]*?")
   (setq-local hs-block-end-regexp "}\\|</[^/>]*[^/]>")
-  (setq-local hs-forward-sexp-func #'mhtml-forward)
+  (setq-local hs-forward-sexp-function #'mhtml-forward)
 
   ;; Attach this to both pre- and post- hooks just in case it ever
   ;; changes a key binding that might be accessed from the menu bar.
diff --git a/lisp/textmodes/sgml-mode.el b/lisp/textmodes/sgml-mode.el
index 1044bba42e7..aec49d83a73 100644
--- a/lisp/textmodes/sgml-mode.el
+++ b/lisp/textmodes/sgml-mode.el
@@ -671,7 +671,7 @@ Do \\[describe-key] on the following bindings to discover what they do.
   (setq-local hs-block-start-regexp "<[^/>]*?")
   (setq-local hs-block-end-regexp "</[^/>]*[^/]>")
   (setq-local hs-c-start-regexp "<!--")
-  (setq-local hs-forward-sexp-func #'sgml-skip-tag-forward))
+  (setq-local hs-forward-sexp-function #'sgml-skip-tag-forward))
 
 (defun sgml-comment-indent ()
   (if (looking-at "--") comment-column 0))
diff --git a/lisp/treesit.el b/lisp/treesit.el
index 360b74f2a47..e365fc218dd 100644
--- a/lisp/treesit.el
+++ b/lisp/treesit.el
@@ -4261,7 +4261,7 @@ For BOUND, MOVE, BACKWARD, LOOKING-AT, see the descriptions in
       t)))
 
 (defun treesit-hs-find-block-beginning ()
-  "Tree-sitter implementation of `hs-find-block-beginning-func'."
+  "Tree-sitter implementation of `hs-find-block-beginning-function'."
   (let* ((pred (bound-and-true-p hs-treesit-things))
          (thing (treesit-thing-at (point) pred))
          (beg (when thing (treesit-node-start thing)))
@@ -4272,7 +4272,7 @@ For BOUND, MOVE, BACKWARD, LOOKING-AT, see the descriptions in
       t)))
 
 (defun treesit-hs-find-next-block (_regexp maxp comments)
-  "Tree-sitter implementation of `hs-find-next-block-func'."
+  "Tree-sitter implementation of `hs-find-next-block-function'."
   (when (not comments)
     (forward-comment (point-max)))
   (let* ((comment-pred
@@ -4301,7 +4301,7 @@ For BOUND, MOVE, BACKWARD, LOOKING-AT, see the descriptions in
       t)))
 
 (defun treesit-hs-looking-at-block-start-p ()
-  "Tree-sitter implementation of `hs-looking-at-block-start-p-func'."
+  "Tree-sitter implementation of `hs-looking-at-block-start-predicate'."
   (let* ((pred (bound-and-true-p hs-treesit-things))
          (thing (treesit-thing-at (point) pred))
          (beg (when thing (treesit-node-start thing)))
@@ -4311,7 +4311,7 @@ For BOUND, MOVE, BACKWARD, LOOKING-AT, see the descriptions in
       t)))
 
 (defun treesit-hs-inside-comment-p ()
-  "Tree-sitter implementation of `hs-inside-comment-p-func'."
+  "Tree-sitter implementation of `hs-inside-comment-predicate'."
   (let* ((comment-pred
           (if (treesit-thing-defined-p 'comment (treesit-language-at (point)))
               'comment "\\`comment\\'"))
@@ -4515,11 +4515,11 @@ before calling this function."
     (setq-local hs-c-start-regexp nil
                 hs-block-start-regexp nil
                 hs-block-end-regexp #'treesit-hs-block-end
-                hs-forward-sexp-func #'forward-list
-                hs-find-block-beginning-func #'treesit-hs-find-block-beginning
-                hs-find-next-block-func #'treesit-hs-find-next-block
-                hs-looking-at-block-start-p-func #'treesit-hs-looking-at-block-start-p
-                hs-inside-comment-p-func #'treesit-hs-inside-comment-p))
+                hs-forward-sexp-function #'forward-list
+                hs-find-block-beginning-function #'treesit-hs-find-block-beginning
+                hs-find-next-block-function #'treesit-hs-find-next-block
+                hs-looking-at-block-start-predicate #'treesit-hs-looking-at-block-start-p
+                hs-inside-comment-predicate #'treesit-hs-inside-comment-p))
 
   (when (treesit-thing-defined-p 'sentence nil)
     (setq-local forward-sentence-function #'treesit-forward-sentence))

commit 5d11ee9f54a2795f648d6daa5321866dfec37bac
Author: Steven Allen <steven@stebalien.com>
Date:   Sun Sep 21 12:36:33 2025 -0700

    Lookup cached basic-auth credentials with the correct key
    
    Credentials cached in 'url-basic-auth-storage' are keyed by
    "server:port", but were being looked up by just "server" in
    'url-basic-auth'.
    * lisp/url/url-auth.el (url-basic-auth): Lookup cached basic auth
    credentials by "server:port".  (Bug#79486)
    
    * test/lisp/url/url-auth-tests.el (url-auth-test-auth-retrieve-cache):
    Check the digest auth test-cases cache retrieval test cases against the
    basic auth logic.

diff --git a/lisp/url/url-auth.el b/lisp/url/url-auth.el
index c07f7b4397a..bd805413639 100644
--- a/lisp/url/url-auth.el
+++ b/lisp/url/url-auth.el
@@ -71,13 +71,14 @@ instead of the filename inheritance method."
 	 (user (url-user href))
 	 (pass (url-password href))
 	 (enable-recursive-minibuffers t) ; for url-handler-mode (bug#10298)
+	 (serverport (format "%s:%d" server port))
 	 byserv retval data)
     (setq file (cond
 		(realm realm)
 		((string= "" file) "/")
 		((string-match "/$" file) file)
 		(t (url-file-directory file)))
-	  byserv (cdr-safe (assoc server
+	  byserv (cdr-safe (assoc serverport
 				  (symbol-value url-basic-auth-storage))))
     (cond
      ((and user pass)
@@ -93,9 +94,8 @@ instead of the filename inheritance method."
 		  (url-do-auth-source-search server type :secret user)
                   (and (url-interactive-p)
 		       (read-passwd "Password: " nil (or pass "")))))
-      (setq server (format "%s:%d" server port))
       (set url-basic-auth-storage
-	   (cons (list server
+	   (cons (list serverport
 		       (cons file
 			     (setq retval
 				   (base64-encode-string
@@ -129,9 +129,8 @@ instead of the filename inheritance method."
 			(url-do-auth-source-search server type :secret user)
                         (and (url-interactive-p)
 			     (read-passwd "Password: ")))
-                  server (format "%s:%d" server port)
 		  retval (base64-encode-string (format "%s:%s" user pass) t)
-		  byserv (assoc server (symbol-value url-basic-auth-storage)))
+		  byserv (assoc serverport (symbol-value url-basic-auth-storage)))
 	    (setcdr byserv
 		    (cons (cons file retval) (cdr byserv))))))
      (t (setq retval nil)))
diff --git a/test/lisp/url/url-auth-tests.el b/test/lisp/url/url-auth-tests.el
index 73ca9dd4c83..51ee587de49 100644
--- a/test/lisp/url/url-auth-tests.el
+++ b/test/lisp/url/url-auth-tests.el
@@ -27,6 +27,7 @@
 
 (require 'ert)
 (require 'url-auth)
+(require 'url-http)
 
 (defvar url-auth-test-challenges nil
   "List of challenges for testing.
@@ -133,8 +134,8 @@ server's WWW-Authenticate header field.")
       (should (string= (nth 1 key) (plist-get challenge :expected-ha2)))
       )))
 
-(ert-deftest url-auth-test-digest-auth-retrieve-cache ()
-  "Check how the entry point retrieves cached authentication.
+(ert-deftest url-auth-test-auth-retrieve-cache ()
+  "Check how the basic/digest auth entry point retrieves cached authentication.
 Essential is how realms and paths are matched."
 
   (let* ((url-digest-auth-storage
@@ -150,6 +151,14 @@ Essential is how realms and paths are matched."
             ("rootless.org:80"          ; no "/" entry for this on purpose
              ("/path" "pathuser" "key")
              ("realm" "realmuser" "key"))))
+         (url-http-real-basic-auth-storage
+          (mapcar (pcase-lambda (`(,server . ,auths))
+                    (cons server
+                          (mapcar (pcase-lambda (`(,realm ,user ,secret))
+                                    (cons realm (base64-encode-string
+                                                 (format "%s:%s" user secret) t)))
+                                  auths)))
+                  url-digest-auth-storage))
          (attrs (list (cons "nonce" "servernonce")))
          auth)
 
@@ -215,6 +224,7 @@ Essential is how realms and paths are matched."
                   (list :url "http://rootless.org/path/query?q=a"
                         :realm "realm" :expected-user "realmuser")
                   ))
+      ;; Check digest auth.
       (setq auth (url-digest-auth (plist-get row :url)
                                   nil nil
                                   (plist-get row :realm) attrs))
@@ -223,6 +233,19 @@ Essential is how realms and paths are matched."
                  (should (string-match ".*username=\"\\(.*?\\)\".*" auth))
                  (should (string= (match-string 1 auth)
                                   (plist-get row :expected-user))))
+        (should-not auth))
+      ;; Check basic auth.
+      (setq auth (url-basic-auth (plist-get row :url)
+                                  nil nil
+                                  (plist-get row :realm) attrs))
+      (if (plist-get row :expected-user)
+          (progn (should auth)
+                 (should (string-prefix-p "Basic " auth))
+                 (setq auth (base64-decode-string
+                             (string-remove-prefix "Basic " auth) t))
+                 (should (string-match "\\`\\(.*?\\):key\\'" auth))
+                 (should (string= (match-string 1 auth)
+                                  (plist-get row :expected-user))))
         (should-not auth)))))
 
 (ert-deftest url-auth-test-digest-auth ()

commit 19ee1288454ff8e55599e4a17274dca498a2ff71
Author: Alexander Kuleshov <kuleshovmail@gmail.com>
Date:   Sat Nov 8 21:14:20 2025 +0500

    * lisp/progmodes/ld-script.el: Add 'PT_TLS' to 'ld-script-keywords'.

diff --git a/lisp/progmodes/ld-script.el b/lisp/progmodes/ld-script.el
index 319b886dd48..396c2bc6a59 100644
--- a/lisp/progmodes/ld-script.el
+++ b/lisp/progmodes/ld-script.el
@@ -121,6 +121,7 @@
     ;; 3.8 PHDRS Command
     "PHDRS" "FILEHDR" "FLAGS"
     "PT_NULL" "PT_LOAD" "PT_DYNAMIC" "PT_INTERP" "PT_NOTE" "PT_SHLIB" "PT_PHDR"
+    "PT_TLS"
     ;; 3.9 VERSION Command
     "VERSION")
   "Keywords used of GNU ld script.")

commit 69092236f47eaa761dd07f45c6d10fc15a0d0073
Author: David Fussner <dfussner@googlemail.com>
Date:   Thu Oct 30 14:51:05 2025 +0000

    Fix package-vc to install multiple info manuals
    
    * lisp/emacs-lisp/package-vc.el (package-vc--build-documentation):
      Take the name of the .info file from the name of the source file,
      instead of from the name of the package.

diff --git a/lisp/emacs-lisp/package-vc.el b/lisp/emacs-lisp/package-vc.el
index 8133b45b912..6642522d11e 100644
--- a/lisp/emacs-lisp/package-vc.el
+++ b/lisp/emacs-lisp/package-vc.el
@@ -371,7 +371,7 @@ otherwise it's assumed to be an Info file."
   (let* ((pkg-name (package-desc-name pkg-desc))
          (default-directory (package-desc-dir pkg-desc))
          (docs-directory (file-name-directory (expand-file-name file)))
-         (output (expand-file-name (format "%s.info" pkg-name)))
+         (output (expand-file-name (format "%s.info" (file-name-base file))))
          (log-buffer (get-buffer-create (format " *package-vc doc: %s*" pkg-name)))
          clean-up)
     (with-current-buffer log-buffer

commit 60a13d85fe991a41a38741891348d5b9bf763997
Author: Philip Kaludercic <philipk@posteo.net>
Date:   Sat Nov 8 13:19:21 2025 +0100

    Fix error messages when building docs for VC packages
    
    * lisp/emacs-lisp/package-vc.el (package-vc--build-documentation):
    Use the buffer name of the output buffer instead of the buffer
    name of the current buffer.

diff --git a/lisp/emacs-lisp/package-vc.el b/lisp/emacs-lisp/package-vc.el
index 7433fce2d89..8133b45b912 100644
--- a/lisp/emacs-lisp/package-vc.el
+++ b/lisp/emacs-lisp/package-vc.el
@@ -393,15 +393,16 @@ otherwise it's assumed to be an Info file."
                                 "--no-split" file
                                 "-o" output))
             (message "Failed to build manual %s, see buffer %S"
-                     file (buffer-name)))
+                     file (buffer-name log-buffer)))
            ((/= 0 (call-process "install-info" nil log-buffer nil
                                 output (expand-file-name "dir")))
             (message "Failed to install manual %s, see buffer %S"
-                     output (buffer-name)))
+                     output (buffer-name log-buffer)))
            ((kill-buffer log-buffer))))
       (error (with-current-buffer log-buffer
                (insert (error-message-string err)))
-             (message "Failed to export org manual for %s, see buffer %S" pkg-name log-buffer)))
+             (message "Failed to export org manual for %s, see buffer %S"
+                      pkg-name (buffer-name log-buffer))))
     (when clean-up
       (delete-file file))))
 

commit c35e5a23fe5aa8241b94784f30184f382bc7783d
Author: Philip Kaludercic <philipk@posteo.net>
Date:   Sat Nov 8 00:30:54 2025 +0100

    ; * etc/NEWS: Merge diff sections

diff --git a/etc/NEWS b/etc/NEWS
index 2c4de22a2e6..3b66f4baff2 100644
--- a/etc/NEWS
+++ b/etc/NEWS
@@ -2030,6 +2030,13 @@ They suggest the previous revision as the default for REV1, not the last
 one as before.  This makes them different from 'vc-diff' and
 'vc-root-diff' when those are called without a prefix argument.
 
++++
+*** 'diff-apply-buffer' now considers the region and can reverse-apply.
+If the region is active, this command now applies all hunks that the
+region overlaps; otherwise, it applies all hunks.
+With a prefix argument, it now reverse-applies the hunks.
+This matches the existing prefix argument to 'diff-apply-hunk'.
+
 ** Ediff
 
 +++
@@ -2530,15 +2537,6 @@ View mode, copies to the kill ring the ID of the revision at point in
 the log entry.  If there are marked revisions, it copies the IDs of
 those, instead.
 
-** Diff mode
-
-+++
-*** 'diff-apply-buffer' now considers the region and can reverse-apply.
-If the region is active, this command now applies all hunks that the
-region overlaps; otherwise, it applies all hunks.
-With a prefix argument, it now reverse-applies the hunks.
-This matches the existing prefix argument to 'diff-apply-hunk'.
-
 ** Package
 
 +++

commit 211f0520fcb82dac5c077919c69a21082c9aef91
Author: Philip Kaludercic <philipk@posteo.net>
Date:   Thu Nov 6 23:00:28 2025 +0100

    Allow 'package-upgrade-all' to upgrade built-in packages
    
    * lisp/emacs-lisp/package.el (package-upgrade-all): Respect
    'package-install-upgrade-built-in'.  (Bug#79718)

diff --git a/lisp/emacs-lisp/package.el b/lisp/emacs-lisp/package.el
index c39c8bf24cc..63124706e28 100644
--- a/lisp/emacs-lisp/package.el
+++ b/lisp/emacs-lisp/package.el
@@ -2341,7 +2341,7 @@ from ELPA by either using `\\[package-upgrade]' or
 `\\<package-menu-mode-map>\\[package-menu-mark-install]' after `\\[list-packages]'."
   (interactive (list (not noninteractive)))
   (package-refresh-contents)
-  (let ((upgradeable (package--upgradeable-packages)))
+  (let ((upgradeable (package--upgradeable-packages package-install-upgrade-built-in)))
     (if (not upgradeable)
         (message "No packages to upgrade")
       (when (and query

commit 00524e6e02050475f171ad03664e3700f5753890
Merge: 64fea996f3d a71ba898db8
Author: Eli Zaretskii <eliz@gnu.org>
Date:   Sat Nov 8 07:04:52 2025 -0500

    Merge from origin/emacs-30
    
    a71ba898db8 ; Update the MinGW URLs in w32 FAQ and nt/INSTALL
    e0ffcc655e5 No more color emoji issue on OpenBSD 7.8 and later (bug#7...

commit 64fea996f3d0338bb9ecdf93a42934f1b3dd8c8e
Author: Eli Zaretskii <eliz@gnu.org>
Date:   Sat Nov 8 14:02:44 2025 +0200

    Adapt vc-test-misc to MS-Windows
    
    * test/lisp/vc/vc-tests/vc-test-misc.el (vc-test-exec-after-1)
    (vc-test-exec-after-2, vc-test-exec-after-3)
    (vc-test-exec-after-4, vc-test-exec-after-5): Fix shell commands
    for MS-Windows: use "&" instead of ";" and don't use fractional
    times for 'sleep', as some Windows ports of 'sleep' don't support
    that.

diff --git a/test/lisp/vc/vc-tests/vc-test-misc.el b/test/lisp/vc/vc-tests/vc-test-misc.el
index 33aebbdb895..0bbcefd16fd 100644
--- a/test/lisp/vc/vc-tests/vc-test-misc.el
+++ b/test/lisp/vc/vc-tests/vc-test-misc.el
@@ -76,7 +76,9 @@
   "Test `vc-exec-after' adding a sentinel."
   (with-temp-buffer
     (let ((proc (start-process-shell-command "test" (current-buffer)
-                                             "sleep 0.2; echo hello"))
+                                             (if (eq system-type 'windows-nt)
+                                                 "sleep 1 & echo hello"
+                                               "sleep 0.2; echo hello")))
           success)
       (vc-exec-after (lambda () (setq success t)))
       (should-not (eq (process-sentinel proc)
@@ -88,7 +90,9 @@
   "Test `vc-exec-after' executing the code immediately."
   (with-temp-buffer
     (let ((proc (start-process-shell-command "test" (current-buffer)
-                                             "sleep 0.2; echo hello"))
+                                             (if (eq system-type 'windows-nt)
+                                                 "sleep 1 & echo hello"
+                                               "sleep 0.2; echo hello")))
           success)
       (vc-test--exec-after-wait)
       (vc-exec-after (lambda () (setq success t)))
@@ -100,7 +104,9 @@
   "Test SUCCESS argument to `vc-exec-after'."
   (with-temp-buffer
     (let ((proc (start-process-shell-command "test" (current-buffer)
-                                             "sleep 0.2; echo hello"))
+                                             (if (eq system-type 'windows-nt)
+                                                 "sleep 1 & echo hello"
+                                               "sleep 0.2; echo hello")))
           (passes (start-process "test2" nil "true"))
           success)
       (vc-exec-after (lambda () (setq success t)) passes)
@@ -109,7 +115,9 @@
 
   (with-temp-buffer
     (let ((proc (start-process-shell-command "test" (current-buffer)
-                                             "sleep 0.2; echo hello"))
+                                             (if (eq system-type 'windows-nt)
+                                                 "sleep 1 & echo hello"
+                                               "sleep 0.2; echo hello")))
           (fails (start-process "test2" nil "false"))
           success)
       (vc-exec-after (lambda () (setq success t)) fails)
@@ -120,7 +128,9 @@
   "Test `vc-exec-after' handling the process mark."
   (with-temp-buffer
     (let ((proc (start-process-shell-command "test" (current-buffer)
-                                             "echo hello there; sleep 0.2"))
+                                             (if (eq system-type 'windows-nt)
+                                                 "echo hello there & sleep 1"
+                                               "echo hello there; sleep 0.2")))
           success)
       ;; Disable the default output, which further moves point.
       (set-process-sentinel proc #'ignore)
@@ -140,7 +150,9 @@
   "Test `vc-exec-after' with `vc-sentinel-movepoint' variable."
   (with-temp-buffer
     (let ((proc (start-process-shell-command "test" (current-buffer)
-                                             "echo hello there; sleep 0.2"))
+                                             (if (eq system-type 'windows-nt)
+                                                 "echo hello there & sleep 1"
+                                               "echo hello there; sleep 0.2")))
           success)
       ;; Disable the default output, which further moves point.
       (set-process-sentinel proc #'ignore)

commit 2aff4fed69392238424230318c7c14a8e6a326f3
Author: Eli Zaretskii <eliz@gnu.org>
Date:   Sat Nov 8 13:09:36 2025 +0200

    ; Fix doc strings of the various 'insert-*' functions
    
    * src/editfns.c (Finsert_before_markers)
    (Finsert_and_inherit_before_markers, Finsert_char, Finsert_byte)
    (Finsert_buffer_substring): Clarify the effect on markers.
    (Bug#79692)

diff --git a/src/editfns.c b/src/editfns.c
index 8c83784a0cb..d3a4c226240 100644
--- a/src/editfns.c
+++ b/src/editfns.c
@@ -1396,7 +1396,10 @@ usage: (insert-and-inherit &rest ARGS)  */)
 
 DEFUN ("insert-before-markers", Finsert_before_markers, Sinsert_before_markers, 0, MANY, 0,
        doc: /* Insert strings or characters at point, relocating markers after the text.
-Point and markers move forward to end up after the inserted text.
+Point and all markers at or after the insertion point move forward to
+end up after the inserted text.  This is unlike with `insert' and other
+insertion functions, where before-insertion markers remain before the
+inserted text.
 
 If the current buffer is multibyte, unibyte strings are converted
 to multibyte for insertion (see `unibyte-char-to-multibyte').
@@ -1419,7 +1422,10 @@ usage: (insert-before-markers &rest ARGS)  */)
 DEFUN ("insert-before-markers-and-inherit", Finsert_and_inherit_before_markers,
   Sinsert_and_inherit_before_markers, 0, MANY, 0,
        doc: /* Insert text at point, relocating markers and inheriting properties.
-Point and markers move forward to end up after the inserted text.
+Point and all markers at or after the insertion point move forward to
+end up after the inserted text.  This is unlike with `insert' and other
+insertion functions, where before-insertion markers remain before the
+inserted text.
 
 If the current buffer is multibyte, unibyte strings are converted
 to multibyte for insertion (see `unibyte-char-to-multibyte').
@@ -1463,8 +1469,8 @@ its Unicode name in calls from Lisp, use `char-from-name'.
 When called interactively, COUNT is the prefix argument.  If omitted or
 nil, it defaults to 1.
 
-Inserting the character(s) relocates point and before-insertion
-markers in the same ways as the function `insert'.
+Inserting the character(s) relocates point and markers in the same ways
+as the function `insert'.
 
 The optional third argument INHERIT, if non-nil, says to inherit text
 properties from adjoining text, if those properties are sticky.  When
@@ -1520,7 +1526,8 @@ BYTE is a number of the range 0..255.
 If BYTE is 128..255 and the current buffer is multibyte, the
 corresponding eight-bit character is inserted.
 
-Point, and before-insertion markers, are relocated as in the function `insert'.
+Point and markers are relocated as in the function `insert'.
+
 The optional third arg INHERIT, if non-nil, says to inherit text properties
 from adjoining text, if those properties are sticky.  */)
   (Lisp_Object byte, Lisp_Object count, Lisp_Object inherit)
@@ -1707,9 +1714,7 @@ BUFFER may be a buffer or a buffer name.
 Arguments START and END are character positions specifying the substring.
 They default to the values of (point-min) and (point-max) in BUFFER.
 
-Point and before-insertion markers move forward to end up after the
-inserted text.
-Any other markers at the point of insertion remain before the text.
+Point and markers are relocated as in the function `insert'.
 
 If the current buffer is multibyte and BUFFER is unibyte, or vice
 versa, strings are converted from unibyte to multibyte or vice versa

commit cc4de67bd2439ddddbdd1792509799b370a942c4
Author: Lester Longley <lester@ieee.org>
Date:   Mon Sep 15 09:35:03 2025 -0400

    Fix 'bind*' in 'cond*'
    
    * lisp/emacs-lisp/cond-star.el (cond*-non-exit-clause-substance):
    Fix 'bind*' to match the documentation.  (Bug#79247)
    
    Copyright-paperwork-exempt: yes

diff --git a/lisp/emacs-lisp/cond-star.el b/lisp/emacs-lisp/cond-star.el
index 7dc6b34cc64..7d042116578 100644
--- a/lisp/emacs-lisp/cond-star.el
+++ b/lisp/emacs-lisp/cond-star.el
@@ -178,7 +178,9 @@ only in the CONDITION of a `cond*' clause."
 (defun cond*-non-exit-clause-substance (clause)
   "For a non-exit cond* clause CLAUSE, return its substance.
 This removes a final keyword if that's what makes CLAUSE non-exit."
-  (cond ((null (cdr-safe clause))   ;; clause has only one element.
+  (cond ((or (null (cdr-safe clause))   ;; either clause has only one element
+             (and (consp (car clause))  ;; or it starts with `bind*'
+                  (eq (caar clause) 'bind*)))
          clause)
         ;; Starts with t or a keyword.
         ;; Include t as the first element of the substance

commit a71ba898db84f728e2898c6b5f65402f600be9b9
Author: Eli Zaretskii <eliz@gnu.org>
Date:   Sat Nov 8 12:09:04 2025 +0200

    ; Update the MinGW URLs in w32 FAQ and nt/INSTALL
    
    * nt/INSTALL: Update MinGW URLs.
    
    * doc/misc/efaq-w32.texi (MinGW): Update the URL's and the text to
    reflect the fact that mingw.org's MinGW is no longer developed and
    can be found only on the WWW Archive.
    (Compiling): Add a cross-reference to "MinGW".

diff --git a/doc/misc/efaq-w32.texi b/doc/misc/efaq-w32.texi
index 5c24364286d..74e12485eec 100644
--- a/doc/misc/efaq-w32.texi
+++ b/doc/misc/efaq-w32.texi
@@ -196,7 +196,7 @@ in the Emacs source distribution.
 If you need to build or run Emacs on MS Windows before Windows 7, you
 have to use the MinGW port of GCC and the MSYS suite of tools.  The
 file @file{nt/INSTALL} in Emacs source distribution contains the
-details.
+details.  @xref{MinGW}.
 
 Support for displaying images, as well as XML/HTML rendering and TLS
 networking requires external libraries, the headers and import
@@ -2245,21 +2245,27 @@ software.  This includes all the optional libraries used by Emacs
 Hunspell, Gawk, GNU Make, Groff, GDB.
 
 @node MinGW
-@section MinGW and MSYS
+@section mingw.org's MinGW and MSYS
 @cindex mingw tools
 @cindex msys environment
 @cindex subprocesses, mingw and msys
 
 @uref{https://osdn.net/projects/mingw/}
 
-MinGW is another set of development tools that produce native Windows
-executables, not dependent on Cygwin's POSIX emulation DLLs.
-
-MSYS is a POSIX shell and minimal set of tools that are commonly used in
-configure scripts.  Like Cygwin, this environment uses a non-native
-filesystem mapping to appear more POSIX like to the scripts that it
-runs.  This is intended to complement the MinGW tools to make it easier
-to port software to Windows.
+MinGW from @code{mingw.org} is another set of development tools that
+produce native Windows executables, not dependent on Cygwin's POSIX
+emulation DLLs.  This is the original MinGW project, nowadays no longer
+actively developed.  Its files can currently be found only via the WWW
+archive site known as the @dfn{Wayback Machine}.  The latest MinGW
+release files can be found here:
+@uref{https://web.archive.org/web/20210410172202/https://osdn.net/projects/mingw/releases/}.
+
+MSYS, which is part of @code{mingw.org}s MinGW, is a POSIX shell and
+minimal set of tools that are commonly used in configure scripts.  Like
+Cygwin, this environment uses a non-native filesystem mapping to appear
+more POSIX like to the scripts that it runs.  This is intended to
+complement the MinGW tools to make it easier to port software to
+Windows.
 
 @node GnuWin32
 @section GnuWin32
diff --git a/nt/INSTALL b/nt/INSTALL
index abdb33fbb29..70ddb2ca420 100644
--- a/nt/INSTALL
+++ b/nt/INSTALL
@@ -137,9 +137,9 @@ build should run on Windows 9X and newer systems).
 
   A nice installer, called mingw-get, is available for those who don't
   like to mess with manual installations.  You can download it from
-  here:
+  the "Wayback Machine", here:
 
-    https://osdn.net/projects/mingw/releases
+    https://web.archive.org/web/20210410172202/https://osdn.net/projects/mingw/releases/
 
   (This installer only supports packages downloaded from the MinGW
   site; for the rest you will still need the manual method.)
@@ -201,9 +201,9 @@ build should run on Windows 9X and newer systems).
 
   You will need to install the MinGW port of GCC and Binutils, and the
   MinGW runtime and Windows API distributions, to compile Emacs.  You
-  can find these on the MinGW download/Base page:
+  can find these on the MinGW download page:
 
-    https://osdn.net/projects/mingw/releases
+    https://web.archive.org/web/20210410172202/https://osdn.net/projects/mingw/releases/
 
   In general, install the latest stable versions of the following
   MinGW packages from that page: gcc, binutils, mingw-rt, w32api.  You

commit ef9860588aca66abbcc47a0d49a373e0cd660d78
Author: Eli Zaretskii <eliz@gnu.org>
Date:   Sat Nov 8 11:40:33 2025 +0200

    ; * etc/NEWS (hs-hide-block-behavior): Explain the replacements.

diff --git a/etc/NEWS b/etc/NEWS
index 5c72fb469d7..2c4de22a2e6 100644
--- a/etc/NEWS
+++ b/etc/NEWS
@@ -1114,6 +1114,11 @@ after cursor position.  By default this is set to 'after-bol'.
 
 +++
 *** The variable 'hs-special-modes-alist' is now obsolete.
+Instead of customizing Hideshow for a mode by setting the elements of
+'hs-special-modes-alist', such as START, COMMENT-START,
+FORWARD-SEXP-FUNC, etc., major mode authors should set the corresponding
+buffer-local variables 'hs-block-start-regexp', 'hs-c-start-regexp',
+'hs-forward-sexp-function', etc.
 
 ** C-ts mode
 

commit e0ffcc655e5965393c4520c47866526d1d3620d9
Author: Manuel Giraud <manuel@ledu-giraud.fr>
Date:   Wed Nov 5 14:04:48 2025 +0100

    No more color emoji issue on OpenBSD 7.8 and later (bug#79768)
    
    Since version OpenBSD 7.8, its FreeType library supports color
    emoji out of the box.  See
    https://cvsweb.openbsd.org/xenocara/lib/freetype/include/freetype/config/ftoption.h?rev=1.32&content-type=text/x-cvsweb-markup.

diff --git a/etc/PROBLEMS b/etc/PROBLEMS
index ca06ce98d04..517ca2616ea 100644
--- a/etc/PROBLEMS
+++ b/etc/PROBLEMS
@@ -1304,7 +1304,7 @@ Emacs will select some other font instead.
 The only workaround is not to choose such font variants as the default
 font when running Emacs on MS-Windows.
 
-** On OpenBSD, color Emoji are not supported by default.
+** On OpenBSD before version 7.8, color Emoji are not supported by default.
 
 The system's FreeType library is not built with libpng support, so it
 can't display color emoji.  This is due to the fact that, on OpenBSD,
@@ -1324,6 +1324,7 @@ following those steps:
 	5. Build and install Xenocara (also, see release(8)).
 
 Note that this support will be gone after each OpenBSD's system upgrade.
+Also note that upgrading to OpenBSD 7.8 solves this whole issue.
 
 * Internationalization problems