;ELC
;;; Compiled by mockbuild@buildfarm06-new.corp.cloudlinux.com on Fri Oct 11 10:09:04 2024
;;; from file /builddir/build/BUILD/emacs-24.3/lisp/emacs-lisp/re-builder.el
;;; in Emacs version 24.3.1
;;; with all optimizations.

;;; This file uses dynamic docstrings, first added in Emacs 19.29.

;;; This file does not contain utf-8 non-ASCII characters,
;;; and so can be loaded in Emacs versions earlier than 23.

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;


(byte-code "\300\301!\204\n\302\303!\210\304\305\306\307\310\311\312\313&\210\314\315\316\317\320DD\321\310\305\322\323&\210\314\324\316\317\325DD\326\310\305\322\327&\210\314\330\316\317\331DD\332\310\305\322\333&\210\314\334\316\317\335DD\336\310\305\322\337&\210\340\341\342\343\310\305%\210\340\344\345\346\310\305%\210\340\347\350\351\310\305%\210\340\352\353\354\310\305%\207" [fboundp make-overlay require overlay custom-declare-group re-builder nil "Options for the RE Builder." :group lisp :prefix "reb-" custom-declare-variable reb-blink-delay funcall function #[0 "\300\207" [0.5] 1 "\n\n(fn)"] "Seconds to blink cursor for next/previous match in RE Builder." :type number reb-mode-hook #[0 "\300\207" [nil] 1 "\n\n(fn)"] "Hooks to run on entering RE Builder mode." hook reb-re-syntax #[0 "\300\207" [read] 1 "\n\n(fn)"] "Syntax for the REs in the RE Builder.\nCan either be `read', `string', or `rx'." (choice (const :tag "Read syntax" read) (const :tag "String syntax" string) (const :tag "`rx' syntax" rx)) reb-auto-match-limit #[0 "\300\207" [200] 1 "\n\n(fn)"] "Positive integer limiting the matches for RE Builder auto updates.\nSet it to nil if you don't want limits here." (restricted-sexp :match-alternatives (integerp 'nil)) custom-declare-face 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." 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." 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." reb-match-3 ((((min-colors 88) (class color) (background light)) :background "yellow1") (((class color) (background light)) :background "yellow") (((class color) (background dark)) :background "sienna4") (t :inverse-video t)) "Used for displaying the third matching subexpression."] 8)
#@36 Enables the RE Builder minor mode.
(defvar reb-mode nil (#$ . 2744))
#@39 Buffer to which the RE is applied to.
(defvar reb-target-buffer nil (#$ . 2819))
#@39 Window to which the RE is applied to.
(defvar reb-target-window nil (#$ . 2906))
#@33 Last regexp used by RE Builder.
(defvar reb-regexp nil (#$ . 2993))
#@111 Last regexp used by RE Builder before processing it.
Except for Lisp syntax this is the same as `reb-regexp'.
(defvar reb-regexp-src nil (#$ . 3068))
#@37 List of overlays of the RE Builder.
(defvar reb-overlays nil (#$ . 3224))
#@27 Old window configuration.
(defvar reb-window-config nil (#$ . 3304))
#@43 Indicates whether sub-exp mode is active.
(defvar reb-subexp-mode nil (#$ . 3379))
#@36 Indicates which sub-exp is active.
(defvar reb-subexp-displayed nil (#$ . 3468))
#@42 String in mode line for additional info.
(defvar reb-mode-string "" (#$ . 3555))
#@45 String in mode line showing validity of RE.
(defvar reb-valid-string "" (#$ . 3642))
(byte-code "\300\301!\210\300\302!\210\300\303!\207" [make-variable-buffer-local reb-overlays reb-regexp reb-regexp-src] 2)
#@35 Buffer to use for the RE Builder.
(defconst reb-buffer "*RE-Builder*" (#$ . 3857))
#@32 Keymap used by the RE Builder.
(defvar reb-mode-map (byte-code "\300 \300 \301\302\303#\210\301\304\305#\210\301\306\307#\210\301\310\311#\210\301\312\313#\210\301\314\315#\210\301\316\317#\210\301\320\321#\210\301\322\323#\210\301\324\325B#\210\301
\326\327#\210\301
\330\331#\210\301
\332\333#\210\301
\334\335#\210\301
\336\337#\210\301
\340\341#\210\301
\342\343#\210\301
\344\345#\210\301
\346\347#\210
\207" [make-sparse-keymap define-key "" reb-toggle-case "" reb-quit "" reb-copy "" reb-next-match "" reb-prev-match "	" reb-change-syntax "" reb-enter-subexp-mode "" reb-change-target-buffer "" reb-force-update [menu-bar reb-mode] "Re-Builder" [rq] (menu-item "Quit" reb-quit :help "Quit the RE Builder mode") [rt] (menu-item "Case sensitive" reb-toggle-case :button (:toggle with-current-buffer reb-target-buffer (null case-fold-search)) :help "Toggle case sensitivity of searches for RE Builder target buffer") [rb] (menu-item "Change target buffer..." reb-change-target-buffer :help "Change the target buffer and display it in the target window") [rs] (menu-item "Change syntax..." reb-change-syntax :help "Change the syntax used by the RE Builder") [re] (menu-item "Enter subexpression mode" reb-enter-subexp-mode :help "Enter the subexpression mode in the RE Builder") [ru] (menu-item "Force update" reb-force-update :help "Force an update in the RE Builder target window without a match limit") [rn] (menu-item "Go to next match" reb-next-match :help "Go to next match in the RE Builder target window") [rp] (menu-item "Go to previous match" reb-prev-match :help "Go to previous match in the RE Builder target window") [rc] (menu-item "Copy current RE" reb-copy :help "Copy current RE into the kill ring for later insertion")] 7) (#$ . 3946))
(byte-code "\300\301N\204\302\300\301\303\304!#\210\305\306!\204\302\306\307\310#\210\300\207" [reb-mode-hook variable-documentation put purecopy "Hook run when entering RE Builder mode.\nNo problems result if this variable is not bound.\n`add-hook' automatically binds it.  (This is true for all hook variables.)" boundp reb-mode-map definition-name reb-mode] 5)
(defvar reb-mode-map (make-sparse-keymap))
(byte-code "\300\301N\204\302\300\301\303\304!#\210\305\306!\204\302\306\307\310#\210\300\207" [reb-mode-map variable-documentation put purecopy "Keymap for `reb-mode'." boundp reb-mode-syntax-table definition-name reb-mode] 5)
(defvar reb-mode-syntax-table (make-syntax-table))
(byte-code "\300\301N\204\302\300\301\303\304!#\210\302\305\306\307#\207" [reb-mode-syntax-table variable-documentation put purecopy "Syntax table for `reb-mode'." reb-mode-abbrev-table definition-name reb-mode] 5)
(defvar reb-mode-abbrev-table (progn (define-abbrev-table 'reb-mode-abbrev-table nil) reb-mode-abbrev-table))
(byte-code "\300\301N\204\302\300\301\303\304!#\210\302\305\306\307#\207" [reb-mode-abbrev-table variable-documentation put purecopy "Abbrev table for `reb-mode'." reb-mode derived-mode-parent nil] 5)
#@166 Major mode for interactively building Regular Expressions.

This mode runs the hook `reb-mode-hook', as the final step
during initialization.

\{reb-mode-map}

(fn)
(defalias 'reb-mode #[0 "\306\300!\210\307\310 \210\311\312\313!\210\314\f!\210
\306\315!\210\316
\317 \210)\320\321!\207" [delay-mode-hooks major-mode mode-name reb-mode-map reb-mode-syntax-table reb-mode-abbrev-table make-local-variable t kill-all-local-variables reb-mode "RE Builder" use-local-map set-syntax-table blink-matching-paren nil reb-mode-common run-mode-hooks reb-mode-hook local-abbrev-table] 2 (#$ . 6962) nil])
(defvar reb-lisp-mode-map (byte-code "\301 \302
\303\304\303\"#\210\211\207" [reb-mode-map make-sparse-keymap define-key "" lookup-key] 7))
(byte-code "\300\301N\204\302\300\301\303\304!#\210\305\306!\204\302\306\307\310#\210\300\207" [reb-lisp-mode-hook variable-documentation put purecopy "Hook run when entering RE Builder Lisp mode.\nNo problems result if this variable is not bound.\n`add-hook' automatically binds it.  (This is true for all hook variables.)" boundp reb-lisp-mode-map definition-name reb-lisp-mode] 5)
(defvar reb-lisp-mode-map (make-sparse-keymap))
(byte-code "\300\301N\204\302\300\301\303\304!#\210\305\306!\204\302\306\307\310#\210\300\207" [reb-lisp-mode-map variable-documentation put purecopy "Keymap for `reb-lisp-mode'." boundp reb-lisp-mode-syntax-table definition-name reb-lisp-mode] 5)
(defvar reb-lisp-mode-syntax-table (make-syntax-table))
(byte-code "\300\301N\204\302\300\301\303\304!#\210\302\305\306\307#\207" [reb-lisp-mode-syntax-table variable-documentation put purecopy "Syntax table for `reb-lisp-mode'." reb-lisp-mode-abbrev-table definition-name reb-lisp-mode] 5)
(defvar reb-lisp-mode-abbrev-table (progn (define-abbrev-table 'reb-lisp-mode-abbrev-table nil) reb-lisp-mode-abbrev-table))
(byte-code "\300\301N\204\302\300\301\303\304!#\210\302\305\306\307#\207" [reb-lisp-mode-abbrev-table variable-documentation put purecopy "Abbrev table for `reb-lisp-mode'." reb-lisp-mode derived-mode-parent emacs-lisp-mode] 5)
#@260 Major mode for interactively building symbolic Regular Expressions.

In addition to any hooks its parent mode `emacs-lisp-mode' might have run,
this mode runs the hook `reb-lisp-mode-hook', as the final step
during initialization.

\{reb-lisp-mode-map}

(fn)
(defalias 'reb-lisp-mode #[0 "\306\300!\210\307\310 \210\311\312\310\313N\203\314\311\313\310\313N#\210\315!\204'\316\317 \"\210\320\f!\211\2035\211\321 =\203;\322\f\323 \"\210\210\324
\325\"\204R
=\204R\326
\325C#\210\327!\210\330\f!\210
 \331>\203h\332\333!\210\334 \210)\335\336!\207" [delay-mode-hooks major-mode mode-name reb-lisp-mode-map reb-lisp-mode-syntax-table reb-lisp-mode-abbrev-table make-local-variable t emacs-lisp-mode reb-lisp-mode "RE Builder Lisp" mode-class put keymap-parent set-keymap-parent current-local-map char-table-parent standard-syntax-table set-char-table-parent syntax-table abbrev-table-get :parents abbrev-table-put use-local-map set-syntax-table (sregex rx) require rx reb-mode-common run-mode-hooks reb-lisp-mode-hook local-abbrev-table reb-re-syntax] 5 (#$ . 9048) nil])
#@59 Keymap used by the RE Builder for the subexpression mode.
(defvar reb-subexp-mode-map (byte-code "\301 \302
!\210\303
\304\305\304\"#\210\303
\306\307#\210\310\311\211W\203.\211\303\312!\313#\266\211T\262
\202\266\211\207" [reb-mode-map make-keymap suppress-keymap define-key "" lookup-key "q" reb-quit-subexp-mode 10 0 int-to-string reb-display-subexp] 8) (#$ . 10144))
#@75 Setup functions common to functions `reb-mode' and `reb-mode-lisp'.

(fn)
(defalias 'reb-mode-common #[0 "\303\211\304\305 \210\306\307\310\311\312$\210\306\313\314\311\312$\210\310\311\211\211#\207" [reb-mode-string reb-valid-string mode-line-buffer-identification "" (25 "%b" reb-mode-string reb-valid-string) reb-update-modestring add-hook after-change-functions reb-auto-update nil t kill-buffer-hook reb-kill-buffer] 6 (#$ . 10531)])
#@60 Return t if display is capable of displaying colors.

(fn)
(defalias 'reb-color-display-p #[0 "\300\301!\203\301\302 \303\"\202\300\304!\205\304\302 \303\"\305=\207" [fboundp frame-parameter selected-frame display-type frame-property color] 3 (#$ . 10979)])
#@56 Return non-nil if RE Builder uses a Lisp syntax.

(fn)
(defalias 'reb-lisp-syntax-p #[0 "\301>\207" [reb-re-syntax (sregex rx)] 2 (#$ . 11249)])
(put 'reb-lisp-syntax-p 'byte-optimizer 'byte-compile-inline-expand)
#@73 Return binding for SYMBOL in the RE Builder target buffer.

(fn SYMBOL)
(defalias 'reb-target-binding '(macro . #[257 "\300\301E\207" [with-current-buffer reb-target-buffer] 4 (#$ . 11470)]))
#@61 Initialize the current buffer as a RE Builder buffer.

(fn)
(defalias 'reb-initialize-buffer #[0 "\301 \210\302 \210\303e\\b\210\304>\203\305 \210\202\306 \210\307 \207" [reb-re-syntax erase-buffer reb-insert-regexp 2 (sregex rx) reb-lisp-mode reb-mode reb-do-update] 2 (#$ . 11669)])
#@68 Return non-nil if the current buffer is a RE Builder buffer.

(fn)
(defalias 'reb-mode-buffer-p #[0 "\301>\207" [major-mode (reb-mode reb-lisp-mode)] 2 (#$ . 11965)])
(defalias 'regexp-builder 're-builder)
#@337 Construct a regexp interactively.
This command makes the current buffer the "target" buffer of
the regexp builder.  It displays a buffer named "*RE-Builder*"
in another window, initially containing an empty regexp.

As you edit the regexp in the "*RE-Builder*" buffer, the
matching parts of the target buffer will be highlighted.

(fn)
(defalias 're-builder #[0 "\304 \230\203\305 \203\306\307!\207	\203\310 \210p\311 \312\313!\206.\314 \315\311 \316 \317Z\"!\210\320\321!!\210\322 \207" [reb-buffer reb-target-buffer reb-target-window reb-window-config buffer-name reb-mode-buffer-p message "Already in the RE Builder" reb-delete-overlays selected-window select-window get-buffer-window current-window-configuration split-window window-height 4 switch-to-buffer get-buffer-create reb-initialize-buffer] 5 (#$ . 12179) nil])
#@73 Change the target buffer and display it in the target window.

(fn BUF)
(defalias 'reb-change-target-buffer #[257 "\303
!\211\204
\304\305!\202\306 \210\211\307	\205\n!\210\310 \207" [reb-target-buffer reb-subexp-mode reb-subexp-displayed get-buffer error "No such buffer" reb-delete-overlays reb-do-update reb-update-modestring] 4 (#$ . 13023) "bSet target buffer to: "])
#@78 Force an update in the RE Builder target window without a match limit.

(fn)
(defalias 'reb-force-update #[0 "\303\304	\205\n!)\207" [reb-auto-match-limit reb-subexp-mode reb-subexp-displayed nil reb-update-overlays] 2 (#$ . 13408) nil])
#@33 Quit the RE Builder mode.

(fn)
(defalias 'reb-quit #[0 "\303\211\304 \210\305 \210\306\n!\207" [reb-subexp-mode reb-subexp-displayed reb-window-config nil reb-delete-overlays bury-buffer set-window-configuration] 3 (#$ . 13655) nil])
#@57 Go to next match in the RE Builder target window.

(fn)
(defalias 'reb-next-match #[0 "\304 \210\305!r\306\307\310\311\312\313!\314\"\315\316%DC\216\317
@\320\"\210\321	d\322#\204,\323\324!\2028\325\n\2035\2066\310\322\"*\207" [reb-target-window reb-regexp reb-subexp-mode reb-subexp-displayed reb-assert-buffer-in-window internal--before-with-selected-window funcall make-byte-code 0 "\301\300!\207" vconcat vector [internal--after-with-selected-window] 2 "\n\n(fn)" select-window norecord re-search-forward t message "No more matches" reb-show-subexp] 8 (#$ . 13898) nil])
#@61 Go to previous match in the RE Builder target window.

(fn)
(defalias 'reb-prev-match #[0 "\304 \210\305!r\306\307\310\311\312\313!\314\"\315\316%DC\216\317
@\320\"\210`\211Sb\210\321	e\322#\203:\323\n\2034\2065\310\322\"\202@\211b\210\324\325!\262
*\207" [reb-target-window reb-regexp reb-subexp-mode reb-subexp-displayed reb-assert-buffer-in-window internal--before-with-selected-window funcall make-byte-code 0 "\301\300!\207" vconcat vector [internal--after-with-selected-window] 2 "\n\n(fn)" select-window norecord re-search-backward t reb-show-subexp message "No more matches"] 8 (#$ . 14487) nil])
#@73 Toggle case sensitivity of searches for RE Builder target buffer.

(fn)
(defalias 'reb-toggle-case #[0 "rq\210	?)\302 \210\303\304\211\211\305$\207" [reb-target-buffer case-fold-search reb-update-modestring reb-auto-update nil t] 5 (#$ . 15106) nil])
#@63 Copy current RE into the kill ring for later insertion.

(fn)
(defalias 'reb-copy #[0 "\303 \210\304\305\306!!\307\310DC\216\311r	q\210\n)!\210)rq\210\312 +\313
\314GSO!\210\315\316!\207" [standard-output reb-target-buffer reb-regexp reb-update-regexp get-buffer-create generate-new-buffer-name " *string-output*" funcall #[0 "\301!\207" [standard-output kill-buffer] 2 "\n\n(fn)"] print buffer-string kill-new 1 message "Regexp copied to kill-ring"] 5 (#$ . 15365) nil])
#@55 Enter the subexpression mode in the RE Builder.

(fn)
(defalias 'reb-enter-subexp-mode #[0 "\302\303 \210\304	!\210\305\306!\207" [reb-subexp-mode reb-subexp-mode-map t reb-update-modestring use-local-map message "`0'-`9' to display subexpressions  `q' to quit subexp mode"] 2 (#$ . 15849) nil])
#@340 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.

(fn SUBEXP &optional PAUSE)
(defalias 'reb-show-subexp #[513 "\302!r\303\304\305\306\307\310!\311\"\312\313%DC\216\314
@\315\"\210\316 \204(\224b\210\317	!\210\225b\210\316 \2035
\2058\317	!*\207" [reb-target-window reb-blink-delay internal--before-with-selected-window funcall make-byte-code 0 "\301\300!\207" vconcat vector [internal--after-with-selected-window] 2 "\n\n(fn)" select-window norecord reb-color-display-p sit-for] 10 (#$ . 16153)])
#@54 Quit the subexpression mode in the RE Builder.

(fn)
(defalias 'reb-quit-subexp-mode #[0 "\303\211\304 \210\305\n!\210\306 \207" [reb-subexp-mode reb-subexp-displayed reb-mode-map nil reb-update-modestring use-local-map reb-do-update] 3 (#$ . 16926) nil])
#@138 Change the syntax used by the RE Builder.
Optional argument SYNTAX must be specified if called non-interactively.

(fn &optional SYNTAX)
(defalias 'reb-change-syntax #[256 "\211\302>\203\303!
\211\205r\211q\210\304 )\207\305\306\"\207" [reb-buffer reb-re-syntax (read string sregex rx) get-buffer reb-initialize-buffer error "Invalid syntax: %s"] 4 (#$ . 17191) (byte-code "\301\302\303\304\305\306\"\307\310\311!%!C\207" [reb-re-syntax intern completing-read "Select syntax: " mapcar #[257 "\300
!\301B\207" [symbol-name 1] 3 "\n\n(fn EL)"] (read string sregex rx) nil t symbol-name] 8)])
#@138 Update matches in the RE Builder target window.
If SUBEXP is non-nil mark only the corresponding sub-expressions.

(fn &optional SUBEXP)
(defalias 'reb-do-update #[256 "\300 \210\301 \210\302
!\207" [reb-assert-buffer-in-window reb-update-regexp reb-update-overlays] 3 (#$ . 17796)])
#@256 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.

(fn BEG END LENOLD &optional FORCE)
(defalias 'reb-auto-update #[1027 "\302\303\304\305\306\307\310!\311\"\312\313%D\314\303\315\302EDC\217\211\316 \210	\317>\2053

\230?\2053
\320\230\2053\321 \207" [reb-valid-string reb-re-syntax #1=#:err funcall make-byte-code 0 "\301 \204	\300\203\f\302 \210\303\207" vconcat vector [reb-update-regexp reb-do-update #2=""] 1 "\n\n(fn)" error #[257 "\300\207" [" *invalid*"] 2 " *invalid*\n\n(fn IGNORED)"] force-mode-line-update (sregex rx) #2# reb-delete-overlays] 13 (#$ . 18087)])
#@73 Delete all RE Builder overlays in the `reb-target-buffer' buffer.

(fn)
(defalias 'reb-delete-overlays #[0 "\302!\205rq\210\303\304	\"\210\305\211)\207" [reb-target-buffer reb-overlays buffer-live-p mapc delete-overlay nil] 3 (#$ . 18843)])
#@76 Assert that `reb-target-buffer' is displayed in `reb-target-window'.

(fn)
(defalias 'reb-assert-buffer-in-window #[0 "\302	!=?\205
\303	\"\207" [reb-target-buffer reb-target-window window-buffer set-window-buffer] 3 (#$ . 19095)])
#@73 Update the variable `reb-mode-string' displayed in the mode line.

(fn)
(defalias 'reb-update-modestring #[0 "\203\305\306	\206\307\"\202\310r\nq\210)\204\311\202\310P\312 \207" [reb-subexp-mode reb-subexp-displayed reb-target-buffer case-fold-search reb-mode-string format " (subexp %s)" "-" "" " Case" force-mode-line-update] 3 (#$ . 19336)])
#@79 Highlight only subexpression SUBEXP in the RE Builder.

(fn &optional SUBEXP)
(defalias 'reb-display-subexp #[256 "\211\206\n\302\303\304\"!\305 \210\306	!\207" [last-command-event reb-subexp-displayed string-to-number format "%c" reb-update-modestring reb-do-update] 5 (#$ . 19700) nil])
#@79 When the RE Builder buffer is killed make sure no overlays stay around.

(fn)
(defalias 'reb-kill-buffer #[0 "\300 \205\301 \207" [reb-mode-buffer-p reb-delete-overlays] 1 (#$ . 19998)])
#@24 Read current RE.

(fn)
(defalias 'reb-read-regexp #[0 "\212\301=\203eb\210\301p!\2026\302=\203.eb\210\303\304!\210`db\210\305\304!\210\306
`\"\262
\2026\307>\2056\310 )\207" [reb-re-syntax read string re-search-forward "\"" re-search-backward buffer-substring-no-properties (sregex rx) buffer-string] 4 (#$ . 20193)])
#@43 Return empty RE for current syntax.

(fn)
(defalias 'reb-empty-regexp #[0 "\301>\203\302\207\303\207" [reb-re-syntax (sregex rx) "'()" ""] 2 (#$ . 20526)])
#@26 Insert current RE.

(fn)
(defalias 'reb-insert-regexp #[0 "rq\210	)\206\304 \n\305=\203\306
p\"\2028\n\307=\203&\310
\311\261\2028\n\312>\2058rq\210)\2067\304 c\207" [reb-target-buffer reb-regexp reb-re-syntax reb-regexp-src reb-empty-regexp read print string "\n\"" "\"" (sregex rx)] 4 (#$ . 20691)])
#@70 Return RE after processing it according to `reb-re-syntax'.

(fn RE)
(defalias 'reb-cook-regexp #[257 "\301>\203\302\303\304!@!!\207\207" [reb-re-syntax (sregex rx) rx-to-string eval read-from-string] 5 (#$ . 21012)])
#@93 Update the regexp for the target buffer.
Return t if the (cooked) expression changed.

(fn)
(defalias 'reb-update-regexp #[0 "\304 \305
!rq\210	\211\230?\n\306>\203\262
)\207" [reb-target-buffer reb-regexp reb-re-syntax reb-regexp-src reb-read-regexp reb-cook-regexp (sregex rx)] 6 (#$ . 21240)])
#@61 Return number of sub-expressions in the regexp RE.

(fn RE)
(defalias 'reb-count-subexps #[257 "\300\211\301\302#\203
T\262\300\225\262
\202
\207" [0 string-match "\\\\("] 7 (#$ . 21551)])
#@158 Switch to `reb-target-buffer' and mark all matches of `reb-regexp'.
If SUBEXP is non-nil mark only the corresponding sub-expressions.

(fn &optional SUBEXP)
(defalias 'reb-update-overlays #[256 "rq\210	)\304
!\305\211\306rq\210\307 \210eb\210m\204\277\310d\311#\203\277\n\203,\nW\203\277\312\305!G\305U\203<m\204<\313u\210\305\306\211T\262X\203\272\203VU\203\263\224\203\263\314\224\225\"
\203~U\203q\313\262\202uT\262\315\316\317\"!\202\224\315\316\317\"!\206\224S\211\262\205\224\313\262\320\204\234\321 \262
BT\262\322\323#\210\322\324#\266T\262\202C\266\202)\203\310
\202\311\325\326\305U\203\325\327\202\330\330!	\203\341\331\202\342\332\313U\203\354\332\202\355\333\n\203\374\nU\203\374\334\202\375\332%\266\211\205
\335
!\210\336\206
\305!\207" [reb-target-buffer reb-regexp reb-auto-match-limit reb-overlays reb-count-subexps 0 nil reb-delete-overlays re-search-forward t match-string 1 make-overlay intern-soft format "reb-match-%d" reb-match-1 match-data overlay-put face priority message "%s %smatch%s%s" "No" int-to-string "subexpression " "" "es" " (limit reached)" store-match-data reb-show-subexp] 15 (#$ . 21754)])
#@38 Unload the RE Builder library.

(fn)
(defalias 're-builder-unload-function #[0 "\301\302!!\203!rq\210\303\304\305\306#\210\303\307\310\306#\210\311 \203 \312 \210)\313\207" [reb-buffer buffer-live-p get-buffer remove-hook after-change-functions reb-auto-update t kill-buffer-hook reb-kill-buffer reb-mode-buffer-p reb-delete-overlays nil] 4 (#$ . 22979)])
(provide 're-builder)