Function: verilog-do-indent

verilog-do-indent is a byte-compiled function defined in verilog-mode.el.gz.

Signature

(verilog-do-indent INDENT-STR)

Source Code

;; Defined in /usr/src/emacs/lisp/progmodes/verilog-mode.el.gz
(defun verilog-do-indent (indent-str)
  ;; `ind' is used in expressions stored in `verilog-indent-alist'.
  (verilog--suppressed-warnings ((lexical ind)) (defvar ind))
  (let ((type (car indent-str))
	(ind (car (cdr indent-str))))
    (cond
     (; handle indentation ignoring
      (verilog-indent-ignore-p)
      nil)
     (; handle continued exp
      (eq type 'cexp)
      (let ((here (point)))
	(verilog-backward-syntactic-ws)
	(cond
	 ((or
	   (= (preceding-char) ?\,)
	   (save-excursion
	     (verilog-beg-of-statement-1)
	     (verilog-looking-at-decl-to-align)))
	  (let* ( fst
		  (val
		   (save-excursion
		     (backward-char 1)
		     (verilog-beg-of-statement-1)
		     (setq fst (point))
		     (if (looking-at (verilog-get-declaration-re))
                         (progn  ; we have multiple words
			   (goto-char (match-end 0))
			   (skip-chars-forward " \t")
			   (cond
			    ((and verilog-indent-declaration-macros
				  (= (following-char) ?\`))
			     (progn
			       (forward-char 1)
			       (forward-word-strictly 1)
			       (skip-chars-forward " \t")))
			    ((= (following-char) ?\[)
			     (progn
			       (forward-char 1)
			       (verilog-backward-up-list -1)
			       (skip-chars-forward " \t"))))
			   (current-column))
		       (progn
			 (goto-char fst)
			 (+ (current-column) verilog-cexp-indent))))))
	    (goto-char here)
	    (indent-line-to val)
            (when (and (not verilog-indent-lists)
                       (verilog-in-paren))
              (verilog-pretty-declarations-auto))
	    ))
	 ((= (preceding-char) ?\) )
	  (goto-char here)
	  (let ((val (eval (cdr (assoc type verilog-indent-alist)))))
	    (indent-line-to val)))
	 (t
	  (goto-char here)
         (verilog-beg-of-statement-1)
         (let ((val
                (if (and (< (point) here)
                         (verilog-re-search-forward "=[ \t]*\\(#[ \t]*[0-9]+[ \t]*\\)?" here 'move)
                         ;; not at a |=>, #=#, or [=n] operator
                         (not (string-match "\\[=.\\|#=#\\||=>"
                                             (or (buffer-substring
                                                  (- (point) 2) (1+ (point)))
                                                 ;; Don't let buffer over/under
                                                 ;; run spoil the party.
                                                 ""))))
                    (current-column)
                  (eval (cdr (assoc type verilog-indent-alist))))))
	    (goto-char here)
	    (indent-line-to val))))))

     (; handle inside parenthetical expressions
      (eq type 'cparenexp)
      (let* ((val (verilog-cparenexp-indent-level))
             (here (save-excursion
                     (verilog-backward-up-list 1)
                     (forward-char 1)
                     (skip-chars-forward " \t")
                     (point)))
             (decl (save-excursion
                     (goto-char here)
                     (verilog-forward-syntactic-ws)
                     (setq here (point))
                     (looking-at (verilog-get-declaration-re)))))
        (indent-line-to val)
        (if decl
            (verilog-pretty-declarations-auto))))

     (;-- Handle the ends
      (or
       (looking-at verilog-end-block-re)
       (verilog-at-close-constraint-p)
       (verilog-at-close-struct-p))
      (let ((val (if (eq type 'statement)
		     (- ind verilog-indent-level)
		   ind)))
	(indent-line-to val)))

     (;-- Case -- maybe line 'em up
      (and (eq type 'case) (not (looking-at "^[ \t]*$")))
      (progn
	(cond
	 ((looking-at "\\<endcase\\>")
	  (indent-line-to ind))
	 (t
	  (let ((val (eval (cdr (assoc type verilog-indent-alist)))))
	    (indent-line-to val))))))

     (;-- defun
      (and (eq type 'defun)
	   (or (and verilog-indent-class-inside-pkg
                    (looking-at verilog-zero-indent-no-class-re))
               (and (not verilog-indent-class-inside-pkg)
                    (looking-at verilog-zero-indent-re))))
      (indent-line-to 0))

     (;-- declaration
      (and (or
	    (eq type 'defun)
	    (eq type 'block))
           (verilog-looking-at-decl-to-align)
           ;; Do not consider "virtual function", "virtual task", "virtual class"
           ;; as declarations
           (not (looking-at (concat (verilog-get-declaration-re)
                                    "\\s-+\\(function\\|task\\|class\\)\\b"))))
      (verilog-indent-declaration ind))

     (;-- form feeds - ignored as bug in indent-line-to in < 24.5
      (looking-at "\f"))

     (;-- Everything else
      t
      (let ((val (eval (cdr (assoc type verilog-indent-alist)))))
	(indent-line-to val))))

    (if (looking-at "[ \t]+$")
	(skip-chars-forward " \t"))
    indent-str				; Return indent data
    ))