| Current File : //proc/self/root/kunden/usr/share/emacs/27.2/lisp/emacs-lisp/re-builder.elc |
;ELC
;;; Compiled
;;; in Emacs version 27.2
;;; 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\302\303\304\305\306\307&\210\310\311\312\313\314DD\315\304\301\316\317&\210\310\320\312\313\321DD\322\304\301\316\323&\210\310\324\312\313\325DD\326\304\301\316\327&\210\310\330\312\313\331DD\332\304\301\316\333&\210\334\335\336\337\304\301%\210\334\340\341\342\304\301%\210\334\343\344\345\304\301%\210\334\346\347\350\304\301%\207" [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] "Seconds to blink cursor for next/previous match in RE Builder." :type number reb-mode-hook #[0 "\300\207" [nil] 1] "Hooks to run on entering RE Builder mode." hook reb-re-syntax #[0 "\300\207" [read] 1] "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] "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 (#$ . 2478))
#@39 Buffer to which the RE is applied to.
(defvar reb-target-buffer nil (#$ . 2553))
#@39 Window to which the RE is applied to.
(defvar reb-target-window nil (#$ . 2640))
#@33 Last regexp used by RE Builder.
(defvar reb-regexp nil (#$ . 2727))
#@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 (#$ . 2802))
#@37 List of overlays of the RE Builder.
(defvar reb-overlays nil (#$ . 2958))
#@27 Old window configuration.
(defvar reb-window-config nil (#$ . 3038))
#@43 Indicates whether sub-exp mode is active.
(defvar reb-subexp-mode nil (#$ . 3113))
#@36 Indicates which sub-exp is active.
(defvar reb-subexp-displayed nil (#$ . 3202))
#@42 String in mode line for additional info.
(defvar reb-mode-string "" (#$ . 3289))
#@45 String in mode line showing validity of RE.
(defvar reb-valid-string "" (#$ . 3376))
(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*" (#$ . 3591))
#@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\301\350\351#\210\301\352\353#\210\301\354\355#\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") [div1] (menu-item "--") [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") [div2] (menu-item "--") [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") [div3] (menu-item "--") [rc] (menu-item "Copy current RE" reb-copy :help "Copy current RE into the kill ring for later insertion")] 7) (#$ . 3680))
(defvar reb-mode-hook nil)
(byte-code "\300\301N\204\f \302\300\301\303#\210\304\305!\204 \302\305\306\307#\210\300\207" [reb-mode-hook variable-documentation put "Hook run after 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] 4)
(defvar reb-mode-map (make-sparse-keymap))
(byte-code "\301\302N\204 \303\301\302\304\305!#\210\306\307!\204 \303\307\310\311#\210\312\313 !\210\307\302N\204- \303\307\302\304\314!#\210\306\300!\204B \303\300\310\311#\210\315\316\300\317\"\210!\210\300\302N\204P \303\300\302\304\320!#\210\303\311\321\317#\207" [reb-mode-abbrev-table reb-mode-map variable-documentation put purecopy "Keymap for `reb-mode'." boundp reb-mode-syntax-table definition-name reb-mode (lambda (#1=#:def-tmp-var) (defvar reb-mode-syntax-table #1#)) make-syntax-table "Syntax table for `reb-mode'." (lambda (#1#) (defvar reb-mode-abbrev-table #1#)) define-abbrev-table nil "Abbrev table for `reb-mode'." derived-mode-parent] 5)
#@175 Major mode for interactively building Regular Expressions.
This mode runs the hook `reb-mode-hook', as the final or penultimate step
during initialization.
\{reb-mode-map}
(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 (#$ . 6688) 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))
(defvar reb-lisp-mode-hook nil)
(byte-code "\300\301N\204\f \302\300\301\303#\210\304\305!\204 \302\305\306\307#\210\300\207" [reb-lisp-mode-hook variable-documentation put "Hook run after 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] 4)
(defvar reb-lisp-mode-map (make-sparse-keymap))
(byte-code "\301\302N\204 \303\301\302\304\305!#\210\306\307!\204 \303\307\310\311#\210\312\313 !\210\307\302N\204- \303\307\302\304\314!#\210\306\300!\204B \303\300\310\311#\210\315\316\300\317\"\210!\210\300\302N\204P \303\300\302\304\320!#\210\303\311\321\322#\207" [reb-lisp-mode-abbrev-table reb-lisp-mode-map variable-documentation put purecopy "Keymap for `reb-lisp-mode'." boundp reb-lisp-mode-syntax-table definition-name reb-lisp-mode (lambda (#1=#:def-tmp-var) (defvar reb-lisp-mode-syntax-table #1#)) make-syntax-table "Syntax table for `reb-lisp-mode'." (lambda (#1#) (defvar reb-lisp-mode-abbrev-table #1#)) define-abbrev-table nil "Abbrev table for `reb-lisp-mode'." derived-mode-parent emacs-lisp-mode] 5)
#@269 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 or penultimate step
during initialization.
\{reb-lisp-mode-map}
(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
\325 C#\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 (#$ . 8628) 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) (#$ . 9733))
#@69 Setup functions common to functions `reb-mode' and `reb-lisp-mode'.
(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 (#$ . 10119)])
#@54 Return t if display is capable of displaying colors.
(defalias 'reb-color-display-p #[0 "\300\301\302\"\303=\207" [frame-parameter nil display-type color] 3 (#$ . 10561)])
#@50 Return non-nil if RE Builder uses a Lisp syntax.
(defalias 'reb-lisp-syntax-p #[0 "\301>\207" [reb-re-syntax (sregex rx)] 2 (#$ . 10739)])
(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 (#$ . 10954)]))
#@55 Initialize the current buffer as a RE Builder buffer.
(defalias 'reb-initialize-buffer #[0 "\301 \210\302 \210\303e\\b\210\304>\203 \305 \210\202 \306 \210\307 \210\310 \207" [reb-re-syntax erase-buffer reb-insert-regexp 2 (sregex rx) reb-lisp-mode reb-mode reb-restart-font-lock reb-do-update] 2 (#$ . 11153)])
#@62 Return non-nil if the current buffer is a RE Builder buffer.
(defalias 'reb-mode-buffer-p #[0 "\301>\207" [major-mode (reb-mode reb-lisp-mode)] 2 (#$ . 11474)])
(defalias 'regexp-builder 're-builder)
#@331 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.
(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\323!\210\324 \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 font-lock-mode 1 reb-initialize-buffer] 5 (#$ . 11682) 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 (#$ . 12550) "bSet target buffer to: "])
#@72 Force an update in the RE Builder target window without a match limit.
(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 (#$ . 12935) nil])
#@27 Quit the RE Builder mode.
(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 (#$ . 13176) nil])
#@51 Go to next match in the RE Builder target window.
(defalias 'reb-next-match #[0 "\304 \210\305!r\306\307\310\311\312!\313\"\314$\216\315@\316\"\210\317 d\320#\204' \321\322!\2023 \323\n\2030 \2061 \307\320\"*\207" [reb-target-window reb-regexp reb-subexp-mode reb-subexp-displayed reb-assert-buffer-in-window internal--before-with-selected-window make-byte-code 0 "\301\300!\207" vconcat vector [internal--after-with-selected-window] 2 select-window norecord re-search-forward t message "No more matches" reb-show-subexp] 7 (#$ . 13413) nil])
#@55 Go to previous match in the RE Builder target window.
(defalias 'reb-prev-match #[0 "\304 \210\305!r\306\307\310\311\312!\313\"\314$\216\315@\316\"\210`\211Sb\210\317 e\320#\2035 \321\n\203/ \2060 \307\320\"\202; \211b\210\322\323!\262*\207" [reb-target-window reb-regexp reb-subexp-mode reb-subexp-displayed reb-assert-buffer-in-window internal--before-with-selected-window make-byte-code 0 "\301\300!\207" vconcat vector [internal--after-with-selected-window] 2 select-window norecord re-search-backward t reb-show-subexp message "No more matches"] 7 (#$ . 13966) nil])
#@67 Toggle case sensitivity of searches for RE Builder target buffer.
(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 (#$ . 14549) nil])
#@57 Copy current RE into the kill ring for later insertion.
(defalias 'reb-copy #[0 "\303 \210\304\305!\306\216\307r q\210\n)!\210)rq\210\310 +\311\312GS#\262\313\314\315\316\317%\262\320!\210\321\322\"\207" [standard-output reb-target-buffer reb-regexp reb-update-regexp generate-new-buffer " *string-output*" #[0 "\301!\207" [standard-output kill-buffer] 2] print buffer-string substring 1 replace-regexp-in-string "\n" "\\n" nil t kill-new message "Copied regexp `%s' to kill-ring"] 7 (#$ . 14802) nil])
#@49 Enter the subexpression mode in the RE Builder.
(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 (#$ . 15323) 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$\216\312@\313\"\210\314 \204# \224b\210\315 !\210\225b\210\314 \2030 \2053 \315 !*\207" [reb-target-window reb-blink-delay internal--before-with-selected-window make-byte-code 0 "\301\300!\207" vconcat vector [internal--after-with-selected-window] 2 select-window norecord reb-color-display-p sit-for] 9 (#$ . 15621)])
#@48 Quit the subexpression mode in the RE Builder.
(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 (#$ . 16363) nil])
(defvar reb-change-syntax-hist 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\205 r\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 (#$ . 16658) (byte-code "\301\302\303\304\"\305\306\307\306\211\310!\311&!C\207" [reb-re-syntax intern completing-read format "Select syntax (default %s): " (read string sregex rx) nil t symbol-name reb-change-syntax-hist] 10)])
#@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 (#$ . 17253)])
#@256 Called from `after-change-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 "\3021 \303 \204 \203 \304 \210\3050\202 \210\306\211\307 \210 \310>\2052 \230?\2052 \305\230\2052 \311 \207" [reb-valid-string reb-re-syntax (error) reb-update-regexp reb-do-update "" " *invalid*" force-mode-line-update (sregex rx) reb-delete-overlays] 8 (#$ . 17544)])
#@67 Delete all RE Builder overlays in the `reb-target-buffer' buffer.
(defalias 'reb-delete-overlays #[0 "\302!\205 rq\210\303\304 \"\210\305\211)\207" [reb-target-buffer reb-overlays buffer-live-p mapc delete-overlay nil] 3 (#$ . 18120)])
#@70 Assert that `reb-target-buffer' is displayed in `reb-target-window'.
(defalias 'reb-assert-buffer-in-window #[0 "\302 !=?\205
\303 \"\207" [reb-target-buffer reb-target-window window-buffer set-window-buffer] 3 (#$ . 18366)])
#@67 Update the variable `reb-mode-string' displayed in the mode line.
(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 (#$ . 18601)])
#@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 (#$ . 18959) nil])
#@73 When the RE Builder buffer is killed make sure no overlays stay around.
(defalias 'reb-kill-buffer #[0 "\300 \205 \301 \207" [reb-mode-buffer-p reb-delete-overlays] 1 (#$ . 19257)])
#@18 Read current RE.
(defalias 'reb-read-regexp #[0 "\212\301\267\202( eb\210\302p!\2020 eb\210\303\304!\210`db\210\305\304!\210\306`\"\262\2020 \307>\2050 \310 )\207" [reb-re-syntax #s(hash-table size 2 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (read 7 string 16)) read re-search-forward "\"" re-search-backward buffer-substring-no-properties (sregex rx) buffer-string] 4 (#$ . 19446)])
#@37 Return empty RE for current syntax.
(defalias 'reb-empty-regexp #[0 "\301>\203 \302\207\303\207" [reb-re-syntax (sregex rx) "'()" ""] 2 (#$ . 19862)])
#@20 Insert current RE.
(defalias 'reb-insert-regexp #[0 "rq\210 )\206 \304 \n\305\267\202 \306p\"\2022 \307\310\261\2022 \n\311>\2052 rq\210 )\2061 \304 c\207" [reb-target-buffer reb-regexp reb-re-syntax reb-regexp-src reb-empty-regexp #s(hash-table size 2 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (read 17 string 24)) print "\n\"" "\"" (sregex rx)] 4 (#$ . 20021)])
#@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 (#$ . 20420)])
#@87 Update the regexp for the target buffer.
Return t if the (cooked) expression changed.
(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 (#$ . 20648)])
#@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 (#$ . 20953)])
#@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 )\305!\306\211\307\211\211rq\210\n\2034 \310\n!r\311\306\312\313\314!\315\"\316$\216\317@\320\"\210\321 *\262\2025 `\262\322 \210eb\210m\204\370 \323d\324#\203\370 \203T W\203\370 \325\306!G\306U\203d m\204d \326u\210\306\307\211T\262 X\203\363 \n\203 \nU\203\354 \224\203\354 \327\224\225\"\203\247 U\203\232 \326\262\202\236 T\262\330\331\332\"!\202\275 \330\331\332\"!\206\275 S\211\262\205\275 \326\262\333\204\306 \334 \262\204\325 `V\203\325 \334 \262\fBT\262 \335\336#\210\335\337#\266T\262\202l \266\202= )\203\202\340\341\306U\203\342\202\343! \203\344\202 \345\326U\203&\345\202'\346 \2036 U\2036\347\2027\345%\266\205N\350\206D!\210\351\206M\306!\207" [reb-target-buffer reb-regexp reb-target-window reb-auto-match-limit reb-overlays reb-count-subexps 0 nil internal--before-with-selected-window make-byte-code "\301\300!\207" vconcat vector [internal--after-with-selected-window] 2 select-window norecord window-point 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] 17 (#$ . 21156)])
#@32 Unload the RE Builder library.
(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 (#$ . 22676)])
#@14
(fn BOUND)
(defalias 'reb-fontify-string-re #[257 "\30129 \302>\2058 \303\304=\203 \305\202 \306\307#\2058 \310\224\204\n \311`S\312\"\211<\203/ \313>\210\314\301\307\"\266\202\n 0\207" [reb-re-syntax found (read string) re-search-forward read "\\(\\\\\\\\\\)\\(?:\\(\\\\\\\\\\)\\|\\((\\(?:\\?[0-9]*:\\)?\\|[|)]\\)\\)" "\\(\\\\\\)\\(?:\\(\\\\\\)\\|\\((\\(?:\\?[0-9]*:\\)?\\|[|)]\\)\\)" t 2 get-text-property face font-lock-string-face throw] 5 (#$ . 23036)])
(byte-code "\300\301\302\303\304\305%\210\300\306\307\310\304\305%\207" [custom-declare-face reb-regexp-grouping-backslash ((t :inherit font-lock-keyword-face :weight bold :underline t)) "Font Lock mode face for backslashes in Lisp regexp grouping constructs." :group re-builder reb-regexp-grouping-construct ((t :inherit font-lock-keyword-face :weight bold :underline t)) "Font Lock mode face used to highlight grouping constructs in Lisp regexps."] 6)
(defconst reb-string-font-lock-keywords '(((reb-fontify-string-re (1 'reb-regexp-grouping-backslash prepend) (3 'reb-regexp-grouping-construct prepend)) (reb-mark-non-matching-parenthesis)) nil))
#@28
(fn LIMIT CURRENT WHERE)
(defalias 'reb-while #[771 "W\203 T\207\300\301#\210\302\207" [message "Reached (while limit=%s, where=%s)" nil] 7 (#$ . 24160)])
(put 'reb-while 'byte-optimizer 'byte-compile-inline-expand)
#@14
(fn BOUND)
(defalias 'reb-mark-non-matching-parenthesis #[257 "\211dY\205\242 \300\301\211eb\210\302\303W\203 T\266\203\202% \304\305#\210\301\266\203\211\262\203\210 m\204\210 \306\301w\210m\204\f \307`\310\"\262\211\311=\204N \211<\203\202 \311>\203\202 \301f\312=\203] `B\262\202\202 \301f\313=\203z \203o A\262\202\202 \314``T\310\315$\210\202\202 \304\316\317\301f!\"\210\301u\210\202\f \211\205\236 \211@\314\211T\310\315$\210A\266\202\202\211 \262\266\203\207" [0 nil 100 "mark-par" message "Reached (while limit=%s, where=%s)" "^()" get-text-property face reb-regexp-grouping-construct 40 41 put-text-property font-lock-warning-face "markpar: char-after=%s" char-to-string] 11 (#$ . 24390)])
(require 'rx)
(defconst reb-rx-font-lock-keywords (byte-code "\303\304\"\303\305 \"\303\306\n\"\307\310\311C\312\"\313Q\314B\307\310\315C\312\"\313Q\316B\317\310\312\"\320Q\321B\322\310\312\"\320Q\323B\307\310\312\"P\324B\257\207" [rx--builtin-forms rx--syntax-codes rx--categories mapcar symbol-name #[257 "\300@!\207" [symbol-name] 3 "\n\n(fn REC)"] #[257 "\300@!\207" [symbol-name] 3 "\n\n(fn REC)"] "(" regexp-opt "rx-to-string" t "[[:space:]]" ((1 font-lock-function-name-face)) "rx" ((1 font-lock-preprocessor-face)) "(category[[:space:]]+" ")" ((1 font-lock-variable-name-face)) "(syntax[[:space:]]+" ((1 font-lock-type-face)) ((1 font-lock-keyword-face))] 11))
#@56 Restart `font-lock-mode' to fit current regexp format.
(defalias 'reb-restart-font-lock #[0 "\305\306\"\210r\307 !q\210\n\302\310!\210\311\312!\210\313\267\202\" \202# \314\202# \315\211\205+ \302\316!\262)\207" [reb-re-syntax reb-buffer font-lock-mode reb-string-font-lock-keywords font-lock-defaults message "reb-restart-font-lock re-re-syntax=%s" get-buffer -1 kill-local-variable font-lock-set-defaults #s(hash-table size 3 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (read 26 string 26 rx 30)) (reb-rx-font-lock-keywords nil) nil 1] 3 (#$ . 25795)])
(provide 're-builder)