* lisp/char-fold.el: Rename from character-fold.el.

* lisp/replace.el (replace-char-fold): Rename from replace-character-fold.
* test/automated/char-fold-tests.el: Rename from character-fold-tests.el.
http://lists.gnu.org/archive/html/emacs-devel/2015-12/msg00529.html

diff --git a/doc/emacs/search.texi b/doc/emacs/search.texi
index 7958a4a2bfa13480e14f0b8b1ce302555fe995d9..d841934c8559b0fe131586d6fd54d9eb8350abfc 100644 (file)
--- a/doc/emacs/search.texi
+++ b/doc/emacs/search.texi
@@ -1264,13 +1264,13 @@ but match under character folding are known as @dfn{equivalent
 character sequences}.
 
 @kindex M-s ' @r{(Incremental Search)}
 character sequences}.
 
 @kindex M-s ' @r{(Incremental Search)}

-@findex isearch-toggle-character-fold
+@findex isearch-toggle-char-fold

   Generally, search commands in Emacs do not by default perform
 character folding in order to match equivalent character sequences.
 You can enable this behavior by customizing the variable
   Generally, search commands in Emacs do not by default perform
 character folding in order to match equivalent character sequences.
 You can enable this behavior by customizing the variable

-@code{search-default-mode} to @code{character-fold-to-regexp}.
+@code{search-default-mode} to @code{char-fold-to-regexp}.

 @xref{Search Customizations}.  Within an incremental search, typing
 @xref{Search Customizations}.  Within an incremental search, typing

-@kbd{M-s '} (@code{isearch-toggle-character-fold}) toggles character
+@kbd{M-s '} (@code{isearch-toggle-char-fold}) toggles character

 folding, but only for that search.  (Replace commands have a different
 default, controlled by a separate option; see @ref{Replacement and Lax
 Matches}.)
 folding, but only for that search.  (Replace commands have a different
 default, controlled by a separate option; see @ref{Replacement and Lax
 Matches}.)


@@ -1481,7 +1481,7 @@ replacement is done without case conversion.
 (@pxref{Lax Search, character folding}) when looking for the text to
 replace.  To enable character folding for matching in
 @code{query-replace} and @code{replace-string}, set the variable
 (@pxref{Lax Search, character folding}) when looking for the text to
 replace.  To enable character folding for matching in
 @code{query-replace} and @code{replace-string}, set the variable

-@code{replace-character-fold} to a non-@code{nil} value.  (This
+@code{replace-char-fold} to a non-@code{nil} value.  (This

 setting does not affect the replacement text, only how Emacs finds the
 text to replace.  It also doesn't affect @code{replace-regexp}.)
 
 setting does not affect the replacement text, only how Emacs finds the
 text to replace.  It also doesn't affect @code{replace-regexp}.)
 

diff --git a/etc/NEWS b/etc/NEWS
index 3031cab4782c415106fc963172691fa59778eae6..670465f2ab852060aed14c4d713f80601aa3d3f9 100644 (file)
--- a/etc/NEWS
+++ b/etc/NEWS
@@ -633,11 +633,11 @@ as many other symbols like U+249C (PARENTHESIZED LATIN SMALL LETTER
 A).
 
 Character folding is enabled by customizing 'search-default-mode' to
 A).
 
 Character folding is enabled by customizing 'search-default-mode' to

-the value 'character-fold-to-regexp'.  You can also toggle character
+the value 'char-fold-to-regexp'.  You can also toggle character

 folding in the middle of a search by typing 'M-s ''.
 
 'query-replace' honors character folding if the new variable
 folding in the middle of a search by typing 'M-s ''.
 
 'query-replace' honors character folding if the new variable

-'replace-character-fold' is customized to a non-nil value.
+'replace-char-fold' is customized to a non-nil value.

 
 +++
 *** New user option 'search-default-mode'.
 
 +++
 *** New user option 'search-default-mode'.


@@ -647,9 +647,9 @@ value, nil specifies that Isearch does literal searches (however,
 as in previous Emacs versions).
 
 +++
 as in previous Emacs versions).
 
 +++

-*** New function 'character-fold-to-regexp' can be used
+*** New function 'char-fold-to-regexp' can be used

 by searching commands to produce a regexp matching anything that
 by searching commands to produce a regexp matching anything that

-character-folds into STRING.
+char-folds into STRING.

 
 +++
 *** The new 'M-s M-w' key binding uses eww to search the web for the
 
 +++
 *** The new 'M-s M-w' key binding uses eww to search the web for the

diff --git a/lisp/character-fold.el b/lisp/char-fold.el
similarity index 85%
rename from lisp/character-fold.el
rename to lisp/char-fold.el
index 2d3a8c67fa566aca264a4d2e61a4e2d2f154d455..68bea29ea45b35d842b99892835b89510f9f4a61 100644 (file)
--- a/lisp/character-fold.el
+++ b/lisp/char-fold.el
@@ -1,4 +1,4 @@
-;;; character-fold.el --- match unicode to similar ASCII -*- lexical-binding: t; -*-
+;;; char-fold.el --- match unicode to similar ASCII -*- lexical-binding: t; -*-

 
 ;; Copyright (C) 2015-2016 Free Software Foundation, Inc.
 
 
 ;; Copyright (C) 2015-2016 Free Software Foundation, Inc.
 


@@ -22,12 +22,12 @@
 
 ;;; Code:
 
 
 ;;; Code:
 

-(eval-and-compile (put 'character-fold-table 'char-table-extra-slots 1))
+(eval-and-compile (put 'char-fold-table 'char-table-extra-slots 1))

 \f
 \f

-(defconst character-fold-table
+(defconst char-fold-table

   (eval-when-compile
   (eval-when-compile

-    (let ((equiv (make-char-table 'character-fold-table))
-          (equiv-multi (make-char-table 'character-fold-table))
+    (let ((equiv (make-char-table 'char-fold-table))
+          (equiv-multi (make-char-table 'char-fold-table))

           (table (unicode-property-table-internal 'decomposition)))
       (set-char-table-extra-slot equiv 0 equiv-multi)
 
           (table (unicode-property-table-internal 'decomposition)))
       (set-char-table-extra-slot equiv 0 equiv-multi)
 


@@ -115,7 +115,7 @@
        equiv)
       equiv))
   "Used for folding characters of the same group during search.
        equiv)
       equiv))
   "Used for folding characters of the same group during search.

-This is a char-table with the `character-fold-table' subtype.
+This is a char-table with the `char-fold-table' subtype.

 
 Let us refer to the character in question by char-x.
 Each entry is either nil (meaning char-x only matches literally)
 
 Let us refer to the character in question by char-x.
 Each entry is either nil (meaning char-x only matches literally)


@@ -136,18 +136,18 @@ For instance, the default alist for ?f includes:
 
 Exceptionally for the space character (32), ALIST is ignored.")
 
 
 Exceptionally for the space character (32), ALIST is ignored.")
 

-(defun character-fold--make-space-string (n)
+(defun char-fold--make-space-string (n)

   "Return a string that matches N spaces."
   (format "\\(?:%s\\|%s\\)"
           (make-string n ?\s)
           (apply #'concat
   "Return a string that matches N spaces."
   (format "\\(?:%s\\|%s\\)"
           (make-string n ?\s)
           (apply #'concat

-                 (make-list n (or (aref character-fold-table ?\s) " ")))))
+                 (make-list n (or (aref char-fold-table ?\s) " ")))))

 
 ;;;###autoload
 
 ;;;###autoload

-(defun character-fold-to-regexp (string &optional _lax from)
-  "Return a regexp matching anything that character-folds into STRING.
+(defun char-fold-to-regexp (string &optional _lax from)
+  "Return a regexp matching anything that char-folds into STRING.

 Any character in STRING that has an entry in
 Any character in STRING that has an entry in

-`character-fold-table' is replaced with that entry (which is a
+`char-fold-table' is replaced with that entry (which is a

 regexp) and other characters are `regexp-quote'd.
 
 If the resulting regexp would be too long for Emacs to handle,
 regexp) and other characters are `regexp-quote'd.
 
 If the resulting regexp would be too long for Emacs to handle,


@@ -156,7 +156,7 @@ just return the result of calling `regexp-quote' on STRING.
 FROM is for internal use.  It specifies an index in the STRING
 from which to start."
   (let* ((spaces 0)
 FROM is for internal use.  It specifies an index in the STRING
 from which to start."
   (let* ((spaces 0)

-         (multi-char-table (char-table-extra-slot character-fold-table 0))
+         (multi-char-table (char-table-extra-slot char-fold-table 0))

          (i (or from 0))
          (end (length string))
          (out nil))
          (i (or from 0))
          (end (length string))
          (out nil))


@@ -172,9 +172,9 @@ from which to start."
       (pcase (aref string i)
         (`?\s (setq spaces (1+ spaces)))
         (c (when (> spaces 0)
       (pcase (aref string i)
         (`?\s (setq spaces (1+ spaces)))
         (c (when (> spaces 0)

-             (push (character-fold--make-space-string spaces) out)
+             (push (char-fold--make-space-string spaces) out)

              (setq spaces 0))
              (setq spaces 0))

-           (let ((regexp (or (aref character-fold-table c)
+           (let ((regexp (or (aref char-fold-table c)

                              (regexp-quote (string c))))
                  ;; Long string.  The regexp would probably be too long.
                  (alist (unless (> end 50)
                              (regexp-quote (string c))))
                  ;; Long string.  The regexp would probably be too long.
                  (alist (unless (> end 50)


@@ -206,13 +206,13 @@ from which to start."
                                        (let ((length (car entry))
                                              (suffix-regexp (cdr entry)))
                                          (concat suffix-regexp
                                        (let ((length (car entry))
                                              (suffix-regexp (cdr entry)))
                                          (concat suffix-regexp

-                                                 (character-fold-to-regexp subs nil length))))
+                                                 (char-fold-to-regexp subs nil length))))

                                      `((0 . ,regexp) . ,matched-entries) "\\|")
                           "\\)"))))
                    out))))
       (setq i (1+ i)))
     (when (> spaces 0)
                                      `((0 . ,regexp) . ,matched-entries) "\\|")
                           "\\)"))))
                    out))))
       (setq i (1+ i)))
     (when (> spaces 0)

-      (push (character-fold--make-space-string spaces) out))
+      (push (char-fold--make-space-string spaces) out))

     (let ((regexp (apply #'concat (nreverse out))))
       ;; Limited by `MAX_BUF_SIZE' in `regex.c'.
       (if (> (length regexp) 5000)
     (let ((regexp (apply #'concat (nreverse out))))
       ;; Limited by `MAX_BUF_SIZE' in `regex.c'.
       (if (> (length regexp) 5000)


@@ -221,22 +221,22 @@ from which to start."
 
 \f
 ;;; Commands provided for completeness.
 
 \f
 ;;; Commands provided for completeness.

-(defun character-fold-search-forward (string &optional bound noerror count)
-  "Search forward for a character-folded version of STRING.
-STRING is converted to a regexp with `character-fold-to-regexp',
+(defun char-fold-search-forward (string &optional bound noerror count)
+  "Search forward for a char-folded version of STRING.
+STRING is converted to a regexp with `char-fold-to-regexp',

 which is searched for with `re-search-forward'.
 BOUND NOERROR COUNT are passed to `re-search-forward'."
   (interactive "sSearch: ")
 which is searched for with `re-search-forward'.
 BOUND NOERROR COUNT are passed to `re-search-forward'."
   (interactive "sSearch: ")

-  (re-search-forward (character-fold-to-regexp string) bound noerror count))
+  (re-search-forward (char-fold-to-regexp string) bound noerror count))

 
 

-(defun character-fold-search-backward (string &optional bound noerror count)
-  "Search backward for a character-folded version of STRING.
-STRING is converted to a regexp with `character-fold-to-regexp',
+(defun char-fold-search-backward (string &optional bound noerror count)
+  "Search backward for a char-folded version of STRING.
+STRING is converted to a regexp with `char-fold-to-regexp',

 which is searched for with `re-search-backward'.
 BOUND NOERROR COUNT are passed to `re-search-backward'."
   (interactive "sSearch: ")
 which is searched for with `re-search-backward'.
 BOUND NOERROR COUNT are passed to `re-search-backward'."
   (interactive "sSearch: ")

-  (re-search-backward (character-fold-to-regexp string) bound noerror count))
+  (re-search-backward (char-fold-to-regexp string) bound noerror count))

 
 

-(provide 'character-fold)
+(provide 'char-fold)

 
 

-;;; character-fold.el ends here
+;;; char-fold.el ends here

diff --git a/lisp/isearch.el b/lisp/isearch.el
index 418d9ea273a3a118a5712f565335fd38ffa9340a..e4de0b627e38fa156b1bac67daaf9c3558eb159b 100644 (file)
--- a/lisp/isearch.el
+++ b/lisp/isearch.el
@@ -222,7 +222,7 @@ It is nil if none yet.")
 Default value, nil, means edit the string instead."
   :type 'boolean)
 
 Default value, nil, means edit the string instead."
   :type 'boolean)
 

-(autoload 'character-fold-to-regexp "character-fold")
+(autoload 'char-fold-to-regexp "char-fold")

 
 (defcustom search-default-mode nil
   "Default mode to use when starting isearch.
 
 (defcustom search-default-mode nil
   "Default mode to use when starting isearch.


@@ -236,7 +236,7 @@ isearch).
 If a function, use that function as an `isearch-regexp-function'.
 Example functions (and the keys to toggle them during isearch)
 are `word-search-regexp' \(`\\[isearch-toggle-word]'), `isearch-symbol-regexp'
 If a function, use that function as an `isearch-regexp-function'.
 Example functions (and the keys to toggle them during isearch)
 are `word-search-regexp' \(`\\[isearch-toggle-word]'), `isearch-symbol-regexp'

-\(`\\[isearch-toggle-symbol]'), and `character-fold-to-regexp' \(`\\[isearch-toggle-character-fold]')."
+\(`\\[isearch-toggle-symbol]'), and `char-fold-to-regexp' \(`\\[isearch-toggle-char-fold]')."

   ;; :type is set below by `isearch-define-mode-toggle'.
   :type '(choice (const :tag "Literal search" nil)
                  (const :tag "Regexp search" t)
   ;; :type is set below by `isearch-define-mode-toggle'.
   :type '(choice (const :tag "Literal search" nil)
                  (const :tag "Regexp search" t)


@@ -718,7 +718,7 @@ Type \\[isearch-toggle-invisible] to toggle search in invisible text.
 Type \\[isearch-toggle-regexp] to toggle regular-expression mode.
 Type \\[isearch-toggle-word] to toggle word mode.
 Type \\[isearch-toggle-symbol] to toggle symbol mode.
 Type \\[isearch-toggle-regexp] to toggle regular-expression mode.
 Type \\[isearch-toggle-word] to toggle word mode.
 Type \\[isearch-toggle-symbol] to toggle symbol mode.

-Type \\[isearch-toggle-character-fold] to toggle character folding.
+Type \\[isearch-toggle-char-fold] to toggle character folding.

 
 Type \\[isearch-toggle-lax-whitespace] to toggle whitespace matching.
 In incremental searches, a space or spaces normally matches any whitespace
 
 Type \\[isearch-toggle-lax-whitespace] to toggle whitespace matching.
 In incremental searches, a space or spaces normally matches any whitespace


@@ -1546,9 +1546,9 @@ The command then executes BODY and updates the isearch prompt."
 Turning on word search turns off regexp mode.")
 (isearch-define-mode-toggle symbol "_" isearch-symbol-regexp "\
 Turning on symbol search turns off regexp mode.")
 Turning on word search turns off regexp mode.")
 (isearch-define-mode-toggle symbol "_" isearch-symbol-regexp "\
 Turning on symbol search turns off regexp mode.")

-(isearch-define-mode-toggle character-fold "'" character-fold-to-regexp "\
+(isearch-define-mode-toggle char-fold "'" char-fold-to-regexp "\

 Turning on character-folding turns off regexp mode.")
 Turning on character-folding turns off regexp mode.")

-(put 'character-fold-to-regexp 'isearch-message-prefix "char-fold ")
+(put 'char-fold-to-regexp 'isearch-message-prefix "char-fold ")

 
 (isearch-define-mode-toggle regexp "r" nil nil
   (setq isearch-regexp (not isearch-regexp))
 
 (isearch-define-mode-toggle regexp "r" nil nil
   (setq isearch-regexp (not isearch-regexp))

diff --git a/lisp/menu-bar.el b/lisp/menu-bar.el
index 6571a4b9d4f19cb7e8cdb1b9cff9889c922180d2..640395e8d7d0778ac33249777a68fb74de0e5f96 100644 (file)
--- a/lisp/menu-bar.el
+++ b/lisp/menu-bar.el
@@ -1257,7 +1257,7 @@ mail status in mode line"))
 (defvar menu-bar-search-options-menu
   (let ((menu (make-sparse-keymap "Search Options")))
 
 (defvar menu-bar-search-options-menu
   (let ((menu (make-sparse-keymap "Search Options")))
 

-    (dolist (x '((character-fold-to-regexp "Fold Characters" "Character folding")
+    (dolist (x '((char-fold-to-regexp "Fold Characters" "Character folding")

                  (isearch-symbol-regexp "Whole Symbols" "Whole symbol")
                  (word-search-regexp "Whole Words" "Whole word")))
       (bindings--define-key menu (vector (nth 0 x))
                  (isearch-symbol-regexp "Whole Symbols" "Whole symbol")
                  (word-search-regexp "Whole Words" "Whole word")))
       (bindings--define-key menu (vector (nth 0 x))

diff --git a/lisp/replace.el b/lisp/replace.el
index 26e5875dc08860d665ef8b23b62b916efc952227..fe90062cc8a02e1a8e90772657f9d7e75339dc35 100644 (file)
--- a/lisp/replace.el
+++ b/lisp/replace.el
@@ -33,7 +33,7 @@
   :type 'boolean
   :group 'matching)
 
   :type 'boolean
   :group 'matching)
 

-(defcustom replace-character-fold nil
+(defcustom replace-char-fold nil

   "Non-nil means replacement commands should do character folding in matches.
 This means, for instance, that \\=' will match a large variety of
 unicode quotes.
   "Non-nil means replacement commands should do character folding in matches.
 This means, for instance, that \\=' will match a large variety of
 unicode quotes.


@@ -324,7 +324,7 @@ If `replace-lax-whitespace' is non-nil, a space or spaces in the string
 to be replaced will match a sequence of whitespace chars defined by the
 regexp in `search-whitespace-regexp'.
 
 to be replaced will match a sequence of whitespace chars defined by the
 regexp in `search-whitespace-regexp'.
 

-If `replace-character-fold' is non-nil, matching uses character folding,
+If `replace-char-fold' is non-nil, matching uses character folding,

 i.e. it ignores diacritics and other differences between equivalent
 character strings.
 
 i.e. it ignores diacritics and other differences between equivalent
 character strings.
 


@@ -383,7 +383,7 @@ If `replace-regexp-lax-whitespace' is non-nil, a space or spaces in the regexp
 to be replaced will match a sequence of whitespace chars defined by the
 regexp in `search-whitespace-regexp'.
 
 to be replaced will match a sequence of whitespace chars defined by the
 regexp in `search-whitespace-regexp'.
 

-This function is not affected by `replace-character-fold'.
+This function is not affected by `replace-char-fold'.

 
 Third arg DELIMITED (prefix arg if interactive), if non-nil, means replace
 only matches surrounded by word boundaries.  A negative prefix arg means
 
 Third arg DELIMITED (prefix arg if interactive), if non-nil, means replace
 only matches surrounded by word boundaries.  A negative prefix arg means


@@ -474,7 +474,7 @@ If `replace-regexp-lax-whitespace' is non-nil, a space or spaces in the regexp
 to be replaced will match a sequence of whitespace chars defined by the
 regexp in `search-whitespace-regexp'.
 
 to be replaced will match a sequence of whitespace chars defined by the
 regexp in `search-whitespace-regexp'.
 

-This function is not affected by `replace-character-fold'.
+This function is not affected by `replace-char-fold'.

 
 Third arg DELIMITED (prefix arg if interactive), if non-nil, means replace
 only matches that are surrounded by word boundaries.
 
 Third arg DELIMITED (prefix arg if interactive), if non-nil, means replace
 only matches that are surrounded by word boundaries.


@@ -568,7 +568,7 @@ If `replace-lax-whitespace' is non-nil, a space or spaces in the string
 to be replaced will match a sequence of whitespace chars defined by the
 regexp in `search-whitespace-regexp'.
 
 to be replaced will match a sequence of whitespace chars defined by the
 regexp in `search-whitespace-regexp'.
 

-If `replace-character-fold' is non-nil, matching uses character folding,
+If `replace-char-fold' is non-nil, matching uses character folding,

 i.e. it ignores diacritics and other differences between equivalent
 character strings.
 
 i.e. it ignores diacritics and other differences between equivalent
 character strings.
 


@@ -623,7 +623,7 @@ If `replace-regexp-lax-whitespace' is non-nil, a space or spaces in the regexp
 to be replaced will match a sequence of whitespace chars defined by the
 regexp in `search-whitespace-regexp'.
 
 to be replaced will match a sequence of whitespace chars defined by the
 regexp in `search-whitespace-regexp'.
 

-This function is not affected by `replace-character-fold'
+This function is not affected by `replace-char-fold'

 
 In Transient Mark mode, if the mark is active, operate on the contents
 of the region.  Otherwise, operate from point to the end of the buffer's
 
 In Transient Mark mode, if the mark is active, operate on the contents
 of the region.  Otherwise, operate from point to the end of the buffer's


@@ -2051,9 +2051,9 @@ It is called with three arguments, as if it were
   ;; used after `recursive-edit' might override them.
   (let* ((isearch-regexp regexp-flag)
         (isearch-regexp-function (or delimited-flag
   ;; used after `recursive-edit' might override them.
   (let* ((isearch-regexp regexp-flag)
         (isearch-regexp-function (or delimited-flag

-                           (and replace-character-fold
+                           (and replace-char-fold

                                 (not regexp-flag)
                                 (not regexp-flag)

-                                #'character-fold-to-regexp)))
+                                #'char-fold-to-regexp)))

         (isearch-lax-whitespace
          replace-lax-whitespace)
         (isearch-regexp-lax-whitespace
         (isearch-lax-whitespace
          replace-lax-whitespace)
         (isearch-regexp-lax-whitespace

diff --git a/test/automated/character-fold-tests.el b/test/automated/char-fold-tests.el
similarity index 53%
rename from test/automated/character-fold-tests.el
rename to test/automated/char-fold-tests.el
index c611217712ef0e3b9b9844b56bff0f13e20e1c77..485254aa6cfa2bd848cc2417684f00d0b9d61128 100644 (file)
--- a/test/automated/character-fold-tests.el
+++ b/test/automated/char-fold-tests.el
@@ -1,4 +1,4 @@
-;;; character-fold-tests.el --- Tests for character-fold.el  -*- lexical-binding: t; -*-
+;;; char-fold-tests.el --- Tests for char-fold.el  -*- lexical-binding: t; -*-

 
 ;; Copyright (C) 2013-2016 Free Software Foundation, Inc.
 
 
 ;; Copyright (C) 2013-2016 Free Software Foundation, Inc.
 


@@ -20,42 +20,42 @@
 ;;; Code:
 
 (require 'ert)
 ;;; Code:
 
 (require 'ert)

-(require 'character-fold)
+(require 'char-fold)

 
 

-(defun character-fold--random-word (n)
+(defun char-fold--random-word (n)

   (mapconcat (lambda (_) (string (+ 9 (random 117))))
              (make-list n nil) ""))
 
   (mapconcat (lambda (_) (string (+ 9 (random 117))))
              (make-list n nil) ""))
 

-(defun character-fold--test-search-with-contents (contents string)
+(defun char-fold--test-search-with-contents (contents string)

   (with-temp-buffer
     (insert contents)
     (goto-char (point-min))
   (with-temp-buffer
     (insert contents)
     (goto-char (point-min))

-    (should (search-forward-regexp (character-fold-to-regexp string) nil 'noerror))
+    (should (search-forward-regexp (char-fold-to-regexp string) nil 'noerror))

     (goto-char (point-min))
     (goto-char (point-min))

-    (should (character-fold-search-forward string nil 'noerror))
-    (should (character-fold-search-backward string nil 'noerror))))
+    (should (char-fold-search-forward string nil 'noerror))
+    (should (char-fold-search-backward string nil 'noerror))))

 
 \f
 
 \f

-(ert-deftest character-fold--test-consistency ()
+(ert-deftest char-fold--test-consistency ()

   (dotimes (n 30)
   (dotimes (n 30)

-    (let ((w (character-fold--random-word n)))
+    (let ((w (char-fold--random-word n)))

       ;; A folded string should always match the original string.
       ;; A folded string should always match the original string.

-      (character-fold--test-search-with-contents w w))))
+      (char-fold--test-search-with-contents w w))))

 
 

-(ert-deftest character-fold--test-lax-whitespace ()
+(ert-deftest char-fold--test-lax-whitespace ()

   (dotimes (n 40)
   (dotimes (n 40)

-    (let ((w1 (character-fold--random-word n))
-          (w2 (character-fold--random-word n))
+    (let ((w1 (char-fold--random-word n))
+          (w2 (char-fold--random-word n))

           (search-spaces-regexp "\\s-+"))
           (search-spaces-regexp "\\s-+"))

-      (character-fold--test-search-with-contents
+      (char-fold--test-search-with-contents

        (concat w1 "\s\n\s\t\f\t\n\r\t" w2)
        (concat w1 " " w2))
        (concat w1 "\s\n\s\t\f\t\n\r\t" w2)
        (concat w1 " " w2))

-      (character-fold--test-search-with-contents
+      (char-fold--test-search-with-contents

        (concat w1 "\s\n\s\t\f\t\n\r\t" w2)
        (concat w1 (make-string 10 ?\s) w2)))))
 
        (concat w1 "\s\n\s\t\f\t\n\r\t" w2)
        (concat w1 (make-string 10 ?\s) w2)))))
 

-(defun character-fold--test-match-exactly (string &rest strings-to-match)
-  (let ((re (concat "\\`" (character-fold-to-regexp string) "\\'")))
+(defun char-fold--test-match-exactly (string &rest strings-to-match)
+  (let ((re (concat "\\`" (char-fold-to-regexp string) "\\'")))

     (dolist (it strings-to-match)
       (should (string-match re it)))
     ;; Case folding
     (dolist (it strings-to-match)
       (should (string-match re it)))
     ;; Case folding


@@ -64,49 +64,49 @@
         (should (string-match (upcase re) (downcase it)))
         (should (string-match (downcase re) (upcase it)))))))
 
         (should (string-match (upcase re) (downcase it)))
         (should (string-match (downcase re) (upcase it)))))))
 

-(ert-deftest character-fold--test-some-defaults ()
+(ert-deftest char-fold--test-some-defaults ()

   (dolist (it '(("ffl" . "ffl") ("ffi" . "ffi")
                 ("fi" . "fi") ("ff" . "ff")
                 ("ä" . "ä")))
   (dolist (it '(("ffl" . "ffl") ("ffi" . "ffi")
                 ("fi" . "fi") ("ff" . "ff")
                 ("ä" . "ä")))

-    (character-fold--test-search-with-contents (cdr it) (car it))
-    (let ((multi (char-table-extra-slot character-fold-table 0))
-          (character-fold-table (make-char-table 'character-fold-table)))
-      (set-char-table-extra-slot character-fold-table 0 multi)
-      (character-fold--test-match-exactly (car it) (cdr it)))))
-
-(ert-deftest character-fold--test-fold-to-regexp ()
-  (let ((character-fold-table (make-char-table 'character-fold-table))
-        (multi  (make-char-table 'character-fold-table)))
-    (set-char-table-extra-slot character-fold-table 0 multi)
-    (aset character-fold-table ?a "xx")
-    (aset character-fold-table ?1 "44")
-    (aset character-fold-table ?\s "-!-")
-    (character-fold--test-match-exactly "a1a1" "xx44xx44")
-    (character-fold--test-match-exactly "a1  a 1" "xx44-!--!-xx-!-44")
+    (char-fold--test-search-with-contents (cdr it) (car it))
+    (let ((multi (char-table-extra-slot char-fold-table 0))
+          (char-fold-table (make-char-table 'char-fold-table)))
+      (set-char-table-extra-slot char-fold-table 0 multi)
+      (char-fold--test-match-exactly (car it) (cdr it)))))
+
+(ert-deftest char-fold--test-fold-to-regexp ()
+  (let ((char-fold-table (make-char-table 'char-fold-table))
+        (multi  (make-char-table 'char-fold-table)))
+    (set-char-table-extra-slot char-fold-table 0 multi)
+    (aset char-fold-table ?a "xx")
+    (aset char-fold-table ?1 "44")
+    (aset char-fold-table ?\s "-!-")
+    (char-fold--test-match-exactly "a1a1" "xx44xx44")
+    (char-fold--test-match-exactly "a1  a 1" "xx44-!--!-xx-!-44")

     (aset multi ?a '(("1" . "99")
                      ("2" . "88")
                      ("12" . "77")))
     (aset multi ?a '(("1" . "99")
                      ("2" . "88")
                      ("12" . "77")))

-    (character-fold--test-match-exactly "a" "xx")
-    (character-fold--test-match-exactly "a1" "xx44" "99")
-    (character-fold--test-match-exactly "a12" "77" "xx442" "992")
-    (character-fold--test-match-exactly "a2" "88")
+    (char-fold--test-match-exactly "a" "xx")
+    (char-fold--test-match-exactly "a1" "xx44" "99")
+    (char-fold--test-match-exactly "a12" "77" "xx442" "992")
+    (char-fold--test-match-exactly "a2" "88")

     (aset multi ?1 '(("2" . "yy")))
     (aset multi ?1 '(("2" . "yy")))

-    (character-fold--test-match-exactly "a1" "xx44" "99")
-    (character-fold--test-match-exactly "a12" "77" "xx442" "992")
+    (char-fold--test-match-exactly "a1" "xx44" "99")
+    (char-fold--test-match-exactly "a12" "77" "xx442" "992")

     ;; Support for this case is disabled.  See function definition or:
     ;; https://lists.gnu.org/archive/html/emacs-devel/2015-11/msg02562.html
     ;; Support for this case is disabled.  See function definition or:
     ;; https://lists.gnu.org/archive/html/emacs-devel/2015-11/msg02562.html

-    ;; (character-fold--test-match-exactly "a12" "xxyy")
+    ;; (char-fold--test-match-exactly "a12" "xxyy")

     ))
 
     ))
 

-(ert-deftest character-fold--speed-test ()
+(ert-deftest char-fold--speed-test ()

   (dolist (string (append '("tty-set-up-initial-frame-face"
                             "tty-set-up-initial-frame-face-frame-faceframe-faceframe-faceframe-face")
   (dolist (string (append '("tty-set-up-initial-frame-face"
                             "tty-set-up-initial-frame-face-frame-faceframe-faceframe-faceframe-face")

-                          (mapcar #'character-fold--random-word '(10 50 100
+                          (mapcar #'char-fold--random-word '(10 50 100

                                                                      50 100))))
     (message "Testing %s" string)
     ;; Make sure we didn't just fallback on the trivial search.
     (should-not (string= (regexp-quote string)
                                                                      50 100))))
     (message "Testing %s" string)
     ;; Make sure we didn't just fallback on the trivial search.
     (should-not (string= (regexp-quote string)

-                         (character-fold-to-regexp string)))
+                         (char-fold-to-regexp string)))

     (with-temp-buffer
       (save-excursion (insert string))
       (let ((time (time-to-seconds (current-time))))
     (with-temp-buffer
       (save-excursion (insert string))
       (let ((time (time-to-seconds (current-time))))


@@ -114,11 +114,11 @@
         ;; created a lot of redundant paths in the regexp. Because of
         ;; that, if a really long string "almost" matches, the regexp
         ;; engine took a long time to realize that it doesn't match.
         ;; created a lot of redundant paths in the regexp. Because of
         ;; that, if a really long string "almost" matches, the regexp
         ;; engine took a long time to realize that it doesn't match.

-        (should-not (character-fold-search-forward (concat string "c") nil 'noerror))
+        (should-not (char-fold-search-forward (concat string "c") nil 'noerror))

         ;; Ensure it took less than a second.
         (should (< (- (time-to-seconds (current-time))
                       time)
                    1))))))
 
         ;; Ensure it took less than a second.
         (should (< (- (time-to-seconds (current-time))
                       time)
                    1))))))
 

-(provide 'character-fold-tests)
-;;; character-fold-tests.el ends here
+(provide 'char-fold-tests)
+;;; char-fold-tests.el ends here