lisp/emacs-lisp/re-builder.el

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