A variant of match-end, but after replacement?

A variant of match-end, but after replacement?

[Marcin Borkowski]

Hi all,

I perform search using string-match, and then do the replacement using
replace-match.  Now I'd like to know the position of the end of my
replacement, so that I know where to start the next search (since I'm
coding a variant of replace-regexp-in-string).  Is there anything like
that in Emacs, or should I just concatenate the parts before and after
the match with the match in-between instead of using replace-match, so
that I can calculate that position myself?

Note: I have good reasons not to use replace-regexp-in-string, since
I want to replace each match with something different, according to what
was matched inside one of the groups.  AFAIK, replace-regexp-in-string
doesn't support such a use-case.

TIA,

-- 
Marcin Borkowski
http://octd.wmi.amu.edu.pl/en/Marcin_Borkowski
Faculty of Mathematics and Computer Science
Adam Mickiewicz University

Re: A variant of match-end, but after replacement?

[Dmitry Gutov]

By the way,

On 07/19/2015 02:49 PM, Marcin Borkowski wrote:
> Note: I have good reasons not to use replace-regexp-in-string, since
> I want to replace each match with something different, according to what
> was matched inside one of the groups.  AFAIK, replace-regexp-in-string
> doesn't support such a use-case.

...it does. Its REP argument can be a function, and in it you're free to 
choose the replacement based on the match data.

Re: A variant of match-end, but after replacement?

[Pascal J. Bourguignon]

Marcin Borkowski <mbork@mbork.pl> writes:

> Hi all,
>
> I perform search using string-match, and then do the replacement using
> replace-match.  Now I'd like to know the position of the end of my
> replacement, so that I know where to start the next search (since I'm
> coding a variant of replace-regexp-in-string).  Is there anything like
> that in Emacs, or should I just concatenate the parts before and after
> the match with the match in-between instead of using replace-match, so
> that I can calculate that position myself?

   (let ((old-end (prog1 (match-end 1)
                    (replace-match "newtext" t t nil 1)))) 
      (do-something old-end))


-- 
__Pascal Bourguignon__                 http://www.informatimago.com/
“The factory of the future will have only two employees, a man and a
dog. The man will be there to feed the dog. The dog will be there to
keep the man from touching the equipment.” -- Carl Bass CEO Autodesk

Re: A variant of match-end, but after replacement?

[Marcin Borkowski]

On 2015-07-19, at 14:06, Pascal J. Bourguignon <pjb@informatimago.com> wrote:

> Marcin Borkowski <mbork@mbork.pl> writes:
>
>> Hi all,
>>
>> I perform search using string-match, and then do the replacement using
>> replace-match.  Now I'd like to know the position of the end of my
>> replacement, so that I know where to start the next search (since I'm
>> coding a variant of replace-regexp-in-string).  Is there anything like
>> that in Emacs, or should I just concatenate the parts before and after
>> the match with the match in-between instead of using replace-match, so
>> that I can calculate that position myself?
>
>    (let ((old-end (prog1 (match-end 1)
>                     (replace-match "newtext" t t nil 1)))) 
>       (do-something old-end))

Nope - I'm doing search and replacement in a string, not in a buffer...

Thanks anyway

-- 
Marcin Borkowski
http://octd.wmi.amu.edu.pl/en/Marcin_Borkowski
Faculty of Mathematics and Computer Science
Adam Mickiewicz University

Re: A variant of match-end, but after replacement?

[Marcin Borkowski]

On 2015-07-19, at 14:22, Marcin Borkowski <mbork@mbork.pl> wrote:

> On 2015-07-19, at 14:06, Pascal J. Bourguignon <pjb@informatimago.com> wrote:
>
>> Marcin Borkowski <mbork@mbork.pl> writes:
>>
>>> Hi all,
>>>
>>> I perform search using string-match, and then do the replacement using
>>> replace-match.  Now I'd like to know the position of the end of my
>>> replacement, so that I know where to start the next search (since I'm
>>> coding a variant of replace-regexp-in-string).  Is there anything like
>>> that in Emacs, or should I just concatenate the parts before and after
>>> the match with the match in-between instead of using replace-match, so
>>> that I can calculate that position myself?
>>
>>    (let ((old-end (prog1 (match-end 1)
>>                     (replace-match "newtext" t t nil 1)))) 
>>       (do-something old-end))
>
> Nope - I'm doing search and replacement in a string, not in a buffer...

BTW: this probably won't work in a buffer either, since match-end
returns a number, not a marker (as I thought).

> Thanks anyway

Best,

-- 
Marcin Borkowski
http://octd.wmi.amu.edu.pl/en/Marcin_Borkowski
Faculty of Mathematics and Computer Science
Adam Mickiewicz University

Re: A variant of match-end, but after replacement?

[Nicolas Richard]

Marcin Borkowski <mbork@mbork.pl> writes:
> Nope - I'm doing search and replacement in a string, not in a buffer...

you could do:
   (with-temp-buffer
     (insert string)
     do-magic-here
     (buffer-string))

-- 
Nico.

Re: A variant of match-end, but after replacement?

[Pascal J. Bourguignon]

Marcin Borkowski <mbork@mbork.pl> writes:

> On 2015-07-19, at 14:06, Pascal J. Bourguignon <pjb@informatimago.com> wrote:
>
>> Marcin Borkowski <mbork@mbork.pl> writes:
>>
>>> Hi all,
>>>
>>> I perform search using string-match, and then do the replacement using
>>> replace-match.  Now I'd like to know the position of the end of my
>>> replacement, so that I know where to start the next search (since I'm
>>> coding a variant of replace-regexp-in-string).  Is there anything like
>>> that in Emacs, or should I just concatenate the parts before and after
>>> the match with the match in-between instead of using replace-match, so
>>> that I can calculate that position myself?
>>
>>    (let ((old-end (prog1 (match-end 1)
>>                     (replace-match "newtext" t t nil 1)))) 
>>       (do-something old-end))
>
> Nope - I'm doing search and replacement in a string, not in a buffer...
>
> Thanks anyway

Then:

    (let ((old-end (prog1 (match-end 1)
                     (replace-match "newtext" t t string 1)))) 
       (do-something old-end))
-- 
__Pascal Bourguignon__                 http://www.informatimago.com/
“The factory of the future will have only two employees, a man and a
dog. The man will be there to feed the dog. The dog will be there to
keep the man from touching the equipment.” -- Carl Bass CEO Autodesk

Re: A variant of match-end, but after replacement?

[Marcin Borkowski]

On 2015-07-19, at 14:30, Pascal J. Bourguignon <pjb@informatimago.com> wrote:

> Marcin Borkowski <mbork@mbork.pl> writes:
>
>> On 2015-07-19, at 14:06, Pascal J. Bourguignon <pjb@informatimago.com> wrote:
>>
>>> Marcin Borkowski <mbork@mbork.pl> writes:
>>>
>>>> Hi all,
>>>>
>>>> I perform search using string-match, and then do the replacement using
>>>> replace-match.  Now I'd like to know the position of the end of my
>>>> replacement, so that I know where to start the next search (since I'm
>>>> coding a variant of replace-regexp-in-string).  Is there anything like
>>>> that in Emacs, or should I just concatenate the parts before and after
>>>> the match with the match in-between instead of using replace-match, so
>>>> that I can calculate that position myself?
>>>
>>>    (let ((old-end (prog1 (match-end 1)
>>>                     (replace-match "newtext" t t nil 1)))) 
>>>       (do-something old-end))
>>
>> Nope - I'm doing search and replacement in a string, not in a buffer...
>>
>> Thanks anyway
>
> Then:
>
>     (let ((old-end (prog1 (match-end 1)
>                      (replace-match "newtext" t t string 1)))) 
>        (do-something old-end))

Still not there - I can't assume that "newtext" will have the same
length as the thing it replaced...

-- 
Marcin Borkowski
http://octd.wmi.amu.edu.pl/en/Marcin_Borkowski
Faculty of Mathematics and Computer Science
Adam Mickiewicz University

Re: A variant of match-end, but after replacement?

[Dmitry Gutov]

On 07/19/2015 04:20 PM, Marcin Borkowski wrote:

> Still not there - I can't assume that "newtext" will have the same
> length as the thing it replaced...

You can do the arithmetics there, or use a marker.

Re: A variant of match-end, but after replacement?

[Marcin Borkowski]

On 2015-07-19, at 15:26, Dmitry Gutov <dgutov@yandex.ru> wrote:

> On 07/19/2015 04:20 PM, Marcin Borkowski wrote:
>
>> Still not there - I can't assume that "newtext" will have the same
>> length as the thing it replaced...
>
> You can do the arithmetics there, or use a marker.

Arithmetic is fine (as Pascal showed in his last answer), markers not
(I'm in a string, not a buffer).

Best,

-- 
Marcin Borkowski
http://octd.wmi.amu.edu.pl/en/Marcin_Borkowski
Faculty of Mathematics and Computer Science
Adam Mickiewicz University

Re: A variant of match-end, but after replacement?

[Pascal J. Bourguignon]

Marcin Borkowski <mbork@mbork.pl> writes:

>>     (let ((old-end (prog1 (match-end 1)
>>                      (replace-match "newtext" t t string 1)))) 
>>        (do-something old-end))
>
> Still not there - I can't assume that "newtext" will have the same
> length as the thing it replaced...

Sorry, I misread what you wanted. 

    (let ((new-end (+ (prog1 (match-beginning 1)
                         (replace-match new-text t t string 1)))
                      (length new-text)))
       (do-somthing-from new-end))


-- 
__Pascal Bourguignon__                 http://www.informatimago.com/
“The factory of the future will have only two employees, a man and a
dog. The man will be there to feed the dog. The dog will be there to
keep the man from touching the equipment.” -- Carl Bass CEO Autodesk

Re: A variant of match-end, but after replacement?

[Marcin Borkowski]

On 2015-07-19, at 15:41, Pascal J. Bourguignon <pjb@informatimago.com> wrote:

> Marcin Borkowski <mbork@mbork.pl> writes:
>
>>>     (let ((old-end (prog1 (match-end 1)
>>>                      (replace-match "newtext" t t string 1)))) 
>>>        (do-something old-end))
>>
>> Still not there - I can't assume that "newtext" will have the same
>> length as the thing it replaced...
>
> Sorry, I misread what you wanted. 
>
>     (let ((new-end (+ (prog1 (match-beginning 1)
>                          (replace-match new-text t t string 1)))
>                       (length new-text)))
>        (do-somthing-from new-end))

Thanks!  That's easy, and indeed it will work, since the length of the
replacement is fixed in my use-case.

Best,

-- 
Marcin Borkowski
http://octd.wmi.amu.edu.pl/en/Marcin_Borkowski
Faculty of Mathematics and Computer Science
Adam Mickiewicz University

Re: A variant of match-end, but after replacement?

[Barry Margolin]

In article <mailman.7160.1437335923.904.help-gnu-emacs@gnu.org>,
 Marcin Borkowski <mbork@mbork.pl> wrote:

> On 2015-07-19, at 15:41, Pascal J. Bourguignon <pjb@informatimago.com> wrote:
> 
> > Marcin Borkowski <mbork@mbork.pl> writes:
> >
> >>>     (let ((old-end (prog1 (match-end 1)
> >>>                      (replace-match "newtext" t t string 1)))) 
> >>>        (do-something old-end))
> >>
> >> Still not there - I can't assume that "newtext" will have the same
> >> length as the thing it replaced...
> >
> > Sorry, I misread what you wanted. 
> >
> >     (let ((new-end (+ (prog1 (match-beginning 1)
> >                          (replace-match new-text t t string 1)))
> >                       (length new-text)))
> >        (do-somthing-from new-end))
> 
> Thanks!  That's easy, and indeed it will work, since the length of the
> replacement is fixed in my use-case.

Yeah, this would be trickier if new-text contained back-references.

-- 
Barry Margolin, barmar@alum.mit.edu
Arlington, MA
*** PLEASE post questions in newsgroups, not directly to me ***

Re: A variant of match-end, but after replacement?

[Pascal J. Bourguignon]

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

> In article <mailman.7160.1437335923.904.help-gnu-emacs@gnu.org>,
>  Marcin Borkowski <mbork@mbork.pl> wrote:
>
>> On 2015-07-19, at 15:41, Pascal J. Bourguignon <pjb@informatimago.com> wrote:
>> 
>> > Marcin Borkowski <mbork@mbork.pl> writes:
>> >
>> >>>     (let ((old-end (prog1 (match-end 1)
>> >>>                      (replace-match "newtext" t t string 1)))) 
>> >>>        (do-something old-end))
>> >>
>> >> Still not there - I can't assume that "newtext" will have the same
>> >> length as the thing it replaced...
>> >
>> > Sorry, I misread what you wanted. 
>> >
>> >     (let ((new-end (+ (prog1 (match-beginning 1)
>> >                          (replace-match new-text t t string 1)))
>> >                       (length new-text)))
>> >        (do-somthing-from new-end))
>> 
>> Thanks!  That's easy, and indeed it will work, since the length of the
>> replacement is fixed in my use-case.
>
> Yeah, this would be trickier if new-text contained back-references.

Not very much:

    (let ((end        (match-end 1))
          (new-string (replace-match new-text t t string 1)))
      (do-something-from new-string
                         (+ end (- (length string) (legnth new-string)))))


-- 
__Pascal Bourguignon__                 http://www.informatimago.com/
“The factory of the future will have only two employees, a man and a
dog. The man will be there to feed the dog. The dog will be there to
keep the man from touching the equipment.” -- Carl Bass CEO Autodesk

Re: A variant of match-end, but after replacement?

[Marcin Borkowski]

On 2015-07-20, at 00:45, Pascal J. Bourguignon <pjb@informatimago.com> wrote:

> Barry Margolin <barmar@alum.mit.edu> writes:
>
>> In article <mailman.7160.1437335923.904.help-gnu-emacs@gnu.org>,
>>  Marcin Borkowski <mbork@mbork.pl> wrote:
>>
>>> On 2015-07-19, at 15:41, Pascal J. Bourguignon <pjb@informatimago.com> wrote:
>>> 
>>> > Marcin Borkowski <mbork@mbork.pl> writes:
>>> >
>>> >>>     (let ((old-end (prog1 (match-end 1)
>>> >>>                      (replace-match "newtext" t t string 1)))) 
>>> >>>        (do-something old-end))
>>> >>
>>> >> Still not there - I can't assume that "newtext" will have the same
>>> >> length as the thing it replaced...
>>> >
>>> > Sorry, I misread what you wanted. 
>>> >
>>> >     (let ((new-end (+ (prog1 (match-beginning 1)
>>> >                          (replace-match new-text t t string 1)))
>>> >                       (length new-text)))
>>> >        (do-somthing-from new-end))
>>> 
>>> Thanks!  That's easy, and indeed it will work, since the length of the
>>> replacement is fixed in my use-case.
>>
>> Yeah, this would be trickier if new-text contained back-references.
>
> Not very much:
>
>     (let ((end        (match-end 1))
>           (new-string (replace-match new-text t t string 1)))
>       (do-something-from new-string
>                          (+ end (- (length string) (legnth new-string)))))

I give up.  It seems that a PhD in math is not enough to deal with
string-length arithmetic;-).  Shame on me!  (OTOH, mails from you often
teach me that when I have the impression that I'm smart, it's usually
only an impression.)

Thanks a lot!

-- 
Marcin Borkowski
http://octd.wmi.amu.edu.pl/en/Marcin_Borkowski
Faculty of Mathematics and Computer Science
Adam Mickiewicz University

Re: A variant of match-end, but after replacement?

[Pascal J. Bourguignon]

Marcin Borkowski <mbork@mbork.pl> writes:
>> Not very much:
>>
>>     (let ((end        (match-end 1))
>>           (new-string (replace-match new-text t t string 1)))
>>       (do-something-from new-string
>>                          (+ end (- (length new-string) (length string)))))
>
> I give up.  It seems that a PhD in math is not enough to deal with
> string-length arithmetic;-).  Shame on me!  (OTOH, mails from you often
> teach me that when I have the impression that I'm smart, it's usually
> only an impression.)

Sorry, I was about to write out the equation, but if it's necessary,
I'll do.



   (length new-string)
   --------------------------------------------------------
   (length prefix)  (length new)           (length suffix)
   ---------------- ---------------------- ----------------
   pppppppppppppppp nnnnnnnnnnnnnnnnnnnnnn ssssssssssssssss
                                          ^
                                          |
                                       new-end

   (length old-string)
   --------------------------------------------------
   (length prefix)  (length old)     (length suffix)
   ---------------- ---------------- ----------------
   pppppppppppppppp oooooooooooooooo ssssssssssssssss
                                    ^
                                    |
                               (match-end)


So, we have:

    (= (length suffix) (- (length new-string) new-end))
    (= (length suffix) (- (length old-string) (match-end)))

Or, in math:

       s = ns-ne
       s = os-me
    
Therefore:

        0 = (ns-ne) - (os-me)
  <=>   0 = ns - ne - os + me
  <=>  ne = me + (ns - os)
  <=> (= new-end (+ (match-end) (- (length new-string) (length old-string))))
      
Hence:
           
     (let ((end        (match-end 1))
           (new-string (replace-match new-text t t old-string 1)))
       (do-something-from new-string
                          (+ end (- (length new-string) (length old-string)))))


-- 
__Pascal Bourguignon__                 http://www.informatimago.com/
“The factory of the future will have only two employees, a man and a
dog. The man will be there to feed the dog. The dog will be there to
keep the man from touching the equipment.” -- Carl Bass CEO Autodesk