merge from trunk; clean up some issues

45 files changed, 4428 insertions, 3203 deletions

diff --git a/lisp/progmodes/ada-mode.el b/lisp/progmodes/ada-mode.el
index 3709aa26bbe..805444d08b9 100644
--- a/lisp/progmodes/ada-mode.el
+++ b/lisp/progmodes/ada-mode.el
@@ -457,15 +457,8 @@ The extensions should include a `.' if needed.")
 (defvar ada-mode-extra-prefix "\C-c\C-q"
   "Prefix key to access `ada-mode-extra-map' functions.")
 
-(defvar ada-mode-abbrev-table nil
+(define-abbrev-table 'ada-mode-abbrev-table ()
   "Local abbrev table for Ada mode.")
-(define-abbrev-table 'ada-mode-abbrev-table ())
-
-(defvar ada-mode-syntax-table nil
-  "Syntax table to be used for editing Ada source code.")
-
-(defvar ada-mode-symbol-syntax-table nil
-  "Syntax table for Ada, where `_' is a word constituent.")
 
 (eval-when-compile
   ;; These values are used in eval-when-compile expressions.
@@ -845,61 +838,58 @@ the 4 file locations can be clicked on and jumped to."
 ;; better is available on XEmacs.
 ;;-------------------------------------------------------------------------
 
-(defun ada-create-syntax-table ()
-  "Create the two syntax tables use in the Ada mode.
-The standard table declares `_' as a symbol constituent, the second one
-declares it as a word constituent."
-  (interactive)
-  (setq ada-mode-syntax-table (make-syntax-table))
-
-  ;; define string brackets (`%' is alternative string bracket, but
-  ;; almost never used as such and throws font-lock and indentation
-  ;; off the track.)
-  (modify-syntax-entry ?%  "$" ada-mode-syntax-table)
-  (modify-syntax-entry ?\" "\"" ada-mode-syntax-table)
-
-  (modify-syntax-entry ?:  "." ada-mode-syntax-table)
-  (modify-syntax-entry ?\; "." ada-mode-syntax-table)
-  (modify-syntax-entry ?&  "." ada-mode-syntax-table)
-  (modify-syntax-entry ?\|  "." ada-mode-syntax-table)
-  (modify-syntax-entry ?+  "." ada-mode-syntax-table)
-  (modify-syntax-entry ?*  "." ada-mode-syntax-table)
-  (modify-syntax-entry ?/  "." ada-mode-syntax-table)
-  (modify-syntax-entry ?=  "." ada-mode-syntax-table)
-  (modify-syntax-entry ?<  "." ada-mode-syntax-table)
-  (modify-syntax-entry ?>  "." ada-mode-syntax-table)
-  (modify-syntax-entry ?$ "." ada-mode-syntax-table)
-  (modify-syntax-entry ?\[ "." ada-mode-syntax-table)
-  (modify-syntax-entry ?\] "." ada-mode-syntax-table)
-  (modify-syntax-entry ?\{ "." ada-mode-syntax-table)
-  (modify-syntax-entry ?\} "." ada-mode-syntax-table)
-  (modify-syntax-entry ?. "." ada-mode-syntax-table)
-  (modify-syntax-entry ?\\ "." ada-mode-syntax-table)
-  (modify-syntax-entry ?\' "." ada-mode-syntax-table)
-
-  ;; a single hyphen is punctuation, but a double hyphen starts a comment
-  (modify-syntax-entry ?-  ". 12" ada-mode-syntax-table)
-
-  ;; See the comment above on grammar related function for the special
-  ;; setup for '#'.
-  (if (featurep 'xemacs)
-      (modify-syntax-entry ?#  "<" ada-mode-syntax-table)
-    (modify-syntax-entry ?#  "$" ada-mode-syntax-table))
-
-  ;; and \f and \n end a comment
-  (modify-syntax-entry ?\f  ">   " ada-mode-syntax-table)
-  (modify-syntax-entry ?\n  ">   " ada-mode-syntax-table)
-
-  ;; define what belongs in Ada symbols
-  (modify-syntax-entry ?_ "_" ada-mode-syntax-table)
-
-  ;; define parentheses to match
-  (modify-syntax-entry ?\( "()" ada-mode-syntax-table)
-  (modify-syntax-entry ?\) ")(" ada-mode-syntax-table)
-
-  (setq ada-mode-symbol-syntax-table (copy-syntax-table ada-mode-syntax-table))
-  (modify-syntax-entry ?_ "w" ada-mode-symbol-syntax-table)
-  )
+(defvar ada-mode-syntax-table
+  (let ((st (make-syntax-table)))
+    ;; Define string brackets (`%' is alternative string bracket, but
+    ;; almost never used as such and throws font-lock and indentation
+    ;; off the track.)
+    (modify-syntax-entry ?%  "$" st)
+    (modify-syntax-entry ?\" "\"" st)
+
+    (modify-syntax-entry ?:  "." st)
+    (modify-syntax-entry ?\; "." st)
+    (modify-syntax-entry ?&  "." st)
+    (modify-syntax-entry ?\|  "." st)
+    (modify-syntax-entry ?+  "." st)
+    (modify-syntax-entry ?*  "." st)
+    (modify-syntax-entry ?/  "." st)
+    (modify-syntax-entry ?=  "." st)
+    (modify-syntax-entry ?<  "." st)
+    (modify-syntax-entry ?>  "." st)
+    (modify-syntax-entry ?$ "." st)
+    (modify-syntax-entry ?\[ "." st)
+    (modify-syntax-entry ?\] "." st)
+    (modify-syntax-entry ?\{ "." st)
+    (modify-syntax-entry ?\} "." st)
+    (modify-syntax-entry ?. "." st)
+    (modify-syntax-entry ?\\ "." st)
+    (modify-syntax-entry ?\' "." st)
+
+    ;; A single hyphen is punctuation, but a double hyphen starts a comment.
+    (modify-syntax-entry ?-  ". 12" st)
+
+    ;; See the comment above on grammar related function for the special
+    ;; setup for '#'.
+    (modify-syntax-entry ?# (if (featurep 'xemacs) "<" "$") st)
+
+    ;; And \f and \n end a comment.
+    (modify-syntax-entry ?\f  ">   " st)
+    (modify-syntax-entry ?\n  ">   " st)
+
+    ;; Define what belongs in Ada symbols.
+    (modify-syntax-entry ?_ "_" st)
+
+    ;; Define parentheses to match.
+    (modify-syntax-entry ?\( "()" st)
+    (modify-syntax-entry ?\) ")(" st)
+    st)
+  "Syntax table to be used for editing Ada source code.")
+
+(defvar ada-mode-symbol-syntax-table
+  (let ((st (make-syntax-table ada-mode-syntax-table)))
+    (modify-syntax-entry ?_ "w" st)
+    st)
+  "Syntax table for Ada, where `_' is a word constituent.")
 
 ;;  Support of special characters in XEmacs (see the comments at the beginning
 ;;  of the section on Grammar related functions).
@@ -1293,7 +1283,7 @@ the file name."
   (if ada-popup-key
       (define-key ada-mode-map ada-popup-key 'ada-popup-menu))
 
-  ;;  Support for Abbreviations (the user still need to "M-x abbrev-mode"
+  ;;  Support for Abbreviations (the user still needs to "M-x abbrev-mode").
   (setq local-abbrev-table ada-mode-abbrev-table)
 
   ;;  Support for which-function mode
@@ -1625,9 +1615,8 @@ ARG is the prefix the user entered with \\[universal-argument]."
       (let ((lastk last-command-event))
 
         (with-syntax-table ada-mode-symbol-syntax-table
-          (cond ((or (eq lastk ?\n)
-                     (eq lastk ?\r))
-                 ;; horrible kludge
+          (cond ((memq lastk '(?\n ?\r))
+                 ;; Horrible kludge.
                  (insert " ")
                  (ada-adjust-case)
                  ;; horrible dekludge
@@ -1706,9 +1695,7 @@ ARG is ignored, and is there for compatibility with `capitalize-word' only."
   (interactive)
   (let ((end   (save-excursion (skip-syntax-forward  "w") (point)))
         (begin (save-excursion (skip-syntax-backward "w") (point))))
-    (modify-syntax-entry ?_ "_")
-    (capitalize-region begin end)
-    (modify-syntax-entry ?_ "w")))
+    (capitalize-region begin end)))
 
 (defun ada-adjust-case-region (from to)
   "Adjust the case of all words in the region between FROM and TO.
@@ -2165,7 +2152,7 @@ and the offset."
     (unwind-protect
         (with-syntax-table ada-mode-symbol-syntax-table
 
-          ;;  This need to be done here so that the advice is not always
+          ;;  This needs to be done here so that the advice is not always
           ;;  activated (this might interact badly with other modes)
           (if (featurep 'xemacs)
               (ad-activate 'parse-partial-sexp t))
@@ -3419,27 +3406,23 @@ Stop the search at LIMIT."
 If BACKWARD is non-nil, jump to the beginning of the previous word.
 Return the new position of point or nil if not found."
   (let ((match-cons nil)
-        (orgpoint (point))
-        (old-syntax (char-to-string (char-syntax ?_))))
-    (modify-syntax-entry ?_ "w")
+        (orgpoint (point)))
     (unless backward
-      (skip-syntax-forward "w"))
+      (skip-syntax-forward "w_"))
     (if (setq match-cons
-              (ada-search-ignore-string-comment "\\w" backward nil t))
+              (ada-search-ignore-string-comment "\\sw\\|\\s_" backward nil t))
         ;;
         ;; move to the beginning of the word found
         ;;
         (progn
           (goto-char (car match-cons))
-          (skip-syntax-backward "w")
+          (skip-syntax-backward "w_")
           (point))
       ;;
       ;; if not found, restore old position of point
       ;;
       (goto-char orgpoint)
-      'nil)
-    (modify-syntax-entry ?_ old-syntax))
-  )
+      'nil)))
 
 
 (defun ada-check-matching-start (keyword)
@@ -5431,9 +5414,6 @@ This function typically is to be hooked into `ff-file-created-hook'."
 (ada-create-keymap)
 (ada-create-menu)
 
-;;  Create the syntax tables, but do not activate them
-(ada-create-syntax-table)
-
 ;;  Add the default extensions (and set up speedbar)
 (ada-add-extensions ".ads" ".adb")
 ;; This two files are generated by GNAT when running with -gnatD
diff --git a/lisp/progmodes/autoconf.el b/lisp/progmodes/autoconf.el
index 8a99ad6e1b3..e6eaea985af 100644
--- a/lisp/progmodes/autoconf.el
+++ b/lisp/progmodes/autoconf.el
@@ -41,10 +41,10 @@
   "Hook run by `autoconf-mode'.")
 
 (defconst autoconf-definition-regexp
-  "A\\(?:H_TEMPLATE\\|C_\\(?:SUBST\\|DEFINE\\(?:_UNQUOTED\\)?\\)\\)(\\[*\\(\\sw+\\)\\]*")
+  "A\\(?:H_TEMPLATE\\|C_\\(?:SUBST\\|DEFINE\\(?:_UNQUOTED\\)?\\)\\)(\\[*\\(\\(?:\\sw\\|\\s_\\)+\\)\\]*")
 
 (defvar autoconf-font-lock-keywords
-  `(("\\_<A[CHMS]_\\sw+" . font-lock-keyword-face)
+  `(("\\_<A[CHMS]_\\(?:\\sw\\|\\s_\\)+" . font-lock-keyword-face)
     (,autoconf-definition-regexp
      1 font-lock-function-name-face)
     ;; Are any other M4 keywords really appropriate for configure.ac,
@@ -67,13 +67,11 @@
 This version looks back for an AC_DEFINE or AC_SUBST.  It will stop
 searching backwards at another AC_... command."
   (save-excursion
-    (with-syntax-table (copy-syntax-table autoconf-mode-syntax-table)
-      (modify-syntax-entry ?_ "w")
-      (skip-syntax-forward "w" (line-end-position))
-      (if (re-search-backward autoconf-definition-regexp
-                              (save-excursion (beginning-of-defun) (point))
-                              t)
-          (match-string-no-properties 1)))))
+    (skip-syntax-forward "w_" (line-end-position))
+    (if (re-search-backward autoconf-definition-regexp
+                            (save-excursion (beginning-of-defun) (point))
+                            t)
+        (match-string-no-properties 1))))
 
 ;;;###autoload
 (define-derived-mode autoconf-mode prog-mode "Autoconf"
@@ -85,9 +83,8 @@ searching backwards at another AC_... command."
   (setq-local syntax-propertize-function
               (syntax-propertize-rules ("\\<dnl\\>" (0 "<"))))
   (setq-local font-lock-defaults
-              `(autoconf-font-lock-keywords nil nil (("_" . "w"))))
+              `(autoconf-font-lock-keywords nil nil))
   (setq-local imenu-generic-expression autoconf-imenu-generic-expression)
-  (setq-local imenu-syntax-alist '(("_" . "w")))
   (setq-local indent-line-function #'indent-relative)
   (setq-local add-log-current-defun-function
               #'autoconf-current-defun-function))
diff --git a/lisp/progmodes/cc-bytecomp.el b/lisp/progmodes/cc-bytecomp.el
index e41455f7883..337a5292417 100644
--- a/lisp/progmodes/cc-bytecomp.el
+++ b/lisp/progmodes/cc-bytecomp.el
@@ -232,6 +232,9 @@ perhaps a `cc-bytecomp-restore-environment' is forgotten somewhere"))
           (cc-bytecomp-setup-environment)
           t))))
 
+(defvar cc-bytecomp-noruntime-functions nil
+  "Saved value of `byte-compile-noruntime-functions'.")
+
 (defmacro cc-require (cc-part)
   "Force loading of the corresponding .el file in the current directory
 during compilation, but compile in a `require'.  Don't use within
@@ -240,7 +243,16 @@ during compilation, but compile in a `require'.  Don't use within
 Having cyclic cc-require's will result in infinite recursion.  That's
 somewhat intentional."
   `(progn
-     (eval-when-compile (cc-bytecomp-load (symbol-name ,cc-part)))
+     (eval-when-compile
+       (setq cc-bytecomp-noruntime-functions byte-compile-noruntime-functions)
+       (cc-bytecomp-load (symbol-name ,cc-part)))
+     ;; Hack to suppress spurious "might not be defined at runtime" warnings.
+     ;; The basic issue is that
+     ;;   (eval-when-compile (require 'foo))
+     ;;   (require 'foo)
+     ;; produces bogus noruntime warnings about functions from foo.
+     (eval-when-compile
+       (setq byte-compile-noruntime-functions cc-bytecomp-noruntime-functions))
      (require ,cc-part)))
 
 (defmacro cc-provide (feature)
@@ -266,7 +278,7 @@ somewhat intentional."
 during compilation, but do a compile time `require' otherwise.  Don't
 use within `eval-when-compile'."
   `(eval-when-compile
-     (if (and (featurep 'cc-bytecomp)
+     (if (and (fboundp 'cc-bytecomp-is-compiling)
               (cc-bytecomp-is-compiling))
          (if (or (not load-in-progress)
                  (not (featurep ,cc-part)))
diff --git a/lisp/progmodes/cc-cmds.el b/lisp/progmodes/cc-cmds.el
index 0bb804799dc..dc6ed1348d1 100644
--- a/lisp/progmodes/cc-cmds.el
+++ b/lisp/progmodes/cc-cmds.el
@@ -45,7 +45,6 @@
 (cc-require 'cc-engine)
 
 ;; Silence the compiler.
-(cc-bytecomp-defun delete-forward-p)    ; XEmacs
 (cc-bytecomp-defvar filladapt-mode)     ; c-fill-paragraph contains a kludge
                                         ; which looks at this.
 
diff --git a/lisp/progmodes/cc-defs.el b/lisp/progmodes/cc-defs.el
index 48236c2dca2..b90a01dcb3b 100644
--- a/lisp/progmodes/cc-defs.el
+++ b/lisp/progmodes/cc-defs.el
@@ -48,16 +48,12 @@
 
 ;; Silence the compiler.
 (cc-bytecomp-defvar c-enable-xemacs-performance-kludge-p) ; In cc-vars.el
-(cc-bytecomp-defun buffer-syntactic-context-depth) ; XEmacs
 (cc-bytecomp-defun region-active-p)     ; XEmacs
-(cc-bytecomp-defvar zmacs-region-stays) ; XEmacs
-(cc-bytecomp-defvar zmacs-regions)      ; XEmacs
 (cc-bytecomp-defvar mark-active)        ; Emacs
 (cc-bytecomp-defvar deactivate-mark)    ; Emacs
 (cc-bytecomp-defvar inhibit-point-motion-hooks) ; Emacs
 (cc-bytecomp-defvar parse-sexp-lookup-properties) ; Emacs
 (cc-bytecomp-defvar text-property-default-nonsticky) ; Emacs 21
-(cc-bytecomp-defvar lookup-syntax-properties) ; XEmacs
 (cc-bytecomp-defun string-to-syntax)    ; Emacs 21
 
 
@@ -93,7 +89,7 @@
 
 ;;; Variables also used at compile time.
 
-(defconst c-version "5.32.4"
+(defconst c-version "5.32.5"
   "CC Mode version number.")
 
 (defconst c-version-sym (intern c-version))
@@ -334,6 +330,8 @@ to it is returned.  This function does not modify the point or the mark."
 (defmacro c-region-is-active-p ()
   ;; Return t when the region is active.  The determination of region
   ;; activeness is different in both Emacs and XEmacs.
+  ;; FIXME? Emacs has region-active-p since 23.1, so maybe this test
+  ;; should be updated.
   (if (cc-bytecomp-boundp 'mark-active)
       ;; Emacs.
       'mark-active
@@ -343,7 +341,7 @@ to it is returned.  This function does not modify the point or the mark."
 (defmacro c-set-region-active (activate)
   ;; Activate the region if ACTIVE is non-nil, deactivate it
   ;; otherwise.  Covers the differences between Emacs and XEmacs.
-  (if (cc-bytecomp-fboundp 'zmacs-activate-region)
+  (if (fboundp 'zmacs-activate-region)
       ;; XEmacs.
       `(if ,activate
            (zmacs-activate-region)
@@ -707,9 +705,9 @@ be after it."
   ;; `c-parse-state'.
 
   `(progn
-     (if (and ,(cc-bytecomp-fboundp 'buffer-syntactic-context-depth)
+     (if (and ,(fboundp 'buffer-syntactic-context-depth)
               c-enable-xemacs-performance-kludge-p)
-         ,(when (cc-bytecomp-fboundp 'buffer-syntactic-context-depth)
+         ,(when (fboundp 'buffer-syntactic-context-depth)
             ;; XEmacs only.  This can improve the performance of
             ;; c-parse-state to between 3 and 60 times faster when
             ;; braces are hung.  It can also degrade performance by
@@ -1606,7 +1604,7 @@ non-nil, a caret is prepended to invert the set."
     (let ((buf (generate-new-buffer " test"))
           parse-sexp-lookup-properties
           parse-sexp-ignore-comments
-          lookup-syntax-properties)
+          lookup-syntax-properties)     ; XEmacs
       (with-current-buffer buf
         (set-syntax-table (make-syntax-table))
 
diff --git a/lisp/progmodes/cc-engine.el b/lisp/progmodes/cc-engine.el
index 368b1fc50dc..b0c0bfd7bde 100644
--- a/lisp/progmodes/cc-engine.el
+++ b/lisp/progmodes/cc-engine.el
@@ -147,9 +147,6 @@
 (cc-require-when-compile 'cc-langs)
 (cc-require 'cc-vars)
 
-;; Silence the compiler.
-(cc-bytecomp-defun buffer-syntactic-context) ; XEmacs
-
 
 ;; Make declarations for all the `c-lang-defvar' variables in cc-langs.
 
@@ -2180,32 +2177,45 @@ comment at the start of cc-engine.el for more info."
 ;; reduced by buffer changes, and increased by invocations of
 ;; `c-state-literal-at'.  FIXME!!!
 
-(defsubst c-state-pp-to-literal (from to)
+(defsubst c-state-pp-to-literal (from to &optional not-in-delimiter)
   ;; Do a parse-partial-sexp from FROM to TO, returning either
   ;;     (STATE TYPE (BEG . END))     if TO is in a literal; or
   ;;     (STATE)                      otherwise,
   ;; where STATE is the parsing state at TO, TYPE is the type of the literal
   ;; (one of 'c, 'c++, 'string) and (BEG . END) is the boundaries of the literal.
   ;;
+  ;; Unless NOT-IN-DELIMITER is non-nil, when TO is inside a two-character
+  ;; comment opener, this is recognized as being in a comment literal.
+  ;;
   ;; Only elements 3 (in a string), 4 (in a comment), 5 (following a quote),
   ;; 7 (comment type) and 8 (start of comment/string) (and possibly 9) of
   ;; STATE are valid.
   (save-excursion
     (let ((s (parse-partial-sexp from to))
-          ty)
-      (when (or (nth 3 s) (nth 4 s))    ; in a string or comment
+          ty co-st)
+      (cond
+       ((or (nth 3 s) (nth 4 s))        ; in a string or comment
         (setq ty (cond
                   ((nth 3 s) 'string)
-                  ((eq (nth 7 s) t) 'c++)
+                  ((nth 7 s) 'c++)
                   (t 'c)))
         (parse-partial-sexp (point) (point-max)
-                            nil                  ; TARGETDEPTH
-                            nil                  ; STOPBEFORE
-                            s                    ; OLDSTATE
-                            'syntax-table))      ; stop at end of literal
-      (if ty
-          `(,s ,ty (,(nth 8 s) . ,(point)))
-        `(,s)))))
+                            nil            ; TARGETDEPTH
+                            nil            ; STOPBEFORE
+                            s              ; OLDSTATE
+                            'syntax-table) ; stop at end of literal
+        `(,s ,ty (,(nth 8 s) . ,(point))))
+
+       ((and (not not-in-delimiter)     ; inside a comment starter
+             (not (bobp))
+             (progn (backward-char)
+                    (looking-at c-comment-start-regexp)))
+        (setq ty (if (looking-at c-block-comment-start-regexp) 'c 'c++)
+              co-st (point))
+        (forward-comment 1)
+        `(,s ,ty (,co-st . ,(point))))
+
+       (t `(,s))))))
 
 (defun c-state-safe-place (here)
   ;; Return a buffer position before HERE which is "safe", i.e. outside any
@@ -3143,10 +3153,13 @@ comment at the start of cc-engine.el for more info."
   ;; This function is called from c-after-change.
 
   ;; The caches of non-literals:
-  (if (< here c-state-nonlit-pos-cache-limit)
-      (setq c-state-nonlit-pos-cache-limit here))
-  (if (< here c-state-semi-nonlit-pos-cache-limit)
-      (setq c-state-semi-nonlit-pos-cache-limit here))
+  ;; Note that we use "<=" for the possibility of the second char of a two-char
+  ;; comment opener being typed; this would invalidate any cache position at
+  ;; HERE.
+  (if (<= here c-state-nonlit-pos-cache-limit)
+      (setq c-state-nonlit-pos-cache-limit (1- here)))
+  (if (<= here c-state-semi-nonlit-pos-cache-limit)
+      (setq c-state-semi-nonlit-pos-cache-limit (1- here)))
 
   ;; `c-state-cache':
   ;; Case 1: if `here' is in a literal containing point-min, everything
@@ -4444,19 +4457,12 @@ comment at the start of cc-engine.el for more info."
            (lim (or lim (c-state-semi-safe-place pos)))
            (pp-to-lit (save-restriction
                         (widen)
-                        (c-state-pp-to-literal lim pos)))
+                        (c-state-pp-to-literal lim pos not-in-delimiter)))
            (state (car pp-to-lit))
            (lit-limits (car (cddr pp-to-lit))))
 
       (cond
        (lit-limits)
-       ((and (not not-in-delimiter)
-             (not (elt state 5))
-             (eq (char-before) ?/)
-             (looking-at "[/*]")) ; FIXME!!! use c-line/block-comment-starter.  2008-09-28.
-        ;; We're standing in a comment starter.
-        (backward-char 1)
-        (cons (point) (progn (c-forward-single-comment) (point))))
 
        (near
         (goto-char pos)
@@ -6466,6 +6472,52 @@ comment at the start of cc-engine.el for more info."
            (c-go-list-forward)
          t)))
 
+(defun c-back-over-member-initializers ()
+  ;; Test whether we are in a C++ member initializer list, and if so, go back
+  ;; to the introducing ":", returning the position of the opening paren of
+  ;; the function's arglist.  Otherwise return nil, leaving point unchanged.
+  (let ((here (point))
+        (paren-state (c-parse-state))
+        res)
+
+    (setq res
+          (catch 'done
+            (if (not (c-at-toplevel-p))
+                (progn
+                  (while (not (c-at-toplevel-p))
+                    (goto-char (c-pull-open-brace paren-state)))
+                  (c-backward-syntactic-ws)
+                  (when (not (c-simple-skip-symbol-backward))
+                    (throw 'done nil))
+                  (c-backward-syntactic-ws))
+              (c-backward-syntactic-ws)
+              (when (memq (char-before) '(?\) ?}))
+                (when (not (c-go-list-backward))
+                  (throw 'done nil))
+                (c-backward-syntactic-ws))
+              (when (c-simple-skip-symbol-backward)
+                (c-backward-syntactic-ws)))
+
+            (while (eq (char-before) ?,)
+              (backward-char)
+              (c-backward-syntactic-ws)
+
+              (when (not (memq (char-before) '(?\) ?})))
+                (throw 'done nil))
+              (when (not (c-go-list-backward))
+                (throw 'done nil))
+              (c-backward-syntactic-ws)
+              (when (not (c-simple-skip-symbol-backward))
+                (throw 'done nil))
+              (c-backward-syntactic-ws))
+
+            (and
+             (eq (char-before) ?:)
+             (c-just-after-func-arglist-p))))
+
+    (or res (goto-char here))
+    res))
+
 
 ;; Handling of large scale constructs like statements and declarations.
 
@@ -9668,18 +9720,13 @@ comment at the start of cc-engine.el for more info."
               ;; 2007-11-09)
               ))))
 
-         ;; CASE 5B: After a function header but before the body (or
-         ;; the ending semicolon if there's no body).
+         ;; CASE 5R: Member init list.  (Used to be part of CASE  5B.1)
+         ;; Note there is no limit on the backward search here, since member
+         ;; init lists can, in practice, be very large.
          ((save-excursion
-            (when (setq placeholder (c-just-after-func-arglist-p
-                                     (max lim (c-determine-limit 500))))
+            (when (setq placeholder (c-back-over-member-initializers))
               (setq tmp-pos (point))))
-          (cond
-
-           ;; CASE 5B.1: Member init list.
-           ((eq (char-after tmp-pos) ?:)
-            (if (or (>= tmp-pos indent-point)
-                    (= (c-point 'bosws) (1+ tmp-pos)))
+          (if (= (c-point 'bosws) (1+ tmp-pos))
                 (progn
                   ;; There is no preceding member init clause.
                   ;; Indent relative to the beginning of indentation
@@ -9692,6 +9739,23 @@ comment at the start of cc-engine.el for more info."
               (c-forward-syntactic-ws)
               (c-add-syntax 'member-init-cont (point))))
 
+         ;; CASE 5B: After a function header but before the body (or
+         ;; the ending semicolon if there's no body).
+         ((save-excursion
+            (when (setq placeholder (c-just-after-func-arglist-p
+                                     (max lim (c-determine-limit 500))))
+              (setq tmp-pos (point))))
+          (cond
+
+           ;; CASE 5B.1: Member init list.
+           ((eq (char-after tmp-pos) ?:)
+            ;; There is no preceding member init clause.
+            ;; Indent relative to the beginning of indentation
+            ;; for the topmost-intro line that contains the
+            ;; prototype's open paren.
+            (goto-char placeholder)
+            (c-add-syntax 'member-init-intro (c-point 'boi)))
+
            ;; CASE 5B.2: K&R arg decl intro
            ((and c-recognize-knr-p
                  (c-in-knr-argdecl lim))
diff --git a/lisp/progmodes/cc-fonts.el b/lisp/progmodes/cc-fonts.el
index f6c47f5bb4d..6a4bfd9e875 100644
--- a/lisp/progmodes/cc-fonts.el
+++ b/lisp/progmodes/cc-fonts.el
@@ -176,7 +176,6 @@
       'font-lock-negation-char-face))
 
 (cc-bytecomp-defun face-inverse-video-p) ; Only in Emacs.
-(cc-bytecomp-defun face-property-instance) ; Only in XEmacs.
 
 (defun c-make-inverse-face (oldface newface)
   ;; Emacs and XEmacs have completely different face manipulation
@@ -2486,7 +2485,7 @@ need for `pike-font-lock-extra-types'.")
               (setq comment-beg nil))
             (setq region-beg comment-beg))
 
-      (if (eq (elt (parse-partial-sexp comment-beg (+ comment-beg 2)) 7) t)
+      (if (elt (parse-partial-sexp comment-beg (+ comment-beg 2)) 7)
           ;; Collect a sequence of doc style line comments.
           (progn
             (goto-char comment-beg)
diff --git a/lisp/progmodes/cc-langs.el b/lisp/progmodes/cc-langs.el
index ba9c42e4c89..af52ad53aad 100644
--- a/lisp/progmodes/cc-langs.el
+++ b/lisp/progmodes/cc-langs.el
@@ -812,8 +812,8 @@ Assumed to not contain any submatches or \\| operators."
 (c-lang-defconst c-anchored-cpp-prefix
   "Regexp matching the prefix of a cpp directive anchored to BOL,
 in the languages that have a macro preprocessor."
-  t (if (c-lang-const c-opt-cpp-prefix)
-        (concat "^" (c-lang-const c-opt-cpp-prefix))))
+  t "^\\s *\\(#\\)\\s *"
+  (java awk) nil)
 (c-lang-defvar c-anchored-cpp-prefix (c-lang-const c-anchored-cpp-prefix))
 
 (c-lang-defconst c-opt-cpp-start
diff --git a/lisp/progmodes/cc-menus.el b/lisp/progmodes/cc-menus.el
index a06eaf566d8..067a4df13dd 100644
--- a/lisp/progmodes/cc-menus.el
+++ b/lisp/progmodes/cc-menus.el
@@ -161,49 +161,132 @@ A sample value might look like: `\\(_P\\|_PROTO\\)'.")
   cc-imenu-c++-generic-expression
   "Imenu generic expression for C mode.  See `imenu-generic-expression'.")
 
-(defvar cc-imenu-java-generic-expression
+
+;; Auxiliary regexps for Java try to match their trailing whitespace where
+;; appropriate, but _not_ starting whitespace.
+
+(defconst cc-imenu-java-ellipsis-regexp
+  (concat
+   "\\.\\{3\\}"
+   "[ \t\n\r]*"))
+
+(defun cc-imenu-java-build-type-args-regex (depth)
+  "Builds regexp for type arguments list with DEPTH allowed
+nested angle brackets constructs."
+  (if (> depth 0)
+      (concat "<"
+                "[][.," c-alnum "_? \t\n\r]+"
+                (if (> depth 1)
+                    "\\(")
+                (cc-imenu-java-build-type-args-regex (1- depth))
+                (if (> depth 1)
+                  (concat "[][.," c-alnum "_? \t\n\r]*"
+                          "\\)*"))
+              ">")))
+
+(defconst cc-imenu-java-type-spec-regexp
+  (concat
+   ;; zero or more identifiers followed by a dot
+   "\\("
+     "[" c-alpha "_][" c-alnum "_]*\\."
+   "\\)*"
+   ;; a single mandatory identifier without a dot
+   "[" c-alpha "_][" c-alnum "_]*"
+   ;; then choice:
+   "\\("
+   ;; (option 1) type arguments list which _may_ be followed with brackets
+   ;; and/or spaces, then optional variable arity
+     "[ \t\n\r]*"
+     (cc-imenu-java-build-type-args-regex 3)
+     "[][ \t\n\r]*"
+     "\\(" cc-imenu-java-ellipsis-regexp "\\)?"
+   "\\|"
+   ;; (option 2) just brackets and/or spaces (there should be at least one),
+   ;; then optional variable arity
+     "[][ \t\n\r]+"
+     "\\(" cc-imenu-java-ellipsis-regexp "\\)?"
+   "\\|"
+   ;; (option 3) just variable arity
+     cc-imenu-java-ellipsis-regexp
+   "\\)"))
+
+(defconst cc-imenu-java-comment-regexp
+  (concat
+   "/"
+   "\\("
+   ;; a traditional comment
+     "\\*"
+     "\\("
+       "[^*]"
+     "\\|"
+       "\\*+[^/*]"
+     "\\)*"
+     "\\*+/"
+   "\\|"
+   ;; an end-of-line comment
+     "/[^\n\r]*[\n\r]"
+   "\\)"
+  "[ \t\n\r]*"
+   ))
+
+;; Comments are allowed before the argument, after any of the
+;; modifiers and after the identifier.
+(defconst cc-imenu-java-method-arg-regexp
+  (concat
+   "\\(" cc-imenu-java-comment-regexp "\\)*"
+   ;; optional modifiers
+   "\\("
+     ;; a modifier is either an annotation or "final"
+     "\\("
+       "@[" c-alpha "_]"
+       "[" c-alnum "._]*"
+       ;; TODO support element-value pairs!
+     "\\|"
+       "final"
+     "\\)"
+     ;; a modifier ends with comments and/or ws
+     "\\("
+       "\\(" cc-imenu-java-comment-regexp "\\)+"
+     "\\|"
+       "[ \t\n\r]+"
+       "\\(" cc-imenu-java-comment-regexp "\\)*"
+     "\\)"
+   "\\)*"
+   ;; type spec
+   cc-imenu-java-type-spec-regexp
+   ;; identifier
+   "[" c-alpha "_]"
+   "[" c-alnum "_]*"
+   ;; optional comments and/or ws
+   "[ \t\n\r]*"
+   "\\(" cc-imenu-java-comment-regexp "\\)*"
+   ))
+
+(defconst cc-imenu-java-generic-expression
   `((nil
      ,(concat
-       "[" c-alpha "_][\]\[." c-alnum "_<> ]+[ \t\n\r]+" ; type spec
-       "\\([" c-alpha "_][" c-alnum "_]*\\)" ; method name
+       cc-imenu-java-type-spec-regexp
+       "\\("                                  ; method name which gets captured
+                                              ; into index
+         "[" c-alpha "_]"
+         "[" c-alnum "_]*"
+       "\\)"
        "[ \t\n\r]*"
-       ;; An argument list htat is either empty or contains any number
-       ;; of arguments.  An argument is any number of annotations
-       ;; followed by a type spec followed by a word.  A word is an
-       ;; identifier.  A type spec is an identifier, possibly followed
-       ;; by < typespec > possibly followed by [].
-       (concat "("
-               "\\("
-               "[ \t\n\r]*"
-               "\\("
-               "@"
-               "[" c-alpha "_]"
-               "[" c-alnum "._]""*"
-               "[ \t\n\r]+"
-               "\\)*"
-               "\\("
-               "[" c-alpha "_]"
-               "[\]\[" c-alnum "_.]*"
-               "\\("
-
-               "<"
-               "[ \t\n\r]*"
-               "[\]\[.," c-alnum "_<> \t\n\r]*"
-               ">"
-               "\\)?"
-               "\\(\\[\\]\\)?"
-               "[ \t\n\r]+"
-               "\\)"
-               "[" c-alpha "_]"
-               "[" c-alnum "_]*"
-               "[ \t\n\r,]*"
-               "\\)*"
-               ")"
-               "[.," c-alnum " \t\n\r]*"
-               "{"
-               )) 1))
+       ;; An argument list that contains zero or more arguments.
+       (concat
+        "("
+        "[ \t\n\r]*"
+        "\\("
+          "\\(" cc-imenu-java-method-arg-regexp ",[ \t\n\r]*\\)*"
+          cc-imenu-java-method-arg-regexp
+        "\\)?"
+        ")"
+        "[.,_" c-alnum " \t\n\r]*"            ; throws etc.
+        "{"
+        )) 7))
   "Imenu generic expression for Java mode.  See `imenu-generic-expression'.")
 
+
 ;; Internal variables
 (defvar cc-imenu-objc-generic-expression-noreturn-index nil)
 (defvar cc-imenu-objc-generic-expression-general-func-index nil)
diff --git a/lisp/progmodes/cc-mode.el b/lisp/progmodes/cc-mode.el
index 3c3a5766582..36c9f72fa18 100644
--- a/lisp/progmodes/cc-mode.el
+++ b/lisp/progmodes/cc-mode.el
@@ -86,8 +86,8 @@
     (load "cc-bytecomp" nil t)))
 
 (cc-require 'cc-defs)
-(cc-require-when-compile 'cc-langs)
 (cc-require 'cc-vars)
+(cc-require-when-compile 'cc-langs)
 (cc-require 'cc-engine)
 (cc-require 'cc-styles)
 (cc-require 'cc-cmds)
@@ -97,7 +97,6 @@
 
 ;; Silence the compiler.
 (cc-bytecomp-defvar adaptive-fill-first-line-regexp) ; Emacs
-(cc-bytecomp-defun set-keymap-parents)  ; XEmacs
 (cc-bytecomp-defun run-mode-hooks)      ; Emacs 21.1
 
 ;; We set these variables during mode init, yet we don't require
@@ -212,7 +211,7 @@ control).  See \"cc-mode.el\" for more info."
      ((cc-bytecomp-fboundp 'set-keymap-parent)
       (set-keymap-parent map c-mode-base-map))
      ;; XEmacs
-     ((cc-bytecomp-fboundp 'set-keymap-parents)
+     ((fboundp 'set-keymap-parents)
       (set-keymap-parents map c-mode-base-map))
      ;; incompatible
      (t (error "CC Mode is incompatible with this version of Emacs")))
@@ -936,7 +935,8 @@ Note that the style variables are always made local to the buffer."
 
     ;; Add needed properties to each CPP construct in the region.
     (goto-char c-new-BEG)
-    (let ((pps-position c-new-BEG)  pps-state mbeg)
+    (skip-chars-backward " \t")
+    (let ((pps-position (point))  pps-state mbeg)
       (while (and (< (point) c-new-END)
                   (search-forward-regexp c-anchored-cpp-prefix c-new-END t))
         ;; If we've found a "#" inside a string/comment, ignore it.
@@ -945,14 +945,12 @@ Note that the style variables are always made local to the buffer."
               pps-position (point))
         (unless (or (nth 3 pps-state)   ; in a string?
                     (nth 4 pps-state))  ; in a comment?
-          (goto-char (match-beginning 0))
+          (goto-char (match-beginning 1))
           (setq mbeg (point))
           (if (> (c-syntactic-end-of-macro) mbeg)
               (progn
                 (c-neutralize-CPP-line mbeg (point))
-                (c-set-cpp-delimiters mbeg (point))
-                ;(setq pps-position (point))
-                )
+                (c-set-cpp-delimiters mbeg (point)))
             (forward-line))           ; no infinite loop with, e.g., "#//"
           )))))
 
@@ -1060,7 +1058,7 @@ Note that the style variables are always made local to the buffer."
   ;; This calls the language variable c-before-font-lock-functions, if non nil.
   ;; This typically sets `syntax-table' properties.
 
-  (c-save-buffer-state ()
+  (c-save-buffer-state (case-fold-search)
     ;; When `combine-after-change-calls' is used we might get calls
     ;; with regions outside the current narrowing.  This has been
     ;; observed in Emacs 20.7.
@@ -1078,12 +1076,13 @@ Note that the style variables are always made local to the buffer."
             (setq beg end)))
 
         ;; C-y is capable of spuriously converting category properties
-        ;; c-</>-as-paren-syntax into hard syntax-table properties.  Remove
-        ;; these when it happens.
+        ;; c-</>-as-paren-syntax and c-cpp-delimiter into hard syntax-table
+        ;; properties.  Remove these when it happens.
         (c-clear-char-property-with-value beg end 'syntax-table
                                           c-<-as-paren-syntax)
         (c-clear-char-property-with-value beg end 'syntax-table
                                           c->-as-paren-syntax)
+        (c-clear-char-property-with-value beg end 'syntax-table nil)
 
         (c-trim-found-types beg end old-len) ; maybe we don't need all of these.
         (c-invalidate-sws-region-after beg end)
@@ -1161,9 +1160,6 @@ Note that the style variables are always made local to the buffer."
   ;; `c-set-fl-decl-start' for the detailed functionality.
   (cons (c-set-fl-decl-start beg) end))
 
-(defvar c-standard-font-lock-fontify-region-function nil
-  "Standard value of `font-lock-fontify-region-function'")
-
 (defun c-font-lock-fontify-region (beg end &optional verbose)
   ;; Effectively advice around `font-lock-fontify-region' which extends the
   ;; region (BEG END), for example, to avoid context fontification chopping
@@ -1188,17 +1184,14 @@ Note that the style variables are always made local to the buffer."
                   (setq new-region (funcall fn new-beg new-end))
                   (setq new-beg (car new-region)  new-end (cdr new-region)))
                 c-before-context-fontification-functions))))
-    (funcall c-standard-font-lock-fontify-region-function
+    (funcall (default-value 'font-lock-fontify-region-function)
              new-beg new-end verbose)))
 
 (defun c-after-font-lock-init ()
   ;; Put on `font-lock-mode-hook'.  This function ensures our after-change
-  ;; function will get executed before the font-lock one.  Amongst other
-  ;; things.
+  ;; function will get executed before the font-lock one.
   (remove-hook 'after-change-functions 'c-after-change t)
-  (add-hook 'after-change-functions 'c-after-change nil t)
-  (setq c-standard-font-lock-fontify-region-function
-        (default-value 'font-lock-fontify-region-function)))
+  (add-hook 'after-change-functions 'c-after-change nil t))
 
 (defun c-font-lock-init ()
   "Set up the font-lock variables for using the font-lock support in CC Mode.
diff --git a/lisp/progmodes/cc-vars.el b/lisp/progmodes/cc-vars.el
index 66ff217c73e..c89402c63a3 100644
--- a/lisp/progmodes/cc-vars.el
+++ b/lisp/progmodes/cc-vars.el
@@ -42,23 +42,25 @@
 
 (cc-require 'cc-defs)
 
-;; Silence the compiler.
-(cc-bytecomp-defun get-char-table)      ; XEmacs
-
 (cc-eval-when-compile
   (require 'custom)
   (require 'widget))
 
 ;;; Helpers
 
-;; This widget exists in newer versions of the Custom library
-(or (get 'other 'widget-type)
-    (define-widget 'other 'sexp
-      "Matches everything, but doesn't let the user edit the value.
+
+;; Emacs has 'other since at least version 21.1.
+;; FIXME this is probably broken, since the widget is defined
+;; in wid-edit, which this file does not load.  So we will always
+;; define the widget, even when we don't need to.
+(when (featurep 'xemacs)
+  (or (get 'other 'widget-type)
+      (define-widget 'other 'sexp
+        "Matches everything, but doesn't let the user edit the value.
 Useful as last item in a `choice' widget."
-      :tag "Other"
-      :format "%t%n"
-      :value 'other))
+        :tag "Other"
+        :format "%t%n"
+        :value 'other)))
 
 ;; The next defun will supersede c-const-symbol.
 (eval-and-compile
@@ -1622,11 +1624,30 @@ names)."))
 )
 (make-variable-buffer-local 'c-macro-with-semi-re)
 
+(defvar c-macro-names-with-semicolon
+  '("Q_OBJECT" "Q_PROPERTY" "Q_DECLARE" "Q_ENUMS")
+  "List of #defined symbols whose expansion ends with a semicolon.
+Alternatively it can be a string, a regular expression which
+matches all such symbols.
+
+The \"symbols\" must be syntactically valid identifiers in the
+target language \(C, C++, Objective C), or \(as the case may be)
+the regular expression must match only valid identifiers.
+
+If you change this variable's value, call the function
+`c-make-macros-with-semi-re' to set the necessary internal
+variables.
+
+Note that currently \(2008-11-04) this variable is a prototype,
+and is likely to disappear or change its form soon.")
+(make-variable-buffer-local 'c-macro-names-with-semicolon)
+
 (defun c-make-macro-with-semi-re ()
   ;; Convert `c-macro-names-with-semicolon' into the regexp
   ;; `c-macro-with-semi-re' (or just copy it if it's already a re).
   (setq c-macro-with-semi-re
         (and
+         (boundp 'c-opt-cpp-macro-define)
          c-opt-cpp-macro-define
          (cond
           ((stringp c-macro-names-with-semicolon)
@@ -1643,24 +1664,6 @@ names)."))
 c-macro-names-with-semicolon: %s"
                     c-macro-names-with-semicolon))))))
 
-(defvar c-macro-names-with-semicolon
-  '("Q_OBJECT" "Q_PROPERTY" "Q_DECLARE" "Q_ENUMS")
-  "List of #defined symbols whose expansion ends with a semicolon.
-Alternatively it can be a string, a regular expression which
-matches all such symbols.
-
-The \"symbols\" must be syntactically valid identifiers in the
-target language \(C, C++, Objective C), or \(as the case may be)
-the regular expression must match only valid identifiers.
-
-If you change this variable's value, call the function
-`c-make-macros-with-semi-re' to set the necessary internal
-variables.
-
-Note that currently \(2008-11-04) this variable is a prototype,
-and is likely to disappear or change its form soon.")
-(make-variable-buffer-local 'c-macro-names-with-semicolon)
-
 (defvar c-file-style nil
   "Variable interface for setting style via File Local Variables.
 In a file's Local Variable section, you can set this variable to a
diff --git a/lisp/progmodes/cfengine.el b/lisp/progmodes/cfengine.el
index 74b81b0cd01..11eb0eeaf49 100644
--- a/lisp/progmodes/cfengine.el
+++ b/lisp/progmodes/cfengine.el
@@ -30,11 +30,13 @@
 ;; The CFEngine 3.x support doesn't have Imenu support but patches are
 ;; welcome.
 
+;; By default, CFEngine 3.x syntax is used.
+
 ;; You can set it up so either `cfengine2-mode' (2.x and earlier) or
 ;; `cfengine3-mode' (3.x) will be picked, depending on the buffer
 ;; contents:
 
-;; (add-to-list 'auto-mode-alist '("\\.cf\\'" . cfengine-mode))
+;; (add-to-list 'auto-mode-alist '("\\.cf\\'" . cfengine-auto-mode))
 
 ;; OR you can choose to always use a specific version, if you prefer
 ;; it:
@@ -181,7 +183,7 @@ This includes those for cfservd as well as cfagent.")
     ("$(\\([[:alnum:]_]+\\))" 1 font-lock-variable-name-face)
     ("${\\([[:alnum:]_]+\\)}" 1 font-lock-variable-name-face)
     ;; Variable definitions.
-    ("\\<\\([[:alnum:]_]+\\)[ \t]*=[ \t]*(" 1 font-lock-variable-name-face)
+    ("\\_<\\([[:alnum:]_]+\\)[ \t]*=[ \t]*(" 1 font-lock-variable-name-face)
     ;; File, acl &c in group:   { token ... }
     ("{[ \t]*\\([^ \t\n]+\\)" 1 font-lock-constant-face)))
 
@@ -189,9 +191,9 @@ This includes those for cfservd as well as cfagent.")
   `(
     ;; Defuns.  This happens early so they don't get caught by looser
     ;; patterns.
-    (,(concat "\\<" cfengine3-defuns-regex "\\>"
-              "[ \t]+\\<\\([[:alnum:]_.:]+\\)\\>"
-              "[ \t]+\\<\\([[:alnum:]_.:]+\\)"
+    (,(concat "\\_<" cfengine3-defuns-regex "\\_>"
+              "[ \t]+\\_<\\([[:alnum:]_.:]+\\)\\_>"
+              "[ \t]+\\_<\\([[:alnum:]_.:]+\\)"
               ;; Optional parentheses with variable names inside.
               "\\(?:(\\([^)]*\\))\\)?")
      (1 font-lock-builtin-face)
@@ -212,10 +214,10 @@ This includes those for cfservd as well as cfagent.")
     ("[@$]{\\([[:alnum:]_.:]+\\)}" 1 font-lock-variable-name-face)
 
     ;; Variable definitions.
-    ("\\<\\([[:alnum:]_]+\\)[ \t]*=[ \t]*(" 1 font-lock-variable-name-face)
+    ("\\_<\\([[:alnum:]_]+\\)[ \t]*=[ \t]*(" 1 font-lock-variable-name-face)
 
     ;; Variable types.
-    (,(concat "\\<" (eval-when-compile (regexp-opt cfengine3-vartypes t)) "\\>")
+    (,(concat "\\_<" (eval-when-compile (regexp-opt cfengine3-vartypes t)) "\\_>")
      1 font-lock-type-face)))
 
 (defvar cfengine2-imenu-expression
@@ -223,9 +225,9 @@ This includes those for cfservd as well as cfagent.")
                               (regexp-opt cfengine2-actions t))
                   ":[^:]")
          1)
-    ("Variables/classes" "\\<\\([[:alnum:]_]+\\)[ \t]*=[ \t]*(" 1)
-    ("Variables/classes" "\\<define=\\([[:alnum:]_]+\\)" 1)
-    ("Variables/classes" "\\<DefineClass\\>[ \t]+\\([[:alnum:]_]+\\)" 1))
+    ("Variables/classes" "\\_<\\([[:alnum:]_]+\\)[ \t]*=[ \t]*(" 1)
+    ("Variables/classes" "\\_<define=\\([[:alnum:]_]+\\)" 1)
+    ("Variables/classes" "\\_<DefineClass\\>[ \t]+\\([[:alnum:]_]+\\)" 1))
   "`imenu-generic-expression' for CFEngine mode.")
 
 (defun cfengine2-outline-level ()
@@ -338,7 +340,7 @@ Intended as the value of `indent-line-function'."
 Treats body/bundle blocks as defuns."
   (unless (<= (current-column) (current-indentation))
     (end-of-line))
-  (if (re-search-backward (concat "^[ \t]*" cfengine3-defuns-regex "\\>") nil t)
+  (if (re-search-backward (concat "^[ \t]*" cfengine3-defuns-regex "\\_>") nil t)
       (beginning-of-line)
     (goto-char (point-min)))
   t)
@@ -347,7 +349,7 @@ Treats body/bundle blocks as defuns."
   "`end-of-defun' function for Cfengine 3 mode.
 Treats body/bundle blocks as defuns."
   (end-of-line)
-  (if (re-search-forward (concat "^[ \t]*" cfengine3-defuns-regex "\\>") nil t)
+  (if (re-search-forward (concat "^[ \t]*" cfengine3-defuns-regex "\\_>") nil t)
       (beginning-of-line)
     (goto-char (point-max)))
   t)
@@ -366,7 +368,7 @@ Intended as the value of `indent-line-function'."
 
       (cond
        ;; Body/bundle blocks start at 0.
-       ((looking-at (concat cfengine3-defuns-regex "\\>"))
+       ((looking-at (concat cfengine3-defuns-regex "\\_>"))
         (indent-line-to 0))
        ;; Categories are indented one step.
        ((looking-at (concat cfengine3-category-regex "[ \t]*\\(#.*\\)*$"))
@@ -583,7 +585,7 @@ on the buffer contents"
     (save-restriction
       (goto-char (point-min))
       (while (not (or (eobp) v3))
-        (setq v3 (looking-at (concat cfengine3-defuns-regex "\\>")))
+        (setq v3 (looking-at (concat cfengine3-defuns-regex "\\_>")))
         (forward-line)))
     (if v3 (cfengine3-mode) (cfengine2-mode))))
 
diff --git a/lisp/progmodes/compile.el b/lisp/progmodes/compile.el
index 9e9e2f0b090..d6f136ec92d 100644
--- a/lisp/progmodes/compile.el
+++ b/lisp/progmodes/compile.el
@@ -1814,6 +1814,7 @@ Returns the compilation buffer created."
     (define-key map [follow-link] 'mouse-face)
     (define-key map "\C-c\C-c" 'compile-goto-error)
     (define-key map "\C-m" 'compile-goto-error)
+    (define-key map "\C-o" 'compilation-display-error)
     (define-key map "\C-c\C-k" 'kill-compilation)
     (define-key map "\M-n" 'compilation-next-error)
     (define-key map "\M-p" 'compilation-previous-error)
@@ -1858,6 +1859,7 @@ Returns the compilation buffer created."
     (define-key map [follow-link] 'mouse-face)
     (define-key map "\C-c\C-c" 'compile-goto-error)
     (define-key map "\C-m" 'compile-goto-error)
+    (define-key map "\C-o" 'compilation-display-error)
     (define-key map "\C-c\C-k" 'kill-compilation)
     (define-key map "\M-n" 'compilation-next-error)
     (define-key map "\M-p" 'compilation-previous-error)
@@ -2299,6 +2301,12 @@ Prefix arg N says how many files to move backwards (or forwards, if negative)."
   (interactive "p")
   (compilation-next-file (- n)))
 
+(defun compilation-display-error ()
+  "Display the source for current error in another window."
+  (interactive)
+  (setq compilation-current-error (point))
+  (next-error-no-select 0))
+
 (defun kill-compilation ()
   "Kill the process made by the \\[compile] or \\[grep] commands."
   (interactive)
@@ -2374,10 +2382,12 @@ This is the value of `next-error-function' in Compilation buffers."
                  ;;            (setq timestamp compilation-buffer-modtime)))
                  )
       (with-current-buffer
-          (compilation-find-file
-           marker
-           (caar (compilation--loc->file-struct loc))
-           (cadr (car (compilation--loc->file-struct loc))))
+          (apply #'compilation-find-file
+                 marker
+                 (caar (compilation--loc->file-struct loc))
+                 (cadr (car (compilation--loc->file-struct loc)))
+                 (compilation--file-struct->formats
+                  (compilation--loc->file-struct loc)))
         (let ((screen-columns
                ;; Obey the compilation-error-screen-columns of the target
                ;; buffer if its major mode set it buffer-locally.
diff --git a/lisp/progmodes/cperl-mode.el b/lisp/progmodes/cperl-mode.el
index e8678fe6281..910e7c49d2a 100644
--- a/lisp/progmodes/cperl-mode.el
+++ b/lisp/progmodes/cperl-mode.el
@@ -565,6 +565,7 @@ If nil, the value of `cperl-indent-level' will be used."
   "*Non-nil means that the _ (underline) should be treated as word char."
   :type 'boolean
   :group 'cperl)
+(make-obsolete-variable 'cperl-under-as-char 'superword-mode "24.4")
 
 (defcustom cperl-extra-perl-args ""
   "*Extra arguments to use when starting Perl.
@@ -1905,7 +1906,7 @@ or as help on variables `cperl-tips', `cperl-problems',
   (and (boundp 'msb-menu-cond)
        (not cperl-msb-fixed)
        (cperl-msb-fix))
-  (if (featurep 'easymenu)
+  (if (fboundp 'easy-menu-add)
       (easy-menu-add cperl-menu))       ; A NOP in Emacs.
   (run-mode-hooks 'cperl-mode-hook)
   (if cperl-hook-after-change
@@ -6529,6 +6530,9 @@ side-effect of memorizing only.  Examples in `cperl-style-examples'."
   (let ((perl-dbg-flags (concat cperl-extra-perl-args " -wc")))
     (eval '(mode-compile))))            ; Avoid a warning
 
+(declare-function Info-find-node "info"
+                  (filename nodename &optional no-going-back))
+
 (defun cperl-info-buffer (type)
   ;; Returns buffer with documentation.  Creates if missing.
   ;; If TYPE, this vars buffer.
@@ -6667,10 +6671,13 @@ Customized by setting variables `cperl-shrink-wrap-info-frame',
   (buffer-substring
    (match-beginning 1) (match-end 1)))
 
+(declare-function imenu-choose-buffer-index "imenu" (&optional prompt alist))
+
 (defun cperl-imenu-on-info ()
   "Shows imenu for Perl Info Buffer.
 Opens Perl Info buffer if needed."
   (interactive)
+  (require 'imenu)
   (let* ((buffer (current-buffer))
          imenu-create-index-function
          imenu-prev-index-position-function
@@ -7130,6 +7137,10 @@ Use as
 (defvar cperl-hierarchy '(() ())
   "Global hierarchy of classes.")
 
+;; Follows call to (autoloaded) visit-tags-table.
+(declare-function file-of-tag "etags" (&optional relative))
+(declare-function etags-snarf-tag "etags" (&optional use-explicit))
+
 (defun cperl-tags-hier-fill ()
   ;; Suppose we are in a tag table cooked by cperl.
   (goto-char 1)
@@ -7173,6 +7184,7 @@ Use as
       (end-of-line))))
 
 (declare-function x-popup-menu "menu.c" (position menu))
+(declare-function etags-goto-tag-location "etags" (tag-info))
 
 (defun cperl-tags-hier-init (&optional update)
   "Show hierarchical menu of classes and methods.
@@ -8516,6 +8528,8 @@ the appropriate statement modifier."
     ;;(error "Not at `if', `unless', `while', `until', `for' or `foreach'")
     (cperl-invert-if-unless-modifiers)))
 
+(declare-function Man-getpage-in-background "man" (topic))
+
 ;;; By Anthony Foiani <afoiani@uswest.com>
 ;;; Getting help on modules in C-h f ?
 ;;; This is a modified version of `man'.
diff --git a/lisp/progmodes/cpp.el b/lisp/progmodes/cpp.el
index 674d98b8dc3..d332d8bff31 100644
--- a/lisp/progmodes/cpp.el
+++ b/lisp/progmodes/cpp.el
@@ -136,13 +136,18 @@ Each entry is a list with the following elements:
     ("true" . t)
     ("both" . both)))
 
+;; FIXME Gets clobbered by cpp-choose-face, so why is even it a defcustom?
 (defcustom cpp-face-default-list nil
   "Alist of faces you can choose from for cpp conditionals.
 Each element has the form (STRING . FACE), where STRING
 serves as a name (for `cpp-highlight-buffer' only)
 and FACE is either a face (a symbol)
 or a cons cell (background-color . COLOR)."
-  :type '(repeat (cons string (choice face (cons (const background-color) string))))
+  :type '(alist :key-type (string :tag "Name")
+                :value-type (choice face
+                                    (const invisible)
+                                    (cons (const background-color)
+                                          (string :tag "Color"))))
   :group 'cpp)
 
 (defcustom cpp-face-light-name-list
diff --git a/lisp/progmodes/f90.el b/lisp/progmodes/f90.el
index dba1d6a2f9b..9bde2900a67 100644
--- a/lisp/progmodes/f90.el
+++ b/lisp/progmodes/f90.el
@@ -247,15 +247,36 @@
 
 (defcustom f90-smart-end 'blink
   "Qualification of END statements according to the matching block start.
-For example, the END that closes an IF block is changed to END
-IF.  If the block has a label, this is added as well.  Allowed
-values are 'blink, 'no-blink, and nil.  If nil, nothing is done.
-The other two settings have the same effect, but 'blink
+For example, change the END that closes an IF block to END IF.
+If the block has a label, add it as well (unless `f90-smart-end-names'
+says not to).  Allowed values are `blink', `no-blink', and nil.  If nil,
+nothing is done.  The other two settings have the same effect, but `blink'
 additionally blinks the cursor to the start of the block."
   :type  '(choice (const blink) (const no-blink) (const nil))
   :safe  (lambda (value) (memq value '(blink no-blink nil)))
   :group 'f90)
 
+;; Optional: program, module, type, function, subroutine
+;; Not optional: block data?, forall, if, select case/type, associate, do,
+;;   where, interface, critical
+;; No labels: enum
+(defcustom f90-smart-end-names t
+  "Whether completion of END statements should insert optional block names.
+For example, when closing a \"PROGRAM PROGNAME\" block, \"PROGNAME\" is
+optional in the \"END PROGRAM\" statement.  The same is true for modules,
+functions, subroutines, and types.  Some people prefer to omit the name
+from the END statement, since it makes it easier to change the name.
+
+This does not apply to named DO, IF, etc. blocks.  If such blocks
+start with a label, they must end with one.
+
+If an end statement has a name that does not match the start, it is always
+corrected, regardless of the value of this variable."
+  :type 'boolean
+  :safe 'booleanp
+  :group 'f90
+  :version "24.4")
+
 (defcustom f90-break-delimiters "[-+\\*/><=,% \t]"
   "Regexp matching delimiter characters at which lines may be broken.
 There are some common two-character tokens where one or more of
@@ -298,55 +319,61 @@ The options are 'downcase-word, 'upcase-word, 'capitalize-word and nil."
 ;; User options end here.
 
 (defconst f90-keywords-re
-  (regexp-opt '("allocatable" "allocate" "assign" "assignment" "backspace"
-                "block" "call" "case" "character" "close" "common" "complex"
-                "contains" "continue" "cycle" "data" "deallocate"
-                "dimension" "do" "double" "else" "elseif" "elsewhere" "end"
-                "enddo" "endfile" "endif" "entry" "equivalence" "exit"
-                "external" "forall" "format" "function" "goto" "if"
-                "implicit" "include" "inquire" "integer" "intent"
-                "interface" "intrinsic" "logical" "module" "namelist" "none"
-                "nullify" "only" "open" "operator" "optional" "parameter"
-                "pause" "pointer" "precision" "print" "private" "procedure"
-                "program" "public" "read" "real" "recursive" "result" "return"
-                "rewind" "save" "select" "sequence" "stop" "subroutine"
-                "target" "then" "type" "use" "where" "while" "write"
-                ;; F95 keywords.
-                "elemental" "pure"
-                ;; F2003
-                "abstract" "associate" "asynchronous" "bind" "class"
-                "deferred" "enum" "enumerator" "extends" "extends_type_of"
-                "final" "generic" "import" "non_intrinsic" "non_overridable"
-                "nopass" "pass" "protected" "same_type_as" "value" "volatile"
-                ;; F2008.
-                "contiguous" "submodule" "concurrent" "codimension"
-                "sync all" "sync memory" "critical" "image_index"
-                ) 'words)
+  (concat
+   "\\_<"
+   (regexp-opt '("allocatable" "allocate" "assign" "assignment" "backspace"
+                 "block" "call" "case" "character" "close" "common" "complex"
+                 "contains" "continue" "cycle" "data" "deallocate"
+                 "dimension" "do" "double" "else" "elseif" "elsewhere" "end"
+                 "enddo" "endfile" "endif" "entry" "equivalence" "exit"
+                 "external" "forall" "format" "function" "goto" "if"
+                 "implicit" "include" "inquire" "integer" "intent"
+                 "interface" "intrinsic" "logical" "module" "namelist" "none"
+                 "nullify" "only" "open" "operator" "optional" "parameter"
+                 "pause" "pointer" "precision" "print" "private" "procedure"
+                 "program" "public" "read" "real" "recursive" "result" "return"
+                 "rewind" "save" "select" "sequence" "stop" "subroutine"
+                 "target" "then" "type" "use" "where" "while" "write"
+                 ;; F95 keywords.
+                 "elemental" "pure"
+                 ;; F2003
+                 "abstract" "associate" "asynchronous" "bind" "class"
+                 "deferred" "enum" "enumerator" "extends" "extends_type_of"
+                 "final" "generic" "import" "non_intrinsic" "non_overridable"
+                 "nopass" "pass" "protected" "same_type_as" "value" "volatile"
+                 ;; F2008.
+                 "contiguous" "submodule" "concurrent" "codimension"
+                 "sync all" "sync memory" "critical" "image_index"
+                 ))
+   "\\_>")
   "Regexp used by the function `f90-change-keywords'.")
 
 (defconst f90-keywords-level-3-re
-  (regexp-opt
-   '("allocatable" "allocate" "assign" "assignment" "backspace"
-     "close" "deallocate" "dimension" "endfile" "entry" "equivalence"
-     "external" "inquire" "intent" "intrinsic" "nullify" "only" "open"
-     ;; FIXME operator and assignment should be F2003 procedures?
-     "operator" "optional" "parameter" "pause" "pointer" "print" "private"
-     "public" "read" "recursive" "result" "rewind" "save" "select"
-     "sequence" "target" "write"
-     ;; F95 keywords.
-     "elemental" "pure"
-     ;; F2003. asynchronous separate.
-     "abstract" "deferred" "import" "final" "non_intrinsic" "non_overridable"
-     "nopass" "pass" "protected" "value" "volatile"
-     ;; F2008.
-     ;; "concurrent" is only in the sense of "do [,] concurrent", but given
-     ;; the [,] it's simpler to just do every instance (cf "do while").
-     "contiguous" "concurrent" "codimension" "sync all" "sync memory"
-     ) 'words)
+  (concat
+   "\\_<"
+   (regexp-opt
+    '("allocatable" "allocate" "assign" "assignment" "backspace"
+      "close" "deallocate" "dimension" "endfile" "entry" "equivalence"
+      "external" "inquire" "intent" "intrinsic" "nullify" "only" "open"
+      ;; FIXME operator and assignment should be F2003 procedures?
+      "operator" "optional" "parameter" "pause" "pointer" "print" "private"
+      "public" "read" "recursive" "result" "rewind" "save" "select"
+      "sequence" "target" "write"
+      ;; F95 keywords.
+      "elemental" "pure"
+      ;; F2003. asynchronous separate.
+      "abstract" "deferred" "import" "final" "non_intrinsic" "non_overridable"
+      "nopass" "pass" "protected" "value" "volatile"
+      ;; F2008.
+      ;; "concurrent" is only in the sense of "do [,] concurrent", but given
+      ;; the [,] it's simpler to just do every instance (cf "do while").
+      "contiguous" "concurrent" "codimension" "sync all" "sync memory"
+      ))
+   "\\_>")
   "Keyword-regexp for font-lock level >= 3.")
 
 (defconst f90-procedures-re
-  (concat "\\<"
+  (concat "\\_<"
           (regexp-opt
            '("abs" "achar" "acos" "adjustl" "adjustr" "aimag" "aint"
              "all" "allocated" "anint" "any" "asin" "associated"
@@ -407,61 +434,67 @@ The options are 'downcase-word, 'upcase-word, 'capitalize-word and nil."
   "Regexp matching intrinsic operators.")
 
 (defconst f90-hpf-keywords-re
-  (regexp-opt
-   ;; Intrinsic procedures.
-   '("all_prefix" "all_scatter" "all_suffix" "any_prefix"
-     "any_scatter" "any_suffix" "copy_prefix" "copy_scatter"
-     "copy_suffix" "count_prefix" "count_scatter" "count_suffix"
-     "grade_down" "grade_up"
-     "hpf_alignment" "hpf_distribution" "hpf_template" "iall" "iall_prefix"
-     "iall_scatter" "iall_suffix" "iany" "iany_prefix" "iany_scatter"
-     "iany_suffix" "ilen" "iparity" "iparity_prefix"
-     "iparity_scatter" "iparity_suffix" "leadz" "maxval_prefix"
-     "maxval_scatter" "maxval_suffix" "minval_prefix" "minval_scatter"
-     "minval_suffix" "number_of_processors" "parity"
-     "parity_prefix" "parity_scatter" "parity_suffix" "popcnt" "poppar"
-     "processors_shape" "product_prefix" "product_scatter"
-     "product_suffix" "sum_prefix" "sum_scatter" "sum_suffix"
-     ;; Directives.
-     "align" "distribute" "dynamic" "independent" "inherit" "processors"
-     "realign" "redistribute" "template"
-     ;; Keywords.
-     "block" "cyclic" "extrinsic" "new" "onto" "pure" "with") 'words)
+  (concat
+   "\\_<"
+   (regexp-opt
+    ;; Intrinsic procedures.
+    '("all_prefix" "all_scatter" "all_suffix" "any_prefix"
+      "any_scatter" "any_suffix" "copy_prefix" "copy_scatter"
+      "copy_suffix" "count_prefix" "count_scatter" "count_suffix"
+      "grade_down" "grade_up"
+      "hpf_alignment" "hpf_distribution" "hpf_template" "iall" "iall_prefix"
+      "iall_scatter" "iall_suffix" "iany" "iany_prefix" "iany_scatter"
+      "iany_suffix" "ilen" "iparity" "iparity_prefix"
+      "iparity_scatter" "iparity_suffix" "leadz" "maxval_prefix"
+      "maxval_scatter" "maxval_suffix" "minval_prefix" "minval_scatter"
+      "minval_suffix" "number_of_processors" "parity"
+      "parity_prefix" "parity_scatter" "parity_suffix" "popcnt" "poppar"
+      "processors_shape" "product_prefix" "product_scatter"
+      "product_suffix" "sum_prefix" "sum_scatter" "sum_suffix"
+      ;; Directives.
+      "align" "distribute" "dynamic" "independent" "inherit" "processors"
+      "realign" "redistribute" "template"
+      ;; Keywords.
+      "block" "cyclic" "extrinsic" "new" "onto" "pure" "with"))
+   "\\_>")
   "Regexp for all HPF keywords, procedures and directives.")
 
 (defconst f90-constants-re
-  (regexp-opt '( ;; F2003 iso_fortran_env constants.
-                "iso_fortran_env"
-                "input_unit" "output_unit" "error_unit"
-                "iostat_end" "iostat_eor"
-                "numeric_storage_size" "character_storage_size"
-                "file_storage_size"
-                ;; F2003 iso_c_binding constants.
-                "iso_c_binding"
-                "c_int" "c_short" "c_long" "c_long_long" "c_signed_char"
-                "c_size_t"
-                "c_int8_t" "c_int16_t" "c_int32_t" "c_int64_t"
-                "c_int_least8_t" "c_int_least16_t" "c_int_least32_t"
-                "c_int_least64_t"
-                "c_int_fast8_t" "c_int_fast16_t" "c_int_fast32_t"
-                "c_int_fast64_t"
-                "c_intmax_t" "c_intptr_t"
-                "c_float" "c_double" "c_long_double"
-                "c_float_complex" "c_double_complex" "c_long_double_complex"
-                "c_bool" "c_char"
-                "c_null_char" "c_alert" "c_backspace" "c_form_feed"
-                "c_new_line" "c_carriage_return" "c_horizontal_tab"
-                "c_vertical_tab"
-                "c_ptr" "c_funptr" "c_null_ptr" "c_null_funptr"
-                "ieee_exceptions"
-                "ieee_arithmetic"
-                "ieee_features"
-                ;; F2008 iso_fortran_env constants.
-                "character_kinds" "int8" "int16" "int32" "int64"
-                "integer_kinds" "iostat_inquire_internal_unit"
-                "logical_kinds" "real_kinds" "real32" "real64" "real128"
-                "lock_type" "atomic_int_kind" "atomic_logical_kind"
-                ) 'words)
+  (concat
+   "\\_<"
+   (regexp-opt '( ;; F2003 iso_fortran_env constants.
+                 "iso_fortran_env"
+                 "input_unit" "output_unit" "error_unit"
+                 "iostat_end" "iostat_eor"
+                 "numeric_storage_size" "character_storage_size"
+                 "file_storage_size"
+                 ;; F2003 iso_c_binding constants.
+                 "iso_c_binding"
+                 "c_int" "c_short" "c_long" "c_long_long" "c_signed_char"
+                 "c_size_t"
+                 "c_int8_t" "c_int16_t" "c_int32_t" "c_int64_t"
+                 "c_int_least8_t" "c_int_least16_t" "c_int_least32_t"
+                 "c_int_least64_t"
+                 "c_int_fast8_t" "c_int_fast16_t" "c_int_fast32_t"
+                 "c_int_fast64_t"
+                 "c_intmax_t" "c_intptr_t"
+                 "c_float" "c_double" "c_long_double"
+                 "c_float_complex" "c_double_complex" "c_long_double_complex"
+                 "c_bool" "c_char"
+                 "c_null_char" "c_alert" "c_backspace" "c_form_feed"
+                 "c_new_line" "c_carriage_return" "c_horizontal_tab"
+                 "c_vertical_tab"
+                 "c_ptr" "c_funptr" "c_null_ptr" "c_null_funptr"
+                 "ieee_exceptions"
+                 "ieee_arithmetic"
+                 "ieee_features"
+                 ;; F2008 iso_fortran_env constants.
+                 "character_kinds" "int8" "int16" "int32" "int64"
+                 "integer_kinds" "iostat_inquire_internal_unit"
+                 "logical_kinds" "real_kinds" "real32" "real64" "real128"
+                 "lock_type" "atomic_int_kind" "atomic_logical_kind"
+                 ))
+   "\\_>")
   "Regexp for Fortran intrinsic constants.")
 
 ;; cf f90-looking-at-type-like.
@@ -470,16 +503,16 @@ The options are 'downcase-word, 'upcase-word, 'capitalize-word and nil."
 Set the match data so that subexpression 1,2 are the TYPE, and
 type-name parts, respectively."
   (let (found l)
-    (while (and (re-search-forward "\\<\\(\\(?:end[ \t]*\\)?type\\)\\>[ \t]*"
+    (while (and (re-search-forward "\\_<\\(\\(?:end[ \t]*\\)?type\\)\\_>[ \t]*"
                                    limit t)
                 (not (setq found
                            (progn
                              (setq l (match-data))
-                             (unless (looking-at "\\(is\\>\\|(\\)")
-                               (when (if (looking-at "\\(\\sw+\\)")
+                             (unless (looking-at "\\(is\\_>\\|(\\)")
+                               (when (if (looking-at "\\(\\(?:\\sw\\|\\s_\\)+\\)")
                                          (goto-char (match-end 0))
                                        (re-search-forward
-                                        "[ \t]*::[ \t]*\\(\\sw+\\)"
+                                        "[ \t]*::[ \t]*\\(\\(?:\\sw\\|\\s_\\)+\\)"
                                         (line-end-position) t))
                                  ;; 0 is wrong, but we don't use it.
                                  (set-match-data
@@ -491,33 +524,33 @@ type-name parts, respectively."
 (defvar f90-font-lock-keywords-1
   (list
    ;; Special highlighting of "module procedure".
-   '("\\<\\(module[ \t]*procedure\\)\\>\\([^()\n]*::\\)?[ \t]*\\([^&!\n]*\\)"
+   '("\\_<\\(module[ \t]*procedure\\)\\_>\\([^()\n]*::\\)?[ \t]*\\([^&!\n]*\\)"
      (1 font-lock-keyword-face) (3 font-lock-function-name-face nil t))
    ;; Highlight definition of derived type.
-;;;    '("\\<\\(\\(?:end[ \t]*\\)?type\\)\\>\\([^()\n]*::\\)?[ \t]*\\(\\sw+\\)"
+;;;    '("\\_<\\(\\(?:end[ \t]*\\)?type\\)\\_>\\([^()\n]*::\\)?[ \t]*\\(\\(?:\\sw\\|\\s_\\)+\\)"
 ;;;      (1 font-lock-keyword-face) (3 font-lock-function-name-face))
    '(f90-typedef-matcher
      (1 font-lock-keyword-face) (2 font-lock-function-name-face))
    ;; F2003.  Prevent operators being highlighted as functions.
-   '("\\<\\(\\(?:end[ \t]*\\)?interface[ \t]*\\(?:assignment\\|operator\\|\
+   '("\\_<\\(\\(?:end[ \t]*\\)?interface[ \t]*\\(?:assignment\\|operator\\|\
 read\\|write\\)\\)[ \t]*(" (1 font-lock-keyword-face t))
    ;; Other functions and declarations.  Named interfaces = F2003.
    ;; F2008: end submodule submodule_name.
-   '("\\<\\(\\(?:end[ \t]*\\)?\\(program\\|\\(?:sub\\)?module\\|\
+   '("\\_<\\(\\(?:end[ \t]*\\)?\\(program\\|\\(?:sub\\)?module\\|\
 function\\|associate\\|subroutine\\|interface\\)\\|use\\|call\\)\
-\\>[ \t]*\\(\\sw+\\)?"
+\\_>[ \t]*\\(\\(?:\\sw\\|\\s_\\)+\\)?"
      (1 font-lock-keyword-face) (3 font-lock-function-name-face nil t))
    ;; F2008: submodule (parent_name) submodule_name.
-   '("\\<\\(submodule\\)\\>[ \t]*([^)\n]+)[ \t]*\\(\\sw+\\)?"
+   '("\\_<\\(submodule\\)\\_>[ \t]*([^)\n]+)[ \t]*\\(\\(?:\\sw\\|\\s_\\)+\\)?"
      (1 font-lock-keyword-face) (2 font-lock-function-name-face nil t))
    ;; F2003.
-   '("\\<\\(use\\)[ \t]*,[ \t]*\\(\\(?:non_\\)?intrinsic\\)[ \t]*::[ \t]*\
-\\(\\sw+\\)"
+   '("\\_<\\(use\\)[ \t]*,[ \t]*\\(\\(?:non_\\)?intrinsic\\)[ \t]*::[ \t]*\
+\\(\\(?:\\sw\\|\\s_\\)+\\)"
      (1 font-lock-keyword-face) (2 font-lock-keyword-face)
      (3 font-lock-function-name-face))
-   "\\<\\(\\(end[ \t]*\\)?block[ \t]*data\\|contains\\)\\>"
+   "\\_<\\(\\(end[ \t]*\\)?block[ \t]*data\\|contains\\)\\_>"
    ;; "abstract interface" is F2003.
-   '("\\<abstract[ \t]*interface\\>" (0 font-lock-keyword-face t)))
+   '("\\_<abstract[ \t]*interface\\_>" (0 font-lock-keyword-face t)))
   "This does fairly subdued highlighting of comments and function calls.")
 
 ;; NB not explicitly handling this, yet it seems to work.
@@ -529,7 +562,7 @@ and variable-name parts, respectively."
   ;; Matcher functions must return nil only when there are no more
   ;; matches within the search range.
   (let (found l)
-    (while (and (re-search-forward "\\<\\(type\\|class\\)[ \t]*(" limit t)
+    (while (and (re-search-forward "\\_<\\(type\\|class\\)[ \t]*(" limit t)
                 (not
                  (setq found
                        (condition-case nil
@@ -544,7 +577,7 @@ and variable-name parts, respectively."
                              (when
                                  (re-search-forward
                                   ;; type (foo) bar, qux
-                                  (if (looking-at "\\sw+")
+                                  (if (looking-at "\\(?:\\sw\\|\\s_\\)+")
                                       "\\([^&!\n]+\\)"
                                     ;; type (foo), stuff :: bar, qux
                                     "::[ \t]*\\([^&!\n]+\\)")
@@ -587,53 +620,53 @@ enumerator\\|generic\\|procedure\\|logical\\|double[ \t]*precision\\)\
     ;; integer( kind=1 ) function foo()
     ;; thanks to the happy accident described above.
     ;; Not anchored, so don't need to worry about "pure" etc.
-    '("\\<\\(\\(real\\|integer\\|c\\(haracter\\|omplex\\)\\|\
+    '("\\_<\\(\\(real\\|integer\\|c\\(haracter\\|omplex\\)\\|\
 logical\\|double[ \t]*precision\\|\
-\\(?:type\\|class\\)[ \t]*([ \t]*\\sw+[ \t]*)\\)[ \t]*\\)\
-\\(function\\)\\>[ \t]*\\(\\sw+\\)[ \t]*\\(([^&!\n]*)\\)"
+\\(?:type\\|class\\)[ \t]*([ \t]*\\(?:\\sw\\|\\s_\\)+[ \t]*)\\)[ \t]*\\)\
+\\(function\\)\\_>[ \t]*\\(\\(?:\\sw\\|\\s_\\)+\\)[ \t]*\\(([^&!\n]*)\\)"
       (1 font-lock-type-face t) (4 font-lock-keyword-face t)
       (5 font-lock-function-name-face t) (6 'default t))
     ;; enum (F2003; must be followed by ", bind(C)").
-    '("\\<\\(enum\\)[ \t]*," (1 font-lock-keyword-face))
+    '("\\_<\\(enum\\)[ \t]*," (1 font-lock-keyword-face))
     ;; end do, enum (F2003), if, select, where, and forall constructs.
     ;; block, critical (F2008).
     ;; Note that "block data" may get somewhat mixed up with F2008 blocks,
     ;; but since the former is obsolete I'm not going to worry about it.
-    '("\\<\\(end[ \t]*\\(do\\|if\\|enum\\|select\\|forall\\|where\\|\
-block\\|critical\\)\\)\\>\
-\\([ \t]+\\(\\sw+\\)\\)?"
+    '("\\_<\\(end[ \t]*\\(do\\|if\\|enum\\|select\\|forall\\|where\\|\
+block\\|critical\\)\\)\\_>\
+\\([ \t]+\\(\\(?:\\sw\\|\\s_\\)+\\)\\)?"
       (1 font-lock-keyword-face) (3 font-lock-constant-face nil t))
-    '("^[ \t0-9]*\\(\\(\\sw+\\)[ \t]*:[ \t]*\\)?\\(\\(if\\|\
+    '("^[ \t0-9]*\\(\\(\\(?:\\sw\\|\\s_\\)+\\)[ \t]*:[ \t]*\\)?\\(\\(if\\|\
 do\\([ \t]*while\\)?\\|select[ \t]*\\(?:case\\|type\\)\\|where\\|\
-forall\\|block\\|critical\\)\\)\\>"
+forall\\|block\\|critical\\)\\)\\_>"
       (2 font-lock-constant-face nil t) (3 font-lock-keyword-face))
     ;; Implicit declaration.
-    '("\\<\\(implicit\\)[ \t]*\\(real\\|integer\\|c\\(haracter\\|omplex\\)\
+    '("\\_<\\(implicit\\)[ \t]*\\(real\\|integer\\|c\\(haracter\\|omplex\\)\
 \\|enumerator\\|procedure\\|\
-logical\\|double[ \t]*precision\\|type[ \t]*(\\sw+)\\|none\\)[ \t]*"
+logical\\|double[ \t]*precision\\|type[ \t]*(\\(?:\\sw\\|\\s_\\)+)\\|none\\)[ \t]*"
       (1 font-lock-keyword-face) (2 font-lock-type-face))
-    '("\\<\\(namelist\\|common\\)[ \t]*\/\\(\\sw+\\)?\/"
+    '("\\_<\\(namelist\\|common\\)[ \t]*\/\\(\\(?:\\sw\\|\\s_\\)+\\)?\/"
       (1 font-lock-keyword-face) (2 font-lock-constant-face nil t))
-    "\\<else\\([ \t]*if\\|where\\)?\\>"
+    "\\_<else\\([ \t]*if\\|where\\)?\\_>"
     '("\\(&\\)[ \t]*\\(!\\|$\\)"  (1 font-lock-keyword-face))
-    "\\<\\(then\\|continue\\|format\\|include\\|stop\\|return\\)\\>"
-    '("\\<\\(exit\\|cycle\\)[ \t]*\\(\\sw+\\)?\\>"
+    "\\_<\\(then\\|continue\\|format\\|include\\|stop\\|return\\)\\_>"
+    '("\\_<\\(exit\\|cycle\\)[ \t]*\\(\\(?:\\sw\\|\\s_\\)+\\)?\\_>"
       (1 font-lock-keyword-face) (2 font-lock-constant-face nil t))
-    '("\\<\\(case\\)[ \t]*\\(default\\|(\\)" . 1)
+    '("\\_<\\(case\\)[ \t]*\\(default\\|(\\)" . 1)
     ;; F2003 "class default".
-    '("\\<\\(class\\)[ \t]*default" . 1)
+    '("\\_<\\(class\\)[ \t]*default" . 1)
     ;; F2003 "type is" in a "select type" block.
-    '("\\<\\(\\(type\\|class\\)[ \t]*is\\)[ \t]*(" (1 font-lock-keyword-face t))
-    '("\\<\\(do\\|go[ \t]*to\\)\\>[ \t]*\\([0-9]+\\)"
+    '("\\_<\\(\\(type\\|class\\)[ \t]*is\\)[ \t]*(" (1 font-lock-keyword-face t))
+    '("\\_<\\(do\\|go[ \t]*to\\)\\_>[ \t]*\\([0-9]+\\)"
       (1 font-lock-keyword-face) (2 font-lock-constant-face))
     ;; Line numbers (lines whose first character after number is letter).
     '("^[ \t]*\\([0-9]+\\)[ \t]*[a-z]+" (1 font-lock-constant-face t))
     ;; Override eg for "#include".
-    '("^#[ \t]*\\w+" (0 font-lock-preprocessor-face t)
-      ("\\<defined\\>" nil nil (0 font-lock-preprocessor-face)))
+    '("^#[ \t]*\\(?:\\sw\\|\\s_\\)+" (0 font-lock-preprocessor-face t)
+      ("\\_<defined\\_>" nil nil (0 font-lock-preprocessor-face)))
     '("^#" ("\\(&&\\|||\\)" nil nil (0 font-lock-constant-face t)))
-    '("^#[ \t]*define[ \t]+\\(\\w+\\)(" (1 font-lock-function-name-face))
-    '("^#[ \t]*define[ \t]+\\(\\w+\\)" (1 font-lock-variable-name-face))
+    '("^#[ \t]*define[ \t]+\\(\\(?:\\sw\\|\\s_\\)+\\)(" (1 font-lock-function-name-face))
+    '("^#[ \t]*define[ \t]+\\(\\(?:\\sw\\|\\s_\\)+\\)" (1 font-lock-variable-name-face))
     '("^#[ \t]*include[ \t]+\\(<.+>\\)" (1 font-lock-string-face))))
   "Highlights declarations, do-loops and other constructs.")
 
@@ -645,9 +678,9 @@ logical\\|double[ \t]*precision\\|type[ \t]*(\\sw+)\\|none\\)[ \t]*"
            ;; FIXME why isn't this font-lock-builtin-face, which
            ;; otherwise we hardly use, as in fortran.el?
            (list f90-procedures-re '(1 font-lock-keyword-face keep))
-           "\\<real\\>"                 ; avoid overwriting real defs
+           "\\_<real\\_>"                 ; avoid overwriting real defs
            ;; As an attribute, but not as an optional argument.
-           '("\\<\\(asynchronous\\)[ \t]*[^=]" . 1)))
+           '("\\_<\\(asynchronous\\)[ \t]*[^=]" . 1)))
   "Highlights all F90 keywords and intrinsic procedures.")
 
 (defvar f90-font-lock-keywords-4
@@ -666,8 +699,7 @@ Can be overridden by the value of `font-lock-maximum-decoration'.")
   (let ((table (make-syntax-table)))
     (modify-syntax-entry ?\! "<"  table) ; begin comment
     (modify-syntax-entry ?\n ">"  table) ; end comment
-    ;; FIXME: This goes against the convention: it should be "_".
-    (modify-syntax-entry ?_  "w"  table) ; underscore in names
+    (modify-syntax-entry ?_  "_"  table) ; underscore in names
     (modify-syntax-entry ?\' "\"" table) ; string quote
     (modify-syntax-entry ?\" "\"" table) ; string quote
     ;; FIXME: We used to set ` to word syntax for the benefit of abbrevs, but
@@ -822,14 +854,14 @@ Can be overridden by the value of `font-lock-maximum-decoration'.")
 
 ;; Regexps for finding program structures.
 (defconst f90-blocks-re
-  (concat "\\(block[ \t]*data\\|"
+  (concat "\\(\\(?:block[ \t]*data\\|"
           (regexp-opt '("do" "if" "interface" "function" "module" "program"
                         "select" "subroutine" "type" "where" "forall"
                         ;; F2003.
                         "enum" "associate"
                         ;; F2008.
                         "submodule" "block" "critical"))
-          "\\)\\>")
+          "\\)\\_>\\)")
   "Regexp potentially indicating a \"block\" of F90 code.")
 
 (defconst f90-program-block-re
@@ -845,15 +877,15 @@ Can be overridden by the value of `font-lock-maximum-decoration'.")
 (defconst f90-end-if-re
   (concat "end[ \t]*"
           (regexp-opt '("if" "select" "where" "forall") 'paren)
-          "\\>")
+          "\\_>")
   "Regexp matching the end of an IF, SELECT, WHERE, FORALL block.")
 
 (defconst f90-end-type-re
-  "end[ \t]*\\(type\\|enum\\|interface\\|block[ \t]*data\\)\\>"
+  "end[ \t]*\\(type\\|enum\\|interface\\|block[ \t]*data\\)\\_>"
   "Regexp matching the end of a TYPE, ENUM, INTERFACE, BLOCK DATA section.")
 
 (defconst f90-end-associate-re
-  "end[ \t]*associate\\>"
+  "end[ \t]*associate\\_>"
   "Regexp matching the end of an ASSOCIATE block.")
 
 ;; This is for a TYPE block, not a variable of derived TYPE.
@@ -864,12 +896,12 @@ Can be overridden by the value of `font-lock-maximum-decoration'.")
   ;; type, stuff :: word
   ;; type, bind(c) :: word
   ;; NOT "type ("
-  "\\<\\(type\\)\\>\\(?:\\(?:[^()\n]*\\|\
-.*,[ \t]*bind[ \t]*([ \t]*c[ \t]*)[ \t]*\\)::\\)?[ \t]*\\(\\sw+\\)"
+  "\\_<\\(type\\)\\_>\\(?:\\(?:[^()\n]*\\|\
+.*,[ \t]*bind[ \t]*([ \t]*c[ \t]*)[ \t]*\\)::\\)?[ \t]*\\(\\(?:\\sw\\|\\s_\\)+\\)"
   "Regexp matching the definition of a derived type.")
 
 (defconst f90-typeis-re
-  "\\<\\(class\\|type\\)[ \t]*is[ \t]*("
+  "\\_<\\(class\\|type\\)[ \t]*is[ \t]*("
   "Regexp matching a CLASS/TYPE IS statement.")
 
 (defconst f90-no-break-re
@@ -888,12 +920,12 @@ allowed.  This minor issue currently only affects \"(/\" and \"/)\".")
 
 ;; Hideshow support.
 (defconst f90-end-block-re
-  (concat "^[ \t0-9]*\\<end[ \t]*"
+  (concat "^[ \t0-9]*\\_<end[ \t]*"
           (regexp-opt '("do" "if" "forall" "function" "interface"
                         "module" "program" "select" "subroutine"
                         "type" "where" "enum" "associate" "submodule"
                         "block" "critical") t)
-          "\\>")
+          "\\_>")
   "Regexp matching the end of an F90 \"block\", from the line start.
 Used in the F90 entry in `hs-special-modes-alist'.")
 
@@ -903,11 +935,11 @@ Used in the F90 entry in `hs-special-modes-alist'.")
   (concat
    "^[ \t0-9]*"                         ; statement number
    "\\(\\("
-   "\\(\\sw+[ \t]*:[ \t]*\\)?"          ; structure label
+   "\\(\\(?:\\sw\\|\\s_\\)+[ \t]*:[ \t]*\\)?"          ; structure label
    "\\(do\\|select[ \t]*\\(case\\|type\\)\\|"
    ;; See comments in fortran-start-block-re for the problems of IF.
    "if[ \t]*(\\(.*\\|"
-   ".*\n\\([^if]*\\([^i].\\|.[^f]\\|.\\>\\)\\)\\)\\<then\\|"
+   ".*\n\\([^if]*\\([^i].\\|.[^f]\\|.\\_>\\)\\)\\)\\_<then\\|"
    ;; Distinguish WHERE block from isolated WHERE.
    "\\(where\\|forall\\)[ \t]*(.*)[ \t]*\\(!\\|$\\)\\)\\)"
    "\\|"
@@ -917,7 +949,7 @@ Used in the F90 entry in `hs-special-modes-alist'.")
    "type[ \t,]\\("
    "[^i(!\n\"\& \t]\\|"                 ; not-i(
    "i[^s!\n\"\& \t]\\|"                 ; i not-s
-   "is\\sw\\)\\|"
+   "is\\(?:\\sw\\|\\s_\\)\\)\\|"
    ;; "abstract interface" is F2003; "submodule" is F2008.
    "program\\|\\(?:abstract[ \t]*\\)?interface\\|\\(?:sub\\)?module\\|"
    ;; "enum", but not "enumerator".
@@ -945,10 +977,10 @@ Set subexpression 1 in the match-data to the name of the type."
                 (not (setq found
                            (save-excursion
                              (goto-char (match-end 0))
-                             (unless (looking-at "\\(is\\>\\|(\\)")
-                               (or (looking-at "\\(\\sw+\\)")
+                             (unless (looking-at "\\(is\\_>\\|(\\)")
+                               (or (looking-at "\\(\\(?:\\sw\\|\\s_\\)+\\)")
                                    (re-search-forward
-                                    "[ \t]*::[ \t]*\\(\\sw+\\)"
+                                    "[ \t]*::[ \t]*\\(\\(?:\\sw\\|\\s_\\)+\\)"
                                     (line-end-position) t))))))))
     found))
 
@@ -957,36 +989,35 @@ Set subexpression 1 in the match-data to the name of the type."
         (not-n "[^n!\n\"\& \t]") (not-d "[^d!\n\"\& \t]")
         ;; (not-ib "[^i(!\n\"\& \t]") (not-s "[^s!\n\"\& \t]")
         )
-    (list
-     '(nil "^[ \t0-9]*program[ \t]+\\(\\sw+\\)" 1)
-     '("Submodules" "^[ \t0-9]*submodule[ \t]*([^)\n]+)[ \t]*\
-\\(\\sw+\\)[ \t]*\\(!\\|$\\)" 1)
-     '("Modules" "^[ \t0-9]*module[ \t]+\\(\\sw+\\)[ \t]*\\(!\\|$\\)" 1)
-     (list "Types" 'f90-imenu-type-matcher 1)
-     ;; Does not handle: "type[, stuff] :: foo".
-;;;      (format "^[ \t0-9]*type[ \t]+\\(\\(%s\\|i%s\\|is\\sw\\)\\sw*\\)"
-;;;              not-ib not-s)
-;;;      1)
-     ;; Can't get the subexpression numbers to match in the two branches.
-;;;      (format "^[ \t0-9]*type\\([ \t]*,.*\\(::\\)[ \t]*\\(\\sw+\\)\\|[ \t]+\\(\\(%s\\|i%s\\|is\\sw\\)\\sw*\\)\\)" not-ib not-s)
-;;;      3)
-     (list
-      "Procedures"
-      (concat
-       "^[ \t0-9]*"
-       "\\("
-       ;; At least three non-space characters before function/subroutine.
-       ;; Check that the last three non-space characters do not spell E N D.
-       "[^!\"\&\n]*\\("
-       not-e good-char good-char "\\|"
-       good-char not-n good-char "\\|"
-       good-char good-char not-d "\\)"
-       "\\|"
-       ;; Less than three non-space characters before function/subroutine.
-       good-char "?" good-char "?"
-       "\\)"
-       "[ \t]*\\(function\\|subroutine\\)[ \t]+\\(\\sw+\\)")
-      4)))
+    `((nil "^[ \t0-9]*program[ \t]+\\(\\(?:\\sw\\|\\s_\\)+\\)" 1)
+      ("Submodules" "^[ \t0-9]*submodule[ \t]*([^)\n]+)[ \t]*\
+\\(\\(?:\\sw\\|\\s_\\)+\\)[ \t]*\\(!\\|$\\)" 1)
+      ("Modules" "^[ \t0-9]*module[ \t]+\\(\\(?:\\sw\\|\\s_\\)+\\)[ \t]*\\(!\\|$\\)" 1)
+      ("Types" f90-imenu-type-matcher 1)
+      ;; Does not handle: "type[, stuff] :: foo".
+      ;;(format "^[ \t0-9]*type[ \t]+\\(\\(%s\\|i%s\\|is\\(?:\\sw\\|\\s_\\)\\)\\(?:\\sw\\|\\s_\\)*\\)"
+      ;;        not-ib not-s)
+      ;;1)
+      ;; Can't get the subexpression numbers to match in the two branches.
+      ;; FIXME: Now with \(?N:..\) we can get the numbers to match!
+      ;;(format "^[ \t0-9]*type\\([ \t]*,.*\\(::\\)[ \t]*\\(\\(?:\\sw\\|\\s_\\)+\\)\\|[ \t]+\\(\\(%s\\|i%s\\|is\\(?:\\sw\\|\\s_\\)\\)\\(?:\\sw\\|\\s_\\)*\\)\\)" not-ib not-s)
+      ;;3)
+      ("Procedures"
+       ,(concat
+         "^[ \t0-9]*"
+         "\\("
+         ;; At least three non-space characters before function/subroutine.
+         ;; Check that the last three non-space characters do not spell E N D.
+         "[^!\"\&\n]*\\("
+         not-e good-char good-char "\\|"
+         good-char not-n good-char "\\|"
+         good-char good-char not-d "\\)"
+         "\\|"
+         ;; Less than three non-space characters before function/subroutine.
+         good-char "?" good-char "?"
+         "\\)"
+         "[ \t]*\\(function\\|subroutine\\)[ \t]+\\(\\(?:\\sw\\|\\s_\\)+\\)")
+       4)))
   "Value for `imenu-generic-expression' in F90 mode.")
 
 (defun f90-add-imenu-menu ()
@@ -1119,11 +1150,11 @@ Variables controlling indentation style and extra features:
   Automatic insertion of \& at beginning of continuation lines (default t).
 `f90-smart-end'
   From an END statement, check and fill the end using matching block start.
-  Allowed values are 'blink, 'no-blink, and nil, which determine
-  whether to blink the matching beginning (default 'blink).
+  Allowed values are `blink', `no-blink', and nil, which determine
+  whether to blink the matching beginning (default `blink').
 `f90-auto-keyword-case'
   Automatic change of case of keywords (default nil).
-  The possibilities are 'downcase-word, 'upcase-word, 'capitalize-word.
+  The possibilities are `downcase-word', `upcase-word', `capitalize-word'.
 `f90-leave-line-no'
   Do not left-justify line numbers (default nil).
 
@@ -1235,13 +1266,13 @@ whitespace, if any."
 (defsubst f90-looking-at-do ()
   "Return (\"do\" NAME) if a do statement starts after point.
 NAME is nil if the statement has no label."
-  (if (looking-at "\\(\\(\\sw+\\)[ \t]*:\\)?[ \t]*\\(do\\)\\>")
+  (if (looking-at "\\(\\(\\(?:\\sw\\|\\s_\\)+\\)[ \t]*:\\)?[ \t]*\\(do\\)\\_>")
       (list (match-string 3) (match-string 2))))
 
 (defsubst f90-looking-at-select-case ()
   "Return (\"select\" NAME) if a select statement starts after point.
 NAME is nil if the statement has no label."
-  (if (looking-at "\\(\\(\\sw+\\)[ \t]*:\\)?[ \t]*\
+  (if (looking-at "\\(\\(\\(?:\\sw\\|\\s_\\)+\\)[ \t]*:\\)?[ \t]*\
 \\(select\\)[ \t]*\\(case\\|type\\)[ \t]*(")
       (list (match-string 3) (match-string 2))))
 
@@ -1249,50 +1280,50 @@ NAME is nil if the statement has no label."
   "Return (\"if\" NAME) if an if () then statement starts after point.
 NAME is nil if the statement has no label."
   (save-excursion
-    (when (looking-at "\\(\\(\\sw+\\)[ \t]*:\\)?[ \t]*\\(if\\)\\>")
+    (when (looking-at "\\(\\(\\(?:\\sw\\|\\s_\\)+\\)[ \t]*:\\)?[ \t]*\\(if\\)\\_>")
       (let ((struct (match-string 3))
             (label (match-string 2))
             (pos (scan-lists (point) 1 0)))
         (and pos (goto-char pos))
         (skip-chars-forward " \t")
-        (if (or (looking-at "then\\>")
+        (if (or (looking-at "then\\_>")
                 (when (f90-line-continued)
                   (f90-next-statement)
                   (skip-chars-forward " \t0-9&")
-                  (looking-at "then\\>")))
+                  (looking-at "then\\_>")))
             (list struct label))))))
 
 ;; FIXME label?
 (defsubst f90-looking-at-associate ()
   "Return (\"associate\") if an associate block starts after point."
-  (if (looking-at "\\<\\(associate\\)[ \t]*(")
+  (if (looking-at "\\_<\\(associate\\)[ \t]*(")
       (list (match-string 1))))
 
 (defsubst f90-looking-at-critical ()
   "Return (KIND NAME) if a critical or block block starts after point."
-  (if (looking-at "\\(\\(\\sw+\\)[ \t]*:\\)?[ \t]*\\(critical\\|block\\)\\>")
+  (if (looking-at "\\(\\(\\(?:\\sw\\|\\s_\\)+\\)[ \t]*:\\)?[ \t]*\\(critical\\|block\\)\\_>")
       (let ((struct (match-string 3))
             (label (match-string 2)))
         (if (or (not (string-equal "block" struct))
                 (save-excursion
                   (skip-chars-forward " \t")
-                  (not (looking-at "data\\>"))))
+                  (not (looking-at "data\\_>"))))
             (list struct label)))))
 
 (defsubst f90-looking-at-end-critical ()
   "Return non-nil if a critical or block block ends after point."
-  (if (looking-at "end[ \t]*\\(critical\\|block\\)\\>")
+  (if (looking-at "end[ \t]*\\(critical\\|block\\)\\_>")
       (or (not (string-equal "block" (match-string 1)))
           (save-excursion
             (skip-chars-forward " \t")
-            (not (looking-at "data\\>"))))))
+            (not (looking-at "data\\_>"))))))
 
 (defsubst f90-looking-at-where-or-forall ()
   "Return (KIND NAME) if a where or forall block starts after point.
 NAME is nil if the statement has no label."
   (save-excursion
-    (when (looking-at "\\(\\(\\sw+\\)[ \t]*:\\)?[ \t]*\
-\\(where\\|forall\\)\\>")
+    (when (looking-at "\\(\\(\\(?:\\sw\\|\\s_\\)+\\)[ \t]*:\\)?[ \t]*\
+\\(where\\|forall\\)\\_>")
       (let ((struct (match-string 3))
             (label (match-string 2))
             (pos (scan-lists (point) 1 0)))
@@ -1305,43 +1336,43 @@ NAME is nil if the statement has no label."
 NAME is non-nil only for type and certain interfaces."
   (cond
    ((save-excursion
-      (and (looking-at "\\<type\\>[ \t]*")
+      (and (looking-at "\\_<type\\_>[ \t]*")
            (goto-char (match-end 0))
-           (not (looking-at "\\(is\\>\\|(\\)"))
-           (or (looking-at "\\(\\sw+\\)")
-               (re-search-forward "[ \t]*::[ \t]*\\(\\sw+\\)"
+           (not (looking-at "\\(is\\_>\\|(\\)"))
+           (or (looking-at "\\(\\(?:\\sw\\|\\s_\\)+\\)")
+               (re-search-forward "[ \t]*::[ \t]*\\(\\(?:\\sw\\|\\s_\\)+\\)"
                                   (line-end-position) t))))
     (list "type" (match-string 1)))
 ;;;    ((and (not (looking-at f90-typeis-re))
 ;;;          (looking-at f90-type-def-re))
 ;;;     (list (match-string 1) (match-string 2)))
-   ((looking-at "\\<\\(interface\\)\\>[ \t]*")
+   ((looking-at "\\_<\\(interface\\)\\_>[ \t]*")
     (list (match-string 1)
           (save-excursion
             (goto-char (match-end 0))
             (if (or (looking-at "\\(operator\\|assignment\\|read\\|\
 write\\)[ \t]*([^)\n]*)")
-                    (looking-at "\\sw+"))
+                    (looking-at "\\(?:\\sw\\|\\s_\\)+"))
                 (match-string 0)))))
-   ((looking-at "\\(enum\\|block[ \t]*data\\)\\>")
+   ((looking-at "\\(enum\\|block[ \t]*data\\)\\_>")
     (list (match-string 1) nil))
-   ((looking-at "abstract[ \t]*\\(interface\\)\\>")
+   ((looking-at "abstract[ \t]*\\(interface\\)\\_>")
     (list (match-string 1) nil))))
 
 (defsubst f90-looking-at-program-block-start ()
   "Return (KIND NAME) if a program block with name NAME starts after point."
 ;;;NAME is nil for an un-named main PROGRAM block."
   (cond
-   ((looking-at "\\(program\\)[ \t]+\\(\\sw+\\)\\>")
+   ((looking-at "\\(program\\)[ \t]+\\(\\(?:\\sw\\|\\s_\\)+\\)\\_>")
     (list (match-string 1) (match-string 2)))
-   ((and (not (looking-at "module[ \t]*procedure\\>"))
-         (looking-at "\\(module\\)[ \t]+\\(\\sw+\\)\\>"))
+   ((and (not (looking-at "module[ \t]*procedure\\_>"))
+         (looking-at "\\(module\\)[ \t]+\\(\\(?:\\sw\\|\\s_\\)+\\)\\_>"))
     (list (match-string 1) (match-string 2)))
-   ((looking-at "\\(submodule\\)[ \t]*([^)\n]+)[ \t]*\\(\\sw+\\)\\>")
+   ((looking-at "\\(submodule\\)[ \t]*([^)\n]+)[ \t]*\\(\\(?:\\sw\\|\\s_\\)+\\)\\_>")
     (list (match-string 1) (match-string 2)))
    ((and (not (looking-at "end[ \t]*\\(function\\|subroutine\\)"))
          (looking-at "[^!'\"\&\n]*\\(function\\|subroutine\\)[ \t]+\
-\\(\\sw+\\)"))
+\\(\\(?:\\sw\\|\\s_\\)+\\)"))
     (list (match-string 1) (match-string 2)))))
 ;; Following will match an un-named main program block; however
 ;; one needs to check if there is an actual PROGRAM statement after
@@ -1357,7 +1388,7 @@ write\\)[ \t]*([^)\n]*)")
 \\(?:assignment\\|operator\\|read\\|write\\)[ \t]*([^)\n]*)\\)")
          (list (match-string 1) (match-string 2)))
         ((looking-at (concat "end[ \t]*" f90-blocks-re
-                             "?\\([ \t]+\\(\\sw+\\)\\)?\\>"))
+                             "?\\([ \t]+\\(\\(?:\\sw\\|\\s_\\)+\\)\\)?\\_>"))
         (list (match-string 1) (match-string 3)))))
 
 (defsubst f90-comment-indent ()
@@ -1414,10 +1445,10 @@ if all else fails."
     (not (or (looking-at "end")
              (looking-at "\\(do\\|if\\|else\\(if\\|where\\)?\
 \\|select[ \t]*\\(case\\|type\\)\\|case\\|where\\|forall\\|\
-block\\|critical\\)\\>")
+block\\|critical\\)\\_>")
              (looking-at "\\(program\\|\\(?:sub\\)?module\\|\
-\\(?:abstract[ \t]*\\)?interface\\|block[ \t]*data\\)\\>")
-             (looking-at "\\(contains\\|\\sw+[ \t]*:\\)")
+\\(?:abstract[ \t]*\\)?interface\\|block[ \t]*data\\)\\_>")
+             (looking-at "\\(contains\\|\\(?:\\sw\\|\\s_\\)+[ \t]*:\\)")
              (looking-at f90-type-def-re)
              (re-search-forward "\\(function\\|subroutine\\)"
                                 (line-end-position) t)))))
@@ -1483,7 +1514,7 @@ Does not check type and subprogram indentation."
                (setq icol (- icol f90-associate-indent)))
               ((f90-looking-at-end-critical)
                (setq icol (- icol f90-critical-indent)))
-              ((looking-at "end[ \t]*do\\>")
+              ((looking-at "end[ \t]*do\\_>")
                (setq icol (- icol f90-do-indent))))
         (end-of-line))
       icol)))
@@ -1550,7 +1581,7 @@ Does not check type and subprogram indentation."
                         (cond ((or (looking-at f90-else-like-re)
                                    (looking-at f90-end-if-re))
                                (setq icol (- icol f90-if-indent)))
-                              ((looking-at "end[ \t]*do\\>")
+                              ((looking-at "end[ \t]*do\\_>")
                                (setq icol (- icol f90-do-indent)))
                               ((looking-at f90-end-type-re)
                                (setq icol (- icol f90-type-indent)))
@@ -1671,7 +1702,7 @@ Interactively, pushes mark before moving point."
              (setq start-list (cons start-this start-list) ; not add-to-list!
                    count (1+ count)))
             ((looking-at (concat "end[ \t]*" f90-blocks-re
-                                 "[ \t]*\\(\\sw+\\)?"))
+                                 "[ \t]*\\(\\(?:\\sw\\|\\s_\\)+\\)?"))
              (setq end-type (match-string 1)
                    end-label (match-string 2)
                    count (1- count))
@@ -1716,7 +1747,7 @@ Interactively, pushes mark before moving point."
       (skip-chars-forward " \t0-9")
       (cond ((or (f90-in-string) (f90-in-comment)))
             ((looking-at (concat "end[ \t]*" f90-blocks-re
-                                 "[ \t]*\\(\\sw+\\)?"))
+                                 "[ \t]*\\(\\(?:\\sw\\|\\s_\\)+\\)?"))
              (setq end-list (cons (list (match-string 1) (match-string 2))
                                   end-list)
                    count (1+ count)))
@@ -1962,7 +1993,7 @@ If run in the middle of a line, the line is not broken."
                                     (car end-struct) (cadr end-struct))))
              (setq ind-b
                    (cond ((looking-at f90-end-if-re) f90-if-indent)
-                         ((looking-at "end[ \t]*do\\>")  f90-do-indent)
+                         ((looking-at "end[ \t]*do\\_>")  f90-do-indent)
                          ((looking-at f90-end-type-re) f90-type-indent)
                          ((looking-at f90-end-associate-re)
                           f90-associate-indent)
@@ -2108,12 +2139,19 @@ Like `join-line', but handles F90 syntax."
         (zmacs-deactivate-region)
       (deactivate-mark))))
 
+(defconst f90-end-block-optional-name
+  '("program" "module" "subroutine" "function" "type")
+  "Block types where including the name in the end statement is optional.")
+
 (defun f90-block-match (beg-block beg-name end-block end-name)
   "Match end-struct with beg-struct and complete end-block if possible.
 BEG-BLOCK is the type of block as indicated at the start (e.g., do).
 BEG-NAME is the block start name (may be nil).
 END-BLOCK is the type of block as indicated at the end (may be nil).
 END-NAME is the block end name (may be nil).
+If the block type matches `f90-end-block-optional-name', do not add
+an end name if `f90-smart-end-names' is nil, but always update an
+incorrect end name if there already was one.
 Leave point at the end of line."
   ;; Hack to deal with the case when this is called from
   ;; f90-indent-region on a program block without an explicit PROGRAM
@@ -2133,8 +2171,11 @@ Leave point at the end of line."
     (if (f90-equal-symbols beg-name end-name)
         (and end-name (search-forward end-name))
       (cond ((and beg-name (not end-name))
-             (message "Inserting %s." beg-name)
-             (insert (concat " " beg-name)))
+             (unless (and (not f90-smart-end-names)
+                          (member-ignore-case beg-block
+                                              f90-end-block-optional-name))
+               (message "Inserting %s." beg-name)
+               (insert (concat " " beg-name))))
             ((and beg-name end-name)
              (message "Replacing %s with %s." end-name beg-name)
              (search-forward end-name)
diff --git a/lisp/progmodes/flymake.el b/lisp/progmodes/flymake.el
index 0f92df95a9d..99b48e8d0db 100644
--- a/lisp/progmodes/flymake.el
+++ b/lisp/progmodes/flymake.el
@@ -1,4 +1,4 @@
-;;; flymake.el -- a universal on-the-fly syntax checker
+;;; flymake.el --- a universal on-the-fly syntax checker
 
 ;; Copyright (C) 2003-2013 Free Software Foundation, Inc.
 
@@ -68,6 +68,9 @@
 
 ;;;; [[ cross-emacs compatibility routines
 (defsubst flymake-makehash (&optional test)
+  "Create and return a new hash table using TEST to compare keys.
+It uses the function `make-hash-table' to make a hash-table if
+you use GNU Emacs, otherwise it uses `makehash'."
   (if (fboundp 'make-hash-table)
       (if test (make-hash-table :test test) (make-hash-table))
     (with-no-warnings
@@ -106,10 +109,12 @@ Zero-length substrings at the beginning and end of the list are omitted."
     (lambda () temporary-file-directory)))
 
 (defun flymake-posn-at-point-as-event (&optional position window dx dy)
-  "Return pixel position of top left corner of glyph at POSITION,
-relative to top left corner of WINDOW, as a mouse-1 click
-event (identical to the event that would be triggered by clicking
-mouse button 1 at the top left corner of the glyph).
+  "Return pixel position of top left corner of glyph at POSITION.
+
+The position is relative to top left corner of WINDOW, as a
+mouse-1 click event (identical to the event that would be
+triggered by clicking mouse button 1 at the top left corner of
+the glyph).
 
 POSITION and WINDOW default to the position of point in the
 selected window.
@@ -164,7 +169,9 @@ See `x-popup-menu' for the menu specifier format."
 
 (if (featurep 'xemacs) (progn
 
-(defun flymake-nop ())
+(defun flymake-nop ()
+  "Do nothing."
+  nil)
 
 (defun flymake-make-xemacs-menu (menu-data)
   "Return a menu specifier using MENU-DATA."
@@ -187,6 +194,7 @@ See `x-popup-menu' for the menu specifier format."
     (count-lines (window-start) (point))))
 
 (defun flymake-selected-frame ()
+  "Return the frame that is now selected."
   (if (fboundp 'window-edges)
       (selected-frame)
     (selected-window)))
@@ -217,31 +225,41 @@ See `x-popup-menu' for the menu specifier format."
   :group 'flymake
   :type 'integer)
 
+
+;; (defcustom flymake-log-file-name "~/flymake.log"
+;;   "Where to put the flymake log if logging is enabled.
+;; 
+;;    See `flymake-log-level' if you want to control what is logged."
+;;   :group 'flymake
+;;   :type 'string)
+
 (defun flymake-log (level text &rest args)
   "Log a message at level LEVEL.
 If LEVEL is higher than `flymake-log-level', the message is
 ignored.  Otherwise, it is printed using `message'.
 TEXT is a format control string, and the remaining arguments ARGS
-are the string substitutions (see `format')."
+are the string substitutions (see the function `format')."
   (if (<= level flymake-log-level)
       (let* ((msg (apply 'format text args)))
         (message "%s" msg)
         ;;(with-temp-buffer
         ;;    (insert msg)
         ;;   (insert "\n")
-        ;;   (flymake-save-buffer-in-file "d:/flymake.log" t)  ; make log file name customizable
+        ;;   (flymake-save-buffer-in-file "~/flymake.log")  ; make log file name customizable
         ;;)
         )))
 
 (defun flymake-ins-after (list pos val)
-  "Insert VAL into LIST after position POS."
-  (let ((tmp (copy-sequence list)))     ; (???)
+  "Insert VAL into LIST after position POS.
+POS counts from zero."
+  (let ((tmp (copy-sequence list)))
     (setcdr (nthcdr pos tmp) (cons val (nthcdr (1+ pos) tmp)))
     tmp))
 
 (defun flymake-set-at (list pos val)
-  "Set VAL at position POS in LIST."
-  (let ((tmp (copy-sequence list)))     ; (???)
+  "Set VAL at position POS in LIST.
+POS counts from zero."
+  (let ((tmp (copy-sequence list)))
     (setcar (nthcdr pos tmp) val)
     tmp))
 
@@ -249,7 +267,6 @@ are the string substitutions (see `format')."
   "List of currently active flymake processes.")
 
 (defvar flymake-output-residual nil)
-
 (make-variable-buffer-local 'flymake-output-residual)
 
 (defgroup flymake nil
@@ -257,6 +274,13 @@ are the string substitutions (see `format')."
   :version "23.1"
   :group 'tools)
 
+(defcustom flymake-xml-program
+  (if (executable-find "xmlstarlet") "xmlstarlet" "xml")
+  "Program to use for XML validation."
+  :type 'file
+  :group 'flymake
+  :version "24.4")
+
 (defcustom flymake-allowed-file-name-masks
   '(("\\.\\(?:c\\(?:pp\\|xx\\|\\+\\+\\)?\\|CC\\)\\'" flymake-simple-make-init)
     ("\\.xml\\'" flymake-xml-init)
@@ -279,16 +303,31 @@ are the string substitutions (see `format')."
     ;; ("[ \t]*\\input[ \t]*{\\(.*\\)\\(%s\\)}" 1 2 ))
     ;; ("\\.tex\\'" 1)
     )
-  "Files syntax checking is allowed for."
+  "Files syntax checking is allowed for.
+This is an alist with elements of the form:
+  REGEXP INIT [CLEANUP [NAME]]
+REGEXP is a regular expression that matches a file name.
+INIT is the init function to use.
+CLEANUP is the cleanup function to use, default `flymake-simple-cleanup'.
+NAME is the file name function to use, default `flymake-get-real-file-name'."
   :group 'flymake
-  :type '(repeat (string symbol symbol symbol)))
+  :type '(alist :key-type (regexp :tag "File regexp")
+                :value-type
+                (list :tag "Handler functions"
+                      (function :tag "Init function")
+                      (choice :tag "Cleanup function"
+                              (const :tag "flymake-simple-cleanup" nil)
+                              function)
+                      (choice :tag "Name function"
+                              (const :tag "flymake-get-real-file-name" nil)
+                              function))))
 
 (defun flymake-get-file-name-mode-and-masks (file-name)
   "Return the corresponding entry from `flymake-allowed-file-name-masks'."
   (unless (stringp file-name)
     (error "Invalid file-name"))
   (let ((fnm flymake-allowed-file-name-masks)
-        (mode-and-masks  nil))
+        (mode-and-masks nil))
     (while (and (not mode-and-masks) fnm)
       (if (string-match (car (car fnm)) file-name)
           (setq mode-and-masks (cdr (car fnm))))
@@ -314,18 +353,22 @@ Return nil if we cannot, non-nil if we can."
       'flymake-simple-cleanup))
 
 (defun flymake-get-real-file-name-function (file-name)
-  (or (nth 2 (flymake-get-file-name-mode-and-masks file-name))
+  (or (nth 4 (flymake-get-file-name-mode-and-masks file-name))
       'flymake-get-real-file-name))
 
 (defvar flymake-find-buildfile-cache (flymake-makehash 'equal))
 
 (defun flymake-get-buildfile-from-cache (dir-name)
+  "Look up DIR-NAME in cache and return its associated value.
+If DIR-NAME is not found, return nil."
   (gethash dir-name flymake-find-buildfile-cache))
 
 (defun flymake-add-buildfile-to-cache (dir-name buildfile)
+  "Associate DIR-NAME with BUILDFILE in the buildfile cache."
   (puthash dir-name buildfile flymake-find-buildfile-cache))
 
 (defun flymake-clear-buildfile-cache ()
+  "Clear the buildfile cache."
   (clrhash flymake-find-buildfile-cache))
 
 (defun flymake-find-buildfile (buildfile-name source-dir-name)
@@ -372,9 +415,11 @@ Return t if so, nil if not."
 
 (defun flymake-find-possible-master-files (file-name master-file-dirs masks)
   "Find (by name and location) all possible master files.
-Master files include .cpp and .c for .h.  Files are searched for
-starting from the .h directory and max max-level parent dirs.
-File contents are not checked."
+
+Name is specified by FILE-NAME and location is specified by
+MASTER-FILE-DIRS.  Master files include .cpp and .c for .h.
+Files are searched for starting from the .h directory and max
+max-level parent dirs.  File contents are not checked."
   (let* ((dirs master-file-dirs)
          (files  nil)
          (done   nil))
@@ -571,6 +616,8 @@ Find master file, patch and save it."
         nil))))
 
 (defun flymake-save-buffer-in-file (file-name)
+  "Save the entire buffer contents into file FILE-NAME.
+Create parent directories as needed."
   (make-directory (file-name-directory file-name) 1)
   (write-region nil nil file-name nil 566)
   (flymake-log 3 "saved buffer %s in file %s" (buffer-name) file-name))
@@ -1837,7 +1884,9 @@ Use CREATE-TEMP-F for creating temp copy."
 
 ;;;; xml-specific init-cleanup routines
 (defun flymake-xml-init ()
-  (list "xml" (list "val" (flymake-init-create-temp-buffer-copy 'flymake-create-temp-inplace))))
+  (list flymake-xml-program
+        (list "val" (flymake-init-create-temp-buffer-copy
+                     'flymake-create-temp-inplace))))
 
 (provide 'flymake)
 
diff --git a/lisp/progmodes/gdb-mi.el b/lisp/progmodes/gdb-mi.el
index 8ba2822c3a3..0b52302a98d 100644
--- a/lisp/progmodes/gdb-mi.el
+++ b/lisp/progmodes/gdb-mi.el
@@ -91,7 +91,7 @@
 (require 'gud)
 (require 'json)
 (require 'bindat)
-(eval-when-compile (require 'cl-lib))
+(require 'cl-lib)
 
 (declare-function speedbar-change-initial-expansion-list
                   "speedbar" (new-default))
@@ -206,8 +206,8 @@ Only used for files that Emacs can't find.")
 (defvar gdb-last-command nil)
 (defvar gdb-prompt-name nil)
 (defvar gdb-token-number 0)
-(defvar gdb-handler-alist '())
-(defvar gdb-handler-number nil)
+(defvar gdb-handler-list '()
+  "List of gdb-handler keeping track of all pending GDB commands.")
 (defvar gdb-source-file-list nil
   "List of source files for the current executable.")
 (defvar gdb-first-done-or-error t)
@@ -242,33 +242,114 @@ Possible values are these symbols:
                disposition of output generated by commands that
                gdb mode sends to gdb on its own behalf.")
 
-;; Pending triggers prevent congestion: Emacs won't send two similar
-;; consecutive requests.
-
-(defvar gdb-pending-triggers '()
-  "A list of trigger functions which have not yet been handled.
-
-Elements are either function names or pairs (buffer . function)")
-
-(defmacro gdb-add-pending (item)
-  `(push ,item gdb-pending-triggers))
-(defmacro gdb-pending-p (item)
-  `(member ,item gdb-pending-triggers))
-(defmacro gdb-delete-pending (item)
-  `(setq gdb-pending-triggers
-         (delete ,item gdb-pending-triggers)))
+(defcustom gdb-discard-unordered-replies t
+  "Non-nil means discard any out-of-order GDB replies.
+This protects against lost GDB replies, assuming that GDB always
+replies in the same order as Emacs sends commands.  When receiving a
+reply with a given token-number, assume any pending messages with a
+lower token-number are out-of-order."
+  :type 'boolean
+  :group 'gud
+  :version "24.4")
+
+(cl-defstruct gdb-handler
+  "Data required to handle the reply of a command sent to GDB."
+  ;; Prefix of the command sent to GDB.  The GDB reply for this command
+  ;; will be prefixed with this same TOKEN-NUMBER
+  (token-number nil :read-only t)
+  ;; Callback to invoke when the reply is received from GDB
+  (function nil :read-only t)
+  ;; PENDING-TRIGGER is used to prevent congestion: Emacs won't send
+  ;; two requests with the same PENDING-TRIGGER until a reply is received
+  ;; for the first one."
+  (pending-trigger nil))
+
+(defun gdb-add-handler (token-number handler-function &optional pending-trigger)
+  "Insert a new GDB command handler in `gdb-handler-list'.
+Handlers are used to keep track of the commands sent to GDB
+and to handle the replies received.
+Upon reception of a reply prefixed with TOKEN-NUMBER,
+invoke the callback HANDLER-FUNCTION.
+If PENDING-TRIGGER is specified, no new GDB commands will be
+sent with this same PENDING-TRIGGER until a reply is received
+for this handler."
+
+  (push (make-gdb-handler :token-number token-number
+                          :function handler-function
+                          :pending-trigger pending-trigger)
+        gdb-handler-list))
+
+(defun gdb-delete-handler (token-number)
+  "Remove the handler TOKEN-NUMBER from `gdb-handler-list'.
+Additionally, if `gdb-discard-unordered-replies' is non-nil,
+discard all handlers having a token number less than TOKEN-NUMBER."
+  (if gdb-discard-unordered-replies
+
+      (setq gdb-handler-list
+            (cl-delete-if
+             (lambda (handler)
+               "Discard any HANDLER with a token number `<=' than TOKEN-NUMBER."
+               (when (< (gdb-handler-token-number handler) token-number)
+                 (message (format
+                           "WARNING! Discarding GDB handler with token #%d\n"
+                           (gdb-handler-token-number handler))))
+               (<= (gdb-handler-token-number handler) token-number))
+             gdb-handler-list))
+
+    (setq gdb-handler-list
+          (cl-delete-if
+           (lambda (handler)
+             "Discard any HANDLER with a token number `eq' to TOKEN-NUMBER."
+             (eq (gdb-handler-token-number handler) token-number))
+           gdb-handler-list))))
+
+(defun gdb-get-handler-function (token-number)
+  "Return the function callback registered with the handler TOKEN-NUMBER."
+  (gdb-handler-function
+   (cl-find-if (lambda (handler) (eq (gdb-handler-token-number handler)
+                                      token-number))
+                gdb-handler-list)))
+
+
+(defun gdb-pending-handler-p (pending-trigger)
+  "Return non-nil if a command handler is pending with trigger PENDING-TRIGGER."
+  (cl-find-if (lambda (handler) (eq (gdb-handler-pending-trigger handler)
+                                     pending-trigger))
+               gdb-handler-list))
+
+
+(defun gdb-handle-reply (token-number)
+  "Handle the GDB reply TOKEN-NUMBER.
+This invokes the handler registered with this token number
+in `gdb-handler-list' and clears all pending handlers invalidated
+by the reception of this reply."
+  (let ((handler-function (gdb-get-handler-function token-number)))
+    (when handler-function
+      (funcall handler-function)
+      (gdb-delete-handler token-number))))
+
+(defun gdb-remove-all-pending-triggers ()
+  "Remove all pending triggers from gdb-handler-list.
+The handlers are left in gdb-handler-list so that replies received
+from GDB could still be handled.  However, removing the pending triggers
+allows Emacs to send new commands even if replies of previous commands
+were not yet received."
+  (dolist (handler gdb-handler-list)
+    (setf (gdb-handler-pending-trigger handler) nil)))
 
 (defmacro gdb-wait-for-pending (&rest body)
-  "Wait until `gdb-pending-triggers' is empty and evaluate FORM.
-
-This function checks `gdb-pending-triggers' value every
-`gdb-wait-for-pending' seconds."
-  (run-with-timer
-   0.5 nil
-   `(lambda ()
-      (if (not gdb-pending-triggers)
-          (progn ,@body)
-        (gdb-wait-for-pending ,@body)))))
+  "Wait for all pending GDB commands to finish and evaluate BODY.
+
+This function checks every 0.5 seconds if there are any pending
+triggers in `gdb-handler-list'."
+  `(run-with-timer
+    0.5 nil
+    '(lambda ()
+       (if (not (cl-find-if (lambda (handler)
+                               (gdb-handler-pending-trigger handler))
+                             gdb-handler-list))
+           (progn ,@body)
+         (gdb-wait-for-pending ,@body)))))
 
 ;; Publish-subscribe
 
@@ -574,21 +655,20 @@ NOARG must be t when this macro is used outside `gud-def'"
     (concat (gdb-gud-context-command ,cmd1 ,noall) " " ,cmd2)
     ,(when (not noarg) 'arg)))
 
-(defun gdb--check-interpreter (proc string)
+(defun gdb--check-interpreter (filter proc string)
   (unless (zerop (length string))
-    (let ((filter (process-get proc 'gud-normal-filter)))
-      (set-process-filter proc filter)
-      (unless (memq (aref string 0) '(?^ ?~ ?@ ?& ?* ?=))
-        ;; Apparently we're not running with -i=mi.
-        (let ((msg "Error: you did not specify -i=mi on GDB's command line!"))
-          (message msg)
-          (setq string (concat (propertize msg 'font-lock-face 'error)
-                               "\n" string)))
-        ;; Use the old gud-gbd filter, not because it works, but because it
-        ;; will properly display GDB's answers rather than hanging waiting for
-        ;; answers that aren't coming.
-        (set (make-local-variable 'gud-marker-filter) #'gud-gdb-marker-filter))
-      (funcall filter proc string))))
+    (remove-function (process-filter proc) #'gdb--check-interpreter)
+    (unless (memq (aref string 0) '(?^ ?~ ?@ ?& ?* ?=))
+      ;; Apparently we're not running with -i=mi.
+      (let ((msg "Error: you did not specify -i=mi on GDB's command line!"))
+        (message msg)
+        (setq string (concat (propertize msg 'font-lock-face 'error)
+                             "\n" string)))
+      ;; Use the old gud-gbd filter, not because it works, but because it
+      ;; will properly display GDB's answers rather than hanging waiting for
+      ;; answers that aren't coming.
+      (set (make-local-variable 'gud-marker-filter) #'gud-gdb-marker-filter))
+    (funcall filter proc string)))
 
 (defvar gdb-control-level 0)
 
@@ -662,8 +742,7 @@ detailed description of this mode.
   ;; Setup a temporary process filter to warn when GDB was not started
   ;; with -i=mi.
   (let ((proc (get-buffer-process gud-comint-buffer)))
-    (process-put proc 'gud-normal-filter (process-filter proc))
-    (set-process-filter proc #'gdb--check-interpreter))
+    (add-function :around (process-filter proc) #'gdb--check-interpreter))
 
   (set (make-local-variable 'gud-minor-mode) 'gdbmi)
   (set (make-local-variable 'gdb-control-level) 0)
@@ -822,14 +901,12 @@ detailed description of this mode.
         gdb-frame-number nil
         gdb-thread-number nil
         gdb-var-list nil
-        gdb-pending-triggers nil
         gdb-output-sink 'user
         gdb-location-alist nil
         gdb-source-file-list nil
         gdb-last-command nil
         gdb-token-number 0
-        gdb-handler-alist '()
-        gdb-handler-number nil
+        gdb-handler-list '()
         gdb-prompt-name nil
         gdb-first-done-or-error t
         gdb-buffer-fringe-width (car (window-fringes))
@@ -1109,17 +1186,15 @@ With arg, enter name of variable to be watched in the minibuffer."
       (message-box "No symbol \"%s\" in current context." expr))))
 
 (defun gdb-speedbar-update ()
-  (when (and (boundp 'speedbar-frame) (frame-live-p speedbar-frame)
-             (not (gdb-pending-p 'gdb-speedbar-timer)))
+  (when (and (boundp 'speedbar-frame) (frame-live-p speedbar-frame))
     ;; Dummy command to update speedbar even when idle.
-    (gdb-input "-environment-pwd" 'gdb-speedbar-timer-fn)
-    ;; Keep gdb-pending-triggers non-nil till end.
-    (gdb-add-pending 'gdb-speedbar-timer)))
+    (gdb-input "-environment-pwd"
+               'gdb-speedbar-timer-fn
+               'gdb-speedbar-update)))
 
 (defun gdb-speedbar-timer-fn ()
   (if gdb-speedbar-auto-raise
       (raise-frame speedbar-frame))
-  (gdb-delete-pending 'gdb-speedbar-timer)
   (speedbar-timer-fn))
 
 (defun gdb-var-evaluate-expression-handler (varnum changed)
@@ -1209,9 +1284,9 @@ With arg, enter name of variable to be watched in the minibuffer."
 
                                         ; Uses "-var-update --all-values".  Needs GDB 6.4 onwards.
 (defun gdb-var-update ()
-  (if (not (gdb-pending-p 'gdb-var-update))
-      (gdb-input "-var-update --all-values *" 'gdb-var-update-handler))
-  (gdb-add-pending 'gdb-var-update))
+  (gdb-input "-var-update --all-values *"
+             'gdb-var-update-handler
+             'gdb-var-update))
 
 (defun gdb-var-update-handler ()
   (let ((changelist (bindat-get-field (gdb-json-partial-output) 'changelist)))
@@ -1274,8 +1349,6 @@ With arg, enter name of variable to be watched in the minibuffer."
                   (push var1 var-list))
                 (setq var1 (pop temp-var-list)))
               (setq gdb-var-list (nreverse var-list))))))))
-  (setq gdb-pending-triggers
-        (delq 'gdb-var-update gdb-pending-triggers))
   (gdb-speedbar-update))
 
 (defun gdb-speedbar-expand-node (text token indent)
@@ -1729,18 +1802,25 @@ All embedded quotes, newlines, and backslashes are preceded with a backslash."
   (setq string (replace-regexp-in-string "\n" "\\n" string t t))
   (concat "\"" string "\""))
 
-(defun gdb-input (command handler-function)
+(defun gdb-input (command handler-function &optional trigger-name)
   "Send COMMAND to GDB via the MI interface.
 Run the function HANDLER-FUNCTION, with no arguments, once the command is
-complete."
-  (if gdb-enable-debug (push (list 'send-item command handler-function)
-                             gdb-debug-log))
-  (setq gdb-token-number (1+ gdb-token-number))
-  (setq command (concat (number-to-string gdb-token-number) command))
-  (push (cons gdb-token-number handler-function) gdb-handler-alist)
-  (if gdbmi-debug-mode (message "gdb-input: %s" command))
-  (process-send-string (get-buffer-process gud-comint-buffer)
-                       (concat command "\n")))
+complete.  Do not send COMMAND to GDB if TRIGGER-NAME is non-nil and
+Emacs is still waiting for a reply from another command previously
+sent with the same TRIGGER-NAME."
+  (when (or (not trigger-name)
+            (not (gdb-pending-handler-p trigger-name)))
+    (setq gdb-token-number (1+ gdb-token-number))
+    (setq command (concat (number-to-string gdb-token-number) command))
+
+    (if gdb-enable-debug (push (list 'send-item command handler-function)
+                               gdb-debug-log))
+
+    (gdb-add-handler gdb-token-number handler-function trigger-name)
+
+    (if gdbmi-debug-mode (message "gdb-input: %s" command))
+    (process-send-string (get-buffer-process gud-comint-buffer)
+                         (concat command "\n"))))
 
 ;; NOFRAME is used for gud execution control commands
 (defun gdb-current-context-command (command)
@@ -1776,7 +1856,7 @@ If `gdb-thread-number' is nil, just wrap NAME in asterisks."
 (defun gdb-resync()
   (setq gud-running nil)
   (setq gdb-output-sink 'user)
-  (setq gdb-pending-triggers nil))
+  (gdb-remove-all-pending-triggers))
 
 (defun gdb-update (&optional no-proc)
   "Update buffers showing status of debug session.
@@ -2149,19 +2229,23 @@ the end of the current result or async record is reached."
     ;; Search the data stream for the end of the current record:
     (let* ((newline-pos (string-match "\n" gud-marker-acc gdbmi-bnf-offset))
            (is-progressive (equal (cdr class-command) 'progressive))
-           (is-complete (not (null newline-pos)))
-           result-str)
+       (is-complete (not (null newline-pos)))
+       result-str)
+
+      (when gdbmi-debug-mode
+        (message "gdbmi-bnf-incomplete-record-result: %s"
+                 (substring gud-marker-acc gdbmi-bnf-offset newline-pos)))
 
       ;; Update the gdbmi-bnf-offset only if the current chunk of data can
       ;; be processed by the class-command handler:
       (when (or is-complete is-progressive)
-        (setq result-str
+        (setq result-str
               (substring gud-marker-acc gdbmi-bnf-offset newline-pos))
-        (setq gdbmi-bnf-offset (+ 1 newline-pos)))
 
-      (if gdbmi-debug-mode
-          (message "gdbmi-bnf-incomplete-record-result: %s"
-                   (substring gud-marker-acc gdbmi-bnf-offset newline-pos)))
+        ;; Move gdbmi-bnf-offset past the end of the chunk.
+        (setq gdbmi-bnf-offset (+ gdbmi-bnf-offset (length result-str)))
+        (when newline-pos
+          (setq gdbmi-bnf-offset (1+ gdbmi-bnf-offset))))
 
       ;; Update the parsing state before invoking the handler in class-command
       ;; to make sure it's not left in an invalid state if the handler was
@@ -2253,9 +2337,9 @@ Unset `gdb-thread-number' if current thread exited and update threads list."
     (if (string= gdb-thread-number thread-id)
         (gdb-setq-thread-number nil))
     ;; When we continue current thread and it quickly exits,
-    ;; gdb-pending-triggers left after gdb-running disallow us to
-    ;; properly call -thread-info without --thread option. Thus we
-    ;; need to use gdb-wait-for-pending.
+    ;; the pending triggers in gdb-handler-list left after gdb-running
+    ;; disallow us to properly call -thread-info without --thread option.
+    ;; Thus we need to use gdb-wait-for-pending.
     (gdb-wait-for-pending
      (gdb-emit-signal gdb-buf-publisher 'update-threads))))
 
@@ -2270,9 +2354,10 @@ Sets `gdb-thread-number' to new id."
     ;; by `=thread-selected` notification. `^done` causes `gdb-update`
     ;; as usually. Things happen to fast and second call (from
     ;; gdb-thread-selected handler) gets cut off by our beloved
-    ;; gdb-pending-triggers.
-    ;; Solution is `gdb-wait-for-pending` macro: it guarantees that its
-    ;; body will get executed when `gdb-pending-triggers` is empty.
+    ;; pending triggers.
+    ;; Solution is `gdb-wait-for-pending' macro: it guarantees that its
+    ;; body will get executed when `gdb-handler-list' if free of
+    ;; pending triggers.
     (gdb-wait-for-pending
      (gdb-update))))
 
@@ -2291,8 +2376,7 @@ Sets `gdb-thread-number' to new id."
    (propertize gdb-inferior-status 'face font-lock-type-face))
   (when (not gdb-non-stop)
     (setq gud-running t))
-  (setq gdb-active-process t)
-  (gdb-emit-signal gdb-buf-publisher 'update-threads))
+  (setq gdb-active-process t))
 
 (defun gdb-starting (_output-field _result)
   ;; CLI commands don't emit ^running at the moment so use gdb-running too.
@@ -2300,11 +2384,7 @@ Sets `gdb-thread-number' to new id."
   (gdb-force-mode-line-update
    (propertize gdb-inferior-status 'face font-lock-type-face))
   (setq gdb-active-process t)
-  (setq gud-running t)
-  ;; GDB doesn't seem to respond to -thread-info before first stop or
-  ;; thread exit (even in non-stop mode), so this is useless.
-  ;; Behavior may change in the future.
-  (gdb-emit-signal gdb-buf-publisher 'update-threads))
+  (setq gud-running t))
 
 ;; -break-insert -t didn't give a reason before gdb 6.9
 
@@ -2436,10 +2516,7 @@ current thread and update GDB buffers."
     (when (and token-number is-complete)
       (with-current-buffer
           (gdb-get-buffer-create 'gdb-partial-output-buffer)
-        (funcall
-         (cdr (assoc (string-to-number token-number) gdb-handler-alist))))
-      (setq gdb-handler-alist
-            (assq-delete-all token-number gdb-handler-alist)))
+        (gdb-handle-reply (string-to-number token-number))))
 
   (when is-complete
     (gdb-clear-partial-output))))
@@ -2657,27 +2734,23 @@ trigger argument when describing buffer types with
      (when
          (or (not ,signal-list)
              (memq signal ,signal-list))
-       (when (not (gdb-pending-p
-                   (cons (current-buffer) ',trigger-name)))
-         (gdb-input ,gdb-command
-                    (gdb-bind-function-to-buffer ',handler-name (current-buffer)))
-         (gdb-add-pending (cons (current-buffer) ',trigger-name))))))
+       (gdb-input ,gdb-command
+                  (gdb-bind-function-to-buffer ',handler-name (current-buffer))
+                  (cons (current-buffer) ',trigger-name)))))
 
 ;; Used by disassembly buffer only, the rest use
 ;; def-gdb-trigger-and-handler
-(defmacro def-gdb-auto-update-handler (handler-name trigger-name custom-defun
+(defmacro def-gdb-auto-update-handler (handler-name custom-defun
                                                     &optional nopreserve)
-  "Define a handler HANDLER-NAME for TRIGGER-NAME with CUSTOM-DEFUN.
+  "Define a handler HANDLER-NAME calling CUSTOM-DEFUN.
 
 Handlers are normally called from the buffers they put output in.
 
-Delete ((current-buffer) . TRIGGER-NAME) from
-`gdb-pending-triggers', erase current buffer and evaluate
-CUSTOM-DEFUN.  Then `gdb-update-buffer-name' is called.
+Erase current buffer and evaluate CUSTOM-DEFUN.
+Then call `gdb-update-buffer-name'.
 
 If NOPRESERVE is non-nil, window point is not restored after CUSTOM-DEFUN."
   `(defun ,handler-name ()
-     (gdb-delete-pending (cons (current-buffer) ',trigger-name))
      (let* ((inhibit-read-only t)
             ,@(unless nopreserve
                 '((window (get-buffer-window (current-buffer) 0))
@@ -2705,7 +2778,7 @@ See `def-gdb-auto-update-handler'."
        ,gdb-command
        ,handler-name ,signal-list)
      (def-gdb-auto-update-handler ,handler-name
-       ,trigger-name ,custom-defun)))
+       ,custom-defun)))
 
 
 
@@ -3622,7 +3695,6 @@ DOC is an optional documentation string."
 
 (def-gdb-auto-update-handler
   gdb-disassembly-handler
-  gdb-invalidate-disassembly
   gdb-disassembly-handler-custom
   t)
 
@@ -4114,21 +4186,19 @@ member."
 
 ;; Needs GDB 6.4 onwards (used to fail with no stack).
 (defun gdb-get-changed-registers ()
-  (when (and (gdb-get-buffer 'gdb-registers-buffer)
-             (not (gdb-pending-p 'gdb-get-changed-registers)))
+  (when (gdb-get-buffer 'gdb-registers-buffer)
     (gdb-input "-data-list-changed-registers"
-               'gdb-changed-registers-handler)
-    (gdb-add-pending 'gdb-get-changed-registers)))
+               'gdb-changed-registers-handler
+               'gdb-get-changed-registers)))
 
 (defun gdb-changed-registers-handler ()
-  (gdb-delete-pending 'gdb-get-changed-registers)
   (setq gdb-changed-registers nil)
   (dolist (register-number
            (bindat-get-field (gdb-json-partial-output) 'changed-registers))
     (push register-number gdb-changed-registers)))
 
 (defun gdb-register-names-handler ()
-  ;; Don't use gdb-pending-triggers because this handler is called
+  ;; Don't use pending triggers because this handler is called
   ;; only once (in gdb-init-1)
   (setq gdb-register-names nil)
   (dolist (register-name
@@ -4152,16 +4222,13 @@ is set in them."
 (defun gdb-get-main-selected-frame ()
   "Trigger for `gdb-frame-handler' which uses main current thread.
 Called from `gdb-update'."
-  (if (not (gdb-pending-p 'gdb-get-main-selected-frame))
-      (progn
-        (gdb-input (gdb-current-context-command "-stack-info-frame")
-                   'gdb-frame-handler)
-        (gdb-add-pending 'gdb-get-main-selected-frame))))
+  (gdb-input (gdb-current-context-command "-stack-info-frame")
+             'gdb-frame-handler
+             'gdb-get-main-selected-frame))
 
 (defun gdb-frame-handler ()
   "Set `gdb-selected-frame' and `gdb-selected-file' to show
 overlay arrow in source buffer."
-  (gdb-delete-pending 'gdb-get-main-selected-frame)
   (let ((frame (bindat-get-field (gdb-json-partial-output) 'frame)))
     (when frame
       (setq gdb-selected-frame (bindat-get-field frame 'func))
diff --git a/lisp/progmodes/grep.el b/lisp/progmodes/grep.el
index 1e152c6d751..46af51e1f97 100644
--- a/lisp/progmodes/grep.el
+++ b/lisp/progmodes/grep.el
@@ -410,7 +410,9 @@ Notice that using \\[next-error] or \\[compile-goto-error] modifies
       (0 '(face nil compilation-message nil help-echo nil mouse-face nil) t)
       (1 grep-error-face)
       (2 grep-error-face nil t))
-     ("^.+?-[0-9]+-.*\n" (0 grep-context-face)))
+     ;; "filename-linenumber-" format is used for context lines in GNU grep,
+     ;; "filename=linenumber=" for lines with function names in "git grep -p".
+     ("^.+?[-=][0-9]+[-=].*\n" (0 grep-context-face)))
    "Additional things to highlight in grep output.
 This gets tacked on the end of the generated expressions.")
 
diff --git a/lisp/progmodes/gud.el b/lisp/progmodes/gud.el
index d339495d76a..c549d9eedef 100644
--- a/lisp/progmodes/gud.el
+++ b/lisp/progmodes/gud.el
@@ -46,11 +46,8 @@
 (defvar gdb-show-changed-values)
 (defvar gdb-source-window)
 (defvar gdb-var-list)
-(defvar gdb-speedbar-auto-raise)
-(defvar gud-tooltip-mode)
 (defvar hl-line-mode)
 (defvar hl-line-sticky-flag)
-(defvar tool-bar-map)
 
 
 ;; ======================================================================
@@ -416,7 +413,7 @@ we're in the GUD buffer)."
 
 ;; ======================================================================
 ;; speedbar support functions and variables.
-(eval-when-compile (require 'speedbar)) ;For speedbar-with-attached-buffer.
+(eval-when-compile (require 'dframe)) ; for dframe-with-attached-buffer
 
 (defvar gud-last-speedbar-stackframe nil
   "Description of the currently displayed GUD stack.
@@ -425,19 +422,24 @@ The value t means that there is no stack, and we are in display-file mode.")
 (defvar gud-speedbar-key-map nil
   "Keymap used when in the buffers display mode.")
 
+;; At runtime, will be pulled in as a require of speedbar.
+(declare-function dframe-message "dframe" (fmt &rest args))
+
 (defun gud-speedbar-item-info ()
   "Display the data type of the watch expression element."
   (let ((var (nth (- (line-number-at-pos (point)) 2) gdb-var-list)))
     (if (nth 7 var)
-        (speedbar-message "%s: %s" (nth 7 var) (nth 3 var))
-      (speedbar-message "%s" (nth 3 var)))))
+        (dframe-message "%s: %s" (nth 7 var) (nth 3 var))
+      (dframe-message "%s" (nth 3 var)))))
+
+(declare-function speedbar-make-specialized-keymap "speedbar" ())
+(declare-function speedbar-add-expansion-list "speedbar" (new-list))
+(defvar speedbar-mode-functions-list)
 
 (defun gud-install-speedbar-variables ()
   "Install those variables used by speedbar to enhance gud/gdb."
-  (if gud-speedbar-key-map
-      nil
+  (unless gud-speedbar-key-map
     (setq gud-speedbar-key-map (speedbar-make-specialized-keymap))
-
     (define-key gud-speedbar-key-map "j" 'speedbar-edit-line)
     (define-key gud-speedbar-key-map "e" 'speedbar-edit-line)
     (define-key gud-speedbar-key-map "\C-m" 'speedbar-edit-line)
@@ -486,6 +488,13 @@ The value t means that there is no stack, and we are in display-file mode.")
 DIRECTORY and ZERO are not used, but are required by the caller."
   (gud-speedbar-buttons gud-comint-buffer))
 
+(declare-function speedbar-make-tag-line "speedbar"
+                  (type char func data tag tfunc tdata tface depth))
+(declare-function speedbar-remove-localized-speedbar-support "speedbar"
+                  (buffer))
+(declare-function speedbar-insert-button "speedbar"
+                  (text face mouse function &optional token prevline))
+
 (defun gud-speedbar-buttons (buffer)
   "Create a speedbar display based on the current state of GUD.
 If the GUD BUFFER is not running a supported debugger, then turn
@@ -707,6 +716,16 @@ The option \"--fullname\" must be included in this value."
 (defvar gud-filter-pending-text nil
   "Non-nil means this is text that has been saved for later in `gud-filter'.")
 
+;; One of the nice features of GDB is its impressive support for
+;; context-sensitive command completion.  We preserve that feature
+;; in the GUD buffer by using a GDB command designed just for Emacs.
+
+(defvar gud-gdb-completion-function nil
+  "Completion function for GDB commands.
+It receives two arguments: COMMAND, the prefix for which we seek
+completion; and CONTEXT, the text before COMMAND on the line.
+It should return a list of completion strings.")
+
 ;; If in gdb mode, gdb-mi is loaded.
 (declare-function gdb-restore-windows "gdb-mi" ())
 
@@ -767,16 +786,6 @@ directory and source-file directory for your debugger."
   (setq gud-filter-pending-text nil)
   (run-hooks 'gud-gdb-mode-hook))
 
-;; One of the nice features of GDB is its impressive support for
-;; context-sensitive command completion.  We preserve that feature
-;; in the GUD buffer by using a GDB command designed just for Emacs.
-
-(defvar gud-gdb-completion-function nil
-  "Completion function for GDB commands.
-It receives two arguments: COMMAND, the prefix for which we seek
-completion; and CONTEXT, the text before COMMAND on the line.
-It should return a list of completion strings.")
-
 ;; The completion process filter indicates when it is finished.
 (defvar gud-gdb-fetch-lines-in-progress)
 
@@ -884,9 +893,14 @@ It is passed through `gud-gdb-marker-filter' before we look at it."
 
 ;; gdb speedbar functions
 
+;; Part of the macro expansion of dframe-with-attached-buffer.
+;; At runtime, will be pulled in as a require of speedbar.
+(declare-function dframe-select-attached-frame "dframe" (&optional frame))
+(declare-function dframe-maybee-jump-to-attached-frame "dframe" ())
+
 (defun gud-gdb-goto-stackframe (_text token _indent)
   "Goto the stackframe described by TEXT, TOKEN, and INDENT."
-  (speedbar-with-attached-buffer
+  (dframe-with-attached-buffer
    (gud-basic-call (concat "server frame " (nth 1 token)))
    (sit-for 1)))
 
@@ -1487,14 +1501,38 @@ into one that invokes an Emacs-enabled debugging session.
   (let ((output ""))
 
     ;; Process all the complete markers in this chunk.
-    (while (string-match "\032\032\\(\\([a-zA-Z]:\\)?[^:\n]*\\):\\([0-9]*\\):.*\n"
-                         gud-marker-acc)
+    ;;
+    ;; Here I match the string coming out of perldb.
+    ;; The strings can look like any of
+    ;;
+    ;;  "\032\032/tmp/tst.pl:6:0\n"
+    ;;  "\032\032(eval 5)[/tmp/tst.pl:6]:3:0\n"
+    ;;  "\032\032(eval 17)[Basic/Core/Core.pm.PL (i.e. PDL::Core.pm):2931]:1:0\n"
+    ;;
+    ;; From those I want the filename and the line number.  First I look for
+    ;; the eval case.  If that doesn't match, I look for the "normal" case.
+    (while
+        (string-match
+         (eval-when-compile
+           (let ((file-re "\\(?:[a-zA-Z]:\\)?[^:\n]*"))
+             (concat "\032\032\\(?:"
+                     (concat
+                      "(eval [0-9]+)\\["
+                      "\\(" file-re "\\)" ; Filename.
+                      "\\(?: (i\\.e\\. [^)]*)\\)?"
+                      ":\\([0-9]*\\)\\]") ; Line number.
+                     "\\|"
+                     (concat
+                      "\\(?1:" file-re "\\)" ; Filename.
+                      ":\\(?2:[0-9]*\\)")    ; Line number.
+                     "\\):.*\n")))
+         gud-marker-acc)
       (setq
 
        ;; Extract the frame position from the marker.
        gud-last-frame
        (cons (match-string 1 gud-marker-acc)
-             (string-to-number (match-string 3 gud-marker-acc)))
+             (string-to-number (match-string 2 gud-marker-acc)))
 
        ;; Append any text before the marker to the output we're going
        ;; to return - we don't include the marker in this text.
@@ -2612,6 +2650,8 @@ It is saved for when this flag is not set.")
 (add-to-list 'overlay-arrow-variable-list 'gud-overlay-arrow-position)
 
 (declare-function gdb-reset "gdb-mi" ())
+(declare-function speedbar-change-initial-expansion-list "speedbar" (new))
+(defvar speedbar-previously-used-expansion-list-name)
 
 (defun gud-sentinel (proc msg)
   (cond ((null (buffer-name (process-buffer proc)))
@@ -2619,7 +2659,7 @@ It is saved for when this flag is not set.")
          ;; Stop displaying an arrow in a source file.
          (setq gud-overlay-arrow-position nil)
          (set-process-buffer proc nil)
-         (if (and (boundp 'speedbar-frame)
+         (if (and (boundp 'speedbar-initial-expansion-list-name)
                   (string-equal speedbar-initial-expansion-list-name "GUD"))
              (speedbar-change-initial-expansion-list
               speedbar-previously-used-expansion-list-name))
@@ -3312,6 +3352,9 @@ only tooltips in the buffer containing the overlay arrow."
   :group 'gud
   :group 'tooltip)
 
+(make-obsolete-variable 'gud-tooltip-echo-area
+                        "disable Tooltip mode instead" "24.4" 'set)
+
 ;;; Reacting on mouse movements
 
 (defun gud-tooltip-change-major-mode ()
@@ -3363,9 +3406,6 @@ ACTIVATEP non-nil means activate mouse motion events."
 
 ;;; Tips for `gud'
 
-(defvar gud-tooltip-original-filter nil
-  "Process filter to restore after GUD output has been received.")
-
 (defvar gud-tooltip-dereference nil
   "Non-nil means print expressions with a `*' in front of them.
 For C this would dereference a pointer expression.")
@@ -3396,12 +3436,13 @@ With arg, dereference expr if ARG is positive, otherwise do not dereference."
 ; 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 GDB/MI as in
-; gdb-mi.el gets round this problem.
+; gdb-mi.el gets around this problem.
 (defun gud-tooltip-process-output (process output)
   "Process debugger output and show it in a tooltip window."
-  (set-process-filter process gud-tooltip-original-filter)
+  (remove-function (process-filter process) #'gud-tooltip-process-output)
   (tooltip-show (tooltip-strip-prompt process output)
-                (or gud-tooltip-echo-area tooltip-use-echo-area)))
+                (or gud-tooltip-echo-area tooltip-use-echo-area
+                    (not tooltip-mode))))
 
 (defun gud-tooltip-print-command (expr)
   "Return a suitable command to print the expression EXPR."
@@ -3411,7 +3452,7 @@ With arg, dereference expr if ARG is positive, otherwise do not dereference."
     ((or `xdb `pdb) (concat "p " expr))
     (`sdb (concat expr "/"))))
 
-(declare-function gdb-input "gdb-mi" (command handler))
+(declare-function gdb-input "gdb-mi" (command handler &optional trigger))
 (declare-function tooltip-expr-to-print "tooltip" (event))
 (declare-function tooltip-event-buffer "tooltip" (event))
 
@@ -3444,7 +3485,8 @@ This function must return nil if it doesn't handle EVENT."
                     (unless (null define-elt)
                       (tooltip-show
                        (cdr define-elt)
-                       (or gud-tooltip-echo-area tooltip-use-echo-area))
+                       (or gud-tooltip-echo-area tooltip-use-echo-area
+                           (not tooltip-mode)))
                       expr))))
             (when gud-tooltip-dereference
               (setq expr (concat "*" expr)))
@@ -3466,8 +3508,8 @@ so they have been disabled."))
                       (gdb-input
                        (concat cmd "\n")
                        `(lambda () (gdb-tooltip-print ,expr))))
-                  (setq gud-tooltip-original-filter (process-filter process))
-                  (set-process-filter process 'gud-tooltip-process-output)
+                  (add-function :override (process-filter process)
+                                #'gud-tooltip-process-output)
                   (gud-basic-call cmd))
                 expr))))))))
 
diff --git a/lisp/progmodes/idlw-help.el b/lisp/progmodes/idlw-help.el
index 749b0b65576..7060cae5080 100644
--- a/lisp/progmodes/idlw-help.el
+++ b/lisp/progmodes/idlw-help.el
@@ -90,16 +90,15 @@ Defaults to `browse-url-browser-function', which see."
 (defcustom idlwave-help-browser-generic-program browse-url-generic-program
   "Program to run if using `browse-url-generic-program'."
   :group 'idlwave-online-help
-  :type 'string)
-
-(defvar browse-url-generic-args)
+  :type '(choice (const nil) string))
 
+;; AFAICS, never used since it was introduced in 2004.
 (defcustom idlwave-help-browser-generic-args
   (if (boundp 'browse-url-generic-args)
       browse-url-generic-args "")
   "Program args to use if using `browse-url-generic-program'."
   :group 'idlwave-online-help
-  :type 'string)
+  :type '(repeat string))
 
 (defcustom idlwave-help-browser-is-local nil
   "Whether the browser will display locally in an Emacs window.
@@ -1179,7 +1178,7 @@ Useful when source code is displayed as help.  See the option
   (if (featurep 'font-lock)
       (let ((major-mode 'idlwave-mode)
             (font-lock-verbose
-             (if (interactive-p) font-lock-verbose nil))
+             (if (called-interactively-p 'interactive) font-lock-verbose nil))
             (syntax-table (syntax-table)))
         (unwind-protect
             (progn
diff --git a/lisp/progmodes/idlwave.el b/lisp/progmodes/idlwave.el
index aeaf1acb2ac..ba9a632b949 100644
--- a/lisp/progmodes/idlwave.el
+++ b/lisp/progmodes/idlwave.el
@@ -5078,11 +5078,14 @@ Cache to disk for quick recovery."
   ;; 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
-          (append idlwave-buffer-routines
-                  idlwave-compiled-routines
-                  idlwave-library-catalog-routines
-                  idlwave-user-catalog-routines))
+  (let ((temp (append idlwave-buffer-routines
+                      idlwave-compiled-routines
+                      idlwave-library-catalog-routines
+                      idlwave-user-catalog-routines)))
+    ;; Not actually used for anything?
+    (if idlwave-last-system-routine-info-cons-cell
+        (setcdr idlwave-last-system-routine-info-cons-cell temp)
+      (setq idlwave-last-system-routine-info-cons-cell (cons temp nil))))
   (setq idlwave-class-alist nil)
 
   ;; Give a message with information about the number of routines we have.
@@ -5481,30 +5484,21 @@ directories and save the routine info.
     (message "Creating user catalog file...")
     (kill-buffer "*idlwave-scan.pro*")
     (kill-buffer (get-buffer-create "*IDLWAVE Widget*"))
-    (let ((font-lock-maximum-size 0)
-          (auto-mode-alist nil))
-      (find-file idlwave-user-catalog-file))
-    (if (and (boundp 'font-lock-mode)
-             font-lock-mode)
-        (font-lock-mode 0))
-    (erase-buffer)
-    (insert ";; IDLWAVE user catalog file\n")
-    (insert (format ";; Created %s\n\n" (current-time-string)))
-
-    ;; Define the routine info list
-    (insert "\n(setq idlwave-user-catalog-routines\n    '(")
-    (let ((standard-output (current-buffer)))
-      (mapc (lambda (x)
-              (insert "\n    ")
-              (prin1 x)
-              (goto-char (point-max)))
-            idlwave-user-catalog-routines))
-    (insert (format "))\n\n;;; %s ends here\n"
-                    (file-name-nondirectory idlwave-user-catalog-file)))
-    (goto-char (point-min))
-    ;; Save the buffer
-    (save-buffer 0)
-    (kill-buffer (current-buffer)))
+    (with-temp-buffer
+      (insert ";; IDLWAVE user catalog file\n")
+      (insert (format ";; Created %s\n\n" (current-time-string)))
+
+      ;; Define the routine info list
+      (insert "\n(setq idlwave-user-catalog-routines\n    '(")
+      (let ((standard-output (current-buffer)))
+        (mapc (lambda (x)
+                (insert "\n    ")
+                (prin1 x)
+                (goto-char (point-max)))
+              idlwave-user-catalog-routines))
+      (insert (format "))\n\n;;; %s ends here\n"
+                      (file-name-nondirectory idlwave-user-catalog-file)))
+      (write-region nil nil idlwave-user-catalog-file)))
   (message "Creating user catalog file...done")
   (message "Info for %d routines saved in %s"
            (length idlwave-user-catalog-routines)
@@ -5522,31 +5516,23 @@ directories and save the routine info.
 (defun idlwave-write-paths ()
   (interactive)
   (when (and idlwave-path-alist idlwave-system-directory)
-    (let ((font-lock-maximum-size 0)
-          (auto-mode-alist nil))
-      (find-file idlwave-path-file))
-    (if (and (boundp 'font-lock-mode)
-             font-lock-mode)
-        (font-lock-mode 0))
-    (erase-buffer)
-    (insert ";; IDLWAVE paths\n")
-    (insert (format ";; Created %s\n\n" (current-time-string)))
+    (with-temp-buffer
+      (insert ";; IDLWAVE paths\n")
+      (insert (format ";; Created %s\n\n" (current-time-string)))
     ;; 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)))
-      (mapc (lambda (x)
-              (insert "\n      ")
-              (prin1 x)
-              (goto-char (point-max)))
-            idlwave-path-alist))
-    (insert "))\n")
-    (save-buffer 0)
-    (kill-buffer (current-buffer))))
-
+      (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)))
+        (mapc (lambda (x)
+                (insert "\n      ")
+                (prin1 x)
+                (goto-char (point-max)))
+              idlwave-path-alist))
+      (insert "))\n")
+      (write-region nil nil idlwave-path-file))))
 
 (defun idlwave-expand-path (path &optional default-dir)
   ;; Expand parts of path starting with '+' recursively into directory list.
diff --git a/lisp/progmodes/js.el b/lisp/progmodes/js.el
index 2ea78fc321c..28ee859f9db 100644
--- a/lisp/progmodes/js.el
+++ b/lisp/progmodes/js.el
@@ -55,7 +55,6 @@
 
 (eval-when-compile
   (require 'cl-lib)
-  (require 'comint)
   (require 'ido))
 
 (defvar inferior-moz-buffer)
@@ -2217,6 +2216,9 @@ marker."
 
 (defvar find-tag-marker-ring)           ; etags
 
+;; etags loads ring.
+(declare-function ring-insert "ring" (ring item))
+
 (defun js-find-symbol (&optional arg)
   "Read a JavaScript symbol and jump to it.
 With a prefix argument, restrict symbols to those from the
@@ -2639,6 +2641,11 @@ with `js--js-encode-value'."
    ;; order to catch a prompt that's only partially arrived
    (save-excursion (forward-line 0) (point))))
 
+;; Presumably "inferior-moz-process" loads comint.
+(declare-function comint-send-string "comint" (process string))
+(declare-function comint-send-input "comint"
+                  (&optional no-newline artificial))
+
 (defun js--js-enter-repl ()
   (inferior-moz-process) ; called for side-effect
   (with-current-buffer inferior-moz-buffer
@@ -2697,6 +2704,10 @@ with `js--js-encode-value'."
 (defsubst js--js-true (value)
   (not (js--js-not value)))
 
+;; The somewhat complex code layout confuses the byte-compiler into
+;; thinking this function "might not be defined at runtime".
+(declare-function js--optimize-arglist "js" (arglist))
+
 (eval-and-compile
   (defun js--optimize-arglist (arglist)
     "Convert immediate js< and js! references to deferred ones."
@@ -2824,6 +2835,8 @@ If nil, the whole Array is treated as a JS symbol.")
     (`error (signal 'js-js-error (list (cl-second result))))
     (x (error "Unmatched case in js--js-decode-retval: %S" x))))
 
+(defvar comint-last-input-end)
+
 (defun js--js-funcall (function &rest arguments)
   "Call the Mozilla function FUNCTION with arguments ARGUMENTS.
 If function is a string, look it up as a property on the global
@@ -2996,6 +3009,8 @@ left-to-right."
 
 (defvar js-read-tab-history nil)
 
+(declare-function ido-chop "ido" (items elem))
+
 (defun js--read-tab (prompt)
   "Read a Mozilla tab with prompt PROMPT.
 Return a cons of (TYPE . OBJECT).  TYPE is either 'window or
diff --git a/lisp/progmodes/ld-script.el b/lisp/progmodes/ld-script.el
index 34d1525bbab..ffb425ee1e9 100644
--- a/lisp/progmodes/ld-script.el
+++ b/lisp/progmodes/ld-script.el
@@ -48,7 +48,7 @@
     (modify-syntax-entry ?\) ")(" st)
     (modify-syntax-entry ?\[ "(]" st)
     (modify-syntax-entry ?\] ")[" st)
-    (modify-syntax-entry ?_ "w"   st)
+    (modify-syntax-entry ?_ "_"   st)
     (modify-syntax-entry ?. "_"   st)
     (modify-syntax-entry ?\\  "\\" st)
     (modify-syntax-entry ?: "." st)
@@ -154,10 +154,10 @@
 
 (defvar ld-script-font-lock-keywords
   (append
-   `((,(regexp-opt ld-script-keywords 'words)
-      1 font-lock-keyword-face)
-     (,(regexp-opt ld-script-builtins 'words)
-      1 font-lock-builtin-face)
+   `((,(concat "\\_<" (regexp-opt ld-script-keywords) "\\_>")
+      0 font-lock-keyword-face)
+     (,(concat "\\_<" (regexp-opt ld-script-builtins) "\\_>")
+      0 font-lock-builtin-face)
      ;; 3.6.7 Output Section Discarding
      ;; 3.6.4.1 Input Section Basics
      ;; 3.6.8.7 Output Section Phdr
diff --git a/lisp/progmodes/m4-mode.el b/lisp/progmodes/m4-mode.el
index 0641fc776de..4ba2ae1ded9 100644
--- a/lisp/progmodes/m4-mode.el
+++ b/lisp/progmodes/m4-mode.el
@@ -45,15 +45,10 @@
   :prefix "m4-"
   :group 'languages)
 
-(defcustom m4-program
-  (cond
-   ((file-exists-p "/usr/local/bin/m4") "/usr/local/bin/m4")
-   ((file-exists-p "/usr/bin/m4") "/usr/bin/m4")
-   ((file-exists-p "/bin/m4") "/bin/m4")
-   ((file-exists-p "/usr/ccs/bin/m4") "/usr/ccs/bin/m4")
-   ( t "m4")
-   )
-  "File name of the m4 executable."
+(defcustom m4-program "m4"
+  "File name of the m4 executable.
+If m4 is not in your PATH, set this to an absolute file name."
+  :version "24.4"
   :type 'file
   :group 'm4)
 
@@ -85,19 +80,24 @@
   :group 'm4)
 
 ;;this may still need some work
-(defvar m4-mode-syntax-table nil
+(defvar m4-mode-syntax-table
+  (let ((table (make-syntax-table)))
+    (modify-syntax-entry ?` "('" table)
+    (modify-syntax-entry ?' ")`" table)
+    (modify-syntax-entry ?# "<\n" table)
+    (modify-syntax-entry ?\n ">#" table)
+    (modify-syntax-entry ?{  "_" table)
+    (modify-syntax-entry ?}  "_" table)
+    ;; FIXME: This symbol syntax for underscore looks OK on its own, but it's
+    ;; odd that it should have the same syntax as { and } are these really
+    ;; valid in m4 symbols?
+    (modify-syntax-entry ?_  "_" table)
+    ;; FIXME: These three chars with word syntax look wrong.
+    (modify-syntax-entry ?*  "w" table)
+    (modify-syntax-entry ?\"  "w" table)
+    (modify-syntax-entry ?\"  "w" table)
+    table)
   "Syntax table used while in `m4-mode'.")
-(setq m4-mode-syntax-table (make-syntax-table))
-(modify-syntax-entry ?` "('" m4-mode-syntax-table)
-(modify-syntax-entry ?' ")`" m4-mode-syntax-table)
-(modify-syntax-entry ?# "<\n" m4-mode-syntax-table)
-(modify-syntax-entry ?\n ">#" m4-mode-syntax-table)
-(modify-syntax-entry ?{  "_" m4-mode-syntax-table)
-(modify-syntax-entry ?}  "_" m4-mode-syntax-table)
-(modify-syntax-entry ?*  "w" m4-mode-syntax-table)
-(modify-syntax-entry ?_  "w" m4-mode-syntax-table)
-(modify-syntax-entry ?\"  "w" m4-mode-syntax-table)
-(modify-syntax-entry ?\"  "w" m4-mode-syntax-table)
 
 (defvar m4-mode-map
   (let ((map (make-sparse-keymap))
@@ -117,12 +117,6 @@
                   :help "Send contents of the current region to m4"))
     map))
 
-(defvar m4-mode-abbrev-table nil
-  "Abbrev table used while in `m4-mode'.")
-
-(unless m4-mode-abbrev-table
-  (define-abbrev-table 'm4-mode-abbrev-table ()))
-
 (defun m4-m4-buffer ()
   "Send contents of the current buffer to m4."
   (interactive)
@@ -151,7 +145,6 @@
 ;;;###autoload
 (define-derived-mode m4-mode prog-mode "m4"
   "A major mode to edit m4 macro files."
-  :abbrev-table m4-mode-abbrev-table
   (setq-local comment-start "#")
   (setq-local parse-sexp-ignore-comments t)
   (setq-local add-log-current-defun-function #'m4-current-defun-name)
diff --git a/lisp/progmodes/make-mode.el b/lisp/progmodes/make-mode.el
index 20673866bc4..3069c790e1c 100644
--- a/lisp/progmodes/make-mode.el
+++ b/lisp/progmodes/make-mode.el
@@ -241,7 +241,7 @@ to MODIFY A FILE WITHOUT YOUR CONFIRMATION when \"it seems necessary\"."
   "List of special targets.
 You will be offered to complete on one of those in the minibuffer whenever
 you enter a \".\" at the beginning of a line in `makefile-mode'."
-  :type '(repeat (list string))
+  :type '(repeat string)
   :group 'makefile)
 (put 'makefile-special-targets-list 'risky-local-variable t)
 
diff --git a/lisp/progmodes/meta-mode.el b/lisp/progmodes/meta-mode.el
index b090435ac9b..6a150667f19 100644
--- a/lisp/progmodes/meta-mode.el
+++ b/lisp/progmodes/meta-mode.el
@@ -794,6 +794,7 @@ The environment marked is the one that contains point or follows point."
 
 (defvar meta-common-mode-syntax-table
   (let ((st (make-syntax-table)))
+    ;; FIXME: This goes against the convention!
     ;; underscores are word constituents
     (modify-syntax-entry ?_  "w"  st)
     ;; miscellaneous non-word symbols
diff --git a/lisp/progmodes/octave-inf.el b/lisp/progmodes/octave-inf.el
deleted file mode 100644
index de7ca32befe..00000000000
--- a/lisp/progmodes/octave-inf.el
+++ /dev/null
@@ -1,386 +0,0 @@
-;;; octave-inf.el --- running Octave as an inferior Emacs process
-
-;; Copyright (C) 1997, 2001-2013 Free Software Foundation, Inc.
-
-;; Author: Kurt Hornik <Kurt.Hornik@wu-wien.ac.at>
-;;         John Eaton <jwe@bevo.che.wisc.edu>
-;; Maintainer: FSF
-;; Keywords: languages
-;; Package: octave-mod
-
-;; This file is part of GNU Emacs.
-
-;; GNU Emacs is free software: you can redistribute it and/or modify
-;; it under the terms of the GNU General Public License as published by
-;; the Free Software Foundation, either version 3 of the License, or
-;; (at your option) any later version.
-
-;; GNU Emacs is distributed in the hope that it will be useful,
-;; but WITHOUT ANY WARRANTY; without even the implied warranty of
-;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-;; GNU General Public License for more details.
-
-;; You should have received a copy of the GNU General Public License
-;; along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.
-
-;;; Commentary:
-
-;;; Code:
-
-(require 'octave-mod)
-(require 'comint)
-
-(defgroup octave-inferior nil
-  "Running Octave as an inferior Emacs process."
-  :group 'octave)
-
-(defcustom inferior-octave-program "octave"
-  "Program invoked by `inferior-octave'."
-  :type 'string
-  :group 'octave-inferior)
-
-(defcustom inferior-octave-prompt
-  "\\(^octave\\(\\|.bin\\|.exe\\)\\(-[.0-9]+\\)?\\(:[0-9]+\\)?\\|^debug\\|^\\)>+ "
-  "Regexp to match prompts for the inferior Octave process."
-  :type 'regexp
-  :group 'octave-inferior)
-
-(defcustom inferior-octave-startup-file nil
-  "Name of the inferior Octave startup file.
-The contents of this file are sent to the inferior Octave process on
-startup."
-  :type '(choice (const :tag "None" nil)
-                 file)
-  :group 'octave-inferior)
-
-(defcustom inferior-octave-startup-args nil
-  "List of command line arguments for the inferior Octave process.
-For example, for suppressing the startup message and using `traditional'
-mode, set this to (\"-q\" \"--traditional\")."
-  :type '(repeat string)
-  :group 'octave-inferior)
-
-(defvar inferior-octave-mode-map
-  (let ((map (make-sparse-keymap)))
-    (set-keymap-parent map comint-mode-map)
-    (define-key map "\t" 'comint-dynamic-complete)
-    (define-key map "\M-?" 'comint-dynamic-list-filename-completions)
-    (define-key map "\C-c\C-l" 'inferior-octave-dynamic-list-input-ring)
-    (define-key map [menu-bar inout list-history]
-      '("List Input History" . inferior-octave-dynamic-list-input-ring))
-    ;; FIXME: free C-h so it can do the describe-prefix-bindings.
-    (define-key map "\C-c\C-h" 'info-lookup-symbol)
-    map)
-  "Keymap used in Inferior Octave mode.")
-
-(defvar inferior-octave-mode-syntax-table
-  (let ((table (make-syntax-table octave-mode-syntax-table)))
-    table)
-  "Syntax table in use in inferior-octave-mode buffers.")
-
-(defcustom inferior-octave-mode-hook nil
-  "Hook to be run when Inferior Octave mode is started."
-  :type 'hook
-  :group 'octave-inferior)
-
-(defvar inferior-octave-font-lock-keywords
-  (list
-   (cons inferior-octave-prompt 'font-lock-type-face))
-  ;; Could certainly do more font locking in inferior Octave ...
-  "Additional expressions to highlight in Inferior Octave mode.")
-
-
-;;; Compatibility functions
-(if (not (fboundp 'comint-line-beginning-position))
-    ;; comint-line-beginning-position is defined in Emacs 21
-    (defun comint-line-beginning-position ()
-      "Returns the buffer position of the beginning of the line, after any prompt.
-The prompt is assumed to be any text at the beginning of the line matching
-the regular expression `comint-prompt-regexp', a buffer local variable."
-      (save-excursion (comint-bol nil) (point))))
-
-
-(defvar inferior-octave-output-list nil)
-(defvar inferior-octave-output-string nil)
-(defvar inferior-octave-receive-in-progress nil)
-
-(defvar inferior-octave-startup-hook nil)
-
-(defvar inferior-octave-complete-impossible nil
-  "Non-nil means that `inferior-octave-complete' is impossible.")
-
-(defvar inferior-octave-has-built-in-variables nil
-  "Non-nil means that Octave has built-in variables.")
-
-(defvar inferior-octave-dynamic-complete-functions
-  '(inferior-octave-completion-at-point comint-filename-completion)
-  "List of functions called to perform completion for inferior Octave.
-This variable is used to initialize `comint-dynamic-complete-functions'
-in the Inferior Octave buffer.")
-
-(defvar info-lookup-mode)
-
-(define-derived-mode inferior-octave-mode comint-mode "Inferior Octave"
-  "Major mode for interacting with an inferior Octave process.
-Runs Octave as a subprocess of Emacs, with Octave I/O through an Emacs
-buffer.
-
-Entry to this mode successively runs the hooks `comint-mode-hook' and
-`inferior-octave-mode-hook'."
-  (setq comint-prompt-regexp inferior-octave-prompt
-        mode-line-process '(":%s")
-        local-abbrev-table octave-abbrev-table)
-
-  (set (make-local-variable 'comment-start) octave-comment-start)
-  (set (make-local-variable 'comment-end) "")
-  (set (make-local-variable 'comment-column) 32)
-  (set (make-local-variable 'comment-start-skip) octave-comment-start-skip)
-
-  (set (make-local-variable 'font-lock-defaults)
-       '(inferior-octave-font-lock-keywords nil nil))
-
-  (set (make-local-variable 'info-lookup-mode) 'octave-mode)
-
-  (setq comint-input-ring-file-name
-        (or (getenv "OCTAVE_HISTFILE") "~/.octave_hist")
-        comint-input-ring-size (or (getenv "OCTAVE_HISTSIZE") 1024))
-  (set (make-local-variable 'comint-dynamic-complete-functions)
-       inferior-octave-dynamic-complete-functions)
-  (add-hook 'comint-input-filter-functions
-        'inferior-octave-directory-tracker nil t)
-  (comint-read-input-ring t))
-
-;;;###autoload
-(defun inferior-octave (&optional arg)
-  "Run an inferior Octave process, I/O via `inferior-octave-buffer'.
-This buffer is put in Inferior Octave mode.  See `inferior-octave-mode'.
-
-Unless ARG is non-nil, switches to this buffer.
-
-The elements of the list `inferior-octave-startup-args' are sent as
-command line arguments to the inferior Octave process on startup.
-
-Additional commands to be executed on startup can be provided either in
-the file specified by `inferior-octave-startup-file' or by the default
-startup file, `~/.emacs-octave'."
-  (interactive "P")
-  (let ((buffer inferior-octave-buffer))
-    (get-buffer-create buffer)
-    (if (comint-check-proc buffer)
-        ()
-      (with-current-buffer buffer
-        (comint-mode)
-        (inferior-octave-startup)
-        (inferior-octave-mode)))
-    (if (not arg)
-        (pop-to-buffer buffer))))
-
-;;;###autoload
-(defalias 'run-octave 'inferior-octave)
-
-(defun inferior-octave-startup ()
-  "Start an inferior Octave process."
-  (let ((proc (comint-exec-1
-               (substring inferior-octave-buffer 1 -1)
-               inferior-octave-buffer
-               inferior-octave-program
-               (append (list "-i" "--no-line-editing")
-                       inferior-octave-startup-args))))
-    (set-process-filter proc 'inferior-octave-output-digest)
-    (setq comint-ptyp process-connection-type
-          inferior-octave-process proc
-          inferior-octave-output-list nil
-          inferior-octave-output-string nil
-          inferior-octave-receive-in-progress t)
-
-    ;; This may look complicated ... However, we need to make sure that
-    ;; we additional startup code only AFTER Octave is ready (otherwise,
-    ;; output may be mixed up).  Hence, we need to digest the Octave
-    ;; output to see when it issues a prompt.
-    (while inferior-octave-receive-in-progress
-      (accept-process-output inferior-octave-process))
-    (goto-char (point-max))
-    (set-marker (process-mark proc) (point))
-    (insert-before-markers
-     (concat
-      (if (not (bobp)) "\n")
-      (if inferior-octave-output-list
-          (concat (mapconcat
-                   'identity inferior-octave-output-list "\n")
-                  "\n"))))
-
-     ;; Find out whether Octave has built-in variables.
-     (inferior-octave-send-list-and-digest
-      (list "exist \"LOADPATH\"\n"))
-     (setq inferior-octave-has-built-in-variables
-          (string-match "101$" (car inferior-octave-output-list)))
-
-    ;; An empty secondary prompt, as e.g. obtained by '--braindead',
-    ;; means trouble.
-    (inferior-octave-send-list-and-digest (list "PS2\n"))
-    (if (string-match "\\(PS2\\|ans\\) = *$" (car inferior-octave-output-list))
-        (inferior-octave-send-list-and-digest
-         (list (if inferior-octave-has-built-in-variables
-                   "PS2 = \"> \"\n"
-                 "PS2 (\"> \");\n"))))
-
-    ;; O.k., now we are ready for the Inferior Octave startup commands.
-    (let* (commands
-           (program (file-name-nondirectory inferior-octave-program))
-           (file (or inferior-octave-startup-file
-                          (concat "~/.emacs-" program))))
-      (setq commands
-            (list "more off;\n"
-                  (if (not (string-equal
-                            inferior-octave-output-string ">> "))
-                      (if inferior-octave-has-built-in-variables
-                          "PS1=\"\\\\s> \";\n"
-                        "PS1 (\"\\\\s> \");\n"))
-                  (if (file-exists-p file)
-                      (format "source (\"%s\");\n" file))))
-      (inferior-octave-send-list-and-digest commands))
-    (insert-before-markers
-     (concat
-      (if inferior-octave-output-list
-          (concat (mapconcat
-                   'identity inferior-octave-output-list "\n")
-                  "\n"))
-      inferior-octave-output-string))
-    ;; Next, we check whether Octave supports `completion_matches' ...
-    (inferior-octave-send-list-and-digest
-     (list "exist \"completion_matches\"\n"))
-    (setq inferior-octave-complete-impossible
-          (not (string-match "5$" (car inferior-octave-output-list))))
-
-    ;; And finally, everything is back to normal.
-    (set-process-filter proc 'inferior-octave-output-filter)
-    (run-hooks 'inferior-octave-startup-hook)
-    (run-hooks 'inferior-octave-startup-hook)
-    ;; Just in case, to be sure a cd in the startup file
-    ;; won't have detrimental effects.
-    (inferior-octave-resync-dirs)))
-
-
-(defun inferior-octave-completion-at-point ()
-  "Return the data to complete the Octave symbol at point."
-  (let* ((end (point))
-         (start
-          (save-excursion
-            (skip-syntax-backward "w_" (comint-line-beginning-position))
-            (point))))
-    (cond ((eq start end) nil)
-          (inferior-octave-complete-impossible
-           (message (concat
-                     "Your Octave does not have `completion_matches'.  "
-                     "Please upgrade to version 2.X."))
-           nil)
-          (t
-           (list
-            start end
-            (completion-table-dynamic
-             (lambda (command)
-               (inferior-octave-send-list-and-digest
-                (list (concat "completion_matches (\"" command "\");\n")))
-               (sort (delete-dups inferior-octave-output-list)
-                     'string-lessp))))))))
-
-(define-obsolete-function-alias 'inferior-octave-complete
-  'completion-at-point "24.1")
-
-(defun inferior-octave-dynamic-list-input-ring ()
-  "List the buffer's input history in a help buffer."
-  ;; We cannot use `comint-dynamic-list-input-ring', because it replaces
-  ;; "completion" by "history reference" ...
-  (interactive)
-  (if (or (not (ring-p comint-input-ring))
-          (ring-empty-p comint-input-ring))
-      (message "No history")
-    (let ((history nil)
-          (history-buffer " *Input History*")
-          (index (1- (ring-length comint-input-ring)))
-          (conf (current-window-configuration)))
-      ;; We have to build up a list ourselves from the ring vector.
-      (while (>= index 0)
-        (setq history (cons (ring-ref comint-input-ring index) history)
-              index (1- index)))
-      ;; Change "completion" to "history reference"
-      ;; to make the display accurate.
-      (with-output-to-temp-buffer history-buffer
-        (display-completion-list history)
-        (set-buffer history-buffer))
-      (message "Hit space to flush")
-      (let ((ch (read-event)))
-        (if (eq ch ?\ )
-            (set-window-configuration conf)
-          (setq unread-command-events (list ch)))))))
-
-(defun inferior-octave-strip-ctrl-g (string)
-  "Strip leading `^G' character.
-If STRING starts with a `^G', ring the bell and strip it."
-  (if (string-match "^\a" string)
-      (progn
-        (ding)
-        (setq string (substring string 1))))
-  string)
-
-(defun inferior-octave-output-filter (proc string)
-  "Standard output filter for the inferior Octave process.
-Ring Emacs bell if process output starts with an ASCII bell, and pass
-the rest to `comint-output-filter'."
-  (comint-output-filter proc (inferior-octave-strip-ctrl-g string)))
-
-(defun inferior-octave-output-digest (_proc string)
-  "Special output filter for the inferior Octave process.
-Save all output between newlines into `inferior-octave-output-list', and
-the rest to `inferior-octave-output-string'."
-  (setq string (concat inferior-octave-output-string string))
-  (while (string-match "\n" string)
-    (setq inferior-octave-output-list
-          (append inferior-octave-output-list
-                  (list (substring string 0 (match-beginning 0))))
-          string (substring string (match-end 0))))
-  (if (string-match inferior-octave-prompt string)
-      (setq inferior-octave-receive-in-progress nil))
-  (setq inferior-octave-output-string string))
-
-(defun inferior-octave-send-list-and-digest (list)
-  "Send LIST to the inferior Octave process and digest the output.
-The elements of LIST have to be strings and are sent one by one.  All
-output is passed to the filter `inferior-octave-output-digest'."
-  (let* ((proc inferior-octave-process)
-         (filter (process-filter proc))
-         string)
-    (set-process-filter proc 'inferior-octave-output-digest)
-    (setq inferior-octave-output-list nil)
-    (unwind-protect
-        (while (setq string (car list))
-          (setq inferior-octave-output-string nil
-                inferior-octave-receive-in-progress t)
-          (comint-send-string proc string)
-          (while inferior-octave-receive-in-progress
-            (accept-process-output proc))
-          (setq list (cdr list)))
-      (set-process-filter proc filter))))
-
-(defun inferior-octave-directory-tracker (string)
-  "Tracks `cd' commands issued to the inferior Octave process.
-Use \\[inferior-octave-resync-dirs] to resync if Emacs gets confused."
-  (cond
-   ((string-match "^[ \t]*cd[ \t;]*$" string)
-    (cd "~"))
-   ((string-match "^[ \t]*cd[ \t]+\\([^ \t\n;]*\\)[ \t\n;]*" string)
-    (cd (substring string (match-beginning 1) (match-end 1))))))
-
-(defun inferior-octave-resync-dirs ()
-  "Resync the buffer's idea of the current directory.
-This command queries the inferior Octave process about its current
-directory and makes this the current buffer's default directory."
-  (interactive)
-  (inferior-octave-send-list-and-digest '("disp (pwd ())\n"))
-  (cd (car inferior-octave-output-list)))
-
-;;; provide ourself
-
-(provide 'octave-inf)
-
-;;; octave-inf.el ends here
diff --git a/lisp/progmodes/octave-mod.el b/lisp/progmodes/octave-mod.el
deleted file mode 100644
index 806afe5a537..00000000000
--- a/lisp/progmodes/octave-mod.el
+++ /dev/null
@@ -1,1152 +0,0 @@
-;;; octave-mod.el --- editing Octave source files under Emacs
-
-;; Copyright (C) 1997, 2001-2013 Free Software Foundation, Inc.
-
-;; Author: Kurt Hornik <Kurt.Hornik@wu-wien.ac.at>
-;;         John Eaton <jwe@octave.org>
-;; Maintainer: FSF
-;; Keywords: languages
-
-;; This file is part of GNU Emacs.
-
-;; GNU Emacs is free software: you can redistribute it and/or modify
-;; it under the terms of the GNU General Public License as published by
-;; the Free Software Foundation, either version 3 of the License, or
-;; (at your option) any later version.
-
-;; GNU Emacs is distributed in the hope that it will be useful,
-;; but WITHOUT ANY WARRANTY; without even the implied warranty of
-;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-;; GNU General Public License for more details.
-
-;; You should have received a copy of the GNU General Public License
-;; along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.
-
-;;; Commentary:
-
-;; This package provides Emacs support for Octave.
-;; It defines Octave mode, a major mode for editing
-;; Octave code.
-
-;; The file octave-inf.el contains code for interacting with an inferior
-;; Octave process using comint.
-
-;; See the documentation of `octave-mode' and
-;; `run-octave' for further information on usage and customization.
-
-;;; Code:
-(require 'custom)
-
-(defgroup octave nil
-  "Major mode for editing Octave source files."
-  :link '(custom-group-link :tag "Font Lock Faces group" font-lock-faces)
-  :group 'languages)
-
-(defvar inferior-octave-output-list nil)
-(defvar inferior-octave-output-string nil)
-(defvar inferior-octave-receive-in-progress nil)
-
-(declare-function inferior-octave-send-list-and-digest "octave-inf" (list))
-
-(defconst octave-maintainer-address
-  "Kurt Hornik <Kurt.Hornik@wu-wien.ac.at>, bug-gnu-emacs@gnu.org"
-  "Current maintainer of the Emacs Octave package.")
-
-(define-abbrev-table 'octave-abbrev-table
-  (mapcar (lambda (e) (append e '(nil 0 t)))
-          '(("`a" "all_va_args")
-            ("`b" "break")
-            ("`cs" "case")
-            ("`ca" "catch")
-            ("`c" "continue")
-            ("`el" "else")
-            ("`eli" "elseif")
-            ("`et" "end_try_catch")
-            ("`eu" "end_unwind_protect")
-            ("`ef" "endfor")
-            ("`efu" "endfunction")
-            ("`ei" "endif")
-            ("`es" "endswitch")
-            ("`ew" "endwhile")
-            ("`f" "for")
-            ("`fu" "function")
-            ("`gl" "global")
-            ("`gp" "gplot")
-            ("`gs" "gsplot")
-            ("`if" "if ()")
-            ("`o" "otherwise")
-            ("`rp" "replot")
-            ("`r" "return")
-            ("`s" "switch")
-            ("`t" "try")
-            ("`u" "until ()")
-            ("`up" "unwind_protect")
-            ("`upc" "unwind_protect_cleanup")
-            ("`w" "while ()")))
-  "Abbrev table for Octave's reserved words.
-Used in `octave-mode' and inferior-octave-mode buffers.
-All Octave abbrevs start with a grave accent (`)."
-  :regexp "\\(?:[^`]\\|^\\)\\(\\(?:\\<\\|`\\)\\w+\\)\\W*")
-
-(defvar octave-comment-char ?#
-  "Character to start an Octave comment.")
-(defvar octave-comment-start
-  (string octave-comment-char ?\s)
-  "String to insert to start a new Octave in-line comment.")
-(defvar octave-comment-start-skip "\\s<+\\s-*"
-  "Regexp to match the start of an Octave comment up to its body.")
-
-(defvar octave-begin-keywords
-  '("do" "for" "function" "if" "switch" "try" "unwind_protect" "while"))
-(defvar octave-else-keywords
-  '("case" "catch" "else" "elseif" "otherwise" "unwind_protect_cleanup"))
-(defvar octave-end-keywords
-  '("endfor" "endfunction" "endif" "endswitch" "end_try_catch"
-    "end_unwind_protect" "endwhile" "until" "end"))
-
-(defvar octave-reserved-words
-  (append octave-begin-keywords
-          octave-else-keywords
-          octave-end-keywords
-          '("break" "continue" "end" "global" "persistent" "return"))
-  "Reserved words in Octave.")
-
-(defvar octave-text-functions
-  '("casesen" "cd" "chdir" "clear" "diary" "dir" "document" "echo"
-    "edit_history" "format" "help" "history" "hold"
-    "load" "ls" "more" "run_history" "save" "type"
-    "which" "who" "whos")
-  "Text functions in Octave.")
-
-(defvar octave-variables
-  '("DEFAULT_EXEC_PATH" "DEFAULT_LOADPATH"
-    "EDITOR" "EXEC_PATH" "F_DUPFD" "F_GETFD" "F_GETFL" "F_SETFD"
-    "F_SETFL" "I" "IMAGE_PATH" "Inf" "J"
-    "NaN" "OCTAVE_VERSION" "O_APPEND" "O_CREAT" "O_EXCL"
-    "O_NONBLOCK" "O_RDONLY" "O_RDWR" "O_TRUNC" "O_WRONLY" "PAGER" "PS1"
-    "PS2" "PS4" "PWD" "SEEK_CUR" "SEEK_END" "SEEK_SET" "__F_DUPFD__"
-    "__F_GETFD__" "__F_GETFL__" "__F_SETFD__" "__F_SETFL__" "__I__"
-    "__Inf__" "__J__" "__NaN__" "__OCTAVE_VERSION__" "__O_APPEND__"
-    "__O_CREAT__" "__O_EXCL__" "__O_NONBLOCK__" "__O_RDONLY__"
-    "__O_RDWR__" "__O_TRUNC__" "__O_WRONLY__" "__PWD__" "__SEEK_CUR__"
-    "__SEEK_END__" "__SEEK_SET__" "__argv__" "__e__" "__eps__"
-    "__i__" "__inf__" "__j__" "__nan__" "__pi__"
-    "__program_invocation_name__" "__program_name__" "__realmax__"
-    "__realmin__" "__stderr__" "__stdin__" "__stdout__" "ans" "argv"
-    "beep_on_error" "completion_append_char"
-    "crash_dumps_octave_core" "default_save_format"
-    "e" "echo_executing_commands" "eps"
-    "error_text" "gnuplot_binary" "history_file"
-    "history_size" "ignore_function_time_stamp"
-    "inf" "nan" "nargin" "output_max_field_width" "output_precision"
-    "page_output_immediately" "page_screen_output" "pi"
-    "print_answer_id_name" "print_empty_dimensions"
-    "program_invocation_name" "program_name"
-    "realmax" "realmin" "return_last_computed_value" "save_precision"
-    "saving_history" "sighup_dumps_octave_core" "sigterm_dumps_octave_core"
-    "silent_functions" "split_long_rows" "stderr" "stdin" "stdout"
-    "string_fill_char" "struct_levels_to_print"
-    "suppress_verbose_help_message")
-  "Builtin variables in Octave.")
-
-(defvar octave-function-header-regexp
-  (concat "^\\s-*\\_<\\(function\\)\\_>"
-          "\\([^=;\n]*=[ \t]*\\|[ \t]*\\)\\(\\(?:\\w\\|\\s_\\)+\\)\\_>")
-  "Regexp to match an Octave function header.
-The string `function' and its name are given by the first and third
-parenthetical grouping.")
-
-(defvar octave-font-lock-keywords
-  (list
-   ;; Fontify all builtin keywords.
-   (cons (concat "\\_<\\("
-                 (regexp-opt (append octave-reserved-words
-                                     octave-text-functions))
-                 "\\)\\_>")
-         'font-lock-keyword-face)
-   ;; Fontify all builtin operators.
-   (cons "\\(&\\||\\|<=\\|>=\\|==\\|<\\|>\\|!=\\|!\\)"
-         (if (boundp 'font-lock-builtin-face)
-             'font-lock-builtin-face
-           'font-lock-preprocessor-face))
-   ;; Fontify all builtin variables.
-   (cons (concat "\\_<" (regexp-opt octave-variables) "\\_>")
-         'font-lock-variable-name-face)
-   ;; Fontify all function declarations.
-   (list octave-function-header-regexp
-         '(1 font-lock-keyword-face)
-         '(3 font-lock-function-name-face nil t)))
-  "Additional Octave expressions to highlight.")
-
-(defun octave-syntax-propertize-function (start end)
-  (goto-char start)
-  (octave-syntax-propertize-sqs end)
-  (funcall (syntax-propertize-rules
-            ;; Try to distinguish the string-quotes from the transpose-quotes.
-            ("[[({,; ]\\('\\)"
-             (1 (prog1 "\"'" (octave-syntax-propertize-sqs end)))))
-           (point) end))
-
-(defun octave-syntax-propertize-sqs (end)
-  "Propertize the content/end of single-quote strings."
-  (when (eq (nth 3 (syntax-ppss)) ?\')
-    ;; A '..' string.
-    (when (re-search-forward
-           "\\(?:\\=\\|[^']\\)\\(?:''\\)*\\('\\)\\($\\|[^']\\)" end 'move)
-      (goto-char (match-beginning 2))
-      (when (eq (char-before (match-beginning 1)) ?\\)
-        ;; Backslash cannot escape a single quote.
-        (put-text-property (1- (match-beginning 1)) (match-beginning 1)
-                           'syntax-table (string-to-syntax ".")))
-      (put-text-property (match-beginning 1) (match-end 1)
-                         'syntax-table (string-to-syntax "\"'")))))
-
-(defcustom inferior-octave-buffer "*Inferior Octave*"
-  "Name of buffer for running an inferior Octave process."
-  :type 'string
-  :group 'octave-inferior)
-
-(defvar inferior-octave-process nil)
-
-(defvar octave-mode-map
-  (let ((map (make-sparse-keymap)))
-    (define-key map "`" 'octave-abbrev-start)
-    (define-key map "\e\n" 'octave-indent-new-comment-line)
-    (define-key map "\M-\C-q" 'octave-indent-defun)
-    (define-key map "\C-c\C-b" 'octave-submit-bug-report)
-    (define-key map "\C-c\C-p" 'octave-previous-code-line)
-    (define-key map "\C-c\C-n" 'octave-next-code-line)
-    (define-key map "\C-c\C-a" 'octave-beginning-of-line)
-    (define-key map "\C-c\C-e" 'octave-end-of-line)
-    (define-key map [remap down-list] 'smie-down-list)
-    (define-key map "\C-c\M-\C-h" 'octave-mark-block)
-    (define-key map "\C-c]" 'smie-close-block)
-    (define-key map "\C-c/" 'smie-close-block)
-    (define-key map "\C-c\C-f" 'octave-insert-defun)
-    ;; FIXME: free C-h so it can do the describe-prefix-bindings.
-    (define-key map "\C-c\C-h" 'info-lookup-symbol)
-    (define-key map "\C-c\C-il" 'octave-send-line)
-    (define-key map "\C-c\C-ib" 'octave-send-block)
-    (define-key map "\C-c\C-if" 'octave-send-defun)
-    (define-key map "\C-c\C-ir" 'octave-send-region)
-    (define-key map "\C-c\C-is" 'octave-show-process-buffer)
-    (define-key map "\C-c\C-ih" 'octave-hide-process-buffer)
-    (define-key map "\C-c\C-ik" 'octave-kill-process)
-    (define-key map "\C-c\C-i\C-l" 'octave-send-line)
-    (define-key map "\C-c\C-i\C-b" 'octave-send-block)
-    (define-key map "\C-c\C-i\C-f" 'octave-send-defun)
-    (define-key map "\C-c\C-i\C-r" 'octave-send-region)
-    (define-key map "\C-c\C-i\C-s" 'octave-show-process-buffer)
-    ;; FIXME: free C-h so it can do the describe-prefix-bindings.
-    (define-key map "\C-c\C-i\C-h" 'octave-hide-process-buffer)
-    (define-key map "\C-c\C-i\C-k" 'octave-kill-process)
-    map)
-  "Keymap used in Octave mode.")
-
-
-
-(easy-menu-define octave-mode-menu octave-mode-map
-  "Menu for Octave mode."
-  '("Octave"
-    ("Lines"
-      ["Previous Code Line"     octave-previous-code-line t]
-      ["Next Code Line"         octave-next-code-line t]
-      ["Begin of Continuation"  octave-beginning-of-line t]
-      ["End of Continuation"    octave-end-of-line t]
-      ["Split Line at Point"    octave-indent-new-comment-line t])
-    ("Blocks"
-      ["Mark Block"             octave-mark-block t]
-      ["Close Block"            smie-close-block t])
-    ("Functions"
-      ["Indent Function"        octave-indent-defun t]
-      ["Insert Function"        octave-insert-defun t])
-    "-"
-    ("Debug"
-      ["Send Current Line"      octave-send-line t]
-      ["Send Current Block"     octave-send-block t]
-      ["Send Current Function"  octave-send-defun t]
-      ["Send Region"            octave-send-region t]
-      ["Show Process Buffer"    octave-show-process-buffer t]
-      ["Hide Process Buffer"    octave-hide-process-buffer t]
-      ["Kill Process"           octave-kill-process t])
-    "-"
-    ["Indent Line"              indent-according-to-mode t]
-    ["Complete Symbol"          completion-at-point t]
-    "-"
-    ["Toggle Abbrev Mode"       abbrev-mode
-     :style toggle :selected abbrev-mode]
-    ["Toggle Auto-Fill Mode"    auto-fill-mode
-     :style toggle :selected auto-fill-function]
-    "-"
-    ["Submit Bug Report"        octave-submit-bug-report t]
-    "-"
-    ["Describe Octave Mode"     describe-mode t]
-    ["Lookup Octave Index"      info-lookup-symbol t]))
-
-(defvar octave-mode-syntax-table
-  (let ((table (make-syntax-table)))
-    (modify-syntax-entry ?\r " "  table)
-    (modify-syntax-entry ?+ "."   table)
-    (modify-syntax-entry ?- "."   table)
-    (modify-syntax-entry ?= "."   table)
-    (modify-syntax-entry ?* "."   table)
-    (modify-syntax-entry ?/ "."   table)
-    (modify-syntax-entry ?> "."   table)
-    (modify-syntax-entry ?< "."   table)
-    (modify-syntax-entry ?& "."   table)
-    (modify-syntax-entry ?| "."   table)
-    (modify-syntax-entry ?! "."   table)
-    (modify-syntax-entry ?\\ "\\" table)
-    (modify-syntax-entry ?\' "."  table)
-    ;; Was "w" for abbrevs, but now that it's not necessary any more,
-    (modify-syntax-entry ?\` "."  table)
-    (modify-syntax-entry ?\" "\"" table)
-    (modify-syntax-entry ?. "_"   table)
-    (modify-syntax-entry ?_ "_"   table)
-    ;; The "b" flag only applies to the second letter of the comstart
-    ;; and the first letter of the comend, i.e. the "4b" below is ineffective.
-    ;; If we try to put `b' on the single-line comments, we get a similar
-    ;; problem where the % and # chars appear as first chars of the 2-char
-    ;; comend, so the multi-line ender is also turned into style-b.
-    ;; So we need the new "c" comment style.
-    (modify-syntax-entry ?\% "< 13"  table)
-    (modify-syntax-entry ?\# "< 13"  table)
-    (modify-syntax-entry ?\{ "(} 2c"  table)
-    (modify-syntax-entry ?\} "){ 4c"  table)
-    (modify-syntax-entry ?\n ">"  table)
-    table)
-  "Syntax table in use in `octave-mode' buffers.")
-
-(defcustom octave-blink-matching-block t
-  "Control the blinking of matching Octave block keywords.
-Non-nil means show matching begin of block when inserting a space,
-newline or semicolon after an else or end keyword."
-  :type 'boolean
-  :group 'octave)
-
-(defcustom octave-block-offset 2
-  "Extra indentation applied to statements in Octave block structures."
-  :type 'integer
-  :group 'octave)
-
-(defvar octave-block-comment-start
-  (concat (make-string 2 octave-comment-char) " ")
-  "String to insert to start a new Octave comment on an empty line.")
-
-(defcustom octave-continuation-offset 4
-  "Extra indentation applied to Octave continuation lines."
-  :type 'integer
-  :group 'octave)
-(eval-and-compile
-  (defconst octave-continuation-marker-regexp "\\\\\\|\\.\\.\\."))
-(defvar octave-continuation-regexp
-  (concat "[^#%\n]*\\(" octave-continuation-marker-regexp
-          "\\)\\s-*\\(\\s<.*\\)?$"))
-(defcustom octave-continuation-string "\\"
-  "Character string used for Octave continuation lines.  Normally \\."
-  :type 'string
-  :group 'octave)
-
-(defvar octave-completion-alist nil
-  "Alist of Octave symbols for completion in Octave mode.
-Each element looks like (VAR . VAR), where the car and cdr are the same
-symbol (an Octave command or variable name).
-Currently, only builtin variables can be completed.")
-
-(defvar octave-mode-imenu-generic-expression
-  (list
-   ;; Functions
-   (list nil octave-function-header-regexp 3))
-  "Imenu expression for Octave mode.  See `imenu-generic-expression'.")
-
-(defcustom octave-mode-hook nil
-  "Hook to be run when Octave mode is started."
-  :type 'hook
-  :group 'octave)
-
-(defcustom octave-send-show-buffer t
-  "Non-nil means display `inferior-octave-buffer' after sending to it."
-  :type 'boolean
-  :group 'octave)
-(defcustom octave-send-line-auto-forward t
-  "Control auto-forward after sending to the inferior Octave process.
-Non-nil means always go to the next Octave code line after sending."
-  :type 'boolean
-  :group 'octave)
-(defcustom octave-send-echo-input t
-  "Non-nil means echo input sent to the inferior Octave process."
-  :type 'boolean
-  :group 'octave)
-
-
-;;; SMIE indentation
-
-(require 'smie)
-
-(defconst octave-operator-table
-  '((assoc ";" "\n") (assoc ",") ; The doc claims they have equal precedence!?
-    (right "=" "+=" "-=" "*=" "/=")
-    (assoc "&&") (assoc "||") ; The doc claims they have equal precedence!?
-    (assoc "&") (assoc "|")   ; The doc claims they have equal precedence!?
-    (nonassoc "<" "<=" "==" ">=" ">" "!=" "~=")
-    (nonassoc ":")                      ;No idea what this is.
-    (assoc "+" "-")
-    (assoc "*" "/" "\\" ".\\" ".*" "./")
-    (nonassoc "'" ".'")
-    (nonassoc "++" "--" "!" "~")        ;And unary "+" and "-".
-    (right "^" "**" ".^" ".**")
-    ;; It's not really an operator, but for indentation purposes it
-    ;; could be convenient to treat it as one.
-    (assoc "...")))
-
-(defconst octave-smie-bnf-table
-  '((atom)
-    ;; We can't distinguish the first element in a sequence with
-    ;; precedence grammars, so we can't distinguish the condition
-    ;; if the `if' from the subsequent body, for example.
-    ;; This has to be done later in the indentation rules.
-    (exp (exp "\n" exp)
-         ;; We need to mention at least one of the operators in this part
-         ;; of the grammar: if the BNF and the operator table have
-         ;; no overlap, SMIE can't know how they relate.
-         (exp ";" exp)
-         ("try" exp "catch" exp "end_try_catch")
-         ("try" exp "catch" exp "end")
-         ("unwind_protect" exp
-          "unwind_protect_cleanup" exp "end_unwind_protect")
-         ("unwind_protect" exp "unwind_protect_cleanup" exp "end")
-         ("for" exp "endfor")
-         ("for" exp "end")
-         ("do" exp "until" atom)
-         ("while" exp "endwhile")
-         ("while" exp "end")
-         ("if" exp "endif")
-         ("if" exp "else" exp "endif")
-         ("if" exp "elseif" exp "else" exp "endif")
-         ("if" exp "elseif" exp "elseif" exp "else" exp "endif")
-         ("if" exp "elseif" exp "elseif" exp "else" exp "end")
-         ("switch" exp "case" exp "endswitch")
-         ("switch" exp "case" exp "otherwise" exp "endswitch")
-         ("switch" exp "case" exp "case" exp "otherwise" exp "endswitch")
-         ("switch" exp "case" exp "case" exp "otherwise" exp "end")
-         ("function" exp "endfunction")
-         ("function" exp "end"))
-    ;; (fundesc (atom "=" atom))
-    ))
-
-(defconst octave-smie-grammar
-  (smie-prec2->grammar
-   (smie-merge-prec2s
-    (smie-bnf->prec2 octave-smie-bnf-table
-                     '((assoc "\n" ";")))
-
-    (smie-precs->prec2 octave-operator-table))))
-
-;; Tokenizing needs to be refined so that ";;" is treated as two
-;; tokens and also so as to recognize the \n separator (and
-;; corresponding continuation lines).
-
-(defconst octave-operator-regexp
-  (regexp-opt (apply 'append (mapcar 'cdr octave-operator-table))))
-
-(defun octave-smie-backward-token ()
-  (let ((pos (point)))
-    (forward-comment (- (point)))
-    (cond
-     ((and (not (eq (char-before) ?\;)) ;Coalesce ";" and "\n".
-           (> pos (line-end-position))
-           (if (looking-back octave-continuation-marker-regexp (- (point) 3))
-               (progn
-                 (goto-char (match-beginning 0))
-                 (forward-comment (- (point)))
-                 nil)
-             t)
-           ;; Ignore it if it's within parentheses.
-           (let ((ppss (syntax-ppss)))
-             (not (and (nth 1 ppss)
-                       (eq ?\( (char-after (nth 1 ppss)))))))
-      (skip-chars-forward " \t")
-      ;; Why bother distinguishing \n and ;?
-      ";") ;;"\n"
-     ((and (looking-back octave-operator-regexp (- (point) 3) 'greedy)
-           ;; Don't mistake a string quote for a transpose.
-           (not (looking-back "\\s\"" (1- (point)))))
-      (goto-char (match-beginning 0))
-      (match-string-no-properties 0))
-     (t
-      (smie-default-backward-token)))))
-
-(defun octave-smie-forward-token ()
-  (skip-chars-forward " \t")
-  (when (looking-at (eval-when-compile
-                      (concat "\\(" octave-continuation-marker-regexp
-                              "\\)[ \t]*\\($\\|[%#]\\)")))
-    (goto-char (match-end 1))
-    (forward-comment 1))
-  (cond
-   ((and (looking-at "$\\|[%#]")
-         ;; Ignore it if it's within parentheses.
-         (prog1 (let ((ppss (syntax-ppss)))
-                  (not (and (nth 1 ppss)
-                            (eq ?\( (char-after (nth 1 ppss))))))
-           (forward-comment (point-max))))
-    ;; Why bother distinguishing \n and ;?
-    ";") ;;"\n"
-   ((looking-at ";[ \t]*\\($\\|[%#]\\)")
-    ;; Combine the ; with the subsequent \n.
-    (goto-char (match-beginning 1))
-    (forward-comment 1)
-    ";")
-   ((and (looking-at octave-operator-regexp)
-         ;; Don't mistake a string quote for a transpose.
-         (not (looking-at "\\s\"")))
-    (goto-char (match-end 0))
-    (match-string-no-properties 0))
-   (t
-    (smie-default-forward-token))))
-
-(defun octave-smie-rules (kind token)
-  (pcase (cons kind token)
-    ;; We could set smie-indent-basic instead, but that would have two
-    ;; disadvantages:
-    ;; - changes to octave-block-offset wouldn't take effect immediately.
-    ;; - edebug wouldn't show the use of this variable.
-    (`(:elem . basic) octave-block-offset)
-    ;; Since "case" is in the same BNF rules as switch..end, SMIE by default
-    ;; aligns it with "switch".
-    (`(:before . "case") (if (not (smie-rule-sibling-p)) octave-block-offset))
-    (`(:after . ";")
-     (if (smie-rule-parent-p "function" "if" "while" "else" "elseif" "for"
-                             "otherwise" "case" "try" "catch" "unwind_protect"
-                             "unwind_protect_cleanup")
-         (smie-rule-parent octave-block-offset)
-       ;; For (invalid) code between switch and case.
-       ;; (if (smie-parent-p "switch") 4)
-       0))))
-
-(defvar electric-layout-rules)
-
-;;;###autoload
-(define-derived-mode octave-mode prog-mode "Octave"
-  "Major mode for editing Octave code.
-
-This mode makes it easier to write Octave code by helping with
-indentation, doing some of the typing for you (with Abbrev mode) and by
-showing keywords, comments, strings, etc. in different faces (with
-Font Lock mode on terminals that support it).
-
-Octave itself is a high-level language, primarily intended for numerical
-computations.  It provides a convenient command line interface for
-solving linear and nonlinear problems numerically.  Function definitions
-can also be stored in files, and it can be used in a batch mode (which
-is why you need this mode!).
-
-The latest released version of Octave is always available via anonymous
-ftp from ftp.octave.org in the directory `/pub/octave'.  Complete
-source and binaries for several popular systems are available.
-
-Type \\[list-abbrevs] to display the built-in abbrevs for Octave keywords.
-
-Keybindings
-===========
-
-\\{octave-mode-map}
-
-Variables you can use to customize Octave mode
-==============================================
-
-`octave-blink-matching-block'
-  Non-nil means show matching begin of block when inserting a space,
-  newline or semicolon after an else or end keyword.  Default is t.
-
-`octave-block-offset'
-  Extra indentation applied to statements in block structures.
-  Default is 2.
-
-`octave-continuation-offset'
-  Extra indentation applied to Octave continuation lines.
-  Default is 4.
-
-`octave-continuation-string'
-  String used for Octave continuation lines.
-  Default is a backslash.
-
-`octave-send-echo-input'
-  Non-nil means always display `inferior-octave-buffer' after sending a
-  command to the inferior Octave process.
-
-`octave-send-line-auto-forward'
-  Non-nil means always go to the next unsent line of Octave code after
-  sending a line to the inferior Octave process.
-
-`octave-send-echo-input'
-  Non-nil means echo input sent to the inferior Octave process.
-
-Turning on Octave mode runs the hook `octave-mode-hook'.
-
-To begin using this mode for all `.m' files that you edit, add the
-following lines to your init file:
-
-  (add-to-list 'auto-mode-alist '(\"\\\\.m\\\\'\" . octave-mode))
-
-To automatically turn on the abbrev and auto-fill features,
-add the following lines to your init file as well:
-
-  (add-hook 'octave-mode-hook
-            (lambda ()
-              (abbrev-mode 1)
-              (auto-fill-mode 1)))
-
-To submit a problem report, enter \\[octave-submit-bug-report] from \
-an Octave mode buffer.
-This automatically sets up a mail buffer with version information
-already added.  You just need to add a description of the problem,
-including a reproducible test case and send the message."
-  (setq local-abbrev-table octave-abbrev-table)
-
-  (smie-setup octave-smie-grammar #'octave-smie-rules
-              :forward-token  #'octave-smie-forward-token
-              :backward-token #'octave-smie-backward-token)
-  (set (make-local-variable 'smie-indent-basic) 'octave-block-offset)
-
-    (set (make-local-variable 'smie-blink-matching-triggers)
-       (cons ?\; smie-blink-matching-triggers))
-  (unless octave-blink-matching-block
-    (remove-hook 'post-self-insert-hook #'smie-blink-matching-open 'local))
-
-  (set (make-local-variable 'electric-indent-chars)
-       (cons ?\; electric-indent-chars))
-  ;; IIUC matlab-mode takes the opposite approach: it makes RET insert
-  ;; a ";" at those places where it's correct (i.e. outside of parens).
-  (set (make-local-variable 'electric-layout-rules) '((?\; . after)))
-
-  (set (make-local-variable 'comment-start) octave-comment-start)
-  (set (make-local-variable 'comment-end) "")
-  ;; Don't set it here: it's not really a property of the language,
-  ;; just a personal preference of the author.
-  ;; (set (make-local-variable 'comment-column) 32)
-  (set (make-local-variable 'comment-start-skip) "\\s<+\\s-*")
-  (set (make-local-variable 'comment-add) 1)
-
-  (set (make-local-variable 'parse-sexp-ignore-comments) t)
-  (set (make-local-variable 'paragraph-start)
-       (concat "\\s-*$\\|" page-delimiter))
-  (set (make-local-variable 'paragraph-separate) paragraph-start)
-  (set (make-local-variable 'paragraph-ignore-fill-prefix) t)
-  (set (make-local-variable 'fill-paragraph-function) 'octave-fill-paragraph)
-  ;; FIXME: Why disable it?
-  ;; (set (make-local-variable 'adaptive-fill-regexp) nil)
-  ;; Again, this is not a property of the language, don't set it here.
-  ;; (set (make-local-variable 'fill-column) 72)
-  (set (make-local-variable 'normal-auto-fill-function) 'octave-auto-fill)
-
-  (set (make-local-variable 'font-lock-defaults)
-       '(octave-font-lock-keywords))
-
-  (set (make-local-variable 'syntax-propertize-function)
-       #'octave-syntax-propertize-function)
-
-  (set (make-local-variable 'imenu-generic-expression)
-       octave-mode-imenu-generic-expression)
-  (set (make-local-variable 'imenu-case-fold-search) nil)
-
-  (add-hook 'completion-at-point-functions
-            'octave-completion-at-point-function nil t)
-  (set (make-local-variable 'beginning-of-defun-function)
-       'octave-beginning-of-defun)
-
-  (easy-menu-add octave-mode-menu)
-  (octave-initialize-completions))
-
-;;; Miscellaneous useful functions
-
-(defsubst octave-in-comment-p ()
-  "Return t if point is inside an Octave comment."
-  (nth 4 (syntax-ppss)))
-
-(defsubst octave-in-string-p ()
-  "Return t if point is inside an Octave string."
-  (nth 3 (syntax-ppss)))
-
-(defsubst octave-not-in-string-or-comment-p ()
-  "Return t if point is not inside an Octave string or comment."
-  (let ((pps (syntax-ppss)))
-    (not (or (nth 3 pps) (nth 4 pps)))))
-
-
-(defun octave-looking-at-kw (regexp)
-  "Like `looking-at', but sets `case-fold-search' nil."
-  (let ((case-fold-search nil))
-    (looking-at regexp)))
-
-(defun octave-maybe-insert-continuation-string ()
-  (if (or (octave-in-comment-p)
-          (save-excursion
-            (beginning-of-line)
-            (looking-at octave-continuation-regexp)))
-      nil
-    (delete-horizontal-space)
-    (insert (concat " " octave-continuation-string))))
-
-;;; Indentation
-
-(defun octave-indent-new-comment-line ()
-  "Break Octave line at point, continuing comment if within one.
-If within code, insert `octave-continuation-string' before breaking the
-line.  If within a string, signal an error.
-The new line is properly indented."
-  (interactive)
-  (delete-horizontal-space)
-  (cond
-   ((octave-in-comment-p)
-    (indent-new-comment-line))
-   ((octave-in-string-p)
-    (error "Cannot split a code line inside a string"))
-   (t
-    (insert (concat " " octave-continuation-string))
-    (reindent-then-newline-and-indent))))
-
-(defun octave-indent-defun ()
-  "Properly indent the Octave function which contains point."
-  (interactive)
-  (save-excursion
-    (mark-defun)
-    (message "Indenting function...")
-    (indent-region (point) (mark) nil))
-  (message "Indenting function...done."))
-
-
-;;; Motion
-(defun octave-next-code-line (&optional arg)
-  "Move ARG lines of Octave code forward (backward if ARG is negative).
-Skips past all empty and comment lines.  Default for ARG is 1.
-
-On success, return 0.  Otherwise, go as far as possible and return -1."
-  (interactive "p")
-  (or arg (setq arg 1))
-  (beginning-of-line)
-  (let ((n 0)
-        (inc (if (> arg 0) 1 -1)))
-    (while (and (/= arg 0) (= n 0))
-      (setq n (forward-line inc))
-      (while (and (= n 0)
-                  (looking-at "\\s-*\\($\\|\\s<\\)"))
-        (setq n (forward-line inc)))
-      (setq arg (- arg inc)))
-    n))
-
-(defun octave-previous-code-line (&optional arg)
-  "Move ARG lines of Octave code backward (forward if ARG is negative).
-Skips past all empty and comment lines.  Default for ARG is 1.
-
-On success, return 0.  Otherwise, go as far as possible and return -1."
-  (interactive "p")
-  (or arg (setq arg 1))
-  (octave-next-code-line (- arg)))
-
-(defun octave-beginning-of-line ()
-  "Move point to beginning of current Octave line.
-If on an empty or comment line, go to the beginning of that line.
-Otherwise, move backward to the beginning of the first Octave code line
-which is not inside a continuation statement, i.e., which does not
-follow a code line ending in `...' or `\\', or is inside an open
-parenthesis list."
-  (interactive)
-  (beginning-of-line)
-  (if (not (looking-at "\\s-*\\($\\|\\s<\\)"))
-      (while (or (condition-case nil
-                     (progn
-                       (up-list -1)
-                       (beginning-of-line)
-                       t)
-                   (error nil))
-                 (and (or (looking-at "\\s-*\\($\\|\\s<\\)")
-                          (save-excursion
-                            (if (zerop (octave-previous-code-line))
-                                (looking-at octave-continuation-regexp))))
-                      (zerop (forward-line -1)))))))
-
-(defun octave-end-of-line ()
-  "Move point to end of current Octave line.
-If on an empty or comment line, go to the end of that line.
-Otherwise, move forward to the end of the first Octave code line which
-does not end in `...' or `\\' or is inside an open parenthesis list."
-  (interactive)
-  (end-of-line)
-  (if (save-excursion
-        (beginning-of-line)
-        (looking-at "\\s-*\\($\\|\\s<\\)"))
-      ()
-    (while (or (condition-case nil
-                   (progn
-                     (up-list 1)
-                     (end-of-line)
-                     t)
-                 (error nil))
-               (and (save-excursion
-                      (beginning-of-line)
-                      (or (looking-at "\\s-*\\($\\|\\s<\\)")
-                          (looking-at octave-continuation-regexp)))
-                    (zerop (forward-line 1)))))
-    (end-of-line)))
-
-(defun octave-mark-block ()
-  "Put point at the beginning of this Octave block, mark at the end.
-The block marked is the one that contains point or follows point."
-  (interactive)
-  (if (and (looking-at "\\sw\\|\\s_")
-           (looking-back "\\sw\\|\\s_" (1- (point))))
-      (skip-syntax-forward "w_"))
-  (unless (or (looking-at "\\s(")
-              (save-excursion
-                (let* ((token (funcall smie-forward-token-function))
-                       (level (assoc token smie-grammar)))
-                  (and level (not (numberp (cadr level)))))))
-    (backward-up-list 1))
-  (mark-sexp))
-
-(defun octave-beginning-of-defun (&optional arg)
-  "Move backward to the beginning of an Octave function.
-With positive ARG, do it that many times.  Negative argument -N means
-move forward to Nth following beginning of a function.
-Returns t unless search stops at the beginning or end of the buffer."
-  (let* ((arg (or arg 1))
-         (inc (if (> arg 0) 1 -1))
-         (found nil)
-         (case-fold-search nil))
-    (and (not (eobp))
-         (not (and (> arg 0) (looking-at "\\_<function\\_>")))
-         (skip-syntax-forward "w"))
-    (while (and (/= arg 0)
-                (setq found
-                      (re-search-backward "\\_<function\\_>" inc)))
-      (if (octave-not-in-string-or-comment-p)
-          (setq arg (- arg inc))))
-    (if found
-        (progn
-          (and (< inc 0) (goto-char (match-beginning 0)))
-          t))))
-
-
-;;; Filling
-(defun octave-auto-fill ()
-  "Perform auto-fill in Octave mode.
-Returns nil if no feasible place to break the line could be found, and t
-otherwise."
-  (let (fc give-up)
-    (if (or (null (setq fc (current-fill-column)))
-            (save-excursion
-              (beginning-of-line)
-              (and auto-fill-inhibit-regexp
-                   (octave-looking-at-kw auto-fill-inhibit-regexp))))
-        nil                             ; Can't do anything
-      (if (and (not (octave-in-comment-p))
-               (> (current-column) fc))
-          (setq fc (- fc (+ (length octave-continuation-string) 1))))
-      (while (and (not give-up) (> (current-column) fc))
-        (let* ((opoint (point))
-               (fpoint
-                (save-excursion
-                  (move-to-column (+ fc 1))
-                  (skip-chars-backward "^ \t\n")
-                  ;; If we're at the beginning of the line, break after
-                  ;; the first word
-                  (if (bolp)
-                      (re-search-forward "[ \t]" opoint t))
-                  ;; If we're in a comment line, don't break after the
-                  ;; comment chars
-                  (if (save-excursion
-                        (skip-syntax-backward " <")
-                        (bolp))
-                      (re-search-forward "[ \t]" (line-end-position)
-                                         'move))
-                  ;; If we're not in a comment line and just ahead the
-                  ;; continuation string, don't break here.
-                  (if (and (not (octave-in-comment-p))
-                           (looking-at
-                            (concat "\\s-*"
-                                    (regexp-quote
-                                     octave-continuation-string)
-                                    "\\s-*$")))
-                      (end-of-line))
-                  (skip-chars-backward " \t")
-                  (point))))
-          (if (save-excursion
-                (goto-char fpoint)
-                (not (or (bolp) (eolp))))
-              (let ((prev-column (current-column)))
-                (if (save-excursion
-                      (skip-chars-backward " \t")
-                      (= (point) fpoint))
-                    (progn
-                      (octave-maybe-insert-continuation-string)
-                      (indent-new-comment-line t))
-                  (save-excursion
-                    (goto-char fpoint)
-                    (octave-maybe-insert-continuation-string)
-                    (indent-new-comment-line t)))
-                (if (>= (current-column) prev-column)
-                    (setq give-up t)))
-            (setq give-up t))))
-      (not give-up))))
-
-(defun octave-fill-paragraph (&optional _arg)
-  "Fill paragraph of Octave code, handling Octave comments."
-  ;; FIXME: difference with generic fill-paragraph:
-  ;; - code lines are only split, never joined.
-  ;; - \n that end comments are never removed.
-  ;; - insert continuation marker when splitting code lines.
-  (interactive "P")
-  (save-excursion
-    (let ((end (progn (forward-paragraph) (copy-marker (point) t)))
-          (beg (progn
-                 (forward-paragraph -1)
-                 (skip-chars-forward " \t\n")
-                 (beginning-of-line)
-                 (point)))
-          (cfc (current-fill-column))
-          comment-prefix)
-      (goto-char beg)
-      (while (< (point) end)
-        (condition-case nil
-            (indent-according-to-mode)
-          (error nil))
-        (move-to-column cfc)
-        ;; First check whether we need to combine non-empty comment lines
-        (if (and (< (current-column) cfc)
-                 (octave-in-comment-p)
-                 (not (save-excursion
-                        (beginning-of-line)
-                        (looking-at "^\\s-*\\s<+\\s-*$"))))
-            ;; This is a nonempty comment line which does not extend
-            ;; past the fill column.  If it is followed by a nonempty
-            ;; comment line with the same comment prefix, try to
-            ;; combine them, and repeat this until either we reach the
-            ;; fill-column or there is nothing more to combine.
-            (progn
-              ;; Get the comment prefix
-              (save-excursion
-                (beginning-of-line)
-                (while (and (re-search-forward "\\s<+")
-                            (not (octave-in-comment-p))))
-                (setq comment-prefix (match-string 0)))
-              ;; And keep combining ...
-              (while (and (< (current-column) cfc)
-                          (save-excursion
-                            (forward-line 1)
-                            (and (looking-at
-                                  (concat "^\\s-*"
-                                          comment-prefix
-                                          "\\S<"))
-                                 (not (looking-at
-                                       (concat "^\\s-*"
-                                               comment-prefix
-                                               "\\s-*$"))))))
-                (delete-char 1)
-                (re-search-forward comment-prefix)
-                (delete-region (match-beginning 0) (match-end 0))
-                (fixup-whitespace)
-                (move-to-column cfc))))
-        ;; We might also try to combine continued code lines>  Perhaps
-        ;; some other time ...
-        (skip-chars-forward "^ \t\n")
-        (delete-horizontal-space)
-        (if (or (< (current-column) cfc)
-                (and (= (current-column) cfc) (eolp)))
-            (forward-line 1)
-          (if (not (eolp)) (insert " "))
-          (or (octave-auto-fill)
-              (forward-line 1))))
-      t)))
-
-
-;;; Completions
-(defun octave-initialize-completions ()
-  "Create an alist for Octave completions."
-  (if octave-completion-alist
-      ()
-    (setq octave-completion-alist
-          (append octave-reserved-words
-                  octave-text-functions
-                  octave-variables))))
-
-(defun octave-completion-at-point-function ()
-  "Find the text to complete and the corresponding table."
-  (let* ((beg (save-excursion (skip-syntax-backward "w_") (point)))
-         (end (point)))
-    (if (< beg (point))
-        ;; Extend region past point, if applicable.
-        (save-excursion (skip-syntax-forward "w_")
-                        (setq end (point))))
-    (list beg end octave-completion-alist)))
-
-(define-obsolete-function-alias 'octave-complete-symbol
-  'completion-at-point "24.1")
-
-;;; Electric characters && friends
-
-(defun octave-abbrev-start ()
-  "Start entering an Octave abbreviation.
-If Abbrev mode is turned on, typing ` (grave accent) followed by ? or
-\\[help-command] lists all Octave abbrevs.  Any other key combination is
-executed normally.
-Note that all Octave mode abbrevs start with a grave accent."
-  (interactive)
-  (self-insert-command 1)
-  (when abbrev-mode
-    (set-temporary-overlay-map
-     (let ((map (make-sparse-keymap)))
-       (define-key map [??] 'list-abbrevs)
-       (define-key map (vector help-char) 'list-abbrevs)
-       map))))
-
-(define-skeleton octave-insert-defun
-  "Insert an Octave function skeleton.
-Prompt for the function's name, arguments and return values (to be
-entered without parens)."
-  (let* ((defname (substring (buffer-name) 0 -2))
-         (name (read-string (format "Function name (default %s): " defname)
-                            nil nil defname))
-         (args (read-string "Arguments: "))
-         (vals (read-string "Return values: ")))
-    (format "%s%s (%s)"
-            (cond
-             ((string-equal vals "") vals)
-             ((string-match "[ ,]" vals) (concat "[" vals "] = "))
-             (t (concat vals " = ")))
-            name
-            args))
-  \n "function " > str \n \n
-  octave-block-comment-start "usage: " str \n
-  octave-block-comment-start \n octave-block-comment-start
-  \n _ \n
-  "endfunction" > \n)
-
-;;; Communication with the inferior Octave process
-(defun octave-kill-process ()
-  "Kill inferior Octave process and its buffer."
-  (interactive)
-  (if inferior-octave-process
-      (progn
-        (process-send-string inferior-octave-process "quit;\n")
-        (accept-process-output inferior-octave-process)))
-  (if inferior-octave-buffer
-      (kill-buffer inferior-octave-buffer)))
-
-(defun octave-show-process-buffer ()
-  "Make sure that `inferior-octave-buffer' is displayed."
-  (interactive)
-  (if (get-buffer inferior-octave-buffer)
-      (display-buffer inferior-octave-buffer)
-    (message "No buffer named %s" inferior-octave-buffer)))
-
-(defun octave-hide-process-buffer ()
-  "Delete all windows that display `inferior-octave-buffer'."
-  (interactive)
-  (if (get-buffer inferior-octave-buffer)
-      (delete-windows-on inferior-octave-buffer)
-    (message "No buffer named %s" inferior-octave-buffer)))
-
-(defun octave-send-region (beg end)
-  "Send current region to the inferior Octave process."
-  (interactive "r")
-  (inferior-octave t)
-  (let ((proc inferior-octave-process)
-        (string (buffer-substring-no-properties beg end))
-        line)
-    (with-current-buffer inferior-octave-buffer
-      (setq inferior-octave-output-list nil)
-      (while (not (string-equal string ""))
-        (if (string-match "\n" string)
-            (setq line (substring string 0 (match-beginning 0))
-                  string (substring string (match-end 0)))
-          (setq line string string ""))
-        (setq inferior-octave-receive-in-progress t)
-        (inferior-octave-send-list-and-digest (list (concat line "\n")))
-        (while inferior-octave-receive-in-progress
-          (accept-process-output proc))
-        (insert-before-markers
-         (mapconcat 'identity
-                    (append
-                     (if octave-send-echo-input (list line) (list ""))
-                     (mapcar 'inferior-octave-strip-ctrl-g
-                             inferior-octave-output-list)
-                     (list inferior-octave-output-string))
-                    "\n")))))
-  (if octave-send-show-buffer
-      (display-buffer inferior-octave-buffer)))
-
-(defun octave-send-block ()
-  "Send current Octave block to the inferior Octave process."
-  (interactive)
-  (save-excursion
-    (octave-mark-block)
-    (octave-send-region (point) (mark))))
-
-(defun octave-send-defun ()
-  "Send current Octave function to the inferior Octave process."
-  (interactive)
-  (save-excursion
-    (mark-defun)
-    (octave-send-region (point) (mark))))
-
-(defun octave-send-line (&optional arg)
-  "Send current Octave code line to the inferior Octave process.
-With positive prefix ARG, send that many lines.
-If `octave-send-line-auto-forward' is non-nil, go to the next unsent
-code line."
-  (interactive "P")
-  (or arg (setq arg 1))
-  (if (> arg 0)
-      (let (beg end)
-        (beginning-of-line)
-        (setq beg (point))
-        (octave-next-code-line (- arg 1))
-        (end-of-line)
-        (setq end (point))
-        (if octave-send-line-auto-forward
-            (octave-next-code-line 1))
-        (octave-send-region beg end))))
-
-(defun octave-eval-print-last-sexp ()
-  "Evaluate Octave sexp before point and print value into current buffer."
-  (interactive)
-  (inferior-octave t)
-  (let ((standard-output (current-buffer))
-        (print-escape-newlines nil)
-        (opoint (point)))
-    (terpri)
-    (prin1
-     (save-excursion
-       (forward-sexp -1)
-       (inferior-octave-send-list-and-digest
-        (list (concat (buffer-substring-no-properties (point) opoint)
-                      "\n")))
-       (mapconcat 'identity inferior-octave-output-list "\n")))
-    (terpri)))
-
-;;; Bug reporting
-(defun octave-submit-bug-report ()
-  "Submit a bug report on the Emacs Octave package via mail."
-  (interactive)
-  (require 'reporter)
-  (and
-   (y-or-n-p "Do you want to submit a bug report? ")
-   (reporter-submit-bug-report
-    octave-maintainer-address
-    (concat "Emacs version " emacs-version)
-    (list
-     'octave-blink-matching-block
-     'octave-block-offset
-     'octave-comment-char
-     'octave-continuation-offset
-     'octave-continuation-string
-     'octave-send-echo-input
-     'octave-send-line-auto-forward
-     'octave-send-show-buffer))))
-
-;; provide ourself
-
-(provide 'octave-mod)
-
-;;; octave-mod.el ends here
diff --git a/lisp/progmodes/octave.el b/lisp/progmodes/octave.el
new file mode 100644
index 00000000000..c6e19fe3a15
--- /dev/null
+++ b/lisp/progmodes/octave.el
@@ -0,0 +1,1732 @@
+;;; octave.el --- editing octave source files under emacs   -*- lexical-binding: t; -*-
+
+;; Copyright (C) 1997, 2001-2013 Free Software Foundation, Inc.
+
+;; Author: Kurt Hornik <Kurt.Hornik@wu-wien.ac.at>
+;;         John Eaton <jwe@octave.org>
+;; Maintainer: FSF
+;; Keywords: languages
+
+;; This file is part of GNU Emacs.
+
+;; GNU Emacs is free software: you can redistribute it and/or modify
+;; it under the terms of the GNU General Public License as published by
+;; the Free Software Foundation, either version 3 of the License, or
+;; (at your option) any later version.
+
+;; GNU Emacs is distributed in the hope that it will be useful,
+;; but WITHOUT ANY WARRANTY; without even the implied warranty of
+;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+;; GNU General Public License for more details.
+
+;; You should have received a copy of the GNU General Public License
+;; along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.
+
+;;; Commentary:
+
+;; This package provides emacs support for Octave.  It defines a major
+;; mode for editing Octave code and contains code for interacting with
+;; an inferior Octave process using comint.
+
+;; See the documentation of `octave-mode' and `run-octave' for further
+;; information on usage and customization.
+
+;;; Code:
+(require 'comint)
+
+;;; For emacs < 24.3.
+(require 'newcomment)
+(eval-and-compile
+  (unless (fboundp 'user-error)
+    (defalias 'user-error 'error))
+  (unless (fboundp 'delete-consecutive-dups)
+    (defalias 'delete-consecutive-dups 'delete-dups)))
+(eval-when-compile
+  (unless (fboundp 'setq-local)
+    (defmacro setq-local (var val)
+      "Set variable VAR to value VAL in current buffer."
+      (list 'set (list 'make-local-variable (list 'quote var)) val))))
+
+(defgroup octave nil
+  "Editing Octave code."
+  :link '(custom-group-link :tag "Font Lock Faces group" font-lock-faces)
+  :group 'languages)
+
+(define-obsolete-function-alias 'octave-submit-bug-report
+  'report-emacs-bug "24.4")
+
+(define-abbrev-table 'octave-abbrev-table nil
+  "Abbrev table for Octave's reserved words.
+Used in `octave-mode' and `inferior-octave-mode' buffers.")
+
+(defvar octave-comment-char ?#
+  "Character to start an Octave comment.")
+
+(defvar octave-comment-start (char-to-string octave-comment-char)
+  "Octave-specific `comment-start' (which see).")
+
+(defvar octave-comment-start-skip "\\(^\\|\\S<\\)\\(?:%!\\|\\s<+\\)\\s-*"
+  "Octave-specific `comment-start-skip' (which see).")
+
+(defvar octave-begin-keywords
+  '("classdef" "do" "enumeration" "events" "for" "function" "if" "methods"
+    "parfor" "properties" "switch" "try" "unwind_protect" "while"))
+
+(defvar octave-else-keywords
+  '("case" "catch" "else" "elseif" "otherwise" "unwind_protect_cleanup"))
+
+(defvar octave-end-keywords
+  '("endclassdef" "endenumeration" "endevents" "endfor" "endfunction" "endif"
+    "endmethods" "endparfor" "endproperties" "endswitch" "end_try_catch"
+    "end_unwind_protect" "endwhile" "until" "end"))
+
+(defvar octave-reserved-words
+  (append octave-begin-keywords
+          octave-else-keywords
+          octave-end-keywords
+          '("break" "continue" "global" "persistent" "return"))
+  "Reserved words in Octave.")
+
+(defvar octave-function-header-regexp
+  (concat "^\\s-*\\_<\\(function\\)\\_>"
+          "\\([^=;\n]*=[ \t]*\\|[ \t]*\\)\\(\\(?:\\w\\|\\s_\\)+\\)\\_>")
+  "Regexp to match an Octave function header.
+The string `function' and its name are given by the first and third
+parenthetical grouping.")
+
+
+(defvar octave-mode-map
+  (let ((map (make-sparse-keymap)))
+    (define-key map "\M-."     'octave-find-definition)
+    (define-key map "\M-\C-j"  'octave-indent-new-comment-line)
+    (define-key map "\C-c\C-p" 'octave-previous-code-line)
+    (define-key map "\C-c\C-n" 'octave-next-code-line)
+    (define-key map "\C-c\C-a" 'octave-beginning-of-line)
+    (define-key map "\C-c\C-e" 'octave-end-of-line)
+    (define-key map [remap down-list] 'smie-down-list)
+    (define-key map "\C-c\M-\C-h" 'octave-mark-block)
+    (define-key map "\C-c]" 'smie-close-block)
+    (define-key map "\C-c/" 'smie-close-block)
+    (define-key map "\C-c;" 'octave-update-function-file-comment)
+    (define-key map "\C-hd" 'octave-help)
+    (define-key map "\C-c\C-f" 'octave-insert-defun)
+    (define-key map "\C-c\C-il" 'octave-send-line)
+    (define-key map "\C-c\C-ib" 'octave-send-block)
+    (define-key map "\C-c\C-if" 'octave-send-defun)
+    (define-key map "\C-c\C-ir" 'octave-send-region)
+    (define-key map "\C-c\C-is" 'octave-show-process-buffer)
+    (define-key map "\C-c\C-iq" 'octave-hide-process-buffer)
+    (define-key map "\C-c\C-ik" 'octave-kill-process)
+    (define-key map "\C-c\C-i\C-l" 'octave-send-line)
+    (define-key map "\C-c\C-i\C-b" 'octave-send-block)
+    (define-key map "\C-c\C-i\C-f" 'octave-send-defun)
+    (define-key map "\C-c\C-i\C-r" 'octave-send-region)
+    (define-key map "\C-c\C-i\C-s" 'octave-show-process-buffer)
+    (define-key map "\C-c\C-i\C-q" 'octave-hide-process-buffer)
+    (define-key map "\C-c\C-i\C-k" 'octave-kill-process)
+    map)
+  "Keymap used in Octave mode.")
+
+
+
+(easy-menu-define octave-mode-menu octave-mode-map
+  "Menu for Octave mode."
+  '("Octave"
+    ["Split Line at Point"          octave-indent-new-comment-line t]
+    ["Previous Code Line"           octave-previous-code-line t]
+    ["Next Code Line"               octave-next-code-line t]
+    ["Begin of Line"                octave-beginning-of-line t]
+    ["End of Line"                  octave-end-of-line t]
+    ["Mark Block"                   octave-mark-block t]
+    ["Close Block"                  smie-close-block t]
+    "---"
+    ["Start Octave Process"         run-octave t]
+    ["Documentation Lookup"         info-lookup-symbol t]
+    ["Help on Function"             octave-help t]
+    ["Find Function Definition"     octave-find-definition t]
+    ["Insert Function"              octave-insert-defun t]
+    ["Update Function File Comment" octave-update-function-file-comment t]
+    "---"
+    ["Function Syntax Hints" (call-interactively
+                              (if (fboundp 'eldoc-post-insert-mode)
+                                  'eldoc-post-insert-mode
+                                'eldoc-mode))
+     :style toggle :selected (or eldoc-post-insert-mode eldoc-mode)
+     :help "Display function signatures after typing `SPC' or `('"]
+    ["Delimiter Matching"           smie-highlight-matching-block-mode
+     :style toggle :selected smie-highlight-matching-block-mode
+     :help "Highlight matched pairs such as `if ... end'"
+     :visible (fboundp 'smie-highlight-matching-block-mode)]
+    ["Auto Fill"                    auto-fill-mode
+     :style toggle :selected auto-fill-function
+     :help "Automatic line breaking"]
+    ["Electric Layout"              electric-layout-mode
+     :style toggle :selected electric-layout-mode
+     :help "Automatically insert newlines around some chars"]
+    "---"
+    ("Debug"
+     ["Send Current Line"       octave-send-line t]
+     ["Send Current Block"      octave-send-block t]
+     ["Send Current Function"   octave-send-defun t]
+     ["Send Region"             octave-send-region t]
+     ["Show Process Buffer"     octave-show-process-buffer t]
+     ["Hide Process Buffer"     octave-hide-process-buffer t]
+     ["Kill Process"            octave-kill-process t])
+    "---"
+    ["Customize Octave"         (customize-group 'octave) t]
+    ["Submit Bug Report"        report-emacs-bug t]))
+
+(defvar octave-mode-syntax-table
+  (let ((table (make-syntax-table)))
+    (modify-syntax-entry ?\r " "  table)
+    (modify-syntax-entry ?+ "."   table)
+    (modify-syntax-entry ?- "."   table)
+    (modify-syntax-entry ?= "."   table)
+    (modify-syntax-entry ?* "."   table)
+    (modify-syntax-entry ?/ "."   table)
+    (modify-syntax-entry ?> "."   table)
+    (modify-syntax-entry ?< "."   table)
+    (modify-syntax-entry ?& "."   table)
+    (modify-syntax-entry ?| "."   table)
+    (modify-syntax-entry ?! "."   table)
+    (modify-syntax-entry ?\\ "."  table)
+    (modify-syntax-entry ?\' "."  table)
+    (modify-syntax-entry ?\` "."  table)
+    (modify-syntax-entry ?. "."   table)
+    (modify-syntax-entry ?\" "\"" table)
+    (modify-syntax-entry ?_ "_"   table)
+    ;; The "b" flag only applies to the second letter of the comstart
+    ;; and the first letter of the comend, i.e. the "4b" below is ineffective.
+    ;; If we try to put `b' on the single-line comments, we get a similar
+    ;; problem where the % and # chars appear as first chars of the 2-char
+    ;; comend, so the multi-line ender is also turned into style-b.
+    ;; So we need the new "c" comment style.
+    (modify-syntax-entry ?\% "< 13"  table)
+    (modify-syntax-entry ?\# "< 13"  table)
+    (modify-syntax-entry ?\{ "(} 2c"  table)
+    (modify-syntax-entry ?\} "){ 4c"  table)
+    (modify-syntax-entry ?\n ">"  table)
+    table)
+  "Syntax table in use in `octave-mode' buffers.")
+
+(defcustom octave-font-lock-texinfo-comment t
+  "Control whether to highlight the texinfo comment block."
+  :type 'boolean
+  :group 'octave
+  :version "24.4")
+
+(defcustom octave-blink-matching-block t
+  "Control the blinking of matching Octave block keywords.
+Non-nil means show matching begin of block when inserting a space,
+newline or semicolon after an else or end keyword."
+  :type 'boolean
+  :group 'octave)
+
+(defcustom octave-block-offset 2
+  "Extra indentation applied to statements in Octave block structures."
+  :type 'integer
+  :group 'octave)
+
+(defvar octave-block-comment-start
+  (concat (make-string 2 octave-comment-char) " ")
+  "String to insert to start a new Octave comment on an empty line.")
+
+(defcustom octave-continuation-offset 4
+  "Extra indentation applied to Octave continuation lines."
+  :type 'integer
+  :group 'octave)
+
+(eval-and-compile
+  (defconst octave-continuation-marker-regexp "\\\\\\|\\.\\.\\."))
+
+(defvar octave-continuation-regexp
+  (concat "[^#%\n]*\\(" octave-continuation-marker-regexp
+          "\\)\\s-*\\(\\s<.*\\)?$"))
+
+;; Char \ is considered a bad decision for continuing a line.
+(defconst octave-continuation-string "..."
+  "Character string used for Octave continuation lines.")
+
+(defvar octave-mode-imenu-generic-expression
+  (list
+   ;; Functions
+   (list nil octave-function-header-regexp 3))
+  "Imenu expression for Octave mode.  See `imenu-generic-expression'.")
+
+(defcustom octave-mode-hook nil
+  "Hook to be run when Octave mode is started."
+  :type 'hook
+  :group 'octave)
+
+(defcustom octave-send-show-buffer t
+  "Non-nil means display `inferior-octave-buffer' after sending to it."
+  :type 'boolean
+  :group 'octave)
+
+(defcustom octave-send-line-auto-forward t
+  "Control auto-forward after sending to the inferior Octave process.
+Non-nil means always go to the next Octave code line after sending."
+  :type 'boolean
+  :group 'octave)
+
+(defcustom octave-send-echo-input t
+  "Non-nil means echo input sent to the inferior Octave process."
+  :type 'boolean
+  :group 'octave)
+
+
+;;; SMIE indentation
+
+(require 'smie)
+
+;; Use '__operators__' in Octave REPL to get a full list.
+(defconst octave-operator-table
+  '((assoc ";" "\n") (assoc ",") ; The doc claims they have equal precedence!?
+    (right "=" "+=" "-=" "*=" "/=")
+    (assoc "&&") (assoc "||") ; The doc claims they have equal precedence!?
+    (assoc "&") (assoc "|")   ; The doc claims they have equal precedence!?
+    (nonassoc "<" "<=" "==" ">=" ">" "!=" "~=")
+    (nonassoc ":")                      ;No idea what this is.
+    (assoc "+" "-")
+    (assoc "*" "/" "\\" ".\\" ".*" "./")
+    (nonassoc "'" ".'")
+    (nonassoc "++" "--" "!" "~")        ;And unary "+" and "-".
+    (right "^" "**" ".^" ".**")
+    ;; It's not really an operator, but for indentation purposes it
+    ;; could be convenient to treat it as one.
+    (assoc "...")))
+
+(defconst octave-smie-bnf-table
+  '((atom)
+    ;; We can't distinguish the first element in a sequence with
+    ;; precedence grammars, so we can't distinguish the condition
+    ;; if the `if' from the subsequent body, for example.
+    ;; This has to be done later in the indentation rules.
+    (exp (exp "\n" exp)
+         ;; We need to mention at least one of the operators in this part
+         ;; of the grammar: if the BNF and the operator table have
+         ;; no overlap, SMIE can't know how they relate.
+         (exp ";" exp)
+         ("try" exp "catch" exp "end_try_catch")
+         ("try" exp "catch" exp "end")
+         ("unwind_protect" exp
+          "unwind_protect_cleanup" exp "end_unwind_protect")
+         ("unwind_protect" exp "unwind_protect_cleanup" exp "end")
+         ("for" exp "endfor")
+         ("for" exp "end")
+         ("parfor" exp "endparfor")
+         ("parfor" exp "end")
+         ("do" exp "until" atom)
+         ("while" exp "endwhile")
+         ("while" exp "end")
+         ("if" exp "endif")
+         ("if" exp "else" exp "endif")
+         ("if" exp "elseif" exp "else" exp "endif")
+         ("if" exp "elseif" exp "elseif" exp "else" exp "endif")
+         ("if" exp "elseif" exp "elseif" exp "else" exp "end")
+         ("switch" exp "case" exp "endswitch")
+         ("switch" exp "case" exp "otherwise" exp "endswitch")
+         ("switch" exp "case" exp "case" exp "otherwise" exp "endswitch")
+         ("switch" exp "case" exp "case" exp "otherwise" exp "end")
+         ("function" exp "endfunction")
+         ("function" exp "end")
+         ("enumeration" exp "endenumeration")
+         ("enumeration" exp "end")
+         ("events" exp "endevents")
+         ("events" exp "end")
+         ("methods" exp "endmethods")
+         ("methods" exp "end")
+         ("properties" exp "endproperties")
+         ("properties" exp "end")
+         ("classdef" exp "endclassdef")
+         ("classdef" exp "end"))
+    ;; (fundesc (atom "=" atom))
+    ))
+
+(defconst octave-smie-grammar
+  (smie-prec2->grammar
+   (smie-merge-prec2s
+    (smie-bnf->prec2 octave-smie-bnf-table
+                     '((assoc "\n" ";")))
+
+    (smie-precs->prec2 octave-operator-table))))
+
+;; Tokenizing needs to be refined so that ";;" is treated as two
+;; tokens and also so as to recognize the \n separator (and
+;; corresponding continuation lines).
+
+(defconst octave-operator-regexp
+  (regexp-opt (apply 'append (mapcar 'cdr octave-operator-table))))
+
+(defun octave-smie-backward-token ()
+  (let ((pos (point)))
+    (forward-comment (- (point)))
+    (cond
+     ((and (not (eq (char-before) ?\;)) ;Coalesce ";" and "\n".
+           (> pos (line-end-position))
+           (if (looking-back octave-continuation-marker-regexp (- (point) 3))
+               (progn
+                 (goto-char (match-beginning 0))
+                 (forward-comment (- (point)))
+                 nil)
+             t)
+           ;; Ignore it if it's within parentheses.
+           (let ((ppss (syntax-ppss)))
+             (not (and (nth 1 ppss)
+                       (eq ?\( (char-after (nth 1 ppss)))))))
+      (skip-chars-forward " \t")
+      ;; Why bother distinguishing \n and ;?
+      ";") ;;"\n"
+     ((and (looking-back octave-operator-regexp (- (point) 3) 'greedy)
+           ;; Don't mistake a string quote for a transpose.
+           (not (looking-back "\\s\"" (1- (point)))))
+      (goto-char (match-beginning 0))
+      (match-string-no-properties 0))
+     (t
+      (smie-default-backward-token)))))
+
+(defun octave-smie-forward-token ()
+  (skip-chars-forward " \t")
+  (when (looking-at (eval-when-compile
+                      (concat "\\(" octave-continuation-marker-regexp
+                              "\\)[ \t]*\\($\\|[%#]\\)")))
+    (goto-char (match-end 1))
+    (forward-comment 1))
+  (cond
+   ((and (looking-at "[%#\n]")
+         (not (or (save-excursion (skip-chars-backward " \t")
+                                  ;; Only add implicit ; when needed.
+                                  (or (bolp) (eq (char-before) ?\;)))
+                  ;; Ignore it if it's within parentheses.
+                  (let ((ppss (syntax-ppss)))
+                    (and (nth 1 ppss)
+                         (eq ?\( (char-after (nth 1 ppss))))))))
+    (if (eolp) (forward-char 1) (forward-comment 1))
+    ;; Why bother distinguishing \n and ;?
+    ";") ;;"\n"
+   ((progn (forward-comment (point-max)) nil))
+   ((looking-at ";[ \t]*\\($\\|[%#]\\)")
+    ;; Combine the ; with the subsequent \n.
+    (goto-char (match-beginning 1))
+    (forward-comment 1)
+    ";")
+   ((and (looking-at octave-operator-regexp)
+         ;; Don't mistake a string quote for a transpose.
+         (not (looking-at "\\s\"")))
+    (goto-char (match-end 0))
+    (match-string-no-properties 0))
+   (t
+    (smie-default-forward-token))))
+
+(defun octave-smie-rules (kind token)
+  (pcase (cons kind token)
+    ;; We could set smie-indent-basic instead, but that would have two
+    ;; disadvantages:
+    ;; - changes to octave-block-offset wouldn't take effect immediately.
+    ;; - edebug wouldn't show the use of this variable.
+    (`(:elem . basic) octave-block-offset)
+    ;; Since "case" is in the same BNF rules as switch..end, SMIE by default
+    ;; aligns it with "switch".
+    (`(:before . "case") (if (not (smie-rule-sibling-p)) octave-block-offset))
+    (`(:after . ";")
+     (if (smie-rule-parent-p "classdef" "events" "enumeration" "function" "if"
+                             "while" "else" "elseif" "for" "parfor"
+                             "properties" "methods" "otherwise" "case"
+                             "try" "catch" "unwind_protect"
+                             "unwind_protect_cleanup")
+         (smie-rule-parent octave-block-offset)
+       ;; For (invalid) code between switch and case.
+       ;; (if (smie-parent-p "switch") 4)
+       nil))))
+
+(defun octave-indent-comment ()
+  "A function for `smie-indent-functions' (which see)."
+  (save-excursion
+    (back-to-indentation)
+    (cond
+     ((octave-in-string-or-comment-p) nil)
+     ((looking-at-p "\\(\\s<\\)\\1\\{2,\\}")
+      0)
+     ;; Exclude %{, %} and %!.
+     ((and (looking-at-p "\\s<\\(?:[^{}!]\\|$\\)")
+           (not (looking-at-p "\\(\\s<\\)\\1")))
+      (comment-choose-indent)))))
+
+
+(defvar octave-font-lock-keywords
+  (list
+   ;; Fontify all builtin keywords.
+   (cons (concat "\\_<\\("
+                 (regexp-opt octave-reserved-words)
+                 "\\)\\_>")
+         'font-lock-keyword-face)
+   ;; Note: 'end' also serves as the last index in an indexing expression.
+   ;; Ref: http://www.mathworks.com/help/matlab/ref/end.html
+   (list (lambda (limit)
+           (while (re-search-forward "\\_<end\\_>" limit 'move)
+             (let ((beg (match-beginning 0))
+                   (end (match-end 0)))
+               (unless (octave-in-string-or-comment-p)
+                 (condition-case nil
+                     (progn
+                       (goto-char beg)
+                       (backward-up-list)
+                       (when (memq (char-after) '(?\( ?\[ ?\{))
+                         (put-text-property beg end 'face nil))
+                       (goto-char end))
+                   (error (goto-char end))))))
+           nil))
+   ;; Fontify all operators.
+   (cons octave-operator-regexp 'font-lock-builtin-face)
+   ;; Fontify all function declarations.
+   (list octave-function-header-regexp
+         '(1 font-lock-keyword-face)
+         '(3 font-lock-function-name-face nil t)))
+  "Additional Octave expressions to highlight.")
+
+(defun octave-syntax-propertize-function (start end)
+  (goto-char start)
+  (octave-syntax-propertize-sqs end)
+  (funcall (syntax-propertize-rules
+            ("\\\\" (0 (when (eq (nth 3 (save-excursion
+                                          (syntax-ppss (match-beginning 0))))
+                                 ?\")
+                         (string-to-syntax "\\"))))
+            ;; Try to distinguish the string-quotes from the transpose-quotes.
+            ("\\(?:^\\|[[({,; ]\\)\\('\\)"
+             (1 (prog1 "\"'" (octave-syntax-propertize-sqs end)))))
+           (point) end))
+
+(defun octave-syntax-propertize-sqs (end)
+  "Propertize the content/end of single-quote strings."
+  (when (eq (nth 3 (syntax-ppss)) ?\')
+    ;; A '..' string.
+    (when (re-search-forward
+           "\\(?:\\=\\|[^']\\)\\(?:''\\)*\\('\\)\\($\\|[^']\\)" end 'move)
+      (goto-char (match-beginning 2))
+      (when (eq (char-before (match-beginning 1)) ?\\)
+        ;; Backslash cannot escape a single quote.
+        (put-text-property (1- (match-beginning 1)) (match-beginning 1)
+                           'syntax-table (string-to-syntax ".")))
+      (put-text-property (match-beginning 1) (match-end 1)
+                         'syntax-table (string-to-syntax "\"'")))))
+
+(defvar electric-layout-rules)
+
+;;;###autoload
+(define-derived-mode octave-mode prog-mode "Octave"
+  "Major mode for editing Octave code.
+
+Octave is a high-level language, primarily intended for numerical
+computations.  It provides a convenient command line interface
+for solving linear and nonlinear problems numerically.  Function
+definitions can also be stored in files and used in batch mode."
+  :abbrev-table octave-abbrev-table
+
+  (smie-setup octave-smie-grammar #'octave-smie-rules
+              :forward-token  #'octave-smie-forward-token
+              :backward-token #'octave-smie-backward-token)
+  (setq-local smie-indent-basic 'octave-block-offset)
+  (add-hook 'smie-indent-functions #'octave-indent-comment nil t)
+
+  (setq-local smie-blink-matching-triggers
+              (cons ?\; smie-blink-matching-triggers))
+  (unless octave-blink-matching-block
+    (remove-hook 'post-self-insert-hook #'smie-blink-matching-open 'local))
+
+  (setq-local electric-indent-chars
+              (cons ?\; electric-indent-chars))
+  ;; IIUC matlab-mode takes the opposite approach: it makes RET insert
+  ;; a ";" at those places where it's correct (i.e. outside of parens).
+  (setq-local electric-layout-rules '((?\; . after)))
+
+  (setq-local comment-start octave-comment-start)
+  (setq-local comment-end "")
+  (setq-local comment-start-skip octave-comment-start-skip)
+  (setq-local comment-add 1)
+
+  (setq-local parse-sexp-ignore-comments t)
+  (setq-local paragraph-start (concat "\\s-*$\\|" page-delimiter))
+  (setq-local paragraph-separate paragraph-start)
+  (setq-local paragraph-ignore-fill-prefix t)
+  (setq-local fill-paragraph-function 'octave-fill-paragraph)
+
+  (setq-local fill-nobreak-predicate
+              (lambda () (eq (octave-in-string-p) ?')))
+  (add-function :around (local 'comment-line-break-function)
+                #'octave--indent-new-comment-line)
+
+  (setq font-lock-defaults '(octave-font-lock-keywords))
+
+  (setq-local syntax-propertize-function #'octave-syntax-propertize-function)
+
+  (setq-local imenu-generic-expression octave-mode-imenu-generic-expression)
+  (setq-local imenu-case-fold-search nil)
+
+  (add-hook 'completion-at-point-functions 'octave-completion-at-point nil t)
+  (add-hook 'before-save-hook 'octave-sync-function-file-names nil t)
+  (setq-local beginning-of-defun-function 'octave-beginning-of-defun)
+  (and octave-font-lock-texinfo-comment (octave-font-lock-texinfo-comment))
+  (setq-local eldoc-documentation-function 'octave-eldoc-function)
+
+  (easy-menu-add octave-mode-menu))
+
+
+(defcustom inferior-octave-program "octave"
+  "Program invoked by `inferior-octave'."
+  :type 'string
+  :group 'octave)
+
+(defcustom inferior-octave-buffer "*Inferior Octave*"
+  "Name of buffer for running an inferior Octave process."
+  :type 'string
+  :group 'octave)
+
+(defcustom inferior-octave-prompt
+  "\\(^octave\\(\\|.bin\\|.exe\\)\\(-[.0-9]+\\)?\\(:[0-9]+\\)?\\|^debug\\|^\\)>+ "
+  "Regexp to match prompts for the inferior Octave process."
+  :type 'regexp
+  :group 'octave)
+
+(defcustom inferior-octave-prompt-read-only comint-prompt-read-only
+  "If non-nil, the Octave prompt is read only.
+See `comint-prompt-read-only' for details."
+  :type 'boolean
+  :group 'octave
+  :version "24.4")
+
+(defcustom inferior-octave-startup-file
+  (convert-standard-filename
+   (concat "~/.emacs-" (file-name-nondirectory inferior-octave-program)))
+  "Name of the inferior Octave startup file.
+The contents of this file are sent to the inferior Octave process on
+startup."
+  :type '(choice (const :tag "None" nil) file)
+  :group 'octave
+  :version "24.4")
+
+(defcustom inferior-octave-startup-args nil
+  "List of command line arguments for the inferior Octave process.
+For example, for suppressing the startup message and using `traditional'
+mode, set this to (\"-q\" \"--traditional\")."
+  :type '(repeat string)
+  :group 'octave)
+
+(defcustom inferior-octave-mode-hook nil
+  "Hook to be run when Inferior Octave mode is started."
+  :type 'hook
+  :group 'octave)
+
+(defvar inferior-octave-process nil)
+
+(defvar inferior-octave-mode-map
+  (let ((map (make-sparse-keymap)))
+    (set-keymap-parent map comint-mode-map)
+    (define-key map "\M-." 'octave-find-definition)
+    (define-key map "\t" 'completion-at-point)
+    (define-key map "\C-hd" 'octave-help)
+    ;; Same as in `shell-mode'.
+    (define-key map "\M-?" 'comint-dynamic-list-filename-completions)
+    (define-key map "\C-c\C-l" 'inferior-octave-dynamic-list-input-ring)
+    (define-key map [menu-bar inout list-history]
+      '("List Input History" . inferior-octave-dynamic-list-input-ring))
+    map)
+  "Keymap used in Inferior Octave mode.")
+
+(defvar inferior-octave-mode-syntax-table
+  (let ((table (make-syntax-table octave-mode-syntax-table)))
+    table)
+  "Syntax table in use in inferior-octave-mode buffers.")
+
+(defvar inferior-octave-font-lock-keywords
+  (list
+   (cons inferior-octave-prompt 'font-lock-type-face))
+  ;; Could certainly do more font locking in inferior Octave ...
+  "Additional expressions to highlight in Inferior Octave mode.")
+
+(defvar inferior-octave-output-list nil)
+(defvar inferior-octave-output-string nil)
+(defvar inferior-octave-receive-in-progress nil)
+
+(define-obsolete-variable-alias 'inferior-octave-startup-hook
+  'inferior-octave-mode-hook "24.4")
+
+(defvar inferior-octave-dynamic-complete-functions
+  '(inferior-octave-completion-at-point comint-filename-completion)
+  "List of functions called to perform completion for inferior Octave.
+This variable is used to initialize `comint-dynamic-complete-functions'
+in the Inferior Octave buffer.")
+
+(defvar info-lookup-mode)
+
+(define-derived-mode inferior-octave-mode comint-mode "Inferior Octave"
+  "Major mode for interacting with an inferior Octave process."
+  :abbrev-table octave-abbrev-table
+  (setq comint-prompt-regexp inferior-octave-prompt)
+
+  (setq-local comment-start octave-comment-start)
+  (setq-local comment-end "")
+  (setq comment-column 32)
+  (setq-local comment-start-skip octave-comment-start-skip)
+
+  (setq font-lock-defaults '(inferior-octave-font-lock-keywords nil nil))
+
+  (setq-local info-lookup-mode 'octave-mode)
+  (setq-local eldoc-documentation-function 'octave-eldoc-function)
+
+  (setq comint-input-ring-file-name
+        (or (getenv "OCTAVE_HISTFILE") "~/.octave_hist")
+        comint-input-ring-size (or (getenv "OCTAVE_HISTSIZE") 1024))
+  (setq-local comint-dynamic-complete-functions
+              inferior-octave-dynamic-complete-functions)
+  (setq-local comint-prompt-read-only inferior-octave-prompt-read-only)
+  (add-hook 'comint-input-filter-functions
+            'inferior-octave-directory-tracker nil t)
+  ;; http://thread.gmane.org/gmane.comp.gnu.octave.general/48572
+  (add-hook 'window-configuration-change-hook
+            'inferior-octave-track-window-width-change nil t)
+  (comint-read-input-ring t))
+
+;;;###autoload
+(defun inferior-octave (&optional arg)
+  "Run an inferior Octave process, I/O via `inferior-octave-buffer'.
+This buffer is put in Inferior Octave mode.  See `inferior-octave-mode'.
+
+Unless ARG is non-nil, switches to this buffer.
+
+The elements of the list `inferior-octave-startup-args' are sent as
+command line arguments to the inferior Octave process on startup.
+
+Additional commands to be executed on startup can be provided either in
+the file specified by `inferior-octave-startup-file' or by the default
+startup file, `~/.emacs-octave'."
+  (interactive "P")
+  (let ((buffer (get-buffer-create inferior-octave-buffer)))
+    (unless arg
+      (pop-to-buffer buffer))
+    (unless (comint-check-proc buffer)
+      (with-current-buffer buffer
+        (inferior-octave-startup)
+        (inferior-octave-mode)))
+    buffer))
+
+;;;###autoload
+(defalias 'run-octave 'inferior-octave)
+
+(defun inferior-octave-startup ()
+  "Start an inferior Octave process."
+  (let ((proc (comint-exec-1
+               (substring inferior-octave-buffer 1 -1)
+               inferior-octave-buffer
+               inferior-octave-program
+               (append (list "-i" "--no-line-editing")
+                       ;; --no-gui is introduced in Octave > 3.7
+                       (when (zerop (process-file inferior-octave-program
+                                                  nil nil nil
+                                                  "--no-gui" "--help"))
+                         (list "--no-gui"))
+                       inferior-octave-startup-args))))
+    (set-process-filter proc 'inferior-octave-output-digest)
+    (setq inferior-octave-process proc
+          inferior-octave-output-list nil
+          inferior-octave-output-string nil
+          inferior-octave-receive-in-progress t)
+
+    ;; This may look complicated ... However, we need to make sure that
+    ;; we additional startup code only AFTER Octave is ready (otherwise,
+    ;; output may be mixed up).  Hence, we need to digest the Octave
+    ;; output to see when it issues a prompt.
+    (while inferior-octave-receive-in-progress
+      (or (process-live-p inferior-octave-process)
+          (error "Process `%s' died" inferior-octave-process))
+      (accept-process-output inferior-octave-process))
+    (goto-char (point-max))
+    (set-marker (process-mark proc) (point))
+    (insert-before-markers
+     (concat
+      (if (not (bobp)) "\n")
+      (if inferior-octave-output-list
+          (concat (mapconcat
+                   'identity inferior-octave-output-list "\n")
+                  "\n"))))
+
+    ;; An empty secondary prompt, as e.g. obtained by '--braindead',
+    ;; means trouble.
+    (inferior-octave-send-list-and-digest (list "PS2\n"))
+    (when (string-match "\\(PS2\\|ans\\) = *$"
+                        (car inferior-octave-output-list))
+      (inferior-octave-send-list-and-digest (list "PS2 (\"> \");\n")))
+
+    (inferior-octave-send-list-and-digest
+     (list "disp(getenv(\"OCTAVE_SRCDIR\"))\n"))
+    (process-put proc 'octave-srcdir
+                 (unless (equal (car inferior-octave-output-list) "")
+                   (car inferior-octave-output-list)))
+
+    ;; O.K., now we are ready for the Inferior Octave startup commands.
+    (inferior-octave-send-list-and-digest
+     (list "more off;\n"
+           (unless (equal inferior-octave-output-string ">> ")
+             "PS1 (\"\\\\s> \");\n")
+           (when (and inferior-octave-startup-file
+                      (file-exists-p inferior-octave-startup-file))
+             (format "source (\"%s\");\n" inferior-octave-startup-file))))
+    (when inferior-octave-output-list
+      (insert-before-markers
+       (mapconcat 'identity inferior-octave-output-list "\n")))
+
+    ;; And finally, everything is back to normal.
+    (set-process-filter proc 'comint-output-filter)
+    ;; Just in case, to be sure a cd in the startup file
+    ;; won't have detrimental effects.
+    (inferior-octave-resync-dirs)
+    ;; Generate a proper prompt, which is critical to
+    ;; `comint-history-isearch-backward-regexp'.  Bug#14433.
+    (comint-send-string proc "\n")))
+
+(defvar inferior-octave-completion-table
+  ;;
+  ;; Use cache to avoid repetitive computation of completions due to
+  ;; bug#11906 - http://debbugs.gnu.org/11906 - which may cause
+  ;; noticeable delay.  CACHE: (CMD TIME VALUE).
+  (let ((cache))
+    (completion-table-dynamic
+     (lambda (command)
+       (unless (and (equal (car cache) command)
+                    (< (float-time) (+ 5 (cadr cache))))
+         (inferior-octave-send-list-and-digest
+          (list (concat "completion_matches (\"" command "\");\n")))
+         (setq cache (list command (float-time)
+                           (delete-consecutive-dups
+                            (sort inferior-octave-output-list 'string-lessp)))))
+       (car (cddr cache))))))
+
+(defun inferior-octave-completion-at-point ()
+  "Return the data to complete the Octave symbol at point."
+  ;; http://debbugs.gnu.org/14300
+  (let* ((filecomp (string-match-p
+                    "/" (or (comint--match-partial-filename) "")))
+         (end (point))
+         (start
+          (unless filecomp
+            (save-excursion
+              (skip-syntax-backward "w_" (comint-line-beginning-position))
+              (point)))))
+    (when (and start (> end start))
+      (list start end (completion-table-in-turn
+                       inferior-octave-completion-table
+                       'comint-completion-file-name-table)))))
+
+(define-obsolete-function-alias 'inferior-octave-complete
+  'completion-at-point "24.1")
+
+(defun inferior-octave-dynamic-list-input-ring ()
+  "List the buffer's input history in a help buffer."
+  ;; We cannot use `comint-dynamic-list-input-ring', because it replaces
+  ;; "completion" by "history reference" ...
+  (interactive)
+  (if (or (not (ring-p comint-input-ring))
+          (ring-empty-p comint-input-ring))
+      (message "No history")
+    (let ((history nil)
+          (history-buffer " *Input History*")
+          (index (1- (ring-length comint-input-ring)))
+          (conf (current-window-configuration)))
+      ;; We have to build up a list ourselves from the ring vector.
+      (while (>= index 0)
+        (setq history (cons (ring-ref comint-input-ring index) history)
+              index (1- index)))
+      ;; Change "completion" to "history reference"
+      ;; to make the display accurate.
+      (with-output-to-temp-buffer history-buffer
+        (display-completion-list history)
+        (set-buffer history-buffer))
+      (message "Hit space to flush")
+      (let ((ch (read-event)))
+        (if (eq ch ?\ )
+            (set-window-configuration conf)
+          (setq unread-command-events (list ch)))))))
+
+(defun inferior-octave-output-digest (_proc string)
+  "Special output filter for the inferior Octave process.
+Save all output between newlines into `inferior-octave-output-list', and
+the rest to `inferior-octave-output-string'."
+  (setq string (concat inferior-octave-output-string string))
+  (while (string-match "\n" string)
+    (setq inferior-octave-output-list
+          (append inferior-octave-output-list
+                  (list (substring string 0 (match-beginning 0))))
+          string (substring string (match-end 0))))
+  (if (string-match inferior-octave-prompt string)
+      (setq inferior-octave-receive-in-progress nil))
+  (setq inferior-octave-output-string string))
+
+(defun inferior-octave-check-process ()
+  (or (and inferior-octave-process
+           (process-live-p inferior-octave-process))
+      (error (substitute-command-keys
+              "No inferior octave process running. Type \\[run-octave]"))))
+
+(defun inferior-octave-send-list-and-digest (list)
+  "Send LIST to the inferior Octave process and digest the output.
+The elements of LIST have to be strings and are sent one by one.  All
+output is passed to the filter `inferior-octave-output-digest'."
+  (inferior-octave-check-process)
+  (let* ((proc inferior-octave-process)
+         (filter (process-filter proc))
+         string)
+    (set-process-filter proc 'inferior-octave-output-digest)
+    (setq inferior-octave-output-list nil)
+    (unwind-protect
+        (while (setq string (car list))
+          (setq inferior-octave-output-string nil
+                inferior-octave-receive-in-progress t)
+          (comint-send-string proc string)
+          (while inferior-octave-receive-in-progress
+            (accept-process-output proc))
+          (setq list (cdr list)))
+      (set-process-filter proc filter))))
+
+(defvar inferior-octave-directory-tracker-resync nil)
+(make-variable-buffer-local 'inferior-octave-directory-tracker-resync)
+
+(defun inferior-octave-directory-tracker (string)
+  "Tracks `cd' commands issued to the inferior Octave process.
+Use \\[inferior-octave-resync-dirs] to resync if Emacs gets confused."
+  (when inferior-octave-directory-tracker-resync
+    (setq inferior-octave-directory-tracker-resync nil)
+    (inferior-octave-resync-dirs))
+  (cond
+   ((string-match "^[ \t]*cd[ \t;]*$" string)
+    (cd "~"))
+   ((string-match "^[ \t]*cd[ \t]+\\([^ \t\n;]*\\)[ \t\n;]*" string)
+    (condition-case err
+        (cd (match-string 1 string))
+      (error (setq inferior-octave-directory-tracker-resync t)
+             (message "%s: `%s'"
+                      (error-message-string err)
+                      (match-string 1 string)))))))
+
+(defun inferior-octave-resync-dirs ()
+  "Resync the buffer's idea of the current directory.
+This command queries the inferior Octave process about its current
+directory and makes this the current buffer's default directory."
+  (interactive)
+  (inferior-octave-send-list-and-digest '("disp (pwd ())\n"))
+  (cd (car inferior-octave-output-list)))
+
+(defcustom inferior-octave-minimal-columns 80
+  "The minimal column width for the inferior Octave process."
+  :type 'integer
+  :group 'octave
+  :version "24.4")
+
+(defvar inferior-octave-last-column-width nil)
+
+(defun inferior-octave-track-window-width-change ()
+  ;; http://thread.gmane.org/gmane.comp.gnu.octave.general/48572
+  (let ((width (max inferior-octave-minimal-columns (window-width))))
+    (unless (eq inferior-octave-last-column-width width)
+      (setq-local inferior-octave-last-column-width width)
+      (when (and inferior-octave-process
+                 (process-live-p inferior-octave-process))
+        (inferior-octave-send-list-and-digest
+         (list (format "putenv(\"COLUMNS\", \"%s\");\n" width)))))))
+
+
+;;; Miscellaneous useful functions
+
+(defun octave-in-comment-p ()
+  "Return non-nil if point is inside an Octave comment."
+  (nth 4 (syntax-ppss)))
+
+(defun octave-in-string-p ()
+  "Return non-nil if point is inside an Octave string."
+  (nth 3 (syntax-ppss)))
+
+(defun octave-in-string-or-comment-p ()
+  "Return non-nil if point is inside an Octave string or comment."
+  (nth 8 (syntax-ppss)))
+
+(defun octave-looking-at-kw (regexp)
+  "Like `looking-at', but sets `case-fold-search' nil."
+  (let ((case-fold-search nil))
+    (looking-at regexp)))
+
+(defun octave-maybe-insert-continuation-string ()
+  (if (or (octave-in-comment-p)
+          (save-excursion
+            (beginning-of-line)
+            (looking-at octave-continuation-regexp)))
+      nil
+    (delete-horizontal-space)
+    (insert (concat " " octave-continuation-string))))
+
+(defun octave-completing-read ()
+  (let ((def (or (thing-at-point 'symbol)
+                 (save-excursion
+                   (skip-syntax-backward "-(")
+                   (thing-at-point 'symbol)))))
+    (completing-read
+     (format (if def "Function (default %s): "
+               "Function: ") def)
+     inferior-octave-completion-table
+     nil nil nil nil def)))
+
+(defun octave-goto-function-definition (fn)
+  "Go to the function definition of FN in current buffer."
+  (goto-char (point-min))
+  (let ((search
+         (lambda (re sub)
+           (let (done)
+             (while (and (not done) (re-search-forward re nil t))
+               (when (and (equal (match-string sub) fn)
+                          (not (nth 8 (syntax-ppss))))
+                 (setq done t)))
+             (or done (goto-char (point-min)))))))
+    (pcase (file-name-extension (buffer-file-name))
+      (`"cc" (funcall search
+                      "\\_<DEFUN\\(?:_DLD\\)?\\s-*(\\s-*\\(\\(?:\\sw\\|\\s_\\)+\\)" 1))
+      (t (funcall search octave-function-header-regexp 3)))))
+
+(defun octave-function-file-p ()
+  "Return non-nil if the first token is \"function\".
+The value is (START END NAME-START NAME-END) of the function."
+  (save-excursion
+    (goto-char (point-min))
+    (when (equal (funcall smie-forward-token-function) "function")
+      (forward-word -1)
+      (let* ((start (point))
+             (end (progn (forward-sexp 1) (point)))
+             (name (when (progn
+                           (goto-char start)
+                           (re-search-forward octave-function-header-regexp
+                                              end t))
+                     (list (match-beginning 3) (match-end 3)))))
+        (cons start (cons end name))))))
+
+;; Like forward-comment but stop at non-comment blank
+(defun octave-skip-comment-forward (limit)
+  (let ((ppss (syntax-ppss)))
+    (if (nth 4 ppss)
+        (goto-char (nth 8 ppss))
+      (goto-char (or (comment-search-forward limit t) (point)))))
+  (while (and (< (point) limit) (looking-at-p "\\s<"))
+    (forward-comment 1)))
+
+;;; First non-copyright comment block
+(defun octave-function-file-comment ()
+  "Beginning and end positions of the function file comment."
+  (save-excursion
+    (goto-char (point-min))
+    ;; Copyright block: octave/libinterp/parse-tree/lex.ll around line 1634
+    (while (save-excursion
+             (when (comment-search-forward (point-max) t)
+               (when (eq (char-after) ?\{) ; case of block comment
+                 (forward-char 1))
+               (skip-syntax-forward "-")
+               (let ((case-fold-search t))
+                 (looking-at-p "\\(?:copyright\\|author\\)\\_>"))))
+      (octave-skip-comment-forward (point-max)))
+    (let ((beg (comment-search-forward (point-max) t)))
+      (when beg
+        (goto-char beg)
+        (octave-skip-comment-forward (point-max))
+        (list beg (point))))))
+
+(defun octave-sync-function-file-names ()
+  "Ensure function name agree with function file name.
+See Info node `(octave)Function Files'."
+  (interactive)
+  (when buffer-file-name
+    (pcase-let ((`(,start ,_end ,name-start ,name-end)
+                 (octave-function-file-p)))
+      (when (and start name-start)
+        (let* ((func (buffer-substring name-start name-end))
+               (file (file-name-sans-extension
+                      (file-name-nondirectory buffer-file-name)))
+               (help-form (format "\
+a: Use function name `%s'
+b: Use file name `%s'
+q: Don't fix\n" func file))
+               (c (unless (equal file func)
+                    (save-window-excursion
+                      (help-form-show)
+                      (read-char-choice
+                       "Which name to use? (a/b/q) " '(?a ?b ?q))))))
+          (pcase c
+            (`?a (let ((newname (expand-file-name
+                                 (concat func (file-name-extension
+                                               buffer-file-name t)))))
+                   (when (or (not (file-exists-p newname))
+                             (yes-or-no-p
+                              (format "Target file %s exists; proceed? " newname)))
+                     (when (file-exists-p buffer-file-name)
+                       (rename-file buffer-file-name newname t))
+                     (set-visited-file-name newname))))
+            (`?b (save-excursion
+                   (goto-char name-start)
+                   (delete-region name-start name-end)
+                   (insert file)))))))))
+
+(defun octave-update-function-file-comment (beg end)
+  "Query replace function names in function file comment."
+  (interactive
+   (progn
+     (barf-if-buffer-read-only)
+     (if (use-region-p)
+         (list (region-beginning) (region-end))
+       (or (octave-function-file-comment)
+           (error "No function file comment found")))))
+  (save-excursion
+    (let* ((bounds (or (octave-function-file-p)
+                       (error "Not in a function file buffer")))
+           (func (if (cddr bounds)
+                     (apply #'buffer-substring (cddr bounds))
+                   (error "Function name not found")))
+           (old-func (progn
+                       (goto-char beg)
+                       (when (re-search-forward
+                              "[=}]\\s-*\\(\\(?:\\sw\\|\\s_\\)+\\)\\_>"
+                              (min (line-end-position 4) end)
+                              t)
+                         (match-string 1))))
+           (old-func (read-string (format (if old-func
+                                              "Name to replace (default %s): "
+                                            "Name to replace: ")
+                                          old-func)
+                                  nil nil old-func)))
+      (if (and func old-func (not (equal func old-func)))
+          (perform-replace old-func func 'query
+                           nil 'delimited nil nil beg end)
+        (message "Function names match")))))
+
+(defface octave-function-comment-block
+  '((t (:inherit font-lock-doc-face)))
+  "Face used to highlight function comment block."
+  :group 'octave)
+
+(eval-when-compile (require 'texinfo))
+
+(defun octave-font-lock-texinfo-comment ()
+  (let ((kws
+         (eval-when-compile
+           (delq nil (mapcar
+                      (lambda (kw)
+                        (if (numberp (nth 1 kw))
+                            `(,(nth 0 kw) ,(nth 1 kw) ,(nth 2 kw) prepend)
+                          (message "Ignoring Texinfo highlight: %S" kw)))
+                      texinfo-font-lock-keywords)))))
+    (font-lock-add-keywords
+     nil
+     `((,(lambda (limit)
+           (while (and (< (point) limit)
+                       (search-forward "-*- texinfo -*-" limit t)
+                       (octave-in-comment-p))
+             (let ((beg (nth 8 (syntax-ppss)))
+                   (end (progn
+                          (octave-skip-comment-forward (point-max))
+                          (point))))
+               (put-text-property beg end 'font-lock-multiline t)
+               (font-lock-prepend-text-property
+                beg end 'face 'octave-function-comment-block)
+               (dolist (kw kws)
+                 (goto-char beg)
+                 (while (re-search-forward (car kw) end 'move)
+                   (font-lock-apply-highlight (cdr kw))))))
+           nil)))
+     'append)))
+
+
+;;; Indentation
+
+(defun octave-indent-new-comment-line (&optional soft)
+  ;; FIXME: C-M-j should probably be bound globally to a function like
+  ;; this one.
+  "Break Octave line at point, continuing comment if within one.
+Insert `octave-continuation-string' before breaking the line
+unless inside a list.  Signal an error if within a single-quoted
+string."
+  (interactive)
+  (funcall comment-line-break-function soft))
+
+(defun octave--indent-new-comment-line (orig &rest args)
+  (cond
+   ((octave-in-comment-p) nil)
+   ((eq (octave-in-string-p) ?')
+    (error "Cannot split a single-quoted string"))
+   ((eq (octave-in-string-p) ?\")
+    (insert octave-continuation-string))
+   (t
+    (delete-horizontal-space)
+    (unless (and (cadr (syntax-ppss))
+                 (eq (char-after (cadr (syntax-ppss))) ?\())
+      (insert " " octave-continuation-string))))
+  (apply orig args)
+  (indent-according-to-mode))
+
+(define-obsolete-function-alias
+  'octave-indent-defun 'prog-indent-sexp "24.4")
+
+
+;;; Motion
+(defun octave-next-code-line (&optional arg)
+  "Move ARG lines of Octave code forward (backward if ARG is negative).
+Skips past all empty and comment lines.  Default for ARG is 1.
+
+On success, return 0.  Otherwise, go as far as possible and return -1."
+  (interactive "p")
+  (or arg (setq arg 1))
+  (beginning-of-line)
+  (let ((n 0)
+        (inc (if (> arg 0) 1 -1)))
+    (while (and (/= arg 0) (= n 0))
+      (setq n (forward-line inc))
+      (while (and (= n 0)
+                  (looking-at "\\s-*\\($\\|\\s<\\)"))
+        (setq n (forward-line inc)))
+      (setq arg (- arg inc)))
+    n))
+
+(defun octave-previous-code-line (&optional arg)
+  "Move ARG lines of Octave code backward (forward if ARG is negative).
+Skips past all empty and comment lines.  Default for ARG is 1.
+
+On success, return 0.  Otherwise, go as far as possible and return -1."
+  (interactive "p")
+  (or arg (setq arg 1))
+  (octave-next-code-line (- arg)))
+
+(defun octave-beginning-of-line ()
+  "Move point to beginning of current Octave line.
+If on an empty or comment line, go to the beginning of that line.
+Otherwise, move backward to the beginning of the first Octave code line
+which is not inside a continuation statement, i.e., which does not
+follow a code line ending with `...' or is inside an open
+parenthesis list."
+  (interactive)
+  (beginning-of-line)
+  (unless (looking-at "\\s-*\\($\\|\\s<\\)")
+    (while (or (when (cadr (syntax-ppss))
+                 (goto-char (cadr (syntax-ppss)))
+                 (beginning-of-line)
+                 t)
+               (and (or (looking-at "\\s-*\\($\\|\\s<\\)")
+                        (save-excursion
+                          (if (zerop (octave-previous-code-line))
+                              (looking-at octave-continuation-regexp))))
+                    (zerop (forward-line -1)))))))
+
+(defun octave-end-of-line ()
+  "Move point to end of current Octave line.
+If on an empty or comment line, go to the end of that line.
+Otherwise, move forward to the end of the first Octave code line which
+does not end with `...' or is inside an open parenthesis list."
+  (interactive)
+  (end-of-line)
+  (unless (save-excursion
+            (beginning-of-line)
+            (looking-at "\\s-*\\($\\|\\s<\\)"))
+    (while (or (when (cadr (syntax-ppss))
+                 (condition-case nil
+                     (progn
+                       (up-list 1)
+                       (end-of-line)
+                       t)
+                   (error nil)))
+               (and (save-excursion
+                      (beginning-of-line)
+                      (or (looking-at "\\s-*\\($\\|\\s<\\)")
+                          (looking-at octave-continuation-regexp)))
+                    (zerop (forward-line 1)))))
+    (end-of-line)))
+
+(defun octave-mark-block ()
+  "Put point at the beginning of this Octave block, mark at the end.
+The block marked is the one that contains point or follows point."
+  (interactive)
+  (if (and (looking-at "\\sw\\|\\s_")
+           (looking-back "\\sw\\|\\s_" (1- (point))))
+      (skip-syntax-forward "w_"))
+  (unless (or (looking-at "\\s(")
+              (save-excursion
+                (let* ((token (funcall smie-forward-token-function))
+                       (level (assoc token smie-grammar)))
+                  (and level (not (numberp (cadr level)))))))
+    (backward-up-list 1))
+  (mark-sexp))
+
+(defun octave-beginning-of-defun (&optional arg)
+  "Octave-specific `beginning-of-defun-function' (which see)."
+  (or arg (setq arg 1))
+  ;; Move out of strings or comments.
+  (when (octave-in-string-or-comment-p)
+    (goto-char (octave-in-string-or-comment-p)))
+  (letrec ((orig (point))
+           (toplevel (lambda (pos)
+                       (condition-case nil
+                           (progn
+                             (backward-up-list 1)
+                             (funcall toplevel (point)))
+                         (scan-error pos)))))
+    (goto-char (funcall toplevel (point)))
+    (when (and (> arg 0) (/= orig (point)))
+      (setq arg (1- arg)))
+    (forward-sexp (- arg))
+    (and (< arg 0) (forward-sexp -1))
+    (/= orig (point))))
+
+(defun octave-fill-paragraph (&optional _arg)
+  "Fill paragraph of Octave code, handling Octave comments."
+  ;; FIXME: difference with generic fill-paragraph:
+  ;; - code lines are only split, never joined.
+  ;; - \n that end comments are never removed.
+  ;; - insert continuation marker when splitting code lines.
+  (interactive "P")
+  (save-excursion
+    (let ((end (progn (forward-paragraph) (copy-marker (point) t)))
+          (beg (progn
+                 (forward-paragraph -1)
+                 (skip-chars-forward " \t\n")
+                 (beginning-of-line)
+                 (point)))
+          (cfc (current-fill-column))
+          comment-prefix)
+      (goto-char beg)
+      (while (< (point) end)
+        (condition-case nil
+            (indent-according-to-mode)
+          (error nil))
+        (move-to-column cfc)
+        ;; First check whether we need to combine non-empty comment lines
+        (if (and (< (current-column) cfc)
+                 (octave-in-comment-p)
+                 (not (save-excursion
+                        (beginning-of-line)
+                        (looking-at "^\\s-*\\s<+\\s-*$"))))
+            ;; This is a nonempty comment line which does not extend
+            ;; past the fill column.  If it is followed by a nonempty
+            ;; comment line with the same comment prefix, try to
+            ;; combine them, and repeat this until either we reach the
+            ;; fill-column or there is nothing more to combine.
+            (progn
+              ;; Get the comment prefix
+              (save-excursion
+                (beginning-of-line)
+                (while (and (re-search-forward "\\s<+")
+                            (not (octave-in-comment-p))))
+                (setq comment-prefix (match-string 0)))
+              ;; And keep combining ...
+              (while (and (< (current-column) cfc)
+                          (save-excursion
+                            (forward-line 1)
+                            (and (looking-at
+                                  (concat "^\\s-*"
+                                          comment-prefix
+                                          "\\S<"))
+                                 (not (looking-at
+                                       (concat "^\\s-*"
+                                               comment-prefix
+                                               "\\s-*$"))))))
+                (delete-char 1)
+                (re-search-forward comment-prefix)
+                (delete-region (match-beginning 0) (match-end 0))
+                (fixup-whitespace)
+                (move-to-column cfc))))
+        ;; We might also try to combine continued code lines>  Perhaps
+        ;; some other time ...
+        (skip-chars-forward "^ \t\n")
+        (delete-horizontal-space)
+        (if (or (< (current-column) cfc)
+                (and (= (current-column) cfc) (eolp)))
+            (forward-line 1)
+          (if (not (eolp)) (insert " "))
+          (or (funcall normal-auto-fill-function)
+              (forward-line 1))))
+      t)))
+
+;;; Completions
+
+(defun octave-completion-at-point ()
+  "Find the text to complete and the corresponding table."
+  (let* ((beg (save-excursion (skip-syntax-backward "w_") (point)))
+         (end (point)))
+    (if (< beg (point))
+        ;; Extend region past point, if applicable.
+        (save-excursion (skip-syntax-forward "w_")
+                        (setq end (point))))
+    (when (> end beg)
+      (list beg end (or (and inferior-octave-process
+                             (process-live-p inferior-octave-process)
+                             inferior-octave-completion-table)
+                        octave-reserved-words)))))
+
+(define-obsolete-function-alias 'octave-complete-symbol
+  'completion-at-point "24.1")
+
+;;; Electric characters && friends
+(define-skeleton octave-insert-defun
+  "Insert an Octave function skeleton.
+Prompt for the function's name, arguments and return values (to be
+entered without parens)."
+  (let* ((defname (file-name-sans-extension (buffer-name)))
+         (name (read-string (format "Function name (default %s): " defname)
+                            nil nil defname))
+         (args (read-string "Arguments: "))
+         (vals (read-string "Return values: ")))
+    (format "%s%s (%s)"
+            (cond
+             ((string-equal vals "") vals)
+             ((string-match "[ ,]" vals) (concat "[" vals "] = "))
+             (t (concat vals " = ")))
+            name
+            args))
+  \n octave-block-comment-start "usage: " str \n
+  octave-block-comment-start '(delete-horizontal-space) \n
+  octave-block-comment-start '(delete-horizontal-space) \n
+  "function " > str \n
+  _ \n
+  "endfunction" > \n)
+
+;;; Communication with the inferior Octave process
+(defun octave-kill-process ()
+  "Kill inferior Octave process and its buffer."
+  (interactive)
+  (if inferior-octave-process
+      (progn
+        (process-send-string inferior-octave-process "quit;\n")
+        (accept-process-output inferior-octave-process)))
+  (if inferior-octave-buffer
+      (kill-buffer inferior-octave-buffer)))
+
+(defun octave-show-process-buffer ()
+  "Make sure that `inferior-octave-buffer' is displayed."
+  (interactive)
+  (if (get-buffer inferior-octave-buffer)
+      (display-buffer inferior-octave-buffer)
+    (message "No buffer named %s" inferior-octave-buffer)))
+
+(defun octave-hide-process-buffer ()
+  "Delete all windows that display `inferior-octave-buffer'."
+  (interactive)
+  (if (get-buffer inferior-octave-buffer)
+      (delete-windows-on inferior-octave-buffer)
+    (message "No buffer named %s" inferior-octave-buffer)))
+
+(defun octave-send-region (beg end)
+  "Send current region to the inferior Octave process."
+  (interactive "r")
+  (inferior-octave t)
+  (let ((proc inferior-octave-process)
+        (string (buffer-substring-no-properties beg end))
+        line)
+    (with-current-buffer inferior-octave-buffer
+      (setq inferior-octave-output-list nil)
+      (while (not (string-equal string ""))
+        (if (string-match "\n" string)
+            (setq line (substring string 0 (match-beginning 0))
+                  string (substring string (match-end 0)))
+          (setq line string string ""))
+        (setq inferior-octave-receive-in-progress t)
+        (inferior-octave-send-list-and-digest (list (concat line "\n")))
+        (while inferior-octave-receive-in-progress
+          (accept-process-output proc))
+        (insert-before-markers
+         (mapconcat 'identity
+                    (append
+                     (if octave-send-echo-input (list line) (list ""))
+                     inferior-octave-output-list
+                     (list inferior-octave-output-string))
+                    "\n")))))
+  (if octave-send-show-buffer
+      (display-buffer inferior-octave-buffer)))
+
+(defun octave-send-block ()
+  "Send current Octave block to the inferior Octave process."
+  (interactive)
+  (save-excursion
+    (octave-mark-block)
+    (octave-send-region (point) (mark))))
+
+(defun octave-send-defun ()
+  "Send current Octave function to the inferior Octave process."
+  (interactive)
+  (save-excursion
+    (mark-defun)
+    (octave-send-region (point) (mark))))
+
+(defun octave-send-line (&optional arg)
+  "Send current Octave code line to the inferior Octave process.
+With positive prefix ARG, send that many lines.
+If `octave-send-line-auto-forward' is non-nil, go to the next unsent
+code line."
+  (interactive "P")
+  (or arg (setq arg 1))
+  (if (> arg 0)
+      (let (beg end)
+        (beginning-of-line)
+        (setq beg (point))
+        (octave-next-code-line (- arg 1))
+        (end-of-line)
+        (setq end (point))
+        (if octave-send-line-auto-forward
+            (octave-next-code-line 1))
+        (octave-send-region beg end))))
+
+(defun octave-eval-print-last-sexp ()
+  "Evaluate Octave sexp before point and print value into current buffer."
+  (interactive)
+  (inferior-octave t)
+  (let ((standard-output (current-buffer))
+        (print-escape-newlines nil)
+        (opoint (point)))
+    (terpri)
+    (prin1
+     (save-excursion
+       (forward-sexp -1)
+       (inferior-octave-send-list-and-digest
+        (list (concat (buffer-substring-no-properties (point) opoint)
+                      "\n")))
+       (mapconcat 'identity inferior-octave-output-list "\n")))
+    (terpri)))
+
+
+
+(defcustom octave-eldoc-message-style 'auto
+  "Octave eldoc message style: auto, oneline, multiline."
+  :type '(choice (const :tag "Automatic" auto)
+                 (const :tag "One Line" oneline)
+                 (const :tag "Multi Line" multiline))
+  :group 'octave
+  :version "24.4")
+
+;; (FN SIGNATURE1 SIGNATURE2 ...)
+(defvar octave-eldoc-cache nil)
+
+(defun octave-eldoc-function-signatures (fn)
+  (unless (equal fn (car octave-eldoc-cache))
+    (inferior-octave-send-list-and-digest
+     (list (format "\
+if ismember(exist(\"%s\"), [2 3 5 103]) print_usage(\"%s\") endif\n"
+                   fn fn)))
+    (let (result)
+      (dolist (line inferior-octave-output-list)
+        (when (string-match
+               "\\s-*\\(?:--[^:]+\\|usage\\):\\s-*\\(.*\\)$"
+               line)
+          (push (match-string 1 line) result)))
+      (setq octave-eldoc-cache
+            (cons (substring-no-properties fn)
+                  (nreverse result)))))
+  (cdr octave-eldoc-cache))
+
+(defun octave-eldoc-function ()
+  "A function for `eldoc-documentation-function' (which see)."
+  (when (and inferior-octave-process
+             (process-live-p inferior-octave-process))
+    (let* ((ppss (syntax-ppss))
+           (paren-pos (cadr ppss))
+           (fn (save-excursion
+                 (if (and paren-pos
+                          ;; PAREN-POS must be after the prompt
+                          (>= paren-pos
+                              (if (eq (get-buffer-process (current-buffer))
+                                      inferior-octave-process)
+                                  (process-mark inferior-octave-process)
+                                (point-min)))
+                          (or (not (eq (get-buffer-process (current-buffer))
+                                       inferior-octave-process))
+                              (< (process-mark inferior-octave-process)
+                                 paren-pos))
+                          (eq (char-after paren-pos) ?\())
+                     (goto-char paren-pos)
+                   (setq paren-pos nil))
+                 (when (or (< (skip-syntax-backward "-") 0) paren-pos)
+                   (thing-at-point 'symbol))))
+           (sigs (and fn (octave-eldoc-function-signatures fn)))
+           (oneline (mapconcat 'identity sigs
+                               (propertize " | " 'face 'warning)))
+           (multiline (mapconcat (lambda (s) (concat "-- " s)) sigs "\n")))
+      ;;
+      ;; Return the value according to style.
+      (pcase octave-eldoc-message-style
+        (`auto (if (< (length oneline) (window-width (minibuffer-window)))
+                   oneline
+                 multiline))
+        (`oneline oneline)
+        (`multiline multiline)))))
+
+(defcustom octave-help-buffer "*Octave Help*"
+  "Buffer name for `octave-help'."
+  :type 'string
+  :group 'octave
+  :version "24.4")
+
+(define-button-type 'octave-help-file
+  'follow-link t
+  'action #'help-button-action
+  'help-function 'octave-find-definition)
+
+(define-button-type 'octave-help-function
+  'follow-link t
+  'action (lambda (b)
+            (octave-help
+             (buffer-substring (button-start b) (button-end b)))))
+
+(defvar octave-help-mode-map
+  (let ((map (make-sparse-keymap)))
+    (define-key map "\M-." 'octave-find-definition)
+    (define-key map "\C-hd" 'octave-help)
+    map))
+
+(define-derived-mode octave-help-mode help-mode "OctHelp"
+  "Major mode for displaying Octave documentation."
+  :abbrev-table nil
+  :syntax-table octave-mode-syntax-table
+  (eval-and-compile (require 'help-mode))
+  ;; Mostly stolen from `help-make-xrefs'.
+  (let ((inhibit-read-only t))
+    (setq-local info-lookup-mode 'octave-mode)
+    ;; Delete extraneous newlines at the end of the docstring
+    (goto-char (point-max))
+    (while (and (not (bobp)) (bolp))
+      (delete-char -1))
+    (insert "\n")
+    (when (or help-xref-stack help-xref-forward-stack)
+      (insert "\n"))
+    (when help-xref-stack
+      (help-insert-xref-button help-back-label 'help-back
+                               (current-buffer)))
+    (when help-xref-forward-stack
+      (when help-xref-stack
+        (insert "\t"))
+      (help-insert-xref-button help-forward-label 'help-forward
+                               (current-buffer)))
+    (when (or help-xref-stack help-xref-forward-stack)
+      (insert "\n"))))
+
+(defvar octave-help-mode-finish-hook nil
+  "Octave specific hook for `temp-buffer-show-hook'.")
+
+(defun octave-help-mode-finish ()
+  (when (eq major-mode 'octave-help-mode)
+    (run-hooks 'octave-help-mode-finish-hook)))
+
+(add-hook 'temp-buffer-show-hook 'octave-help-mode-finish)
+
+(defun octave-help (fn)
+  "Display the documentation of FN."
+  (interactive (list (octave-completing-read)))
+  (inferior-octave-send-list-and-digest
+   (list (format "help \"%s\"\n" fn)))
+  (let ((lines inferior-octave-output-list)
+        (inhibit-read-only t))
+    (when (string-match "error: \\(.*\\)$" (car lines))
+      (error "%s" (match-string 1 (car lines))))
+    (with-help-window octave-help-buffer
+      (princ (mapconcat 'identity lines "\n"))
+      (with-current-buffer octave-help-buffer
+        ;; Bound to t so that `help-buffer' returns current buffer for
+        ;; `help-setup-xref'.
+        (let ((help-xref-following t))
+          (help-setup-xref (list 'octave-help fn)
+                           (called-interactively-p 'interactive)))
+        ;; Note: can be turned off by suppress_verbose_help_message.
+        ;;
+        ;; Remove boring trailing text: Additional help for built-in functions
+        ;; and operators ...
+        (goto-char (point-max))
+        (when (search-backward "\n\n\n" nil t)
+          (goto-char (match-beginning 0))
+          (delete-region (point) (point-max)))
+        ;; File name highlight
+        (goto-char (point-min))
+        (when (re-search-forward "from the file \\(.*\\)$"
+                                 (line-end-position)
+                                 t)
+          (let* ((file (match-string 1))
+                 (dir (file-name-directory
+                       (directory-file-name (file-name-directory file)))))
+            (replace-match "" nil nil nil 1)
+            (insert "`")
+            ;; Include the parent directory which may be regarded as
+            ;; the category for the FN.
+            (help-insert-xref-button (file-relative-name file dir)
+                                     'octave-help-file fn)
+            (insert "'")))
+        ;; Make 'See also' clickable
+        (with-syntax-table octave-mode-syntax-table
+          (when (re-search-forward "^\\s-*See also:" nil t)
+            (let ((end (save-excursion (re-search-forward "^\\s-*$" nil t))))
+              (while (re-search-forward "\\_<\\(?:\\sw\\|\\s_\\)+\\_>" end t)
+                (make-text-button (match-beginning 0) (match-end 0)
+                                  :type 'octave-help-function)))))
+        (octave-help-mode)))))
+
+(defcustom octave-source-directories nil
+  "A list of directories for Octave sources.
+If the environment variable OCTAVE_SRCDIR is set, it is searched first."
+  :type '(repeat directory)
+  :group 'octave
+  :version "24.4")
+
+(defun octave-source-directories ()
+  (let ((srcdir (or (and inferior-octave-process
+                         (process-get inferior-octave-process 'octave-srcdir))
+                    (getenv "OCTAVE_SRCDIR"))))
+    (if srcdir
+        (cons srcdir octave-source-directories)
+      octave-source-directories)))
+
+(defvar octave-find-definition-filename-function
+  #'octave-find-definition-default-filename)
+
+(defun octave-find-definition-default-filename (name)
+  "Default value for `octave-find-definition-filename-function'."
+  (pcase (file-name-extension name)
+    (`"oct"
+     (octave-find-definition-default-filename
+      (concat "libinterp/dldfcn/"
+              (file-name-sans-extension (file-name-nondirectory name))
+              ".cc")))
+    (`"cc"
+     (let ((file (or (locate-file name (octave-source-directories))
+                     (locate-file (file-name-nondirectory name)
+                                  (octave-source-directories)))))
+       (or (and file (file-exists-p file))
+           (error "File `%s' not found" name))
+       file))
+    (`"mex"
+     (if (yes-or-no-p (format "File `%s' may be binary; open? "
+                              (file-name-nondirectory name)))
+         name
+       (user-error "Aborted")))
+    (t name)))
+
+(defvar find-tag-marker-ring)
+
+(defun octave-find-definition (fn)
+  "Find the definition of FN.
+Functions implemented in C++ can be found if
+`octave-source-directories' is set correctly."
+  (interactive (list (octave-completing-read)))
+  (inferior-octave-send-list-and-digest
+   ;; help NAME is more verbose
+   (list (format "\
+if iskeyword(\"%s\") disp(\"`%s' is a keyword\") else which(\"%s\") endif\n"
+                 fn fn fn)))
+  (let* ((line (car inferior-octave-output-list))
+         (file (when (and line (string-match "from the file \\(.*\\)$" line))
+                 (match-string 1 line))))
+    (if (not file)
+        (user-error "%s" (or line (format "`%s' not found" fn)))
+      (require 'etags)
+      (ring-insert find-tag-marker-ring (point-marker))
+      (setq file (funcall octave-find-definition-filename-function file))
+      (when file
+        (find-file file)
+        (octave-goto-function-definition fn)))))
+
+
+(provide 'octave)
+;;; octave.el ends here
diff --git a/lisp/progmodes/opascal.el b/lisp/progmodes/opascal.el
index 5f78b770936..e608ea8af0e 100644
--- a/lisp/progmodes/opascal.el
+++ b/lisp/progmodes/opascal.el
@@ -110,29 +110,6 @@ end;                            end;"
 regardless of where in the line point is when the TAB command is used."
   :type 'boolean)
 
-(define-obsolete-variable-alias
-  'delphi-comment-face 'opascal-comment-face "24.4")
-(defcustom opascal-comment-face 'font-lock-comment-face
-  "Face used to color OPascal comments."
-  :type 'face)
-
-(define-obsolete-variable-alias
-  'delphi-string-face 'opascal-string-face "24.4")
-(defcustom opascal-string-face 'font-lock-string-face
-  "Face used to color OPascal strings."
-  :type 'face)
-
-(define-obsolete-variable-alias
-  'delphi-keyword-face 'opascal-keyword-face "24.4")
-(defcustom opascal-keyword-face 'font-lock-keyword-face
-  "Face used to color OPascal keywords."
-  :type 'face)
-
-(define-obsolete-variable-alias 'delphi-other-face 'opascal-other-face "24.4")
-(defcustom opascal-other-face nil
-  "Face used to color everything else."
-  :type '(choice (const :tag "None" nil) face))
-
 (defconst opascal-directives
   '(absolute abstract assembler automated cdecl default dispid dynamic
     export external far forward index inline message name near nodefault
@@ -274,6 +251,21 @@ routine.")
 (defconst opascal-leading-spaces-re (concat "^" opascal-spaces-re))
 (defconst opascal-word-chars "a-zA-Z0-9_")
 
+(defvar opascal-mode-syntax-table
+  (let ((st (make-syntax-table)))
+    ;; Strings.
+    (modify-syntax-entry ?\" "\"" st)
+    (modify-syntax-entry ?\' "\"" st)
+    ;; Comments.
+    (modify-syntax-entry ?\{ "<" st)
+    (modify-syntax-entry ?\} ">" st)
+    (modify-syntax-entry ?\( "()1" st)
+    (modify-syntax-entry ?\) ")(4" st)
+    (modify-syntax-entry ?*  ". 23b" st)
+    (modify-syntax-entry ?/  ". 12c" st)
+    (modify-syntax-entry ?\n "> c" st)
+    st))
+
 (defmacro opascal-save-excursion (&rest forms)
   ;; Executes the forms such that any movements have no effect, including
   ;; searches.
@@ -283,13 +275,6 @@ routine.")
             (deactivate-mark nil))
         (progn ,@forms)))))
 
-(defmacro opascal-save-state (&rest forms)
-  ;; Executes the forms such that any buffer modifications do not have any side
-  ;; effects beyond the buffer's actual content changes.
-  `(let ((opascal--ignore-changes t))
-     (with-silent-modifications
-       ,@forms)))
-
 (defsubst opascal-is (element in-set)
   ;; If the element is in the set, the element cdr is returned, otherwise nil.
   (memq element in-set))
@@ -347,13 +332,6 @@ routine.")
   ;; Returns the column of the point p.
   (save-excursion (goto-char p) (current-column)))
 
-(defun opascal-face-of (token-kind)
-  ;; Returns the face property appropriate for the token kind.
-  (cond ((opascal-is token-kind opascal-comments) opascal-comment-face)
-        ((opascal-is token-kind opascal-strings) opascal-string-face)
-        ((opascal-is token-kind opascal-keywords) opascal-keyword-face)
-        (opascal-other-face)))
-
 (defvar opascal-progress-last-reported-point nil
   "The last point at which progress was reported.")
 
@@ -361,8 +339,6 @@ routine.")
   "Number of chars to process before the next parsing progress report.")
 (defconst opascal-scanning-progress-step 2048
   "Number of chars to process before the next scanning progress report.")
-(defconst opascal-fontifying-progress-step opascal-scanning-progress-step
-  "Number of chars to process before the next fontification progress report.")
 
 (defun opascal-progress-start ()
   ;; Initializes progress reporting.
@@ -400,22 +376,30 @@ routine.")
     (goto-char curr-point)
     next))
 
-(defvar opascal--ignore-changes t
-  "Internal flag to control if the OPascal mode responds to buffer changes.
-Defaults to t in case the `opascal-after-change' function is called on a
-non-OPascal buffer.  Set to nil in OPascal buffers.  To override, just do:
- (let ((opascal--ignore-changes t)) ...)")
-
-(defun opascal-set-text-properties (from to properties)
-  ;; Like `set-text-properties', except we do not consider this to be a buffer
-  ;; modification.
-  (opascal-save-state
-   (set-text-properties from to properties)))
+(defconst opascal--literal-start-re (regexp-opt '("//" "{" "(*" "'" "\"")))
 
 (defun opascal-literal-kind (p)
   ;; Returns the literal kind the point p is in (or nil if not in a literal).
-  (if (and (<= (point-min) p) (<= p (point-max)))
-      (get-text-property p 'token)))
+  (when (and (<= (point-min) p) (<= p (point-max)))
+    (save-excursion
+      (let ((ppss (syntax-ppss p)))
+        ;; We want to return non-nil when right in front
+        ;; of a comment/string.
+        (if (null (nth 8 ppss))
+            (when (looking-at opascal--literal-start-re)
+              (pcase (char-after)
+                (`?/  'comment-single-line)
+                (`?\{ 'comment-multi-line-1)
+                (`?\( 'comment-multi-line-2)
+                (`?\' 'string)
+                (`?\" 'double-quoted-string)))
+          (if (nth 3 ppss)   ;String.
+              (if (eq (nth 3 ppss) ?\")
+                  'double-quoted-string 'string)
+            (pcase (nth 7 ppss)
+              (`2 'comment-single-line)
+              (`1 'comment-multi-line-2)
+              (_  'comment-multi-line-1))))))))
 
 (defun opascal-literal-start-pattern (literal-kind)
   ;; Returns the start pattern of the literal kind.
@@ -446,96 +430,27 @@ non-OPascal buffer.  Set to nil in OPascal buffers.  To override, just do:
                 (string . "['\n]")
                 (double-quoted-string . "[\"\n]")))))
 
-(defun opascal-is-literal-start (p)
-  ;; True if the point p is at the start point of a (completed) literal.
-  (let* ((kind (opascal-literal-kind p))
-         (pattern (opascal-literal-start-pattern kind)))
-    (or (null kind) ; Non-literals are considered as start points.
-        (opascal-looking-at-string p pattern))))
-
 (defun opascal-is-literal-end (p)
   ;; True if the point p is at the end point of a (completed) literal.
-  (let* ((kind (opascal-literal-kind (1- p)))
-         (pattern (opascal-literal-end-pattern kind)))
-    (or (null kind) ; Non-literals are considered as end points.
-
-        (and (opascal-looking-at-string (- p (length pattern)) pattern)
-             (or (not (opascal-is kind opascal-strings))
-                 ;; Special case: string delimiters are start/end ambiguous.
-                 ;; We have an end only if there is some string content (at
-                 ;; least a starting delimiter).
-                 (not (opascal-is-literal-end (1- p)))))
-
-        ;; Special case: strings cannot span lines.
-        (and (opascal-is kind opascal-strings) (eq ?\n (char-after (1- p)))))))
-
-(defun opascal-is-stable-literal (p)
-  ;; True if the point p marks a stable point. That is, a point outside of a
-  ;; literal region, inside of a literal region, or adjacent to completed
-  ;; literal regions.
-  (let ((at-start (opascal-is-literal-start p))
-        (at-end  (opascal-is-literal-end p)))
-    (or (>= p (point-max))
-        (and at-start at-end)
-        (and (not at-start) (not at-end)
-             (eq (opascal-literal-kind (1- p)) (opascal-literal-kind p))))))
-
-(defun opascal-complete-literal (literal-kind limit)
-  ;; Continues the search for a literal's true end point and returns the
-  ;; point past the end pattern (if found) or the limit (if not found).
-  (let ((pattern (opascal-literal-stop-pattern literal-kind)))
-    (if (not (stringp pattern))
-        (error "Invalid literal kind %S" literal-kind)
-      ;; Search up to the limit.
-      (re-search-forward pattern limit 'goto-limit-on-fail)
-      (point))))
-
-(defun opascal-literal-text-properties (kind)
-  ;; Creates a list of text properties for the literal kind.
-  (if (and (boundp 'font-lock-mode)
-           font-lock-mode)
-      (list 'token kind 'face (opascal-face-of kind) 'lazy-lock t)
-    (list 'token kind)))
-
-(defun opascal-parse-next-literal (limit)
-  ;; Searches for the next literal region (i.e. comment or string) and sets the
-  ;; the point to its end (or the limit, if not found). The literal region is
-  ;; marked as such with a text property, to speed up tokenizing during face
-  ;; coloring and indentation scanning.
-  (let ((search-start (point)))
-    (cond ((not (opascal-is-literal-end search-start))
-           ;; We are completing an incomplete literal.
-           (let ((kind (opascal-literal-kind (1- search-start))))
-             (opascal-complete-literal kind limit)
-             (opascal-set-text-properties
-              search-start (point) (opascal-literal-text-properties kind))))
-
-          ((re-search-forward
-            "\\(//\\)\\|\\({\\)\\|\\((\\*\\)\\|\\('\\)\\|\\(\"\\)"
-            limit 'goto-limit-on-fail)
-           ;; We found the start of a new literal. Find its end and mark it.
-           (let ((kind (cond ((match-beginning 1) 'comment-single-line)
-                             ((match-beginning 2) 'comment-multi-line-1)
-                             ((match-beginning 3) 'comment-multi-line-2)
-                             ((match-beginning 4) 'string)
-                             ((match-beginning 5) 'double-quoted-string)))
-                 (start (match-beginning 0)))
-             (opascal-set-text-properties search-start start nil)
-             (opascal-complete-literal kind limit)
-             (opascal-set-text-properties
-              start (point) (opascal-literal-text-properties kind))))
-
-          ;; Nothing found. Mark it as a non-literal.
-          ((opascal-set-text-properties search-start limit nil)))
-    (opascal-step-progress (point) "Parsing" opascal-parsing-progress-step)))
+  (save-excursion
+    (and (null (nth 8 (syntax-ppss p)))
+         (nth 8 (syntax-ppss (1- p))))))
 
 (defun opascal-literal-token-at (p)
-  ;; Returns the literal token surrounding the point p, or nil if none.
-  (let ((kind (opascal-literal-kind p)))
-    (when kind
-      (let ((start (previous-single-property-change (1+ p) 'token))
-            (end (next-single-property-change p 'token)))
-        (opascal-token-of kind (or start (point-min)) (or end (point-max)))))))
+  "Return the literal token surrounding the point P, or nil if none."
+  (save-excursion
+    (let ((ppss (syntax-ppss p)))
+      (when (or (nth 8 ppss) (looking-at opascal--literal-start-re))
+        (let* ((new-start (or (nth 8 ppss) p))
+               (new-end (progn
+                          (goto-char new-start)
+                          (condition-case nil
+                              (if (memq (char-after) '(?\' ?\"))
+                                  (forward-sexp 1)
+                                (forward-comment 1))
+                            (scan-error (goto-char (point-max))))
+                          (point))))
+          (opascal-token-of (opascal-literal-kind p) new-start new-end))))))
 
 (defun opascal-point-token-at (p kind)
   ;; Returns the single character token at the point p.
@@ -645,55 +560,6 @@ non-OPascal buffer.  Set to nil in OPascal buffers.  To override, just do:
              (opascal-is (opascal-token-kind next-token) '(space newline))))
     next-token))
 
-(defun opascal-parse-region (from to)
-  ;; Parses the literal tokens in the region. The point is set to "to".
-  (save-restriction
-    (widen)
-    (goto-char from)
-    (while (< (point) to)
-      (opascal-parse-next-literal to))))
-
-(defun opascal-parse-region-until-stable (from to)
-  ;; Parses at least the literal tokens in the region. After that, parsing
-  ;; continues as long as obsolete literal regions are encountered. The point
-  ;; is set to the encountered stable point.
-  (save-restriction
-    (widen)
-    (opascal-parse-region from to)
-    (while (not (opascal-is-stable-literal (point)))
-      (opascal-parse-next-literal (point-max)))))
-
-(defun opascal-fontify-region (from to &optional verbose)
-  ;; Colors the text in the region according to OPascal rules.
-  (opascal-save-excursion
-   (opascal-save-state
-    (let ((p from)
-          (opascal-verbose verbose)
-          (token nil))
-      (opascal-progress-start)
-      (while (< p to)
-        ;; Color the token and move past it.
-        (setq token (opascal-token-at p))
-        (add-text-properties
-         (opascal-token-start token) (opascal-token-end token)
-         (list 'face (opascal-face-of (opascal-token-kind token)) 'lazy-lock t))
-        (setq p (opascal-token-end token))
-        (opascal-step-progress p "Fontifying" opascal-fontifying-progress-step))
-      (opascal-progress-done)))))
-
-(defun opascal-after-change (change-start change-end _old-length)
-  ;; Called when the buffer has changed. Reparses the changed region.
-  (unless opascal--ignore-changes
-    (let ((opascal--ignore-changes t)) ; Prevent recursive calls.
-      (opascal-save-excursion
-       (opascal-progress-start)
-       ;; Reparse at least from the token previous to the change to the end of
-       ;; line after the change.
-       (opascal-parse-region-until-stable
-        (opascal-token-start (opascal-token-at (1- change-start)))
-        (progn (goto-char change-end) (end-of-line) (point)))
-       (opascal-progress-done)))))
-
 (defun opascal-group-start (from-token)
   ;; Returns the token that denotes the start of the ()/[] group.
   (let ((token (opascal-previous-token from-token))
@@ -1561,41 +1427,6 @@ If before the indent, the point is moved to the indent."
   (interactive "r")
   (opascal-debug-log "String: %S" (buffer-substring from to)))
 
-(defun opascal-debug-show-is-stable ()
-  (interactive)
-  (opascal-debug-log "stable: %S prev: %S next: %S"
-                    (opascal-is-stable-literal (point))
-                    (opascal-literal-kind (1- (point)))
-                    (opascal-literal-kind (point))))
-
-(defun opascal-debug-unparse-buffer ()
-  (interactive)
-  (opascal-set-text-properties (point-min) (point-max) nil))
-
-(defun opascal-debug-parse-region (from to)
-  (interactive "r")
-  (let ((opascal-verbose t))
-    (opascal-save-excursion
-     (opascal-progress-start)
-     (opascal-parse-region from to)
-     (opascal-progress-done "Parsing done"))))
-
-(defun opascal-debug-parse-window ()
-  (interactive)
-  (opascal-debug-parse-region (window-start) (window-end)))
-
-(defun opascal-debug-parse-buffer ()
-  (interactive)
-  (opascal-debug-parse-region (point-min) (point-max)))
-
-(defun opascal-debug-fontify-window ()
-  (interactive)
-  (opascal-fontify-region (window-start) (window-end) t))
-
-(defun opascal-debug-fontify-buffer ()
-  (interactive)
-  (opascal-fontify-region (point-min) (point-max) t))
-
 (defun opascal-debug-tokenize-region (from to)
   (interactive)
   (opascal-save-excursion
@@ -1747,6 +1578,7 @@ An error is raised if not in a comment."
           (error "Not in a comment")
         (let* ((start-comment (opascal-comment-block-start comment))
                (end-comment (opascal-comment-block-end comment))
+               ;; FIXME: Don't abuse global variables like `comment-end/start'.
                (comment-start (opascal-token-start start-comment))
                (comment-end (opascal-token-end end-comment))
                (content-start (opascal-comment-content-start start-comment))
@@ -1814,12 +1646,7 @@ An error is raised if not in a comment."
 
           ;; Restore our position
           (goto-char marked-point)
-          (set-marker marked-point nil)
-
-          ;; React to the entire fill change as a whole.
-          (opascal-progress-start)
-          (opascal-parse-region comment-start comment-end)
-            (opascal-progress-done)))))))
+          (set-marker marked-point nil)))))))
 
 (defun opascal-new-comment-line ()
   "If in a // comment, do a newline, indented such that one is still in the
@@ -1848,16 +1675,37 @@ comment block.  If not in a // comment, just does a normal newline."
         (goto-char end)
         token)))
 
+(defconst opascal-font-lock-keywords
+  `(("\\_<\\(function\\|pro\\(cedure\\|gram\\)\\)[ \t]+\\([[:alpha:]][[:alnum:]_]*\\)"
+     (1 font-lock-keyword-face) (3 font-lock-function-name-face))
+    ,(concat "\\_<" (regexp-opt (mapcar #'symbol-name opascal-keywords))
+              "\\_>")))
+
 (defconst opascal-font-lock-defaults
-  '(nil ; We have our own fontify routine, so keywords don't apply.
-    t ; Syntactic fontification doesn't apply.
+  '(opascal-font-lock-keywords
+    nil ; Syntactic fontification does apply.
     nil ; Don't care about case since we don't use regexps to find tokens.
     nil ; Syntax alists don't apply.
-    nil ; Syntax begin movement doesn't apply
-    (font-lock-fontify-region-function . opascal-fontify-region)
-    (font-lock-verbose . opascal-fontifying-progress-step))
+    nil ; Syntax begin movement doesn't apply.
+    )
   "OPascal mode font-lock defaults.  Syntactic fontification is ignored.")
 
+(defconst opascal--syntax-propertize
+  (syntax-propertize-rules
+   ;; The syntax-table settings are too coarse and end up treating /* and (/
+   ;; as comment starters.  Fix it here by removing the "2" from the syntax
+   ;; of the second char of such sequences.
+   ("/\\(\\*\\)" (1 ". 3b"))
+   ("(\\(\\/\\)" (1 (prog1 ". 1c" (forward-char -1) nil)))
+   ;; Pascal uses '' and "" rather than \' and \" to escape quotes.
+   ("''\\|\"\"" (0 (if (save-excursion
+                         (nth 3 (syntax-ppss (match-beginning 0))))
+                       (string-to-syntax ".")
+                     ;; In case of 3 or more quotes in a row, only advance
+                     ;; one quote at a time.
+                     (forward-char -1)
+                     nil)))))
+
 (defvar opascal-debug-mode-map
   (let ((kmap (make-sparse-keymap)))
     (dolist (binding '(("n" opascal-debug-goto-next-token)
@@ -1866,14 +1714,7 @@ comment block.  If not in a // comment, just does a normal newline."
                        ("T" opascal-debug-tokenize-buffer)
                        ("W" opascal-debug-tokenize-window)
                        ("g" opascal-debug-goto-point)
-                       ("s" opascal-debug-show-current-string)
-                       ("a" opascal-debug-parse-buffer)
-                       ("w" opascal-debug-parse-window)
-                       ("f" opascal-debug-fontify-window)
-                       ("F" opascal-debug-fontify-buffer)
-                       ("r" opascal-debug-parse-region)
-                       ("c" opascal-debug-unparse-buffer)
-                       ("x" opascal-debug-show-is-stable)))
+                       ("s" opascal-debug-show-current-string)))
       (define-key kmap (car binding) (cadr binding)))
     kmap)
   "Keystrokes for OPascal mode debug commands.")
@@ -1923,14 +1764,8 @@ Customization:
 
 Coloring:
 
- `opascal-comment-face'                (default font-lock-comment-face)
-    Face used to color OPascal comments.
- `opascal-string-face'                 (default font-lock-string-face)
-    Face used to color OPascal strings.
  `opascal-keyword-face'                (default font-lock-keyword-face)
     Face used to color OPascal keywords.
- `opascal-other-face'                  (default nil)
-    Face used to color everything else.
 
 Turning on OPascal mode calls the value of the variable `opascal-mode-hook'
 with no args, if that value is non-nil."
@@ -1940,21 +1775,13 @@ with no args, if that value is non-nil."
   (setq-local comment-indent-function #'opascal-indent-line)
   (setq-local case-fold-search t)
   (setq-local opascal-progress-last-reported-point nil)
-  (setq-local opascal--ignore-changes nil)
   (setq-local font-lock-defaults opascal-font-lock-defaults)
   (setq-local tab-always-indent opascal-tab-always-indents)
+  (setq-local syntax-propertize-function opascal--syntax-propertize)
 
-  ;; FIXME: Use syntax-propertize-function to tokenize, maybe?
-  
-  ;; We need to keep track of changes to the buffer to determine if we need
-  ;; to retokenize changed text.
-  (add-hook 'after-change-functions #'opascal-after-change nil t)
-
-  (opascal-save-excursion
-   (let ((opascal-verbose t))
-     (opascal-progress-start)
-     (opascal-parse-region (point-min) (point-max))
-     (opascal-progress-done))))
+  (setq-local comment-start "// ")
+  (setq-local comment-start-skip "\\(?://\\|(\\*\\|{\\)[ \t]*")
+  (setq-local comment-end-skip "[ \t]*\\(?:\n\\|\\*)\\|}\\)"))
 
 (provide 'opascal)
 ;;; opascal.el ends here
diff --git a/lisp/progmodes/pascal.el b/lisp/progmodes/pascal.el
index 829ecda5150..ffc8200644a 100644
--- a/lisp/progmodes/pascal.el
+++ b/lisp/progmodes/pascal.el
@@ -158,31 +158,44 @@
 
 
 
-(defconst pascal-font-lock-keywords (purecopy
-  (list
-   '("^[ \t]*\\(function\\|pro\\(cedure\\|gram\\)\\)\\>[ \t]*\\([a-z]\\)"
+(defconst pascal-font-lock-keywords
+  `(("\\_<\\(function\\|pro\\(cedure\\|gram\\)\\)[ \t]+\\([[:alpha:]][[:alnum:]_]*\\)"
+     (1 font-lock-keyword-face)
+     (3 font-lock-function-name-face))
+    ;; ("type" "const" "real" "integer" "char" "boolean" "var"
+    ;;  "record" "array" "file")
+    (,(concat "\\<\\(array\\|boolean\\|c\\(har\\|onst\\)\\|file\\|"
+              "integer\\|re\\(al\\|cord\\)\\|type\\|var\\)\\>")
+     font-lock-type-face)
+    ("\\<\\(label\\|external\\|forward\\)\\>" . font-lock-constant-face)
+    ("\\<\\([0-9]+\\)[ \t]*:" 1 font-lock-function-name-face)
+    ;; ("of" "to" "for" "if" "then" "else" "case" "while"
+    ;;  "do" "until" "and" "or" "not" "in" "with" "repeat" "begin" "end")
+    ,(concat "\\<\\("
+             "and\\|begin\\|case\\|do\\|e\\(lse\\|nd\\)\\|for\\|i[fn]\\|"
+             "not\\|o[fr]\\|repeat\\|t\\(hen\\|o\\)\\|until\\|w\\(hile\\|ith\\)"
+             "\\)\\>")
+    ("\\<\\(goto\\)\\>[ \t]*\\([0-9]+\\)?"
      1 font-lock-keyword-face)
-   '("^[ \t]*\\(function\\|pro\\(cedure\\|gram\\)\\)\\>[ \t]*\\([a-z][a-z0-9_]*\\)"
-     3 font-lock-function-name-face t)
-;   ("type" "const" "real" "integer" "char" "boolean" "var"
-;    "record" "array" "file")
-   (cons (concat "\\<\\(array\\|boolean\\|c\\(har\\|onst\\)\\|file\\|"
-                 "integer\\|re\\(al\\|cord\\)\\|type\\|var\\)\\>")
-         'font-lock-type-face)
-   '("\\<\\(label\\|external\\|forward\\)\\>" . font-lock-constant-face)
-   '("\\<\\([0-9]+\\)[ \t]*:" 1 font-lock-function-name-face)
-;   ("of" "to" "for" "if" "then" "else" "case" "while"
-;    "do" "until" "and" "or" "not" "in" "with" "repeat" "begin" "end")
-   (concat "\\<\\("
-           "and\\|begin\\|case\\|do\\|e\\(lse\\|nd\\)\\|for\\|i[fn]\\|"
-           "not\\|o[fr]\\|repeat\\|t\\(hen\\|o\\)\\|until\\|w\\(hile\\|ith\\)"
-           "\\)\\>")
-   '("\\<\\(goto\\)\\>[ \t]*\\([0-9]+\\)?"
-     1 font-lock-keyword-face)
-   '("\\<\\(goto\\)\\>[ \t]*\\([0-9]+\\)?"
-     2 font-lock-keyword-face t)))
+    ("\\<\\(goto\\)\\>[ \t]*\\([0-9]+\\)?"
+     2 font-lock-keyword-face t))
   "Additional expressions to highlight in Pascal mode.")
-(put 'pascal-mode 'font-lock-defaults '(pascal-font-lock-keywords nil t))
+
+(defconst pascal--syntax-propertize
+  (syntax-propertize-rules
+   ;; The syntax-table settings are too coarse and end up treating /* and (/
+   ;; as comment starters.  Fix it here by removing the "2" from the syntax
+   ;; of the second char of such sequences.
+   ("/\\(\\*\\)" (1 ". 3b"))
+   ("(\\(\\/\\)" (1 (prog1 ". 1c" (forward-char -1) nil)))
+   ;; Pascal uses '' and "" rather than \' and \" to escape quotes.
+   ("''\\|\"\"" (0 (if (save-excursion
+                         (nth 3 (syntax-ppss (match-beginning 0))))
+                       (string-to-syntax ".")
+                     ;; In case of 3 or more quotes in a row, only advance
+                     ;; one quote at a time.
+                     (forward-char -1)
+                     nil)))))
 
 (defcustom pascal-indent-level 3
   "Indentation of Pascal statements with respect to containing block."
@@ -346,23 +359,22 @@ See also the user variables `pascal-type-keywords', `pascal-start-keywords' and
 
 Turning on Pascal mode calls the value of the variable pascal-mode-hook with
 no args, if that value is non-nil."
-  (set (make-local-variable 'local-abbrev-table) pascal-mode-abbrev-table)
-  (set (make-local-variable 'indent-line-function) 'pascal-indent-line)
-  (set (make-local-variable 'comment-indent-function) 'pascal-indent-comment)
-  (set (make-local-variable 'parse-sexp-ignore-comments) nil)
-  (set (make-local-variable 'blink-matching-paren-dont-ignore-comments) t)
-  (set (make-local-variable 'case-fold-search) t)
-  (set (make-local-variable 'comment-start) "{")
-  (set (make-local-variable 'comment-start-skip) "(\\*+ *\\|{ *")
-  (set (make-local-variable 'comment-end) "}")
+  (setq-local local-abbrev-table pascal-mode-abbrev-table)
+  (setq-local indent-line-function 'pascal-indent-line)
+  (setq-local comment-indent-function 'pascal-indent-comment)
+  (setq-local parse-sexp-ignore-comments nil)
+  (setq-local blink-matching-paren-dont-ignore-comments t)
+  (setq-local case-fold-search t)
+  (setq-local comment-start "{")
+  (setq-local comment-start-skip "(\\*+ *\\|{ *")
+  (setq-local comment-end "}")
   (add-hook 'completion-at-point-functions 'pascal-completions-at-point nil t)
   ;; Font lock support
-  (set (make-local-variable 'font-lock-defaults)
-       '(pascal-font-lock-keywords nil t))
+  (setq-local font-lock-defaults '(pascal-font-lock-keywords nil t))
+  (setq-local syntax-propertize-function pascal--syntax-propertize)
   ;; Imenu support
-  (set (make-local-variable 'imenu-generic-expression)
-       pascal-imenu-generic-expression)
-  (set (make-local-variable 'imenu-case-fold-search) t)
+  (setq-local imenu-generic-expression pascal-imenu-generic-expression)
+  (setq-local imenu-case-fold-search t)
   ;; Pascal-mode's own hide/show support.
   (add-to-invisibility-spec '(pascal . t)))
 
diff --git a/lisp/progmodes/perl-mode.el b/lisp/progmodes/perl-mode.el
index bd58a7300ec..01ac8584e19 100644
--- a/lisp/progmodes/perl-mode.el
+++ b/lisp/progmodes/perl-mode.el
@@ -148,10 +148,10 @@
 
 (defvar perl-imenu-generic-expression
   '(;; Functions
-    (nil "^[ \t]*sub\\s-+\\([-A-Za-z0-9+_:]+\\)" 1)
+    (nil "^[ \t]*sub\\s-+\\([-[:alnum:]+_:]+\\)" 1)
     ;;Variables
-    ("Variables" "^\\(?:my\\|our\\)\\s-+\\([$@%][-A-Za-z0-9+_:]+\\)\\s-*=" 1)
-    ("Packages" "^[ \t]*package\\s-+\\([-A-Za-z0-9+_:]+\\);" 1)
+    ("Variables" "^\\(?:my\\|our\\)\\s-+\\([$@%][-[:alnum:]+_:]+\\)\\s-*=" 1)
+    ("Packages" "^[ \t]*package\\s-+\\([-[:alnum:]+_:]+\\);" 1)
     ("Doc sections" "^=head[0-9][ \t]+\\(.*\\)" 1))
   "Imenu generic expression for Perl mode.  See `imenu-generic-expression'.")
 
@@ -160,6 +160,7 @@
 
 (defcustom perl-prettify-symbols t
   "If non-nil, some symbols will be displayed using Unicode chars."
+  :version "24.4"
   :type 'boolean)
 
 (defconst perl--prettify-symbols-alist
@@ -275,7 +276,6 @@ Regexp match data 0 points to the chars."
   (let ((case-fold-search nil))
     (goto-char start)
     (perl-syntax-propertize-special-constructs end)
-    ;; TODO: here-documents ("<<\\(\\sw\\|['\"]\\)")
     (funcall
      (syntax-propertize-rules
       ;; Turn POD into b-style comments.  Place the cut rule first since it's
@@ -287,7 +287,7 @@ Regexp match data 0 points to the chars."
       ;; check that it occurs inside a '..' string.
       ("\\(\\$\\)[{']" (1 ". p"))
       ;; Handle funny names like $DB'stop.
-      ("\\$ ?{?^?[_a-zA-Z][_a-zA-Z0-9]*\\('\\)[_a-zA-Z]" (1 "_"))
+      ("\\$ ?{?^?[_[:alpha:]][_[:alnum:]]*\\('\\)[_[:alpha:]]" (1 "_"))
       ;; format statements
       ("^[ \t]*format.*=[ \t]*\\(\n\\)"
        (1 (prog1 "\"" (perl-syntax-propertize-special-constructs end))))
@@ -345,7 +345,29 @@ Regexp match data 0 points to the chars."
                                            perl-quote-like-pairs)
                                     (string-to-syntax "|")
                                   (string-to-syntax "\"")))
-             (perl-syntax-propertize-special-constructs end))))))
+             (perl-syntax-propertize-special-constructs end)))))
+      ;; Here documents.
+      ;; TODO: Handle <<WORD.  These are trickier because you need to
+      ;; disambiguate with the shift operator.
+      ("<<[ \t]*\\('[^'\n]*'\\|\"[^\"\n]*\"\\|\\\\[[:alpha:]][[:alnum:]]*\\).*\\(\n\\)"
+       (2 (let* ((st (get-text-property (match-beginning 2) 'syntax-table))
+                 (name (match-string 1)))
+            (goto-char (match-end 1))
+            (if (save-excursion (nth 8 (syntax-ppss (match-beginning 0))))
+                ;; Leave the property of the newline unchanged.
+                st
+              (cons (car (string-to-syntax "< c"))
+                    ;; Remember the names of heredocs found on this line.
+                    (cons (pcase (aref name 0)
+                            (`?\\ (substring name 1))
+                            (_ (substring name 1 -1)))
+                          (cdr st)))))))
+      ;; We don't call perl-syntax-propertize-special-constructs directly
+      ;; from the << rule, because there might be other elements (between
+      ;; the << and the \n) that need to be propertized.
+      ("\\(?:$\\)\\s<"
+       (0 (ignore (perl-syntax-propertize-special-constructs end))))
+      )
      (point) end)))
 
 (defvar perl-empty-syntax-table
@@ -370,6 +392,22 @@ Regexp match data 0 points to the chars."
   (let ((state (syntax-ppss))
         char)
     (cond
+     ((eq 2 (nth 7 state))
+      ;; A Here document.
+      (let ((names (cdr (get-text-property (nth 8 state) 'syntax-table))))
+        (when (cdr names)
+          (setq names (reverse names))
+          ;; Multiple heredocs on a single line, we have to search from the
+          ;; beginning, since we don't know which names might be
+          ;; before point.
+          (goto-char (nth 8 state)))
+        (while (and names
+                    (re-search-forward
+                     (concat "^" (regexp-quote (pop names)) "\n")
+                     limit 'move))
+          (unless names
+            (put-text-property (1- (point)) (point) 'syntax-table
+                               (string-to-syntax "> c"))))))
      ((or (null (setq char (nth 3 state)))
           (and (characterp char) (eq (char-syntax (nth 3 state)) ?\")))
       ;; Normal text, or comment, or docstring, or normal string.
diff --git a/lisp/progmodes/prolog.el b/lisp/progmodes/prolog.el
index 85e4172c8fe..63bd9258d69 100644
--- a/lisp/progmodes/prolog.el
+++ b/lisp/progmodes/prolog.el
@@ -278,16 +278,16 @@
 
 ;;; Code:
 
+(require 'comint)
+
 (eval-when-compile
   (require 'font-lock)
   ;; We need imenu everywhere because of the predicate index!
   (require 'imenu)
   ;)
-  (require 'info)
   (require 'shell)
   )
 
-(require 'comint)
 (require 'easymenu)
 (require 'align)
 
@@ -772,6 +772,8 @@ Relevant only when `prolog-imenu-flag' is non-nil."
   :version "24.1"
   :group 'prolog-other
   :type 'boolean)
+(make-obsolete-variable 'prolog-underscore-wordchar-flag
+                        'superword-mode "24.4")
 
 (defcustom prolog-use-sicstus-sd nil
   "If non-nil, use the source level debugger of SICStus 3#7 and later."
@@ -785,6 +787,7 @@ This is really kludgy, and unneeded (i.e. obsolete) in Emacs>=24."
   :version "24.1"
   :group 'prolog-other
   :type 'boolean)
+(make-obsolete-variable 'prolog-char-quote-workaround nil "24.1")
 
 
 ;;-------------------------------------------------------------------
@@ -802,10 +805,7 @@ This is really kludgy, and unneeded (i.e. obsolete) in Emacs>=24."
   ;; - In atoms \x<hex> sometimes needs a terminating \ (ISO-style)
   ;;   and sometimes not.
   (let ((table (make-syntax-table)))
-    (if prolog-underscore-wordchar-flag
-        (modify-syntax-entry ?_ "w" table)
-      (modify-syntax-entry ?_ "_" table))
-
+    (modify-syntax-entry ?_ (if prolog-underscore-wordchar-flag "w" "_") table)
     (modify-syntax-entry ?+ "." table)
     (modify-syntax-entry ?- "." table)
     (modify-syntax-entry ?= "." table)
@@ -815,7 +815,8 @@ This is really kludgy, and unneeded (i.e. obsolete) in Emacs>=24."
     (modify-syntax-entry ?\' "\"" table)
 
     ;; Any better way to handle the 0'<char> construct?!?
-    (when prolog-char-quote-workaround
+    (when (and prolog-char-quote-workaround
+               (not (fboundp 'syntax-propertize-rules)))
       (modify-syntax-entry ?0 "\\" table))
 
     (modify-syntax-entry ?% "<" table)
@@ -1770,7 +1771,8 @@ This function must be called from the source code buffer."
                                              real-file))
     (with-current-buffer buffer
       (goto-char (point-max))
-      (set-process-filter process 'prolog-consult-compile-filter)
+      (add-function :override (process-filter process)
+                    #'prolog-consult-compile-filter)
       (process-send-string "prolog" command-string)
       ;; (prolog-build-prolog-command compilep file real-file first-line))
       (while (and prolog-process-flag
@@ -1781,7 +1783,8 @@ This function must be called from the source code buffer."
       (insert (if compilep
                   "\nCompilation finished.\n"
                 "\nConsulted.\n"))
-      (set-process-filter process old-filter))))
+      (remove-function (process-filter process)
+                       #'prolog-consult-compile-filter))))
 
 (defvar compilation-error-list)
 
@@ -3027,11 +3030,14 @@ The rest of the elements are undefined."
         (error "Sorry, no help method defined for this Prolog system."))))
    ))
 
+
+(autoload 'Info-goto-node "info" nil t)
+(declare-function Info-follow-nearest-node "info" (&optional FORK))
+
 (defun prolog-help-info (predicate)
   (let ((buffer (current-buffer))
         oldp
         (str (concat "^\\* " (regexp-quote predicate) " */")))
-    (require 'info)
     (pop-to-buffer nil)
     (Info-goto-node prolog-info-predicate-index)
     (if (not (re-search-forward str nil t))
@@ -3120,7 +3126,6 @@ Only for internal use by `prolog-find-documentation'")
 (defun prolog-goto-predicate-info (predicate)
   "Go to the info page for PREDICATE, which is a PredSpec."
   (interactive)
-  (require 'info)
   (string-match "\\(.*\\)/\\([0-9]+\\).*$" predicate)
   (let ((buffer (current-buffer))
         (name (match-string 1 predicate))
diff --git a/lisp/progmodes/python.el b/lisp/progmodes/python.el
index f0f67d01845..ccb2dcba42e 100644
--- a/lisp/progmodes/python.el
+++ b/lisp/progmodes/python.el
@@ -157,7 +157,7 @@
 
 ;; Skeletons: 6 skeletons are provided for simple inserting of class,
 ;; def, for, if, try and while.  These skeletons are integrated with
-;; dabbrev.  If you have `dabbrev-mode' activated and
+;; abbrev.  If you have `abbrev-mode' activated and
 ;; `python-skeleton-autoinsert' is set to t, then whenever you type
 ;; the name of any of those defined and hit SPC, they will be
 ;; automatically expanded.  As an alternative you can use the defined
@@ -177,12 +177,14 @@
 ;; might guessed you should run `python-shell-send-buffer' from time
 ;; to time to get better results too.
 
-;; Imenu: This mode supports Imenu in its most basic form, letting it
-;; build the necessary alist via `imenu-default-create-index-function'
-;; by having set `imenu-extract-index-name-function' to
-;; `python-info-current-defun' and
-;; `imenu-prev-index-position-function' to
-;; `python-imenu-prev-index-position'.
+;; Imenu: There are two index building functions to be used as
+;; `imenu-create-index-function': `python-imenu-create-index' (the
+;; default one, builds the alist in form of a tree) and
+;; `python-imenu-create-flat-index'. See also
+;; `python-imenu-format-item-label-function',
+;; `python-imenu-format-parent-item-label-function',
+;; `python-imenu-format-parent-item-jump-label-function' variables for
+;; changing the way labels are formatted in the tree version.
 
 ;; If you used python-mode.el you probably will miss auto-indentation
 ;; when inserting newlines.  To achieve the same behavior you have
@@ -368,22 +370,24 @@ This variant of `rx' supports common python named REGEXPS."
 
 ;;; Font-lock and syntax
 
+(eval-when-compile
+  (defun python-syntax--context-compiler-macro (form type &optional syntax-ppss)
+    (pcase type
+      (`'comment
+       `(let ((ppss (or ,syntax-ppss (syntax-ppss))))
+          (and (nth 4 ppss) (nth 8 ppss))))
+      (`'string
+       `(let ((ppss (or ,syntax-ppss (syntax-ppss))))
+          (and (nth 3 ppss) (nth 8 ppss))))
+      (`'paren
+       `(nth 1 (or ,syntax-ppss (syntax-ppss))))
+      (_ form))))
+
 (defun python-syntax-context (type &optional syntax-ppss)
   "Return non-nil if point is on TYPE using SYNTAX-PPSS.
 TYPE can be `comment', `string' or `paren'.  It returns the start
 character address of the specified TYPE."
-  (declare (compiler-macro
-            (lambda (form)
-              (pcase type
-                (`'comment
-                 `(let ((ppss (or ,syntax-ppss (syntax-ppss))))
-                    (and (nth 4 ppss) (nth 8 ppss))))
-                (`'string
-                 `(let ((ppss (or ,syntax-ppss (syntax-ppss))))
-                    (and (nth 3 ppss) (nth 8 ppss))))
-                (`'paren
-                 `(nth 1 (or ,syntax-ppss (syntax-ppss))))
-                (_ form)))))
+  (declare (compiler-macro python-syntax--context-compiler-macro))
   (let ((ppss (or syntax-ppss (syntax-ppss))))
     (pcase type
       (`comment (and (nth 4 ppss) (nth 8 ppss)))
@@ -638,6 +642,13 @@ It makes underscores and dots word constituent chars.")
 These make `python-indent-calculate-indentation' subtract the value of
 `python-indent-offset'.")
 
+(defvar python-indent-block-enders
+  '("break" "continue" "pass" "raise" "return")
+  "List of words that mark the end of a block.
+These make `python-indent-calculate-indentation' subtract the
+value of `python-indent-offset' when `python-indent-context' is
+AFTER-LINE.")
+
 (defun python-indent-guess-indent-offset ()
   "Guess and set `python-indent-offset' for the current buffer."
   (interactive)
@@ -763,9 +774,13 @@ START is the buffer position where the sexp starts."
             (save-excursion
               (goto-char context-start)
               (current-indentation))
-            (if (progn
-                  (back-to-indentation)
-                  (looking-at (regexp-opt python-indent-dedenters)))
+            (if (or (save-excursion
+                      (back-to-indentation)
+                      (looking-at (regexp-opt python-indent-dedenters)))
+                    (save-excursion
+                      (python-util-forward-comment -1)
+                      (python-nav-beginning-of-statement)
+                      (member (current-word) python-indent-block-enders)))
                 python-indent-offset
               0)))
           ;; When inside of a string, do nothing. just use the current
@@ -1180,6 +1195,70 @@ Returns nil if point is not in a def or class."
       ;; Ensure point moves forward.
       (and (> beg-pos (point)) (goto-char beg-pos)))))
 
+(defun python-nav--syntactically (fn poscompfn &optional contextfn)
+  "Move point using FN avoiding places with specific context.
+FN must take no arguments.  POSCOMPFN is a two arguments function
+used to compare current and previous point after it is moved
+using FN, this is normally a less-than or greater-than
+comparison.  Optional argument CONTEXTFN defaults to
+`python-syntax-context-type' and is used for checking current
+point context, it must return a non-nil value if this point must
+be skipped."
+  (let ((contextfn (or contextfn 'python-syntax-context-type))
+        (start-pos (point-marker))
+        (prev-pos))
+    (catch 'found
+      (while t
+        (let* ((newpos
+                (and (funcall fn) (point-marker)))
+               (context (funcall contextfn)))
+          (cond ((and (not context) newpos
+                      (or (and (not prev-pos) newpos)
+                          (and prev-pos newpos
+                               (funcall poscompfn newpos prev-pos))))
+                 (throw 'found (point-marker)))
+                ((and newpos context)
+                 (setq prev-pos (point)))
+                (t (when (not newpos) (goto-char start-pos))
+                   (throw 'found nil))))))))
+
+(defun python-nav--forward-defun (arg)
+  "Internal implementation of python-nav-{backward,forward}-defun.
+Uses ARG to define which function to call, and how many times
+repeat it."
+  (let ((found))
+    (while (and (> arg 0)
+                (setq found
+                      (python-nav--syntactically
+                       (lambda ()
+                         (re-search-forward
+                          python-nav-beginning-of-defun-regexp nil t))
+                       '>)))
+      (setq arg (1- arg)))
+    (while (and (< arg 0)
+                (setq found
+                      (python-nav--syntactically
+                       (lambda ()
+                         (re-search-backward
+                          python-nav-beginning-of-defun-regexp nil t))
+                       '<)))
+      (setq arg (1+ arg)))
+    found))
+
+(defun python-nav-backward-defun (&optional arg)
+  "Navigate to closer defun backward ARG times.
+Unlikely `python-nav-beginning-of-defun' this doesn't care about
+nested definitions."
+  (interactive "^p")
+  (python-nav--forward-defun (- (or arg 1))))
+
+(defun python-nav-forward-defun (&optional arg)
+  "Navigate to closer defun forward ARG times.
+Unlikely `python-nav-beginning-of-defun' this doesn't care about
+nested definitions."
+  (interactive "^p")
+  (python-nav--forward-defun (or arg 1)))
+
 (defun python-nav-beginning-of-statement ()
   "Move to start of current statement."
   (interactive "^")
@@ -1603,7 +1682,7 @@ This variable, when set to a string, makes the values stored in
 `python-shell-process-environment' and `python-shell-exec-path'
 to be modified properly so shells are started with the specified
 virtualenv."
-  :type 'string
+  :type '(choice (const nil) string)
   :group 'python
   :safe 'stringp)
 
@@ -2644,8 +2723,8 @@ the if condition."
 (defvar python-skeleton-available '()
   "Internal list of available skeletons.")
 
-(define-abbrev-table 'python-mode-abbrev-table ()
-  "Abbrev table for Python mode."
+(define-abbrev-table 'python-mode-skeleton-abbrev-table ()
+  "Abbrev table for Python mode skeletons."
   :case-fixed t
   ;; Allow / inside abbrevs.
   :regexp "\\(?:^\\|[^/]\\)\\<\\([[:word:]/]+\\)\\W*"
@@ -2658,13 +2737,13 @@ the if condition."
 (defmacro python-skeleton-define (name doc &rest skel)
   "Define a `python-mode' skeleton using NAME DOC and SKEL.
 The skeleton will be bound to python-skeleton-NAME and will
-be added to `python-mode-abbrev-table'."
+be added to `python-mode-skeleton-abbrev-table'."
   (declare (indent 2))
   (let* ((name (symbol-name name))
          (function-name (intern (concat "python-skeleton-" name))))
     `(progn
-       (define-abbrev python-mode-abbrev-table ,name "" ',function-name
-         :system t)
+       (define-abbrev python-mode-skeleton-abbrev-table
+         ,name "" ',function-name :system t)
        (setq python-skeleton-available
              (cons ',function-name python-skeleton-available))
        (define-skeleton ,function-name
@@ -2672,6 +2751,10 @@ be added to `python-mode-abbrev-table'."
               (format "Insert %s statement." name))
          ,@skel))))
 
+(define-abbrev-table 'python-mode-abbrev-table ()
+  "Abbrev table for Python mode."
+  :parents (list python-mode-skeleton-abbrev-table))
+
 (defmacro python-define-auxiliary-skeleton (name doc &optional &rest skel)
   "Define a `python-mode' auxiliary skeleton using NAME DOC and SKEL.
 The skeleton will be bound to python-skeleton-NAME."
@@ -2928,15 +3011,193 @@ Interactively, prompt for symbol."
 
 ;;; Imenu
 
-(defun python-imenu-prev-index-position ()
-  "Python mode's `imenu-prev-index-position-function'."
-  (let ((found))
-    (while (and (setq found
-                      (re-search-backward python-nav-beginning-of-defun-regexp nil t))
-                (not (python-info-looking-at-beginning-of-defun))))
-    (and found
-         (python-info-looking-at-beginning-of-defun)
-         (python-info-current-defun))))
+(defvar python-imenu-format-item-label-function
+  'python-imenu-format-item-label
+  "Imenu function used to format an item label.
+It must be a function with two arguments: TYPE and NAME.")
+
+(defvar python-imenu-format-parent-item-label-function
+  'python-imenu-format-parent-item-label
+  "Imenu function used to format a parent item label.
+It must be a function with two arguments: TYPE and NAME.")
+
+(defvar python-imenu-format-parent-item-jump-label-function
+  'python-imenu-format-parent-item-jump-label
+  "Imenu function used to format a parent jump item label.
+It must be a function with two arguments: TYPE and NAME.")
+
+(defun python-imenu-format-item-label (type name)
+  "Return imenu label for single node using TYPE and NAME."
+  (format "%s (%s)" name type))
+
+(defun python-imenu-format-parent-item-label (type name)
+  "Return imenu label for parent node using TYPE and NAME."
+  (format "%s..." (python-imenu-format-item-label type name)))
+
+(defun python-imenu-format-parent-item-jump-label (type name)
+  "Return imenu label for parent node jump using TYPE and NAME."
+  (if (string= type "class")
+      "*class definition*"
+    "*function definition*"))
+
+(defun python-imenu--put-parent (type name pos num-children tree &optional root)
+  "Add the parent with TYPE, NAME, POS and NUM-CHILDREN to TREE.
+Optional Argument ROOT must be non-nil when the node being
+processed is the root of the TREE."
+  (let ((label
+         (funcall python-imenu-format-item-label-function type name))
+        (jump-label
+         (funcall python-imenu-format-parent-item-jump-label-function type name)))
+    (if root
+        ;; This is the root, everything is a children.
+        (cons label (cons (cons jump-label pos) tree))
+      ;; This is node a which may contain some children.
+      (cons
+       (cons label (cons (cons jump-label pos)
+                         ;; Append all the children
+                         (python-util-popn tree num-children)))
+       ;; All previous non-children nodes.
+       (nthcdr num-children tree)))))
+
+(defun python-imenu--build-tree (&optional min-indent prev-indent num-children tree)
+  "Recursively build the tree of nested definitions of a node.
+Arguments MIN-INDENT PREV-INDENT NUM-CHILDREN and TREE are
+internal and should not be passed explicitly unless you know what
+you are doing."
+  (setq num-children (or num-children 0)
+        min-indent (or min-indent 0))
+  (let* ((pos (python-nav-backward-defun))
+         (type)
+         (name (when (and pos (looking-at python-nav-beginning-of-defun-regexp))
+                 (let ((split (split-string (match-string-no-properties 0))))
+                   (setq type (car split))
+                   (cadr split))))
+         (label (when name
+                  (funcall python-imenu-format-item-label-function type name)))
+         (indent (current-indentation)))
+    (cond ((not pos)
+           ;; No defun found, nothing to add.
+           tree)
+          ((equal indent 0)
+           (if (> num-children 0)
+               ;; Append it as the parent of everything collected to
+               ;; this point.
+               (python-imenu--put-parent type name pos num-children tree t)
+             ;; There are no children, this is a lonely defun.
+             (cons label pos)))
+          ((equal min-indent indent)
+           ;; Stop collecting nodes after moving to a position with
+           ;; indentation equaling min-indent. This is specially
+           ;; useful for navigating nested definitions recursively.
+           tree)
+          (t
+           (python-imenu--build-tree
+            min-indent
+            indent
+            ;; Add another children, either when this is the
+            ;; first call or when indentation is
+            ;; less-or-equal than previous. And do not
+            ;; discard the number of children, because the
+            ;; way code is scanned, all children are
+            ;; collected until a root node yet to be found
+            ;; appears.
+            (if (or (not prev-indent)
+                    (and
+                     (> indent min-indent)
+                     (<= indent prev-indent)))
+                (1+ num-children)
+              num-children)
+            (cond ((not prev-indent)
+                   ;; First call to the function: append this
+                   ;; defun to the index.
+                   (list (cons label pos)))
+                  ((= indent prev-indent)
+                   ;; Add another defun with the same depth
+                   ;; as the previous.
+                   (cons (cons label pos) tree))
+                  ((and (< indent prev-indent)
+                        (< 0 num-children))
+                   ;; There are children to be appended and
+                   ;; the previous defun had more
+                   ;; indentation, the current one must be a
+                   ;; parent.
+                   (python-imenu--put-parent type name pos num-children tree))
+                  ((> indent prev-indent)
+                   ;; There are children defuns deeper than
+                   ;; current depth. Fear not, we already
+                   ;; know how to treat them.
+                   (cons
+                    (prog1
+                        (python-imenu--build-tree
+                         prev-indent indent 1 (list (cons label pos)))
+                      ;; Adjustment: after scanning backwards
+                      ;; for all deeper children, we need to
+                      ;; continue our scan for a parent from
+                      ;; the current defun we are looking at.
+                      (python-nav-forward-defun))
+                    tree))))))))
+
+(defun python-imenu-create-index ()
+  "Return tree Imenu alist for the current python buffer.
+Change `python-imenu-format-item-label-function',
+`python-imenu-format-parent-item-label-function',
+`python-imenu-format-parent-item-jump-label-function' to
+customize how labels are formatted."
+  (goto-char (point-max))
+  (let ((index)
+        (tree))
+    (while (setq tree (python-imenu--build-tree))
+      (setq index (cons tree index)))
+    index))
+
+(defun python-imenu-create-flat-index (&optional alist prefix)
+  "Return flat outline of the current python buffer for Imenu.
+Optional Argument ALIST is the tree to be flattened, when nil
+`python-imenu-build-index' is used with
+`python-imenu-format-parent-item-jump-label-function'
+`python-imenu-format-parent-item-label-function'
+`python-imenu-format-item-label-function' set to (lambda (type
+name) name).  Optional Argument PREFIX is used in recursive calls
+and should not be passed explicitly.
+
+Converts this:
+
+    \((\"Foo\" . 103)
+     (\"Bar\" . 138)
+     (\"decorator\"
+      (\"decorator\" . 173)
+      (\"wrap\"
+       (\"wrap\" . 353)
+       (\"wrapped_f\" . 393))))
+
+To this:
+
+    \((\"Foo\" . 103)
+     (\"Bar\" . 138)
+     (\"decorator\" . 173)
+     (\"decorator.wrap\" . 353)
+     (\"decorator.wrapped_f\" . 393))"
+  ;; Inspired by imenu--flatten-index-alist removed in revno 21853.
+  (apply
+   'nconc
+   (mapcar
+    (lambda (item)
+      (let ((name (if prefix
+                      (concat prefix "." (car item))
+                    (car item)))
+            (pos (cdr item)))
+        (cond ((or (numberp pos) (markerp pos))
+               (list (cons name pos)))
+              ((listp pos)
+               (cons
+                (cons name (cdar pos))
+                (python-imenu-create-flat-index (cddr item) name))))))
+    (or alist
+        (let* ((fn (lambda (type name) name))
+               (python-imenu-format-item-label-function fn)
+              (python-imenu-format-parent-item-label-function fn)
+              (python-imenu-format-parent-item-jump-label-function fn))
+          (python-imenu-create-index))))))
 
 
 ;;; Misc helpers
@@ -3257,6 +3518,22 @@ Optional argument DIRECTION defines the direction to move to."
       (goto-char comment-start))
     (forward-comment factor)))
 
+(defun python-util-popn (lst n)
+  "Return LST first N elements.
+N should be an integer, when it's a natural negative number its
+opposite is used.  When N is bigger than the length of LST, the
+list is returned as is."
+  (let* ((n (min (abs n)))
+         (len (length lst))
+         (acc))
+    (if (> n len)
+        lst
+      (while (< 0 n)
+        (setq acc (cons (car lst) acc)
+              lst (cdr lst)
+              n (1- n)))
+      (reverse acc))))
+
 
 ;;;###autoload
 (define-derived-mode python-mode prog-mode "Python"
@@ -3302,11 +3579,8 @@ if that value is non-nil."
   (add-hook 'post-self-insert-hook
             'python-indent-post-self-insert-function nil 'local)
 
-  (set (make-local-variable 'imenu-extract-index-name-function)
-       #'python-info-current-defun)
-
-  (set (make-local-variable 'imenu-prev-index-position-function)
-       #'python-imenu-prev-index-position)
+  (set (make-local-variable 'imenu-create-index-function)
+       #'python-imenu-create-index)
 
   (set (make-local-variable 'add-log-current-defun-function)
        #'python-info-current-defun)
diff --git a/lisp/progmodes/ruby-mode.el b/lisp/progmodes/ruby-mode.el
index 6e471d1aa2a..fa4efe49b7b 100644
--- a/lisp/progmodes/ruby-mode.el
+++ b/lisp/progmodes/ruby-mode.el
@@ -113,7 +113,7 @@
   "Regexp to match the beginning of a heredoc.")
 
   (defconst ruby-expression-expansion-re
-    "[^\\]\\(\\\\\\\\\\)*\\(#\\({[^}\n\\\\]*\\(\\\\.[^}\n\\\\]*\\)*}\\|\\(\\$\\|@\\|@@\\)\\(\\w\\|_\\)+\\)\\)"))
+    "\\(?:[^\\]\\|\\=\\)\\(\\\\\\\\\\)*\\(#\\({[^}\n\\\\]*\\(\\\\.[^}\n\\\\]*\\)*}\\|\\(\\$\\|@\\|@@\\)\\(\\w\\|_\\)+\\)\\)"))
 
 (defun ruby-here-doc-end-match ()
   "Return a regexp to find the end of a heredoc.
@@ -148,13 +148,16 @@ This should only be called after matching against `ruby-here-doc-beg-re'."
 (define-abbrev-table 'ruby-mode-abbrev-table ()
   "Abbrev table in use in Ruby mode buffers.")
 
+(defvar ruby-use-smie nil)
+
 (defvar ruby-mode-map
   (let ((map (make-sparse-keymap)))
-    (define-key map (kbd "M-C-b") 'ruby-backward-sexp)
-    (define-key map (kbd "M-C-f") 'ruby-forward-sexp)
+    (unless ruby-use-smie
+      (define-key map (kbd "M-C-b") 'ruby-backward-sexp)
+      (define-key map (kbd "M-C-f") 'ruby-forward-sexp)
+      (define-key map (kbd "M-C-q") 'ruby-indent-exp))
     (define-key map (kbd "M-C-p") 'ruby-beginning-of-block)
     (define-key map (kbd "M-C-n") 'ruby-end-of-block)
-    (define-key map (kbd "M-C-q") 'ruby-indent-exp)
     (define-key map (kbd "C-c {") 'ruby-toggle-block)
     map)
   "Keymap used in Ruby mode.")
@@ -236,6 +239,111 @@ Also ignores spaces after parenthesis when 'space."
 (put 'ruby-comment-column 'safe-local-variable 'integerp)
 (put 'ruby-deep-arglist 'safe-local-variable 'booleanp)
 
+;;; SMIE support
+
+(require 'smie)
+
+(defconst ruby-smie-grammar
+  ;; FIXME: Add support for Cucumber.
+  (smie-prec2->grammar
+   (smie-bnf->prec2
+    '((id)
+      (insts (inst) (insts ";" insts))
+      (inst (exp) (inst "iuwu-mod" exp))
+      (exp  (exp1) (exp "," exp))
+      (exp1 (exp2) (exp2 "?" exp1 ":" exp1))
+      (exp2 ("def" insts "end")
+            ("begin" insts-rescue-insts "end")
+            ("do" insts "end")
+            ("class" insts "end") ("module" insts "end")
+            ("for" for-body "end")
+            ("[" expseq "]")
+            ("{" hashvals "}")
+            ("while" insts "end")
+            ("until" insts "end")
+            ("unless" insts "end")
+            ("if" if-body "end")
+            ("case"  cases "end"))
+      (for-body (for-head ";" insts))
+      (for-head (id "in" exp))
+      (cases (exp "then" insts) ;; FIXME: Ruby also allows (exp ":" insts).
+              (cases "when" cases) (insts "else" insts))
+      (expseq (exp) );;(expseq "," expseq)
+      (hashvals (id "=>" exp1) (hashvals "," hashvals))
+      (insts-rescue-insts (insts)
+                          (insts-rescue-insts "rescue" insts-rescue-insts)
+                          (insts-rescue-insts "ensure" insts-rescue-insts))
+      (itheni (insts) (exp "then" insts))
+      (ielsei (itheni) (itheni "else" insts))
+      (if-body (ielsei) (if-body "elsif" if-body)))
+    '((nonassoc "in") (assoc ";") (assoc ","))
+    '((assoc "when"))
+    '((assoc "elsif"))
+    '((assoc "rescue" "ensure"))
+    '((assoc ",")))))
+
+(defun ruby-smie--bosp ()
+  (save-excursion (skip-chars-backward " \t")
+                  (or (bolp) (eq (char-before) ?\;))))
+
+(defun ruby-smie--implicit-semi-p ()
+  (save-excursion
+    (skip-chars-backward " \t")
+    (not (or (bolp)
+             (memq (char-before) '(?\; ?- ?+ ?* ?/ ?:))
+             (and (memq (char-before) '(?\? ?=))
+                  (not (memq (char-syntax (char-before (1- (point))))
+                             '(?w ?_))))))))
+
+(defun ruby-smie--forward-token ()
+  (skip-chars-forward " \t")
+  (if (and (looking-at "[\n#]")
+           ;; Only add implicit ; when needed.
+           (ruby-smie--implicit-semi-p))
+      (progn
+        (if (eolp) (forward-char 1) (forward-comment 1))
+        ";")
+    (forward-comment (point-max))
+    (let ((tok (smie-default-forward-token)))
+      (cond
+       ((member tok '("unless" "if" "while" "until"))
+        (if (save-excursion (forward-word -1) (ruby-smie--bosp))
+            tok "iuwu-mod"))
+       (t tok)))))
+
+(defun ruby-smie--backward-token ()
+  (let ((pos (point)))
+    (forward-comment (- (point)))
+    (if (and (> pos (line-end-position))
+             (ruby-smie--implicit-semi-p))
+        (progn (skip-chars-forward " \t")
+               ";")
+      (let ((tok (smie-default-backward-token)))
+        (cond
+         ((member tok '("unless" "if" "while" "until"))
+          (if (ruby-smie--bosp)
+              tok "iuwu-mod"))
+         (t tok))))))
+
+(defun ruby-smie-rules (kind token)
+  (pcase (cons kind token)
+    (`(:elem . basic) ruby-indent-level)
+    (`(:after . ";")
+     (if (smie-rule-parent-p "def" "begin" "do" "class" "module" "for"
+                             "[" "{" "while" "until" "unless"
+                             "if" "then" "elsif" "else" "when"
+                             "rescue" "ensure")
+         (smie-rule-parent ruby-indent-level)
+       ;; For (invalid) code between switch and case.
+       ;; (if (smie-parent-p "switch") 4)
+       0))
+    (`(:before . ,(or `"else" `"then" `"elsif")) 0)
+    (`(:before . ,(or `"when"))
+     (if (not (smie-rule-sibling-p)) 0)) ;; ruby-indent-level
+    ;; Hack attack: Since newlines are separators, don't try to align args that
+    ;; appear on a separate line.
+    (`(:list-intro . ";") t)))
+
 (defun ruby-imenu-create-index-in-block (prefix beg end)
   "Create an imenu index of methods inside a block."
   (let ((index-alist '()) (case-fold-search nil)
@@ -290,7 +398,11 @@ Also ignores spaces after parenthesis when 'space."
   (set-syntax-table ruby-mode-syntax-table)
   (setq local-abbrev-table ruby-mode-abbrev-table)
   (setq indent-tabs-mode ruby-indent-tabs-mode)
-  (set (make-local-variable 'indent-line-function) 'ruby-indent-line)
+  (if ruby-use-smie
+      (smie-setup ruby-smie-grammar #'ruby-smie-rules
+                  :forward-token  #'ruby-smie--forward-token
+                  :backward-token #'ruby-smie--backward-token)
+    (set (make-local-variable 'indent-line-function) 'ruby-indent-line))
   (set (make-local-variable 'require-final-newline) t)
   (set (make-local-variable 'comment-start) "# ")
   (set (make-local-variable 'comment-end) "")
@@ -847,22 +959,24 @@ Can be one of `heredoc', `modifier', `expr-qstr', `expr-re'."
         indent))))
 
 (defun ruby-beginning-of-defun (&optional arg)
-  "Move backward to the beginning of the current top-level defun.
+  "Move backward to the beginning of the current defun.
 With ARG, move backward multiple defuns.  Negative ARG means
 move forward."
   (interactive "p")
-  (and (re-search-backward (concat "^\\s *" ruby-defun-beg-re "\\_>")
-                           nil t (or arg 1))
-       (beginning-of-line)))
-
-(defun ruby-end-of-defun (&optional arg)
-  "Move forward to the end of the current top-level defun.
-With ARG, move forward multiple defuns.  Negative ARG means
-move backward."
+  (let (case-fold-search)
+    (and (re-search-backward (concat "^\\s *" ruby-defun-beg-re "\\_>")
+                             nil t (or arg 1))
+         (beginning-of-line))))
+
+(defun ruby-end-of-defun ()
+  "Move point to the end of the current defun.
+The defun begins at or after the point.  This function is called
+by `end-of-defun'."
   (interactive "p")
   (ruby-forward-sexp)
-  (when (looking-back (concat "^\\s *" ruby-block-end-re))
-    (forward-line 1)))
+  (let (case-fold-search)
+    (when (looking-back (concat "^\\s *" ruby-block-end-re))
+      (forward-line 1))))
 
 (defun ruby-beginning-of-indent ()
   "Backtrack to a line which can be used as a reference for
@@ -881,6 +995,7 @@ current block, a sibling block, or an outer block.  Do that (abs N) times."
         (depth (or (nth 2 (ruby-parse-region (line-beginning-position)
                                              (line-end-position)))
                    0))
+        case-fold-search
         down done)
     (when (< (* depth signum) 0)
       ;; Moving end -> end or beginning -> beginning.
@@ -1232,6 +1347,9 @@ If the result is do-end block, it will always be multiline."
 (declare-function ruby-syntax-propertize-heredoc "ruby-mode" (limit))
 (declare-function ruby-syntax-enclosing-percent-literal "ruby-mode" (limit))
 (declare-function ruby-syntax-propertize-percent-literal "ruby-mode" (limit))
+;; Unusual code layout confuses the byte-compiler.
+(declare-function ruby-syntax-propertize-expansion "ruby-mode" ())
+(declare-function ruby-syntax-expansion-allowed-p "ruby-mode" (parse-state))
 
 (if (eval-when-compile (fboundp #'syntax-propertize-rules))
     ;; New code that works independently from font-lock.
@@ -1245,54 +1363,70 @@ If the result is do-end block, it will always be multiline."
           '("gsub" "gsub!" "sub" "sub!" "scan" "split" "split!" "index" "match"
             "assert_match" "Given" "Then" "When")
           "Methods that can take regexp as the first argument.
-It will be properly highlighted even when the call omits parens."))
+It will be properly highlighted even when the call omits parens.")
+
+        (defvar ruby-syntax-before-regexp-re
+          (concat
+           ;; Special tokens that can't be followed by a division operator.
+           "\\(^\\|[[=(,~?:;<>]"
+           ;; Control flow keywords and operators following bol or whitespace.
+           "\\|\\(?:^\\|\\s \\)"
+           (regexp-opt '("if" "elsif" "unless" "while" "until" "when" "and"
+                         "or" "not" "&&" "||"))
+           ;; Method name from the list.
+           "\\|\\_<"
+           (regexp-opt ruby-syntax-methods-before-regexp)
+           "\\)\\s *")
+          "Regexp to match text that can be followed by a regular expression."))
 
       (defun ruby-syntax-propertize-function (start end)
         "Syntactic keywords for Ruby mode.  See `syntax-propertize-function'."
-        (goto-char start)
-        (ruby-syntax-propertize-heredoc end)
-        (ruby-syntax-enclosing-percent-literal end)
-        (funcall
-         (syntax-propertize-rules
-          ;; $' $" $` .... are variables.
-          ;; ?' ?" ?` are ascii codes.
-          ("\\([?$]\\)[#\"'`]"
-           (1 (unless (save-excursion
-                        ;; Not within a string.
-                        (nth 3 (syntax-ppss (match-beginning 0))))
-                (string-to-syntax "\\"))))
-          ;; Regexps: regexps are distinguished from division because
-          ;; of the keyword, symbol, or method name before them.
-          ((concat
-            ;; Special tokens that can't be followed by a division operator.
-            "\\(^\\|[[=(,~?:;<>]"
-            ;; Control flow keywords and operators following bol or whitespace.
-            "\\|\\(?:^\\|\\s \\)"
-            (regexp-opt '("if" "elsif" "unless" "while" "until" "when" "and"
-                          "or" "not" "&&" "||"))
-            ;; Method name from the list.
-            "\\|\\_<"
-            (regexp-opt ruby-syntax-methods-before-regexp)
-            "\\)\\s *"
-            ;; The regular expression itself.
-            "\\(/\\)[^/\n\\\\]*\\(?:\\\\.[^/\n\\\\]*\\)*\\(/\\)")
-           (3 (unless (nth 3 (syntax-ppss (match-beginning 2)))
-                (put-text-property (match-beginning 2) (match-end 2)
-                                   'syntax-table (string-to-syntax "\"/"))
-                (string-to-syntax "\"/"))))
-          ("^=en\\(d\\)\\_>" (1 "!"))
-          ("^\\(=\\)begin\\_>" (1 "!"))
-          ;; Handle here documents.
-          ((concat ruby-here-doc-beg-re ".*\\(\n\\)")
-           (7 (unless (ruby-singleton-class-p (match-beginning 0))
-                (put-text-property (match-beginning 7) (match-end 7)
-                                   'syntax-table (string-to-syntax "\""))
-                (ruby-syntax-propertize-heredoc end))))
-          ;; Handle percent literals: %w(), %q{}, etc.
-          ((concat "\\(?:^\\|[[ \t\n<+(,=]\\)" ruby-percent-literal-beg-re)
-           (1 (prog1 "|" (ruby-syntax-propertize-percent-literal end)))))
-         (point) end)
-        (ruby-syntax-propertize-expansions start end))
+        (let (case-fold-search)
+          (goto-char start)
+          (remove-text-properties start end '(ruby-expansion-match-data))
+          (ruby-syntax-propertize-heredoc end)
+          (ruby-syntax-enclosing-percent-literal end)
+          (funcall
+           (syntax-propertize-rules
+            ;; $' $" $` .... are variables.
+            ;; ?' ?" ?` are ascii codes.
+            ("\\([?$]\\)[#\"'`]"
+             (1 (unless (save-excursion
+                          ;; Not within a string.
+                          (nth 3 (syntax-ppss (match-beginning 0))))
+                  (string-to-syntax "\\"))))
+            ;; Regular expressions.  Start with matching unescaped slash.
+            ("\\(?:\\=\\|[^\\]\\)\\(?:\\\\\\\\\\)*\\(/\\)"
+             (1 (let ((state (save-excursion (syntax-ppss (match-beginning 1)))))
+                  (when (or
+                         ;; Beginning of a regexp.
+                         (and (null (nth 8 state))
+                              (save-excursion
+                                (forward-char -1)
+                                (looking-back ruby-syntax-before-regexp-re
+                                              (point-at-bol))))
+                         ;; End of regexp.  We don't match the whole
+                         ;; regexp at once because it can have
+                         ;; string interpolation inside, or span
+                         ;; several lines.
+                         (eq ?/ (nth 3 state)))
+                    (string-to-syntax "\"/")))))
+            ;; Expression expansions in strings.  We're handling them
+            ;; here, so that the regexp rule never matches inside them.
+            (ruby-expression-expansion-re
+             (0 (ignore (ruby-syntax-propertize-expansion))))
+            ("^=en\\(d\\)\\_>" (1 "!"))
+            ("^\\(=\\)begin\\_>" (1 "!"))
+            ;; Handle here documents.
+            ((concat ruby-here-doc-beg-re ".*\\(\n\\)")
+             (7 (unless (ruby-singleton-class-p (match-beginning 0))
+                  (put-text-property (match-beginning 7) (match-end 7)
+                                     'syntax-table (string-to-syntax "\""))
+                  (ruby-syntax-propertize-heredoc end))))
+            ;; Handle percent literals: %w(), %q{}, etc.
+            ((concat "\\(?:^\\|[[ \t\n<+(,=]\\)" ruby-percent-literal-beg-re)
+             (1 (prog1 "|" (ruby-syntax-propertize-percent-literal end)))))
+           (point) end)))
 
       (defun ruby-syntax-propertize-heredoc (limit)
         (let ((ppss (syntax-ppss))
@@ -1305,7 +1439,7 @@ It will be properly highlighted even when the call omits parens."))
                                         (line-end-position) t)
                 (unless (ruby-singleton-class-p (match-beginning 0))
                   (push (concat (ruby-here-doc-end-match) "\n") res))))
-            (let ((start (point)))
+            (save-excursion
               ;; With multiple openers on the same line, we don't know in which
               ;; part `start' is, so we have to go back to the beginning.
               (when (cdr res)
@@ -1315,9 +1449,9 @@ It will be properly highlighted even when the call omits parens."))
                 (if (null res)
                     (put-text-property (1- (point)) (point)
                                        'syntax-table (string-to-syntax "\""))))
-              ;; Make extra sure we don't move back, lest we could fall into an
-              ;; inf-loop.
-              (if (< (point) start) (goto-char start))))))
+              ;; End up at bol following the heredoc openers.
+              ;; Propertize expression expansions from this point forward.
+              ))))
 
       (defun ruby-syntax-enclosing-percent-literal (limit)
         (let ((state (syntax-ppss))
@@ -1338,44 +1472,59 @@ It will be properly highlighted even when the call omits parens."))
                  (cl (or (cdr (aref (syntax-table) op))
                          (cdr (assoc op '((?< . ?>))))))
                  parse-sexp-lookup-properties)
-            (condition-case nil
-                (progn
-                  (if cl ; Paired delimiters.
-                      ;; Delimiter pairs of the same kind can be nested
-                      ;; inside the literal, as long as they are balanced.
-                      ;; Create syntax table that ignores other characters.
-                      (with-syntax-table (make-char-table 'syntax-table nil)
-                        (modify-syntax-entry op (concat "(" (char-to-string cl)))
-                        (modify-syntax-entry cl (concat ")" ops))
-                        (modify-syntax-entry ?\\ "\\")
-                        (save-restriction
-                          (narrow-to-region (point) limit)
-                          (forward-list))) ; skip to the paired character
-                    ;; Single character delimiter.
-                    (re-search-forward (concat "[^\\]\\(?:\\\\\\\\\\)*"
-                                               (regexp-quote ops)) limit nil))
-                  ;; Found the closing delimiter.
-                  (put-text-property (1- (point)) (point) 'syntax-table
-                                     (string-to-syntax "|")))
-              ;; Unclosed literal, leave the following text unpropertized.
-              ((scan-error search-failed) (goto-char limit))))))
+            (save-excursion
+              (condition-case nil
+                  (progn
+                    (if cl              ; Paired delimiters.
+                        ;; Delimiter pairs of the same kind can be nested
+                        ;; inside the literal, as long as they are balanced.
+                        ;; Create syntax table that ignores other characters.
+                        (with-syntax-table (make-char-table 'syntax-table nil)
+                          (modify-syntax-entry op (concat "(" (char-to-string cl)))
+                          (modify-syntax-entry cl (concat ")" ops))
+                          (modify-syntax-entry ?\\ "\\")
+                          (save-restriction
+                            (narrow-to-region (point) limit)
+                            (forward-list))) ; skip to the paired character
+                      ;; Single character delimiter.
+                      (re-search-forward (concat "[^\\]\\(?:\\\\\\\\\\)*"
+                                                 (regexp-quote ops)) limit nil))
+                    ;; Found the closing delimiter.
+                    (put-text-property (1- (point)) (point) 'syntax-table
+                                       (string-to-syntax "|")))
+                ;; Unclosed literal, do nothing.
+                ((scan-error search-failed)))))))
+
+      (defun ruby-syntax-propertize-expansion ()
+        ;; Save the match data to a text property, for font-locking later.
+        ;; Set the syntax of all double quotes and backticks to punctuation.
+        (let* ((beg (match-beginning 2))
+               (end (match-end 2))
+               (state (and beg (save-excursion (syntax-ppss beg)))))
+          (when (ruby-syntax-expansion-allowed-p state)
+            (put-text-property beg (1+ beg) 'ruby-expansion-match-data
+                               (match-data))
+            (goto-char beg)
+            (while (re-search-forward "[\"`]" end 'move)
+              (put-text-property (match-beginning 0) (match-end 0)
+                                 'syntax-table (string-to-syntax "."))))))
+
+      (defun ruby-syntax-expansion-allowed-p (parse-state)
+        "Return non-nil if expression expansion is allowed."
+        (let ((term (nth 3 parse-state)))
+          (cond
+           ((memq term '(?\" ?` ?\n ?/)))
+           ((eq term t)
+            (save-match-data
+              (save-excursion
+                (goto-char (nth 8 parse-state))
+                (looking-at "%\\(?:[QWrx]\\|\\W\\)")))))))
 
       (defun ruby-syntax-propertize-expansions (start end)
-        (remove-text-properties start end '(ruby-expansion-match-data))
-        (goto-char start)
-        ;; Find all expression expansions and
-        ;; - save the match data to a text property, for font-locking later,
-        ;; - set the syntax of all double quotes and backticks to punctuation.
-        (while (re-search-forward ruby-expression-expansion-re end 'move)
-          (let ((beg (match-beginning 2))
-                (end (match-end 2)))
-            (when (and beg (save-excursion (nth 3 (syntax-ppss beg))))
-              (put-text-property beg (1+ beg) 'ruby-expansion-match-data
-                                 (match-data))
-              (goto-char beg)
-              (while (re-search-forward "[\"`]" end 'move)
-                (put-text-property (match-beginning 0) (match-end 0)
-                                   'syntax-table (string-to-syntax ".")))))))
+        (save-excursion
+          (goto-char start)
+          (while (re-search-forward ruby-expression-expansion-re end 'move)
+            (ruby-syntax-propertize-expansion))))
       )
 
   ;; For Emacsen where syntax-propertize-rules is not (yet) available,
diff --git a/lisp/progmodes/sh-script.el b/lisp/progmodes/sh-script.el
index 8f1954402e5..07e9bb85c4e 100644
--- a/lisp/progmodes/sh-script.el
+++ b/lisp/progmodes/sh-script.el
@@ -335,11 +335,11 @@ shell it really is."
      . ((nil
          ;; function FOO
          ;; function FOO()
-         "^\\s-*function\\s-+\\\([[:alpha:]_][[:alnum:]_]+\\)\\s-*\\(?:()\\)?"
+         "^\\s-*function\\s-+\\\([[:alpha:]_][[:alnum:]_]*\\)\\s-*\\(?:()\\)?"
          1)
         ;; FOO()
         (nil
-         "^\\s-*\\([[:alpha:]_][[:alnum:]_]+\\)\\s-*()"
+         "^\\s-*\\([[:alpha:]_][[:alnum:]_]*\\)\\s-*()"
          1)
         )))
   "Alist of regular expressions for recognizing shell function definitions.
@@ -353,6 +353,28 @@ See `sh-feature' and `imenu-generic-expression'."
   :group 'sh-script
   :version "20.4")
 
+(defun sh-current-defun-name ()
+  "Find the name of function or variable at point.
+For use in `add-log-current-defun-function'."
+  (save-excursion
+    (end-of-line)
+    (when (re-search-backward
+           (concat "\\(?:"
+                   ;; function FOO
+                   ;; function FOO()
+                   "^\\s-*function\\s-+\\\([[:alpha:]_][[:alnum:]_]*\\)\\s-*\\(?:()\\)?"
+                   "\\)\\|\\(?:"
+                   ;; FOO()
+                   "^\\s-*\\([[:alpha:]_][[:alnum:]_]*\\)\\s-*()"
+                   "\\)\\|\\(?:"
+                   ;; FOO=
+                   "^\\([[:alpha:]_][[:alnum:]_]*\\)="
+                   "\\)")
+           nil t)
+      (or (match-string-no-properties 1)
+          (match-string-no-properties 2)
+          (match-string-no-properties 3)))))
+
 (defvar sh-shell-variables nil
   "Alist of shell variable names that should be included in completion.
 These are used for completion in addition to all the variables named
@@ -1533,6 +1555,7 @@ with your script for an edit-interpret-debug cycle."
   (setq-local skeleton-newline-indent-rigidly t)
   (setq-local defun-prompt-regexp
               (concat "^\\(function[ \t]\\|[[:alnum:]]+[ \t]+()[ \t]+\\)"))
+  (setq-local add-log-current-defun-function #'sh-current-defun-name)
   ;; Parse or insert magic number for exec, and set all variables depending
   ;; on the shell thus determined.
   (sh-set-shell
diff --git a/lisp/progmodes/sql.el b/lisp/progmodes/sql.el
index 3cf6757d5ec..940afc3d5f4 100644
--- a/lisp/progmodes/sql.el
+++ b/lisp/progmodes/sql.el
@@ -285,36 +285,49 @@ file.  Since that is a plaintext file, this could be dangerous."
 
 (define-widget 'sql-login-params 'lazy
   "Widget definition of the login parameters list"
-  ;; FIXME: does not implement :default property for the user,
-  ;; database and server options.  Anybody have some guidance on how to
-  ;; do this.
   :tag "Login Parameters"
-  :type '(repeat (choice
-                  (const user)
-                  (const password)
-                  (choice :tag "server"
-                          (const server)
-                          (list :tag "file"
-                                (const :format "" server)
-                                (const :format "" :file)
-                                regexp)
-                          (list :tag "completion"
-                                (const :format "" server)
+  :type '(set :tag "Login Parameters"
+              (choice :tag "user"
+                      :value user
+                      (const user)
+                      (list :tag "Specify a default"
+                            (const user)
+                            (list :tag "Default"
+                                  :inline t (const :default) string)))
+              (const password)
+              (choice :tag "server"
+                      :value server
+                      (const server)
+                      (list :tag "Specify a default"
+                            (const server)
+                            (list :tag "Default"
+                                  :inline t (const :default) string))
+                      (list :tag "file"
+                            (const :format "" server)
+                            (const :format "" :file)
+                            regexp)
+                      (list :tag "completion"
+                            (const :format "" server)
+                            (const :format "" :completion)
+                            (restricted-sexp
+                             :match-alternatives (listp stringp))))
+              (choice :tag "database"
+                      :value database
+                      (const database)
+                      (list :tag "Specify a default"
+                            (const database)
+                            (list :tag "Default"
+                                  :inline t (const :default) string))
+                      (list :tag "file"
+                            (const :format "" database)
+                            (const :format "" :file)
+                            regexp)
+                      (list :tag "completion"
+                            (const :format "" database)
                                 (const :format "" :completion)
                                 (restricted-sexp
                                  :match-alternatives (listp stringp))))
-                  (choice :tag "database"
-                          (const database)
-                          (list :tag "file"
-                                (const :format "" database)
-                                (const :format "" :file)
-                                regexp)
-                          (list :tag "completion"
-                                (const :format "" database)
-                                (const :format "" :completion)
-                                (restricted-sexp
-                                 :match-alternatives (listp stringp))))
-                  (const port))))
+              (const port)))
 
 ;; SQL Product support
 
diff --git a/lisp/progmodes/subword.el b/lisp/progmodes/subword.el
index 80e632c6ef6..a75bdff27bd 100644
--- a/lisp/progmodes/subword.el
+++ b/lisp/progmodes/subword.el
@@ -26,7 +26,8 @@
 
 ;; This package provides `subword' oriented commands and a minor mode
 ;; (`subword-mode') that substitutes the common word handling
-;; functions with them.
+;; functions with them.  It also provides the `superword-mode' minor
+;; mode that treats symbols as words, the opposite of `subword-mode'.
 
 ;; In spite of GNU Coding Standards, it is popular to name a symbol by
 ;; mixing uppercase and lowercase letters, e.g. "GtkWidget",
@@ -43,12 +44,13 @@
 
 ;; The subword oriented commands defined in this package recognize
 ;; subwords in a nomenclature to move between them and to edit them as
-;; words.
+;; words.  You also get a mode to treat symbols as words instead,
+;; called `superword-mode' (the opposite of `subword-mode').
 
 ;; In the minor mode, all common key bindings for word oriented
 ;; commands are overridden by the subword oriented commands:
 
-;; Key     Word oriented command      Subword oriented command
+;; Key     Word oriented command      Subword oriented command (also superword)
 ;; ============================================================
 ;; M-f     `forward-word'             `subword-forward'
 ;; M-b     `backward-word'            `subword-backward'
@@ -67,8 +69,13 @@
 ;; To make the mode turn on automatically, put the following code in
 ;; your .emacs:
 ;;
-;; (add-hook 'c-mode-common-hook
-;;        (lambda () (subword-mode 1)))
+;; (add-hook 'c-mode-common-hook 'subword-mode)
+;;
+
+;; To make the mode turn `superword-mode' on automatically for
+;; only some modes, put the following code in your .emacs:
+;;
+;; (add-hook 'c-mode-common-hook 'superword-mode)
 ;;
 
 ;; Acknowledgment:
@@ -98,7 +105,8 @@
   (let ((map (make-sparse-keymap)))
     (dolist (cmd '(forward-word backward-word mark-word kill-word
                                 backward-kill-word transpose-words
-                                capitalize-word upcase-word downcase-word))
+                                capitalize-word upcase-word downcase-word
+                                left-word right-word))
       (let ((othercmd (let ((name (symbol-name cmd)))
                         (string-match "\\([[:alpha:]-]+\\)-word[s]?" name)
                         (intern (concat "subword-" (match-string 1 name))))))
@@ -133,21 +141,21 @@ subwords in a nomenclature to move between subwords and to edit them
 as words.
 
 \\{subword-mode-map}"
-    nil
-    nil
-    subword-mode-map)
+    :lighter " ,"
+    (when subword-mode (superword-mode -1)))
 
 (define-obsolete-function-alias 'c-subword-mode 'subword-mode "23.2")
 
 ;;;###autoload
 (define-global-minor-mode global-subword-mode subword-mode
-  (lambda () (subword-mode 1)))
+  (lambda () (subword-mode 1))
+  :group 'convenience)
 
 (defun subword-forward (&optional arg)
   "Do the same as `forward-word' but on subwords.
 See the command `subword-mode' for a description of subwords.
 Optional argument ARG is the same as for `forward-word'."
-  (interactive "p")
+  (interactive "^p")
   (unless arg (setq arg 1))
   (cond
    ((< 0 arg)
@@ -165,9 +173,23 @@ Optional argument ARG is the same as for `forward-word'."
   "Do the same as `backward-word' but on subwords.
 See the command `subword-mode' for a description of subwords.
 Optional argument ARG is the same as for `backward-word'."
-  (interactive "p")
+  (interactive "^p")
   (subword-forward (- (or arg 1))))
 
+(defun subword-right (&optional arg)
+  "Do the same as `right-word' but on subwords."
+  (interactive "^p")
+  (if (eq (current-bidi-paragraph-direction) 'left-to-right)
+      (subword-forward arg)
+    (subword-backward arg)))
+
+(defun subword-left (&optional arg)
+  "Do the same as `left-word' but on subwords."
+  (interactive "^p")
+  (if (eq (current-bidi-paragraph-direction) 'left-to-right)
+      (subword-backward arg)
+    (subword-forward arg)))
+
 (defun subword-mark (arg)
   "Do the same as `mark-word' but on subwords.
 See the command `subword-mode' for a description of subwords.
@@ -254,41 +276,74 @@ Optional argument ARG is the same as for `capitalize-word'."
     (unless advance
       (goto-char start))))
 
+
+
+(defvar superword-mode-map subword-mode-map
+  "Keymap used in `superword-mode' minor mode.")
+
+;;;###autoload
+(define-minor-mode superword-mode
+  "Toggle superword movement and editing (Superword mode).
+With a prefix argument ARG, enable Superword mode if ARG is
+positive, and disable it otherwise.  If called from Lisp, enable
+the mode if ARG is omitted or nil.
+
+Superword mode is a buffer-local minor mode.  Enabling it remaps
+word-based editing commands to superword-based commands that
+treat symbols as words, e.g. \"this_is_a_symbol\".
+
+The superword oriented commands activated in this minor mode
+recognize symbols as superwords to move between superwords and to
+edit them as words.
+
+\\{superword-mode-map}"
+    :lighter " ²"
+    (when superword-mode (subword-mode -1)))
+
+;;;###autoload
+(define-global-minor-mode global-superword-mode superword-mode
+  (lambda () (superword-mode 1))
+  :group 'convenience)
 
 
 ;;
 ;; Internal functions
 ;;
 (defun subword-forward-internal ()
-  (if (and
-       (save-excursion
-         (let ((case-fold-search nil))
-           (re-search-forward subword-forward-regexp nil t)))
-       (> (match-end 0) (point)))
-      (goto-char
-       (cond
-        ((< 1 (- (match-end 2) (match-beginning 2)))
-         (1- (match-end 2)))
-        (t
-         (match-end 0))))
-    (forward-word 1)))
-
+  (if superword-mode
+      (forward-symbol 1)
+    (if (and
+         (save-excursion
+           (let ((case-fold-search nil))
+             (re-search-forward subword-forward-regexp nil t)))
+         (> (match-end 0) (point)))
+        (goto-char
+         (cond
+          ((< 1 (- (match-end 2) (match-beginning 2)))
+           (1- (match-end 2)))
+          (t
+           (match-end 0))))
+      (forward-word 1))))
 
 (defun subword-backward-internal ()
-  (if (save-excursion
-        (let ((case-fold-search nil))
-          (re-search-backward subword-backward-regexp nil t)))
-      (goto-char
-       (cond
-        ((and (match-end 3)
-              (< 1 (- (match-end 3) (match-beginning 3)))
-              (not (eq (point) (match-end 3))))
-         (1- (match-end 3)))
-        (t
-         (1+ (match-beginning 0)))))
-    (backward-word 1)))
+  (if superword-mode
+      (forward-symbol -1)
+    (if (save-excursion
+          (let ((case-fold-search nil))
+            (re-search-backward subword-backward-regexp nil t)))
+        (goto-char
+         (cond
+          ((and (match-end 3)
+                (< 1 (- (match-end 3) (match-beginning 3)))
+                (not (eq (point) (match-end 3))))
+           (1- (match-end 3)))
+          (t
+           (1+ (match-beginning 0)))))
+      (backward-word 1))))
 
 
+
 (provide 'subword)
+(provide 'superword)
 
 ;;; subword.el ends here
diff --git a/lisp/progmodes/tcl.el b/lisp/progmodes/tcl.el
index 9169a433015..3e91aeba9a1 100644
--- a/lisp/progmodes/tcl.el
+++ b/lisp/progmodes/tcl.el
@@ -266,7 +266,7 @@ quoted for Tcl."
   ;; Maybe someone has a better set?
   (let ((map (make-sparse-keymap)))
     ;; Will inherit from `comint-mode-map' thanks to define-derived-mode.
-    (define-key map "\t" 'comint-dynamic-complete)
+    (define-key map "\t" 'completion-at-point)
     (define-key map "\M-?" 'comint-dynamic-list-filename-completions)
     (define-key map "\177" 'backward-delete-char-untabify)
     (define-key map "\M-\C-x" 'tcl-eval-defun)
diff --git a/lisp/progmodes/vera-mode.el b/lisp/progmodes/vera-mode.el
index 7b59faca261..443472192be 100644
--- a/lisp/progmodes/vera-mode.el
+++ b/lisp/progmodes/vera-mode.el
@@ -101,6 +101,8 @@ select and move operations.  All parts of an identifier separated by underscore
 are treated as single words otherwise."
   :type 'boolean
   :group 'vera)
+(make-obsolete-variable 'vera-underscore-is-part-of-word
+                        'superword-mode "24.4")
 
 (defcustom vera-intelligent-tab t
   "Non-nil means `TAB' does indentation, word completion and tab insertion.
@@ -1353,6 +1355,11 @@ If `vera-intelligent-tab' is nil, always indent line."
 (defvar vera-expand-upper-case nil)
 
 (eval-when-compile (require 'hippie-exp))
+(declare-function he-init-string "hippie-exp" (beg end))
+(declare-function he-dabbrev-beg "hippie-exp" ())
+(declare-function he-string-member "hippie-exp" (str lst &optional trans-case))
+(declare-function he-reset-string "hippie-exp" ())
+(declare-function he-substitute-string "hippie-exp" (str &optional trans-case))
 
 (defun vera-try-expand-abbrev (old)
   "Try expanding abbreviations from `vera-abbrev-list'."
diff --git a/lisp/progmodes/verilog-mode.el b/lisp/progmodes/verilog-mode.el
index 5571a905f85..ed911fcbba2 100644
--- a/lisp/progmodes/verilog-mode.el
+++ b/lisp/progmodes/verilog-mode.el
@@ -123,9 +123,9 @@
 ;;; Code:
 
 ;; This variable will always hold the version number of the mode
-(defconst verilog-mode-version (substring "$$Revision: 820 $$" 12 -3)
+(defconst verilog-mode-version (substring "$$Revision: 840 $$" 12 -3)
   "Version of this Verilog mode.")
-(defconst verilog-mode-release-date (substring "$$Date: 2012-09-17 20:43:10 -0400 (Mon, 17 Sep 2012) $$" 8 -3)
+(defconst verilog-mode-release-date (substring "$$Date: 2013-01-03 05:29:05 -0800 (Thu, 03 Jan 2013) $$" 8 -3)
   "Release date of this Verilog mode.")
 (defconst verilog-mode-release-emacs t
   "If non-nil, this version of Verilog mode was released with Emacs itself.")
@@ -501,7 +501,7 @@ entry \"Fontify Buffer\").  XEmacs: turn off and on font locking."
   "Type of statements to lineup across multiple lines.
 If 'all' is selected, then all line ups described below are done.
 
-If 'declaration', then just declarations are lined up with any
+If 'declarations', then just declarations are lined up with any
 preceding declarations, taking into account widths and the like,
 so or example the code:
         reg [31:0] a;
@@ -964,7 +964,7 @@ See also `verilog-library-flags', `verilog-library-directories'."
 This is used for AUTORESET and AUTOTIEOFF.  For proper behavior,
 you will probably also need `verilog-auto-reset-widths' set."
   :group 'verilog-mode-auto
-  :type 'string)
+  :type '(choice (const nil) regexp))
 (put 'verilog-active-low-regexp 'safe-local-variable 'stringp)
 
 (defcustom verilog-auto-sense-include-inputs nil
@@ -1129,37 +1129,37 @@ won't merge conflict."
 
 (defcustom verilog-auto-inst-interfaced-ports nil
   "Non-nil means include interfaced ports in AUTOINST expansions."
+  :version "24.3"  ;; rev773, default change rev815
   :group 'verilog-mode-auto
-  :type 'boolean
-  :version "24.3")
+  :type 'boolean)
 (put 'verilog-auto-inst-interfaced-ports 'safe-local-variable 'verilog-booleanp)
 
 (defcustom verilog-auto-input-ignore-regexp nil
   "If set, when creating AUTOINPUT list, ignore signals matching this regexp.
 See the \\[verilog-faq] for examples on using this."
   :group 'verilog-mode-auto
-  :type 'string)
+  :type '(choice (const nil) regexp))
 (put 'verilog-auto-input-ignore-regexp 'safe-local-variable 'stringp)
 
 (defcustom verilog-auto-inout-ignore-regexp nil
   "If set, when creating AUTOINOUT list, ignore signals matching this regexp.
 See the \\[verilog-faq] for examples on using this."
   :group 'verilog-mode-auto
-  :type 'string)
+  :type '(choice (const nil) regexp))
 (put 'verilog-auto-inout-ignore-regexp 'safe-local-variable 'stringp)
 
 (defcustom verilog-auto-output-ignore-regexp nil
   "If set, when creating AUTOOUTPUT list, ignore signals matching this regexp.
 See the \\[verilog-faq] for examples on using this."
   :group 'verilog-mode-auto
-  :type 'string)
+  :type '(choice (const nil) regexp))
 (put 'verilog-auto-output-ignore-regexp 'safe-local-variable 'stringp)
 
 (defcustom verilog-auto-template-warn-unused nil
   "Non-nil means report warning if an AUTO_TEMPLATE line is not used.
 This feature is not supported before Emacs 21.1 or XEmacs 21.4."
+  :version "24.3"  ;;rev787
   :group 'verilog-mode-auto
-  :version "24.3"
   :type 'boolean)
 (put 'verilog-auto-template-warn-unused 'safe-local-variable 'verilog-booleanp)
 
@@ -1176,21 +1176,21 @@ assignment, else the data type for variable creation."
   "If set, when creating AUTOTIEOFF list, ignore signals matching this regexp.
 See the \\[verilog-faq] for examples on using this."
   :group 'verilog-mode-auto
-  :type 'string)
+  :type '(choice (const nil) regexp))
 (put 'verilog-auto-tieoff-ignore-regexp 'safe-local-variable 'stringp)
 
 (defcustom verilog-auto-unused-ignore-regexp nil
   "If set, when creating AUTOUNUSED list, ignore signals matching this regexp.
 See the \\[verilog-faq] for examples on using this."
   :group 'verilog-mode-auto
-  :type 'string)
+  :type '(choice (const nil) regexp))
 (put 'verilog-auto-unused-ignore-regexp 'safe-local-variable 'stringp)
 
 (defcustom verilog-typedef-regexp nil
   "If non-nil, regular expression that matches Verilog-2001 typedef names.
 For example, \"_t$\" matches typedefs named with _t, as in the C language."
   :group 'verilog-mode-auto
-  :type 'string)
+  :type '(choice (const nil) regexp))
 (put 'verilog-typedef-regexp 'safe-local-variable 'stringp)
 
 (defcustom verilog-mode-hook   'verilog-set-compile-command
@@ -1230,14 +1230,14 @@ For example, \"_t$\" matches typedefs named with _t, as in the C language."
 
 (defcustom verilog-before-save-font-hook nil
   "Hook run before `verilog-save-font-mods' removes highlighting."
+  :version "24.3"  ;;rev735
   :group 'verilog-mode-auto
-  :version "24.3"
   :type 'hook)
 
 (defcustom verilog-after-save-font-hook nil
   "Hook run after `verilog-save-font-mods' restores highlighting."
+  :version "24.3"  ;;rev735
   :group 'verilog-mode-auto
-  :version "24.3"
   :type 'hook)
 
 (defvar verilog-imenu-generic-expression
@@ -2784,6 +2784,8 @@ find the errors."
     (modify-syntax-entry ?> "." table)
     (modify-syntax-entry ?& "." table)
     (modify-syntax-entry ?| "." table)
+    ;; FIXME: This goes against Emacs conventions.  Use "_" syntax instead and
+    ;; then use regexps with things like "\\_<...\\_>".
     (modify-syntax-entry ?` "w" table)
     (modify-syntax-entry ?_ "w" table)
     (modify-syntax-entry ?\' "." table)
@@ -7771,9 +7773,12 @@ Tieoff value uses `verilog-active-low-regexp' and
          ;; Else presume verilog-auto-reset-widths is true
          (t
           (let* ((width (verilog-sig-width sig)))
-            (if (string-match "^[0-9]+$" width)
-                (concat width (if (verilog-sig-signed sig) "'sh0" "'h0"))
-              (concat "{" width "{1'b0}}")))))))
+            (cond ((not width)
+                   "`0/*NOWIDTH*/")
+                  ((string-match "^[0-9]+$" width)
+                   (concat width (if (verilog-sig-signed sig) "'sh0" "'h0")))
+                  (t
+                   (concat "{" width "{1'b0}}"))))))))
 
 ;;
 ;; Dumping
@@ -7954,6 +7959,7 @@ Return an array of [outputs inouts inputs wire reg assign const]."
         vec expect-signal keywd newsig rvalue enum io signed typedefed multidim
         modport
         varstack tmp)
+    ;;(if dbg (setq dbg (concat dbg (format "\n\nverilog-read-decls START PT %s END %s\n" (point) end-mod-point))))
     (save-excursion
       (verilog-beg-of-defun-quick)
       (setq sigs-const (verilog-read-auto-constants (point) end-mod-point))
@@ -8008,7 +8014,7 @@ Return an array of [outputs inouts inputs wire reg assign const]."
           (setq paren (1- paren))
           (forward-char 1)
           (when (< paren sig-paren)
-            (setq expect-signal nil)))   ; ) that ends variables inside v2k arg list
+            (setq expect-signal nil rvalue nil)))   ; ) that ends variables inside v2k arg list
          ((looking-at "\\s-*\\(\\[[^]]+\\]\\)")
           (goto-char (match-end 0))
           (cond (newsig ; Memory, not just width.  Patch last signal added's memory (nth 3)
@@ -12456,12 +12462,20 @@ used on the right hand side of assignments.
 
 By default, AUTORESET will include the width of the signal in the
 autos, SystemVerilog designs may want to change this.  To control
-this behavior, see `verilog-auto-reset-widths'.
+this behavior, see `verilog-auto-reset-widths'.  In some cases
+AUTORESET must use a '0 assignment and it will print NOWIDTH; use
+`verilog-auto-reset-widths' unbased to prevent this.
 
 AUTORESET ties signals to deasserted, which is presumed to be zero.
 Signals that match `verilog-active-low-regexp' will be deasserted by tying
 them to a one.
 
+AUTORESET may try to reset arrays or structures that cannot be
+reset by a simple assignment, resulting in compile errors.  This
+is a feature to be taken as a hint that you need to reset these
+signals manually (or put them into a \"`ifdef NEVER signal<=`0;
+`endif\" so Verilog-Mode ignores them.)
+
 An example:
 
     always @(posedge clk or negedge reset_l) begin
diff --git a/lisp/progmodes/vhdl-mode.el b/lisp/progmodes/vhdl-mode.el
index e3b421efbe1..0050a94513a 100644
--- a/lisp/progmodes/vhdl-mode.el
+++ b/lisp/progmodes/vhdl-mode.el
@@ -13,10 +13,10 @@
 ;; filed in the Emacs bug reporting system against this file, a copy
 ;; of the bug report be sent to the maintainer's email address.
 
-(defconst vhdl-version "3.33.28"
+(defconst vhdl-version "3.34.2"
   "VHDL Mode version number.")
 
-(defconst vhdl-time-stamp "2010-09-22"
+(defconst vhdl-time-stamp "2012-11-21"
   "VHDL Mode time stamp for last update.")
 
 ;; This file is part of GNU Emacs.
@@ -72,8 +72,7 @@
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;; Emacs Versions
 
-;; supported: GNU Emacs 20.X/21.X/22.X,23.X, XEmacs 20.X/21.X
-;; tested on: GNU Emacs 20.4/21.3/22.1,23.X, XEmacs 21.1 (marginally)
+;; this updated version was only tested on: GNU Emacs 20.4
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;; Installation
@@ -84,7 +83,7 @@
 ;; or into an arbitrary directory that is added to the load path by the
 ;; following line in your Emacs start-up file `.emacs':
 
-;;   (setq load-path (cons (expand-file-name "<directory-name>") load-path))
+;;   (push (expand-file-name "<directory-name>") load-path)
 
 ;; If you already have the compiled `vhdl-mode.elc' file, put it in the same
 ;; directory.  Otherwise, byte-compile the source file:
@@ -96,7 +95,7 @@
 ;; (not required in Emacs 20 and higher):
 
 ;;   (autoload 'vhdl-mode "vhdl-mode" "VHDL Mode" t)
-;;   (setq auto-mode-alist (cons '("\\.vhdl?\\'" . vhdl-mode) auto-mode-alist))
+;;   (push '("\\.vhdl?\\'" . vhdl-mode) auto-mode-alist)
 
 ;; More detailed installation instructions are included in the official
 ;; VHDL Mode distribution.
@@ -130,6 +129,7 @@
 ;; Emacs 21+ handling
 (defconst vhdl-emacs-21 (and (<= 21 emacs-major-version) (not (featurep 'xemacs)))
   "Non-nil if GNU Emacs 21, 22, ... is used.")
+;; Emacs 22+ handling
 (defconst vhdl-emacs-22 (and (<= 22 emacs-major-version) (not (featurep 'xemacs)))
   "Non-nil if GNU Emacs 22, ... is used.")
 
@@ -210,22 +210,25 @@ Overrides local variable `indent-tabs-mode'."
 
 (defcustom vhdl-compiler-alist
   '(
+    ;;     60:       docal  <= false;
+    ;;               ^^^^^
+    ;; [Error] Assignment error: variable is illegal target of signal assignment
     ("ADVance MS" "vacom" "-work \\1" "make" "-f \\1"
      nil "valib \\1; vamap \\2 \\1" "./" "work/" "Makefile" "adms"
-     ("\\s-\\([0-9]+\\):" 0 1 0) ("Compiling file \\(.+\\)" 1)
+     ("^\\s-+\\([0-9]+\\):\\s-+" nil 1 nil) ("Compiling file \\(.+\\)" 1)
      ("ENTI/\\1.vif" "ARCH/\\1-\\2.vif" "CONF/\\1.vif"
       "PACK/\\1.vif" "BODY/\\1.vif" upcase))
     ;; Aldec
-    ;; COMP96 ERROR COMP96_0078: "Unknown identifier "Addr_Bits"." "<filename>" 40 30
-    ("Aldec" "vcom" "-93 -work \\1" "make" "-f \\1"
+    ;; COMP96 ERROR COMP96_0018: "Identifier expected." "test.vhd" 66 3
+    ("Aldec" "vcom" "-work \\1" "make" "-f \\1"
      nil "vlib \\1; vmap \\2 \\1" "./" "work/" "Makefile" "aldec"
-     (".+?[ \t]+\\(?:ERROR\\)[^:]+:.+?\\(?:.+\"\\(.+?\\)\"[ \t]+\\([0-9]+\\)\\)" 1 2 0) ("" 0)
+     (".* ERROR [^:]+: \".*\" \"\\([^ \\t\\n]+\\)\" \\([0-9]+\\) \\([0-9]+\\)" 1 2 3) ("" 0)
      nil)
     ;; Cadence Leapfrog: cv -file test.vhd
     ;; duluth: *E,430 (test.vhd,13): identifier (POSITIV) is not declared
     ("Cadence Leapfrog" "cv" "-work \\1 -file" "make" "-f \\1"
      nil "mkdir \\1" "./" "work/" "Makefile" "leapfrog"
-     ("duluth: \\*E,[0-9]+ (\\(.+\\),\\([0-9]+\\)):" 1 2 0) ("" 0)
+     ("duluth: \\*E,[0-9]+ (\\([^ \\t\\n]+\\),\\([0-9]+\\)):" 1 2 nil) ("" 0)
      ("\\1/entity" "\\2/\\1" "\\1/configuration"
       "\\1/package" "\\1/body" downcase))
     ;; Cadence Affirma NC vhdl: ncvhdl test.vhd
@@ -233,21 +236,27 @@ Overrides local variable `indent-tabs-mode'."
     ;; (PLL_400X_TOP) is not declared [10.3].
     ("Cadence NC" "ncvhdl" "-work \\1" "make" "-f \\1"
      nil "mkdir \\1" "./" "work/" "Makefile" "ncvhdl"
-     ("ncvhdl_p: \\*E,\\w+ (\\(.+\\),\\([0-9]+\\)|\\([0-9]+\\)):" 1 2 3) ("" 0)
+     ("ncvhdl_p: \\*E,\\w+ (\\([^ \\t\\n]+\\),\\([0-9]+\\)|\\([0-9]+\\)):" 1 2 3) ("" 0)
      ("\\1/entity/pc.db" "\\2/\\1/pc.db" "\\1/configuration/pc.db"
       "\\1/package/pc.db" "\\1/body/pc.db" downcase))
     ;; ghdl vhdl: ghdl test.vhd
     ("GHDL" "ghdl" "-i --workdir=\\1 --ieee=synopsys -fexplicit " "make" "-f \\1"
      nil "mkdir \\1" "./" "work/" "Makefile" "ghdl"
-     ("ghdl_p: \\*E,\\w+ (\\(.+\\),\\([0-9]+\\)|\\([0-9]+\\)):" 1 2 3) ("" 0)
+     ("ghdl_p: \\*E,\\w+ (\\([^ \\t\\n]+\\),\\([0-9]+\\)|\\([0-9]+\\)):" 1 2 3) ("" 0)
      ("\\1/entity" "\\2/\\1" "\\1/configuration"
       "\\1/package" "\\1/body" downcase))
+    ;; IBM Compiler
+    ;; 00 COACHDL* | [CCHDL-1]: File: adder.vhd, line.column: 120.6
+    ("IBM Compiler" "g2tvc" "-src" "precomp" "\\1"
+     nil "mkdir \\1" "./" "work/" "Makefile" "ibm"
+     ("[0-9]+ COACHDL.*: File: \\([^ \\t\\n]+\\), line.column: \\([0-9]+\\).\\([0-9]+\\)" 1 2 3) (" " 0)
+     nil)
     ;; Ikos Voyager: analyze test.vhd
     ;; analyze test.vhd
     ;; E L4/C5:        this library unit is inaccessible
     ("Ikos" "analyze" "-l \\1" "make" "-f \\1"
      nil "mkdir \\1" "./" "work/" "Makefile" "ikos"
-     ("E L\\([0-9]+\\)/C\\([0-9]+\\):" 0 1 2)
+     ("E L\\([0-9]+\\)/C\\([0-9]+\\):" nil 1 2)
      ("^analyze +\\(.+ +\\)*\\(.+\\)$" 2)
      nil)
     ;; ModelSim, Model Technology: vcom test.vhd
@@ -257,29 +266,39 @@ Overrides local variable `indent-tabs-mode'."
     ;; ** Error: adder.vhd(190): Unknown identifier: ctl_numb
     ("ModelSim" "vcom" "-93 -work \\1" "make" "-f \\1"
      nil "vlib \\1; vmap \\2 \\1" "./" "work/" "Makefile" "modelsim"
-     ("\\(ERROR\\|WARNING\\|\\*\\* Error\\|\\*\\* Warning\\)[^:]*:\\( *\[[0-9]+\]\\)? \\(.+\\)(\\([0-9]+\\)):" 3 4 0) ("" 0)
+     ("\\(ERROR\\|WARNING\\|\\*\\* Error\\|\\*\\* Warning\\)[^:]*:\\( *\[[0-9]+\]\\)? \\([^ \\t\\n]+\\)(\\([0-9]+\\)):" 3 4 nil) ("" 0)
      ("\\1/_primary.dat" "\\2/\\1.dat" "\\1/_primary.dat"
       "\\1/_primary.dat" "\\1/body.dat" downcase))
     ;; ProVHDL, Synopsys LEDA: provhdl -w work -f test.vhd
     ;; test.vhd:34: error message
     ("LEDA ProVHDL" "provhdl" "-w \\1 -f" "make" "-f \\1"
      nil "mkdir \\1" "./" "work/" "Makefile" "provhdl"
-     ("\\([^ \t\n]+\\):\\([0-9]+\\): " 1 2 0) ("" 0)
+     ("\\([^ \\t\\n]+\\):\\([0-9]+\\): " 1 2 nil) ("" 0)
      ("ENTI/\\1.vif" "ARCH/\\1-\\2.vif" "CONF/\\1.vif"
       "PACK/\\1.vif" "BODY/BODY-\\1.vif" upcase))
+    ;; Quartus compiler
+    ;; Error: VHDL error at dvi2sdi.vhd(473): object k2_alto_out_lvl is used
+    ;; Error: Verilog HDL syntax error at otsuif_v1_top.vhd(147) near text
+    ;; Error: VHDL syntax error at otsuif_v1_top.vhd(147): clk_ is an illegal
+    ;; Error: VHDL Use Clause error at otsuif_v1_top.vhd(455): design library
+    ;; Warning: VHDL Process Statement warning at dvi2sdi_tst.vhd(172): ...
+    ("Quartus" "make" "-work \\1" "make" "-f \\1"
+     nil "mkdir \\1" "./" "work/" "Makefile" "quartus"
+     ("\\(Error\\|Warning\\): .* \\([^ \\t\\n]+\\)(\\([0-9]+\\))" 2 3 nil) ("" 0)
+     nil)
     ;; QuickHDL, Mentor Graphics: qvhcom test.vhd
     ;; ERROR: test.vhd(24): near "dnd": expecting: END
     ;; WARNING[4]: test.vhd(30): A space is required between ...
     ("QuickHDL" "qvhcom" "-work \\1" "make" "-f \\1"
      nil "mkdir \\1" "./" "work/" "Makefile" "quickhdl"
-     ("\\(ERROR\\|WARNING\\)[^:]*: \\(.+\\)(\\([0-9]+\\)):" 2 3 0) ("" 0)
+     ("\\(ERROR\\|WARNING\\)[^:]*: \\([^ \\t\\n]+\\)(\\([0-9]+\\)):" 2 3 nil) ("" 0)
      ("\\1/_primary.dat" "\\2/\\1.dat" "\\1/_primary.dat"
       "\\1/_primary.dat" "\\1/body.dat" downcase))
     ;; Savant: scram -publish-cc test.vhd
     ;; test.vhd:87: _set_passed_through_out_port(IIR_Boolean) not defined for
     ("Savant" "scram" "-publish-cc -design-library-name \\1" "make" "-f \\1"
      nil "mkdir \\1" "./" "work._savant_lib/" "Makefile" "savant"
-     ("\\([^ \t\n]+\\):\\([0-9]+\\): " 1 2 0) ("" 0)
+     ("\\([^ \\t\\n]+\\):\\([0-9]+\\): " 1 2 nil) ("" 0)
      ("\\1_entity.vhdl" "\\2_secondary_units._savant_lib/\\2_\\1.vhdl"
       "\\1_config.vhdl" "\\1_package.vhdl"
       "\\1_secondary_units._savant_lib/\\1_package_body.vhdl" downcase))
@@ -287,39 +306,39 @@ Overrides local variable `indent-tabs-mode'."
     ;; Error: CSVHDL0002: test.vhd: (line 97): Invalid prefix
     ("Simili" "vhdlp" "-work \\1" "make" "-f \\1"
      nil "mkdir \\1" "./" "work/" "Makefile" "simili"
-     ("\\(Error\\|Warning\\): \\w+: \\(.+\\): (line \\([0-9]+\\)): " 2 3 0) ("" 0)
+     ("\\(Error\\|Warning\\): \\w+: \\([^ \\t\\n]+\\): (line \\([0-9]+\\)): " 2 3 nil) ("" 0)
      ("\\1/prim.var" "\\2/_\\1.var" "\\1/prim.var"
       "\\1/prim.var" "\\1/_body.var" downcase))
     ;; Speedwave (Innoveda): analyze -libfile vsslib.ini -src test.vhd
     ;;     ERROR[11]::File test.vhd Line 100: Use of undeclared identifier
     ("Speedwave" "analyze" "-libfile vsslib.ini -src" "make" "-f \\1"
      nil "mkdir \\1" "./" "work/" "Makefile" "speedwave"
-     ("^ *ERROR\[[0-9]+\]::File \\(.+\\) Line \\([0-9]+\\):" 1 2 0) ("" 0)
+     ("^ *ERROR\[[0-9]+\]::File \\([^ \\t\\n]+\\) Line \\([0-9]+\\):" 1 2 nil) ("" 0)
      nil)
     ;; Synopsys, VHDL Analyzer (sim): vhdlan -nc test.vhd
     ;; **Error: vhdlan,703 test.vhd(22): OTHERS is not legal in this context.
     ("Synopsys" "vhdlan" "-nc -work \\1" "make" "-f \\1"
      nil "mkdir \\1" "./" "work/" "Makefile" "synopsys"
-     ("\\*\\*Error: vhdlan,[0-9]+ \\(.+\\)(\\([0-9]+\\)):" 1 2 0) ("" 0)
+     ("\\*\\*Error: vhdlan,[0-9]+ \\([^ \\t\\n]+\\)(\\([0-9]+\\)):" 1 2 nil) ("" 0)
      ("\\1.sim" "\\2__\\1.sim" "\\1.sim" "\\1.sim" "\\1__.sim" upcase))
     ;; Synopsys, VHDL Analyzer (syn): vhdlan -nc -spc test.vhd
     ;; **Error: vhdlan,703 test.vhd(22): OTHERS is not legal in this context.
     ("Synopsys Design Compiler" "vhdlan" "-nc -spc -work \\1" "make" "-f \\1"
      nil "mkdir \\1" "./" "work/" "Makefile" "synopsys_dc"
-     ("\\*\\*Error: vhdlan,[0-9]+ \\(.+\\)(\\([0-9]+\\)):" 1 2 0) ("" 0)
+     ("\\*\\*Error: vhdlan,[0-9]+ \\([^ \\t\\n]+\\)(\\([0-9]+\\)):" 1 2 nil) ("" 0)
      ("\\1.syn" "\\2__\\1.syn" "\\1.syn" "\\1.syn" "\\1__.syn" upcase))
     ;; Synplify:
     ;; @W:"test.vhd":57:8:57:9|Optimizing register bit count_x(5) to a constant 0
     ("Synplify" "n/a" "n/a" "make" "-f \\1"
      nil "mkdir \\1" "./" "work/" "Makefile" "synplify"
-     ("@[EWN]:\"\\(.+\\)\":\\([0-9]+\\):\\([0-9]+\\):" 1 2 3) ("" 0)
+     ("@[EWN]:\"\\([^ \\t\\n]+\\)\":\\([0-9]+\\):\\([0-9]+\\):" 1 2 3) ("" 0)
      nil)
     ;; Vantage: analyze -libfile vsslib.ini -src test.vhd
     ;;     Compiling "test.vhd" line 1...
     ;; **Error: LINE 49 *** No aggregate value is valid in this context.
     ("Vantage" "analyze" "-libfile vsslib.ini -src" "make" "-f \\1"
      nil "mkdir \\1" "./" "work/" "Makefile" "vantage"
-     ("\\*\\*Error: LINE \\([0-9]+\\) \\*\\*\\*" 0 1 0)
+     ("\\*\\*Error: LINE \\([0-9]+\\) \\*\\*\\*" nil 1 nil)
      ("^ *Compiling \"\\(.+\\)\" " 1)
      nil)
     ;; VeriBest: vc vhdl test.vhd
@@ -329,21 +348,21 @@ Overrides local variable `indent-tabs-mode'."
     ;; [Error] Name BITA is unknown
     ("VeriBest" "vc" "vhdl" "make" "-f \\1"
      nil "mkdir \\1" "./" "work/" "Makefile" "veribest"
-     ("^ +\\([0-9]+\\): +[^ ]" 0 1 0) ("" 0)
+     ("^ +\\([0-9]+\\): +[^ ]" nil 1 nil) ("" 0)
      nil)
     ;; Viewlogic: analyze -libfile vsslib.ini -src test.vhd
     ;;     Compiling "test.vhd" line 1...
     ;; **Error: LINE 49 *** No aggregate value is valid in this context.
     ("Viewlogic" "analyze" "-libfile vsslib.ini -src" "make" "-f \\1"
      nil "mkdir \\1" "./" "work/" "Makefile" "viewlogic"
-     ("\\*\\*Error: LINE \\([0-9]+\\) \\*\\*\\*" 0 1 0)
+     ("\\*\\*Error: LINE \\([0-9]+\\) \\*\\*\\*" nil 1 nil)
      ("^ *Compiling \"\\(.+\\)\" " 1)
      nil)
     ;; Xilinx XST:
     ;; ERROR:HDLParsers:164 - "test.vhd" Line 3. parse error
     ("Xilinx XST" "xflow" "" "make" "-f \\1"
      nil "mkdir \\1" "./" "work/" "Makefile" "xilinx"
-     ("^ERROR:HDLParsers:[0-9]+ - \"\\(.+\\)\" Line \\([0-9]+\\)\." 1 2 0) ("" 0)
+     ("^ERROR:HDLParsers:[0-9]+ - \"\\([^ \\t\\n]+\\)\" Line \\([0-9]+\\)\." 1 2 nil) ("" 0)
      nil)
     )
   "List of available VHDL compilers and their properties.
@@ -429,9 +448,13 @@ NOTE: Activate new error and file message regexps and reflect the new setting
                 (string :tag "ID string          ")
                 (list :tag "Error message" :indent 4
                       (regexp  :tag "Regexp           ")
-                      (integer :tag "File subexp index")
+                      (choice  :tag "File subexp      "
+                              (integer :tag "Index")
+                              (const :tag "No file name" nil))
                       (integer :tag "Line subexp index")
-                      (integer :tag "Column subexp idx"))
+                      (choice  :tag "Column subexp    "
+                              (integer :tag "Index")
+                              (const :tag "No column number" nil)))
                 (list :tag "File message" :indent 4
                       (regexp  :tag "Regexp           ")
                       (integer :tag "File subexp index"))
@@ -450,6 +473,7 @@ NOTE: Activate new error and file message regexps and reflect the new setting
                                       (const :tag "Downcase" downcase))))))
   :set (lambda (variable value)
          (vhdl-custom-set variable value 'vhdl-update-mode-menu))
+  :version "24.4"
   :group 'vhdl-compile)
 
 (defcustom vhdl-compiler "GHDL"
@@ -457,7 +481,7 @@ NOTE: Activate new error and file message regexps and reflect the new setting
 Select a compiler name from the ones defined in option `vhdl-compiler-alist'."
   :type (let ((alist vhdl-compiler-alist) list)
           (while alist
-            (setq list (cons (list 'const (caar alist)) list))
+            (push (list 'const (caar alist)) list)
             (setq alist (cdr alist)))
           (append '(choice) (nreverse list)))
   :group 'vhdl-compile)
@@ -602,7 +626,7 @@ NOTE: Reflect the new setting in the choice list of option `vhdl-project'
                  (list :tag "Compiler" :indent 6
                        ,(let ((alist vhdl-compiler-alist) list)
                           (while alist
-                            (setq list (cons (list 'const (caar alist)) list))
+                            (push (list 'const (caar alist)) list)
                             (setq alist (cdr alist)))
                           (append '(choice :tag "Compiler name")
                                   (nreverse list)))
@@ -637,7 +661,7 @@ headers and the source files/directories to be scanned in the hierarchy
 browser.  The current project can also be changed temporarily in the menu."
   :type (let ((alist vhdl-project-alist) list)
           (while alist
-            (setq list (cons (list 'const (caar alist)) list))
+            (push (list 'const (caar alist)) list)
             (setq alist (cdr alist)))
           (append '(choice (const :tag "None" nil) (const :tag "--"))
                   (nreverse list)))
@@ -1268,6 +1292,18 @@ The comments and empty lines between groups of ports are pasted:
                  (const :tag "Always" always))
   :group 'vhdl-port)
 
+(defcustom vhdl-actual-generic-name '(".*" . "\\&")
+  (concat
+   "Specifies how actual generic names are obtained from formal generic names.
+In a component instantiation, an actual generic name can be
+obtained by modifying the formal generic name (e.g. attaching or stripping
+off a substring)."
+   vhdl-name-doc-string)
+  :type '(cons (regexp :tag "From regexp")
+               (string :tag "To string  "))
+  :group 'vhdl-port
+  :version "24.4")
+
 (defcustom vhdl-actual-port-name '(".*" . "\\&")
   (concat
    "Specifies how actual port names are obtained from formal port names.
@@ -1469,21 +1505,21 @@ NOTE: Activate the new setting in a VHDL buffer by using the menu entry
 (defvar end-comment-column)
 
 
-(defgroup vhdl-align nil
-  "Customizations for alignment."
+(defgroup vhdl-beautify nil
+  "Customizations for beautification."
   :group 'vhdl)
 
 (defcustom vhdl-auto-align t
   "Non-nil means align some templates automatically after generation."
   :type 'boolean
-  :group 'vhdl-align)
+  :group 'vhdl-beautify)
 
 (defcustom vhdl-align-groups t
   "Non-nil means align groups of code lines separately.
 A group of code lines is a region of consecutive lines between two lines that
 match the regexp in option `vhdl-align-group-separate'."
   :type 'boolean
-  :group 'vhdl-align)
+  :group 'vhdl-beautify)
 
 (defcustom vhdl-align-group-separate "^\\s-*$"
   "Regexp for matching a line that separates groups of lines for alignment.
@@ -1491,7 +1527,7 @@ Examples:
   \"^\\s-*$\":          matches an empty line
   \"^\\s-*\\(--.*\\)?$\": matches an empty line or a comment-only line"
   :type 'regexp
-  :group 'vhdl-align)
+  :group 'vhdl-beautify)
 
 (defcustom vhdl-align-same-indent t
   "Non-nil means align blocks with same indent separately.
@@ -1500,7 +1536,18 @@ blocks of same indent which are aligned separately (except for argument/port
 lists).  This gives nicer alignment in most cases.
 Option `vhdl-align-groups' still applies within these blocks."
   :type 'boolean
-  :group 'vhdl-align)
+  :group 'vhdl-beautify)
+
+(defcustom vhdl-beautify-options '(t t t t t)
+  "List of options for beautifying code.  Allows to disable individual
+features of code beautification."
+  :type '(list (boolean :tag "Whitespace cleanup       ")
+               (boolean :tag "Single statement per line")
+               (boolean :tag "Indentation              ")
+               (boolean :tag "Alignment                ")
+               (boolean :tag "Case fixing              "))
+  :group 'vhdl-beautify
+  :version "24.4")
 
 
 (defgroup vhdl-highlight nil
@@ -1846,7 +1893,7 @@ useful in large files where syntax-based indentation gets very slow."
   :group 'vhdl-misc)
 
 (defcustom vhdl-indent-comment-like-next-code-line t
-  "*Non-nil means comment lines are indented like the following code line.
+  "Non-nil means comment lines are indented like the following code line.
 Otherwise, comment lines are indented like the preceding code line.
 Indenting comment lines like the following code line gives nicer indentation
 when comments precede the code that they refer to."
@@ -1872,14 +1919,11 @@ NOTE: Activate the new setting by restarting Emacs."
   "Non-nil means consider the underscore character `_' as part of word.
 An identifier containing underscores is then treated as a single word in
 select and move operations.  All parts of an identifier separated by underscore
-are treated as single words otherwise.
-
-NOTE: Activate the new setting in a VHDL buffer by using the menu entry
-      \"Activate Options\"."
+are treated as single words otherwise."
   :type 'boolean
-  :set (lambda (variable value)
-         (vhdl-custom-set variable value 'vhdl-mode-syntax-table-init))
   :group 'vhdl-misc)
+(make-obsolete-variable 'vhdl-underscore-is-part-of-word
+                        'superword-mode "24.4")
 
 
 (defgroup vhdl-related nil
@@ -2070,7 +2114,7 @@ your style, only those that are different from the default.")
                             (lambda (var)
                               (cons var (symbol-value var))))
                            varlist))))
-      (setq vhdl-style-alist (cons default vhdl-style-alist))))
+      (push default vhdl-style-alist)))
 
 (defvar vhdl-mode-hook nil
   "Hook called by `vhdl-mode'.")
@@ -2087,10 +2131,11 @@ your style, only those that are different from the default.")
 (require 'hippie-exp)
 
 ;; optional (minimize warning messages during compile)
+(unless (featurep 'xemacs)
 (eval-when-compile
   (require 'font-lock)
   (require 'ps-print)
-  (require 'speedbar))
+    (require 'speedbar)))               ; for speedbar-with-writable
 
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
@@ -2190,6 +2235,17 @@ Ignore byte-compiler warnings you might see."
 (unless (fboundp 'member-ignore-case)
   (defalias 'member-ignore-case 'member))
 
+;; `last-input-char' obsolete in Emacs 24, `last-input-event' different
+;; behavior in XEmacs
+(defvar vhdl-last-input-event)
+(if (featurep 'xemacs)
+    (defvaralias 'vhdl-last-input-event 'last-input-char)
+  (defvaralias 'vhdl-last-input-event 'last-input-event))
+
+;; `help-print-return-message' changed to `print-help-return-message' in Emacs
+;;;(unless (fboundp 'help-print-return-message)
+;;;  (defalias 'help-print-return-message 'print-help-return-message))
+
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;; Compatibility with older VHDL Mode versions
 
@@ -2210,7 +2266,7 @@ Ignore byte-compiler warnings you might see."
       (vhdl-warning (apply 'format args) t)
     (unless vhdl-warnings
       (vhdl-run-when-idle .1 nil 'vhdl-print-warnings))
-    (setq vhdl-warnings (cons (apply 'format args) vhdl-warnings))))
+    (push (apply 'format args) vhdl-warnings)))
 
 (defun vhdl-warning (string &optional nobeep)
   "Print out warning STRING and beep."
@@ -2244,7 +2300,7 @@ Ignore byte-compiler warnings you might see."
   (let ((old-alist vhdl-model-alist)
         new-alist)
     (while old-alist
-      (setq new-alist (cons (append (car old-alist) '("")) new-alist))
+      (push (append (car old-alist) '("")) new-alist)
       (setq old-alist (cdr old-alist)))
     (setq vhdl-model-alist (nreverse new-alist)))
   (customize-save-variable 'vhdl-model-alist vhdl-model-alist))
@@ -2254,7 +2310,7 @@ Ignore byte-compiler warnings you might see."
   (let ((old-alist vhdl-project-alist)
         new-alist)
     (while old-alist
-      (setq new-alist (cons (append (car old-alist) '("")) new-alist))
+      (push (append (car old-alist) '("")) new-alist)
       (setq old-alist (cdr old-alist)))
     (setq vhdl-project-alist (nreverse new-alist)))
   (customize-save-variable 'vhdl-project-alist vhdl-project-alist))
@@ -2342,7 +2398,6 @@ Ignore byte-compiler warnings you might see."
   (unless (get 'speedbar-indentation-width 'saved-value)
     (setq speedbar-indentation-width 2)))
 
-
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;;; Help functions / inline substitutions / macros
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
@@ -2433,6 +2488,7 @@ old environment.  Used for consistent searching."
                        (progn (set-buffer (create-file-buffer ,file-name))
                               (setq file-opened t)
                               (vhdl-insert-file-contents ,file-name)
+                              ;; FIXME: This modifies a global syntax-table!
                               (modify-syntax-entry ?\- ". 12" (syntax-table))
                               (modify-syntax-entry ?\n ">" (syntax-table))
                               (modify-syntax-entry ?\^M ">" (syntax-table))
@@ -2489,7 +2545,7 @@ conversion."
 
 (defun vhdl-delete (elt list)
   "Delete by side effect the first occurrence of ELT as a member of LIST."
-  (setq list (cons nil list))
+  (push nil list)
   (let ((list1 list))
     (while (and (cdr list1) (not (equal elt (cadr list1))))
       (setq list1 (cdr list1)))
@@ -2497,6 +2553,9 @@ conversion."
       (setcdr list1 (cddr list1))))
   (cdr list))
 
+(declare-function speedbar-refresh "speedbar" (&optional arg))
+(declare-function speedbar-do-function-pointer "speedbar" ())
+
 (defun vhdl-speedbar-refresh (&optional key)
   "Refresh directory or project with name KEY."
   (when (and (boundp 'speedbar-frame)
@@ -2537,6 +2596,11 @@ conversion."
     (set-buffer (marker-buffer marker)))
   (goto-char marker))
 
+(defun vhdl-goto-line (line)
+  "Use this instead of calling user level function `goto-line'."
+  (goto-char (point-min))
+  (forward-line (1- line)))
+
 (defun vhdl-menu-split (list title)
   "Split menu LIST into several submenus, if number of
 elements > `vhdl-menu-max-size'."
@@ -2547,19 +2611,19 @@ elements > `vhdl-menu-max-size'."
             (menuno 1)
             (i 0))
         (while remain
-          (setq sublist (cons (car remain) sublist))
+          (push (car remain) sublist)
           (setq remain (cdr remain))
           (setq i (+ i 1))
           (if (= i vhdl-menu-max-size)
               (progn
-                (setq result (cons (cons (format "%s %s" title menuno)
-                                         (nreverse sublist)) result))
+                (push (cons (format "%s %s" title menuno)
+                            (nreverse sublist)) result)
                 (setq i 0)
                 (setq menuno (+ menuno 1))
                 (setq sublist '()))))
         (and sublist
-             (setq result (cons (cons (format "%s %s" title menuno)
-                                      (nreverse sublist)) result)))
+             (push (cons (format "%s %s" title menuno)
+                         (nreverse sublist)) result))
         (nreverse result))
     list))
 
@@ -2723,11 +2787,6 @@ STRING are replaced by `-' and substrings are converted to lower case."
     (define-key vhdl-mode-map "\M-\C-h"    'vhdl-mark-defun))
   (define-key vhdl-mode-map "\M-\C-q"      'vhdl-indent-sexp)
   (define-key vhdl-mode-map "\M-^"         'vhdl-delete-indentation)
-  ;; backspace/delete key bindings
-  (define-key vhdl-mode-map [backspace]    'backward-delete-char-untabify)
-  (unless (boundp 'delete-key-deletes-forward) ; XEmacs variable
-    (define-key vhdl-mode-map [delete]       'delete-char)
-    (define-key vhdl-mode-map [(meta delete)] 'kill-word))
   ;; mode specific key bindings
   (define-key vhdl-mode-map "\C-c\C-m\C-e" 'vhdl-electric-mode)
   (define-key vhdl-mode-map "\C-c\C-m\C-s" 'vhdl-stutter-mode)
@@ -2794,6 +2853,8 @@ STRING are replaced by `-' and substrings are converted to lower case."
   (define-key vhdl-mode-map "\C-c\C-l\C-o" 'vhdl-line-open)
   (define-key vhdl-mode-map "\C-c\C-l\C-g" 'goto-line)
   (define-key vhdl-mode-map "\C-c\C-l\C-c" 'vhdl-comment-uncomment-line)
+  (define-key vhdl-mode-map "\C-c\C-x\C-s" 'vhdl-fix-statement-region)
+  (define-key vhdl-mode-map "\C-c\C-x\M-s" 'vhdl-fix-statement-buffer)
   (define-key vhdl-mode-map "\C-c\C-x\C-p" 'vhdl-fix-clause)
   (define-key vhdl-mode-map "\C-c\C-x\M-c" 'vhdl-fix-case-region)
   (define-key vhdl-mode-map "\C-c\C-x\C-c" 'vhdl-fix-case-buffer)
@@ -2864,56 +2925,51 @@ STRING are replaced by `-' and substrings are converted to lower case."
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;; Syntax table
 
-(defvar vhdl-mode-syntax-table nil
+(defvar vhdl-mode-syntax-table
+  (let ((st (make-syntax-table)))
+    ;; define punctuation
+    (modify-syntax-entry ?\# "."    st)
+    (modify-syntax-entry ?\$ "."    st)
+    (modify-syntax-entry ?\% "."    st)
+    (modify-syntax-entry ?\& "."    st)
+    (modify-syntax-entry ?\' "."    st)
+    (modify-syntax-entry ?\* "."    st)
+    (modify-syntax-entry ?\+ "."    st)
+    (modify-syntax-entry ?\. "."    st)
+    (modify-syntax-entry ?\/ "."    st)
+    (modify-syntax-entry ?\: "."    st)
+    (modify-syntax-entry ?\; "."    st)
+    (modify-syntax-entry ?\< "."    st)
+    (modify-syntax-entry ?\= "."    st)
+    (modify-syntax-entry ?\> "."    st)
+    (modify-syntax-entry ?\\ "."    st)
+    (modify-syntax-entry ?\| "."    st)
+    ;; define string
+    (modify-syntax-entry ?\" "\""   st)
+    ;; define underscore
+    (modify-syntax-entry ?\_ (if vhdl-underscore-is-part-of-word "w" "_") st)
+    ;; a single hyphen is punctuation, but a double hyphen starts a comment
+    (modify-syntax-entry ?\- ". 12" st)
+    ;; and \n and \^M end a comment
+    (modify-syntax-entry ?\n ">"    st)
+    (modify-syntax-entry ?\^M ">"   st)
+    ;; define parentheses to match
+    (modify-syntax-entry ?\( "()"   st)
+    (modify-syntax-entry ?\) ")("   st)
+    (modify-syntax-entry ?\[ "(]"   st)
+    (modify-syntax-entry ?\] ")["   st)
+    (modify-syntax-entry ?\{ "(}"   st)
+    (modify-syntax-entry ?\} "){"   st)
+    st)
   "Syntax table used in `vhdl-mode' buffers.")
 
-(defvar vhdl-mode-ext-syntax-table nil
+(defvar vhdl-mode-ext-syntax-table
+  ;; Extended syntax table including '_' (for simpler search regexps).
+  (let ((st (copy-syntax-table vhdl-mode-syntax-table)))
+    (modify-syntax-entry ?_ "w" st)
+    st)
   "Syntax table extended by `_' used in `vhdl-mode' buffers.")
 
-(defun vhdl-mode-syntax-table-init ()
-  "Initialize `vhdl-mode-syntax-table'."
-  (setq vhdl-mode-syntax-table (make-syntax-table))
-  ;; define punctuation
-  (modify-syntax-entry ?\# "."    vhdl-mode-syntax-table)
-  (modify-syntax-entry ?\$ "."    vhdl-mode-syntax-table)
-  (modify-syntax-entry ?\% "."    vhdl-mode-syntax-table)
-  (modify-syntax-entry ?\& "."    vhdl-mode-syntax-table)
-  (modify-syntax-entry ?\' "."    vhdl-mode-syntax-table)
-  (modify-syntax-entry ?\* "."    vhdl-mode-syntax-table)
-  (modify-syntax-entry ?\+ "."    vhdl-mode-syntax-table)
-  (modify-syntax-entry ?\. "."    vhdl-mode-syntax-table)
-  (modify-syntax-entry ?\/ "."    vhdl-mode-syntax-table)
-  (modify-syntax-entry ?\: "."    vhdl-mode-syntax-table)
-  (modify-syntax-entry ?\; "."    vhdl-mode-syntax-table)
-  (modify-syntax-entry ?\< "."    vhdl-mode-syntax-table)
-  (modify-syntax-entry ?\= "."    vhdl-mode-syntax-table)
-  (modify-syntax-entry ?\> "."    vhdl-mode-syntax-table)
-  (modify-syntax-entry ?\\ "."    vhdl-mode-syntax-table)
-  (modify-syntax-entry ?\| "."    vhdl-mode-syntax-table)
-  ;; define string
-  (modify-syntax-entry ?\" "\""   vhdl-mode-syntax-table)
-  ;; define underscore
-  (when vhdl-underscore-is-part-of-word
-    (modify-syntax-entry ?\_ "w"   vhdl-mode-syntax-table))
-  ;; a single hyphen is punctuation, but a double hyphen starts a comment
-  (modify-syntax-entry ?\- ". 12" vhdl-mode-syntax-table)
-  ;; and \n and \^M end a comment
-  (modify-syntax-entry ?\n ">"    vhdl-mode-syntax-table)
-  (modify-syntax-entry ?\^M ">"   vhdl-mode-syntax-table)
-  ;; define parentheses to match
-  (modify-syntax-entry ?\( "()"   vhdl-mode-syntax-table)
-  (modify-syntax-entry ?\) ")("   vhdl-mode-syntax-table)
-  (modify-syntax-entry ?\[ "(]"   vhdl-mode-syntax-table)
-  (modify-syntax-entry ?\] ")["   vhdl-mode-syntax-table)
-  (modify-syntax-entry ?\{ "(}"   vhdl-mode-syntax-table)
-  (modify-syntax-entry ?\} "){"   vhdl-mode-syntax-table)
-  ;; extended syntax table including '_' (for simpler search regexps)
-  (setq vhdl-mode-ext-syntax-table (copy-syntax-table vhdl-mode-syntax-table))
-  (modify-syntax-entry ?_ "w" vhdl-mode-ext-syntax-table))
-
-;; initialize syntax table for VHDL Mode
-(vhdl-mode-syntax-table-init)
-
 (defvar vhdl-syntactic-context nil
   "Buffer local variable containing syntactic analysis list.")
 (make-variable-buffer-local 'vhdl-syntactic-context)
@@ -3506,6 +3562,9 @@ STRING are replaced by `-' and substrings are converted to lower case."
      ["Whitespace Region"       vhdl-fixup-whitespace-region (mark)]
      ["Whitespace Buffer"       vhdl-fixup-whitespace-buffer t]
      "--"
+     ["Statement Region"        vhdl-fix-statement-region (mark)]
+     ["Statement Buffer"        vhdl-fix-statement-buffer t]
+     "--"
      ["Trailing Spaces Buffer"  vhdl-remove-trailing-spaces t])
     ("Update"
      ["Sensitivity List"        vhdl-update-sensitivity-list-process t]
@@ -3814,6 +3873,7 @@ STRING are replaced by `-' and substrings are converted to lower case."
        ["Always"
         (customize-set-variable 'vhdl-include-group-comments 'always)
         :style radio :selected (eq 'always vhdl-include-group-comments)])
+      ["Actual Generic Name..." (customize-option 'vhdl-actual-generic-name) t]
       ["Actual Port Name..." (customize-option 'vhdl-actual-port-name) t]
       ["Instance Name..." (customize-option 'vhdl-instance-name) t]
       ("Testbench"
@@ -3910,7 +3970,7 @@ STRING are replaced by `-' and substrings are converted to lower case."
       ["End Comment Column..." (customize-option 'vhdl-end-comment-column) t]
       "--"
       ["Customize Group..." (customize-group 'vhdl-comment) t])
-     ("Align"
+     ("Beautify"
       ["Auto Align Templates"
        (customize-set-variable 'vhdl-auto-align (not vhdl-auto-align))
        :style toggle :selected vhdl-auto-align]
@@ -3918,13 +3978,14 @@ STRING are replaced by `-' and substrings are converted to lower case."
        (customize-set-variable 'vhdl-align-groups (not vhdl-align-groups))
        :style toggle :selected vhdl-align-groups]
       ["Group Separation String..."
-       (customize-set-variable 'vhdl-align-group-separate) t]
+       (customize-option 'vhdl-align-group-separate) t]
       ["Align Lines with Same Indent"
        (customize-set-variable 'vhdl-align-same-indent
                                (not vhdl-align-same-indent))
        :style toggle :selected vhdl-align-same-indent]
+      ["Beautify Options..." (customize-option 'vhdl-beautify-options) t]
       "--"
-      ["Customize Group..." (customize-group 'vhdl-align) t])
+      ["Customize Group..." (customize-group 'vhdl-beautify) t])
      ("Highlight"
       ["Highlighting On/Off..."
        (customize-option
@@ -4188,14 +4249,13 @@ The directory of the current source file is scanned."
     (setq found nil)
     (while file-list
       (setq found t)
-      (setq menu-list (cons (vector (car file-list)
-                                   (list 'find-file (car file-list)) t)
-                           menu-list))
+      (push (vector (car file-list) (list 'find-file (car file-list)) t)
+            menu-list)
       (setq file-list (cdr file-list)))
     (setq menu-list (vhdl-menu-split menu-list "Sources"))
-    (when found (setq menu-list (cons "--" menu-list)))
-    (setq menu-list (cons ["*Rescan*" vhdl-add-source-files-menu t] menu-list))
-    (setq menu-list (cons "Sources" menu-list))
+    (when found (push "--" menu-list))
+    (push ["*Rescan*" vhdl-add-source-files-menu t] menu-list)
+    (push "Sources" menu-list)
     ;; Create menu
     (easy-menu-add menu-list)
     (easy-menu-define vhdl-sources-menu newmap
@@ -4579,7 +4639,7 @@ Usage:
     option `vhdl-index-menu' to non-nil) or made accessible as a mouse menu
     (e.g. add \"(global-set-key '[S-down-mouse-3] 'imenu)\" to your start-up
     file) for browsing the file contents (is not populated if buffer is
-    larger than `font-lock-maximum-size').  Also, a source file menu can be
+    larger than 256000).  Also, a source file menu can be
     added (set option `vhdl-source-file-menu' to non-nil) for browsing the
     current directory for VHDL source files.
 
@@ -4706,7 +4766,7 @@ Usage:
     automatically recognized as VHDL source files.  To add an extension
     \".xxx\", add the following line to your Emacs start-up file (`.emacs'):
 
-      \(setq auto-mode-alist (cons '(\"\\\\.xxx\\\\'\" . vhdl-mode) auto-mode-alist))
+      \(push '(\"\\\\.xxx\\\\'\" . vhdl-mode) auto-mode-alist)
 
 
   HINTS:
@@ -7277,7 +7337,7 @@ indentation change."
                       (beginning-of-line 2)
                       (setq syntax (vhdl-get-syntactic-context)))))
                 (when is-comment
-                  (setq syntax (cons (cons 'comment nil) syntax)))
+                  (push (cons 'comment nil) syntax))
                 (apply '+ (mapcar 'vhdl-get-offset syntax)))
             ;; indent like previous nonblank line
             (save-excursion (beginning-of-line)
@@ -7388,7 +7448,7 @@ ENDPOS is encountered."
 
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-;;; Alignment, whitespace fixup, beautifying
+;;; Alignment, beautifying
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
 (defconst vhdl-align-alist
@@ -7604,7 +7664,8 @@ the token in MATCH."
         (when vhdl-progress-interval
           (setq vhdl-progress-info (vector (count-lines (point-min) beg)
                                            (count-lines (point-min) end) 0))))
-      (vhdl-fixup-whitespace-region beg end t)
+      (when (nth 0 vhdl-beautify-options)
+        (vhdl-fixup-whitespace-region beg end t))
       (goto-char beg)
       (if (not vhdl-align-groups)
           ;; align entire region
@@ -7728,14 +7789,14 @@ the token in MATCH."
        ;; search for comment start positions and lengths
        (while (< (point) end)
          (when (and (not (looking-at "^\\s-*\\(begin\\|end\\)\\>"))
-                    (looking-at "^\\(.*[^ \t\n\r\f-]+\\)\\s-*\\(--.*\\)$")
+                    (looking-at "^\\(.*?[^ \t\n\r\f-]+\\)\\s-*\\(--.*\\)$")
                     (not (save-excursion (goto-char (match-beginning 2))
                                          (vhdl-in-literal))))
            (setq start (+ (- (match-end 1) (match-beginning 1)) spacing))
            (setq length (- (match-end 2) (match-beginning 2)))
            (setq start-max (max start start-max))
            (setq length-max (max length length-max))
-           (setq comment-list (cons (cons start length) comment-list)))
+           (push (cons start length) comment-list))
          (beginning-of-line 2))
        (setq comment-list
              (sort comment-list (function (lambda (a b) (> (car a) (car b))))))
@@ -7746,14 +7807,14 @@ the token in MATCH."
          (unless (or (= (caar comment-list) (car start-list))
                      (<= (+ (car start-list) (cdar comment-list))
                             end-comment-column))
-           (setq start-list (cons (caar comment-list) start-list)))
+           (push (caar comment-list) start-list))
          (setq comment-list (cdr comment-list)))
        ;; align lines as nicely as possible
        (goto-char beg)
        (while (< (point) end)
          (setq cur-start nil)
          (when (and (not (looking-at "^\\s-*\\(begin\\|end\\)\\>"))
-                    (or (and (looking-at "^\\(.*[^ \t\n\r\f-]+\\)\\(\\s-*\\)\\(--.*\\)$")
+                    (or (and (looking-at "^\\(.*?[^ \t\n\r\f-]+\\)\\(\\s-*\\)\\(--.*\\)$")
                              (not (save-excursion
                                     (goto-char (match-beginning 3))
                                     (vhdl-in-literal))))
@@ -7879,7 +7940,7 @@ end of line, do nothing in comments and strings."
         (replace-match "\\2")))
     ;; surround operator symbols by one space
     (goto-char beg)
-    (while (re-search-forward "\\(--.*\n\\|\"[^\"\n]*[\"\n]\\|\'.\'\\|\\\\[^\\\n]*[\\\n]\\)\\|\\(\\([^/:<>=]\\)\\(:\\|\\??=\\|\\??<<\\|\\??>>\\|\\??<\\|\\??>\\|:=\\|\\??<=\\|\\??>=\\|=>\\|\\??/=\\|\\?\\?\\)\\([^=>]\\|$\\)\\)" end t)
+    (while (re-search-forward "\\(--.*\n\\|\"[^\"\n]*[\"\n]\\|\'.\'\\|\\\\[^\\\n]*[\\\n]\\)\\|\\(\\([^/:<>=\n]\\)\\(:\\|\\??=\\|\\??<<\\|\\??>>\\|\\??<\\|\\??>\\|:=\\|\\??<=\\|\\??>=\\|=>\\|\\??/=\\|\\?\\?\\)\\([^=>\n]\\|$\\)\\)" end t)
       (if (or (match-string 1)
               (<= (match-beginning 0)  ; not if at boi
                  (save-excursion (back-to-indentation) (point))))
@@ -7913,6 +7974,154 @@ end of line, do nothing in comments."
   (vhdl-fixup-whitespace-region (point-min) (point-max)))
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Case fixing
+
+(defun vhdl-fix-case-region-1 (beg end upper-case word-regexp &optional count)
+  "Convert all words matching WORD-REGEXP in region to lower or upper case,
+depending on parameter UPPER-CASE."
+  (let ((case-replace nil)
+        (last-update 0))
+    (vhdl-prepare-search-2
+     (save-excursion
+       (goto-char end)
+       (setq end (point-marker))
+       (goto-char beg)
+       (while (re-search-forward word-regexp end t)
+         (or (vhdl-in-literal)
+             (if upper-case
+                 (upcase-word -1)
+               (downcase-word -1)))
+         (when (and count vhdl-progress-interval (not noninteractive)
+                    (< vhdl-progress-interval
+                       (- (nth 1 (current-time)) last-update)))
+           (message "Fixing case... (%2d%s)"
+                    (+ (* count 20) (/ (* 20 (- (point) beg)) (- end beg)))
+                    "%")
+           (setq last-update (nth 1 (current-time)))))
+       (goto-char end)))))
+
+(defun vhdl-fix-case-region (beg end &optional arg)
+  "Convert all VHDL words in region to lower or upper case, depending on
+options vhdl-upper-case-{keywords,types,attributes,enum-values}."
+  (interactive "r\nP")
+  (vhdl-fix-case-region-1
+   beg end vhdl-upper-case-keywords vhdl-keywords-regexp 0)
+  (vhdl-fix-case-region-1
+   beg end vhdl-upper-case-types vhdl-types-regexp 1)
+  (vhdl-fix-case-region-1
+   beg end vhdl-upper-case-attributes (concat "'" vhdl-attributes-regexp) 2)
+  (vhdl-fix-case-region-1
+   beg end vhdl-upper-case-enum-values vhdl-enum-values-regexp 3)
+  (vhdl-fix-case-region-1
+   beg end vhdl-upper-case-constants vhdl-constants-regexp 4)
+  (when vhdl-progress-interval (message "Fixing case...done")))
+
+(defun vhdl-fix-case-buffer ()
+  "Convert all VHDL words in buffer to lower or upper case, depending on
+options vhdl-upper-case-{keywords,types,attributes,enum-values}."
+  (interactive)
+  (vhdl-fix-case-region (point-min) (point-max)))
+
+(defun vhdl-fix-case-word (&optional arg)
+  "Convert word after cursor to upper case if necessary."
+  (interactive "p")
+  (save-excursion
+    (when arg (backward-word 1))
+    (vhdl-prepare-search-1
+     (when (and vhdl-upper-case-keywords
+                (looking-at vhdl-keywords-regexp))
+       (upcase-word 1))
+     (when (and vhdl-upper-case-types
+                (looking-at vhdl-types-regexp))
+       (upcase-word 1))
+     (when (and vhdl-upper-case-attributes
+                (looking-at vhdl-attributes-regexp))
+       (upcase-word 1))
+     (when (and vhdl-upper-case-enum-values
+                (looking-at vhdl-enum-values-regexp))
+       (upcase-word 1))
+     (when (and vhdl-upper-case-constants
+                (looking-at vhdl-constants-regexp))
+       (upcase-word 1)))))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Fix statements
+;; - force each statement to be on a separate line except when on same line
+;;   with 'end' keyword
+
+(defun vhdl-fix-statement-region (beg end &optional arg)
+  "Force statements in region on separate line except when on same line
+with 'end' keyword (necessary for correct indentation).
+Currently supported keywords: 'begin', 'if'."
+  (interactive "r\nP")
+  (vhdl-prepare-search-2
+   (let (point)
+     (save-excursion
+       (goto-char end)
+       (setq end (point-marker))
+       (goto-char beg)
+       ;; `begin' keyword
+       (while (re-search-forward
+               "^\\s-*[^ \t\n].*?\\(\\<begin\\>\\)\\(.*\\<end\\>\\)?" end t)
+         (goto-char (match-end 0))
+         (setq point (point-marker))
+         (when (and (match-string 1)
+                    (or (not (match-string 2))
+                        (save-excursion (goto-char (match-end 2))
+                                        (vhdl-in-literal)))
+                    (not (save-excursion (goto-char (match-beginning 1))
+                                         (vhdl-in-literal))))
+           (goto-char (match-beginning 1))
+           (insert "\n")
+           (indent-according-to-mode))
+         (goto-char point))
+       (goto-char beg)
+       ;; `for', `if' keywords
+       (while (re-search-forward "\\<\\(for\\|if\\)\\>" end t)
+         (goto-char (match-end 1))
+         (setq point (point-marker))
+         ;; exception: in literal or preceded by `end' or label
+         (when (and (not (save-excursion (goto-char (match-beginning 1))
+                                         (vhdl-in-literal)))
+                    (save-excursion
+                      (beginning-of-line 1)
+                      (save-match-data
+                        (and (re-search-forward "^\\s-*\\([^ \t\n].*\\)"
+                                                (match-beginning 1) t)
+                             (not (string-match
+                                   "\\(\\<end\\>\\|\\<wait\\>\\|\\w+\\s-*:\\)\\s-*$"
+                                   (match-string 1)))))))
+           (goto-char (match-beginning 1))
+           (insert "\n")
+           (indent-according-to-mode))
+         (goto-char point))))))
+
+(defun vhdl-fix-statement-buffer ()
+  "Force statements in buffer on separate line except when on same line
+with 'end' keyword (necessary for correct indentation)."
+  (interactive)
+  (vhdl-fix-statement-region (point-min) (point-max)))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Trailing spaces
+
+(defun vhdl-remove-trailing-spaces-region (beg end &optional arg)
+  "Remove trailing spaces in region."
+  (interactive "r\nP")
+  (save-excursion
+    (goto-char end)
+    (setq end (point-marker))
+    (goto-char beg)
+    (while (re-search-forward "[ \t]+$" end t)
+      (unless (vhdl-in-literal)
+        (replace-match "" nil nil)))))
+
+(defun vhdl-remove-trailing-spaces ()
+  "Remove trailing spaces in buffer."
+  (interactive)
+  (vhdl-remove-trailing-spaces-region (point-min) (point-max)))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;; Beautify
 
 (defun vhdl-beautify-region (beg end)
@@ -7922,10 +8131,17 @@ case fixing to a region.  Calls functions `vhdl-indent-buffer',
 `vhdl-fix-case-buffer'."
   (interactive "r")
   (setq end (save-excursion (goto-char end) (point-marker)))
-  (vhdl-indent-region beg end)
+  (save-excursion ; remove DOS EOL characters in UNIX file
+    (goto-char beg)
+    (while (search-forward "
" nil t)
+      (replace-match "" nil t)))
+  (when (nth 0 vhdl-beautify-options) (vhdl-fixup-whitespace-region beg end t))
+  (when (nth 1 vhdl-beautify-options) (vhdl-fix-statement-region beg end))
+  (when (nth 2 vhdl-beautify-options) (vhdl-indent-region beg end))
   (let ((vhdl-align-groups t))
-    (vhdl-align-region beg end))
-  (vhdl-fix-case-region beg end))
+    (when (nth 3 vhdl-beautify-options) (vhdl-align-region beg end)))
+  (when (nth 4 vhdl-beautify-options) (vhdl-fix-case-region beg end))
+  (when (nth 0 vhdl-beautify-options) (vhdl-remove-trailing-spaces-region beg end)))
 
 (defun vhdl-beautify-buffer ()
   "Beautify buffer by applying indentation, whitespace fixup, alignment, and
@@ -8021,7 +8237,8 @@ buffer."
      (while (re-search-forward "^\\s-*\\(\\w+[ \t\n\r\f]*:[ \t\n\r\f]*\\)?process\\>" nil t)
        (goto-char (match-beginning 0))
        (condition-case nil (vhdl-update-sensitivity-list) (error "")))
-     (message "Updating sensitivity lists...done"))))
+     (message "Updating sensitivity lists...done")))
+  (when noninteractive (save-buffer)))
 
 (defun vhdl-update-sensitivity-list ()
   "Update sensitivity list."
@@ -8047,57 +8264,57 @@ buffer."
              (scan-regions-list
               '(;; right-hand side of signal/variable assignment
                 ;; (special case: "<=" is relational operator in a condition)
-                ((re-search-forward "[<:]=" proc-end t)
-                 (re-search-forward ";\\|\\<\\(then\\|loop\\|report\\|severity\\|is\\)\\>" proc-end t))
+                ((vhdl-re-search-forward "[<:]=" proc-end t)
+                 (vhdl-re-search-forward ";\\|\\<\\(then\\|loop\\|report\\|severity\\|is\\)\\>" proc-end t))
                 ;; if condition
-                ((re-search-forward "^\\s-*if\\>" proc-end t)
-                 (re-search-forward "\\<then\\>" proc-end t))
+                ((vhdl-re-search-forward "^\\s-*if\\>" proc-end t)
+                 (vhdl-re-search-forward "\\<then\\>" proc-end t))
                 ;; elsif condition
-                ((re-search-forward "\\<elsif\\>" proc-end t)
-                 (re-search-forward "\\<then\\>" proc-end t))
+                ((vhdl-re-search-forward "\\<elsif\\>" proc-end t)
+                 (vhdl-re-search-forward "\\<then\\>" proc-end t))
                 ;; while loop condition
-                ((re-search-forward "^\\s-*while\\>" proc-end t)
-                 (re-search-forward "\\<loop\\>" proc-end t))
+                ((vhdl-re-search-forward "^\\s-*while\\>" proc-end t)
+                 (vhdl-re-search-forward "\\<loop\\>" proc-end t))
                 ;; exit/next condition
-                ((re-search-forward "\\<\\(exit\\|next\\)\\s-+\\w+\\s-+when\\>" proc-end t)
-                 (re-search-forward ";" proc-end t))
+                ((vhdl-re-search-forward "\\<\\(exit\\|next\\)\\s-+\\w+\\s-+when\\>" proc-end t)
+                 (vhdl-re-search-forward ";" proc-end t))
                 ;; assert condition
-                ((re-search-forward "\\<assert\\>" proc-end t)
-                 (re-search-forward "\\(\\<report\\>\\|\\<severity\\>\\|;\\)" proc-end t))
+                ((vhdl-re-search-forward "\\<assert\\>" proc-end t)
+                 (vhdl-re-search-forward "\\(\\<report\\>\\|\\<severity\\>\\|;\\)" proc-end t))
                 ;; case expression
-                ((re-search-forward "^\\s-*case\\>" proc-end t)
-                 (re-search-forward "\\<is\\>" proc-end t))
+                ((vhdl-re-search-forward "^\\s-*case\\>" proc-end t)
+                 (vhdl-re-search-forward "\\<is\\>" proc-end t))
                 ;; parameter list of procedure call, array index
                 ((and (re-search-forward "^\\s-*\\(\\w\\|\\.\\)+[ \t\n\r\f]*(" proc-end t)
                       (1- (point)))
                  (progn (backward-char) (forward-sexp)
                         (while (looking-at "(") (forward-sexp)) (point)))))
-             name field read-list sens-list signal-list
+             name field read-list sens-list signal-list tmp-list
              sens-beg sens-end beg end margin)
           ;; scan for signals in old sensitivity list
           (goto-char proc-beg)
-          (re-search-forward "\\<process\\>" proc-mid t)
+          (vhdl-re-search-forward "\\<process\\>" proc-mid t)
           (if (not (looking-at "[ \t\n\r\f]*("))
               (setq sens-beg (point))
-            (setq sens-beg (re-search-forward "\\([ \t\n\r\f]*\\)([ \t\n\r\f]*" nil t))
+            (setq sens-beg (vhdl-re-search-forward "\\([ \t\n\r\f]*\\)([ \t\n\r\f]*" nil t))
             (goto-char (match-end 1))
             (forward-sexp)
             (setq sens-end (1- (point)))
             (goto-char sens-beg)
-            (while (and (re-search-forward "\\(\\w+\\)" sens-end t)
+            (while (and (vhdl-re-search-forward "\\(\\w+\\)" sens-end t)
                         (setq sens-list
                               (cons (downcase (match-string 0)) sens-list))
-                        (re-search-forward "\\s-*,\\s-*" sens-end t))))
+                        (vhdl-re-search-forward "\\s-*,\\s-*" sens-end t))))
           (setq signal-list (append visible-list sens-list))
           ;; search for sequential parts
           (goto-char proc-mid)
           (while (setq beg (re-search-forward "^\\s-*\\(els\\)?if\\>" proc-end t))
-            (setq end (re-search-forward "\\<then\\>" proc-end t))
-            (when (re-search-backward "\\('event\\|\\<\\(falling\\|rising\\)_edge\\)\\>" beg t)
+            (setq end (vhdl-re-search-forward "\\<then\\>" proc-end t))
+            (when (vhdl-re-search-backward "\\('event\\|\\<\\(falling\\|rising\\)_edge\\)\\>" beg t)
               (goto-char end)
               (backward-word 1)
               (vhdl-forward-sexp)
-              (setq seq-region-list (cons (cons end (point)) seq-region-list))
+              (push (cons end (point)) seq-region-list)
               (beginning-of-line)))
           ;; scan for signals read in process
           (while scan-regions-list
@@ -8114,15 +8331,35 @@ buffer."
                                  (and tmp-list (< (point) (cdar tmp-list))))))
                 (while (vhdl-re-search-forward "[^'\".]\\<\\([a-zA-Z]\\w*\\)\\(\\(\\.\\w+\\|[ \t\n\r\f]*([^)]*)\\)*\\)[ \t\n\r\f]*\\('\\(\\w+\\)\\|\\(=>\\)\\)?" end t)
                   (setq name (match-string 1))
+                  ;; get array index range
                   (when vhdl-array-index-record-field-in-sensitivity-list
-                    (setq field (match-string 2)))
+                    (setq field (match-string 2))
+                    ;; not use if it includes a variable name
+                    (save-match-data
+                      (setq tmp-list visible-list)
+                      (while (and field tmp-list)
+                        (when (string-match
+                               (concat "\\<" (car tmp-list) "\\>") field)
+                          (setq field nil))
+                        (setq tmp-list (cdr tmp-list)))))
                   (when (and (not (match-string 6)) ; not when formal parameter
                              (not (and (match-string 5) ; not event attribute
                                        (not (member (downcase (match-string 5))
                                                     '("event" "last_event" "transaction")))))
                              (member (downcase name) signal-list))
-                    (unless (member-ignore-case (concat name field) read-list)
-                      (setq read-list (cons (concat name field) read-list))))
+                    ;; not add if name or name+field already exists
+                    (unless
+                        (or (member-ignore-case name read-list)
+                            (member-ignore-case (concat name field) read-list))
+                      (push (concat name field) read-list))
+                    (setq tmp-list read-list)
+                    ;; remove existing name+field if name is added
+                    (save-match-data
+                      (while tmp-list
+                        (when (string-match (concat "^" name field "[(.]")
+                                            (car tmp-list))
+                          (setq read-list (delete (car tmp-list) read-list)))
+                        (setq tmp-list (cdr tmp-list)))))
                   (goto-char (match-end 1)))))
             (setq scan-regions-list (cdr scan-regions-list)))
           ;; update sensitivity list
@@ -8178,7 +8415,7 @@ buffer."
              (while (< (point) end)
                (when (looking-at "signal[ \t\n\r\f]+")
                  (goto-char (match-end 0)))
-               (while (looking-at "\\(\\w+\\)[ \t\n\r\f,]+")
+               (while (looking-at "\\([a-zA-Z]\\w*\\)[ \t\n\r\f,]+")
                  (setq signal-list
                        (cons (downcase (match-string 1)) signal-list))
                  (goto-char (match-end 0))
@@ -8197,12 +8434,12 @@ buffer."
            (when (= 0 (nth 0 (parse-partial-sexp beg (point))))
              (if (match-string 2)
                  ;; scan signal name
-                 (while (looking-at "[ \t\n\r\f,]+\\(\\w+\\)")
+                 (while (looking-at "[ \t\n\r\f,]+\\([a-zA-Z]\\w*\\)")
                    (setq signal-list
                          (cons (downcase (match-string 1)) signal-list))
                    (goto-char (match-end 0)))
                ;; scan alias name, check is alias of (declared) signal
-               (when (and (looking-at "[ \t\n\r\f]+\\(\\w+\\)[^;]*\\<is[ \t\n\r\f]+\\(\\w+\\)")
+               (when (and (looking-at "[ \t\n\r\f]+\\([a-zA-Z]\\w*\\)[^;]*\\<is[ \t\n\r\f]+\\([a-zA-Z]\\w*\\)")
                           (member (downcase (match-string 2)) signal-list))
                  (setq signal-list
                        (cons (downcase (match-string 1)) signal-list))
@@ -8290,19 +8527,6 @@ buffer."
            (goto-char end)
            (insert ")")))))))
 
-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-;; Miscellaneous
-
-(defun vhdl-remove-trailing-spaces ()
-  "Remove trailing spaces in the whole buffer."
-  (interactive)
-  (save-match-data
-    (save-excursion
-      (goto-char (point-min))
-      (while (re-search-forward "[ \t]+$" (point-max) t)
-        (unless (vhdl-in-literal)
-          (replace-match "" nil nil))))))
-
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;;; Electrification
@@ -8334,14 +8558,14 @@ project is defined."
 With a prefix argument ARG, enable the mode if ARG is positive,
 and disable it otherwise.  If called from Lisp, enable it if ARG
 is omitted or nil."
-  :global t)
+  :global t :group 'vhdl-mode)
 
 (define-minor-mode vhdl-stutter-mode
   "Toggle VHDL stuttering mode.
 With a prefix argument ARG, enable the mode if ARG is positive,
 and disable it otherwise.  If called from Lisp, enable it if ARG
 is omitted or nil."
-  :global t)
+  :global t :group 'vhdl-mode)
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;; Stuttering
@@ -8398,7 +8622,7 @@ is omitted or nil."
 (defun vhdl-electric-quote (count) "'' --> \""
   (interactive "p")
   (if (and vhdl-stutter-mode (= count 1) (not (vhdl-in-literal)))
-      (if (= (preceding-char) last-input-event)
+      (if (= (preceding-char) vhdl-last-input-event)
           (progn (delete-char -1) (insert-char ?\" 1))
         (insert-char ?\' 1))
     (self-insert-command count)))
@@ -8406,7 +8630,7 @@ is omitted or nil."
 (defun vhdl-electric-semicolon (count) "';;' --> ' : ', ': ;' --> ' := '"
   (interactive "p")
   (if (and vhdl-stutter-mode (= count 1) (not (vhdl-in-literal)))
-      (cond ((= (preceding-char) last-input-event)
+      (cond ((= (preceding-char) vhdl-last-input-event)
              (progn (delete-char -1)
                     (unless (eq (preceding-char) ? ) (insert " "))
                     (insert ": ")
@@ -8420,7 +8644,7 @@ is omitted or nil."
 (defun vhdl-electric-comma (count) "',,' --> ' <= '"
   (interactive "p")
   (if (and vhdl-stutter-mode (= count 1) (not (vhdl-in-literal)))
-      (cond ((= (preceding-char) last-input-event)
+      (cond ((= (preceding-char) vhdl-last-input-event)
              (progn (delete-char -1)
                     (unless (eq (preceding-char) ? ) (insert " "))
                     (insert "<= ")))
@@ -8430,7 +8654,7 @@ is omitted or nil."
 (defun vhdl-electric-period (count) "'..' --> ' => '"
   (interactive "p")
   (if (and vhdl-stutter-mode (= count 1) (not (vhdl-in-literal)))
-      (cond ((= (preceding-char) last-input-event)
+      (cond ((= (preceding-char) vhdl-last-input-event)
              (progn (delete-char -1)
                     (unless (eq (preceding-char) ? ) (insert " "))
                     (insert "=> ")))
@@ -8440,7 +8664,7 @@ is omitted or nil."
 (defun vhdl-electric-equal (count) "'==' --> ' == '"
   (interactive "p")
   (if (and vhdl-stutter-mode (= count 1) (not (vhdl-in-literal)))
-      (cond ((= (preceding-char) last-input-event)
+      (cond ((= (preceding-char) vhdl-last-input-event)
              (progn (delete-char -1)
                     (unless (eq (preceding-char) ? ) (insert " "))
                     (insert "== ")))
@@ -8711,12 +8935,13 @@ since these are almost equivalent)."
                     "[COMPONENT | ENTITY | CONFIGURATION]" " " t))
         (setq unit (upcase (or unit "")))
         (cond ((equal unit "ENTITY")
-               (vhdl-template-field "library name" "." nil nil nil nil
+               (let ((begin (point)))
+                 (vhdl-template-field "library name" "." t begin (point) nil
                                     (vhdl-work-library))
                (vhdl-template-field "entity name" "(")
                (if (vhdl-template-field "[architecture name]" nil t)
                    (insert ")")
-                 (delete-char -1)))
+                   (delete-char -1))))
               ((equal unit "CONFIGURATION")
                (vhdl-template-field "library name" "." nil nil nil nil
                                     (vhdl-work-library))
@@ -9852,7 +10077,7 @@ otherwise."
       (let ((definition
               (upcase
                (or (vhdl-template-field
-                    "[scalar type | ARRAY | RECORD | ACCESS | FILE]" nil t)
+                    "[scalar type | ARRAY | RECORD | ACCESS | FILE | ENUM]" nil t)
                    ""))))
         (cond ((equal definition "")
                (delete-char -4)
@@ -9870,6 +10095,11 @@ otherwise."
               ((equal definition "FILE")
                (vhdl-insert-keyword " OF ")
                (vhdl-template-field "type" ";"))
+              ((equal definition "ENUM")
+               (kill-word -1)
+               (insert "(")
+               (setq end-pos (point-marker))
+               (insert ");"))
               (t (insert ";")))
         (when mid-pos
           (setq end-pos (point-marker))
@@ -10916,7 +11146,7 @@ but not if inside a comment or quote."
           (backward-word 1)
           (vhdl-case-word 1)
           (delete-char 1))
-      (let ((invoke-char last-command-event)
+      (let ((invoke-char vhdl-last-input-event)
             (abbrev-mode -1)
             (vhdl-template-invoked-by-hook t))
         (let ((caught (catch 'abort
@@ -11640,7 +11870,8 @@ reflected in a subsequent paste operation."
           ;; paste formal and actual generic
           (insert (car (nth 0 generic)) " => "
                   (if no-constants
-                      (car (nth 0 generic))
+                      (vhdl-replace-string vhdl-actual-generic-name
+                                           (car (nth 0 generic)))
                     (or (nth 2 generic) "")))
           (setq generic-list (cdr generic-list))
           (insert (if generic-list "," ")"))
@@ -11783,7 +12014,7 @@ reflected in a subsequent paste operation."
             ;; paste generic constants
             (setq name (nth 0 generic))
             (when name
-              (insert (car name))
+              (insert (vhdl-replace-string vhdl-actual-generic-name (car name)))
               ;; paste type
               (insert " : " (nth 1 generic))
               ;; paste initialization
@@ -11809,7 +12040,7 @@ reflected in a subsequent paste operation."
     (message "Pasting port as signals...")
     (unless no-indent (indent-according-to-mode))
     (let ((margin (current-indentation))
-          start port names
+          start port names type generic-list port-name constant-name pos
           (port-list (nth 2 vhdl-port-list)))
       (when port-list
         (setq start (point))
@@ -11829,7 +12060,21 @@ reflected in a subsequent paste operation."
             (setq names (cdr names))
             (when names (insert ", ")))
           ;; paste type
-          (insert " : " (nth 3 port))
+          (setq type (nth 3 port))
+          (setq generic-list (nth 1 vhdl-port-list))
+          (vhdl-prepare-search-1
+           (setq pos 0)
+           ;; replace formal by actual generics
+           (while generic-list
+             (setq port-name (car (nth 0 (car generic-list))))
+             (while (string-match (concat "\\<" port-name "\\>") type pos)
+               (setq constant-name
+                     (save-match-data (vhdl-replace-string
+                                       vhdl-actual-generic-name port-name)))
+               (setq type (replace-match constant-name t nil type))
+               (setq pos (match-end 0)))
+             (setq generic-list (cdr generic-list))))
+          (insert " : " type)
           ;; paste initialization (inputs only)
           (when (and initialize (nth 2 port) (equal "IN" (upcase (nth 2 port))))
             (insert " := "
@@ -12418,77 +12663,6 @@ expressions (e.g. for index ranges of types and signals)."
                                 try-expand-list-all-buffers)))
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-;;  Case fixing
-
-(defun vhdl-fix-case-region-1 (beg end upper-case word-regexp &optional count)
-  "Convert all words matching WORD-REGEXP in region to lower or upper case,
-depending on parameter UPPER-CASE."
-  (let ((case-replace nil)
-        (last-update 0))
-    (vhdl-prepare-search-2
-     (save-excursion
-       (goto-char end)
-       (setq end (point-marker))
-       (goto-char beg)
-       (while (re-search-forward word-regexp end t)
-         (or (vhdl-in-literal)
-             (if upper-case
-                 (upcase-word -1)
-               (downcase-word -1)))
-         (when (and count vhdl-progress-interval (not noninteractive)
-                    (< vhdl-progress-interval
-                       (- (nth 1 (current-time)) last-update)))
-           (message "Fixing case... (%2d%s)"
-                    (+ (* count 20) (/ (* 20 (- (point) beg)) (- end beg)))
-                    "%")
-           (setq last-update (nth 1 (current-time)))))
-       (goto-char end)))))
-
-(defun vhdl-fix-case-region (beg end &optional arg)
-  "Convert all VHDL words in region to lower or upper case, depending on
-options vhdl-upper-case-{keywords,types,attributes,enum-values}."
-  (interactive "r\nP")
-  (vhdl-fix-case-region-1
-   beg end vhdl-upper-case-keywords vhdl-keywords-regexp 0)
-  (vhdl-fix-case-region-1
-   beg end vhdl-upper-case-types vhdl-types-regexp 1)
-  (vhdl-fix-case-region-1
-   beg end vhdl-upper-case-attributes (concat "'" vhdl-attributes-regexp) 2)
-  (vhdl-fix-case-region-1
-   beg end vhdl-upper-case-enum-values vhdl-enum-values-regexp 3)
-  (vhdl-fix-case-region-1
-   beg end vhdl-upper-case-constants vhdl-constants-regexp 4)
-  (when vhdl-progress-interval (message "Fixing case...done")))
-
-(defun vhdl-fix-case-buffer ()
-  "Convert all VHDL words in buffer to lower or upper case, depending on
-options vhdl-upper-case-{keywords,types,attributes,enum-values}."
-  (interactive)
-  (vhdl-fix-case-region (point-min) (point-max)))
-
-(defun vhdl-fix-case-word (&optional arg)
-  "Convert word after cursor to upper case if necessary."
-  (interactive "p")
-  (save-excursion
-    (when arg (backward-word 1))
-    (vhdl-prepare-search-1
-     (when (and vhdl-upper-case-keywords
-                (looking-at vhdl-keywords-regexp))
-       (upcase-word 1))
-     (when (and vhdl-upper-case-types
-                (looking-at vhdl-types-regexp))
-       (upcase-word 1))
-     (when (and vhdl-upper-case-attributes
-                (looking-at vhdl-attributes-regexp))
-       (upcase-word 1))
-     (when (and vhdl-upper-case-enum-values
-                (looking-at vhdl-enum-values-regexp))
-       (upcase-word 1))
-     (when (and vhdl-upper-case-constants
-                (looking-at vhdl-constants-regexp))
-       (upcase-word 1)))))
-
-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;; Line handling functions
 
 (defun vhdl-current-line ()
@@ -12642,7 +12816,7 @@ it works within comments too."
     ;; print results
     (message "\n\
 File statistics: \"%s\"\n\
----------------------\n\
+-----------------------\n\
 # statements    : %5d\n\
 # code lines    : %5d\n\
 # empty lines   : %5d\n\
@@ -13493,9 +13667,9 @@ hierarchy otherwise.")
         (while (and (re-search-backward "^[ \t]*\\(end\\|use\\)\\>" nil t)
                     (equal "USE" (upcase (match-string 1))))
           (when (looking-at "^[ \t]*use[ \t\n\r\f]*\\(\\w+\\)\\.\\(\\w+\\)\\.\\w+")
-            (setq lib-alist (cons (cons (match-string-no-properties 1)
+            (push (cons (match-string-no-properties 1)
                                         (vhdl-match-string-downcase 2))
-                                  lib-alist))))))
+                  lib-alist)))))
     lib-alist))
 
 (defun vhdl-scan-directory-contents (name &optional project update num-string
@@ -13541,7 +13715,7 @@ hierarchy otherwise.")
               file-tmp-list)
           (while file-list
             (unless (string-match file-exclude-regexp (car file-list))
-              (setq file-tmp-list (cons (car file-list) file-tmp-list)))
+              (push (car file-list) file-tmp-list))
             (setq file-list (cdr file-list)))
           (setq file-list (nreverse file-tmp-list))))
       ;; do for all files
@@ -13576,7 +13750,7 @@ hierarchy otherwise.")
                          "Entity declared twice (used 1.): \"%s\"\n  1. in \"%s\" (line %d)\n  2. in \"%s\" (line %d)"
                          ent-name  (nth 1 ent-entry) (nth 2 ent-entry)
                          file-name (vhdl-current-line))
-                      (setq ent-list (cons ent-key ent-list))
+                      (push ent-key ent-list)
                       (aput 'ent-alist ent-key
                             (list ent-name file-name (vhdl-current-line)
                                   (nth 3 ent-entry) (nth 4 ent-entry)
@@ -13628,7 +13802,7 @@ hierarchy otherwise.")
                          "Configuration declared twice (used 1.): \"%s\" of \"%s\"\n  1. in \"%s\" (line %d)\n  2. in \"%s\" (line %d)"
                          conf-name ent-name (nth 1 conf-entry)
                          (nth 2 conf-entry) file-name conf-line)
-                      (setq conf-list (cons conf-key conf-list))
+                      (push conf-key conf-list)
                       ;; scan for subconfigurations and subentities
                       (while (re-search-forward "^[ \t]*for[ \t\n\r\f]+\\(\\w+\\([ \t\n\r\f]*,[ \t\n\r\f]*\\w+\\)*\\)[ \t\n\r\f]*:[ \t\n\r\f]*\\(\\w+\\)[ \t\n\r\f]+" end-of-unit t)
                         (setq inst-comp-key (vhdl-match-string-downcase 3)
@@ -13691,8 +13865,8 @@ hierarchy otherwise.")
                       (setq func-alist (nreverse func-alist))
                       (setq comp-alist (nreverse comp-alist))
                       (if is-body
-                          (setq pack-body-list (cons pack-key pack-body-list))
-                        (setq pack-list (cons pack-key pack-list)))
+                          (push pack-key pack-body-list)
+                        (push pack-key pack-list))
                       (aput
                        'pack-alist pack-key
                        (if is-body
@@ -13946,7 +14120,7 @@ of PROJECT."
       (let ((case-fold-search nil))
         (while dir-list
           (unless (string-match file-exclude-regexp (car dir-list))
-            (setq dir-list-tmp (cons (car dir-list) dir-list-tmp)))
+            (push (car dir-list) dir-list-tmp))
           (setq dir-list (cdr dir-list)))
         (setq dir-list (nreverse dir-list-tmp))))
     (message "Collecting source files...done")
@@ -14338,12 +14512,19 @@ if required."
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;; Add hierarchy browser functionality to speedbar
 
-(defvar vhdl-speedbar-key-map nil
+(defvar vhdl-speedbar-mode-map nil
   "Keymap used when in the VHDL hierarchy browser mode.")
 
 (defvar vhdl-speedbar-menu-items nil
   "Additional menu-items to add to speedbar frame.")
 
+(declare-function speedbar-add-supported-extension "speedbar" (extension))
+(declare-function speedbar-add-mode-functions-list "speedbar" (new-list))
+(declare-function speedbar-make-specialized-keymap "speedbar" ())
+(declare-function speedbar-change-initial-expansion-list "speedbar"
+                  (new-default))
+(declare-function speedbar-add-expansion-list "speedbar" (new-list))
+
 (defun vhdl-speedbar-initialize ()
   "Initialize speedbar."
   ;; general settings
@@ -14366,24 +14547,24 @@ if required."
        (speedbar-item-info . vhdl-speedbar-item-info)
        (speedbar-line-directory . vhdl-speedbar-line-project)))
     ;; keymap
-    (unless vhdl-speedbar-key-map
-      (setq vhdl-speedbar-key-map (speedbar-make-specialized-keymap))
-      (define-key vhdl-speedbar-key-map "e" 'speedbar-edit-line)
-      (define-key vhdl-speedbar-key-map "\C-m" 'speedbar-edit-line)
-      (define-key vhdl-speedbar-key-map "+" 'speedbar-expand-line)
-      (define-key vhdl-speedbar-key-map "=" 'speedbar-expand-line)
-      (define-key vhdl-speedbar-key-map "-" 'vhdl-speedbar-contract-level)
-      (define-key vhdl-speedbar-key-map "_" 'vhdl-speedbar-contract-all)
-      (define-key vhdl-speedbar-key-map "C" 'vhdl-speedbar-port-copy)
-      (define-key vhdl-speedbar-key-map "P" 'vhdl-speedbar-place-component)
-      (define-key vhdl-speedbar-key-map "F" 'vhdl-speedbar-configuration)
-      (define-key vhdl-speedbar-key-map "A" 'vhdl-speedbar-select-mra)
-      (define-key vhdl-speedbar-key-map "K" 'vhdl-speedbar-make-design)
-      (define-key vhdl-speedbar-key-map "R" 'vhdl-speedbar-rescan-hierarchy)
-      (define-key vhdl-speedbar-key-map "S" 'vhdl-save-caches)
+    (unless vhdl-speedbar-mode-map
+      (setq vhdl-speedbar-mode-map (speedbar-make-specialized-keymap))
+      (define-key vhdl-speedbar-mode-map "e" 'speedbar-edit-line)
+      (define-key vhdl-speedbar-mode-map "\C-m" 'speedbar-edit-line)
+      (define-key vhdl-speedbar-mode-map "+" 'speedbar-expand-line)
+      (define-key vhdl-speedbar-mode-map "=" 'speedbar-expand-line)
+      (define-key vhdl-speedbar-mode-map "-" 'vhdl-speedbar-contract-level)
+      (define-key vhdl-speedbar-mode-map "_" 'vhdl-speedbar-contract-all)
+      (define-key vhdl-speedbar-mode-map "C" 'vhdl-speedbar-port-copy)
+      (define-key vhdl-speedbar-mode-map "P" 'vhdl-speedbar-place-component)
+      (define-key vhdl-speedbar-mode-map "F" 'vhdl-speedbar-configuration)
+      (define-key vhdl-speedbar-mode-map "A" 'vhdl-speedbar-select-mra)
+      (define-key vhdl-speedbar-mode-map "K" 'vhdl-speedbar-make-design)
+      (define-key vhdl-speedbar-mode-map "R" 'vhdl-speedbar-rescan-hierarchy)
+      (define-key vhdl-speedbar-mode-map "S" 'vhdl-save-caches)
       (let ((key 0))
         (while (<= key 9)
-          (define-key vhdl-speedbar-key-map (int-to-string key)
+          (define-key vhdl-speedbar-mode-map (int-to-string key)
             `(lambda () (interactive) (vhdl-speedbar-set-depth ,key)))
           (setq key (1+ key)))))
     (define-key speedbar-mode-map "h"
@@ -14436,10 +14617,10 @@ if required."
          ["Save Caches" vhdl-save-caches vhdl-updated-project-list])))
     ;; hook-ups
     (speedbar-add-expansion-list
-     '("vhdl directory" vhdl-speedbar-menu-items vhdl-speedbar-key-map
+     '("vhdl directory" vhdl-speedbar-menu-items vhdl-speedbar-mode-map
        vhdl-speedbar-display-directory))
     (speedbar-add-expansion-list
-     '("vhdl project" vhdl-speedbar-menu-items vhdl-speedbar-key-map
+     '("vhdl project" vhdl-speedbar-menu-items vhdl-speedbar-mode-map
        vhdl-speedbar-display-projects))
     (setq speedbar-stealthy-function-list
           (append
@@ -14473,11 +14654,15 @@ if required."
   "Name of last selected project.")
 
 ;; macros must be defined in the file they are used (copied from `speedbar.el')
-(defmacro speedbar-with-writable (&rest forms)
-  "Allow the buffer to be writable and evaluate FORMS."
-  (list 'let '((inhibit-read-only t))
-        (cons 'progn forms)))
-(put 'speedbar-with-writable 'lisp-indent-function 0)
+;;; (defmacro speedbar-with-writable (&rest forms)
+;;;   "Allow the buffer to be writable and evaluate FORMS."
+;;;   (list 'let '((inhibit-read-only t))
+;;;     (cons 'progn forms)))
+;;; (put 'speedbar-with-writable 'lisp-indent-function 0)
+
+(declare-function speedbar-extension-list-to-regex "speedbar" (extlist))
+(declare-function speedbar-directory-buttons "speedbar" (directory _index))
+(declare-function speedbar-file-lists "speedbar" (directory))
 
 (defun vhdl-speedbar-display-directory (directory depth &optional rescan)
   "Display directory and hierarchy information in speedbar."
@@ -14513,6 +14698,9 @@ if required."
       (error (vhdl-warning-when-idle "ERROR:  Invalid hierarchy information, unable to display correctly"))))
   (setq speedbar-full-text-cache nil)) ; prevent caching
 
+(declare-function speedbar-make-tag-line "speedbar"
+                  (type char func data tag tfunc tdata tface depth))
+
 (defun vhdl-speedbar-insert-projects ()
   "Insert all projects in speedbar."
   (vhdl-speedbar-make-title-line "Projects:")
@@ -14616,6 +14804,8 @@ otherwise use cached data."
          depth)
         (setq pack-alist (cdr pack-alist))))))
 
+(declare-function speedbar-line-directory "speedbar" (&optional depth))
+
 (defun vhdl-speedbar-rescan-hierarchy ()
   "Rescan hierarchy for the directory or project under the cursor."
   (interactive)
@@ -14637,6 +14827,8 @@ otherwise use cached data."
          (abbreviate-file-name (match-string 1 path)))))
     (vhdl-speedbar-refresh key)))
 
+(declare-function speedbar-goto-this-file "speedbar" (file))
+
 (defun vhdl-speedbar-expand-dirs (directory)
   "Expand subdirectories in DIRECTORY according to
  `speedbar-shown-directories'."
@@ -14686,6 +14878,8 @@ otherwise use cached data."
          (setq unit-alist (cdr unit-alist))))))
   (vhdl-speedbar-update-current-unit nil t))
 
+(declare-function speedbar-center-buffer-smartly "speedbar" ())
+
 (defun vhdl-speedbar-contract-level ()
   "Contract current level in current directory/project."
   (interactive)
@@ -14726,21 +14920,24 @@ otherwise use cached data."
       (setq arch-alist (nth 4 (car ent-alist)))
       (setq subunit-alist nil)
       (while arch-alist
-        (setq subunit-alist (cons (caar arch-alist) subunit-alist))
+        (push (caar arch-alist) subunit-alist)
         (setq arch-alist (cdr arch-alist)))
-      (setq unit-alist (cons (list (caar ent-alist) subunit-alist) unit-alist))
+      (push (list (caar ent-alist) subunit-alist) unit-alist)
       (setq ent-alist (cdr ent-alist)))
     (while conf-alist
-      (setq unit-alist (cons (list (caar conf-alist)) unit-alist))
+      (push (list (caar conf-alist)) unit-alist)
       (setq conf-alist (cdr conf-alist)))
     (while pack-alist
-      (setq unit-alist (cons (list (caar pack-alist)) unit-alist))
+      (push (list (caar pack-alist)) unit-alist)
       (setq pack-alist (cdr pack-alist)))
     (aput 'vhdl-speedbar-shown-unit-alist key unit-alist)
     (vhdl-speedbar-refresh)
     (when (memq 'display vhdl-speedbar-save-cache)
       (add-to-list 'vhdl-updated-project-list key))))
 
+(declare-function speedbar-change-expand-button-char "speedbar" (char))
+(declare-function speedbar-delete-subblock "speedbar" (indent))
+
 (defun vhdl-speedbar-expand-project (text token indent)
   "Expand/contract the project under the cursor."
   (cond
@@ -15069,6 +15266,8 @@ otherwise use cached data."
       (setq vhdl-speedbar-last-selected-project vhdl-project)))
   t)
 
+(declare-function speedbar-position-cursor-on-line "speedbar" ())
+
 (defun vhdl-speedbar-update-current-unit (&optional no-position always)
   "Highlight all design units that are contained in the current file.
 NO-POSITION non-nil means do not re-position cursor."
@@ -15158,6 +15357,9 @@ NO-POSITION non-nil means do not re-position cursor."
     (setq unit-list (cdr unit-list)))
   pos)
 
+(declare-function speedbar-make-button "speedbar"
+                  (start end face mouse function &optional token))
+
 (defun vhdl-speedbar-make-inst-line (inst-name inst-file-marker
                                                ent-name ent-file-marker
                                                arch-name arch-file-marker
@@ -15344,6 +15546,8 @@ NO-POSITION non-nil means do not re-position cursor."
                               'speedbar-directory-face level)
       (setq dirs (cdr dirs)))))
 
+(declare-function speedbar-reset-scanners "speedbar" ())
+
 (defun vhdl-speedbar-dired (text token indent)
   "Speedbar click handler for directory expand button in hierarchy mode."
   (cond ((string-match "+" text)        ; we have to expand this dir
@@ -15374,7 +15578,7 @@ NO-POSITION non-nil means do not re-position cursor."
                     (concat (speedbar-line-directory indent) token))))
            (while oldl
              (if (not (string-match (concat "^" (regexp-quote td)) (car oldl)))
-                 (setq newl (cons (car oldl) newl)))
+                 (push (car oldl) newl))
              (setq oldl (cdr oldl)))
            (setq speedbar-shown-directories (nreverse newl)))
          (speedbar-change-expand-button-char ?+)
@@ -15383,6 +15587,8 @@ NO-POSITION non-nil means do not re-position cursor."
   (when (equal (selected-frame) speedbar-frame)
     (speedbar-center-buffer-smartly)))
 
+(declare-function speedbar-files-item-info "speedbar" ())
+
 (defun vhdl-speedbar-item-info ()
   "Derive and display information about this line item."
   (save-excursion
@@ -15431,6 +15637,8 @@ NO-POSITION non-nil means do not re-position cursor."
           (vhdl-default-directory)))))
      (t (message "")))))
 
+(declare-function speedbar-line-text "speedbar" (&optional p))
+
 (defun vhdl-speedbar-line-text ()
   "Calls `speedbar-line-text' and removes text properties."
   (let ((string (speedbar-line-text)))
@@ -15481,7 +15689,7 @@ NO-POSITION non-nil means do not re-position cursor."
       (setq dir (car path-list))
       (string-match "\\(-r \\)?\\(\\([^?*]*[/\\]\\)*\\)" dir)
       (if (file-directory-p (match-string 2 dir))
-          (setq path-list-1 (cons dir path-list-1))
+          (push dir path-list-1)
         (vhdl-warning-when-idle "No such directory: \"%s\"" (match-string 2 dir)))
       (setq path-list (cdr path-list)))
     ;; resolve path wildcards
@@ -15503,13 +15711,13 @@ NO-POSITION non-nil means do not re-position cursor."
                           dir-list)
                       (while all-list
                         (when (file-directory-p (car all-list))
-                          (setq dir-list (cons (car all-list) dir-list)))
+                          (push (car all-list) dir-list))
                         (setq all-list (cdr all-list)))
                       dir-list))
                    (cdr path-list-1))))
         (string-match "\\(-r \\)?\\(.*\\)[/\\].*" dir)
         (when (file-directory-p (match-string 2 dir))
-          (setq path-list-2 (cons dir path-list-2)))
+          (push dir path-list-2))
         (setq path-list-1 (cdr path-list-1))))
     (nreverse path-list-2)))
 
@@ -15525,6 +15733,11 @@ NO-POSITION non-nil means do not re-position cursor."
       (goto-char dest)
       nil)))
 
+(declare-function speedbar-find-file-in-frame "speedbar" (file))
+(declare-function speedbar-set-timer "speedbar" (timeout))
+;; speedbar loads dframe at runtime.
+(declare-function dframe-maybee-jump-to-attached-frame "dframe" ())
+
 (defun vhdl-speedbar-find-file (text token indent)
   "When user clicks on TEXT, load file with name and position in TOKEN.
 Jump to the design unit if `vhdl-speedbar-jump-to-unit' is t or if the file
@@ -15534,12 +15747,11 @@ is already shown in a buffer."
     (let ((buffer (get-file-buffer (car token))))
       (speedbar-find-file-in-frame (car token))
       (when (or vhdl-speedbar-jump-to-unit buffer)
-        (goto-char (point-min))
-        (forward-line (1- (cdr token)))
+        (vhdl-goto-line (cdr token))
         (recenter))
       (vhdl-speedbar-update-current-unit t t)
       (speedbar-set-timer dframe-update-speed)
-      (speedbar-maybee-jump-to-attached-frame))))
+      (dframe-maybee-jump-to-attached-frame))))
 
 (defun vhdl-speedbar-port-copy ()
   "Copy the port of the entity/component or subprogram under the cursor."
@@ -15553,8 +15765,7 @@ is already shown in a buffer."
               (let ((token (get-text-property
                             (match-beginning 3) 'speedbar-token)))
                 (vhdl-visit-file (car token) t
-                                 (progn (goto-char (point-min))
-                                        (forward-line (1- (cdr token)))
+                                 (progn (vhdl-goto-line (cdr token))
                                         (end-of-line)
                                         (if is-entity
                                             (vhdl-port-copy)
@@ -15600,6 +15811,8 @@ is already shown in a buffer."
       (setcar (cddr (cddr ent-entry)) arch-key) ; (nth 4 ent-entry)
       (speedbar-refresh))))
 
+(declare-function speedbar-line-file "speedbar" (&optional p))
+
 (defun vhdl-speedbar-make-design ()
   "Make (compile) design unit or directory/project under the cursor."
   (interactive)
@@ -16007,7 +16220,7 @@ component instantiation."
                              (or (aget generic-alist (match-string 2) t)
                                  (error "ERROR:  Formal generic \"%s\" mismatch for instance \"%s\"" (match-string 2) inst-name))
                            (cdar generic-alist))))
-             (setq constant-alist (cons constant-entry constant-alist))
+             (push constant-entry constant-alist)
              (setq constant-name (downcase constant-name))
              (if (or (member constant-name single-list)
                      (member constant-name multi-list))
@@ -16027,7 +16240,7 @@ component instantiation."
                                         (or (aget port-alist (match-string 2) t)
                                             (error "ERROR:  Formal port \"%s\" mismatch for instance \"%s\"" (match-string 2) inst-name))
                                       (cdar port-alist))))
-           (setq signal-alist (cons signal-entry signal-alist))
+           (push signal-entry signal-alist)
            (setq signal-name (downcase signal-name))
            (if (equal (upcase (nth 2 signal-entry)) "IN")
                ;; input signal
@@ -16061,8 +16274,8 @@ component instantiation."
            (unless (match-string 1)
              (setq port-alist (cdr port-alist)))
            (vhdl-forward-syntactic-ws))
-         (setq inst-alist (cons (list inst-name (nreverse constant-alist)
-                                      (nreverse signal-alist)) inst-alist)))
+         (push (list inst-name (nreverse constant-alist)
+                     (nreverse signal-alist)) inst-alist))
        ;; prepare signal insertion
        (vhdl-goto-marker arch-decl-pos)
        (forward-line 1)
@@ -16129,6 +16342,7 @@ component instantiation."
          (while constant-alist
            (setq constant-name (downcase (caar constant-alist))
                  constant-entry (car constant-alist))
+           (unless (string-match "^[0-9]+" constant-name)
            (cond ((member constant-name written-list)
                   nil)
                  ((member constant-name multi-list)
@@ -16145,7 +16359,7 @@ component instantiation."
                   (setq generic-end-pos
                         (vhdl-compose-insert-generic constant-entry))
                   (setq generic-inst-pos (point-marker))
-                  (add-to-list 'written-list constant-name)))
+                    (add-to-list 'written-list constant-name))))
            (setq constant-alist (cdr constant-alist)))
          (when (/= constant-temp-pos generic-inst-pos)
            (vhdl-goto-marker (vhdl-max-marker constant-temp-pos generic-pos))
@@ -16305,8 +16519,7 @@ current project/directory."
     ;; insert component declarations
     (while ent-alist
       (vhdl-visit-file (nth 2 (car ent-alist)) nil
-                       (progn (goto-char (point-min))
-                              (forward-line (1- (nth 3 (car ent-alist))))
+                       (progn (vhdl-goto-line (nth 3 (car ent-alist)))
                               (end-of-line)
                               (vhdl-port-copy)))
       (goto-char component-pos)
@@ -16562,12 +16775,12 @@ no project is defined."
         (setq sublist (nth 11 (car commands-alist)))
         (unless (or (equal "" (car sublist))
                     (assoc (car sublist) regexp-alist))
-          (setq regexp-alist (cons (list (nth 0 sublist)
-                                         (if (= 0 (nth 1 sublist))
-                                             (if (featurep 'xemacs) 9 nil)
+          (push (list (nth 0 sublist)
+                      (if (and (featurep 'xemacs) (not (nth 1 sublist)))
+                          9
                                            (nth 1 sublist))
                                          (nth 2 sublist) (nth 3 sublist))
-                                   regexp-alist)))
+                regexp-alist))
         (setq commands-alist (cdr commands-alist)))
       (setq compilation-error-regexp-alist
             (append compilation-error-regexp-alist (nreverse regexp-alist))))
@@ -16580,7 +16793,7 @@ no project is defined."
         (setq sublist (nth 12 (car commands-alist)))
         (unless (or (equal "" (car sublist))
                     (assoc (car sublist) regexp-alist))
-          (setq regexp-alist (cons sublist regexp-alist)))
+          (push sublist regexp-alist))
         (setq commands-alist (cdr commands-alist)))
       (setq compilation-file-regexp-alist
             (append compilation-file-regexp-alist (nreverse regexp-alist))))))
@@ -16709,6 +16922,42 @@ specified by a target."
     (compile (concat (if (equal command "") "make" command)
                      " " options " " vhdl-make-target))))
 
+;; Emacs 22+ setup
+(defvar vhdl-error-regexp-emacs-alist
+  ;; Get regexps from `vhdl-compiler-alist'
+  (let ((compiler-alist vhdl-compiler-alist)
+        (error-regexp-alist '((vhdl-directory "^ *Compiling \"\\(.+\\)\"" 1))))
+   (while compiler-alist
+     ;; add error message regexps
+     (setq error-regexp-alist
+           (cons (append (list (make-symbol (concat "vhdl-" (subst-char-in-string ?  ?- (downcase (nth 0 (car compiler-alist)))))))
+                         (nth 11 (car compiler-alist)))
+                 error-regexp-alist))
+     ;; add filename regexps
+     (when (/= 0 (nth 1 (nth 12 (car compiler-alist))))
+       (setq error-regexp-alist
+             (cons (append (list (make-symbol (concat "vhdl-" (subst-char-in-string ?  ?- (downcase (nth 0 (car compiler-alist)))) "-file")))
+                           (nth 12 (car compiler-alist)))
+                   error-regexp-alist)))
+     (setq compiler-alist (cdr compiler-alist)))
+   error-regexp-alist)
+  "List of regexps for VHDL compilers.  For Emacs 22+.")
+
+;; Add error regexps using compilation-mode-hook.
+(defun vhdl-error-regexp-add-emacs ()
+  "Set up Emacs compile for VHDL."
+  (interactive)
+  (when (and (boundp 'compilation-error-regexp-alist-alist)
+             (not (assoc 'vhdl-modelsim compilation-error-regexp-alist-alist)))
+    (mapcar
+     (lambda (item)
+       (push (car item) compilation-error-regexp-alist)
+       (push item compilation-error-regexp-alist-alist))
+     vhdl-error-regexp-emacs-alist)))
+
+(when vhdl-emacs-22
+  (add-hook 'compilation-mode-hook 'vhdl-error-regexp-add-emacs))
+
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;; Makefile generation
 
@@ -16731,7 +16980,7 @@ specified by a target."
   (let (pack-list)
     (while lib-alist
       (when (equal (downcase (caar lib-alist)) (downcase work-library))
-        (setq pack-list (cons (cdar lib-alist) pack-list)))
+        (push (cdar lib-alist) pack-list))
       (setq lib-alist (cdr lib-alist)))
     pack-list))
 
@@ -16783,8 +17032,10 @@ specified by a target."
       (setq ent-entry (car ent-alist)
             ent-key (nth 0 ent-entry))
       (when (nth 2 ent-entry)
-        (setq ent-file-name (file-relative-name
-                             (nth 2 ent-entry) compile-directory)
+        (setq ent-file-name (if vhdl-compile-absolute-path
+                                (nth 2 ent-entry)
+                              (file-relative-name (nth 2 ent-entry)
+                                                  compile-directory))
               arch-alist (nth 4 ent-entry)
               lib-alist (nth 6 ent-entry)
               rule (aget rule-alist ent-file-name)
@@ -16794,9 +17045,9 @@ specified by a target."
               subcomp-list nil)
         (setq tmp-key (vhdl-replace-string
                        ent-regexp (funcall adjust-case ent-key)))
-        (setq unit-list (cons (cons ent-key tmp-key) unit-list))
+        (push (cons ent-key tmp-key) unit-list)
         ;; rule target for this entity
-        (setq target-list (cons ent-key target-list))
+        (push ent-key target-list)
         ;; rule dependencies for all used packages
         (setq pack-list (vhdl-get-packages lib-alist work-library))
         (setq depend-list (append depend-list pack-list))
@@ -16808,8 +17059,10 @@ specified by a target."
           (setq arch-entry (car arch-alist)
                 arch-key (nth 0 arch-entry)
                 ent-arch-key (concat ent-key "-" arch-key)
-                arch-file-name (file-relative-name (nth 2 arch-entry)
-                                                   compile-directory)
+                arch-file-name (if vhdl-compile-absolute-path
+                                   (nth 2 arch-entry)
+                                 (file-relative-name (nth 2 arch-entry)
+                                                     compile-directory))
                 inst-alist (nth 4 arch-entry)
                 lib-alist (nth 5 arch-entry)
                 rule (aget rule-alist arch-file-name)
@@ -16820,11 +17073,11 @@ specified by a target."
                          (funcall adjust-case (concat arch-key " " ent-key))))
           (setq unit-list
                 (cons (cons ent-arch-key tmp-key) unit-list))
-          (setq second-list (cons ent-arch-key second-list))
+          (push ent-arch-key second-list)
           ;; rule target for this architecture
-          (setq target-list (cons ent-arch-key target-list))
+          (push ent-arch-key target-list)
           ;; rule dependency for corresponding entity
-          (setq depend-list (cons ent-key depend-list))
+          (push ent-key depend-list)
           ;; rule dependencies for contained component instantiations
           (while inst-alist
             (setq inst-entry (car inst-alist))
@@ -16842,9 +17095,8 @@ specified by a target."
           ;; add rule
           (aput 'rule-alist arch-file-name (list target-list depend-list))
           (setq arch-alist (cdr arch-alist)))
-        (setq prim-list (cons (list ent-key second-list
-                                    (append subcomp-list all-pack-list))
-                              prim-list)))
+        (push (list ent-key second-list (append subcomp-list all-pack-list))
+              prim-list))
       (setq ent-alist (cdr ent-alist)))
     (setq ent-alist tmp-list)
     ;; rules for all configurations
@@ -16852,8 +17104,10 @@ specified by a target."
     (while conf-alist
       (setq conf-entry (car conf-alist)
             conf-key (nth 0 conf-entry)
-            conf-file-name (file-relative-name
-                            (nth 2 conf-entry) compile-directory)
+            conf-file-name (if vhdl-compile-absolute-path
+                               (nth 2 conf-entry)
+                             (file-relative-name (nth 2 conf-entry)
+                                                 compile-directory))
             ent-key (nth 4 conf-entry)
             arch-key (nth 5 conf-entry)
             inst-alist (nth 6 conf-entry)
@@ -16864,9 +17118,9 @@ specified by a target."
             subcomp-list (list ent-key))
       (setq tmp-key (vhdl-replace-string
                      conf-regexp (funcall adjust-case conf-key)))
-      (setq unit-list (cons (cons conf-key tmp-key) unit-list))
+      (push (cons conf-key tmp-key) unit-list)
       ;; rule target for this configuration
-      (setq target-list (cons conf-key target-list))
+      (push conf-key target-list)
       ;; rule dependency for corresponding entity and architecture
       (setq depend-list
             (cons ent-key (cons (concat ent-key "-" arch-key) depend-list)))
@@ -16884,16 +17138,14 @@ specified by a target."
             (setq depend-list (cons inst-ent-key depend-list)
                   subcomp-list (cons inst-ent-key subcomp-list)))
 ;           (when comp-arch-key
-;             (setq depend-list (cons (concat comp-ent-key "-" comp-arch-key)
-;                                     depend-list)))
+;             (push (concat comp-ent-key "-" comp-arch-key) depend-list))
           (when inst-conf-key
             (setq depend-list (cons inst-conf-key depend-list)
                   subcomp-list (cons inst-conf-key subcomp-list))))
         (setq inst-alist (cdr inst-alist)))
       ;; add rule
       (aput 'rule-alist conf-file-name (list target-list depend-list))
-      (setq prim-list (cons (list conf-key nil (append subcomp-list pack-list))
-                            prim-list))
+      (push (list conf-key nil (append subcomp-list pack-list)) prim-list)
       (setq conf-alist (cdr conf-alist)))
     (setq conf-alist tmp-list)
     ;; rules for all packages
@@ -16903,16 +17155,18 @@ specified by a target."
             pack-key (nth 0 pack-entry)
             pack-body-key nil)
       (when (nth 2 pack-entry)
-        (setq pack-file-name (file-relative-name (nth 2 pack-entry)
-                                                 compile-directory)
+        (setq pack-file-name (if vhdl-compile-absolute-path
+                                 (nth 2 pack-entry)
+                               (file-relative-name (nth 2 pack-entry)
+                                                   compile-directory))
               lib-alist (nth 6 pack-entry) lib-body-alist (nth 10 pack-entry)
               rule (aget rule-alist pack-file-name)
               target-list (nth 0 rule) depend-list (nth 1 rule))
         (setq tmp-key (vhdl-replace-string
                        pack-regexp (funcall adjust-case pack-key)))
-        (setq unit-list (cons (cons pack-key tmp-key) unit-list))
+        (push (cons pack-key tmp-key) unit-list)
         ;; rule target for this package
-        (setq target-list (cons pack-key target-list))
+        (push pack-key target-list)
         ;; rule dependencies for all used packages
         (setq pack-list (vhdl-get-packages lib-alist work-library))
         (setq depend-list (append depend-list pack-list))
@@ -16922,8 +17176,10 @@ specified by a target."
         ;; rules for this package's body
         (when (nth 7 pack-entry)
           (setq pack-body-key (concat pack-key "-body")
-                pack-body-file-name (file-relative-name (nth 7 pack-entry)
-                                                        compile-directory)
+                pack-body-file-name (if vhdl-compile-absolute-path
+                                        (nth 7 pack-entry)
+                                      (file-relative-name (nth 7 pack-entry)
+                                                          compile-directory))
                 rule (aget rule-alist pack-body-file-name)
                 target-list (nth 0 rule)
                 depend-list (nth 1 rule))
@@ -16932,9 +17188,9 @@ specified by a target."
           (setq unit-list
                 (cons (cons pack-body-key tmp-key) unit-list))
           ;; rule target for this package's body
-          (setq target-list (cons pack-body-key target-list))
+          (push pack-body-key target-list)
           ;; rule dependency for corresponding package declaration
-          (setq depend-list (cons pack-key depend-list))
+          (push pack-key depend-list)
           ;; rule dependencies for all used packages
           (setq pack-list (vhdl-get-packages lib-body-alist work-library))
           (setq depend-list (append depend-list pack-list))
@@ -17057,16 +17313,16 @@ specified by a target."
         (unless (equal unit-key unit-name)
           (insert " \\\n" unit-name))
         (insert " :"
-                " \\\n\t\t" (nth 2 vhdl-makefile-default-targets)
-                " \\\n\t\t$(UNIT-" work-library "-" unit-key ")")
-        (while second-list
-          (insert " \\\n\t\t$(UNIT-" work-library "-" (car second-list) ")")
-          (setq second-list (cdr second-list)))
+                " \\\n\t\t" (nth 2 vhdl-makefile-default-targets))
         (while subcomp-list
           (when (and (assoc (car subcomp-list) unit-list)
                      (not (equal unit-key (car subcomp-list))))
             (insert " \\\n\t\t" (car subcomp-list)))
           (setq subcomp-list (cdr subcomp-list)))
+        (insert " \\\n\t\t$(UNIT-" work-library "-" unit-key ")")
+        (while second-list
+          (insert " \\\n\t\t$(UNIT-" work-library "-" (car second-list) ")")
+          (setq second-list (cdr second-list)))
         (insert "\n")
         (setq prim-list (cdr prim-list)))
       ;; insert rule for each library unit file
@@ -17205,6 +17461,7 @@ specified by a target."
        'vhdl-include-direction-comments
        'vhdl-include-type-comments
        'vhdl-include-group-comments
+       'vhdl-actual-generic-name
        'vhdl-actual-port-name
        'vhdl-instance-name
        'vhdl-testbench-entity-name
@@ -17287,13 +17544,21 @@ specified by a target."
 
 (defconst vhdl-doc-release-notes nil
   "\
-Release Notes for VHDL Mode 3.33
+Release Notes for VHDL Mode 3.34
 ================================
 
-  - New Features
-  - User Options
+- Added support for GNU Emacs 22/23/24:
+  - Compilation error parsing fixed for new `compile.el' package.
+
+- Port translation: Derive actual generic name from formal generic name.
+
+- New user options:
+  `vhdl-actual-generic-name': Specify how actual generic names are obtained.
 
 
+Release Notes for VHDL Mode 3.33
+================================
+
 New Features
 ------------
 
diff --git a/lisp/progmodes/which-func.el b/lisp/progmodes/which-func.el
index edfe368479c..c8044f407fc 100644
--- a/lisp/progmodes/which-func.el
+++ b/lisp/progmodes/which-func.el
@@ -343,6 +343,10 @@ If no function name is found, return nil."
 
 ;;; Integration with other packages
 
+(defvar ediff-window-A)
+(defvar ediff-window-B)
+(defvar ediff-window-C)
+
 (defun which-func-update-ediff-windows ()
   "Update Which-Function mode display for Ediff windows.
 This function is meant to be called from `ediff-select-hook'."
diff --git a/lisp/progmodes/xscheme.el b/lisp/progmodes/xscheme.el
index 2ad44b4b1c8..37c3cd37a6c 100644
--- a/lisp/progmodes/xscheme.el
+++ b/lisp/progmodes/xscheme.el
@@ -35,7 +35,6 @@
 ;;;; Internal Variables
 
 (defvar xscheme-previous-mode)
-(defvar xscheme-previous-process-state)
 (defvar xscheme-last-input-end)
 
 (defvar xscheme-process-command-line nil
@@ -388,8 +387,6 @@ with no args, if that value is non-nil.
   (if (not preserve)
       (let ((previous-mode major-mode))
         (kill-all-local-variables)
-        (make-local-variable 'xscheme-process-name)
-        (make-local-variable 'xscheme-previous-process-state)
         (make-local-variable 'xscheme-runlight-string)
         (make-local-variable 'xscheme-runlight)
         (set (make-local-variable 'xscheme-previous-mode) previous-mode)
@@ -397,35 +394,29 @@ with no args, if that value is non-nil.
           (set (make-local-variable 'xscheme-buffer-name) (buffer-name buffer))
           (set (make-local-variable 'xscheme-last-input-end) (make-marker))
           (let ((process (get-buffer-process buffer)))
-            (if process
-                (progn
-                  (setq xscheme-process-name (process-name process))
-                  (setq xscheme-previous-process-state
-                        (cons (process-filter process)
-                              (process-sentinel process)))
-                  (xscheme-process-filter-initialize t)
-                  (xscheme-mode-line-initialize xscheme-buffer-name)
-                  (set-process-sentinel process 'xscheme-process-sentinel)
-                  (set-process-filter process 'xscheme-process-filter))
-                (setq xscheme-previous-process-state (cons nil nil)))))))
+            (when process
+              (setq-local xscheme-process-name (process-name process))
+              ;; FIXME: Use add-function!
+              (xscheme-process-filter-initialize t)
+              (xscheme-mode-line-initialize xscheme-buffer-name)
+              (add-function :override (process-sentinel process)
+                            #'xscheme-process-sentinel)
+              (add-function :override (process-filter process)
+                            #'xscheme-process-filter))))))
   (scheme-interaction-mode-initialize)
   (scheme-mode-variables)
   (run-mode-hooks 'scheme-mode-hook 'scheme-interaction-mode-hook))
 
 (defun exit-scheme-interaction-mode ()
-  "Take buffer out of scheme interaction mode"
+  "Take buffer out of scheme interaction mode."
   (interactive)
   (if (not (derived-mode-p 'scheme-interaction-mode))
       (error "Buffer not in scheme interaction mode"))
-  (let ((previous-state xscheme-previous-process-state))
-    (funcall xscheme-previous-mode)
-    (let ((process (get-buffer-process (current-buffer))))
-      (if process
-          (progn
-            (if (eq (process-filter process) 'xscheme-process-filter)
-                (set-process-filter process (car previous-state)))
-            (if (eq (process-sentinel process) 'xscheme-process-sentinel)
-                (set-process-sentinel process (cdr previous-state))))))))
+  (funcall xscheme-previous-mode)
+  (let ((process (get-buffer-process (current-buffer))))
+    (when process
+      (remove-function (process-sentinel process) #'xscheme-process-sentinel)
+      (remove-function (process-filter process) #'xscheme-process-filter))))
 
 (defvar scheme-interaction-mode-commands-alist nil)
 (defvar scheme-interaction-mode-map nil)