(U+6215): Apply new conventions for glyph granularity.

[chise/xemacs-chise.git.1] / lisp / isearch-mode.el

diff --git a/lisp/isearch-mode.el b/lisp/isearch-mode.el
index f42dc35..4ec4f66 100644 (file)
--- a/lisp/isearch-mode.el
+++ b/lisp/isearch-mode.el
@@ -180,8 +180,8 @@ an overlay having an `invisible' property and that overlay has a property
 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
@@ -238,6 +238,13 @@ Default nil means edit the string from the search ring first."
     ;; 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)
@@ -674,7 +681,7 @@ is treated as a regexp.  See \\[isearch-forward] for more info."
 (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
@@ -866,7 +873,7 @@ Use `isearch-exit' to quit without signaling."
       ;; 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.
@@ -1210,7 +1217,8 @@ Obsolete."
       (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
@@ -1721,18 +1729,18 @@ If there is no completion possible, say so and continue searching."
   (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)
@@ -1746,7 +1754,7 @@ Before that, if search-invisible is `open', unhide the extents with an
                 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
@@ -1765,9 +1773,9 @@ Before that, if search-invisible is `open', unhide the extents with an
   (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))
@@ -1776,7 +1784,7 @@ Before that, if search-invisible is `open', unhide the extents with an
     ;; 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))