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