|
98
|
1 ;;; verilog-mode.el --- major mode for editing verilog source in Emacs
|
|
134
|
2 ;;
|
|
153
|
3 ;; $Header: /afs/informatik.uni-tuebingen.de/local/web/xemacs/xemacs-cvs/XEmacs/xemacs/lisp/modes/Attic/verilog-mode.el,v 1.5 1997/05/29 23:49:56 steve Exp $
|
|
98
|
4
|
|
|
5 ;; Copyright (C) 1996 Free Software Foundation, Inc.
|
|
|
6
|
|
|
7 ;; Author: Michael McNamara (mac@silicon-sorcery.com)
|
|
|
8 ;; President, Silicon Sorcery
|
|
|
9 ;; Keywords: languages
|
|
|
10
|
|
|
11 ;; This file is part of GNU Emacs.
|
|
|
12
|
|
|
13 ;; This program is free software; you can redistribute it and/or modify
|
|
|
14 ;; it under the terms of the GNU General Public License as published by
|
|
|
15 ;; the Free Software Foundation; either version 2 of the License, or
|
|
|
16 ;; (at your option) any later version.
|
|
|
17
|
|
|
18 ;; This program is distributed in the hope that it will be useful,
|
|
|
19 ;; but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
20 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
21 ;; GNU General Public License for more details.
|
|
|
22
|
|
|
23 ;; You should have received a copy of the GNU General Public License
|
|
|
24 ;; along with this program; if not, write to the Free Software
|
|
|
25 ;; Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
|
|
|
26
|
|
|
27 ;;; Commentary:
|
|
|
28
|
|
134
|
29 ;;; This mode borrows heavily from the pascal-mode and the cc-mode of emacs
|
|
98
|
30
|
|
134
|
31 ;;; USAGE
|
|
|
32 ;;; =====
|
|
98
|
33
|
|
134
|
34 ;;; A major mode for editing Verilog HDL source code. When you have
|
|
|
35 ;;; entered Verilog mode, you may get more info by pressing C-h m. You
|
|
|
36 ;;; may also get online help describing various functions by: C-h f
|
|
|
37 ;;; <Name of function you want described>
|
|
98
|
38
|
|
134
|
39 ;;; To set up automatic verilog mode, put this file in your load path,
|
|
|
40 ;;; and include stuff like this in your .emacs:
|
|
98
|
41
|
|
134
|
42 ; (autoload 'verilog-mode "verilog-mode" "Verilog mode" t )
|
|
|
43 ; (setq auto-mode-alist (cons '("\\.v\\'" . verilog-mode) auto-mode-alist))
|
|
|
44 ; (setq auto-mode-alist (cons '("\\.dv\\'" . verilog-mode) auto-mode-alist))
|
|
98
|
45
|
|
134
|
46 ;;; If you want to customize Verilog mode to fit your needs better,
|
|
|
47 ;;; you may add these lines (the values of the variables presented
|
|
|
48 ;;; here are the defaults):
|
|
|
49 ;;;
|
|
|
50 ;;; ;; User customization for Verilog mode
|
|
|
51 ;;; (setq verilog-indent-level 3
|
|
|
52 ;;; verilog-indent-level-module 3
|
|
|
53 ;;; verilog-indent-level-declaration 3
|
|
|
54 ;;; verilog-indent-level-behavorial 3
|
|
|
55 ;;; verilog-case-indent 2
|
|
|
56 ;;; verilog-auto-newline t
|
|
|
57 ;;; verilog-auto-indent-on-newline t
|
|
|
58 ;;; verilog-tab-always-indent t
|
|
|
59 ;;; verilog-auto-endcomments t
|
|
|
60 ;;; verilog-minimum-comment-distance 40
|
|
|
61 ;;; verilog-indent-begin-after-if t
|
|
|
62 ;;; verilog-auto-lineup '(all))
|
|
98
|
63
|
|
134
|
64 ;;; KNOWN BUGS / BUGREPORTS
|
|
|
65 ;;; ======================= This is beta code, and likely has
|
|
|
66 ;;; bugs. Please report any and all bugs to me at mac@silicon-sorcery.com.
|
|
98
|
67 ;;
|
|
|
68 ;;; Code:
|
|
|
69
|
|
|
70 (provide 'verilog-mode)
|
|
|
71
|
|
|
72 ;; This variable will always hold the version number of the mode
|
|
153
|
73 (defconst verilog-mode-version "$$Revision: 1.5 $$"
|
|
98
|
74 "Version of this verilog mode.")
|
|
|
75
|
|
134
|
76 ;;
|
|
|
77 ;; A hack so we can support either custom, or the old defvar
|
|
|
78 ;;
|
|
|
79 (eval-and-compile
|
|
|
80 (condition-case ()
|
|
|
81 (require 'custom)
|
|
|
82 (error nil))
|
|
|
83 (if (and (featurep 'custom) (fboundp 'custom-declare-variable))
|
|
|
84 nil ;; We've got what we needed
|
|
|
85 ;; We have the old custom-library, hack around it!
|
|
|
86 (defmacro defgroup (&rest args)
|
|
|
87 nil)
|
|
|
88 (defmacro customize (&rest args)
|
|
|
89 (message "Sorry, Customise is not available with this version of emacs"))
|
|
|
90 (defmacro defcustom (var value doc &rest args)
|
|
|
91 (` (defvar (, var) (, value) (, doc))))))
|
|
98
|
92
|
|
134
|
93 (defun verilog-customize ()
|
|
|
94 "Link to customize screen for Verilog"
|
|
|
95 (interactive)
|
|
142
|
96 (customize 'verilog)
|
|
134
|
97 )
|
|
98
|
98
|
|
142
|
99 (defgroup verilog nil
|
|
134
|
100 "Faciliates easy editing of Verilog source text"
|
|
|
101 :group 'languages)
|
|
|
102
|
|
|
103 (defcustom verilog-indent-level 3
|
|
|
104 "*Indentation of Verilog statements with respect to containing block."
|
|
142
|
105 :group 'verilog
|
|
134
|
106 :type 'integer
|
|
|
107 )
|
|
98
|
108
|
|
134
|
109 (defcustom verilog-indent-level-module 3
|
|
|
110 "* Indentation of Module level Verilog statements. (eg always, initial)
|
|
|
111 Set to 0 to get initial and always statements lined up
|
|
|
112 on the left side of your screen."
|
|
142
|
113 :group 'verilog
|
|
134
|
114 :type 'integer
|
|
|
115 )
|
|
98
|
116
|
|
134
|
117 (defcustom verilog-indent-level-declaration 3
|
|
|
118 "*Indentation of declarations with respect to containing block.
|
|
|
119 Set to 0 to get them list right under containing block."
|
|
142
|
120 :group 'verilog
|
|
134
|
121 :type 'integer
|
|
|
122 )
|
|
|
123
|
|
|
124 (defcustom verilog-indent-level-behavorial 3
|
|
|
125 "*Absolute indentation of first begin in a task or function block
|
|
|
126 Set to 0 to get such code to start at the left side of the screen."
|
|
142
|
127 :group 'verilog
|
|
134
|
128 :type 'integer
|
|
|
129 )
|
|
98
|
130
|
|
134
|
131 (defcustom verilog-cexp-indent 1
|
|
|
132 "*Indentation of Verilog statements split across lines."
|
|
142
|
133 :group 'verilog
|
|
134
|
134 :type 'integer
|
|
|
135 )
|
|
|
136
|
|
|
137 (defcustom verilog-case-indent 2
|
|
|
138 "*Indentation for case statements."
|
|
142
|
139 :group 'verilog
|
|
134
|
140 :type 'integer
|
|
|
141 )
|
|
98
|
142
|
|
134
|
143 (defcustom verilog-auto-newline t
|
|
|
144 "*Non-nil means automatically newline after semicolons"
|
|
142
|
145 :group 'verilog
|
|
134
|
146 :type 'integer
|
|
|
147 )
|
|
|
148
|
|
|
149 (defcustom verilog-auto-indent-on-newline t
|
|
|
150 "*Non-nil means automatically indent line after newline"
|
|
142
|
151 :group 'verilog
|
|
134
|
152 :type 'integer
|
|
|
153 )
|
|
98
|
154
|
|
134
|
155 (defcustom verilog-tab-always-indent t
|
|
|
156 "*Non-nil means TAB in Verilog mode should always reindent the
|
|
|
157 current line, regardless of where in the line point is when the TAB
|
|
|
158 command is used."
|
|
142
|
159 :group 'verilog
|
|
134
|
160 :type 'integer
|
|
|
161 )
|
|
|
162
|
|
|
163 (defcustom verilog-indent-begin-after-if t
|
|
|
164 "*If true, indent begin statements following if, else, while, for
|
|
|
165 and repeat. otherwise, line them up."
|
|
142
|
166 :group 'verilog
|
|
134
|
167 :type 'boolean )
|
|
98
|
168
|
|
134
|
169 (defcustom verilog-auto-endcomments t
|
|
|
170 "*Non-nil means a comment /* ... */ is set after the ends which ends
|
|
|
171 cases and functions. The name of the function or case will be set
|
|
|
172 between the braces."
|
|
142
|
173 :group 'verilog
|
|
134
|
174 :type 'boolean )
|
|
|
175
|
|
|
176 (defcustom verilog-minimum-comment-distance 40
|
|
|
177 "*Minimum distance between begin and end required before a comment
|
|
|
178 will be inserted. Setting this variable to zero results in every
|
|
|
179 end aquiring a comment; the default avoids too many redundanet
|
|
|
180 comments in tight quarters"
|
|
142
|
181 :group 'verilog
|
|
134
|
182 :type 'integer
|
|
|
183 )
|
|
|
184
|
|
|
185 (defvar verilog-auto-lineup '(all)
|
|
|
186 "*List of contexts where auto lineup of :'s or ='s should be done.
|
|
|
187 Elements can be of type: 'declaration' or 'case', which will do auto
|
|
|
188 lineup in declarations or case-statements respectively. The word 'all'
|
|
|
189 will do all lineups. '(case declaration) for instance will do lineup
|
|
|
190 in case-statements and parameterlist, while '(all) will do all
|
|
|
191 lineups."
|
|
|
192 )
|
|
98
|
193
|
|
|
194 (defvar verilog-mode-abbrev-table nil
|
|
|
195 "Abbrev table in use in Verilog-mode buffers.")
|
|
|
196
|
|
|
197 (defvar verilog-font-lock-keywords-after-1930
|
|
|
198 '(
|
|
134
|
199 ;;
|
|
|
200 ("^\\s-*\\(function\\|task\\|module\\|macromodule\\|primitive\\)\\>"
|
|
98
|
201 1 font-lock-keyword-face)
|
|
134
|
202 ("^\\s-*\\(function\\|task\\|module\\|macromodule\\|primitive\\)\\>\\s-*\\(\\sw+\\)"
|
|
98
|
203 2 font-lock-function-name-face nil t)
|
|
134
|
204 ("\\\\\\s-*" 0 'font-lock-function-name-face)
|
|
|
205 ("\\(@\\)\\|\\(#\\s-*\\(\\(\[0-9\]+\\('[hdxbo][0-9_xz]*\\)?\\)\\|\\((\[^)\]*)\\|\\sw+\\)\\)\\)" 0 font-lock-type-face)
|
|
|
206 ("\\(`\\s-*[A-Za-z][A-Za-z0-9_]*\\)" 0 font-lock-type-face)
|
|
|
207 ("\\<\\(in\\(teger\\|put\\|out\\)\\|parameter\\|defparam\\|output\\|supply[01]?\\|event\\|tri\\(0\\|1\\|reg\\|and\\|or\\)?\\|w\\(ire\\|or\\|and\\)\\|time\\|re\\(al\\(time\\)?\\|g\\)\\)\\>"
|
|
|
208 0 font-lock-type-face)
|
|
|
209 ("\\(\\$[a-zA-Z][a-zA-Z0-9_\\$]*\\)\\|\\(\\<\\(begin\\|case[xz]?\\|end\\(case\\|function\\|task\\|module\\|table\\|primitive\\|specify\\)?\\|a\\(ssign\\|lways\\)\\|default\\|initial\\|table\\|\\(pos\\|neg\\)edge\\|else\\|for\\(ever\\|k\\)?\\|join\\|if\\|repeat\\|then\\|while\\|specify\\)\\>\\)"
|
|
98
|
210 0 font-lock-keyword-face)
|
|
|
211 )
|
|
|
212 )
|
|
134
|
213
|
|
98
|
214 (defvar verilog-font-lock-keywords-before-1930
|
|
|
215 '(
|
|
134
|
216 ("^\\s-*\\(function\\|task\\|module\\|macromodule\\|primitive\\)\\>" . 1)
|
|
|
217 ("^\\s-*\\(function\\|task\\|module\\|macromodule\\|primitive\\)\\>\\s-*\\(\\sw+\\)"
|
|
98
|
218 2 font-lock-function-name-face nil t)
|
|
134
|
219 ("\\(\\\\\\s-*\\)\\|\\(`[ \t]*[A-Za-z][A-Za-z0-9_]*\\)" 0 font-lock-function-name-face)
|
|
98
|
220 ("[@#]" . font-lock-type-face)
|
|
|
221 ("\\<\\(in\\(teger\\|put\\|out\\)\\|parameter\\|defparam\\|output\\|supply[01]?\\|event\\|tri\\(0\\|1\\|reg\\|and\\|or\\)?\\|w\\(ire\\|or\\|and\\)\\|time\\|re\\(al\\(time\\)?\\|g\\)\\)\\>"
|
|
|
222 0 font-lock-type-face)
|
|
|
223 ("\\(\\$[a-zA-Z][a-zA-Z0-9_\\$]*\\)\\|\\(\\<\\(begin\\|case[xz]?\\|end\\(case\\|function\\|task\\|module\\|table\\|primitive\\|specify\\)?\\|a\\(ssign\\|lways\\)\\|default\\|initial\\|table\\|\\(pos\\|neg\\)edge\\|else\\|for\\(ever\\|k\\)?\\|join\\|if\\|repeat\\|then\\|while\\|specify\\)\\>\\)" . font-lock-keyword-face)
|
|
|
224 )
|
|
|
225 )
|
|
|
226
|
|
134
|
227 ;; Insure we have certain packages
|
|
|
228
|
|
|
229 (if (fboundp 'eval-when-compile)
|
|
|
230 (eval-when-compile
|
|
|
231 (condition-case nil
|
|
|
232 (require 'imenu)
|
|
|
233 (error nil))
|
|
|
234 (condition-case nil
|
|
|
235 (require 'reporter)
|
|
|
236 (error nil))
|
|
|
237 (condition-case nil
|
|
|
238 (require 'easymenu)
|
|
|
239 (error nil))))
|
|
|
240
|
|
98
|
241 (defvar verilog-imenu-generic-expression
|
|
134
|
242 '((nil "^\\s-*\\(\\(m\\(odule\\|acromodule\\)\\)\\|primitive\\)\\s-+\\([a-zA-Z0-9_.:]+\\)" 3)
|
|
|
243 ("*Vars*" "^\\s-*\\(reg\\|wire\\)\\)\\s-+\\(\\|\\[[^\\]+]\\s-+\\)\\([-A-Za-z0-9+]+\\)" 3))
|
|
98
|
244 "Imenu expression for Verilog-mode. See `imenu-generic-expression'.")
|
|
|
245
|
|
|
246 (defvar verilog-mode-abbrev-table nil
|
|
|
247 "Abbrev table in use in Verilog-mode buffers.")
|
|
|
248
|
|
|
249
|
|
|
250 (define-abbrev-table 'verilog-mode-abbrev-table ())
|
|
|
251
|
|
|
252 (defvar verilog-mode-map ()
|
|
|
253 "Keymap used in Verilog mode.")
|
|
|
254 (if verilog-mode-map
|
|
|
255 ()
|
|
|
256 (setq verilog-mode-map (make-sparse-keymap))
|
|
|
257 (define-key verilog-mode-map ";" 'electric-verilog-semi)
|
|
|
258 (define-key verilog-mode-map ":" 'electric-verilog-colon)
|
|
|
259 (define-key verilog-mode-map "=" 'electric-verilog-equal)
|
|
|
260 (define-key verilog-mode-map "\`" 'electric-verilog-tick)
|
|
|
261 (define-key verilog-mode-map "\t" 'electric-verilog-tab)
|
|
|
262 (define-key verilog-mode-map "\r" 'electric-verilog-terminate-line)
|
|
|
263 (define-key verilog-mode-map "\M-\C-b" 'electric-verilog-backward-sexp)
|
|
|
264 (define-key verilog-mode-map "\M-\C-f" 'electric-verilog-forward-sexp)
|
|
|
265 (define-key verilog-mode-map "\M-\r" (function (lambda ()
|
|
134
|
266 (interactive) (electric-verilog-terminate-line 1))))
|
|
153
|
267 ;; GDF - Leave the DEL key alone
|
|
|
268 ;; (define-key verilog-mode-map "\177" 'backward-delete-char-untabify)
|
|
98
|
269 (define-key verilog-mode-map "\M-\t" 'verilog-complete-word)
|
|
|
270 (define-key verilog-mode-map "\M-?" 'verilog-show-completions)
|
|
|
271 (define-key verilog-mode-map "\M-\C-h" 'verilog-mark-defun)
|
|
|
272 (define-key verilog-mode-map "\C-c\C-b" 'verilog-insert-block)
|
|
|
273 (define-key verilog-mode-map "\C-cb" 'verilog-label-be)
|
|
134
|
274 (define-key verilog-mode-map "\C-ci" 'verilog-pretty-declarations)
|
|
|
275 (define-key verilog-mode-map "\C-cC-b" 'verilog-submit-bug-report)
|
|
98
|
276 (define-key verilog-mode-map "\M-*" 'verilog-star-comment)
|
|
134
|
277 (define-key verilog-mode-map "\C-c\C-c" 'verilog-comment-region)
|
|
|
278 (define-key verilog-mode-map "\C-c\C-u" 'verilog-uncomment-region)
|
|
98
|
279 (define-key verilog-mode-map "\M-\C-a" 'verilog-beg-of-defun)
|
|
|
280 (define-key verilog-mode-map "\M-\C-e" 'verilog-end-of-defun)
|
|
|
281 (define-key verilog-mode-map "\C-c\C-d" 'verilog-goto-defun)
|
|
|
282 )
|
|
|
283
|
|
134
|
284 ;; menus
|
|
|
285
|
|
|
286 (if (string-match "XEmacs" emacs-version)
|
|
|
287 (defvar verilog-xemacs-menu
|
|
|
288 '("Verilog"
|
|
|
289 ["Line up declarations around point" verilog-pretty-declarations t]
|
|
|
290 ["Redo/insert comments on every end" verilog-label-be t]
|
|
|
291 "----"
|
|
|
292 ["Beginning of function" verilog-beg-of-defun t]
|
|
|
293 ["End of function" verilog-end-of-defun t]
|
|
|
294 ["Mark function" verilog-mark-defun t]
|
|
|
295 "----"
|
|
|
296 ["Move to beginning of block" electric-verilog-backward-sexp t]
|
|
|
297 ["Move to end of block" electric-verilog-forward-sexp t]
|
|
|
298 "----"
|
|
|
299 ["Comment Region" verilog-comment-region t]
|
|
|
300 ["UnComment Region" verilog-uncomment-region t]
|
|
|
301 ["Multi-line comment insert" verilog-star-comment t]
|
|
|
302 "----"
|
|
|
303 ["Insert begin-end block" verilog-insert-block t]
|
|
|
304 ["Complete word" verilog-complete-word t]
|
|
|
305 "----"
|
|
|
306 ["Submit bug report" verilog-submit-bug-report t]
|
|
|
307 ["Customize Verilog Mode..." verilog-customize t]
|
|
|
308 "XEmacs menu for VERILOG mode."))
|
|
|
309 (progn
|
|
|
310 (easy-menu-define verilog-menu verilog-mode-map "Menu for Verilog mode"
|
|
|
311 '("Verilog"
|
|
|
312 ["Line up declarations around point" verilog-pretty-declarations t]
|
|
|
313 ["Redo/insert comments on every end" verilog-label-be t]
|
|
|
314 "----"
|
|
|
315 ["Beginning of function" verilog-beg-of-defun t]
|
|
|
316 ["End of function" verilog-end-of-defun t]
|
|
|
317 ["Mark function" verilog-mark-defun t]
|
|
|
318 "----"
|
|
|
319 ["Move to beginning of block" electric-verilog-backward-sexp t]
|
|
|
320 ["Move to end of block" electric-verilog-forward-sexp t]
|
|
|
321 "----"
|
|
|
322 ["Comment Region" verilog-comment-region t]
|
|
|
323 ["UnComment Region" verilog-uncomment-region t]
|
|
|
324 ["Multi-line comment insert" verilog-star-comment t]
|
|
|
325 "----"
|
|
|
326 ["Insert begin-end block" verilog-insert-block t]
|
|
|
327 ["Complete word" verilog-complete-word t]
|
|
|
328 "----"
|
|
|
329 ["Submit bug report" verilog-submit-bug-report t]
|
|
|
330 ["Customize Verilog Mode..." verilog-customize t]
|
|
|
331 ))))
|
|
|
332
|
|
|
333 (defvar verilog-mode-abbrev-table nil
|
|
|
334 "Abbrev table in use in Verilog-mode buffers.")
|
|
|
335
|
|
|
336 (define-abbrev-table 'verilog-mode-abbrev-table ())
|
|
98
|
337
|
|
|
338
|
|
|
339 ;;;
|
|
|
340 ;;; Regular expressions used to calculate indent, etc.
|
|
|
341 ;;;
|
|
|
342 (defconst verilog-symbol-re "\\<[a-zA-Z_][a-zA-Z_0-9.]*\\>")
|
|
134
|
343 (defconst verilog-case-re "\\(\\<case[xz]?\\>\\)")
|
|
98
|
344 ;; Want to match
|
|
|
345 ;; aa :
|
|
|
346 ;; aa,bb :
|
|
|
347 ;; a[34:32] :
|
|
|
348 ;; a,
|
|
|
349 ;; b :
|
|
134
|
350 (defconst
|
|
|
351 verilog-no-indent-begin-re
|
|
|
352 "\\<\\(if\\|else\\|while\\|for\\|repeat\\|always\\)\\>")
|
|
|
353 (defconst verilog-ends-re
|
|
|
354 (concat
|
|
|
355 "\\(\\<else\\>\\)\\|"
|
|
|
356 "\\(\\<if\\>\\)\\|"
|
|
|
357 "\\(\\<end\\>\\)\\|"
|
|
|
358 "\\(\\<join\\>\\)\\|"
|
|
|
359 "\\(\\<endcase\\>\\)\\|"
|
|
|
360 "\\(\\<endtable\\>\\)\\|"
|
|
|
361 "\\(\\<endspecify\\>\\)\\|"
|
|
|
362 "\\(\\<endfunction\\>\\)\\|"
|
|
|
363 "\\(\\<endtask\\>\\)"))
|
|
|
364
|
|
|
365
|
|
|
366 (defconst verilog-enders-re
|
|
|
367 (concat "\\(\\<endcase\\>\\)\\|"
|
|
|
368 "\\(\\<end\\>\\)\\|"
|
|
|
369 "\\(\\<end\\(\\(function\\)\\|\\(task\\)\\|"
|
|
|
370 "\\(module\\)\\|\\(primitive\\)\\)\\>\\)"))
|
|
98
|
371 (defconst verilog-endcomment-reason-re
|
|
|
372 (concat
|
|
134
|
373 "\\(\\<fork\\>\\)\\|"
|
|
|
374 "\\(\\<begin\\>\\)\\|"
|
|
|
375 "\\(\\<if\\>\\)\\|"
|
|
|
376 "\\(\\<else\\>\\)\\|"
|
|
|
377 "\\(\\<end\\>.*\\<else\\>\\)\\|"
|
|
|
378 "\\(\\<task\\>\\)\\|"
|
|
|
379 "\\(\\<function\\>\\)\\|"
|
|
|
380 "\\(\\<initial\\>\\)\\|"
|
|
|
381 "\\(\\<always\\>\\(\[ \t\]*@\\)?\\)\\|"
|
|
|
382 "\\(\\<while\\>\\)\\|"
|
|
|
383 "\\(\\<for\\(ever\\)?\\>\\)\\|"
|
|
|
384 "\\(\\<repeat\\>\\)\\|\\(\\<wait\\>\\)\\|"
|
|
98
|
385 "#"))
|
|
|
386
|
|
|
387 (defconst verilog-named-block-re "begin[ \t]*:")
|
|
134
|
388 (defconst verilog-beg-block-re
|
|
|
389 ;; "begin" "case" "casex" "fork" "casez" "table" "specify" "function" "task"
|
|
|
390 "\\(\\<\\(begin\\>\\|case\\(\\>\\|x\\>\\|z\\>\\)\\|f\\(ork\\>\\|unction\\>\\)\\|specify\\>\\|ta\\(ble\\>\\|sk\\>\\)\\)\\)")
|
|
|
391
|
|
|
392 (defconst verilog-beg-block-re-1
|
|
|
393 "\\<\\(begin\\)\\|\\(case[xz]?\\)\\|\\(fork\\)\\|\\(table\\)\\|\\(specify\\)\\|\\(function\\)\\|\\(task\\)\\>")
|
|
|
394 (defconst verilog-end-block-re
|
|
|
395 ;; "end" "join" "endcase" "endtable" "endspecify" "endtask" "endfunction"
|
|
|
396 "\\<\\(end\\(\\>\\|case\\>\\|function\\>\\|specify\\>\\|ta\\(ble\\>\\|sk\\>\\)\\)\\|join\\>\\)")
|
|
|
397
|
|
98
|
398 (defconst verilog-end-block-re-1 "\\(\\<end\\>\\)\\|\\(\\<endcase\\>\\)\\|\\(\\<join\\>\\)\\|\\(\\<endtable\\>\\)\\|\\(\\<endspecify\\>\\)\\|\\(\\<endfunction\\>\\)\\|\\(\\<endtask\\>\\)")
|
|
|
399 (defconst verilog-declaration-re
|
|
134
|
400 ;; "input" "inout" "output" "integer" "parameter" "defparam" "event"
|
|
|
401 ;; "real" "reg" "realtime" "time" "tri" "tri0" "tri1" "trireg" "triand"
|
|
|
402 ;; "trior" "supply0" "supply1" "wire" "wor" "wand"
|
|
|
403 "\\(\\<\\(defparam\\>\\|event\\>\\|in\\(out\\>\\|put\\>\\|teger\\>\\)\\|output\\>\\|parameter\\>\\|re\\(al\\(\\>\\|time\\>\\)\\|g\\>\\)\\|supply\\(0\\>\\|1\\>\\)\\|t\\(ime\\>\\|ri\\(0\\>\\|1\\>\\|\\>\\|and\\>\\|or\\>\\|reg\\>\\)\\)\\|w\\(and\\>\\|ire\\>\\|or\\>\\)\\)\\)")
|
|
98
|
404 (defconst verilog-declaration-re-1 (concat "^[ \t]*" verilog-declaration-re "[ \t]*\\(\\[[^]]*\\][ \t]*\\)?"))
|
|
134
|
405 (defconst verilog-declaration-re-2 (concat "[ \t]*" verilog-declaration-re "[ \t]*\\(\\[[^]]*\\][ \t]*\\)?"))
|
|
|
406 (defconst verilog-defun-re
|
|
|
407 ;;"module" "macromodule" "primitive"
|
|
|
408 "\\(\\<\\(m\\(acromodule\\>\\|odule\\>\\)\\|primitive\\>\\)\\)")
|
|
|
409 (defconst verilog-end-defun-re
|
|
|
410 ;; "endmodule" "endprimitive"
|
|
|
411 "\\(\\<end\\(module\\>\\|primitive\\>\\)\\)")
|
|
98
|
412 (defconst verilog-zero-indent-re
|
|
|
413 (concat verilog-defun-re "\\|" verilog-end-defun-re))
|
|
|
414 (defconst verilog-directive-re
|
|
134
|
415 ;; "`else" "`ifdef" "`endif" "`define" "`undef" "`include"
|
|
|
416 "\\(\\<`\\(define\\>\\|e\\(lse\\>\\|ndif\\>\\)\\|i\\(fdef\\>\\|nclude\\>\\)\\|undef\\>\\)\\)")
|
|
98
|
417 (defconst verilog-autoindent-lines-re
|
|
134
|
418 ;; "macromodule" "module" "primitive" "end" "endcase" "endfunction"
|
|
|
419 ;; "endtask" "endmodule" "endprimitive" "endspecify" "endtable" "join"
|
|
|
420 ;; "begin" "else" "`else" "`ifdef" "`endif" "`define" "`undef" "`include"
|
|
|
421 "\\(\\<\\(`\\(define\\>\\|e\\(lse\\>\\|ndif\\>\\)\\|i\\(fdef\\>\\|nclude\\>\\)\\|undef\\>\\)\\|begin\\>\\|e\\(lse\\>\\|nd\\(\\>\\|case\\>\\|function\\>\\|module\\>\\|primitive\\>\\|specify\\>\\|ta\\(ble\\>\\|sk\\>\\)\\)\\)\\|join\\>\\|m\\(acromodule\\>\\|odule\\>\\)\\|primitive\\>\\)\\)")
|
|
|
422
|
|
98
|
423 (defconst verilog-behavorial-block-beg-re
|
|
|
424 "\\(\\<initial\\>\\|\\<always\\>\\|\\<function\\>\\|\\<task\\>\\)")
|
|
|
425 (defconst verilog-indent-reg
|
|
134
|
426 (concat
|
|
|
427 "\\(\\<begin\\>\\|\\<case[xz]?\\>\\|\\<specify\\>\\|\\<fork\\>\\|\\<table\\>\\)\\|"
|
|
|
428 "\\(\\<end\\>\\|\\<join\\>\\|\\<endcase\\>\\|\\<endtable\\>\\|\\<endspecify\\>\\)\\|"
|
|
|
429 "\\(\\<module\\>\\|\\<macromodule\\>\\|\\<primitive\\>\\|\\<initial\\>\\|\\<always\\>\\)\\|"
|
|
|
430 "\\(\\<endmodule\\>\\|\\<endprimitive\\>\\)\\|"
|
|
|
431 "\\(\\<endtask\\>\\|\\<endfunction\\>\\)\\|"
|
|
|
432 "\\(\\<function\\>\\|\\<task\\>\\)"
|
|
|
433 ;; "\\|\\(\\<if\\>\\|\\<else\\>\\)"
|
|
|
434 ))
|
|
|
435 (defconst verilog-indent-re
|
|
|
436 "\\(\\<\\(always\\>\\|begin\\>\\|case\\(\\>\\|x\\>\\|z\\>\\)\\|end\\(\\>\\|case\\>\\|function\\>\\|module\\>\\|primitive\\>\\|specify\\>\\|ta\\(ble\\>\\|sk\\>\\)\\)\\|f\\(ork\\>\\|unction\\>\\)\\|initial\\>\\|join\\>\\|m\\(acromodule\\>\\|odule\\>\\)\\|primitive\\>\\|specify\\>\\|ta\\(ble\\>\\|sk\\>\\)\\)\\)")
|
|
|
437
|
|
|
438 (defconst verilog-defun-level-re
|
|
|
439 ;; "module" "macromodule" "primitive" "initial" "always" "endtask" "endfunction"
|
|
|
440 "\\(\\<\\(always\\>\\|end\\(function\\>\\|task\\>\\)\\|initial\\>\\|m\\(acromodule\\>\\|odule\\>\\)\\|primitive\\>\\)\\)")
|
|
|
441 (defconst verilog-cpp-level-re
|
|
|
442 ;;"endmodule" "endprimitive"
|
|
|
443 "\\(\\<end\\(module\\>\\|primitive\\>\\)\\)")
|
|
|
444 (defconst verilog-behavorial-level-re
|
|
|
445 ;; "function" "task"
|
|
|
446 "\\(\\<\\(function\\>\\|task\\>\\)\\)")
|
|
98
|
447 (defconst verilog-complete-reg
|
|
134
|
448 ;; "always" "repeat" "case" "casex" "casez" "while" "if" "for" "forever"
|
|
|
449 "\\(\\<\\(always\\>\\|case\\(\\>\\|x\\>\\|z\\>\\)\\|else\\|for\\(\\>\\|ever\\>\\)\\|if\\>\\|repeat\\>\\|while\\>\\)\\)")
|
|
98
|
450 (defconst verilog-end-statement-re
|
|
|
451 (concat "\\(" verilog-beg-block-re "\\)\\|\\("
|
|
|
452 verilog-end-block-re "\\)"))
|
|
|
453 (defconst verilog-endcase-re
|
|
|
454 (concat verilog-case-re "\\|"
|
|
|
455 "\\(endcase\\)\\|"
|
|
|
456 verilog-defun-re
|
|
|
457 ))
|
|
|
458 ;;; Strings used to mark beginning and end of excluded text
|
|
|
459 (defconst verilog-exclude-str-start "/* -----\\/----- EXCLUDED -----\\/-----")
|
|
|
460 (defconst verilog-exclude-str-end " -----/\\----- EXCLUDED -----/\\----- */")
|
|
|
461
|
|
|
462 (defconst verilog-emacs-features
|
|
|
463 (let ((major (and (boundp 'emacs-major-version)
|
|
|
464 emacs-major-version))
|
|
|
465 (minor (and (boundp 'emacs-minor-version)
|
|
|
466 emacs-minor-version))
|
|
|
467 flavor comments)
|
|
|
468 ;; figure out version numbers if not already discovered
|
|
|
469 (and (or (not major) (not minor))
|
|
|
470 (string-match "\\([0-9]+\\).\\([0-9]+\\)" emacs-version)
|
|
|
471 (setq major (string-to-int (substring emacs-version
|
|
|
472 (match-beginning 1)
|
|
|
473 (match-end 1)))
|
|
|
474 minor (string-to-int (substring emacs-version
|
|
|
475 (match-beginning 2)
|
|
|
476 (match-end 2)))))
|
|
|
477 (if (not (and major minor))
|
|
|
478 (error "Cannot figure out the major and minor version numbers."))
|
|
|
479 ;; calculate the major version
|
|
|
480 (cond
|
|
|
481 ((= major 18) (setq major 'v18)) ;Emacs 18
|
|
|
482 ((= major 4) (setq major 'v18)) ;Epoch 4
|
|
134
|
483 ((= major 20) (setq major 'v20
|
|
|
484 flavor 'XEmacs))
|
|
98
|
485 ((= major 19) (setq major 'v19 ;Emacs 19
|
|
|
486 flavor (if (or (string-match "Lucid" emacs-version)
|
|
|
487 (string-match "XEmacs" emacs-version))
|
|
|
488 'XEmacs 'FSF)))
|
|
|
489 ;; I don't know
|
|
|
490 (t (error "Cannot recognize major version number: %s" major)))
|
|
134
|
491 ;; XEmacs 19 uses 8-bit modify-syntax-entry flags, as do all
|
|
|
492 ;; patched Emacs 19, Emacs 18, Epoch 4's. Only Emacs 19 uses a
|
|
|
493 ;; 1-bit flag. Let's be as smart as we can about figuring this
|
|
|
494 ;; out.
|
|
98
|
495 (if (or (eq major 'v20) (eq major 'v19))
|
|
|
496 (let ((table (copy-syntax-table)))
|
|
|
497 (modify-syntax-entry ?a ". 12345678" table)
|
|
|
498 (cond
|
|
|
499 ;; XEmacs pre 20 and Emacs pre 19.30 use vectors for syntax tables.
|
|
|
500 ((vectorp table)
|
|
|
501 (if (= (logand (lsh (aref table ?a) -16) 255) 255)
|
|
|
502 (setq comments '8-bit)
|
|
|
503 (setq comments '1-bit)))
|
|
|
504 ;; XEmacs 20 is known to be 8-bit
|
|
|
505 ((eq flavor 'XEmacs) (setq comments '8-bit))
|
|
|
506 ;; Emacs 19.30 and beyond are known to be 1-bit
|
|
|
507 ((eq flavor 'FSF) (setq comments '1-bit))
|
|
|
508 ;; Don't know what this is
|
|
|
509 (t (error "Couldn't figure out syntax table format."))
|
|
|
510 ))
|
|
|
511 ;; Emacs 18 has no support for dual comments
|
|
|
512 (setq comments 'no-dual-comments))
|
|
|
513 ;; lets do some minimal sanity checking.
|
|
|
514 (if (or
|
|
|
515 ;; Lemacs before 19.6 had bugs
|
|
|
516 (and (eq major 'v19) (eq flavor 'XEmacs) (< minor 6))
|
|
|
517 ;; Emacs 19 before 19.21 has known bugs
|
|
|
518 (and (eq major 'v19) (eq flavor 'FSF) (< minor 21))
|
|
|
519 )
|
|
|
520 (with-output-to-temp-buffer "*verilog-mode warnings*"
|
|
|
521 (print (format
|
|
134
|
522 "The version of Emacs that you are running, %s,
|
|
98
|
523 has known bugs in its syntax parsing routines which will affect the
|
|
|
524 performance of verilog-mode. You should strongly consider upgrading to the
|
|
|
525 latest available version. verilog-mode may continue to work, after a
|
|
|
526 fashion, but strange indentation errors could be encountered."
|
|
134
|
527 emacs-version))))
|
|
98
|
528 ;; Emacs 18, with no patch is not too good
|
|
|
529 (if (and (eq major 'v18) (eq comments 'no-dual-comments))
|
|
|
530 (with-output-to-temp-buffer "*verilog-mode warnings*"
|
|
|
531 (print (format
|
|
134
|
532 "The version of Emacs 18 you are running, %s,
|
|
98
|
533 has known deficiencies in its ability to handle the dual verilog
|
|
|
534 (and C++) comments, (e.g. the // and /* */ comments). This will
|
|
|
535 not be much of a problem for you if you only use the /* */ comments,
|
|
|
536 but you really should strongly consider upgrading to one of the latest
|
|
|
537 Emacs 19's. In Emacs 18, you may also experience performance degradations.
|
|
|
538 Emacs 19 has some new built-in routines which will speed things up for you.
|
|
|
539 Because of these inherent problems, verilog-mode is not supported
|
|
|
540 on emacs-18."
|
|
134
|
541 emacs-version))))
|
|
98
|
542 ;; Emacs 18 with the syntax patches are no longer supported
|
|
|
543 (if (and (eq major 'v18) (not (eq comments 'no-dual-comments)))
|
|
|
544 (with-output-to-temp-buffer "*verilog-mode warnings*"
|
|
|
545 (print (format
|
|
134
|
546 "You are running a syntax patched Emacs 18 variant. While this should
|
|
98
|
547 work for you, you may want to consider upgrading to Emacs 19.
|
|
|
548 The syntax patches are no longer supported either for verilog-mode."))))
|
|
|
549 (list major comments))
|
|
|
550 "A list of features extant in the Emacs you are using.
|
|
|
551 There are many flavors of Emacs out there, each with different
|
|
|
552 features supporting those needed by verilog-mode. Here's the current
|
|
|
553 supported list, along with the values for this variable:
|
|
|
554
|
|
|
555 Vanilla Emacs 18/Epoch 4: (v18 no-dual-comments)
|
|
|
556 Emacs 18/Epoch 4 (patch2): (v18 8-bit)
|
|
|
557 XEmacs (formerly Lucid) 19: (v19 8-bit)
|
|
134
|
558 XEmacs 20: (v20 8-bit)
|
|
98
|
559 Emacs 19: (v19 1-bit).")
|
|
|
560
|
|
|
561 (defconst verilog-comment-start-regexp "//\\|/\\*"
|
|
|
562 "Dual comment value for `comment-start-regexp'.")
|
|
|
563
|
|
|
564 (defun verilog-populate-syntax-table (table)
|
|
|
565 ;; Populate the syntax TABLE
|
|
|
566 ;; DO NOT TRY TO SET _ (UNDERSCORE) TO WORD CLASS!
|
|
|
567 (modify-syntax-entry ?\\ "\\" table)
|
|
|
568 (modify-syntax-entry ?+ "." table)
|
|
|
569 (modify-syntax-entry ?- "." table)
|
|
|
570 (modify-syntax-entry ?= "." table)
|
|
|
571 (modify-syntax-entry ?% "." table)
|
|
|
572 (modify-syntax-entry ?< "." table)
|
|
|
573 (modify-syntax-entry ?> "." table)
|
|
|
574 (modify-syntax-entry ?& "." table)
|
|
|
575 (modify-syntax-entry ?| "." table)
|
|
|
576 (modify-syntax-entry ?_ "w" table)
|
|
|
577 (modify-syntax-entry ?\' "." table)
|
|
|
578 )
|
|
|
579
|
|
|
580 (defun verilog-setup-dual-comments (table)
|
|
|
581 ;; Set up TABLE to handle block and line style comments
|
|
|
582 (cond
|
|
|
583 ((memq '8-bit verilog-emacs-features)
|
|
|
584 ;; XEmacs (formerly Lucid) has the best implementation
|
|
|
585 (modify-syntax-entry ?/ ". 1456" table)
|
|
|
586 (modify-syntax-entry ?* ". 23" table)
|
|
|
587 (modify-syntax-entry ?\n "> b" table)
|
|
|
588 ;; Give CR the same syntax as newline, for selective-display
|
|
|
589 (modify-syntax-entry ?\^m "> b" table))
|
|
|
590 ((memq '1-bit verilog-emacs-features)
|
|
|
591 ;; Emacs 19 does things differently, but we can work with it
|
|
|
592 (modify-syntax-entry ?/ ". 124b" table)
|
|
|
593 (modify-syntax-entry ?* ". 23" table)
|
|
|
594 (modify-syntax-entry ?\n "> b" table)
|
|
|
595 ;; Give CR the same syntax as newline, for selective-display
|
|
|
596 (modify-syntax-entry ?\^m "> b" table))
|
|
|
597 ))
|
|
|
598
|
|
|
599 (defvar verilog-mode-syntax-table nil
|
|
|
600 "Syntax table used in verilog-mode buffers.")
|
|
|
601 (if verilog-mode-syntax-table
|
|
|
602 ()
|
|
|
603 (setq verilog-mode-syntax-table (make-syntax-table))
|
|
|
604 (verilog-populate-syntax-table verilog-mode-syntax-table)
|
|
|
605 ;; add extra comment syntax
|
|
|
606 (verilog-setup-dual-comments verilog-mode-syntax-table)
|
|
|
607 )
|
|
134
|
608
|
|
|
609 (defvar verilog-font-lock-keywords nil
|
|
|
610 "keyword highlighting used in verilog-mode buffers.")
|
|
|
611 (defvar verilog-font-lock-keywords-1 nil
|
|
|
612 "keyword highlighting used in verilog-mode buffers.")
|
|
|
613 (defvar verilog-font-lock-keywords-2 nil
|
|
|
614 "keyword highlighting used in verilog-mode buffers.")
|
|
|
615 (defvar verilog-font-lock-keywords-3 nil
|
|
|
616 "keyword highlighting used in verilog-mode buffers.")
|
|
|
617 (defvar verilog-font-lock-keywords-4 nil
|
|
|
618 "keyword highlighting used in verilog-mode buffers.")
|
|
|
619 (if verilog-font-lock-keywords
|
|
|
620 ()
|
|
|
621 (cond
|
|
|
622 ;; We can assume 8-bit syntax table emacsen aupport new syntax
|
|
|
623 ((memq '8-bit verilog-emacs-features)
|
|
|
624 (setq verilog-font-lock-keywords verilog-font-lock-keywords-after-1930
|
|
|
625 verilog-font-lock-keywords-1 verilog-font-lock-keywords-after-1930
|
|
|
626 verilog-font-lock-keywords-2 verilog-font-lock-keywords-after-1930
|
|
|
627 verilog-font-lock-keywords-3 verilog-font-lock-keywords-after-1930
|
|
|
628 verilog-font-lock-keywords-4 verilog-font-lock-keywords-after-1930)
|
|
|
629 )
|
|
|
630 (t
|
|
|
631 (setq verilog-font-lock-keywords verilog-font-lock-keywords-before-1930
|
|
|
632 verilog-font-lock-keywords-1 verilog-font-lock-keywords-before-1930
|
|
|
633 verilog-font-lock-keywords-2 verilog-font-lock-keywords-before-1930
|
|
|
634 verilog-font-lock-keywords-3 verilog-font-lock-keywords-before-1930
|
|
|
635 verilog-font-lock-keywords-4 verilog-font-lock-keywords-before-1930)
|
|
|
636 )
|
|
|
637 )
|
|
|
638 )
|
|
|
639
|
|
98
|
640 ;;;
|
|
|
641 ;;; Macros
|
|
|
642 ;;;
|
|
|
643
|
|
|
644 (defsubst verilog-re-search-forward (REGEXP BOUND NOERROR)
|
|
|
645 "Like re-search-forward, but skips over matches in comments or strings"
|
|
|
646 (set-match-data '(nil nil))
|
|
|
647 (while (and
|
|
|
648 (re-search-forward REGEXP BOUND NOERROR)
|
|
|
649 (and (verilog-skip-forward-comment-or-string)
|
|
|
650 (progn
|
|
|
651 (store-match-data '(nil nil))
|
|
|
652 (if BOUND
|
|
|
653 (< (point) BOUND)
|
|
|
654 t)
|
|
|
655 )
|
|
|
656 )
|
|
|
657 )
|
|
|
658 )
|
|
|
659 (match-end 0))
|
|
|
660
|
|
|
661 (defsubst verilog-re-search-backward (REGEXP BOUND NOERROR)
|
|
|
662 "Like re-search-backward, but skips over matches in comments or strings"
|
|
|
663 (set-match-data '(nil nil))
|
|
|
664 (while (and
|
|
|
665 (re-search-backward REGEXP BOUND NOERROR)
|
|
|
666 (verilog-skip-backward-comment-or-string)
|
|
|
667 (not (set-match-data '(nil nil))))
|
|
|
668 ())
|
|
|
669 (match-end 0))
|
|
|
670
|
|
|
671 (defsubst verilog-get-beg-of-line (&optional arg)
|
|
|
672 (save-excursion
|
|
|
673 (beginning-of-line arg)
|
|
|
674 (point)))
|
|
|
675
|
|
|
676 (defsubst verilog-get-end-of-line (&optional arg)
|
|
|
677 (save-excursion
|
|
|
678 (end-of-line arg)
|
|
|
679 (point)))
|
|
|
680
|
|
|
681 (defun verilog-declaration-end ()
|
|
|
682 (search-forward ";"))
|
|
|
683
|
|
|
684 (defun electric-verilog-backward-sexp ()
|
|
|
685 "Move backward over a sexp"
|
|
|
686 (interactive)
|
|
|
687 ;; before that see if we are in a comment
|
|
|
688 (verilog-backward-sexp)
|
|
|
689 )
|
|
|
690 (defun electric-verilog-forward-sexp ()
|
|
|
691 "Move backward over a sexp"
|
|
|
692 (interactive)
|
|
|
693 ;; before that see if we are in a comment
|
|
|
694 (verilog-forward-sexp)
|
|
|
695 )
|
|
|
696
|
|
|
697 (defun verilog-backward-sexp ()
|
|
|
698 (let ((reg)
|
|
|
699 (elsec 1)
|
|
|
700 (found nil)
|
|
|
701 )
|
|
|
702 (if (not (looking-at "\\<"))
|
|
|
703 (forward-word -1))
|
|
|
704 (cond
|
|
|
705 ((verilog-skip-backward-comment-or-string)
|
|
|
706 )
|
|
|
707 ((looking-at "\\<else\\>")
|
|
|
708 (setq reg (concat
|
|
|
709 verilog-end-block-re
|
|
|
710 "\\|\\(\\<else\\>\\)"
|
|
|
711 "\\|\\(\\<if\\>\\)"
|
|
|
712 ))
|
|
|
713 (while (and (not found)
|
|
|
714 (verilog-re-search-backward reg nil 'move))
|
|
|
715 (cond
|
|
|
716 ((match-end 1) ; endblock
|
|
134
|
717 ; try to leap back to matching outward block by striding across
|
|
|
718 ; indent level changing tokens then immediately
|
|
|
719 ; previous line governs indentation.
|
|
98
|
720 (verilog-leap-to-head)
|
|
|
721 )
|
|
|
722 ((match-end 2) ; else, we're in deep
|
|
|
723 (setq elsec (1+ elsec))
|
|
|
724 )
|
|
|
725 ((match-end 3) ; found it
|
|
|
726 (setq elsec (1- elsec))
|
|
|
727 (if (= 0 elsec)
|
|
|
728 ;; Now previous line describes syntax
|
|
|
729 (setq found 't)
|
|
|
730 ))
|
|
|
731 )
|
|
|
732 )
|
|
|
733 )
|
|
134
|
734 ((looking-at verilog-end-block-re)
|
|
98
|
735 (verilog-leap-to-head)
|
|
|
736 )
|
|
|
737 ((looking-at "\\(endmodule\\>\\)\\|\\(\\<endprimitive\\>\\)")
|
|
|
738 (cond
|
|
|
739 ((match-end 1)
|
|
|
740 (verilog-re-search-backward "\\<\\(macro\\)?module\\>" nil 'move))
|
|
|
741 ((match-end 2)
|
|
|
742 (verilog-re-search-backward "\\<primitive\\>" nil 'move))
|
|
|
743 (t
|
|
|
744 (backward-sexp 1))))
|
|
|
745 (t
|
|
|
746 (backward-sexp))
|
|
|
747 ) ;; cond
|
|
|
748 )
|
|
|
749 )
|
|
|
750 (defun verilog-forward-sexp ()
|
|
|
751 (let ((reg)
|
|
|
752 (st (point)))
|
|
|
753 (if (not (looking-at "\\<"))
|
|
|
754 (forward-word -1))
|
|
|
755 (cond
|
|
|
756 ((verilog-skip-forward-comment-or-string)
|
|
|
757 (verilog-forward-syntactic-ws)
|
|
|
758 )
|
|
|
759 ((looking-at verilog-beg-block-re-1);; begin|fork|case|table|specify
|
|
|
760 (cond
|
|
|
761 ((match-end 1) ; end
|
|
|
762 ;; Search forward for matching begin
|
|
|
763 (setq reg "\\(\\<begin\\>\\)\\|\\(\\<end\\>\\)" )
|
|
|
764 )
|
|
|
765 ((match-end 2) ; endcase
|
|
|
766 ;; Search forward for matching case
|
|
|
767 (setq reg "\\(\\<case[xz]?\\>[^:]\\)\\|\\(\\<endcase\\>\\)" )
|
|
|
768 )
|
|
|
769 ((match-end 3) ; join
|
|
|
770 ;; Search forward for matching fork
|
|
|
771 (setq reg "\\(\\<fork\\>\\)\\|\\(\\<join\\>\\)" )
|
|
|
772 )
|
|
|
773 ((match-end 4) ; endtable
|
|
|
774 ;; Search forward for matching table
|
|
|
775 (setq reg "\\(\\<table\\>\\)\\|\\(\\<endtable\\>\\)" )
|
|
|
776 )
|
|
|
777 ((match-end 5) ; endspecify
|
|
|
778 ;; Search forward for matching specify
|
|
|
779 (setq reg "\\(\\<specify\\>\\)\\|\\(\\<endspecify\\>\\)" )
|
|
|
780 )
|
|
|
781 ((match-end 6) ; endfunction
|
|
|
782 ;; Search forward for matching function
|
|
|
783 (setq reg "\\(\\<function\\>\\)\\|\\(\\<endfunction\\>\\)" )
|
|
|
784 )
|
|
|
785 ((match-end 7) ; endspecify
|
|
|
786 ;; Search forward for matching task
|
|
|
787 (setq reg "\\(\\<task\\>\\)\\|\\(\\<endtask\\>\\)" )
|
|
|
788 )
|
|
|
789 )
|
|
|
790 (if (forward-word 1)
|
|
|
791 (catch 'skip
|
|
|
792 (let ((nest 1))
|
|
|
793 (while (verilog-re-search-forward reg nil 'move)
|
|
|
794 (cond
|
|
|
795 ((match-end 2) ; end
|
|
|
796 (setq nest (1- nest))
|
|
|
797 (if (= 0 nest)
|
|
|
798 (throw 'skip 1)))
|
|
|
799 ((match-end 1) ; begin
|
|
|
800 (setq nest (1+ nest)))))
|
|
|
801 )
|
|
|
802 )
|
|
|
803 )
|
|
|
804 )
|
|
|
805 ((looking-at "\\(\\<\\(macro\\)?module\\>\\)\\|\\(\\<primitive\\>\\)")
|
|
|
806 (cond
|
|
|
807 ((match-end 1)
|
|
|
808 (verilog-re-search-forward "\\<endmodule\\>" nil 'move))
|
|
|
809 ((match-end 2)
|
|
|
810 (verilog-re-search-forward "\\<endprimitive\\>" nil 'move))
|
|
|
811 (t
|
|
|
812 (goto-char st)
|
|
|
813 (if (= (following-char) ?\) )
|
|
|
814 (forward-char 1)
|
|
|
815 (forward-sexp 1)))))
|
|
|
816 (t
|
|
|
817 (goto-char st)
|
|
|
818 (if (= (following-char) ?\) )
|
|
|
819 (forward-char 1)
|
|
|
820 (forward-sexp 1)))
|
|
|
821 ) ;; cond
|
|
|
822 )
|
|
|
823 )
|
|
|
824
|
|
|
825
|
|
|
826 (defun verilog-declaration-beg ()
|
|
|
827 (verilog-re-search-backward verilog-declaration-re (bobp) t))
|
|
|
828
|
|
|
829 (defsubst verilog-within-string ()
|
|
|
830 (save-excursion
|
|
|
831 (nth 3 (parse-partial-sexp (verilog-get-beg-of-line) (point)))))
|
|
|
832
|
|
134
|
833 (put 'verilog-mode 'font-lock-defaults
|
|
|
834 '((verilog-font-lock-keywords-after-1930 )
|
|
|
835 nil ;; nil means highlight strings & comments as well as keywords
|
|
|
836 nil ;; nil means keywords must match case
|
|
|
837 nil ;; syntax table handled elsewhere
|
|
|
838 verilog-beg-of-defun ;; function to move to beginning of reasonable region to highlight
|
|
|
839 ))
|
|
98
|
840
|
|
|
841 ;;;###autoload
|
|
|
842 (defun verilog-mode ()
|
|
|
843 "Major mode for editing Verilog code. \\<verilog-mode-map>
|
|
|
844 NEWLINE, TAB indents for Verilog code.
|
|
|
845 Delete converts tabs to spaces as it moves back.
|
|
|
846 Supports highlighting.
|
|
|
847
|
|
|
848 Variables controlling indentation/edit style:
|
|
|
849
|
|
|
850 verilog-indent-level (default 3)
|
|
|
851 Indentation of Verilog statements with respect to containing block.
|
|
134
|
852 verilog-indent-level-module (default 3)
|
|
|
853 Absolute indentation of Module level Verilog statements.
|
|
|
854 Set to 0 to get initial and always statements lined up
|
|
|
855 on the left side of your screen.
|
|
|
856 verilog-indent-level-declaration (default 3)
|
|
|
857 Indentation of declarations with respect to containing block.
|
|
|
858 Set to 0 to get them list right under containing block.
|
|
|
859 verilog-indent-level-behavorial (default 3)
|
|
|
860 Indentation of first begin in a task or function block
|
|
|
861 Set to 0 to get such code to linedup underneath the task or function keyword
|
|
98
|
862 verilog-cexp-indent (default 1)
|
|
|
863 Indentation of Verilog statements broken across lines.
|
|
|
864 verilog-case-indent (default 2)
|
|
|
865 Indentation for case statements.
|
|
|
866 verilog-auto-newline (default nil)
|
|
134
|
867 Non-nil means automatically newline after semicolons and the punctation
|
|
|
868 mark after an end.
|
|
98
|
869 verilog-auto-indent-on-newline (default t)
|
|
|
870 Non-nil means automatically indent line after newline
|
|
|
871 verilog-tab-always-indent (default t)
|
|
|
872 Non-nil means TAB in Verilog mode should always reindent the current line,
|
|
|
873 regardless of where in the line point is when the TAB command is used.
|
|
|
874 verilog-indent-begin-after-if (default t)
|
|
108
|
875 Non-nil means to indent begin statements following a preceding
|
|
98
|
876 if, else, while, for and repeat statements, if any. otherwise,
|
|
108
|
877 the begin is lined up with the preceding token. If t, you get:
|
|
98
|
878 if (a)
|
|
|
879 begin
|
|
|
880 otherwise you get:
|
|
|
881 if (a)
|
|
|
882 begin
|
|
|
883 verilog-auto-endcomments (default t)
|
|
134
|
884 Non-nil means a comment /* ... */ is set after the ends which ends
|
|
|
885 cases, tasks, functions and modules.
|
|
98
|
886 The type and name of the object will be set between the braces.
|
|
134
|
887 verilog-minimum-comment-distance (default 40)
|
|
|
888 Minimum distance between begin and end required before a comment
|
|
|
889 will be inserted. Setting this variable to zero results in every
|
|
|
890 end aquiring a comment; the default avoids too many redundanet
|
|
|
891 comments in tight quarters.
|
|
98
|
892 verilog-auto-lineup (default `(all))
|
|
|
893 List of contexts where auto lineup of :'s or ='s should be done.
|
|
|
894
|
|
|
895 Turning on Verilog mode calls the value of the variable verilog-mode-hook with
|
|
|
896 no args, if that value is non-nil.
|
|
|
897 Other useful functions are:
|
|
134
|
898 \\[verilog-complete-word]\t-complete word with appropriate possibilities
|
|
|
899 (functions, verilog keywords...)
|
|
|
900 \\[verilog-comment-region]\t- Put marked area in a comment, fixing
|
|
|
901 nested comments.
|
|
|
902 \\[verilog-uncomment-region]\t- Uncomment an area commented with \
|
|
|
903 \\[verilog-comment-region].
|
|
98
|
904 \\[verilog-insert-block]\t- insert begin ... end;
|
|
|
905 \\[verilog-star-comment]\t- insert /* ... */
|
|
|
906 \\[verilog-mark-defun]\t- Mark function.
|
|
|
907 \\[verilog-beg-of-defun]\t- Move to beginning of current function.
|
|
|
908 \\[verilog-end-of-defun]\t- Move to end of current function.
|
|
134
|
909 \\[verilog-label-be]\t- Label matching begin ... end, fork ... join
|
|
|
910 and case ... endcase statements;
|
|
98
|
911 "
|
|
|
912 (interactive)
|
|
|
913 (kill-all-local-variables)
|
|
|
914 (use-local-map verilog-mode-map)
|
|
|
915 (setq major-mode 'verilog-mode)
|
|
|
916 (setq mode-name "Verilog")
|
|
|
917 (setq local-abbrev-table verilog-mode-abbrev-table)
|
|
|
918 (set-syntax-table verilog-mode-syntax-table)
|
|
|
919 (make-local-variable 'indent-line-function)
|
|
|
920 (setq indent-line-function 'verilog-indent-line)
|
|
|
921 (setq comment-indent-function 'verilog-indent-comment)
|
|
|
922 (make-local-variable 'parse-sexp-ignore-comments)
|
|
|
923 (setq parse-sexp-ignore-comments nil)
|
|
|
924 (make-local-variable 'comment-start)
|
|
|
925 (make-local-variable 'comment-end)
|
|
|
926 (make-local-variable 'comment-multi-line)
|
|
|
927 (make-local-variable 'comment-start-skip)
|
|
|
928 (setq comment-start "// "
|
|
|
929 comment-end ""
|
|
|
930 comment-start-skip "/\\*+ *\\|// *"
|
|
|
931 comment-multi-line nil)
|
|
134
|
932 ;; Setting up things for font-lock
|
|
|
933 (if (string-match "XEmacs" emacs-version)
|
|
|
934 (progn
|
|
|
935 (if (and current-menubar
|
|
|
936 (not (assoc "Verilog" current-menubar)))
|
|
|
937 (progn
|
|
|
938 (set-buffer-menubar (copy-sequence current-menubar))
|
|
|
939 (add-submenu nil verilog-xemacs-menu))) ))
|
|
|
940 ;; Stuff for GNU emacs
|
|
|
941 (make-local-variable 'font-lock-defaults)
|
|
|
942 (setq font-lock-defaults
|
|
|
943 '((verilog-font-lock-keywords verilog-font-lock-keywords-1
|
|
|
944 verilog-font-lock-keywords-2
|
|
|
945 verilog-font-lock-keywords-3
|
|
|
946 verilog-font-lock-keywords-4)
|
|
|
947 nil t))
|
|
|
948 ;; Tell imenu how to handle verilog.
|
|
|
949 (make-local-variable 'imenu-generic-expression)
|
|
|
950 (setq imenu-generic-expression verilog-imenu-generic-expression)
|
|
|
951 ;; End GNU emacs stuff
|
|
98
|
952 (run-hooks 'verilog-mode-hook))
|
|
|
953
|
|
|
954
|
|
|
955 ;;;
|
|
|
956 ;;; Electric functions
|
|
|
957 ;;;
|
|
|
958 (defun electric-verilog-terminate-line (&optional arg)
|
|
|
959 "Terminate line and indent next line."
|
|
|
960 (interactive)
|
|
|
961 ;; before that see if we are in a comment
|
|
|
962 (let ((state
|
|
|
963 (save-excursion
|
|
|
964 (parse-partial-sexp (point-min) (point)))))
|
|
|
965 (cond
|
|
|
966 ((nth 7 state) ; Inside // comment
|
|
|
967 (if (eolp)
|
|
|
968 (progn
|
|
|
969 (delete-horizontal-space)
|
|
|
970 (newline))
|
|
|
971 (progn
|
|
|
972 (newline)
|
|
|
973 (insert-string "// ")
|
|
|
974 (beginning-of-line)
|
|
|
975 ))
|
|
|
976 (verilog-indent-line)
|
|
|
977 )
|
|
|
978 ((nth 4 state) ; Inside any comment (hence /**/)
|
|
|
979 (newline)
|
|
|
980 (beginning-of-line)
|
|
|
981 (verilog-indent-comment t)
|
|
|
982 )
|
|
|
983 ((eolp)
|
|
|
984 ;; First, check if current line should be indented
|
|
|
985 (if (save-excursion
|
|
|
986 (delete-horizontal-space)
|
|
|
987 (beginning-of-line)
|
|
|
988 (skip-chars-forward " \t")
|
|
|
989 (if (looking-at verilog-autoindent-lines-re)
|
|
|
990 (let ((indent-str (verilog-indent-line)))
|
|
|
991 ;; Maybe we should set some endcomments
|
|
|
992 (if verilog-auto-endcomments
|
|
|
993 (verilog-set-auto-endcomments indent-str arg))
|
|
|
994 (end-of-line)
|
|
|
995 (delete-horizontal-space)
|
|
|
996 (if arg
|
|
|
997 ()
|
|
|
998 (newline))
|
|
|
999 nil)
|
|
|
1000 (progn
|
|
|
1001 (end-of-line)
|
|
|
1002 (delete-horizontal-space)
|
|
134
|
1003 't
|
|
|
1004 )))
|
|
98
|
1005 (newline)
|
|
134
|
1006 (forward-line 1)
|
|
|
1007 )
|
|
98
|
1008 ;; Indent next line
|
|
|
1009 (if verilog-auto-indent-on-newline
|
|
|
1010 (verilog-indent-line))
|
|
|
1011 )
|
|
|
1012 (t
|
|
|
1013 (newline)
|
|
|
1014 )
|
|
|
1015 )
|
|
|
1016 )
|
|
|
1017 )
|
|
|
1018
|
|
|
1019 (defun electric-verilog-semi ()
|
|
|
1020 "Insert `;' character and reindent the line."
|
|
|
1021 (interactive)
|
|
|
1022 (insert last-command-char)
|
|
134
|
1023 (if (verilog-in-comment-or-string-p)
|
|
|
1024 ()
|
|
|
1025 (save-excursion
|
|
|
1026 (beginning-of-line)
|
|
|
1027 (verilog-indent-line))
|
|
|
1028 (if (and verilog-auto-newline
|
|
|
1029 (= 0 (verilog-parenthesis-depth)))
|
|
|
1030 (electric-verilog-terminate-line))))
|
|
98
|
1031
|
|
|
1032 (defun electric-verilog-colon ()
|
|
|
1033 "Insert `:' and do all indentions except line indent on this line."
|
|
|
1034 (interactive)
|
|
|
1035 (insert last-command-char)
|
|
|
1036 ;; Do nothing if within string.
|
|
|
1037 (if (or
|
|
|
1038 (verilog-within-string)
|
|
|
1039 (not (verilog-in-case-region-p)))
|
|
|
1040 ()
|
|
|
1041 (save-excursion
|
|
|
1042 (let ((p (point))
|
|
|
1043 (lim (progn (verilog-beg-of-statement) (point))))
|
|
|
1044 (goto-char p)
|
|
|
1045 (verilog-backward-case-item lim)
|
|
|
1046 (verilog-indent-line)))
|
|
|
1047 ;; (let ((verilog-tab-always-indent nil))
|
|
|
1048 ;; (verilog-indent-line))
|
|
|
1049 )
|
|
|
1050 )
|
|
|
1051
|
|
|
1052 (defun electric-verilog-equal ()
|
|
|
1053 "Insert `=', and do indention if within block."
|
|
|
1054 (interactive)
|
|
|
1055 (insert last-command-char)
|
|
|
1056 ;; Could auto line up expressions, but not yet
|
|
|
1057 ;; (if (eq (car (verilog-calculate-indent)) 'block)
|
|
|
1058 ;; (let ((verilog-tab-always-indent nil))
|
|
|
1059 ;; (verilog-indent-command)))
|
|
|
1060 )
|
|
|
1061
|
|
|
1062
|
|
|
1063 (defun electric-verilog-tick ()
|
|
|
1064 "Insert back-tick, and indent to coulmn 0 if this is a CPP directive."
|
|
|
1065 (interactive)
|
|
|
1066 (insert last-command-char)
|
|
134
|
1067 (if (save-excursion
|
|
|
1068 (beginning-of-line)
|
|
|
1069 (looking-at
|
|
|
1070 "^[ \t]*\`\\(\\<ifdef\\>\\|\\\<else\\>\\|\\<endif\\>\\|\\<define\\>\\)"))
|
|
98
|
1071 (save-excursion (beginning-of-line)
|
|
|
1072 (delete-horizontal-space))))
|
|
|
1073
|
|
|
1074 (defun electric-verilog-tab ()
|
|
|
1075 "Function called when TAB is pressed in Verilog mode."
|
|
|
1076 (interactive)
|
|
|
1077 ;; If verilog-tab-always-indent, indent the beginning of the line.
|
|
|
1078 (if verilog-tab-always-indent
|
|
134
|
1079 (let* (
|
|
|
1080 (boi-point
|
|
|
1081 (save-excursion
|
|
|
1082 (beginning-of-line)
|
|
|
1083 (skip-chars-forward " \t")
|
|
|
1084 (let (type state )
|
|
|
1085 (setq type (verilog-indent-line))
|
|
|
1086 (setq state (car type))
|
|
|
1087 (cond
|
|
|
1088 ((eq state 'block)
|
|
|
1089 (if (looking-at verilog-behavorial-block-beg-re )
|
|
|
1090 (error
|
|
|
1091 (concat
|
|
|
1092 "The reserved word \""
|
|
|
1093 (buffer-substring (match-beginning 0) (match-end 0))
|
|
|
1094 "\" must be at the behavorial level!"))))
|
|
|
1095 ))
|
|
|
1096 (back-to-indentation)
|
|
|
1097 (point))))
|
|
98
|
1098 (if (< (point) boi-point)
|
|
|
1099 (back-to-indentation)))
|
|
|
1100 (progn (insert "\t"))
|
|
|
1101 )
|
|
|
1102 )
|
|
|
1103
|
|
|
1104
|
|
|
1105
|
|
|
1106 ;;;
|
|
|
1107 ;;; Interactive functions
|
|
|
1108 ;;;
|
|
|
1109 (defun verilog-insert-block ()
|
|
|
1110 "Insert Verilog begin ... end; block in the code with right indentation."
|
|
|
1111 (interactive)
|
|
|
1112 (verilog-indent-line)
|
|
|
1113 (insert "begin")
|
|
|
1114 (electric-verilog-terminate-line)
|
|
|
1115 (save-excursion
|
|
|
1116 (electric-verilog-terminate-line)
|
|
|
1117 (insert "end")
|
|
|
1118 (beginning-of-line)
|
|
|
1119 (verilog-indent-line)))
|
|
|
1120
|
|
|
1121 (defun verilog-star-comment ()
|
|
|
1122 "Insert Verilog star comment at point."
|
|
|
1123 (interactive)
|
|
|
1124 (verilog-indent-line)
|
|
|
1125 (insert "/*")
|
|
|
1126 (save-excursion
|
|
|
1127 (newline)
|
|
|
1128 (insert " */"))
|
|
|
1129 (newline)
|
|
|
1130 (insert " * "))
|
|
|
1131
|
|
|
1132 (defun verilog-mark-defun ()
|
|
|
1133 "Mark the current verilog function (or procedure).
|
|
|
1134 This puts the mark at the end, and point at the beginning."
|
|
|
1135 (interactive)
|
|
|
1136 (push-mark (point))
|
|
|
1137 (verilog-end-of-defun)
|
|
|
1138 (push-mark (point))
|
|
|
1139 (verilog-beg-of-defun)
|
|
|
1140 (if (fboundp 'zmacs-activate-region)
|
|
|
1141 (zmacs-activate-region)))
|
|
|
1142
|
|
134
|
1143 (defun verilog-comment-region (start end)
|
|
98
|
1144 "Put the region into a Verilog comment.
|
|
|
1145 The comments that are in this area are \"deformed\":
|
|
|
1146 `*)' becomes `!(*' and `}' becomes `!{'.
|
|
|
1147 These deformed comments are returned to normal if you use
|
|
134
|
1148 \\[verilog-uncomment-region] to undo the commenting.
|
|
98
|
1149
|
|
|
1150 The commented area starts with `verilog-exclude-str-start', and ends with
|
|
|
1151 `verilog-include-str-end'. But if you change these variables,
|
|
134
|
1152 \\[verilog-uncomment-region] won't recognize the comments."
|
|
98
|
1153 (interactive "r")
|
|
|
1154 (save-excursion
|
|
|
1155 ;; Insert start and endcomments
|
|
|
1156 (goto-char end)
|
|
|
1157 (if (and (save-excursion (skip-chars-forward " \t") (eolp))
|
|
|
1158 (not (save-excursion (skip-chars-backward " \t") (bolp))))
|
|
|
1159 (forward-line 1)
|
|
|
1160 (beginning-of-line))
|
|
|
1161 (insert verilog-exclude-str-end)
|
|
|
1162 (setq end (point))
|
|
|
1163 (newline)
|
|
|
1164 (goto-char start)
|
|
|
1165 (beginning-of-line)
|
|
|
1166 (insert verilog-exclude-str-start)
|
|
|
1167 (newline)
|
|
|
1168 ;; Replace end-comments within commented area
|
|
|
1169 (goto-char end)
|
|
|
1170 (save-excursion
|
|
|
1171 (while (re-search-backward "\\*/" start t)
|
|
134
|
1172 (replace-match "*-/" t t)))
|
|
|
1173 (save-excursion
|
|
|
1174 (let ((s+1 (1+ start)))
|
|
|
1175 (while (re-search-backward "/\\*" s+1 t)
|
|
|
1176 (replace-match "/-*" t t))))
|
|
98
|
1177 )
|
|
|
1178 )
|
|
|
1179
|
|
134
|
1180 (defun verilog-uncomment-region ()
|
|
98
|
1181 "Uncomment a commented area; change deformed comments back to normal.
|
|
|
1182 This command does nothing if the pointer is not in a commented
|
|
134
|
1183 area. See also `verilog-comment-region'."
|
|
98
|
1184 (interactive)
|
|
|
1185 (save-excursion
|
|
|
1186 (let ((start (point))
|
|
|
1187 (end (point)))
|
|
|
1188 ;; Find the boundaries of the comment
|
|
|
1189 (save-excursion
|
|
|
1190 (setq start (progn (search-backward verilog-exclude-str-start nil t)
|
|
|
1191 (point)))
|
|
|
1192 (setq end (progn (search-forward verilog-exclude-str-end nil t)
|
|
|
1193 (point))))
|
|
|
1194 ;; Check if we're really inside a comment
|
|
|
1195 (if (or (equal start (point)) (<= end (point)))
|
|
|
1196 (message "Not standing within commented area.")
|
|
|
1197 (progn
|
|
|
1198 ;; Remove endcomment
|
|
|
1199 (goto-char end)
|
|
|
1200 (beginning-of-line)
|
|
|
1201 (let ((pos (point)))
|
|
|
1202 (end-of-line)
|
|
|
1203 (delete-region pos (1+ (point))))
|
|
|
1204 ;; Change comments back to normal
|
|
|
1205 (save-excursion
|
|
134
|
1206 (while (re-search-backward "\\*-/" start t)
|
|
98
|
1207 (replace-match "*/" t t)))
|
|
134
|
1208 (save-excursion
|
|
|
1209 (while (re-search-backward "/-\\*" start t)
|
|
|
1210 (replace-match "/*" t t)))
|
|
98
|
1211 ;; Remove startcomment
|
|
|
1212 (goto-char start)
|
|
|
1213 (beginning-of-line)
|
|
|
1214 (let ((pos (point)))
|
|
|
1215 (end-of-line)
|
|
|
1216 (delete-region pos (1+ (point)))))))))
|
|
|
1217
|
|
|
1218 (defun verilog-beg-of-defun ()
|
|
|
1219 "Move backward to the beginning of the current function or procedure."
|
|
|
1220 (interactive)
|
|
|
1221 (verilog-re-search-backward verilog-defun-re nil 'move)
|
|
|
1222 )
|
|
|
1223 (defun verilog-end-of-defun ()
|
|
|
1224 (interactive)
|
|
|
1225 (verilog-re-search-forward verilog-end-defun-re nil 'move)
|
|
|
1226 )
|
|
|
1227
|
|
|
1228 (defun verilog-label-be (&optional arg)
|
|
134
|
1229 "Label matching begin ... end, fork ... join and case ... endcase
|
|
|
1230 statements in this module; With argument, first kill any existing
|
|
|
1231 labels."
|
|
98
|
1232 (interactive)
|
|
|
1233 (let ((cnt 0)
|
|
|
1234 (oldpos (point))
|
|
|
1235 (b (progn
|
|
|
1236 (verilog-beg-of-defun)
|
|
|
1237 (point-marker)))
|
|
|
1238 (e (progn
|
|
|
1239 (verilog-end-of-defun)
|
|
|
1240 (point-marker)))
|
|
|
1241 )
|
|
|
1242 (goto-char (marker-position b))
|
|
|
1243 (if (> (- e b) 200)
|
|
|
1244 (message "Relabeling module..."))
|
|
|
1245 (while (and
|
|
|
1246 (> (marker-position e) (point))
|
|
|
1247 (verilog-re-search-forward
|
|
|
1248 (concat
|
|
134
|
1249 "\\<end\\(\\(function\\)\\|\\(task\\)\\|\\(module\\)\\|"
|
|
|
1250 "\\(primitive\\)\\|\\(case\\)\\)?\\>"
|
|
98
|
1251 "\\|\\(`endif\\)\\|\\(`else\\)")
|
|
|
1252 nil 'move))
|
|
|
1253 (goto-char (match-beginning 0))
|
|
|
1254 (let ((indent-str (verilog-indent-line)))
|
|
|
1255 (verilog-set-auto-endcomments indent-str 't)
|
|
|
1256 (end-of-line)
|
|
|
1257 (delete-horizontal-space)
|
|
|
1258 )
|
|
|
1259 (setq cnt (1+ cnt))
|
|
|
1260 (if (= 9 (% cnt 10))
|
|
|
1261 (message "%d..." cnt))
|
|
|
1262 )
|
|
|
1263 (goto-char oldpos)
|
|
|
1264 (if (or
|
|
|
1265 (> (- e b) 200)
|
|
|
1266 (> cnt 20))
|
|
|
1267 (message "%d lines autocommented" cnt))
|
|
|
1268 )
|
|
|
1269 )
|
|
|
1270 (defun verilog-beg-of-statement ()
|
|
|
1271 "Move backward to beginning of statement"
|
|
|
1272 (interactive)
|
|
|
1273 (while (save-excursion
|
|
|
1274 (and
|
|
|
1275 (not (looking-at verilog-complete-reg))
|
|
134
|
1276 (verilog-backward-syntactic-ws)
|
|
98
|
1277 (not (or (bolp) (= (preceding-char) ?\;)))
|
|
|
1278 )
|
|
|
1279 )
|
|
|
1280 (skip-chars-backward " \t")
|
|
|
1281 (verilog-backward-token))
|
|
|
1282 (let ((last (point)))
|
|
|
1283 (while (progn
|
|
|
1284 (setq last (point))
|
|
|
1285 (and (not (looking-at verilog-complete-reg))
|
|
|
1286 (verilog-continued-line))))
|
|
|
1287 (goto-char last)
|
|
|
1288 (verilog-forward-syntactic-ws)
|
|
|
1289 )
|
|
|
1290 )
|
|
134
|
1291
|
|
|
1292 (defun verilog-beg-of-statement-1 ()
|
|
|
1293 "Move backward to beginning of statement"
|
|
|
1294 (interactive)
|
|
|
1295 (let ((pt (point)))
|
|
|
1296
|
|
|
1297 (while (and (not (looking-at verilog-complete-reg))
|
|
|
1298 (setq pt (point))
|
|
|
1299 (verilog-backward-token)
|
|
|
1300 (setq pt (point))
|
|
|
1301 (verilog-backward-syntactic-ws)
|
|
|
1302 (not (bolp))
|
|
|
1303 (not (= (preceding-char) ?\;)))
|
|
|
1304 )
|
|
|
1305 (goto-char pt)
|
|
|
1306 (while (progn
|
|
|
1307 (setq pt (point))
|
|
|
1308 (and (not (looking-at verilog-complete-reg))
|
|
|
1309 (not (= (preceding-char) ?\;))
|
|
|
1310 (verilog-continued-line))))
|
|
|
1311 (goto-char pt)
|
|
|
1312 (verilog-forward-syntactic-ws)
|
|
|
1313 )
|
|
|
1314 )
|
|
98
|
1315 (defun verilog-end-of-statement ()
|
|
|
1316 "Move forward to end of current statement."
|
|
|
1317 (interactive)
|
|
|
1318 (let ((nest 0) pos)
|
|
|
1319 (or (looking-at verilog-beg-block-re)
|
|
|
1320 ;; Skip to end of statement
|
|
|
1321 (setq pos (catch 'found
|
|
|
1322 (while t
|
|
|
1323 (forward-sexp 1)
|
|
|
1324 (verilog-skip-forward-comment-or-string)
|
|
|
1325 (cond ((looking-at "[ \t]*;")
|
|
|
1326 (skip-chars-forward "^;")
|
|
|
1327 (forward-char 1)
|
|
|
1328 (throw 'found (point)))
|
|
|
1329 ((save-excursion
|
|
|
1330 (forward-sexp -1)
|
|
|
1331 (looking-at verilog-beg-block-re))
|
|
|
1332 (goto-char (match-beginning 0))
|
|
|
1333 (throw 'found nil))
|
|
|
1334 ((eobp)
|
|
|
1335 (throw 'found (point))))))))
|
|
|
1336 (if (not pos)
|
|
|
1337 ;; Skip a whole block
|
|
|
1338 (catch 'found
|
|
|
1339 (while t
|
|
|
1340 (verilog-re-search-forward verilog-end-statement-re nil 'move)
|
|
|
1341 (setq nest (if (match-end 1)
|
|
|
1342 (1+ nest)
|
|
|
1343 (1- nest)))
|
|
|
1344 (cond ((eobp)
|
|
|
1345 (throw 'found (point)))
|
|
|
1346 ((= 0 nest)
|
|
|
1347 (throw 'found (verilog-end-of-statement))))))
|
|
|
1348 pos)))
|
|
|
1349 (defun verilog-in-case-region-p ()
|
|
134
|
1350 "Return TRUE if in a case region: more specifically, point @ in the
|
|
|
1351 line foo : @ begin"
|
|
98
|
1352 (interactive)
|
|
|
1353 (save-excursion
|
|
|
1354 (if (and
|
|
|
1355 (progn (verilog-forward-syntactic-ws)
|
|
|
1356 (looking-at "\\<begin\\>"))
|
|
|
1357 (progn (verilog-backward-syntactic-ws)
|
|
|
1358 (= (preceding-char) ?\:)))
|
|
|
1359 (catch 'found
|
|
|
1360 (let ((nest 1))
|
|
|
1361 (while t
|
|
134
|
1362 (verilog-re-search-backward
|
|
|
1363 (concat "\\(\\<module\\>\\)\\|\\(\\<case[xz]?\\>[^:]\\)\\|"
|
|
|
1364 "\\(\\<endcase\\>\\)\\>")
|
|
|
1365 nil 'move)
|
|
98
|
1366 (cond
|
|
|
1367 ((match-end 3)
|
|
|
1368 (setq nest (1+ nest)))
|
|
|
1369 ((match-end 2)
|
|
|
1370 (if (= nest 1)
|
|
|
1371 (throw 'found 1))
|
|
|
1372 (setq nest (1- nest))
|
|
|
1373 )
|
|
|
1374 ( t
|
|
|
1375 (throw 'found (= nest 0)))
|
|
|
1376 )
|
|
|
1377 )
|
|
|
1378 )
|
|
|
1379 )
|
|
|
1380 nil)
|
|
|
1381 )
|
|
|
1382 )
|
|
|
1383 (defun verilog-backward-case-item (lim)
|
|
|
1384 "Skip backward to nearest enclosing case item"
|
|
|
1385 (interactive)
|
|
|
1386 (let (
|
|
|
1387 (str 'nil)
|
|
134
|
1388 (lim1
|
|
|
1389 (progn
|
|
|
1390 (save-excursion
|
|
|
1391 (verilog-re-search-backward verilog-endcomment-reason-re
|
|
|
1392 lim 'move)
|
|
|
1393 (point)))))
|
|
98
|
1394 ;; Try to find the real :
|
|
|
1395 (if (save-excursion (search-backward ":" lim1 t))
|
|
|
1396 (let ((colon 0)
|
|
|
1397 b e )
|
|
134
|
1398 (while
|
|
|
1399 (and
|
|
|
1400 (< colon 1)
|
|
|
1401 (verilog-re-search-backward "\\(\\[\\)\\|\\(\\]\\)\\|\\(:\\)"
|
|
|
1402 lim1 'move))
|
|
98
|
1403 (cond
|
|
|
1404 ((match-end 1) ;; [
|
|
|
1405 (setq colon (1+ colon))
|
|
|
1406 (if (>= colon 0)
|
|
|
1407 (error "unbalanced [")))
|
|
|
1408 ((match-end 2) ;; ]
|
|
|
1409 (setq colon (1- colon)))
|
|
|
1410
|
|
|
1411 ((match-end 3) ;; :
|
|
|
1412 (setq colon (1+ colon)))
|
|
|
1413
|
|
|
1414 )
|
|
|
1415 )
|
|
|
1416 ;; Skip back to begining of case item
|
|
|
1417 (skip-chars-backward "\t ")
|
|
|
1418 (verilog-skip-backward-comment-or-string)
|
|
|
1419 (setq e (point))
|
|
134
|
1420 (setq b
|
|
|
1421 (progn
|
|
|
1422 (if
|
|
|
1423 (verilog-re-search-backward
|
|
|
1424 "\\<\\(case[zx]?\\)\\>\\|;\\|\\<end\\>" nil 'move)
|
|
|
1425 (progn
|
|
|
1426 (cond
|
|
|
1427 ((match-end 1)
|
|
|
1428 (goto-char (match-end 1))
|
|
|
1429 (verilog-forward-ws&directives)
|
|
|
1430 (if (looking-at "(")
|
|
|
1431 (progn
|
|
|
1432 (forward-sexp)
|
|
|
1433 (verilog-forward-ws&directives)
|
|
|
1434 ))
|
|
|
1435 (point))
|
|
|
1436 (t
|
|
|
1437 (goto-char (match-end 0))
|
|
|
1438 (verilog-forward-ws&directives)
|
|
|
1439 (point))
|
|
|
1440 ))
|
|
|
1441 (error "Malformed case item")
|
|
98
|
1442 )
|
|
134
|
1443 )
|
|
98
|
1444 )
|
|
|
1445 (setq str (buffer-substring b e))
|
|
134
|
1446 (if
|
|
|
1447 (setq e
|
|
|
1448 (string-match
|
|
|
1449 "[ \t]*\\(\\(\n\\)\\|\\(//\\)\\|\\(/\\*\\)\\)" str))
|
|
98
|
1450 (setq str (concat (substring str 0 e) "...")))
|
|
|
1451 str)
|
|
|
1452 'nil)
|
|
|
1453 )
|
|
|
1454 )
|
|
|
1455
|
|
|
1456
|
|
|
1457 ;;;
|
|
|
1458 ;;; Other functions
|
|
|
1459 ;;;
|
|
|
1460
|
|
|
1461 (defun kill-existing-comment ()
|
|
|
1462 "kill autocomment on this line"
|
|
|
1463 (save-excursion
|
|
|
1464 (let* (
|
|
|
1465 (e (progn
|
|
|
1466 (end-of-line)
|
|
|
1467 (point)))
|
|
|
1468 (b (progn
|
|
|
1469 (beginning-of-line)
|
|
|
1470 (search-forward "//" e t))))
|
|
|
1471 (if b
|
|
|
1472 (delete-region (- b 2) e))
|
|
|
1473 )
|
|
|
1474 )
|
|
|
1475 )
|
|
|
1476
|
|
|
1477 (defun verilog-set-auto-endcomments (indent-str kill-existing-comment)
|
|
|
1478 "Insert `// case: 7 ' or `// NAME ' on this line if appropriate.
|
|
|
1479 Insert `// case expr ' if this line ends a case block.
|
|
|
1480 Insert `// ifdef FOO ' if this line ends code conditional on FOO.
|
|
|
1481 Insert `// NAME ' if this line ends a module or primitive named NAME."
|
|
|
1482 (save-excursion
|
|
|
1483 (cond
|
|
|
1484 (; Comment close preprocessor directives
|
|
|
1485 (and
|
|
|
1486 (looking-at "\\(`endif\\)\\|\\(`else\\)")
|
|
|
1487 (or kill-existing-comment
|
|
|
1488 (not (save-excursion
|
|
|
1489 (end-of-line)
|
|
|
1490 (search-backward "//" (verilog-get-beg-of-line) t)))))
|
|
|
1491 (let ( (reg "\\(`else\\)\\|\\(`ifdef\\)\\|\\(`endif\\)")
|
|
|
1492 (nest 1)
|
|
|
1493 b e
|
|
|
1494 (else (if (match-end 2)
|
|
|
1495 1
|
|
|
1496 0))
|
|
|
1497 )
|
|
|
1498 (end-of-line)
|
|
|
1499 (if kill-existing-comment
|
|
|
1500 (kill-existing-comment))
|
|
|
1501 (delete-horizontal-space)
|
|
|
1502 (save-excursion
|
|
|
1503 (backward-sexp 1)
|
|
|
1504 (while (and (/= nest 0)
|
|
|
1505 (verilog-re-search-backward reg nil 'move))
|
|
|
1506 (cond
|
|
|
1507 ((match-end 1) ; `else
|
|
|
1508 (if (= nest 1)
|
|
|
1509 (setq else 1)))
|
|
|
1510 ((match-end 2) ; `ifdef
|
|
|
1511 (setq nest (1- nest)))
|
|
|
1512 ((match-end 3) ; `endif
|
|
|
1513 (setq nest (1+ nest)))
|
|
|
1514 ))
|
|
|
1515 (if (match-end 0)
|
|
|
1516 (setq b (progn
|
|
|
1517 (skip-chars-forward "^ \t")
|
|
|
1518 (verilog-forward-syntactic-ws)
|
|
|
1519 (point))
|
|
|
1520 e (progn
|
|
|
1521 (skip-chars-forward "a-zA-Z0-9_")
|
|
|
1522 (point)
|
|
|
1523 ))))
|
|
|
1524 (if b
|
|
|
1525 (if (> (- (point) b) verilog-minimum-comment-distance)
|
|
|
1526 (insert (concat (if
|
|
|
1527 (= else 0)
|
|
|
1528 " // ifdef "
|
|
|
1529 " // !ifdef ")
|
|
|
1530 (buffer-substring b e))))
|
|
|
1531 (progn
|
|
|
1532 (insert " // unmatched `endif")
|
|
|
1533 (ding 't))
|
|
|
1534 )))
|
|
|
1535
|
|
|
1536 (; Comment close case/function/task/module and named block
|
|
|
1537 (and (looking-at "\\<end")
|
|
|
1538 (or kill-existing-comment
|
|
|
1539 (not (save-excursion
|
|
|
1540 (end-of-line)
|
|
|
1541 (search-backward "//" (verilog-get-beg-of-line) t)))))
|
|
|
1542 (let ((type (car indent-str)))
|
|
|
1543 (if (eq type 'declaration)
|
|
|
1544 ()
|
|
|
1545 (if
|
|
134
|
1546 (looking-at verilog-enders-re)
|
|
98
|
1547 (cond
|
|
|
1548 (;- This is a case block; search back for the start of this case
|
|
|
1549 (match-end 1)
|
|
|
1550
|
|
|
1551 (let ((err 't)
|
|
|
1552 (str "UNMATCHED!!"))
|
|
|
1553 (save-excursion
|
|
|
1554 (verilog-leap-to-head)
|
|
|
1555 (if (match-end 0)
|
|
|
1556 (progn
|
|
|
1557 (goto-char (match-end 1))
|
|
|
1558 (setq str (concat (buffer-substring (match-beginning 1) (match-end 1))
|
|
|
1559 (verilog-get-expr)))
|
|
|
1560 (setq err nil))))
|
|
|
1561 (end-of-line)
|
|
|
1562 (if kill-existing-comment
|
|
|
1563 (kill-existing-comment))
|
|
|
1564 (delete-horizontal-space)
|
|
|
1565 (insert (concat " // " str ))
|
|
|
1566 (if err (ding 't))
|
|
|
1567 ))
|
|
|
1568
|
|
|
1569 (;- This is a begin..end block
|
|
|
1570 (match-end 2)
|
|
|
1571 (let ((str " // UNMATCHED !!")
|
|
|
1572 (err 't)
|
|
|
1573 (here (point))
|
|
|
1574 there
|
|
|
1575 cntx
|
|
|
1576 )
|
|
|
1577 (save-excursion
|
|
|
1578 (verilog-leap-to-head)
|
|
|
1579 (setq there (point))
|
|
|
1580 (if (not (match-end 0))
|
|
|
1581 (progn
|
|
|
1582 (goto-char here)
|
|
|
1583 (end-of-line)
|
|
|
1584 (if kill-existing-comment
|
|
|
1585 (kill-existing-comment))
|
|
|
1586 (delete-horizontal-space)
|
|
|
1587 (insert str)
|
|
|
1588 (ding 't)
|
|
|
1589 )
|
|
|
1590 (let ( sp
|
|
|
1591 (lim (save-excursion (verilog-beg-of-defun) (point)))
|
|
|
1592 (here (point))
|
|
|
1593 )
|
|
|
1594 (cond
|
|
|
1595 (;-- handle named block differently
|
|
|
1596 (looking-at verilog-named-block-re)
|
|
|
1597 (search-forward ":")
|
|
|
1598 (setq there (point))
|
|
|
1599 (setq str (verilog-get-expr))
|
|
|
1600 (setq err nil)
|
|
|
1601 (setq str (concat " // block: " str )))
|
|
|
1602
|
|
|
1603 ((verilog-in-case-region-p) ;-- handle case item differently
|
|
|
1604 (goto-char here)
|
|
|
1605 (setq str (verilog-backward-case-item lim))
|
|
|
1606 (setq there (point))
|
|
|
1607 (setq err nil)
|
|
|
1608 (setq str (concat " // case: " str ))
|
|
|
1609 )
|
|
|
1610 (;- try to find "reason" for this begin
|
|
|
1611 (cond
|
|
|
1612 (;
|
|
134
|
1613 (eq here (progn
|
|
|
1614 (verilog-backward-token)
|
|
|
1615 (verilog-beg-of-statement)
|
|
|
1616 (point)))
|
|
98
|
1617 (setq err nil)
|
|
|
1618 (setq str ""))
|
|
|
1619 ((looking-at verilog-endcomment-reason-re)
|
|
|
1620 (setq there (match-end 0))
|
|
|
1621 (setq cntx (concat
|
|
|
1622 (buffer-substring (match-beginning 0) (match-end 0)) " "))
|
|
|
1623 (cond
|
|
|
1624 (;
|
|
|
1625 (match-end 2)
|
|
|
1626 (setq err nil)
|
|
|
1627 (save-excursion
|
|
|
1628 (goto-char sp)
|
|
|
1629 (if (and (verilog-continued-line)
|
|
|
1630 (looking-at "\\<repeat\\>\\|\\<wait\\>\\|\\<always\\>"))
|
|
|
1631 (progn
|
|
|
1632 (goto-char (match-end 0))
|
|
|
1633 (setq there (point))
|
|
|
1634 (setq str
|
|
|
1635 (concat " // "
|
|
|
1636 (buffer-substring (match-beginning 0) (match-end 0)) " "
|
|
|
1637 (verilog-get-expr))))
|
|
|
1638 (setq str "")
|
|
|
1639 )
|
|
|
1640 )
|
|
|
1641 )
|
|
|
1642 (;- else
|
|
|
1643 (match-end 4)
|
|
|
1644 (let ((nest 0)
|
|
|
1645 ( reg "\\(\\<begin\\>\\)\\|\\(\\<end\\>\\)\\|\\(\\<if\\>\\)")
|
|
|
1646 )
|
|
|
1647 (catch 'skip
|
|
|
1648 (while (verilog-re-search-backward reg nil 'move)
|
|
|
1649 (cond
|
|
|
1650 ((match-end 1) ; begin
|
|
|
1651 (setq nest (1- nest)))
|
|
|
1652 ((match-end 2) ; end
|
|
|
1653 (setq nest (1+ nest)))
|
|
|
1654 ((match-end 3)
|
|
|
1655 (if (= 0 nest)
|
|
|
1656 (progn
|
|
|
1657 (goto-char (match-end 0))
|
|
|
1658 (setq there (point))
|
|
|
1659 (setq err nil)
|
|
|
1660 (setq str (verilog-get-expr))
|
|
|
1661 (setq str (concat " // else: !if" str ))
|
|
|
1662 (throw 'skip 1))
|
|
|
1663 )))
|
|
|
1664 )
|
|
|
1665 )
|
|
|
1666 )
|
|
|
1667 )
|
|
134
|
1668 (;- end else
|
|
|
1669 (match-end 5)
|
|
|
1670 (goto-char there)
|
|
|
1671 (let ((nest 0)
|
|
|
1672 ( reg "\\(\\<begin\\>\\)\\|\\(\\<end\\>\\)\\|\\(\\<if\\>\\)")
|
|
|
1673 )
|
|
|
1674 (catch 'skip
|
|
|
1675 (while (verilog-re-search-backward reg nil 'move)
|
|
|
1676 (cond
|
|
|
1677 ((match-end 1) ; begin
|
|
|
1678 (setq nest (1- nest)))
|
|
|
1679 ((match-end 2) ; end
|
|
|
1680 (setq nest (1+ nest)))
|
|
|
1681 ((match-end 3)
|
|
|
1682 (if (= 0 nest)
|
|
|
1683 (progn
|
|
|
1684 (goto-char (match-end 0))
|
|
|
1685 (setq there (point))
|
|
|
1686 (setq err nil)
|
|
|
1687 (setq str (verilog-get-expr))
|
|
|
1688 (setq str (concat " // else: !if" str ))
|
|
|
1689 (throw 'skip 1))
|
|
|
1690 )))
|
|
|
1691 )
|
|
|
1692 )
|
|
|
1693 )
|
|
|
1694 )
|
|
|
1695
|
|
98
|
1696 (;- task/function/initial et cetera
|
|
|
1697 t
|
|
|
1698 (match-end 0)
|
|
|
1699 (goto-char (match-end 0))
|
|
|
1700 (setq there (point))
|
|
|
1701 (setq err nil)
|
|
|
1702 (setq str (verilog-get-expr))
|
|
|
1703 (setq str (concat " // " cntx str )))
|
|
|
1704
|
|
|
1705 (;-- otherwise...
|
|
|
1706 (setq str " // auto-endcomment confused ")
|
|
|
1707 )
|
|
|
1708 )
|
|
|
1709 )
|
|
|
1710 ((and
|
|
|
1711 (verilog-in-case-region-p) ;-- handle case item differently
|
|
|
1712 (progn
|
|
|
1713 (setq there (point))
|
|
|
1714 (goto-char here)
|
|
|
1715 (setq str (verilog-backward-case-item lim))))
|
|
|
1716 (setq err nil)
|
|
|
1717 (setq str (concat " // case: " str ))
|
|
|
1718 )
|
|
|
1719 )
|
|
|
1720 )
|
|
|
1721 )
|
|
|
1722 )
|
|
|
1723 (goto-char here)
|
|
|
1724 (end-of-line)
|
|
|
1725 (if kill-existing-comment
|
|
|
1726 (kill-existing-comment))
|
|
|
1727 (delete-horizontal-space)
|
|
|
1728 (if (or err
|
|
|
1729 (> (- here there) verilog-minimum-comment-distance))
|
|
|
1730 (insert str))
|
|
|
1731 (if err (ding 't))
|
|
|
1732 )
|
|
|
1733 )
|
|
|
1734 )
|
|
|
1735 )
|
|
|
1736
|
|
|
1737
|
|
|
1738 (;- this is end{function,task,module}
|
|
|
1739 t
|
|
|
1740 (let (string reg (width nil))
|
|
|
1741 (end-of-line)
|
|
|
1742 (if kill-existing-comment
|
|
|
1743 (kill-existing-comment))
|
|
|
1744 (delete-horizontal-space)
|
|
|
1745 (backward-sexp)
|
|
|
1746 (cond
|
|
|
1747 ((match-end 5)
|
|
|
1748 (setq reg "\\(\\<function\\>\\)\\|\\(\\<\\(endfunction\\|task\\|\\(macro\\)?module\\|primitive\\)\\>\\)")
|
|
|
1749 (setq width "\\([ \t]*\\[[^]]*\\]\\)?")
|
|
|
1750 )
|
|
|
1751 ((match-end 6)
|
|
|
1752 (setq reg "\\(\\<task\\>\\)\\|\\(\\<\\(endtask\\|function\\|\\(macro\\)?module\\|primitive\\)\\>\\)"))
|
|
|
1753 ((match-end 7)
|
|
|
1754 (setq reg "\\(\\<\\(macro\\)?module\\>\\)\\|\\<endmodule\\>"))
|
|
|
1755 ((match-end 8)
|
|
|
1756 (setq reg "\\(\\<primitive\\>\\)\\|\\(\\<\\(endprimitive\\|function\\|task\\|\\(macro\\)?module\\)\\>\\)"))
|
|
|
1757 )
|
|
|
1758 (let (b e)
|
|
|
1759 (save-excursion
|
|
|
1760 (verilog-re-search-backward reg nil 'move)
|
|
|
1761 (cond
|
|
|
1762 ((match-end 1)
|
|
|
1763 (setq b (progn
|
|
|
1764 (skip-chars-forward "^ \t")
|
|
|
1765 (verilog-forward-ws&directives)
|
|
|
1766 (if (and width (looking-at width))
|
|
|
1767 (progn
|
|
|
1768 (goto-char (match-end 0))
|
|
|
1769 (verilog-forward-ws&directives)
|
|
|
1770 ))
|
|
|
1771 (point))
|
|
|
1772 e (progn
|
|
|
1773 (skip-chars-forward "a-zA-Z0-9_")
|
|
|
1774 (point)))
|
|
|
1775 (setq string (buffer-substring b e)))
|
|
|
1776 (t
|
|
|
1777 (ding 't)
|
|
|
1778 (setq string "unmactched end(function|task|module|primitive)")))))
|
|
|
1779 (end-of-line)
|
|
|
1780 (insert (concat " // " string )))
|
|
|
1781 )
|
|
|
1782 )
|
|
|
1783 )
|
|
|
1784 )
|
|
|
1785 )
|
|
|
1786 )
|
|
|
1787 )
|
|
|
1788 )
|
|
|
1789 )
|
|
|
1790
|
|
|
1791 (defun verilog-get-expr()
|
|
|
1792 "Grab expression at point, e.g, case ( a | b & (c ^d))"
|
|
|
1793 (let* ((b (progn
|
|
|
1794 (verilog-forward-syntactic-ws)
|
|
|
1795 (skip-chars-forward " \t")
|
|
|
1796 (point)))
|
|
|
1797 (e (let ((par 1))
|
|
|
1798 (cond
|
|
|
1799 ((looking-at "(")
|
|
|
1800 (forward-char 1)
|
|
|
1801 (while (and (/= par 0)
|
|
|
1802 (verilog-re-search-forward "\\((\\)\\|\\()\\)" nil 'move))
|
|
|
1803 (cond
|
|
|
1804 ((match-end 1)
|
|
|
1805 (setq par (1+ par)))
|
|
|
1806 ((match-end 2)
|
|
|
1807 (setq par (1- par)))))
|
|
|
1808 (point))
|
|
|
1809 ((looking-at "\\[")
|
|
|
1810 (forward-char 1)
|
|
|
1811 (while (and (/= par 0)
|
|
|
1812 (verilog-re-search-forward "\\(\\[\\)\\|\\(\\]\\)" nil 'move))
|
|
|
1813 (cond
|
|
|
1814 ((match-end 1)
|
|
|
1815 (setq par (1+ par)))
|
|
|
1816 ((match-end 2)
|
|
|
1817 (setq par (1- par)))))
|
|
|
1818 (verilog-forward-syntactic-ws)
|
|
|
1819 (skip-chars-forward "^ \t\n")
|
|
|
1820 (point))
|
|
|
1821 ((looking-at "/[/\\*]")
|
|
|
1822 b)
|
|
|
1823 ('t
|
|
|
1824 (skip-chars-forward "^: \t\n")
|
|
|
1825 (point)
|
|
|
1826 ))))
|
|
|
1827 (str (buffer-substring b e)))
|
|
|
1828 (if (setq e (string-match "[ \t]*\\(\\(\n\\)\\|\\(//\\)\\|\\(/\\*\\)\\)" str))
|
|
|
1829 (setq str (concat (substring str 0 e) "...")))
|
|
|
1830 str)
|
|
|
1831 )
|
|
|
1832
|
|
|
1833
|
|
|
1834 ;;;
|
|
|
1835 ;;; Indentation
|
|
|
1836 ;;;
|
|
|
1837 (defconst verilog-indent-alist
|
|
|
1838 '((block . (+ ind verilog-indent-level))
|
|
|
1839 (case . (+ ind verilog-case-indent))
|
|
|
1840 (cparenexp . (+ ind verilog-indent-level))
|
|
|
1841 (cexp . (+ ind verilog-indent-level))
|
|
134
|
1842 (defun . verilog-indent-level-module)
|
|
|
1843 (declaration . verilog-indent-level-declaration)
|
|
98
|
1844 (tf . verilog-indent-level)
|
|
134
|
1845 (behavorial . (+ verilog-indent-level-behavorial verilog-indent-level-module))
|
|
98
|
1846 (statement . ind)
|
|
|
1847 (cpp . 0)
|
|
|
1848 (comment . (verilog-indent-comment))
|
|
|
1849 (unknown . 3)
|
|
|
1850 (string . 0)))
|
|
|
1851
|
|
|
1852 (defun verilog-calculate-indent ()
|
|
|
1853 "Calculate the indent of the current Verilog line, through examination
|
|
|
1854 of previous lines. Once a line is found that is definitive as to the
|
|
|
1855 type of the current line, return that lines' indent level and it's
|
|
|
1856 type. Return a list of two elements: (INDENT-TYPE INDENT-LEVEL)."
|
|
|
1857 (save-excursion
|
|
|
1858 (let* ((starting_position (point))
|
|
|
1859 (par 0)
|
|
|
1860 (begin (looking-at "[ \t]*begin\\>"))
|
|
|
1861 (type (catch 'nesting
|
|
|
1862 ;; Keep working backwards until we can figure out
|
|
|
1863 ;; what type of statement this is.
|
|
|
1864 ;; Basically we need to figure out
|
|
|
1865 ;; 1) if this is a continuation of the previous line;
|
|
|
1866 ;; 2) are we in a block scope (begin..end)
|
|
|
1867
|
|
|
1868 ;; if we are in a comment, done.
|
|
|
1869 (if (verilog-in-star-comment-p) (throw 'nesting 'comment))
|
|
|
1870
|
|
|
1871 ;; if we are in a parenthesized list, done.
|
|
|
1872 (if (verilog-in-paren) (progn (setq par 1) (throw 'nesting 'block)))
|
|
|
1873
|
|
|
1874 ;; See if we are continuing a previous line
|
|
|
1875 (while t
|
|
|
1876 ;; trap out if we crawl off the top of the buffer
|
|
|
1877 (if (bobp) (throw 'nesting 'cpp))
|
|
|
1878
|
|
134
|
1879 (if (verilog-continued-line-1)
|
|
98
|
1880 (let ((sp (point)))
|
|
|
1881 (if (and
|
|
|
1882 (not (looking-at verilog-complete-reg))
|
|
134
|
1883 (verilog-continued-line-1))
|
|
98
|
1884 (progn (goto-char sp)
|
|
|
1885 (throw 'nesting 'cexp))
|
|
|
1886 (goto-char sp))
|
|
134
|
1887
|
|
98
|
1888 (if (and begin
|
|
|
1889 (not verilog-indent-begin-after-if)
|
|
|
1890 (looking-at verilog-no-indent-begin-re))
|
|
|
1891 (throw 'nesting 'statement)
|
|
134
|
1892 (progn
|
|
|
1893 (throw 'nesting 'cexp)
|
|
|
1894 )
|
|
|
1895 ))
|
|
98
|
1896
|
|
|
1897 ;; not a continued line
|
|
|
1898 (goto-char starting_position))
|
|
|
1899
|
|
|
1900 (if (looking-at "\\<else\\>")
|
|
|
1901 ;; search back for governing if, striding across begin..end pairs
|
|
|
1902 ;; appropriately
|
|
134
|
1903 (let ((elsec 1))
|
|
|
1904 (while (verilog-re-search-backward verilog-ends-re nil 'move)
|
|
98
|
1905 (cond
|
|
134
|
1906 ((match-end 1) ; else, we're in deep
|
|
|
1907 (setq elsec (1+ elsec))
|
|
|
1908 )
|
|
|
1909 ((match-end 2) ; found it
|
|
|
1910 (setq elsec (1- elsec))
|
|
|
1911 (if (= 0 elsec)
|
|
|
1912 ;; Now previous line describes syntax
|
|
|
1913 (throw 'nesting 'statement)
|
|
|
1914 ))
|
|
|
1915 (t ; endblock
|
|
|
1916 ; try to leap back to matching outward block by striding across
|
|
|
1917 ; indent level changing tokens then immediately
|
|
|
1918 ; previous line governs indentation.
|
|
98
|
1919 (let ((reg)(nest 1))
|
|
134
|
1920 ;; (looking-at verilog-end-block-re-1);; end|join|endcase|endtable|endspecify
|
|
98
|
1921 (cond
|
|
134
|
1922 ((match-end 3) ; end
|
|
98
|
1923 ;; Search back for matching begin
|
|
|
1924 (setq reg "\\(\\<begin\\>\\)\\|\\(\\<end\\>\\)" )
|
|
|
1925 )
|
|
134
|
1926 ((match-end 4) ; endcase
|
|
98
|
1927 ;; Search back for matching case
|
|
|
1928 (setq reg "\\(\\<case[xz]?\\>[^:]\\)\\|\\(\\<endcase\\>\\)" )
|
|
|
1929 )
|
|
134
|
1930 ((match-end 5) ; join
|
|
98
|
1931 ;; Search back for matching fork
|
|
|
1932 (setq reg "\\(\\<fork\\>\\)\\|\\(\\<join\\>\\)" )
|
|
|
1933 )
|
|
134
|
1934 ((match-end 6) ; endtable
|
|
98
|
1935 ;; Search back for matching table
|
|
|
1936 (setq reg "\\(\\<table\\>\\)\\|\\(\\<endtable\\>\\)" )
|
|
|
1937 )
|
|
134
|
1938 ((match-end 7) ; endspecify
|
|
98
|
1939 ;; Search back for matching specify
|
|
|
1940 (setq reg "\\(\\<specify\\>\\)\\|\\(\\<endspecify\\>\\)" )
|
|
|
1941 )
|
|
134
|
1942 ((match-end 8) ; endfunction
|
|
98
|
1943 ;; Search back for matching function
|
|
|
1944 (setq reg "\\(\\<function\\>\\)\\|\\(\\<endfunction\\>\\)" )
|
|
|
1945 )
|
|
134
|
1946 ((match-end 9) ; endtask
|
|
98
|
1947 ;; Search back for matching task
|
|
|
1948 (setq reg "\\(\\<task\\>\\)\\|\\(\\<endtask\\>\\)" )
|
|
|
1949 )
|
|
|
1950 )
|
|
|
1951 (catch 'skip
|
|
|
1952 (while (verilog-re-search-backward reg nil 'move)
|
|
|
1953 (cond
|
|
|
1954 ((match-end 1) ; begin
|
|
|
1955 (setq nest (1- nest))
|
|
|
1956 (if (= 0 nest)
|
|
|
1957 (throw 'skip 1)))
|
|
|
1958 ((match-end 2) ; end
|
|
|
1959 (setq nest (1+ nest)))))
|
|
|
1960 )
|
|
|
1961 )
|
|
|
1962 )
|
|
134
|
1963 )
|
|
98
|
1964 )
|
|
|
1965 )
|
|
|
1966 )
|
|
134
|
1967 (throw 'nesting (verilog-calc-1))
|
|
98
|
1968 )
|
|
|
1969 )
|
|
|
1970 )
|
|
|
1971 )
|
|
|
1972 ;; Return type of block and indent level.
|
|
|
1973 (if (not type)
|
|
|
1974 (setq type 'cpp))
|
|
|
1975 (if (> par 0) ; Unclosed Parenthesis
|
|
|
1976 (list 'cparenexp par)
|
|
134
|
1977 (cond
|
|
|
1978 ((eq type 'case)
|
|
|
1979 (list type (verilog-case-indent-level)))
|
|
|
1980 ((eq type 'statement)
|
|
|
1981 (list type (current-column)))
|
|
|
1982 ((eq type 'defun)
|
|
|
1983 (list type 0))
|
|
|
1984 (t
|
|
|
1985 (list type (verilog-indent-level)))))
|
|
|
1986 )
|
|
|
1987 )
|
|
|
1988 )
|
|
|
1989 (defun verilog-calc-1 ()
|
|
|
1990 ""
|
|
|
1991 (catch 'nesting
|
|
|
1992 (while (verilog-re-search-backward verilog-indent-re nil 'move)
|
|
|
1993 (cond
|
|
|
1994 ((looking-at verilog-beg-block-re-1)
|
|
|
1995 (cond
|
|
|
1996 ((match-end 2) (throw 'nesting 'case))
|
|
|
1997 (t (throw 'nesting 'block))))
|
|
|
1998
|
|
|
1999 ((looking-at verilog-end-block-re)
|
|
|
2000 (verilog-leap-to-head)
|
|
|
2001 (if (verilog-in-case-region-p)
|
|
|
2002 (progn
|
|
|
2003 (verilog-leap-to-case-head)
|
|
|
2004 (if (looking-at verilog-case-re)
|
|
|
2005 (throw 'nesting 'case))
|
|
|
2006 )))
|
|
|
2007
|
|
|
2008 ((looking-at verilog-defun-level-re)
|
|
|
2009 (throw 'nesting 'defun))
|
|
|
2010
|
|
|
2011 ((looking-at verilog-cpp-level-re)
|
|
|
2012 (throw 'nesting 'cpp))
|
|
|
2013
|
|
|
2014 ((looking-at verilog-behavorial-level-re)
|
|
|
2015 (throw 'nesting 'behavorial))
|
|
|
2016
|
|
|
2017 ((bobp)
|
|
|
2018 (throw 'nesting 'cpp))
|
|
|
2019 )
|
|
|
2020 )
|
|
|
2021 )
|
|
|
2022 )
|
|
|
2023
|
|
98
|
2024 (defun verilog-leap-to-case-head () ""
|
|
|
2025 (let ((nest 1))
|
|
|
2026 (while (/= 0 nest)
|
|
|
2027 (verilog-re-search-backward "\\(\\<case[xz]?\\>[^:]\\)\\|\\(\\<endcase\\>\\)" nil 'move)
|
|
|
2028 (cond
|
|
|
2029 ((match-end 1)
|
|
|
2030 (setq nest (1- nest)))
|
|
|
2031 ((match-end 2)
|
|
|
2032 (setq nest (1+ nest)))
|
|
|
2033 ((bobp)
|
|
|
2034 (ding 't)
|
|
|
2035 (setq nest 0))
|
|
|
2036 )
|
|
|
2037 )
|
|
|
2038 )
|
|
|
2039 )
|
|
|
2040
|
|
134
|
2041 (defun verilog-leap-to-head ()
|
|
|
2042 "Move point to the head of this block; jump from end to matching begin,
|
|
|
2043 from endcase to matching case, and so on."
|
|
98
|
2044 (let (reg
|
|
|
2045 snest
|
|
|
2046 (nest 1))
|
|
134
|
2047 (cond
|
|
|
2048 ((looking-at "\\<end\\>")
|
|
|
2049 ;; Search back for matching begin
|
|
|
2050 (setq reg (concat "\\(\\<begin\\>\\)\\|\\(\\<end\\>\\)\\|"
|
|
|
2051 "\\(\\<endcase\\>\\)\\|\\(\\<join\\>\\)" )))
|
|
|
2052
|
|
|
2053 ((looking-at "\\<endcase\\>")
|
|
|
2054 ;; Search back for matching case
|
|
|
2055 (setq reg "\\(\\<case[xz]?\\>\\)\\|\\(\\<endcase\\>\\)" )
|
|
|
2056 )
|
|
|
2057 ((looking-at "\\<join\\>")
|
|
|
2058 ;; Search back for matching fork
|
|
|
2059 (setq reg "\\(\\<fork\\>\\)\\|\\(\\<join\\>\\)" )
|
|
|
2060 )
|
|
|
2061 ((looking-at "\\<endtable\\>")
|
|
|
2062 ;; Search back for matching table
|
|
|
2063 (setq reg "\\(\\<table\\>\\)\\|\\(\\<endtable\\>\\)" )
|
|
|
2064 )
|
|
|
2065 ((looking-at "\\<endspecify\\>")
|
|
|
2066 ;; Search back for matching specify
|
|
|
2067 (setq reg "\\(\\<specify\\>\\)\\|\\(\\<endspecify\\>\\)" )
|
|
|
2068 )
|
|
|
2069 ((looking-at "\\<endfunction\\>")
|
|
|
2070 ;; Search back for matching function
|
|
|
2071 (setq reg "\\(\\<function\\>\\)\\|\\(\\<endfunction\\>\\)" )
|
|
|
2072 )
|
|
|
2073 ((looking-at "\\<endtask\\>")
|
|
|
2074 ;; Search back for matching task
|
|
|
2075 (setq reg "\\(\\<task\\>\\)\\|\\(\\<endtask\\>\\)" )
|
|
|
2076 )
|
|
|
2077 )
|
|
|
2078 (catch 'skip
|
|
|
2079 (let (sreg)
|
|
|
2080 (while (verilog-re-search-backward reg nil 'move)
|
|
98
|
2081 (cond
|
|
134
|
2082 ((match-end 1) ; begin
|
|
|
2083 (setq nest (1- nest))
|
|
|
2084 (if (= 0 nest)
|
|
|
2085 ;; Now previous line describes syntax
|
|
|
2086 (throw 'skip 1))
|
|
|
2087 (if (and snest
|
|
|
2088 (= snest nest))
|
|
|
2089 (setq reg sreg))
|
|
|
2090 )
|
|
|
2091 ((match-end 2) ; end
|
|
|
2092 (setq nest (1+ nest))
|
|
|
2093 )
|
|
|
2094 ((match-end 3)
|
|
|
2095 ;; endcase, jump to case
|
|
|
2096 (setq snest nest)
|
|
|
2097 (setq nest (1+ nest))
|
|
|
2098 (setq sreg reg)
|
|
98
|
2099 (setq reg "\\(\\<case[xz]?\\>[^:]\\)\\|\\(\\<endcase\\>\\)" )
|
|
|
2100 )
|
|
134
|
2101 ((match-end 4)
|
|
|
2102 ;; join, jump to fork
|
|
|
2103 (setq snest nest)
|
|
|
2104 (setq nest (1+ nest))
|
|
|
2105 (setq sreg reg)
|
|
98
|
2106 (setq reg "\\(\\<fork\\>\\)\\|\\(\\<join\\>\\)" )
|
|
|
2107 )
|
|
|
2108 )
|
|
|
2109 )
|
|
134
|
2110 )
|
|
98
|
2111 )
|
|
|
2112 )
|
|
|
2113 )
|
|
134
|
2114
|
|
|
2115 (defun verilog-continued-line-1 ()
|
|
|
2116 "Return true if this is a continued line.
|
|
|
2117 Set point to where line starts"
|
|
|
2118 (let ((continued 't))
|
|
|
2119 (if (eq 0 (forward-line -1))
|
|
|
2120 (progn
|
|
|
2121 (end-of-line)
|
|
|
2122 (verilog-backward-ws&directives)
|
|
|
2123 (if (bobp)
|
|
|
2124 (setq continued nil)
|
|
|
2125 (setq continued (verilog-backward-token))
|
|
|
2126 )
|
|
|
2127 )
|
|
|
2128 (setq continued nil)
|
|
|
2129 )
|
|
|
2130 continued)
|
|
|
2131 )
|
|
|
2132
|
|
98
|
2133 (defun verilog-continued-line ()
|
|
|
2134 "Return true if this is a continued line.
|
|
|
2135 Set point to where line starts"
|
|
|
2136 (let ((continued 't))
|
|
|
2137 (if (eq 0 (forward-line -1))
|
|
|
2138 (progn
|
|
|
2139 (end-of-line)
|
|
|
2140 (verilog-backward-ws&directives)
|
|
|
2141 (if (bobp)
|
|
|
2142 (setq continued nil)
|
|
|
2143 (while (and continued
|
|
|
2144 (save-excursion
|
|
|
2145 (skip-chars-backward " \t")
|
|
|
2146 (not (bolp))))
|
|
134
|
2147 (setq continued (verilog-backward-token))
|
|
98
|
2148 ) ;; while
|
|
|
2149 )
|
|
|
2150 )
|
|
|
2151 (setq continued nil)
|
|
|
2152 )
|
|
|
2153 continued)
|
|
|
2154 )
|
|
|
2155
|
|
|
2156 (defun verilog-backward-token ()
|
|
|
2157 "step backward token, returning true if we are now at an end of line token"
|
|
|
2158 (verilog-backward-syntactic-ws)
|
|
|
2159 (cond
|
|
|
2160 ((bolp)
|
|
|
2161 nil)
|
|
|
2162 (;-- Anything ending in a ; is complete
|
|
|
2163 (= (preceding-char) ?\;)
|
|
|
2164 nil)
|
|
|
2165 (;-- Could be 'case (foo)' or 'always @(bar)' which is complete
|
|
|
2166 (= (preceding-char) ?\))
|
|
|
2167 (progn
|
|
|
2168 (backward-char)
|
|
|
2169 (backward-up-list 1)
|
|
|
2170 (verilog-backward-syntactic-ws)
|
|
|
2171 (forward-word -1)
|
|
|
2172 (not (looking-at "\\<case[xz]?\\>[^:]"))))
|
|
|
2173 (;-- any of begin|initial|while are complete statements; 'begin : foo' is also complete
|
|
|
2174 t
|
|
|
2175 (forward-word -1)
|
|
|
2176 (cond
|
|
|
2177 (
|
|
134
|
2178 (looking-at "\\(else\\)\\|\\(initial\\>\\)\\|\\(always\\>\\)")
|
|
98
|
2179 t)
|
|
|
2180 (
|
|
|
2181 (looking-at verilog-indent-reg)
|
|
|
2182 nil)
|
|
|
2183 (t
|
|
|
2184 (let
|
|
|
2185 ((back (point)))
|
|
|
2186 (verilog-backward-syntactic-ws)
|
|
|
2187 (cond
|
|
|
2188 ((= (preceding-char) ?\:)
|
|
|
2189 (backward-char)
|
|
|
2190 (verilog-backward-syntactic-ws)
|
|
|
2191 (backward-sexp)
|
|
|
2192 (if (looking-at "begin")
|
|
|
2193 nil
|
|
|
2194 t)
|
|
|
2195 )
|
|
|
2196 ((= (preceding-char) ?\#)
|
|
|
2197 (backward-char)
|
|
|
2198 t)
|
|
134
|
2199 ((= (preceding-char) ?\`)
|
|
|
2200 (backward-char)
|
|
|
2201 t)
|
|
98
|
2202
|
|
|
2203 (t
|
|
|
2204 (goto-char back)
|
|
|
2205 t)
|
|
|
2206 )
|
|
|
2207 )
|
|
|
2208 )
|
|
|
2209 )
|
|
|
2210 )
|
|
|
2211 )
|
|
|
2212 )
|
|
|
2213
|
|
|
2214 (defun verilog-backward-syntactic-ws (&optional lim)
|
|
|
2215 ;; Backward skip over syntactic whitespace for Emacs 19.
|
|
|
2216 (save-restriction
|
|
|
2217 (let* ((lim (or lim (point-min)))
|
|
|
2218 (here lim)
|
|
|
2219 bol
|
|
|
2220 )
|
|
|
2221 (if (< lim (point))
|
|
|
2222 (progn
|
|
|
2223 (narrow-to-region lim (point))
|
|
|
2224 (while (/= here (point))
|
|
|
2225 (setq here (point))
|
|
|
2226 (forward-comment (-(buffer-size)))
|
|
|
2227 (save-excursion
|
|
|
2228 (setq bol (progn (beginning-of-line) (point))))
|
|
|
2229 (search-backward "//" bol t)
|
|
|
2230 )))
|
|
134
|
2231 ))
|
|
|
2232 t)
|
|
98
|
2233
|
|
|
2234 (defun verilog-forward-syntactic-ws (&optional lim)
|
|
|
2235 ;; forward skip over syntactic whitespace for Emacs 19.
|
|
|
2236 (save-restriction
|
|
|
2237 (let* ((lim (or lim (point-max)))
|
|
|
2238 (here lim)
|
|
|
2239 )
|
|
|
2240 (if (> lim (point))
|
|
|
2241 (progn
|
|
|
2242 (narrow-to-region (point) lim)
|
|
|
2243 (while (/= here (point))
|
|
|
2244 (setq here (point))
|
|
|
2245 (forward-comment (buffer-size))
|
|
|
2246 )))
|
|
|
2247 )))
|
|
|
2248
|
|
|
2249 (defun verilog-backward-ws&directives (&optional lim)
|
|
|
2250 ;; Backward skip over syntactic whitespace and compiler directives for Emacs 19.
|
|
|
2251 (save-restriction
|
|
|
2252 (let* ((lim (or lim (point-min)))
|
|
|
2253 (here lim)
|
|
|
2254 jump
|
|
|
2255 )
|
|
|
2256 (if (< lim (point))
|
|
|
2257 (progn
|
|
|
2258 (let ((state
|
|
|
2259 (save-excursion
|
|
|
2260 (parse-partial-sexp (point-min) (point)))))
|
|
|
2261 (cond
|
|
|
2262 ((nth 4 state) ;; in /* */ comment
|
|
|
2263 (verilog-re-search-backward "/\*" nil 'move)
|
|
|
2264 )
|
|
|
2265 ((nth 7 state) ;; in // comment
|
|
|
2266 (verilog-re-search-backward "//" nil 'move)
|
|
|
2267 )))
|
|
|
2268 (narrow-to-region lim (point))
|
|
|
2269 (while (/= here (point))
|
|
|
2270 (setq here (point))
|
|
|
2271 (forward-comment (-(buffer-size)))
|
|
|
2272 (save-excursion
|
|
|
2273 (beginning-of-line)
|
|
|
2274 (if (looking-at "[ \t]*\\(`define\\)\\|\\(`ifdef\\)\\|\\(`else\\)\\|\\(`endif\\)\\|\\(`timescale\\)\\|\\(`include\\)")
|
|
|
2275 (setq jump t)
|
|
|
2276 (setq jump nil)))
|
|
|
2277 (if jump
|
|
|
2278 (beginning-of-line))
|
|
|
2279 )))
|
|
|
2280 )))
|
|
|
2281
|
|
|
2282 (defun verilog-forward-ws&directives (&optional lim)
|
|
|
2283 ;; forward skip over syntactic whitespace and compiler directives for Emacs 19.
|
|
|
2284 (save-restriction
|
|
|
2285 (let* ((lim (or lim (point-max)))
|
|
|
2286 (here lim)
|
|
|
2287 jump
|
|
|
2288 )
|
|
|
2289 (if (> lim (point))
|
|
|
2290 (progn
|
|
|
2291 (let ((state
|
|
|
2292 (save-excursion
|
|
|
2293 (parse-partial-sexp (point-min) (point)))))
|
|
|
2294 (cond
|
|
|
2295 ((nth 4 state) ;; in /* */ comment
|
|
|
2296 (verilog-re-search-forward "/\*" nil 'move)
|
|
|
2297 )
|
|
|
2298 ((nth 7 state) ;; in // comment
|
|
|
2299 (verilog-re-search-forward "//" nil 'move)
|
|
|
2300 )))
|
|
|
2301 (narrow-to-region (point) lim)
|
|
|
2302 (while (/= here (point))
|
|
|
2303 (setq here (point))
|
|
|
2304 (forward-comment (buffer-size))
|
|
|
2305 (save-excursion
|
|
|
2306 (beginning-of-line)
|
|
|
2307 (if (looking-at "[ \t]*\\(`define\\)\\|\\(`ifdef\\)\\|\\(`else\\)\\|\\(`endif\\)\\|\\(`timescale\\)")
|
|
|
2308 (setq jump t)))
|
|
|
2309 (if jump
|
|
|
2310 (beginning-of-line 2))
|
|
|
2311 )))
|
|
|
2312 )))
|
|
|
2313 (defun verilog-parenthesis-depth ()
|
|
|
2314 "Return non zero if in parenthetical-expression"
|
|
|
2315 (save-excursion
|
|
|
2316 (car (parse-partial-sexp (point-min) (point)))))
|
|
|
2317
|
|
|
2318 (defun verilog-in-comment-or-string-p ()
|
|
|
2319 "Return true if in a string or comment"
|
|
|
2320 (let ((state
|
|
|
2321 (save-excursion
|
|
|
2322 (parse-partial-sexp (point-min) (point)))))
|
|
|
2323 (or (nth 3 state) (nth 4 state) (nth 7 state))) ; Inside string or comment
|
|
|
2324 )
|
|
|
2325
|
|
|
2326 (defun verilog-in-star-comment-p ()
|
|
|
2327 "Return true if in a star comment"
|
|
|
2328 (let ((state
|
|
|
2329 (save-excursion
|
|
|
2330 (parse-partial-sexp (point-min) (point)))))
|
|
|
2331 (nth 4 state))
|
|
|
2332 )
|
|
|
2333
|
|
|
2334 (defun verilog-in-paren ()
|
|
|
2335 "Return true if in a parenthetical expression"
|
|
|
2336 (let ((state
|
|
|
2337 (save-excursion
|
|
|
2338 (parse-partial-sexp (point-min) (point)))))
|
|
|
2339 (/= 0 (nth 0 state)))
|
|
|
2340 )
|
|
|
2341
|
|
|
2342 (defun verilog-skip-forward-comment-or-string ()
|
|
|
2343 "Return true if in a string or comment"
|
|
|
2344 (let ((state
|
|
|
2345 (save-excursion
|
|
|
2346 (parse-partial-sexp (point-min) (point)))))
|
|
|
2347 (cond
|
|
|
2348 ((nth 3 state) ;Inside string
|
|
|
2349 (goto-char (nth 3 state))
|
|
|
2350 t)
|
|
|
2351 ((nth 7 state) ;Inside // comment
|
|
|
2352 (forward-line 1)
|
|
|
2353 t)
|
|
|
2354 ((nth 4 state) ;Inside any comment (hence /**/)
|
|
|
2355 (search-forward "*/"))
|
|
|
2356 (t
|
|
|
2357 nil)
|
|
|
2358 )
|
|
|
2359 )
|
|
|
2360 )
|
|
|
2361
|
|
|
2362 (defun verilog-skip-backward-comment-or-string ()
|
|
|
2363 "Return true if in a string or comment"
|
|
|
2364 (let ((state
|
|
|
2365 (save-excursion
|
|
|
2366 (parse-partial-sexp (point-min) (point)))))
|
|
|
2367 (cond
|
|
|
2368 ((nth 3 state) ;Inside string
|
|
|
2369 (search-backward "\"")
|
|
|
2370 t)
|
|
|
2371 ((nth 7 state) ;Inside // comment
|
|
|
2372 (search-backward "//")
|
|
|
2373 t)
|
|
|
2374 ((nth 4 state) ;Inside /* */ comment
|
|
|
2375 (search-backward "/*")
|
|
|
2376 t)
|
|
|
2377 (t
|
|
|
2378 nil)
|
|
|
2379 )
|
|
|
2380 )
|
|
|
2381 )
|
|
|
2382
|
|
|
2383 (defun verilog-skip-forward-comment-p ()
|
|
|
2384 "If in comment, move to end and return true"
|
|
|
2385 (let (state)
|
|
|
2386 (progn
|
|
|
2387 (setq state
|
|
|
2388 (save-excursion
|
|
|
2389 (parse-partial-sexp (point-min) (point))))
|
|
|
2390 (cond
|
|
|
2391 ((nth 3 state)
|
|
|
2392 t)
|
|
|
2393 ((nth 7 state) ;Inside // comment
|
|
|
2394 (end-of-line)
|
|
|
2395 (forward-char 1)
|
|
|
2396 t)
|
|
|
2397 ((nth 4 state) ;Inside any comment
|
|
|
2398 t)
|
|
|
2399 (t
|
|
|
2400 nil)
|
|
|
2401 )
|
|
|
2402 )
|
|
|
2403 )
|
|
|
2404 )
|
|
|
2405
|
|
|
2406 (defun verilog-indent-line-relative ()
|
|
|
2407 "Cheap version of indent line that only looks at
|
|
|
2408 a few lines to determine indent level"
|
|
|
2409 (interactive)
|
|
|
2410 (let ((indent-str))
|
|
|
2411 (save-excursion
|
|
|
2412 (beginning-of-line)
|
|
|
2413 (if (looking-at "^[ \t]*$")
|
|
|
2414 (cond ;- A blank line; No need to be too smart.
|
|
|
2415 ((bobp)
|
|
|
2416 (setq indent-str (list 'cpp 0)))
|
|
|
2417 ((verilog-continued-line)
|
|
|
2418 (let ((sp (point)))
|
|
|
2419 (if (verilog-continued-line)
|
|
|
2420 (progn (goto-char sp)
|
|
|
2421 (setq indent-str (list 'statement (verilog-indent-level))))
|
|
|
2422 (goto-char sp)
|
|
|
2423 (setq indent-str (list 'block (verilog-indent-level))))))
|
|
|
2424 (t
|
|
|
2425 (setq indent-str (verilog-calculate-indent))))
|
|
|
2426 (setq indent-str (verilog-calculate-indent))
|
|
|
2427 )
|
|
|
2428 )
|
|
|
2429 (verilog-do-indent indent-str)
|
|
|
2430 )
|
|
|
2431 )
|
|
|
2432 (defun verilog-indent-line ()
|
|
|
2433 "Indent for special part of code."
|
|
|
2434 (if (looking-at verilog-directive-re)
|
|
|
2435 ;; We could nicely nest `ifdef's, but...
|
|
|
2436 (progn
|
|
|
2437 (delete-horizontal-space)
|
|
|
2438 (indent-to 0)
|
|
|
2439 (list 'cpp 0)) ; Return verilog-calculate-indent data
|
|
|
2440 (verilog-do-indent (verilog-calculate-indent)))
|
|
|
2441 )
|
|
|
2442
|
|
|
2443 (defun verilog-do-indent (indent-str)
|
|
|
2444 ""
|
|
|
2445 (let ((type (car indent-str))
|
|
|
2446 (ind (car (cdr indent-str))))
|
|
|
2447 (delete-horizontal-space)
|
|
|
2448 (cond
|
|
134
|
2449 (; handle continued exp
|
|
98
|
2450 (eq type 'cexp)
|
|
|
2451 (let ((here (point)))
|
|
134
|
2452 (verilog-backward-syntactic-ws)
|
|
|
2453 (cond
|
|
|
2454 ((= (preceding-char) ?\,)
|
|
|
2455 (let* ( fst
|
|
|
2456 (column
|
|
|
2457 (save-excursion
|
|
|
2458 (backward-char 1)
|
|
|
2459 (verilog-beg-of-statement)
|
|
|
2460 (setq fst (point))
|
|
|
2461 (if (looking-at verilog-declaration-re)
|
|
|
2462 (progn ;; we have multiple words
|
|
|
2463 (goto-char (match-end 0))
|
|
|
2464 (skip-chars-forward " \t")
|
|
|
2465 (if (= (following-char) ?\[)
|
|
|
2466 (progn
|
|
|
2467 (forward-char 1)
|
|
|
2468 (backward-up-list -1)
|
|
|
2469 (skip-chars-forward " \t")
|
|
|
2470 )
|
|
98
|
2471 )
|
|
134
|
2472 )
|
|
|
2473 (;; we have a single word
|
|
|
2474 goto-char fst)
|
|
98
|
2475 )
|
|
134
|
2476 (current-column)
|
|
98
|
2477 )
|
|
134
|
2478 )
|
|
|
2479 )
|
|
98
|
2480 (goto-char here)
|
|
134
|
2481 (beginning-of-line)
|
|
|
2482 (delete-horizontal-space)
|
|
|
2483 (indent-to column))
|
|
|
2484 )
|
|
|
2485 ((= (preceding-char) ?\) )
|
|
|
2486 (goto-char here)
|
|
|
2487 (indent-to (eval (cdr (assoc type verilog-indent-alist))))
|
|
98
|
2488 )
|
|
134
|
2489 (t
|
|
|
2490 (goto-char here)
|
|
|
2491 (let ((val))
|
|
|
2492 (verilog-beg-of-statement)
|
|
|
2493 (if (verilog-re-search-forward "=[ \\t]*" here 'move)
|
|
|
2494 (setq val (current-column))
|
|
|
2495 (setq val (eval (cdr (assoc type verilog-indent-alist)))))
|
|
|
2496 (goto-char here)
|
|
|
2497 (indent-to val)
|
|
|
2498 )
|
|
|
2499 )
|
|
|
2500 )
|
|
98
|
2501 )
|
|
|
2502 )
|
|
|
2503 (; handle inside parenthetical expressions
|
|
|
2504 (eq type 'cparenexp)
|
|
|
2505 (let ((column (save-excursion
|
|
|
2506 (backward-up-list 1)
|
|
|
2507 (forward-char 1)
|
|
|
2508 (skip-chars-forward " \t")
|
|
|
2509 (current-column))))
|
|
|
2510 (beginning-of-line)
|
|
|
2511 (delete-horizontal-space)
|
|
|
2512 (indent-to column)))
|
|
|
2513
|
|
134
|
2514 (;-- Handle the ends
|
|
|
2515 (looking-at verilog-end-block-re )
|
|
|
2516 (if (eq type 'statement)
|
|
|
2517 (indent-to (- ind verilog-indent-level))
|
|
|
2518 (indent-to ind)))
|
|
98
|
2519 (;-- Case -- maybe line 'em up
|
|
|
2520 (and (eq type 'case) (not (looking-at "^[ \t]*$")))
|
|
|
2521 (progn
|
|
|
2522 (cond
|
|
|
2523 ((looking-at "\\<endcase\\>")
|
|
|
2524 (indent-to ind))
|
|
|
2525 (t
|
|
|
2526 (indent-to (eval (cdr (assoc type verilog-indent-alist))))
|
|
|
2527 ))))
|
|
|
2528
|
|
134
|
2529
|
|
98
|
2530 (;-- defun
|
|
|
2531 (and (eq type 'defun)
|
|
134
|
2532 (looking-at verilog-zero-indent-re))
|
|
98
|
2533 (indent-to 0))
|
|
|
2534
|
|
134
|
2535 (;-- declaration
|
|
|
2536 (and (or
|
|
|
2537 (eq type 'defun)
|
|
|
2538 (eq type 'block))
|
|
|
2539 (looking-at verilog-declaration-re))
|
|
|
2540 (verilog-indent-declaration ind))
|
|
|
2541
|
|
98
|
2542 (;-- Everything else
|
|
|
2543 t
|
|
|
2544 (let ((val (eval (cdr (assoc type verilog-indent-alist)))))
|
|
|
2545 (indent-to val)
|
|
|
2546 ))
|
|
|
2547 )
|
|
|
2548 (if (looking-at "[ \t]+$")
|
|
|
2549 (skip-chars-forward " \t"))
|
|
134
|
2550 indent-str ; Return indent data
|
|
98
|
2551 )
|
|
|
2552 )
|
|
|
2553
|
|
|
2554 (defun verilog-indent-level ()
|
|
|
2555 "Return the indent-level the current statement has."
|
|
|
2556 (save-excursion
|
|
|
2557 (beginning-of-line)
|
|
|
2558 (skip-chars-forward " \t")
|
|
|
2559 (current-column)))
|
|
|
2560
|
|
|
2561
|
|
|
2562 (defun verilog-case-indent-level ()
|
|
|
2563 "Return the indent-level the current statement has.
|
|
|
2564 Do not count named blocks or case-statements."
|
|
|
2565 (save-excursion
|
|
|
2566 (skip-chars-forward " \t")
|
|
|
2567 (cond
|
|
|
2568 ((looking-at verilog-named-block-re)
|
|
|
2569 (current-column))
|
|
|
2570 ((and (not (looking-at verilog-case-re))
|
|
134
|
2571 (looking-at "^[^:;]+[ \t]*:"))
|
|
98
|
2572 (search-forward ":" nil t)
|
|
|
2573 (skip-chars-forward " \t")
|
|
|
2574 (current-column))
|
|
|
2575 (t
|
|
|
2576 (current-column)))))
|
|
|
2577
|
|
|
2578 (defun verilog-indent-comment (&optional arg)
|
|
|
2579 "Indent current line as comment.
|
|
|
2580 If optional arg is non-nil, just return the
|
|
|
2581 column number the line should be indented to."
|
|
|
2582 (let* ((stcol
|
|
|
2583 (cond
|
|
|
2584 ((verilog-in-star-comment-p)
|
|
|
2585 (save-excursion
|
|
|
2586 (re-search-backward "/\\*" nil t)
|
|
|
2587 (1+(current-column))))
|
|
|
2588 ( comment-column
|
|
|
2589 comment-column )
|
|
|
2590 (t
|
|
|
2591 (save-excursion
|
|
|
2592 (re-search-backward "//" nil t)
|
|
|
2593 (current-column)))
|
|
|
2594 )
|
|
|
2595 ))
|
|
|
2596 (if arg
|
|
|
2597 (progn
|
|
|
2598 (delete-horizontal-space)
|
|
|
2599 (indent-to stcol))
|
|
|
2600 stcol
|
|
|
2601 )
|
|
|
2602 )
|
|
|
2603 )
|
|
|
2604
|
|
|
2605 ;;;
|
|
|
2606
|
|
134
|
2607 (defun verilog-pretty-declarations ()
|
|
|
2608 "Line up declarations arround point"
|
|
|
2609 (interactive)
|
|
|
2610 (save-excursion
|
|
|
2611 (if (progn
|
|
|
2612 (verilog-beg-of-statement-1)
|
|
|
2613 (looking-at verilog-declaration-re))
|
|
|
2614 (let* ((m1 (make-marker))
|
|
|
2615 (e) (r)
|
|
|
2616 (here (point))
|
|
|
2617 (start
|
|
|
2618 (progn
|
|
|
2619 (verilog-beg-of-statement-1)
|
|
|
2620 (while (looking-at verilog-declaration-re)
|
|
|
2621 (beginning-of-line)
|
|
|
2622 (setq e (point))
|
|
|
2623 (verilog-backward-syntactic-ws)
|
|
|
2624 (backward-char)
|
|
|
2625 (verilog-beg-of-statement-1))
|
|
|
2626 e))
|
|
|
2627 (end
|
|
|
2628 (progn
|
|
|
2629 (goto-char here)
|
|
|
2630 (verilog-end-of-statement)
|
|
|
2631 (setq e (point)) ;Might be on last line
|
|
|
2632 (verilog-forward-syntactic-ws)
|
|
|
2633 (while (looking-at verilog-declaration-re)
|
|
|
2634 (beginning-of-line)
|
|
|
2635 (verilog-end-of-statement)
|
|
|
2636 (setq e (point))
|
|
|
2637 (verilog-forward-syntactic-ws)
|
|
|
2638 )
|
|
|
2639 e))
|
|
|
2640 (edpos (set-marker (make-marker) end))
|
|
|
2641 (ind)
|
|
|
2642 (base-ind
|
|
|
2643 (progn
|
|
|
2644 (goto-char start)
|
|
|
2645 (verilog-do-indent (verilog-calculate-indent))
|
|
|
2646 (verilog-forward-ws&directives)
|
|
|
2647 (current-column)
|
|
|
2648 ))
|
|
|
2649 )
|
|
|
2650 (goto-char end)
|
|
|
2651 (goto-char start)
|
|
|
2652 (if (> (- end start) 100)
|
|
|
2653 (message "Lining up declarations..(please stand by)"))
|
|
|
2654 ;; Get the begining of line indent first
|
|
|
2655 (while (progn (setq e (marker-position edpos))
|
|
|
2656 (< (point) e))
|
|
|
2657 (delete-horizontal-space)
|
|
|
2658 (indent-to base-ind)
|
|
|
2659 (forward-line))
|
|
|
2660 ;; Now find biggest prefix
|
|
|
2661 (setq ind (verilog-get-lineup-indent start edpos))
|
|
|
2662 ;; Now indent each line.
|
|
|
2663 (goto-char start)
|
|
|
2664 (while (progn (setq e (marker-position edpos))
|
|
|
2665 (setq r (- e (point)))
|
|
|
2666 (> r 0))
|
|
|
2667 (setq e (point))
|
|
|
2668 (message "%d" r)
|
|
|
2669 (cond
|
|
|
2670 ((looking-at verilog-declaration-re-1)
|
|
|
2671 (let ((p (match-end 0)))
|
|
|
2672 (set-marker m1 p)
|
|
|
2673 (if (verilog-re-search-forward "\\[" p 'move)
|
|
|
2674 (progn
|
|
|
2675 (forward-char -1)
|
|
|
2676 (just-one-space)
|
|
|
2677 (goto-char (marker-position m1))
|
|
|
2678 (just-one-space)
|
|
|
2679 (indent-to ind)
|
|
|
2680 )
|
|
|
2681 (progn
|
|
|
2682 (just-one-space)
|
|
|
2683 (indent-to ind))
|
|
|
2684 )
|
|
|
2685 ))
|
|
|
2686 ((verilog-continued-line-1)
|
|
|
2687 (goto-char e)
|
|
|
2688 (delete-horizontal-space)
|
|
|
2689 (indent-to ind))
|
|
|
2690 (t ; Must be comment or white space
|
|
|
2691 (goto-char e)
|
|
|
2692 (verilog-forward-ws&directives)
|
|
|
2693 (forward-line -1)
|
|
|
2694 )
|
|
|
2695 )
|
|
|
2696 (forward-line 1)
|
|
|
2697 )
|
|
|
2698 (message "")
|
|
|
2699 )
|
|
|
2700 )
|
|
|
2701 )
|
|
|
2702 )
|
|
|
2703 (defun verilog-indent-declaration (baseind)
|
|
|
2704 "Indent current lines as declaration, lining up the variable names
|
|
|
2705 based on previous declaration's indentation."
|
|
98
|
2706 (interactive)
|
|
|
2707 (let ((pos (point-marker))
|
|
134
|
2708 (lim (save-excursion
|
|
|
2709 (verilog-re-search-backward "\\(\\<begin\\>\\)\\|\\(\\<module\\>\\)" nil 'move)
|
|
|
2710 (point)))
|
|
|
2711 (ind)
|
|
|
2712 (m1 (make-marker))
|
|
98
|
2713 )
|
|
134
|
2714 ;; Use previous declaration (in this module) as template.
|
|
|
2715 (if (verilog-re-search-backward verilog-declaration-re-1 lim t)
|
|
|
2716 (progn
|
|
|
2717 (goto-char (match-end 0))
|
|
|
2718 (setq ind (current-column))
|
|
|
2719 (goto-char pos)
|
|
|
2720 (beginning-of-line)
|
|
|
2721 (indent-to (+ baseind (eval (cdr (assoc 'declaration verilog-indent-alist)))))
|
|
|
2722 (if (looking-at verilog-declaration-re-2)
|
|
|
2723 (let ((p (match-end 0)))
|
|
|
2724 (set-marker m1 p)
|
|
|
2725 (if (verilog-re-search-forward "\\[" p 'move)
|
|
|
2726 (progn
|
|
|
2727 (forward-char -1)
|
|
|
2728 (just-one-space)
|
|
|
2729 (goto-char (marker-position m1))
|
|
|
2730 (just-one-space)
|
|
|
2731 (indent-to ind)
|
|
98
|
2732 )
|
|
134
|
2733 (progn
|
|
|
2734 (just-one-space)
|
|
|
2735 (indent-to ind)
|
|
|
2736 )
|
|
|
2737 )
|
|
|
2738 )
|
|
|
2739 )
|
|
|
2740 )
|
|
|
2741 (indent-to (+ baseind (eval (cdr (assoc 'declaration verilog-indent-alist)))))
|
|
|
2742 )
|
|
|
2743 (goto-char pos)
|
|
|
2744 )
|
|
|
2745 )
|
|
98
|
2746
|
|
|
2747 ; "Return the indent level that will line up several lines within the region
|
|
|
2748 ;from b to e nicely. The lineup string is str."
|
|
|
2749 (defun verilog-get-lineup-indent (b edpos)
|
|
|
2750 (save-excursion
|
|
|
2751 (let ((ind 0) e)
|
|
|
2752 (goto-char b)
|
|
|
2753 ;; Get rightmost position
|
|
|
2754 (while (progn (setq e (marker-position edpos))
|
|
|
2755 (< (point) e))
|
|
|
2756 (if (verilog-re-search-forward verilog-declaration-re-1 e 'move)
|
|
|
2757 (progn
|
|
|
2758 (goto-char (match-end 0))
|
|
|
2759 (verilog-backward-syntactic-ws)
|
|
|
2760 (if (> (current-column) ind)
|
|
|
2761 (setq ind (current-column)))
|
|
|
2762 (goto-char (match-end 0)))))
|
|
|
2763 (if (> ind 0)
|
|
|
2764 (1+ ind)
|
|
|
2765 ;; No lineup-string found
|
|
|
2766 (goto-char b)
|
|
|
2767 (end-of-line)
|
|
|
2768 (skip-chars-backward " \t")
|
|
|
2769 (1+ (current-column))))))
|
|
|
2770
|
|
|
2771 ;; A useful mode debugging aide
|
|
|
2772 (defun verilog-comment-depth (type val)
|
|
|
2773 ""
|
|
|
2774 (save-excursion
|
|
|
2775 (let
|
|
|
2776 ((b (prog2
|
|
|
2777 (beginning-of-line)
|
|
|
2778 (point-marker)
|
|
|
2779 (end-of-line)))
|
|
|
2780 (e (point-marker)))
|
|
|
2781 (if (re-search-backward " /\\* \[#-\]# \[a-z\]+ \[0-9\]+ ## \\*/" b t)
|
|
|
2782 (progn
|
|
|
2783 (replace-match " /* -# ## */")
|
|
|
2784 (end-of-line))
|
|
|
2785 (progn
|
|
|
2786 (end-of-line)
|
|
|
2787 (insert " /* ## ## */"))))
|
|
|
2788 (backward-char 6)
|
|
|
2789 (insert
|
|
|
2790 (format "%s %d" type val))
|
|
|
2791 )
|
|
|
2792 )
|
|
|
2793 ;;;
|
|
|
2794 ;;;
|
|
|
2795 ;;; Completion
|
|
|
2796 ;;;
|
|
|
2797 (defvar verilog-str nil)
|
|
|
2798 (defvar verilog-all nil)
|
|
|
2799 (defvar verilog-pred nil)
|
|
|
2800 (defvar verilog-buffer-to-use nil)
|
|
|
2801 (defvar verilog-flag nil)
|
|
|
2802 (defvar verilog-toggle-completions nil
|
|
|
2803 "*Non-nil means \\<verilog-mode-map>\\[verilog-complete-word] should try all possible completions one by one.
|
|
|
2804 Repeated use of \\[verilog-complete-word] will show you all of them.
|
|
|
2805 Normally, when there is more than one possible completion,
|
|
|
2806 it displays a list of all possible completions.")
|
|
|
2807
|
|
|
2808
|
|
|
2809 (defvar verilog-type-keywords
|
|
|
2810 '("buf" "bufif0" "bufif1" "cmos" "defparam" "inout" "input"
|
|
|
2811 "integer" "nand" "nmos" "nor" "not" "notif0" "notif1" "or" "output" "parameter"
|
|
|
2812 "pmos" "pull0" "pull1" "pullup" "rcmos" "real" "realtime" "reg" "rnmos" "rpmos" "rtran"
|
|
|
2813 "rtranif0" "rtranif1" "time" "tran" "tranif0" "tranif1" "tri" "tri0" "tri1"
|
|
|
2814 "triand" "trior" "trireg" "wand" "wire" "wor" "xnor" "xor" )
|
|
|
2815 "*Keywords for types used when completing a word in a declaration or parmlist.
|
|
|
2816 \(eg. integer, real, char.) The types defined within the Verilog program
|
|
|
2817 will be completed runtime, and should not be added to this list.")
|
|
|
2818
|
|
|
2819 (defvar verilog-defun-keywords
|
|
|
2820 '("begin" "function" "task" "initial" "always" "assign" "posedge" "negedge" "endmodule")
|
|
|
2821 "*Keywords to complete when standing at first word of a line in declarative scope.
|
|
|
2822 \(eg. initial, always, begin, assign.)
|
|
|
2823 The procedures and variables defined within the Verilog program
|
|
|
2824 will be completed runtime and should not be added to this list.")
|
|
|
2825
|
|
|
2826 (defvar verilog-block-keywords
|
|
|
2827 '("begin" "fork" "join" "case" "end" "if" "else" "for" "while" "repeat")
|
|
|
2828 "*Keywords to complete when standing at first word of a line in behavorial scope.
|
|
|
2829 \(eg. begin, if, then, else, for, fork.)
|
|
|
2830 The procedures and variables defined within the Verilog program
|
|
|
2831 will be completed runtime and should not be added to this list.")
|
|
|
2832
|
|
|
2833 (defvar verilog-tf-keywords
|
|
|
2834 '("begin" "fork" "join" "case" "end" "endtask" "endfunction" "if" "else" "for" "while" "repeat")
|
|
|
2835 "*Keywords to complete when standing at first word of a line in a task or function scope.
|
|
|
2836 \(eg. begin, if, then, else, for, fork.)
|
|
|
2837 The procedures and variables defined within the Verilog program
|
|
|
2838 will be completed runtime and should not be added to this list.")
|
|
|
2839
|
|
|
2840 (defvar verilog-case-keywords
|
|
|
2841 '("begin" "fork" "join" "case" "end" "endcase" "if" "else" "for" "repeat")
|
|
|
2842 "*Keywords to complete when standing at first word of a line in behavorial scope.
|
|
|
2843 \(eg. begin, if, then, else, for, fork.)
|
|
|
2844 The procedures and variables defined within the Verilog program
|
|
|
2845 will be completed runtime and should not be added to this list.")
|
|
|
2846
|
|
|
2847 (defvar verilog-separator-keywords
|
|
|
2848 '("else" "then" "begin")
|
|
|
2849 "*Keywords to complete when NOT standing at the first word of a statement.
|
|
|
2850 \(eg. else, then.)
|
|
|
2851 Variables and function names defined within the
|
|
|
2852 Verilog program are completed runtime and should not be added to this list.")
|
|
|
2853
|
|
|
2854 (defun verilog-string-diff (str1 str2)
|
|
|
2855 "Return index of first letter where STR1 and STR2 differs."
|
|
|
2856 (catch 'done
|
|
|
2857 (let ((diff 0))
|
|
|
2858 (while t
|
|
|
2859 (if (or (> (1+ diff) (length str1))
|
|
|
2860 (> (1+ diff) (length str2)))
|
|
|
2861 (throw 'done diff))
|
|
|
2862 (or (equal (aref str1 diff) (aref str2 diff))
|
|
|
2863 (throw 'done diff))
|
|
|
2864 (setq diff (1+ diff))))))
|
|
|
2865
|
|
|
2866 ;; Calculate all possible completions for functions if argument is `function',
|
|
|
2867 ;; completions for procedures if argument is `procedure' or both functions and
|
|
|
2868 ;; procedures otherwise.
|
|
|
2869
|
|
|
2870 (defun verilog-func-completion (type)
|
|
|
2871 ;; Build regular expression for module/task/function names
|
|
|
2872 (if (string= verilog-str "")
|
|
|
2873 (setq verilog-str "[a-zA-Z_]"))
|
|
|
2874 (let ((verilog-str (concat (cond
|
|
|
2875 ((eq type 'module) "\\<\\(module\\)\\s +")
|
|
|
2876 ((eq type 'tf) "\\<\\(task\\|function\\)\\s +")
|
|
|
2877 (t "\\<\\(task\\|function\\|module\\)\\s +"))
|
|
|
2878 "\\<\\(" verilog-str "[a-zA-Z0-9_.]*\\)\\>"))
|
|
|
2879 match)
|
|
|
2880
|
|
|
2881 (if (not (looking-at verilog-defun-re))
|
|
|
2882 (verilog-re-search-backward verilog-defun-re nil t))
|
|
|
2883 (forward-char 1)
|
|
|
2884
|
|
|
2885 ;; Search through all reachable functions
|
|
|
2886 (goto-char (point-min))
|
|
|
2887 (while (verilog-re-search-forward verilog-str (point-max) t)
|
|
|
2888 (progn (setq match (buffer-substring (match-beginning 2)
|
|
|
2889 (match-end 2)))
|
|
|
2890 (if (or (null verilog-pred)
|
|
|
2891 (funcall verilog-pred match))
|
|
|
2892 (setq verilog-all (cons match verilog-all)))))
|
|
|
2893 (if (match-beginning 0)
|
|
|
2894 (goto-char (match-beginning 0)))))
|
|
|
2895
|
|
|
2896 (defun verilog-get-completion-decl ()
|
|
|
2897 ;; Macro for searching through current declaration (var, type or const)
|
|
|
2898 ;; for matches of `str' and adding the occurence tp `all'
|
|
|
2899 (let ((end (save-excursion (verilog-declaration-end)
|
|
|
2900 (point)))
|
|
|
2901 match)
|
|
|
2902 ;; Traverse lines
|
|
|
2903 (while (< (point) end)
|
|
|
2904 (if (verilog-re-search-forward verilog-declaration-re-1 (verilog-get-end-of-line) t)
|
|
|
2905 ;; Traverse current line
|
|
|
2906 (while (and (verilog-re-search-forward
|
|
|
2907 (concat "\\((\\|\\<\\(var\\|type\\|const\\)\\>\\)\\|"
|
|
|
2908 verilog-symbol-re)
|
|
|
2909 (verilog-get-beg-of-line) t)
|
|
|
2910 (not (match-end 1)))
|
|
|
2911 (setq match (buffer-substring (match-beginning 0) (match-end 0)))
|
|
|
2912 (if (string-match (concat "\\<" verilog-str) match)
|
|
|
2913 (if (or (null verilog-pred)
|
|
|
2914 (funcall verilog-pred match))
|
|
|
2915 (setq verilog-all (cons match verilog-all))))))
|
|
|
2916 (if (verilog-re-search-forward "\\<record\\>" (verilog-get-end-of-line) t)
|
|
|
2917 (verilog-declaration-end)
|
|
|
2918 (forward-line 1)))))
|
|
|
2919
|
|
|
2920 (defun verilog-type-completion ()
|
|
|
2921 "Calculate all possible completions for types."
|
|
|
2922 (let ((start (point))
|
|
|
2923 goon)
|
|
|
2924 ;; Search for all reachable type declarations
|
|
|
2925 (while (or (verilog-beg-of-defun)
|
|
|
2926 (setq goon (not goon)))
|
|
|
2927 (save-excursion
|
|
|
2928 (if (and (< start (prog1 (save-excursion (verilog-end-of-defun)
|
|
|
2929 (point))
|
|
|
2930 (forward-char 1)))
|
|
|
2931 (verilog-re-search-forward
|
|
|
2932 "\\<type\\>\\|\\<\\(begin\\|function\\|procedure\\)\\>"
|
|
|
2933 start t)
|
|
|
2934 (not (match-end 1)))
|
|
|
2935 ;; Check current type declaration
|
|
|
2936 (verilog-get-completion-decl))))))
|
|
|
2937
|
|
|
2938 (defun verilog-var-completion ()
|
|
|
2939 "Calculate all possible completions for variables (or constants)."
|
|
|
2940 nil)
|
|
|
2941 ; Not done yet; in 1.99 perhaps
|
|
|
2942 ; (let ((start (point))
|
|
|
2943 ; goon twice)
|
|
|
2944 ; ;; Search for all reachable var declarations
|
|
|
2945 ; (while (or (verilog-beg-of-defun)
|
|
|
2946 ; (setq goon (not goon)))
|
|
|
2947 ; (save-excursion
|
|
|
2948 ; (if (> start (prog1 (save-excursion (verilog-end-of-defun)
|
|
|
2949 ; (point))))
|
|
|
2950 ; () ; Declarations not reacable
|
|
|
2951 ; (cond ((and (verilog-re-search-forward verilog-declaration-re start t)
|
|
|
2952 ; ;; Check var/const declarations
|
|
|
2953 ; (verilog-get-completion-decl)))))))))
|
|
|
2954
|
|
|
2955
|
|
|
2956 (defun verilog-keyword-completion (keyword-list)
|
|
|
2957 "Give list of all possible completions of keywords in KEYWORD-LIST."
|
|
|
2958 (mapcar '(lambda (s)
|
|
|
2959 (if (string-match (concat "\\<" verilog-str) s)
|
|
|
2960 (if (or (null verilog-pred)
|
|
|
2961 (funcall verilog-pred s))
|
|
|
2962 (setq verilog-all (cons s verilog-all)))))
|
|
|
2963 keyword-list))
|
|
|
2964
|
|
|
2965 ;; Function passed to completing-read, try-completion or
|
|
|
2966 ;; all-completions to get completion on STR. If predicate is non-nil,
|
|
|
2967 ;; it must be a function to be called for every match to check if this
|
|
|
2968 ;; should really be a match. If flag is t, the function returns a list
|
|
|
2969 ;; of all possible completions. If it is nil it returns a string, the
|
|
|
2970 ;; longest possible completion, or t if STR is an exact match. If flag
|
|
|
2971 ;; is 'lambda, the function returns t if STR is an exact match, nil
|
|
|
2972 ;; otherwise.
|
|
|
2973
|
|
|
2974 (defun verilog-completion (verilog-str verilog-pred verilog-flag)
|
|
|
2975 (save-excursion
|
|
|
2976 (let ((verilog-all nil))
|
|
|
2977 ;; Set buffer to use for searching labels. This should be set
|
|
|
2978 ;; within functins which use verilog-completions
|
|
|
2979 (set-buffer verilog-buffer-to-use)
|
|
|
2980
|
|
|
2981 ;; Determine what should be completed
|
|
|
2982 (let ((state (car (verilog-calculate-indent))))
|
|
|
2983 (cond ((eq state 'defun)
|
|
|
2984 (save-excursion (verilog-var-completion))
|
|
|
2985 (verilog-func-completion 'module)
|
|
|
2986 (verilog-keyword-completion verilog-defun-keywords))
|
|
|
2987
|
|
|
2988 ((eq state 'block)
|
|
|
2989 (save-excursion (verilog-var-completion))
|
|
|
2990 (verilog-func-completion 'tf)
|
|
|
2991 (verilog-keyword-completion verilog-block-keywords))
|
|
|
2992
|
|
|
2993 ((eq state 'case)
|
|
|
2994 (save-excursion (verilog-var-completion))
|
|
|
2995 (verilog-func-completion 'tf)
|
|
|
2996 (verilog-keyword-completion verilog-case-keywords))
|
|
|
2997
|
|
|
2998 ((eq state 'tf)
|
|
|
2999 (save-excursion (verilog-var-completion))
|
|
|
3000 (verilog-func-completion 'tf)
|
|
|
3001 (verilog-keyword-completion verilog-tf-keywords))
|
|
|
3002
|
|
|
3003 (t;--Anywhere else
|
|
|
3004 (save-excursion (verilog-var-completion))
|
|
|
3005 (verilog-func-completion 'both)
|
|
|
3006 (verilog-keyword-completion verilog-separator-keywords))))
|
|
|
3007
|
|
|
3008 ;; Now we have built a list of all matches. Give response to caller
|
|
|
3009 (verilog-completion-response))))
|
|
|
3010
|
|
|
3011 (defun verilog-completion-response ()
|
|
|
3012 (cond ((or (equal verilog-flag 'lambda) (null verilog-flag))
|
|
|
3013 ;; This was not called by all-completions
|
|
|
3014 (if (null verilog-all)
|
|
|
3015 ;; Return nil if there was no matching label
|
|
|
3016 nil
|
|
|
3017 ;; Get longest string common in the labels
|
|
|
3018 (let* ((elm (cdr verilog-all))
|
|
|
3019 (match (car verilog-all))
|
|
|
3020 (min (length match))
|
|
|
3021 tmp)
|
|
|
3022 (if (string= match verilog-str)
|
|
|
3023 ;; Return t if first match was an exact match
|
|
|
3024 (setq match t)
|
|
|
3025 (while (not (null elm))
|
|
|
3026 ;; Find longest common string
|
|
|
3027 (if (< (setq tmp (verilog-string-diff match (car elm))) min)
|
|
|
3028 (progn
|
|
|
3029 (setq min tmp)
|
|
|
3030 (setq match (substring match 0 min))))
|
|
|
3031 ;; Terminate with match=t if this is an exact match
|
|
|
3032 (if (string= (car elm) verilog-str)
|
|
|
3033 (progn
|
|
|
3034 (setq match t)
|
|
|
3035 (setq elm nil))
|
|
|
3036 (setq elm (cdr elm)))))
|
|
|
3037 ;; If this is a test just for exact match, return nil ot t
|
|
|
3038 (if (and (equal verilog-flag 'lambda) (not (equal match 't)))
|
|
|
3039 nil
|
|
|
3040 match))))
|
|
|
3041 ;; If flag is t, this was called by all-completions. Return
|
|
|
3042 ;; list of all possible completions
|
|
|
3043 (verilog-flag
|
|
|
3044 verilog-all)))
|
|
|
3045
|
|
|
3046 (defvar verilog-last-word-numb 0)
|
|
|
3047 (defvar verilog-last-word-shown nil)
|
|
|
3048 (defvar verilog-last-completions nil)
|
|
|
3049
|
|
|
3050 (defun verilog-complete-word ()
|
|
|
3051 "Complete word at current point.
|
|
|
3052 \(See also `verilog-toggle-completions', `verilog-type-keywords',
|
|
|
3053 `verilog-start-keywords' and `verilog-separator-keywords'.)"
|
|
|
3054 (interactive)
|
|
|
3055 (let* ((b (save-excursion (skip-chars-backward "a-zA-Z0-9_") (point)))
|
|
|
3056 (e (save-excursion (skip-chars-forward "a-zA-Z0-9_") (point)))
|
|
|
3057 (verilog-str (buffer-substring b e))
|
|
|
3058 ;; The following variable is used in verilog-completion
|
|
|
3059 (verilog-buffer-to-use (current-buffer))
|
|
|
3060 (allcomp (if (and verilog-toggle-completions
|
|
|
3061 (string= verilog-last-word-shown verilog-str))
|
|
|
3062 verilog-last-completions
|
|
|
3063 (all-completions verilog-str 'verilog-completion)))
|
|
|
3064 (match (if verilog-toggle-completions
|
|
|
3065 "" (try-completion
|
|
|
3066 verilog-str (mapcar '(lambda (elm)
|
|
|
3067 (cons elm 0)) allcomp)))))
|
|
|
3068 ;; Delete old string
|
|
|
3069 (delete-region b e)
|
|
|
3070
|
|
|
3071 ;; Toggle-completions inserts whole labels
|
|
|
3072 (if verilog-toggle-completions
|
|
|
3073 (progn
|
|
|
3074 ;; Update entry number in list
|
|
|
3075 (setq verilog-last-completions allcomp
|
|
|
3076 verilog-last-word-numb
|
|
|
3077 (if (>= verilog-last-word-numb (1- (length allcomp)))
|
|
|
3078 0
|
|
|
3079 (1+ verilog-last-word-numb)))
|
|
|
3080 (setq verilog-last-word-shown (elt allcomp verilog-last-word-numb))
|
|
|
3081 ;; Display next match or same string if no match was found
|
|
|
3082 (if (not (null allcomp))
|
|
|
3083 (insert "" verilog-last-word-shown)
|
|
|
3084 (insert "" verilog-str)
|
|
|
3085 (message "(No match)")))
|
|
|
3086 ;; The other form of completion does not necessarly do that.
|
|
|
3087
|
|
|
3088 ;; Insert match if found, or the original string if no match
|
|
|
3089 (if (or (null match) (equal match 't))
|
|
|
3090 (progn (insert "" verilog-str)
|
|
|
3091 (message "(No match)"))
|
|
|
3092 (insert "" match))
|
|
|
3093 ;; Give message about current status of completion
|
|
|
3094 (cond ((equal match 't)
|
|
|
3095 (if (not (null (cdr allcomp)))
|
|
|
3096 (message "(Complete but not unique)")
|
|
|
3097 (message "(Sole completion)")))
|
|
|
3098 ;; Display buffer if the current completion didn't help
|
|
|
3099 ;; on completing the label.
|
|
|
3100 ((and (not (null (cdr allcomp))) (= (length verilog-str)
|
|
|
3101 (length match)))
|
|
|
3102 (with-output-to-temp-buffer "*Completions*"
|
|
|
3103 (display-completion-list allcomp))
|
|
|
3104 ;; Wait for a keypress. Then delete *Completion* window
|
|
|
3105 (momentary-string-display "" (point))
|
|
|
3106 (delete-window (get-buffer-window (get-buffer "*Completions*")))
|
|
|
3107 )))))
|
|
|
3108
|
|
|
3109 (defun verilog-show-completions ()
|
|
|
3110 "Show all possible completions at current point."
|
|
|
3111 (interactive)
|
|
|
3112 (let* ((b (save-excursion (skip-chars-backward "a-zA-Z0-9_") (point)))
|
|
|
3113 (e (save-excursion (skip-chars-forward "a-zA-Z0-9_") (point)))
|
|
|
3114 (verilog-str (buffer-substring b e))
|
|
|
3115 ;; The following variable is used in verilog-completion
|
|
|
3116 (verilog-buffer-to-use (current-buffer))
|
|
|
3117 (allcomp (if (and verilog-toggle-completions
|
|
|
3118 (string= verilog-last-word-shown verilog-str))
|
|
|
3119 verilog-last-completions
|
|
|
3120 (all-completions verilog-str 'verilog-completion))))
|
|
|
3121 ;; Show possible completions in a temporary buffer.
|
|
|
3122 (with-output-to-temp-buffer "*Completions*"
|
|
|
3123 (display-completion-list allcomp))
|
|
|
3124 ;; Wait for a keypress. Then delete *Completion* window
|
|
|
3125 (momentary-string-display "" (point))
|
|
|
3126 (delete-window (get-buffer-window (get-buffer "*Completions*")))))
|
|
|
3127
|
|
|
3128
|
|
|
3129 (defun verilog-get-default-symbol ()
|
|
|
3130 "Return symbol around current point as a string."
|
|
|
3131 (save-excursion
|
|
|
3132 (buffer-substring (progn
|
|
|
3133 (skip-chars-backward " \t")
|
|
|
3134 (skip-chars-backward "a-zA-Z0-9_")
|
|
|
3135 (point))
|
|
|
3136 (progn
|
|
|
3137 (skip-chars-forward "a-zA-Z0-9_")
|
|
|
3138 (point)))))
|
|
|
3139
|
|
|
3140 (defun verilog-build-defun-re (str &optional arg)
|
|
|
3141 "Return function/task/module starting with STR as regular expression.
|
|
|
3142 With optional second arg non-nil, STR is the complete name of the instruction."
|
|
|
3143 (if arg
|
|
|
3144 (concat "^\\(function\\|task\\|module\\)[ \t]+\\(" str "\\)\\>")
|
|
|
3145 (concat "^\\(function\\|task\\|module\\)[ \t]+\\(" str "[a-zA-Z0-9_]*\\)\\>")))
|
|
|
3146
|
|
|
3147 ;; Function passed to completing-read, try-completion or
|
|
|
3148 ;; all-completions to get completion on any function name. If
|
|
|
3149 ;; predicate is non-nil, it must be a function to be called for every
|
|
|
3150 ;; match to check if this should really be a match. If flag is t, the
|
|
|
3151 ;; function returns a list of all possible completions. If it is nil
|
|
|
3152 ;; it returns a string, the longest possible completion, or t if STR
|
|
|
3153 ;; is an exact match. If flag is 'lambda, the function returns t if
|
|
|
3154 ;; STR is an exact match, nil otherwise.
|
|
|
3155
|
|
|
3156 (defun verilog-comp-defun (verilog-str verilog-pred verilog-flag)
|
|
|
3157 (save-excursion
|
|
|
3158 (let ((verilog-all nil)
|
|
|
3159 match)
|
|
|
3160
|
|
|
3161 ;; Set buffer to use for searching labels. This should be set
|
|
|
3162 ;; within functins which use verilog-completions
|
|
|
3163 (set-buffer verilog-buffer-to-use)
|
|
|
3164
|
|
|
3165 (let ((verilog-str verilog-str))
|
|
|
3166 ;; Build regular expression for functions
|
|
|
3167 (if (string= verilog-str "")
|
|
|
3168 (setq verilog-str (verilog-build-defun-re "[a-zA-Z_]"))
|
|
|
3169 (setq verilog-str (verilog-build-defun-re verilog-str)))
|
|
|
3170 (goto-char (point-min))
|
|
|
3171
|
|
|
3172 ;; Build a list of all possible completions
|
|
|
3173 (while (verilog-re-search-forward verilog-str nil t)
|
|
|
3174 (setq match (buffer-substring (match-beginning 2) (match-end 2)))
|
|
|
3175 (if (or (null verilog-pred)
|
|
|
3176 (funcall verilog-pred match))
|
|
|
3177 (setq verilog-all (cons match verilog-all)))))
|
|
|
3178
|
|
|
3179 ;; Now we have built a list of all matches. Give response to caller
|
|
|
3180 (verilog-completion-response))))
|
|
|
3181
|
|
|
3182 (defun verilog-goto-defun ()
|
|
|
3183 "Move to specified Verilog module/task/function.
|
|
|
3184 The default is a name found in the buffer around point."
|
|
|
3185 (interactive)
|
|
|
3186 (let* ((default (verilog-get-default-symbol))
|
|
|
3187 ;; The following variable is used in verilog-comp-function
|
|
|
3188 (verilog-buffer-to-use (current-buffer))
|
|
|
3189 (default (if (verilog-comp-defun default nil 'lambda)
|
|
|
3190 default ""))
|
|
|
3191 (label (if (not (string= default ""))
|
|
|
3192 ;; Do completion with default
|
|
|
3193 (completing-read (concat "Label: (default " default ") ")
|
|
|
3194 'verilog-comp-defun nil t "")
|
|
|
3195 ;; There is no default value. Complete without it
|
|
|
3196 (completing-read "Label: "
|
|
|
3197 'verilog-comp-defun nil t ""))))
|
|
|
3198 ;; If there was no response on prompt, use default value
|
|
|
3199 (if (string= label "")
|
|
|
3200 (setq label default))
|
|
|
3201 ;; Goto right place in buffer if label is not an empty string
|
|
|
3202 (or (string= label "")
|
|
|
3203 (progn
|
|
|
3204 (goto-char (point-min))
|
|
|
3205 (re-search-forward (verilog-build-defun-re label t))
|
|
|
3206 (beginning-of-line)))))
|
|
|
3207 (defun verilog-showscopes ()
|
|
|
3208 "list all scopes in this module"
|
|
|
3209 (interactive)
|
|
|
3210 (let (
|
|
|
3211 (buffer (current-buffer))
|
|
|
3212 (linenum 1)
|
|
|
3213 (nlines 0)
|
|
|
3214 (first 1)
|
|
|
3215 (prevpos (point-min))
|
|
|
3216 (final-context-start (make-marker))
|
|
|
3217 (regexp "\\(module\\s-+\\w+\\s-*(\\)\\|\\(\\w+\\s-+\\w+\\s-*(\\)")
|
|
|
3218 )
|
|
|
3219 (with-output-to-temp-buffer "*Occur*"
|
|
|
3220 (save-excursion
|
|
|
3221 (message (format "Searching for %s ..." regexp))
|
|
|
3222 ;; Find next match, but give up if prev match was at end of buffer.
|
|
|
3223 (while (and (not (= prevpos (point-max)))
|
|
|
3224 (verilog-re-search-forward regexp nil t))
|
|
|
3225 (goto-char (match-beginning 0))
|
|
|
3226 (beginning-of-line)
|
|
|
3227 (save-match-data
|
|
|
3228 (setq linenum (+ linenum (count-lines prevpos (point)))))
|
|
|
3229 (setq prevpos (point))
|
|
|
3230 (goto-char (match-end 0))
|
|
|
3231 (let* ((start (save-excursion
|
|
|
3232 (goto-char (match-beginning 0))
|
|
|
3233 (forward-line (if (< nlines 0) nlines (- nlines)))
|
|
|
3234 (point)))
|
|
|
3235 (end (save-excursion
|
|
|
3236 (goto-char (match-end 0))
|
|
|
3237 (if (> nlines 0)
|
|
|
3238 (forward-line (1+ nlines))
|
|
|
3239 (forward-line 1))
|
|
|
3240 (point)))
|
|
|
3241 (tag (format "%3d" linenum))
|
|
|
3242 (empty (make-string (length tag) ?\ ))
|
|
|
3243 tem)
|
|
|
3244 (save-excursion
|
|
|
3245 (setq tem (make-marker))
|
|
|
3246 (set-marker tem (point))
|
|
|
3247 (set-buffer standard-output)
|
|
|
3248 (setq occur-pos-list (cons tem occur-pos-list))
|
|
|
3249 (or first (zerop nlines)
|
|
|
3250 (insert "--------\n"))
|
|
|
3251 (setq first nil)
|
|
|
3252 (insert-buffer-substring buffer start end)
|
|
|
3253 (backward-char (- end start))
|
|
|
3254 (setq tem (if (< nlines 0) (- nlines) nlines))
|
|
|
3255 (while (> tem 0)
|
|
|
3256 (insert empty ?:)
|
|
|
3257 (forward-line 1)
|
|
|
3258 (setq tem (1- tem)))
|
|
|
3259 (let ((this-linenum linenum))
|
|
|
3260 (set-marker final-context-start
|
|
|
3261 (+ (point) (- (match-end 0) (match-beginning 0))))
|
|
|
3262 (while (< (point) final-context-start)
|
|
|
3263 (if (null tag)
|
|
|
3264 (setq tag (format "%3d" this-linenum)))
|
|
|
3265 (insert tag ?:)))))))
|
|
|
3266 (set-buffer-modified-p nil))))
|
|
134
|
3267
|
|
|
3268 (defun verilog-submit-bug-report ()
|
|
|
3269 "Submit via mail a bug report on lazy-lock.el."
|
|
|
3270 (interactive)
|
|
|
3271 (let ((reporter-prompt-for-summary-p t))
|
|
|
3272 (reporter-submit-bug-report
|
|
|
3273 "verilog-mode-bugs@silicon-sorcery.com"
|
|
|
3274 (concat "verilog-mode v" (substring verilog-mode-version 12 -3))
|
|
|
3275 '(verilog-indent-level
|
|
|
3276 verilog-indent-level-module
|
|
|
3277 verilog-indent-level-declaration
|
|
|
3278 verilog-indent-level-behavorial
|
|
|
3279 verilog-case-indent
|
|
|
3280 verilog-auto-newline
|
|
|
3281 verilog-auto-indent-on-newline
|
|
|
3282 verilog-tab-always-indent
|
|
|
3283 verilog-auto-endcomments
|
|
|
3284 verilog-minimum-comment-distance
|
|
|
3285 verilog-indent-begin-after-if
|
|
|
3286 verilog-auto-lineup)
|
|
|
3287 nil nil
|
|
|
3288 (concat "Hi Mac,
|
|
|
3289
|
|
|
3290 I want to report a bug. I've read the `Bugs' section of `Info' on
|
|
|
3291 Emacs, so I know how to make a clear and unambiguous report. To get
|
|
|
3292 to that Info section, I typed
|
|
|
3293
|
|
|
3294 M-x info RET m " invocation-name " RET m bugs RET
|
|
|
3295
|
|
|
3296 Before I go further, I want to say that Verilog mode has changed my life.
|
|
|
3297 I save so much time, my files are colored nicely, my co workers respect
|
|
|
3298 my coding ability... until now. I'd really appreciate anything you
|
|
|
3299 could do to help me out with this minor deficiency in the product.
|
|
|
3300
|
|
|
3301 To reproduce the bug, start a fresh Emacs via " invocation-name "
|
|
|
3302 -no-init-file -no-site-file'. In a new buffer, in verilog mode, type
|
|
|
3303 the code included below.
|
|
|
3304
|
|
|
3305 Given those lines, I expected [[Fill in here]] to happen;
|
|
|
3306 but instead, [[Fill in here]] happens!.
|
|
|
3307
|
|
|
3308 == The code: =="))))
|
|
|
3309
|
|
98
|
3310 ;;; verilog.el ends here
|
