Merged from miles@gnu.org--gnu-2005 (patch 45-55, 214-231)

Patches applied:

 * miles@gnu.org--gnu-2005/emacs--cvs-trunk--0--patch-214
   Update from CVS

 * miles@gnu.org--gnu-2005/emacs--cvs-trunk--0--patch-215
   Update from CVS

 * miles@gnu.org--gnu-2005/emacs--cvs-trunk--0--patch-216
   Update from CVS

 * miles@gnu.org--gnu-2005/emacs--cvs-trunk--0--patch-217
   Update from CVS

 * miles@gnu.org--gnu-2005/emacs--cvs-trunk--0--patch-218
   Update from CVS

 * miles@gnu.org--gnu-2005/emacs--cvs-trunk--0--patch-219
   Update from CVS

 * miles@gnu.org--gnu-2005/emacs--cvs-trunk--0--patch-220
   Merge from gnus--rel--5.10

 * miles@gnu.org--gnu-2005/emacs--cvs-trunk--0--patch-221
   Update from CVS

 * miles@gnu.org--gnu-2005/emacs--cvs-trunk--0--patch-222
   Update from CVS

 * miles@gnu.org--gnu-2005/emacs--cvs-trunk--0--patch-223
   Update from CVS

 * miles@gnu.org--gnu-2005/emacs--cvs-trunk--0--patch-224
   Update from CVS

 * miles@gnu.org--gnu-2005/emacs--cvs-trunk--0--patch-225
   Update from CVS

 * miles@gnu.org--gnu-2005/emacs--cvs-trunk--0--patch-226
   Update from CVS

 * miles@gnu.org--gnu-2005/emacs--cvs-trunk--0--patch-227
   Update from CVS

 * miles@gnu.org--gnu-2005/emacs--cvs-trunk--0--patch-228
   Update from CVS

 * miles@gnu.org--gnu-2005/emacs--cvs-trunk--0--patch-229
   Update from CVS

 * miles@gnu.org--gnu-2005/emacs--cvs-trunk--0--patch-230
   Merge from gnus--rel--5.10

 * miles@gnu.org--gnu-2005/emacs--cvs-trunk--0--patch-231
   Update from CVS

 * miles@gnu.org--gnu-2005/gnus--rel--5.10--patch-45
   Update from CVS

 * miles@gnu.org--gnu-2005/gnus--rel--5.10--patch-46
   Update from CVS

 * miles@gnu.org--gnu-2005/gnus--rel--5.10--patch-47
   Update from CVS

 * miles@gnu.org--gnu-2005/gnus--rel--5.10--patch-48
   Update from CVS

 * miles@gnu.org--gnu-2005/gnus--rel--5.10--patch-49
   Update from CVS

 * miles@gnu.org--gnu-2005/gnus--rel--5.10--patch-50
   Update from CVS: texi Makefile.in CVS keyw cruft

 * miles@gnu.org--gnu-2005/gnus--rel--5.10--patch-51
   Update from CVS: ChangeLog tweaks

 * miles@gnu.org--gnu-2005/gnus--rel--5.10--patch-52
   Update from CVS

 * miles@gnu.org--gnu-2005/gnus--rel--5.10--patch-53
   Merge from emacs--cvs-trunk--0

 * miles@gnu.org--gnu-2005/gnus--rel--5.10--patch-54
   Update from CVS

 * miles@gnu.org--gnu-2005/gnus--rel--5.10--patch-55
   Update from CVS

git-archimport-id: lorentey@elte.hu--2004/emacs--multi-tty--0--patch-324

12 files changed, 251 insertions, 73 deletions

diff --git a/lisp/progmodes/compile.el b/lisp/progmodes/compile.el
index 457177d7c4c..bafc901d3d1 100644
--- a/lisp/progmodes/compile.el
+++ b/lisp/progmodes/compile.el
@@ -1613,6 +1613,8 @@ and overlay is highlighted between MK and END-MK."
     (compilation-set-window-height w)
 
     (when highlight-regexp
+      (if (timerp next-error-highlight-timer)
+          (cancel-timer next-error-highlight-timer))
       (unless compilation-highlight-overlay
         (setq compilation-highlight-overlay
               (make-overlay (point-min) (point-min)))
@@ -1632,8 +1634,11 @@ and overlay is highlighted between MK and END-MK."
               (move-overlay compilation-highlight-overlay
                             (point) end (current-buffer)))
             (if (numberp next-error-highlight)
-                (sit-for next-error-highlight))
-            (if (not (eq next-error-highlight t))
+                (setq next-error-highlight-timer
+                      (run-at-time next-error-highlight nil 'delete-overlay
+                                   compilation-highlight-overlay)))
+            (if (not (or (eq next-error-highlight t)
+                         (numberp next-error-highlight)))
                 (delete-overlay compilation-highlight-overlay))))))
     (when (and (eq next-error-highlight 'fringe-arrow))
       (set (make-local-variable 'overlay-arrow-position)
diff --git a/lisp/progmodes/cwarn.el b/lisp/progmodes/cwarn.el
index b16381cd2c7..9dfd4dd9e26 100644
--- a/lisp/progmodes/cwarn.el
+++ b/lisp/progmodes/cwarn.el
@@ -1,6 +1,6 @@
 ;;; cwarn.el --- highlight suspicious C and C++ constructions
 
-;; Copyright (C) 1999, 2000, 2001 Free Software Foundation, Inc.
+;; Copyright (C) 1999, 2000, 2001, 2005 Free Software Foundation, Inc.
 
 ;; Author: Anders Lindgren <andersl@andersl.com>
 ;; Keywords: c, languages, faces
@@ -193,7 +193,7 @@ be included in the variable `cwarn-configuration'.  By default C and
 C++ modes are included.
 
 With ARG, turn CWarn mode on if and only if arg is positive."
-  nil cwarn-mode-text nil
+  :group 'cwarn :lighter cwarn-mode-text
   (cwarn-font-lock-keywords cwarn-mode)
   (if font-lock-mode (font-lock-fontify-buffer)))
 
diff --git a/lisp/progmodes/f90.el b/lisp/progmodes/f90.el
index fdb7fffac6c..4c8b847b7cd 100644
--- a/lisp/progmodes/f90.el
+++ b/lisp/progmodes/f90.el
@@ -597,41 +597,32 @@ characters long.")
 
 ;; Hideshow support.
 (defconst f90-end-block-re
-  (concat "^[ \t0-9]*\\<end\\>[ \t]*"
+  (concat "^[ \t0-9]*\\<end[ \t]*"
           (regexp-opt '("do" "if" "forall" "function" "interface"
-                        "module" "program" "select"  "subroutine"
+                        "module" "program" "select" "subroutine"
                         "type" "where" ) t)
           "[ \t]*\\sw*")
-  "Regexp matching the end of a \"block\" of F90 code.
+  "Regexp matching the end of an F90 \"block\", from the line start.
 Used in the F90 entry in `hs-special-modes-alist'.")
 
 ;; Ignore the fact that FUNCTION, SUBROUTINE, WHERE, FORALL have a
-;; following "(".  DO, CASE, IF can have labels; IF must be
-;; accompanied by THEN.
-;; A big problem is that many of these statements can be broken over
-;; lines, even with embedded comments. We only try to handle this for
-;; IF ... THEN statements, assuming and hoping it will be less common
-;; for other constructs. We match up to one new-line, provided ")
-;; THEN" appears on one line. Matching on just ") THEN" is no good,
-;; since that includes ELSE branches.
-;; For a fully accurate solution, hideshow would probably have to be
-;; modified to allow functions as well as regexps to be used to
-;; specify block start and end positions.
+;; following "(".  DO, CASE, IF can have labels.
 (defconst f90-start-block-re
   (concat
    "^[ \t0-9]*"                         ; statement number
    "\\(\\("
    "\\(\\sw+[ \t]*:[ \t]*\\)?"          ; structure label
-   "\\(do\\|select[ \t]*case\\|if[ \t]*(.*\n?.*)[ \t]*then\\|"
+   "\\(do\\|select[ \t]*case\\|"
+   ;; See comments in fortran-start-block-re for the problems of IF.
+   "if[ \t]*(\\(.*\\|"
+   ".*\n\\([^if]*\\([^i].\\|.[^f]\\|.\\>\\)\\)\\)\\<then\\|"
    ;; Distinguish WHERE block from isolated WHERE.
    "\\(where\\|forall\\)[ \t]*(.*)[ \t]*\\(!\\|$\\)\\)\\)"
    "\\|"
    "program\\|interface\\|module\\|type\\|function\\|subroutine"
-   ;; ") THEN" at line end. Problem - also does ELSE.
-;;;   "\\|.*)[ \t]*then[ \t]*\\($\\|!\\)"
    "\\)"
    "[ \t]*")
-  "Regexp matching the start of a \"block\" of F90 code.
+  "Regexp matching the start of an F90 \"block\", from the line start.
 A simple regexp cannot do this in fully correct fashion, so this
 tries to strike a compromise between complexity and flexibility.
 Used in the F90 entry in `hs-special-modes-alist'.")
@@ -1305,12 +1296,12 @@ Checks for consistency of block types and labels (if present).
 Does not check the outermost block, because it may be incomplete.
 Interactively, pushes mark before moving point."
   (interactive "p")
+  (if (interactive-p) (push-mark (point) t))
   (and num (< num 0) (f90-end-of-block (- num)))
   (let ((case-fold-search t)
         (count (or num 1))
         end-list end-this end-type end-label
         start-this start-type start-label)
-    (if (interactive-p) (push-mark (point) t))
     (beginning-of-line)                 ; probably want this
     (while (and (> count 0) (re-search-backward f90-blocks-re nil 'move))
       (beginning-of-line)
diff --git a/lisp/progmodes/flymake.el b/lisp/progmodes/flymake.el
index 70150111a86..7067ddca21c 100644
--- a/lisp/progmodes/flymake.el
+++ b/lisp/progmodes/flymake.el
@@ -964,7 +964,7 @@ Convert it to flymake internal format."
         (if (consp file)        (setq file (car file)))
         (if (consp line)        (setq line (car line)))
         (if (consp col) (setq col (car col)))
-        
+
         (when (not (functionp line))
           (setq converted-list (cons (list regexp file line col) converted-list)))))
     converted-list))
@@ -1508,7 +1508,7 @@ Return first 'INCLUDE-DIRS/REL-FILE-NAME' that exists,  or just REL-FILE-NAME if
   "Minor mode to do on-the-fly syntax checking.
 When called interactively, toggles the minor mode.
 With arg, turn Flymake mode on if and only if arg is positive."
-  :lighter flymake-mode-line
+  :group 'flymake :lighter flymake-mode-line
   (if flymake-mode
       (if (flymake-can-syntax-check-file (buffer-file-name))
           (flymake-mode-on)
diff --git a/lisp/progmodes/fortran.el b/lisp/progmodes/fortran.el
index 768012c736c..30e1977d28d 100644
--- a/lisp/progmodes/fortran.el
+++ b/lisp/progmodes/fortran.el
@@ -1,7 +1,7 @@
 ;;; fortran.el --- Fortran mode for GNU Emacs
 
-;; Copyright (c) 1986, 93, 94, 95, 97, 98, 99, 2000, 01, 03, 04
-;;   Free Software Foundation, Inc.
+;; Copyright (C) 1986, 1993, 1994, 1995, 1997, 1998, 1999, 2000, 2001,
+;;               2003, 2004, 2005  Free Software Foundation, Inc.
 
 ;; Author: Michael D. Prange <prange@erl.mit.edu>
 ;; Maintainer: Glenn Morris <gmorris@ast.cam.ac.uk>
@@ -95,7 +95,7 @@ with a character in column 6."
   :group 'fortran-indent)
 
 (defcustom fortran-if-indent 3
-  "*Extra indentation applied to IF blocks."
+  "*Extra indentation applied to IF, SELECT CASE and WHERE blocks."
   :type  'integer
   :group 'fortran-indent)
 
@@ -321,7 +321,8 @@ program\\|subroutine\\)\\>[ \t]*\\(\\sw+\\)?"
                             "while" "inquire" "stop" "return"
                             "include" "open" "close" "read"
                             "write" "format" "print" "select" "case"
-                            "cycle" "exit" "rewind" "backspace")
+                            "cycle" "exit" "rewind" "backspace"
+                            "where" "elsewhere")
                           'paren) "\\>")
            ;; Builtin operators.
            (concat "\\." (regexp-opt
@@ -370,6 +371,29 @@ program\\|subroutine\\)\\>[ \t]*\\(\\sw+\\)?"
                 fortran-font-lock-keywords-2)))
   "Gaudy level highlighting for Fortran mode.")
 
+(defvar fortran-font-lock-keywords-4
+  (append fortran-font-lock-keywords-3
+          (list (list
+                 (concat "\\<"
+                         (regexp-opt
+                          '("int" "ifix" "idint" "real" "float" "sngl"
+                            "dble" "cmplx" "ichar" "char" "aint" "dint"
+                            "anint" "dnint" "nint" "idnint" "iabs" "abs"
+                            "dabs" "cabs" "mod" "amod" "dmod" "isign"
+                            "sign" "dsign" "idim" "dim" "ddim" "dprod"
+                            "max" "max0" "amax1" "dmax1" "amax0" "max1"
+                            "min0" "amin1" "dmin1" "amin0" "min1" "len"
+                            "index" "lge" "lgt" "lle" "llt" "aimag"
+                            "conjg" "sqrt" "dsqrt" "csqrt" "exp" "dexp"
+                            "cexp" "log" "alog" "dlog" "clog" "log10"
+                            "alog10" "dlog10" "sin" "dsin" "csin" "cos"
+                            "dcos" "ccos" "tan" "dtan" "asin" "dasin"
+                            "acos" "dacos" "atan" "datan" "atan2" "datan2"
+                            "sinh" "dsinh" "cosh" "dcosh" "tanh" "dtanh")
+                          'paren) "[ \t]*(") '(1 font-lock-builtin-face))))
+  "Maximum highlighting for Fortran mode.
+Consists of level 3 plus all other intrinsics not already highlighted.")
+
 ;; Comments are real pain in Fortran because there is no way to
 ;; represent the standard comment syntax in an Emacs syntax table.
 ;; (We can do so for F90-style).  Therefore an unmatched quote in a
@@ -409,6 +433,64 @@ These get fixed-format comments fontified.")
   "Value for `imenu-generic-expression' in Fortran mode.")
 
 
+;; Hideshow support.
+(defconst fortran-blocks-re
+  (concat "block[ \t]*data\\|select[ \t]*case\\|"
+          (regexp-opt '("do" "if" "interface" "function" "map" "program"
+                        "structure" "subroutine" "union" "where")))
+  "Regexp potentially indicating the start or end of a Fortran \"block\".
+Omits naked END statements, and DO-loops closed by anything other
+than ENDDO.")
+
+(defconst fortran-end-block-re
+  ;; Do-loops terminated by things other than ENDDO cannot be handled
+  ;; with a regexp. This omission does not seem to matter to hideshow...
+  (concat "^[ \t0-9]*\\<end[ \t]*\\("
+          fortran-blocks-re
+          ;; Naked END statement.
+          "\\|!\\|$\\)")
+  "Regexp matching the end of a Fortran \"block\", from the line start.
+Note that only ENDDO is handled for the end of a DO-loop.  Used
+in the Fortran entry in `hs-special-modes-alist'.")
+
+(defconst fortran-start-block-re
+  (concat
+   "^[ \t0-9]*\\("                      ; statement number
+   ;; Structure label for DO, IF, SELECT, WHERE.
+   "\\(\\(\\sw+[ \t]*:[ \t]*\\)?"
+   ;; IF blocks are a nuisance:
+   ;; IF ( ... ) foo   is not a block, but a single statement.
+   ;; IF ( ... ) THEN  can be split over multiple lines.
+   ;; [So can, eg, a DO WHILE (... ), but that is less common, I hope.]
+   ;; The regexp below allows for it to be split over at most 2 lines.
+   ;; That leads to the problem of not matching two consecutive IF
+   ;; statements as one, eg:
+   ;; IF ( ... ) foo
+   ;; IF ( ... ) THEN
+   ;; It simply is not possible to do this in a 100% correct fashion
+   ;; using a regexp - see the functions fortran-end-if,
+   ;; fortran-beginning-if for the hoops we have to go through.
+   ;; An alternative is to match on THEN at a line end, eg:
+   ;;   ".*)[ \t]*then[ \t]*\\($\\|!\\)"
+   ;; This would also match ELSE branches, though. This does not seem
+   ;; right to me, because then one has neighbouring blocks that are
+   ;; not nested in each other.
+   "\\(if[ \t]*(\\(.*\\|"
+   ".*\n\\([^if]*\\([^i].\\|.[^f]\\|.\\>\\)\\)\\)\\<then\\|"
+   "do\\|select[ \t]*case\\|where\\)\\)\\|"
+   (regexp-opt '("interface" "function" "map" "program"
+                 "structure" "subroutine" "union"))
+   "\\|block[ \t]*data\\)[ \t]*")
+  "Regexp matching the start of a Fortran \"block\", from the line start.
+A simple regexp cannot do this in fully correct fashion, so this
+tries to strike a compromise between complexity and flexibility.
+Used in the Fortran entry in `hs-special-modes-alist'.")
+
+(add-to-list 'hs-special-modes-alist
+             `(fortran-mode ,fortran-start-block-re ,fortran-end-block-re
+                            "^[cC*!]" fortran-end-of-block nil))
+
+
 (defvar fortran-mode-syntax-table
   (let ((table (make-syntax-table)))
     ;; We might like `;' to be punctuation (g77 multi-statement
@@ -422,7 +504,8 @@ These get fixed-format comments fontified.")
     (modify-syntax-entry ?/  "."  table)
     (modify-syntax-entry ?\' "\"" table)
     (modify-syntax-entry ?\" "\"" table)
-    ;; Consistent with GNU Fortran -- see the manual.
+    ;; Consistent with GNU Fortran's default -- see the manual.
+    ;; The F77 standard imposes no rule on this issue.
     (modify-syntax-entry ?\\ "\\" table)
     ;; This might be better as punctuation, as for C, but this way you
     ;; can treat floating-point numbers as symbols.
@@ -446,6 +529,8 @@ These get fixed-format comments fontified.")
     (define-key map "\C-c;"    'fortran-comment-region)
     (define-key map "\M-;"     'fortran-indent-comment)
     (define-key map "\M-\n"    'fortran-split-line)
+    (define-key map "\M-\C-n"  'fortran-end-of-block)
+    (define-key map "\M-\C-p"  'fortran-beginning-of-block)
     (define-key map "\M-\C-q"  'fortran-indent-subprogram)
     (define-key map "\C-c\C-w" 'fortran-window-create-momentarily)
     (define-key map "\C-c\C-r" 'fortran-column-ruler)
@@ -606,7 +691,7 @@ Key definitions:
 
 Variables controlling indentation style and extra features:
 
-`comment-start'
+`fortran-comment-line-start'
   To use comments starting with `!', set this to the string \"!\".
 `fortran-do-indent'
   Extra indentation within DO blocks (default 3).
@@ -696,7 +781,8 @@ with no args, if that value is non-nil."
        '((fortran-font-lock-keywords
           fortran-font-lock-keywords-1
           fortran-font-lock-keywords-2
-          fortran-font-lock-keywords-3)
+          fortran-font-lock-keywords-3
+          fortran-font-lock-keywords-4)
          nil t ((?/ . "$/") ("_$" . "w"))
          fortran-beginning-of-subprogram))
   (set (make-local-variable 'font-lock-syntactic-keywords)
@@ -1059,6 +1145,84 @@ Directive lines are treated as comments."
     (if (not not-last-statement)
         'last-statement)))
 
+(defun fortran-looking-at-if-then ()
+  "Return non-nil if at the start of a line with an IF ... THEN statement."
+  ;; cf f90-looking-at-if-then.
+  (let ((p (point))
+        (i (fortran-beginning-if)))
+    (if i
+        (save-excursion
+          (goto-char i)
+          (beginning-of-line)
+          (= (point) p)))))
+
+;; Used in hs-special-modes-alist.
+(defun fortran-end-of-block (&optional num)
+  "Move point forward to the end of the current code block.
+With optional argument NUM, go forward that many balanced blocks.
+If NUM is negative, go backward to the start of a block.  Does
+not check for consistency of block types.  Interactively, pushes
+mark before moving point."
+  (interactive "p")
+  (if (interactive-p) (push-mark (point) t))
+  (and num (< num 0) (fortran-beginning-of-block (- num)))
+  (let ((case-fold-search t)
+        (count (or num 1)))
+    (end-of-line)
+    (while (and (> count 0)
+                (re-search-forward
+                 (concat "\\(" fortran-blocks-re
+                         (if fortran-check-all-num-for-matching-do
+                             "\\|^[ \t]*[0-9]+" "")
+                         "\\|continue\\|end\\)\\>")
+                 nil 'move))
+      (beginning-of-line)
+      (if (if (looking-at (concat "^[0-9 \t]*" fortran-if-start-re))
+              (fortran-looking-at-if-then)
+            (looking-at fortran-start-block-re))
+          (setq count (1+ count))
+        (if (or (looking-at fortran-end-block-re)
+                (and (or (looking-at "^[0-9 \t]*continue")
+                         (and fortran-check-all-num-for-matching-do
+                              (looking-at "[ \t]*[0-9]+")))
+                     (fortran-check-for-matching-do)))
+            (setq count (1- count))))
+      (end-of-line))
+    (if (> count 0) (error "Missing block end"))))
+
+(defun fortran-beginning-of-block (&optional num)
+  "Move point backwards to the start of the current code block.
+With optional argument NUM, go backward that many balanced
+blocks.  If NUM is negative, go forward to the end of a block.
+Does not check for consistency of block types.  Interactively,
+pushes mark before moving point."
+  (interactive "p")
+  (if (interactive-p) (push-mark (point) t))
+  (and num (< num 0) (fortran-end-of-block (- num)))
+  (let ((case-fold-search t)
+        (count (or num 1)))
+    (beginning-of-line)
+    (while (and (> count 0)
+                (re-search-backward
+                 (concat "\\(" fortran-blocks-re
+                         (if fortran-check-all-num-for-matching-do
+                             "\\|^[ \t]*[0-9]+" "")
+                         "\\|continue\\|end\\)\\>")
+                 nil 'move))
+      (beginning-of-line)
+      (if (if (looking-at (concat "^[0-9 \t]*" fortran-if-start-re))
+              (fortran-looking-at-if-then)
+            (looking-at fortran-start-block-re))
+          (setq count (1- count))
+        (if (or (looking-at fortran-end-block-re)
+                (and (or (looking-at "^[0-9 \t]*continue")
+                         (and fortran-check-all-num-for-matching-do
+                              (looking-at "[ \t]*[0-9]+")))
+                     (fortran-check-for-matching-do)))
+            (setq count (1+ count)))))
+    ;; Includes an un-named main program block.
+    (if (> count 0) (error "Missing block start"))))
+
 
 (defun fortran-blink-match (regex keyword find-begin)
   "From a line matching REGEX, blink matching KEYWORD statement line.
@@ -1679,8 +1843,9 @@ If ALL is nil, only match comments that start in column > 0."
                             (1+ (point)))))
                   (if (re-search-forward "\\S\"\\s\"\\S\"" eol t)
                       (backward-char 2))
-                  ;; If the current string is longer than 72 - 6 chars,
-                  ;; break it at the fill column (else infinite loop).
+                  ;; If the current string is longer than (fill-column
+                  ;; - 6) chars, break it at the fill column (else
+                  ;; infinite loop).
                   (if (> (- (point) start)
                          (- fill-column 6 fortran-continuation-indent))
                       fcpoint
diff --git a/lisp/progmodes/glasses.el b/lisp/progmodes/glasses.el
index dea40b8db19..7aff14ec608 100644
--- a/lisp/progmodes/glasses.el
+++ b/lisp/progmodes/glasses.el
@@ -1,6 +1,6 @@
 ;;; glasses.el --- make cantReadThis readable
 
-;; Copyright (C) 1999, 2000, 2001 Free Software Foundation, Inc.
+;; Copyright (C) 1999, 2000, 2001, 2005 Free Software Foundation, Inc.
 
 ;; Author: Milan Zamazal <pdm@zamazal.org>
 ;; Maintainer: Milan Zamazal <pdm@zamazal.org>
@@ -251,7 +251,7 @@ recognized according to the current value of the variable `glasses-separator'."
   "Minor mode for making identifiers likeThis readable.
 When this mode is active, it tries to add virtual separators (like underscores)
 at places they belong to."
-  nil " o^o" nil
+  :group 'glasses :lighter " o^o"
   (save-excursion
     (save-restriction
       (widen)
diff --git a/lisp/progmodes/gud.el b/lisp/progmodes/gud.el
index 0988599ed54..1f9284db9cb 100644
--- a/lisp/progmodes/gud.el
+++ b/lisp/progmodes/gud.el
@@ -531,6 +531,9 @@ off the specialized speedbar mode."
 
 (defvar gdb-first-prompt t)
 
+(defvar gud-filter-pending-text nil
+  "Non-nil means this is text that has been saved for later in `gud-filter'.")
+
 ;;;###autoload
 (defun gdb (command-line)
   "Run gdb on program FILE in buffer *gud-FILE*.
@@ -562,6 +565,7 @@ and source-file directory for your debugger."
   (setq comint-prompt-regexp "^(.*gdb[+]?) *")
   (setq paragraph-start comint-prompt-regexp)
   (setq gdb-first-prompt t)
+  (setq gud-filter-pending-text nil)
   (run-hooks 'gdb-mode-hook))
 
 ;; One of the nice features of GDB is its impressive support for
@@ -2445,9 +2449,6 @@ comint mode, which see."
   "Non-nil means don't process anything from the debugger right now.
 It is saved for when this flag is not set.")
 
-(defvar gud-filter-pending-text nil
-  "Non-nil means this is text that has been saved for later in `gud-filter'.")
-
 ;; These functions are responsible for inserting output from your debugger
 ;; into the buffer.  The hard work is done by the method that is
 ;; the value of gud-marker-filter.
@@ -2516,19 +2517,22 @@ It is saved for when this flag is not set.")
               (gud-filter proc ""))))))
 
 (defvar gud-minor-mode-type nil)
+(defvar gud-overlay-arrow-position nil)
+(put 'gud-overlay-arrow-position 'overlay-arrow-string "=>")
+(add-to-list 'overlay-arrow-variable-list 'gud-overlay-arrow-position)
 
 (defun gud-sentinel (proc msg)
   (cond ((null (buffer-name (process-buffer proc)))
          ;; buffer killed
          ;; Stop displaying an arrow in a source file.
-         (setq overlay-arrow-position nil)
+         (setq gud-overlay-arrow-position nil)
          (set-process-buffer proc nil)
          (if (memq gud-minor-mode-type '(gdbmi gdba))
              (gdb-reset)
            (gud-reset)))
         ((memq (process-status proc) '(signal exit))
          ;; Stop displaying an arrow in a source file.
-         (setq overlay-arrow-position nil)
+         (setq gud-overlay-arrow-position nil)
          (with-current-buffer gud-comint-buffer
            (if (memq gud-minor-mode-type '(gdbmi gdba))
                (gdb-reset)
@@ -2611,13 +2615,13 @@ Obeying it means displaying in another window the specified file and line."
               (goto-line line)
               (setq pos (point))
               (setq overlay-arrow-string "=>")
-              (or overlay-arrow-position
-                  (setq overlay-arrow-position (make-marker)))
-              (set-marker overlay-arrow-position (point) (current-buffer)))
+              (or gud-overlay-arrow-position
+                  (setq gud-overlay-arrow-position (make-marker)))
+              (set-marker gud-overlay-arrow-position (point) (current-buffer)))
             (cond ((or (< pos (point-min)) (> pos (point-max)))
                    (widen)
                    (goto-char pos))))
-          (if window (set-window-point window overlay-arrow-position))))))
+          (if window (set-window-point window gud-overlay-arrow-position))))))
 
 ;; The gud-call function must do the right thing whether its invoking
 ;; keystroke is from the GUD buffer itself (via major-mode binding)
diff --git a/lisp/progmodes/hideif.el b/lisp/progmodes/hideif.el
index da6b6f772b6..23031c5bcda 100644
--- a/lisp/progmodes/hideif.el
+++ b/lisp/progmodes/hideif.el
@@ -1,6 +1,6 @@
 ;;; hideif.el --- hides selected code within ifdef
 
-;; Copyright (C) 1988,1994,2001, 2002 Free Software Foundation, Inc.
+;; Copyright (C) 1988, 1994, 2001, 2002, 2005 Free Software Foundation, Inc.
 
 ;; Author: Daniel LaLiberte <liberte@holonexus.org>
 ;; Maintainer: FSF
@@ -197,7 +197,7 @@ how the hiding is done:
         After `show-ifdefs', read-only status is restored to previous value.
 
 \\{hide-ifdef-mode-map}"
-  nil " Ifdef" nil
+  :group 'hide-ifdef :lighter " Ifdef"
   (if hide-ifdef-mode
       (progn
         ;; inherit global values
diff --git a/lisp/progmodes/python.el b/lisp/progmodes/python.el
index 20af0aaf96e..5073f2bc23a 100644
--- a/lisp/progmodes/python.el
+++ b/lisp/progmodes/python.el
@@ -1098,28 +1098,40 @@ Don't save anything for STR matching `inferior-python-filter-regexp'."
 (defvar python-preoutput-continuation nil
   "If non-nil, funcall this when `python-preoutput-filter' sees `_emacs_ok'.")
 
+(defvar python-preoutput-leftover nil)
+
 ;; Using this stops us getting lines in the buffer like
 ;; >>> ... ... >>>
 ;; Also look for (and delete) an `_emacs_ok' string and call
 ;; `python-preoutput-continuation' if we get it.
 (defun python-preoutput-filter (s)
   "`comint-preoutput-filter-functions' function: ignore prompts not at bol."
+  (when python-preoutput-leftover
+    (setq s (concat python-preoutput-leftover s))
+    (setq python-preoutput-leftover nil))
   (cond ((and (string-match (rx (and string-start (repeat 3 (any ".>"))
-                                     " " string-end))
-                            s)
-              (/= (let ((inhibit-field-text-motion t))
-                    (line-beginning-position))
-                  (point)))
-         "")
-        ((string= s "_emacs_ok\n")
-         (when python-preoutput-continuation
-           (funcall python-preoutput-continuation)
-           (setq python-preoutput-continuation nil))
-         "")
-        ((string-match "_emacs_out \\(.*\\)\n" s)
-         (setq python-preoutput-result (match-string 1 s))
+                                     " " string-end))
+                            s)
+              (/= (let ((inhibit-field-text-motion t))
+                    (line-beginning-position))
+                  (point)))
+         "")
+        ((string= s "_emacs_ok\n")
+         (when python-preoutput-continuation
+           (funcall python-preoutput-continuation)
+           (setq python-preoutput-continuation nil))
+         "")
+        ((string-match "_emacs_out \\(.*\\)\n" s)
+         (setq python-preoutput-result (match-string 1 s))
+         "")
+        ((string-match ".*\n" s)
+         s)
+        ((or (eq t (compare-strings s nil nil "_emacs_ok\n" nil (length s)))
+             (let ((end (min (length "_emacs_out ") (length s))))
+               (eq t (compare-strings s nil end "_emacs_out " nil end))))
+         (setq python-preoutput-leftover s)
          "")
-        (t s)))
+        (t s)))
 
 ;;;###autoload
 (defun run-python (&optional cmd noshow)
@@ -1359,7 +1371,9 @@ The result is what follows `_emacs_out' in the output (or nil)."
   (let ((proc (python-proc)))
     (python-send-string string)
     (setq python-preoutput-result nil)
-    (accept-process-output proc 5)
+    (while (progn
+             (accept-process-output proc 5)
+             python-preoutput-leftover))
     python-preoutput-result))
 
 ;; Fixme: try to make it work with point in the arglist.  Also, is
diff --git a/lisp/progmodes/scheme.el b/lisp/progmodes/scheme.el
index d9ffea852d1..c792b59ad87 100644
--- a/lisp/progmodes/scheme.el
+++ b/lisp/progmodes/scheme.el
@@ -90,7 +90,7 @@
     (modify-syntax-entry ?\] ")[  " st)
     (modify-syntax-entry ?{ "(}  " st)
     (modify-syntax-entry ?} "){  " st)
-    (modify-syntax-entry ?\| "  23" st)
+    (modify-syntax-entry ?\| "\" 23b" st)
 
     ;; Other atom delimiters
     (modify-syntax-entry ?\( "()  " st)
@@ -103,7 +103,7 @@
     ;; Special characters
     (modify-syntax-entry ?, "'   " st)
     (modify-syntax-entry ?@ "'   " st)
-    (modify-syntax-entry ?# "'  14" st)
+    (modify-syntax-entry ?# "' 14bn" st)
     (modify-syntax-entry ?\\ "\\   " st)
     st))
 
diff --git a/lisp/progmodes/tcl.el b/lisp/progmodes/tcl.el
index 4dba6b61a56..24ae19b0ad4 100644
--- a/lisp/progmodes/tcl.el
+++ b/lisp/progmodes/tcl.el
@@ -1,6 +1,7 @@
 ;;; tcl.el --- Tcl code editing commands for Emacs
 
-;; Copyright (C) 1994,98,1999,2000,01,02,2003,2004  Free Software Foundation, Inc.
+;; Copyright (C) 1994, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005
+;;           Free Software Foundation, Inc.
 
 ;; Maintainer: FSF
 ;; Author: Tom Tromey <tromey@redhat.com>
@@ -469,10 +470,7 @@ Uses variables `tcl-proc-regexp' and `tcl-keyword-list'."
          ;; Keywords.  Only recognized if surrounded by whitespace.
          ;; FIXME consider using "not word or symbol", not
          ;; "whitespace".
-         (cons (concat "\\(\\s-\\|^\\)"
-                       ;; FIXME Use regexp-quote?
-                       (regexp-opt tcl-keyword-list t)
-                       "\\(\\s-\\|$\\)")
+         (cons (concat "\\_<" (regexp-opt tcl-keyword-list t) "\\_>")
                2))))
 
 (if tcl-proc-regexp
@@ -1507,5 +1505,5 @@ The first line is assumed to look like \"#!.../program ...\"."
 
 (provide 'tcl)
 
-;;; arch-tag: 8a032554-c3ef-422e-b84c-acec0522179d
+;; arch-tag: 8a032554-c3ef-422e-b84c-acec0522179d
 ;;; tcl.el ends here
diff --git a/lisp/progmodes/which-func.el b/lisp/progmodes/which-func.el
index dae5722d430..d329e234025 100644
--- a/lisp/progmodes/which-func.el
+++ b/lisp/progmodes/which-func.el
@@ -1,6 +1,7 @@
 ;;; which-func.el --- print current function in mode line
 
-;; Copyright (C) 1994, 1997, 1998, 2001, 2003 Free Software Foundation, Inc.
+;; Copyright (C) 1994, 1997, 1998, 2001, 2003, 2005
+;;           Free Software Foundation, Inc.
 
 ;; Author:   Alex Rezinsky <alexr@msil.sps.mot.com>
 ;;           (doesn't seem to be responsive any more)
@@ -251,7 +252,7 @@ If no function name is found, return nil."
     (when (and (null name)
                (boundp 'imenu--index-alist) (null imenu--index-alist)
                (null which-function-imenu-failed))
-      (imenu--make-index-alist)
+      (imenu--make-index-alist t)
       (unless imenu--index-alist
         (make-local-variable 'which-function-imenu-failed)
         (setq which-function-imenu-failed t)))
@@ -291,5 +292,5 @@ If no function name is found, return nil."
 
 (provide 'which-func)
 
-;;; arch-tag: fa8a55c7-bfe3-4ffc-95ab-01bf21796827
+;; arch-tag: fa8a55c7-bfe3-4ffc-95ab-01bf21796827
 ;;; which-func.el ends here