inital checkin using existing vim and preparing for use of bash_magic
This commit is contained in:
322
vim/bundle/ubuntu-vim72/indent/GenericIndent.vim
Normal file
322
vim/bundle/ubuntu-vim72/indent/GenericIndent.vim
Normal file
@@ -0,0 +1,322 @@
|
||||
" Vim indent file generic utility functions
|
||||
" Language: * (various)
|
||||
" Maintainer: Dave Silvia <dsilvia@mchsi.com>
|
||||
" Date: 6/30/2004
|
||||
|
||||
" SUMMARY: To use GenericIndent, indent/<your_filename>.vim would have the
|
||||
" following general format:
|
||||
"
|
||||
" if exists("b:did_indent") | finish | endif
|
||||
" let b:did_indent = 1
|
||||
" runtime indent/GenericIndent.vim
|
||||
" let b:indentStmts=''
|
||||
" let b:dedentStmts=''
|
||||
" let b:allStmts=''
|
||||
" setlocal indentexpr=GenericIndent()
|
||||
" setlocal indentkeys=<your_keys>
|
||||
" call GenericIndentStmts(<your_stmts>)
|
||||
" call GenericDedentStmts(<your_stmts>)
|
||||
" call GenericAllStmts()
|
||||
"
|
||||
" END SUMMARY:
|
||||
|
||||
" NOTE: b:indentStmts, b:dedentStmts, and b:allStmts need to be initialized
|
||||
" to '' before callin the functions because 'indent.vim' explicitly
|
||||
" 'unlet's b:did_indent. This means that the lists will compound if
|
||||
" you change back and forth between buffers. This is true as of
|
||||
" version 6.3, 6/23/2004.
|
||||
"
|
||||
" NOTE: By default, GenericIndent is case sensitive.
|
||||
" let b:case_insensitive=1 if you want to ignore case, e.g. DOS batch files
|
||||
|
||||
" The function 'GenericIndent' is data driven and handles most all cases of
|
||||
" indent checking if you first set up the data. To use this function follow
|
||||
" the example below (taken from the file indent/MuPAD_source.vim)
|
||||
"
|
||||
" Before you start, source this file in indent/<your_script>.vim to have it
|
||||
" define functions for your use.
|
||||
"
|
||||
"runtime indent/GenericIndent.vim
|
||||
"
|
||||
" The data is in 5 sets:
|
||||
"
|
||||
" First, set the data set 'indentexpr' to GenericIndent().
|
||||
"
|
||||
"setlocal indentexpr=GenericIndent()
|
||||
"
|
||||
" Second, set the data set 'indentkeys' to the keywords/expressions that need
|
||||
" to be checked for 'indenting' _as_ they typed.
|
||||
"
|
||||
"setlocal indentkeys==end_proc,=else,=then,=elif,=end_if,=end_case,=until,=end_repeat,=end_domain,=end_for,=end_while,=end,o,O
|
||||
"
|
||||
" NOTE: 'o,O' at the end of the previous line says you wish to be called
|
||||
" whenever a newline is placed in the buffer. This allows the previous line
|
||||
" to be checked for indentation parameters.
|
||||
"
|
||||
" Third, set the data set 'b:indentStmts' to the keywords/expressions that, when
|
||||
" they are on a line _when_ you _press_ the _<Enter>_ key,
|
||||
" you wish to have the next line indented.
|
||||
"
|
||||
"call GenericIndentStmts('begin,if,then,else,elif,case,repeat,until,domain,do')
|
||||
"
|
||||
" Fourth, set the data set 'b:dedentStmts' to the keywords/expressions that, when
|
||||
" they are on a line you are currently typing, you wish to have that line
|
||||
" 'dedented' (having already been indented because of the previous line's
|
||||
" indentation).
|
||||
"
|
||||
"call GenericDedentStmts('end_proc,then,else,elif,end_if,end_case,until,end_repeat,end_domain,end_for,end_while,end')
|
||||
"
|
||||
" Fifth, set the data set 'b:allStmts' to the concatenation of the third and
|
||||
" fourth data sets, used for checking when more than one keyword/expression
|
||||
" is on a line.
|
||||
"
|
||||
"call GenericAllStmts()
|
||||
"
|
||||
" NOTE: GenericIndentStmts uses two variables: 'b:indentStmtOpen' and
|
||||
" 'b:indentStmtClose' which default to '\<' and '\>' respectively. You can
|
||||
" set (let) these to any value you wish before calling GenericIndentStmts with
|
||||
" your list. Similarly, GenericDedentStmts uses 'b:dedentStmtOpen' and
|
||||
" 'b:dedentStmtClose'.
|
||||
"
|
||||
" NOTE: Patterns may be used in the lists passed to Generic[In|De]dentStmts
|
||||
" since each element in the list is copied verbatim.
|
||||
"
|
||||
" Optionally, you can set the DEBUGGING flag within your script to have the
|
||||
" debugging messages output. See below for description. This can also be set
|
||||
" (let) from the command line within your editing buffer.
|
||||
"
|
||||
"let b:DEBUGGING=1
|
||||
"
|
||||
" See:
|
||||
" :h runtime
|
||||
" :set runtimepath ?
|
||||
" to familiarize yourself with how this works and where you should have this
|
||||
" file and your file(s) installed.
|
||||
"
|
||||
" For help with setting 'indentkeys' see:
|
||||
" :h indentkeys
|
||||
" Also, for some good examples see 'indent/sh.vim' and 'indent/vim.vim' as
|
||||
" well as files for other languages you may be familiar with.
|
||||
"
|
||||
"
|
||||
" Alternatively, if you'd rather specify yourself, you can enter
|
||||
" 'b:indentStmts', 'b:dedentStmts', and 'b:allStmts' 'literally':
|
||||
"
|
||||
"let b:indentStmts='\<begin\>\|\<if\>\|\<then\>\|\<else\>\|\<elif\>\|\<case\>\|\<repeat\>\|\<until\>\|\<domain\>\|\<do\>'
|
||||
"let b:dedentStmts='\<end_proc\>\|\<else\>\|\<elif\>\|\<end_if\>\|\<end_case\>\|\<until\>\|\<end_repeat\>\|\<end_domain\>\|\<end_for\>\|\<end_while\>\|\<end\>'
|
||||
"let b:allStmts=b:indentStmts.'\|'.b:dedentStmts
|
||||
"
|
||||
" This is only useful if you have particularly different parameters for
|
||||
" matching each statement.
|
||||
|
||||
" RECAP: From indent/MuPAD_source.vim
|
||||
"
|
||||
"if exists("b:did_indent") | finish | endif
|
||||
"
|
||||
"let b:did_indent = 1
|
||||
"
|
||||
"runtime indent/GenericIndent.vim
|
||||
"
|
||||
"setlocal indentexpr=GenericIndent()
|
||||
"setlocal indentkeys==end_proc,=then,=else,=elif,=end_if,=end_case,=until,=end_repeat,=end_domain,=end_for,=end_while,=end,o,O
|
||||
"call GenericIndentStmts('begin,if,then,else,elif,case,repeat,until,domain,do')
|
||||
"call GenericDedentStmts('end_proc,then,else,elif,end_if,end_case,until,end_repeat,end_domain,end_for,end_while,end')
|
||||
"call GenericAllStmts()
|
||||
"
|
||||
" END RECAP:
|
||||
|
||||
let s:hit=0
|
||||
let s:lastVlnum=0
|
||||
let s:myScriptName=expand("<sfile>:t")
|
||||
|
||||
if exists("*GenericIndent")
|
||||
finish
|
||||
endif
|
||||
|
||||
function GenericAllStmts()
|
||||
let b:allStmts=b:indentStmts.'\|'.b:dedentStmts
|
||||
call DebugGenericIndent(expand("<sfile>").": "."b:indentStmts: ".b:indentStmts.", b:dedentStmts: ".b:dedentStmts.", b:allStmts: ".b:allStmts)
|
||||
endfunction
|
||||
|
||||
function GenericIndentStmts(stmts)
|
||||
let Stmts=a:stmts
|
||||
let Comma=match(Stmts,',')
|
||||
if Comma == -1 || Comma == strlen(Stmts)-1
|
||||
echoerr "Must supply a comma separated list of at least 2 entries."
|
||||
echoerr "Supplied list: <".Stmts.">"
|
||||
return
|
||||
endif
|
||||
|
||||
if !exists("b:indentStmtOpen")
|
||||
let b:indentStmtOpen='\<'
|
||||
endif
|
||||
if !exists("b:indentStmtClose")
|
||||
let b:indentStmtClose='\>'
|
||||
endif
|
||||
if !exists("b:indentStmts")
|
||||
let b:indentStmts=''
|
||||
endif
|
||||
if b:indentStmts != ''
|
||||
let b:indentStmts=b:indentStmts.'\|'
|
||||
endif
|
||||
call DebugGenericIndent(expand("<sfile>").": "."b:indentStmtOpen: ".b:indentStmtOpen.", b:indentStmtClose: ".b:indentStmtClose.", b:indentStmts: ".b:indentStmts.", Stmts: ".Stmts)
|
||||
let stmtEntryBegin=0
|
||||
let stmtEntryEnd=Comma
|
||||
let stmtEntry=strpart(Stmts,stmtEntryBegin,stmtEntryEnd-stmtEntryBegin)
|
||||
let Stmts=strpart(Stmts,Comma+1)
|
||||
let Comma=match(Stmts,',')
|
||||
let b:indentStmts=b:indentStmts.b:indentStmtOpen.stmtEntry.b:indentStmtClose
|
||||
while Comma != -1
|
||||
let stmtEntryEnd=Comma
|
||||
let stmtEntry=strpart(Stmts,stmtEntryBegin,stmtEntryEnd-stmtEntryBegin)
|
||||
let Stmts=strpart(Stmts,Comma+1)
|
||||
let Comma=match(Stmts,',')
|
||||
let b:indentStmts=b:indentStmts.'\|'.b:indentStmtOpen.stmtEntry.b:indentStmtClose
|
||||
endwhile
|
||||
let stmtEntry=Stmts
|
||||
let b:indentStmts=b:indentStmts.'\|'.b:indentStmtOpen.stmtEntry.b:indentStmtClose
|
||||
endfunction
|
||||
|
||||
function GenericDedentStmts(stmts)
|
||||
let Stmts=a:stmts
|
||||
let Comma=match(Stmts,',')
|
||||
if Comma == -1 || Comma == strlen(Stmts)-1
|
||||
echoerr "Must supply a comma separated list of at least 2 entries."
|
||||
echoerr "Supplied list: <".Stmts.">"
|
||||
return
|
||||
endif
|
||||
|
||||
if !exists("b:dedentStmtOpen")
|
||||
let b:dedentStmtOpen='\<'
|
||||
endif
|
||||
if !exists("b:dedentStmtClose")
|
||||
let b:dedentStmtClose='\>'
|
||||
endif
|
||||
if !exists("b:dedentStmts")
|
||||
let b:dedentStmts=''
|
||||
endif
|
||||
if b:dedentStmts != ''
|
||||
let b:dedentStmts=b:dedentStmts.'\|'
|
||||
endif
|
||||
call DebugGenericIndent(expand("<sfile>").": "."b:dedentStmtOpen: ".b:dedentStmtOpen.", b:dedentStmtClose: ".b:dedentStmtClose.", b:dedentStmts: ".b:dedentStmts.", Stmts: ".Stmts)
|
||||
let stmtEntryBegin=0
|
||||
let stmtEntryEnd=Comma
|
||||
let stmtEntry=strpart(Stmts,stmtEntryBegin,stmtEntryEnd-stmtEntryBegin)
|
||||
let Stmts=strpart(Stmts,Comma+1)
|
||||
let Comma=match(Stmts,',')
|
||||
let b:dedentStmts=b:dedentStmts.b:dedentStmtOpen.stmtEntry.b:dedentStmtClose
|
||||
while Comma != -1
|
||||
let stmtEntryEnd=Comma
|
||||
let stmtEntry=strpart(Stmts,stmtEntryBegin,stmtEntryEnd-stmtEntryBegin)
|
||||
let Stmts=strpart(Stmts,Comma+1)
|
||||
let Comma=match(Stmts,',')
|
||||
let b:dedentStmts=b:dedentStmts.'\|'.b:dedentStmtOpen.stmtEntry.b:dedentStmtClose
|
||||
endwhile
|
||||
let stmtEntry=Stmts
|
||||
let b:dedentStmts=b:dedentStmts.'\|'.b:dedentStmtOpen.stmtEntry.b:dedentStmtClose
|
||||
endfunction
|
||||
|
||||
" Debugging function. Displays messages in the command area which can be
|
||||
" reviewed using ':messages'. To turn it on use ':let b:DEBUGGING=1'. Once
|
||||
" on, turn off by using ':let b:DEBUGGING=0. If you don't want it at all and
|
||||
" feel it's slowing down your editing (you must have an _awfully_ slow
|
||||
" machine!;-> ), you can just comment out the calls to it from 'GenericIndent'
|
||||
" below. No need to remove the function or the calls, tho', as you never can
|
||||
" tell when they might come in handy!;-)
|
||||
function DebugGenericIndent(msg)
|
||||
if exists("b:DEBUGGING") && b:DEBUGGING
|
||||
echomsg '['.s:hit.']'.s:myScriptName."::".a:msg
|
||||
endif
|
||||
endfunction
|
||||
|
||||
function GenericIndent()
|
||||
" save ignore case option. Have to set noignorecase for the match
|
||||
" functions to do their job the way we want them to!
|
||||
" NOTE: if you add a return to this function be sure you do
|
||||
" if IgnoreCase | set ignorecase | endif
|
||||
" before returning. You can just cut and paste from here.
|
||||
let IgnoreCase=&ignorecase
|
||||
" let b:case_insensitive=1 if you want to ignore case, e.g. DOS batch files
|
||||
if !exists("b:case_insensitive")
|
||||
set noignorecase
|
||||
endif
|
||||
" this is used to let DebugGenericIndent display which invocation of the
|
||||
" function goes with which messages.
|
||||
let s:hit=s:hit+1
|
||||
let lnum=v:lnum
|
||||
let cline=getline(lnum)
|
||||
let lnum=prevnonblank(lnum)
|
||||
if lnum==0 | if IgnoreCase | set ignorecase | endif | return 0 | endif
|
||||
let pline=getline(lnum)
|
||||
let ndnt=indent(lnum)
|
||||
if !exists("b:allStmts")
|
||||
call GenericAllStmts()
|
||||
endif
|
||||
|
||||
call DebugGenericIndent(expand("<sfile>").": "."cline=<".cline.">, pline=<".pline.">, lnum=".lnum.", v:lnum=".v:lnum.", ndnt=".ndnt)
|
||||
if lnum==v:lnum
|
||||
" current line, only check dedent
|
||||
"
|
||||
" just dedented this line, don't need to do it again.
|
||||
" another dedentStmts was added or an end%[_*] was completed.
|
||||
if s:lastVlnum==v:lnum
|
||||
if IgnoreCase | set ignorecase | endif
|
||||
return ndnt
|
||||
endif
|
||||
let s:lastVlnum=v:lnum
|
||||
call DebugGenericIndent(expand("<sfile>").": "."Checking dedent")
|
||||
let srcStr=cline
|
||||
let dedentKeyBegin=match(srcStr,b:dedentStmts)
|
||||
if dedentKeyBegin != -1
|
||||
let dedentKeyEnd=matchend(srcStr,b:dedentStmts)
|
||||
let dedentKeyStr=strpart(srcStr,dedentKeyBegin,dedentKeyEnd-dedentKeyBegin)
|
||||
"only dedent if it's the beginning of the line
|
||||
if match(srcStr,'^\s*\<'.dedentKeyStr.'\>') != -1
|
||||
call DebugGenericIndent(expand("<sfile>").": "."It's the beginning of the line, dedent")
|
||||
let ndnt=ndnt-&shiftwidth
|
||||
endif
|
||||
endif
|
||||
call DebugGenericIndent(expand("<sfile>").": "."dedent - returning ndnt=".ndnt)
|
||||
else
|
||||
" previous line, only check indent
|
||||
call DebugGenericIndent(expand("<sfile>").": "."Checking indent")
|
||||
let srcStr=pline
|
||||
let indentKeyBegin=match(srcStr,b:indentStmts)
|
||||
if indentKeyBegin != -1
|
||||
" only indent if it's the last indentStmts in the line
|
||||
let allKeyBegin=match(srcStr,b:allStmts)
|
||||
let allKeyEnd=matchend(srcStr,b:allStmts)
|
||||
let allKeyStr=strpart(srcStr,allKeyBegin,allKeyEnd-allKeyBegin)
|
||||
let srcStr=strpart(srcStr,allKeyEnd)
|
||||
let allKeyBegin=match(srcStr,b:allStmts)
|
||||
if allKeyBegin != -1
|
||||
" not the end of the line, check what is and only indent if
|
||||
" it's an indentStmts
|
||||
call DebugGenericIndent(expand("<sfile>").": "."Multiple words in line, checking if last is indent")
|
||||
while allKeyBegin != -1
|
||||
let allKeyEnd=matchend(srcStr,b:allStmts)
|
||||
let allKeyStr=strpart(srcStr,allKeyBegin,allKeyEnd-allKeyBegin)
|
||||
let srcStr=strpart(srcStr,allKeyEnd)
|
||||
let allKeyBegin=match(srcStr,b:allStmts)
|
||||
endwhile
|
||||
if match(b:indentStmts,allKeyStr) != -1
|
||||
call DebugGenericIndent(expand("<sfile>").": "."Last word in line is indent")
|
||||
let ndnt=ndnt+&shiftwidth
|
||||
endif
|
||||
else
|
||||
" it's the last indentStmts in the line, go ahead and indent
|
||||
let ndnt=ndnt+&shiftwidth
|
||||
endif
|
||||
endif
|
||||
call DebugGenericIndent(expand("<sfile>").": "."indent - returning ndnt=".ndnt)
|
||||
endif
|
||||
if IgnoreCase | set ignorecase | endif
|
||||
return ndnt
|
||||
endfunction
|
||||
|
||||
|
||||
" TODO: I'm open!
|
||||
"
|
||||
" BUGS: You tell me! Probably. I just haven't found one yet or haven't been
|
||||
" told about one.
|
||||
"
|
||||
45
vim/bundle/ubuntu-vim72/indent/README.txt
Normal file
45
vim/bundle/ubuntu-vim72/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.
|
||||
12
vim/bundle/ubuntu-vim72/indent/aap.vim
Normal file
12
vim/bundle/ubuntu-vim72/indent/aap.vim
Normal file
@@ -0,0 +1,12 @@
|
||||
" Vim indent file
|
||||
" Language: Aap recipe
|
||||
" Maintainer: Bram Moolenaar <Bram@vim.org>
|
||||
" Last Change: 2005 Jun 24
|
||||
|
||||
" Only load this indent file when no other was loaded.
|
||||
if exists("b:did_indent")
|
||||
finish
|
||||
endif
|
||||
|
||||
" Works mostly like Python.
|
||||
runtime! indent/python.vim
|
||||
303
vim/bundle/ubuntu-vim72/indent/ada.vim
Normal file
303
vim/bundle/ubuntu-vim72/indent/ada.vim
Normal file
@@ -0,0 +1,303 @@
|
||||
"------------------------------------------------------------------------------
|
||||
" Description: Vim Ada indent file
|
||||
" Language: Ada (2005)
|
||||
" $Id: ada.vim 887 2008-07-08 14:29:01Z krischik $
|
||||
" Copyright: Copyright (C) 2006 Martin Krischik
|
||||
" Maintainer: Martin Krischik <krischik@users.sourceforge.net>
|
||||
" Neil Bird <neil@fnxweb.com>
|
||||
" Ned Okie <nokie@radford.edu>
|
||||
" $Author: krischik $
|
||||
" $Date: 2008-07-08 16:29:01 +0200 (Di, 08 Jul 2008) $
|
||||
" Version: 4.6
|
||||
" $Revision: 887 $
|
||||
" $HeadURL: https://gnuada.svn.sourceforge.net/svnroot/gnuada/trunk/tools/vim/indent/ada.vim $
|
||||
" History: 24.05.2006 MK Unified Headers
|
||||
" 16.07.2006 MK Ada-Mode as vim-ball
|
||||
" 15.10.2006 MK Bram's suggestion for runtime integration
|
||||
" 05.11.2006 MK Bram suggested to save on spaces
|
||||
" 19.09.2007 NO g: missing before ada#Comment
|
||||
" Help Page: ft-vim-indent
|
||||
"------------------------------------------------------------------------------
|
||||
" 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") || version < 700
|
||||
finish
|
||||
endif
|
||||
|
||||
let b:did_indent = 45
|
||||
|
||||
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
|
||||
|
||||
if exists("g:ada_with_gnat_project_files")
|
||||
let s:AdaBlockStart = '^\s*\(if\>\|while\>\|else\>\|elsif\>\|loop\>\|for\>.*\<\(loop\|use\)\>\|declare\>\|begin\>\|type\>.*\<is\>[^;]*$\|\(type\>.*\)\=\<record\>\|procedure\>\|function\>\|accept\>\|do\>\|task\>\|package\>\|project\>\|then\>\|when\>\|is\>\)'
|
||||
else
|
||||
let s:AdaBlockStart = '^\s*\(if\>\|while\>\|else\>\|elsif\>\|loop\>\|for\>.*\<\(loop\|use\)\>\|declare\>\|begin\>\|type\>.*\<is\>[^;]*$\|\(type\>.*\)\=\<record\>\|procedure\>\|function\>\|accept\>\|do\>\|task\>\|package\>\|then\>\|when\>\|is\>\)'
|
||||
endif
|
||||
|
||||
" Section: s:MainBlockIndent {{{1
|
||||
"
|
||||
" Try to find indent of the block we're in
|
||||
" prev_indent = the previous line's indent
|
||||
" prev_lnum = previous line (to start looking on)
|
||||
" blockstart = expr. that indicates a possible start of this block
|
||||
" stop_at = if non-null, if a matching line is found, gives up!
|
||||
" No recursive previous block analysis: simply look for a valid line
|
||||
" with a lesser or equal indent than we currently (on prev_lnum) have.
|
||||
" This shouldn't work as well as it appears to with lines that are currently
|
||||
" nowhere near the correct indent (e.g., start of line)!
|
||||
" Seems to work OK as it 'starts' with the indent of the /previous/ line.
|
||||
function s:MainBlockIndent (prev_indent, prev_lnum, blockstart, stop_at)
|
||||
let lnum = a:prev_lnum
|
||||
let line = substitute( getline(lnum), g:ada#Comment, '', '' )
|
||||
while lnum > 1
|
||||
if a:stop_at != '' && line =~ '^\s*' . a:stop_at && indent(lnum) < a:prev_indent
|
||||
return a:prev_indent
|
||||
elseif line =~ '^\s*' . a:blockstart
|
||||
let ind = indent(lnum)
|
||||
if ind < a:prev_indent
|
||||
return ind
|
||||
endif
|
||||
endif
|
||||
|
||||
let lnum = prevnonblank(lnum - 1)
|
||||
" Get previous non-blank/non-comment-only line
|
||||
while 1
|
||||
let line = substitute( getline(lnum), g:ada#Comment, '', '' )
|
||||
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 MainBlockIndent
|
||||
|
||||
" Section: s:EndBlockIndent {{{1
|
||||
"
|
||||
" 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, g:ada#Comment, '', '' )
|
||||
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 EndBlockIndent
|
||||
|
||||
" Section: s:StatementIndent {{{1
|
||||
"
|
||||
" 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), g:ada#Comment, '', '' )
|
||||
|
||||
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 StatementIndent
|
||||
|
||||
|
||||
" Section: GetAdaIndent {{{1
|
||||
"
|
||||
" 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), g:ada#Comment, '', '' )
|
||||
if line !~ '^\s*$' && line !~ '^\s*#'
|
||||
break
|
||||
endif
|
||||
let lnum = prevnonblank(lnum - 1)
|
||||
if lnum <= 0
|
||||
return ind
|
||||
endif
|
||||
endwhile
|
||||
|
||||
" Get default indent (from prev. line)
|
||||
let ind = indent(lnum)
|
||||
let initind = ind
|
||||
|
||||
" Now check what's on the previous line
|
||||
if line =~ s:AdaBlockStart || line =~ '(\s*$'
|
||||
" Check for false matches to AdaBlockStart
|
||||
let false_match = 0
|
||||
if line =~ '^\s*\(procedure\|function\|package\)\>.*\<is\s*new\>'
|
||||
" Generic instantiation
|
||||
let false_match = 1
|
||||
elseif line =~ ')\s*;\s*$' || line =~ '^\([^(]*([^)]*)\)*[^(]*;\s*$'
|
||||
" forward declaration
|
||||
let false_match = 1
|
||||
endif
|
||||
" Move indent in
|
||||
if ! false_match
|
||||
let ind = ind + &sw
|
||||
endif
|
||||
elseif line =~ '^\s*\(case\|exception\)\>'
|
||||
" Move indent in twice (next 'when' will move back)
|
||||
let ind = ind + 2 * &sw
|
||||
elseif line =~ '^\s*end\s*record\>'
|
||||
" Move indent back to tallying 'type' preceeding the 'record'.
|
||||
" Allow indent to be equal to 'end record's.
|
||||
let ind = s:MainBlockIndent( ind+&sw, lnum, 'type\>', '' )
|
||||
elseif line =~ '\(^\s*new\>.*\)\@<!)\s*[;,]\s*$'
|
||||
" Revert to indent of line that started this parenthesis pair
|
||||
exe lnum
|
||||
exe 'normal! $F)%'
|
||||
if getline('.') =~ '^\s*('
|
||||
" Dire layout - use previous indent (could check for g:ada#Comment here)
|
||||
let ind = indent( prevnonblank( line('.')-1 ) )
|
||||
else
|
||||
let ind = indent('.')
|
||||
endif
|
||||
exe v:lnum
|
||||
elseif line =~ '[.=(]\s*$'
|
||||
" A statement continuation - move in one
|
||||
let ind = ind + &sw
|
||||
elseif line =~ '^\s*new\>'
|
||||
" Multiple line generic instantiation ('package blah is\nnew thingy')
|
||||
let ind = s:StatementIndent( ind - &sw, lnum )
|
||||
elseif line =~ ';\s*$'
|
||||
" Statement end (but not 'end' ) - try to find current statement-start indent
|
||||
let ind = s:StatementIndent( ind, lnum )
|
||||
endif
|
||||
|
||||
" Check for potential argument list on next line
|
||||
let continuation = (line =~ '[A-Za-z0-9_]\s*$')
|
||||
|
||||
|
||||
" Check current line; search for simplistic matching start-of-block
|
||||
let line = getline(v:lnum)
|
||||
if line =~ '^\s*#'
|
||||
" Start of line for ada-pp
|
||||
let ind = 0
|
||||
elseif continuation && line =~ '^\s*('
|
||||
" Don't do this if we've already indented due to the previous line
|
||||
if ind == initind
|
||||
let ind = ind + &sw
|
||||
endif
|
||||
elseif line =~ '^\s*\(begin\|is\)\>'
|
||||
let ind = s:MainBlockIndent( ind, lnum, '\(procedure\|function\|declare\|package\|task\)\>', 'begin\>' )
|
||||
elseif line =~ '^\s*record\>'
|
||||
let ind = s:MainBlockIndent( ind, lnum, 'type\>\|for\>.*\<use\>', '' ) + &sw
|
||||
elseif line =~ '^\s*\(else\|elsif\)\>'
|
||||
let ind = s:MainBlockIndent( ind, lnum, 'if\>', '' )
|
||||
elseif line =~ '^\s*when\>'
|
||||
" Align 'when' one /in/ from matching block start
|
||||
let ind = s:MainBlockIndent( ind, lnum, '\(case\|exception\)\>', '' ) + &sw
|
||||
elseif line =~ '^\s*end\>\s*\<if\>'
|
||||
" End of if statements
|
||||
let ind = s:EndBlockIndent( ind, lnum, 'if\>', 'end\>\s*\<if\>' )
|
||||
elseif line =~ '^\s*end\>\s*\<loop\>'
|
||||
" End of loops
|
||||
let ind = s:EndBlockIndent( ind, lnum, '\(\(while\|for\)\>.*\)\?\<loop\>', 'end\>\s*\<loop\>' )
|
||||
elseif line =~ '^\s*end\>\s*\<record\>'
|
||||
" End of records
|
||||
let ind = s:EndBlockIndent( ind, lnum, '\(type\>.*\)\=\<record\>', 'end\>\s*\<record\>' )
|
||||
elseif line =~ '^\s*end\>\s*\<procedure\>'
|
||||
" End of procedures
|
||||
let ind = s:EndBlockIndent( ind, lnum, 'procedure\>.*\<is\>', 'end\>\s*\<procedure\>' )
|
||||
elseif line =~ '^\s*end\>\s*\<case\>'
|
||||
" End of case statement
|
||||
let ind = s:EndBlockIndent( ind, lnum, 'case\>.*\<is\>', 'end\>\s*\<case\>' )
|
||||
elseif line =~ '^\s*end\>'
|
||||
" General case for end
|
||||
let ind = s:MainBlockIndent( ind, lnum, '\(if\|while\|for\|loop\|accept\|begin\|record\|case\|exception\|package\)\>', '' )
|
||||
elseif line =~ '^\s*exception\>'
|
||||
let ind = s:MainBlockIndent( ind, lnum, 'begin\>', '' )
|
||||
elseif line =~ '^\s*then\>'
|
||||
let ind = s:MainBlockIndent( ind, lnum, 'if\>', '' )
|
||||
endif
|
||||
|
||||
return ind
|
||||
endfunction GetAdaIndent
|
||||
|
||||
finish " 1}}}
|
||||
|
||||
"------------------------------------------------------------------------------
|
||||
" Copyright (C) 2006 Martin Krischik
|
||||
"
|
||||
" Vim is Charityware - see ":help license" or uganda.txt for licence details.
|
||||
"------------------------------------------------------------------------------
|
||||
" vim: textwidth=78 wrap tabstop=8 shiftwidth=3 softtabstop=3 noexpandtab
|
||||
" vim: foldmethod=marker
|
||||
12
vim/bundle/ubuntu-vim72/indent/ant.vim
Normal file
12
vim/bundle/ubuntu-vim72/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
vim/bundle/ubuntu-vim72/indent/automake.vim
Normal file
11
vim/bundle/ubuntu-vim72/indent/automake.vim
Normal file
@@ -0,0 +1,11 @@
|
||||
" Vim indent file
|
||||
" Language: automake
|
||||
" Maintainer: Nikolai Weibull <now@bitwi.se>
|
||||
" Latest Revision: 2006-04-19
|
||||
|
||||
if exists("b:did_indent")
|
||||
finish
|
||||
endif
|
||||
|
||||
" same as makefile indenting for now.
|
||||
runtime! indent/make.vim
|
||||
228
vim/bundle/ubuntu-vim72/indent/awk.vim
Normal file
228
vim/bundle/ubuntu-vim72/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
|
||||
15
vim/bundle/ubuntu-vim72/indent/bib.vim
Normal file
15
vim/bundle/ubuntu-vim72/indent/bib.vim
Normal file
@@ -0,0 +1,15 @@
|
||||
" Vim indent file
|
||||
" Language: BibTeX
|
||||
" Maintainer: Dorai Sitaram <ds26@gte.com>
|
||||
" URL: http://www.ccs.neu.edu/~dorai/vimplugins/vimplugins.html
|
||||
" Last Change: 2005 Mar 28
|
||||
|
||||
" Only do this when not done yet for this buffer
|
||||
if exists("b:did_indent")
|
||||
finish
|
||||
endif
|
||||
let b:did_indent = 1
|
||||
|
||||
setlocal cindent
|
||||
|
||||
let b:undo_indent = "setl cin<"
|
||||
75
vim/bundle/ubuntu-vim72/indent/bst.vim
Normal file
75
vim/bundle/ubuntu-vim72/indent/bst.vim
Normal file
@@ -0,0 +1,75 @@
|
||||
" Vim indent file
|
||||
" Language: bst
|
||||
" Author: Tim Pope <vimNOSPAM@tpope.info>
|
||||
" $Id: bst.vim,v 1.1 2007/05/05 18:11:12 vimboss Exp $
|
||||
|
||||
if exists("b:did_indent")
|
||||
finish
|
||||
endif
|
||||
let b:did_indent = 1
|
||||
|
||||
setlocal expandtab
|
||||
setlocal indentexpr=GetBstIndent(v:lnum)
|
||||
"setlocal smartindent
|
||||
setlocal cinkeys&
|
||||
setlocal cinkeys-=0#
|
||||
setlocal indentkeys&
|
||||
"setlocal indentkeys+=0%
|
||||
|
||||
" Only define the function once.
|
||||
if exists("*GetBstIndent")
|
||||
finish
|
||||
endif
|
||||
|
||||
function! s:prevgood(lnum)
|
||||
" Find a non-blank line above the current line.
|
||||
" Skip over comments.
|
||||
let lnum = a:lnum
|
||||
while lnum > 0
|
||||
let lnum = prevnonblank(lnum - 1)
|
||||
if getline(lnum) !~ '^\s*%.*$'
|
||||
break
|
||||
endif
|
||||
endwhile
|
||||
return lnum
|
||||
endfunction
|
||||
|
||||
function! s:strip(lnum)
|
||||
let line = getline(a:lnum)
|
||||
let line = substitute(line,'"[^"]*"','""','g')
|
||||
let line = substitute(line,'%.*','','')
|
||||
let line = substitute(line,'^\s\+','','')
|
||||
return line
|
||||
endfunction
|
||||
|
||||
function! s:count(string,char)
|
||||
let str = substitute(a:string,'[^'.a:char.']','','g')
|
||||
return strlen(str)
|
||||
endfunction
|
||||
|
||||
function! GetBstIndent(lnum) abort
|
||||
if a:lnum == 1
|
||||
return 0
|
||||
endif
|
||||
let lnum = s:prevgood(a:lnum)
|
||||
if lnum <= 0
|
||||
return indent(a:lnum - 1)
|
||||
endif
|
||||
let line = s:strip(lnum)
|
||||
let cline = s:strip(a:lnum)
|
||||
if cline =~ '^}' && exists("b:current_syntax")
|
||||
call cursor(a:lnum,indent(a:lnum))
|
||||
if searchpair('{','','}','bW',"synIDattr(synID(line('.'),col('.'),1),'name') =~? 'comment\\|string'")
|
||||
if col('.')+1 == col('$')
|
||||
return indent('.')
|
||||
else
|
||||
return virtcol('.')-1
|
||||
endif
|
||||
endif
|
||||
endif
|
||||
let fakeline = substitute(line,'^}','','').matchstr(cline,'^}')
|
||||
let ind = indent(lnum)
|
||||
let ind = ind + &sw * s:count(line,'{')
|
||||
let ind = ind - &sw * s:count(fakeline,'}')
|
||||
return ind
|
||||
endfunction
|
||||
15
vim/bundle/ubuntu-vim72/indent/c.vim
Normal file
15
vim/bundle/ubuntu-vim72/indent/c.vim
Normal file
@@ -0,0 +1,15 @@
|
||||
" Vim indent file
|
||||
" Language: C
|
||||
" Maintainer: Bram Moolenaar <Bram@vim.org>
|
||||
" Last Change: 2005 Mar 27
|
||||
|
||||
" 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
|
||||
|
||||
let b:undo_indent = "setl cin<"
|
||||
129
vim/bundle/ubuntu-vim72/indent/cdl.vim
Normal file
129
vim/bundle/ubuntu-vim72/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
vim/bundle/ubuntu-vim72/indent/ch.vim
Normal file
18
vim/bundle/ubuntu-vim72/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: 2006 Apr 30
|
||||
" 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
|
||||
14
vim/bundle/ubuntu-vim72/indent/changelog.vim
Normal file
14
vim/bundle/ubuntu-vim72/indent/changelog.vim
Normal file
@@ -0,0 +1,14 @@
|
||||
" Vim indent file
|
||||
" Language: generic Changelog file
|
||||
" Maintainer: noone
|
||||
" Last Change: 2005 Mar 29
|
||||
|
||||
" Only load this indent file when no other was loaded.
|
||||
if exists("b:did_indent")
|
||||
finish
|
||||
endif
|
||||
let b:did_indent = 1
|
||||
|
||||
setlocal ai
|
||||
|
||||
let b:undo_indent = "setl ai<"
|
||||
92
vim/bundle/ubuntu-vim72/indent/cmake.vim
Normal file
92
vim/bundle/ubuntu-vim72/indent/cmake.vim
Normal file
@@ -0,0 +1,92 @@
|
||||
" =============================================================================
|
||||
"
|
||||
" Program: CMake - Cross-Platform Makefile Generator
|
||||
" Module: $RCSfile: cmake-indent.vim,v $
|
||||
" Language: VIM
|
||||
" Date: $Date: 2006/09/23 21:09:08 $
|
||||
" Version: $Revision: 1.7 $
|
||||
"
|
||||
" =============================================================================
|
||||
|
||||
" Vim indent file
|
||||
" Language: CMake (ft=cmake)
|
||||
" Author: Andy Cedilnik <andy.cedilnik@kitware.com>
|
||||
" Maintainer: Andy Cedilnik <andy.cedilnik@kitware.com>
|
||||
" Last Change: $Date: 2006/09/23 21:09:08 $
|
||||
" Version: $Revision: 1.7 $
|
||||
"
|
||||
" Licence: The CMake license applies to this file. See
|
||||
" http://www.cmake.org/HTML/Copyright.html
|
||||
" This implies that distribution with Vim is allowed
|
||||
|
||||
if exists("b:did_indent")
|
||||
finish
|
||||
endif
|
||||
let b:did_indent = 1
|
||||
|
||||
setlocal indentexpr=CMakeGetIndent(v:lnum)
|
||||
|
||||
" Only define the function once.
|
||||
if exists("*CMakeGetIndent")
|
||||
finish
|
||||
endif
|
||||
|
||||
fun! CMakeGetIndent(lnum)
|
||||
let this_line = getline(a:lnum)
|
||||
|
||||
" Find a non-blank line above the current line.
|
||||
let lnum = a:lnum
|
||||
let lnum = prevnonblank(lnum - 1)
|
||||
let previous_line = getline(lnum)
|
||||
|
||||
" Hit the start of the file, use zero indent.
|
||||
if lnum == 0
|
||||
return 0
|
||||
endif
|
||||
|
||||
let ind = indent(lnum)
|
||||
|
||||
let or = '\|'
|
||||
" Regular expressions used by line indentation function.
|
||||
let cmake_regex_comment = '#.*'
|
||||
let cmake_regex_identifier = '[A-Za-z][A-Za-z0-9_]*'
|
||||
let cmake_regex_quoted = '"\([^"\\]\|\\.\)*"'
|
||||
let cmake_regex_arguments = '\(' . cmake_regex_quoted .
|
||||
\ or . '\$(' . cmake_regex_identifier . ')' .
|
||||
\ or . '[^()\\#"]' . or . '\\.' . '\)*'
|
||||
|
||||
let cmake_indent_comment_line = '^\s*' . cmake_regex_comment
|
||||
let cmake_indent_blank_regex = '^\s*$'
|
||||
let cmake_indent_open_regex = '^\s*' . cmake_regex_identifier .
|
||||
\ '\s*(' . cmake_regex_arguments .
|
||||
\ '\(' . cmake_regex_comment . '\)\?$'
|
||||
|
||||
let cmake_indent_close_regex = '^' . cmake_regex_arguments .
|
||||
\ ')\s*' .
|
||||
\ '\(' . cmake_regex_comment . '\)\?$'
|
||||
|
||||
let cmake_indent_begin_regex = '^\s*\(IF\|MACRO\|FOREACH\|ELSE\|ELSEIF\|WHILE\)\s*('
|
||||
let cmake_indent_end_regex = '^\s*\(ENDIF\|ENDFOREACH\|ENDMACRO\|ELSE\|ELSEIF\|ENDWHILE\)\s*('
|
||||
|
||||
" Add
|
||||
if previous_line =~? cmake_indent_comment_line " Handle comments
|
||||
let ind = ind
|
||||
else
|
||||
if previous_line =~? cmake_indent_begin_regex
|
||||
let ind = ind + &sw
|
||||
endif
|
||||
if previous_line =~? cmake_indent_open_regex
|
||||
let ind = ind + &sw
|
||||
endif
|
||||
endif
|
||||
|
||||
" Subtract
|
||||
if this_line =~? cmake_indent_end_regex
|
||||
let ind = ind - &sw
|
||||
endif
|
||||
if previous_line =~? cmake_indent_close_regex
|
||||
let ind = ind - &sw
|
||||
endif
|
||||
|
||||
return ind
|
||||
endfun
|
||||
216
vim/bundle/ubuntu-vim72/indent/cobol.vim
Normal file
216
vim/bundle/ubuntu-vim72/indent/cobol.vim
Normal file
@@ -0,0 +1,216 @@
|
||||
" Vim indent file
|
||||
" Language: cobol
|
||||
" Author: Tim Pope <vimNOSPAM@tpope.info>
|
||||
" $Id: cobol.vim,v 1.1 2007/05/05 18:08:19 vimboss Exp $
|
||||
|
||||
if exists("b:did_indent")
|
||||
finish
|
||||
endif
|
||||
let b:did_indent = 1
|
||||
|
||||
setlocal expandtab
|
||||
setlocal indentexpr=GetCobolIndent(v:lnum)
|
||||
setlocal indentkeys&
|
||||
setlocal indentkeys+=0<*>,0/,0$,0=01,=~division,=~section,0=~end,0=~then,0=~else,0=~when,*<Return>,.
|
||||
|
||||
" Only define the function once.
|
||||
if exists("*GetCobolIndent")
|
||||
finish
|
||||
endif
|
||||
|
||||
let s:skip = 'getline(".") =~ "^.\\{6\\}[*/$-]\\|\"[^\"]*\""'
|
||||
|
||||
function! s:prevgood(lnum)
|
||||
" Find a non-blank line above the current line.
|
||||
" Skip over comments.
|
||||
let lnum = a:lnum
|
||||
while lnum > 0
|
||||
let lnum = prevnonblank(lnum - 1)
|
||||
let line = getline(lnum)
|
||||
if line !~? '^\s*[*/$-]' && line !~? '^.\{6\}[*/$CD-]'
|
||||
break
|
||||
endif
|
||||
endwhile
|
||||
return lnum
|
||||
endfunction
|
||||
|
||||
function! s:stripped(lnum)
|
||||
return substitute(strpart(getline(a:lnum),0,72),'^\s*','','')
|
||||
endfunction
|
||||
|
||||
function! s:optionalblock(lnum,ind,blocks,clauses)
|
||||
let ind = a:ind
|
||||
let clauses = '\c\<\%(\<NOT\s\+\)\@<!\%(NOT\s\+\)\=\%('.a:clauses.'\)'
|
||||
let begin = '\c-\@<!\<\%('.a:blocks.'\)\>'
|
||||
let beginfull = begin.'\ze.*\%(\n\%(\s*\%([*/$-].*\)\=\n\)*\)\=\s*\%('.clauses.'\)'
|
||||
let end = '\c\<end-\%('.a:blocks.'\)\>\|\%(\.\%( \|$\)\)\@='
|
||||
let cline = s:stripped(a:lnum)
|
||||
let line = s:stripped(s:prevgood(a:lnum))
|
||||
if cline =~? clauses "&& line !~? '^search\>'
|
||||
call cursor(a:lnum,1)
|
||||
let lastclause = searchpair(beginfull,clauses,end,'bWr',s:skip)
|
||||
if getline(lastclause) =~? clauses && s:stripped(lastclause) !~? '^'.begin
|
||||
let ind = indent(lastclause)
|
||||
elseif lastclause > 0
|
||||
let ind = indent(lastclause) + &sw
|
||||
"let ind = ind + &sw
|
||||
endif
|
||||
elseif line =~? clauses && cline !~? end
|
||||
let ind = ind + &sw
|
||||
endif
|
||||
return ind
|
||||
endfunction
|
||||
|
||||
function! GetCobolIndent(lnum) abort
|
||||
let minshft = 6
|
||||
let ashft = minshft + 1
|
||||
let bshft = ashft + 4
|
||||
" (Obsolete) numbered lines
|
||||
if getline(a:lnum) =~? '^\s*\d\{6\}\%($\|[ */$CD-]\)'
|
||||
return 0
|
||||
endif
|
||||
let cline = s:stripped(a:lnum)
|
||||
" Comments, etc. must start in the 7th column
|
||||
if cline =~? '^[*/$-]'
|
||||
return minshft
|
||||
elseif cline =~# '^[CD]' && indent(a:lnum) == minshft
|
||||
return minshft
|
||||
endif
|
||||
" Divisions, sections, and file descriptions start in area A
|
||||
if cline =~? '\<\(DIVISION\|SECTION\)\%($\|\.\)' || cline =~? '^[FS]D\>'
|
||||
return ashft
|
||||
endif
|
||||
" Fields
|
||||
if cline =~? '^0*\(1\|77\)\>'
|
||||
return ashft
|
||||
endif
|
||||
if cline =~? '^\d\+\>'
|
||||
let cnum = matchstr(cline,'^\d\+\>')
|
||||
let default = 0
|
||||
let step = -1
|
||||
while step < 2
|
||||
let lnum = a:lnum
|
||||
while lnum > 0 && lnum < line('$') && lnum > a:lnum - 500 && lnum < a:lnum + 500
|
||||
let lnum = step > 0 ? nextnonblank(lnum + step) : prevnonblank(lnum + step)
|
||||
let line = getline(lnum)
|
||||
let lindent = indent(lnum)
|
||||
if line =~? '^\s*\d\+\>'
|
||||
let num = matchstr(line,'^\s*\zs\d\+\>')
|
||||
if 0+cnum == num
|
||||
return lindent
|
||||
elseif 0+cnum > num && default < lindent + &sw
|
||||
let default = lindent + &sw
|
||||
endif
|
||||
elseif lindent < bshft && lindent >= ashft
|
||||
break
|
||||
endif
|
||||
endwhile
|
||||
let step = step + 2
|
||||
endwhile
|
||||
return default ? default : bshft
|
||||
endif
|
||||
let lnum = s:prevgood(a:lnum)
|
||||
" Hit the start of the file, use "zero" indent.
|
||||
if lnum == 0
|
||||
return ashft
|
||||
endif
|
||||
" Initial spaces are ignored
|
||||
let line = s:stripped(lnum)
|
||||
let ind = indent(lnum)
|
||||
" Paragraphs. There may be some false positives.
|
||||
if cline =~? '^\(\a[A-Z0-9-]*[A-Z0-9]\|\d[A-Z0-9-]*\a\)\.' "\s*$'
|
||||
if cline !~? '^EXIT\s*\.' && line =~? '\.\s*$'
|
||||
return ashft
|
||||
endif
|
||||
endif
|
||||
" Paragraphs in the identification division.
|
||||
"if cline =~? '^\(PROGRAM-ID\|AUTHOR\|INSTALLATION\|' .
|
||||
"\ 'DATE-WRITTEN\|DATE-COMPILED\|SECURITY\)\>'
|
||||
"return ashft
|
||||
"endif
|
||||
if line =~? '\.$'
|
||||
" XXX
|
||||
return bshft
|
||||
endif
|
||||
if line =~? '^PERFORM\>'
|
||||
let perfline = substitute(line, '\c^PERFORM\s*', "", "")
|
||||
if perfline =~? '^\%(\k\+\s\+TIMES\)\=\s*$'
|
||||
let ind = ind + &sw
|
||||
elseif perfline =~? '^\%(WITH\s\+TEST\|VARYING\|UNTIL\)\>.*[^.]$'
|
||||
let ind = ind + &sw
|
||||
endif
|
||||
endif
|
||||
if line =~? '^\%(IF\|THEN\|ELSE\|READ\|EVALUATE\|SEARCH\|SELECT\)\>'
|
||||
let ind = ind + &sw
|
||||
endif
|
||||
let ind = s:optionalblock(a:lnum,ind,'ADD\|COMPUTE\|DIVIDE\|MULTIPLY\|SUBTRACT','ON\s\+SIZE\s\+ERROR')
|
||||
let ind = s:optionalblock(a:lnum,ind,'STRING\|UNSTRING\|ACCEPT\|DISPLAY\|CALL','ON\s\+OVERFLOW\|ON\s\+EXCEPTION')
|
||||
if cline !~? '^AT\s\+END\>' || line !~? '^SEARCH\>'
|
||||
let ind = s:optionalblock(a:lnum,ind,'DELETE\|REWRITE\|START\|WRITE\|READ','INVALID\s\+KEY\|AT\s\+END\|NO\s\+DATA\|AT\s\+END-OF-PAGE')
|
||||
endif
|
||||
if cline =~? '^WHEN\>'
|
||||
call cursor(a:lnum,1)
|
||||
" We also search for READ so that contained AT ENDs are skipped
|
||||
let lastclause = searchpair('\c-\@<!\<\%(SEARCH\|EVALUATE\|READ\)\>','\c\<\%(WHEN\|AT\s\+END\)\>','\c\<END-\%(SEARCH\|EVALUATE\|READ\)\>','bW',s:skip)
|
||||
let g:foo = s:stripped(lastclause)
|
||||
if s:stripped(lastclause) =~? '\c\<\%(WHEN\|AT\s\+END\)\>'
|
||||
"&& s:stripped(lastclause) !~? '^\%(SEARCH\|EVALUATE\|READ\)\>'
|
||||
let ind = indent(lastclause)
|
||||
elseif lastclause > 0
|
||||
let ind = indent(lastclause) + &sw
|
||||
endif
|
||||
elseif line =~? '^WHEN\>'
|
||||
let ind = ind + &sw
|
||||
endif
|
||||
"I'm not sure why I had this
|
||||
"if line =~? '^ELSE\>-\@!' && line !~? '\.$'
|
||||
"let ind = indent(s:prevgood(lnum))
|
||||
"endif
|
||||
if cline =~? '^\(END\)\>-\@!'
|
||||
" On lines with just END, 'guess' a simple shift left
|
||||
let ind = ind - &sw
|
||||
elseif cline =~? '^\(END-IF\|THEN\|ELSE\)\>-\@!'
|
||||
call cursor(a:lnum,indent(a:lnum))
|
||||
let match = searchpair('\c-\@<!\<IF\>','\c-\@<!\%(THEN\|ELSE\)\>','\c-\@<!\<END-IF\>\zs','bnW',s:skip)
|
||||
if match > 0
|
||||
let ind = indent(match)
|
||||
endif
|
||||
elseif cline =~? '^END-[A-Z]'
|
||||
let beginword = matchstr(cline,'\c\<END-\zs[A-Z0-9-]\+')
|
||||
let endword = 'END-'.beginword
|
||||
let first = 0
|
||||
let suffix = '.*\%(\n\%(\%(\s*\|.\{6\}\)[*/].*\n\)*\)\=\s*'
|
||||
if beginword =~? '^\%(ADD\|COMPUTE\|DIVIDE\|MULTIPLY\|SUBTRACT\)$'
|
||||
let beginword = beginword . suffix . '\<\%(NOT\s\+\)\=ON\s\+SIZE\s\+ERROR'
|
||||
let g:beginword = beginword
|
||||
let first = 1
|
||||
elseif beginword =~? '^\%(STRING\|UNSTRING\)$'
|
||||
let beginword = beginword . suffix . '\<\%(NOT\s\+\)\=ON\s\+OVERFLOW'
|
||||
let first = 1
|
||||
elseif beginword =~? '^\%(ACCEPT\|DISPLAY\)$'
|
||||
let beginword = beginword . suffix . '\<\%(NOT\s\+\)\=ON\s\+EXCEPTION'
|
||||
let first = 1
|
||||
elseif beginword ==? 'CALL'
|
||||
let beginword = beginword . suffix . '\<\%(NOT\s\+\)\=ON\s\+\%(EXCEPTION\|OVERFLOW\)'
|
||||
let first = 1
|
||||
elseif beginword =~? '^\%(DELETE\|REWRITE\|START\|READ\|WRITE\)$'
|
||||
let first = 1
|
||||
let beginword = beginword . suffix . '\<\%(NOT\s\+\)\=\(INVALID\s\+KEY'
|
||||
if beginword =~? '^READ'
|
||||
let first = 0
|
||||
let beginword = beginword . '\|AT\s\+END\|NO\s\+DATA'
|
||||
elseif beginword =~? '^WRITE'
|
||||
let beginword = beginword . '\|AT\s\+END-OF-PAGE'
|
||||
endif
|
||||
let beginword = beginword . '\)'
|
||||
endif
|
||||
call cursor(a:lnum,indent(a:lnum))
|
||||
let match = searchpair('\c-\@<!\<'.beginword.'\>','','\c\<'.endword.'\>\zs','bnW'.(first? 'r' : ''),s:skip)
|
||||
if match > 0
|
||||
let ind = indent(match)
|
||||
elseif cline =~? '^\(END-\(READ\|EVALUATE\|SEARCH\|PERFORM\)\)\>'
|
||||
let ind = ind - &sw
|
||||
endif
|
||||
endif
|
||||
return ind < bshft ? bshft : ind
|
||||
endfunction
|
||||
82
vim/bundle/ubuntu-vim72/indent/config.vim
Normal file
82
vim/bundle/ubuntu-vim72/indent/config.vim
Normal file
@@ -0,0 +1,82 @@
|
||||
" Vim indent file
|
||||
" Language: Autoconf configure.{ac,in} file
|
||||
" Maintainer: Nikolai Weibull <now@bitwi.se>
|
||||
" Latest Revision: 2006-12-20
|
||||
" 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
|
||||
|
||||
runtime! indent/sh.vim " will set b:did_indent
|
||||
|
||||
setlocal indentexpr=GetConfigIndent()
|
||||
setlocal indentkeys=!^F,o,O,=then,=do,=else,=elif,=esac,=fi,=fin,=fil,=done
|
||||
setlocal nosmartindent
|
||||
|
||||
" 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
|
||||
15
vim/bundle/ubuntu-vim72/indent/cpp.vim
Normal file
15
vim/bundle/ubuntu-vim72/indent/cpp.vim
Normal file
@@ -0,0 +1,15 @@
|
||||
" Vim indent file
|
||||
" Language: C++
|
||||
" Maintainer: Bram Moolenaar <Bram@vim.org>
|
||||
" Last Change: 2008 Nov 29
|
||||
|
||||
" 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
|
||||
|
||||
let b:undo_indent = "setl cin<"
|
||||
15
vim/bundle/ubuntu-vim72/indent/cs.vim
Normal file
15
vim/bundle/ubuntu-vim72/indent/cs.vim
Normal file
@@ -0,0 +1,15 @@
|
||||
" 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
|
||||
|
||||
let b:undo_indent = "setl cin<"
|
||||
84
vim/bundle/ubuntu-vim72/indent/css.vim
Normal file
84
vim/bundle/ubuntu-vim72/indent/css.vim
Normal file
@@ -0,0 +1,84 @@
|
||||
" Vim indent file
|
||||
" Language: CSS
|
||||
" Maintainer: Nikolai Weibull <now@bitwi.se>
|
||||
" Latest Revision: 2006-12-20
|
||||
|
||||
if exists("b:did_indent")
|
||||
finish
|
||||
endif
|
||||
let b:did_indent = 1
|
||||
|
||||
setlocal indentexpr=GetCSSIndent()
|
||||
setlocal indentkeys=0{,0},!^F,o,O
|
||||
setlocal nosmartindent
|
||||
|
||||
if exists("*GetCSSIndent")
|
||||
finish
|
||||
endif
|
||||
|
||||
function s:prevnonblanknoncomment(lnum)
|
||||
let lnum = a:lnum
|
||||
while lnum > 1
|
||||
let lnum = prevnonblank(lnum)
|
||||
let line = getline(lnum)
|
||||
if line =~ '\*/'
|
||||
while lnum > 1 && line !~ '/\*'
|
||||
let lnum -= 1
|
||||
endwhile
|
||||
if line =~ '^\s*/\*'
|
||||
let lnum -= 1
|
||||
else
|
||||
break
|
||||
endif
|
||||
else
|
||||
break
|
||||
endif
|
||||
endwhile
|
||||
return lnum
|
||||
endfunction
|
||||
|
||||
function s:count_braces(lnum, count_open)
|
||||
let n_open = 0
|
||||
let n_close = 0
|
||||
let line = getline(a:lnum)
|
||||
let pattern = '[{}]'
|
||||
let i = match(line, pattern)
|
||||
while i != -1
|
||||
if synIDattr(synID(a:lnum, i + 1, 0), 'name') !~ 'css\%(Comment\|StringQ\{1,2}\)'
|
||||
if line[i] == '{'
|
||||
let n_open += 1
|
||||
elseif line[i] == '}'
|
||||
if n_open > 0
|
||||
let n_open -= 1
|
||||
else
|
||||
let n_close += 1
|
||||
endif
|
||||
endif
|
||||
endif
|
||||
let i = match(line, pattern, i + 1)
|
||||
endwhile
|
||||
return a:count_open ? n_open : n_close
|
||||
endfunction
|
||||
|
||||
function GetCSSIndent()
|
||||
let line = getline(v:lnum)
|
||||
if line =~ '^\s*\*'
|
||||
return cindent(v:lnum)
|
||||
elseif line =~ '^\s*}'
|
||||
return indent(v:lnum) - &sw
|
||||
endif
|
||||
|
||||
let pnum = s:prevnonblanknoncomment(v:lnum - 1)
|
||||
if pnum == 0
|
||||
return 0
|
||||
endif
|
||||
|
||||
let ind = indent(pnum) + s:count_braces(pnum, 1) * &sw
|
||||
|
||||
let pline = getline(pnum)
|
||||
if pline =~ '}\s*$'
|
||||
let ind -= (s:count_braces(pnum, 0) - (pline =~ '^\s*}' ? 1 : 0)) * &sw
|
||||
endif
|
||||
|
||||
return ind
|
||||
endfunction
|
||||
15
vim/bundle/ubuntu-vim72/indent/cuda.vim
Normal file
15
vim/bundle/ubuntu-vim72/indent/cuda.vim
Normal file
@@ -0,0 +1,15 @@
|
||||
" Vim indent file
|
||||
" Language: CUDA
|
||||
" Maintainer: Bram Moolenaar <Bram@vim.org>
|
||||
" Last Change: 2008 Nov 29
|
||||
|
||||
" Only load this indent file when no other was loaded.
|
||||
if exists("b:did_indent")
|
||||
finish
|
||||
endif
|
||||
let b:did_indent = 1
|
||||
|
||||
" It's just like C indenting
|
||||
setlocal cindent
|
||||
|
||||
let b:undo_indent = "setl cin<"
|
||||
22
vim/bundle/ubuntu-vim72/indent/d.vim
Normal file
22
vim/bundle/ubuntu-vim72/indent/d.vim
Normal file
@@ -0,0 +1,22 @@
|
||||
" Vim indent file for the D programming language (version 0.137).
|
||||
"
|
||||
" Language: D
|
||||
" Maintainer: Jason Mills<jmills@cs.mun.ca>
|
||||
" Last Change: 2005 Nov 22
|
||||
" Version: 0.1
|
||||
"
|
||||
" Please email me with bugs, comments, and suggestion. Put vim in the subject
|
||||
" to ensure the email will not be marked has spam.
|
||||
"
|
||||
|
||||
" Only load this indent file when no other was loaded.
|
||||
if exists("b:did_indent")
|
||||
finish
|
||||
endif
|
||||
|
||||
let b:did_indent = 1
|
||||
|
||||
" D indenting is a lot like the built-in C indenting.
|
||||
setlocal cindent
|
||||
|
||||
" vim: ts=8 noet
|
||||
13
vim/bundle/ubuntu-vim72/indent/dictconf.vim
Normal file
13
vim/bundle/ubuntu-vim72/indent/dictconf.vim
Normal file
@@ -0,0 +1,13 @@
|
||||
" Vim indent file
|
||||
" Language: dict(1) configuration file
|
||||
" Maintainer: Nikolai Weibull <now@bitwi.se>
|
||||
" Latest Revision: 2006-12-20
|
||||
|
||||
if exists("b:did_indent")
|
||||
finish
|
||||
endif
|
||||
let b:did_indent = 1
|
||||
|
||||
setlocal indentkeys=0{,0},!^F,o,O cinwords= autoindent smartindent
|
||||
setlocal nosmartindent
|
||||
inoremap <buffer> # X#
|
||||
13
vim/bundle/ubuntu-vim72/indent/dictdconf.vim
Normal file
13
vim/bundle/ubuntu-vim72/indent/dictdconf.vim
Normal file
@@ -0,0 +1,13 @@
|
||||
" Vim indent file
|
||||
" Language: dictd(8) configuration file
|
||||
" Maintainer: Nikolai Weibull <now@bitwi.se>
|
||||
" Latest Revision: 2006-12-20
|
||||
|
||||
if exists("b:did_indent")
|
||||
finish
|
||||
endif
|
||||
let b:did_indent = 1
|
||||
|
||||
setlocal indentkeys=0{,0},!^F,o,O cinwords= autoindent smartindent
|
||||
setlocal nosmartindent
|
||||
inoremap <buffer> # X#
|
||||
15
vim/bundle/ubuntu-vim72/indent/docbk.vim
Normal file
15
vim/bundle/ubuntu-vim72/indent/docbk.vim
Normal file
@@ -0,0 +1,15 @@
|
||||
" Vim indent file
|
||||
" Language: DocBook Documentation Format
|
||||
" Maintainer: Nikolai Weibull <now@bitwi.se>
|
||||
" Latest Revision: 2006-04-19
|
||||
|
||||
if exists("b:did_indent")
|
||||
finish
|
||||
endif
|
||||
|
||||
" Same as XML indenting for now.
|
||||
runtime! indent/xml.vim
|
||||
|
||||
if exists('*XmlIndentGet')
|
||||
setlocal indentexpr=XmlIndentGet(v:lnum,0)
|
||||
endif
|
||||
325
vim/bundle/ubuntu-vim72/indent/dtd.vim
Normal file
325
vim/bundle/ubuntu-vim72/indent/dtd.vim
Normal file
@@ -0,0 +1,325 @@
|
||||
" Vim indent file
|
||||
" Language: DTD (Document Type Definition for XML)
|
||||
" Maintainer: Nikolai Weibull <now@bitwi.se>
|
||||
" Latest Revision: 2008-07-18
|
||||
|
||||
let s:cpo_save = &cpo
|
||||
set cpo&vim
|
||||
|
||||
setlocal indentexpr=GetDTDIndent()
|
||||
setlocal indentkeys=!^F,o,O,>
|
||||
setlocal nosmartindent
|
||||
|
||||
if exists("*GetDTDIndent")
|
||||
finish
|
||||
endif
|
||||
|
||||
" TODO: Needs to be adjusted to stop at [, <, and ].
|
||||
let s:token_pattern = '^[^[:space:]]\+'
|
||||
|
||||
function s:lex1(input, start, ...)
|
||||
let pattern = a:0 > 0 ? a:1 : s:token_pattern
|
||||
let start = matchend(a:input, '^\_s*', a:start)
|
||||
if start == -1
|
||||
return ["", a:start]
|
||||
endif
|
||||
let end = matchend(a:input, pattern, start)
|
||||
if end == -1
|
||||
return ["", a:start]
|
||||
endif
|
||||
let token = strpart(a:input, start, end - start)
|
||||
return [token, end]
|
||||
endfunction
|
||||
|
||||
function s:lex(input, start, ...)
|
||||
let pattern = a:0 > 0 ? a:1 : s:token_pattern
|
||||
let info = s:lex1(a:input, a:start, pattern)
|
||||
while info[0] == '--'
|
||||
let info = s:lex1(a:input, info[1], pattern)
|
||||
while info[0] != "" && info[0] != '--'
|
||||
let info = s:lex1(a:input, info[1], pattern)
|
||||
endwhile
|
||||
if info[0] == ""
|
||||
return info
|
||||
endif
|
||||
let info = s:lex1(a:input, info[1], pattern)
|
||||
endwhile
|
||||
return info
|
||||
endfunction
|
||||
|
||||
function s:indent_to_innermost_parentheses(line, end)
|
||||
let token = '('
|
||||
let end = a:end
|
||||
let parentheses = [end - 1]
|
||||
while token != ""
|
||||
let [token, end] = s:lex(a:line, end, '^\%([(),|]\|[A-Za-z0-9_-]\+\)[?*+]\=')
|
||||
if token[0] == '('
|
||||
call add(parentheses, end - 1)
|
||||
elseif token[0] == ')'
|
||||
if len(parentheses) == 1
|
||||
return [-1, end]
|
||||
endif
|
||||
call remove(parentheses, -1)
|
||||
endif
|
||||
endwhile
|
||||
return [parentheses[-1] - strridx(a:line, "\n", parentheses[-1]), end]
|
||||
endfunction
|
||||
|
||||
" TODO: Line and end could be script global (think OO members).
|
||||
function GetDTDIndent()
|
||||
if v:lnum == 1
|
||||
return 0
|
||||
endif
|
||||
|
||||
" Begin by searching back for a <! that isn’t inside a comment.
|
||||
" From here, depending on what follows immediately after, parse to
|
||||
" where we’re at to determine what to do.
|
||||
if search('<!', 'bceW') == 0
|
||||
return indent(v:lnum - 1)
|
||||
endif
|
||||
let lnum = line('.')
|
||||
let col = col('.')
|
||||
let indent = indent('.')
|
||||
let line = join(getline(lnum, v:lnum - 1), "\n")
|
||||
|
||||
let [declaration, end] = s:lex1(line, col)
|
||||
if declaration == ""
|
||||
return indent + &sw
|
||||
elseif declaration == '--'
|
||||
" We’re looking at a comment. Now, simply determine if the comment is
|
||||
" terminated or not. If it isn’t, let Vim take care of that using
|
||||
" 'comments' and 'autoindent'. Otherwise, indent to the first lines level.
|
||||
while declaration != ""
|
||||
let [declaration, end] = s:lex(line, end)
|
||||
if declaration == "-->"
|
||||
return indent
|
||||
endif
|
||||
endwhile
|
||||
return -1
|
||||
elseif declaration == 'ELEMENT'
|
||||
" Check for element name. If none exists, indent one level.
|
||||
let [name, end] = s:lex(line, end)
|
||||
if name == ""
|
||||
return indent + &sw
|
||||
endif
|
||||
|
||||
" Check for token following element name. This can be a specification of
|
||||
" whether the start or end tag may be omitted. If nothing is found, indent
|
||||
" one level.
|
||||
let [token, end] = s:lex(line, end)
|
||||
let n = 0
|
||||
while token =~ '[-O]' && n < 2
|
||||
let [token, end] = s:lex(line, end, '^\%([-O(]\|ANY\|EMPTY\)')
|
||||
let n += 1
|
||||
endwhile
|
||||
if token == ""
|
||||
return indent + &sw
|
||||
endif
|
||||
|
||||
" Next comes the content model. If the token we’ve found isn’t a
|
||||
" parenthesis it must be either ANY, EMPTY or some random junk. Either
|
||||
" way, we’re done indenting this element, so set it to that of the first
|
||||
" line so that the terminating “>” winds up having the same indention.
|
||||
if token != '('
|
||||
return indent
|
||||
endif
|
||||
|
||||
" Now go through the content model. We need to keep track of the nesting
|
||||
" of parentheses. As soon as we hit 0 we’re done. If that happens we must
|
||||
" have a complete content model. Thus set indention to be the same as that
|
||||
" of the first line so that the terminating “>” winds up having the same
|
||||
" indention. Otherwise, we’ll indent to the innermost parentheses not yet
|
||||
" matched.
|
||||
let [indent_of_innermost, end] = s:indent_to_innermost_parentheses(line, end)
|
||||
if indent_of_innermost != -1
|
||||
return indent_of_innermost
|
||||
endif
|
||||
|
||||
" Finally, look for any additions and/or exceptions to the content model.
|
||||
" This is defined by a “+” or “-” followed by another content model
|
||||
" declaration.
|
||||
" TODO: Can the “-” be separated by whitespace from the “(”?
|
||||
let seen = { '+(': 0, '-(': 0 }
|
||||
while 1
|
||||
let [additions_exceptions, end] = s:lex(line, end, '^[+-](')
|
||||
if additions_exceptions != '+(' && additions_exceptions != '-('
|
||||
let [token, end] = s:lex(line, end)
|
||||
if token == '>'
|
||||
return indent
|
||||
endif
|
||||
" TODO: Should use s:lex here on getline(v:lnum) and check for >.
|
||||
return getline(v:lnum) =~ '^\s*>' || count(values(seen), 0) == 0 ? indent : (indent + &sw)
|
||||
endif
|
||||
|
||||
" If we’ve seen an addition or exception already and this is of the same
|
||||
" kind, the user is writing a broken DTD. Time to bail.
|
||||
if seen[additions_exceptions]
|
||||
return indent
|
||||
endif
|
||||
let seen[additions_exceptions] = 1
|
||||
|
||||
let [indent_of_innermost, end] = s:indent_to_innermost_parentheses(line, end)
|
||||
if indent_of_innermost != -1
|
||||
return indent_of_innermost
|
||||
endif
|
||||
endwhile
|
||||
elseif declaration == 'ATTLIST'
|
||||
" Check for element name. If none exists, indent one level.
|
||||
let [name, end] = s:lex(line, end)
|
||||
if name == ""
|
||||
return indent + &sw
|
||||
endif
|
||||
|
||||
" Check for any number of attributes.
|
||||
while 1
|
||||
" Check for attribute name. If none exists, indent one level, unless the
|
||||
" current line is a lone “>”, in which case we indent to the same level
|
||||
" as the first line. Otherwise, if the attribute name is “>”, we have
|
||||
" actually hit the end of the attribute list, in which case we indent to
|
||||
" the same level as the first line.
|
||||
let [name, end] = s:lex(line, end)
|
||||
if name == ""
|
||||
" TODO: Should use s:lex here on getline(v:lnum) and check for >.
|
||||
return getline(v:lnum) =~ '^\s*>' ? indent : (indent + &sw)
|
||||
elseif name == ">"
|
||||
return indent
|
||||
endif
|
||||
|
||||
" Check for attribute value declaration. If none exists, indent two
|
||||
" levels. Otherwise, if it’s an enumerated value, check for nested
|
||||
" parentheses and indent to the innermost one if we don’t reach the end
|
||||
" of the listc. Otherwise, just continue with looking for the default
|
||||
" attribute value.
|
||||
" TODO: Do validation of keywords
|
||||
" (CDATA|NMTOKEN|NMTOKENS|ID|IDREF|IDREFS|ENTITY|ENTITIES)?
|
||||
let [value, end] = s:lex(line, end, '^\%((\|[^[:space:]]\+\)')
|
||||
if value == ""
|
||||
return indent + &sw * 2
|
||||
elseif value == 'NOTATION'
|
||||
" If this is a enumerated value based on notations, read another token
|
||||
" for the actual value. If it doesn’t exist, indent three levels.
|
||||
" TODO: If validating according to above, value must be equal to '('.
|
||||
let [value, end] = s:lex(line, end, '^\%((\|[^[:space:]]\+\)')
|
||||
if value == ""
|
||||
return indent + &sw * 3
|
||||
endif
|
||||
endif
|
||||
|
||||
if value == '('
|
||||
let [indent_of_innermost, end] = s:indent_to_innermost_parentheses(line, end)
|
||||
if indent_of_innermost != -1
|
||||
return indent_of_innermost
|
||||
endif
|
||||
endif
|
||||
|
||||
" Finally look for the attribute’s default value. If non exists, indent
|
||||
" two levels.
|
||||
" TODO: Do validation of keywords (#REQUIRED|#IMPLIED)?
|
||||
let [default, end] = s:lex(line, end, '^\%("\_[^"]*"\|[^[:space:]]\+\)')
|
||||
if default == ""
|
||||
return indent + &sw * 2
|
||||
elseif default == '#FIXED'
|
||||
" We need to look for the fixed value. If non exists, indent three
|
||||
" levels.
|
||||
let [default, end] = s:lex(line, end, '^"\_[^"]*"')
|
||||
if default == ""
|
||||
return indent + &sw * 3
|
||||
endif
|
||||
endif
|
||||
endwhile
|
||||
elseif declaration == 'ENTITY'
|
||||
" Check for entity name. If none exists, indent one level. Otherwise, if
|
||||
" the name actually turns out to be a percent sign, “%”, this is a
|
||||
" parameter entity. Read another token to determine the entity name and,
|
||||
" again, if none exists, indent one level.
|
||||
let [name, end] = s:lex(line, end)
|
||||
if name == ""
|
||||
return indent + &sw
|
||||
elseif name == '%'
|
||||
let [name, end] = s:lex(line, end)
|
||||
if name == ""
|
||||
return indent + &sw
|
||||
endif
|
||||
endif
|
||||
|
||||
" Now check for the entity value. If none exists, indent one level. If it
|
||||
" does exist, indent to same level as first line, as we’re now done with
|
||||
" this entity.
|
||||
"
|
||||
" The entity value can be a string in single or double quotes (no escapes
|
||||
" to worry about, as entities are used instead). However, it can also be
|
||||
" that this is an external unparsed entity. In that case we have to look
|
||||
" further for (possibly) a public ID and an URI followed by the NDATA
|
||||
" keyword and the actual notation name. For the public ID and URI, indent
|
||||
" two levels, if they don’t exist. If the NDATA keyword doesn’t exist,
|
||||
" indent one level. Otherwise, if the actual notation name doesn’t exist,
|
||||
" indent two level. If it does, indent to same level as first line, as
|
||||
" we’re now done with this entity.
|
||||
let [value, end] = s:lex(line, end)
|
||||
if value == ""
|
||||
return indent + &sw
|
||||
elseif value == 'SYSTEM' || value == 'PUBLIC'
|
||||
let [quoted_string, end] = s:lex(line, end, '\%("[^"]\+"\|''[^'']\+''\)')
|
||||
if quoted_string == ""
|
||||
return indent + &sw * 2
|
||||
endif
|
||||
|
||||
if value == 'PUBLIC'
|
||||
let [quoted_string, end] = s:lex(line, end, '\%("[^"]\+"\|''[^'']\+''\)')
|
||||
if quoted_string == ""
|
||||
return indent + &sw * 2
|
||||
endif
|
||||
endif
|
||||
|
||||
let [ndata, end] = s:lex(line, end)
|
||||
if ndata == ""
|
||||
return indent + &sw
|
||||
endif
|
||||
|
||||
let [name, end] = s:lex(line, end)
|
||||
return name == "" ? (indent + &sw * 2) : indent
|
||||
else
|
||||
return indent
|
||||
endif
|
||||
elseif declaration == 'NOTATION'
|
||||
" Check for notation name. If none exists, indent one level.
|
||||
let [name, end] = s:lex(line, end)
|
||||
if name == ""
|
||||
return indent + &sw
|
||||
endif
|
||||
|
||||
" Now check for the external ID. If none exists, indent one level.
|
||||
let [id, end] = s:lex(line, end)
|
||||
if id == ""
|
||||
return indent + &sw
|
||||
elseif id == 'SYSTEM' || id == 'PUBLIC'
|
||||
let [quoted_string, end] = s:lex(line, end, '\%("[^"]\+"\|''[^'']\+''\)')
|
||||
if quoted_string == ""
|
||||
return indent + &sw * 2
|
||||
endif
|
||||
|
||||
if id == 'PUBLIC'
|
||||
let [quoted_string, end] = s:lex(line, end, '\%("[^"]\+"\|''[^'']\+''\|>\)')
|
||||
if quoted_string == ""
|
||||
" TODO: Should use s:lex here on getline(v:lnum) and check for >.
|
||||
return getline(v:lnum) =~ '^\s*>' ? indent : (indent + &sw * 2)
|
||||
elseif quoted_string == '>'
|
||||
return indent
|
||||
endif
|
||||
endif
|
||||
endif
|
||||
|
||||
return indent
|
||||
endif
|
||||
|
||||
" TODO: Processing directives could be indented I suppose. But perhaps it’s
|
||||
" just as well to let the user decide how to indent them (perhaps extending
|
||||
" this function to include proper support for whatever processing directive
|
||||
" language they want to use).
|
||||
|
||||
" Conditional sections are simply passed along to let Vim decide what to do
|
||||
" (and hence the user).
|
||||
return -1
|
||||
endfunction
|
||||
|
||||
let &cpo = s:cpo_save
|
||||
17
vim/bundle/ubuntu-vim72/indent/dtrace.vim
Normal file
17
vim/bundle/ubuntu-vim72/indent/dtrace.vim
Normal file
@@ -0,0 +1,17 @@
|
||||
" Vim indent file
|
||||
" Language: D script as described in "Solaris Dynamic Tracing Guide",
|
||||
" http://docs.sun.com/app/docs/doc/817-6223
|
||||
" Last Change: 2008/03/20
|
||||
" Version: 1.2
|
||||
" Maintainer: Nicolas Weber <nicolasweber@gmx.de>
|
||||
|
||||
" Only load this indent file when no other was loaded.
|
||||
if exists("b:did_indent")
|
||||
finish
|
||||
endif
|
||||
let b:did_indent = 1
|
||||
|
||||
" Built-in C indenting works nicely for dtrace.
|
||||
setlocal cindent
|
||||
|
||||
let b:undo_indent = "setl cin<"
|
||||
90
vim/bundle/ubuntu-vim72/indent/dylan.vim
Normal file
90
vim/bundle/ubuntu-vim72/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
vim/bundle/ubuntu-vim72/indent/eiffel.vim
Normal file
106
vim/bundle/ubuntu-vim72/indent/eiffel.vim
Normal file
@@ -0,0 +1,106 @@
|
||||
" Vim indent file
|
||||
" Language: Eiffel
|
||||
" Maintainer: Jocelyn Fiat <eiffel@djoce.net>
|
||||
" Previous-Maintainer: David Clarke <gadicath@dishevelled.net>
|
||||
" $Date: 2004/12/09 21:33:52 $
|
||||
" $Revision: 1.3 $
|
||||
" URL: http://www.djoce.net/page/vim/
|
||||
" Last Change: 2004 Sept 14 : removed specific value for tab (sw)
|
||||
|
||||
" 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
|
||||
|
||||
" 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 == &sw
|
||||
let ind = 0
|
||||
endif
|
||||
|
||||
return ind
|
||||
endfunction
|
||||
|
||||
" vim:sw=2
|
||||
206
vim/bundle/ubuntu-vim72/indent/erlang.vim
Normal file
206
vim/bundle/ubuntu-vim72/indent/erlang.vim
Normal file
@@ -0,0 +1,206 @@
|
||||
" Vim indent file
|
||||
" Language: Erlang
|
||||
" Maintainer: Csaba Hoch <csaba.hoch@gmail.com>
|
||||
" Contributor: Edwin Fine <efine145_nospam01 at usa dot net>
|
||||
" Last Change: 2008 Mar 12
|
||||
|
||||
" Only load this indent file when no other was loaded.
|
||||
if exists("b:did_indent")
|
||||
finish
|
||||
endif
|
||||
let b:did_indent = 1
|
||||
|
||||
setlocal indentexpr=ErlangIndent()
|
||||
setlocal indentkeys+==after,=end,=catch,=),=],=}
|
||||
|
||||
" Only define the functions once.
|
||||
if exists("*ErlangIndent")
|
||||
finish
|
||||
endif
|
||||
|
||||
" The function go through the whole line, analyses it and sets the indentation
|
||||
" (ind variable).
|
||||
" l: the number of the line to be examined.
|
||||
function s:ErlangIndentAtferLine(l)
|
||||
let i = 0 " the index of the current character in the line
|
||||
let length = strlen(a:l) " the length of the line
|
||||
let ind = 0 " how much should be the difference between the indentation of
|
||||
" the current line and the indentation of the next line?
|
||||
" e.g. +1: the indentation of the next line should be equal to
|
||||
" the indentation of the current line plus one shiftwidth
|
||||
let lastFun = 0 " the last token was a 'fun'
|
||||
let lastReceive = 0 " the last token was a 'receive'; needed for 'after'
|
||||
let lastHashMark = 0 " the last token was a 'hashmark'
|
||||
|
||||
while 0<= i && i < length
|
||||
|
||||
" m: the next value of the i
|
||||
if a:l[i] == '%'
|
||||
break
|
||||
elseif a:l[i] == '"'
|
||||
let m = matchend(a:l,'"\%([^"\\]\|\\.\)*"',i)
|
||||
let lastReceive = 0
|
||||
elseif a:l[i] == "'"
|
||||
let m = matchend(a:l,"'[^']*'",i)
|
||||
let lastReceive = 0
|
||||
elseif a:l[i] =~# "[a-z]"
|
||||
let m = matchend(a:l,".[[:alnum:]_]*",i)
|
||||
if lastFun
|
||||
let ind = ind - 1
|
||||
let lastFun = 0
|
||||
let lastReceive = 0
|
||||
elseif a:l[(i):(m-1)] =~# '^\%(case\|if\|try\)$'
|
||||
let ind = ind + 1
|
||||
elseif a:l[(i):(m-1)] =~# '^receive$'
|
||||
let ind = ind + 1
|
||||
let lastReceive = 1
|
||||
elseif a:l[(i):(m-1)] =~# '^begin$'
|
||||
let ind = ind + 2
|
||||
let lastReceive = 0
|
||||
elseif a:l[(i):(m-1)] =~# '^end$'
|
||||
let ind = ind - 2
|
||||
let lastReceive = 0
|
||||
elseif a:l[(i):(m-1)] =~# '^after$'
|
||||
if lastReceive == 0
|
||||
let ind = ind - 1
|
||||
else
|
||||
let ind = ind + 0
|
||||
end
|
||||
let lastReceive = 0
|
||||
elseif a:l[(i):(m-1)] =~# '^fun$'
|
||||
let ind = ind + 1
|
||||
let lastFun = 1
|
||||
let lastReceive = 0
|
||||
endif
|
||||
elseif a:l[i] =~# "[A-Z_]"
|
||||
let m = matchend(a:l,".[[:alnum:]_]*",i)
|
||||
let lastReceive = 0
|
||||
elseif a:l[i] == '$'
|
||||
let m = i+2
|
||||
let lastReceive = 0
|
||||
elseif a:l[i] == "." && (i+1>=length || a:l[i+1]!~ "[0-9]")
|
||||
let m = i+1
|
||||
if lastHashMark
|
||||
let lastHashMark = 0
|
||||
else
|
||||
let ind = ind - 1
|
||||
end
|
||||
let lastReceive = 0
|
||||
elseif a:l[i] == '-' && (i+1<length && a:l[i+1]=='>')
|
||||
let m = i+2
|
||||
let ind = ind + 1
|
||||
let lastReceive = 0
|
||||
elseif a:l[i] == ';'
|
||||
let m = i+1
|
||||
let ind = ind - 1
|
||||
let lastReceive = 0
|
||||
elseif a:l[i] == '#'
|
||||
let m = i+1
|
||||
let lastHashMark = 1
|
||||
elseif a:l[i] =~# '[({[]'
|
||||
let m = i+1
|
||||
let ind = ind + 1
|
||||
let lastFun = 0
|
||||
let lastReceive = 0
|
||||
let lastHashMark = 0
|
||||
elseif a:l[i] =~# '[)}\]]'
|
||||
let m = i+1
|
||||
let ind = ind - 1
|
||||
let lastReceive = 0
|
||||
else
|
||||
let m = i+1
|
||||
endif
|
||||
|
||||
let i = m
|
||||
|
||||
endwhile
|
||||
|
||||
return ind
|
||||
|
||||
endfunction
|
||||
|
||||
function s:FindPrevNonBlankNonComment(lnum)
|
||||
let lnum = prevnonblank(a:lnum)
|
||||
let line = getline(lnum)
|
||||
" continue to search above if the current line begins with a '%'
|
||||
while line =~# '^\s*%.*$'
|
||||
let lnum = prevnonblank(lnum - 1)
|
||||
if 0 == lnum
|
||||
return 0
|
||||
endif
|
||||
let line = getline(lnum)
|
||||
endwhile
|
||||
return lnum
|
||||
endfunction
|
||||
|
||||
function ErlangIndent()
|
||||
|
||||
" 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 prevline = getline(lnum)
|
||||
let currline = getline(v:lnum)
|
||||
|
||||
let ind = indent(lnum) + &sw * s:ErlangIndentAtferLine(prevline)
|
||||
|
||||
" special cases:
|
||||
if prevline =~# '^\s*\%(after\|end\)\>'
|
||||
let ind = ind + 2*&sw
|
||||
endif
|
||||
if currline =~# '^\s*end\>'
|
||||
let ind = ind - 2*&sw
|
||||
endif
|
||||
if currline =~# '^\s*after\>'
|
||||
let plnum = s:FindPrevNonBlankNonComment(v:lnum-1)
|
||||
if getline(plnum) =~# '^[^%]*\<receive\>\s*\%(%.*\)\=$'
|
||||
let ind = ind - 1*&sw
|
||||
" If the 'receive' is not in the same line as the 'after'
|
||||
else
|
||||
let ind = ind - 2*&sw
|
||||
endif
|
||||
endif
|
||||
if prevline =~# '^\s*[)}\]]'
|
||||
let ind = ind + 1*&sw
|
||||
endif
|
||||
if currline =~# '^\s*[)}\]]'
|
||||
let ind = ind - 1*&sw
|
||||
endif
|
||||
if prevline =~# '^\s*\%(catch\)\s*\%(%\|$\)'
|
||||
let ind = ind + 1*&sw
|
||||
endif
|
||||
if currline =~# '^\s*\%(catch\)\s*\%(%\|$\)'
|
||||
let ind = ind - 1*&sw
|
||||
endif
|
||||
|
||||
if ind<0
|
||||
let ind = 0
|
||||
endif
|
||||
return ind
|
||||
|
||||
endfunction
|
||||
|
||||
" TODO:
|
||||
"
|
||||
" f() ->
|
||||
" x("foo
|
||||
" bar")
|
||||
" ,
|
||||
" bad_indent.
|
||||
"
|
||||
" fun
|
||||
" init/0,
|
||||
" bad_indent
|
||||
"
|
||||
" #rec
|
||||
" .field,
|
||||
" bad_indent
|
||||
"
|
||||
" case X of
|
||||
" 1 when A; B ->
|
||||
" bad_indent
|
||||
|
||||
78
vim/bundle/ubuntu-vim72/indent/eruby.vim
Normal file
78
vim/bundle/ubuntu-vim72/indent/eruby.vim
Normal file
@@ -0,0 +1,78 @@
|
||||
" Vim indent file
|
||||
" Language: eRuby
|
||||
" Maintainer: Tim Pope <vimNOSPAM@tpope.info>
|
||||
" Info: $Id: eruby.vim,v 1.16 2008/06/29 04:18:43 tpope Exp $
|
||||
" URL: http://vim-ruby.rubyforge.org
|
||||
" Anon CVS: See above site
|
||||
" Release Coordinator: Doug Kearns <dougkearns@gmail.com>
|
||||
|
||||
if exists("b:did_indent")
|
||||
finish
|
||||
endif
|
||||
|
||||
runtime! indent/ruby.vim
|
||||
unlet! b:did_indent
|
||||
setlocal indentexpr=
|
||||
|
||||
if exists("b:eruby_subtype")
|
||||
exe "runtime! indent/".b:eruby_subtype.".vim"
|
||||
else
|
||||
runtime! indent/html.vim
|
||||
endif
|
||||
unlet! b:did_indent
|
||||
|
||||
if &l:indentexpr == ''
|
||||
if &l:cindent
|
||||
let &l:indentexpr = 'cindent(v:lnum)'
|
||||
else
|
||||
let &l:indentexpr = 'indent(prevnonblank(v:lnum-1))'
|
||||
endif
|
||||
endif
|
||||
let b:eruby_subtype_indentexpr = &l:indentexpr
|
||||
|
||||
let b:did_indent = 1
|
||||
|
||||
setlocal indentexpr=GetErubyIndent()
|
||||
setlocal indentkeys=o,O,*<Return>,<>>,{,},0),0],o,O,!^F,=end,=else,=elsif,=rescue,=ensure,=when
|
||||
|
||||
" Only define the function once.
|
||||
if exists("*GetErubyIndent")
|
||||
finish
|
||||
endif
|
||||
|
||||
function! GetErubyIndent(...)
|
||||
if a:0 && a:1 == '.'
|
||||
let v:lnum = line('.')
|
||||
elseif a:0 && a:1 =~ '^\d'
|
||||
let v:lnum = a:1
|
||||
endif
|
||||
let vcol = col('.')
|
||||
call cursor(v:lnum,1)
|
||||
let inruby = searchpair('<%','','%>','W')
|
||||
call cursor(v:lnum,vcol)
|
||||
if inruby && getline(v:lnum) !~ '^<%\|^\s*-\=%>'
|
||||
let ind = GetRubyIndent()
|
||||
else
|
||||
exe "let ind = ".b:eruby_subtype_indentexpr
|
||||
endif
|
||||
let lnum = prevnonblank(v:lnum-1)
|
||||
let line = getline(lnum)
|
||||
let cline = getline(v:lnum)
|
||||
if cline =~# '<%-\=\s*\%(}\|end\|else\|\%(ensure\|rescue\|elsif\|when\).\{-\}\)\s*\%(-\=%>\|$\)'
|
||||
let ind = ind - &sw
|
||||
endif
|
||||
if line =~# '\%({\|\<do\)\%(\s*|[^|]*|\)\=\s*-\=%>'
|
||||
let ind = ind + &sw
|
||||
elseif line =~# '<%-\=\s*\%(module\|class\|def\|if\|for\|while\|until\|else\|elsif\|case\|when\|unless\|begin\|ensure\|rescue\)\>.*%>'
|
||||
let ind = ind + &sw
|
||||
endif
|
||||
if line =~# '^\s*<%[=#-]\=\s*$' && cline !~# '^\s*end\>'
|
||||
let ind = ind + &sw
|
||||
endif
|
||||
if cline =~# '^\s*-\=%>\s*$'
|
||||
let ind = ind - &sw
|
||||
endif
|
||||
return ind
|
||||
endfunction
|
||||
|
||||
" vim:set sw=2 sts=2 ts=8 noet:
|
||||
36
vim/bundle/ubuntu-vim72/indent/eterm.vim
Normal file
36
vim/bundle/ubuntu-vim72/indent/eterm.vim
Normal file
@@ -0,0 +1,36 @@
|
||||
" Vim indent file
|
||||
" Language: Eterm configuration file
|
||||
" Maintainer: Nikolai Weibull <now@bitwi.se>
|
||||
" Latest Revision: 2006-12-20
|
||||
|
||||
if exists("b:did_indent")
|
||||
finish
|
||||
endif
|
||||
let b:did_indent = 1
|
||||
|
||||
setlocal indentexpr=GetEtermIndent()
|
||||
setlocal indentkeys=!^F,o,O,=end
|
||||
setlocal nosmartindent
|
||||
|
||||
if exists("*GetEtermIndent")
|
||||
finish
|
||||
endif
|
||||
|
||||
function GetEtermIndent()
|
||||
let lnum = prevnonblank(v:lnum - 1)
|
||||
if lnum == 0
|
||||
return 0
|
||||
endif
|
||||
|
||||
let ind = indent(lnum)
|
||||
|
||||
if getline(lnum) =~ '^\s*begin\>'
|
||||
let ind = ind + &sw
|
||||
endif
|
||||
|
||||
if getline(v:lnum) =~ '^\s*end\>'
|
||||
let ind = ind - &sw
|
||||
endif
|
||||
|
||||
return ind
|
||||
endfunction
|
||||
167
vim/bundle/ubuntu-vim72/indent/fortran.vim
Normal file
167
vim/bundle/ubuntu-vim72/indent/fortran.vim
Normal file
@@ -0,0 +1,167 @@
|
||||
" Vim indent file
|
||||
" Language: Fortran95 (and Fortran90, Fortran77, F and elf90)
|
||||
" Version: 0.37
|
||||
" URL: http://www.unb.ca/chem/ajit/indent/fortran.vim
|
||||
" Last Change: 2006 Nov 16
|
||||
" 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
|
||||
|
||||
setlocal indentkeys+==~end,=~case,=~if,=~else,=~do,=~where,=~elsewhere,=~select
|
||||
setlocal indentkeys+==~endif,=~enddo,=~endwhere,=~endselect
|
||||
setlocal indentkeys+==~type,=~interface
|
||||
|
||||
" 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 250 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 = 250
|
||||
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
|
||||
|
||||
let s:cposet=&cpoptions
|
||||
set cpoptions-=C
|
||||
|
||||
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("g: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, elsewhere, type and interface statements
|
||||
if prevstat =~? '^\s*\(\d\+\s\)\=\s*\(else\|case\|where\|elsewhere\)\>'
|
||||
\ ||prevstat =~? '^\s*\(\d\+\s\)\=\s*\(type\|interface\)\>'
|
||||
\ || 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
|
||||
" Remove unwanted indent after type( statements
|
||||
if prevstat =~? '\<type\s*('
|
||||
let ind = ind - &sw
|
||||
endif
|
||||
endif
|
||||
|
||||
"Subtract a shiftwidth from else, elsewhere, case, end if,
|
||||
" end where, end select, end interface and end type statements
|
||||
if getline(v:lnum) =~? '^\s*\(\d\+\s\)\=\s*'
|
||||
\. '\(else\|elsewhere\|case\|end\s*\(if\|where\|select\|interface\|type\)\)\>'
|
||||
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
|
||||
41
vim/bundle/ubuntu-vim72/indent/framescript.vim
Normal file
41
vim/bundle/ubuntu-vim72/indent/framescript.vim
Normal file
@@ -0,0 +1,41 @@
|
||||
" Vim indent file
|
||||
" Language: FrameScript
|
||||
" Maintainer: Nikolai Weibull <now@bitwi.se>
|
||||
" Latest Revision: 2008-07-19
|
||||
|
||||
if exists("b:did_indent")
|
||||
finish
|
||||
endif
|
||||
let b:did_indent = 1
|
||||
|
||||
setlocal indentexpr=GetFrameScriptIndent()
|
||||
setlocal indentkeys=!^F,o,O,0=~Else,0=~EndIf,0=~EndLoop,0=~EndSub
|
||||
setlocal nosmartindent
|
||||
|
||||
if exists("*GetFrameScriptIndent")
|
||||
finish
|
||||
endif
|
||||
|
||||
function GetFrameScriptIndent()
|
||||
let lnum = prevnonblank(v:lnum - 1)
|
||||
|
||||
if lnum == 0
|
||||
return 0
|
||||
endif
|
||||
|
||||
if getline(v:lnum) =~ '^\s*\*'
|
||||
return cindent(v:lnum)
|
||||
endif
|
||||
|
||||
let ind = indent(lnum)
|
||||
|
||||
if getline(lnum) =~? '^\s*\%(If\|Loop\|Sub\)'
|
||||
let ind = ind + &sw
|
||||
endif
|
||||
|
||||
if getline(v:lnum) =~? '^\s*\%(Else\|End\%(If\|Loop\|Sub\)\)'
|
||||
let ind = ind - &sw
|
||||
endif
|
||||
|
||||
return ind
|
||||
endfunction
|
||||
35
vim/bundle/ubuntu-vim72/indent/gitconfig.vim
Normal file
35
vim/bundle/ubuntu-vim72/indent/gitconfig.vim
Normal file
@@ -0,0 +1,35 @@
|
||||
" Vim indent file
|
||||
" Language: git config file
|
||||
" Maintainer: Tim Pope <vimNOSPAM@tpope.org>
|
||||
" Last Change: 2009 Dec 24
|
||||
|
||||
if exists("b:did_indent")
|
||||
finish
|
||||
endif
|
||||
let b:did_indent = 1
|
||||
|
||||
setlocal autoindent
|
||||
setlocal indentexpr=GetGitconfigIndent()
|
||||
setlocal indentkeys=o,O,*<Return>,0[,],0;,0#,=,!^F
|
||||
|
||||
" Only define the function once.
|
||||
if exists("*GetGitconfigIndent")
|
||||
finish
|
||||
endif
|
||||
|
||||
function! GetGitconfigIndent()
|
||||
let line = getline(prevnonblank(v:lnum-1))
|
||||
let cline = getline(v:lnum)
|
||||
if line =~ '\\\@<!\%(\\\\\)*\\$'
|
||||
" odd number of slashes, in a line continuation
|
||||
return 2 * &sw
|
||||
elseif cline =~ '^\s*\['
|
||||
return 0
|
||||
elseif cline =~ '^\s*\a'
|
||||
return &sw
|
||||
elseif cline == '' && line =~ '^\['
|
||||
return &sw
|
||||
else
|
||||
return -1
|
||||
endif
|
||||
endfunction
|
||||
73
vim/bundle/ubuntu-vim72/indent/haml.vim
Normal file
73
vim/bundle/ubuntu-vim72/indent/haml.vim
Normal file
@@ -0,0 +1,73 @@
|
||||
" Vim indent file
|
||||
" Language: HAML
|
||||
" Maintainer: Tim Pope <vimNOSPAM@tpope.info>
|
||||
" Last Change: 2007 Dec 16
|
||||
|
||||
if exists("b:did_indent")
|
||||
finish
|
||||
endif
|
||||
runtime! indent/ruby.vim
|
||||
unlet! b:did_indent
|
||||
let b:did_indent = 1
|
||||
|
||||
setlocal autoindent sw=2 et
|
||||
setlocal indentexpr=GetHamlIndent()
|
||||
setlocal indentkeys=o,O,*<Return>,},],0),!^F,=end,=else,=elsif,=rescue,=ensure,=when
|
||||
|
||||
" Only define the function once.
|
||||
if exists("*GetHamlIndent")
|
||||
finish
|
||||
endif
|
||||
|
||||
let s:attributes = '\%({.\{-\}}\|\[.\{-\}\]\)'
|
||||
let s:tag = '\%([%.#][[:alnum:]_-]\+\|'.s:attributes.'\)*[<>]*'
|
||||
|
||||
if !exists('g:haml_self_closing_tags')
|
||||
let g:haml_self_closing_tags = 'meta|link|img|hr|br'
|
||||
endif
|
||||
|
||||
function! GetHamlIndent()
|
||||
let lnum = prevnonblank(v:lnum-1)
|
||||
if lnum == 0
|
||||
return 0
|
||||
endif
|
||||
let line = substitute(getline(lnum),'\s\+$','','')
|
||||
let cline = substitute(substitute(getline(v:lnum),'\s\+$','',''),'^\s\+','','')
|
||||
let lastcol = strlen(line)
|
||||
let line = substitute(line,'^\s\+','','')
|
||||
let indent = indent(lnum)
|
||||
let cindent = indent(v:lnum)
|
||||
if cline =~# '\v^-\s*%(elsif|else|when)>'
|
||||
let indent = cindent < indent ? cindent : indent - &sw
|
||||
endif
|
||||
let increase = indent + &sw
|
||||
if indent == indent(lnum)
|
||||
let indent = cindent <= indent ? -1 : increase
|
||||
endif
|
||||
"let indent = indent == indent(lnum) ? -1 : indent
|
||||
"let indent = indent > indent(lnum) + &sw ? indent(lnum) + &sw : indent
|
||||
|
||||
let group = synIDattr(synID(lnum,lastcol,1),'name')
|
||||
|
||||
if line =~ '^!!!'
|
||||
return indent
|
||||
elseif line =~ '^/\%(\[[^]]*\]\)\=$'
|
||||
return increase
|
||||
elseif line =~ '^:'
|
||||
return increase
|
||||
elseif line =~ '^'.s:tag.'[=~-]\s*\%(\%(if\|else\|elsif\|unless\|case\|when\|while\|until\|for\|begin\|module\|class\|def\)\>\%(.*\<end\>\)\@!\|.*do |[^|]*|\s*$\)'
|
||||
return increase
|
||||
elseif line == '-#'
|
||||
return increase
|
||||
elseif group =~? '\v^(hamlSelfCloser)$' || line =~? '^%\v%('.g:haml_self_closing_tags.')>'
|
||||
return indent
|
||||
elseif group =~? '\v^%(hamlTag|hamlAttributesDelimiter|hamlObjectDelimiter|hamlClass|hamlId|htmlTagName|htmlSpecialTagName)$'
|
||||
return increase
|
||||
elseif synIDattr(synID(v:lnum,1,1),'name') ==? 'hamlRubyFilter'
|
||||
return GetRubyIndent()
|
||||
else
|
||||
return indent
|
||||
endif
|
||||
endfunction
|
||||
|
||||
" vim:set sw=2:
|
||||
55
vim/bundle/ubuntu-vim72/indent/hamster.vim
Normal file
55
vim/bundle/ubuntu-vim72/indent/hamster.vim
Normal file
@@ -0,0 +1,55 @@
|
||||
" Vim indent file
|
||||
" Language: Hamster Script
|
||||
" Version: 2.0.6.0
|
||||
" Last Change: Wed Nov 08 2006 12:02:42 PM
|
||||
" Maintainer: David Fishburn <fishburn@ianywhere.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+==~if,=~else,=~endif,=~endfor,=~endwhile
|
||||
setlocal indentkeys+==~do,=~until,=~while,=~repeat,=~for,=~loop
|
||||
setlocal indentkeys+==~sub,=~endsub
|
||||
|
||||
" Define the appropriate indent function but only once
|
||||
setlocal indentexpr=HamGetFreeIndent()
|
||||
if exists("*HamGetFreeIndent")
|
||||
finish
|
||||
endif
|
||||
|
||||
function HamGetIndent(lnum)
|
||||
let ind = indent(a:lnum)
|
||||
let prevline=getline(a:lnum)
|
||||
|
||||
" Add a shiftwidth to statements following if, else, elseif,
|
||||
" case, select, default, do, until, while, for, start
|
||||
if prevline =~? '^\s*\<\(if\|else\%(if\)\?\|for\|repeat\|do\|while\|sub\)\>'
|
||||
let ind = ind + &sw
|
||||
endif
|
||||
|
||||
" Subtract a shiftwidth from else, elseif, end(if|while|for), until
|
||||
let line = getline(v:lnum)
|
||||
if line =~? '^\s*\(else\|elseif\|loop\|until\|end\%(if\|while\|for\|sub\)\)\>'
|
||||
let ind = ind - &sw
|
||||
endif
|
||||
|
||||
return ind
|
||||
endfunction
|
||||
|
||||
function HamGetFreeIndent()
|
||||
" 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=HamGetIndent(lnum)
|
||||
return ind
|
||||
endfunction
|
||||
|
||||
" vim:sw=2 tw=80
|
||||
242
vim/bundle/ubuntu-vim72/indent/html.vim
Normal file
242
vim/bundle/ubuntu-vim72/indent/html.vim
Normal file
@@ -0,0 +1,242 @@
|
||||
" Description: html indenter
|
||||
" Author: Johannes Zellner <johannes@zellner.org>
|
||||
" Last Change: Mo, 05 Jun 2006 22:32:41 CEST
|
||||
" Restoring 'cpo' and 'ic' added by Bram 2006 May 5
|
||||
" 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>,<>>,{,}
|
||||
|
||||
|
||||
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
|
||||
|
||||
let s:cpo_save = &cpo
|
||||
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>
|
||||
if restore_ic == 0
|
||||
setlocal noic
|
||||
endif
|
||||
return -1
|
||||
endif
|
||||
|
||||
" [-- special handling for <javascript>: use cindent --]
|
||||
let js = '<script.*type\s*=\s*.*java'
|
||||
|
||||
""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""
|
||||
" by Tye Zdrojewski <zdro@yahoo.com>, 05 Jun 2006
|
||||
" ZDR: This needs to be an AND (we are 'after the start of the pair' AND
|
||||
" we are 'before the end of the pair'). Otherwise, indentation
|
||||
" before the start of the script block will be affected; the end of
|
||||
" the pair will still match if we are before the beginning of the
|
||||
" pair.
|
||||
"
|
||||
if 0 < searchpair(js, '', '</script>', 'nWb')
|
||||
\ && 0 < searchpair(js, '', '</script>', 'nW')
|
||||
" we're inside javascript
|
||||
if getline(lnum) !~ js && getline(a:lnum) != '</script>'
|
||||
if restore_ic == 0
|
||||
setlocal noic
|
||||
endif
|
||||
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
|
||||
if restore_ic == 0
|
||||
setlocal noic
|
||||
endif
|
||||
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
|
||||
|
||||
let &cpo = s:cpo_save
|
||||
unlet s:cpo_save
|
||||
|
||||
" [-- EOF <runtime>/indent/html.vim --]
|
||||
12
vim/bundle/ubuntu-vim72/indent/htmldjango.vim
Normal file
12
vim/bundle/ubuntu-vim72/indent/htmldjango.vim
Normal file
@@ -0,0 +1,12 @@
|
||||
" Vim indent file
|
||||
" Language: Django HTML template
|
||||
" Maintainer: Dave Hodder <dmh@dmh.org.uk>
|
||||
" Last Change: 2007 Jan 25
|
||||
|
||||
" Only load this indent file when no other was loaded.
|
||||
if exists("b:did_indent")
|
||||
finish
|
||||
endif
|
||||
|
||||
" Use HTML formatting rules.
|
||||
runtime! indent/html.vim
|
||||
63
vim/bundle/ubuntu-vim72/indent/idlang.vim
Normal file
63
vim/bundle/ubuntu-vim72/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
|
||||
|
||||
68
vim/bundle/ubuntu-vim72/indent/ishd.vim
Normal file
68
vim/bundle/ubuntu-vim72/indent/ishd.vim
Normal file
@@ -0,0 +1,68 @@
|
||||
" 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 autoindent
|
||||
setlocal indentexpr=GetIshdIndent(v:lnum)
|
||||
setlocal indentkeys&
|
||||
setlocal indentkeys+==else,=elseif,=endif,=end,=begin,<:>
|
||||
" setlocal indentkeys-=0#
|
||||
|
||||
let b:undo_indent = "setl ai< indentexpr< indentkeys<"
|
||||
|
||||
" 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
|
||||
130
vim/bundle/ubuntu-vim72/indent/java.vim
Normal file
130
vim/bundle/ubuntu-vim72/indent/java.vim
Normal file
@@ -0,0 +1,130 @@
|
||||
" Vim indent file
|
||||
" Language: Java
|
||||
" Maintainer: Toby Allsopp <toby.allsopp@peace.com> (resigned)
|
||||
" Last Change: 2005 Mar 28
|
||||
|
||||
" 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 cindent 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()
|
||||
|
||||
let b:undo_indent = "set cin< cino< indentkeys< indentexpr<"
|
||||
|
||||
" 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
|
||||
15
vim/bundle/ubuntu-vim72/indent/javascript.vim
Normal file
15
vim/bundle/ubuntu-vim72/indent/javascript.vim
Normal file
@@ -0,0 +1,15 @@
|
||||
" Vim indent file
|
||||
" Language: Javascript
|
||||
" Maintainer: None! Wanna improve this?
|
||||
" Last Change: 2007 Jan 22
|
||||
|
||||
" 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 not too bad.
|
||||
setlocal cindent
|
||||
|
||||
let b:undo_indent = "setl cin<"
|
||||
17
vim/bundle/ubuntu-vim72/indent/jsp.vim
Normal file
17
vim/bundle/ubuntu-vim72/indent/jsp.vim
Normal file
@@ -0,0 +1,17 @@
|
||||
" Vim filetype indent file
|
||||
" Language: JSP files
|
||||
" Maintainer: David Fishburn <fishburn@ianywhere.com>
|
||||
" Version: 1.0
|
||||
" Last Change: Wed Nov 08 2006 11:08:05 AM
|
||||
|
||||
" Only load this indent file when no other was loaded.
|
||||
if exists("b:did_indent")
|
||||
finish
|
||||
endif
|
||||
|
||||
" If there has been no specific JSP indent script created,
|
||||
" use the default html indent script which will handle
|
||||
" html, javascript and most of the JSP constructs.
|
||||
runtime! indent/html.vim
|
||||
|
||||
|
||||
84
vim/bundle/ubuntu-vim72/indent/ld.vim
Normal file
84
vim/bundle/ubuntu-vim72/indent/ld.vim
Normal file
@@ -0,0 +1,84 @@
|
||||
" Vim indent file
|
||||
" Language: ld(1) script
|
||||
" Maintainer: Nikolai Weibull <now@bitwi.se>
|
||||
" Latest Revision: 2006-12-20
|
||||
|
||||
if exists("b:did_indent")
|
||||
finish
|
||||
endif
|
||||
let b:did_indent = 1
|
||||
|
||||
setlocal indentexpr=GetLDIndent()
|
||||
setlocal indentkeys=0{,0},!^F,o,O
|
||||
setlocal nosmartindent
|
||||
|
||||
if exists("*GetLDIndent")
|
||||
finish
|
||||
endif
|
||||
|
||||
function s:prevnonblanknoncomment(lnum)
|
||||
let lnum = a:lnum
|
||||
while lnum > 1
|
||||
let lnum = prevnonblank(lnum)
|
||||
let line = getline(lnum)
|
||||
if line =~ '\*/'
|
||||
while lnum > 1 && line !~ '/\*'
|
||||
let lnum -= 1
|
||||
endwhile
|
||||
if line =~ '^\s*/\*'
|
||||
let lnum -= 1
|
||||
else
|
||||
break
|
||||
endif
|
||||
else
|
||||
break
|
||||
endif
|
||||
endwhile
|
||||
return lnum
|
||||
endfunction
|
||||
|
||||
function s:count_braces(lnum, count_open)
|
||||
let n_open = 0
|
||||
let n_close = 0
|
||||
let line = getline(a:lnum)
|
||||
let pattern = '[{}]'
|
||||
let i = match(line, pattern)
|
||||
while i != -1
|
||||
if synIDattr(synID(a:lnum, i + 1, 0), 'name') !~ 'ld\%(Comment\|String\)'
|
||||
if line[i] == '{'
|
||||
let n_open += 1
|
||||
elseif line[i] == '}'
|
||||
if n_open > 0
|
||||
let n_open -= 1
|
||||
else
|
||||
let n_close += 1
|
||||
endif
|
||||
endif
|
||||
endif
|
||||
let i = match(line, pattern, i + 1)
|
||||
endwhile
|
||||
return a:count_open ? n_open : n_close
|
||||
endfunction
|
||||
|
||||
function GetLDIndent()
|
||||
let line = getline(v:lnum)
|
||||
if line =~ '^\s*\*'
|
||||
return cindent(v:lnum)
|
||||
elseif line =~ '^\s*}'
|
||||
return indent(v:lnum) - &sw
|
||||
endif
|
||||
|
||||
let pnum = s:prevnonblanknoncomment(v:lnum - 1)
|
||||
if pnum == 0
|
||||
return 0
|
||||
endif
|
||||
|
||||
let ind = indent(pnum) + s:count_braces(pnum, 1) * &sw
|
||||
|
||||
let pline = getline(pnum)
|
||||
if pline =~ '}\s*$'
|
||||
let ind -= (s:count_braces(pnum, 0) - (pline =~ '^\s*}' ? 1 : 0)) * &sw
|
||||
endif
|
||||
|
||||
return ind
|
||||
endfunction
|
||||
15
vim/bundle/ubuntu-vim72/indent/lisp.vim
Normal file
15
vim/bundle/ubuntu-vim72/indent/lisp.vim
Normal file
@@ -0,0 +1,15 @@
|
||||
" Vim indent file
|
||||
" Language: Lisp
|
||||
" Maintainer: Sergey Khorev <sergey.khorev@gmail.com>
|
||||
" URL: http://iamphet.nm.ru/vim
|
||||
" Last Change: 2005 May 19
|
||||
|
||||
" Only load this indent file when no other was loaded.
|
||||
if exists("b:did_indent")
|
||||
finish
|
||||
endif
|
||||
let b:did_indent = 1
|
||||
|
||||
setlocal ai nosi
|
||||
|
||||
let b:undo_indent = "setl ai< si<"
|
||||
61
vim/bundle/ubuntu-vim72/indent/logtalk.vim
Normal file
61
vim/bundle/ubuntu-vim72/indent/logtalk.vim
Normal file
@@ -0,0 +1,61 @@
|
||||
" Maintainer: Paulo Moura <pmoura@logtalk.org>
|
||||
" Revised on: 2008.06.02
|
||||
" Language: Logtalk
|
||||
|
||||
" This Logtalk indent file is a modified version of the Prolog
|
||||
" indent file written by Gergely Kontra
|
||||
|
||||
" Only load this indent file when no other was loaded.
|
||||
if exists("b:did_indent")
|
||||
finish
|
||||
endif
|
||||
|
||||
let b:did_indent = 1
|
||||
|
||||
setlocal indentexpr=GetLogtalkIndent()
|
||||
setlocal indentkeys-=:,0#
|
||||
setlocal indentkeys+=0%,-,0;,>,0)
|
||||
|
||||
" Only define the function once.
|
||||
if exists("*GetLogtalkIndent")
|
||||
finish
|
||||
endif
|
||||
|
||||
function! GetLogtalkIndent()
|
||||
" 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 entity opening directive on previous line
|
||||
if pline =~ '^\s*:-\s\(object\|protocol\|category\)\ze(.*,$'
|
||||
let ind = ind + &sw
|
||||
" Check for clause head on previous line
|
||||
elseif pline =~ ':-\s*\(%.*\)\?$'
|
||||
let ind = ind + &sw
|
||||
" Check for entity closing directive on previous line
|
||||
elseif pline =~ '^\s*:-\send_\(object\|protocol\|category\)\.\(%.*\)\?$'
|
||||
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*\([(;]\|->\)' && pline !~ '\.\s*\(%.*\)\?$' && 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
|
||||
63
vim/bundle/ubuntu-vim72/indent/lua.vim
Normal file
63
vim/bundle/ubuntu-vim72/indent/lua.vim
Normal file
@@ -0,0 +1,63 @@
|
||||
" Vim indent file
|
||||
" Language: Lua script
|
||||
" Maintainer: Marcus Aurelius Farias <marcus.cf 'at' bol.com.br>
|
||||
" First Author: Max Ischenko <mfi 'at' ukr.net>
|
||||
" Last Change: 2007 Jul 23
|
||||
|
||||
" Only load this indent file when no other was loaded.
|
||||
if exists("b:did_indent")
|
||||
finish
|
||||
endif
|
||||
let b:did_indent = 1
|
||||
|
||||
setlocal indentexpr=GetLuaIndent()
|
||||
|
||||
" To make Vim call GetLuaIndent() when it finds '\s*end' or '\s*until'
|
||||
" on the current line ('else' is default and includes 'elseif').
|
||||
setlocal indentkeys+=0=end,0=until
|
||||
|
||||
setlocal autoindent
|
||||
|
||||
" Only define the function once.
|
||||
if exists("*GetLuaIndent")
|
||||
finish
|
||||
endif
|
||||
|
||||
function! GetLuaIndent()
|
||||
" Find a non-blank line above the current line.
|
||||
let prevlnum = prevnonblank(v:lnum - 1)
|
||||
|
||||
" Hit the start of the file, use zero indent.
|
||||
if prevlnum == 0
|
||||
return 0
|
||||
endif
|
||||
|
||||
" Add a 'shiftwidth' after lines that start a block:
|
||||
" 'function', 'if', 'for', 'while', 'repeat', 'else', 'elseif', '{'
|
||||
let ind = indent(prevlnum)
|
||||
let prevline = getline(prevlnum)
|
||||
let midx = match(prevline, '^\s*\%(if\>\|for\>\|while\>\|repeat\>\|else\>\|elseif\>\|do\>\|then\>\)')
|
||||
if midx == -1
|
||||
let midx = match(prevline, '{\s*$')
|
||||
if midx == -1
|
||||
let midx = match(prevline, '\<function\>\s*\%(\k\|[.:]\)\{-}\s*(')
|
||||
endif
|
||||
endif
|
||||
|
||||
if midx != -1
|
||||
" Add 'shiftwidth' if what we found previously is not in a comment and
|
||||
" an "end" or "until" is not present on the same line.
|
||||
if synIDattr(synID(prevlnum, midx + 1, 1), "name") != "luaComment" && prevline !~ '\<end\>\|\<until\>'
|
||||
let ind = ind + &shiftwidth
|
||||
endif
|
||||
endif
|
||||
|
||||
" Subtract a 'shiftwidth' on end, else (and elseif), until and '}'
|
||||
" This is the part that requires 'indentkeys'.
|
||||
let midx = match(getline(v:lnum), '^\s*\%(end\|else\|until\|}\)')
|
||||
if midx != -1 && synIDattr(synID(v:lnum, midx + 1, 1), "name") != "luaComment"
|
||||
let ind = ind - &shiftwidth
|
||||
endif
|
||||
|
||||
return ind
|
||||
endfunction
|
||||
13
vim/bundle/ubuntu-vim72/indent/mail.vim
Normal file
13
vim/bundle/ubuntu-vim72/indent/mail.vim
Normal file
@@ -0,0 +1,13 @@
|
||||
" Vim indent file
|
||||
" Language: Mail
|
||||
" Maintainer: Bram Moolenaar
|
||||
" Last Change: 2009 Jun 03
|
||||
|
||||
if exists("b:did_indent")
|
||||
finish
|
||||
endif
|
||||
let b:did_indent = 1
|
||||
|
||||
" What works best is auto-indenting, disable other indenting.
|
||||
" For formatting see the ftplugin.
|
||||
setlocal autoindent nosmartindent nocindent indentexpr=
|
||||
116
vim/bundle/ubuntu-vim72/indent/make.vim
Normal file
116
vim/bundle/ubuntu-vim72/indent/make.vim
Normal file
@@ -0,0 +1,116 @@
|
||||
" Vim indent file
|
||||
" Language: Makefile
|
||||
" Maintainer: Nikolai Weibull <now@bitwi.se>
|
||||
" Latest Revision: 2007-05-07
|
||||
|
||||
if exists("b:did_indent")
|
||||
finish
|
||||
endif
|
||||
let b:did_indent = 1
|
||||
|
||||
setlocal indentexpr=GetMakeIndent()
|
||||
setlocal indentkeys=!^F,o,O,<:>,=else,=endif
|
||||
setlocal nosmartindent
|
||||
|
||||
if exists("*GetMakeIndent")
|
||||
finish
|
||||
endif
|
||||
|
||||
let s:comment_rx = '^\s*#'
|
||||
let s:rule_rx = '^[^ \t#:][^#:]*:\{1,2}\%([^=:]\|$\)'
|
||||
let s:continued_rule_rx = '^[^#:]*:\{1,2}\%([^=:]\|$\)'
|
||||
let s:continuation_rx = '\\$'
|
||||
let s:assignment_rx = '^\s*\h\w*\s*[+?]\==\s*\zs.*\\$'
|
||||
let s:folded_assignment_rx = '^\s*\h\w*\s*[+?]\=='
|
||||
" TODO: This needs to be a lot more restrictive in what it matches.
|
||||
let s:just_inserted_rule_rx = '^\s*[^#:]\+:\{1,2}$'
|
||||
let s:conditional_directive_rx = '^ *\%(ifn\=\%(eq\|def\)\|else\)\>'
|
||||
let s:end_conditional_directive_rx = '^\s*\%(else\|endif\)\>'
|
||||
|
||||
function s:remove_continuation(line)
|
||||
return substitute(a:line, s:continuation_rx, "", "")
|
||||
endfunction
|
||||
|
||||
function GetMakeIndent()
|
||||
" TODO: Should this perhaps be v:lnum -1?
|
||||
" let prev_lnum = prevnonblank(v:lnum - 1)
|
||||
let prev_lnum = v:lnum - 1
|
||||
if prev_lnum == 0
|
||||
return 0
|
||||
endif
|
||||
let prev_line = getline(prev_lnum)
|
||||
|
||||
let prev_prev_lnum = prev_lnum - 1
|
||||
let prev_prev_line = prev_prev_lnum != 0 ? getline(prev_prev_lnum) : ""
|
||||
|
||||
" TODO: Deal with comments. In comments, continuations aren't interesting.
|
||||
if prev_line =~ s:continuation_rx
|
||||
if prev_prev_line =~ s:continuation_rx
|
||||
return indent(prev_lnum)
|
||||
elseif prev_line =~ s:rule_rx
|
||||
return &sw
|
||||
elseif prev_line =~ s:assignment_rx
|
||||
call cursor(prev_lnum, 1)
|
||||
if search(s:assignment_rx, 'W') != 0
|
||||
return virtcol('.') - 1
|
||||
else
|
||||
" TODO: ?
|
||||
return &sw
|
||||
endif
|
||||
else
|
||||
" TODO: OK, this might be a continued shell command, so perhaps indent
|
||||
" properly here? Leave this out for now, but in the next release this
|
||||
" should be using indent/sh.vim somehow.
|
||||
"if prev_line =~ '^\t' " s:rule_command_rx
|
||||
" if prev_line =~ '^\s\+[@-]\%(if\)\>'
|
||||
" return indent(prev_lnum) + 2
|
||||
" endif
|
||||
"endif
|
||||
return indent(prev_lnum) + &sw
|
||||
endif
|
||||
elseif prev_prev_line =~ s:continuation_rx
|
||||
let folded_line = s:remove_continuation(prev_prev_line) . ' ' . s:remove_continuation(prev_line)
|
||||
let lnum = prev_prev_lnum - 1
|
||||
let line = getline(lnum)
|
||||
while line =~ s:continuation_rx
|
||||
let folded_line = s:remove_continuation(line) . ' ' . folded_line
|
||||
let lnum -= 1
|
||||
let line = getline(lnum)
|
||||
endwhile
|
||||
let folded_lnum = lnum + 1
|
||||
if folded_line =~ s:rule_rx
|
||||
if getline(v:lnum) =~ s:rule_rx
|
||||
return 0
|
||||
else
|
||||
return &ts
|
||||
endif
|
||||
else
|
||||
" elseif folded_line =~ s:folded_assignment_rx
|
||||
if getline(v:lnum) =~ s:rule_rx
|
||||
return 0
|
||||
else
|
||||
return indent(folded_lnum)
|
||||
endif
|
||||
" else
|
||||
" " TODO: ?
|
||||
" return indent(prev_lnum)
|
||||
endif
|
||||
elseif prev_line =~ s:rule_rx
|
||||
if getline(v:lnum) =~ s:rule_rx
|
||||
return 0
|
||||
else
|
||||
return &ts
|
||||
endif
|
||||
elseif prev_line =~ s:conditional_directive_rx
|
||||
return &sw
|
||||
else
|
||||
let line = getline(v:lnum)
|
||||
if line =~ s:just_inserted_rule_rx
|
||||
return 0
|
||||
elseif line =~ s:end_conditional_directive_rx
|
||||
return v:lnum - 1 == 0 ? 0 : indent(v:lnum - 1) - &sw
|
||||
else
|
||||
return v:lnum - 1 == 0 ? 0 : indent(v:lnum - 1)
|
||||
endif
|
||||
endif
|
||||
endfunction
|
||||
74
vim/bundle/ubuntu-vim72/indent/matlab.vim
Normal file
74
vim/bundle/ubuntu-vim72/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
|
||||
75
vim/bundle/ubuntu-vim72/indent/mma.vim
Normal file
75
vim/bundle/ubuntu-vim72/indent/mma.vim
Normal file
@@ -0,0 +1,75 @@
|
||||
" Vim indent file
|
||||
" Language: Mathematica
|
||||
" Author: steve layland <layland@wolfram.com>
|
||||
" Last Change: Sat May 10 18:56:22 CDT 2005
|
||||
" Source: http://vim.sourceforge.net/scripts/script.php?script_id=1274
|
||||
" http://members.wolfram.com/layland/vim/indent/mma.vim
|
||||
"
|
||||
" NOTE:
|
||||
" Empty .m files will automatically be presumed to be Matlab files
|
||||
" unless you have the following in your .vimrc:
|
||||
"
|
||||
" let filetype_m="mma"
|
||||
"
|
||||
" Credits:
|
||||
" o steve hacked this out of a random indent file in the Vim 6.1
|
||||
" distribution that he no longer remembers...sh.vim? Thanks!
|
||||
|
||||
" Only load this indent file when no other was loaded.
|
||||
if exists("b:did_indent")
|
||||
finish
|
||||
endif
|
||||
let b:did_indent = 1
|
||||
|
||||
setlocal indentexpr=GetMmaIndent()
|
||||
setlocal indentkeys+=0[,0],0(,0)
|
||||
setlocal nosi "turn off smart indent so we don't over analyze } blocks
|
||||
|
||||
if exists("*GetMmaIndent")
|
||||
finish
|
||||
endif
|
||||
|
||||
function GetMmaIndent()
|
||||
|
||||
" Hit the start of the file, use zero indent.
|
||||
if v:lnum == 0
|
||||
return 0
|
||||
endif
|
||||
|
||||
" Find a non-blank line above the current line.
|
||||
let lnum = prevnonblank(v:lnum - 1)
|
||||
|
||||
" use indenting as a base
|
||||
let ind = indent(v:lnum)
|
||||
let lnum = v:lnum
|
||||
|
||||
" if previous line has an unmatched bracket, or ( indent.
|
||||
" doesn't do multiple parens/blocks/etc...
|
||||
|
||||
" also, indent only if this line if this line isn't starting a new
|
||||
" block... TODO - fix this with indentkeys?
|
||||
if getline(v:lnum-1) =~ '\\\@<!\%(\[[^\]]*\|([^)]*\|{[^}]*\)$' && getline(v:lnum) !~ '\s\+[\[({]'
|
||||
let ind = ind+&sw
|
||||
endif
|
||||
|
||||
" if this line had unmatched closing block,
|
||||
" indent to the matching opening block
|
||||
if getline(v:lnum) =~ '[^[]*]\s*$'
|
||||
" move to the closing bracket
|
||||
call search(']','bW')
|
||||
" and find it's partner's indent
|
||||
let ind = indent(searchpair('\[','',']','bWn'))
|
||||
" same for ( blocks
|
||||
elseif getline(v:lnum) =~ '[^(]*)$'
|
||||
call search(')','bW')
|
||||
let ind = indent(searchpair('(','',')','bWn'))
|
||||
|
||||
" and finally, close { blocks if si ain't already set
|
||||
elseif getline(v:lnum) =~ '[^{]*}'
|
||||
call search('}','bW')
|
||||
let ind = indent(searchpair('{','','}','bWn'))
|
||||
endif
|
||||
|
||||
return ind
|
||||
endfunction
|
||||
|
||||
206
vim/bundle/ubuntu-vim72/indent/mp.vim
Normal file
206
vim/bundle/ubuntu-vim72/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
|
||||
35
vim/bundle/ubuntu-vim72/indent/mupad.vim
Normal file
35
vim/bundle/ubuntu-vim72/indent/mupad.vim
Normal file
@@ -0,0 +1,35 @@
|
||||
" Vim indent file
|
||||
" Language: MuPAD source files
|
||||
" Maintainer: Dave Silvia <dsilvia@mchsi.com>
|
||||
" Filenames: *.mu
|
||||
" Date: 6/30/2004
|
||||
|
||||
if exists("b:did_indent")
|
||||
finish
|
||||
endif
|
||||
|
||||
let b:did_indent = 1
|
||||
|
||||
runtime indent/GenericIndent.vim
|
||||
|
||||
let b:indentStmts=''
|
||||
let b:dedentStmts=''
|
||||
let b:allStmts=''
|
||||
" NOTE: b:indentStmts, b:dedentStmts, and b:allStmts need to be initialized
|
||||
" to '' before callin the functions because 'indent.vim' explicitly
|
||||
" 'unlet's b:did_indent. This means that the lists will compound if
|
||||
" you change back and forth between buffers. This is true as of
|
||||
" version 6.3, 6/23/2004.
|
||||
setlocal indentexpr=GenericIndent()
|
||||
setlocal indentkeys==end_proc,=then,=else,=elif,=end_if,=end_case,=until,=end_repeat,=end_domain,=end_for,=end_while,=end,o,O
|
||||
|
||||
call GenericIndentStmts('begin,if,then,else,elif,case,repeat,until,domain,do')
|
||||
call GenericDedentStmts('end_proc,then,else,elif,end_if,end_case,until,end_repeat,end_domain,end_for,end_while,end')
|
||||
call GenericAllStmts()
|
||||
|
||||
|
||||
" TODO: More comprehensive indentstmt, dedentstmt, and indentkeys values.
|
||||
"
|
||||
" BUGS: You tell me! Probably. I just haven't found one yet or haven't been
|
||||
" told about one.
|
||||
"
|
||||
79
vim/bundle/ubuntu-vim72/indent/objc.vim
Normal file
79
vim/bundle/ubuntu-vim72/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
|
||||
253
vim/bundle/ubuntu-vim72/indent/ocaml.vim
Normal file
253
vim/bundle/ubuntu-vim72/indent/ocaml.vim
Normal file
@@ -0,0 +1,253 @@
|
||||
" Vim indent file
|
||||
" Language: OCaml
|
||||
" Maintainers: Jean-Francois Yuen <jfyuen@happycoders.org>
|
||||
" Mike Leary <leary@nwlink.com>
|
||||
" Markus Mottl <markus.mottl@gmail.com>
|
||||
" URL: http://www.ocaml.info/vim/indent/ocaml.vim
|
||||
" Last Change: 2005 Jun 25 - Fixed multiple bugs due to 'else\nreturn ind' working
|
||||
" 2005 May 09 - Added an option to not indent OCaml-indents specially (MM)
|
||||
" 2005 Apr 11 - Fixed an indentation bug concerning "let" (MM)
|
||||
|
||||
" 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=class,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)
|
||||
setlocal nolisp
|
||||
setlocal nosmartindent
|
||||
setlocal textwidth=80
|
||||
|
||||
" Comment formatting
|
||||
if !exists("no_ocaml_comments")
|
||||
if (has("comments"))
|
||||
setlocal comments=sr:(*,mb:*,ex:*)
|
||||
setlocal fo=cqort
|
||||
endif
|
||||
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*\%(class\|let\|type\)\>.*='
|
||||
|
||||
" Skipping pattern, for comments
|
||||
function s:GetLineWithoutFullComment(lnum)
|
||||
let lnum = prevnonblank(a:lnum - 1)
|
||||
let lline = substitute(getline(lnum), '(\*.*\*)\s*$', '', '')
|
||||
while lline =~ '^\s*$' && lnum > 0
|
||||
let lnum = prevnonblank(lnum - 1)
|
||||
let lline = substitute(getline(lnum), '(\*.*\*)\s*$', '', '')
|
||||
endwhile
|
||||
return lnum
|
||||
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:GetLineWithoutFullComment(llet)
|
||||
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:beflet'))
|
||||
endfunction
|
||||
|
||||
function GetOCamlIndent()
|
||||
" Find a non-commented line above the current line.
|
||||
let lnum = s:GetLineWithoutFullComment(v:lnum)
|
||||
|
||||
" At the start of the file use zero indent.
|
||||
if lnum == 0
|
||||
return 0
|
||||
endif
|
||||
|
||||
let ind = indent(lnum)
|
||||
let lline = substitute(getline(lnum), '(\*.*\*)\s*$', '', '')
|
||||
|
||||
" 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':
|
||||
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':
|
||||
elseif line =~ '^\s*let\>'
|
||||
if lline !~ s:lim . '\|' . s:letlim . '\|' . s:beflet
|
||||
return s:FindLet(s:type, '','\<let\s*$')
|
||||
endif
|
||||
|
||||
" Indent if current line begins with 'class' or 'type':
|
||||
elseif line =~ '^\s*\(class\|type\)\>'
|
||||
if lline !~ s:lim . '\|\<and\s*$\|' . s:letlim
|
||||
return s:FindLet(s:type, '','\<\(class\|type\)\s*$')
|
||||
endif
|
||||
|
||||
" Indent for pattern matching:
|
||||
elseif line =~ '^\s*|'
|
||||
if lline !~ '^\s*\(|[^\]]\|\(match\|type\|with\)\>\)\|\<\(function\|parser\|private\|with\)\s*$'
|
||||
call search('|', 'bW')
|
||||
return indent(searchpair('^\s*\(match\|type\)\>\|\<\(function\|parser\|private\|with\)\s*$', '', '^\s*|', 'bWn', 'synIDattr(synID(line("."), col("."), 0), "name") =~? "string\\|comment" || getline(".") !~ "^\\s*|.*->"'))
|
||||
endif
|
||||
|
||||
" Indent if current line begins with ';;':
|
||||
elseif line =~ '^\s*;;'
|
||||
if lline !~ ';;\s*$'
|
||||
return s:GetInd(v:lnum, s:letpat, s:letlim)
|
||||
endif
|
||||
|
||||
" Indent if current line begins with 'in':
|
||||
elseif line =~ '^\s*in\>'
|
||||
if lline !~ '^\s*\(let\|and\)\>'
|
||||
return s:FindPair('\<let\>', '', '\<in\>')
|
||||
endif
|
||||
|
||||
" Indent if current line begins with 'else':
|
||||
elseif line =~ '^\s*else\>'
|
||||
if lline !~ '^\s*\(if\|then\)\>'
|
||||
return s:FindPair('\<if\>', '', '\<else\>')
|
||||
endif
|
||||
|
||||
" Indent if current line begins with 'then':
|
||||
elseif line =~ '^\s*then\>'
|
||||
if lline !~ '^\s*\(if\|else\)\>'
|
||||
return s:FindPair('\<if\>', '', '\<then\>')
|
||||
endif
|
||||
|
||||
" Indent if current line begins with 'and':
|
||||
elseif line =~ '^\s*and\>'
|
||||
if lline !~ '^\s*\(and\|let\|type\)\>\|\<end\s*$'
|
||||
return ind - &sw
|
||||
endif
|
||||
|
||||
" Indent if current line begins with 'with':
|
||||
elseif line =~ '^\s*with\>'
|
||||
if lline !~ '^\s*\(match\|try\)\>'
|
||||
return s:FindPair('\<\%(match\|try\)\>', '','\<with\>')
|
||||
endif
|
||||
|
||||
" Indent if current line begins with 'exception', 'external', 'include' or
|
||||
" 'open':
|
||||
elseif line =~ '^\s*\(exception\|external\|include\|open\)\>'
|
||||
if lline !~ s:lim . '\|' . s:letlim
|
||||
call search(line)
|
||||
return indent(search('^\s*\(\(exception\|external\|include\|open\|type\)\>\|val\>.*:\)', 'bW'))
|
||||
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*\(\(exception\|include\|initializer\|method\|open\|type\|val\)\>\|external\>.*:\)', 'bW'))
|
||||
endif
|
||||
|
||||
" Indent if current line begins with 'constraint', 'inherit', 'initializer'
|
||||
" or 'method':
|
||||
elseif line =~ '^\s*\(constraint\|inherit\|initializer\|method\)\>'
|
||||
if lline !~ s:obj
|
||||
return indent(search('\<\(object\|object\s*(.*)\)\s*$', 'bW')) + &sw
|
||||
endif
|
||||
|
||||
endif
|
||||
|
||||
" Add a 'shiftwidth' after lines ending with:
|
||||
if lline =~ '\(:\|=\|->\|<-\|(\|\[\|{\|{<\|\[|\|\[<\|\<\(begin\|do\|else\|fun\|function\|functor\|if\|initializer\|object\|parser\|private\|sig\|struct\|then\|try\)\|\<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('(', '',')')
|
||||
|
||||
" If this is a multiline comment then align '*':
|
||||
elseif lline =~ '^\s*(\*' && line =~ '^\s*\*'
|
||||
let ind = ind + 1
|
||||
|
||||
endif
|
||||
|
||||
" Subtract a 'shiftwidth' after lines matching 'match ... with parser':
|
||||
if lline =~ '\<match\>.*\<with\>\s*\<parser\s*$'
|
||||
let ind = ind - &sw
|
||||
endif
|
||||
|
||||
return ind
|
||||
|
||||
endfunction
|
||||
|
||||
" vim:sw=2
|
||||
182
vim/bundle/ubuntu-vim72/indent/occam.vim
Normal file
182
vim/bundle/ubuntu-vim72/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
|
||||
"}}}
|
||||
173
vim/bundle/ubuntu-vim72/indent/pascal.vim
Normal file
173
vim/bundle/ubuntu-vim72/indent/pascal.vim
Normal file
@@ -0,0 +1,173 @@
|
||||
" Vim indent file
|
||||
" Language: Pascal
|
||||
" Maintainer: Neil Carter <n.carter@swansea.ac.uk>
|
||||
" Created: 2004 Jul 13
|
||||
" Last Change: 2005 Jul 05
|
||||
|
||||
|
||||
if exists("b:did_indent")
|
||||
finish
|
||||
endif
|
||||
let b:did_indent = 1
|
||||
|
||||
setlocal indentexpr=GetPascalIndent(v:lnum)
|
||||
setlocal indentkeys&
|
||||
setlocal indentkeys+==end;,==const,==type,==var,==begin,==repeat,==until,==for
|
||||
setlocal indentkeys+==program,==function,==procedure,==object,==private
|
||||
setlocal indentkeys+==record,==if,==else,==case
|
||||
|
||||
if exists("*GetPascalIndent")
|
||||
finish
|
||||
endif
|
||||
|
||||
|
||||
function! s:GetPrevNonCommentLineNum( line_num )
|
||||
|
||||
" Skip lines starting with a comment
|
||||
let SKIP_LINES = '^\s*\(\((\*\)\|\(\*\ \)\|\(\*)\)\|{\|}\)'
|
||||
|
||||
let nline = a:line_num
|
||||
while nline > 0
|
||||
let nline = prevnonblank(nline-1)
|
||||
if getline(nline) !~? SKIP_LINES
|
||||
break
|
||||
endif
|
||||
endwhile
|
||||
|
||||
return nline
|
||||
endfunction
|
||||
|
||||
|
||||
function! GetPascalIndent( line_num )
|
||||
" Line 0 always goes at column 0
|
||||
if a:line_num == 0
|
||||
return 0
|
||||
endif
|
||||
|
||||
let this_codeline = getline( a:line_num )
|
||||
|
||||
" If in the middle of a three-part comment
|
||||
if this_codeline =~ '^\s*\*'
|
||||
return indent( a:line_num )
|
||||
endif
|
||||
|
||||
let prev_codeline_num = s:GetPrevNonCommentLineNum( a:line_num )
|
||||
let prev_codeline = getline( prev_codeline_num )
|
||||
let indnt = indent( prev_codeline_num )
|
||||
|
||||
" Compiler directives should always go in column zero.
|
||||
if this_codeline =~ '^\s*{\(\$IFDEF\|\$ELSE\|\$ENDIF\)'
|
||||
return 0
|
||||
endif
|
||||
|
||||
" These items have nothing before or after (not even a comment), and
|
||||
" go on column 0. Make sure that the ^\s* is followed by \( to make
|
||||
" ORs work properly, and not include the start of line (this must
|
||||
" always appear).
|
||||
" The bracketed expression with the underline is a routine
|
||||
" separator. This is one case where we do indent comment lines.
|
||||
if this_codeline =~ '^\s*\((\*\ _\+\ \*)\|\<\(const\|var\)\>\)$'
|
||||
return 0
|
||||
endif
|
||||
|
||||
" These items may have text after them, and go on column 0 (in most
|
||||
" cases). The problem is that "function" and "procedure" keywords
|
||||
" should be indented if within a class declaration.
|
||||
if this_codeline =~ '^\s*\<\(program\|type\|uses\|procedure\|function\)\>'
|
||||
return 0
|
||||
endif
|
||||
|
||||
" BEGIN
|
||||
" If the begin does not come after "if", "for", or "else", then it
|
||||
" goes in column 0
|
||||
if this_codeline =~ '^\s*begin\>' && prev_codeline !~ '^\s*\<\(if\|for\|else\)\>'
|
||||
return 0
|
||||
endif
|
||||
|
||||
" These keywords are indented once only.
|
||||
if this_codeline =~ '^\s*\<\(private\)\>'
|
||||
return &shiftwidth
|
||||
endif
|
||||
|
||||
" If the PREVIOUS LINE contained these items, the current line is
|
||||
" always indented once.
|
||||
if prev_codeline =~ '^\s*\<\(type\|uses\)\>'
|
||||
return &shiftwidth
|
||||
endif
|
||||
|
||||
" These keywords are indented once only. Possibly surrounded by
|
||||
" other chars.
|
||||
if this_codeline =~ '^.\+\<\(object\|record\)\>'
|
||||
return &shiftwidth
|
||||
endif
|
||||
|
||||
" If the previous line was indenting...
|
||||
if prev_codeline =~ '^\s*\<\(for\|if\|case\|else\|end\ else\)\>'
|
||||
" then indent.
|
||||
let indnt = indnt + &shiftwidth
|
||||
" BUT... if this is the start of a multistatement block then we
|
||||
" need to align the begin with the previous line.
|
||||
if this_codeline =~ '^\s*begin\>'
|
||||
return indnt - &shiftwidth
|
||||
endif
|
||||
|
||||
" We also need to keep the indentation level constant if the
|
||||
" whole if-then statement was on one line.
|
||||
if prev_codeline =~ '\<then\>.\+'
|
||||
let indnt = indnt - &shiftwidth
|
||||
endif
|
||||
endif
|
||||
|
||||
" PREVIOUS-LINE BEGIN
|
||||
" If the previous line was an indenting keyword then indent once...
|
||||
if prev_codeline =~ '^\s*\<\(const\|var\|begin\|repeat\|private\)\>'
|
||||
" But only if this is another var in a list.
|
||||
if this_codeline !~ '^\s*var\>'
|
||||
return indnt + &shiftwidth
|
||||
endif
|
||||
endif
|
||||
|
||||
" PREVIOUS-LINE BEGIN
|
||||
" Indent code after a case statement begin
|
||||
if prev_codeline =~ '\:\ begin\>'
|
||||
return indnt + &shiftwidth
|
||||
endif
|
||||
|
||||
" These words may have text before them on the line (hence the .*)
|
||||
" but are followed by nothing. Always indent once only.
|
||||
if prev_codeline =~ '^\(.*\|\s*\)\<\(object\|record\)\>$'
|
||||
return indnt + &shiftwidth
|
||||
endif
|
||||
|
||||
" If we just closed a bracket that started on a previous line, then
|
||||
" unindent. But don't return yet -- we need to check for further
|
||||
" unindentation (for end/until/else)
|
||||
if prev_codeline =~ '^[^(]*[^*])'
|
||||
let indnt = indnt - &shiftwidth
|
||||
endif
|
||||
|
||||
" At the end of a block, we have to unindent both the current line
|
||||
" (the "end" for instance) and the newly-created line.
|
||||
if this_codeline =~ '^\s*\<\(end\|until\|else\)\>'
|
||||
return indnt - &shiftwidth
|
||||
endif
|
||||
|
||||
" If we have opened a bracket and it continues over one line,
|
||||
" then indent once.
|
||||
"
|
||||
" RE = an opening bracket followed by any amount of anything other
|
||||
" than a closing bracket and then the end-of-line.
|
||||
"
|
||||
" If we didn't include the end of line, this RE would match even
|
||||
" closed brackets, since it would match everything up to the closing
|
||||
" bracket.
|
||||
"
|
||||
" This test isn't clever enough to handle brackets inside strings or
|
||||
" comments.
|
||||
if prev_codeline =~ '([^*]\=[^)]*$'
|
||||
return indnt + &shiftwidth
|
||||
endif
|
||||
|
||||
return indnt
|
||||
endfunction
|
||||
|
||||
180
vim/bundle/ubuntu-vim72/indent/perl.vim
Normal file
180
vim/bundle/ubuntu-vim72/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: 2005 Sep 07
|
||||
|
||||
" 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")
|
||||
|
||||
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
|
||||
|
||||
let s:cpo_save = &cpo
|
||||
set cpo-=C
|
||||
|
||||
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\|Block\|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\|Block\|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
|
||||
703
vim/bundle/ubuntu-vim72/indent/php.vim
Normal file
703
vim/bundle/ubuntu-vim72/indent/php.vim
Normal file
@@ -0,0 +1,703 @@
|
||||
" Vim indent file
|
||||
" Language: PHP
|
||||
" Author: John Wellesz <John.wellesz (AT) teaser (DOT) fr>
|
||||
" URL: http://www.2072productions.com/vim/indent/php.vim
|
||||
" Last Change: 2008 November 22nd
|
||||
" Newsletter: http://www.2072productions.com/?to=php-indent-for-vim-newsletter.php
|
||||
" Version: 1.30
|
||||
"
|
||||
"
|
||||
" If you find a bug, please e-mail me at John.wellesz (AT) teaser (DOT) fr
|
||||
" with an example of code that breaks the algorithm.
|
||||
"
|
||||
"
|
||||
" Thanks a lot for using this script.
|
||||
"
|
||||
"
|
||||
" NOTE: This script must be used with PHP syntax ON and with the php syntax
|
||||
" script by Lutz Eymers (http://www.isp.de/data/php.vim ) or with the
|
||||
" script by Peter Hodge (http://www.vim.org/scripts/script.php?script_id=1571 )
|
||||
" the later is bunbdled by default with Vim 7.
|
||||
"
|
||||
"
|
||||
" In the case you have syntax errors in your script such as HereDoc end
|
||||
" identifiers not at col 1 you'll have to indent your file 2 times (This
|
||||
" script will automatically put HereDoc end identifiers at col 1 if
|
||||
" they are followed by a ';').
|
||||
"
|
||||
"
|
||||
" NOTE: If you are editing files in Unix file format and that (by accident)
|
||||
" there are '\r' before new lines, this script won't be able to proceed
|
||||
" correctly and will make many mistakes because it won't be able to match
|
||||
" '\s*$' correctly.
|
||||
" So you have to remove those useless characters first with a command like:
|
||||
"
|
||||
" :%s /\r$//g
|
||||
"
|
||||
" or simply 'let' the option PHP_removeCRwhenUnix to 1 and the script will
|
||||
" silently remove them when VIM load this script (at each bufread).
|
||||
"
|
||||
" Options: See :help php-indent for available options.
|
||||
|
||||
|
||||
if exists("b:did_indent")
|
||||
finish
|
||||
endif
|
||||
let b:did_indent = 1
|
||||
|
||||
|
||||
let php_sync_method = 0
|
||||
|
||||
|
||||
if exists("PHP_default_indenting")
|
||||
let b:PHP_default_indenting = PHP_default_indenting * &sw
|
||||
else
|
||||
let b:PHP_default_indenting = 0
|
||||
endif
|
||||
|
||||
if exists("PHP_BracesAtCodeLevel")
|
||||
let b:PHP_BracesAtCodeLevel = PHP_BracesAtCodeLevel
|
||||
else
|
||||
let b:PHP_BracesAtCodeLevel = 0
|
||||
endif
|
||||
|
||||
|
||||
if exists("PHP_autoformatcomment")
|
||||
let b:PHP_autoformatcomment = PHP_autoformatcomment
|
||||
else
|
||||
let b:PHP_autoformatcomment = 1
|
||||
endif
|
||||
|
||||
if exists("PHP_vintage_case_default_indent")
|
||||
let b:PHP_vintage_case_default_indent = PHP_vintage_case_default_indent
|
||||
else
|
||||
let b:PHP_vintage_case_default_indent = 0
|
||||
endif
|
||||
|
||||
|
||||
|
||||
let b:PHP_lastindented = 0
|
||||
let b:PHP_indentbeforelast = 0
|
||||
let b:PHP_indentinghuge = 0
|
||||
let b:PHP_CurrentIndentLevel = b:PHP_default_indenting
|
||||
let b:PHP_LastIndentedWasComment = 0
|
||||
let b:PHP_InsideMultilineComment = 0
|
||||
let b:InPHPcode = 0
|
||||
let b:InPHPcode_checked = 0
|
||||
let b:InPHPcode_and_script = 0
|
||||
let b:InPHPcode_tofind = ""
|
||||
let b:PHP_oldchangetick = b:changedtick
|
||||
let b:UserIsTypingComment = 0
|
||||
let b:optionsset = 0
|
||||
|
||||
setlocal nosmartindent
|
||||
setlocal noautoindent
|
||||
setlocal nocindent
|
||||
setlocal nolisp
|
||||
|
||||
setlocal indentexpr=GetPhpIndent()
|
||||
setlocal indentkeys=0{,0},0),:,!^F,o,O,e,*<Return>,=?>,=<?,=*/
|
||||
|
||||
|
||||
|
||||
let s:searchpairflags = 'bWr'
|
||||
|
||||
if &fileformat == "unix" && exists("PHP_removeCRwhenUnix") && PHP_removeCRwhenUnix
|
||||
silent! %s/\r$//g
|
||||
endif
|
||||
|
||||
if exists("*GetPhpIndent")
|
||||
call ResetPhpOptions()
|
||||
finish " XXX
|
||||
endif
|
||||
|
||||
let s:endline= '\s*\%(//.*\|#.*\|/\*.*\*/\s*\)\=$'
|
||||
let s:PHP_startindenttag = '<?\%(.*?>\)\@!\|<script[^>]*>\%(.*<\/script>\)\@!'
|
||||
"setlocal debug=msg " XXX
|
||||
|
||||
|
||||
function! GetLastRealCodeLNum(startline) " {{{
|
||||
|
||||
let lnum = a:startline
|
||||
|
||||
if b:GetLastRealCodeLNum_ADD && b:GetLastRealCodeLNum_ADD == lnum + 1
|
||||
let lnum = b:GetLastRealCodeLNum_ADD
|
||||
endif
|
||||
|
||||
let old_lnum = lnum
|
||||
|
||||
while lnum > 1
|
||||
let lnum = prevnonblank(lnum)
|
||||
let lastline = getline(lnum)
|
||||
|
||||
if b:InPHPcode_and_script && lastline =~ '?>\s*$'
|
||||
let lnum = lnum - 1
|
||||
elseif lastline =~ '^\s*?>.*<?\%(php\)\=\s*$'
|
||||
let lnum = lnum - 1
|
||||
elseif lastline =~ '^\s*\%(//\|#\|/\*.*\*/\s*$\)'
|
||||
let lnum = lnum - 1
|
||||
elseif lastline =~ '\*/\s*$'
|
||||
call cursor(lnum, 1)
|
||||
if lastline !~ '^\*/'
|
||||
call search('\*/', 'W')
|
||||
endif
|
||||
let lnum = searchpair('/\*', '', '\*/', s:searchpairflags, 'Skippmatch2()')
|
||||
|
||||
let lastline = getline(lnum)
|
||||
if lastline =~ '^\s*/\*'
|
||||
let lnum = lnum - 1
|
||||
else
|
||||
break
|
||||
endif
|
||||
|
||||
|
||||
elseif lastline =~? '\%(//\s*\|?>.*\)\@<!<?\%(php\)\=\s*$\|^\s*<script\>'
|
||||
|
||||
while lastline !~ '\(<?.*\)\@<!?>' && lnum > 1
|
||||
let lnum = lnum - 1
|
||||
let lastline = getline(lnum)
|
||||
endwhile
|
||||
if lastline =~ '^\s*?>'
|
||||
let lnum = lnum - 1
|
||||
else
|
||||
break
|
||||
endif
|
||||
|
||||
|
||||
elseif lastline =~? '^\a\w*;\=$' && lastline !~? s:notPhpHereDoc " XXX 0607
|
||||
let tofind=substitute( lastline, '\(\a\w*\);\=', '<<<''\\=\1''\\=$', '') " XXX 0607
|
||||
while getline(lnum) !~? tofind && lnum > 1
|
||||
let lnum = lnum - 1
|
||||
endwhile
|
||||
else
|
||||
break
|
||||
endif
|
||||
endwhile
|
||||
|
||||
if lnum==1 && getline(lnum)!~ '<?'
|
||||
let lnum=0
|
||||
endif
|
||||
|
||||
if b:InPHPcode_and_script && !b:InPHPcode
|
||||
let b:InPHPcode_and_script = 0
|
||||
endif
|
||||
|
||||
|
||||
|
||||
return lnum
|
||||
endfunction " }}}
|
||||
|
||||
function! Skippmatch2()
|
||||
|
||||
let line = getline(".")
|
||||
|
||||
if line =~ '\%(".*\)\@<=/\*\%(.*"\)\@=' || line =~ '\%(\%(//\|#\).*\)\@<=/\*'
|
||||
return 1
|
||||
else
|
||||
return 0
|
||||
endif
|
||||
endfun
|
||||
|
||||
function! Skippmatch() " {{{
|
||||
let synname = synIDattr(synID(line("."), col("."), 0), "name")
|
||||
if synname == "Delimiter" || synname == "phpRegionDelimiter" || synname =~# "^phpParent" || synname == "phpArrayParens" || synname =~# '^php\%(Block\|Brace\)' || synname == "javaScriptBraces" || synname =~# "^phpComment" && b:UserIsTypingComment
|
||||
return 0
|
||||
else
|
||||
return 1
|
||||
endif
|
||||
endfun " }}}
|
||||
|
||||
function! FindOpenBracket(lnum) " {{{
|
||||
call cursor(a:lnum, 1)
|
||||
return searchpair('{', '', '}', 'bW', 'Skippmatch()')
|
||||
endfun " }}}
|
||||
|
||||
function! FindTheIfOfAnElse (lnum, StopAfterFirstPrevElse) " {{{
|
||||
|
||||
if getline(a:lnum) =~# '^\s*}\s*else\%(if\)\=\>'
|
||||
let beforeelse = a:lnum
|
||||
else
|
||||
let beforeelse = GetLastRealCodeLNum(a:lnum - 1)
|
||||
endif
|
||||
|
||||
if !s:level
|
||||
let s:iftoskip = 0
|
||||
endif
|
||||
|
||||
if getline(beforeelse) =~# '^\s*\%(}\s*\)\=else\%(\s*if\)\@!\>'
|
||||
let s:iftoskip = s:iftoskip + 1
|
||||
endif
|
||||
|
||||
if getline(beforeelse) =~ '^\s*}'
|
||||
let beforeelse = FindOpenBracket(beforeelse)
|
||||
|
||||
if getline(beforeelse) =~ '^\s*{'
|
||||
let beforeelse = GetLastRealCodeLNum(beforeelse - 1)
|
||||
endif
|
||||
endif
|
||||
|
||||
|
||||
if !s:iftoskip && a:StopAfterFirstPrevElse && getline(beforeelse) =~# '^\s*\%([}]\s*\)\=else\%(if\)\=\>'
|
||||
return beforeelse
|
||||
endif
|
||||
|
||||
if getline(beforeelse) !~# '^\s*if\>' && beforeelse>1 || s:iftoskip && beforeelse>1
|
||||
|
||||
if s:iftoskip && getline(beforeelse) =~# '^\s*if\>'
|
||||
let s:iftoskip = s:iftoskip - 1
|
||||
endif
|
||||
|
||||
let s:level = s:level + 1
|
||||
let beforeelse = FindTheIfOfAnElse(beforeelse, a:StopAfterFirstPrevElse)
|
||||
endif
|
||||
|
||||
return beforeelse
|
||||
|
||||
endfunction " }}}
|
||||
|
||||
function! IslinePHP (lnum, tofind) " {{{
|
||||
let cline = getline(a:lnum)
|
||||
|
||||
if a:tofind==""
|
||||
let tofind = "^\\s*[\"']*\\s*\\zs\\S"
|
||||
else
|
||||
let tofind = a:tofind
|
||||
endif
|
||||
|
||||
let tofind = tofind . '\c'
|
||||
|
||||
let coltotest = match (cline, tofind) + 1
|
||||
|
||||
let synname = synIDattr(synID(a:lnum, coltotest, 0), "name")
|
||||
|
||||
if synname =~ '^php' || synname=="Delimiter" || synname =~? '^javaScript'
|
||||
return synname
|
||||
else
|
||||
return ""
|
||||
endif
|
||||
endfunction " }}}
|
||||
|
||||
let s:notPhpHereDoc = '\%(break\|return\|continue\|exit\|else\)'
|
||||
let s:blockstart = '\%(\%(\%(}\s*\)\=else\%(\s\+\)\=\)\=if\>\|else\>\|while\>\|switch\>\|for\%(each\)\=\>\|declare\>\|class\>\|interface\>\|abstract\>\|try\>\|catch\>\)'
|
||||
|
||||
let s:autoresetoptions = 0
|
||||
if ! s:autoresetoptions
|
||||
let s:autoresetoptions = 1
|
||||
endif
|
||||
|
||||
function! ResetPhpOptions()
|
||||
if ! b:optionsset && &filetype == "php"
|
||||
if b:PHP_autoformatcomment
|
||||
|
||||
setlocal comments=s1:/*,mb:*,ex:*/,://,:#
|
||||
|
||||
setlocal formatoptions-=t
|
||||
setlocal formatoptions+=q
|
||||
setlocal formatoptions+=r
|
||||
setlocal formatoptions+=o
|
||||
setlocal formatoptions+=w
|
||||
setlocal formatoptions+=c
|
||||
setlocal formatoptions+=b
|
||||
endif
|
||||
let b:optionsset = 1
|
||||
endif
|
||||
endfunc
|
||||
|
||||
call ResetPhpOptions()
|
||||
|
||||
function! GetPhpIndent()
|
||||
|
||||
let b:GetLastRealCodeLNum_ADD = 0
|
||||
|
||||
let UserIsEditing=0
|
||||
if b:PHP_oldchangetick != b:changedtick
|
||||
let b:PHP_oldchangetick = b:changedtick
|
||||
let UserIsEditing=1
|
||||
endif
|
||||
|
||||
if b:PHP_default_indenting
|
||||
let b:PHP_default_indenting = g:PHP_default_indenting * &sw
|
||||
endif
|
||||
|
||||
let cline = getline(v:lnum)
|
||||
|
||||
if !b:PHP_indentinghuge && b:PHP_lastindented > b:PHP_indentbeforelast
|
||||
if b:PHP_indentbeforelast
|
||||
let b:PHP_indentinghuge = 1
|
||||
echom 'Large indenting detected, speed optimizations engaged (v1.30)'
|
||||
endif
|
||||
let b:PHP_indentbeforelast = b:PHP_lastindented
|
||||
endif
|
||||
|
||||
if b:InPHPcode_checked && prevnonblank(v:lnum - 1) != b:PHP_lastindented
|
||||
if b:PHP_indentinghuge
|
||||
echom 'Large indenting deactivated'
|
||||
let b:PHP_indentinghuge = 0
|
||||
let b:PHP_CurrentIndentLevel = b:PHP_default_indenting
|
||||
endif
|
||||
let b:PHP_lastindented = v:lnum
|
||||
let b:PHP_LastIndentedWasComment=0
|
||||
let b:PHP_InsideMultilineComment=0
|
||||
let b:PHP_indentbeforelast = 0
|
||||
|
||||
let b:InPHPcode = 0
|
||||
let b:InPHPcode_checked = 0
|
||||
let b:InPHPcode_and_script = 0
|
||||
let b:InPHPcode_tofind = ""
|
||||
|
||||
elseif v:lnum > b:PHP_lastindented
|
||||
let real_PHP_lastindented = b:PHP_lastindented
|
||||
let b:PHP_lastindented = v:lnum
|
||||
endif
|
||||
|
||||
|
||||
if !b:InPHPcode_checked " {{{ One time check
|
||||
let b:InPHPcode_checked = 1
|
||||
|
||||
let synname = ""
|
||||
if cline !~ '<?.*?>'
|
||||
let synname = IslinePHP (prevnonblank(v:lnum), "")
|
||||
endif
|
||||
|
||||
if synname!=""
|
||||
if synname != "phpHereDoc" && synname != "phpHereDocDelimiter"
|
||||
let b:InPHPcode = 1
|
||||
let b:InPHPcode_tofind = ""
|
||||
|
||||
if synname =~# "^phpComment"
|
||||
let b:UserIsTypingComment = 1
|
||||
else
|
||||
let b:UserIsTypingComment = 0
|
||||
endif
|
||||
|
||||
if synname =~? '^javaScript'
|
||||
let b:InPHPcode_and_script = 1
|
||||
endif
|
||||
|
||||
else
|
||||
let b:InPHPcode = 0
|
||||
let b:UserIsTypingComment = 0
|
||||
|
||||
let lnum = v:lnum - 1
|
||||
while getline(lnum) !~? '<<<''\=\a\w*''\=$' && lnum > 1
|
||||
let lnum = lnum - 1
|
||||
endwhile
|
||||
|
||||
let b:InPHPcode_tofind = substitute( getline(lnum), '^.*<<<''\=\(\a\w*\)''\=$', '^\\s*\1;\\=$', '') " XXX 0607
|
||||
endif
|
||||
else
|
||||
let b:InPHPcode = 0
|
||||
let b:UserIsTypingComment = 0
|
||||
let b:InPHPcode_tofind = '<?\%(.*?>\)\@!\|<script.*>'
|
||||
endif
|
||||
endif "!b:InPHPcode_checked }}}
|
||||
|
||||
|
||||
" Test if we are indenting PHP code {{{
|
||||
let lnum = prevnonblank(v:lnum - 1)
|
||||
let last_line = getline(lnum)
|
||||
|
||||
if b:InPHPcode_tofind!=""
|
||||
if cline =~? b:InPHPcode_tofind
|
||||
let b:InPHPcode = 1
|
||||
let b:InPHPcode_tofind = ""
|
||||
let b:UserIsTypingComment = 0
|
||||
if cline =~ '\*/'
|
||||
call cursor(v:lnum, 1)
|
||||
if cline !~ '^\*/'
|
||||
call search('\*/', 'W')
|
||||
endif
|
||||
let lnum = searchpair('/\*', '', '\*/', s:searchpairflags, 'Skippmatch2()')
|
||||
|
||||
let b:PHP_CurrentIndentLevel = b:PHP_default_indenting
|
||||
|
||||
let b:PHP_LastIndentedWasComment = 0
|
||||
|
||||
if cline =~ '^\s*\*/'
|
||||
return indent(lnum) + 1
|
||||
else
|
||||
return indent(lnum)
|
||||
endif
|
||||
|
||||
elseif cline =~? '<script\>'
|
||||
let b:InPHPcode_and_script = 1
|
||||
let b:GetLastRealCodeLNum_ADD = v:lnum
|
||||
endif
|
||||
endif
|
||||
endif
|
||||
|
||||
if b:InPHPcode
|
||||
|
||||
if !b:InPHPcode_and_script && last_line =~ '\%(<?.*\)\@<!?>\%(.*<?\)\@!' && IslinePHP(lnum, '?>')=~"Delimiter"
|
||||
if cline !~? s:PHP_startindenttag
|
||||
let b:InPHPcode = 0
|
||||
let b:InPHPcode_tofind = s:PHP_startindenttag
|
||||
elseif cline =~? '<script\>'
|
||||
let b:InPHPcode_and_script = 1
|
||||
endif
|
||||
|
||||
elseif last_line =~? '<<<''\=\a\w*''\=$' " XXX 0607
|
||||
let b:InPHPcode = 0
|
||||
let b:InPHPcode_tofind = substitute( last_line, '^.*<<<''\=\(\a\w*\)''\=$', '^\\s*\1;\\=$', '') " XXX 0607
|
||||
|
||||
elseif !UserIsEditing && cline =~ '^\s*/\*\%(.*\*/\)\@!' && getline(v:lnum + 1) !~ '^\s*\*'
|
||||
let b:InPHPcode = 0
|
||||
let b:InPHPcode_tofind = '\*/'
|
||||
|
||||
elseif cline =~? '^\s*</script>'
|
||||
let b:InPHPcode = 0
|
||||
let b:InPHPcode_tofind = s:PHP_startindenttag
|
||||
endif
|
||||
endif " }}}
|
||||
|
||||
|
||||
if !b:InPHPcode && !b:InPHPcode_and_script
|
||||
return -1
|
||||
endif
|
||||
|
||||
" Indent successive // or # comment the same way the first is {{{
|
||||
if cline =~ '^\s*\%(//\|#\|/\*.*\*/\s*$\)'
|
||||
if b:PHP_LastIndentedWasComment == 1
|
||||
return indent(real_PHP_lastindented)
|
||||
endif
|
||||
let b:PHP_LastIndentedWasComment = 1
|
||||
else
|
||||
let b:PHP_LastIndentedWasComment = 0
|
||||
endif " }}}
|
||||
|
||||
" Indent multiline /* comments correctly {{{
|
||||
|
||||
if b:PHP_InsideMultilineComment || b:UserIsTypingComment
|
||||
if cline =~ '^\s*\*\%(\/\)\@!'
|
||||
if last_line =~ '^\s*/\*'
|
||||
return indent(lnum) + 1
|
||||
else
|
||||
return indent(lnum)
|
||||
endif
|
||||
else
|
||||
let b:PHP_InsideMultilineComment = 0
|
||||
endif
|
||||
endif
|
||||
|
||||
if !b:PHP_InsideMultilineComment && cline =~ '^\s*/\*' && cline !~ '\*/\s*$'
|
||||
if getline(v:lnum + 1) !~ '^\s*\*'
|
||||
return -1
|
||||
endif
|
||||
let b:PHP_InsideMultilineComment = 1
|
||||
endif " }}}
|
||||
|
||||
|
||||
" Things always indented at col 1 (PHP delimiter: <?, ?>, Heredoc end) {{{
|
||||
if cline =~# '^\s*<?' && cline !~ '?>'
|
||||
return 0
|
||||
endif
|
||||
|
||||
if cline =~ '^\s*?>' && cline !~# '<?'
|
||||
return 0
|
||||
endif
|
||||
|
||||
if cline =~? '^\s*\a\w*;$\|^\a\w*$' && cline !~? s:notPhpHereDoc " XXX 0607
|
||||
return 0
|
||||
endif " }}}
|
||||
|
||||
let s:level = 0
|
||||
|
||||
let lnum = GetLastRealCodeLNum(v:lnum - 1)
|
||||
|
||||
let last_line = getline(lnum)
|
||||
let ind = indent(lnum)
|
||||
let endline= s:endline
|
||||
|
||||
if ind==0 && b:PHP_default_indenting
|
||||
let ind = b:PHP_default_indenting
|
||||
endif
|
||||
|
||||
if lnum == 0
|
||||
return b:PHP_default_indenting
|
||||
endif
|
||||
|
||||
|
||||
if cline =~ '^\s*}\%(}}\)\@!'
|
||||
let ind = indent(FindOpenBracket(v:lnum))
|
||||
let b:PHP_CurrentIndentLevel = b:PHP_default_indenting
|
||||
return ind
|
||||
endif
|
||||
|
||||
if cline =~ '^\s*\*/'
|
||||
call cursor(v:lnum, 1)
|
||||
if cline !~ '^\*/'
|
||||
call search('\*/', 'W')
|
||||
endif
|
||||
let lnum = searchpair('/\*', '', '\*/', s:searchpairflags, 'Skippmatch2()')
|
||||
|
||||
let b:PHP_CurrentIndentLevel = b:PHP_default_indenting
|
||||
|
||||
if cline =~ '^\s*\*/'
|
||||
return indent(lnum) + 1
|
||||
else
|
||||
return indent(lnum)
|
||||
endif
|
||||
endif
|
||||
|
||||
let defaultORcase = '^\s*\%(default\|case\).*:'
|
||||
|
||||
if last_line =~ '[;}]'.endline && last_line !~ '^)' && last_line !~# defaultORcase " Added && last_line !~ '^)' on 2007-12-30
|
||||
if ind==b:PHP_default_indenting
|
||||
return b:PHP_default_indenting
|
||||
elseif b:PHP_indentinghuge && ind==b:PHP_CurrentIndentLevel && cline !~# '^\s*\%(else\|\%(case\|default\).*:\|[})];\=\)' && last_line !~# '^\s*\%(\%(}\s*\)\=else\)' && getline(GetLastRealCodeLNum(lnum - 1))=~';'.endline
|
||||
return b:PHP_CurrentIndentLevel
|
||||
endif
|
||||
endif
|
||||
|
||||
let LastLineClosed = 0
|
||||
|
||||
let terminated = '\%(;\%(\s*?>\)\=\|<<<''\=\a\w*''\=$\|^\s*}\)'.endline " XXX 0607
|
||||
|
||||
let unstated = '\%(^\s*'.s:blockstart.'.*)\|\%(//.*\)\@<!\<e'.'lse\>\)'.endline
|
||||
|
||||
if ind != b:PHP_default_indenting && cline =~# '^\s*else\%(if\)\=\>'
|
||||
let b:PHP_CurrentIndentLevel = b:PHP_default_indenting
|
||||
return indent(FindTheIfOfAnElse(v:lnum, 1))
|
||||
elseif cline =~ '^\s*)\=\s*{'
|
||||
let previous_line = last_line
|
||||
let last_line_num = lnum
|
||||
|
||||
while last_line_num > 1
|
||||
|
||||
if previous_line =~ '^\s*\%(' . s:blockstart . '\|\%([a-zA-Z]\s*\)*function\)'
|
||||
|
||||
let ind = indent(last_line_num)
|
||||
|
||||
if b:PHP_BracesAtCodeLevel
|
||||
let ind = ind + &sw
|
||||
endif
|
||||
|
||||
return ind
|
||||
endif
|
||||
|
||||
let last_line_num = last_line_num - 1
|
||||
let previous_line = getline(last_line_num)
|
||||
endwhile
|
||||
|
||||
elseif last_line =~# unstated && cline !~ '^\s*);\='.endline
|
||||
let ind = ind + &sw " we indent one level further when the preceding line is not stated
|
||||
return ind
|
||||
|
||||
elseif (ind != b:PHP_default_indenting || last_line =~ '^)' ) && last_line =~ terminated " Added || last_line =~ '^)' on 2007-12-30 (array indenting [rpblem broke other things)
|
||||
let previous_line = last_line
|
||||
let last_line_num = lnum
|
||||
let LastLineClosed = 1
|
||||
|
||||
while 1
|
||||
if previous_line =~ '^\s*}'
|
||||
let last_line_num = FindOpenBracket(last_line_num)
|
||||
|
||||
if getline(last_line_num) =~ '^\s*{'
|
||||
let last_line_num = GetLastRealCodeLNum(last_line_num - 1)
|
||||
endif
|
||||
|
||||
let previous_line = getline(last_line_num)
|
||||
|
||||
continue
|
||||
else
|
||||
|
||||
if getline(last_line_num) =~# '^\s*else\%(if\)\=\>'
|
||||
let last_line_num = FindTheIfOfAnElse(last_line_num, 0)
|
||||
continue
|
||||
endif
|
||||
|
||||
|
||||
let last_match = last_line_num
|
||||
|
||||
let one_ahead_indent = indent(last_line_num)
|
||||
let last_line_num = GetLastRealCodeLNum(last_line_num - 1)
|
||||
let two_ahead_indent = indent(last_line_num)
|
||||
let after_previous_line = previous_line
|
||||
let previous_line = getline(last_line_num)
|
||||
|
||||
|
||||
if previous_line =~# defaultORcase.'\|{'.endline
|
||||
break
|
||||
endif
|
||||
|
||||
if after_previous_line=~# '^\s*'.s:blockstart.'.*)'.endline && previous_line =~# '[;}]'.endline
|
||||
break
|
||||
endif
|
||||
|
||||
if one_ahead_indent == two_ahead_indent || last_line_num < 1
|
||||
if previous_line =~# '\%(;\|^\s*}\)'.endline || last_line_num < 1
|
||||
break
|
||||
endif
|
||||
endif
|
||||
endif
|
||||
endwhile
|
||||
|
||||
if indent(last_match) != ind
|
||||
let ind = indent(last_match)
|
||||
let b:PHP_CurrentIndentLevel = b:PHP_default_indenting
|
||||
|
||||
if cline =~# defaultORcase
|
||||
let ind = ind - &sw
|
||||
endif
|
||||
return ind
|
||||
endif
|
||||
endif
|
||||
|
||||
let plinnum = GetLastRealCodeLNum(lnum - 1)
|
||||
let pline = getline(plinnum)
|
||||
|
||||
let last_line = substitute(last_line,"\\(//\\|#\\)\\(\\(\\([^\"']*\\([\"']\\)[^\"']*\\5\\)\\+[^\"']*$\\)\\|\\([^\"']*$\\)\\)",'','')
|
||||
|
||||
|
||||
if ind == b:PHP_default_indenting
|
||||
if last_line =~ terminated
|
||||
let LastLineClosed = 1
|
||||
endif
|
||||
endif
|
||||
|
||||
if !LastLineClosed
|
||||
|
||||
|
||||
if last_line =~# '[{(]'.endline || last_line =~? '\h\w*\s*(.*,$' && pline !~ '[,(]'.endline
|
||||
|
||||
if !b:PHP_BracesAtCodeLevel || last_line !~# '^\s*{'
|
||||
let ind = ind + &sw
|
||||
endif
|
||||
|
||||
if b:PHP_BracesAtCodeLevel || b:PHP_vintage_case_default_indent == 1 || cline !~# defaultORcase
|
||||
let b:PHP_CurrentIndentLevel = ind
|
||||
|
||||
return ind
|
||||
endif
|
||||
|
||||
elseif last_line =~ '\S\+\s*),'.endline
|
||||
call cursor(lnum, 1)
|
||||
call search('),'.endline, 'W')
|
||||
let openedparent = searchpair('(', '', ')', 'bW', 'Skippmatch()')
|
||||
if openedparent != lnum
|
||||
let ind = indent(openedparent)
|
||||
endif
|
||||
elseif last_line =~ '^\s*'.s:blockstart
|
||||
let ind = ind + &sw
|
||||
|
||||
elseif last_line =~# defaultORcase && cline !~# defaultORcase
|
||||
let ind = ind + &sw
|
||||
|
||||
|
||||
elseif pline =~ '\%(;\%(\s*?>\)\=\|<<<''\=\a\w*''\=$\|^\s*}\|{\)'.endline . '\|' . defaultORcase && cline !~# defaultORcase
|
||||
|
||||
let ind = ind + &sw
|
||||
endif
|
||||
|
||||
endif
|
||||
|
||||
if cline =~ '^\s*);\='
|
||||
let ind = ind - &sw
|
||||
elseif cline =~# defaultORcase && last_line !~# defaultORcase
|
||||
let ind = ind - &sw
|
||||
|
||||
endif
|
||||
|
||||
let b:PHP_CurrentIndentLevel = ind
|
||||
return ind
|
||||
endfunction
|
||||
68
vim/bundle/ubuntu-vim72/indent/postscr.vim
Normal file
68
vim/bundle/ubuntu-vim72/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
vim/bundle/ubuntu-vim72/indent/pov.vim
Normal file
84
vim/bundle/ubuntu-vim72/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
vim/bundle/ubuntu-vim72/indent/prolog.vim
Normal file
58
vim/bundle/ubuntu-vim72/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
|
||||
13
vim/bundle/ubuntu-vim72/indent/pyrex.vim
Normal file
13
vim/bundle/ubuntu-vim72/indent/pyrex.vim
Normal file
@@ -0,0 +1,13 @@
|
||||
" Vim indent file
|
||||
" Language: Pyrex
|
||||
" Maintainer: Marco Barisione <marco.bari@people.it>
|
||||
" URL: http://marcobari.altervista.org/pyrex_vim.html
|
||||
" Last Change: 2005 Jun 24
|
||||
|
||||
" Only load this indent file when no other was loaded.
|
||||
if exists("b:did_indent")
|
||||
finish
|
||||
endif
|
||||
|
||||
" Use Python formatting rules
|
||||
runtime! indent/python.vim
|
||||
193
vim/bundle/ubuntu-vim72/indent/python.vim
Normal file
193
vim/bundle/ubuntu-vim72/indent/python.vim
Normal file
@@ -0,0 +1,193 @@
|
||||
" Vim indent file
|
||||
" Language: Python
|
||||
" Maintainer: Bram Moolenaar <Bram@vim.org>
|
||||
" Original Author: David Bustos <bustos@caltech.edu>
|
||||
" Last Change: 2006 Jun 18
|
||||
|
||||
" 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
|
||||
|
||||
" Come here when loading the script the first time.
|
||||
|
||||
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) + (exists("g:pyindent_continue") ? eval(g:pyindent_continue) : (&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") =~ "String$"
|
||||
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')"
|
||||
\ . " =~ '\\(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')"
|
||||
\ . " =~ '\\(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')"
|
||||
\ . " =~ '\\(Comment\\|String\\)$'")
|
||||
if pp > 0
|
||||
return indent(plnum) + (exists("g:pyindent_nested_paren") ? eval(g:pyindent_nested_paren) : &sw)
|
||||
endif
|
||||
return indent(plnum) + (exists("g:pyindent_open_paren") ? eval(g:pyindent_open_paren) : (&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)
|
||||
if has('syntax_items')
|
||||
" If the last character in the line is a comment, do a binary search for
|
||||
" the start of the comment. synID() is slow, a linear search would take
|
||||
" too long on a long line.
|
||||
if synIDattr(synID(plnum, pline_len, 1), "name") =~ "Comment$"
|
||||
let min = 1
|
||||
let max = pline_len
|
||||
while min < max
|
||||
let col = (min + max) / 2
|
||||
if synIDattr(synID(plnum, col, 1), "name") =~ "Comment$"
|
||||
let max = col
|
||||
else
|
||||
let min = col + 1
|
||||
endif
|
||||
endwhile
|
||||
let pline = strpart(pline, 0, min - 1)
|
||||
endif
|
||||
else
|
||||
let col = 0
|
||||
while col < pline_len
|
||||
if pline[col] == '#'
|
||||
let pline = strpart(pline, 0, col)
|
||||
break
|
||||
endif
|
||||
let col = col + 1
|
||||
endwhile
|
||||
endif
|
||||
|
||||
" 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\|pass\)\>'
|
||||
" 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
|
||||
if getline(lnum) =~ '^\s*\(try\|except\)\>'
|
||||
let ind = indent(lnum)
|
||||
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
|
||||
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
|
||||
36
vim/bundle/ubuntu-vim72/indent/readline.vim
Normal file
36
vim/bundle/ubuntu-vim72/indent/readline.vim
Normal file
@@ -0,0 +1,36 @@
|
||||
" Vim indent file
|
||||
" Language: readline configuration file
|
||||
" Maintainer: Nikolai Weibull <now@bitwi.se>
|
||||
" Latest Revision: 2006-12-20
|
||||
|
||||
if exists("b:did_indent")
|
||||
finish
|
||||
endif
|
||||
let b:did_indent = 1
|
||||
|
||||
setlocal indentexpr=GetReadlineIndent()
|
||||
setlocal indentkeys=!^F,o,O,=$else,=$endif
|
||||
setlocal nosmartindent
|
||||
|
||||
if exists("*GetReadlineIndent")
|
||||
finish
|
||||
endif
|
||||
|
||||
function GetReadlineIndent()
|
||||
let lnum = prevnonblank(v:lnum - 1)
|
||||
if lnum == 0
|
||||
return 0
|
||||
endif
|
||||
|
||||
let ind = indent(lnum)
|
||||
|
||||
if getline(lnum) =~ '^\s*$\(if\|else\)\>'
|
||||
let ind = ind + &sw
|
||||
endif
|
||||
|
||||
if getline(v:lnum) =~ '^\s*$\(else\|endif\)\>'
|
||||
let ind = ind - &sw
|
||||
endif
|
||||
|
||||
return ind
|
||||
endfunction
|
||||
63
vim/bundle/ubuntu-vim72/indent/rpl.vim
Normal file
63
vim/bundle/ubuntu-vim72/indent/rpl.vim
Normal file
@@ -0,0 +1,63 @@
|
||||
" Vim indent file
|
||||
" Language: RPL/2
|
||||
" Version: 0.2
|
||||
" Last Change: 2005 Mar 28
|
||||
" Maintainer: BERTRAND Joë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 autoindent
|
||||
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
|
||||
|
||||
let b:undo_indent = "set ai< indentkeys< indentexpr<"
|
||||
|
||||
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
|
||||
53
vim/bundle/ubuntu-vim72/indent/rst.vim
Normal file
53
vim/bundle/ubuntu-vim72/indent/rst.vim
Normal file
@@ -0,0 +1,53 @@
|
||||
" Vim indent file
|
||||
" Language: reStructuredText Documentation Format
|
||||
" Maintainer: Nikolai Weibull <now@bitwi.se>
|
||||
" Latest Revision: 2006-12-20
|
||||
|
||||
if exists("b:did_indent")
|
||||
finish
|
||||
endif
|
||||
let b:did_indent = 1
|
||||
|
||||
setlocal indentexpr=GetRSTIndent()
|
||||
setlocal indentkeys=!^F,o,O
|
||||
setlocal nosmartindent
|
||||
|
||||
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
|
||||
378
vim/bundle/ubuntu-vim72/indent/ruby.vim
Normal file
378
vim/bundle/ubuntu-vim72/indent/ruby.vim
Normal file
@@ -0,0 +1,378 @@
|
||||
" Vim indent file
|
||||
" Language: Ruby
|
||||
" Maintainer: Nikolai Weibull <now at bitwi.se>
|
||||
" Info: $Id: ruby.vim,v 1.47 2008/06/29 04:18:43 tpope Exp $
|
||||
" URL: http://vim-ruby.rubyforge.org
|
||||
" Anon CVS: See above site
|
||||
" Release Coordinator: Doug Kearns <dougkearns@gmail.com>
|
||||
|
||||
" 0. Initialization {{{1
|
||||
" =================
|
||||
|
||||
" Only load this indent file when no other was loaded.
|
||||
if exists("b:did_indent")
|
||||
finish
|
||||
endif
|
||||
let b:did_indent = 1
|
||||
|
||||
setlocal nosmartindent
|
||||
|
||||
" Now, set up our indentation expression and keys that trigger it.
|
||||
setlocal indentexpr=GetRubyIndent()
|
||||
setlocal indentkeys=0{,0},0),0],!^F,o,O,e
|
||||
setlocal indentkeys+==end,=elsif,=when,=ensure,=rescue,==begin,==end
|
||||
|
||||
" Only define the function once.
|
||||
if exists("*GetRubyIndent")
|
||||
finish
|
||||
endif
|
||||
|
||||
let s:cpo_save = &cpo
|
||||
set cpo&vim
|
||||
|
||||
" 1. Variables {{{1
|
||||
" ============
|
||||
|
||||
" Regex of syntax group names that are or delimit string or are comments.
|
||||
let s:syng_strcom = '\<ruby\%(String\|StringEscape\|ASCIICode' .
|
||||
\ '\|Interpolation\|NoInterpolation\|Comment\|Documentation\)\>'
|
||||
|
||||
" Regex of syntax group names that are strings.
|
||||
let s:syng_string =
|
||||
\ '\<ruby\%(String\|Interpolation\|NoInterpolation\|StringEscape\)\>'
|
||||
|
||||
" Regex of syntax group names that are strings or documentation.
|
||||
let s:syng_stringdoc =
|
||||
\'\<ruby\%(String\|Interpolation\|NoInterpolation\|StringEscape\|Documentation\)\>'
|
||||
|
||||
" Expression used to check whether we should skip a match with searchpair().
|
||||
let s:skip_expr =
|
||||
\ "synIDattr(synID(line('.'),col('.'),1),'name') =~ '".s:syng_strcom."'"
|
||||
|
||||
" Regex used for words that, at the start of a line, add a level of indent.
|
||||
let s:ruby_indent_keywords = '^\s*\zs\<\%(module\|class\|def\|if\|for' .
|
||||
\ '\|while\|until\|else\|elsif\|case\|when\|unless\|begin\|ensure' .
|
||||
\ '\|rescue\)\>' .
|
||||
\ '\|\%([*+/,=-]\|<<\|>>\|:\s\)\s*\zs' .
|
||||
\ '\<\%(if\|for\|while\|until\|case\|unless\|begin\)\>'
|
||||
|
||||
" Regex used for words that, at the start of a line, remove a level of indent.
|
||||
let s:ruby_deindent_keywords =
|
||||
\ '^\s*\zs\<\%(ensure\|else\|rescue\|elsif\|when\|end\)\>'
|
||||
|
||||
" Regex that defines the start-match for the 'end' keyword.
|
||||
"let s:end_start_regex = '\%(^\|[^.]\)\<\%(module\|class\|def\|if\|for\|while\|until\|case\|unless\|begin\|do\)\>'
|
||||
" TODO: the do here should be restricted somewhat (only at end of line)?
|
||||
let s:end_start_regex = '^\s*\zs\<\%(module\|class\|def\|if\|for' .
|
||||
\ '\|while\|until\|case\|unless\|begin\)\>' .
|
||||
\ '\|\%([*+/,=-]\|<<\|>>\|:\s\)\s*\zs' .
|
||||
\ '\<\%(if\|for\|while\|until\|case\|unless\|begin\)\>' .
|
||||
\ '\|\<do\>'
|
||||
|
||||
" Regex that defines the middle-match for the 'end' keyword.
|
||||
let s:end_middle_regex = '\<\%(ensure\|else\|\%(\%(^\|;\)\s*\)\@<=\<rescue\>\|when\|elsif\)\>'
|
||||
|
||||
" Regex that defines the end-match for the 'end' keyword.
|
||||
let s:end_end_regex = '\%(^\|[^.:@$]\)\@<=\<end\>'
|
||||
|
||||
" Expression used for searchpair() call for finding match for 'end' keyword.
|
||||
let s:end_skip_expr = s:skip_expr .
|
||||
\ ' || (expand("<cword>") == "do"' .
|
||||
\ ' && getline(".") =~ "^\\s*\\<\\(while\\|until\\|for\\)\\>")'
|
||||
|
||||
" Regex that defines continuation lines, not including (, {, or [.
|
||||
let s:continuation_regex = '\%([\\*+/.,:]\|\%(<%\)\@<![=-]\|\W[|&?]\|||\|&&\)\s*\%(#.*\)\=$'
|
||||
|
||||
" Regex that defines continuation lines.
|
||||
" TODO: this needs to deal with if ...: and so on
|
||||
let s:continuation_regex2 =
|
||||
\ '\%([\\*+/.,:({[]\|\%(<%\)\@<![=-]\|\W[|&?]\|||\|&&\)\s*\%(#.*\)\=$'
|
||||
|
||||
" Regex that defines blocks.
|
||||
let s:block_regex =
|
||||
\ '\%(\<do\>\|{\)\s*\%(|\%([*@]\=\h\w*,\=\s*\)\%(,\s*[*@]\=\h\w*\)*|\)\=\s*\%(#.*\)\=$'
|
||||
|
||||
" 2. Auxiliary Functions {{{1
|
||||
" ======================
|
||||
|
||||
" Check if the character at lnum:col is inside a string, comment, or is ascii.
|
||||
function s:IsInStringOrComment(lnum, col)
|
||||
return synIDattr(synID(a:lnum, a:col, 1), 'name') =~ s:syng_strcom
|
||||
endfunction
|
||||
|
||||
" Check if the character at lnum:col is inside a string.
|
||||
function s:IsInString(lnum, col)
|
||||
return synIDattr(synID(a:lnum, a:col, 1), 'name') =~ s:syng_string
|
||||
endfunction
|
||||
|
||||
" Check if the character at lnum:col is inside a string or documentation.
|
||||
function s:IsInStringOrDocumentation(lnum, col)
|
||||
return synIDattr(synID(a:lnum, a:col, 1), 'name') =~ s:syng_stringdoc
|
||||
endfunction
|
||||
|
||||
" Find line above 'lnum' that isn't empty, in a comment, or in a string.
|
||||
function s:PrevNonBlankNonString(lnum)
|
||||
let in_block = 0
|
||||
let lnum = prevnonblank(a:lnum)
|
||||
while lnum > 0
|
||||
" Go in and out of blocks comments as necessary.
|
||||
" If the line isn't empty (with opt. comment) or in a string, end search.
|
||||
let line = getline(lnum)
|
||||
if line =~ '^=begin$'
|
||||
if in_block
|
||||
let in_block = 0
|
||||
else
|
||||
break
|
||||
endif
|
||||
elseif !in_block && line =~ '^=end$'
|
||||
let in_block = 1
|
||||
elseif !in_block && line !~ '^\s*#.*$' && !(s:IsInStringOrComment(lnum, 1)
|
||||
\ && s:IsInStringOrComment(lnum, strlen(line)))
|
||||
break
|
||||
endif
|
||||
let lnum = prevnonblank(lnum - 1)
|
||||
endwhile
|
||||
return lnum
|
||||
endfunction
|
||||
|
||||
" Find line above 'lnum' that started the continuation 'lnum' may be part of.
|
||||
function s:GetMSL(lnum)
|
||||
" Start on the line we're at and use its indent.
|
||||
let msl = a:lnum
|
||||
let lnum = s:PrevNonBlankNonString(a:lnum - 1)
|
||||
while lnum > 0
|
||||
" If we have a continuation line, or we're in a string, use line as MSL.
|
||||
" Otherwise, terminate search as we have found our MSL already.
|
||||
let line = getline(lnum)
|
||||
let col = match(line, s:continuation_regex2) + 1
|
||||
if (col > 0 && !s:IsInStringOrComment(lnum, col))
|
||||
\ || s:IsInString(lnum, strlen(line))
|
||||
let msl = lnum
|
||||
else
|
||||
break
|
||||
endif
|
||||
let lnum = s:PrevNonBlankNonString(lnum - 1)
|
||||
endwhile
|
||||
return msl
|
||||
endfunction
|
||||
|
||||
" Check if line 'lnum' has more opening brackets than closing ones.
|
||||
function s:LineHasOpeningBrackets(lnum)
|
||||
let open_0 = 0
|
||||
let open_2 = 0
|
||||
let open_4 = 0
|
||||
let line = getline(a:lnum)
|
||||
let pos = match(line, '[][(){}]', 0)
|
||||
while pos != -1
|
||||
if !s:IsInStringOrComment(a:lnum, pos + 1)
|
||||
let idx = stridx('(){}[]', line[pos])
|
||||
if idx % 2 == 0
|
||||
let open_{idx} = open_{idx} + 1
|
||||
else
|
||||
let open_{idx - 1} = open_{idx - 1} - 1
|
||||
endif
|
||||
endif
|
||||
let pos = match(line, '[][(){}]', pos + 1)
|
||||
endwhile
|
||||
return (open_0 > 0) . (open_2 > 0) . (open_4 > 0)
|
||||
endfunction
|
||||
|
||||
function s:Match(lnum, regex)
|
||||
let col = match(getline(a:lnum), a:regex) + 1
|
||||
return col > 0 && !s:IsInStringOrComment(a:lnum, col) ? col : 0
|
||||
endfunction
|
||||
|
||||
function s:MatchLast(lnum, regex)
|
||||
let line = getline(a:lnum)
|
||||
let col = match(line, '.*\zs' . a:regex)
|
||||
while col != -1 && s:IsInStringOrComment(a:lnum, col)
|
||||
let line = strpart(line, 0, col)
|
||||
let col = match(line, '.*' . a:regex)
|
||||
endwhile
|
||||
return col + 1
|
||||
endfunction
|
||||
|
||||
" 3. GetRubyIndent Function {{{1
|
||||
" =========================
|
||||
|
||||
function GetRubyIndent()
|
||||
" 3.1. Setup {{{2
|
||||
" ----------
|
||||
|
||||
" Set up variables for restoring position in file. Could use v:lnum here.
|
||||
let vcol = col('.')
|
||||
|
||||
" 3.2. Work on the current line {{{2
|
||||
" -----------------------------
|
||||
|
||||
" Get the current line.
|
||||
let line = getline(v:lnum)
|
||||
let ind = -1
|
||||
|
||||
" If we got a closing bracket on an empty line, find its match and indent
|
||||
" according to it. For parentheses we indent to its column - 1, for the
|
||||
" others we indent to the containing line's MSL's level. Return -1 if fail.
|
||||
let col = matchend(line, '^\s*[]})]')
|
||||
if col > 0 && !s:IsInStringOrComment(v:lnum, col)
|
||||
call cursor(v:lnum, col)
|
||||
let bs = strpart('(){}[]', stridx(')}]', line[col - 1]) * 2, 2)
|
||||
if searchpair(escape(bs[0], '\['), '', bs[1], 'bW', s:skip_expr) > 0
|
||||
if line[col-1]==')' && col('.') != col('$') - 1
|
||||
let ind = virtcol('.')-1
|
||||
else
|
||||
let ind = indent(s:GetMSL(line('.')))
|
||||
endif
|
||||
endif
|
||||
return ind
|
||||
endif
|
||||
|
||||
" If we have a =begin or =end set indent to first column.
|
||||
if match(line, '^\s*\%(=begin\|=end\)$') != -1
|
||||
return 0
|
||||
endif
|
||||
|
||||
" If we have a deindenting keyword, find its match and indent to its level.
|
||||
" TODO: this is messy
|
||||
if s:Match(v:lnum, s:ruby_deindent_keywords)
|
||||
call cursor(v:lnum, 1)
|
||||
if searchpair(s:end_start_regex, s:end_middle_regex, s:end_end_regex, 'bW',
|
||||
\ s:end_skip_expr) > 0
|
||||
let line = getline('.')
|
||||
if strpart(line, 0, col('.') - 1) =~ '=\s*$' &&
|
||||
\ strpart(line, col('.') - 1, 2) !~ 'do'
|
||||
let ind = virtcol('.') - 1
|
||||
else
|
||||
let ind = indent('.')
|
||||
endif
|
||||
endif
|
||||
return ind
|
||||
endif
|
||||
|
||||
" If we are in a multi-line string or line-comment, don't do anything to it.
|
||||
if s:IsInStringOrDocumentation(v:lnum, matchend(line, '^\s*') + 1)
|
||||
return indent('.')
|
||||
endif
|
||||
|
||||
" 3.3. Work on the previous line. {{{2
|
||||
" -------------------------------
|
||||
|
||||
" Find a non-blank, non-multi-line string line above the current line.
|
||||
let lnum = s:PrevNonBlankNonString(v:lnum - 1)
|
||||
|
||||
" If the line is empty and inside a string, use the previous line.
|
||||
if line =~ '^\s*$' && lnum != prevnonblank(v:lnum - 1)
|
||||
return indent(prevnonblank(v:lnum))
|
||||
endif
|
||||
|
||||
" At the start of the file use zero indent.
|
||||
if lnum == 0
|
||||
return 0
|
||||
endif
|
||||
|
||||
" Set up variables for current line.
|
||||
let line = getline(lnum)
|
||||
let ind = indent(lnum)
|
||||
|
||||
" If the previous line ended with a block opening, add a level of indent.
|
||||
if s:Match(lnum, s:block_regex)
|
||||
return indent(s:GetMSL(lnum)) + &sw
|
||||
endif
|
||||
|
||||
" If the previous line contained an opening bracket, and we are still in it,
|
||||
" add indent depending on the bracket type.
|
||||
if line =~ '[[({]'
|
||||
let counts = s:LineHasOpeningBrackets(lnum)
|
||||
if counts[0] == '1' && searchpair('(', '', ')', 'bW', s:skip_expr) > 0
|
||||
if col('.') + 1 == col('$')
|
||||
return ind + &sw
|
||||
else
|
||||
return virtcol('.')
|
||||
endif
|
||||
elseif counts[1] == '1' || counts[2] == '1'
|
||||
return ind + &sw
|
||||
else
|
||||
call cursor(v:lnum, vcol)
|
||||
end
|
||||
endif
|
||||
|
||||
" If the previous line ended with an "end", match that "end"s beginning's
|
||||
" indent.
|
||||
let col = s:Match(lnum, '\%(^\|[^.:@$]\)\<end\>\s*\%(#.*\)\=$')
|
||||
if col > 0
|
||||
call cursor(lnum, col)
|
||||
if searchpair(s:end_start_regex, '', s:end_end_regex, 'bW',
|
||||
\ s:end_skip_expr) > 0
|
||||
let n = line('.')
|
||||
let ind = indent('.')
|
||||
let msl = s:GetMSL(n)
|
||||
if msl != n
|
||||
let ind = indent(msl)
|
||||
end
|
||||
return ind
|
||||
endif
|
||||
end
|
||||
|
||||
let col = s:Match(lnum, s:ruby_indent_keywords)
|
||||
if col > 0
|
||||
call cursor(lnum, col)
|
||||
let ind = virtcol('.') - 1 + &sw
|
||||
" let ind = indent(lnum) + &sw
|
||||
" TODO: make this better (we need to count them) (or, if a searchpair
|
||||
" fails, we know that something is lacking an end and thus we indent a
|
||||
" level
|
||||
if s:Match(lnum, s:end_end_regex)
|
||||
let ind = indent('.')
|
||||
endif
|
||||
return ind
|
||||
endif
|
||||
|
||||
" 3.4. Work on the MSL line. {{{2
|
||||
" --------------------------
|
||||
|
||||
" Set up variables to use and search for MSL to the previous line.
|
||||
let p_lnum = lnum
|
||||
let lnum = s:GetMSL(lnum)
|
||||
|
||||
" If the previous line wasn't a MSL and is continuation return its indent.
|
||||
" TODO: the || s:IsInString() thing worries me a bit.
|
||||
if p_lnum != lnum
|
||||
if s:Match(p_lnum,s:continuation_regex)||s:IsInString(p_lnum,strlen(line))
|
||||
return ind
|
||||
endif
|
||||
endif
|
||||
|
||||
" Set up more variables, now that we know we wasn't continuation bound.
|
||||
let line = getline(lnum)
|
||||
let msl_ind = indent(lnum)
|
||||
|
||||
" If the MSL line had an indenting keyword in it, add a level of indent.
|
||||
" TODO: this does not take into account contrived things such as
|
||||
" module Foo; class Bar; end
|
||||
if s:Match(lnum, s:ruby_indent_keywords)
|
||||
let ind = msl_ind + &sw
|
||||
if s:Match(lnum, s:end_end_regex)
|
||||
let ind = ind - &sw
|
||||
endif
|
||||
return ind
|
||||
endif
|
||||
|
||||
" If the previous line ended with [*+/.-=], indent one extra level.
|
||||
if s:Match(lnum, s:continuation_regex)
|
||||
if lnum == p_lnum
|
||||
let ind = msl_ind + &sw
|
||||
else
|
||||
let ind = msl_ind
|
||||
endif
|
||||
endif
|
||||
|
||||
" }}}2
|
||||
|
||||
return ind
|
||||
endfunction
|
||||
|
||||
" }}}1
|
||||
|
||||
let &cpo = s:cpo_save
|
||||
unlet s:cpo_save
|
||||
|
||||
" vim:set sw=2 sts=2 ts=8 noet:
|
||||
39
vim/bundle/ubuntu-vim72/indent/sass.vim
Normal file
39
vim/bundle/ubuntu-vim72/indent/sass.vim
Normal file
@@ -0,0 +1,39 @@
|
||||
" Vim indent file
|
||||
" Language: SASS
|
||||
" Maintainer: Tim Pope <vimNOSPAM@tpope.info>
|
||||
" Last Change: 2007 Dec 16
|
||||
|
||||
if exists("b:did_indent")
|
||||
finish
|
||||
endif
|
||||
let b:did_indent = 1
|
||||
|
||||
setlocal autoindent sw=2 et
|
||||
setlocal indentexpr=GetSassIndent()
|
||||
setlocal indentkeys=o,O,*<Return>,<:>,!^F
|
||||
|
||||
" Only define the function once.
|
||||
if exists("*GetSassIndent")
|
||||
finish
|
||||
endif
|
||||
|
||||
let s:property = '^\s*:\|^\s*[[:alnum:]-]\+:'
|
||||
|
||||
function! GetSassIndent()
|
||||
let lnum = prevnonblank(v:lnum-1)
|
||||
let line = substitute(getline(lnum),'\s\+$','','')
|
||||
let cline = substitute(substitute(getline(v:lnum),'\s\+$','',''),'^\s\+','','')
|
||||
let lastcol = strlen(line)
|
||||
let line = substitute(line,'^\s\+','','')
|
||||
let indent = indent(lnum)
|
||||
let cindent = indent(v:lnum)
|
||||
if line !~ s:property && cline =~ s:property
|
||||
return indent + &sw
|
||||
"elseif line =~ s:property && cline !~ s:property
|
||||
"return indent - &sw
|
||||
else
|
||||
return -1
|
||||
endif
|
||||
endfunction
|
||||
|
||||
" vim:set sw=2:
|
||||
11
vim/bundle/ubuntu-vim72/indent/scheme.vim
Normal file
11
vim/bundle/ubuntu-vim72/indent/scheme.vim
Normal file
@@ -0,0 +1,11 @@
|
||||
" Vim indent file
|
||||
" Language: Scheme
|
||||
" Maintainer: Sergey Khorev <sergey.khorev@gmail.com>
|
||||
" Last Change: 2005 Jun 24
|
||||
|
||||
" Only load this indent file when no other was loaded.
|
||||
if exists("b:did_indent")
|
||||
finish
|
||||
endif
|
||||
|
||||
runtime! indent/lisp.vim
|
||||
89
vim/bundle/ubuntu-vim72/indent/sdl.vim
Normal file
89
vim/bundle/ubuntu-vim72/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
|
||||
158
vim/bundle/ubuntu-vim72/indent/sh.vim
Normal file
158
vim/bundle/ubuntu-vim72/indent/sh.vim
Normal file
@@ -0,0 +1,158 @@
|
||||
" Vim indent file
|
||||
" Language: Shell Script
|
||||
" Maintainer: Nikolai Weibull <now@bitwi.se>
|
||||
" Latest Revision: 2010-01-06
|
||||
|
||||
if exists("b:did_indent")
|
||||
finish
|
||||
endif
|
||||
let b:did_indent = 1
|
||||
|
||||
setlocal indentexpr=GetShIndent()
|
||||
setlocal indentkeys+=0=then,0=do,0=else,0=elif,0=fi,0=esac,0=done,),0=;;,0=;&
|
||||
setlocal indentkeys+=0=fin,0=fil,0=fip,0=fir,0=fix
|
||||
setlocal indentkeys-=:,0#
|
||||
setlocal nosmartindent
|
||||
|
||||
if exists("*GetShIndent")
|
||||
finish
|
||||
endif
|
||||
|
||||
let s:cpo_save = &cpo
|
||||
set cpo&vim
|
||||
|
||||
function s:buffer_shiftwidth()
|
||||
return &shiftwidth
|
||||
endfunction
|
||||
|
||||
let s:sh_indent_defaults = {
|
||||
\ 'default': function('s:buffer_shiftwidth'),
|
||||
\ 'continuation-line': function('s:buffer_shiftwidth'),
|
||||
\ 'case-labels': function('s:buffer_shiftwidth'),
|
||||
\ 'case-statements': function('s:buffer_shiftwidth'),
|
||||
\ 'case-breaks': 0 }
|
||||
|
||||
function! s:indent_value(option)
|
||||
let Value = exists('b:sh_indent_options')
|
||||
\ && has_key(b:sh_indent_options, a:option) ?
|
||||
\ b:sh_indent_options[a:option] :
|
||||
\ s:sh_indent_defaults[a:option]
|
||||
if type(Value) == type(function('type'))
|
||||
return Value()
|
||||
endif
|
||||
return Value
|
||||
endfunction
|
||||
|
||||
function! GetShIndent()
|
||||
let lnum = prevnonblank(v:lnum - 1)
|
||||
if lnum == 0
|
||||
return 0
|
||||
endif
|
||||
|
||||
let pnum = prevnonblank(lnum - 1)
|
||||
|
||||
let ind = indent(lnum)
|
||||
let line = getline(lnum)
|
||||
if line =~ '^\s*\%(if\|then\|do\|else\|elif\|case\|while\|until\|for\|select\)\>'
|
||||
if line !~ '\<\%(fi\|esac\|done\)\>\s*\%(#.*\)\=$'
|
||||
let ind += s:indent_value('default')
|
||||
endif
|
||||
elseif s:is_case_label(line, pnum)
|
||||
if !s:is_case_ended(line)
|
||||
let ind += s:indent_value('case-statements')
|
||||
endif
|
||||
elseif line =~ '^\s*\<\k\+\>\s*()\s*{' || line =~ '^\s*{'
|
||||
if line !~ '}\s*\%(#.*\)\=$'
|
||||
let ind += s:indent_value('default')
|
||||
endif
|
||||
elseif s:is_continuation_line(line)
|
||||
if pnum == 0 || !s:is_continuation_line(getline(pnum))
|
||||
let ind += s:indent_value('continuation-line')
|
||||
endif
|
||||
elseif pnum != 0 && s:is_continuation_line(getline(pnum))
|
||||
let ind = indent(s:find_continued_lnum(pnum))
|
||||
endif
|
||||
|
||||
let pine = line
|
||||
let line = getline(v:lnum)
|
||||
if line =~ '^\s*\%(then\|do\|else\|elif\|fi\|done\)\>' || line =~ '^\s*}'
|
||||
let ind -= s:indent_value('default')
|
||||
elseif line =~ '^\s*esac\>'
|
||||
let ind -= (s:is_case_label(pine, lnum) && s:is_case_ended(pine) ?
|
||||
\ 0 : s:indent_value('case-statements')) +
|
||||
\ s:indent_value('case-labels')
|
||||
if s:is_case_break(pine)
|
||||
let ind += s:indent_value('case-breaks')
|
||||
endif
|
||||
elseif s:is_case_label(line, lnum)
|
||||
if s:is_case(pine)
|
||||
let ind = indent(lnum) + s:indent_value('case-labels')
|
||||
else
|
||||
let ind -= s:indent_value('case-statements') - s:indent_value('case-breaks')
|
||||
endif
|
||||
elseif s:is_case_break(line)
|
||||
let ind -= s:indent_value('case-breaks')
|
||||
endif
|
||||
|
||||
return ind
|
||||
endfunction
|
||||
|
||||
function! s:is_continuation_line(line)
|
||||
return a:line =~ '\%(\%(^\|[^\\]\)\\\|&&\|||\)$'
|
||||
endfunction
|
||||
|
||||
function! s:find_continued_lnum(lnum)
|
||||
let i = a:lnum
|
||||
while i > 1 && s:is_continuation_line(getline(i - 1))
|
||||
let i -= 1
|
||||
endwhile
|
||||
return i
|
||||
endfunction
|
||||
|
||||
function! s:is_case_label(line, pnum)
|
||||
if a:line !~ '^\s*(\=.*)'
|
||||
return 0
|
||||
endif
|
||||
|
||||
if a:pnum > 0
|
||||
let pine = getline(a:pnum)
|
||||
if !(s:is_case(pine) || s:is_case_ended(pine))
|
||||
return 0
|
||||
endif
|
||||
endif
|
||||
|
||||
let suffix = substitute(a:line, '^\s*(\=', "", "")
|
||||
let nesting = 0
|
||||
let i = 0
|
||||
let n = strlen(suffix)
|
||||
while i < n
|
||||
let c = suffix[i]
|
||||
let i += 1
|
||||
if c == '\\'
|
||||
let i += 1
|
||||
elseif c == '('
|
||||
let nesting += 1
|
||||
elseif c == ')'
|
||||
if nesting == 0
|
||||
return 1
|
||||
endif
|
||||
let nesting -= 1
|
||||
endif
|
||||
endwhile
|
||||
return 0
|
||||
endfunction
|
||||
|
||||
function! s:is_case(line)
|
||||
return a:line =~ '^\s*case\>'
|
||||
endfunction
|
||||
|
||||
function! s:is_case_break(line)
|
||||
return a:line =~ '^\s*;[;&]'
|
||||
endfunction
|
||||
|
||||
function! s:is_case_ended(line)
|
||||
return s:is_case_break(a:line) || a:line =~ ';[;&]\s*\%(#.*\)\=$'
|
||||
endfunction
|
||||
|
||||
let &cpo = s:cpo_save
|
||||
unlet s:cpo_save
|
||||
217
vim/bundle/ubuntu-vim72/indent/sml.vim
Normal file
217
vim/bundle/ubuntu-vim72/indent/sml.vim
Normal file
@@ -0,0 +1,217 @@
|
||||
" Vim indent file
|
||||
" Language: SML
|
||||
" Maintainer: Saikat Guha <sg266@cornell.edu>
|
||||
" Hubert Chao <hc85@cornell.edu>
|
||||
" Original OCaml Version:
|
||||
" Jean-Francois Yuen <jfyuen@ifrance.com>
|
||||
" Mike Leary <leary@nwlink.com>
|
||||
" Markus Mottl <markus@oefai.at>
|
||||
" OCaml URL: http://www.oefai.at/~markus/vim/indent/ocaml.vim
|
||||
" Last Change: 2003 Jan 04 - Adapted to SML
|
||||
" 2002 Nov 06 - Some fixes (JY)
|
||||
" 2002 Oct 28 - Fixed bug with indentation of ']' (MM)
|
||||
" 2002 Oct 22 - Major rewrite (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=GetSMLIndent()
|
||||
setlocal indentkeys+=0=and,0=else,0=end,0=handle,0=if,0=in,0=let,0=then,0=val,0=fun,0=\|,0=*),0)
|
||||
setlocal nolisp
|
||||
setlocal nosmartindent
|
||||
setlocal textwidth=80
|
||||
setlocal shiftwidth=2
|
||||
|
||||
" Comment formatting
|
||||
if (has("comments"))
|
||||
set comments=sr:(*,mb:*,ex:*)
|
||||
set fo=cqort
|
||||
endif
|
||||
|
||||
" Only define the function once.
|
||||
"if exists("*GetSMLIndent")
|
||||
"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 = '\<\%(let\|sig\|struct\)\>'
|
||||
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"'))
|
||||
let lno = searchpair(a:pstart, a:pmid, a:pend, 'bW', 'synIDattr(synID(line("."), col("."), 0), "name") =~? "string\\|comment"')
|
||||
if lno == -1
|
||||
return indent(lno)
|
||||
else
|
||||
return col(".") - 1
|
||||
endif
|
||||
endfunction
|
||||
|
||||
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"'))
|
||||
let lno = searchpair(a:pstart, a:pmid, a:pend, 'bW', 'synIDattr(synID(line("."), col("."), 0), "name") =~? "string\\|comment"')
|
||||
let moduleLine = getline(lno)
|
||||
if lno == -1 || moduleLine =~ '^\s*\(fun\|structure\|signature\)\>'
|
||||
return indent(lno)
|
||||
else
|
||||
return col(".") - 1
|
||||
endif
|
||||
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! GetSMLIndent()
|
||||
" 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
|
||||
elseif lline =~ '^\s*val\>.*=\s*$'
|
||||
return ind + &sw
|
||||
endif
|
||||
|
||||
let line = getline(v:lnum)
|
||||
|
||||
" Indent lines starting with 'end' to matching module
|
||||
if line =~ '^\s*end\>'
|
||||
return s:FindLet(s:module, '', '\<end\>')
|
||||
|
||||
" Match 'else' with 'if'
|
||||
elseif line =~ '^\s*else\>'
|
||||
if lline !~ '^\s*\(if\|else\|then\)\>'
|
||||
return s:FindPair('\<if\>', '', '\<then\>')
|
||||
else
|
||||
return ind
|
||||
endif
|
||||
|
||||
" Match 'then' with 'if'
|
||||
elseif line =~ '^\s*then\>'
|
||||
if lline !~ '^\s*\(if\|else\|then\)\>'
|
||||
return s:FindPair('\<if\>', '', '\<then\>')
|
||||
else
|
||||
return ind
|
||||
endif
|
||||
|
||||
" Indent if current line begins with ']'
|
||||
elseif line =~ '^\s*\]'
|
||||
return s:FindPair('\[','','\]')
|
||||
|
||||
" Indent current line starting with 'in' to last matching 'let'
|
||||
elseif line =~ '^\s*in\>'
|
||||
let ind = s:FindLet('\<let\>','','\<in\>')
|
||||
|
||||
" Indent from last matching module if line matches:
|
||||
elseif line =~ '^\s*\(fun\|val\|open\|structure\|and\|datatype\|type\|exception\)\>'
|
||||
cursor(lnum,1)
|
||||
let lastModule = indent(searchpair(s:module, '', '\<end\>', 'bWn', 'synIDattr(synID(line("."), col("."), 0), "name") =~? "string\\|comment"'))
|
||||
if lastModule == -1
|
||||
return 0
|
||||
else
|
||||
return lastModule + &sw
|
||||
endif
|
||||
|
||||
" Indent lines starting with '|' from matching 'case', 'handle'
|
||||
elseif line =~ '^\s*|'
|
||||
" cursor(lnum,1)
|
||||
let lastSwitch = search('\<\(case\|handle\|fun\|datatype\)\>','bW')
|
||||
let switchLine = getline(lastSwitch)
|
||||
let switchLineIndent = indent(lastSwitch)
|
||||
if lline =~ '^\s*|'
|
||||
return ind
|
||||
endif
|
||||
if switchLine =~ '\<case\>'
|
||||
return col(".") + 2
|
||||
elseif switchLine =~ '\<handle\>'
|
||||
return switchLineIndent + &sw
|
||||
elseif switchLine =~ '\<datatype\>'
|
||||
call search('=')
|
||||
return col(".") - 1
|
||||
else
|
||||
return switchLineIndent + 2
|
||||
endif
|
||||
|
||||
|
||||
" Indent if last line ends with 'sig', 'struct', 'let', 'then', 'else',
|
||||
" 'in'
|
||||
elseif lline =~ '\<\(sig\|struct\|let\|in\|then\|else\)\s*$'
|
||||
let ind = ind + &sw
|
||||
|
||||
" Indent if last line ends with 'of', align from 'case'
|
||||
elseif lline =~ '\<\(of\)\s*$'
|
||||
call search('\<case\>',"bW")
|
||||
let ind = col(".")+4
|
||||
|
||||
" Indent if current line starts with 'of'
|
||||
elseif line =~ '^\s*of\>'
|
||||
call search('\<case\>',"bW")
|
||||
let ind = col(".")+1
|
||||
|
||||
|
||||
" Indent if last line starts with 'fun', 'case', 'fn'
|
||||
elseif lline =~ '^\s*\(fun\|fn\|case\)\>'
|
||||
let ind = ind + &sw
|
||||
|
||||
endif
|
||||
|
||||
" Don't indent 'let' if last line started with 'fun', 'fn'
|
||||
if line =~ '^\s*let\>'
|
||||
if lline =~ '^\s*\(fun\|fn\)'
|
||||
let ind = ind - &sw
|
||||
endif
|
||||
endif
|
||||
|
||||
return ind
|
||||
|
||||
endfunction
|
||||
|
||||
" vim:sw=2
|
||||
39
vim/bundle/ubuntu-vim72/indent/sql.vim
Normal file
39
vim/bundle/ubuntu-vim72/indent/sql.vim
Normal file
@@ -0,0 +1,39 @@
|
||||
" Vim indent file loader
|
||||
" Language: SQL
|
||||
" Maintainer: David Fishburn <fishburn at ianywhere dot com>
|
||||
" Last Change: Thu Sep 15 2005 10:27:51 AM
|
||||
" Version: 1.0
|
||||
" Download: http://vim.sourceforge.net/script.php?script_id=495
|
||||
|
||||
" Description: Checks for a:
|
||||
" buffer local variable,
|
||||
" global variable,
|
||||
" If the above exist, it will source the type specified.
|
||||
" If none exist, it will source the default sqlanywhere.vim file.
|
||||
|
||||
|
||||
" Only load this indent file when no other was loaded.
|
||||
if exists("b:did_indent")
|
||||
finish
|
||||
endif
|
||||
|
||||
" Default to the standard Vim distribution file
|
||||
let filename = 'sqlanywhere'
|
||||
|
||||
" Check for overrides. Buffer variables have the highest priority.
|
||||
if exists("b:sql_type_override")
|
||||
" Check the runtimepath to see if the file exists
|
||||
if globpath(&runtimepath, 'indent/'.b:sql_type_override.'.vim') != ''
|
||||
let filename = b:sql_type_override
|
||||
endif
|
||||
elseif exists("g:sql_type_default")
|
||||
if globpath(&runtimepath, 'indent/'.g:sql_type_default.'.vim') != ''
|
||||
let filename = g:sql_type_default
|
||||
endif
|
||||
endif
|
||||
|
||||
" Source the appropriate file
|
||||
exec 'runtime indent/'.filename.'.vim'
|
||||
|
||||
|
||||
" vim:sw=4:
|
||||
385
vim/bundle/ubuntu-vim72/indent/sqlanywhere.vim
Normal file
385
vim/bundle/ubuntu-vim72/indent/sqlanywhere.vim
Normal file
@@ -0,0 +1,385 @@
|
||||
" Vim indent file
|
||||
" Language: SQL
|
||||
" Maintainer: David Fishburn <fishburn at ianywhere dot com>
|
||||
" Last Change: Mon Apr 02 2007 9:13:47 AM
|
||||
" Version: 1.5
|
||||
" Download: http://vim.sourceforge.net/script.php?script_id=495
|
||||
|
||||
" Notes:
|
||||
" Indenting keywords are based on Oracle and Sybase Adaptive Server
|
||||
" Anywhere (ASA). Test indenting was done with ASA stored procedures and
|
||||
" fuctions and Oracle packages which contain stored procedures and
|
||||
" functions.
|
||||
" This has not been tested against Microsoft SQL Server or
|
||||
" Sybase Adaptive Server Enterprise (ASE) which use the Transact-SQL
|
||||
" syntax. That syntax does not have end tags for IF's, which makes
|
||||
" indenting more difficult.
|
||||
"
|
||||
" Known Issues:
|
||||
" The Oracle MERGE statement does not have an end tag associated with
|
||||
" it, this can leave the indent hanging to the right one too many.
|
||||
|
||||
" Only load this indent file when no other was loaded.
|
||||
if exists("b:did_indent")
|
||||
finish
|
||||
endif
|
||||
let b:did_indent = 1
|
||||
let b:current_indent = "sqlanywhere"
|
||||
|
||||
setlocal indentkeys-=0{
|
||||
setlocal indentkeys-=0}
|
||||
setlocal indentkeys-=:
|
||||
setlocal indentkeys-=0#
|
||||
setlocal indentkeys-=e
|
||||
|
||||
" This indicates formatting should take place when one of these
|
||||
" expressions is used. These expressions would normally be something
|
||||
" you would type at the BEGINNING of a line
|
||||
" SQL is generally case insensitive, so this files assumes that
|
||||
" These keywords are something that would trigger an indent LEFT, not
|
||||
" an indent right, since the SQLBlockStart is used for those keywords
|
||||
setlocal indentkeys+==~end,=~else,=~elseif,=~elsif,0=~when,0=)
|
||||
|
||||
" GetSQLIndent is executed whenever one of the expressions
|
||||
" in the indentkeys is typed
|
||||
setlocal indentexpr=GetSQLIndent()
|
||||
|
||||
" Only define the functions once.
|
||||
if exists("*GetSQLIndent")
|
||||
finish
|
||||
endif
|
||||
|
||||
" List of all the statements that start a new block.
|
||||
" These are typically words that start a line.
|
||||
" IS is excluded, since it is difficult to determine when the
|
||||
" ending block is (especially for procedures/functions).
|
||||
let s:SQLBlockStart = '^\s*\%('.
|
||||
\ 'if\|else\|elseif\|elsif\|'.
|
||||
\ 'while\|loop\|do\|'.
|
||||
\ 'begin\|'.
|
||||
\ 'case\|when\|merge\|exception'.
|
||||
\ '\)\>'
|
||||
let s:SQLBlockEnd = '^\s*\(end\)\>'
|
||||
|
||||
" The indent level is also based on unmatched paranethesis
|
||||
" If a line has an extra "(" increase the indent
|
||||
" If a line has an extra ")" decrease the indent
|
||||
function s:CountUnbalancedParan( line, paran_to_check )
|
||||
let l = a:line
|
||||
let lp = substitute(l, '[^(]', '', 'g')
|
||||
let l = a:line
|
||||
let rp = substitute(l, '[^)]', '', 'g')
|
||||
|
||||
if a:paran_to_check =~ ')'
|
||||
" echom 'CountUnbalancedParan ) returning: ' .
|
||||
" \ (strlen(rp) - strlen(lp))
|
||||
return (strlen(rp) - strlen(lp))
|
||||
elseif a:paran_to_check =~ '('
|
||||
" echom 'CountUnbalancedParan ( returning: ' .
|
||||
" \ (strlen(lp) - strlen(rp))
|
||||
return (strlen(lp) - strlen(rp))
|
||||
else
|
||||
" echom 'CountUnbalancedParan unknown paran to check: ' .
|
||||
" \ a:paran_to_check
|
||||
return 0
|
||||
endif
|
||||
endfunction
|
||||
|
||||
" Unindent commands based on previous indent level
|
||||
function s:CheckToIgnoreRightParan( prev_lnum, num_levels )
|
||||
let lnum = a:prev_lnum
|
||||
let line = getline(lnum)
|
||||
let ends = 0
|
||||
let num_right_paran = a:num_levels
|
||||
let ignore_paran = 0
|
||||
let vircol = 1
|
||||
|
||||
while num_right_paran > 0
|
||||
silent! exec 'norm! '.lnum."G\<bar>".vircol."\<bar>"
|
||||
let right_paran = search( ')', 'W' )
|
||||
if right_paran != lnum
|
||||
" This should not happen since there should be at least
|
||||
" num_right_paran matches for this line
|
||||
break
|
||||
endif
|
||||
let vircol = virtcol(".")
|
||||
|
||||
" if getline(".") =~ '^)'
|
||||
let matching_paran = searchpair('(', '', ')', 'bW',
|
||||
\ 's:IsColComment(line("."), col("."))')
|
||||
|
||||
if matching_paran < 1
|
||||
" No match found
|
||||
" echom 'CTIRP - no match found, ignoring'
|
||||
break
|
||||
endif
|
||||
|
||||
if matching_paran == lnum
|
||||
" This was not an unmatched parantenses, start the search again
|
||||
" again after this column
|
||||
" echom 'CTIRP - same line match, ignoring'
|
||||
continue
|
||||
endif
|
||||
|
||||
" echom 'CTIRP - match: ' . line(".") . ' ' . getline(".")
|
||||
|
||||
if getline(matching_paran) =~? '\(if\|while\)\>'
|
||||
" echom 'CTIRP - if/while ignored: ' . line(".") . ' ' . getline(".")
|
||||
let ignore_paran = ignore_paran + 1
|
||||
endif
|
||||
|
||||
" One match found, decrease and check for further matches
|
||||
let num_right_paran = num_right_paran - 1
|
||||
|
||||
endwhile
|
||||
|
||||
" Fallback - just move back one
|
||||
" return a:prev_indent - &sw
|
||||
return ignore_paran
|
||||
endfunction
|
||||
|
||||
" Based on the keyword provided, loop through previous non empty
|
||||
" non comment lines to find the statement that initated the keyword.
|
||||
" Return its indent level
|
||||
" CASE ..
|
||||
" WHEN ...
|
||||
" Should return indent level of CASE
|
||||
" EXCEPTION ..
|
||||
" WHEN ...
|
||||
" something;
|
||||
" WHEN ...
|
||||
" Should return indent level of exception.
|
||||
function s:GetStmtStarterIndent( keyword, curr_lnum )
|
||||
let lnum = a:curr_lnum
|
||||
|
||||
" Default - reduce indent by 1
|
||||
let ind = indent(a:curr_lnum) - &sw
|
||||
|
||||
if a:keyword =~? 'end'
|
||||
exec 'normal! ^'
|
||||
let stmts = '^\s*\%('.
|
||||
\ '\<begin\>\|' .
|
||||
\ '\%(\%(\<end\s\+\)\@<!\<loop\>\)\|' .
|
||||
\ '\%(\%(\<end\s\+\)\@<!\<case\>\)\|' .
|
||||
\ '\%(\%(\<end\s\+\)\@<!\<for\>\)\|' .
|
||||
\ '\%(\%(\<end\s\+\)\@<!\<if\>\)'.
|
||||
\ '\)'
|
||||
let matching_lnum = searchpair(stmts, '', '\<end\>\zs', 'bW',
|
||||
\ 's:IsColComment(line("."), col(".")) == 1')
|
||||
exec 'normal! $'
|
||||
if matching_lnum > 0 && matching_lnum < a:curr_lnum
|
||||
let ind = indent(matching_lnum)
|
||||
endif
|
||||
elseif a:keyword =~? 'when'
|
||||
exec 'normal! ^'
|
||||
let matching_lnum = searchpair(
|
||||
\ '\%(\<end\s\+\)\@<!\<case\>\|\<exception\>\|\<merge\>',
|
||||
\ '',
|
||||
\ '\%(\%(\<when\s\+others\>\)\|\%(\<end\s\+case\>\)\)',
|
||||
\ 'bW',
|
||||
\ 's:IsColComment(line("."), col(".")) == 1')
|
||||
exec 'normal! $'
|
||||
if matching_lnum > 0 && matching_lnum < a:curr_lnum
|
||||
let ind = indent(matching_lnum)
|
||||
else
|
||||
let ind = indent(a:curr_lnum)
|
||||
endif
|
||||
endif
|
||||
|
||||
return ind
|
||||
endfunction
|
||||
|
||||
|
||||
" Check if the line is a comment
|
||||
function s:IsLineComment(lnum)
|
||||
let rc = synIDattr(
|
||||
\ synID(a:lnum,
|
||||
\ match(getline(a:lnum), '\S')+1, 0)
|
||||
\ , "name")
|
||||
\ =~? "comment"
|
||||
|
||||
return rc
|
||||
endfunction
|
||||
|
||||
|
||||
" Check if the column is a comment
|
||||
function s:IsColComment(lnum, cnum)
|
||||
let rc = synIDattr(synID(a:lnum, a:cnum, 0), "name")
|
||||
\ =~? "comment"
|
||||
|
||||
return rc
|
||||
endfunction
|
||||
|
||||
|
||||
" Instead of returning a column position, return
|
||||
" an appropriate value as a factor of shiftwidth.
|
||||
function s:ModuloIndent(ind)
|
||||
let ind = a:ind
|
||||
|
||||
if ind > 0
|
||||
let modulo = ind % &shiftwidth
|
||||
|
||||
if modulo > 0
|
||||
let ind = ind - modulo
|
||||
endif
|
||||
endif
|
||||
|
||||
return ind
|
||||
endfunction
|
||||
|
||||
|
||||
" Find correct indent of a new line based upon the previous line
|
||||
function GetSQLIndent()
|
||||
let lnum = v:lnum
|
||||
let ind = indent(lnum)
|
||||
|
||||
" If the current line is a comment, leave the indent as is
|
||||
" Comment out this additional check since it affects the
|
||||
" indenting of =, and will not reindent comments as it should
|
||||
" if s:IsLineComment(lnum) == 1
|
||||
" return ind
|
||||
" endif
|
||||
|
||||
" while 1
|
||||
" Get previous non-blank line
|
||||
let prevlnum = prevnonblank(lnum - 1)
|
||||
if prevlnum <= 0
|
||||
return ind
|
||||
endif
|
||||
|
||||
if s:IsLineComment(prevlnum) == 1
|
||||
if getline(v:lnum) =~ '^\s*\*'
|
||||
let ind = s:ModuloIndent(indent(prevlnum))
|
||||
return ind + 1
|
||||
endif
|
||||
" If the previous line is a comment, then return -1
|
||||
" to tell Vim to use the formatoptions setting to determine
|
||||
" the indent to use
|
||||
" But only if the next line is blank. This would be true if
|
||||
" the user is typing, but it would not be true if the user
|
||||
" is reindenting the file
|
||||
if getline(v:lnum) =~ '^\s*$'
|
||||
return -1
|
||||
endif
|
||||
endif
|
||||
|
||||
" let prevline = getline(prevlnum)
|
||||
" if prevline !~ '^\s*$'
|
||||
" " echom 'previous non blank - break: ' . prevline
|
||||
" break
|
||||
" endif
|
||||
" endwhile
|
||||
|
||||
" echom 'PREVIOUS INDENT: ' . indent(prevlnum) . ' LINE: ' . getline(prevlnum)
|
||||
|
||||
" This is the line you just hit return on, it is not the current line
|
||||
" which is new and empty
|
||||
" Based on this line, we can determine how much to indent the new
|
||||
" line
|
||||
|
||||
" Get default indent (from prev. line)
|
||||
let ind = indent(prevlnum)
|
||||
let prevline = getline(prevlnum)
|
||||
|
||||
" Now check what's on the previous line to determine if the indent
|
||||
" should be changed, for example IF, BEGIN, should increase the indent
|
||||
" where END IF, END, should decrease the indent.
|
||||
if prevline =~? s:SQLBlockStart
|
||||
" Move indent in
|
||||
let ind = ind + &sw
|
||||
" echom 'prevl - SQLBlockStart - indent ' . ind . ' line: ' . prevline
|
||||
elseif prevline =~ '[()]'
|
||||
if prevline =~ '('
|
||||
let num_unmatched_left = s:CountUnbalancedParan( prevline, '(' )
|
||||
else
|
||||
let num_unmatched_left = 0
|
||||
endif
|
||||
if prevline =~ ')'
|
||||
let num_unmatched_right = s:CountUnbalancedParan( prevline, ')' )
|
||||
else
|
||||
let num_unmatched_right = 0
|
||||
" let num_unmatched_right = s:CountUnbalancedParan( prevline, ')' )
|
||||
endif
|
||||
if num_unmatched_left > 0
|
||||
" There is a open left paranethesis
|
||||
" increase indent
|
||||
let ind = ind + ( &sw * num_unmatched_left )
|
||||
elseif num_unmatched_right > 0
|
||||
" if it is an unbalanced paranethesis only unindent if
|
||||
" it was part of a command (ie create table(..) )
|
||||
" instead of part of an if (ie if (....) then) which should
|
||||
" maintain the indent level
|
||||
let ignore = s:CheckToIgnoreRightParan( prevlnum, num_unmatched_right )
|
||||
" echom 'prevl - ) unbalanced - CTIRP - ignore: ' . ignore
|
||||
|
||||
if prevline =~ '^\s*)'
|
||||
let ignore = ignore + 1
|
||||
" echom 'prevl - begins ) unbalanced ignore: ' . ignore
|
||||
endif
|
||||
|
||||
if (num_unmatched_right - ignore) > 0
|
||||
let ind = ind - ( &sw * (num_unmatched_right - ignore) )
|
||||
endif
|
||||
|
||||
endif
|
||||
endif
|
||||
|
||||
|
||||
" echom 'CURRENT INDENT: ' . ind . ' LINE: ' . getline(v:lnum)
|
||||
|
||||
" This is a new blank line since we just typed a carriage return
|
||||
" Check current line; search for simplistic matching start-of-block
|
||||
let line = getline(v:lnum)
|
||||
|
||||
if line =~? '^\s*els'
|
||||
" Any line when you type else will automatically back up one
|
||||
" ident level (ie else, elseif, elsif)
|
||||
let ind = ind - &sw
|
||||
" echom 'curr - else - indent ' . ind
|
||||
elseif line =~? '^\s*end\>'
|
||||
let ind = s:GetStmtStarterIndent('end', v:lnum)
|
||||
" General case for end
|
||||
" let ind = ind - &sw
|
||||
" echom 'curr - end - indent ' . ind
|
||||
elseif line =~? '^\s*when\>'
|
||||
let ind = s:GetStmtStarterIndent('when', v:lnum)
|
||||
" If the WHEN clause is used with a MERGE or EXCEPTION
|
||||
" clause, do not change the indent level, since these
|
||||
" statements do not have a corresponding END statement.
|
||||
" if stmt_starter =~? 'case'
|
||||
" let ind = ind - &sw
|
||||
" endif
|
||||
" elseif line =~ '^\s*)\s*;\?\s*$'
|
||||
" elseif line =~ '^\s*)'
|
||||
elseif line =~ '^\s*)'
|
||||
let num_unmatched_right = s:CountUnbalancedParan( line, ')' )
|
||||
let ignore = s:CheckToIgnoreRightParan( v:lnum, num_unmatched_right )
|
||||
" If the line ends in a ), then reduce the indent
|
||||
" This catches items like:
|
||||
" CREATE TABLE T1(
|
||||
" c1 int,
|
||||
" c2 int
|
||||
" );
|
||||
" But we do not want to unindent a line like:
|
||||
" IF ( c1 = 1
|
||||
" AND c2 = 3 ) THEN
|
||||
" let num_unmatched_right = s:CountUnbalancedParan( line, ')' )
|
||||
" if num_unmatched_right > 0
|
||||
" elseif strpart( line, strlen(line)-1, 1 ) =~ ')'
|
||||
" let ind = ind - &sw
|
||||
if line =~ '^\s*)'
|
||||
" let ignore = ignore + 1
|
||||
" echom 'curr - begins ) unbalanced ignore: ' . ignore
|
||||
endif
|
||||
|
||||
if (num_unmatched_right - ignore) > 0
|
||||
let ind = ind - ( &sw * (num_unmatched_right - ignore) )
|
||||
endif
|
||||
" endif
|
||||
endif
|
||||
|
||||
" echom 'final - indent ' . ind
|
||||
return s:ModuloIndent(ind)
|
||||
endfunction
|
||||
|
||||
" vim:sw=4:
|
||||
75
vim/bundle/ubuntu-vim72/indent/tcl.vim
Normal file
75
vim/bundle/ubuntu-vim72/indent/tcl.vim
Normal file
@@ -0,0 +1,75 @@
|
||||
" Vim indent file
|
||||
" Language: Tcl
|
||||
" Maintainer: Nikolai Weibull <now@bitwi.se>
|
||||
" Latest Revision: 2006-12-20
|
||||
|
||||
if exists("b:did_indent")
|
||||
finish
|
||||
endif
|
||||
let b:did_indent = 1
|
||||
|
||||
setlocal indentexpr=GetTclIndent()
|
||||
setlocal indentkeys=0{,0},!^F,o,O,0]
|
||||
setlocal nosmartindent
|
||||
|
||||
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 s:count_braces(lnum, count_open)
|
||||
let n_open = 0
|
||||
let n_close = 0
|
||||
let line = getline(a:lnum)
|
||||
let pattern = '[{}]'
|
||||
let i = match(line, pattern)
|
||||
while i != -1
|
||||
if synIDattr(synID(a:lnum, i + 1, 0), 'name') !~ 'tcl\%(Comment\|String\)'
|
||||
if line[i] == '{'
|
||||
let n_open += 1
|
||||
elseif line[i] == '}'
|
||||
if n_open > 0
|
||||
let n_open -= 1
|
||||
else
|
||||
let n_close += 1
|
||||
endif
|
||||
endif
|
||||
endif
|
||||
let i = match(line, pattern, i + 1)
|
||||
endwhile
|
||||
return a:count_open ? n_open : n_close
|
||||
endfunction
|
||||
|
||||
function GetTclIndent()
|
||||
let line = getline(v:lnum)
|
||||
if line =~ '^\s*\*'
|
||||
return cindent(v:lnum)
|
||||
elseif line =~ '^\s*}'
|
||||
return indent(v:lnum) - &sw
|
||||
endif
|
||||
|
||||
let pnum = s:prevnonblanknoncomment(v:lnum - 1)
|
||||
if pnum == 0
|
||||
return 0
|
||||
endif
|
||||
|
||||
let ind = indent(pnum) + s:count_braces(pnum, 1) * &sw
|
||||
|
||||
let pline = getline(pnum)
|
||||
if pline =~ '}\s*$'
|
||||
let ind -= (s:count_braces(pnum, 0) - (pline =~ '^\s*}' ? 1 : 0)) * &sw
|
||||
endif
|
||||
|
||||
return ind
|
||||
endfunction
|
||||
51
vim/bundle/ubuntu-vim72/indent/tcsh.vim
Normal file
51
vim/bundle/ubuntu-vim72/indent/tcsh.vim
Normal file
@@ -0,0 +1,51 @@
|
||||
" Vim indent file
|
||||
" Language: C-shell (tcsh)
|
||||
" Maintainer: Gautam Iyer <gautam@math.uchicago.edu>
|
||||
" Last Modified: Sat 16 Jun 2007 04:27:45 PM PDT
|
||||
|
||||
" 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 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
|
||||
72
vim/bundle/ubuntu-vim72/indent/tf.vim
Normal file
72
vim/bundle/ubuntu-vim72/indent/tf.vim
Normal file
@@ -0,0 +1,72 @@
|
||||
" Vim indent file
|
||||
" Language: tf (TinyFugue)
|
||||
" Maintainer: Christian J. Robinson <infynity@onewest.net>
|
||||
" URL: http://www.infynity.spodzone.com/vim/indent/tf.vim
|
||||
" Last Change: 2002 May 29
|
||||
|
||||
" Only load this indent file when no other was loaded.
|
||||
if exists("b:did_indent")
|
||||
finish
|
||||
endif
|
||||
let b:did_indent = 1
|
||||
|
||||
setlocal indentexpr=GetTFIndent()
|
||||
setlocal indentkeys-=0{,0} indentkeys-=0# indentkeys-=:
|
||||
setlocal indentkeys+==/endif,=/then,=/else,=/done,0;
|
||||
|
||||
" Only define the function once:
|
||||
if exists("*GetTFIndent")
|
||||
finish
|
||||
endif
|
||||
|
||||
function GetTFIndent()
|
||||
" Find a non-blank line above the current line:
|
||||
let lnum = prevnonblank(v:lnum - 1)
|
||||
|
||||
" No indent for the start of the file:
|
||||
if lnum == 0
|
||||
return 0
|
||||
endif
|
||||
|
||||
let ind = indent(lnum)
|
||||
let line = getline(lnum)
|
||||
|
||||
" No indentation if the previous line didn't end with "\":
|
||||
" (Could be annoying, but it lets you know if you made a mistake.)
|
||||
if line !~ '\\$'
|
||||
return 0
|
||||
endif
|
||||
|
||||
if line =~ '\(/def.*\\\|/for.*\(%;\s*\)\@\<!\\\)$'
|
||||
let ind = ind + &sw
|
||||
elseif line =~ '\(/if\|/else\|/then\)'
|
||||
if line !~ '/endif'
|
||||
let ind = ind + &sw
|
||||
endif
|
||||
elseif line =~ '/while'
|
||||
if line !~ '/done'
|
||||
let ind = ind + &sw
|
||||
endif
|
||||
endif
|
||||
|
||||
let line = getline(v:lnum)
|
||||
|
||||
if line =~ '\(/else\|/endif\|/then\)'
|
||||
if line !~ '/if'
|
||||
let ind = ind - &sw
|
||||
endif
|
||||
elseif line =~ '/done'
|
||||
if line !~ '/while'
|
||||
let ind = ind - &sw
|
||||
endif
|
||||
endif
|
||||
|
||||
" Comments at the beginning of a line:
|
||||
if line =~ '^\s*;'
|
||||
let ind = 0
|
||||
endif
|
||||
|
||||
|
||||
return ind
|
||||
|
||||
endfunction
|
||||
36
vim/bundle/ubuntu-vim72/indent/tilde.vim
Normal file
36
vim/bundle/ubuntu-vim72/indent/tilde.vim
Normal file
@@ -0,0 +1,36 @@
|
||||
"Description: Indent scheme for the tilde weblanguage
|
||||
"Author: Tobias Rundströ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
|
||||
75
vim/bundle/ubuntu-vim72/indent/vb.vim
Normal file
75
vim/bundle/ubuntu-vim72/indent/vb.vim
Normal file
@@ -0,0 +1,75 @@
|
||||
" Vim indent file
|
||||
" Language: VisualBasic (ft=vb) / Basic (ft=basic) / SaxBasic (ft=vb)
|
||||
" Author: Johannes Zellner <johannes@zellner.org>
|
||||
" Last Change: Fri, 18 Jun 2004 07:22:42 CEST
|
||||
|
||||
if exists("b:did_indent")
|
||||
finish
|
||||
endif
|
||||
let b:did_indent = 1
|
||||
|
||||
setlocal autoindent
|
||||
setlocal indentexpr=VbGetIndent(v:lnum)
|
||||
setlocal indentkeys&
|
||||
setlocal indentkeys+==~else,=~elseif,=~end,=~wend,=~case,=~next,=~select,=~loop,<:>
|
||||
|
||||
let b:undo_indent = "set ai< indentexpr< indentkeys<"
|
||||
|
||||
" 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
vim/bundle/ubuntu-vim72/indent/verilog.vim
Normal file
219
vim/bundle/ubuntu-vim72/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
|
||||
406
vim/bundle/ubuntu-vim72/indent/vhdl.vim
Normal file
406
vim/bundle/ubuntu-vim72/indent/vhdl.vim
Normal file
@@ -0,0 +1,406 @@
|
||||
" VHDL indent ('93 syntax)
|
||||
" Language: VHDL
|
||||
" Maintainer: Gerald Lai <laigera+vim?gmail.com>
|
||||
" Version: 1.54
|
||||
" Last Change: 2007 Aug 17
|
||||
" URL: http://www.vim.org/scripts/script.php?script_id=1450
|
||||
|
||||
" only load this indent file when no other was loaded
|
||||
if exists("b:did_indent")
|
||||
finish
|
||||
endif
|
||||
let b:did_indent = 1
|
||||
|
||||
" setup indent options for local VHDL buffer
|
||||
setlocal indentexpr=GetVHDLindent()
|
||||
setlocal indentkeys=!^F,o,O,0(,0)
|
||||
setlocal indentkeys+==~begin,=~end\ ,=~end\ ,=~is,=~select,=~when
|
||||
setlocal indentkeys+==~if,=~then,=~elsif,=~else
|
||||
setlocal indentkeys+==~case,=~loop,=~for,=~generate,=~record,=~units,=~process,=~block,=~function,=~component,=~procedure
|
||||
setlocal indentkeys+==~architecture,=~configuration,=~entity,=~package
|
||||
|
||||
" constants
|
||||
" not a comment
|
||||
let s:NC = '\%(--.*\)\@<!'
|
||||
" end of string
|
||||
let s:ES = '\s*\%(--.*\)\=$'
|
||||
" no "end" keyword in front
|
||||
let s:NE = '\%(\<end\s\+\)\@<!'
|
||||
|
||||
" option to disable alignment of generic/port mappings
|
||||
if !exists("g:vhdl_indent_genportmap")
|
||||
let g:vhdl_indent_genportmap = 1
|
||||
endif
|
||||
|
||||
" option to disable alignment of right-hand side assignment "<=" statements
|
||||
if !exists("g:vhdl_indent_rhsassign")
|
||||
let g:vhdl_indent_rhsassign = 1
|
||||
endif
|
||||
|
||||
" only define indent function once
|
||||
if exists("*GetVHDLindent")
|
||||
finish
|
||||
endif
|
||||
|
||||
function GetVHDLindent()
|
||||
" store current line & string
|
||||
let curn = v:lnum
|
||||
let curs = getline(curn)
|
||||
|
||||
" find previous line that is not a comment
|
||||
let prevn = prevnonblank(curn - 1)
|
||||
let prevs = getline(prevn)
|
||||
while prevn > 0 && prevs =~ '^\s*--'
|
||||
let prevn = prevnonblank(prevn - 1)
|
||||
let prevs = getline(prevn)
|
||||
endwhile
|
||||
let prevs_noi = substitute(prevs, '^\s*', '', '')
|
||||
|
||||
" default indent starts as previous non-comment line's indent
|
||||
let ind = prevn > 0 ? indent(prevn) : 0
|
||||
" backup default
|
||||
let ind2 = ind
|
||||
|
||||
" indent: special; kill string so it would not affect other filters
|
||||
" keywords: "report" + string
|
||||
" where: anywhere in current or previous line
|
||||
let s0 = s:NC.'\<report\>\s*".*"'
|
||||
if curs =~? s0
|
||||
let curs = ""
|
||||
endif
|
||||
if prevs =~? s0
|
||||
let prevs = ""
|
||||
endif
|
||||
|
||||
" indent: previous line's comment position, otherwise follow next non-comment line if possible
|
||||
" keyword: "--"
|
||||
" where: start of current line
|
||||
if curs =~ '^\s*--'
|
||||
let pn = curn - 1
|
||||
let ps = getline(pn)
|
||||
if curs =~ '^\s*--\s' && ps =~ '--'
|
||||
return indent(pn) + stridx(substitute(ps, '^\s*', '', ''), '--')
|
||||
else
|
||||
" find nextnonblank line that is not a comment
|
||||
let nn = nextnonblank(curn + 1)
|
||||
let ns = getline(nn)
|
||||
while nn > 0 && ns =~ '^\s*--'
|
||||
let nn = nextnonblank(nn + 1)
|
||||
let ns = getline(nn)
|
||||
endwhile
|
||||
let n = indent(nn)
|
||||
return n != -1 ? n : ind
|
||||
endif
|
||||
endif
|
||||
|
||||
" ****************************************************************************************
|
||||
" indent: align generic variables & port names
|
||||
" keywords: "generic", "map", "port" + "(", provided current line is part of mapping
|
||||
" where: anywhere in previous 2 lines
|
||||
" find following previous non-comment line
|
||||
let pn = prevnonblank(prevn - 1)
|
||||
let ps = getline(pn)
|
||||
while pn > 0 && ps =~ '^\s*--'
|
||||
let pn = prevnonblank(pn - 1)
|
||||
let ps = getline(pn)
|
||||
endwhile
|
||||
if (curs =~ '^\s*)' || curs =~? '^\s*\%(\<\%(generic\|map\|port\)\>.*\)\@<!\S\+\s*\%(=>\s*\S\+\|:[^=]\@=\s*\%(\%(in\|out\|inout\|buffer\|linkage\)\>\|\w\+\s\+:=\)\)') && (prevs =~? s:NC.'\<\%(generic\|map\|port\)\s*(\%(\s*\w\)\=' || (ps =~? s:NC.'\<\%(generic\|map\|port\)'.s:ES && prevs =~ '^\s*('))
|
||||
" align closing ")" with opening "("
|
||||
if curs =~ '^\s*)'
|
||||
return ind2 + stridx(prevs_noi, '(')
|
||||
endif
|
||||
let m = matchend(prevs_noi, '(\s*\ze\w')
|
||||
if m != -1
|
||||
return ind2 + m
|
||||
else
|
||||
if g:vhdl_indent_genportmap
|
||||
return ind2 + stridx(prevs_noi, '(') + &sw
|
||||
else
|
||||
return ind2 + &sw
|
||||
endif
|
||||
endif
|
||||
endif
|
||||
|
||||
" indent: align conditional/select statement
|
||||
" keywords: variable + "<=" without ";" ending
|
||||
" where: start of previous line
|
||||
if prevs =~? '^\s*\S\+\s*<=[^;]*'.s:ES
|
||||
if g:vhdl_indent_rhsassign
|
||||
return ind2 + matchend(prevs_noi, '<=\s*\ze.')
|
||||
else
|
||||
return ind2 + &sw
|
||||
endif
|
||||
endif
|
||||
|
||||
" indent: backtrace previous non-comment lines for next smaller or equal size indent
|
||||
" keywords: "end" + "record", "units"
|
||||
" where: start of previous line
|
||||
" keyword: ")"
|
||||
" where: start of previous line
|
||||
" keyword: without "<=" + ";" ending
|
||||
" where: anywhere in previous line
|
||||
" keyword: "=>" + ")" ending, provided current line does not begin with ")"
|
||||
" where: anywhere in previous line
|
||||
" _note_: indent allowed to leave this filter
|
||||
let m = 0
|
||||
if prevs =~? '^\s*end\s\+\%(record\|units\)\>'
|
||||
let m = 3
|
||||
elseif prevs =~ '^\s*)'
|
||||
let m = 1
|
||||
elseif prevs =~ s:NC.'\%(<=.*\)\@<!;'.s:ES || (curs !~ '^\s*)' && prevs =~ s:NC.'=>.*'.s:NC.')'.s:ES)
|
||||
let m = 2
|
||||
endif
|
||||
|
||||
if m > 0
|
||||
let pn = prevnonblank(prevn - 1)
|
||||
let ps = getline(pn)
|
||||
while pn > 0
|
||||
let t = indent(pn)
|
||||
if ps !~ '^\s*--' && t < ind
|
||||
" make sure one of these is true
|
||||
" keywords: variable + "<=" without ";" ending
|
||||
" where: start of previous non-comment line
|
||||
" keywords: "generic", "map", "port"
|
||||
" where: anywhere in previous non-comment line
|
||||
" keyword: "("
|
||||
" where: start of previous non-comment line
|
||||
if m < 3 && ps !~? '^\s*\S\+\s*<=[^;]*'.s:ES
|
||||
if ps =~? s:NC.'\<\%(generic\|map\|port\)\>' || ps =~ '^\s*('
|
||||
let ind = t
|
||||
endif
|
||||
break
|
||||
endif
|
||||
let ind = t
|
||||
if m > 1
|
||||
" find following previous non-comment line
|
||||
let ppn = prevnonblank(pn - 1)
|
||||
let pps = getline(ppn)
|
||||
while ppn > 0 && pps =~ '^\s*--'
|
||||
let ppn = prevnonblank(ppn - 1)
|
||||
let pps = getline(ppn)
|
||||
endwhile
|
||||
" indent: follow
|
||||
" keyword: "select"
|
||||
" where: end of following previous non-comment line
|
||||
" keyword: "type"
|
||||
" where: start of following previous non-comment line
|
||||
if m == 2
|
||||
let s1 = s:NC.'\<select'.s:ES
|
||||
if ps !~? s1 && pps =~? s1
|
||||
let ind = indent(ppn)
|
||||
endif
|
||||
elseif m == 3
|
||||
let s1 = '^\s*type\>'
|
||||
if ps !~? s1 && pps =~? s1
|
||||
let ind = indent(ppn)
|
||||
endif
|
||||
endif
|
||||
endif
|
||||
break
|
||||
endif
|
||||
let pn = prevnonblank(pn - 1)
|
||||
let ps = getline(pn)
|
||||
endwhile
|
||||
endif
|
||||
|
||||
" indent: follow indent of previous opening statement, otherwise -sw
|
||||
" keyword: "begin"
|
||||
" where: anywhere in current line
|
||||
if curs =~? s:NC.'\<begin\>'
|
||||
let ind = ind - &sw
|
||||
" find previous opening statement of
|
||||
" keywords: "architecture", "block", "entity", "function", "generate", "procedure", "process"
|
||||
let s2 = s:NC.s:NE.'\<\%(architecture\|block\|entity\|function\|generate\|procedure\|process\)\>'
|
||||
if (curs !~? s2.'.*'.s:NC.'\<begin\>.*'.s:ES && prevs =~? s2) || m == 1
|
||||
let ind = ind + &sw
|
||||
endif
|
||||
return ind
|
||||
endif
|
||||
|
||||
" indent: +sw if previous line is previous opening statement
|
||||
" keywords: "record", "units"
|
||||
" where: anywhere in current line
|
||||
if curs =~? s:NC.s:NE.'\<\%(record\|units\)\>'
|
||||
" find previous opening statement of
|
||||
" keyword: "type"
|
||||
let s3 = s:NC.s:NE.'\<type\>'
|
||||
if curs !~? s3.'.*'.s:NC.'\<\%(record\|units\)\>.*'.s:ES && prevs =~? s3
|
||||
let ind = ind + &sw
|
||||
endif
|
||||
return ind
|
||||
endif
|
||||
|
||||
" ****************************************************************************************
|
||||
" indent: 0
|
||||
" keywords: "architecture", "configuration", "entity", "library", "package"
|
||||
" where: start of current line
|
||||
if curs =~? '^\s*\%(architecture\|configuration\|entity\|library\|package\)\>'
|
||||
return 0
|
||||
endif
|
||||
|
||||
" indent: maintain indent of previous opening statement
|
||||
" keyword: "is"
|
||||
" where: start of current line
|
||||
" find previous opening statement of
|
||||
" keywords: "architecture", "block", "configuration", "entity", "function", "package", "procedure", "process", "type"
|
||||
if curs =~? '^\s*\<is\>' && prevs =~? s:NC.s:NE.'\<\%(architecture\|block\|configuration\|entity\|function\|package\|procedure\|process\|type\)\>'
|
||||
return ind2
|
||||
endif
|
||||
|
||||
" indent: maintain indent of previous opening statement
|
||||
" keyword: "then"
|
||||
" where: start of current line
|
||||
" find previous opening statement of
|
||||
" keywords: "elsif", "if"
|
||||
if curs =~? '^\s*\<then\>' && prevs =~? s:NC.'\%(\<elsif\>\|'.s:NE.'\<if\>\)'
|
||||
return ind2
|
||||
endif
|
||||
|
||||
" indent: maintain indent of previous opening statement
|
||||
" keyword: "generate"
|
||||
" where: start of current line
|
||||
" find previous opening statement of
|
||||
" keywords: "for", "if"
|
||||
if curs =~? '^\s*\<generate\>' && prevs =~? s:NC.s:NE.'\%(\%(\<wait\s\+\)\@<!\<for\|\<if\)\>'
|
||||
return ind2
|
||||
endif
|
||||
|
||||
" indent: +sw
|
||||
" keywords: "block", "process"
|
||||
" removed: "begin", "case", "elsif", "if", "loop", "record", "units", "while"
|
||||
" where: anywhere in previous line
|
||||
if prevs =~? s:NC.s:NE.'\<\%(block\|process\)\>'
|
||||
return ind + &sw
|
||||
endif
|
||||
|
||||
" indent: +sw
|
||||
" keywords: "architecture", "configuration", "entity", "package"
|
||||
" removed: "component", "for", "when", "with"
|
||||
" where: start of previous line
|
||||
if prevs =~? '^\s*\%(architecture\|configuration\|entity\|package\)\>'
|
||||
return ind + &sw
|
||||
endif
|
||||
|
||||
" indent: +sw
|
||||
" keyword: "select"
|
||||
" removed: "generate", "is", "=>"
|
||||
" where: end of previous line
|
||||
if prevs =~? s:NC.'\<select'.s:ES
|
||||
return ind + &sw
|
||||
endif
|
||||
|
||||
" indent: +sw
|
||||
" keyword: "begin", "loop", "record", "units"
|
||||
" where: anywhere in previous line
|
||||
" keyword: "component", "else", "for"
|
||||
" where: start of previous line
|
||||
" keyword: "generate", "is", "then", "=>"
|
||||
" where: end of previous line
|
||||
" _note_: indent allowed to leave this filter
|
||||
if prevs =~? s:NC.'\%(\<begin\>\|'.s:NE.'\<\%(loop\|record\|units\)\>\)' || prevs =~? '^\s*\%(component\|else\|for\)\>' || prevs =~? s:NC.'\%('.s:NE.'\<generate\|\<\%(is\|then\)\|=>\)'.s:ES
|
||||
let ind = ind + &sw
|
||||
endif
|
||||
|
||||
" ****************************************************************************************
|
||||
" indent: -sw
|
||||
" keywords: "when", provided previous line does not begin with "when", does not end with "is"
|
||||
" where: start of current line
|
||||
let s4 = '^\s*when\>'
|
||||
if curs =~? s4
|
||||
if prevs =~? s:NC.'\<is'.s:ES
|
||||
return ind
|
||||
elseif prevs !~? s4
|
||||
return ind - &sw
|
||||
else
|
||||
return ind2
|
||||
endif
|
||||
endif
|
||||
|
||||
" indent: -sw
|
||||
" keywords: "else", "elsif", "end" + "block", "for", "function", "generate", "if", "loop", "procedure", "process", "record", "units"
|
||||
" where: start of current line
|
||||
if curs =~? '^\s*\%(else\|elsif\|end\s\+\%(block\|for\|function\|generate\|if\|loop\|procedure\|process\|record\|units\)\)\>'
|
||||
return ind - &sw
|
||||
endif
|
||||
|
||||
" indent: backtrace previous non-comment lines
|
||||
" keyword: "end" + "case", "component"
|
||||
" where: start of current line
|
||||
let m = 0
|
||||
if curs =~? '^\s*end\s\+case\>'
|
||||
let m = 1
|
||||
elseif curs =~? '^\s*end\s\+component\>'
|
||||
let m = 2
|
||||
endif
|
||||
|
||||
if m > 0
|
||||
" find following previous non-comment line
|
||||
let pn = prevn
|
||||
let ps = getline(pn)
|
||||
while pn > 0
|
||||
if ps !~ '^\s*--'
|
||||
"indent: -2sw
|
||||
"keywords: "end" + "case"
|
||||
"where: start of previous non-comment line
|
||||
"indent: -sw
|
||||
"keywords: "when"
|
||||
"where: start of previous non-comment line
|
||||
"indent: follow
|
||||
"keywords: "case"
|
||||
"where: start of previous non-comment line
|
||||
if m == 1
|
||||
if ps =~? '^\s*end\s\+case\>'
|
||||
return indent(pn) - 2 * &sw
|
||||
elseif ps =~? '^\s*when\>'
|
||||
return indent(pn) - &sw
|
||||
elseif ps =~? '^\s*case\>'
|
||||
return indent(pn)
|
||||
endif
|
||||
"indent: follow
|
||||
"keyword: "component"
|
||||
"where: start of previous non-comment line
|
||||
elseif m == 2
|
||||
if ps =~? '^\s*component\>'
|
||||
return indent(pn)
|
||||
endif
|
||||
endif
|
||||
endif
|
||||
let pn = prevnonblank(pn - 1)
|
||||
let ps = getline(pn)
|
||||
endwhile
|
||||
return ind - &sw
|
||||
endif
|
||||
|
||||
" indent: -sw
|
||||
" keyword: ")"
|
||||
" where: start of current line
|
||||
if curs =~ '^\s*)'
|
||||
return ind - &sw
|
||||
endif
|
||||
|
||||
" indent: 0
|
||||
" keywords: "end" + "architecture", "configuration", "entity", "package"
|
||||
" where: start of current line
|
||||
if curs =~? '^\s*end\s\+\%(architecture\|configuration\|entity\|package\)\>'
|
||||
return 0
|
||||
endif
|
||||
|
||||
" indent: -sw
|
||||
" keywords: "end" + identifier
|
||||
" where: start of current line
|
||||
"if curs =~? '^\s*end\s\+\w\+\>'
|
||||
if curs =~? '^\s*end\s'
|
||||
return ind - &sw
|
||||
endif
|
||||
|
||||
" ****************************************************************************************
|
||||
" indent: maintain indent of previous opening statement
|
||||
" keywords: without "generic", "map", "port" + ":" but not ":=" + "in", "out", "inout", "buffer", "linkage", variable & ":="
|
||||
" where: start of current line
|
||||
if curs =~? '^\s*\%(\<\%(generic\|map\|port\)\>.*\)\@<!\S\+\s*:[^=]\@=\s*\%(\%(in\|out\|inout\|buffer\|linkage\)\>\|\w\+\s\+:=\)'
|
||||
return ind2
|
||||
endif
|
||||
|
||||
" return leftover filtered indent
|
||||
return ind
|
||||
endfunction
|
||||
74
vim/bundle/ubuntu-vim72/indent/vim.vim
Normal file
74
vim/bundle/ubuntu-vim72/indent/vim.vim
Normal file
@@ -0,0 +1,74 @@
|
||||
" Vim indent file
|
||||
" Language: Vim script
|
||||
" Maintainer: Bram Moolenaar <Bram@vim.org>
|
||||
" Last Change: 2005 Jul 06
|
||||
|
||||
" 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 (or g:vim_indent_cont if it exists).
|
||||
let ind = indent(lnum)
|
||||
if getline(v:lnum) =~ '^\s*\\' && v:lnum > 1 && getline(lnum) !~ '^\s*\\'
|
||||
if exists("g:vim_indent_cont")
|
||||
let ind = ind + g:vim_indent_cont
|
||||
else
|
||||
let ind = ind + &sw * 3
|
||||
endif
|
||||
elseif getline(lnum) =~ '\(^\||\)\s*\(if\|wh\%[ile]\|for\|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. And not when there is a backslash before the pipe.
|
||||
" And when syntax HL is enabled avoid a match inside a string.
|
||||
let line = getline(lnum)
|
||||
let i = match(line, '[^\\]|\s*\(ene\@!\)')
|
||||
if i > 0 && line !~ '^\s*au\%[tocmd]'
|
||||
if !has('syntax_items') || synIDattr(synID(lnum, i + 2, 1), "name") !~ '\(Comment\|String\)$'
|
||||
let ind = ind - &sw
|
||||
endif
|
||||
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
|
||||
37
vim/bundle/ubuntu-vim72/indent/xf86conf.vim
Normal file
37
vim/bundle/ubuntu-vim72/indent/xf86conf.vim
Normal file
@@ -0,0 +1,37 @@
|
||||
" Vim indent file
|
||||
" Language: XFree86 Configuration File
|
||||
" Maintainer: Nikolai Weibull <now@bitwi.se>
|
||||
" Latest Revision: 2006-12-20
|
||||
|
||||
if exists("b:did_indent")
|
||||
finish
|
||||
endif
|
||||
let b:did_indent = 1
|
||||
|
||||
setlocal indentexpr=GetXF86ConfIndent()
|
||||
setlocal indentkeys=!^F,o,O,=End
|
||||
setlocal nosmartindent
|
||||
|
||||
if exists("*GetXF86ConfIndent")
|
||||
finish
|
||||
endif
|
||||
|
||||
function GetXF86ConfIndent()
|
||||
let lnum = prevnonblank(v:lnum - 1)
|
||||
|
||||
if lnum == 0
|
||||
return 0
|
||||
endif
|
||||
|
||||
let ind = indent(lnum)
|
||||
|
||||
if getline(lnum) =~? '^\s*\(Sub\)\=Section\>'
|
||||
let ind = ind + &sw
|
||||
endif
|
||||
|
||||
if getline(v:lnum) =~? '^\s*End\(Sub\)\=Section\>'
|
||||
let ind = ind - &sw
|
||||
endif
|
||||
|
||||
return ind
|
||||
endfunction
|
||||
12
vim/bundle/ubuntu-vim72/indent/xhtml.vim
Normal file
12
vim/bundle/ubuntu-vim72/indent/xhtml.vim
Normal file
@@ -0,0 +1,12 @@
|
||||
" Vim indent file
|
||||
" Language: XHTML
|
||||
" Maintainer: Bram Moolenaar <Bram@vim.org> (for now)
|
||||
" Last Change: 2005 Jun 24
|
||||
|
||||
" Only load this indent file when no other was loaded.
|
||||
if exists("b:did_indent")
|
||||
finish
|
||||
endif
|
||||
|
||||
" Handled like HTML for now.
|
||||
runtime! indent/html.vim
|
||||
50
vim/bundle/ubuntu-vim72/indent/xinetd.vim
Normal file
50
vim/bundle/ubuntu-vim72/indent/xinetd.vim
Normal file
@@ -0,0 +1,50 @@
|
||||
" Vim indent file
|
||||
" Language: xinetd.conf(5) configuration file
|
||||
" Maintainer: Nikolai Weibull <now@bitwi.se>
|
||||
" Latest Revision: 2006-12-20
|
||||
|
||||
if exists("b:did_indent")
|
||||
finish
|
||||
endif
|
||||
let b:did_indent = 1
|
||||
|
||||
setlocal indentexpr=GetXinetdIndent()
|
||||
setlocal indentkeys=0{,0},!^F,o,O
|
||||
setlocal nosmartindent
|
||||
|
||||
if exists("*GetXinetdIndent")
|
||||
finish
|
||||
endif
|
||||
|
||||
function s:count_braces(lnum, count_open)
|
||||
let n_open = 0
|
||||
let n_close = 0
|
||||
let line = getline(a:lnum)
|
||||
let pattern = '[{}]'
|
||||
let i = match(line, pattern)
|
||||
while i != -1
|
||||
if synIDattr(synID(a:lnum, i + 1, 0), 'name') !~ 'ld\%(Comment\|String\)'
|
||||
if line[i] == '{'
|
||||
let n_open += 1
|
||||
elseif line[i] == '}'
|
||||
if n_open > 0
|
||||
let n_open -= 1
|
||||
else
|
||||
let n_close += 1
|
||||
endif
|
||||
endif
|
||||
endif
|
||||
let i = match(line, pattern, i + 1)
|
||||
endwhile
|
||||
return a:count_open ? n_open : n_close
|
||||
endfunction
|
||||
|
||||
function GetXinetdIndent()
|
||||
let pnum = prevnonblank(v:lnum - 1)
|
||||
if pnum == 0
|
||||
return 0
|
||||
endif
|
||||
|
||||
return indent(pnum) + s:count_braces(pnum, 1) * &sw
|
||||
\ - s:count_braces(v:lnum, 0) * &sw
|
||||
endfunction
|
||||
96
vim/bundle/ubuntu-vim72/indent/xml.vim
Normal file
96
vim/bundle/ubuntu-vim72/indent/xml.vim
Normal file
@@ -0,0 +1,96 @@
|
||||
" Language: xml
|
||||
" Maintainer: Johannes Zellner <johannes@zellner.org>
|
||||
" Last Change: 2009-05-26 00:17:25
|
||||
" 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.
|
||||
" 2009-05-26 patch by Nikolai Weibull
|
||||
" 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
|
||||
elseif syn1 =~ '^xmlComment' && syn2 =~ '^xmlComment'
|
||||
" indent comments specially
|
||||
return -1
|
||||
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
|
||||
let check_lnum = <SID>XmlIndentSynCheck(lnum)
|
||||
let check_alnum = <SID>XmlIndentSynCheck(a:lnum)
|
||||
if 0 == check_lnum || 0 == check_alnum
|
||||
return indent(a:lnum)
|
||||
elseif -1 == check_lnum || -1 == check_alnum
|
||||
return -1
|
||||
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
vim/bundle/ubuntu-vim72/indent/xsd.vim
Normal file
13
vim/bundle/ubuntu-vim72/indent/xsd.vim
Normal file
@@ -0,0 +1,13 @@
|
||||
" Vim indent file
|
||||
" Language: .xsd files (XML Schema)
|
||||
" Maintainer: Nobody
|
||||
" Last Change: 2005 Jun 09
|
||||
|
||||
" 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
|
||||
|
||||
13
vim/bundle/ubuntu-vim72/indent/xslt.vim
Normal file
13
vim/bundle/ubuntu-vim72/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
|
||||
|
||||
41
vim/bundle/ubuntu-vim72/indent/yacc.vim
Normal file
41
vim/bundle/ubuntu-vim72/indent/yacc.vim
Normal file
@@ -0,0 +1,41 @@
|
||||
" Vim indent file
|
||||
" Language: YACC input file
|
||||
" Maintainer: Nikolai Weibull <now@bitwi.se>
|
||||
" Latest Revision: 2006-12-20
|
||||
|
||||
" 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
|
||||
setlocal nosmartindent
|
||||
|
||||
" 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
|
||||
11
vim/bundle/ubuntu-vim72/indent/zsh.vim
Normal file
11
vim/bundle/ubuntu-vim72/indent/zsh.vim
Normal file
@@ -0,0 +1,11 @@
|
||||
" Vim indent file
|
||||
" Language: Zsh Shell Script
|
||||
" Maintainer: Nikolai Weibull <now@bitwi.se>
|
||||
" Latest Revision: 2006-04-19
|
||||
|
||||
if exists("b:did_indent")
|
||||
finish
|
||||
endif
|
||||
|
||||
" Same as sh indenting for now.
|
||||
runtime! indent/sh.vim
|
||||
Reference in New Issue
Block a user