Merged from miles@gnu.org--gnu-2005 (patch 80-82, 350-422)

Patches applied:

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

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

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

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

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

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

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

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

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

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

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

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

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

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

 * miles@gnu.org--gnu-2005/emacs--cvs-trunk--0--patch-364
   Remove "-face" suffix from widget faces

 * miles@gnu.org--gnu-2005/emacs--cvs-trunk--0--patch-365
   Remove "-face" suffix from custom faces

 * miles@gnu.org--gnu-2005/emacs--cvs-trunk--0--patch-366
   Remove "-face" suffix from change-log faces

 * miles@gnu.org--gnu-2005/emacs--cvs-trunk--0--patch-367
   Remove "-face" suffix from compilation faces

 * miles@gnu.org--gnu-2005/emacs--cvs-trunk--0--patch-368
   Remove "-face" suffix from diff-mode faces

 * miles@gnu.org--gnu-2005/emacs--cvs-trunk--0--patch-369
   lisp/longlines.el (longlines-visible-face): Face removed

 * miles@gnu.org--gnu-2005/emacs--cvs-trunk--0--patch-370
   Remove "-face" suffix from woman faces

 * miles@gnu.org--gnu-2005/emacs--cvs-trunk--0--patch-371
   Remove "-face" suffix from whitespace-highlight face

 * miles@gnu.org--gnu-2005/emacs--cvs-trunk--0--patch-372
   Remove "-face" suffix from ruler-mode faces

 * miles@gnu.org--gnu-2005/emacs--cvs-trunk--0--patch-373
   Remove "-face" suffix from show-paren faces

 * miles@gnu.org--gnu-2005/emacs--cvs-trunk--0--patch-374
   Remove "-face" suffix from log-view faces

 * miles@gnu.org--gnu-2005/emacs--cvs-trunk--0--patch-375
   Remove "-face" suffix from smerge faces

 * miles@gnu.org--gnu-2005/emacs--cvs-trunk--0--patch-376
   Remove "-face" suffix from show-tabs faces

 * miles@gnu.org--gnu-2005/emacs--cvs-trunk--0--patch-377
   Remove "-face" suffix from highlight-changes faces

 * miles@gnu.org--gnu-2005/emacs--cvs-trunk--0--patch-378
   Remove "-face" suffix from and downcase info faces

 * miles@gnu.org--gnu-2005/emacs--cvs-trunk--0--patch-379
   Remove "-face" suffix from pcvs faces

 * miles@gnu.org--gnu-2005/emacs--cvs-trunk--0--patch-380
   Update uses of renamed pcvs faces

 * miles@gnu.org--gnu-2005/emacs--cvs-trunk--0--patch-381
   Tweak ChangeLog

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

 * miles@gnu.org--gnu-2005/emacs--cvs-trunk--0--patch-383
   Remove "-face" suffix from strokes-char face

 * miles@gnu.org--gnu-2005/emacs--cvs-trunk--0--patch-384
   Remove "-face" suffix from compare-windows face

 * miles@gnu.org--gnu-2005/emacs--cvs-trunk--0--patch-385
   Remove "-face" suffix from calendar faces

 * miles@gnu.org--gnu-2005/emacs--cvs-trunk--0--patch-386
   Remove "-face" suffix from diary-button face

 * miles@gnu.org--gnu-2005/emacs--cvs-trunk--0--patch-387
   Remove "-face" suffix from testcover faces

 * miles@gnu.org--gnu-2005/emacs--cvs-trunk--0--patch-388
   Remove "-face" suffix from viper faces

 * miles@gnu.org--gnu-2005/emacs--cvs-trunk--0--patch-389
   Remove "-face" suffix from org faces

 * miles@gnu.org--gnu-2005/emacs--cvs-trunk--0--patch-390
   Remove "-face" suffix from sgml-namespace face

 * miles@gnu.org--gnu-2005/emacs--cvs-trunk--0--patch-391
   Remove "-face" suffix from table-cell face

 * miles@gnu.org--gnu-2005/emacs--cvs-trunk--0--patch-392
   Remove "-face" suffix from tex-mode faces

 * miles@gnu.org--gnu-2005/emacs--cvs-trunk--0--patch-393
   Remove "-face" suffix from texinfo-heading face

 * miles@gnu.org--gnu-2005/emacs--cvs-trunk--0--patch-394
   Remove "-face" suffix from flyspell faces

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

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

 * miles@gnu.org--gnu-2005/emacs--cvs-trunk--0--patch-397
   Remove "-face" suffix from gomoku faces

 * miles@gnu.org--gnu-2005/emacs--cvs-trunk--0--patch-398
   Remove "-face" suffix from mpuz faces

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

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

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

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

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

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

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

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

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

 * miles@gnu.org--gnu-2005/emacs--cvs-trunk--0--patch-408
   Remove "-face" suffix from Buffer-menu-buffer face

 * miles@gnu.org--gnu-2005/emacs--cvs-trunk--0--patch-409
   Remove "-face" suffix from antlr-mode faces

 * miles@gnu.org--gnu-2005/emacs--cvs-trunk--0--patch-410
   Remove "-face" suffix from ebrowse faces

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

 * miles@gnu.org--gnu-2005/emacs--cvs-trunk--0--patch-412
   Remove "-face" suffix from flymake faces

 * miles@gnu.org--gnu-2005/emacs--cvs-trunk--0--patch-413
   Remove "-face" suffix from idlwave faces

 * miles@gnu.org--gnu-2005/emacs--cvs-trunk--0--patch-414
   Remove "-face" suffix from sh-script faces

 * miles@gnu.org--gnu-2005/emacs--cvs-trunk--0--patch-415
   Remove "-face" suffix from vhdl-mode faces

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

 * miles@gnu.org--gnu-2005/emacs--cvs-trunk--0--patch-417
   Remove "-face" suffix from which-func face

 * miles@gnu.org--gnu-2005/emacs--cvs-trunk--0--patch-418
   Remove "-face" suffix from cperl-mode faces

 * miles@gnu.org--gnu-2005/emacs--cvs-trunk--0--patch-419
   Remove "-face" suffix from ld-script faces

 * miles@gnu.org--gnu-2005/emacs--cvs-trunk--0--patch-420
   Fix cperl-mode font-lock problem

 * miles@gnu.org--gnu-2005/emacs--cvs-trunk--0--patch-421
   Tweak which-func face

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

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

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

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

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

20 files changed, 917 insertions, 776 deletions

diff --git a/lisp/progmodes/ada-mode.el b/lisp/progmodes/ada-mode.el
index bc0edb1f047..ba4702d90a4 100644
--- a/lisp/progmodes/ada-mode.el
+++ b/lisp/progmodes/ada-mode.el
@@ -1462,7 +1462,7 @@ The standard casing rules will no longer apply to this word."
            (setq file-name (car ada-case-exception-file)))
           (t
            (error (concat "No exception file specified. "
-                          "See variable ada-case-exception-file."))))
+                          "See variable ada-case-exception-file"))))
 
     (set-syntax-table ada-mode-symbol-syntax-table)
     (unless word
@@ -1501,7 +1501,7 @@ word itself has a special casing."
                 (car ada-case-exception-file))
                (t
                 (error (concat "No exception file specified. "
-                               "See variable ada-case-exception-file."))))))
+                               "See variable ada-case-exception-file"))))))
 
     ;;  Find the substring to define as an exception. Order is: the parameter,
     ;;  if any, or the selected region, or the word under the cursor
@@ -5398,7 +5398,7 @@ This function typically is to be hooked into `ff-file-created-hooks'."
           (setq body-file (ada-get-body-name))
           (if body-file
               (find-file body-file)
-            (error "No body found for the package. Create it first."))
+            (error "No body found for the package. Create it first"))
 
           (save-restriction
             (widen)
diff --git a/lisp/progmodes/antlr-mode.el b/lisp/progmodes/antlr-mode.el
index bdf376bfab7..89d167de25d 100644
--- a/lisp/progmodes/antlr-mode.el
+++ b/lisp/progmodes/antlr-mode.el
@@ -1,6 +1,6 @@
 ;;; antlr-mode.el --- major mode for ANTLR grammar files
 
-;; Copyright (C) 1999, 2000, 2001, 2002, 2003 Free Software Foundation, Inc.
+;; Copyright (C) 1999, 2000, 2001, 2002, 2003, 2005 Free Software Foundation, Inc.
 ;;
 ;; Author: Christoph.Wedler@sap.com
 ;; Keywords: languages, ANTLR, code generator
@@ -827,58 +827,72 @@ font-lock keywords according to `font-lock-defaults' used for the code
 in the grammar's actions and semantic predicates, see
 `antlr-font-lock-maximum-decoration'.")
 
-(defvar antlr-font-lock-default-face 'antlr-font-lock-default-face)
-(defface antlr-font-lock-default-face nil
+(defvar antlr-default-face 'antlr-default)
+(defface antlr-default
   "Face to prevent strings from language dependent highlighting.
 Do not change."
   :group 'antlr)
+;; backward-compatibility alias
+(put 'antlr-font-lock-default-face 'face-alias 'antlr-default)
 
-(defvar antlr-font-lock-keyword-face 'antlr-font-lock-keyword-face)
-(defface antlr-font-lock-keyword-face
+(defvar antlr-keyword-face 'antlr-keyword)
+(defface antlr-keyword
   (cond-emacs-xemacs
    '((((class color) (background light))
       (:foreground "black" :EMACS :weight bold :XEMACS :bold t))))
   "ANTLR keywords."
   :group 'antlr)
+;; backward-compatibility alias
+(put 'antlr-font-lock-keyword-face 'face-alias 'antlr-keyword)
 
-(defvar antlr-font-lock-syntax-face 'antlr-font-lock-keyword-face)
-(defface antlr-font-lock-syntax-face
+(defvar antlr-syntax-face 'antlr-keyword)
+(defface antlr-syntax
   (cond-emacs-xemacs
    '((((class color) (background light))
       (:foreground "black" :EMACS :weight bold :XEMACS :bold t))))
   "ANTLR syntax symbols like :, |, (, ), ...."
   :group 'antlr)
+;; backward-compatibility alias
+(put 'antlr-font-lock-syntax-face 'face-alias 'antlr-syntax)
 
-(defvar antlr-font-lock-ruledef-face 'antlr-font-lock-ruledef-face)
-(defface antlr-font-lock-ruledef-face
+(defvar antlr-ruledef-face 'antlr-ruledef)
+(defface antlr-ruledef
   (cond-emacs-xemacs
    '((((class color) (background light))
       (:foreground "blue" :EMACS :weight bold :XEMACS :bold t))))
   "ANTLR rule references (definition)."
   :group 'antlr)
+;; backward-compatibility alias
+(put 'antlr-font-lock-ruledef-face 'face-alias 'antlr-ruledef)
 
-(defvar antlr-font-lock-tokendef-face 'antlr-font-lock-tokendef-face)
-(defface antlr-font-lock-tokendef-face
+(defvar antlr-tokendef-face 'antlr-tokendef)
+(defface antlr-tokendef
   (cond-emacs-xemacs
    '((((class color) (background light))
       (:foreground "blue" :EMACS :weight bold :XEMACS :bold t))))
   "ANTLR token references (definition)."
   :group 'antlr)
+;; backward-compatibility alias
+(put 'antlr-font-lock-tokendef-face 'face-alias 'antlr-tokendef)
 
-(defvar antlr-font-lock-ruleref-face 'antlr-font-lock-ruleref-face)
-(defface antlr-font-lock-ruleref-face
+(defvar antlr-ruleref-face 'antlr-ruleref)
+(defface antlr-ruleref
   '((((class color) (background light)) (:foreground "blue4")))
   "ANTLR rule references (usage)."
   :group 'antlr)
+;; backward-compatibility alias
+(put 'antlr-font-lock-ruleref-face 'face-alias 'antlr-ruleref)
 
-(defvar antlr-font-lock-tokenref-face 'antlr-font-lock-tokenref-face)
-(defface antlr-font-lock-tokenref-face
+(defvar antlr-tokenref-face 'antlr-tokenref)
+(defface antlr-tokenref
   '((((class color) (background light)) (:foreground "orange4")))
   "ANTLR token references (usage)."
   :group 'antlr)
+;; backward-compatibility alias
+(put 'antlr-font-lock-tokenref-face 'face-alias 'antlr-tokenref)
 
-(defvar antlr-font-lock-literal-face 'antlr-font-lock-literal-face)
-(defface antlr-font-lock-literal-face
+(defvar antlr-literal-face 'antlr-literal)
+(defface antlr-literal
   (cond-emacs-xemacs
    '((((class color) (background light))
       (:foreground "brown4" :EMACS :weight bold :XEMACS :bold t))))
@@ -886,6 +900,8 @@ Do not change."
 It is used to highlight strings matched by the first regexp group of
 `antlr-font-lock-literal-regexp'."
   :group 'antlr)
+;; backward-compatibility alias
+(put 'antlr-font-lock-literal-face 'face-alias 'antlr-literal)
 
 (defcustom antlr-font-lock-literal-regexp "\"\\(\\sw\\(\\sw\\|-\\)*\\)\""
   "Regexp matching literals with special syntax highlighting, or nil.
@@ -904,56 +920,56 @@ group.  The string matched by the first group is highlighted with
   (cond-emacs-xemacs
    `((antlr-invalidate-context-cache)
      ("\\$setType[ \t]*(\\([A-Za-z\300-\326\330-\337]\\sw*\\))"
-      (1 antlr-font-lock-tokendef-face))
-     ("\\$\\sw+" (0 font-lock-keyword-face))
+      (1 antlr-tokendef-face))
+     ("\\$\\sw+" (0 keyword-face))
      ;; the tokens are already fontified as string/docstrings:
      (,(lambda (limit)
-         (if antlr-font-lock-literal-regexp
+         (if antlr-literal-regexp
              (antlr-re-search-forward antlr-font-lock-literal-regexp limit)))
-      (1 antlr-font-lock-literal-face t)
+      (1 antlr-literal-face t)
       :XEMACS (0 nil))                  ; XEmacs bug workaround
      (,(lambda (limit)
          (antlr-re-search-forward antlr-class-header-regexp limit))
-      (1 antlr-font-lock-keyword-face)
-      (2 antlr-font-lock-ruledef-face)
-      (3 antlr-font-lock-keyword-face)
+      (1 antlr-keyword-face)
+      (2 antlr-ruledef-face)
+      (3 antlr-keyword-face)
       (4 (if (member (match-string 4) '("Lexer" "Parser" "TreeParser"))
-             'antlr-font-lock-keyword-face
-           'font-lock-type-face)))
+             antlr-keyword-face
+           type-face)))
      (,(lambda (limit)
          (antlr-re-search-forward
           "\\<\\(header\\|options\\|tokens\\|exception\\|catch\\|returns\\)\\>"
           limit))
-     (1 antlr-font-lock-keyword-face))
+     (1 antlr-keyword-face))
      (,(lambda (limit)
          (antlr-re-search-forward
           "^\\(private\\|public\\|protected\\)\\>[ \t]*\\(\\(\\sw+[ \t]*\\(:\\)?\\)\\)?"
           limit))
      (1 font-lock-type-face)            ; not XEmacs' java level-3 fruit salad
      (3 (if (antlr-upcase-p (char-after (match-beginning 3)))
-            'antlr-font-lock-tokendef-face
-          'antlr-font-lock-ruledef-face) nil t)
-     (4 antlr-font-lock-syntax-face nil t))
+            antlr-tokendef-face
+          antlr-ruledef-face) nil t)
+     (4 antlr-syntax-face nil t))
      (,(lambda (limit)
          (antlr-re-search-forward "^\\(\\sw+\\)[ \t]*\\(:\\)?" limit))
      (1 (if (antlr-upcase-p (char-after (match-beginning 0)))
-            'antlr-font-lock-tokendef-face
-          'antlr-font-lock-ruledef-face) nil t)
-     (2 antlr-font-lock-syntax-face nil t))
+            antlr-tokendef-face
+          antlr-ruledef-face) nil t)
+     (2 antlr-syntax-face nil t))
      (,(lambda (limit)
          ;; v:ruleref and v:"literal" is allowed...
          (antlr-re-search-forward "\\(\\sw+\\)[ \t]*\\([=:]\\)?" limit))
      (1 (if (match-beginning 2)
             (if (eq (char-after (match-beginning 2)) ?=)
-                'antlr-font-lock-default-face
-              'font-lock-variable-name-face)
+                antlr-default-face
+              font-lock-variable-name-face)
           (if (antlr-upcase-p (char-after (match-beginning 1)))
-              'antlr-font-lock-tokenref-face
-            'antlr-font-lock-ruleref-face)))
-     (2 antlr-font-lock-default-face nil t))
+              antlr-tokenref-face
+            antlr-ruleref-face)))
+     (2 antlr-default-face nil t))
      (,(lambda (limit)
          (antlr-re-search-forward "[|&:;(~]\\|)\\([*+?]\\|=>\\)?" limit))
-     (0 'antlr-font-lock-syntax-face))))
+     (0 antlr-syntax-face))))
   "Font-lock keywords for ANTLR's normal grammar code.
 See `antlr-font-lock-keywords-alist' for the keywords of actions.")
 
diff --git a/lisp/progmodes/compile.el b/lisp/progmodes/compile.el
index 0cb87a5b17a..3f3b385c5ed 100644
--- a/lisp/progmodes/compile.el
+++ b/lisp/progmodes/compile.el
@@ -231,9 +231,9 @@ of[ \t]+\"?\\([a-zA-Z]?:?[^\":\n]+\\)\"?:" 3 2 nil (1))
 
     (makepp
      "^makepp: \\(?:\\(?:warning\\(:\\).*?\\|\\(Scanning\\|[LR]e?l?oading makefile\\) \\|.*?\\)\
-`\\(\\(\\S +?\\)\\(?::\\([0-9]+\\)\\)?\\)'\\)"
+`\\(\\(\\S +?\\)\\(?::\\([0-9]+\\)\\)?\\)['(]\\)"
      4 5 nil (1 . 2) 3
-     ("`\\(\\(\\S +?\\)\\(?::\\([0-9]+\\)\\)?\\)'" nil nil
+     ("`\\(\\(\\S +?\\)\\(?::\\([0-9]+\\)\\)?\\)['(]" nil nil
       (2 compilation-info-face)
       (3 compilation-line-face nil t)
       (1 (compilation-error-properties 2 3 nil nil nil 0 nil)
@@ -246,8 +246,8 @@ of[ \t]+\"?\\([a-zA-Z]?:?[^\":\n]+\\)\"?:" 3 2 nil (1))
      " in \\([^()\n ]+\\)(\\([0-9]+\\))$" 1 2)
 
     (msft
-     "^\\(\\(?:[a-zA-Z]:\\)?[^:(\t\n]+\\)(\\([0-9]+\\)) \
-: \\(?:error\\|warnin\\(g\\)\\) C[0-9]+:" 1 2 nil (3))
+     "^\\([0-9]+>\\)?\\(\\(?:[a-zA-Z]:\\)?[^:(\t\n]+\\)(\\([0-9]+\\)) \
+: \\(?:error\\|warnin\\(g\\)\\) C[0-9]+:" 2 3 nil (4))
 
     (oracle
      "^\\(?:Semantic error\\|Error\\|PCC-[0-9]+:\\).* line \\([0-9]+\\)\
@@ -468,15 +468,17 @@ starting the compilation process.")
 ;; History of compile commands.
 (defvar compile-history nil)
 
-(defface compilation-warning-face
+(defface compilation-warning
   '((((class color) (min-colors 16)) (:foreground "Orange" :weight bold))
     (((class color)) (:foreground "cyan" :weight bold))
     (t (:weight bold)))
   "Face used to highlight compiler warnings."
   :group 'font-lock-highlighting-faces
   :version "22.1")
+;; backward-compatibility alias
+(put 'compilation-warning-face 'face-alias 'compilation-warning)
 
-(defface compilation-info-face
+(defface compilation-info
   '((((class color) (min-colors 16) (background light))
      (:foreground "Green3" :weight bold))
     (((class color) (min-colors 88) (background dark))
@@ -488,6 +490,8 @@ starting the compilation process.")
   "Face used to highlight compiler warnings."
   :group 'font-lock-highlighting-faces
   :version "22.1")
+;; backward-compatibility alias
+(put 'compilation-info-face 'face-alias 'compilation-info)
 
 (defvar compilation-message-face nil
   "Face name to use for whole messages.
@@ -498,10 +502,10 @@ Faces `compilation-error-face', `compilation-warning-face',
 (defvar compilation-error-face 'font-lock-warning-face
   "Face name to use for file name in error messages.")
 
-(defvar compilation-warning-face 'compilation-warning-face
+(defvar compilation-warning-face 'compilation-warning
   "Face name to use for file name in warning messages.")
 
-(defvar compilation-info-face 'compilation-info-face
+(defvar compilation-info-face 'compilation-info
   "Face name to use for file name in informational messages.")
 
 (defvar compilation-line-face 'font-lock-variable-name-face
@@ -935,6 +939,7 @@ Returns the compilation buffer created."
                     (substitute-env-vars (match-string 1 command))
                   "~")
               default-directory))
+        (erase-buffer)
         ;; Select the desired mode.
         (if (not (eq mode t))
             (funcall mode)
@@ -944,11 +949,11 @@ Returns the compilation buffer created."
         (if highlight-regexp
             (set (make-local-variable 'compilation-highlight-regexp)
                  highlight-regexp))
-        (erase-buffer)
         ;; Output a mode setter, for saving and later reloading this buffer.
         (insert "-*- mode: " name-of-mode
                 "; default-directory: " (prin1-to-string default-directory)
-                " -*-\n" command "\n")  (setq thisdir default-directory))
+                " -*-\n" command "\n")
+        (setq thisdir default-directory))
       (set-buffer-modified-p nil))
     ;; If we're already in the compilation buffer, go to the end
     ;; of the buffer, so point will track the compilation output.
diff --git a/lisp/progmodes/cperl-mode.el b/lisp/progmodes/cperl-mode.el
index 4abd8123e6a..9826c995b97 100644
--- a/lisp/progmodes/cperl-mode.el
+++ b/lisp/progmodes/cperl-mode.el
@@ -343,7 +343,7 @@ Affects: `cperl-font-lock', `cperl-electric-lbrace-space',
   :group 'cperl-indentation-details)
 
 (defvar cperl-vc-header-alist nil)
-(make-obsolete-variable 
+(make-obsolete-variable
  'cperl-vc-header-alist
  "use cperl-vc-rcs-header or cperl-vc-sccs-header instead.")
 
@@ -369,7 +369,7 @@ Affects: `cperl-font-lock', `cperl-electric-lbrace-space',
 
 (defcustom cperl-info-on-command-no-prompt nil
   "*Not-nil (and non-null) means not to prompt on C-h f.
-The opposite behaviour is always available if prefixed with C-c.
+The opposite behavior is always available if prefixed with C-c.
 Can be overwritten by `cperl-hairy' if nil."
   :type '(choice (const null) boolean)
   :group 'cperl-affected-by-hairy)
@@ -564,11 +564,11 @@ when syntaxifying a chunk of buffer."
     (font-lock-variable-name-face       nil nil         bold)
     (font-lock-function-name-face       nil nil         bold italic box)
     (font-lock-constant-face            nil "LightGray" bold)
-    (cperl-array-face                   nil "LightGray" bold underline)
-    (cperl-hash-face                    nil "LightGray" bold italic underline)
+    (cperl-array                        nil "LightGray" bold underline)
+    (cperl-hash                         nil "LightGray" bold italic underline)
     (font-lock-comment-face             nil "LightGray" italic)
     (font-lock-string-face              nil nil         italic underline)
-    (cperl-nonoverridable-face          nil nil         italic underline)
+    (cperl-nonoverridable               nil nil         italic underline)
     (font-lock-type-face                nil nil         underline)
     (underline                          nil "LightGray" strikeout))
   "List given as an argument to `ps-extend-face-list' in `cperl-ps-print'."
@@ -583,7 +583,7 @@ when syntaxifying a chunk of buffer."
 (defvar cperl-dark-foreground
   (cperl-choose-color "orchid1" "orange"))
 
-(defface cperl-nonoverridable-face
+(defface cperl-nonoverridable
   `((((class grayscale) (background light))
      (:background "Gray90" :slant italic :underline t))
     (((class grayscale) (background dark))
@@ -595,8 +595,10 @@ when syntaxifying a chunk of buffer."
     (t (:weight bold :underline t)))
   "Font Lock mode face used non-overridable keywords and modifiers of regexps."
   :group 'cperl-faces)
+;; backward-compatibility alias
+(put 'cperl-nonoverridable-face 'face-alias 'cperl-nonoverridable)
 
-(defface cperl-array-face
+(defface cperl-array
   `((((class grayscale) (background light))
      (:background "Gray90" :weight bold))
     (((class grayscale) (background dark))
@@ -608,8 +610,10 @@ when syntaxifying a chunk of buffer."
     (t (:weight bold)))
   "Font Lock mode face used to highlight array names."
   :group 'cperl-faces)
+;; backward-compatibility alias
+(put 'cperl-array-face 'face-alias 'cperl-array)
 
-(defface cperl-hash-face
+(defface cperl-hash
   `((((class grayscale) (background light))
      (:background "Gray90" :weight bold :slant italic))
     (((class grayscale) (background dark))
@@ -621,6 +625,8 @@ when syntaxifying a chunk of buffer."
     (t (:weight bold :slant italic)))
   "Font Lock mode face used to highlight hash names."
   :group 'cperl-faces)
+;; backward-compatibility alias
+(put 'cperl-hash-face 'face-alias 'cperl-hash)
 
 
 
@@ -867,8 +873,8 @@ B) Speed of editing operations.
 (defvar cperl-tips-faces 'please-ignore-this-line
   "CPerl mode uses following faces for highlighting:
 
-  `cperl-array-face'            Array names
-  `cperl-hash-face'             Hash names
+  `cperl-array'                 Array names
+  `cperl-hash'                  Hash names
   `font-lock-comment-face'      Comments, PODs and whatever is considered
                                 syntaxically to be not code
   `font-lock-constant-face'     HERE-doc delimiters, labels, delimiters of
@@ -879,7 +885,7 @@ B) Speed of editing operations.
                                 (except those conflicting with Perl operators),
                                 package names (when recognized), format names
   `font-lock-keyword-face'      Control flow switch constructs, declarators
-  `cperl-nonoverridable-face'   Non-overridable keywords, modifiers of RExen
+  `cperl-nonoverridable'        Non-overridable keywords, modifiers of RExen
   `font-lock-string-face'       Strings, qw() constructs, RExen, POD sections,
                                 literal parts and the terminator of formats
                                 and whatever is syntaxically considered
@@ -887,7 +893,7 @@ B) Speed of editing operations.
   `font-lock-type-face'         Overridable keywords
   `font-lock-variable-name-face' Variable declarations, indirect array and
                                 hash names, POD headers/item names
-  `cperl-invalid-face'          Trailing whitespace
+  `cperl-invalid'               Trailing whitespace
 
 Note that in several situations the highlighting tries to inform about
 possible confusion, such as different colors for function names in
@@ -1303,7 +1309,7 @@ you type it inside the inline block of control construct, like
 and you are on a boundary of a statement inside braces, it will
 transform the construct into a multiline and will place you into an
 appropriately indented blank line.  If you need a usual
-`newline-and-indent' behaviour, it is on \\[newline-and-indent],
+`newline-and-indent' behavior, it is on \\[newline-and-indent],
 see documentation on `cperl-electric-linefeed'.
 
 Use \\[cperl-invert-if-unless] to change a construction of the form
@@ -1481,7 +1487,7 @@ or as help on variables `cperl-tips', `cperl-problems',
   (make-local-variable 'comment-start-skip)
   (setq comment-start-skip "#+ *")
   (make-local-variable 'defun-prompt-regexp)
-  (setq defun-prompt-regexp "^[ \t]*sub[ \t\n]+\\([^ \t\n{(;]+\\)\\([ \t\n]*([^()]*)[ \t\n]*\\)?[ \t\n]*)")
+  (setq defun-prompt-regexp "^[ \t]*sub[ \t\n]+\\([^ \t\n{(;]+\\)\\([ \t\n]*([^()]*)[ \t\n]*\\)?[ \t\n]*")
   (make-local-variable 'comment-indent-function)
   (setq comment-indent-function 'cperl-comment-indent)
   (make-local-variable 'parse-sexp-ignore-comments)
@@ -3167,7 +3173,7 @@ the sections using `cperl-pod-head-face', `cperl-pod-face',
          (cperl-nonoverridable-face
           (if (boundp 'cperl-nonoverridable-face)
               cperl-nonoverridable-face
-            'cperl-nonoverridable-face))
+            'cperl-nonoverridable))
          (stop-point (if ignore-max
                          (point-max)
                        max))
@@ -3661,7 +3667,7 @@ the sections using `cperl-pod-head-face', `cperl-pod-face',
                         (forward-word 1) ; skip modifiers s///s
                         (if tail (cperl-commentify tail (point) t))
                         (cperl-postpone-fontification
-                         e1 (point) 'face 'cperl-nonoverridable-face)))
+                         e1 (point) 'face 'cperl-nonoverridable)))
                   ;; Check whether it is m// which means "previous match"
                   ;; and highlight differently
                   (setq is-REx
@@ -4710,7 +4716,7 @@ indentation and initial hashes.  Behaves usually outside of comment."
               "u\\(se\\|n\\(shift\\|ti\\(l\\|e\\)\\|def\\|less\\)\\)\\|"
               "while\\|y\\|__\\(END\\|DATA\\)__" ;__DATA__ added manually
               "\\|[sm]"                 ; Added manually
-              "\\)\\>") 2 'cperl-nonoverridable-face)
+              "\\)\\>") 2 'cperl-nonoverridable)
             ;;          (mapconcat 'identity
             ;;                     '("#endif" "#else" "#ifdef" "#ifndef" "#if"
             ;;                       "#include" "#define" "#undef")
@@ -4773,15 +4779,15 @@ indentation and initial hashes.  Behaves usually outside of comment."
                 '(
                   ("\\(\\([@%]\\|\$#\\)[a-zA-Z_:][a-zA-Z0-9_:]*\\)" 1
                    (if (eq (char-after (match-beginning 2)) ?%)
-                       cperl-hash-face
-                     cperl-array-face)
+                       'cperl-hash
+                     'cperl-array)
                    t)                   ; arrays and hashes
                   ("\\(\\([$@]+\\)[a-zA-Z_:][a-zA-Z0-9_:]*\\)[ \t]*\\([[{]\\)"
                    1
                    (if (= (- (match-end 2) (match-beginning 2)) 1)
                        (if (eq (char-after (match-beginning 3)) ?{)
-                           cperl-hash-face
-                         cperl-array-face) ; arrays and hashes
+                           'cperl-hash
+                         'cperl-array) ; arrays and hashes
                      font-lock-variable-name-face) ; Just to put something
                    t)
                   ;;("\\([smy]\\|tr\\)\\([^a-z_A-Z0-9]\\)\\(\\([^\n\\]*||\\)\\)\\2")
@@ -4854,21 +4860,21 @@ indentation and initial hashes.  Behaves usually outside of comment."
                       [nil              nil             t               t       t]
                       nil
                       [nil              nil             t               t       t])
-                (list 'cperl-nonoverridable-face
+                (list 'cperl-nonoverridable
                       ["chartreuse3"    ("orchid1" "orange")
                        nil              "Gray80"]
                       [nil              nil             "gray90"]
                       [nil              nil             nil             t       t]
                       [nil              nil             t               t]
                       [nil              nil             t               t       t])
-                (list 'cperl-array-face
+                (list 'cperl-array
                       ["blue"           "yellow"        nil             "Gray80"]
                       ["lightyellow2"   ("navy" "os2blue" "darkgreen")
                        "gray90"]
                       t
                       nil
                       nil)
-                (list 'cperl-hash-face
+                (list 'cperl-hash
                       ["red"            "red"           nil             "Gray80"]
                       ["lightyellow2"   ("navy" "os2blue" "darkgreen")
                        "gray90"]
@@ -4891,15 +4897,15 @@ indentation and initial hashes.  Behaves usually outside of comment."
                             "Face for variable names")
           (cperl-force-face font-lock-type-face
                             "Face for data types")
-          (cperl-force-face cperl-nonoverridable-face
+          (cperl-force-face cperl-nonoverridable
                             "Face for data types from another group")
           (cperl-force-face font-lock-comment-face
                             "Face for comments")
           (cperl-force-face font-lock-function-name-face
                             "Face for function names")
-          (cperl-force-face cperl-hash-face
+          (cperl-force-face cperl-hash
                             "Face for hashes")
-          (cperl-force-face cperl-array-face
+          (cperl-force-face cperl-array
                             "Face for arrays")
           ;;(defvar font-lock-constant-face 'font-lock-constant-face)
           ;;(defvar font-lock-variable-name-face 'font-lock-variable-name-face)
@@ -4909,7 +4915,7 @@ indentation and initial hashes.  Behaves usually outside of comment."
           ;;    "Face to use for data types."))
           ;;(or (boundp 'cperl-nonoverridable-face)
           ;;    (defconst cperl-nonoverridable-face
-          ;;    'cperl-nonoverridable-face
+          ;;    'cperl-nonoverridable
           ;;    "Face to use for data types from another group."))
           ;;(if (not cperl-xemacs-p) nil
           ;;  (or (boundp 'font-lock-comment-face)
@@ -4925,26 +4931,24 @@ indentation and initial hashes.  Behaves usually outside of comment."
           ;;      'font-lock-function-name-face
           ;;      "Face to use for function names.")))
           (if (and
-               (not (cperl-is-face 'cperl-array-face))
+               (not (cperl-is-face 'cperl-array))
                (cperl-is-face 'font-lock-emphasized-face))
-              (copy-face 'font-lock-emphasized-face 'cperl-array-face))
+              (copy-face 'font-lock-emphasized-face 'cperl-array))
           (if (and
-               (not (cperl-is-face 'cperl-hash-face))
+               (not (cperl-is-face 'cperl-hash))
                (cperl-is-face 'font-lock-other-emphasized-face))
-              (copy-face 'font-lock-other-emphasized-face
-                         'cperl-hash-face))
+              (copy-face 'font-lock-other-emphasized-face 'cperl-hash))
           (if (and
-               (not (cperl-is-face 'cperl-nonoverridable-face))
+               (not (cperl-is-face 'cperl-nonoverridable))
                (cperl-is-face 'font-lock-other-type-face))
-              (copy-face 'font-lock-other-type-face
-                         'cperl-nonoverridable-face))
+              (copy-face 'font-lock-other-type-face 'cperl-nonoverridable))
           ;;(or (boundp 'cperl-hash-face)
           ;;    (defconst cperl-hash-face
-          ;;    'cperl-hash-face
+          ;;    'cperl-hash
           ;;    "Face to use for hashes."))
           ;;(or (boundp 'cperl-array-face)
           ;;    (defconst cperl-array-face
-          ;;    'cperl-array-face
+          ;;    'cperl-array
           ;;    "Face to use for arrays."))
           ;; Here we try to guess background
           (let ((background
@@ -4983,17 +4987,17 @@ indentation and initial hashes.  Behaves usually outside of comment."
                                        "pink")))
                (t
                 (set-face-background 'font-lock-type-face "gray90"))))
-            (if (cperl-is-face 'cperl-nonoverridable-face)
+            (if (cperl-is-face 'cperl-nonoverridable)
                 nil
-              (copy-face 'font-lock-type-face 'cperl-nonoverridable-face)
+              (copy-face 'font-lock-type-face 'cperl-nonoverridable)
               (cond
                ((eq background 'light)
-                (set-face-foreground 'cperl-nonoverridable-face
+                (set-face-foreground 'cperl-nonoverridable
                                      (if (x-color-defined-p "chartreuse3")
                                          "chartreuse3"
                                        "chartreuse")))
                ((eq background 'dark)
-                (set-face-foreground 'cperl-nonoverridable-face
+                (set-face-foreground 'cperl-nonoverridable
                                      (if (x-color-defined-p "orchid1")
                                          "orchid1"
                                        "orange")))))
@@ -5045,20 +5049,15 @@ indentation and initial hashes.  Behaves usually outside of comment."
     '(setq ps-bold-faces
            ;;                   font-lock-variable-name-face
            ;;                   font-lock-constant-face
-           (append '(cperl-array-face
-                     cperl-hash-face)
+           (append '(cperl-array cperl-hash)
                    ps-bold-faces)
            ps-italic-faces
            ;;                   font-lock-constant-face
-           (append '(cperl-nonoverridable-face
-                     cperl-hash-face)
+           (append '(cperl-nonoverridable cperl-hash)
                    ps-italic-faces)
            ps-underlined-faces
            ;;        font-lock-type-face
-           (append '(cperl-array-face
-                     cperl-hash-face
-                     underline
-                     cperl-nonoverridable-face)
+           (append '(cperl-array cperl-hash underline cperl-nonoverridable)
                    ps-underlined-faces))))
 
 (defvar ps-print-face-extension-alist)
@@ -5091,27 +5090,27 @@ Style of printout regulated by the variable `cperl-ps-print-face-properties'."
 ;;;   (defvar ps-italic-faces nil)
 ;;;   (setq ps-bold-faces
 ;;;     (append '(font-lock-emphasized-face
-;;;               cperl-array-face
+;;;               cperl-array
 ;;;               font-lock-keyword-face
 ;;;               font-lock-variable-name-face
 ;;;               font-lock-constant-face
 ;;;               font-lock-reference-face
 ;;;               font-lock-other-emphasized-face
-;;;               cperl-hash-face)
+;;;               cperl-hash)
 ;;;             ps-bold-faces))
 ;;;   (setq ps-italic-faces
-;;;     (append '(cperl-nonoverridable-face
+;;;     (append '(cperl-nonoverridable
 ;;;               font-lock-constant-face
 ;;;               font-lock-reference-face
 ;;;               font-lock-other-emphasized-face
-;;;               cperl-hash-face)
+;;;               cperl-hash)
 ;;;             ps-italic-faces))
 ;;;   (setq ps-underlined-faces
 ;;;     (append '(font-lock-emphasized-face
-;;;               cperl-array-face
+;;;               cperl-array
 ;;;               font-lock-other-emphasized-face
-;;;               cperl-hash-face
-;;;               cperl-nonoverridable-face font-lock-type-face)
+;;;               cperl-hash
+;;;               cperl-nonoverridable font-lock-type-face)
 ;;;             ps-underlined-faces))
 ;;;   (cons 'font-lock-type-face ps-underlined-faces))
 
diff --git a/lisp/progmodes/cpp.el b/lisp/progmodes/cpp.el
index 0d9a9f62a60..9910f1f548f 100644
--- a/lisp/progmodes/cpp.el
+++ b/lisp/progmodes/cpp.el
@@ -144,7 +144,7 @@ or a cons cell (background-color . COLOR)."
   '("light gray" "light blue" "light cyan" "light yellow" "light pink"
     "pale green" "beige" "orange" "magenta" "violet" "medium purple"
     "turquoise")
-  "Background colours useful with dark foreground colors."
+  "Background colors useful with dark foreground colors."
   :type '(repeat string)
   :group 'cpp)
 
@@ -152,7 +152,7 @@ or a cons cell (background-color . COLOR)."
   '("dim gray" "blue" "cyan" "yellow" "red"
     "dark green" "brown" "dark orange" "dark khaki" "dark violet" "purple"
     "dark turquoise")
-  "Background colours useful with light foreground colors."
+  "Background colors useful with light foreground colors."
   :type '(repeat string)
   :group 'cpp)
 
diff --git a/lisp/progmodes/delphi.el b/lisp/progmodes/delphi.el
index 3d86f15c175..166e5b8984e 100644
--- a/lisp/progmodes/delphi.el
+++ b/lisp/progmodes/delphi.el
@@ -152,8 +152,8 @@ regardless of where in the line point is when the TAB command is used."
 (defcustom delphi-newline-always-indents t
   "*Non-nil means NEWLINE in Delphi mode should always reindent the current
 line, insert a blank line and move to the default indent column of the blank
-line. If nil, then no indentation occurs, and NEWLINE does the usual
-behaviour. This is useful when one needs to do customized indentation that
+line.  If nil, then no indentation occurs, and NEWLINE does the usual
+behavior.  This is useful when one needs to do customized indentation that
 differs from the default."
   :type 'boolean
   :group 'delphi)
diff --git a/lisp/progmodes/ebrowse.el b/lisp/progmodes/ebrowse.el
index 953ecd79f7f..5f8ea5ae70a 100644
--- a/lisp/progmodes/ebrowse.el
+++ b/lisp/progmodes/ebrowse.el
@@ -157,50 +157,64 @@ This space is used to display markers."
   :group 'ebrowse)
 
 
-(defface ebrowse-tree-mark-face
+(defface ebrowse-tree-mark
   '((((min-colors 88)) (:foreground "red1"))
     (t (:foreground "red")))
   "*The face used for the mark character in the tree."
   :group 'ebrowse-faces)
+;; backward-compatibility alias
+(put 'ebrowse-tree-mark-face 'face-alias 'ebrowse-tree-mark)
 
 
-(defface ebrowse-root-class-face
+(defface ebrowse-root-class
   '((((min-colors 88)) (:weight bold :foreground "blue1"))
     (t (:weight bold :foreground "blue")))
   "*The face used for root classes in the tree."
   :group 'ebrowse-faces)
+;; backward-compatibility alias
+(put 'ebrowse-root-class-face 'face-alias 'ebrowse-root-class)
 
 
-(defface ebrowse-file-name-face
+(defface ebrowse-file-name
   '((t (:italic t)))
   "*The face for filenames displayed in the tree."
   :group 'ebrowse-faces)
+;; backward-compatibility alias
+(put 'ebrowse-file-name-face 'face-alias 'ebrowse-file-name)
 
 
-(defface ebrowse-default-face
+(defface ebrowse-default
   '((t nil))
   "*Face for everything else in the tree not having other faces."
   :group 'ebrowse-faces)
+;; backward-compatibility alias
+(put 'ebrowse-default-face 'face-alias 'ebrowse-default)
 
 
-(defface ebrowse-member-attribute-face
+(defface ebrowse-member-attribute
   '((((min-colors 88)) (:foreground "red1"))
     (t (:foreground "red")))
   "*Face used to display member attributes."
   :group 'ebrowse-faces)
+;; backward-compatibility alias
+(put 'ebrowse-member-attribute-face 'face-alias 'ebrowse-member-attribute)
 
 
-(defface ebrowse-member-class-face
+(defface ebrowse-member-class
   '((t (:foreground "purple")))
   "*Face used to display the class title in member buffers."
   :group 'ebrowse-faces)
+;; backward-compatibility alias
+(put 'ebrowse-member-class-face 'face-alias 'ebrowse-member-class)
 
 
-(defface ebrowse-progress-face
+(defface ebrowse-progress
   '((((min-colors 88)) (:background "blue1"))
     (t (:background "blue")))
   "*Face for progress indicator."
   :group 'ebrowse-faces)
+;; backward-compatibility alias
+(put 'ebrowse-progress-face 'face-alias 'ebrowse-progress)
 
 
 
@@ -883,7 +897,7 @@ this is the first progress message displayed."
     (message (concat title ": "
                      (propertize (make-string ebrowse-n-boxes
                                               (if (display-color-p) ?\  ?+))
-                                 'face 'ebrowse-progress-face)))))
+                                 'face 'ebrowse-progress)))))
 
 
 ;;; Reading a tree from disk
@@ -1310,7 +1324,7 @@ With PREFIX, insert that many filenames."
                              (ebrowse-ts-class tree))
                             "unknown")
                     ")"))
-          (ebrowse-set-face start (point) 'ebrowse-file-name-face)
+          (ebrowse-set-face start (point) 'ebrowse-file-name)
           (beginning-of-line)
           (forward-line 1))))))
 
@@ -1828,7 +1842,7 @@ TREE denotes the class shown."
    start end
    `(mouse-face highlight ebrowse-what mark ebrowse-tree ,tree
                 help-echo "double-mouse-1: mark/unmark"))
-  (ebrowse-set-face start end 'ebrowse-tree-mark-face))
+  (ebrowse-set-face start end 'ebrowse-tree-mark))
 
 
 (defun* ebrowse-draw-tree-fn (&aux stack1 stack2 start)
@@ -1855,8 +1869,8 @@ This function may look weird, but this is faster than recursion."
           (when (ebrowse-template-p class)
             (insert "<>"))
           (ebrowse-set-face start (point) (if (zerop level)
-                                              'ebrowse-root-class-face
-                                            'ebrowse-default-face))
+                                              'ebrowse-root-class
+                                            'ebrowse-default))
           (setf start-of-class-name start
                 end-of-class-name (point))
           ;; If filenames are to be displayed...
@@ -1867,7 +1881,7 @@ This function may look weird, but this is faster than recursion."
                     (or (ebrowse-cs-file class)
                         "unknown")
                     ")")
-            (ebrowse-set-face start (point) 'ebrowse-file-name-face))
+            (ebrowse-set-face start (point) 'ebrowse-file-name))
           (ebrowse-set-mark-props start-of-line (1+ start-of-line) tree)
           (add-text-properties
            start-of-class-name end-of-class-name
@@ -2694,7 +2708,7 @@ the class cursor is on."
       (insert "<>"))
     (setq class-name-end (point))
     (insert ":\n\n")
-    (ebrowse-set-face start (point) 'ebrowse-member-class-face)
+    (ebrowse-set-face start (point) 'ebrowse-member-class)
     (add-text-properties
      class-name-start class-name-end
      '(ebrowse-what class-name
@@ -2810,7 +2824,7 @@ TREE is the class tree of MEMBER-LIST."
             (ebrowse-draw-member-attributes member-struc)
             (insert ">")
             (ebrowse-set-face start (point)
-                              'ebrowse-member-attribute-face)))
+                              'ebrowse-member-attribute)))
         (insert " ")
         (ebrowse-draw-member-regexp member-struc))))
   (insert "\n")
@@ -2841,7 +2855,7 @@ TREE is the class tree in which the members are found."
             (ebrowse-draw-member-attributes member)
             (insert "> ")
             (ebrowse-set-face start-of-entry (point)
-                              'ebrowse-member-attribute-face))
+                              'ebrowse-member-attribute))
           ;; insert member name truncated to column width
           (setq start-of-name (point))
           (insert (substring name 0
diff --git a/lisp/progmodes/flymake.el b/lisp/progmodes/flymake.el
index 28a6aae2435..c47f2e34cd2 100644
--- a/lisp/progmodes/flymake.el
+++ b/lisp/progmodes/flymake.el
@@ -704,7 +704,7 @@ It's flymake process filter."
   (nth 1 err-info))
 
 (defvar flymake-new-err-info nil
-  "Same as 'flymake-err-info', effective when a syntax check is in progress.")
+  "Same as `flymake-err-info', effective when a syntax check is in progress.")
 
 (make-variable-buffer-local 'flymake-new-err-info)
 
@@ -839,19 +839,23 @@ Return t if it has at least one flymake overlay, nil if no overlay."
       (setq ov (cdr ov)))
     has-flymake-overlays))
 
-(defface flymake-errline-face
+(defface flymake-errline
   ;;+   '((((class color)) (:foreground "OrangeRed" :bold t :underline t))
   ;;+   '((((class color)) (:underline "OrangeRed"))
   '((((class color)) (:background "LightPink"))
     (t (:bold t)))
   "Face used for marking error lines."
   :group 'flymake)
+;; backward-compatibility alias
+(put 'flymake-errline-face 'face-alias 'flymake-errline)
 
-(defface flymake-warnline-face
+(defface flymake-warnline
   '((((class color)) (:background "LightBlue2"))
     (t (:bold t)))
   "Face used for marking warning lines."
   :group 'flymake)
+;; backward-compatibility alias
+(put 'flymake-warnline-face 'face-alias 'flymake-warnline)
 
 (defun flymake-highlight-line (line-no line-err-info-list)
   "Highlight line LINE-NO in current buffer.
@@ -886,8 +890,8 @@ Perhaps use text from LINE-ERR-INFO-ILST to enhance highlighting."
       (setq end (point)))
 
     (if (> (flymake-get-line-err-count line-err-info-list "e") 0)
-        (setq face 'flymake-errline-face)
-      (setq face 'flymake-warnline-face))
+        (setq face 'flymake-errline)
+      (setq face 'flymake-warnline))
 
     (flymake-make-overlay beg end tooltip-text face nil)))
 
@@ -1312,7 +1316,7 @@ Return first 'INCLUDE-DIRS/REL-FILE-NAME' that exists,  or just REL-FILE-NAME if
         (flymake-start-syntax-check buffer)))))
 
 (defun flymake-start-syntax-check-for-current-buffer ()
-  "Run 'flymake-start-syntax-check' for current buffer if it isn't already running."
+  "Run `flymake-start-syntax-check' for current buffer if it isn't already running."
   (interactive)
   (flymake-start-syntax-check (current-buffer)))
 
@@ -1655,7 +1659,7 @@ With arg, turn Flymake mode on if and only if arg is positive."
     temp-source-file-name))
 
 (defun flymake-simple-cleanup (buffer)
-  "Do cleanup after 'flymake-init-create-temp-buffer-copy'.
+  "Do cleanup after `flymake-init-create-temp-buffer-copy'.
 Delete temp file."
   (let* ((temp-source-file-name (flymake-get-buffer-value buffer "temp-source-file-name")))
     (flymake-safe-delete-file temp-source-file-name)
diff --git a/lisp/progmodes/gdb-ui.el b/lisp/progmodes/gdb-ui.el
index a9274cfcae7..3a34a621fc6 100644
--- a/lisp/progmodes/gdb-ui.el
+++ b/lisp/progmodes/gdb-ui.el
@@ -250,7 +250,7 @@ Also display the main routine in the disassembly buffer if present."
      (let ((string (buffer-string)))
        ;; remove newline for gud-tooltip-echo-area
        (substring string 0 (- (length string) 1))))
-   gud-tooltip-echo-area))
+   (or gud-tooltip-echo-area tooltip-use-echo-area)))
 
 ;; If expr is a macro for a function don't print because of possible dangerous
 ;; side-effects. Also printing a function within a tooltip generates an
@@ -994,24 +994,24 @@ sink to `user' in `gdb-stopping', that is fine."
 This begins the collection of output from the current command if that
 happens to be appropriate."
   (unless gdb-pending-triggers
-        (gdb-get-selected-frame)
-        (gdb-invalidate-frames)
-        (gdb-invalidate-breakpoints)
-        ;; Do this through gdb-get-selected-frame -> gdb-frame-handler
-        ;; so gdb-frame-address is updated.
-        ;; (gdb-invalidate-assembler)
-        (gdb-invalidate-registers)
-        (gdb-invalidate-memory)
-        (gdb-invalidate-locals)
-        (gdb-invalidate-threads)
-        (unless (eq system-type 'darwin) ;Breaks on Darwin's GDB-5.3.
-          ;; FIXME: with GDB-6 on Darwin, this might very well work.
-          ;; only needed/used with speedbar/watch expressions
-          (when (and (boundp 'speedbar-frame) (frame-live-p speedbar-frame))
-            (setq gdb-var-changed t)    ; force update
-            (dolist (var gdb-var-list)
-              (setcar (nthcdr 5 var) nil))
-            (gdb-var-update))))
+    (gdb-get-selected-frame)
+    (gdb-invalidate-frames)
+    (gdb-invalidate-breakpoints)
+    ;; Do this through gdb-get-selected-frame -> gdb-frame-handler
+    ;; so gdb-frame-address is updated.
+    ;; (gdb-invalidate-assembler)
+    (gdb-invalidate-registers)
+    (gdb-invalidate-memory)
+    (gdb-invalidate-locals)
+    (gdb-invalidate-threads)
+    (unless (eq system-type 'darwin) ;Breaks on Darwin's GDB-5.3.
+      ;; FIXME: with GDB-6 on Darwin, this might very well work.
+      ;; only needed/used with speedbar/watch expressions
+      (when (and (boundp 'speedbar-frame) (frame-live-p speedbar-frame))
+        (setq gdb-var-changed t)    ; force update
+        (dolist (var gdb-var-list)
+          (setcar (nthcdr 5 var) nil))
+        (gdb-var-update))))
   (let ((sink gdb-output-sink))
     (cond
      ((eq sink 'user) t)
@@ -1695,7 +1695,9 @@ static char *magick[] = {
   (setq buffer-read-only t)
   (use-local-map gdb-registers-mode-map)
   (run-mode-hooks 'gdb-registers-mode-hook)
-  'gdb-invalidate-registers)
+  (if (with-current-buffer gud-comint-buffer (eq gud-minor-mode 'gdba))
+      'gdb-invalidate-registers
+    'gdbmi-invalidate-registers))
 
 (defun gdb-registers-buffer-name ()
   (with-current-buffer gud-comint-buffer
@@ -2058,12 +2060,12 @@ corresponding to the mode line clicked."
         (replace-match " (array);\n" nil nil))))
   (let ((buf (gdb-get-buffer 'gdb-locals-buffer)))
     (and buf (with-current-buffer buf
-               (let ((p (point))
+               (let ((p (window-point (get-buffer-window buf 0)))
                      (buffer-read-only nil))
-                 (delete-region (point-min) (point-max))
+                 (erase-buffer)
                  (insert-buffer-substring (gdb-get-create-buffer
                                            'gdb-partial-output-buffer))
-                 (goto-char p)))))
+                (set-window-point (get-buffer-window buf 0) p)))))
   (run-hooks 'gdb-info-locals-hook))
 
 (defun gdb-info-locals-custom ()
@@ -2172,18 +2174,18 @@ corresponding to the mode line clicked."
 (let ((menu (make-sparse-keymap "GDB-UI")))
   (define-key gud-menu-map [ui]
     `(menu-item "GDB-UI" ,menu :visible (eq gud-minor-mode 'gdba)))
-  (define-key menu [gdb-restore-windows]
-  '(menu-item "Restore Window Layout" gdb-restore-windows
-              :help "Restore standard layout for debug session."))
-  (define-key menu [gdb-many-windows]
-  '(menu-item "Display Other Windows" gdb-many-windows
-              :help "Toggle display of locals, stack and breakpoint information"
-              :button (:toggle . gdb-many-windows)))
   (define-key menu [gdb-use-inferior-io]
     (menu-bar-make-toggle toggle-gdb-use-inferior-io-buffer
                           gdb-use-inferior-io-buffer
      "Separate inferior IO" "Use separate IO %s"
-     "Toggle separate IO for inferior.")))
+     "Toggle separate IO for inferior."))
+  (define-key menu [gdb-many-windows]
+  '(menu-item "Display Other Windows" gdb-many-windows
+              :help "Toggle display of locals, stack and breakpoint information"
+              :button (:toggle . gdb-many-windows)))
+  (define-key menu [gdb-restore-windows]
+  '(menu-item "Restore Window Layout" gdb-restore-windows
+              :help "Restore standard layout for debug session.")))
 
 (defadvice toggle-gdb-use-inferior-io-buffer (after gdb-kill-io-buffer activate)
   (unless gdb-use-inferior-io-buffer
@@ -2341,6 +2343,8 @@ Add directory to search path for source files using the GDB command, dir."))
 (add-hook 'find-file-hook 'gdb-find-file-hook)
 
 (defun gdb-find-file-hook ()
+"Set up buffer for debugging if file is part of the source code
+of the current session."
   (if (and (not gdb-find-file-unhook)
            ;; in case gud or gdb-ui is just loaded
            gud-comint-buffer
diff --git a/lisp/progmodes/gud.el b/lisp/progmodes/gud.el
index 31b9e7d7204..7d4fc00cd56 100644
--- a/lisp/progmodes/gud.el
+++ b/lisp/progmodes/gud.el
@@ -140,6 +140,9 @@ Used to grey out relevant togolbar icons.")
                   :enable (and (not gud-running)
                                (memq gud-minor-mode
                                      '(gdbmi gdba gdb dbx xdb jdb pdb bashdb))))
+    ([print*]   menu-item "Print Dereference" gud-pstar
+                     :enable (and (not gud-running)
+                                  (memq gud-minor-mode '(gdbmi gdba gdb))))
     ([print]    menu-item "Print Expression" gud-print
                      :enable (not gud-running))
     ([watch]    menu-item "Watch Expression" gud-watch
@@ -183,18 +186,19 @@ Used to grey out relevant togolbar icons.")
         (dolist (x '((gud-break . "gud-break")
                      (gud-remove . "gud-remove")
                      (gud-print . "gud-print")
+                     (gud-pstar . "gud-pstar")
                      (gud-watch . "gud-watch")
-                     (gud-run . "gud-run")
-                     (gud-until . "gud-until")
                      (gud-cont . "gud-cont")
+                     (gud-until . "gud-until")
+                     (gud-finish . "gud-finish")
+                     (gud-run . "gud-run")
                      ;; gud-s, gud-si etc. instead of gud-step,
                      ;; gud-stepi, to avoid file-name clashes on DOS
                      ;; 8+3 filesystems.
-                     (gud-step . "gud-s")
                      (gud-next . "gud-n")
-                     (gud-finish . "gud-finish")
-                     (gud-stepi . "gud-si")
+                     (gud-step . "gud-s")
                      (gud-nexti . "gud-ni")
+                     (gud-stepi . "gud-si")
                      (gud-up . "gud-up")
                      (gud-down . "gud-down")
                      (gud-goto-info . "info"))
@@ -580,6 +584,8 @@ and source-file directory for your debugger."
   (gud-def gud-up     "up %p"        "<" "Up N stack frames (numeric arg).")
   (gud-def gud-down   "down %p"      ">" "Down N stack frames (numeric arg).")
   (gud-def gud-print  "print %e"     "\C-p" "Evaluate C expression at point.")
+  (gud-def gud-pstar  "print* %e"    nil
+           "Evaluate C dereferenced pointer expression at point.")
   (gud-def gud-until  "until %l"     "\C-u" "Continue to current line.")
   (gud-def gud-run    "run"          nil    "Run the program.")
 
@@ -1214,7 +1220,7 @@ containing the executable being debugged."
 The directory containing FILE becomes the initial working directory
 and source-file directory for your debugger.
 
-You can set the variable 'gud-xdb-directories' to a list of program source
+You can set the variable `gud-xdb-directories' to a list of program source
 directories if your program contains sources from more than one directory."
   (interactive (list (gud-query-cmdline 'xdb)))
 
@@ -3133,8 +3139,6 @@ only tooltips in the buffer containing the overlay arrow."
                                 'gud-tooltip-modes "22.1")
 (define-obsolete-variable-alias 'tooltip-gud-display
                                 'gud-tooltip-display "22.1")
-(define-obsolete-variable-alias 'tooltip-use-echo-area
-                                'gud-tooltip-echo-area "22.1")
 
 ;;; Reacting on mouse movements
 
@@ -3236,7 +3240,7 @@ This event can be examined by forms in GUD-TOOLTIP-DISPLAY.")
 
 ; This will only display data that comes in one chunk.
 ; Larger arrays (say 400 elements) are displayed in
-; the tootip incompletely and spill over into the gud buffer.
+; the tooltip incompletely and spill over into the gud buffer.
 ; Switching the process-filter creates timing problems and
 ; it may be difficult to do better. Using annotations as in
 ; gdb-ui.el gets round this problem.
@@ -3244,7 +3248,7 @@ This event can be examined by forms in GUD-TOOLTIP-DISPLAY.")
   "Process debugger output and show it in a tooltip window."
   (set-process-filter process gud-tooltip-original-filter)
   (tooltip-show (tooltip-strip-prompt process output)
-                gud-tooltip-echo-area))
+                (or gud-tooltip-echo-area tooltip-use-echo-area)))
 
 (defun gud-tooltip-print-command (expr)
   "Return a suitable command to print the expression EXPR.
@@ -3289,7 +3293,9 @@ This function must return nil if it doesn't handle EVENT."
                                                 (cddr mouse))))
                   (let ((define-elt (assoc expr gdb-define-alist)))
                     (unless (null define-elt)
-                      (tooltip-show (cdr define-elt))
+                      (tooltip-show
+                       (cdr define-elt)
+                       (or gud-tooltip-echo-area tooltip-use-echo-area))
                       expr))))
             (let ((cmd (gud-tooltip-print-command expr)))
               (when (and gud-tooltip-mode (eq gud-minor-mode 'gdb))
diff --git a/lisp/progmodes/idlw-help.el b/lisp/progmodes/idlw-help.el
index 6c2cb00bbde..ba31e6e0ef8 100644
--- a/lisp/progmodes/idlw-help.el
+++ b/lisp/progmodes/idlw-help.el
@@ -182,12 +182,14 @@ support."
   :group 'idlwave-online-help
   :type 'string)
 
-(defface idlwave-help-link-face
+(defface idlwave-help-link
   '((((min-colors 88) (class color)) (:foreground "Blue1"))
     (((class color)) (:foreground "Blue"))
     (t (:weight bold)))
   "Face for highlighting links into IDLWAVE online help."
   :group 'idlwave-online-help)
+;; backward-compatibility alias
+(put 'idlwave-help-link-face 'face-alias 'idlwave-help-link)
 
 (defvar idlwave-help-activate-links-aggressively nil
   "Obsolete variable.")
@@ -586,12 +588,12 @@ Needs additional info stored in global `idlwave-completion-help-info'."
 (defun idlwave-highlight-linked-completions ()
   "Highlight all completions for which help is available and attach link.
 Those words in `idlwave-completion-help-links' have links.  The
-`idlwave-help-link-face' face is used for this."
+`idlwave-help-link' face is used for this."
   (if idlwave-highlight-help-links-in-completion
       (with-current-buffer (get-buffer "*Completions*")
         (save-excursion
           (let* ((case-fold-search t)
-                 (props (list 'face 'idlwave-help-link-face))
+                 (props (list 'face 'idlwave-help-link))
                  (info idlwave-completion-help-info) ; global passed in
                  (what (nth 0 info))  ; what was completed, or a func
                  (class (nth 3 info)) ; any class
diff --git a/lisp/progmodes/idlw-shell.el b/lisp/progmodes/idlw-shell.el
index e804b9f8d50..04e6a28ee40 100644
--- a/lisp/progmodes/idlw-shell.el
+++ b/lisp/progmodes/idlw-shell.el
@@ -510,40 +510,44 @@ t          Glyph when possible, otherwise face (same effect as 'glyph)."
 (defvar idlwave-shell-use-breakpoint-glyph t
   "Obsolete variable.  See `idlwave-shell-mark-breakpoints.")
 
-(defcustom idlwave-shell-breakpoint-face 'idlwave-shell-bp-face
+(defcustom idlwave-shell-breakpoint-face 'idlwave-shell-bp
   "*The face for breakpoint lines in the source code.
 Allows you to choose the font, color and other properties for
 lines which have a breakpoint.  See also `idlwave-shell-mark-breakpoints'."
   :group 'idlwave-shell-highlighting-and-faces
   :type 'symbol)
 
-(if idlwave-shell-have-new-custom
-    ;; We have the new customize - use it to define a customizable face
-    (defface idlwave-shell-bp-face
-      '((((class color)) (:foreground "Black" :background "Pink"))
-        (t (:underline t)))
-      "Face for highlighting lines with breakpoints."
-      :group 'idlwave-shell-highlighting-and-faces)
-  ;; Just copy the underline face to be on the safe side.
-  (copy-face 'underline 'idlwave-shell-bp-face))
+(if (not idlwave-shell-have-new-custom)
+    ;; Just copy the underline face to be on the safe side.
+    (copy-face 'underline 'idlwave-shell-bp)
+  ;; We have the new customize - use it to define a customizable face
+  (defface idlwave-shell-bp
+    '((((class color)) (:foreground "Black" :background "Pink"))
+      (t (:underline t)))
+    "Face for highlighting lines with breakpoints."
+    :group 'idlwave-shell-highlighting-and-faces)
+  ;; backward-compatibility alias
+  (put 'idlwave-shell-bp-face 'face-alias 'idlwave-shell-bp))
 
 (defcustom idlwave-shell-disabled-breakpoint-face
-  'idlwave-shell-disabled-bp-face
+  'idlwave-shell-disabled-bp
   "*The face for disabled breakpoint lines in the source code.
 Allows you to choose the font, color and other properties for
 lines which have a breakpoint.  See also `idlwave-shell-mark-breakpoints'."
   :group 'idlwave-shell-highlighting-and-faces
   :type 'symbol)
 
-(if idlwave-shell-have-new-custom
-    ;; We have the new customize - use it to define a customizable face
-    (defface idlwave-shell-disabled-bp-face
-      '((((class color)) (:foreground "Black" :background "gray"))
-        (t (:underline t)))
-      "Face for highlighting lines with breakpoints."
-      :group 'idlwave-shell-highlighting-and-faces)
-  ;; Just copy the underline face to be on the safe side.
-  (copy-face 'underline 'idlwave-shell-disabled-bp-face))
+(if (not idlwave-shell-have-new-custom)
+    ;; Just copy the underline face to be on the safe side.
+    (copy-face 'underline 'idlwave-shell-disabled-bp)
+  ;; We have the new customize - use it to define a customizable face
+  (defface idlwave-shell-disabled-bp
+    '((((class color)) (:foreground "Black" :background "gray"))
+      (t (:underline t)))
+    "Face for highlighting lines with breakpoints."
+    :group 'idlwave-shell-highlighting-and-faces)
+  ;; backward-compatibility alias
+  (put 'idlwave-shell-disabled-bp-face 'face-alias 'idlwave-shell-disabled-bp))
 
 
 (defcustom idlwave-shell-expression-face 'secondary-selection
@@ -2734,7 +2738,7 @@ Runs to the last statement and then steps 1 statement.  Use the .out command."
              (funcall orig-func cur-line orig-bp-line)
              (or (not bp-line) (funcall closer-func cur-line bp-line)))
             (setq bp-line cur-line))))
-    (unless bp-line (error "No further breakpoints."))
+    (unless bp-line (error "No further breakpoints"))
     (goto-line bp-line)))
 
 ;; Examine Commands ------------------------------------------------------
diff --git a/lisp/progmodes/idlwave.el b/lisp/progmodes/idlwave.el
index 6bd7e0eaced..820e619f331 100644
--- a/lisp/progmodes/idlwave.el
+++ b/lisp/progmodes/idlwave.el
@@ -70,7 +70,7 @@
 ;; of the documentation is available from the maintainers webpage (see
 ;; SOURCE).
 ;;
-;; 
+;;
 ;; ACKNOWLEDGMENTS
 ;; ===============
 ;;
@@ -120,7 +120,7 @@
 ;;   up inserting the character that expanded the abbrev after moving
 ;;   point backward, e.g., "\cl" expanded with a space becomes
 ;;   "LONG( )" with point before the close paren.  This is solved by
-;;   using a temporary function in `post-command-hook' - not pretty, 
+;;   using a temporary function in `post-command-hook' - not pretty,
 ;;   but it works.
 ;;
 ;;   Tabs and spaces are treated equally as whitespace when filling a
@@ -166,13 +166,13 @@
       nil ;; We've got what we needed
     ;; We have the old or no custom-library, hack around it!
     (defmacro defgroup (&rest args) nil)
-    (defmacro defcustom (var value doc &rest args) 
+    (defmacro defcustom (var value doc &rest args)
       `(defvar ,var ,value ,doc))))
 
 (defgroup idlwave nil
   "Major mode for editing IDL .pro files"
   :tag "IDLWAVE"
-  :link '(url-link :tag "Home Page" 
+  :link '(url-link :tag "Home Page"
                    "http://idlwave.org")
   :link '(emacs-commentary-link :tag "Commentary in idlw-shell.el"
                                 "idlw-shell.el")
@@ -286,8 +286,8 @@ extends to the end of the match for the regular expression."
 
 (defcustom idlwave-auto-fill-split-string t
   "*If non-nil then auto fill will split strings with the IDL `+' operator.
-When the line end falls within a string, string concatenation with the 
-'+' operator will be used to distribute a long string over lines.  
+When the line end falls within a string, string concatenation with the
+'+' operator will be used to distribute a long string over lines.
 If nil and a string is split then a terminal beep and warning are issued.
 
 This variable is ignored when `idlwave-fill-comment-line-only' is
@@ -351,7 +351,7 @@ usually a good idea.."
 Initializing the routine info can take long, in particular if a large
 library catalog is involved.  When Emacs is idle for more than the number
 of seconds specified by this variable, it starts the initialization.
-The process is split into five steps, in order to keep possible work 
+The process is split into five steps, in order to keep possible work
 interruption as short as possible.  If one of the steps finishes, and no
 user input has arrived in the mean time, initialization proceeds immediately
 to the next step.
@@ -403,7 +403,7 @@ t         All available
                (const :tag "When saving a buffer" save-buffer)
                (const :tag "After a buffer was killed" kill-buffer)
                (const :tag "After a buffer was compiled successfully, update shell info" compile-buffer))))
-               
+
 (defcustom idlwave-rinfo-max-source-lines 5
   "*Maximum number of source files displayed in the Routine Info window.
 When an integer, it is the maximum number of source files displayed.
@@ -436,7 +436,7 @@ value of `!DIR'.  See also `idlwave-library-path'."
   :group 'idlwave-routine-info
   :type 'directory)
 
-(defcustom idlwave-config-directory 
+(defcustom idlwave-config-directory
   (convert-standard-filename "~/.idlwave")
   "*Directory for configuration files and user-library catalog."
   :group 'idlwave-routine-info
@@ -451,7 +451,7 @@ value of `!DIR'.  See also `idlwave-library-path'."
 (defcustom idlwave-special-lib-alist nil
   "Alist of regular expressions matching special library directories.
 When listing routine source locations, IDLWAVE gives a short hint where
-the file defining the routine is located.  By default it lists `SystemLib' 
+the file defining the routine is located.  By default it lists `SystemLib'
 for routines in the system library `!DIR/lib' and `Library' for anything
 else.  This variable can define additional types.  The car of each entry
 is a regular expression matching the file name (they normally will match
@@ -462,7 +462,7 @@ chars are allowed."
           (cons regexp string)))
 
 (defcustom idlwave-auto-write-paths t
-  "Write out path (!PATH) and system directory (!DIR) info automatically.  
+  "Write out path (!PATH) and system directory (!DIR) info automatically.
 Path info is needed to locate library catalog files.  If non-nil,
 whenever the path-list changes as a result of shell-query, etc., it is
 written to file.  Otherwise, the menu option \"Write Paths\" can be
@@ -493,7 +493,7 @@ used to force a write."
 This variable determines the case (UPPER/lower/Capitalized...) of
 words inserted into the buffer by completion.  The preferred case can
 be specified separately for routine names, keywords, classes and
-methods. 
+methods.
 This alist should therefore have entries for `routine' (normal
 functions and procedures, i.e. non-methods), `keyword', `class', and
 `method'.  Plausible values are
@@ -580,7 +580,7 @@ certain methods this assumption is almost always true.  The methods
 for which to assume this can be set here."
   :group 'idlwave-routine-info
   :type '(repeat (regexp :tag "Match method:")))
-  
+
 
 (defcustom idlwave-completion-show-classes 1
   "*Number of classes to show when completing object methods and keywords.
@@ -645,7 +645,7 @@ should contain at least two elements: (method-default . VALUE) and
 specify if the class should be found during method and keyword
 completion, respectively.
 
-The alist may have additional entries specifying exceptions from the 
+The alist may have additional entries specifying exceptions from the
 keyword completion rule for specific methods, like INIT or
 GETPROPERTY.  In order to turn on class specification for the INIT
 method, add an entry (\"INIT\" . t).  The method name must be ALL-CAPS."
@@ -669,7 +669,7 @@ particular object method call.  This happens during the commands
 value of the variable `idlwave-query-class'.
 
 When you specify a class, this information can be stored as a text
-property on the `->' arrow in the source code, so that during the same 
+property on the `->' arrow in the source code, so that during the same
 editing session, IDLWAVE will not have to ask again.  When this
 variable is non-nil, IDLWAVE will store and reuse the class information.
 The class stored can be checked and removed with `\\[idlwave-routine-info]'
@@ -1049,7 +1049,7 @@ IDL process is made."
   :group 'idlwave-misc
   :type 'boolean)
 
-(defcustom idlwave-default-font-lock-items 
+(defcustom idlwave-default-font-lock-items
   '(pros-and-functions batch-files idlwave-idl-keywords label goto
                        common-blocks class-arrows)
   "Items which should be fontified on the default fontification level 2.
@@ -1111,25 +1111,25 @@ As a user, you should not set this to t.")
 ;;; and Carsten Dominik...
 
 ;; The following are the reserved words in IDL.  Maybe we should
-;; highlight some more stuff as well?       
+;; highlight some more stuff as well?
 ;; Procedure declarations.  Fontify keyword plus procedure name.
 (defvar idlwave-idl-keywords
-  ;; To update this regexp, update the list of keywords and 
+  ;; To update this regexp, update the list of keywords and
   ;; evaluate the form.
-  ;;    (insert 
+  ;;    (insert
   ;;     (prin1-to-string
-  ;;      (concat 
+  ;;      (concat
   ;;       "\\<\\("
-  ;;       (regexp-opt 
+  ;;       (regexp-opt
   ;;        '("||" "&&" "and" "or" "xor" "not"
-  ;;          "eq" "ge" "gt" "le" "lt" "ne" 
+  ;;          "eq" "ge" "gt" "le" "lt" "ne"
   ;;          "for" "do" "endfor"
-  ;;          "if" "then" "endif" "else" "endelse" 
+  ;;          "if" "then" "endif" "else" "endelse"
   ;;          "case" "of" "endcase"
   ;;          "switch" "break" "continue" "endswitch"
   ;;          "begin" "end"
   ;;          "repeat" "until" "endrep"
-  ;;          "while" "endwhile" 
+  ;;          "while" "endwhile"
   ;;          "goto" "return"
   ;;          "inherits" "mod"
   ;;          "compile_opt" "forward_function"
@@ -1152,7 +1152,7 @@ As a user, you should not set this to t.")
           (2 font-lock-reference-face nil t)      ; block name
           (font-lock-match-c++-style-declaration-item-and-skip-to-next
            ;; Start with point after block name and comma
-           (goto-char (match-end 0))  ; needed for XEmacs, could be nil 
+           (goto-char (match-end 0))  ; needed for XEmacs, could be nil
            nil
            (1 font-lock-variable-name-face)       ; variable names
            )))
@@ -1207,7 +1207,7 @@ As a user, you should not set this to t.")
        ;; All operators (not used because too noisy)
        (all-operators
         '("[-*^#+<>/]" (0 font-lock-keyword-face)))
-        
+
        ;; Arrows with text property `idlwave-class'
        (class-arrows
         '(idlwave-match-class-arrows (0 idlwave-class-arrow-face))))
@@ -1244,14 +1244,14 @@ As a user, you should not set this to t.")
 
 (defvar idlwave-font-lock-defaults
   '((idlwave-font-lock-keywords
-     idlwave-font-lock-keywords-1 
+     idlwave-font-lock-keywords-1
      idlwave-font-lock-keywords-2
      idlwave-font-lock-keywords-3)
-    nil t 
-    ((?$ . "w") (?_ . "w") (?. . "w") (?| . "w") (?& . "w")) 
+    nil t
+    ((?$ . "w") (?_ . "w") (?. . "w") (?| . "w") (?& . "w"))
     beginning-of-line))
 
-(put 'idlwave-mode 'font-lock-defaults 
+(put 'idlwave-mode 'font-lock-defaults
      idlwave-font-lock-defaults) ; XEmacs
 
 (defconst idlwave-comment-line-start-skip "^[ \t]*;"
@@ -1259,7 +1259,7 @@ As a user, you should not set this to t.")
 That is the _beginning_ of a line containing a comment delimiter `;' preceded
 only by whitespace.")
 
-(defconst idlwave-begin-block-reg 
+(defconst idlwave-begin-block-reg
   "\\<\\(pro\\|function\\|begin\\|case\\|switch\\)\\>"
   "Regular expression to find the beginning of a block. The case does
 not matter. The search skips matches in comments.")
@@ -1336,17 +1336,17 @@ blocks starting with a BEGIN statement.  The matches must have associations
    '(goto . ("goto\\>" nil))
    '(case . ("case\\>" nil))
    '(switch . ("switch\\>" nil))
-   (cons 'call (list (concat "\\(" idlwave-variable "\\) *= *" 
+   (cons 'call (list (concat "\\(" idlwave-variable "\\) *= *"
                              "\\(" idlwave-method-call "\\s *\\)?"
                              idlwave-identifier
                              "\\s *(") nil))
-   (cons 'call (list (concat 
+   (cons 'call (list (concat
                       "\\(" idlwave-method-call "\\s *\\)?"
-                      idlwave-identifier 
+                      idlwave-identifier
                       "\\( *\\($\\|\\$\\)\\|\\s *,\\)") nil))
-   (cons 'assign (list (concat 
+   (cons 'assign (list (concat
                         "\\(" idlwave-variable "\\) *=") nil)))
-  
+
   "Associated list of statement matching regular expressions.
 Each regular expression matches the start of an IDL statement.  The
 first element of each association is a symbol giving the statement
@@ -1540,15 +1540,15 @@ Capitalize system variables - action only
          (not (equal idlwave-shell-debug-modifiers '())))
   ;; Bind the debug commands also with the special modifiers.
   (let ((shift (memq 'shift idlwave-shell-debug-modifiers))
-        (mods-noshift (delq 'shift 
+        (mods-noshift (delq 'shift
                             (copy-sequence idlwave-shell-debug-modifiers))))
-    (define-key idlwave-mode-map 
+    (define-key idlwave-mode-map
       (vector (append mods-noshift (list (if shift ?C ?c))))
       'idlwave-shell-save-and-run)
-    (define-key idlwave-mode-map 
+    (define-key idlwave-mode-map
       (vector (append mods-noshift (list (if shift ?B ?b))))
       'idlwave-shell-break-here)
-    (define-key idlwave-mode-map 
+    (define-key idlwave-mode-map
       (vector (append mods-noshift (list (if shift ?E ?e))))
       'idlwave-shell-run-region)))
 (define-key idlwave-mode-map "\C-c\C-d\C-c" 'idlwave-shell-save-and-run)
@@ -1584,7 +1584,7 @@ Capitalize system variables - action only
 (define-key idlwave-mode-map "\M-\C-i" 'idlwave-complete)
 (define-key idlwave-mode-map "\C-c\C-i" 'idlwave-update-routine-info)
 (define-key idlwave-mode-map "\C-c="    'idlwave-resolve)
-(define-key idlwave-mode-map 
+(define-key idlwave-mode-map
   (if (featurep 'xemacs) [(shift button3)] [(shift mouse-3)])
   'idlwave-mouse-context-help)
 
@@ -1595,7 +1595,7 @@ Capitalize system variables - action only
 ;                                                   (lambda (char) 0)))
 (idlwave-action-and-binding "<"  '(idlwave-surround -1 -1))
 ;; Binding works for both > and ->, by changing the length of the token.
-(idlwave-action-and-binding ">"  '(idlwave-surround -1 -1 '(?-) 1 
+(idlwave-action-and-binding ">"  '(idlwave-surround -1 -1 '(?-) 1
                                                     'idlwave-gtr-pad-hook))
 (idlwave-action-and-binding "->" '(idlwave-surround -1 -1 nil 2) t)
 (idlwave-action-and-binding ","  '(idlwave-surround 0 -1))
@@ -1629,7 +1629,7 @@ idlwave-mode-abbrev-table unless TABLE is non-nil."
       (error (apply 'define-abbrev args)))))
 
 (condition-case nil
-    (modify-syntax-entry (string-to-char idlwave-abbrev-start-char) 
+    (modify-syntax-entry (string-to-char idlwave-abbrev-start-char)
                          "w" idlwave-mode-syntax-table)
   (error nil))
 
@@ -1702,7 +1702,7 @@ idlwave-mode-abbrev-table unless TABLE is non-nil."
 (idlwave-define-abbrev "s"  "size()"       (idlwave-keyword-abbrev 1))
 (idlwave-define-abbrev "wi" "widget_info()" (idlwave-keyword-abbrev 1))
 (idlwave-define-abbrev "wc" "widget_control," (idlwave-keyword-abbrev 0))
-  
+
 ;; This section is reserved words only. (From IDL user manual)
 ;;
 (idlwave-define-abbrev "and"        "and"       (idlwave-keyword-abbrev 0 t) t)
@@ -1751,7 +1751,7 @@ idlwave-mode-abbrev-table unless TABLE is non-nil."
 (defvar imenu-extract-index-name-function)
 (defvar imenu-prev-index-position-function)
 ;; defined later - so just make the compiler hush
-(defvar idlwave-mode-menu)  
+(defvar idlwave-mode-menu)
 (defvar idlwave-mode-debug-menu)
 
 ;;;###autoload
@@ -1836,7 +1836,7 @@ The main features of this mode are
    \\i         IF statement template
    \\elif      IF-ELSE statement template
    \\b         BEGIN
-   
+
    For a full list, use \\[idlwave-list-abbrevs].  Some templates also
    have direct keybindings - see the list of keybindings below.
 
@@ -1878,26 +1878,26 @@ The main features of this mode are
 
   (interactive)
   (kill-all-local-variables)
-  
+
   (if idlwave-startup-message
       (message "Emacs IDLWAVE mode version %s." idlwave-mode-version))
   (setq idlwave-startup-message nil)
-  
+
   (setq local-abbrev-table idlwave-mode-abbrev-table)
   (set-syntax-table idlwave-mode-syntax-table)
-  
+
   (set (make-local-variable 'indent-line-function) 'idlwave-indent-and-action)
-  
+
   (make-local-variable idlwave-comment-indent-function)
   (set idlwave-comment-indent-function 'idlwave-comment-hook)
-  
+
   (set (make-local-variable 'comment-start-skip) ";+[ \t]*")
   (set (make-local-variable 'comment-start) ";")
   (set (make-local-variable 'require-final-newline) mode-require-final-newline)
   (set (make-local-variable 'abbrev-all-caps) t)
   (set (make-local-variable 'indent-tabs-mode) nil)
   (set (make-local-variable 'completion-ignore-case) t)
-  
+
   (use-local-map idlwave-mode-map)
 
   (when (featurep 'easymenu)
@@ -1907,11 +1907,11 @@ The main features of this mode are
   (setq mode-name "IDLWAVE")
   (setq major-mode 'idlwave-mode)
   (setq abbrev-mode t)
-  
+
   (set (make-local-variable idlwave-fill-function) 'idlwave-auto-fill)
   (setq comment-end "")
   (set (make-local-variable 'comment-multi-line) nil)
-  (set (make-local-variable 'paragraph-separate) 
+  (set (make-local-variable 'paragraph-separate)
        "[ \t\f]*$\\|[ \t]*;+[ \t]*$\\|;+[+=-_*]+$")
   (set (make-local-variable 'paragraph-start) "[ \t\f]\\|[ \t]*;+[ \t]")
   (set (make-local-variable 'paragraph-ignore-fill-prefix) nil)
@@ -1920,7 +1920,7 @@ The main features of this mode are
   ;; Set tag table list to use IDLTAGS as file name.
   (if (boundp 'tag-table-alist)
       (add-to-list 'tag-table-alist '("\\.pro$" . "IDLTAGS")))
-  
+
   ;; Font-lock additions - originally Phil Williams, then Ulrik Dickow
   ;; Following line is for Emacs - XEmacs uses the corresponding property
   ;; on the `idlwave-mode' symbol.
@@ -1961,18 +1961,18 @@ The main features of this mode are
   (unless idlwave-setup-done
     (if (not (file-directory-p idlwave-config-directory))
         (make-directory idlwave-config-directory))
-    (setq idlwave-user-catalog-file (expand-file-name 
-                                     idlwave-user-catalog-file 
+    (setq idlwave-user-catalog-file (expand-file-name
+                                     idlwave-user-catalog-file
                                      idlwave-config-directory)
-        idlwave-path-file (expand-file-name 
-                           idlwave-path-file 
+        idlwave-path-file (expand-file-name
+                           idlwave-path-file
                            idlwave-config-directory))
     (idlwave-read-paths)  ; we may need these early
     (setq idlwave-setup-done t)))
 
 ;;
 ;; Code Formatting ----------------------------------------------------
-;; 
+;;
 
 (defun idlwave-push-mark (&rest rest)
   "Push mark for compatibility with Emacs 18/19."
@@ -2121,7 +2121,7 @@ Also checks if the correct end statement has been used."
         (if (> end-pos eol-pos)
             (setq end-pos pos))
         (goto-char end-pos)
-        (setq end (buffer-substring 
+        (setq end (buffer-substring
                    (progn
                      (skip-chars-backward "a-zA-Z")
                      (point))
@@ -2143,7 +2143,7 @@ Also checks if the correct end statement has been used."
             (sit-for 1))
            (t
             (beep)
-            (message "Warning: Shouldn't this be \"%s\" instead of \"%s\"?" 
+            (message "Warning: Shouldn't this be \"%s\" instead of \"%s\"?"
                      end1 end)
             (sit-for 1))))))))
   ;;(delete-char 1))
@@ -2155,8 +2155,8 @@ Also checks if the correct end statement has been used."
        ((looking-at "pro\\|case\\|switch\\|function\\>")
         (assoc (downcase (match-string 0)) idlwave-block-matches))
        ((looking-at "begin\\>")
-        (let ((limit (save-excursion 
-                       (idlwave-beginning-of-statement) 
+        (let ((limit (save-excursion
+                       (idlwave-beginning-of-statement)
                        (point))))
           (cond
            ((re-search-backward ":[ \t]*\\=" limit t)
@@ -2184,9 +2184,9 @@ Also checks if the correct end statement has been used."
     (insert "end")
     (idlwave-show-begin)))
 
-(defun idlwave-gtr-pad-hook (char) 
+(defun idlwave-gtr-pad-hook (char)
   "Let the > symbol expand around -> if present.  The new token length
-is returned."  
+is returned."
   2)
 
 (defun idlwave-surround (&optional before after escape-chars length ec-hook)
@@ -2216,8 +2216,8 @@ return value."
     (let* ((length (or length 1)) ; establish a default for LENGTH
            (prev-char (char-after (- (point) (1+ length)))))
       (when (or (not (memq prev-char escape-chars))
-                (and (fboundp ec-hook) 
-                     (setq length 
+                (and (fboundp ec-hook)
+                     (setq length
                            (save-excursion (funcall ec-hook prev-char)))))
         (backward-char length)
         (save-restriction
@@ -2439,7 +2439,7 @@ Returns non-nil if successfull."
         (let ((eos (save-excursion
                      (idlwave-block-jump-out -1 'nomark)
                      (point))))
-          (if (setq status (idlwave-find-key 
+          (if (setq status (idlwave-find-key
                             idlwave-end-block-reg -1 'nomark eos))
               (idlwave-beginning-of-statement)
             (message "No nested block before beginning of containing block.")))
@@ -2447,7 +2447,7 @@ Returns non-nil if successfull."
       (let ((eos (save-excursion
                    (idlwave-block-jump-out 1 'nomark)
                    (point))))
-        (if (setq status (idlwave-find-key 
+        (if (setq status (idlwave-find-key
                           idlwave-begin-block-reg 1 'nomark eos))
             (idlwave-end-of-statement)
           (message "No nested block before end of containing block."))))
@@ -2461,7 +2461,7 @@ The marks are pushed."
         (here (point)))
     (goto-char (point-max))
     (if (re-search-backward idlwave-doclib-start nil t)
-        (progn 
+        (progn
           (setq beg (progn (beginning-of-line) (point)))
           (if (re-search-forward idlwave-doclib-end nil t)
               (progn
@@ -2495,7 +2495,7 @@ actual statement."
    ((eq major-mode 'idlwave-shell-mode)
     (if (re-search-backward idlwave-shell-prompt-pattern nil t)
         (goto-char (match-end 0))))
-   (t   
+   (t
     (if (save-excursion (forward-line -1) (idlwave-is-continuation-line))
         (idlwave-previous-statement)
       (beginning-of-line)))))
@@ -2572,7 +2572,7 @@ If not in a statement just moves to end of line. Returns position."
   (let ((save-point (point)))
     (when (re-search-forward ".*&" lim t)
       (goto-char (match-end 0))
-      (if (idlwave-quoted) 
+      (if (idlwave-quoted)
           (goto-char save-point)
         (if (eq (char-after (- (point) 2)) ?&) (goto-char save-point))))
     (point)))
@@ -2589,7 +2589,7 @@ If there is no label point is not moved and nil is returned."
   ;; - not in parenthesis (like a[0:3])
   ;; - not followed by another ":" in explicit class, ala a->b::c
   ;; As many in this mode, this function is heuristic and not an exact
-  ;; parser. 
+  ;; parser.
   (let* ((start (point))
          (eos (save-excursion (idlwave-end-of-statement) (point)))
          (end (idlwave-find-key ":" 1 'nomark eos)))
@@ -2666,7 +2666,7 @@ equal sign will be surrounded by BEFORE and AFTER blanks.  If
 `idlwave-pad-keyword' is t then keyword assignment is treated just
 like assignment statements.  When nil, spaces are removed for keyword
 assignment.  Any other value keeps the current space around the `='.
-Limits in for loops are treated as keyword assignment.  
+Limits in for loops are treated as keyword assignment.
 
 Starting with IDL 6.0, a number of op= assignments are available.
 Since ambiguities of the form:
@@ -2681,25 +2681,25 @@ operators, such as ##=, ^=, etc., will be pre-padded.
 
 See `idlwave-surround'."
   (if idlwave-surround-by-blank
-      (let 
+      (let
           ((non-an-ops "\\(##\\|\\*\\|\\+\\|-\\|/\\|<\\|>\\|\\^\\)\\=")
-           (an-ops 
+           (an-ops
             "\\s-\\(AND\\|EQ\\|GE\\|GT\\|LE\\|LT\\|MOD\\|NE\\|OR\\|XOR\\)\\=")
            (len 1))
-        
-        (save-excursion 
+
+        (save-excursion
           (let ((case-fold-search t))
             (backward-char)
-            (if (or 
+            (if (or
                  (re-search-backward non-an-ops nil t)
                  ;; Why doesn't ##? work for both?
-                 (re-search-backward "\\(#\\)\\=" nil t)) 
+                 (re-search-backward "\\(#\\)\\=" nil t))
                 (setq len (1+ (length (match-string 1))))
               (when (re-search-backward an-ops nil t)
                 (setq begin nil) ; won't modify begin
                 (setq len (1+ (length (match-string 1))))))))
-        
-        (if (eq t idlwave-pad-keyword)  
+
+        (if (eq t idlwave-pad-keyword)
             ;; Everything gets padded equally
             (idlwave-surround before after nil len)
           ;; Treating keywords/for variables specially...
@@ -2710,22 +2710,22 @@ See `idlwave-surround'."
                         (skip-chars-backward "= \t")
                         (nth 2 (idlwave-where)))))
             (cond ((or (memq what '(function-keyword procedure-keyword))
-                       (memq (caar st) '(for pdef))) 
-                   (cond 
+                       (memq (caar st) '(for pdef)))
+                   (cond
                     ((null idlwave-pad-keyword)
                      (idlwave-surround 0 0)
                      ) ; remove space
                     (t))) ; leave any spaces alone
                   (t (idlwave-surround before after nil len))))))))
-              
+
 
 (defun idlwave-indent-and-action (&optional arg)
   "Call `idlwave-indent-line' and do expand actions.
 With prefix ARG non-nil, indent the entire sub-statement."
   (interactive "p")
   (save-excursion
-    (if (and idlwave-expand-generic-end 
-             (re-search-backward "\\<\\(end\\)\\s-*\\=" 
+    (if (and idlwave-expand-generic-end
+             (re-search-backward "\\<\\(end\\)\\s-*\\="
                                  (max 0 (- (point) 10)) t)
              (looking-at "\\(end\\)\\([ \n\t]\\|\\'\\)"))
         (progn (goto-char (match-end 1))
@@ -2735,7 +2735,7 @@ With prefix ARG non-nil, indent the entire sub-statement."
   (when (and (not arg) current-prefix-arg)
     (setq arg current-prefix-arg)
     (setq current-prefix-arg nil))
-  (if arg 
+  (if arg
       (idlwave-indent-statement)
     (idlwave-indent-line t)))
 
@@ -2868,7 +2868,7 @@ Inserts spaces before markers at point."
                 (save-excursion
                   (cond
                    ;; Beginning of file
-                   ((prog1 
+                   ((prog1
                         (idlwave-previous-statement)
                       (setq beg-prev-pos (point)))
                     0)
@@ -2878,7 +2878,7 @@ Inserts spaces before markers at point."
                        idlwave-main-block-indent))
                    ;; Begin block
                    ((idlwave-look-at idlwave-begin-block-reg t)
-                    (+ (idlwave-min-current-statement-indent) 
+                    (+ (idlwave-min-current-statement-indent)
                        idlwave-block-indent))
                    ;; End Block
                    ((idlwave-look-at idlwave-end-block-reg t)
@@ -2889,7 +2889,7 @@ Inserts spaces before markers at point."
                       (idlwave-min-current-statement-indent)))
                       ;;                      idlwave-end-offset
                       ;;                      idlwave-block-indent))
-                   
+
                    ;; Default to current indent
                    ((idlwave-current-statement-indent))))))
           ;; adjust the indentation based on the current statement
@@ -2905,7 +2905,7 @@ Inserts spaces before markers at point."
 
 (defun idlwave-calculate-paren-indent (beg-reg end-reg close-exp)
   "Calculate the continuation indent inside a paren group.
-Returns a cons-cell with (open . indent), where open is the 
+Returns a cons-cell with (open . indent), where open is the
 location of the open paren"
   (let ((open (nth 1 (parse-partial-sexp beg-reg end-reg))))
     ;; Found an innermost open paren.
@@ -2946,24 +2946,24 @@ groupings, are treated separately."
            (end-reg (progn (beginning-of-line) (point)))
            (beg-last-statement (save-excursion (idlwave-previous-statement)
                                                (point)))
-           (beg-reg (progn (idlwave-start-of-substatement 'pre) 
+           (beg-reg (progn (idlwave-start-of-substatement 'pre)
                            (if (eq (line-beginning-position) end-reg)
                                (goto-char beg-last-statement)
                              (point))))
            (basic-indent (+ (idlwave-min-current-statement-indent end-reg)
                             idlwave-continuation-indent))
            fancy-nonparen-indent fancy-paren-indent)
-      (cond 
+      (cond
        ;; Align then with its matching if, etc.
        ((let ((matchers '(("\\<if\\>" . "[ \t]*then")
                           ("\\<\\(if\\|end\\(if\\)?\\)\\>" . "[ \t]*else")
                           ("\\<\\(for\\|while\\)\\>" . "[ \t]*do")
-                          ("\\<\\(repeat\\|end\\(rep\\)?\\)\\>" . 
+                          ("\\<\\(repeat\\|end\\(rep\\)?\\)\\>" .
                            "[ \t]*until")
                           ("\\<case\\>" . "[ \t]*of")))
               match cont-re)
           (goto-char end-reg)
-          (and 
+          (and
            (setq cont-re
                  (catch 'exit
                    (while (setq match (car matchers))
@@ -2972,7 +2972,7 @@ groupings, are treated separately."
                      (setq matchers (cdr matchers)))))
            (idlwave-find-key cont-re -1 'nomark beg-last-statement)))
         (if (looking-at "end") ;; that one's special
-            (- (idlwave-current-indent) 
+            (- (idlwave-current-indent)
                (+ idlwave-block-indent idlwave-end-offset))
           (idlwave-current-indent)))
 
@@ -2998,7 +2998,7 @@ groupings, are treated separately."
               (let* ((end-reg end-reg)
                     (close-exp (progn
                                  (goto-char end-reg)
-                                 (skip-chars-forward " \t") 
+                                 (skip-chars-forward " \t")
                                  (looking-at "\\s)")))
                     indent-cons)
                 (catch 'loop
@@ -3032,12 +3032,12 @@ groupings, are treated separately."
                    (if (save-match-data (looking-at "[ \t$]*\\(;.*\\)?$"))
                        nil
                      (current-column)))
-                  
+
                   ;; Continued assignment (with =):
                   ((catch 'assign ;
                      (while (looking-at "[^=\n\r]*\\(=\\)[ \t]*")
                        (goto-char (match-end 0))
-                       (if (null (idlwave-what-function beg-reg)) 
+                       (if (null (idlwave-what-function beg-reg))
                            (throw 'assign t))))
                    (unless (or
                             (idlwave-in-quote)
@@ -3099,7 +3099,7 @@ possibility of unbalanced blocks."
   (let* ((here (point))
          (case-fold-search t)
          (limit (if (>= dir 0) (point-max) (point-min)))
-         (block-limit (if (>= dir 0) 
+         (block-limit (if (>= dir 0)
                           idlwave-begin-block-reg
                         idlwave-end-block-reg))
          found
@@ -3110,7 +3110,7 @@ possibility of unbalanced blocks."
                                (idlwave-find-key
                                 idlwave-begin-unit-reg dir t limit)
                              (end-of-line)
-                             (idlwave-find-key 
+                             (idlwave-find-key
                               idlwave-end-unit-reg dir t limit)))
                          limit)))
     (if (>= dir 0) (end-of-line)) ;Make sure we are in current block
@@ -3135,7 +3135,7 @@ possibility of unbalanced blocks."
                   (or (null end-reg) (< (point) end-reg)))
         (unless comm-or-empty (setq min (min min (idlwave-current-indent)))))
       (if (or comm-or-empty (and end-reg (>= (point) end-reg)))
-          min 
+          min
         (min min (idlwave-current-indent))))))
 
 (defun idlwave-current-statement-indent (&optional last-line)
@@ -3161,10 +3161,10 @@ Skips any whitespace. Returns 0 if the end-of-line follows the whitespace."
 Blank or comment-only lines following regular continuation lines (with
 `$') count as continuations too."
   (save-excursion
-    (or 
+    (or
      (idlwave-look-at "\\<\\$")
      (catch 'loop
-       (while (and (looking-at "^[ \t]*\\(;.*\\)?$") 
+       (while (and (looking-at "^[ \t]*\\(;.*\\)?$")
                    (eq (forward-line -1) 0))
          (if (idlwave-look-at "\\<\\$") (throw 'loop t)))))))
 
@@ -3262,7 +3262,7 @@ ignored."
                                           (beginning-of-line) (point))
                                         (point))))
                "[^;]"))
-        
+
         ;; Mark the beginning and end of the paragraph
         (goto-char bcl)
         (while (and (looking-at fill-prefix-reg)
@@ -3326,7 +3326,7 @@ ignored."
                       (insert (make-string diff ?\ ))))
                 (forward-line -1))
               )
-          
+
           ;; No hang. Instead find minimum indentation of paragraph
           ;; after first line.
           ;; For the following while statement, since START is at the
@@ -3358,7 +3358,7 @@ ignored."
                   t)
                  (current-column))
                indent))
-        
+
         ;; try to keep point at its original place
         (goto-char here)
 
@@ -3407,7 +3407,7 @@ If not found returns nil."
           (current-column)))))
 
 (defun idlwave-auto-fill ()
-  "Called to break lines in auto fill mode.  
+  "Called to break lines in auto fill mode.
 Only fills non-comment lines if `idlwave-fill-comment-line-only' is
 non-nil.  Places a continuation character at the end of the line if
 not in a comment.  Splits strings with IDL concatenation operator `+'
@@ -3558,7 +3558,7 @@ is non-nil."
   (insert (current-time-string))
   (insert ", " (user-full-name))
   (if (boundp 'user-mail-address)
-      (insert " <" user-mail-address ">") 
+      (insert " <" user-mail-address ">")
     (insert " <" (user-login-name) "@" (system-name) ">"))
   ;; Remove extra spaces from line
   (idlwave-fill-paragraph)
@@ -3584,7 +3584,7 @@ location on mark ring so that the user can return to previous point."
              (setq end (match-end 0)))
         (progn
           (goto-char beg)
-          (if (re-search-forward 
+          (if (re-search-forward
                (concat idlwave-doc-modifications-keyword ":")
                end t)
               (end-of-line)
@@ -3682,7 +3682,7 @@ constants - a double quote followed by an octal digit."
      (not (idlwave-in-quote))
      (save-excursion
        (forward-char)
-       (re-search-backward (concat "\\(" idlwave-idl-keywords 
+       (re-search-backward (concat "\\(" idlwave-idl-keywords
                                    "\\|[[(*+-/=,^><]\\)\\s-*\\*") limit t)))))
 
 
@@ -3728,7 +3728,7 @@ unless the optional second argument NOINDENT is non-nil."
           (indent-region beg end nil))
       (if (stringp prompt)
           (message prompt)))))
-  
+
 (defun idlwave-rw-case (string)
   "Make STRING have the case required by `idlwave-reserved-word-upcase'."
   (if idlwave-reserved-word-upcase
@@ -3746,7 +3746,7 @@ unless the optional second argument NOINDENT is non-nil."
 (defun idlwave-case ()
   "Build skeleton IDL case statement."
   (interactive)
-  (idlwave-template 
+  (idlwave-template
    (idlwave-rw-case "case")
    (idlwave-rw-case " of\n\nendcase")
    "Selector expression"))
@@ -3754,7 +3754,7 @@ unless the optional second argument NOINDENT is non-nil."
 (defun idlwave-switch ()
   "Build skeleton IDL switch statement."
   (interactive)
-  (idlwave-template 
+  (idlwave-template
    (idlwave-rw-case "switch")
    (idlwave-rw-case " of\n\nendswitch")
    "Selector expression"))
@@ -3762,7 +3762,7 @@ unless the optional second argument NOINDENT is non-nil."
 (defun idlwave-for ()
   "Build skeleton for loop statment."
   (interactive)
-  (idlwave-template 
+  (idlwave-template
    (idlwave-rw-case "for")
    (idlwave-rw-case " do begin\n\nendfor")
    "Loop expression"))
@@ -3777,14 +3777,14 @@ unless the optional second argument NOINDENT is non-nil."
 
 (defun idlwave-procedure ()
   (interactive)
-  (idlwave-template 
+  (idlwave-template
    (idlwave-rw-case "pro")
    (idlwave-rw-case "\n\nreturn\nend")
    "Procedure name"))
 
 (defun idlwave-function ()
   (interactive)
-  (idlwave-template 
+  (idlwave-template
    (idlwave-rw-case "function")
    (idlwave-rw-case "\n\nreturn\nend")
    "Function name"))
@@ -3798,7 +3798,7 @@ unless the optional second argument NOINDENT is non-nil."
 
 (defun idlwave-while ()
   (interactive)
-  (idlwave-template 
+  (idlwave-template
    (idlwave-rw-case "while")
    (idlwave-rw-case " do begin\n\nendwhile")
    "Entry condition"))
@@ -3877,8 +3877,8 @@ Buffer containing unsaved changes require confirmation before they are killed."
 (defun idlwave-count-outlawed-buffers (tag)
   "How many outlawed buffers have tag TAG?"
   (length (delq nil
-                (mapcar 
-                 (lambda (x) (eq (cdr x) tag)) 
+                (mapcar
+                 (lambda (x) (eq (cdr x) tag))
                  idlwave-outlawed-buffers))))
 
 (defun idlwave-do-kill-autoloaded-buffers (&rest reasons)
@@ -3892,9 +3892,9 @@ Buffer containing unsaved changes require confirmation before they are killed."
                    (memq (cdr entry) reasons))
                (kill-buffer (car entry))
                (incf cnt)
-               (setq idlwave-outlawed-buffers 
+               (setq idlwave-outlawed-buffers
                      (delq entry idlwave-outlawed-buffers)))
-        (setq idlwave-outlawed-buffers 
+        (setq idlwave-outlawed-buffers
               (delq entry idlwave-outlawed-buffers))))
     (message "%d buffer%s killed" cnt (if (= cnt 1) "" "s"))))
 
@@ -3906,7 +3906,7 @@ Intended for `after-save-hook'."
          (entry (assq buf idlwave-outlawed-buffers)))
     ;; Revoke license
     (if entry
-        (setq idlwave-outlawed-buffers 
+        (setq idlwave-outlawed-buffers
               (delq entry idlwave-outlawed-buffers)))
     ;; Remove this function from the hook.
     (remove-hook 'after-save-hook 'idlwave-revoke-license-to-kill 'local)))
@@ -3925,7 +3925,7 @@ Intended for `after-save-hook'."
 (defun idlwave-expand-lib-file-name (file)
   ;; Find FILE on the scanned lib path and return a buffer visiting it
   ;; This is for, e.g., finding source with no user catalog
-  (cond 
+  (cond
    ((null file) nil)
    ((file-name-absolute-p file) file)
    (t (idlwave-locate-lib-file file))))
@@ -3940,7 +3940,7 @@ you specify /."
   (interactive)
   (let (directory directories cmd append status numdirs dir getsubdirs
                   buffer save_buffer files numfiles item errbuf)
-    
+
     ;;
     ;; Read list of directories
     (setq directory (read-string "Tag Directories: " "."))
@@ -3992,7 +3992,7 @@ you specify /."
                     (message (concat "Tagging " item "..."))
                     (setq errbuf (get-buffer-create "*idltags-error*"))
                     (setq status (+ status
-                                    (if (eq 0 (call-process 
+                                    (if (eq 0 (call-process
                                                "sh" nil errbuf nil "-c"
                                                (concat cmd append item)))
                                         0
@@ -4006,13 +4006,13 @@ you specify /."
                   (setq numfiles (1+ numfiles))
                   (setq item (nth numfiles files))
                   )))
-            
+
             (setq numdirs (1+ numdirs))
             (setq dir (nth numdirs directories)))
         (progn
           (setq numdirs (1+ numdirs))
           (setq dir (nth numdirs directories)))))
-    
+
     (setq errbuf (get-buffer-create "*idltags-error*"))
     (if (= status 0)
         (kill-buffer errbuf))
@@ -4088,7 +4088,7 @@ blank lines."
   ;; Make sure the hash functions are accessible.
   (if (or (not (fboundp 'gethash))
           (not (fboundp 'puthash)))
-      (progn 
+      (progn
         (require 'cl)
         (or (fboundp 'puthash)
             (defalias 'puthash 'cl-puthash))))
@@ -4107,7 +4107,7 @@ blank lines."
       ;; Reset the system & library hash
       (loop for entry in entries
         for var = (car entry) for size = (nth 1 entry)
-        do (setcdr (symbol-value var) 
+        do (setcdr (symbol-value var)
                    (make-hash-table ':size size ':test 'equal)))
       (setq idlwave-sint-dirs nil
             idlwave-sint-libnames nil))
@@ -4117,7 +4117,7 @@ blank lines."
       ;; Reset the buffer & shell hash
       (loop for entry in entries
         for var = (car entry) for size = (nth 1 entry)
-        do (setcar (symbol-value var) 
+        do (setcar (symbol-value var)
                    (make-hash-table ':size size ':test 'equal))))))
 
 (defun idlwave-sintern-routine-or-method (name &optional class set)
@@ -4204,11 +4204,11 @@ If DEFAULT-DIR is passed, it is used as the base of the directory"
             (setq class (idlwave-sintern-class class set))
             (setq name (idlwave-sintern-method name set)))
         (setq name (idlwave-sintern-routine name set)))
-      
+
       ;; The source
       (let ((source-type (car source))
             (source-file  (nth 1 source))
-            (source-dir  (if default-dir  
+            (source-dir  (if default-dir
                              (file-name-as-directory default-dir)
                            (nth 2 source)))
             (source-lib (nth 3 source)))
@@ -4217,7 +4217,7 @@ If DEFAULT-DIR is passed, it is used as the base of the directory"
         (if (stringp source-lib)
             (setq source-lib (idlwave-sintern-libname source-lib set)))
         (setq source (list source-type source-file source-dir source-lib)))
-      
+
       ;; The keywords
       (setq kwds (mapcar (lambda (x)
                            (idlwave-sintern-keyword-list x set))
@@ -4355,10 +4355,10 @@ will re-read the catalog."
                      "-l" (expand-file-name "~/.emacs")
                      "-l" "idlwave"
                      "-f" "idlwave-rescan-catalog-directories"))
-         (process (apply 'start-process "idlcat" 
+         (process (apply 'start-process "idlcat"
                          nil emacs args)))
     (setq idlwave-catalog-process process)
-    (set-process-sentinel 
+    (set-process-sentinel
      process
      (lambda (pro why)
        (when (string-match "finished" why)
@@ -4431,7 +4431,7 @@ information updated immediately, leave NO-CONCATENATE nil."
            ;; The override-idle means, even if the idle timer has done some
            ;; preparing work, load and renormalize everything anyway.
            (override-idle (or arg idlwave-buffer-case-takes-precedence)))
-      
+
       (setq idlwave-buffer-routines nil
             idlwave-compiled-routines nil
             idlwave-unresolved-routines nil)
@@ -4442,7 +4442,7 @@ information updated immediately, leave NO-CONCATENATE nil."
         (idlwave-reset-sintern (cond (load t)
                                      ((null idlwave-system-routines) t)
                                      (t 'bufsh))))
-      
+
       (if idlwave-buffer-case-takes-precedence
           ;; We can safely scan the buffer stuff first
           (progn
@@ -4457,9 +4457,9 @@ information updated immediately, leave NO-CONCATENATE nil."
                                     (idlwave-shell-is-running)))
              (ask-shell (and shell-is-running
                              idlwave-query-shell-for-routine-info)))
-      
+
         ;; Load the library catalogs again, first re-scanning the path
-        (when arg 
+        (when arg
           (if shell-is-running
               (idlwave-shell-send-command idlwave-shell-path-query
                                           '(progn
@@ -4479,7 +4479,7 @@ information updated immediately, leave NO-CONCATENATE nil."
             ;;    Therefore, we do a concatenation now, even though
             ;;    the shell might do it again.
             (idlwave-concatenate-rinfo-lists nil 'run-hooks))
-      
+
         (when ask-shell
           ;; Ask the shell about the routines it knows of.
           (message "Querying the shell")
@@ -4541,7 +4541,7 @@ information updated immediately, leave NO-CONCATENATE nil."
                   (progn
                     (setq idlwave-library-routines nil)
                     (ding)
-                    (message "Outdated user catalog: %s... recreate" 
+                    (message "Outdated user catalog: %s... recreate"
                              idlwave-user-catalog-file))
                 (message "Loading user catalog in idle time...done"))
               (aset arr 2 t)
@@ -4549,15 +4549,15 @@ information updated immediately, leave NO-CONCATENATE nil."
           (when (not (aref arr 3))
             (when idlwave-user-catalog-routines
               (message "Normalizing user catalog routines in idle time...")
-              (setq idlwave-user-catalog-routines 
+              (setq idlwave-user-catalog-routines
                     (idlwave-sintern-rinfo-list
                      idlwave-user-catalog-routines 'sys))
-              (message 
+              (message
                "Normalizing user catalog routines in idle time...done"))
             (aset arr 3 t)
             (throw 'exit t))
           (when (not (aref arr 4))
-            (idlwave-scan-library-catalogs 
+            (idlwave-scan-library-catalogs
              "Loading and normalizing library catalogs in idle time...")
             (aset arr 4 t)
             (throw 'exit t))
@@ -4598,8 +4598,8 @@ information updated immediately, leave NO-CONCATENATE nil."
     (setq idlwave-true-path-alist nil)
     (when (or force (not (aref idlwave-load-rinfo-steps-done 3)))
       (message "Normalizing user catalog routines...")
-      (setq idlwave-user-catalog-routines 
-            (idlwave-sintern-rinfo-list 
+      (setq idlwave-user-catalog-routines
+            (idlwave-sintern-rinfo-list
              idlwave-user-catalog-routines 'sys))
       (message "Normalizing user catalog routines...done")))
   (when (or force (not (aref idlwave-load-rinfo-steps-done 4)))
@@ -4610,11 +4610,11 @@ information updated immediately, leave NO-CONCATENATE nil."
 
 (defun idlwave-update-buffer-routine-info ()
   (let (res)
-    (cond 
+    (cond
      ((eq idlwave-scan-all-buffers-for-routine-info t)
       ;; Scan all buffers, current buffer last
       (message "Scanning all buffers...")
-      (setq res (idlwave-get-routine-info-from-buffers 
+      (setq res (idlwave-get-routine-info-from-buffers
                  (reverse (buffer-list)))))
      ((null idlwave-scan-all-buffers-for-routine-info)
       ;; Don't scan any buffers
@@ -4627,12 +4627,12 @@ information updated immediately, leave NO-CONCATENATE nil."
             (setq res (idlwave-get-routine-info-from-buffers
                        (list (current-buffer))))))))
     ;; Put the result into the correct variable
-    (setq idlwave-buffer-routines 
+    (setq idlwave-buffer-routines
           (idlwave-sintern-rinfo-list res 'set))))
 
 (defun idlwave-concatenate-rinfo-lists (&optional quiet run-hook)
   "Put the different sources for routine information together."
-  ;; The sequence here is important because earlier definitions shadow 
+  ;; The sequence here is important because earlier definitions shadow
   ;; later ones.  We assume that if things in the buffers are newer
   ;; then in the shell of the system, they are meant to be different.
   (setcdr idlwave-last-system-routine-info-cons-cell
@@ -4644,7 +4644,7 @@ information updated immediately, leave NO-CONCATENATE nil."
 
   ;; Give a message with information about the number of routines we have.
   (unless quiet
-    (message 
+    (message
      "Routines Found: buffer(%d) compiled(%d) library(%d) user(%d) system(%d)"
      (length idlwave-buffer-routines)
      (length idlwave-compiled-routines)
@@ -4662,7 +4662,7 @@ information updated immediately, leave NO-CONCATENATE nil."
           (when (and (setq class (nth 2 x))
                      (not (assq class idlwave-class-alist)))
             (push (list class) idlwave-class-alist)))
-        idlwave-class-alist)))      
+        idlwave-class-alist)))
 
 ;; Three functions for the hooks
 (defun idlwave-save-buffer-update ()
@@ -4695,7 +4695,7 @@ information updated immediately, leave NO-CONCATENATE nil."
 
 (defun idlwave-replace-buffer-routine-info (file new)
   "Cut the part from FILE out of `idlwave-buffer-routines' and add NEW."
-  (let ((list idlwave-buffer-routines) 
+  (let ((list idlwave-buffer-routines)
         found)
     (while list
       ;; The following test uses eq to make sure it works correctly
@@ -4706,7 +4706,7 @@ information updated immediately, leave NO-CONCATENATE nil."
             (setcar list nil)
             (setq found t))
         (if found
-            ;; End of that section reached. Jump. 
+            ;; End of that section reached. Jump.
             (setq list nil)))
       (setq list (cdr list)))
     (setq idlwave-buffer-routines
@@ -4738,11 +4738,11 @@ information updated immediately, leave NO-CONCATENATE nil."
       (save-restriction
         (widen)
         (goto-char (point-min))
-        (while (re-search-forward 
+        (while (re-search-forward
                 "^[ \t]*\\(pro\\|function\\)[ \t]" nil t)
           (setq string (buffer-substring-no-properties
                         (match-beginning 0)
-                        (progn 
+                        (progn
                           (idlwave-end-of-statement)
                           (point))))
           (setq entry (idlwave-parse-definition string))
@@ -4780,7 +4780,7 @@ information updated immediately, leave NO-CONCATENATE nil."
         (push (match-string 1 string) args)))
     ;; Normalize and sort.
     (setq args (nreverse args))
-    (setq keywords (sort keywords (lambda (a b) 
+    (setq keywords (sort keywords (lambda (a b)
                                     (string< (downcase a) (downcase b)))))
     ;; Make and return the entry
     ;; We don't know which argument are optional, so this information
@@ -4790,7 +4790,7 @@ information updated immediately, leave NO-CONCATENATE nil."
           class
           (cond ((not (boundp 'idlwave-scanning-lib))
                  (list  'buffer (buffer-file-name)))
-;               ((string= (downcase 
+;               ((string= (downcase
 ;                          (file-name-sans-extension
 ;                           (file-name-nondirectory (buffer-file-name))))
 ;                         (downcase name))
@@ -4798,7 +4798,7 @@ information updated immediately, leave NO-CONCATENATE nil."
 ;               (t (cons 'lib (file-name-nondirectory (buffer-file-name))))
                 (t (list 'user (file-name-nondirectory (buffer-file-name))
                          idlwave-scanning-lib-dir "UserLib")))
-          (concat 
+          (concat
            (if (string= type "function") "Result = " "")
            (if class "Obj ->[%s::]" "")
            "%s"
@@ -4842,10 +4842,10 @@ time - so no widget will pop up."
                (> (length idlwave-user-catalog-file) 0)
                (file-accessible-directory-p
                 (file-name-directory idlwave-user-catalog-file))
-               (not (string= "" (file-name-nondirectory 
+               (not (string= "" (file-name-nondirectory
                                  idlwave-user-catalog-file))))
     (error "`idlwave-user-catalog-file' does not point to a file in an accessible directory"))
-  
+
   (cond
     ;; Rescan the known directories
    ((and arg idlwave-path-alist
@@ -4855,13 +4855,13 @@ time - so no widget will pop up."
    ;; Expand the directories from library-path and run the widget
    (idlwave-library-path
     (idlwave-display-user-catalog-widget
-     (if idlwave-true-path-alist 
+     (if idlwave-true-path-alist
          ;; Propagate any flags on the existing path-alist
          (mapcar (lambda (x)
                    (let ((path-entry (assoc (file-truename x)
                                             idlwave-true-path-alist)))
                      (if path-entry
-                         (cons x (cdr path-entry)) 
+                         (cons x (cdr path-entry))
                        (list x))))
                  (idlwave-expand-path idlwave-library-path))
        (mapcar 'list (idlwave-expand-path idlwave-library-path)))))
@@ -4886,7 +4886,7 @@ time - so no widget will pop up."
     (idlwave-scan-library-catalogs "Locating library catalogs..." 'no-load)
     (idlwave-display-user-catalog-widget idlwave-path-alist)))
 
-(defconst idlwave-user-catalog-widget-help-string 
+(defconst idlwave-user-catalog-widget-help-string
   "This is the front-end to the creation of the IDLWAVE user catalog.
 Please select the directories on IDL's search path from which you
 would like to extract routine information, to be stored in the file:
@@ -4921,7 +4921,7 @@ directories and save the routine info.
   (make-local-variable 'idlwave-widget)
   (widget-insert (format idlwave-user-catalog-widget-help-string
                          idlwave-user-catalog-file))
-  
+
   (widget-create 'push-button
                  :notify 'idlwave-widget-scan-user-lib-files
                  "Scan & Save")
@@ -4931,7 +4931,7 @@ directories and save the routine info.
                  "Delete File")
   (widget-insert "  ")
   (widget-create 'push-button
-                 :notify 
+                 :notify
                  '(lambda (&rest ignore)
                     (let ((path-list (widget-get idlwave-widget :path-dirs)))
                       (mapcar (lambda (x)
@@ -4942,7 +4942,7 @@ directories and save the routine info.
                  "Select All Non-Lib")
   (widget-insert "  ")
   (widget-create 'push-button
-                 :notify 
+                 :notify
                  '(lambda (&rest ignore)
                     (let ((path-list (widget-get idlwave-widget :path-dirs)))
                       (mapcar (lambda (x)
@@ -4958,18 +4958,18 @@ directories and save the routine info.
   (widget-insert "\n\n")
 
   (widget-insert "Select Directories: \n")
-  
+
   (setq idlwave-widget
         (apply 'widget-create
                'checklist
-               :value  (delq nil (mapcar (lambda (x) 
-                                           (if (memq 'user (cdr x)) 
+               :value  (delq nil (mapcar (lambda (x)
+                                           (if (memq 'user (cdr x))
                                                (car x)))
                                          dirs-list))
                :greedy t
                :tag "List of directories"
-               (mapcar (lambda (x) 
-                         (list 'item 
+               (mapcar (lambda (x)
+                         (list 'item
                                (if (memq 'lib (cdr x))
                                    (concat "[LIB] " (car x) )
                                  (car x)))) dirs-list)))
@@ -4979,7 +4979,7 @@ directories and save the routine info.
   (widget-setup)
   (goto-char (point-min))
   (delete-other-windows))
-  
+
 (defun idlwave-delete-user-catalog-file (&rest ignore)
   (if (yes-or-no-p
        (format "Delete file %s " idlwave-user-catalog-file))
@@ -4995,7 +4995,7 @@ directories and save the routine info.
          (this-path-alist path-alist)
          dir-entry)
     (while (setq dir-entry (pop this-path-alist))
-      (if (member 
+      (if (member
            (if (memq 'lib (cdr dir-entry))
                (concat "[LIB] " (car dir-entry))
              (car dir-entry))
@@ -5092,7 +5092,7 @@ directories and save the routine info.
     ;; Define the variable which knows the value of "!DIR"
     (insert (format "\n(setq idlwave-system-directory \"%s\")\n"
                     idlwave-system-directory))
-  
+
     ;; Define the variable which contains a list of all scanned directories
     (insert "\n(setq idlwave-path-alist\n    '(")
     (let ((standard-output (current-buffer)))
@@ -5132,7 +5132,7 @@ directories and save the routine info.
       (when (file-directory-p dir)
         (setq files (nreverse (directory-files dir t "[^.]")))
         (while (setq file (pop files))
-          (if (file-directory-p file) 
+          (if (file-directory-p file)
               (push (file-name-as-directory file) path)))
         (push dir path1)))
     path1))
@@ -5141,7 +5141,7 @@ directories and save the routine info.
 ;;----- Scanning the library catalogs ------------------
 
 (defun idlwave-scan-library-catalogs (&optional message-base no-load)
-  "Scan for library catalog files (.idlwave_catalog) and ingest.  
+  "Scan for library catalog files (.idlwave_catalog) and ingest.
 
 All directories on `idlwave-path-alist' (or `idlwave-library-path'
 instead, if present) are searched.  Print MESSAGE-BASE along with the
@@ -5149,7 +5149,7 @@ libraries being loaded, if passed, and skip loading/normalizing if
 NO-LOAD is non-nil.  The variable `idlwave-use-library-catalogs' can
 be set to nil to disable library catalog scanning."
   (when idlwave-use-library-catalogs
-    (let ((dirs 
+    (let ((dirs
            (if idlwave-library-path
                (idlwave-expand-path idlwave-library-path)
              (mapcar 'car idlwave-path-alist)))
@@ -5158,7 +5158,7 @@ be set to nil to disable library catalog scanning."
       (if message-base (message message-base))
       (while (setq dir (pop dirs))
         (catch 'continue
-          (when (file-readable-p 
+          (when (file-readable-p
                  (setq catalog (expand-file-name ".idlwave_catalog" dir)))
             (unless no-load
               (setq idlwave-library-catalog-routines nil)
@@ -5166,20 +5166,20 @@ be set to nil to disable library catalog scanning."
               (condition-case nil
                   (load catalog t t t)
                 (error (throw 'continue t)))
-              (when (and 
-                     message-base 
-                     (not (string= idlwave-library-catalog-libname 
+              (when (and
+                     message-base
+                     (not (string= idlwave-library-catalog-libname
                                    old-libname)))
-                (message (concat message-base 
+                (message (concat message-base
                                  idlwave-library-catalog-libname))
                 (setq old-libname idlwave-library-catalog-libname))
               (when idlwave-library-catalog-routines
                 (setq all-routines
-                      (append 
+                      (append
                        (idlwave-sintern-rinfo-list
                         idlwave-library-catalog-routines 'sys dir)
                        all-routines))))
-            
+
             ;;  Add a 'lib flag if on path-alist
             (when (and idlwave-path-alist
                        (setq dir-entry (assoc dir idlwave-path-alist)))
@@ -5190,17 +5190,17 @@ be set to nil to disable library catalog scanning."
 ;;----- Communicating with the Shell -------------------
 
 ;; First, here is the idl program which can be used to query IDL for
-;; defined routines. 
+;; defined routines.
 (defconst idlwave-routine-info.pro
   "
 ;; START OF IDLWAVE SUPPORT ROUTINES
 pro idlwave_print_info_entry,name,func=func,separator=sep
   ;; See if it's an object method
   if name eq '' then return
-  func    = keyword_set(func) 
+  func    = keyword_set(func)
   methsep = strpos(name,'::')
   meth    = methsep ne -1
-  
+
   ;; Get routine info
   pars   = routine_info(name,/parameters,functions=func)
   source = routine_info(name,/source,functions=func)
@@ -5208,12 +5208,12 @@ pro idlwave_print_info_entry,name,func=func,separator=sep
   nkw    = pars.num_kw_args
   if nargs gt 0 then args = pars.args
   if nkw   gt 0 then kwargs = pars.kw_args
-  
+
   ;; Trim the class, and make the name
-  if meth then begin 
+  if meth then begin
       class = strmid(name,0,methsep)
       name  = strmid(name,methsep+2,strlen(name)-1)
-      if nargs gt 0 then begin 
+      if nargs gt 0 then begin
           ;; remove the self argument
           wh = where(args ne 'SELF',nargs)
           if nargs gt 0 then args = args[wh]
@@ -5222,7 +5222,7 @@ pro idlwave_print_info_entry,name,func=func,separator=sep
       ;; No class, just a normal routine.
       class = \"\"
   endelse
-   
+
   ;; Calling sequence
   cs = \"\"
   if func then cs = 'Result = '
@@ -5243,9 +5243,9 @@ pro idlwave_print_info_entry,name,func=func,separator=sep
           kwstring = kwstring + ' ' + kwargs[j]
       endfor
   endif
-  
+
   ret=(['IDLWAVE-PRO','IDLWAVE-FUN'])[func]
-  
+
   print,ret + ': ' + name + sep + class + sep + source[0].path  $
     + sep + cs + sep + kwstring
 end
@@ -5285,7 +5285,7 @@ pro idlwave_get_class_tags, class
   if res then print,'IDLWAVE-CLASS-TAGS: '+class+' '+strjoin(tags,' ',/single)
 end
 ;; END OF IDLWAVE SUPPORT ROUTINES
-" 
+"
   "The idl programs to get info from the shell.")
 
 (defvar idlwave-idlwave_routine_info-compiled nil
@@ -5308,12 +5308,12 @@ end
       (erase-buffer)
       (insert idlwave-routine-info.pro)
       (save-buffer 0))
-    (idlwave-shell-send-command 
+    (idlwave-shell-send-command
      (concat ".run " idlwave-shell-temp-pro-file)
      nil 'hide wait)
 ;    (message "SENDING SAVE") ; ????????????????????????
     (idlwave-shell-send-command
-     (format "save,'idlwave_routine_info','idlwave_print_info_entry','idlwave_get_class_tags','idlwave_get_sysvars',FILE='%s',/ROUTINES" 
+     (format "save,'idlwave_routine_info','idlwave_print_info_entry','idlwave_get_class_tags','idlwave_get_sysvars',FILE='%s',/ROUTINES"
              (idlwave-shell-temp-file 'rinfo))
      nil 'hide wait))
 
@@ -5396,7 +5396,7 @@ When we force a method or a method keyword, CLASS can specify the class."
          (completion-regexp-list
           (if (equal arg '(16))
               (list (read-string (concat "Completion Regexp: "))))))
-    
+
     (if (and module (string-match "::" module))
         (setq class (substring module 0 (match-beginning 0))
               module (substring module (match-end 0))))
@@ -5417,7 +5417,7 @@ When we force a method or a method keyword, CLASS can specify the class."
      ;; Check for any special completion functions
      ((and idlwave-complete-special
            (idlwave-call-special idlwave-complete-special)))
-     
+
      ((null what)
       (error "Nothing to complete here"))
 
@@ -5434,7 +5434,7 @@ When we force a method or a method keyword, CLASS can specify the class."
                               (idlwave-all-class-inherits class-selector)))
              (isa (concat "procedure" (if class-selector "-method" "")))
              (type-selector 'pro))
-        (setq idlwave-completion-help-info 
+        (setq idlwave-completion-help-info
               (list 'routine nil type-selector class-selector nil super-classes))
         (idlwave-complete-in-buffer
          'procedure (if class-selector 'method 'routine)
@@ -5442,8 +5442,8 @@ When we force a method or a method keyword, CLASS can specify the class."
          (format "Select a %s name%s"
                  isa
                  (if class-selector
-                     (format " (class is %s)" 
-                             (if (eq class-selector t) 
+                     (format " (class is %s)"
+                             (if (eq class-selector t)
                                  "unknown" class-selector))
                    ""))
          isa
@@ -5457,7 +5457,7 @@ When we force a method or a method keyword, CLASS can specify the class."
                               (idlwave-all-class-inherits class-selector)))
              (isa (concat "function" (if class-selector "-method" "")))
              (type-selector 'fun))
-        (setq idlwave-completion-help-info 
+        (setq idlwave-completion-help-info
               (list 'routine nil type-selector class-selector nil super-classes))
         (idlwave-complete-in-buffer
          'function (if class-selector 'method 'routine)
@@ -5465,7 +5465,7 @@ When we force a method or a method keyword, CLASS can specify the class."
          (format "Select a %s name%s"
                  isa
                  (if class-selector
-                     (format " (class is %s)" 
+                     (format " (class is %s)"
                              (if (eq class-selector t)
                                  "unknown" class-selector))
                    ""))
@@ -5495,14 +5495,14 @@ When we force a method or a method keyword, CLASS can specify the class."
         (setq list (idlwave-fix-keywords name 'pro class list super-classes))
         (unless list (error (format "No keywords available for procedure %s"
                                     (idlwave-make-full-name class name))))
-        (setq idlwave-completion-help-info 
+        (setq idlwave-completion-help-info
               (list 'keyword name type-selector class-selector entry super-classes))
         (idlwave-complete-in-buffer
          'keyword 'keyword list nil
          (format "Select keyword for procedure %s%s"
                  (idlwave-make-full-name class name)
                  (if (or (member '("_EXTRA") list)
-                         (member '("_REF_EXTRA") list))                  
+                         (member '("_REF_EXTRA") list))
                      " (note _EXTRA)" ""))
          isa
          'idlwave-attach-keyword-classes)))
@@ -5533,13 +5533,13 @@ When we force a method or a method keyword, CLASS can specify the class."
                          (idlwave-make-full-name class name)))
         (unless list (error (format "No keywords available for function %s"
                                     msg-name)))
-        (setq idlwave-completion-help-info 
+        (setq idlwave-completion-help-info
               (list 'keyword name type-selector class-selector nil super-classes))
         (idlwave-complete-in-buffer
          'keyword 'keyword list nil
          (format "Select keyword for function %s%s" msg-name
                  (if (or (member '("_EXTRA") list)
-                         (member '("_REF_EXTRA") list))                  
+                         (member '("_REF_EXTRA") list))
                      " (note _EXTRA)" ""))
          isa
          'idlwave-attach-keyword-classes)))
@@ -5577,10 +5577,10 @@ other completions will be tried.")
                       ("class")))
          (module (idlwave-sintern-routine-or-method module class))
          (class (idlwave-sintern-class class))
-         (what (cond 
+         (what (cond
                 ((equal what 0)
                  (setq what
-                       (intern (completing-read 
+                       (intern (completing-read
                                 "Complete what? " what-list nil t))))
                 ((integerp what)
                  (setq what (intern (car (nth (1- what) what-list)))))
@@ -5602,7 +5602,7 @@ other completions will be tried.")
              (super-classes nil)
              (type-selector 'pro)
              (pro (or module
-                      (idlwave-completing-read 
+                      (idlwave-completing-read
                        "Procedure: " (idlwave-routines) 'idlwave-selector))))
         (setq pro (idlwave-sintern-routine pro))
         (list nil-list nil-list 'procedure-keyword
@@ -5616,7 +5616,7 @@ other completions will be tried.")
              (super-classes nil)
              (type-selector 'fun)
              (func (or module
-                       (idlwave-completing-read 
+                       (idlwave-completing-read
                         "Function: " (idlwave-routines) 'idlwave-selector))))
         (setq func (idlwave-sintern-routine func))
         (list nil-list nil-list 'function-keyword
@@ -5656,7 +5656,7 @@ other completions will be tried.")
 
      ((eq what 'class)
       (list nil-list nil-list 'class nil-list nil))
-     
+
      (t (error "Invalid value for WHAT")))))
 
 (defun idlwave-completing-read (&rest args)
@@ -5679,7 +5679,7 @@ other completions will be tried.")
                     (stringp idlwave-shell-default-directory)
                     (file-directory-p idlwave-shell-default-directory))
                idlwave-shell-default-directory
-             default-directory)))          
+             default-directory)))
     (comint-dynamic-complete-filename)))
 
 (defun idlwave-make-full-name (class name)
@@ -5688,7 +5688,7 @@ other completions will be tried.")
 
 (defun idlwave-rinfo-assoc (name type class list)
   "Like `idlwave-rinfo-assq', but sintern strings first."
-  (idlwave-rinfo-assq 
+  (idlwave-rinfo-assq
    (idlwave-sintern-routine-or-method name class)
    type (idlwave-sintern-class class) list))
 
@@ -5712,7 +5712,7 @@ other completions will be tried.")
           (setq classes nil)))
     rtn))
 
-(defun idlwave-best-rinfo-assq (name type class list &optional with-file 
+(defun idlwave-best-rinfo-assq (name type class list &optional with-file
                                      keep-system)
   "Like `idlwave-rinfo-assq', but get all twins and sort, then return first.
 If WITH-FILE is passed, find the best rinfo entry with a file
@@ -5737,7 +5737,7 @@ syslib files."
                                     twins)))))
     (car twins)))
 
-(defun idlwave-best-rinfo-assoc (name type class list &optional with-file 
+(defun idlwave-best-rinfo-assoc (name type class list &optional with-file
                                      keep-system)
   "Like `idlwave-best-rinfo-assq', but sintern strings first."
   (idlwave-best-rinfo-assq
@@ -5828,7 +5828,7 @@ INFO is as returned by idlwave-what-function or -procedure."
 Must accept two arguments: `apos' and `info'")
 
 (defun idlwave-determine-class (info type)
-  ;; Determine the class of a routine call.  
+  ;; Determine the class of a routine call.
   ;; INFO is the `cw-list' structure as returned by idlwave-where.
   ;; The second element in this structure is the class.  When nil, we
   ;; return nil.  When t, try to get the class from text properties at
@@ -5848,7 +5848,7 @@ Must accept two arguments: `apos' and `info'")
                       (dassoc (cdr dassoc))
                       (t t)))
          (arrow (and apos (string= (buffer-substring apos (+ 2 apos)) "->")))
-         (is-self 
+         (is-self
           (and arrow
                (save-excursion (goto-char apos)
                                (forward-word -1)
@@ -5869,19 +5869,19 @@ Must accept two arguments: `apos' and `info'")
           (setq class (or (nth 2 (idlwave-current-routine)) class)))
 
       ;; Before prompting, try any special class determination routines
-      (when (and (eq t class) 
+      (when (and (eq t class)
                  idlwave-determine-class-special
                  (not force-query))
-        (setq special-class 
+        (setq special-class
               (idlwave-call-special idlwave-determine-class-special apos))
-        (if special-class 
+        (if special-class
             (setq class (idlwave-sintern-class special-class)
                   store idlwave-store-inquired-class)))
-      
+
       ;; Prompt for a class, if we need to
       (when (and (eq class t)
                  (or force-query query))
-        (setq class-alist 
+        (setq class-alist
               (mapcar 'list (idlwave-all-method-classes (car info) type)))
         (setq class
               (idlwave-sintern-class
@@ -5890,9 +5890,9 @@ Must accept two arguments: `apos' and `info'")
                  (error "No classes available with method %s" (car info)))
                 ((and (= (length class-alist) 1) (not force-query))
                  (car (car class-alist)))
-                (t 
+                (t
                  (setq store idlwave-store-inquired-class)
-                 (idlwave-completing-read 
+                 (idlwave-completing-read
                   (format "Class%s: " (if (stringp (car info))
                                           (format " for %s method %s"
                                                   type (car info))
@@ -5904,9 +5904,9 @@ Must accept two arguments: `apos' and `info'")
         ;; We have a real class here
         (when (and store arrow)
           (condition-case ()
-              (add-text-properties 
-               apos (+ apos 2) 
-               `(idlwave-class ,class face ,idlwave-class-arrow-face 
+              (add-text-properties
+               apos (+ apos 2)
+               `(idlwave-class ,class face ,idlwave-class-arrow-face
                                rear-nonsticky t))
             (error nil)))
         (setf (nth 2 info) class))
@@ -5934,14 +5934,14 @@ Must accept two arguments: `apos' and `info'")
 
 
 (defun idlwave-where ()
-  "Find out where we are. 
+  "Find out where we are.
 The return value is a list with the following stuff:
 \(PRO-LIST FUNC-LIST COMPLETE-WHAT CW-LIST LAST-CHAR)
 
 PRO-LIST       (PRO POINT CLASS ARROW)
 FUNC-LIST      (FUNC POINT CLASS ARROW)
 COMPLETE-WHAT  a symbol indicating what kind of completion makes sense here
-CW-LIST        (PRO-OR-FUNC POINT CLASS ARROW)  Like PRO-LIST, for what can 
+CW-LIST        (PRO-OR-FUNC POINT CLASS ARROW)  Like PRO-LIST, for what can
                be completed here.
 LAST-CHAR      last relevant character before point (non-white non-comment,
                not part of current identifier or leading slash).
@@ -5953,7 +5953,7 @@ POINT:  Where is this
 CLASS:  What class has the routine (nil=no, t=is method, but class unknown)
 ARROW:  Location of the arrow"
   (idlwave-routines)
-  (let* (;(bos (save-excursion (idlwave-beginning-of-statement) (point))) 
+  (let* (;(bos (save-excursion (idlwave-beginning-of-statement) (point)))
          (bos (save-excursion (idlwave-start-of-substatement 'pre) (point)))
          (func-entry (idlwave-what-function bos))
          (func (car func-entry))
@@ -5975,8 +5975,8 @@ ARROW:  Location of the arrow"
      ((string-match "\\`[ \t]*\\(pro\\|function\\)[ \t]+[a-zA-Z0-9_]*\\'"
                     match-string)
       (setq cw 'class))
-     ((string-match 
-       "\\`[ \t]*\\([a-zA-Z][a-zA-Z0-9$_]*\\)?\\'" 
+     ((string-match
+       "\\`[ \t]*\\([a-zA-Z][a-zA-Z0-9$_]*\\)?\\'"
        (if (> pro-point 0)
            (buffer-substring pro-point (point))
          match-string))
@@ -5987,11 +5987,11 @@ ARROW:  Location of the arrow"
       nil)
      ((string-match "OBJ_NEW([ \t]*['\"]\\([a-zA-Z0-9$_]*\\)?\\'"
                     match-string)
-      (setq cw 'class))                    
+      (setq cw 'class))
      ((string-match "\\<inherits\\s-+\\([a-zA-Z0-9$_]*\\)?\\'"
                     match-string)
-      (setq cw 'class))                    
-     ((and func 
+      (setq cw 'class))
+     ((and func
            (> func-point pro-point)
            (= func-level 1)
            (memq last-char '(?\( ?,)))
@@ -6037,7 +6037,7 @@ ARROW:  Location of the arrow"
   ;;    searches to this point.
 
   (catch 'exit
-    (let (pos 
+    (let (pos
           func-point
           (cnt 0)
           func arrow-start class)
@@ -6052,18 +6052,18 @@ ARROW:  Location of the arrow"
              (setq pos (point))
              (incf cnt)
              (when (and (= (following-char) ?\()
-                        (re-search-backward 
+                        (re-search-backward
                          "\\(::\\|\\<\\)\\([a-zA-Z][a-zA-Z0-9$_]*\\)[ \t]*\\="
                          bound t))
                (setq func (match-string 2)
                      func-point (goto-char (match-beginning 2))
                      pos func-point)
-               (if (re-search-backward 
+               (if (re-search-backward
                     "->[ \t]*\\(\\([a-zA-Z][a-zA-Z0-9$_]*\\)::\\)?\\=" bound t)
                    (setq arrow-start (copy-marker (match-beginning 0))
                          class (or (match-string 2) t)))
-               (throw 
-                'exit 
+               (throw
+                'exit
                 (list
                  (idlwave-sintern-routine-or-method func class)
                  (idlwave-sintern-class class)
@@ -6079,18 +6079,18 @@ ARROW:  Location of the arrow"
   ;;    searches to this point.
   (let ((pos (point)) pro-point
         pro class arrow-start string)
-    (save-excursion 
+    (save-excursion
       ;;(idlwave-beginning-of-statement)
       (idlwave-start-of-substatement 'pre)
       (setq string (buffer-substring (point) pos))
-      (if (string-match 
+      (if (string-match
            "\\`[ \t]*\\([a-zA-Z][a-zA-Z0-9$_]*\\)[ \t]*\\(,\\|\\'\\)" string)
           (setq pro (match-string 1 string)
                 pro-point (+ (point) (match-beginning 1)))
         (if (and (idlwave-skip-object)
                  (setq string (buffer-substring (point) pos))
-                 (string-match 
-                  "\\`[ \t]*\\(->\\)[ \t]*\\(\\([a-zA-Z][a-zA-Z0-9$_]*\\)::\\)?\\([a-zA-Z][a-zA-Z0-9$_]*\\)?[ \t]*\\(,\\|\\(\\$\\s *\\(;.*\\)?\\)?$\\)" 
+                 (string-match
+                  "\\`[ \t]*\\(->\\)[ \t]*\\(\\([a-zA-Z][a-zA-Z0-9$_]*\\)::\\)?\\([a-zA-Z][a-zA-Z0-9$_]*\\)?[ \t]*\\(,\\|\\(\\$\\s *\\(;.*\\)?\\)?$\\)"
                   string))
             (setq pro (if (match-beginning 4)
                           (match-string 4 string))
@@ -6134,7 +6134,7 @@ ARROW:  Location of the arrow"
               (throw 'exit nil))))
         (goto-char pos)
       nil)))
-  
+
 (defun idlwave-last-valid-char ()
   "Return the last character before point which is not white or a comment
 and also not part of the current identifier.  Since we do this in
@@ -6224,23 +6224,23 @@ accumulate information on matching completions."
      ((or (eq completion t)
           (and (= 1 (length (setq all-completions
                                   (idlwave-uniquify
-                                   (all-completions part list 
-                                                    (or special-selector 
+                                   (all-completions part list
+                                                    (or special-selector
                                                         selector))))))
                (equal dpart dcompletion)))
       ;; This is already complete
       (idlwave-after-successful-completion type slash beg)
       (message "%s is already the complete %s" part isa)
       nil)
-     (t        
+     (t
       ;; We cannot add something - offer a list.
       (message "Making completion list...")
-      
+
       (unless idlwave-completion-help-links ; already set somewhere?
         (mapcar (lambda (x)  ; Pass link prop through to highlight-linked
                   (let ((link (get-text-property 0 'link (car x))))
                     (if link
-                        (push (cons (car x) link) 
+                        (push (cons (car x) link)
                               idlwave-completion-help-links))))
                 list))
       (let* ((list all-completions)
@@ -6250,7 +6250,7 @@ accumulate information on matching completions."
 ;            (completion-fixup-function               ; Emacs
 ;             (lambda () (and (eq (preceding-char) ?>)
 ;                             (re-search-backward " <" beg t)))))
-             
+
         (setq list (sort list (lambda (a b)
                                 (string< (downcase a) (downcase b)))))
         (if prepare-display-function
@@ -6260,7 +6260,7 @@ accumulate information on matching completions."
                      idlwave-complete-empty-string-as-lower-case)
                  (not idlwave-completion-force-default-case))
             (setq list (mapcar (lambda (x)
-                                 (if (listp x) 
+                                 (if (listp x)
                                      (setcar x (downcase (car x)))
                                    (setq x (downcase x)))
                                  x)
@@ -6280,19 +6280,19 @@ accumulate information on matching completions."
            (re-search-backward "\\<\\(pro\\|function\\)[ \t]+\\="
                                (- (point) 15) t)
            (goto-char (point-min))
-           (re-search-forward 
+           (re-search-forward
             "^[ \t]*\\(pro\\|function\\)[ \t]+\\([a-zA-Z0-9_]+::\\)" nil t))))
       ;; Yank the full class specification
       (insert (match-string 2))
     ;; Do the completion, using list gathered from `idlwave-routines'
-    (idlwave-complete-in-buffer 
-     'class 'class (idlwave-class-alist) nil 
+    (idlwave-complete-in-buffer
+     'class 'class (idlwave-class-alist) nil
      "Select a class" "class"
      '(lambda (list)  ;; Push it to help-links if system help available
         (mapcar (lambda (x)
                   (let* ((entry (idlwave-class-info x))
                          (link (nth 1 (assq 'link entry))))
-                    (if link (push (cons x link) 
+                    (if link (push (cons x link)
                                    idlwave-completion-help-links))
                     x))
                 list)))))
@@ -6304,7 +6304,7 @@ accumulate information on matching completions."
   ;; SHOW-CLASSES is the value of `idlwave-completion-show-classes'.
   (if (or (null show-classes)           ; don't want to see classes
           (null class-selector)         ; not a method call
-          (and 
+          (and
            (stringp class-selector) ; the class is already known
            (not super-classes)))    ; no possibilities for inheritance
       ;; In these cases, we do not have to do anything
@@ -6319,13 +6319,13 @@ accumulate information on matching completions."
            (max (abs show-classes))
            (lmax (if do-dots (apply 'max (mapcar 'length list))))
           classes nclasses class-info space)
-      (mapcar 
+      (mapcar
        (lambda (x)
          ;; get the classes
          (if (eq type 'class-tag)
              ;; Just one class for tags
              (setq classes
-                   (list 
+                   (list
                     (idlwave-class-or-superclass-with-tag class-selector x)))
            ;; Multiple classes for method or method-keyword
            (setq classes
@@ -6334,7 +6334,7 @@ accumulate information on matching completions."
                       method-selector x type-selector)
                    (idlwave-all-method-classes x type-selector)))
            (if inherit
-               (setq classes 
+               (setq classes
                      (delq nil
                            (mapcar (lambda (x) (if (memq x inherit) x nil))
                                    classes)))))
@@ -6371,7 +6371,7 @@ accumulate information on matching completions."
 (defun idlwave-attach-class-tag-classes (list)
   ;; Call idlwave-attach-classes with class structure tags
   (idlwave-attach-classes list 'class-tag idlwave-completion-show-classes))
-                                        
+
 
 ;;----------------------------------------------------------------------
 ;;----------------------------------------------------------------------
@@ -6392,7 +6392,7 @@ sort the list before displaying"
           ((= 1 (length list))
            (setq rtn (car list)))
           ((featurep 'xemacs)
-           (if sort (setq list (sort list (lambda (a b) 
+           (if sort (setq list (sort list (lambda (a b)
                                             (string< (upcase a) (upcase b))))))
            (setq menu
                  (append (list title)
@@ -6403,7 +6403,7 @@ sort the list before displaying"
            (setq resp (get-popup-menu-response menu))
            (funcall (event-function resp) (event-object resp)))
           (t
-           (if sort (setq list (sort list (lambda (a b) 
+           (if sort (setq list (sort list (lambda (a b)
                                             (string< (upcase a) (upcase b))))))
            (setq menu (cons title
                             (list
@@ -6494,7 +6494,7 @@ sort the list before displaying"
     (setq idlwave-before-completion-wconf (current-window-configuration)))
 
   (if (featurep 'xemacs)
-      (idlwave-display-completion-list-xemacs 
+      (idlwave-display-completion-list-xemacs
        list)
     (idlwave-display-completion-list-emacs list))
 
@@ -6575,7 +6575,7 @@ If these don't exist, a letter in the string is automatically selected."
             (mapcar (lambda(x)
                       (princ (nth 1 x))
                       (princ "\n"))
-                    keys-alist))            
+                    keys-alist))
           (setq char (read-char)))
       (setq char (read-char)))
     (message nil)
@@ -6695,7 +6695,7 @@ If these don't exist, a letter in the string is automatically selected."
 (defun idlwave-make-modified-completion-map-emacs (old-map)
   "Replace `choose-completion' and `mouse-choose-completion' in OLD-MAP."
   (let ((new-map (copy-keymap old-map)))
-    (substitute-key-definition 
+    (substitute-key-definition
      'choose-completion 'idlwave-choose-completion new-map)
     (substitute-key-definition
      'mouse-choose-completion 'idlwave-mouse-choose-completion new-map)
@@ -6721,8 +6721,8 @@ If these don't exist, a letter in the string is automatically selected."
 ;;
 ;; - Go again over the documentation how to write a completion
 ;;   plugin.  It is in self.el, but currently still very bad.
-;;   This could be in a separate file in the distribution, or 
-;;   in an appendix for the manual.  
+;;   This could be in a separate file in the distribution, or
+;;   in an appendix for the manual.
 
 (defvar idlwave-struct-skip
   "[ \t]*\\(\\$.*\n\\(^[ \t]*\\(\\$[ \t]*\\)?\\(;.*\\)?\n\\)*\\)?[ \t]*"
@@ -6761,7 +6761,7 @@ Point is expected just before the opening `{' of the struct definition."
          (beg (car borders))
          (end (cdr borders))
          (case-fold-search t))
-    (re-search-forward (concat "\\(^[ \t]*\\|[,{][ \t]*\\)" tag "[ \t]*:") 
+    (re-search-forward (concat "\\(^[ \t]*\\|[,{][ \t]*\\)" tag "[ \t]*:")
                        end t)))
 
 (defun idlwave-struct-inherits ()
@@ -6776,7 +6776,7 @@ Point is expected just before the opening `{' of the struct definition."
       (goto-char beg)
       (save-restriction
         (narrow-to-region beg end)
-        (while (re-search-forward 
+        (while (re-search-forward
                 (concat "[{,]"  ;leading comma/brace
                         idlwave-struct-skip ; 4 groups
                         "inherits"    ; The INHERITS tag
@@ -6826,9 +6826,9 @@ backward."
                   (concat "\\<" (regexp-quote (downcase var)) "\\>" ws)
                 "\\(\\)")
               "=" ws "\\({\\)"
-              (if name 
+              (if name
                   (if (stringp name)
-                      (concat ws "\\(\\<" (downcase name) "\\)[^a-zA-Z0-9_$]") 
+                      (concat ws "\\(\\<" (downcase name) "\\)[^a-zA-Z0-9_$]")
                     ;; Just a generic name
                     (concat ws "\\<\\([a-zA-Z_0-9$]+\\)" ws ","))
                 ""))))
@@ -6839,7 +6839,7 @@ backward."
           (goto-char (match-beginning 3))
           (match-string-no-properties 5)))))
 
-(defvar idlwave-class-info nil) 
+(defvar idlwave-class-info nil)
 (defvar idlwave-system-class-info nil) ; Gathered from idlw-rinfo
 (defvar idlwave-class-reset nil) ; to reset buffer-local classes
 
@@ -6852,13 +6852,13 @@ backward."
   (let (list entry)
     (if idlwave-class-info
         (if idlwave-class-reset
-            (setq           
+            (setq
              idlwave-class-reset nil
              idlwave-class-info ; Remove any visited in a buffer
-             (delq nil (mapcar 
-                        (lambda (x) 
-                          (let ((filebuf 
-                                 (idlwave-class-file-or-buffer 
+             (delq nil (mapcar
+                        (lambda (x)
+                          (let ((filebuf
+                                 (idlwave-class-file-or-buffer
                                   (or (cdr (assq 'found-in x)) (car x)))))
                             (if (cdr filebuf)
                                 nil
@@ -6896,7 +6896,7 @@ class/struct definition"
           (progn
             ;; For everything there
             (setq end-lim (save-excursion (idlwave-end-of-subprogram) (point)))
-            (while (setq name 
+            (while (setq name
                          (idlwave-find-structure-definition nil t end-lim))
               (funcall all-hook name)))
         (idlwave-find-structure-definition nil (or alt-class class))))))
@@ -6934,11 +6934,11 @@ class/struct definition"
           (insert-file-contents file))
         (save-excursion
           (goto-char 1)
-          (idlwave-find-class-definition class 
+          (idlwave-find-class-definition class
            ;; Scan all of the structures found there
            (lambda (name)
              (let* ((this-class (idlwave-sintern-class name))
-                    (entry 
+                    (entry
                      (list this-class
                            (cons 'tags (idlwave-struct-tags))
                            (cons 'inherits (idlwave-struct-inherits)))))
@@ -6963,7 +6963,7 @@ class/struct definition"
   (condition-case err
       (apply 'append (mapcar 'idlwave-class-tags
                              (cons class (idlwave-all-class-inherits class))))
-    (error           
+    (error
      (idlwave-class-tag-reset)
      (error "%s" (error-message-string err)))))
 
@@ -7000,24 +7000,24 @@ The list is cached in `idlwave-class-info' for faster access."
           all-inherits))))))
 
 (defun idlwave-entry-keywords (entry &optional record-link)
-  "Return the flat entry keywords alist from routine-info entry.  
+  "Return the flat entry keywords alist from routine-info entry.
 If RECORD-LINK is non-nil, the keyword text is copied and a text
 property indicating the link is added."
   (let (kwds)
     (mapcar
-     (lambda (key-list) 
+     (lambda (key-list)
        (let ((file (car key-list)))
          (mapcar (lambda (key-cons)
                    (let ((key (car key-cons))
                          (link (cdr key-cons)))
                      (when (and record-link file)
                          (setq key (copy-sequence key))
-                         (put-text-property 
+                         (put-text-property
                           0 (length key)
-                          'link 
-                          (concat 
-                           file 
-                           (if link 
+                          'link
+                          (concat
+                           file
+                           (if link
                                (concat idlwave-html-link-sep
                                        (number-to-string link))))
                           key))
@@ -7030,13 +7030,13 @@ property indicating the link is added."
   "Find keyword KEYWORD in entry ENTRY, and return (with link) if set"
   (catch 'exit
     (mapc
-     (lambda (key-list) 
+     (lambda (key-list)
        (let ((file (car key-list))
              (kwd (assoc keyword (cdr key-list))))
          (when kwd
-           (setq kwd (cons (car kwd) 
+           (setq kwd (cons (car kwd)
                            (if (and file (cdr kwd))
-                               (concat file 
+                               (concat file
                                        idlwave-html-link-sep
                                        (number-to-string (cdr kwd)))
                              (cdr kwd))))
@@ -7074,14 +7074,14 @@ property indicating the link is added."
           ;; Check if we need to update the "current" class
           (if (not (equal class-selector idlwave-current-tags-class))
               (idlwave-prepare-class-tag-completion class-selector))
-          (setq idlwave-completion-help-info 
+          (setq idlwave-completion-help-info
                 (list 'idlwave-complete-class-structure-tag-help
-                      (idlwave-sintern-routine 
+                      (idlwave-sintern-routine
                        (concat class-selector "__define"))
                       nil))
           (let  ((idlwave-cpl-bold idlwave-current-native-class-tags))
             (idlwave-complete-in-buffer
-             'class-tag 'class-tag 
+             'class-tag 'class-tag
              idlwave-current-class-tags nil
              (format "Select a tag of class %s" class-selector)
              "class tag"
@@ -7133,7 +7133,7 @@ Gets set in `idlw-rinfo.el'.")
              (skip-chars-backward "[a-zA-Z0-9_$]")
              (equal (char-before) ?!))
            (setq idlwave-completion-help-info '(idlwave-complete-sysvar-help))
-           (idlwave-complete-in-buffer 'sysvar 'sysvar 
+           (idlwave-complete-in-buffer 'sysvar 'sysvar
                                        idlwave-system-variables-alist nil
                                        "Select a system variable"
                                        "system variable")
@@ -7152,7 +7152,7 @@ Gets set in `idlw-rinfo.el'.")
              (or tags (error "System variable !%s is not a structure" var))
              (setq idlwave-completion-help-info
                    (list 'idlwave-complete-sysvar-tag-help var))
-             (idlwave-complete-in-buffer 'sysvartag 'sysvartag 
+             (idlwave-complete-in-buffer 'sysvartag 'sysvartag
                                          tags nil
                                          "Select a system variable tag"
                                          "system variable tag")
@@ -7179,8 +7179,8 @@ Gets set in `idlw-rinfo.el'.")
      ((eq mode 'test) ; we can at least link the main
       (and (stringp word) entry main))
      ((eq mode 'set)
-      (if entry 
-          (setq link 
+      (if entry
+          (setq link
                 (if (setq target (cdr (assoc word tags)))
                   (idlwave-substitute-link-target main target)
                 main)))) ;; setting dynamic!!!
@@ -7198,7 +7198,7 @@ Gets set in `idlw-rinfo.el'.")
 
 ;; Fake help in the source buffer for class structure tags.
 ;; KWD AND NAME ARE GLOBAL-VARIABLES HERE.
-(defvar name) 
+(defvar name)
 (defvar kwd)
 (defvar idlwave-help-do-class-struct-tag nil)
 (defun idlwave-complete-class-structure-tag-help (mode word)
@@ -7207,13 +7207,13 @@ Gets set in `idlw-rinfo.el'.")
     nil)
    ((eq mode 'set)
     (let (class-with found-in)
-      (when (setq class-with 
-                (idlwave-class-or-superclass-with-tag 
+      (when (setq class-with
+                (idlwave-class-or-superclass-with-tag
                  idlwave-current-tags-class
                  word))
-        (if (assq (idlwave-sintern-class class-with) 
+        (if (assq (idlwave-sintern-class class-with)
                   idlwave-system-class-info)
-            (error "No help available for system class tags."))
+            (error "No help available for system class tags"))
         (if (setq found-in (idlwave-class-found-in class-with))
             (setq name (cons (concat found-in "__define") class-with))
           (setq name (concat class-with "__define")))))
@@ -7224,7 +7224,7 @@ Gets set in `idlw-rinfo.el'.")
 (defun idlwave-class-or-superclass-with-tag (class tag)
   "Find and return the CLASS or one of its superclass with the
 associated TAG, if any."
-  (let ((sclasses (cons class (cdr (assq 'all-inherits 
+  (let ((sclasses (cons class (cdr (assq 'all-inherits
                                          (idlwave-class-info class)))))
         cl)
    (catch 'exit
@@ -7233,7 +7233,7 @@ associated TAG, if any."
        (let ((tags (idlwave-class-tags cl)))
          (while tags
            (if (eq t (compare-strings tag 0 nil (car tags) 0 nil t))
-             (throw 'exit cl))         
+             (throw 'exit cl))
            (setq tags (cdr tags))))))))
 
 
@@ -7256,8 +7256,8 @@ associated TAG, if any."
       (setcar entry (idlwave-sintern-sysvar (car entry) 'set))
       (setq tags (assq 'tags entry))
       (if tags
-          (setcdr tags 
-                  (mapcar (lambda (x) 
+          (setcdr tags
+                  (mapcar (lambda (x)
                             (cons (idlwave-sintern-sysvartag (car x) 'set)
                                   (cdr x)))
                           (cdr tags)))))))
@@ -7274,19 +7274,19 @@ associated TAG, if any."
                          text start)
       (setq start (match-end 0)
             var (match-string 1 text)
-            tags (if (match-end 3) 
+            tags (if (match-end 3)
                      (idlwave-split-string (match-string 3 text))))
       ;; Maintain old links, if present
       (setq old-entry (assq (idlwave-sintern-sysvar var) old))
       (setq link (assq 'link old-entry))
       (setq idlwave-system-variables-alist
-            (cons (list var 
-                        (cons 
-                         'tags 
-                         (mapcar (lambda (x) 
-                                   (cons x 
-                                         (cdr (assq 
-                                               (idlwave-sintern-sysvartag x) 
+            (cons (list var
+                        (cons
+                         'tags
+                         (mapcar (lambda (x)
+                                   (cons x
+                                         (cdr (assq
+                                               (idlwave-sintern-sysvartag x)
                                                (cdr (assq 'tags old-entry))))))
                                  tags)) link)
                   idlwave-system-variables-alist)))
@@ -7308,9 +7308,9 @@ associated TAG, if any."
 
 (defun idlwave-uniquify (list)
   (let ((ht (make-hash-table :size (length list) :test 'equal)))
-    (delq nil 
+    (delq nil
           (mapcar (lambda (x)
-                    (unless (gethash x ht) 
+                    (unless (gethash x ht)
                       (puthash x t ht)
                       x))
                   list))))
@@ -7338,11 +7338,11 @@ Restore the pre-completion window configuration if possible."
       nil)))
 
   ;; Restore the pre-completion window configuration if this is safe.
-  
-  (if (or (eq verify 'force)                                    ; force 
-          (and 
+
+  (if (or (eq verify 'force)                                    ; force
+          (and
            (get-buffer-window "*Completions*")                  ; visible
-           (idlwave-local-value 'idlwave-completion-p 
+           (idlwave-local-value 'idlwave-completion-p
                                 "*Completions*")                ; cib-buffer
            (eq (marker-buffer idlwave-completion-mark)
                (current-buffer))                                ; buffer OK
@@ -7440,7 +7440,7 @@ With ARG, enforce query for the class of object methods."
     (if (string-match "\\(pro\\|function\\)[ \t]+\\(\\(.*\\)::\\)?\\(.*\\)"
                       resolve)
         (setq type (match-string 1 resolve)
-              class (if (match-beginning 2) 
+              class (if (match-beginning 2)
                         (match-string 3 resolve)
                       nil)
               name (match-string 4 resolve)))
@@ -7449,15 +7449,15 @@ With ARG, enforce query for the class of object methods."
 
     (cond
      ((null class)
-      (idlwave-shell-send-command 
+      (idlwave-shell-send-command
        (format "resolve_routine,'%s'%s" (downcase name) kwd)
        'idlwave-update-routine-info
        nil t))
      (t
-      (idlwave-shell-send-command 
+      (idlwave-shell-send-command
        (format "resolve_routine,'%s__define'%s" (downcase class) kwd)
-       (list 'idlwave-shell-send-command 
-             (format "resolve_routine,'%s__%s'%s" 
+       (list 'idlwave-shell-send-command
+             (format "resolve_routine,'%s__%s'%s"
                      (downcase class) (downcase name) kwd)
              '(idlwave-update-routine-info)
              nil t))))))
@@ -7474,19 +7474,19 @@ force class query for object methods."
          (this-buffer (equal arg '(4)))
          (module (idlwave-fix-module-if-obj_new (idlwave-what-module)))
          (default (if module
-                      (concat (idlwave-make-full-name 
+                      (concat (idlwave-make-full-name
                                (nth 2 module) (car module))
                               (if (eq (nth 1 module) 'pro) "<p>" "<f>"))
                     "none"))
-         (list 
+         (list
           (idlwave-uniquify
            (delq nil
-                 (mapcar (lambda (x) 
+                 (mapcar (lambda (x)
                            (if (eq 'system (car-safe (nth 3 x)))
                                ;; Take out system routines with no source.
                                nil
                              (list
-                              (concat (idlwave-make-full-name 
+                              (concat (idlwave-make-full-name
                                        (nth 2 x) (car x))
                                       (if (eq (nth 1 x) 'pro) "<p>" "<f>")))))
                          (if this-buffer
@@ -7515,10 +7515,10 @@ force class query for object methods."
                      (t t)))
     (idlwave-do-find-module name type class nil this-buffer)))
 
-(defun idlwave-do-find-module (name type class 
+(defun idlwave-do-find-module (name type class
                                     &optional force-source this-buffer)
   (let ((name1 (idlwave-make-full-name class name))
-        source buf1 entry 
+        source buf1 entry
         (buf (current-buffer))
         (pos (point))
         file name2)
@@ -7528,11 +7528,11 @@ force class query for object methods."
           name2 (if (nth 2 entry)
                     (idlwave-make-full-name (nth 2 entry) name)
                   name1))
-    (if source  
+    (if source
         (setq file (idlwave-routine-source-file source)))
     (unless file  ; Try to find it on the path.
-      (setq file 
-            (idlwave-expand-lib-file-name 
+      (setq file
+            (idlwave-expand-lib-file-name
              (if class
                  (format "%s__define.pro" (downcase class))
                (format "%s.pro" (downcase name))))))
@@ -7540,14 +7540,14 @@ force class query for object methods."
      ((or (null name) (equal name ""))
       (error "Abort"))
      ((eq (car source) 'system)
-      (error "Source code for system routine %s is not available" 
+      (error "Source code for system routine %s is not available"
              name2))
      ((or (not file) (not (file-regular-p file)))
       (error "Source code for routine %s is not available"
              name2))
      (t
       (when (not this-buffer)
-        (setq buf1 
+        (setq buf1
               (idlwave-find-file-noselect file 'find))
         (pop-to-buffer buf1 t))
       (goto-char (point-max))
@@ -7557,7 +7557,7 @@ force class query for object methods."
                      (cond ((eq type 'fun) "function")
                            ((eq type 'pro) "pro")
                            (t "\\(pro\\|function\\)"))
-                     "\\>[ \t]+" 
+                     "\\>[ \t]+"
                      (regexp-quote (downcase name2))
                      "[^a-zA-Z0-9_$]")
              nil t)
@@ -7594,17 +7594,17 @@ Used by `idlwave-routine-info' and `idlwave-find-module'."
       (cond
        ((and (eq cw 'procedure)
              (not (equal this-word "")))
-        (setq this-word (idlwave-sintern-routine-or-method 
+        (setq this-word (idlwave-sintern-routine-or-method
                          this-word (nth 2 (nth 3 where))))
         (list this-word 'pro
-              (idlwave-determine-class 
+              (idlwave-determine-class
                (cons this-word (cdr (nth 3 where)))
                'pro)))
-       ((and (eq cw 'function) 
+       ((and (eq cw 'function)
              (not (equal this-word ""))
              (or (eq next-char ?\()     ; exclude arrays, vars.
                  (looking-at "[a-zA-Z0-9_]*[ \t]*(")))
-        (setq this-word (idlwave-sintern-routine-or-method 
+        (setq this-word (idlwave-sintern-routine-or-method
                          this-word (nth 2 (nth 3 where))))
         (list this-word 'fun
               (idlwave-determine-class
@@ -7641,7 +7641,7 @@ Used by `idlwave-routine-info' and `idlwave-find-module'."
       class)))
 
 (defun idlwave-fix-module-if-obj_new (module)
-  "Check if MODULE points to obj_new.  
+  "Check if MODULE points to obj_new.
 If yes, and if the cursor is in the keyword region, change to the
 appropriate Init method."
   (let* ((name (car module))
@@ -7681,30 +7681,30 @@ from all classes if class equals t."
                              string)
                (setq class (idlwave-sintern-class (match-string 1 string)))
                (setq idlwave-current-obj_new-class class)
-               (setq keywords 
-                     (append keywords 
+               (setq keywords
+                     (append keywords
                              (idlwave-entry-keywords
                               (idlwave-rinfo-assq
                                (idlwave-sintern-method "INIT")
                                'fun
                                class
                                (idlwave-routines)) 'do-link))))))
-    
+
     ;; If the class is `t', combine all keywords of all methods NAME
     (when (eq class t)
       (mapc (lambda (entry)
               (and
                (nth 2 entry)             ; non-nil class
                (eq (nth 1 entry) type)   ; correct type
-               (setq keywords 
-                     (append keywords 
+               (setq keywords
+                     (append keywords
                              (idlwave-entry-keywords entry 'do-link)))))
             (idlwave-all-assq name (idlwave-routines)))
       (setq keywords (idlwave-uniquify keywords)))
-    
+
     ;; If we have inheritance, add all keywords from superclasses, if
     ;; the user indicated that method in `idlwave-keyword-class-inheritance'
-    (when (and 
+    (when (and
            super-classes
            idlwave-keyword-class-inheritance
            (stringp class)
@@ -7724,7 +7724,7 @@ from all classes if class equals t."
                  (mapcar (lambda (k) (add-to-list 'keywords k))
                          (idlwave-entry-keywords entry 'do-link))))
       (setq keywords (idlwave-uniquify keywords)))
-    
+
     ;; Return the final list
     keywords))
 
@@ -7749,14 +7749,14 @@ If we do not know about MODULE, just return KEYWORD literally."
                     (assq (idlwave-sintern-keyword "_REF_EXTRA") kwd-alist)))
          (completion-ignore-case t)
          candidates)
-    (cond ((assq kwd kwd-alist) 
+    (cond ((assq kwd kwd-alist)
            kwd)
           ((setq candidates (all-completions kwd kwd-alist))
            (if (= (length candidates) 1)
                (car candidates)
              candidates))
           ((and entry extra)
-           ;; Inheritance may cause this keyword to be correct 
+           ;; Inheritance may cause this keyword to be correct
            keyword)
           (entry
            ;; We do know the function, which does not have the keyword.
@@ -7768,13 +7768,13 @@ If we do not know about MODULE, just return KEYWORD literally."
 
 (defvar idlwave-rinfo-mouse-map (make-sparse-keymap))
 (defvar idlwave-rinfo-map (make-sparse-keymap))
-(define-key idlwave-rinfo-mouse-map 
+(define-key idlwave-rinfo-mouse-map
   (if (featurep 'xemacs) [button2] [mouse-2])
   'idlwave-mouse-active-rinfo)
-(define-key idlwave-rinfo-mouse-map 
+(define-key idlwave-rinfo-mouse-map
   (if (featurep 'xemacs) [(shift button2)] [(shift mouse-2)])
   'idlwave-mouse-active-rinfo-shift)
-(define-key idlwave-rinfo-mouse-map 
+(define-key idlwave-rinfo-mouse-map
   (if (featurep 'xemacs) [button3] [mouse-3])
   'idlwave-mouse-active-rinfo-right)
 (define-key idlwave-rinfo-mouse-map " " 'idlwave-active-rinfo-space)
@@ -7800,7 +7800,7 @@ If we do not know about MODULE, just return KEYWORD literally."
   (let* ((initial-class (or initial-class class))
          (entry (or (idlwave-best-rinfo-assq name type class
                                              (idlwave-routines))
-                    (idlwave-rinfo-assq name type class 
+                    (idlwave-rinfo-assq name type class
                                         idlwave-unresolved-routines)))
          (name (or (car entry) name))
          (class (or (nth 2 entry) class))
@@ -7825,7 +7825,7 @@ If we do not know about MODULE, just return KEYWORD literally."
          (km-prop (if (featurep 'xemacs) 'keymap 'local-map))
          (face 'idlwave-help-link-face)
          beg props win cnt total)
-    ;; Fix keywords, but don't add chained super-classes, since these 
+    ;; Fix keywords, but don't add chained super-classes, since these
     ;; are shown separately for that super-class
     (setq keywords (idlwave-fix-keywords name type class keywords))
     (cond
@@ -7867,7 +7867,7 @@ If we do not know about MODULE, just return KEYWORD literally."
                           km-prop idlwave-rinfo-mouse-map
                           'help-echo help-echo-use
                           'data (cons 'usage data)))
-        (if html-file (setq props (append (list 'face face 'link html-file) 
+        (if html-file (setq props (append (list 'face face 'link html-file)
                                           props)))
         (insert "Usage:    ")
         (setq beg (point))
@@ -7876,14 +7876,14 @@ If we do not know about MODULE, just return KEYWORD literally."
                   (format calling-seq name name name name))
                 "\n")
         (add-text-properties beg (point) props)
-        
+
         (insert "Keywords:")
         (if (null keywords)
             (insert " No keywords accepted.")
           (setq col 9)
           (mapcar
            (lambda (x)
-             (if (>= (+ col 1 (length (car x))) 
+             (if (>= (+ col 1 (length (car x)))
                      (window-width))
                  (progn
                    (insert "\n         ")
@@ -7901,7 +7901,7 @@ If we do not know about MODULE, just return KEYWORD literally."
              (add-text-properties beg (point) props)
              (setq col (+ col 1 (length (car x)))))
            keywords))
-        
+
         (setq cnt 1 total (length all))
         ;; Here entry is (key file (list of type-conses))
         (while (setq entry (pop all))
@@ -7914,7 +7914,7 @@ If we do not know about MODULE, just return KEYWORD literally."
                                           (cdr (car (nth 2 entry))))
                             'data (cons 'source data)))
           (idlwave-insert-source-location
-           (format "\n%-8s  %s" 
+           (format "\n%-8s  %s"
                    (if (equal cnt 1)
                        (if (> total 1) "Sources:" "Source:")
                      "")
@@ -7923,7 +7923,7 @@ If we do not know about MODULE, just return KEYWORD literally."
           (incf cnt)
           (when (and all (> cnt idlwave-rinfo-max-source-lines))
             ;; No more source lines, please
-            (insert (format 
+            (insert (format
                      "\n          Source information truncated to %d entries."
                      idlwave-rinfo-max-source-lines))
             (setq all nil)))
@@ -7937,7 +7937,7 @@ If we do not know about MODULE, just return KEYWORD literally."
               (unwind-protect
                   (progn
                     (select-window win)
-                    (enlarge-window (- (/ (frame-height) 2) 
+                    (enlarge-window (- (/ (frame-height) 2)
                                        (window-height)))
                     (shrink-window-if-larger-than-buffer))
                 (select-window ww)))))))))
@@ -7974,9 +7974,9 @@ it."
      ((and (not file) shell-flag)
       (insert "Unresolved"))
 
-     ((null file)               
+     ((null file)
       (insert "ERROR"))
-     
+
      ((idlwave-syslib-p file)
       (if (string-match "obsolete" (file-name-directory file))
           (insert "Obsolete  ")
@@ -7990,7 +7990,7 @@ it."
      ;; Old special syntax: a matching regexp
      ((setq special (idlwave-special-lib-test file))
       (insert (format "%-10s" special)))
-     
+
      ;; Catch-all with file
      ((idlwave-lib-p file)      (insert "Library   "))
 
@@ -8005,7 +8005,7 @@ it."
                (if shell-flag "S" "-")
                (if buffer-flag "B" "-")
                "] ")))
-    (when (> ndupl 1) 
+    (when (> ndupl 1)
       (setq beg (point))
       (insert (format "(%dx) " ndupl))
       (add-text-properties beg (point) (list 'face 'bold)))
@@ -8029,7 +8029,7 @@ Return the name of the special lib if there is a match."
                   alist nil)))
       rtn)
      (t nil))))
-  
+
 (defun idlwave-mouse-active-rinfo-right (ev)
   (interactive "e")
   (idlwave-mouse-active-rinfo ev 'right))
@@ -8062,9 +8062,9 @@ was pressed."
 
     (cond ((eq id 'class) ; Switch class being displayed
            (if (window-live-p bufwin) (select-window bufwin))
-           (idlwave-display-calling-sequence 
+           (idlwave-display-calling-sequence
             (idlwave-sintern-method name)
-            type (idlwave-sintern-class word) 
+            type (idlwave-sintern-class word)
             initial-class))
           ((eq id 'usage) ; Online help on this routine
            (idlwave-online-help link name type class))
@@ -8105,9 +8105,9 @@ was pressed."
       (setq bwin (get-buffer-window buffer)))
     (if (eq (preceding-char) ?/)
         (insert keyword)
-      (unless (save-excursion 
+      (unless (save-excursion
                 (re-search-backward
-                 "[(,][ \t]*\\(\\$[ \t]*\\(;.*\\)?\n\\)?[ \t]*\\=" 
+                 "[(,][ \t]*\\(\\$[ \t]*\\(;.*\\)?\n\\)?[ \t]*\\="
                  (min (- (point) 100) (point-min)) t))
         (insert ", "))
       (if shift (insert "/"))
@@ -8159,7 +8159,7 @@ the load path in order to find a definition.  The output of this
 command can be used to detect possible name clashes during this process."
   (idlwave-routines)  ; Make sure everything is loaded.
   (unless (or idlwave-user-catalog-routines idlwave-library-catalog-routines)
-    (or (y-or-n-p 
+    (or (y-or-n-p
          "You don't have any user or library catalogs.  Continue anyway? ")
         (error "Abort")))
   (let* ((routines (append idlwave-system-routines
@@ -8172,7 +8172,7 @@ command can be used to detect possible name clashes during this process."
          (keymap (make-sparse-keymap))
          (props (list 'mouse-face 'highlight
                       km-prop keymap
-                      'help-echo "Mouse2: Find source"))      
+                      'help-echo "Mouse2: Find source"))
          (nroutines (length (or special-routines routines)))
          (step (/ nroutines 99))
          (n 0)
@@ -8196,13 +8196,13 @@ command can be used to detect possible name clashes during this process."
     (message "Sorting routines...done")
 
     (define-key keymap (if (featurep 'xemacs) [(button2)] [(mouse-2)])
-      (lambda (ev) 
+      (lambda (ev)
         (interactive "e")
         (mouse-set-point ev)
         (apply 'idlwave-do-find-module
                (get-text-property (point) 'find-args))))
     (define-key keymap [(return)]
-      (lambda () 
+      (lambda ()
         (interactive)
         (apply 'idlwave-do-find-module
                (get-text-property (point) 'find-args))))
@@ -8230,13 +8230,13 @@ command can be used to detect possible name clashes during this process."
                   (> (idlwave-count-memq 'buffer (nth 2 (car dtwins))) 1))
           (incf cnt)
           (insert (format "\n%s%s"
-                          (idlwave-make-full-name (nth 2 routine) 
+                          (idlwave-make-full-name (nth 2 routine)
                                                   (car routine))
                           (if (eq (nth 1 routine) 'fun) "()" "")))
           (while (setq twin (pop dtwins))
             (setq props1 (append (list 'find-args
-                                       (list (nth 0 routine) 
-                                             (nth 1 routine) 
+                                       (list (nth 0 routine)
+                                             (nth 1 routine)
                                              (nth 2 routine)))
                                  props))
             (idlwave-insert-source-location "\n   - " twin props1))))
@@ -8259,7 +8259,7 @@ command can be used to detect possible name clashes during this process."
              (or (not (stringp sfile))
                  (not (string-match "\\S-" sfile))))
         (setq stype 'unresolved))
-    (princ (format "      %-10s %s\n" 
+    (princ (format "      %-10s %s\n"
                    stype
                    (if sfile sfile "No source code available")))))
 
@@ -8278,20 +8278,20 @@ ENTRY will also be returned, as the first item of this list."
                (eq type (nth 1 candidate))
                (eq class (nth 2 candidate)))
           (push candidate twins)))
-    (if (setq candidate (idlwave-rinfo-assq name type class 
+    (if (setq candidate (idlwave-rinfo-assq name type class
                                             idlwave-unresolved-routines))
         (push candidate twins))
     (cons entry (nreverse twins))))
 
 (defun idlwave-study-twins (entries)
-  "Return dangerous twins of first entry in ENTRIES.  
+  "Return dangerous twins of first entry in ENTRIES.
 Dangerous twins are routines with same name, but in different files on
 the load path.  If a file is in the system library and has an entry in
 the `idlwave-system-routines' list, we omit the latter as
 non-dangerous because many IDL routines are implemented as library
 routines, and may have been scanned."
   (let* ((entry (car entries))
-         (name (car entry))      ; 
+         (name (car entry))      ;
          (type (nth 1 entry))    ; Must be bound for
          (class (nth 2 entry))   ;  idlwave-routine-twin-compare
          (cnt 0)
@@ -8309,23 +8309,23 @@ routines, and may have been scanned."
                       (t 'unresolved)))
 
       ;; Check for an entry in the system library
-      (if (and file 
+      (if (and file
                (not syslibp)
                (idlwave-syslib-p file))
           (setq syslibp t))
-      
+
       ;; If there's more than one matching entry for the same file, just
       ;; append the type-cons to the type list.
       (if (setq entry (assoc key alist))
           (push type-cons (nth 2 entry))
         (push (list key file (list type-cons)) alist)))
-    
+
     (setq alist (nreverse alist))
-    
+
     (when syslibp
       ;; File is in system *library* - remove any 'system entry
       (setq alist (delq (assq 'system alist) alist)))
-    
+
     ;; If 'system remains and we've scanned the syslib, it's a builtin
     ;; (rather than a !DIR/lib/.pro file bundled as source).
     (when (and (idlwave-syslib-scanned-p)
@@ -8362,7 +8362,7 @@ compares twins on the basis of their file names and path locations."
      ((not (eq type (nth 1 b)))
       ;; Type decides
       (< (if (eq type 'fun) 1 0) (if (eq (nth 1 b) 'fun) 1 0)))
-     (t 
+     (t
       ;; A and B are twins - so the decision is more complicated.
       ;; Call twin-compare with the proper arguments.
       (idlwave-routine-entry-compare-twins a b)))))
@@ -8414,7 +8414,7 @@ This expects NAME TYPE CLASS to be bound to the right values."
          (tpath-alist (idlwave-true-path-alist))
          (apathp (and (stringp akey)
                       (assoc (file-name-directory akey) tpath-alist)))
-         (bpathp (and (stringp bkey) 
+         (bpathp (and (stringp bkey)
                       (assoc (file-name-directory bkey) tpath-alist)))
          ;; How early on search path?  High number means early since we
          ;; measure the tail of the path list
@@ -8450,7 +8450,7 @@ This expects NAME TYPE CLASS to be bound to the right values."
      (t                                nil))))  ; Default
 
 (defun idlwave-routine-source-file (source)
-  (if (nth 2 source) 
+  (if (nth 2 source)
       (expand-file-name (nth 1 source) (nth 2 source))
     (nth 1 source)))
 
@@ -8540,7 +8540,7 @@ Assumes that point is at the beginning of the unit as found by
   (forward-sexp 2)
   (forward-sexp -1)
   (let ((begin (point)))
-    (re-search-forward 
+    (re-search-forward
      "[a-zA-Z_][a-zA-Z0-9$_]+\\(::[a-zA-Z_][a-zA-Z0-9$_]+\\)?")
     (if (fboundp 'buffer-substring-no-properties)
         (buffer-substring-no-properties begin (point))
@@ -8580,12 +8580,12 @@ Assumes that point is at the beginning of the unit as found by
   (start-process "idldeclient" nil
                  idlwave-shell-explicit-file-name "-c" "-e"
                  (buffer-file-name) "&"))
-                
+
 (defun idlwave-launch-idlhelp ()
   "Start the IDLhelp application."
   (interactive)
   (start-process "idlhelp" nil idlwave-help-application))
- 
+
 ;; Menus - using easymenu.el
 (defvar idlwave-mode-menu-def
   `("IDLWAVE"
@@ -8672,7 +8672,7 @@ Assumes that point is at the beginning of the unit as found by
     ("Customize"
      ["Browse IDLWAVE Group" idlwave-customize t]
      "--"
-     ["Build Full Customize Menu" idlwave-create-customize-menu 
+     ["Build Full Customize Menu" idlwave-create-customize-menu
       (fboundp 'customize-menu-create)])
     ("Documentation"
      ["Describe Mode" describe-mode t]
@@ -8689,22 +8689,22 @@ Assumes that point is at the beginning of the unit as found by
   '("Debug"
     ["Start IDL shell" idlwave-shell t]
     ["Save and .RUN buffer" idlwave-shell-save-and-run
-     (and (boundp 'idlwave-shell-automatic-start) 
+     (and (boundp 'idlwave-shell-automatic-start)
           idlwave-shell-automatic-start)]))
 
 (if (or (featurep 'easymenu) (load "easymenu" t))
     (progn
-      (easy-menu-define idlwave-mode-menu idlwave-mode-map 
-                        "IDL and WAVE CL editing menu" 
+      (easy-menu-define idlwave-mode-menu idlwave-mode-map
+                        "IDL and WAVE CL editing menu"
                         idlwave-mode-menu-def)
-      (easy-menu-define idlwave-mode-debug-menu idlwave-mode-map 
-                        "IDL and WAVE CL editing menu" 
+      (easy-menu-define idlwave-mode-debug-menu idlwave-mode-map
+                        "IDL and WAVE CL editing menu"
                         idlwave-mode-debug-menu-def)))
 
 (defun idlwave-customize ()
   "Call the customize function with idlwave as argument."
   (interactive)
-  ;; Try to load the code for the shell, so that we can customize it 
+  ;; Try to load the code for the shell, so that we can customize it
   ;; as well.
   (or (featurep 'idlw-shell)
       (load "idlw-shell" t))
@@ -8715,11 +8715,11 @@ Assumes that point is at the beginning of the unit as found by
   (interactive)
   (if (fboundp 'customize-menu-create)
       (progn
-        ;; Try to load the code for the shell, so that we can customize it 
+        ;; Try to load the code for the shell, so that we can customize it
         ;; as well.
         (or (featurep 'idlw-shell)
             (load "idlw-shell" t))
-        (easy-menu-change 
+        (easy-menu-change
          '("IDLWAVE") "Customize"
          `(["Browse IDLWAVE group" idlwave-customize t]
            "--"
@@ -8767,7 +8767,7 @@ This function was written since `list-abbrevs' looks terrible for IDLWAVE mode."
   (let ((table (symbol-value 'idlwave-mode-abbrev-table))
         abbrevs
         str rpl func fmt (len-str 0) (len-rpl 0))
-    (mapatoms 
+    (mapatoms
      (lambda (sym)
        (if (symbol-value sym)
            (progn
@@ -8793,7 +8793,7 @@ This function was written since `list-abbrevs' looks terrible for IDLWAVE mode."
     (with-output-to-temp-buffer "*Help*"
       (if arg
           (progn
-            (princ "Abbreviations and Actions in IDLWAVE-Mode\n") 
+            (princ "Abbreviations and Actions in IDLWAVE-Mode\n")
             (princ "=========================================\n\n")
             (princ (format fmt "KEY" "REPLACE" "HOOK"))
             (princ (format fmt "---" "-------" "----")))
diff --git a/lisp/progmodes/ld-script.el b/lisp/progmodes/ld-script.el
index 120cae538d5..ef24604ba7b 100644
--- a/lisp/progmodes/ld-script.el
+++ b/lisp/progmodes/ld-script.el
@@ -1,6 +1,6 @@
 ;;; ld-script.el --- GNU linker script editing mode for Emacs
 
-;; Copyright (C) 2003 Free Software Foundation, Inc.
+;; Copyright (C) 2003, 2005 Free Software Foundation, Inc.
 
 ;; Author: Masatake YAMATO<jet@gyve.org>
 ;; Keywords: languages, faces
@@ -34,11 +34,13 @@
   :prefix "ld-script-"
   :group 'languages)
 
-(defvar ld-script-location-counter-face 'ld-script-location-counter-face)
-(defface ld-script-location-counter-face
+(defvar ld-script-location-counter-face 'ld-script-location-counter)
+(defface ld-script-location-counter
   '((t (:weight bold :inherit font-lock-builtin-face)))
   "Face for location counter in GNU ld script."
   :group 'ld-script)
+;; backward-compatibility alias
+(put 'ld-script-location-counter-face 'face-alias 'ld-script-location-counter)
 
 ;; Syntax rules
 (defvar ld-script-mode-syntax-table
diff --git a/lisp/progmodes/make-mode.el b/lisp/progmodes/make-mode.el
index 055cdf7fc7d..d9c38349b49 100644
--- a/lisp/progmodes/make-mode.el
+++ b/lisp/progmodes/make-mode.el
@@ -99,35 +99,38 @@
   :group 'tools
   :prefix "makefile-")
 
-(defface makefile-space-face
+(defface makefile-space
   '((((class color)) (:background  "hotpink"))
     (t (:reverse-video t)))
   "Face to use for highlighting leading spaces in Font-Lock mode."
   :group 'faces
   :group 'makefile)
 
-(defface makefile-targets-face
+(defface makefile-targets
   ;; This needs to go along both with foreground and background colors (i.e. shell)
-  '((t (:underline t)))
+  '((t (:inherit font-lock-function-name-face)))
   "Face to use for additionally highlighting rule targets in Font-Lock mode."
   :group 'faces
-  :group 'makefile)
+  :group 'makefile
+  :version "22.1")
 
-(defface makefile-shell-face
-  '((((class color) (background light)) (:background  "seashell1"))
-    (((class color) (background dark)) (:background  "seashell4"))
-    (t (:reverse-video t)))
+(defface makefile-shell
+  ()
+  ;;'((((class color) (min-colors 88) (background light)) (:background  "seashell1"))
+  ;;  (((class color) (min-colors 88) (background dark)) (:background  "seashell4")))
   "Face to use for additionally highlighting Shell commands in Font-Lock mode."
   :group 'faces
-  :group 'makefile)
+  :group 'makefile
+  :version "22.1")
 
-(defface makefile-makepp-perl-face
+(defface makefile-makepp-perl
   '((((class color) (background light)) (:background  "LightBlue1")) ; Camel Book
     (((class color) (background dark)) (:background  "DarkBlue"))
     (t (:reverse-video t)))
   "Face to use for additionally highlighting Perl code in Font-Lock mode."
   :group 'faces
-  :group 'makefile)
+  :group 'makefile
+  :version "22.1")
 
 (defcustom makefile-browser-buffer-name "*Macros and Targets*"
   "*Name of the macro- and target browser buffer."
@@ -259,9 +262,14 @@ not be enclosed in { } or ( )."
 ;; index in makefile-imenu-generic-expression.
 (defvar makefile-dependency-regex
   ;; Allow for two nested levels $(v1:$(v2:$(v3:a=b)=c)=d)
-  "^ *\\(\\(?: *\\$\\(?:[({]\\(?:\\$\\(?:[({]\\(?:\\$\\(?:[^({]\\|.[^\n$#})]+?[})]\\)\\|[^\n$#)}]\\)+?[})]\\|[^({]\\)\\|[^\n$#)}]\\)+?[})]\\|[^({]\\)\\| *[^ \n$#:=]+\\)+?\\)[ \t]*\\(:\\)\\(?:[ \t]*$\\|[^=\n]\\(?:[^#\n]*?;[ \t]*\\(.+\\)\\)?\\)"
+  "^\\(\\(?:\\$\\(?:[({]\\(?:\\$\\(?:[({]\\(?:\\$\\(?:[^({]\\|.[^\n$#})]+?[})]\\)\\|[^\n$#)}]\\)+?[})]\\|[^({]\\)\\|[^\n$#)}]\\)+?[})]\\|[^({]\\)\\|[^\n$#:=]\\)+?\\)\\(:\\)\\(?:[ \t]*$\\|[^=\n]\\(?:[^#\n]*?;[ \t]*\\(.+\\)\\)?\\)"
   "Regex used to find dependency lines in a makefile.")
 
+(defconst makefile-bsdmake-dependency-regex
+  (progn (string-match (regexp-quote "\\(:\\)") makefile-dependency-regex)
+         (replace-match "\\([:!]\\)" t t makefile-dependency-regex))
+  "Regex used to find dependency lines in a BSD makefile.")
+
 (defvar makefile-dependency-skip "^:"
   "Characters to skip to find a line that might be a dependency.")
 
@@ -269,11 +277,21 @@ not be enclosed in { } or ( )."
   "^\t[ \t]*\\([-@]*\\)[ \t]*\\(\\(?:.*\\\\\n\\)*.*\\)"
   "Regex used to highlight rule action lines in font lock mode.")
 
+(defconst makefile-makepp-rule-action-regex
+  ;; Don't care about initial tab, but I don't know how to font-lock correctly without.
+  "^\t[ \t]*\\(\\(?:\\(?:noecho\\|ignore[-_]error\\|[-@]+\\)[ \t]*\\)*\\)\\(\\(&\\S +\\)?\\(?:.*\\\\\n\\)*.*\\)"
+  "Regex used to highlight makepp rule action lines in font lock mode.")
+
+(defconst makefile-bsdmake-rule-action-regex
+  (progn (string-match "-@" makefile-rule-action-regex)
+         (replace-match "-+@" t t makefile-rule-action-regex))
+  "Regex used to highlight BSD rule action lines in font lock mode.")
+
 ;; Note that the first and second subexpression is used by font lock.  Note
 ;; that if you change this regexp you might have to fix the imenu index in
 ;; makefile-imenu-generic-expression.
 (defconst makefile-macroassign-regex
-  "^ *\\([^ \n\t][^:#= \t\n]*\\)[ \t]*\\(?:!=[ \t]*\\(\\(?:.+\\\\\n\\)*.+\\)\\|[*:+]?[:?]?=[ \t]*\\(\\(?:.*\\\\\n\\)*.*\\)\\)"
+  "^ *\\([^ \n\t][^:#= \t\n]*\\)[ \t]*\\(?:!=\\|[*:+]?[:?]?=\\)"
   "Regex used to find macro assignment lines in a makefile.")
 
 (defconst makefile-var-use-regex
@@ -285,8 +303,8 @@ not be enclosed in { } or ( )."
   "Regex for filenames that will NOT be included in the target list.")
 
 (if (fboundp 'facemenu-unlisted-faces)
-    (add-to-list 'facemenu-unlisted-faces 'makefile-space-face))
-(defvar makefile-space-face 'makefile-space-face
+    (add-to-list 'facemenu-unlisted-faces 'makefile-space))
+(defvar makefile-space 'makefile-space
   "Face to use for highlighting leading spaces in Font-Lock mode.")
 
 ;; These lists were inspired by the old solution.  But they are silly, because
@@ -331,14 +349,14 @@ not be enclosed in { } or ( )."
     (,makefile-macroassign-regex
      (1 font-lock-variable-name-face)
      ;; This is for after !=
-     (2 'makefile-shell-face prepend t)
+     (2 'makefile-shell prepend t)
      ;; This is for after normal assignment
      (3 'font-lock-string-face prepend t))
 
     ;; Rule actions.
     (makefile-match-action
      (1 font-lock-type-face)
-     (2 'makefile-shell-face prepend)
+     (2 'makefile-shell prepend)
      ;; Only makepp has builtin commands.
      (3 font-lock-builtin-face prepend t))
 
@@ -350,7 +368,7 @@ not be enclosed in { } or ( )."
     ("[^$]\\$\\([@%<?^+*_]\\|[a-zA-Z0-9]\\>\\)"
      1 font-lock-constant-face prepend)
     ("[^$]\\(\\$[@%*]\\)"
-     1 'makefile-targets-face prepend)
+     1 'makefile-targets append)
 
     ;; Fontify conditionals and includes.
     (,(concat "^\\(?: [ \t]*\\)?"
@@ -365,22 +383,22 @@ not be enclosed in { } or ( )."
     ,@(if space
           '(;; Highlight lines that contain just whitespace.
             ;; They can cause trouble, especially if they start with a tab.
-            ("^[ \t]+$" . makefile-space-face)
+            ("^[ \t]+$" . makefile-space)
 
             ;; Highlight shell comments that Make treats as commands,
             ;; since these can fool people.
-            ("^\t+#" 0 makefile-space-face t)
+            ("^\t+#" 0 makefile-space t)
 
             ;; Highlight spaces that precede tabs.
             ;; They can make a tab fail to be effective.
-            ("^\\( +\\)\t" 1 makefile-space-face)))
+            ("^\\( +\\)\t" 1 makefile-space)))
 
     ,@font-lock-keywords
 
     ;; Do dependencies.
     (makefile-match-dependency
-     (1 'makefile-targets-face prepend)
-     (3 'makefile-shell-face prepend t))))
+     (1 'makefile-targets prepend)
+     (3 'makefile-shell prepend t))))
 
 (defconst makefile-font-lock-keywords
   (makefile-make-font-lock-keywords
@@ -402,7 +420,7 @@ not be enclosed in { } or ( )."
    "^\\(?: [ \t]*\\)?if\\(n\\)\\(?:def\\|eq\\)\\>"
 
    '("[^$]\\(\\$[({][@%*][DF][})]\\)"
-     1 'makefile-targets-face prepend)
+     1 'makefile-targets append)
 
    ;; $(function ...) ${function ...}
    '("[^$]\\$[({]\\([-a-zA-Z0-9_.]+\\s \\)"
@@ -411,7 +429,7 @@ not be enclosed in { } or ( )."
    ;; $(shell ...) ${shell ...}
    '("[^$]\\$\\([({]\\)shell[ \t]+"
      makefile-match-function-end nil nil
-     (1 'makefile-shell-face prepend t))))
+     (1 'makefile-shell prepend t))))
 
 (defconst makefile-makepp-font-lock-keywords
   (makefile-make-font-lock-keywords
@@ -421,7 +439,7 @@ not be enclosed in { } or ( )."
    "^\\(?: [ \t]*\\)?\\(?:and[ \t]+\\|else[ \t]+\\|or[ \t]+\\)?if\\(n\\)\\(?:def\\|eq\\|sys\\)\\>"
 
    '("[^$]\\(\\$[({]\\(?:output\\|stem\\|target\\)s?\\_>.*?[})]\\)"
-     1 'makefile-targets-face prepend)
+     1 'makefile-targets append)
 
    ;; Colon modifier keywords.
    '("\\(:\\s *\\)\\(build_c\\(?:ache\\|heck\\)\\|env\\(?:ironment\\)?\\|foreach\\|signature\\|scanner\\|quickscan\\|smartscan\\)\\>\\([^:\n]*\\)"
@@ -436,32 +454,32 @@ not be enclosed in { } or ( )."
    ;; $(shell ...) $((shell ...)) ${shell ...} ${{shell ...}}
    '("[^$]\\$\\(((?\\|{{?\\)shell\\(?:[-_]\\(?:global[-_]\\)?once\\)?[ \t]+"
      makefile-match-function-end nil nil
-     (1 'makefile-shell-face prepend t))
+     (1 'makefile-shell prepend t))
 
    ;; $(perl ...) $((perl ...)) ${perl ...} ${{perl ...}}
    '("[^$]\\$\\(((?\\|{{?\\)makeperl[ \t]+"
      makefile-match-function-end nil nil
-     (1 'makefile-makepp-perl-face prepend t))
+     (1 'makefile-makepp-perl prepend t))
    '("[^$]\\$\\(((?\\|{{?\\)perl[ \t]+"
      makefile-match-function-end nil nil
-     (1 'makefile-makepp-perl-face t t))
+     (1 'makefile-makepp-perl t t))
 
    ;; Can we unify these with (if (match-end 1) 'prepend t)?
-   '("ifmakeperl\\s +\\(.*\\)" 1 'makefile-makepp-perl-face prepend)
-   '("ifperl\\s +\\(.*\\)" 1 'makefile-makepp-perl-face t)
+   '("ifmakeperl\\s +\\(.*\\)" 1 'makefile-makepp-perl prepend)
+   '("ifperl\\s +\\(.*\\)" 1 'makefile-makepp-perl t)
 
    ;; Perl block single- or multiline, as statement or rule action.
    ;; Don't know why the initial newline in 2nd variant of group 2 doesn't get skipped.
    '("\\<make\\(?:perl\\|sub\\s +\\S +\\)\\s *\n?\\s *{\\(?:{\\s *\n?\\(\\(?:.*\n\\)+?\\)\\s *}\\|\\s *\\(\\(?:.*?\\|\n?\\(?:.*\n\\)+?\\)\\)\\)}"
-     (1 'makefile-makepp-perl-face prepend t)
-     (2 'makefile-makepp-perl-face prepend t))
+     (1 'makefile-makepp-perl prepend t)
+     (2 'makefile-makepp-perl prepend t))
    '("\\<\\(?:perl\\|sub\\s +\\S +\\)\\s *\n?\\s *{\\(?:{\\s *\n?\\(\\(?:.*\n\\)+?\\)\\s *}\\|\\s *\\(\\(?:.*?\\|\n?\\(?:.*\n\\)+?\\)\\)\\)}"
-     (1 'makefile-makepp-perl-face t t)
-     (2 'makefile-makepp-perl-face t t))
+     (1 'makefile-makepp-perl t t)
+     (2 'makefile-makepp-perl t t))
 
    ;; Statement style perl block.
    '("perl[-_]begin\\s *\\(?:\\s #.*\\)?\n\\(\\(?:.*\n\\)+?\\)\\s *perl[-_]end\\>"
-     1 'makefile-makepp-perl-face t)))
+     1 'makefile-makepp-perl t)))
 
 (defconst makefile-bsdmake-font-lock-keywords
   (makefile-make-font-lock-keywords
@@ -849,10 +867,8 @@ Makefile mode can be configured by modifying the following variables:
 ;;;###autoload
 (define-derived-mode makefile-makepp-mode makefile-mode "Makeppfile"
   "An adapted `makefile-mode' that knows about makepp."
-   (set (make-local-variable 'makefile-rule-action-regex)
-        ;; Don't care about initial tab, but I don't know how to font-lock correctly without.
-        "^\t[ \t]*\\(\\(?:\\(?:noecho\\|ignore[-_]error\\|[-@]+\\)[ \t]*\\)*\\)\\(\\(&\\S +\\)?\\(?:.*\\\\\n\\)*.*\\)")
-
+  (set (make-local-variable 'makefile-rule-action-regex)
+       makefile-makepp-rule-action-regex)
   (setq font-lock-defaults
         `(makefile-makepp-font-lock-keywords ,@(cdr font-lock-defaults))
         imenu-generic-expression
@@ -863,11 +879,10 @@ Makefile mode can be configured by modifying the following variables:
 (define-derived-mode makefile-bsdmake-mode makefile-mode "BSDmakefile"
   "An adapted `makefile-mode' that knows about BSD make."
   (set (make-local-variable 'makefile-dependency-regex)
-       ;; Identical to default, except allows `!' instead of `:'.
-       "^ *\\(\\(?: *\\$\\(?:[({]\\(?:\\$\\(?:[({]\\(?:\\$\\(?:[^({]\\|.[^\n$#})]+?[})]\\)\\|[^\n$#)}]\\)+?[})]\\|[^({]\\)\\|[^\n$#)}]\\)+?[})]\\|[^({]\\)\\| *[^ \n$#:=]+\\)+?\\)[ \t]*\\([:!]\\)\\(?:[ \t]*$\\|[^=\n]\\(?:[^#\n]*?;[ \t]*\\(.+\\)\\)?\\)")
+       makefile-bsdmake-dependency-regex)
   (set (make-local-variable 'makefile-dependency-skip) "^:!")
   (set (make-local-variable 'makefile-rule-action-regex)
-       "^\t[ \t]*\\([-+@]*\\)[ \t]*\\(\\(?:.*\\\\\n\\)*.*\\)")
+       makefile-bsdmake-rule-action-regex)
   (setq font-lock-defaults
         `(makefile-bsdmake-font-lock-keywords ,@(cdr font-lock-defaults))))
 
@@ -897,6 +912,8 @@ Makefile mode can be configured by modifying the following variables:
               (backward-char))
             (get-text-property (point) 'face)
             (beginning-of-line)
+            (if (> (point) (+ (point-min) 2))
+                (eq (char-before (1- (point))) ?\\))
             (if (looking-at makefile-dependency-regex)
                 (throw 'found t))))
       (goto-char pt)
@@ -1686,9 +1703,24 @@ matched in a rule action."
         (forward-char)
         (or (eq (char-after) ?=)
             (get-text-property (1- (point)) 'face)
+            (if (> (line-beginning-position) (+ (point-min) 2))
+                (eq (char-before (line-end-position 0)) ?\\))
             (when (save-excursion
                     (beginning-of-line)
                     (looking-at makefile-dependency-regex))
+              (save-excursion
+                (let ((deps-end (match-end 1))
+                      (match-data (match-data)))
+                  (goto-char deps-end)
+                  (skip-chars-backward " \t")
+                  (setq deps-end (point))
+                  (beginning-of-line)
+                  (skip-chars-forward " \t")
+                  ;; Alter the bounds recorded for subexp 1,
+                  ;; which is what is supposed to match the targets.
+                  (setcar (nthcdr 2 match-data) (point))
+                  (setcar (nthcdr 3 match-data) deps-end)
+                  (store-match-data match-data)))
               (end-of-line)
               (throw 'found (point)))))
       (goto-char pt))
diff --git a/lisp/progmodes/octave-inf.el b/lisp/progmodes/octave-inf.el
index 250d00171f2..a45976eef32 100644
--- a/lisp/progmodes/octave-inf.el
+++ b/lisp/progmodes/octave-inf.el
@@ -129,7 +129,7 @@ buffer.
 Entry to this mode successively runs the hooks `comint-mode-hook' and
 `inferior-octave-mode-hook'."
   (interactive)
-  (comint-mode)
+  (delay-mode-hooks (comint-mode))
   (setq comint-prompt-regexp inferior-octave-prompt
         major-mode 'inferior-octave-mode
         mode-name "Inferior Octave"
diff --git a/lisp/progmodes/sh-script.el b/lisp/progmodes/sh-script.el
index 604ff8c1e78..23d8374818e 100644
--- a/lisp/progmodes/sh-script.el
+++ b/lisp/progmodes/sh-script.el
@@ -792,7 +792,7 @@ See `sh-feature'.")
 
 ;; Font-Lock support
 
-(defface sh-heredoc-face
+(defface sh-heredoc
   '((((min-colors 88) (class color)
       (background dark))
      (:foreground "yellow1" :weight bold))
@@ -806,7 +806,9 @@ See `sh-feature'.")
      (:weight bold)))
   "Face to show a here-document"
   :group 'sh-indentation)
-(defvar sh-heredoc-face 'sh-heredoc-face)
+;; backward-compatibility alias
+(put 'sh-heredoc-face 'face-alias 'sh-heredoc)
+(defvar sh-heredoc-face 'sh-heredoc)
 
 (defface sh-escaped-newline '((t :inherit font-lock-string-face))
   "Face used for (non-escaped) backslash at end of a line in Shell-script mode."
diff --git a/lisp/progmodes/sql.el b/lisp/progmodes/sql.el
index add4493e5f8..9b819ceae00 100644
--- a/lisp/progmodes/sql.el
+++ b/lisp/progmodes/sql.el
@@ -2328,7 +2328,7 @@ you entered, right above the output it created.
 
 \(setq comint-output-filter-functions
        \(function (lambda (STR) (comint-show-output))))"
-  (comint-mode)
+  (delay-mode-hooks (comint-mode))
   ;; Get the `sql-product' for this interactive session.
   (set (make-local-variable 'sql-product)
        (or sql-interactive-product
diff --git a/lisp/progmodes/vhdl-mode.el b/lisp/progmodes/vhdl-mode.el
index ebccb1bf5bf..9885e9ae039 100644
--- a/lisp/progmodes/vhdl-mode.el
+++ b/lisp/progmodes/vhdl-mode.el
@@ -1379,11 +1379,11 @@ Option `vhdl-align-groups' still applies within these blocks."
 (defcustom vhdl-highlight-keywords t
   "*Non-nil means highlight VHDL keywords and other standardized words.
 The following faces are used:
-  `font-lock-keyword-face'       : keywords
-  `font-lock-type-face'          : standardized types
-  `vhdl-font-lock-attribute-face': standardized attributes
-  `vhdl-font-lock-enumvalue-face': standardized enumeration values
-  `vhdl-font-lock-function-face' : standardized function and package names
+  `font-lock-keyword-face'      : keywords
+  `font-lock-type'              : standardized types
+  `vhdl-attribute'              : standardized attributes
+  `vhdl-enumvalue'              : standardized enumeration values
+  `vhdl-function'               : standardized function and package names
 
 NOTE: Activate the new setting in a VHDL buffer by re-fontifying it (menu
       entry \"Fontify Buffer\")."
@@ -1398,7 +1398,7 @@ The following faces are used:
   `font-lock-function-name-face' : names in declarations of units,
      subprograms, components, as well as labels of VHDL constructs
   `font-lock-type-face'          : names in type/nature declarations
-  `vhdl-font-lock-attribute-face': names in attribute declarations
+  `vhdl-attribute'               : names in attribute declarations
   `font-lock-variable-name-face' : names in declarations of signals,
      variables, constants, subprogram parameters, generics, and ports
 
@@ -1426,7 +1426,7 @@ NOTE: Activate the new setting in a VHDL buffer by re-fontifying it (menu
   "*Non-nil means highlight forbidden words.
 The reserved words specified in option `vhdl-forbidden-words' or having the
 syntax specified in option `vhdl-forbidden-syntax' are highlighted in a
-warning color (face `vhdl-font-lock-reserved-words-face') to indicate not to
+warning color (face `vhdl-reserved-word') to indicate not to
 use them.
 
 NOTE: Activate the new setting in a VHDL buffer by re-fontifying it (menu
@@ -1440,7 +1440,7 @@ NOTE: Activate the new setting in a VHDL buffer by re-fontifying it (menu
 (defcustom vhdl-highlight-verilog-keywords nil
   "*Non-nil means highlight Verilog keywords as reserved words.
 Verilog keywords are highlighted in a warning color (face
-`vhdl-font-lock-reserved-words-face') to indicate not to use them.
+`vhdl-reserved-word') to indicate not to use them.
 
 NOTE: Activate the new setting in a VHDL buffer by re-fontifying it (menu
       entry \"Fontify Buffer\")."
@@ -1454,7 +1454,7 @@ NOTE: Activate the new setting in a VHDL buffer by re-fontifying it (menu
   "*Non-nil means background-highlight code excluded from translation.
 That is, all code between \"-- pragma translate_off\" and
 \"-- pragma translate_on\" is highlighted using a different background color
-\(face `vhdl-font-lock-translate-off-face').
+\(face `vhdl-translate-off').
 Note: this might slow down on-the-fly fontification (and thus editing).
 
 NOTE: Activate the new setting in a VHDL buffer by re-fontifying it (menu
@@ -1501,7 +1501,7 @@ different kinds of signals (e.g. \"Clk50\", \"Rst_n\") or objects (e.g.
 \"Signal_s\", \"Variable_v\", \"Constant_c\") by distinguishing them using
 common substrings or name suffices.
 For each entry, a new face is generated with the specified colors and name
-\"vhdl-font-lock-\" + name + \"-face\".
+\"vhdl-\" + name.
 
 NOTE: Activate a changed regexp in a VHDL buffer by re-fontifying it (menu
       entry \"Fontify Buffer\").  All other changes require restarting Emacs."
@@ -12484,7 +12484,7 @@ This does highlighting of keywords and standard identifiers.")
    (list
     (concat
      "^\\s-*attribute\\s-+\\(\\w+\\)")
-    1 'vhdl-font-lock-attribute-face)
+    1 'vhdl-attribute)
 
    ;; highlight type/nature name in (sub)type/(sub)nature declarations
    (list
@@ -12542,40 +12542,39 @@ This does highlighting of additional reserved words.")
 
 (defconst vhdl-font-lock-keywords-5
   ;; background highlight translate-off regions
-  '((vhdl-match-translate-off (0 vhdl-font-lock-translate-off-face append)))
+  '((vhdl-match-translate-off (0 vhdl-translate-off-face append)))
   "For consideration as a value of `vhdl-font-lock-keywords'.
 This does background highlighting of translate-off regions.")
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;; Font and color definitions
 
-(defvar vhdl-font-lock-prompt-face         'vhdl-font-lock-prompt-face
+(defvar vhdl-prompt-face         'vhdl-prompt
   "Face name to use for prompts.")
 
-(defvar vhdl-font-lock-attribute-face      'vhdl-font-lock-attribute-face
+(defvar vhdl-attribute-face      'vhdl-attribute
   "Face name to use for standardized attributes.")
 
-(defvar vhdl-font-lock-enumvalue-face      'vhdl-font-lock-enumvalue-face
+(defvar vhdl-enumvalue-face      'vhdl-enumvalue
   "Face name to use for standardized enumeration values.")
 
-(defvar vhdl-font-lock-function-face       'vhdl-font-lock-function-face
+(defvar vhdl-function-face       'vhdl-function
   "Face name to use for standardized functions and packages.")
 
-(defvar vhdl-font-lock-directive-face      'vhdl-font-lock-directive-face
+(defvar vhdl-directive-face      'vhdl-directive
   "Face name to use for directives.")
 
-(defvar vhdl-font-lock-reserved-words-face 'vhdl-font-lock-reserved-words-face
+(defvar vhdl-reserved-words-face 'vhdl-reserved-words
   "Face name to use for additional reserved words.")
 
-(defvar vhdl-font-lock-translate-off-face  'vhdl-font-lock-translate-off-face
+(defvar vhdl-translate-off-face  'vhdl-translate-off
   "Face name to use for translate-off regions.")
 
 ;; face names to use for words with special syntax.
 (let ((syntax-alist vhdl-special-syntax-alist)
       name)
   (while syntax-alist
-    (setq name (vhdl-function-name
-                "vhdl-font-lock" (nth 0 (car syntax-alist)) "face"))
+    (setq name (vhdl-function-name "vhdl" (nth 0 (car syntax-alist))))
     (eval `(defvar ,name ',name
              ,(concat "Face name to use for "
                       (nth 0 (car syntax-alist)) ".")))
@@ -12599,8 +12598,8 @@ This does background highlighting of translate-off regions.")
 (custom-add-to-group
  'vhdl-highlight-faces 'font-lock-variable-name-face 'custom-face)
 
-(defface vhdl-font-lock-prompt-face
-  '((((min-colors 88) (class color) (background light)) 
+(defface vhdl-prompt
+  '((((min-colors 88) (class color) (background light))
      (:foreground "Red1" :bold t))
     (((class color) (background light)) (:foreground "Red" :bold t))
     (((class color) (background dark)) (:foreground "Pink" :bold t))
@@ -12608,62 +12607,75 @@ This does background highlighting of translate-off regions.")
   "Font lock mode face used to highlight prompts."
   :group 'vhdl-highlight-faces
   :group 'font-lock-highlighting-faces)
+;; backward-compatibility alias
+(put 'vhdl-font-lock-prompt-face 'face-alias 'vhdl-prompt)
 
-(defface vhdl-font-lock-attribute-face
+(defface vhdl-attribute
   '((((class color) (background light)) (:foreground "Orchid"))
     (((class color) (background dark)) (:foreground "LightSteelBlue"))
     (t (:italic t :bold t)))
   "Font lock mode face used to highlight standardized attributes."
   :group 'vhdl-highlight-faces
   :group 'font-lock-highlighting-faces)
+;; backward-compatibility alias
+(put 'vhdl-font-lock-attribute-face 'face-alias 'vhdl-attribute)
 
-(defface vhdl-font-lock-enumvalue-face
+(defface vhdl-enumvalue
   '((((class color) (background light)) (:foreground "SaddleBrown"))
     (((class color) (background dark)) (:foreground "BurlyWood"))
     (t (:italic t :bold t)))
   "Font lock mode face used to highlight standardized enumeration values."
   :group 'vhdl-highlight-faces
   :group 'font-lock-highlighting-faces)
+;; backward-compatibility alias
+(put 'vhdl-font-lock-enumvalue-face 'face-alias 'vhdl-enumvalue)
 
-(defface vhdl-font-lock-function-face
+(defface vhdl-function
   '((((class color) (background light)) (:foreground "Cyan4"))
     (((class color) (background dark)) (:foreground "Orchid1"))
     (t (:italic t :bold t)))
   "Font lock mode face used to highlight standardized functions and packages."
   :group 'vhdl-highlight-faces
   :group 'font-lock-highlighting-faces)
+;; backward-compatibility alias
+(put 'vhdl-font-lock-function-face 'face-alias 'vhdl-function)
 
-(defface vhdl-font-lock-directive-face
+(defface vhdl-directive
   '((((class color) (background light)) (:foreground "CadetBlue"))
     (((class color) (background dark)) (:foreground "Aquamarine"))
     (t (:italic t :bold t)))
   "Font lock mode face used to highlight directives."
   :group 'vhdl-highlight-faces
   :group 'font-lock-highlighting-faces)
+;; backward-compatibility alias
+(put 'vhdl-font-lock-directive-face 'face-alias 'vhdl-directive)
 
-(defface vhdl-font-lock-reserved-words-face
+(defface vhdl-reserved-word
   '((((class color) (background light)) (:foreground "Orange" :bold t))
-    (((min-colors 88) (class color) (background dark)) 
+    (((min-colors 88) (class color) (background dark))
      (:foreground "Yellow1" :bold t))
     (((class color) (background dark)) (:foreground "Yellow" :bold t))
     (t ()))
   "Font lock mode face used to highlight additional reserved words."
   :group 'vhdl-highlight-faces
   :group 'font-lock-highlighting-faces)
+;; backward-compatibility alias
+(put 'vhdl-font-lock-reserved-words-face 'face-alias 'vhdl-reserved-word)
 
-(defface vhdl-font-lock-translate-off-face
+(defface vhdl-translate-off
   '((((class color) (background light)) (:background "LightGray"))
     (((class color) (background dark)) (:background "DimGray"))
     (t ()))
   "Font lock mode face used to background highlight translate-off regions."
   :group 'vhdl-highlight-faces
   :group 'font-lock-highlighting-faces)
+;; backward-compatibility alias
+(put 'vhdl-font-lock-translate-off-face 'face-alias 'vhdl-translate-off)
 
 ;; font lock mode faces used to highlight words with special syntax.
 (let ((syntax-alist vhdl-special-syntax-alist))
   (while syntax-alist
-    (eval `(defface ,(vhdl-function-name
-                      "vhdl-font-lock" (caar syntax-alist) "face")
+    (eval `(defface ,(vhdl-function-name "vhdl" (caar syntax-alist))
              '((((class color) (background light))
                 (:foreground ,(nth 2 (car syntax-alist))))
                (((class color) (background dark))
@@ -12684,20 +12696,19 @@ This does background highlighting of translate-off regions.")
   (setq vhdl-font-lock-keywords-0
         (list (list (concat "\\(^\\|[ \t(.']\\)\\(<"
                             vhdl-template-prompt-syntax ">\\)")
-                    2 'vhdl-font-lock-prompt-face t)
+                    2 'vhdl-prompt t)
               (list (concat "--\\s-*"
                             vhdl-directive-keywords-regexp "\\s-+\\(.*\\)$")
-                    2 'vhdl-font-lock-directive-face t)))
+                    2 'vhdl-directive t)))
   ;; highlight keywords and standardized types, attributes, enumeration
   ;; values, and subprograms
   (setq vhdl-font-lock-keywords-1
         (list
-         (list (concat "'" vhdl-attributes-regexp)
-               1 'vhdl-font-lock-attribute-face)
+         (list (concat "'" vhdl-attributes-regexp) 1 'vhdl-attribute)
          (list vhdl-types-regexp       1 'font-lock-type-face)
-         (list vhdl-functions-regexp   1 'vhdl-font-lock-function-face)
-         (list vhdl-packages-regexp    1 'vhdl-font-lock-function-face)
-         (list vhdl-enum-values-regexp 1 'vhdl-font-lock-enumvalue-face)
+         (list vhdl-functions-regexp   1 'vhdl-function)
+         (list vhdl-packages-regexp    1 'vhdl-function)
+         (list vhdl-enum-values-regexp 1 'vhdl-enumvalue)
          (list vhdl-keywords-regexp    1 'font-lock-keyword-face)))
   ;; highlight words with special syntax.
   (setq vhdl-font-lock-keywords-3
@@ -12708,14 +12719,13 @@ This does background highlighting of translate-off regions.")
                   (cons
                    (cons (concat "\\<\\(" (nth 1 (car syntax-alist)) "\\)\\>")
                          (vhdl-function-name
-                          "vhdl-font-lock" (nth 0 (car syntax-alist)) "face"))
+                          "vhdl" (nth 0 (car syntax-alist))))
                    keywords))
             (setq syntax-alist (cdr syntax-alist)))
           keywords))
   ;; highlight additional reserved words
   (setq vhdl-font-lock-keywords-4
-        (list (list vhdl-reserved-words-regexp 1
-                    'vhdl-font-lock-reserved-words-face)))
+        (list (list vhdl-reserved-words-regexp 1 'vhdl-reserved-word)))
   ;; highlight everything together
   (setq vhdl-font-lock-keywords
         (append
@@ -12753,18 +12763,12 @@ This does background highlighting of translate-off regions.")
   (unless (or (not vhdl-print-customize-faces)
               ps-print-color-p)
     (set (make-local-variable 'ps-bold-faces)
-         '(font-lock-keyword-face
-           font-lock-type-face
-           vhdl-font-lock-attribute-face
-           vhdl-font-lock-enumvalue-face
-           vhdl-font-lock-directive-face))
+         '(font-lock-keyword-face font-lock-type-face
+           vhdl-attribute vhdl-enumvalue vhdl-directive))
     (set (make-local-variable 'ps-italic-faces)
          '(font-lock-comment-face
-           font-lock-function-name-face
-           font-lock-type-face
-           vhdl-font-lock-attribute-face
-           vhdl-font-lock-enumvalue-face
-           vhdl-font-lock-directive-face))
+           font-lock-function-name-face font-lock-type-face
+           vhdl-attribute vhdl-enumvalue vhdl-directive))
     (set (make-local-variable 'ps-underlined-faces)
          '(font-lock-string-face))
     (setq ps-always-build-face-reference t))
@@ -13973,7 +13977,7 @@ otherwise use cached data."
          'bracket ?+ 'vhdl-speedbar-expand-entity (nth 0 ent-entry)
          (nth 1 ent-entry) 'vhdl-speedbar-find-file
          (cons (nth 2 ent-entry) (nth 3 ent-entry))
-         'vhdl-speedbar-entity-face depth)
+         'vhdl-speedbar-entity depth)
         (unless (nth 2 ent-entry)
           (end-of-line 0) (insert "!") (forward-char 1))
         (unless (member (nth 0 ent-entry) ent-inst-list)
@@ -13987,7 +13991,7 @@ otherwise use cached data."
          'bracket ?+ 'vhdl-speedbar-expand-config (nth 0 conf-entry)
          (nth 1 conf-entry) 'vhdl-speedbar-find-file
          (cons (nth 2 conf-entry) (nth 3 conf-entry))
-         'vhdl-speedbar-configuration-face depth)
+         'vhdl-speedbar-configuration depth)
         (setq conf-alist (cdr conf-alist)))
       ;; insert packages
       (when pack-alist (vhdl-speedbar-make-title-line "Packages:" depth))
@@ -14178,7 +14182,7 @@ otherwise use cached data."
               (cons token (nth 0 arch-entry))
               (nth 1 arch-entry) 'vhdl-speedbar-find-file
               (cons (nth 2 arch-entry) (nth 3 arch-entry))
-              'vhdl-speedbar-architecture-face (1+ indent))
+              'vhdl-speedbar-architecture (1+ indent))
              (setq arch-alist (cdr arch-alist)))
            ;; insert instantiations
            (when inst-alist
@@ -14361,7 +14365,7 @@ otherwise use cached data."
                (cons token (nth 0 comp-entry))
                (nth 1 comp-entry) 'vhdl-speedbar-find-file
                (cons (nth 2 comp-entry) (nth 3 comp-entry))
-               'vhdl-speedbar-entity-face (1+ indent))
+               'vhdl-speedbar-entity (1+ indent))
               (setq comp-alist (cdr comp-alist)))
             ;; insert subprograms
             (when func-alist
@@ -14477,43 +14481,43 @@ NO-POSITION non-nil means do not re-position cursor."
           (let* ((file-entry (aget file-alist speedbar-last-selected-file t)))
             (vhdl-speedbar-update-units
              "\\[.\\] " (nth 0 file-entry)
-             speedbar-last-selected-file 'vhdl-speedbar-entity-face)
+             speedbar-last-selected-file 'vhdl-speedbar-entity)
             (vhdl-speedbar-update-units
              "{.} " (nth 1 file-entry)
-             speedbar-last-selected-file 'vhdl-speedbar-architecture-face)
+             speedbar-last-selected-file 'vhdl-speedbar-architecture)
             (vhdl-speedbar-update-units
              "\\[.\\] " (nth 3 file-entry)
-             speedbar-last-selected-file 'vhdl-speedbar-configuration-face)
+             speedbar-last-selected-file 'vhdl-speedbar-configuration)
             (vhdl-speedbar-update-units
              "[]>] " (nth 4 file-entry)
-             speedbar-last-selected-file 'vhdl-speedbar-package-face)
+             speedbar-last-selected-file 'vhdl-speedbar-package)
             (vhdl-speedbar-update-units
              "\\[.\\].+(" '("body")
-             speedbar-last-selected-file 'vhdl-speedbar-package-face)
+             speedbar-last-selected-file 'vhdl-speedbar-package)
             (vhdl-speedbar-update-units
              "> " (nth 6 file-entry)
-             speedbar-last-selected-file 'vhdl-speedbar-instantiation-face))
+             speedbar-last-selected-file 'vhdl-speedbar-instantiation))
           ;; highlight current units
           (let* ((file-entry (aget file-alist file-name t)))
             (setq
              pos (vhdl-speedbar-update-units
                   "\\[.\\] " (nth 0 file-entry)
-                  file-name 'vhdl-speedbar-entity-selected-face pos)
+                  file-name 'vhdl-speedbar-entity-selected pos)
              pos (vhdl-speedbar-update-units
                   "{.} " (nth 1 file-entry)
-                  file-name 'vhdl-speedbar-architecture-selected-face pos)
+                  file-name 'vhdl-speedbar-architecture-selected pos)
              pos (vhdl-speedbar-update-units
                   "\\[.\\] " (nth 3 file-entry)
-                  file-name 'vhdl-speedbar-configuration-selected-face pos)
+                  file-name 'vhdl-speedbar-configuration-selected pos)
              pos (vhdl-speedbar-update-units
                   "[]>] " (nth 4 file-entry)
-                  file-name 'vhdl-speedbar-package-selected-face pos)
+                  file-name 'vhdl-speedbar-package-selected pos)
              pos (vhdl-speedbar-update-units
                   "\\[.\\].+(" '("body")
-                  file-name 'vhdl-speedbar-package-selected-face pos)
+                  file-name 'vhdl-speedbar-package-selected pos)
              pos (vhdl-speedbar-update-units
                   "> " (nth 6 file-entry)
-                  file-name 'vhdl-speedbar-instantiation-selected-face pos))))))
+                  file-name 'vhdl-speedbar-instantiation-selected pos))))))
       ;; move speedbar so the first highlighted unit is visible
       (when (and pos (not no-position))
         (goto-char pos)
@@ -14564,21 +14568,21 @@ NO-POSITION non-nil means do not re-position cursor."
         (insert "(top)")
       (insert inst-name)
       (speedbar-make-button
-       start (point) 'vhdl-speedbar-instantiation-face 'speedbar-highlight-face
+       start (point) 'vhdl-speedbar-instantiation 'speedbar-highlight-face
        'vhdl-speedbar-find-file inst-file-marker))
     (insert delimiter)
     (when ent-name
       (setq start (point))
       (insert ent-name)
       (speedbar-make-button
-       start (point) 'vhdl-speedbar-entity-face 'speedbar-highlight-face
+       start (point) 'vhdl-speedbar-entity 'speedbar-highlight-face
        'vhdl-speedbar-find-file ent-file-marker)
       (when arch-name
         (insert " (")
         (setq start (point))
         (insert arch-name)
         (speedbar-make-button
-         start (point) 'vhdl-speedbar-architecture-face 'speedbar-highlight-face
+         start (point) 'vhdl-speedbar-architecture 'speedbar-highlight-face
          'vhdl-speedbar-find-file arch-file-marker)
         (insert ")"))
       (when conf-name
@@ -14586,14 +14590,14 @@ NO-POSITION non-nil means do not re-position cursor."
         (setq start (point))
         (insert conf-name)
         (speedbar-make-button
-         start (point) 'vhdl-speedbar-configuration-face 'speedbar-highlight-face
+         start (point) 'vhdl-speedbar-configuration 'speedbar-highlight-face
          'vhdl-speedbar-find-file conf-file-marker)
         (insert ")")))
     (when (and lib-name (not (equal lib-name (downcase (vhdl-work-library)))))
       (setq start (point))
       (insert " (" lib-name ")")
       (put-text-property (+ 2 start) (1- (point)) 'face
-                         'vhdl-speedbar-library-face))
+                         'vhdl-speedbar-library))
     (insert-char ?\n 1)
     (put-text-property visible-start (point) 'invisible nil)))
 
@@ -14617,7 +14621,7 @@ NO-POSITION non-nil means do not re-position cursor."
     (setq start (point))
     (insert pack-name)
     (speedbar-make-button
-     start (point) 'vhdl-speedbar-package-face 'speedbar-highlight-face
+     start (point) 'vhdl-speedbar-package 'speedbar-highlight-face
      'vhdl-speedbar-find-file pack-file-marker)
     (unless (car pack-file-marker)
       (insert "!"))
@@ -14626,7 +14630,7 @@ NO-POSITION non-nil means do not re-position cursor."
       (setq start (point))
       (insert "body")
       (speedbar-make-button
-       start (point) 'vhdl-speedbar-package-face 'speedbar-highlight-face
+       start (point) 'vhdl-speedbar-package 'speedbar-highlight-face
        'vhdl-speedbar-find-file body-file-marker)
       (insert ")"))
     (insert-char ?\n 1)
@@ -14650,12 +14654,12 @@ NO-POSITION non-nil means do not re-position cursor."
     (setq start (point))
     (insert pack-name)
     (speedbar-make-button
-     start (point) 'vhdl-speedbar-package-face 'speedbar-highlight-face
+     start (point) 'vhdl-speedbar-package 'speedbar-highlight-face
      'vhdl-speedbar-find-file pack-file-marker)
     (setq start (point))
     (insert " (" lib-name ")")
     (put-text-property (+ 2 start) (1- (point)) 'face
-                       'vhdl-speedbar-library-face)
+                       'vhdl-speedbar-library)
     (insert-char ?\n 1)
     (put-text-property visible-start (point) 'invisible nil)))
 
@@ -14678,14 +14682,14 @@ NO-POSITION non-nil means do not re-position cursor."
     (setq start (point))
     (insert func-name)
     (speedbar-make-button
-     start (point) 'vhdl-speedbar-subprogram-face 'speedbar-highlight-face
+     start (point) 'vhdl-speedbar-subprogram 'speedbar-highlight-face
      'vhdl-speedbar-find-file func-file-marker)
     (when (car func-body-file-marker)
       (insert " (")
       (setq start (point))
       (insert "body")
       (speedbar-make-button
-       start (point) 'vhdl-speedbar-subprogram-face 'speedbar-highlight-face
+       start (point) 'vhdl-speedbar-subprogram 'speedbar-highlight-face
        'vhdl-speedbar-find-file func-body-file-marker)
       (insert ")"))
     (insert-char ?\n 1)
@@ -14773,22 +14777,22 @@ NO-POSITION non-nil means do not re-position cursor."
         (message
          "%s \"%s\" in \"%s\""
          ;; design unit kind
-         (cond ((or (eq face 'vhdl-speedbar-entity-face)
-                    (eq face 'vhdl-speedbar-entity-selected-face))
+         (cond ((or (eq face 'vhdl-speedbar-entity)
+                    (eq face 'vhdl-speedbar-entity-selected))
                 (if (equal (match-string 2) ">") "Component" "Entity"))
-               ((or (eq face 'vhdl-speedbar-architecture-face)
-                    (eq face 'vhdl-speedbar-architecture-selected-face))
+               ((or (eq face 'vhdl-speedbar-architecture)
+                    (eq face 'vhdl-speedbar-architecture-selected))
                 "Architecture")
-               ((or (eq face 'vhdl-speedbar-configuration-face)
-                    (eq face 'vhdl-speedbar-configuration-selected-face))
+               ((or (eq face 'vhdl-speedbar-configuration)
+                    (eq face 'vhdl-speedbar-configuration-selected))
                 "Configuration")
-               ((or (eq face 'vhdl-speedbar-package-face)
-                    (eq face 'vhdl-speedbar-package-selected-face))
+               ((or (eq face 'vhdl-speedbar-package)
+                    (eq face 'vhdl-speedbar-package-selected))
                 "Package")
-               ((or (eq face 'vhdl-speedbar-instantiation-face)
-                    (eq face 'vhdl-speedbar-instantiation-selected-face))
+               ((or (eq face 'vhdl-speedbar-instantiation)
+                    (eq face 'vhdl-speedbar-instantiation-selected))
                 "Instantiation")
-               ((eq face 'vhdl-speedbar-subprogram-face)
+               ((eq face 'vhdl-speedbar-subprogram)
                 "Subprogram")
                (t ""))
          ;; design unit name
@@ -14924,7 +14928,7 @@ is already shown in a buffer."
   "Place the entity/component under the cursor as component."
   (interactive)
   (if (not (vhdl-speedbar-check-unit 'entity))
-      (error "ERROR:  No entity/component under cursor.")
+      (error "ERROR:  No entity/component under cursor")
     (vhdl-speedbar-port-copy)
     (if (fboundp 'speedbar-select-attached-frame)
         (speedbar-select-attached-frame)
@@ -14964,11 +14968,11 @@ expansion function)."
       (speedbar-position-cursor-on-line)
       (cond ((eq design-unit 'entity)
              (memq (get-text-property (match-end 0) 'face)
-                   '(vhdl-speedbar-entity-face
-                     vhdl-speedbar-entity-selected-face)))
+                   '(vhdl-speedbar-entity
+                     vhdl-speedbar-entity-selected)))
             ((eq design-unit 'subprogram)
              (eq (get-text-property (match-end 0) 'face)
-                 'vhdl-speedbar-subprogram-face))
+                 'vhdl-speedbar-subprogram))
             (t nil))))
 
 (defun vhdl-speedbar-set-depth (depth)
@@ -14979,82 +14983,106 @@ expansion function)."
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;; Fontification
 
-(defface vhdl-speedbar-entity-face
+(defface vhdl-speedbar-entity
   '((((class color) (background light)) (:foreground "ForestGreen"))
     (((class color) (background dark)) (:foreground "PaleGreen")))
   "Face used for displaying entity names."
   :group 'speedbar-faces)
+;; backward-compatibility alias
+(put 'vhdl-speedbar-entity-face 'face-alias 'vhdl-speedbar-entity)
 
-(defface vhdl-speedbar-architecture-face
+(defface vhdl-speedbar-architecture
   '((((min-colors 88) (class color) (background light)) (:foreground "Blue1"))
     (((class color) (background light)) (:foreground "Blue"))
     (((class color) (background dark)) (:foreground "LightSkyBlue")))
   "Face used for displaying architecture names."
   :group 'speedbar-faces)
+;; backward-compatibility alias
+(put 'vhdl-speedbar-architecture-face 'face-alias 'vhdl-speedbar-architecture)
 
-(defface vhdl-speedbar-configuration-face
+(defface vhdl-speedbar-configuration
   '((((class color) (background light)) (:foreground "DarkGoldenrod"))
     (((class color) (background dark)) (:foreground "Salmon")))
   "Face used for displaying configuration names."
   :group 'speedbar-faces)
+;; backward-compatibility alias
+(put 'vhdl-speedbar-configuration-face 'face-alias 'vhdl-speedbar-configuration)
 
-(defface vhdl-speedbar-package-face
+(defface vhdl-speedbar-package
   '((((class color) (background light)) (:foreground "Grey50"))
     (((class color) (background dark)) (:foreground "Grey80")))
   "Face used for displaying package names."
   :group 'speedbar-faces)
+;; backward-compatibility alias
+(put 'vhdl-speedbar-package-face 'face-alias 'vhdl-speedbar-package)
 
-(defface vhdl-speedbar-library-face
+(defface vhdl-speedbar-library
   '((((class color) (background light)) (:foreground "Purple"))
     (((class color) (background dark)) (:foreground "Orchid1")))
   "Face used for displaying library names."
   :group 'speedbar-faces)
+;; backward-compatibility alias
+(put 'vhdl-speedbar-library-face 'face-alias 'vhdl-speedbar-library)
 
-(defface vhdl-speedbar-instantiation-face
+(defface vhdl-speedbar-instantiation
   '((((class color) (background light)) (:foreground "Brown"))
     (((min-colors 88) (class color) (background dark)) (:foreground "Yellow1"))
     (((class color) (background dark)) (:foreground "Yellow")))
   "Face used for displaying instantiation names."
   :group 'speedbar-faces)
+;; backward-compatibility alias
+(put 'vhdl-speedbar-instantiation-face 'face-alias 'vhdl-speedbar-instantiation)
 
-(defface vhdl-speedbar-subprogram-face
+(defface vhdl-speedbar-subprogram
   '((((class color) (background light)) (:foreground "Orchid4"))
     (((class color) (background dark)) (:foreground "BurlyWood2")))
   "Face used for displaying subprogram names."
   :group 'speedbar-faces)
+;; backward-compatibility alias
+(put 'vhdl-speedbar-subprogram-face 'face-alias 'vhdl-speedbar-subprogram)
 
-(defface vhdl-speedbar-entity-selected-face
+(defface vhdl-speedbar-entity-selected
   '((((class color) (background light)) (:foreground "ForestGreen" :underline t))
     (((class color) (background dark)) (:foreground "PaleGreen" :underline t)))
   "Face used for displaying entity names."
   :group 'speedbar-faces)
+;; backward-compatibility alias
+(put 'vhdl-speedbar-entity-selected-face 'face-alias 'vhdl-speedbar-entity-selected)
 
-(defface vhdl-speedbar-architecture-selected-face
+(defface vhdl-speedbar-architecture-selected
   '((((min-colors 88) (class color) (background light)) (:foreground "Blue1" :underline t))
     (((min-colors 88) (class color) (background light)) (:foreground "Blue1" :underline t))
     (((class color) (background light)) (:foreground "Blue" :underline t))
     (((class color) (background dark)) (:foreground "LightSkyBlue" :underline t)))
   "Face used for displaying architecture names."
   :group 'speedbar-faces)
+;; backward-compatibility alias
+(put 'vhdl-speedbar-architecture-selected-face 'face-alias 'vhdl-speedbar-architecture-selected)
 
-(defface vhdl-speedbar-configuration-selected-face
+(defface vhdl-speedbar-configuration-selected
   '((((class color) (background light)) (:foreground "DarkGoldenrod" :underline t))
     (((class color) (background dark)) (:foreground "Salmon" :underline t)))
   "Face used for displaying configuration names."
   :group 'speedbar-faces)
+;; backward-compatibility alias
+(put 'vhdl-speedbar-configuration-selected-face 'face-alias 'vhdl-speedbar-configuration-selected)
 
-(defface vhdl-speedbar-package-selected-face
+(defface vhdl-speedbar-package-selected
   '((((class color) (background light)) (:foreground "Grey50" :underline t))
     (((class color) (background dark)) (:foreground "Grey80" :underline t)))
   "Face used for displaying package names."
   :group 'speedbar-faces)
+;; backward-compatibility alias
+(put 'vhdl-speedbar-package-selected-face 'face-alias 'vhdl-speedbar-package-selected)
 
-(defface vhdl-speedbar-instantiation-selected-face
+(defface vhdl-speedbar-instantiation-selected
   '((((class color) (background light)) (:foreground "Brown" :underline t))
     (((min-colors 88) (class color) (background dark)) (:foreground "Yellow1" :underline t))
     (((class color) (background dark)) (:foreground "Yellow" :underline t)))
   "Face used for displaying instantiation names."
   :group 'speedbar-faces)
+;; backward-compatibility alias
+(put 'vhdl-speedbar-instantiation-selected-face 'face-alias 'vhdl-speedbar-instantiation-selected)
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;; Initialization
diff --git a/lisp/progmodes/which-func.el b/lisp/progmodes/which-func.el
index 1fa37532ab0..a96bd076e12 100644
--- a/lisp/progmodes/which-func.el
+++ b/lisp/progmodes/which-func.el
@@ -113,17 +113,40 @@ Zero means compute the Imenu menu regardless of size."
     map)
   "Keymap to display on mode line which-func.")
 
-(defface which-func-face
-  '((t (:inherit font-lock-function-name-face)))
-  "Face used to highlight mode line function names.
-Defaults to `font-lock-function-name-face' if font-lock is loaded."
+(defface which-func
+  ;; Whether `font-lock-function-name-face' is an appropriate face to
+  ;; inherit depends on the mode-line face; define several variants based
+  ;; on the default mode-line face.
+  '(;; The default mode-line face on a high-color display is a relatively
+    ;; light color ("grey75"), and only the light-background variant of
+    ;; `font-lock-function-name-face' is visible against it.
+    (((class color) (min-colors 88) (background light))
+     :inherit font-lock-function-name-face)
+    ;; The default mode-line face on other display types is inverse-video;
+    ;; it seems that only in the dark-background case is
+    ;; `font-lock-function-name-face' visible against it.
+    (((class grayscale mono) (background dark))
+     :inherit font-lock-function-name-face)
+    (((class color) (background light))
+     :inherit font-lock-function-name-face)
+    ;; If none of the above cases, use an explicit color chosen to contrast
+    ;; well with the default mode-line face.
+    (((class color) (min-colors 88) (background dark))
+     :foreground "Blue1")
+    (((background dark))
+     :foreground "Blue1")
+    (t
+     :foreground "LightSkyBlue"))
+  "Face used to highlight mode line function names."
   :group 'which-func)
+;; backward-compatibility alias
+(put 'which-func-face 'face-alias 'which-func)
 
 (defcustom which-func-format
   `("["
     (:propertize which-func-current
                  local-map ,which-func-keymap
-                 face which-func-face
+                 face which-func
                  ;;mouse-face highlight ; currently not evaluated :-(
                  help-echo "mouse-1: go to beginning, mouse-2: toggle rest visibility, mouse-3: go to end")
     "]")