updated for version 7.0001
This commit is contained in:
Bram Moolenaar
45
runtime/indent/README.txt
Normal file
45
runtime/indent/README.txt
Normal file
@ -0,0 +1,45 @@
|
||||
This directory contains files to automatically compute the indent for a
|
||||
type of file.
|
||||
|
||||
If you want to add your own indent file for your personal use, read the docs
|
||||
at ":help indent-expression". Looking at the existing files should give you
|
||||
inspiration.
|
||||
|
||||
If you make a new indent file which would be useful for others, please send it
|
||||
to Bram@vim.org. Include instructions for detecting the file type for this
|
||||
language, by file name extension or by checking a few lines in the file.
|
||||
And please stick to the rules below.
|
||||
|
||||
If you have remarks about an existing file, send them to the maintainer of
|
||||
that file. Only when you get no response send a message to Bram@vim.org.
|
||||
|
||||
If you are the maintainer of an indent file and make improvements, e-mail the
|
||||
new version to Bram@vim.org.
|
||||
|
||||
|
||||
Rules for making an indent file:
|
||||
|
||||
You should use this check for "b:did_indent":
|
||||
|
||||
" Only load this indent file when no other was loaded yet.
|
||||
if exists("b:did_indent")
|
||||
finish
|
||||
endif
|
||||
let b:did_indent = 1
|
||||
|
||||
Always use ":setlocal" to set 'indentexpr'. This avoids it being carried over
|
||||
to other buffers.
|
||||
|
||||
To trigger the indenting after typing a word like "endif", add the word to the
|
||||
'cinkeys' option with "+=".
|
||||
|
||||
You normally set 'indentexpr' to evaluate a function and then define that
|
||||
function. That function only needs to be defined once for as long as Vim is
|
||||
running. Add a test if the function exists and use ":finish", like this:
|
||||
if exists("*GetMyIndent")
|
||||
finish
|
||||
endif
|
||||
|
||||
The user may have several options set unlike you, try to write the file such
|
||||
that it works with any option settings. Also be aware of certain features not
|
||||
being compiled in.
|
||||
7
runtime/indent/aap.vim
Normal file
7
runtime/indent/aap.vim
Normal file
@ -0,0 +1,7 @@
|
||||
" Vim indent file
|
||||
" Language: Aap recipe
|
||||
" Maintainer: Bram Moolenaar <Bram@vim.org>
|
||||
" Last Change: 2003 Sep 08
|
||||
|
||||
" Works mostly like Python.
|
||||
runtime! indent/python.vim
|
||||
264
runtime/indent/ada.vim
Normal file
264
runtime/indent/ada.vim
Normal file
@ -0,0 +1,264 @@
|
||||
" Vim indent file
|
||||
" Language: Ada
|
||||
" Maintainer: Neil Bird <neil@fnxweb.com>
|
||||
" Last Change: 2003 May 20
|
||||
" 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\>\|declare\>\|begin\>\|type\>.*\<is\s*$\|\(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 (and about to complete)
|
||||
" 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 -1
|
||||
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
|
||||
|
||||
" As per MainBlockIndent, but 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)
|
||||
|
||||
" 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 - 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*('
|
||||
let ind = ind + &sw
|
||||
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\>', '' ) + &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\)\>', '' )
|
||||
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 :
|
||||
12
runtime/indent/ant.vim
Normal file
12
runtime/indent/ant.vim
Normal file
@ -0,0 +1,12 @@
|
||||
" Vim indent file
|
||||
" Language: ANT files
|
||||
" Maintainer: David Fishburn <fishburn@ianywhere.com>
|
||||
" Last Change: Thu May 15 2003 10:02:54 PM
|
||||
|
||||
" Only load this indent file when no other was loaded.
|
||||
if exists("b:did_indent")
|
||||
finish
|
||||
endif
|
||||
|
||||
" Use XML formatting rules
|
||||
runtime! indent/xml.vim
|
||||
11
runtime/indent/automake.vim
Normal file
11
runtime/indent/automake.vim
Normal file
@ -0,0 +1,11 @@
|
||||
" Vim indent file
|
||||
" Language: automake
|
||||
" Maintainer: Nikolai Weibull <source@pcppopper.org>
|
||||
" URL: http://www.pcppopper.org/vim/indent/pcp/automake/
|
||||
" Latest Revision: 2004-04-25
|
||||
" arch-tag: 9a2af48c-48d4-4bae-82c3-c801bc9d1976
|
||||
|
||||
" same as makefile indenting for now.
|
||||
source <sfile>:p:h/make.vim
|
||||
|
||||
" vim: set sts=2 sw=2:
|
||||
228
runtime/indent/awk.vim
Normal file
228
runtime/indent/awk.vim
Normal file
@ -0,0 +1,228 @@
|
||||
" vim: set sw=3 sts=3:
|
||||
|
||||
" Awk indent script. It can handle multi-line statements and expressions.
|
||||
" It works up to the point where the distinction between correct/incorrect
|
||||
" and personal taste gets fuzzy. Drop me an e-mail for bug reports and
|
||||
" reasonable style suggestions.
|
||||
"
|
||||
" Bugs:
|
||||
" =====
|
||||
" - Some syntax errors may cause erratic indentation.
|
||||
" - Same for very unusual but syntacticly correct use of { }
|
||||
" - In some cases it's confused by the use of ( and { in strings constants
|
||||
" - This version likes the closing brace of a multiline pattern-action be on
|
||||
" character position 1 before the following pattern-action combination is
|
||||
" formatted
|
||||
|
||||
" Author:
|
||||
" =======
|
||||
" Erik Janssen, ejanssen@itmatters.nl
|
||||
"
|
||||
" History:
|
||||
" ========
|
||||
" 26-04-2002 Got initial version working reasonably well
|
||||
" 29-04-2002 Fixed problems in function headers and max line width
|
||||
" Added support for two-line if's without curly braces
|
||||
|
||||
" Only load this indent file when no other was loaded.
|
||||
if exists("b:did_indent")
|
||||
finish
|
||||
endif
|
||||
|
||||
let b:did_indent = 1
|
||||
|
||||
setlocal indentexpr=GetAwkIndent()
|
||||
" Mmm, copied from the tcl indent program. Is this okay?
|
||||
setlocal indentkeys-=:,0#
|
||||
|
||||
" Only define the function once.
|
||||
if exists("*GetAwkIndent")
|
||||
finish
|
||||
endif
|
||||
|
||||
" This function contains a lot of exit points. It checks for simple cases
|
||||
" first to get out of the function as soon as possible, thereby reducing the
|
||||
" number of possibilities later on in the difficult parts
|
||||
|
||||
function! GetAwkIndent()
|
||||
|
||||
" Find previous line and get it's indentation
|
||||
let prev_lineno = s:Get_prev_line( v:lnum )
|
||||
if prev_lineno == 0
|
||||
return 0
|
||||
endif
|
||||
let prev_data = getline( prev_lineno )
|
||||
let ind = indent( prev_lineno )
|
||||
|
||||
" Increase indent if the previous line contains an opening brace. Search
|
||||
" for this brace the hard way to prevent errors if the previous line is a
|
||||
" 'pattern { action }' (simple check match on /{/ increases the indent then)
|
||||
|
||||
if s:Get_brace_balance( prev_data, '{', '}' ) > 0
|
||||
return ind + &sw
|
||||
endif
|
||||
|
||||
let brace_balance = s:Get_brace_balance( prev_data, '(', ')' )
|
||||
|
||||
" If prev line has positive brace_balance and starts with a word (keyword
|
||||
" or function name), align the current line on the first '(' of the prev
|
||||
" line
|
||||
|
||||
if brace_balance > 0 && s:Starts_with_word( prev_data )
|
||||
return s:Safe_indent( ind, s:First_word_len(prev_data), getline(v:lnum))
|
||||
endif
|
||||
|
||||
" If this line starts with an open brace bail out now before the line
|
||||
" continuation checks.
|
||||
|
||||
if getline( v:lnum ) =~ '^\s*{'
|
||||
return ind
|
||||
endif
|
||||
|
||||
" If prev line seems to be part of multiline statement:
|
||||
" 1. Prev line is first line of a multiline statement
|
||||
" -> attempt to indent on first ' ' or '(' of prev line, just like we
|
||||
" indented the positive brace balance case above
|
||||
" 2. Prev line is not first line of a multiline statement
|
||||
" -> copy indent of prev line
|
||||
|
||||
let continue_mode = s:Seems_continuing( prev_data )
|
||||
if continue_mode > 0
|
||||
if s:Seems_continuing( getline(s:Get_prev_line( prev_lineno )) )
|
||||
" Case 2
|
||||
return ind
|
||||
else
|
||||
" Case 1
|
||||
if continue_mode == 1
|
||||
" Need continuation due to comma, backslash, etc
|
||||
return s:Safe_indent( ind, s:First_word_len(prev_data), getline(v:lnum))
|
||||
else
|
||||
" if/for/while without '{'
|
||||
return ind + &sw
|
||||
endif
|
||||
endif
|
||||
endif
|
||||
|
||||
" If the previous line doesn't need continuation on the current line we are
|
||||
" on the start of a new statement. We have to make sure we align with the
|
||||
" previous statement instead of just the previous line. This is a bit
|
||||
" complicated because the previous statement might be multi-line.
|
||||
"
|
||||
" The start of a multiline statement can be found by:
|
||||
"
|
||||
" 1 If the previous line contains closing braces and has negative brace
|
||||
" balance, search backwards until cumulative brace balance becomes zero,
|
||||
" take indent of that line
|
||||
" 2 If the line before the previous needs continuation search backward
|
||||
" until that's not the case anymore. Take indent of one line down.
|
||||
|
||||
" Case 1
|
||||
if prev_data =~ ')' && brace_balance < 0
|
||||
while brace_balance != 0
|
||||
let prev_lineno = s:Get_prev_line( prev_lineno )
|
||||
let prev_data = getline( prev_lineno )
|
||||
let brace_balance=brace_balance+s:Get_brace_balance(prev_data,'(',')' )
|
||||
endwhile
|
||||
let ind = indent( prev_lineno )
|
||||
else
|
||||
" Case 2
|
||||
if s:Seems_continuing( getline( prev_lineno - 1 ) )
|
||||
let prev_lineno = prev_lineno - 2
|
||||
let prev_data = getline( prev_lineno )
|
||||
while prev_lineno > 0 && (s:Seems_continuing( prev_data ) > 0)
|
||||
let prev_lineno = s:Get_prev_line( prev_lineno )
|
||||
let prev_data = getline( prev_lineno )
|
||||
endwhile
|
||||
let ind = indent( prev_lineno + 1 )
|
||||
endif
|
||||
endif
|
||||
|
||||
" Decrease indent if this line contains a '}'.
|
||||
if getline(v:lnum) =~ '^\s*}'
|
||||
let ind = ind - &sw
|
||||
endif
|
||||
|
||||
return ind
|
||||
endfunction
|
||||
|
||||
" Find the open and close braces in this line and return how many more open-
|
||||
" than close braces there are. It's also used to determine cumulative balance
|
||||
" across multiple lines.
|
||||
|
||||
function! s:Get_brace_balance( line, b_open, b_close )
|
||||
let line2 = substitute( a:line, a:b_open, "", "g" )
|
||||
let openb = strlen( a:line ) - strlen( line2 )
|
||||
let line3 = substitute( line2, a:b_close, "", "g" )
|
||||
let closeb = strlen( line2 ) - strlen( line3 )
|
||||
return openb - closeb
|
||||
endfunction
|
||||
|
||||
" Find out whether the line starts with a word (i.e. keyword or function
|
||||
" call). Might need enhancements here.
|
||||
|
||||
function! s:Starts_with_word( line )
|
||||
if a:line =~ '^\s*[a-zA-Z_0-9]\+\s*('
|
||||
return 1
|
||||
endif
|
||||
return 0
|
||||
endfunction
|
||||
|
||||
" Find the length of the first word in a line. This is used to be able to
|
||||
" align a line relative to the 'print ' or 'if (' on the previous line in case
|
||||
" such a statement spans multiple lines.
|
||||
" Precondition: only to be used on lines where 'Starts_with_word' returns 1.
|
||||
|
||||
function! s:First_word_len( line )
|
||||
let white_end = matchend( a:line, '^\s*' )
|
||||
if match( a:line, '^\s*func' ) != -1
|
||||
let word_end = matchend( a:line, '[a-z]\+\s\+[a-zA-Z_0-9]\+[ (]*' )
|
||||
else
|
||||
let word_end = matchend( a:line, '[a-zA-Z_0-9]\+[ (]*' )
|
||||
endif
|
||||
return word_end - white_end
|
||||
endfunction
|
||||
|
||||
" Determine if 'line' completes a statement or is continued on the next line.
|
||||
" This one is far from complete and accepts illegal code. Not important for
|
||||
" indenting, however.
|
||||
|
||||
function! s:Seems_continuing( line )
|
||||
" Unfinished lines
|
||||
if a:line =~ '[\\,\|\&\+\-\*\%\^]\s*$'
|
||||
return 1
|
||||
endif
|
||||
" if/for/while (cond) eol
|
||||
if a:line =~ '^\s*\(if\|while\|for\)\s*(.*)\s*$' || a:line =~ '^\s*else\s*'
|
||||
return 2
|
||||
endif
|
||||
return 0
|
||||
endfunction
|
||||
|
||||
" Get previous relevant line. Search back until a line is that is no
|
||||
" comment or blank and return the line number
|
||||
|
||||
function! s:Get_prev_line( lineno )
|
||||
let lnum = a:lineno - 1
|
||||
let data = getline( lnum )
|
||||
while lnum > 0 && (data =~ '^\s*#' || data =~ '^\s*$')
|
||||
let lnum = lnum - 1
|
||||
let data = getline( lnum )
|
||||
endwhile
|
||||
return lnum
|
||||
endfunction
|
||||
|
||||
" This function checks whether an indented line exceeds a maximum linewidth
|
||||
" (hardcoded 80). If so and it is possible to stay within 80 positions (or
|
||||
" limit num of characters beyond linewidth) by decreasing the indent (keeping
|
||||
" it > base_indent), do so.
|
||||
|
||||
function! s:Safe_indent( base, wordlen, this_line )
|
||||
let line_base = matchend( a:this_line, '^\s*' )
|
||||
let line_len = strlen( a:this_line ) - line_base
|
||||
let indent = a:base
|
||||
if (indent + a:wordlen + line_len) > 80
|
||||
" Simple implementation good enough for the time being
|
||||
let indent = indent + 3
|
||||
endif
|
||||
return indent + a:wordlen
|
||||
endfunction
|
||||
13
runtime/indent/c.vim
Normal file
13
runtime/indent/c.vim
Normal file
@ -0,0 +1,13 @@
|
||||
" Vim indent file
|
||||
" Language: C
|
||||
" Maintainer: Bram Moolenaar <Bram@vim.org>
|
||||
" Last Change: 2001 Jun 12
|
||||
|
||||
" Only load this indent file when no other was loaded.
|
||||
if exists("b:did_indent")
|
||||
finish
|
||||
endif
|
||||
let b:did_indent = 1
|
||||
|
||||
" C indenting is built-in, thus this is very simple
|
||||
setlocal cindent
|
||||
129
runtime/indent/cdl.vim
Normal file
129
runtime/indent/cdl.vim
Normal file
@ -0,0 +1,129 @@
|
||||
" Description: Comshare Dimension Definition Language (CDL)
|
||||
" Author: Raul Segura Acevedo <raulseguraaceved@netscape.net>
|
||||
" Last Change: Fri Nov 30 13:35:48 2001 CST
|
||||
|
||||
if exists("b:did_indent")
|
||||
"finish
|
||||
endif
|
||||
let b:did_indent = 1
|
||||
|
||||
setlocal indentexpr=CdlGetIndent(v:lnum)
|
||||
setlocal indentkeys&
|
||||
setlocal indentkeys+==~else,=~endif,=~then,;,),=
|
||||
|
||||
" Only define the function once.
|
||||
if exists("*CdlGetIndent")
|
||||
"finish
|
||||
endif
|
||||
|
||||
" find out if an "...=..." expresion its an asignment (or a conditional)
|
||||
" it scans 'line' first, and then the previos lines
|
||||
fun! CdlAsignment(lnum, line)
|
||||
let f = -1
|
||||
let lnum = a:lnum
|
||||
let line = a:line
|
||||
while lnum > 0 && f == -1
|
||||
" line without members [a] of [b]:[c]...
|
||||
let inicio = 0
|
||||
while 1
|
||||
" keywords that help to decide
|
||||
let inicio = matchend(line, '\c\<\(expr\|\a*if\|and\|or\|not\|else\|then\|memberis\|\k\+of\)\>\|[<>;]', inicio)
|
||||
if inicio < 0
|
||||
break
|
||||
endif
|
||||
" it's formula if there's a ';', 'elsE', 'theN', 'enDif' or 'expr'
|
||||
" conditional if there's a '<', '>', 'elseif', 'if', 'and', 'or', 'not',
|
||||
" 'memberis', 'childrenof' and other \k\+of funcions
|
||||
let f = line[inicio-1] =~? '[en;]' || strpart(line, inicio-4, 4) =~? 'ndif\|expr'
|
||||
endw
|
||||
let lnum = prevnonblank(lnum-1)
|
||||
let line = substitute(getline(lnum), '\c\(\[[^]]*]\(\s*of\s*\|:\)*\)\+', ' ', 'g')
|
||||
endw
|
||||
" if we hit the start of the file then f = -1, return 1 (formula)
|
||||
return f != 0
|
||||
endf
|
||||
|
||||
fun! CdlGetIndent(lnum)
|
||||
let thisline = getline(a:lnum)
|
||||
if match(thisline, '^\s*\(\k\+\|\[[^]]*]\)\s*\(,\|;\s*$\)') >= 0
|
||||
" it's an attributes line
|
||||
return &sw
|
||||
elseif match(thisline, '^\c\s*\([{}]\|\/[*/]\|dimension\|schedule\|group\|hierarchy\|class\)') >= 0
|
||||
" it's a header or '{' or '}' or a comment
|
||||
return 0
|
||||
end
|
||||
|
||||
let lnum = prevnonblank(a:lnum-1)
|
||||
" Hit the start of the file, use zero indent.
|
||||
if lnum == 0
|
||||
return 0
|
||||
endif
|
||||
|
||||
" PREVIOUS LINE
|
||||
let ind = indent(lnum)
|
||||
let line = getline(lnum)
|
||||
let f = -1 " wether a '=' is a conditional or a asignment, -1 means we don't know yet
|
||||
" one 'closing' element at the beginning of the line has already reduced the
|
||||
" indent, but 'else', 'elseif' & 'then' increment it for the next line
|
||||
" '=' at the beginning has already de right indent (increased for asignments)
|
||||
let inicio = matchend(line, '^\c\s*\(else\a*\|then\|endif\|/[*/]\|[);={]\)')
|
||||
if inicio > 0
|
||||
let c = line[inicio-1]
|
||||
" ')' and '=' don't change indent and are useless to set 'f'
|
||||
if c == '{'
|
||||
return &sw
|
||||
elseif c != ')' && c != '='
|
||||
let f = 1 " all but 'elseif' are followed by a formula
|
||||
if c ==? 'n' || c ==? 'e' " 'then', 'else'
|
||||
let ind = ind + &sw
|
||||
elseif strpart(line, inicio-6, 6) ==? 'elseif' " elseif, set f to conditional
|
||||
let ind = ind + &sw
|
||||
let f = 0
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
" remove members [a] of [b]:[c]... (inicio remainds valid)
|
||||
let line = substitute(line, '\c\(\[[^]]*]\(\s*of\s*\|:\)*\)\+', ' ', 'g')
|
||||
while 1
|
||||
" search for the next interesting element
|
||||
let inicio=matchend(line, '\c\<if\|endif\|[()=;]', inicio)
|
||||
if inicio < 0
|
||||
break
|
||||
end
|
||||
|
||||
let c = line[inicio-1]
|
||||
" 'expr(...)' containing the formula
|
||||
if strpart(line, inicio-5, 5) ==? 'expr('
|
||||
let ind = 0
|
||||
let f = 1
|
||||
elseif c == ')' || c== ';' || strpart(line, inicio-5, 5) ==? 'endif'
|
||||
let ind = ind - &sw
|
||||
elseif c == '(' || c ==? 'f' " '(' or 'if'
|
||||
let ind = ind + &sw
|
||||
else " c == '='
|
||||
" if it is an asignment increase indent
|
||||
if f == -1 " we don't know yet, find out
|
||||
let f = CdlAsignment(lnum, strpart(line, 0, inicio))
|
||||
end
|
||||
if f == 1 " formula increase it
|
||||
let ind = ind + &sw
|
||||
end
|
||||
end
|
||||
endw
|
||||
|
||||
" CURRENT LINE, if it starts with a closing element, decrease indent
|
||||
" or if it starts with '=' (asignment), increase indent
|
||||
if match(thisline, '^\c\s*\(else\|then\|endif\|[);]\)') >= 0
|
||||
let ind = ind - &sw
|
||||
elseif match(thisline, '^\s*=') >= 0
|
||||
if f == -1 " we don't know yet if is an asignment, find out
|
||||
let f = CdlAsignment(lnum, "")
|
||||
end
|
||||
if f == 1 " formula increase it
|
||||
let ind = ind + &sw
|
||||
end
|
||||
end
|
||||
|
||||
return ind
|
||||
endfun
|
||||
18
runtime/indent/ch.vim
Normal file
18
runtime/indent/ch.vim
Normal file
@ -0,0 +1,18 @@
|
||||
" Vim indent file
|
||||
" Language: Ch
|
||||
" Maintainer: SoftIntegration, Inc. <info@softintegration.com>
|
||||
" URL: http://www.softintegration.com/download/vim/indent/ch.vim
|
||||
" Last change: 2003 Aug 05
|
||||
" Created based on cpp.vim
|
||||
"
|
||||
" Ch is a C/C++ interpreter with many high level extensions
|
||||
|
||||
|
||||
" Only load this indent file when no other was loaded.
|
||||
if exists("b:did_indent")
|
||||
finish
|
||||
endif
|
||||
let b:did_indent = 1
|
||||
|
||||
" Ch indenting is built-in, thus this is very simple
|
||||
setlocal cindent
|
||||
85
runtime/indent/config.vim
Normal file
85
runtime/indent/config.vim
Normal file
@ -0,0 +1,85 @@
|
||||
" Vim indent file
|
||||
" Language: Autoconf configure.{ac,in} file
|
||||
" Maintainer: Nikolai Weibull <source@pcppopper.org>
|
||||
" URL: http://www.pcppopper.org/vim/indent/pcp/config/
|
||||
" Latest Revision: 2004-04-25
|
||||
" arch-tag: 7779c341-796f-408e-80e4-a55c26b519a4
|
||||
" TODO: how about nested [()]'s in one line
|
||||
" what's wrong with '\\\@!'?
|
||||
|
||||
" Only load this indent file when no other was loaded.
|
||||
if exists("b:did_indent")
|
||||
finish
|
||||
endif
|
||||
|
||||
source <sfile>:p:h/sh.vim " will set b:did_indent
|
||||
|
||||
setlocal indentexpr=GetConfigIndent()
|
||||
setlocal indentkeys=!^F,o,O,=then,=do,=else,=elif,=esac,=fi,=fin,=fil,=done
|
||||
|
||||
" Only define the function once.
|
||||
if exists("*GetConfigIndent")
|
||||
finish
|
||||
endif
|
||||
|
||||
" get the offset (indent) of the end of the match of 'regexp' in 'line'
|
||||
function s:GetOffsetOf(line, regexp)
|
||||
let end = matchend(a:line, a:regexp)
|
||||
let width = 0
|
||||
let i = 0
|
||||
while i < end
|
||||
if a:line[i] != "\t"
|
||||
let width = width + 1
|
||||
else
|
||||
let width = width + &ts - (width % &ts)
|
||||
endif
|
||||
let i = i + 1
|
||||
endwhile
|
||||
return width
|
||||
endfunction
|
||||
|
||||
function GetConfigIndent()
|
||||
" Find a non-blank line above the current line.
|
||||
let lnum = prevnonblank(v:lnum - 1)
|
||||
|
||||
" Hit the start of the file, use zero indent.
|
||||
if lnum == 0
|
||||
return 0
|
||||
endif
|
||||
|
||||
" where to put this
|
||||
let ind = GetShIndent()
|
||||
let line = getline(lnum)
|
||||
|
||||
" if previous line has unmatched, unescaped opening parentheses,
|
||||
" indent to its position. TODO: not failsafe if multiple ('s
|
||||
if line =~ '\\\@<!([^)]*$'
|
||||
let ind = s:GetOffsetOf(line, '\\\@!(')
|
||||
endif
|
||||
|
||||
" if previous line has unmatched opening bracket,
|
||||
" indent to its position. TODO: same as above
|
||||
if line =~ '\[[^]]*$'
|
||||
let ind = s:GetOffsetOf(line, '\[')
|
||||
endif
|
||||
|
||||
" if previous line had an unmatched closing parantheses,
|
||||
" indent to the matching opening parantheses
|
||||
if line =~ '[^(]*\\\@<!)$'
|
||||
call search(')', 'bW')
|
||||
let lnum = searchpair('\\\@<!(', '', ')', 'bWn')
|
||||
let ind = indent(lnum)
|
||||
endif
|
||||
|
||||
" if previous line had an unmatched closing bracket,
|
||||
" indent to the matching opening bracket
|
||||
if line =~ '[^[]*]$'
|
||||
call search(']', 'bW')
|
||||
let lnum = searchpair('\[', '', ']', 'bWn')
|
||||
let ind = indent(lnum)
|
||||
endif
|
||||
|
||||
return ind
|
||||
endfunction
|
||||
|
||||
" vim: set sts=2 sw=2:
|
||||
13
runtime/indent/cpp.vim
Normal file
13
runtime/indent/cpp.vim
Normal file
@ -0,0 +1,13 @@
|
||||
" Vim indent file
|
||||
" Language: C++
|
||||
" Maintainer: Bram Moolenaar <Bram@vim.org>
|
||||
" Last Change: 2001 Jun 12
|
||||
|
||||
" Only load this indent file when no other was loaded.
|
||||
if exists("b:did_indent")
|
||||
finish
|
||||
endif
|
||||
let b:did_indent = 1
|
||||
|
||||
" C++ indenting is built-in, thus this is very simple
|
||||
setlocal cindent
|
||||
13
runtime/indent/cs.vim
Normal file
13
runtime/indent/cs.vim
Normal file
@ -0,0 +1,13 @@
|
||||
" Vim indent file
|
||||
" Language: C#
|
||||
" Maintainer: Johannes Zellner <johannes@zellner.org>
|
||||
" Last Change: Fri, 15 Mar 2002 07:53:54 CET
|
||||
|
||||
" Only load this indent file when no other was loaded.
|
||||
if exists("b:did_indent")
|
||||
finish
|
||||
endif
|
||||
let b:did_indent = 1
|
||||
|
||||
" C# is like indenting C
|
||||
setlocal cindent
|
||||
79
runtime/indent/css.vim
Normal file
79
runtime/indent/css.vim
Normal file
@ -0,0 +1,79 @@
|
||||
" Vim indent file
|
||||
" Language: CSS
|
||||
" Maintainer: Nikolai Weibull <source@pcppopper.org>
|
||||
" URL: http://www.pcppopper.org/vim/indent/pcp/css/
|
||||
" Latest Revision: 2004-04-25
|
||||
" arch-tag: ccfd77a0-1c9a-43f7-a407-bbe704541442
|
||||
|
||||
" Only load this indent file when no other was loaded.
|
||||
if exists("b:did_indent")
|
||||
finish
|
||||
endif
|
||||
|
||||
let b:did_indent = 1
|
||||
|
||||
setlocal indentexpr=GetCSSIndent()
|
||||
setlocal indentkeys-=:,0# indentkeys-=e
|
||||
|
||||
" Only define the function once.
|
||||
if exists("*GetCSSIndent")
|
||||
finish
|
||||
endif
|
||||
|
||||
function! s:LookupLine(lnum)
|
||||
" find a non-blank line above the current line
|
||||
let lnum = prevnonblank(a:lnum - 1)
|
||||
|
||||
if lnum == 0
|
||||
return 0
|
||||
endif
|
||||
|
||||
let line = getline(lnum)
|
||||
|
||||
" if the line has an end comment sequence we need to find a line
|
||||
" that isn't affected by the comment.
|
||||
if line =~ '\*/'
|
||||
while line !~ '/\*'
|
||||
let lnum = lnum - 1
|
||||
let line = getline(lnum)
|
||||
endwhile
|
||||
endif
|
||||
|
||||
" if the line we found only contained the comment and whitespace
|
||||
" we need to find another line to use...
|
||||
if line =~ '^\s*/\*'
|
||||
return s:LookupLine(lnum)
|
||||
else
|
||||
return lnum
|
||||
endif
|
||||
endfunction
|
||||
|
||||
function GetCSSIndent()
|
||||
let lnum = s:LookupLine(v:lnum)
|
||||
|
||||
if lnum == 0
|
||||
return 0
|
||||
endif
|
||||
|
||||
" remove commented stuff from line
|
||||
let line = substitute(getline(lnum), '/\*.\*/', '', 'eg')
|
||||
|
||||
let ind = indent(lnum)
|
||||
|
||||
" check for opening brace on the previous line
|
||||
" skip if it also contains a closing brace...
|
||||
if line =~ '{\(.*}\)\@!'
|
||||
let ind = ind + &sw
|
||||
endif
|
||||
|
||||
let line = getline(v:lnum)
|
||||
|
||||
" check for closing brace first on current line
|
||||
if line =~ '^\s*}'
|
||||
let ind = ind - &sw
|
||||
endif
|
||||
|
||||
return ind
|
||||
endfunction
|
||||
|
||||
" vim: set sts=2 sw=2:
|
||||
13
runtime/indent/docbk.vim
Normal file
13
runtime/indent/docbk.vim
Normal file
@ -0,0 +1,13 @@
|
||||
" Vim indent file
|
||||
" Language: DocBook Documentation Format
|
||||
" Maintainer: Nikolai Weibull <source@pcppopper.org>
|
||||
" URL: http://www.pcppopper.org/vim/indent/pcp/docbk/
|
||||
" Latest Revision: 2004-05-22
|
||||
" arch-tag: 3d073af7-1d69-42a2-99ad-9a49a21eb28f
|
||||
|
||||
" Same as XML indenting for now.
|
||||
runtime! indent/xml.vim
|
||||
|
||||
setlocal indentexpr=XmlIndentGet(v:lnum,0)
|
||||
|
||||
" vim: set sts=2 sw=2:
|
||||
90
runtime/indent/dylan.vim
Normal file
90
runtime/indent/dylan.vim
Normal file
@ -0,0 +1,90 @@
|
||||
" Vim indent file
|
||||
" Language: Dylan
|
||||
" Version: 0.01
|
||||
" Last Change: 2003 Feb 04
|
||||
" Maintainer: Brent A. Fulgham <bfulgham@debian.org>
|
||||
|
||||
" Only load this indent file when no other was loaded.
|
||||
if exists("b:did_indent")
|
||||
finish
|
||||
endif
|
||||
let b:did_indent = 1
|
||||
|
||||
setlocal indentkeys+==~begin,=~block,=~case,=~cleanup,=~define,=~end,=~else,=~elseif,=~exception,=~for,=~finally,=~if,=~otherwise,=~select,=~unless,=~while
|
||||
|
||||
" Define the appropriate indent function but only once
|
||||
setlocal indentexpr=DylanGetIndent()
|
||||
if exists("*DylanGetIndent")
|
||||
finish
|
||||
endif
|
||||
|
||||
function DylanGetIndent()
|
||||
" Get the line to be indented
|
||||
let cline = getline(v:lnum)
|
||||
|
||||
" Don't reindent comments on first column
|
||||
if cline =~ '^/\[/\*]'
|
||||
return 0
|
||||
endif
|
||||
|
||||
"Find the previous non-blank line
|
||||
let lnum = prevnonblank(v:lnum - 1)
|
||||
"Use zero indent at the top of the file
|
||||
if lnum == 0
|
||||
return 0
|
||||
endif
|
||||
|
||||
let prevline=getline(lnum)
|
||||
let ind = indent(lnum)
|
||||
let chg = 0
|
||||
|
||||
" If previous line was a comment, use its indent
|
||||
if prevline =~ '^\s*//'
|
||||
return ind
|
||||
endif
|
||||
|
||||
" If previous line was a 'define', indent
|
||||
if prevline =~? '\(^\s*\(begin\|block\|case\|define\|else\|elseif\|for\|finally\|if\|select\|unless\|while\)\|\s*\S*\s*=>$\)'
|
||||
let chg = &sw
|
||||
" local methods indent the shift-width, plus 6 for the 'local'
|
||||
elseif prevline =~? '^\s*local'
|
||||
let chg = &sw + 6
|
||||
" If previous line was a let with no closing semicolon, indent
|
||||
elseif prevline =~? '^\s*let.*[^;]\s*$'
|
||||
let chg = &sw
|
||||
" If previous line opened a parenthesis, and did not close it, indent
|
||||
elseif prevline =~ '^.*(\s*[^)]*\((.*)\)*[^)]*$'
|
||||
return = match( prevline, '(.*\((.*)\|[^)]\)*.*$') + 1
|
||||
"elseif prevline =~ '^.*(\s*[^)]*\((.*)\)*[^)]*$'
|
||||
elseif prevline =~ '^[^(]*)\s*$'
|
||||
" This line closes a parenthesis. Find opening
|
||||
let curr_line = prevnonblank(lnum - 1)
|
||||
while curr_line >= 0
|
||||
let str = getline(curr_line)
|
||||
if str !~ '^.*(\s*[^)]*\((.*)\)*[^)]*$'
|
||||
let curr_line = prevnonblank(curr_line - 1)
|
||||
else
|
||||
break
|
||||
endif
|
||||
endwhile
|
||||
if curr_line < 0
|
||||
return -1
|
||||
endif
|
||||
let ind = indent(curr_line)
|
||||
" Although we found the closing parenthesis, make sure this
|
||||
" line doesn't start with an indentable command:
|
||||
let curr_str = getline(curr_line)
|
||||
if curr_str =~? '^\s*\(begin\|block\|case\|define\|else\|elseif\|for\|finally\|if\|select\|unless\|while\)'
|
||||
let chg = &sw
|
||||
endif
|
||||
endif
|
||||
|
||||
" If a line starts with end, un-indent (even if we just indented!)
|
||||
if cline =~? '^\s*\(cleanup\|end\|else\|elseif\|exception\|finally\|otherwise\)'
|
||||
let chg = chg - &sw
|
||||
endif
|
||||
|
||||
return ind + chg
|
||||
endfunction
|
||||
|
||||
" vim:sw=2 tw=130
|
||||
106
runtime/indent/eiffel.vim
Normal file
106
runtime/indent/eiffel.vim
Normal file
@ -0,0 +1,106 @@
|
||||
" Vim indent file
|
||||
" Language: Eiffel
|
||||
" Maintainer: David Clarke <gadicath@dishevelled.net>
|
||||
" $Date$
|
||||
" $Revision$
|
||||
" URL: http://gadicath.webhop.net/other/eiffel.vim
|
||||
|
||||
" Only load this indent file when no other was loaded.
|
||||
if exists("b:did_indent")
|
||||
finish
|
||||
endif
|
||||
let b:did_indent = 1
|
||||
|
||||
setlocal indentexpr=GetEiffelIndent()
|
||||
setlocal nolisp
|
||||
setlocal nosmartindent
|
||||
setlocal nocindent
|
||||
setlocal autoindent
|
||||
setlocal comments=:--
|
||||
setlocal indentkeys+==end,=else,=ensure,=require,=check,=loop,=until
|
||||
setlocal indentkeys+==creation,=feature,=inherit,=class,=is,=redefine,=rename,=variant
|
||||
setlocal indentkeys+==invariant,=do,=local,=export
|
||||
setlocal sw=3
|
||||
setlocal tw=78
|
||||
|
||||
" Define some stuff
|
||||
" keywords grouped by indenting
|
||||
let s:trust_user_indent = '\(+\)\(\s*\(--\).*\)\=$'
|
||||
let s:relative_indent = '^\s*\(deferred\|class\|feature\|creation\|inherit\|loop\|from\|until\|if\|else\|elseif\|ensure\|require\|check\|do\|local\|invariant\|variant\|rename\|redefine\|do\|export\)\>'
|
||||
let s:outdent = '^\s*\(else\|invariant\|variant\|do\|require\|until\|loop\|local\)\>'
|
||||
let s:no_indent = '^\s*\(class\|feature\|creation\|inherit\)\>'
|
||||
let s:single_dent = '^[^-]\+[[:alnum:]]\+ is\(\s*\(--\).*\)\=$'
|
||||
let s:inheritance_dent = '\s*\(redefine\|rename\|export\)\>'
|
||||
|
||||
|
||||
" Only define the function once.
|
||||
if exists("*GetEiffelIndent")
|
||||
finish
|
||||
endif
|
||||
|
||||
function GetEiffelIndent()
|
||||
|
||||
" Eiffel Class indenting
|
||||
"
|
||||
" Find a non-blank line above the current line.
|
||||
let lnum = prevnonblank(v:lnum - 1)
|
||||
|
||||
" At the start of the file use zero indent.
|
||||
if lnum == 0
|
||||
return 0
|
||||
endif
|
||||
|
||||
" trust the user's indenting
|
||||
if getline(lnum) =~ s:trust_user_indent
|
||||
return -1
|
||||
endif
|
||||
|
||||
" Add a 'shiftwidth' after lines that start with an indent word
|
||||
let ind = indent(lnum)
|
||||
if getline(lnum) =~ s:relative_indent
|
||||
let ind = ind + &sw
|
||||
endif
|
||||
|
||||
" Indent to single indent
|
||||
if getline(v:lnum) =~ s:single_dent && getline(v:lnum) !~ s:relative_indent
|
||||
\ && getline(v:lnum) !~ '\s*\<\(and\|or\|implies\)\>'
|
||||
let ind = &sw
|
||||
endif
|
||||
|
||||
" Indent to double indent
|
||||
if getline(v:lnum) =~ s:inheritance_dent
|
||||
let ind = 2 * &sw
|
||||
endif
|
||||
|
||||
" Indent line after the first line of the function definition
|
||||
if getline(lnum) =~ s:single_dent
|
||||
let ind = ind + &sw
|
||||
endif
|
||||
|
||||
" The following should always be at the start of a line, no indenting
|
||||
if getline(v:lnum) =~ s:no_indent
|
||||
let ind = 0
|
||||
endif
|
||||
|
||||
" Subtract a 'shiftwidth', if this isn't the first thing after the 'is'
|
||||
" or first thing after the 'do'
|
||||
if getline(v:lnum) =~ s:outdent && getline(v:lnum - 1) !~ s:single_dent
|
||||
\ && getline(v:lnum - 1) !~ '^\s*do\>'
|
||||
let ind = ind - &sw
|
||||
endif
|
||||
|
||||
" Subtract a shiftwidth for end statements
|
||||
if getline(v:lnum) =~ '^\s*end\>'
|
||||
let ind = ind - &sw
|
||||
endif
|
||||
|
||||
" set indent of zero end statements that are at an indent of 3, this should
|
||||
" only ever be the class's end.
|
||||
if getline(v:lnum) =~ '^\s*end\>' && ind == 3
|
||||
let ind = 0
|
||||
endif
|
||||
|
||||
return ind
|
||||
endfunction
|
||||
|
||||
" vim:sw=2
|
||||
49
runtime/indent/eterm.vim
Normal file
49
runtime/indent/eterm.vim
Normal file
@ -0,0 +1,49 @@
|
||||
" Vim indent file
|
||||
" Language: Eterm configuration file
|
||||
" Maintainer: Nikolai Weibull <source@pcppopper.org>
|
||||
" URL: http://www.pcppopper.org/vim/indent/pcp/eterm/
|
||||
" Latest Revision: 2004-04-25
|
||||
" arch-tag: a22a92b1-c59f-4f47-8207-b21db6549b21
|
||||
|
||||
" Only load this indent file when no other was loaded.
|
||||
if exists("b:did_indent")
|
||||
finish
|
||||
endif
|
||||
|
||||
let b:did_indent = 1
|
||||
|
||||
setlocal indentexpr=GetEtermIndent()
|
||||
setlocal indentkeys=!^F,o,O,=end
|
||||
|
||||
" Only define the function once.
|
||||
if exists("*GetEtermIndent")
|
||||
finish
|
||||
endif
|
||||
|
||||
function GetEtermIndent()
|
||||
" Find a non-blank line above the current line.
|
||||
let lnum = prevnonblank(v:lnum - 1)
|
||||
|
||||
" Hit the start of the file, use zero indent.
|
||||
if lnum == 0
|
||||
return 0
|
||||
endif
|
||||
|
||||
let line = getline(lnum)
|
||||
let ind = indent(lnum)
|
||||
|
||||
if line =~ '^\s*begin\>'
|
||||
let ind = ind + &sw
|
||||
endif
|
||||
|
||||
let line = getline(v:lnum)
|
||||
|
||||
" Check for closing brace on current line
|
||||
if line =~ '^\s*end\>'
|
||||
let ind = ind - &sw
|
||||
endif
|
||||
|
||||
return ind
|
||||
endfunction
|
||||
|
||||
" vim: set sts=2 sw=2:
|
||||
161
runtime/indent/fortran.vim
Normal file
161
runtime/indent/fortran.vim
Normal file
@ -0,0 +1,161 @@
|
||||
" Vim indent file
|
||||
" Language: Fortran95 (and Fortran90, Fortran77, F and elf90)
|
||||
" Version: 0.36
|
||||
" URL: http://www.unb.ca/chem/ajit/indent/fortran.vim
|
||||
" Last Change: 2004 Apr. 05
|
||||
" Maintainer: Ajit J. Thakkar <ajit@unb.ca>; <http://www.unb.ca/chem/ajit/>
|
||||
" Usage: Do :help fortran-indent from Vim
|
||||
|
||||
" Only load this indent file when no other was loaded.
|
||||
if exists("b:did_indent")
|
||||
finish
|
||||
endif
|
||||
let b:did_indent = 1
|
||||
|
||||
let s:cposet=&cpoptions
|
||||
set cpoptions-=C
|
||||
|
||||
setlocal indentkeys+==~end,=~case,=~if,=~else,=~do,=~where,=~elsewhere,=~select
|
||||
setlocal indentkeys+==~endif,=~enddo,=~endwhere,=~endselect
|
||||
|
||||
" Determine whether this is a fixed or free format source file
|
||||
" if this hasn't been done yet
|
||||
if !exists("b:fortran_fixed_source")
|
||||
if exists("fortran_free_source")
|
||||
" User guarantees free source form
|
||||
let b:fortran_fixed_source = 0
|
||||
elseif exists("fortran_fixed_source")
|
||||
" User guarantees fixed source form
|
||||
let b:fortran_fixed_source = 1
|
||||
else
|
||||
" f90 and f95 allow both fixed and free source form
|
||||
" assume fixed source form unless signs of free source form
|
||||
" are detected in the first five columns of the first 25 lines
|
||||
" Detection becomes more accurate and time-consuming if more lines
|
||||
" are checked. Increase the limit below if you keep lots of comments at
|
||||
" the very top of each file and you have a fast computer
|
||||
let s:lmax = 25
|
||||
if ( s:lmax > line("$") )
|
||||
let s:lmax = line("$")
|
||||
endif
|
||||
let b:fortran_fixed_source = 1
|
||||
let s:ln=1
|
||||
while s:ln <= s:lmax
|
||||
let s:test = strpart(getline(s:ln),0,5)
|
||||
if s:test[0] !~ '[Cc*!#]' && s:test !~ '^ \+[!#]' && s:test =~ '[^ 0-9\t]'
|
||||
let b:fortran_fixed_source = 0
|
||||
break
|
||||
endif
|
||||
let s:ln = s:ln + 1
|
||||
endwhile
|
||||
endif
|
||||
endif
|
||||
|
||||
" Define the appropriate indent function but only once
|
||||
if (b:fortran_fixed_source == 1)
|
||||
setlocal indentexpr=FortranGetFixedIndent()
|
||||
if exists("*FortranGetFixedIndent")
|
||||
finish
|
||||
endif
|
||||
else
|
||||
setlocal indentexpr=FortranGetFreeIndent()
|
||||
if exists("*FortranGetFreeIndent")
|
||||
finish
|
||||
endif
|
||||
endif
|
||||
|
||||
function FortranGetIndent(lnum)
|
||||
let ind = indent(a:lnum)
|
||||
let prevline=getline(a:lnum)
|
||||
" Strip tail comment
|
||||
let prevstat=substitute(prevline, '!.*$', '', '')
|
||||
|
||||
"Indent do loops only if they are all guaranteed to be of do/end do type
|
||||
if exists("b:fortran_do_enddo") || exists("fortran_do_enddo")
|
||||
if prevstat =~? '^\s*\(\d\+\s\)\=\s*\(\a\w*\s*:\)\=\s*do\>'
|
||||
let ind = ind + &sw
|
||||
endif
|
||||
if getline(v:lnum) =~? '^\s*\(\d\+\s\)\=\s*end\s*do\>'
|
||||
let ind = ind - &sw
|
||||
endif
|
||||
endif
|
||||
|
||||
"Add a shiftwidth to statements following if, else, case,
|
||||
"where and elsewhere statements
|
||||
if prevstat =~? '^\s*\(\d\+\s\)\=\s*\(else\|case\|where\|elsewhere\)\>'
|
||||
\ || prevstat =~? '^\s*\(\d\+\s\)\=\s*\(\a\w*\s*:\)\=\s*if\>'
|
||||
let ind = ind + &sw
|
||||
" Remove unwanted indent after logical and arithmetic ifs
|
||||
if prevstat =~? '\<if\>' && prevstat !~? '\<then\>'
|
||||
let ind = ind - &sw
|
||||
endif
|
||||
endif
|
||||
|
||||
"Subtract a shiftwidth from else, elsewhere, case, end if,
|
||||
" end where and end select statements
|
||||
if getline(v:lnum) =~? '^\s*\(\d\+\s\)\=\s*'
|
||||
\. '\(else\|elsewhere\|case\|end\s*\(if\|where\|select\)\)\>'
|
||||
let ind = ind - &sw
|
||||
" Fix indent for case statement immediately after select
|
||||
if prevstat =~? '\<select\>'
|
||||
let ind = ind + &sw
|
||||
endif
|
||||
endif
|
||||
|
||||
return ind
|
||||
endfunction
|
||||
|
||||
function FortranGetFreeIndent()
|
||||
"Find the previous non-blank line
|
||||
let lnum = prevnonblank(v:lnum - 1)
|
||||
|
||||
"Use zero indent at the top of the file
|
||||
if lnum == 0
|
||||
return 0
|
||||
endif
|
||||
|
||||
let ind=FortranGetIndent(lnum)
|
||||
return ind
|
||||
endfunction
|
||||
|
||||
function FortranGetFixedIndent()
|
||||
let currline=getline(v:lnum)
|
||||
"Don't indent comments, continuation lines and labelled lines
|
||||
if strpart(currline,0,6) =~ '[^ \t]'
|
||||
let ind = indent(v:lnum)
|
||||
return ind
|
||||
endif
|
||||
|
||||
"Find the previous line which is not blank, not a comment,
|
||||
"not a continuation line, and does not have a label
|
||||
let lnum = v:lnum - 1
|
||||
while lnum > 0
|
||||
let prevline=getline(lnum)
|
||||
if (prevline =~ "^[C*!]") || (prevline =~ "^\s*$")
|
||||
\ || (strpart(prevline,5,1) !~ "[ 0]")
|
||||
" Skip comments, blank lines and continuation lines
|
||||
let lnum = lnum - 1
|
||||
else
|
||||
let test=strpart(prevline,0,5)
|
||||
if test =~ "[0-9]"
|
||||
" Skip lines with statement numbers
|
||||
let lnum = lnum - 1
|
||||
else
|
||||
break
|
||||
endif
|
||||
endif
|
||||
endwhile
|
||||
|
||||
"First line must begin at column 7
|
||||
if lnum == 0
|
||||
return 6
|
||||
endif
|
||||
|
||||
let ind=FortranGetIndent(lnum)
|
||||
return ind
|
||||
endfunction
|
||||
|
||||
let &cpoptions=s:cposet
|
||||
unlet s:cposet
|
||||
|
||||
" vim:sw=2 tw=130
|
||||
219
runtime/indent/html.vim
Normal file
219
runtime/indent/html.vim
Normal file
@ -0,0 +1,219 @@
|
||||
" Description: html indenter
|
||||
" Author: Johannes Zellner <johannes@zellner.org>
|
||||
" Last Change: Tue, 27 Apr 2004 10:28:39 CEST
|
||||
" Globals: g:html_indent_tags -- indenting tags
|
||||
" g:html_indent_strict -- inhibit 'O O' elements
|
||||
" g:html_indent_strict_table -- inhibit 'O -' elements
|
||||
|
||||
" Only load this indent file when no other was loaded.
|
||||
if exists("b:did_indent")
|
||||
finish
|
||||
endif
|
||||
let b:did_indent = 1
|
||||
|
||||
|
||||
" [-- local settings (must come before aborting the script) --]
|
||||
setlocal indentexpr=HtmlIndentGet(v:lnum)
|
||||
setlocal indentkeys=o,O,*<Return>,<>>,<bs>,{,}
|
||||
|
||||
|
||||
if exists('g:html_indent_tags')
|
||||
unlet g:html_indent_tags
|
||||
endif
|
||||
|
||||
" [-- helper function to assemble tag list --]
|
||||
fun! <SID>HtmlIndentPush(tag)
|
||||
if exists('g:html_indent_tags')
|
||||
let g:html_indent_tags = g:html_indent_tags.'\|'.a:tag
|
||||
else
|
||||
let g:html_indent_tags = a:tag
|
||||
endif
|
||||
endfun
|
||||
|
||||
|
||||
" [-- <ELEMENT ? - - ...> --]
|
||||
call <SID>HtmlIndentPush('a')
|
||||
call <SID>HtmlIndentPush('abbr')
|
||||
call <SID>HtmlIndentPush('acronym')
|
||||
call <SID>HtmlIndentPush('address')
|
||||
call <SID>HtmlIndentPush('b')
|
||||
call <SID>HtmlIndentPush('bdo')
|
||||
call <SID>HtmlIndentPush('big')
|
||||
call <SID>HtmlIndentPush('blockquote')
|
||||
call <SID>HtmlIndentPush('button')
|
||||
call <SID>HtmlIndentPush('caption')
|
||||
call <SID>HtmlIndentPush('center')
|
||||
call <SID>HtmlIndentPush('cite')
|
||||
call <SID>HtmlIndentPush('code')
|
||||
call <SID>HtmlIndentPush('colgroup')
|
||||
call <SID>HtmlIndentPush('del')
|
||||
call <SID>HtmlIndentPush('dfn')
|
||||
call <SID>HtmlIndentPush('dir')
|
||||
call <SID>HtmlIndentPush('div')
|
||||
call <SID>HtmlIndentPush('dl')
|
||||
call <SID>HtmlIndentPush('em')
|
||||
call <SID>HtmlIndentPush('fieldset')
|
||||
call <SID>HtmlIndentPush('font')
|
||||
call <SID>HtmlIndentPush('form')
|
||||
call <SID>HtmlIndentPush('frameset')
|
||||
call <SID>HtmlIndentPush('h1')
|
||||
call <SID>HtmlIndentPush('h2')
|
||||
call <SID>HtmlIndentPush('h3')
|
||||
call <SID>HtmlIndentPush('h4')
|
||||
call <SID>HtmlIndentPush('h5')
|
||||
call <SID>HtmlIndentPush('h6')
|
||||
call <SID>HtmlIndentPush('i')
|
||||
call <SID>HtmlIndentPush('iframe')
|
||||
call <SID>HtmlIndentPush('ins')
|
||||
call <SID>HtmlIndentPush('kbd')
|
||||
call <SID>HtmlIndentPush('label')
|
||||
call <SID>HtmlIndentPush('legend')
|
||||
call <SID>HtmlIndentPush('map')
|
||||
call <SID>HtmlIndentPush('menu')
|
||||
call <SID>HtmlIndentPush('noframes')
|
||||
call <SID>HtmlIndentPush('noscript')
|
||||
call <SID>HtmlIndentPush('object')
|
||||
call <SID>HtmlIndentPush('ol')
|
||||
call <SID>HtmlIndentPush('optgroup')
|
||||
" call <SID>HtmlIndentPush('pre')
|
||||
call <SID>HtmlIndentPush('q')
|
||||
call <SID>HtmlIndentPush('s')
|
||||
call <SID>HtmlIndentPush('samp')
|
||||
call <SID>HtmlIndentPush('script')
|
||||
call <SID>HtmlIndentPush('select')
|
||||
call <SID>HtmlIndentPush('small')
|
||||
call <SID>HtmlIndentPush('span')
|
||||
call <SID>HtmlIndentPush('strong')
|
||||
call <SID>HtmlIndentPush('style')
|
||||
call <SID>HtmlIndentPush('sub')
|
||||
call <SID>HtmlIndentPush('sup')
|
||||
call <SID>HtmlIndentPush('table')
|
||||
call <SID>HtmlIndentPush('textarea')
|
||||
call <SID>HtmlIndentPush('title')
|
||||
call <SID>HtmlIndentPush('tt')
|
||||
call <SID>HtmlIndentPush('u')
|
||||
call <SID>HtmlIndentPush('ul')
|
||||
call <SID>HtmlIndentPush('var')
|
||||
|
||||
|
||||
" [-- <ELEMENT ? O O ...> --]
|
||||
if !exists('g:html_indent_strict')
|
||||
call <SID>HtmlIndentPush('body')
|
||||
call <SID>HtmlIndentPush('head')
|
||||
call <SID>HtmlIndentPush('html')
|
||||
call <SID>HtmlIndentPush('tbody')
|
||||
endif
|
||||
|
||||
|
||||
" [-- <ELEMENT ? O - ...> --]
|
||||
if !exists('g:html_indent_strict_table')
|
||||
call <SID>HtmlIndentPush('th')
|
||||
call <SID>HtmlIndentPush('td')
|
||||
call <SID>HtmlIndentPush('tr')
|
||||
call <SID>HtmlIndentPush('tfoot')
|
||||
call <SID>HtmlIndentPush('thead')
|
||||
endif
|
||||
|
||||
delfun <SID>HtmlIndentPush
|
||||
|
||||
set cpo-=C
|
||||
|
||||
" [-- count indent-increasing tags of line a:lnum --]
|
||||
fun! <SID>HtmlIndentOpen(lnum, pattern)
|
||||
let s = substitute('x'.getline(a:lnum),
|
||||
\ '.\{-}\(\(<\)\('.a:pattern.'\)\>\)', "\1", 'g')
|
||||
let s = substitute(s, "[^\1].*$", '', '')
|
||||
return strlen(s)
|
||||
endfun
|
||||
|
||||
" [-- count indent-decreasing tags of line a:lnum --]
|
||||
fun! <SID>HtmlIndentClose(lnum, pattern)
|
||||
let s = substitute('x'.getline(a:lnum),
|
||||
\ '.\{-}\(\(<\)/\('.a:pattern.'\)\>>\)', "\1", 'g')
|
||||
let s = substitute(s, "[^\1].*$", '', '')
|
||||
return strlen(s)
|
||||
endfun
|
||||
|
||||
" [-- count indent-increasing '{' of (java|css) line a:lnum --]
|
||||
fun! <SID>HtmlIndentOpenAlt(lnum)
|
||||
return strlen(substitute(getline(a:lnum), '[^{]\+', '', 'g'))
|
||||
endfun
|
||||
|
||||
" [-- count indent-decreasing '}' of (java|css) line a:lnum --]
|
||||
fun! <SID>HtmlIndentCloseAlt(lnum)
|
||||
return strlen(substitute(getline(a:lnum), '[^}]\+', '', 'g'))
|
||||
endfun
|
||||
|
||||
" [-- return the sum of indents respecting the syntax of a:lnum --]
|
||||
fun! <SID>HtmlIndentSum(lnum, style)
|
||||
if a:style == match(getline(a:lnum), '^\s*</')
|
||||
if a:style == match(getline(a:lnum), '^\s*</\<\('.g:html_indent_tags.'\)\>')
|
||||
let open = <SID>HtmlIndentOpen(a:lnum, g:html_indent_tags)
|
||||
let close = <SID>HtmlIndentClose(a:lnum, g:html_indent_tags)
|
||||
if 0 != open || 0 != close
|
||||
return open - close
|
||||
endif
|
||||
endif
|
||||
endif
|
||||
if '' != &syntax &&
|
||||
\ synIDattr(synID(a:lnum, 1, 1), 'name') =~ '\(css\|java\).*' &&
|
||||
\ synIDattr(synID(a:lnum, strlen(getline(a:lnum)), 1), 'name')
|
||||
\ =~ '\(css\|java\).*'
|
||||
if a:style == match(getline(a:lnum), '^\s*}')
|
||||
return <SID>HtmlIndentOpenAlt(a:lnum) - <SID>HtmlIndentCloseAlt(a:lnum)
|
||||
endif
|
||||
endif
|
||||
return 0
|
||||
endfun
|
||||
|
||||
fun! HtmlIndentGet(lnum)
|
||||
" Find a non-empty line above the current line.
|
||||
let lnum = prevnonblank(a:lnum - 1)
|
||||
|
||||
" Hit the start of the file, use zero indent.
|
||||
if lnum == 0
|
||||
return 0
|
||||
endif
|
||||
|
||||
let restore_ic = &ic
|
||||
setlocal ic " ignore case
|
||||
|
||||
" [-- special handling for <pre>: no indenting --]
|
||||
if getline(a:lnum) =~ '\c</pre>'
|
||||
\ || 0 < searchpair('\c<pre>', '', '\c</pre>', 'nWb')
|
||||
\ || 0 < searchpair('\c<pre>', '', '\c</pre>', 'nW')
|
||||
" we're in a line with </pre> or inside <pre> ... </pre>
|
||||
return -1
|
||||
endif
|
||||
|
||||
" [-- special handling for <javascript>: use cindent --]
|
||||
let js = '<script.*type\s*=\s*.*java'
|
||||
if 0 < searchpair(js, '', '</script>', 'nWb')
|
||||
\ || 0 < searchpair(js, '', '</script>', 'nW')
|
||||
" we're inside javascript
|
||||
if getline(lnum) !~ js && getline(a:lnum) != '</script>'
|
||||
return cindent(a:lnum)
|
||||
endif
|
||||
endif
|
||||
|
||||
if getline(lnum) =~ '\c</pre>'
|
||||
" line before the current line a:lnum contains
|
||||
" a closing </pre>. --> search for line before
|
||||
" starting <pre> to restore the indent.
|
||||
let preline = prevnonblank(search('\c<pre>', 'bW') - 1)
|
||||
if preline > 0
|
||||
return indent(preline)
|
||||
endif
|
||||
endif
|
||||
|
||||
let ind = <SID>HtmlIndentSum(lnum, -1)
|
||||
let ind = ind + <SID>HtmlIndentSum(a:lnum, 0)
|
||||
|
||||
if restore_ic == 0
|
||||
setlocal noic
|
||||
endif
|
||||
|
||||
return indent(lnum) + (&sw * ind)
|
||||
endfun
|
||||
|
||||
" [-- EOF <runtime>/indent/html.vim --]
|
||||
63
runtime/indent/idlang.vim
Normal file
63
runtime/indent/idlang.vim
Normal file
@ -0,0 +1,63 @@
|
||||
" IDL (Interactive Data Language) indent file.
|
||||
" Language: IDL (ft=idlang)
|
||||
" Last change: 2002 Sep 23
|
||||
" Maintainer: Aleksandar Jelenak <ajelenak AT yahoo.com>
|
||||
|
||||
" Only load this indent file when no other was loaded.
|
||||
if exists("b:did_indent")
|
||||
finish
|
||||
endif
|
||||
let b:did_indent = 1
|
||||
|
||||
setlocal indentkeys=o,O,0=endif,0=ENDIF,0=endelse,0=ENDELSE,0=endwhile,
|
||||
\0=ENDWHILE,0=endfor,0=ENDFOR,0=endrep,0=ENDREP
|
||||
|
||||
setlocal indentexpr=GetIdlangIndent(v:lnum)
|
||||
|
||||
" Only define the function once.
|
||||
if exists("*GetIdlangIndent")
|
||||
finish
|
||||
endif
|
||||
|
||||
function GetIdlangIndent(lnum)
|
||||
" First non-empty line above the current line.
|
||||
let pnum = prevnonblank(v:lnum-1)
|
||||
" v:lnum is the first non-empty line -- zero indent.
|
||||
if pnum == 0
|
||||
return 0
|
||||
endif
|
||||
" Second non-empty line above the current line.
|
||||
let pnum2 = prevnonblank(pnum-1)
|
||||
|
||||
" Current indent.
|
||||
let curind = indent(pnum)
|
||||
|
||||
" Indenting of continued lines.
|
||||
if getline(pnum) =~ '\$\s*\(;.*\)\=$'
|
||||
if getline(pnum2) !~ '\$\s*\(;.*\)\=$'
|
||||
let curind = curind+&sw
|
||||
endif
|
||||
else
|
||||
if getline(pnum2) =~ '\$\s*\(;.*\)\=$'
|
||||
let curind = curind-&sw
|
||||
endif
|
||||
endif
|
||||
|
||||
" Indenting blocks of statements.
|
||||
if getline(v:lnum) =~? '^\s*\(endif\|endelse\|endwhile\|endfor\|endrep\)\>'
|
||||
if getline(pnum) =~? 'begin\>'
|
||||
elseif indent(v:lnum) > curind-&sw
|
||||
let curind = curind-&sw
|
||||
else
|
||||
return -1
|
||||
endif
|
||||
elseif getline(pnum) =~? 'begin\>'
|
||||
if indent(v:lnum) < curind+&sw
|
||||
let curind = curind+&sw
|
||||
else
|
||||
return -1
|
||||
endif
|
||||
endif
|
||||
return curind
|
||||
endfunction
|
||||
|
||||
65
runtime/indent/ishd.vim
Normal file
65
runtime/indent/ishd.vim
Normal file
@ -0,0 +1,65 @@
|
||||
" Description: InstallShield indenter
|
||||
" Author: Johannes Zellner <johannes@zellner.org>
|
||||
" Last Change: Tue, 27 Apr 2004 14:54:59 CEST
|
||||
|
||||
" Only load this indent file when no other was loaded.
|
||||
if exists("b:did_indent")
|
||||
finish
|
||||
endif
|
||||
let b:did_indent = 1
|
||||
|
||||
setlocal indentexpr=GetIshdIndent(v:lnum)
|
||||
setlocal indentkeys&
|
||||
setlocal indentkeys+==else,=elseif,=endif,=end,=begin,<:>
|
||||
" setlocal indentkeys-=0#
|
||||
|
||||
" Only define the function once.
|
||||
if exists("*GetIshdIndent")
|
||||
finish
|
||||
endif
|
||||
|
||||
fun! GetIshdIndent(lnum)
|
||||
" labels and preprocessor get zero indent immediately
|
||||
let this_line = getline(a:lnum)
|
||||
let LABELS_OR_PREPROC = '^\s*\(\<\k\+\>:\s*$\|#.*\)'
|
||||
let LABELS_OR_PREPROC_EXCEPT = '^\s*\<default\+\>:'
|
||||
if this_line =~ LABELS_OR_PREPROC && this_line !~ LABELS_OR_PREPROC_EXCEPT
|
||||
return 0
|
||||
endif
|
||||
|
||||
" Find a non-blank line above the current line.
|
||||
" Skip over labels and preprocessor directives.
|
||||
let lnum = a:lnum
|
||||
while lnum > 0
|
||||
let lnum = prevnonblank(lnum - 1)
|
||||
let previous_line = getline(lnum)
|
||||
if previous_line !~ LABELS_OR_PREPROC || previous_line =~ LABELS_OR_PREPROC_EXCEPT
|
||||
break
|
||||
endif
|
||||
endwhile
|
||||
|
||||
" Hit the start of the file, use zero indent.
|
||||
if lnum == 0
|
||||
return 0
|
||||
endif
|
||||
|
||||
let ind = indent(lnum)
|
||||
|
||||
" Add
|
||||
if previous_line =~ '^\s*\<\(function\|begin\|switch\|case\|default\|if.\{-}then\|else\|elseif\|while\|repeat\)\>'
|
||||
let ind = ind + &sw
|
||||
endif
|
||||
|
||||
" Subtract
|
||||
if this_line =~ '^\s*\<endswitch\>'
|
||||
let ind = ind - 2 * &sw
|
||||
elseif this_line =~ '^\s*\<\(begin\|end\|endif\|endwhile\|else\|elseif\|until\)\>'
|
||||
let ind = ind - &sw
|
||||
elseif this_line =~ '^\s*\<\(case\|default\)\>'
|
||||
if previous_line !~ '^\s*\<switch\>'
|
||||
let ind = ind - &sw
|
||||
endif
|
||||
endif
|
||||
|
||||
return ind
|
||||
endfun
|
||||
128
runtime/indent/java.vim
Normal file
128
runtime/indent/java.vim
Normal file
@ -0,0 +1,128 @@
|
||||
" Vim indent file
|
||||
" Language: Java
|
||||
" Maintainer: Toby Allsopp <toby.allsopp@peace.com>
|
||||
" Last Change: 2003 Oct 21
|
||||
|
||||
" Only load this indent file when no other was loaded.
|
||||
if exists("b:did_indent")
|
||||
finish
|
||||
endif
|
||||
let b:did_indent = 1
|
||||
|
||||
" Indent Java anonymous classes correctly.
|
||||
setlocal cinoptions& cinoptions+=j1
|
||||
|
||||
" The "extends" and "implements" lines start off with the wrong indent.
|
||||
setlocal indentkeys& indentkeys+=0=extends indentkeys+=0=implements
|
||||
|
||||
" Set the function to do the work.
|
||||
setlocal indentexpr=GetJavaIndent()
|
||||
|
||||
" Only define the function once.
|
||||
if exists("*GetJavaIndent")
|
||||
finish
|
||||
endif
|
||||
|
||||
function! SkipJavaBlanksAndComments(startline)
|
||||
let lnum = a:startline
|
||||
while lnum > 1
|
||||
let lnum = prevnonblank(lnum)
|
||||
if getline(lnum) =~ '\*/\s*$'
|
||||
while getline(lnum) !~ '/\*' && lnum > 1
|
||||
let lnum = lnum - 1
|
||||
endwhile
|
||||
if getline(lnum) =~ '^\s*/\*'
|
||||
let lnum = lnum - 1
|
||||
else
|
||||
break
|
||||
endif
|
||||
elseif getline(lnum) =~ '^\s*//'
|
||||
let lnum = lnum - 1
|
||||
else
|
||||
break
|
||||
endif
|
||||
endwhile
|
||||
return lnum
|
||||
endfunction
|
||||
|
||||
function GetJavaIndent()
|
||||
|
||||
" Java is just like C; use the built-in C indenting and then correct a few
|
||||
" specific cases.
|
||||
let theIndent = cindent(v:lnum)
|
||||
|
||||
" If we're in the middle of a comment then just trust cindent
|
||||
if getline(v:lnum) =~ '^\s*\*'
|
||||
return theIndent
|
||||
endif
|
||||
|
||||
" find start of previous line, in case it was a continuation line
|
||||
let lnum = SkipJavaBlanksAndComments(v:lnum - 1)
|
||||
let prev = lnum
|
||||
while prev > 1
|
||||
let next_prev = SkipJavaBlanksAndComments(prev - 1)
|
||||
if getline(next_prev) !~ ',\s*$'
|
||||
break
|
||||
endif
|
||||
let prev = next_prev
|
||||
endwhile
|
||||
|
||||
" Try to align "throws" lines for methods and "extends" and "implements" for
|
||||
" classes.
|
||||
if getline(v:lnum) =~ '^\s*\(extends\|implements\)\>'
|
||||
\ && getline(lnum) !~ '^\s*\(extends\|implements\)\>'
|
||||
let theIndent = theIndent + &sw
|
||||
endif
|
||||
|
||||
" correct for continuation lines of "throws", "implements" and "extends"
|
||||
let cont_kw = matchstr(getline(prev),
|
||||
\ '^\s*\zs\(throws\|implements\|extends\)\>\ze.*,\s*$')
|
||||
if strlen(cont_kw) > 0
|
||||
let amount = strlen(cont_kw) + 1
|
||||
if getline(lnum) !~ ',\s*$'
|
||||
let theIndent = theIndent - (amount + &sw)
|
||||
if theIndent < 0
|
||||
let theIndent = 0
|
||||
endif
|
||||
elseif prev == lnum
|
||||
let theIndent = theIndent + amount
|
||||
if cont_kw ==# 'throws'
|
||||
let theIndent = theIndent + &sw
|
||||
endif
|
||||
endif
|
||||
elseif getline(prev) =~ '^\s*\(throws\|implements\|extends\)\>'
|
||||
\ && (getline(prev) =~ '{\s*$'
|
||||
\ || getline(v:lnum) =~ '^\s*{\s*$')
|
||||
let theIndent = theIndent - &sw
|
||||
endif
|
||||
|
||||
" When the line starts with a }, try aligning it with the matching {,
|
||||
" skipping over "throws", "extends" and "implements" clauses.
|
||||
if getline(v:lnum) =~ '^\s*}\s*\(//.*\|/\*.*\)\=$'
|
||||
call cursor(v:lnum, 1)
|
||||
silent normal %
|
||||
let lnum = line('.')
|
||||
if lnum < v:lnum
|
||||
while lnum > 1
|
||||
let next_lnum = SkipJavaBlanksAndComments(lnum - 1)
|
||||
if getline(lnum) !~ '^\s*\(throws\|extends\|implements\)\>'
|
||||
\ && getline(next_lnum) !~ ',\s*$'
|
||||
break
|
||||
endif
|
||||
let lnum = prevnonblank(next_lnum)
|
||||
endwhile
|
||||
return indent(lnum)
|
||||
endif
|
||||
endif
|
||||
|
||||
" Below a line starting with "}" never indent more. Needed for a method
|
||||
" below a method with an indented "throws" clause.
|
||||
let lnum = SkipJavaBlanksAndComments(v:lnum - 1)
|
||||
if getline(lnum) =~ '^\s*}\s*\(//.*\|/\*.*\)\=$' && indent(lnum) < theIndent
|
||||
let theIndent = indent(lnum)
|
||||
endif
|
||||
|
||||
return theIndent
|
||||
endfunction
|
||||
|
||||
" vi: sw=2 et
|
||||
49
runtime/indent/lua.vim
Normal file
49
runtime/indent/lua.vim
Normal file
@ -0,0 +1,49 @@
|
||||
" Vim indent file
|
||||
" Language: Lua script
|
||||
" Maintainer: Marcus Aurelius Farias <marcuscf@vant.com.br>
|
||||
" First Author: Max Ischenko <mfi@ukr.net>
|
||||
" Last Change: 2003 Jan 20
|
||||
|
||||
" Only define the function once.
|
||||
if exists("*GetLuaIndent") | finish | endif
|
||||
|
||||
setlocal indentexpr=GetLuaIndent()
|
||||
|
||||
" To make Vim call GetLuaIndent() when it finds '\s*end' or '\s*until'
|
||||
" on the current line (else is default).
|
||||
setlocal indentkeys+=0=end,0=until
|
||||
|
||||
setlocal autoindent
|
||||
|
||||
function! GetLuaIndent()
|
||||
" Find a non-blank line above the current line.
|
||||
let lnum = prevnonblank(v:lnum - 1)
|
||||
|
||||
" Hit the start of the file, use zero indent.
|
||||
if lnum == 0
|
||||
return 0
|
||||
endif
|
||||
|
||||
" Add a 'shiftwidth' after lines beginning with:
|
||||
" function, if, for, while, repeat, else, elseif, '{'
|
||||
let ind = indent(lnum)
|
||||
let flag = 0
|
||||
if getline(lnum) =~ '^\s*\(function\>\|if\>\|for\>\|while\>\|repeat\>\|else\>\|elseif\>\|do\>\)' || getline(lnum) =~ '{\s*$' || getline(lnum) =~ '\s*=\s*function'
|
||||
let ind = ind + &sw
|
||||
let flag = 1
|
||||
endif
|
||||
|
||||
" Subtract a 'shiftwidth' after lines ending with
|
||||
" 'end' when they begin with while, if, for, etc.
|
||||
if flag == 1 && getline(lnum) =~ '\<end\>\|\<until\>'
|
||||
let ind = ind - &sw
|
||||
endif
|
||||
|
||||
" Subtract a 'shiftwidth' on end, else (and elseif), until and '}'
|
||||
" This is the part that requires 'indentkeys'.
|
||||
if getline(v:lnum) =~ '^\s*\(end\|else\|until\|}\)'
|
||||
let ind = ind - &sw
|
||||
endif
|
||||
|
||||
return ind
|
||||
endfunction
|
||||
57
runtime/indent/make.vim
Normal file
57
runtime/indent/make.vim
Normal file
@ -0,0 +1,57 @@
|
||||
" Vim indent file
|
||||
" Language: Makefile
|
||||
" Maintainer: Nikolai Weibull <source@pcppopper.org>
|
||||
" URL: http://www.pcppopper.org/vim/indent/pcp/make/
|
||||
" Latest Revision: 2004-04-25
|
||||
" arch-tag: b539e147-a05c-4860-98af-1d2436db2f4b
|
||||
|
||||
" Only load this indent file when no other was loaded.
|
||||
if exists("b:did_indent")
|
||||
finish
|
||||
endif
|
||||
|
||||
let b:did_indent = 1
|
||||
|
||||
setlocal indentexpr=GetMakeIndent()
|
||||
setlocal indentkeys=!^F,o,O
|
||||
|
||||
" Only define the function once.
|
||||
if exists("*GetMakeIndent")
|
||||
finish
|
||||
endif
|
||||
|
||||
function s:GetStringWidth(line, str)
|
||||
let end = matchend(a:line, a:str)
|
||||
let width = 0
|
||||
let i = 0
|
||||
while i < end
|
||||
if a:line[i] != "\t"
|
||||
let width = width + 1
|
||||
else
|
||||
let width = width + &ts - (width % &ts)
|
||||
endif
|
||||
let i = i + 1
|
||||
endwhile
|
||||
return width
|
||||
endfunction
|
||||
|
||||
function GetMakeIndent()
|
||||
if v:lnum == 1
|
||||
return 0
|
||||
endif
|
||||
|
||||
let ind = indent(v:lnum - 1)
|
||||
let line = getline(v:lnum - 1)
|
||||
|
||||
if line == ''
|
||||
let ind = 0
|
||||
elseif line =~ '^[^ \t#:][^#:]*:\{1,2}\([^=:]\|$\)'
|
||||
let ind = ind + &ts
|
||||
elseif line =~ '^\s*\h\w*\s*=\s*.\+\\$'
|
||||
let ind = s:GetStringWidth(line, '=\s*')
|
||||
endif
|
||||
|
||||
return ind
|
||||
endfunction
|
||||
|
||||
" vim: set sts=2 sw=2:
|
||||
74
runtime/indent/matlab.vim
Normal file
74
runtime/indent/matlab.vim
Normal file
@ -0,0 +1,74 @@
|
||||
" Matlab indent file
|
||||
" Language: Matlab
|
||||
" Maintainer: Christophe Poucet <christophe.poucet@pandora.be>
|
||||
" Last Change: 6 January, 2001
|
||||
|
||||
" Only load this indent file when no other was loaded.
|
||||
if exists("b:did_indent")
|
||||
finish
|
||||
endif
|
||||
let b:did_indent = 1
|
||||
|
||||
" Some preliminary setting
|
||||
setlocal indentkeys=!,o,O=end,=case,=else,=elseif,=otherwise,=catch
|
||||
|
||||
|
||||
setlocal indentexpr=GetMatlabIndent(v:lnum)
|
||||
|
||||
" Only define the function once.
|
||||
if exists("*GetMatlabIndent")
|
||||
finish
|
||||
endif
|
||||
|
||||
function GetMatlabIndent(lnum)
|
||||
" Give up if this line is explicitly joined.
|
||||
if getline(a:lnum - 1) =~ '\\$'
|
||||
return -1
|
||||
endif
|
||||
|
||||
" Search backwards for the first non-empty line.
|
||||
let plnum = a:lnum - 1
|
||||
while plnum > 0 && getline(plnum) =~ '^\s*$'
|
||||
let plnum = plnum - 1
|
||||
endwhile
|
||||
|
||||
if plnum == 0
|
||||
" This is the first non-empty line, use zero indent.
|
||||
return 0
|
||||
endif
|
||||
|
||||
let curind = indent(plnum)
|
||||
|
||||
" If the current line is a stop-block statement...
|
||||
if getline(v:lnum) =~ '^\s*\(end\|else\|elseif\|case\|otherwise\|catch\)\>'
|
||||
" See if this line does not follow the line right after an openblock
|
||||
if getline(plnum) =~ '^\s*\(for\|if\|else\|elseif\|case\|while\|switch\|try\|otherwise\|catch\)\>'
|
||||
" See if the user has already dedented
|
||||
elseif indent(v:lnum) > curind - &sw
|
||||
" If not, recommend one dedent
|
||||
let curind = curind - &sw
|
||||
else
|
||||
" Otherwise, trust the user
|
||||
return -1
|
||||
endif
|
||||
" endif
|
||||
|
||||
" If the previous line opened a block
|
||||
elseif getline(plnum) =~ '^\s*\(for\|if\|else\|elseif\|case\|while\|switch\|try\|otherwise\|catch\)\>'
|
||||
" See if the user has already indented
|
||||
if indent(v:lnum) < curind + &sw
|
||||
"If not, recommend indent
|
||||
let curind = curind + &sw
|
||||
else
|
||||
" Otherwise, trust the user
|
||||
return -1
|
||||
endif
|
||||
endif
|
||||
|
||||
|
||||
|
||||
" If we got to here, it means that the user takes the standardversion, so we return it
|
||||
return curind
|
||||
endfunction
|
||||
|
||||
" vim:sw=2
|
||||
206
runtime/indent/mp.vim
Normal file
206
runtime/indent/mp.vim
Normal file
@ -0,0 +1,206 @@
|
||||
" MetaPost indent file
|
||||
" Language: MetaPost
|
||||
" Maintainer: Eugene Minkovskii <emin@mccme.ru>
|
||||
" Last Change: 2003 Nov 21
|
||||
" Version: 0.1
|
||||
" ==========================================================================
|
||||
|
||||
" Identation Rules: {{{1
|
||||
" First of all, MetaPost language don't expect any identation rules.
|
||||
" This screept need for you only if you (not MetaPost) need to do
|
||||
" exactly code. If you don't need to use indentation, see
|
||||
" :help filetype-indent-off
|
||||
"
|
||||
" Note: Every rules of identation in MetaPost or TeX languages (and in some
|
||||
" other of course) is very subjective. I can release only my vision of this
|
||||
" promlem.
|
||||
"
|
||||
" ..........................................................................
|
||||
" Example of correct (by me) identation {{{2
|
||||
" shiftwidth=4
|
||||
" ==========================================================================
|
||||
" for i=0 upto 99:
|
||||
" z[i] = (0,1u) rotated (i*360/100);
|
||||
" endfor
|
||||
" draw z0 -- z10 -- z20
|
||||
" withpen ... % <- 2sw because breaked line
|
||||
" withcolor ...; % <- same as previous
|
||||
" draw z0 for i=1 upto 99:
|
||||
" -- z[i] % <- 1sw from left end of 'for' satement
|
||||
" endfor withpen ... % <- 0sw from left end of 'for' satement
|
||||
" withcolor ...; % <- 2sw because breaked line
|
||||
" draw if One: % <- This is internal if (like 'for' above)
|
||||
" one
|
||||
" elsif Other:
|
||||
" other
|
||||
" fi withpen ...;
|
||||
" if one: % <- This is external if
|
||||
" draw one;
|
||||
" elseif other:
|
||||
" draw other;
|
||||
" fi
|
||||
" draw z0; draw z1;
|
||||
" }}}
|
||||
" }}}
|
||||
|
||||
" Only load this indent file when no other was loaded.
|
||||
if exists("b:did_indent")
|
||||
finish
|
||||
endif
|
||||
let b:did_indent = 1
|
||||
|
||||
setlocal indentexpr=GetMetaPostIndent()
|
||||
setlocal indentkeys+=;,<:>,=if,=for,=def,=end,=else,=fi
|
||||
|
||||
" Only define the function once.
|
||||
if exists("*GetMetaPostIndent")
|
||||
finish
|
||||
endif
|
||||
|
||||
" Auxiliary Definitions: {{{1
|
||||
function! MetaNextNonblankNoncomment(pos)
|
||||
" Like nextnonblank() but ignore comment lines
|
||||
let tmp = nextnonblank(a:pos)
|
||||
while tmp && getline(tmp) =~ '^\s*%'
|
||||
let tmp = nextnonblank(tmp+1)
|
||||
endwhile
|
||||
return tmp
|
||||
endfunction
|
||||
|
||||
function! MetaPrevNonblankNoncomment(pos)
|
||||
" Like prevnonblank() but ignore comment lines
|
||||
let tmp = prevnonblank(a:pos)
|
||||
while tmp && getline(tmp) =~ '^\s*%'
|
||||
let tmp = prevnonblank(tmp-1)
|
||||
endwhile
|
||||
return tmp
|
||||
endfunction
|
||||
|
||||
function! MetaSearchNoncomment(pattern, ...)
|
||||
" Like search() but ignore commented areas
|
||||
if a:0
|
||||
let flags = a:1
|
||||
elseif &wrapscan
|
||||
let flags = "w"
|
||||
else
|
||||
let flags = "W"
|
||||
endif
|
||||
let cl = line(".")
|
||||
let cc = col(".")
|
||||
let tmp = search(a:pattern, flags)
|
||||
while tmp && synIDattr(synID(line("."), col("."), 1), "name") =~
|
||||
\ 'm[fp]\(Comment\|TeXinsert\|String\)'
|
||||
let tmp = search(a:pattern, flags)
|
||||
endwhile
|
||||
if !tmp
|
||||
call cursor(cl,cc)
|
||||
endif
|
||||
return tmp
|
||||
endfunction
|
||||
" }}}
|
||||
|
||||
function! GetMetaPostIndent()
|
||||
" not indent in comment ???
|
||||
if synIDattr(synID(line("."), col("."), 1), "name") =~
|
||||
\ 'm[fp]\(Comment\|TeXinsert\|String\)'
|
||||
return -1
|
||||
endif
|
||||
" Some RegExps: {{{1
|
||||
" end_of_item: all of end by ';'
|
||||
" + all of end by :endfor, :enddef, :endfig, :endgroup, :fi
|
||||
" + all of start by :beginfig(num), :begingroup
|
||||
" + all of start by :for, :if, :else, :elseif and end by ':'
|
||||
" + all of start by :def, :vardef and end by '='
|
||||
let end_of_item = '\(' .
|
||||
\ ';\|' .
|
||||
\ '\<\(end\(for\|def\|fig\|group\)\|fi\)\>\|' .
|
||||
\ '\<begin\(group\>\|fig\s*(\s*\d\+\s*)\)\|' .
|
||||
\ '\<\(for\|if\|else\(if\)\=\)\>.\+:\|' .
|
||||
\ '\<\(var\)\=def\>.\+=' . '\)'
|
||||
" }}}
|
||||
" Save: current position {{{1
|
||||
let cl = line (".")
|
||||
let cc = col (".")
|
||||
let cs = getline(".")
|
||||
" if it is :beginfig or :endfig use zero indent
|
||||
if cs =~ '^\s*\(begin\|end\)fig\>'
|
||||
return 0
|
||||
endif
|
||||
" }}}
|
||||
" Initialise: ind variable {{{1
|
||||
" search previous item not in current line
|
||||
let p_semicol_l = MetaSearchNoncomment(end_of_item,"bW")
|
||||
while p_semicol_l == cl
|
||||
let p_semicol_l = MetaSearchNoncomment(end_of_item,"bW")
|
||||
endwhile
|
||||
" if this is first item in program use zero indent
|
||||
if !p_semicol_l
|
||||
return 0
|
||||
endif
|
||||
" if this is multiline item, remember first indent
|
||||
if MetaNextNonblankNoncomment(p_semicol_l+1) < cl
|
||||
let ind = indent(MetaNextNonblankNoncomment(p_semicol_l+1))
|
||||
" else --- search pre-previous item for search first line in previous item
|
||||
else
|
||||
" search pre-previous item not in current line
|
||||
let pp_semicol_l = MetaSearchNoncomment(end_of_item,"bW")
|
||||
while pp_semicol_l == p_semicol_l
|
||||
let pp_semicol_l = MetaSearchNoncomment(end_of_item,"bW")
|
||||
endwhile
|
||||
" if we find pre-previous item, remember indent of previous item
|
||||
" else --- remember zero
|
||||
if pp_semicol_l
|
||||
let ind = indent(MetaNextNonblankNoncomment(line(".")+1))
|
||||
else
|
||||
let ind = 0
|
||||
endif
|
||||
endif
|
||||
" }}}
|
||||
" Increase Indent: {{{1
|
||||
" if it is an internal/external :for or :if statements {{{2
|
||||
let pnn_s = getline(MetaPrevNonblankNoncomment(cl-1))
|
||||
if pnn_s =~ '\<\(for\|if\)\>.\+:\s*\($\|%\)'
|
||||
let ind = match(pnn_s, '\<\(for\|if\)\>.\+:\s*\($\|%\)') + &sw
|
||||
" }}}
|
||||
" if it is a :def, :vardef, :beginfig, :begingroup, :else, :elseif {{{2
|
||||
elseif pnn_s =~ '^\s*\(' .
|
||||
\ '\(var\)\=def\|' .
|
||||
\ 'begin\(group\|fig\s*(\s*\d\+\s*)\)\|' .
|
||||
\ 'else\(if\)\=' . '\)\>'
|
||||
let ind = ind + &sw
|
||||
" }}}
|
||||
" if it is a broken line {{{2
|
||||
elseif pnn_s !~ end_of_item.'\s*\($\|%\)'
|
||||
let ind = ind + (2 * &sw)
|
||||
endif
|
||||
" }}}
|
||||
" }}}
|
||||
" Decrease Indent: {{{1
|
||||
" if this is :endfor or :enddef statements {{{2
|
||||
" this is correct because :def cannot be inside :for
|
||||
if cs =~ '\<end\(for\|def\)\=\>'
|
||||
call MetaSearchNoncomment('\<for\>.\+:\s*\($\|%\)' . '\|' .
|
||||
\ '^\s*\(var\)\=def\>',"bW")
|
||||
if col(".") > 1
|
||||
let ind = col(".") - 1
|
||||
else
|
||||
let ind = indent(".")
|
||||
endif
|
||||
" }}}
|
||||
" if this is :fi, :else, :elseif statements {{{2
|
||||
elseif cs =~ '\<\(else\(if\)\=\|fi\)\>'
|
||||
call MetaSearchNoncomment('\<if\>.\+:\s*\($\|%\)',"bW")
|
||||
let ind = col(".") - 1
|
||||
" }}}
|
||||
" if this is :endgroup statement {{{2
|
||||
elseif cs =~ '^\s*endgroup\>'
|
||||
let ind = ind - &sw
|
||||
endif
|
||||
" }}}
|
||||
" }}}
|
||||
|
||||
return ind
|
||||
endfunction
|
||||
"
|
||||
|
||||
" vim:sw=2:fdm=marker
|
||||
79
runtime/indent/objc.vim
Normal file
79
runtime/indent/objc.vim
Normal file
@ -0,0 +1,79 @@
|
||||
" Vim indent file
|
||||
" Language: Objective-C
|
||||
" Maintainer: Kazunobu Kuriyama <kazunobu.kuriyama@nifty.com>
|
||||
" Last Change: 2004 May 16
|
||||
"
|
||||
|
||||
|
||||
" Only load this indent file when no other was loaded.
|
||||
if exists("b:did_indent")
|
||||
finish
|
||||
endif
|
||||
let b:did_indent = 1
|
||||
setlocal cindent
|
||||
|
||||
" Set the function to do the work.
|
||||
setlocal indentexpr=GetObjCIndent()
|
||||
|
||||
" To make a colon (:) suggest an indentation other than a goto/swich label,
|
||||
setlocal indentkeys-=:
|
||||
setlocal indentkeys+=<:>
|
||||
|
||||
" Only define the function once.
|
||||
if exists("*GetObjCIndent")
|
||||
finish
|
||||
endif
|
||||
|
||||
function s:GetWidth(line, regexp)
|
||||
let end = matchend(a:line, a:regexp)
|
||||
let width = 0
|
||||
let i = 0
|
||||
while i < end
|
||||
if a:line[i] != "\t"
|
||||
let width = width + 1
|
||||
else
|
||||
let width = width + &ts - (width % &ts)
|
||||
endif
|
||||
let i = i + 1
|
||||
endwhile
|
||||
return width
|
||||
endfunction
|
||||
|
||||
function s:LeadingWhiteSpace(line)
|
||||
let end = strlen(a:line)
|
||||
let width = 0
|
||||
let i = 0
|
||||
while i < end
|
||||
let char = a:line[i]
|
||||
if char != " " && char != "\t"
|
||||
break
|
||||
endif
|
||||
if char != "\t"
|
||||
let width = width + 1
|
||||
else
|
||||
let width = width + &ts - (width % &ts)
|
||||
endif
|
||||
let i = i + 1
|
||||
endwhile
|
||||
return width
|
||||
endfunction
|
||||
|
||||
|
||||
function GetObjCIndent()
|
||||
let theIndent = cindent(v:lnum)
|
||||
|
||||
let prev_line = getline(v:lnum - 1)
|
||||
let cur_line = getline(v:lnum)
|
||||
|
||||
if prev_line !~# ":" || cur_line !~# ":"
|
||||
return theIndent
|
||||
endif
|
||||
|
||||
if prev_line !~# ";"
|
||||
let prev_colon_pos = s:GetWidth(prev_line, ":")
|
||||
let delta = s:GetWidth(cur_line, ":") - s:LeadingWhiteSpace(cur_line)
|
||||
let theIndent = prev_colon_pos - delta
|
||||
endif
|
||||
|
||||
return theIndent
|
||||
endfunction
|
||||
311
runtime/indent/ocaml.vim
Normal file
311
runtime/indent/ocaml.vim
Normal file
@ -0,0 +1,311 @@
|
||||
" Vim indent file
|
||||
" Language: OCaml
|
||||
" Maintainers: Jean-Francois Yuen <jfyuen@ifrance.com>
|
||||
" Mike Leary <leary@nwlink.com>
|
||||
" Markus Mottl <markus@oefai.at>
|
||||
" URL: http://www.oefai.at/~markus/vim/indent/ocaml.vim
|
||||
" Last Change: 2003 Apr 14
|
||||
" 2003 Mar 05 - Added '{<' and some fixes (JY)
|
||||
" 2002 Nov 06 - Some fixes (JY)
|
||||
|
||||
" Only load this indent file when no other was loaded.
|
||||
if exists("b:did_indent")
|
||||
finish
|
||||
endif
|
||||
let b:did_indent = 1
|
||||
|
||||
setlocal expandtab
|
||||
setlocal indentexpr=GetOCamlIndent()
|
||||
setlocal indentkeys+=0=and,0=constraint,0=done,0=else,0=end,0=exception,0=external,0=if,0=in,0=include,0=inherit,0=initializer,0=let,0=method,0=open,0=then,0=type,0=val,0=with,0=;;,0=>\],0=\|\],0=\|,0=*),0=>},0},0\],0)
|
||||
setlocal nolisp
|
||||
setlocal nosmartindent
|
||||
setlocal textwidth=80
|
||||
|
||||
" Comment formatting
|
||||
if (has("comments"))
|
||||
setlocal comments=sr:(*,mb:*,ex:*)
|
||||
setlocal fo=cqort
|
||||
endif
|
||||
|
||||
" Only define the function once.
|
||||
if exists("*GetOCamlIndent")
|
||||
finish
|
||||
endif
|
||||
|
||||
" Define some patterns:
|
||||
let s:beflet = '^\s*\(initializer\|method\|try\)\|\(\<\(begin\|do\|else\|in\|then\|try\)\|->\|;\|(\)\s*$'
|
||||
let s:letpat = '^\s*\(let\|type\|module\|class\|open\|exception\|val\|include\|external\)\>'
|
||||
let s:letlim = '\(\<\(sig\|struct\)\|;;\)\s*$'
|
||||
let s:lim = '^\s*\(exception\|external\|include\|let\|module\|open\|type\|val\)\>'
|
||||
let s:module = '\<\%(begin\|sig\|struct\|object\)\>'
|
||||
let s:obj = '^\s*\(constraint\|inherit\|initializer\|method\|val\)\>\|\<\(object\|object\s*(.*)\)\s*$'
|
||||
let s:type = '^\s*\%(let\|type\)\>.*='
|
||||
let s:val = '^\s*\(val\|external\)\>.*:'
|
||||
|
||||
" Skipping pattern, for comments
|
||||
function s:SkipPattern(lnum, pat)
|
||||
let def = prevnonblank(a:lnum - 1)
|
||||
while def > 0 && getline(def) =~ a:pat
|
||||
let def = prevnonblank(def - 1)
|
||||
endwhile
|
||||
return def
|
||||
endfunction
|
||||
|
||||
" Indent for ';;' to match multiple 'let'
|
||||
function s:GetInd(lnum, pat, lim)
|
||||
let llet = search(a:pat, 'bW')
|
||||
let old = indent(a:lnum)
|
||||
while llet > 0
|
||||
let old = indent(llet)
|
||||
let nb = s:SkipPattern(llet, '^\s*(\*.*\*)\s*$')
|
||||
if getline(nb) =~ a:lim
|
||||
return old
|
||||
endif
|
||||
let llet = search(a:pat, 'bW')
|
||||
endwhile
|
||||
return old
|
||||
endfunction
|
||||
|
||||
" Indent pairs
|
||||
function s:FindPair(pstart, pmid, pend)
|
||||
call search(a:pend, 'bW')
|
||||
return indent(searchpair(a:pstart, a:pmid, a:pend, 'bWn', 'synIDattr(synID(line("."), col("."), 0), "name") =~? "string\\|comment"'))
|
||||
endfunction
|
||||
|
||||
" Indent 'let'
|
||||
function s:FindLet(pstart, pmid, pend)
|
||||
call search(a:pend, 'bW')
|
||||
return indent(searchpair(a:pstart, a:pmid, a:pend, 'bWn', 'synIDattr(synID(line("."), col("."), 0), "name") =~? "string\\|comment" || getline(".") =~ "^\\s*let\\>.*=.*\\<in\\s*$" || getline(prevnonblank(".") - 1) =~ "^\\s*let\\>.*=\\s*$\\|" . s:beflet'))
|
||||
endfunction
|
||||
|
||||
function GetOCamlIndent()
|
||||
" Find a non-blank line above the current line.
|
||||
let lnum = prevnonblank(v:lnum - 1)
|
||||
|
||||
" At the start of the file use zero indent.
|
||||
if lnum == 0
|
||||
return 0
|
||||
endif
|
||||
|
||||
let ind = indent(lnum)
|
||||
let lline = getline(lnum)
|
||||
|
||||
" Return double 'shiftwidth' after lines matching:
|
||||
if lline =~ '^\s*|.*->\s*$'
|
||||
return ind + &sw + &sw
|
||||
endif
|
||||
|
||||
let line = getline(v:lnum)
|
||||
|
||||
" Indent if current line begins with 'end'
|
||||
" for 'sig', 'struct', 'object' and 'begin':
|
||||
if line =~ '^\s*end\>'
|
||||
return s:FindPair(s:module, '','\<end\>')
|
||||
|
||||
" Indent if current line begins with 'done' for 'do':
|
||||
elseif line =~ '^\s*done\>'
|
||||
return s:FindPair('\<do\>', '','\<done\>')
|
||||
|
||||
" Indent if current line begins with '}' or '>}':
|
||||
elseif line =~ '^\s*\(\|>\)}'
|
||||
return s:FindPair('{', '','}')
|
||||
|
||||
" Indent if current line begins with ']', '|]' or '>]':
|
||||
elseif line =~ '^\s*\(\||\|>\)\]'
|
||||
return s:FindPair('\[', '','\]')
|
||||
|
||||
" Indent if current line begins with ')':
|
||||
elseif line =~ '^\s*)'
|
||||
return s:FindPair('(', '',')')
|
||||
|
||||
" Indent if current line begins with 'let'
|
||||
" and last line does not begin with 'let' or end with 'in' or ';;':
|
||||
elseif line =~ '^\s*let\>'
|
||||
if lline !~ s:lim . '\|' . s:letlim . '\|' . s:beflet
|
||||
return s:FindLet(s:type, '','\<let\s*$')
|
||||
else return ind
|
||||
endif
|
||||
|
||||
" Indent if current line begins with 'type'
|
||||
" and last line does not end with 'and' or ';;':
|
||||
elseif line =~ '^\s*type\>'
|
||||
if lline !~ s:lim . '\|\<and\s*$\|' . s:letlim
|
||||
return s:FindLet(s:type, '','\<type\s*$')
|
||||
else return ind
|
||||
endif
|
||||
|
||||
" Indent for pattern matching:
|
||||
elseif line =~ '^\s*|'
|
||||
if lline !~ '^\s*\(|\|\(match\|with\|type\)\>\)\|\<\(function\|parser\|with\)\s*$'
|
||||
call search('|', 'bW')
|
||||
return indent(searchpair('^\s*\(type\|match\)\>\|\<\(with\|function\|parser\)\s*$', '', '|', 'bWn', 'synIDattr(synID(line("."), col("."), 0), "name") =~? "string\\|comment" || getline(".") =~ "\\[|\\||\\]" && getline(".") !~ "^\\s*|.*->"'))
|
||||
else return ind
|
||||
endif
|
||||
|
||||
" Indent if current line begins with ';;':
|
||||
elseif line =~ '^\s*;;'
|
||||
if lline !~ ';;\s*$'
|
||||
return s:GetInd(v:lnum, s:letpat, s:letlim)
|
||||
else return ind
|
||||
endif
|
||||
|
||||
" Indent if current line begins with 'in' and previous
|
||||
" line does not start with 'let' or 'and':
|
||||
elseif line =~ '^\s*in\>'
|
||||
if lline !~ '^\s*\(let\|and\)\>'
|
||||
return s:FindPair('\<let\>', '', '\<in\>')
|
||||
else return ind
|
||||
endif
|
||||
|
||||
" Indent if current line begins with 'else'
|
||||
" and previous line does not start with 'if', 'then' or 'else':
|
||||
elseif line =~ '^\s*else\>'
|
||||
if lline !~ '^\s*\(if\|else\|then\)\>'
|
||||
return s:FindPair('\<if\>', '', '\<else\>')
|
||||
else return ind
|
||||
endif
|
||||
|
||||
" Indent if current line begins with 'then'
|
||||
" and previous line does not start with 'if', 'then' or 'else':
|
||||
elseif line =~ '^\s*then\>'
|
||||
if lline !~ '^\s*\(if\|else\|then\)\>'
|
||||
return s:FindPair('\<if\>', '', '\<then\>')
|
||||
else return ind
|
||||
endif
|
||||
|
||||
" Subtract a 'shiftwidth' if current line begins with 'and' and previous
|
||||
" line does not start with 'let', 'and' or 'type' or end with 'end'
|
||||
" (for classes):
|
||||
elseif line =~ '^\s*and\>'
|
||||
if lline !~ '^\s*\(and\|let\|type\)\>\|\<end\s*$'
|
||||
return ind - &sw
|
||||
else return ind
|
||||
endif
|
||||
|
||||
" Indent if current line begins with 'with'
|
||||
" and previous line does not start with 'match' or 'try':
|
||||
elseif line =~ '^\s*with\>'
|
||||
if lline !~ '^\s*\(match\|try\)\>'
|
||||
return s:FindPair('\<\%(match\|try\)\>', '','\<with\>')
|
||||
else return ind
|
||||
endif
|
||||
|
||||
" Indent if current line begins with 'exception':
|
||||
elseif line =~ '^\s*exception\>'
|
||||
if lline !~ s:lim . '\|' . s:letlim
|
||||
return indent(search(s:val . '\|^\s*\(external\|include\|open\|type\)\>', 'bW'))
|
||||
else return ind
|
||||
endif
|
||||
|
||||
" Indent if current line begins with 'external':
|
||||
elseif line =~ '^\s*external\>'
|
||||
if lline !~ s:lim . '\|' . s:letlim
|
||||
return indent(search(s:val . '\|^\s*\(exception\|include\|open\|type\)\>', 'bW'))
|
||||
else return ind
|
||||
endif
|
||||
|
||||
" Indent if current line begins with 'include':
|
||||
elseif line =~ '^\s*include\>'
|
||||
if lline !~ s:lim . '\|' . s:letlim
|
||||
return indent(search(s:val . '\|^\s*\(exception\|external\|open\|type\)\>', 'bW'))
|
||||
else return ind
|
||||
endif
|
||||
|
||||
" Indent if current line begins with 'open':
|
||||
elseif line =~ '^\s*open\>'
|
||||
if lline !~ s:lim . '\|' . s:letlim
|
||||
return indent(search(s:val . '\|^\s*\(exception\|external\|include\|type\)\>', 'bW'))
|
||||
else return ind
|
||||
endif
|
||||
|
||||
" Indent if current line begins with 'val':
|
||||
elseif line =~ '^\s*val\>'
|
||||
if lline !~ '^\s*\(exception\|external\|include\|open\)\>\|' . s:obj . '\|' . s:letlim
|
||||
return indent(search(s:val . '\|^\s*\(exception\|include\|initializer\|method\|open\|type\)\>', 'bW'))
|
||||
else return ind
|
||||
endif
|
||||
|
||||
" Indent if current line begins with 'constraint':
|
||||
elseif line =~ '^\s*constraint\>'
|
||||
if lline !~ s:obj
|
||||
return indent(search('^\s*\(inherit\|initializer\|method\|val\)\>', 'bW'))
|
||||
else return ind
|
||||
endif
|
||||
|
||||
" Indent if current line begins with 'inherit':
|
||||
elseif line =~ '^\s*inherit\>'
|
||||
if lline !~ s:obj
|
||||
return indent(search('^\s*\(constraint\|initializer\|method\|val\)\>', 'bW'))
|
||||
else return ind
|
||||
endif
|
||||
|
||||
" Indent if current line begins with 'inherit':
|
||||
elseif line =~ '^\s*initializer\>'
|
||||
if lline !~ s:obj
|
||||
return indent(search('^\s*\(constraint\|inherit\|method\|val\)\>', 'bW'))
|
||||
else return ind
|
||||
endif
|
||||
|
||||
" Indent if current line begins with 'method':
|
||||
elseif line =~ '^\s*method\>'
|
||||
if lline !~ s:obj
|
||||
return indent(search('^\s*\(\(constraint\|inherit\|initializer\|val\)\>\|method\>.*\(:\|=\)\)', 'bW'))
|
||||
else return ind
|
||||
endif
|
||||
|
||||
" Indent back to normal after comments:
|
||||
elseif line =~ '^\s*\*)'
|
||||
call search('\*)', 'bW')
|
||||
return indent(searchpair('(\*', '', '\*)', 'bWn', 'synIDattr(synID(line("."), col("."), 0), "name") =~? "string"'))
|
||||
|
||||
endif
|
||||
|
||||
" Add a 'shiftwidth' after lines ending with:
|
||||
if lline =~ '\(:\|=\|->\|<-\|(\|\[\|{\|{<\|\[|\|\[<\|\<\(begin\|struct\|sig\|functor\|initializer\|object\|try\|do\|if\|then\|else\|fun\|function\|parser\)\|\<object\s*(.*)\)\s*$'
|
||||
let ind = ind + &sw
|
||||
|
||||
" Back to normal indent after lines ending with ';;':
|
||||
elseif lline =~ ';;\s*$' && lline !~ '^\s*;;'
|
||||
let ind = s:GetInd(v:lnum, s:letpat, s:letlim)
|
||||
|
||||
" Back to normal indent after lines ending with 'end':
|
||||
elseif lline =~ '\<end\s*$'
|
||||
let ind = s:FindPair(s:module, '','\<end\>')
|
||||
|
||||
" Back to normal indent after lines ending with 'in':
|
||||
elseif lline =~ '\<in\s*$' && lline !~ '^\s*in\>'
|
||||
let ind = s:FindPair('\<let\>', '', '\<in\>')
|
||||
|
||||
" Back to normal indent after lines ending with 'done':
|
||||
elseif lline =~ '\<done\s*$'
|
||||
let ind = s:FindPair('\<do\>', '','\<done\>')
|
||||
|
||||
" Back to normal indent after lines ending with '}' or '>}':
|
||||
elseif lline =~ '\(\|>\)}\s*$'
|
||||
let ind = s:FindPair('{', '','}')
|
||||
|
||||
" Back to normal indent after lines ending with ']', '|]' or '>]':
|
||||
elseif lline =~ '\(\||\|>\)\]\s*$'
|
||||
let ind = s:FindPair('\[', '','\]')
|
||||
|
||||
" Back to normal indent after comments:
|
||||
elseif lline =~ '\*)\s*$'
|
||||
call search('\*)', 'bW')
|
||||
let ind = indent(searchpair('(\*', '', '\*)', 'bWn', 'synIDattr(synID(line("."), col("."), 0), "name") =~? "string"'))
|
||||
|
||||
" Back to normal indent after lines ending with ')':
|
||||
elseif lline =~ ')\s*$'
|
||||
let ind = s:FindPair('(', '',')')
|
||||
|
||||
endif
|
||||
|
||||
" Subtract a 'shiftwidth' after lines matching 'match ... with parser':
|
||||
if lline =~ '^\s*match\>.*\<with\>\s*\<parser\s*$'
|
||||
let ind = ind - &sw
|
||||
endif
|
||||
|
||||
return ind
|
||||
|
||||
endfunction
|
||||
|
||||
" vim:sw=2
|
||||
182
runtime/indent/occam.vim
Normal file
182
runtime/indent/occam.vim
Normal file
@ -0,0 +1,182 @@
|
||||
" Vim indent file
|
||||
" Language: occam
|
||||
" Maintainer: Mario Schweigler <ms44@kent.ac.uk>
|
||||
" Last Change: 23 April 2003
|
||||
|
||||
" Only load this indent file when no other was loaded.
|
||||
if exists("b:did_indent")
|
||||
finish
|
||||
endif
|
||||
let b:did_indent = 1
|
||||
|
||||
"{{{ Settings
|
||||
" Set the occam indent function
|
||||
setlocal indentexpr=GetOccamIndent()
|
||||
" Indent after new line and after initial colon
|
||||
setlocal indentkeys=o,O,0=:
|
||||
"}}}
|
||||
|
||||
" Only define the function once
|
||||
if exists("*GetOccamIndent")
|
||||
finish
|
||||
endif
|
||||
|
||||
"{{{ Indent definitions
|
||||
" Define carriage return indent
|
||||
let s:FirstLevelIndent = '^\C\s*\(IF\|ALT\|PRI\s\+ALT\|PAR\|SEQ\|PRI\s\+PAR\|WHILE\|VALOF\|CLAIM\|FORKING\)\>\|\(--.*\)\@<!\(\<PROC\>\|??\|\<CASE\>\s*\(--.*\)\=\_$\)'
|
||||
let s:FirstLevelNonColonEndIndent = '^\C\s*PROTOCOL\>\|\(--.*\)\@<!\<\(\(CHAN\|DATA\)\s\+TYPE\|FUNCTION\)\>'
|
||||
let s:SecondLevelIndent = '^\C\s*\(IF\|ALT\|PRI\s\+ALT\)\>\|\(--.*\)\@<!?\s*\<CASE\>\s*\(--.*\)\=\_$'
|
||||
let s:SecondLevelNonColonEndIndent = '\(--.*\)\@<!\<\(CHAN\|DATA\)\s\+TYPE\>'
|
||||
|
||||
" Define colon indent
|
||||
let s:ColonIndent = '\(--.*\)\@<!\<PROC\>'
|
||||
let s:ColonNonColonEndIndent = '^\C\s*PROTOCOL\>\|\(--.*\)\@<!\<\(\(CHAN\|DATA\)\s\+TYPE\|FUNCTION\)\>'
|
||||
|
||||
let s:ColonEnd = '\(--.*\)\@<!:\s*\(--.*\)\=$'
|
||||
let s:ColonStart = '^\s*:\s*\(--.*\)\=$'
|
||||
|
||||
" Define comment
|
||||
let s:CommentLine = '^\s*--'
|
||||
"}}}
|
||||
|
||||
"{{{ function GetOccamIndent()
|
||||
" Auxiliary function to get the correct indent for a line of occam code
|
||||
function GetOccamIndent()
|
||||
|
||||
" Ensure magic is on
|
||||
let save_magic = &magic
|
||||
setlocal magic
|
||||
|
||||
" Get reference line number
|
||||
let linenum = prevnonblank(v:lnum - 1)
|
||||
while linenum > 0 && getline(linenum) =~ s:CommentLine
|
||||
let linenum = prevnonblank(linenum - 1)
|
||||
endwhile
|
||||
|
||||
" Get current indent
|
||||
let curindent = indent(linenum)
|
||||
|
||||
" Get current line
|
||||
let line = getline(linenum)
|
||||
|
||||
" Get previous line number
|
||||
let prevlinenum = prevnonblank(linenum - 1)
|
||||
while prevlinenum > 0 && getline(prevlinenum) =~ s:CommentLine
|
||||
let prevlinenum = prevnonblank(prevlinenum - 1)
|
||||
endwhile
|
||||
|
||||
" Get previous line
|
||||
let prevline = getline(prevlinenum)
|
||||
|
||||
" Colon indent
|
||||
if getline(v:lnum) =~ s:ColonStart
|
||||
|
||||
let found = 0
|
||||
|
||||
while found < 1
|
||||
|
||||
if line =~ s:ColonStart
|
||||
let found = found - 1
|
||||
elseif line =~ s:ColonIndent || (line =~ s:ColonNonColonEndIndent && line !~ s:ColonEnd)
|
||||
let found = found + 1
|
||||
endif
|
||||
|
||||
if found < 1
|
||||
let linenum = prevnonblank(linenum - 1)
|
||||
if linenum > 0
|
||||
let line = getline(linenum)
|
||||
else
|
||||
let found = 1
|
||||
endif
|
||||
endif
|
||||
|
||||
endwhile
|
||||
|
||||
if linenum > 0
|
||||
let curindent = indent(linenum)
|
||||
else
|
||||
let colonline = getline(v:lnum)
|
||||
let tabstr = ''
|
||||
while strlen(tabstr) < &tabstop
|
||||
let tabstr = ' ' . tabstr
|
||||
endwhile
|
||||
let colonline = substitute(colonline, '\t', tabstr, 'g')
|
||||
let curindent = match(colonline, ':')
|
||||
endif
|
||||
|
||||
" Restore magic
|
||||
if !save_magic|setlocal nomagic|endif
|
||||
|
||||
return curindent
|
||||
endif
|
||||
|
||||
if getline(v:lnum) =~ '^\s*:'
|
||||
let colonline = getline(v:lnum)
|
||||
let tabstr = ''
|
||||
while strlen(tabstr) < &tabstop
|
||||
let tabstr = ' ' . tabstr
|
||||
endwhile
|
||||
let colonline = substitute(colonline, '\t', tabstr, 'g')
|
||||
let curindent = match(colonline, ':')
|
||||
|
||||
" Restore magic
|
||||
if !save_magic|setlocal nomagic|endif
|
||||
|
||||
return curindent
|
||||
endif
|
||||
|
||||
" Carriage return indenat
|
||||
if line =~ s:FirstLevelIndent || (line =~ s:FirstLevelNonColonEndIndent && line !~ s:ColonEnd)
|
||||
\ || (line !~ s:ColonStart && (prevline =~ s:SecondLevelIndent
|
||||
\ || (prevline =~ s:SecondLevelNonColonEndIndent && prevline !~ s:ColonEnd)))
|
||||
let curindent = curindent + &shiftwidth
|
||||
|
||||
" Restore magic
|
||||
if !save_magic|setlocal nomagic|endif
|
||||
|
||||
return curindent
|
||||
endif
|
||||
|
||||
" Commented line
|
||||
if getline(prevnonblank(v:lnum - 1)) =~ s:CommentLine
|
||||
|
||||
" Restore magic
|
||||
if !save_magic|setlocal nomagic|endif
|
||||
|
||||
return indent(prevnonblank(v:lnum - 1))
|
||||
endif
|
||||
|
||||
" Look for previous second level IF / ALT / PRI ALT
|
||||
let found = 0
|
||||
|
||||
while !found
|
||||
|
||||
if indent(prevlinenum) == curindent - &shiftwidth
|
||||
let found = 1
|
||||
endif
|
||||
|
||||
if !found
|
||||
let prevlinenum = prevnonblank(prevlinenum - 1)
|
||||
while prevlinenum > 0 && getline(prevlinenum) =~ s:CommentLine
|
||||
let prevlinenum = prevnonblank(prevlinenum - 1)
|
||||
endwhile
|
||||
if prevlinenum == 0
|
||||
let found = 1
|
||||
endif
|
||||
endif
|
||||
|
||||
endwhile
|
||||
|
||||
if prevlinenum > 0
|
||||
if getline(prevlinenum) =~ s:SecondLevelIndent
|
||||
let curindent = curindent + &shiftwidth
|
||||
endif
|
||||
endif
|
||||
|
||||
" Restore magic
|
||||
if !save_magic|setlocal nomagic|endif
|
||||
|
||||
return curindent
|
||||
|
||||
endfunction
|
||||
"}}}
|
||||
180
runtime/indent/perl.vim
Normal file
180
runtime/indent/perl.vim
Normal file
@ -0,0 +1,180 @@
|
||||
" Vim indent file
|
||||
" Language: Perl
|
||||
" Author: Rafael Garcia-Suarez <rgarciasuarez@free.fr>
|
||||
" URL: http://rgarciasuarez.free.fr/vim/indent/perl.vim
|
||||
" Last Change: 2003 Apr 25
|
||||
|
||||
" Suggestions and improvements by :
|
||||
" Aaron J. Sherman (use syntax for hints)
|
||||
" Artem Chuprina (play nice with folding)
|
||||
|
||||
" TODO things that are not or not properly indented (yet) :
|
||||
" - Continued statements
|
||||
" print "foo",
|
||||
" "bar";
|
||||
" print "foo"
|
||||
" if bar();
|
||||
" - Multiline regular expressions (m//x)
|
||||
" (The following probably needs modifying the perl syntax file)
|
||||
" - qw() lists
|
||||
" - Heredocs with terminators that don't match \I\i*
|
||||
|
||||
" Only load this indent file when no other was loaded.
|
||||
if exists("b:did_indent")
|
||||
finish
|
||||
endif
|
||||
let b:did_indent = 1
|
||||
|
||||
" Is syntax highlighting active ?
|
||||
let b:indent_use_syntax = has("syntax") && &syntax == "perl"
|
||||
|
||||
let s:cpo_save = &cpo
|
||||
set cpo-=C
|
||||
|
||||
setlocal indentexpr=GetPerlIndent()
|
||||
setlocal indentkeys+=0=,0),0=or,0=and
|
||||
if !b:indent_use_syntax
|
||||
setlocal indentkeys+=0=EO
|
||||
endif
|
||||
|
||||
" Only define the function once.
|
||||
if exists("*GetPerlIndent")
|
||||
finish
|
||||
endif
|
||||
|
||||
function GetPerlIndent()
|
||||
|
||||
" Get the line to be indented
|
||||
let cline = getline(v:lnum)
|
||||
|
||||
" Indent POD markers to column 0
|
||||
if cline =~ '^\s*=\L\@!'
|
||||
return 0
|
||||
endif
|
||||
|
||||
" Don't reindent coments on first column
|
||||
if cline =~ '^#.'
|
||||
return 0
|
||||
endif
|
||||
|
||||
" Get current syntax item at the line's first char
|
||||
let csynid = ''
|
||||
if b:indent_use_syntax
|
||||
let csynid = synIDattr(synID(v:lnum,1,0),"name")
|
||||
endif
|
||||
|
||||
" Don't reindent POD and heredocs
|
||||
if csynid == "perlPOD" || csynid == "perlHereDoc" || csynid =~ "^pod"
|
||||
return indent(v:lnum)
|
||||
endif
|
||||
|
||||
" Indent end-of-heredocs markers to column 0
|
||||
if b:indent_use_syntax
|
||||
" Assumes that an end-of-heredoc marker matches \I\i* to avoid
|
||||
" confusion with other types of strings
|
||||
if csynid == "perlStringStartEnd" && cline =~ '^\I\i*$'
|
||||
return 0
|
||||
endif
|
||||
else
|
||||
" Without syntax hints, assume that end-of-heredocs markers begin with EO
|
||||
if cline =~ '^\s*EO'
|
||||
return 0
|
||||
endif
|
||||
endif
|
||||
|
||||
" Now get the indent of the previous perl line.
|
||||
|
||||
" Find a non-blank line above the current line.
|
||||
let lnum = prevnonblank(v:lnum - 1)
|
||||
" Hit the start of the file, use zero indent.
|
||||
if lnum == 0
|
||||
return 0
|
||||
endif
|
||||
let line = getline(lnum)
|
||||
let ind = indent(lnum)
|
||||
" Skip heredocs, POD, and comments on 1st column
|
||||
if b:indent_use_syntax
|
||||
let skippin = 2
|
||||
while skippin
|
||||
let synid = synIDattr(synID(lnum,1,0),"name")
|
||||
if (synid == "perlStringStartEnd" && line =~ '^\I\i*$')
|
||||
\ || (skippin != 2 && synid == "perlPOD")
|
||||
\ || (skippin != 2 && synid == "perlHereDoc")
|
||||
\ || synid == "perlComment"
|
||||
\ || synid =~ "^pod"
|
||||
let lnum = prevnonblank(lnum - 1)
|
||||
if lnum == 0
|
||||
return 0
|
||||
endif
|
||||
let line = getline(lnum)
|
||||
let ind = indent(lnum)
|
||||
let skippin = 1
|
||||
else
|
||||
let skippin = 0
|
||||
endif
|
||||
endwhile
|
||||
else
|
||||
if line =~ "^EO"
|
||||
let lnum = search("<<[\"']\\=EO", "bW")
|
||||
let line = getline(lnum)
|
||||
let ind = indent(lnum)
|
||||
endif
|
||||
endif
|
||||
|
||||
" Indent blocks enclosed by {} or ()
|
||||
if b:indent_use_syntax
|
||||
" Find a real opening brace
|
||||
let bracepos = match(line, '[(){}]', matchend(line, '^\s*[)}]'))
|
||||
while bracepos != -1
|
||||
let synid = synIDattr(synID(lnum, bracepos + 1, 0), "name")
|
||||
" If the brace is highlighted in one of those groups, indent it.
|
||||
" 'perlHereDoc' is here only to handle the case '&foo(<<EOF)'.
|
||||
if synid == ""
|
||||
\ || synid == "perlMatchStartEnd"
|
||||
\ || synid == "perlHereDoc"
|
||||
\ || synid =~ "^perlFiledescStatement"
|
||||
\ || synid =~ '^perl\(Sub\|BEGINEND\|If\)Fold'
|
||||
let brace = strpart(line, bracepos, 1)
|
||||
if brace == '(' || brace == '{'
|
||||
let ind = ind + &sw
|
||||
else
|
||||
let ind = ind - &sw
|
||||
endif
|
||||
endif
|
||||
let bracepos = match(line, '[(){}]', bracepos + 1)
|
||||
endwhile
|
||||
let bracepos = matchend(cline, '^\s*[)}]')
|
||||
if bracepos != -1
|
||||
let synid = synIDattr(synID(v:lnum, bracepos, 0), "name")
|
||||
if synid == ""
|
||||
\ || synid == "perlMatchStartEnd"
|
||||
\ || synid =~ '^perl\(Sub\|BEGINEND\|If\)Fold'
|
||||
let ind = ind - &sw
|
||||
endif
|
||||
endif
|
||||
else
|
||||
if line =~ '[{(]\s*\(#[^)}]*\)\=$'
|
||||
let ind = ind + &sw
|
||||
endif
|
||||
if cline =~ '^\s*[)}]'
|
||||
let ind = ind - &sw
|
||||
endif
|
||||
endif
|
||||
|
||||
" Indent lines that begin with 'or' or 'and'
|
||||
if cline =~ '^\s*\(or\|and\)\>'
|
||||
if line !~ '^\s*\(or\|and\)\>'
|
||||
let ind = ind + &sw
|
||||
endif
|
||||
elseif line =~ '^\s*\(or\|and\)\>'
|
||||
let ind = ind - &sw
|
||||
endif
|
||||
|
||||
return ind
|
||||
|
||||
endfunction
|
||||
|
||||
let &cpo = s:cpo_save
|
||||
unlet s:cpo_save
|
||||
|
||||
" vim:ts=8:sts=2:sw=2
|
||||
118
runtime/indent/php.vim
Normal file
118
runtime/indent/php.vim
Normal file
@ -0,0 +1,118 @@
|
||||
" Vim indent file
|
||||
" Language: PHP
|
||||
" Author: Miles Lott <milos@groupwhere.org>
|
||||
" URL: http://milosch.dyndns.org/php.vim
|
||||
" Last Change: 2004 May 18
|
||||
" Version: 0.5
|
||||
" Notes: Close all switches with default:\nbreak; and it will look better.
|
||||
" Also, open and close brackets should be alone on a line.
|
||||
" This is my preference, and the only way this will look nice.
|
||||
" Try an older version if you care less about the formatting of
|
||||
" switch/case. It is nearly perfect for anyone regardless of your
|
||||
" stance on brackets.
|
||||
"
|
||||
" Changes: 0.5 - fix duplicate indent on open tag, and empty bracketed
|
||||
" statements.
|
||||
" 0.4 - Fixes for closing php tag, switch statement closure, and php_indent_shortopentags
|
||||
" option from Steffen Bruentjen <vim@kontraphon.de>
|
||||
"
|
||||
" Options: php_noindent_switch=1 -- do not try to indent switch/case statements (version 0.1 behavior)
|
||||
" php_indent_shortopentags=1 -- indent after short php open tags, too
|
||||
|
||||
" Only load this indent file when no other was loaded.
|
||||
if exists("b:did_indent")
|
||||
finish
|
||||
endif
|
||||
let b:did_indent = 1
|
||||
|
||||
setlocal indentexpr=GetPhpIndent()
|
||||
"setlocal indentkeys+=0=,0),=EO
|
||||
setlocal indentkeys+=0=,0),=EO,=>
|
||||
|
||||
" Only define the function once.
|
||||
if exists("*GetPhpIndent")
|
||||
finish
|
||||
endif
|
||||
|
||||
" Handle option(s)
|
||||
if exists("php_noindent_switch")
|
||||
let b:php_noindent_switch=1
|
||||
endif
|
||||
|
||||
function GetPhpIndent()
|
||||
" Find a non-blank line above the current line.
|
||||
let lnum = prevnonblank(v:lnum - 1)
|
||||
" Hit the start of the file, use zero indent.
|
||||
if lnum == 0
|
||||
return 0
|
||||
endif
|
||||
let line = getline(lnum) " last line
|
||||
let cline = getline(v:lnum) " current line
|
||||
let pline = getline(lnum - 1) " previous to last line
|
||||
let ind = indent(lnum)
|
||||
|
||||
" Indent after php open tag
|
||||
if line =~ '<?php'
|
||||
let ind = ind + &sw
|
||||
elseif exists('g:php_indent_shortopentags')
|
||||
" indent after short open tag
|
||||
if line =~ '<?'
|
||||
let ind = ind + &sw
|
||||
endif
|
||||
endif
|
||||
" indent after php closing tag
|
||||
if cline =~ '\M?>'
|
||||
let ind = ind - &sw
|
||||
endif
|
||||
|
||||
if exists("b:php_noindent_switch") " version 1 behavior, diy switch/case,etc
|
||||
" Indent blocks enclosed by {} or ()
|
||||
if line =~ '[{(]\s*\(#[^)}]*\)\=$'
|
||||
let ind = ind + &sw
|
||||
endif
|
||||
if cline =~ '^\s*[)}]'
|
||||
let ind = ind - &sw
|
||||
endif
|
||||
return ind
|
||||
else
|
||||
" Search the matching bracket (with searchpair()) and set the indent of
|
||||
" to the indent of the matching line.
|
||||
if cline =~ '^\s*}'
|
||||
call cursor(line('.'), 1)
|
||||
let ind = indent(searchpair('{', '', '}',
|
||||
'bW', 'synIDattr(synID(line("."), col("."),
|
||||
0), "name") =~? "string"'))
|
||||
return ind
|
||||
endif
|
||||
" Try to indent switch/case statements as well
|
||||
" Indent blocks enclosed by {} or () or case statements, with some anal requirements
|
||||
if line =~ 'case.*:\|[{(]\s*\(#[^)}]*\)\=$'
|
||||
let ind = ind + &sw
|
||||
" return if the current line is not another case statement of the previous line is a bracket open
|
||||
if cline !~ '.*case.*:\|default:' || line =~ '[{(]\s*\(#[^)}]*\)\=$'
|
||||
return ind
|
||||
endif
|
||||
endif
|
||||
if cline =~ '^\s*case.*:\|^\s*default:\|^\s*[)}]'
|
||||
let ind = ind - &sw
|
||||
" if the last line is a break or return, or the current line is a close bracket,
|
||||
" or if the previous line is a default statement, subtract another
|
||||
if line =~ '^\s*break;\|^\s*return\|' && cline =~ '^\s*[)}]' && pline =~ 'default:'
|
||||
let ind = ind - &sw
|
||||
endif
|
||||
endif
|
||||
" Search the matching bracket (with searchpair()) and set the indent of cline
|
||||
" to the indent of the matching line.
|
||||
if cline =~ '^\s*}'
|
||||
call cursor(line('. '), 1)
|
||||
let ind = indent(searchpair('{', '', '}', 'bW', 'synIDattr(synID(line("."), col("."), 0), "name") =~? "string"'))
|
||||
return ind
|
||||
endif
|
||||
|
||||
if line =~ 'default:'
|
||||
let ind = ind + &sw
|
||||
endif
|
||||
return ind
|
||||
endif
|
||||
endfunction
|
||||
" vim: set ts=4 sw=4:
|
||||
68
runtime/indent/postscr.vim
Normal file
68
runtime/indent/postscr.vim
Normal file
@ -0,0 +1,68 @@
|
||||
" PostScript indent file
|
||||
" Language: PostScript
|
||||
" Maintainer: Mike Williams <mrw@netcomuk.co.uk>
|
||||
" Last Change: 2nd July 2001
|
||||
"
|
||||
|
||||
" Only load this indent file when no other was loaded.
|
||||
if exists("b:did_indent")
|
||||
finish
|
||||
endif
|
||||
let b:did_indent = 1
|
||||
|
||||
setlocal indentexpr=PostscrIndentGet(v:lnum)
|
||||
setlocal indentkeys+=0],0=>>,0=%%,0=end,0=restore,0=grestore indentkeys-=:,0#,e
|
||||
|
||||
" Catch multiple instantiations
|
||||
if exists("*PostscrIndentGet")
|
||||
finish
|
||||
endif
|
||||
|
||||
function! PostscrIndentGet(lnum)
|
||||
" Find a non-empty non-comment line above the current line.
|
||||
" Note: ignores DSC comments as well!
|
||||
let lnum = a:lnum - 1
|
||||
while lnum != 0
|
||||
let lnum = prevnonblank(lnum)
|
||||
if getline(lnum) !~ '^\s*%.*$'
|
||||
break
|
||||
endif
|
||||
let lnum = lnum - 1
|
||||
endwhile
|
||||
|
||||
" Hit the start of the file, use user indent.
|
||||
if lnum == 0
|
||||
return -1
|
||||
endif
|
||||
|
||||
" Start with the indent of the previous line
|
||||
let ind = indent(lnum)
|
||||
let pline = getline(lnum)
|
||||
|
||||
" Indent for dicts, arrays, and saves with possible trailing comment
|
||||
if pline =~ '\(begin\|<<\|g\=save\|{\|[\)\s*\(%.*\)\=$'
|
||||
let ind = ind + &sw
|
||||
endif
|
||||
|
||||
" Remove indent for popped dicts, and restores.
|
||||
if pline =~ '\(end\|g\=restore\)\s*$'
|
||||
let ind = ind - &sw
|
||||
|
||||
" Else handle immediate dedents of dicts, restores, and arrays.
|
||||
elseif getline(a:lnum) =~ '\(end\|>>\|g\=restore\|}\|]\)'
|
||||
let ind = ind - &sw
|
||||
|
||||
" Else handle DSC comments - always start of line.
|
||||
elseif getline(a:lnum) =~ '^\s*%%'
|
||||
let ind = 0
|
||||
endif
|
||||
|
||||
" For now catch excessive left indents if they occur.
|
||||
if ind < 0
|
||||
let ind = -1
|
||||
endif
|
||||
|
||||
return ind
|
||||
endfunction
|
||||
|
||||
" vim:sw=2
|
||||
84
runtime/indent/pov.vim
Normal file
84
runtime/indent/pov.vim
Normal file
@ -0,0 +1,84 @@
|
||||
" Vim indent file
|
||||
" Language: PoV-Ray Scene Description Language
|
||||
" Maintainer: David Necas (Yeti) <yeti@physics.muni.cz>
|
||||
" Last Change: 2002-10-20
|
||||
" URI: http://trific.ath.cx/Ftp/vim/indent/pov.vim
|
||||
|
||||
" Only load this indent file when no other was loaded.
|
||||
if exists("b:did_indent")
|
||||
finish
|
||||
endif
|
||||
let b:did_indent = 1
|
||||
|
||||
" Some preliminary settings.
|
||||
setlocal nolisp " Make sure lisp indenting doesn't supersede us.
|
||||
|
||||
setlocal indentexpr=GetPoVRayIndent()
|
||||
setlocal indentkeys+==else,=end,0]
|
||||
|
||||
" Only define the function once.
|
||||
if exists("*GetPoVRayIndent")
|
||||
finish
|
||||
endif
|
||||
|
||||
" Counts matches of a regexp <rexp> in line number <line>.
|
||||
" Doesn't count matches inside strings and comments (as defined by current
|
||||
" syntax).
|
||||
function! s:MatchCount(line, rexp)
|
||||
let str = getline(a:line)
|
||||
let i = 0
|
||||
let n = 0
|
||||
while i >= 0
|
||||
let i = matchend(str, a:rexp, i)
|
||||
if i >= 0 && synIDattr(synID(a:line, i, 0), "name") !~? "string\|comment"
|
||||
let n = n + 1
|
||||
endif
|
||||
endwhile
|
||||
return n
|
||||
endfunction
|
||||
|
||||
" The main function. Returns indent amount.
|
||||
function GetPoVRayIndent()
|
||||
" If we are inside a comment (may be nested in obscure ways), give up
|
||||
if synIDattr(synID(v:lnum, indent(v:lnum)+1, 0), "name") =~? "string\|comment"
|
||||
return -1
|
||||
endif
|
||||
|
||||
" Search backwards for the frist non-empty, non-comment line.
|
||||
let plnum = prevnonblank(v:lnum - 1)
|
||||
let plind = indent(plnum)
|
||||
while plnum > 0 && synIDattr(synID(plnum, plind+1, 0), "name") =~? "comment"
|
||||
let plnum = prevnonblank(plnum - 1)
|
||||
let plind = indent(plnum)
|
||||
endwhile
|
||||
|
||||
" Start indenting from zero
|
||||
if plnum == 0
|
||||
return 0
|
||||
endif
|
||||
|
||||
" Analyse previous nonempty line.
|
||||
let chg = 0
|
||||
let chg = chg + s:MatchCount(plnum, '[[{(]')
|
||||
let chg = chg + s:MatchCount(plnum, '#\s*\%(if\|ifdef\|ifndef\|switch\|while\|macro\|else\)\>')
|
||||
let chg = chg - s:MatchCount(plnum, '#\s*end\>')
|
||||
let chg = chg - s:MatchCount(plnum, '[]})]')
|
||||
" Dirty hack for people writing #if and #else on the same line.
|
||||
let chg = chg - s:MatchCount(plnum, '#\s*\%(if\|ifdef\|ifndef\|switch\)\>.*#\s*else\>')
|
||||
" When chg > 0, then we opened groups and we should indent more, but when
|
||||
" chg < 0, we closed groups and this already affected the previous line,
|
||||
" so we should not dedent. And when everything else fails, scream.
|
||||
let chg = chg > 0 ? chg : 0
|
||||
|
||||
" Analyse current line
|
||||
" FIXME: If we have to dedent, we should try to find the indentation of the
|
||||
" opening line.
|
||||
let cur = s:MatchCount(v:lnum, '^\s*\%(#\s*\%(end\|else\)\>\|[]})]\)')
|
||||
if cur > 0
|
||||
let final = plind + (chg - cur) * &sw
|
||||
else
|
||||
let final = plind + chg * &sw
|
||||
endif
|
||||
|
||||
return final < 0 ? 0 : final
|
||||
endfunction
|
||||
58
runtime/indent/prolog.vim
Normal file
58
runtime/indent/prolog.vim
Normal file
@ -0,0 +1,58 @@
|
||||
" vim: set sw=4 sts=4:
|
||||
" Maintainer : Gergely Kontra <kgergely@mcl.hu>
|
||||
" Revised on : 2002.02.18. 23:34:05
|
||||
" Language : Prolog
|
||||
|
||||
" TODO:
|
||||
" checking with respect to syntax highlighting
|
||||
" ignoring multiline comments
|
||||
" detecting multiline strings
|
||||
|
||||
" Only load this indent file when no other was loaded.
|
||||
if exists("b:did_indent")
|
||||
finish
|
||||
endif
|
||||
|
||||
let b:did_indent = 1
|
||||
|
||||
setlocal indentexpr=GetPrologIndent()
|
||||
setlocal indentkeys-=:,0#
|
||||
setlocal indentkeys+=0%,-,0;,>,0)
|
||||
|
||||
" Only define the function once.
|
||||
"if exists("*GetPrologIndent")
|
||||
" finish
|
||||
"endif
|
||||
|
||||
function! GetPrologIndent()
|
||||
" Find a non-blank line above the current line.
|
||||
let pnum = prevnonblank(v:lnum - 1)
|
||||
" Hit the start of the file, use zero indent.
|
||||
if pnum == 0
|
||||
return 0
|
||||
endif
|
||||
let line = getline(v:lnum)
|
||||
let pline = getline(pnum)
|
||||
|
||||
let ind = indent(pnum)
|
||||
" Previous line was comment -> use previous line's indent
|
||||
if pline =~ '^\s*%'
|
||||
retu ind
|
||||
endif
|
||||
" Check for clause head on previous line
|
||||
if pline =~ ':-\s*\(%.*\)\?$'
|
||||
let ind = ind + &sw
|
||||
" Check for end of clause on previous line
|
||||
elseif pline =~ '\.\s*\(%.*\)\?$'
|
||||
let ind = ind - &sw
|
||||
endif
|
||||
" Check for opening conditional on previous line
|
||||
if pline =~ '^\s*\([(;]\|->\)'
|
||||
let ind = ind + &sw
|
||||
endif
|
||||
" Check for closing an unclosed paren, or middle ; or ->
|
||||
if line =~ '^\s*\([);]\|->\)'
|
||||
let ind = ind - &sw
|
||||
endif
|
||||
return ind
|
||||
endfunction
|
||||
8
runtime/indent/pyrex.vim
Normal file
8
runtime/indent/pyrex.vim
Normal file
@ -0,0 +1,8 @@
|
||||
" Vim indent file
|
||||
" Language: Pyrex
|
||||
" Maintainer: Marco Barisione <marco.bari@people.it>
|
||||
" URL: http://marcobari.altervista.org/pyrex_vim.html
|
||||
" Last Change: 2004 May 16
|
||||
|
||||
" Use Python formatting rules
|
||||
runtime! indent/python.vim
|
||||
175
runtime/indent/python.vim
Normal file
175
runtime/indent/python.vim
Normal file
@ -0,0 +1,175 @@
|
||||
" Vim indent file
|
||||
" Language: Python
|
||||
" Maintainer: Bram Moolenaar <Bram@vim.org>
|
||||
" Original Author: David Bustos <bustos@caltech.edu>
|
||||
" Last Change: 2003 Sep 08
|
||||
|
||||
" Only load this indent file when no other was loaded.
|
||||
if exists("b:did_indent")
|
||||
finish
|
||||
endif
|
||||
let b:did_indent = 1
|
||||
|
||||
" Some preliminary settings
|
||||
setlocal nolisp " Make sure lisp indenting doesn't supersede us
|
||||
setlocal autoindent " indentexpr isn't much help otherwise
|
||||
|
||||
setlocal indentexpr=GetPythonIndent(v:lnum)
|
||||
setlocal indentkeys+=<:>,=elif,=except
|
||||
|
||||
" Only define the function once.
|
||||
if exists("*GetPythonIndent")
|
||||
finish
|
||||
endif
|
||||
|
||||
let s:maxoff = 50 " maximum number of lines to look backwards for ()
|
||||
|
||||
function GetPythonIndent(lnum)
|
||||
" If this line is explicitly joined: If the previous line was also joined,
|
||||
" line it up with that one, otherwise add two 'shiftwidth'
|
||||
if getline(a:lnum - 1) =~ '\\$'
|
||||
if a:lnum > 1 && getline(a:lnum - 2) =~ '\\$'
|
||||
return indent(a:lnum - 1)
|
||||
endif
|
||||
return indent(a:lnum - 1) + (&sw * 2)
|
||||
endif
|
||||
|
||||
" If the start of the line is in a string don't change the indent.
|
||||
if has('syntax_items')
|
||||
\ && synIDattr(synID(a:lnum, 1, 1), "name") == "pythonString"
|
||||
return -1
|
||||
endif
|
||||
|
||||
" Search backwards for the previous non-empty line.
|
||||
let plnum = prevnonblank(v:lnum - 1)
|
||||
|
||||
if plnum == 0
|
||||
" This is the first non-empty line, use zero indent.
|
||||
return 0
|
||||
endif
|
||||
|
||||
" If the previous line is inside parenthesis, use the indent of the starting
|
||||
" line.
|
||||
" Trick: use the non-existing "dummy" variable to break out of the loop when
|
||||
" going too far back.
|
||||
call cursor(plnum, 1)
|
||||
let parlnum = searchpair('(', '', ')', 'nbW',
|
||||
\ "line('.') < " . (plnum - s:maxoff) . " ? dummy :"
|
||||
\ . " synIDattr(synID(line('.'), col('.'), 1), 'name')"
|
||||
\ . " =~ 'python\\(Comment\\|String\\)'")
|
||||
if parlnum > 0
|
||||
let plindent = indent(parlnum)
|
||||
let plnumstart = parlnum
|
||||
else
|
||||
let plindent = indent(plnum)
|
||||
let plnumstart = plnum
|
||||
endif
|
||||
|
||||
|
||||
" When inside parenthesis: If at the first line below the parenthesis add
|
||||
" two 'shiftwidth', otherwise same as previous line.
|
||||
" i = (a
|
||||
" + b
|
||||
" + c)
|
||||
call cursor(a:lnum, 1)
|
||||
let p = searchpair('(', '', ')', 'bW',
|
||||
\ "line('.') < " . (a:lnum - s:maxoff) . " ? dummy :"
|
||||
\ . " synIDattr(synID(line('.'), col('.'), 1), 'name')"
|
||||
\ . " =~ 'python\\(Comment\\|String\\)'")
|
||||
if p > 0
|
||||
if p == plnum
|
||||
" When the start is inside parenthesis, only indent one 'shiftwidth'.
|
||||
let pp = searchpair('(', '', ')', 'bW',
|
||||
\ "line('.') < " . (a:lnum - s:maxoff) . " ? dummy :"
|
||||
\ . " synIDattr(synID(line('.'), col('.'), 1), 'name')"
|
||||
\ . " =~ 'python\\(Comment\\|String\\)'")
|
||||
if pp > 0
|
||||
return indent(plnum) + &sw
|
||||
endif
|
||||
return indent(plnum) + (&sw * 2)
|
||||
endif
|
||||
if plnumstart == p
|
||||
return indent(plnum)
|
||||
endif
|
||||
return plindent
|
||||
endif
|
||||
|
||||
|
||||
" Get the line and remove a trailing comment.
|
||||
" Use syntax highlighting attributes when possible.
|
||||
let pline = getline(plnum)
|
||||
let pline_len = strlen(pline)
|
||||
let col = 0
|
||||
while col < pline_len
|
||||
if pline[col] == '#' && (!has('syntax_items')
|
||||
\ || synIDattr(synID(plnum, col + 1, 1), "name") == "pythonComment")
|
||||
let pline = strpart(pline, 0, col)
|
||||
break
|
||||
endif
|
||||
let col = col + 1
|
||||
endwhile
|
||||
|
||||
" If the previous line ended with a colon, indent this line
|
||||
if pline =~ ':\s*$'
|
||||
return plindent + &sw
|
||||
endif
|
||||
|
||||
" If the previous line was a stop-execution statement...
|
||||
if getline(plnum) =~ '^\s*\(break\|continue\|raise\|return\)\>'
|
||||
" See if the user has already dedented
|
||||
if indent(a:lnum) > indent(plnum) - &sw
|
||||
" If not, recommend one dedent
|
||||
return indent(plnum) - &sw
|
||||
endif
|
||||
" Otherwise, trust the user
|
||||
return -1
|
||||
endif
|
||||
|
||||
" If the current line begins with a keyword that lines up with "try"
|
||||
if getline(a:lnum) =~ '^\s*\(except\|finally\)\>'
|
||||
let lnum = a:lnum - 1
|
||||
while lnum >= 1
|
||||
echomsg 'got here'
|
||||
if getline(lnum) =~ '^\s*\(try\|except\)\>'
|
||||
let ind = indent(lnum)
|
||||
echomsg 'got here, indent is ' . ind
|
||||
if ind >= indent(a:lnum)
|
||||
return -1 " indent is already less than this
|
||||
endif
|
||||
return ind " line up with previous try or except
|
||||
endif
|
||||
let lnum = lnum - 1
|
||||
endwhile
|
||||
echomsg 'got to the end'
|
||||
return -1 " no matching "try"!
|
||||
endif
|
||||
|
||||
" If the current line begins with a header keyword, dedent
|
||||
if getline(a:lnum) =~ '^\s*\(elif\|else\)\>'
|
||||
|
||||
" Unless the previous line was a one-liner
|
||||
if getline(plnumstart) =~ '^\s*\(for\|if\|try\)\>'
|
||||
return plindent
|
||||
endif
|
||||
|
||||
" Or the user has already dedented
|
||||
if indent(a:lnum) <= plindent - &sw
|
||||
return -1
|
||||
endif
|
||||
|
||||
return plindent - &sw
|
||||
endif
|
||||
|
||||
" When after a () construct we probably want to go back to the start line.
|
||||
" a = (b
|
||||
" + c)
|
||||
" here
|
||||
if parlnum > 0
|
||||
return plindent
|
||||
endif
|
||||
|
||||
return -1
|
||||
|
||||
endfunction
|
||||
|
||||
" vim:sw=2
|
||||
48
runtime/indent/readline.vim
Normal file
48
runtime/indent/readline.vim
Normal file
@ -0,0 +1,48 @@
|
||||
" Vim indent file
|
||||
" Language: readline configuration file
|
||||
" Maintainer: Nikolai Weibull <source@pcppopper.org>
|
||||
" URL: http://www.pcppopper.org/vim/indent/pcp/readline/
|
||||
" Latest Revision: 2004-04-25
|
||||
" arch-tag: ee681235-3abf-4a42-8587-edabd409a980
|
||||
|
||||
" Only load this indent file when no other was loaded.
|
||||
if exists("b:did_indent")
|
||||
finish
|
||||
endif
|
||||
|
||||
let b:did_indent = 1
|
||||
|
||||
setlocal indentexpr=GetReadlineIndent()
|
||||
setlocal indentkeys=!^F,o,O,=$else,=$endif
|
||||
|
||||
" Only define the function once.
|
||||
if exists("*GetReadlineIndent")
|
||||
finish
|
||||
endif
|
||||
|
||||
function GetReadlineIndent()
|
||||
let lnum = prevnonblank(v:lnum - 1)
|
||||
|
||||
if lnum == 0
|
||||
return 0
|
||||
endif
|
||||
|
||||
let line = getline(lnum)
|
||||
let ind = indent(lnum)
|
||||
|
||||
" increase indent if previous line started with $if or $else
|
||||
if line =~ '^\s*$\(if\|else\)\>'
|
||||
let ind = ind + &sw
|
||||
endif
|
||||
|
||||
let line = getline(v:lnum)
|
||||
|
||||
" decrease indent if this line starts with $else or $endif
|
||||
if line =~ '^\s*$\(else\|endif\)\>'
|
||||
let ind = ind - &sw
|
||||
endif
|
||||
|
||||
return ind
|
||||
endfunction
|
||||
|
||||
" vim: set sts=2 sw=2:
|
||||
60
runtime/indent/rpl.vim
Normal file
60
runtime/indent/rpl.vim
Normal file
@ -0,0 +1,60 @@
|
||||
" Vim indent file
|
||||
" Language: RPL/2
|
||||
" Version: 0.2
|
||||
" Last Change: 2002 August 16
|
||||
" Maintainer: BERTRAND Jo<4A>l <rpl2@free.fr>
|
||||
|
||||
" Only load this indent file when no other was loaded.
|
||||
if exists("b:did_indent")
|
||||
finish
|
||||
endif
|
||||
let b:did_indent = 1
|
||||
|
||||
setlocal indentkeys+==~end,=~case,=~if,=~then,=~else,=~do,=~until,=~while,=~repeat,=~select,=~default,=~for,=~start,=~next,=~step,<<>,<>>
|
||||
|
||||
" Define the appropriate indent function but only once
|
||||
setlocal indentexpr=RplGetFreeIndent()
|
||||
if exists("*RplGetFreeIndent")
|
||||
finish
|
||||
endif
|
||||
|
||||
function RplGetIndent(lnum)
|
||||
let ind = indent(a:lnum)
|
||||
let prevline=getline(a:lnum)
|
||||
" Strip tail comment
|
||||
let prevstat=substitute(prevline, '!.*$', '', '')
|
||||
|
||||
" Add a shiftwidth to statements following if, iferr, then, else, elseif,
|
||||
" case, select, default, do, until, while, repeat, for, start
|
||||
if prevstat =~? '\<\(if\|iferr\|do\|while\)\>' && prevstat =~? '\<end\>'
|
||||
elseif prevstat =~? '\(^\|\s\+\)<<\($\|\s\+\)' && prevstat =~? '\s\+>>\($\|\s\+\)'
|
||||
elseif prevstat =~? '\<\(if\|iferr\|then\|else\|elseif\|select\|case\|do\|until\|while\|repeat\|for\|start\|default\)\>' || prevstat =~? '\(^\|\s\+\)<<\($\|\s\+\)'
|
||||
let ind = ind + &sw
|
||||
endif
|
||||
|
||||
" Subtract a shiftwidth from then, else, elseif, end, until, repeat, next,
|
||||
" step
|
||||
let line = getline(v:lnum)
|
||||
if line =~? '^\s*\(then\|else\|elseif\|until\|repeat\|next\|step\|default\|end\)\>'
|
||||
let ind = ind - &sw
|
||||
elseif line =~? '^\s*>>\($\|\s\+\)'
|
||||
let ind = ind - &sw
|
||||
endif
|
||||
|
||||
return ind
|
||||
endfunction
|
||||
|
||||
function RplGetFreeIndent()
|
||||
" Find the previous non-blank line
|
||||
let lnum = prevnonblank(v:lnum - 1)
|
||||
|
||||
" Use zero indent at the top of the file
|
||||
if lnum == 0
|
||||
return 0
|
||||
endif
|
||||
|
||||
let ind=RplGetIndent(lnum)
|
||||
return ind
|
||||
endfunction
|
||||
|
||||
" vim:sw=2 tw=130
|
||||
60
runtime/indent/rst.vim
Normal file
60
runtime/indent/rst.vim
Normal file
@ -0,0 +1,60 @@
|
||||
" Vim indent file
|
||||
" Language: reStructuredText Documentation Format
|
||||
" Maintainer: Nikolai Weibull <source@pcppopper.org>
|
||||
" URL: http://www.pcppopper.org/vim/indent/pcp/rst/
|
||||
" Latest Revision: 2004-04-25
|
||||
" arch-tag: 3fe10f75-24d0-4d94-a924-0ce945958104
|
||||
|
||||
" Only load this indent file when no other was loaded.
|
||||
if exists("b:did_indent")
|
||||
finish
|
||||
endif
|
||||
|
||||
let b:did_indent = 1
|
||||
|
||||
setlocal indentexpr=GetRSTIndent()
|
||||
setlocal indentkeys-=:,0# indentkeys-=e
|
||||
|
||||
" Only define the function once.
|
||||
if exists("*GetRSTIndent")
|
||||
finish
|
||||
endif
|
||||
|
||||
function GetRSTIndent()
|
||||
let lnum = prevnonblank(v:lnum - 1)
|
||||
|
||||
if lnum == 0
|
||||
return 0
|
||||
endif
|
||||
|
||||
let ind = indent(lnum)
|
||||
let line = getline(lnum)
|
||||
|
||||
if line =~ '^\s*[-*+]\s'
|
||||
let ind = ind + 2
|
||||
elseif line =~ '^\s*\d\+.\s'
|
||||
let ind = ind + matchend(substitute(line, '^\s*', '', ''), '\d\+.\s\+')
|
||||
endif
|
||||
|
||||
let line = getline(v:lnum - 1)
|
||||
|
||||
if line =~ '^\s*$'
|
||||
execute lnum
|
||||
call search('^\s*\%([-*+]\s\|\d\+.\s\|\.\.\|$\)', 'bW')
|
||||
let line = getline('.')
|
||||
if line =~ '^\s*[-*+]'
|
||||
let ind = ind - 2
|
||||
elseif line =~ '^\s*\d\+\.\s'
|
||||
let ind = ind - matchend(substitute(line, '^\s*', '', ''),
|
||||
\ '\d\+\.\s\+')
|
||||
elseif line =~ '^\s*\.\.'
|
||||
let ind = ind - 3
|
||||
else
|
||||
let ind = ind
|
||||
endif
|
||||
endif
|
||||
|
||||
return ind
|
||||
endfunction
|
||||
|
||||
" vim: set sts=2 sw=2:
|
||||
67
runtime/indent/ruby.vim
Normal file
67
runtime/indent/ruby.vim
Normal file
@ -0,0 +1,67 @@
|
||||
" Vim indent file
|
||||
" Language: Ruby
|
||||
" Maintainer: Gavin Sinclair <gsinclair@soyabean.com.au>
|
||||
" Last Change: 2003 May 11
|
||||
" URL: www.soyabean.com.au/gavin/vim/index.html
|
||||
" Changes: (since vim 6.1)
|
||||
" - indentation after a line ending in comma, etc, (even in a comment) was
|
||||
" broken, now fixed (2002/08/14)
|
||||
|
||||
" Only load this indent file when no other was loaded.
|
||||
if exists("b:did_indent")
|
||||
finish
|
||||
endif
|
||||
let b:did_indent = 1
|
||||
|
||||
setlocal indentexpr=GetRubyIndent()
|
||||
setlocal nolisp
|
||||
setlocal nosmartindent
|
||||
setlocal autoindent
|
||||
setlocal indentkeys+==end,=else,=elsif,=when,=ensure,=rescue
|
||||
|
||||
" Only define the function once.
|
||||
if exists("*GetRubyIndent")
|
||||
finish
|
||||
endif
|
||||
|
||||
function GetRubyIndent()
|
||||
" Find a non-blank line above the current line.
|
||||
let lnum = prevnonblank(v:lnum - 1)
|
||||
|
||||
" At the start of the file use zero indent.
|
||||
if lnum == 0
|
||||
return 0
|
||||
endif
|
||||
|
||||
" If the line trailed with [*+,.(] - but not in a comment - trust the user
|
||||
if getline(lnum) =~ '\(\[^#\].*\)?\(\*\|\.\|+\|,\|(\)\(\s*#.*\)\=$'
|
||||
return -1
|
||||
endif
|
||||
|
||||
" Add a 'shiftwidth' after lines beginning with:
|
||||
" module, class, dev, if, for, while, until, else, elsif, case, when, {
|
||||
let ind = indent(lnum)
|
||||
let flag = 0
|
||||
if getline(lnum) =~ '^\s*\(module\>\|class\>\|def\>\|if\>\|for\>\|while\>\|until\>\|else\>\|elsif\>\|case\>\|when\>\|unless\|begin\|ensure\>\|rescue\>\)'
|
||||
\ || getline(lnum) =~ '{\s*$'
|
||||
\ || getline(lnum) =~ '\({\|\<do\>\).*|.*|\s*$'
|
||||
\ || getline(lnum) =~ '\<do\>\(\s*#.*\)\=$'
|
||||
let ind = ind + &sw
|
||||
let flag = 1
|
||||
endif
|
||||
|
||||
" Subtract a 'shiftwidth' after lines ending with
|
||||
" "end" when they begin with while, if, for, until
|
||||
if flag == 1 && getline(lnum) =~ '\<end\>\(\s*#.*\)\=$'
|
||||
let ind = ind - &sw
|
||||
endif
|
||||
|
||||
" Subtract a 'shiftwidth' on end, else and, elsif, when and }
|
||||
if getline(v:lnum) =~ '^\s*\(end\>\|else\>\|elsif\>\|when\>\|ensure\>\|rescue\>\|}\)'
|
||||
let ind = ind - &sw
|
||||
endif
|
||||
|
||||
return ind
|
||||
endfunction
|
||||
|
||||
" vim:sw=2
|
||||
89
runtime/indent/sdl.vim
Normal file
89
runtime/indent/sdl.vim
Normal file
@ -0,0 +1,89 @@
|
||||
" Vim indent file
|
||||
" Language: SDL
|
||||
" Maintainer: Michael Piefel <piefel@informatik.hu-berlin.de>
|
||||
" Last Change: 2001 Sep 17
|
||||
|
||||
" Shamelessly stolen from the Vim-Script indent file
|
||||
|
||||
" Only load this indent file when no other was loaded.
|
||||
if exists("b:did_indent")
|
||||
finish
|
||||
endif
|
||||
let b:did_indent = 1
|
||||
|
||||
setlocal indentexpr=GetSDLIndent()
|
||||
setlocal indentkeys+==~end,=~state,*<Return>
|
||||
|
||||
" Only define the function once.
|
||||
if exists("*GetSDLIndent")
|
||||
" finish
|
||||
endif
|
||||
|
||||
set cpo-=C
|
||||
|
||||
function! GetSDLIndent()
|
||||
" Find a non-blank line above the current line.
|
||||
let lnum = prevnonblank(v:lnum - 1)
|
||||
|
||||
" At the start of the file use zero indent.
|
||||
if lnum == 0
|
||||
return 0
|
||||
endif
|
||||
|
||||
let ind = indent(lnum)
|
||||
let virtuality = '^\s*\(\(virtual\|redefined\|finalized\)\s\+\)\=\s*'
|
||||
|
||||
" Add a single space to comments which use asterisks
|
||||
if getline(lnum) =~ '^\s*\*'
|
||||
let ind = ind - 1
|
||||
endif
|
||||
if getline(v:lnum) =~ '^\s*\*'
|
||||
let ind = ind + 1
|
||||
endif
|
||||
|
||||
" Add a 'shiftwidth' after states, different blocks, decision (and alternatives), inputs
|
||||
if (getline(lnum) =~? '^\s*\(start\|state\|system\|package\|connection\|channel\|alternative\|macro\|operator\|newtype\|select\|substructure\|decision\|generator\|refinement\|service\|method\|exceptionhandler\|asntype\|syntype\|value\|(.*):\|\(priority\s\+\)\=input\|provided\)'
|
||||
\ || getline(lnum) =~? virtuality . '\(process\|procedure\|block\|object\)')
|
||||
\ && getline(lnum) !~? 'end[[:alpha:]]\+;$'
|
||||
let ind = ind + &sw
|
||||
endif
|
||||
|
||||
" Subtract a 'shiftwidth' after states
|
||||
if getline(lnum) =~? '^\s*\(stop\|return\>\|nextstate\)'
|
||||
let ind = ind - &sw
|
||||
endif
|
||||
|
||||
" Subtract a 'shiftwidth' on on end (uncompleted line)
|
||||
if getline(v:lnum) =~? '^\s*end\>'
|
||||
let ind = ind - &sw
|
||||
endif
|
||||
|
||||
" Put each alternatives where the corresponding decision was
|
||||
if getline(v:lnum) =~? '^\s*\((.*)\|else\):'
|
||||
normal k
|
||||
let ind = indent(searchpair('^\s*decision', '', '^\s*enddecision', 'bW',
|
||||
\ 'synIDattr(synID(line("."), col("."), 0), "name") =~? "sdlString"'))
|
||||
endif
|
||||
|
||||
" Put each state where the preceding state was
|
||||
if getline(v:lnum) =~? '^\s*state\>'
|
||||
let ind = indent(search('^\s*start', 'bW'))
|
||||
endif
|
||||
|
||||
" Systems and packages are always in column 0
|
||||
if getline(v:lnum) =~? '^\s*\(\(end\)\=system\|\(end\)\=package\)'
|
||||
return 0;
|
||||
endif
|
||||
|
||||
" Put each end* where the corresponding begin was
|
||||
if getline(v:lnum) =~? '^\s*end[[:alpha:]]'
|
||||
normal k
|
||||
let partner=matchstr(getline(v:lnum), '\(' . virtuality . 'end\)\@<=[[:alpha:]]\+')
|
||||
let ind = indent(searchpair(virtuality . partner, '', '^\s*end' . partner, 'bW',
|
||||
\ 'synIDattr(synID(line("."), col("."), 0), "name") =~? "sdlString"'))
|
||||
endif
|
||||
|
||||
return ind
|
||||
endfunction
|
||||
|
||||
" vim:sw=2
|
||||
58
runtime/indent/sh.vim
Normal file
58
runtime/indent/sh.vim
Normal file
@ -0,0 +1,58 @@
|
||||
" Vim indent file
|
||||
" Language: Shell Script
|
||||
" Maintainer: Nikolai Weibull <source@pcppopper.org>
|
||||
" URL: http://www.pcppopper.org/vim/indent/pcp/sh/
|
||||
" Latest Revision: 2004-04-25
|
||||
" arch-tag: 431c7fc1-12a6-4d71-9636-1498ef56b038
|
||||
|
||||
" Only load this indent file when no other was loaded.
|
||||
if exists("b:did_indent")
|
||||
finish
|
||||
endif
|
||||
|
||||
let b:did_indent = 1
|
||||
|
||||
setlocal indentexpr=GetShIndent()
|
||||
setlocal indentkeys+==then,=do,=else,=elif,=esac,=fi,=fin,=fil,=done
|
||||
setlocal indentkeys-=:,0#
|
||||
|
||||
" Only define the function once.
|
||||
if exists("*GetShIndent")
|
||||
finish
|
||||
endif
|
||||
|
||||
set cpoptions-=C
|
||||
|
||||
function GetShIndent()
|
||||
" Find a non-blank line above the current line.
|
||||
let lnum = prevnonblank(v:lnum - 1)
|
||||
|
||||
" Hit the start of the file, use zero indent.
|
||||
if lnum == 0
|
||||
return 0
|
||||
endif
|
||||
|
||||
" Add a 'shiftwidth' after if, while, else, case, until, for, function()
|
||||
" Skip if the line also contains the closure for the above
|
||||
let ind = indent(lnum)
|
||||
let line = getline(lnum)
|
||||
if line =~ '^\s*\(if\|then\|do\|else\|elif\|case\|while\|until\|for\)\>'
|
||||
\ || line =~ '^\s*\<\h\w*\>\s*()\s*{'
|
||||
\ || line =~ '^\s*{'
|
||||
if line !~ '\(esac\|fi\|done\)\>\s*$' && line !~ '}\s*$'
|
||||
let ind = ind + &sw
|
||||
endif
|
||||
endif
|
||||
|
||||
" Subtract a 'shiftwidth' on a then, do, else, esac, fi, done
|
||||
" Retain the indentation level if line matches fin (for find)
|
||||
let line = getline(v:lnum)
|
||||
if (line =~ '^\s*\(then\|do\|else\|elif\|esac\|fi\|done\)\>' || line =~ '^\s*}')
|
||||
\ && line !~ '^\s*fi[ln]\>'
|
||||
let ind = ind - &sw
|
||||
endif
|
||||
|
||||
return ind
|
||||
endfunction
|
||||
|
||||
" vim: set sts=2 sw=2:
|
||||
123
runtime/indent/tcl.vim
Normal file
123
runtime/indent/tcl.vim
Normal file
@ -0,0 +1,123 @@
|
||||
" Vim indent file
|
||||
" Language: Tcl
|
||||
" Maintainer: Nikolai Weibull <source@pcppopper.org>
|
||||
" URL: http://www.pcppopper.org/vim/indent/pcp/tcl/
|
||||
" Latest Revision: 2004-05-21
|
||||
" arch-tag: 64fab1fa-d670-40ab-a191-55678f20ceb0
|
||||
|
||||
" only load this indent file when no other was loaded.
|
||||
if exists("b:did_indent")
|
||||
finish
|
||||
endif
|
||||
|
||||
let b:did_indent = 1
|
||||
|
||||
setlocal indentexpr=GetTclIndent()
|
||||
setlocal indentkeys-=:,0#
|
||||
setlocal indentkeys+=0]
|
||||
|
||||
" only define the function once.
|
||||
if exists("*GetTclIndent")
|
||||
finish
|
||||
endif
|
||||
|
||||
function s:PrevNonBlankNonComment(lnum)
|
||||
let lnum = prevnonblank(a:lnum)
|
||||
while lnum > 0
|
||||
let line = getline(lnum)
|
||||
if line !~ '^\s*\(#\|$\)'
|
||||
break
|
||||
endif
|
||||
let lnum = prevnonblank(lnum - 1)
|
||||
endwhile
|
||||
return lnum
|
||||
endfunction
|
||||
|
||||
function! GetTclIndent()
|
||||
let lnum = s:PrevNonBlankNonComment(v:lnum - 1)
|
||||
|
||||
if lnum == 0
|
||||
return 0
|
||||
endif
|
||||
|
||||
let line = getline(lnum)
|
||||
let ind = indent(lnum)
|
||||
|
||||
" TODO: Possible improvement, check that 'begin' and 'end' aren't inside a
|
||||
" comment or string. This will mess it up. As I am pressed for time and
|
||||
" stuff like this is unlikely to happen I won't deal with it in this
|
||||
" version.
|
||||
let open = 0
|
||||
let begin = match(line, '{', 0)
|
||||
while begin > -1
|
||||
let end = match(line, '}', begin + 1)
|
||||
if end < 0
|
||||
let open = open + 1
|
||||
else
|
||||
let tmp = match(line, '{', begin + 1)
|
||||
if tmp != -1 && tmp < end
|
||||
let open = open + 1
|
||||
endif
|
||||
endif
|
||||
let begin = match(line, '{', begin + 1)
|
||||
endwhile
|
||||
|
||||
let begin = match(line, '[', 0)
|
||||
while begin > -1
|
||||
let end = match(line, ']', begin + 1)
|
||||
if end < 0
|
||||
let open = open + 1
|
||||
else
|
||||
let tmp = match(line, '{', begin + 1)
|
||||
if tmp != -1 && tmp < end
|
||||
let open = open + 1
|
||||
endif
|
||||
endif
|
||||
let begin = match(line, '{', begin + 1)
|
||||
endwhile
|
||||
|
||||
let close = 0
|
||||
let prev = 0
|
||||
let end = matchend(line, '^\s*}.*}', prev)
|
||||
while end > -1
|
||||
let begin = match(line, '{', prev + 1)
|
||||
if begin < 0 || begin > prev
|
||||
let close = close + 1
|
||||
endif
|
||||
let prev = end
|
||||
let end = match(line, '}', prev + 1)
|
||||
endwhile
|
||||
|
||||
let prev = 0
|
||||
let end = match(line, ']', prev)
|
||||
while end > -1
|
||||
let begin = match(line, '[', prev + 1)
|
||||
if begin < 0 || begin > prev
|
||||
let close = close + 1
|
||||
endif
|
||||
let prev = end
|
||||
let end = match(line, ']', prev + 1)
|
||||
endwhile
|
||||
|
||||
let ind = ind + (open - close) * &sw
|
||||
|
||||
let line = getline(v:lnum)
|
||||
|
||||
let close = 0
|
||||
let prev = 0
|
||||
let end = match(line, '}', prev)
|
||||
while end > -1
|
||||
let begin = match(line, '{', prev + 1)
|
||||
if begin < 0 || begin > prev
|
||||
let close = close + 1
|
||||
endif
|
||||
let prev = end
|
||||
let end = match(line, '}', prev + 1)
|
||||
endwhile
|
||||
|
||||
let ind = ind - close * &sw
|
||||
|
||||
return ind >= 0 ? ind : 0
|
||||
endfunction
|
||||
|
||||
" vim: set sts=2 sw=2:
|
||||
51
runtime/indent/tcsh.vim
Normal file
51
runtime/indent/tcsh.vim
Normal file
@ -0,0 +1,51 @@
|
||||
" Vim indent file
|
||||
" Language: C-shell (tcsh)
|
||||
" Maintainor: Gautam Iyer <gautam@math.uchicago.edu>
|
||||
" Last Modified: Wed 04 Feb 2004 04:36:07 PM CST
|
||||
|
||||
" Only load this indent file when no other was loaded.
|
||||
if exists("b:did_indent")
|
||||
finish
|
||||
endif
|
||||
|
||||
let b:did_indent = 1
|
||||
|
||||
setlocal indentexpr=TcshGetIndent()
|
||||
setlocal indentkeys+=e,0=end,0=endsw,*<return> indentkeys-=0{,0},0),:,0#
|
||||
|
||||
" Only define the function once.
|
||||
if exists("*TcshGetIndent")
|
||||
finish
|
||||
endif
|
||||
|
||||
set cpoptions-=C
|
||||
|
||||
function TcshGetIndent()
|
||||
" Find a non-blank line above the current line.
|
||||
let lnum = prevnonblank(v:lnum - 1)
|
||||
|
||||
" Hit the start of the file, use zero indent.
|
||||
if lnum == 0
|
||||
return 0
|
||||
endif
|
||||
|
||||
" Add indent if previous line begins with while or foreach
|
||||
" OR line ends with case <str>:, default:, else, then or \
|
||||
let ind = indent(lnum)
|
||||
let line = getline(lnum)
|
||||
if line =~ '\v^\s*%(while|foreach)>|^\s*%(case\s.*:|default:|else)\s*$|%(<then|\\)$'
|
||||
let ind = ind + &sw
|
||||
endif
|
||||
|
||||
if line =~ '\v^\s*breaksw>'
|
||||
let ind = ind - &sw
|
||||
endif
|
||||
|
||||
" Subtract indent if current line has on end, endif, case commands
|
||||
let line = getline(v:lnum)
|
||||
if line =~ '\v^\s*%(else|end|endif)\s*$'
|
||||
let ind = ind - &sw
|
||||
endif
|
||||
|
||||
return ind
|
||||
endfunction
|
||||
36
runtime/indent/tilde.vim
Normal file
36
runtime/indent/tilde.vim
Normal file
@ -0,0 +1,36 @@
|
||||
"Description: Indent scheme for the tilde weblanguage
|
||||
"Author: Tobias Rundstr<74>m <tobi@tobi.nu>
|
||||
"URL: http://tilde.tildesoftware.net
|
||||
"Last Change: May 8 09:15:09 CEST 2002
|
||||
|
||||
if exists ("b:did_indent")
|
||||
finish
|
||||
endif
|
||||
|
||||
let b:did_indent = 1
|
||||
|
||||
setlocal autoindent
|
||||
setlocal indentexpr=GetTildeIndent(v:lnum)
|
||||
setlocal indentkeys=o,O,)
|
||||
|
||||
if exists("*GetTildeIndent")
|
||||
finish
|
||||
endif
|
||||
|
||||
function GetTildeIndent(lnum)
|
||||
let plnum = prevnonblank(v:lnum-1)
|
||||
|
||||
if plnum == 0
|
||||
return 0
|
||||
endif
|
||||
|
||||
if getline(v:lnum) =~ '^\s*\~\(endif\|else\|elseif\|end\)\>'
|
||||
return indent(v:lnum) - &sw
|
||||
endif
|
||||
|
||||
if getline(plnum) =~ '^\s*\~\(if\|foreach\|foreach_row\|xml_loop\|file_loop\|file_write\|file_append\|imap_loopsections\|imap_index\|imap_list\|ldap_search\|post_loopall\|post_loop\|file_loop\|sql_loop_num\|sql_dbmsselect\|search\|sql_loop\|post\|for\|function_define\|silent\|while\|setvalbig\|mail_create\|systempipe\|mail_send\|dual\|elseif\|else\)\>'
|
||||
return indent(plnum) + &sw
|
||||
else
|
||||
return -1
|
||||
endif
|
||||
endfunction
|
||||
72
runtime/indent/vb.vim
Normal file
72
runtime/indent/vb.vim
Normal file
@ -0,0 +1,72 @@
|
||||
" Vim indent file
|
||||
" Language: VisualBasic (ft=vb) / Basic (ft=basic) / SaxBasic (ft=vb)
|
||||
" Author: Johannes Zellner <johannes@zellner.org>
|
||||
" Last Change: Tue, 27 Apr 2004 14:54:59 CEST
|
||||
|
||||
if exists("b:did_indent")
|
||||
finish
|
||||
endif
|
||||
let b:did_indent = 1
|
||||
|
||||
setlocal indentexpr=VbGetIndent(v:lnum)
|
||||
setlocal indentkeys&
|
||||
setlocal indentkeys+==~else,=~elseif,=~end,=~wend,=~case,=~next,=~select,~=loop,<:>
|
||||
|
||||
" Only define the function once.
|
||||
if exists("*VbGetIndent")
|
||||
finish
|
||||
endif
|
||||
|
||||
fun! VbGetIndent(lnum)
|
||||
" labels and preprocessor get zero indent immediately
|
||||
let this_line = getline(a:lnum)
|
||||
let LABELS_OR_PREPROC = '^\s*\(\<\k\+\>:\s*$\|#.*\)'
|
||||
if this_line =~? LABELS_OR_PREPROC
|
||||
return 0
|
||||
endif
|
||||
|
||||
" Find a non-blank line above the current line.
|
||||
" Skip over labels and preprocessor directives.
|
||||
let lnum = a:lnum
|
||||
while lnum > 0
|
||||
let lnum = prevnonblank(lnum - 1)
|
||||
let previous_line = getline(lnum)
|
||||
if previous_line !~? LABELS_OR_PREPROC
|
||||
break
|
||||
endif
|
||||
endwhile
|
||||
|
||||
" Hit the start of the file, use zero indent.
|
||||
if lnum == 0
|
||||
return 0
|
||||
endif
|
||||
|
||||
let ind = indent(lnum)
|
||||
|
||||
" Add
|
||||
if previous_line =~? '^\s*\<\(begin\|\%(\%(private\|public\|friend\)\s\+\)\=\%(function\|sub\|property\)\|select\|case\|default\|if\>.\{-}\<then\>\s*$\|else\|elseif\|do\|for\|while\|enum\|with\)\>'
|
||||
let ind = ind + &sw
|
||||
endif
|
||||
|
||||
" Subtract
|
||||
if this_line =~? '^\s*\<end\>\s\+\<select\>'
|
||||
if previous_line !~? '^\s*\<select\>'
|
||||
let ind = ind - 2 * &sw
|
||||
else
|
||||
" this case is for an empty 'select' -- 'end select'
|
||||
" (w/o any case statements) like:
|
||||
"
|
||||
" select case readwrite
|
||||
" end select
|
||||
let ind = ind - &sw
|
||||
endif
|
||||
elseif this_line =~? '^\s*\<\(end\|else\|until\|loop\|next\|wend\)\>'
|
||||
let ind = ind - &sw
|
||||
elseif this_line =~? '^\s*\<\(case\|default\)\>'
|
||||
if previous_line !~? '^\s*\<select\>'
|
||||
let ind = ind - &sw
|
||||
endif
|
||||
endif
|
||||
|
||||
return ind
|
||||
endfun
|
||||
219
runtime/indent/verilog.vim
Normal file
219
runtime/indent/verilog.vim
Normal file
@ -0,0 +1,219 @@
|
||||
" Language: Verilog HDL
|
||||
" Maintainer: Chih-Tsun Huang <cthuang@larc.ee.nthu.edu.tw>
|
||||
" Last Change: Wed Oct 31 16:13:11 CST 2001
|
||||
" URL: http://larc.ee.nthu.edu.tw/~cthuang/vim/indent/verilog.vim
|
||||
"
|
||||
" Credits:
|
||||
" Suggestions for improvement, bug reports by
|
||||
" Leo Butlero <lbutler@brocade.com>
|
||||
"
|
||||
" Buffer Variables:
|
||||
" b:verilog_indent_modules : indenting after the declaration
|
||||
" of module blocks
|
||||
" b:verilog_indent_width : indenting width
|
||||
" b:verilog_indent_verbose : verbose to each indenting
|
||||
"
|
||||
|
||||
" Only load this indent file when no other was loaded.
|
||||
if exists("b:did_indent")
|
||||
finish
|
||||
endif
|
||||
let b:did_indent = 1
|
||||
|
||||
setlocal indentexpr=GetVerilogIndent()
|
||||
setlocal indentkeys=!^F,o,O,0),=begin,=end,=join,=endcase
|
||||
setlocal indentkeys+==endmodule,=endfunction,=endtask,=endspecify
|
||||
setlocal indentkeys+==`else,=`endif
|
||||
|
||||
" Only define the function once.
|
||||
if exists("*GetVerilogIndent")
|
||||
finish
|
||||
endif
|
||||
|
||||
set cpo-=C
|
||||
|
||||
function GetVerilogIndent()
|
||||
|
||||
if exists('b:verilog_indent_width')
|
||||
let offset = b:verilog_indent_width
|
||||
else
|
||||
let offset = &sw
|
||||
endif
|
||||
if exists('b:verilog_indent_modules')
|
||||
let indent_modules = offset
|
||||
else
|
||||
let indent_modules = 0
|
||||
endif
|
||||
|
||||
" Find a non-blank line above the current line.
|
||||
let lnum = prevnonblank(v:lnum - 1)
|
||||
|
||||
" At the start of the file use zero indent.
|
||||
if lnum == 0
|
||||
return 0
|
||||
endif
|
||||
|
||||
let lnum2 = prevnonblank(lnum - 1)
|
||||
let curr_line = getline(v:lnum)
|
||||
let last_line = getline(lnum)
|
||||
let last_line2 = getline(lnum2)
|
||||
let ind = indent(lnum)
|
||||
let ind2 = indent(lnum - 1)
|
||||
let offset_comment1 = 1
|
||||
" Define the condition of an open statement
|
||||
" Exclude the match of //, /* or */
|
||||
let vlog_openstat = '\(\<or\>\|\([*/]\)\@<![*(,{><+-/%^&|!=?:]\([*/]\)\@!\)'
|
||||
" Define the condition when the statement ends with a one-line comment
|
||||
let vlog_comment = '\(//.*\|/\*.*\*/\s*\)'
|
||||
if exists('b:verilog_indent_verbose')
|
||||
let vverb_str = 'INDENT VERBOSE:'
|
||||
let vverb = 1
|
||||
else
|
||||
let vverb = 0
|
||||
endif
|
||||
|
||||
" Indent accoding to last line
|
||||
" End of multiple-line comment
|
||||
if last_line =~ '\*/\s*$' && last_line !~ '/\*.\{-}\*/'
|
||||
let ind = ind - offset_comment1
|
||||
if vverb
|
||||
echo vverb_str "De-indent after a multiple-line comment."
|
||||
endif
|
||||
|
||||
" Indent after if/else/for/case/always/initial/specify/fork blocks
|
||||
elseif last_line =~ '`\@<!\<\(if\|else\)\>' ||
|
||||
\ last_line =~ '^\s*\<\(for\|case\%[[zx]]\)\>' ||
|
||||
\ last_line =~ '^\s*\<\(always\|initial\)\>' ||
|
||||
\ last_line =~ '^\s*\<\(specify\|fork\)\>'
|
||||
if last_line !~ '\(;\|\<end\>\)\s*' . vlog_comment . '*$' ||
|
||||
\ last_line =~ '\(//\|/\*\).*\(;\|\<end\>\)\s*' . vlog_comment . '*$'
|
||||
let ind = ind + offset
|
||||
if vverb | echo vverb_str "Indent after a block statement." | endif
|
||||
endif
|
||||
" Indent after function/task blocks
|
||||
elseif last_line =~ '^\s*\<\(function\|task\)\>'
|
||||
if last_line !~ '\<end\>\s*' . vlog_comment . '*$' ||
|
||||
\ last_line =~ '\(//\|/\*\).*\(;\|\<end\>\)\s*' . vlog_comment . '*$'
|
||||
let ind = ind + offset
|
||||
if vverb
|
||||
echo vverb_str "Indent after function/task block statement."
|
||||
endif
|
||||
endif
|
||||
|
||||
" Indent after module/function/task/specify/fork blocks
|
||||
elseif last_line =~ '^\s*\<module\>'
|
||||
let ind = ind + indent_modules
|
||||
if vverb && indent_modules
|
||||
echo vverb_str "Indent after module statement."
|
||||
endif
|
||||
if last_line =~ '[(,]\s*' . vlog_comment . '*$' &&
|
||||
\ last_line !~ '\(//\|/\*\).*[(,]\s*' . vlog_comment . '*$'
|
||||
let ind = ind + offset
|
||||
if vverb
|
||||
echo vverb_str "Indent after a multiple-line module statement."
|
||||
endif
|
||||
endif
|
||||
|
||||
" Indent after a 'begin' statement
|
||||
elseif last_line =~ '\(\<begin\>\)\(\s*:\s*\w\+\)*' . vlog_comment . '*$' &&
|
||||
\ last_line !~ '\(//\|/\*\).*\(\<begin\>\)' &&
|
||||
\ ( last_line2 !~ vlog_openstat . '\s*' . vlog_comment . '*$' ||
|
||||
\ last_line2 =~ '^\s*[^=!]\+\s*:\s*' . vlog_comment . '*$' )
|
||||
let ind = ind + offset
|
||||
if vverb | echo vverb_str "Indent after begin statement." | endif
|
||||
|
||||
" De-indent for the end of one-line block
|
||||
elseif ( last_line !~ '\<begin\>' ||
|
||||
\ last_line =~ '\(//\|/\*\).*\<begin\>' ) &&
|
||||
\ last_line2 =~ '\<\(`\@<!if\|`\@<!else\|for\|always\|initial\)\>.*' .
|
||||
\ vlog_comment . '*$' &&
|
||||
\ last_line2 !~
|
||||
\ '\(//\|/\*\).*\<\(`\@<!if\|`\@<!else\|for\|always\|initial\)\>' &&
|
||||
\ last_line2 !~ vlog_openstat . '\s*' . vlog_comment . '*$' &&
|
||||
\ ( last_line2 !~ '\<begin\>' ||
|
||||
\ last_line2 =~ '\(//\|/\*\).*\<begin\>' )
|
||||
let ind = ind - offset
|
||||
if vverb
|
||||
echo vverb_str "De-indent after the end of one-line statement."
|
||||
endif
|
||||
|
||||
" Multiple-line statement (including case statement)
|
||||
" Open statement
|
||||
" Ident the first open line
|
||||
elseif last_line =~ vlog_openstat . '\s*' . vlog_comment . '*$' &&
|
||||
\ last_line !~ '\(//\|/\*\).*' . vlog_openstat . '\s*$' &&
|
||||
\ last_line2 !~ vlog_openstat . '\s*' . vlog_comment . '*$'
|
||||
let ind = ind + offset
|
||||
if vverb | echo vverb_str "Indent after an open statement." | endif
|
||||
|
||||
" Close statement
|
||||
" De-indent for an optional close parenthesis and a semicolon, and only
|
||||
" if there exists precedent non-whitespace char
|
||||
elseif last_line =~ ')*\s*;\s*' . vlog_comment . '*$' &&
|
||||
\ last_line !~ '^\s*)*\s*;\s*' . vlog_comment . '*$' &&
|
||||
\ last_line !~ '\(//\|/\*\).*\S)*\s*;\s*' . vlog_comment . '*$' &&
|
||||
\ ( last_line2 =~ vlog_openstat . '\s*' . vlog_comment . '*$' &&
|
||||
\ last_line2 !~ ';\s*//.*$') &&
|
||||
\ last_line2 !~ '^\s*' . vlog_comment . '$'
|
||||
let ind = ind - offset
|
||||
if vverb | echo vverb_str "De-indent after a close statement." | endif
|
||||
|
||||
" `ifdef and `else
|
||||
elseif last_line =~ '^\s*`\<\(ifdef\|else\)\>'
|
||||
let ind = ind + offset
|
||||
if vverb
|
||||
echo vverb_str "Indent after a `ifdef or `else statement."
|
||||
endif
|
||||
|
||||
endif
|
||||
|
||||
" Re-indent current line
|
||||
|
||||
" De-indent on the end of the block
|
||||
" join/end/endcase/endfunction/endtask/endspecify
|
||||
if curr_line =~ '^\s*\<\(join\|end\|endcase\)\>' ||
|
||||
\ curr_line =~ '^\s*\<\(endfunction\|endtask\|endspecify\)\>'
|
||||
let ind = ind - offset
|
||||
if vverb | echo vverb_str "De-indent the end of a block." | endif
|
||||
elseif curr_line =~ '^\s*\<endmodule\>'
|
||||
let ind = ind - indent_modules
|
||||
if vverb && indent_modules
|
||||
echo vverb_str "De-indent the end of a module."
|
||||
endif
|
||||
|
||||
" De-indent on a stand-alone 'begin'
|
||||
elseif curr_line =~ '^\s*\<begin\>'
|
||||
if last_line !~ '^\s*\<\(function\|task\|specify\|module\)\>' &&
|
||||
\ last_line !~ '^\s*\()*\s*;\|)\+\)\s*' . vlog_comment . '*$' &&
|
||||
\ ( last_line =~
|
||||
\ '\<\(`\@<!if\|`\@<!else\|for\|case\%[[zx]]\|always\|initial\)\>' ||
|
||||
\ last_line =~ ')\s*' . vlog_comment . '*$' ||
|
||||
\ last_line =~ vlog_openstat . '\s*' . vlog_comment . '*$' )
|
||||
let ind = ind - offset
|
||||
if vverb
|
||||
echo vverb_str "De-indent a stand alone begin statement."
|
||||
endif
|
||||
endif
|
||||
|
||||
" De-indent after the end of multiple-line statement
|
||||
elseif curr_line =~ '^\s*)' &&
|
||||
\ ( last_line =~ vlog_openstat . '\s*' . vlog_comment . '*$' ||
|
||||
\ last_line !~ vlog_openstat . '\s*' . vlog_comment . '*$' &&
|
||||
\ last_line2 =~ vlog_openstat . '\s*' . vlog_comment . '*$' )
|
||||
let ind = ind - offset
|
||||
if vverb
|
||||
echo vverb_str "De-indent the end of a multiple statement."
|
||||
endif
|
||||
|
||||
" De-indent `else and `endif
|
||||
elseif curr_line =~ '^\s*`\<\(else\|endif\)\>'
|
||||
let ind = ind - offset
|
||||
if vverb | echo vverb_str "De-indent `else and `endif statement." | endif
|
||||
|
||||
endif
|
||||
|
||||
" Return the indention
|
||||
return ind
|
||||
endfunction
|
||||
|
||||
" vim:sw=2
|
||||
65
runtime/indent/vim.vim
Normal file
65
runtime/indent/vim.vim
Normal file
@ -0,0 +1,65 @@
|
||||
" Vim indent file
|
||||
" Language: Vim script
|
||||
" Maintainer: Bram Moolenaar <Bram@vim.org>
|
||||
" Last Change: 2003 May 25
|
||||
|
||||
" Only load this indent file when no other was loaded.
|
||||
if exists("b:did_indent")
|
||||
finish
|
||||
endif
|
||||
let b:did_indent = 1
|
||||
|
||||
setlocal indentexpr=GetVimIndent()
|
||||
setlocal indentkeys+==end,=else,=cat,=fina,=END,0\\
|
||||
|
||||
" Only define the function once.
|
||||
if exists("*GetVimIndent")
|
||||
finish
|
||||
endif
|
||||
|
||||
function GetVimIndent()
|
||||
" Find a non-blank line above the current line.
|
||||
let lnum = prevnonblank(v:lnum - 1)
|
||||
|
||||
" If the current line doesn't start with '\' and below a line that starts
|
||||
" with '\', use the indent of the line above it.
|
||||
if getline(v:lnum) !~ '^\s*\\'
|
||||
while lnum > 0 && getline(lnum) =~ '^\s*\\'
|
||||
let lnum = lnum - 1
|
||||
endwhile
|
||||
endif
|
||||
|
||||
" At the start of the file use zero indent.
|
||||
if lnum == 0
|
||||
return 0
|
||||
endif
|
||||
|
||||
" Add a 'shiftwidth' after :if, :while, :try, :catch, :finally, :function
|
||||
" and :else. Add it three times for a line that starts with '\' after
|
||||
" a line that doesn't.
|
||||
let ind = indent(lnum)
|
||||
if getline(v:lnum) =~ '^\s*\\' && v:lnum > 1 && getline(lnum) !~ '^\s*\\'
|
||||
let ind = ind + &sw * 3
|
||||
elseif getline(lnum) =~ '\(^\||\)\s*\(if\|wh\%[ile]\|try\|cat\%[ch]\|fina\%[lly]\|fu\%[nction]\|el\%[seif]\)\>'
|
||||
let ind = ind + &sw
|
||||
elseif getline(lnum) =~ '^\s*aug\%[roup]' && getline(lnum) !~ '^\s*aug\%[roup]\s*!\=\s\+END'
|
||||
let ind = ind + &sw
|
||||
endif
|
||||
|
||||
" If the previous line contains an "end" after a pipe, but not in an ":au"
|
||||
" command.
|
||||
if getline(lnum) =~ '|\s*\(ene\@!\)' && getline(lnum) !~ '^\s*au\%[tocmd]'
|
||||
let ind = ind - &sw
|
||||
endif
|
||||
|
||||
|
||||
" Subtract a 'shiftwidth' on a :endif, :endwhile, :catch, :finally, :endtry,
|
||||
" :endfun, :else and :augroup END.
|
||||
if getline(v:lnum) =~ '^\s*\(ene\@!\|cat\|fina\|el\|aug\%[roup]\s*!\=\s\+END\)'
|
||||
let ind = ind - &sw
|
||||
endif
|
||||
|
||||
return ind
|
||||
endfunction
|
||||
|
||||
" vim:sw=2
|
||||
42
runtime/indent/xf86conf.vim
Normal file
42
runtime/indent/xf86conf.vim
Normal file
@ -0,0 +1,42 @@
|
||||
" Vim indent file
|
||||
" Language: XFree86 Configuration File
|
||||
" Maintainer: Nikolai Weibull <source@pcppopper.org>
|
||||
" URL: http://www.pcppopper.org/vim/indent/pcp/xf86conf/
|
||||
" Latest Revision: 2004-04-25
|
||||
" arch-tag: 8a42f7b6-5088-49cf-b15b-07696a91c015
|
||||
|
||||
" Only load this indent file when no other was loaded.
|
||||
if exists("b:did_indent")
|
||||
finish
|
||||
endif
|
||||
|
||||
let b:did_indent = 1
|
||||
|
||||
setlocal indentexpr=GetXF86ConfIndent()
|
||||
setlocal indentkeys=!^F,o,O,=End
|
||||
|
||||
" Only define the function once.
|
||||
if exists("*GetXF86ConfIndent")
|
||||
finish
|
||||
endif
|
||||
|
||||
function GetXF86ConfIndent()
|
||||
let lnum = prevnonblank(v:lnum - 1)
|
||||
|
||||
if lnum == 0
|
||||
return 0
|
||||
endif
|
||||
|
||||
let ind = indent(lnum)
|
||||
let line = getline(lnum)
|
||||
|
||||
if line =~? '^\s*\(Sub\)\=Section'
|
||||
let ind = ind + &sw
|
||||
elseif getline(v:lnum) =~? '^\s*End'
|
||||
let ind = ind - &sw
|
||||
endif
|
||||
|
||||
return ind
|
||||
endfunction
|
||||
|
||||
" vim: set sts=2 sw=2:
|
||||
7
runtime/indent/xhtml.vim
Normal file
7
runtime/indent/xhtml.vim
Normal file
@ -0,0 +1,7 @@
|
||||
" Vim indent file
|
||||
" Language: XHTML
|
||||
" Maintainer: Bram Moolenaar <Bram@vim.org> (for now)
|
||||
" Last Change: 2003 Feb 04
|
||||
|
||||
" Handled like HTML for now.
|
||||
runtime! indent/html.vim
|
||||
88
runtime/indent/xml.vim
Normal file
88
runtime/indent/xml.vim
Normal file
@ -0,0 +1,88 @@
|
||||
" Language: xml
|
||||
" Maintainer: Johannes Zellner <johannes@zellner.org>
|
||||
" Last Change: Tue, 27 Apr 2004 14:54:59 CEST
|
||||
" Notes: 1) does not indent pure non-xml code (e.g. embedded scripts)
|
||||
" 2) will be confused by unbalanced tags in comments
|
||||
" or CDATA sections.
|
||||
" TODO: implement pre-like tags, see xml_indent_open / xml_indent_close
|
||||
|
||||
" Only load this indent file when no other was loaded.
|
||||
if exists("b:did_indent")
|
||||
finish
|
||||
endif
|
||||
let b:did_indent = 1
|
||||
|
||||
" [-- local settings (must come before aborting the script) --]
|
||||
setlocal indentexpr=XmlIndentGet(v:lnum,1)
|
||||
setlocal indentkeys=o,O,*<Return>,<>>,<<>,/,{,}
|
||||
|
||||
set cpo-=C
|
||||
|
||||
if !exists('b:xml_indent_open')
|
||||
let b:xml_indent_open = '.\{-}<\a'
|
||||
" pre tag, e.g. <address>
|
||||
" let b:xml_indent_open = '.\{-}<[/]\@!\(address\)\@!'
|
||||
endif
|
||||
|
||||
if !exists('b:xml_indent_close')
|
||||
let b:xml_indent_close = '.\{-}</'
|
||||
" end pre tag, e.g. </address>
|
||||
" let b:xml_indent_close = '.\{-}</\(address\)\@!'
|
||||
endif
|
||||
|
||||
" [-- finish, if the function already exists --]
|
||||
if exists('*XmlIndentGet') | finish | endif
|
||||
|
||||
fun! <SID>XmlIndentWithPattern(line, pat)
|
||||
let s = substitute('x'.a:line, a:pat, "\1", 'g')
|
||||
return strlen(substitute(s, "[^\1].*$", '', ''))
|
||||
endfun
|
||||
|
||||
" [-- check if it's xml --]
|
||||
fun! <SID>XmlIndentSynCheck(lnum)
|
||||
if '' != &syntax
|
||||
let syn1 = synIDattr(synID(a:lnum, 1, 1), 'name')
|
||||
let syn2 = synIDattr(synID(a:lnum, strlen(getline(a:lnum)) - 1, 1), 'name')
|
||||
if '' != syn1 && syn1 !~ 'xml' && '' != syn2 && syn2 !~ 'xml'
|
||||
" don't indent pure non-xml code
|
||||
return 0
|
||||
endif
|
||||
endif
|
||||
return 1
|
||||
endfun
|
||||
|
||||
" [-- return the sum of indents of a:lnum --]
|
||||
fun! <SID>XmlIndentSum(lnum, style, add)
|
||||
let line = getline(a:lnum)
|
||||
if a:style == match(line, '^\s*</')
|
||||
return (&sw *
|
||||
\ (<SID>XmlIndentWithPattern(line, b:xml_indent_open)
|
||||
\ - <SID>XmlIndentWithPattern(line, b:xml_indent_close)
|
||||
\ - <SID>XmlIndentWithPattern(line, '.\{-}/>'))) + a:add
|
||||
else
|
||||
return a:add
|
||||
endif
|
||||
endfun
|
||||
|
||||
fun! XmlIndentGet(lnum, use_syntax_check)
|
||||
" Find a non-empty line above the current line.
|
||||
let lnum = prevnonblank(a:lnum - 1)
|
||||
|
||||
" Hit the start of the file, use zero indent.
|
||||
if lnum == 0
|
||||
return 0
|
||||
endif
|
||||
|
||||
if a:use_syntax_check
|
||||
if 0 == <SID>XmlIndentSynCheck(lnum) || 0 == <SID>XmlIndentSynCheck(a:lnum)
|
||||
return indent(a:lnum)
|
||||
endif
|
||||
endif
|
||||
|
||||
let ind = <SID>XmlIndentSum(lnum, -1, indent(lnum))
|
||||
let ind = <SID>XmlIndentSum(a:lnum, 0, ind)
|
||||
|
||||
return ind
|
||||
endfun
|
||||
|
||||
" vim:ts=8
|
||||
13
runtime/indent/xslt.vim
Normal file
13
runtime/indent/xslt.vim
Normal file
@ -0,0 +1,13 @@
|
||||
" Vim indent file
|
||||
" Language: XSLT .xslt files
|
||||
" Maintainer: David Fishburn <fishburn@ianywhere.com>
|
||||
" Last Change: Wed May 14 2003 8:48:41 PM
|
||||
|
||||
" Only load this indent file when no other was loaded.
|
||||
if exists("b:did_indent")
|
||||
finish
|
||||
endif
|
||||
|
||||
" Use XML formatting rules
|
||||
runtime! indent/xml.vim
|
||||
|
||||
44
runtime/indent/yacc.vim
Normal file
44
runtime/indent/yacc.vim
Normal file
@ -0,0 +1,44 @@
|
||||
" Vim indent file
|
||||
" Language: YACC input file
|
||||
" Maintainer: Nikolai Weibull <source@pcppopper.org>
|
||||
" URL: http://www.pcppopper.org/vim/indent/pcp/yacc/
|
||||
" Latest Revision: 2004-04-25
|
||||
" arch-tag: 629aa719-8fe4-4787-adb7-ae94ca801610
|
||||
|
||||
" Only load this indent file when no other was loaded.
|
||||
if exists("b:did_indent")
|
||||
finish
|
||||
endif
|
||||
|
||||
let b:did_indent = 1
|
||||
|
||||
setlocal indentexpr=GetYaccIndent()
|
||||
setlocal indentkeys=!^F,o,O
|
||||
|
||||
" Only define the function once.
|
||||
if exists("*GetYaccIndent")
|
||||
finish
|
||||
endif
|
||||
|
||||
function GetYaccIndent()
|
||||
if v:lnum == 1
|
||||
return 0
|
||||
endif
|
||||
|
||||
let ind = indent(v:lnum - 1)
|
||||
let line = getline(v:lnum - 1)
|
||||
|
||||
if line == ''
|
||||
let ind = 0
|
||||
elseif line =~ '^\w\+\s*:'
|
||||
let ind = ind + matchend(line, '^\w\+\s*')
|
||||
elseif line =~ '^\s*;'
|
||||
let ind = 0
|
||||
else
|
||||
let ind = indent(v:lnum)
|
||||
endif
|
||||
|
||||
return ind
|
||||
endfunction
|
||||
|
||||
" vim: set sts=2 sw=2:
|
||||
11
runtime/indent/zsh.vim
Normal file
11
runtime/indent/zsh.vim
Normal file
@ -0,0 +1,11 @@
|
||||
" Vim indent file
|
||||
" Language: Zsh Shell Script
|
||||
" Maintainer: Nikolai Weibull <source@pcppopper.org>
|
||||
" URL: http://www.pcppopper.org/vim/indent/pcp/zsh/
|
||||
" Latest Revision: 2004-05-22
|
||||
" arch-tag: e566f55f-d8c0-4c60-b4b3-60c0dbd6dea1
|
||||
|
||||
" Same as sh indenting for now.
|
||||
runtime! indent/sh.vim
|
||||
|
||||
" vim: set sts=2 sw=2:
|
||||
Reference in New Issue
Block a user