[COMMIT] Re-builder; new package (with separated docs)

APPROVE COMMIT Detlev, the program is excellent, and adding the functionality as an XEmacs makes it much more convenient for our users to use. Norbert still has to do general package management for people to actually use it, by the way, so don’t try to check it out just yet. NOTE: This patch has been committed. xemacs-packages/re-builder/ChangeLog addition: 2005-02-27 Aidan Kehoe <kehoea(a)parhasard.net&gt; * Makefile: Created. XEmacs Packages (existing ChangeLogs) source patch: Diff command: cvs -q diff -Nu Files affected: xemacs-packages/re-builder/re-builder.texi xemacs-packages/re-builder/re-builder.el xemacs-packages/re-builder/package-info.in xemacs-packages/re-builder/OUR-CHANGES xemacs-packages/re-builder/Makefile Index: xemacs-packages/re-builder/Makefile =================================================================== RCS file: Makefile diff -N Makefile --- /dev/null Fri Mar 4 21:28:48 2005 +++ Makefile Fri Mar 4 21:28:25 2005 ＠＠ -0,0 +1,34 ＠＠ +# Makefile for the re-builder package. + +# This file is part of XEmacs. + +# XEmacs is free software; you can redistribute it and/or modify it +# under the terms of the GNU General Public License as published by the +# Free Software Foundation; either version 2, or (at your option) any +# later version. + +# XEmacs is distributed in the hope that it will be useful, but WITHOUT +# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or +# FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License +# for more details. + +# You should have received a copy of the GNU General Public License +# along with XEmacs; see the file COPYING. If not, write to +# the Free Software Foundation, Inc., 59 Temple Place - Suite 330, +# Boston, MA 02111-1307, USA. + +# The GNU Emacs CVS version of re-builder.el is canonical--we're +# distributing this to make it more convenient for XEmacs users. + +VERSION = 1.0 +AUTHOR_VERSION = 1.20 +MAINTAINER = Aidan Kehoe <aidan(a)xemacs.org&gt; +PACKAGE = re-builder +PKG_TYPE = regular +REQUIRES = fsf-compat +CATEGORY = standard +STANDARD_DOCS = t + +ELCS = re-builder.elc + +include ../../XEmacs.rules Index: xemacs-packages/re-builder/OUR-CHANGES =================================================================== RCS file: OUR-CHANGES diff -N OUR-CHANGES --- /dev/null Fri Mar 4 21:28:48 2005 +++ OUR-CHANGES Fri Mar 4 21:28:25 2005 ＠＠ -0,0 +1,65 ＠＠ +Index: re-builder.el +=================================================================== +RCS file: /cvsroot/emacs/emacs/lisp/emacs-lisp/re-builder.el,v +retrieving revision 1.20 +diff -u -u -r1.20 re-builder.el +--- re-builder.el 27 Feb 2005 10:35:51 -0000 1.20 ++++ re-builder.el 27 Feb 2005 17:17:00 -0000 +＠＠ -71,6 +71,9 ＠＠ + ;; is a package by me and its support may go away as it is nearly the + ;; same as the `sregex' package in Emacs) + ++;; Note that the `sregex,' `rx' and `lisp-re' syntaxes will only be ++;; available in XEmacs if you've installed them yourself. ++ + ;; Editing symbolic expressions is done through a major mode derived + ;; from `emacs-lisp-mode' so you'll get all the good stuff like + ;; automatic indentation and font-locking etc. +＠＠ -148,9 +151,9 ＠＠ + + (defface reb-match-0 + '((((class color) (background light)) +-:background "lightblue") ++ (:background "lightblue")) + (((class color) (background dark)) +-:background "steelblue4") ++ (:background "steelblue4")) + (t +:inverse-video t)) + "Used for displaying the whole match." +＠＠ -158,9 +161,9 ＠＠ + + (defface reb-match-1 + '((((class color) (background light)) +-:background "aquamarine") ++ (:background "aquamarine")) + (((class color) (background dark)) +-:background "blue3") ++ (:background "blue3")) + (t +:inverse-video t)) + "Used for displaying the first matching subexpression." +＠＠ -168,9 +171,9 ＠＠ + + (defface reb-match-2 + '((((class color) (background light)) +-:background "springgreen") ++ (:background "springgreen")) + (((class color) (background dark)) +-:background "chartreuse4") ++ (:background "chartreuse4")) + (t +:inverse-video t)) + "Used for displaying the second matching subexpression." +＠＠ -178,9 +181,9 ＠＠ + + (defface reb-match-3 + '((((class color) (background light)) +-:background "yellow") ++ (:background "yellow")) + (((class color) (background dark)) +-:background "sienna4") ++ (:background "sienna4")) + (t +:inverse-video t)) + "Used for displaying the third matching subexpression." Index: xemacs-packages/re-builder/package-info.in =================================================================== RCS file: package-info.in diff -N package-info.in --- /dev/null Fri Mar 4 21:28:48 2005 +++ package-info.in Fri Mar 4 21:28:25 2005 ＠＠ -0,0 +1,19 ＠＠ +(re-builder + (standards-version 1.1 + version VERSION + author-version AUTHOR_VERSION + date DATE + build-date BUILD_DATE + maintainer MAINTAINER + distribution xemacs + priority medium + category CATEGORY + dump nil + description "Interactive development tool for regular expressions." + filename FILENAME + md5sum MD5SUM + size SIZE + provides (re-builder) + requires (REQUIRES) + type regular +)) Index: xemacs-packages/re-builder/re-builder.el =================================================================== RCS file: re-builder.el diff -N re-builder.el --- /dev/null Fri Mar 4 21:28:48 2005 +++ re-builder.el Fri Mar 4 21:28:25 2005 ＠＠ -0,0 +1,699 ＠＠ +;;; re-builder.el --- building Regexps with visual feedback + +;; Copyright (C) 1999, 2000, 2001, 2002, 2004 Free Software Foundation, Inc. + +;; Author: Detlev Zundel <dzu(a)gnu.org&gt; +;; Keywords: matching, lisp, tools + +;; This file is part of GNU Emacs. + +;; GNU Emacs is free software; you can redistribute it and/or modify +;; it under the terms of the GNU General Public License as published by +;; the Free Software Foundation; either version 2, or (at your option) +;; any later version. + +;; GNU Emacs is distributed in the hope that it will be useful, +;; but WITHOUT ANY WARRANTY; without even the implied warranty of +;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +;; GNU General Public License for more details. + +;; You should have received a copy of the GNU General Public License +;; along with GNU Emacs; see the file COPYING. If not, write to the +;; Free Software Foundation, Inc., 59 Temple Place - Suite 330, +;; Boston, MA 02111-1307, USA. + +;;; Commentary: + +;; When I have to come up with regular expressions that are more +;; complex than simple string matchers, especially if they contain sub +;; expressions, I find myself spending quite some time in the +;; `development cycle'. `re-builder' aims to shorten this time span +;; so I can get on with the more interesting bits. + +;; With it you can have immediate visual feedback about how well the +;; regexp behaves to your expectations on the intended data. + +;; When called up `re-builder' attaches itself to the current buffer +;; which becomes its target buffer, where all the matching is done. +;; The active window is split so you have a view on the data while +;; authoring the RE. If the edited expression is valid the matches in +;; the target buffer are marked automatically with colored overlays +;; (for non-color displays see below) giving you feedback over the +;; extents of the matched (sub) expressions. The (non-)validity is +;; shown only in the modeline without throwing the errors at you. If +;; you want to know the reason why RE Builder considers it as invalid +;; call `reb-force-update' ("\C-c\C-u") which should reveal the error. + +;; The target buffer can be changed with `reb-change-target-buffer' +;; ("\C-c\C-b"). Changing the target buffer automatically removes +;; the overlays from the old buffer and displays the new one in the +;; target window. + +;; The `re-builder' keeps the focus while updating the matches in the +;; target buffer so corrections are easy to incorporate. If you are +;; satisfied with the result you can paste the RE to the kill-ring +;; with `reb-copy' ("\C-c\C-w"), quit the `re-builder' ("\C-c\C-q") +;; and use it wherever you need it. + +;; As the automatic updates can take some time on large buffers, they +;; can be limited by `reb-auto-match-limit' so that they should not +;; have a negative impact on the editing. Setting it to nil makes +;; even the auto updates go all the way. Forcing an update overrides +;; this limit allowing an easy way to see all matches. + +;; Currently `re-builder' understands five different forms of input, +;; namely `read', `string', `rx', `sregex' and `lisp-re' syntax. Read +;; syntax and string syntax are both delimited by `"'s and behave +;; according to their name. With the `string' syntax there's no need +;; to escape the backslashes and double quotes simplifying the editing +;; somewhat. The other three allow editing of symbolic regular +;; expressions supported by the packages of the same name. (`lisp-re' +;; is a package by me and its support may go away as it is nearly the +;; same as the `sregex' package in Emacs) + +;; Note that the `sregex,' `rx' and `lisp-re' syntaxes will only be +;; available in XEmacs if you've installed them yourself. + +;; Editing symbolic expressions is done through a major mode derived +;; from `emacs-lisp-mode' so you'll get all the good stuff like +;; automatic indentation and font-locking etc. + +;; When editing a symbolic regular expression, only the first +;; expression in the RE Builder buffer is considered, which helps +;; limiting the extent of the expression like the `"'s do for the text +;; modes. For the `sregex' syntax the function `sregex' is applied to +;; the evaluated expression read. So you can use quoted arguments +;; with something like '("findme") or you can construct arguments to +;; your hearts delight with a valid ELisp expression. (The compiled +;; string form will be copied by `reb-copy') If you want to take +;; a glance at the corresponding string you can temporarily change the +;; input syntax. + +;; Changing the input syntax is transparent (for the obvious exception +;; non-symbolic -> symbolic) so you can change your mind as often as +;; you like. + +;; There is also a shortcut function for toggling the +;; `case-fold-search' variable in the target buffer with an immediate +;; update. + + +;; Q: But what if my display cannot show colored overlays? +;; A: Then the cursor will flash around the matched text making it stand +;; out. + +;; Q: But how can I then make out the sub-expressions? +;; A: Thats where the `sub-expression mode' comes in. In it only the +;; digit keys are assigned to perform an update that will flash the +;; corresponding subexp only. + + +;;; Code: + +;; On XEmacs, load the overlay compatibility library +(if (not (fboundp 'make-overlay)) + (require 'overlay)) + +;; User costomizable variables +(defgroup re-builder nil + "Options for the RE Builder." +:group 'lisp +:prefix "reb-") + +(defcustom reb-blink-delay 0.5 + "*Seconds to blink cursor for next/previous match in RE Builder." +:group 're-builder +:type 'number) + +(defcustom reb-mode-hook nil + "*Hooks to run on entering RE Builder mode." +:group 're-builder +:type 'hook) + +(defcustom reb-re-syntax 'read + "*Syntax for the REs in the RE Builder. +Can either be `read', `string', `sregex' or `lisp-re'." +:group 're-builder +:type '(choice (const :tag "Read syntax" read) + (const :tag "String syntax" string) + (const :tag "`sregex' syntax" sregex) + (const :tag "`lisp-re' syntax" lisp-re) + (const :tag "`rx' syntax" rx) + (value: string))) + +(defcustom reb-auto-match-limit 200 + "*Positive integer limiting the matches for RE Builder auto updates. +Set it to nil if you don't want limits here." +:group 're-builder +:type '(restricted-sexp :match-alternatives + (integerp 'nil))) + + +(defface reb-match-0 + '((((class color) (background light)) + (:background "lightblue")) + (((class color) (background dark)) + (:background "steelblue4")) + (t +:inverse-video t)) + "Used for displaying the whole match." +:group 're-builder) + +(defface reb-match-1 + '((((class color) (background light)) + (:background "aquamarine")) + (((class color) (background dark)) + (:background "blue3")) + (t +:inverse-video t)) + "Used for displaying the first matching subexpression." +:group 're-builder) + +(defface reb-match-2 + '((((class color) (background light)) + (:background "springgreen")) + (((class color) (background dark)) + (:background "chartreuse4")) + (t +:inverse-video t)) + "Used for displaying the second matching subexpression." +:group 're-builder) + +(defface reb-match-3 + '((((class color) (background light)) + (:background "yellow")) + (((class color) (background dark)) + (:background "sienna4")) + (t +:inverse-video t)) + "Used for displaying the third matching subexpression." +:group 're-builder) + +;; Internal variables below +(defvar reb-mode nil + "Enables the RE Builder minor mode.") + +(defvar reb-target-buffer nil + "Buffer to which the RE is applied to.") + +(defvar reb-target-window nil + "Window to which the RE is applied to.") + +(defvar reb-regexp nil + "Last regexp used by RE Builder.") + +(defvar reb-regexp-src nil + "Last regexp used by RE Builder before processing it. +Except for Lisp syntax this is the same as `reb-regexp'.") + +(defvar reb-overlays nil + "List of overlays of the RE Builder.") + +(defvar reb-window-config nil + "Old window configuration.") + +(defvar reb-subexp-mode nil + "Indicates whether sub-exp mode is active.") + +(defvar reb-subexp-displayed nil + "Indicates which sub-exp is active.") + +(defvar reb-mode-string "" + "String in mode line for additional info.") + +(defvar reb-valid-string "" + "String in mode line showing validity of RE.") + +(make-variable-buffer-local 'reb-overlays) +(make-variable-buffer-local 'reb-regexp) +(make-variable-buffer-local 'reb-regexp-src) + +(defconst reb-buffer "*RE-Builder*" + "Buffer to use for the RE Builder.") + +;; Define the local "\C-c" keymap +(defvar reb-mode-map + (let ((map (make-sparse-keymap))) + (define-key map "\C-c\C-c" 'reb-toggle-case) + (define-key map "\C-c\C-q" 'reb-quit) + (define-key map "\C-c\C-w" 'reb-copy) + (define-key map "\C-c\C-s" 'reb-next-match) + (define-key map "\C-c\C-r" 'reb-prev-match) + (define-key map "\C-c\C-i" 'reb-change-syntax) + (define-key map "\C-c\C-e" 'reb-enter-subexp-mode) + (define-key map "\C-c\C-b" 'reb-change-target-buffer) + (define-key map "\C-c\C-u" 'reb-force-update) + map) + "Keymap used by the RE Builder.") + +(defun reb-mode () + "Major mode for interactively building Regular Expressions. +\\{reb-mode-map}" + (interactive) + (kill-all-local-variables) + (setq major-mode 'reb-mode + mode-name "RE Builder") + (use-local-map reb-mode-map) + (reb-mode-common) + (run-hooks 'reb-mode-hook)) + +(define-derived-mode reb-lisp-mode + emacs-lisp-mode "RE Builder Lisp" + "Major mode for interactively building symbolic Regular Expressions." + (cond ((eq reb-re-syntax 'lisp-re) ; Pull in packages + (require 'lisp-re)) ; as needed + ((eq reb-re-syntax 'sregex) ; sregex is not autoloaded + (require 'sregex)) ; right now.. + ((eq reb-re-syntax 'rx) ; rx-to-string is autoloaded + (require 'rx))) ; require rx anyway + (reb-mode-common)) + +;; Use the same "\C-c" keymap as `reb-mode' and use font-locking from +;; `emacs-lisp-mode' +(define-key reb-lisp-mode-map "\C-c" + (lookup-key reb-mode-map "\C-c")) + +(defvar reb-subexp-mode-map + (let ((m (make-keymap))) + (suppress-keymap m) + ;; Again share the "\C-c" keymap for the commands + (define-key m "\C-c" (lookup-key reb-mode-map "\C-c")) + (define-key m "q" 'reb-quit-subexp-mode) + (dotimes (digit 10) + (define-key m (int-to-string digit) 'reb-display-subexp)) + m) + "Keymap used by the RE Builder for the subexpression mode.") + +(defun reb-mode-common () + "Setup functions common to functions `reb-mode' and `reb-mode-lisp'." + + (setq reb-mode-string "" + reb-valid-string "" + mode-line-buffer-identification + '(25 . ("%b" reb-mode-string reb-valid-string))) + (reb-update-modestring) + (make-local-variable 'after-change-functions) + (add-hook 'after-change-functions + 'reb-auto-update) + ;; At least make the overlays go away if the buffer is killed + (make-local-variable 'reb-kill-buffer) + (add-hook 'kill-buffer-hook 'reb-kill-buffer) + (reb-auto-update nil nil nil)) + + +;; Handy macro for doing things in other windows +(defmacro reb-with-current-window (window &rest body) + "With WINDOW selected evaluate BODY forms and reselect previous window." + + (let ((oldwindow (make-symbol "*oldwindow*"))) + `(let ((,oldwindow (selected-window))) + (select-window ,window) + (unwind-protect + (progn + ,＠body) + (select-window ,oldwindow))))) +(put 'reb-with-current-window 'lisp-indent-function 0) + +(defun reb-color-display-p () + "Return t if display is capable of displaying colors." + (eq 'color + ;; emacs/xemacs compatibility + (if (fboundp 'frame-parameter) + (frame-parameter (selected-frame) 'display-type) + (frame-property (selected-frame) 'display-type)))) + +(defsubst reb-lisp-syntax-p () + "Return non-nil if RE Builder uses a Lisp syntax." + (memq reb-re-syntax '(lisp-re sregex rx))) + +(defmacro reb-target-binding (symbol) + "Return binding for SYMBOL in the RE Builder target buffer." + `(with-current-buffer reb-target-buffer ,symbol)) + +;;; This is to help people find this in Apropos. +;;;###autoload +(defun regexp-builder () + "Alias for `re-builder': Construct a regexp interactively." + (interactive) + (re-builder)) + +;;;###autoload +(defun re-builder () + "Construct a regexp interactively." + (interactive) + + (if (and (string= (buffer-name) reb-buffer) + (memq major-mode '(reb-mode reb-lisp-mode))) + (message "Already in the RE Builder") + (if reb-target-buffer + (reb-delete-overlays)) + (setq reb-target-buffer (current-buffer) + reb-target-window (selected-window) + reb-window-config (current-window-configuration)) + (select-window (split-window (selected-window) (- (window-height) 4))) + (switch-to-buffer (get-buffer-create reb-buffer)) + (erase-buffer) + (reb-insert-regexp) + (goto-char (+ 2 (point-min))) + (cond + ((reb-lisp-syntax-p) + (reb-lisp-mode)) + (t (reb-mode))))) + +(defun reb-change-target-buffer (buf) + "Change the target buffer and display it in the target window." + (interactive "bSet target buffer to: ") + + (let ((buffer (get-buffer buf))) + (if (not buffer) + (error "No such buffer") + (reb-delete-overlays) + (setq reb-target-buffer buffer) + (reb-do-update + (if reb-subexp-mode reb-subexp-displayed nil)) + (reb-update-modestring)))) + +(defun reb-force-update () + "Force an update in the RE Builder target window without a match limit." + (interactive) + + (let ((reb-auto-match-limit nil)) + (reb-update-overlays + (if reb-subexp-mode reb-subexp-displayed nil)))) + +(defun reb-quit () + "Quit the RE Builder mode." + (interactive) + + (setq reb-subexp-mode nil + reb-subexp-displayed nil) + (reb-delete-overlays) + (bury-buffer) + (set-window-configuration reb-window-config)) + +(defun reb-next-match () + "Go to next match in the RE Builder target window." + (interactive) + + (reb-assert-buffer-in-window) + (reb-with-current-window + reb-target-window + (if (not (re-search-forward reb-regexp (point-max) t)) + (message "No more matches.") + (reb-show-subexp + (or (and reb-subexp-mode reb-subexp-displayed) 0) + t)))) + +(defun reb-prev-match () + "Go to previous match in the RE Builder target window." + (interactive) + + (reb-assert-buffer-in-window) + (reb-with-current-window reb-target-window + (goto-char (1- (point))) + (if (not (re-search-backward reb-regexp (point-min) t)) + (message "No more matches.") + (reb-show-subexp + (or (and reb-subexp-mode reb-subexp-displayed) 0) + t)))) + +(defun reb-toggle-case () + "Toggle case sensitivity of searches for RE Builder target buffer." + (interactive) + + (with-current-buffer reb-target-buffer + (setq case-fold-search (not case-fold-search))) + (reb-update-modestring) + (reb-auto-update nil nil nil t)) + +(defun reb-copy () + "Copy current RE into the kill ring for later insertion." + (interactive) + + (reb-update-regexp) + (let ((re (with-output-to-string + (print (reb-target-binding reb-regexp))))) + (kill-new (substring re 1 (1- (length re)))) + (message "Regexp copied to kill-ring"))) + +;; The subexpression mode is not electric because the number of +;; matches should be seen rather than a prompt. +(defun reb-enter-subexp-mode () + "Enter the subexpression mode in the RE Builder." + (interactive) + (setq reb-subexp-mode t) + (reb-update-modestring) + (use-local-map reb-subexp-mode-map) + (message "`0'-`9' to display subexpressions `q' to quit subexp mode.")) + +(defun reb-show-subexp (subexp &optional pause) + "Visually show limit of subexpression SUBEXP of recent search. +On color displays this just puts point to the end of the expression as +the match should already be marked by an overlay. +On other displays jump to the beginning and the end of it. +If the optional PAUSE is non-nil then pause at the end in any case." + (reb-with-current-window reb-target-window + (if (not (reb-color-display-p)) + (progn (goto-char (match-beginning subexp)) + (sit-for reb-blink-delay))) + (goto-char (match-end subexp)) + (if (or (not (reb-color-display-p)) pause) + (sit-for reb-blink-delay)))) + +(defun reb-quit-subexp-mode () + "Quit the subexpression mode in the RE Builder." + (interactive) + (setq reb-subexp-mode nil + reb-subexp-displayed nil) + (reb-update-modestring) + (use-local-map reb-mode-map) + (reb-do-update)) + +(defun reb-change-syntax (&optional syntax) + "Change the syntax used by the RE Builder. +Optional argument SYNTAX must be specified if called non-interactively." + (interactive + (list (intern + (completing-read "Select syntax: " + (mapcar (lambda (el) (cons (symbol-name el) 1)) + '(read string lisp-re sregex rx)) + nil t (symbol-name reb-re-syntax))))) + + (if (memq syntax '(read string lisp-re sregex rx)) + (let ((buffer (get-buffer reb-buffer))) + (setq reb-re-syntax syntax) + (if buffer + (with-current-buffer buffer + (erase-buffer) + (reb-insert-regexp) + (goto-char (+ 2 (point-min))) + (cond ((reb-lisp-syntax-p) + (reb-lisp-mode)) + (t (reb-mode)))))) + (error "Invalid syntax: %s" syntax))) + + +;; Non-interactive functions below +(defun reb-do-update (&optional subexp) + "Update matches in the RE Builder target window. +If SUBEXP is non-nil mark only the corresponding sub-expressions." + + (reb-assert-buffer-in-window) + (reb-update-regexp) + (reb-update-overlays subexp)) + +(defun reb-auto-update (beg end lenold &optional force) + "Called from `after-update-functions' to update the display. +BEG, END and LENOLD are passed in from the hook. +An actual update is only done if the regexp has changed or if the +optional fourth argument FORCE is non-nil." + (let ((prev-valid reb-valid-string) + (new-valid + (condition-case nil + (progn + (if (or (reb-update-regexp) force) + (progn + (reb-assert-buffer-in-window) + (reb-do-update))) + "") + (error " *invalid*")))) + (setq reb-valid-string new-valid) + (force-mode-line-update) + + ;; Through the caching of the re a change invalidating the syntax + ;; for symbolic expressions will not delete the overlays so we + ;; catch it here + (if (and (reb-lisp-syntax-p) + (not (string= prev-valid new-valid)) + (string= prev-valid "")) + (reb-delete-overlays)))) + +(defun reb-delete-overlays () + "Delete all RE Builder overlays in the `reb-target-buffer' buffer." + (if (buffer-live-p reb-target-buffer) + (with-current-buffer reb-target-buffer + (mapcar 'delete-overlay reb-overlays) + (setq reb-overlays nil)))) + +(defun reb-assert-buffer-in-window () + "Assert that `reb-target-buffer' is displayed in `reb-target-window'." + + (if (not (eq reb-target-buffer (window-buffer reb-target-window))) + (set-window-buffer reb-target-window reb-target-buffer))) + +(defun reb-update-modestring () + "Update the variable `reb-mode-string' displayed in the mode line." + (setq reb-mode-string + (concat + (if reb-subexp-mode + (format " (subexp %s)" (or reb-subexp-displayed "-")) + "") + (if (not (reb-target-binding case-fold-search)) + " Case" + ""))) + (force-mode-line-update)) + +(defun reb-display-subexp (&optional subexp) + "Highlight only subexpression SUBEXP in the RE Builder." + (interactive) + + (setq reb-subexp-displayed + (or subexp (string-to-int (format "%c" last-command-char)))) + (reb-update-modestring) + (reb-do-update reb-subexp-displayed)) + +(defun reb-kill-buffer () + "When the RE Builder buffer is killed make sure no overlays stay around." + + (if (member major-mode '(reb-mode reb-lisp-mode)) + (reb-delete-overlays))) + + +;; The next functions are the interface between the regexp and +;; its textual representation in the RE Builder buffer. +;; They are the only functions concerned with the actual syntax +;; being used. +(defun reb-read-regexp () + "Read current RE." + (save-excursion + (cond ((eq reb-re-syntax 'read) + (goto-char (point-min)) + (read (current-buffer))) + ((eq reb-re-syntax 'string) + (goto-char (point-min)) + (re-search-forward "\"") + (let ((beg (point))) + (goto-char (point-max)) + (re-search-backward "\"") + (buffer-substring-no-properties beg (point)))) + ((reb-lisp-syntax-p) + (buffer-string))))) + +(defun reb-empty-regexp () + "Return empty RE for current syntax." + (cond ((reb-lisp-syntax-p) "'()") + (t ""))) + +(defun reb-insert-regexp () + "Insert current RE." + + (let ((re (or (reb-target-binding reb-regexp) + (reb-empty-regexp)))) + (cond ((eq reb-re-syntax 'read) + (print re (current-buffer))) + ((eq reb-re-syntax 'string) + (insert "\n\"" re "\"")) + ;; For the Lisp syntax we need the "source" of the regexp + ((reb-lisp-syntax-p) + (insert (or (reb-target-binding reb-regexp-src) + (reb-empty-regexp))))))) + +(defun reb-cook-regexp (re) + "Return RE after processing it according to `reb-re-syntax'." + (cond ((eq reb-re-syntax 'lisp-re) + (lre-compile-string (eval (car (read-from-string re))))) + ((eq reb-re-syntax 'sregex) + (apply 'sregex (eval (car (read-from-string re))))) + ((eq reb-re-syntax 'rx) + (rx-to-string (eval (car (read-from-string re))))) + (t re))) + +(defun reb-update-regexp () + "Update the regexp for the target buffer. +Return t if the (cooked) expression changed." + (let* ((re-src (reb-read-regexp)) + (re (reb-cook-regexp re-src))) + (with-current-buffer reb-target-buffer + (let ((oldre reb-regexp)) + (prog1 + (not (string= oldre re)) + (setq reb-regexp re) + ;; Only update the source re for the lisp formats + (if (reb-lisp-syntax-p) + (setq reb-regexp-src re-src))))))) + + +;; And now the real core of the whole thing +(defun reb-count-subexps (re) + "Return number of sub-expressions in the regexp RE." + + (let ((i 0) (beg 0)) + (while (string-match "\\\\(" re beg) + (setq i (1+ i) + beg (match-end 0))) + i)) + + +(defun reb-update-overlays (&optional subexp) + "Switch to `reb-target-buffer' and mark all matches of `reb-regexp'. +If SUBEXP is non-nil mark only the corresponding sub-expressions." + + (let* ((re (reb-target-binding reb-regexp)) + (subexps (reb-count-subexps re)) + (matches 0) + (submatches 0) + firstmatch) + (save-excursion + (set-buffer reb-target-buffer) + (reb-delete-overlays) + (goto-char (point-min)) + (while (and (re-search-forward re (point-max) t) + (or (not reb-auto-match-limit) + (< matches reb-auto-match-limit))) + (if (= 0 (length (match-string 0))) + (error "Empty regular expression!")) + (let ((i 0)) + (setq matches (1+ matches)) + (while (<= i subexps) + (if (and (or (not subexp) (= subexp i)) + (match-beginning i)) + (let ((overlay (make-overlay (match-beginning i) + (match-end i))) + (face-name (format "reb-match-%d" i))) + (if (not firstmatch) + (setq firstmatch (match-data))) + (setq reb-overlays (cons overlay reb-overlays) + submatches (1+ submatches)) + (overlay-put + overlay 'face + (or (intern-soft face-name) + (error "Too many subexpressions - face `%s' not defined" + face-name ))) + (overlay-put overlay 'priority i))) + (setq i (1+ i)))))) + (let ((count (if subexp submatches matches))) + (message "%s %smatch%s%s" + (if (= 0 count) "No" (int-to-string count)) + (if subexp "subexpression " "") + (if (= 1 count) "" "es") + (if (and reb-auto-match-limit + (= reb-auto-match-limit count)) + " (limit reached)" ""))) + (if firstmatch + (progn (store-match-data firstmatch) + (reb-show-subexp (or subexp 0)))))) + +(provide 're-builder) + +;;; arch-tag: 5c5515ac-4085-4524-a421-033f44f032e7 +;;; re-builder.el ends here Index: xemacs-packages/re-builder/re-builder.texi =================================================================== RCS file: re-builder.texi diff -N re-builder.texi --- /dev/null Fri Mar 4 21:28:48 2005 +++ re-builder.texi Fri Mar 4 21:28:26 2005 ＠＠ -0,0 +1,282 ＠＠ +\input texinfo ＠c -*-texinfo-*- + +＠c Manual for the XEmacs re-builder package. + +＠c ** #### something uses these headers, find out how and explain here +＠c %**start of header +＠setfilename re-builder.info +＠settitle Visual development of regular expressions +＠setchapternewpage odd +＠c %**end of header + +＠c Version values, for easy modification +＠set VERSION 1.1 +＠set UPDATED Friday, March 4, 2005 + +＠c ** Many people seem to prefer this footenote style +＠footnotestyle end + +＠direntry +* re-builder:: Write regular expressions with visual feedback. +＠end direntry + +＠c ** It is often convenient to use a macro for names which have unusual +＠c ** spelling or formatting conventions. +＠c Macro to make formatting of the package name consistent. +＠macro pkgname +＠i{re-builder} +＠end macro + +＠c Copying permissions, et al +＠c Note that this whole section is repeated thrice, once for the Info +＠c version, once for TeX, and once for HTML. +＠c Note that if you combine this document with others' work, you may +＠c need to change the permissions statement. Make sure you do so in all +＠c three places. +＠c #### Probably not the right place for HTML. +＠html +This file documents the ＠pkgname{} XEmacs package, which provides visual +feedback when developing regular expressions. + +This documentation was taken from the source file, ＠file{re-builder.el}, +which is subject to the following conditions; because of the nature of +the GNU GPL, this file is as a result also subject to those conditions. + +Copyright ＠copyright{} 1999, 2000, 2001, 2002, 2004 Free Software +Foundation, Inc. + +This file is part of GNU Emacs. + +GNU Emacs is free software; you can redistribute it and/or modify it +under the terms of the GNU General Public License as published by the +Free Software Foundation; either version 2, or (at your option) any +later version. + +GNU Emacs is distributed in the hope that it will be useful, but WITHOUT +ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or +FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License +for more details. + +You should have received a copy of the GNU General Public License along +with GNU Emacs; see the file COPYING. If not, write to the Free +Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA +02111-1307, USA. + +End of permissions notice. +＠end html + +＠ifinfo +This file documents the ＠pkgname{} XEmacs package, which provides visual +feedback when developing regular expressions. + +This documentation was taken from the source file, ＠file{re-builder.el}, +which is subject to the following conditions; because of the nature of +the GNU GPL, this file is as a result also subject to those conditions. + +Copyright ＠copyright{} 1999, 2000, 2001, 2002, 2004 Free Software +Foundation, Inc. + +This file is part of GNU Emacs. + +GNU Emacs is free software; you can redistribute it and/or modify it +under the terms of the GNU General Public License as published by the +Free Software Foundation; either version 2, or (at your option) any +later version. + +GNU Emacs is distributed in the hope that it will be useful, but WITHOUT +ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or +FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License +for more details. + +You should have received a copy of the GNU General Public License along +with GNU Emacs; see the file COPYING. If not, write to the Free +Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA +02111-1307, USA. + +End of permissions notice. +＠end ifinfo + +＠tex + +＠titlepage +＠title R +＠subtitle Last updated ＠value{UPDATED} + +＠author Detlev Zundel. Texinfo conversion by Aidan Kehoe. +＠page +This file documents the ＠pkgname{} XEmacs package, which provides visual +feedback when developing regular expressions. + +This documentation was taken from the source file, ＠file{re-builder.el}, +which is subject to the following conditions; because of the nature of +the GNU GPL, this file is as a result also subject to those conditions. + +＠vskip 0pt plus 1filll +Copyright ＠copyright{} 1999, 2000, 2001, 2002, 2004 Free Software +Foundation, Inc. + +This file is part of GNU Emacs. + +GNU Emacs is free software; you can redistribute it and/or modify it +under the terms of the GNU General Public License as published by the +Free Software Foundation; either version 2, or (at your option) any +later version. + +GNU Emacs is distributed in the hope that it will be useful, but WITHOUT +ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or +FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License +for more details. + +You should have received a copy of the GNU General Public License along +with GNU Emacs; see the file COPYING. If not, write to the Free +Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA +02111-1307, USA. + +＠end titlepage +＠page + +＠end tex + +＠ifnottex +＠node Top, Copying, (dir), (dir) +＠top Re-builder on XEmacs + +When I have to come up with regular expressions that are more +complex than simple string matchers, especially if they contain sub +expressions, I find myself spending quite some time in the +`development cycle'. `re-builder' aims to shorten this time span +so I can get on with the more interesting bits. + +With it you can have immediate visual feedback about how well the +regexp behaves to your expectations on the intended data. + +This is version ＠value{VERSION} of the ＠pkgname{} manual, last updated on +＠value{UPDATED}. + +＠end ifnottex + +＠menu +* Copying:: ＠pkgname{} copying conditions. +* Overview:: ＠pkgname{} history and general information. + +For general users: +* Usage:: An overview of the operation of ＠pkgname{}. +* Regex Types:: Types of regular expression handled. +* Questions:: A couple of selected queries. +＠end menu + +＠node Copying, Overview, Top, Top +＠chapter ＠pkgname{} Copying Conditions + +＠c ** CHECK THE COPYRIGHT DATE(S) AND HOLDER(S)! + +Copyright (C) 1999, 2000, 2001, 2002, 2004 Free Software Foundation, Inc. + +＠pkgname{} is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 2, or (at your option) +any later version. + +＠pkgname{} is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for more details. + +You should have received a copy of the GNU General Public License +along with XEmacs; see the file COPYING. If not, write to the +Free Software Foundation, Inc., 59 Temple Place - Suite 330, +Boston, MA 02111-1307, USA. + +＠node Overview, Usage, Copying, Top +＠chapter An Overview of ＠pkgname{} + +When I have to come up with regular expressions that are more complex +than simple string matchers, especially if they contain sub expressions, +I find myself spending quite some time in the `development cycle'. +＠pkgname{} aims to shorten this time span so I can get on with the more +interesting bits. + +With it you can have immediate visual feedback about how well the regexp +behaves to your expectations on the intended data. + +＠node Usage, Regex Types, Overview, Top +＠chapter Operation of ＠pkgname{} + +When called up, with ＠kbd{M-x re-builder RET}, ＠pkgname{} attaches +itself to the current buffer which becomes its target buffer, where all +the matching is done. The active window is split so you have a view on +the data while authoring the RE. If the edited expression is valid the +matches in the target buffer are marked automatically with colored +overlays (for non-color displays see below) giving you feedback over the +extents of the matched (sub) expressions. The (non-)validity is shown +only in the modeline without throwing the errors at you. If you want to +know the reason why RE Builder considers it as invalid call +＠kbd{reb-force-update} (＠kbd{C-c C-u}) which should reveal the error. + +The target buffer can be changed with ＠code{reb-change-target-buffer} +(＠kbd{C-c C-b}). Changing the target buffer automatically removes +the overlays from the old buffer and displays the new one in the +target window. + +＠pkgname{} keeps the focus while updating the matches in the target +buffer so corrections are easy to incorporate. If you are satisfied +with the result you can paste the RE to the kill-ring with +＠code{reb-copy} (＠kbd{C-c C-w}), quit ＠pkgname{} (＠kbd{C-c C-q}) and use +it wherever you need it. + +As the automatic updates can take some time on large buffers, they can +be limited by ＠code{reb-auto-match-limit} so that they should not have a +negative impact on the editing. Setting it to nil makes even the auto +updates go all the way. Forcing an update overrides this limit allowing +an easy way to see all matches. + +＠node Regex Types, Questions, Usage, Top +＠chapter Regex Types + +Currently ＠pkgname{} understands five different forms of input, namely +＠code{read}, ＠code{string}, ＠code{rx}, ＠code{sregex} and ＠code{lisp-re} +syntax. Read syntax and string syntax are both delimited by ＠code{"}s +and behave according to their name. With the ＠code{string} syntax +there's no need to escape the backslashes and double quotes simplifying +the editing somewhat. The other three allow editing of symbolic regular +expressions supported by the packages of the same name. (＠code{lisp-re} +is a package by me and its support may go away as it is nearly the same +as the ＠code{sregex} package in Emacs) + +Note that the ＠code{sregex,} ＠code{rx} and ＠code{lisp-re} syntaxes will +only be available in XEmacs if you've installed them yourself. + +Editing symbolic expressions is done through a major mode derived +from ＠code{emacs-lisp-mode} so you'll get all the good stuff like +automatic indentation and font-locking etc. + +When editing a symbolic regular expression, only the first expression in +the RE Builder buffer is considered, which helps limiting the extent of +the expression like the ＠code{"}s do for the text modes. For the +＠code{sregex} syntax the function ＠code{sregex} is applied to the +evaluated expression read. So you can use quoted arguments with +something like '("findme") or you can construct arguments to your hearts +delight with a valid ELisp expression. (The compiled string form will +be copied by ＠code{reb-copy}) If you want to take a glance at the +corresponding string you can temporarily change the input syntax. + +Changing the input syntax is transparent (for the obvious exception +non-symbolic -> symbolic) so you can change your mind as often as you +like. + +There is also a shortcut function for toggling the +＠code{case-fold-search} variable in the target buffer with an immediate +update. + +＠node Questions, , Regex Types, Top +＠chapter Questions + +Q: But what if my display cannot show colored overlays? + +A: Then the cursor will flash around the matched text making it stand out. + +Q: But how can I then make out the sub-expressions? + +A: Thats where the `sub-expression mode' comes in. In it only the digit +keys are assigned to perform an update that will flash the corresponding +subexp only. -- “I, for instance, am gung-ho about open source because my family is being held hostage in Rob Malda’s basement. But who fact-checks me, or Enderle, when we say something in public? No-one!” -- Danny O’Brien