Merge from trunk

19 files changed, 1067 insertions, 607 deletions

diff --git a/lisp/progmodes/ada-mode.el b/lisp/progmodes/ada-mode.el
index 33ff4645a77..1825098a55e 100644
--- a/lisp/progmodes/ada-mode.el
+++ b/lisp/progmodes/ada-mode.el
@@ -105,7 +105,7 @@
 ;; should be loaded before the ada-mode, which will then setup some variables
 ;; to improve the support for Ada code.
 ;; Here is the list of these modes:
-;;   `which-function-mode': Display in the modeline the name of the subprogram
+;;   `which-function-mode': Display in the mode line the name of the subprogram
 ;;      the cursor is in.
 ;;   `outline-mode': Provides the capability to collapse or expand the code
 ;;      for specific language constructs, for instance if you want to hide the
@@ -5055,7 +5055,7 @@ Since the search can be long, the results are cached."
 		    (re-search-backward ada-imenu-subprogram-menu-re nil t))
 
 	  ;; Get the function name, but not the properties, or this changes
-	  ;; the face in the modeline on Emacs 21
+	  ;; the face in the mode line on Emacs 21
 	  (setq func-name (match-string-no-properties 3))
 	  (if (and (not (ada-in-comment-p))
 		   (not (save-excursion
diff --git a/lisp/progmodes/antlr-mode.el b/lisp/progmodes/antlr-mode.el
index 345ca563906..4062646c967 100644
--- a/lisp/progmodes/antlr-mode.el
+++ b/lisp/progmodes/antlr-mode.el
@@ -235,11 +235,11 @@ MAJOR-MODE, the major mode of the code in the grammar's actions, is the
 value of `antlr-language' if the first group in the string matched by
 REGEXP in `antlr-language-limit-n-regexp' is one of the OPTION-VALUEs.
 An OPTION-VALUE of nil denotes the fallback element.  MODELINE-STRING is
-also displayed in the modeline next to \"Antlr\"."
+also displayed in the mode line next to \"Antlr\"."
   :group 'antlr
   :type '(repeat (group :value (java-mode "")
 			(function :tag "Major mode")
-			(string :tag "Modeline string")
+			(string :tag "Mode line string")
 			(repeat :tag "ANTLR language option" :inline t
 				(choice (const :tag "Default" nil)
 					string )))))
diff --git a/lisp/progmodes/cc-cmds.el b/lisp/progmodes/cc-cmds.el
index 9cf20ccb516..4a3577bb29b 100644
--- a/lisp/progmodes/cc-cmds.el
+++ b/lisp/progmodes/cc-cmds.el
@@ -310,7 +310,7 @@ left out.
 Turning on auto-newline automatically enables electric indentation.
 
 When the auto-newline feature is enabled (indicated by \"/la\" on the
-modeline after the mode name) newlines are automatically inserted
+mode line after the mode name) newlines are automatically inserted
 after special characters such as brace, comma, semi-colon, and colon."
   (interactive "P")
   (setq c-auto-newline
@@ -329,7 +329,7 @@ positive, turns it off when negative, and just toggles it when zero or
 left out.
 
 When the hungry-delete-key feature is enabled (indicated by \"/h\" on
-the modeline after the mode name) the delete key gobbles all preceding
+the mode line after the mode name) the delete key gobbles all preceding
 whitespace in one fell swoop."
   (interactive "P")
   (setq c-hungry-delete-key (c-calculate-state arg c-hungry-delete-key))
diff --git a/lisp/progmodes/cc-mode.el b/lisp/progmodes/cc-mode.el
index ff18f56bbe8..2a000957589 100644
--- a/lisp/progmodes/cc-mode.el
+++ b/lisp/progmodes/cc-mode.el
@@ -1,6 +1,6 @@
 ;;; cc-mode.el --- major mode for editing C and similar languages
 
-;; Copyright (C) 1985, 1987, 1992-2012  Free Software Foundation, Inc.
+;; Copyright (C) 1985, 1987, 1992-2012 Free Software Foundation, Inc.
 
 ;; Authors:    2003- Alan Mackenzie
 ;;             1998- Martin Stjernholm
@@ -1584,7 +1584,7 @@ Key bindings:
 (easy-menu-define c-pike-menu pike-mode-map "Pike Mode Commands"
 		  (cons "Pike" (c-lang-const c-mode-menu pike)))
 
-;;;###autoload (add-to-list 'auto-mode-alist '("\\.\\(u?lpc\\|pike\\|pmod\\(.in\\)?\\)\\'" . pike-mode))
+;;;###autoload (add-to-list 'auto-mode-alist '("\\.\\(u?lpc\\|pike\\|pmod\\(\\.in\\)?\\)\\'" . pike-mode))
 ;;;###autoload (add-to-list 'interpreter-mode-alist '("pike" . pike-mode))
 
 ;;;###autoload
diff --git a/lisp/progmodes/compile.el b/lisp/progmodes/compile.el
index 7ffaddb2c49..61dc371c087 100644
--- a/lisp/progmodes/compile.el
+++ b/lisp/progmodes/compile.el
@@ -209,7 +209,7 @@ of[ \t]+\"?\\([a-zA-Z]?:?[^\":\n]+\\)\"?:" 3 2 nil (1))
     ;; due to matching filenames via \\(.*?\\).  This might be faster.
     (maven
      ;; Maven is a popular free software build tool for Java.
-     "\\([0-9]*[^0-9\n]\\(?:[^\n :]\\| [^-/\n]\\|:[^ \n]\\)*?\\):\\[\\([0-9]+\\),\\([0-9]+\\)\\] " 1 2 3)
+     "\\([^ \n]\\(?:[^\n :]\\| [^-/\n]\\|:[^ \n]\\)*?\\):\\[\\([0-9]+\\),\\([0-9]+\\)\\] " 1 2 3)
 
     (jikes-line
      "^ *\\([0-9]+\\)\\.[ \t]+.*\n +\\(<-*>\n\\*\\*\\* \\(?:Error\\|Warnin\\(g\\)\\)\\)"
@@ -674,6 +674,34 @@ starting the compilation process."
   :group 'compilation
   :version "22.1")
 
+;; The next three faces must be able to stand out against the
+;; `mode-line' and `mode-line-inactive' faces.
+
+(defface compilation-mode-line-fail
+  '((default :inherit compilation-error)
+    (((class color) (min-colors 16)) (:foreground "Red1" :weight bold))
+    (((class color) (min-colors 8)) (:foreground "red"))
+    (t (:inverse-video t :weight bold)))
+  "Face for Compilation mode's \"error\" mode line indicator."
+  :group 'compilation
+  :version "24.2")
+
+(defface compilation-mode-line-run
+  '((t :inherit compilation-warning))
+  "Face for Compilation mode's \"running\" mode line indicator."
+  :group 'compilation
+  :version "24.2")
+
+(defface compilation-mode-line-exit
+  '((default :inherit compilation-info)
+    (((class color) (min-colors 16))
+     (:foreground "ForestGreen" :weight bold))
+    (((class color)) (:foreground "green" :weight bold))
+    (t (:weight bold)))
+  "Face for Compilation mode's \"exit\" mode line indicator."
+  :group 'compilation
+  :version "24.2")
+
 (defface compilation-line-number
   '((t :inherit font-lock-keyword-face))
   "Face for displaying line numbers in compiler messages."
@@ -1626,7 +1654,7 @@ Returns the compilation buffer created."
 						       outbuf command))))
 	      ;; Make the buffer's mode line show process state.
 	      (setq mode-line-process
-		    (list (propertize ":%s" 'face 'compilation-warning)))
+		    '(:propertize ":%s" face compilation-mode-line-run))
 	      (set-process-sentinel proc 'compilation-sentinel)
 	      (unless (eq mode t)
 		;; Keep the comint filter, since it's needed for proper handling
@@ -1646,9 +1674,9 @@ Returns the compilation buffer created."
 		    (cons proc compilation-in-progress)))
 	  ;; No asynchronous processes available.
 	  (message "Executing `%s'..." command)
-	  ;; Fake modeline display as if `start-process' were run.
+	  ;; Fake mode line display as if `start-process' were run.
 	  (setq mode-line-process
-		(list (propertize ":run" 'face 'compilation-warning)))
+		'(:propertize ":run" face compilation-mode-line-run))
 	  (force-mode-line-update)
 	  (sit-for 0)			; Force redisplay
 	  (save-excursion
@@ -1884,6 +1912,9 @@ Runs `compilation-mode-hook' with `run-mode-hooks' (which see).
   (setq buffer-read-only t)
   (run-mode-hooks 'compilation-mode-hook))
 
+;;;###autoload
+(put 'define-compilation-mode 'doc-string-elt 3)
+
 (defmacro define-compilation-mode (mode name doc &rest body)
   "This is like `define-derived-mode' without the PARENT argument.
 The parent is always `compilation-mode' and the customizable `compilation-...'
@@ -2043,9 +2074,10 @@ commands of Compilation major mode are available.  See
                                                        (car status)))))
 	    (message "%s" msg)
 	    (propertize out-string
-			'help-echo msg 'face (if (> exit-status 0)
-						 'compilation-error
-					       'compilation-info))))
+			'help-echo msg
+			'face (if (> exit-status 0)
+				  'compilation-mode-line-fail
+				'compilation-mode-line-exit))))
     ;; Force mode line redisplay soon.
     (force-mode-line-update)
     (if (and opoint (< opoint omax))
diff --git a/lisp/progmodes/cwarn.el b/lisp/progmodes/cwarn.el
index 3e99f3c9176..09c7e908806 100644
--- a/lisp/progmodes/cwarn.el
+++ b/lisp/progmodes/cwarn.el
@@ -119,12 +119,6 @@
   :version "21.1"
   :group 'faces)
 
-(defvar cwarn-mode nil
-  "Non-nil when Cwarn mode is active.
-
-Never set this variable directly, use the command `cwarn-mode'
-instead.")
-
 (defcustom cwarn-configuration
   '((c-mode (not reference))
     (c++-mode t))
diff --git a/lisp/progmodes/ebrowse.el b/lisp/progmodes/ebrowse.el
index 849ca4b7c9d..5c2ba080d31 100644
--- a/lisp/progmodes/ebrowse.el
+++ b/lisp/progmodes/ebrowse.el
@@ -48,7 +48,6 @@
   "Settings for the C++ class browser."
   :group 'tools)
 
-
 (defcustom ebrowse-search-path nil
   "List of directories to search for source files in a class tree.
 Elements should be directory names; nil as an element means to try
@@ -154,61 +153,42 @@ This space is used to display markers."
   "Faces used by Ebrowse."
   :group 'ebrowse)
 
-
 (defface ebrowse-tree-mark
-  '((((min-colors 88)) (:foreground "red1"))
-    (t (:foreground "red")))
-  "The face used for the mark character in the tree."
+  '((((min-colors 88)) :foreground "red1")
+    (t :foreground "red"))
+  "Face for the mark character in the Ebrowse tree."
   :group 'ebrowse-faces)
-(define-obsolete-face-alias 'ebrowse-tree-mark-face 'ebrowse-tree-mark "22.1")
-
 
 (defface ebrowse-root-class
-  '((((min-colors 88)) (:weight bold :foreground "blue1"))
-    (t (:weight bold :foreground "blue")))
-  "The face used for root classes in the tree."
+  '((((min-colors 88)) :weight bold :foreground "blue1")
+    (t :weight bold :foreground "blue"))
+  "Face for root classes in the Ebrowse tree."
   :group 'ebrowse-faces)
-(define-obsolete-face-alias 'ebrowse-root-class-face 'ebrowse-root-class "22.1")
 
-
-(defface ebrowse-file-name
-  '((t (:italic t)))
-  "The face for filenames displayed in the tree."
+(defface ebrowse-file-name '((t :slant italic))
+  "Face for filenames in the Ebrowse tree."
   :group 'ebrowse-faces)
-(define-obsolete-face-alias 'ebrowse-file-name-face 'ebrowse-file-name "22.1")
-
 
-(defface ebrowse-default
-  '((t nil))
-  "Face for everything else in the tree not having other faces."
+(defface ebrowse-default '((t))
+  "Face for items in the Ebrowse tree which do not have other faces."
   :group 'ebrowse-faces)
-(define-obsolete-face-alias 'ebrowse-default-face 'ebrowse-default "22.1")
-
 
 (defface ebrowse-member-attribute
-  '((((min-colors 88)) (:foreground "red1"))
-    (t (:foreground "red")))
-  "Face used to display member attributes."
+  '((((min-colors 88)) :foreground "red1")
+    (t :foreground "red"))
+  "Face for member attributes."
   :group 'ebrowse-faces)
-(define-obsolete-face-alias 'ebrowse-member-attribute-face
-  'ebrowse-member-attribute "22.1")
-
 
 (defface ebrowse-member-class
-  '((t (:foreground "purple")))
+  '((t :foreground "purple"))
   "Face used to display the class title in member buffers."
   :group 'ebrowse-faces)
-(define-obsolete-face-alias 'ebrowse-member-class-face
-  'ebrowse-member-class "22.1")
-
 
 (defface ebrowse-progress
-  '((((min-colors 88)) (:background "blue1"))
-    (t (:background "blue")))
+  '((((min-colors 88)) :background "blue1")
+    (t :background "blue"))
   "Face for progress indicator."
   :group 'ebrowse-faces)
-(define-obsolete-face-alias 'ebrowse-progress-face 'ebrowse-progress "22.1")
-
 
 
 ;;; Utilities.
diff --git a/lisp/progmodes/flymake.el b/lisp/progmodes/flymake.el
index 96d4105f65b..654fd3dba8d 100644
--- a/lisp/progmodes/flymake.el
+++ b/lisp/progmodes/flymake.el
@@ -796,16 +796,12 @@ Return t if it has at least one flymake overlay, nil if no overlay."
     has-flymake-overlays))
 
 (defface flymake-errline
-  '((((class color) (background dark)) (:background "Firebrick4"))
-    (((class color) (background light)) (:background "LightPink"))
-    (t (:bold t)))
+  '((t :inherit error))
   "Face used for marking error lines."
   :group 'flymake)
 
 (defface flymake-warnline
-  '((((class color) (background dark)) (:background "DarkBlue"))
-    (((class color) (background light)) (:background "LightBlue2"))
-    (t (:bold t)))
+  '((t :inherit warning))
   "Face used for marking warning lines."
   :group 'flymake)
 
diff --git a/lisp/progmodes/fortran.el b/lisp/progmodes/fortran.el
index 8d488fe9be4..665b0767b2c 100644
--- a/lisp/progmodes/fortran.el
+++ b/lisp/progmodes/fortran.el
@@ -165,7 +165,7 @@ allow trailing comments on a line."
 (defcustom fortran-directive-re
   "^[ \t]*#.*"
   "Regexp to match a directive line.
-The matching text will be fontified with `font-lock-keyword-face'.
+The matching text will be fontified with `font-lock-preprocessor-face'.
 The matching line will be given zero indentation."
   :version "22.1"
   :type    'regexp
@@ -452,7 +452,7 @@ The only difference is, it returns t in a case when the default returns nil."
     ;; Standard continuation character and in a TAB-formatted line.
     '("^ \\{5\\}\\([^ 0\n]\\)" 1 font-lock-string-face)
     '("^\t\\([1-9]\\)"         1 font-lock-string-face))
-   `((,fortran-directive-re (0 font-lock-keyword-face t)))
+   `((,fortran-directive-re (0 font-lock-preprocessor-face t)))
    ;; `fortran-font-lock-keywords-2' without types (see above).
    (cdr (nthcdr (length fortran-font-lock-keywords-1)
                 fortran-font-lock-keywords-2)))
diff --git a/lisp/progmodes/gdb-mi.el b/lisp/progmodes/gdb-mi.el
index 0cc5de90573..5ea0f6a3fd2 100644
--- a/lisp/progmodes/gdb-mi.el
+++ b/lisp/progmodes/gdb-mi.el
@@ -459,9 +459,14 @@ Most recent commands are listed first.  This list stores only the last
 `gdb-debug-log-max' values.  This variable is used to debug GDB-MI.")
 
 ;;;###autoload
-(defcustom gdb-enable-debug nil
-  "Non-nil means record the process input and output in `gdb-debug-log'."
-  :type 'boolean
+(define-minor-mode gdb-enable-debug
+  "Toggle logging of transaction between Emacs and Gdb.
+The log is stored in `gdb-debug-log' as an alist with elements
+whose cons is send, send-item or recv and whose cdr is the string
+being transferred.  This list may grow up to a size of
+`gdb-debug-log-max' after which the oldest element (at the end of
+the list) is deleted every time a new one is added (at the front)."
+  :global t
   :group 'gdb
   :version "22.1")
 
@@ -512,21 +517,6 @@ Also display the main routine in the disassembly buffer if present."
 	  ;; Force mode line redisplay soon.
 	  (force-mode-line-update)))))
 
-(defun gdb-enable-debug (arg)
-  "Toggle logging of transaction between Emacs and Gdb.
-The log is stored in `gdb-debug-log' as an alist with elements
-whose cons is send, send-item or recv and whose cdr is the string
-being transferred.  This list may grow up to a size of
-`gdb-debug-log-max' after which the oldest element (at the end of
-the list) is deleted every time a new one is added (at the front)."
-  (interactive "P")
-  (setq gdb-enable-debug
-	(if (null arg)
-	    (not gdb-enable-debug)
-	  (> (prefix-numeric-value arg) 0)))
-  (message (format "Logging of transaction %sabled"
-		   (if gdb-enable-debug "en" "dis"))))
-
 ;; These two are used for menu and toolbar
 (defun gdb-control-all-threads ()
   "Switch to non-stop/A mode."
@@ -830,7 +820,7 @@ detailed description of this mode.
   (run-hooks 'gdb-mode-hook))
 
 (defun gdb-init-1 ()
-  ;; (re-)initialize
+  ;; (Re-)initialize.
   (setq gdb-selected-frame nil
 	gdb-frame-number nil
         gdb-thread-number nil
@@ -879,7 +869,7 @@ detailed description of this mode.
 
   (gdb-input "-enable-pretty-printing" 'ignore)
 
-  ;; find source file and compilation directory here
+  ;; Find source file and compilation directory here.
   (if gdb-create-source-file-list
       ;; Needs GDB 6.2 onwards.
       (gdb-input "-file-list-exec-source-files" 'gdb-get-source-file-list))
@@ -979,15 +969,17 @@ no input, and GDB is waiting for input."
     (gdb-create-define-alist)
     (add-hook 'after-save-hook 'gdb-create-define-alist nil t)))
 
-(defmacro gdb-if-arrow (arrow-position &rest body)
-  `(if ,arrow-position
-       (let ((buffer (marker-buffer ,arrow-position)) (line))
-         (if (equal buffer (window-buffer (posn-window end)))
-             (with-current-buffer buffer
-               (when (or (equal start end)
-                         (equal (posn-point start)
-                                (marker-position ,arrow-position)))
-                 ,@body))))))
+(defmacro gdb--if-arrow (arrow-position start-posn end-posn &rest body)
+  (declare (indent 3))
+  (let ((buffer (make-symbol "buffer")))
+    `(if ,arrow-position
+         (let ((,buffer (marker-buffer ,arrow-position)))
+           (if (equal ,buffer (window-buffer (posn-window ,end-posn)))
+               (with-current-buffer ,buffer
+                 (when (or (equal ,start-posn ,end-posn)
+                           (equal (posn-point ,start-posn)
+                                  (marker-position ,arrow-position)))
+                   ,@body)))))))
 
 (defun gdb-mouse-until (event)
   "Continue running until a source line past the current line.
@@ -997,15 +989,15 @@ with mouse-1 (default bindings)."
   (interactive "e")
   (let ((start (event-start event))
 	(end (event-end event)))
-    (gdb-if-arrow gud-overlay-arrow-position
-		  (setq line (line-number-at-pos (posn-point end)))
-		  (gud-call (concat "until " (number-to-string line))))
-    (gdb-if-arrow gdb-disassembly-position
-		  (save-excursion
-		    (goto-char (point-min))
-		    (forward-line (1- (line-number-at-pos (posn-point end))))
-		    (forward-char 2)
-		    (gud-call (concat "until *%a"))))))
+    (gdb--if-arrow gud-overlay-arrow-position start end
+      (let ((line (line-number-at-pos (posn-point end))))
+        (gud-call (concat "until " (number-to-string line)))))
+    (gdb--if-arrow gdb-disassembly-position start end
+      (save-excursion
+        (goto-char (point-min))
+        (forward-line (1- (line-number-at-pos (posn-point end))))
+        (forward-char 2)
+        (gud-call (concat "until *%a"))))))
 
 (defun gdb-mouse-jump (event)
   "Set execution address/line.
@@ -1016,19 +1008,17 @@ line, and no execution takes place."
   (interactive "e")
   (let ((start (event-start event))
 	(end (event-end event)))
-    (gdb-if-arrow gud-overlay-arrow-position
-		  (setq line (line-number-at-pos (posn-point end)))
-		  (progn
-		    (gud-call (concat "tbreak " (number-to-string line)))
-		    (gud-call (concat "jump " (number-to-string line)))))
-    (gdb-if-arrow gdb-disassembly-position
-		  (save-excursion
-		    (goto-char (point-min))
-		    (forward-line (1- (line-number-at-pos (posn-point end))))
-		    (forward-char 2)
-		    (progn
-		      (gud-call (concat "tbreak *%a"))
-		      (gud-call (concat "jump *%a")))))))
+    (gdb--if-arrow gud-overlay-arrow-position start end
+      (let ((line (line-number-at-pos (posn-point end))))
+        (gud-call (concat "tbreak " (number-to-string line)))
+        (gud-call (concat "jump " (number-to-string line)))))
+    (gdb--if-arrow gdb-disassembly-position start end
+      (save-excursion
+        (goto-char (point-min))
+        (forward-line (1- (line-number-at-pos (posn-point end))))
+        (forward-char 2)
+        (gud-call (concat "tbreak *%a"))
+        (gud-call (concat "jump *%a"))))))
 
 (defcustom gdb-show-changed-values t
   "If non-nil change the face of out of scope variables and changed values.
@@ -1050,10 +1040,11 @@ Changed values are highlighted with the face `font-lock-warning-face'."
   :group 'gdb
   :version "22.2")
 
-(defcustom gdb-speedbar-auto-raise nil
-  "If non-nil raise speedbar every time display of watch expressions is\
- updated."
-  :type 'boolean
+(define-minor-mode gdb-speedbar-auto-raise
+  "Minor mode to automatically raise the speedbar for watch expressions.
+With prefix argument ARG, automatically raise speedbar if ARG is
+positive, otherwise don't automatically raise it."
+  :global t
   :group 'gdb
   :version "22.1")
 
@@ -1063,18 +1054,6 @@ Changed values are highlighted with the face `font-lock-warning-face'."
   :group 'gdb
   :version "22.1")
 
-(defun gdb-speedbar-auto-raise (arg)
-  "Toggle automatic raising of the speedbar for watch expressions.
-With prefix argument ARG, automatically raise speedbar if ARG is
-positive, otherwise don't automatically raise it."
-  (interactive "P")
-  (setq gdb-speedbar-auto-raise
-	(if (null arg)
-	    (not gdb-speedbar-auto-raise)
-	  (> (prefix-numeric-value arg) 0)))
-  (message (format "Auto raising %sabled"
-		   (if gdb-speedbar-auto-raise "en" "dis"))))
-
 (define-key gud-minor-mode-map "\C-c\C-w" 'gud-watch)
 (define-key global-map (vconcat gud-key-prefix "\C-w") 'gud-watch)
 
@@ -1212,8 +1191,8 @@ With arg, enter name of variable to be watched in the minibuffer."
 (defun gdb-edit-value (_text _token _indent)
   "Assign a value to a variable displayed in the speedbar."
   (let* ((var (nth (- (count-lines (point-min) (point)) 2) gdb-var-list))
-	 (varnum (car var)) (value))
-    (setq value (read-string "New value: "))
+	 (varnum (car var))
+         (value (read-string "New value: ")))
     (gdb-input (concat "-var-assign " varnum " " value)
 	       `(lambda () (gdb-edit-value-handler ,value)))))
 
@@ -1865,7 +1844,7 @@ is running."
     (setq gud-running
           (string= (bindat-get-field (gdb-current-buffer-thread) 'state)
                    "running"))
-    ;; Set frame number to "0" when _current_ threads stops
+    ;; Set frame number to "0" when _current_ threads stops.
     (when (and (gdb-current-buffer-thread)
                (not (eq gud-running old-value)))
       (setq gdb-frame-number "0"))))
@@ -1933,10 +1912,10 @@ is running."
 	     (> (length gdb-debug-log) gdb-debug-log-max))
 	(setcdr (nthcdr (1- gdb-debug-log-max) gdb-debug-log) nil)))
 
-  ;; Recall the left over gud-marker-acc from last time
+  ;; Recall the left over gud-marker-acc from last time.
   (setq gud-marker-acc (concat gud-marker-acc string))
 
-  ;; Start accumulating output for the GUD buffer
+  ;; Start accumulating output for the GUD buffer.
   (setq gdb-filter-output "")
   (let (output-record-list)
 
@@ -1982,9 +1961,8 @@ is running."
 (defun gdb-gdb (_output-field))
 
 (defun gdb-shell (output-field)
-  (let ((gdb-output-sink gdb-output-sink))
-    (setq gdb-filter-output
-          (concat output-field gdb-filter-output))))
+  (setq gdb-filter-output
+        (concat output-field gdb-filter-output)))
 
 (defun gdb-ignored-notification (_output-field))
 
@@ -2068,14 +2046,15 @@ current thread and update GDB buffers."
 			     (concat " --thread " thread-id)))
 		 'gdb-register-names-handler))
 
-;;; Don't set gud-last-frame here as it's currently done in gdb-frame-handler
-;;; because synchronous GDB doesn't give these fields with CLI.
-;;;     (when file
-;;;       (setq
-;;;        ;; Extract the frame position from the marker.
-;;;        gud-last-frame (cons file
-;;; 			    (string-to-number
-;;; 			     (match-string 6 gud-marker-acc)))))
+    ;; Don't set gud-last-frame here as it's currently done in
+    ;; gdb-frame-handler because synchronous GDB doesn't give these fields
+    ;; with CLI.
+    ;;(when file
+    ;;  (setq
+    ;;   ;; Extract the frame position from the marker.
+    ;;   gud-last-frame (cons file
+    ;;    		    (string-to-number
+    ;;    		     (match-string 6 gud-marker-acc)))))
 
     (setq gdb-inferior-status (or reason "unknown"))
     (gdb-force-mode-line-update
@@ -2359,8 +2338,9 @@ calling `gdb-table-string'."
 (defun gdb-get-many-fields (struct &rest fields)
   "Return a list of FIELDS values from STRUCT."
   (let ((values))
-    (dolist (field fields values)
-      (setq values (append values (list (bindat-get-field struct field)))))))
+    (dolist (field fields)
+      (push (bindat-get-field struct field) values))
+    (nreverse values)))
 
 (defmacro def-gdb-auto-update-trigger (trigger-name gdb-command
                                                     handler-name
@@ -4134,31 +4114,19 @@ window is dedicated."
                              nil win5))
     (select-window win0)))
 
-(defcustom gdb-many-windows nil
+(define-minor-mode gdb-many-windows
   "If nil just pop up the GUD buffer unless `gdb-show-main' is t.
 In this case it starts with two windows: one displaying the GUD
 buffer and the other with the source file with the main routine
 of the debugged program.  Non-nil means display the layout shown for
 `gdb'."
-  :type 'boolean
+  :global t
   :group 'gdb
-  :version "22.1")
-
-(defun gdb-many-windows (arg)
-  "Toggle the number of windows in the basic arrangement.
-With arg, display additional buffers iff arg is positive."
-  (interactive "P")
-  (setq gdb-many-windows
-        (if (null arg)
-            (not gdb-many-windows)
-          (> (prefix-numeric-value arg) 0)))
-  (message (format "Display of other windows %sabled"
-                   (if gdb-many-windows "en" "dis")))
+  :version "22.1"
   (if (and gud-comint-buffer
            (buffer-name gud-comint-buffer))
-      (condition-case nil
-          (gdb-restore-windows)
-        (error nil))))
+      (ignore-errors
+        (gdb-restore-windows))))
 
 (defun gdb-restore-windows ()
   "Restore the basic arrangement of windows used by gdb.
diff --git a/lisp/progmodes/idlw-shell.el b/lisp/progmodes/idlw-shell.el
index da8f30bab43..4f9109284ae 100644
--- a/lisp/progmodes/idlw-shell.el
+++ b/lisp/progmodes/idlw-shell.el
@@ -481,7 +481,7 @@ line where IDL is stopped.  See also `idlwave-shell-mark-stop-line'."
 
 (defcustom idlwave-shell-electric-stop-line-face
   (prog1
-      (copy-face 'modeline 'idlwave-shell-electric-stop-line)
+      (copy-face 'mode-line 'idlwave-shell-electric-stop-line)
     (set-face-background 'idlwave-shell-electric-stop-line
 			 idlwave-shell-electric-stop-color)
     (condition-case nil
diff --git a/lisp/progmodes/js.el b/lisp/progmodes/js.el
index 1c8a1f45e57..cdc3ef1c2e0 100644
--- a/lisp/progmodes/js.el
+++ b/lisp/progmodes/js.el
@@ -1646,6 +1646,11 @@ This performs fontification according to `js--class-styles'."
   (funcall
    (syntax-propertize-rules
     ;; Distinguish /-division from /-regexp chars (and from /-comment-starter).
+    ;; FIXME: Allow regexps after infix ops like + ...
+    ;; https://developer.mozilla.org/en/JavaScript/Reference/Operators
+    ;; We can probably just add +, -, !, <, >, %, ^, ~, |, &, ?, : at which
+    ;; point I think only * and / would be missing which could also be added,
+    ;; but need care to avoid affecting the // and */ comment markers.
     ("\\(?:^\\|[=([{,:;]\\)\\(?:[ \t]\\)*\\(/\\)[^/*]"
      (1 (ignore
 	 (forward-char -1)
@@ -3324,7 +3329,7 @@ If one hasn't been set, or if it's stale, prompt for a new one."
         comment-start-skip "\\(//+\\|/\\*+\\)\\s *")
 
   (set (make-local-variable 'electric-indent-chars)
-       (append "{}():;," electric-indent-chars))
+       (append "{}():;," electric-indent-chars)) ;FIXME: js2-mode adds "[]*".
   (set (make-local-variable 'electric-layout-rules)
        '((?\; . after) (?\{ . after) (?\} . before)))
 
diff --git a/lisp/progmodes/pascal.el b/lisp/progmodes/pascal.el
index 62ba9418ced..ce37fc2c571 100644
--- a/lisp/progmodes/pascal.el
+++ b/lisp/progmodes/pascal.el
@@ -232,10 +232,10 @@ will do all lineups."
   :group 'pascal)
 
 (defvar pascal-toggle-completions nil
-  "Non-nil meant \\<pascal-mode-map>\\[pascal-complete-word] would try all possible completions one by one.
-Repeated use of \\[pascal-complete-word] would show you all of them.
-Normally, when there is more than one possible completion,
-it displays a list of all possible completions.")
+  "If non-nil, `pascal-complete-word' tries all possible completions.
+Repeated use of \\[pascal-complete-word] then shows all
+completions in turn, instead of displaying a list of all possible
+completions.")
 (make-obsolete-variable 'pascal-toggle-completions
                         'completion-cycle-threshold "24.1")
 
diff --git a/lisp/progmodes/scheme.el b/lisp/progmodes/scheme.el
index 1fa75f239eb..7cab07fe387 100644
--- a/lisp/progmodes/scheme.el
+++ b/lisp/progmodes/scheme.el
@@ -201,7 +201,7 @@ Editing commands are similar to those of `lisp-mode'.
 In addition, if an inferior Scheme process is running, some additional
 commands will be defined, for evaluating expressions and controlling
 the interpreter, and the state of the process will be displayed in the
-modeline of all Scheme buffers.  The names of commands that interact
+mode line of all Scheme buffers.  The names of commands that interact
 with the Scheme process start with \"xscheme-\" if you use the MIT
 Scheme-specific `xscheme' package; for more information see the
 documentation for `xscheme-interaction-mode'.  Use \\[run-scheme] to
diff --git a/lisp/progmodes/vera-mode.el b/lisp/progmodes/vera-mode.el
index 6737bf229a0..31f2fc1fe31 100644
--- a/lisp/progmodes/vera-mode.el
+++ b/lisp/progmodes/vera-mode.el
@@ -670,23 +670,23 @@ Adapted from `font-lock-match-c-style-declaration-item-and-skip-to-next'."
   "Face name to use for interface names.")
 
 (defface vera-font-lock-number
-  '((((class color) (background light)) (:foreground "Gold4"))
-    (((class color) (background dark)) (:foreground "BurlyWood1"))
-    (t (:italic t :bold t)))
+  '((((class color) (background light)) :foreground "Gold4")
+    (((class color) (background dark))  :foreground "BurlyWood1")
+    (t :slant italic :weight bold))
   "Font lock mode face used to highlight @ definitions."
   :group 'font-lock-highlighting-faces)
 
 (defface vera-font-lock-function
-  '((((class color) (background light)) (:foreground "DarkCyan"))
-    (((class color) (background dark)) (:foreground "Orchid1"))
-    (t (:italic t :bold t)))
+  '((((class color) (background light)) :foreground "DarkCyan")
+    (((class color) (background dark))  :foreground "Orchid1")
+    (t :slant italic :weight bold))
   "Font lock mode face used to highlight predefined functions and tasks."
   :group 'font-lock-highlighting-faces)
 
 (defface vera-font-lock-interface
-  '((((class color) (background light)) (:foreground "Grey40"))
-    (((class color) (background dark)) (:foreground "Grey80"))
-    (t (:italic t :bold t)))
+  '((((class color) (background light)) :foreground "Grey40")
+    (((class color) (background dark))  :foreground "Grey80")
+    (t :slant italic :weight bold))
   "Font lock mode face used to highlight interface names."
   :group 'font-lock-highlighting-faces)
 
diff --git a/lisp/progmodes/verilog-mode.el b/lisp/progmodes/verilog-mode.el
index 0cd8d01aff1..c072754e66d 100644
--- a/lisp/progmodes/verilog-mode.el
+++ b/lisp/progmodes/verilog-mode.el
@@ -12105,7 +12105,7 @@ Typing \\[verilog-auto] will make this into:
   "Expand AUTOUNDEF statements, as part of \\[verilog-auto].
 Take any `defines since the last AUTOUNDEF in the current file
 and create `undefs for them.  This is used to insure that
-file-local defines do not polute the global `define name space.
+file-local defines do not pollute the global `define name space.
 
 Limitations:
   AUTOUNDEF presumes any identifier following `define is the
@@ -12145,7 +12145,7 @@ defines the regular expression will be undefed."
 	   (end-pt (point))
 	   defs def)
       (save-excursion
-	;; Scan from beginnng of file, or last AUTOUNDEF
+	;; Scan from start of file, or last AUTOUNDEF
 	(or (verilog-re-search-backward-quick "/\\*AUTOUNDEF\\>" end-pt t)
 	    (goto-char (point-min)))
 	(while (verilog-re-search-forward-quick
diff --git a/lisp/progmodes/vhdl-mode.el b/lisp/progmodes/vhdl-mode.el
index 9b7ee5d6aa0..5177bc6d9f5 100644
--- a/lisp/progmodes/vhdl-mode.el
+++ b/lisp/progmodes/vhdl-mode.el
@@ -13,10 +13,10 @@
 ;; filed in the Emacs bug reporting system against this file, a copy
 ;; of the bug report be sent to the maintainer's email address.
 
-(defconst vhdl-version "3.33.6"
+(defconst vhdl-version "3.33.28"
   "VHDL Mode version number.")
 
-(defconst vhdl-time-stamp "2005-08-30"
+(defconst vhdl-time-stamp "2010-09-22"
   "VHDL Mode time stamp for last update.")
 
 ;; This file is part of GNU Emacs.
@@ -72,13 +72,13 @@
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;; Emacs Versions
 
-;; supported: GNU Emacs 20.X/21.X/22.X, XEmacs 20.X/21.X
-;; tested on: GNU Emacs 20.4, XEmacs 21.1 (marginally)
+;; supported: GNU Emacs 20.X/21.X/22.X,23.X, XEmacs 20.X/21.X
+;; tested on: GNU Emacs 20.4/21.3/22.1,23.X, XEmacs 21.1 (marginally)
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;; Installation
 
-;; Prerequisites:  GNU Emacs 20.X/21.X/22.X, XEmacs 20.X/21.X.
+;; Prerequisites:  GNU Emacs 20.X/21.X/22.X/23.X, XEmacs 20.X/21.X.
 
 ;; Put `vhdl-mode.el' into the `site-lisp' directory of your Emacs installation
 ;; or into an arbitrary directory that is added to the load path by the
@@ -93,7 +93,7 @@
 
 ;; Add the following lines to the `site-start.el' file in the `site-lisp'
 ;; directory of your Emacs installation or to your Emacs start-up file `.emacs'
-;; (not required in Emacs 20.X):
+;; (not required in Emacs 20 and higher):
 
 ;;   (autoload 'vhdl-mode "vhdl-mode" "VHDL Mode" t)
 ;;   (setq auto-mode-alist (cons '("\\.vhdl?\\'" . vhdl-mode) auto-mode-alist))
@@ -184,7 +184,7 @@ Examples:
   \".*\"           \"\"      inserts empty string")
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-;; User variables
+;; User variables (customization options)
 
 (defgroup vhdl nil
   "Customizations for VHDL Mode."
@@ -210,6 +210,17 @@ Overrides local variable `indent-tabs-mode'."
 
 (defcustom vhdl-compiler-alist
   '(
+    ("ADVance MS" "vacom" "-work \\1" "make" "-f \\1"
+     nil "valib \\1; vamap \\2 \\1" "./" "work/" "Makefile" "adms"
+     ("\\s-\\([0-9]+\\):" 0 1 0) ("Compiling file \\(.+\\)" 1)
+     ("ENTI/\\1.vif" "ARCH/\\1-\\2.vif" "CONF/\\1.vif"
+      "PACK/\\1.vif" "BODY/\\1.vif" upcase))
+    ;; Aldec
+    ;; COMP96 ERROR COMP96_0078: "Unknown identifier "Addr_Bits"." "<filename>" 40 30
+    ("Aldec" "vcom" "-93 -work \\1" "make" "-f \\1"
+     nil "vlib \\1; vmap \\2 \\1" "./" "work/" "Makefile" "aldec"
+     (".+?[ \t]+\\(?:ERROR\\)[^:]+:.+?\\(?:.+\"\\(.+?\\)\"[ \t]+\\([0-9]+\\)\\)" 1 2 0) ("" 0)
+     nil)
     ;; Cadence Leapfrog: cv -file test.vhd
     ;; duluth: *E,430 (test.vhd,13): identifier (POSITIV) is not declared
     ("Cadence Leapfrog" "cv" "-work \\1 -file" "make" "-f \\1"
@@ -225,6 +236,12 @@ Overrides local variable `indent-tabs-mode'."
      ("ncvhdl_p: \\*E,\\w+ (\\(.+\\),\\([0-9]+\\)|\\([0-9]+\\)):" 1 2 3) ("" 0)
      ("\\1/entity/pc.db" "\\2/\\1/pc.db" "\\1/configuration/pc.db"
       "\\1/package/pc.db" "\\1/body/pc.db" downcase))
+    ;; ghdl vhdl: ghdl test.vhd
+    ("GHDL" "ghdl" "-i --workdir=\\1 --ieee=synopsys -fexplicit " "make" "-f \\1"
+     nil "mkdir \\1" "./" "work/" "Makefile" "ghdl"
+     ("ghdl_p: \\*E,\\w+ (\\(.+\\),\\([0-9]+\\)|\\([0-9]+\\)):" 1 2 3) ("" 0)
+     ("\\1/entity" "\\2/\\1" "\\1/configuration"
+      "\\1/package" "\\1/body" downcase))
     ;; Ikos Voyager: analyze test.vhd
     ;; analyze test.vhd
     ;; E L4/C5:        this library unit is inaccessible
@@ -236,10 +253,11 @@ Overrides local variable `indent-tabs-mode'."
     ;; ModelSim, Model Technology: vcom test.vhd
     ;; ERROR: test.vhd(14): Unknown identifier: positiv
     ;; WARNING[2]: test.vhd(85): Possible infinite loop
+    ;; ** Warning: [4] ../src/emacsvsim.vhd(43): An abstract ...
     ;; ** Error: adder.vhd(190): Unknown identifier: ctl_numb
     ("ModelSim" "vcom" "-93 -work \\1" "make" "-f \\1"
      nil "vlib \\1; vmap \\2 \\1" "./" "work/" "Makefile" "modelsim"
-     ("\\(ERROR\\|WARNING\\|\\*\\* Error\\|\\*\\* Warning\\)[^:]*: \\(.+\\)(\\([0-9]+\\)):" 2 3 0) ("" 0)
+     ("\\(ERROR\\|WARNING\\|\\*\\* Error\\|\\*\\* Warning\\)[^:]*:\\( *\[[0-9]+\]\\)? \\(.+\\)(\\([0-9]+\\)):" 3 4 0) ("" 0)
      ("\\1/_primary.dat" "\\2/\\1.dat" "\\1/_primary.dat"
       "\\1/_primary.dat" "\\1/body.dat" downcase))
     ;; ProVHDL, Synopsys LEDA: provhdl -w work -f test.vhd
@@ -321,6 +339,12 @@ Overrides local variable `indent-tabs-mode'."
      ("\\*\\*Error: LINE \\([0-9]+\\) \\*\\*\\*" 0 1 0)
      ("^ *Compiling \"\\(.+\\)\" " 1)
      nil)
+    ;; Xilinx XST:
+    ;; ERROR:HDLParsers:164 - "test.vhd" Line 3. parse error
+    ("Xilinx XST" "xflow" "" "make" "-f \\1"
+     nil "mkdir \\1" "./" "work/" "Makefile" "xilinx"
+     ("^ERROR:HDLParsers:[0-9]+ - \"\\(.+\\)\" Line \\([0-9]+\\)\." 1 2 0) ("" 0)
+     nil)
     )
   "List of available VHDL compilers and their properties.
 Each list entry specifies the following items for a compiler:
@@ -428,7 +452,7 @@ NOTE: Activate new error and file message regexps and reflect the new setting
 	 (vhdl-custom-set variable value 'vhdl-update-mode-menu))
   :group 'vhdl-compile)
 
-(defcustom vhdl-compiler "ModelSim"
+(defcustom vhdl-compiler "GHDL"
   "Specifies the VHDL compiler to be used for syntax analysis.
 Select a compiler name from the ones defined in option `vhdl-compiler-alist'."
   :type (let ((alist vhdl-compiler-alist) list)
@@ -450,6 +474,17 @@ NOTE: Activate the new setting by restarting Emacs."
   :type 'boolean
   :group 'vhdl-compile)
 
+(defcustom vhdl-makefile-default-targets '("all" "clean" "library")
+  "List of default target names in Makefiles.
+Automatically generated Makefiles include three default targets to compile
+the entire design, clean the entire design and to create the design library.
+This option allows to change the names of these targets to avoid conflicts
+with other user Makefiles."
+  :type '(list (string :tag "Compile entire design")
+	       (string :tag "Clean entire design  ")
+	       (string :tag "Create design library"))
+  :group 'vhdl-compile)
+
 (defcustom vhdl-makefile-generation-hook nil
   "Functions to run at the end of Makefile generation.
 Allows to insert user specific parts into a Makefile.
@@ -647,11 +682,11 @@ A project setup file can be obtained by exporting a project (see menu).
   :group 'vhdl-port
   :group 'vhdl-compose)
 
-(defcustom vhdl-standard '(87 nil)
+(defcustom vhdl-standard '(93 nil)
   "VHDL standards used.
 Basic standard:
   VHDL'87      : IEEE Std 1076-1987
-  VHDL'93      : IEEE Std 1076-1993
+  VHDL'93/02   : IEEE Std 1076-1993/2002
 Additional standards:
   VHDL-AMS     : IEEE Std 1076.1 (analog-mixed-signal)
   Math packages: IEEE Std 1076.2 (`math_real', `math_complex')
@@ -660,7 +695,7 @@ 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" 93))
+		       (const :tag "VHDL'93/02" 93))
 	       (set :tag "Additional standards" :indent 2
 		    (const :tag "VHDL-AMS" ams)
 		    (const :tag "Math packages" math)))
@@ -730,6 +765,14 @@ This is done when expanded."
 		 (const :tag "Always" always))
   :group 'vhdl-style)
 
+(defcustom vhdl-array-index-record-field-in-sensitivity-list t
+  "Non-nil means include array indices / record fields in sensitivity list.
+If a signal read in a process is a record field or pointed to by an array
+index, the record field or array index is included with the record name in
+the sensitivity list (e.g. \"in1(0)\", \"in2.f0\").
+Otherwise, only the record name is included (e.g. \"in1\", \"in2\")."
+  :type 'boolean
+  :group 'vhdl-style)
 
 (defgroup vhdl-naming nil
   "Customizations for naming conventions."
@@ -916,7 +959,8 @@ if the header needs to be version controlled.
 The following keywords for template generation are supported:
   <filename>    : replaced by the name of the buffer
   <author>      : replaced by the user name and email address
-                  \(`user-full-name', `mail-host-address', `user-mail-address')
+                  \(`user-full-name',`mail-host-address', `user-mail-address')
+  <authorfull>  : replaced by the user full name (`user-full-name')
   <login>       : replaced by user login name (`user-login-name')
   <company>     : replaced by contents of option `vhdl-company-name'
   <date>        : replaced by the current date
@@ -999,11 +1043,12 @@ NOTE: Activate the new setting in a VHDL buffer by using the menu entry
   "Customizations for sequential processes."
   :group 'vhdl-template)
 
-(defcustom vhdl-reset-kind 'async
+(defcustom  vhdl-reset-kind 'async
   "Specifies which kind of reset to use in sequential processes."
   :type '(choice (const :tag "None" none)
 		 (const :tag "Synchronous" sync)
-		 (const :tag "Asynchronous" async))
+		 (const :tag "Asynchronous" async)
+		 (const :tag "Query" query))
   :group 'vhdl-sequential-process)
 
 (defcustom vhdl-reset-active-high nil
@@ -1563,22 +1608,25 @@ NOTE: Activate the new setting in a VHDL buffer by re-fontifying it (menu
   :group 'vhdl-highlight)
 
 (defcustom vhdl-special-syntax-alist
-  '(("generic/constant" "\\w+_[cg]" "Gold3" "BurlyWood1")
-    ("type" "\\w+_t" "ForestGreen" "PaleGreen")
-    ("variable" "\\w+_v" "Grey50" "Grey80"))
+  '(("generic/constant" "\\<\\w+_[cg]\\>" "Gold3" "BurlyWood1" nil)
+    ("type" "\\<\\w+_t\\>" "ForestGreen" "PaleGreen" nil)
+    ("variable" "\\<\\w+_v\\>" "Grey50" "Grey80" nil))
   "List of special syntax to be highlighted.
 If option `vhdl-highlight-special-words' is non-nil, words with the specified
 syntax (as regular expression) are highlighted in the corresponding color.
 
   Name         : string of words and spaces
   Regexp       : regular expression describing word syntax
-                  (e.g. \"\\\w+_c\" matches word with suffix \"_c\")
+                 (e.g. \"\\\\=\<\\\w+_c\\\\=\>\" matches word with suffix \"_c\")
+                 expression must start with \"\\\\=\<\" and end with \"\\\\=\>\"
+                 if only whole words should be matched (no substrings)
   Color (light): foreground color for light background
                  (matching color examples: Gold3, Grey50, LimeGreen, Tomato,
                  LightSeaGreen, DodgerBlue, Gold, PaleVioletRed)
   Color (dark) : foreground color for dark background
                  (matching color examples: BurlyWood1, Grey80, Green, Coral,
                  AquaMarine2, LightSkyBlue1, Yellow, PaleVioletRed1)
+  In comments  : If non-nil, words are also highlighted inside comments
 
 Can be used for visual support of naming conventions, such as highlighting
 different kinds of signals (e.g. \"Clk50\", \"Rst_n\") or objects (e.g.
@@ -1593,7 +1641,8 @@ NOTE: Activate a changed regexp in a VHDL buffer by re-fontifying it (menu
 		       (string :tag "Name         ")
 		       (regexp :tag "Regexp       " "\\w+_")
 		       (string :tag "Color (light)")
-		       (string :tag "Color (dark) ")))
+		       (string :tag "Color (dark) ")
+		       (boolean :tag "In comments  ")))
   :set (lambda (variable value)
 	 (vhdl-custom-set variable value 'vhdl-font-lock-init))
   :group 'vhdl-highlight)
@@ -1794,6 +1843,14 @@ useful in large files where syntax-based indentation gets very slow."
   :type 'boolean
   :group 'vhdl-misc)
 
+(defcustom vhdl-indent-comment-like-next-code-line t
+  "*Non-nil means comment lines are indented like the following code line.
+Otherwise, comment lines are indented like the preceding code line.
+Indenting comment lines like the following code line gives nicer indentation
+when comments precede the code that they refer to."
+  :type 'boolean
+  :group 'vhdl-misc)
+
 (defcustom vhdl-word-completion-case-sensitive nil
   "Non-nil means word completion using `TAB' is case sensitive.
 That is, `TAB' completes words that start with the same letters and case.
@@ -1833,6 +1890,7 @@ NOTE: Activate the new setting in a VHDL buffer by using the menu entry
   (custom-add-to-group 'vhdl-related 'paren-showing 'custom-group))
 (custom-add-to-group 'vhdl-related 'ps-print 'custom-group)
 (custom-add-to-group 'vhdl-related 'speedbar 'custom-group)
+(custom-add-to-group 'vhdl-related 'comment-style 'custom-variable)
 (custom-add-to-group 'vhdl-related 'line-number-mode 'custom-variable)
 (unless (featurep 'xemacs)
   (custom-add-to-group 'vhdl-related 'transient-mark-mode 'custom-variable))
@@ -1841,6 +1899,15 @@ NOTE: Activate the new setting in a VHDL buffer by using the menu entry
 (custom-add-to-group 'vhdl-related 'user-mail-address 'custom-variable)
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Hidden user variables
+
+(defvar vhdl-compile-absolute-path nil
+  "If non-nil, use absolute instead of relative path for compiled files.")
+
+(defvar vhdl-comment-display-line-char ?-
+  "Character to use in comment display line.")
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;; Internal variables
 
 (defvar vhdl-menu-max-size 20
@@ -3270,9 +3337,6 @@ STRING are replaced by `-' and substrings are converted to lower case."
       (list
        (append
 	'("Package")
-	(when (vhdl-standard-p 'math)
-	  '(["math_complex"	vhdl-template-package-math-complex t]
-	    ["math_real"	vhdl-template-package-math-real t]))
 	'(["numeric_bit"	vhdl-template-package-numeric-bit t]
 	  ["numeric_std"	vhdl-template-package-numeric-std t]
 	  ["std_logic_1164"	vhdl-template-package-std-logic-1164 t]
@@ -3283,8 +3347,22 @@ STRING are replaced by `-' and substrings are converted to lower case."
 	  ["std_logic_unsigned"	vhdl-template-package-std-logic-unsigned t]
 	  ["std_logic_misc"	vhdl-template-package-std-logic-misc t]
 	  ["std_logic_textio"	vhdl-template-package-std-logic-textio t]
-	  "--"
-	  ["Insert Package..."	vhdl-template-insert-package
+	  "--")
+	(when (vhdl-standard-p 'ams)
+	  '(["fundamental_constants" vhdl-template-package-fundamental-constants t]
+	    ["material_constants" vhdl-template-package-material-constants t]
+	    ["energy_systems"	vhdl-template-package-energy-systems t]
+	    ["electrical_systems" vhdl-template-package-electrical-systems t]
+	    ["mechanical_systems" vhdl-template-package-mechanical-systems t]
+	    ["radiant_systems"	vhdl-template-package-radiant-systems t]
+	    ["thermal_systems"	vhdl-template-package-thermal-systems t]
+	    ["fluidic_systems"	vhdl-template-package-fluidic-systems t]
+	    "--"))
+	(when (vhdl-standard-p 'math)
+	  '(["math_complex"	vhdl-template-package-math-complex t]
+	    ["math_real"	vhdl-template-package-math-real t]
+	    "--"))
+	'(["Insert Package..."	vhdl-template-insert-package
 				:keys "C-c C-i C-p"])))
       '(("Directive"
 	 ["translate_on"	vhdl-template-directive-translate-on t]
@@ -3417,6 +3495,7 @@ STRING are replaced by `-' and substrings are converted to lower case."
      ["Buffer"			vhdl-beautify-buffer t])
     ("Fix"
      ["Generic/Port Clause"	vhdl-fix-clause t]
+     ["Generic/Port Clause Buffer" vhdl-fix-clause t]
      "--"
      ["Case Region"		vhdl-fix-case-region (mark)]
      ["Case Buffer"		vhdl-fix-case-buffer t]
@@ -3449,11 +3528,13 @@ STRING are replaced by `-' and substrings are converted to lower case."
      ("Mode"
       ["Electric Mode"
        (progn (customize-set-variable 'vhdl-electric-mode
-				      (not vhdl-electric-mode)))
+				      (not vhdl-electric-mode))
+	      (vhdl-mode-line-update))
        :style toggle :selected vhdl-electric-mode :keys "C-c C-m C-e"]
       ["Stutter Mode"
        (progn (customize-set-variable 'vhdl-stutter-mode
-				      (not vhdl-stutter-mode)))
+				      (not vhdl-stutter-mode))
+	      (vhdl-mode-line-update))
        :style toggle :selected vhdl-stutter-mode :keys "C-c C-m C-s"]
       ["Indent Tabs Mode"
        (progn (customize-set-variable 'vhdl-indent-tabs-mode
@@ -3515,6 +3596,8 @@ STRING are replaced by `-' and substrings are converted to lower case."
        (customize-set-variable 'vhdl-compile-use-local-error-regexp
 			       (not vhdl-compile-use-local-error-regexp))
        :style toggle :selected vhdl-compile-use-local-error-regexp]
+      ["Makefile Default Targets..."
+       (customize-option 'vhdl-makefile-default-targets) t]
       ["Makefile Generation Hook..."
        (customize-option 'vhdl-makefile-generation-hook) t]
       ["Default Library Name" (customize-option 'vhdl-default-library) t]
@@ -3527,7 +3610,7 @@ STRING are replaced by `-' and substrings are converted to lower case."
 				       (list '87 (cadr vhdl-standard)))
 	       (vhdl-activate-customizations))
 	:style radio :selected (eq '87 (car vhdl-standard))]
-       ["VHDL'93"
+       ["VHDL'93/02"
 	(progn (customize-set-variable 'vhdl-standard
 				       (list '93 (cadr vhdl-standard)))
 	       (vhdl-activate-customizations))
@@ -3580,6 +3663,10 @@ STRING are replaced by `-' and substrings are converted to lower case."
        ["Always"
 	(customize-set-variable 'vhdl-use-direct-instantiation 'always)
 	:style radio :selected (eq 'always vhdl-use-direct-instantiation)])
+      ["Include Array Index and Record Field in Sensitivity List"
+       (customize-set-variable 'vhdl-array-index-record-field-in-sensitivity-list
+			       (not vhdl-array-index-record-field-in-sensitivity-list))
+       :style toggle :selected vhdl-array-index-record-field-in-sensitivity-list]
       "--"
       ["Customize Group..." (customize-group 'vhdl-style) t])
      ("Naming"
@@ -3676,7 +3763,10 @@ STRING are replaced by `-' and substrings are converted to lower case."
 	 :style radio :selected (eq 'sync vhdl-reset-kind)]
 	["Asynchronous"
 	 (customize-set-variable 'vhdl-reset-kind 'async)
-	 :style radio :selected (eq 'async vhdl-reset-kind)])
+	 :style radio :selected (eq 'async vhdl-reset-kind)]
+	["Query"
+	 (customize-set-variable 'vhdl-reset-kind 'query)
+	 :style radio :selected (eq 'query vhdl-reset-kind)])
        ["Reset is Active High"
 	(customize-set-variable 'vhdl-reset-active-high
 				(not vhdl-reset-active-high))
@@ -3966,6 +4056,10 @@ STRING are replaced by `-' and substrings are converted to lower case."
        (customize-set-variable 'vhdl-indent-syntax-based
 			       (not vhdl-indent-syntax-based))
        :style toggle :selected vhdl-indent-syntax-based]
+      ["Indent Comments Like Next Code Line"
+       (customize-set-variable 'vhdl-indent-comment-like-next-code-line
+			       (not vhdl-indent-comment-like-next-code-line))
+       :style toggle :selected vhdl-indent-comment-like-next-code-line]
       ["Word Completion is Case Sensitive"
        (customize-set-variable 'vhdl-word-completion-case-sensitive
 			       (not vhdl-word-completion-case-sensitive))
@@ -4009,7 +4103,7 @@ STRING are replaced by `-' and substrings are converted to lower case."
      "^\\s-*\\(\\(\\(impure\\|pure\\)\\s-+\\|\\)function\\|procedure\\)\\s-+\\(\"?\\(\\w\\|\\s_\\)+\"?\\)"
      4)
     ("Instance"
-     "^\\s-*\\(\\(\\w\\|\\s_\\)+\\s-*:\\(\\s-\\|\n\\)*\\(\\w\\|\\s_\\)+\\)\\(\\s-\\|\n\\)+\\(generic\\|port\\)\\s-+map\\>"
+     "^\\s-*\\(\\(\\w\\|\\s_\\)+\\s-*:\\(\\s-\\|\n\\)*\\(entity\\s-+\\(\\w\\|\\s_\\)+\\.\\)?\\(\\w\\|\\s_\\)+\\)\\(\\s-\\|\n\\)+\\(generic\\|port\\)\\s-+map\\>"
      1)
     ("Component"
      "^\\s-*\\(component\\)\\s-+\\(\\(\\w\\|\\s_\\)+\\)"
@@ -4132,7 +4226,7 @@ Usage:
     brackets and removed if the queried string is left empty.  Prompts for
     mandatory arguments remain in the code if the queried string is left
     empty.  They can be queried again by `C-c C-t C-q'.  Enabled
-    electrification is indicated by `/e' in the modeline.
+    electrification is indicated by `/e' in the mode line.
 
       Typing `M-SPC' after a keyword inserts a space without calling the
     template generator.  Automatic template generation (i.e.
@@ -4159,7 +4253,7 @@ Usage:
     Double striking of some keys inserts cumbersome VHDL syntax elements.
     Stuttering can be disabled (enabled) by typing `C-c C-m C-s' or by
     option `vhdl-stutter-mode'.  Enabled stuttering is indicated by `/s' in
-    the modeline.  The stuttering keys and their effects are:
+    the mode line.  The stuttering keys and their effects are:
 
       ;;   -->  \" : \"       [   -->  (        --    -->  comment
       ;;;  -->  \" := \"      [[  -->  [        --CR  -->  comment-out code
@@ -4193,8 +4287,10 @@ Usage:
                    with a comment in between.
         `--CR'     comments out code on that line.  Re-hitting CR comments
                    out following lines.
-        `C-c c'    comments out a region if not commented out,
-                   uncomments a region if already commented out.
+        `C-c C-c'  comments out a region if not commented out,
+                   uncomments a region if already commented out.  Option
+                   `comment-style' defines where the comment characters
+                   should be placed (beginning of line, indent, etc.).
 
       You are prompted for comments after object definitions (i.e. signals,
     variables, constants, ports) and after subprogram and process
@@ -4215,7 +4311,8 @@ Usage:
     `TAB' indents a line if at the beginning of the line.  The amount of
     indentation is specified by option `vhdl-basic-offset'.  `C-c C-i C-l'
     always indents the current line (is bound to `TAB' if option
-    `vhdl-intelligent-tab' is nil).
+    `vhdl-intelligent-tab' is nil).  If a region is active, `TAB' indents
+    the entire region.
 
       Indentation can be done for a group of lines (`C-c C-i C-g'), a region
     \(`M-C-\\') or the entire buffer (menu).  Argument and port lists are
@@ -4229,6 +4326,10 @@ Usage:
       Syntax-based indentation can be very slow in large files.  Option
     `vhdl-indent-syntax-based' allows to use faster but simpler indentation.
 
+      Option `vhdl-indent-comment-like-next-code-line' controls whether
+    comment lines are indented like the preceding or like the following code
+    line.
+
 
   ALIGNMENT:
     The alignment functions align operators, keywords, and inline comments
@@ -4357,12 +4458,12 @@ Usage:
 
 
   STRUCTURAL COMPOSITION:
-    Enables simple structural composition.  `C-c C-c C-n' creates a skeleton
+    Enables simple structural composition.  `C-c C-m C-n' creates a skeleton
     for a new component.  Subcomponents (i.e. component declaration and
     instantiation) can be automatically placed from a previously read port
-    \(`C-c C-c C-p') or directly from the hierarchy browser (`P').  Finally,
+    \(`C-c C-m C-p') or directly from the hierarchy browser (`P').  Finally,
     all subcomponents can be automatically connected using internal signals
-    and ports (`C-c C-c C-w') following these rules:
+    and ports (`C-c C-m C-w') following these rules:
       - subcomponent actual ports with same name are considered to be
         connected by a signal (internal signal or port)
       - signals that are only inputs to subcomponents are considered as
@@ -4383,25 +4484,25 @@ Usage:
 
       Component declarations can be placed in a components package (option
     `vhdl-use-components-package') which can be automatically generated for
-    an entire directory or project (`C-c C-c M-p').  The VHDL'93 direct
+    an entire directory or project (`C-c C-m M-p').  The VHDL'93 direct
     component instantiation is also supported (option
     `vhdl-use-direct-instantiation').
 
-|     Configuration declarations can automatically be generated either from
-|   the menu (`C-c C-c C-f') (for the architecture the cursor is in) or from
-|   the speedbar menu (for the architecture under the cursor).  The
-|   configurations can optionally be hierarchical (i.e. include all
-|   component levels of a hierarchical design, option
-|   `vhdl-compose-configuration-hierarchical') or include subconfigurations
-|   (option `vhdl-compose-configuration-use-subconfiguration').  For
-|   subcomponents in hierarchical configurations, the most-recently-analyzed
-|   (mra) architecture is selected.  If another architecture is desired, it
-|   can be marked as most-recently-analyzed (speedbar menu) before
-|   generating the configuration.
-|
-|     Note: Configurations of subcomponents (i.e. hierarchical configuration
-|   declarations) are currently not considered when displaying
-|   configurations in speedbar.
+      Configuration declarations can automatically be generated either from
+    the menu (`C-c C-m C-f') (for the architecture the cursor is in) or from
+    the speedbar menu (for the architecture under the cursor).  The
+    configurations can optionally be hierarchical (i.e. include all
+    component levels of a hierarchical design, option
+    `vhdl-compose-configuration-hierarchical') or include subconfigurations
+    (option `vhdl-compose-configuration-use-subconfiguration').  For
+    subcomponents in hierarchical configurations, the most-recently-analyzed
+    (mra) architecture is selected.  If another architecture is desired, it
+    can be marked as most-recently-analyzed (speedbar menu) before
+    generating the configuration.
+ 
+      Note: Configurations of subcomponents (i.e. hierarchical configuration
+    declarations) are currently not considered when displaying
+    configurations in speedbar.
 
       See the options group `vhdl-compose' for all relevant user options.
 
@@ -4433,11 +4534,13 @@ Usage:
 
       The Makefile's default target \"all\" compiles the entire design, the
     target \"clean\" removes it and the target \"library\" creates the
-    library directory if not existent.  The Makefile also includes a target
-    for each primary library unit which allows selective compilation of this
-    unit, its secondary units and its subhierarchy (example: compilation of
-    a design specified by a configuration).  User specific parts can be
-    inserted into a Makefile with option `vhdl-makefile-generation-hook'.
+    library directory if not existent.  These target names can be customized
+    by option `vhdl-makefile-default-targets'.  The Makefile also includes a
+    target for each primary library unit which allows selective compilation
+    of this unit, its secondary units and its subhierarchy (example:
+    compilation of a design specified by a configuration).  User specific
+    parts can be inserted into a Makefile with option
+    `vhdl-makefile-generation-hook'.
 
     Limitations:
       - Only library units and dependencies within the current library are
@@ -4483,7 +4586,7 @@ Usage:
 
   VHDL STANDARDS:
     The VHDL standards to be used are specified in option `vhdl-standard'.
-    Available standards are: VHDL'87/'93, VHDL-AMS, and Math Packages.
+    Available standards are: VHDL'87/'93(02), VHDL-AMS, and Math Packages.
 
 
   KEYWORD CASE:
@@ -4559,6 +4662,9 @@ Usage:
         - Out parameters of procedures are considered to be read.
       Use option `vhdl-entity-file-name' to specify the entity file name
       \(used to obtain the port names).
+      Use option `vhdl-array-index-record-field-in-sensitivity-list' to
+      specify whether to include array indices and record fields in
+      sensitivity lists.
 
 
   CODE FIXING:
@@ -4632,16 +4738,17 @@ releases.  You are kindly invited to participate in beta testing.  Subscribe
 to above mailing lists by sending an email to <reto@gnu.org>.
 
 VHDL Mode is officially distributed at
-URL `http://opensource.ethz.ch/emacs/vhdl-mode.html'
+http://www.iis.ee.ethz.ch/~zimmi/emacs/vhdl-mode.html
 where the latest version can be found.
 
 
 Known problems:
 ---------------
 
-- Indentation bug in simultaneous if- and case-statements (VHDL-AMS).
 - XEmacs: Incorrect start-up when automatically opening speedbar.
 - XEmacs: Indentation in XEmacs 21.4 (and higher).
+- Indentation incorrect for new 'postponed' VHDL keyword.
+- Indentation incorrect for 'protected body' construct.
 
 
                                                 The VHDL Mode Authors
@@ -4764,7 +4871,7 @@ Key bindings:
 ;;; Keywords and standardized words
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
-(defconst vhdl-93-keywords
+(defconst vhdl-02-keywords
   '(
     "abs" "access" "after" "alias" "all" "and" "architecture" "array"
     "assert" "attribute"
@@ -4779,7 +4886,7 @@ Key bindings:
     "map" "mod"
     "nand" "new" "next" "nor" "not" "null"
     "of" "on" "open" "or" "others" "out"
-    "package" "port" "postponed" "procedure" "process" "pure"
+    "package" "port" "postponed" "procedure" "process" "protected" "pure"
     "range" "record" "register" "reject" "rem" "report" "return"
     "rol" "ror"
     "select" "severity" "shared" "signal" "sla" "sll" "sra" "srl" "subtype"
@@ -4789,7 +4896,7 @@ Key bindings:
     "wait" "when" "while" "with"
     "xnor" "xor"
     )
-  "List of VHDL'93 keywords.")
+  "List of VHDL'02 keywords.")
 
 (defconst vhdl-ams-keywords
   '(
@@ -4822,7 +4929,7 @@ Key bindings:
     )
   "List of Verilog keywords as candidate for additional reserved words.")
 
-(defconst vhdl-93-types
+(defconst vhdl-02-types
   '(
     "boolean" "bit" "bit_vector" "character" "severity_level" "integer"
     "real" "time" "natural" "positive" "string" "line" "text" "side"
@@ -4830,25 +4937,72 @@ Key bindings:
     "std_logic" "std_logic_vector"
     "std_ulogic" "std_ulogic_vector"
     )
-  "List of VHDL'93 standardized types.")
+  "List of VHDL'02 standardized types.")
 
 (defconst vhdl-ams-types
+  ;; standards: IEEE Std 1076.1-2007, IEEE Std 1076.1.1-2004
   '(
+    ;; package `standard'
     "domain_type" "real_vector"
-    ;; from `nature_pkg' package
-    "voltage" "current" "electrical" "position" "velocity" "force"
-    "mechanical_vf" "mechanical_pf" "rotvel" "torque" "rotational"
-    "pressure" "flowrate" "fluid"
-  )
+    ;; package `energy_systems'
+    "energy" "power" "periodicity" "real_across" "real_through" "unspecified"
+    "unspecified_vector" "energy_vector" "power_vector" "periodicity_vector"
+    "real_across_vector" "real_through_vector"
+    ;; package `electrical_systems'
+    "voltage" "current" "charge" "resistance" "conductance" "capacitance"
+    "mmf" "electric_flux" "electric_flux_density" "electric_field_strength"
+    "magnetic_flux" "magnetic_flux_density" "magnetic_field_strength"
+    "inductance" "reluctance" "electrical" "electrical_vector" "magnetic"
+    "magnetic_vector" "voltage_vector" "current_vector" "mmf_vector"
+    "magnetic_flux_vector" "charge_vector" "resistance_vector"
+    "conductance_vector" "capacitance_vector" "electric_flux_vector"
+    "electric_flux_density_vector" "electric_field_strength_vector"
+    "magnetic_flux_density_vector" "magnetic_field_strength_vector"
+    "inductance_vector" "reluctance_vector" "ground"
+    ;; package `mechanical_systems'
+    "displacement" "force" "velocity" "acceleration" "mass" "stiffness"
+    "damping" "momentum" "angle" "torque" "angular_velocity"
+    "angular_acceleration" "moment_inertia" "angular_momentum"
+    "angular_stiffness" "angular_damping" "translational"
+    "translational_vector" "translational_velocity"
+    "translational_velocity_vector" "rotational" "rotational_vector"
+    "rotational_velocity" "rotational_velocity_vector" "displacement_vector"
+    "force_vector" "velocity_vector" "force_velocity_vector" "angle_vector"
+    "torque_vector" "angular_velocity_vector" "torque_velocity_vector"
+    "acceleration_vector" "mass_vector" "stiffness_vector" "damping_vector"
+    "momentum_vector" "angular_acceleration_vector" "moment_inertia_vector"
+    "angular_momentum_vector" "angular_stiffness_vector"
+    "angular_damping_vector" "anchor" "translational_v_ref"
+    "rotational_v_ref" "translational_v" "rotational_v"
+    ;; package `radiant_systems'
+    "illuminance" "luminous_flux" "luminous_intensity" "irradiance" "radiant"
+    "radiant_vector" "luminous_intensity_vector" "luminous_flux_vector"
+    "illuminance_vector" "irradiance_vector"
+    ;; package `thermal_systems'
+    "temperature" "heat_flow" "thermal_capacitance" "thermal_resistance"
+    "thermal_conductance" "thermal" "thermal_vector" "temperature_vector"
+    "heat_flow_vector" "thermal_capacitance_vector"
+    "thermal_resistance_vector" "thermal_conductance_vector"
+    ;; package `fluidic_systems'
+    "pressure" "vflow_rate" "mass_flow_rate" "volume" "density" "viscosity"
+    "fresistance" "fconductance" "fcapacitance" "inertance" "cfresistance"
+    "cfcapacitance" "cfinertance" "cfconductance" "fluidic" "fluidic_vector"
+    "compressible_fluidic" "compressible_fluidic_vector" "pressure_vector"
+    "vflow_rate_vector" "mass_flow_rate_vector" "volume_vector"
+    "density_vector" "viscosity_vector" "fresistance_vector"
+    "fconductance_vector" "fcapacitance_vector" "inertance_vector"
+    "cfresistance_vector" "cfconductance_vector" "cfcapacitance_vector"
+    "cfinertance_vector"
+    )
   "List of VHDL-AMS standardized types.")
 
 (defconst vhdl-math-types
   '(
-    "complex" "complex_polar"
+    "complex" "complex_polar" "positive_real" "principal_value"
     )
   "List of Math Packages standardized types.")
 
-(defconst vhdl-93-attributes
+(defconst vhdl-02-attributes
   '(
     "base" "left" "right" "high" "low" "pos" "val" "succ"
     "pred" "leftof" "rightof" "range" "reverse_range"
@@ -4858,7 +5012,7 @@ Key bindings:
     "simple_name" "instance_name" "path_name"
     "foreign"
     )
-  "List of VHDL'93 standardized attributes.")
+  "List of VHDL'02 standardized attributes.")
 
 (defconst vhdl-ams-attributes
   '(
@@ -4869,7 +5023,7 @@ Key bindings:
     )
   "List of VHDL-AMS standardized attributes.")
 
-(defconst vhdl-93-enum-values
+(defconst vhdl-02-enum-values
   '(
     "true" "false"
     "note" "warning" "error" "failure"
@@ -4878,7 +5032,7 @@ Key bindings:
     "fs" "ps" "ns" "us" "ms" "sec" "min" "hr"
     "right" "left"
     )
-  "List of VHDL'93 standardized enumeration values.")
+  "List of VHDL'02 standardized enumeration values.")
 
 (defconst vhdl-ams-enum-values
   '(
@@ -4888,22 +5042,38 @@ Key bindings:
     )
   "List of VHDL-AMS standardized enumeration values.")
 
+(defconst vhdl-ams-constants
+  ;; standard: IEEE Std 1076.1.1-2004
+  '(
+    ;; package `fundamental_constants'
+    "phys_q" "phys_eps0" "phys_mu0" "phys_k" "phys_gravity" "phys_ctok"
+    "phys_c" "phys_h" "phys_h_over_2_pi" "yocto" "zepto" "atto" "femto"
+    "pico" "nano" "micro" "milli" "centi" "deci" "deka" "hecto" "kilo" "mega"
+    "giga" "tera" "peta" "exa" "zetta" "yotta" "deca"
+    ;; package `material_constants'
+    "phys_eps_si" "phys_eps_sio2" "phys_e_si" "phys_e_sio2" "phys_e_poly"
+    "phys_nu_si" "phys_nu_poly" "phys_rho_poly" "phys_rho_sio2"
+    "ambient_temperature" "ambient_pressure" "ambient_illuminance"
+    )
+  "List of VHDL-AMS standardized constants.")
+
 (defconst vhdl-math-constants
+  ;; standard: IEEE Std 1076.2-1996
   '(
-    "math_e" "math_1_over_e"
-    "math_pi" "math_two_pi" "math_1_over_pi"
-    "math_half_pi" "math_q_pi" "math_3_half_pi"
-    "math_log_of_2" "math_log_of_10" "math_log2_of_e" "math_log10_of_e"
-    "math_sqrt2" "math_sqrt1_2" "math_sqrt_pi"
-    "math_deg_to_rad" "math_rad_to_deg"
-    "cbase_1" "cbase_j" "czero"
+    "math_1_over_e" "math_1_over_pi" "math_1_over_sqrt_2" "math_2_pi"
+    "math_3_pi_over_2" "math_cbase_1" "math_cbase_j" "math_czero"
+    "math_deg_to_rad" "math_e" "math_log10_of_e" "math_log2_of_e"
+    "math_log_of_10" "math_log_of_2" "math_pi" "math_pi_over_2"
+    "math_pi_over_3" "math_pi_over_4" "math_rad_to_deg" "math_sqrt_2"
+    "math_sqrt_pi"
     )
   "List of Math Packages standardized constants.")
 
-(defconst vhdl-93-functions
+(defconst vhdl-02-functions
   '(
     "now" "resolved" "rising_edge" "falling_edge"
-    "read" "readline" "write" "writeline" "endfile"
+    "read" "readline" "hread" "oread" "write" "writeline" "hwrite" "owrite"
+    "endfile"
     "resize" "is_X" "std_match"
     "shift_left" "shift_right" "rotate_left" "rotate_right"
     "to_unsigned" "to_signed" "to_integer"
@@ -4913,25 +5083,27 @@ Key bindings:
     "shl" "shr" "ext" "sxt"
     "deallocate"
     )
-  "List of VHDL'93 standardized functions.")
+  "List of VHDL'02 standardized functions.")
 
 (defconst vhdl-ams-functions
   '(
+    ;; package `standard'
     "frequency"
     )
   "List of VHDL-AMS standardized functions.")
 
 (defconst vhdl-math-functions
+  ;; standard: IEEE Std 1076.2-1996
   '(
-    "sign" "ceil" "floor" "round" "trunc" "fmax" "fmin" "uniform"
-    "sqrt" "cbrt" "exp" "log"
-    "sin" "cos" "tan" "arcsin" "arccos" "arctan"
-    "sinh" "cosh" "tanh" "arcsinh" "arccosh" "arctanh"
-    "cmplx" "complex_to_polar" "polar_to_complex" "arg" "conj"
+    "arccos" "arccosh" "arcsin" "arcsinh" "arctan" "arctanh" "arg"
+    "cbrt" "ceil" "cmplx" "complex_to_polar" "conj" "cos" "cosh" "exp"
+    "floor" "get_principal_value" "log" "log10" "log2" "polar_to_complex"
+    "realmax" "realmin" "round" "sign" "sin" "sinh" "sqrt"
+    "tan" "tanh" "trunc" "uniform"
     )
   "List of Math Packages standardized functions.")
 
-(defconst vhdl-93-packages
+(defconst vhdl-02-packages
   '(
     "std_logic_1164" "numeric_std" "numeric_bit"
     "standard" "textio"
@@ -4939,12 +5111,13 @@ Key bindings:
     "std_logic_misc" "std_logic_textio"
     "ieee" "std" "work"
     )
-  "List of VHDL'93 standardized packages and libraries.")
+  "List of VHDL'02 standardized packages and libraries.")
 
 (defconst vhdl-ams-packages
   '(
-    ;; from `nature_pkg' package
-    "nature_pkg"
+    "fundamental_constants" "material_constants" "energy_systems"
+    "electrical_systems" "mechanical_systems" "radiant_systems"
+    "thermal_systems" "fluidic_systems"
     )
   "List of VHDL-AMS standardized packages and libraries.")
 
@@ -4990,6 +5163,9 @@ Key bindings:
 (defvar vhdl-enum-values-regexp nil
   "Regexp for VHDL standardized enumeration values.")
 
+(defvar vhdl-constants-regexp nil
+  "Regexp for VHDL standardized constants.")
+
 (defvar vhdl-functions-regexp nil
   "Regexp for VHDL standardized functions.")
 
@@ -5002,29 +5178,50 @@ Key bindings:
 (defvar vhdl-directive-keywords-regexp nil
   "Regexp for compiler directive keywords.")
 
+(defun vhdl-upcase-list (condition list)
+  "Upcase all elements in LIST based on CONDITION."
+  (when condition
+    (let ((tmp-list list))
+      (while tmp-list
+	(setcar tmp-list (upcase (car tmp-list)))
+	(setq tmp-list (cdr tmp-list)))))
+  list)
+
 (defun vhdl-words-init ()
   "Initialize reserved words."
   (setq vhdl-keywords
-	(append vhdl-93-keywords
-		(when (vhdl-standard-p 'ams) vhdl-ams-keywords)))
+	(vhdl-upcase-list
+	 (and vhdl-highlight-case-sensitive vhdl-upper-case-keywords)
+	 (append vhdl-02-keywords
+		 (when (vhdl-standard-p 'ams) vhdl-ams-keywords))))
   (setq vhdl-types
-	(append vhdl-93-types
-		(when (vhdl-standard-p 'ams) vhdl-ams-types)
-		(when (vhdl-standard-p 'math) vhdl-math-types)))
+	(vhdl-upcase-list
+	 (and vhdl-highlight-case-sensitive vhdl-upper-case-types)
+	 (append vhdl-02-types
+		 (when (vhdl-standard-p 'ams) vhdl-ams-types)
+		 (when (vhdl-standard-p 'math) vhdl-math-types))))
   (setq vhdl-attributes
-	(append vhdl-93-attributes
-		(when (vhdl-standard-p 'ams) vhdl-ams-attributes)))
+	(vhdl-upcase-list
+	 (and vhdl-highlight-case-sensitive vhdl-upper-case-attributes)
+	 (append vhdl-02-attributes
+		 (when (vhdl-standard-p 'ams) vhdl-ams-attributes))))
   (setq vhdl-enum-values
-	(append vhdl-93-enum-values
-		(when (vhdl-standard-p 'ams) vhdl-ams-enum-values)))
+	(vhdl-upcase-list
+	 (and vhdl-highlight-case-sensitive vhdl-upper-case-enum-values)
+	 (append vhdl-02-enum-values
+		 (when (vhdl-standard-p 'ams) vhdl-ams-enum-values))))
   (setq vhdl-constants
-	(append (when (vhdl-standard-p 'math) vhdl-math-constants)))
+	(vhdl-upcase-list
+	 (and vhdl-highlight-case-sensitive vhdl-upper-case-constants)
+	 (append (when (vhdl-standard-p 'ams) vhdl-ams-constants)
+		 (when (vhdl-standard-p 'math) vhdl-math-constants)
+		 '(""))))
   (setq vhdl-functions
-	(append vhdl-93-functions
+	(append vhdl-02-functions
 		(when (vhdl-standard-p 'ams) vhdl-ams-functions)
 		(when (vhdl-standard-p 'math) vhdl-math-functions)))
   (setq vhdl-packages
-	(append vhdl-93-packages
+	(append vhdl-02-packages
 		(when (vhdl-standard-p 'ams) vhdl-ams-packages)
 		(when (vhdl-standard-p 'math) vhdl-math-packages)))
   (setq vhdl-reserved-words
@@ -5039,6 +5236,8 @@ Key bindings:
 	(concat "\\<\\(" (regexp-opt vhdl-attributes) "\\)\\>"))
   (setq vhdl-enum-values-regexp
 	(concat "\\<\\(" (regexp-opt vhdl-enum-values) "\\)\\>"))
+  (setq vhdl-constants-regexp
+	(concat "\\<\\(" (regexp-opt vhdl-constants) "\\)\\>"))
   (setq vhdl-functions-regexp
 	(concat "\\<\\(" (regexp-opt vhdl-functions) "\\)\\>"))
   (setq vhdl-packages-regexp
@@ -5090,7 +5289,7 @@ We cannot use just `word' syntax class since `_' cannot be in word
 class.  Putting underscore in word class breaks forward word movement
 behavior that users are familiar with.")
 
-(defconst vhdl-case-header-key "case[( \t\n][^;=>]+[) \t\n]is"
+(defconst vhdl-case-header-key "case[( \t\n\r\f][^;=>]+[) \t\n\r\f]is"
   "Regexp describing a case statement header key.")
 
 (defconst vhdl-label-key
@@ -5318,6 +5517,17 @@ the offset is simply returned."
   "Check if point is in a string."
   (eq (vhdl-in-literal) 'string))
 
+(defun vhdl-in-quote-p ()
+  "Check if point is in a quote ('x')."
+  (or (and (> (point) (point-min))
+	   (< (1+ (point)) (point-max))
+	   (= (char-before (point)) ?\')
+	   (= (char-after (1+ (point))) ?\'))
+      (and (> (1- (point)) (point-min))
+	   (< (point) (point-max))
+	   (= (char-before (1- (point))) ?\')
+	   (= (char-after (point)) ?\'))))
+
 (defun vhdl-in-literal ()
   "Determine if point is in a VHDL literal."
   (save-excursion
@@ -5328,6 +5538,12 @@ the offset is simply returned."
        ((vhdl-beginning-of-macro) 'pound)
        (t nil)))))
 
+(defun vhdl-in-extended-identifier-p ()
+  "Determine if point is inside extended identifier (delimited by '\')."
+  (save-match-data
+    (and (save-excursion (re-search-backward "\\\\" (vhdl-point 'bol) t))
+	 (save-excursion (re-search-forward "\\\\" (vhdl-point 'eol) t)))))
+
 (defun vhdl-forward-comment (&optional direction)
   "Skip all comments (including whitespace).  Skip backwards if DIRECTION is
 negative, skip forward otherwise."
@@ -5335,20 +5551,30 @@ negative, skip forward otherwise."
   (if (and direction (< direction 0))
       ;; skip backwards
       (progn
-	(skip-chars-backward " \t\n")
+	(skip-chars-backward " \t\n\r\f")
 	(while (re-search-backward "^[^\"-]*\\(\\(-?\"[^\"]*\"\\|-[^\"-]\\)[^\"-]*\\)*\\(--\\)" (vhdl-point 'bol) t)
 	  (goto-char (match-beginning 3))
-	  (skip-chars-backward " \t\n")))
+	  (skip-chars-backward " \t\n\r\f")))
     ;; skip forwards
-    (skip-chars-forward " \t\n")
+    (skip-chars-forward " \t\n\r\f")
     (while (looking-at "--.*")
       (goto-char (match-end 0))
-      (skip-chars-forward " \t\n"))))
+      (skip-chars-forward " \t\n\r\f"))))
 
 ;; XEmacs hack: work around buggy `forward-comment' in XEmacs 21.4+
 (unless (and (featurep 'xemacs) (string< "21.2" emacs-version))
   (defalias 'vhdl-forward-comment 'forward-comment))
 
+(defun vhdl-back-to-indentation ()
+  "Move point to the first non-whitespace character on this line."
+  (interactive)
+  (beginning-of-line 1)
+  (skip-syntax-forward " " (vhdl-point 'eol)))
+
+;; XEmacs hack: work around old `back-to-indentation' in XEmacs
+(when (featurep 'xemacs)
+  (defalias 'back-to-indentation 'vhdl-back-to-indentation))
+
 ;; This is the best we can do in Win-Emacs.
 (defun vhdl-win-il (&optional lim)
   "Determine if point is in a VHDL literal."
@@ -5513,7 +5739,7 @@ that point, else nil."
   (and
    (save-excursion
      (forward-sexp)
-     (skip-chars-forward " \t\n")
+     (skip-chars-forward " \t\n\r\f")
      (not (looking-at "is\\b[^_]")))
    (save-excursion
      (backward-sexp)
@@ -5553,12 +5779,12 @@ corresponding \"begin\" keyword, else return nil."
 	   "is"))))
 
 (defconst vhdl-begin-fwd-re
-  "\\b\\(is\\|begin\\|block\\|component\\|generate\\|then\\|else\\|loop\\|process\\|procedural\\|units\\|record\\|for\\)\\b\\([^_]\\|\\'\\)"
+  "\\b\\(is\\|begin\\|block\\|component\\|generate\\|then\\|else\\|loop\\|process\\|procedural\\(\\s-+body\\)?\\|units\\|use\\|record\\|protected\\(\\s-+body\\)?\\|for\\)\\b\\([^_]\\|\\'\\)"
   "A regular expression for searching forward that matches all known
 \"begin\" keywords.")
 
 (defconst vhdl-begin-bwd-re
-  "\\b\\(is\\|begin\\|block\\|component\\|generate\\|then\\|else\\|loop\\|process\\|procedural\\|units\\|record\\|for\\)\\b[^_]"
+  "\\b\\(is\\|begin\\|block\\|component\\|generate\\|then\\|else\\|loop\\|process\\|procedural\\(\\s-+body\\)?\\|units\\|use\\|record\\|protected\\(\\s-+body\\)?\\|for\\)\\b[^_]"
   "A regular expression for searching backward that matches all known
 \"begin\" keywords.")
 
@@ -5591,21 +5817,21 @@ keyword."
 	   (and (/= (following-char) ?\;)
 		(not (looking-at "is\\|begin\\|process\\|procedural\\|block")))))
     t)
-   ;; "begin", "then":
-   ((looking-at "be\\|t")
+   ;; "begin", "then", "use":
+   ((looking-at "be\\|t\\|use")
     t)
    ;; "else":
    ((and (looking-at "e")
 	 ;; make sure that the "else" isn't inside a
 	 ;; conditional signal assignment.
 	 (save-excursion
-	   (re-search-backward ";\\|\\bwhen\\b[^_]" lim 'move)
+	   (vhdl-re-search-backward ";\\|\\bwhen\\b[^_]" lim 'move)
 	   (or (eq (following-char) ?\;)
 	       (eq (point) lim))))
     t)
    ;; "block", "generate", "loop", "process", "procedural",
-   ;; "units", "record":
-   ((and (looking-at "bl\\|[glpur]")
+   ;; "units", "record", "protected body":
+   ((and (looking-at "block\\|generate\\|loop\\|process\\|procedural\\|protected\\(\\s-+body\\)?\\|units\\|record")
 	 (save-excursion
 	   (backward-sexp)
 	   (not (looking-at "end\\s-+\\w"))))
@@ -5633,7 +5859,7 @@ keyword."
   (cond
    ((looking-at "is\\|block\\|generate\\|process\\|procedural")
     "begin")
-   ((looking-at "then")
+   ((looking-at "then\\|use")
     "<else>")
    (t
     "end")))
@@ -5648,6 +5874,9 @@ Assumes that the caller will make sure that we are not in the middle
 of an identifier that just happens to contain a \"begin\" keyword."
   (save-excursion
     (and (looking-at vhdl-begin-fwd-re)
+	 (or (not (looking-at "\\<use\\>"))
+	     (save-excursion (back-to-indentation)
+			     (looking-at "\\(\\w+\\s-*:\\s-*\\)?\\<\\(case\\|elsif\\|if\\)\\>")))
 	 (/= (preceding-char) ?_)
 	 (not (vhdl-in-literal))
 	 (vhdl-begin-p lim)
@@ -5670,8 +5899,8 @@ of an identifier that just happens to contain a \"begin\" keyword."
 			      (vhdl-beginning-of-statement-1 lim)
 			      (vhdl-backward-skip-label lim)
 			      (vhdl-first-word (point)))))))
-	  ;; "component", "units", "record":
-	  ((looking-at "[cur]")
+	  ;; "component", "units", "record", "protected body":
+	  ((looking-at "component\\|units\\|protected\\(\\s-+body\\)?\\|record")
 	   ;; The first end found will close the block
 	   (vector "end" nil))
 	  ;; "block", "process", "procedural":
@@ -5683,8 +5912,8 @@ of an identifier that just happens to contain a \"begin\" keyword."
 			 (vhdl-backward-skip-label lim)
 			 (vhdl-first-word (point))))))
 	  ;; "then":
-	  ((looking-at "t")
-	   (vector "elsif\\|else\\|end\\s-+if"
+	  ((looking-at "t\\|use")
+	   (vector "elsif\\|else\\|end\\s-+\\(if\\|use\\)"
 		   (and (vhdl-last-word (point))
 			(or (vhdl-first-word (point))
 			    (save-excursion
@@ -5730,25 +5959,25 @@ of an identifier that just happens to contain an \"end\" keyword."
 	       (vhdl-end-p lim))
 	  (if (looking-at "el")
 	      ;; "else", "elsif":
-	      (vector "if\\|elsif" (vhdl-first-word (point)) "then" nil)
+	      (vector "if\\|elsif" (vhdl-first-word (point)) "then\\|use" nil)
 	    ;; "end ...":
 	    (setq pos (point))
 	    (forward-sexp)
-	    (skip-chars-forward " \t\n")
+	    (skip-chars-forward " \t\n\r\f")
 	    (cond
 	     ;; "end if":
 	     ((looking-at "if\\b[^_]")
 	      (vector "else\\|elsif\\|if"
 		      (vhdl-first-word pos)
-		      "else\\|then" nil))
+		      "else\\|then\\|use" nil))
 	     ;; "end component":
 	     ((looking-at "component\\b[^_]")
 	      (vector (buffer-substring (match-beginning 1)
 					(match-end 1))
 		      (vhdl-first-word pos)
 		      nil nil))
-	     ;; "end units", "end record":
-	     ((looking-at "\\(units\\|record\\)\\b[^_]")
+	     ;; "end units", "end record", "end protected":
+	     ((looking-at "\\(units\\|record\\|protected\\(\\s-+body\\)?\\)\\b[^_]")
 	      (vector (buffer-substring (match-beginning 1)
 					(match-end 1))
 		      (vhdl-first-word pos)
@@ -5805,38 +6034,38 @@ of an identifier that just happens to contain an \"end\" keyword."
     (cond ((looking-at "block\\|process\\|procedural")
 	   (if (save-excursion
 		 (forward-sexp)
-		 (skip-chars-forward " \t\n")
+		 (skip-chars-forward " \t\n\r\f")
 		 (= (following-char) ?\())
 	       (forward-sexp 2)
 	     (forward-sexp))
-	   (when (looking-at "[ \t\n]*is")
+	   (when (looking-at "[ \t\n\r\f]*is")
 	     (goto-char (match-end 0)))
 	   (point))
 	  ((looking-at "component")
 	   (forward-sexp 2)
-	   (when (looking-at "[ \t\n]*is")
+	   (when (looking-at "[ \t\n\r\f]*is")
 	     (goto-char (match-end 0)))
 	   (point))
 	  ((looking-at "for")
 	   (forward-sexp 2)
-	   (skip-chars-forward " \t\n")
+	   (skip-chars-forward " \t\n\r\f")
 	   (while (looking-at "[,:(]")
 	     (forward-sexp)
-	     (skip-chars-forward " \t\n"))
+	     (skip-chars-forward " \t\n\r\f"))
 	   (point))
 	  (t nil)
 	  )))
 
 (defconst vhdl-trailer-re
-  "\\b\\(is\\|then\\|generate\\|loop\\|record\\)\\b[^_]")
+  "\\b\\(is\\|then\\|generate\\|loop\\|record\\|protected\\(\\s-+body\\)?\\|use\\)\\b[^_]")
 
 (defconst vhdl-statement-fwd-re
-  "\\b\\(if\\|for\\|while\\)\\b\\([^_]\\|\\'\\)"
+  "\\b\\(if\\|for\\|while\\|loop\\)\\b\\([^_]\\|\\'\\)"
   "A regular expression for searching forward that matches all known
 \"statement\" keywords.")
 
 (defconst vhdl-statement-bwd-re
-  "\\b\\(if\\|for\\|while\\)\\b[^_]"
+  "\\b\\(if\\|for\\|while\\|loop\\)\\b[^_]"
   "A regular expression for searching backward that matches all known
 \"statement\" keywords.")
 
@@ -5852,7 +6081,7 @@ in the middle of an identifier that just happens to contain a
 	 ;; Make sure it's the start of a parameter specification.
 	 (save-excursion
 	   (forward-sexp 2)
-	   (skip-chars-forward " \t\n")
+	   (skip-chars-forward " \t\n\r\f")
 	   (looking-at "in\\b[^_]"))
 	 ;; Make sure it's not an "end for".
 	 (save-excursion
@@ -5871,7 +6100,7 @@ in the middle of an identifier that just happens to contain a
     t)
    ))
 
-(defconst vhdl-case-alternative-re "when[( \t\n][^;=>]+=>"
+(defconst vhdl-case-alternative-re "when[( \t\n\r\f][^;=>]+=>"
   "Regexp describing a case statement alternative key.")
 
 (defun vhdl-case-alternative-p (&optional lim)
@@ -5908,6 +6137,9 @@ contain a \"when\" keyword."
 	(cond
 	 ;; "begin" keyword:
 	 ((and (looking-at vhdl-begin-fwd-re)
+	       (or (not (looking-at "\\<use\\>"))
+		   (save-excursion (back-to-indentation)
+				   (looking-at "\\(\\w+\\s-*:\\s-*\\)?\\<\\(case\\|elsif\\|if\\)\\>")))
 	       (/= (preceding-char) ?_)
 	       (vhdl-begin-p lim))
 	  (setq foundp 'begin))
@@ -5931,7 +6163,7 @@ With COUNT, do it that many times."
     (save-excursion
       (while (> count 0)
 	;; skip whitespace
-	(skip-chars-forward " \t\n")
+	(skip-chars-forward " \t\n\r\f")
 	;; Check for an unbalanced "end" keyword
 	(if (and (looking-at vhdl-end-fwd-re)
 		 (/= (preceding-char) ?_)
@@ -6007,6 +6239,10 @@ searches."
 	    nil
 	  (backward-sexp)
 	  (if (and (looking-at vhdl-begin-fwd-re)
+		   (or (not (looking-at "\\<use\\>"))
+		       (save-excursion
+			 (back-to-indentation)
+			 (looking-at "\\(\\w+\\s-*:\\s-*\\)?\\<\\(case\\|elsif\\|if\\)\\>")))
 		   (/= (preceding-char) ?_)
 		   (not (vhdl-in-literal))
 		   (vhdl-begin-p lim))
@@ -6278,7 +6514,7 @@ search, and an argument indicating an interactive call."
   (re-search-forward vhdl-e-o-s-re))
 
 (defconst vhdl-b-o-s-re
-  (concat ";\\|\(\\|\)\\|\\bwhen\\b[^_]\\|"
+  (concat ";[^_]\\|\([^_]\\|\)[^_]\\|\\bwhen\\b[^_]\\|"
 	  vhdl-begin-bwd-re "\\|" vhdl-statement-bwd-re))
 
 (defun vhdl-beginning-of-statement-1 (&optional lim)
@@ -6299,7 +6535,7 @@ statement if already at the beginning of one."
     (while (and (not donep)
 		(not (bobp))
 		;; look backwards for a statement boundary
-		(re-search-backward vhdl-b-o-s-re lim 'move))
+		(progn (forward-char) (re-search-backward vhdl-b-o-s-re lim 'move)))
       (if (or (= (preceding-char) ?_)
 	      (vhdl-in-literal))
 	  (backward-char)
@@ -6319,13 +6555,17 @@ statement if already at the beginning of one."
 		     (vhdl-forward-syntactic-ws here)
 		     (setq donep t))))
 	 ;; If we are looking at a semicolon, then stop
-	 ((eq (following-char) ?\;)
+	 ((and (eq (following-char) ?\;) (not (vhdl-in-quote-p)))
 	  (progn
 	    (forward-char)
 	    (vhdl-forward-syntactic-ws here)
 	    (setq donep t)))
 	 ;; If we are looking at a "begin", then stop
 	 ((and (looking-at vhdl-begin-fwd-re)
+	       (or (not (looking-at "\\<use\\>"))
+		   (save-excursion
+		     (back-to-indentation)
+		     (looking-at "\\(\\w+\\s-*:\\s-*\\)?\\<\\(case\\|elsif\\|if\\)\\>")))
 	       (/= (preceding-char) ?_)
 	       (vhdl-begin-p nil))
 	  ;; If it's a leader "begin", then find the
@@ -6576,6 +6816,10 @@ is not moved."
 	(setq begin-after-ip (and
 			      (not literal)
 			      (looking-at vhdl-begin-fwd-re)
+			      (or (not (looking-at "\\<use\\>"))
+				  (save-excursion
+				    (back-to-indentation)
+				    (looking-at "\\(\\w+\\s-*:\\s-*\\)?\\<\\(case\\|elsif\\|if\\)\\>")))
 			      (vhdl-begin-p)))
 	(setq end-after-ip (and
 			    (not literal)
@@ -6624,7 +6868,8 @@ is not moved."
 	   ((progn
 	      (vhdl-backward-syntactic-ws lim)
 	      (or (bobp)
-		  (= (preceding-char) ?\;)))
+		  (and (= (preceding-char) ?\;)
+		       (not (vhdl-in-quote-p)))))
 	    (vhdl-add-syntax 'statement placeholder))
 	   ;; CASE 2D: we are looking at a top-level statement-cont
 	   (t
@@ -6662,6 +6907,10 @@ is not moved."
 		 (save-excursion
 		   (vhdl-beginning-of-statement-1 containing-sexp)
 		   (skip-chars-backward " \t(")
+		   (while (and (= (preceding-char) ?\;)
+			       (not (vhdl-in-quote-p)))
+		     (vhdl-beginning-of-statement-1 containing-sexp)
+		     (skip-chars-backward " \t("))
 		   (<= (point) containing-sexp)))
 	    (goto-char containing-sexp)
 	    (vhdl-add-syntax 'arglist-cont-nonempty (vhdl-point 'boi)))
@@ -6730,7 +6979,7 @@ is not moved."
 		     (save-excursion
 		       (goto-char new)
 		       (eq new (progn (back-to-indentation) (point)))))
-		(setq placeholder new)))
+		(setq placeholder new)))	
 	  (vhdl-add-syntax 'statement-cont placeholder)
 	  (if begin-after-ip
 	      (vhdl-add-syntax 'block-open)))
@@ -6891,7 +7140,7 @@ only-lines."
     (let* ((relpos (cdr langelem))
 	   (assignp (save-excursion
 		     (goto-char (vhdl-point 'boi))
-		     (and (re-search-forward "\\(<\\|:\\)="
+		     (and (re-search-forward "\\(<\\|:\\|=\\)="
 					     (vhdl-point 'eol) t)
 			  (- (point) (vhdl-point 'boi)))))
 	   (curcol (progn
@@ -6900,7 +7149,7 @@ only-lines."
 	   foundp)
       (while (and (not foundp)
 		  (< (point) (vhdl-point 'eol)))
-	(re-search-forward "\\(<\\|:\\)=\\|(" (vhdl-point 'eol) 'move)
+	(re-search-forward "\\(<\\|:\\|=\\)=\\|(" (vhdl-point 'eol) 'move)
 	(if (vhdl-in-literal)
 	    (forward-char)
 	  (if (= (preceding-char) ?\()
@@ -7001,7 +7250,8 @@ character is a space."
   (interactive)
   (if (and (= (preceding-char) ? ) (vhdl-in-comment-p))
       (indent-new-comment-line)
-    (when (and (>= (preceding-char) ?a) (<= (preceding-char) ?z))
+    (when (and (>= (preceding-char) ?a) (<= (preceding-char) ?z)
+	       (not (vhdl-in-comment-p)))
       (vhdl-fix-case-word -1))
     (newline-and-indent)))
 
@@ -7011,6 +7261,7 @@ indentation change."
   (interactive)
   (let* ((syntax (and vhdl-indent-syntax-based (vhdl-get-syntactic-context)))
 	 (pos (- (point-max) (point)))
+	 (is-comment nil)
 	 (indent
 	  (if syntax
 	      ;; indent syntax-based
@@ -7018,6 +7269,15 @@ indentation change."
 		       (>= (vhdl-get-offset (car syntax)) comment-column))
 		  ;; special case: comments at or right of comment-column
 		  (vhdl-get-offset (car syntax))
+		;; align comments like following code line
+		(when vhdl-indent-comment-like-next-code-line
+		  (save-excursion
+		    (while (eq (caar syntax) 'comment)
+		      (setq is-comment t)
+		      (beginning-of-line 2)
+		      (setq syntax (vhdl-get-syntactic-context)))))
+		(when is-comment
+		  (setq syntax (cons (cons 'comment nil) syntax)))
 		(apply '+ (mapcar 'vhdl-get-offset syntax)))
 	    ;; indent like previous nonblank line
 	    (save-excursion (beginning-of-line)
@@ -7026,10 +7286,13 @@ indentation change."
 	 (shift-amt  (- indent (current-indentation))))
     (and vhdl-echo-syntactic-information-p
 	 (message "syntax: %s, indent= %d" syntax indent))
-    (unless (zerop shift-amt)
-      (delete-region (vhdl-point 'bol) (vhdl-point 'boi))
-      (beginning-of-line)
-      (indent-to indent))
+    (let ((has-formfeed
+	   (save-excursion (beginning-of-line) (looking-at "\\s-*\f"))))
+      (when (or (not (zerop shift-amt)) has-formfeed)
+	(delete-region (vhdl-point 'bol) (vhdl-point 'boi))
+	(beginning-of-line)
+	(when has-formfeed (insert "\f"))
+	(indent-to indent)))
     (if (< (point) (vhdl-point 'boi))
 	(back-to-indentation)
       ;; If initial point was within line's indentation, position after
@@ -7040,7 +7303,7 @@ indentation change."
     (vhdl-update-progress-info "Indenting" (vhdl-current-line))
     shift-amt))
 
-(defun vhdl-indent-region (beg end column)
+(defun vhdl-indent-region (beg end &optional column)
   "Indent region as VHDL code.
 Adds progress reporting to `indent-region'."
   (interactive "r\nP")
@@ -7055,7 +7318,7 @@ Adds progress reporting to `indent-region'."
   "Indent whole buffer as VHDL code.
 Calls `indent-region' for whole buffer and adds progress reporting."
   (interactive)
-  (vhdl-indent-region (point-min) (point-max) nil))
+  (vhdl-indent-region (point-min) (point-max)))
 
 (defun vhdl-indent-group ()
   "Indent group of lines between empty lines."
@@ -7068,7 +7331,7 @@ Calls `indent-region' for whole buffer and adds progress reporting."
 	       (if (re-search-forward vhdl-align-group-separate nil t)
 		   (point-marker)
 		 (point-max-marker)))))
-    (vhdl-indent-region beg end nil)))
+    (vhdl-indent-region beg end)))
 
 (defun vhdl-indent-sexp (&optional endpos)
   "Indent each line of the list starting just after point.
@@ -7131,21 +7394,23 @@ ENDPOS is encountered."
 (defconst vhdl-align-alist
   '(
     ;; after some keywords
-    (vhdl-mode "^\\s-*\\(constant\\|quantity\\|signal\\|subtype\\|terminal\\|type\\|variable\\)[ \t]"
-	       "^\\s-*\\(constant\\|quantity\\|signal\\|subtype\\|terminal\\|type\\|variable\\)\\([ \t]+\\)" 2)
+    (vhdl-mode "^\\s-*\\(across\\|constant\\|quantity\\|signal\\|subtype\\|terminal\\|through\\|type\\|variable\\)[ \t]"
+	       "^\\s-*\\(across\\|constant\\|quantity\\|signal\\|subtype\\|terminal\\|through\\|type\\|variable\\)\\([ \t]+\\)" 2)
     ;; before ':'
     (vhdl-mode ":[^=]" "\\([ \t]*\\):[^=]")
     ;; after direction specifications
     (vhdl-mode ":[ \t]*\\(in\\|out\\|inout\\|buffer\\|\\)\\>"
 	       ":[ \t]*\\(in\\|out\\|inout\\|buffer\\|\\)\\([ \t]+\\)" 2)
     ;; before "==", ":=", "=>", and "<="
-    (vhdl-mode "[<:=]=" "\\([ \t]*\\)[<:=]=" 1) ; since "<= ... =>" can occur
+    (vhdl-mode "[<:=]=" "\\([ \t]*\\)\\??[<:=]=" 1) ; since "<= ... =>" can occur
     (vhdl-mode "=>" "\\([ \t]*\\)=>" 1)
-    (vhdl-mode "[<:=]=" "\\([ \t]*\\)[<:=]=" 1) ; since "=> ... <=" can occur
+    (vhdl-mode "[<:=]=" "\\([ \t]*\\)\\??[<:=]=" 1) ; since "=> ... <=" can occur
     ;; before some keywords
     (vhdl-mode "[ \t]after\\>" "[^ \t]\\([ \t]+\\)after\\>" 1)
     (vhdl-mode "[ \t]when\\>" "[^ \t]\\([ \t]+\\)when\\>" 1)
     (vhdl-mode "[ \t]else\\>" "[^ \t]\\([ \t]+\\)else\\>" 1)
+    (vhdl-mode "[ \t]across\\>" "[^ \t]\\([ \t]+\\)across\\>" 1)
+    (vhdl-mode "[ \t]through\\>" "[^ \t]\\([ \t]+\\)through\\>" 1)
     ;; before "=>" since "when/else ... =>" can occur
     (vhdl-mode "=>" "\\([ \t]*\\)=>" 1)
     )
@@ -7195,7 +7460,7 @@ parentheses."
 	(forward-list)
 	(setq end (point))
 	(goto-char (1+ beg))
-	(skip-chars-forward " \t\n")
+	(skip-chars-forward " \t\n\r\f")
 	(setq beg (point))))
     ;; run FUNCTION
     (if beg
@@ -7280,8 +7545,14 @@ the token in MATCH."
 	    bol (setq begin (progn (beginning-of-line) (point))))
       (while (< bol end)
 	(save-excursion
-	  (when (and (re-search-forward match eol t)
-		     (not (vhdl-in-literal)))
+	  (when (and (vhdl-re-search-forward match eol t)
+		     (save-excursion
+		       (goto-char (match-beginning 0))
+		       (forward-char)
+		       (and (not (vhdl-in-literal))
+			    (not (vhdl-in-quote-p))
+			    (not (vhdl-in-extended-identifier-p))))
+		     (not (looking-at "\\s-*$")))
 	    (setq distance (- (match-beginning substr) bol))
 	    (when (> distance max)
 	      (setq max distance))))
@@ -7295,8 +7566,16 @@ the token in MATCH."
       (goto-char (setq bol begin))
       (setq eol (point-at-eol))
       (while (> lines 0)
-  	(when (and (re-search-forward match eol t)
-		   (not (vhdl-in-literal)))
+  	(when (and (vhdl-re-search-forward match eol t)
+		   (save-excursion
+		     (goto-char (match-beginning 0))
+		     (forward-char)
+		     (and (not (vhdl-in-literal))
+			  (not (vhdl-in-quote-p))
+			  (not (vhdl-in-extended-identifier-p))))
+		   (not (looking-at "\\s-*$"))
+		   (> (match-beginning 0)  ; not if at boi
+		      (save-excursion (back-to-indentation) (point))))
 	  (setq width (- (match-end substr) (match-beginning substr)))
 	  (setq distance (- (match-beginning substr) bol))
 	  (goto-char (match-beginning substr))
@@ -7449,7 +7728,7 @@ the token in MATCH."
        ;; search for comment start positions and lengths
        (while (< (point) end)
 	 (when (and (not (looking-at "^\\s-*\\(begin\\|end\\)\\>"))
-		    (looking-at "^\\(.*[^ \t\n-]+\\)\\s-*\\(--.*\\)$")
+		    (looking-at "^\\(.*[^ \t\n\r\f-]+\\)\\s-*\\(--.*\\)$")
 		    (not (save-excursion (goto-char (match-beginning 2))
 					 (vhdl-in-literal))))
 	   (setq start (+ (- (match-end 1) (match-beginning 1)) spacing))
@@ -7474,7 +7753,7 @@ the token in MATCH."
        (while (< (point) end)
 	 (setq cur-start nil)
 	 (when (and (not (looking-at "^\\s-*\\(begin\\|end\\)\\>"))
-		    (or (and (looking-at "^\\(.*[^ \t\n-]+\\)\\(\\s-*\\)\\(--.*\\)$")
+		    (or (and (looking-at "^\\(.*[^ \t\n\r\f-]+\\)\\(\\s-*\\)\\(--.*\\)$")
 			     (not (save-excursion
 				    (goto-char (match-beginning 3))
 				    (vhdl-in-literal))))
@@ -7582,32 +7861,35 @@ end of line, do nothing in comments and strings."
     (setq end (point-marker))
     ;; have no space before and one space after `,' and ';'
     (goto-char beg)
-    (while (re-search-forward "\\(--.*\n\\|\"[^\"\n]*[\"\n]\\|\'.\'\\)\\|\\(\\s-*\\([,;]\\)\\)" end t)
+    (while (re-search-forward "\\(--.*\n\\|\"[^\"\n]*[\"\n]\\|\'.\'\\|\\\\[^\\\n]*[\\\n]\\)\\|\\(\\s-*\\([,;]\\)\\)" end t)
       (if (match-string 1)
 	  (goto-char (match-end 1))
-	(replace-match "\\3 " nil nil nil 3)))
+	(replace-match "\\3 " nil nil nil 2)))
     ;; have no space after `('
     (goto-char beg)
-    (while (re-search-forward "\\(--.*\n\\|\"[^\"\n]*[\"\n]\\|\'.\'\\)\\|\\((\\)\\s-+" end t)
+    (while (re-search-forward "\\(--.*\n\\|\"[^\"\n]*[\"\n]\\|\'.\'\\|\\\\[^\\\n]*[\\\n]\\)\\|\\((\\)\\s-+" end t)
       (if (match-string 1)
 	  (goto-char (match-end 1))
 	(replace-match "\\2")))
     ;; have no space before `)'
     (goto-char beg)
-    (while (re-search-forward "\\(--.*\n\\|\"[^\"\n]*[\"\n]\\|\'.\'\\|^\\s-+\\)\\|\\s-+\\()\\)" end t)
+    (while (re-search-forward "\\(--.*\n\\|\"[^\"\n]*[\"\n]\\|\'.\'\\|\\\\[^\\\n]*[\\\n]\\|^\\s-+\\)\\|\\s-+\\()\\)" end t)
       (if (match-string 1)
 	  (goto-char (match-end 1))
 	(replace-match "\\2")))
     ;; surround operator symbols by one space
     (goto-char beg)
-    (while (re-search-forward "\\(--.*\n\\|\"[^\"\n]*[\"\n]\\|\'.\'\\)\\|\\(\\([^/:<>=]\\)\\(:\\|=\\|<\\|>\\|:=\\|<=\\|>=\\|=>\\|/=\\)\\([^=>]\\|$\\)\\)" end t)
-      (if (match-string 1)
-	  (goto-char (match-end 1))
+    (while (re-search-forward "\\(--.*\n\\|\"[^\"\n]*[\"\n]\\|\'.\'\\|\\\\[^\\\n]*[\\\n]\\)\\|\\(\\([^/:<>=]\\)\\(:\\|\\??=\\|\\??<<\\|\\??>>\\|\\??<\\|\\??>\\|:=\\|\\??<=\\|\\??>=\\|=>\\|\\??/=\\|\\?\\?\\)\\([^=>]\\|$\\)\\)" end t)
+      (if (or (match-string 1)
+	      (<= (match-beginning 0)  ; not if at boi
+		 (save-excursion (back-to-indentation) (point))))
+	  (goto-char (match-end 0))
 	(replace-match "\\3 \\4 \\5")
 	(goto-char (match-end 2))))
     ;; eliminate multiple spaces and spaces at end of line
     (goto-char beg)
     (while (or (and (looking-at "--.*\n") (re-search-forward "--.*\n" end t))
+	       (and (looking-at "--.*") (re-search-forward "--.*" end t))
 	       (and (looking-at "\"") (re-search-forward "\"[^\"\n]*[\"\n]" end t))
 	       (and (looking-at "\\s-+$") (re-search-forward "\\s-+$" end t)
 		    (progn (replace-match "" nil nil) t))
@@ -7618,6 +7900,7 @@ end of line, do nothing in comments and strings."
 		    (progn (replace-match "  " nil nil) t))
 	       (and (looking-at "\\s-+") (re-search-forward "\\s-+" end t)
 		    (progn (replace-match " " nil nil) t))
+	       (and (looking-at "-") (re-search-forward "-" end t))
 ;	       (re-search-forward "[^ \t-]+" end t))))
 	       (re-search-forward "[^ \t\"-]+" end t))))
   (unless no-message (message "Fixing up whitespace...done")))
@@ -7639,7 +7922,7 @@ case fixing to a region.  Calls functions `vhdl-indent-buffer',
 `vhdl-fix-case-buffer'."
   (interactive "r")
   (setq end (save-excursion (goto-char end) (point-marker)))
-  (vhdl-indent-region beg end nil)
+  (vhdl-indent-region beg end)
   (let ((vhdl-align-groups t))
     (vhdl-align-region beg end))
   (vhdl-fix-case-region beg end))
@@ -7720,7 +8003,7 @@ buffer."
     (vhdl-prepare-search-2
      (end-of-line)
      ;; look whether in process
-     (if (not (and (re-search-backward "^\\s-*\\(\\w+[ \t\n]*:[ \t\n]*\\)?\\(process\\|end\\s-+process\\)\\>" nil t)
+     (if (not (and (re-search-backward "^\\s-*\\(\\w+[ \t\n\r\f]*:[ \t\n\r\f]*\\)?\\(process\\|end\\s-+process\\)\\>" nil t)
 		   (equal (upcase (match-string 2)) "PROCESS")
 		   (save-excursion (re-search-forward "^\\s-*end\\s-+process\\>" nil t))))
 	 (error "ERROR:  Not within a process")
@@ -7735,7 +8018,7 @@ buffer."
     (vhdl-prepare-search-2
      (goto-char (point-min))
      (message "Updating sensitivity lists...")
-     (while (re-search-forward "^\\s-*\\(\\w+[ \t\n]*:[ \t\n]*\\)?process\\>" nil t)
+     (while (re-search-forward "^\\s-*\\(\\w+[ \t\n\r\f]*:[ \t\n\r\f]*\\)?process\\>" nil t)
        (goto-char (match-beginning 0))
        (condition-case nil (vhdl-update-sensitivity-list) (error "")))
      (message "Updating sensitivity lists...done"))))
@@ -7744,9 +8027,13 @@ buffer."
   "Update sensitivity list."
     (let ((proc-beg (point))
 	  (proc-end (re-search-forward "^\\s-*end\\s-+process\\>" nil t))
-	  (proc-mid (re-search-backward "^\\s-*begin\\>" nil t))
+	  (proc-mid (vhdl-re-search-backward
+		     "\\(\\(\\<begin\\>\\)\\|^\\s-*process\\>\\)" nil t))
 	  seq-region-list)
       (cond
+       ;; error if 'begin' keyword missing
+       ((not (match-string 2))
+	(error "ERROR:  No 'begin' keyword found"))
        ;; search for wait statement (no sensitivity list allowed)
        ((progn (goto-char proc-mid)
 	       (vhdl-re-search-forward "\\<wait\\>" proc-end t))
@@ -7780,19 +8067,19 @@ buffer."
 		;; case expression
 		((re-search-forward "^\\s-*case\\>" proc-end t)
 		 (re-search-forward "\\<is\\>" proc-end t))
-		;; parameter list of procedure call
-		((and (re-search-forward "^\\s-*\\w+[ \t\n]*(" proc-end t)
+		;; parameter list of procedure call, array index
+		((and (re-search-forward "^\\s-*\\(\\w\\|\\.\\)+[ \t\n\r\f]*(" proc-end t)
 		      (1- (point)))
 		 (progn (backward-char) (forward-sexp)
 			(while (looking-at "(") (forward-sexp)) (point)))))
-	     name read-list sens-list signal-list
+	     name field read-list sens-list signal-list
 	     sens-beg sens-end beg end margin)
 	  ;; scan for signals in old sensitivity list
 	  (goto-char proc-beg)
 	  (re-search-forward "\\<process\\>" proc-mid t)
-	  (if (not (looking-at "[ \t\n]*("))
+	  (if (not (looking-at "[ \t\n\r\f]*("))
 	      (setq sens-beg (point))
-	    (setq sens-beg (re-search-forward "\\([ \t\n]*\\)([ \t\n]*" nil t))
+	    (setq sens-beg (re-search-forward "\\([ \t\n\r\f]*\\)([ \t\n\r\f]*" nil t))
 	    (goto-char (match-end 1))
 	    (forward-sexp)
 	    (setq sens-end (1- (point)))
@@ -7825,15 +8112,17 @@ buffer."
 					     (< (point) (caar tmp-list)))
 				   (setq tmp-list (cdr tmp-list)))
 				 (and tmp-list (< (point) (cdar tmp-list))))))
-		(while (vhdl-re-search-forward "[^'\"]\\<\\([a-zA-Z]\\w*\\)\\>[ \t\n]*\\('\\(\\w+\\)\\|\\(=>\\)\\)?" end t)
+		(while (vhdl-re-search-forward "[^'\".]\\<\\([a-zA-Z]\\w*\\)\\(\\(\\.\\w+\\|[ \t\n\r\f]*([^)]*)\\)*\\)[ \t\n\r\f]*\\('\\(\\w+\\)\\|\\(=>\\)\\)?" end t)
 		  (setq name (match-string 1))
-		  (when (and (not (match-string 4)) ; not when formal parameter
-			     (not (and (match-string 3) ; not event attribute
-				       (not (member (downcase (match-string 3))
+		  (when vhdl-array-index-record-field-in-sensitivity-list
+		    (setq field (match-string 2)))
+		  (when (and (not (match-string 6)) ; not when formal parameter
+			     (not (and (match-string 5) ; not event attribute
+				       (not (member (downcase (match-string 5))
 						    '("event" "last_event" "transaction")))))
 			     (member (downcase name) signal-list))
-		    (unless (member-ignore-case name read-list)
-		      (setq read-list (cons name read-list))))
+		    (unless (member-ignore-case (concat name field) read-list)
+		      (setq read-list (cons (concat name field) read-list))))
 		  (goto-char (match-end 1)))))
 	    (setq scan-regions-list (cdr scan-regions-list)))
 	  ;; update sensitivity list
@@ -7879,17 +8168,17 @@ buffer."
 	 (goto-char (point-min))
 	 (if (not (re-search-forward (concat "^entity\\s-+" entity-name "\\>") nil t))
 	     (error "ERROR:  Entity \"%s\" not found:\n  --> see option `vhdl-entity-file-name'" entity-name)
-	   (when (setq beg (re-search-forward
-			    "^\\s-*port[ \t\n]*("
+	   (when (setq beg (vhdl-re-search-forward
+			    "\\<port[ \t\n\r\f]*("
 			    (save-excursion
 			      (re-search-forward "^end\\>" nil t)) t))
 	     (setq end (save-excursion
 			 (backward-char) (forward-sexp) (point)))
 	     (vhdl-forward-syntactic-ws)
 	     (while (< (point) end)
-	       (when (looking-at "signal[ \t\n]+")
+	       (when (looking-at "signal[ \t\n\r\f]+")
 		 (goto-char (match-end 0)))
-	       (while (looking-at "\\(\\w+\\)[ \t\n,]+")
+	       (while (looking-at "\\(\\w+\\)[ \t\n\r\f,]+")
 		 (setq signal-list
 		       (cons (downcase (match-string 1)) signal-list))
 		 (goto-char (match-end 0))
@@ -7908,12 +8197,12 @@ buffer."
 	   (when (= 0 (nth 0 (parse-partial-sexp beg (point))))
 	     (if (match-string 2)
 		 ;; scan signal name
-		 (while (looking-at "[ \t\n,]+\\(\\w+\\)")
+		 (while (looking-at "[ \t\n\r\f,]+\\(\\w+\\)")
 		   (setq signal-list
 			 (cons (downcase (match-string 1)) signal-list))
 		   (goto-char (match-end 0)))
 	       ;; scan alias name, check is alias of (declared) signal
-	       (when (and (looking-at "[ \t\n]+\\(\\w+\\)[^;]*\\<is[ \t\n]+\\(\\w+\\)")
+	       (when (and (looking-at "[ \t\n\r\f]+\\(\\w+\\)[^;]*\\<is[ \t\n\r\f]+\\(\\w+\\)")
 			  (member (downcase (match-string 2)) signal-list))
 		 (setq signal-list
 		       (cons (downcase (match-string 1)) signal-list))
@@ -7950,6 +8239,18 @@ buffer."
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;; Generic/port clause fixing
 
+(defun vhdl-fix-clause-buffer ()
+  "Fix all generic/port clauses in current buffer."
+  (interactive)
+  (save-excursion
+    (vhdl-prepare-search-2
+     (goto-char (point-min))
+     (message "Fixing generic/port clauses...")
+     (while (re-search-forward "^\\s-*\\(generic\\|port\\)[ \t\n\r\f]*(" nil t)
+       (goto-char (match-end 0))
+       (condition-case nil (vhdl-fix-clause) (error "")))
+     (message "Fixing generic/port clauses...done"))))
+
 (defun vhdl-fix-clause ()
   "Fix closing parenthesis within generic/port clause."
   (interactive)
@@ -7957,13 +8258,14 @@ buffer."
     (vhdl-prepare-search-2
      (let ((pos (point))
 	   beg end)
-       (if (not (re-search-backward "^\\s-*\\(generic\\|port\\)[ \t\n]*(" nil t))
+       (end-of-line)
+       (if (not (re-search-backward "^\\s-*\\(generic\\|port\\)[ \t\n\r\f]*(" nil t))
 	   (error "ERROR:  Not within a generic/port clause")
 	 ;; search for end of clause
 	 (goto-char (match-end 0))
 	 (setq beg (1- (point)))
 	 (vhdl-forward-syntactic-ws)
-	 (while (looking-at "\\w+\\([ \t\n]*,[ \t\n]*\\w+\\)*[ \t\n]*:[ \t\n]*\\w+[^;]*;")
+	 (while (looking-at "\\w+\\([ \t\n\r\f]*,[ \t\n\r\f]*\\w+\\)*[ \t\n\r\f]*:[ \t\n\r\f]*\\w+[^;]*;")
 	   (goto-char (1- (match-end 0)))
 	   (setq end (point-marker))
 	   (forward-char)
@@ -8317,7 +8619,8 @@ is omitted or nil."
   (let ((margin (current-indentation))
 	(start (point))
 	label)
-    (unless kind (setq kind (if (vhdl-sequential-statement-p) 'is 'use)))
+    (unless kind (setq kind (if (or (vhdl-sequential-statement-p)
+				    (not (vhdl-standard-p 'ams))) 'is 'use)))
     (if (or (not (eq vhdl-optional-labels 'all)) (vhdl-standard-p '87))
 	(vhdl-insert-keyword "CASE ")
       (vhdl-insert-keyword ": CASE ")
@@ -8905,7 +9208,7 @@ otherwise."
       (vhdl-insert-keyword
        (concat " " (if (eq kind 'then) "THEN" "USE") "\n\n"))
       (indent-to margin)
-      (vhdl-insert-keyword "END IF")
+      (vhdl-insert-keyword (concat "END " (if (eq kind 'then) "IF" "USE")))
       (when label (insert " " label))
       (insert ";")
       (forward-line -1)
@@ -9226,6 +9529,7 @@ otherwise."
   (interactive)
   (let ((margin (current-indentation))
 	(start (point))
+	(reset-kind vhdl-reset-kind)
 	label seq input-signals clock reset final-pos)
     (setq seq (if kind (eq kind 'seq)
 		(eq (vhdl-decision-query
@@ -9248,7 +9552,13 @@ otherwise."
       (setq clock (or (and (not (equal "" vhdl-clock-name))
 			   (progn (insert vhdl-clock-name) vhdl-clock-name))
 		      (vhdl-template-field "clock name") "<clock>"))
-      (when (eq vhdl-reset-kind 'async)
+      (when (eq reset-kind 'query)
+	(setq reset-kind
+	      (if (eq (vhdl-decision-query
+		       "" "(a)synchronous or (s)ynchronous reset?" t) ?a)
+		  'async
+		'sync)))
+      (when (eq reset-kind 'async)
 	(insert ", ")
 	(setq reset (or (and (not (equal "" vhdl-reset-name))
 			     (progn (insert vhdl-reset-name) vhdl-reset-name))
@@ -9257,7 +9567,7 @@ otherwise."
     (unless (vhdl-standard-p '87) (vhdl-insert-keyword " IS"))
     (insert "\n")
     (vhdl-template-begin-end "PROCESS" label margin)
-    (when seq (setq reset (vhdl-template-seq-process clock reset)))
+    (when seq (setq reset (vhdl-template-seq-process clock reset reset-kind)))
     (when vhdl-prompt-for-comments
       (setq final-pos (point-marker))
       (vhdl-prepare-search-2
@@ -9589,13 +9899,13 @@ otherwise."
 	(in-arglist (vhdl-in-argument-list-p)))
     (vhdl-prepare-search-2
      (if (or (save-excursion
-	       (and (vhdl-re-search-backward
-		     "\\<function\\|procedure\\|process\\|procedural\\|end\\>"
-		     nil t)
-		    (not (progn (backward-word 1) (looking-at "\\<end\\>")))))
+	       (progn (vhdl-beginning-of-block)
+		      (looking-at "\\s-*\\(\\w+\\s-*:\\s-*\\)?\\<\\(\\<function\\|procedure\\|process\\|procedural\\)\\>")))
 	     (save-excursion (backward-word 1) (looking-at "\\<shared\\>")))
 	 (vhdl-insert-keyword "VARIABLE ")
-       (vhdl-insert-keyword "SHARED VARIABLE ")))
+       (if (vhdl-standard-p '87)
+	   (error "ERROR:  Not within sequential block")
+	 (vhdl-insert-keyword "SHARED VARIABLE "))))
     (when (vhdl-template-field "names" nil t start (point))
       (insert " : ")
       (when in-arglist (vhdl-template-field "[IN | OUT | INOUT]" " " t))
@@ -9692,14 +10002,16 @@ otherwise."
        (concat (if vhdl-clock-rising-edge "rising" "falling")
 	       " clock edge")))))
 
-(defun vhdl-template-seq-process (clock reset)
+(defun vhdl-template-seq-process (clock reset reset-kind)
   "Insert a template for the body of a sequential process."
   (let ((margin (current-indentation))
 	position)
     (vhdl-insert-keyword "IF ")
-    (when (eq vhdl-reset-kind 'async)
+    (when vhdl-conditions-in-parenthesis (insert "("))
+    (when (eq reset-kind 'async)
       (insert reset " = "
 	      (if vhdl-reset-active-high vhdl-one-string vhdl-zero-string))
+      (when vhdl-conditions-in-parenthesis (insert ")"))
       (vhdl-insert-keyword " THEN")
       (vhdl-comment-insert-inline
        (concat "asynchronous reset (active "
@@ -9707,7 +10019,8 @@ otherwise."
       (insert "\n") (indent-to (+ margin vhdl-basic-offset))
       (setq position (point))
       (insert "\n") (indent-to margin)
-      (vhdl-insert-keyword "ELSIF "))
+      (vhdl-insert-keyword "ELSIF ")
+      (when vhdl-conditions-in-parenthesis (insert "(")))
     (if (eq vhdl-clock-edge-condition 'function)
 	(insert (if vhdl-clock-rising-edge "rising" "falling")
 		"_edge(" clock ")")
@@ -9715,17 +10028,20 @@ otherwise."
       (vhdl-insert-keyword " AND ")
       (insert clock " = "
 	      (if vhdl-clock-rising-edge vhdl-one-string vhdl-zero-string)))
+    (when vhdl-conditions-in-parenthesis (insert ")"))
     (vhdl-insert-keyword " THEN")
     (vhdl-comment-insert-inline
      (concat (if vhdl-clock-rising-edge "rising" "falling") " clock edge"))
     (insert "\n") (indent-to (+ margin vhdl-basic-offset))
-    (when (eq vhdl-reset-kind 'sync)
+    (when (eq reset-kind 'sync)
       (vhdl-insert-keyword "IF ")
+      (when vhdl-conditions-in-parenthesis (insert "("))
       (setq reset (or (and (not (equal "" vhdl-reset-name))
 			   (progn (insert vhdl-reset-name) vhdl-reset-name))
 		      (vhdl-template-field "reset name") "<reset>"))
       (insert " = "
 	      (if vhdl-reset-active-high vhdl-one-string vhdl-zero-string))
+      (when vhdl-conditions-in-parenthesis (insert ")"))
       (vhdl-insert-keyword " THEN")
       (vhdl-comment-insert-inline
        (concat "synchronous reset (active "
@@ -9737,7 +10053,7 @@ otherwise."
       (insert "\n") (indent-to (+ margin (* 2 vhdl-basic-offset)))
       (insert "\n") (indent-to (+ margin vhdl-basic-offset))
       (vhdl-insert-keyword "END IF;"))
-    (when (eq vhdl-reset-kind 'none)
+    (when (eq reset-kind 'none)
       (setq position (point)))
     (insert "\n") (indent-to margin)
     (vhdl-insert-keyword "END IF;")
@@ -9761,21 +10077,11 @@ specification, if not already there."
 	(insert library ";")
 	(when package
 	  (insert "\n")
-	  (indent-to margin)))
-      (when package
-	(vhdl-insert-keyword "USE ")
-	(insert library "." package)
-	(vhdl-insert-keyword ".ALL;")))))
-
-(defun vhdl-template-package-math-complex ()
-  "Insert specification of `math_complex' package."
-  (interactive)
-  (vhdl-template-standard-package "ieee" "math_complex"))
-
-(defun vhdl-template-package-math-real ()
-  "Insert specification of `math_real' package."
-  (interactive)
-  (vhdl-template-standard-package "ieee" "math_real"))
+	  (indent-to margin))))
+    (when package
+      (vhdl-insert-keyword "USE ")
+      (insert library "." package)
+      (vhdl-insert-keyword ".ALL;"))))
 
 (defun vhdl-template-package-numeric-bit ()
   "Insert specification of `numeric_bit' package."
@@ -9822,6 +10128,56 @@ specification, if not already there."
   (interactive)
   (vhdl-template-standard-package "std" "textio"))
 
+(defun vhdl-template-package-fundamental-constants ()
+  "Insert specification of `fundamental_constants' package."
+  (interactive)
+  (vhdl-template-standard-package "ieee" "fundamental_constants"))
+
+(defun vhdl-template-package-material-constants ()
+  "Insert specification of `material_constants' package."
+  (interactive)
+  (vhdl-template-standard-package "ieee" "material_constants"))
+
+(defun vhdl-template-package-energy-systems ()
+  "Insert specification of `energy_systems' package."
+  (interactive)
+  (vhdl-template-standard-package "ieee" "energy_systems"))
+
+(defun vhdl-template-package-electrical-systems ()
+  "Insert specification of `electrical_systems' package."
+  (interactive)
+  (vhdl-template-standard-package "ieee" "electrical_systems"))
+
+(defun vhdl-template-package-mechanical-systems ()
+  "Insert specification of `mechanical_systems' package."
+  (interactive)
+  (vhdl-template-standard-package "ieee" "mechanical_systems"))
+
+(defun vhdl-template-package-radiant-systems ()
+  "Insert specification of `radiant_systems' package."
+  (interactive)
+  (vhdl-template-standard-package "ieee" "radiant_systems"))
+
+(defun vhdl-template-package-thermal-systems ()
+  "Insert specification of `thermal_systems' package."
+  (interactive)
+  (vhdl-template-standard-package "ieee" "thermal_systems"))
+
+(defun vhdl-template-package-fluidic-systems ()
+  "Insert specification of `fluidic_systems' package."
+  (interactive)
+  (vhdl-template-standard-package "ieee" "fluidic_systems"))
+
+(defun vhdl-template-package-math-complex ()
+  "Insert specification of `math_complex' package."
+  (interactive)
+  (vhdl-template-standard-package "ieee" "math_complex"))
+
+(defun vhdl-template-package-math-real ()
+  "Insert specification of `math_real' package."
+  (interactive)
+  (vhdl-template-standard-package "ieee" "math_real"))
+
 (defun vhdl-template-directive (directive)
   "Insert directive."
   (unless (= (current-indentation) (current-column))
@@ -9900,6 +10256,9 @@ specification, if not already there."
 	 (insert (user-full-name))
 	 (when user-mail-address (insert "  <" user-mail-address ">")))
        (goto-char beg)
+       (while (search-forward "<authorfull>" end t)
+	 (replace-match (user-full-name) t t))
+       (goto-char beg)
        (while (search-forward "<login>" end t)
 	 (replace-match (user-login-name) t t))
        (goto-char beg)
@@ -9915,7 +10274,7 @@ 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"))
+			       ((vhdl-standard-p '93) "'93/02"))
 		  (when (vhdl-standard-p 'ams) ", VHDL-AMS")
 		  (when (vhdl-standard-p 'math) ", Math Packages")) t t))
        (goto-char beg)
@@ -10021,9 +10380,10 @@ If starting after end-comment-column, start a new line."
   "Displays one line of dashes."
   (interactive)
   (while (= (preceding-char) ?-) (delete-char -2))
+  (insert "--")
   (let* ((col (current-column))
 	 (len (- end-comment-column col)))
-    (insert-char ?- len)))
+    (insert-char vhdl-comment-display-line-char len)))
 
 (defun vhdl-comment-append-inline ()
   "Append empty inline comment to current line."
@@ -10084,7 +10444,7 @@ If starting after end-comment-column, start a new line."
     (goto-char beg)
     (beginning-of-line)
     (setq beg (point))
-    (if (looking-at comment-start)
+    (if (looking-at (concat "\\s-*" comment-start))
 	(comment-region beg end '(4))
       (comment-region beg end))))
 
@@ -10119,7 +10479,7 @@ If starting after end-comment-column, start a new line."
     (goto-char beg)
     (beginning-of-line)
     (while (< (point) end)
-      (when (looking-at "^.*[^ \t\n-]+\\(\\s-*--.*\\)$")
+      (when (looking-at "^.*[^ \t\n\r\f-]+\\(\\s-*--.*\\)$")
 	(delete-region (match-beginning 1) (match-end 1)))
       (beginning-of-line 2))))
 
@@ -10323,9 +10683,9 @@ if in comment and past end-comment-column."
 	 (self-insert-command count)
 	 (cond ((>= (current-column) (+ 2 end-comment-column))
 		(backward-char 1)
-		(skip-chars-backward "^ \t\n")
+		(skip-chars-backward "^ \t\n\r\f")
 		(indent-new-comment-line)
-		(skip-chars-forward "^ \t\n")
+		(skip-chars-forward "^ \t\n\r\f")
 		(forward-char 1))
 	       ((>= (current-column) end-comment-column)
 		(indent-new-comment-line))
@@ -10369,7 +10729,9 @@ with double-quotes is to be inserted.  DEFAULT specifies a default string."
       (vhdl-fix-case-region-1 position (point) vhdl-upper-case-attributes
 			      (concat "'" vhdl-attributes-regexp))
       (vhdl-fix-case-region-1 position (point) vhdl-upper-case-enum-values
-			      vhdl-enum-values-regexp))
+			      vhdl-enum-values-regexp)
+      (vhdl-fix-case-region-1 position (point) vhdl-upper-case-constants
+			      vhdl-constants-regexp))
     (when (or (not (equal string "")) (not optional))
       (insert (or follow-string "")))
     (if (equal string "") nil string)))
@@ -10455,55 +10817,57 @@ else insert tab (used for word completion in VHDL minibuffer)."
 (defun vhdl-beginning-of-block ()
   "Move cursor to the beginning of the enclosing block."
   (let (pos)
-    (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]+\\)?\\(function\\|procedure\\)\\|\\(for\\)\\|\\(architecture\\|component\\|configuration\\|entity\\|package\\|record\\|units\\)\\|\\(\\w+[ \t\n]*:[ \t\n]*\\)?\\(postponed[ \t\n]+\\)?\\(block\\|case\\|for\\|if\\|procedural\\|process\\|while\\)\\)\\>" nil t))
-			     ;; not consider subprogram declarations
-			     (or (and (match-string 5)
-				      (save-match-data
-					(save-excursion
-					  (goto-char (match-end 5))
-					  (forward-word 1)
-					  (vhdl-forward-syntactic-ws)
-					  (when (looking-at "(")
-					    (forward-sexp))
-					  (re-search-forward "\\<is\\>\\|\\(;\\)" nil t))
-					(match-string 1)))
-				 ;; not consider configuration specifications
-				 (and (match-string 6)
-				      (save-match-data
-					(save-excursion
-					  (vhdl-end-of-block)
-					  (beginning-of-line)
-					  (not (looking-at "^\\s-*end\\s-+\\(for\\|generate\\|loop\\)\\>"))))))))
-		 (match-string 2))
-	;; skip subblock if block end found
-	(vhdl-beginning-of-block)))
+    (vhdl-prepare-search-2
+     (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))
+			      ;; not consider subprogram declarations
+			      (or (and (match-string 5)
+				       (save-match-data
+					 (save-excursion
+					   (goto-char (match-end 5))
+					   (forward-word 1)
+					   (vhdl-forward-syntactic-ws)
+					   (when (looking-at "(")
+					     (forward-sexp))
+					   (re-search-forward "\\<is\\>\\|\\(;\\)" nil t))
+					 (match-string 1)))
+				  ;; not consider configuration specifications
+				  (and (match-string 6)
+				       (save-match-data
+					 (save-excursion
+					   (vhdl-end-of-block)
+					   (beginning-of-line)
+					   (not (looking-at "^\\s-*end\\s-+\\(for\\|generate\\|loop\\)\\>"))))))))
+		  (match-string 2))
+	 ;; skip subblock if block end found
+	 (vhdl-beginning-of-block))))
     (when pos (goto-char pos))))
 
 (defun vhdl-end-of-block ()
   "Move cursor to the end of the enclosing block."
   (let (pos)
-    (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]+\\)?\\(function\\|procedure\\)\\|\\(for\\)\\|\\(architecture\\|component\\|configuration\\|entity\\|package\\|record\\|units\\)\\|\\(\\w+[ \t\n]*:[ \t\n]*\\)?\\(postponed[ \t\n]+\\)?\\(block\\|case\\|for\\|if\\|procedural\\|process\\|while\\)\\)\\>" nil t))
-			     ;; not consider subprogram declarations
-			     (or (and (match-string 5)
-				      (save-match-data
-					(save-excursion (re-search-forward "\\<is\\>\\|\\(;\\)" nil t))
-					(match-string 1)))
-				 ;; not consider configuration specifications
-				 (and (match-string 6)
-				      (save-match-data
-					(save-excursion
-					  (vhdl-end-of-block)
-					  (beginning-of-line)
-					  (not (looking-at "^\\s-*end\\s-+\\(for\\|generate\\|loop\\)\\>"))))))))
-		 (not (match-string 2)))
-	;; skip subblock if block beginning found
-	(vhdl-end-of-block)))
+    (vhdl-prepare-search-2
+     (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))
+			      ;; not consider subprogram declarations
+			      (or (and (match-string 5)
+				       (save-match-data
+					 (save-excursion (re-search-forward "\\<is\\>\\|\\(;\\)" nil t))
+					 (match-string 1)))
+				  ;; not consider configuration specifications
+				  (and (match-string 6)
+				       (save-match-data
+					 (save-excursion
+					   (vhdl-end-of-block)
+					   (beginning-of-line)
+					   (not (looking-at "^\\s-*end\\s-+\\(for\\|generate\\|loop\\)\\>"))))))))
+		  (not (match-string 2)))
+	 ;; skip subblock if block beginning found
+	 (vhdl-end-of-block))))
     (when pos (goto-char pos))))
 
 (defun vhdl-sequential-statement-p ()
@@ -10518,7 +10882,7 @@ else insert tab (used for word completion in VHDL minibuffer)."
 		   (< start (point)))
 	    ;; ... a sequential block
 	    (progn (vhdl-beginning-of-block)
-		   (looking-at "^\\s-*\\(\\(\\w+[ \t\n]+\\)?\\(function\\|procedure\\)\\|\\(\\w+[ \t\n]*:[ \t\n]*\\)?\\(\\w+[ \t\n]+\\)?\\(procedural\\|process\\)\\)\\>")))))))
+		   (looking-at "^\\s-*\\(\\(\\w+[ \t\n\r\f]+\\)?\\(function\\|procedure\\)\\|\\(\\w+[ \t\n\r\f]*:[ \t\n\r\f]*\\)?\\(\\w+[ \t\n\r\f]+\\)?\\(procedural\\|process\\)\\)\\>")))))))
 
 (defun vhdl-in-argument-list-p ()
   "Check if within an argument list."
@@ -10542,7 +10906,9 @@ but not if inside a comment or quote."
       (progn
 	(insert " ")
 	(unexpand-abbrev)
-	(delete-char -1))
+	(backward-word 1)
+	(vhdl-case-word 1)
+	(delete-char 1))
     (if (not vhdl-electric-mode)
 	(progn
 	  (insert " ")
@@ -10821,7 +11187,10 @@ but not if inside a comment or quote."
 (defun vhdl-parse-string (string &optional optional)
   "Check that the text following point matches the regexp in STRING."
   (if (looking-at string)
-      (goto-char (match-end 0))
+      (progn (goto-char (match-end 0))
+	     (when (vhdl-in-literal)
+	       (end-of-line))
+	     (point))
     (unless optional
       (throw 'parse (format "ERROR:  Syntax error near line %s, expecting \"%s\""
 			    (vhdl-current-line) string)))
@@ -10919,7 +11288,9 @@ reflected in a subsequent paste operation."
 	      port-dir (car port-dir-car))
 	(setcar port-dir-car
 		(cond ((equal port-dir "in") "out")
+		      ((equal port-dir "IN") "OUT")
 		      ((equal port-dir "out") "in")
+		      ((equal port-dir "OUT") "IN")
 		      (t port-dir)))
 	(setq port-list (cdr port-list)))
       (setq vhdl-port-reversed-direction (not vhdl-port-reversed-direction))
@@ -10949,20 +11320,23 @@ reflected in a subsequent paste operation."
 	  (message "Reading port of %s \"%s\"..." decl-type name)
 	  (vhdl-forward-syntactic-ws)
 	  ;; parse generic clause
-	  (when (vhdl-parse-string "generic[ \t\n]*(" t)
+	  (when (vhdl-parse-string "generic[ \t\n\r\f]*(" t)
 	    ;; parse group comment and spacing
 	    (setq group-comment (vhdl-parse-group-comment))
-	    (setq end-of-list (vhdl-parse-string ")[ \t\n]*;[ \t\n]*" t))
+	    (setq end-of-list (vhdl-parse-string ")[ \t\n\r\f]*;[ \t\n\r\f]*" t))
 	    (while (not end-of-list)
 	      ;; parse names (accept extended identifiers)
-	      (vhdl-parse-string "\\(\\w+\\|\\\\[^\\]+\\\\\\)[ \t\n]*")
+	      (vhdl-parse-string "\\(\\\\[^\\]+\\\\\\|\\w+\\)[ \t\n\r\f]*")
 	      (setq names (list (match-string-no-properties 1)))
-	      (while (vhdl-parse-string ",[ \t\n]*\\(\\w+\\)[ \t\n]*" t)
+	      (while (vhdl-parse-string ",[ \t\n\r\f]*\\(\\\\[^\\]+\\\\\\|\\w+\\)[ \t\n\r\f]*" t)
 		(setq names
 		      (append names (list (match-string-no-properties 1)))))
 	      ;; parse type
-	      (vhdl-parse-string ":[ \t\n]*\\([^():;\n]+\\)")
+	      (vhdl-parse-string ":[ \t\n\r\f]*\\([^():;\n]+\\)")
 	      (setq type (match-string-no-properties 1))
+	      (when (vhdl-in-comment-p) ; if stuck in comment
+		(setq type (concat type (and (vhdl-parse-string ".*")
+					     (match-string-no-properties 0)))))
 	      (setq comment nil)
 	      (while (looking-at "(")
 		(setq type
@@ -10980,7 +11354,7 @@ reflected in a subsequent paste operation."
 	      (setq type (substring type 0 (match-end 1)))
 	      ;; parse initialization expression
 	      (setq init nil)
-	      (when (vhdl-parse-string ":=[ \t\n]*" t)
+	      (when (vhdl-parse-string ":=[ \t\n\r\f]*" t)
 		(vhdl-parse-string "\\([^();\n]*\\)")
 		(setq init (match-string-no-properties 1))
 		(while (looking-at "(")
@@ -11014,28 +11388,31 @@ reflected in a subsequent paste operation."
 	      ;; parse group comment and spacing
 	      (setq group-comment (vhdl-parse-group-comment))))
 	  ;; parse port clause
-	  (when (vhdl-parse-string "port[ \t\n]*(" t)
+	  (when (vhdl-parse-string "port[ \t\n\r\f]*(" t)
 	    ;; parse group comment and spacing
 	    (setq group-comment (vhdl-parse-group-comment))
-	    (setq end-of-list (vhdl-parse-string ")[ \t\n]*;[ \t\n]*" t))
+	    (setq end-of-list (vhdl-parse-string ")[ \t\n\r\f]*;[ \t\n\r\f]*" t))
 	    (while (not end-of-list)
 	      ;; parse object
 	      (setq object
-		    (and (vhdl-parse-string "\\<\\(signal\\|quantity\\|terminal\\)\\>[ \t\n]*" t)
+		    (and (vhdl-parse-string "\\<\\(signal\\|quantity\\|terminal\\)\\>[ \t\n\r\f]*" t)
 			 (match-string-no-properties 1)))
 	      ;; parse names (accept extended identifiers)
-	      (vhdl-parse-string "\\(\\w+\\|\\\\[^\\]+\\\\\\)[ \t\n]*")
+	      (vhdl-parse-string "\\(\\\\[^\\]+\\\\\\|\\w+\\)[ \t\n\r\f]*")
 	      (setq names (list (match-string-no-properties 1)))
-	      (while (vhdl-parse-string ",[ \t\n]*\\(\\w+\\|\\\\[^\\]+\\\\\\)[ \t\n]*" t)
+	      (while (vhdl-parse-string ",[ \t\n\r\f]*\\(\\\\[^\\]+\\\\\\|\\w+\\)[ \t\n\r\f]*" t)
 		(setq names (append names (list (match-string-no-properties 1)))))
 	      ;; parse direction
-	      (vhdl-parse-string ":[ \t\n]*")
+	      (vhdl-parse-string ":[ \t\n\r\f]*")
 	      (setq direct
-		    (and (vhdl-parse-string "\\<\\(in\\|out\\|inout\\|buffer\\|linkage\\)\\>[ \t\n]+" t)
+		    (and (vhdl-parse-string "\\<\\(in\\|out\\|inout\\|buffer\\|linkage\\)\\>[ \t\n\r\f]+" t)
 			 (match-string-no-properties 1)))
 	      ;; parse type
 	      (vhdl-parse-string "\\([^();\n]+\\)")
 	      (setq type (match-string-no-properties 1))
+	      (when (vhdl-in-comment-p) ; if stuck in comment
+		(setq type (concat type (and (vhdl-parse-string ".*")
+					     (match-string-no-properties 0)))))
 	      (setq comment nil)
 	      (while (looking-at "(")
 		(setq type (concat type
@@ -11313,7 +11690,7 @@ reflected in a subsequent paste operation."
 	  (setq port-list (cdr port-list))
 	  (insert (if port-list "," ");"))
 	  ;; paste comment
-	  (when (or vhdl-include-direction-comments
+	  (when (or (and vhdl-include-direction-comments (nth 2 port))
 		    vhdl-include-type-comments
 		    (and vhdl-include-port-comments (nth 4 port)))
 	    (vhdl-comment-insert-inline
@@ -11454,12 +11831,17 @@ reflected in a subsequent paste operation."
 	  ;; paste type
 	  (insert " : " (nth 3 port))
 	  ;; paste initialization (inputs only)
-	  (when (and initialize (equal "IN" (upcase (nth 2 port))))
-	    (insert " := " (if (string-match "(.+)" (nth 3 port))
-			       "(others => '0')" "'0'")))
+	  (when (and initialize (nth 2 port) (equal "IN" (upcase (nth 2 port))))
+	    (insert " := "
+		    (cond ((string-match "integer" (nth 3 port)) "0")
+			  ((string-match "natural" (nth 3 port)) "0")
+			  ((string-match "positive" (nth 3 port)) "0")
+			  ((string-match "real" (nth 3 port)) "0.0")
+			  ((string-match "(.+)" (nth 3 port)) "(others => '0')")
+			  (t "'0'"))))
 	  (insert ";")
 	  ;; paste comment
-	  (when (or vhdl-include-direction-comments
+	  (when (or (and vhdl-include-direction-comments (nth 2 port))
 		    (and vhdl-include-port-comments (nth 4 port)))
 	    (vhdl-comment-insert-inline
 	     (concat
@@ -11495,8 +11877,14 @@ reflected in a subsequent paste operation."
 	      (setq name (car (nth 0 port)))
 	      (insert (vhdl-replace-string vhdl-actual-port-name name))
 	      ;; paste initialization
-	      (insert " <= " (if (string-match "(.+)" (nth 3 port))
-				 "(others => '0')" "'0'") ";"))
+	      (insert " <= "
+		      (cond ((string-match "integer" (nth 3 port)) "0")
+			    ((string-match "natural" (nth 3 port)) "0")
+			    ((string-match "positive" (nth 3 port)) "0")
+			    ((string-match "real" (nth 3 port)) "0.0")
+			    ((string-match "(.+)" (nth 3 port)) "(others => '0')")
+			    (t "'0'"))
+		      ";"))
 	    (setq port-list (cdr port-list))
 	    (when (and port-list
 		       (equal "IN" (upcase (nth 2 (car port-list)))))
@@ -11609,7 +11997,9 @@ reflected in a subsequent paste operation."
       ;; paste custom declarations
       (unless (equal "" vhdl-testbench-declarations)
 	(insert "\n")
-	(vhdl-insert-string-or-file vhdl-testbench-declarations))
+	(setq position (point))
+	(vhdl-insert-string-or-file vhdl-testbench-declarations)
+	(vhdl-indent-region position (point)))
       (setq position (point))
       (insert "\n\n")
       (vhdl-comment-display-line) (insert "\n")
@@ -11638,7 +12028,9 @@ reflected in a subsequent paste operation."
       ;; paste custom statements
       (unless (equal "" vhdl-testbench-statements)
 	(insert "\n")
-	(vhdl-insert-string-or-file vhdl-testbench-statements))
+	(setq position (point))
+	(vhdl-insert-string-or-file vhdl-testbench-statements)
+	(vhdl-indent-region position (point)))
       (insert "\n")
       (indent-to vhdl-basic-offset)
       (unless (eq vhdl-testbench-create-files 'none)
@@ -11707,8 +12099,8 @@ reflected in a subsequent paste operation."
 	  ;; check if within function declaration
 	  (setq pos (point))
 	  (end-of-line)
-	  (when (looking-at "[ \t\n]*\\((\\|;\\|is\\>\\)") (goto-char (match-end 0)))
-	  (unless (and (re-search-backward "^\\s-*\\(\\(procedure\\)\\|\\(\\(pure\\|impure\\)\\s-+\\)?function\\)\\s-+\\(\"?\\w+\"?\\)[ \t\n]*\\(\\((\\)\\|;\\|is\\>\\)" nil t)
+	  (when (looking-at "[ \t\n\r\f]*\\((\\|;\\|is\\>\\)") (goto-char (match-end 0)))
+	  (unless (and (re-search-backward "^\\s-*\\(\\(procedure\\)\\|\\(\\(pure\\|impure\\)\\s-+\\)?function\\)\\s-+\\(\"?\\w+\"?\\)[ \t\n\r\f]*\\(\\((\\)\\|;\\|is\\>\\)" nil t)
 		       (goto-char (match-end 0))
 		       (save-excursion (backward-char)
 				    (forward-sexp)
@@ -11721,21 +12113,21 @@ reflected in a subsequent paste operation."
 	  ;; parse parameter list
 	  (setq group-comment (vhdl-parse-group-comment))
 	  (setq end-of-list (or end-of-list
-				(vhdl-parse-string ")[ \t\n]*\\(;\\|\\(is\\|return\\)\\>\\)" t)))
+				(vhdl-parse-string ")[ \t\n\r\f]*\\(;\\|\\(is\\|return\\)\\>\\)" t)))
 	  (while (not end-of-list)
 	    ;; parse object
 	    (setq object
-		  (and (vhdl-parse-string "\\(constant\\|signal\\|variable\\|file\\|quantity\\|terminal\\)[ \t\n]*" t)
+		  (and (vhdl-parse-string "\\(constant\\|signal\\|variable\\|file\\|quantity\\|terminal\\)[ \t\n\r\f]*" t)
 			 (match-string-no-properties 1)))
 	    ;; parse names (accept extended identifiers)
-	    (vhdl-parse-string "\\(\\w+\\|\\\\[^\\]+\\\\\\)[ \t\n]*")
+	    (vhdl-parse-string "\\(\\\\[^\\]+\\\\\\|\\w+\\)[ \t\n\r\f]*")
 	    (setq names (list (match-string-no-properties 1)))
-	    (while (vhdl-parse-string ",[ \t\n]*\\(\\w+\\|\\\\[^\\]+\\\\\\)[ \t\n]*" t)
+	    (while (vhdl-parse-string ",[ \t\n\r\f]*\\(\\\\[^\\]+\\\\\\|\\w+\\)[ \t\n\r\f]*" t)
 	      (setq names (append names (list (match-string-no-properties 1)))))
 	    ;; parse direction
-	    (vhdl-parse-string ":[ \t\n]*")
+	    (vhdl-parse-string ":[ \t\n\r\f]*")
 	    (setq direct
-		  (and (vhdl-parse-string "\\(in\\|out\\|inout\\|buffer\\|linkage\\)[ \t\n]+" t)
+		  (and (vhdl-parse-string "\\(in\\|out\\|inout\\|buffer\\|linkage\\)[ \t\n\r\f]+" t)
 		       (match-string-no-properties 1)))
 	    ;; parse type
 	    (vhdl-parse-string "\\([^():;\n]+\\)")
@@ -11757,7 +12149,7 @@ reflected in a subsequent paste operation."
 	    (setq type (substring type 0 (match-end 1)))
 	    ;; parse initialization expression
 	    (setq init nil)
-	    (when (vhdl-parse-string ":=[ \t\n]*" t)
+	    (when (vhdl-parse-string ":=[ \t\n\r\f]*" t)
 	      (vhdl-parse-string "\\([^();\n]*\\)")
 	      (setq init (match-string-no-properties 1))
 	      (while (looking-at "(")
@@ -11787,7 +12179,7 @@ reflected in a subsequent paste operation."
 	    (vhdl-parse-string "\\(;\\|\\(is\\|\\(return\\)\\)\\>\\)\\s-*")
 	    ;; parse return type
 	    (when (match-string 3)
-	      (vhdl-parse-string "[ \t\n]*\\(.+\\)[ \t\n]*\\(;\\|is\\>\\)\\s-*")
+	      (vhdl-parse-string "[ \t\n\r\f]*\\(.+\\)[ \t\n\r\f]*\\(;\\|is\\>\\)\\s-*")
 	      (setq return-type (match-string-no-properties 1))
 	      (when (and return-type
 			 (string-match "\\(\\s-*--\\s-*\\)\\(.*\\)" return-type))
@@ -12015,17 +12407,15 @@ expressions (e.g. for index ranges of types and signals)."
  (defalias 'he-list-beg 'vhdl-he-list-beg))
 
 ;; function for expanding abbrevs and dabbrevs
-(defun vhdl-expand-abbrev (arg))
-(fset 'vhdl-expand-abbrev (make-hippie-expand-function
-			   '(try-expand-dabbrev
-			     try-expand-dabbrev-all-buffers
-			     vhdl-try-expand-abbrev)))
+(defalias 'vhdl-expand-abbrev (make-hippie-expand-function
+			       '(try-expand-dabbrev
+				 try-expand-dabbrev-all-buffers
+				 vhdl-try-expand-abbrev)))
 
 ;; function for expanding parenthesis
-(defun vhdl-expand-paren (arg))
-(fset 'vhdl-expand-paren (make-hippie-expand-function
-			  '(try-expand-list
-			    try-expand-list-all-buffers)))
+(defalias 'vhdl-expand-paren (make-hippie-expand-function
+			      '(try-expand-list
+				try-expand-list-all-buffers)))
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;;  Case fixing
@@ -12049,7 +12439,7 @@ depending on parameter UPPER-CASE."
 		    (< vhdl-progress-interval
 		       (- (nth 1 (current-time)) last-update)))
 	   (message "Fixing case... (%2d%s)"
-		    (+ (* count 25) (/ (* 25 (- (point) beg)) (- end beg)))
+		    (+ (* count 20) (/ (* 20 (- (point) beg)) (- end beg)))
 		    "%")
 	   (setq last-update (nth 1 (current-time)))))
        (goto-char end)))))
@@ -12066,6 +12456,8 @@ options vhdl-upper-case-{keywords,types,attributes,enum-values}."
    beg end vhdl-upper-case-attributes (concat "'" vhdl-attributes-regexp) 2)
   (vhdl-fix-case-region-1
    beg end vhdl-upper-case-enum-values vhdl-enum-values-regexp 3)
+  (vhdl-fix-case-region-1
+   beg end vhdl-upper-case-constants vhdl-constants-regexp 4)
   (when vhdl-progress-interval (message "Fixing case...done")))
 
 (defun vhdl-fix-case-buffer ()
@@ -12091,6 +12483,9 @@ options vhdl-upper-case-{keywords,types,attributes,enum-values}."
        (upcase-word 1))
      (when (and vhdl-upper-case-enum-values
 		(looking-at vhdl-enum-values-regexp))
+       (upcase-word 1))
+     (when (and vhdl-upper-case-constants
+		(looking-at vhdl-constants-regexp))
        (upcase-word 1)))))
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
@@ -12205,6 +12600,9 @@ it works within comments too."
   (interactive)
   (let ((no-stats 0)
 	(no-code-lines 0)
+	(no-empty-lines 0)
+	(no-comm-lines 0)
+	(no-comments 0)
 	(no-lines (count-lines (point-min) (point-max))))
     (save-excursion
       ;; count statements
@@ -12218,15 +12616,40 @@ it works within comments too."
       (while (not (eobp))
 	(unless (looking-at "^\\s-*\\(--.*\\)?$")
 	  (setq no-code-lines (1+ no-code-lines)))
-	(beginning-of-line 2)))
+	(beginning-of-line 2))
+      ;; count empty lines
+      (goto-char (point-min))
+      (while (and (re-search-forward "^\\s-*$" nil t)
+		  (not (eq (point) (point-max))))
+	(if (match-string 1)
+	    (goto-char (match-end 1))
+	  (setq no-empty-lines (1+ no-empty-lines))
+	  (unless (eq (point) (point-max))
+	    (forward-char))))
+      ;; count comment-only lines
+      (goto-char (point-min))
+      (while (re-search-forward "^\\s-*--.*" nil t)
+	(if (match-string 1)
+	    (goto-char (match-end 1))
+	  (setq no-comm-lines (1+ no-comm-lines))))
+      ;; count comments
+      (goto-char (point-min))
+      (while (re-search-forward "--.*" nil t)
+	(if (match-string 1)
+	    (goto-char (match-end 1))
+	  (setq no-comments (1+ no-comments)))))
     ;; print results
     (message "\n\
 File statistics: \"%s\"\n\
 ---------------------\n\
-# statements  : %5d\n\
-# code lines  : %5d\n\
-# total lines : %5d\n\ "
-	     (buffer-file-name) no-stats no-code-lines no-lines)
+# statements    : %5d\n\
+# code lines    : %5d\n\
+# empty lines   : %5d\n\
+# comment lines : %5d\n\
+# comments      : %5d\n\
+# total lines   : %5d\n\ "
+	     (buffer-file-name) no-stats no-code-lines no-empty-lines
+	     no-comm-lines no-comments no-lines)
     (unless vhdl-emacs-21 (vhdl-show-messages))))
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
@@ -12390,18 +12813,18 @@ File statistics: \"%s\"\n\
   (concat
    "\\(^\\)\\s-*\\("
    ;; generic/port clause
-   "\\(generic\\|port\\)[ \t\n]*(\\|"
+   "\\(generic\\|port\\)[ \t\n\r\f]*(\\|"
    ;; component
    "component\\>\\|"
    ;; component instantiation
-   "\\(\\w\\|\\s_\\)+[ \t\n]*:[ \t\n]*"
-   "\\(\\(component\\|configuration\\|entity\\)[ \t\n]+\\)?"
-   "\\(\\w\\|\\s_\\)+\\([ \t\n]*(\\(\\w\\|\\s_\\)+)\\)?[ \t\n]*"
-   "\\(generic\\|port\\)[ \t\n]+map[ \t\n]*(\\|"
+   "\\(\\w\\|\\s_\\)+[ \t\n\r\f]*:[ \t\n\r\f]*"
+   "\\(\\(component\\|configuration\\|entity\\)[ \t\n\r\f]+\\)?"
+   "\\(\\w\\|\\s_\\)+\\([ \t\n\r\f]*(\\(\\w\\|\\s_\\)+)\\)?[ \t\n\r\f]*"
+   "\\(generic\\|port\\)[ \t\n\r\f]+map[ \t\n\r\f]*(\\|"
    ;; subprogram
    "\\(function\\|procedure\\)\\>\\|"
    ;; process, block
-   "\\(\\(\\w\\|\\s_\\)+[ \t\n]*:[ \t\n]*\\)?\\(process\\|block\\)\\>\\|"
+   "\\(\\(\\w\\|\\s_\\)+[ \t\n\r\f]*:[ \t\n\r\f]*\\)?\\(process\\|block\\)\\>\\|"
    ;; configuration declaration
    "configuration\\>"
    "\\)")
@@ -12414,7 +12837,7 @@ File statistics: \"%s\"\n\
      (beginning-of-line)
      (cond
       ;; generic/port clause
-      ((looking-at "^\\s-*\\(generic\\|port\\)[ \t\n]*(")
+      ((looking-at "^\\s-*\\(generic\\|port\\)[ \t\n\r\f]*(")
        (goto-char (match-end 0))
        (backward-char)
        (forward-sexp))
@@ -12424,16 +12847,16 @@ File statistics: \"%s\"\n\
       ;; component instantiation
       ((looking-at
 	(concat
-	 "^\\s-*\\w+\\s-*:[ \t\n]*"
-	 "\\(\\(component\\|configuration\\|entity\\)[ \t\n]+\\)?"
-	 "\\w+\\(\\s-*(\\w+)\\)?[ \t\n]*"
-	 "\\(generic\\|port\\)\\s-+map[ \t\n]*("))
+	 "^\\s-*\\w+\\s-*:[ \t\n\r\f]*"
+	 "\\(\\(component\\|configuration\\|entity\\)[ \t\n\r\f]+\\)?"
+	 "\\w+\\(\\s-*(\\w+)\\)?[ \t\n\r\f]*"
+	 "\\(generic\\|port\\)\\s-+map[ \t\n\r\f]*("))
        (goto-char (match-end 0))
        (backward-char)
        (forward-sexp)
        (setq pos (point))
        (vhdl-forward-syntactic-ws)
-       (when (looking-at "port\\s-+map[ \t\n]*(")
+       (when (looking-at "port\\s-+map[ \t\n\r\f]*(")
 	 (goto-char (match-end 0))
 	 (backward-char)
 	 (forward-sexp)
@@ -12585,7 +13008,7 @@ This does highlighting of keywords and standard identifiers.")
    ;; highlight labels of common constructs
    (list
     (concat
-     "^\\s-*\\(\\w+\\)\\s-*:[ \t\n]*\\(\\("
+     "^\\s-*\\(\\w+\\)\\s-*:[ \t\n\r\f]*\\(\\("
      "assert\\|block\\|case\\|exit\\|for\\|if\\|loop\\|next\\|null\\|"
      "postponed\\|process\\|"
      (when (vhdl-standard-p 'ams) "procedural\\|")
@@ -12596,14 +13019,14 @@ This does highlighting of keywords and standard identifiers.")
    ;; highlight label and component name of component instantiations
    (list
     (concat
-     "^\\s-*\\(\\w+\\)\\s-*:[ \t\n]*\\(\\w+\\)"
-     "\\(\\s-*\\(--[^\n]*\\)?$\\|\\s-+\\(generic\\|port\\)\\s-+map\\>\\)")
+     "^\\s-*\\(\\w+\\)\\s-*:[ \t\n\r\f]*\\(\\w+\\)[ \t\n\r\f]*"
+     "\\(--[^\n]*[ \t\n\r\f]+\\)*\\(generic\\|port\\)\\s-+map\\>")
     '(1 font-lock-function-name-face) '(2 font-lock-function-name-face))
 
    ;; highlight label and instantiated unit of component instantiations
    (list
     (concat
-     "^\\s-*\\(\\w+\\)\\s-*:[ \t\n]*"
+     "^\\s-*\\(\\w+\\)\\s-*:[ \t\n\r\f]*"
      "\\(component\\|configuration\\|entity\\)\\s-+"
      "\\(\\w+\\)\\(\\.\\(\\w+\\)\\)?\\(\\s-*(\\(\\w+\\))\\)?")
     '(1 font-lock-function-name-face) '(3 font-lock-function-name-face)
@@ -12638,7 +13061,7 @@ This does highlighting of keywords and standard identifiers.")
    (list
     (concat
      "^\\s-*for\\s-+\\(\\w+\\(,\\s-*\\w+\\)*\\)\\>\\s-*"
-     "\\(:[ \t\n]*\\(\\w+\\)\\|[^i \t]\\)")
+     "\\(:[ \t\n\r\f]*\\(\\w+\\)\\|[^i \t]\\)")
     '(1 font-lock-function-name-face) '(4 font-lock-function-name-face nil t))
 
    ;; highlight names in library clauses
@@ -12662,8 +13085,8 @@ This does highlighting of keywords and standard identifiers.")
    ;; highlight type/nature name in (sub)type/(sub)nature declarations
    (list
     (concat
-     "^\\s-*\\(sub\\)?\\(nature\\|type\\)\\s-+\\(\\w+\\)")
-    3 'font-lock-type-face)
+     "^\\s-*\\(\\(sub\\)?\\(nature\\|type\\)\\|end\\s-+\\(record\\|protected\\)\\)\\s-+\\(\\w+\\)")
+    5 'font-lock-type-face)
 
    ;; highlight signal/variable/constant declaration names
    (list "\\(:[^=]\\)"
@@ -12867,6 +13290,7 @@ This does background highlighting of translate-off regions.")
 	 (list vhdl-functions-regexp   1 'vhdl-font-lock-function-face)
 	 (list vhdl-packages-regexp    1 'vhdl-font-lock-function-face)
 	 (list vhdl-enum-values-regexp 1 'vhdl-font-lock-enumvalue-face)
+	 (list vhdl-constants-regexp   1 'font-lock-constant-face)
 	 (list vhdl-keywords-regexp    1 'font-lock-keyword-face)))
   ;; highlight words with special syntax.
   (setq vhdl-font-lock-keywords-3
@@ -12875,9 +13299,10 @@ This does background highlighting of translate-off regions.")
 	  (while syntax-alist
 	    (setq keywords
 		  (cons
-		   (cons (concat "\\<\\(" (nth 1 (car syntax-alist)) "\\)\\>")
+		   (list (concat "\\(" (nth 1 (car syntax-alist)) "\\)") 1
 			 (vhdl-function-name
-			  "vhdl-font-lock" (nth 0 (car syntax-alist)) "face"))
+			  "vhdl-font-lock" (nth 0 (car syntax-alist)) "face")
+			 (nth 4 (car syntax-alist)))
 		   keywords))
 	    (setq syntax-alist (cdr syntax-alist)))
 	  keywords))
@@ -13066,7 +13491,7 @@ hierarchy otherwise.")
       (when (re-search-backward "^[ \t]*\\(architecture\\|configuration\\|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]*\\(\\w+\\)\\.\\(\\w+\\)\\.\\w+")
+	  (when (looking-at "^[ \t]*use[ \t\n\r\f]*\\(\\w+\\)\\.\\(\\w+\\)\\.\\w+")
 	    (setq lib-alist (cons (cons (match-string-no-properties 1)
 					(vhdl-match-string-downcase 2))
 				  lib-alist))))))
@@ -13140,7 +13565,7 @@ hierarchy otherwise.")
 			 (setq big-files t))
 		;; scan for entities
 		(goto-char (point-min))
-		(while (re-search-forward "^[ \t]*entity[ \t\n]+\\(\\w+\\)[ \t\n]+is\\>" nil t)
+		(while (re-search-forward "^[ \t]*entity[ \t\n\r\f]+\\(\\w+\\)[ \t\n\r\f]+is\\>" nil t)
 		  (let* ((ent-name (match-string-no-properties 1))
 			 (ent-key (downcase ent-name))
 			 (ent-entry (aget ent-alist ent-key t))
@@ -13157,7 +13582,7 @@ hierarchy otherwise.")
 				  lib-alist)))))
 		;; scan for architectures
 		(goto-char (point-min))
-		(while (re-search-forward "^[ \t]*architecture[ \t\n]+\\(\\w+\\)[ \t\n]+of[ \t\n]+\\(\\w+\\)[ \t\n]+is\\>" nil t)
+		(while (re-search-forward "^[ \t]*architecture[ \t\n\r\f]+\\(\\w+\\)[ \t\n\r\f]+of[ \t\n\r\f]+\\(\\w+\\)[ \t\n\r\f]+is\\>" nil t)
 		  (let* ((arch-name (match-string-no-properties 1))
 			 (arch-key (downcase arch-name))
 			 (ent-name (match-string-no-properties 2))
@@ -13183,7 +13608,7 @@ hierarchy otherwise.")
 				  arch-key (nth 5 ent-entry))))))
 		;; scan for configurations
 		(goto-char (point-min))
-		(while (re-search-forward "^[ \t]*configuration[ \t\n]+\\(\\w+\\)[ \t\n]+of[ \t\n]+\\(\\w+\\)[ \t\n]+is\\>" nil t)
+		(while (re-search-forward "^[ \t]*configuration[ \t\n\r\f]+\\(\\w+\\)[ \t\n\r\f]+of[ \t\n\r\f]+\\(\\w+\\)[ \t\n\r\f]+is\\>" nil t)
 		  (let* ((conf-name (match-string-no-properties 1))
 			 (conf-key (downcase conf-name))
 			 (conf-entry (aget conf-alist conf-key t))
@@ -13195,7 +13620,7 @@ hierarchy otherwise.")
 			 arch-key comp-conf-list inst-key-list
 			 inst-comp-key inst-ent-key inst-arch-key
 			 inst-conf-key inst-lib-key)
-		    (when (vhdl-re-search-forward "\\<for[ \t\n]+\\(\\w+\\)")
+		    (when (vhdl-re-search-forward "\\<for[ \t\n\r\f]+\\(\\w+\\)")
 		      (setq arch-key (vhdl-match-string-downcase 1)))
 		    (if conf-entry
 			(vhdl-warning-when-idle
@@ -13204,13 +13629,13 @@ hierarchy otherwise.")
 			 (nth 2 conf-entry) file-name conf-line)
 		      (setq conf-list (cons conf-key conf-list))
 		      ;; scan for subconfigurations and subentities
-		      (while (re-search-forward "^[ \t]*for[ \t\n]+\\(\\w+\\([ \t\n]*,[ \t\n]*\\w+\\)*\\)[ \t\n]*:[ \t\n]*\\(\\w+\\)[ \t\n]+" end-of-unit t)
+		      (while (re-search-forward "^[ \t]*for[ \t\n\r\f]+\\(\\w+\\([ \t\n\r\f]*,[ \t\n\r\f]*\\w+\\)*\\)[ \t\n\r\f]*:[ \t\n\r\f]*\\(\\w+\\)[ \t\n\r\f]+" end-of-unit t)
 			(setq inst-comp-key (vhdl-match-string-downcase 3)
 			      inst-key-list (split-string
 					     (vhdl-match-string-downcase 1)
-					     "[ \t\n]*,[ \t\n]*"))
+					     "[ \t\n\r\f]*,[ \t\n\r\f]*"))
 			(vhdl-forward-syntactic-ws)
-			(when (looking-at "use[ \t\n]+\\(\\(entity\\)\\|configuration\\)[ \t\n]+\\(\\w+\\)\\.\\(\\w+\\)[ \t\n]*\\((\\(\\w+\\))\\)?")
+			(when (looking-at "use[ \t\n\r\f]+\\(\\(entity\\)\\|configuration\\)[ \t\n\r\f]+\\(\\w+\\)\\.\\(\\w+\\)[ \t\n\r\f]*\\((\\(\\w+\\))\\)?")
 			  (setq
 			   inst-lib-key (vhdl-match-string-downcase 3)
 			   inst-ent-key (and (match-string 2)
@@ -13232,7 +13657,7 @@ hierarchy otherwise.")
 				  arch-key comp-conf-list lib-alist)))))
 		;; scan for packages
 		(goto-char (point-min))
-		(while (re-search-forward "^[ \t]*package[ \t\n]+\\(body[ \t\n]+\\)?\\(\\w+\\)[ \t\n]+is\\>" nil t)
+		(while (re-search-forward "^[ \t]*package[ \t\n\r\f]+\\(body[ \t\n\r\f]+\\)?\\(\\w+\\)[ \t\n\r\f]+is\\>" nil t)
 		  (let* ((pack-name (match-string-no-properties 2))
 			 (pack-key (downcase pack-name))
 			 (is-body (match-string-no-properties 1))
@@ -13250,7 +13675,7 @@ hierarchy otherwise.")
 		      ;; scan for context clauses
 		      (setq lib-alist (vhdl-scan-context-clause))
 		      ;; scan for component and subprogram declarations/bodies
-		      (while (re-search-forward "^[ \t]*\\(component\\|function\\|procedure\\)[ \t\n]+\\(\\w+\\|\".*\"\\)" end-of-unit t)
+		      (while (re-search-forward "^[ \t]*\\(component\\|function\\|procedure\\)[ \t\n\r\f]+\\(\\w+\\|\".*\"\\)" end-of-unit t)
 			(if (equal (upcase (match-string 1)) "COMPONENT")
 			    (setq comp-name (match-string-no-properties 2)
 				  comp-alist
@@ -13286,7 +13711,7 @@ hierarchy otherwise.")
 			 (setq big-files t))
 		;; scan for architectures
 		(goto-char (point-min))
-		(while (re-search-forward "^[ \t]*architecture[ \t\n]+\\(\\w+\\)[ \t\n]+of[ \t\n]+\\(\\w+\\)[ \t\n]+is\\>" nil t)
+		(while (re-search-forward "^[ \t]*architecture[ \t\n\r\f]+\\(\\w+\\)[ \t\n\r\f]+of[ \t\n\r\f]+\\(\\w+\\)[ \t\n\r\f]+is\\>" nil t)
 		  (let* ((ent-name (match-string-no-properties 2))
 			 (ent-key (downcase ent-name))
 			 (arch-name (match-string-no-properties 1))
@@ -13300,12 +13725,12 @@ hierarchy otherwise.")
 			 inst-alist inst-path)
 		    ;; scan for contained instantiations
 		    (while (and (re-search-forward
-				 (concat "^[ \t]*\\(\\w+\\)[ \t\n]*:[ \t\n]*\\("
-					 "\\(\\w+\\)[ \t\n]+\\(--[^\n]*\n[ \t\n]*\\)*\\(generic\\|port\\)[ \t\n]+map\\>\\|"
-					 "component[ \t\n]+\\(\\w+\\)\\|"
-					 "\\(\\(entity\\)\\|configuration\\)[ \t\n]+\\(\\(\\w+\\)\\.\\)?\\(\\w+\\)\\([ \t\n]*(\\(\\w+\\))\\)?\\|"
+				 (concat "^[ \t]*\\(\\w+\\)[ \t\n\r\f]*:[ \t\n\r\f]*\\("
+					 "\\(\\w+\\)[ \t\n\r\f]+\\(--[^\n]*\n[ \t\n\r\f]*\\)*\\(generic\\|port\\)[ \t\n\r\f]+map\\>\\|"
+					 "component[ \t\n\r\f]+\\(\\w+\\)\\|"
+					 "\\(\\(entity\\)\\|configuration\\)[ \t\n\r\f]+\\(\\(\\w+\\)\\.\\)?\\(\\w+\\)\\([ \t\n\r\f]*(\\(\\w+\\))\\)?\\|"
 					 "\\(\\(for\\|if\\)\\>[^;:]+\\<generate\\>\\|block\\>\\)\\)\\|"
-					 "\\(^[ \t]*end[ \t\n]+\\(generate\\|block\\)\\>\\)") end-of-unit t)
+					 "\\(^[ \t]*end[ \t\n\r\f]+\\(generate\\|block\\)\\>\\)") end-of-unit t)
 				(or (not limit-hier-inst-no)
 				    (<= (setq inst-no (1+ inst-no))
 					limit-hier-inst-no)))
@@ -13349,8 +13774,8 @@ hierarchy otherwise.")
 		    ;; scan for contained configuration specifications
 		    (goto-char beg-of-unit)
 		    (while (re-search-forward
-			    (concat "^[ \t]*for[ \t\n]+\\(\\w+\\([ \t\n]*,[ \t\n]*\\w+\\)*\\)[ \t\n]*:[ \t\n]*\\(\\w+\\)[ \t\n]+\\(--[^\n]*\n[ \t\n]*\\)*"
-				    "use[ \t\n]+\\(\\(entity\\)\\|configuration\\)[ \t\n]+\\(\\(\\w+\\)\\.\\)?\\(\\w+\\)\\([ \t\n]*(\\(\\w+\\))\\)?") end-of-unit t)
+			    (concat "^[ \t]*for[ \t\n\r\f]+\\(\\w+\\([ \t\n\r\f]*,[ \t\n\r\f]*\\w+\\)*\\)[ \t\n\r\f]*:[ \t\n\r\f]*\\(\\w+\\)[ \t\n\r\f]+\\(--[^\n]*\n[ \t\n\r\f]*\\)*"
+				    "use[ \t\n\r\f]+\\(\\(entity\\)\\|configuration\\)[ \t\n\r\f]+\\(\\(\\w+\\)\\.\\)?\\(\\w+\\)\\([ \t\n\r\f]*(\\(\\w+\\))\\)?") end-of-unit t)
 		      (let* ((inst-comp-name (match-string-no-properties 3))
 			     (inst-ent-key
 			      (and (match-string 6)
@@ -13362,7 +13787,7 @@ hierarchy otherwise.")
 			     (inst-lib-key (vhdl-match-string-downcase 8))
 			     (inst-key-list
 			      (split-string (vhdl-match-string-downcase 1)
-					    "[ \t\n]*,[ \t\n]*"))
+					    "[ \t\n\r\f]*,[ \t\n\r\f]*"))
 			     (tmp-inst-alist inst-alist)
 			     inst-entry)
 			(while tmp-inst-alist
@@ -15347,7 +15772,7 @@ expansion function)."
 	      (read-from-minibuffer "architecture name: "
 				    nil vhdl-minibuffer-local-map)
 	    (vhdl-replace-string vhdl-compose-architecture-name ent-name)))
-	 ent-file-name arch-file-name ent-buffer arch-buffer project)
+	 ent-file-name arch-file-name ent-buffer arch-buffer project end-pos)
     (message "Creating component \"%s(%s)\"..." ent-name arch-name)
     ;; open entity file
     (unless (eq vhdl-compose-create-files 'none)
@@ -15364,6 +15789,7 @@ expansion function)."
     ;; insert header
     (if vhdl-compose-include-header
 	(progn (vhdl-template-header)
+	       (setq end-pos (point))
 	       (goto-char (point-max)))
       (vhdl-comment-display-line) (insert "\n\n"))
     ;; insert library clause
@@ -15390,6 +15816,7 @@ expansion function)."
     ;; open architecture file
     (if (not (eq vhdl-compose-create-files 'separate))
 	(insert "\n")
+      (goto-char (or end-pos (point-min)))
       (setq ent-buffer (current-buffer))
       (setq arch-file-name
 	    (concat (vhdl-replace-string vhdl-architecture-file-name
@@ -15434,7 +15861,7 @@ expansion function)."
     (if (and vhdl-compose-include-header (not (equal vhdl-file-footer "")))
 	(vhdl-template-footer)
       (vhdl-comment-display-line) (insert "\n"))
-    (goto-char (point-min))
+    (goto-char (or end-pos (point-min)))
     (setq arch-buffer (current-buffer))
     (when ent-buffer (set-buffer ent-buffer) (save-buffer))
     (set-buffer arch-buffer) (save-buffer)
@@ -15453,8 +15880,8 @@ component instantiation."
       (error "ERROR:  No port has been read")
     (save-excursion
       (vhdl-prepare-search-2
-       (unless (or (re-search-backward "^architecture[ \t\n]+\\w+[ \t\n]+of[ \t\n]+\\(\\w+\\)[ \t\n]+is\\>" nil t)
-		   (re-search-forward "^architecture[ \t\n]+\\w+[ \t\n]+of[ \t\n]+\\(\\w+\\)[ \t\n]+is\\>" nil t))
+       (unless (or (re-search-backward "^architecture[ \t\n\r\f]+\\w+[ \t\n\r\f]+of[ \t\n\r\f]+\\(\\w+\\)[ \t\n\r\f]+is\\>" nil t)
+		   (re-search-forward "^architecture[ \t\n\r\f]+\\w+[ \t\n\r\f]+of[ \t\n\r\f]+\\(\\w+\\)[ \t\n\r\f]+is\\>" nil t))
 	 (error "ERROR:  No architecture found"))
        (let* ((ent-name (match-string 1))
 	      (ent-file-name
@@ -15471,13 +15898,13 @@ component instantiation."
 				(car vhdl-port-list) "\\>") nil t)))
 	   (re-search-forward "^begin\\>" nil)
 	   (beginning-of-line)
-	   (skip-chars-backward " \t\n")
+	   (skip-chars-backward " \t\n\r\f")
 	   (insert "\n\n") (indent-to vhdl-basic-offset)
 	   (vhdl-port-paste-component t))
 	 ;; place component instantiation
 	 (re-search-forward "^end\\>" nil)
 	 (beginning-of-line)
-	 (skip-chars-backward " \t\n")
+	 (skip-chars-backward " \t\n\r\f")
 	 (insert "\n\n") (indent-to vhdl-basic-offset)
 	 (vhdl-port-paste-instance nil t t)
 	 ;; place use clause for used packages
@@ -15486,7 +15913,7 @@ component instantiation."
 	   (when (file-exists-p ent-file-name)
 	     (find-file ent-file-name))
 	   (goto-char (point-min))
-	   (unless (re-search-forward (concat "^entity[ \t\n]+" ent-name "[ \t\n]+is\\>") nil t)
+	   (unless (re-search-forward (concat "^entity[ \t\n\r\f]+" ent-name "[ \t\n\r\f]+is\\>") nil t)
 	     (error "ERROR:  Entity not found: \"%s\"" ent-name))
 	   (goto-char (match-beginning 0))
 	   (if (and (save-excursion
@@ -15505,8 +15932,8 @@ component instantiation."
   (interactive)
   (save-excursion
     (vhdl-prepare-search-2
-     (unless (or (re-search-backward "^architecture[ \t\n]+\\w+[ \t\n]+of[ \t\n]+\\(\\w+\\)[ \t\n]+is\\>" nil t)
-		 (re-search-forward "^architecture[ \t\n]+\\w+[ \t\n]+of[ \t\n]+\\(\\w+\\)[ \t\n]+is\\>" nil t))
+     (unless (or (re-search-backward "^architecture[ \t\n\r\f]+\\w+[ \t\n\r\f]+of[ \t\n\r\f]+\\(\\w+\\)[ \t\n\r\f]+is\\>" nil t)
+		 (re-search-forward "^architecture[ \t\n\r\f]+\\w+[ \t\n\r\f]+of[ \t\n\r\f]+\\(\\w+\\)[ \t\n\r\f]+is\\>" nil t))
        (error "ERROR:  No architecture found"))
      (let* ((ent-name (match-string 1))
 	    (ent-file-name
@@ -15532,11 +15959,11 @@ component instantiation."
        ;; process all instances
        (goto-char arch-stat-pos)
        (while (re-search-forward
-	       (concat "^[ \t]*\\(\\w+\\)[ \t\n]*:[ \t\n]*\\("
-		       "\\(component[ \t\n]+\\)?\\(\\w+\\)"
-		       "[ \t\n]+\\(--[^\n]*\n[ \t\n]*\\)*\\(\\(generic\\)\\|port\\)[ \t\n]+map\\|"
-		       "\\(\\(entity\\)\\|configuration\\)[ \t\n]+\\(\\(\\w+\\)\\.\\)?\\(\\w+\\)\\([ \t\n]*(\\(\\w+\\))\\)?"
-		       "[ \t\n]+\\(--[^\n]*\n[ \t\n]*\\)*\\(\\(generic\\)\\|port\\)[ \t\n]+map\\)[ \t\n]*(") arch-end-pos t)
+	       (concat "^[ \t]*\\(\\w+\\)[ \t\n\r\f]*:[ \t\n\r\f]*\\("
+		       "\\(component[ \t\n\r\f]+\\)?\\(\\w+\\)"
+		       "[ \t\n\r\f]+\\(--[^\n]*\n[ \t\n\r\f]*\\)*\\(\\(generic\\)\\|port\\)[ \t\n\r\f]+map\\|"
+		       "\\(\\(entity\\)\\|configuration\\)[ \t\n\r\f]+\\(\\(\\w+\\)\\.\\)?\\(\\w+\\)\\([ \t\n\r\f]*(\\(\\w+\\))\\)?"
+		       "[ \t\n\r\f]+\\(--[^\n]*\n[ \t\n\r\f]*\\)*\\(\\(generic\\)\\|port\\)[ \t\n\r\f]+map\\)[ \t\n\r\f]*(") arch-end-pos t)
 	 (setq inst-name (match-string-no-properties 1)
 	       comp-name (match-string-no-properties 4)
 	       comp-ent-name (match-string-no-properties 12)
@@ -15548,7 +15975,7 @@ component instantiation."
 	      (when vhdl-use-components-package pack-file-name) t
 	      (save-excursion
 		(goto-char (point-min))
-		(unless (re-search-forward (concat "^\\s-*component[ \t\n]+" comp-name "\\>") nil t)
+		(unless (re-search-forward (concat "^\\s-*component[ \t\n\r\f]+" comp-name "\\>") nil t)
 		  (error "ERROR:  Component declaration not found: \"%s\"" comp-name))
 		(vhdl-port-copy)))
 	   ;; ... from entity declaration (direct instantiation)
@@ -15559,7 +15986,7 @@ component instantiation."
 	    comp-ent-file-name t
 	    (save-excursion
 	      (goto-char (point-min))
-	      (unless (re-search-forward (concat "^\\s-*entity[ \t\n]+" comp-ent-name "\\>") nil t)
+	      (unless (re-search-forward (concat "^\\s-*entity[ \t\n\r\f]+" comp-ent-name "\\>") nil t)
 		(error "ERROR:  Entity declaration not found: \"%s\"" comp-ent-name))
 	      (vhdl-port-copy))))
 	 (vhdl-port-flatten t)
@@ -15571,7 +15998,7 @@ component instantiation."
 	 (when has-generic
 	   ;; process all constants in generic map
 	   (vhdl-forward-syntactic-ws)
-	   (while (vhdl-parse-string "\\(\\(\\w+\\)[ \t\n]*=>[ \t\n]*\\)?\\(\\w+\\),?" t)
+	   (while (vhdl-parse-string "\\(\\(\\w+\\)[ \t\n\r\f]*=>[ \t\n\r\f]*\\)?\\(\\w+\\),?" t)
 	     (setq constant-name (match-string-no-properties 3))
 	     (setq constant-entry
 		   (cons constant-name
@@ -15589,10 +16016,10 @@ component instantiation."
 	     (unless (match-string 1)
 	       (setq generic-alist (cdr generic-alist)))
 	     (vhdl-forward-syntactic-ws))
-	   (vhdl-re-search-forward "\\<port\\s-+map[ \t\n]*(" nil t))
+	   (vhdl-re-search-forward "\\<port\\s-+map[ \t\n\r\f]*(" nil t))
 	 ;; process all signals in port map
 	 (vhdl-forward-syntactic-ws)
-	 (while (vhdl-parse-string "\\(\\(\\w+\\)[ \t\n]*=>[ \t\n]*\\)?\\(\\w+\\),?" t)
+	 (while (vhdl-parse-string "\\(\\(\\w+\\)[ \t\n\r\f]*=>[ \t\n\r\f]*\\)?\\(\\w+\\),?" t)
 	   (setq signal-name (match-string-no-properties 3))
 	   (setq signal-entry (cons signal-name
 				    (if (match-string 1)
@@ -15638,7 +16065,7 @@ component instantiation."
        ;; prepare signal insertion
        (vhdl-goto-marker arch-decl-pos)
        (forward-line 1)
-       (re-search-forward "^\\s-*-- Internal signal declarations[ \t\n]*-*\n" arch-stat-pos t)
+       (re-search-forward "^\\s-*-- Internal signal declarations[ \t\n\r\f]*-*\n" arch-stat-pos t)
        (setq signal-pos (point-marker))
        (while (progn (vhdl-forward-syntactic-ws)
 		     (looking-at "signal\\>"))
@@ -15649,10 +16076,10 @@ component instantiation."
        (when (file-exists-p ent-file-name)
 	 (find-file ent-file-name))
        (goto-char (point-min))
-       (unless (re-search-forward (concat "^entity[ \t\n]+" ent-name "[ \t\n]+is\\>") nil t)
+       (unless (re-search-forward (concat "^entity[ \t\n\r\f]+" ent-name "[ \t\n\r\f]+is\\>") nil t)
 	 (error "ERROR:  Entity not found: \"%s\"" ent-name))
        ;; prepare generic clause insertion
-       (unless (and (re-search-forward "\\(^\\s-*generic[ \t\n]*(\\)\\|^end\\>" nil t)
+       (unless (and (re-search-forward "\\(^\\s-*generic[ \t\n\r\f]*(\\)\\|^end\\>" nil t)
 		    (match-string 1))
 	 (goto-char (match-beginning 0))
 	 (indent-to vhdl-basic-offset)
@@ -15670,7 +16097,7 @@ component instantiation."
        (setq generic-beg-pos (point-marker) generic-pos (point-marker)
 	     generic-inst-pos (point-marker) generic-end-pos (point-marker))
        ;; prepare port clause insertion
-       (unless (and (re-search-forward "\\(^\\s-*port[ \t\n]*(\\)\\|^end\\>" nil t)
+       (unless (and (re-search-forward "\\(^\\s-*port[ \t\n\r\f]*(\\)\\|^end\\>" nil t)
 		    (match-string 1))
 	 (goto-char (match-beginning 0))
 	 (indent-to vhdl-basic-offset)
@@ -15894,7 +16321,8 @@ current project/directory."
     (message "Generating components package \"%s\"...done\n  File created: \"%s\""
 	     pack-name pack-file-name)))
 
-(defun vhdl-compose-configuration-architecture (ent-name arch-name inst-alist
+(defun vhdl-compose-configuration-architecture (ent-name arch-name ent-alist
+							 conf-alist inst-alist
 							 &optional insert-conf)
   "Generate block configuration for architecture."
   (let ((margin (current-indentation))
@@ -15970,7 +16398,7 @@ current project/directory."
 		       (nth 3 ent-entry))
 	      (indent-to (+ margin vhdl-basic-offset))
 	      (vhdl-compose-configuration-architecture
-	       (nth 0 ent-entry) arch-name
+	       (nth 0 ent-entry) arch-name ent-alist conf-alist
 	       (nth 3 (aget (nth 3 ent-entry) (downcase arch-name) t))))))
 	;; insert component configuration end
 	(indent-to margin)
@@ -16052,7 +16480,8 @@ current project/directory."
      (vhdl-insert-keyword " IS\n")
      (indent-to vhdl-basic-offset)
      ;; insert block configuration (for architecture)
-     (vhdl-compose-configuration-architecture ent-name arch-name inst-alist t)
+     (vhdl-compose-configuration-architecture
+      ent-name arch-name ent-alist conf-alist inst-alist t)
      (vhdl-insert-keyword "END ") (insert conf-name ";")
      (when conf-file-name
        ;; insert footer and save
@@ -16072,6 +16501,9 @@ current project/directory."
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;; (using `compile.el')
 
+(defvar vhdl-compile-post-command ""
+  "String appended to compile command after file name.")
+
 (defun vhdl-makefile-name ()
   "Return the Makefile name of the current project or the current compiler if
 no project is defined."
@@ -16226,9 +16658,11 @@ do not print any file names."
 	 (compiler (or (aget vhdl-compiler-alist vhdl-compiler nil)
 		       (error "ERROR:  No such compiler: \"%s\"" vhdl-compiler)))
 	 (command (nth 0 compiler))
-	 (file-name (buffer-file-name))
-	 (options (vhdl-get-compile-options project compiler file-name))
 	 (default-directory (vhdl-compile-directory))
+	 (file-name (if vhdl-compile-absolute-path
+			(buffer-file-name)
+		      (file-relative-name (buffer-file-name))))
+	 (options (vhdl-get-compile-options project compiler file-name))
 	 compilation-process-setup-function)
     (unless (file-directory-p default-directory)
       (error "ERROR:  Compile directory does not exist: \"%s\"" default-directory))
@@ -16236,14 +16670,18 @@ do not print any file names."
     (when (string-match " " file-name)
       (setq file-name (concat "\"" file-name "\"")))
     ;; print out file name if compiler does not
-    (setq vhdl-compile-file-name (buffer-file-name))
+    (setq vhdl-compile-file-name (if vhdl-compile-absolute-path
+				     (buffer-file-name)
+				   (file-relative-name (buffer-file-name))))
     (when (and (= 0 (nth 1 (nth 10 compiler)))
 	       (= 0 (nth 1 (nth 11 compiler))))
       (setq compilation-process-setup-function 'vhdl-compile-print-file-name))
     ;; run compilation
     (if options
 	(when command
-	  (compile (concat command " " options " " file-name)))
+	  (compile (concat command " " options " " file-name
+			   (unless (equal vhdl-compile-post-command "")
+			     (concat " " vhdl-compile-post-command)))))
       (vhdl-warning "Your project settings tell me not to compile this file"))))
 
 (defvar vhdl-make-target "all"
@@ -16551,6 +16989,8 @@ specified by a target."
       (insert "\n\n# Define compilation command and options\n"
 	      "\nCOMPILE = " (nth 0 compiler)
 	      "\nOPTIONS = " (vhdl-get-compile-options project compiler nil)
+	      (if (equal vhdl-compile-post-command "") ""
+		(concat "\nPOST-COMPILE = " vhdl-compile-post-command))
 	      "\n")
       ;; insert library paths
       (setq library-directory
@@ -16580,16 +17020,16 @@ specified by a target."
       (setq unit-list tmp-list)
       ;; insert `make all' rule
       (insert "\n\n\n# Rule for compiling entire design\n"
-	      "\nall :"
-	      " \\\n\t\tlibrary"
+	      "\n" (nth 0 vhdl-makefile-default-targets) " :"
+	      " \\\n\t\t" (nth 2 vhdl-makefile-default-targets)
 	      " \\\n\t\t$(ALL_UNITS)\n")
       ;; insert `make clean' rule
       (insert "\n\n# Rule for cleaning entire design\n"
-	      "\nclean : "
+	      "\n" (nth 1 vhdl-makefile-default-targets) " : "
 	      "\n\t-rm -f $(ALL_UNITS)\n")
       ;; insert `make library' rule
       (insert "\n\n# Rule for creating library directory\n"
-	      "\nlibrary :"
+	      "\n" (nth 2 vhdl-makefile-default-targets) " :"
 	      " \\\n\t\t$(LIBRARY-" work-library ")\n"
 	      "\n$(LIBRARY-" work-library ") :"
 	      "\n\t"
@@ -16597,6 +17037,11 @@ specified by a target."
 	       (cons "\\(.*\\)\n\\(.*\\)" (nth 5 compiler))
 	       (concat "$(LIBRARY-" work-library ")\n" (vhdl-work-library)))
 	      "\n")
+      ;; insert '.PHONY' declaration
+      (insert "\n\n.PHONY : "
+	      (nth 0 vhdl-makefile-default-targets) " "
+	      (nth 1 vhdl-makefile-default-targets) " "
+	      (nth 2 vhdl-makefile-default-targets) "\n")
       ;; insert rule for each library unit
       (insert "\n\n# Rules for compiling single library units and their subhierarchy\n")
       (while prim-list
@@ -16611,7 +17056,7 @@ specified by a target."
 	(unless (equal unit-key unit-name)
 	  (insert " \\\n" unit-name))
 	(insert " :"
-		" \\\n\t\tlibrary"
+		" \\\n\t\t" (nth 2 vhdl-makefile-default-targets)
 		" \\\n\t\t$(UNIT-" work-library "-" unit-key ")")
 	(while second-list
 	  (insert " \\\n\t\t$(UNIT-" work-library "-" (car second-list) ")")
@@ -16653,7 +17098,9 @@ specified by a target."
 	(if options
 	    (insert "\n\t$(COMPILE) "
 		    (if (eq options 'default) "$(OPTIONS)" options) " "
-		    (nth 0 rule) "\n")
+		    (nth 0 rule)
+		    (if (equal vhdl-compile-post-command "") ""
+		      " $(POST-COMPILE)") "\n")
 	  (setq tmp-list target-list)
 	  (while target-list
 	    (insert "\n\t@touch $(UNIT-" work-library "-" (car target-list) ")"
@@ -16712,6 +17159,7 @@ specified by a target."
        'vhdl-compiler-alist
        'vhdl-compiler
        'vhdl-compile-use-local-error-regexp
+       'vhdl-makefile-default-targets
        'vhdl-makefile-generation-hook
        'vhdl-default-library
        'vhdl-standard
@@ -16722,6 +17170,7 @@ specified by a target."
        'vhdl-upper-case-enum-values
        'vhdl-upper-case-constants
        'vhdl-use-direct-instantiation
+       'vhdl-array-index-record-field-in-sensitivity-list
        'vhdl-compose-configuration-name
        'vhdl-entity-file-name
        'vhdl-architecture-file-name
@@ -16812,6 +17261,7 @@ specified by a target."
        'vhdl-print-customize-faces
        'vhdl-intelligent-tab
        'vhdl-indent-syntax-based
+       'vhdl-indent-comment-like-next-code-line
        'vhdl-word-completion-case-sensitive
        'vhdl-word-completion-in-minibuffer
        'vhdl-underscore-is-part-of-word
@@ -16851,6 +17301,17 @@ CONFIGURATION DECLARATION GENERATION:
     (See documentation (`C-c C-h') in section on STRUCTURAL COMPOSITION.)
 
 
+Key Bindings
+------------
+
+For Emacs compliance the following key bindings have been changed:
+
+- `C-c c'        ->  `C-c C-c'      `vhdl-comment-uncomment-region'
+- `C-c f'        ->  `C-c C-i C-f'  `vhdl-fontify-buffer'
+- `C-c s'        ->  `C-c C-i C-s'  `vhdl-statistics-buffer'
+- `C-c C-c ...'  ->  `C-c C-m ...'  `vhdl-compose-...'
+
+
 User Options
 ------------
 
@@ -16864,6 +17325,12 @@ User Options
   Specify whether hierarchical configurations should be created.
 `vhdl-compose-configuration-use-subconfiguration': (new)
   Specify whether subconfigurations should be used inside configurations.
+`vhdl-makefile-default-targets': (new)
+  Customize names of Makefile default targets.
+`vhdl-indent-comment-like-next-code-line': (new)
+  Specify whether comment lines are indented like following code line.
+`vhdl-array-index-record-field-in-sensitivity-list': (new)
+  Specify whether to include array indices / record fields in sensitivity list.
 ")
 
 
@@ -16872,19 +17339,20 @@ User Options
 Reserved words in VHDL
 ----------------------
 
-VHDL'93 (IEEE Std 1076-1993):
-  `vhdl-93-keywords'      : keywords
-  `vhdl-93-types'         : standardized types
-  `vhdl-93-attributes'    : standardized attributes
-  `vhdl-93-enum-values'   : standardized enumeration values
-  `vhdl-93-functions'     : standardized functions
-  `vhdl-93-packages'      : standardized packages and libraries
+VHDL'93/02 (IEEE Std 1076-1993/2002):
+  `vhdl-02-keywords'      : keywords
+  `vhdl-02-types'         : standardized types
+  `vhdl-02-attributes'    : standardized attributes
+  `vhdl-02-enum-values'   : standardized enumeration values
+  `vhdl-02-functions'     : standardized functions
+  `vhdl-02-packages'      : standardized packages and libraries
 
-VHDL-AMS (IEEE Std 1076.1):
+VHDL-AMS (IEEE Std 1076.1 / 1076.1.1):
   `vhdl-ams-keywords'     : keywords
   `vhdl-ams-types'        : standardized types
   `vhdl-ams-attributes'   : standardized attributes
   `vhdl-ams-enum-values'  : standardized enumeration values
+  `vhdl-ams-constants'    : standardized constants
   `vhdl-ams-functions'    : standardized functions
 
 Math Packages (IEEE Std 1076.2):
diff --git a/lisp/progmodes/which-func.el b/lisp/progmodes/which-func.el
index d57a3128a16..d5c8a1c6792 100644
--- a/lisp/progmodes/which-func.el
+++ b/lisp/progmodes/which-func.el
@@ -68,7 +68,7 @@
   "String to display in the mode line when current function is unknown.")
 
 (defgroup which-func nil
-  "Display the current function name in the modeline."
+  "Display the current function name in the mode line."
   :group 'tools
   :version "20.3")
 
@@ -163,7 +163,7 @@ single string, the new name of the item.")
 (defvar which-func-cleanup-function nil
   "Function to transform a string before displaying it in the mode line.
 The function is called with one argument, the string to display.
-Its return value is displayed in the modeline.
+Its return value is displayed in the mode line.
 If nil, no function is called.  The default value is nil.
 
 This feature can be useful if Imenu is set up to make more
@@ -209,7 +209,8 @@ It creates the Imenu index for the buffer, if necessary."
 	  (setq imenu--index-alist
 		(save-excursion (funcall imenu-create-index-function))))
     (error
-     (unless (equal err '(error "This buffer cannot use `imenu-default-create-index-function'"))
+     (unless (equal err
+                    '(user-error "This buffer cannot use `imenu-default-create-index-function'"))
        (message "which-func-ff-hook error: %S" err))
      (setq which-func-mode nil))))
 
@@ -336,6 +337,22 @@ If no function name is found, return nil."
 	  (funcall which-func-cleanup-function name)
 	name))))
 
+
+;;; Integration with other packages
+
+(defun which-func-update-ediff-windows ()
+  "Update Which-Function mode display for Ediff windows.
+This function is meant to be called from `ediff-select-hook'."
+  (when (eq major-mode 'ediff-mode)
+    (when ediff-window-A
+      (which-func-update-1 ediff-window-A))
+    (when ediff-window-B
+      (which-func-update-1 ediff-window-B))
+    (when ediff-window-C
+      (which-func-update-1 ediff-window-C))))
+
+(add-hook 'ediff-select-hook 'which-func-update-ediff-windows)
+
 (provide 'which-func)
 
 ;;; which-func.el ends here
diff --git a/lisp/progmodes/xscheme.el b/lisp/progmodes/xscheme.el
index f9d83da1a3a..52ebdfbdcdf 100644
--- a/lisp/progmodes/xscheme.el
+++ b/lisp/progmodes/xscheme.el
@@ -74,7 +74,7 @@ by the scheme process, so additional control-g's are to be ignored.")
 
 (defconst default-xscheme-runlight
   '(": " xscheme-runlight-string)
-  "Default global (shared) xscheme-runlight modeline format.")
+  "Default global (shared) xscheme-runlight mode line format.")
 
 (defvar xscheme-runlight "")
 (defvar xscheme-runlight-string nil)
@@ -326,7 +326,7 @@ buffer is not visible at that time, the value will also be displayed
 in the minibuffer.  If an error occurs, the process buffer will
 automatically pop up to show you the error message.
 
-While the Scheme process is running, the modelines of all buffers in
+While the Scheme process is running, the mode lines of all buffers in
 scheme-mode are modified to show the state of the process.  The
 possible states and their meanings are:
 
@@ -334,7 +334,7 @@ input		waiting for input
 run		evaluating
 gc		garbage collecting
 
-The process buffer's modeline contains additional information where
+The process buffer's mode line contains additional information where
 the buffer's name is normally displayed: the command interpreter level
 and type.
 
@@ -404,7 +404,7 @@ with no args, if that value is non-nil.
                         (cons (process-filter process)
                               (process-sentinel process)))
 		  (xscheme-process-filter-initialize t)
-		  (xscheme-modeline-initialize xscheme-buffer-name)
+		  (xscheme-mode-line-initialize xscheme-buffer-name)
 		  (set-process-sentinel process 'xscheme-process-sentinel)
 		  (set-process-filter process 'xscheme-process-filter))
                 (setq xscheme-previous-process-state (cons nil nil)))))))
@@ -817,7 +817,7 @@ Control returns to the top level rep loop."
 			    xscheme-buffer-name)
 		   (set-marker (process-mark process) (point-max))
 		   (xscheme-process-filter-initialize t)
-		   (xscheme-modeline-initialize xscheme-buffer-name)
+		   (xscheme-mode-line-initialize xscheme-buffer-name)
 		   (set-process-sentinel process 'xscheme-process-sentinel)
 		   (set-process-filter process 'xscheme-process-filter)
 		   (run-hooks 'xscheme-start-hook)))))
@@ -951,7 +951,7 @@ the remaining input.")
   (if running-p
       (let ((name (buffer-name (current-buffer))))
 	(setq scheme-mode-line-process '(": " xscheme-runlight-string))
-	(xscheme-modeline-initialize name)
+	(xscheme-mode-line-initialize name)
 	(if (equal name (default-value 'xscheme-buffer-name))
 	    (setq-default xscheme-runlight default-xscheme-runlight))))
   (if (or (eq xscheme-runlight default-xscheme-runlight)
@@ -1059,7 +1059,7 @@ the remaining input.")
     (set-buffer (process-buffer process))
     (goto-char (process-mark process))))
 
-(defun xscheme-modeline-initialize (name)
+(defun xscheme-mode-line-initialize (name)
   (setq xscheme-runlight-string "")
   (if (equal name (default-value 'xscheme-buffer-name))
       (setq-default xscheme-runlight-string ""))