Re: query-replace-interactive not documented

[Juri Linkov]

David Kastrup <address@hidden> writes:
> Anyway, since it appears that we can hardly avoid using non-escaped
> parens if we want to make use of the Lisp reader as well as paren
> matching, one might as well use the original proposal allowing a
> variable name directly.

Yes, I think paren matching is needed for editing Lisp expressions
in the minibuffer.

> How about using \'?  After all, we have an unevaled expression
> following.

In regexps \' is used to match the empty string at the end of the
buffer.  But perhaps in the replacement string this symbol is free
to use.  Also in some pattern-matching languages like Perl $' is
an alias for $POSTMATCH.  But I don't see what it could mean in the
context of `query-replace-regexp'.  So unless a potential meaning for
\' in `query-replace-regexp' will be proposed, I think \' is a good
symbol which would have mnemonics of quoting Lisp expression.

> First you are matching against !( not against \!( or similar.

OK, this is the easiest part.  I tried different prefixes and messed up
the latest one.

> Then you are not replacing any \1 \2 or similar sequences as far as
> I can see.  It will probably not be easy to do this right: have the
> \( replacement not being interpreted afterwards, but the non-evalled
> ones still being interpreted.  Probably one needs to explicitly
> double any \ returned from the evaluation, and then call
> perform-replace with "t" instead of 'literal.

Replacing backreferences in expressions is easy: it is just one call
to `replace-match-string-symbols'.  Replacing them in strings is easy
as well: just using t instead of `literal'.  However, this has one
side-effect: when evaluation returns a string in the form \D, then it
is substituted later for the Dth occurrence.  But I think this is right:
it allows to construct replacement strings by Lisp expressions (though,
it is not very needed).

Anyway, with the current implementation all three expressions below
produce the same replacement for the entire string:

\& = \'\& = \'"\\&"

Here is the newest version.  I tested it a little, and it seems
it works in all mentioned cases.

Index: replace.el
===================================================================
RCS file: /cvsroot/emacs/emacs/lisp/replace.el,v
retrieving revision 1.172
diff -c -r1.172 replace.el
*** replace.el  10 Jun 2004 04:21:14 -0000      1.172
--- replace.el  15 Jun 2004 17:57:28 -0000
***************
*** 174,179 ****
--- 183,199 ----
           (if (and transient-mark-mode mark-active)
               (region-end)))))
  
+   (if (string-match "\\\\'" to-string)
+       (let (to expr)
+         (while (string-match "\\\\'" to-string)
+           (setq to  (cons (substring to-string 0 (match-beginning 0)) to)
+                 to-string (substring to-string   (match-end       0))
+                 expr      (read-from-string to-string)
+                 to        (cons `(format "%s" ,(car expr)) to)
+                 to-string (substring to-string (cdr expr))))
+         (setq to (nreverse (cons to-string to)))
+         (replace-match-string-symbols to)
+         (setq to-string `(replace-eval-replacement concat ,@to))))
    (perform-replace regexp to-string t t delimited nil nil start end))
  (define-key esc-map [?\C-%] 'query-replace-regexp)

-- 
Juri Linkov
http://www.jurta.org/emacs/