Re: regexp case sensitivity bug

Re: regexp case sensitivity bug

[Richard Stallman]

    In Emacs 21.1.1, when I do isearch-forward-regexp with input "\bP",
    Emacs matches 'p's case insensitively.

Does this patch fix it?

*** isearch.el.~1.215.~	Sun Nov 10 13:13:37 2002
--- isearch.el	Mon Dec  9 11:20:37 2002
***************
*** 1871,1877 ****
  	(if (and regexp-flag (eq char ?\\))
  	    (setq quote-flag (not quote-flag))
  	  (if (and (not quote-flag) (not (eq char (downcase char))))
! 	      (setq found t))))
        (setq i (1+ i)))
      (not found)))
  
--- 1871,1878 ----
  	(if (and regexp-flag (eq char ?\\))
  	    (setq quote-flag (not quote-flag))
  	  (if (and (not quote-flag) (not (eq char (downcase char))))
! 	      (setq found t))
! 	  (setq quote-flag nil)))
        (setq i (1+ i)))
      (not found)))

Re: regexp case sensitivity bug

[Dean Herington]

Richard Stallman wrote:

>     In Emacs 21.1.1, when I do isearch-forward-regexp with input "\bP",
>     Emacs matches 'p's case insensitively.
>
> Does this patch fix it?
>
> *** isearch.el.~1.215.~ Sun Nov 10 13:13:37 2002
> --- isearch.el  Mon Dec  9 11:20:37 2002
> ***************
> *** 1871,1877 ****
>         (if (and regexp-flag (eq char ?\\))
>             (setq quote-flag (not quote-flag))
>           (if (and (not quote-flag) (not (eq char (downcase char))))
> !             (setq found t))))
>         (setq i (1+ i)))
>       (not found)))
>
> --- 1871,1878 ----
>         (if (and regexp-flag (eq char ?\\))
>             (setq quote-flag (not quote-flag))
>           (if (and (not quote-flag) (not (eq char (downcase char))))
> !             (setq found t))
> !         (setq quote-flag nil)))
>         (setq i (1+ i)))
>       (not found)))

That patch fixes the bug I saw.

How about the following, which I find simpler?

(defun isearch-no-upper-case-p (string regexp-flag)
  "Return t if there are no upper case chars in STRING.
If REGEXP-FLAG is non-nil, disregard letters quoted by `\\'
since they have special meaning in a regexp."
  (let ((i 0) (len (length string)) found)
    (while (and (not found) (< i len))
      (let ((char (aref string i)))
        (if (and regexp-flag (eq char ?\\))
            (setq i (1+ i))
          (if (not (eq char (downcase char)))
              (setq found t))))
      (setq i (1+ i)))
    (not found)))

Re: regexp case sensitivity bug

[Kim F. Storm]

Dean Herington <heringto@cs.unc.edu> writes:

> Richard Stallman wrote:
> 
> >     In Emacs 21.1.1, when I do isearch-forward-regexp with input "\bP",
> >     Emacs matches 'p's case insensitively.
> >
> > Does this patch fix it?
> >
> > *** isearch.el.~1.215.~ Sun Nov 10 13:13:37 2002
> > --- isearch.el  Mon Dec  9 11:20:37 2002
> > ***************
> > *** 1871,1877 ****
> >         (if (and regexp-flag (eq char ?\\))
> >             (setq quote-flag (not quote-flag))
> >           (if (and (not quote-flag) (not (eq char (downcase char))))
> > !             (setq found t))))
> >         (setq i (1+ i)))
> >       (not found)))
> >
> > --- 1871,1878 ----
> >         (if (and regexp-flag (eq char ?\\))
> >             (setq quote-flag (not quote-flag))
> >           (if (and (not quote-flag) (not (eq char (downcase char))))
> > !             (setq found t))
> > !         (setq quote-flag nil)))
> >         (setq i (1+ i)))
> >       (not found)))
> 
> That patch fixes the bug I saw.
> 
> How about the following, which I find simpler?
> 
> (defun isearch-no-upper-case-p (string regexp-flag)
>   "Return t if there are no upper case chars in STRING.
> If REGEXP-FLAG is non-nil, disregard letters quoted by `\\'
> since they have special meaning in a regexp."
>   (let ((i 0) (len (length string)) found)
>     (while (and (not found) (< i len))
>       (let ((char (aref string i)))
>         (if (and regexp-flag (eq char ?\\))
>             (setq i (1+ i))
>           (if (not (eq char (downcase char)))
>               (setq found t))))
>       (setq i (1+ i)))
>     (not found)))
> 

Or we can use a completely different approach:

(defun isearch-no-upper-case-p (string regexp-flag)
  "..."
  (let ((case-fold-search nil))
    (save-match-data
      (null (string-match 
              (if regexp-flag "\\(^\\|[^\\]\\)[[:upper:]]" "[[:upper:]]")
              string)))))


-- 
Kim F. Storm <storm@cua.dk> http://www.cua.dk

Re: regexp case sensitivity bug

[Andreas Schwab]

storm@cua.dk (Kim F. Storm) writes:

|> Or we can use a completely different approach:
|> 
|> (defun isearch-no-upper-case-p (string regexp-flag)
|>   "..."
|>   (let ((case-fold-search nil))
|>     (save-match-data
|>       (null (string-match 
|>               (if regexp-flag "\\(^\\|[^\\]\\)[[:upper:]]" "[[:upper:]]")
|>               string)))))

That needs to check whether there is an even number of \ before the
letter, because only then the letter is not part of a special regex
matcher.

Andreas.

-- 
Andreas Schwab, SuSE Labs, schwab@suse.de
SuSE Linux AG, Deutschherrnstr. 15-19, D-90429 Nürnberg
Key fingerprint = 58CA 54C7 6D53 942B 1756  01D3 44D5 214B 8276 4ED5
"And now for something completely different."

Re: regexp case sensitivity bug

[Richard Stallman]

    Or we can use a completely different approach:

    (defun isearch-no-upper-case-p (string regexp-flag)
      "..."
      (let ((case-fold-search nil))
	(save-match-data
	  (null (string-match 
		  (if regexp-flag "\\(^\\|[^\\]\\)[[:upper:]]" "[[:upper:]]")
		  string)))))

That's not correct in the case where there are two \'s in a row
(or any even number).