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, 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 (unless (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.
 133 Can 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.
 143 Set 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.
 206 Except 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         (menu-map (make-sparse-keymap)))
 237     (define-key map "\C-c\C-c" 'reb-toggle-case)
 238     (define-key map "\C-c\C-q" 'reb-quit)
 239     (define-key map "\C-c\C-w" 'reb-copy)
 240     (define-key map "\C-c\C-s" 'reb-next-match)
 241     (define-key map "\C-c\C-r" 'reb-prev-match)
 242     (define-key map "\C-c\C-i" 'reb-change-syntax)
 243     (define-key map "\C-c\C-e" 'reb-enter-subexp-mode)
 244     (define-key map "\C-c\C-b" 'reb-change-target-buffer)
 245     (define-key map "\C-c\C-u" 'reb-force-update)
 246     (define-key map [menu-bar reb-mode] (cons "Re-Builder" menu-map))
 247     (define-key menu-map [rq]
 248       '(menu-item "Quit" reb-quit
 249                   :help "Quit the RE Builder mode"))
 250     (define-key menu-map [rt]
 251       '(menu-item "Case sensitive" reb-toggle-case
 252                   :button (:toggle . case-fold-search)
 253                   :help "Toggle case sensitivity of searches for RE Builder target buffer."))
 254     (define-key menu-map [rb]
 255       '(menu-item "Change target buffer..." reb-change-target-buffer
 256                   :help "Change the target buffer and display it in the target window"))
 257     (define-key menu-map [rs]
 258       '(menu-item "Change syntax..." reb-change-syntax
 259                   :help "Change the syntax used by the RE Builder"))
 260     (define-key menu-map [re]
 261       '(menu-item "Enter subexpression mode" reb-enter-subexp-mode
 262                   :help "Enter the subexpression mode in the RE Builder"))
 263     (define-key menu-map [ru]
 264       '(menu-item "Force update" reb-force-update
 265                   :help "Force an update in the RE Builder target window without a match limit"))
 266     (define-key menu-map [rn]
 267       '(menu-item "Go to next match" reb-next-match
 268                   :help "Go to next match in the RE Builder target window"))
 269     (define-key menu-map [rp]
 270       '(menu-item "Go to previous match" reb-prev-match
 271                   :help "Go to previous match in the RE Builder target window"))
 272     (define-key menu-map [rc]
 273       '(menu-item "Copy current RE" reb-copy
 274                   :help "Copy current RE into the kill ring for later insertion"))
 275     map)
 276   "Keymap used by the RE Builder.")
 277
 278 (defun reb-mode ()
 279   "Major mode for interactively building Regular Expressions.
 280 \\{reb-mode-map}"
 281   (interactive)
 282   (kill-all-local-variables)
 283   (setq major-mode 'reb-mode
 284         mode-name "RE Builder")
 285   (set (make-local-variable 'blink-matching-paren) nil)
 286   (use-local-map reb-mode-map)
 287   (reb-mode-common)
 288   (run-mode-hooks 'reb-mode-hook))
 289
 290 (define-derived-mode reb-lisp-mode
 291   emacs-lisp-mode "RE Builder Lisp"
 292   "Major mode for interactively building symbolic Regular Expressions."
 293   (cond ((eq reb-re-syntax 'lisp-re)    ; Pull in packages
 294          (require 'lisp-re))            ; as needed
 295         ((eq reb-re-syntax 'sregex)     ; sregex is not autoloaded
 296          (require 'sregex))             ; right now..
 297         ((eq reb-re-syntax 'rx)         ; rx-to-string is autoloaded
 298          (require 'rx)))                ; require rx anyway
 299   (reb-mode-common))
 300
 301 ;; Use the same "\C-c" keymap as `reb-mode' and use font-locking from
 302 ;; `emacs-lisp-mode'
 303 (define-key reb-lisp-mode-map "\C-c"
 304   (lookup-key reb-mode-map "\C-c"))
 305
 306 (defvar reb-subexp-mode-map
 307   (let ((m (make-keymap)))
 308     (suppress-keymap m)
 309     ;; Again share the "\C-c" keymap for the commands
 310     (define-key m "\C-c" (lookup-key reb-mode-map "\C-c"))
 311     (define-key m "q" 'reb-quit-subexp-mode)
 312     (dotimes (digit 10)
 313       (define-key m (int-to-string digit) 'reb-display-subexp))
 314     m)
 315   "Keymap used by the RE Builder for the subexpression mode.")
 316
 317 (defun reb-mode-common ()
 318   "Setup functions common to functions `reb-mode' and `reb-mode-lisp'."
 319
 320   (setq reb-mode-string  ""
 321         reb-valid-string ""
 322         mode-line-buffer-identification
 323                          '(25 . ("%b" reb-mode-string reb-valid-string)))
 324   (reb-update-modestring)
 325   (add-hook 'after-change-functions 'reb-auto-update nil t)
 326   ;; At least make the overlays go away if the buffer is killed
 327   (add-hook 'kill-buffer-hook 'reb-kill-buffer nil t)
 328   (reb-auto-update nil nil nil))
 329
 330 (defun reb-color-display-p ()
 331   "Return t if display is capable of displaying colors."
 332   (eq 'color
 333       ;; emacs/xemacs compatibility
 334       (if (fboundp 'frame-parameter)
 335           (frame-parameter (selected-frame) 'display-type)
 336         (if (fboundp 'frame-property)
 337             (frame-property (selected-frame) 'display-type)))))
 338
 339 (defsubst reb-lisp-syntax-p ()
 340   "Return non-nil if RE Builder uses a Lisp syntax."
 341   (memq reb-re-syntax '(lisp-re sregex rx)))
 342
 343 (defmacro reb-target-binding (symbol)
 344   "Return binding for SYMBOL in the RE Builder target buffer."
 345   `(with-current-buffer reb-target-buffer ,symbol))
 346
 347 (defun reb-initialize-buffer ()
 348   "Initialize the current buffer as a RE Builder buffer."
 349   (erase-buffer)
 350   (reb-insert-regexp)
 351   (goto-char (+ 2 (point-min)))
 352   (cond ((reb-lisp-syntax-p)
 353          (reb-lisp-mode))
 354         (t (reb-mode))))
 355
 356 (defun reb-mode-buffer-p ()
 357   "Return non-nil if the current buffer is a RE Builder buffer."
 358   (memq major-mode '(reb-mode reb-lisp-mode)))
 359
 360 ;;; This is to help people find this in Apropos.
 361 ;;;###autoload
 362 (defalias 'regexp-builder 're-builder)
 363
 364 ;;;###autoload
 365 (defun re-builder ()
 366   "Construct a regexp interactively."
 367   (interactive)
 368
 369   (if (and (string= (buffer-name) reb-buffer)
 370            (reb-mode-buffer-p))
 371       (message "Already in the RE Builder")
 372     (when reb-target-buffer
 373       (reb-delete-overlays))
 374     (setq reb-target-buffer (current-buffer)
 375           reb-target-window (selected-window)
 376           reb-window-config (current-window-configuration))
 377     (select-window (split-window (selected-window) (- (window-height) 4)))
 378     (switch-to-buffer (get-buffer-create reb-buffer))
 379     (reb-initialize-buffer)))
 380
 381 (defun reb-change-target-buffer (buf)
 382   "Change the target buffer and display it in the target window."
 383   (interactive "bSet target buffer to: ")
 384
 385   (let ((buffer (get-buffer buf)))
 386     (if (not buffer)
 387         (error "No such buffer")
 388       (reb-delete-overlays)
 389       (setq reb-target-buffer buffer)
 390       (reb-do-update
 391        (if reb-subexp-mode reb-subexp-displayed nil))
 392       (reb-update-modestring))))
 393
 394 (defun reb-force-update ()
 395   "Force an update in the RE Builder target window without a match limit."
 396   (interactive)
 397
 398   (let ((reb-auto-match-limit nil))
 399     (reb-update-overlays
 400      (if reb-subexp-mode reb-subexp-displayed nil))))
 401
 402 (defun reb-quit ()
 403   "Quit the RE Builder mode."
 404   (interactive)
 405
 406   (setq reb-subexp-mode nil
 407         reb-subexp-displayed nil)
 408   (reb-delete-overlays)
 409   (bury-buffer)
 410   (set-window-configuration reb-window-config))
 411
 412 (defun reb-next-match ()
 413   "Go to next match in the RE Builder target window."
 414   (interactive)
 415
 416   (reb-assert-buffer-in-window)
 417   (with-selected-window reb-target-window
 418     (if (not (re-search-forward reb-regexp (point-max) t))
 419         (message "No more matches")
 420       (reb-show-subexp
 421        (or (and reb-subexp-mode reb-subexp-displayed) 0)
 422        t))))
 423
 424 (defun reb-prev-match ()
 425   "Go to previous match in the RE Builder target window."
 426   (interactive)
 427
 428   (reb-assert-buffer-in-window)
 429   (with-selected-window reb-target-window
 430     (let ((p (point)))
 431       (goto-char (1- p))
 432       (if (re-search-backward reb-regexp (point-min) t)
 433           (reb-show-subexp
 434            (or (and reb-subexp-mode reb-subexp-displayed) 0)
 435            t)
 436         (goto-char p)
 437         (message "No more matches")))))
 438
 439 (defun reb-toggle-case ()
 440   "Toggle case sensitivity of searches for RE Builder target buffer."
 441   (interactive)
 442
 443   (with-current-buffer reb-target-buffer
 444     (setq case-fold-search (not case-fold-search)))
 445   (reb-update-modestring)
 446   (reb-auto-update nil nil nil t))
 447
 448 (defun reb-copy ()
 449   "Copy current RE into the kill ring for later insertion."
 450   (interactive)
 451
 452   (reb-update-regexp)
 453   (let ((re (with-output-to-string
 454               (print (reb-target-binding reb-regexp)))))
 455     (kill-new (substring re 1 (1- (length re))))
 456     (message "Regexp copied to kill-ring")))
 457
 458 ;; The subexpression mode is not electric because the number of
 459 ;; matches should be seen rather than a prompt.
 460 (defun reb-enter-subexp-mode ()
 461   "Enter the subexpression mode in the RE Builder."
 462   (interactive)
 463   (setq reb-subexp-mode t)
 464   (reb-update-modestring)
 465   (use-local-map reb-subexp-mode-map)
 466   (message "`0'-`9' to display subexpressions  `q' to quit subexp mode"))
 467
 468 (defun reb-show-subexp (subexp &optional pause)
 469   "Visually show limit of subexpression SUBEXP of recent search.
 470 On color displays this just puts point to the end of the expression as
 471 the match should already be marked by an overlay.
 472 On other displays jump to the beginning and the end of it.
 473 If the optional PAUSE is non-nil then pause at the end in any case."
 474   (with-selected-window reb-target-window
 475     (unless (reb-color-display-p)
 476       (goto-char (match-beginning subexp))
 477       (sit-for reb-blink-delay))
 478     (goto-char (match-end subexp))
 479     (when (or (not (reb-color-display-p)) pause)
 480       (sit-for reb-blink-delay))))
 481
 482 (defun reb-quit-subexp-mode ()
 483   "Quit the subexpression mode in the RE Builder."
 484   (interactive)
 485   (setq reb-subexp-mode nil
 486         reb-subexp-displayed nil)
 487   (reb-update-modestring)
 488   (use-local-map reb-mode-map)
 489   (reb-do-update))
 490
 491 (defun reb-change-syntax (&optional syntax)
 492   "Change the syntax used by the RE Builder.
 493 Optional argument SYNTAX must be specified if called non-interactively."
 494   (interactive
 495    (list (intern
 496           (completing-read "Select syntax: "
 497                            (mapcar (lambda (el) (cons (symbol-name el) 1))
 498                                    '(read string lisp-re sregex rx))
 499                            nil t (symbol-name reb-re-syntax)))))
 500
 501   (if (memq syntax '(read string lisp-re sregex rx))
 502       (let ((buffer (get-buffer reb-buffer)))
 503         (setq reb-re-syntax syntax)
 504         (when buffer
 505           (with-current-buffer buffer
 506             (reb-initialize-buffer))))
 507     (error "Invalid syntax: %s" syntax)))
 508
 509
 510 ;; Non-interactive functions below
 511 (defun reb-do-update (&optional subexp)
 512   "Update matches in the RE Builder target window.
 513 If SUBEXP is non-nil mark only the corresponding sub-expressions."
 514
 515   (reb-assert-buffer-in-window)
 516   (reb-update-regexp)
 517   (reb-update-overlays subexp))
 518
 519 (defun reb-auto-update (beg end lenold &optional force)
 520   "Called from `after-update-functions' to update the display.
 521 BEG, END and LENOLD are passed in from the hook.
 522 An actual update is only done if the regexp has changed or if the
 523 optional fourth argument FORCE is non-nil."
 524   (let ((prev-valid reb-valid-string)
 525         (new-valid
 526          (condition-case nil
 527              (progn
 528                (when (or (reb-update-regexp) force)
 529                  (reb-assert-buffer-in-window)
 530                  (reb-do-update))
 531                "")
 532            (error " *invalid*"))))
 533     (setq reb-valid-string new-valid)
 534     (force-mode-line-update)
 535
 536     ;; Through the caching of the re a change invalidating the syntax
 537     ;; for symbolic expressions will not delete the overlays so we
 538     ;; catch it here
 539     (when (and (reb-lisp-syntax-p)
 540                (not (string= prev-valid new-valid))
 541                (string= prev-valid ""))
 542       (reb-delete-overlays))))
 543
 544 (defun reb-delete-overlays ()
 545   "Delete all RE Builder overlays in the `reb-target-buffer' buffer."
 546   (when (buffer-live-p reb-target-buffer)
 547     (with-current-buffer reb-target-buffer
 548       (mapc 'delete-overlay reb-overlays)
 549       (setq reb-overlays nil))))
 550
 551 (defun reb-assert-buffer-in-window ()
 552   "Assert that `reb-target-buffer' is displayed in `reb-target-window'."
 553
 554   (if (not (eq reb-target-buffer (window-buffer reb-target-window)))
 555       (set-window-buffer reb-target-window reb-target-buffer)))
 556
 557 (defun reb-update-modestring ()
 558   "Update the variable `reb-mode-string' displayed in the mode line."
 559   (setq reb-mode-string
 560         (concat
 561          (if reb-subexp-mode
 562              (format " (subexp %s)" (or reb-subexp-displayed "-"))
 563            "")
 564          (if (not (reb-target-binding case-fold-search))
 565              " Case"
 566            "")))
 567   (force-mode-line-update))
 568
 569 (defun reb-display-subexp (&optional subexp)
 570   "Highlight only subexpression SUBEXP in the RE Builder."
 571   (interactive)
 572
 573   (setq reb-subexp-displayed
 574         (or subexp (string-to-number (format "%c" last-command-char))))
 575   (reb-update-modestring)
 576   (reb-do-update reb-subexp-displayed))
 577
 578 (defun reb-kill-buffer ()
 579   "When the RE Builder buffer is killed make sure no overlays stay around."
 580
 581   (when (reb-mode-buffer-p)
 582     (reb-delete-overlays)))
 583
 584
 585 ;; The next functions are the interface between the regexp and
 586 ;; its textual representation in the RE Builder buffer.
 587 ;; They are the only functions concerned with the actual syntax
 588 ;; being used.
 589 (defun reb-read-regexp ()
 590   "Read current RE."
 591   (save-excursion
 592     (cond ((eq reb-re-syntax 'read)
 593            (goto-char (point-min))
 594            (read (current-buffer)))
 595           ((eq reb-re-syntax 'string)
 596            (goto-char (point-min))
 597            (re-search-forward "\"")
 598            (let ((beg (point)))
 599              (goto-char (point-max))
 600              (re-search-backward "\"")
 601              (buffer-substring-no-properties beg (point))))
 602           ((reb-lisp-syntax-p)
 603            (buffer-string)))))
 604
 605 (defun reb-empty-regexp ()
 606   "Return empty RE for current syntax."
 607   (cond ((reb-lisp-syntax-p) "'()")
 608         (t "")))
 609
 610 (defun reb-insert-regexp ()
 611   "Insert current RE."
 612
 613   (let ((re (or (reb-target-binding reb-regexp)
 614                 (reb-empty-regexp))))
 615   (cond ((eq reb-re-syntax 'read)
 616          (print re (current-buffer)))
 617         ((eq reb-re-syntax 'string)
 618          (insert "\n\"" re "\""))
 619         ;; For the Lisp syntax we need the "source" of the regexp
 620         ((reb-lisp-syntax-p)
 621          (insert (or (reb-target-binding reb-regexp-src)
 622                      (reb-empty-regexp)))))))
 623
 624 (defun reb-cook-regexp (re)
 625   "Return RE after processing it according to `reb-re-syntax'."
 626   (cond ((eq reb-re-syntax 'lisp-re)
 627          (when (fboundp 'lre-compile-string)
 628            (lre-compile-string (eval (car (read-from-string re))))))
 629         ((eq reb-re-syntax 'sregex)
 630          (apply 'sregex (eval (car (read-from-string re)))))
 631         ((eq reb-re-syntax 'rx)
 632          (rx-to-string (eval (car (read-from-string re)))))
 633         (t re)))
 634
 635 (defun reb-update-regexp ()
 636   "Update the regexp for the target buffer.
 637 Return t if the (cooked) expression changed."
 638   (let* ((re-src (reb-read-regexp))
 639          (re (reb-cook-regexp re-src)))
 640     (with-current-buffer reb-target-buffer
 641       (let ((oldre reb-regexp))
 642         (prog1
 643             (not (string= oldre re))
 644           (setq reb-regexp re)
 645           ;; Only update the source re for the lisp formats
 646           (when (reb-lisp-syntax-p)
 647             (setq reb-regexp-src re-src)))))))
 648
 649
 650 ;; And now the real core of the whole thing
 651 (defun reb-count-subexps (re)
 652   "Return number of sub-expressions in the regexp RE."
 653
 654   (let ((i 0) (beg 0))
 655     (while (string-match "\\\\(" re beg)
 656       (setq i (1+ i)
 657             beg (match-end 0)))
 658     i))
 659
 660 (defun reb-update-overlays (&optional subexp)
 661   "Switch to `reb-target-buffer' and mark all matches of `reb-regexp'.
 662 If SUBEXP is non-nil mark only the corresponding sub-expressions."
 663   (let* ((re (reb-target-binding reb-regexp))
 664          (subexps (reb-count-subexps re))
 665          (matches 0)
 666          (submatches 0)
 667          firstmatch)
 668     (save-excursion
 669       (set-buffer reb-target-buffer)
 670       (reb-delete-overlays)
 671       (goto-char (point-min))
 672       (while (and (not (eobp))
 673                   (re-search-forward re (point-max) t)
 674                   (or (not reb-auto-match-limit)
 675                       (< matches reb-auto-match-limit)))
 676         (when (and (= 0 (length (match-string 0)))
 677                    (not (eobp)))
 678           (forward-char 1))
 679         (let ((i 0)
 680               suffix max-suffix)
 681           (setq matches (1+ matches))
 682           (while (<= i subexps)
 683             (when (and (or (not subexp) (= subexp i))
 684                        (match-beginning i))
 685               (let ((overlay (make-overlay (match-beginning i)
 686                                            (match-end i)))
 687                     ;; When we have exceeded the number of provided faces,
 688                     ;; cycle thru them where `max-suffix' denotes the maximum
 689                     ;; suffix for `reb-match-*' that has been defined and
 690                     ;; `suffix' the suffix calculated for the current match.
 691                     (face
 692                      (cond
 693                        (max-suffix
 694                         (if (= suffix max-suffix)
 695                             (setq suffix 1)
 696                           (setq suffix (1+ suffix)))
 697                         (intern-soft (format "reb-match-%d" suffix)))
 698                        ((intern-soft (format "reb-match-%d" i)))
 699                        ((setq max-suffix (1- i))
 700                         (setq suffix 1)
 701                         ;; `reb-match-1' must exist.
 702                         'reb-match-1))))
 703                 (unless firstmatch (setq firstmatch (match-data)))
 704                 (setq reb-overlays (cons overlay reb-overlays)
 705                       submatches (1+ submatches))
 706                 (overlay-put overlay 'face face)
 707                 (overlay-put overlay 'priority i)))
 708             (setq i (1+ i))))))
 709     (let ((count (if subexp submatches matches)))
 710       (message "%s %smatch%s%s"
 711                (if (= 0 count) "No" (int-to-string count))
 712                (if subexp "subexpression " "")
 713                (if (= 1 count) "" "es")
 714                (if (and reb-auto-match-limit
 715                         (= reb-auto-match-limit count))
 716                    " (limit reached)" "")))
 717     (when firstmatch
 718       (store-match-data firstmatch)
 719       (reb-show-subexp (or subexp 0)))))
 720
 721 ;; The End
 722 (defun re-builder-unload-function ()
 723   "Unload the RE Builder library."
 724   (when (buffer-live-p (get-buffer reb-buffer))
 725     (with-current-buffer reb-buffer
 726       (remove-hook 'after-change-functions 'reb-auto-update t)
 727       (remove-hook 'kill-buffer-hook 'reb-kill-buffer t)
 728       (when (reb-mode-buffer-p)
 729         (reb-delete-overlays)
 730         (funcall default-major-mode))))
 731   ;; continue standard unloading
 732   nil)
 733
 734 (provide 're-builder)
 735
 736 ;; arch-tag: 5c5515ac-4085-4524-a421-033f44f032e7
 737 ;;; re-builder.el ends here