runtime/indent/ada.vim - third_party/vim - Git at Google

 " Vim indent file
 " Language:	Ada
 " Maintainer:	Neil Bird <neil@fnxweb.com>
 " Last Change:	2004 Nov 23
 " Version:	$Id$
 " Look for the latest version at http://vim.sourceforge.net/
 "
 " ToDo:
 "  Verify handling of multi-line exprs. and recovery upon the final ';'.
 "  Correctly find comments given '"' and "" ==> " syntax.
 "  Combine the two large block-indent functions into one?

 " Only load this indent file when no other was loaded.
 if exists("b:did_indent")
    finish
 endif
 let b:did_indent = 1

 setlocal indentexpr=GetAdaIndent()
 setlocal indentkeys-=0{,0}
 setlocal indentkeys+=0=~then,0=~end,0=~elsif,0=~when,0=~exception,0=~begin,0=~is,0=~record

 " Only define the functions once.
 if exists("*GetAdaIndent")
    finish
 endif

 let s:AdaBlockStart = '^\s*\(if\>\|while\>\|else\>\|elsif\>\|loop\>\|for\>.*\<\(loop\|use\)\>\|declare\>\|begin\>\|type\>.*\<is\>[^;]*$\|\(type\>.*\)\=\<record\>\|procedure\>\|function\>\|accept\>\|do\>\|task\>\|package\>\|then\>\|when\>\|is\>\)'
 let s:AdaComment = "\\v^(\"[^\"]*\"|'.'|[^\"']){-}\\zs\\s*--.*"


 " Try to find indent of the block we're in
 " prev_indent = the previous line's indent
 " prev_lnum   = previous line (to start looking on)
 " blockstart  = expr. that indicates a possible start of this block
 " stop_at     = if non-null, if a matching line is found, gives up!
 " No recursive previous block analysis: simply look for a valid line
 " with a lesser or equal indent than we currently (on prev_lnum) have.
 " This shouldn't work as well as it appears to with lines that are currently
 " nowhere near the correct indent (e.g., start of line)!
 " Seems to work OK as it 'starts' with the indent of the /previous/ line.
 function s:MainBlockIndent( prev_indent, prev_lnum, blockstart, stop_at )
    let lnum = a:prev_lnum
    let line = substitute( getline(lnum), s:AdaComment, '', '' )
    while lnum > 1
       if a:stop_at != ''  &&  line =~ '^\s*' . a:stop_at  &&  indent(lnum) < a:prev_indent
          return a:prev_indent
       elseif line =~ '^\s*' . a:blockstart
          let ind = indent(lnum)
          if ind < a:prev_indent
             return ind
          endif
       endif

       let lnum = prevnonblank(lnum - 1)
       " Get previous non-blank/non-comment-only line
       while 1
          let line = substitute( getline(lnum), s:AdaComment, '', '' )
          if line !~ '^\s*$' && line !~ '^\s*#'
             break
          endif
          let lnum = prevnonblank(lnum - 1)
          if lnum <= 0
             return a:prev_indent
          endif
       endwhile
    endwhile
    " Fallback - just move back one
    return a:prev_indent - &sw
 endfunction

 " Try to find indent of the block we're in (and about to complete),
 " including handling of nested blocks. Works on the 'end' of a block.
 " prev_indent = the previous line's indent
 " prev_lnum   = previous line (to start looking on)
 " blockstart  = expr. that indicates a possible start of this block
 " blockend    = expr. that indicates a possible end of this block
 function s:EndBlockIndent( prev_indent, prev_lnum, blockstart, blockend )
    let lnum = a:prev_lnum
    let line = getline(lnum)
    let ends = 0
    while lnum > 1
       if getline(lnum) =~ '^\s*' . a:blockstart
 	 let ind = indent(lnum)
          if ends <= 0
             if ind < a:prev_indent
 	       return ind
             endif
          else
             let ends = ends - 1
 	 endif
       elseif getline(lnum) =~ '^\s*' . a:blockend
          let ends = ends + 1
       endif

       let lnum = prevnonblank(lnum - 1)
       " Get previous non-blank/non-comment-only line
       while 1
 	 let line = getline(lnum)
 	 let line = substitute( line, s:AdaComment, '', '' )
 	 if line !~ '^\s*$'
 	    break
 	 endif
 	 let lnum = prevnonblank(lnum - 1)
 	 if lnum <= 0
 	    return a:prev_indent
 	 endif
       endwhile
    endwhile
    " Fallback - just move back one
    return a:prev_indent - &sw
 endfunction

 " Return indent of previous statement-start
 " (after we've indented due to multi-line statements).
 " This time, we start searching on the line *before* the one given (which is
 " the end of a statement - we want the previous beginning).
 function s:StatementIndent( current_indent, prev_lnum )
    let lnum  = a:prev_lnum
    while lnum > 0
       let prev_lnum = lnum
       let lnum = prevnonblank(lnum - 1)
       " Get previous non-blank/non-comment-only line
       while 1
          let line = substitute( getline(lnum), s:AdaComment, '', '' )
          if line !~ '^\s*$' && line !~ '^\s*#'
             break
          endif
          let lnum = prevnonblank(lnum - 1)
          if lnum <= 0
             return a:current_indent
          endif
       endwhile
       " Leave indent alone if our ';' line is part of a ';'-delineated
       " aggregate (e.g., procedure args.) or first line after a block start.
       if line =~ s:AdaBlockStart || line =~ '(\s*$'
          return a:current_indent
       endif
       if line !~ '[.=(]\s*$'
          let ind = indent(prev_lnum)
          if ind < a:current_indent
             return ind
          endif
       endif
    endwhile
    " Fallback - just use current one
    return a:current_indent
 endfunction


 " Find correct indent of a new line based upon what went before
 function GetAdaIndent()
    " Find a non-blank line above the current line.
    let lnum = prevnonblank(v:lnum - 1)
    let ind = indent(lnum)
    let package_line = 0

    " Get previous non-blank/non-comment-only/non-cpp line
    while 1
       let line = substitute( getline(lnum), s:AdaComment, '', '' )
       if line !~ '^\s*$' && line !~ '^\s*#'
          break
       endif
       let lnum = prevnonblank(lnum - 1)
       if lnum <= 0
          return ind
       endif
    endwhile

    " Get default indent (from prev. line)
    let ind = indent(lnum)
    let initind = ind

    " Now check what's on the previous line
    if line =~ s:AdaBlockStart  ||  line =~ '(\s*$'
       " Check for false matches to AdaBlockStart
       let false_match = 0
       if line =~ '^\s*\(procedure\|function\|package\)\>.*\<is\s*new\>'
          " Generic instantiation
          let false_match = 1
       elseif line =~ ')\s*;\s*$'  ||  line =~ '^\([^(]*([^)]*)\)*[^(]*;\s*$'
          " forward declaration
          let false_match = 1
       endif
       " Move indent in
       if ! false_match
          let ind = ind + &sw
       endif
    elseif line =~ '^\s*\(case\|exception\)\>'
       " Move indent in twice (next 'when' will move back)
       let ind = ind + 2 * &sw
    elseif line =~ '^\s*end\s*record\>'
       " Move indent back to tallying 'type' preceeding the 'record'.
       " Allow indent to be equal to 'end record's.
       let ind = s:MainBlockIndent( ind+&sw, lnum, 'type\>', '' )
    elseif line =~ '\(^\s*new\>.*\)\@<!)\s*[;,]\s*$'
       " Revert to indent of line that started this parenthesis pair
       exe lnum
       exe 'normal! $F)%'
       if getline('.') =~ '^\s*('
          " Dire layout - use previous indent (could check for AdaComment here)
          let ind = indent( prevnonblank( line('.')-1 ) )
       else
          let ind = indent('.')
       endif
       exe v:lnum
    elseif line =~ '[.=(]\s*$'
       " A statement continuation - move in one
       let ind = ind + &sw
    elseif line =~ '^\s*new\>'
       " Multiple line generic instantiation ('package blah is\nnew thingy')
       let ind = s:StatementIndent( ind - &sw, lnum )
    elseif line =~ ';\s*$'
       " Statement end (but not 'end' ) - try to find current statement-start indent
       let ind = s:StatementIndent( ind, lnum )
    endif

    " Check for potential argument list on next line
    let continuation = (line =~ '[A-Za-z0-9_]\s*$')


    " Check current line; search for simplistic matching start-of-block
    let line = getline(v:lnum)
    if line =~ '^\s*#'
       " Start of line for ada-pp
       let ind = 0
    elseif continuation && line =~ '^\s*('
       " Don't do this if we've already indented due to the previous line
       if ind == initind
          let ind = ind + &sw
       endif
    elseif line =~ '^\s*\(begin\|is\)\>'
       let ind = s:MainBlockIndent( ind, lnum, '\(procedure\|function\|declare\|package\|task\)\>', 'begin\>' )
    elseif line =~ '^\s*record\>'
       let ind = s:MainBlockIndent( ind, lnum, 'type\>\|for\>.*\<use\>', '' ) + &sw
    elseif line =~ '^\s*\(else\|elsif\)\>'
       let ind = s:MainBlockIndent( ind, lnum, 'if\>', '' )
    elseif line =~ '^\s*when\>'
       " Align 'when' one /in/ from matching block start
       let ind = s:MainBlockIndent( ind, lnum, '\(case\|exception\)\>', '' ) + &sw
    elseif line =~ '^\s*end\>\s*\<if\>'
       " End of if statements
       let ind = s:EndBlockIndent( ind, lnum, 'if\>', 'end\>\s*\<if\>' )
    elseif line =~ '^\s*end\>\s*\<loop\>'
       " End of loops
       let ind = s:EndBlockIndent( ind, lnum, '\(\(while\|for\)\>.*\)\?\<loop\>', 'end\>\s*\<loop\>' )
    elseif line =~ '^\s*end\>\s*\<record\>'
       " End of records
       let ind = s:EndBlockIndent( ind, lnum, '\(type\>.*\)\=\<record\>', 'end\>\s*\<record\>' )
    elseif line =~ '^\s*end\>\s*\<procedure\>'
       " End of procedures
       let ind = s:EndBlockIndent( ind, lnum, 'procedure\>.*\<is\>', 'end\>\s*\<procedure\>' )
    elseif line =~ '^\s*end\>\s*\<case\>'
       " End of case statement
       let ind = s:EndBlockIndent( ind, lnum, 'case\>.*\<is\>', 'end\>\s*\<case\>' )
    elseif line =~ '^\s*end\>'
       " General case for end
       let ind = s:MainBlockIndent( ind, lnum, '\(if\|while\|for\|loop\|accept\|begin\|record\|case\|exception\|package\)\>', '' )
    elseif line =~ '^\s*exception\>'
       let ind = s:MainBlockIndent( ind, lnum, 'begin\>', '' )
    elseif line =~ '^\s*then\>'
       let ind = s:MainBlockIndent( ind, lnum, 'if\>', '' )
    endif

    return ind
 endfunction

 " vim: set sw=3 sts=3 :
	" Vim indent file
	" Language: Ada
	" Maintainer: Neil Bird <neil@fnxweb.com>
	" Last Change: 2004 Nov 23
	" Version: $Id$
	" Look for the latest version at http://vim.sourceforge.net/
	"
	" ToDo:
	" Verify handling of multi-line exprs. and recovery upon the final ';'.
	" Correctly find comments given '"' and "" ==> " syntax.
	" Combine the two large block-indent functions into one?

	" Only load this indent file when no other was loaded.
	if exists("b:did_indent")
	finish
	endif
	let b:did_indent = 1

	setlocal indentexpr=GetAdaIndent()
	setlocal indentkeys-=0{,0}
	setlocal indentkeys+=0=~then,0=~end,0=~elsif,0=~when,0=~exception,0=~begin,0=~is,0=~record

	" Only define the functions once.
	if exists("*GetAdaIndent")
	finish
	endif

	let s:AdaBlockStart = '^\s\(if\>\\|while\>\\|else\>\\|elsif\>\\|loop\>\\|for\>.\<\(loop\\|use\)\>\\|declare\>\\|begin\>\\|type\>.\<is\>[^;]$\\|\(type\>.*\)\=\<record\>\\|procedure\>\\|function\>\\|accept\>\\|do\>\\|task\>\\|package\>\\|then\>\\|when\>\\|is\>\)'
	let s:AdaComment = "\\v^(\"[^\"]\"\|'.'\|[^\"']){-}\\zs\\s--.*"


	" Try to find indent of the block we're in
	" prev_indent = the previous line's indent
	" prev_lnum = previous line (to start looking on)
	" blockstart = expr. that indicates a possible start of this block
	" stop_at = if non-null, if a matching line is found, gives up!
	" No recursive previous block analysis: simply look for a valid line
	" with a lesser or equal indent than we currently (on prev_lnum) have.
	" This shouldn't work as well as it appears to with lines that are currently
	" nowhere near the correct indent (e.g., start of line)!
	" Seems to work OK as it 'starts' with the indent of the /previous/ line.
	function s:MainBlockIndent( prev_indent, prev_lnum, blockstart, stop_at )
	let lnum = a:prev_lnum
	let line = substitute( getline(lnum), s:AdaComment, '', '' )
	while lnum > 1
	if a:stop_at != '' && line =~ '^\s*' . a:stop_at && indent(lnum) < a:prev_indent
	return a:prev_indent
	elseif line =~ '^\s*' . a:blockstart
	let ind = indent(lnum)
	if ind < a:prev_indent
	return ind
	endif
	endif

	let lnum = prevnonblank(lnum - 1)
	" Get previous non-blank/non-comment-only line
	while 1
	let line = substitute( getline(lnum), s:AdaComment, '', '' )
	if line !~ '^\s$' && line !~ '^\s#'
	break
	endif
	let lnum = prevnonblank(lnum - 1)
	if lnum <= 0
	return a:prev_indent
	endif
	endwhile
	endwhile
	" Fallback - just move back one
	return a:prev_indent - &sw
	endfunction

	" Try to find indent of the block we're in (and about to complete),
	" including handling of nested blocks. Works on the 'end' of a block.
	" prev_indent = the previous line's indent
	" prev_lnum = previous line (to start looking on)
	" blockstart = expr. that indicates a possible start of this block
	" blockend = expr. that indicates a possible end of this block
	function s:EndBlockIndent( prev_indent, prev_lnum, blockstart, blockend )
	let lnum = a:prev_lnum
	let line = getline(lnum)
	let ends = 0
	while lnum > 1
	if getline(lnum) =~ '^\s*' . a:blockstart
	let ind = indent(lnum)
	if ends <= 0
	if ind < a:prev_indent
	return ind
	endif
	else
	let ends = ends - 1
	endif
	elseif getline(lnum) =~ '^\s*' . a:blockend
	let ends = ends + 1
	endif

	let lnum = prevnonblank(lnum - 1)
	" Get previous non-blank/non-comment-only line
	while 1
	let line = getline(lnum)
	let line = substitute( line, s:AdaComment, '', '' )
	if line !~ '^\s*$'
	break
	endif
	let lnum = prevnonblank(lnum - 1)
	if lnum <= 0
	return a:prev_indent
	endif
	endwhile
	endwhile
	" Fallback - just move back one
	return a:prev_indent - &sw
	endfunction

	" Return indent of previous statement-start
	" (after we've indented due to multi-line statements).
	" This time, we start searching on the line before the one given (which is
	" the end of a statement - we want the previous beginning).
	function s:StatementIndent( current_indent, prev_lnum )
	let lnum = a:prev_lnum
	while lnum > 0
	let prev_lnum = lnum
	let lnum = prevnonblank(lnum - 1)
	" Get previous non-blank/non-comment-only line
	while 1
	let line = substitute( getline(lnum), s:AdaComment, '', '' )
	if line !~ '^\s$' && line !~ '^\s#'
	break
	endif
	let lnum = prevnonblank(lnum - 1)
	if lnum <= 0
	return a:current_indent
	endif
	endwhile
	" Leave indent alone if our ';' line is part of a ';'-delineated
	" aggregate (e.g., procedure args.) or first line after a block start.
	if line =~ s:AdaBlockStart \|\| line =~ '(\s*$'
	return a:current_indent
	endif
	if line !~ '[.=(]\s*$'
	let ind = indent(prev_lnum)
	if ind < a:current_indent
	return ind
	endif
	endif
	endwhile
	" Fallback - just use current one
	return a:current_indent
	endfunction


	" Find correct indent of a new line based upon what went before
	function GetAdaIndent()
	" Find a non-blank line above the current line.
	let lnum = prevnonblank(v:lnum - 1)
	let ind = indent(lnum)
	let package_line = 0

	" Get previous non-blank/non-comment-only/non-cpp line
	while 1
	let line = substitute( getline(lnum), s:AdaComment, '', '' )
	if line !~ '^\s$' && line !~ '^\s#'
	break
	endif
	let lnum = prevnonblank(lnum - 1)
	if lnum <= 0
	return ind
	endif
	endwhile

	" Get default indent (from prev. line)
	let ind = indent(lnum)
	let initind = ind

	" Now check what's on the previous line
	if line =~ s:AdaBlockStart \|\| line =~ '(\s*$'
	" Check for false matches to AdaBlockStart
	let false_match = 0
	if line =~ '^\s\(procedure\\|function\\|package\)\>.\<is\s*new\>'
	" Generic instantiation
	let false_match = 1
	elseif line =~ ')\s;\s$' \|\| line =~ '^\([^(]([^)])\)[^(];\s*$'
	" forward declaration
	let false_match = 1
	endif
	" Move indent in
	if ! false_match
	let ind = ind + &sw
	endif
	elseif line =~ '^\s*\(case\\|exception\)\>'
	" Move indent in twice (next 'when' will move back)
	let ind = ind + 2 * &sw
	elseif line =~ '^\send\srecord\>'
	" Move indent back to tallying 'type' preceeding the 'record'.
	" Allow indent to be equal to 'end record's.
	let ind = s:MainBlockIndent( ind+&sw, lnum, 'type\>', '' )
	elseif line =~ '\(^\snew\>.\)\@<!)\s[;,]\s$'
	" Revert to indent of line that started this parenthesis pair
	exe lnum
	exe 'normal! $F)%'
	if getline('.') =~ '^\s*('
	" Dire layout - use previous indent (could check for AdaComment here)
	let ind = indent( prevnonblank( line('.')-1 ) )
	else
	let ind = indent('.')
	endif
	exe v:lnum
	elseif line =~ '[.=(]\s*$'
	" A statement continuation - move in one
	let ind = ind + &sw
	elseif line =~ '^\s*new\>'
	" Multiple line generic instantiation ('package blah is\nnew thingy')
	let ind = s:StatementIndent( ind - &sw, lnum )
	elseif line =~ ';\s*$'
	" Statement end (but not 'end' ) - try to find current statement-start indent
	let ind = s:StatementIndent( ind, lnum )
	endif

	" Check for potential argument list on next line
	let continuation = (line =~ '[A-Za-z0-9_]\s*$')


	" Check current line; search for simplistic matching start-of-block
	let line = getline(v:lnum)
	if line =~ '^\s*#'
	" Start of line for ada-pp
	let ind = 0
	elseif continuation && line =~ '^\s*('
	" Don't do this if we've already indented due to the previous line
	if ind == initind
	let ind = ind + &sw
	endif
	elseif line =~ '^\s*\(begin\\|is\)\>'
	let ind = s:MainBlockIndent( ind, lnum, '\(procedure\\|function\\|declare\\|package\\|task\)\>', 'begin\>' )
	elseif line =~ '^\s*record\>'
	let ind = s:MainBlockIndent( ind, lnum, 'type\>\\|for\>.*\<use\>', '' ) + &sw
	elseif line =~ '^\s*\(else\\|elsif\)\>'
	let ind = s:MainBlockIndent( ind, lnum, 'if\>', '' )
	elseif line =~ '^\s*when\>'
	" Align 'when' one /in/ from matching block start
	let ind = s:MainBlockIndent( ind, lnum, '\(case\\|exception\)\>', '' ) + &sw
	elseif line =~ '^\send\>\s\<if\>'
	" End of if statements
	let ind = s:EndBlockIndent( ind, lnum, 'if\>', 'end\>\s*\<if\>' )
	elseif line =~ '^\send\>\s\<loop\>'
	" End of loops
	let ind = s:EndBlockIndent( ind, lnum, '\(\(while\\|for\)\>.\)\?\<loop\>', 'end\>\s\<loop\>' )
	elseif line =~ '^\send\>\s\<record\>'
	" End of records
	let ind = s:EndBlockIndent( ind, lnum, '\(type\>.\)\=\<record\>', 'end\>\s\<record\>' )
	elseif line =~ '^\send\>\s\<procedure\>'
	" End of procedures
	let ind = s:EndBlockIndent( ind, lnum, 'procedure\>.\<is\>', 'end\>\s\<procedure\>' )
	elseif line =~ '^\send\>\s\<case\>'
	" End of case statement
	let ind = s:EndBlockIndent( ind, lnum, 'case\>.\<is\>', 'end\>\s\<case\>' )
	elseif line =~ '^\s*end\>'
	" General case for end
	let ind = s:MainBlockIndent( ind, lnum, '\(if\\|while\\|for\\|loop\\|accept\\|begin\\|record\\|case\\|exception\\|package\)\>', '' )
	elseif line =~ '^\s*exception\>'
	let ind = s:MainBlockIndent( ind, lnum, 'begin\>', '' )
	elseif line =~ '^\s*then\>'
	let ind = s:MainBlockIndent( ind, lnum, 'if\>', '' )
	endif

	return ind
	endfunction

	" vim: set sw=3 sts=3 :