;;; vlog-mode.el --- Verilog editing commands for Emacs
;
;   $Source: /home/mmabry/lisp/vlog-mode.el,v $
;	$Id: vlog-mode.el,v 1.15 1998/12/08 14:07:00 mmabry Exp mmabry $	
;
;   $Log: vlog-mode.el,v $
;   Revision 1.15  1998/12/08 14:07:00  mmabry
;   New indent function that works like indenting in cc-mode.  Bug fixes
;   in some of the module instantiation functions.  Abbrev mode fixes.
;   Auto-fill-mode is not turned on by vlog-mode.
;
;   Revision 1.14  1998/05/15 14:29:36  mmabry
;   emacs 20 font-lock fixes and a couple of minor bug fixes
;
;   Revision 1.13  1998/04/17 20:55:13  mmabry
;   bug fixes, clean-up, set C-c C-f to vlog-find-file
;
;   Revision 1.12  1998/03/10 19:12:46  mmabry
;   free variable in byte-compile
;
;   Revision 1.11  1998/03/10 19:10:06  mmabry
;   Bug fixes in port and instance insertion.
;   Added vars to reduce instance name length.
;   Added vlog-indent-line-better-2 but did not enable it since it's not
;   very useful.  Limited functionality.
;
;   Revision 1.10  1998/02/04 16:10:55  mmabry
;   heavily cleaned comments.  Added stutter-period.  Changed tabbing
;   somewhat.
;
;   Revision 1.9  1997/12/11 19:46:59  mmabry
;   fixed the prefix arg for module instantiation
;
;   Revision 1.8  1997/12/11 15:05:12  mmabry
;   why did I comment out the loading of verilog-font-lock.el?
;
;   Revision 1.7  1997/12/10 19:37:39  mmabry
;   changed tabbing functionality to align line when within code.
;   Some templates had a trailing space after word 'begin', which I
;   removed
;
;   Revision 1.6  1997/10/27 14:28:48  mmabry
;   found tab bug in vlog-insert-port-connections
;
;   Revision 1.5  1997/10/16 17:04:46  mmabry
;   added loading of verilog-font-lock mode and bumped revision to 1.4 due
;   to all the changes made.
;
;   Revision 1.4  1997/10/16 16:22:04  mmabry
;   cleaned up for byte compiling
;
;   Revision 1.3  1997/10/15 18:56:55  mmabry
;   auto-fill-mode and abbrev-mode added as defaults
;
;   Revision 1.2  1997/10/14 18:43:16  mmabry
;   incorporated lots of defaults into vlog-mode so that the average user
;   does not require any vlog-mode-hooks just to get functionality.
;
;   Revision 1.1  1997/10/03 21:04:33  mmabry
;   Initial revision
;
;
;;-----------------------------------------------------------------
;;
;; Copyright (C) 1998 by Mark Mabry <mmabry@avici.com>

;; Author: 
;; Version 1.5		(Also under variable `vlog-mode-version')
;; Keywords: Verilog hdl programming

;; GNU Emacs is free software; you can redistribute it and/or modify
;; it under the terms of the GNU General Public License as published by
;; the Free Software Foundation; either version 2, or (at your option)
;; any later version.

;; This program is distributed in the hope that it will be useful,
;; but WITHOUT ANY WARRANTY; without even the implied warranty of
;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
;; GNU General Public License for more details.

;; You should have received a copy of the GNU General Public License
;; along with GNU Emacs; see the file COPYING.  If not, write to
;; the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.

;;;;; Commentary:

;; Major mode for editing the Verilog hardware description language.
;; Called vlog-mode to easily allow user to try other verilog-mode modes.
;; Versions upto 1.3 are from Phil Welling <Philip.Welling@tek.com>
;; Based on shell-script.el and statement.el created by 
;; Daniel Pfeiffer <pfeiffer@cict.fr>.
;; Features were added to statement.el for more flexibility in
;; making skeletons.

;; Also uses abbrev-hooked mode ideas from Todd Carpenter's vhdl-mode
;; as implemented by Richard Eversole <eversole@cadence.com>
;; in his Verilog HDL mode.

;; Version 1.2 Improvements:
;; + vlog-insert-port-connections now correctly fills the port connection
;;	region and indents multi-line ports to column of first port
;; + Modified vlog-for-var-begin and vlog-for-i-begin skeletons so that
;;	they now have defaults.
;; + Changed specparam and parameter abbrevs so that additional `m' and `r',
;;	respectively, is needed.
;; + Added Verilog syntax documentation to skeletons so that
;;	M-x describe-function RET vlog-<function> RET will be more useful.

;; Version 1.2a Improvements
;; + Made small fixes to work with Version 19.

;; Version 1.3 Improvements
;; + Added "forj" abbrev for `vlog-for-j-begin' since the letter "j" only 
;;	appears as the loop variable (whereas "i" is in begIn) to allow
;;	for entire line substitution
;; + New indent mechanism `vlog-indent-line-better'
;;	If text precedes cursor on that line, insert TAB;
;;	Else if looking at SPC or TAB, move cursor to current indentation;
;;	Else indent as far as preceding line, then by `mode-indent-level'
;; + Old indent mechanism `vlog-indent-line' is bound to 
;;		C-c C-i  (same as C-c TAB)
;;	Its operation is
;;		Indent as far as preceding line, then by `mode-level-indent'
;; + "assign" abbrev for `vlog-assign' changed to "assignn"

;; Version 1.4 Improvements
;; + Fixed some vlog-in-comments bugs
;; + Added "_" as word syntax in syntax table
;; + cleaned up byte compilation
;; + New indent mechanism `vlog-indent-line-better'
;;	If text precedes cursor on that line, align line with previous line
;;	Else if looking at SPC or TAB, move cursor to current indentation;
;;	Else indent as far as preceding line, then by `mode-indent-level'.
;;	Use M-i, `tab-to-tab-stop' to insert at tab within a line.
;; + Changed `vlog-insert-port-connections' functionality so that put one 
;;	port per line.  It works well if the input/output declarations are
;;	one per line also, but often works with multiple declarations per
;;	line.  
;; + Created `vlog-stutter-comma' which inserts ` <= ' when two commas are
;;	typed.  Idea came from Todd Carpenter's vhdl mode.
;; + Created `vlog-stutter-period' which inserts a blocking assignment ` = '
;;	when 2 periods are typed.
;; + Created `vlog-update-module-ports' which updates the module port list 
;;	from the i/o declarations.  Uses a new function, 
;;	`vlog-delete-module-ports'.
;; + Created `vlog-insert-module-instance' which will instantiate a module at
;;	point.  It asks for the file name of the module to instantiate.  If 
;;	there are multiple modules per file, the first one is always chosen.
;;	With an arg, it will put down all the wire declarations needed by
;;	this block.
;; + Added two new templates: `vlog-std-reg' and `vlog-enable-reg' which 
;;	are templates for a behavioral flip-flop and enabled flop.
;;

;; Version 1.5 Improvements
;; + Created a new tabbing function `vlog-indent-line-better-2', which should
;;     always format the line correctly.  This is a major change in tabbing 
;;     functionality. The function parses the Verilog code and determines the 
;;     correct indentation based on the preceding lines of code.  Solid basic 
;;     functionality is there. Needs more testing from others.  
;; + Updated the font-lock keywords for changes in Emacs version 20.
;; + Added a new font-lock match of "FIXME" and words inside `' to be fontified
;;     with warning face.
;; + Bug fixes in `abbrev-mode-hook' and `vlog-insert-module-instance'.

;; Enjoy!

;;;;; Support:

;; I am basically issuing this as is.
;; I am slowing adding more high-level functionality to it, and solidifying
;; newer functions.
;; Please send me any errors/improvements since I would like
;; to correct/add them if feasible.

;;;;; Installation:

;; Three files are needed:
;;	1. vlog-mode.el
;;	2. statement.el		File with statement-skeleton functions
;;	3. paired-insert.el	File for bracket matching (not as important)
;;	4. verilog-font-lock.el Font Lock mode
;; Place them in one of the directories of your load-path if you can.
;; If you don't know your load path, type the following in emacs:
;; 	M-x describe-variable RET load-path RET 
;; If these are unwriteable by you, create a directory for them (ie ~/.lisp)
;; and add the following to your ~/.emacs file:
;;	(setq load-path (cons "/home/user/.lisp" load-path))
;;
;; I would recommend byte compiling those 3 files so that they will be
;; faster.  Try
;;	M-x byte-compile-file RET vlog-mode.el RET
;; etc. in emacs.
;; Ignore warnings about auto-fill-hook or auto-fill-function.  They are 
;; version specific.


;; Also, add the following to your ~/.emacs file:
;;
;; ;; Vlog-mode customization
;; (autoload 'vlog-mode "vlog-mode" "Verilog Editing Mode" t)
;; (autoload 'define-statement-skeleton "statement" "\
;; Command for defining a statement-skeleton." nil 'macro)
;; (autoload 'insert-statement-skeleton "statement" "\
;; Command for inserting a statement-skeleton." nil nil)
;; (autoload 'self-insert-maybe-paired "paired-insert" nil t nil)
;; (autoload 'mirror-mode "paired-insert" nil t nil)
;;
;; (setq auto-mode-alist (cons '("\\.v$" . vlog-mode) auto-mode-alist))
;;
;; (add-hook 'vlog-mode-hook 
;;      '(lambda ()  
;;         (progn 
;;         (auto-fill-mode 1)			; Enable auto-fill-mode
;;	   (abbrev-mode 1)              	; Enable abbrev-mode
;;
;;
;; That's it.  


;;
;; Customization examples.  Add these to vlog-mode-hook
;;
;;	   ;; Set number of spaces for indent
;;	   (setq mode-indent-level 3)
;;
;;	   ; Enable matched parens
;;	   (setq self-insert-normally nil)
;;
;;	   ;; Uncomment following line for previous indent behavior
;;	   ;(setq indent-line-function 'vlog-indent-line)
;;	   
;;
;;     ;;;; Examples of adjusting configuration
;;	   ;; Example of new skeleton
;;	   (vlog-defun vlog-try-this "a new skeleton"
;;	          (nil "what to try: " "This is new: " str))
;;	   ;; Example of redefining a skeleton
;;	   (put 'vlog-for nil '("upper limit: "
;;	   		"better for \(i=0;i<" str ";i=i+1\)" \n))

;;;;; Usage:

;; The vlog-mode-hook shown above is the default I normally used.
;; Abbrev mode enabled will probably be the fastest way to insert code.
;; As expected, you are free to change any of the key bindings and
;; abbrevs that you like.
;;
;; For most, you type the Verilog construct and it will expand.
;; For net data types, reg data types, and primitive gates, type the
;; last char twice (ie 'andd' expands to 'and ').
;; This choice allows the user to insert a simple 'and' faster.
;;
;; To list the abbrevs,
;;	M-x list-abbrevs RET
;; One way of having different abbrev bindings would be to start a
;; session in vlog-mode, 
;;	M-x write-abbrev-file RET ~/.abbrev_defs RET
;; Then, edit ~/.abbrev_defs to suit your needs.
;; This program will only create a vlog-mode-abbrev-table if not
;; already specified.

;;; Code:

;; page 1:	variables and settings
;; page 2:	mode-command and utility functions
;; page 3:	statement syntax-commands for various shells
;; page 4:	various other commands

;;;###autoload
;(setq auto-mode-alist
;;;	- that have a suffix .v 
;      (cons '("\\.v$" . vlog-mode)
;		  auto-mode-alist))

(defvar vlog-mode-version "1.5"
  "Version number for vlog-mode")

;; Font Lock variables
(load "verilog-font-lock")

;; Syntax table
(defvar vlog-mode-syntax-table
  (let ((table (copy-syntax-table (standard-syntax-table))))
    (modify-syntax-entry ?\\ "\\" table)
    (modify-syntax-entry ?+ "." table)
    (modify-syntax-entry ?- "." table)
    (modify-syntax-entry ?= "." table)
    (modify-syntax-entry ?% "." table)
    (modify-syntax-entry ?< "." table)
    (modify-syntax-entry ?> "." table)
    (modify-syntax-entry ?& "." table)
    (modify-syntax-entry ?| "." table)
;   set Underscore to word class
    (modify-syntax-entry ?_ "w" table)
    (modify-syntax-entry ?\' "." table)
    ;;;; For Emacs 19
    ;; For dual comments (block and line style)
    (modify-syntax-entry ?/  ". 124b" table)
    (modify-syntax-entry ?*  ". 23"   table)
    (modify-syntax-entry ?\n "> b"    table)
    ;; Give CR the same syntax as newline, for selective-display
    (modify-syntax-entry ?\^m "> b"   table)
	;;;; For XEmacs
    ;(modify-syntax-entry ?/  ". 1456" table)
    ;(modify-syntax-entry ?*  ". 23"   table)
    ;(modify-syntax-entry ?\n "> b"    table)
    ;; Give CR the same syntax as newline, for selective-display
    ;(modify-syntax-entry ?\^m "> b"    table)
    table)
  "Syntax table in use in vlog-mode.")


(defvar vlog-mode-map
  (let ((map (make-sparse-keymap)))
      (define-key map "\C-ca" 'vlog-assign)
      (define-key map "\C-cb" 'vlog-begin-end-groupname)
      (define-key map "\C-cc" 'comment-region)
      (define-key map "\C-ce" 'vlog-enable-reg)
      (define-key map "\C-cf" 'vlog-function)
      (define-key map "\C-cg" 'vlog-declare-reg)
      (define-key map "\C-ci" 'vlog-if-else-begin)
      (define-key map "\C-cj" 'vlog-fork-join-groupname)
      (define-key map "\C-cm" 'vlog-insert-module-instance)
      (define-key map "\C-cq" 'vlog-query-for-variable)
      (define-key map "\C-cr" 'vlog-std-reg)
      (define-key map "\C-ct" 'vlog-table)
      (define-key map "\C-cw" 'vlog-declare-wire)
      (define-key map "\C-c[" 'beginning-of-vlog-module)
      (define-key map "\C-c]" 'end-of-vlog-module)

      (define-key map "\C-c\C-a" 'vlog-always-begin)
      (define-key map "\C-c\C-b" 'vlog-begin-end)
;      (define-key map "\C-c\C-c" 'vlog-case-choice)
      (define-key map "\C-c\C-c" 'vlog-case-statements)
      (define-key map "\C-c\ec" 'vlog-compiler-celldefine)
      (define-key map "\C-c\C-d" 'vlog-defparam)
      (define-key map "\C-c\ed" 'vlog-compiler-define)
;      (define-key map "\C-c\C-f" 'vlog-for-var-begin)
      (define-key map "\C-c\C-f" 'vlog-find-file)
      (define-key map "\C-c\C-j" 'vlog-fork-join)
;      (define-key map "\C-c\C-i" 'vlog-indent-line)
      (define-key map "\C-c\ei" 'vlog-compiler-ifdef-else)
      (define-key map "\C-c\C-m" 'vlog-module)
      (define-key map "\C-c\em" 'vlog-insert-port-connections)
      (define-key map "\C-c\C-n" 'vlog-net-data-types-choice)
      (define-key map "\C-c\C-r" 'vlog-reg-data-types-choice)
      (define-key map "\C-c\C-p" 'vlog-primitive-gates-choice)
      (define-key map "\C-c\p" 'vlog-pin-to-pin-path-delays)
      (define-key map "\C-c\C-o" 'vlog-operators)
      (define-key map "\C-c\C-s" 'vlog-specify)
      (define-key map "\C-c\C-t" 'vlog-task)
      (define-key map "\C-c\C-u" 'vlog-user-defined-primitive)
      (define-key map "\C-c\ep" 'vlog-builtin-print-choice)
      (define-key map "\C-c\e\C-p" 'vlog-builtin-fprint-choice)

    
    (define-key map "(" 'self-insert-maybe-paired)
    (define-key map "{" 'self-insert-maybe-paired)
    (define-key map "[" 'self-insert-maybe-paired)
    (define-key map "'" 'self-insert-maybe-paired)
    (define-key map "`" 'self-insert-maybe-paired)
    (define-key map "\"" 'self-insert-maybe-paired)

;	(define-key map "."        'vlog-stutter-period)
	(define-key map ","        'vlog-stutter-comma)
    
    (define-key map "\C-m" 'vlog-newline-and-indent)
    (define-key map "\C-j" 'newline)
    map)
  "Keymap used in vlog-mode.")

(defvar vlog-shell nil
  "The shell being programmed.  nil because only used for vlog.")

;; this gets assigned to mode-indent-level
;(defvar vlog-indent-level 2
;  "The default value for indenting in vlog-mode.
;This is the width of tab stops after the indentation of the preceeding line.")
(defvar mode-indent-level 2
  "The default value for indenting in vlog-mode.
This is the width of tab stops after the indentation of the preceeding line.")

(defvar vlog-remember-variable-min 2
  "*Don't remember variables less than this length for completing reads.")

(defvar vlog-fill-port-list nil
  "*Specifies whether to fill the module port list.")

(defvar end-comment-column 76 
  "*Specifies the fill column for comments in vlog-mode.")

(defvar vlog-module-multiline-to-first-port nil
  "*Whether to have multiple lines in a module port list.")

;  This goes into your .abbrev_defs file, but if it isn't there, this takes
;  care of adding it automatically. 
(defvar vlog-mode-abbrev-table nil
  "Abbreviation table used in Vlog HDL mode buffers.")

;process-environment and reserved words
(defvar vlog-variables
  '(("always")		("endtask")	("or")		("supply0")
    ("and")		("event")	("output")	("supply1")
    ("assign")		("for")		("parameter")	("table")
    ("attribute")	("force")	("pmos")	("task")
    ("begin")		("forever")	("posedge")	("time")
    ("buf")		("fork")	("primitive")	("tran")
    ("bufif0")		("function")	("pull0")	("tranif0")
    ("bufif1")		("highz0")	("pull1")	("tranif1")
    ("case")		("highz1")	("pulldown")	("tri")
    ("casex")		("if")		("pullup")	("tri0")
    ("casez")		("initial")	("rcmos")	("tri1")
    ("cmos")		("inout")	("reg")		("triand")
    ("deassign")	("input")	("release")	("trior")
    ("default")		("integer")	("repeat")	("trireg")
    ("defparam")	("join")	("rnmos")	("use")
    ("disable")		("large")	("rpmos")	("vectored")
    ("edge")		("macromodule")	("rtran")	("wait")
    ("else")		("medium")	("rtranif0")	("wand")
    ("end")		("module")	("rtranif1")	("weak0")
    ("endattribute")	("nand")	("scalared")	("weak1")
    ("endcase")		("negedge")	("small")	("while")
    ("endfunction")	("nmos")	("specify")	("wired")
    ("endmodule")	("nor")		("specparam")	("wor")
    ("endprimitive")	("not")		("strength")	("xnor")
    ("endspecify")	("notif0")	("strong0")	("xor")
    ("endtable")	("notif1")	("strong1")
  )
  "Alist of all variables and reserved words used for completing read.")

;; mode-command and utility functions

(require 'dabbrev)
;(load "paired-insert.el")
(autoload 'define-statement-skeleton "statement"
  "Command for defining a statement-skeleton." nil 'macro)
(autoload 'insert-statement-skeleton "statement"
  "Command for inserting a statement-skeleton." nil nil)
(autoload 'self-insert-maybe-paired "paired-insert")

;;;###autoload
(defun vlog-mode ()
  "Major mode for editing Verilog files.

Behavior is to use statement skeletons for the various Verilog constructs.
These statements may be invoked either through an extensive abbrev-mode table
or through the C-c prefix.

The syntax of statements can be modified by putting a property on 
the command or new ones defined with vlog-defun.  
For example

	(put 'vlog-until nil '(() \"until \" _ \\n > \"do\" \\n \"done\"))
or
	(put 'vlog-if nil '(\"What? \" \"If ya got ( \" str \" ) ya betta {  }\"))

where `vlog-until' or `vlog-if' have been or will be defined 
by `vlog-defun'.

The following commands are available:

\\[vlog-always]	 Insert an always block statement
\\[vlog-always-begin]	 Insert an always block statement with a begin-end statement
\\[vlog-assign]	 Insert an explicit assign statement
\\[vlog-begin-end]	 Insert a begin-end statement
\\[vlog-begin-end-groupname]	 Insert begin-end statement with group_name
\\[vlog-case-choice]	 Insert a case statement
\\[vlog-case-statements]	 Insert a case statement prompting for the individual statements
\\[vlog-compiler-celldefine]	 Insert a `celldefine and `endcelldefine compiler directives statement
\\[vlog-compiler-define]	 Insert a `define compiler directive statement
\\[vlog-defparam]	 Insert a defparam statement
\\[vlog-find-file]	Opens the filename specified by the word that point is on.  Must be in current dir.
\\[vlog-for]	 Insert a for statement
\\[vlog-for-var-begin]	 Insert a for statement with index var choice 
\\[vlog-fork-join]	 Insert a fork-join statement
\\[vlog-fork-join-groupname]	 Insert fork-join statement with group_name
\\[vlog-function]	 Insert a function statement
\\[vlog-if-else]	 Insert an if statement with multiple else statements
\\[vlog-if-else-begin]	 Insert an if statement with multiple else statements and begin-end pairs
\\[vlog-compiler-ifdef-else]	 Insert an `ifdef compiler directive statement with an `else statement
\\[vlog-module]	 Insert a 'module <module_name>' statement
\\[vlog-insert-port-connections]	 Insert port connections for module
\\[vlog-update-module-ports]	Updates all ports in a module declaration from i/o declares
\\[vlog-module-instance]	 Insert a module instance (old and very manual)
\\[vlog-insert-module-instance]	Insert a module instance as taken from the file containing the definition of the module.
\\[vlog-update-module-instance]	Deletes and re-instantiates the instance that the point is on.
\\[vlog-integer]	 Insert an integer with size, base, and value
\\[vlog-net-data-types-choice]	 Insert net data types with drive_strength, size, and delay
\\[vlog-reg-data-types-choice]	 Insert register data types with size and array_size
\\[vlog-primitive-gates-choice]	 Insert a primitive (gate) instance with drive_strength, delay, 
			name, and array range
\\[vlog-specify]	 Insert a specify block statement
\\[vlog-task]	 Insert a task statement
\\[vlog-table]	 Insert a table statement
\\[vlog-user-defined-primitive]	 Insert a User Defined Primitive (UDP)
\\[vlog-pin-to-pin-path-delays]	 Insert pin-to-pin path delays
\\[vlog-operators]	 Insert an operator statement

\\[backward-delete-char]	 Delete backward one character
\\[backward-delete-char-untabify]	 Delete backward one position, even if it was a tab.
\\[help-for-help]	 Help key binding

\\[vlog-newline-and-indent]	 Delete unquoted space and indent new line same as this one.
\\[vlog-inline-comment]	 Add an inline comment with //

\\[vlog-query-for-variable]	 Query for a variable or reserved word with completions offered

\\[vlog-insert-port-connections]	Insert output, inout, and input sigs in module ports."
  (interactive)
  (kill-all-local-variables)
  (set-syntax-table vlog-mode-syntax-table)
  (use-local-map vlog-mode-map)
  (make-local-variable 'indent-line-function)
  (make-local-variable 'comment-start)
  (make-local-variable 'comment-start-skip)
  (make-local-variable 'comment-end)
  (make-local-variable 'comment-multi-line)
  (make-local-variable 'comment-column)
  (make-local-variable 'end-comment-column)
  (make-local-variable 'font-lock-defaults)
  (make-local-variable 'require-final-newline)
  (make-local-variable 'vlog-shell)
  (make-local-variable 'self-insert-paired-alist)
  (make-local-variable 'self-insert-no-pairing)
  (make-local-variable 'vlog-variables)
  (make-local-variable 'dabbrev-case-fold-search)
  (make-local-variable 'dabbrev-case-replace)
  (make-local-variable 'font-lock-keywords)
;  (make-local-variable 'mode-indent-level)
  ;; If non-nil, make vlog-insert-port-connections indent to 1st port
  (make-local-variable 'vlog-module-multiline-to-first-port)
  (make-local-variable 'font-lock-defaults)
;  (make-local-variable 'vlog-module-port-per-line)
  (setq major-mode 'vlog-mode
	mode-name "Vlog"
	local-abbrev-table vlog-mode-abbrev-table
	abbrev-mode 1
	indent-line-function 'vlog-indent-line-better-2
	comment-start "// "
	comment-end ""
	comment-start-skip "/\\*+ *\\|// *"
	comment-multi-line nil
	comment-column 40
	end-comment-column 76
	fill-column 76
	dabbrev-case-fold-search t
	dabbrev-case-replace nil
	;; C shells do
;	require-final-newline t
	self-insert-paired-alist '((?` ?`))
	self-insert-no-pairing 'vlog-quoted-p
	vlog-module-multiline-to-first-port nil)
  (setq font-lock-defaults '(verilog-font-lock-keywords nil t))

  (run-hooks 'vlog-mode-hook))

(put 'vlog-defun 'lisp-indent-hook 'defun)
(defmacro vlog-defun (command documentation &rest definitions)
  "Define COMMAND with [DOCSTRING] to insert statements as in DEFINITION ...
Prior definitions (e.g. from ~/.emacs) are maintained.
Each definition is built up as (SHELL PROMPT ELEMENT ...).  Alternately
a synonym definition can be (SHELL . PREVIOUSLY-DEFINED-SHELL).

For the meaning of (PROMPT ELEMENT ...) see insert-statement-skeleton.
Each DEFINITION is actually stored as
	(put COMMAND SHELL (PROMPT ELEMENT ...)),
which you can also do yourself."
  (or (stringp documentation)
      (setq definitions (cons documentation definitions)
	    documentation ""))
  ;; The compiled version doesn't.
  (require 'backquote)
  (`(progn
      (let ((definitions '(, definitions)))
	(while definitions
	  (or (get '(, command) (car (car definitions)))
	      (put '(, command) (car (car definitions))
		   (if (symbolp (cdr (car definitions)))
		       (get '(, command) (cdr (car definitions)))
		     (cdr (car definitions)))))
	  (setq definitions (cdr definitions))))
      (defun (, command) (arg)
	(, documentation)
	(interactive "*P")
	(insert-statement-skeleton
	 (or (get '(, command) vlog-shell)
	     (error "%s statement syntax not defined for shell %s."
		    '(, command) vlog-shell)))))))

;; Old indent-line-better
;(defun vlog-indent-line-better ()
;  "If text precedes point on that line, insert TAB;
; Else if looking at SPC or TAB, move cursor to current indentation;
; Else indent as far as preceding line, then by steps of `mode-indent-level'"
;  (interactive)
;  (let ((previous (save-excursion
;		    (previous-line 1)
;		    (current-indentation))) ;get indentation col of prev line
;	(origpos (point))
;	(origmarker (point-marker))
;	(current (save-excursion
;		   (back-to-indentation)
;		   (current-column))))	;get indentation col of this line
;    (beginning-of-line)
;    (if (re-search-forward "[^ \t]" origpos 'f)	;goto to origpos if fail
;		;cursor is within the line of code
;                ; This inserted 'mode-indent-level' spaces within line of code
;;		(progn
;;		  (goto-char origpos)
;;		  ;(insert "\t")         ;; mhm - use spaces instead of tab
;;		  (insert-char ?\  mode-indent-level)
;;		  )
;	;; This code lines up this line with previous line
;	(progn
;	  (back-to-indentation)
;	  (delete-region (point) ;to possibly replace spaces with tabs
;			 (progn (beginning-of-line)
;				(point))) 
;	  (indent-to previous)
;	  (goto-char origmarker)
;	  )
;      (if (looking-at "[ \t]")		;origpos is within initial indentation
;		  (back-to-indentation)
;		(progn			;cursor is at start of line of code
;		  (delete-region (point) ;to possibly replace spaces with tabs
;				 (progn (beginning-of-line)
;					(point))) 
;		  (indent-to (if (< current previous)
;				 previous
;			       (+ current mode-indent-level))))
;		))))


(defvar vlog-begend-regexp "\\(\\<begin\\>\\|\\<end\\>\\)")
(defvar vlog-begendcase-regexp "\\(\\<case[xz]?\\>\\|\\<endcase\\>\\)")
(defvar vlog-begenddef-regexp "\\(\`ifdef\\>\\|\`endif\\>\\)")
(defvar vlog-begendmod-regexp "\\(\\<module\\>\\|\\<endmodule\\>\\)")

(defun vlog-indent-line-better-2 ()
  "If text precedes point on that line, insert TAB;
Else if looking at SPC or TAB, move cursor to current indentation;
Else indent as far as preceding line, then by steps of `mode-indent-level' 
-mhm "
  (interactive)
  ;(debug 'debug)
  (let ((origmarker (point-marker))
	(origpos (point))
	(endline nil)
	(markerhack nil)
					; get indentation col of prev line
;	(previous (vlog-get-previous-indent)) 
	previous 
	(eol (save-excursion
	       (end-of-line)
	       (point)))
	(bol (save-excursion
	       (beginning-of-line)
	       (point))))
    (beginning-of-line)
    ; Is this line an `end' line?
    (cond
     ((looking-at 
       "\\s *\\(\\<end\\(case\\|if\\|module\\)?\\>\\|\`else\\>\\|\`endif\\>\\)")
      ;; this line has end on it
;      (message "ms is %s" (match-string 2))
      (setq endline 't)
      (cond 
       ;; endcase
       ((string= (match-string 2) "case")
	(setq previous (save-excursion 
			 (vlog-find-matching-begin 
			  vlog-begendcase-regexp "endcase"))))
       ;; `endif/`else
       ((or (string= (match-string 1) "`endif")
	    (string= (match-string 1) "`else"))
	(setq previous (save-excursion 
			 (vlog-find-matching-begin 
			  vlog-begenddef-regexp "endif"))))
       ((string= (match-string 2) "module")
	(setq previous (save-excursion 
			 (vlog-find-matching-begin 
			  vlog-begendmod-regexp "endmodule"))))
       ;; end
       (t
	(setq previous (save-excursion 
			 (vlog-find-matching-begin
			  vlog-begend-regexp "end")))))
      (back-to-indentation)
      (delete-region (point) bol)
      (indent-to previous)
;      (if (not (< previous mode-indent-level))
;      (indent-to (- previous mode-indent-level))
;)
      (goto-char origmarker))
     ; no "end" on this line
     ; this line ends in a comma
;     ((and (looking-at "[^*,\\s *$")
;      ; if previous line ends in a comma, line them up
;	   (save-excursion
;	     (forward-line -1)
;	     (looking-at "\\s +\\..*,\\s *$")))
;      (setq previous (save-excursion 
;		       (forward-line -1)
;		       (back-to-indentation)
;		       (current-column)))
;      (message "dot comma line")
;      (back-to-indentation)
;      (delete-region (point) bol)
;      (indent-to previous)
;      (goto-char origmarker)
;      )
     
     ; else, this is not an `end' line
     (t 
      (let ((parselim (save-excursion
			(beginning-of-line)
			(point)))
	    ;; `ToDo' Optimization? => set cl-paren-lim = parselim.
	    (cl-paren-lim (save-excursion
			(beginning-of-line)
			(point))))
	(setq previous (save-excursion
			 (vlog-prev-line-indent-walk parselim cl-paren-lim)))
;	(message "previous is %s" previous)
	(back-to-indentation)
	;; indent for line continuation
;	(if (vlog-line-continuation endline)
;	    (setq previous (+ previous mode-indent-level)))
	(cond 
	 ;; blank line
	 ((and (looking-at "$")
	       (eq bol origpos))
;	  (message "Blank line")
	  (setq markerhack 'blank-line)
	  )
	 ;; for maintaining cursor position
	 ((and (not (> origpos (point)))
	       (not (eq bol (save-excursion
			      (goto-char origmarker)
			      (point)))))
;	  (message "reseting origmarker")
	  (setq origmarker (save-excursion
			     (forward-char 1)
			     (point-marker)))
	  (setq markerhack 'indent-rgn)
	  )
	 )
	;; Do new indentation
	(delete-region (point) bol)
	(indent-to previous)
	;; Correct cursor position
	(goto-char origmarker)
	(cond ((eq markerhack 'indent-rgn)
	       (forward-char -1))
	      ((eq markerhack 'blank-line)
	       (end-of-line))
	      )
	;; don't leave cursor on bol
	(if (eq (current-column) 0)
	    (back-to-indentation))
	)
      )
     )
    )
  )

; 
(defvar vlog-initial-indent 2)
(defvar vlog-statement-begin-regexp 
  "\\(\\<always\\>\\|\\<if\\>\\|\\<else\\>\\|\\<forever\\>\\|\\<initial\\>\\)" )
;(setq vlog-statement-begin-regexp 
;  "\\(\\<always\\>\\|\\<if\\>\\|\\<else\\>\\|\\<forever\\>\\|\\<initial\\>\\)" )
(defvar vlog-case-item-begin-regexp "\\w+:\\s +")
;(setq vlog-case-item-begin-regexp "\\w+:\\s +")

(defun vlog-begin-end-search-backward ()
  ""
  (if (re-search-backward 
       "^.*\\(\\<begin\\>\\|\\<end\\(case\\)?\\>\\|\\<case[xz]?\\>\\)" 
       (point-min) 't)
      (progn
	(goto-char (match-beginning 1))
	(if (vlog-in-comment)
	    (vlog-begin-end-search-backward)
	  (progn
	    (beginning-of-line)
;	    (message "Found a true begin/end")
	    't
	    )
	  )
    ;else return 0 because there wasn't one to be found
	)
    )
)

(defun vlog-line-continuation (endline)
  "When to add another indent due to line continuation"
;  (message "Inside line continuation check")
  (save-excursion 
    (if (or (eq endline t)
	    (looking-at "[^\n]*\\<begin\\>.*$"))
	nil
      (forward-line -1)
      (if (or (looking-at "[ \t]*$")
	      (looking-at "[^\n]*\\(;\\|\\<begin\\>\\).*$")
	      (looking-at 
	       "\\s *\\(`?end\\(if\\)?\\|case\\).*$"))
	  nil t))))


(defun vlog-find-matching-begin (begend-regexp end-str &optional move)
  ""
  ;(debug 'debug)
  (let ((ms nil))
    (defun inner-find-matching-begin (begend-regexp end-str )
      ""
      (while (or (string= ms end-str)
		  (string= ms nil))
	(re-search-backward begend-regexp (point-min) 't)
	(setq ms (match-string 0))
	(while (vlog-in-comment)
	  (re-search-backward begend-regexp (point-min) 't)
	  (setq ms (match-string 0))
	  )
	(if (string= ms end-str)
	    (progn
;	    (inner-find-matching-begin begend-regexp end-str)
	      (inner-find-matching-begin begend-regexp end-str))
;	(message "inner begin is %s" (point))
	  )
	)
      (setq ms nil)
      )
;    (message "bg is %s" begend-regexp)
;    (message "es is %s" end-str)
    (inner-find-matching-begin begend-regexp end-str)
    )
  (if (eq move t)			;don't move to point just return col
      (progn
	;(message "point is %s" (point))
;      (message "On line: %s" (count-lines (point-min) (point)))
      )
    (back-to-indentation)
 ; (message "Matching Begin is at %s" (point))
    (current-column))
  )

(defun vlog-backward-parens-get-col (bol)
  ""
  (skip-chars-backward " \t" bol)
  (if (memq (char-before) '(?\) ?\] ?\}))
      (backward-list))
  (back-to-indentation)
  (current-column))

;(defun vlog-backward-parens (bol)
;  ""
;  (skip-chars-backward " \t" bol)
;  (if (memq (char-before) '(?\) ?\] ?\}))
;      (backward-list))
;  (back-to-indentation)
;  (current-column))

(defun vlog-prev-line-indent-walk (parselim cl-paren-lim)
  "Walk up the code testing for a line to derive the indent level from.  
Return the indent level."
  (let (bol ms 
	(continued-line nil)
	(begin-on-curline nil)
	(pstate nil)
	(no-cont-line nil)
	(indent-lvl 0))

    (defun vlog-unmatched-open-paren-line (parselim)
      ""
      (save-excursion
;	(message "point is %d" (point))
;	(message "parselim is %d" parselim)
	(setq pstate (parse-partial-sexp (point) parselim))
	
;	(message "paren depth is %s" (nth 0 pstate))
;	(message "position is %s" (nth 1 pstate))
	(nth 1 pstate)
	)
      )

    (defun vlog-unmatched-close-paren-line (cl-paren-lim)
      ""
      (save-excursion
	(setq pstate (parse-partial-sexp (point) cl-paren-lim))
;	(message "position is %s" (nth 2 pstate))
;	(message "min paren depth is %s" (nth 6 pstate))
	(if (< (nth 6 pstate) 0)
	    t nil
	    )
	)
      )

    (defun indent-anchor (first-line)
      "Returns indent level based current line, if there are code anchor
 points on the line.  If not, return nil."
      (beginning-of-line)
      (setq bol (point))
;    (message "Walking on line %d i-a" (1+ (count-lines (point-min) (point))))
      (cond 
       ;; check for begin/end/case 
       ((looking-at 
	 "[^\n]*\\(\\<begin\\>\\|\\<end\\(case\\)?\\>\\|\\<case[xz]?\\>\\)")
;      (message "line has begin/end/case match")
	(setq ms (match-string 1))
	(goto-char (match-beginning 1))
	(if (not (vlog-in-comment))
	    (progn
;           (message "Found a true begin/end")
	      (if (string= ms "begin")
		  (progn
;		    (message "mil is %d" mode-indent-level)
;		(setq indent-lvl (vlog-backward-parens-get-col bol))
		    (setq indent-lvl (+ (vlog-backward-parens-get-col bol)
					mode-indent-level)))
		(back-to-indentation)
;		(message "case or end match")
;		(message "match string is %s" ms)
		(setq indent-lvl (+ (current-column)
				    (if (or (string= ms "case")
					    (string= ms "casex")
					    (string= ms "casez"))
					mode-indent-level 0))))
	      )
;	  (vlog-prev-line-indent-walk parselim) ; else go up 1 line and look again
	  nil
	  )
	)
       ;; check for ifdef/else/endif 
       ((looking-at "[^\n]*\\(\`ifdef\\>\\|\`else\\>\\|\`endif\\>\\)")
;      (message "line has ifdef/else/endif match")
	(setq ms (match-string 1))
	(goto-char (match-beginning 1))
	(if (not (vlog-in-comment))
;	  (progn
;	    (message "Found a true ifdef/endif")
;	  (setq indent-lvl (current-column))
	    (setq indent-lvl (+ (current-column)
				(if (or (string= ms "\`ifdef")
					(string= ms "\`else"))
				    mode-indent-level 0)))
;	    )
;	  (vlog-prev-line-indent-walk parselim) ; else go up 1 line and look again
	  nil
	  )
	)
       ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
       ;; check for if/else without a begin
       ;;; Work in Progress ;;
;;       ((looking-at "\w*\\(else\\>\\||if\\>\\)
       ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
       ;; check for (, {, [ on current line
       ;; first check for a closing paren w/o a preceeding open paren 
       ((and (goto-char bol)
	     (vlog-unmatched-open-paren-line parselim))
;	(message "checking for unmatched open paren")
	(goto-char (nth 1 pstate))
	(setq continued-line nil)
	(setq indent-lvl (1+ (current-column)))
	)

       ;; check to see if we are inside parens.  if so move to begin of parens.
       ((and (goto-char bol)
	     (vlog-unmatched-close-paren-line cl-paren-lim))
;	(message "we are inside some parens. Getting out.")
;	(vlog-find-matching-begin "\(\\|\)" "\)" t)
	(if (eq first-line t)
	    (progn
	      (if (re-search-forward "[^\n]*;" (save-excursion
						 (end-of-line)
						 (point))
				     t)
		  (if (or (vlog-in-comment)
			  (vlog-in-quote))
		      nil 
		    (setq no-cont-line t))
		(setq no-cont-line t))
	      (beginning-of-line)))
	(up-list -1)
	nil
	)

       ;; check for reg/wire/input/output/inout declare
       ;; (this is a shortcut to looking for module definition
       ((looking-at "\\s *\\(reg\\|wire\\|\\(in\\|out\\)put\\|inout\\)\\>")
;      (message "line initial reg/wire/io declare match")
	(goto-char (match-beginning 1))
	(if (not (vlog-in-comment))
	    (setq indent-lvl (current-column))
;	(vlog-prev-line-indent-walk parselim) ; else go up 1 line and look again
	  nil
	  ))
       ;; check for module definition
       ((looking-at "\\s *\\(module\\)")
;      (message "line has module match")
	(goto-char (match-beginning 1))
	(if (not (vlog-in-comment))
	    (progn
;	    (message "Found a true module")
	      (setq indent-lvl (+ (current-column) mode-indent-level)))
;	(vlog-prev-line-indent-walk parselim) ; else go up 1 line and look again
	  nil
	  ))
       ;; default case - we didn't find anything on this line.  Go up 
       ;; one and try again
       (t (goto-char bol)
;	  (message "nothing found on this line")
;	(vlog-prev-line-indent-walk parselim)
	  ;; if we are at beginning of buffer set indent-lvl = 0
	  (if (eq (point) (point-min))
	      (progn
		(setq continued-line nil) ;turn off so indent-lvl will = 0
		0)
	    nil
	    )
	  )
       )
      )


;    (message "point is %s" (point))
    ;; test for begin on current line.  No line continue here.
    (setq begin-on-curline (looking-at "[^\n]*\\<begin\\>.*$"))
;    (message "First line check starting")
    (forward-line -1)			; goto previous line
    (if (setq indent-lvl (indent-anchor t))
	indent-lvl
      ;; set line cont flag
      (if (and (not begin-on-curline)
	       (not no-cont-line)
	       (not (looking-at "[ \t]*$"))
	       (not (looking-at "[ \t]*`")))
	  (progn
	    (if (re-search-forward "[^\n]*;" (save-excursion
					       (end-of-line)
					       (point))
				   t)
;	    (message "On line %d" (1+ (count-lines (point-min) (point))))  
;	    (if (looking-at "[^\n]*;")
		(if (or (vlog-in-comment)
			(vlog-in-quote))
		    (progn
;		      (message "semi was inside comment")
		      (setq continued-line nil))
		  )
	      ;; no ";" on line
	      (end-of-line)
	      (if (vlog-in-comment)
		  (progn
;		    (message "testing cont line in comment")
		    (setq continued-line nil)) ; comments aren't continues
;		(message "failed cont line in comment test")
		(setq continued-line t))))
	)
      (beginning-of-line)
      (forward-line -1)
;      (message "cont line is %s" continued-line)
      ;; walk up file for indent level
      (while (not (setq indent-lvl (indent-anchor nil)))
	(forward-line -1))
      (setq indent-lvl (+ indent-lvl
			  (if continued-line mode-indent-level 0)))
      )
    ))


;(defun vlog-indent-line ()
;  "Indent as far as preceding line, then by steps of `mode-indent-level'."
;  (interactive)
;  (let ((previous (save-excursion
;		    (previous-line 1)
;		    (current-indentation)))
;		(current (progn
;				   (back-to-indentation)
;				   (current-column))))
;    (delete-region (point)
;		   (progn (beginning-of-line)
;			  (point)))	; to possibly replace spaces with tabs
;    (indent-to (if (< current previous)
;							   previous
;							 (+ current mode-indent-level)))
;	)
;  )

(defun vlog-remember-variable (var)
  "Make VARIABLE available for future completing reads in this buffer."
  ;; Used with vlog-query-for-variable
  (or (< (length var) vlog-remember-variable-min)
      (assoc var vlog-variables)
      (setq vlog-variables (cons (list var) vlog-variables)))
  var)


(defun vlog-quoted-p ()
  "Is point preceded by an odd number of backslashes?"
  (eq 1 (% (- (point) (save-excursion
			(skip-chars-backward "\\\\")
			(point)))
	   2)))

;; various other commands

(defun vlog-query-for-variable (arg)
  "Query for a variable-name or reserved words with completions offered."
  (interactive "*p")
    (let (completion-ignore-case
	  (minibuffer-local-completion-map
	   (or (get 'vlog-query-for-variable 'keymap)
	       (put 'vlog-query-for-variable 'keymap
		    (copy-keymap minibuffer-local-completion-map))))
	  (buffer (current-buffer)))
      (insert
       (prog1
	   (vlog-remember-variable
	    (completing-read "Variable: " vlog-variables
			     (function (lambda (element)
					 (or (not (cdr element))
					     (memq vlog-shell (cdr element)))))))
	 (if (eq t arg) (forward-char 1))))
      (if (eq t arg) (forward-char 1))))


(defun vlog-newline-and-indent (&optional arg)
  "Strip unquoted whitespace, insert a newline and indent it like current line.
Unquoted whitespace is stripped from the current line's end, unless a
prefix ARG is given."
  (interactive "*P")
  (let ((previous (current-indentation))
		str
		(end-of-line (point)))
    (if arg ()
      (skip-chars-backward " \t") 
      (and (< (point) end-of-line)
;	   (vlog-quoted-p)
		   (forward-char 1))
;      (setq str (read-string (format "%s%c%d" "ready2" ?  (point))))
      (delete-region (point) end-of-line)
	  )
    (newline)
    (indent-for-tab-command)
;    (skip-chars-forward " \t")
;	(message "%d" previous)
;    (indent-to previous)
))


;;========================================================================
;; statement syntax-commands
;;========================================================================

;; You are welcome to add the syntax or even completely new statements as
;; appropriate for your favorite style.

(vlog-defun vlog-always
  "Insert an always block statement."
  (nil "Condition: "
       "always @ (" str ")" \n
       > _ ))

(vlog-defun vlog-always-begin
  "Insert an always block statement with a begin-end statement."
  (nil "Condition: "
       "always @ (" str ") begin" \n
       > _ \n
       < "end//always "))

(vlog-defun vlog-assign
  "Insert an explicit assign statement."
  (nil nil
       "assign "
       ("[delay rise \(min\)]: " % "#\(" str
	("[delay rise \(typ\)]: " % ":" str
	 ("[delay rise \(max\)]: " % ":" str))
	("[delay fall\(min\)]: " % "," str
	 ("[delay fall \(typ\)]: " % ":" str
	  ("[delay fall \(max\)]: " % ":" str))
	 ("[delay turn-off\(min\)]: " % "," str
	  ("[delay turn-off \(typ\)]: " % ":" str
	   ("[delay turn-off \(max\)]: " % ":" str))))
	"\) ")
       ("net_name: " % str)
       " = "
       ("assignment: " % str)
       ";"))

(vlog-defun vlog-begin-end
  "Insert a begin-end statement."
  (nil nil
       "begin" \n
       > _ \n
       < "end"))

(vlog-defun vlog-begin-end-groupname
  "Insert a begin-end statement with optional groupname."
  (nil nil
       "begin" 
       ("[group_name]: " % ": " str) 
       \n
       > _ \n
       < "end"))

(vlog-defun vlog-case-choice
  "Insert a case statement prompting for case matches with choice of case type."
  (nil nil
       "case"
       ("type of case \(null, x, or z\): " % str)
       " \("
       ("net or register: " % str)
       "\)" \n
       >
       ("[case match]: " % str ": " _ ";" \n
	("[case match]: " str ": ;" \n))
       ("[default]: " % "default: ;" \n)
       < "endcase" ))

(vlog-defun vlog-case
  "Insert a case statement prompting for case matches."
  (nil nil
       " \("
       ("net or register: " % str)
       "\)" \n
       >
       ("[case match]: " % str ": " _ ";" \n
	("[case match]: " str ": ;" \n))
       ("[default]: " % "default: ;" \n)
       < "endcase" ))

(vlog-defun vlog-case-statements
  "Insert a case statement prompting for case matches and
for the individual statements."
  (nil nil
       "case"
       ("type of case \(null, x, or z\): " % str)
       " \("
       ("net or register: " % str)
       "\)" \n
       >
       ("[case match]: " str ": "
	("[statement]: " % str)
	";" \n)
       "default: " _ ";" \n
       < "endcase"))

(vlog-defun vlog-compiler-celldefine
  "Insert a `celldefine and `endcelldefine compiler directives statement."
  (nil nil
       "`celldefine" \n
       _ \n
       "`endcelldefine"))

(vlog-defun vlog-compiler-define
  "Insert a `define compiler directive statement."
  (nil "mnemonic [with optional (args)]: "
       "`define " str
       ("text_string [include optional (args)]: " % " " str) \n
       ))

(vlog-defun vlog-defparam
  "Insert a defparam for parameter redefinition."
  (nil nil
       ("defparam instance_name: " "defparam " str "."
	("parameter_name: " % str)
	" = "
	("value: " % str)
	";")))

(vlog-defun vlog-for
  "Insert a for statement."
  (nil "Initial assignment: "
       "for \(" str "; "
       ("expression: " %  str)
       "; "
       ("step assignment: " % str)
       "\)" \n
       > _ ))

(vlog-defun vlog-for-i-begin
  "Insert a for statement using i with begin-end pair."
  (nil "upper limit[32]: "
       "for \(i=0; i<" str | "32"
       "; i=i+1\) begin" \n
       > _ \n
       < "end"))

(vlog-defun vlog-for-j-begin
  "Insert a for statement using j with begin-end pair."
  (nil "upper limit[32]: "
       "for \(j=0; j<" str | "32"
       "; j=j+1\) begin" \n
       > _ \n
       < "end"))

(vlog-defun vlog-std-reg 
  "Make a specific register always statement"
  (nil "Reg name: "
	   "always @ (posedge clk or negedge reset_l) begin" \n
	   > "if (!reset_l) begin" \n
	   > str " <= 0;" \n
	   < "end" \n
	   "else begin" \n
	   > str " <= ;" \n
	   < "end" \n
	   < "end//always "))

(vlog-defun vlog-enable-reg "Make a specific enabled register always statement"
  (nil "Reg name: "
	   "always @ (posedge clk or negedge reset_l) begin" \n
	   > "if (!reset_l) begin" \n
	   > str " <= 0;" \n
	   < "end" \n
	   "else begin" \n
	   > "if () begin" \n
	   > str " <= ;" \n
	   < "end" \n
	   < "end" \n
	   < "end//always "))

(vlog-defun vlog-for-var-begin
  "Insert a for statement using index var (prompted for) with begin-end pair.
Prefix ARG can change the upper limit from the default."
  (nil "index variable: "
       "for \(" str | "i" "=0; " str | "i"  "<" arg | "32"  
       "; " str | "i" "=" str | "i" "+1\) begin" \n
       > _ \n
       < "end"))

(vlog-defun vlog-for-begin
  "Insert a for statement with begin-end pair."
  (nil "Initial assignment: "
       "for \(" str "; "
       ("expression: " %  str)
       "; "
       ("step assignment: " % str)
       "\) begin" \n
       > _ \n
       < "end"))

(vlog-defun vlog-fork-join
  "Insert a fork-join statement."
  (nil nil
       "fork" \n
       > _ \n
       < "join"))

(vlog-defun vlog-fork-join-groupname
  "Insert a fork-join statement with optional group_name."
  (nil nil
       "fork " 
       ("[group_name]: " % ": " str)
       \n
       > _ \n
       < "join"))

(vlog-defun vlog-function
  "Insert a function statement.
Functions must have at least one input, and may have any number of outputs
or inouts \(output and inouts new in OVI 2.0\).
They may not contain timing controls.
Functions return the value assigned to the name of the function."
  (nil nil
       "function "
       ("[return size msb]: " % "[" str
	("return size lsb: " % ":" str) "] ")
       ("function_name: " % str)
       ";" \n
       > 
       ("output signals with same port size: " "output " 
	("[msb]: " % "[" str
	 ("lsb: " % ":" str ) "] ") str ";" \n)
       ("inout signals with same port size: " "inout " 
	("[msb]: " % "[" str
	 ("lsb: " % ":" str ) "] ") str ";" \n)
       ("input signals with same port size: " "input " 
	("[msb]: " % "[" str
	 ("lsb: " % ":" str ) "] ") str ";" \n)
       \n 
       _ \n \n
       < "endfunction" \n))

(vlog-defun vlog-if-else
  "Insert an if statement with multiple else statements."
  (nil "expression: "
       "if \(" str "\)" \n
       > _ 
       ("[else if expression]: " \n
	< "else if \(" str "\)" \n
	> )
       ("[else]: " % \n
	< "else" \n
	> )))

(vlog-defun vlog-if-else-begin
  "Insert an if statement with multiple else statements inserting 
a begin-end pair for each one."
  (nil "expression: "
       "if \(" str "\) begin" \n
       > _ \n
       < "end"
       ("[else if expression]: " \n
	"else if \(" str "\) begin" \n
	> \n
	< "end")
       ("[else]: " % \n
	"else begin" \n
	> \n
	< "end")))

(vlog-defun vlog-compiler-ifdef-else
  "Insert an `ifdef compiler directive statement with an `else statement."
  (nil nil
       "`ifdef "
       ("define_mnemonic: " % str  \n)
       > _ \n
       ("[`else]: " % < "`else" \n
	> \n)
       < "`endif"))

(vlog-defun vlog-module
  "Insert a 'module <module_name>' statement."
  (nil "module_name: "
       "module " str " ();" \n
       > 
       ("output signals with same port size: " "output " 
	("[msb]: " % "[" str
	 ("lsb: " % ":" str ) "] ") str ";" \n)
       ("inout signals with same port size: " "inout " 
	("[msb]: " % "[" str
	 ("lsb: " % ":" str ) "] ") str ";" \n)
       ("input signals with same port size: " "input " 
	("[msb]: " % "[" str
	 ("lsb: " % ":" str ) "] ") str ";" \n)
       \n _ \n \n
       < "endmodule //of " str \n))

(vlog-defun vlog-module-instance
  "Insert a module instance."
  (nil "module name for this instance: "
       str " "
       ("[parameter assignments]: " % "#\(" str "\) ")
       ;; Instance name required so if no name, no ports are asked for.
       ("instance name: " % str
	("port connections: " % " \(" str "\)")
	("instance name: " ", " str
	 ("port connections: " % " \(" str "\)")))
       ";"))	

(vlog-defun vlog-integer
  "Insert an integer with size, base, and value.
Ex: 8'hA7"
  (nil "Integer size: "
       str 
       ("base (b, o, d, h): " % "'" str
	("value: " % str))))

(vlog-defun vlog-net-data-types-choice
  "Insert choice of net data type with drive_strength, size, and delay.
Form: net_type \(drive_strength\) [size] #delay net_name\(s\) 
        [= continuous assign];
net_types:
	wire, wor, wand,
	tri, trior, triand, tri1, tri0, supply0, supply1, and trireg"
  (nil nil
       ("Net type: "
	str " "
	("[drive_strength1]: " % "\(" str 
	 ("drive_strength0: " % "," str )
	 "\) ")
	("[size msb]: " % "[" str
	 ("size lsb: " % ":" str) "] ")
	("[delay rise \(min\)]: " % "#\(" str
	 ("[delay rise \(typ\)]: " % ":" str
	  ("[delay rise \(max\)]: " % ":" str))
	 ("[delay fall\(min\)]: " % "," str
	  ("[delay fall \(typ\)]: " % ":" str
	   ("[delay fall \(max\)]: " % ":" str))
	  ("[delay turn-off\(min\)]: " % "," str
	   ("[delay turn-off \(typ\)]: " % ":" str
	    ("[delay turn-off \(max\)]: " % ":" str))))
	 "\) ")
	("net_names: " % str )
	("[continuous assignment]: " % " = " str)
	";")))

(vlog-defun vlog-net-data-types
  "Insert net data types with drive_strength, size, and delay.
Form: net_type \(drive_strength\) [size] #delay net_name\(s\) 
        [= continuous assign];
net_types:
	wire, wor, wand,
	tri, trior, triand, tri1, tri0, supply0, supply1, and trireg"
  (nil nil
       ("[drive_strength1]: " % "\(" str 
	("drive_strength0: " % "," str )
	"\) ")
       ("[size msb]: " % "[" str
	("size lsb: " % ":" str) "] ")
       ("[delay rise \(min\)]: " % "#\(" str
	("[delay rise \(typ\)]: " % ":" str
	 ("[delay rise \(max\)]: " % ":" str))
	("[delay fall\(min\)]: " % "," str
	 ("[delay fall \(typ\)]: " % ":" str
	  ("[delay fall \(max\)]: " % ":" str))
	 ("[delay turn-off\(min\)]: " % "," str
	  ("[delay turn-off \(typ\)]: " % ":" str
	   ("[delay turn-off \(max\)]: " % ":" str))))
	"\) ")
       ("net_names: " % str )
       ("[continuous assignment]: " % " = " str)
       ";"))

(vlog-defun vlog-reg-data-types-choice
  "Insert choice of register data type with size and array_size.
Form: register_type [size] name [array_size];
register_types:
	reg, integer, time, and real"
  (nil nil
       ("Register type: "
	str " "
	("[size msb]: " % "[" str
	 ("size lsb: " % ":" str) "] ")
	("register names: " % str ) 
	("[first address of array size]: " % " [" str
	 ("last address of array size: " % ":" str)
	  "]")
	";")))

(vlog-defun vlog-reg-data-types
  "Insert register data types with size and array_size.
Form: register_type [size] name [array_size];
register_types:
	reg, integer, time, and real"
  (nil nil
       ("[size msb]: " % "[" str
	("size lsb: " % ":" str) "] ")
       ("register names: " % str ) 
       ("[first address of array size]: " % " [" str
	("last address of array size: " % ":" str)
	"]")
       ";"))

(vlog-defun vlog-parameter
  "Insert a parameter data type."
  (nil nil
       ("parameter constant_name: " "parameter " str " = "
	("value: " % str)
	";" \n)))

(vlog-defun vlog-primitive-gates-choice
  "Insert a primitive (gate) instance with drive_strength, delay, 
name, and array range with choice of primitive.
Form: prim_type (drive_strength) #delay [instance_name] 
        [instance_array_range \(OVI 2.0\)] \(terminals\);
prim_types:
	and, nand, or, nor, xor, xnor	\(<1 output>, <1 or more inputs>\)
	buf, not			\(<1 or more outputs>, <1 input>\)
	bufif[01], notif[01], [pn]mos, r[pn]mos
					\(<1 output>, <1 input>, <1 control>\)
	cmos, rcmos			\(<1 output>,<1 input>,<n cnt>,<p cnt>\)
	tran, rtran			\(<2 bidir inouts>\)
	tranif[01], rtranif[01]		\(<2 bidir inouts>, <1 control>\)
	pullup, pulldown		\(<1 output>\)"
  (nil "Primitive type: "
	str " "
	("[drive_strength1]: " % "\(" str 
	 ("drive_strength0: " % "," str )
	 "\) ")
	("[delay rise \(min\)]: " % "#\(" str
	 ("[delay rise \(typ\)]: " % ":" str
	  ("[delay rise \(max\)]: " % ":" str))
	 ("[delay fall\(min\)]: " % "," str
	  ("[delay fall \(typ\)]: " % ":" str
	   ("[delay fall \(max\)]: " % ":" str))
	  ("[delay turn-off\(min\)]: " % "," str
	   ("[delay turn-off \(typ\)]: " % ":" str
	    ("[delay turn-off \(max\)]: " % ":" str))))
	 "\) ")
	("[instance name]: " % str 
	 ("[array range msb \(OVI 2.0\)]: " % "[" str
	  ("array range lsb: " % ":" str)
	  "]")
	 " "
	 )
	"\("
	("terminals: " % str)
	"\)" 
	("[instance name]: " ", " str 
	 ("[array range msb \(OVI 2.0\)]: " % "[" str
	  ("array range lsb: " % ":" str)
	  "]")
	 " \("
	 ("terminals: " % str)
	 "\)" )
	 ";" \n ))

(vlog-defun vlog-primitive-gates
  "Insert a primitive (gate) instance with drive_strength, delay, 
name, and array range.
Form: prim_type (drive_strength) #delay [instance_name] 
        [instance_array_range \(OVI 2.0\)] \(terminals\);
prim_types:
	and, nand, or, nor, xor, xnor	\(<1 output>, <1 or more inputs>\)
	buf, not			\(<1 or more outputs>, <1 input>\)
	bufif[01], notif[01], [pn]mos, r[pn]mos
					\(<1 output>, <1 input>, <1 control>\)
	cmos, rcmos			\(<1 output>,<1 input>,<n cnt>,<p cnt>\)
	tran, rtran			\(<2 bidir inouts>\)
	tranif[01], rtranif[01]		\(<2 bidir inouts>, <1 control>\)
	pullup, pulldown		\(<1 output>\)"
  (nil nil
	("[drive_strength1]: " % "\(" str 
	 ("drive_strength0: " % "," str )
	 "\) ")
	("[delay rise \(min\)]: " % "#\(" str
	 ("[delay rise \(typ\)]: " % ":" str
	  ("[delay rise \(max\)]: " % ":" str))
	 ("[delay fall\(min\)]: " % "," str
	  ("[delay fall \(typ\)]: " % ":" str
	   ("[delay fall \(max\)]: " % ":" str))
	  ("[delay turn-off\(min\)]: " % "," str
	   ("[delay turn-off \(typ\)]: " % ":" str
	    ("[delay turn-off \(max\)]: " % ":" str))))
	 "\) ")
	("[instance name]: " % str 
	 ("[array range msb \(OVI 2.0\)]: " % "[" str
	  ("array range lsb: " % ":" str)
	  "]")
	 " "
	 )
	"\("
	("terminals: " % str)
	"\)" 
	("[instance name]: " ", " str 
	 ("[array range msb \(OVI 2.0\)]: " % "[" str
	  ("array range lsb: " % ":" str)
	  "]")
	 " \("
	 ("terminals: " % str)
	 "\)" )
	";" \n ))

(vlog-defun vlog-specify
  "Insert a specify block statement."
  (nil nil
       "specify" \n
       > 
       ("specparam constant_name: " "specparam " str " = "
	("value: " % str)
	";" \n)
       _ \n
       < "endspecify"))

(vlog-defun vlog-specparam
  "Insert a specparam data type."
  (nil nil
       ("specparam constant_name: " "specparam " str " = "
	("value: " % str)
	";" \n)))

(vlog-defun vlog-task
  "Insert a task statement.
Tasks are subroutines, and may have any number of inputs, outputs, or
inouts, and may contain timing controls."
  (nil "task_name: "
       "task " str ";" \n
       > 
       ("output signals with same port size: " "output " 
	("[msb]: " % "[" str
	 ("lsb: " % ":" str ) "] ") str ";" \n)
       ("inout signals with same port size: " "inout " 
	("[msb]: " % "[" str
	 ("lsb: " % ":" str ) "] ") str ";" \n)
       ("input signals with same port size: " "input " 
	("[msb]: " % "[" str
	 ("lsb: " % ":" str ) "] ") str ";" \n)
       \n 
       _ \n \n
       < "endtask //of " str \n))

(vlog-defun vlog-table
  "Insert a table statement for UDPs.
Entry forms: input_logic_values : output_logic_values;
             input_logic_values : state : output_logic_values;
Table symbols:
  0,1	logic 0,1
  x,X	unknown
  ?	don't care if 0, 1, or X
  b,B	don't care if 0 or 1
  \(vw\)	transition from logic v to logic w
  r,R	rising transition: same as \(01\)
  f,F	falling transition: same as \(10\)
  p,P	positive transition: same as \(01\), \(0X\), or \(X1\)
  n,N	negative transition: same as \(10\), \(1X\), or \(X0\)
  *	any possible transition: same as \(??\)
  -	no change on output of sequential device"
  (nil nil
       "table" \n
       > _ \n
       < "endtable"))

(vlog-defun vlog-user-defined-primitive
  "Insert a User Defined Primitive \(UDP\)."
  (nil "primitive_name: "
       "primitive " str " ();" \n
       >
       ("output terminal: " % "output " str ";" \n )
       ("input terminals: " "input " str ";" \n)
       ("[reg output]: " % "reg " str ";" \n)
       "table" \n
       > _ \n
       < "endtable" \n
       < "endprimitive //of " str \n))

(vlog-defun vlog-pin-to-pin-path-delays
  "Insert a pin-to-pin path delay for within a specify block.
Forms:	\(input [polarity]*> output\) = \(delay\)
	\(input [polarity]=> output\) = \(delay\)
	if \(cond\) \(input [polarity][=*]> output\) = \(delay\)
	\(edge input [=*]> \(output [polarity]: source\)\) = \(delay\)
Different delays can be specified for 1,2,3,6, or 12 transitions."
  (nil nil
       ("[if (condition using input ports)] condition: " "if \(" str "\) "
	("input_port\(s\) with [polarity(+/-)]: " % "\(" str " ")
	("=> or *>: " % str " ")
	("output_port\(s\) or \(output [polarity]: source\): " % str "\) = ")
	("delay rise \(min\): " % "\(" str
	 ("[delay rise \(typ\)]: " % ":" str
	  ("[delay rise \(max\)]: " % ":" str))
	 ("delay fall\(min\): " % "," str
	  ("[delay fall \(typ\)]: " % ":" str
	   ("[delay fall \(max\)]: " % ":" str))
	  ("[delay turn-off\(min\)]: " % "," str
	   ("[delay turn-off \(typ\)]: " % ":" str
	    ("[delay turn-off \(max\)]: " % ":" str))
	   ("[delay for other transitions]: " % ", " str)))
	 "\)")
	";" \n)))

(vlog-defun vlog-expression-question
  "Prompt for expression for repeat and while statements."
  (nil "expression: "
       "\(" str | "1" "\) "))

(vlog-defun vlog-operators
  "Insert an 'operator' statement.
Form: [operand] operator operand

Arithmetic operators:	+ - * / %
			-	Negate \(in 2's complement\)	-n
Bitwise operators:	~	invert each bit			~n
			&	AND each bit
			|	OR each bit
			^	XOR each bit
			~^ ^~	XNOR each bit
Unary Reduction Operators:
			&, ~&	AND, NAND all bits together	&n
			|, ~|	OR, NOR all bits together	|n
		       ^, ~^ ^~	XOR, XNOR all bits together	^n
Logical Operators:	!	Is not true?			!n
			&&, ||	Both, either true?
			==, !=	Equal, not equal for 0 or 1
			===,!==	Equal, not identical for 0, 1, X, and Z
Relational Operators:	< > <= >=
Logical Shift Operators:
			<< >>	Shift left, right n times	m >> n
Other Operators:	?:	<select true> ? <yes> : <no>
			{}	Concatenate signals		{m,n}
			{{}}	Replicate m n-times		{n{m}}
			->	Trigger an event		->n"
  (nil "[operand \(net or reg type\)]: "
       str
       ("operator: " % " " str)
       ("operand \(net or reg type\): " % " " str)))



;; Built-in Tasks and Functions

(vlog-defun vlog-builtin-print-choice
  "Insert one of the builtin tasks for printing with choice of tasks.
Text Formatting Codes:
	%b	binary
	%o	octal
	%d	decimal
	%h	hex
	%e	real, exponential
	%f	real, decimal
	%t	time
	%s	string
	%m	hierarchical names"
  (nil "monitor, display, write, or strobe: "
       "$" str "("
       ("text with format specifiers and quotes: " % str)
       ("[signals]: " % ", " str)
       ");" \n))

(vlog-defun vlog-builtin-print
  "Insert one of the builtin tasks for printing.
Text Formatting Codes:
	%b	binary
	%o	octal
	%d	decimal
	%h	hex
	%e	real, exponential
	%f	real, decimal
	%t	time
	%s	string
	%m	hierarchical names"
  (nil nil
       "("
       ("text with format specifiers and quotes: " % str)
       ("[signals]: " % ", " str)
       ");" \n))

(vlog-defun vlog-builtin-fprint-choice
  "Insert one of the builtin tasks for printing to a file with choice of task"
  (nil "monitor, display, write, or strobe: "
       "$f" str "("
       ("mcd file pointer: " % str ", ")
       ("text with format specifiers and quotes: " % str)
       ("[signals]: " % ", " str)
       ");" \n))

(vlog-defun vlog-builtin-fprint
  "Insert one of the builtin tasks for printing to a file"
  (nil nil
       "("
       ("mcd file pointer: " % str ", ")
       ("text with format specifiers and quotes: " % str)
       ("[signals]: " % ", " str)
       ");" \n))

(vlog-defun vlog-builtin-timeformat
  "Insert the $timeformat builtin task"
  (nil "unit (exponent value): "
       "$timeformat(" str ", "
       ("precision (# of decimal points): " % str ", ")
       ("suffix with quotes: " % str ", ")
       ("min_field_width: " % str )
       ");" \n))

(vlog-defun vlog-builtin-readmem
  "Insert a $readmem[bh] builtin task.
Opens a file for reading, and loads the contents into a register
variable array."
  (nil nil
       "$readmem"
       ("type of readmem \(b or h\): " % str)
       "\("
       ("ASCII filename in quotes: " % str)
       ", "
       ("register_array to load: " % str)
       "\);" \n))

(vlog-defun vlog-builtin-setup
  "Insert the $setup builtin task"
  (nil "data_event: "
       "$setup(" str ", "
       ("reference_event: " % str ", ")
       ("setup_limit: " % str )
       ("[notifier]: " % ", " str)
       ");" \n))

(vlog-defun vlog-builtin-hold
  "Insert the $hold builtin task"
  (nil "reference_event: "
       "$hold(" str ", "
       ("data_event: " % str ", ")
       ("hold_limit: " % str )
       ("[notifier]: " % ", " str)
       ");" \n))

(vlog-defun vlog-builtin-setuphold
  "Insert the $setuphold builtin task"
  (nil "reference_event: "
       "$setuphold(" str ", "
       ("data_event: " % str ", ")
       ("setup_limit: " % str ", ")
       ("hold_limit: " % str )
       ("[notifier]: " % ", " str)
       ");" \n))

(vlog-defun vlog-builtin-skew
  "Insert the $skew builtin task"
  (nil "reference_event: "
       "$skew(" str ", "
       ("data_event: " % str ", ")
       ("skew_limit: " % str )
       ("[notifier]: " % ", " str)
       ");" \n))

(vlog-defun vlog-builtin-recovery
  "Insert the $recovery builtin task"
  (nil "reference_event: "
       "$recovery(" str ", "
       ("data_event: " % str ", ")
       ("recovery_limit: " % str )
       ("[notifier]: " % ", " str)
       ");" \n))

(vlog-defun vlog-builtin-period
  "Insert the $period builtin task"
  (nil "reference_event: "
       "$period(" str ", "
       ("period_limit: " % str )
       ("[notifier]: " % ", " str)
       ");" \n))

(vlog-defun vlog-builtin-width
  "Insert the $width builtin task"
  (nil "reference_event: "
       "$width(" str ", "
       ("width_limit: " % str ", ")
       ("width_threshold: " % str)
       ("[notifier]: " % ", " str)
       ");" \n))

;;========================================================================
;; Abbreviations
;;========================================================================

;  This goes into your .abbrev_defs file, but if it isn't there, this takes
;  care of adding it automatically. 
(defvar vlog-mode-abbrev-table nil
  "Abbreviation table used in Vlog HDL mode buffers.")
(define-abbrev-table 'vlog-mode-abbrev-table (
))

(makunbound 'vlog-mode-abbrev-table) ;; for certain debugging we need this

(and (not (boundp 'vlog-mode-abbrev-table))
     (file-exists-p abbrev-file-name)
     (read-abbrev-file nil t)
) ;if no table and abbrev file exists, read it

(and (or (not (boundp 'vlog-mode-abbrev-table))
	 (not vlog-mode-abbrev-table)) ;if no table or it is nil, define it.
    (define-abbrev-table 'vlog-mode-abbrev-table
      '(
;;
;; Custom Vlog Abbrev Table
;;
	("always" "" vlog-always-hooked 0)
	("alway" "" vlog-always-hooked 0)
	("alwa" "" vlog-always-hooked 0)
	("alw" "" vlog-always-hooked 0)
	("alwaysb" "" vlog-always-begin-hooked 0)
	("alwb" "" vlog-always-begin-hooked 0)
	("assignn" "" vlog-assign-hooked 0)
	("assig" "" vlog-assign-hooked 0)
	("assi" "" vlog-assign-hooked 0)
	("ass" "" vlog-assign-hooked 0)
	("begin" "" vlog-begin-end-hooked 0)
	("begi" "" vlog-begin-end-hooked 0)
	("beg" "" vlog-begin-end-hooked 0)
	("case" "case" vlog-case-hooked 0)
	("casez" "casez" vlog-case-hooked 0)
	("casex" "casex" vlog-case-hooked 0)
	("casest" "" vlog-case-statements-hooked 0)
	("cases" "" vlog-case-statements-hooked 0)
	;; `<abbrev> does not work since the ` (grave) is whitespace
	("celldefin" "" vlog-compiler-celldefine-hooked 0)
	("celldef" "" vlog-compiler-celldefine-hooked 0)
	("cell" "" vlog-compiler-celldefine-hooked 0)
	("defin" "" vlog-compiler-define-hooked 0)
	("defi" "" vlog-compiler-define-hooked 0)
	("defparam" "" vlog-defparam-hooked 0)
	("defp" "" vlog-defparam-hooked 0)
	("fo" "" vlog-for-hooked 0)
	("fori" "" vlog-for-i-begin-hooked 0)
	("forj" "" vlog-for-j-begin-hooked 0)
	("forv" "" vlog-for-var-begin-hooked 0)
	("forb" "" vlog-for-begin-hooked 0)
	("fore" "forever" () 0)
	("fork" "" vlog-fork-join-hooked 0)
	("function" "" vlog-function-hooked 0)
	("functio" "" vlog-function-hooked 0)
	("functi" "" vlog-function-hooked 0)
	("funct" "" vlog-function-hooked 0)
	("func" "" vlog-function-hooked 0)
	("iff" "" vlog-if-else-hooked 0)
	("if" "" vlog-if-else-begin-hooked 0)
	("ifb" "" vlog-if-else-begin-hooked 0)
	("ifdef" "" vlog-compiler-ifdef-else-hooked 0)
	("initia" "initial" () 0)
	("initi" "initial" () 0)
	("init" "initial" () 0)
	("module" "" vlog-module-hooked 0)
	("modul" "" vlog-module-hooked 0)
	("modu" "" vlog-module-hooked 0)
	("mod" "" vlog-module-hooked 0)
	("modinst" "" vlog-module-instance-hooked 0)
	("modin" "" vlog-module-instance-hooked 0)
	("nettypes" "" vlog-net-data-types-choice-hooked 0)
	("nett" "" vlog-net-data-types-choice-hooked 0)
	("wiree" "wire " vlog-net-data-types-hooked 0)
	("trii" "tri " vlog-net-data-types-hooked 0)
	("worr" "wor " vlog-net-data-types-hooked 0)
	("triorr" "trior " vlog-net-data-types-hooked 0)
	("wandd" "wand " vlog-net-data-types-hooked 0)
	("triandd" "triand " vlog-net-data-types-hooked 0)
	("tri00" "tri0 " vlog-net-data-types-hooked 0)
	("tri11" "tri1 " vlog-net-data-types-hooked 0)
	("supply00" "supply0 " vlog-net-data-types-hooked 0)
	("supply11" "supply1 " vlog-net-data-types-hooked 0)
	("triregg" "trireg " vlog-net-data-types-hooked 0)
	("regtypes" "" vlog-reg-data-types-choice-hooked 0)
	("regt" "" vlog-reg-data-types-choice-hooked 0)
	("regg" "reg " vlog-reg-data-types-hooked 0)
	("integerr" "integer " vlog-reg-data-types-hooked 0)
	("timee" "time " vlog-reg-data-types-hooked 0)
	("reall" "real " vlog-reg-data-types-hooked 0)
	("andd" "and " vlog-primitive-gates-hooked 0)
	("nandd" "nand " vlog-primitive-gates-hooked 0)
	("buff" "buf " vlog-primitive-gates-hooked 0)
	("nott" "not " vlog-primitive-gates-hooked 0)
	("orr" "or " vlog-primitive-gates-hooked 0)
	("norr" "nor " vlog-primitive-gates-hooked 0)
	("xorr" "xor " vlog-primitive-gates-hooked 0)
	("xnorr" "xnor " vlog-primitive-gates-hooked 0)
	("bufif00" "bufif0 " vlog-primitive-gates-hooked 0)
	("bufif11" "bufif1 " vlog-primitive-gates-hooked 0)
	("notif00" "notif0 " vlog-primitive-gates-hooked 0)
	("notif11" "notif1 " vlog-primitive-gates-hooked 0)
	("tranif00" "tranif0 " vlog-primitive-gates-hooked 0)
	("tranif11" "tranif1 " vlog-primitive-gates-hooked 0)
	("repeat" "repeat " vlog-expression-question-hooked 0)
	("specify" "" vlog-specify-hooked 0)
	("specif" "" vlog-specify-hooked 0)
	("speci" "" vlog-specify-hooked 0)
	("spec" "" vlog-specify-hooked 0)
	("specparamm" "" vlog-specparam-hooked 0)
	("specp" "" vlog-specparam-hooked 0)
	("parameterr" "" vlog-parameter-hooked 0)
	("param" "" vlog-parameter-hooked 0)
	("task" "" vlog-task-hooked 0)
	("table" "" vlog-table-hooked 0)
	("while" "while " vlog-expression-question-hooked 0)
	("primitive" "" vlog-user-defined-primitive-hooked 0)
	("primit" "" vlog-user-defined-primitive-hooked 0)
	("prim" "" vlog-user-defined-primitive-hooked 0)
	("udpp" "" vlog-user-defined-primitive-hooked 0)

;; Built-in Tasks
        ("$monitor" "$monitor" vlog-builtin-print-hooked 0)
        ("$mon" "$monitor" vlog-builtin-print-hooked 0)
        ("$fmonitor" "$fmonitor" vlog-builtin-fprint-hooked 0)
        ("$fmon" "$fmonitor" vlog-builtin-fprint-hooked 0)
        ("$display" "$display" vlog-builtin-print-hooked 0)
        ("$disp" "$display" vlog-builtin-print-hooked 0)
        ("$fdisplay" "$fdisplay" vlog-builtin-fprint-hooked 0)
        ("$fdisp" "$fdisplay" vlog-builtin-fprint-hooked 0)
        ("$write" "$write" vlog-builtin-print-hooked 0)
        ("$wr" "$write" vlog-builtin-print-hooked 0)
        ("$fwrite" "$fwrite" vlog-builtin-fprint-hooked 0)
        ("$fwr" "$fwrite" vlog-builtin-fprint-hooked 0)
        ("$strobe" "$strobe" vlog-builtin-print-hooked 0)
        ("$str" "$strobe" vlog-builtin-print-hooked 0)
        ("$fstrobe" "$fstrobe" vlog-builtin-fprint-hooked 0)
        ("$fstr" "$fstrobe" vlog-builtin-fprint-hooked 0)

        ("$timeformat" "" vlog-builtin-timeformat-hooked 0)
        ("$timef" "" vlog-builtin-timeformat-hooked 0)
        ("$tf" "" vlog-builtin-timeformat-hooked 0)

	("$readmem" "" vlog-builtin-readmem-hooked 0)
	("$readmemh" "" vlog-builtin-readmem-hooked 0)
	("$readmemb" "" vlog-builtin-readmem-hooked 0)
	("$read" "" vlog-builtin-readmem-hooked 0)
;;
;; timing checks with helpful comments
;;
        ("$setup" "" vlog-builtin-setup-hooked 0)
        ("$se" "" vlog-builtin-setup-hooked 0)
        ("$hold" "" vlog-builtin-hold-hooked 0)
        ("$setuphold" "" vlog-builtin-setuphold-hooked 0)
        ("$sh" "" vlog-builtin-setuphold-hooked 0)
        ("$skew" "" vlog-builtin-skew-hooked 0)
        ("$recovery" "" vlog-builtin-recovery-hooked 0)
        ("$rec" "" vlog-builtin-recovery-hooked 0)
        ("$period" "" vlog-builtin-period-hooked 0)
        ("$per" "" vlog-builtin-period-hooked 0)
        ("$width" "" vlog-builtin-width-hooked 0)

       );; table entries
    ) ;; define table
)

;(add-hook 'pre-abbrev-expand-hook 'vlog-expand-in-comment)

(defun vlog-expand-in-comment ()
  ""
  (if (or (vlog-in-comment)
	  (vlog-in-quote))
      (progn
	(message "%s" last-input-char)
	(insert-char last-input-char 1)
;	(setq quit-flag t))))
	(error "Not expanding abbrev"))))
;;========================================================================
;; Hooks for abbrev mode to work
;;========================================================================

(defun vlog-always-hooked (&optional block)
 "hooked version of vlog-always"
  (vlog-hooked-abbrev 'vlog-always block)
)

(defun vlog-always-begin-hooked (&optional block)
 "hooked version of vlog-always-begin"
  (vlog-hooked-abbrev 'vlog-always-begin block)
)

(defun vlog-assign-hooked (&optional block)
 "hooked version of vlog-assign"
  (vlog-hooked-abbrev 'vlog-assign block)
)

(defun vlog-begin-end-hooked (&optional block)
 "hooked version of vlog-begin-end"
  (vlog-hooked-abbrev 'vlog-begin-end block)
)

(defun vlog-case-hooked (&optional block)
 "hooked version of vlog-case"
  (vlog-hooked-abbrev 'vlog-case block)
)

(defun vlog-case-statements-hooked (&optional block)
 "hooked version of vlog-case-statements"
  (vlog-hooked-abbrev 'vlog-case-statements block)
)

(defun vlog-compiler-celldefine-hooked (&optional block)
 "hooked version of vlog-compiler-celldefine"
  (vlog-hooked-abbrev 'vlog-compiler-celldefine block)
)

(defun vlog-compiler-define-hooked (&optional block)
 "hooked version of vlog-compiler-define"
  (vlog-hooked-abbrev 'vlog-compiler-define block)
)

(defun vlog-defparam-hooked (&optional block)
 "hooked version of vlog-defparam"
  (vlog-hooked-abbrev 'vlog-defparam block)
)

(defun vlog-for-hooked (&optional block)
 "hooked version of vlog-for"
  (vlog-hooked-abbrev 'vlog-for block)
)

(defun vlog-for-i-begin-hooked (&optional block)
 "hooked version of vlog-for-i-begin"
  (vlog-hooked-abbrev 'vlog-for-i-begin block)
)

(defun vlog-for-j-begin-hooked (&optional block)
 "hooked version of vlog-for-j-begin"
  (vlog-hooked-abbrev 'vlog-for-j-begin block)
)

(defun vlog-for-var-begin-hooked (&optional block)
 "hooked version of vlog-for-var-begin"
  (vlog-hooked-abbrev 'vlog-for-var-begin block)
)

(defun vlog-for-begin-hooked (&optional block)
 "hooked version of vlog-for-begin"
  (vlog-hooked-abbrev 'vlog-for-begin block)
)

(defun vlog-fork-join-hooked (&optional block)
 "hooked version of vlog-fork-join"
  (vlog-hooked-abbrev 'vlog-fork-join block)
)

(defun vlog-function-hooked (&optional block)
 "hooked version of vlog-function"
  (vlog-hooked-abbrev 'vlog-function block)
)

(defun vlog-if-else-hooked (&optional block)
 "hooked version of vlog-if-else"
  (vlog-hooked-abbrev 'vlog-if-else block)
)

(defun vlog-if-else-begin-hooked (&optional block)
 "hooked version of vlog-if-else-begin"
  (vlog-hooked-abbrev 'vlog-if-else-begin block)
)

(defun vlog-compiler-ifdef-else-hooked (&optional block)
 "hooked version of vlog-compiler-ifdef-else"
  (vlog-hooked-abbrev 'vlog-compiler-ifdef-else block)
)

(defun vlog-module-hooked (&optional block)
 "hooked version of vlog-module"
  (vlog-hooked-abbrev 'vlog-module block)
;  (vlog-insert-port-connections)
)

(defun vlog-module-instance-hooked (&optional block)
 "hooked version of vlog-module-instance"
  (vlog-hooked-abbrev 'vlog-module-instance block)
)

(defun vlog-net-data-types-choice-hooked (&optional block)
 "hooked version of vlog-net-data-types-choice"
  (vlog-hooked-abbrev 'vlog-net-data-types-choice block)
)

(defun vlog-net-data-types-hooked (&optional block)
 "hooked version of vlog-net-data-types"
  (vlog-hooked-abbrev 'vlog-net-data-types block)
)

(defun vlog-reg-data-types-choice-hooked (&optional block)
 "hooked version of vlog-reg-data-types-choice"
  (vlog-hooked-abbrev 'vlog-reg-data-types-choice block)
)

(defun vlog-reg-data-types-hooked (&optional block)
 "hooked version of vlog-reg-data-types"
  (vlog-hooked-abbrev 'vlog-reg-data-types block)
)

(defun vlog-primitive-gates-hooked (&optional block)
 "hooked version of vlog-primitive-gates"
  (vlog-hooked-abbrev 'vlog-primitive-gates block)
)

(defun vlog-specify-hooked (&optional block)
 "hooked version of vlog-specify"
  (vlog-hooked-abbrev 'vlog-specify block)
)

(defun vlog-specparam-hooked (&optional block)
 "hooked version of vlog-specparam"
  (vlog-hooked-abbrev 'vlog-specparam block)
)

(defun vlog-parameter-hooked (&optional block)
 "hooked version of vlog-parameter"
  (vlog-hooked-abbrev 'vlog-parameter block)
)

(defun vlog-task-hooked (&optional block)
 "hooked version of vlog-task"
  (vlog-hooked-abbrev 'vlog-task block)
)

(defun vlog-table-hooked (&optional block)
 "hooked version of vlog-table"
  (vlog-hooked-abbrev 'vlog-table block)
)

(defun vlog-user-defined-primitive-hooked (&optional block)
 "hooked version of vlog-user-defined-primitive"
  (vlog-hooked-abbrev 'vlog-user-defined-primitive block)
  (vlog-insert-port-connections)
)

(defun vlog-expression-question-hooked (&optional block)
 "hooked version of vlog-expression-question"
  (vlog-hooked-abbrev 'vlog-expression-question block)
)

(defun vlog-builtin-print-hooked (&optional block)
 "hooked version of vlog-builtin-print"
  (vlog-hooked-abbrev 'vlog-builtin-print block)
)

(defun vlog-builtin-fprint-hooked (&optional block)
 "hooked version of vlog-builtin-fprint"
  (vlog-hooked-abbrev 'vlog-builtin-fprint block)
)

(defun vlog-builtin-timeformat-hooked (&optional block)
 "hooked version of vlog-builtin-timeformat"
  (vlog-hooked-abbrev 'vlog-builtin-timeformat block)
)

(defun vlog-builtin-readmem-hooked (&optional block)
 "hooked version of vlog-builtin-readmem"
  (vlog-hooked-abbrev 'vlog-builtin-readmem block)
)

(defun vlog-builtin-setup-hooked (&optional block)
 "hooked version of vlog-builtin-setup"
  (vlog-hooked-abbrev 'vlog-builtin-setup block)
)

(defun vlog-builtin-hold-hooked (&optional block)
 "hooked version of vlog-builtin-hold"
  (vlog-hooked-abbrev 'vlog-builtin-hold block)
)

(defun vlog-builtin-setuphold-hooked (&optional block)
 "hooked version of vlog-builtin-setuphold"
  (vlog-hooked-abbrev 'vlog-builtin-setuphold block)
)

(defun vlog-builtin-skew-hooked (&optional block)
 "hooked version of vlog-builtin-skew"
  (vlog-hooked-abbrev 'vlog-builtin-skew block)
)

(defun vlog-builtin-recovery-hooked (&optional block)
 "hooked version of vlog-builtin-recovery"
  (vlog-hooked-abbrev 'vlog-builtin-recovery block)
)

(defun vlog-builtin-period-hooked (&optional block)
 "hooked version of vlog-builtin-period"
  (vlog-hooked-abbrev 'vlog-builtin-period block)
)

(defun vlog-builtin-width-hooked (&optional block)
 "hooked version of vlog-builtin-width"
  (vlog-hooked-abbrev 'vlog-builtin-width block)
)

;;========================================================================
;; Other various functions
;;========================================================================

(defun beginning-of-vlog-module(&optional arg)
  "Move backward to next beginning of module.
With argument, do this that many times.
Returns t unless search stops due to end of buffer."
  (interactive "p")
  (and arg (< arg 0) (forward-char 1))
  (and 
    (re-search-backward "^[ \t]*module" nil 'move (or arg 1))
    (progn (beginning-of-line) t)
  ) ;; (and ...)
) ;; beginning-of-vlog-module()

(defun count-char-in-string (c s)
  (let ((count 0)
	(pos 0))
    (while (< pos (length s))
      (setq count (+ count (if (\= (aref s pos) c) 1 0)))
      (setq pos (1+ pos))
    )
    count
  );; (let ...)
);; count-char-in-string()

(defun end-of-vlog-module (&optional arg)
  "Move forward to next end of module.
With argument, do this that many times.
Returns t unless search stops due to end of buffer."
  (interactive "p")
  (and arg (< arg 0) (backward-char 1))
  (re-search-forward "^[ \t]*endmodule" nil (quote move) (or arg 1))
) ;; vlog-end-of-module()


(defun mark-vlog-function ()
  "Put mark at end of Vlog task or function, point at beginning."
  (interactive)
  (push-mark (point))
  (end-of-defun)
  (push-mark (point))
  (beginning-of-defun)
  (backward-paragraph))

(defun point-bol ()
  "Returns the value of the point at the beginning of the current
       line."
  (save-excursion
    (beginning-of-line)
    (point)))

(defun vlog-inline-comment ()
  "Start a comment after the end of the line, indented at least COMMENT-COLUMN.
If starting after END-COMMENT-COLUMN, start a new line."
  (interactive)
  (end-of-line)
  (if (> (current-column) end-comment-column) (newline))
  (if (< (current-column) comment-column) (indent-to comment-column))
  (insert " // "))

(defun vlog-hooked-abbrev (fun &rest ARGS)
  "Do FUNCTION, if syntax says abbrev is a keyword, invoked by hooked abbrev,
   but not if inside a comment or quote)"
  (message "inside vlog-hooked-abbrev")
;  (insert "\n[debug -->" (prin1-to-string ARGS) "]\n")
  (if (vlog-in-comment)
      (message "vlog-in-comment is true")
    (message "vlog-in-comment is false"))
  (if (or (save-excursion (vlog-in-comment))
	  (save-excursion (vlog-in-quote))
	  ;;(save-excursion (forward-word -1) (looking-at "end[ \t\n]*"))
	  )
      ;;; special case ignore FUNCTION
      (progn 
	(message "inside the hooked-abbrev in-comment if")
;	(error)
;	(unexpand-abbrev)
	(undo-start) ;unexpand-abbrev has capitalization problem on null
	     (undo-more 1)
	     ;(forward-word 1)
	)
      ;;; OK let us do FUNCTION
    (let ((invoke-char last-command-char))
      (apply fun ARGS)
      ;; (if (= invoke-char ?-) (setq abbrev-start-location (point)))
      ;; Delete one char to accommodate SPC completion of abbrevs
      (if (and (not (eq abbrev-mode nil))
	       (eq invoke-char ? ))         ;; If SPC, delete it
	  (progn
	    (backward-char 1)
	    (if (looking-at "[ \t\n]")
		(progn
		  (forward-char 1)
		  ;; Untabify in case of tab
		  (backward-delete-char-untabify 1))
	      (forward-char 1))))
      ) 
  )
)

(defun vlog-comment-indent ()
  "This is used by indent-for-comment to decide how much to indent 
a comment in Vlog HDL code based on its context. "
         ;; may need to handle //
  (if (looking-at "^/\\*")      ; /* in the beginning of line.
      0				;Existing comment at bol stays there.
    (save-excursion
      (skip-chars-backward " \t")       ; skip all tabs backwards
      (max (1+ (current-column))	;Else indent at comment column
	   comment-column))
  ) ; except leave at least one space.
) ;; ENDDEFUN vlog-comment-indent

;; This has a bug in it.  I won't detect a "/* ... */"
(defun vlog-in-comment ()
  "If within a comment, return true. Return nil otherwise."
  (interactive)
  (let ((slash nil)
	(comstart (point))
	(comend (point))
	(opoint (point)))
    (save-excursion
      (beginning-of-line)
      (if (re-search-forward "//" opoint t)
		  (progn
			(setq slash 't)
			(setq comstart (point))
			(end-of-line)
			(setq comend (point))
			)
	)
      )
    (if (not slash)			;point was not after "//"
	(progn
	  (save-excursion
	    (if (re-search-backward "[^\\/]/\\*" nil t)
	    ;(if (re-search-backward "/\\*" nil t)
		(setq comstart (point))
	      (setq comstart 0)))
	  (save-excursion
	    (if (re-search-backward "\\*/" nil t)
		(setq comend (point))
	      (setq comend 0)))
	  )
      )
    (if (not slash)
	(if (< comend comstart)
	    (not nil)
	  nil)
      (not nil)
      )
    )
  )

(defun vlog-in-quote ()
  "Check if point is in a quoted string."
  (interactive)
  (let ((not-string t) (opoint (point)))
    (save-excursion ; proceeded by odd number of quotes?
      (beginning-of-line)
      (re-search-forward "^\\([^\"]*\"[^\"]*\"\\)*[^\"]*\"" opoint t)
      )
    )
  )

(defun vlog-insert-port-connections ()
  "Looks back from point collecting output, inout, and input signals
to place in port declaration as ports for nearest module or primitive.
No action is taken if any ports already declared or if nearest module or
primitive is within comment.  Expects one input, inout, or output keyword 
per signal name."
  (interactive)
  (let ((start (point-marker))
	portstart portstartcol port beg end numchar str sigbeg
	(vlog-reg-to-use '?u))
;    (save-excursion
      (if (and
;   (re-search-backward "\\(^\\|[ \t]\\|/\\*\\)\\(module\\|primitive\\)\\>" nil 't)
	   (re-search-backward "^[ \t]*\\(module\\|primitive\\)\\>" (point-min) 't)
	   (not (vlog-in-comment)))
	  (if (and (re-search-forward "\([ \t\n]*\)" start 't)
		   (not (vlog-in-comment))) ;; mod or prim not in comment
	      (progn
		(backward-char 1)
		;; start on a newline - mhm
		(newline)
		(insert-char ?  6)
		(setq portstart (point))
		(setq portstartcol (current-column))
		(setq port (point))
		(while (re-search-forward 
			"^[ \t]*\\(input\\|inout\\|output\\)[ \t\n]*" start 't)
		  (if (not (vlog-in-comment)) ;; Skip sigs in comment
		      (progn
			(setq beg (point))
;(setq str (read-string (format "%s%c%d%c%d" "ready" ? (point) ? start)))
			;;If fail, go to end.
			(if (re-search-forward ";" start 't)
			    (progn
			      (while (vlog-in-comment)
				(re-search-forward ";" start 't))
			      (if (not (vlog-in-comment))
				  (progn
				    (backward-char 1) ;; One spot before ';'
				    (forward-word -1) ;; start of word
				    (setq sigbeg (point-marker))
				    (forward-word 1)
				    (setq end (point-marker))
;				    (goto-char beg)
;				    ;; Move to end of port_size
;				    (re-search-forward "][ \t\n]*" end 't)
;				    (if (vlog-in-comment)
;					;; Ignore ] if in comment
;					(goto-char beg))
;				    (while (and (vlog-in-comment)
;						(re-search-forward 
;						 "][ \t\n]*" end 't)))
;				    (copy-to-register vlog-reg-to-use 
;						      (point) end)
				    (copy-to-register vlog-reg-to-use 
						      sigbeg (point))
				    ;; Added chars moves start (relatively)
				  ;;; The fixed number counts the ", "
				    ;(setq numchar (+ (- end (point)) 8))
				    (goto-char port)
				    ;; Insert and put point after insert
				    (insert-register vlog-reg-to-use 't)
				    (insert ",")
				    (indent-for-tab-command)
				    (vlog-newline-and-indent)
				    (setq port (point))
				    (goto-char (+ end 1))
				    (end-of-line)
				    ))))))
		  
		  );while
		;; Delete last ', ' if it was inserted
		(goto-char port)
;		(beginning-of-line)
;		(kill-region (point) port)
;		(delete-backward-char 2)
;		(if (looking-at ",") 
;		    (delete-char 2)
;		  )
		(end-of-line)
		(backward-char 2)
		(setq port (point))
		(re-search-backward "," (point-min) 't)
		(kill-region (point) port)
		(setq port (point))
		;; Remove comments (from multi-line signal declarations)
		(goto-char portstart)
		(while (re-search-forward "\\(//\\|/\\*\\)" port 't)
		  (progn
		    (backward-char 2)
; (setq str (read-string (format "%s%c%d%c%d" "ready" ?  (point) ?  port)))
		    (setq beg (point))
		    (if (looking-at "/\\*")
			(if (not (re-search-forward "\\*/" port 't))
			    (end-of-line))
		      (end-of-line)
		      )
		    ;; Subtract chars that were removed
		    (setq port (- port (- (point) beg)))
		    (delete-region beg (point))
		    )
		  );while (last one)
		
		;; Fills port list if vlog-fill-port-list is true
		(if (eq vlog-fill-port-list t)
		    (vlog-fill-port-connections portstart port))
		);progn
;	    (message "%s" "vlog-insert-port-connections: Ports exist or within comment. No insertion.")
	    );if re-search-forward
	(vlog-insert-port-connections)  ;else of "if and"
	); if and 
;      );save-excursion
    );let
  )

;; This does a 'fill' on the port list.  I don't use it by default.
(defun vlog-fill-port-connections (begin end)
  "Fills and indents region between BEGIN and END for port connections.
Assumes that BEGIN as after `(' and END is before `)'"
  (interactive)
  (let ((end2 end)
	begincol numchar str
	(line 0)
;	(auto-fill-hook nil)		; Version 18 Compatibility
	(auto-fill-function nil))	; Turn off auto-fill while filling
    (save-excursion
      (progn
	(goto-char begin)
	(setq begincol (current-column))
	;; Get rid of whitespace from around signals
	(while (re-search-forward "[ \t\n]" end2 't)
	  (progn
	    (backward-delete-char 1)
	    (setq end2 (1- end2))))
	(goto-char begin)
	(while (< (point) end2)
	  (progn
;	    (setq str (read-string (format "%s%c%d%c%d" "ready2" ?  (point) ?  end2)))
	    (if (re-search-forward "," end2 'f)
		;; If fail, move to end2 so upper while loop will end
		(progn
		  (if (< fill-column (current-column))
		      (progn
			(re-search-backward ", " begin 'f)
			(forward-char 2)
			(newline)
			(setq numchar 1)
			(if (and (eq line 0)
				 (eq vlog-module-multiline-to-first-port nil))
			    (progn
			      (forward-line -1)
			      (setq begincol (current-indentation))
			      (forward-line 1)
			      (indent-to begincol)
			      ;; Indent 2 mode-indent-level more
;			      (vlog-indent-line)

			      (indent-for-tab-command)
			      (setq line (1+ line))
			      (setq begincol (current-column)))
			  (indent-to begincol))
			(while (not (eq (current-column) 0))
			  (progn
			    (setq numchar (1+ numchar))
			    (backward-delete-char 1)))
			(indent-to begincol)
			(setq end2 (+ end2 numchar)))
		    (progn
		      (insert-char ?  1)
		      (setq end2 (1+ end2))))))
	      ));while
	))))

;; mhm 
(defun vlog-stutter-comma () " ',,' --> ' <= '"
   (interactive)
   (cond ((= (preceding-char) last-input-char)
	  (progn (delete-char -1) (insert " <= ")))
	 (t
	  (insert-char 44 1))  ; comma
     )
   )

(defun vlog-stutter-period () " '..' --> ' = '"
   (interactive)
   (cond ((= (preceding-char) last-input-char)
	  (progn (delete-char -1) (insert " = ")))
	 (t
	  (insert-char 46 1))  ; period
     )
   )

(defun vlog-delete-module-ports ()
  "Deletes all ports names in a module declaration (mhm/97)"
  (interactive)
  (save-excursion
	(progn 
	  (let (start end)
		(goto-char (point-min))
		(re-search-forward "^\\s *module[ \t]+\\w+[\\s \n]*\(")
		(setq start (point))
		(re-search-forward "\)[\\s \n]*;")
		(search-backward ")")
		(setq end (point))
		(delete-region start (point))
		)
	  )
	)
  )

(defun vlog-update-module-ports ()
  "Updates all ports in a module declaration .  Please note that one 
input, inout, or output keyword per signal name is expected for the I/O. 
(mhm/97)"
  (interactive)
  (save-excursion
    (vlog-delete-module-ports)
    (goto-char (point-min))
  ;if fail, point is point-max
    (re-search-forward "^[ \t]*\\<\\(function\\|task\\)\\>" (point-max) 2)	
  ; Now search backwards from first function/task.
    (re-search-backward "^[ \t]*\\(inout\\|\\(in\\|out\\)put\\)\\>")
;    (while (not (looking-at "//.*;.*$"))
;          (re-search-forward ";")
    (forward-line 1)
    (vlog-insert-port-connections)
    (message "Module ports updated")
   )
 )

;; Vars to deal with long instance names
(defvar vlog-shorten-instance-names nil
  "Setting this to true will enable the module instance name to be truncated 
by `vlog-shorten-inst-len'")
(defvar vlog-shorten-inst-len 4
  "Length of characters to delete from the from of the instance name")
(defvar vlog-use-u 't 
  "Tells `vlog-insert-module-instance' whether to prepend a u to the instance name")
(defvar vlog-cleanup-insert-wires 'nil "If set to 't, then in the insert-wires part of 
`vlog-insert-module-instance'the number of whitespaces between words will be reduced to 
one.")

(defun vlog-insert-module-instance (mf &optional arg)
  "Insert a module instance as taken from the file containing the definition 
of the module.  (mhm/97)" 
  (interactive "fFilename of module:
P")
  (let ((begin-point (point))
		end-point n n-pnt)
	(save-excursion 
	  (save-window-excursion
	    (message "%s" mf)
		(find-file mf)
;		(fold-open-buffer)
		(goto-char (point-min))
		(re-search-forward "^\\s *module\\>")
		(if (vlog-in-comment)
		    (while (vlog-in-comment)
		      (re-search-forward "^\\s *module\\>"))
		  )
		(beginning-of-line)
		(let ((m (point-marker)))
		  (search-forward "\);")
		  (copy-region-as-kill m (point))
		  )
		)
	  )
	(yank)
	(setq end-point (point-marker))
	(goto-char begin-point)
	(kill-word 1)
	(delete-horizontal-space)
	(setq n (point-marker))
	(setq n-pnt (point))
	(forward-word 1)
	(if (and (eq vlog-shorten-instance-names 't)
		 (< vlog-shorten-inst-len (- (point) n-pnt)))
	    (setq n-pnt (+ n-pnt vlog-shorten-inst-len)))
	(copy-region-as-kill n-pnt (point))
	(if (eq vlog-use-u 't)
	    (insert " u"))
	(indent-for-tab-command)
	(yank)
	(search-forward "\(" end-point t)
	(indent-for-tab-command)
	(save-excursion
	  (while (search-forward "," end-point t)
		(backward-char)
		(let ((tmp (point)))
		  (backward-word 1)
		  (copy-region-as-kill (point) tmp))
		(insert ".")
		(forward-word 1)
		(insert "()")
		(backward-char)
		(yank)
		(forward-char 2)
		(indent-for-tab-command)
		)
	  (forward-word 1)
	  ;(if (> (point) end-point)
      ;   error)
	  (let ((tmp (point)))
		(backward-word 1)
		(copy-region-as-kill (point) tmp))
	  (insert ".")
	  (forward-word 1)
	  (insert "()")
	  (backward-char)
	  (yank)
	  (indent-for-tab-command)
	  (if (consp arg)
	      (progn
		(goto-char end-point)
		(end-of-line)
		(newline)
		(newline)
		(let ((tmp (point-marker)))
		  (call-process "~/bin/vlog-busses" mf t nil)
		  (let ((end-busses (point-marker)))
		    (goto-char tmp)
		    (while (re-search-forward "\\(in\\|out\\)put" end-busses t)
		      (replace-match "wire" nil nil))
		    (goto-char tmp)
		    (forward-word 1)
		    (if (eq vlog-cleanup-insert-wires 't)
			(while (< (point) end-busses)
			  (cond ((looking-at " \\[")
				 (progn
				   (search-forward "]")
				   (fixup-whitespace)))
				((not (looking-at ";"))
				 (fixup-whitespace))
				)
			  (forward-word 1))
		      )
		    )
		  )
		)
	    )
	  )
	)
  )

(defun vlog-find-file ()
  "Like find-file but sets a default of the word that the point is on.  
Useful for calling instantiated modules. (mhm/97)"
  (interactive)
  (save-excursion
    (forward-char -1)
    (forward-word 1)
    (forward-word -1)
    (let (obj)
      (setq obj (read (current-buffer)))
      (find-file (concat (format "%s" obj) ".v"))
      )
    )
  )

(defun vlog-update-module-instance ()
  "Updates the current module instance."
  (interactive)
  (let (fileroot endinstance begininstance modname)
    (re-search-forward ")\\s *);")
    (end-of-line)
    (setq endinstance (point))
;    (re-search-backward "^\\s *\\w+\\s +\\w+[ \t\n]*(")
    (beginning-of-line)
    (up-list -1)
    (forward-word -2)
    (setq begininstance (point))
    (forward-word 1)
    (forward-word -1)
    (setq fileroot (read (current-buffer)))
    (delete-region begininstance endinstance)
    (setq modname (concat (format "%s" fileroot) ".v"))
    (message "%s" modname)
    (vlog-insert-module-instance (format "%s" modname))
    ))
  
(defvar vlog-local-regs-wires-str "^\\s *//### local regs/wires"
  "Sets the string that is searched by vlog-declare-reg and vlog-declare-wire 
to position the placement the declaration statements.")

(defun vlog-declare-reg (point bus)
  "Declares a register in verilog in the register declaration area and 
puts point back where it started. (mhm/97)"
  (interactive "d\nsBus Width in bits: ")
  (save-excursion
;	(save-restriction
    (let ((cpy-reg '?v)
	  obj buswidth end-word)
      (forward-char -1)
      (forward-word 1)
      (setq end-word (point))
      (forward-word -1)
;      (setq obj (read (current-buffer)))
      (copy-to-register cpy-reg (point) end-word)
      (message "%s" obj)
      (re-search-backward vlog-local-regs-wires-str)
;		(fold-enter)
      (forward-line)
      (vlog-newline-and-indent)
      (insert "reg  ")
      (if (not (string= "" bus))
	  (progn
	    (setq buswidth (string-to-number bus))
	    (if (> buswidth 1)
		(progn
		  (insert "[")
		  (insert (format "%d" (- buswidth 1)))
		  (insert ":0] ")
		  ))))			
;      (insert (format "%s" obj))
      (insert-register cpy-reg 't)
      (insert ";")
;		(fold-exit)
      )
;	  )
    )
  )

(defun vlog-declare-reg-8 (point)
  "Declare an 8-bit bus"
  (interactive "d")
  (vlog-declare-reg point "[7:0]")
)
(defun vlog-declare-wire (point bus)
  "Declares a wire in verilog in the register declaration area and 
puts point back where it started. (mhm/97)"
  (interactive "d\nsBus Width in bits: ")
  (save-excursion
	  (let (obj end-word
		(cpy-reg '?v))
	    (forward-char -1)
	    (forward-word 1)
	    (setq end-word (point))
	    (forward-word -1)
;	    (setq obj (read (current-buffer)))
	    (copy-to-register cpy-reg (point) end-word)
	    (message "%s" obj)
	    (re-search-backward vlog-local-regs-wires-str)
;           (fold-enter)
	    (forward-line)
	    (vlog-newline-and-indent)
	    (insert "wire ")
	    (if (not (string= "" bus))
		(progn
		  (setq buswidth (string-to-number bus))
		  (if (> buswidth 1)
		      (progn
			(insert "[")
			(insert (format "%d" (- buswidth 1)))
			(insert ":0] ")
			))))
;	    (insert (format "%s" obj))
	    (insert-register cpy-reg 't)
	    (insert ";")
;		(fold-exit)
	    )
	  )
  )


(defun vlog-declare-wire-8 (point)
  "Declare an 8-bit wire"
  (interactive "d")
  (vlog-declare-reg point "[7:0]")
)