Advanced query-replace-regexp in code

Advanced query-replace-regexp in code

[Nordlöw]

I can't get the following example to work programmatically.

  M-x replace-regexp
  Replace regexp:  \(\w+\)
  Replace regexp with:  \,(capitalize \1)

Is this only possible in interactive query-replace?
If so should I use a combination of while(), looking-at(), re-search-
forward(), replace-match(), match-string() etc.

Thanks in advance,
Per Nordlöw

Re: Advanced query-replace-regexp in code

[Pascal J. Bourguignon]

Nordlöw <per.nordlow@gmail.com> writes:

> I can't get the following example to work programmatically.
>
>   M-x replace-regexp
>   Replace regexp:  \(\w+\)
>   Replace regexp with:  \,(capitalize \1)
>
> Is this only possible in interactive query-replace?
> If so should I use a combination of while(), looking-at(), re-search-
> forward(), replace-match(), match-string() etc.

Yes, for non-interactive use, it's advised to do

        (while (re-search-forward ...)
           (let ((m1 (match-string ...))
                  ...)
               (delete-region ...)
               (insert (format "%s" (your-sexp m1 ...)))))

-- 
__Pascal Bourguignon__

Re: Advanced query-replace-regexp in code

[Barry Margolin]

[-- Warning: decoded text below may be mangled, UTF-8 assumed --]
[-- Attachment #1: Type: text/plain, Size: 872 bytes --]

In article 
<f3f72811-6305-4f62-98af-3a86d6646e9f@e20g2000vbc.googlegroups.com>,
 Nordlöw <per.nordlow@gmail.com> wrote:

> I can't get the following example to work programmatically.
> 
>   M-x replace-regexp
>   Replace regexp:  \(\w+\)
>   Replace regexp with:  \,(capitalize \1)
> 
> Is this only possible in interactive query-replace?
> If so should I use a combination of while(), looking-at(), re-search-
> forward(), replace-match(), match-string() etc.

Yes.  Notice that the documentation of replace-regexp says:

In interactive calls, the replacement text may contain `\,'

It's a special extension just for interactive use.  I'm not sure why it 
was restricted this way.

-- 
Barry Margolin, barmar@alum.mit.edu
Arlington, MA
*** PLEASE post questions in newsgroups, not directly to me ***
*** PLEASE don't copy me on replies, I'll read them in the group ***

Re: Advanced query-replace-regexp in code

[Teemu Likonen]

On 2009-05-27 21:19 (-0400), Barry Margolin wrote:

> In interactive calls, the replacement text may contain `\,'
>
> It's a special extension just for interactive use. I'm not sure why it
> was restricted this way.

I think in Lisp programs it's much easier and more problem-free to
evaluate Lisp expressions normal Lisp-way than to write expressions
inside strings and use the "\\,expression" form there.

Interactive replace string

    \,(capitalize \1)

can be written as

    (capitalize (match-string 1))

in programs. With functions like "concat" or "format" the latter
expression can be concatenated with the surrounding replace string.

Re: Advanced query-replace-regexp in code

[Barry Margolin]

In article <878wkhakp1.fsf@iki.fi>, Teemu Likonen <tlikonen@iki.fi> 
wrote:

> On 2009-05-27 21:19 (-0400), Barry Margolin wrote:
> 
> > In interactive calls, the replacement text may contain `\,'
> >
> > It's a special extension just for interactive use. I'm not sure why it
> > was restricted this way.
> 
> I think in Lisp programs it's much easier and more problem-free to
> evaluate Lisp expressions normal Lisp-way than to write expressions
> inside strings and use the "\\,expression" form there.
> 
> Interactive replace string
> 
>     \,(capitalize \1)
> 
> can be written as
> 
>     (capitalize (match-string 1))
> 
> in programs. With functions like "concat" or "format" the latter
> expression can be concatenated with the surrounding replace string.

In that case, why allow programs to call replace-regexp in the first 
place?  If they can call it, why shouldn't they be able to use all the 
features?

replace-regexp also does the searching and looping for you.  So instead 
of a simple, concise one-liner, you have to code everything, with the 
potential to screw up.

-- 
Barry Margolin, barmar@alum.mit.edu
Arlington, MA
*** PLEASE post questions in newsgroups, not directly to me ***
*** PLEASE don't copy me on replies, I'll read them in the group ***

Re: Advanced query-replace-regexp in code

[Johan Bockgård]

Barry Margolin <barmar@alum.mit.edu> writes:

> In that case, why allow programs to call replace-regexp in the first
> place? If they can call it, why shouldn't they be able to use all the
> features?

They shouldn't call it:

    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.

Re: Advanced query-replace-regexp in code

[Barry Margolin]

In article <mailman.8013.1243539406.31690.help-gnu-emacs@gnu.org>,
 bojohan+news@dd.chalmers.se (Johan Bockgard) wrote:

> Barry Margolin <barmar@alum.mit.edu> writes:
> 
> > In that case, why allow programs to call replace-regexp in the first
> > place? If they can call it, why shouldn't they be able to use all the
> > features?
> 
> They shouldn't call it:
> 
>     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.

Regardless of whether they should or shouldn't use it, it still seems 
strange that the function interprets the second argument differently 
depending on whether it's use interactively or programmatically.  If it 
shouldn't be used programmatically, why is it important that this mode 
*not* recognize \,<expr>?

-- 
Barry Margolin, barmar@alum.mit.edu
Arlington, MA
*** PLEASE post questions in newsgroups, not directly to me ***
*** PLEASE don't copy me on replies, I'll read them in the group ***

Re: Advanced query-replace-regexp in code

[Nordlöw]

On May 29, 4:14 am, Barry Margolin <bar...@alum.mit.edu> wrote:
> In article <mailman.8013.1243539406.31690.help-gnu-em...@gnu.org>,
>  bojohan+n...@dd.chalmers.se (Johan Bockgard) wrote:
>
> > Barry Margolin <bar...@alum.mit.edu> writes:
>
> > > In that case, why allow programs to call replace-regexp in the first
> > > place? If they can call it, why shouldn't they be able to use all the
> > > features?
>
> > They shouldn't call it:
>
> >     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.
>
> Regardless of whether they should or shouldn't use it, it still seems
> strange that the function interprets the second argument differently
> depending on whether it's use interactively or programmatically.  If it
> shouldn't be used programmatically, why is it important that this mode
> *not* recognize \,<expr>?
>
> --
> Barry Margolin, bar...@alum.mit.edu
> Arlington, MA
> *** PLEASE post questions in newsgroups, not directly to me ***
> *** PLEASE don't copy me on replies, I'll read them in the group ***

I agree, this makes no sense as this is powerful feature, eventhough
it runs slowly.

/Nordlöw

Re: Advanced query-replace-regexp in code

[Johan Bockgård]

Barry Margolin <barmar@alum.mit.edu> writes:

> Regardless of whether they should or shouldn't use it, it still seems
> strange that the function interprets the second argument differently
> depending on whether it's use interactively or programmatically.

It doesn't; the magic is in the interactive form.

Re: Advanced query-replace-regexp in code

[Barry Margolin]

In article <mailman.8166.1243709727.31690.help-gnu-emacs@gnu.org>,
 bojohan+news@dd.chalmers.se (Johan Bockgard) wrote:

> Barry Margolin <barmar@alum.mit.edu> writes:
> 
> > Regardless of whether they should or shouldn't use it, it still seems
> > strange that the function interprets the second argument differently
> > depending on whether it's use interactively or programmatically.
> 
> It doesn't; the magic is in the interactive form.

Which seems like a silly place to put it, when it could just as easily 
be in the main body of the function.

-- 
Barry Margolin, barmar@alum.mit.edu
Arlington, MA
*** PLEASE post questions in newsgroups, not directly to me ***
*** PLEASE don't copy me on replies, I'll read them in the group ***

Re: Advanced query-replace-regexp in code

[harven]

Nordlöw <per.nordlow@gmail.com> writes:

> I can't get the following example to work programmatically.
>
>   M-x replace-regexp
>   Replace regexp:  \(\w+\)
>   Replace regexp with:  \,(capitalize \1)
>
> Is this only possible in interactive query-replace?
> If so should I use a combination of while(), looking-at(), re-search-
> forward(), replace-match(), match-string() etc.
>
> Thanks in advance,
> Per Nordlöw

(defun my-cap ()
  (interactive)
  (while (re-search-forward "\\w+" nil t)
     (replace-match (capitalize (match-string 0)) nil t)))


From the doc string of replace-regexp:

[replace-regexp] 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.

hope that helps

Re: Advanced query-replace-regexp in code

[David Kastrup]

Nordlöw <per.nordlow@gmail.com> writes:

> I can't get the following example to work programmatically.
>
>   M-x replace-regexp
>   Replace regexp:  \(\w+\)
>   Replace regexp with:  \,(capitalize \1)
>
> Is this only possible in interactive query-replace?
> If so should I use a combination of while(), looking-at(), re-search-
> forward(), replace-match(), match-string() etc.

Do it interactively, then use

C-x ESC ESC

in order to figure out how to this non-interactively.

-- 
David Kastrup

Re: Advanced query-replace-regexp in code

[Thierry Volpiatto]

David Kastrup <dak@gnu.org> writes:

> Nordlöw <per.nordlow@gmail.com> writes:
>
>> I can't get the following example to work programmatically.
>>
>>   M-x replace-regexp
>>   Replace regexp:  \(\w+\)
>>   Replace regexp with:  \,(capitalize \1)
>>
>> Is this only possible in interactive query-replace?
>> If so should I use a combination of while(), looking-at(), re-search-
>> forward(), replace-match(), match-string() etc.
>
> Do it interactively, then use
>
> C-x ESC ESC
>
> in order to figure out how to this non-interactively.

An example of how to do that could be that:

,----[ Upcase all buffer ]
| (save-excursion
|   (goto-char (point-min))
|   (while (not (eobp))
|     (when (re-search-forward "\\w+" (point-max) t)
|       (replace-match (upcase (match-string 0))))))
`----

-- 
A + Thierry Volpiatto
Location: Saint-Cyr-Sur-Mer - France

Re: Advanced query-replace-regexp in code

[Thierry Volpiatto]

Thierry Volpiatto <thierry.volpiatto@gmail.com> writes:

> David Kastrup <dak@gnu.org> writes:
>
>> Nordlöw <per.nordlow@gmail.com> writes:
>>
>>> I can't get the following example to work programmatically.
>>>
>>>   M-x replace-regexp
>>>   Replace regexp:  \(\w+\)
>>>   Replace regexp with:  \,(capitalize \1)
>>>
>>> Is this only possible in interactive query-replace?
>>> If so should I use a combination of while(), looking-at(), re-search-
>>> forward(), replace-match(), match-string() etc.
>>
>> Do it interactively, then use
>>
>> C-x ESC ESC
>>
>> in order to figure out how to this non-interactively.
>
> An example of how to do that could be that:
>
> ,----[ Upcase all buffer ]
> | (save-excursion
> |   (goto-char (point-min))
> |   (while (not (eobp))
> |     (when (re-search-forward "\\w+" (point-max) t)
> |       (replace-match (upcase (match-string 0))))))
> `----

After testing the above code, (don't break at eob) i found that better:

,----
| (save-excursion
|   (goto-char (point-min))
|   (while (re-search-forward "\\w+" nil t)
|       (replace-match (upcase (match-string 0)))))
`----


-- 
A + Thierry Volpiatto
Location: Saint-Cyr-Sur-Mer - France