;;; vhdl-mode.el --- major mode for editing VHDL code
-;; Copyright (C) 1992-2014 Free Software Foundation, Inc.
+;; Copyright (C) 1992-2015 Free Software Foundation, Inc.
;; Authors: Reto Zimmermann <reto@gnu.org>
;; Rodney J. Whitby <software.vhdl-mode@rwhitby.net>
;; filed in the Emacs bug reporting system against this file, a copy
;; of the bug report be sent to the maintainer's email address.
-(defconst vhdl-version "3.36.1"
+(defconst vhdl-version "3.37.1"
"VHDL Mode version number.")
-(defconst vhdl-time-stamp "2014-11-27"
+(defconst vhdl-time-stamp "2015-01-15"
"VHDL Mode time stamp for last update.")
;; This file is part of GNU Emacs.
;; - Block commenting
;; - Code fixing/alignment/beautification
;; - PostScript printing
-;; - VHDL'87/'93 and VHDL-AMS supported
+;; - VHDL'87/'93/'02/'08 and VHDL-AMS supported
;; - Comprehensive menu
;; - Fully customizable
;; - Works under GNU Emacs (recommended) and XEmacs
'/' or is empty)."
(let ((val (widget-value widget)))
(unless (string-match "^\\(\\|.*/\\)$" val)
- (widget-put widget :error "Invalid directory entry: must end with '/'")
+ (widget-put widget :error "Invalid directory entry: must end with ‘/’")
widget)))
;; help string for user options
Basic standard:
VHDL'87 : IEEE Std 1076-1987
VHDL'93/02 : IEEE Std 1076-1993/2002
+ VHDL'08 : IEEE Std 1076-2008
Additional standards:
VHDL-AMS : IEEE Std 1076.1 (analog-mixed-signal)
Math packages: IEEE Std 1076.2 (`math_real', `math_complex')
\"Activate Options\"."
:type '(list (choice :tag "Basic standard"
(const :tag "VHDL'87" 87)
- (const :tag "VHDL'93/02" 93))
+ (const :tag "VHDL'93/02" 93)
+ (const :tag "VHDL'08" 08))
(set :tag "Additional standards" :indent 2
(const :tag "VHDL-AMS" ams)
(const :tag "Math packages" math)))
:type 'boolean
:group 'vhdl-template)
+(defcustom vhdl-sensitivity-list-all t
+ "Non-nil means use 'all' keyword in sensitivity list."
+ :version "25.1"
+ :type 'boolean
+ :group 'vhdl-template)
+
(defcustom vhdl-zero-string "'0'"
"String to use for a logic zero."
:type 'string
'vhdl-words-init 'vhdl-font-lock-init))
:group 'vhdl-highlight)
-(defcustom vhdl-directive-keywords '("pragma" "synopsys")
+(defcustom vhdl-directive-keywords '("psl" "pragma" "synopsys")
"List of compiler directive keywords recognized for highlighting.
NOTE: Activate the new setting in a VHDL buffer by re-fontifying it (menu
(package . 0)
(architecture . 0)
(package-body . 0)
+ (context . 0)
+ (directive . 0)
)
"Default settings for offsets of syntactic elements.
Do not change this constant! See the variable `vhdl-offsets-alist' for
configuration -- inside a configuration declaration
package -- inside a package declaration
architecture -- inside an architecture body
- package-body -- inside a package body")
+ package-body -- inside a package body
+ context -- inside a context declaration")
(defvar vhdl-comment-only-line-offset 0
"Extra offset for line which contains only the start of a comment.
(defun vhdl-warning-when-idle (&rest args)
"Wait until idle, then print out warning STRING and beep."
- (if noninteractive
- (vhdl-warning (apply 'format args) t)
- (unless vhdl-warnings
- (vhdl-run-when-idle .1 nil 'vhdl-print-warnings))
- (push (apply 'format args) vhdl-warnings)))
+ (let ((message (apply #'format-message args)))
+ (if noninteractive
+ (vhdl-warning message t)
+ (unless vhdl-warnings
+ (vhdl-run-when-idle .1 nil 'vhdl-print-warnings))
+ (push message vhdl-warnings))))
(defun vhdl-warning (string &optional nobeep)
"Print out warning STRING and beep."
(defmacro vhdl-prepare-search-2 (&rest body)
"Enable case insensitive search, switch to syntax table that includes '_',
-and remove `intangible' overlays, then execute BODY, and finally restore the
-old environment. Used for consistent searching."
- ;; FIXME: Why not just let-bind `inhibit-point-motion-hooks'? --Stef
+arrange to ignore `intangible' overlays, then execute BODY, and finally restore
+the old environment. Used for consistent searching."
`(let ((case-fold-search t) ; case insensitive search
(current-syntax-table (syntax-table))
- overlay-all-list overlay-intangible-list overlay)
+ (inhibit-point-motion-hooks t))
;; use extended syntax table
(set-syntax-table vhdl-mode-ext-syntax-table)
- ;; remove `intangible' overlays
- (when (fboundp 'overlay-lists)
- (setq overlay-all-list (overlay-lists))
- (setq overlay-all-list
- (append (car overlay-all-list) (cdr overlay-all-list)))
- (while overlay-all-list
- (setq overlay (car overlay-all-list))
- (when (memq 'intangible (overlay-properties overlay))
- (setq overlay-intangible-list
- (cons overlay overlay-intangible-list))
- (overlay-put overlay 'intangible nil))
- (setq overlay-all-list (cdr overlay-all-list))))
;; execute BODY safely
(unwind-protect
(progn ,@body)
;; restore syntax table
- (set-syntax-table current-syntax-table)
- ;; restore `intangible' overlays
- (when (fboundp 'overlay-lists)
- (while overlay-intangible-list
- (overlay-put (car overlay-intangible-list) 'intangible t)
- (setq overlay-intangible-list
- (cdr overlay-intangible-list)))))))
+ (set-syntax-table current-syntax-table))))
(defmacro vhdl-visit-file (file-name issue-error &rest body)
"Visit file FILE-NAME and execute BODY."
(define-key vhdl-template-map "Cd" 'vhdl-template-configuration-decl)
(define-key vhdl-template-map "Cs" 'vhdl-template-configuration-spec)
(define-key vhdl-template-map "co" 'vhdl-template-constant)
+ (define-key vhdl-template-map "ct" 'vhdl-template-context)
(define-key vhdl-template-map "di" 'vhdl-template-disconnect)
(define-key vhdl-template-map "el" 'vhdl-template-else)
(define-key vhdl-template-map "ei" 'vhdl-template-elsif)
(modify-syntax-entry ?\* "." st)
(modify-syntax-entry ?\+ "." st)
(modify-syntax-entry ?\. "." st)
- (modify-syntax-entry ?\/ "." st)
+;;; (modify-syntax-entry ?\/ "." st)
(modify-syntax-entry ?\: "." st)
(modify-syntax-entry ?\; "." st)
(modify-syntax-entry ?\< "." st)
(modify-syntax-entry ?\" "\"" st)
;; define underscore
(modify-syntax-entry ?\_ (if vhdl-underscore-is-part-of-word "w" "_") st)
- ;; a single hyphen is punctuation, but a double hyphen starts a comment
- (modify-syntax-entry ?\- ". 12" st)
- ;; and \n and \^M end a comment
- (modify-syntax-entry ?\n ">" st)
- (modify-syntax-entry ?\^M ">" st)
+ ;; single-line comments
+ (modify-syntax-entry ?\- ". 12b" st)
+ ;; multi-line comments
+ (modify-syntax-entry ?\/ ". 14b" st)
+ (modify-syntax-entry ?* ". 23" st)
+ (modify-syntax-entry ?\n "> b" st)
+ (modify-syntax-entry ?\^M "> b" st)
;; define parentheses to match
(modify-syntax-entry ?\( "()" st)
(modify-syntax-entry ?\) ")(" st)
("configuration" . vhdl-template-configuration-hook)
("cons" . vhdl-template-constant-hook)
("constant" . vhdl-template-constant-hook)
+ ("context" . vhdl-template-context-hook)
("disconnect" . vhdl-template-disconnect-hook)
("downto" . vhdl-template-default-hook)
("else" . vhdl-template-else-hook)
("configuration declaration" vhdl-template-configuration-decl)
("configuration specification" vhdl-template-configuration-spec)
("constant declaration" vhdl-template-constant)
+ ("context declaration" vhdl-template-context)
("disconnection specification" vhdl-template-disconnect)
("entity declaration" vhdl-template-entity)
("exit statement" vhdl-template-exit)
["Configuration (Decl)" vhdl-template-configuration-decl t]
["Configuration (Spec)" vhdl-template-configuration-spec t]
["Constant" vhdl-template-constant t]
+ ["Context" vhdl-template-context t]
["Disconnect" vhdl-template-disconnect t]
["Else" vhdl-template-else t]
["Elsif" vhdl-template-elsif t]
(list '93 (cadr vhdl-standard)))
(vhdl-activate-customizations))
:style radio :selected (eq '93 (car vhdl-standard))]
+ ["VHDL'08"
+ (progn (customize-set-variable 'vhdl-standard
+ (list '08 (cadr vhdl-standard)))
+ (vhdl-activate-customizations))
+ :style radio :selected (eq '08 (car vhdl-standard))]
"--"
["VHDL-AMS"
(progn (customize-set-variable
(customize-set-variable 'vhdl-conditions-in-parenthesis
(not vhdl-conditions-in-parenthesis))
:style toggle :selected vhdl-conditions-in-parenthesis]
+ ["Sensitivity List uses 'all'"
+ (customize-set-variable 'vhdl-sensitivity-list-all
+ (not vhdl-sensitivity-list-all))
+ :style toggle :selected vhdl-sensitivity-list-all]
["Zero String..." (customize-option 'vhdl-zero-string) t]
["One String..." (customize-option 'vhdl-one-string) t]
("File Header"
("Entity"
"^\\s-*\\(entity\\)\\s-+\\(\\(\\w\\|\\s_\\)+\\)"
2)
+ ("Context"
+ "^\\s-*\\(context\\)\\s-+\\(\\(\\w\\|\\s_\\)+\\)"
+ 2)
)
"Imenu generic expression for VHDL Mode. See `imenu-generic-expression'.")
according to option `vhdl-argument-list-indent'.
If option `vhdl-indent-tabs-mode' is nil, spaces are used instead of
- tabs. `M-x tabify' and `M-x untabify' allow to convert spaces to tabs
+ tabs. `\\[tabify]' and `\\[untabify]' allow to convert spaces to tabs
and vice versa.
Syntax-based indentation can be very slow in large files. Option
VHDL STANDARDS:
The VHDL standards to be used are specified in option `vhdl-standard'.
- Available standards are: VHDL'87/'93(02), VHDL-AMS, and Math Packages.
+ Available standards are: VHDL'87/'93(02)/'08, VHDL-AMS, and Math Packages.
KEYWORD CASE:
`vhdl-highlight-translate-off' is non-nil.
For documentation and customization of the used colors see
- customization group `vhdl-highlight-faces' (`M-x customize-group'). For
+ customization group `vhdl-highlight-faces' (`\\[customize-group]'). For
highlighting of matching parenthesis, see customization group
`paren-showing'. Automatic buffer highlighting is turned on/off by
option `global-font-lock-mode' (`font-lock-auto-fontify' in XEmacs).
sessions using the \"Save Options\" menu entry.
Options and their detailed descriptions can also be accessed by using
- the \"Customize\" menu entry or the command `M-x customize-option' (`M-x
- customize-group' for groups). Some customizations only take effect
+ the \"Customize\" menu entry or the command `\\[customize-option]'
+ (`\\[customize-group]' for groups). Some customizations only take effect
after some action (read the NOTE in the option documentation).
Customization can also be done globally (i.e. site-wide, read the
INSTALL file).
Not all options are described in this documentation, so go and see
- what other useful user options there are (`M-x vhdl-customize' or menu)!
+ what other useful user options there are (`\\[vhdl-customize]' or menu)!
FILE EXTENSIONS:
Maintenance:
------------
-To submit a bug report, enter `M-x vhdl-submit-bug-report' within VHDL Mode.
+To submit a bug report, enter `\\[vhdl-submit-bug-report]' within VHDL Mode.
Add a description of the problem and include a reproducible test case.
Questions and enhancement requests can be sent to <reto@gnu.org>.
)
"List of VHDL'02 keywords.")
+(defconst vhdl-08-keywords
+ '(
+ "context" "force" "property" "release" "sequence"
+ )
+ "List of VHDL'08 keywords.")
+
(defconst vhdl-ams-keywords
'(
"across" "break" "limit" "nature" "noise" "procedural" "quantity"
)
"List of VHDL'02 standardized types.")
+(defconst vhdl-08-types
+ '(
+ "boolean_vector" "integer_vector" "real_vector" "time_vector"
+ )
+ "List of VHDL'08 standardized types.")
+
(defconst vhdl-ams-types
;; standards: IEEE Std 1076.1-2007, IEEE Std 1076.1.1-2004
'(
)
"List of VHDL'02 standardized attributes.")
+(defconst vhdl-08-attributes
+ '(
+ "instance_name" "path_name"
+ )
+ "List of VHDL'08 standardized attributes.")
+
(defconst vhdl-ams-attributes
'(
"across" "through"
)
"List of VHDL'02 standardized functions.")
+(defconst vhdl-08-functions
+ '(
+ "finish" "flush" "justify" "maximum" "minimum"
+ "resolution_limit" "rising_edge" "stop" "swrite"
+ "tee" "to_binarystring" "to_bstring" "to_hexstring" "to_hstring"
+ "to_octalstring" "to_ostring" "to_string"
+ )
+ "List of VHDL'08 standardized functions.")
+
(defconst vhdl-ams-functions
'(
;; package `standard'
)
"List of VHDL'02 standardized packages and libraries.")
+(defconst vhdl-08-packages
+ '(
+ "env" "numeric_std_signed" "numeric_std_unsigned"
+ "ieee_bit_context" "ieee_std_context" ;; contexts
+ )
+ "List of VHDL'08 standardized packages and libraries.")
+
(defconst vhdl-ams-packages
'(
"fundamental_constants" "material_constants" "energy_systems"
)
"List of Math Packages standardized packages and libraries.")
+(defconst vhdl-08-directives
+ '(
+ "author" "author_info" "begin" "begin_protected" "comment"
+ "data_block" "data_keyname" "data_keyowner" "data_method"
+ "decrypt_license" "digest_block" "digest_key_method" "digest_keyname"
+ "digest_keyowner" "digest_method"
+ "encoding" "encrypt_agent" "encrypt_agent_info" "end" "end_protected"
+ "key_block" "key_keyname" "key_keyowner" "key_method"
+ "runtime_license" "viewport"
+ )
+ "List of VHDL'08 standardized tool directives.")
+
(defvar vhdl-keywords nil
"List of VHDL keywords.")
(defvar vhdl-packages nil
"List of VHDL standardized packages and libraries.")
+(defvar vhdl-directives nil
+ "List of VHDL standardized packages and libraries.")
+
(defvar vhdl-reserved-words nil
"List of additional reserved words.")
(vhdl-upcase-list
(and vhdl-highlight-case-sensitive vhdl-upper-case-keywords)
(append vhdl-02-keywords
+ (when (vhdl-standard-p '08) vhdl-08-keywords)
(when (vhdl-standard-p 'ams) vhdl-ams-keywords))))
(setq vhdl-types
(vhdl-upcase-list
(and vhdl-highlight-case-sensitive vhdl-upper-case-types)
(append vhdl-02-types
+ (when (vhdl-standard-p '08) vhdl-08-types)
(when (vhdl-standard-p 'ams) vhdl-ams-types)
(when (vhdl-standard-p 'math) vhdl-math-types))))
(setq vhdl-attributes
(vhdl-upcase-list
(and vhdl-highlight-case-sensitive vhdl-upper-case-attributes)
(append vhdl-02-attributes
+ (when (vhdl-standard-p '08) vhdl-08-attributes)
(when (vhdl-standard-p 'ams) vhdl-ams-attributes))))
(setq vhdl-enum-values
(vhdl-upcase-list
'(""))))
(setq vhdl-functions
(append vhdl-02-functions
+ (when (vhdl-standard-p '08) vhdl-08-functions)
(when (vhdl-standard-p 'ams) vhdl-ams-functions)
(when (vhdl-standard-p 'math) vhdl-math-functions)))
(setq vhdl-packages
(append vhdl-02-packages
+ (when (vhdl-standard-p '08) vhdl-08-packages)
(when (vhdl-standard-p 'ams) vhdl-ams-packages)
(when (vhdl-standard-p 'math) vhdl-math-packages)))
+ (setq vhdl-directives
+ (append (when (vhdl-standard-p '08) vhdl-08-directives)))
(setq vhdl-reserved-words
(append (when vhdl-highlight-forbidden-words vhdl-forbidden-words)
(when vhdl-highlight-verilog-keywords vhdl-verilog-keywords)
(list vhdl-upper-case-enum-values) vhdl-enum-values
(list vhdl-upper-case-constants) vhdl-constants
(list nil) vhdl-functions
- (list nil) vhdl-packages)))
+ (list nil) vhdl-packages
+ (list nil) vhdl-directives)))
;; initialize reserved words for VHDL Mode
(vhdl-words-init)
;; Syntactic support functions:
-(defun vhdl-in-comment-p ()
- "Check if point is in a comment."
- (eq (vhdl-in-literal) 'comment))
+(defun vhdl-in-comment-p (&optional pos)
+ "Check if point is in a comment (include multi-line comments)."
+ (let ((parse (lambda (p)
+ (let ((c (char-after p)))
+ (or (and c (eq (char-syntax c) ?<))
+ (nth 4 (parse-partial-sexp
+ (save-excursion
+ (beginning-of-defun)
+ (point)) p)))))))
+ (save-excursion
+ (goto-char (or pos (point)))
+ (or (funcall parse (point))
+ ;; `parse-partial-sexp's notion of comments doesn't span lines
+ (progn
+ (back-to-indentation)
+ (unless (eolp)
+ (forward-char)
+ (funcall parse (point))))))))
(defun vhdl-in-string-p ()
"Check if point is in a string."
((nth 3 state) 'string)
((nth 4 state) 'comment)
((vhdl-beginning-of-macro) 'pound)
+ ((vhdl-beginning-of-directive) 'directive)
+ ;; for multi-line comments
+ ((and (vhdl-standard-p '08) (vhdl-in-comment-p)) 'comment)
(t nil)))))
(defun vhdl-in-extended-identifier-p ()
- "Determine if point is inside extended identifier (delimited by '\')."
+ "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)))))
(goto-char lim )
(while (< (point) here)
(setq match
- (and (re-search-forward "--\\|[\"']"
+ (and (re-search-forward "--\\|[\"']\\|`"
here 'move)
(buffer-substring (match-beginning 0) (match-end 0))))
(setq state
;; looking at the opening of a VHDL style comment
((string= "--" match)
(if (<= here (progn (end-of-line) (point))) 'comment))
+ ;; looking at a directive
+ ((string= "`" match)
+ (if (<= here (progn (end-of-line) (point))) 'directive))
;; looking at the opening of a double quote string
((string= "\"" match)
(if (not (save-restriction
(setq here (point))
(vhdl-forward-comment hugenum)
;; skip preprocessor directives
- (when (and (eq (char-after) ?#)
+ (when (and (or (eq (char-after) ?#) (eq (char-after) ?`))
(= (vhdl-point 'boi) (point)))
(while (and (eq (char-before (vhdl-point 'eol)) ?\\)
(= (forward-line 1) 0)))
(goto-char here)
nil)))
+(defun vhdl-beginning-of-directive (&optional lim)
+ "Go to the beginning of a directive (nicked from `cc-engine')."
+ (let ((here (point)))
+ (beginning-of-line)
+ (while (eq (char-before (1- (point))) ?\\)
+ (forward-line -1))
+ (back-to-indentation)
+ (if (and (<= (point) here)
+ (eq (char-after) ?`))
+ t
+ (goto-char here)
+ nil)))
+
(defun vhdl-backward-syntactic-ws (&optional lim)
"Backward skip over syntactic whitespace."
(let* ((here (point-min))
;; Core syntactic evaluation functions:
(defconst vhdl-libunit-re
- "\\b\\(architecture\\|configuration\\|entity\\|package\\)\\b[^_]")
+ "\\b\\(architecture\\|configuration\\|context\\|entity\\|package\\)\\b[^_]")
(defun vhdl-libunit-p ()
(and
))
(defconst vhdl-defun-re
- "\\b\\(architecture\\|block\\|configuration\\|entity\\|package\\|process\\|procedural\\|procedure\\|function\\)\\b[^_]")
+ "\\b\\(architecture\\|block\\|configuration\\|context\\|entity\\|package\\|process\\|procedural\\|procedure\\|function\\)\\b[^_]")
(defun vhdl-defun-p ()
(save-excursion
(save-excursion
(backward-sexp)
(not (looking-at "end\\s-+\\w")))
- ;; "architecture", "configuration", "entity",
+ ;; "architecture", "configuration", "context", "entity",
;; "package", "procedure", "function":
t)))
(if (looking-at "block\\|process\\|procedural")
;; "block", "process". "procedural:
(buffer-substring (match-beginning 0) (match-end 0))
- ;; "architecture", "configuration", "entity", "package",
+ ;; "architecture", "configuration", "context", "entity", "package",
;; "procedure", "function":
"is"))))
the middle of an identifier that just happens to contain a \"begin\"
keyword."
(cond
- ;; "[architecture|case|configuration|entity|package|
+ ;; "[architecture|case|configuration|context|entity|package|
;; procedure|function] ... is":
((and (looking-at "i")
(save-excursion
(let (foundp)
(while (and (not foundp)
(re-search-backward
- ";\\|\\b\\(architecture\\|case\\|configuration\\|entity\\|package\\|procedure\\|return\\|is\\|begin\\|process\\|procedural\\|block\\)\\b[^_]"
+ ";\\|\\b\\(architecture\\|case\\|configuration\\|context\\|entity\\|package\\|procedure\\|return\\|is\\|begin\\|process\\|procedural\\|block\\)\\b[^_]"
lim 'move))
(if (or (= (preceding-char) ?_)
(vhdl-in-literal))
(vector "for" (vhdl-first-word pos) nil nil))
;; "end [id]":
(t
- (vector "begin\\|architecture\\|configuration\\|entity\\|package\\|procedure\\|function"
+ (vector "begin\\|architecture\\|configuration\\|context\\|entity\\|package\\|procedure\\|function"
(vhdl-first-word pos)
;; return an alist of (statement . keyword) mappings
'(
("architecture" . "is")
;; "configuration ... is ... end [id]":
("configuration" . "is")
+ ;; "context ... is ... end [id]":
+ ("context" . "is")
;; "entity ... is ... end [id]":
("entity" . "is")
;; "package ... is ... end [id]":
(cond
((looking-at "e") 'entity)
((looking-at "a") 'architecture)
- ((looking-at "c") 'configuration)
+ ((looking-at "conf") 'configuration)
+ ((looking-at "cont") 'context)
((looking-at "p")
(save-excursion
(goto-char bod)
(goto-char (1+ containing-sexp))
(skip-chars-forward " \t")
(not (eolp))
- (not (looking-at "--")))
+ (not (looking-at "--\\|`")))
(save-excursion
(vhdl-beginning-of-statement-1 containing-sexp)
(skip-chars-backward " \t(")
;; now we need to look at any modifiers
(goto-char indent-point)
(skip-chars-forward " \t")
- (if (looking-at "--")
+ (if (or (looking-at "--") (looking-at "/\\*"))
(vhdl-add-syntax 'comment))
+ (if (looking-at "`")
+ (vhdl-add-syntax 'directive))
(if (eq literal 'pound)
(vhdl-add-syntax 'cpp-macro))
;; return the syntax
(vhdl-comment-indent)
;; otherwise, indent as specified by vhdl-comment-only-line-offset
(if (not (bolp))
+ ;; inside multi-line comment
+ (if (looking-at "\\*")
+ 1
+ ;; otherwise
(or (car-safe vhdl-comment-only-line-offset)
- vhdl-comment-only-line-offset)
+ vhdl-comment-only-line-offset))
(or (cdr-safe vhdl-comment-only-line-offset)
(car-safe vhdl-comment-only-line-offset)
-1000 ;jam it against the left side
(- (nth 1 (current-time)) (aref vhdl-progress-info 2))))
(let ((delta (- (aref vhdl-progress-info 1)
(aref vhdl-progress-info 0))))
- (if (= 0 delta)
- (message (concat string "... (100%s)") "%")
- (message (concat string "... (%2d%s)")
- (/ (* 100 (- pos (aref vhdl-progress-info 0)))
- delta) "%")))
+ (message "%s... (%2d%%)" string
+ (if (= 0 delta)
+ 100
+ (floor (* 100.0 (- pos (aref vhdl-progress-info 0)))
+ delta))))
(aset vhdl-progress-info 2 (nth 1 (current-time)))))
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(mapc
(function
(lambda (elt)
- (if (memq (car elt) '(entity configuration package
+ (if (memq (car elt) '(entity configuration context package
package-body architecture))
nil
(setq expurgated (append expurgated (list elt))))))
(vhdl-prepare-search-2
(save-excursion
;; search for declarative part
- (when (and (re-search-backward "^\\(architecture\\|begin\\|configuration\\|end\\|entity\\|package\\)\\>" nil t)
+ (when (and (re-search-backward "^\\(architecture\\|begin\\|configuration\\|context\\|end\\|entity\\|package\\)\\>" nil t)
(not (member (upcase (match-string 1)) '("BEGIN" "END"))))
(setq beg (point))
(re-search-forward "^\\(begin\\|end\\)\\>" nil t)
(setq end (save-excursion (goto-char end) (point-marker)))
(save-excursion ; remove DOS EOL characters in UNIX file
(goto-char beg)
- (while (search-forward "\r" nil t)
+ (while (search-forward "\r" nil t)
(replace-match "" nil t)))
(when (nth 0 vhdl-beautify-options) (vhdl-fixup-whitespace-region beg end t))
(when (nth 1 vhdl-beautify-options) (vhdl-fix-statement-region beg end))
(let ((next-input (read-char)))
(if (= next-input ?-) ; four dashes
(vhdl-comment-display t)
- (setq unread-command-events ; pushback the char
- (list (vhdl-character-to-event next-input))))))
- (setq unread-command-events ; pushback the char
- (list (vhdl-character-to-event next-input)))
+ (push (vhdl-character-to-event next-input)
+ ; pushback the char
+ unread-command-events))))
+ (push (vhdl-character-to-event next-input) ; pushback the char
+ unread-command-events)
(vhdl-comment-insert)))))
(self-insert-command count)))
-(defun vhdl-electric-open-bracket (count) "'[' --> '(', '([' --> '['"
+(defun vhdl-electric-open-bracket (count) "‘[’ --> ‘(’, ‘([’ --> ‘[’"
(interactive "p")
(if (and vhdl-stutter-mode (= count 1) (not (vhdl-in-literal)))
(if (= (preceding-char) ?\()
(insert-char ?\( 1))
(self-insert-command count)))
-(defun vhdl-electric-close-bracket (count) "']' --> ')', ')]' --> ']'"
+(defun vhdl-electric-close-bracket (count) "‘]’ --> ‘)’, ‘)]’ --> ‘]’"
(interactive "p")
(if (and vhdl-stutter-mode (= count 1) (not (vhdl-in-literal)))
(progn
(blink-matching-open))
(self-insert-command count)))
-(defun vhdl-electric-quote (count) "'' --> \""
+(defun vhdl-electric-quote (count) "\\='\\=' --> \""
(interactive "p")
(if (and vhdl-stutter-mode (= count 1) (not (vhdl-in-literal)))
(if (= (preceding-char) vhdl-last-input-event)
(insert-char ?\' 1))
(self-insert-command count)))
-(defun vhdl-electric-semicolon (count) "';;' --> ' : ', ': ;' --> ' := '"
+(defun vhdl-electric-semicolon (count) "‘;;’ --> ‘ : ’, ‘: ;’ --> ‘ := ’"
(interactive "p")
(if (and vhdl-stutter-mode (= count 1) (not (vhdl-in-literal)))
(cond ((= (preceding-char) vhdl-last-input-event)
(t (insert-char ?\; 1)))
(self-insert-command count)))
-(defun vhdl-electric-comma (count) "',,' --> ' <= '"
+(defun vhdl-electric-comma (count) "‘,,’ --> ‘ <= ’"
(interactive "p")
(if (and vhdl-stutter-mode (= count 1) (not (vhdl-in-literal)))
(cond ((= (preceding-char) vhdl-last-input-event)
(t (insert-char ?\, 1)))
(self-insert-command count)))
-(defun vhdl-electric-period (count) "'..' --> ' => '"
+(defun vhdl-electric-period (count) "‘..’ --> ‘ => ’"
(interactive "p")
(if (and vhdl-stutter-mode (= count 1) (not (vhdl-in-literal)))
(cond ((= (preceding-char) vhdl-last-input-event)
(t (insert-char ?\. 1)))
(self-insert-command count)))
-(defun vhdl-electric-equal (count) "'==' --> ' == '"
+(defun vhdl-electric-equal (count) "‘==’ --> ‘ == ’"
(interactive "p")
(if (and vhdl-stutter-mode (= count 1) (not (vhdl-in-literal)))
(cond ((= (preceding-char) vhdl-last-input-event)
(insert ";")
(vhdl-comment-insert-inline))))))
+(defun vhdl-template-context ()
+ "Insert a context declaration."
+ (interactive)
+ (let ((margin (current-indentation))
+ (start (point))
+ entity-exists string name position)
+ (vhdl-insert-keyword "CONTEXT ")
+ (when (setq name (vhdl-template-field "name" nil t start (point)))
+ (vhdl-insert-keyword " IS\n")
+ (when (memq vhdl-insert-empty-lines '(unit all)) (insert "\n"))
+ (indent-to (+ margin vhdl-basic-offset))
+ (setq position (point))
+ (insert "\n")
+ (when (memq vhdl-insert-empty-lines '(unit all)) (insert "\n"))
+ (indent-to margin)
+ (vhdl-insert-keyword "END ")
+ (unless (vhdl-standard-p '87)
+ (vhdl-insert-keyword "CONTEXT "))
+ (insert name ";")
+ (goto-char position))))
+
(defun vhdl-template-default ()
"Insert nothing."
(interactive)
(forward-char 1))
(insert "(")
(if (not seq)
- (unless (setq input-signals
- (vhdl-template-field "[sensitivity list]" ")" t))
+ (unless (or (and (vhdl-standard-p '08) vhdl-sensitivity-list-all
+ (progn (insert "all)") (setq input-signals "all")))
+ (setq input-signals
+ (vhdl-template-field "[sensitivity list]" ")" t)))
(setq input-signals "")
(delete-char -2))
(setq clock (or (and (not (equal "" vhdl-clock-name))
(while (search-forward "<standard>" end t)
(replace-match
(concat "VHDL" (cond ((vhdl-standard-p '87) "'87")
- ((vhdl-standard-p '93) "'93/02"))
+ ((vhdl-standard-p '93) "'93/02")
+ ((vhdl-standard-p '08) "'08"))
(when (vhdl-standard-p 'ams) ", VHDL-AMS")
(when (vhdl-standard-p 'math) ", Math Packages")) t t))
(goto-char beg)
(setq code t))
(unless code
(insert "--")) ; hardwire to 1 space or use vhdl-basic-offset?
- (setq unread-command-events
- (list (vhdl-character-to-event next-input)))))) ; pushback the char
+ (push (vhdl-character-to-event next-input) ; pushback the char
+ unread-command-events))))
(defun vhdl-comment-display (&optional line-exists)
"Add 2 comment lines at the current indent, making a display comment."
(save-excursion
(beginning-of-line)
;; search backward for block beginning or end
- (while (or (while (and (setq pos (re-search-backward "^\\s-*\\(\\(end\\)\\|\\(\\(impure\\|pure\\)[ \t\n\r\f]+\\)?\\(function\\|procedure\\)\\|\\(for\\)\\|\\(architecture\\|component\\|configuration\\|entity\\|package\\(\\s-+body\\)?\\|type[ \t\n\r\f]+\\w+[ \t\n\r\f]+is[ \t\n\r\f]+\\(record\\|protected\\(\\s-+body\\)?\\)\\|units\\)\\|\\(\\w+[ \t\n\r\f]*:[ \t\n\r\f]*\\)?\\(postponed[ \t\n\r\f]+\\)?\\(block\\|case\\|for\\|if\\|procedural\\|process\\|while\\|loop\\)\\)\\>" nil t))
+ (while (or (while (and (setq pos (re-search-backward "^\\s-*\\(\\(end\\)\\|\\(\\(impure\\|pure\\)[ \t\n\r\f]+\\)?\\(function\\|procedure\\)\\|\\(for\\)\\|\\(architecture\\|component\\|configuration\\|context\\|entity\\|package\\(\\s-+body\\)?\\|type[ \t\n\r\f]+\\w+[ \t\n\r\f]+is[ \t\n\r\f]+\\(record\\|protected\\(\\s-+body\\)?\\)\\|units\\)\\|\\(\\w+[ \t\n\r\f]*:[ \t\n\r\f]*\\)?\\(postponed[ \t\n\r\f]+\\)?\\(block\\|case\\|for\\|if\\|procedural\\|process\\|while\\|loop\\)\\)\\>" nil t))
;; not consider subprogram declarations
(or (and (match-string 5)
(save-match-data
(save-excursion
(end-of-line)
;; search forward for block beginning or end
- (while (or (while (and (setq pos (re-search-forward "^\\s-*\\(\\(end\\)\\|\\(\\(impure\\|pure\\)[ \t\n\r\f]+\\)?\\(function\\|procedure\\)\\|\\(for\\)\\|\\(architecture\\|component\\|configuration\\|entity\\|package\\(\\s-+body\\)?\\|type[ \t\n\r\f]+\\w+[ \t\n\r\f]+is[ \t\n\r\f]+\\(record\\|protected\\(\\s-+body\\)?\\)\\|units\\)\\|\\(\\w+[ \t\n\r\f]*:[ \t\n\r\f]*\\)?\\(postponed[ \t\n\r\f]+\\)?\\(block\\|case\\|for\\|if\\|procedural\\|process\\|while\\|loop\\)\\)\\>" nil t))
+ (while (or (while (and (setq pos (re-search-forward "^\\s-*\\(\\(end\\)\\|\\(\\(impure\\|pure\\)[ \t\n\r\f]+\\)?\\(function\\|procedure\\)\\|\\(for\\)\\|\\(architecture\\|component\\|configuration\\|context\\|entity\\|package\\(\\s-+body\\)?\\|type[ \t\n\r\f]+\\w+[ \t\n\r\f]+is[ \t\n\r\f]+\\(record\\|protected\\(\\s-+body\\)?\\)\\|units\\)\\|\\(\\w+[ \t\n\r\f]*:[ \t\n\r\f]*\\)?\\(postponed[ \t\n\r\f]+\\)?\\(block\\|case\\|for\\|if\\|procedural\\|process\\|while\\|loop\\)\\)\\>" nil t))
;; not consider subprogram declarations
(or (and (match-string 5)
(save-match-data
;; delete CR which is still in event queue
(if (fboundp 'enqueue-eval-event)
(enqueue-eval-event 'delete-char -1)
- (setq unread-command-events ; push back a delete char
- (list (vhdl-character-to-event ?\177))))))))
+ (push (vhdl-character-to-event ?\177) ; push back a delete char
+ unread-command-events))))))
(defun vhdl-template-alias-hook ()
(vhdl-hooked-abbrev 'vhdl-template-alias))
(vhdl-hooked-abbrev 'vhdl-template-configuration))
(defun vhdl-template-constant-hook ()
(vhdl-hooked-abbrev 'vhdl-template-constant))
+(defun vhdl-template-context-hook ()
+ (vhdl-hooked-abbrev 'vhdl-template-context))
(defun vhdl-template-disconnect-hook ()
(vhdl-hooked-abbrev 'vhdl-template-disconnect))
(defun vhdl-template-display-comment-hook ()
(list
(concat
"^\\s-*\\("
- "architecture\\|configuration\\|entity\\|package\\(\\s-+body\\)?\\|"
+ "architecture\\|configuration\\|context\\|entity\\|package"
+ "\\(\\s-+body\\)?\\|"
"\\(\\(impure\\|pure\\)\\s-+\\)?function\\|procedure\\|component"
"\\)\\s-+\\(\\w+\\)")
5 'font-lock-function-name-face)
(list
(concat
"^\\s-*end\\s-+\\(\\("
- "architecture\\|block\\|case\\|component\\|configuration\\|entity\\|"
- "for\\|function\\|generate\\|if\\|loop\\|package\\(\\s-+body\\)?\\|"
- "procedure\\|\\(postponed\\s-+\\)?process\\|"
+ "architecture\\|block\\|case\\|component\\|configuration\\|context\\|"
+ "entity\\|for\\|function\\|generate\\|if\\|loop\\|package"
+ "\\(\\s-+body\\)?\\|procedure\\|\\(postponed\\s-+\\)?process\\|"
(when (vhdl-standard-p 'ams) "procedural\\|")
"units"
"\\)\\s-+\\)?\\(\\w*\\)")
;; highlight names in use clauses
(list
(concat
- "\\<use\\s-+\\(\\(entity\\|configuration\\)\\s-+\\)?"
+ "\\<\\(context\\|use\\)\\s-+\\(\\(entity\\|configuration\\)\\s-+\\)?"
"\\(\\w+\\)\\(\\.\\(\\w+\\)\\)?\\((\\(\\w+\\))\\)?")
- '(3 font-lock-function-name-face) '(5 font-lock-function-name-face nil t)
- '(7 font-lock-function-name-face nil t))
+ '(4 font-lock-function-name-face) '(6 font-lock-function-name-face nil t)
+ '(8 font-lock-function-name-face nil t))
;; highlight attribute name in attribute declarations/specifications
(list
'(vhdl-font-lock-match-item
(progn (goto-char (match-end 1)) (match-beginning 2))
nil (1 font-lock-variable-name-face)))
+
+ ;; highlight tool directives
+ (list
+ (concat
+ "^\\s-*\\(`\\w+\\)")
+ 1 'font-lock-preprocessor-face)
)
"For consideration as a value of `vhdl-font-lock-keywords'.
This does context sensitive highlighting of names and labels.")
"Return position of end of current unit."
(let ((pos (point)))
(save-excursion
- (while (and (re-search-forward "^[ \t]*\\(architecture\\|configuration\\|entity\\|package\\)\\>" nil 1)
+ (while (and (re-search-forward "^[ \t]*\\(architecture\\|configuration\\|context\\|entity\\|package\\)\\>" nil 1)
(save-excursion
(goto-char (match-beginning 0))
(vhdl-backward-syntactic-ws)
"Scan the context clause that precedes a design unit."
(let (lib-alist)
(save-excursion
- (when (re-search-backward "^[ \t]*\\(architecture\\|configuration\\|entity\\|package\\)\\>" nil t)
+ (when (re-search-backward "^[ \t]*\\(architecture\\|configuration\\|context\\|entity\\|package\\)\\>" nil t)
(while (and (re-search-backward "^[ \t]*\\(end\\|use\\)\\>" nil t)
(equal "USE" (upcase (match-string 1))))
(when (looking-at "^[ \t]*use[ \t\n\r\f]*\\(\\w+\\)\\.\\(\\w+\\)\\.\\w+")
;; do for all files
(while file-list
(unless noninteractive
- (message "Scanning %s %s\"%s\"... (%2d%s)"
+ (message "Scanning %s %s\"%s\"... (%2d%%)"
(if is-directory "directory" "files")
(or num-string "") name
- (/ (* 100 (- no-files (length file-list))) no-files) "%"))
+ (floor (* 100.0 (- no-files (length file-list))) no-files)))
(let ((file-name (abbreviate-file-name (car file-list)))
ent-list arch-list arch-ent-list conf-list
pack-list pack-body-list inst-list inst-ent-list)
'vhdl-argument-list-indent
'vhdl-association-list-with-formals
'vhdl-conditions-in-parenthesis
+ 'vhdl-sensitivity-list-all
'vhdl-zero-string
'vhdl-one-string
'vhdl-file-header
(defconst vhdl-doc-release-notes nil
"\
+Release Notes for VHDL Mode 3.37
+================================
+
+- Added support for VHDL'08:
+ - New keywords, types, functions, attributes, operators, packages
+ - Context declaration
+ - Block comments
+ - Directives
+ - 'all' keyword in sensitivity list
+
+
Release Notes for VHDL Mode 3.34
================================
Reserved words in VHDL
----------------------
+VHDL'08 (IEEE Std 1076-2008):
+ `vhdl-08-keywords' : keywords
+ `vhdl-08-types' : standardized types
+ `vhdl-08-attributes' : standardized attributes
+ `vhdl-08-functions' : standardized functions
+ `vhdl-08-packages' : standardized packages and libraries
+
VHDL'93/02 (IEEE Std 1076-1993/2002):
`vhdl-02-keywords' : keywords
`vhdl-02-types' : standardized types