;ELC ;;; Compiled by pot@pot.cnuce.cnr.it on Tue Mar 18 15:51:54 2003 ;;; from file /home/pot/gnu/emacs-pretest.new/lisp/replace.el ;;; in Emacs version 21.3 ;;; with bytecomp version 2.85.4.1 ;;; with all optimizations. ;;; This file uses dynamic docstrings, first added in Emacs 19.29. (if (and (boundp 'emacs-version) (< (aref emacs-version (1- (length emacs-version))) ?A) (or (and (boundp 'epoch::version) epoch::version) (string-lessp emacs-version "19.29"))) (error "`replace.el' was compiled for Emacs 19.29 or later")) ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; #@70 *Non-nil means `query-replace' should preserve case in replacements. (custom-declare-variable 'case-replace 't '(#$ . -616) :type 'boolean :group 'matching) (byte-code "\301B\302\301!\204\f\303\303\207" [current-load-list query-replace-history boundp nil] 2) #@98 Non-nil means `query-replace' uses the last search string. That becomes the "string to replace". (defvar query-replace-interactive nil (#$ . 885)) #@220 History list to use for the FROM argument of `query-replace' commands. The value of this variable should be a symbol; that symbol is used as a variable to hold a history list for the strings or patterns to be replaced. (custom-declare-variable 'query-replace-from-history-variable ''query-replace-history '(#$ . 1039) :group 'matching :type 'symbol :version "20.3") #@211 History list to use for the TO argument of `query-replace' commands. The value of this variable should be a symbol; that symbol is used as a variable to hold a history list for replacement strings or patterns. (custom-declare-variable 'query-replace-to-history-variable ''query-replace-history '(#$ . 1412) :group 'matching :type 'symbol :version "20.3") (defalias 'query-replace-read-args #[(string regexp-flag) "\306\211\n\203 \203\f\202 @\202&\307\310\311\"\306\211\211\306\312&\307\310\313 #\306\211\211 \312&\203N\203N \314 \315 \257\202V \306\211\257*\207" [to from query-replace-interactive regexp-flag regexp-search-ring search-ring nil read-from-minibuffer format "%s: " t "%s %s with: " region-beginning region-end string query-replace-from-history-variable query-replace-to-history-variable transient-mark-mode mark-active current-prefix-arg] 8]) #@1045 Replace some occurrences of FROM-STRING with TO-STRING. As each match is found, the user must type a character saying what to do with it. For directions, type \[help-command] at that time. In Transient Mark mode, if the mark is active, operate on the contents of the region. Otherwise, operate from point to the end of the buffer. If `query-replace-interactive' is non-nil, the last incremental search string is used as FROM-STRING--you don't have to specify it with the minibuffer. Replacement transfers the case of the old text to the new text, if `case-replace' and `case-fold-search' are non-nil and FROM-STRING has no uppercase letters. (Preserving case means that if the string matched is all caps, or capitalized, then its replacement is upcased or capitalized.) Third arg DELIMITED (prefix arg if interactive), if non-nil, means replace only matches surrounded by word boundaries. Fourth and fifth arg START and END specify the region to operate on. To customize possible responses, change the "bindings" in `query-replace-map'. (defalias 'query-replace #[(from-string to-string &optional delimited start end) "\305 \306\307\n\307\211 \f& \207" [from-string to-string delimited start end perform-replace t nil] 10 (#$ . 2315) (query-replace-read-args "Query replace" nil)]) (define-key esc-map "%" 'query-replace) #@970 Replace some things after point matching REGEXP with TO-STRING. As each match is found, the user must type a character saying what to do with it. For directions, type \[help-command] at that time. In Transient Mark mode, if the mark is active, operate on the contents of the region. Otherwise, operate from point to the end of the buffer. If `query-replace-interactive' is non-nil, the last incremental search regexp is used as REGEXP--you don't have to specify it with the minibuffer. Preserves case in each replacement if `case-replace' and `case-fold-search' are non-nil and REGEXP has no uppercase letters. Third arg DELIMITED (prefix arg if interactive), if non-nil, means replace only matches surrounded by word boundaries. Fourth and fifth arg START and END specify the region to operate on. In TO-STRING, `\&' stands for whatever matched the whole of REGEXP, and `\=\N' (where N is a digit) stands for whatever what matched the Nth `\(...\)' in REGEXP. (defalias 'query-replace-regexp #[(regexp to-string &optional delimited start end) "\305 \306\211\n\307\211 \f& \207" [regexp to-string delimited start end perform-replace t nil] 10 (#$ . 3652) (query-replace-read-args "Query replace regexp" t)]) (define-key esc-map [67108901] 'query-replace-regexp) #@1388 Replace some things after point matching REGEXP with the result of TO-EXPR. As each match is found, the user must type a character saying what to do with it. For directions, type \[help-command] at that time. TO-EXPR is a Lisp expression evaluated to compute each replacement. It may reference `replace-count' to get the number of replacements already made. If the result of TO-EXPR is not a string, it is converted to one using `prin1-to-string' with the NOESCAPE argument (which see). For convenience, when entering TO-EXPR interactively, you can use `\&' or `\0' to stand for whatever matched the whole of REGEXP, and `\N' (where N is a digit) to stand for whatever matched the Nth `\(...\)' in REGEXP. Use `\#&' or `\#N' if you want a number instead of a string. In Transient Mark mode, if the mark is active, operate on the contents of the region. Otherwise, operate from point to the end of the buffer. If `query-replace-interactive' is non-nil, the last incremental search regexp is used as REGEXP--you don't have to specify it with the minibuffer. Preserves case in each replacement if `case-replace' and `case-fold-search' are non-nil and REGEXP has no uppercase letters. Third arg DELIMITED (prefix arg if interactive), if non-nil, means replace only matches that are surrounded by word boundaries. Fourth and fifth arg START and END specify the region to operate on. (defalias 'query-replace-regexp-eval #[(regexp to-expr &optional delimited start end) "\305\306 B\307\211\n\310\211 \f& \207" [regexp to-expr delimited start end perform-replace replace-eval-replacement t nil] 10 (#$ . 4931) (let (from to start end) (when (and transient-mark-mode mark-active) (setq start (region-beginning) end (region-end))) (if query-replace-interactive (setq from (car regexp-search-ring)) (setq from (read-from-minibuffer "Query replace regexp: " nil nil nil query-replace-from-history-variable nil t))) (setq to (list (read-from-minibuffer (format "Query replace regexp %s with eval: " from) nil nil t query-replace-to-history-variable from t))) (replace-match-string-symbols to) (list from (car to) current-prefix-arg start end))]) #@986 Replace some matches for REGEXP with various strings, in rotation. The second argument TO-STRINGS contains the replacement strings, separated by spaces. Third arg DELIMITED (prefix arg if interactive), if non-nil, means replace only matches surrounded by word boundaries. This command works like `query-replace-regexp' except that each successive replacement uses the next successive replacement string, wrapping around from the last such string to the first. In Transient Mark mode, if the mark is active, operate on the contents of the region. Otherwise, operate from point to the end of the buffer. Non-interactively, TO-STRINGS may be a list of replacement strings. If `query-replace-interactive' is non-nil, the last incremental search regexp is used as REGEXP--you don't have to specify it with the minibuffer. A prefix argument N says to use each replacement string N times before rotating to the next. Fourth and fifth arg START and END specify the region to operate on. (defalias 'map-query-replace-regexp #[(regexp to-strings &optional n start end) "\306 <\203\f \202? G\307U\204?\310\311 \"\2033\312 \307\310\311 \"OC\" \310\311 \"T\306O\211\202 \312 C\"\313\211\202 \314\n\315\211\306 \306\f & )\207" [replacements to-strings regexp n start end nil 0 string-match " " append "" perform-replace t] 11 (#$ . 7082) (let (from to start end) (when (and transient-mark-mode mark-active) (setq start (region-beginning) end (region-end))) (setq from (if query-replace-interactive (car regexp-search-ring) (read-from-minibuffer "Map query replace (regexp): " nil nil nil 'query-replace-history nil t))) (setq to (read-from-minibuffer (format "Query replace %s with (space-separated strings): " from) nil nil nil 'query-replace-history from t)) (list from to start end current-prefix-arg))]) #@1153 Replace occurrences of FROM-STRING with TO-STRING. Preserve case in each match if `case-replace' and `case-fold-search' are non-nil and FROM-STRING has no uppercase letters. (Preserving case means that if the string matched is all caps, or capitalized, then its replacement is upcased or capitalized.) In Transient Mark mode, if the mark is active, operate on the contents of the region. Otherwise, operate from point to the end of the buffer. Third arg DELIMITED (prefix arg if interactive), if non-nil, means replace only matches surrounded by word boundaries. Fourth and fifth arg START and END specify the region to operate on. If `query-replace-interactive' is non-nil, the last incremental search string is used as FROM-STRING--you don't have to specify it with the minibuffer. This function is usually the wrong thing to use in a Lisp program. What you probably want is a loop like this: (while (search-forward FROM-STRING nil t) (replace-match TO-STRING nil t)) which will run faster and will not set the mark or print anything. (You may need a more complex loop if FROM-STRING can match the null string and TO-STRING is also null.) (defalias 'replace-string #[(from-string to-string &optional delimited start end) "\305 \306\211\n\306\211 \f& \207" [from-string to-string delimited start end perform-replace nil] 10 (#$ . 8905) (query-replace-read-args "Replace string" nil)]) #@1083 Replace things after point matching REGEXP with TO-STRING. Preserve case in each match if `case-replace' and `case-fold-search' are non-nil and REGEXP has no uppercase letters. In Transient Mark mode, if the mark is active, operate on the contents of the region. Otherwise, operate from point to the end of the buffer. Third arg DELIMITED (prefix arg if interactive), if non-nil, means replace only matches surrounded by word boundaries. Fourth and fifth arg START and END specify the region to operate on. In TO-STRING, `\&' stands for whatever matched the whole of REGEXP, and `\=\N' (where N is a digit) stands for whatever what matched the Nth `\(...\)' in REGEXP. If `query-replace-interactive' is non-nil, the last incremental search regexp is used as REGEXP--you don't have to specify it with the minibuffer. This function is usually the wrong thing to use in a Lisp program. What you probably want is a loop like this: (while (re-search-forward REGEXP nil t) (replace-match TO-STRING nil nil)) which will run faster and will not set the mark or print anything. (defalias 'replace-regexp #[(regexp to-string &optional delimited start end) "\305 \306\307\n\306\211 \f& \207" [regexp to-string delimited start end perform-replace nil t] 10 (#$ . 10311) (query-replace-read-args "Replace regexp" t)]) #@63 History list for some commands that read regular expressions. (defvar regexp-history nil (#$ . 11636)) (byte-code "\300\301\302\"\210\300\303\304\"\210\300\305\306\"\207" [defalias delete-non-matching-lines keep-lines delete-matching-lines flush-lines count-matches how-many] 3) #@106 Read arguments for `keep-lines' and friends. Prompt for a regexp with PROMPT. Value is a list, (REGEXP). (defalias 'keep-lines-read-args #[(prompt) "\301\302\211\211\303\302\304&C\207" [prompt read-from-minibuffer nil regexp-history t] 8 (#$ . 11922)]) #@500 Delete all lines except those containing matches for REGEXP. A match split across lines preserves all the lines it lies in. Applies to all lines after point. If REGEXP contains upper case characters (excluding those preceded by `\'), the matching is case-sensitive. Second and third arg RSTART and REND specify the region to operate on. Interactively, in Transient Mark mode when the mark is active, operate on the contents of the region. Otherwise, operate from point to the end of the buffer. (defalias 'keep-lines #[(regexp &optional rstart rend) "\203\f ^b\210\202'\n\203 \203\306 \307\310 !\202$`\311 b\210\212n\204/\312y\210`\f\2058\313 \314\"` W\205\210\315 \316#\204Q |\210\202l\212\317\224b\210\320 \210`)W\203k|\210)\212\312y\210`)` W\203;\317\224\317\225U\203;\312u\210\202;+\207" [rstart rend transient-mark-mode mark-active case-fold-search regexp region-beginning copy-marker region-end point-max-marker 1 isearch-no-upper-case-p t re-search-forward move 0 beginning-of-line start end] 4 (#$ . 12184) (keep-lines-read-args "Keep lines (containing match for regexp): ")]) #@488 Delete lines containing matches for REGEXP. If a match is split across lines, all the lines it lies in are deleted. Applies to lines after point. If REGEXP contains upper case characters (excluding those preceded by `\'), the matching is case-sensitive. Second and third arg RSTART and REND specify the region to operate on. Interactively, in Transient Mark mode when the mark is active, operate on the contents of the region. Otherwise, operate from point to the end of the buffer. (defalias 'flush-lines #[(regexp &optional rstart rend) "\203\f ^b\210\202'\n\203 \203\306 \307\310 !\202$`\311 b\210\f\205/\312 \313\"\212` W\205R\314 \313#\205R\212\315\224b\210\316 \210`)\317y\210`|\210\2021*\207" [rstart rend transient-mark-mode mark-active case-fold-search regexp region-beginning copy-marker region-end point-max-marker isearch-no-upper-case-p t re-search-forward 0 beginning-of-line 1] 4 (#$ . 13321) (keep-lines-read-args "Flush lines (containing match for regexp): ")]) #@394 Print number of matches for REGEXP following point. If REGEXP contains upper case characters (excluding those preceded by `\'), the matching is case-sensitive. Second and third arg RSTART and REND specify the region to operate on. Interactively, in Transient Mark mode when the mark is active, operate on the contents of the region. Otherwise, operate from point to the end of the buffer. (defalias 'how-many #[(regexp &optional rstart rend) "\212\203  ^b\210\202(\n\203 \203 \306 \307\310 !\202%`\311 b\210\312\313\f\2052\314 \315\"` W\203]`\316 \315#\203]`U\203U\317u\210\2027T\2027\320\321\",\207" [rstart rend transient-mark-mode mark-active case-fold-search regexp region-beginning copy-marker region-end point-max-marker 0 nil isearch-no-upper-case-p t re-search-forward 1 message "%d occurrences" opoint count] 5 (#$ . 14331) (keep-lines-read-args "How many matches for (regexp): ")]) #@26 Keymap for `occur-mode'. (defvar occur-mode-map (byte-code "\301 \302\303\304#\210\302\305\306#\210\302\307\306#\210\302\310\311#\210\302\312\313#\210\302\314\315#\210)\207" [map make-sparse-keymap define-key [mouse-2] occur-mode-mouse-goto "" occur-mode-goto-occurrence " " "\356" occur-next "\360" occur-prev "g" revert-buffer] 4) (#$ . 15268)) #@32 Name of buffer for last occur. (defvar occur-buffer nil (#$ . 15631)) #@58 Number of lines of context to show around matching line. (defvar occur-nlines nil (#$ . 15707)) #@64 Arguments that were given to `occur' when it made this buffer. (defvar occur-command-arguments nil (#$ . 15809)) (byte-code "\303\304\305\306#\210\301B\307\301!\204\310 \302B\307\302!\204\"\311\312\313\"\314B\315\314\313\"\210\303\304\316\317#\207" [current-load-list occur-mode-map occur-mode-syntax-table put occur-mode mode-class special boundp make-sparse-keymap make-char-table syntax-table nil occur-mode-abbrev-table define-abbrev-table derived-mode-parent fundamental-mode] 4) #@364 Major mode for output from \[occur]. \Move point to one of the items in this buffer, then use \[occur-mode-goto-occurrence] to go to the occurrence that the item refers to. Alternatively, click \[occur-mode-mouse-goto] on an item to go to it. \{occur-mode-map} This mode runs the hook `occur-mode-hook', as the final step during initialization. (defalias 'occur-mode #[nil "\306 \210\306\307N\203\310\311\307\312#\210\311\313\314\n!\204\315\n\316 \"\210\317 !\211\203.\f\320 =\2034\321 \322 \"\210) \203>\323\324 \"\210\325\n!\210\326 !\210\327\330!\331L\210\327\332!\210\327\333!\210\327\334!\210\335\336!\207" [major-mode mode-name occur-mode-map occur-mode-syntax-table parent local-abbrev-table fundamental-mode special put occur-mode t "Occur" keymap-parent set-keymap-parent current-local-map char-table-parent standard-syntax-table set-char-table-parent syntax-table mapatoms #[(symbol) "\302\303! \"\206\304 \303!JK$\207" [symbol occur-mode-abbrev-table intern-soft symbol-name define-abbrev] 5] use-local-map set-syntax-table make-local-variable revert-buffer-function occur-revert-function occur-buffer occur-nlines occur-command-arguments run-hooks occur-mode-hook occur-mode-abbrev-table] 5 (#$ . 16312) nil]) #@45 Handle `revert-buffer' for *Occur* buffers. (defalias 'occur-revert-function #[(ignore1 ignore2) "\212\nq\210\303\304 \"*\207" [occur-command-arguments args occur-buffer apply occur] 3 (#$ . 17577)]) #@62 In Occur mode, go to the occurrence whose line you click on. (defalias 'occur-mode-mouse-goto #[(event) "\305\211\212\306\n\307\n8:\203\307\202\310\n8)\311 8)!q\210\212\n\307\n8:\203-\307\202.\310\n8)\310 8:\203@\310 8@\202C\310 8)b\210\312 \f*\313 !\210\314!b*\207" [pos buffer event position occur-buffer nil window-buffer 2 1 0 occur-mode-find-occurrence pop-to-buffer marker-position] 3 (#$ . 17785) "e"]) (defalias 'occur-mode-find-occurrence #[nil "\203\n\302!\204\303\304\305!\210\306`\307\"\211\204\304\310!\202 )\207" [occur-buffer pos buffer-name nil error "Buffer in which occurrences were found is deleted" get-text-property occur "No occurrence on this line"] 4]) #@50 Go to the occurrence the current line describes. (defalias 'occur-mode-goto-occurrence #[nil "\302 \303 !\210\304!b)\207" [pos occur-buffer occur-mode-find-occurrence pop-to-buffer marker-position] 2 (#$ . 18496) nil]) #@63 Move to the Nth (default 1) next match in the *Occur* buffer. (defalias 'occur-next #[(&optional n) "\204\302\303\304V\2052\305`\306\"\203\302u\210\307`\306\"\211\203' b\210\202+\310\311!\210S\211\202 )\207" [n r 1 nil 0 get-text-property occur-point next-single-property-change error "No more matches"] 4 (#$ . 18723) "p"]) #@67 Move to the Nth (default 1) previous match in the *Occur* buffer. (defalias 'occur-prev #[(&optional n) "\204\302\303\304V\2055\305`\306\"\211\203\307u\210\310`\306\"\211\203* Sb\210\202.\311\312!\210S\211\202 )\207" [n r 1 nil 0 get-text-property occur-point -1 previous-single-property-change error "No earlier matches"] 4 (#$ . 19069) "p"]) #@224 *Default number of context lines included around `list-matching-lines' matches. A negative number means to include that many lines before the match. A positive number means to include that many lines both before and after. (custom-declare-variable 'list-matching-lines-default-context-lines '0 '(#$ . -19436) :type 'integer :group 'matching) (defalias 'list-matching-lines 'occur) #@139 *Face used by \[list-matching-lines] to show the text that matches. If the value is nil, don't highlight the matching portions specially. (defvar list-matching-lines-face 'bold (#$ . -19824)) #@633 Show all lines in the current buffer containing a match for REGEXP. If a match spreads across multiple lines, all those lines are shown. Each line is displayed with NLINES lines before and after, or -NLINES before if NLINES is negative. NLINES defaults to `list-matching-lines-default-context-lines'. Interactively it is the prefix arg. The lines are shown in a buffer named `*Occur*'. It serves as a menu to find any of the occurrences in this buffer. \\[describe-mode] in that buffer will explain how. If REGEXP contains upper case characters (excluding those preceded by `\'), the matching is case-sensitive. (defalias 'occur #[(regexp &optional nlines) "\203\n\306!\202 \n\307\310\310\n\\S\n\245\n_S1\311\3121\"2\3131\314\"3\3074\3155p678\3169e:;\205H\317<\307\";\320 =\212eb\210\321<\322\307#\204c\323\324<\"\202\313\315\224b\210\325\220\212>q\21087\326c\210\307?\327=\203\244db\210\212m\204\236\321<\322\307#\203\236\315\224b\210\335 \210\336 C\337\2169\340:`\"\\9*`:\315\225b\210\212\315\224b\210\315W\203\340\202\342[y\210`)D\212\315\225b\210\315V\203\372Ty\210\202\375\316y\210`)E\315\224DZF\315\225\315\224ZG\31129\"H\322I\322J\322K\320 L\320 M\212\320 \211K`\322\223\210>q\2105T54\204I\341!\204I\342c\210\3224\212\325q\210 )L`\322\223\210`J\3436DE#\210DF\\EU\204r6q\210\344E!)\333=\204\202\345c\210=`E\315\225ZZ\2126q\210\212\315\225b\210\322\210n*\203\241\316\202\242\315\\\322\223\210M`\322\223\210N\203\310\346\347L!F\\\347L!F\\G\\\350N$\210\346\347L!F\\G\\\347L!F\\G\\\316\\\351\307$\210Jb\2109W\203\3659Z\202\366\211I\315V\2033\352\261\210\316y\210IS\211I\202\3719O`=W\203<H\204(\3112O\"HH\352\261\210\316y\210\322HOTO\202m\204X`=X\203X3\352\261\210\316y\210OTO\202<)`dW\203wIW\203w3\352\261\210\316y\210ITI\202Y\353\347L!\347M!S\354#\210\346\347L!\347M!\355K$\210db\210)\316y\210.\n\202\245>q\210eb\2105\316U\203\260\356\202\265\311\3575\"\211Pc\210t\203\304\323\360P\"\210)\307\211Q)\221.\207" [nlines list-matching-lines-default-context-lines tab-width current-tab-width inhibit-read-only min-line-number-width prefix-numeric-value t 6 format "%%%dd" make-string 32 0 1 isearch-no-upper-case-p make-marker re-search-forward nil message "No matches for `%s'" "*Occur*" " matching " prin1 " in buffer " buffer-name 46 10 occur-mode beginning-of-line match-data ((set-match-data save-match-data-internal)) count-lines zerop "--------\n" insert-buffer-substring char-before "\n" put-text-property marker-position face occur-point 58 add-text-properties (mouse-face highlight help-echo "mouse-2: go to this occurrence") occur "1 line" "%d lines" "%s matched" line-number-width line-number-format empty first occur-num-matches buffer default-directory dir linenum prevpos case-fold-search regexp final-context-start standard-output print-escape-newlines occur-buffer occur-nlines occur-command-arguments save-match-data-internal start end match-beg match-len tag tem insertion-start occur-marker text-beg text-end list-matching-lines-face this-linenum message-string buffer-read-only] 7 (#$ . 20023) (list (let* ((default (car regexp-history)) (input (read-from-minibuffer (if default (format "List lines matching regexp (default `%s'): " default) "List lines matching regexp: ") nil nil nil 'regexp-history default t))) (and (equal input "") default (setq input default)) input) current-prefix-arg)]) #@40 Help message while in `query-replace'. (defconst query-replace-help "Type Space or `y' to replace one match, Delete or `n' to skip to next,\nRET or `q' to exit, Period to replace one match and exit,\nComma to replace but not move point immediately,\nC-r to enter recursive edit (\\[exit-recursive-edit] to get out again),\nC-w to delete match and recursive edit,\nC-l to clear the screen, redisplay, and offer same replacement again,\n! to replace all remaining matches with no more questions,\n^ to move point back to previous match,\nE to edit the replacement string" (#$ . 23601)) #@301 Keymap that defines the responses to questions in `query-replace'. The "bindings" in this map are not commands; they are answers. The valid answers include `act', `skip', `act-and-show', `exit', `act-and-exit', `edit', `delete-and-edit', `recenter', `automatic', `backup', `exit-prefix', and `help'. (defvar query-replace-map (make-sparse-keymap) (#$ . 24192)) (byte-code "\301\302\303#\210\301\304\305#\210\301\306\305#\210\301\307\305#\210\301\310\303#\210\301\311\305#\210\301\312\303#\210\301\313\305#\210\301\314\315#\210\301\316\315#\210\301\317\320#\210\301\321\322#\210\301\323\322#\210\301\324\322#\210\301\325\326#\210\301\327\330#\210\301\331\332#\210\301\333\334#\210\301\335\336#\210\301\337\340#\210\301\341\342#\210\301\343\342#\210\301\344\342#\210\301\345\342#\210\301\346\347#\210\301\350\347#\210\301\351\352#\210\301\353\352#\207" [query-replace-map define-key " " act "" skip [delete] [backspace] "y" "n" "Y" "N" "e" edit-replacement "E" "," act-and-show "q" exit " " [return] "." act-and-exit "" edit "" delete-and-edit "\f" recenter "!" automatic "^" backup "" help [f1] [help] "?" "" quit "" "" exit-prefix [escape]] 4) #@336 Process a list (and any sub-lists), expanding certain symbols. Symbol Expands To N (match-string N) (where N is a string of digits) #N (string-to-number (match-string N)) & (match-string 0) #& (string-to-number (match-string 0)) Note that these symbols must be preceeded by a backslash in order to type them. (defalias 'replace-match-string-symbols #[(n) "\205f@:\203\302@!\210\202^@9\203^\303@!\304\305 \"\203/\306\307 !D\240\210\202]\304\310 \"\203F\307\306\307 \311\312O!DD\240\210\202] \313\230\203S\314\240\210\202] \315\230\203]\316\240\210)A\211\204\312\207" [n name replace-match-string-symbols symbol-name string-match "^[0-9]+$" match-string string-to-number "^#[0-9]+$" 1 nil "&" (match-string 0) "#&" (string-to-number (match-string 0))] 8 (#$ . 25378)]) (defalias 'replace-eval-replacement #[(expression replace-count) "\302!\211;\203 \202\303 \304\")\207" [expression replacement eval prin1-to-string t] 4]) (defalias 'replace-loop-through-replacements #[(data replace-count) "\303H U\203'\303 \304H\\I\210\305HA\305\n:\203!\n\202$\306HI\210)\305H@\207" [data replace-count next 0 1 2 3] 5]) #@469 Subroutine of `query-replace'. Its complexity handles interactive queries. Don't use this in your own program unless you want to query and set the mark just as `query-replace' does. Instead, write a simple loop like this: (while (re-search-forward "foo[ \t]+bar" nil t) (replace-match "foobar" nil nil)) which will run faster and probably do exactly what you want. Please see the documentation of `replace-match' to find out how to simulate `case-replace'. (defalias 'perform-replace #[(from-string replacements query-flag regexp-flag delimited-flag &optional repeat-count map start end) "\204 \n\203 \203\306\307\310 !!\210\f\205\" \205\"@\211\227\230?\f\205,@\211\227\230A?A\2038\311\2029\312@\313\211\314\313\315\313\211\314\n\205J\316\317! BCDEFGHIJKLMN\203\206\320NO]!CNO^b\210P\203\206\313Q\321\322!\210R;\203\226RH\313R\202\261R@;\203\261S\204\245\323S\324\325S\211R\211$BRT\203\314\311K\326A\203\304@\202\310\327@!\326QJ\330 \210\331 \210\332\216G\203\216m\204\216B:\203\356BA@b\210B\202 B\204\373\323u\210m?\205 KJC\314#\205 \333\314I\"\211I\203\216I@IA@U?\211D\205?A?\206?\334J!\205?\333 \211U@UA@U?\205>U)BR\203V\335I!\210R@RAE\"H\n\204p\335I!\210\336HML#\210ETE\202\324\331 \210\313\211\211\211VWXYY\204{\335I!\210\337\315\224\315\225\"\210\313Z\340 @H#\210)\341 W\335I!\210\325W!W\342W\"\211V\343=\203\342\344\220\345\346A\203\306\347\202\307\350@\351H\352\316[!\260!\210r\\q\210\353 )\221\210\202V\354=\203\363\313G\314\211Y\202\201V\355=\2031F\203\"F@\211]@b\210]A\314=\211X\204\335]A!\210FAF)\202\340\356!\210\357\360!\210\361\323!\210\202V\362=\203TX\204K\336HML#\210ETE\314Y\314X\202V\363=\203zX\204n\336HML#\210ETE\313G\314Y\314X\202V\364=\203\232X\204\336HML#\210ETE\314X\202V\365=\203\277X\204\264\336HML#\210ETE\314Y\313\314X\202V\366=\203\315\314\211Y\202\201V\367=\203\333\367\313!\210\202V\370=\203 \371 ^\315\224b\210\212KJC\314#\210\333 I)\212\372 \210)^b\210)\335I!\210A\203D\203\334J!\205\333 B\202V\373=\203C\374\375H\"HX\204<\336HML#\210\314\211Y\202\201V\376=\203`\315\224\315\225|\210\335\333 \212\372 \210)!\210\314X\202\377_\313G\201a\201bW!`\"`\314\211Y\203\204`X\206\204\333\314!BFBF,\202\324)`\204\251\340\201cE\211\323U\203\244\350\202\247\201d#\210G\205\260F.\207" [map query-replace-map query-flag minibuffer-auto-raise case-fold-search case-replace raise-frame window-frame minibuffer-window re-search-forward search-forward nil t 0 substitute-command-keys "Query replacing %s with %s: (\\\\[help] for help) " copy-marker run-hooks deactivate-mark-hook 1 replace-loop-through-replacements vector "\\b" regexp-quote push-mark undo-boundary ((byte-code "\203 \204\n\303V\203\304u\210\305 \207" [regexp-flag match-again replace-count 0 -1 replace-dehighlight] 2)) match-data looking-at set-match-data replace-match replace-highlight message read-event lookup-key help "*Help*" princ "Query replacing " "regexp " "" " with " ".\n\n" help-mode exit backup "No previous match" ding no-terminate sit-for act act-and-exit act-and-show automatic skip recenter edit point-marker recursive-edit edit-replacement read-input "Edit replacement string: " delete-and-edit mode-exited from-string regexp-flag match-again limit nonempty-match replace-count stack keep-going next-replacement real-match-data search-string search-function literal nocasify start end transient-mark-mode mark-active replacements repeat-count delimited-flag match def key replaced done message-log-max query-replace-help standard-output elt opos this-command unread-command-events append listify-key-sequence "Replaced %d occurrence%s" "s"] 16 (#$ . 26560)]) #@61 *Non-nil means to highlight words during query replacement. (custom-declare-variable 'query-replace-highlight 't '(#$ . -30452) :type 'boolean :group 'matching) (byte-code "\301B\302\301!\204\f\303\303\207" [current-load-list replace-overlay boundp nil] 2) (defalias 'replace-dehighlight #[nil "\205 \301!\210\302\211\207" [replace-overlay delete-overlay nil] 2]) (defalias 'replace-highlight #[(start end) "\205# \204\304\n \"\305 \306\307\310!\203\310\202\311#\210\312 \n p$\207" [query-replace-highlight replace-overlay start end make-overlay overlay-put face facep query-replace region move-overlay] 5])