vim

Fork of vim, an acceptable text editor
git clone git://git.laack.co/vim.git
Log | Files | Refs | README | LICENSE

ada.vim (11324B)


      1 "------------------------------------------------------------------------------
      2 "  Description: Vim Ada indent file
      3 "     Language: Ada (2005)
      4 "	   $Id: ada.vim 887 2008-07-08 14:29:01Z krischik $
      5 "    Copyright: Copyright (C) 2006 Martin Krischik
      6 "   Maintainer: Martin Krischik <krischik@users.sourceforge.net>
      7 "		Neil Bird <neil@fnxweb.com>
      8 "		Ned Okie <nokie@radford.edu>
      9 "      $Author: krischik $
     10 "	 $Date: 2008-07-08 16:29:01 +0200 (Di, 08 Jul 2008) $
     11 "      Version: 4.6
     12 "    $Revision: 887 $
     13 "     $HeadURL: https://gnuada.svn.sourceforge.net/svnroot/gnuada/trunk/tools/vim/indent/ada.vim $
     14 "      History: 24.05.2006 MK Unified Headers
     15 "		16.07.2006 MK Ada-Mode as vim-ball
     16 "		15.10.2006 MK Bram's suggestion for runtime integration
     17 "		05.11.2006 MK Bram suggested to save on spaces
     18 "		19.09.2007 NO g: missing before ada#Comment
     19 "		2022 April: b:undo_indent added by Doug Kearns
     20 "    Help Page: ft-vim-indent
     21 "------------------------------------------------------------------------------
     22 " ToDo:
     23 "  Verify handling of multi-line exprs. and recovery upon the final ';'.
     24 "  Correctly find comments given '"' and "" ==> " syntax.
     25 "  Combine the two large block-indent functions into one?
     26 "------------------------------------------------------------------------------
     27 
     28 " Only load this indent file when no other was loaded.
     29 if exists("b:did_indent") || version < 700
     30    finish
     31 endif
     32 
     33 let b:did_indent = 45
     34 
     35 setlocal indentexpr=GetAdaIndent()
     36 setlocal indentkeys-=0{,0}
     37 setlocal indentkeys+=0=~then,0=~end,0=~elsif,0=~when,0=~exception,0=~begin,0=~is,0=~record
     38 
     39 let b:undo_indent = "setl inde< indk<"
     40 
     41 " Only define the functions once.
     42 if exists("*GetAdaIndent")
     43    finish
     44 endif
     45 let s:keepcpo= &cpo
     46 set cpo&vim
     47 
     48 if exists("g:ada_with_gnat_project_files")
     49    let s:AdaBlockStart = '^\s*\(if\>\|while\>\|else\>\|elsif\>\|loop\>\|for\>.*\<\(loop\|use\)\>\|declare\>\|begin\>\|type\>.*\<is\>[^;]*$\|\(type\>.*\)\=\<record\>\|procedure\>\|function\>\|accept\>\|do\>\|task\>\|package\>\|project\>\|then\>\|when\>\|is\>\)'
     50 else
     51    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\>\)'
     52 endif
     53 
     54 " Section: s:MainBlockIndent {{{1
     55 "
     56 " Try to find indent of the block we're in
     57 " prev_indent = the previous line's indent
     58 " prev_lnum   = previous line (to start looking on)
     59 " blockstart  = expr. that indicates a possible start of this block
     60 " stop_at     = if non-null, if a matching line is found, gives up!
     61 " No recursive previous block analysis: simply look for a valid line
     62 " with a lesser or equal indent than we currently (on prev_lnum) have.
     63 " This shouldn't work as well as it appears to with lines that are currently
     64 " nowhere near the correct indent (e.g., start of line)!
     65 " Seems to work OK as it 'starts' with the indent of the /previous/ line.
     66 function s:MainBlockIndent (prev_indent, prev_lnum, blockstart, stop_at)
     67    let lnum = a:prev_lnum
     68    let line = substitute( getline(lnum), g:ada#Comment, '', '' )
     69    while lnum > 1
     70       if a:stop_at != ''  &&  line =~ '^\s*' . a:stop_at  &&  indent(lnum) < a:prev_indent
     71 	 return a:prev_indent
     72       elseif line =~ '^\s*' . a:blockstart
     73 	 let ind = indent(lnum)
     74 	 if ind < a:prev_indent
     75 	    return ind
     76 	 endif
     77       endif
     78 
     79       let lnum = prevnonblank(lnum - 1)
     80       " Get previous non-blank/non-comment-only line
     81       while 1
     82 	 let line = substitute( getline(lnum), g:ada#Comment, '', '' )
     83 	 if line !~ '^\s*$' && line !~ '^\s*#'
     84 	    break
     85 	 endif
     86 	 let lnum = prevnonblank(lnum - 1)
     87 	 if lnum <= 0
     88 	    return a:prev_indent
     89 	 endif
     90       endwhile
     91    endwhile
     92    " Fallback - just move back one
     93    return a:prev_indent - shiftwidth()
     94 endfunction MainBlockIndent
     95 
     96 " Section: s:EndBlockIndent {{{1
     97 "
     98 " Try to find indent of the block we're in (and about to complete),
     99 " including handling of nested blocks. Works on the 'end' of a block.
    100 " prev_indent = the previous line's indent
    101 " prev_lnum   = previous line (to start looking on)
    102 " blockstart  = expr. that indicates a possible start of this block
    103 " blockend    = expr. that indicates a possible end of this block
    104 function s:EndBlockIndent( prev_indent, prev_lnum, blockstart, blockend )
    105    let lnum = a:prev_lnum
    106    let line = getline(lnum)
    107    let ends = 0
    108    while lnum > 1
    109       if getline(lnum) =~ '^\s*' . a:blockstart
    110 	 let ind = indent(lnum)
    111 	 if ends <= 0
    112 	    if ind < a:prev_indent
    113 	       return ind
    114 	    endif
    115 	 else
    116 	    let ends = ends - 1
    117 	 endif
    118       elseif getline(lnum) =~ '^\s*' . a:blockend
    119 	 let ends = ends + 1
    120       endif
    121 
    122       let lnum = prevnonblank(lnum - 1)
    123       " Get previous non-blank/non-comment-only line
    124       while 1
    125 	 let line = getline(lnum)
    126 	 let line = substitute( line, g:ada#Comment, '', '' )
    127 	 if line !~ '^\s*$'
    128 	    break
    129 	 endif
    130 	 let lnum = prevnonblank(lnum - 1)
    131 	 if lnum <= 0
    132 	    return a:prev_indent
    133 	 endif
    134       endwhile
    135    endwhile
    136    " Fallback - just move back one
    137    return a:prev_indent - shiftwidth()
    138 endfunction EndBlockIndent
    139 
    140 " Section: s:StatementIndent {{{1
    141 "
    142 " Return indent of previous statement-start
    143 " (after we've indented due to multi-line statements).
    144 " This time, we start searching on the line *before* the one given (which is
    145 " the end of a statement - we want the previous beginning).
    146 function s:StatementIndent( current_indent, prev_lnum )
    147    let lnum  = a:prev_lnum
    148    while lnum > 0
    149       let prev_lnum = lnum
    150       let lnum = prevnonblank(lnum - 1)
    151       " Get previous non-blank/non-comment-only line
    152       while 1
    153 	 let line = substitute( getline(lnum), g:ada#Comment, '', '' )
    154 
    155 	 if line !~ '^\s*$' && line !~ '^\s*#'
    156 	    break
    157 	 endif
    158 	 let lnum = prevnonblank(lnum - 1)
    159 	 if lnum <= 0
    160 	    return a:current_indent
    161 	 endif
    162       endwhile
    163       " Leave indent alone if our ';' line is part of a ';'-delineated
    164       " aggregate (e.g., procedure args.) or first line after a block start.
    165       if line =~ s:AdaBlockStart || line =~ '(\s*$'
    166 	 return a:current_indent
    167       endif
    168       if line !~ '[.=(]\s*$'
    169 	 let ind = indent(prev_lnum)
    170 	 if ind < a:current_indent
    171 	    return ind
    172 	 endif
    173       endif
    174    endwhile
    175    " Fallback - just use current one
    176    return a:current_indent
    177 endfunction StatementIndent
    178 
    179 
    180 " Section: GetAdaIndent {{{1
    181 "
    182 " Find correct indent of a new line based upon what went before
    183 "
    184 function GetAdaIndent()
    185    " Find a non-blank line above the current line.
    186    let lnum = prevnonblank(v:lnum - 1)
    187    let ind = indent(lnum)
    188    let package_line = 0
    189 
    190    " Get previous non-blank/non-comment-only/non-cpp line
    191    while 1
    192       let line = substitute( getline(lnum), g:ada#Comment, '', '' )
    193       if line !~ '^\s*$' && line !~ '^\s*#'
    194 	 break
    195       endif
    196       let lnum = prevnonblank(lnum - 1)
    197       if lnum <= 0
    198 	 return ind
    199       endif
    200    endwhile
    201 
    202    " Get default indent (from prev. line)
    203    let ind = indent(lnum)
    204    let initind = ind
    205 
    206    " Now check what's on the previous line
    207    if line =~ s:AdaBlockStart  ||  line =~ '(\s*$'
    208       " Check for false matches to AdaBlockStart
    209       let false_match = 0
    210       if line =~ '^\s*\(procedure\|function\|package\)\>.*\<is\s*new\>'
    211 	 " Generic instantiation
    212 	 let false_match = 1
    213       elseif line =~ ')\s*;\s*$'  ||  line =~ '^\([^(]*([^)]*)\)*[^(]*;\s*$'
    214 	 " forward declaration
    215 	 let false_match = 1
    216       endif
    217       " Move indent in
    218       if ! false_match
    219 	 let ind = ind + shiftwidth()
    220       endif
    221    elseif line =~ '^\s*\(case\|exception\)\>'
    222       " Move indent in twice (next 'when' will move back)
    223       let ind = ind + 2 * shiftwidth()
    224    elseif line =~ '^\s*end\s*record\>'
    225       " Move indent back to tallying 'type' preceding the 'record'.
    226       " Allow indent to be equal to 'end record's.
    227       let ind = s:MainBlockIndent( ind+shiftwidth(), lnum, 'type\>', '' )
    228    elseif line =~ '\(^\s*new\>.*\)\@<!)\s*[;,]\s*$'
    229       " Revert to indent of line that started this parenthesis pair
    230       exe lnum
    231       exe 'normal! $F)%'
    232       if getline('.') =~ '^\s*('
    233 	 " Dire layout - use previous indent (could check for g:ada#Comment here)
    234 	 let ind = indent( prevnonblank( line('.')-1 ) )
    235       else
    236 	 let ind = indent('.')
    237       endif
    238       exe v:lnum
    239    elseif line =~ '[.=(]\s*$'
    240       " A statement continuation - move in one
    241       let ind = ind + shiftwidth()
    242    elseif line =~ '^\s*new\>'
    243       " Multiple line generic instantiation ('package blah is\nnew thingy')
    244       let ind = s:StatementIndent( ind - shiftwidth(), lnum )
    245    elseif line =~ ';\s*$'
    246       " Statement end (but not 'end' ) - try to find current statement-start indent
    247       let ind = s:StatementIndent( ind, lnum )
    248    endif
    249 
    250    " Check for potential argument list on next line
    251    let continuation = (line =~ '[A-Za-z0-9_]\s*$')
    252 
    253 
    254    " Check current line; search for simplistic matching start-of-block
    255    let line = getline(v:lnum)
    256    if line =~ '^\s*#'
    257       " Start of line for ada-pp
    258       let ind = 0
    259    elseif continuation && line =~ '^\s*('
    260       " Don't do this if we've already indented due to the previous line
    261       if ind == initind
    262 	 let ind = ind + shiftwidth()
    263       endif
    264    elseif line =~ '^\s*\(begin\|is\)\>'
    265       let ind = s:MainBlockIndent( ind, lnum, '\(procedure\|function\|declare\|package\|task\)\>', 'begin\>' )
    266    elseif line =~ '^\s*record\>'
    267       let ind = s:MainBlockIndent( ind, lnum, 'type\>\|for\>.*\<use\>', '' ) + shiftwidth()
    268    elseif line =~ '^\s*\(else\|elsif\)\>'
    269       let ind = s:MainBlockIndent( ind, lnum, 'if\>', '' )
    270    elseif line =~ '^\s*when\>'
    271       " Align 'when' one /in/ from matching block start
    272       let ind = s:MainBlockIndent( ind, lnum, '\(case\|exception\)\>', '' ) + shiftwidth()
    273    elseif line =~ '^\s*end\>\s*\<if\>'
    274       " End of if statements
    275       let ind = s:EndBlockIndent( ind, lnum, 'if\>', 'end\>\s*\<if\>' )
    276    elseif line =~ '^\s*end\>\s*\<loop\>'
    277       " End of loops
    278       let ind = s:EndBlockIndent( ind, lnum, '\(\(while\|for\)\>.*\)\?\<loop\>', 'end\>\s*\<loop\>' )
    279    elseif line =~ '^\s*end\>\s*\<record\>'
    280       " End of records
    281       let ind = s:EndBlockIndent( ind, lnum, '\(type\>.*\)\=\<record\>', 'end\>\s*\<record\>' )
    282    elseif line =~ '^\s*end\>\s*\<procedure\>'
    283       " End of procedures
    284       let ind = s:EndBlockIndent( ind, lnum, 'procedure\>.*\<is\>', 'end\>\s*\<procedure\>' )
    285    elseif line =~ '^\s*end\>\s*\<case\>'
    286       " End of case statement
    287       let ind = s:EndBlockIndent( ind, lnum, 'case\>.*\<is\>', 'end\>\s*\<case\>' )
    288    elseif line =~ '^\s*end\>'
    289       " General case for end
    290       let ind = s:MainBlockIndent( ind, lnum, '\(if\|while\|for\|loop\|accept\|begin\|record\|case\|exception\|package\)\>', '' )
    291    elseif line =~ '^\s*exception\>'
    292       let ind = s:MainBlockIndent( ind, lnum, 'begin\>', '' )
    293    elseif line =~ '^\s*then\>'
    294       let ind = s:MainBlockIndent( ind, lnum, 'if\>', '' )
    295    endif
    296 
    297    return ind
    298 endfunction GetAdaIndent
    299 
    300 let &cpo = s:keepcpo
    301 unlet s:keepcpo
    302 
    303 finish " 1}}}
    304 
    305 "------------------------------------------------------------------------------
    306 "   Copyright (C) 2006	Martin Krischik
    307 "
    308 "   Vim is Charityware - see ":help license" or uganda.txt for licence details.
    309 "------------------------------------------------------------------------------
    310 " vim: textwidth=78 wrap tabstop=8 shiftwidth=3 softtabstop=3 noexpandtab
    311 " vim: foldmethod=marker