1;;; re-builder.el --- building Regexps with visual feedback 2 3;; Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004, 4;; 2005, 2006, 2007 Free Software Foundation, Inc. 5 6;; Author: Detlev Zundel <dzu@gnu.org> 7;; Keywords: matching, lisp, tools 8 9;; This file is part of GNU Emacs. 10 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 2, or (at your option) 14;; any later version. 15 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. 20 21;; You should have received a copy of the GNU General Public License 22;; along with GNU Emacs; see the file COPYING. If not, write to the 23;; Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, 24;; Boston, MA 02110-1301, USA. 25 26;;; Commentary: 27 28;; When I have to come up with regular expressions that are more 29;; complex than simple string matchers, especially if they contain sub 30;; expressions, I find myself spending quite some time in the 31;; `development cycle'. `re-builder' aims to shorten this time span 32;; so I can get on with the more interesting bits. 33 34;; With it you can have immediate visual feedback about how well the 35;; regexp behaves to your expectations on the intended data. 36 37;; When called up `re-builder' attaches itself to the current buffer 38;; which becomes its target buffer, where all the matching is done. 39;; The active window is split so you have a view on the data while 40;; authoring the RE. If the edited expression is valid the matches in 41;; the target buffer are marked automatically with colored overlays 42;; (for non-color displays see below) giving you feedback over the 43;; extents of the matched (sub) expressions. The (non-)validity is 44;; shown only in the modeline without throwing the errors at you. If 45;; you want to know the reason why RE Builder considers it as invalid 46;; call `reb-force-update' ("\C-c\C-u") which should reveal the error. 47 48;; The target buffer can be changed with `reb-change-target-buffer' 49;; ("\C-c\C-b"). Changing the target buffer automatically removes 50;; the overlays from the old buffer and displays the new one in the 51;; target window. 52 53;; The `re-builder' keeps the focus while updating the matches in the 54;; target buffer so corrections are easy to incorporate. If you are 55;; satisfied with the result you can paste the RE to the kill-ring 56;; with `reb-copy' ("\C-c\C-w"), quit the `re-builder' ("\C-c\C-q") 57;; and use it wherever you need it. 58 59;; As the automatic updates can take some time on large buffers, they 60;; can be limited by `reb-auto-match-limit' so that they should not 61;; have a negative impact on the editing. Setting it to nil makes 62;; even the auto updates go all the way. Forcing an update overrides 63;; this limit allowing an easy way to see all matches. 64 65;; Currently `re-builder' understands five different forms of input, 66;; namely `read', `string', `rx', `sregex' and `lisp-re' syntax. Read 67;; syntax and string syntax are both delimited by `"'s and behave 68;; according to their name. With the `string' syntax there's no need 69;; to escape the backslashes and double quotes simplifying the editing 70;; somewhat. The other three allow editing of symbolic regular 71;; expressions supported by the packages of the same name. (`lisp-re' 72;; is a package by me and its support may go away as it is nearly the 73;; same as the `sregex' package in Emacs) 74 75;; Editing symbolic expressions is done through a major mode derived 76;; from `emacs-lisp-mode' so you'll get all the good stuff like 77;; automatic indentation and font-locking etc. 78 79;; When editing a symbolic regular expression, only the first 80;; expression in the RE Builder buffer is considered, which helps 81;; limiting the extent of the expression like the `"'s do for the text 82;; modes. For the `sregex' syntax the function `sregex' is applied to 83;; the evaluated expression read. So you can use quoted arguments 84;; with something like '("findme") or you can construct arguments to 85;; your hearts delight with a valid ELisp expression. (The compiled 86;; string form will be copied by `reb-copy') If you want to take 87;; a glance at the corresponding string you can temporarily change the 88;; input syntax. 89 90;; Changing the input syntax is transparent (for the obvious exception 91;; non-symbolic -> symbolic) so you can change your mind as often as 92;; you like. 93 94;; There is also a shortcut function for toggling the 95;; `case-fold-search' variable in the target buffer with an immediate 96;; update. 97 98 99;; Q: But what if my display cannot show colored overlays? 100;; A: Then the cursor will flash around the matched text making it stand 101;; out. 102 103;; Q: But how can I then make out the sub-expressions? 104;; A: Thats where the `sub-expression mode' comes in. In it only the 105;; digit keys are assigned to perform an update that will flash the 106;; corresponding subexp only. 107 108 109;;; Code: 110 111;; On XEmacs, load the overlay compatibility library 112(if (not (fboundp 'make-overlay)) 113 (require 'overlay)) 114 115;; User customizable variables 116(defgroup re-builder nil 117 "Options for the RE Builder." 118 :group 'lisp 119 :prefix "reb-") 120 121(defcustom reb-blink-delay 0.5 122 "*Seconds to blink cursor for next/previous match in RE Builder." 123 :group 're-builder 124 :type 'number) 125 126(defcustom reb-mode-hook nil 127 "*Hooks to run on entering RE Builder mode." 128 :group 're-builder 129 :type 'hook) 130 131(defcustom reb-re-syntax 'read 132 "*Syntax for the REs in the RE Builder. 133Can either be `read', `string', `sregex', `lisp-re', `rx'." 134 :group 're-builder 135 :type '(choice (const :tag "Read syntax" read) 136 (const :tag "String syntax" string) 137 (const :tag "`sregex' syntax" sregex) 138 (const :tag "`lisp-re' syntax" lisp-re) 139 (const :tag "`rx' syntax" rx))) 140 141(defcustom reb-auto-match-limit 200 142 "*Positive integer limiting the matches for RE Builder auto updates. 143Set it to nil if you don't want limits here." 144 :group 're-builder 145 :type '(restricted-sexp :match-alternatives 146 (integerp 'nil))) 147 148 149(defface reb-match-0 150 '((((class color) (background light)) 151 :background "lightblue") 152 (((class color) (background dark)) 153 :background "steelblue4") 154 (t 155 :inverse-video t)) 156 "Used for displaying the whole match." 157 :group 're-builder) 158 159(defface reb-match-1 160 '((((class color) (background light)) 161 :background "aquamarine") 162 (((class color) (background dark)) 163 :background "blue3") 164 (t 165 :inverse-video t)) 166 "Used for displaying the first matching subexpression." 167 :group 're-builder) 168 169(defface reb-match-2 170 '((((class color) (background light)) 171 :background "springgreen") 172 (((class color) (background dark)) 173 :background "chartreuse4") 174 (t 175 :inverse-video t)) 176 "Used for displaying the second matching subexpression." 177 :group 're-builder) 178 179(defface reb-match-3 180 '((((min-colors 88) (class color) (background light)) 181 :background "yellow1") 182 (((class color) (background light)) 183 :background "yellow") 184 (((class color) (background dark)) 185 :background "sienna4") 186 (t 187 :inverse-video t)) 188 "Used for displaying the third matching subexpression." 189 :group 're-builder) 190 191;; Internal variables below 192(defvar reb-mode nil 193 "Enables the RE Builder minor mode.") 194 195(defvar reb-target-buffer nil 196 "Buffer to which the RE is applied to.") 197 198(defvar reb-target-window nil 199 "Window to which the RE is applied to.") 200 201(defvar reb-regexp nil 202 "Last regexp used by RE Builder.") 203 204(defvar reb-regexp-src nil 205 "Last regexp used by RE Builder before processing it. 206Except for Lisp syntax this is the same as `reb-regexp'.") 207 208(defvar reb-overlays nil 209 "List of overlays of the RE Builder.") 210 211(defvar reb-window-config nil 212 "Old window configuration.") 213 214(defvar reb-subexp-mode nil 215 "Indicates whether sub-exp mode is active.") 216 217(defvar reb-subexp-displayed nil 218 "Indicates which sub-exp is active.") 219 220(defvar reb-mode-string "" 221 "String in mode line for additional info.") 222 223(defvar reb-valid-string "" 224 "String in mode line showing validity of RE.") 225 226(make-variable-buffer-local 'reb-overlays) 227(make-variable-buffer-local 'reb-regexp) 228(make-variable-buffer-local 'reb-regexp-src) 229 230(defconst reb-buffer "*RE-Builder*" 231 "Buffer to use for the RE Builder.") 232 233;; Define the local "\C-c" keymap 234(defvar reb-mode-map 235 (let ((map (make-sparse-keymap))) 236 (define-key map "\C-c\C-c" 'reb-toggle-case) 237 (define-key map "\C-c\C-q" 'reb-quit) 238 (define-key map "\C-c\C-w" 'reb-copy) 239 (define-key map "\C-c\C-s" 'reb-next-match) 240 (define-key map "\C-c\C-r" 'reb-prev-match) 241 (define-key map "\C-c\C-i" 'reb-change-syntax) 242 (define-key map "\C-c\C-e" 'reb-enter-subexp-mode) 243 (define-key map "\C-c\C-b" 'reb-change-target-buffer) 244 (define-key map "\C-c\C-u" 'reb-force-update) 245 map) 246 "Keymap used by the RE Builder.") 247 248(defun reb-mode () 249 "Major mode for interactively building Regular Expressions. 250\\{reb-mode-map}" 251 (interactive) 252 (kill-all-local-variables) 253 (setq major-mode 'reb-mode 254 mode-name "RE Builder") 255 (set (make-local-variable 'blink-matching-paren) nil) 256 (use-local-map reb-mode-map) 257 (reb-mode-common) 258 (run-mode-hooks 'reb-mode-hook)) 259 260(define-derived-mode reb-lisp-mode 261 emacs-lisp-mode "RE Builder Lisp" 262 "Major mode for interactively building symbolic Regular Expressions." 263 (cond ((eq reb-re-syntax 'lisp-re) ; Pull in packages 264 (require 'lisp-re)) ; as needed 265 ((eq reb-re-syntax 'sregex) ; sregex is not autoloaded 266 (require 'sregex)) ; right now.. 267 ((eq reb-re-syntax 'rx) ; rx-to-string is autoloaded 268 (require 'rx))) ; require rx anyway 269 (reb-mode-common)) 270 271;; Use the same "\C-c" keymap as `reb-mode' and use font-locking from 272;; `emacs-lisp-mode' 273(define-key reb-lisp-mode-map "\C-c" 274 (lookup-key reb-mode-map "\C-c")) 275 276(defvar reb-subexp-mode-map 277 (let ((m (make-keymap))) 278 (suppress-keymap m) 279 ;; Again share the "\C-c" keymap for the commands 280 (define-key m "\C-c" (lookup-key reb-mode-map "\C-c")) 281 (define-key m "q" 'reb-quit-subexp-mode) 282 (dotimes (digit 10) 283 (define-key m (int-to-string digit) 'reb-display-subexp)) 284 m) 285 "Keymap used by the RE Builder for the subexpression mode.") 286 287(defun reb-mode-common () 288 "Setup functions common to functions `reb-mode' and `reb-mode-lisp'." 289 290 (setq reb-mode-string "" 291 reb-valid-string "" 292 mode-line-buffer-identification 293 '(25 . ("%b" reb-mode-string reb-valid-string))) 294 (reb-update-modestring) 295 (make-local-variable 'after-change-functions) 296 (add-hook 'after-change-functions 297 'reb-auto-update) 298 ;; At least make the overlays go away if the buffer is killed 299 (make-local-variable 'reb-kill-buffer) 300 (add-hook 'kill-buffer-hook 'reb-kill-buffer) 301 (reb-auto-update nil nil nil)) 302 303(defun reb-color-display-p () 304 "Return t if display is capable of displaying colors." 305 (eq 'color 306 ;; emacs/xemacs compatibility 307 (if (fboundp 'frame-parameter) 308 (frame-parameter (selected-frame) 'display-type) 309 (if (fboundp 'frame-property) 310 (frame-property (selected-frame) 'display-type))))) 311 312(defsubst reb-lisp-syntax-p () 313 "Return non-nil if RE Builder uses a Lisp syntax." 314 (memq reb-re-syntax '(lisp-re sregex rx))) 315 316(defmacro reb-target-binding (symbol) 317 "Return binding for SYMBOL in the RE Builder target buffer." 318 `(with-current-buffer reb-target-buffer ,symbol)) 319 320(defun reb-initialize-buffer () 321 "Initialize the current buffer as a RE Builder buffer." 322 (erase-buffer) 323 (reb-insert-regexp) 324 (goto-char (+ 2 (point-min))) 325 (cond ((reb-lisp-syntax-p) 326 (reb-lisp-mode)) 327 (t (reb-mode)))) 328 329;;; This is to help people find this in Apropos. 330;;;###autoload 331(defalias 'regexp-builder 're-builder) 332 333;;;###autoload 334(defun re-builder () 335 "Construct a regexp interactively." 336 (interactive) 337 338 (if (and (string= (buffer-name) reb-buffer) 339 (memq major-mode '(reb-mode reb-lisp-mode))) 340 (message "Already in the RE Builder") 341 (if reb-target-buffer 342 (reb-delete-overlays)) 343 (setq reb-target-buffer (current-buffer) 344 reb-target-window (selected-window) 345 reb-window-config (current-window-configuration)) 346 (select-window (split-window (selected-window) (- (window-height) 4))) 347 (switch-to-buffer (get-buffer-create reb-buffer)) 348 (reb-initialize-buffer))) 349 350(defun reb-change-target-buffer (buf) 351 "Change the target buffer and display it in the target window." 352 (interactive "bSet target buffer to: ") 353 354 (let ((buffer (get-buffer buf))) 355 (if (not buffer) 356 (error "No such buffer") 357 (reb-delete-overlays) 358 (setq reb-target-buffer buffer) 359 (reb-do-update 360 (if reb-subexp-mode reb-subexp-displayed nil)) 361 (reb-update-modestring)))) 362 363(defun reb-force-update () 364 "Force an update in the RE Builder target window without a match limit." 365 (interactive) 366 367 (let ((reb-auto-match-limit nil)) 368 (reb-update-overlays 369 (if reb-subexp-mode reb-subexp-displayed nil)))) 370 371(defun reb-quit () 372 "Quit the RE Builder mode." 373 (interactive) 374 375 (setq reb-subexp-mode nil 376 reb-subexp-displayed nil) 377 (reb-delete-overlays) 378 (bury-buffer) 379 (set-window-configuration reb-window-config)) 380 381(defun reb-next-match () 382 "Go to next match in the RE Builder target window." 383 (interactive) 384 385 (reb-assert-buffer-in-window) 386 (with-selected-window reb-target-window 387 (if (not (re-search-forward reb-regexp (point-max) t)) 388 (message "No more matches.") 389 (reb-show-subexp 390 (or (and reb-subexp-mode reb-subexp-displayed) 0) 391 t)))) 392 393(defun reb-prev-match () 394 "Go to previous match in the RE Builder target window." 395 (interactive) 396 397 (reb-assert-buffer-in-window) 398 (with-selected-window reb-target-window 399 (let ((p (point))) 400 (goto-char (1- p)) 401 (if (re-search-backward reb-regexp (point-min) t) 402 (reb-show-subexp 403 (or (and reb-subexp-mode reb-subexp-displayed) 0) 404 t) 405 (goto-char p) 406 (message "No more matches."))))) 407 408(defun reb-toggle-case () 409 "Toggle case sensitivity of searches for RE Builder target buffer." 410 (interactive) 411 412 (with-current-buffer reb-target-buffer 413 (setq case-fold-search (not case-fold-search))) 414 (reb-update-modestring) 415 (reb-auto-update nil nil nil t)) 416 417(defun reb-copy () 418 "Copy current RE into the kill ring for later insertion." 419 (interactive) 420 421 (reb-update-regexp) 422 (let ((re (with-output-to-string 423 (print (reb-target-binding reb-regexp))))) 424 (kill-new (substring re 1 (1- (length re)))) 425 (message "Regexp copied to kill-ring"))) 426 427;; The subexpression mode is not electric because the number of 428;; matches should be seen rather than a prompt. 429(defun reb-enter-subexp-mode () 430 "Enter the subexpression mode in the RE Builder." 431 (interactive) 432 (setq reb-subexp-mode t) 433 (reb-update-modestring) 434 (use-local-map reb-subexp-mode-map) 435 (message "`0'-`9' to display subexpressions `q' to quit subexp mode.")) 436 437(defun reb-show-subexp (subexp &optional pause) 438 "Visually show limit of subexpression SUBEXP of recent search. 439On color displays this just puts point to the end of the expression as 440the match should already be marked by an overlay. 441On other displays jump to the beginning and the end of it. 442If the optional PAUSE is non-nil then pause at the end in any case." 443 (with-selected-window reb-target-window 444 (if (not (reb-color-display-p)) 445 (progn (goto-char (match-beginning subexp)) 446 (sit-for reb-blink-delay))) 447 (goto-char (match-end subexp)) 448 (if (or (not (reb-color-display-p)) pause) 449 (sit-for reb-blink-delay)))) 450 451(defun reb-quit-subexp-mode () 452 "Quit the subexpression mode in the RE Builder." 453 (interactive) 454 (setq reb-subexp-mode nil 455 reb-subexp-displayed nil) 456 (reb-update-modestring) 457 (use-local-map reb-mode-map) 458 (reb-do-update)) 459 460(defun reb-change-syntax (&optional syntax) 461 "Change the syntax used by the RE Builder. 462Optional argument SYNTAX must be specified if called non-interactively." 463 (interactive 464 (list (intern 465 (completing-read "Select syntax: " 466 (mapcar (lambda (el) (cons (symbol-name el) 1)) 467 '(read string lisp-re sregex rx)) 468 nil t (symbol-name reb-re-syntax))))) 469 470 (if (memq syntax '(read string lisp-re sregex rx)) 471 (let ((buffer (get-buffer reb-buffer))) 472 (setq reb-re-syntax syntax) 473 (when buffer 474 (with-current-buffer buffer 475 (reb-initialize-buffer)))) 476 (error "Invalid syntax: %s" syntax))) 477 478 479;; Non-interactive functions below 480(defun reb-do-update (&optional subexp) 481 "Update matches in the RE Builder target window. 482If SUBEXP is non-nil mark only the corresponding sub-expressions." 483 484 (reb-assert-buffer-in-window) 485 (reb-update-regexp) 486 (reb-update-overlays subexp)) 487 488(defun reb-auto-update (beg end lenold &optional force) 489 "Called from `after-update-functions' to update the display. 490BEG, END and LENOLD are passed in from the hook. 491An actual update is only done if the regexp has changed or if the 492optional fourth argument FORCE is non-nil." 493 (let ((prev-valid reb-valid-string) 494 (new-valid 495 (condition-case nil 496 (progn 497 (if (or (reb-update-regexp) force) 498 (progn 499 (reb-assert-buffer-in-window) 500 (reb-do-update))) 501 "") 502 (error " *invalid*")))) 503 (setq reb-valid-string new-valid) 504 (force-mode-line-update) 505 506 ;; Through the caching of the re a change invalidating the syntax 507 ;; for symbolic expressions will not delete the overlays so we 508 ;; catch it here 509 (if (and (reb-lisp-syntax-p) 510 (not (string= prev-valid new-valid)) 511 (string= prev-valid "")) 512 (reb-delete-overlays)))) 513 514(defun reb-delete-overlays () 515 "Delete all RE Builder overlays in the `reb-target-buffer' buffer." 516 (if (buffer-live-p reb-target-buffer) 517 (with-current-buffer reb-target-buffer 518 (mapcar 'delete-overlay reb-overlays) 519 (setq reb-overlays nil)))) 520 521(defun reb-assert-buffer-in-window () 522 "Assert that `reb-target-buffer' is displayed in `reb-target-window'." 523 524 (if (not (eq reb-target-buffer (window-buffer reb-target-window))) 525 (set-window-buffer reb-target-window reb-target-buffer))) 526 527(defun reb-update-modestring () 528 "Update the variable `reb-mode-string' displayed in the mode line." 529 (setq reb-mode-string 530 (concat 531 (if reb-subexp-mode 532 (format " (subexp %s)" (or reb-subexp-displayed "-")) 533 "") 534 (if (not (reb-target-binding case-fold-search)) 535 " Case" 536 ""))) 537 (force-mode-line-update)) 538 539(defun reb-display-subexp (&optional subexp) 540 "Highlight only subexpression SUBEXP in the RE Builder." 541 (interactive) 542 543 (setq reb-subexp-displayed 544 (or subexp (string-to-number (format "%c" last-command-char)))) 545 (reb-update-modestring) 546 (reb-do-update reb-subexp-displayed)) 547 548(defun reb-kill-buffer () 549 "When the RE Builder buffer is killed make sure no overlays stay around." 550 551 (if (member major-mode '(reb-mode reb-lisp-mode)) 552 (reb-delete-overlays))) 553 554 555;; The next functions are the interface between the regexp and 556;; its textual representation in the RE Builder buffer. 557;; They are the only functions concerned with the actual syntax 558;; being used. 559(defun reb-read-regexp () 560 "Read current RE." 561 (save-excursion 562 (cond ((eq reb-re-syntax 'read) 563 (goto-char (point-min)) 564 (read (current-buffer))) 565 ((eq reb-re-syntax 'string) 566 (goto-char (point-min)) 567 (re-search-forward "\"") 568 (let ((beg (point))) 569 (goto-char (point-max)) 570 (re-search-backward "\"") 571 (buffer-substring-no-properties beg (point)))) 572 ((reb-lisp-syntax-p) 573 (buffer-string))))) 574 575(defun reb-empty-regexp () 576 "Return empty RE for current syntax." 577 (cond ((reb-lisp-syntax-p) "'()") 578 (t ""))) 579 580(defun reb-insert-regexp () 581 "Insert current RE." 582 583 (let ((re (or (reb-target-binding reb-regexp) 584 (reb-empty-regexp)))) 585 (cond ((eq reb-re-syntax 'read) 586 (print re (current-buffer))) 587 ((eq reb-re-syntax 'string) 588 (insert "\n\"" re "\"")) 589 ;; For the Lisp syntax we need the "source" of the regexp 590 ((reb-lisp-syntax-p) 591 (insert (or (reb-target-binding reb-regexp-src) 592 (reb-empty-regexp))))))) 593 594(defun reb-cook-regexp (re) 595 "Return RE after processing it according to `reb-re-syntax'." 596 (cond ((eq reb-re-syntax 'lisp-re) 597 (if (fboundp 'lre-compile-string) 598 (lre-compile-string (eval (car (read-from-string re)))))) 599 ((eq reb-re-syntax 'sregex) 600 (apply 'sregex (eval (car (read-from-string re))))) 601 ((eq reb-re-syntax 'rx) 602 (rx-to-string (eval (car (read-from-string re))))) 603 (t re))) 604 605(defun reb-update-regexp () 606 "Update the regexp for the target buffer. 607Return t if the (cooked) expression changed." 608 (let* ((re-src (reb-read-regexp)) 609 (re (reb-cook-regexp re-src))) 610 (with-current-buffer reb-target-buffer 611 (let ((oldre reb-regexp)) 612 (prog1 613 (not (string= oldre re)) 614 (setq reb-regexp re) 615 ;; Only update the source re for the lisp formats 616 (if (reb-lisp-syntax-p) 617 (setq reb-regexp-src re-src))))))) 618 619 620;; And now the real core of the whole thing 621(defun reb-count-subexps (re) 622 "Return number of sub-expressions in the regexp RE." 623 624 (let ((i 0) (beg 0)) 625 (while (string-match "\\\\(" re beg) 626 (setq i (1+ i) 627 beg (match-end 0))) 628 i)) 629 630(defun reb-update-overlays (&optional subexp) 631 "Switch to `reb-target-buffer' and mark all matches of `reb-regexp'. 632If SUBEXP is non-nil mark only the corresponding sub-expressions." 633 (let* ((re (reb-target-binding reb-regexp)) 634 (subexps (reb-count-subexps re)) 635 (matches 0) 636 (submatches 0) 637 firstmatch) 638 (save-excursion 639 (set-buffer reb-target-buffer) 640 (reb-delete-overlays) 641 (goto-char (point-min)) 642 (while (and (not (eobp)) 643 (re-search-forward re (point-max) t) 644 (or (not reb-auto-match-limit) 645 (< matches reb-auto-match-limit))) 646 (if (= 0 (length (match-string 0))) 647 (unless (eobp) 648 (forward-char 1))) 649 (let ((i 0) 650 suffix max-suffix) 651 (setq matches (1+ matches)) 652 (while (<= i subexps) 653 (if (and (or (not subexp) (= subexp i)) 654 (match-beginning i)) 655 (let ((overlay (make-overlay (match-beginning i) 656 (match-end i))) 657 ;; When we have exceeded the number of provided faces, 658 ;; cycle thru them where `max-suffix' denotes the maximum 659 ;; suffix for `reb-match-*' that has been defined and 660 ;; `suffix' the suffix calculated for the current match. 661 (face 662 (cond 663 (max-suffix 664 (if (= suffix max-suffix) 665 (setq suffix 1) 666 (setq suffix (1+ suffix))) 667 (intern-soft (format "reb-match-%d" suffix))) 668 ((intern-soft (format "reb-match-%d" i))) 669 ((setq max-suffix (1- i)) 670 (setq suffix 1) 671 ;; `reb-match-1' must exist. 672 'reb-match-1)))) 673 (unless firstmatch (setq firstmatch (match-data))) 674 (setq reb-overlays (cons overlay reb-overlays) 675 submatches (1+ submatches)) 676 (overlay-put overlay 'face face) 677 (overlay-put overlay 'priority i))) 678 (setq i (1+ i)))))) 679 (let ((count (if subexp submatches matches))) 680 (message "%s %smatch%s%s" 681 (if (= 0 count) "No" (int-to-string count)) 682 (if subexp "subexpression " "") 683 (if (= 1 count) "" "es") 684 (if (and reb-auto-match-limit 685 (= reb-auto-match-limit count)) 686 " (limit reached)" ""))) 687 (if firstmatch 688 (progn (store-match-data firstmatch) 689 (reb-show-subexp (or subexp 0)))))) 690 691(provide 're-builder) 692 693;;; arch-tag: 5c5515ac-4085-4524-a421-033f44f032e7 694;;; re-builder.el ends here 695