aboutsummaryrefslogtreecommitdiff
path: root/vim/bundle/syntastic/plugin
diff options
context:
space:
mode:
Diffstat (limited to 'vim/bundle/syntastic/plugin')
-rw-r--r--vim/bundle/syntastic/plugin/syntastic.vim729
-rw-r--r--vim/bundle/syntastic/plugin/syntastic/autoloclist.vim38
-rw-r--r--vim/bundle/syntastic/plugin/syntastic/balloons.vim59
-rw-r--r--vim/bundle/syntastic/plugin/syntastic/checker.vim273
-rw-r--r--vim/bundle/syntastic/plugin/syntastic/cursor.vim138
-rw-r--r--vim/bundle/syntastic/plugin/syntastic/highlighting.vim104
-rw-r--r--vim/bundle/syntastic/plugin/syntastic/loclist.vim439
-rw-r--r--vim/bundle/syntastic/plugin/syntastic/modemap.vim117
-rw-r--r--vim/bundle/syntastic/plugin/syntastic/notifiers.vim86
-rw-r--r--vim/bundle/syntastic/plugin/syntastic/registry.vim375
-rw-r--r--vim/bundle/syntastic/plugin/syntastic/signs.vim138
11 files changed, 2496 insertions, 0 deletions
diff --git a/vim/bundle/syntastic/plugin/syntastic.vim b/vim/bundle/syntastic/plugin/syntastic.vim
new file mode 100644
index 0000000..49b586c
--- /dev/null
+++ b/vim/bundle/syntastic/plugin/syntastic.vim
@@ -0,0 +1,729 @@
+"============================================================================
+"File: syntastic.vim
+"Description: Vim plugin for on the fly syntax checking.
+"License: This program is free software. It comes without any warranty,
+" to the extent permitted by applicable law. You can redistribute
+" it and/or modify it under the terms of the Do What The Fuck You
+" Want To Public License, Version 2, as published by Sam Hocevar.
+" See http://sam.zoy.org/wtfpl/COPYING for more details.
+"
+"============================================================================
+
+if exists('g:loaded_syntastic_plugin') || &compatible
+ finish
+endif
+let g:loaded_syntastic_plugin = 1
+
+if has('reltime')
+ let g:_SYNTASTIC_START = reltime()
+ lockvar! g:_SYNTASTIC_START
+endif
+
+let g:_SYNTASTIC_VERSION = '3.7.0-157'
+lockvar g:_SYNTASTIC_VERSION
+
+" Sanity checks {{{1
+
+if v:version < 700 || (v:version == 700 && !has('patch175'))
+ call syntastic#log#error('need Vim version 7.0.175 or later')
+ finish
+endif
+
+for s:feature in [
+ \ 'autocmd',
+ \ 'eval',
+ \ 'file_in_path',
+ \ 'modify_fname',
+ \ 'quickfix',
+ \ 'reltime',
+ \ 'user_commands'
+ \ ]
+ if !has(s:feature)
+ call syntastic#log#error('need Vim compiled with feature ' . s:feature)
+ finish
+ endif
+endfor
+
+let s:_running_windows = syntastic#util#isRunningWindows()
+lockvar s:_running_windows
+
+if !exists('g:syntastic_shell')
+ let g:syntastic_shell = &shell
+endif
+
+if s:_running_windows
+ let g:_SYNTASTIC_UNAME = 'Windows'
+elseif executable('uname')
+ try
+ let g:_SYNTASTIC_UNAME = split(syntastic#util#system('uname'), "\n")[0]
+ catch /\m^Vim\%((\a\+)\)\=:E484/
+ call syntastic#log#error("your shell " . syntastic#util#var('shell') . " can't handle traditional UNIX syntax for redirections")
+ finish
+ catch /\m^Vim\%((\a\+)\)\=:E684/
+ let g:_SYNTASTIC_UNAME = 'Unknown'
+ endtry
+else
+ let g:_SYNTASTIC_UNAME = 'Unknown'
+endif
+lockvar g:_SYNTASTIC_UNAME
+
+" }}}1
+
+" Defaults {{{1
+
+let g:_SYNTASTIC_DEFAULTS = {
+ \ 'aggregate_errors': 0,
+ \ 'always_populate_loc_list': 0,
+ \ 'auto_jump': 0,
+ \ 'auto_loc_list': 2,
+ \ 'check_on_open': 0,
+ \ 'check_on_wq': 1,
+ \ 'cursor_columns': 1,
+ \ 'debug': 0,
+ \ 'echo_current_error': 1,
+ \ 'enable_balloons': 1,
+ \ 'enable_highlighting': 1,
+ \ 'enable_signs': 1,
+ \ 'error_symbol': '>>',
+ \ 'exit_checks': !(s:_running_windows && syntastic#util#var('shell', &shell) =~? '\m\<cmd\.exe$'),
+ \ 'filetype_map': {},
+ \ 'full_redraws': !(has('gui_running') || has('gui_macvim')),
+ \ 'id_checkers': 1,
+ \ 'ignore_extensions': '\c\v^([gx]?z|lzma|bz2)$',
+ \ 'ignore_files': [],
+ \ 'loc_list_height': 10,
+ \ 'nested_autocommands': 0,
+ \ 'quiet_messages': {},
+ \ 'reuse_loc_lists': 1,
+ \ 'shell': &shell,
+ \ 'sort_aggregated_errors': 1,
+ \ 'stl_format': '[Syntax: line:%F (%t)]',
+ \ 'style_error_symbol': 'S>',
+ \ 'style_warning_symbol': 'S>',
+ \ 'warning_symbol': '>>'
+ \ }
+lockvar! g:_SYNTASTIC_DEFAULTS
+
+for s:key in keys(g:_SYNTASTIC_DEFAULTS)
+ if !exists('g:syntastic_' . s:key)
+ let g:syntastic_{s:key} = copy(g:_SYNTASTIC_DEFAULTS[s:key])
+ endif
+endfor
+
+if exists('g:syntastic_quiet_warnings')
+ call syntastic#log#oneTimeWarn("variable g:syntastic_quiet_warnings is deprecated, please use let g:syntastic_quiet_messages = {'level': 'warnings'} instead")
+ if g:syntastic_quiet_warnings
+ let s:quiet_warnings = get(g:syntastic_quiet_messages, 'type', [])
+ if type(s:quiet_warnings) != type([])
+ let s:quiet_warnings = [s:quiet_warnings]
+ endif
+ call add(s:quiet_warnings, 'warnings')
+ let g:syntastic_quiet_messages['type'] = s:quiet_warnings
+ endif
+endif
+
+" }}}1
+
+" Debug {{{1
+
+let s:_DEBUG_DUMP_OPTIONS = [
+ \ 'shell',
+ \ 'shellcmdflag',
+ \ 'shellpipe',
+ \ 'shellquote',
+ \ 'shellredir',
+ \ 'shellslash',
+ \ 'shelltemp',
+ \ 'shellxquote'
+ \ ]
+if exists('+shellxescape')
+ call add(s:_DEBUG_DUMP_OPTIONS, 'shellxescape')
+endif
+lockvar! s:_DEBUG_DUMP_OPTIONS
+
+" debug constants
+let g:_SYNTASTIC_DEBUG_TRACE = 1
+lockvar g:_SYNTASTIC_DEBUG_TRACE
+let g:_SYNTASTIC_DEBUG_LOCLIST = 2
+lockvar g:_SYNTASTIC_DEBUG_LOCLIST
+let g:_SYNTASTIC_DEBUG_NOTIFICATIONS = 4
+lockvar g:_SYNTASTIC_DEBUG_NOTIFICATIONS
+let g:_SYNTASTIC_DEBUG_AUTOCOMMANDS = 8
+lockvar g:_SYNTASTIC_DEBUG_AUTOCOMMANDS
+let g:_SYNTASTIC_DEBUG_VARIABLES = 16
+lockvar g:_SYNTASTIC_DEBUG_VARIABLES
+let g:_SYNTASTIC_DEBUG_CHECKERS = 32
+lockvar g:_SYNTASTIC_DEBUG_CHECKERS
+
+" }}}1
+
+runtime! plugin/syntastic/*.vim
+
+let s:registry = g:SyntasticRegistry.Instance()
+let s:notifiers = g:SyntasticNotifiers.Instance()
+let s:modemap = g:SyntasticModeMap.Instance()
+
+let s:_quit_pre = []
+
+" Commands {{{1
+
+" @vimlint(EVL103, 1, a:cursorPos)
+" @vimlint(EVL103, 1, a:cmdLine)
+" @vimlint(EVL103, 1, a:argLead)
+function! s:CompleteCheckerName(argLead, cmdLine, cursorPos) abort " {{{2
+ let checker_names = []
+ for ft in s:_resolve_filetypes([])
+ call extend(checker_names, s:registry.getNamesOfAvailableCheckers(ft))
+ endfor
+ return join(checker_names, "\n")
+endfunction " }}}2
+" @vimlint(EVL103, 0, a:cursorPos)
+" @vimlint(EVL103, 0, a:cmdLine)
+" @vimlint(EVL103, 0, a:argLead)
+
+
+" @vimlint(EVL103, 1, a:cursorPos)
+" @vimlint(EVL103, 1, a:cmdLine)
+" @vimlint(EVL103, 1, a:argLead)
+function! s:CompleteFiletypes(argLead, cmdLine, cursorPos) abort " {{{2
+ return join(s:registry.getKnownFiletypes(), "\n")
+endfunction " }}}2
+" @vimlint(EVL103, 0, a:cursorPos)
+" @vimlint(EVL103, 0, a:cmdLine)
+" @vimlint(EVL103, 0, a:argLead)
+
+command! -bar -nargs=* -complete=custom,s:CompleteCheckerName SyntasticCheck call SyntasticCheck(<f-args>)
+command! -bar -nargs=? -complete=custom,s:CompleteFiletypes SyntasticInfo call SyntasticInfo(<f-args>)
+command! -bar Errors call SyntasticErrors()
+command! -bar SyntasticReset call SyntasticReset()
+command! -bar SyntasticToggleMode call SyntasticToggleMode()
+command! -bar SyntasticSetLoclist call SyntasticSetLoclist()
+
+command! SyntasticJavacEditClasspath runtime! syntax_checkers/java/*.vim | SyntasticJavacEditClasspath
+command! SyntasticJavacEditConfig runtime! syntax_checkers/java/*.vim | SyntasticJavacEditConfig
+
+" }}}1
+
+" Public API {{{1
+
+function! SyntasticCheck(...) abort " {{{2
+ call s:UpdateErrors(0, a:000)
+ call syntastic#util#redraw(g:syntastic_full_redraws)
+endfunction " }}}2
+
+function! SyntasticInfo(...) abort " {{{2
+ call s:modemap.modeInfo(a:000)
+ call s:registry.echoInfoFor(s:_resolve_filetypes(a:000))
+ call s:_explain_skip(a:000)
+endfunction " }}}2
+
+function! SyntasticErrors() abort " {{{2
+ call g:SyntasticLoclist.current().show()
+endfunction " }}}2
+
+function! SyntasticReset() abort " {{{2
+ call s:ClearCache()
+ call s:notifiers.refresh(g:SyntasticLoclist.New([]))
+endfunction " }}}2
+
+function! SyntasticToggleMode() abort " {{{2
+ call s:modemap.toggleMode()
+ call s:ClearCache()
+ call s:notifiers.refresh(g:SyntasticLoclist.New([]))
+ call s:modemap.echoMode()
+endfunction " }}}2
+
+function! SyntasticSetLoclist() abort " {{{2
+ call g:SyntasticLoclist.current().setloclist()
+endfunction " }}}2
+
+" }}}1
+
+" Autocommands {{{1
+
+augroup syntastic
+ autocmd!
+ autocmd BufEnter * call s:BufEnterHook()
+augroup END
+
+if g:syntastic_nested_autocommands
+ augroup syntastic
+ autocmd BufReadPost * nested call s:BufReadPostHook()
+ autocmd BufWritePost * nested call s:BufWritePostHook()
+ augroup END
+else
+ augroup syntastic
+ autocmd BufReadPost * call s:BufReadPostHook()
+ autocmd BufWritePost * call s:BufWritePostHook()
+ augroup END
+endif
+
+if exists('##QuitPre')
+ " QuitPre was added in Vim 7.3.544
+ augroup syntastic
+ autocmd QuitPre * call s:QuitPreHook(expand('<amatch>', 1))
+ augroup END
+endif
+
+function! s:BufReadPostHook() abort " {{{2
+ if g:syntastic_check_on_open
+ call syntastic#log#debug(g:_SYNTASTIC_DEBUG_AUTOCOMMANDS,
+ \ 'autocmd: BufReadPost, buffer ' . bufnr('') . ' = ' . string(bufname(str2nr(bufnr('')))))
+ call s:UpdateErrors(1, [])
+ endif
+endfunction " }}}2
+
+function! s:BufWritePostHook() abort " {{{2
+ call syntastic#log#debug(g:_SYNTASTIC_DEBUG_AUTOCOMMANDS,
+ \ 'autocmd: BufWritePost, buffer ' . bufnr('') . ' = ' . string(bufname(str2nr(bufnr('')))))
+ call s:UpdateErrors(1, [])
+endfunction " }}}2
+
+function! s:BufEnterHook() abort " {{{2
+ call syntastic#log#debug(g:_SYNTASTIC_DEBUG_AUTOCOMMANDS,
+ \ 'autocmd: BufEnter, buffer ' . bufnr('') . ' = ' . string(bufname(str2nr(bufnr('')))) .
+ \ ', &buftype = ' . string(&buftype))
+ if &buftype ==# ''
+ call s:notifiers.refresh(g:SyntasticLoclist.current())
+ elseif &buftype ==# 'quickfix'
+ " TODO: this is needed because in recent versions of Vim lclose
+ " can no longer be called from BufWinLeave
+ " TODO: at this point there is no b:syntastic_loclist
+ let loclist = filter(copy(getloclist(0)), 'v:val["valid"] == 1')
+ let owner = str2nr(getbufvar(bufnr(''), 'syntastic_owner_buffer'))
+ let buffers = syntastic#util#unique(map(loclist, 'v:val["bufnr"]') + (owner ? [owner] : []))
+ if !empty(get(w:, 'syntastic_loclist_set', [])) && !empty(loclist) && empty(filter( buffers, 'syntastic#util#bufIsActive(v:val)' ))
+ call SyntasticLoclistHide()
+ endif
+ endif
+endfunction " }}}2
+
+function! s:QuitPreHook(fname) abort " {{{2
+ let buf = bufnr(fnameescape(a:fname))
+ call syntastic#log#debug(g:_SYNTASTIC_DEBUG_AUTOCOMMANDS, 'autocmd: QuitPre, buffer ' . buf . ' = ' . string(a:fname))
+
+ if !syntastic#util#var('check_on_wq')
+ call syntastic#util#setWids()
+ call add(s:_quit_pre, buf . '_' . getbufvar(buf, 'changetick') . '_' . w:syntastic_wid)
+ endif
+
+ if !empty(get(w:, 'syntastic_loclist_set', []))
+ call SyntasticLoclistHide()
+ endif
+endfunction " }}}2
+
+" }}}1
+
+" Main {{{1
+
+"refresh and redraw all the error info for this buf when saving or reading
+function! s:UpdateErrors(auto_invoked, checker_names) abort " {{{2
+ call syntastic#log#debugShowVariables(g:_SYNTASTIC_DEBUG_TRACE, 'version')
+ call syntastic#log#debugShowOptions(g:_SYNTASTIC_DEBUG_TRACE, s:_DEBUG_DUMP_OPTIONS)
+ call syntastic#log#debugDump(g:_SYNTASTIC_DEBUG_VARIABLES)
+ call syntastic#log#debug(g:_SYNTASTIC_DEBUG_TRACE, 'UpdateErrors' . (a:auto_invoked ? ' (auto)' : '') .
+ \ ': ' . (len(a:checker_names) ? join(a:checker_names) : 'default checkers'))
+
+ call s:modemap.synch()
+
+ if s:_skip_file()
+ return
+ endif
+
+ let run_checks = !a:auto_invoked || s:modemap.doAutoChecking()
+ if run_checks
+ call s:CacheErrors(a:checker_names)
+ call syntastic#util#setChangedtick()
+ else
+ if a:auto_invoked
+ return
+ endif
+ endif
+
+ let loclist = g:SyntasticLoclist.current()
+
+ if exists('*SyntasticCheckHook')
+ call SyntasticCheckHook(loclist.getRaw())
+ endif
+
+ " populate loclist and jump {{{3
+ let do_jump = syntastic#util#var('auto_jump') + 0
+ if do_jump == 2
+ let do_jump = loclist.getFirstError(1)
+ elseif do_jump == 3
+ let do_jump = loclist.getFirstError()
+ elseif 0 > do_jump || do_jump > 3
+ let do_jump = 0
+ endif
+
+ let w:syntastic_loclist_set = []
+ if syntastic#util#var('always_populate_loc_list') || do_jump
+ call syntastic#log#debug(g:_SYNTASTIC_DEBUG_NOTIFICATIONS, 'loclist: setloclist (new)')
+ call setloclist(0, loclist.getRaw())
+ if !exists('b:syntastic_changedtick')
+ call syntastic#util#setChangedtick()
+ endif
+ let w:syntastic_loclist_set = [bufnr(''), b:syntastic_changedtick]
+ if run_checks && do_jump && !loclist.isEmpty()
+ call syntastic#log#debug(g:_SYNTASTIC_DEBUG_NOTIFICATIONS, 'loclist: jump')
+ execute 'silent! lrewind ' . do_jump
+
+ " XXX: Vim doesn't call autocmd commands in a predictible
+ " order, which can lead to missing filetype when jumping
+ " to a new file; the following is a workaround for the
+ " resulting brain damage
+ if &filetype ==# ''
+ silent! filetype detect
+ endif
+ endif
+ endif
+ " }}}3
+
+ call s:notifiers.refresh(loclist)
+endfunction " }}}2
+
+"clear the loc list for the buffer
+function! s:ClearCache() abort " {{{2
+ call s:notifiers.reset(g:SyntasticLoclist.current())
+ call b:syntastic_loclist.destroy()
+endfunction " }}}2
+
+"detect and cache all syntax errors in this buffer
+function! s:CacheErrors(checker_names) abort " {{{2
+ call syntastic#log#debug(g:_SYNTASTIC_DEBUG_TRACE, 'CacheErrors: ' .
+ \ (len(a:checker_names) ? join(a:checker_names) : 'default checkers'))
+ call s:ClearCache()
+ let newLoclist = g:SyntasticLoclist.New([])
+
+ if !s:_skip_file()
+ " debug logging {{{3
+ call syntastic#log#debugShowVariables(g:_SYNTASTIC_DEBUG_TRACE, 'aggregate_errors')
+ call syntastic#log#debug(g:_SYNTASTIC_DEBUG_CHECKERS, '$PATH = ' . string($PATH))
+ call syntastic#log#debug(g:_SYNTASTIC_DEBUG_TRACE, 'getcwd() = ' . string(getcwd()))
+ " }}}3
+
+ let filetypes = s:_resolve_filetypes([])
+ let aggregate_errors = syntastic#util#var('aggregate_errors') || len(filetypes) > 1
+ let decorate_errors = aggregate_errors && syntastic#util#var('id_checkers')
+ let sort_aggregated_errors = aggregate_errors && syntastic#util#var('sort_aggregated_errors')
+
+ let clist = []
+ for type in filetypes
+ call extend(clist, s:registry.getCheckers(type, a:checker_names))
+ endfor
+
+ let names = []
+ let unavailable_checkers = 0
+ for checker in clist
+ let cname = checker.getFiletype() . '/' . checker.getName()
+ if !checker.isAvailable()
+ call syntastic#log#debug(g:_SYNTASTIC_DEBUG_TRACE, 'CacheErrors: Checker ' . cname . ' is not available')
+ let unavailable_checkers += 1
+ continue
+ endif
+
+ call syntastic#log#debug(g:_SYNTASTIC_DEBUG_TRACE, 'CacheErrors: Invoking checker: ' . cname)
+
+ let loclist = checker.getLocList()
+
+ if !loclist.isEmpty()
+ if decorate_errors
+ call loclist.decorate(cname)
+ endif
+ call add(names, cname)
+ if checker.wantSort() && !sort_aggregated_errors
+ call loclist.sort()
+ call syntastic#log#debug(g:_SYNTASTIC_DEBUG_LOCLIST, 'sorted:', loclist)
+ endif
+
+ let newLoclist = newLoclist.extend(loclist)
+
+ if !aggregate_errors
+ break
+ endif
+ endif
+ endfor
+
+ " set names {{{3
+ if !empty(names)
+ if len(syntastic#util#unique(map( copy(names), 'substitute(v:val, "\\m/.*", "", "")' ))) == 1
+ let type = substitute(names[0], '\m/.*', '', '')
+ let name = join(map( names, 'substitute(v:val, "\\m.\\{-}/", "", "")' ), ', ')
+ call newLoclist.setName( name . ' ('. type . ')' )
+ else
+ " checkers from mixed types
+ call newLoclist.setName(join(names, ', '))
+ endif
+ endif
+ " }}}3
+
+ " issue warning about no active checkers {{{3
+ if len(clist) == unavailable_checkers
+ if !empty(a:checker_names)
+ if len(a:checker_names) == 1
+ call syntastic#log#warn('checker ' . a:checker_names[0] . ' is not available')
+ else
+ call syntastic#log#warn('checkers ' . join(a:checker_names, ', ') . ' are not available')
+ endif
+ else
+ call syntastic#log#debug(g:_SYNTASTIC_DEBUG_TRACE, 'CacheErrors: no checkers available for ' . &filetype)
+ endif
+ endif
+ " }}}3
+
+ call syntastic#log#debug(g:_SYNTASTIC_DEBUG_LOCLIST, 'aggregated:', newLoclist)
+ if sort_aggregated_errors
+ call newLoclist.sort()
+ call syntastic#log#debug(g:_SYNTASTIC_DEBUG_LOCLIST, 'sorted:', newLoclist)
+ endif
+ endif
+
+ call newLoclist.deploy()
+endfunction " }}}2
+
+"Emulates the :lmake command. Sets up the make environment according to the
+"options given, runs make, resets the environment, returns the location list
+"
+"a:options can contain the following keys:
+" 'makeprg'
+" 'errorformat'
+"
+"The corresponding options are set for the duration of the function call. They
+"are set with :let, so dont escape spaces.
+"
+"a:options may also contain:
+" 'defaults' - a dict containing default values for the returned errors
+" 'subtype' - all errors will be assigned the given subtype
+" 'preprocess' - a function to be applied to the error file before parsing errors
+" 'postprocess' - a list of functions to be applied to the error list
+" 'cwd' - change directory to the given path before running the checker
+" 'env' - environment variables to set before running the checker
+" 'returns' - a list of valid exit codes for the checker
+" @vimlint(EVL102, 1, l:env_save)
+function! SyntasticMake(options) abort " {{{2
+ call syntastic#log#debug(g:_SYNTASTIC_DEBUG_TRACE, 'SyntasticMake: called with options:', a:options)
+
+ " save options and locale env variables {{{3
+ let old_local_errorformat = &l:errorformat
+ let old_errorformat = &errorformat
+ let old_cwd = getcwd()
+ " }}}3
+
+ if has_key(a:options, 'errorformat')
+ let &errorformat = a:options['errorformat']
+ set errorformat<
+ endif
+
+ if has_key(a:options, 'cwd')
+ execute 'lcd ' . fnameescape(a:options['cwd'])
+ endif
+
+ " set environment variables {{{3
+ let env_save = {}
+ if has_key(a:options, 'env') && len(a:options['env'])
+ for key in keys(a:options['env'])
+ if key =~? '\m^[a-z_][a-z0-9_]*$'
+ execute 'let env_save[' . string(key) . '] = $' . key
+ execute 'let $' . key . ' = ' . string(a:options['env'][key])
+ endif
+ endfor
+ endif
+ " }}}3
+
+ let err_lines = split(syntastic#util#system(a:options['makeprg']), "\n", 1)
+
+ " restore environment variables {{{3
+ if len(env_save)
+ for key in keys(env_save)
+ execute 'let $' . key . ' = ' . string(env_save[key])
+ endfor
+ endif
+ " }}}3
+
+ call syntastic#log#debug(g:_SYNTASTIC_DEBUG_LOCLIST, 'checker output:', err_lines)
+
+ " Does it still make sense to go on?
+ let bailout =
+ \ syntastic#util#var('exit_checks') &&
+ \ has_key(a:options, 'returns') &&
+ \ index(a:options['returns'], v:shell_error) == -1
+
+ if !bailout
+ if has_key(a:options, 'Preprocess')
+ let err_lines = call(a:options['Preprocess'], [err_lines])
+ call syntastic#log#debug(g:_SYNTASTIC_DEBUG_LOCLIST, 'preprocess (external):', err_lines)
+ elseif has_key(a:options, 'preprocess')
+ let err_lines = call('syntastic#preprocess#' . a:options['preprocess'], [err_lines])
+ call syntastic#log#debug(g:_SYNTASTIC_DEBUG_LOCLIST, 'preprocess:', err_lines)
+ endif
+ lgetexpr err_lines
+
+ let errors = deepcopy(getloclist(0))
+
+ if has_key(a:options, 'cwd')
+ execute 'lcd ' . fnameescape(old_cwd)
+ endif
+
+ try
+ silent lolder
+ catch /\m^Vim\%((\a\+)\)\=:E380/
+ " E380: At bottom of quickfix stack
+ call setloclist(0, [], 'r')
+ catch /\m^Vim\%((\a\+)\)\=:E776/
+ " E776: No location list
+ " do nothing
+ endtry
+ else
+ let errors = []
+ endif
+
+ " restore options {{{3
+ let &errorformat = old_errorformat
+ let &l:errorformat = old_local_errorformat
+ " }}}3
+
+ if !s:_running_windows && (s:_os_name() =~? 'FreeBSD' || s:_os_name() =~? 'OpenBSD')
+ call syntastic#util#redraw(g:syntastic_full_redraws)
+ endif
+
+ if bailout
+ call syntastic#log#ndebug(g:_SYNTASTIC_DEBUG_LOCLIST, 'checker output:', err_lines)
+ throw 'Syntastic: checker error'
+ endif
+
+ call syntastic#log#debug(g:_SYNTASTIC_DEBUG_LOCLIST, 'raw loclist:', errors)
+
+ if has_key(a:options, 'defaults')
+ call s:_add_to_errors(errors, a:options['defaults'])
+ endif
+
+ " Add subtype info if present.
+ if has_key(a:options, 'subtype')
+ call s:_add_to_errors(errors, { 'subtype': a:options['subtype'] })
+ endif
+
+ if has_key(a:options, 'Postprocess') && !empty(a:options['Postprocess'])
+ for rule in a:options['Postprocess']
+ let errors = call(rule, [errors])
+ endfor
+ call syntastic#log#debug(g:_SYNTASTIC_DEBUG_LOCLIST, 'postprocess (external):', errors)
+ elseif has_key(a:options, 'postprocess') && !empty(a:options['postprocess'])
+ for rule in a:options['postprocess']
+ let errors = call('syntastic#postprocess#' . rule, [errors])
+ endfor
+ call syntastic#log#debug(g:_SYNTASTIC_DEBUG_LOCLIST, 'postprocess:', errors)
+ endif
+
+ return errors
+endfunction " }}}2
+" @vimlint(EVL102, 0, l:env_save)
+
+"return a string representing the state of buffer according to
+"g:syntastic_stl_format
+"
+"return '' if no errors are cached for the buffer
+function! SyntasticStatuslineFlag() abort " {{{2
+ return g:SyntasticLoclist.current().getStatuslineFlag()
+endfunction " }}}2
+
+" }}}1
+
+" Utilities {{{1
+
+function! s:_resolve_filetypes(filetypes) abort " {{{2
+ let type = len(a:filetypes) ? a:filetypes[0] : &filetype
+ return split( get(g:syntastic_filetype_map, type, type), '\m\.' )
+endfunction " }}}2
+
+function! s:_ignore_file(filename) abort " {{{2
+ let fname = fnamemodify(a:filename, ':p')
+ for pattern in g:syntastic_ignore_files
+ if fname =~# pattern
+ return 1
+ endif
+ endfor
+ return 0
+endfunction " }}}2
+
+function! s:_is_quitting(buf) abort " {{{2
+ let quitting = 0
+ if exists('w:syntastic_wid')
+ let key = a:buf . '_' . getbufvar(a:buf, 'changetick') . '_' . w:syntastic_wid
+ let idx = index(s:_quit_pre, key)
+ if idx >= 0
+ call remove(s:_quit_pre, idx)
+ let quitting = 1
+ endif
+ endif
+
+ return quitting
+endfunction " }}}2
+
+" Skip running in special buffers
+function! s:_skip_file() abort " {{{2
+ let fname = expand('%', 1)
+ let skip = s:_is_quitting(bufnr('%')) || get(b:, 'syntastic_skip_checks', 0) ||
+ \ (&buftype !=# '') || !filereadable(fname) || getwinvar(0, '&diff') ||
+ \ getwinvar(0, '&previewwindow') || s:_ignore_file(fname) ||
+ \ fnamemodify(fname, ':e') =~? g:syntastic_ignore_extensions
+ if skip
+ call syntastic#log#debug(g:_SYNTASTIC_DEBUG_TRACE, '_skip_file: skipping checks')
+ endif
+ return skip
+endfunction " }}}2
+
+" Explain why checks will be skipped for the current file
+function! s:_explain_skip(filetypes) abort " {{{2
+ if empty(a:filetypes) && s:_skip_file()
+ let why = []
+ let fname = expand('%', 1)
+
+ if s:_is_quitting(bufnr('%'))
+ call add(why, 'quitting buffer')
+ endif
+ if get(b:, 'syntastic_skip_checks', 0)
+ call add(why, 'b:syntastic_skip_checks set')
+ endif
+ if &buftype !=# ''
+ call add(why, 'buftype = ' . string(&buftype))
+ endif
+ if !filereadable(fname)
+ call add(why, 'file not readable / not local')
+ endif
+ if getwinvar(0, '&diff')
+ call add(why, 'diff mode')
+ endif
+ if getwinvar(0, '&previewwindow')
+ call add(why, 'preview window')
+ endif
+ if s:_ignore_file(fname)
+ call add(why, 'filename matching g:syntastic_ignore_files')
+ endif
+ if fnamemodify(fname, ':e') =~? g:syntastic_ignore_extensions
+ call add(why, 'extension matching g:syntastic_ignore_extensions')
+ endif
+
+ echomsg 'The current file will not be checked (' . join(why, ', ') . ')'
+ endif
+endfunction " }}}2
+
+" Take a list of errors and add default values to them from a:options
+function! s:_add_to_errors(errors, options) abort " {{{2
+ for err in a:errors
+ for key in keys(a:options)
+ if !has_key(err, key) || empty(err[key])
+ let err[key] = a:options[key]
+ endif
+ endfor
+ endfor
+
+ return a:errors
+endfunction " }}}2
+
+function! s:_os_name() abort " {{{2
+ return g:_SYNTASTIC_UNAME
+endfunction " }}}2
+
+" }}}1
+
+" vim: set sw=4 sts=4 et fdm=marker:
diff --git a/vim/bundle/syntastic/plugin/syntastic/autoloclist.vim b/vim/bundle/syntastic/plugin/syntastic/autoloclist.vim
new file mode 100644
index 0000000..153b0bc
--- /dev/null
+++ b/vim/bundle/syntastic/plugin/syntastic/autoloclist.vim
@@ -0,0 +1,38 @@
+if exists('g:loaded_syntastic_notifier_autoloclist') || !exists('g:loaded_syntastic_plugin')
+ finish
+endif
+let g:loaded_syntastic_notifier_autoloclist = 1
+
+let g:SyntasticAutoloclistNotifier = {}
+
+" Public methods {{{1
+"
+function! g:SyntasticAutoloclistNotifier.New() abort " {{{2
+ let newObj = copy(self)
+ return newObj
+endfunction " }}}2
+
+function! g:SyntasticAutoloclistNotifier.refresh(loclist) abort " {{{2
+ call syntastic#log#debug(g:_SYNTASTIC_DEBUG_NOTIFICATIONS, 'autoloclist: refresh')
+ call g:SyntasticAutoloclistNotifier.AutoToggle(a:loclist)
+endfunction " }}}2
+
+function! g:SyntasticAutoloclistNotifier.AutoToggle(loclist) abort " {{{2
+ call syntastic#log#debug(g:_SYNTASTIC_DEBUG_NOTIFICATIONS, 'autoloclist: toggle')
+ let auto_loc_list = syntastic#util#var('auto_loc_list')
+ if !a:loclist.isEmpty()
+ if auto_loc_list == 1 || auto_loc_list == 3
+ call a:loclist.show()
+ endif
+ else
+ if auto_loc_list == 1 || auto_loc_list == 2
+ "TODO: this will close the loc list window if one was opened by
+ "something other than syntastic
+ lclose
+ endif
+ endif
+endfunction " }}}2
+
+" }}}1
+
+" vim: set sw=4 sts=4 et fdm=marker:
diff --git a/vim/bundle/syntastic/plugin/syntastic/balloons.vim b/vim/bundle/syntastic/plugin/syntastic/balloons.vim
new file mode 100644
index 0000000..fdd70bf
--- /dev/null
+++ b/vim/bundle/syntastic/plugin/syntastic/balloons.vim
@@ -0,0 +1,59 @@
+if exists('g:loaded_syntastic_notifier_balloons') || !exists('g:loaded_syntastic_plugin')
+ finish
+endif
+let g:loaded_syntastic_notifier_balloons = 1
+
+if !has('balloon_eval')
+ let g:syntastic_enable_balloons = 0
+endif
+
+let g:SyntasticBalloonsNotifier = {}
+
+" Public methods {{{1
+
+function! g:SyntasticBalloonsNotifier.New() abort " {{{2
+ let newObj = copy(self)
+ return newObj
+endfunction " }}}2
+
+function! g:SyntasticBalloonsNotifier.enabled() abort " {{{2
+ return has('balloon_eval') && syntastic#util#var('enable_balloons')
+endfunction " }}}2
+
+" Update the error balloons
+function! g:SyntasticBalloonsNotifier.refresh(loclist) abort " {{{2
+ unlet! b:syntastic_private_balloons
+ if self.enabled() && !a:loclist.isEmpty()
+ let b:syntastic_private_balloons = a:loclist.balloons()
+ if !empty(b:syntastic_private_balloons)
+ set ballooneval balloonexpr=SyntasticBalloonsExprNotifier()
+ endif
+ endif
+endfunction " }}}2
+
+" Reset the error balloons
+" @vimlint(EVL103, 1, a:loclist)
+function! g:SyntasticBalloonsNotifier.reset(loclist) abort " {{{2
+ let b:syntastic_private_balloons = {}
+ if has('balloon_eval')
+ call syntastic#log#debug(g:_SYNTASTIC_DEBUG_NOTIFICATIONS, 'balloons: reset')
+ unlet! b:syntastic_private_balloons
+ set noballooneval
+ endif
+endfunction " }}}2
+" @vimlint(EVL103, 0, a:loclist)
+
+" }}}1
+
+" Private functions {{{1
+
+function! SyntasticBalloonsExprNotifier() abort " {{{2
+ if !exists('b:syntastic_private_balloons')
+ return ''
+ endif
+ return get(b:syntastic_private_balloons, v:beval_lnum, '')
+endfunction " }}}2
+
+" }}}1
+
+" vim: set sw=4 sts=4 et fdm=marker:
diff --git a/vim/bundle/syntastic/plugin/syntastic/checker.vim b/vim/bundle/syntastic/plugin/syntastic/checker.vim
new file mode 100644
index 0000000..22ad820
--- /dev/null
+++ b/vim/bundle/syntastic/plugin/syntastic/checker.vim
@@ -0,0 +1,273 @@
+if exists('g:loaded_syntastic_checker') || !exists('g:loaded_syntastic_plugin')
+ finish
+endif
+let g:loaded_syntastic_checker = 1
+
+let g:SyntasticChecker = {}
+
+" Public methods {{{1
+
+function! g:SyntasticChecker.New(args, ...) abort " {{{2
+ let newObj = copy(self)
+
+ let newObj._filetype = a:args['filetype']
+ let newObj._name = a:args['name']
+
+ if a:0
+ " redirected checker
+ let newObj._exec = get(a:args, 'exec', a:1['_exec'])
+
+ let filetype = a:1['_filetype']
+ let name = a:1['_name']
+ let prefix = 'SyntaxCheckers_' . filetype . '_' . name . '_'
+
+ if exists('g:syntastic_' . filetype . '_' . name . '_sort') && !exists('g:syntastic_' . newObj._filetype . '_' . newObj._name . '_sort')
+ let g:syntastic_{newObj._filetype}_{newObj._name}_sort = g:syntastic_{filetype}_{name}_sort
+ endif
+
+ if has_key(a:args, 'enable')
+ let newObj._enable = a:args['enable']
+ elseif has_key(a:1, '_enable')
+ let newObj._enable = a:1['_enable']
+ endif
+ else
+ let newObj._exec = get(a:args, 'exec', newObj._name)
+ let prefix = 'SyntaxCheckers_' . newObj._filetype . '_' . newObj._name . '_'
+
+ if has_key(a:args, 'enable')
+ let newObj._enable = a:args['enable']
+ endif
+ endif
+
+ let newObj._locListFunc = function(prefix . 'GetLocList')
+
+ if exists('*' . prefix . 'IsAvailable')
+ let newObj._isAvailableFunc = function(prefix . 'IsAvailable')
+ else
+ let newObj._isAvailableFunc = function('s:_isAvailableDefault')
+ endif
+
+ if exists('*' . prefix . 'GetHighlightRegex')
+ let newObj._highlightRegexFunc = function(prefix . 'GetHighlightRegex')
+ endif
+
+ return newObj
+endfunction " }}}2
+
+function! g:SyntasticChecker.getFiletype() abort " {{{2
+ return self._filetype
+endfunction " }}}2
+
+function! g:SyntasticChecker.getName() abort " {{{2
+ return self._name
+endfunction " }}}2
+
+" Synchronise _exec with user's setting. Force re-validation if needed.
+"
+" XXX: This function must be called at least once before calling either
+" getExec() or getExecEscaped(). Normally isAvailable() does that for you
+" automatically, but you should keep still this in mind if you change the
+" current checker workflow.
+function! g:SyntasticChecker.syncExec() abort " {{{2
+ let user_exec =
+ \ expand( exists('b:syntastic_' . self._name . '_exec') ? b:syntastic_{self._name}_exec :
+ \ syntastic#util#var(self._filetype . '_' . self._name . '_exec'), 1 )
+
+ if user_exec !=# '' && user_exec !=# self._exec
+ let self._exec = user_exec
+ if has_key(self, '_available')
+ " we have a new _exec on the block, it has to be validated
+ call remove(self, '_available')
+ endif
+ endif
+endfunction " }}}2
+
+function! g:SyntasticChecker.getExec() abort " {{{2
+ return self._exec
+endfunction " }}}2
+
+function! g:SyntasticChecker.getExecEscaped() abort " {{{2
+ return syntastic#util#shescape(self._exec)
+endfunction " }}}2
+
+function! g:SyntasticChecker.getLocListRaw() abort " {{{2
+ let checker_start = reltime()
+ let name = self._filetype . '/' . self._name
+
+ if has_key(self, '_enable')
+ let status = syntastic#util#var(self._enable, -1)
+ if type(status) != type(0)
+ call syntastic#log#error('checker ' . name . ': invalid value ' . strtrans(string(status)) .
+ \ ' for g:syntastic_' . self._enable . '; try 0 or 1 instead')
+ return []
+ endif
+ if status < 0
+ call syntastic#log#error('checker ' . name . ': checks disabled for security reasons; ' .
+ \ 'set g:syntastic_' . self._enable . ' to 1 to override')
+ endif
+ if status <= 0
+ call syntastic#log#debug(g:_SYNTASTIC_DEBUG_TRACE, 'getLocList: checker ' . name . ' enabled but not forced')
+ return []
+ else
+ call syntastic#log#debug(g:_SYNTASTIC_DEBUG_TRACE, 'getLocList: checker ' . name . ' forced')
+ endif
+ endif
+
+ try
+ let list = self._locListFunc()
+ if self._exec !=# ''
+ call syntastic#log#debug(g:_SYNTASTIC_DEBUG_TRACE, 'getLocList: checker ' . name . ' returned ' . v:shell_error)
+ endif
+ catch /\m\C^Syntastic: checker error$/
+ let list = []
+ if self._exec !=# ''
+ call syntastic#log#error('checker ' . name . ' returned abnormal status ' . v:shell_error)
+ else
+ call syntastic#log#error('checker ' . name . ' aborted')
+ endif
+ endtry
+ call self._populateHighlightRegexes(list)
+ call syntastic#log#debug(g:_SYNTASTIC_DEBUG_LOCLIST, name . ' raw:', list)
+ call self._quietMessages(list)
+ call syntastic#log#debug(g:_SYNTASTIC_DEBUG_TRACE,
+ \ 'getLocList: checker ' . name . ' run in ' . split(reltimestr(reltime(checker_start)))[0] . 's')
+ return list
+endfunction " }}}2
+
+function! g:SyntasticChecker.getLocList() abort " {{{2
+ return g:SyntasticLoclist.New(self.getLocListRaw())
+endfunction " }}}2
+
+function! g:SyntasticChecker.getVersion(...) abort " {{{2
+ if !exists('self._version')
+ let command = a:0 ? a:1 : self.getExecEscaped() . ' --version'
+ let version_output = syntastic#util#system(command)
+ call self.log('getVersion: ' . string(command) . ': ' .
+ \ string(split(version_output, "\n", 1)) .
+ \ (v:shell_error ? ' (exit code ' . v:shell_error . ')' : '') )
+ let parsed_ver = syntastic#util#parseVersion(version_output)
+ if len(parsed_ver)
+ call self.setVersion(parsed_ver)
+ else
+ call syntastic#log#ndebug(g:_SYNTASTIC_DEBUG_LOCLIST, 'checker output:', split(version_output, "\n", 1))
+ call syntastic#log#error("checker " . self._filetype . "/" . self._name . ": can't parse version string (abnormal termination?)")
+ endif
+ endif
+ return get(self, '_version', [])
+endfunction " }}}2
+
+function! g:SyntasticChecker.setVersion(version) abort " {{{2
+ if len(a:version)
+ let self._version = copy(a:version)
+ call self.log(self.getExec() . ' version =', a:version)
+ endif
+endfunction " }}}2
+
+function! g:SyntasticChecker.log(msg, ...) abort " {{{2
+ let leader = self._filetype . '/' . self._name . ': '
+ if a:0 > 0
+ call syntastic#log#debug(g:_SYNTASTIC_DEBUG_CHECKERS, leader . a:msg, a:1)
+ else
+ call syntastic#log#debug(g:_SYNTASTIC_DEBUG_CHECKERS, leader . a:msg)
+ endif
+endfunction " }}}2
+
+function! g:SyntasticChecker.makeprgBuild(opts) abort " {{{2
+ let basename = self._filetype . '_' . self._name . '_'
+
+ let parts = []
+ call extend(parts, self._getOpt(a:opts, basename, 'exe', self.getExecEscaped()))
+ call extend(parts, self._getOpt(a:opts, basename, 'args', ''))
+ call extend(parts, self._getOpt(a:opts, basename, 'fname', syntastic#util#shexpand('%')))
+ call extend(parts, self._getOpt(a:opts, basename, 'post_args', ''))
+ call extend(parts, self._getOpt(a:opts, basename, 'tail', ''))
+
+ return join(parts)
+endfunction " }}}2
+
+function! g:SyntasticChecker.isAvailable() abort " {{{2
+ call self.syncExec()
+ if !has_key(self, '_available')
+ let self._available = self._isAvailableFunc()
+ endif
+ return self._available
+endfunction " }}}2
+
+function! g:SyntasticChecker.isDisabled() abort " {{{2
+ return has_key(self, '_enable') && syntastic#util#var(self._enable, -1) <= 0
+endfunction " }}}2
+
+function! g:SyntasticChecker.wantSort() abort " {{{2
+ return syntastic#util#var(self._filetype . '_' . self._name . '_sort', 0)
+endfunction " }}}2
+
+" This method is no longer used by syntastic. It's here only to maintain
+" backwards compatibility with external checkers which might depend on it.
+function! g:SyntasticChecker.setWantSort(val) abort " {{{2
+ if !exists('g:syntastic_' . self._filetype . '_' . self._name . '_sort')
+ let g:syntastic_{self._filetype}_{self._name}_sort = a:val
+ endif
+endfunction " }}}2
+
+" }}}1
+
+" Private methods {{{1
+
+function! g:SyntasticChecker._quietMessages(errors) abort " {{{2
+ " wildcard quiet_messages
+ let quiet_filters = copy(syntastic#util#var('quiet_messages', {}))
+ if type(quiet_filters) != type({})
+ call syntastic#log#warn('ignoring invalid syntastic_quiet_messages')
+ unlet quiet_filters
+ let quiet_filters = {}
+ endif
+
+ " per checker quiet_messages
+ let name = self._filetype . '_' . self._name
+ try
+ call extend( quiet_filters, copy(syntastic#util#var(name . '_quiet_messages', {})), 'force' )
+ catch /\m^Vim\%((\a\+)\)\=:E712/
+ call syntastic#log#warn('ignoring invalid syntastic_' . name . '_quiet_messages')
+ endtry
+
+ call syntastic#log#debug(g:_SYNTASTIC_DEBUG_LOCLIST, 'quiet_messages filter:', quiet_filters)
+
+ if !empty(quiet_filters)
+ call syntastic#util#dictFilter(a:errors, quiet_filters)
+ call syntastic#log#debug(g:_SYNTASTIC_DEBUG_LOCLIST, 'filtered by quiet_messages:', a:errors)
+ endif
+endfunction " }}}2
+
+function! g:SyntasticChecker._populateHighlightRegexes(errors) abort " {{{2
+ if has_key(self, '_highlightRegexFunc')
+ for e in a:errors
+ if e['valid']
+ let term = self._highlightRegexFunc(e)
+ if term !=# ''
+ let e['hl'] = term
+ endif
+ endif
+ endfor
+ endif
+endfunction " }}}2
+
+function! g:SyntasticChecker._getOpt(opts, basename, name, default) abort " {{{2
+ let ret = []
+ call extend( ret, syntastic#util#argsescape(get(a:opts, a:name . '_before', '')) )
+ call extend( ret, syntastic#util#argsescape(syntastic#util#var( a:basename . a:name, get(a:opts, a:name, a:default) )) )
+ call extend( ret, syntastic#util#argsescape(get(a:opts, a:name . '_after', '')) )
+
+ return ret
+endfunction " }}}2
+
+" }}}1
+
+" Private functions {{{1
+
+function! s:_isAvailableDefault() dict " {{{2
+ return executable(self.getExec())
+endfunction " }}}2
+
+" }}}1
+
+" vim: set sw=4 sts=4 et fdm=marker:
diff --git a/vim/bundle/syntastic/plugin/syntastic/cursor.vim b/vim/bundle/syntastic/plugin/syntastic/cursor.vim
new file mode 100644
index 0000000..f59d87b
--- /dev/null
+++ b/vim/bundle/syntastic/plugin/syntastic/cursor.vim
@@ -0,0 +1,138 @@
+if exists('g:loaded_syntastic_notifier_cursor') || !exists('g:loaded_syntastic_plugin')
+ finish
+endif
+let g:loaded_syntastic_notifier_cursor = 1
+
+let g:SyntasticCursorNotifier = {}
+
+" Public methods {{{1
+
+function! g:SyntasticCursorNotifier.New() abort " {{{2
+ let newObj = copy(self)
+ return newObj
+endfunction " }}}2
+
+function! g:SyntasticCursorNotifier.enabled() abort " {{{2
+ return syntastic#util#var('echo_current_error')
+endfunction " }}}2
+
+function! g:SyntasticCursorNotifier.refresh(loclist) abort " {{{2
+ if self.enabled() && !a:loclist.isEmpty()
+ call syntastic#log#debug(g:_SYNTASTIC_DEBUG_NOTIFICATIONS, 'cursor: refresh')
+ let b:syntastic_private_messages = copy(a:loclist.messages(bufnr('')))
+ let b:syntastic_private_line = -1
+ let b:syntastic_cursor_columns = a:loclist.getCursorColumns()
+ autocmd! syntastic CursorMoved
+ autocmd syntastic CursorMoved * call SyntasticRefreshCursor()
+ endif
+endfunction " }}}2
+
+" @vimlint(EVL103, 1, a:loclist)
+function! g:SyntasticCursorNotifier.reset(loclist) abort " {{{2
+ call syntastic#log#debug(g:_SYNTASTIC_DEBUG_NOTIFICATIONS, 'cursor: reset')
+ autocmd! syntastic CursorMoved
+ unlet! b:syntastic_private_messages
+ let b:syntastic_private_line = -1
+endfunction " }}}2
+" @vimlint(EVL103, 0, a:loclist)
+
+" }}}1
+
+" Private functions {{{1
+
+function! SyntasticRefreshCursor() abort " {{{2
+ if !exists('b:syntastic_private_messages') || empty(b:syntastic_private_messages)
+ " file not checked
+ return
+ endif
+
+ if !exists('b:syntastic_private_line')
+ let b:syntastic_private_line = -1
+ endif
+ let l = line('.')
+ let current_messages = get(b:syntastic_private_messages, l, {})
+
+ if !exists('b:syntastic_cursor_columns')
+ let b:syntastic_cursor_columns = g:syntastic_cursor_columns
+ endif
+
+ if b:syntastic_cursor_columns
+ let c = virtcol('.')
+ if !exists('b:syntastic_private_idx')
+ let b:syntastic_private_idx = -1
+ endif
+
+ if s:_is_same_index(l, b:syntastic_private_line, c, b:syntastic_private_idx, current_messages)
+ return
+ else
+ let b:syntastic_private_line = l
+ endif
+
+ if !empty(current_messages)
+ let b:syntastic_private_idx = s:_find_index(c, current_messages)
+ call syntastic#util#wideMsg(current_messages[b:syntastic_private_idx].text)
+ else
+ let b:syntastic_private_idx = -1
+ echo
+ endif
+ else
+ if l == b:syntastic_private_line
+ return
+ endif
+ let b:syntastic_private_line = l
+
+ if !empty(current_messages)
+ call syntastic#util#wideMsg(current_messages[0].text)
+ else
+ echo
+ endif
+ endif
+endfunction " }}}2
+
+" }}}1
+
+" Utilities {{{1
+
+function! s:_is_same_index(line, old_line, column, idx, messages) abort " {{{2
+ if a:old_line >= 0 && a:line == a:old_line && a:idx >= 0
+ if len(a:messages) <= 1
+ return 1
+ endif
+
+ if a:messages[a:idx].scol <= a:column || a:idx == 0
+ if a:idx == len(a:messages) - 1 || a:column < a:messages[a:idx + 1].scol
+ return 1
+ else
+ return 0
+ endif
+ else
+ return 0
+ endif
+ else
+ return 0
+ endif
+endfunction " }}}2
+
+function! s:_find_index(column, messages) abort " {{{2
+ let max = len(a:messages) - 1
+ if max == 0
+ return 0
+ endif
+ let min = 0
+
+ " modified binary search: assign index 0 to columns to the left of the first error
+ while min < max - 1
+ let mid = (min + max) / 2
+ if a:column < a:messages[mid].scol
+ let max = mid
+ else
+ let min = mid
+ endif
+ endwhile
+
+ return a:column < a:messages[max].scol ? min : max
+endfunction " }}}2
+
+" }}}1
+
+" vim: set sw=4 sts=4 et fdm=marker:
diff --git a/vim/bundle/syntastic/plugin/syntastic/highlighting.vim b/vim/bundle/syntastic/plugin/syntastic/highlighting.vim
new file mode 100644
index 0000000..a9e1a08
--- /dev/null
+++ b/vim/bundle/syntastic/plugin/syntastic/highlighting.vim
@@ -0,0 +1,104 @@
+if exists('g:loaded_syntastic_notifier_highlighting') || !exists('g:loaded_syntastic_plugin')
+ finish
+endif
+let g:loaded_syntastic_notifier_highlighting = 1
+
+" Highlighting requires getmatches introduced in 7.1.040
+let s:has_highlighting = v:version > 701 || (v:version == 701 && has('patch040'))
+lockvar s:has_highlighting
+
+let g:SyntasticHighlightingNotifier = {}
+
+let s:setup_done = 0
+
+" Public methods {{{1
+
+function! g:SyntasticHighlightingNotifier.New() abort " {{{2
+ let newObj = copy(self)
+
+ if !s:setup_done
+ call self._setup()
+ let s:setup_done = 1
+ lockvar s:setup_done
+ endif
+
+ return newObj
+endfunction " }}}2
+
+function! g:SyntasticHighlightingNotifier.enabled() abort " {{{2
+ return s:has_highlighting && syntastic#util#var('enable_highlighting')
+endfunction " }}}2
+
+" Sets error highlights in the current window
+function! g:SyntasticHighlightingNotifier.refresh(loclist) abort " {{{2
+ if self.enabled()
+ call syntastic#log#debug(g:_SYNTASTIC_DEBUG_NOTIFICATIONS, 'highlighting: refresh')
+ call self._reset()
+ let buf = bufnr('')
+ let issues = filter(a:loclist.copyRaw(), 'v:val["bufnr"] == buf')
+ for item in issues
+ let group = 'Syntastic' . get(item, 'subtype', '') . ( item['type'] ==? 'E' ? 'Error' : 'Warning' )
+
+ " The function `Syntastic_{filetype}_{checker}_GetHighlightRegex` is
+ " used to override default highlighting.
+ if has_key(item, 'hl')
+ call matchadd(group, '\%' . item['lnum'] . 'l' . item['hl'])
+ elseif get(item, 'col', 0)
+ if get(item, 'vcol', 0)
+ let lastcol = virtcol([item['lnum'], '$'])
+ let coltype = 'v'
+ else
+ let lastcol = col([item['lnum'], '$'])
+ let coltype = 'c'
+ endif
+ let lcol = min([lastcol, item['col']])
+
+ call matchadd(group, '\%' . item['lnum'] . 'l\%' . lcol . coltype)
+ endif
+ endfor
+ endif
+endfunction " }}}2
+
+" Remove all error highlights from the window
+" @vimlint(EVL103, 1, a:loclist)
+function! g:SyntasticHighlightingNotifier.reset(loclist) abort " {{{2
+ if s:has_highlighting
+ call syntastic#log#debug(g:_SYNTASTIC_DEBUG_NOTIFICATIONS, 'highlighting: reset')
+ call self._reset()
+ endif
+endfunction " }}}2
+" @vimlint(EVL103, 0, a:loclist)
+
+" }}}1
+
+" Private methods {{{1
+
+" One time setup: define our own highlighting
+function! g:SyntasticHighlightingNotifier._setup() abort " {{{2
+ if s:has_highlighting
+ if !hlexists('SyntasticError')
+ highlight link SyntasticError SpellBad
+ endif
+ if !hlexists('SyntasticWarning')
+ highlight link SyntasticWarning SpellCap
+ endif
+ if !hlexists('SyntasticStyleError')
+ highlight link SyntasticStyleError SyntasticError
+ endif
+ if !hlexists('SyntasticStyleWarning')
+ highlight link SyntasticStyleWarning SyntasticWarning
+ endif
+ endif
+endfunction " }}}2
+
+function! g:SyntasticHighlightingNotifier._reset() abort " {{{2
+ for match in getmatches()
+ if stridx(match['group'], 'Syntastic') == 0
+ call matchdelete(match['id'])
+ endif
+ endfor
+endfunction " }}}2
+
+" }}}1
+
+" vim: set sw=4 sts=4 et fdm=marker:
diff --git a/vim/bundle/syntastic/plugin/syntastic/loclist.vim b/vim/bundle/syntastic/plugin/syntastic/loclist.vim
new file mode 100644
index 0000000..3e9528b
--- /dev/null
+++ b/vim/bundle/syntastic/plugin/syntastic/loclist.vim
@@ -0,0 +1,439 @@
+if exists('g:loaded_syntastic_loclist') || !exists('g:loaded_syntastic_plugin')
+ finish
+endif
+let g:loaded_syntastic_loclist = 1
+
+let g:SyntasticLoclist = {}
+
+" Public methods {{{1
+
+function! g:SyntasticLoclist.New(rawLoclist) abort " {{{2
+ let newObj = copy(self)
+
+ let llist = filter(copy(a:rawLoclist), 'v:val["valid"] == 1')
+
+ for e in llist
+ if get(e, 'type', '') ==# ''
+ let e['type'] = 'E'
+ endif
+ endfor
+
+ let newObj._rawLoclist = llist
+ let newObj._name = ''
+ let newObj._owner = bufnr('')
+ let newObj._sorted = 0
+ let newObj._columns = g:syntastic_cursor_columns
+
+ return newObj
+endfunction " }}}2
+
+function! g:SyntasticLoclist.current() abort " {{{2
+ if !exists('b:syntastic_loclist') || empty(b:syntastic_loclist)
+ let b:syntastic_loclist = g:SyntasticLoclist.New([])
+ endif
+ return b:syntastic_loclist
+endfunction " }}}2
+
+function! g:SyntasticLoclist.extend(other) abort " {{{2
+ let list = self.copyRaw()
+ call extend(list, a:other.copyRaw())
+ return g:SyntasticLoclist.New(list)
+endfunction " }}}2
+
+function! g:SyntasticLoclist.sort() abort " {{{2
+ if !self._sorted
+ for e in self._rawLoclist
+ call s:_set_screen_column(e)
+ endfor
+
+ call sort(self._rawLoclist, self._columns ? 's:_compare_error_items_by_columns' : 's:_compare_error_items_by_lines')
+
+ let self._sorted = 1
+ endif
+endfunction " }}}2
+
+function! g:SyntasticLoclist.isEmpty() abort " {{{2
+ return empty(self._rawLoclist)
+endfunction " }}}2
+
+function! g:SyntasticLoclist.isNewerThan(stamp) abort " {{{2
+ if !exists('self._stamp')
+ let self._stamp = []
+ return 0
+ endif
+ return syntastic#util#compareLexi(self._stamp, a:stamp) > 0
+endfunction " }}}2
+
+function! g:SyntasticLoclist.copyRaw() abort " {{{2
+ return copy(self._rawLoclist)
+endfunction " }}}2
+
+function! g:SyntasticLoclist.getRaw() abort " {{{2
+ return self._rawLoclist
+endfunction " }}}2
+
+function! g:SyntasticLoclist.getBuffers() abort " {{{2
+ return syntastic#util#unique(map(copy(self._rawLoclist), 'str2nr(v:val["bufnr"])') + [self._owner])
+endfunction " }}}2
+
+function! g:SyntasticLoclist.getCursorColumns() abort " {{{2
+ return self._columns
+endfunction " }}}2
+
+function! g:SyntasticLoclist.getStatuslineFlag() abort " {{{2
+ if !exists('self._stl_format')
+ let self._stl_format = ''
+ endif
+ if !exists('self._stl_flag')
+ let self._stl_flag = ''
+ endif
+
+ if g:syntastic_stl_format !=# self._stl_format
+ let self._stl_format = g:syntastic_stl_format
+
+ if !empty(self._rawLoclist)
+ let errors = self.errors()
+ let warnings = self.warnings()
+
+ let num_errors = len(errors)
+ let num_warnings = len(warnings)
+ let num_issues = len(self._rawLoclist)
+
+ let output = self._stl_format
+
+ "hide stuff wrapped in %E(...) unless there are errors
+ let output = substitute(output, '\m\C%E{\([^}]*\)}', num_errors ? '\1' : '' , 'g')
+
+ "hide stuff wrapped in %W(...) unless there are warnings
+ let output = substitute(output, '\m\C%W{\([^}]*\)}', num_warnings ? '\1' : '' , 'g')
+
+ "hide stuff wrapped in %B(...) unless there are both errors and warnings
+ let output = substitute(output, '\m\C%B{\([^}]*\)}', (num_warnings && num_errors) ? '\1' : '' , 'g')
+
+ let flags = {
+ \ '%': '%',
+ \ 't': num_issues,
+ \ 'e': num_errors,
+ \ 'w': num_warnings,
+ \ 'N': (num_issues ? fnamemodify( bufname(self._rawLoclist[0]['bufnr']), ':t') : ''),
+ \ 'P': (num_issues ? fnamemodify( bufname(self._rawLoclist[0]['bufnr']), ':p:~:.') : ''),
+ \ 'F': (num_issues ? self._rawLoclist[0]['lnum'] : ''),
+ \ 'ne': (num_errors ? fnamemodify( bufname(errors[0]['bufnr']), ':t') : ''),
+ \ 'pe': (num_errors ? fnamemodify( bufname(errors[0]['bufnr']), ':p:~:.') : ''),
+ \ 'fe': (num_errors ? errors[0]['lnum'] : ''),
+ \ 'nw': (num_warnings ? fnamemodify( bufname(warnings[0]['bufnr']), ':t') : ''),
+ \ 'pw': (num_warnings ? fnamemodify( bufname(warnings[0]['bufnr']), ':p:~:.') : ''),
+ \ 'fw': (num_warnings ? warnings[0]['lnum'] : '') }
+ let output = substitute(output, '\v\C\%(-?\d*%(\.\d+)?)([npf][ew]|[NPFtew%])', '\=syntastic#util#wformat(submatch(1), flags[submatch(2)])', 'g')
+
+ let self._stl_flag = output
+ else
+ let self._stl_flag = ''
+ endif
+ endif
+
+ return self._stl_flag
+endfunction " }}}2
+
+function! g:SyntasticLoclist.getFirstError(...) abort " {{{2
+ let max_issues = len(self._rawLoclist)
+ if a:0 && a:1 < max_issues
+ let max_issues = a:1
+ endif
+
+ for idx in range(max_issues)
+ if get(self._rawLoclist[idx], 'type', '') ==? 'E'
+ return idx + 1
+ endif
+ endfor
+
+ return 0
+endfunction " }}}2
+
+function! g:SyntasticLoclist.getName() abort " {{{2
+ return len(self._name)
+endfunction " }}}2
+
+function! g:SyntasticLoclist.setName(name) abort " {{{2
+ let self._name = a:name
+endfunction " }}}2
+
+function! g:SyntasticLoclist.getOwner() abort " {{{2
+ return self._owner
+endfunction " }}}2
+
+function! g:SyntasticLoclist.setOwner(buffer) abort " {{{2
+ let self._owner = type(a:buffer) == type(0) ? a:buffer : str2nr(a:buffer)
+endfunction " }}}2
+
+function! g:SyntasticLoclist.deploy() abort " {{{2
+ call self.setOwner(bufnr(''))
+ let self._stamp = syntastic#util#stamp()
+ for buf in self.getBuffers()
+ call setbufvar(buf, 'syntastic_loclist', self)
+ endfor
+endfunction " }}}2
+
+function! g:SyntasticLoclist.destroy() abort " {{{2
+ for buf in self.getBuffers()
+ call setbufvar(buf, 'syntastic_loclist', {})
+ endfor
+endfunction " }}}2
+
+function! g:SyntasticLoclist.decorate(tag) abort " {{{2
+ for e in self._rawLoclist
+ let e['text'] .= ' [' . a:tag . ']'
+ endfor
+endfunction " }}}2
+
+function! g:SyntasticLoclist.balloons() abort " {{{2
+ if !exists('self._cachedBalloons')
+ let sep = has('balloon_multiline') ? "\n" : ' | '
+
+ let self._cachedBalloons = {}
+ for e in self._rawLoclist
+ let buf = e['bufnr']
+
+ if !has_key(self._cachedBalloons, buf)
+ let self._cachedBalloons[buf] = {}
+ endif
+
+ if has_key(self._cachedBalloons[buf], e['lnum'])
+ let self._cachedBalloons[buf][e['lnum']] .= sep . e['text']
+ else
+ let self._cachedBalloons[buf][e['lnum']] = e['text']
+ endif
+ endfor
+ endif
+
+ return get(self._cachedBalloons, bufnr(''), {})
+endfunction " }}}2
+
+function! g:SyntasticLoclist.errors() abort " {{{2
+ if !exists('self._cachedErrors')
+ let self._cachedErrors = self.filter({'type': 'E'})
+ endif
+ return self._cachedErrors
+endfunction " }}}2
+
+function! g:SyntasticLoclist.warnings() abort " {{{2
+ if !exists('self._cachedWarnings')
+ let self._cachedWarnings = self.filter({'type': 'W'})
+ endif
+ return self._cachedWarnings
+endfunction " }}}2
+
+" Legacy function. Syntastic no longer calls it, but we keep it
+" around because other plugins (f.i. powerline) depend on it.
+function! g:SyntasticLoclist.hasErrorsOrWarningsToDisplay() abort " {{{2
+ return !self.isEmpty()
+endfunction " }}}2
+
+" cache used by EchoCurrentError()
+function! g:SyntasticLoclist.messages(buf) abort " {{{2
+ if !exists('self._cachedMessages')
+ let self._cachedMessages = {}
+
+ let errors = self.errors() + self.warnings()
+ for e in errors
+ let b = e['bufnr']
+ let l = e['lnum']
+
+ if !has_key(self._cachedMessages, b)
+ let self._cachedMessages[b] = {}
+ endif
+
+ if !has_key(self._cachedMessages[b], l)
+ let self._cachedMessages[b][l] = [e]
+ elseif self._columns
+ call add(self._cachedMessages[b][l], e)
+ endif
+ endfor
+
+ if self._columns
+ if !self._sorted
+ for b in keys(self._cachedMessages)
+ for l in keys(self._cachedMessages[b])
+ if len(self._cachedMessages[b][l]) > 1
+ for e in self._cachedMessages[b][l]
+ call s:_set_screen_column(e)
+ endfor
+ call sort(self._cachedMessages[b][l], 's:_compare_error_items_by_columns')
+ endif
+ endfor
+ endfor
+ endif
+
+ for b in keys(self._cachedMessages)
+ for l in keys(self._cachedMessages[b])
+ call s:_remove_shadowed_items(self._cachedMessages[b][l])
+ endfor
+ endfor
+ endif
+ endif
+
+ return get(self._cachedMessages, a:buf, {})
+endfunction " }}}2
+
+"Filter the list and return new native loclist
+"e.g.
+" .filter({'bufnr': 10, 'type': 'e'})
+"
+"would return all errors for buffer 10.
+"
+"Note that all comparisons are done with ==?
+function! g:SyntasticLoclist.filter(filters) abort " {{{2
+ let conditions = values(map(copy(a:filters), 's:_translate(v:key, v:val)'))
+ let filter = len(conditions) == 1 ?
+ \ conditions[0] : join(map(conditions, '"(" . v:val . ")"'), ' && ')
+ return filter(copy(self._rawLoclist), filter)
+endfunction " }}}2
+
+function! g:SyntasticLoclist.setloclist() abort " {{{2
+ if !exists('w:syntastic_loclist_set')
+ let w:syntastic_loclist_set = []
+ endif
+ if empty(w:syntastic_loclist_set) || w:syntastic_loclist_set != [bufnr(''), b:changedtick]
+ let replace = g:syntastic_reuse_loc_lists && !empty(w:syntastic_loclist_set)
+ call syntastic#log#debug(g:_SYNTASTIC_DEBUG_NOTIFICATIONS, 'loclist: setloclist ' . (replace ? '(replace)' : '(new)'))
+ call setloclist(0, self.getRaw(), replace ? 'r' : ' ')
+ call syntastic#util#setChangedtick()
+ let w:syntastic_loclist_set = [bufnr(''), b:syntastic_changedtick]
+ endif
+endfunction " }}}2
+
+"display the cached errors for this buf in the location list
+function! g:SyntasticLoclist.show() abort " {{{2
+ call syntastic#log#debug(g:_SYNTASTIC_DEBUG_NOTIFICATIONS, 'loclist: show')
+ call self.setloclist()
+
+ if !self.isEmpty()
+ let num = winnr()
+ execute 'lopen ' . syntastic#util#var('loc_list_height')
+ if num != winnr()
+ execute num . 'wincmd w'
+ endif
+
+ " try to find the loclist window and set w:quickfix_title
+ let errors = getloclist(0)
+ for buf in tabpagebuflist()
+ if buflisted(buf) && bufloaded(buf) && getbufvar(buf, '&buftype') ==# 'quickfix'
+ let win = bufwinnr(buf)
+ let title = getwinvar(win, 'quickfix_title')
+
+ " TODO: try to make sure we actually own this window; sadly,
+ " errors == getloclist(0) is the only somewhat safe way to
+ " achieve that
+ if strpart(title, 0, 16) ==# ':SyntasticCheck ' ||
+ \ ( (title ==# '' || title ==# ':setloclist()') && errors == getloclist(0) )
+ call setwinvar(win, 'quickfix_title', ':SyntasticCheck ' . self._name)
+ call setbufvar(buf, 'syntastic_owner_buffer', self._owner)
+ endif
+ endif
+ endfor
+ endif
+endfunction " }}}2
+
+" }}}1
+
+" Public functions {{{1
+
+function! SyntasticLoclistHide() abort " {{{2
+ call syntastic#log#debug(g:_SYNTASTIC_DEBUG_NOTIFICATIONS, 'loclist: hide')
+ silent! lclose
+endfunction " }}}2
+
+" }}}1
+
+" Utilities {{{1
+
+function! s:_translate(key, val) abort " {{{2
+ return 'get(v:val, ' . string(a:key) . ', "") ==? ' . string(a:val)
+endfunction " }}}2
+
+function! s:_set_screen_column(item) abort " {{{2
+ if !has_key(a:item, 'scol')
+ let col = get(a:item, 'col', 0)
+ if col != 0 && get(a:item, 'vcol', 0) == 0
+ let buf = str2nr(a:item['bufnr'])
+ try
+ let line = getbufline(buf, a:item['lnum'])[0]
+ catch /\m^Vim\%((\a\+)\)\=:E684/
+ let line = ''
+ endtry
+ let a:item['scol'] = syntastic#util#screenWidth(strpart(line, 0, col), getbufvar(buf, '&tabstop'))
+ else
+ let a:item['scol'] = col
+ endif
+ endif
+endfunction " }}}2
+
+function! s:_remove_shadowed_items(errors) abort " {{{2
+ " keep only the first message at a given column
+ let i = 0
+ while i < len(a:errors) - 1
+ let j = i + 1
+ let dupes = 0
+ while j < len(a:errors) && a:errors[j].scol == a:errors[i].scol
+ let dupes = 1
+ let j += 1
+ endwhile
+ if dupes
+ call remove(a:errors, i + 1, j - 1)
+ endif
+ let i += 1
+ endwhile
+
+ " merge messages with the same text
+ let i = 0
+ while i < len(a:errors) - 1
+ let j = i + 1
+ let dupes = 0
+ while j < len(a:errors) && a:errors[j].text == a:errors[i].text
+ let dupes = 1
+ let j += 1
+ endwhile
+ if dupes
+ call remove(a:errors, i + 1, j - 1)
+ endif
+ let i += 1
+ endwhile
+endfunction " }}}2
+
+function! s:_compare_error_items_by_columns(a, b) abort " {{{2
+ if a:a['bufnr'] != a:b['bufnr']
+ " group by file
+ return a:a['bufnr'] - a:b['bufnr']
+ elseif a:a['lnum'] != a:b['lnum']
+ " sort by line
+ return a:a['lnum'] - a:b['lnum']
+ elseif a:a['scol'] != a:b['scol']
+ " sort by screen column
+ return a:a['scol'] - a:b['scol']
+ elseif a:a['type'] !=? a:b['type']
+ " errors take precedence over warnings
+ return a:a['type'] ==? 'E' ? -1 : 1
+ else
+ return 0
+ endif
+endfunction " }}}2
+
+function! s:_compare_error_items_by_lines(a, b) abort " {{{2
+ if a:a['bufnr'] != a:b['bufnr']
+ " group by file
+ return a:a['bufnr'] - a:b['bufnr']
+ elseif a:a['lnum'] != a:b['lnum']
+ " sort by line
+ return a:a['lnum'] - a:b['lnum']
+ elseif a:a['type'] !=? a:b['type']
+ " errors take precedence over warnings
+ return a:a['type'] ==? 'E' ? -1 : 1
+ else
+ " sort by screen column
+ return a:a['scol'] - a:b['scol']
+ endif
+endfunction " }}}2
+
+" }}}1
+
+" vim: set sw=4 sts=4 et fdm=marker:
diff --git a/vim/bundle/syntastic/plugin/syntastic/modemap.vim b/vim/bundle/syntastic/plugin/syntastic/modemap.vim
new file mode 100644
index 0000000..501c82b
--- /dev/null
+++ b/vim/bundle/syntastic/plugin/syntastic/modemap.vim
@@ -0,0 +1,117 @@
+if exists('g:loaded_syntastic_modemap') || !exists('g:loaded_syntastic_plugin')
+ finish
+endif
+let g:loaded_syntastic_modemap = 1
+
+let g:SyntasticModeMap = {}
+
+" Public methods {{{1
+
+function! g:SyntasticModeMap.Instance() abort " {{{2
+ if !exists('s:SyntasticModeMapInstance')
+ let s:SyntasticModeMapInstance = copy(self)
+ call s:SyntasticModeMapInstance.synch()
+ endif
+
+ return s:SyntasticModeMapInstance
+endfunction " }}}2
+
+function! g:SyntasticModeMap.synch() abort " {{{2
+ if exists('g:syntastic_mode_map')
+ let self._mode = get(g:syntastic_mode_map, 'mode', 'active')
+ let self._activeFiletypes = copy(get(g:syntastic_mode_map, 'active_filetypes', []))
+ let self._passiveFiletypes = copy(get(g:syntastic_mode_map, 'passive_filetypes', []))
+ else
+ let self._mode = 'active'
+ let self._activeFiletypes = []
+ let self._passiveFiletypes = []
+ endif
+endfunction " }}}2
+
+function! g:SyntasticModeMap.allowsAutoChecking(filetype) abort " {{{2
+ let fts = split(a:filetype, '\m\.')
+
+ if self.isPassive()
+ return self._isOneFiletypeActive(fts)
+ else
+ return self._noFiletypesArePassive(fts)
+ endif
+endfunction " }}}2
+
+function! g:SyntasticModeMap.doAutoChecking() abort " {{{2
+ let local_mode = get(b:, 'syntastic_mode', '')
+ if local_mode ==# 'active' || local_mode ==# 'passive'
+ return local_mode ==# 'active'
+ endif
+
+ return self.allowsAutoChecking(&filetype)
+endfunction " }}}2
+
+function! g:SyntasticModeMap.isPassive() abort " {{{2
+ return self._mode ==# 'passive'
+endfunction " }}}2
+
+function! g:SyntasticModeMap.toggleMode() abort " {{{2
+ call self.synch()
+
+ if self._mode ==# 'active'
+ let self._mode = 'passive'
+ else
+ let self._mode = 'active'
+ endif
+
+ "XXX Changing a global variable. Tsk, tsk...
+ if !exists('g:syntastic_mode_map')
+ let g:syntastic_mode_map = {}
+ endif
+ let g:syntastic_mode_map['mode'] = self._mode
+endfunction " }}}2
+
+function! g:SyntasticModeMap.echoMode() abort " {{{2
+ echo 'Syntastic: ' . self._mode . ' mode enabled'
+endfunction " }}}2
+
+function! g:SyntasticModeMap.modeInfo(filetypes) abort " {{{2
+ echomsg 'Syntastic version: ' . g:_SYNTASTIC_VERSION . ' (Vim ' . v:version . ', ' . g:_SYNTASTIC_UNAME . ')'
+ let type = len(a:filetypes) ? a:filetypes[0] : &filetype
+ echomsg 'Info for filetype: ' . type
+
+ call self.synch()
+ echomsg 'Global mode: ' . self._mode
+ if self._mode ==# 'active'
+ if len(self._passiveFiletypes)
+ let plural = len(self._passiveFiletypes) != 1 ? 's' : ''
+ echomsg 'Passive filetype' . plural . ': ' . join(sort(copy(self._passiveFiletypes)))
+ endif
+ else
+ if len(self._activeFiletypes)
+ let plural = len(self._activeFiletypes) != 1 ? 's' : ''
+ echomsg 'Active filetype' . plural . ': ' . join(sort(copy(self._activeFiletypes)))
+ endif
+ endif
+ echomsg 'Filetype ' . type . ' is ' . (self.allowsAutoChecking(type) ? 'active' : 'passive')
+
+ if !len(a:filetypes)
+ if exists('b:syntastic_mode') && (b:syntastic_mode ==# 'active' || b:syntastic_mode ==# 'passive')
+ echomsg 'Local mode: ' . b:syntastic_mode
+ endif
+
+ echomsg 'The current file will ' . (self.doAutoChecking() ? '' : 'not ') . 'be checked automatically'
+ endif
+endfunction " }}}2
+
+" }}}1
+
+" Private methods {{{1
+
+function! g:SyntasticModeMap._isOneFiletypeActive(filetypes) abort " {{{2
+ return !empty(filter(copy(a:filetypes), 'index(self._activeFiletypes, v:val) != -1'))
+endfunction " }}}2
+
+function! g:SyntasticModeMap._noFiletypesArePassive(filetypes) abort " {{{2
+ return empty(filter(copy(a:filetypes), 'index(self._passiveFiletypes, v:val) != -1'))
+endfunction " }}}2
+
+" }}}1
+
+" vim: set sw=4 sts=4 et fdm=marker:
diff --git a/vim/bundle/syntastic/plugin/syntastic/notifiers.vim b/vim/bundle/syntastic/plugin/syntastic/notifiers.vim
new file mode 100644
index 0000000..fe158ca
--- /dev/null
+++ b/vim/bundle/syntastic/plugin/syntastic/notifiers.vim
@@ -0,0 +1,86 @@
+if exists('g:loaded_syntastic_notifiers') || !exists('g:loaded_syntastic_plugin')
+ finish
+endif
+let g:loaded_syntastic_notifiers = 1
+
+let g:SyntasticNotifiers = {}
+
+let s:_NOTIFIER_TYPES = ['signs', 'balloons', 'highlighting', 'cursor', 'autoloclist']
+lockvar! s:_NOTIFIER_TYPES
+
+let s:_PERSISTENT_NOTIFIERS = ['signs', 'balloons']
+lockvar! s:_PERSISTENT_NOTIFIERS
+
+" Public methods {{{1
+
+function! g:SyntasticNotifiers.Instance() abort " {{{2
+ if !exists('s:SyntasticNotifiersInstance')
+ let s:SyntasticNotifiersInstance = copy(self)
+ call s:SyntasticNotifiersInstance._initNotifiers()
+ endif
+
+ return s:SyntasticNotifiersInstance
+endfunction " }}}2
+
+function! g:SyntasticNotifiers.refresh(loclist) abort " {{{2
+ if !a:loclist.isEmpty() && !a:loclist.isNewerThan([])
+ " loclist not fully constructed yet
+ return
+ endif
+
+ call syntastic#log#debug(g:_SYNTASTIC_DEBUG_NOTIFICATIONS, 'notifiers: refresh')
+ for type in self._enabled_types
+ let class = substitute(type, '\m.*', 'Syntastic\u&Notifier', '')
+ if !has_key(g:{class}, 'enabled') || self._notifier[type].enabled()
+ if index(s:_PERSISTENT_NOTIFIERS, type) > -1
+ " refresh only if loclist has changed since last call
+ if !exists('b:syntastic_private_' . type . '_stamp')
+ let b:syntastic_private_{type}_stamp = []
+ endif
+ if a:loclist.isNewerThan(b:syntastic_private_{type}_stamp) || a:loclist.isEmpty()
+ call self._notifier[type].refresh(a:loclist)
+ let b:syntastic_private_{type}_stamp = syntastic#util#stamp()
+ endif
+ else
+ call self._notifier[type].refresh(a:loclist)
+ endif
+ endif
+ endfor
+endfunction " }}}2
+
+function! g:SyntasticNotifiers.reset(loclist) abort " {{{2
+ call syntastic#log#debug(g:_SYNTASTIC_DEBUG_NOTIFICATIONS, 'notifiers: reset')
+ for type in self._enabled_types
+ let class = substitute(type, '\m.*', 'Syntastic\u&Notifier', '')
+
+ " reset notifiers regardless if they are enabled or not, since
+ " the user might have disabled them since the last refresh();
+ " notifiers MUST be prepared to deal with reset() when disabled
+ if has_key(g:{class}, 'reset')
+ call self._notifier[type].reset(a:loclist)
+ endif
+
+ " also reset stamps
+ if index(s:_PERSISTENT_NOTIFIERS, type) > -1
+ let b:syntastic_private_{type}_stamp = []
+ endif
+ endfor
+endfunction " }}}2
+
+" }}}1
+
+" Private methods {{{1
+
+function! g:SyntasticNotifiers._initNotifiers() abort " {{{2
+ let self._notifier = {}
+ for type in s:_NOTIFIER_TYPES
+ let class = substitute(type, '\m.*', 'Syntastic\u&Notifier', '')
+ let self._notifier[type] = g:{class}.New()
+ endfor
+
+ let self._enabled_types = copy(s:_NOTIFIER_TYPES)
+endfunction " }}}2
+
+" }}}1
+
+" vim: set sw=4 sts=4 et fdm=marker:
diff --git a/vim/bundle/syntastic/plugin/syntastic/registry.vim b/vim/bundle/syntastic/plugin/syntastic/registry.vim
new file mode 100644
index 0000000..0c2d261
--- /dev/null
+++ b/vim/bundle/syntastic/plugin/syntastic/registry.vim
@@ -0,0 +1,375 @@
+if exists('g:loaded_syntastic_registry') || !exists('g:loaded_syntastic_plugin')
+ finish
+endif
+let g:loaded_syntastic_registry = 1
+
+" Initialisation {{{1
+
+let s:_DEFAULT_CHECKERS = {
+ \ 'actionscript': ['mxmlc'],
+ \ 'ada': ['gcc'],
+ \ 'ansible': ['ansible_lint'],
+ \ 'apiblueprint': ['drafter'],
+ \ 'applescript': ['osacompile'],
+ \ 'asciidoc': ['asciidoc'],
+ \ 'asm': ['gcc'],
+ \ 'bro': ['bro'],
+ \ 'bemhtml': ['bemhtmllint'],
+ \ 'c': ['gcc'],
+ \ 'cabal': ['cabal'],
+ \ 'chef': ['foodcritic'],
+ \ 'co': ['coco'],
+ \ 'cobol': ['cobc'],
+ \ 'coffee': ['coffee', 'coffeelint'],
+ \ 'coq': ['coqtop'],
+ \ 'cpp': ['gcc'],
+ \ 'cs': ['mcs'],
+ \ 'css': ['csslint'],
+ \ 'cucumber': ['cucumber'],
+ \ 'cuda': ['nvcc'],
+ \ 'd': ['dmd'],
+ \ 'dart': ['dartanalyzer'],
+ \ 'docbk': ['xmllint'],
+ \ 'dockerfile': ['dockerfile_lint'],
+ \ 'dustjs': ['swiffer'],
+ \ 'elixir': [],
+ \ 'erlang': ['escript'],
+ \ 'eruby': ['ruby'],
+ \ 'fortran': ['gfortran'],
+ \ 'glsl': ['cgc'],
+ \ 'go': [],
+ \ 'haml': ['haml'],
+ \ 'handlebars': ['handlebars'],
+ \ 'haskell': ['hdevtools', 'hlint'],
+ \ 'haxe': ['haxe'],
+ \ 'hss': ['hss'],
+ \ 'html': ['tidy'],
+ \ 'jade': ['jade_lint'],
+ \ 'java': ['javac'],
+ \ 'javascript': ['jshint', 'jslint'],
+ \ 'json': ['jsonlint', 'jsonval'],
+ \ 'less': ['lessc'],
+ \ 'lex': ['flex'],
+ \ 'limbo': ['limbo'],
+ \ 'lisp': ['clisp'],
+ \ 'llvm': ['llvm'],
+ \ 'lua': ['luac'],
+ \ 'markdown': ['mdl'],
+ \ 'matlab': ['mlint'],
+ \ 'mercury': ['mmc'],
+ \ 'nasm': ['nasm'],
+ \ 'nix': ['nix'],
+ \ 'nroff': ['mandoc'],
+ \ 'objc': ['gcc'],
+ \ 'objcpp': ['gcc'],
+ \ 'ocaml': ['camlp4o'],
+ \ 'perl': ['perlcritic'],
+ \ 'php': ['php', 'phpcs', 'phpmd'],
+ \ 'po': ['msgfmt'],
+ \ 'pod': ['podchecker'],
+ \ 'puppet': ['puppet', 'puppetlint'],
+ \ 'pug': ['pug_lint'],
+ \ 'python': ['python', 'flake8', 'pylint'],
+ \ 'qml': ['qmllint'],
+ \ 'r': [],
+ \ 'rmd': [],
+ \ 'racket': ['racket'],
+ \ 'rnc': ['rnv'],
+ \ 'rst': ['rst2pseudoxml'],
+ \ 'ruby': ['mri'],
+ \ 'sass': ['sass'],
+ \ 'scala': ['fsc', 'scalac'],
+ \ 'scss': ['sass', 'scss_lint'],
+ \ 'sh': ['sh', 'shellcheck'],
+ \ 'slim': ['slimrb'],
+ \ 'sml': ['smlnj'],
+ \ 'spec': ['rpmlint'],
+ \ 'sql': ['sqlint'],
+ \ 'stylus': ['stylint'],
+ \ 'tcl': ['nagelfar'],
+ \ 'tex': ['lacheck', 'chktex'],
+ \ 'texinfo': ['makeinfo'],
+ \ 'text': [],
+ \ 'trig': ['rapper'],
+ \ 'turtle': ['rapper'],
+ \ 'twig': ['twiglint'],
+ \ 'typescript': ['tsc'],
+ \ 'vala': ['valac'],
+ \ 'verilog': ['verilator'],
+ \ 'vhdl': ['ghdl'],
+ \ 'vim': ['vimlint'],
+ \ 'xhtml': ['tidy'],
+ \ 'xml': ['xmllint'],
+ \ 'xslt': ['xmllint'],
+ \ 'xquery': ['basex'],
+ \ 'yacc': ['bison'],
+ \ 'yaml': ['jsyaml'],
+ \ 'yang': ['pyang'],
+ \ 'z80': ['z80syntaxchecker'],
+ \ 'zpt': ['zptlint'],
+ \ 'zsh': ['zsh'],
+ \ }
+lockvar! s:_DEFAULT_CHECKERS
+
+let s:_DEFAULT_FILETYPE_MAP = {
+ \ 'gentoo-metadata': 'xml',
+ \ 'groff': 'nroff',
+ \ 'lhaskell': 'haskell',
+ \ 'litcoffee': 'coffee',
+ \ 'mail': 'text',
+ \ 'mkd': 'markdown',
+ \ 'pe-puppet': 'puppet',
+ \ 'sgml': 'docbk',
+ \ 'sgmllnx': 'docbk',
+ \ }
+lockvar! s:_DEFAULT_FILETYPE_MAP
+
+let s:_ECLIM_TYPES = [
+ \ 'c',
+ \ 'cpp',
+ \ 'html',
+ \ 'java',
+ \ 'php',
+ \ 'python',
+ \ 'ruby',
+ \ ]
+lockvar! s:_ECLIM_TYPES
+
+let s:_YCM_TYPES = [
+ \ 'c',
+ \ 'cpp',
+ \ 'objc',
+ \ 'objcpp',
+ \ ]
+lockvar! s:_YCM_TYPES
+
+let g:SyntasticRegistry = {}
+
+" }}}1
+
+" Public methods {{{1
+
+" Note: Handling of filetype aliases: all public methods take aliases as
+" parameters, all private methods take normalized filetypes. Public methods
+" are thus supposed to normalize filetypes before calling private methods.
+
+function! g:SyntasticRegistry.Instance() abort " {{{2
+ if !exists('s:SyntasticRegistryInstance')
+ let s:SyntasticRegistryInstance = copy(self)
+ let s:SyntasticRegistryInstance._checkerMap = {}
+ endif
+
+ return s:SyntasticRegistryInstance
+endfunction " }}}2
+
+function! g:SyntasticRegistry.CreateAndRegisterChecker(args) abort " {{{2
+ let registry = g:SyntasticRegistry.Instance()
+
+ if has_key(a:args, 'redirect')
+ let [ft, name] = split(a:args['redirect'], '/')
+ call registry._loadCheckersFor(ft, 1)
+
+ let clone = get(registry._checkerMap[ft], name, {})
+ if empty(clone)
+ throw 'Syntastic: Checker ' . a:args['redirect'] . ' redirects to unregistered checker ' . ft . '/' . name
+ endif
+
+ let checker = g:SyntasticChecker.New(a:args, clone)
+ else
+ let checker = g:SyntasticChecker.New(a:args)
+ endif
+ call registry._registerChecker(checker)
+endfunction " }}}2
+
+" Given a list of checker names hints_list, return a map name --> checker.
+" If hints_list is empty, user settings are are used instead. Checkers are
+" not checked for availability (that is, the corresponding IsAvailable() are
+" not run).
+function! g:SyntasticRegistry.getCheckers(ftalias, hints_list) abort " {{{2
+ let ft = s:_normalise_filetype(a:ftalias)
+ call self._loadCheckersFor(ft, 0)
+
+ let checkers_map = self._checkerMap[ft]
+ if empty(checkers_map)
+ return []
+ endif
+
+ call self._checkDeprecation(ft)
+
+ let names =
+ \ !empty(a:hints_list) ? syntastic#util#unique(a:hints_list) :
+ \ exists('b:syntastic_checkers') ? b:syntastic_checkers :
+ \ exists('g:syntastic_' . ft . '_checkers') ? g:syntastic_{ft}_checkers :
+ \ get(s:_DEFAULT_CHECKERS, ft, 0)
+
+ return type(names) == type([]) ?
+ \ self._filterCheckersByName(checkers_map, names) : [checkers_map[keys(checkers_map)[0]]]
+endfunction " }}}2
+
+" Same as getCheckers(), but keep only the available checkers. This runs the
+" corresponding IsAvailable() functions for all checkers.
+function! g:SyntasticRegistry.getCheckersAvailable(ftalias, hints_list) abort " {{{2
+ return filter(self.getCheckers(a:ftalias, a:hints_list), 'v:val.isAvailable()')
+endfunction " }}}2
+
+" Same as getCheckers(), but keep only the checkers that are available and
+" disabled. This runs the corresponding IsAvailable() functions for all checkers.
+function! g:SyntasticRegistry.getCheckersDisabled(ftalias, hints_list) abort " {{{2
+ return filter(self.getCheckers(a:ftalias, a:hints_list), 'v:val.isDisabled() && v:val.isAvailable()')
+endfunction " }}}2
+
+function! g:SyntasticRegistry.getKnownFiletypes() abort " {{{2
+ let types = keys(s:_DEFAULT_CHECKERS)
+
+ call extend(types, keys(s:_DEFAULT_FILETYPE_MAP))
+
+ if exists('g:syntastic_filetype_map')
+ call extend(types, keys(g:syntastic_filetype_map))
+ endif
+
+ if exists('g:syntastic_extra_filetypes') && type(g:syntastic_extra_filetypes) == type([])
+ call extend(types, g:syntastic_extra_filetypes)
+ endif
+
+ return syntastic#util#unique(types)
+endfunction " }}}2
+
+function! g:SyntasticRegistry.getNamesOfAvailableCheckers(ftalias) abort " {{{2
+ let ft = s:_normalise_filetype(a:ftalias)
+ call self._loadCheckersFor(ft, 0)
+ return keys(filter( copy(self._checkerMap[ft]), 'v:val.isAvailable()' ))
+endfunction " }}}2
+
+function! g:SyntasticRegistry.echoInfoFor(ftalias_list) abort " {{{2
+ let ft_list = syntastic#util#unique(map( copy(a:ftalias_list), 's:_normalise_filetype(v:val)' ))
+ if len(ft_list) != 1
+ let available = []
+ let active = []
+ let disabled = []
+
+ for ft in ft_list
+ call extend(available, map( self.getNamesOfAvailableCheckers(ft), 'ft . "/" . v:val' ))
+ call extend(active, map( self.getCheckersAvailable(ft, []), 'ft . "/" . v:val.getName()' ))
+ call extend(disabled, map( self.getCheckersDisabled(ft, []), 'ft . "/" . v:val.getName()' ))
+ endfor
+ else
+ let ft = ft_list[0]
+ let available = self.getNamesOfAvailableCheckers(ft)
+ let active = map(self.getCheckersAvailable(ft, []), 'v:val.getName()')
+ let disabled = map(self.getCheckersDisabled(ft, []), 'v:val.getName()')
+ endif
+
+ let cnt = len(available)
+ let plural = cnt != 1 ? 's' : ''
+ let cklist = cnt ? join(sort(available)) : '-'
+ echomsg 'Available checker' . plural . ': ' . cklist
+
+ let cnt = len(active)
+ let plural = cnt != 1 ? 's' : ''
+ let cklist = cnt ? join(active) : '-'
+ echomsg 'Currently enabled checker' . plural . ': ' . cklist
+
+ let cnt = len(disabled)
+ let plural = cnt != 1 ? 's' : ''
+ if len(disabled)
+ let cklist = join(sort(disabled))
+ echomsg 'Checker' . plural . ' disabled for security reasons: ' . cklist
+ endif
+
+ " Eclim feels entitled to mess with syntastic's variables {{{3
+ if exists(':EclimValidate') && get(g:, 'EclimFileTypeValidate', 1)
+ let disabled = filter(copy(ft_list), 's:_disabled_by_eclim(v:val)')
+ let cnt = len(disabled)
+ if cnt
+ let plural = cnt != 1 ? 's' : ''
+ let cklist = join(disabled, ', ')
+ echomsg 'Checkers for filetype' . plural . ' ' . cklist . ' possibly disabled by Eclim'
+ endif
+ endif
+ " }}}3
+
+ " So does YouCompleteMe {{{3
+ if exists('g:loaded_youcompleteme') && get(g:, 'ycm_show_diagnostics_ui', get(g:, 'ycm_register_as_syntastic_checker', 1))
+ let disabled = filter(copy(ft_list), 's:_disabled_by_ycm(v:val)')
+ let cnt = len(disabled)
+ if cnt
+ let plural = cnt != 1 ? 's' : ''
+ let cklist = join(disabled, ', ')
+ echomsg 'Checkers for filetype' . plural . ' ' . cklist . ' possibly disabled by YouCompleteMe'
+ endif
+ endif
+ " }}}3
+endfunction " }}}2
+
+" }}}1
+
+" Private methods {{{1
+
+function! g:SyntasticRegistry._registerChecker(checker) abort " {{{2
+ let ft = a:checker.getFiletype()
+ if !has_key(self._checkerMap, ft)
+ let self._checkerMap[ft] = {}
+ endif
+
+ let name = a:checker.getName()
+ if has_key(self._checkerMap[ft], name)
+ throw 'Syntastic: Duplicate syntax checker name: ' . ft . '/' . name
+ endif
+
+ let self._checkerMap[ft][name] = a:checker
+endfunction " }}}2
+
+function! g:SyntasticRegistry._filterCheckersByName(checkers_map, list) abort " {{{2
+ return filter( map(copy(a:list), 'get(a:checkers_map, v:val, {})'), '!empty(v:val)' )
+endfunction " }}}2
+
+function! g:SyntasticRegistry._loadCheckersFor(filetype, force) abort " {{{2
+ if !a:force && has_key(self._checkerMap, a:filetype)
+ return
+ endif
+
+ execute 'runtime! syntax_checkers/' . a:filetype . '/*.vim'
+
+ if !has_key(self._checkerMap, a:filetype)
+ let self._checkerMap[a:filetype] = {}
+ endif
+endfunction " }}}2
+
+" Check for obsolete variable g:syntastic_<filetype>_checker
+function! g:SyntasticRegistry._checkDeprecation(filetype) abort " {{{2
+ if exists('g:syntastic_' . a:filetype . '_checker') && !exists('g:syntastic_' . a:filetype . '_checkers')
+ let g:syntastic_{a:filetype}_checkers = [g:syntastic_{a:filetype}_checker]
+ call syntastic#log#oneTimeWarn('variable g:syntastic_' . a:filetype . '_checker is deprecated')
+ endif
+endfunction " }}}2
+
+" }}}1
+
+" Utilities {{{1
+
+"resolve filetype aliases, and replace - with _ otherwise we cant name
+"syntax checker functions legally for filetypes like "gentoo-metadata"
+function! s:_normalise_filetype(ftalias) abort " {{{2
+ let ft = get(s:_DEFAULT_FILETYPE_MAP, a:ftalias, a:ftalias)
+ let ft = get(g:syntastic_filetype_map, ft, ft)
+ let ft = substitute(ft, '\m-', '_', 'g')
+ return ft
+endfunction " }}}2
+
+function! s:_disabled_by_eclim(filetype) abort " {{{2
+ if index(s:_ECLIM_TYPES, a:filetype) >= 0
+ let lang = toupper(a:filetype[0]) . a:filetype[1:]
+ let ft = a:filetype !=# 'cpp' ? lang : 'C'
+ return get(g:, 'Eclim' . lang . 'Validate', 1) && !get(g:, 'Eclim' . ft . 'SyntasticEnabled', 0)
+ endif
+
+ return 0
+endfunction " }}}2
+
+function! s:_disabled_by_ycm(filetype) abort " {{{2
+ return index(s:_YCM_TYPES, a:filetype) >= 0
+endfunction " }}}2
+
+" }}}1
+
+" vim: set sw=4 sts=4 et fdm=marker:
diff --git a/vim/bundle/syntastic/plugin/syntastic/signs.vim b/vim/bundle/syntastic/plugin/syntastic/signs.vim
new file mode 100644
index 0000000..e3bafa0
--- /dev/null
+++ b/vim/bundle/syntastic/plugin/syntastic/signs.vim
@@ -0,0 +1,138 @@
+if exists('g:loaded_syntastic_notifier_signs') || !exists('g:loaded_syntastic_plugin')
+ finish
+endif
+let g:loaded_syntastic_notifier_signs = 1
+
+" Initialisation {{{1
+
+" start counting sign ids at 5000, start here to hopefully avoid conflicting
+" with any other code that places signs (not sure if this precaution is
+" actually needed)
+let s:first_sign_id = 5000
+let s:next_sign_id = s:first_sign_id
+
+let g:SyntasticSignsNotifier = {}
+
+let s:setup_done = 0
+
+" }}}1
+
+" Public methods {{{1
+
+function! g:SyntasticSignsNotifier.New() abort " {{{2
+ let newObj = copy(self)
+ return newObj
+endfunction " }}}2
+
+function! g:SyntasticSignsNotifier.enabled() abort " {{{2
+ return has('signs') && syntastic#util#var('enable_signs')
+endfunction " }}}2
+
+function! g:SyntasticSignsNotifier.refresh(loclist) abort " {{{2
+ call syntastic#log#debug(g:_SYNTASTIC_DEBUG_NOTIFICATIONS, 'signs: refresh')
+
+ let old_signs = copy(self._bufSignIds())
+ if self.enabled()
+ if !s:setup_done
+ call self._setup()
+ let s:setup_done = 1
+ lockvar s:setup_done
+ endif
+
+ call self._signErrors(a:loclist)
+ endif
+ call self._removeSigns(old_signs)
+endfunction " }}}2
+
+" }}}1
+
+" Private methods {{{1
+
+" One time setup: define our own sign types and highlighting
+function! g:SyntasticSignsNotifier._setup() abort " {{{2
+ if has('signs')
+ if !hlexists('SyntasticErrorSign')
+ highlight link SyntasticErrorSign error
+ endif
+ if !hlexists('SyntasticWarningSign')
+ highlight link SyntasticWarningSign todo
+ endif
+ if !hlexists('SyntasticStyleErrorSign')
+ highlight link SyntasticStyleErrorSign SyntasticErrorSign
+ endif
+ if !hlexists('SyntasticStyleWarningSign')
+ highlight link SyntasticStyleWarningSign SyntasticWarningSign
+ endif
+ if !hlexists('SyntasticStyleErrorLine')
+ highlight link SyntasticStyleErrorLine SyntasticErrorLine
+ endif
+ if !hlexists('SyntasticStyleWarningLine')
+ highlight link SyntasticStyleWarningLine SyntasticWarningLine
+ endif
+
+ " define the signs used to display syntax and style errors/warns
+ execute 'sign define SyntasticError text=' . g:syntastic_error_symbol .
+ \ ' texthl=SyntasticErrorSign linehl=SyntasticErrorLine'
+ execute 'sign define SyntasticWarning text=' . g:syntastic_warning_symbol .
+ \ ' texthl=SyntasticWarningSign linehl=SyntasticWarningLine'
+ execute 'sign define SyntasticStyleError text=' . g:syntastic_style_error_symbol .
+ \ ' texthl=SyntasticStyleErrorSign linehl=SyntasticStyleErrorLine'
+ execute 'sign define SyntasticStyleWarning text=' . g:syntastic_style_warning_symbol .
+ \ ' texthl=SyntasticStyleWarningSign linehl=SyntasticStyleWarningLine'
+ endif
+endfunction " }}}2
+
+" Place signs by all syntax errors in the buffer
+function! g:SyntasticSignsNotifier._signErrors(loclist) abort " {{{2
+ let loclist = a:loclist
+ if !loclist.isEmpty()
+
+ let buf = bufnr('')
+ if !bufloaded(buf)
+ " signs can be placed only in loaded buffers
+ return
+ endif
+
+ " errors come first, so that they are not masked by warnings
+ let issues = copy(loclist.errors())
+ call extend(issues, loclist.warnings())
+ call filter(issues, 'v:val["bufnr"] == buf')
+ let seen = {}
+
+ for i in issues
+ if i['lnum'] > 0 && !has_key(seen, i['lnum'])
+ let seen[i['lnum']] = 1
+
+ let sign_severity = i['type'] ==? 'W' ? 'Warning' : 'Error'
+ let sign_subtype = get(i, 'subtype', '')
+ let sign_type = 'Syntastic' . sign_subtype . sign_severity
+
+ execute 'sign place ' . s:next_sign_id . ' line=' . i['lnum'] . ' name=' . sign_type . ' buffer=' . i['bufnr']
+ call add(self._bufSignIds(), s:next_sign_id)
+ let s:next_sign_id += 1
+ endif
+ endfor
+ endif
+endfunction " }}}2
+
+" Remove the signs with the given ids from this buffer
+function! g:SyntasticSignsNotifier._removeSigns(ids) abort " {{{2
+ if has('signs')
+ for s in reverse(copy(a:ids))
+ execute 'sign unplace ' . s
+ call remove(self._bufSignIds(), index(self._bufSignIds(), s))
+ endfor
+ endif
+endfunction " }}}2
+
+" Get all the ids of the SyntaxError signs in the buffer
+function! g:SyntasticSignsNotifier._bufSignIds() abort " {{{2
+ if !exists('b:syntastic_private_sign_ids')
+ let b:syntastic_private_sign_ids = []
+ endif
+ return b:syntastic_private_sign_ids
+endfunction " }}}2
+
+" }}}1
+
+" vim: set sw=4 sts=4 et fdm=marker: