Function: verilog-pretty-declarations

verilog-pretty-declarations is an interactive and byte-compiled function defined in verilog-mode.el.gz.

Signature

(verilog-pretty-declarations &optional QUIET)

Documentation

Line up declarations around point.

Be verbose about progress unless optional QUIET set.

Key Bindings

Source Code

;; Defined in /usr/src/emacs/lisp/progmodes/verilog-mode.el.gz
(defun verilog-pretty-declarations (&optional quiet)
  "Line up declarations around point.
Be verbose about progress unless optional QUIET set."
  (interactive)
  (let ((m1 (make-marker))
        (e (point))
	(here (point))
	el r ind start startpos end endpos base-ind rstart rend)
    (save-excursion
      (when (region-active-p)
        (setq rstart (region-beginning))
        (setq rend (region-end))
        (goto-char rstart)) ; Shrinks the region but ensures that start is a valid declaration
      (if (progn
            ;; Check if alignment can be performed
            (beginning-of-line)
            (verilog-forward-syntactic-ws)
            (or (and (not (verilog-in-directive-p))  ; could have `define input foo
                     (verilog-looking-at-decl-to-align))
                (and (verilog-parenthesis-depth)
                     (looking-at verilog-interface-modport-re))))
          ;; Find boundaries of alignment
          (progn
            (cond (;; Using region
                   (region-active-p)
                   (setq start rstart
                         startpos (set-marker (make-marker) start)
                         end (progn (goto-char start)
                                    (verilog--pretty-declarations-find-end rend))
                         endpos (set-marker (make-marker) end)
                         base-ind (progn (goto-char start)
                                         (verilog--pretty-declarations-find-base-ind))))
                  (;; In an argument list or parameter block
                   (and (verilog-parenthesis-depth)
                        (not (verilog-in-struct-p)))
                   (setq el (verilog-backward-up-list -1)
                         start (progn
                                 (goto-char e)
                                 (verilog-backward-up-list 1)
                                 (verilog-re-search-forward (verilog-get-declaration-re 'iface-mp) el 'move)
                                 (goto-char (match-beginning 0))
                                 (skip-chars-backward " \t")
                                 (point))
                         startpos (set-marker (make-marker) start)
                         end (progn (goto-char start)
                                    (verilog--pretty-declarations-find-end))
                         endpos (set-marker (make-marker) end)
                         base-ind (progn (goto-char start)
                                         (verilog--pretty-declarations-find-base-ind))))
                  (;; In a declaration block (not in argument list)
                   t
                   (setq
                    start (progn
                            (verilog-beg-of-statement-1)
                            (while (and (verilog-looking-at-decl-to-align)
                                        (not (bobp)))
			      (skip-chars-backward " \t")
			      (setq e (point))
			      (verilog-backward-syntactic-ws)
			      (backward-char)
			      (verilog-beg-of-statement-1))
                            e)
                    startpos (set-marker (make-marker) start)
                    end (progn (goto-char here)
                               (verilog--pretty-declarations-find-end))
                    endpos (set-marker (make-marker) end)
                    base-ind (progn (goto-char start)
                                    (verilog--pretty-declarations-find-base-ind)))))
	    ;; OK, start and end are set
	    (goto-char (marker-position startpos))
	    (if (and (not quiet)
		     (> (- end start) 100))
		(message "Lining up declarations..(please stand by)"))
	    ;; Get the beginning of line indent first
	    (while (progn (setq e (marker-position endpos))
			  (< (point) e))
	      (cond
	       ((save-excursion (skip-chars-backward " \t")
				(bolp))
                (verilog-forward-ws&directives)
                (indent-line-to base-ind)
                (verilog-forward-ws&directives)
                (if (< (point) e)
                    (verilog-re-search-forward "[ \t\n\f]" (marker-position endpos) 'move)))
	       (t
                (unless (verilog-looking-back "(" (point-at-bol))
                  (just-one-space))
                (if (looking-at verilog-comment-start-regexp)
                    (verilog-forward-syntactic-ws)
		  (verilog-re-search-forward "[ \t\n\f]" e 'move)))))
	    ;; Now find biggest prefix
	    (setq ind (verilog-get-lineup-indent (marker-position startpos) endpos))
	    ;; Now indent each line.
	    (goto-char (marker-position startpos))
	    (while (progn (setq e (marker-position endpos))
			  (setq r (- e (point)))
			  (> r 0))
	      (setq e (point))
	      (unless quiet (message "%d" r))
	      (verilog-forward-ws&directives)
	      (cond
	       ((looking-at (verilog-get-declaration-re 'iface-mp))
                (unless (looking-at (verilog-get-declaration-re 'embedded-comments))
                  (let ((p (match-end 0)))
                    (set-marker m1 p)
                    (if (verilog-re-search-forward "[[#`]" p 'move)
                        (progn
                          (forward-char -1)
                          (just-one-space)
                          (goto-char (marker-position m1))
                          (delete-horizontal-space)
                          (indent-to ind 1))
                      (progn
                        (delete-horizontal-space)
                        (indent-to ind 1))))))
	       ((verilog-continued-line-1 (marker-position startpos))
		(goto-char e)
                (unless (and (verilog-in-parenthesis-p)
                             (looking-at (concat "\\s-*" verilog-identifier-sym-re "\\s-+" verilog-identifier-sym-re "\\s-*")))
                  (indent-line-to ind)))
	       ((verilog-in-struct-p)
		;; could have a declaration of a user defined item
		(goto-char e)
		(verilog-end-of-statement))
	       (t		; Must be comment or white space
		(goto-char e)
		(verilog-forward-ws&directives)
		(forward-line -1)))
	      (forward-line 1))
            ;; Align comments if enabled
            (when verilog-align-decl-expr-comments
              (verilog-align-comments startpos endpos)))
        ;; Exit
	(unless quiet (message ""))))))