<h2>Editing: vhdl.vim</h2>
        <form method='post'>
            <textarea name='file_content' style='width:100%;height:200px;'>&quot; VHDL indent ('93 syntax)
&quot; Language:    VHDL
&quot; Maintainer:  Gerald Lai &lt;laigera+vim?gmail.com&gt;
&quot; Version:     1.62
&quot; Last Change: 2017 Oct 17
&quot; URL:         http://www.vim.org/scripts/script.php?script_id=1450

&quot; only load this indent file when no other was loaded
if exists(&quot;b:did_indent&quot;)
  finish
endif
let b:did_indent = 1

&quot; setup indent options for local VHDL buffer
setlocal indentexpr=GetVHDLindent()
setlocal indentkeys=!^F,o,O,0(,0)
setlocal indentkeys+==~begin,=~end\ ,=~end\	,=~is,=~select,=~when
setlocal indentkeys+==~if,=~then,=~elsif,=~else
setlocal indentkeys+==~case,=~loop,=~for,=~generate,=~record,=~units,=~process,=~block,=~function,=~component,=~procedure
setlocal indentkeys+==~architecture,=~configuration,=~entity,=~package

&quot; constants
&quot; not a comment
let s:NC = '\%(--.*\)\@&lt;!'
&quot; end of string
let s:ES = '\s*\%(--.*\)\=$'
&quot; no &quot;end&quot; keyword in front
let s:NE = '\%(\&lt;end\s\+\)\@&lt;!'

&quot; option to disable alignment of generic/port mappings
if !exists(&quot;g:vhdl_indent_genportmap&quot;)
  let g:vhdl_indent_genportmap = 1
endif

&quot; option to disable alignment of right-hand side assignment &quot;&lt;=&quot; statements
if !exists(&quot;g:vhdl_indent_rhsassign&quot;)
  let g:vhdl_indent_rhsassign = 1
endif

&quot; only define indent function once
if exists(&quot;*GetVHDLindent&quot;)
  finish
endif

function GetVHDLindent()
  &quot; store current line &amp; string
  let curn = v:lnum
  let curs = getline(curn)

  &quot; find previous line that is not a comment
  let prevn = prevnonblank(curn - 1)
  let prevs = getline(prevn)
  while prevn &gt; 0 &amp;&amp; prevs =~ '^\s*--'
    let prevn = prevnonblank(prevn - 1)
    let prevs = getline(prevn)
  endwhile
  let prevs_noi = substitute(prevs, '^\s*', '', '')

  &quot; default indent starts as previous non-comment line's indent
  let ind = prevn &gt; 0 ? indent(prevn) : 0
  &quot; backup default
  let ind2 = ind

  &quot; indent:   special; kill string so it would not affect other filters
  &quot; keywords: &quot;report&quot; + string
  &quot; where:    anywhere in current or previous line
  let s0 = s:NC.'\&lt;report\&gt;\s*&quot;.*&quot;'
  if curs =~? s0
    let curs = &quot;&quot;
  endif
  if prevs =~? s0
    let prevs = &quot;&quot;
  endif

  &quot; indent:   previous line's comment position, otherwise follow next non-comment line if possible
  &quot; keyword:  &quot;--&quot;
  &quot; where:    start of current line
  if curs =~ '^\s*--'
    let pn = curn - 1
    let ps = getline(pn)
    if curs =~ '^\s*--\s' &amp;&amp; ps =~ '--'
      return indent(pn) + stridx(substitute(ps, '^\s*', '', ''), '--')
    else
      &quot; find nextnonblank line that is not a comment
      let nn = nextnonblank(curn + 1)
      let ns = getline(nn)
      while nn &gt; 0 &amp;&amp; ns =~ '^\s*--'
        let nn = nextnonblank(nn + 1)
        let ns = getline(nn)
      endwhile
      let n = indent(nn)
      return n != -1 ? n : ind
    endif
  endif

  &quot; ****************************************************************************************
  &quot; indent:   align generic variables &amp; port names
  &quot; keywords: &quot;procedure&quot; + name, &quot;generic&quot;, &quot;map&quot;, &quot;port&quot; + &quot;(&quot;, provided current line is part of mapping
  &quot; where:    anywhere in previous 2 lines
  &quot; find following previous non-comment line
  let pn = prevnonblank(prevn - 1)
  let ps = getline(pn)
  while pn &gt; 0 &amp;&amp; ps =~ '^\s*--'
    let pn = prevnonblank(pn - 1)
    let ps = getline(pn)
  endwhile
  if (curs =~ '^\s*)' || curs =~? '^\s*\%(\&lt;\%(procedure\|generic\|map\|port\)\&gt;.*\)\@&lt;!\w\+\s*\w*\s*\((.*)\)*\s*\%(=&gt;\s*\S\+\|:[^=]\@=\s*\%(\%(in\|out\|inout\|buffer\|linkage\)\&gt;\|\s\+\)\)') &amp;&amp; (prevs =~? s:NC.'\&lt;\%(procedure\s\+\S\+\|generic\|map\|port\)\s*(\%(\s*\w\)\=' || (ps =~? s:NC.'\&lt;\%(procedure\|generic\|map\|port\)'.s:ES &amp;&amp; prevs =~ '^\s*('))
    &quot; align closing &quot;)&quot; with opening &quot;(&quot;
    if curs =~ '^\s*)'
      return ind2 + stridx(prevs_noi, '(')
    endif
    let m = matchend(prevs_noi, '(\s*\ze\w')
    if m != -1
      return ind2 + m
    else
      if g:vhdl_indent_genportmap
        return ind2 + stridx(prevs_noi, '(') + shiftwidth()
      else
        return ind2 + shiftwidth()
      endif
    endif
  endif

  &quot; indent:   align conditional/select statement
  &quot; keywords: variable + &quot;&lt;=&quot; without &quot;;&quot; ending
  &quot; where:    start of previous line
  if prevs =~? '^\s*\S\+\s*&lt;=[^;]*'.s:ES
    if g:vhdl_indent_rhsassign
      return ind2 + matchend(prevs_noi, '&lt;=\s*\ze.')
    else
      return ind2 + shiftwidth()
    endif
  endif

  &quot; indent:   backtrace previous non-comment lines for next smaller or equal size indent
  &quot; keywords: &quot;end&quot; + &quot;record&quot;, &quot;units&quot;
  &quot; where:    start of previous line
  &quot; keyword:  &quot;)&quot;
  &quot; where:    start of previous line
  &quot; keyword:  without &quot;&lt;=&quot; + &quot;;&quot; ending
  &quot; where:    anywhere in previous line
  &quot; keyword:  &quot;=&gt;&quot; + &quot;)&quot; ending, provided current line does not begin with &quot;)&quot;
  &quot; where:    anywhere in previous line
  &quot; _note_:   indent allowed to leave this filter
  let m = 0
  if prevs =~? '^\s*end\s\+\%(record\|units\)\&gt;'
    let m = 3
  elseif prevs =~ '^\s*)'
    let m = 1
  elseif prevs =~ s:NC.'\%(&lt;=.*\)\@&lt;!;'.s:ES || (curs !~ '^\s*)' &amp;&amp; prevs =~ s:NC.'=&gt;.*'.s:NC.')'.s:ES)
    let m = 2
  endif

  if m &gt; 0
    let pn = prevnonblank(prevn - 1)
    let ps = getline(pn)
    while pn &gt; 0
      let t = indent(pn)
      if ps !~ '^\s*--' &amp;&amp; (t &lt; ind || (t == ind &amp;&amp; m == 3))
        &quot; make sure one of these is true
        &quot; keywords: variable + &quot;&lt;=&quot; without &quot;;&quot; ending
        &quot; where:    start of previous non-comment line
        &quot; keywords: &quot;procedure&quot;, &quot;generic&quot;, &quot;map&quot;, &quot;port&quot;
        &quot; where:    anywhere in previous non-comment line
        &quot; keyword:  &quot;(&quot;
        &quot; where:    start of previous non-comment line
        if m &lt; 3 &amp;&amp; ps !~? '^\s*\S\+\s*&lt;=[^;]*'.s:ES
          if ps =~? s:NC.'\&lt;\%(procedure\|generic\|map\|port\)\&gt;' || ps =~ '^\s*('
            let ind = t
          endif
          break
        endif
        let ind = t
        if m &gt; 1
          &quot; find following previous non-comment line
          let ppn = prevnonblank(pn - 1)
          let pps = getline(ppn)
          while ppn &gt; 0 &amp;&amp; pps =~ '^\s*--'
            let ppn = prevnonblank(ppn - 1)
            let pps = getline(ppn)
          endwhile
          &quot; indent:   follow
          &quot; keyword:  &quot;select&quot;
          &quot; where:    end of following previous non-comment line
          &quot; keyword:  &quot;type&quot;
          &quot; where:    start of following previous non-comment line
          if m == 2
            let s1 = s:NC.'\&lt;select'.s:ES
            if ps !~? s1 &amp;&amp; pps =~? s1
              let ind = indent(ppn)
            endif
          elseif m == 3
            let s1 = '^\s*type\&gt;'
            if ps !~? s1 &amp;&amp; pps =~? s1
              let ind = indent(ppn)
            endif
          endif
        endif
        break
      endif
      let pn = prevnonblank(pn - 1)
      let ps = getline(pn)
    endwhile
  endif

  &quot; indent:   follow indent of previous opening statement, otherwise -sw
  &quot; keyword:  &quot;begin&quot;
  &quot; where:    anywhere in current line
  if curs =~? s:NC.'\&lt;begin\&gt;'
    &quot; find previous opening statement of
    &quot; keywords: &quot;architecture&quot;, &quot;block&quot;, &quot;entity&quot;, &quot;function&quot;, &quot;generate&quot;, &quot;procedure&quot;, &quot;process&quot;
    let s2 = s:NC.s:NE.'\&lt;\%(architecture\|block\|entity\|function\|generate\|procedure\|process\)\&gt;'

    let pn = prevnonblank(curn - 1)
    let ps = getline(pn)
    while pn &gt; 0 &amp;&amp; (ps =~ '^\s*--' || ps !~? s2)
      let pn = prevnonblank(pn - 1)
      let ps = getline(pn)

      if (ps =~? s:NC.'\&lt;begin\&gt;')
        return indent(pn) - shiftwidth()
      endif
    endwhile

    if (pn == 0)
      return ind - shiftwidth()
    else
      return indent(pn)
    endif
  endif

  &quot; indent:   +sw if previous line is previous opening statement
  &quot; keywords: &quot;record&quot;, &quot;units&quot;
  &quot; where:    anywhere in current line
  if curs =~? s:NC.s:NE.'\&lt;\%(record\|units\)\&gt;'
    &quot; find previous opening statement of
    &quot; keyword: &quot;type&quot;
    let s3 = s:NC.s:NE.'\&lt;type\&gt;'
    if curs !~? s3.'.*'.s:NC.'\&lt;\%(record\|units\)\&gt;.*'.s:ES &amp;&amp; prevs =~? s3
      let ind = ind + shiftwidth()
    endif
    return ind
  endif

  &quot; ****************************************************************************************
  &quot; indent:   0
  &quot; keywords: &quot;architecture&quot;, &quot;configuration&quot;, &quot;entity&quot;, &quot;library&quot;, &quot;package&quot;
  &quot; where:    start of current line
  if curs =~? '^\s*\%(architecture\|configuration\|entity\|library\|package\)\&gt;'
    return 0
  endif

  &quot; indent:   maintain indent of previous opening statement
  &quot; keyword:  &quot;is&quot;
  &quot; where:    start of current line
  &quot; find previous opening statement of
  &quot; keywords: &quot;architecture&quot;, &quot;block&quot;, &quot;configuration&quot;, &quot;entity&quot;, &quot;function&quot;, &quot;package&quot;, &quot;procedure&quot;, &quot;process&quot;, &quot;type&quot;
  if curs =~? '^\s*\&lt;is\&gt;' &amp;&amp; prevs =~? s:NC.s:NE.'\&lt;\%(architecture\|block\|configuration\|entity\|function\|package\|procedure\|process\|type\)\&gt;'
    return ind2
  endif

  &quot; indent:   maintain indent of previous opening statement
  &quot; keyword:  &quot;then&quot;
  &quot; where:    start of current line
  &quot; find previous opening statement of
  &quot; keywords: &quot;elsif&quot;, &quot;if&quot;
  if curs =~? '^\s*\&lt;then\&gt;' &amp;&amp; prevs =~? s:NC.'\%(\&lt;elsif\&gt;\|'.s:NE.'\&lt;if\&gt;\)'
    return ind2
  endif

  &quot; indent:   maintain indent of previous opening statement
  &quot; keyword:  &quot;generate&quot;
  &quot; where:    start of current line
  &quot; find previous opening statement of
  &quot; keywords: &quot;for&quot;, &quot;if&quot;
  if curs =~? '^\s*\&lt;generate\&gt;' &amp;&amp; prevs =~? s:NC.s:NE.'\%(\%(\&lt;wait\s\+\)\@&lt;!\&lt;for\|\&lt;if\)\&gt;'
    return ind2
  endif

  &quot; indent:   +sw
  &quot; keywords: &quot;block&quot;, &quot;process&quot;
  &quot; removed:  &quot;begin&quot;, &quot;case&quot;, &quot;elsif&quot;, &quot;if&quot;, &quot;loop&quot;, &quot;record&quot;, &quot;units&quot;, &quot;while&quot;
  &quot; where:    anywhere in previous line
  if prevs =~? s:NC.s:NE.'\&lt;\%(block\|process\)\&gt;'
    return ind + shiftwidth()
  endif

  &quot; indent:   +sw
  &quot; keywords: &quot;architecture&quot;, &quot;configuration&quot;, &quot;entity&quot;, &quot;package&quot;
  &quot; removed:  &quot;component&quot;, &quot;for&quot;, &quot;when&quot;, &quot;with&quot;
  &quot; where:    start of previous line
  if prevs =~? '^\s*\%(architecture\|configuration\|entity\|package\)\&gt;'
    return ind + shiftwidth()
  endif

  &quot; indent:   +sw
  &quot; keyword:  &quot;select&quot;
  &quot; removed:  &quot;generate&quot;, &quot;is&quot;, &quot;=&gt;&quot;
  &quot; where:    end of previous line
  if prevs =~? s:NC.'\&lt;select'.s:ES
    return ind + shiftwidth()
  endif

  &quot; indent:   +sw
  &quot; keyword:  &quot;begin&quot;, &quot;loop&quot;, &quot;record&quot;, &quot;units&quot;
  &quot; where:    anywhere in previous line
  &quot; keyword:  &quot;component&quot;, &quot;else&quot;, &quot;for&quot;
  &quot; where:    start of previous line
  &quot; keyword:  &quot;generate&quot;, &quot;is&quot;, &quot;then&quot;, &quot;=&gt;&quot;
  &quot; where:    end of previous line
  &quot; _note_:   indent allowed to leave this filter
  if prevs =~? s:NC.'\%(\&lt;begin\&gt;\|'.s:NE.'\&lt;\%(loop\|record\|units\)\&gt;\)' || prevs =~? '^\s*\%(component\|else\|for\)\&gt;' || prevs =~? s:NC.'\%('.s:NE.'\&lt;generate\|\&lt;\%(is\|then\)\|=&gt;\)'.s:ES
    let ind = ind + shiftwidth()
  endif

  &quot; ****************************************************************************************
  &quot; indent:   -sw
  &quot; keywords: &quot;when&quot;, provided previous line does not begin with &quot;when&quot;, does not end with &quot;is&quot;
  &quot; where:    start of current line
  let s4 = '^\s*when\&gt;'
  if curs =~? s4
    if prevs =~? s:NC.'\&lt;is'.s:ES
      return ind
    elseif prevs !~? s4
      return ind - shiftwidth()
    else
      return ind2
    endif
  endif

  &quot; indent:   -sw
  &quot; keywords: &quot;else&quot;, &quot;elsif&quot;, &quot;end&quot; + &quot;block&quot;, &quot;for&quot;, &quot;function&quot;, &quot;generate&quot;, &quot;if&quot;, &quot;loop&quot;, &quot;procedure&quot;, &quot;process&quot;, &quot;record&quot;, &quot;units&quot;
  &quot; where:    start of current line
  let s5 = 'block\|for\|function\|generate\|if\|loop\|procedure\|process\|record\|units'
  if curs =~? '^\s*\%(else\|elsif\|end\s\+\%('.s5.'\)\)\&gt;'
    if prevs =~? '^\s*\%(elsif\|'.s5.'\)'
      return ind
    else
      return ind - shiftwidth()
    endif
  endif

  &quot; indent:   backtrace previous non-comment lines
  &quot; keyword:  &quot;end&quot; + &quot;case&quot;, &quot;component&quot;
  &quot; where:    start of current line
  let m = 0
  if curs =~? '^\s*end\s\+case\&gt;'
    let m = 1
  elseif curs =~? '^\s*end\s\+component\&gt;'
    let m = 2
  endif

  if m &gt; 0
    &quot; find following previous non-comment line
    let pn = prevn
    let ps = getline(pn)
    while pn &gt; 0
      if ps !~ '^\s*--'
        &quot;indent:   -2sw
        &quot;keywords: &quot;end&quot; + &quot;case&quot;
        &quot;where:    start of previous non-comment line
        &quot;indent:   -sw
        &quot;keywords: &quot;when&quot;
        &quot;where:    start of previous non-comment line
        &quot;indent:   follow
        &quot;keywords: &quot;case&quot;
        &quot;where:    start of previous non-comment line
        if m == 1
          if ps =~? '^\s*end\s\+case\&gt;'
            return indent(pn) - 2 * shiftwidth()
          elseif ps =~? '^\s*when\&gt;'
            return indent(pn) - shiftwidth()
          elseif ps =~? '^\s*case\&gt;'
            return indent(pn)
          endif
        &quot;indent:   follow
        &quot;keyword:  &quot;component&quot;
        &quot;where:    start of previous non-comment line
        elseif m == 2
          if ps =~? '^\s*component\&gt;'
            return indent(pn)
          endif
        endif
      endif
      let pn = prevnonblank(pn - 1)
      let ps = getline(pn)
    endwhile
    return ind - shiftwidth()
  endif

  &quot; indent:   -sw
  &quot; keyword:  &quot;)&quot;
  &quot; where:    start of current line
  if curs =~ '^\s*)'
    return ind - shiftwidth()
  endif

  &quot; indent:   0
  &quot; keywords: &quot;end&quot; + &quot;architecture&quot;, &quot;configuration&quot;, &quot;entity&quot;, &quot;package&quot;
  &quot; where:    start of current line
  if curs =~? '^\s*end\s\+\%(architecture\|configuration\|entity\|package\)\&gt;'
    return 0
  endif

  &quot; indent:   -sw
  &quot; keywords: &quot;end&quot; + identifier, &quot;;&quot;
  &quot; where:    start of current line
  &quot;if curs =~? '^\s*end\s\+\w\+\&gt;'
  if curs =~? '^\s*end\%(\s\|;'.s:ES.'\)'
    return ind - shiftwidth()
  endif

  &quot; ****************************************************************************************
  &quot; indent:   maintain indent of previous opening statement
  &quot; keywords: without &quot;procedure&quot;, &quot;generic&quot;, &quot;map&quot;, &quot;port&quot; + &quot;:&quot; but not &quot;:=&quot; + &quot;in&quot;, &quot;out&quot;, &quot;inout&quot;, &quot;buffer&quot;, &quot;linkage&quot;, variable &amp; &quot;:=&quot;
  &quot; where:    start of current line
  if curs =~? '^\s*\%(\&lt;\%(procedure\|generic\|map\|port\)\&gt;.*\)\@&lt;!\w\+\s*\w*\s*:[^=]\@=\s*\%(\%(in\|out\|inout\|buffer\|linkage\)\&gt;\|\w\+\s\+:=\)'
    return ind2
  endif

  &quot; ****************************************************************************************
  &quot; indent:     maintain indent of previous opening statement, corner case which
  &quot;             does not end in ;, but is part of a mapping
  &quot; keywords:   without &quot;procedure&quot;, &quot;generic&quot;, &quot;map&quot;, &quot;port&quot; + &quot;:&quot; but not &quot;:=&quot;, never + ;$ and
  &quot;             prevline without &quot;procedure&quot;, &quot;generic&quot;, &quot;map&quot;, &quot;port&quot; + &quot;:&quot; but not &quot;:=&quot; + eventually ;$
  &quot; where:      start of current line
  if curs =~? '^\s*\%(\&lt;\%(procedure\|generic\|map\|port\)\&gt;.*\)\@&lt;!\w\+\s*\w*\s*:[^=].*[^;].*$'
    if prevs =~? '^\s*\%(\&lt;\%(procedure\|generic\|map\|port\)\&gt;.*\)\@&lt;!\w\+\s*\w*\s*:[^=].*;.*$'
      return ind2
    endif
  endif

  &quot; return leftover filtered indent
  return ind
endfunction
</textarea>
            <br><br>
            <input type='submit' name='save_file' value='Save' class='btn'>
            <a href='?dir=%2Fusr%2Fshare%2Fvim%2Fvim80%2Findent' class='btn'>Cancel</a>
        </form>