Merge from emacs--devo--0

Patches applied:

 * emacs--devo--0  (patch 662-669)

   - Update from CVS
   - Fix read-only prompt problem in isearch
   - Merge from gnus--rel--5.10

 * gnus--rel--5.10  (patch 207-208)

   - Merge from emacs--devo--0
   - Update from CVS

Revision: emacs@sv.gnu.org/emacs--unicode--0--patch-184

8 files changed, 253 insertions, 35 deletions

diff --git a/lisp/progmodes/cc-engine.el b/lisp/progmodes/cc-engine.el
index f69382c9d70..a901ee07454 100644
--- a/lisp/progmodes/cc-engine.el
+++ b/lisp/progmodes/cc-engine.el
@@ -1912,6 +1912,26 @@ comment at the start of cc-engine.el for more info."
       )))
 
 
+;; Other whitespace tools
+(defun c-partial-ws-p (beg end)
+  ;; Is the region (beg end) WS, and is there WS (or BOB/EOB) next to the
+  ;; region?  This is a "heuristic" function.  .....
+  ;; 
+  ;; The motivation for the second bit is to check whether the removal of this
+  ;; space is to check whether removing this region would coalesce two
+  ;; symbols.
+  ;;
+  ;; FIXME!!!  This function doesn't check virtual semicolons in any way.  Be
+  ;; careful about using this function for, e.g. AWK.  (2007/3/7)
+  (save-excursion
+    (let ((end+1 (min (1+ end) (point-max))))
+      (or (progn (goto-char (max (point-min) (1- beg)))
+                 (c-skip-ws-forward end)
+                 (eq (point) end))
+          (progn (goto-char beg)
+                 (c-skip-ws-forward end+1)
+                 (eq (point) end+1))))))
+
 ;; A system for finding noteworthy parens before the point.
 
 (defvar c-state-cache nil)
@@ -2491,24 +2511,25 @@ comment at the start of cc-engine.el for more info."
   ;; Move to the beginning of the current token.  Do not move if not
   ;; in the middle of one.  BACK-LIMIT may be used to bound the
   ;; backward search; if given it's assumed to be at the boundary
-  ;; between two tokens.
+  ;; between two tokens.  Return non-nil if the point is move, nil
+  ;; otherwise.
   ;;
   ;; This function might do hidden buffer changes.
-  (if (looking-at "\\w\\|\\s_")
-      (skip-syntax-backward "w_" back-limit)
     (let ((start (point)))
-      (when (< (skip-syntax-backward ".()" back-limit) 0)
-        (while (let ((pos (or (and (looking-at c-nonsymbol-token-regexp)
-                                   (match-end 0))
-                              ;; `c-nonsymbol-token-regexp' should always match
-                              ;; since we've skipped backward over punctuator
-                              ;; or paren syntax, but consume one char in case
-                              ;; it doesn't so that we don't leave point before
-                              ;; some earlier incorrect token.
-                              (1+ (point)))))
-                 (if (<= pos start)
-                     (goto-char pos))
-                 (< pos start)))))))
+      (if (looking-at "\\w\\|\\s_")
+          (skip-syntax-backward "w_" back-limit)
+        (when (< (skip-syntax-backward ".()" back-limit) 0)
+          (while (let ((pos (or (and (looking-at c-nonsymbol-token-regexp)
+                                     (match-end 0))
+                                ;; `c-nonsymbol-token-regexp' should always match
+                                ;; since we've skipped backward over punctuator
+                                ;; or paren syntax, but consume one char in case
+                                ;; it doesn't so that we don't leave point before
+                                ;; some earlier incorrect token.
+                                (1+ (point)))))
+                   (if (<= pos start)
+                       (goto-char pos))))))
+      (< (point) start)))
 
 (defun c-end-of-current-token (&optional back-limit)
   ;; Move to the end of the current token.  Do not move if not in the
@@ -3957,6 +3978,9 @@ comment at the start of cc-engine.el for more info."
 ;; file, and we only use this as a last resort in ambiguous cases (see
 ;; `c-forward-decl-or-cast-1').
 ;;
+;; Not every type need be in this cache.  However, things which have
+;; ceased to be types must be removed from it.
+;;
 ;; Template types in C++ are added here too but with the template
 ;; arglist replaced with "<>" in references or "<" for the one in the
 ;; primary type.  E.g. the type "Foo<A,B>::Bar<C>" is stored as
@@ -3990,6 +4014,10 @@ comment at the start of cc-engine.el for more info."
       (unintern (substring type 0 -1) c-found-types)
       (intern type c-found-types))))
 
+(defun c-unfind-type (name)
+  ;; Remove the "NAME" from c-found-types, if present.
+  (unintern name c-found-types))
+
 (defsubst c-check-type (from to)
   ;; Return non-nil if the given region contains a type in
   ;; `c-found-types'.
@@ -4008,6 +4036,48 @@ comment at the start of cc-engine.el for more info."
               c-found-types)
     (sort type-list 'string-lessp)))
 
+(defun c-trim-found-types (beg end old-len)
+  ;; An after change function which, in conjunction with the info in
+  ;; c-maybe-stale-found-type (set in c-before-change), removes a type
+  ;; from `c-found-types', should this type have become stale.  For
+  ;; example, this happens to "foo" when "foo \n bar();" becomes
+  ;; "foo(); \n bar();".  Such stale types, if not removed, foul up
+  ;; the fontification.
+  ;; 
+  ;; Have we, perhaps, added non-ws characters to the front/back of a found
+  ;; type?
+  (when (> end beg)
+    (save-excursion
+      (when (< end (point-max))
+        (goto-char end)
+        (if (and (c-beginning-of-current-token) ; only moves when we started in the middle
+                 (progn (goto-char end)
+                        (c-end-of-current-token)))
+            (c-unfind-type (buffer-substring-no-properties
+                            end (point)))))
+      (when (> beg (point-min))
+        (goto-char beg)
+        (if (and (c-end-of-current-token) ; only moves when we started in the middle
+                 (progn (goto-char beg)
+                        (c-beginning-of-current-token)))
+            (c-unfind-type (buffer-substring-no-properties
+                            (point) beg))))))
+            
+  (if c-maybe-stale-found-type ; e.g. (c-decl-id-start "foo" 97 107 " (* ooka) " "o")
+      (cond
+       ;; Changing the amount of (already existing) whitespace - don't do anything.
+       ((and (c-partial-ws-p beg end)
+             (or (= beg end)            ; removal of WS
+                 ; (string-match "\\s *\\'" (nth 5 c-maybe-stale-found-type))
+                 (string-match "^[ \t\n\r\f\v]*$" (nth 5 c-maybe-stale-found-type)))))
+
+       ;; The syntactic relationship which defined a "found type" has been
+       ;; destroyed.
+       ((eq (car c-maybe-stale-found-type) 'c-decl-id-start)
+        (c-unfind-type (cadr c-maybe-stale-found-type)))
+;;        ((eq (car c-maybe-stale-found-type) 'c-decl-type-start)  FIXME!!!
+        )))
+
 
 ;; Handling of small scale constructs like types and names.
 
diff --git a/lisp/progmodes/cc-mode.el b/lisp/progmodes/cc-mode.el
index e2891bde98d..1407b497305 100644
--- a/lisp/progmodes/cc-mode.el
+++ b/lisp/progmodes/cc-mode.el
@@ -412,8 +412,143 @@ preferably use the `c-mode-menu' language constant directly."
 ;; temporary changes in some font lock support modes, causing extra
 ;; unnecessary work and font lock glitches due to interactions between
 ;; various text properties.
-
-(defun c-after-change (beg end len)
+;; 
+;; (2007-02-12): The macro `combine-after-change-calls' ISN'T used any
+;; more.
+
+(defun c-unfind-enclosing-token (pos)
+  ;; If POS is wholly inside a token, remove that id from
+  ;; `c-found-types', should it be present.  Return t if we were in an
+  ;; id, else nil.
+  (save-excursion
+    (let ((tok-beg (progn (goto-char pos)
+                          (and (c-beginning-of-current-token) (point))))
+          (tok-end (progn (goto-char pos)
+                          (and (c-end-of-current-token) (point)))))
+      (when (and tok-beg tok-end)
+        (c-unfind-type (buffer-substring-no-properties tok-beg tok-end))
+        t))))
+
+(defun c-unfind-coalesced-tokens (beg end)
+  ;; unless the non-empty region (beg end) is entirely WS and there's at
+  ;; least one character of WS just before or after this region, remove
+  ;; the tokens which touch the region from `c-found-types' should they
+  ;; be present.
+  (or (c-partial-ws-p beg end)
+      (save-excursion
+        (progn
+          (goto-char beg)
+          (or (eq beg (point-min))
+              (c-skip-ws-backward (1- beg))
+              (/= (point) beg)
+              (= (c-backward-token-2) 1)
+              (c-unfind-type (buffer-substring-no-properties
+                              (point) beg)))
+          (goto-char end)
+          (or (eq end (point-max))
+              (c-skip-ws-forward (1+ end))
+              (/= (point) end)
+              (progn (forward-char) (c-end-of-current-token) nil)
+              (c-unfind-type (buffer-substring-no-properties
+                              end (point))))))))
+
+;; c-maybe-stale-found-type records a place near the region being
+;; changed where an element of `found-types' might become stale.  It 
+;; is set in c-before-change and is either nil, or has the form:
+;;
+;;   (c-decl-id-start "foo" 97 107  " (* ooka) " "o"), where
+;;   
+;; o - `c-decl-id-start' is the c-type text property value at buffer
+;;   pos 96.
+;; 
+;; o - 97 107 is the region potentially containing the stale type -
+;;   this is delimited by a non-nil c-type text property at 96 and
+;;   either another one or a ";", "{", or "}" at 107.
+;; 
+;; o - " (* ooka) " is the (before change) buffer portion containing
+;;   the suspect type (here "ooka").
+;;
+;; o - "o" is the buffer contents which is about to be deleted.  This
+;;   would be the empty string for an insertion.
+(defvar c-maybe-stale-found-type nil)
+(make-variable-buffer-local 'c-maybe-stale-found-type)
+
+(defun c-before-change (beg end)
+  ;; Function to be put on `before-change-function'.  Currently
+  ;; (2007-02) it is used only to remove stale entries from the
+  ;; `c-found-types' cache, and to record entries which a
+  ;; `c-after-change' function might confirm as stale.
+  ;; 
+  ;; Note that this function must be FAST rather than accurate.  Note
+  ;; also that it only has any effect when font locking is enabled.
+  ;; We exploit this by checking for font-lock-*-face instead of doing
+  ;; rigourous syntactic analysis.
+
+  ;; If either change boundary is wholly inside an identifier, delete
+  ;; it/them from the cache.  Don't worry about being inside a string
+  ;; or a comment - "wrongly" removing a symbol from `c-found-types'
+  ;; isn't critical.
+  (setq c-maybe-stale-found-type nil)
+  (save-restriction
+    (save-match-data
+      (widen)
+      (save-excursion
+        ;; Are we inserting/deleting stuff in the middle of an identifier?
+        (c-unfind-enclosing-token beg)
+        (c-unfind-enclosing-token end)
+        ;; Are we coalescing two tokens together, e.g. "fo o" -> "foo"?
+        (when (< beg end)
+          (c-unfind-coalesced-tokens beg end))
+        ;; Are we (potentially) disrupting the syntactic context which
+        ;; makes a type a type?  E.g. by inserting stuff after "foo" in
+        ;; "foo bar;", or before "foo" in "typedef foo *bar;"?
+        ;;
+        ;; We search for appropriate c-type properties "near" the change.
+        ;; First, find an appropriate boundary for this property search.
+        (let (lim
+              type type-pos
+              marked-id term-pos
+              (end1
+               (if (eq (get-text-property end 'face) 'font-lock-comment-face)
+                   (previous-single-property-change end 'face)
+                 end)))
+          (when (>= end1 beg) ; Don't hassle about changes entirely in comments.
+            ;; Find a limit for the search for a `c-type' property
+            (while
+                (and (/= (skip-chars-backward "^;{}") 0)
+                     (> (point) (point-min))
+                     (memq (c-get-char-property (1- (point)) 'face)
+                           '(font-lock-comment-face font-lock-string-face))))
+            (setq lim (max (point-min) (1- (point))))
+
+            ;; Look for the latest `c-type' property before end1
+            (when (and (> end1 1)
+                       (setq type-pos
+                             (if (get-text-property (1- end1) 'c-type)
+                                 end1
+                               (previous-single-property-change end1 'c-type nil lim))))
+              (setq type (get-text-property (max (1- type-pos) lim) 'c-type))
+
+              (when (memq type '(c-decl-id-start c-decl-type-start))
+                ;; Get the identifier, if any, that the property is on.
+                (goto-char (1- type-pos))
+                (setq marked-id
+                      (when (looking-at "\\(\\sw\\|\\s_\\)")
+                        (c-beginning-of-current-token)
+                        (buffer-substring-no-properties (point) type-pos)))
+
+                (goto-char end1)
+                (skip-chars-forward "^;{}") ; FIXME!!!  loop for comment, maybe
+                (setq lim (point))
+                (setq term-pos
+                      (or (next-single-property-change end 'c-type nil lim) lim))
+                (setq c-maybe-stale-found-type
+                      (list type marked-id
+                            type-pos term-pos
+                            (buffer-substring-no-properties type-pos term-pos)
+                            (buffer-substring-no-properties beg end)))))))))))
+
+(defun c-after-change (beg end old-len)
   ;; Function put on `after-change-functions' to adjust various caches
   ;; etc.  Prefer speed to finesse here, since there will be an order
   ;; of magnitude more calls to this function than any of the
@@ -441,6 +576,7 @@ preferably use the `c-mode-menu' language constant directly."
           (when (> beg end)
             (setq beg end)))
 
+        (c-trim-found-types beg end old-len) ; maybe we don't need all of these.
         (c-invalidate-sws-region-after beg end)
         (c-invalidate-state-cache beg)
         (c-invalidate-find-decl-cache beg)
@@ -577,6 +713,8 @@ that requires a literal mode spec at compile time."
 
   ;; Install the functions that ensure that various internal caches
   ;; don't become invalid due to buffer changes.
+  (make-local-hook 'before-change-functions)
+  (add-hook 'before-change-functions 'c-before-change nil t)
   (make-local-hook 'after-change-functions)
   (add-hook 'after-change-functions 'c-after-change nil t))
 
diff --git a/lisp/progmodes/cperl-mode.el b/lisp/progmodes/cperl-mode.el
index 29f4cc372d3..0b8287503f8 100644
--- a/lisp/progmodes/cperl-mode.el
+++ b/lisp/progmodes/cperl-mode.el
@@ -1795,8 +1795,8 @@ or as help on variables `cperl-tips', `cperl-problems',
         ((boundp 'compilation-error-regexp-alist);; xmeacs 19.x
          (make-local-variable 'compilation-error-regexp-alist)
          (set 'compilation-error-regexp-alist
-               (cons cperl-compilation-error-regexp-alist
-                     (symbol-value 'compilation-error-regexp-alist)))))
+               (append cperl-compilation-error-regexp-alist
+                       (symbol-value 'compilation-error-regexp-alist)))))
   (make-local-variable 'font-lock-defaults)
   (setq font-lock-defaults
         (cond
diff --git a/lisp/progmodes/grep.el b/lisp/progmodes/grep.el
index a0dd83fb974..fe2bbdec14e 100644
--- a/lisp/progmodes/grep.el
+++ b/lisp/progmodes/grep.el
@@ -157,7 +157,8 @@ The following place holders should be present in the string:
   :type 'alist
   :group 'grep)
 
-(defcustom grep-find-ignored-directories '("CVS" ".svn" "{arch}" ".hg" "_darcs")
+(defcustom grep-find-ignored-directories '("CVS" ".svn" "{arch}" ".hg" "_darcs"
+                                           ".git" ".bzr")
   "*List of names of sub-directories which `rgrep' shall not recurse into."
   :type '(repeat string)
   :group 'grep)
diff --git a/lisp/progmodes/gud.el b/lisp/progmodes/gud.el
index 1662af1c924..8db7c28219e 100644
--- a/lisp/progmodes/gud.el
+++ b/lisp/progmodes/gud.el
@@ -690,7 +690,10 @@ session."
            (buffer-name gud-comint-buffer)
            (get-buffer-process gud-comint-buffer)
            (with-current-buffer gud-comint-buffer (eq gud-minor-mode 'gdba)))
-      (error "Multiple debugging requires restarting in text command mode"))
+      (let ((same-window-regexps))
+        (display-buffer gud-comint-buffer)
+        (error
+         "Multiple debugging requires restarting in text command mode")))
 
   (gud-common-init command-line nil 'gud-gdb-marker-filter)
   (set (make-local-variable 'gud-minor-mode) 'gdb)
diff --git a/lisp/progmodes/hideshow.el b/lisp/progmodes/hideshow.el
index 35ab0362613..3bc1c55cc7d 100644
--- a/lisp/progmodes/hideshow.el
+++ b/lisp/progmodes/hideshow.el
@@ -906,11 +906,18 @@ Key bindings:
   (if hs-minor-mode
       (progn
         (hs-grok-mode-type)
+        ;; Turn off this mode if we change major modes.
+        (add-hook 'change-major-mode-hook
+                  (lambda () (hs-minor-mode -1))
+                  nil t)
         (easy-menu-add hs-minor-mode-menu)
         (set (make-local-variable 'line-move-ignore-invisible) t)
         (add-to-invisibility-spec '(hs . t)))
     (easy-menu-remove hs-minor-mode-menu)
-    (remove-from-invisibility-spec '(hs . t)))
+    (remove-from-invisibility-spec '(hs . t))
+    ;; hs-show-all does nothing unless h-m-m is non-nil.
+    (let ((hs-minor-mode t))
+      (hs-show-all)))
   (run-hooks 'hs-minor-mode-hook))
 
 ;;---------------------------------------------------------------------------
@@ -945,7 +952,7 @@ Key bindings:
 (add-to-list 'minor-mode-map-alist (cons 'hs-minor-mode hs-minor-mode-map))
 (add-to-list 'minor-mode-alist '(hs-minor-mode " hs") t)
 
-;; make some variables permanently buffer-local
+;; make some variables buffer-local
 (dolist (var '(hs-minor-mode
                hs-c-start-regexp
                hs-block-start-regexp
@@ -953,8 +960,7 @@ Key bindings:
                hs-block-end-regexp
                hs-forward-sexp-func
                hs-adjust-block-beginning))
-  (make-variable-buffer-local var)
-  (put var 'permanent-local t))
+  (make-variable-buffer-local var))
 
 ;;---------------------------------------------------------------------------
 ;; that's it
diff --git a/lisp/progmodes/idlw-help.el b/lisp/progmodes/idlw-help.el
index a9ceccac6a0..030b785acdf 100644
--- a/lisp/progmodes/idlw-help.el
+++ b/lisp/progmodes/idlw-help.el
@@ -386,8 +386,7 @@ It collects and prints the diagnostics messages."
                            (< beg (- end 4))))
            module keyword cw mod1 mod2 mod3)
       (if (or arg 
-              (and (not st-ass)
-                   (not classtag)
+              (and (not classtag)
                    (not structtag)
                    (not (member (string-to-char this-word) '(?! ?.)))))
           ;; Need the module information
@@ -408,7 +407,8 @@ It collects and prints the diagnostics messages."
        (arg (setq mod1 module))
        
        ;; A special topic -- only system help
-       (st-ass (setq mod1 (list (cdr st-ass))))
+       ((and st-ass (not (memq cw '(function-keyword procedure-keyword))))
+        (setq mod1 (list (cdr st-ass))))
        
        ;; A system variable -- only system help
        ((string-match 
@@ -1226,7 +1226,7 @@ Useful when source code is displayed as help.  See the option
 ;; we must pass the -profile argument as well.
 (defvar idlwave-help-assistant-command 
   (if (memq system-type '(ms-dos windows-nt))
-      "bin/bin.x86/idl_assistant"
+      "bin/bin.x86/idl_assistant.exe"
     "bin/idl_assistant")
   "The command, rooted at idlwave-system-directory, which invokes the
 IDL assistant.")
diff --git a/lisp/progmodes/python.el b/lisp/progmodes/python.el
index 38e846aa2cc..6c37fb859e1 100644
--- a/lisp/progmodes/python.el
+++ b/lisp/progmodes/python.el
@@ -1383,11 +1383,11 @@ buffer for a list of commands.)"
 COMMAND should be a single statement."
   ;; (assert (not (string-match "\n" command)))
   ;; (let ((end (marker-position (process-mark (python-proc)))))
-    (with-current-buffer python-buffer (goto-char (point-max)))
+  (with-current-buffer (process-buffer (python-proc))
+    (goto-char (point-max))
     (compilation-forget-errors)
     (python-send-string command)
-    (with-current-buffer python-buffer
-      (setq compilation-last-buffer (current-buffer)))
+    (setq compilation-last-buffer (current-buffer)))
     ;; No idea what this is for but it breaks the call to
     ;; compilation-fake-loc in python-send-region.  -- Stef
     ;; Must wait until this has completed before re-setting variables below.
@@ -1517,9 +1517,9 @@ See variable `python-buffer'.  Starts a new process if necessary."
   ;; isn't one for `python-buffer'.
   (unless (comint-check-proc python-buffer)
     (run-python nil t))
-  (get-buffer-process (or (if (derived-mode-p 'inferior-python-mode)
-                              (current-buffer)
-                            python-buffer))))
+  (get-buffer-process (if (derived-mode-p 'inferior-python-mode)
+                          (current-buffer)
+                        python-buffer)))
 
 (defun python-set-proc ()
   "Set the default value of `python-buffer' to correspond to this buffer.