This variable makes a difference when `search-invisible' is set to `open'.
It means that after search makes some invisible text visible
to show the match, it makes the text invisible again when the match moves.
-Ordinarily the text becomes invisible again at the end of the search."
- :type 'boolean
+Ordinarily the text becomes invisible again at the end of the search."
+ :type 'boolean
:group 'isearch)
(defvar isearch-mode-hook nil
;; then it would terminate the search and be executed without this.
(let ((i 32)
(str (make-string 1 0)))
+ ;; #### GR (and C1 too, in KOI8 and Windows-land at least) should
+ ;; be printing. But that breaks on high-bit-is-meta brain-damage.
+ ;; At least in no-mule, the high bit is treated as a meta bit.
+ ;; With GR treated as printable in isearch, any meta command
+ ;; events will not be executed because they are treated as GR
+ ;; characters by isearch, but then there is an error because
+ ;; event-to-character (properly) returns nil.
(while (< i 127)
(aset str 0 i)
(define-key map str 'isearch-printing-char)
isearch-opoint (point)
search-ring-yank-pointer nil
regexp-search-ring-yank-pointer nil
- isearch-opened-extents nil
+ isearch-unhidden-extents nil
isearch-window-configuration (current-window-configuration)
;; #### What we really need is a buffer-local
(defun isearch-update-ring (string &optional regexp)
"Add STRING to the beginning of the search ring.
REGEXP says which ring to use."
- (if regexp
+ (if regexp
(if (or (null regexp-search-ring)
(not (string= string (car regexp-search-ring))))
(progn
;; and really do quit.
(progn (goto-char isearch-opoint)
(setq isearch-success nil)
- (isearch-done t) ; exit isearch
+ (isearch-done) ; exit and push target string
(signal 'quit '(isearch))) ; and pass on quit signal
;; If search is failing, or has an incomplete regexp,
;; rub out until it is once more successful.
(set yank-pointer-name
(setq yank-pointer
(mod (+ (or yank-pointer 0)
- (if advance -1 1))
+ ;; XEmacs change
+ (if advance -1 (if yank-pointer 1 0)))
length)))
(setq isearch-string (nth yank-pointer ring)
isearch-message (mapconcat 'isearch-text-char-description
(defun isearch-top-state ()
(let ((cmd (car isearch-cmds)))
;; #### Grr, this is so error-prone. If you add something to
- ;; isearch-push-state, don't forget to update this. I thout I'd
+ ;; isearch-push-state, don't forget to update this. I thought I'd
;; make a list of variables, and just do (mapcar* #'set vars
;; values), but the (point) thing would spoil it, leaving to more
;; complication.
(defun isearch-make-extent (begin end)
(let ((x (make-extent begin end (current-buffer))))
- ;; make the isearch extent always take prescedence over any mouse-
+ ;; make the isearch extent always take precedence over any mouse-
;; highlighted extents we may be passing through, since isearch, being
;; modal, is more interesting (there's nothing they could do with a
;; mouse-highlighted extent while in the midst of a search anyway).
(put extent 'invisible nil)
(put extent 'intangible nil))
-(defun isearch-range-invisible (beg end)
- "Return t if all the text from BEG to END is invisible.
+(defun isearch-range-invisible (start end)
+ "Return t if all the text from START to END is invisible.
Before that, if search-invisible is `open', unhide the extents with an
`isearch-open-invisible' property."
;; isearch-search uses this to skip the extents that are invisible,
;; but don't have `isearch-open-invisible' set. It is unclear
- ;; what's supposed to happen if only a part of [BEG, END) overlaps
+ ;; what's supposed to happen if only a part of [START, END) overlaps
;; the extent.
(let (to-be-unhidden)
(if (map-extents
(lambda (extent ignored)
- (if (and (<= (extent-start-position extent) beg)
+ (if (and (<= (extent-start-position extent) start)
(>= (extent-end-position extent) end))
;; All of the region is covered by the extent.
(if (and (eq search-invisible 'open)
t)
;; Else, keep looking.
nil))
- nil beg end nil 'all-extents-closed 'invisible)
+ nil start end nil 'all-extents-closed 'invisible)
;; The whole match must be skipped. Signal it by returning t
;; to the caller.
t
(remprop extent 'isearch-intangible))
;; FSF calls this function `isearch-clean-overlays'.
-(defun isearch-restore-invisible-extents (beg end)
+(defun isearch-restore-invisible-extents (start end)
(cond
- ((null beg)
+ ((null start)
;; Delete all -- this is called at the end of isearch.
(mapc #'isearch-restore-extent isearch-unhidden-extents)
(setq isearch-unhidden-extents nil))
;; restored to their hidden state.
(setq isearch-unhidden-extents
(delete-if (lambda (extent)
- (unless (extent-in-region-p extent beg end
+ (unless (extent-in-region-p extent start end
'all-extents-closed)
(isearch-restore-extent extent)
t))
;; buffer.
(mapc #'delete-extent isearch-highlight-extents)
(setq isearch-highlight-extents nil)
- (setq isearch-highlight-all-start nil
- isearch-window-end nil
+ (setq isearch-window-end nil
isearch-highlight-last-string nil))
(defun isearch-highlight-all-update ()
;; It would be nice if we didn't have to do this; however,
;; window-start doesn't support a GUARANTEE flag, so we must
- ;; force redisplay to get the correct valye for start and end
+ ;; force redisplay to get the correct value for start and end
;; of window.
(sit-for 0)
projects / chise / xemacs-chise.git.1 / blobdiff