mirror/emacs
1
0
Fork 0
mirror of https://git.savannah.gnu.org/git/emacs.git synced 2025-01-10 15:56:18 +00:00
Code Issues Releases Activity

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

Browse Source 
* 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
This commit is contained in:
Juri Linkov 2016-05-17 23:55:38 +03:00
parent a35826dbd4
commit 1fe1e0a8e7
7 changed files with 93 additions and 93 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
doc/emacs/search.texi
View File

@ -1264,13 +1264,13 @@ but match under character folding are known as @dfn{equivalent
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
@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
@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}.)
@ -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
@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}.)

8
etc/NEWS
View File

@ -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
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
'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'.
@ -647,9 +647,9 @@ value, nil specifies that Isearch does literal searches (however,
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
character-folds into STRING.
char-folds into STRING.
+++
*** The new 'M-s M-w' key binding uses eww to search the web for the

52
lisp/character-fold.el → lisp/char-fold.el
View File

@ -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.
@ -22,12 +22,12 @@
;;; 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))
(defconst character-fold-table
(defconst char-fold-table
(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)
@ -115,7 +115,7 @@
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)
@ -136,18 +136,18 @@ For instance, the default alist for ?f includes:
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
(make-list n (or (aref character-fold-table ?\s) " ")))))
(make-list n (or (aref char-fold-table ?\s) " ")))))
;;;###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
`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,
@ -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)
(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))
@ -172,9 +172,9 @@ from which to start."
(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))
(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)
@ -206,13 +206,13 @@ from which to start."
(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)
(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)
@ -221,22 +221,22 @@ from which to start."
;;; 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: ")
(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: ")
(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

10
lisp/isearch.el
View File

@ -222,7 +222,7 @@ It is nil if none yet.")
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.
@ -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'
\(`\\[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)
@ -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-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
@ -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.")
(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.")
(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))

2
lisp/menu-bar.el
View File

@ -1257,7 +1257,7 @@ mail status in mode line"))
(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))

16
lisp/replace.el
View File

@ -33,7 +33,7 @@
: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.
@ -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'.
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.
@ -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'.
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
@ -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'.
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.
@ -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'.
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.
@ -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'.
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
@ -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
(and replace-character-fold
(and replace-char-fold
(not regexp-flag)
#'character-fold-to-regexp)))
#'char-fold-to-regexp)))
(isearch-lax-whitespace
replace-lax-whitespace)
(isearch-regexp-lax-whitespace

90
test/automated/character-fold-tests.el → test/automated/char-fold-tests.el
View File

@ -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.
@ -20,42 +20,42 @@
;;; 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) ""))
(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))
(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))
(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))))
(ert-deftest character-fold--test-consistency ()
(ert-deftest char-fold--test-consistency ()
(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.
(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)
(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-+"))
(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))
(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)))))
(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
@ -64,49 +64,49 @@
(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")
("ä" . "ä")))
(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)))))
(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 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")
(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")))
(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")))
(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
;; (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")
(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)
(character-fold-to-regexp string)))
(char-fold-to-regexp string)))
(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.
(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))))))
(provide 'character-fold-tests)
;;; character-fold-tests.el ends here
(provide 'char-fold-tests)
;;; char-fold-tests.el ends here