(setq alist alist-cdr)))))

(defun vhdl-aget (alist key)

(cdr (assoc key alist)))

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

(defvar vhdl-sources-menu nil)

(defun vhdl-directory-files (directory &optional full match)

(if (not (file-directory-p directory))

(vhdl-warning-when-idle "No such directory: \"%s\"" directory)

(let ((dir (directory-files directory full match)))

`vhdl-project-alist'.

As an alternative to the speedbar, an index menu can be added (set

option `vhdl-index-menu' to non-nil) or made accessible as a mouse menu

(e.g. add \"(global-set-key [S-down-mouse-3] \\='imenu)\" to your start-up

(save-excursion (re-search-forward "\\\\" (vhdl-point 'eol) t)))))

(defun vhdl-forward-comment (&optional direction)

(interactive "p")

(if (and direction (< direction 0))

;; skip backwards

;; Functions to help finding the correct indentation column:

(defun vhdl-first-word (point)

(save-excursion

(and (goto-char point)

(eq (point) (vhdl-point 'boi))

(current-column))))

(defun vhdl-last-word (point)

(save-excursion

(and (goto-char point)

(save-excursion (or (eq (progn (forward-sexp) (point))

(defconst vhdl-begin-fwd-re

"\\b\\(is\\|begin\\|block\\|component\\|generate\\|then\\|else\\|loop\\|process\\|procedural\\(\\s-+body\\)?\\|units\\|use\\|record\\|protected\\(\\s-+body\\)?\\|for\\)\\b\\([^_]\\|\\'\\)"

(defconst vhdl-begin-bwd-re

"\\b\\(is\\|begin\\|block\\|component\\|generate\\|then\\|else\\|loop\\|process\\|procedural\\(\\s-+body\\)?\\|units\\|use\\|record\\|protected\\(\\s-+body\\)?\\|for\\)\\b[^_]"

(defun vhdl-begin-p (&optional lim)

"Return t if we are looking at a real \"begin\" keyword.

(defconst vhdl-statement-fwd-re

"\\b\\(if\\|for\\|while\\|loop\\)\\b\\([^_]\\|\\'\\)"

(defconst vhdl-statement-bwd-re

"\\b\\(if\\|for\\|while\\|loop\\)\\b[^_]"

(defun vhdl-statement-p (&optional _lim)

"Return t if we are looking at a real \"statement\" keyword.

vhdl-begin-bwd-re "\\|" vhdl-statement-bwd-re))

(defun vhdl-beginning-of-statement-1 (&optional lim)

(let ((lim (or lim (point-min)))

(here (point))

(pos (point))

))

(defun vhdl-get-block-state (&optional lim)

LIM is the furthest back we need to search (it should be the

previous libunit keyword)."

(let ((here (point))

(concat vhdl-case-alternative-re "\\|" vhdl-case-header-key))

(defun vhdl-skip-case-alternative (&optional lim)

(let ((lim (or lim (point-max)))

(here (point))

donep foundp)

foundp))

(defun vhdl-backward-skip-label (&optional lim)

(let ((lim (or lim (point-min)))

placeholder)

(if (save-excursion

))

(defun vhdl-forward-skip-label (&optional lim)

(let ((lim (or lim (point-max))))

(if (looking-at vhdl-label-key)

(progn

(- ce-curcol cs-curcol -1))))

(defun vhdl-lineup-comment (_langelem)

(save-excursion

(back-to-indentation)

;; at or to the right of comment-column

(setq this-command 'vhdl-electric-tab)))

(defun vhdl-electric-return ()

character is a space."

(interactive)

(if (and (= (preceding-char) ? ) (vhdl-in-comment-p))

(newline-and-indent)))

(defun vhdl-indent-line ()

(interactive)

(let* ((syntax (and vhdl-indent-syntax-based (vhdl-get-syntactic-context)))

(pos (- (point-max) (point)))

;; Align code

(defvar vhdl-align-try-all-clauses t

(defun vhdl-do-group (function &optional spacing)

"Apply FUNCTION on group of lines between empty lines."

(funcall function beg end spacing)))

(defun vhdl-do-list (function &optional spacing)

(let (beg end)

(save-excursion

;; search for beginning of balanced group of parentheses

(funcall function beg end spacing)))

(defun vhdl-align-region-1 (begin end &optional spacing alignment-list _indent)

(interactive "r\np")

(setq alignment-list (or alignment-list vhdl-align-alist))

(setq spacing (or spacing 1))

(setq copy (cdr copy))))))))

(defun vhdl-align-region-2 (begin end match &optional substr spacing)

(setq spacing (or spacing 1))

(setq substr (or substr 1))

(save-excursion

(beginning-of-line 2))))))

(defun vhdl-align-inline-comment-region (beg end &optional spacing no-message)

(interactive "r\nP")

(save-excursion

(let (orig pos)

(message "Aligning inline comments...done"))))

(defun vhdl-align-inline-comment-buffer ()

(interactive)

(vhdl-align-inline-comment-region (point-min) (point-max)))

;; Fixup whitespace

(defun vhdl-fixup-whitespace-region (beg end &optional no-message)

(interactive "r")

(unless no-message (message "Fixing up whitespace..."))

(save-excursion

(unless no-message (message "Fixing up whitespace...done")))

(defun vhdl-fixup-whitespace-buffer ()

(interactive)

(vhdl-fixup-whitespace-region (point-min) (point-max)))

reset))

(defun vhdl-template-standard-package (library package)

(let ((margin (current-indentation)))

(unless (equal library "std")

(unless (or (save-excursion

;; Help functions

(defun vhdl-electric-space (count)

if in comment and past end-comment-column."

(interactive "p")

(cond ((vhdl-in-comment-p)

string)))

(defun vhdl-paste-group-comment (string indent)

(let ((pos (point-marker)))

(when (> indent 0)

(while (string-match "^\\(--\\)" string)

"Regexp to match start of construct to hide.")

(defun vhdl-hs-forward-sexp-func (count)

(let ((pos (point)))

(vhdl-prepare-search-2

(beginning-of-line)

(goto-char end))))))

(defun vhdl-font-lock-match-item (limit)

`font-lock-match-c-style-declaration-item-and-skip-to-next'."

(condition-case nil

(save-restriction

;; Variables

(defvar vhdl-entity-alist nil

;; structure: (parenthesized expression means list of such entries)

;; (cache-key

;; (ent-key ent-name ent-file ent-line

(setq project-alist (cdr project-alist)))))

(defun vhdl-speedbar-insert-project-hierarchy (project indent &optional rescan)

otherwise use cached data."

(when (or rescan (and (not (assoc project vhdl-file-alist))

(not (vhdl-load-cache project))))

(vhdl-speedbar-expand-units project))

(defun vhdl-speedbar-insert-dir-hierarchy (directory depth &optional rescan)

otherwise use cached data."

(when (or rescan (and (not (assoc directory vhdl-file-alist))

(not (vhdl-load-cache directory))))

(declare-function speedbar-goto-this-file "speedbar" (file))

(defun vhdl-speedbar-expand-dirs (_directory)

;; (nicked from `speedbar-default-directory-list')

(let ((sf (cdr (reverse speedbar-shown-directories)))

(vhdl-speedbar-update-current-unit nil))

(declare-function speedbar-line-text "speedbar" (&optional p))

(defun vhdl-speedbar-line-text ()

(let ((string (speedbar-line-text)))

(set-text-properties 0 (length string) nil string)

string))

(or project-options compiler-options)))

(defun vhdl-compile ()

(interactive)

(vhdl-compile-init)

(let* ((project (vhdl-aget vhdl-project-alist vhdl-project))

`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)

(defconst vhdl-doc-keywords nil