>From 6da0b3ed7d1794bc640326c6f46cb27ca0275b08 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?R=C3=BCdiger=20Sonderfeld?= Date: Wed, 23 May 2012 14:28:00 +0200 Subject: [PATCH 1/2] progmodes/vhdl-mode.el: Backported changes from 3.33. MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit To: address@hidden See http://www.iis.ee.ethz.ch/~zimmi/emacs/vhdl-mode.html#release-notes-3.33 Among the changes are * Support for ghdl (free vhdl compiler). Now default * Add/update support for VHDL-AMS packages. * Update to VHDL'02 standard ... I tried to be very careful not to overwrite any non-upstream changes that were made to vhdl-mode. Signed-off-by: Rüdiger Sonderfeld --- lisp/progmodes/vhdl-mode.el | 1303 +++++++++++++++++++++++++++++-------------- 1 file changed, 893 insertions(+), 410 deletions(-) diff --git a/lisp/progmodes/vhdl-mode.el b/lisp/progmodes/vhdl-mode.el index 9b7ee5d..27215de 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." @@ -197,6 +197,21 @@ Examples: "Customizations for modes." :group 'vhdl) +(defcustom vhdl-electric-mode t + "Non-nil enables electrification (automatic template generation). +If nil, template generators can still be invoked through key bindings and +menu. Is indicated in the modeline by \"/e\" after the mode name and can be +toggled by `\\[vhdl-electric-mode]'." + :type 'boolean + :group 'vhdl-mode) + +(defcustom vhdl-stutter-mode t + "Non-nil enables stuttering. +Is indicated in the modeline by \"/s\" after the mode name and can be toggled +by `\\[vhdl-stutter-mode]'." + :type 'boolean + :group 'vhdl-mode) + (defcustom vhdl-indent-tabs-mode nil "Non-nil means indentation can insert tabs. Overrides local variable `indent-tabs-mode'." @@ -210,6 +225,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"." "" 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 +251,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 +268,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 +354,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 +467,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 +489,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 +697,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 +710,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 +780,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 +974,8 @@ if the header needs to be version controlled. The following keywords for template generation are supported: : replaced by the name of the buffer : 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') + : replaced by the user full name (`user-full-name') : replaced by user login name (`user-login-name') : replaced by contents of option `vhdl-company-name' : replaced by the current date @@ -999,11 +1058,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 +1623,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 +1656,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 +1858,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 +1905,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 +1914,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 +3352,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 +3362,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 +3510,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 +3543,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 +3611,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 +3625,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 +3678,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 +3778,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 +4071,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 +4118,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_\\)+\\)" @@ -4193,8 +4302,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 +4326,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 +4341,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 +4473,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 +4499,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 +4549,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 +4601,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 +4677,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 +4753,17 @@ releases. You are kindly invited to participate in beta testing. Subscribe to above mailing lists by sending an email to . 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 +4886,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 +4901,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 +4911,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 +4944,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 +4952,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 +5027,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 +5038,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 +5047,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 +5057,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 +5098,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 +5126,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 +5178,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 +5193,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 +5251,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 +5304,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 +5532,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 +5553,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 +5566,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 +5754,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 +5794,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 +5832,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 +5874,7 @@ keyword." (cond ((looking-at "is\\|block\\|generate\\|process\\|procedural") "begin") - ((looking-at "then") + ((looking-at "then\\|use") "") (t "end"))) @@ -5648,6 +5889,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 "\\")) + (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 +5914,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 +5927,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 +5974,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 +6049,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 +6096,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 +6115,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 +6152,9 @@ contain a \"when\" keyword." (cond ;; "begin" keyword: ((and (looking-at vhdl-begin-fwd-re) + (or (not (looking-at "\\")) + (save-excursion (back-to-indentation) + (looking-at "\\(\\w+\\s-*:\\s-*\\)?\\<\\(case\\|elsif\\|if\\)\\>"))) (/= (preceding-char) ?_) (vhdl-begin-p lim)) (setq foundp 'begin)) @@ -5931,7 +6178,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 +6254,10 @@ searches." nil (backward-sexp) (if (and (looking-at vhdl-begin-fwd-re) + (or (not (looking-at "\\")) + (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 +6529,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 +6550,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 +6570,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 "\\")) + (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 +6831,10 @@ is not moved." (setq begin-after-ip (and (not literal) (looking-at vhdl-begin-fwd-re) + (or (not (looking-at "\\")) + (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 +6883,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 +6922,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 +6994,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 +7155,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 +7164,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 +7265,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 +7276,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 +7284,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 +7301,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 +7318,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 +7333,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 +7346,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 +7409,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 +7475,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 +7560,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 +7581,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 +7743,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 +7768,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 +7876,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 +7915,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 +7937,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 +8018,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 +8033,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 +8042,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 + "\\(\\(\\\\)\\|^\\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 "\\" proc-end t)) @@ -7780,19 +8082,19 @@ buffer." ;; case expression ((re-search-forward "^\\s-*case\\>" proc-end t) (re-search-forward "\\" 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 "\\" 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 +8127,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 +8183,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 + "\\" 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 +8212,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+\\)[^;]*\\")) - (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 +9582,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 +9914,13 @@ otherwise." (in-arglist (vhdl-in-argument-list-p))) (vhdl-prepare-search-2 (if (or (save-excursion - (and (vhdl-re-search-backward - "\\" - nil t) - (not (progn (backward-word 1) (looking-at "\\"))))) + (progn (vhdl-beginning-of-block) + (looking-at "\\s-*\\(\\w+\\s-*:\\s-*\\)?\\<\\(\\"))) (save-excursion (backward-word 1) (looking-at "\\"))) (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 +10017,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 +10034,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 +10043,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") "")) (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 +10068,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 +10092,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 +10143,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 +10271,9 @@ specification, if not already there." (insert (user-full-name)) (when user-mail-address (insert " <" user-mail-address ">"))) (goto-char beg) + (while (search-forward "" end t) + (replace-match (user-full-name) t t)) + (goto-char beg) (while (search-forward "" end t) (replace-match (user-login-name) t t)) (goto-char beg) @@ -9915,7 +10289,7 @@ specification, if not already there." (while (search-forward "" 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 +10395,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 +10459,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 +10494,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 +10698,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 +10744,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 +10832,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 "\\\\|\\(;\\)" 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 "\\\\|\\(;\\)" 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 "\\\\|\\(;\\)" 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 "\\\\|\\(;\\)" 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 +10897,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 +10921,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 +11202,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 +11303,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 +11335,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 +11369,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 +11403,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 +11705,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 +11846,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 +11892,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 +12012,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 +12043,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 +12114,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 +12128,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 +12164,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 +12194,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 +12422,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 +12454,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 +12471,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 +12498,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 +12615,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 +12631,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 +12828,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 +12852,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 +12862,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 +13023,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 +13034,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 +13076,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 +13100,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 +13305,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 +13314,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 +13506,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 +13580,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 +13597,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 +13623,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 +13635,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 "\\" 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 +13690,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 +13726,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 +13740,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\\)\\>[^;:]+\\\\|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 +13789,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 +13802,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 +15787,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 +15804,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 +15831,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 +15876,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 +15895,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 +15913,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 +15928,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 +15947,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 +15974,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 +15990,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 +16001,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 +16013,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 +16031,10 @@ component instantiation." (unless (match-string 1) (setq generic-alist (cdr generic-alist))) (vhdl-forward-syntactic-ws)) - (vhdl-re-search-forward "\\[ \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 +16080,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 +16091,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 +16112,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 +16336,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 +16413,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 +16495,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 +16516,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 +16673,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 +16685,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 +17004,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 +17035,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 +17052,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 +17071,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 +17113,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 "address@hidden $(UNIT-" work-library "-" (car target-list) ")" @@ -16712,6 +17174,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 +17185,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 +17276,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 +17316,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 +17340,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 +17354,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): -- 1.7.10