Re: On refining regexp by adding exceptions systematically

[Alan Mackenzie]

gnuist <gnuist007@hotmail.com> wrote on 3 Oct 2002 05:27:55 -0700:
> Here is regular expression in emacs lisp that initially seems to work
> for the job:

> [A-Z][A-Z][A-Z][0-9]+

> After running it on a number of uses, I find that there is an exception
> to it, namely PJP89898.   Rather than rehashing the code after having
> forgotten it and reworking my regexp expression (every time I find an
> exception) in some convoluted way, is there a systematic way to add an
> exception or a series of exceptions to the regexp? I am sure that there
> are a number of ways to do this and each has its merits.

Regular expressions are designed to find string expressions which are,
well, regular.  If you really want to add in an exception like you've
got, you're going to end up with something horrible.  It can be done, but
like rowing the Atlantic, why bother?

> I am using this regexp in two ways in a different program.  In the
> first one (looking-at regexp) so that it assumes that cursor is on it.

(and (looking-at regexp) (not (looking-at "PJP89898")))

> In the second one (search-forward-regexp regexp) in a narrowed region
> so that one is trying to find if there is one.  It seems to me that it
> is a little tricky to do this. Perhaps an example code would help with
> exception implemented for searching on a line.

(let (found (startpos (point)))
  (while (and (setq found (search-forward-regexp regexp nil t))
              (save-excursion
                (goto-char (match-data 0))
                (looking-at "PJP89898"))))
  (if found (point)
   (goto-char startpos) nil))

I haven't tested either snippet.

Hope this helps.

By the way, it would be helpful if you could set a Followup-To: header,
so that people know what your "home" group is.  It also makes you look
less like a troll.

> Thanks a lot!
> gnuist007

-- 
Alan Mackenzie (Munich, Germany)
Email: aacm@muuc.dee; to decode, wherever there is a repeated letter
(like "aa"), remove half of them (leaving, say, "a").