commit 23ecd63ba498aa616e2a768090bca360e6d32309 (HEAD, refs/remotes/origin/master)
Author: Stefan Monnier <monnier@iro.umontreal.ca>
Date:   Tue Dec 26 00:08:48 2017 -0500

    * lisp/mail/footnote.el: Reduce redundancy in roman&hebrew defs
    
    (footnote-roman-lower-regexp, footnote-roman-upper-regexp)
    (footnote-roman-upper-list): Auto-generate from footnote-roman-lower-list.
    (footnote-hebrew-numeric-regex): Auto-generate from footnote-hebrew-numeric.
    (footnote--hebrew-numeric): Simplify.
    (footnote-hebrew-symbolic-regex): Generate from footnote-hebrew-symbolic.

diff --git a/lisp/mail/footnote.el b/lisp/mail/footnote.el
index 2448211a23..121e771c55 100644
--- a/lisp/mail/footnote.el
+++ b/lisp/mail/footnote.el
@@ -245,7 +245,8 @@ Wrapping around the alphabet implies successive repetitions of letters."
     (50 . "l") (100 . "c") (500 . "d") (1000 . "m"))
   "List of roman numerals with their values.")
 
-(defconst footnote-roman-lower-regexp "[ivxlcdm]+"
+(defconst footnote-roman-lower-regexp
+  (concat "[" (mapconcat #'cdr footnote-roman-lower-list "") "]+")
   "Regexp of roman numerals.")
 
 (defun footnote--roman-lower (n)
@@ -254,11 +255,11 @@ Wrapping around the alphabet implies successive repetitions of letters."
 
 ;;; ROMAN UPPER
 (defconst footnote-roman-upper-list
-  '((1 . "I") (5 . "V") (10 . "X")
-    (50 . "L") (100 . "C") (500 . "D") (1000 . "M"))
+  (mapcar (lambda (x) (cons (car x) (upcase (cdr x))))
+          footnote-roman-lower-list)
   "List of roman numerals with their values.")
 
-(defconst footnote-roman-upper-regexp "[IVXLCDM]+"
+(defconst footnote-roman-upper-regexp (upcase footnote-roman-lower-regexp)
   "Regexp of roman numerals.  Not complete")
 
 (defun footnote--roman-upper (n)
@@ -355,14 +356,15 @@ Use Unicode characters for footnoting."
 
 ;; Hebrew
 
-(defconst footnote-hebrew-numeric-regex "[אבגדהוזחטיכלמנסעפצקרשת']+")
-; (defconst footnote-hebrew-numeric-regex "\\([אבגדהוזחט]'\\)?\\(ת\\)?\\(ת\\)?\\([קרשת]\\)?\\([טיכלמנסעפצ]\\)?\\([אבגדהוזחט]\\)?")
-
 (defconst footnote-hebrew-numeric
   '(
     ("א" "ב" "ג" "ד" "ה" "ו" "ז" "ח" "ט")
     ("י" "כ" "ל" "מ" "נ" "ס" "ע" "פ" "צ")
-    ("ק" "ר" "ש" "ת" "תק" "תר"" תש" "תת" "תתק")))
+    ("ק" "ר" "ש" "ת" "תק" "תר" "תש" "תת" "תתק")))
+
+(defconst footnote-hebrew-numeric-regex
+  (concat "[" (apply #'concat (apply #'append footnote-hebrew-numeric)) "']+"))
+;; (defconst footnote-hebrew-numeric-regex "\\([אבגדהוזחט]'\\)?\\(ת\\)?\\(ת\\)?\\([קרשת]\\)?\\([טיכלמנסעפצ]\\)?\\([אבגדהוזחט]\\)?")
 
 (defun footnote--hebrew-numeric (n)
   "Supports 9999 footnotes, then rolls over."
@@ -371,25 +373,27 @@ Use Unicode characters for footnoting."
          (hundreds (/ (mod n 1000) 100))
          (tens (/ (mod n 100) 10))
          (units (mod n 10))
-         (special (if (not (= tens 1)) nil
-                    (or (when (= units 5) "טו")
-                        (when (= units 6) "טז")))))
+         (special (cond
+                   ((not (= tens 1)) nil)
+                   ((= units 5) "טו")
+                   ((= units 6) "טז"))))
     (concat
      (when (/= 0 thousands)
        (concat (nth (1- thousands) (nth 0 footnote-hebrew-numeric)) "'"))
      (when (/= 0 hundreds)
        (nth (1- hundreds) (nth 2 footnote-hebrew-numeric)))
-     (if special special
-      (concat
-        (when (/= 0 tens) (nth (1- tens) (nth 1 footnote-hebrew-numeric)))
-        (when (/= 0 units) (nth (1- units) (nth 0 footnote-hebrew-numeric))))))))
-
-(defconst footnote-hebrew-symbolic-regex "[אבגדהוזחטיכלמנסעפצקרשת]")
+     (or special
+         (concat
+          (when (/= 0 tens) (nth (1- tens) (nth 1 footnote-hebrew-numeric)))
+          (when (/= 0 units) (nth (1- units) (nth 0 footnote-hebrew-numeric))))))))
 
 (defconst footnote-hebrew-symbolic
   '(
     "א" "ב" "ג" "ד" "ה" "ו" "ז" "ח" "ט" "י" "כ" "ל" "מ" "נ" "ס" "ע" "פ" "צ" "ק" "ר" "ש" "ת"))
 
+(defconst footnote-hebrew-symbolic-regex
+  (concat "[" (apply #'concat footnote-hebrew-symbolic) "]"))
+
 (defun footnote--hebrew-symbolic (n)
   "Only 22 elements, per the style of eg. 'פירוש שפתי חכמים על רש״י'.
 Proceeds from `י' to `כ', from `צ' to `ק'. After `ת', rolls over to `א'."
@@ -409,7 +413,11 @@ Proceeds from `י' to `כ', from `צ' to `ק'. After `ת', rolls over to `א'."
   "Styles of footnote tags available.
 By default, Arabic numbers, English letters, Roman Numerals,
 Latin and Unicode superscript characters, and Hebrew numerals
-are available.")
+are available.
+Each element of the list should be of the form (NAME FUNCTION REGEXP)
+where NAME is a symbol, FUNCTION takes a footnote number and
+returns the corresponding representation in that style as a string,
+and REGEXP should be a regexp that matches any output of FUNCTION.")
 
 (defcustom footnote-style 'numeric
   "Default style used for footnoting.

commit 336932aaca77537bf0cf9d6d254827957166d6e9
Author: Stefan Monnier <monnier@iro.umontreal.ca>
Date:   Mon Dec 25 23:32:24 2017 -0500

    * lisp/mail/footnote.el: Use lexical-binding
    
    (footnote--renumber): Mark arg 'from' as unused.
    (footnote-add-footnote, footnote-renumber-footnotes)
    (footnote-back-to-message): Remove unused argument 'arg'.

diff --git a/lisp/mail/footnote.el b/lisp/mail/footnote.el
index 795b89649e..2448211a23 100644
--- a/lisp/mail/footnote.el
+++ b/lisp/mail/footnote.el
@@ -1,4 +1,4 @@
-;;; footnote.el --- footnote support for message mode
+;;; footnote.el --- footnote support for message mode  -*- lexical-binding:t -*-
 
 ;; Copyright (C) 1997, 2000-2017 Free Software Foundation, Inc.
 
@@ -546,7 +546,7 @@ styles."
 	  string 'footnote-number arg footnote-mouse-highlight t)
        (propertize string 'footnote-number arg)))))
 
-(defun footnote--renumber (from to pointer-alist text-alist)
+(defun footnote--renumber (_from to pointer-alist text-alist)
   "Renumber a single footnote."
   (let* ((posn-list (cdr pointer-alist)))
     (setcar pointer-alist to)
@@ -782,14 +782,14 @@ footnote area, returns `point-max'."
 	(setq i (1+ i)))
       rc)))
 
-(defun footnote-add-footnote (&optional arg)
+(defun footnote-add-footnote ()
   "Add a numbered footnote.
 The number the footnote receives is dependent upon the relative location
 of any other previously existing footnotes.
 If the variable `footnote-narrow-to-footnotes-when-editing' is set,
 the buffer is narrowed to the footnote body.  The restriction is removed
 by using `footnote-back-to-message'."
-  (interactive "*P")
+  (interactive "*")
   (let ((num
          (if footnote-text-marker-alist
              (if (< (point) (cl-cadar (last footnote-pointer-marker-alist)))
@@ -869,9 +869,9 @@ delete the footnote with that number."
 	    (when (looking-back "\n\n" (- (point) 2))
 	      (kill-line -1))))))))
 
-(defun footnote-renumber-footnotes (&optional arg)
+(defun footnote-renumber-footnotes ()
   "Renumber footnotes, starting from 1."
-  (interactive "*P")
+  (interactive "*")
   (save-excursion
     (let ((i 0)
 	  (notes (length footnote-pointer-marker-alist))
@@ -905,12 +905,12 @@ specified, jump to the text of that footnote."
      (t
       (error "I don't see a footnote here")))))
 
-(defun footnote-back-to-message (&optional arg)
+(defun footnote-back-to-message ()
   "Move cursor back to footnote referent.
 If the cursor is not over the text of a footnote, point is not changed.
 If the buffer was narrowed due to `footnote-narrow-to-footnotes-when-editing'
 being set it is automatically widened."
-  (interactive "P")
+  (interactive)
   (let ((note (footnote--text-under-cursor)))
     (when note
       (when footnote-narrow-to-footnotes-when-editing

commit b7123e2a451961970c1a71c734f3ce607665ae6c
Author: Boruch Baum <boruch_baum@gmx.com>
Date:   Mon Dec 25 23:27:26 2017 -0500

    * lisp/mail/footnote.el: Replace "Footnote-" prefix with "footnote--"
    
    (footnote-section-tag): Remove trailing space.

diff --git a/lisp/mail/footnote.el b/lisp/mail/footnote.el
index adfe03d306..795b89649e 100644
--- a/lisp/mail/footnote.el
+++ b/lisp/mail/footnote.el
@@ -2,8 +2,8 @@
 
 ;; Copyright (C) 1997, 2000-2017 Free Software Foundation, Inc.
 
-;; Author: Steven L Baur <steve@xemacs.org>
-;;         Boruch Baum <boruch_baum@gmx.com>
+;; Author: Steven L Baur <steve@xemacs.org> (1997-)
+;;         Boruch Baum <boruch_baum@gmx.com> (2017-)
 ;; Keywords: mail, news
 ;; Version: 0.19
 
@@ -120,12 +120,13 @@ After that, changing the prefix key requires manipulating keymaps."
 
 ;;; Interface variables that probably shouldn't be changed
 
-(defcustom footnote-section-tag "Footnotes: "
+(defcustom footnote-section-tag "Footnotes:"
   "Tag inserted at beginning of footnote section.
 If you set this to the empty string, no tag is inserted and the
 value of `footnote-section-tag-regexp' is ignored.  Customizing
 this variable has no effect on buffers already displaying
 footnotes."
+  :version "27.1"
   :type 'string
   :group 'footnote)
 
@@ -165,10 +166,10 @@ has no effect on buffers already displaying footnotes."
   :group 'footnote)
 
 (defcustom footnote-align-to-fn-text t
-  "If non-nil, align footnote text lines.
-If nil, footnote text lines are to be aligned flush left with left side
-of the footnote number.  If non-nil footnote text lines are to be aligned
-with the first character of footnote text."
+  "How to left-align footnote text.
+If nil, footnote text is to be aligned flush left with left side
+of the footnote number. If non-nil, footnote text is to be aligned
+left with the first character of footnote text."
   :type  'boolean)
 
 ;;; Private variables
@@ -195,7 +196,7 @@ with the first character of footnote text."
 (defconst footnote-numeric-regexp "[0-9]+"
   "Regexp for digits.")
 
-(defun Footnote-numeric (n)
+(defun footnote--numeric (n)
   "Numeric footnote style.
 Use Arabic numerals for footnoting."
   (int-to-string n))
@@ -207,7 +208,7 @@ Use Arabic numerals for footnoting."
 (defconst footnote-english-upper-regexp "[A-Z]+"
   "Regexp for upper case English alphabet.")
 
-(defun Footnote-english-upper (n)
+(defun footnote--english-upper (n)
   "Upper case English footnoting.
 Wrapping around the alphabet implies successive repetitions of letters."
   (let* ((ltr (mod (1- n) (length footnote-english-upper)))
@@ -226,7 +227,7 @@ Wrapping around the alphabet implies successive repetitions of letters."
 (defconst footnote-english-lower-regexp "[a-z]+"
   "Regexp of lower case English alphabet.")
 
-(defun Footnote-english-lower (n)
+(defun footnote--english-lower (n)
   "Lower case English footnoting.
 Wrapping around the alphabet implies successive repetitions of letters."
   (let* ((ltr (mod (1- n) (length footnote-english-lower)))
@@ -247,9 +248,9 @@ Wrapping around the alphabet implies successive repetitions of letters."
 (defconst footnote-roman-lower-regexp "[ivxlcdm]+"
   "Regexp of roman numerals.")
 
-(defun Footnote-roman-lower (n)
+(defun footnote--roman-lower (n)
   "Generic Roman number footnoting."
-  (Footnote-roman-common n footnote-roman-lower-list))
+  (footnote--roman-common n footnote-roman-lower-list))
 
 ;;; ROMAN UPPER
 (defconst footnote-roman-upper-list
@@ -260,11 +261,11 @@ Wrapping around the alphabet implies successive repetitions of letters."
 (defconst footnote-roman-upper-regexp "[IVXLCDM]+"
   "Regexp of roman numerals.  Not complete")
 
-(defun Footnote-roman-upper (n)
+(defun footnote--roman-upper (n)
   "Generic Roman number footnoting."
-  (Footnote-roman-common n footnote-roman-upper-list))
+  (footnote--roman-common n footnote-roman-upper-list))
 
-(defun Footnote-roman-common (n footnote-roman-list)
+(defun footnote--roman-common (n footnote-roman-list)
   "Lower case Roman footnoting."
   (let* ((our-list footnote-roman-list)
 	 (rom-lngth (length our-list))
@@ -299,22 +300,22 @@ Wrapping around the alphabet implies successive repetitions of letters."
       ;; (message "pairs are: rom-low: %S, rom-high: %S, rom-div: %S"
       ;;	  rom-low-pair rom-high-pair rom-div-pair)
       (cond
-       ((< n 0) (error "Footnote-roman-common called with n < 0"))
+       ((< n 0) (error "footnote--roman-common called with n < 0"))
        ((= n 0) "")
        ((= n (car rom-low-pair)) (cdr rom-low-pair))
        ((= n (car rom-high-pair)) (cdr rom-high-pair))
        ((= (car rom-low-pair) (car rom-high-pair))
 	(concat (cdr rom-low-pair)
-		(Footnote-roman-common
+		(footnote--roman-common
 		 (- n (car rom-low-pair))
 		 footnote-roman-list)))
        ((>= rom-div 0) (concat (cdr rom-div-pair) (cdr rom-high-pair)
-			       (Footnote-roman-common
+			       (footnote--roman-common
 				(- n (- (car rom-high-pair)
 					(car rom-div-pair)))
 				footnote-roman-list)))
        (t (concat (cdr rom-low-pair)
-		  (Footnote-roman-common
+		  (footnote--roman-common
 		   (- n (car rom-low-pair))
 		   footnote-roman-list)))))))
 
@@ -327,7 +328,7 @@ Wrapping around the alphabet implies successive repetitions of letters."
 (defconst footnote-latin-regexp (concat "[" footnote-latin-string "]")
   "Regexp for Latin-1 footnoting characters.")
 
-(defun Footnote-latin (n)
+(defun footnote--latin (n)
   "Latin-1 footnote style.
 Use a range of Latin-1 non-ASCII characters for footnoting."
   (string (aref footnote-latin-string
@@ -341,7 +342,7 @@ Use a range of Latin-1 non-ASCII characters for footnoting."
 (defconst footnote-unicode-regexp (concat "[" footnote-unicode-string "]+")
   "Regexp for Unicode footnoting characters.")
 
-(defun Footnote-unicode (n)
+(defun footnote--unicode (n)
   "Unicode footnote style.
 Use Unicode characters for footnoting."
   (let (modulus result done)
@@ -363,7 +364,7 @@ Use Unicode characters for footnoting."
     ("י" "כ" "ל" "מ" "נ" "ס" "ע" "פ" "צ")
     ("ק" "ר" "ש" "ת" "תק" "תר"" תש" "תת" "תתק")))
 
-(defun Footnote-hebrew-numeric (n)
+(defun footnote--hebrew-numeric (n)
   "Supports 9999 footnotes, then rolls over."
   (let* ((n (+ (mod n 10000) (/ n 10000)))
          (thousands (/ n 1000))
@@ -389,22 +390,22 @@ Use Unicode characters for footnoting."
   '(
     "א" "ב" "ג" "ד" "ה" "ו" "ז" "ח" "ט" "י" "כ" "ל" "מ" "נ" "ס" "ע" "פ" "צ" "ק" "ר" "ש" "ת"))
 
-(defun Footnote-hebrew-symbolic (n)
+(defun footnote--hebrew-symbolic (n)
   "Only 22 elements, per the style of eg. 'פירוש שפתי חכמים על רש״י'.
 Proceeds from `י' to `כ', from `צ' to `ק'. After `ת', rolls over to `א'."
   (nth (mod (1- n) 22) footnote-hebrew-symbolic))
 
 ;;; list of all footnote styles
 (defvar footnote-style-alist
-  `((numeric Footnote-numeric ,footnote-numeric-regexp)
-    (english-lower Footnote-english-lower ,footnote-english-lower-regexp)
-    (english-upper Footnote-english-upper ,footnote-english-upper-regexp)
-    (roman-lower Footnote-roman-lower ,footnote-roman-lower-regexp)
-    (roman-upper Footnote-roman-upper ,footnote-roman-upper-regexp)
-    (latin Footnote-latin ,footnote-latin-regexp)
-    (unicode Footnote-unicode ,footnote-unicode-regexp)
-    (hebrew-numeric Footnote-hebrew-numeric ,footnote-hebrew-numeric-regex)
-    (hebrew-symbolic Footnote-hebrew-symbolic ,footnote-hebrew-symbolic-regex))
+  `((numeric footnote--numeric ,footnote-numeric-regexp)
+    (english-lower footnote--english-lower ,footnote-english-lower-regexp)
+    (english-upper footnote--english-upper ,footnote-english-upper-regexp)
+    (roman-lower footnote--roman-lower ,footnote-roman-lower-regexp)
+    (roman-upper footnote--roman-upper ,footnote-roman-upper-regexp)
+    (latin footnote--latin ,footnote-latin-regexp)
+    (unicode footnote--unicode ,footnote-unicode-regexp)
+    (hebrew-numeric footnote--hebrew-numeric ,footnote-hebrew-numeric-regex)
+    (hebrew-symbolic footnote--hebrew-symbolic ,footnote-hebrew-symbolic-regex))
   "Styles of footnote tags available.
 By default, Arabic numbers, English letters, Roman Numerals,
 Latin and Unicode superscript characters, and Hebrew numerals
@@ -428,36 +429,36 @@ properly if the default font does not contain those characters.
 
 Customizing this variable has no effect on buffers already
 displaying footnotes.  To change the style of footnotes in such a
-buffer use the command `Footnote-set-style'."
+buffer use the command `footnote-set-style'."
   :type (cons 'choice (mapcar (lambda (x) (list 'const (car x)))
 			      footnote-style-alist))
   :group 'footnote)
 
 ;;; Style utilities & functions
-(defun Footnote-style-p (style)
+(defun footnote--style-p (style)
   "Return non-nil if style is a valid style known to `footnote-mode'."
   (assq style footnote-style-alist))
 
-(defun Footnote-index-to-string (index)
+(defun footnote--index-to-string (index)
   "Convert a binary index into a string to display as a footnote.
 Conversion is done based upon the current selected style."
-  (let ((alist (if (Footnote-style-p footnote-style)
+  (let ((alist (if (footnote--style-p footnote-style)
 		   (assq footnote-style footnote-style-alist)
 		 (nth 0 footnote-style-alist))))
     (funcall (nth 1 alist) index)))
 
-(defun Footnote-current-regexp ()
+(defun footnote--current-regexp ()
   "Return the regexp of the index of the current style."
   (concat (nth 2 (or (assq footnote-style footnote-style-alist)
 		     (nth 0 footnote-style-alist)))
 	  "*"))
 
-(defun Footnote-refresh-footnotes (&optional index-regexp)
+(defun footnote--refresh-footnotes (&optional index-regexp)
   "Redraw all footnotes.
 You must call this or arrange to have this called after changing footnote
 styles."
   (unless index-regexp
-    (setq index-regexp (Footnote-current-regexp)))
+    (setq index-regexp (footnote--current-regexp)))
   (save-excursion
     ;; Take care of the pointers first
     (let ((i 0) locn alist)
@@ -476,7 +477,7 @@ styles."
 	     (propertize
 	      (concat
 	       footnote-start-tag
-	       (Footnote-index-to-string (1+ i))
+	       (footnote--index-to-string (1+ i))
 	       footnote-end-tag)
 	      'footnote-number (1+ i) footnote-mouse-highlight t)
 	     nil "\\1"))
@@ -495,13 +496,13 @@ styles."
 	   (propertize
 	    (concat
 	     footnote-start-tag
-	     (Footnote-index-to-string (1+ i))
+	     (footnote--index-to-string (1+ i))
 	     footnote-end-tag)
 	    'footnote-number (1+ i))
 	   nil "\\1"))
 	(setq i (1+ i))))))
 
-(defun Footnote-assoc-index (key alist)
+(defun footnote--assoc-index (key alist)
   "Give index of key in alist."
   (let ((i 0) (max (length alist)) rc)
     (while (and (null rc)
@@ -511,33 +512,33 @@ styles."
       (setq i (1+ i)))
     rc))
 
-(defun Footnote-cycle-style ()
+(defun footnote-cycle-style ()
   "Select next defined footnote style."
   (interactive)
-  (let ((old (Footnote-assoc-index footnote-style footnote-style-alist))
+  (let ((old (footnote--assoc-index footnote-style footnote-style-alist))
 	(max (length footnote-style-alist))
 	idx)
     (setq idx (1+ old))
     (when (>= idx max)
       (setq idx 0))
     (setq footnote-style (car (nth idx footnote-style-alist)))
-    (Footnote-refresh-footnotes (nth 2 (nth old footnote-style-alist)))))
+    (footnote--refresh-footnotes (nth 2 (nth old footnote-style-alist)))))
 
-(defun Footnote-set-style (&optional style)
+(defun footnote-set-style (&optional style)
   "Select a specific style."
   (interactive
    (list (intern (completing-read
 		  "Footnote Style: "
-		  obarray #'Footnote-style-p 'require-match))))
-  (let ((old (Footnote-assoc-index footnote-style footnote-style-alist)))
+		  obarray #'footnote--style-p 'require-match))))
+  (let ((old (footnote--assoc-index footnote-style footnote-style-alist)))
     (setq footnote-style style)
-    (Footnote-refresh-footnotes (nth 2 (nth old footnote-style-alist)))))
+    (footnote--refresh-footnotes (nth 2 (nth old footnote-style-alist)))))
 
 ;; Internal functions
-(defun Footnote-insert-numbered-footnote (arg &optional mousable)
+(defun footnote--insert-numbered-footnote (arg &optional mousable)
   "Insert numbered footnote at (point)."
   (let ((string (concat footnote-start-tag
-			(Footnote-index-to-string arg)
+			(footnote--index-to-string arg)
 			footnote-end-tag)))
     (insert-before-markers
      (if mousable
@@ -545,7 +546,7 @@ styles."
 	  string 'footnote-number arg footnote-mouse-highlight t)
        (propertize string 'footnote-number arg)))))
 
-(defun Footnote-renumber (from to pointer-alist text-alist)
+(defun footnote--renumber (from to pointer-alist text-alist)
   "Renumber a single footnote."
   (let* ((posn-list (cdr pointer-alist)))
     (setcar pointer-alist to)
@@ -553,44 +554,40 @@ styles."
     (while posn-list
       (goto-char (car posn-list))
       (when (looking-back (concat (regexp-quote footnote-start-tag)
-				  (Footnote-current-regexp)
+				  (footnote--current-regexp)
 				  (regexp-quote footnote-end-tag))
 			  (line-beginning-position))
 	(replace-match
 	 (propertize
 	  (concat footnote-start-tag
-		  (Footnote-index-to-string to)
+		  (footnote--index-to-string to)
 		  footnote-end-tag)
 	  'footnote-number to footnote-mouse-highlight t)))
       (setq posn-list (cdr posn-list)))
     (goto-char (cdr text-alist))
     (when (looking-at (concat (regexp-quote footnote-start-tag)
-			      (Footnote-current-regexp)
+			      (footnote--current-regexp)
 			      (regexp-quote footnote-end-tag)))
       (replace-match
        (propertize
 	(concat footnote-start-tag
-		(Footnote-index-to-string to)
+		(footnote--index-to-string to)
 		footnote-end-tag)
 	'footnote-number to)))))
 
-;; Not needed? <-- 2017-12 Boruch: Not my comment! BUT, when I
-;; starting hacking the code, this function
-;; `Footnote-narrow-to-footnotes' was never narrowing, and the result
-;; wasn't breaking anything.
-(defun Footnote-narrow-to-footnotes ()
+(defun footnote--narrow-to-footnotes ()
   "Restrict text in buffer to show only text of footnotes."
   (interactive) ; testing
-  (narrow-to-region (Footnote--get-area-point-min)
-                    (Footnote--get-area-point-max)))
+  (narrow-to-region (footnote--get-area-point-min)
+                    (footnote--get-area-point-max)))
 
-(defun Footnote-goto-char-point-max ()
+(defun footnote--goto-char-point-max ()
   "Move to end of buffer or prior to start of .signature."
   (goto-char (point-max))
   (or (re-search-backward footnote-signature-separator nil t)
       (point)))
 
-(defun Footnote-insert-text-marker (arg locn)
+(defun footnote--insert-text-marker (arg locn)
   "Insert a marker pointing to footnote ARG, at buffer location LOCN."
   (let ((marker (make-marker)))
     (unless (assq arg footnote-text-marker-alist)
@@ -598,9 +595,9 @@ styles."
       (setq footnote-text-marker-alist
 	    (cons (cons arg marker) footnote-text-marker-alist))
       (setq footnote-text-marker-alist
-	    (Footnote-sort footnote-text-marker-alist)))))
+	    (footnote--sort footnote-text-marker-alist)))))
 
-(defun Footnote-insert-pointer-marker (arg locn)
+(defun footnote--insert-pointer-marker (arg locn)
   "Insert a marker pointing to footnote ARG, at buffer location LOCN."
   (let ((marker (make-marker))
 	alist)
@@ -611,14 +608,14 @@ styles."
       (setq footnote-pointer-marker-alist
 	    (cons (cons arg (list marker)) footnote-pointer-marker-alist))
       (setq footnote-pointer-marker-alist
-	    (Footnote-sort footnote-pointer-marker-alist)))))
+	    (footnote--sort footnote-pointer-marker-alist)))))
 
-(defun Footnote-insert-footnote (arg)
+(defun footnote--insert-footnote (arg)
   "Insert a footnote numbered ARG, at (point)."
   (push-mark)
-  (Footnote-insert-pointer-marker arg (point))
-  (Footnote-insert-numbered-footnote arg t)
-  (Footnote-goto-char-point-max)
+  (footnote--insert-pointer-marker arg (point))
+  (footnote--insert-numbered-footnote arg t)
+  (footnote--goto-char-point-max)
   (if (cond
        ((not (string-equal footnote-section-tag ""))
 	(re-search-backward (concat "^" footnote-section-tag-regexp) nil t))
@@ -626,8 +623,8 @@ styles."
 	(goto-char (cdar footnote-text-marker-alist))))
       (save-restriction
 	(when footnote-narrow-to-footnotes-when-editing
-	  (Footnote-narrow-to-footnotes))
-	(Footnote-goto-footnote (1- arg)) ; evil, FIXME (less evil now)
+	  (footnote--narrow-to-footnotes))
+	(footnote-goto-footnote (1- arg)) ; evil, FIXME (less evil now)
 	;; (message "Inserting footnote %d" arg)
 	(unless
 	    (or (eq arg 1)
@@ -636,11 +633,11 @@ styles."
 			   "\n\n"
 			 (concat "\n"
 				 (regexp-quote footnote-start-tag)
-				 (Footnote-current-regexp)
+				 (footnote--current-regexp)
 				 (regexp-quote footnote-end-tag)))
 		       nil t)
 		  (unless (beginning-of-line) t))
-		(Footnote-goto-char-point-max)
+		(footnote--goto-char-point-max)
 		(cond
 		 ((not (string-equal footnote-section-tag ""))
 		  (re-search-backward
@@ -654,21 +651,21 @@ styles."
     (unless (string-equal footnote-section-tag "")
       (insert footnote-section-tag "\n")))
   (let ((old-point (point)))
-    (Footnote-insert-numbered-footnote arg nil)
-    (Footnote-insert-text-marker arg old-point)))
+    (footnote--insert-numbered-footnote arg nil)
+    (footnote--insert-text-marker arg old-point)))
 
-(defun Footnote-sort (list)
+(defun footnote--sort (list)
   (sort list (lambda (e1 e2)
 	       (< (car e1) (car e2)))))
 
-(defun Footnote-text-under-cursor ()
+(defun footnote--text-under-cursor ()
   "Return the number of the current footnote if in footnote text.
 Return nil if the cursor is not positioned over the text of
 a footnote."
   (when (and footnote-text-marker-alist
-             (<= (Footnote--get-area-point-min)
+             (<= (footnote--get-area-point-min)
                  (point)
-                 (Footnote--get-area-point-max)))
+                 (footnote--get-area-point-max)))
     (let ((i 1) alist-txt result)
       (while (and (setq alist-txt (nth i footnote-text-marker-alist))
                   (null result))
@@ -679,40 +676,40 @@ a footnote."
         (setq result (car (nth (1- i) footnote-text-marker-alist))))
       result)))
 
-(defun Footnote-under-cursor ()
+(defun footnote--under-cursor ()
   "Return the number of the footnote underneath the cursor.
 Return nil if the cursor is not over a footnote."
   (or (get-text-property (point) 'footnote-number)
-      (Footnote-text-under-cursor)))
+      (footnote--text-under-cursor)))
 
-(defun Footnote--calc-fn-alignment-column ()
+(defun footnote--calc-fn-alignment-column ()
   "Calculate the left alignment for footnote text."
   ;; FIXME: Maybe it would be better to go to the footnote's beginning and
   ;; see at which column it starts.
   (+ footnote-body-tag-spacing
      (string-width
       (concat footnote-start-tag  footnote-end-tag
-              (Footnote-index-to-string
+              (footnote--index-to-string
                (caar (last footnote-text-marker-alist)))))))
 
-(defun Footnote--fill-prefix-string ()
+(defun footnote--fill-prefix-string ()
   "Return the fill prefix to be used by footnote mode."
   ;; TODO: Prefix to this value other prefix strings, such as those
   ;; designating a comment line, a message response, or a boxquote.
-  (make-string (Footnote--calc-fn-alignment-column) ?\s))
+  (make-string (footnote--calc-fn-alignment-column) ?\s))
 
-(defun Footnote--point-in-body-p ()
+(defun footnote--point-in-body-p ()
   "Return non-nil if point is in the buffer text area,
 i.e. before the beginning of the footnote area."
-  (< (point) (Footnote--get-area-point-min)))
+  (< (point) (footnote--get-area-point-min)))
 
-(defun Footnote--get-area-point-min (&optional before-tag)
+(defun footnote--get-area-point-min (&optional before-tag)
   "Return start of the first footnote.
 If there is no footnote area, returns `point-max'.
 With optional arg BEFORE-TAG, return position of the `footnote-section-tag'
 instead, if applicable."
   (cond
-   ;; FIXME: Shouldn't we use `Footnote--get-area-point-max' instead?
+   ;; FIXME: Shouldn't we use `footnote--get-area-point-max' instead?
    ((not footnote-text-marker-alist) (point-max))
    ((not before-tag) (cdr (car footnote-text-marker-alist)))
    ((string-equal footnote-section-tag "")
@@ -741,28 +738,28 @@ instead, if applicable."
         ;; TODO: integrate sanity checks at reasonable operational points.
         (cdr (car footnote-text-marker-alist)))))))
 
-(defun Footnote--get-area-point-max ()
+(defun footnote--get-area-point-max ()
   "Return the end of footnote area.
 This is either `point-max' or the start of a `.signature' string, as
 defined by variable `footnote-signature-separator'. If there is no
 footnote area, returns `point-max'."
-  (save-excursion (Footnote-goto-char-point-max)))
+  (save-excursion (footnote--goto-char-point-max)))
 
-(defun Footnote--adaptive-fill-function (orig-fun)
+(defun footnote--adaptive-fill-function (orig-fun)
   (or
    (and
     footnote-mode
     footnote-align-to-fn-text
-    (Footnote-text-under-cursor)
-    ;; (not (Footnote--point-in-body-p))
-    ;; (< (point) (Footnote--signature-area-start-point))
-    (Footnote--fill-prefix-string))
+    (footnote--text-under-cursor)
+    ;; (not (footnote--point-in-body-p))
+    ;; (< (point) (footnote--signature-area-start-point))
+    (footnote--fill-prefix-string))
    ;; If not within a footnote's text, fallback to the default.
    (funcall orig-fun)))
 
 ;;; User functions
 
-(defun Footnote-make-hole ()
+(defun footnote--make-hole ()
   (save-excursion
     (let ((i 0)
 	  (notes (length footnote-pointer-marker-alist))
@@ -775,32 +772,32 @@ footnote area, returns `point-max'."
 	    (setq rc (car alist-ptr)))
 	  (save-excursion
 	    (message "Renumbering from %s to %s"
-		     (Footnote-index-to-string (car alist-ptr))
-		     (Footnote-index-to-string
+		     (footnote--index-to-string (car alist-ptr))
+		     (footnote--index-to-string
 		      (1+ (car alist-ptr))))
-	    (Footnote-renumber (car alist-ptr)
+	    (footnote--renumber (car alist-ptr)
 			       (1+ (car alist-ptr))
 			       alist-ptr
 			       alist-txt)))
 	(setq i (1+ i)))
       rc)))
 
-(defun Footnote-add-footnote (&optional arg)
+(defun footnote-add-footnote (&optional arg)
   "Add a numbered footnote.
 The number the footnote receives is dependent upon the relative location
 of any other previously existing footnotes.
 If the variable `footnote-narrow-to-footnotes-when-editing' is set,
 the buffer is narrowed to the footnote body.  The restriction is removed
-by using `Footnote-back-to-message'."
+by using `footnote-back-to-message'."
   (interactive "*P")
   (let ((num
          (if footnote-text-marker-alist
              (if (< (point) (cl-cadar (last footnote-pointer-marker-alist)))
-                 (Footnote-make-hole)
+                 (footnote--make-hole)
                (1+ (caar (last footnote-text-marker-alist))))
            1)))
     (message "Adding footnote %d" num)
-    (Footnote-insert-footnote num)
+    (footnote--insert-footnote num)
     (insert-before-markers (make-string footnote-body-tag-spacing ? ))
     (let ((opoint (point)))
       (save-excursion
@@ -809,18 +806,18 @@ by using `Footnote-back-to-message'."
 	     "\n\n"
 	   "\n"))
 	(when footnote-narrow-to-footnotes-when-editing
-	  (Footnote-narrow-to-footnotes)))
+	  (footnote--narrow-to-footnotes)))
       ;; Emacs/XEmacs bug?  save-excursion doesn't restore point when using
       ;; insert-before-markers.
       (goto-char opoint))))
 
-(defun Footnote-delete-footnote (&optional arg)
+(defun footnote-delete-footnote (&optional arg)
   "Delete a numbered footnote.
 With no parameter, delete the footnote under (point).  With ARG specified,
 delete the footnote with that number."
   (interactive "*P")
   (unless arg
-    (setq arg (Footnote-under-cursor)))
+    (setq arg (footnote--under-cursor)))
   (when (and arg
 	     (or (not footnote-prompt-before-deletion)
 		 (y-or-n-p (format "Really delete footnote %d?" arg))))
@@ -834,7 +831,7 @@ delete the footnote with that number."
 	(save-excursion
 	  (goto-char (car locn))
 	  (when (looking-back (concat (regexp-quote footnote-start-tag)
-				      (Footnote-current-regexp)
+				      (footnote--current-regexp)
 				      (regexp-quote footnote-end-tag))
 			      (line-beginning-position))
 	    (delete-region (match-beginning 0) (match-end 0))))
@@ -848,17 +845,17 @@ delete the footnote with that number."
            (save-restriction ; <= 2017-12 Boruch: WHY?? I see no narrowing / widening here.
 	     (end-of-line)
 	     (next-single-char-property-change
-	      (point) 'footnote-number nil (Footnote-goto-char-point-max))))))
+	      (point) 'footnote-number nil (footnote--goto-char-point-max))))))
       (setq footnote-pointer-marker-alist
 	    (delq alist-ptr footnote-pointer-marker-alist))
       (setq footnote-text-marker-alist
 	    (delq alist-txt footnote-text-marker-alist))
-      (Footnote-renumber-footnotes)
+      (footnote-renumber-footnotes)
       (when (and (null footnote-text-marker-alist)
 		 (null footnote-pointer-marker-alist))
 	(save-excursion
 	  (if (not (string-equal footnote-section-tag ""))
-	      (let* ((end (Footnote-goto-char-point-max))
+	      (let* ((end (footnote--goto-char-point-max))
 		     (start (1- (re-search-backward
 				 (concat "^" footnote-section-tag-regexp)
 				 nil t))))
@@ -868,11 +865,11 @@ delete the footnote with that number."
 		(delete-region start (if (< end (point-max))
 					 end
 				       (point-max))))
-	    (Footnote-goto-char-point-max)
+	    (footnote--goto-char-point-max)
 	    (when (looking-back "\n\n" (- (point) 2))
 	      (kill-line -1))))))))
 
-(defun Footnote-renumber-footnotes (&optional arg)
+(defun footnote-renumber-footnotes (&optional arg)
   "Renumber footnotes, starting from 1."
   (interactive "*P")
   (save-excursion
@@ -883,16 +880,16 @@ delete the footnote with that number."
 	(setq alist-ptr (nth i footnote-pointer-marker-alist))
 	(setq alist-txt (nth i footnote-text-marker-alist))
 	(unless (= (1+ i) (car alist-ptr))
-	  (Footnote-renumber (car alist-ptr) (1+ i) alist-ptr alist-txt))
+	  (footnote--renumber (car alist-ptr) (1+ i) alist-ptr alist-txt))
 	(setq i (1+ i))))))
 
-(defun Footnote-goto-footnote (&optional arg)
+(defun footnote-goto-footnote (&optional arg)
   "Jump to the text of a footnote.
 With no parameter, jump to the text of the footnote under (point).  With ARG
 specified, jump to the text of that footnote."
   (interactive "P")
   (unless arg
-    (setq arg (Footnote-under-cursor)))
+    (setq arg (footnote--under-cursor)))
   (let ((footnote (assq arg footnote-text-marker-alist)))
     (cond
      (footnote
@@ -908,13 +905,13 @@ specified, jump to the text of that footnote."
      (t
       (error "I don't see a footnote here")))))
 
-(defun Footnote-back-to-message (&optional arg)
+(defun footnote-back-to-message (&optional arg)
   "Move cursor back to footnote referent.
 If the cursor is not over the text of a footnote, point is not changed.
 If the buffer was narrowed due to `footnote-narrow-to-footnotes-when-editing'
 being set it is automatically widened."
   (interactive "P")
-  (let ((note (Footnote-text-under-cursor)))
+  (let ((note (footnote--text-under-cursor)))
     (when note
       (when footnote-narrow-to-footnotes-when-editing
 	(widen))
@@ -922,13 +919,13 @@ being set it is automatically widened."
 
 (defvar footnote-mode-map
   (let ((map (make-sparse-keymap)))
-    (define-key map "a" 'Footnote-add-footnote)
-    (define-key map "b" 'Footnote-back-to-message)
-    (define-key map "c" 'Footnote-cycle-style)
-    (define-key map "d" 'Footnote-delete-footnote)
-    (define-key map "g" 'Footnote-goto-footnote)
-    (define-key map "r" 'Footnote-renumber-footnotes)
-    (define-key map "s" 'Footnote-set-style)
+    (define-key map "a" 'footnote-add-footnote)
+    (define-key map "b" 'footnote-back-to-message)
+    (define-key map "c" 'footnote-cycle-style)
+    (define-key map "d" 'footnote-delete-footnote)
+    (define-key map "g" 'footnote-goto-footnote)
+    (define-key map "r" 'footnote-renumber-footnotes)
+    (define-key map "s" 'footnote-set-style)
     map))
 
 (defvar footnote-minor-mode-map
@@ -956,9 +953,9 @@ play around with the following keys:
     ;; but only `ignore' behaves correctly with add/remove-function.
     (setq adaptive-fill-function #'ignore))
   (remove-function (local 'adaptive-fill-function)
-                   #'Footnote--adaptive-fill-function)
+                   #'footnote--adaptive-fill-function)
   (when footnote-mode
-    ;; (Footnote-setup-keybindings)
+    ;; (footnote-setup-keybindings)
     (make-local-variable 'footnote-style)
     (make-local-variable 'footnote-body-tag-spacing)
     (make-local-variable 'footnote-spaced-footnotes)
@@ -968,7 +965,7 @@ play around with the following keys:
     (make-local-variable 'footnote-end-tag)
     (make-local-variable 'adaptive-fill-function)
     (add-function :around (local 'adaptive-fill-function)
-                  #'Footnote--adaptive-fill-function)
+                  #'footnote--adaptive-fill-function)
 
     ;; filladapt is an XEmacs package which AFAIK has never been ported
     ;; to Emacs.

commit cd1d9e79f74f137511d49eb9b0ae7ba750ba6c3c
Author: Stefan Monnier <monnier@iro.umontreal.ca>
Date:   Mon Dec 25 22:51:23 2017 -0500

    * lisp/register.el: Use cl-generic
    
    (registerv): Make it a "normal"struct.
    (registerv-make): Declare obsolete.
    (register-val-jump-to, register-val-describe, register-val-insert):
    New generic functions.
    (jump-to-register, describe-register-1, insert-register): Use them.
    
    * lisp/emacs-lisp/cl-generic.el: Prefill a combination of struct+typeof.
    (cl--generic-prefill-dispatchers): Allow a list of specializers.

diff --git a/lisp/emacs-lisp/cl-generic.el b/lisp/emacs-lisp/cl-generic.el
index 0027899679..5c16f64a6f 100644
--- a/lisp/emacs-lisp/cl-generic.el
+++ b/lisp/emacs-lisp/cl-generic.el
@@ -808,22 +808,26 @@ methods.")
   ;; able to preload cl-generic without also preloading the byte-compiler,
   ;; So we use `eval-when-compile' so as not keep it available longer than
   ;; strictly needed.
-(defmacro cl--generic-prefill-dispatchers (arg-or-context specializer)
+(defmacro cl--generic-prefill-dispatchers (arg-or-context &rest specializers)
   (unless (integerp arg-or-context)
     (setq arg-or-context `(&context . ,arg-or-context)))
   (unless (fboundp 'cl--generic-get-dispatcher)
     (require 'cl-generic))
   (let ((fun (cl--generic-get-dispatcher
-              `(,arg-or-context ,@(cl-generic-generalizers specializer)
-                                ,cl--generic-t-generalizer))))
+              `(,arg-or-context
+                ,@(apply #'append
+                         (mapcar #'cl-generic-generalizers specializers))
+                ,cl--generic-t-generalizer))))
     ;; Recompute dispatch at run-time, since the generalizers may be slightly
     ;; different (e.g. byte-compiled rather than interpreted).
     ;; FIXME: There is a risk that the run-time generalizer is not equivalent
     ;; to the compile-time one, in which case `fun' may not be correct
     ;; any more!
-    `(let ((dispatch `(,',arg-or-context
-                       ,@(cl-generic-generalizers ',specializer)
-                       ,cl--generic-t-generalizer)))
+    `(let ((dispatch
+            `(,',arg-or-context
+              ,@(apply #'append
+                       (mapcar #'cl-generic-generalizers ',specializers))
+              ,cl--generic-t-generalizer)))
        ;; (message "Prefilling for %S with \n%S" dispatch ',fun)
        (puthash dispatch ',fun cl--generic-dispatchers)))))
 
@@ -1205,6 +1209,7 @@ See the full list and their hierarchy in `cl--generic-typeof-types'."
    (cl-call-next-method)))
 
 (cl--generic-prefill-dispatchers 0 integer)
+(cl--generic-prefill-dispatchers 0 cl--generic-generalizer integer)
 
 ;;; Dispatch on major mode.
 
diff --git a/lisp/register.el b/lisp/register.el
index 23eefd08b8..0fdcd51dac 100644
--- a/lisp/register.el
+++ b/lisp/register.el
@@ -39,9 +39,7 @@
   (registerv (:constructor nil)
 	     (:constructor registerv--make (&optional data print-func
 						      jump-func insert-func))
-	     (:copier nil)
-	     (:type vector)
-	     :named)
+	     (:copier nil))
   (data        nil :read-only t)
   (print-func  nil :read-only t)
   (jump-func   nil :read-only t)
@@ -59,6 +57,7 @@ this sentence:
 JUMP-FUNC if provided, controls how `jump-to-register' jumps to the register.
 INSERT-FUNC if provided, controls how `insert-register' insert the register.
 They both receive DATA as argument."
+  (declare (obsolete "Use your own type with methods on register-val-(insert|describe|jump-to)" "27.1"))
   (registerv--make data print-func jump-func insert-func))
 
 (defvar register-alist nil
@@ -245,36 +244,44 @@ Interactively, reads the register using `register-read-with-preview'."
   (interactive (list (register-read-with-preview "Jump to register: ")
 		     current-prefix-arg))
   (let ((val (get-register register)))
-    (cond
-     ((registerv-p val)
-      (cl-assert (registerv-jump-func val) nil
-              "Don't know how to jump to register %s"
-              (single-key-description register))
-      (funcall (registerv-jump-func val) (registerv-data val)))
-     ((and (consp val) (frame-configuration-p (car val)))
-      (set-frame-configuration (car val) (not delete))
-      (goto-char (cadr val)))
-     ((and (consp val) (window-configuration-p (car val)))
-      (set-window-configuration (car val))
-      (goto-char (cadr val)))
-     ((markerp val)
-      (or (marker-buffer val)
-	  (user-error "That register's buffer no longer exists"))
-      (switch-to-buffer (marker-buffer val))
-      (unless (or (= (point) (marker-position val))
-                  (eq last-command 'jump-to-register))
-        (push-mark))
-      (goto-char val))
-     ((and (consp val) (eq (car val) 'file))
-      (find-file (cdr val)))
-     ((and (consp val) (eq (car val) 'file-query))
-      (or (find-buffer-visiting (nth 1 val))
-	  (y-or-n-p (format "Visit file %s again? " (nth 1 val)))
-	  (user-error "Register access aborted"))
-      (find-file (nth 1 val))
-      (goto-char (nth 2 val)))
-     (t
-      (user-error "Register doesn't contain a buffer position or configuration")))))
+    (register-val-jump-to val delete)))
+
+(cl-defgeneric register-val-jump-to (_val _arg)
+  "Execute the \"jump\" operation of VAL.
+ARG is the value of the prefix argument or nil."
+  (user-error "Register doesn't contain a buffer position or configuration"))
+
+(cl-defmethod register-val-jump-to ((val registerv) _arg)
+  (cl-assert (registerv-jump-func val) nil
+             "Don't know how to jump to register value %S" val)
+  (funcall (registerv-jump-func val) (registerv-data val)))
+
+(cl-defmethod register-val-jump-to ((val marker) _arg)
+  (or (marker-buffer val)
+      (user-error "That register's buffer no longer exists"))
+  (switch-to-buffer (marker-buffer val))
+  (unless (or (= (point) (marker-position val))
+              (eq last-command 'jump-to-register))
+    (push-mark))
+  (goto-char val))
+
+(cl-defmethod register-val-jump-to ((val cons) delete)
+  (cond
+   ((frame-configuration-p (car val))
+    (set-frame-configuration (car val) (not delete))
+    (goto-char (cadr val)))
+   ((window-configuration-p (car val))
+    (set-window-configuration (car val))
+    (goto-char (cadr val)))
+   ((eq (car val) 'file)
+    (find-file (cdr val)))
+   ((eq (car val) 'file-query)
+    (or (find-buffer-visiting (nth 1 val))
+	(y-or-n-p (format "Visit file %s again? " (nth 1 val)))
+	(user-error "Register access aborted"))
+    (find-file (nth 1 val))
+    (goto-char (nth 2 val)))
+   (t (cl-call-next-method val delete))))
 
 (defun register-swap-out ()
   "Turn markers into file-query references when a buffer is killed."
@@ -356,79 +363,84 @@ Interactively, reads the register using `register-read-with-preview'."
   (princ (single-key-description register))
   (princ " contains ")
   (let ((val (get-register register)))
+    (register-val-describe val verbose)))
+
+(cl-defgeneric register-val-describe (val verbose)
+  "Print description of register value VAL to `standard-output'."
+  (princ "Garbage:\n")
+  (if verbose (prin1 val)))
+
+(cl-defmethod register-val-describe ((val registerv) _verbose)
+  (if (registerv-print-func val)
+      (funcall (registerv-print-func val) (registerv-data val))
+    (princ "[UNPRINTABLE CONTENTS].")))
+
+(cl-defmethod register-val-describe ((val number) _verbose)
+  (princ val))
+
+(cl-defmethod register-val-describe ((val marker) _verbose)
+  (let ((buf (marker-buffer val)))
+    (if (null buf)
+	(princ "a marker in no buffer")
+      (princ "a buffer position:\n    buffer ")
+      (princ (buffer-name buf))
+      (princ ", position ")
+      (princ (marker-position val)))))
+
+(cl-defmethod register-val-describe ((val cons) verbose)
+  (cond
+   ((window-configuration-p (car val))
+    (princ "a window configuration."))
+
+   ((frame-configuration-p (car val))
+    (princ "a frame configuration."))
+
+   ((eq (car val) 'file)
+    (princ "the file ")
+    (prin1 (cdr val))
+    (princ "."))
+
+   ((eq (car val) 'file-query)
+    (princ "a file-query reference:\n    file ")
+    (prin1 (car (cdr val)))
+    (princ ",\n    position ")
+    (princ (car (cdr (cdr val))))
+    (princ "."))
+
+   (t
+    (if verbose
+	(progn
+	  (princ "the rectangle:\n")
+	  (while val
+	    (princ "    ")
+	    (princ (car val))
+	    (terpri)
+	    (setq val (cdr val))))
+      (princ "a rectangle starting with ")
+      (princ (car val))))))
+
+(cl-defmethod register-val-describe ((val string) verbose)
+  (setq val (copy-sequence val))
+  (if (eq yank-excluded-properties t)
+      (set-text-properties 0 (length val) nil val)
+    (remove-list-of-text-properties 0 (length val)
+				    yank-excluded-properties val))
+  (if verbose
+      (progn
+	(princ "the text:\n")
+	(princ val))
     (cond
-     ((registerv-p val)
-      (if (registerv-print-func val)
-          (funcall (registerv-print-func val) (registerv-data val))
-        (princ "[UNPRINTABLE CONTENTS].")))
-
-     ((numberp val)
-      (princ val))
-
-     ((markerp val)
-      (let ((buf (marker-buffer val)))
-	(if (null buf)
-	    (princ "a marker in no buffer")
-	  (princ "a buffer position:\n    buffer ")
-	  (princ (buffer-name buf))
-	  (princ ", position ")
-	  (princ (marker-position val)))))
-
-     ((and (consp val) (window-configuration-p (car val)))
-      (princ "a window configuration."))
-
-     ((and (consp val) (frame-configuration-p (car val)))
-      (princ "a frame configuration."))
-
-     ((and (consp val) (eq (car val) 'file))
-      (princ "the file ")
-      (prin1 (cdr val))
-      (princ "."))
-
-     ((and (consp val) (eq (car val) 'file-query))
-      (princ "a file-query reference:\n    file ")
-      (prin1 (car (cdr val)))
-      (princ ",\n    position ")
-      (princ (car (cdr (cdr val))))
-      (princ "."))
-
-     ((consp val)
-      (if verbose
-	  (progn
-	    (princ "the rectangle:\n")
-	    (while val
-	      (princ "    ")
-	      (princ (car val))
-	      (terpri)
-	      (setq val (cdr val))))
-	(princ "a rectangle starting with ")
-	(princ (car val))))
-
-     ((stringp val)
-      (setq val (copy-sequence val))
-      (if (eq yank-excluded-properties t)
-	  (set-text-properties 0 (length val) nil val)
-	(remove-list-of-text-properties 0 (length val)
-					yank-excluded-properties val))
-      (if verbose
-	  (progn
-	    (princ "the text:\n")
-	    (princ val))
-	(cond
-	 ;; Extract first N characters starting with first non-whitespace.
-	 ((string-match (format "[^ \t\n].\\{,%d\\}"
-				;; Deduct 6 for the spaces inserted below.
-				(min 20 (max 0 (- (window-width) 6))))
-			val)
-	  (princ "text starting with\n    ")
-	  (princ (match-string 0 val)))
-	 ((string-match "^[ \t\n]+$" val)
-	  (princ "whitespace"))
-	 (t
-	  (princ "the empty string")))))
+     ;; Extract first N characters starting with first non-whitespace.
+     ((string-match (format "[^ \t\n].\\{,%d\\}"
+			    ;; Deduct 6 for the spaces inserted below.
+			    (min 20 (max 0 (- (window-width) 6))))
+		    val)
+      (princ "text starting with\n    ")
+      (princ (match-string 0 val)))
+     ((string-match "^[ \t\n]+$" val)
+      (princ "whitespace"))
      (t
-      (princ "Garbage:\n")
-      (if verbose (prin1 val))))))
+      (princ "the empty string")))))
 
 (defun insert-register (register &optional arg)
   "Insert contents of register REGISTER.  (REGISTER is a character.)
@@ -444,24 +456,32 @@ Interactively, reads the register using `register-read-with-preview'."
 		       (not current-prefix-arg))))
   (push-mark)
   (let ((val (get-register register)))
-    (cond
-     ((registerv-p val)
-      (cl-assert (registerv-insert-func val) nil
-              "Don't know how to insert register %s"
-              (single-key-description register))
-      (funcall (registerv-insert-func val) (registerv-data val)))
-     ((consp val)
-      (insert-rectangle val))
-     ((stringp val)
-      (insert-for-yank val))
-     ((numberp val)
-      (princ val (current-buffer)))
-     ((and (markerp val) (marker-position val))
-      (princ (marker-position val) (current-buffer)))
-     (t
-      (user-error "Register does not contain text"))))
+    (register-val-insert val))
   (if (not arg) (exchange-point-and-mark)))
 
+(cl-defgeneric register-val-insert (_val)
+  "Insert register value VAL."
+  (user-error "Register does not contain text"))
+
+(cl-defmethod register-val-insert ((val registerv))
+  (cl-assert (registerv-insert-func val) nil
+             "Don't know how to insert register value %S" val)
+  (funcall (registerv-insert-func val) (registerv-data val)))
+
+(cl-defmethod register-val-insert ((val cons))
+  (insert-rectangle val))
+
+(cl-defmethod register-val-insert ((val string))
+  (insert-for-yank val))
+
+(cl-defmethod register-val-insert ((val number))
+  (princ val (current-buffer)))
+
+(cl-defmethod register-val-insert ((val marker))
+  (if (marker-position val)
+      (princ (marker-position val) (current-buffer))
+    (cl-call-next-method val)))
+
 (defun copy-to-register (register start end &optional delete-flag region)
   "Copy region into register REGISTER.
 With prefix arg, delete as well.

commit cf13450db84d507ef1d5d32e56345ecf0bd5c592
Author: Chris Zheng <chriszheng99@gmail.com>
Date:   Mon Dec 25 19:21:58 2017 +0200

    Fix MS-Windows build broken by recent changes in json.c
    
    * src/json.c [WINDOWSNT] (fn_json_object_get): Define.
    (init_json_functions) [WINDOWSNT]: Load json_object_get from DLL.
    (Bug#29848)
    
    Copyright-paperwork-exempt: yes

diff --git a/src/json.c b/src/json.c
index f615c4269f..88db86ad2e 100644
--- a/src/json.c
+++ b/src/json.c
@@ -60,6 +60,7 @@ DEF_DLL_FN (double, json_real_value, (const json_t *real));
 DEF_DLL_FN (const char *, json_string_value, (const json_t *string));
 DEF_DLL_FN (size_t, json_string_length, (const json_t *string));
 DEF_DLL_FN (json_t *, json_array_get, (const json_t *array, size_t index));
+DEF_DLL_FN (json_t *, json_object_get, (const json_t *object, const char *key));
 DEF_DLL_FN (size_t, json_object_size, (const json_t *object));
 DEF_DLL_FN (const char *, json_object_iter_key, (void *iter));
 DEF_DLL_FN (void *, json_object_iter, (json_t *object));
@@ -108,6 +109,7 @@ init_json_functions (void)
   LOAD_DLL_FN (library, json_string_value);
   LOAD_DLL_FN (library, json_string_length);
   LOAD_DLL_FN (library, json_array_get);
+  LOAD_DLL_FN (library, json_object_get);
   LOAD_DLL_FN (library, json_object_size);
   LOAD_DLL_FN (library, json_object_iter_key);
   LOAD_DLL_FN (library, json_object_iter);
@@ -141,6 +143,7 @@ init_json_functions (void)
 #define json_string_value fn_json_string_value
 #define json_string_length fn_json_string_length
 #define json_array_get fn_json_array_get
+#define json_object_get fn_json_object_get
 #define json_object_size fn_json_object_size
 #define json_object_iter_key fn_json_object_iter_key
 #define json_object_iter fn_json_object_iter

commit 448eebcccee723a3c528a4fd03b4eb684f700f22
Author: Stefan Monnier <monnier@iro.umontreal.ca>
Date:   Mon Dec 25 12:12:17 2017 -0500

    * lisp/rtree.el: Use lexical-binding and not 'cl'.

diff --git a/lisp/rtree.el b/lisp/rtree.el
index 9db03c474d..095ed19ffe 100644
--- a/lisp/rtree.el
+++ b/lisp/rtree.el
@@ -1,4 +1,4 @@
-;;; rtree.el --- functions for manipulating range trees
+;;; rtree.el --- functions for manipulating range trees  -*- lexical-binding:t -*-
 
 ;; Copyright (C) 2010-2017 Free Software Foundation, Inc.
 
@@ -43,9 +43,6 @@
 
 ;;; Code:
 
-(eval-when-compile
-  (require 'cl))
-
 (defmacro rtree-make-node ()
   `(list (list nil) nil))
 
@@ -85,7 +82,7 @@
   range)
 
 (define-obsolete-function-alias 'rtree-normalise-range
-  'rtree-normalize-range "25.1")
+  #'rtree-normalize-range "25.1")
 
 (defun rtree-make (range)
   "Make an rtree from RANGE."

commit 4ddf0b8e43537626aa5aa49122b1fe7a9ad3adc3
Author: Lars Ingebrigtsen <larsi@gnus.org>
Date:   Mon Dec 25 11:29:41 2017 +0100

    lisp/net/mailcap.el (mailcap-file-name-to-mime-type): New function.
    
    * lisp/net/mailcap.el (mailcap-file-name-to-mime-type): New function.

diff --git a/etc/NEWS b/etc/NEWS
index 1f8fe67152..64c74c0d56 100644
--- a/etc/NEWS
+++ b/etc/NEWS
@@ -210,6 +210,11 @@ a multibyte string even if its second argument is an ASCII character.
 'json-insert', 'json-parse-string', and 'json-parse-buffer'.  These
 are implemented in C using the Jansson library.
 
+---
+** The new function `mailcap-file-name-to-mime-type' has been added.
+It's a simple convenience function for looking up MIME types based on
+file name extensions.
+
 
 * Changes in Emacs 27.1 on Non-Free Operating Systems
 
diff --git a/lisp/net/mailcap.el b/lisp/net/mailcap.el
index be1a171cd4..197d233dda 100644
--- a/lisp/net/mailcap.el
+++ b/lisp/net/mailcap.el
@@ -1006,6 +1006,14 @@ If FORCE, re-parse even if already parsed."
       (setq extn (concat "." extn)))
   (cdr (assoc (downcase extn) mailcap-mime-extensions)))
 
+(defun mailcap-file-name-to-mime-type (file-name)
+  "Return the MIME content type based on the FILE-NAME's extension.
+For instance, \"foo.png\" will result in \"image/png\"."
+  (mailcap-extension-to-mime
+   (if (string-match "\\(\\.[^.]+\\)\\'" file-name)
+       (match-string 1 file-name)
+     "")))
+
 (defun mailcap-mime-types ()
   "Return a list of MIME media types."
   (mailcap-parse-mimetypes)

commit 53a32e6636f391212c662f2f3d4b671e96610b7a
Author: Michael Albinus <michael.albinus@gmx.de>
Date:   Mon Dec 25 12:27:06 2017 +0100

    Fix Bug#29822
    
    * lisp/net/tramp-sh.el (tramp-maybe-open-connection):
    Fix handling of restricted shells.  (Bug#29822)

diff --git a/lisp/net/tramp-sh.el b/lisp/net/tramp-sh.el
index 96a0d84907..2eae8ff941 100644
--- a/lisp/net/tramp-sh.el
+++ b/lisp/net/tramp-sh.el
@@ -4738,14 +4738,16 @@ connection if a previous connection has died for some reason."
 			   (if tramp-encoding-command-interactive
 			       (list tramp-encoding-shell
 				     tramp-encoding-command-interactive)
-			     (list tramp-encoding-shell))))))
+			     (list tramp-encoding-shell)))))
+		     current-host)
 
-		;; Set sentinel and query flag.
+		;; Set sentinel and query flag.  Initialize variables.
 		(tramp-set-connection-property p "vector" vec)
 		(set-process-sentinel p 'tramp-process-sentinel)
 		(process-put p 'adjust-window-size-function 'ignore)
 		(set-process-query-on-exit-flag p nil)
-		(setq tramp-current-connection (cons vec (current-time)))
+		(setq tramp-current-connection (cons vec (current-time))
+		      current-host (system-name))
 
 		(tramp-message
 		 vec 6 "%s" (mapconcat 'identity (process-command p) " "))
@@ -4799,8 +4801,9 @@ connection if a previous connection has died for some reason."
 
 		    ;; Check, whether there is a restricted shell.
 		    (dolist (elt tramp-restricted-shell-hosts-alist)
-		      (when (string-match elt l-host)
+		      (when (string-match elt current-host)
 			(setq r-shell t)))
+		    (setq current-host l-host)
 
 		    ;; Set password prompt vector.
 		    (tramp-set-connection-property