FM / indent

/usr/share/vim/vim74/indent

Name	Size	Mode	Actions
aap.vim	265	0644	edit dl rm
ada.vim	11147	0644	edit dl rm
ant.vim	290	0644	edit dl rm
automake.vim	231	0644	edit dl rm
awk.vim	7748	0644	edit dl rm
bib.vim	346	0644	edit dl rm
bst.vim	1919	0644	edit dl rm
c.vim	325	0644	edit dl rm
cdl.vim	4172	0644	edit dl rm
ch.vim	470	0644	edit dl rm
chaiscript.vim	1135	0644	edit dl rm
changelog.vim	264	0644	edit dl rm
clojure.vim	12132	0644	edit dl rm
cmake.vim	2754	0644	edit dl rm
cobol.vim	8197	0644	edit dl rm
config.vim	2166	0644	edit dl rm
cpp.vim	329	0644	edit dl rm
cs.vim	327	0644	edit dl rm
css.vim	1719	0644	edit dl rm
cucumber.vim	2624	0644	edit dl rm
cuda.vim	305	0644	edit dl rm
d.vim	510	0644	edit dl rm
dictconf.vim	325	0644	edit dl rm
dictdconf.vim	326	0644	edit dl rm
docbk.vim	324	0644	edit dl rm
dtd.vim	11668	0644	edit dl rm
dtrace.vim	451	0644	edit dl rm
dylan.vim	2662	0644	edit dl rm
eiffel.vim	3208	0644	edit dl rm
erlang.vim	46235	0644	edit dl rm
eruby.vim	2161	0644	edit dl rm
eterm.vim	638	0644	edit dl rm
falcon.vim	13982	0644	edit dl rm
fortran.vim	6559	0644	edit dl rm
framescript.vim	786	0644	edit dl rm
gitconfig.vim	817	0644	edit dl rm
gitolite.vim	996	0644	edit dl rm
haml.vim	2189	0644	edit dl rm
hamster.vim	1407	0644	edit dl rm
html.vim	14812	0644	edit dl rm
htmldjango.vim	273	0644	edit dl rm
idlang.vim	1566	0644	edit dl rm
ishd.vim	1841	0644	edit dl rm
java.vim	4115	0644	edit dl rm
javascript.vim	336	0644	edit dl rm
jsp.vim	462	0644	edit dl rm
ld.vim	1753	0644	edit dl rm
lifelines.vim	637	0644	edit dl rm
liquid.vim	1879	0644	edit dl rm
lisp.vim	353	0644	edit dl rm
logtalk.vim	1690	0644	edit dl rm
lua.vim	1914	0644	edit dl rm
mail.vim	308	0644	edit dl rm
make.vim	3431	0644	edit dl rm
matlab.vim	1928	0644	edit dl rm
mma.vim	2227	0644	edit dl rm
mp.vim	6527	0644	edit dl rm
objc.vim	1645	0644	edit dl rm
ocaml.vim	9110	0644	edit dl rm
occam.vim	4634	0644	edit dl rm
pascal.vim	5653	0644	edit dl rm
perl.vim	5811	0644	edit dl rm
perl6.vim	3503	0644	edit dl rm
php.vim	19423	0644	edit dl rm
postscr.vim	1622	0644	edit dl rm
pov.vim	2643	0644	edit dl rm
prolog.vim	1454	0644	edit dl rm
pyrex.vim	326	0644	edit dl rm
python.vim	5744	0644	edit dl rm
r.vim	14786	0644	edit dl rm
readline.vim	681	0644	edit dl rm
README.txt	1639	0644	edit dl rm
rpl.vim	1835	0644	edit dl rm
rst.vim	1387	0644	edit dl rm
ruby.vim	17546	0644	edit dl rm
sass.vim	1018	0644	edit dl rm
scheme.vim	241	0644	edit dl rm
scss.vim	191	0644	edit dl rm
sdl.vim	2767	0644	edit dl rm
sh.vim	4040	0644	edit dl rm
sml.vim	6418	0644	edit dl rm
sql.vim	1204	0644	edit dl rm
sqlanywhere.vim	13075	0644	edit dl rm
tcl.vim	1602	0644	edit dl rm
tcsh.vim	1243	0644	edit dl rm
tex.vim	9695	0644	edit dl rm
tf.vim	1499	0644	edit dl rm
tilde.vim	994	0644	edit dl rm
treetop.vim	677	0644	edit dl rm
vb.vim	2044	0644	edit dl rm
verilog.vim	7620	0644	edit dl rm
vhdl.vim	13801	0644	edit dl rm
vim.vim	2830	0644	edit dl rm
xf86conf.vim	679	0644	edit dl rm
xhtml.vim	269	0644	edit dl rm
xinetd.vim	1201	0644	edit dl rm
xml.vim	2840	0644	edit dl rm
xsd.vim	253	0644	edit dl rm
xslt.vim	297	0644	edit dl rm
yacc.vim	769	0644	edit dl rm
yaml.vim	4117	0644	edit dl rm
zimbu.vim	3891	0644	edit dl rm
zsh.vim	231	0644	edit dl rm

Edit: /usr/share/vim/vim74/indent/clojure.vim (12132B)

" Vim indent file
" Language:     Clojure
" Author:       Meikel Brandmeyer <mb@kotka.de>
" URL:          http://kotka.de/projects/clojure/vimclojure.html
"
" Maintainer:   Sung Pae <self@sungpae.com>
" URL:          https://github.com/guns/vim-clojure-static
" License:      Same as Vim
" Last Change:  30 January 2013

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

let s:save_cpo = &cpo
set cpo&vim

let b:undo_indent = 'setlocal autoindent< smartindent< lispwords< expandtab< softtabstop< shiftwidth< indentexpr< indentkeys<'

setlocal noautoindent nosmartindent
setlocal softtabstop=2 shiftwidth=2 expandtab
setlocal indentkeys=!,o,O

if exists("*searchpairpos")

if !exists('g:clojure_maxlines')
        let g:clojure_maxlines = 100
    endif

if !exists('g:clojure_fuzzy_indent')
        let g:clojure_fuzzy_indent = 1
    endif

if !exists('g:clojure_fuzzy_indent_patterns')
        let g:clojure_fuzzy_indent_patterns = ['^with', '^def', '^let']
    endif

if !exists('g:clojure_fuzzy_indent_blacklist')
        let g:clojure_fuzzy_indent_blacklist = ['-fn$', '\v^with-%(meta|out-str|loading-context)$']
    endif

if !exists('g:clojure_special_indent_words')
        let g:clojure_special_indent_words = 'deftype,defrecord,reify,proxy,extend-type,extend-protocol,letfn'
    endif

if !exists('g:clojure_align_multiline_strings')
        let g:clojure_align_multiline_strings = 0
    endif

function! s:SynIdName()
        return synIDattr(synID(line("."), col("."), 0), "name")
    endfunction

function! s:CurrentChar()
        return getline('.')[col('.')-1]
    endfunction

function! s:CurrentWord()
        return getline('.')[col('.')-1 : searchpos('\v>', 'n', line('.'))[1]-2]
    endfunction

function! s:IsParen()
        return s:CurrentChar() =~ '\v[\[\]\{\}]' &&
             \ s:SynIdName() !~? '\vstring|comment'
    endfunction

" Returns 1 if string matches a pattern in 'patterns', which may be a
    " list of patterns, or a comma-delimited string of implicitly anchored
    " patterns.
    function! s:MatchesOne(patterns, string)
        let list = type(a:patterns) == type([])
                   \ ? a:patterns
                   \ : map(split(a:patterns, ','), '"^" . v:val . "$"')
        for pat in list
            if a:string =~ pat | return 1 | endif
        endfor
    endfunction

function! s:SavePosition()
        let [ _b, l, c, _o ] = getpos(".")
        let b = bufnr("%")
        return [b, l, c]
    endfunction

function! s:RestorePosition(value)
        let [b, l, c] = a:value
        if bufnr("%") != b
            execute b "buffer!"
        endif
        call setpos(".", [0, l, c, 0])
    endfunction

function! s:MatchPairs(open, close, stopat)
        " Stop only on vector and map [ resp. {. Ignore the ones in strings and
        " comments.
        if a:stopat == 0
            let stopat = max([line(".") - g:clojure_maxlines, 0])
        else
            let stopat = a:stopat
        endif

let pos = searchpairpos(a:open, '', a:close, 'bWn', "!s:IsParen()", stopat)
        return [pos[0], virtcol(pos)]
    endfunction

function! s:ClojureCheckForStringWorker()
        " Check whether there is the last character of the previous line is
        " highlighted as a string. If so, we check whether it's a ". In this
        " case we have to check also the previous character. The " might be the
        " closing one. In case the we are still in the string, we search for the
        " opening ". If this is not found we take the indent of the line.
        let nb = prevnonblank(v:lnum - 1)

if nb == 0
            return -1
        endif

call cursor(nb, 0)
        call cursor(0, col("$") - 1)
        if s:SynIdName() !~? "string"
            return -1
        endif

" This will not work for a " in the first column...
        if s:CurrentChar() == '"'
            call cursor(0, col("$") - 2)
            if s:SynIdName() !~? "string"
                return -1
            endif
            if s:CurrentChar() != '\\'
                return -1
            endif
            call cursor(0, col("$") - 1)
        endif

let p = searchpos('$^\|[^\\]$\zs"', 'bW')

if p != [0, 0]
            return p[1] - 1
        endif

return indent(".")
    endfunction

function! s:CheckForString()
        let pos = s:SavePosition()
        try
            let val = s:ClojureCheckForStringWorker()
        finally
            call s:RestorePosition(pos)
        endtry
        return val
    endfunction

function! s:ClojureIsMethodSpecialCaseWorker(position)
        " Find the next enclosing form.
        call search('\S', 'Wb')

" Special case: we are at a '(('.
        if s:CurrentChar() == '('
            return 0
        endif
        call cursor(a:position)

let nextParen = s:MatchPairs('(', ')', 0)

" Special case: we are now at toplevel.
        if nextParen == [0, 0]
            return 0
        endif
        call cursor(nextParen)

call search('\S', 'W')
        if g:clojure_special_indent_words =~ '\<' . s:CurrentWord() . '\>'
            return 1
        endif

return 0
    endfunction

function! s:IsMethodSpecialCase(position)
        let pos = s:SavePosition()
        try
            let val = s:ClojureIsMethodSpecialCaseWorker(a:position)
        finally
            call s:RestorePosition(pos)
        endtry
        return val
    endfunction

function! GetClojureIndent()
        " Get rid of special case.
        if line(".") == 1
            return 0
        endif

" We have to apply some heuristics here to figure out, whether to use
        " normal lisp indenting or not.
        let i = s:CheckForString()
        if i > -1
            return i + !!g:clojure_align_multiline_strings
        endif

call cursor(0, 1)

" Find the next enclosing [ or {. We can limit the second search
        " to the line, where the [ was found. If no [ was there this is
        " zero and we search for an enclosing {.
        let paren = s:MatchPairs('(', ')', 0)
        let bracket = s:MatchPairs('\[', '\]', paren[0])
        let curly = s:MatchPairs('{', '}', bracket[0])

" In case the curly brace is on a line later then the [ or - in
        " case they are on the same line - in a higher column, we take the
        " curly indent.
        if curly[0] > bracket[0] || curly[1] > bracket[1]
            if curly[0] > paren[0] || curly[1] > paren[1]
                return curly[1]
            endif
        endif

" If the curly was not chosen, we take the bracket indent - if
        " there was one.
        if bracket[0] > paren[0] || bracket[1] > paren[1]
            return bracket[1]
        endif

" There are neither { nor [ nor (, ie. we are at the toplevel.
        if paren == [0, 0]
            return 0
        endif

" Now we have to reimplement lispindent. This is surprisingly easy, as
        " soon as one has access to syntax items.
        "
        " - Check whether we are in a special position after a word in
        "   g:clojure_special_indent_words. These are special cases.
        " - Get the next keyword after the (.
        " - If its first character is also a (, we have another sexp and align
        "   one column to the right of the unmatched (.
        " - In case it is in lispwords, we indent the next line to the column of
        "   the ( + sw.
        " - If not, we check whether it is last word in the line. In that case
        "   we again use ( + sw for indent.
        " - In any other case we use the column of the end of the word + 2.
        call cursor(paren)

if s:IsMethodSpecialCase(paren)
            return paren[1] + &shiftwidth - 1
        endif

" In case we are at the last character, we use the paren position.
        if col("$") - 1 == paren[1]
            return paren[1]
        endif

" In case after the paren is a whitespace, we search for the next word.
        normal! l
        if s:CurrentChar() == ' '
            normal! w
        endif

" If we moved to another line, there is no word after the (. We
        " use the ( position for indent.
        if line(".") > paren[0]
            return paren[1]
        endif

" We still have to check, whether the keyword starts with a (, [ or {.
        " In that case we use the ( position for indent.
        let w = s:CurrentWord()
        if stridx('([{', w[0]) > -1
            return paren[1]
        endif

" Test words without namespace qualifiers and leading reader macro
        " metacharacters.
        "
        " e.g. clojure.core/defn and #'defn should both indent like defn.
        let ww = substitute(w, "\\v%(.*/|[#'`~@^,]*)(.*)", '\1', '')

if &lispwords =~ '\V\<' . ww . '\>'
            return paren[1] + &shiftwidth - 1
        endif

if g:clojure_fuzzy_indent
            \ && !s:MatchesOne(g:clojure_fuzzy_indent_blacklist, ww)
            \ && s:MatchesOne(g:clojure_fuzzy_indent_patterns, ww)
            return paren[1] + &shiftwidth - 1
        endif

normal! W
        if paren[0] < line(".")
            return paren[1] + &shiftwidth - 1
        endif

normal! ge
        return virtcol(".") + 1
    endfunction

setlocal indentexpr=GetClojureIndent()

else

" In case we have searchpairpos not available we fall back to
    " normal lisp indenting.
    setlocal indentexpr=
    setlocal lisp
    let b:undo_indent .= '| setlocal lisp<'

endif

" Specially indented symbols from clojure.core and clojure.test.
"
" Clojure symbols are indented in the defn style when they:
"
"   * Define vars and anonymous functions
"   * Create new lexical scopes or scopes with altered environments
"   * Create conditional branches from a predicate function or value
"
" The arglists for these functions are generally in the form of [x & body];
" Functions that accept a flat list of forms do not treat the first argument
" specially and hence are not indented specially.

" Definitions
setlocal lispwords=
setlocal lispwords+=bound-fn
setlocal lispwords+=def
setlocal lispwords+=definline
setlocal lispwords+=definterface
setlocal lispwords+=defmacro
setlocal lispwords+=defmethod
setlocal lispwords+=defmulti
setlocal lispwords+=defn
setlocal lispwords+=defn-
setlocal lispwords+=defonce
setlocal lispwords+=defprotocol
setlocal lispwords+=defrecord
setlocal lispwords+=defstruct
setlocal lispwords+=deftest " clojure.test
setlocal lispwords+=deftest- " clojure.test
setlocal lispwords+=deftype
setlocal lispwords+=extend
setlocal lispwords+=extend-protocol
setlocal lispwords+=extend-type
setlocal lispwords+=fn
setlocal lispwords+=ns
setlocal lispwords+=proxy
setlocal lispwords+=reify
setlocal lispwords+=set-test " clojure.test

" Binding forms
setlocal lispwords+=as->
setlocal lispwords+=binding
setlocal lispwords+=doall
setlocal lispwords+=dorun
setlocal lispwords+=doseq
setlocal lispwords+=dotimes
setlocal lispwords+=doto
setlocal lispwords+=for
setlocal lispwords+=if-let
setlocal lispwords+=let
setlocal lispwords+=letfn
setlocal lispwords+=locking
setlocal lispwords+=loop
setlocal lispwords+=testing " clojure.test
setlocal lispwords+=when-first
setlocal lispwords+=when-let
setlocal lispwords+=with-bindings
setlocal lispwords+=with-in-str
setlocal lispwords+=with-local-vars
setlocal lispwords+=with-open
setlocal lispwords+=with-precision
setlocal lispwords+=with-redefs
setlocal lispwords+=with-redefs-fn
setlocal lispwords+=with-test " clojure.test

" Conditional branching
setlocal lispwords+=case
setlocal lispwords+=cond->
setlocal lispwords+=cond->>
setlocal lispwords+=condp
setlocal lispwords+=if
setlocal lispwords+=if-not
setlocal lispwords+=when
setlocal lispwords+=when-not
setlocal lispwords+=while

" Exception handling
setlocal lispwords+=catch
setlocal lispwords+=try " For aesthetics when enclosing single line

let &cpo = s:save_cpo
unlet! s:save_cpo

" vim:sts=4 sw=4 et:

cmd: