Merged from emacs@sv.gnu.org

Patches applied:

 * emacs@sv.gnu.org/emacs--devo--0--patch-674
   Merge from gnus--rel--5.10

 * emacs@sv.gnu.org/emacs--devo--0--patch-675
   Update from CVS

 * emacs@sv.gnu.org/emacs--devo--0--patch-676
   Update from CVS

 * emacs@sv.gnu.org/emacs--devo--0--patch-677
   Update from CVS

 * emacs@sv.gnu.org/emacs--devo--0--patch-678
   Update from CVS

 * emacs@sv.gnu.org/emacs--devo--0--patch-679
   Update from CVS

 * emacs@sv.gnu.org/emacs--devo--0--patch-680
   Update from CVS

 * emacs@sv.gnu.org/emacs--devo--0--patch-681
   Update from CVS

 * emacs@sv.gnu.org/emacs--devo--0--patch-682
   Update from CVS

 * emacs@sv.gnu.org/emacs--devo--0--patch-683
   Update from CVS

 * emacs@sv.gnu.org/emacs--devo--0--patch-684
   Update from CVS

 * emacs@sv.gnu.org/emacs--devo--0--patch-685
   Merge from gnus--rel--5.10

 * emacs@sv.gnu.org/emacs--devo--0--patch-686
   Update from CVS

 * emacs@sv.gnu.org/emacs--devo--0--patch-687
   Release ERC 5.2.

 * emacs@sv.gnu.org/emacs--devo--0--patch-688
   Update from CVS

 * emacs@sv.gnu.org/emacs--devo--0--patch-689
   Update from CVS

 * emacs@sv.gnu.org/emacs--devo--0--patch-690
   Update from CVS

 * emacs@sv.gnu.org/emacs--devo--0--patch-691
   Update from CVS

 * emacs@sv.gnu.org/emacs--devo--0--patch-692
   Update from CVS

 * emacs@sv.gnu.org/emacs--devo--0--patch-693
   Update from CVS

 * emacs@sv.gnu.org/emacs--devo--0--patch-694
   Update from CVS

 * emacs@sv.gnu.org/emacs--devo--0--patch-695
   Merge from gnus--rel--5.10

 * emacs@sv.gnu.org/emacs--devo--0--patch-696
   Update from CVS

 * emacs@sv.gnu.org/emacs--devo--0--patch-697
   Merge from gnus--rel--5.10

 * emacs@sv.gnu.org/emacs--devo--0--patch-698
   Update from CVS

 * emacs@sv.gnu.org/emacs--devo--0--patch-699
   Update from CVS

 * emacs@sv.gnu.org/emacs--devo--0--patch-700
   Update from CVS

 * emacs@sv.gnu.org/emacs--devo--0--patch-701
   Update from CVS

 * emacs@sv.gnu.org/gnus--rel--5.10--patch-209
   Merge from emacs--devo--0

 * emacs@sv.gnu.org/gnus--rel--5.10--patch-210
   Update from CVS

 * emacs@sv.gnu.org/gnus--rel--5.10--patch-211
   Update from CVS

 * emacs@sv.gnu.org/gnus--rel--5.10--patch-212
   Merge from emacs--devo--0

 * emacs@sv.gnu.org/gnus--rel--5.10--patch-213
   Update from CVS

 * emacs@sv.gnu.org/gnus--rel--5.10--patch-214
   Merge from emacs--devo--0

 * emacs@sv.gnu.org/gnus--rel--5.10--patch-215
   Update from CVS

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

23 files changed, 334 insertions, 206 deletions

diff --git a/lisp/progmodes/cc-awk.el b/lisp/progmodes/cc-awk.el
index b0c15bff903..b3e0e381135 100644
--- a/lisp/progmodes/cc-awk.el
+++ b/lisp/progmodes/cc-awk.el
@@ -988,6 +988,7 @@ nor helpful.
 Note that this function might do hidden buffer changes.  See the
 comment at the start of cc-engine.el for more info."
   (interactive "p")
+  (or arg (setq arg 1))
   (save-match-data
     (c-save-buffer-state                ; ensures the buffer is writable.
      nil
diff --git a/lisp/progmodes/cc-cmds.el b/lisp/progmodes/cc-cmds.el
index 4f9e1947738..79043c87b63 100644
--- a/lisp/progmodes/cc-cmds.el
+++ b/lisp/progmodes/cc-cmds.el
@@ -1262,11 +1262,11 @@ newline cleanups are done if appropriate; see the variable `c-cleanup-list'."
                      (backward-char)
                      (skip-chars-backward " \t")
                      (setq beg (point))
-                     (c-save-buffer-state () (c-on-identifier))
-                     ;; Don't add a space into #define FOO()....
-                     (not (and (c-beginning-of-macro)
-                               (c-forward-over-cpp-define-id)
-                               (eq (point) beg)))))
+                     (and (c-save-buffer-state () (c-on-identifier))
+                          ;; Don't add a space into #define FOO()....
+                          (not (and (c-beginning-of-macro)
+                                    (c-forward-over-cpp-define-id)
+                                    (eq (point) beg))))))
               (save-excursion
                 (delete-region beg end)
                 (goto-char beg)
@@ -1477,9 +1477,7 @@ No indentation or other \"electric\" behavior is performed."
     (c-syntactic-re-search-forward "{")
     (backward-char)
     (setq n (1- n)))
-   (;; (or (eq where 'at-header) (eq where 'outwith-function)
-;;      (eq where 'at-function-end) (eq where 'in-trailer))
-    (memq where '(at-header outwith-function at-function-end in-trailer))
+   ((memq where '(at-header outwith-function at-function-end in-trailer))
     (c-syntactic-skip-backward "^}")
     (when (eq (char-before) ?\})
       (backward-sexp)
@@ -1513,7 +1511,8 @@ defun."
   (or arg (setq arg 1))
 
   (c-save-buffer-state
-      ((start (point))
+      (beginning-of-defun-function end-of-defun-function
+       (start (point))
        where paren-state pos)
 
     ;; Move back out of any macro/comment/string we happen to be in.
@@ -1526,8 +1525,7 @@ defun."
     (if (< arg 0)
         ;; Move forward to the closing brace of a function.
         (progn
-          (if ;; (or (eq where 'at-function-end) (eq where 'outwith-function))
-              (memq where '(at-function-end outwith-function))
+          (if (memq where '(at-function-end outwith-function))
               (setq arg (1+ arg)))
           (if (< arg 0)
               (setq arg (c-forward-to-nth-EOF-} (- arg) where)))
@@ -1587,13 +1585,11 @@ defun."
    ((eq where 'in-trailer)
     (c-syntactic-skip-backward "^}")
     (setq n (1- n)))
-   (;; (or (eq where 'at-function-end) (eq where 'outwith-function)
-;;      (eq where 'at-header) (eq where 'in-header))
-    (memq where '(at-function-end outwith-function at-header in-header))
-    (c-syntactic-re-search-forward "{")
-    (backward-char)
-    (forward-sexp)
-    (setq n (1- n)))
+   ((memq where '(at-function-end outwith-function at-header in-header))
+    (when (c-syntactic-re-search-forward "{" nil 'eob)
+      (backward-char)
+      (forward-sexp)
+      (setq n (1- n))))
    (t (error "c-forward-to-nth-EOF-}: `where' is %s" where)))
 
   ;; Each time round the loop, go forward to a "}" at the outermost level.
@@ -1618,7 +1614,8 @@ the open-parenthesis that starts a defun; see `beginning-of-defun'."
   (or arg (setq arg 1))
 
   (c-save-buffer-state
-      ((start (point))
+      (beginning-of-defun-function end-of-defun-function
+       (start (point))
        where paren-state pos)
 
     ;; Move back out of any macro/comment/string we happen to be in.
@@ -1631,15 +1628,12 @@ the open-parenthesis that starts a defun; see `beginning-of-defun'."
     (if (< arg 0)
         ;; Move backwards to the } of a function
         (progn
-          (if ;; (or (eq where 'at-header) (eq where 'outwith-function))
-              (memq where '(at-header outwith-function))
+          (if (memq where '(at-header outwith-function))
               (setq arg (1+ arg)))
           (if (< arg 0)
               (setq arg (c-backward-to-nth-BOF-{ (- arg) where)))
-          (when (and (= arg 0)
-                     (c-syntactic-skip-backward "^}")
-                     (eq (char-before) ?\}))
-            t))
+          (if (= arg 0)
+              (c-syntactic-skip-backward "^}")))
 
       ;; Move forward to the } of a function
       (if (> arg 0)
diff --git a/lisp/progmodes/cc-defs.el b/lisp/progmodes/cc-defs.el
index 43fa0ab5937..8c10df649de 100644
--- a/lisp/progmodes/cc-defs.el
+++ b/lisp/progmodes/cc-defs.el
@@ -74,12 +74,12 @@
 ; (eval-after-load "font-lock"  ; 2006-07-09.  font-lock is now preloaded
 ;   '
 (if (and (not (featurep 'cc-fix)) ; only load the file once.
-            (featurep 'xemacs) ; There is now (2005/12) code in GNU Emacs CVS
-                               ; to make the call to f-l-c-k throw an error.
-            (let (font-lock-keywords)
-              (font-lock-compile-keywords '("\\<\\>"))
-              font-lock-keywords))     ; did the previous call foul this up?
-       (load "cc-fix")) ;)
+         (featurep 'xemacs)     ; There is now (2005/12) code in GNU Emacs CVS
+                                ; to make the call to f-l-c-k throw an error.
+         (let (font-lock-keywords)
+           (font-lock-compile-keywords '("\\<\\>"))
+           font-lock-keywords))     ; did the previous call foul this up?
+    (load "cc-fix")) ;)
 
 ;; The above takes care of the delayed loading, but this is necessary
 ;; to ensure correct byte compilation.
@@ -708,7 +708,8 @@ be after it."
             ;; c-parse-state to between 3 and 60 times faster when
             ;; braces are hung.  It can also degrade performance by
             ;; about as much when braces are not hung.
-            '(let (pos)
+            '(let (beginning-of-defun-function end-of-defun-function
+                                               pos)
                (while (not pos)
                  (save-restriction
                    (widen)
@@ -731,7 +732,8 @@ be after it."
                   ))
                (goto-char pos)))
        ;; Emacs, which doesn't have buffer-syntactic-context-depth
-       (beginning-of-defun))
+       (let (beginning-of-defun-function end-of-defun-function)
+         (beginning-of-defun)))
      ;; if defun-prompt-regexp is non-nil, b-o-d won't leave us at the
      ;; open brace.
      (and defun-prompt-regexp
diff --git a/lisp/progmodes/cc-engine.el b/lisp/progmodes/cc-engine.el
index a901ee07454..717016af7ea 100644
--- a/lisp/progmodes/cc-engine.el
+++ b/lisp/progmodes/cc-engine.el
@@ -1917,9 +1917,8 @@ comment at the start of cc-engine.el for more info."
   ;; 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.
+  ;; The motivation for the second bit 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)
@@ -5372,7 +5371,7 @@ comment at the start of cc-engine.el for more info."
           ;; True if there's a prefix match outside the outermost
           ;; paren pair that surrounds the declarator.
           got-prefix-before-parens
-y         ;; True if there's a suffix match outside the outermost
+          ;; True if there's a suffix match outside the outermost
           ;; paren pair that surrounds the declarator.  The value is
           ;; the position of the first suffix match.
           got-suffix-after-parens
@@ -5878,19 +5877,23 @@ y	  ;; True if there's a suffix match outside the outermost
 
 (defun c-forward-label (&optional assume-markup preceding-token-end limit)
   ;; Assuming that point is at the beginning of a token, check if it starts a
-  ;; label and if so move over it and return t, otherwise don't move and
-  ;; return nil.  "Label" here means "most things with a colon".
+  ;; label and if so move over it and return non-nil (t in default situations,
+  ;; specific symbols (see below) for interesting situations), otherwise don't
+  ;; move and return nil.  "Label" here means "most things with a colon".
   ;;
   ;; More precisely, a "label" is regarded as one of:
-  ;; (i) a goto target like "foo:";
-  ;; (ii) A case label - either the entire construct "case FOO:" or just the
-  ;;   bare "case", should the colon be missing;
-  ;; (iii) a keyword which needs a colon, like "default:" or "private:";
+  ;; (i) a goto target like "foo:" - returns the symbol `goto-target';
+  ;; (ii) A case label - either the entire construct "case FOO:", or just the
+  ;;   bare "case", should the colon be missing.  We return t;
+  ;; (iii) a keyword which needs a colon, like "default:" or "private:";  We
+  ;;   return t;
   ;; (iv) One of QT's "extended" C++ variants of
-  ;; "private:"/"protected:"/"public:"/"more:" looking like "public slots:".
+  ;;   "private:"/"protected:"/"public:"/"more:" looking like "public slots:".
+  ;;   Returns the symbol `qt-2kwds-colon'.
+  ;; (v) QT's construct "signals:".  Returns the symbol `qt-1kwd-colon'.
   ;; (v) One of the keywords matched by `c-opt-extra-label-key' (without any
   ;;   colon).  Currently (2006-03), this applies only to Objective C's
-  ;;   keywords "@private", "@protected", and "@public".
+  ;;   keywords "@private", "@protected", and "@public".  Returns t.
   ;;
   ;; One of the things which will NOT be recognised as a label is a bit-field
   ;; element of a struct, something like "int foo:5".
@@ -5919,8 +5922,10 @@ y	  ;; True if there's a suffix match outside the outermost
   ;; This function might do hidden buffer changes.
 
   (let ((start (point))
+        label-end
         qt-symbol-idx
-        macro-start)                    ; if we're in one.
+        macro-start                     ; if we're in one.
+        label-type)
     (cond
      ;; "case" or "default" (Doesn't apply to AWK). 
      ((looking-at c-label-kwds-regexp)
@@ -5933,25 +5938,26 @@ y	  ;; True if there's a suffix match outside the outermost
 
         ;; Find the label end.
         (goto-char kwd-end)
-        (if (and (c-syntactic-re-search-forward
-                  ;; Stop on chars that aren't allowed in expressions,
-                  ;; and on operator chars that would be meaningless
-                  ;; there.  FIXME: This doesn't cope with ?: operators.
-                  "[;{=,@]\\|\\(\\=\\|[^:]\\):\\([^:]\\|\\'\\)"
-                  limit t t nil 1)
-                 (match-beginning 2))
-
-            (progn
-              (goto-char (match-beginning 2)) ; just after the :
-              (c-put-c-type-property (1- (point)) 'c-decl-end)
-              t)
-
-          ;; It's an unfinished label.  We consider the keyword enough
-          ;; to recognize it as a label, so that it gets fontified.
-          ;; Leave the point at the end of it, but don't put any
-          ;; `c-decl-end' marker.
-          (goto-char kwd-end)
-          t)))
+        (setq label-type
+              (if (and (c-syntactic-re-search-forward
+                        ;; Stop on chars that aren't allowed in expressions,
+                        ;; and on operator chars that would be meaningless
+                        ;; there.  FIXME: This doesn't cope with ?: operators.
+                        "[;{=,@]\\|\\(\\=\\|[^:]\\):\\([^:]\\|\\'\\)"
+                        limit t t nil 1)
+                       (match-beginning 2))
+
+                  (progn                ; there's a proper :
+                    (goto-char (match-beginning 2)) ; just after the :
+                    (c-put-c-type-property (1- (point)) 'c-decl-end)
+                    t)
+
+              ;; It's an unfinished label.  We consider the keyword enough
+              ;; to recognize it as a label, so that it gets fontified.
+              ;; Leave the point at the end of it, but don't put any
+              ;; `c-decl-end' marker.
+                (goto-char kwd-end)
+                t))))
 
      ;; @private, @protected, @public, in Objective C, or similar.
      ((and c-opt-extra-label-key
@@ -5963,7 +5969,7 @@ y	  ;; True if there's a suffix match outside the outermost
       (when c-record-type-identifiers
         (c-record-ref-id (cons (match-beginning 1) (point))))
       (c-put-c-type-property (1- (point)) 'c-decl-end)
-      t)
+      (setq label-type t))
 
      ;; All other cases of labels.
      ((and c-recognize-colon-labels     ; nil for AWK and IDL, otherwise t.
@@ -6039,26 +6045,49 @@ y	  ;; True if there's a suffix match outside the outermost
                          (c-forward-syntactic-ws)
                          (c-forward-label nil pte start))))))))))
 
+           ;; Point is still at the beginning of the possible label construct.
+           ;; 
            ;; Check that the next nonsymbol token is ":", or that we're in one
            ;; of QT's "slots" declarations.  Allow '(' for the sake of macro
            ;; arguments.  FIXME: Should build this regexp from the language
            ;; constants.
-           (when (c-syntactic-re-search-forward
-                  "[ \t[:?;{=*/%&|,<>!@+-]" limit t t) ; not at EOB
-             (backward-char)
-             (setq qt-symbol-idx
-                   (and (c-major-mode-is 'c++-mode)
-                        (string-match
-                         "\\(p\\(r\\(ivate\\|otected\\)\\|ublic\\)\\|more\\)\\>"
-                         (buffer-substring start (point)))))
-             (c-forward-syntactic-ws limit)
-             (when (or (looking-at ":\\([^:]\\|\\'\\)") ; A single colon.
-                       (and qt-symbol-idx
-                            (search-forward-regexp "\\=slots\\>" limit t)
-                            (progn (c-forward-syntactic-ws limit)
-                                   (looking-at ":\\([^:]\\|\\'\\)")))) ; A single colon
-               (forward-char)           ; to after the colon.
-               t)))
+           (cond
+            ;; public: protected: private:
+            ((and
+              (c-major-mode-is 'c++-mode)
+              (search-forward-regexp
+               "\\=p\\(r\\(ivate\\|otected\\)\\|ublic\\)\\>[^_]" nil t)
+              (progn (backward-char)
+                     (c-forward-syntactic-ws limit)
+                     (looking-at ":\\([^:]\\|\\'\\)"))) ; A single colon.
+             (forward-char)
+             (setq label-type t))
+            ;; QT double keyword like "protected slots:" or goto target.
+            ((progn (goto-char start) nil))
+            ((when (c-syntactic-re-search-forward
+                    "[ \t\n[:?;{=*/%&|,<>!@+-]" limit t t) ; not at EOB
+               (backward-char)
+               (setq label-end (point))
+               (setq qt-symbol-idx
+                     (and (c-major-mode-is 'c++-mode)
+                          (string-match
+                           "\\(p\\(r\\(ivate\\|otected\\)\\|ublic\\)\\|more\\)\\>"
+                           (buffer-substring start (point)))))  
+               (c-forward-syntactic-ws limit)
+               (cond
+                ((looking-at ":\\([^:]\\|\\'\\)") ; A single colon.
+                 (forward-char)
+                 (setq label-type
+                       (if (string= "signals" ; Special QT macro
+                                    (buffer-substring-no-properties start label-end))
+                           'qt-1kwd-colon
+                         'goto-target)))
+                ((and qt-symbol-idx
+                      (search-forward-regexp "\\=slots\\>" limit t)
+                      (progn (c-forward-syntactic-ws limit)
+                             (looking-at ":\\([^:]\\|\\'\\)"))) ; A single colon
+                 (forward-char)
+                 (setq label-type 'qt-2kwds-colon)))))))
 
       (save-restriction
         (narrow-to-region start (point))
@@ -6069,6 +6098,7 @@ y	  ;; True if there's a suffix match outside the outermost
           (while (progn
                    (when (looking-at c-nonlabel-token-key)
                      (goto-char start)
+                     (setq label-type nil)
                      (throw 'check-label nil))
                    (and (c-safe (c-forward-sexp)
                                 (c-forward-syntactic-ws)
@@ -6088,12 +6118,12 @@ y	  ;; True if there's a suffix match outside the outermost
 
           (c-put-c-type-property (1- (point-max)) 'c-decl-end)
           (goto-char (point-max))
-          t)))
+          )))
 
      (t
       ;; Not a label.
-      (goto-char start)
-      nil))))
+      (goto-char start)))
+    label-type))
 
 (defun c-forward-objc-directive ()
   ;; Assuming the point is at the beginning of a token, try to move
diff --git a/lisp/progmodes/cc-fonts.el b/lisp/progmodes/cc-fonts.el
index a880ae9a1fe..0df09eda481 100644
--- a/lisp/progmodes/cc-fonts.el
+++ b/lisp/progmodes/cc-fonts.el
@@ -704,8 +704,13 @@ casts and declarations are fontified.  Used on level 2 and higher."
       ))
 
 (defun c-font-lock-complex-decl-prepare (limit)
+  ;; This function will be called from font-lock for a region bounded by POINT
+  ;; and LIMIT, as though it were to identify a keyword for
+  ;; font-lock-keyword-face.  It always returns NIL to inhibit this and
+  ;; prevent a repeat invocation.  See elisp/lispref page "Search-based
+  ;; Fontification".
+  ;;
   ;; Called before any of the matchers in `c-complex-decl-matchers'.
-  ;; Nil is always returned.
   ;;
   ;; This function does hidden buffer changes.
 
@@ -742,10 +747,15 @@ casts and declarations are fontified.  Used on level 2 and higher."
   nil)
 
 (defun c-font-lock-<>-arglists (limit)
+  ;; This function will be called from font-lock for a region bounded by POINT
+  ;; and LIMIT, as though it were to identify a keyword for
+  ;; font-lock-keyword-face.  It always returns NIL to inhibit this and
+  ;; prevent a repeat invocation.  See elisp/lispref page "Search-based
+  ;; Fontification".
+  ;;
   ;; Fontify types and references in names containing angle bracket
   ;; arglists from the point to LIMIT.  Note that
-  ;; `c-font-lock-declarations' already has handled many of them.  Nil
-  ;; is always returned.
+  ;; `c-font-lock-declarations' already has handled many of them.
   ;;
   ;; This function might do hidden buffer changes.
 
@@ -971,9 +981,14 @@ casts and declarations are fontified.  Used on level 2 and higher."
         font-lock-keyword-face))
 
 (defun c-font-lock-declarations (limit)
+  ;; This function will be called from font-lock for a region bounded by POINT
+  ;; and LIMIT, as though it were to identify a keyword for
+  ;; font-lock-keyword-face.  It always returns NIL to inhibit this and
+  ;; prevent a repeat invocation.  See elisp/lispref page "Search-based
+  ;; Fontification".
+  ;;
   ;; Fontify all the declarations, casts and labels from the point to LIMIT.
-  ;; Assumes that strings and comments have been fontified already.  Nil is
-  ;; always returned.
+  ;; Assumes that strings and comments have been fontified already.
   ;;
   ;; This function might do hidden buffer changes.
 
@@ -1009,6 +1024,7 @@ casts and declarations are fontified.  Used on level 2 and higher."
           ;; `c-forward-decl-or-cast-1' and `c-forward-label' for
           ;; later fontification.
           (c-record-type-identifiers t)
+          label-type
           c-record-ref-identifiers
           ;; Make `c-forward-type' calls mark up template arglists if
           ;; it finds any.  That's necessary so that we later will
@@ -1174,39 +1190,31 @@ casts and declarations are fontified.  Used on level 2 and higher."
               (c-fontify-recorded-types-and-refs)
               nil))
 
-          ;; It was a false alarm.
+          ;; It was a false alarm.  Check if we're in a label (or other
+          ;; construct with `:' except bitfield) instead.
           (goto-char start-pos)
-          ;; The below code attempts to fontify the case constants in
-          ;; c-label-face-name, but it cannot catch every case [sic].
-          ;; And do we want to fontify case constants anyway?
-          (c-forward-label t match-pos nil)
-;;;       (when (c-forward-label t match-pos nil)
-;;;         ;; Can't use `c-fontify-types-and-refs' here since we
-;;;         ;; should use the label face.
-;;;         (save-excursion
-;;;           (while c-record-ref-identifiers
-;;;             (let ((elem (car c-record-ref-identifiers))
-;;;                   c-record-type-identifiers)
-;;;               (goto-char (cdr elem))
-;;;               ;; Find the end of any label.
-;;;               (while (and (re-search-forward "\\sw\\|:" nil t)
-;;;                           (progn (backward-char 1) t)
-;;;                           (or (re-search-forward
-;;;                                "\\=0[Xx][0-9A-Fa-f]+\\|\\([0-9]+\\)" nil t)
-;;;                               (c-forward-name)))
-;;;                 (c-backward-syntactic-ws)
-;;;                 (let ((end (point)))
-;;;                   ;; Now find the start of the bit we regard as the label.
-;;;                   (when (and (c-simple-skip-symbol-backward)
-;;;                              (not (c-get-char-property (point) 'face)))
-;;;                     (c-put-font-lock-face (point) end c-label-face-name))
-;;;                   (goto-char end))))
-;;;             (setq c-record-ref-identifiers (cdr c-record-ref-identifiers))))
-;;;         ;; `c-forward-label' probably has added a `c-decl-end'
-;;;         ;; marker, so return t to `c-find-decl-spots' to signal
-;;;         ;; that.
-;;;         t)
-          )))
+          (when (setq label-type (c-forward-label t match-pos nil))
+            ;; Can't use `c-fontify-types-and-refs' here since we
+            ;; use the label face at times.
+            (cond ((eq label-type 'goto-target)
+                   (c-put-font-lock-face (caar c-record-ref-identifiers)
+                                         (cdar c-record-ref-identifiers)
+                                         c-label-face-name))
+                  ((eq label-type 'qt-1kwd-colon)
+                   (c-put-font-lock-face (caar c-record-ref-identifiers)
+                                         (cdar c-record-ref-identifiers)
+                                         'font-lock-keyword-face))
+                  ((eq label-type 'qt-2kwds-colon)
+                   (mapc
+                    (lambda (kwd)
+                      (c-put-font-lock-face (car kwd) (cdr kwd)
+                                            'font-lock-keyword-face))
+                    c-record-ref-identifiers)))
+            (setq c-record-ref-identifiers nil)
+            ;; `c-forward-label' has probably added a `c-decl-end'
+            ;; marker, so return t to `c-find-decl-spots' to signal
+            ;; that.
+            t))))
 
       nil)))
 
@@ -1285,6 +1293,14 @@ on level 2 only and so aren't combined with `c-complex-decl-matchers'."
   "Complex font lock matchers for types and declarations.  Used on level
 3 and higher."
 
+  ;; Note: This code in this form dumps a number of funtions into the
+  ;; resulting constant, `c-matchers-3'.  At run time, font lock will call
+  ;; each of them as a "FUNCTION" (see Elisp page "Search-based
+  ;; Fontification").  The font lock region is delimited by POINT and the
+  ;; single parameter, LIMIT.  Each of these functions returns NIL (thus
+  ;; inhibiting spurious font-lock-keyword-face highlighting and another
+  ;; call).
+
   t `(;; Initialize some things before the search functions below.
       c-font-lock-complex-decl-prepare
 
@@ -1397,6 +1413,8 @@ on level 2 only and so aren't combined with `c-complex-decl-matchers'."
 
       ;; Fontify the type in C++ "new" expressions.
       ,@(when (c-major-mode-is 'c++-mode)
+          ;; This pattern is a probably a "(MATCHER . ANCHORED-HIGHLIGHTER)"
+          ;; (see Elisp page "Search-based Fontification").
           `(("\\<new\\>"
              (c-font-lock-c++-new))))
       ))
diff --git a/lisp/progmodes/cc-langs.el b/lisp/progmodes/cc-langs.el
index fe01ab02ae3..906cbfb19a7 100644
--- a/lisp/progmodes/cc-langs.el
+++ b/lisp/progmodes/cc-langs.el
@@ -221,11 +221,6 @@ the evaluated constant value at compile time."
     ;; with the group symbol for each group and should return non-nil
     ;; if that group is to be included.
     ;;
-    ;; OP-FILTER filters the individual operators in each group.  It
-    ;; can be t to choose all operators, a regexp to test against each
-    ;; operator, or a function which will be called for each operator
-    ;; and should return non-nil for those to include.
-    ;;
     ;; If XLATE is given, it's a function which is called for each
     ;; matching operator and its return value is collected instead.
     ;; If it returns a list, the elements are spliced directly into
@@ -1376,6 +1371,26 @@ EOL terminated statements."
   (c-lang-const c-vsemi-status-unknown-p-fn))
 
 
+;;; Defun functions
+
+;; The Emacs variables beginning-of-defun-function and
+;; end-of-defun-function will be set so that commands like
+;; `mark-defun' and `narrow-to-defun' work right.  The key sequences
+;; C-M-a and C-M-e are, however, bound directly to the CC Mode
+;; functions, allowing optimisation for large n.
+(c-lang-defconst beginning-of-defun-function
+  "Function to which beginning-of-defun-function will be set."
+  t 'c-beginning-of-defun
+  awk 'c-awk-beginning-of-defun)
+(c-lang-setvar beginning-of-defun-function
+               (c-lang-const beginning-of-defun-function))
+
+(c-lang-defconst end-of-defun-function
+  "Function to which end-of-defun-function will be set."
+  t 'c-end-of-defun
+  awk 'c-awk-end-of-defun)
+(c-lang-setvar end-of-defun-function (c-lang-const end-of-defun-function))
+
 ;;; In-comment text handling.
 
 (c-lang-defconst c-paragraph-start
diff --git a/lisp/progmodes/cc-mode.el b/lisp/progmodes/cc-mode.el
index 1407b497305..f5da0eecc2e 100644
--- a/lisp/progmodes/cc-mode.el
+++ b/lisp/progmodes/cc-mode.el
@@ -158,8 +158,8 @@
 ;; These are typically standard emacs variables such as `comment-start'.
 (defmacro c-make-emacs-variables-local ()
   `(progn
-     ,@(mapcan (lambda (init)
-                 `((make-local-variable ',(car init))))
+     ,@(mapcar (lambda (init)
+                 `(make-local-variable ',(car init)))
                (cdr c-emacs-variable-inits))))
 
 (defun c-init-language-vars-for (mode)
@@ -509,9 +509,9 @@ preferably use the `c-mode-menu' language constant directly."
               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)))
+               (or (and (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
diff --git a/lisp/progmodes/cc-subword.el b/lisp/progmodes/cc-subword.el
index 29494fdc6a7..a6a365d316b 100644
--- a/lisp/progmodes/cc-subword.el
+++ b/lisp/progmodes/cc-subword.el
@@ -218,38 +218,52 @@ Optional argument ARG is the same as for `transpose-words'."
   (interactive "*p")
   (transpose-subr 'c-forward-subword arg))
 
-(defun c-capitalize-subword (arg)
-  "Do the same as `capitalize-word' but on subwords.
-See the command `c-subword-mode' for a description of subwords.
-Optional argument ARG is the same as for `capitalize-word'."
-  (interactive "p")
-  (let ((count (abs arg))
-        (direction (if (< 0 arg) 1 -1)))
-    (dotimes (i count)
-      (when (re-search-forward
-             (concat "[" c-alpha "]")
-             nil t)
-        (goto-char (match-beginning 0)))
-      (let* ((p (point))
-             (pp (1+ p))
-             (np (c-forward-subword direction)))
-        (upcase-region p pp)
-        (downcase-region pp np)
-        (goto-char np)))))
+
 
 (defun c-downcase-subword (arg)
   "Do the same as `downcase-word' but on subwords.
 See the command `c-subword-mode' for a description of subwords.
 Optional argument ARG is the same as for `downcase-word'."
   (interactive "p")
-  (downcase-region (point) (c-forward-subword arg)))
+  (let ((start (point)))
+    (downcase-region (point) (c-forward-subword arg))
+    (when (< arg 0) 
+      (goto-char start))))
 
 (defun c-upcase-subword (arg)
   "Do the same as `upcase-word' but on subwords.
 See the command `c-subword-mode' for a description of subwords.
 Optional argument ARG is the same as for `upcase-word'."
   (interactive "p")
-  (upcase-region (point) (c-forward-subword arg)))
+  (let ((start (point)))
+    (upcase-region (point) (c-forward-subword arg))
+    (when (< arg 0) 
+      (goto-char start))))
+
+(defun c-capitalize-subword (arg)
+  "Do the same as `capitalize-word' but on subwords.
+See the command `c-subword-mode' for a description of subwords.
+Optional argument ARG is the same as for `capitalize-word'."
+  (interactive "p")
+  (let ((count (abs arg))
+        (start (point))
+        (advance (if (< arg 0) nil t)))
+    (dotimes (i count)
+      (if advance
+          (progn (re-search-forward
+                  (concat "[" c-alpha "]")
+                  nil t)
+                 (goto-char (match-beginning 0)))
+        (c-backward-subword))
+      (let* ((p (point))
+             (pp (1+ p))
+             (np (c-forward-subword)))
+        (upcase-region p pp)
+        (downcase-region pp np)
+        (goto-char (if advance np p))))
+    (unless advance
+      (goto-char start))))
+
 
 
 ;;
diff --git a/lisp/progmodes/cc-vars.el b/lisp/progmodes/cc-vars.el
index cbf2b44de23..8d28cba79ad 100644
--- a/lisp/progmodes/cc-vars.el
+++ b/lisp/progmodes/cc-vars.el
@@ -890,7 +890,8 @@ Only currently supported behavior is `alignleft'."
 
 (defcustom c-special-indent-hook nil
   "*Hook for user defined special indentation adjustments.
-This hook gets called after a line is indented by the mode."
+This hook gets called after each line is indented by the mode.  It is only
+called if `c-syntactic-indentation' is non-nil."
   :type 'hook
   :group 'c)
 
diff --git a/lisp/progmodes/compile.el b/lisp/progmodes/compile.el
index aa77caf0670..ce933cb13d5 100644
--- a/lisp/progmodes/compile.el
+++ b/lisp/progmodes/compile.el
@@ -391,6 +391,7 @@ be added."
                     ,(expand-file-name "compilation.txt" data-directory))
   :group 'compilation)
 
+;;;###autoload(put 'compilation-directory 'safe-local-variable 'stringp)
 (defvar compilation-directory nil
   "Directory to restore to when doing `recompile'.")
 
@@ -625,7 +626,7 @@ Faces `compilation-error-face', `compilation-warning-face',
                    (cons (match-string-no-properties idx) dir))
       mouse-face highlight
       keymap compilation-button-map
-      help-echo "mouse-2: visit this directory")))
+      help-echo "mouse-2: visit destination directory")))
 
 ;; Data type `reverse-ordered-alist' retriever.  This function retrieves the
 ;; KEY element from the ALIST, creating it in the right position if not already
diff --git a/lisp/progmodes/cperl-mode.el b/lisp/progmodes/cperl-mode.el
index 0b8287503f8..a07fb5ee44f 100644
--- a/lisp/progmodes/cperl-mode.el
+++ b/lisp/progmodes/cperl-mode.el
@@ -233,6 +233,7 @@ for constructs with multiline if/unless/while/until/for/foreach condition."
   "*Indentation of CPerl statements with respect to containing block."
   :type 'integer
   :group 'cperl-indentation-details)
+(put 'cperl-indent-level 'safe-local-variable 'integerp)
 
 (defcustom cperl-lineup-step nil
   "*`cperl-lineup' will always lineup at multiple of this number.
@@ -1871,9 +1872,7 @@ or as help on variables `cperl-tips', `cperl-problems',
       (easy-menu-add cperl-menu))       ; A NOP in Emacs.
   (run-mode-hooks 'cperl-mode-hook)
   (if cperl-hook-after-change
-      (progn
-        (make-local-hook 'after-change-functions)
-        (add-hook 'after-change-functions 'cperl-after-change-function nil t)))
+      (add-hook 'after-change-functions 'cperl-after-change-function nil t))
   ;; After hooks since fontification will break this
   (if cperl-pod-here-scan
       (or cperl-syntaxify-by-font-lock
diff --git a/lisp/progmodes/dcl-mode.el b/lisp/progmodes/dcl-mode.el
index 618de7a3345..bdec1bf9ef4 100644
--- a/lisp/progmodes/dcl-mode.el
+++ b/lisp/progmodes/dcl-mode.el
@@ -71,6 +71,9 @@
 
 ;;; Code:
 
+(require 'tempo)
+
+
 ;;; *** Customization *****************************************************
 
 
@@ -1935,8 +1938,6 @@ section at the end of the current buffer."
 ;; standard Emacs.  I would have liked something closer to the functionality
 ;; of LSE templates...
 
-
-(require 'tempo)
 (defvar dcl-tempo-tags nil
   "Tempo tags for DCL mode.")
 
diff --git a/lisp/progmodes/ebnf2ps.el b/lisp/progmodes/ebnf2ps.el
index 23ba4b55f33..55f61222796 100644
--- a/lisp/progmodes/ebnf2ps.el
+++ b/lisp/progmodes/ebnf2ps.el
@@ -2609,7 +2609,7 @@ See `ebnf-style-database' documentation."
   (and (assoc name ebnf-style-database)
        (error "Style name already exists: %s" name))
   (or (assoc inherits ebnf-style-database)
-      (error "Style inheritance name does'nt exist: %s" inherits))
+      (error "Style inheritance name doesn't exist: %s" inherits))
   (setq ebnf-style-database
         (cons (cons name (cons inherits (ebnf-check-style-values values)))
               ebnf-style-database)))
@@ -2639,7 +2639,7 @@ See `ebnf-style-database' documentation."
 See `ebnf-style-database' documentation."
   (interactive "SStyle name: \nXStyle values: ")
   (let ((style (or (assoc name ebnf-style-database)
-                   (error "Style name does'nt exist: %s" name)))
+                   (error "Style name doesn't exist: %s" name)))
         (merge (ebnf-check-style-values values))
         val elt new check)
     ;; modify value of existing variables
diff --git a/lisp/progmodes/flymake.el b/lisp/progmodes/flymake.el
index 8d126c8a413..4903d7d26ec 100644
--- a/lisp/progmodes/flymake.el
+++ b/lisp/progmodes/flymake.el
@@ -931,8 +931,8 @@ Convert it to flymake internal format."
       2 4 nil 5))
    ;; compilation-error-regexp-alist)
    (flymake-reformat-err-line-patterns-from-compile-el compilation-error-regexp-alist-alist))
-  "Patterns for matching error/warning lines.
-\(REGEXP FILE-IDX LINE-IDX ERR-TEXT-IDX).
+  "Patterns for matching error/warning lines.  Each pattern has the form
+\(REGEXP FILE-IDX LINE-IDX COL-IDX ERR-TEXT-IDX).
 Use `flymake-reformat-err-line-patterns-from-compile-el' to add patterns
 from compile.el")
 
diff --git a/lisp/progmodes/gdb-ui.el b/lisp/progmodes/gdb-ui.el
index b598f2de1f7..4dbc9893f61 100644
--- a/lisp/progmodes/gdb-ui.el
+++ b/lisp/progmodes/gdb-ui.el
@@ -1771,10 +1771,15 @@ static char *magick[] = {
   :group 'gud)
 
 (defface breakpoint-disabled
-  ;; We use different values of grey for different background types,
-  ;; so that on low-color displays it will end up as something visible
-  ;; if it has to be approximated.
-  '((t :foreground  "grey70"))
+  '((((class color) (min-colors 88)) :foreground "grey70")
+    ;; Ensure that on low-color displays that we end up something visible.
+    (((class color) (min-colors 8) (background light))
+     :foreground "black")
+    (((class color) (min-colors 8) (background dark))
+     :foreground "white")
+    (((type tty) (class mono))
+     :inverse-video t)
+    (t :background "gray"))
   "Face for disabled breakpoint icon in fringe."
   :group 'gud)
 
diff --git a/lisp/progmodes/grep.el b/lisp/progmodes/grep.el
index fe2bbdec14e..2c43abfd50c 100644
--- a/lisp/progmodes/grep.el
+++ b/lisp/progmodes/grep.el
@@ -315,17 +315,7 @@ Notice that using \\[next-error] or \\[compile-goto-error] modifies
 This gets tacked on the end of the generated expressions.")
 
 ;;;###autoload
-(defvar grep-program
-  ;; Currently zgrep has trouble.  It runs egrep instead of grep,
-  ;; and it doesn't pass along long options right.
-  "grep"
-  ;; (if (equal (condition-case nil     ; in case "zgrep" isn't in exec-path
-  ;;             (call-process "zgrep" nil nil nil
-  ;;                           "foo" null-device)
-  ;;           (error nil))
-  ;;         1)
-  ;;     "zgrep"
-  ;;   "grep")
+(defvar grep-program "grep"
   "The default grep program for `grep-command' and `grep-find-command'.
 This variable's value takes effect when `grep-compute-defaults' is called.")
 
@@ -336,10 +326,10 @@ This variable's value takes effect when `grep-compute-defaults' is called.")
 
 ;;;###autoload
 (defvar grep-find-use-xargs nil
-  "Whether \\[grep-find] uses the `xargs' utility by default.
-
-If `exec', it uses `find -exec'; if `gnu', it uses `find -print0' and `xargs -0';
-if not nil and not `gnu', it uses `find -print' and `xargs'.
+  "Non-nil means that `grep-find' uses the `xargs' utility by default.
+If `exec', use `find -exec'.
+If `gnu', use `find -print0' and `xargs -0'.
+Any other non-nil value means to use `find -print' and `xargs'.
 
 This variable's value takes effect when `grep-compute-defaults' is called.")
 
diff --git a/lisp/progmodes/gud.el b/lisp/progmodes/gud.el
index 8db7c28219e..3d252190eff 100644
--- a/lisp/progmodes/gud.el
+++ b/lisp/progmodes/gud.el
@@ -147,8 +147,7 @@ Used to grey out relevant toolbar icons.")
     ([refresh]  "Refresh" . gud-refresh)
     ([run]      menu-item "Run" gud-run
                   :enable (not gud-running)
-                  :visible (and (memq gud-minor-mode '(gdbmi gdb dbx jdb))
-                                (not (eq gud-minor-mode 'gdba))))
+                  :visible (memq gud-minor-mode '(gdbmi gdb dbx jdb)))
     ([go]       menu-item (if gdb-active-process "Continue" "Run") gud-go
                   :visible (and (not gud-running)
                                 (eq gud-minor-mode 'gdba)))
@@ -214,7 +213,45 @@ Used to grey out relevant toolbar icons.")
   :name "Gud")
 
 (easy-mmode-defmap gud-minor-mode-map
-  `(([menu-bar debug] . ("Gud" . ,gud-menu-map)))
+  (append
+     `(([menu-bar debug] . ("Gud" . ,gud-menu-map)))
+     ;; Get tool bar like functionality from the menu bar on a text only
+     ;; terminal.
+   (unless window-system
+     `(([menu-bar down]
+        . (,(propertize "down" 'face 'font-lock-doc-face) . gud-down))
+       ([menu-bar up]
+        . (,(propertize "up" 'face 'font-lock-doc-face) . gud-up))
+       ([menu-bar finish]
+        . (,(propertize "finish" 'face 'font-lock-doc-face) . gud-finish))
+       ([menu-bar step]
+        . (,(propertize "step" 'face 'font-lock-doc-face) . gud-step))
+       ([menu-bar next]
+        . (,(propertize "next" 'face 'font-lock-doc-face) . gud-next))
+       ([menu-bar until] menu-item
+        ,(propertize "until" 'face 'font-lock-doc-face) gud-until
+                  :visible (memq gud-minor-mode '(gdbmi gdba gdb perldb)))
+       ([menu-bar cont] menu-item
+        ,(propertize "cont" 'face 'font-lock-doc-face) gud-cont
+        :visible (not (eq gud-minor-mode 'gdba)))
+       ([menu-bar run] menu-item
+        ,(propertize "run" 'face 'font-lock-doc-face) gud-run
+        :visible (memq gud-minor-mode '(gdbmi gdb dbx jdb)))
+       ([menu-bar go] menu-item 
+        ,(propertize " go " 'face 'font-lock-doc-face) gud-go
+        :visible (and (not gud-running)
+                      (eq gud-minor-mode 'gdba)))
+       ([menu-bar stop] menu-item
+        ,(propertize "stop" 'face 'font-lock-doc-face) gud-stop-subjob
+        :visible (or gud-running
+                     (not (eq gud-minor-mode 'gdba))))
+       ([menu-bar print]
+        . (,(propertize "print" 'face 'font-lock-doc-face) . gud-print))
+       ([menu-bar tools] . undefined)
+       ([menu-bar buffer] . undefined)
+       ([menu-bar options] . undefined)
+       ([menu-bar edit] . undefined)
+       ([menu-bar file] . undefined))))
   "Map used in visited files.")
 
 (let ((m (assq 'gud-minor-mode minor-mode-map-alist)))
@@ -686,14 +723,13 @@ text command mode to debug multiple programs within one Emacs
 session."
   (interactive (list (gud-query-cmdline 'gdb)))
 
-  (if (and gud-comint-buffer
+  (when (and gud-comint-buffer
            (buffer-name gud-comint-buffer)
            (get-buffer-process gud-comint-buffer)
            (with-current-buffer gud-comint-buffer (eq gud-minor-mode 'gdba)))
-      (let ((same-window-regexps))
-        (display-buffer gud-comint-buffer)
+        (gdb-restore-windows)
         (error
-         "Multiple debugging requires restarting in text command mode")))
+         "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)
@@ -2268,6 +2304,8 @@ gud, see `gud-mode'."
   (gud-def gud-up     "up\C-Mwhere"   "<"    "Up one stack frame.")
   (gud-def gud-down   "down\C-Mwhere" ">"    "Up one stack frame.")
   (gud-def gud-run    "run"           nil    "Run the program.") ;if VM start using jdb
+  (gud-def gud-print  "print %e"  "\C-p" "Evaluate Java expression at point.")
+
 
   (setq comint-prompt-regexp "^> \\|^[^ ]+\\[[0-9]+\\] ")
   (setq paragraph-start comint-prompt-regexp)
@@ -2817,7 +2855,9 @@ Obeying it means displaying in another window the specified file and line."
           (when (looking-at comint-prompt-regexp)
             (set-marker gud-delete-prompt-marker (point))
             (set-marker-insertion-type gud-delete-prompt-marker t))
-          (insert (concat  expr " = ")))))
+          (unless (eq (buffer-local-value 'gud-minor-mode gud-comint-buffer)
+                      'jdb)
+              (insert (concat  expr " = "))))))
     expr))
 
 ;; The next eight functions are hacked from gdbsrc.el by
diff --git a/lisp/progmodes/hideshow.el b/lisp/progmodes/hideshow.el
index 3bc1c55cc7d..9f01787b336 100644
--- a/lisp/progmodes/hideshow.el
+++ b/lisp/progmodes/hideshow.el
@@ -184,7 +184,6 @@
 ;; (5) Hideshow interacts badly with Ediff and `vc-diff'.  At the moment, the
 ;;     suggested workaround is to turn off hideshow entirely, for example:
 ;;
-;;     (defun turn-off-hideshow () (hs-minor-mode -1))
 ;;     (add-hook 'ediff-prepare-buffer-hook 'turn-off-hideshow)
 ;;     (add-hook 'vc-before-checkin-hook 'turn-off-hideshow)
 ;;
@@ -908,7 +907,7 @@ Key bindings:
         (hs-grok-mode-type)
         ;; Turn off this mode if we change major modes.
         (add-hook 'change-major-mode-hook
-                  (lambda () (hs-minor-mode -1))
+                  'turn-off-hideshow
                   nil t)
         (easy-menu-add hs-minor-mode-menu)
         (set (make-local-variable 'line-move-ignore-invisible) t)
@@ -920,6 +919,11 @@ Key bindings:
       (hs-show-all)))
   (run-hooks 'hs-minor-mode-hook))
 
+;;;###autoload
+(defun turn-off-hideshow ()
+  "Unconditionally turn off `hs-minor-mode'."
+  (hs-minor-mode -1))
+
 ;;---------------------------------------------------------------------------
 ;; load-time actions
 
diff --git a/lisp/progmodes/idlw-shell.el b/lisp/progmodes/idlw-shell.el
index aa2d1b32d10..bcecdeafa0f 100644
--- a/lisp/progmodes/idlw-shell.el
+++ b/lisp/progmodes/idlw-shell.el
@@ -2698,7 +2698,7 @@ in the current routine."
          (class (nth 2 module)))
     (if module
         (progn 
-          (setq module (idlwave-make-full-name (nth 2 module) (car module)))
+          (setq module (idlwave-make-full-name class name))
           (idlwave-shell-module-source-query module type)
           (idlwave-shell-set-bp-in-module name type class))
       (error "No identifier at point"))))
@@ -2707,14 +2707,15 @@ in the current routine."
 (defun idlwave-shell-set-bp-in-module (name type class)
   "Set breakpoint in module.  Assumes that `idlwave-shell-sources-alist'
 contains an entry for that module."
-  (let ((source-file 
-         (car-safe (cdr-safe
-                    (or
-                     (assoc (upcase (idlwave-make-full-name class name))
-                            idlwave-shell-sources-alist)
-                     (nth 3 (idlwave-best-rinfo-assoc name type class 
-                                                      (idlwave-routines)))))))
-        buf)
+  (let* ((module (idlwave-make-full-name class name))
+         (source-file 
+          (car-safe (cdr-safe
+                     (or
+                      (assoc (upcase module)
+                             idlwave-shell-sources-alist)
+                      (nth 3 (idlwave-best-rinfo-assoc name type class 
+                                                       (idlwave-routines)))))))
+         buf)
     (if (or (not source-file)
             (not (file-regular-p source-file))
             (not (setq buf
diff --git a/lisp/progmodes/idlwave.el b/lisp/progmodes/idlwave.el
index c4349e9c092..d29e56ce75d 100644
--- a/lisp/progmodes/idlwave.el
+++ b/lisp/progmodes/idlwave.el
@@ -3487,6 +3487,7 @@ if `idlwave-auto-fill-split-string' is non-nil."
           (idlwave-indent-line)
           ;; Prevent actions do-auto-fill which calls indent-line-function.
           (let (idlwave-do-actions
+                (paragraph-separate ".")
                 (fill-nobreak-predicate
                  (if (and (idlwave-in-quote)
                           idlwave-auto-fill-split-string)
diff --git a/lisp/progmodes/m4-mode.el b/lisp/progmodes/m4-mode.el
index 734a86b0b99..bd31f731693 100644
--- a/lisp/progmodes/m4-mode.el
+++ b/lisp/progmodes/m4-mode.el
@@ -118,14 +118,19 @@
 (defun m4-m4-buffer ()
   "Send contents of the current buffer to m4."
   (interactive)
-  (shell-command-on-region (point-min) (point-max) m4-program "*m4-output*"
-                           nil)
+  (shell-command-on-region
+   (point-min) (point-max)
+   (mapconcat 'identity (cons m4-program m4-program-options) "\s")
+   "*m4-output*" nil)
   (switch-to-buffer-other-window "*m4-output*"))
 
 (defun m4-m4-region ()
   "Send contents of the current region to m4."
   (interactive)
-  (shell-command-on-region (point) (mark) m4-program "*m4-output*" nil)
+  (shell-command-on-region
+   (point) (mark)
+   (mapconcat 'identity (cons m4-program m4-program-options) "\s")
+   "*m4-output*" nil)
   (switch-to-buffer-other-window "*m4-output*"))
 
 ;;;###autoload
diff --git a/lisp/progmodes/perl-mode.el b/lisp/progmodes/perl-mode.el
index 078e94ffbf4..255f63aed41 100644
--- a/lisp/progmodes/perl-mode.el
+++ b/lisp/progmodes/perl-mode.el
@@ -391,6 +391,7 @@ The expansion is entirely correct because it uses the C preprocessor."
   "*Indentation of Perl statements with respect to containing block."
   :type 'integer
   :group 'perl)
+(put 'perl-indent-level 'safe-local-variable 'integerp)
 (defcustom perl-continued-statement-offset 4
   "*Extra indent for lines not starting new statements."
   :type 'integer
diff --git a/lisp/progmodes/python.el b/lisp/progmodes/python.el
index 226d4bdc62d..e57c7e639c9 100644
--- a/lisp/progmodes/python.el
+++ b/lisp/progmodes/python.el
@@ -981,11 +981,15 @@ don't move and return nil.  Otherwise return t."
                        (_ (if (python-comment-line-p)
                               (python-skip-comments/blanks t)))
                        (ci (current-indentation))
-                       (open (python-open-block-statement-p)))
+                       (open (python-open-block-statement-p))
+                       opoint)
                   (if (and (zerop ci) (not open))
                       (not (goto-char point))
                     (catch 'done
-                      (while (zerop (python-next-statement))
+                      (setq opoint (point))
+                      (while (and (zerop (python-next-statement))
+                                  (not (= opoint (point))))
+                        (setq opoint (point))
                         (when (or (and open (<= (current-indentation) ci))
                                   (< (current-indentation) ci))
                           (python-skip-comments/blanks t)
@@ -2225,6 +2229,7 @@ with skeleton expansions for compound statement templates.
                                    ;;  . python-font-lock-syntactic-face-function)
                                    ))
   (set (make-local-variable 'parse-sexp-lookup-properties) t)
+  (set (make-local-variable 'parse-sexp-ignore-comments) t)
   (set (make-local-variable 'comment-start) "# ")
   (set (make-local-variable 'indent-line-function) #'python-indent-line)
   (set (make-local-variable 'indent-region-function) #'python-indent-region)