1 ;;; regexp-opt.el --- generate efficient regexps to match strings -*- lexical-binding: t -*-
3 ;; Copyright (C) 1994-2017 Free Software Foundation, Inc.
5 ;; Author: Simon Marshall <simon@gnu.org>
6 ;; Maintainer: emacs-devel@gnu.org
7 ;; Keywords: strings, regexps, extensions
9 ;; This file is part of GNU Emacs.
11 ;; GNU Emacs is free software: you can redistribute it and/or modify
12 ;; it under the terms of the GNU General Public License as published by
13 ;; the Free Software Foundation, either version 3 of the License, or
14 ;; (at your option) any later version.
16 ;; GNU Emacs is distributed in the hope that it will be useful,
17 ;; but WITHOUT ANY WARRANTY; without even the implied warranty of
18 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19 ;; GNU General Public License for more details.
21 ;; You should have received a copy of the GNU General Public License
22 ;; along with GNU Emacs. If not, see <https://www.gnu.org/licenses/>.
26 ;; The "opt" in "regexp-opt" stands for "optim\\(al\\|i[sz]e\\)".
28 ;; This package generates a regexp from a given list of strings (which matches
29 ;; one of those strings) so that the regexp generated by:
31 ;; (regexp-opt strings)
33 ;; is equivalent to, but more efficient than, the regexp generated by:
35 ;; (mapconcat 'regexp-quote strings "\\|")
39 ;; (let ((strings '("cond" "if" "when" "unless" "while"
40 ;; "let" "let*" "progn" "prog1" "prog2"
41 ;; "save-restriction" "save-excursion" "save-window-excursion"
42 ;; "save-current-buffer" "save-match-data"
43 ;; "catch" "throw" "unwind-protect" "condition-case")))
44 ;; (concat "(" (regexp-opt strings t) "\\>"))
45 ;; => "(\\(c\\(atch\\|ond\\(ition-case\\)?\\)\\|if\\|let\\*?\\|prog[12n]\\|save-\\(current-buffer\\|excursion\\|match-data\\|restriction\\|window-excursion\\)\\|throw\\|un\\(less\\|wind-protect\\)\\|wh\\(en\\|ile\\)\\)\\>"
47 ;; Searching using the above example `regexp-opt' regexp takes approximately
48 ;; two-thirds of the time taken using the equivalent `mapconcat' regexp.
50 ;; Since this package was written to produce efficient regexps, not regexps
51 ;; efficiently, it is probably not a good idea to in-line too many calls in
52 ;; your code, unless you use the following trick with `eval-when-compile':
54 ;; (defvar definition-regexp
57 ;; (regexp-opt '("defun" "defsubst" "defmacro" "defalias"
58 ;; "defvar" "defconst") t)
61 ;; The `byte-compile' code will be as if you had defined the variable thus:
63 ;; (defvar definition-regexp
64 ;; "^(\\(def\\(alias\\|const\\|macro\\|subst\\|un\\|var\\)\\)\\>")
66 ;; Note that if you use this trick for all instances of `regexp-opt' and
67 ;; `regexp-opt-depth' in your code, regexp-opt.el would only have to be loaded
68 ;; at compile time. But note also that using this trick means that should
69 ;; regexp-opt.el be changed, perhaps to fix a bug or to add a feature to
70 ;; improve the efficiency of `regexp-opt' regexps, you would have to recompile
71 ;; your code for such changes to have effect in your code.
73 ;; Originally written for font-lock.el, from an idea from Stig's hl319.el, with
74 ;; thanks for ideas also to Michael Ernst, Bob Glickstein, Dan Nicolaescu and
76 ;; No doubt `regexp-opt' doesn't always produce optimal regexps, so code, ideas
77 ;; or any other information to improve things are welcome.
79 ;; One possible improvement would be to compile '("aa" "ab" "ba" "bb")
80 ;; into "[ab][ab]" rather than "a[ab]\\|b[ab]". I'm not sure it's worth
81 ;; it but if someone knows how to do it without going through too many
82 ;; contortions, I'm all ears.
87 (defun regexp-opt (strings &optional paren
)
88 "Return a regexp to match a string in the list STRINGS.
89 Each string should be unique in STRINGS and should not contain
90 any regexps, quoted or not. Optional PAREN specifies how the
91 returned regexp is surrounded by grouping constructs.
93 The optional argument PAREN can be any of the following:
96 the resulting regexp is preceded by PAREN and followed by
97 \\), e.g. use \"\\\\(?1:\" to produce an explicitly numbered
101 the resulting regexp is surrounded by \\=\\<\\( and \\)\\>.
104 the resulting regexp is surrounded by \\_<\\( and \\)\\_>.
107 the resulting regexp is surrounded by \\( and \\).
110 the resulting regexp is surrounded by \\(?: and \\), if it is
111 necessary to ensure that a postfix operator appended to it will
112 apply to the whole expression.
114 The resulting regexp is equivalent to but usually more efficient
115 than that of a simplified version:
117 (defun simplified-regexp-opt (strings &optional paren)
119 (cond ((stringp paren) (cons paren \"\\\\)\"))
120 ((eq paren 'words) '(\"\\\\\\=<\\\\(\" . \"\\\\)\\\\>\"))
121 ((eq paren 'symbols) '(\"\\\\_<\\\\(\" . \"\\\\)\\\\_>\"))
122 ((null paren) '(\"\\\\(?:\" . \"\\\\)\"))
123 (t '(\"\\\\(\" . \"\\\\)\")))))
125 (mapconcat 'regexp-quote strings \"\\\\|\")
128 ;; Recurse on the sorted list.
129 (let* ((max-lisp-eval-depth 10000)
130 (max-specpdl-size 10000)
131 (completion-ignore-case nil
)
132 (completion-regexp-list nil
)
133 (open (cond ((stringp paren
) paren
) (paren "\\(")))
134 (sorted-strings (delete-dups
135 (sort (copy-sequence strings
) 'string-lessp
)))
136 (re (regexp-opt-group sorted-strings
(or open t
) (not open
))))
137 (cond ((eq paren
'words
)
138 (concat "\\<" re
"\\>"))
140 (concat "\\_<" re
"\\_>"))
144 (defun regexp-opt-depth (regexp)
145 "Return the depth of REGEXP.
146 This means the number of non-shy regexp grouping constructs
147 \(parenthesized expressions) in REGEXP."
149 ;; Hack to signal an error if REGEXP does not have balanced parentheses.
150 (string-match regexp
"")
151 ;; Count the number of open parentheses in REGEXP.
152 (let ((count 0) start last
)
153 (while (string-match "\\\\(\\(\\?[0-9]*:\\)?" regexp start
)
154 (setq start
(match-end 0)) ; Start of next search.
155 (when (and (not (match-beginning 1))
156 (subregexp-context-p regexp
(match-beginning 0) last
))
157 ;; It's not a shy group and it's not inside brackets or after
158 ;; a backslash: it's really a group-open marker.
159 (setq last start
) ; Speed up next regexp-opt-re-context-p.
160 (setq count
(1+ count
))))
163 ;;; Workhorse functions.
165 (defun regexp-opt-group (strings &optional paren lax
)
166 "Return a regexp to match a string in the sorted list STRINGS.
167 If PAREN non-nil, output regexp parentheses around returned regexp.
168 If LAX non-nil, don't output parentheses if it doesn't require them.
169 Merges keywords to avoid backtracking in Emacs's regexp matcher."
170 ;; The basic idea is to find the shortest common prefix or suffix, remove it
171 ;; and recurse. If there is no prefix, we divide the list into two so that
172 ;; (at least) one half will have at least a one-character common prefix.
174 ;; Also we delay the addition of grouping parenthesis as long as possible
175 ;; until we're sure we need them, and try to remove one-character sequences
176 ;; so we can use character sets rather than grouping parenthesis.
177 (let* ((open-group (cond ((stringp paren
) paren
) (paren "\\(?:") (t "")))
178 (close-group (if paren
"\\)" ""))
179 (open-charset (if lax
"" open-group
))
180 (close-charset (if lax
"" close-group
)))
183 ;; If there are no strings, just return the empty string.
184 ((= (length strings
) 0)
187 ;; If there is only one string, just return it.
188 ((= (length strings
) 1)
189 (if (= (length (car strings
)) 1)
190 (concat open-charset
(regexp-quote (car strings
)) close-charset
)
191 (concat open-group
(regexp-quote (car strings
)) close-group
)))
193 ;; If there is an empty string, remove it and recurse on the rest.
194 ((= (length (car strings
)) 0)
196 (regexp-opt-group (cdr strings
) t t
) "?"
199 ;; If there are several one-char strings, use charsets
200 ((and (= (length (car strings
)) 1)
201 (let ((strs (cdr strings
)))
202 (while (and strs
(/= (length (car strs
)) 1))
206 ;; Collect one-char strings
208 (if (= (length s
) 1) (push (string-to-char s
) letters
) (push s rest
)))
211 ;; several one-char strings: take them and recurse
212 ;; on the rest (first so as to match the longest).
214 (regexp-opt-group (nreverse rest
))
215 "\\|" (regexp-opt-charset letters
)
217 ;; all are one-char strings: just return a character set.
219 (regexp-opt-charset letters
)
222 ;; We have a list of different length strings.
224 (let ((prefix (try-completion "" strings
)))
225 (if (> (length prefix
) 0)
226 ;; common prefix: take it and recurse on the suffixes.
227 (let* ((n (length prefix
))
228 (suffixes (mapcar (lambda (s) (substring s n
)) strings
)))
230 (regexp-quote prefix
)
231 (regexp-opt-group suffixes t t
)
234 (let* ((sgnirts (mapcar #'reverse strings
))
235 (xiffus (try-completion "" sgnirts
)))
236 (if (> (length xiffus
) 0)
237 ;; common suffix: take it and recurse on the prefixes.
238 (let* ((n (- (length xiffus
)))
240 ;; Sorting is necessary in cases such as ("ad" "d").
241 (sort (mapcar (lambda (s) (substring s
0 n
)) strings
)
244 (regexp-opt-group prefixes t t
)
245 (regexp-quote (nreverse xiffus
))
248 ;; Otherwise, divide the list into those that start with a
249 ;; particular letter and those that do not, and recurse on them.
250 (let* ((char (substring-no-properties (car strings
) 0 1))
251 (half1 (all-completions char strings
))
252 (half2 (nthcdr (length half1
) strings
)))
254 (regexp-opt-group half1
)
255 "\\|" (regexp-opt-group half2
)
256 close-group
))))))))))
259 (defun regexp-opt-charset (chars)
260 "Return a regexp to match a character in CHARS.
261 CHARS should be a list of characters."
262 ;; The basic idea is to find character ranges. Also we take care in the
263 ;; position of character set meta characters in the character set regexp.
265 (let* ((charmap (make-char-table 'regexp-opt-charset
))
268 (bracket "") (dash "") (caret ""))
270 ;; Make a character map but extract character set meta characters.
280 (aset charmap char t
))))
282 ;; Make a character set from the map using ranges where applicable.
287 (if (= (1- (car c
)) end
) (setq end
(cdr c
))
288 (if (> end
(+ start
2))
289 (setq charset
(format "%s%c-%c" charset start end
))
290 (while (>= end start
)
291 (setq charset
(format "%s%c" charset start
))
292 (setq start
(1+ start
))))
293 (setq start
(car c
) end
(cdr c
)))
294 (if (= (1- c
) end
) (setq end c
)
295 (if (> end
(+ start
2))
296 (setq charset
(format "%s%c-%c" charset start end
))
297 (while (>= end start
)
298 (setq charset
(format "%s%c" charset start
))
299 (setq start
(1+ start
))))
300 (setq start c end c
)))))
303 (if (> end
(+ start
2))
304 (setq charset
(format "%s%c-%c" charset start end
))
305 (while (>= end start
)
306 (setq charset
(format "%s%c" charset start
))
307 (setq start
(1+ start
)))))
309 ;; Make sure a caret is not first and a dash is first or last.
310 (if (and (string-equal charset
"") (string-equal bracket
""))
311 (if (string-equal dash
"")
312 "\\^" ; [^] is not a valid regexp
313 (concat "[" dash caret
"]"))
314 (concat "[" bracket charset caret dash
"]"))))
316 (provide 'regexp-opt
)
318 ;;; regexp-opt.el ends here