Matching labels with buttons

Matching labels with buttons

[Heime]

I want to match cases such as

Label [-]

Have constructed the following regexp, but it does not match the above

"\\(.*\\)\\(\\s-*\\[\\-\\]\\s-*\\)"

I aw using 

(when (string-match "\\(.*\\)\\(\\s-*\\[\\-\\]\\s-*\\)" text)




Sent with Proton Mail secure email.

Re: Matching labels with buttons

[Heime]

Sent with Proton Mail secure email.

On Monday, July 15th, 2024 at 11:17 PM, Heime <heimeborgia@protonmail.com> wrote:

> I want to match cases such as
> 
> Label [-]
> 
> Have constructed the following regexp, but it does not match the above
> 
> "\\(.\\)\\(\\s-\\[\\-\\]\\s-\\)"
> 
> I aw using
> 
> (when (string-match "\\(.\\)\\(\\s-\\[\\-\\]\\s-\\)" text)

In the code I have

  (if (string-match "\\(\\s-*\\[\\-\\]\\s-*\\)\\(.*\\)" label)    ; [-] LB

      (progn
        (setq bt (match-string 1 label))
        (setq lb (match-string 2 label))
        (setq result
               (concat bt (propertize lb 'face '(:foreground "red")))))


    (when (string-match "\\(.*\\)\\(\\s-*\\[\\-\\]\\s-*\\)" label) ; LB [-]

      (setq lb (match-string 1 label))
      (setq bt (match-string 2 label))
      (setq result 
             (concat (propertize lb 'face '(:foreground "red")) bt)))

Doing some tests with 

"OFF [-]"

keeps matching the first string-match

Re: Matching labels with buttons

[Stephen Berman]

On Mon, 15 Jul 2024 11:25:28 +0000 Heime <heimeborgia@protonmail.com> wrote:

> Sent with Proton Mail secure email.
>
> On Monday, July 15th, 2024 at 11:17 PM, Heime <heimeborgia@protonmail.com> wrote:
>
>> I want to match cases such as
>>
>> Label [-]
>>
>> Have constructed the following regexp, but it does not match the above
>>
>> "\\(.\\)\\(\\s-\\[\\-\\]\\s-\\)"
>>
>> I aw using
>>
>> (when (string-match "\\(.\\)\\(\\s-\\[\\-\\]\\s-\\)" text)
>
> In the code I have
>
>   (if (string-match "\\(\\s-*\\[\\-\\]\\s-*\\)\\(.*\\)" label)    ; [-] LB
>
>       (progn
>         (setq bt (match-string 1 label))
>         (setq lb (match-string 2 label))
>         (setq result
>                (concat bt (propertize lb 'face '(:foreground "red")))))
>
>
>     (when (string-match "\\(.*\\)\\(\\s-*\\[\\-\\]\\s-*\\)" label) ; LB [-]
>
>       (setq lb (match-string 1 label))
>       (setq bt (match-string 2 label))
>       (setq result
>              (concat (propertize lb 'face '(:foreground "red")) bt)))
>
> Doing some tests with
>
> "OFF [-]"
>
> keeps matching the first string-match

That's because your regexp isn't anchored, so string-match succeeds if
it finds a match anywhere in the string passed to it.  To avoid this,
start the regexp with "\\`", which anchors it to the start of the string
being matched against; see (info "(elisp) Regexp Backslash").

Steve Berman

Re: Matching labels with buttons

[Bruno Barbier]

Heime <heimeborgia@protonmail.com> writes:

> Sent with Proton Mail secure email.
>
> On Monday, July 15th, 2024 at 11:17 PM, Heime <heimeborgia@protonmail.com> wrote:
>
>> I want to match cases such as
>> 
>> Label [-]
>> 
>> Have constructed the following regexp, but it does not match the above
>> 
>> "\\(.\\)\\(\\s-\\[\\-\\]\\s-\\)"
>> 
>> I aw using
>> 
>> (when (string-match "\\(.\\)\\(\\s-\\[\\-\\]\\s-\\)" text)
>
> In the code I have
>
>   (if (string-match "\\(\\s-*\\[\\-\\]\\s-*\\)\\(.*\\)" label)    ; [-] LB
>
>       (progn
>         (setq bt (match-string 1 label))
>         (setq lb (match-string 2 label))
>         (setq result
>                (concat bt (propertize lb 'face '(:foreground "red")))))
>
>
>     (when (string-match "\\(.*\\)\\(\\s-*\\[\\-\\]\\s-*\\)" label) ; LB [-]
>
>       (setq lb (match-string 1 label))
>       (setq bt (match-string 2 label))
>       (setq result 
>              (concat (propertize lb 'face '(:foreground "red")) bt)))
>
> Doing some tests with 
>
> "OFF [-]"
>
> keeps matching the first string-match

Because it does match:

   (string-match "\\(\\s-*\\[\\-\\]\\s-*\\)\\(.*\\)" "OFF [-]")
   => 3

When building regular expressions, I'm often using the amazing M-x
re-builder: it allows to construct regexps interactively with visual
feedbacks, it even understands the "rx" syntax, for more readable
regexps.

HTH,

Bruno

Re: Matching labels with buttons

[Heime]

On Monday, July 15th, 2024 at 11:56 PM, Stephen Berman <stephen.berman@gmx.net> wrote:

> On Mon, 15 Jul 2024 11:25:28 +0000 Heime heimeborgia@protonmail.com wrote:
> 
> > Sent with Proton Mail secure email.
> > 
> > On Monday, July 15th, 2024 at 11:17 PM, Heime heimeborgia@protonmail.com wrote:
> > 
> > > I want to match cases such as
> > > 
> > > Label [-]
> > > 
> > > Have constructed the following regexp, but it does not match the above
> > > 
> > > "\\(.\\)\\(\\s-\\[\\-\\]\\s-\\)"
> > > 
> > > I aw using
> > > 
> > > (when (string-match "\\(.\\)\\(\\s-\\[\\-\\]\\s-\\)" text)
> > 
> > In the code I have
> > 
> > (if (string-match "\\(\\s-\\[\\-\\]\\s-\\)\\(.*\\)" label) ; [-] LB
> > 
> > (progn
> > (setq bt (match-string 1 label))
> > (setq lb (match-string 2 label))
> > (setq result
> > (concat bt (propertize lb 'face '(:foreground "red")))))
> > 
> > (when (string-match "\\(.\\)\\(\\s-\\[\\-\\]\\s-*\\)" label) ; LB [-]
> > 
> > (setq lb (match-string 1 label))
> > (setq bt (match-string 2 label))
> > (setq result
> > (concat (propertize lb 'face '(:foreground "red")) bt)))
> > 
> > Doing some tests with
> > 
> > "OFF [-]"
> > 
> > keeps matching the first string-match
> 
> 
> That's because your regexp isn't anchored, so string-match succeeds if
> it finds a match anywhere in the string passed to it. To avoid this,
> start the regexp with "\\`", which anchors it to the start of the string
> being matched against; see (info "(elisp) Regexp Backslash").
> 
> Steve Berman


I would like to have two regex expressions, one to match only " [-] LABEL " and 
another to match only " LABEL [-] ".  With any number of whitespace.

Can one use "^" ?  Or is "\\`" preferred ? And can one use "[[:space:]]*" rather
than "\\s-*" ?  Which is preferred ?

Re: Matching labels with buttons

[Stephen Berman]

On Mon, 15 Jul 2024 12:35:53 +0000 Heime <heimeborgia@protonmail.com> wrote:

> On Monday, July 15th, 2024 at 11:56 PM, Stephen Berman
> <stephen.berman@gmx.net> wrote:
>
>> On Mon, 15 Jul 2024 11:25:28 +0000 Heime heimeborgia@protonmail.com wrote:
>>
>> > Sent with Proton Mail secure email.
>> >
>> > On Monday, July 15th, 2024 at 11:17 PM, Heime heimeborgia@protonmail.com wrote:
>> >
>> > > I want to match cases such as
>> > >
>> > > Label [-]
>> > >
>> > > Have constructed the following regexp, but it does not match the above
>> > >
>> > > "\\(.\\)\\(\\s-\\[\\-\\]\\s-\\)"
>> > >
>> > > I aw using
>> > >
>> > > (when (string-match "\\(.\\)\\(\\s-\\[\\-\\]\\s-\\)" text)
>> >
>> > In the code I have
>> >
>> > (if (string-match "\\(\\s-\\[\\-\\]\\s-\\)\\(.*\\)" label) ; [-] LB
>> >
>> > (progn
>> > (setq bt (match-string 1 label))
>> > (setq lb (match-string 2 label))
>> > (setq result
>> > (concat bt (propertize lb 'face '(:foreground "red")))))
>> >
>> > (when (string-match "\\(.\\)\\(\\s-\\[\\-\\]\\s-*\\)" label) ; LB [-]
>> >
>> > (setq lb (match-string 1 label))
>> > (setq bt (match-string 2 label))
>> > (setq result
>> > (concat (propertize lb 'face '(:foreground "red")) bt)))
>> >
>> > Doing some tests with
>> >
>> > "OFF [-]"
>> >
>> > keeps matching the first string-match
>>
>>
>> That's because your regexp isn't anchored, so string-match succeeds if
>> it finds a match anywhere in the string passed to it. To avoid this,
>> start the regexp with "\\`", which anchors it to the start of the string
>> being matched against; see (info "(elisp) Regexp Backslash").
>>
>> Steve Berman
>
>
> I would like to have two regex expressions, one to match only " [-] LABEL " and
> another to match only " LABEL [-] ".  With any number of whitespace.
>
> Can one use "^" ?  Or is "\\`" preferred ?

If you are always matching against a string, e.g. just using
string-match, then IIUC "^" and "\\`" give the same results.  If you are
matching against test in a buffer, e.g. with re-search-forward,
looking-at etc., then they can differ: "^" matches the beginning the the
line containing the matched string, "\\`" the beginning of the string
itself, regardless of where in the line it is (at point-min the results
are the same).

>                                            And can one use "[[:space:]]*" rather
> than "\\s-*" ?  Which is preferred ?

IIUC these both give the same results.

Steve Berman

Re: Matching labels with buttons

[Heime]

Sent with Proton Mail secure email.

On Tuesday, July 16th, 2024 at 12:52 AM, Stephen Berman <stephen.berman@gmx.net> wrote:

> On Mon, 15 Jul 2024 12:35:53 +0000 Heime heimeborgia@protonmail.com wrote:
> 
> > On Monday, July 15th, 2024 at 11:56 PM, Stephen Berman
> > stephen.berman@gmx.net wrote:
> > 
> > > On Mon, 15 Jul 2024 11:25:28 +0000 Heime heimeborgia@protonmail.com wrote:
> > > 
> > > > Sent with Proton Mail secure email.
> > > > 
> > > > On Monday, July 15th, 2024 at 11:17 PM, Heime heimeborgia@protonmail.com wrote:
> > > > 
> > > > > I want to match cases such as
> > > > > 
> > > > > Label [-]
> > > > > 
> > > > > Have constructed the following regexp, but it does not match the above
> > > > > 
> > > > > "\\(.\\)\\(\\s-\\[\\-\\]\\s-\\)"
> > > > > 
> > > > > I aw using
> > > > > 
> > > > > (when (string-match "\\(.\\)\\(\\s-\\[\\-\\]\\s-\\)" text)
> > > > 
> > > > In the code I have
> > > > 
> > > > (if (string-match "\\(\\s-\\[\\-\\]\\s-\\)\\(.*\\)" label) ; [-] LB
> > > > 
> > > > (progn
> > > > (setq bt (match-string 1 label))
> > > > (setq lb (match-string 2 label))
> > > > (setq result
> > > > (concat bt (propertize lb 'face '(:foreground "red")))))
> > > > 
> > > > (when (string-match "\\(.\\)\\(\\s-\\[\\-\\]\\s-*\\)" label) ; LB [-]
> > > > 
> > > > (setq lb (match-string 1 label))
> > > > (setq bt (match-string 2 label))
> > > > (setq result
> > > > (concat (propertize lb 'face '(:foreground "red")) bt)))
> > > > 
> > > > Doing some tests with
> > > > 
> > > > "OFF [-]"
> > > > 
> > > > keeps matching the first string-match
> > > 
> > > That's because your regexp isn't anchored, so string-match succeeds if
> > > it finds a match anywhere in the string passed to it. To avoid this,
> > > start the regexp with "\\`", which anchors it to the start of the string
> > > being matched against; see (info "(elisp) Regexp Backslash").
> > > 
> > > Steve Berman
> > 
> > I would like to have two regex expressions, one to match only " [-] LABEL " and
> > another to match only " LABEL [-] ". With any number of whitespace.
> > 
> > Can one use "^" ? Or is "\\`" preferred ?
> 
> 
> If you are always matching against a string, e.g. just using
> string-match, then IIUC "^" and "\\`" give the same results. If you are matching against test in a buffer, e.g. with re-search-forward, looking-at etc., then they can differ: "^" matches the beginning the the line containing the matched string, "\\\\`" the beginning of the string
> itself, regardless of where in the line it is (at point-min the results
> are the same).
> 
> > And can one use "[[:space:]]" rather
> > than "\\s-" ? Which is preferred ?
> 
> 
> IIUC these both give the same results.
> 
> Steve Berman

Would I introduce \\` before the first grouping

"\\`\\(\\s-\\[\\-\\]\\s-\\)\\(.*\\)"

How would I print \\` in a docstring ?

Re: Matching labels with buttons

[Stephen Berman]

On Mon, 15 Jul 2024 12:58:05 +0000 Heime <heimeborgia@protonmail.com> wrote:

> Sent with Proton Mail secure email.
>
> On Tuesday, July 16th, 2024 at 12:52 AM, Stephen Berman
> <stephen.berman@gmx.net> wrote:
>
>> On Mon, 15 Jul 2024 12:35:53 +0000 Heime heimeborgia@protonmail.com wrote:
>>
>> > On Monday, July 15th, 2024 at 11:56 PM, Stephen Berman
>> > stephen.berman@gmx.net wrote:
>> >
>> > > On Mon, 15 Jul 2024 11:25:28 +0000 Heime heimeborgia@protonmail.com wrote:
>> > >
>> > > > Sent with Proton Mail secure email.
>> > > >
>> > > > On Monday, July 15th, 2024 at 11:17 PM, Heime
>> > > > heimeborgia@protonmail.com wrote:
>> > > >
>> > > > > I want to match cases such as
>> > > > >
>> > > > > Label [-]
>> > > > >
>> > > > > Have constructed the following regexp, but it does not match the above
>> > > > >
>> > > > > "\\(.\\)\\(\\s-\\[\\-\\]\\s-\\)"
>> > > > >
>> > > > > I aw using
>> > > > >
>> > > > > (when (string-match "\\(.\\)\\(\\s-\\[\\-\\]\\s-\\)" text)
>> > > >
>> > > > In the code I have
>> > > >
>> > > > (if (string-match "\\(\\s-\\[\\-\\]\\s-\\)\\(.*\\)" label) ; [-] LB
>> > > >
>> > > > (progn
>> > > > (setq bt (match-string 1 label))
>> > > > (setq lb (match-string 2 label))
>> > > > (setq result
>> > > > (concat bt (propertize lb 'face '(:foreground "red")))))
>> > > >
>> > > > (when (string-match "\\(.\\)\\(\\s-\\[\\-\\]\\s-*\\)" label) ; LB [-]
>> > > >
>> > > > (setq lb (match-string 1 label))
>> > > > (setq bt (match-string 2 label))
>> > > > (setq result
>> > > > (concat (propertize lb 'face '(:foreground "red")) bt)))
>> > > >
>> > > > Doing some tests with
>> > > >
>> > > > "OFF [-]"
>> > > >
>> > > > keeps matching the first string-match
>> > >
>> > > That's because your regexp isn't anchored, so string-match succeeds if
>> > > it finds a match anywhere in the string passed to it. To avoid this,
>> > > start the regexp with "\\`", which anchors it to the start of the string
>> > > being matched against; see (info "(elisp) Regexp Backslash").
>> > >
>> > > Steve Berman
>> >
>> > I would like to have two regex expressions, one to match only " [-] LABEL " and
>> > another to match only " LABEL [-] ". With any number of whitespace.
>> >
>> > Can one use "^" ? Or is "\\`" preferred ?
>>
>>
>> If you are always matching against a string, e.g. just using
>> string-match, then IIUC "^" and "\\`" give the same results. If you are
>> matching against test in a buffer, e.g. with re-search-forward, looking-at
>> etc., then they can differ: "^" matches the beginning the the line
>> containing the matched string, "\\\\`" the beginning of the string
>> itself, regardless of where in the line it is (at point-min the results
>> are the same).
>>
>> > And can one use "[[:space:]]" rather
>> > than "\\s-" ? Which is preferred ?
>>
>>
>> IIUC these both give the same results.
>>
>> Steve Berman
>
> Would I introduce \\` before the first grouping
>
> "\\`\\(\\s-\\[\\-\\]\\s-\\)\\(.*\\)"

Since "\\`" matches the empty string, I don't think it matters whether
it's inside or outside of the group.  But since in this case it's
anchoring the entire regexp, it seems conceptually preferable to keep it
outside (in contrast, e.g., to the case where the regexp is a
disjunction and you only want to anchor one of the disjuncts).

> How would I print \\` in a docstring ?

You have to escape the "`": \\\\=` (not \\=\\`).

Steve Berman

Re: Matching labels with buttons

[Heime]

On Tuesday, July 16th, 2024 at 1:42 AM, Stephen Berman <stephen.berman@gmx.net> wrote:

> On Mon, 15 Jul 2024 12:58:05 +0000 Heime heimeborgia@protonmail.com wrote:
> 
> > Sent with Proton Mail secure email.
> > 
> > On Tuesday, July 16th, 2024 at 12:52 AM, Stephen Berman
> > stephen.berman@gmx.net wrote:
> > 
> > > On Mon, 15 Jul 2024 12:35:53 +0000 Heime heimeborgia@protonmail.com wrote:
> > > 
> > > > On Monday, July 15th, 2024 at 11:56 PM, Stephen Berman
> > > > stephen.berman@gmx.net wrote:
> > > > 
> > > > > On Mon, 15 Jul 2024 11:25:28 +0000 Heime heimeborgia@protonmail.com wrote:
> > > > > 
> > > > > > Sent with Proton Mail secure email.
> > > > > > 
> > > > > > On Monday, July 15th, 2024 at 11:17 PM, Heime
> > > > > > heimeborgia@protonmail.com wrote:
> > > > > > 
> > > > > > > I want to match cases such as
> > > > > > > 
> > > > > > > Label [-]
> > > > > > > 
> > > > > > > Have constructed the following regexp, but it does not match the above
> > > > > > > 
> > > > > > > "\\(.\\)\\(\\s-\\[\\-\\]\\s-\\)"
> > > > > > > 
> > > > > > > I aw using
> > > > > > > 
> > > > > > > (when (string-match "\\(.\\)\\(\\s-\\[\\-\\]\\s-\\)" text)
> > > > > > 
> > > > > > In the code I have
> > > > > > 
> > > > > > (if (string-match "\\(\\s-\\[\\-\\]\\s-\\)\\(.*\\)" label) ; [-] LB
> > > > > > 
> > > > > > (progn
> > > > > > (setq bt (match-string 1 label))
> > > > > > (setq lb (match-string 2 label))
> > > > > > (setq result
> > > > > > (concat bt (propertize lb 'face '(:foreground "red")))))
> > > > > > 
> > > > > > (when (string-match "\\(.\\)\\(\\s-\\[\\-\\]\\s-*\\)" label) ; LB [-]
> > > > > > 
> > > > > > (setq lb (match-string 1 label))
> > > > > > (setq bt (match-string 2 label))
> > > > > > (setq result
> > > > > > (concat (propertize lb 'face '(:foreground "red")) bt)))
> > > > > > 
> > > > > > Doing some tests with
> > > > > > 
> > > > > > "OFF [-]"
> > > > > > 
> > > > > > keeps matching the first string-match
> > > > > 
> > > > > That's because your regexp isn't anchored, so string-match succeeds if
> > > > > it finds a match anywhere in the string passed to it. To avoid this,
> > > > > start the regexp with "\\`", which anchors it to the start of the string
> > > > > being matched against; see (info "(elisp) Regexp Backslash").
> > > > > 
> > > > > Steve Berman
> > > > 
> > > > I would like to have two regex expressions, one to match only " [-] LABEL " and
> > > > another to match only " LABEL [-] ". With any number of whitespace.
> > > > 
> > > > Can one use "^" ? Or is "\\`" preferred ?
> > > 
> > > If you are always matching against a string, e.g. just using
> > > string-match, then IIUC "^" and "\\`" give the same results. If you are matching against test in a buffer, e.g. with re-search-forward, looking-at etc., then they can differ: "^" matches the beginning the the line containing the matched string, "\\\\\\\\`" the beginning of the string
> > > itself, regardless of where in the line it is (at point-min the results
> > > are the same).
> > > 
> > > > And can one use "[[:space:]]" rather
> > > > than "\\s-" ? Which is preferred ?
> > > 
> > > IIUC these both give the same results.
> > > 
> > > Steve Berman
> > 
> > Would I introduce \\` before the first grouping
> > 
> > "\\`\\(\\s-\\[\\-\\]\\s-\\)\\(.*\\)"
> 
> 
> Since "\\`" matches the empty string, I don't think it matters whether
> it's inside or outside of the group. But since in this case it's
> anchoring the entire regexp, it seems conceptually preferable to keep it
> outside (in contrast, e.g., to the case where the regexp is a
> disjunction and you only want to anchor one of the disjuncts).
> 
> > How would I print \\` in a docstring ?
> 
> 
> You have to escape the "`": \\\\\\\\=` (not \\=\\`).
> 
> Steve Berman


I also have to handle the case of " LABEL [-] " with a different regex, so I can
distinguish between " [-] LABEL " and " LABEL [-] ".

Re: Matching labels with buttons

[Heime]

On Tuesday, July 16th, 2024 at 4:24 AM, Heime <heimeborgia@protonmail.com> wrote:

> On Tuesday, July 16th, 2024 at 1:42 AM, Stephen Berman stephen.berman@gmx.net wrote:
> 
> > On Mon, 15 Jul 2024 12:58:05 +0000 Heime heimeborgia@protonmail.com wrote:
> > 
> > > Sent with Proton Mail secure email.
> > > 
> > > On Tuesday, July 16th, 2024 at 12:52 AM, Stephen Berman
> > > stephen.berman@gmx.net wrote:
> > > 
> > > > On Mon, 15 Jul 2024 12:35:53 +0000 Heime heimeborgia@protonmail.com wrote:
> > > > 
> > > > > On Monday, July 15th, 2024 at 11:56 PM, Stephen Berman
> > > > > stephen.berman@gmx.net wrote:
> > > > > 
> > > > > > On Mon, 15 Jul 2024 11:25:28 +0000 Heime heimeborgia@protonmail.com wrote:
> > > > > > 
> > > > > > > Sent with Proton Mail secure email.
> > > > > > > 
> > > > > > > On Monday, July 15th, 2024 at 11:17 PM, Heime
> > > > > > > heimeborgia@protonmail.com wrote:
> > > > > > > 
> > > > > > > > I want to match cases such as
> > > > > > > > 
> > > > > > > > Label [-]
> > > > > > > > 
> > > > > > > > Have constructed the following regexp, but it does not match the above
> > > > > > > > 
> > > > > > > > "\\(.\\)\\(\\s-\\[\\-\\]\\s-\\)"
> > > > > > > > 
> > > > > > > > I aw using
> > > > > > > > 
> > > > > > > > (when (string-match "\\(.\\)\\(\\s-\\[\\-\\]\\s-\\)" text)
> > > > > > > 
> > > > > > > In the code I have
> > > > > > > 
> > > > > > > (if (string-match "\\(\\s-\\[\\-\\]\\s-\\)\\(.*\\)" label) ; [-] LB
> > > > > > > 
> > > > > > > (progn
> > > > > > > (setq bt (match-string 1 label))
> > > > > > > (setq lb (match-string 2 label))
> > > > > > > (setq result
> > > > > > > (concat bt (propertize lb 'face '(:foreground "red")))))
> > > > > > > 
> > > > > > > (when (string-match "\\(.\\)\\(\\s-\\[\\-\\]\\s-*\\)" label) ; LB [-]
> > > > > > > 
> > > > > > > (setq lb (match-string 1 label))
> > > > > > > (setq bt (match-string 2 label))
> > > > > > > (setq result
> > > > > > > (concat (propertize lb 'face '(:foreground "red")) bt)))
> > > > > > > 
> > > > > > > Doing some tests with
> > > > > > > 
> > > > > > > "OFF [-]"
> > > > > > > 
> > > > > > > keeps matching the first string-match
> > > > > > 
> > > > > > That's because your regexp isn't anchored, so string-match succeeds if
> > > > > > it finds a match anywhere in the string passed to it. To avoid this,
> > > > > > start the regexp with "\\`", which anchors it to the start of the string
> > > > > > being matched against; see (info "(elisp) Regexp Backslash").
> > > > > > 
> > > > > > Steve Berman
> > > > > 
> > > > > I would like to have two regex expressions, one to match only " [-] LABEL " and
> > > > > another to match only " LABEL [-] ". With any number of whitespace.
> > > > > 
> > > > > Can one use "^" ? Or is "\\`" preferred ?
> > > > 
> > > > If you are always matching against a string, e.g. just using
> > > > string-match, then IIUC "^" and "\\`" give the same results. If you are matching against test in a buffer, e.g. with re-search-forward, looking-at etc., then they can differ: "^" matches the beginning the the line containing the matched string, "\\\\\\\\\\\\\\\\`" the beginning of the string
> > > > itself, regardless of where in the line it is (at point-min the results
> > > > are the same).
> > > > 
> > > > > And can one use "[[:space:]]" rather
> > > > > than "\\s-" ? Which is preferred ?
> > > > 
> > > > IIUC these both give the same results.
> > > > 
> > > > Steve Berman
> > > 
> > > Would I introduce \\` before the first grouping
> > > 
> > > "\\`\\(\\s-\\[\\-\\]\\s-\\)\\(.*\\)"
> > 
> > Since "\\`" matches the empty string, I don't think it matters whether
> > it's inside or outside of the group. But since in this case it's
> > anchoring the entire regexp, it seems conceptually preferable to keep it
> > outside (in contrast, e.g., to the case where the regexp is a
> > disjunction and you only want to anchor one of the disjuncts).
> > 
> > > How would I print \\` in a docstring ?
> > 
> > You have to escape the "`": \\\\\\\\\\\\\\\\=` (not \\=\\`).
> > 
> > Steve Berman
> 
> I also have to handle the case of " LABEL [-] " with a different regex, so I can
> distinguish between " [-] LABEL " and " LABEL [-] ".

In the latter case I want to match [-] at the end with any trailing spaces.

Re: Matching labels with buttons

[tpeplt]

Bruno Barbier <brubar.cs@gmail.com> writes:

> Heime <heimeborgia@protonmail.com> writes:
>
> ...
>
> Because it does match:
>
>    (string-match "\\(\\s-*\\[\\-\\]\\s-*\\)\\(.*\\)" "OFF [-]")
>    => 3
>
> When building regular expressions, I'm often using the amazing M-x
> re-builder: it allows to construct regexps interactively with visual
> feedbacks, it even understands the "rx" syntax, for more readable
> regexps.
>

Seconded.  Build your regular expression using the regular-expression
builder, ‘re-builder’.  See (info "(elisp) Regular Expressions").  Note
that ‘re-builder’ comes with a menu that you can use either to carry out
re-builder commands or to learn the re-builder key sequences for
commands.

An approach you can try:

1. Create a text file (or a only a buffer) that contains examples of
strings that you want your regular expression to match.  Start with the
simplest example and build up line-by-line with additional examples to
the most complex example that you can think of.

2. Start re-builder with M-x re-builder.  Enter the simplest regular
expression that should match your simplest example.  Read the Elisp
manual entry above, if necessary, to resolve any misunderstanding if
your regular expression does not match.  Once the simplest regular
expression matches your simplest example, add to your regular expression
in order to match the second example.  The new expression should match
your first and second example before you move to matching your third
example.  And so on.

-- 
The lyf so short, the craft so long to lerne.
- Geoffrey Chaucer, The Parliament of Birds.

Re: Matching labels with buttons

[Stephen Berman]

On Mon, 15 Jul 2024 17:25:42 +0000 Heime <heimeborgia@protonmail.com> wrote:

> On Tuesday, July 16th, 2024 at 4:24 AM, Heime <heimeborgia@protonmail.com> wrote:
>
>> On Tuesday, July 16th, 2024 at 1:42 AM, Stephen Berman
>> stephen.berman@gmx.net wrote:
>>
>> > On Mon, 15 Jul 2024 12:58:05 +0000 Heime heimeborgia@protonmail.com wrote:
>> >
>> > > Sent with Proton Mail secure email.
>> > >
>> > > On Tuesday, July 16th, 2024 at 12:52 AM, Stephen Berman
>> > > stephen.berman@gmx.net wrote:
>> > >
>> > > > On Mon, 15 Jul 2024 12:35:53 +0000 Heime heimeborgia@protonmail.com wrote:
>> > > >
>> > > > > On Monday, July 15th, 2024 at 11:56 PM, Stephen Berman
>> > > > > stephen.berman@gmx.net wrote:
>> > > > >
>> > > > > > On Mon, 15 Jul 2024 11:25:28 +0000 Heime
>> > > > > > heimeborgia@protonmail.com wrote:
>> > > > > >
>> > > > > > > Sent with Proton Mail secure email.
>> > > > > > >
>> > > > > > > On Monday, July 15th, 2024 at 11:17 PM, Heime
>> > > > > > > heimeborgia@protonmail.com wrote:
>> > > > > > >
>> > > > > > > > I want to match cases such as
>> > > > > > > >
>> > > > > > > > Label [-]
>> > > > > > > >
>> > > > > > > > Have constructed the following regexp, but it does not match
>> > > > > > > > the above
>> > > > > > > >
>> > > > > > > > "\\(.\\)\\(\\s-\\[\\-\\]\\s-\\)"
>> > > > > > > >
>> > > > > > > > I aw using
>> > > > > > > >
>> > > > > > > > (when (string-match "\\(.\\)\\(\\s-\\[\\-\\]\\s-\\)" text)
>> > > > > > >
>> > > > > > > In the code I have
>> > > > > > >
>> > > > > > > (if (string-match "\\(\\s-\\[\\-\\]\\s-\\)\\(.*\\)" label) ; [-] LB
>> > > > > > >
>> > > > > > > (progn
>> > > > > > > (setq bt (match-string 1 label))
>> > > > > > > (setq lb (match-string 2 label))
>> > > > > > > (setq result
>> > > > > > > (concat bt (propertize lb 'face '(:foreground "red")))))
>> > > > > > >
>> > > > > > > (when (string-match "\\(.\\)\\(\\s-\\[\\-\\]\\s-*\\)" label) ; LB [-]
>> > > > > > >
>> > > > > > > (setq lb (match-string 1 label))
>> > > > > > > (setq bt (match-string 2 label))
>> > > > > > > (setq result
>> > > > > > > (concat (propertize lb 'face '(:foreground "red")) bt)))
>> > > > > > >
>> > > > > > > Doing some tests with
>> > > > > > >
>> > > > > > > "OFF [-]"
>> > > > > > >
>> > > > > > > keeps matching the first string-match
>> > > > > >
>> > > > > > That's because your regexp isn't anchored, so string-match succeeds if
>> > > > > > it finds a match anywhere in the string passed to it. To avoid this,
>> > > > > > start the regexp with "\\`", which anchors it to the start of the string
>> > > > > > being matched against; see (info "(elisp) Regexp Backslash").
>> > > > > >
>> > > > > > Steve Berman
>> > > > >
>> > > > > I would like to have two regex expressions, one to match only " [-]
>> > > > > LABEL " and
>> > > > > another to match only " LABEL [-] ". With any number of whitespace.
>> > > > >
>> > > > > Can one use "^" ? Or is "\\`" preferred ?
>> > > >
>> > > > If you are always matching against a string, e.g. just using
>> > > > string-match, then IIUC "^" and "\\`" give the same results. If you
>> > > > are matching against test in a buffer, e.g. with re-search-forward,
>> > > > looking-at etc., then they can differ: "^" matches the beginning the
>> > > > the line containing the matched string, "\\\\\\\\\\\\\\\\`" the
>> > > > beginning of the string
>> > > > itself, regardless of where in the line it is (at point-min the results
>> > > > are the same).
>> > > >
>> > > > > And can one use "[[:space:]]" rather
>> > > > > than "\\s-" ? Which is preferred ?
>> > > >
>> > > > IIUC these both give the same results.
>> > > >
>> > > > Steve Berman
>> > >
>> > > Would I introduce \\` before the first grouping
>> > >
>> > > "\\`\\(\\s-\\[\\-\\]\\s-\\)\\(.*\\)"
>> >
>> > Since "\\`" matches the empty string, I don't think it matters whether
>> > it's inside or outside of the group. But since in this case it's
>> > anchoring the entire regexp, it seems conceptually preferable to keep it
>> > outside (in contrast, e.g., to the case where the regexp is a
>> > disjunction and you only want to anchor one of the disjuncts).
>> >
>> > > How would I print \\` in a docstring ?
>> >
>> > You have to escape the "`": \\\\\\\\\\\\\\\\=` (not \\=\\`).
>> >
>> > Steve Berman
>>
>> I also have to handle the case of " LABEL [-] " with a different regex, so I can
>> distinguish between " [-] LABEL " and " LABEL [-] ".
>
> In the latter case I want to match [-] at the end with any trailing spaces.

With your original code amended by anchoring the first regexp as I
suggested, I think it handles both cases you want; at least the brief
tests I tried worked.  If you don't get the results you want, please
show the complete code you're using and examples where it fails.

Steve Berman

Re: Matching labels with buttons

[Heime]

On Tuesday, July 16th, 2024 at 9:20 AM, Stephen Berman <stephen.berman@gmx.net> wrote:

> On Mon, 15 Jul 2024 17:25:42 +0000 Heime heimeborgia@protonmail.com wrote:
> 
> > On Tuesday, July 16th, 2024 at 4:24 AM, Heime heimeborgia@protonmail.com wrote:
> > 
> > > On Tuesday, July 16th, 2024 at 1:42 AM, Stephen Berman
> > > stephen.berman@gmx.net wrote:
> > > 
> > > > On Mon, 15 Jul 2024 12:58:05 +0000 Heime heimeborgia@protonmail.com wrote:
> > > > 
> > > > > Sent with Proton Mail secure email.
> > > > > 
> > > > > On Tuesday, July 16th, 2024 at 12:52 AM, Stephen Berman
> > > > > stephen.berman@gmx.net wrote:
> > > > > 
> > > > > > On Mon, 15 Jul 2024 12:35:53 +0000 Heime heimeborgia@protonmail.com wrote:
> > > > > > 
> > > > > > > On Monday, July 15th, 2024 at 11:56 PM, Stephen Berman
> > > > > > > stephen.berman@gmx.net wrote:
> > > > > > > 
> > > > > > > > On Mon, 15 Jul 2024 11:25:28 +0000 Heime
> > > > > > > > heimeborgia@protonmail.com wrote:
> > > > > > > > 
> > > > > > > > > Sent with Proton Mail secure email.
> > > > > > > > > 
> > > > > > > > > On Monday, July 15th, 2024 at 11:17 PM, Heime
> > > > > > > > > heimeborgia@protonmail.com wrote:
> > > > > > > > > 
> > > > > > > > > > I want to match cases such as
> > > > > > > > > > 
> > > > > > > > > > Label [-]
> > > > > > > > > > 
> > > > > > > > > > Have constructed the following regexp, but it does not match
> > > > > > > > > > the above
> > > > > > > > > > 
> > > > > > > > > > "\\(.\\)\\(\\s-\\[\\-\\]\\s-\\)"
> > > > > > > > > > 
> > > > > > > > > > I aw using
> > > > > > > > > > 
> > > > > > > > > > (when (string-match "\\(.\\)\\(\\s-\\[\\-\\]\\s-\\)" text)
> > > > > > > > > 
> > > > > > > > > In the code I have
> > > > > > > > > 
> > > > > > > > > (if (string-match "\\(\\s-\\[\\-\\]\\s-\\)\\(.*\\)" label) ; [-] LB
> > > > > > > > > 
> > > > > > > > > (progn
> > > > > > > > > (setq bt (match-string 1 label))
> > > > > > > > > (setq lb (match-string 2 label))
> > > > > > > > > (setq result
> > > > > > > > > (concat bt (propertize lb 'face '(:foreground "red")))))
> > > > > > > > > 
> > > > > > > > > (when (string-match "\\(.\\)\\(\\s-\\[\\-\\]\\s-*\\)" label) ; LB [-]
> > > > > > > > > 
> > > > > > > > > (setq lb (match-string 1 label))
> > > > > > > > > (setq bt (match-string 2 label))
> > > > > > > > > (setq result
> > > > > > > > > (concat (propertize lb 'face '(:foreground "red")) bt)))
> > > > > > > > > 
> > > > > > > > > Doing some tests with
> > > > > > > > > 
> > > > > > > > > "OFF [-]"
> > > > > > > > > 
> > > > > > > > > keeps matching the first string-match
> > > > > > > > 
> > > > > > > > That's because your regexp isn't anchored, so string-match succeeds if
> > > > > > > > it finds a match anywhere in the string passed to it. To avoid this,
> > > > > > > > start the regexp with "\\`", which anchors it to the start of the string
> > > > > > > > being matched against; see (info "(elisp) Regexp Backslash").
> > > > > > > > 
> > > > > > > > Steve Berman
> > > > > > > 
> > > > > > > I would like to have two regex expressions, one to match only " [-]
> > > > > > > LABEL " and
> > > > > > > another to match only " LABEL [-] ". With any number of whitespace.
> > > > > > > 
> > > > > > > Can one use "^" ? Or is "\\`" preferred ?
> > > > > > 
> > > > > > If you are always matching against a string, e.g. just using
> > > > > > string-match, then IIUC "^" and "\\`" give the same results. If you are matching against test in a buffer, e.g. with re-search-forward, looking-at etc., then they can differ: "^" matches the beginning the the line containing the matched string, "\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\`" the
> > > > > > beginning of the string
> > > > > > itself, regardless of where in the line it is (at point-min the results
> > > > > > are the same).
> > > > > > 
> > > > > > > And can one use "[[:space:]]" rather
> > > > > > > than "\\s-" ? Which is preferred ?
> > > > > > 
> > > > > > IIUC these both give the same results.
> > > > > > 
> > > > > > Steve Berman
> > > > > 
> > > > > Would I introduce \\` before the first grouping
> > > > > 
> > > > > "\\`\\(\\s-\\[\\-\\]\\s-\\)\\(.*\\)"
> > > > 
> > > > Since "\\`" matches the empty string, I don't think it matters whether
> > > > it's inside or outside of the group. But since in this case it's
> > > > anchoring the entire regexp, it seems conceptually preferable to keep it
> > > > outside (in contrast, e.g., to the case where the regexp is a
> > > > disjunction and you only want to anchor one of the disjuncts).
> > > > 
> > > > > How would I print \\` in a docstring ?
> > > > 
> > > > You have to escape the "`": \\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\=` (not \\=\\`).
> > > > 
> > > > Steve Berman
> > > 
> > > I also have to handle the case of " LABEL [-] " with a different regex, so I can
> > > distinguish between " [-] LABEL " and " LABEL [-] ".
> > 
> > In the latter case I want to match [-] at the end with any trailing spaces.
> 
> 
> With your original code amended by anchoring the first regexp as I
> suggested, I think it handles both cases you want; at least the brief
> tests I tried worked. If you don't get the results you want, please
> show the complete code you're using and examples where it fails.
> 
> Steve Berman

Have used 

"\\`\\(\\s-*\\[\\-\\]\\s-*\\)\\(.*\\)"  for " [-] LABEL "

and

"\\(.*\\)\\(\\s-*\\[\\-\\]\\s-*\\)\\'"  for " LABEL [-] "

Re: Matching labels with buttons

[Stephen Berman]

On Mon, 15 Jul 2024 21:29:38 +0000 Heime <heimeborgia@protonmail.com> wrote:

> On Tuesday, July 16th, 2024 at 9:20 AM, Stephen Berman
> <stephen.berman@gmx.net> wrote:
>
>> On Mon, 15 Jul 2024 17:25:42 +0000 Heime heimeborgia@protonmail.com wrote:
>>
>> > On Tuesday, July 16th, 2024 at 4:24 AM, Heime heimeborgia@protonmail.com wrote:
[...]
>> > > I also have to handle the case of " LABEL [-] " with a different regex,
>> > > so I can
>> > > distinguish between " [-] LABEL " and " LABEL [-] ".
>> >
>> > In the latter case I want to match [-] at the end with any trailing spaces.
>>
>>
>> With your original code amended by anchoring the first regexp as I
>> suggested, I think it handles both cases you want; at least the brief
>> tests I tried worked. If you don't get the results you want, please
>> show the complete code you're using and examples where it fails.
>>
>> Steve Berman
>
> Have used
>
> "\\`\\(\\s-*\\[\\-\\]\\s-*\\)\\(.*\\)"  for " [-] LABEL "
>
> and
>
> "\\(.*\\)\\(\\s-*\\[\\-\\]\\s-*\\)\\'"  for " LABEL [-] "

Since you didn't do what I requested, I've done it.  Evaluate the
following code, which is based on your original code amended as I
suggested (I didn't use "\\'" in the second regexp, but the results are
the same with and without it):

(defun heime-button (label)
  (if (string-match "\\`\\(\\s-*\\[\\-\\]\\s-*\\)\\(.*\\)" label) ; [-] LB
      (progn
        (setq bt (match-string 1 label))
        (setq lb (match-string 2 label))
        (setq result
              (concat bt (propertize lb 'face '(:foreground "red")))))
    (when (string-match "\\(.*\\)\\(\\s-*\\[\\-\\]\\s-*\\)" label) ; LB [-]
      (setq lb (match-string 1 label))
      (setq bt (match-string 2 label))
      (setq result
            (concat (propertize lb 'face '(:foreground "red")) bt))))
  (insert result))

(with-current-buffer (get-buffer-create "*Heime Test*")
  (erase-buffer)
  (heime-button " [-] LABEL ")
  (newline)
  (heime-button " LABEL [-] "))

(switch-to-buffer "*Heime Test*")

What I see in buffer *Heime Test* is this:

 [-] LABEL
 LABEL [-]

where each string "LABEL" is red.  Is this not what you want?

Steve Berman

Re: Matching labels with buttons

[Heime]

On Tuesday, July 16th, 2024 at 9:50 AM, Stephen Berman <stephen.berman@gmx.net> wrote:

> On Mon, 15 Jul 2024 21:29:38 +0000 Heime heimeborgia@protonmail.com wrote:
> 
> > On Tuesday, July 16th, 2024 at 9:20 AM, Stephen Berman
> > stephen.berman@gmx.net wrote:
> > 
> > > On Mon, 15 Jul 2024 17:25:42 +0000 Heime heimeborgia@protonmail.com wrote:
> > > 
> > > > On Tuesday, July 16th, 2024 at 4:24 AM, Heime heimeborgia@protonmail.com wrote:
> 
> [...]
> 
> > > > > I also have to handle the case of " LABEL [-] " with a different regex,
> > > > > so I can
> > > > > distinguish between " [-] LABEL " and " LABEL [-] ".
> > > > 
> > > > In the latter case I want to match [-] at the end with any trailing spaces.
> > > 
> > > With your original code amended by anchoring the first regexp as I
> > > suggested, I think it handles both cases you want; at least the brief
> > > tests I tried worked. If you don't get the results you want, please
> > > show the complete code you're using and examples where it fails.
> > > 
> > > Steve Berman
> > 
> > Have used
> > 
> > "\\`\\(\\s-\\[\\-\\]\\s-\\)\\(.*\\)" for " [-] LABEL "
> > 
> > and
> > 
> > "\\(.\\)\\(\\s-\\[\\-\\]\\s-*\\)\\'" for " LABEL [-] "
> 
> 
> Since you didn't do what I requested, I've done it. Evaluate the
> following code, which is based on your original code amended as I
> suggested (I didn't use "\\'" in the second regexp, but the results are
> the same with and without it):

Was that about showing the code ?  It is basically writing down the regex strings.

> (defun heime-button (label)
> (if (string-match "\\`\\(\\s-\\[\\-\\]\\s-\\)\\(.\\)" label) ; [-] LB
> (progn
> (setq bt (match-string 1 label))
> (setq lb (match-string 2 label))
> (setq result
> (concat bt (propertize lb 'face '(:foreground "red")))))
> (when (string-match "\\(.\\)\\(\\s-\\[\\-\\]\\s-\\)" label) ; LB [-]
> (setq lb (match-string 1 label))
> (setq bt (match-string 2 label))
> (setq result
> (concat (propertize lb 'face '(:foreground "red")) bt))))
> (insert result))
> 
> (with-current-buffer (get-buffer-create "Heime Test")
> (erase-buffer)
> (heime-button " [-] LABEL ")
> (newline)
> (heime-button " LABEL [-] "))
> 
> (switch-to-buffer "Heime Test")
> 
> What I see in buffer Heime Test is this:
> 
> [-] LABEL
> LABEL [-]
> 
> where each string "LABEL" is red. Is this not what you want?
> 
> Steve Berman

Yes it is what I wanted.  Having read the documentation, why don't you apply 
\\' for the second case to match the empty string, but only at the end of string
being matched against ? 

Re: Matching labels with buttons

[Stephen Berman]

On Mon, 15 Jul 2024 22:29:27 +0000 Heime <heimeborgia@protonmail.com> wrote:

> On Tuesday, July 16th, 2024 at 9:50 AM, Stephen Berman
> <stephen.berman@gmx.net> wrote:
>
>> On Mon, 15 Jul 2024 21:29:38 +0000 Heime heimeborgia@protonmail.com wrote:
>>
>> > On Tuesday, July 16th, 2024 at 9:20 AM, Stephen Berman
>> > stephen.berman@gmx.net wrote:
>> >
>> > > On Mon, 15 Jul 2024 17:25:42 +0000 Heime heimeborgia@protonmail.com wrote:
>> > >
>> > > > On Tuesday, July 16th, 2024 at 4:24 AM, Heime
>> > > > heimeborgia@protonmail.com wrote:
>>
>> [...]
>>
>> > > > > I also have to handle the case of " LABEL [-] " with a different regex,
>> > > > > so I can
>> > > > > distinguish between " [-] LABEL " and " LABEL [-] ".
>> > > >
>> > > > In the latter case I want to match [-] at the end with any trailing spaces.
>> > >
>> > > With your original code amended by anchoring the first regexp as I
>> > > suggested, I think it handles both cases you want; at least the brief
>> > > tests I tried worked. If you don't get the results you want, please
>> > > show the complete code you're using and examples where it fails.
>> > >
>> > > Steve Berman
>> >
>> > Have used
>> >
>> > "\\`\\(\\s-\\[\\-\\]\\s-\\)\\(.*\\)" for " [-] LABEL "
>> >
>> > and
>> >
>> > "\\(.\\)\\(\\s-\\[\\-\\]\\s-*\\)\\'" for " LABEL [-] "
>>
>>
>> Since you didn't do what I requested, I've done it. Evaluate the
>> following code, which is based on your original code amended as I
>> suggested (I didn't use "\\'" in the second regexp, but the results are
>> the same with and without it):
>
> Was that about showing the code ?  It is basically writing down the regex strings.

I asked for the complete code, so I don't have to guess what you're doing.

>> (defun heime-button (label)
>> (if (string-match "\\`\\(\\s-\\[\\-\\]\\s-\\)\\(.\\)" label) ; [-] LB
>> (progn
>> (setq bt (match-string 1 label))
>> (setq lb (match-string 2 label))
>> (setq result
>> (concat bt (propertize lb 'face '(:foreground "red")))))
>> (when (string-match "\\(.\\)\\(\\s-\\[\\-\\]\\s-\\)" label) ; LB [-]
>> (setq lb (match-string 1 label))
>> (setq bt (match-string 2 label))
>> (setq result
>> (concat (propertize lb 'face '(:foreground "red")) bt))))
>> (insert result))
>>
>> (with-current-buffer (get-buffer-create "Heime Test")
>> (erase-buffer)
>> (heime-button " [-] LABEL ")
>> (newline)
>> (heime-button " LABEL [-] "))
>>
>> (switch-to-buffer "Heime Test")
>>
>> What I see in buffer Heime Test is this:
>>
>> [-] LABEL
>> LABEL [-]
>>
>> where each string "LABEL" is red. Is this not what you want?
>>
>> Steve Berman
>
> Yes it is what I wanted.  Having read the documentation, why don't you apply
> \\' for the second case to match the empty string, but only at the end of string
> being matched against ?

As I wrote, for the examples you've given, the results are the same with
and without "\\'" at the end of the second regexp, so omitting it
simplifies the regexp.  But if you want to avoid matching a string like
" LABEL [-] some other text", then you should include the end anchor "\\'".

Steve Berman

Re: Matching labels with buttons

[Heime]

On Tuesday, July 16th, 2024 at 10:46 AM, Stephen Berman <stephen.berman@gmx.net> wrote:

> On Mon, 15 Jul 2024 22:29:27 +0000 Heime heimeborgia@protonmail.com wrote:
> 
> > On Tuesday, July 16th, 2024 at 9:50 AM, Stephen Berman
> > stephen.berman@gmx.net wrote:
> > 
> > > On Mon, 15 Jul 2024 21:29:38 +0000 Heime heimeborgia@protonmail.com wrote:
> > > 
> > > > On Tuesday, July 16th, 2024 at 9:20 AM, Stephen Berman
> > > > stephen.berman@gmx.net wrote:
> > > > 
> > > > > On Mon, 15 Jul 2024 17:25:42 +0000 Heime heimeborgia@protonmail.com wrote:
> > > > > 
> > > > > > On Tuesday, July 16th, 2024 at 4:24 AM, Heime
> > > > > > heimeborgia@protonmail.com wrote:
> > > 
> > > [...]
> > > 
> > > > > > > I also have to handle the case of " LABEL [-] " with a different regex,
> > > > > > > so I can
> > > > > > > distinguish between " [-] LABEL " and " LABEL [-] ".
> > > > > > 
> > > > > > In the latter case I want to match [-] at the end with any trailing spaces.
> > > > > 
> > > > > With your original code amended by anchoring the first regexp as I
> > > > > suggested, I think it handles both cases you want; at least the brief
> > > > > tests I tried worked. If you don't get the results you want, please
> > > > > show the complete code you're using and examples where it fails.
> > > > > 
> > > > > Steve Berman
> > > > 
> > > > Have used
> > > > 
> > > > "\\`\\(\\s-\\[\\-\\]\\s-\\)\\(.*\\)" for " [-] LABEL "
> > > > 
> > > > and
> > > > 
> > > > "\\(.\\)\\(\\s-\\[\\-\\]\\s-*\\)\\'" for " LABEL [-] "
> > > 
> > > Since you didn't do what I requested, I've done it. Evaluate the
> > > following code, which is based on your original code amended as I
> > > suggested (I didn't use "\\'" in the second regexp, but the results are
> > > the same with and without it):
> > 
> > Was that about showing the code ? It is basically writing down the regex strings.
> 
> 
> I asked for the complete code, so I don't have to guess what you're doing.
> 
> > > (defun heime-button (label)
> > > (if (string-match "\\`\\(\\s-\\[\\-\\]\\s-\\)\\(.\\)" label) ; [-] LB
> > > (progn
> > > (setq bt (match-string 1 label))
> > > (setq lb (match-string 2 label))
> > > (setq result
> > > (concat bt (propertize lb 'face '(:foreground "red")))))
> > > (when (string-match "\\(.\\)\\(\\s-\\[\\-\\]\\s-\\)" label) ; LB [-]
> > > (setq lb (match-string 1 label))
> > > (setq bt (match-string 2 label))
> > > (setq result
> > > (concat (propertize lb 'face '(:foreground "red")) bt))))
> > > (insert result))
> > > 
> > > (with-current-buffer (get-buffer-create "Heime Test")
> > > (erase-buffer)
> > > (heime-button " [-] LABEL ")
> > > (newline)
> > > (heime-button " LABEL [-] "))
> > > 
> > > (switch-to-buffer "Heime Test")
> > > 
> > > What I see in buffer Heime Test is this:
> > > 
> > > [-] LABEL
> > > LABEL [-]
> > > 
> > > where each string "LABEL" is red. Is this not what you want?
> > > 
> > > Steve Berman
> > 
> > Yes it is what I wanted. Having read the documentation, why don't you apply
> > \\' for the second case to match the empty string, but only at the end of string
> > being matched against ?
> 
> 
> As I wrote, for the examples you've given, the results are the same with
> and without "\\'" at the end of the second regexp, so omitting it
> simplifies the regexp. But if you want to avoid matching a string like
> " LABEL [-] some other text", then you should include the end anchor "\\'".
> 
> Steve Berman

Yes, I want to avoid matching " LABEL [-] some other text".