|
72
|
1 ;;; vhdl-mode.el --- major mode for editing VHDL code
|
|
|
2
|
|
179
|
3 ;; Copyright (C) 1994 - 1997 Rodney J. Whitby
|
|
72
|
4 ;; Copyright (C) 1992, 1993, 1994 Barry A. Warsaw
|
|
|
5 ;; Copyright (C) 1992, 1993, 1994 Free Software Foundation, Inc.
|
|
|
6
|
|
179
|
7 ;; Author: Rodney J. Whitby <rwhitby@geocities.com>
|
|
|
8 ;; Maintainer: Rodney J. Whitby <rwhitby@geocities.com>
|
|
72
|
9 ;; Created: June 1994, adapted from cc-mode.el 4.29 by Barry A. Warsaw.
|
|
179
|
10 ;; Version: $Revision: 1.6 $
|
|
|
11 ;; Last Modified: $Date: 1997/08/01 03:27:57 $
|
|
72
|
12 ;; Keywords: languages VHDL
|
|
179
|
13 ;; Archive: http://www.geocities.com/SiliconValley/Park/8287/
|
|
72
|
14
|
|
|
15 ;; NOTE: Read the commentary below for the right way to submit bug reports!
|
|
|
16
|
|
|
17 ;; This file is not yet part of GNU Emacs.
|
|
|
18
|
|
|
19 ;; GNU Emacs is free software; you can redistribute it and/or modify
|
|
|
20 ;; it under the terms of the GNU General Public License as published by
|
|
|
21 ;; the Free Software Foundation; either version 2, or (at your option)
|
|
|
22 ;; any later version.
|
|
|
23
|
|
|
24 ;; GNU Emacs is distributed in the hope that it will be useful,
|
|
|
25 ;; but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
26 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
27 ;; GNU General Public License for more details.
|
|
|
28
|
|
|
29 ;; You should have received a copy of the GNU General Public License
|
|
|
30 ;; along with GNU Emacs; see the file COPYING. If not, write to
|
|
|
31 ;; the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
|
|
|
32
|
|
|
33 ;;; Commentary:
|
|
|
34
|
|
|
35 ;; This package provides indentation support for VHDL code.
|
|
|
36
|
|
179
|
37 ;; Details on VHDL-MODE are now contained in an accompanying texinfo
|
|
72
|
38 ;; manual (vhdl-mode.texi).
|
|
|
39
|
|
|
40 ;; To submit bug reports, hit "C-c C-b", and please try to include a
|
|
|
41 ;; code sample so I can reproduce your problem. If you have other
|
|
|
42 ;; questions contact me at the address listed at the top of this file.
|
|
|
43
|
|
|
44 ;; YOU CAN IGNORE ALL BYTE-COMPILER WARNINGS. They are the result of
|
|
|
45 ;; the multi-Emacsen support. FSF Emacs 19 and XEmacs 19 (formerly
|
|
|
46 ;; Lucid) do things differently and there's no way to shut the
|
|
|
47 ;; byte-compiler up at the necessary granularity. Let me say this
|
|
|
48 ;; again: YOU CAN IGNORE ALL BYTE-COMPILER WARNINGS (you'd be
|
|
|
49 ;; surprised at how many people don't follow this advice :-).
|
|
|
50
|
|
|
51 ;; To use VHDL-MODE, add the following to your .emacs file. This
|
|
|
52 ;; assumes you will use .vhd extensions for your VHDL source:
|
|
|
53 ;;
|
|
|
54 ;; (autoload 'vhdl-mode "vhdl-mode" "VHDL Editing Mode" t)
|
|
|
55 ;; (setq auto-mode-alist
|
|
|
56 ;; (append '(("\\.vhd$" . vhdl-mode) ; to edit VHDL code
|
|
|
57 ;; ) auto-mode-alist))
|
|
|
58 ;;
|
|
|
59 ;; If you would like to join the `vhdl-mode-announce' announcements
|
|
|
60 ;; list or the `vhdl-mode-victims' beta testers list, send add/drop
|
|
|
61 ;; requests to the address listed at the top of this file.
|
|
|
62 ;;
|
|
|
63 ;; Many, many thanks go out to all the folks on the beta test list.
|
|
|
64 ;; Without their patience, testing, insight, and code contributions,
|
|
|
65 ;; and encouragement vhdl-mode.el would be a far inferior package.
|
|
|
66
|
|
|
67 ;; LCD Archive Entry:
|
|
179
|
68 ;; vhdl-mode.el|Rodney J. Whitby|rwhitby@geocities.com
|
|
72
|
69 ;; |Major mode for editing VHDL code
|
|
179
|
70 ;; |$Date: 1997/08/01 03:27:57 $|$Revision: 1.6 $
|
|
|
71 ;; |http://www.geocities.com/SiliconValley/Park/8287/
|
|
72
|
72
|
|
|
73
|
|
|
74 ;;; Code:
|
|
|
75
|
|
|
76 ;; user definable variables
|
|
|
77 ;; vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv
|
|
|
78
|
|
|
79 (defvar vhdl-inhibit-startup-warnings-p nil
|
|
|
80 "*If non-nil, inhibits start up compatibility warnings.")
|
|
|
81 (defvar vhdl-strict-syntax-p nil
|
|
|
82 "*If non-nil, all syntactic symbols must be found in `vhdl-offsets-alist'.
|
|
|
83 If the syntactic symbol for a particular line does not match a symbol
|
|
|
84 in the offsets alist, an error is generated, otherwise no error is
|
|
|
85 reported and the syntactic symbol is ignored.")
|
|
|
86 (defvar vhdl-echo-syntactic-information-p nil
|
|
|
87 "*If non-nil, syntactic info is echoed when the line is indented.")
|
|
|
88 (defvar vhdl-basic-offset 2
|
|
|
89 "*Amount of basic offset used by + and - symbols in `vhdl-offsets-alist'.")
|
|
|
90
|
|
|
91 (defconst vhdl-offsets-alist-default
|
|
|
92 '((string . -1000)
|
|
|
93 (block-open . 0)
|
|
|
94 (block-close . 0)
|
|
|
95 (statement . 0)
|
|
|
96 (statement-cont . vhdl-lineup-statement-cont)
|
|
|
97 (statement-block-intro . +)
|
|
|
98 (statement-case-intro . +)
|
|
|
99 (case-alternative . +)
|
|
|
100 (comment . vhdl-lineup-comment)
|
|
|
101 (arglist-intro . vhdl-lineup-arglist-intro)
|
|
|
102 (arglist-cont . 0)
|
|
|
103 (arglist-cont-nonempty . vhdl-lineup-arglist)
|
|
|
104 (arglist-close . vhdl-lineup-arglist)
|
|
|
105 (entity . 0)
|
|
|
106 (configuration . 0)
|
|
|
107 (package . 0)
|
|
|
108 (architecture . 0)
|
|
|
109 (package-body . 0)
|
|
|
110 )
|
|
|
111 "Default settings for offsets of syntactic elements.
|
|
|
112 Do not change this constant! See the variable `vhdl-offsets-alist' for
|
|
|
113 more information.")
|
|
|
114
|
|
|
115 (defvar vhdl-offsets-alist (copy-alist vhdl-offsets-alist-default)
|
|
|
116 "*Association list of syntactic element symbols and indentation offsets.
|
|
|
117 As described below, each cons cell in this list has the form:
|
|
|
118
|
|
|
119 (SYNTACTIC-SYMBOL . OFFSET)
|
|
|
120
|
|
|
121 When a line is indented, vhdl-mode first determines the syntactic
|
|
|
122 context of the line by generating a list of symbols called syntactic
|
|
|
123 elements. This list can contain more than one syntactic element and
|
|
|
124 the global variable `vhdl-syntactic-context' contains the context list
|
|
|
125 for the line being indented. Each element in this list is actually a
|
|
|
126 cons cell of the syntactic symbol and a buffer position. This buffer
|
|
|
127 position is call the relative indent point for the line. Some
|
|
|
128 syntactic symbols may not have a relative indent point associated with
|
|
|
129 them.
|
|
|
130
|
|
|
131 After the syntactic context list for a line is generated, vhdl-mode
|
|
|
132 calculates the absolute indentation for the line by looking at each
|
|
|
133 syntactic element in the list. First, it compares the syntactic
|
|
|
134 element against the SYNTACTIC-SYMBOL's in `vhdl-offsets-alist'. When it
|
|
|
135 finds a match, it adds the OFFSET to the column of the relative indent
|
|
|
136 point. The sum of this calculation for each element in the syntactic
|
|
|
137 list is the absolute offset for line being indented.
|
|
|
138
|
|
|
139 If the syntactic element does not match any in the `vhdl-offsets-alist',
|
|
|
140 an error is generated if `vhdl-strict-syntax-p' is non-nil, otherwise
|
|
|
141 the element is ignored.
|
|
|
142
|
|
|
143 Actually, OFFSET can be an integer, a function, a variable, or one of
|
|
|
144 the following symbols: `+', `-', `++', or `--'. These latter
|
|
|
145 designate positive or negative multiples of `vhdl-basic-offset',
|
|
|
146 respectively: *1, *-1, *2, and *-2. If OFFSET is a function, it is
|
|
|
147 called with a single argument containing the cons of the syntactic
|
|
|
148 element symbol and the relative indent point. The function should
|
|
|
149 return an integer offset.
|
|
|
150
|
|
|
151 Here is the current list of valid syntactic element symbols:
|
|
|
152
|
|
|
153 string -- inside multi-line string
|
|
|
154 block-open -- statement block open
|
|
|
155 block-close -- statement block close
|
|
|
156 statement -- a VHDL statement
|
|
|
157 statement-cont -- a continuation of a VHDL statement
|
|
|
158 statement-block-intro -- the first line in a new statement block
|
|
|
159 statement-case-intro -- the first line in a case alternative block
|
|
|
160 case-alternative -- a case statement alternative clause
|
|
|
161 comment -- a line containing only a comment
|
|
|
162 arglist-intro -- the first line in an argument list
|
|
|
163 arglist-cont -- subsequent argument list lines when no
|
|
|
164 arguments follow on the same line as the
|
|
|
165 the arglist opening paren
|
|
|
166 arglist-cont-nonempty -- subsequent argument list lines when at
|
|
|
167 least one argument follows on the same
|
|
|
168 line as the arglist opening paren
|
|
|
169 arglist-close -- the solo close paren of an argument list
|
|
|
170 entity -- inside an entity declaration
|
|
|
171 configuration -- inside a configuration declaration
|
|
|
172 package -- inside a package declaration
|
|
|
173 architecture -- inside an architecture body
|
|
|
174 package-body -- inside a package body
|
|
|
175 ")
|
|
|
176
|
|
|
177 (defvar vhdl-tab-always-indent t
|
|
|
178 "*Controls the operation of the TAB key.
|
|
|
179 If t, hitting TAB always just indents the current line. If nil,
|
|
|
180 hitting TAB indents the current line if point is at the left margin or
|
|
|
181 in the line's indentation, otherwise it insert a real tab character.
|
|
|
182 If other than nil or t, then tab is inserted only within literals
|
|
|
183 -- defined as comments and strings -- and inside preprocessor
|
|
|
184 directives, but line is always reindented.
|
|
|
185
|
|
|
186 Note that indentation of lines containing only comments is also
|
|
|
187 controlled by the `vhdl-comment-only-line-offset' variable.")
|
|
|
188
|
|
|
189 (defvar vhdl-comment-only-line-offset 0
|
|
|
190 "*Extra offset for line which contains only the start of a comment.
|
|
|
191 Can contain an integer or a cons cell of the form:
|
|
|
192
|
|
|
193 (NON-ANCHORED-OFFSET . ANCHORED-OFFSET)
|
|
|
194
|
|
|
195 Where NON-ANCHORED-OFFSET is the amount of offset given to
|
|
|
196 non-column-zero anchored comment-only lines, and ANCHORED-OFFSET is
|
|
|
197 the amount of offset to give column-zero anchored comment-only lines.
|
|
|
198 Just an integer as value is equivalent to (<val> . 0)")
|
|
|
199
|
|
|
200 (defvar vhdl-special-indent-hook nil
|
|
|
201 "*Hook for user defined special indentation adjustments.
|
|
|
202 This hook gets called after a line is indented by the mode.")
|
|
|
203
|
|
|
204 (defvar vhdl-style-alist
|
|
|
205 '(("IEEE"
|
|
|
206 (vhdl-basic-offset . 4)
|
|
|
207 (vhdl-offsets-alist . ())
|
|
|
208 )
|
|
|
209 )
|
|
|
210 "Styles of Indentation.
|
|
|
211 Elements of this alist are of the form:
|
|
|
212
|
|
|
213 (STYLE-STRING (VARIABLE . VALUE) [(VARIABLE . VALUE) ...])
|
|
|
214
|
|
|
215 where STYLE-STRING is a short descriptive string used to select a
|
|
|
216 style, VARIABLE is any vhdl-mode variable, and VALUE is the intended
|
|
|
217 value for that variable when using the selected style.
|
|
|
218
|
|
|
219 There is one special case when VARIABLE is `vhdl-offsets-alist'. In this
|
|
|
220 case, the VALUE is a list containing elements of the form:
|
|
|
221
|
|
|
222 (SYNTACTIC-SYMBOL . VALUE)
|
|
|
223
|
|
|
224 as described in `vhdl-offsets-alist'. These are passed directly to
|
|
|
225 `vhdl-set-offset' so there is no need to set every syntactic symbol in
|
|
|
226 your style, only those that are different from the default.")
|
|
|
227
|
|
|
228 ;; dynamically append the default value of most variables
|
|
|
229 (or (assoc "Default" vhdl-style-alist)
|
|
|
230 (let* ((varlist '(vhdl-inhibit-startup-warnings-p
|
|
|
231 vhdl-strict-syntax-p
|
|
|
232 vhdl-echo-syntactic-information-p
|
|
|
233 vhdl-basic-offset
|
|
|
234 vhdl-offsets-alist
|
|
|
235 vhdl-tab-always-indent
|
|
|
236 vhdl-comment-only-line-offset))
|
|
|
237 (default (cons "Default"
|
|
|
238 (mapcar
|
|
|
239 (function
|
|
|
240 (lambda (var)
|
|
|
241 (cons var (symbol-value var))
|
|
|
242 ))
|
|
|
243 varlist))))
|
|
|
244 (setq vhdl-style-alist (cons default vhdl-style-alist))))
|
|
|
245
|
|
|
246 (defvar vhdl-mode-hook nil
|
|
|
247 "*Hook called by `vhdl-mode'.")
|
|
|
248
|
|
|
249 (defvar vhdl-mode-menu
|
|
|
250 '(["Comment Out Region" comment-region (mark)]
|
|
|
251 ;; ["Indent Expression" vhdl-indent-exp
|
|
|
252 ;; (memq (following-char) '(?\( ?\[ ?\{))]
|
|
|
253 ["Indent Line" vhdl-indent-command t]
|
|
|
254 ["Backward Statement" vhdl-beginning-of-statement t]
|
|
|
255 ;; ["Forward Statement" vhdl-end-of-statement t]
|
|
|
256 )
|
|
|
257 "XEmacs 19 (formerly Lucid) menu for VHDL mode.")
|
|
|
258
|
|
|
259 ;; ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
|
|
260 ;; NO USER DEFINABLE VARIABLES BEYOND THIS POINT
|
|
|
261
|
|
|
262
|
|
|
263 ;; Emacs variant handling, and standard mode variables and functions:
|
|
|
264
|
|
|
265 (defconst vhdl-emacs-features
|
|
|
266 (let ((major (and (boundp 'emacs-major-version)
|
|
|
267 emacs-major-version))
|
|
|
268 (minor (and (boundp 'emacs-minor-version)
|
|
|
269 emacs-minor-version))
|
|
|
270 flavor)
|
|
|
271 ;; figure out version numbers if not already discovered
|
|
|
272 (and (or (not major) (not minor))
|
|
|
273 (string-match "\\([0-9]+\\).\\([0-9]+\\)" emacs-version)
|
|
|
274 (setq major (string-to-int (substring emacs-version
|
|
|
275 (match-beginning 1)
|
|
|
276 (match-end 1)))
|
|
|
277 minor (string-to-int (substring emacs-version
|
|
|
278 (match-beginning 2)
|
|
|
279 (match-end 2)))))
|
|
|
280 (if (not (and major minor))
|
|
|
281 (error "Cannot figure out the major and minor version numbers."))
|
|
|
282 ;; calculate the major version
|
|
|
283 (cond
|
|
179
|
284 ((= major 18) (setq major 'v18)) ;Emacs 18
|
|
|
285 ((= major 4) (setq major 'v18)) ;Epoch 4
|
|
|
286 ((>= major 19) (setq major 'v19 ;Emacs 19 or later
|
|
|
287 flavor (cond
|
|
|
288 ((string-match "Win-Emacs" emacs-version)
|
|
|
289 'Win-Emacs)
|
|
|
290 ((or (string-match "Lucid" emacs-version)
|
|
|
291 (string-match "XEmacs" emacs-version))
|
|
|
292 'XEmacs)
|
|
|
293 (t
|
|
|
294 'FSF))))
|
|
72
|
295 ;; I don't know
|
|
|
296 (t (error "Cannot recognize major version number: %s" major)))
|
|
|
297 ;; lets do some minimal sanity checking.
|
|
|
298 (if (and (or
|
|
|
299 ;; Emacs 18 is brain dead
|
|
|
300 (eq major 'v18)
|
|
|
301 ;; Lemacs before 19.6 had bugs
|
|
|
302 (and (eq major 'v19) (eq flavor 'XEmacs) (< minor 6))
|
|
|
303 ;; FSF 19 before 19.21 had bugs
|
|
|
304 (and (eq major 'v19) (eq flavor 'FSF) (< minor 21)))
|
|
|
305 (not vhdl-inhibit-startup-warnings-p))
|
|
|
306 (with-output-to-temp-buffer "*vhdl-mode warnings*"
|
|
|
307 (print (format
|
|
|
308 "The version of Emacs that you are running, %s,
|
|
|
309 has known bugs in its syntax.c parsing routines which will affect the
|
|
|
310 performance of vhdl-mode. You should strongly consider upgrading to the
|
|
|
311 latest available version. vhdl-mode may continue to work, after a
|
|
|
312 fashion, but strange indentation errors could be encountered."
|
|
|
313 emacs-version))))
|
|
|
314 (list major flavor))
|
|
|
315 "A list of features extant in the Emacs you are using.
|
|
|
316 There are many flavors of Emacs out there, each with different
|
|
|
317 features supporting those needed by vhdl-mode. Here's the current
|
|
|
318 supported list, along with the values for this variable:
|
|
|
319
|
|
|
320 Emacs 18/Epoch 4: (v18)
|
|
|
321 XEmacs (formerly Lucid) 19: (v19 XEmacs)
|
|
|
322 Win-Emacs 1.35: (V19 Win-Emacs)
|
|
|
323 FSF Emacs 19: (v19 FSF).")
|
|
|
324
|
|
|
325 (defvar vhdl-mode-abbrev-table nil
|
|
|
326 "Abbrev table in use in vhdl-mode buffers.")
|
|
|
327 (define-abbrev-table 'vhdl-mode-abbrev-table ())
|
|
|
328
|
|
|
329 (defvar vhdl-mode-map ()
|
|
|
330 "Keymap used in vhdl-mode buffers.")
|
|
|
331 (if vhdl-mode-map
|
|
|
332 ()
|
|
|
333 ;; TBD: should we even worry about naming this keymap. My vote: no,
|
|
|
334 ;; because FSF and XEmacs (formerly Lucid) do it differently.
|
|
|
335 (setq vhdl-mode-map (make-sparse-keymap))
|
|
|
336 ;; put standard keybindings into MAP
|
|
|
337 (define-key vhdl-mode-map "\M-a" 'vhdl-beginning-of-statement)
|
|
|
338 ;;(define-key vhdl-mode-map "\M-e" 'vhdl-end-of-statement)
|
|
|
339 (define-key vhdl-mode-map "\M-\C-f" 'vhdl-forward-sexp)
|
|
|
340 (define-key vhdl-mode-map "\M-\C-b" 'vhdl-backward-sexp)
|
|
|
341 (define-key vhdl-mode-map "\M-\C-u" 'vhdl-backward-up-list)
|
|
|
342 ;;(define-key vhdl-mode-map "\M-\C-d" 'vhdl-down-list)
|
|
|
343 (define-key vhdl-mode-map "\M-\C-a" 'vhdl-beginning-of-defun)
|
|
|
344 (define-key vhdl-mode-map "\M-\C-e" 'vhdl-end-of-defun)
|
|
|
345 (define-key vhdl-mode-map "\M-\C-h" 'vhdl-mark-defun)
|
|
|
346 (define-key vhdl-mode-map "\M-\C-q" 'vhdl-indent-sexp)
|
|
|
347 (define-key vhdl-mode-map "\t" 'vhdl-indent-command)
|
|
179
|
348 (define-key vhdl-mode-map "\177" 'backward-delete-char-untabify)
|
|
72
|
349 ;; these are new keybindings, with no counterpart to BOCM
|
|
|
350 (define-key vhdl-mode-map "\C-c\C-b" 'vhdl-submit-bug-report)
|
|
|
351 (define-key vhdl-mode-map "\C-c\C-c" 'comment-region)
|
|
|
352 (define-key vhdl-mode-map "\C-c\C-o" 'vhdl-set-offset)
|
|
|
353 (define-key vhdl-mode-map "\C-c\C-r" 'vhdl-regress-line)
|
|
|
354 (define-key vhdl-mode-map "\C-c\C-s" 'vhdl-show-syntactic-information)
|
|
|
355 (define-key vhdl-mode-map "\C-c\C-v" 'vhdl-version)
|
|
|
356 ;; in XEmacs (formerly Lucid) 19, we want the menu to popup when
|
|
|
357 ;; the 3rd button is hit. In 19.10 and beyond this is done
|
|
|
358 ;; automatically if we put the menu on mode-popup-menu variable,
|
|
|
359 ;; see c-common-init. RMS decided that this feature should not be
|
|
|
360 ;; included for FSF's Emacs.
|
|
|
361 (if (and (boundp 'current-menubar)
|
|
|
362 (not (boundp 'mode-popup-menu)))
|
|
|
363 (define-key vhdl-mode-map 'button3 'vhdl-popup-menu))
|
|
|
364 )
|
|
|
365
|
|
|
366 (defvar vhdl-mode-syntax-table nil
|
|
|
367 "Syntax table used in vhdl-mode buffers.")
|
|
|
368 (if vhdl-mode-syntax-table
|
|
|
369 ()
|
|
|
370 (setq vhdl-mode-syntax-table (make-syntax-table))
|
|
|
371 ;; DO NOT TRY TO SET _ (UNDERSCORE) TO WORD CLASS!
|
|
|
372 (modify-syntax-entry ?\" "\"" vhdl-mode-syntax-table)
|
|
|
373 (modify-syntax-entry ?\$ "." vhdl-mode-syntax-table)
|
|
|
374 (modify-syntax-entry ?\% "." vhdl-mode-syntax-table)
|
|
|
375 (modify-syntax-entry ?\& "." vhdl-mode-syntax-table)
|
|
|
376 (modify-syntax-entry ?\' "." vhdl-mode-syntax-table)
|
|
|
377 (modify-syntax-entry ?\( "()" vhdl-mode-syntax-table)
|
|
|
378 (modify-syntax-entry ?\) ")(" vhdl-mode-syntax-table)
|
|
|
379 (modify-syntax-entry ?\* "." vhdl-mode-syntax-table)
|
|
|
380 (modify-syntax-entry ?\+ "." vhdl-mode-syntax-table)
|
|
|
381 (modify-syntax-entry ?\. "." vhdl-mode-syntax-table)
|
|
|
382 (modify-syntax-entry ?\/ "." vhdl-mode-syntax-table)
|
|
|
383 (modify-syntax-entry ?\: "." vhdl-mode-syntax-table)
|
|
|
384 (modify-syntax-entry ?\; "." vhdl-mode-syntax-table)
|
|
|
385 (modify-syntax-entry ?\< "." vhdl-mode-syntax-table)
|
|
|
386 (modify-syntax-entry ?\= "." vhdl-mode-syntax-table)
|
|
|
387 (modify-syntax-entry ?\> "." vhdl-mode-syntax-table)
|
|
|
388 (modify-syntax-entry ?\[ "(]" vhdl-mode-syntax-table)
|
|
|
389 (modify-syntax-entry ?\\ "\\" vhdl-mode-syntax-table)
|
|
|
390 (modify-syntax-entry ?\] ")[" vhdl-mode-syntax-table)
|
|
|
391 (modify-syntax-entry ?\{ "(}" vhdl-mode-syntax-table)
|
|
|
392 (modify-syntax-entry ?\| "." vhdl-mode-syntax-table)
|
|
|
393 (modify-syntax-entry ?\} "){" vhdl-mode-syntax-table)
|
|
|
394 ;; add comment syntax
|
|
|
395 (modify-syntax-entry ?\- ". 12" vhdl-mode-syntax-table)
|
|
|
396 (modify-syntax-entry ?\n ">" vhdl-mode-syntax-table)
|
|
|
397 (modify-syntax-entry ?\^M ">" vhdl-mode-syntax-table))
|
|
|
398
|
|
|
399 (defvar vhdl-syntactic-context nil
|
|
|
400 "Buffer local variable containing syntactic analysis list.")
|
|
|
401 (make-variable-buffer-local 'vhdl-syntactic-context)
|
|
|
402
|
|
|
403 ;; Support for outline modes
|
|
|
404
|
|
|
405 (defconst vhdl-outline-regexp
|
|
|
406 (concat "\\(entity\\)\\|\\(package\\)\\|"
|
|
|
407 "\\( *procedure\\)\\|\\( *function\\)\\|"
|
|
|
408 "\\( *component\\)\\|\\(architecture\\)\\|"
|
|
|
409 "\\(package body\\)\\|\\( *[A-Za-z][A-Za-z0-9_]* : block\\)\\|"
|
|
|
410 "\\( *[A-Za-z][A-Za-z0-9_]* : process\\)\\|\\(configuration\\)"))
|
|
|
411
|
|
|
412 (defun vhdl-outline-level () ; was copied from c-outline-level
|
|
|
413 (save-excursion
|
|
|
414 (skip-chars-forward "\t ")
|
|
|
415 (current-column)))
|
|
|
416
|
|
|
417 ;; Support for font-lock
|
|
|
418
|
|
|
419 (defconst vhdl-font-lock-keywords-1
|
|
|
420 (purecopy
|
|
|
421 (list
|
|
|
422 ;; Highlight names of common constructs
|
|
|
423 (list
|
|
|
424 (concat
|
|
|
425 "^[ \t]*\\(entity\\|architecture\\|configuration\\|function\\|"
|
|
|
426 "procedure\\|component\\|package[ \t]+body\\|package\\|"
|
|
|
427 "end[ \t]+\\(block\\|process\\|case\\|generate\\|loop\\)\\)[ \t]+"
|
|
|
428 "\\(\\(\\w\\|\\s_\\)+\\)")
|
|
|
429 3 'font-lock-function-name-face)
|
|
|
430
|
|
|
431 ;; Highlight labels of common constructs
|
|
|
432 (list
|
|
|
433 (concat
|
|
|
434 "^[ \t]*\\(\\(\\w\\|\\s_\\)+\\)[ \t]*:[ \t\n]*\\(block\\|process\\|"
|
|
|
435 "if\\|for\\|case\\|exit\\|loop\\|next\\|null\\|with\\|"
|
|
|
436 "\\(\\w\\|\\s_\\)+[ \t\n]+port[ \t]+map\\)\\>[^_]")
|
|
|
437 1 'font-lock-function-name-face)
|
|
|
438
|
|
|
439 ;; Highlight OF labels
|
|
|
440 (list
|
|
|
441 (concat
|
|
|
442 "^[ \t]*\\(configuration\\|architecture\\|attribute\\)[ \t]+"
|
|
|
443 "\\(\\(\\w\\|\\s_\\)+\\)[ \t]+of[ \t]+\\(\\(\\w\\|\\s_\\)+\\)")
|
|
|
444 4 'font-lock-function-name-face)
|
|
|
445
|
|
|
446 ;; Fontify library useage clauses.
|
|
|
447 (list
|
|
|
448 (concat
|
|
|
449 "[^\\s_]\\<\\(library\\|use\\)[ \t\n]+\\(entity[ \t\n]+\\)?"
|
|
|
450 "\\(\\(\\w\\|\\s_\\|[\.()]\\)+\\)")
|
|
|
451 3 'font-lock-function-name-face)
|
|
|
452 ))
|
|
|
453 "For consideration as a value of `vhdl-font-lock-keywords'.
|
|
|
454 This does fairly subdued highlighting of function names.")
|
|
|
455
|
|
|
456 (defconst vhdl-font-lock-keywords-2
|
|
|
457 (purecopy
|
|
|
458 (append
|
|
|
459 vhdl-font-lock-keywords-1
|
|
|
460 (list
|
|
|
461 (list
|
|
|
462 (concat
|
|
|
463 "[^\\s_]\\<\\("
|
|
|
464 (mapconcat
|
|
|
465 'identity
|
|
|
466 '(
|
|
|
467 ;; the following is a list of all reserved words known in VHDL'93
|
|
|
468 "abs" "access" "after" "alias" "all" "and" "assert"
|
|
|
469 "architecture" "array" "attribute"
|
|
|
470 "begin" "block" "body" "buffer" "bus"
|
|
|
471 "case" "component" "configuration" "constant"
|
|
|
472 "disconnect" "downto"
|
|
|
473 "else" "elsif" "end" "entity" "exit"
|
|
|
474 "file" "for" "function"
|
|
|
475 "generate" "generic" "group" "guarded"
|
|
|
476 "if" "impure" "in" "inertial" "inout" "is"
|
|
|
477 "label" "library" "linkage" "literal" "loop"
|
|
|
478 "map" "mod"
|
|
|
479 "nand" "new" "next" "nor" "not" "null"
|
|
|
480 "of" "on" "open" "or" "others" "out"
|
|
|
481 "package" "port" "postponed" "procedure" "process" "pure"
|
|
|
482 "range" "record" "register" "reject" "rem" "report" "return"
|
|
|
483 "rol" "ror"
|
|
|
484 "select" "severity" "signal" "shared" "sla" "sll" "sra" "srl"
|
|
|
485 "subtype"
|
|
|
486 "then" "to" "transport" "type"
|
|
|
487 "unaffected" "units" "until" "use"
|
|
|
488 "variable" "wait" "when" "while" "with"
|
|
|
489 "xnor" "xor"
|
|
|
490 "note" "warning" "error" "failure"
|
|
|
491 ;; the following list contains predefined attributes
|
|
|
492 "base" "left" "right" "high" "low" "pos" "val" "succ"
|
|
|
493 "pred" "leftof" "rightof" "range" "reverse_range"
|
|
|
494 "length" "delayed" "stable" "quiet" "transaction"
|
|
|
495 "event" "active" "last_event" "last_active" "last_value"
|
|
|
496 "driving" "driving_value" "ascending" "value" "image"
|
|
|
497 "simple_name" "instance_name" "path_name"
|
|
|
498 "foreign"
|
|
|
499 ;; the following list contains standardized types
|
|
|
500 "boolean" "bit" "bit_vector" "character" "severity_level" "integer"
|
|
|
501 "real" "time" "natural" "positive" "string" "text" "line"
|
|
|
502 "unsigned" "signed"
|
|
|
503 "std_logic" "std_logic_vector"
|
|
|
504 "std_ulogic" "std_ulogic_vector"
|
|
|
505 )
|
|
|
506 "\\|")
|
|
|
507 "\\)\\>[^\\s_]")
|
|
|
508 1 'font-lock-keyword-face)
|
|
|
509 )))
|
|
|
510 "For consideration as a value of `vhdl-font-lock-keywords'.
|
|
|
511 This does a lot more highlighting.")
|
|
|
512
|
|
|
513 ;; The keywords in the preceding lists assume case-insensitivity.
|
|
|
514 (put 'vhdl-mode 'font-lock-keywords-case-fold-search t)
|
|
|
515
|
|
|
516 (defvar vhdl-font-lock-keywords vhdl-font-lock-keywords-1
|
|
|
517 "Additional expressions to highlight in VHDL mode.")
|
|
|
518
|
|
|
519 ;; This should eventually be subsumed into the respective functions in
|
|
|
520 ;; the source for "font-lock.el".
|
|
|
521 (if (featurep 'advice)
|
|
|
522 (progn
|
|
|
523 (defadvice font-lock-use-default-minimal-decoration
|
|
|
524 (before vhdl-mode activate)
|
|
|
525 "Do it for VHDL mode too."
|
|
|
526 (setq vhdl-font-lock-keywords vhdl-font-lock-keywords-1))
|
|
|
527
|
|
|
528 (defadvice font-lock-use-default-maximal-decoration
|
|
|
529 (before vhdl-mode activate)
|
|
|
530 "Do it for VHDL mode too."
|
|
|
531 (setq vhdl-font-lock-keywords vhdl-font-lock-keywords-2))
|
|
|
532 ))
|
|
|
533
|
|
|
534
|
|
|
535 ;; Main entry point for VHDL mode:
|
|
|
536
|
|
|
537 ;;;###autoload
|
|
|
538 (defun vhdl-mode ()
|
|
|
539 "Major mode for editing VHDL code.
|
|
179
|
540 vhdl-mode $Revision: 1.6 $
|
|
72
|
541 To submit a problem report, enter `\\[vhdl-submit-bug-report]' from a
|
|
|
542 vhdl-mode buffer. This automatically sets up a mail buffer with version
|
|
|
543 information already added. You just need to add a description of the
|
|
179
|
544 problem, including a reproducable test case and send the message.
|
|
72
|
545
|
|
|
546 Note that the details of configuring vhdl-mode will soon be moved to the
|
|
|
547 accompanying texinfo manual. Until then, please read the README file
|
|
|
548 that came with the vhdl-mode distribution.
|
|
|
549
|
|
|
550 The hook variable `vhdl-mode-hook' is run with no args, if that value is
|
|
|
551 bound and has a non-nil value.
|
|
|
552
|
|
|
553 Key bindings:
|
|
|
554 \\{vhdl-mode-map}"
|
|
|
555 (interactive)
|
|
|
556 (kill-all-local-variables)
|
|
|
557 (set-syntax-table vhdl-mode-syntax-table)
|
|
|
558 (setq major-mode 'vhdl-mode
|
|
|
559 mode-name "VHDL"
|
|
|
560 local-abbrev-table vhdl-mode-abbrev-table)
|
|
|
561 (use-local-map vhdl-mode-map)
|
|
|
562 ;; set local variable values
|
|
|
563 (set (make-local-variable 'paragraph-start) (concat "^$\\|" page-delimiter))
|
|
|
564 (set (make-local-variable 'paragraph-separate) paragraph-start)
|
|
|
565 (set (make-local-variable 'paragraph-ignore-fill-prefix) t)
|
|
|
566 (set (make-local-variable 'require-final-newline) t)
|
|
|
567 (set (make-local-variable 'parse-sexp-ignore-comments) t)
|
|
|
568 (set (make-local-variable 'indent-line-function) 'vhdl-indent-line)
|
|
|
569 (set (make-local-variable 'comment-start) "-- ")
|
|
|
570 (set (make-local-variable 'comment-end) "")
|
|
|
571 (set (make-local-variable 'comment-column) 32)
|
|
|
572 (set (make-local-variable 'comment-start-skip) "--+ *")
|
|
|
573 (set (make-local-variable 'outline-regexp) vhdl-outline-regexp)
|
|
|
574 (set (make-local-variable 'outline-level) 'vhdl-outline-level)
|
|
|
575
|
|
|
576 ;; setup the comment indent variable in a Emacs version portable way
|
|
|
577 ;; ignore any byte compiler warnings you might get here
|
|
|
578 (if (boundp 'comment-indent-function)
|
|
|
579 (progn
|
|
|
580 (make-local-variable 'comment-indent-function)
|
|
|
581 (setq comment-indent-function 'vhdl-comment-indent))
|
|
|
582 (make-local-variable 'comment-indent-hook)
|
|
|
583 (setq comment-indent-hook 'vhdl-comment-indent))
|
|
|
584 ;; put VHDL menu into menubar and on popup menu for XEmacs (formerly
|
|
|
585 ;; Lucid) 19. I think this happens automatically for FSF Emacs 19.
|
|
|
586 (if (and (boundp 'current-menubar)
|
|
|
587 current-menubar
|
|
|
588 (not (assoc mode-name current-menubar)))
|
|
|
589 (progn
|
|
|
590 (set-buffer-menubar (copy-sequence current-menubar))
|
|
|
591 (add-menu nil mode-name vhdl-mode-menu)))
|
|
|
592 (if (boundp 'mode-popup-menu)
|
|
|
593 (setq mode-popup-menu
|
|
|
594 (cons (concat mode-name " Mode Commands") vhdl-mode-menu)))
|
|
|
595 (run-hooks 'vhdl-mode-hook))
|
|
|
596
|
|
|
597 ;; menus for XEmacs (formerly Lucid)
|
|
|
598
|
|
|
599 (defun vhdl-popup-menu (e)
|
|
|
600 "Pops up the VHDL menu."
|
|
|
601 (interactive "@e")
|
|
|
602 (popup-menu (cons (concat mode-name " Mode Commands") vhdl-mode-menu))
|
|
|
603 (vhdl-keep-region-active))
|
|
|
604
|
|
|
605 ;; active regions
|
|
|
606
|
|
|
607 (defun vhdl-keep-region-active ()
|
|
|
608 ;; do whatever is necessary to keep the region active in XEmacs
|
|
|
609 ;; (formerly Lucid). ignore byte-compiler warnings you might see
|
|
|
610 (and (boundp 'zmacs-region-stays)
|
|
|
611 (setq zmacs-region-stays t)))
|
|
|
612
|
|
|
613 ;; constant regular expressions for looking at various constructs
|
|
|
614
|
|
|
615 (defconst vhdl-symbol-key "\\(\\w\\|\\s_\\)+"
|
|
|
616 "Regexp describing a VHDL symbol.
|
|
|
617 We cannot use just `word' syntax class since `_' cannot be in word
|
|
|
618 class. Putting underscore in word class breaks forward word movement
|
|
|
619 behavior that users are familiar with.")
|
|
|
620
|
|
|
621 (defconst vhdl-case-alternative-key "when[( \t\n][^;=>]+=>"
|
|
|
622 "Regexp describing a case statement alternative key.")
|
|
|
623
|
|
|
624 (defconst vhdl-case-header-key "case[( \t\n][^;=>]+[) \t\n]is"
|
|
|
625 "Regexp describing a case statement header key.")
|
|
|
626
|
|
|
627 (defconst vhdl-label-key
|
|
|
628 (concat vhdl-symbol-key "\\s-*:")
|
|
|
629 "Regexp describing a VHDL label.")
|
|
|
630
|
|
|
631
|
|
|
632 ;; Macro definitions:
|
|
|
633
|
|
|
634 (defmacro vhdl-point (position)
|
|
|
635 ;; Returns the value of point at certain commonly referenced POSITIONs.
|
|
|
636 ;; POSITION can be one of the following symbols:
|
|
|
637 ;;
|
|
|
638 ;; bol -- beginning of line
|
|
|
639 ;; eol -- end of line
|
|
|
640 ;; bod -- beginning of defun
|
|
|
641 ;; boi -- back to indentation
|
|
|
642 ;; eoi -- last whitespace on line
|
|
|
643 ;; ionl -- indentation of next line
|
|
|
644 ;; iopl -- indentation of previous line
|
|
|
645 ;; bonl -- beginning of next line
|
|
|
646 ;; bopl -- beginning of previous line
|
|
|
647 ;;
|
|
|
648 ;; This function does not modify point or mark.
|
|
|
649 (or (and (eq 'quote (car-safe position))
|
|
|
650 (null (cdr (cdr position))))
|
|
|
651 (error "bad buffer position requested: %s" position))
|
|
|
652 (setq position (nth 1 position))
|
|
|
653 (` (let ((here (point)))
|
|
|
654 (,@ (cond
|
|
|
655 ((eq position 'bol) '((beginning-of-line)))
|
|
|
656 ((eq position 'eol) '((end-of-line)))
|
|
|
657 ((eq position 'bod) '((save-match-data
|
|
|
658 (vhdl-beginning-of-defun))))
|
|
|
659 ((eq position 'boi) '((back-to-indentation)))
|
|
|
660 ((eq position 'eoi) '((end-of-line)(skip-chars-backward " \t")))
|
|
|
661 ((eq position 'bonl) '((forward-line 1)))
|
|
|
662 ((eq position 'bopl) '((forward-line -1)))
|
|
|
663 ((eq position 'iopl)
|
|
|
664 '((forward-line -1)
|
|
|
665 (back-to-indentation)))
|
|
|
666 ((eq position 'ionl)
|
|
|
667 '((forward-line 1)
|
|
|
668 (back-to-indentation)))
|
|
|
669 (t (error "unknown buffer position requested: %s" position))
|
|
|
670 ))
|
|
|
671 (prog1
|
|
|
672 (point)
|
|
|
673 (goto-char here))
|
|
|
674 ;; workaround for an Emacs18 bug -- blech! Well, at least it
|
|
|
675 ;; doesn't hurt for v19
|
|
|
676 (,@ nil)
|
|
|
677 )))
|
|
|
678
|
|
|
679 (defmacro vhdl-safe (&rest body)
|
|
|
680 ;; safely execute BODY, return nil if an error occurred
|
|
|
681 (` (condition-case nil
|
|
|
682 (progn (,@ body))
|
|
|
683 (error nil))))
|
|
|
684
|
|
|
685 (defmacro vhdl-add-syntax (symbol &optional relpos)
|
|
|
686 ;; a simple macro to append the syntax in symbol to the syntax list.
|
|
|
687 ;; try to increase performance by using this macro
|
|
|
688 (` (setq vhdl-syntactic-context
|
|
|
689 (cons (cons (, symbol) (, relpos)) vhdl-syntactic-context))))
|
|
|
690
|
|
|
691 (defmacro vhdl-has-syntax (symbol)
|
|
|
692 ;; a simple macro to return check the syntax list.
|
|
|
693 ;; try to increase performance by using this macro
|
|
|
694 (` (assoc (, symbol) vhdl-syntactic-context)))
|
|
|
695
|
|
|
696
|
|
|
697 ;; Syntactic element offset manipulation:
|
|
|
698
|
|
|
699 (defun vhdl-read-offset (langelem)
|
|
|
700 ;; read new offset value for LANGELEM from minibuffer. return a
|
|
|
701 ;; legal value only
|
|
|
702 (let ((oldoff (format "%s" (cdr-safe (assq langelem vhdl-offsets-alist))))
|
|
|
703 (errmsg "Offset must be int, func, var, or one of +, -, ++, --: ")
|
|
|
704 (prompt "Offset: ")
|
|
|
705 offset input interned)
|
|
|
706 (while (not offset)
|
|
|
707 (setq input (read-string prompt oldoff)
|
|
|
708 offset (cond ((string-equal "+" input) '+)
|
|
|
709 ((string-equal "-" input) '-)
|
|
|
710 ((string-equal "++" input) '++)
|
|
|
711 ((string-equal "--" input) '--)
|
|
|
712 ((string-match "^-?[0-9]+$" input)
|
|
|
713 (string-to-int input))
|
|
|
714 ((fboundp (setq interned (intern input)))
|
|
|
715 interned)
|
|
|
716 ((boundp interned) interned)
|
|
|
717 ;; error, but don't signal one, keep trying
|
|
|
718 ;; to read an input value
|
|
|
719 (t (ding)
|
|
|
720 (setq prompt errmsg)
|
|
|
721 nil))))
|
|
|
722 offset))
|
|
|
723
|
|
|
724 (defun vhdl-set-offset (symbol offset &optional add-p)
|
|
|
725 "Change the value of a syntactic element symbol in `vhdl-offsets-alist'.
|
|
|
726 SYMBOL is the syntactic element symbol to change and OFFSET is the new
|
|
|
727 offset for that syntactic element. Optional ADD says to add SYMBOL to
|
|
|
728 `vhdl-offsets-alist' if it doesn't already appear there."
|
|
|
729 (interactive
|
|
|
730 (let* ((langelem
|
|
|
731 (intern (completing-read
|
|
|
732 (concat "Syntactic symbol to change"
|
|
|
733 (if current-prefix-arg " or add" "")
|
|
|
734 ": ")
|
|
|
735 (mapcar
|
|
|
736 (function
|
|
|
737 (lambda (langelem)
|
|
|
738 (cons (format "%s" (car langelem)) nil)))
|
|
|
739 vhdl-offsets-alist)
|
|
|
740 nil (not current-prefix-arg)
|
|
|
741 ;; initial contents tries to be the last element
|
|
|
742 ;; on the syntactic analysis list for the current
|
|
|
743 ;; line
|
|
|
744 (let* ((syntax (vhdl-get-syntactic-context))
|
|
|
745 (len (length syntax))
|
|
|
746 (ic (format "%s" (car (nth (1- len) syntax)))))
|
|
|
747 (if (memq 'v19 vhdl-emacs-features)
|
|
|
748 (cons ic 0)
|
|
|
749 ic))
|
|
|
750 )))
|
|
|
751 (offset (vhdl-read-offset langelem)))
|
|
|
752 (list langelem offset current-prefix-arg)))
|
|
|
753 ;; sanity check offset
|
|
|
754 (or (eq offset '+)
|
|
|
755 (eq offset '-)
|
|
|
756 (eq offset '++)
|
|
|
757 (eq offset '--)
|
|
|
758 (integerp offset)
|
|
|
759 (fboundp offset)
|
|
|
760 (boundp offset)
|
|
|
761 (error "Offset must be int, func, var, or one of +, -, ++, --: %s"
|
|
|
762 offset))
|
|
|
763 (let ((entry (assq symbol vhdl-offsets-alist)))
|
|
|
764 (if entry
|
|
|
765 (setcdr entry offset)
|
|
|
766 (if add-p
|
|
|
767 (setq vhdl-offsets-alist (cons (cons symbol offset) vhdl-offsets-alist))
|
|
|
768 (error "%s is not a valid syntactic symbol." symbol))))
|
|
|
769 (vhdl-keep-region-active))
|
|
|
770
|
|
|
771 (defun vhdl-set-style (style &optional local)
|
|
|
772 "Set vhdl-mode variables to use one of several different indentation styles.
|
|
|
773 STYLE is a string representing the desired style and optional LOCAL is
|
|
|
774 a flag which, if non-nil, means to make the style variables being
|
|
|
775 changed buffer local, instead of the default, which is to set the
|
|
|
776 global variables. Interactively, the flag comes from the prefix
|
|
|
777 argument. The styles are chosen from the `vhdl-style-alist' variable."
|
|
|
778 (interactive (list (completing-read "Use which VHDL indentation style? "
|
|
|
779 vhdl-style-alist nil t)
|
|
|
780 current-prefix-arg))
|
|
|
781 (let ((vars (cdr (assoc style vhdl-style-alist))))
|
|
|
782 (or vars
|
|
|
783 (error "Invalid VHDL indentation style `%s'" style))
|
|
|
784 ;; set all the variables
|
|
|
785 (mapcar
|
|
|
786 (function
|
|
|
787 (lambda (varentry)
|
|
|
788 (let ((var (car varentry))
|
|
|
789 (val (cdr varentry)))
|
|
|
790 (and local
|
|
|
791 (make-local-variable var))
|
|
|
792 ;; special case for vhdl-offsets-alist
|
|
|
793 (if (not (eq var 'vhdl-offsets-alist))
|
|
|
794 (set var val)
|
|
|
795 ;; reset vhdl-offsets-alist to the default value first
|
|
|
796 (setq vhdl-offsets-alist (copy-alist vhdl-offsets-alist-default))
|
|
|
797 ;; now set the langelems that are different
|
|
|
798 (mapcar
|
|
|
799 (function
|
|
|
800 (lambda (langentry)
|
|
|
801 (let ((langelem (car langentry))
|
|
|
802 (offset (cdr langentry)))
|
|
|
803 (vhdl-set-offset langelem offset)
|
|
|
804 )))
|
|
|
805 val))
|
|
|
806 )))
|
|
|
807 vars))
|
|
|
808 (vhdl-keep-region-active))
|
|
|
809
|
|
179
|
810 (defun vhdl-add-style (style descrip &optional set-p)
|
|
|
811 "Adds a style to `vhdl-style-alist', or updates an existing one.
|
|
|
812 STYLE is a string identifying the style to add or update. DESCRIP is
|
|
|
813 an association list describing the style and must be of the form:
|
|
|
814
|
|
|
815 ((VARIABLE . VALUE) [(VARIABLE . VALUE) ...])
|
|
|
816
|
|
|
817 See the variable `vhdl-style-alist' for the semantics of VARIABLE and
|
|
|
818 VALUE. This function also sets the current style to STYLE using
|
|
|
819 `vhdl-set-style' if the optional SET-P flag is non-nil."
|
|
|
820 (interactive
|
|
|
821 (let ((stylename (completing-read "Style to add: " vhdl-style-alist))
|
|
|
822 (description (eval-minibuffer "Style description: ")))
|
|
|
823 (list stylename description
|
|
|
824 (y-or-n-p "Set the style too? "))))
|
|
|
825 (setq style (downcase style))
|
|
|
826 (let ((s (assoc style vhdl-style-alist)))
|
|
|
827 (if s
|
|
|
828 (setcdr s (copy-alist descrip)) ; replace
|
|
|
829 (setq vhdl-style-alist (cons (cons style descrip) vhdl-style-alist))))
|
|
|
830 (and set-p (vhdl-set-style style)))
|
|
|
831
|
|
72
|
832 (defun vhdl-get-offset (langelem)
|
|
|
833 ;; Get offset from LANGELEM which is a cons cell of the form:
|
|
|
834 ;; (SYMBOL . RELPOS). The symbol is matched against
|
|
|
835 ;; vhdl-offsets-alist and the offset found there is either returned,
|
|
|
836 ;; or added to the indentation at RELPOS. If RELPOS is nil, then
|
|
|
837 ;; the offset is simply returned.
|
|
|
838 (let* ((symbol (car langelem))
|
|
|
839 (relpos (cdr langelem))
|
|
|
840 (match (assq symbol vhdl-offsets-alist))
|
|
|
841 (offset (cdr-safe match)))
|
|
|
842 ;; offset can be a number, a function, a variable, or one of the
|
|
|
843 ;; symbols + or -
|
|
|
844 (cond
|
|
|
845 ((not match)
|
|
|
846 (if vhdl-strict-syntax-p
|
|
|
847 (error "don't know how to indent a %s" symbol)
|
|
|
848 (setq offset 0
|
|
|
849 relpos 0)))
|
|
|
850 ((eq offset '+) (setq offset vhdl-basic-offset))
|
|
|
851 ((eq offset '-) (setq offset (- vhdl-basic-offset)))
|
|
|
852 ((eq offset '++) (setq offset (* 2 vhdl-basic-offset)))
|
|
|
853 ((eq offset '--) (setq offset (* 2 (- vhdl-basic-offset))))
|
|
|
854 ((and (not (numberp offset))
|
|
|
855 (fboundp offset))
|
|
|
856 (setq offset (funcall offset langelem)))
|
|
|
857 ((not (numberp offset))
|
|
|
858 (setq offset (eval offset)))
|
|
|
859 )
|
|
|
860 (+ (if (and relpos
|
|
|
861 (< relpos (vhdl-point 'bol)))
|
|
|
862 (save-excursion
|
|
|
863 (goto-char relpos)
|
|
|
864 (current-column))
|
|
|
865 0)
|
|
|
866 offset)))
|
|
|
867
|
|
|
868
|
|
|
869 ;; Syntactic support functions:
|
|
|
870
|
|
|
871 ;; Returns `comment' if in a comment, `string' if in a string literal,
|
|
|
872 ;; or nil if not in a literal at all. Optional LIM is used as the
|
|
|
873 ;; backward limit of the search. If omitted, or nil, (point-min) is
|
|
|
874 ;; used.
|
|
|
875
|
|
|
876 (defun vhdl-in-literal (&optional lim)
|
|
|
877 ;; Determine if point is in a VHDL literal.
|
|
|
878 (save-excursion
|
|
|
879 (let* ((lim (or lim (point-min)))
|
|
|
880 (state (parse-partial-sexp lim (point))))
|
|
|
881 (cond
|
|
|
882 ((nth 3 state) 'string)
|
|
|
883 ((nth 4 state) 'comment)
|
|
|
884 (t nil)))
|
|
|
885 ))
|
|
|
886
|
|
|
887 ;; This is the best we can do in Win-Emacs.
|
|
|
888 (defun vhdl-win-il (&optional lim)
|
|
|
889 ;; Determine if point is in a VHDL literal
|
|
|
890 (save-excursion
|
|
|
891 (let* ((here (point))
|
|
|
892 (state nil)
|
|
|
893 (match nil)
|
|
|
894 (lim (or lim (vhdl-point 'bod))))
|
|
|
895 (goto-char lim )
|
|
|
896 (while (< (point) here)
|
|
|
897 (setq match
|
|
|
898 (and (re-search-forward "--\\|[\"']"
|
|
|
899 here 'move)
|
|
|
900 (buffer-substring (match-beginning 0) (match-end 0))))
|
|
|
901 (setq state
|
|
|
902 (cond
|
|
|
903 ;; no match
|
|
|
904 ((null match) nil)
|
|
|
905 ;; looking at the opening of a VHDL style comment
|
|
|
906 ((string= "--" match)
|
|
|
907 (if (<= here (progn (end-of-line) (point))) 'comment))
|
|
|
908 ;; looking at the opening of a double quote string
|
|
|
909 ((string= "\"" match)
|
|
|
910 (if (not (save-restriction
|
|
|
911 ;; this seems to be necessary since the
|
|
|
912 ;; re-search-forward will not work without it
|
|
|
913 (narrow-to-region (point) here)
|
|
|
914 (re-search-forward
|
|
|
915 ;; this regexp matches a double quote
|
|
|
916 ;; which is preceded by an even number
|
|
|
917 ;; of backslashes, including zero
|
|
|
918 "\\([^\\]\\|^\\)\\(\\\\\\\\\\)*\"" here 'move)))
|
|
|
919 'string))
|
|
|
920 ;; looking at the opening of a single quote string
|
|
|
921 ((string= "'" match)
|
|
|
922 (if (not (save-restriction
|
|
|
923 ;; see comments from above
|
|
|
924 (narrow-to-region (point) here)
|
|
|
925 (re-search-forward
|
|
|
926 ;; this matches a single quote which is
|
|
|
927 ;; preceded by zero or two backslashes.
|
|
|
928 "\\([^\\]\\|^\\)\\(\\\\\\\\\\)?'"
|
|
|
929 here 'move)))
|
|
|
930 'string))
|
|
|
931 (t nil)))
|
|
|
932 ) ; end-while
|
|
|
933 state)))
|
|
|
934
|
|
|
935 (and (memq 'Win-Emacs vhdl-emacs-features)
|
|
|
936 (fset 'vhdl-in-literal 'vhdl-win-il))
|
|
|
937
|
|
|
938 ;; Skipping of "syntactic whitespace". Syntactic whitespace is
|
|
|
939 ;; defined as lexical whitespace or comments. Search no farther back
|
|
|
940 ;; or forward than optional LIM. If LIM is omitted, (point-min) is
|
|
|
941 ;; used for backward skipping, (point-max) is used for forward
|
|
|
942 ;; skipping.
|
|
|
943
|
|
|
944 (defun vhdl-forward-syntactic-ws (&optional lim)
|
|
|
945 ;; Forward skip of syntactic whitespace.
|
|
|
946 (save-restriction
|
|
|
947 (let* ((lim (or lim (point-max)))
|
|
|
948 (here lim)
|
|
|
949 (hugenum (point-max)))
|
|
|
950 (narrow-to-region lim (point))
|
|
|
951 (while (/= here (point))
|
|
|
952 (setq here (point))
|
|
|
953 (forward-comment hugenum))
|
|
|
954 )))
|
|
|
955
|
|
|
956 ;; This is the best we can do in Win-Emacs.
|
|
|
957 (defun vhdl-win-fsws (&optional lim)
|
|
|
958 ;; Forward skip syntactic whitespace for Win-Emacs.
|
|
|
959 (let ((lim (or lim (point-max)))
|
|
|
960 stop)
|
|
|
961 (while (not stop)
|
|
|
962 (skip-chars-forward " \t\n\r\f" lim)
|
|
|
963 (cond
|
|
|
964 ;; vhdl comment
|
|
|
965 ((looking-at "--") (end-of-line))
|
|
|
966 ;; none of the above
|
|
|
967 (t (setq stop t))
|
|
|
968 ))))
|
|
|
969
|
|
|
970 (and (memq 'Win-Emacs vhdl-emacs-features)
|
|
|
971 (fset 'vhdl-forward-syntactic-ws 'vhdl-win-fsws))
|
|
|
972
|
|
|
973 (defun vhdl-backward-syntactic-ws (&optional lim)
|
|
|
974 ;; Backward skip over syntactic whitespace.
|
|
|
975 (save-restriction
|
|
|
976 (let* ((lim (or lim (point-min)))
|
|
|
977 (here lim)
|
|
|
978 (hugenum (- (point-max))))
|
|
|
979 (if (< lim (point))
|
|
|
980 (progn
|
|
|
981 (narrow-to-region lim (point))
|
|
|
982 (while (/= here (point))
|
|
|
983 (setq here (point))
|
|
|
984 (forward-comment hugenum)
|
|
|
985 )))
|
|
|
986 )))
|
|
|
987
|
|
|
988 ;; This is the best we can do in Win-Emacs.
|
|
|
989 (defun vhdl-win-bsws (&optional lim)
|
|
|
990 ;; Backward skip syntactic whitespace for Win-Emacs.
|
|
|
991 (let ((lim (or lim (vhdl-point 'bod)))
|
|
|
992 stop)
|
|
|
993 (while (not stop)
|
|
|
994 (skip-chars-backward " \t\n\r\f" lim)
|
|
|
995 (cond
|
|
|
996 ;; vhdl comment
|
|
|
997 ((eq (vhdl-in-literal lim) 'comment)
|
|
|
998 (skip-chars-backward "^-" lim)
|
|
|
999 (skip-chars-backward "-" lim)
|
|
|
1000 (while (not (or (and (= (following-char) ?-)
|
|
|
1001 (= (char-after (1+ (point))) ?-))
|
|
|
1002 (<= (point) lim)))
|
|
|
1003 (skip-chars-backward "^-" lim)
|
|
|
1004 (skip-chars-backward "-" lim)))
|
|
|
1005 ;; none of the above
|
|
|
1006 (t (setq stop t))
|
|
|
1007 ))))
|
|
|
1008
|
|
|
1009 (and (memq 'Win-Emacs vhdl-emacs-features)
|
|
|
1010 (fset 'vhdl-backward-syntactic-ws 'vhdl-win-bsws))
|
|
|
1011
|
|
|
1012 ;; Functions to help finding the correct indentation column:
|
|
|
1013
|
|
|
1014 (defun vhdl-first-word (point)
|
|
|
1015 "If the keyword at POINT is at boi, then return (current-column) at
|
|
|
1016 that point, else nil."
|
|
|
1017 (save-excursion
|
|
|
1018 (and (goto-char point)
|
|
|
1019 (eq (point) (vhdl-point 'boi))
|
|
|
1020 (current-column))))
|
|
|
1021
|
|
|
1022 (defun vhdl-last-word (point)
|
|
|
1023 "If the keyword at POINT is at eoi, then return (current-column) at
|
|
|
1024 that point, else nil."
|
|
|
1025 (save-excursion
|
|
|
1026 (and (goto-char point)
|
|
|
1027 (save-excursion (or (eq (progn (forward-sexp) (point))
|
|
|
1028 (vhdl-point 'eoi))
|
|
|
1029 (looking-at "\\s-*\\(--\\)?")))
|
|
|
1030 (current-column))))
|
|
|
1031
|
|
|
1032
|
|
|
1033 ;; Core syntactic evaluation functions:
|
|
|
1034
|
|
|
1035 (defconst vhdl-libunit-re
|
|
|
1036 "\\b\\(architecture\\|configuration\\|entity\\|package\\)\\b[^_]")
|
|
|
1037
|
|
|
1038 (defun vhdl-libunit-p ()
|
|
|
1039 (and
|
|
|
1040 (save-excursion
|
|
|
1041 (forward-sexp)
|
|
|
1042 (skip-chars-forward " \t\n")
|
|
|
1043 (not (looking-at "is\\b[^_]")))
|
|
|
1044 (save-excursion
|
|
|
1045 (backward-sexp)
|
|
|
1046 (not (looking-at "use\\b[^_]")))))
|
|
|
1047
|
|
|
1048 (defconst vhdl-defun-re
|
|
|
1049 "\\b\\(architecture\\|block\\|configuration\\|entity\\|package\\|process\\|procedure\\|function\\)\\b[^_]")
|
|
|
1050
|
|
|
1051 (defun vhdl-defun-p ()
|
|
|
1052 (save-excursion
|
|
|
1053 (if (looking-at "block\\|process")
|
|
|
1054 ;; "block", "process":
|
|
|
1055 (save-excursion
|
|
|
1056 (backward-sexp)
|
|
|
1057 (not (looking-at "end\\s-+\\w")))
|
|
|
1058 ;; "architecture", "configuration", "entity",
|
|
|
1059 ;; "package", "procedure", "function":
|
|
|
1060 t)))
|
|
|
1061
|
|
|
1062 (defun vhdl-corresponding-defun ()
|
|
|
1063 "If the word at the current position corresponds to a \"defun\"
|
|
|
1064 keyword, then return a string that can be used to find the
|
|
|
1065 corresponding \"begin\" keyword, else return nil."
|
|
|
1066 (save-excursion
|
|
|
1067 (and (looking-at vhdl-defun-re)
|
|
|
1068 (vhdl-defun-p)
|
|
|
1069 (if (looking-at "block\\|process")
|
|
|
1070 ;; "block", "process":
|
|
|
1071 (buffer-substring (match-beginning 0) (match-end 0))
|
|
|
1072 ;; "architecture", "configuration", "entity", "package",
|
|
|
1073 ;; "procedure", "function":
|
|
|
1074 "is"))))
|
|
|
1075
|
|
|
1076 (defconst vhdl-begin-fwd-re
|
|
|
1077 "\\b\\(is\\|begin\\|block\\|component\\|generate\\|then\\|else\\|loop\\|process\\|units\\|record\\|for\\)\\b\\([^_]\\|\\'\\)"
|
|
|
1078 "A regular expression for searching forward that matches all known
|
|
|
1079 \"begin\" keywords.")
|
|
|
1080
|
|
|
1081 (defconst vhdl-begin-bwd-re
|
|
|
1082 "\\b\\(is\\|begin\\|block\\|component\\|generate\\|then\\|else\\|loop\\|process\\|units\\|record\\|for\\)\\b"
|
|
|
1083 "A regular expression for searching backward that matches all known
|
|
|
1084 \"begin\" keywords.")
|
|
|
1085
|
|
|
1086 (defun vhdl-begin-p (&optional lim)
|
|
|
1087 "Return t if we are looking at a real \"begin\" keyword.
|
|
|
1088 Assumes that the caller will make sure that we are looking at
|
|
|
1089 vhdl-begin-fwd-re, and are not inside a literal, and that we are not in
|
|
|
1090 the middle of an identifier that just happens to contain a \"begin\"
|
|
|
1091 keyword."
|
|
|
1092 (cond
|
|
|
1093 ;; "[architecture|case|configuration|entity|package|
|
|
|
1094 ;; procedure|function] ... is":
|
|
|
1095 ((and (looking-at "i")
|
|
|
1096 (save-excursion
|
|
|
1097 ;; Skip backward over first sexp (needed to skip over a
|
|
|
1098 ;; procedure interface list, and is harmless in other
|
|
|
1099 ;; situations). Note that we need "return" in the
|
|
|
1100 ;; following search list so that we don't run into
|
|
|
1101 ;; semicolons in the function interface list.
|
|
|
1102 (backward-sexp)
|
|
|
1103 (let (foundp)
|
|
|
1104 (while (and (not foundp)
|
|
|
1105 (re-search-backward
|
|
|
1106 ";\\|\\b\\(architecture\\|case\\|configuration\\|entity\\|package\\|procedure\\|return\\|is\\|begin\\|process\\|block\\)\\b[^_]"
|
|
|
1107 lim 'move))
|
|
|
1108 (if (or (= (preceding-char) ?_)
|
|
|
1109 (vhdl-in-literal lim))
|
|
|
1110 (backward-char)
|
|
|
1111 (setq foundp t))))
|
|
|
1112 (and (/= (following-char) ?\;)
|
|
|
1113 (not (looking-at "is\\|begin\\|process\\|block")))))
|
|
|
1114 t)
|
|
|
1115 ;; "begin", "then":
|
|
|
1116 ((looking-at "be\\|t")
|
|
|
1117 t)
|
|
|
1118 ;; "else":
|
|
|
1119 ((and (looking-at "e")
|
|
|
1120 ;; make sure that the "else" isn't inside a
|
|
|
1121 ;; conditional signal assignment.
|
|
|
1122 (save-excursion
|
|
|
1123 (re-search-backward ";\\|\\bwhen\\b[^_]" lim 'move)
|
|
|
1124 (or (eq (following-char) ?\;)
|
|
|
1125 (eq (point) lim))))
|
|
|
1126 t)
|
|
|
1127 ;; "block", "component", "generate", "loop", "process",
|
|
|
1128 ;; "units", "record":
|
|
|
1129 ((and (looking-at "bl\\|[cglpur]")
|
|
|
1130 (save-excursion
|
|
|
1131 (backward-sexp)
|
|
|
1132 (not (looking-at "end\\s-+\\w"))))
|
|
|
1133 t)
|
|
|
1134 ;; "for" (inside configuration declaration):
|
|
|
1135 ((and (looking-at "f")
|
|
|
1136 (save-excursion
|
|
|
1137 (backward-sexp)
|
|
|
1138 (not (looking-at "end\\s-+\\w")))
|
|
|
1139 (vhdl-has-syntax 'configuration))
|
|
|
1140 t)
|
|
|
1141 ))
|
|
|
1142
|
|
|
1143 (defun vhdl-corresponding-mid (&optional lim)
|
|
|
1144 (cond
|
|
|
1145 ((looking-at "is\\|block\\|process")
|
|
|
1146 "begin")
|
|
|
1147 ((looking-at "then")
|
|
|
1148 "<else>")
|
|
|
1149 (t
|
|
|
1150 "end")))
|
|
|
1151
|
|
|
1152 (defun vhdl-corresponding-end (&optional lim)
|
|
|
1153 "If the word at the current position corresponds to a \"begin\"
|
|
|
1154 keyword, then return a vector containing enough information to find
|
|
|
1155 the corresponding \"end\" keyword, else return nil. The keyword to
|
|
|
1156 search forward for is aref 0. The column in which the keyword must
|
|
|
1157 appear is aref 1 or nil if any column is suitable.
|
|
|
1158 Assumes that the caller will make sure that we are not in the middle
|
|
|
1159 of an identifier that just happens to contain a \"begin\" keyword."
|
|
|
1160 (save-excursion
|
|
|
1161 (and (looking-at vhdl-begin-fwd-re)
|
|
|
1162 (/= (preceding-char) ?_)
|
|
|
1163 (not (vhdl-in-literal lim))
|
|
|
1164 (vhdl-begin-p lim)
|
|
|
1165 (cond
|
|
|
1166 ;; "is", "generate", "loop":
|
|
|
1167 ((looking-at "[igl]")
|
|
|
1168 (vector "end"
|
|
|
1169 (and (vhdl-last-word (point))
|
|
|
1170 (or (vhdl-first-word (point))
|
|
|
1171 (save-excursion
|
|
|
1172 (vhdl-beginning-of-statement-1 lim)
|
|
|
1173 (vhdl-backward-skip-label lim)
|
|
|
1174 (vhdl-first-word (point)))))))
|
|
|
1175 ;; "begin", "else", "for":
|
|
|
1176 ((looking-at "be\\|[ef]")
|
|
|
1177 (vector "end"
|
|
|
1178 (and (vhdl-last-word (point))
|
|
|
1179 (or (vhdl-first-word (point))
|
|
|
1180 (save-excursion
|
|
|
1181 (vhdl-beginning-of-statement-1 lim)
|
|
|
1182 (vhdl-backward-skip-label lim)
|
|
|
1183 (vhdl-first-word (point)))))))
|
|
|
1184 ;; "component", "units", "record":
|
|
|
1185 ((looking-at "[cur]")
|
|
|
1186 ;; The first end found will close the block
|
|
|
1187 (vector "end" nil))
|
|
|
1188 ;; "block", "process":
|
|
|
1189 ((looking-at "bl\\|p")
|
|
|
1190 (vector "end"
|
|
|
1191 (or (vhdl-first-word (point))
|
|
|
1192 (save-excursion
|
|
|
1193 (vhdl-beginning-of-statement-1 lim)
|
|
|
1194 (vhdl-backward-skip-label lim)
|
|
|
1195 (vhdl-first-word (point))))))
|
|
|
1196 ;; "then":
|
|
|
1197 ((looking-at "t")
|
|
|
1198 (vector "elsif\\|else\\|end"
|
|
|
1199 (and (vhdl-last-word (point))
|
|
|
1200 (or (vhdl-first-word (point))
|
|
|
1201 (save-excursion
|
|
|
1202 (vhdl-beginning-of-statement-1 lim)
|
|
|
1203 (vhdl-backward-skip-label lim)
|
|
|
1204 (vhdl-first-word (point)))))))
|
|
|
1205 ))))
|
|
|
1206
|
|
|
1207 (defconst vhdl-end-fwd-re "\\b\\(end\\|else\\|elsif\\)\\b\\([^_]\\|\\'\\)")
|
|
|
1208
|
|
|
1209 (defconst vhdl-end-bwd-re "\\b\\(end\\|else\\|elsif\\)\\b")
|
|
|
1210
|
|
|
1211 (defun vhdl-end-p (&optional lim)
|
|
|
1212 "Return t if we are looking at a real \"end\" keyword.
|
|
|
1213 Assumes that the caller will make sure that we are looking at
|
|
|
1214 vhdl-end-fwd-re, and are not inside a literal, and that we are not in
|
|
|
1215 the middle of an identifier that just happens to contain an \"end\"
|
|
|
1216 keyword."
|
|
|
1217 (or (not (looking-at "else"))
|
|
|
1218 ;; make sure that the "else" isn't inside a conditional signal
|
|
|
1219 ;; assignment.
|
|
|
1220 (save-excursion
|
|
|
1221 (re-search-backward ";\\|\\bwhen\\b[^_]" lim 'move)
|
|
|
1222 (or (eq (following-char) ?\;)
|
|
|
1223 (eq (point) lim)))))
|
|
|
1224
|
|
|
1225 (defun vhdl-corresponding-begin (&optional lim)
|
|
|
1226 "If the word at the current position corresponds to an \"end\"
|
|
|
1227 keyword, then return a vector containing enough information to find
|
|
|
1228 the corresponding \"begin\" keyword, else return nil. The keyword to
|
|
|
1229 search backward for is aref 0. The column in which the keyword must
|
|
|
1230 appear is aref 1 or nil if any column is suitable. The supplementary
|
|
|
1231 keyword to search forward for is aref 2 or nil if this is not
|
|
|
1232 required. If aref 3 is t, then the \"begin\" keyword may be found in
|
|
|
1233 the middle of a statement.
|
|
|
1234 Assumes that the caller will make sure that we are not in the middle
|
|
|
1235 of an identifier that just happens to contain an \"end\" keyword."
|
|
|
1236 (save-excursion
|
|
|
1237 (let (pos)
|
|
|
1238 (if (and (looking-at vhdl-end-fwd-re)
|
|
|
1239 (not (vhdl-in-literal lim))
|
|
|
1240 (vhdl-end-p lim))
|
|
|
1241 (if (looking-at "el")
|
|
|
1242 ;; "else", "elsif":
|
|
|
1243 (vector "if\\|elsif" (vhdl-first-word (point)) "then" nil)
|
|
|
1244 ;; "end ...":
|
|
|
1245 (setq pos (point))
|
|
|
1246 (forward-sexp)
|
|
|
1247 (skip-chars-forward " \t\n")
|
|
|
1248 (cond
|
|
|
1249 ;; "end if":
|
|
|
1250 ((looking-at "if\\b[^_]")
|
|
|
1251 (vector "else\\|elsif\\|if"
|
|
|
1252 (vhdl-first-word pos)
|
|
|
1253 "else\\|then" nil))
|
|
|
1254 ;; "end component":
|
|
|
1255 ((looking-at "component\\b[^_]")
|
|
|
1256 (vector (buffer-substring (match-beginning 1)
|
|
|
1257 (match-end 1))
|
|
|
1258 (vhdl-first-word pos)
|
|
|
1259 nil nil))
|
|
|
1260 ;; "end units", "end record":
|
|
|
1261 ((looking-at "\\(units\\|record\\)\\b[^_]")
|
|
|
1262 (vector (buffer-substring (match-beginning 1)
|
|
|
1263 (match-end 1))
|
|
|
1264 (vhdl-first-word pos)
|
|
|
1265 nil t))
|
|
|
1266 ;; "end block", "end process":
|
|
|
1267 ((looking-at "\\(block\\|process\\)\\b[^_]")
|
|
|
1268 (vector "begin" (vhdl-first-word pos) nil nil))
|
|
|
1269 ;; "end case":
|
|
|
1270 ((looking-at "case\\b[^_]")
|
|
|
1271 (vector "case" (vhdl-first-word pos) "is" nil))
|
|
|
1272 ;; "end generate":
|
|
|
1273 ((looking-at "generate\\b[^_]")
|
|
|
1274 (vector "generate\\|for\\|if"
|
|
|
1275 (vhdl-first-word pos)
|
|
|
1276 "generate" nil))
|
|
|
1277 ;; "end loop":
|
|
|
1278 ((looking-at "loop\\b[^_]")
|
|
|
1279 (vector "loop\\|while\\|for"
|
|
|
1280 (vhdl-first-word pos)
|
|
|
1281 "loop" nil))
|
|
|
1282 ;; "end for" (inside configuration declaration):
|
|
|
1283 ((looking-at "for\\b[^_]")
|
|
|
1284 (vector "for" (vhdl-first-word pos) nil nil))
|
|
|
1285 ;; "end [id]":
|
|
|
1286 (t
|
|
|
1287 (vector "begin\\|architecture\\|configuration\\|entity\\|package\\|procedure\\|function"
|
|
|
1288 (vhdl-first-word pos)
|
|
|
1289 ;; return an alist of (statement . keyword) mappings
|
|
|
1290 '(
|
|
|
1291 ;; "begin ... end [id]":
|
|
|
1292 ("begin" . nil)
|
|
|
1293 ;; "architecture ... is ... begin ... end [id]":
|
|
|
1294 ("architecture" . "is")
|
|
|
1295 ;; "configuration ... is ... end [id]":
|
|
|
1296 ("configuration" . "is")
|
|
|
1297 ;; "entity ... is ... end [id]":
|
|
|
1298 ("entity" . "is")
|
|
|
1299 ;; "package ... is ... end [id]":
|
|
|
1300 ("package" . "is")
|
|
|
1301 ;; "procedure ... is ... begin ... end [id]":
|
|
|
1302 ("procedure" . "is")
|
|
|
1303 ;; "function ... is ... begin ... end [id]":
|
|
|
1304 ("function" . "is")
|
|
|
1305 )
|
|
|
1306 nil))
|
|
|
1307 ))) ; "end ..."
|
|
|
1308 )))
|
|
|
1309
|
|
|
1310 (defconst vhdl-leader-re
|
|
|
1311 "\\b\\(block\\|component\\|process\\|for\\)\\b[^_]")
|
|
|
1312
|
|
|
1313 (defun vhdl-end-of-leader ()
|
|
|
1314 (save-excursion
|
|
|
1315 (cond ((looking-at "block\\|process")
|
|
|
1316 (if (save-excursion
|
|
|
1317 (forward-sexp)
|
|
|
1318 (skip-chars-forward " \t\n")
|
|
|
1319 (= (following-char) ?\())
|
|
|
1320 (forward-sexp 2)
|
|
|
1321 (forward-sexp))
|
|
|
1322 (point))
|
|
|
1323 ((looking-at "component")
|
|
|
1324 (forward-sexp 2)
|
|
|
1325 (point))
|
|
|
1326 ((looking-at "for")
|
|
|
1327 (forward-sexp 2)
|
|
|
1328 (skip-chars-forward " \t\n")
|
|
|
1329 (while (looking-at "[,:(]")
|
|
|
1330 (forward-sexp)
|
|
|
1331 (skip-chars-forward " \t\n"))
|
|
|
1332 (point))
|
|
|
1333 (t nil)
|
|
|
1334 )))
|
|
|
1335
|
|
|
1336 (defconst vhdl-trailer-re
|
|
|
1337 "\\b\\(is\\|then\\|generate\\|loop\\)\\b[^_]")
|
|
|
1338
|
|
|
1339 (defconst vhdl-statement-fwd-re
|
|
|
1340 "\\b\\(if\\|for\\|while\\)\\b\\([^_]\\|\\'\\)"
|
|
|
1341 "A regular expression for searching forward that matches all known
|
|
|
1342 \"statement\" keywords.")
|
|
|
1343
|
|
|
1344 (defconst vhdl-statement-bwd-re
|
|
|
1345 "\\b\\(if\\|for\\|while\\)\\b"
|
|
|
1346 "A regular expression for searching backward that matches all known
|
|
|
1347 \"statement\" keywords.")
|
|
|
1348
|
|
|
1349 (defun vhdl-statement-p (&optional lim)
|
|
|
1350 "Return t if we are looking at a real \"statement\" keyword.
|
|
|
1351 Assumes that the caller will make sure that we are looking at
|
|
|
1352 vhdl-statement-fwd-re, and are not inside a literal, and that we are not in
|
|
|
1353 the middle of an identifier that just happens to contain a \"statement\"
|
|
|
1354 keyword."
|
|
|
1355 (cond
|
|
|
1356 ;; "for" ... "generate":
|
|
|
1357 ((and (looking-at "f")
|
|
|
1358 ;; Make sure it's the start of a parameter specification.
|
|
|
1359 (save-excursion
|
|
|
1360 (forward-sexp 2)
|
|
|
1361 (skip-chars-forward " \t\n")
|
|
|
1362 (looking-at "in\\b[^_]"))
|
|
|
1363 ;; Make sure it's not an "end for".
|
|
|
1364 (save-excursion
|
|
|
1365 (backward-sexp)
|
|
|
1366 (not (looking-at "end\\s-+\\w"))))
|
|
|
1367 t)
|
|
|
1368 ;; "if" ... "then", "if" ... "generate", "if" ... "loop":
|
|
|
1369 ((and (looking-at "i")
|
|
|
1370 ;; Make sure it's not an "end if".
|
|
|
1371 (save-excursion
|
|
|
1372 (backward-sexp)
|
|
|
1373 (not (looking-at "end\\s-+\\w"))))
|
|
|
1374 t)
|
|
|
1375 ;; "while" ... "loop":
|
|
|
1376 ((looking-at "w")
|
|
|
1377 t)
|
|
|
1378 ))
|
|
|
1379
|
|
|
1380
|
|
|
1381 ;; Core syntactic movement functions:
|
|
|
1382
|
|
|
1383 (defconst vhdl-b-t-b-re
|
|
|
1384 (concat vhdl-begin-bwd-re "\\|" vhdl-end-bwd-re))
|
|
|
1385
|
|
|
1386 (defun vhdl-backward-to-block (&optional lim)
|
|
|
1387 "Move backward to the previous \"begin\" or \"end\" keyword."
|
|
|
1388 (let (foundp)
|
|
|
1389 (while (and (not foundp)
|
|
|
1390 (re-search-backward vhdl-b-t-b-re lim 'move))
|
|
|
1391 (if (or (= (preceding-char) ?_)
|
|
|
1392 (vhdl-in-literal lim))
|
|
|
1393 (backward-char)
|
|
|
1394 (cond
|
|
|
1395 ;; "begin" keyword:
|
|
|
1396 ((and (looking-at vhdl-begin-fwd-re)
|
|
|
1397 (/= (preceding-char) ?_)
|
|
|
1398 (vhdl-begin-p lim))
|
|
|
1399 (setq foundp 'begin))
|
|
|
1400 ;; "end" keyword:
|
|
|
1401 ((and (looking-at vhdl-end-fwd-re)
|
|
|
1402 (/= (preceding-char) ?_)
|
|
|
1403 (vhdl-end-p lim))
|
|
|
1404 (setq foundp 'end))
|
|
|
1405 ))
|
|
|
1406 )
|
|
|
1407 foundp
|
|
|
1408 ))
|
|
|
1409
|
|
|
1410 (defun vhdl-forward-sexp (&optional count lim)
|
|
|
1411 "Move forward across one balanced expression (sexp).
|
|
|
1412 With COUNT, do it that many times."
|
|
|
1413 (interactive "p")
|
|
|
1414 (let ((count (or count 1))
|
|
|
1415 (case-fold-search t)
|
|
|
1416 end-vec target)
|
|
|
1417 (save-excursion
|
|
|
1418 (while (> count 0)
|
|
|
1419 ;; skip whitespace
|
|
|
1420 (skip-chars-forward " \t\n")
|
|
|
1421 ;; Check for an unbalanced "end" keyword
|
|
|
1422 (if (and (looking-at vhdl-end-fwd-re)
|
|
|
1423 (/= (preceding-char) ?_)
|
|
|
1424 (not (vhdl-in-literal lim))
|
|
|
1425 (vhdl-end-p lim)
|
|
|
1426 (not (looking-at "else")))
|
|
|
1427 (error
|
|
|
1428 "Containing expression ends prematurely in vhdl-forward-sexp"))
|
|
|
1429 ;; If the current keyword is a "begin" keyword, then find the
|
|
|
1430 ;; corresponding "end" keyword.
|
|
|
1431 (if (setq end-vec (vhdl-corresponding-end lim))
|
|
|
1432 (let (
|
|
|
1433 ;; end-re is the statement keyword to search for
|
|
|
1434 (end-re
|
|
|
1435 (concat "\\b\\(" (aref end-vec 0) "\\)\\b\\([^_]\\|\\'\\)"))
|
|
|
1436 ;; column is either the statement keyword target column
|
|
|
1437 ;; or nil
|
|
|
1438 (column (aref end-vec 1))
|
|
|
1439 (eol (vhdl-point 'eol))
|
|
|
1440 foundp literal placeholder)
|
|
|
1441 ;; Look for the statement keyword.
|
|
|
1442 (while (and (not foundp)
|
|
|
1443 (re-search-forward end-re nil t)
|
|
|
1444 (setq placeholder (match-end 1))
|
|
|
1445 (goto-char (match-beginning 0)))
|
|
|
1446 ;; If we are in a literal, or not in the right target
|
|
|
1447 ;; column and not on the same line as the begin, then
|
|
|
1448 ;; try again.
|
|
|
1449 (if (or (and column
|
|
|
1450 (/= (current-indentation) column)
|
|
|
1451 (> (point) eol))
|
|
|
1452 (= (preceding-char) ?_)
|
|
|
1453 (setq literal (vhdl-in-literal lim)))
|
|
|
1454 (if (eq literal 'comment)
|
|
|
1455 (end-of-line)
|
|
|
1456 (forward-char))
|
|
|
1457 ;; An "else" keyword corresponds to both the opening brace
|
|
|
1458 ;; of the following sexp and the closing brace of the
|
|
|
1459 ;; previous sexp.
|
|
|
1460 (if (not (looking-at "else"))
|
|
|
1461 (goto-char placeholder))
|
|
|
1462 (setq foundp t))
|
|
|
1463 )
|
|
|
1464 (if (not foundp)
|
|
|
1465 (error "Unbalanced keywords in vhdl-forward-sexp"))
|
|
|
1466 )
|
|
|
1467 ;; If the current keyword is not a "begin" keyword, then just
|
|
|
1468 ;; perform the normal forward-sexp.
|
|
|
1469 (forward-sexp)
|
|
|
1470 )
|
|
|
1471 (setq count (1- count))
|
|
|
1472 )
|
|
|
1473 (setq target (point)))
|
|
|
1474 (goto-char target)
|
|
|
1475 nil))
|
|
|
1476
|
|
|
1477 (defun vhdl-backward-sexp (&optional count lim)
|
|
|
1478 "Move backward across one balanced expression (sexp).
|
|
|
1479 With COUNT, do it that many times. LIM bounds any required backward
|
|
|
1480 searches."
|
|
|
1481 (interactive "p")
|
|
|
1482 (let ((count (or count 1))
|
|
|
1483 (case-fold-search t)
|
|
|
1484 begin-vec target)
|
|
|
1485 (save-excursion
|
|
|
1486 (while (> count 0)
|
|
|
1487 ;; Perform the normal backward-sexp, unless we are looking at
|
|
|
1488 ;; "else" - an "else" keyword corresponds to both the opening brace
|
|
|
1489 ;; of the following sexp and the closing brace of the previous sexp.
|
|
|
1490 (if (and (looking-at "else\\b\\([^_]\\|\\'\\)")
|
|
|
1491 (/= (preceding-char) ?_)
|
|
|
1492 (not (vhdl-in-literal lim)))
|
|
|
1493 nil
|
|
|
1494 (backward-sexp)
|
|
|
1495 (if (and (looking-at vhdl-begin-fwd-re)
|
|
|
1496 (/= (preceding-char) ?_)
|
|
|
1497 (not (vhdl-in-literal lim))
|
|
|
1498 (vhdl-begin-p lim))
|
|
|
1499 (error "Containing expression ends prematurely in vhdl-backward-sexp")))
|
|
|
1500 ;; If the current keyword is an "end" keyword, then find the
|
|
|
1501 ;; corresponding "begin" keyword.
|
|
|
1502 (if (and (setq begin-vec (vhdl-corresponding-begin lim))
|
|
|
1503 (/= (preceding-char) ?_))
|
|
|
1504 (let (
|
|
|
1505 ;; begin-re is the statement keyword to search for
|
|
|
1506 (begin-re
|
|
|
1507 (concat "\\b\\(" (aref begin-vec 0) "\\)\\b[^_]"))
|
|
|
1508 ;; column is either the statement keyword target column
|
|
|
1509 ;; or nil
|
|
|
1510 (column (aref begin-vec 1))
|
|
|
1511 ;; internal-p controls where the statement keyword can
|
|
|
1512 ;; be found.
|
|
|
1513 (internal-p (aref begin-vec 3))
|
|
|
1514 (last-backward (point)) last-forward
|
|
|
1515 foundp literal keyword)
|
|
|
1516 ;; Look for the statement keyword.
|
|
|
1517 (while (and (not foundp)
|
|
|
1518 (re-search-backward begin-re lim t)
|
|
|
1519 (setq keyword
|
|
|
1520 (buffer-substring (match-beginning 1)
|
|
|
1521 (match-end 1))))
|
|
|
1522 ;; If we are in a literal or in the wrong column,
|
|
|
1523 ;; then try again.
|
|
|
1524 (if (or (and column
|
|
|
1525 (and (/= (current-indentation) column)
|
|
|
1526 ;; possibly accept current-column as
|
|
|
1527 ;; well as current-indentation.
|
|
|
1528 (or (not internal-p)
|
|
|
1529 (/= (current-column) column))))
|
|
|
1530 (= (preceding-char) ?_)
|
|
|
1531 (vhdl-in-literal lim))
|
|
|
1532 (backward-char)
|
|
|
1533 ;; If there is a supplementary keyword, then
|
|
|
1534 ;; search forward for it.
|
|
|
1535 (if (and (setq begin-re (aref begin-vec 2))
|
|
|
1536 (or (not (listp begin-re))
|
|
|
1537 ;; If begin-re is an alist, then find the
|
|
|
1538 ;; element corresponding to the actual
|
|
|
1539 ;; keyword that we found.
|
|
|
1540 (progn
|
|
|
1541 (setq begin-re
|
|
|
1542 (assoc keyword begin-re))
|
|
|
1543 (and begin-re
|
|
|
1544 (setq begin-re (cdr begin-re))))))
|
|
|
1545 (and
|
|
|
1546 (setq begin-re
|
|
|
1547 (concat "\\b\\(" begin-re "\\)\\b[^_]"))
|
|
|
1548 (save-excursion
|
|
|
1549 (setq last-forward (point))
|
|
|
1550 ;; Look for the supplementary keyword
|
|
|
1551 ;; (bounded by the backward search start
|
|
|
1552 ;; point).
|
|
|
1553 (while (and (not foundp)
|
|
|
1554 (re-search-forward begin-re
|
|
|
1555 last-backward t)
|
|
|
1556 (goto-char (match-beginning 1)))
|
|
|
1557 ;; If we are in a literal, then try again.
|
|
|
1558 (if (or (= (preceding-char) ?_)
|
|
|
1559 (setq literal
|
|
|
1560 (vhdl-in-literal last-forward)))
|
|
|
1561 (if (eq literal 'comment)
|
|
|
1562 (goto-char
|
|
|
1563 (min (vhdl-point 'eol) last-backward))
|
|
|
1564 (forward-char))
|
|
|
1565 ;; We have found the supplementary keyword.
|
|
|
1566 ;; Save the position of the keyword in foundp.
|
|
|
1567 (setq foundp (point)))
|
|
|
1568 )
|
|
|
1569 foundp)
|
|
|
1570 ;; If the supplementary keyword was found, then
|
|
|
1571 ;; move point to the supplementary keyword.
|
|
|
1572 (goto-char foundp))
|
|
|
1573 ;; If there was no supplementary keyword, then
|
|
|
1574 ;; point is already at the statement keyword.
|
|
|
1575 (setq foundp t)))
|
|
|
1576 ) ; end of the search for the statement keyword
|
|
|
1577 (if (not foundp)
|
|
|
1578 (error "Unbalanced keywords in vhdl-backward-sexp"))
|
|
|
1579 ))
|
|
|
1580 (setq count (1- count))
|
|
|
1581 )
|
|
|
1582 (setq target (point)))
|
|
|
1583 (goto-char target)
|
|
|
1584 nil))
|
|
|
1585
|
|
|
1586 (defun vhdl-backward-up-list (&optional count limit)
|
|
|
1587 "Move backward out of one level of blocks.
|
|
|
1588 With argument, do this that many times."
|
|
|
1589 (interactive "p")
|
|
|
1590 (let ((count (or count 1))
|
|
|
1591 target)
|
|
|
1592 (save-excursion
|
|
|
1593 (while (> count 0)
|
|
|
1594 (if (looking-at vhdl-defun-re)
|
|
|
1595 (error "Unbalanced blocks"))
|
|
|
1596 (vhdl-backward-to-block limit)
|
|
|
1597 (setq count (1- count)))
|
|
|
1598 (setq target (point)))
|
|
|
1599 (goto-char target)))
|
|
|
1600
|
|
|
1601 (defun vhdl-end-of-defun (&optional count)
|
|
|
1602 "Move forward to the end of a VHDL defun."
|
|
|
1603 (interactive)
|
|
|
1604 (let ((case-fold-search t))
|
|
|
1605 (vhdl-beginning-of-defun)
|
|
|
1606 (if (not (looking-at "block\\|process"))
|
|
|
1607 (re-search-forward "\\bis\\b"))
|
|
|
1608 (vhdl-forward-sexp)))
|
|
|
1609
|
|
|
1610 (defun vhdl-mark-defun ()
|
|
|
1611 "Put mark at end of this \"defun\", point at beginning."
|
|
|
1612 (interactive)
|
|
|
1613 (let ((case-fold-search t))
|
|
|
1614 (push-mark)
|
|
|
1615 (vhdl-beginning-of-defun)
|
|
|
1616 (push-mark)
|
|
|
1617 (if (not (looking-at "block\\|process"))
|
|
|
1618 (re-search-forward "\\bis\\b"))
|
|
|
1619 (vhdl-forward-sexp)
|
|
|
1620 (exchange-point-and-mark)))
|
|
|
1621
|
|
|
1622 (defun vhdl-beginning-of-libunit ()
|
|
|
1623 "Move backward to the beginning of a VHDL library unit.
|
|
|
1624 Returns the location of the corresponding begin keyword, unless search
|
|
|
1625 stops due to beginning or end of buffer."
|
|
|
1626 ;; Note that if point is between the "libunit" keyword and the
|
|
|
1627 ;; corresponding "begin" keyword, then that libunit will not be
|
|
|
1628 ;; recognised, and the search will continue backwards. If point is
|
|
|
1629 ;; at the "begin" keyword, then the defun will be recognised. The
|
|
|
1630 ;; returned point is at the first character of the "libunit" keyword.
|
|
|
1631 (let ((last-forward (point))
|
|
|
1632 (last-backward
|
|
|
1633 ;; Just in case we are actually sitting on the "begin"
|
|
|
1634 ;; keyword, allow for the keyword and an extra character,
|
|
|
1635 ;; as this will be used when looking forward for the
|
|
|
1636 ;; "begin" keyword.
|
|
|
1637 (save-excursion (forward-word 1) (1+ (point))))
|
|
|
1638 foundp literal placeholder)
|
|
|
1639 ;; Find the "libunit" keyword.
|
|
|
1640 (while (and (not foundp)
|
|
|
1641 (re-search-backward vhdl-libunit-re nil 'move))
|
|
|
1642 ;; If we are in a literal, or not at a real libunit, then try again.
|
|
|
1643 (if (or (= (preceding-char) ?_)
|
|
|
1644 (vhdl-in-literal (point-min))
|
|
|
1645 (not (vhdl-libunit-p)))
|
|
|
1646 (backward-char)
|
|
|
1647 ;; Find the corresponding "begin" keyword.
|
|
|
1648 (setq last-forward (point))
|
|
|
1649 (while (and (not foundp)
|
|
|
1650 (re-search-forward "\\bis\\b[^_]" last-backward t)
|
|
|
1651 (setq placeholder (match-beginning 0)))
|
|
|
1652 (if (or (= (preceding-char) ?_)
|
|
|
1653 (setq literal (vhdl-in-literal last-forward)))
|
|
|
1654 ;; It wasn't a real keyword, so keep searching.
|
|
|
1655 (if (eq literal 'comment)
|
|
|
1656 (goto-char
|
|
|
1657 (min (vhdl-point 'eol) last-backward))
|
|
|
1658 (forward-char))
|
|
|
1659 ;; We have found the begin keyword, loop will exit.
|
|
|
1660 (setq foundp placeholder)))
|
|
|
1661 ;; Go back to the libunit keyword
|
|
|
1662 (goto-char last-forward)))
|
|
|
1663 foundp))
|
|
|
1664
|
|
|
1665 (defun vhdl-beginning-of-defun (&optional count)
|
|
|
1666 "Move backward to the beginning of a VHDL defun.
|
|
|
1667 With argument, do it that many times.
|
|
|
1668 Returns the location of the corresponding begin keyword, unless search
|
|
|
1669 stops due to beginning or end of buffer."
|
|
|
1670 ;; Note that if point is between the "defun" keyword and the
|
|
|
1671 ;; corresponding "begin" keyword, then that defun will not be
|
|
|
1672 ;; recognised, and the search will continue backwards. If point is
|
|
|
1673 ;; at the "begin" keyword, then the defun will be recognised. The
|
|
|
1674 ;; returned point is at the first character of the "defun" keyword.
|
|
|
1675 (interactive "p")
|
|
|
1676 (let ((count (or count 1))
|
|
|
1677 (case-fold-search t)
|
|
|
1678 (last-forward (point))
|
|
|
1679 foundp)
|
|
|
1680 (while (> count 0)
|
|
|
1681 (setq foundp nil)
|
|
|
1682 (goto-char last-forward)
|
|
|
1683 (let ((last-backward
|
|
|
1684 ;; Just in case we are actually sitting on the "begin"
|
|
|
1685 ;; keyword, allow for the keyword and an extra character,
|
|
|
1686 ;; as this will be used when looking forward for the
|
|
|
1687 ;; "begin" keyword.
|
|
|
1688 (save-excursion (forward-word 1) (1+ (point))))
|
|
|
1689 begin-string literal)
|
|
|
1690 (while (and (not foundp)
|
|
|
1691 (re-search-backward vhdl-defun-re nil 'move))
|
|
|
1692 ;; If we are in a literal, then try again.
|
|
|
1693 (if (or (= (preceding-char) ?_)
|
|
|
1694 (vhdl-in-literal (point-min)))
|
|
|
1695 (backward-char)
|
|
|
1696 (if (setq begin-string (vhdl-corresponding-defun))
|
|
|
1697 ;; This is a real defun keyword.
|
|
|
1698 ;; Find the corresponding "begin" keyword.
|
|
|
1699 ;; Look for the begin keyword.
|
|
|
1700 (progn
|
|
|
1701 ;; Save the search start point.
|
|
|
1702 (setq last-forward (point))
|
|
|
1703 (while (and (not foundp)
|
|
|
1704 (search-forward begin-string last-backward t))
|
|
|
1705 (if (or (= (preceding-char) ?_)
|
|
|
1706 (save-match-data
|
|
|
1707 (setq literal (vhdl-in-literal last-forward))))
|
|
|
1708 ;; It wasn't a real keyword, so keep searching.
|
|
|
1709 (if (eq literal 'comment)
|
|
|
1710 (goto-char
|
|
|
1711 (min (vhdl-point 'eol) last-backward))
|
|
|
1712 (forward-char))
|
|
|
1713 ;; We have found the begin keyword, loop will exit.
|
|
|
1714 (setq foundp (match-beginning 0)))
|
|
|
1715 )
|
|
|
1716 ;; Go back to the defun keyword
|
|
|
1717 (goto-char last-forward)) ; end search for begin keyword
|
|
|
1718 ))
|
|
|
1719 ) ; end of the search for the defun keyword
|
|
|
1720 )
|
|
|
1721 (setq count (1- count))
|
|
|
1722 )
|
|
|
1723 (vhdl-keep-region-active)
|
|
|
1724 foundp))
|
|
|
1725
|
|
|
1726 (defun vhdl-beginning-of-statement (&optional count lim)
|
|
|
1727 "Go to the beginning of the innermost VHDL statement.
|
|
|
1728 With prefix arg, go back N - 1 statements. If already at the
|
|
|
1729 beginning of a statement then go to the beginning of the preceding
|
|
|
1730 one. If within a string or comment, or next to a comment (only
|
|
|
1731 whitespace between), move by sentences instead of statements.
|
|
|
1732
|
|
|
1733 When called from a program, this function takes 2 optional args: the
|
|
|
1734 prefix arg, and a buffer position limit which is the farthest back to
|
|
|
1735 search."
|
|
|
1736 (interactive "p")
|
|
|
1737 (let ((count (or count 1))
|
|
|
1738 (case-fold-search t)
|
|
|
1739 (lim (or lim (point-min)))
|
|
|
1740 (here (point))
|
|
|
1741 state)
|
|
|
1742 (save-excursion
|
|
|
1743 (goto-char lim)
|
|
|
1744 (setq state (parse-partial-sexp (point) here nil nil)))
|
|
|
1745 (if (and (interactive-p)
|
|
|
1746 (or (nth 3 state)
|
|
|
1747 (nth 4 state)
|
|
|
1748 (looking-at (concat "[ \t]*" comment-start-skip))))
|
|
|
1749 (forward-sentence (- count))
|
|
|
1750 (while (> count 0)
|
|
|
1751 (vhdl-beginning-of-statement-1 lim)
|
|
|
1752 (setq count (1- count))))
|
|
|
1753 ;; its possible we've been left up-buf of lim
|
|
|
1754 (goto-char (max (point) lim))
|
|
|
1755 )
|
|
|
1756 (vhdl-keep-region-active))
|
|
|
1757
|
|
|
1758 (defconst vhdl-b-o-s-re
|
|
|
1759 (concat ";\\|\(\\|\)\\|\\bwhen\\b[^_]\\|"
|
|
|
1760 vhdl-begin-bwd-re "\\|" vhdl-statement-bwd-re))
|
|
|
1761
|
|
|
1762 (defun vhdl-beginning-of-statement-1 (&optional lim)
|
|
|
1763 ;; move to the start of the current statement, or the previous
|
|
|
1764 ;; statement if already at the beginning of one.
|
|
|
1765 (let ((lim (or lim (point-min)))
|
|
|
1766 (here (point))
|
|
|
1767 (pos (point))
|
|
|
1768 donep)
|
|
|
1769 ;; go backwards one balanced expression, but be careful of
|
|
|
1770 ;; unbalanced paren being reached
|
|
|
1771 (if (not (vhdl-safe (progn (backward-sexp) t)))
|
|
|
1772 (progn
|
|
|
1773 (backward-up-list 1)
|
|
|
1774 (forward-char)
|
|
|
1775 (vhdl-forward-syntactic-ws here)
|
|
|
1776 (setq donep t)))
|
|
|
1777 (while (and (not donep)
|
|
|
1778 (not (bobp))
|
|
|
1779 ;; look backwards for a statement boundary
|
|
|
1780 (re-search-backward vhdl-b-o-s-re lim 'move))
|
|
|
1781 (if (or (= (preceding-char) ?_)
|
|
|
1782 (vhdl-in-literal lim))
|
|
|
1783 (backward-char)
|
|
|
1784 (cond
|
|
|
1785 ;; If we are looking at an open paren, then stop after it
|
|
|
1786 ((eq (following-char) ?\()
|
|
|
1787 (forward-char)
|
|
|
1788 (vhdl-forward-syntactic-ws here)
|
|
|
1789 (setq donep t))
|
|
|
1790 ;; If we are looking at a close paren, then skip it
|
|
|
1791 ((eq (following-char) ?\))
|
|
|
1792 (forward-char)
|
|
|
1793 (setq pos (point))
|
|
|
1794 (backward-sexp)
|
|
|
1795 (if (< (point) lim)
|
|
|
1796 (progn (goto-char pos)
|
|
|
1797 (vhdl-forward-syntactic-ws here)
|
|
|
1798 (setq donep t))))
|
|
|
1799 ;; If we are looking at a semicolon, then stop
|
|
|
1800 ((eq (following-char) ?\;)
|
|
|
1801 (progn
|
|
|
1802 (forward-char)
|
|
|
1803 (vhdl-forward-syntactic-ws here)
|
|
|
1804 (setq donep t)))
|
|
|
1805 ;; If we are looking at a "begin", then stop
|
|
|
1806 ((and (looking-at vhdl-begin-fwd-re)
|
|
|
1807 (/= (preceding-char) ?_)
|
|
|
1808 (vhdl-begin-p nil))
|
|
|
1809 ;; If it's a leader "begin", then find the
|
|
|
1810 ;; right place
|
|
|
1811 (if (looking-at vhdl-leader-re)
|
|
|
1812 (save-excursion
|
|
|
1813 ;; set a default stop point at the begin
|
|
|
1814 (setq pos (point))
|
|
|
1815 ;; is the start point inside the leader area ?
|
|
|
1816 (goto-char (vhdl-end-of-leader))
|
|
|
1817 (vhdl-forward-syntactic-ws here)
|
|
|
1818 (if (< (point) here)
|
|
|
1819 ;; start point was not inside leader area
|
|
|
1820 ;; set stop point at word after leader
|
|
|
1821 (setq pos (point))))
|
|
|
1822 (forward-word 1)
|
|
|
1823 (vhdl-forward-syntactic-ws here)
|
|
|
1824 (setq pos (point)))
|
|
|
1825 (goto-char pos)
|
|
|
1826 (setq donep t))
|
|
|
1827 ;; If we are looking at a "statement", then stop
|
|
|
1828 ((and (looking-at vhdl-statement-fwd-re)
|
|
|
1829 (/= (preceding-char) ?_)
|
|
|
1830 (vhdl-statement-p nil))
|
|
|
1831 (setq donep t))
|
|
|
1832 ;; If we are looking at a case alternative key, then stop
|
|
|
1833 ((looking-at vhdl-case-alternative-key)
|
|
|
1834 (save-excursion
|
|
|
1835 ;; set a default stop point at the when
|
|
|
1836 (setq pos (point))
|
|
|
1837 ;; is the start point inside the case alternative key ?
|
|
|
1838 (goto-char (match-end 0))
|
|
|
1839 (vhdl-forward-syntactic-ws here)
|
|
|
1840 (if (< (point) here)
|
|
|
1841 ;; start point was not inside the case alternative key
|
|
|
1842 ;; set stop point at word after case alternative keyleader
|
|
|
1843 (setq pos (point))))
|
|
|
1844 (goto-char pos)
|
|
|
1845 (setq donep t))
|
|
|
1846 ;; Bogus find, continue
|
|
|
1847 (t
|
|
|
1848 (backward-char)))))
|
|
|
1849 ))
|
|
|
1850
|
|
|
1851
|
|
|
1852 ;; Defuns for calculating the current syntactic state:
|
|
|
1853
|
|
|
1854 (defun vhdl-get-library-unit (bod placeholder)
|
|
|
1855 ;; If there is an enclosing library unit at bod, with it's \"begin\"
|
|
|
1856 ;; keyword at placeholder, then return the library unit type.
|
|
|
1857 (let ((here (vhdl-point 'bol)))
|
|
|
1858 (if (save-excursion
|
|
|
1859 (goto-char placeholder)
|
|
|
1860 (vhdl-safe (vhdl-forward-sexp 1 bod))
|
|
|
1861 (<= here (point)))
|
|
|
1862 (save-excursion
|
|
|
1863 (goto-char bod)
|
|
|
1864 (cond
|
|
|
1865 ((looking-at "e") 'entity)
|
|
|
1866 ((looking-at "a") 'architecture)
|
|
|
1867 ((looking-at "c") 'configuration)
|
|
|
1868 ((looking-at "p")
|
|
|
1869 (save-excursion
|
|
|
1870 (goto-char bod)
|
|
|
1871 (forward-sexp)
|
|
|
1872 (vhdl-forward-syntactic-ws here)
|
|
|
1873 (if (looking-at "body\\b[^_]")
|
|
|
1874 'package-body 'package))))))
|
|
|
1875 ))
|
|
|
1876
|
|
|
1877 (defun vhdl-get-block-state (&optional lim)
|
|
|
1878 ;; Finds and records all the closest opens.
|
|
|
1879 ;; lim is the furthest back we need to search (it should be the
|
|
|
1880 ;; previous libunit keyword).
|
|
|
1881 (let ((here (point))
|
|
|
1882 (lim (or lim (point-min)))
|
|
|
1883 keyword sexp-start sexp-mid sexp-end
|
|
|
1884 preceding-sexp containing-sexp
|
|
|
1885 containing-begin containing-mid containing-paren)
|
|
|
1886 (save-excursion
|
|
|
1887 ;; Find the containing-paren, and use that as the limit
|
|
|
1888 (if (setq containing-paren
|
|
|
1889 (save-restriction
|
|
|
1890 (narrow-to-region lim (point))
|
|
|
1891 (vhdl-safe (scan-lists (point) -1 1))))
|
|
|
1892 (setq lim containing-paren))
|
|
|
1893 ;; Look backwards for "begin" and "end" keywords.
|
|
|
1894 (while (and (> (point) lim)
|
|
|
1895 (not containing-sexp))
|
|
|
1896 (setq keyword (vhdl-backward-to-block lim))
|
|
|
1897 (cond
|
|
|
1898 ((eq keyword 'begin)
|
|
|
1899 ;; Found a "begin" keyword
|
|
|
1900 (setq sexp-start (point))
|
|
|
1901 (setq sexp-mid (vhdl-corresponding-mid lim))
|
|
|
1902 (setq sexp-end (vhdl-safe
|
|
|
1903 (save-excursion
|
|
|
1904 (vhdl-forward-sexp 1 lim) (point))))
|
|
|
1905 (if (and sexp-end (<= sexp-end here))
|
|
|
1906 ;; we want to record this sexp, but we only want to
|
|
|
1907 ;; record the last-most of any of them before here
|
|
|
1908 (or preceding-sexp
|
|
|
1909 (setq preceding-sexp sexp-start))
|
|
|
1910 ;; we're contained in this sexp so put sexp-start on
|
|
|
1911 ;; front of list
|
|
|
1912 (setq containing-sexp sexp-start)
|
|
|
1913 (setq containing-mid sexp-mid)
|
|
|
1914 (setq containing-begin t)))
|
|
|
1915 ((eq keyword 'end)
|
|
|
1916 ;; Found an "end" keyword
|
|
|
1917 (forward-sexp)
|
|
|
1918 (setq sexp-end (point))
|
|
|
1919 (setq sexp-mid nil)
|
|
|
1920 (setq sexp-start
|
|
|
1921 (or (vhdl-safe (vhdl-backward-sexp 1 lim) (point))
|
|
|
1922 (progn (backward-sexp) (point))))
|
|
|
1923 ;; we want to record this sexp, but we only want to
|
|
|
1924 ;; record the last-most of any of them before here
|
|
|
1925 (or preceding-sexp
|
|
|
1926 (setq preceding-sexp sexp-start)))
|
|
|
1927 )))
|
|
|
1928 ;; Check if the containing-paren should be the containing-sexp
|
|
|
1929 (if (and containing-paren
|
|
|
1930 (or (null containing-sexp)
|
|
|
1931 (< containing-sexp containing-paren)))
|
|
|
1932 (setq containing-sexp containing-paren
|
|
|
1933 preceding-sexp nil
|
|
|
1934 containing-begin nil
|
|
|
1935 containing-mid nil))
|
|
|
1936 (vector containing-sexp preceding-sexp containing-begin containing-mid)
|
|
|
1937 ))
|
|
|
1938
|
|
|
1939
|
|
|
1940 (defconst vhdl-s-c-a-re
|
|
|
1941 (concat vhdl-case-alternative-key "\\|" vhdl-case-header-key))
|
|
|
1942
|
|
|
1943 (defun vhdl-skip-case-alternative (&optional lim)
|
|
|
1944 ;; skip forward over case/when bodies, with optional maximal
|
|
|
1945 ;; limit. if no next case alternative is found, nil is returned and point
|
|
|
1946 ;; is not moved
|
|
|
1947 (let ((lim (or lim (point-max)))
|
|
|
1948 (here (point))
|
|
|
1949 donep foundp)
|
|
|
1950 (while (and (< (point) lim)
|
|
|
1951 (not donep))
|
|
|
1952 (if (and (re-search-forward vhdl-s-c-a-re lim 'move)
|
|
|
1953 (save-match-data
|
|
|
1954 (not (vhdl-in-literal)))
|
|
|
1955 (/= (match-beginning 0) here))
|
|
|
1956 (progn
|
|
|
1957 (goto-char (match-beginning 0))
|
|
|
1958 (cond
|
|
|
1959 ((and (looking-at "case")
|
|
|
1960 (re-search-forward "\\bis[^_]" lim t))
|
|
|
1961 (backward-sexp)
|
|
|
1962 (vhdl-forward-sexp))
|
|
|
1963 (t
|
|
|
1964 (setq donep t
|
|
|
1965 foundp t))))))
|
|
|
1966 (if (not foundp)
|
|
|
1967 (goto-char here))
|
|
|
1968 foundp))
|
|
|
1969
|
|
|
1970 (defun vhdl-backward-skip-label (&optional lim)
|
|
|
1971 ;; skip backward over a label, with optional maximal
|
|
|
1972 ;; limit. if label is found, nil is returned and point
|
|
|
1973 ;; is not moved
|
|
|
1974 (let ((lim (or lim (point-min)))
|
|
|
1975 placeholder)
|
|
|
1976 (if (save-excursion
|
|
|
1977 (vhdl-backward-syntactic-ws lim)
|
|
|
1978 (and (eq (preceding-char) ?:)
|
|
|
1979 (progn
|
|
|
1980 (backward-sexp)
|
|
|
1981 (setq placeholder (point))
|
|
|
1982 (looking-at vhdl-label-key))))
|
|
|
1983 (goto-char placeholder))
|
|
|
1984 ))
|
|
|
1985
|
|
|
1986 (defun vhdl-get-syntactic-context ()
|
|
|
1987 ;; guess the syntactic description of the current line of VHDL code.
|
|
|
1988 (save-excursion
|
|
|
1989 (save-restriction
|
|
|
1990 (beginning-of-line)
|
|
|
1991 (let* ((indent-point (point))
|
|
|
1992 (case-fold-search t)
|
|
|
1993 vec literal containing-sexp preceding-sexp
|
|
|
1994 containing-begin containing-mid containing-leader
|
|
|
1995 char-before-ip char-after-ip begin-after-ip end-after-ip
|
|
|
1996 placeholder lim library-unit
|
|
|
1997 )
|
|
|
1998
|
|
|
1999 ;; Reset the syntactic context
|
|
|
2000 (setq vhdl-syntactic-context nil)
|
|
|
2001
|
|
|
2002 (save-excursion
|
|
|
2003 ;; Move to the start of the previous library unit, and
|
|
|
2004 ;; record the position of the "begin" keyword.
|
|
|
2005 (setq placeholder (vhdl-beginning-of-libunit))
|
|
|
2006 ;; The position of the "libunit" keyword gives us a gross
|
|
|
2007 ;; limit point.
|
|
|
2008 (setq lim (point))
|
|
|
2009 )
|
|
|
2010
|
|
|
2011 ;; If there is a previous library unit, and we are enclosed by
|
|
|
2012 ;; it, then set the syntax accordingly.
|
|
|
2013 (and placeholder
|
|
|
2014 (setq library-unit (vhdl-get-library-unit lim placeholder))
|
|
|
2015 (vhdl-add-syntax library-unit lim))
|
|
|
2016
|
|
|
2017 ;; Find the surrounding state.
|
|
|
2018 (if (setq vec (vhdl-get-block-state lim))
|
|
|
2019 (progn
|
|
|
2020 (setq containing-sexp (aref vec 0))
|
|
|
2021 (setq preceding-sexp (aref vec 1))
|
|
|
2022 (setq containing-begin (aref vec 2))
|
|
|
2023 (setq containing-mid (aref vec 3))
|
|
|
2024 ))
|
|
|
2025
|
|
|
2026 ;; set the limit on the farthest back we need to search
|
|
|
2027 (setq lim (if containing-sexp
|
|
|
2028 (save-excursion
|
|
|
2029 (goto-char containing-sexp)
|
|
|
2030 ;; set containing-leader if required
|
|
|
2031 (if (looking-at vhdl-leader-re)
|
|
|
2032 (setq containing-leader (vhdl-end-of-leader)))
|
|
|
2033 (vhdl-point 'bol))
|
|
|
2034 (point-min)))
|
|
|
2035
|
|
|
2036 ;; cache char before and after indent point, and move point to
|
|
|
2037 ;; the most likely position to perform the majority of tests
|
|
|
2038 (goto-char indent-point)
|
|
|
2039 (skip-chars-forward " \t")
|
|
|
2040 (setq literal (vhdl-in-literal lim))
|
|
|
2041 (setq char-after-ip (following-char))
|
|
|
2042 (setq begin-after-ip (and
|
|
|
2043 (not literal)
|
|
|
2044 (looking-at vhdl-begin-fwd-re)
|
|
|
2045 (vhdl-begin-p)))
|
|
|
2046 (setq end-after-ip (and
|
|
|
2047 (not literal)
|
|
|
2048 (looking-at vhdl-end-fwd-re)
|
|
|
2049 (vhdl-end-p)))
|
|
|
2050 (vhdl-backward-syntactic-ws lim)
|
|
|
2051 (setq char-before-ip (preceding-char))
|
|
|
2052 (goto-char indent-point)
|
|
|
2053 (skip-chars-forward " \t")
|
|
|
2054
|
|
|
2055 ;; now figure out syntactic qualities of the current line
|
|
|
2056 (cond
|
|
|
2057 ;; CASE 1: in a string or comment.
|
|
|
2058 ((memq literal '(string comment))
|
|
|
2059 (vhdl-add-syntax literal (vhdl-point 'bopl)))
|
|
|
2060 ;; CASE 2: Line is at top level.
|
|
|
2061 ((null containing-sexp)
|
|
|
2062 ;; Find the point to which indentation will be relative
|
|
|
2063 (save-excursion
|
|
|
2064 (if (null preceding-sexp)
|
|
|
2065 ;; CASE 2X.1
|
|
|
2066 ;; no preceding-sexp -> use the preceding statement
|
|
|
2067 (vhdl-beginning-of-statement-1 lim)
|
|
|
2068 ;; CASE 2X.2
|
|
|
2069 ;; if there is a preceding-sexp then indent relative to it
|
|
|
2070 (goto-char preceding-sexp)
|
|
|
2071 ;; if not at boi, then the block-opening keyword is
|
|
|
2072 ;; probably following a label, so we need a different
|
|
|
2073 ;; relpos
|
|
|
2074 (if (/= (point) (vhdl-point 'boi))
|
|
|
2075 ;; CASE 2X.3
|
|
|
2076 (vhdl-beginning-of-statement-1 lim)))
|
|
|
2077 ;; v-b-o-s could have left us at point-min
|
|
|
2078 (and (bobp)
|
|
|
2079 ;; CASE 2X.4
|
|
|
2080 (vhdl-forward-syntactic-ws indent-point))
|
|
|
2081 (setq placeholder (point)))
|
|
|
2082 (cond
|
|
|
2083 ;; CASE 2A : we are looking at a block-open
|
|
|
2084 (begin-after-ip
|
|
|
2085 (vhdl-add-syntax 'block-open placeholder))
|
|
|
2086 ;; CASE 2B: we are looking at a block-close
|
|
|
2087 (end-after-ip
|
|
|
2088 (vhdl-add-syntax 'block-close placeholder))
|
|
|
2089 ;; CASE 2C: we are looking at a top-level statement
|
|
|
2090 ((progn
|
|
|
2091 (vhdl-backward-syntactic-ws lim)
|
|
|
2092 (or (bobp)
|
|
|
2093 (= (preceding-char) ?\;)))
|
|
|
2094 (vhdl-add-syntax 'statement placeholder))
|
|
|
2095 ;; CASE 2D: we are looking at a top-level statement-cont
|
|
|
2096 (t
|
|
|
2097 (vhdl-beginning-of-statement-1 lim)
|
|
|
2098 ;; v-b-o-s could have left us at point-min
|
|
|
2099 (and (bobp)
|
|
|
2100 ;; CASE 2D.1
|
|
|
2101 (vhdl-forward-syntactic-ws indent-point))
|
|
|
2102 (vhdl-add-syntax 'statement-cont (point)))
|
|
|
2103 )) ; end CASE 2
|
|
|
2104 ;; CASE 3: line is inside parentheses. Most likely we are
|
|
|
2105 ;; either in a subprogram argument (interface) list, or a
|
|
|
2106 ;; continued expression containing parentheses.
|
|
|
2107 ((null containing-begin)
|
|
|
2108 (vhdl-backward-syntactic-ws containing-sexp)
|
|
|
2109 (cond
|
|
|
2110 ;; CASE 3A: we are looking at the arglist closing paren
|
|
|
2111 ((eq char-after-ip ?\))
|
|
|
2112 (goto-char containing-sexp)
|
|
|
2113 (vhdl-add-syntax 'arglist-close (vhdl-point 'boi)))
|
|
|
2114 ;; CASE 3B: we are looking at the first argument in an empty
|
|
|
2115 ;; argument list.
|
|
|
2116 ((eq char-before-ip ?\()
|
|
|
2117 (goto-char containing-sexp)
|
|
|
2118 (vhdl-add-syntax 'arglist-intro (vhdl-point 'boi)))
|
|
|
2119 ;; CASE 3C: we are looking at an arglist continuation line,
|
|
|
2120 ;; but the preceding argument is on the same line as the
|
|
|
2121 ;; opening paren. This case includes multi-line
|
|
|
2122 ;; expression paren groupings.
|
|
|
2123 ((and (save-excursion
|
|
|
2124 (goto-char (1+ containing-sexp))
|
|
|
2125 (skip-chars-forward " \t")
|
|
|
2126 (not (eolp))
|
|
|
2127 (not (looking-at "--")))
|
|
|
2128 (save-excursion
|
|
|
2129 (vhdl-beginning-of-statement-1 containing-sexp)
|
|
|
2130 (skip-chars-backward " \t(")
|
|
|
2131 (<= (point) containing-sexp)))
|
|
|
2132 (goto-char containing-sexp)
|
|
|
2133 (vhdl-add-syntax 'arglist-cont-nonempty (vhdl-point 'boi)))
|
|
|
2134 ;; CASE 3D: we are looking at just a normal arglist
|
|
|
2135 ;; continuation line
|
|
|
2136 (t (vhdl-beginning-of-statement-1 containing-sexp)
|
|
|
2137 (vhdl-forward-syntactic-ws indent-point)
|
|
|
2138 (vhdl-add-syntax 'arglist-cont (vhdl-point 'boi)))
|
|
|
2139 ))
|
|
|
2140 ;; CASE 4: A block mid open
|
|
|
2141 ((and begin-after-ip
|
|
|
2142 (looking-at containing-mid))
|
|
|
2143 (goto-char containing-sexp)
|
|
|
2144 ;; If the \"begin\" keyword is a trailer, then find v-b-o-s
|
|
|
2145 (if (looking-at vhdl-trailer-re)
|
|
|
2146 ;; CASE 4.1
|
|
|
2147 (progn (forward-sexp) (vhdl-beginning-of-statement-1 nil)))
|
|
|
2148 (vhdl-backward-skip-label (vhdl-point 'boi))
|
|
|
2149 (vhdl-add-syntax 'block-open (point)))
|
|
|
2150 ;; CASE 5: block close brace
|
|
|
2151 (end-after-ip
|
|
|
2152 (goto-char containing-sexp)
|
|
|
2153 ;; If the \"begin\" keyword is a trailer, then find v-b-o-s
|
|
|
2154 (if (looking-at vhdl-trailer-re)
|
|
|
2155 ;; CASE 5.1
|
|
|
2156 (progn (forward-sexp) (vhdl-beginning-of-statement-1 nil)))
|
|
|
2157 (vhdl-backward-skip-label (vhdl-point 'boi))
|
|
|
2158 (vhdl-add-syntax 'block-close (point)))
|
|
|
2159 ;; CASE 6: A continued statement
|
|
|
2160 ((and (/= char-before-ip ?\;)
|
|
|
2161 ;; check it's not a trailer begin keyword, or a begin
|
|
|
2162 ;; keyword immediately following a label.
|
|
|
2163 (not (and begin-after-ip
|
|
|
2164 (or (looking-at vhdl-trailer-re)
|
|
|
2165 (save-excursion
|
|
|
2166 (vhdl-backward-skip-label containing-sexp)))))
|
|
|
2167 ;; check it's not a statement keyword
|
|
|
2168 (not (and (looking-at vhdl-statement-fwd-re)
|
|
|
2169 (vhdl-statement-p)))
|
|
|
2170 ;; see if the b-o-s is before the indent point
|
|
|
2171 (> indent-point
|
|
|
2172 (save-excursion
|
|
|
2173 (vhdl-beginning-of-statement-1 containing-sexp)
|
|
|
2174 ;; If we ended up after a leader, then this will
|
|
|
2175 ;; move us forward to the start of the first
|
|
|
2176 ;; statement. Note that a containing sexp here is
|
|
|
2177 ;; always a keyword, not a paren, so this will
|
|
|
2178 ;; have no effect if we hit the containing-sexp.
|
|
|
2179 (vhdl-forward-syntactic-ws indent-point)
|
|
|
2180 (setq placeholder (point))))
|
|
|
2181 ;; check it's not a block-intro
|
|
|
2182 (/= placeholder containing-sexp)
|
|
|
2183 ;; check it's not a case block-intro
|
|
|
2184 (save-excursion
|
|
|
2185 (goto-char placeholder)
|
|
|
2186 (or (not (looking-at vhdl-case-alternative-key))
|
|
|
2187 (> (match-end 0) indent-point))))
|
|
|
2188 (vhdl-add-syntax 'statement-cont placeholder)
|
|
|
2189 (if begin-after-ip
|
|
|
2190 (vhdl-add-syntax 'block-open)))
|
|
|
2191 ;; Statement. But what kind?
|
|
|
2192 ;; CASE 7: A case alternative key
|
|
|
2193 ((looking-at vhdl-case-alternative-key)
|
|
|
2194 ;; for a case alternative key, we set relpos to the first
|
|
|
2195 ;; non-whitespace char on the line containing the "case"
|
|
|
2196 ;; keyword.
|
|
|
2197 (goto-char containing-sexp)
|
|
|
2198 ;; If the \"begin\" keyword is a trailer, then find v-b-o-s
|
|
|
2199 (if (looking-at vhdl-trailer-re)
|
|
|
2200 (progn (forward-sexp) (vhdl-beginning-of-statement-1 nil)))
|
|
|
2201 (vhdl-add-syntax 'case-alternative (vhdl-point 'boi)))
|
|
|
2202 ;; CASE 8: statement catchall
|
|
|
2203 (t
|
|
|
2204 ;; we know its a statement, but we need to find out if it is
|
|
|
2205 ;; the first statement in a block
|
|
|
2206 (if containing-leader
|
|
|
2207 (goto-char containing-leader)
|
|
|
2208 (goto-char containing-sexp)
|
|
|
2209 ;; Note that a containing sexp here is always a keyword,
|
|
|
2210 ;; not a paren, so skip over the keyword.
|
|
|
2211 (forward-sexp))
|
|
|
2212 ;; move to the start of the first statement
|
|
|
2213 (vhdl-forward-syntactic-ws indent-point)
|
|
|
2214 (setq placeholder (point))
|
|
|
2215 ;; we want to ignore case alternatives keys when skipping forward
|
|
|
2216 (let (incase-p)
|
|
|
2217 (while (looking-at vhdl-case-alternative-key)
|
|
|
2218 (setq incase-p (point))
|
|
|
2219 ;; we also want to skip over the body of the
|
|
|
2220 ;; case/when statement if that doesn't put us at
|
|
|
2221 ;; after the indent-point
|
|
|
2222 (while (vhdl-skip-case-alternative indent-point))
|
|
|
2223 ;; set up the match end
|
|
|
2224 (looking-at vhdl-case-alternative-key)
|
|
|
2225 (goto-char (match-end 0))
|
|
|
2226 ;; move to the start of the first case alternative statement
|
|
|
2227 (vhdl-forward-syntactic-ws indent-point)
|
|
|
2228 (setq placeholder (point)))
|
|
|
2229 (cond
|
|
|
2230 ;; CASE 8A: we saw a case/when statement so we must be
|
|
|
2231 ;; in a switch statement. find out if we are at the
|
|
|
2232 ;; statement just after a case alternative key
|
|
|
2233 ((and incase-p
|
|
|
2234 (= (point) indent-point))
|
|
|
2235 ;; relpos is the "when" keyword
|
|
|
2236 (vhdl-add-syntax 'statement-case-intro incase-p))
|
|
|
2237 ;; CASE 8B: any old statement
|
|
|
2238 ((< (point) indent-point)
|
|
|
2239 ;; relpos is the first statement of the block
|
|
|
2240 (vhdl-add-syntax 'statement placeholder)
|
|
|
2241 (if begin-after-ip
|
|
|
2242 (vhdl-add-syntax 'block-open)))
|
|
|
2243 ;; CASE 8C: first statement in a block
|
|
|
2244 (t
|
|
|
2245 (goto-char containing-sexp)
|
|
|
2246 ;; If the \"begin\" keyword is a trailer, then find v-b-o-s
|
|
|
2247 (if (looking-at vhdl-trailer-re)
|
|
|
2248 (progn (forward-sexp) (vhdl-beginning-of-statement-1 nil)))
|
|
|
2249 (vhdl-backward-skip-label (vhdl-point 'boi))
|
|
|
2250 (vhdl-add-syntax 'statement-block-intro (point))
|
|
|
2251 (if begin-after-ip
|
|
|
2252 (vhdl-add-syntax 'block-open)))
|
|
|
2253 )))
|
|
|
2254 )
|
|
|
2255
|
|
|
2256 ;; now we need to look at any modifiers
|
|
|
2257 (goto-char indent-point)
|
|
|
2258 (skip-chars-forward " \t")
|
|
|
2259 (if (looking-at "--")
|
|
|
2260 (vhdl-add-syntax 'comment))
|
|
|
2261 ;; return the syntax
|
|
|
2262 vhdl-syntactic-context))))
|
|
|
2263
|
|
|
2264
|
|
|
2265 ;; Standard indentation line-ups:
|
|
|
2266
|
|
|
2267 (defun vhdl-lineup-arglist (langelem)
|
|
|
2268 ;; lineup the current arglist line with the arglist appearing just
|
|
|
2269 ;; after the containing paren which starts the arglist.
|
|
|
2270 (save-excursion
|
|
|
2271 (let* ((containing-sexp
|
|
|
2272 (save-excursion
|
|
|
2273 ;; arglist-cont-nonempty gives relpos ==
|
|
|
2274 ;; to boi of containing-sexp paren. This
|
|
|
2275 ;; is good when offset is +, but bad
|
|
|
2276 ;; when it is vhdl-lineup-arglist, so we
|
|
|
2277 ;; have to special case a kludge here.
|
|
|
2278 (if (memq (car langelem) '(arglist-intro arglist-cont-nonempty))
|
|
|
2279 (progn
|
|
|
2280 (beginning-of-line)
|
|
|
2281 (backward-up-list 1)
|
|
|
2282 (skip-chars-forward " \t" (vhdl-point 'eol)))
|
|
|
2283 (goto-char (cdr langelem)))
|
|
|
2284 (point)))
|
|
|
2285 (cs-curcol (save-excursion
|
|
|
2286 (goto-char (cdr langelem))
|
|
|
2287 (current-column))))
|
|
|
2288 (if (save-excursion
|
|
|
2289 (beginning-of-line)
|
|
|
2290 (looking-at "[ \t]*)"))
|
|
|
2291 (progn (goto-char (match-end 0))
|
|
|
2292 (backward-sexp)
|
|
|
2293 (forward-char)
|
|
|
2294 (vhdl-forward-syntactic-ws)
|
|
|
2295 (- (current-column) cs-curcol))
|
|
|
2296 (goto-char containing-sexp)
|
|
|
2297 (or (eolp)
|
|
|
2298 (let ((eol (vhdl-point 'eol))
|
|
|
2299 (here (progn
|
|
|
2300 (forward-char)
|
|
|
2301 (skip-chars-forward " \t")
|
|
|
2302 (point))))
|
|
|
2303 (vhdl-forward-syntactic-ws)
|
|
|
2304 (if (< (point) eol)
|
|
|
2305 (goto-char here))))
|
|
|
2306 (- (current-column) cs-curcol)
|
|
|
2307 ))))
|
|
|
2308
|
|
|
2309 (defun vhdl-lineup-arglist-intro (langelem)
|
|
|
2310 ;; lineup an arglist-intro line to just after the open paren
|
|
|
2311 (save-excursion
|
|
|
2312 (let ((cs-curcol (save-excursion
|
|
|
2313 (goto-char (cdr langelem))
|
|
|
2314 (current-column)))
|
|
|
2315 (ce-curcol (save-excursion
|
|
|
2316 (beginning-of-line)
|
|
|
2317 (backward-up-list 1)
|
|
|
2318 (skip-chars-forward " \t" (vhdl-point 'eol))
|
|
|
2319 (current-column))))
|
|
|
2320 (- ce-curcol cs-curcol -1))))
|
|
|
2321
|
|
|
2322 (defun vhdl-lineup-comment (langelem)
|
|
|
2323 ;; support old behavior for comment indentation. we look at
|
|
|
2324 ;; vhdl-comment-only-line-offset to decide how to indent comment
|
|
|
2325 ;; only-lines
|
|
|
2326 (save-excursion
|
|
|
2327 (back-to-indentation)
|
|
|
2328 ;; at or to the right of comment-column
|
|
|
2329 (if (>= (current-column) comment-column)
|
|
|
2330 (vhdl-comment-indent)
|
|
|
2331 ;; otherwise, indent as specified by vhdl-comment-only-line-offset
|
|
|
2332 (if (not (bolp))
|
|
|
2333 (or (car-safe vhdl-comment-only-line-offset)
|
|
|
2334 vhdl-comment-only-line-offset)
|
|
|
2335 (or (cdr-safe vhdl-comment-only-line-offset)
|
|
|
2336 (car-safe vhdl-comment-only-line-offset)
|
|
|
2337 -1000 ;jam it against the left side
|
|
|
2338 )))))
|
|
|
2339
|
|
|
2340 (defun vhdl-lineup-statement-cont (langelem)
|
|
|
2341 ;; line up statement-cont after the assignment operator
|
|
|
2342 (save-excursion
|
|
|
2343 (let* ((relpos (cdr langelem))
|
|
|
2344 (assignp (save-excursion
|
|
|
2345 (goto-char (vhdl-point 'boi))
|
|
|
2346 (and (re-search-forward "\\(<\\|:\\)="
|
|
|
2347 (vhdl-point 'eol) t)
|
|
|
2348 (- (point) (vhdl-point 'boi)))))
|
|
|
2349 (curcol (progn
|
|
|
2350 (goto-char relpos)
|
|
|
2351 (current-column)))
|
|
|
2352 foundp)
|
|
|
2353 (while (and (not foundp)
|
|
|
2354 (< (point) (vhdl-point 'eol)))
|
|
|
2355 (re-search-forward "\\(<\\|:\\)=\\|(" (vhdl-point 'eol) 'move)
|
|
|
2356 (if (vhdl-in-literal (cdr langelem))
|
|
|
2357 (forward-char)
|
|
|
2358 (if (= (preceding-char) ?\()
|
|
|
2359 ;; skip over any parenthesized expressions
|
|
|
2360 (goto-char (min (vhdl-point 'eol)
|
|
|
2361 (scan-lists (point) 1 1)))
|
|
|
2362 ;; found an assignment operator (not at eol)
|
|
|
2363 (setq foundp (not (looking-at "\\s-*$"))))))
|
|
|
2364 (if (not foundp)
|
|
|
2365 ;; there's no assignment operator on the line
|
|
|
2366 vhdl-basic-offset
|
|
|
2367 ;; calculate indentation column after assign and ws, unless
|
|
|
2368 ;; our line contains an assignment operator
|
|
|
2369 (if (not assignp)
|
|
|
2370 (progn
|
|
|
2371 (forward-char)
|
|
|
2372 (skip-chars-forward " \t")
|
|
|
2373 (setq assignp 0)))
|
|
|
2374 (- (current-column) assignp curcol))
|
|
|
2375 )))
|
|
|
2376
|
|
|
2377
|
|
|
2378 ;; Indentation commands:
|
|
|
2379
|
|
|
2380 ;; This is used by indent-for-comment to decide how much to indent a
|
|
|
2381 ;; comment in VHDL code based on its context.
|
|
|
2382 (defun vhdl-comment-indent ()
|
|
|
2383 (if (looking-at (concat "^--"))
|
|
|
2384 0 ;Existing comment at bol stays there.
|
|
|
2385 (let ((opoint (point))
|
|
|
2386 placeholder)
|
|
|
2387 (save-excursion
|
|
|
2388 (beginning-of-line)
|
|
|
2389 (cond
|
|
|
2390 ;; CASE 1: use comment-column if previous line is a
|
|
|
2391 ;; comment-only line indented to the left of comment-column
|
|
|
2392 ((save-excursion
|
|
|
2393 (beginning-of-line)
|
|
|
2394 (and (not (bobp))
|
|
|
2395 (forward-line -1))
|
|
|
2396 (skip-chars-forward " \t")
|
|
|
2397 (prog1
|
|
|
2398 (looking-at "--")
|
|
|
2399 (setq placeholder (point))))
|
|
|
2400 (goto-char placeholder)
|
|
|
2401 (if (< (current-column) comment-column)
|
|
|
2402 comment-column
|
|
|
2403 (current-column)))
|
|
|
2404 ;; CASE 2: If comment-column is 0, and nothing but space
|
|
|
2405 ;; before the comment, align it at 0 rather than 1.
|
|
|
2406 ((progn
|
|
|
2407 (goto-char opoint)
|
|
|
2408 (skip-chars-backward " \t")
|
|
|
2409 (and (= comment-column 0) (bolp)))
|
|
|
2410 0)
|
|
|
2411 ;; CASE 3: indent at comment column except leave at least one
|
|
|
2412 ;; space.
|
|
|
2413 (t (max (1+ (current-column))
|
|
|
2414 comment-column))
|
|
|
2415 )))))
|
|
|
2416
|
|
|
2417 (defun vhdl-indent-line ()
|
|
|
2418 ;; indent the current line as VHDL code. Returns the amount of
|
|
|
2419 ;; indentation change
|
|
|
2420 (let* ((syntax (vhdl-get-syntactic-context))
|
|
|
2421 (pos (- (point-max) (point)))
|
|
|
2422 (indent (apply '+ (mapcar 'vhdl-get-offset syntax)))
|
|
|
2423 (shift-amt (- (current-indentation) indent)))
|
|
|
2424 (and vhdl-echo-syntactic-information-p
|
|
|
2425 (message "syntax: %s, indent= %d" syntax indent))
|
|
|
2426 (if (zerop shift-amt)
|
|
|
2427 nil
|
|
|
2428 (delete-region (vhdl-point 'bol) (vhdl-point 'boi))
|
|
|
2429 (beginning-of-line)
|
|
|
2430 (indent-to indent))
|
|
|
2431 (if (< (point) (vhdl-point 'boi))
|
|
|
2432 (back-to-indentation)
|
|
|
2433 ;; If initial point was within line's indentation, position after
|
|
|
2434 ;; the indentation. Else stay at same point in text.
|
|
|
2435 (if (> (- (point-max) pos) (point))
|
|
|
2436 (goto-char (- (point-max) pos)))
|
|
|
2437 )
|
|
|
2438 (run-hooks 'vhdl-special-indent-hook)
|
|
|
2439 shift-amt))
|
|
|
2440
|
|
|
2441 (defun vhdl-indent-command (&optional whole-exp)
|
|
|
2442 "Indent current line as VHDL code, or in some cases insert a tab character.
|
|
|
2443
|
|
|
2444 If `vhdl-tab-always-indent' is t, always just indent the current line.
|
|
|
2445 If nil, indent the current line only if point is at the left margin or
|
|
|
2446 in the line's indentation; otherwise insert a tab. If other than nil
|
|
|
2447 or t, then tab is inserted only within literals (comments and strings)
|
|
|
2448 and inside preprocessor directives, but line is always reindented.
|
|
|
2449
|
|
|
2450 A numeric argument, regardless of its value, means indent rigidly all
|
|
|
2451 the lines of the expression starting after point so that this line
|
|
|
2452 becomes properly indented. The relative indentation among the lines
|
|
|
2453 of the expression are preserved."
|
|
|
2454 (interactive "P")
|
|
|
2455 (if whole-exp
|
|
|
2456 ;; If arg, always indent this line as VHDL
|
|
|
2457 ;; and shift remaining lines of expression the same amount.
|
|
|
2458 (let ((shift-amt (vhdl-indent-line))
|
|
|
2459 beg end)
|
|
|
2460 (save-excursion
|
|
|
2461 (if (eq vhdl-tab-always-indent t)
|
|
|
2462 (beginning-of-line))
|
|
|
2463 (setq beg (point))
|
|
|
2464 (forward-sexp)
|
|
|
2465 (setq end (point))
|
|
|
2466 (goto-char beg)
|
|
|
2467 (forward-line 1)
|
|
|
2468 (setq beg (point)))
|
|
|
2469 (if (> end beg)
|
|
|
2470 (indent-code-rigidly beg end (- shift-amt))))
|
|
|
2471 ;; No arg supplied, use vhdl-tab-always-indent to determine
|
|
|
2472 ;; behavior
|
|
|
2473 (cond
|
|
|
2474 ;; CASE 1: indent when at column zero or in lines indentation,
|
|
|
2475 ;; otherwise insert a tab
|
|
|
2476 ((not vhdl-tab-always-indent)
|
|
|
2477 (if (save-excursion
|
|
|
2478 (skip-chars-backward " \t")
|
|
|
2479 (not (bolp)))
|
|
|
2480 (insert-tab)
|
|
|
2481 (vhdl-indent-line)))
|
|
|
2482 ;; CASE 2: just indent the line
|
|
|
2483 ((eq vhdl-tab-always-indent t)
|
|
|
2484 (vhdl-indent-line))
|
|
|
2485 ;; CASE 3: if in a literal, insert a tab, but always indent the
|
|
|
2486 ;; line
|
|
|
2487 (t
|
|
|
2488 (if (vhdl-in-literal (vhdl-point 'bod))
|
|
|
2489 (insert-tab))
|
|
|
2490 (vhdl-indent-line)
|
|
|
2491 ))))
|
|
|
2492
|
|
|
2493 (defun vhdl-indent-sexp (&optional endpos)
|
|
|
2494 "Indent each line of the list starting just after point.
|
|
|
2495 If optional arg ENDPOS is given, indent each line, stopping when
|
|
|
2496 ENDPOS is encountered. (interactive)"
|
|
|
2497 (interactive)
|
|
|
2498 (save-excursion
|
|
|
2499 (let ((beg (point))
|
|
|
2500 (end (progn
|
|
|
2501 (vhdl-forward-sexp nil endpos)
|
|
|
2502 (point))))
|
|
|
2503 (indent-region beg end nil))))
|
|
|
2504
|
|
|
2505 (defun vhdl-show-syntactic-information ()
|
|
|
2506 "Show syntactic information for current line."
|
|
|
2507 (interactive)
|
|
|
2508 (message "syntactic analysis: %s" (vhdl-get-syntactic-context))
|
|
|
2509 (vhdl-keep-region-active))
|
|
|
2510
|
|
|
2511
|
|
|
2512 ;; Verification and regression functions:
|
|
|
2513
|
|
|
2514 (defun vhdl-regress-line (&optional arg)
|
|
|
2515 "Check syntactic information for current line."
|
|
|
2516 (interactive "P")
|
|
|
2517 (let ((expected (save-excursion
|
|
|
2518 (end-of-line)
|
|
|
2519 (if (search-backward " -- ((" (vhdl-point 'bol) t)
|
|
|
2520 (progn
|
|
|
2521 (forward-char 4)
|
|
|
2522 (read (current-buffer))))))
|
|
|
2523 (actual (vhdl-get-syntactic-context))
|
|
|
2524 (expurgated))
|
|
|
2525 ;; remove the library unit symbols
|
|
|
2526 (mapcar
|
|
|
2527 (function
|
|
|
2528 (lambda (elt)
|
|
|
2529 (if (memq (car elt) '(entity configuration package
|
|
|
2530 package-body architecture))
|
|
|
2531 nil
|
|
|
2532 (setq expurgated (append expurgated (list elt))))))
|
|
|
2533 actual)
|
|
|
2534 (if (and (not arg) expected (listp expected))
|
|
|
2535 (if (not (equal expected expurgated))
|
|
|
2536 (error "Should be: %s, is: %s" expected expurgated))
|
|
|
2537 (save-excursion
|
|
|
2538 (beginning-of-line)
|
|
|
2539 (if (not (looking-at "^\\s-*\\(--.*\\)?$"))
|
|
|
2540 (progn
|
|
|
2541 (end-of-line)
|
|
|
2542 (if (search-backward " -- ((" (vhdl-point 'bol) t)
|
|
|
2543 (kill-line))
|
|
|
2544 (insert " -- ")
|
|
|
2545 (insert (format "%s" expurgated)))))))
|
|
|
2546 (vhdl-keep-region-active))
|
|
|
2547
|
|
|
2548 (defun test-vhdl-get-block-state ()
|
|
|
2549 (interactive)
|
|
|
2550 (let ((case-fold-search t)
|
|
|
2551 here vec (delay 0.5))
|
|
|
2552 (setq here (point))
|
|
|
2553 (message "%s" (prin1-to-string (setq vec (vhdl-get-block-state))))
|
|
|
2554 (and (aref vec 0)
|
|
|
2555 (goto-char (aref vec 0))
|
|
|
2556 (sit-for delay))
|
|
|
2557 (and (aref vec 1)
|
|
|
2558 (goto-char (aref vec 1))
|
|
|
2559 (sit-for delay))
|
|
|
2560 (goto-char here)
|
|
|
2561 ))
|
|
|
2562
|
|
|
2563 ;; Support for Barry Warsaw's elp (emacs lisp profiler) package:
|
|
|
2564
|
|
|
2565 (setq elp-all-instrumented-list nil)
|
|
|
2566 (setq elp-function-list
|
|
|
2567 '(
|
|
|
2568 vhdl-indent-command
|
|
|
2569 vhdl-indent-line
|
|
|
2570 vhdl-comment-indent
|
|
|
2571 vhdl-lineup-statement-cont
|
|
|
2572 vhdl-lineup-comment
|
|
|
2573 vhdl-lineup-arglist-intro
|
|
|
2574 vhdl-lineup-arglist
|
|
|
2575 vhdl-get-syntactic-context
|
|
|
2576 vhdl-skip-case-alternative
|
|
|
2577 vhdl-get-block-state
|
|
|
2578 vhdl-get-library-unit
|
|
|
2579 vhdl-beginning-of-statement
|
|
|
2580 vhdl-beginning-of-statement-1
|
|
|
2581 vhdl-beginning-of-defun
|
|
|
2582 vhdl-beginning-of-libunit
|
|
|
2583 vhdl-backward-sexp
|
|
|
2584 vhdl-forward-sexp
|
|
|
2585 vhdl-backward-to-block
|
|
|
2586 vhdl-statement-p
|
|
|
2587 vhdl-end-of-leader
|
|
|
2588 vhdl-corresponding-begin
|
|
|
2589 vhdl-end-p
|
|
|
2590 vhdl-corresponding-end
|
|
|
2591 vhdl-corresponding-mid
|
|
|
2592 vhdl-begin-p
|
|
|
2593 vhdl-corresponding-defun
|
|
|
2594 vhdl-defun-p
|
|
|
2595 vhdl-libunit-p
|
|
|
2596 vhdl-last-word
|
|
|
2597 vhdl-first-word
|
|
|
2598 vhdl-backward-syntactic-ws
|
|
|
2599 vhdl-forward-syntactic-ws
|
|
|
2600 vhdl-in-literal
|
|
|
2601 vhdl-keep-region-active
|
|
|
2602 ))
|
|
|
2603
|
|
|
2604 ;; (elp-instrument-list elp-function-list)
|
|
|
2605
|
|
|
2606 (defun vhdl-trace-all-functions ()
|
|
|
2607 (interactive)
|
|
|
2608 (let ((list elp-function-list))
|
|
|
2609 (while list
|
|
|
2610 (trace-function-background (car list))
|
|
|
2611 (setq list (cdr list)))))
|
|
|
2612
|
|
|
2613
|
|
|
2614 ;; Defuns for submitting bug reports:
|
|
|
2615
|
|
179
|
2616 (defconst vhdl-version "$Revision: 1.6 $"
|
|
72
|
2617 "vhdl-mode version number.")
|
|
179
|
2618 (defconst vhdl-mode-help-address "rwhitby@geocities.com"
|
|
72
|
2619 "Address accepting submission of bug reports.")
|
|
|
2620
|
|
|
2621 (defun vhdl-version ()
|
|
|
2622 "Echo the current version of vhdl-mode in the minibuffer."
|
|
|
2623 (interactive)
|
|
|
2624 (message "Using vhdl-mode %s" vhdl-version)
|
|
|
2625 (vhdl-keep-region-active))
|
|
|
2626
|
|
|
2627 ;; get reporter-submit-bug-report when byte-compiling
|
|
|
2628 (and (fboundp 'eval-when-compile)
|
|
|
2629 (eval-when-compile
|
|
|
2630 (require 'reporter)))
|
|
|
2631
|
|
|
2632 (defun vhdl-submit-bug-report ()
|
|
|
2633 "Submit via mail a bug report on vhdl-mode."
|
|
|
2634 (interactive)
|
|
|
2635 ;; load in reporter
|
|
|
2636 (and
|
|
|
2637 (y-or-n-p "Do you want to submit a report on vhdl-mode? ")
|
|
|
2638 (require 'reporter)
|
|
|
2639 (reporter-submit-bug-report
|
|
|
2640 vhdl-mode-help-address
|
|
|
2641 (concat "vhdl-mode " vhdl-version)
|
|
|
2642 (list
|
|
|
2643 ;; report only the vars that affect indentation
|
|
|
2644 'vhdl-basic-offset
|
|
|
2645 'vhdl-offsets-alist
|
|
|
2646 'vhdl-comment-only-line-offset
|
|
|
2647 'vhdl-tab-always-indent
|
|
|
2648 'tab-width
|
|
|
2649 )
|
|
|
2650 (function
|
|
|
2651 (lambda ()
|
|
|
2652 (insert
|
|
|
2653 (if vhdl-special-indent-hook
|
|
|
2654 (concat "\n@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@\n"
|
|
|
2655 "vhdl-special-indent-hook is set to '"
|
|
|
2656 (format "%s" vhdl-special-indent-hook)
|
|
|
2657 ".\nPerhaps this is your problem?\n"
|
|
|
2658 "@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@\n\n")
|
|
|
2659 "\n")
|
|
|
2660 (format "vhdl-emacs-features: %s\n" vhdl-emacs-features)
|
|
|
2661 )))
|
|
|
2662 nil
|
|
|
2663 "Dear Rod,"
|
|
|
2664 )))
|
|
|
2665
|
|
|
2666 (provide 'vhdl-mode)
|
|
|
2667 ;;; vhdl-mode.el ends here
|
