[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]
[elpa] externals/compat fc8d878a37 1/3: Drop remaining 24.3 code
|
From: |
ELPA Syncer |
|
Subject: |
[elpa] externals/compat fc8d878a37 1/3: Drop remaining 24.3 code |
|
Date: |
Wed, 4 Jan 2023 19:57:26 -0500 (EST) |
branch: externals/compat
commit fc8d878a3743f326696e950deb5ff2463c5585be
Author: Daniel Mendler <mail@daniel-mendler.de>
Commit: Daniel Mendler <mail@daniel-mendler.de>
Drop remaining 24.3 code
---
Makefile | 3 +-
NEWS.org | 2 +-
compat-24.el | 433 +-------------------------------------------------------
compat-25.el | 1 -
compat-tests.el | 369 +----------------------------------------------
compat.texi | 269 ++---------------------------------
6 files changed, 15 insertions(+), 1062 deletions(-)
diff --git a/Makefile b/Makefile
index 139e7683af..e205f12393 100644
--- a/Makefile
+++ b/Makefile
@@ -4,8 +4,7 @@
EMACS = emacs
MAKEINFO = makeinfo
-BYTEC = compat-24.elc \
- compat-25.elc \
+BYTEC = compat-25.elc \
compat-26.elc \
compat-27.elc \
compat-28.elc \
diff --git a/NEWS.org b/NEWS.org
index 631f3da242..69de87c678 100644
--- a/NEWS.org
+++ b/NEWS.org
@@ -23,7 +23,7 @@
- Deprecate ~compat-help.el~ and ~compat-font-lock.el~
- Development moved to GitHub
- BREAKING: Drop broken function ~func-arity~
-- BREAKING: Drop support for Emacs 24.3
+- BREAKING: Drop support for Emacs 24.3. Emacs 24.4 is required now.
* Release of "Compat" Version 28.1.2.2
diff --git a/compat-24.el b/compat-24.el
index 6c15c22249..ccfb57f15e 100644
--- a/compat-24.el
+++ b/compat-24.el
@@ -1,6 +1,6 @@
-;;; compat-24.el --- Compatibility Layer for Emacs 24.4 -*- lexical-binding:
t; -*-
+;;; compat-24.el --- Obsolete package -*- lexical-binding: t; -*-
-;; Copyright (C) 2021-2023 Free Software Foundation, Inc.
+;; Copyright (C) 2021-2023 Free Software Foundation, Inc.
;; This program is free software; you can redistribute it and/or modify
;; it under the terms of the GNU General Public License as published by
@@ -16,436 +16,9 @@
;; along with this program. If not, see <https://www.gnu.org/licenses/>.
;;; Commentary:
-
-;; Find here the functionality added in Emacs 24.4, needed by older
-;; versions.
-
;;; Code:
-(eval-when-compile (load "compat-macs.el" nil t t))
-(compat-declare-version "24.4")
-
-;;;; Defined in data.c
-
-(compat-defun = (number-or-marker &rest numbers-or-markers) ;; <OK>
- "Handle multiple arguments."
- :explicit t
- (catch 'fail
- (while numbers-or-markers
- (unless (= number-or-marker (car numbers-or-markers))
- (throw 'fail nil))
- (setq number-or-marker (pop numbers-or-markers)))
- t))
-
-(compat-defun < (number-or-marker &rest numbers-or-markers) ;; <OK>
- "Handle multiple arguments."
- :explicit t
- (catch 'fail
- (while numbers-or-markers
- (unless (< number-or-marker (car numbers-or-markers))
- (throw 'fail nil))
- (setq number-or-marker (pop numbers-or-markers)))
- t))
-
-(compat-defun > (number-or-marker &rest numbers-or-markers) ;; <OK>
- "Handle multiple arguments."
- :explicit t
- (catch 'fail
- (while numbers-or-markers
- (unless (> number-or-marker (car numbers-or-markers))
- (throw 'fail nil))
- (setq number-or-marker (pop numbers-or-markers)))
- t))
-
-(compat-defun <= (number-or-marker &rest numbers-or-markers) ;; <OK>
- "Handle multiple arguments."
- :explicit t
- (catch 'fail
- (while numbers-or-markers
- (unless (<= number-or-marker (car numbers-or-markers))
- (throw 'fail nil))
- (setq number-or-marker (pop numbers-or-markers)))
- t))
-
-(compat-defun >= (number-or-marker &rest numbers-or-markers) ;; <OK>
- "Handle multiple arguments."
- :explicit t
- (catch 'fail
- (while numbers-or-markers
- (unless (>= number-or-marker (pop numbers-or-markers))
- (throw 'fail nil)))
- t))
-
-(compat-defun bool-vector-exclusive-or (a b &optional c) ;; <OR>
- "Return A ^ B, bitwise exclusive or.
-If optional third argument C is given, store result into C.
-A, B, and C must be bool vectors of the same length.
-Return the destination vector if it changed or nil otherwise."
- (unless (bool-vector-p a)
- (signal 'wrong-type-argument (list 'bool-vector-p a)))
- (unless (bool-vector-p b)
- (signal 'wrong-type-argument (list 'bool-vector-p b)))
- (unless (or (null c) (bool-vector-p c))
- (signal 'wrong-type-argument (list 'bool-vector-p c)))
- (when (/= (length a) (length b))
- (signal 'wrong-length-argument (list (length a) (length b))))
- (let ((dest (or c (make-bool-vector (length a) nil))) changed)
- (when (/= (length a) (length dest))
- (signal 'wrong-length-argument (list (length a) (length dest))))
- (dotimes (i (length dest))
- (let ((val (not (eq (aref a i) (aref b i)))))
- (unless (eq val (aref dest i))
- (setq changed t))
- (aset dest i val)))
- (if c (and changed c) dest)))
-
-(compat-defun bool-vector-union (a b &optional c) ;; <OK>
- "Return A | B, bitwise or.
-If optional third argument C is given, store result into C.
-A, B, and C must be bool vectors of the same length.
-Return the destination vector if it changed or nil otherwise."
- (unless (bool-vector-p a)
- (signal 'wrong-type-argument (list 'bool-vector-p a)))
- (unless (bool-vector-p b)
- (signal 'wrong-type-argument (list 'bool-vector-p b)))
- (unless (or (null c) (bool-vector-p c))
- (signal 'wrong-type-argument (list 'bool-vector-p c)))
- (when (/= (length a) (length b))
- (signal 'wrong-length-argument (list (length a) (length b))))
- (let ((dest (or c (make-bool-vector (length a) nil))) changed)
- (when (/= (length a) (length dest))
- (signal 'wrong-length-argument (list (length a) (length dest))))
- (dotimes (i (length dest))
- (let ((val (or (aref a i) (aref b i))))
- (unless (eq val (aref dest i))
- (setq changed t))
- (aset dest i val)))
- (if c (and changed c) dest)))
-
-(compat-defun bool-vector-intersection (a b &optional c) ;; <OK>
- "Return A & B, bitwise and.
-If optional third argument C is given, store result into C.
-A, B, and C must be bool vectors of the same length.
-Return the destination vector if it changed or nil otherwise."
- (unless (bool-vector-p a)
- (signal 'wrong-type-argument (list 'bool-vector-p a)))
- (unless (bool-vector-p b)
- (signal 'wrong-type-argument (list 'bool-vector-p b)))
- (unless (or (null c) (bool-vector-p c))
- (signal 'wrong-type-argument (list 'bool-vector-p c)))
- (when (/= (length a) (length b))
- (signal 'wrong-length-argument (list (length a) (length b))))
- (let ((dest (or c (make-bool-vector (length a) nil))) changed)
- (when (/= (length a) (length dest))
- (signal 'wrong-length-argument (list (length a) (length dest))))
- (dotimes (i (length dest))
- (let ((val (and (aref a i) (aref b i))))
- (unless (eq val (aref dest i))
- (setq changed t))
- (aset dest i val)))
- (if c (and changed c) dest)))
-
-(compat-defun bool-vector-set-difference (a b &optional c) ;; <OK>
- "Return A &~ B, set difference.
-If optional third argument C is given, store result into C.
-A, B, and C must be bool vectors of the same length.
-Return the destination vector if it changed or nil otherwise."
- (unless (bool-vector-p a)
- (signal 'wrong-type-argument (list 'bool-vector-p a)))
- (unless (bool-vector-p b)
- (signal 'wrong-type-argument (list 'bool-vector-p b)))
- (unless (or (null c) (bool-vector-p c))
- (signal 'wrong-type-argument (list 'bool-vector-p c)))
- (when (/= (length a) (length b))
- (signal 'wrong-length-argument (list (length a) (length b))))
- (let ((dest (or c (make-bool-vector (length a) nil))) changed)
- (when (/= (length a) (length dest))
- (signal 'wrong-length-argument (list (length a) (length dest))))
- (dotimes (i (length dest))
- (let ((val (and (aref a i) (not (aref b i)))))
- (unless (eq val (aref dest i))
- (setq changed t))
- (aset dest i val)))
- (if c (and changed c) dest)))
-
-(compat-defun bool-vector-not (a &optional b) ;; <OK>
- "Compute ~A, set complement.
-If optional second argument B is given, store result into B.
-A and B must be bool vectors of the same length.
-Return the destination vector."
- (unless (bool-vector-p a)
- (signal 'wrong-type-argument (list 'bool-vector-p a)))
- (unless (or (null b) (bool-vector-p b))
- (signal 'wrong-type-argument (list 'bool-vector-p b)))
- (let ((dest (or b (make-bool-vector (length a) nil))))
- (when (/= (length a) (length dest))
- (signal 'wrong-length-argument (list (length a) (length dest))))
- (dotimes (i (length dest))
- (aset dest i (not (aref a i))))
- dest))
-
-(compat-defun bool-vector-subsetp (a b) ;; <OK>
- "Return t if every t value in A is also t in B, nil otherwise.
-A and B must be bool vectors of the same length."
- (unless (bool-vector-p a)
- (signal 'wrong-type-argument (list 'bool-vector-p a)))
- (unless (bool-vector-p b)
- (signal 'wrong-type-argument (list 'bool-vector-p b)))
- (when (/= (length a) (length b))
- (signal 'wrong-length-argument (list (length a) (length b))))
- (catch 'not-subset
- (dotimes (i (length a))
- (when (if (aref a i) (not (aref b i)) nil)
- (throw 'not-subset nil)))
- t))
-
-(compat-defun bool-vector-count-consecutive (a b i) ;; <OK>
- "Count how many consecutive elements in A equal B starting at I.
-A is a bool vector, B is t or nil, and I is an index into A."
- (unless (bool-vector-p a)
- (signal 'wrong-type-argument (list 'bool-vector-p a)))
- (setq b (and b t)) ;normalise to nil or t
- (unless (< i (length a))
- (signal 'args-out-of-range (list a i)))
- (let ((len (length a)) (n i))
- (while (and (< i len) (eq (aref a i) b))
- (setq i (1+ i)))
- (- i n)))
-
-(compat-defun bool-vector-count-population (a) ;; <OK>
- "Count how many elements in A are t.
-A is a bool vector. To count A's nil elements, subtract the
-return value from A's length."
- (unless (bool-vector-p a)
- (signal 'wrong-type-argument (list 'bool-vector-p a)))
- (let ((n 0))
- (dotimes (i (length a))
- (when (aref a i)
- (setq n (1+ n))))
- n))
-
-;;;; Defined in subr.el
-
-(compat-defun special-form-p (object) ;; <OK>
- "Non-nil if and only if OBJECT is a special form."
- (if (and (symbolp object) (fboundp object))
- (setq object (condition-case nil
- (indirect-function object)
- (void-function nil))))
- (and (subrp object) (eq (cdr (subr-arity object)) 'unevalled)))
-
-(compat-defun macrop (object) ;; <OK>
- "Non-nil if and only if OBJECT is a macro."
- (let ((def (condition-case nil
- (indirect-function object)
- (void-function nil))))
- (when (consp def)
- (or (eq 'macro (car def))
- (and (autoloadp def) (memq (nth 4 def) '(macro t)))))))
-
-(compat-defun string-suffix-p (suffix string &optional ignore-case) ;; <OK>
- "Return non-nil if SUFFIX is a suffix of STRING.
-If IGNORE-CASE is non-nil, the comparison is done without paying
-attention to case differences."
- (let ((start-pos (- (length string) (length suffix))))
- (and (>= start-pos 0)
- (eq t (compare-strings suffix nil nil
- string start-pos nil ignore-case)))))
-
-(compat-defun split-string (string &optional separators omit-nulls trim) ;;
<OK>
- "Extend `split-string' by a TRIM argument.
-The remaining arguments STRING, SEPARATORS and OMIT-NULLS are
-handled just as with `split-string'."
- :explicit t
- (let* ((token (split-string string separators omit-nulls))
- (trimmed (if trim
- (mapcar
- (lambda (token)
- (when (string-match (concat "\\`" trim) token)
- (setq token (substring token (match-end 0))))
- (when (string-match (concat trim "\\'") token)
- (setq token (substring token 0 (match-beginning
0))))
- token)
- token)
- token)))
- (if omit-nulls (delete "" trimmed) trimmed)))
-
-(compat-defun delete-consecutive-dups (list &optional circular) ;; <OK>
- "Destructively remove `equal' consecutive duplicates from LIST.
-First and last elements are considered consecutive if CIRCULAR is
-non-nil."
- (let ((tail list) last)
- (while (cdr tail)
- (if (equal (car tail) (cadr tail))
- (setcdr tail (cddr tail))
- (setq last tail
- tail (cdr tail))))
- (if (and circular
- last
- (equal (car tail) (car list)))
- (setcdr last nil)))
- list)
-
-(compat-defun define-error (name message &optional parent) ;; <UNTESTED>
- "Define NAME as a new error signal.
-MESSAGE is a string that will be output to the echo area if such an error
-is signaled without being caught by a `condition-case'.
-PARENT is either a signal or a list of signals from which it inherits.
-Defaults to `error'."
- (unless parent (setq parent 'error))
- (let ((conditions
- (if (consp parent)
- (apply #'append
- (mapcar (lambda (parent)
- (cons parent
- (or (get parent 'error-conditions)
- (error "Unknown signal `%s'" parent))))
- parent))
- (cons parent (get parent 'error-conditions)))))
- (put name 'error-conditions
- (delete-dups (copy-sequence (cons name conditions))))
- (when message (put name 'error-message message))))
-
-;;;; Defined in minibuffer.el
-
-(compat-defun completion-table-with-cache (fun &optional ignore-case) ;;
<UNTESTED>
- "Create dynamic completion table from function FUN, with cache.
-This is a wrapper for `completion-table-dynamic' that saves the last
-argument-result pair from FUN, so that several lookups with the
-same argument (or with an argument that starts with the first one)
-only need to call FUN once. This can be useful when FUN performs a
-relatively slow operation, such as calling an external process.
-
-When IGNORE-CASE is non-nil, FUN is expected to be case-insensitive."
- (let* (last-arg last-result
- (new-fun
- (lambda (arg)
- (if (and last-arg (string-prefix-p last-arg arg ignore-case))
- last-result
- (prog1
- (setq last-result (funcall fun arg))
- (setq last-arg arg))))))
- (completion-table-dynamic new-fun)))
-
-(compat-defun completion-table-merge (&rest tables) ;; <UNTESTED>
- "Create a completion table that collects completions from all TABLES."
- (lambda (string pred action)
- (cond
- ((null action)
- (let ((retvals (mapcar (lambda (table)
- (try-completion string table pred))
- tables)))
- (if (member string retvals)
- string
- (try-completion string
- (mapcar (lambda (value)
- (if (eq value t) string value))
- (delq nil retvals))
- pred))))
- ((eq action t)
- (apply #'append (mapcar (lambda (table)
- (all-completions string table pred))
- tables)))
- (t
- (completion--some (lambda (table)
- (complete-with-action action table string pred))
- tables)))))
-
-;;;; Defined in subr-x.el
-
-(compat-defun hash-table-keys (hash-table) ;; <OK>
- "Return a list of keys in HASH-TABLE."
- (let (values)
- (maphash
- (lambda (k _v) (push k values))
- hash-table)
- values))
-
-(compat-defun hash-table-values (hash-table) ;; <OK>
- "Return a list of values in HASH-TABLE."
- (let (values)
- (maphash
- (lambda (_k v) (push v values))
- hash-table)
- values))
-
-(compat-defun string-empty-p (string) ;; <OK>
- "Check whether STRING is empty."
- (string= string ""))
-
-(compat-defun string-join (strings &optional separator) ;; <OK>
- "Join all STRINGS using SEPARATOR.
-Optional argument SEPARATOR must be a string, a vector, or a list of
-characters; nil stands for the empty string."
- (mapconcat #'identity strings separator))
-
-(compat-defun string-blank-p (string) ;; <OK>
- "Check whether STRING is either empty or only whitespace.
-The following characters count as whitespace here: space, tab, newline and
-carriage return."
- (string-match-p "\\`[ \t\n\r]*\\'" string))
-
-(compat-defun string-remove-prefix (prefix string) ;; <OK>
- "Remove PREFIX from STRING if present."
- (if (string-prefix-p prefix string)
- (substring string (length prefix))
- string))
-
-(compat-defun string-remove-suffix (suffix string) ;; <OK>
- "Remove SUFFIX from STRING if present."
- (if (string-suffix-p suffix string)
- (substring string 0 (- (length string) (length suffix)))
- string))
-
-;;;; Defined in faces.el
-
-(compat-defun face-spec-set (face spec &optional spec-type) ;; <UNTESTED>
- "Set the FACE's spec SPEC, define FACE, and recalculate its attributes.
-See `defface' for the format of SPEC.
-
-The appearance of each face is controlled by its specs (set via
-this function), and by the internal frame-specific face
-attributes (set via `set-face-attribute').
-
-This function also defines FACE as a valid face name if it is not
-already one, and (re)calculates its attributes on existing
-frames.
-
-The optional argument SPEC-TYPE determines which spec to set:
- nil, omitted or `face-override-spec' means the override spec,
- which overrides all the other types of spec mentioned below
- (this is usually what you want if calling this function
- outside of Custom code);
- `customized-face' or `saved-face' means the customized spec or
- the saved custom spec;
- `face-defface-spec' means the default spec
- (usually set only via `defface');
- `reset' means to ignore SPEC, but clear the `customized-face'
- and `face-override-spec' specs;
-Any other value means not to set any spec, but to run the
-function for defining FACE and recalculating its attributes."
- (if (get face 'face-alias)
- (setq face (get face 'face-alias)))
- ;; Save SPEC to the relevant symbol property.
- (unless spec-type
- (setq spec-type 'face-override-spec))
- (if (memq spec-type '(face-defface-spec face-override-spec
- customized-face saved-face))
- (put face spec-type spec))
- (if (memq spec-type '(reset saved-face))
- (put face 'customized-face nil))
- ;; Setting the face spec via Custom empties out any override spec,
- ;; similar to how setting a variable via Custom changes its values.
- (if (memq spec-type '(customized-face saved-face reset))
- (put face 'face-override-spec nil))
- ;; If we reset the face based on its custom spec, it is unmodified
- ;; as far as Custom is concerned.
- (unless (eq face 'face-override-spec)
- (put face 'face-modified nil))
- ;; Initialize the face if it does not exist, then recalculate.
- (make-empty-face face)
- (dolist (frame (frame-list))
- (face-spec-recalc face frame)))
+(warn "compat-24 has been deprecated")
(provide 'compat-24)
;;; compat-24.el ends here
diff --git a/compat-25.el b/compat-25.el
index 8ac018632b..6161facf0f 100644
--- a/compat-25.el
+++ b/compat-25.el
@@ -22,7 +22,6 @@
;;; Code:
-(require 'compat-24)
(eval-when-compile (load "compat-macs.el" nil t t))
(compat-declare-version "25.1")
diff --git a/compat-tests.el b/compat-tests.el
index 2d830e08cd..edcf1e291d 100644
--- a/compat-tests.el
+++ b/compat-tests.el
@@ -176,142 +176,14 @@
(insert-into-buffer other 2 3))
(should (string= (buffer-string) "abce")))))
-(ert-deftest bool-vector-exclusive-or ()
- (let ((a (bool-vector t t nil nil))
- (b (bool-vector t nil t nil)))
- (let ((c (make-bool-vector 4 nil))) ;; side effect test
- (bool-vector-exclusive-or a b c)
- (should-equal (bool-vector nil t t nil) c)
- (should-equal (bool-vector nil t t nil) c))
- (should-equal (bool-vector nil t t nil) (bool-vector-exclusive-or a b))
- (should-equal (bool-vector nil t t nil) (bool-vector-exclusive-or b a))
- (when (version<= "24.4" emacs-version)
- (should-error (bool-vector-exclusive-or a (bool-vector)) :type
'wrong-length-argument)
- (should-error (bool-vector-exclusive-or a b (bool-vector)) :type
'wrong-length-argument))
- (should-error (bool-vector-exclusive-or (bool-vector) (vector)) :type
'wrong-type-argument)
- (should-error (bool-vector-exclusive-or (vector) (bool-vector)) :type
'wrong-type-argument)
- (should-error (bool-vector-exclusive-or (vector) (vector)) :type
'wrong-type-argument)
- (should-error (bool-vector-exclusive-or (bool-vector) (bool-vector)
(vector)) :type 'wrong-type-argument)
- (should-error (bool-vector-exclusive-or (bool-vector) (vector) (vector))
:type 'wrong-type-argument)
- (should-error (bool-vector-exclusive-or (vector) (bool-vector) (vector))
:type 'wrong-type-argument)
- (should-error (bool-vector-exclusive-or (vector) (vector) (vector)) :type
'wrong-type-argument)))
-
-(ert-deftest bool-vector-union ()
- (let ((a (bool-vector t t nil nil))
- (b (bool-vector t nil t nil)))
- (should-equal (bool-vector t t t nil) (bool-vector-union a b))
- (should-equal (bool-vector t t t nil) (bool-vector-union b a))
- (let ((c (make-bool-vector 4 nil))) ;; Side effects
- (bool-vector-union a b c)
- (should-equal (bool-vector t t t nil) c))
- (when (version<= "24.4" emacs-version)
- (should-error (bool-vector-union a (bool-vector)) :type
'wrong-length-argument)
- (should-error (bool-vector-union a b (bool-vector))) :type
'wrong-length-argument)
- (should-error (bool-vector-union (bool-vector) (vector)) :type
'wrong-type-argument)
- (should-error (bool-vector-union (vector) (bool-vector)) :type
'wrong-type-argument)
- (should-error (bool-vector-union (vector) (vector)) :type
'wrong-type-argument)
- (should-error (bool-vector-union (bool-vector) (bool-vector) (vector))
:type 'wrong-type-argument)
- (should-error (bool-vector-union (bool-vector) (vector) (vector)) :type
'wrong-type-argument)
- (should-error (bool-vector-union (vector) (bool-vector) (vector)) :type
'wrong-type-argument)
- (should-error (bool-vector-union (vector) (vector) (vector)))) :type
'wrong-type-argument)
-
-(ert-deftest bool-vector-intersection ()
- (let ((a (bool-vector t t nil nil))
- (b (bool-vector t nil t nil)))
- (should-equal (bool-vector t nil nil nil) (bool-vector-intersection a b))
- (should-equal (bool-vector t nil nil nil) (bool-vector-intersection b a))
- (let ((c (make-bool-vector 4 nil))) ;; side effect
- (bool-vector-intersection a b c)
- (should-equal (bool-vector t nil nil nil) c))
- (when (version<= "24.4" emacs-version)
- (should-error (bool-vector-intersection a (bool-vector)) :type
'wrong-length-argument)
- (should-error (bool-vector-intersection a b (bool-vector)) :type
'wrong-length-argument))
- (should-error (bool-vector-intersection (bool-vector) (vector)) :type
'wrong-type-argument)
- (should-error (bool-vector-intersection (vector) (bool-vector)) :type
'wrong-type-argument)
- (should-error (bool-vector-intersection (vector) (vector)) :type
'wrong-type-argument)
- (should-error (bool-vector-intersection (bool-vector) (bool-vector)
(vector)) :type 'wrong-type-argument)
- (should-error (bool-vector-intersection (bool-vector) (vector) (vector))
:type 'wrong-type-argument)
- (should-error (bool-vector-intersection (vector) (bool-vector) (vector))
:type 'wrong-type-argument)
- (should-error (bool-vector-intersection (vector) (vector) (vector))))
:type 'wrong-type-argument)
-
-(ert-deftest bool-vector-set-difference ()
- (let ((a (bool-vector t t nil nil))
- (b (bool-vector t nil t nil)))
- (should-equal (bool-vector nil t nil nil) (bool-vector-set-difference a b))
- (should-equal (bool-vector nil nil t nil) (bool-vector-set-difference b a))
- (let ((c (make-bool-vector 4 nil))) ;; side effect
- (bool-vector-set-difference a b c)
- (should-equal (bool-vector nil t nil nil) c))
- (let ((c (make-bool-vector 4 nil))) ;; side effect
- (bool-vector-set-difference b a c)
- (should-equal (bool-vector nil nil t nil) c))
- (when (version<= "24.4" emacs-version)
- (should-error (bool-vector-set-difference a (bool-vector)) :type
'wrong-length-argument)
- (should-error (bool-vector-set-difference a b (bool-vector)) :type
'wrong-length-argument))
- (should-error (bool-vector-set-difference (bool-vector) (vector)) :type
'wrong-type-argument)
- (should-error (bool-vector-set-difference (vector) (bool-vector)) :type
'wrong-type-argument)
- (should-error (bool-vector-set-difference (vector) (vector)) :type
'wrong-type-argument)
- (should-error (bool-vector-set-difference (bool-vector) (bool-vector)
(vector)) :type 'wrong-type-argument)
- (should-error (bool-vector-set-difference (bool-vector) (vector) (vector))
:type 'wrong-type-argument)
- (should-error (bool-vector-set-difference (vector) (bool-vector) (vector))
:type 'wrong-type-argument)
- (should-error (bool-vector-set-difference (vector) (vector) (vector))))
:type 'wrong-type-argument)
-
-(ert-deftest bool-vector-not ()
+(ert-deftest bool-vector ()
(should-equal (bool-vector) (bool-vector-not (bool-vector)))
(should-equal (bool-vector t) (bool-vector-not (bool-vector nil)))
(should-equal (bool-vector nil) (bool-vector-not (bool-vector t)))
(should-equal (bool-vector t t) (bool-vector-not (bool-vector nil nil)))
(should-equal (bool-vector t nil) (bool-vector-not (bool-vector nil t)))
(should-equal (bool-vector nil t) (bool-vector-not (bool-vector t nil)))
- (should-equal (bool-vector nil nil) (bool-vector-not (bool-vector t t)))
- (should-error (bool-vector-not (vector)) :type 'wrong-type-argument))
-
-(ert-deftest bool-vector-count-consecutive ()
- (should-equal 0 (bool-vector-count-consecutive (bool-vector nil)
(bool-vector nil) 0))
- (should-equal 0 (bool-vector-count-consecutive (make-bool-vector 10 nil) t
0))
- (should-equal 10 (bool-vector-count-consecutive (make-bool-vector 10 nil)
nil 0))
- (should-equal 0 (bool-vector-count-consecutive (make-bool-vector 10 nil) t
1))
- (should-equal 9 (bool-vector-count-consecutive (make-bool-vector 10 nil) nil
1))
- (should-equal 0 (bool-vector-count-consecutive (make-bool-vector 10 nil) t
1))
- (should-equal 9 (bool-vector-count-consecutive (make-bool-vector 10 t) t 1))
- (should-equal 0 (bool-vector-count-consecutive (make-bool-vector 10 nil) t
8))
- (should-equal 2 (bool-vector-count-consecutive (make-bool-vector 10 nil) nil
8))
- (should-equal 2 (bool-vector-count-consecutive (make-bool-vector 10 t) t 8))
- (should-equal 10 (bool-vector-count-consecutive (make-bool-vector 10 t)
(make-bool-vector 10 t) 0))
- (should-equal 4 (bool-vector-count-consecutive (bool-vector t t t t nil t t
t t t) t 0))
- (should-equal 0 (bool-vector-count-consecutive (bool-vector t t t t nil t t
t t t) t 4))
- (should-equal 5 (bool-vector-count-consecutive (bool-vector t t t t nil t t
t t t) t 5))
- (should-error (bool-vector-count-consecutive (vector) nil 0) :type
'wrong-type-argument))
-
-(ert-deftest bool-vector-count-population ()
- (should-equal 0 (bool-vector-count-population (bool-vector)))
- (should-equal 0 (bool-vector-count-population (make-bool-vector 10 nil)))
- (should-equal 10 (bool-vector-count-population (make-bool-vector 10 t)))
- (should-equal 1 (bool-vector-count-population (bool-vector nil nil t nil)))
- (should-equal 1 (bool-vector-count-population (bool-vector nil nil nil t)))
- (should-equal 1 (bool-vector-count-population (bool-vector t nil nil nil)))
- (should-equal 2 (bool-vector-count-population (bool-vector t nil nil t)))
- (should-equal 2 (bool-vector-count-population (bool-vector t nil t nil)))
- (should-equal 3 (bool-vector-count-population (bool-vector t nil t t)))
- (should-error (bool-vector-count-population (vector)) :type
'wrong-type-argument))
-
-(ert-deftest bool-vector-subsetp ()
- (should (bool-vector-subsetp (bool-vector) (bool-vector)))
- (should (bool-vector-subsetp (bool-vector t) (bool-vector t)))
- (should (bool-vector-subsetp (bool-vector nil) (bool-vector t)))
- (should-not (bool-vector-subsetp (bool-vector t) (bool-vector nil)))
- (should (bool-vector-subsetp (bool-vector nil) (bool-vector nil)))
- (should (bool-vector-subsetp (bool-vector t t) (bool-vector t t)))
- (should (bool-vector-subsetp (bool-vector nil nil) (bool-vector t t)))
- (should (bool-vector-subsetp (bool-vector nil nil) (bool-vector t nil)))
- (should (bool-vector-subsetp (bool-vector nil nil) (bool-vector nil t)))
- (should-not (bool-vector-subsetp (bool-vector t nil) (bool-vector nil nil)))
- (should-not (bool-vector-subsetp (bool-vector nil t) (bool-vector nil nil)))
- (when (version<= "24.4" emacs-version)
- (should-error (bool-vector-subsetp (bool-vector nil) (bool-vector nil
nil)) :type 'wrong-length-argument))
- (should-error (bool-vector-subsetp (bool-vector) (vector)) :type
'wrong-type-argument)
- (should-error (bool-vector-subsetp (vector) (bool-vector)) :type
'wrong-type-argument)
- (should-error (bool-vector-subsetp (vector) (vector))) :type
'wrong-type-argument)
+ (should-equal (bool-vector nil nil) (bool-vector-not (bool-vector t t))))
(ert-deftest assoc ()
;; Fallback behaviour:
@@ -461,29 +333,6 @@
(should-equal 'l (cddadr xxxx))
(should-equal 'h (cdddar xxxx))))
-(ert-deftest special-form-p ()
- (should (special-form-p 'if))
- (should (special-form-p 'cond))
- (should-not (special-form-p 'when))
- (should-not (special-form-p 'defun))
- (should-not (special-form-p '+))
- (should-not (special-form-p nil))
- (should-not (special-form-p "macro"))
- (should-not (special-form-p '(macro . +))))
-
-(ert-deftest macrop ()
- (should (macrop 'lambda))
- (should (macrop 'defun))
- (should (macrop 'defmacro))
- (should-not (macrop 'defalias))
- (should-not (macrop 'foobar))
- (should-not (macrop 'if))
- (should-not (macrop '+))
- (should-not (macrop 1))
- (should-not (macrop nil))
- (should-not (macrop "macro"))
- (should (macrop '(macro . +))))
-
(ert-deftest subr-primitive-p ()
(should (subr-primitive-p (symbol-function 'identity))) ;function from
fns.c
(unless (fboundp 'subr-native-elisp-p)
@@ -491,128 +340,6 @@
(should-not (subr-primitive-p (symbol-function 'defun))) ;macro from
subr.el
(should-not (subr-primitive-p nil)))
-(ert-deftest = ()
- (should (compat-call = 0 0))
- (should (compat-call = 0 0 0))
- (should (compat-call = 0 0 0 0))
- (should (compat-call = 0 0 0 0 0))
- (should (compat-call = 0.0 0.0))
- (should (compat-call = +0.0 -0.0))
- (should (compat-call = 0.0 0.0 0.0))
- (should (compat-call = 0.0 0.0 0.0 0.0))
- (should-not (compat-call = 0 1))
- (should-not (compat-call = 0 0 1))
- (should-not (compat-call = 0 0 0 0 1))
- (should-error (compat-call = 0 0 'a) :type 'wrong-type-argument)
- (should-not (compat-call = 0 1 'a))
- (should-not (compat-call = 0.0 0.0 0.0 0.1)))
-
-(ert-deftest < ()
- (should-not (compat-call < 0 0))
- (should-not (compat-call < 0 0 0))
- (should-not (compat-call < 0 0 0 0))
- (should-not (compat-call < 0 0 0 0 0))
- (should-not (compat-call < 0.0 0.0))
- (should-not (compat-call < +0.0 -0.0))
- (should-not (compat-call < 0.0 0.0 0.0))
- (should-not (compat-call < 0.0 0.0 0.0 0.0))
- (should (compat-call < 0 1))
- (should-not (compat-call < 1 0))
- (should-not (compat-call < 0 0 1))
- (should (compat-call < 0 1 2))
- (should-not (compat-call < 2 1 0))
- (should-not (compat-call < 0 0 0 0 1))
- (should (compat-call < 0 1 2 3 4))
- (should-error (compat-call < 0 1 'a) :type 'wrong-type-argument)
- (should-not (compat-call < 0 0 'a))
- (should-not (compat-call < 0.0 0.0 0.0 0.1))
- (should (compat-call < -0.1 0.0 0.2 0.4))
- (should (compat-call < -0.1 0 0.2 0.4)))
-
-(ert-deftest > ()
- (should-not (compat-call > 0 0))
- (should-not (compat-call > 0 0 0))
- (should-not (compat-call > 0 0 0 0))
- (should-not (compat-call > 0 0 0 0 0))
- (should-not (compat-call > 0.0 0.0))
- (should-not (compat-call > +0.0 -0.0))
- (should-not (compat-call > 0.0 0.0 0.0))
- (should-not (compat-call > 0.0 0.0 0.0 0.0))
- (should (compat-call > 1 0))
- (should-not (compat-call > 1 0 0))
- (should-not (compat-call > 0 1 2))
- (should (compat-call > 2 1 0))
- (should-not (compat-call > 1 0 0 0 0))
- (should (compat-call > 4 3 2 1 0))
- (should-not (compat-call > 4 3 2 1 1))
- (should-error (compat-call > 1 0 'a) :type 'wrong-type-argument)
- (should-not (compat-call > 0 0 'a))
- (should-not (compat-call > 0.1 0.0 0.0 0.0))
- (should (compat-call > 0.4 0.2 0.0 -0.1))
- (should (compat-call > 0.4 0.2 0 -0.1)))
-
-(ert-deftest <= ()
- (should (compat-call <= 0 0))
- (should (compat-call <= 0 0 0))
- (should (compat-call <= 0 0 0 0))
- (should (compat-call <= 0 0 0 0 0))
- (should (compat-call <= 0.0 0.0))
- (should (compat-call <= +0.0 -0.0))
- (should (compat-call <= 0.0 0.0 0.0))
- (should (compat-call <= 0.0 0.0 0.0 0.0))
- (should-not (compat-call <= 1 0))
- (should-not (compat-call <= 1 0 0))
- (should (compat-call <= 0 1 2))
- (should-not (compat-call <= 2 1 0))
- (should-not (compat-call <= 1 0 0 0 0))
- (should-not (compat-call <= 4 3 2 1 0))
- (should-not (compat-call <= 4 3 2 1 1))
- (should (compat-call <= 0 1 2 3 4))
- (should (compat-call <= 1 1 2 3 4))
- (should-error (compat-call <= 0 0 'a) :type 'wrong-type-argument)
- (should-error (compat-call <= 0 1 'a) :type 'wrong-type-argument)
- (should-not (compat-call <= 1 0 'a))
- (should-not (compat-call <= 0.1 0.0 0.0 0.0))
- (should (compat-call <= 0.0 0.0 0.0 0.1))
- (should (compat-call <= -0.1 0.0 0.2 0.4))
- (should (compat-call <= -0.1 0.0 0.0 0.2 0.4))
- (should (compat-call <= -0.1 0.0 0 0.2 0.4))
- (should (compat-call <= -0.1 0 0.2 0.4))
- (should-not (compat-call <= 0.4 0.2 0.0 -0.1))
- (should-not (compat-call <= 0.4 0.2 0.0 0.0 -0.1))
- (should-not (compat-call <= 0.4 0.2 0 0.0 0.0 -0.1))
- (should-not (compat-call <= 0.4 0.2 0 -0.1)))
-
-(ert-deftest >= ()
- (should (compat-call >= 0 0))
- (should (compat-call >= 0 0 0))
- (should (compat-call >= 0 0 0 0))
- (should (compat-call >= 0 0 0 0 0))
- (should (compat-call >= 0.0 0.0))
- (should (compat-call >= +0.0 -0.0))
- (should (compat-call >= 0.0 0.0 0.0))
- (should (compat-call >= 0.0 0.0 0.0 0.0))
- (should (compat-call >= 1 0))
- (should (compat-call >= 1 0 0))
- (should-not (compat-call >= 0 1 2))
- (should (compat-call >= 2 1 0))
- (should (compat-call >= 1 0 0 0 0))
- (should (compat-call >= 4 3 2 1 0))
- (should (compat-call >= 4 3 2 1 1))
- (should-error (compat-call >= 0 0 'a) :type 'wrong-type-argument)
- (should-error (compat-call >= 1 0 'a) :type 'wrong-type-argument)
- (should-not (compat-call >= 0 1 'a))
- (should (compat-call >= 0.1 0.0 0.0 0.0))
- (should-not (compat-call >= 0.0 0.0 0.0 0.1))
- (should-not (compat-call >= -0.1 0.0 0.2 0.4))
- (should-not (compat-call >= -0.1 0.0 0.0 0.2 0.4))
- (should-not (compat-call >= -0.1 0.0 0 0.2 0.4))
- (should-not (compat-call >= -0.1 0 0.2 0.4))
- (should (compat-call >= 0.4 0.2 0.0 -0.1))
- (should (compat-call >= 0.4 0.2 0.0 0.0 -0.1))
- (should (compat-call >= 0.4 0.2 0 0.0 0.0 -0.1))
- (should (compat-call >= 0.4 0.2 0 -0.1)))
-
(ert-deftest mapcan ()
(should-not (mapcan #'identity nil))
(should-equal (list 1)
@@ -879,11 +606,6 @@
(should-equal '(1 2 3 4) (flatten-tree '((1) nil 2 ((3 4)))))
(should-equal '(1 2 3 4) (flatten-tree '(((1 nil)) 2 (((3 nil nil) 4))))))
-(ert-deftest delete-consecutive-dups ()
- (should-equal '(1 2 3 4) (delete-consecutive-dups '(1 2 3 4)))
- (should-equal '(1 2 3 4) (delete-consecutive-dups '(1 2 2 3 4 4)))
- (should-equal '(1 2 3 2 4) (delete-consecutive-dups '(1 2 2 3 2 4 4))))
-
(ert-deftest sort ()
(should-equal (list 1 2 3) (compat-call sort (list 1 2 3) #'<))
(should-equal (list 1 2 3) (compat-call sort (list 3 2 1) #'<))
@@ -903,23 +625,6 @@
(should (string-greaterp "aaab" "aaaa"))
(should-not (string-greaterp "aaaa" "aaab")))
-(ert-deftest string-suffix-p ()
- (should (string-suffix-p "a" "abba"))
- (should (string-suffix-p "ba" "ba" "abba"))
- (should (string-suffix-p "abba" "abba"))
- (should-not (string-suffix-p "a" "ABBA"))
- (should-not (string-suffix-p "bA" "ABBA"))
- (should-not (string-suffix-p "aBBA" "ABBA"))
- (should-not (string-suffix-p "c" "ABBA"))
- (should-not (string-suffix-p "c" "abba"))
- (should-not (string-suffix-p "cddc" "abba"))
- (should-not (string-suffix-p "aabba" "abba")))
-
-(ert-deftest split-string ()
- (should-equal '("a" "b" "c") (split-string "a b c"))
- (should-equal '("..a.." "..b.." "..c..") (split-string "..a.. ..b.. ..c.."))
- (should-equal '("a" "b" "c") (split-string "..a.. ..b.. ..c.." nil nil
"\\.+")))
-
(ert-deftest string-clean-whitespace ()
(should-equal "a b c" (string-clean-whitespace "a b c"))
(should-equal "a b c" (string-clean-whitespace " a b c"))
@@ -972,48 +677,6 @@
(should-equal "aaa" (string-chop-newline "aaa\n"))
(should-equal "aaa\n" (string-chop-newline "aaa\n\n")))
-(ert-deftest string-empty-p ()
- (should (string-empty-p ""))
- (should-not (string-empty-p " "))
- (should (string-empty-p (make-string 0 ?x)))
- (should-not (string-empty-p (make-string 1 ?x))))
-
-(ert-deftest string-join ()
- (should-equal "" (string-join '("")))
- (should-equal "" (string-join '("") " "))
- (should-equal "a" (string-join '("a")))
- (should-equal "a" (string-join '("a") " "))
- (should-equal "abc" (string-join '("a" "b" "c")))
- (should-equal "a b c" (string-join '("a" "b" "c") " ")))
-
-(ert-deftest string-blank-p ()
- (should-equal 0 (string-blank-p ""))
- (should-equal 0 (string-blank-p " "))
- (should-equal 0 (string-blank-p (make-string 0 ?x)))
- (should-not (string-blank-p (make-string 1 ?x))))
-
-(ert-deftest string-remove-prefix ()
- (should-equal "" (string-remove-prefix "" ""))
- (should-equal "a" (string-remove-prefix "" "a"))
- (should-equal "" (string-remove-prefix "a" ""))
- (should-equal "bc" (string-remove-prefix "a" "abc"))
- (should-equal "abc" (string-remove-prefix "c" "abc"))
- (should-equal "bbcc" (string-remove-prefix "aa" "aabbcc"))
- (should-equal "aabbcc" (string-remove-prefix "bb" "aabbcc"))
- (should-equal "aabbcc" (string-remove-prefix "cc" "aabbcc"))
- (should-equal "aabbcc" (string-remove-prefix "dd" "aabbcc")))
-
-(ert-deftest string-remove-suffix ()
- (should-equal "" (string-remove-suffix "" ""))
- (should-equal "a" (string-remove-suffix "" "a"))
- (should-equal "" (string-remove-suffix "a" ""))
- (should-equal "abc" (string-remove-suffix "a" "abc"))
- (should-equal "ab" (string-remove-suffix "c" "abc"))
- (should-equal "aabbcc" (string-remove-suffix "aa" "aabbcc"))
- (should-equal "aabbcc" (string-remove-suffix "bb" "aabbcc"))
- (should-equal "aabb" (string-remove-suffix "cc" "aabbcc"))
- (should-equal "aabbcc" (string-remove-suffix "dd" "aabbcc")))
-
(ert-deftest string-distance ()
(should-equal 3 (string-distance "kitten" "sitting")) ;from wikipedia
(if (version<= "28" emacs-version) ;trivial examples
@@ -1273,34 +936,6 @@
;; thrown.
(should-error (string-replace "" "x" "abc") :type 'wrong-length-argument)))
-(ert-deftest hash-table-keys ()
- (let ((ht (make-hash-table)))
- (should-not (hash-table-keys ht))
- (puthash 1 'one ht)
- (should-equal '(1) (hash-table-keys ht))
- (puthash 1 'one ht)
- (should-equal '(1) (hash-table-keys ht))
- (puthash 2 'two ht)
- (should (memq 1 (hash-table-keys ht)))
- (should (memq 2 (hash-table-keys ht)))
- (should (= 2 (length (hash-table-keys ht))))
- (remhash 1 ht)
- (should-equal '(2) (hash-table-keys ht))))
-
-(ert-deftest hash-table-values ()
- (let ((ht (make-hash-table)))
- (should-not (hash-table-values ht))
- (puthash 1 'one ht)
- (should-equal '(one) (hash-table-values ht))
- (puthash 1 'one ht)
- (should-equal '(one) (hash-table-values ht))
- (puthash 2 'two ht)
- (should (memq 'one (hash-table-values ht)))
- (should (memq 'two (hash-table-values ht)))
- (should (= 2 (length (hash-table-values ht))))
- (remhash 1 ht)
- (should-equal '(two) (hash-table-values ht))))
-
(ert-deftest when-let* ()
(should-equal "second"
(when-let*
diff --git a/compat.texi b/compat.texi
index 7f85fd11de..24d284c687 100644
--- a/compat.texi
+++ b/compat.texi
@@ -69,7 +69,6 @@ Introduction
Support
-* Emacs 24.4:: Compatibility support for Emacs 24.4
* Emacs 25.1:: Compatibility support for Emacs 25.1
* Emacs 26.1:: Compatibility support for Emacs 26.1
* Emacs 27.1:: Compatibility support for Emacs 27.1
@@ -96,14 +95,17 @@ for Emacs Lisp. That is to say by using Compat, an Elisp
package does
not have to make the decision to either use new and useful functionality
or support old versions of Emacs.
-Version 24.4 is chosen as the oldest version we can reasonably support,
-since subr-x was introduced in this version.
+Version 24.4 is chosen as the oldest version we can support, since
+Elisp has seen significant semantic changes at that version. On the
+library level subr-x was introduced in 24.4. Most popular Emacs
+packages which could potentially benefit from Compat already require
+24.4 or even newer versions of Emacs. The long time release of CentOS
+7, which still distributes Emacs 24.3 reaches end of life soon (2024).
Note that Compat provides functions with extended functionality for
commands that are already defined (@code{sort}, @code{assoc},
-@code{seq}, @dots{}). These functions must be looked up explicitly
-with @code{compat-function} or called explicitly with
-@code{compat-call}.
+@dots{}). These functions must be looked up explicitly with
+@code{compat-function} or called explicitly with @code{compat-call}.
@node Usage
@section Usage
@@ -219,7 +221,6 @@ This section goes into the features that Compat manages and
doesn't
manage to provide for each Emacs version.
@menu
-* Emacs 24.4:: Compatibility support for Emacs 24.4
* Emacs 25.1:: Compatibility support for Emacs 25.1
* Emacs 26.1:: Compatibility support for Emacs 26.1
* Emacs 27.1:: Compatibility support for Emacs 27.1
@@ -227,260 +228,6 @@ manage to provide for each Emacs version.
* Emacs 29.1:: Compatibility support for Emacs 29.1
@end menu
-@node Emacs 24.4
-@section Emacs 24.4
-
-@subsection Implicit Definitions
-The following functions and macros implemented in 24.4, and are provided
-by Compat:
-
-@c copied from lispref/eval.texi
-@defun special-form-p object
-This predicate tests whether its argument is a special form, and returns
-@code{t} if so, @code{nil} otherwise.
-
-@xref{Special Forms,,,elisp}.
-@end defun
-
-@c copied from lispref/macros.texi
-@defun macrop object
-This predicate tests whether its argument is a macro, and returns
-@code{t} if so, @code{nil} otherwise.
-
-@xref{Simple Macro,,,elisp}.
-@end defun
-
-@c copied form lispref/strings.texi
-@defun string-suffix-p suffix string &optional ignore-case
-This function returns non-@code{nil} if @var{suffix} is a suffix of
-@var{string}; i.e., if @var{string} ends with @var{suffix}. If the
-optional argument @var{ignore-case} is non-@code{nil}, the comparison
-ignores case differences.
-
-@xref{Text Comparison,,,elisp}.
-@end defun
-
-@c based on lisp/subr.el
-@defun delete-consecutive-dups list &optional circular
-Destructively remove @code{equal} consecutive duplicates from
-@var{list}. First and last elements are considered consecutive if
-@var{circular} is non-nil.
-@end defun
-
-@c copied from lispref/control.texi
-@defun define-error name message &optional parent
- In order for a symbol to be an error symbol, it must be defined with
-@code{define-error} which takes a parent condition (defaults to
-@code{error}). This parent defines the conditions that this kind of
-error belongs to. The transitive set of parents always includes the
-error symbol itself, and the symbol @code{error}. Because quitting is
-not considered an error, the set of parents of @code{quit} is just
-@code{(quit)}.
-
-@xref{Error Symbols,,,elisp}.
-@end defun
-
-@c copied from lispref/sequences.texi
-@defun bool-vector-exclusive-or a b &optional c
-Return @dfn{bitwise exclusive or} of bool vectors @var{a} and @var{b}.
-If optional argument @var{c} is given, the result of this operation is
-stored into @var{c}. All arguments should be bool vectors of the same
-length.
-
-@xref{Bool-Vectors,,,elisp}.
-@end defun
-
-@c copied from lispref/sequences.texi
-@defun bool-vector-union a b &optional c
-Return @dfn{bitwise or} of bool vectors @var{a} and @var{b}. If
-optional argument @var{c} is given, the result of this operation is
-stored into @var{c}. All arguments should be bool vectors of the same
-length.
-
-@xref{Bool-Vectors,,,elisp}.
-@end defun
-
-@c copied from lispref/sequences.texi
-@defun bool-vector-intersection a b &optional c
-Return @dfn{bitwise and} of bool vectors @var{a} and @var{b}. If
-optional argument @var{c} is given, the result of this operation is
-stored into @var{c}. All arguments should be bool vectors of the same
-length.
-
-@xref{Bool-Vectors,,,elisp}.
-@end defun
-
-@c copied from lispref/sequences.texi
-@defun bool-vector-set-difference a b &optional c
-Return @dfn{set difference} of bool vectors @var{a} and @var{b}. If
-optional argument @var{c} is given, the result of this operation is
-stored into @var{c}. All arguments should be bool vectors of the same
-length.
-
-@xref{Bool-Vectors,,,elisp}.
-@end defun
-
-@c copied from lispref/sequences.texi
-@defun bool-vector-not a &optional b
-Return @dfn{set complement} of bool vector @var{a}. If optional
-argument @var{b} is given, the result of this operation is stored into
-@var{b}. All arguments should be bool vectors of the same length.
-
-@xref{Bool-Vectors,,,elisp}.
-@end defun
-
-@c copied from lispref/sequences.texi
-@defun bool-vector-subsetp a b
-Return @code{t} if every @code{t} value in @var{a} is also @code{t} in
-@var{b}, @code{nil} otherwise. All arguments should be bool vectors of
-the same length.
-
-@xref{Bool-Vectors,,,elisp}.
-@end defun
-
-@c copied from lispref/sequences.texi
-@defun bool-vector-count-consecutive a b i
-Return the number of consecutive elements in @var{a} equal @var{b}
-starting at @var{i}. @code{a} is a bool vector, @var{b} is @code{t} or
-@code{nil}, and @var{i} is an index into @code{a}.
-
-@xref{Bool-Vectors,,,elisp}.
-@end defun
-
-@c copied from lispref/sequences.texi
-@defun bool-vector-count-population a
-Return the number of elements that are @code{t} in bool vector @var{a}.
-
-@xref{Bool-Vectors,,,elisp}.
-@end defun
-
-@c copied from lispref/minibuf.texi
-@defun completion-table-with-cache function &optional ignore-case
-This is a wrapper for @code{completion-table-dynamic} that saves the
-last argument-result pair. This means that multiple lookups with the
-same argument only need to call @var{function} once. This can be useful
-when a slow operation is involved, such as calling an external process.
-
-@xref{Programmed Completion,,,elisp}.
-@end defun
-
-@c copied from lispref/display.texi
-@defun face-spec-set face spec &optional spec-type
-This function applies @var{spec} as a face spec for @code{face}.
-@var{spec} should be a face spec, as described in the above
-documentation for @code{defface}.
-
-This function also defines @var{face} as a valid face name if it is not
-already one, and (re)calculates its attributes on existing frames.
-
-The optional argument @var{spec-type} determines which spec to set. If
-it is omitted or @code{nil} or @code{face-override-spec}, this function
-sets the @dfn{override spec}, which overrides face specs on @var{face}
-of all the other types mentioned below. This is useful when calling
-this function outside of Custom code. If @var{spec-type} is
-@code{customized-face} or @code{saved-face}, this function sets the
-customized spec or the saved custom spec, respectively. If it is
-@code{face-defface-spec}, this function sets the default face spec (the
-same one set by @code{defface}). If it is @code{reset}, this function
-clears out all customization specs and override specs from @var{face}
-(in this case, the value of @var{spec} is ignored). The effect of any
-other value of @var{spec-type} on the face specs is reserved for
-internal use, but the function will still define @var{face} itself and
-recalculate its attributes, as described above.
-
-@xref{Defining Faces,,,elisp}.
-@end defun
-
-@subsection Explicit Definitions
-These functions must be called explicitly via @code{compat-call},
-since their calling convention changed:
-
-@c all copied from lispref/numbers.texi
-@defun compat-call@ = number-or-marker &rest number-or-markers
-This function tests whether all its arguments are numerically equal, and
-returns @code{t} if so, @code{nil} otherwise.
-
-@xref{Comparison of Numbers,,,elisp}.
-@end defun
-@defun compat-call@ < number-or-marker &rest number-or-markers
-This function tests whether each argument is strictly less than the
-following argument. It returns @code{t} if so, @code{nil} otherwise.
-
-@xref{Comparison of Numbers,,,elisp}.
-@end defun
-@defun compat-call@ > number-or-marker &rest number-or-markers
-This function tests whether each argument is strictly greater than the
-following argument. It returns @code{t} if so, @code{nil} otherwise.
-
-@xref{Comparison of Numbers,,,elisp}.
-@end defun
-@defun compat-call@ <= number-or-marker &rest number-or-markers
-This function tests whether each argument is less than or equal to the
-following argument. It returns @code{t} if so, @code{nil} otherwise.
-
-@xref{Comparison of Numbers,,,elisp}.
-@end defun
-@defun compat-call@ >= number-or-marker &rest number-or-markers
-This function tests whether each argument is greater than or equal to
-the following argument. It returns @code{t} if so, @code{nil}
-otherwise.
-
-@xref{Comparison of Numbers,,,elisp}.
-@end defun
-
-These functions differ from the previous implementation in that they
-allow for more than two argument to be compared.
-
-@c based on lispref/strings.texi
-@defun compat-call@ split-string string &optional separators omit-nulls trim
-This function splits @var{string} into substrings based on the regular
-expression @var{separators} (@pxref{Regular Expressions,,,elisp}). Each
-match for @var{separators} defines a splitting point; the substrings
-between splitting points are made into a list, which is returned.
-
-@pxref{Creating Strings,,,elisp} for more details.
-
-This version handles the optional argument @var{trim}. If it is
-non-@code{nil}, it should be a regular expression to match text to trim
-from the beginning and end of each substring. If trimming makes the
-substring empty, it is treated as null.
-@end defun
-
-@subsection Missing Definitions
-Compat does not provide support for the following Lisp features
-implemented in 24.4:
-
-@itemize
-@item
-Allowing the second optional argument to @code{eval} to specify a
-lexical environment.
-@item
-The @code{define-alternatives} macro.
-@item
-Support for the @code{defalias-fset-function} symbol property.
-@item
-The @code{group-gid} and @code{groupd-read-gid} functions.
-@item
-The @code{pre-redisplay-function} hook.
-@item
-Allowing for @code{with-demoted-errors} to take a additional argument
-@code{format}.
-@item
-The @code{add-face-text-property} function.
-@item
-No @code{tty-setup-hook} hook.
-@item
-The @code{get-pos-property} function.
-@item
-The @code{define-advice} macro.
-@item
-Support for generators.
-@item
-The @code{string-trim}, @code{string-trim-left} and
-@code{string-trim-right} functions. These are instead provided as
-explicit functions as part of @ref{Emacs 26.1} support.
-@end itemize
-
@node Emacs 25.1
@section Emacs 25.1