* mail/rmail.el (rmail-show-message-1): When displaying a mime message,

       indicate start and finish in the echo area.

       * mail/rmail.el (rmail-epa-decrypt): Disregard <pre> before armor.
       Ignore more kinds of whitespace in mime headers.
       Modify the decrypted mime part's mime type so it will be displayed
       by default when visiting this message again.

       * net/browse-url.el (browse-url-firefox-program): Prefer IceCat, doc.
       (browse-url-firefox-arguments)
       (browse-url-firefox-startup-arguments): Doc fix.

15 files changed, 755 insertions, 332 deletions

diff --git a/lisp/progmodes/cc-engine.el b/lisp/progmodes/cc-engine.el
index 328e0f79a1c..823d795b6de 100644
--- a/lisp/progmodes/cc-engine.el
+++ b/lisp/progmodes/cc-engine.el
@@ -2277,7 +2277,9 @@ comment at the start of cc-engine.el for more info."
           (while
               ;; Add an element to `c-state-nonlit-pos-cache' each iteration.
               (and
-               (<= (setq npos (+ pos c-state-nonlit-pos-interval)) here)
+               (setq npos
+                     (when (<= (+ pos c-state-nonlit-pos-interval) here)
+                       (+ pos c-state-nonlit-pos-interval)))
 
                ;; Test for being in a literal.  If so, go to after it.
                (progn
@@ -2304,7 +2306,9 @@ comment at the start of cc-engine.el for more info."
           ;; Add one extra element above HERE so as to to avoid the previous
           ;; expensive calculation when the next call is close to the current
           ;; one.  This is especially useful when inside a large macro.
-          (setq c-state-nonlit-pos-cache (cons npos c-state-nonlit-pos-cache)))
+          (when npos
+            (setq c-state-nonlit-pos-cache
+                  (cons npos c-state-nonlit-pos-cache))))
 
         (if (> pos c-state-nonlit-pos-cache-limit)
             (setq c-state-nonlit-pos-cache-limit pos))
@@ -3069,7 +3073,7 @@ comment at the start of cc-engine.el for more info."
       (setq dropped-cons (consp (car c-state-cache)))
       (setq c-state-cache (cdr c-state-cache))
       (setq pos pa))
-    ;; At this stage, (> pos here);
+    ;; At this stage, (>= pos here);
     ;; (< (c-state-cache-top-lparen) here)  (or is nil).
 
     (cond
diff --git a/lisp/progmodes/cc-langs.el b/lisp/progmodes/cc-langs.el
index 4d16a9b9d33..ee5a5a6503f 100644
--- a/lisp/progmodes/cc-langs.el
+++ b/lisp/progmodes/cc-langs.el
@@ -495,9 +495,9 @@ parameters \(point-min) and \(point-max).")
 (c-lang-defconst c-before-font-lock-functions
   ;; For documentation see the following c-lang-defvar of the same name.
   ;; The value here may be a list of functions or a single function.
-  t 'c-change-set-fl-decl-start
+  t 'c-change-expand-fl-region
   (c c++ objc) '(c-neutralize-syntax-in-and-mark-CPP
-                 c-change-set-fl-decl-start)
+                 c-change-expand-fl-region)
   awk 'c-awk-extend-and-syntax-tablify-region)
 (c-lang-defvar c-before-font-lock-functions
                (let ((fs (c-lang-const c-before-font-lock-functions)))
@@ -524,7 +524,7 @@ parameters \(point-min), \(point-max) and <buffer size>.")
 
 (c-lang-defconst c-before-context-fontification-functions
   awk nil
-  t 'c-context-set-fl-decl-start)
+  t 'c-context-expand-fl-region)
   ;; For documentation see the following c-lang-defvar of the same name.
   ;; The value here may be a list of functions or a single function.
 (c-lang-defvar c-before-context-fontification-functions
diff --git a/lisp/progmodes/cc-mode.el b/lisp/progmodes/cc-mode.el
index 01e93b3f202..42ee14072d8 100644
--- a/lisp/progmodes/cc-mode.el
+++ b/lisp/progmodes/cc-mode.el
@@ -968,12 +968,17 @@ Note that the style variables are always made local to the buffer."
     (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.
-        (setq pps-state
-              (parse-partial-sexp pps-position (point) nil nil pps-state)
-              pps-position (point))
-        (unless (or (nth 3 pps-state)   ; in a string?
-                    (nth 4 pps-state))  ; in a comment?
+        ;; If we've found a "#" inside a macro/string/comment, ignore it.
+        (unless
+            (or (save-excursion
+                  (goto-char (match-beginning 0))
+                  (c-beginning-of-macro))
+                (progn
+                  (setq pps-state
+                        (parse-partial-sexp pps-position (point) nil nil pps-state)
+                        pps-position (point))
+                  (or (nth 3 pps-state)    ; in a string?
+                      (nth 4 pps-state)))) ; in a comment?
           (goto-char (match-beginning 1))
           (setq mbeg (point))
           (if (> (c-syntactic-end-of-macro) mbeg)
@@ -1143,11 +1148,11 @@ Note that the style variables are always made local to the buffer."
                   (funcall fn beg end old-len))
                 c-before-font-lock-functions))))))
 
-(defun c-set-fl-decl-start (pos)
+(defun c-fl-decl-start (pos)
   ;; If the beginning of the line containing POS is in the middle of a "local"
   ;; declaration (i.e. one which does not start outside of braces enclosing
   ;; POS, such as a struct), return the beginning of that declaration.
-  ;; Otherwise return POS.  Note that declarations, in this sense, can be
+  ;; Otherwise return nil.  Note that declarations, in this sense, can be
   ;; nested.
   ;;
   ;; This function is called indirectly from font locking stuff - either from
@@ -1184,29 +1189,50 @@ Note that the style variables are always made local to the buffer."
                               (1- (point)) 'syntax-table)
                              c-<-as-paren-syntax)))))
          (not (bobp)))
-      (backward-char))
-    new-pos))                           ; back over (, [, <.
-
-(defun c-change-set-fl-decl-start (_beg _end _old-len)
-  ;; Set c-new-BEG to the beginning of a "local" declaration if it('s BOL) is
-  ;; inside one.  This is called from an after-change-function, but the
-  ;; parameters BEG END and OLD-LEN are ignored.  See `c-set-fl-decl-start'
-  ;; for the detailed functionality.
-  (if font-lock-mode
-      (setq c-new-BEG (c-set-fl-decl-start c-new-BEG))))
-
-(defun c-context-set-fl-decl-start (beg end)
-  ;; Return a cons (NEW-BEG . END), where NEW-BEG is the beginning of a
-  ;; "local" declaration (BOL at) NEW is inside or BEG.  See
-  ;; `c-set-fl-decl-start' for the detailed functionality.
-  (cons (c-set-fl-decl-start beg) end))
+      (backward-char))                  ; back over (, [, <.
+    (and (/= new-pos pos) new-pos)))
+
+(defun c-change-expand-fl-region (beg end old-len)
+  ;; Expand the region (c-new-BEG c-new-END) to an after-change font-lock
+  ;; region.  This will usually be the smallest sequence of whole lines
+  ;; containing `c-new-BEG' and `c-new-END', but if `c-new-BEG' is in a
+  ;; "local" declaration (see `c-fl-decl-start') the beginning of this is used
+  ;; as the lower bound.
+  ;;
+  ;; This is called from an after-change-function, but the parameters BEG END
+  ;; and OLD-LEN are not used.
+   (if font-lock-mode
+       (setq c-new-BEG
+             (or (c-fl-decl-start c-new-BEG) (c-point 'bol c-new-BEG))
+             c-new-END (c-point 'bonl c-new-END))))
+
+(defun c-context-expand-fl-region (beg end)
+  ;; Return a cons (NEW-BEG . NEW-END), where NEW-BEG is the beginning of a
+  ;; "local" declaration containing BEG (see `c-fl-decl-start') or BOL BEG is
+  ;; in.  NEW-END is beginning of the line after the one END is in.
+  (cons (or (c-fl-decl-start beg) (c-point 'bol beg))
+        (c-point 'bonl end)))
+
+(defun c-before-context-fl-expand-region (beg end)
+  ;; Expand the region (BEG END) as specified by
+  ;; `c-before-context-fontification-functions'.  Return a cons of the bounds
+  ;; of the new region.
+  (save-restriction
+    (widen)
+    (save-excursion
+      (let ((new-beg beg) (new-end end) new-region)
+        (mapc (lambda (fn)
+                (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)
+        new-region))))
 
 (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
-  ;; off the start of the context.  Do not do anything if it's already been
-  ;; done (i.e. from an after-change fontification.  An example (C++) where
-  ;; this used to happen is this:
+  ;; off the start of the context.  Do not extend the region if it's already
+  ;; been done (i.e. from an after-change fontification.  An example (C++)
+  ;; where the chopping off used to happen is this:
   ;;
   ;;     template <typename T>
   ;;
@@ -1215,17 +1241,39 @@ Note that the style variables are always made local to the buffer."
   ;; 
   ;; Type a space in the first blank line, and the fontification of the next
   ;; line was fouled up by context fontification.
-  (let ((new-beg beg) (new-end end) new-region case-fold-search
-        open-paren-in-column-0-is-defun-start)
-    (if c-in-after-change-fontification
-        (setq c-in-after-change-fontification nil)
-      (save-restriction
-        (widen)
-        (save-excursion
-          (mapc (lambda (fn)
-                  (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))))
+  (let (new-beg new-end new-region case-fold-search
+                open-paren-in-column-0-is-defun-start)
+    (if (and c-in-after-change-fontification
+             (< beg c-new-END) (> end c-new-BEG))
+        ;; Region and the latest after-change fontification region overlap.
+        ;; Determine the upper and lower bounds of our adjusted region
+        ;; separately.
+        (progn
+          (if (<= beg c-new-BEG)
+              (setq c-in-after-change-fontification nil))
+          (setq new-beg
+                (if (and (>= beg (c-point 'bol c-new-BEG))
+                         (<= beg c-new-BEG))
+                    ;; Either jit-lock has accepted `c-new-BEG', or has
+                    ;; (probably) extended the change region spuriously to
+                    ;; BOL, which position likely has a syntactically
+                    ;; different position.  To ensure correct fontification,
+                    ;; we start at `c-new-BEG', assuming any characters to the
+                    ;; left of `c-new-BEG' on the line do not require
+                    ;; fontification.
+                    c-new-BEG
+                  (setq new-region (c-before-context-fl-expand-region beg end)
+                        new-end (cdr new-region))
+                  (car new-region)))
+          (setq new-end
+                (if (and (>= end (c-point 'bol c-new-END))
+                         (<= end c-new-END))
+                    c-new-END
+                  (or new-end
+                      (cdr (c-before-context-fl-expand-region beg end))))))
+      ;; Context (etc.) fontification.
+      (setq new-region (c-before-context-fl-expand-region beg end)
+            new-beg (car new-region)  new-end (cdr new-region)))
     (funcall (default-value 'font-lock-fontify-region-function)
              new-beg new-end verbose)))
 
@@ -1264,7 +1312,7 @@ This function is called from `c-common-init', once per mode initialization."
 ;; Emacs 22 and later.
 (defun c-extend-after-change-region (_beg _end _old-len)
   "Extend the region to be fontified, if necessary."
-  ;; Note: the parameters are ignored here.  This somewhat indirect
+  ;; Note: the parameter OLD-LEN is ignored here.  This somewhat indirect
   ;; implementation exists because it is minimally different from the
   ;; stand-alone CC Mode which, lacking
   ;; font-lock-extend-after-change-region-function, is forced to use advice
@@ -1273,6 +1321,13 @@ This function is called from `c-common-init', once per mode initialization."
   ;; Of the seven CC Mode languages, currently (2009-05) only C, C++, Objc
   ;; (the languages with #define) and AWK Mode make non-null use of this
   ;; function.
+  (when (eq font-lock-support-mode 'jit-lock-mode)
+    (save-restriction
+      (widen)
+      (if (< c-new-BEG beg)
+          (put-text-property c-new-BEG beg 'fontified nil))
+      (if (> c-new-END end)
+          (put-text-property end c-new-END 'fontified nil))))
   (cons c-new-BEG c-new-END))
 
 ;; Emacs < 22 and XEmacs
diff --git a/lisp/progmodes/cperl-mode.el b/lisp/progmodes/cperl-mode.el
index 3b8742ee842..2acfc104cf3 100644
--- a/lisp/progmodes/cperl-mode.el
+++ b/lisp/progmodes/cperl-mode.el
@@ -2281,8 +2281,8 @@ to nil."
              (search-backward ")")
              (if (eq last-command-event ?\()
                  (progn                 ; Avoid "if (())"
-                   (delete-backward-char 1)
-                   (delete-backward-char -1))))
+                   (delete-char -1)
+                   (delete-char 1))))
            (if delete
                (cperl-putback-char cperl-del-back-ch))
            (if cperl-message-electric-keyword
@@ -2588,7 +2588,7 @@ Will untabify if `cperl-electric-backspace-untabify' is non-nil."
           (delete-region (point) p))
       (if cperl-electric-backspace-untabify
           (backward-delete-char-untabify arg)
-        (delete-backward-char arg)))))
+        (call-interactively 'delete-backward-char)))))
 
 (put 'cperl-electric-backspace 'delete-selection 'supersede)
 
diff --git a/lisp/progmodes/elisp-mode.el b/lisp/progmodes/elisp-mode.el
index b2c5fbfe60e..29f1ee9a98c 100644
--- a/lisp/progmodes/elisp-mode.el
+++ b/lisp/progmodes/elisp-mode.el
@@ -883,10 +883,11 @@ If CHAR is not a character, return nil."
 
 (defun elisp--eval-last-sexp (eval-last-sexp-arg-internal)
   "Evaluate sexp before point; print value in the echo area.
-With argument, print output into current buffer.
-With a zero prefix arg, print output with no limit on the length
-and level of lists, and include additional formats for integers
-\(octal, hexadecimal, and character)."
+If EVAL-LAST-SEXP-ARG-INTERNAL is non-nil, print output into
+current buffer.  If EVAL-LAST-SEXP-ARG-INTERNAL is `0', print
+output with no limit on the length and level of lists, and
+include additional formats for integers \(octal, hexadecimal, and
+character)."
   (let ((standard-output (if eval-last-sexp-arg-internal (current-buffer) t)))
     ;; Setup the lexical environment if lexical-binding is enabled.
     (elisp--eval-last-sexp-print-value
diff --git a/lisp/progmodes/f90.el b/lisp/progmodes/f90.el
index aeb4ddee9ef..6264d3b7b82 100644
--- a/lisp/progmodes/f90.el
+++ b/lisp/progmodes/f90.el
@@ -342,8 +342,10 @@ The options are 'downcase-word, 'upcase-word, 'capitalize-word and nil."
                  "final" "generic" "import" "non_intrinsic" "non_overridable"
                  "nopass" "pass" "protected" "same_type_as" "value" "volatile"
                  ;; F2008.
+                 ;; FIXME f90-change-keywords does not work right if
+                 ;; there are spaces.
                  "contiguous" "submodule" "concurrent" "codimension"
-                 "sync all" "sync memory" "critical" "image_index"
+                 "sync all" "sync memory" "critical" "image_index" "error stop"
                  ))
    "\\_>")
   "Regexp used by the function `f90-change-keywords'.")
@@ -417,6 +419,8 @@ The options are 'downcase-word, 'upcase-word, 'capitalize-word and nil."
              "norm2" "parity" "findloc" "is_contiguous"
              "sync images" "lock" "unlock" "image_index"
              "lcobound" "ucobound" "num_images" "this_image"
+             "acosh" "asinh" "atanh"
+             "atomic_define" "atomic_ref" "execute_command_line"
              ;; F2008 iso_fortran_env module.
              "compiler_options" "compiler_version"
              ;; F2008 iso_c_binding module.
@@ -649,7 +653,8 @@ logical\\|double[ \t]*precision\\|type[ \t]*(\\(?:\\sw\\|\\s_\\)+)\\|none\\)[ \t
       (1 font-lock-keyword-face) (2 font-lock-constant-face nil t))
     "\\_<else\\([ \t]*if\\|where\\)?\\_>"
     '("\\(&\\)[ \t]*\\(!\\|$\\)"  (1 font-lock-keyword-face))
-    "\\_<\\(then\\|continue\\|format\\|include\\|stop\\|return\\)\\_>"
+    "\\_<\\(then\\|continue\\|format\\|include\\|\\(?:error[ \t]+\\)?stop\\|\
+return\\)\\_>"
     '("\\_<\\(exit\\|cycle\\)[ \t]*\\(\\(?:\\sw\\|\\s_\\)+\\)?\\_>"
       (1 font-lock-keyword-face) (2 font-lock-constant-face nil t))
     '("\\_<\\(case\\)[ \t]*\\(default\\|(\\)" . 1)
@@ -1629,7 +1634,10 @@ Return (TYPE NAME), or nil if not found."
                 (re-search-backward f90-program-block-re nil 'move))
       (beginning-of-line)
       (skip-chars-forward " \t0-9")
-      (cond ((setq matching-beg (f90-looking-at-program-block-start))
+      ;; Check if in string in case using non-standard feature where
+      ;; continued strings do not need "&" at start of continuations.
+      (cond ((f90-in-string))
+            ((setq matching-beg (f90-looking-at-program-block-start))
              (setq count (1- count)))
             ((f90-looking-at-program-block-end)
              (setq count (1+ count)))))
@@ -1654,7 +1662,8 @@ Return (TYPE NAME), or nil if not found."
                 (re-search-forward f90-program-block-re nil 'move))
       (beginning-of-line)
       (skip-chars-forward " \t0-9")
-      (cond ((f90-looking-at-program-block-start)
+      (cond ((f90-in-string))
+            ((f90-looking-at-program-block-start)
              (setq count (1+ count)))
             ((setq matching-end (f90-looking-at-program-block-end))
              (setq count (1- count))))
@@ -2194,8 +2203,12 @@ Leave point at the end of line."
         (end-point (point))
         (case-fold-search t)
         matching-beg beg-name end-name beg-block end-block end-struct)
+    ;; Check if in string in case using non-standard feature where
+    ;; continued strings do not need "&" at start of continuations.
     (when (save-excursion (beginning-of-line) (skip-chars-forward " \t0-9")
-                          (setq end-struct (f90-looking-at-program-block-end)))
+                          (unless (f90-in-string)
+                            (setq end-struct
+                                  (f90-looking-at-program-block-end))))
       (setq end-block (car end-struct)
             end-name  (cadr end-struct))
       (save-excursion
@@ -2338,6 +2351,8 @@ CHANGE-WORD should be one of 'upcase-word, 'downcase-word, 'capitalize-word."
                             (skip-chars-forward " \t0-9")
                             (looking-at "#"))))
               (setq ref-point (point)
+                    ;; FIXME this does not work for constructs with
+                    ;; embedded space, eg "sync all".
                     back-point (save-excursion (backward-word 1) (point))
                     saveword (buffer-substring back-point ref-point))
               (funcall change-word -1)
diff --git a/lisp/progmodes/gdb-mi.el b/lisp/progmodes/gdb-mi.el
index 27846ede332..486d67297a9 100644
--- a/lisp/progmodes/gdb-mi.el
+++ b/lisp/progmodes/gdb-mi.el
@@ -1629,9 +1629,19 @@ this trigger is subscribed to `gdb-buf-publisher' and called with
   :syntax-table nil :abbrev-table nil
   (make-comint-in-buffer "gdb-inferior" (current-buffer) nil))
 
+(defcustom gdb-display-io-nopopup nil
+  "When non-nil, and the 'gdb-inferior-io buffer is buried, don't pop it up."
+  :type 'boolean
+  :group 'gdb
+  :version "25.1")
+
 (defun gdb-inferior-filter (proc string)
   (unless (string-equal string "")
-    (gdb-display-buffer (gdb-get-buffer-create 'gdb-inferior-io)))
+    (let (buf)
+      (unless (and gdb-display-io-nopopup
+                   (setq buf (gdb-get-buffer 'gdb-inferior-io))
+                   (null (get-buffer-window buf)))
+        (gdb-display-buffer (gdb-get-buffer-create 'gdb-inferior-io)))))
   (with-current-buffer (gdb-get-buffer-create 'gdb-inferior-io)
     (comint-output-filter proc string)))
 
diff --git a/lisp/progmodes/gud.el b/lisp/progmodes/gud.el
index 42c5b20a7b8..9ab0667b5ba 100644
--- a/lisp/progmodes/gud.el
+++ b/lisp/progmodes/gud.el
@@ -1,4 +1,4 @@
-;;; gud.el --- Grand Unified Debugger mode for running GDB and other debuggers
+;;; gud.el --- Grand Unified Debugger mode for running GDB and other debuggers  -*- lexical-binding:t -*-
 
 ;; Copyright (C) 1992-1996, 1998, 2000-2015 Free Software Foundation,
 ;; Inc.
@@ -2813,7 +2813,7 @@ Obeying it means displaying in another window the specified file and line."
             (gud-find-file true-file)))
          (window (and buffer
                       (or (get-buffer-window buffer)
-                          (display-buffer buffer))))
+                          (display-buffer buffer '(nil (inhibit-same-window . t))))))
          (pos))
     (when buffer
       (with-current-buffer buffer
diff --git a/lisp/progmodes/js.el b/lisp/progmodes/js.el
index c25e52cdc6a..62f19f42df1 100644
--- a/lisp/progmodes/js.el
+++ b/lisp/progmodes/js.el
@@ -509,6 +509,48 @@ getting timeout messages."
   :type 'integer
   :group 'js)
 
+(defcustom js-indent-first-init nil
+  "Non-nil means specially indent the first variable declaration's initializer.
+Normally, the first declaration's initializer is unindented, and
+subsequent declarations have their identifiers aligned with it:
+
+  var o = {
+      foo: 3
+  };
+
+  var o = {
+      foo: 3
+  },
+      bar = 2;
+
+If this option has the value t, indent the first declaration's
+initializer by an additional level:
+
+  var o = {
+          foo: 3
+      };
+
+  var o = {
+          foo: 3
+      },
+      bar = 2;
+
+If this option has the value `dynamic', if there is only one declaration,
+don't indent the first one's initializer; otherwise, indent it.
+
+  var o = {
+      foo: 3
+  };
+
+  var o = {
+          foo: 3
+      },
+      bar = 2;"
+  :version "25.1"
+  :type '(choice (const nil) (const t) (const dynamic))
+  :safe 'symbolp
+  :group 'js)
+
 ;;; KeyMap
 
 (defvar js-mode-map
@@ -534,6 +576,7 @@ getting timeout messages."
   (let ((table (make-syntax-table)))
     (c-populate-syntax-table table)
     (modify-syntax-entry ?$ "_" table)
+    (modify-syntax-entry ?` "\"" table)
     table)
   "Syntax table for `js-mode'.")
 
@@ -1857,6 +1900,36 @@ In particular, return the buffer position of the first `for' kwd."
       (goto-char for-kwd)
       (current-column))))
 
+(defun js--maybe-goto-declaration-keyword-end (parse-status)
+  "Helper function for `js--proper-indentation'.
+Depending on the value of `js-indent-first-init', move
+point to the end of a variable declaration keyword so that
+indentation is aligned to that column."
+  (cond
+   ((eq js-indent-first-init t)
+    (when (looking-at js--declaration-keyword-re)
+      (goto-char (1+ (match-end 0)))))
+   ((eq js-indent-first-init 'dynamic)
+    (let ((bracket (nth 1 parse-status))
+          declaration-keyword-end
+          at-closing-bracket-p
+          comma-p)
+      (when (looking-at js--declaration-keyword-re)
+        (setq declaration-keyword-end (match-end 0))
+        (save-excursion
+          (goto-char bracket)
+          (setq at-closing-bracket-p
+                (condition-case nil
+                    (progn
+                      (forward-sexp)
+                      t)
+                  (error nil)))
+          (when at-closing-bracket-p
+            (while (forward-comment 1))
+            (setq comma-p (looking-at-p ","))))
+        (when comma-p
+          (goto-char (1+ declaration-keyword-end))))))))
+
 (defun js--proper-indentation (parse-status)
   "Return the proper indentation for the current line."
   (save-excursion
@@ -1890,6 +1963,7 @@ In particular, return the buffer position of the first `for' kwd."
                    (skip-syntax-backward " ")
                    (when (eq (char-before) ?\)) (backward-list))
                    (back-to-indentation)
+                   (js--maybe-goto-declaration-keyword-end parse-status)
                    (let* ((in-switch-p (unless same-indent-p
                                          (looking-at "\\_<switch\\_>")))
                           (same-indent-p (or same-indent-p
@@ -1928,8 +2002,9 @@ In particular, return the buffer position of the first `for' kwd."
   (let* ((parse-status
           (save-excursion (syntax-ppss (point-at-bol))))
          (offset (- (point) (save-excursion (back-to-indentation) (point)))))
-    (indent-line-to (js--proper-indentation parse-status))
-    (when (> offset 0) (forward-char offset))))
+    (unless (nth 3 parse-status)
+      (indent-line-to (js--proper-indentation parse-status))
+      (when (> offset 0) (forward-char offset)))))
 
 ;;; Filling
 
diff --git a/lisp/progmodes/python.el b/lisp/progmodes/python.el
index d340550a017..67b44aa1bbe 100644
--- a/lisp/progmodes/python.el
+++ b/lisp/progmodes/python.el
@@ -4,7 +4,7 @@
 
 ;; Author: Fabián E. Gallina <fabian@anue.biz>
 ;; URL: https://github.com/fgallina/python.el
-;; Version: 0.24.4
+;; Version: 0.24.5
 ;; Maintainer: emacs-devel@gnu.org
 ;; Created: Jul 2010
 ;; Keywords: languages
@@ -696,6 +696,12 @@ It makes underscores and dots word constituent chars.")
   :group 'python
   :safe 'booleanp)
 
+(defcustom python-indent-guess-indent-offset-verbose t
+  "Non-nil means to emit a warning when indentation guessing fails."
+  :type 'boolean
+  :group 'python
+  :safe' booleanp)
+
 (defcustom python-indent-trigger-commands
   '(indent-for-tab-command yas-expand yas/expand)
   "Commands that might trigger a `python-indent-line' call."
@@ -766,8 +772,9 @@ work on `python-indent-calculate-indentation' instead."
                  (current-indentation))))
           (if (and indentation (not (zerop indentation)))
               (set (make-local-variable 'python-indent-offset) indentation)
-            (message "Can't guess python-indent-offset, using defaults: %s"
-                     python-indent-offset)))))))
+            (when python-indent-guess-indent-offset-verbose
+              (message "Can't guess python-indent-offset, using defaults: %s"
+                       python-indent-offset))))))))
 
 (defun python-indent-context ()
   "Get information about the current indentation context.
@@ -843,15 +850,6 @@ keyword
        ;; Beginning of buffer.
        ((= (line-number-at-pos) 1)
         (cons :no-indent 0))
-       ;; Comment continuation (maybe).
-       ((save-excursion
-          (when (and
-                 (or
-                  (python-info-current-line-comment-p)
-                  (python-info-current-line-empty-p))
-                 (forward-comment -1)
-                 (python-info-current-line-comment-p))
-            (cons :after-comment (point)))))
        ;; Inside a string.
        ((let ((start (python-syntax-context 'string ppss)))
           (when start
@@ -963,28 +961,29 @@ keyword
        ((let ((start (python-info-dedenter-statement-p)))
           (when start
             (cons :at-dedenter-block-start start))))
-       ;; After normal line.
-       ((let ((start (save-excursion
-                       (back-to-indentation)
-                       (skip-chars-backward " \t\n")
-                       (python-nav-beginning-of-statement)
-                       (point))))
-          (when start
-            (if (save-excursion
-                  (python-util-forward-comment -1)
-                  (python-nav-beginning-of-statement)
-                  (looking-at (python-rx block-ender)))
-                (cons :after-block-end start)
-              (cons :after-line start)))))
-       ;; Default case: do not indent.
-       (t (cons :no-indent 0))))))
+       ;; After normal line, comment or ender (default case).
+       ((save-excursion
+          (back-to-indentation)
+          (skip-chars-backward " \t\n")
+          (python-nav-beginning-of-statement)
+          (cons
+           (cond ((python-info-current-line-comment-p)
+                  :after-comment)
+                 ((save-excursion
+                    (goto-char (line-end-position))
+                    (python-util-forward-comment -1)
+                    (python-nav-beginning-of-statement)
+                    (looking-at (python-rx block-ender)))
+                  :after-block-end)
+                 (t :after-line))
+           (point))))))))
 
 (defun python-indent--calculate-indentation ()
   "Internal implementation of `python-indent-calculate-indentation'.
 May return an integer for the maximum possible indentation at
 current context or a list of integers.  The latter case is only
 happening for :at-dedenter-block-start context since the
-possibilities can be narrowed to especific indentation points."
+possibilities can be narrowed to specific indentation points."
   (save-restriction
     (widen)
     (save-excursion
@@ -1068,12 +1067,14 @@ minimum."
          (levels (python-indent--calculate-levels indentation)))
     (if previous
         (python-indent--previous-level levels (current-indentation))
-      (apply #'max levels))))
+      (if levels
+          (apply #'max levels)
+        0))))
 
 (defun python-indent-line (&optional previous)
   "Internal implementation of `python-indent-line-function'.
 Use the PREVIOUS level when argument is non-nil, otherwise indent
-to the maxium available level.  When indentation is the minimum
+to the maximum available level.  When indentation is the minimum
 possible and PREVIOUS is non-nil, cycle back to the maximum
 level."
   (let ((follow-indentation-p
@@ -1108,9 +1109,7 @@ indentation levels from right to left."
   (interactive "*")
   (when (and (not (bolp))
            (not (python-syntax-comment-or-string-p))
-           (= (+ (line-beginning-position)
-                 (current-indentation))
-              (point)))
+           (= (current-indentation) (current-column)))
       (python-indent-line t)
       t))
 
@@ -2295,16 +2294,15 @@ Signals an error if no shell buffer is available for current buffer."
       (let ((process-name
              (process-name (get-buffer-process (current-buffer)))))
         (generate-new-buffer
-         (format "*%s-font-lock*" process-name))))))
+         (format " *%s-font-lock*" process-name))))))
 
 (defun python-shell-font-lock-kill-buffer ()
   "Kill the font-lock buffer safely."
-  (python-shell-with-shell-buffer
-    (when (and python-shell--font-lock-buffer
-               (buffer-live-p python-shell--font-lock-buffer))
-      (kill-buffer python-shell--font-lock-buffer)
-      (when (derived-mode-p 'inferior-python-mode)
-        (setq python-shell--font-lock-buffer nil)))))
+  (when (and python-shell--font-lock-buffer
+             (buffer-live-p python-shell--font-lock-buffer))
+    (kill-buffer python-shell--font-lock-buffer)
+    (when (derived-mode-p 'inferior-python-mode)
+      (setq python-shell--font-lock-buffer nil))))
 
 (defmacro python-shell-font-lock-with-font-lock-buffer (&rest body)
   "Execute the forms in BODY in the font-lock buffer.
@@ -2318,6 +2316,8 @@ also `with-current-buffer'."
          (setq python-shell--font-lock-buffer
                (python-shell-font-lock-get-or-create-buffer)))
        (set-buffer python-shell--font-lock-buffer)
+       (when (not font-lock-mode)
+         (font-lock-mode 1))
        (set (make-local-variable 'delay-mode-hooks) t)
        (let ((python-indent-guess-indent-offset nil))
          (when (not (derived-mode-p 'python-mode))
@@ -2331,57 +2331,66 @@ goes wrong and syntax highlighting in the shell gets messed up."
   (interactive)
   (python-shell-with-shell-buffer
     (python-shell-font-lock-with-font-lock-buffer
-      (delete-region (point-min) (point-max)))))
+      (erase-buffer))))
 
 (defun python-shell-font-lock-comint-output-filter-function (output)
   "Clean up the font-lock buffer after any OUTPUT."
-  (when (and (not (string= "" output))
-             ;; Is end of output and is not just a prompt.
-             (not (member
-                   (python-shell-comint-end-of-output-p
-                    (ansi-color-filter-apply output))
-                   '(nil 0))))
-    ;; If output is other than an input prompt then "real" output has
-    ;; been received and the font-lock buffer must be cleaned up.
-    (python-shell-font-lock-cleanup-buffer))
+  (if (and (not (string= "" output))
+           ;; Is end of output and is not just a prompt.
+           (not (member
+                 (python-shell-comint-end-of-output-p
+                  (ansi-color-filter-apply output))
+                 '(nil 0))))
+      ;; If output is other than an input prompt then "real" output has
+      ;; been received and the font-lock buffer must be cleaned up.
+      (python-shell-font-lock-cleanup-buffer)
+    ;; Otherwise just add a newline.
+    (python-shell-font-lock-with-font-lock-buffer
+      (goto-char (point-max))
+      (newline)))
   output)
 
 (defun python-shell-font-lock-post-command-hook ()
   "Fontifies current line in shell buffer."
-  (if (eq this-command 'comint-send-input)
-      ;; Add a newline when user sends input as this may be a block.
-      (python-shell-font-lock-with-font-lock-buffer
-        (goto-char (line-end-position))
-        (newline))
-    (when (and (python-util-comint-last-prompt)
-               (> (point) (cdr (python-util-comint-last-prompt))))
-      (let ((input (buffer-substring-no-properties
-                    (cdr (python-util-comint-last-prompt)) (point-max)))
-            (old-input (python-shell-font-lock-with-font-lock-buffer
-                         (buffer-substring-no-properties
-                          (line-beginning-position) (point-max))))
-            (current-point (point))
-            (buffer-undo-list t))
-        ;; When input hasn't changed, do nothing.
-        (when (not (string= input old-input))
-          (delete-region (cdr (python-util-comint-last-prompt)) (point-max))
-          (insert
-           (python-shell-font-lock-with-font-lock-buffer
-             (delete-region (line-beginning-position)
-                            (line-end-position))
-             (insert input)
-             ;; Ensure buffer is fontified, keeping it
-             ;; compatible with Emacs < 24.4.
-             (if (fboundp 'font-lock-ensure)
-                 (funcall 'font-lock-ensure)
-               (font-lock-default-fontify-buffer))
-             ;; Replace FACE text properties with FONT-LOCK-FACE so
-             ;; they are not overwritten by comint buffer's font lock.
-             (python-util-text-properties-replace-name
-              'face 'font-lock-face)
-             (buffer-substring (line-beginning-position)
-                               (line-end-position))))
-          (goto-char current-point))))))
+  (let ((prompt-end (cdr (python-util-comint-last-prompt))))
+    (when (and prompt-end (> (point) prompt-end)
+               (process-live-p (get-buffer-process (current-buffer))))
+      (let* ((input (buffer-substring-no-properties
+                     prompt-end (point-max)))
+             (deactivate-mark nil)
+             (start-pos prompt-end)
+             (buffer-undo-list t)
+             (font-lock-buffer-pos nil)
+             (replacement
+              (python-shell-font-lock-with-font-lock-buffer
+                (delete-region (line-beginning-position)
+                               (point-max))
+                (setq font-lock-buffer-pos (point))
+                (insert input)
+                ;; Ensure buffer is fontified, keeping it
+                ;; compatible with Emacs < 24.4.
+                (if (fboundp 'font-lock-ensure)
+                    (funcall 'font-lock-ensure)
+                  (font-lock-default-fontify-buffer))
+                (buffer-substring font-lock-buffer-pos
+                                  (point-max))))
+             (replacement-length (length replacement))
+             (i 0))
+        ;; Inject text properties to get input fontified.
+        (while (not (= i replacement-length))
+          (let* ((plist (text-properties-at i replacement))
+                 (next-change (or (next-property-change i replacement)
+                                  replacement-length))
+                 (plist (let ((face (plist-get plist 'face)))
+                          (if (not face)
+                              plist
+                            ;; Replace FACE text properties with
+                            ;; FONT-LOCK-FACE so input is fontified.
+                            (plist-put plist 'face nil)
+                            (plist-put plist 'font-lock-face face)))))
+            (set-text-properties
+             (+ start-pos i) (+ start-pos next-change) plist)
+            (setq i next-change)))))))
 
 (defun python-shell-font-lock-turn-on (&optional msg)
   "Turn on shell font-lock.
@@ -2414,7 +2423,7 @@ With argument MSG show deactivation message."
        '(face nil font-lock-face nil)))
     (set (make-local-variable 'python-shell--font-lock-buffer) nil)
     (remove-hook 'post-command-hook
-                 #'python-shell-font-lock-post-command-hook'local)
+                 #'python-shell-font-lock-post-command-hook 'local)
     (remove-hook 'kill-buffer-hook
                  #'python-shell-font-lock-kill-buffer 'local)
     (remove-hook 'comint-output-filter-functions
@@ -3148,67 +3157,68 @@ With argument MSG show activation/deactivation message."
   "Get completions using native readline for PROCESS.
 When IMPORT is non-nil takes precedence over INPUT for
 completion."
-  (when (and python-shell-completion-native-enable
-             (python-util-comint-last-prompt)
-             (>= (point) (cdr (python-util-comint-last-prompt))))
-    (let* ((input (or import input))
-           (original-filter-fn (process-filter process))
-           (redirect-buffer (get-buffer-create
-                             python-shell-completion-native-redirect-buffer))
-           (separators (python-rx
-                        (or whitespace open-paren close-paren)))
-           (trigger "\t\t\t")
-           (new-input (concat input trigger))
-           (input-length
-            (save-excursion
-              (+ (- (point-max) (comint-bol)) (length new-input))))
-           (delete-line-command (make-string input-length ?\b))
-           (input-to-send (concat new-input delete-line-command)))
-      ;; Ensure restoring the process filter, even if the user quits
-      ;; or there's some other error.
-      (unwind-protect
-          (with-current-buffer redirect-buffer
-            ;; Cleanup the redirect buffer
-            (delete-region (point-min) (point-max))
-            ;; Mimic `comint-redirect-send-command', unfortunately it
-            ;; can't be used here because it expects a newline in the
-            ;; command and that's exactly what we are trying to avoid.
-            (let ((comint-redirect-echo-input nil)
-                  (comint-redirect-verbose nil)
-                  (comint-redirect-perform-sanity-check nil)
-                  (comint-redirect-insert-matching-regexp nil)
-                  ;; Feed it some regex that will never match.
-                  (comint-redirect-finished-regexp "^\\'$")
-                  (comint-redirect-output-buffer redirect-buffer))
-              ;; Compatibility with Emacs 24.x.  Comint changed and
-              ;; now `comint-redirect-filter' gets 3 args.  This
-              ;; checks which version of `comint-redirect-filter' is
-              ;; in use based on its args and uses `apply-partially'
-              ;; to make it up for the 3 args case.
-              (if (= (length
-                      (help-function-arglist 'comint-redirect-filter)) 3)
-                  (set-process-filter
-                   process (apply-partially
-                            #'comint-redirect-filter original-filter-fn))
-                (set-process-filter process #'comint-redirect-filter))
-              (process-send-string process input-to-send)
-              (accept-process-output
-               process
-               python-shell-completion-native-output-timeout)
-              ;; XXX: can't use `python-shell-accept-process-output'
-              ;; here because there are no guarantees on how output
-              ;; ends.  The workaround here is to call
-              ;; `accept-process-output' until we don't find anything
-              ;; else to accept.
-              (while (accept-process-output
-                      process
-                      python-shell-completion-native-output-timeout))
-              (cl-remove-duplicates
-               (split-string
-                (buffer-substring-no-properties
-                 (point-min) (point-max))
-                separators t))))
-        (set-process-filter process original-filter-fn)))))
+  (with-current-buffer (process-buffer process)
+    (when (and python-shell-completion-native-enable
+               (python-util-comint-last-prompt)
+               (>= (point) (cdr (python-util-comint-last-prompt))))
+      (let* ((input (or import input))
+             (original-filter-fn (process-filter process))
+             (redirect-buffer (get-buffer-create
+                               python-shell-completion-native-redirect-buffer))
+             (separators (python-rx
+                          (or whitespace open-paren close-paren)))
+             (trigger "\t\t\t")
+             (new-input (concat input trigger))
+             (input-length
+              (save-excursion
+                (+ (- (point-max) (comint-bol)) (length new-input))))
+             (delete-line-command (make-string input-length ?\b))
+             (input-to-send (concat new-input delete-line-command)))
+        ;; Ensure restoring the process filter, even if the user quits
+        ;; or there's some other error.
+        (unwind-protect
+            (with-current-buffer redirect-buffer
+              ;; Cleanup the redirect buffer
+              (delete-region (point-min) (point-max))
+              ;; Mimic `comint-redirect-send-command', unfortunately it
+              ;; can't be used here because it expects a newline in the
+              ;; command and that's exactly what we are trying to avoid.
+              (let ((comint-redirect-echo-input nil)
+                    (comint-redirect-verbose nil)
+                    (comint-redirect-perform-sanity-check nil)
+                    (comint-redirect-insert-matching-regexp nil)
+                    ;; Feed it some regex that will never match.
+                    (comint-redirect-finished-regexp "^\\'$")
+                    (comint-redirect-output-buffer redirect-buffer))
+                ;; Compatibility with Emacs 24.x.  Comint changed and
+                ;; now `comint-redirect-filter' gets 3 args.  This
+                ;; checks which version of `comint-redirect-filter' is
+                ;; in use based on its args and uses `apply-partially'
+                ;; to make it up for the 3 args case.
+                (if (= (length
+                        (help-function-arglist 'comint-redirect-filter)) 3)
+                    (set-process-filter
+                     process (apply-partially
+                              #'comint-redirect-filter original-filter-fn))
+                  (set-process-filter process #'comint-redirect-filter))
+                (process-send-string process input-to-send)
+                (accept-process-output
+                 process
+                 python-shell-completion-native-output-timeout)
+                ;; XXX: can't use `python-shell-accept-process-output'
+                ;; here because there are no guarantees on how output
+                ;; ends.  The workaround here is to call
+                ;; `accept-process-output' until we don't find anything
+                ;; else to accept.
+                (while (accept-process-output
+                        process
+                        python-shell-completion-native-output-timeout))
+                (cl-remove-duplicates
+                 (split-string
+                  (buffer-substring-no-properties
+                   (point-min) (point-max))
+                  separators t))))
+          (set-process-filter process original-filter-fn))))))
 
 (defun python-shell-completion-get-completions (process import input)
   "Do completion at point using PROCESS for IMPORT or INPUT.
@@ -3251,20 +3261,23 @@ completion."
 Optional argument PROCESS forces completions to be retrieved
 using that one instead of current buffer's process."
   (setq process (or process (get-buffer-process (current-buffer))))
-  (let* ((last-prompt-end (cdr (python-util-comint-last-prompt)))
+  (let* ((line-start (if (derived-mode-p 'inferior-python-mode)
+                         ;; Working on a shell buffer: use prompt end.
+                         (cdr (python-util-comint-last-prompt))
+                       (line-beginning-position)))
          (import-statement
           (when (string-match-p
                  (rx (* space) word-start (or "from" "import") word-end space)
-                 (buffer-substring-no-properties last-prompt-end (point)))
-            (buffer-substring-no-properties last-prompt-end (point))))
+                 (buffer-substring-no-properties line-start (point)))
+            (buffer-substring-no-properties line-start (point))))
          (start
           (save-excursion
             (if (not (re-search-backward
                       (python-rx
                        (or whitespace open-paren close-paren string-delimiter))
-                      last-prompt-end
+                      line-start
                       t 1))
-                last-prompt-end
+                line-start
               (forward-char (length (match-string-no-properties 0)))
               (point))))
          (end (point))
@@ -3847,8 +3860,10 @@ The skeleton will be bound to python-skeleton-NAME."
   :type 'string
   :group 'python)
 
-(defvar-local python-check-custom-command nil
+(defvar python-check-custom-command nil
   "Internal use.")
+;; XXX: Avoid `defvar-local' for compat with Emacs<24.3
+(make-variable-buffer-local 'python-check-custom-command)
 
 (defun python-check (command)
   "Check a Python file (default current buffer's file).
@@ -3917,15 +3932,29 @@ See `python-check-command' for the default."
   :type 'string
   :group 'python)
 
+(defun python-eldoc--get-symbol-at-point ()
+  "Get the current symbol for eldoc.
+Returns the current symbol handling point within arguments."
+  (save-excursion
+    (let ((start (python-syntax-context 'paren)))
+      (when start
+        (goto-char start))
+      (when (or start
+                (eobp)
+                (memq (char-syntax (char-after)) '(?\ ?-)))
+        ;; Try to adjust to closest symbol if not in one.
+        (python-util-forward-comment -1)))
+    (python-info-current-symbol t)))
+
 (defun python-eldoc--get-doc-at-point (&optional force-input force-process)
   "Internal implementation to get documentation at point.
-If not FORCE-INPUT is passed then what `python-info-current-symbol'
+If not FORCE-INPUT is passed then what `python-eldoc--get-symbol-at-point'
 returns will be used.  If not FORCE-PROCESS is passed what
 `python-shell-get-process' returns is used."
   (let ((process (or force-process (python-shell-get-process))))
     (when process
       (let ((input (or force-input
-                       (python-info-current-symbol t))))
+                       (python-eldoc--get-symbol-at-point))))
         (and input
              ;; Prevent resizing the echo area when iPython is
              ;; enabled.  Bug#18794.
@@ -3945,7 +3974,7 @@ inferior Python process is updated properly."
   "Get help on SYMBOL using `help'.
 Interactively, prompt for symbol."
   (interactive
-   (let ((symbol (python-info-current-symbol t))
+   (let ((symbol (python-eldoc--get-symbol-at-point))
          (enable-recursive-minibuffers t))
      (list (read-string (if symbol
                             (format "Describe symbol (default %s): " symbol)
@@ -3954,6 +3983,17 @@ Interactively, prompt for symbol."
   (message (python-eldoc--get-doc-at-point symbol)))
 
 
+;;; Hideshow
+
+(defun python-hideshow-forward-sexp-function (arg)
+  "Python specific `forward-sexp' function for `hs-minor-mode'.
+Argument ARG is ignored."
+  arg  ; Shut up, byte compiler.
+  (python-nav-end-of-defun)
+  (unless (python-info-current-line-empty-p)
+    (backward-char)))
+
+
 ;;; Imenu
 
 (defvar python-imenu-format-item-label-function
@@ -4573,23 +4613,6 @@ returned as is."
               n (1- n)))
       (reverse acc))))
 
-(defun python-util-text-properties-replace-name
-  (from to &optional start end)
-  "Replace properties named FROM to TO, keeping its value.
-Arguments START and END narrow the buffer region to work on."
-  (save-excursion
-    (goto-char (or start (point-min)))
-    (while (not (eobp))
-      (let ((plist (text-properties-at (point)))
-            (next-change (or (next-property-change (point) (current-buffer))
-                             (or end (point-max)))))
-        (when (plist-get plist from)
-          (let* ((face (plist-get plist from))
-                 (plist (plist-put plist from nil))
-                 (plist (plist-put plist to face)))
-            (set-text-properties (point) next-change plist (current-buffer))))
-        (goto-char next-change)))))
-
 (defun python-util-strip-string (string)
   "Strip STRING whitespace and newlines from end and beginning."
   (replace-regexp-in-string
@@ -4682,14 +4705,23 @@ Arguments START and END narrow the buffer region to work on."
                                                  (current-column))))
          (^ '(- (1+ (current-indentation))))))
 
-  (add-function :before-until (local 'eldoc-documentation-function)
-                #'python-eldoc-function)
-
-  (add-to-list 'hs-special-modes-alist
-               `(python-mode "^\\s-*\\(?:def\\|class\\)\\>" nil "#"
-                             ,(lambda (_arg)
-                                (python-nav-end-of-defun))
-                             nil))
+  (if (null eldoc-documentation-function)
+      ;; Emacs<25
+      (set (make-local-variable 'eldoc-documentation-function)
+           #'python-eldoc-function)
+    (add-function :before-until (local 'eldoc-documentation-function)
+                  #'python-eldoc-function))
+
+  (add-to-list
+   'hs-special-modes-alist
+   `(python-mode
+     "\\s-*\\(?:def\\|class\\)\\>"
+     ;; Use the empty string as end regexp so it doesn't default to
+     ;; "\\s)".  This way parens at end of defun are properly hidden.
+     ""
+     "#"
+     python-hideshow-forward-sexp-function
+     nil))
 
   (set (make-local-variable 'outline-regexp)
        (python-rx (* space) block-start))
diff --git a/lisp/progmodes/ruby-mode.el b/lisp/progmodes/ruby-mode.el
index d1e42ca3443..f2fb95ce59a 100644
--- a/lisp/progmodes/ruby-mode.el
+++ b/lisp/progmodes/ruby-mode.el
@@ -1817,7 +1817,7 @@ 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.
-     "\\(^\\|[[=(,~;<>]"
+     "\\(^\\|[[{|=(,~;<>!]"
      ;; Distinguish ternary operator tokens.
      ;; FIXME: They don't really have to be separated with spaces.
      "\\|[?:] "
@@ -2053,8 +2053,9 @@ See `font-lock-syntax-table'.")
           "rescue"
           "retry"
           "return"
-          "then"
+          "self"
           "super"
+          "then"
           "unless"
           "undef"
           "until"
@@ -2071,10 +2072,10 @@ See `font-lock-syntax-table'.")
           "at_exit"
           "autoload"
           "autoload?"
+          "callcc"
           "catch"
           "eval"
           "exec"
-          "fork"
           "format"
           "lambda"
           "load"
@@ -2092,7 +2093,10 @@ See `font-lock-syntax-table'.")
           "sprintf"
           "syscall"
           "system"
+          "throw"
+          "trace_var"
           "trap"
+          "untrace_var"
           "warn"
           ;; keyword-like private methods on Module
           "alias_method"
@@ -2122,13 +2126,15 @@ See `font-lock-syntax-table'.")
           "__dir__"
           "__method__"
           "abort"
-          "at_exit"
           "binding"
           "block_given?"
           "caller"
           "exit"
           "exit!"
           "fail"
+          "fork"
+          "global_variables"
+          "local_variables"
           "private"
           "protected"
           "public"
@@ -2137,8 +2143,7 @@ See `font-lock-syntax-table'.")
           "readline"
           "readlines"
           "sleep"
-          "srand"
-          "throw")
+          "srand")
         'symbols))
      (1 font-lock-builtin-face))
     ;; Here-doc beginnings.
@@ -2149,13 +2154,21 @@ See `font-lock-syntax-table'.")
     "\\_<\\(?:BEGIN\\|END\\)\\_>\\|^__END__$"
     ;; Variables.
     (,(concat ruby-font-lock-keyword-beg-re
-              "\\_<\\(nil\\|self\\|true\\|false\\)\\_>")
-     1 font-lock-variable-name-face)
+              "\\_<\\(nil\\|true\\|false\\)\\_>")
+     1 font-lock-constant-face)
     ;; Keywords that evaluate to certain values.
     ("\\_<__\\(?:LINE\\|ENCODING\\|FILE\\)__\\_>"
      (0 font-lock-builtin-face))
-    ;; Symbols.
-    ("\\(^\\|[^:]\\)\\(:\\([-+~]@?\\|[/%&|^`]\\|\\*\\*?\\|<\\(<\\|=>?\\)?\\|>[>=]?\\|===?\\|=~\\|![~=]?\\|\\[\\]=?\\|@?\\(\\w\\|_\\)+\\([!?=]\\|\\b_*\\)\\|#{[^}\n\\\\]*\\(\\\\.[^}\n\\\\]*\\)*}\\)\\)"
+    ;; Symbols with symbol characters.
+    ("\\(^\\|[^:]\\)\\(:@?\\(?:\\w\\|_\\)+\\)\\([!?=]\\)?"
+     (2 font-lock-constant-face)
+     (3 (unless (and (eq (char-before (match-end 3)) ?=)
+                     (eq (char-after (match-end 3)) ?>))
+          ;; bug#18466
+          font-lock-constant-face)
+        nil t))
+    ;; Symbols with special characters.
+    ("\\(^\\|[^:]\\)\\(:\\([-+~]@?\\|[/%&|^`]\\|\\*\\*?\\|<\\(<\\|=>?\\)?\\|>[>=]?\\|===?\\|=~\\|![~=]?\\|\\[\\]=?\\|#{[^}\n\\\\]*\\(\\\\.[^}\n\\\\]*\\)*}\\)\\)"
      2 font-lock-constant-face)
     ;; Special globals.
     (,(concat "\\$\\(?:[:\"!@;,/\\._><\\$?~=*&`'+0-9]\\|-[0adFiIlpvw]\\|"
diff --git a/lisp/progmodes/sql.el b/lisp/progmodes/sql.el
index 2ed3a745bb0..3800cfb6b15 100644
--- a/lisp/progmodes/sql.el
+++ b/lisp/progmodes/sql.el
@@ -4,7 +4,7 @@
 
 ;; Author: Alex Schroeder <alex@gnu.org>
 ;; Maintainer: Michael Mauger <michael@mauger.com>
-;; Version: 3.4
+;; Version: 3.5
 ;; Keywords: comm languages processes
 ;; URL: http://savannah.gnu.org/projects/emacs/
 
@@ -3296,13 +3296,13 @@ Allows the suppression of continuation prompts.")
 (defun sql-starts-with-prompt-re ()
   "Anchor the prompt expression at the beginning of the output line.
 Remove the start of line regexp."
-  (replace-regexp-in-string "\\^" "\\\\`" comint-prompt-regexp))
+  (concat "\\`" comint-prompt-regexp))
 
 (defun sql-ends-with-prompt-re ()
   "Anchor the prompt expression at the end of the output line.
-Remove the start of line regexp from the prompt expression since
-it may not follow newline characters in the output line."
-  (concat (replace-regexp-in-string "\\^" "" sql-prompt-regexp) "\\'"))
+Match a SQL prompt or a password prompt."
+  (concat "\\(?:\\(?:" sql-prompt-regexp "\\)\\|"
+          "\\(?:" comint-password-prompt-regexp "\\)\\)\\'"))
 
 (defun sql-interactive-remove-continuation-prompt (oline)
   "Strip out continuation prompts out of the OLINE.
@@ -3321,7 +3321,17 @@ to the next chunk to properly match the broken-up prompt.
 If the filter gets confused, it should reset and stop filtering
 to avoid deleting non-prompt output."
 
-  (when comint-prompt-regexp
+  ;; continue gathering lines of text iff
+  ;;  + we know what a prompt looks like, and
+  ;;  + there is held text, or
+  ;;  + there are continuation prompt yet to come, or
+  ;;  + not just a prompt string
+  (when (and comint-prompt-regexp
+             (or (> (length (or sql-preoutput-hold "")) 0)
+                 (> (or sql-output-newline-count 0) 0)
+                 (not (or (string-match sql-prompt-regexp oline)
+                          (string-match sql-prompt-cont-regexp oline)))))
+
     (save-match-data
       (let (prompt-found last-nl)
 
@@ -3357,16 +3367,19 @@ to avoid deleting non-prompt output."
                 sql-preoutput-hold ""))
 
         ;; Break up output by physical lines if we haven't hit the final prompt
-        (unless (and (not (string= oline ""))
-                     (string-match (sql-ends-with-prompt-re) oline)
-                     (>= (match-end 0) (length oline)))
-          (setq last-nl 0)
-          (while (string-match "\n" oline last-nl)
-            (setq last-nl (match-end 0)))
-          (setq sql-preoutput-hold (concat (substring oline last-nl)
-                                           sql-preoutput-hold)
-                oline (substring oline 0 last-nl))))))
-   oline)
+        (let ((end-re (sql-ends-with-prompt-re)))
+          (unless (and (not (string= oline ""))
+                       (string-match end-re oline)
+                       (>= (match-end 0) (length oline)))
+            ;; Find everything upto the last nl
+            (setq last-nl 0)
+            (while (string-match "\n" oline last-nl)
+              (setq last-nl (match-end 0)))
+            ;; Hold after the last nl, return upto last nl
+            (setq sql-preoutput-hold (concat (substring oline last-nl)
+                                             sql-preoutput-hold)
+                  oline (substring oline 0 last-nl)))))))
+  oline)
 
 ;;; Sending the region to the SQLi buffer.
 
diff --git a/lisp/progmodes/verilog-mode.el b/lisp/progmodes/verilog-mode.el
index 7b6f2d3a819..57206544b9b 100644
--- a/lisp/progmodes/verilog-mode.el
+++ b/lisp/progmodes/verilog-mode.el
@@ -123,7 +123,7 @@
 ;;; Code:
 
 ;; This variable will always hold the version number of the mode
-(defconst verilog-mode-version "2014-11-12-aa4b777-vpo"
+(defconst verilog-mode-version "2015-02-20-0d6420b-vpo"
   "Version of this Verilog mode.")
 (defconst verilog-mode-release-emacs t
   "If non-nil, this version of Verilog mode was released with Emacs itself.")
@@ -8419,7 +8419,6 @@ Return an array of [outputs inouts inputs wire reg assign const]."
   (defvar sigs-temp)
   ;; These are known to be from other packages and may not be defined
   (defvar diff-command nil)
-  (defvar vector-skip-list)
   ;; There are known to be from newer versions of Emacs
   (defvar create-lockfiles))
 
@@ -10884,7 +10883,7 @@ See the example in `verilog-auto-inout-modport'."
 (defvar vl-bits  nil "See `verilog-auto-inst'.") ; Prevent compile warning
 (defvar vl-mbits nil "See `verilog-auto-inst'.") ; Prevent compile warning
 
-(defun verilog-auto-inst-port (port-st indent-pt tpl-list tpl-num for-star par-values)
+(defun verilog-auto-inst-port (port-st indent-pt moddecls tpl-list tpl-num for-star par-values)
   "Print out an instantiation connection for this PORT-ST.
 Insert to INDENT-PT, use template TPL-LIST.
 @ are instantiation numbers, replaced with TPL-NUM.
@@ -10901,9 +10900,10 @@ If PAR-VALUES replace final strings with these parameter values."
          (vl-mbits (if (verilog-sig-multidim port-st)
                        (verilog-sig-multidim-string port-st) ""))
          (vl-bits (if (or verilog-auto-inst-vector
-                          (not (assoc port vector-skip-list))
+                          (not (assoc port (verilog-decls-get-signals moddecls)))
                           (not (equal (verilog-sig-bits port-st)
-                                      (verilog-sig-bits (assoc port vector-skip-list)))))
+                                      (verilog-sig-bits
+                                       (assoc port (verilog-decls-get-signals moddecls))))))
                       (or (verilog-sig-bits port-st) "")
                     ""))
          (case-fold-search nil)
@@ -10932,7 +10932,12 @@ If PAR-VALUES replace final strings with these parameter values."
                         (concat "/*" vl-mbits vl-bits "*/")
                       (concat vl-bits))
           tpl-net (concat port
-                          (if vl-modport (concat "." vl-modport) "")
+                          (if (and vl-modport
+                                   ;; .modport cannot be added if attachment is
+                                   ;; already declared as modport, VCS croaks
+                                   (let ((sig (assoc port (verilog-decls-get-interfaces moddecls))))
+                                     (not (and sig (verilog-sig-modport sig)))))
+                              (concat "." vl-modport) "")
                           dflt-bits))
     ;; Find template
     (cond (tpl-ass          ; Template of exact port name
@@ -11002,12 +11007,12 @@ If PAR-VALUES replace final strings with these parameter values."
 ;;(x "incom[@\"(+ (* 8 @) 7)\":@\"(* 8 @)\"]")
 ;;(x ".out (outgo[@\"(concat (+ (* 8 @) 7) \\\":\\\" ( * 8 @))\"]));")
 
-(defun verilog-auto-inst-port-list (sig-list indent-pt tpl-list tpl-num for-star par-values)
+(defun verilog-auto-inst-port-list (sig-list indent-pt moddecls tpl-list tpl-num for-star par-values)
   "For `verilog-auto-inst' print a list of ports using `verilog-auto-inst-port'."
   (when verilog-auto-inst-sort
     (setq sig-list (sort (copy-alist sig-list) `verilog-signals-sort-compare)))
   (mapc (lambda (port)
-          (verilog-auto-inst-port port indent-pt
+          (verilog-auto-inst-port port indent-pt moddecls
                                   tpl-list tpl-num for-star par-values))
         sig-list))
 
@@ -11366,8 +11371,6 @@ For more information see the \\[verilog-faq] and forums at URL
                                           (+ 16 (* 8 (/ (+ indent-pt 7) 8)))))
            (modi (verilog-modi-current))
            (moddecls (verilog-modi-get-decls modi))
-           (vector-skip-list (unless verilog-auto-inst-vector
-                               (verilog-decls-get-signals moddecls)))
            submod submodi submoddecls
            inst skip-pins tpl-list tpl-num did-first par-values)
 
@@ -11409,7 +11412,7 @@ For more information see the \\[verilog-faq] and forums at URL
             (when (not did-first) (verilog-auto-inst-first) (setq did-first t))
             ;; Note these are searched for in verilog-read-sub-decls.
             (verilog-insert-indent "// Interfaced\n")
-            (verilog-auto-inst-port-list sig-list indent-pt
+            (verilog-auto-inst-port-list sig-list indent-pt moddecls
                                          tpl-list tpl-num for-star par-values)))
         (let ((sig-list (verilog-signals-not-in
                          (verilog-decls-get-interfaces submoddecls)
@@ -11419,7 +11422,7 @@ For more information see the \\[verilog-faq] and forums at URL
             (when (not did-first) (verilog-auto-inst-first) (setq did-first t))
             ;; Note these are searched for in verilog-read-sub-decls.
             (verilog-insert-indent "// Interfaces\n")
-            (verilog-auto-inst-port-list sig-list indent-pt
+            (verilog-auto-inst-port-list sig-list indent-pt moddecls
                                          tpl-list tpl-num for-star par-values)))
         (let ((sig-list (verilog-signals-not-in
                          (verilog-decls-get-outputs submoddecls)
@@ -11428,7 +11431,7 @@ For more information see the \\[verilog-faq] and forums at URL
           (when sig-list
             (when (not did-first) (verilog-auto-inst-first) (setq did-first t))
             (verilog-insert-indent "// Outputs\n")
-            (verilog-auto-inst-port-list sig-list indent-pt
+            (verilog-auto-inst-port-list sig-list indent-pt moddecls
                                          tpl-list tpl-num for-star par-values)))
         (let ((sig-list (verilog-signals-not-in
                          (verilog-decls-get-inouts submoddecls)
@@ -11437,7 +11440,7 @@ For more information see the \\[verilog-faq] and forums at URL
           (when sig-list
             (when (not did-first) (verilog-auto-inst-first) (setq did-first t))
             (verilog-insert-indent "// Inouts\n")
-            (verilog-auto-inst-port-list sig-list indent-pt
+            (verilog-auto-inst-port-list sig-list indent-pt moddecls
                                          tpl-list tpl-num for-star par-values)))
         (let ((sig-list (verilog-signals-not-in
                          (verilog-decls-get-inputs submoddecls)
@@ -11446,7 +11449,7 @@ For more information see the \\[verilog-faq] and forums at URL
           (when sig-list
             (when (not did-first) (verilog-auto-inst-first) (setq did-first t))
             (verilog-insert-indent "// Inputs\n")
-            (verilog-auto-inst-port-list sig-list indent-pt
+            (verilog-auto-inst-port-list sig-list indent-pt moddecls
                                          tpl-list tpl-num for-star par-values)))
         ;; Kill extra semi
         (save-excursion
@@ -11509,8 +11512,6 @@ Templates:
                                           (+ 16 (* 8 (/ (+ indent-pt 7) 8)))))
            (modi (verilog-modi-current))
            (moddecls (verilog-modi-get-decls modi))
-           (vector-skip-list (unless verilog-auto-inst-vector
-                               (verilog-decls-get-signals moddecls)))
            submod submodi submoddecls
            inst skip-pins tpl-list tpl-num did-first)
       ;; Find module name that is instantiated
@@ -11550,7 +11551,7 @@ Templates:
             (when (not did-first) (verilog-auto-inst-first) (setq did-first t))
             ;; Note these are searched for in verilog-read-sub-decls.
             (verilog-insert-indent "// Parameters\n")
-            (verilog-auto-inst-port-list sig-list indent-pt
+            (verilog-auto-inst-port-list sig-list indent-pt moddecls
                                          tpl-list tpl-num nil nil)))
         ;; Kill extra semi
         (save-excursion
diff --git a/lisp/progmodes/vhdl-mode.el b/lisp/progmodes/vhdl-mode.el
index 875de3b865c..8d6d2a29293 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.36.1"
+(defconst vhdl-version "3.37.1"
   "VHDL Mode version number.")
 
-(defconst vhdl-time-stamp "2014-11-27"
+(defconst vhdl-time-stamp "2015-01-15"
   "VHDL Mode time stamp for last update.")
 
 ;; This file is part of GNU Emacs.
@@ -59,7 +59,7 @@
 ;;   - Block commenting
 ;;   - Code fixing/alignment/beautification
 ;;   - PostScript printing
-;;   - VHDL'87/'93 and VHDL-AMS supported
+;;   - VHDL'87/'93/'02/'08 and VHDL-AMS supported
 ;;   - Comprehensive menu
 ;;   - Fully customizable
 ;;   - Works under GNU Emacs (recommended) and XEmacs
@@ -716,6 +716,7 @@ A project setup file can be obtained by exporting a project (see menu).
 Basic standard:
   VHDL'87      : IEEE Std 1076-1987
   VHDL'93/02   : IEEE Std 1076-1993/2002
+  VHDL'08      : IEEE Std 1076-2008
 Additional standards:
   VHDL-AMS     : IEEE Std 1076.1 (analog-mixed-signal)
   Math packages: IEEE Std 1076.2 (`math_real', `math_complex')
@@ -724,7 +725,8 @@ NOTE: Activate the new setting in a VHDL buffer by using the menu entry
       \"Activate Options\"."
   :type '(list (choice :tag "Basic standard"
                        (const :tag "VHDL'87" 87)
-                       (const :tag "VHDL'93/02" 93))
+                       (const :tag "VHDL'93/02" 93)
+                       (const :tag "VHDL'08" 08))
                (set :tag "Additional standards" :indent 2
                     (const :tag "VHDL-AMS" ams)
                     (const :tag "Math packages" math)))
@@ -942,6 +944,12 @@ If nil, only a list of actual parameters is entered."
   :type 'boolean
   :group 'vhdl-template)
 
+(defcustom vhdl-sensitivity-list-all t
+  "Non-nil means use 'all' keyword in sensitivity list."
+  :version "25.1"
+  :type 'boolean
+  :group 'vhdl-template)
+
 (defcustom vhdl-zero-string "'0'"
   "String to use for a logic zero."
   :type 'string
@@ -1728,7 +1736,7 @@ NOTE: Activate the new setting in a VHDL buffer by re-fontifying it (menu
                           'vhdl-words-init 'vhdl-font-lock-init))
   :group 'vhdl-highlight)
 
-(defcustom vhdl-directive-keywords '("pragma" "synopsys")
+(defcustom vhdl-directive-keywords '("psl" "pragma" "synopsys")
   "List of compiler directive keywords recognized for highlighting.
 
 NOTE: Activate the new setting in a VHDL buffer by re-fontifying it (menu
@@ -2001,6 +2009,8 @@ reported and the syntactic symbol is ignored.")
     (package               . 0)
     (architecture          . 0)
     (package-body          . 0)
+    (context               . 0)
+    (directive             . 0)
     )
   "Default settings for offsets of syntactic elements.
 Do not change this constant!  See the variable `vhdl-offsets-alist' for
@@ -2065,7 +2075,8 @@ Here is the current list of valid syntactic element symbols:
  configuration          -- inside a configuration declaration
  package                -- inside a package declaration
  architecture           -- inside an architecture body
- package-body           -- inside a package body")
+ package-body           -- inside a package body
+ context                -- inside a context declaration")
 
 (defvar vhdl-comment-only-line-offset 0
   "Extra offset for line which contains only the start of a comment.
@@ -2684,6 +2695,7 @@ elements > `vhdl-menu-max-size'."
   (define-key vhdl-template-map "Cd"    'vhdl-template-configuration-decl)
   (define-key vhdl-template-map "Cs"    'vhdl-template-configuration-spec)
   (define-key vhdl-template-map "co"    'vhdl-template-constant)
+  (define-key vhdl-template-map "ct"    'vhdl-template-context)
   (define-key vhdl-template-map "di"    'vhdl-template-disconnect)
   (define-key vhdl-template-map "el"    'vhdl-template-else)
   (define-key vhdl-template-map "ei"    'vhdl-template-elsif)
@@ -2963,7 +2975,7 @@ STRING are replaced by `-' and substrings are converted to lower case."
     (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)
@@ -2975,11 +2987,13 @@ STRING are replaced by `-' and substrings are converted to lower case."
     (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)
+    ;; single-line comments
+    (modify-syntax-entry ?\- ". 12b" st)
+    ;; multi-line comments
+    (modify-syntax-entry ?\/ ". 14b" st)
+    (modify-syntax-entry ?*  ". 23" st)
+    (modify-syntax-entry ?\n "> b"  st)
+    (modify-syntax-entry ?\^M "> b"   st)
     ;; define parentheses to match
     (modify-syntax-entry ?\( "()"   st)
     (modify-syntax-entry ?\) ")("   st)
@@ -3044,6 +3058,7 @@ STRING are replaced by `-' and substrings are converted to lower case."
                  ("configuration" . vhdl-template-configuration-hook)
                  ("cons"          . vhdl-template-constant-hook)
                  ("constant"      . vhdl-template-constant-hook)
+                 ("context"       . vhdl-template-context-hook)
                  ("disconnect"    . vhdl-template-disconnect-hook)
                  ("downto"        . vhdl-template-default-hook)
                  ("else"          . vhdl-template-else-hook)
@@ -3191,6 +3206,7 @@ STRING are replaced by `-' and substrings are converted to lower case."
       ("configuration declaration"         vhdl-template-configuration-decl)
       ("configuration specification"       vhdl-template-configuration-spec)
       ("constant declaration"              vhdl-template-constant)
+      ("context declaration"               vhdl-template-context)
       ("disconnection specification"       vhdl-template-disconnect)
       ("entity declaration"                vhdl-template-entity)
       ("exit statement"                    vhdl-template-exit)
@@ -3367,6 +3383,7 @@ STRING are replaced by `-' and substrings are converted to lower case."
          ["Configuration (Decl)"        vhdl-template-configuration-decl t]
          ["Configuration (Spec)"        vhdl-template-configuration-spec t]
          ["Constant"            vhdl-template-constant t]
+         ["Context"             vhdl-template-context t]
          ["Disconnect"          vhdl-template-disconnect t]
          ["Else"                vhdl-template-else t]
          ["Elsif"               vhdl-template-elsif t]
@@ -3708,6 +3725,11 @@ STRING are replaced by `-' and substrings are converted to lower case."
                                        (list '93 (cadr vhdl-standard)))
                (vhdl-activate-customizations))
         :style radio :selected (eq '93 (car vhdl-standard))]
+       ["VHDL'08"
+        (progn (customize-set-variable 'vhdl-standard
+                                       (list '08 (cadr vhdl-standard)))
+               (vhdl-activate-customizations))
+        :style radio :selected (eq '08 (car vhdl-standard))]
        "--"
        ["VHDL-AMS"
         (progn (customize-set-variable
@@ -3830,6 +3852,10 @@ STRING are replaced by `-' and substrings are converted to lower case."
        (customize-set-variable 'vhdl-conditions-in-parenthesis
                                (not vhdl-conditions-in-parenthesis))
        :style toggle :selected vhdl-conditions-in-parenthesis]
+      ["Sensitivity List uses 'all'"
+       (customize-set-variable 'vhdl-sensitivity-list-all
+                               (not vhdl-sensitivity-list-all))
+       :style toggle :selected vhdl-sensitivity-list-all]
       ["Zero String..." (customize-option 'vhdl-zero-string) t]
       ["One String..." (customize-option 'vhdl-one-string) t]
       ("File Header"
@@ -4224,6 +4250,9 @@ STRING are replaced by `-' and substrings are converted to lower case."
     ("Entity"
      "^\\s-*\\(entity\\)\\s-+\\(\\(\\w\\|\\s_\\)+\\)"
      2)
+    ("Context"
+     "^\\s-*\\(context\\)\\s-+\\(\\(\\w\\|\\s_\\)+\\)"
+     2)
     )
   "Imenu generic expression for VHDL Mode.  See `imenu-generic-expression'.")
 
@@ -4677,7 +4706,7 @@ Usage:
 
   VHDL STANDARDS:
     The VHDL standards to be used are specified in option `vhdl-standard'.
-    Available standards are: VHDL'87/'93(02), VHDL-AMS, and Math Packages.
+    Available standards are: VHDL'87/'93(02)/'08, VHDL-AMS, and Math Packages.
 
 
   KEYWORD CASE:
@@ -4987,6 +5016,12 @@ Key bindings:
     )
   "List of VHDL'02 keywords.")
 
+(defconst vhdl-08-keywords
+  '(
+    "context" "force" "property" "release" "sequence"
+    )
+  "List of VHDL'08 keywords.")
+
 (defconst vhdl-ams-keywords
   '(
     "across" "break" "limit" "nature" "noise" "procedural" "quantity"
@@ -5028,6 +5063,12 @@ Key bindings:
     )
   "List of VHDL'02 standardized types.")
 
+(defconst vhdl-08-types
+  '(
+    "boolean_vector" "integer_vector" "real_vector" "time_vector"
+    )
+  "List of VHDL'08 standardized types.")
+
 (defconst vhdl-ams-types
   ;; standards: IEEE Std 1076.1-2007, IEEE Std 1076.1.1-2004
   '(
@@ -5103,6 +5144,12 @@ Key bindings:
     )
   "List of VHDL'02 standardized attributes.")
 
+(defconst vhdl-08-attributes
+  '(
+    "instance_name" "path_name"
+    )
+  "List of VHDL'08 standardized attributes.")
+
 (defconst vhdl-ams-attributes
   '(
     "across" "through"
@@ -5174,6 +5221,15 @@ Key bindings:
     )
   "List of VHDL'02 standardized functions.")
 
+(defconst vhdl-08-functions
+  '(
+    "finish" "flush" "justify" "maximum" "minimum"
+    "resolution_limit" "rising_edge" "stop" "swrite"
+    "tee" "to_binarystring" "to_bstring" "to_hexstring" "to_hstring"
+    "to_octalstring" "to_ostring" "to_string"
+    )
+  "List of VHDL'08 standardized functions.")
+
 (defconst vhdl-ams-functions
   '(
     ;; package `standard'
@@ -5202,6 +5258,13 @@ Key bindings:
     )
   "List of VHDL'02 standardized packages and libraries.")
 
+(defconst vhdl-08-packages
+  '(
+    "env" "numeric_std_signed" "numeric_std_unsigned"
+    "ieee_bit_context" "ieee_std_context"  ;; contexts
+    )
+  "List of VHDL'08 standardized packages and libraries.")
+
 (defconst vhdl-ams-packages
   '(
     "fundamental_constants" "material_constants" "energy_systems"
@@ -5216,6 +5279,18 @@ Key bindings:
     )
   "List of Math Packages standardized packages and libraries.")
 
+(defconst vhdl-08-directives
+  '(
+    "author" "author_info" "begin" "begin_protected" "comment"
+    "data_block" "data_keyname" "data_keyowner" "data_method"
+    "decrypt_license" "digest_block" "digest_key_method" "digest_keyname"
+    "digest_keyowner" "digest_method"
+    "encoding" "encrypt_agent" "encrypt_agent_info" "end" "end_protected"
+    "key_block" "key_keyname" "key_keyowner" "key_method"
+    "runtime_license" "viewport"
+    )
+  "List of VHDL'08 standardized tool directives.")
+
 (defvar vhdl-keywords nil
   "List of VHDL keywords.")
 
@@ -5237,6 +5312,9 @@ Key bindings:
 (defvar vhdl-packages nil
   "List of VHDL standardized packages and libraries.")
 
+(defvar vhdl-directives nil
+  "List of VHDL standardized packages and libraries.")
+
 (defvar vhdl-reserved-words nil
   "List of additional reserved words.")
 
@@ -5282,17 +5360,20 @@ Key bindings:
         (vhdl-upcase-list
          (and vhdl-highlight-case-sensitive vhdl-upper-case-keywords)
          (append vhdl-02-keywords
+                 (when (vhdl-standard-p '08) vhdl-08-keywords)
                  (when (vhdl-standard-p 'ams) vhdl-ams-keywords))))
   (setq vhdl-types
         (vhdl-upcase-list
          (and vhdl-highlight-case-sensitive vhdl-upper-case-types)
          (append vhdl-02-types
+                 (when (vhdl-standard-p '08) vhdl-08-types)
                  (when (vhdl-standard-p 'ams) vhdl-ams-types)
                  (when (vhdl-standard-p 'math) vhdl-math-types))))
   (setq vhdl-attributes
         (vhdl-upcase-list
          (and vhdl-highlight-case-sensitive vhdl-upper-case-attributes)
          (append vhdl-02-attributes
+                 (when (vhdl-standard-p '08) vhdl-08-attributes)
                  (when (vhdl-standard-p 'ams) vhdl-ams-attributes))))
   (setq vhdl-enum-values
         (vhdl-upcase-list
@@ -5307,12 +5388,16 @@ Key bindings:
                  '(""))))
   (setq vhdl-functions
         (append vhdl-02-functions
+                (when (vhdl-standard-p '08) vhdl-08-functions)
                 (when (vhdl-standard-p 'ams) vhdl-ams-functions)
                 (when (vhdl-standard-p 'math) vhdl-math-functions)))
   (setq vhdl-packages
         (append vhdl-02-packages
+                (when (vhdl-standard-p '08) vhdl-08-packages)
                 (when (vhdl-standard-p 'ams) vhdl-ams-packages)
                 (when (vhdl-standard-p 'math) vhdl-math-packages)))
+  (setq vhdl-directives
+        (append (when (vhdl-standard-p '08) vhdl-08-directives)))
   (setq vhdl-reserved-words
         (append (when vhdl-highlight-forbidden-words vhdl-forbidden-words)
                 (when vhdl-highlight-verilog-keywords vhdl-verilog-keywords)
@@ -5357,7 +5442,8 @@ Key bindings:
          (list vhdl-upper-case-enum-values) vhdl-enum-values
          (list vhdl-upper-case-constants) vhdl-constants
          (list nil) vhdl-functions
-         (list nil) vhdl-packages)))
+         (list nil) vhdl-packages
+         (list nil) vhdl-directives)))
 
 ;; initialize reserved words for VHDL Mode
 (vhdl-words-init)
@@ -5598,9 +5684,24 @@ the offset is simply returned."
 
 ;; Syntactic support functions:
 
-(defun vhdl-in-comment-p ()
-  "Check if point is in a comment."
-  (eq (vhdl-in-literal) 'comment))
+(defun vhdl-in-comment-p (&optional pos)
+  "Check if point is in a comment (include multi-line comments)."
+  (let ((parse (lambda (p)
+                 (let ((c (char-after p)))
+                   (or (and c (eq (char-syntax c) ?<))
+                       (nth 4 (parse-partial-sexp
+                               (save-excursion
+                                 (beginning-of-defun)
+                                 (point)) p)))))))
+    (save-excursion
+      (goto-char (or pos (point)))
+      (or (funcall parse (point))
+          ;; `parse-partial-sexp's notion of comments doesn't span lines
+          (progn
+            (back-to-indentation)
+            (unless (eolp)
+              (forward-char)
+              (funcall parse (point))))))))
 
 (defun vhdl-in-string-p ()
   "Check if point is in a string."
@@ -5625,6 +5726,9 @@ the offset is simply returned."
        ((nth 3 state) 'string)
        ((nth 4 state) 'comment)
        ((vhdl-beginning-of-macro) 'pound)
+       ((vhdl-beginning-of-directive) 'directive)
+       ;; for multi-line comments
+       ((and (vhdl-standard-p '08) (vhdl-in-comment-p)) 'comment)
        (t nil)))))
 
 (defun vhdl-in-extended-identifier-p ()
@@ -5675,7 +5779,7 @@ negative, skip forward otherwise."
       (goto-char lim )
       (while (< (point) here)
         (setq match
-              (and (re-search-forward "--\\|[\"']"
+              (and (re-search-forward "--\\|[\"']\\|`"
                                       here 'move)
                    (buffer-substring (match-beginning 0) (match-end 0))))
         (setq state
@@ -5685,6 +5789,9 @@ negative, skip forward otherwise."
                ;; looking at the opening of a VHDL style comment
                ((string= "--" match)
                 (if (<= here (progn (end-of-line) (point))) 'comment))
+               ;; looking at a directive
+               ((string= "`" match)
+                (if (<= here (progn (end-of-line) (point))) 'directive))
                ;; looking at the opening of a double quote string
                ((string= "\"" match)
                 (if (not (save-restriction
@@ -5729,7 +5836,7 @@ negative, skip forward otherwise."
       (setq here (point))
       (vhdl-forward-comment hugenum)
       ;; skip preprocessor directives
-      (when (and (eq (char-after) ?#)
+      (when (and (or (eq (char-after) ?#) (eq (char-after) ?`))
                  (= (vhdl-point 'boi) (point)))
         (while (and (eq (char-before (vhdl-point 'eol)) ?\\)
                     (= (forward-line 1) 0)))
@@ -5766,6 +5873,19 @@ negative, skip forward otherwise."
       (goto-char here)
       nil)))
 
+(defun vhdl-beginning-of-directive (&optional lim)
+  "Go to the beginning of a directive (nicked from `cc-engine')."
+  (let ((here (point)))
+    (beginning-of-line)
+    (while (eq (char-before (1- (point))) ?\\)
+      (forward-line -1))
+    (back-to-indentation)
+    (if (and (<= (point) here)
+             (eq (char-after) ?`))
+        t
+      (goto-char here)
+      nil)))
+
 (defun vhdl-backward-syntactic-ws (&optional lim)
   "Backward skip over syntactic whitespace."
   (let* ((here (point-min))
@@ -5822,7 +5942,7 @@ that point, else nil."
 ;; Core syntactic evaluation functions:
 
 (defconst vhdl-libunit-re
-  "\\b\\(architecture\\|configuration\\|entity\\|package\\)\\b[^_]")
+  "\\b\\(architecture\\|configuration\\|context\\|entity\\|package\\)\\b[^_]")
 
 (defun vhdl-libunit-p ()
   (and
@@ -5840,7 +5960,7 @@ that point, else nil."
    ))
 
 (defconst vhdl-defun-re
-  "\\b\\(architecture\\|block\\|configuration\\|entity\\|package\\|process\\|procedural\\|procedure\\|function\\)\\b[^_]")
+  "\\b\\(architecture\\|block\\|configuration\\|context\\|entity\\|package\\|process\\|procedural\\|procedure\\|function\\)\\b[^_]")
 
 (defun vhdl-defun-p ()
   (save-excursion
@@ -5849,7 +5969,7 @@ that point, else nil."
         (save-excursion
           (backward-sexp)
           (not (looking-at "end\\s-+\\w")))
-      ;; "architecture", "configuration", "entity",
+      ;; "architecture", "configuration", "context", "entity",
       ;; "package", "procedure", "function":
       t)))
 
@@ -5863,7 +5983,7 @@ corresponding \"begin\" keyword, else return nil."
          (if (looking-at "block\\|process\\|procedural")
              ;; "block", "process". "procedural:
              (buffer-substring (match-beginning 0) (match-end 0))
-           ;; "architecture", "configuration", "entity", "package",
+           ;; "architecture", "configuration", "context", "entity", "package",
            ;; "procedure", "function":
            "is"))))
 
@@ -5884,7 +6004,7 @@ vhdl-begin-fwd-re, and are not inside a literal, and that we are not in
 the middle of an identifier that just happens to contain a \"begin\"
 keyword."
   (cond
-   ;; "[architecture|case|configuration|entity|package|
+   ;; "[architecture|case|configuration|context|entity|package|
    ;;   procedure|function] ... is":
    ((and (looking-at "i")
          (save-excursion
@@ -5897,7 +6017,7 @@ keyword."
            (let (foundp)
              (while (and (not foundp)
                          (re-search-backward
-                          ";\\|\\b\\(architecture\\|case\\|configuration\\|entity\\|package\\|procedure\\|return\\|is\\|begin\\|process\\|procedural\\|block\\)\\b[^_]"
+                          ";\\|\\b\\(architecture\\|case\\|configuration\\|context\\|entity\\|package\\|procedure\\|return\\|is\\|begin\\|process\\|procedural\\|block\\)\\b[^_]"
                           lim 'move))
                (if (or (= (preceding-char) ?_)
                        (vhdl-in-literal))
@@ -6092,7 +6212,7 @@ of an identifier that just happens to contain an \"end\" keyword."
               (vector "for" (vhdl-first-word pos) nil nil))
              ;; "end [id]":
              (t
-              (vector "begin\\|architecture\\|configuration\\|entity\\|package\\|procedure\\|function"
+              (vector "begin\\|architecture\\|configuration\\|context\\|entity\\|package\\|procedure\\|function"
                       (vhdl-first-word pos)
                       ;; return an alist of (statement . keyword) mappings
                       '(
@@ -6102,6 +6222,8 @@ of an identifier that just happens to contain an \"end\" keyword."
                         ("architecture"   . "is")
                         ;; "configuration ... is ... end [id]":
                         ("configuration"  . "is")
+                        ;; "context ... is ... end [id]":
+                        ("context"        . "is")
                         ;; "entity ... is ... end [id]":
                         ("entity"         . "is")
                         ;; "package ... is ... end [id]":
@@ -6716,7 +6838,8 @@ keyword at PLACEHOLDER, then return the library unit type."
           (cond
            ((looking-at "e") 'entity)
            ((looking-at "a") 'architecture)
-           ((looking-at "c") 'configuration)
+           ((looking-at "conf") 'configuration)
+           ((looking-at "cont") 'context)
            ((looking-at "p")
             (save-excursion
               (goto-char bod)
@@ -6992,7 +7115,7 @@ is not moved."
                    (goto-char (1+ containing-sexp))
                    (skip-chars-forward " \t")
                    (not (eolp))
-                   (not (looking-at "--")))
+                   (not (looking-at "--\\|`")))
                  (save-excursion
                    (vhdl-beginning-of-statement-1 containing-sexp)
                    (skip-chars-backward " \t(")
@@ -7141,8 +7264,10 @@ is not moved."
         ;; now we need to look at any modifiers
         (goto-char indent-point)
         (skip-chars-forward " \t")
-        (if (looking-at "--")
+        (if (or (looking-at "--") (looking-at "/\\*"))
             (vhdl-add-syntax 'comment))
+        (if (looking-at "`")
+            (vhdl-add-syntax 'directive))
         (if (eq literal 'pound)
             (vhdl-add-syntax 'cpp-macro))
         ;; return the syntax
@@ -7216,8 +7341,12 @@ only-lines."
         (vhdl-comment-indent)
       ;; otherwise, indent as specified by vhdl-comment-only-line-offset
       (if (not (bolp))
+          ;; inside multi-line comment
+          (if (looking-at "\\*")
+              1
+            ;; otherwise
           (or (car-safe vhdl-comment-only-line-offset)
-              vhdl-comment-only-line-offset)
+                vhdl-comment-only-line-offset))
         (or (cdr-safe vhdl-comment-only-line-offset)
             (car-safe vhdl-comment-only-line-offset)
             -1000                       ;jam it against the left side
@@ -7457,7 +7586,7 @@ ENDPOS is encountered."
     (mapc
      (function
       (lambda (elt)
-        (if (memq (car elt) '(entity configuration package
+        (if (memq (car elt) '(entity configuration context package
                                      package-body architecture))
             nil
           (setq expurgated (append expurgated (list elt))))))
@@ -7787,7 +7916,7 @@ the token in MATCH."
     (vhdl-prepare-search-2
      (save-excursion
        ;; search for declarative part
-       (when (and (re-search-backward "^\\(architecture\\|begin\\|configuration\\|end\\|entity\\|package\\)\\>" nil t)
+       (when (and (re-search-backward "^\\(architecture\\|begin\\|configuration\\|context\\|end\\|entity\\|package\\)\\>" nil t)
                   (not (member (upcase (match-string 1)) '("BEGIN" "END"))))
          (setq beg (point))
          (re-search-forward "^\\(begin\\|end\\)\\>" nil t)
@@ -9137,6 +9266,27 @@ a configuration declaration if not within a design unit."
           (insert ";")
           (vhdl-comment-insert-inline))))))
 
+(defun vhdl-template-context ()
+  "Insert a context declaration."
+  (interactive)
+  (let ((margin (current-indentation))
+        (start (point))
+        entity-exists string name position)
+    (vhdl-insert-keyword "CONTEXT ")
+    (when (setq name (vhdl-template-field "name" nil t start (point)))
+      (vhdl-insert-keyword " IS\n")
+      (when (memq vhdl-insert-empty-lines '(unit all)) (insert "\n"))
+      (indent-to (+ margin vhdl-basic-offset))
+      (setq position (point))
+      (insert "\n")
+      (when (memq vhdl-insert-empty-lines '(unit all)) (insert "\n"))
+      (indent-to margin)
+      (vhdl-insert-keyword "END ")
+      (unless (vhdl-standard-p '87)
+        (vhdl-insert-keyword "CONTEXT "))
+      (insert name ";")
+      (goto-char position))))
+
 (defun vhdl-template-default ()
   "Insert nothing."
   (interactive)
@@ -9798,8 +9948,10 @@ otherwise."
       (forward-char 1))
     (insert "(")
     (if (not seq)
-        (unless (setq input-signals
-                      (vhdl-template-field "[sensitivity list]" ")" t))
+        (unless (or (and (vhdl-standard-p '08) vhdl-sensitivity-list-all
+                         (progn (insert "all)") (setq input-signals "all")))
+                    (setq input-signals
+                          (vhdl-template-field "[sensitivity list]" ")" t)))
           (setq input-signals "")
           (delete-char -2))
       (setq clock (or (and (not (equal "" vhdl-clock-name))
@@ -10533,7 +10685,8 @@ specification, if not already there."
        (while (search-forward "<standard>" end t)
          (replace-match
           (concat "VHDL" (cond ((vhdl-standard-p '87) "'87")
-                               ((vhdl-standard-p '93) "'93/02"))
+                               ((vhdl-standard-p '93) "'93/02")
+                               ((vhdl-standard-p '08) "'08"))
                   (when (vhdl-standard-p 'ams) ", VHDL-AMS")
                   (when (vhdl-standard-p 'math) ", Math Packages")) t t))
        (goto-char beg)
@@ -11071,7 +11224,7 @@ else insert tab (used for word completion in VHDL minibuffer)."
      (save-excursion
        (beginning-of-line)
        ;; search backward for block beginning or end
-       (while (or (while (and (setq pos (re-search-backward "^\\s-*\\(\\(end\\)\\|\\(\\(impure\\|pure\\)[ \t\n\r\f]+\\)?\\(function\\|procedure\\)\\|\\(for\\)\\|\\(architecture\\|component\\|configuration\\|entity\\|package\\(\\s-+body\\)?\\|type[ \t\n\r\f]+\\w+[ \t\n\r\f]+is[ \t\n\r\f]+\\(record\\|protected\\(\\s-+body\\)?\\)\\|units\\)\\|\\(\\w+[ \t\n\r\f]*:[ \t\n\r\f]*\\)?\\(postponed[ \t\n\r\f]+\\)?\\(block\\|case\\|for\\|if\\|procedural\\|process\\|while\\|loop\\)\\)\\>" nil t))
+       (while (or (while (and (setq pos (re-search-backward "^\\s-*\\(\\(end\\)\\|\\(\\(impure\\|pure\\)[ \t\n\r\f]+\\)?\\(function\\|procedure\\)\\|\\(for\\)\\|\\(architecture\\|component\\|configuration\\|context\\|entity\\|package\\(\\s-+body\\)?\\|type[ \t\n\r\f]+\\w+[ \t\n\r\f]+is[ \t\n\r\f]+\\(record\\|protected\\(\\s-+body\\)?\\)\\|units\\)\\|\\(\\w+[ \t\n\r\f]*:[ \t\n\r\f]*\\)?\\(postponed[ \t\n\r\f]+\\)?\\(block\\|case\\|for\\|if\\|procedural\\|process\\|while\\|loop\\)\\)\\>" nil t))
                               ;; not consider subprogram declarations
                               (or (and (match-string 5)
                                        (save-match-data
@@ -11102,7 +11255,7 @@ else insert tab (used for word completion in VHDL minibuffer)."
      (save-excursion
        (end-of-line)
        ;; search forward for block beginning or end
-       (while (or (while (and (setq pos (re-search-forward "^\\s-*\\(\\(end\\)\\|\\(\\(impure\\|pure\\)[ \t\n\r\f]+\\)?\\(function\\|procedure\\)\\|\\(for\\)\\|\\(architecture\\|component\\|configuration\\|entity\\|package\\(\\s-+body\\)?\\|type[ \t\n\r\f]+\\w+[ \t\n\r\f]+is[ \t\n\r\f]+\\(record\\|protected\\(\\s-+body\\)?\\)\\|units\\)\\|\\(\\w+[ \t\n\r\f]*:[ \t\n\r\f]*\\)?\\(postponed[ \t\n\r\f]+\\)?\\(block\\|case\\|for\\|if\\|procedural\\|process\\|while\\|loop\\)\\)\\>" nil t))
+       (while (or (while (and (setq pos (re-search-forward "^\\s-*\\(\\(end\\)\\|\\(\\(impure\\|pure\\)[ \t\n\r\f]+\\)?\\(function\\|procedure\\)\\|\\(for\\)\\|\\(architecture\\|component\\|configuration\\|context\\|entity\\|package\\(\\s-+body\\)?\\|type[ \t\n\r\f]+\\w+[ \t\n\r\f]+is[ \t\n\r\f]+\\(record\\|protected\\(\\s-+body\\)?\\)\\|units\\)\\|\\(\\w+[ \t\n\r\f]*:[ \t\n\r\f]*\\)?\\(postponed[ \t\n\r\f]+\\)?\\(block\\|case\\|for\\|if\\|procedural\\|process\\|while\\|loop\\)\\)\\>" nil t))
                               ;; not consider subprogram declarations
                               (or (and (match-string 5)
                                        (save-match-data
@@ -11203,6 +11356,8 @@ but not if inside a comment or quote."
   (vhdl-hooked-abbrev 'vhdl-template-configuration))
 (defun vhdl-template-constant-hook ()
   (vhdl-hooked-abbrev 'vhdl-template-constant))
+(defun vhdl-template-context-hook ()
+  (vhdl-hooked-abbrev 'vhdl-template-context))
 (defun vhdl-template-disconnect-hook ()
   (vhdl-hooked-abbrev 'vhdl-template-disconnect))
 (defun vhdl-template-display-comment-hook ()
@@ -13190,7 +13345,8 @@ This does highlighting of keywords and standard identifiers.")
    (list
     (concat
      "^\\s-*\\("
-     "architecture\\|configuration\\|entity\\|package\\(\\s-+body\\)?\\|"
+     "architecture\\|configuration\\|context\\|entity\\|package"
+     "\\(\\s-+body\\)?\\|"
      "\\(\\(impure\\|pure\\)\\s-+\\)?function\\|procedure\\|component"
      "\\)\\s-+\\(\\w+\\)")
     5 'font-lock-function-name-face)
@@ -13232,9 +13388,9 @@ This does highlighting of keywords and standard identifiers.")
    (list
     (concat
      "^\\s-*end\\s-+\\(\\("
-     "architecture\\|block\\|case\\|component\\|configuration\\|entity\\|"
-     "for\\|function\\|generate\\|if\\|loop\\|package\\(\\s-+body\\)?\\|"
-     "procedure\\|\\(postponed\\s-+\\)?process\\|"
+     "architecture\\|block\\|case\\|component\\|configuration\\|context\\|"
+     "entity\\|for\\|function\\|generate\\|if\\|loop\\|package"
+     "\\(\\s-+body\\)?\\|procedure\\|\\(postponed\\s-+\\)?process\\|"
      (when (vhdl-standard-p 'ams) "procedural\\|")
      "units"
      "\\)\\s-+\\)?\\(\\w*\\)")
@@ -13266,10 +13422,10 @@ This does highlighting of keywords and standard identifiers.")
    ;; highlight names in use clauses
    (list
     (concat
-     "\\<use\\s-+\\(\\(entity\\|configuration\\)\\s-+\\)?"
+     "\\<\\(context\\|use\\)\\s-+\\(\\(entity\\|configuration\\)\\s-+\\)?"
      "\\(\\w+\\)\\(\\.\\(\\w+\\)\\)?\\((\\(\\w+\\))\\)?")
-    '(3 font-lock-function-name-face) '(5 font-lock-function-name-face nil t)
-    '(7 font-lock-function-name-face nil t))
+    '(4 font-lock-function-name-face) '(6 font-lock-function-name-face nil t)
+    '(8 font-lock-function-name-face nil t))
 
    ;; highlight attribute name in attribute declarations/specifications
    (list
@@ -13316,6 +13472,12 @@ This does highlighting of keywords and standard identifiers.")
          '(vhdl-font-lock-match-item
            (progn (goto-char (match-end 1)) (match-beginning 2))
            nil (1 font-lock-variable-name-face)))
+
+   ;; highlight tool directives
+   (list
+    (concat
+     "^\\s-*\\(`\\w+\\)")
+    1 'font-lock-preprocessor-face)
    )
   "For consideration as a value of `vhdl-font-lock-keywords'.
 This does context sensitive highlighting of names and labels.")
@@ -13661,7 +13823,7 @@ hierarchy otherwise.")
   "Return position of end of current unit."
   (let ((pos (point)))
     (save-excursion
-      (while (and (re-search-forward "^[ \t]*\\(architecture\\|configuration\\|entity\\|package\\)\\>" nil 1)
+      (while (and (re-search-forward "^[ \t]*\\(architecture\\|configuration\\|context\\|entity\\|package\\)\\>" nil 1)
                   (save-excursion
                     (goto-char (match-beginning 0))
                     (vhdl-backward-syntactic-ws)
@@ -13682,7 +13844,7 @@ hierarchy otherwise.")
   "Scan the context clause that precedes a design unit."
   (let (lib-alist)
     (save-excursion
-      (when (re-search-backward "^[ \t]*\\(architecture\\|configuration\\|entity\\|package\\)\\>" nil t)
+      (when (re-search-backward "^[ \t]*\\(architecture\\|configuration\\|context\\|entity\\|package\\)\\>" nil t)
         (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+")
@@ -17502,6 +17664,7 @@ specified by a target."
        'vhdl-argument-list-indent
        'vhdl-association-list-with-formals
        'vhdl-conditions-in-parenthesis
+       'vhdl-sensitivity-list-all
        'vhdl-zero-string
        'vhdl-one-string
        'vhdl-file-header
@@ -17606,6 +17769,17 @@ specified by a target."
 
 (defconst vhdl-doc-release-notes nil
   "\
+Release Notes for VHDL Mode 3.37
+================================
+
+- Added support for VHDL'08:
+  - New keywords, types, functions, attributes, operators, packages
+  - Context declaration
+  - Block comments
+  - Directives
+  - 'all' keyword in sensitivity list
+
+
 Release Notes for VHDL Mode 3.34
 ================================
 
@@ -17667,6 +17841,13 @@ User Options
 Reserved words in VHDL
 ----------------------
 
+VHDL'08 (IEEE Std 1076-2008):
+  `vhdl-08-keywords'      : keywords
+  `vhdl-08-types'         : standardized types
+  `vhdl-08-attributes'    : standardized attributes
+  `vhdl-08-functions'     : standardized functions
+  `vhdl-08-packages'      : standardized packages and libraries
+
 VHDL'93/02 (IEEE Std 1076-1993/2002):
   `vhdl-02-keywords'      : keywords
   `vhdl-02-types'         : standardized types
diff --git a/lisp/progmodes/xref.el b/lisp/progmodes/xref.el
index 55405b63fe0..fe72b3f778c 100644
--- a/lisp/progmodes/xref.el
+++ b/lisp/progmodes/xref.el
@@ -628,6 +628,29 @@ The argument has the same meaning as in `apropos'."
 ;;;###autoload (define-key ctl-x-5-map "." #'xref-find-definitions-other-frame)
 
 
+;;; Helper functions
+
+(defvar xref-etags-mode--saved nil)
+
+(define-minor-mode xref-etags-mode
+  "Minor mode to make xref use etags again.
+
+Certain major modes install their own mechanisms for listing
+identifiers and navigation.  Turn this on to undo those settings
+and just use etags."
+  :lighter ""
+  (if xref-etags-mode
+      (progn
+        (setq xref-etags-mode--saved
+              (cons xref-find-function
+                    xref-identifier-completion-table-function))
+        (kill-local-variable 'xref-find-function)
+        (kill-local-variable 'xref-identifier-completion-table-function))
+    (setq-local xref-find-function (car xref-etags-mode--saved))
+    (setq-local xref-identifier-completion-table-function
+                (cdr xref-etags-mode--saved))))
+
+
 (provide 'xref)
 
 ;;; xref.el ends here