vim: pyflakes -> syntastic

.gitignore

@@ -1,2 +1,2 @@
 vim/.netrwhist
-vim/jedi_vim.pyc
+vim/__pycache__/

vim/autoload/syntastic/c.vim

@@ -0,0 +1,345 @@
+if exists('g:loaded_syntastic_c_autoload') || !exists('g:loaded_syntastic_plugin')
+    finish
+endif
+let g:loaded_syntastic_c_autoload = 1
+
+let s:save_cpo = &cpo
+set cpo&vim
+
+" Public functions {{{1
+
+" convenience function to determine the 'null device' parameter
+" based on the current operating system
+function! syntastic#c#NullOutput() abort " {{{2
+    let known_os = has('unix') || has('mac') || syntastic#util#isRunningWindows()
+    return known_os ? '-o ' . syntastic#util#DevNull() : ''
+endfunction " }}}2
+
+" read additional compiler flags from the given configuration file
+" the file format and its parsing mechanism is inspired by clang_complete
+function! syntastic#c#ReadConfig(file) abort " {{{2
+    call syntastic#log#debug(g:_SYNTASTIC_DEBUG_CHECKERS, 'ReadConfig: looking for', a:file)
+
+    " search upwards from the current file's directory
+    let config = findfile(a:file, '.;')
+    if config ==# ''
+        call syntastic#log#debug(g:_SYNTASTIC_DEBUG_CHECKERS, 'ReadConfig: file not found')
+        return ''
+    endif
+    call syntastic#log#debug(g:_SYNTASTIC_DEBUG_CHECKERS, 'ReadConfig: config file:', config)
+    if !filereadable(config)
+        call syntastic#log#debug(g:_SYNTASTIC_DEBUG_CHECKERS, 'ReadConfig: file unreadable')
+        return ''
+    endif
+
+    " convert filename into absolute path
+    let filepath = fnamemodify(config, ':p:h')
+
+    " try to read config file
+    try
+        let lines = readfile(config)
+    catch /\m^Vim\%((\a\+)\)\=:E48[45]/
+        call syntastic#log#debug(g:_SYNTASTIC_DEBUG_CHECKERS, 'ReadConfig: error reading file')
+        return ''
+    endtry
+
+    " filter out empty lines and comments
+    call filter(lines, 'v:val !~# ''\v^(\s*#|$)''')
+
+    " remove leading and trailing spaces
+    call map(lines, 'substitute(v:val, ''\m^\s\+'', "", "")')
+    call map(lines, 'substitute(v:val, ''\m\s\+$'', "", "")')
+
+    let parameters = []
+    for line in lines
+        let matches = matchstr(line, '\m\C^\s*-I\s*\zs.\+')
+        if matches !=# ''
+            " this one looks like an absolute path
+            if match(matches, '\m^\%(/\|\a:\)') != -1
+                call add(parameters, '-I' . matches)
+            else
+                call add(parameters, '-I' . filepath . syntastic#util#Slash() . matches)
+            endif
+        else
+            call add(parameters, line)
+        endif
+    endfor
+
+    return join(map(parameters, 'syntastic#util#shescape(v:val)'))
+endfunction " }}}2
+
+" GetLocList() for C-like compilers
+function! syntastic#c#GetLocList(filetype, subchecker, options) abort " {{{2
+    try
+        let flags = s:_get_cflags(a:filetype, a:subchecker, a:options)
+    catch /\m\C^Syntastic: skip checks$/
+        return []
+    endtry
+
+    let makeprg = syntastic#util#shexpand(g:syntastic_{a:filetype}_compiler) .
+        \ ' ' . flags . ' ' . syntastic#util#shexpand('%')
+
+    let errorformat = s:_get_checker_var('g', a:filetype, a:subchecker, 'errorformat', a:options['errorformat'])
+
+    let postprocess = s:_get_checker_var('g', a:filetype, a:subchecker, 'remove_include_errors', 0) ?
+        \ ['filterForeignErrors'] : []
+
+    " process makeprg
+    return SyntasticMake({
+        \ 'makeprg': makeprg,
+        \ 'errorformat': errorformat,
+        \ 'postprocess': postprocess })
+endfunction " }}}2
+
+" }}}1
+
+" Private functions {{{1
+
+" initialize c/cpp syntax checker handlers
+function! s:_init() abort " {{{2
+    let s:handlers = []
+    let s:cflags = {}
+
+    call s:_registerHandler('\m\<cairo',       's:_checkPackage', ['cairo', 'cairo'])
+    call s:_registerHandler('\m\<freetype',    's:_checkPackage', ['freetype', 'freetype2', 'freetype'])
+    call s:_registerHandler('\m\<glade',       's:_checkPackage', ['glade', 'libglade-2.0', 'libglade'])
+    call s:_registerHandler('\m\<glib',        's:_checkPackage', ['glib', 'glib-2.0', 'glib'])
+    call s:_registerHandler('\m\<gtk',         's:_checkPackage', ['gtk', 'gtk+-2.0', 'gtk+', 'glib-2.0', 'glib'])
+    call s:_registerHandler('\m\<libsoup',     's:_checkPackage', ['libsoup', 'libsoup-2.4', 'libsoup-2.2'])
+    call s:_registerHandler('\m\<libxml',      's:_checkPackage', ['libxml', 'libxml-2.0', 'libxml'])
+    call s:_registerHandler('\m\<pango',       's:_checkPackage', ['pango', 'pango'])
+    call s:_registerHandler('\m\<SDL',         's:_checkPackage', ['sdl', 'sdl'])
+    call s:_registerHandler('\m\<opengl',      's:_checkPackage', ['opengl', 'gl'])
+    call s:_registerHandler('\m\<webkit',      's:_checkPackage', ['webkit', 'webkit-1.0'])
+
+    call s:_registerHandler('\m\<php\.h\>',    's:_checkPhp',    [])
+    call s:_registerHandler('\m\<Python\.h\>', 's:_checkPython', [])
+    call s:_registerHandler('\m\<ruby',        's:_checkRuby',   [])
+endfunction " }}}2
+
+" register a handler dictionary object
+function! s:_registerHandler(regex, function, args) abort " {{{2
+    let handler = {}
+    let handler['regex'] = a:regex
+    let handler['func'] = function(a:function)
+    let handler['args'] = a:args
+    call add(s:handlers, handler)
+endfunction " }}}2
+
+" try to find library with 'pkg-config'
+" search possible libraries from first to last given
+" argument until one is found
+function! s:_checkPackage(name, ...) abort " {{{2
+    if executable('pkg-config')
+        if !has_key(s:cflags, a:name)
+            for pkg in a:000
+                let pkg_flags = syntastic#util#system('pkg-config --cflags ' . pkg)
+                " since we cannot necessarily trust the pkg-config exit code
+                " we have to check for an error output as well
+                if v:shell_error == 0 && pkg_flags !~? 'not found'
+                    let pkg_flags = ' ' . substitute(pkg_flags, "\n", '', '')
+                    let s:cflags[a:name] = pkg_flags
+                    return pkg_flags
+                endif
+            endfor
+        else
+            return s:cflags[a:name]
+        endif
+    endif
+    return ''
+endfunction " }}}2
+
+" try to find PHP includes with 'php-config'
+function! s:_checkPhp() abort " {{{2
+    if executable('php-config')
+        if !has_key(s:cflags, 'php')
+            let s:cflags['php'] = syntastic#util#system('php-config --includes')
+            let s:cflags['php'] = ' ' . substitute(s:cflags['php'], "\n", '', '')
+        endif
+        return s:cflags['php']
+    endif
+    return ''
+endfunction " }}}2
+
+" try to find the python headers with distutils
+function! s:_checkPython() abort " {{{2
+    if executable('python')
+        if !has_key(s:cflags, 'python')
+            let s:cflags['python'] = syntastic#util#system('python -c ''from distutils import ' .
+                \ 'sysconfig; import sys; sys.stdout.write(sysconfig.get_python_inc())''')
+            let s:cflags['python'] = substitute(s:cflags['python'], "\n", '', '')
+            let s:cflags['python'] = ' -I' . s:cflags['python']
+        endif
+        return s:cflags['python']
+    endif
+    return ''
+endfunction " }}}2
+
+" try to find the ruby headers with 'rbconfig'
+function! s:_checkRuby() abort " {{{2
+    if executable('ruby')
+        if !has_key(s:cflags, 'ruby')
+            let s:cflags['ruby'] = syntastic#util#system('ruby -r rbconfig -e ' .
+                \ '''puts RbConfig::CONFIG["rubyhdrdir"] || RbConfig::CONFIG["archdir"]''')
+            let s:cflags['ruby'] = substitute(s:cflags['ruby'], "\n", '', '')
+            let s:cflags['ruby'] = ' -I' . s:cflags['ruby']
+        endif
+        return s:cflags['ruby']
+    endif
+    return ''
+endfunction " }}}2
+
+" }}}1
+
+" Utilities {{{1
+
+" resolve checker-related user variables
+function! s:_get_checker_var(scope, filetype, subchecker, name, default) abort " {{{2
+    let prefix = a:scope . ':' . 'syntastic_'
+    if exists(prefix . a:filetype . '_' . a:subchecker . '_' . a:name)
+        return {a:scope}:syntastic_{a:filetype}_{a:subchecker}_{a:name}
+    elseif exists(prefix . a:filetype . '_' . a:name)
+        return {a:scope}:syntastic_{a:filetype}_{a:name}
+    else
+        return a:default
+    endif
+endfunction " }}}2
+
+" resolve user CFLAGS
+function! s:_get_cflags(ft, ck, opts) abort " {{{2
+    " determine whether to parse header files as well
+    if has_key(a:opts, 'header_names') && expand('%', 1) =~? a:opts['header_names']
+        if s:_get_checker_var('g', a:ft, a:ck, 'check_header', 0)
+            let flags = get(a:opts, 'header_flags', '') . ' -c ' . syntastic#c#NullOutput()
+        else
+            " checking headers when check_header is unset: bail out
+            throw 'Syntastic: skip checks'
+        endif
+    else
+        let flags = get(a:opts, 'main_flags', '')
+    endif
+
+    let flags .= ' ' . s:_get_checker_var('g', a:ft, a:ck, 'compiler_options', '') . ' ' . s:_get_include_dirs(a:ft)
+
+    " check if the user manually set some cflags
+    let b_cflags = s:_get_checker_var('b', a:ft, a:ck, 'cflags', '')
+    if b_cflags ==# ''
+        if a:ft ==# 'c' || a:ft ==# 'cpp'
+            " check whether to search for include files at all
+            if !s:_get_checker_var('g', a:ft, a:ck, 'no_include_search', 0)
+                " refresh the include file search if desired
+                if s:_get_checker_var('g', a:ft, a:ck, 'auto_refresh_includes', 0)
+                    let flags .= ' ' . s:_search_headers()
+                else
+                    " search for header includes if not cached already
+                    if !exists('b:syntastic_' . a:ft . '_includes')
+                        let b:syntastic_{a:ft}_includes = s:_search_headers()
+                    endif
+                    let flags .= ' ' . b:syntastic_{a:ft}_includes
+                endif
+            endif
+        endif
+    else
+        " user-defined cflags
+        let flags .= ' ' . b_cflags
+    endif
+
+    " add optional config file parameters
+    let config_file = s:_get_checker_var('g', a:ft, a:ck, 'config_file', '.syntastic_' . a:ft . '_config')
+    let flags .= ' ' . syntastic#c#ReadConfig(config_file)
+
+    return flags
+endfunction " }}}2
+
+" get the gcc include directory argument depending on the default
+" includes and the optional user-defined 'g:syntastic_c_include_dirs'
+function! s:_get_include_dirs(filetype) abort " {{{2
+    let include_dirs = []
+
+    if a:filetype =~# '\v^%(c|cpp|objc|objcpp)$' &&
+                \ (!exists('g:syntastic_'.a:filetype.'_no_default_include_dirs') ||
+                \ !g:syntastic_{a:filetype}_no_default_include_dirs)
+        let include_dirs = copy(s:default_includes)
+    endif
+
+    if exists('g:syntastic_'.a:filetype.'_include_dirs')
+        call extend(include_dirs, g:syntastic_{a:filetype}_include_dirs)
+    endif
+
+    return join(map(syntastic#util#unique(include_dirs), 'syntastic#util#shescape("-I" . v:val)'))
+endfunction " }}}2
+
+" search the first 100 lines for include statements that are
+" given in the handlers dictionary
+function! s:_search_headers() abort " {{{2
+    let includes = ''
+    let files = []
+    let found = []
+    let lines = filter(getline(1, 100), 'v:val =~# ''\m^\s*#\s*include''')
+
+    " search current buffer
+    for line in lines
+        let file = matchstr(line, '\m"\zs\S\+\ze"')
+        if file !=# ''
+            call add(files, file)
+            continue
+        endif
+
+        for handler in s:handlers
+            if line =~# handler['regex']
+                let includes .= call(handler['func'], handler['args'])
+                call add(found, handler['regex'])
+                break
+            endif
+        endfor
+    endfor
+
+    " search included headers
+    for hfile in files
+        if hfile !=# ''
+            let filename = expand('%:p:h', 1) . syntastic#util#Slash() . hfile
+
+            try
+                let lines = readfile(filename, '', 100)
+            catch /\m^Vim\%((\a\+)\)\=:E484/
+                continue
+            endtry
+
+            call filter(lines, 'v:val =~# ''\m^\s*#\s*include''')
+
+            for handler in s:handlers
+                if index(found, handler['regex']) != -1
+                    continue
+                endif
+
+                for line in lines
+                    if line =~# handler['regex']
+                        let includes .= call(handler['func'], handler['args'])
+                        call add(found, handler['regex'])
+                        break
+                    endif
+                endfor
+            endfor
+        endif
+    endfor
+
+    return includes
+endfunction " }}}2
+
+" }}}1
+
+" default include directories
+let s:default_includes = [
+    \ '.',
+    \ '..',
+    \ 'include',
+    \ 'includes',
+    \ '..' . syntastic#util#Slash() . 'include',
+    \ '..' . syntastic#util#Slash() . 'includes' ]
+
+call s:_init()
+
+let &cpo = s:save_cpo
+unlet s:save_cpo
+
+" vim: set sw=4 sts=4 et fdm=marker:

vim/autoload/syntastic/log.vim

@@ -0,0 +1,182 @@
+if exists('g:loaded_syntastic_log_autoload') || !exists('g:loaded_syntastic_plugin')
+    finish
+endif
+let g:loaded_syntastic_log_autoload = 1
+
+let s:save_cpo = &cpo
+set cpo&vim
+
+let s:one_time_notices_issued = []
+
+" Public functions {{{1
+
+function! syntastic#log#info(msg) abort " {{{2
+    echomsg 'syntastic: info: ' . a:msg
+endfunction " }}}2
+
+function! syntastic#log#warn(msg) abort " {{{2
+    echohl WarningMsg
+    echomsg 'syntastic: warning: ' . a:msg
+    echohl None
+endfunction " }}}2
+
+function! syntastic#log#error(msg) abort " {{{2
+    execute "normal \<Esc>"
+    echohl ErrorMsg
+    echomsg 'syntastic: error: ' . a:msg
+    echohl None
+endfunction " }}}2
+
+function! syntastic#log#oneTimeWarn(msg) abort " {{{2
+    if index(s:one_time_notices_issued, a:msg) >= 0
+        return
+    endif
+
+    call add(s:one_time_notices_issued, a:msg)
+    call syntastic#log#warn(a:msg)
+endfunction " }}}2
+
+" @vimlint(EVL102, 1, l:OLD_VAR)
+function! syntastic#log#deprecationWarn(old, new, ...) abort " {{{2
+    if exists('g:syntastic_' . a:old) && !exists('g:syntastic_' . a:new)
+        let msg = 'variable g:syntastic_' . a:old . ' is deprecated, please use '
+
+        if a:0
+            let OLD_VAR = g:syntastic_{a:old}
+            try
+                let NEW_VAR = eval(a:1)
+                let msg .= 'in its stead: let g:syntastic_' . a:new . ' = ' . string(NEW_VAR)
+                let g:syntastic_{a:new} = NEW_VAR
+            catch
+                let msg .= 'g:syntastic_' . a:new . ' instead'
+            endtry
+        else
+            let msg .= 'g:syntastic_' . a:new . ' instead'
+            let g:syntastic_{a:new} = g:syntastic_{a:old}
+        endif
+
+        call syntastic#log#oneTimeWarn(msg)
+    endif
+endfunction " }}}2
+" @vimlint(EVL102, 0, l:OLD_VAR)
+
+function! syntastic#log#debug(level, msg, ...) abort " {{{2
+    if !s:_isDebugEnabled(a:level)
+        return
+    endif
+
+    let leader = s:_log_timestamp()
+    call s:_logRedirect(1)
+
+    if a:0 > 0
+        " filter out dictionary functions
+        echomsg leader . a:msg . ' ' .
+            \ strtrans(string(type(a:1) == type({}) || type(a:1) == type([]) ?
+            \ filter(copy(a:1), 'type(v:val) != type(function("tr"))') : a:1))
+    else
+        echomsg leader . a:msg
+    endif
+
+    call s:_logRedirect(0)
+endfunction " }}}2
+
+function! syntastic#log#debugShowOptions(level, names) abort " {{{2
+    if !s:_isDebugEnabled(a:level)
+        return
+    endif
+
+    let leader = s:_log_timestamp()
+    call s:_logRedirect(1)
+
+    let vlist = copy(type(a:names) == type('') ? [a:names] : a:names)
+    if !empty(vlist)
+        call map(vlist, "'&' . v:val . ' = ' . strtrans(string(eval('&' . v:val)))")
+        echomsg leader . join(vlist, ', ')
+    endif
+    call s:_logRedirect(0)
+endfunction " }}}2
+
+function! syntastic#log#debugShowVariables(level, names) abort " {{{2
+    if !s:_isDebugEnabled(a:level)
+        return
+    endif
+
+    let leader = s:_log_timestamp()
+    call s:_logRedirect(1)
+
+    let vlist = type(a:names) == type('') ? [a:names] : a:names
+    for name in vlist
+        let msg = s:_format_variable(name)
+        if msg !=# ''
+            echomsg leader . msg
+        endif
+    endfor
+
+    call s:_logRedirect(0)
+endfunction " }}}2
+
+function! syntastic#log#debugDump(level) abort " {{{2
+    if !s:_isDebugEnabled(a:level)
+        return
+    endif
+
+    call syntastic#log#debugShowVariables( a:level, sort(keys(g:_SYNTASTIC_DEFAULTS)) )
+endfunction " }}}2
+
+" }}}1
+
+" Private functions {{{1
+
+function! s:_isDebugEnabled_smart(level) abort " {{{2
+    return and(g:syntastic_debug, a:level)
+endfunction " }}}2
+
+function! s:_isDebugEnabled_dumb(level) abort " {{{2
+    " poor man's bit test for bit N, assuming a:level == 2**N
+    return (g:syntastic_debug / a:level) % 2
+endfunction " }}}2
+
+let s:_isDebugEnabled = function(exists('*and') ? 's:_isDebugEnabled_smart' : 's:_isDebugEnabled_dumb')
+lockvar s:_isDebugEnabled
+
+function! s:_logRedirect(on) abort " {{{2
+    if exists('g:syntastic_debug_file')
+        if a:on
+            try
+                execute 'redir >> ' . fnameescape(expand(g:syntastic_debug_file, 1))
+            catch /\m^Vim\%((\a\+)\)\=:/
+                silent! redir END
+                unlet g:syntastic_debug_file
+            endtry
+        else
+            silent! redir END
+        endif
+    endif
+endfunction " }}}2
+
+" }}}1
+
+" Utilities {{{1
+
+function! s:_log_timestamp() abort " {{{2
+    return 'syntastic: ' . split(reltimestr(reltime(g:_SYNTASTIC_START)))[0] . ': '
+endfunction " }}}2
+
+function! s:_format_variable(name) abort " {{{2
+    let vals = []
+    if exists('g:syntastic_' . a:name)
+        call add(vals, 'g:syntastic_' . a:name . ' = ' . strtrans(string(g:syntastic_{a:name})))
+    endif
+    if exists('b:syntastic_' . a:name)
+        call add(vals, 'b:syntastic_' . a:name . ' = ' . strtrans(string(b:syntastic_{a:name})))
+    endif
+
+    return join(vals, ', ')
+endfunction " }}}2
+
+" }}}1
+
+let &cpo = s:save_cpo
+unlet s:save_cpo
+
+" vim: set sw=4 sts=4 et fdm=marker:

vim/autoload/syntastic/postprocess.vim

@@ -0,0 +1,73 @@
+if exists('g:loaded_syntastic_postprocess_autoload') || !exists('g:loaded_syntastic_plugin')
+    finish
+endif
+let g:loaded_syntastic_postprocess_autoload = 1
+
+let s:save_cpo = &cpo
+set cpo&vim
+
+" Public functions {{{1
+
+" merge consecutive blanks
+function! syntastic#postprocess#compressWhitespace(errors) abort " {{{2
+    for e in a:errors
+        let e['text'] = substitute(e['text'], "\001", '', 'g')
+        let e['text'] = substitute(e['text'], '\n', ' ', 'g')
+        let e['text'] = substitute(e['text'], '\m\s\{2,}', ' ', 'g')
+        let e['text'] = substitute(e['text'], '\m^\s\+', '', '')
+        let e['text'] = substitute(e['text'], '\m\s\+$', '', '')
+    endfor
+
+    return a:errors
+endfunction " }}}2
+
+" remove spurious CR under Cygwin
+function! syntastic#postprocess#cygwinRemoveCR(errors) abort " {{{2
+    if has('win32unix')
+        for e in a:errors
+            let e['text'] = substitute(e['text'], '\r', '', 'g')
+        endfor
+    endif
+
+    return a:errors
+endfunction " }}}2
+
+" decode XML entities
+function! syntastic#postprocess#decodeXMLEntities(errors) abort " {{{2
+    for e in a:errors
+        let e['text'] = syntastic#util#decodeXMLEntities(e['text'])
+    endfor
+
+    return a:errors
+endfunction " }}}2
+
+" filter out errors referencing other files
+function! syntastic#postprocess#filterForeignErrors(errors) abort " {{{2
+    return filter(copy(a:errors), 'get(v:val, "bufnr") == ' . bufnr(''))
+endfunction " }}}2
+
+" make sure line numbers are not past end of buffers
+" XXX: this loads all referenced buffers in memory
+function! syntastic#postprocess#guards(errors) abort " {{{2
+    let buffers = syntastic#util#unique(map(filter(copy(a:errors), 'v:val["valid"]'), 'str2nr(v:val["bufnr"])'))
+
+    let guards = {}
+    for b in buffers
+        let guards[b] = len(getbufline(b, 1, '$'))
+    endfor
+
+    for e in a:errors
+        if e['valid'] && e['lnum'] > guards[e['bufnr']]
+            let e['lnum'] = guards[e['bufnr']]
+        endif
+    endfor
+
+    return a:errors
+endfunction " }}}2
+
+" }}}1
+
+let &cpo = s:save_cpo
+unlet s:save_cpo
+
+" vim: set sw=4 sts=4 et fdm=marker:

vim/autoload/syntastic/preprocess.vim

@@ -0,0 +1,316 @@
+if exists('g:loaded_syntastic_preprocess_autoload') || !exists('g:loaded_syntastic_plugin')
+    finish
+endif
+let g:loaded_syntastic_preprocess_autoload = 1
+
+let s:save_cpo = &cpo
+set cpo&vim
+
+" Public functions {{{1
+
+function! syntastic#preprocess#cabal(errors) abort " {{{2
+    let out = []
+    let star = 0
+    for err in a:errors
+        if star
+            if err ==# ''
+                let star = 0
+            else
+                let out[-1] .= ' ' . err
+            endif
+        else
+            call add(out, err)
+            if err =~# '\m^*\s'
+                let star = 1
+            endif
+        endif
+    endfor
+    return out
+endfunction " }}}2
+
+function! syntastic#preprocess#checkstyle(errors) abort " {{{2
+    let out = []
+    let fname = expand('%', 1)
+    for err in a:errors
+        if match(err, '\m<error\>') > -1
+            let line = str2nr(matchstr(err, '\m\<line="\zs\d\+\ze"'))
+            if line == 0
+                continue
+            endif
+
+            let col = str2nr(matchstr(err, '\m\<column="\zs\d\+\ze"'))
+
+            let type = matchstr(err, '\m\<severity="\zs.\ze')
+            if type !~? '^[EW]'
+                let type = 'E'
+            endif
+
+            let message = syntastic#util#decodeXMLEntities(matchstr(err, '\m\<message="\zs[^"]\+\ze"'))
+
+            call add(out, join([fname, type, line, col, message], ':'))
+        elseif match(err, '\m<file name="') > -1
+            let fname = syntastic#util#decodeXMLEntities(matchstr(err, '\v\<file name\="\zs[^"]+\ze"'))
+        endif
+    endfor
+    return out
+endfunction " }}}2
+
+function! syntastic#preprocess#cppcheck(errors) abort " {{{2
+    return map(copy(a:errors), 'substitute(v:val, ''\v^\[[^]]+\]\zs( -\> \[[^]]+\])+\ze:'', "", "")')
+endfunction " }}}2
+
+" @vimlint(EVL102, 1, l:true)
+" @vimlint(EVL102, 1, l:false)
+" @vimlint(EVL102, 1, l:null)
+function! syntastic#preprocess#flow(errors) abort " {{{2
+    " JSON artifacts
+    let true = 1
+    let false = 0
+    let null = ''
+
+    " A hat tip to Marc Weber for this trick
+    " http://stackoverflow.com/questions/17751186/iterating-over-a-string-in-vimscript-or-parse-a-json-file/19105763#19105763
+    try
+        let errs = eval(join(a:errors, ''))
+    catch
+        let errs = {}
+    endtry
+
+    let out = []
+    if type(errs) == type({}) && has_key(errs, 'errors') && type(errs['errors']) == type([])
+        for e in errs['errors']
+            if type(e) == type({}) && has_key(e, 'message') && type(e['message']) == type([]) && len(e['message'])
+                let m = e['message'][0]
+                let t = e['message'][1:]
+
+                try
+                    let msg =
+                        \ m['path'] . ':' .
+                        \ m['line'] . ':' .
+                        \ m['start'] . ':' .
+                        \ (m['line'] ==# m['endline'] && str2nr(m['end']) > 0 ? m['end'] . ':' : '') .
+                        \ ' ' . m['descr']
+
+                    if len(t)
+                        let msg .= ' ' . join(map(t,
+                            \ 'v:val["descr"] . " (" . v:val["path"] . ":" . v:val["line"] . ":" . v:val["start"] . ' .
+                            \ '"," . (v:val["line"] !=# v:val["endline"] ? v:val["endline"] . ":" : "") . ' .
+                            \ 'v:val["end"] . ")"'))
+                    endif
+
+                    let msg = substitute(msg, '\r', '', 'g')
+                    let msg = substitute(msg, '\n', ' ', 'g')
+
+                    call add(out, msg)
+                catch /\m^Vim\%((\a\+)\)\=:E716/
+                    call syntastic#log#warn('checker javascript/flow: unknown error format')
+                    let out = []
+                    break
+                endtry
+            else
+                call syntastic#log#warn('checker javascript/flow: unknown error format')
+                let out = []
+                break
+            endif
+        endfor
+    else
+        call syntastic#log#warn('checker javascript/flow: unknown error format')
+    endif
+
+    return out
+endfunction " }}}2
+" @vimlint(EVL102, 0, l:true)
+" @vimlint(EVL102, 0, l:false)
+" @vimlint(EVL102, 0, l:null)
+
+function! syntastic#preprocess#killEmpty(errors) abort " {{{2
+    return filter(copy(a:errors), 'v:val !=# ""')
+endfunction " }}}2
+
+function! syntastic#preprocess#perl(errors) abort " {{{2
+    let out = []
+
+    for e in a:errors
+        let parts = matchlist(e, '\v^(.*)\sat\s(.{-})\sline\s(\d+)(.*)$')
+        if !empty(parts)
+            call add(out, parts[2] . ':' . parts[3] . ':' . parts[1] . parts[4])
+        endif
+    endfor
+
+    return syntastic#util#unique(out)
+endfunction " }}}2
+
+" @vimlint(EVL102, 1, l:true)
+" @vimlint(EVL102, 1, l:false)
+" @vimlint(EVL102, 1, l:null)
+function! syntastic#preprocess#prospector(errors) abort " {{{2
+    " JSON artifacts
+    let true = 1
+    let false = 0
+    let null = ''
+
+    " A hat tip to Marc Weber for this trick
+    " http://stackoverflow.com/questions/17751186/iterating-over-a-string-in-vimscript-or-parse-a-json-file/19105763#19105763
+    try
+        let errs = eval(join(a:errors, ''))
+    catch
+        let errs = {}
+    endtry
+
+    let out = []
+    if type(errs) == type({}) && has_key(errs, 'messages')
+        if type(errs['messages']) == type([])
+            for e in errs['messages']
+                if type(e) == type({})
+                    try
+                        if e['source'] ==# 'pylint'
+                            let e['location']['character'] += 1
+                        endif
+
+                        let msg =
+                            \ e['location']['path'] . ':' .
+                            \ e['location']['line'] . ':' .
+                            \ e['location']['character'] . ': ' .
+                            \ e['code'] . ' ' .
+                            \ e['message'] . ' ' .
+                            \ '[' . e['source'] . ']'
+
+                        call add(out, msg)
+                    catch /\m^Vim\%((\a\+)\)\=:E716/
+                        call syntastic#log#warn('checker python/prospector: unknown error format')
+                        let out = []
+                        break
+                    endtry
+                else
+                    call syntastic#log#warn('checker python/prospector: unknown error format')
+                    let out = []
+                    break
+                endif
+            endfor
+        else
+            call syntastic#log#warn('checker python/prospector: unknown error format')
+        endif
+    endif
+
+    return out
+endfunction " }}}2
+" @vimlint(EVL102, 0, l:true)
+" @vimlint(EVL102, 0, l:false)
+" @vimlint(EVL102, 0, l:null)
+
+function! syntastic#preprocess#rparse(errors) abort " {{{2
+    let errlist = copy(a:errors)
+
+    " remove uninteresting lines and handle continuations
+    let i = 0
+    while i < len(errlist)
+        if i > 0 && errlist[i][:1] ==# '  ' && errlist[i] !~# '\m\s\+\^$'
+            let errlist[i-1] .= errlist[i][1:]
+            call remove(errlist, i)
+        elseif errlist[i] !~# '\m^\(Lint:\|Lint checking:\|Error in\) '
+            call remove(errlist, i)
+        else
+            let i += 1
+        endif
+    endwhile
+
+    let out = []
+    let fname = ''
+    for e in errlist
+        if match(e, '\m^Lint: ') == 0
+            let parts = matchlist(e, '\m^Lint: \(.*\): found on lines \([0-9, ]\+\)\(+\(\d\+\) more\)\=')
+            if len(parts) >= 3
+                for line in split(parts[2], '\m,\s*')
+                    call add(out, 'E:' . fname . ':' . line . ': ' . parts[1])
+                endfor
+            endif
+            if len(parts) >= 5 && parts[4] !=# ''
+                call add(out, 'E:' . fname . ':0: ' . parts[1] . ' - ' . parts[4] . ' messages not shown')
+            endif
+        elseif match(e, '\m^Lint checking: ') == 0
+            let fname = matchstr(e, '\m^Lint checking: \zs.*')
+        elseif match(e, '\m^Error in ') == 0
+            call add(out, substitute(e, '\m^Error in .\+ : .\+\ze:\d\+:\d\+: ', 'E:' . fname, ''))
+        endif
+    endfor
+
+    return out
+endfunction " }}}2
+
+function! syntastic#preprocess#tslint(errors) abort " {{{2
+    return map(copy(a:errors), 'substitute(v:val, ''\m^\(([^)]\+)\)\s\(.\+\)$'', ''\2 \1'', "")')
+endfunction " }}}2
+
+function! syntastic#preprocess#validator(errors) abort " {{{2
+    let out = []
+    for e in a:errors
+        let parts = matchlist(e, '\v^"([^"]+)"(.+)')
+        if len(parts) >= 3
+            " URL decode, except leave alone any "+"
+            let parts[1] = substitute(parts[1], '\m%\(\x\x\)', '\=nr2char("0x".submatch(1))', 'g')
+            let parts[1] = substitute(parts[1], '\m\\"', '"', 'g')
+            let parts[1] = substitute(parts[1], '\m\\\\', '\\', 'g')
+            call add(out, '"' . parts[1] . '"' . parts[2])
+        endif
+    endfor
+    return out
+endfunction " }}}2
+
+" @vimlint(EVL102, 1, l:true)
+" @vimlint(EVL102, 1, l:false)
+" @vimlint(EVL102, 1, l:null)
+function! syntastic#preprocess#vint(errors) abort " {{{2
+    " JSON artifacts
+    let true = 1
+    let false = 0
+    let null = ''
+
+    " A hat tip to Marc Weber for this trick
+    " http://stackoverflow.com/questions/17751186/iterating-over-a-string-in-vimscript-or-parse-a-json-file/19105763#19105763
+    try
+        let errs = eval(join(a:errors, ''))
+    catch
+        let errs = []
+    endtry
+
+    let out = []
+    if type(errs) == type([])
+        for e in errs
+            if type(e) == type({})
+                try
+                    let msg =
+                        \ e['file_path'] . ':' .
+                        \ e['line_number'] . ':' .
+                        \ e['column_number'] . ':' .
+                        \ e['severity'][0] . ': ' .
+                        \ e['description'] . ' (' .
+                        \ e['policy_name'] . ')'
+
+                    call add(out, msg)
+                catch /\m^Vim\%((\a\+)\)\=:E716/
+                    call syntastic#log#warn('checker vim/vint: unknown error format')
+                    let out = []
+                    break
+                endtry
+            else
+                call syntastic#log#warn('checker vim/vint: unknown error format')
+                let out = []
+                break
+            endif
+        endfor
+    else
+        call syntastic#log#warn('checker vim/vint: unknown error format')
+    endif
+
+    return out
+endfunction " }}}2
+" @vimlint(EVL102, 0, l:true)
+" @vimlint(EVL102, 0, l:false)
+" @vimlint(EVL102, 0, l:null)
+
+" }}}1
+
+let &cpo = s:save_cpo
+unlet s:save_cpo
+
+" vim: set sw=4 sts=4 et fdm=marker:

vim/autoload/syntastic/util.vim

@@ -0,0 +1,414 @@
+if exists('g:loaded_syntastic_util_autoload') || !exists('g:loaded_syntastic_plugin')
+    finish
+endif
+let g:loaded_syntastic_util_autoload = 1
+
+let s:save_cpo = &cpo
+set cpo&vim
+
+" Public functions {{{1
+
+function! syntastic#util#isRunningWindows() abort " {{{2
+    return has('win16') || has('win32') || has('win64')
+endfunction " }}}2
+
+function! syntastic#util#DevNull() abort " {{{2
+    if syntastic#util#isRunningWindows()
+        return 'NUL'
+    endif
+    return '/dev/null'
+endfunction " }}}2
+
+" Get directory separator
+function! syntastic#util#Slash() abort " {{{2
+    return (!exists('+shellslash') || &shellslash) ? '/' : '\'
+endfunction " }}}2
+
+function! syntastic#util#CygwinPath(path) abort " {{{2
+    return substitute(syntastic#util#system('cygpath -m ' . syntastic#util#shescape(a:path)), "\n", '', 'g')
+endfunction " }}}2
+
+function! syntastic#util#system(command) abort " {{{2
+    let old_shell = &shell
+    let old_lc_messages = $LC_MESSAGES
+    let old_lc_all = $LC_ALL
+
+    let &shell = syntastic#util#var('shell')
+    let $LC_MESSAGES = 'C'
+    let $LC_ALL = ''
+
+    let out = system(a:command)
+
+    let $LC_ALL = old_lc_all
+    let $LC_MESSAGES = old_lc_messages
+
+    let &shell = old_shell
+
+    return out
+endfunction " }}}2
+
+" Create a temporary directory
+function! syntastic#util#tmpdir() abort " {{{2
+    let tempdir = ''
+
+    if (has('unix') || has('mac')) && executable('mktemp')
+        " TODO: option "-t" to mktemp(1) is not portable
+        let tmp = $TMPDIR !=# '' ? $TMPDIR : $TMP !=# '' ? $TMP : '/tmp'
+        let out = split(syntastic#util#system('mktemp -q -d ' . tmp . '/vim-syntastic-' . getpid() . '-XXXXXXXX'), "\n")
+        if v:shell_error == 0 && len(out) == 1
+            let tempdir = out[0]
+        endif
+    endif
+
+    if tempdir ==# ''
+        if has('win32') || has('win64')
+            let tempdir = $TEMP . syntastic#util#Slash() . 'vim-syntastic-' . getpid()
+        elseif has('win32unix')
+            let tempdir = syntastic#util#CygwinPath('/tmp/vim-syntastic-'  . getpid())
+        elseif $TMPDIR !=# ''
+            let tempdir = $TMPDIR . '/vim-syntastic-' . getpid()
+        else
+            let tempdir = '/tmp/vim-syntastic-' . getpid()
+        endif
+
+        try
+            call mkdir(tempdir, 'p', 0700)
+        catch /\m^Vim\%((\a\+)\)\=:E739/
+            call syntastic#log#error(v:exception)
+            let tempdir = '.'
+        endtry
+    endif
+
+    return tempdir
+endfunction " }}}2
+
+" Recursively remove a directory
+function! syntastic#util#rmrf(what) abort " {{{2
+    " try to make sure we don't delete directories we didn't create
+    if a:what !~? 'vim-syntastic-'
+        return
+    endif
+
+    if  getftype(a:what) ==# 'dir'
+        if !exists('s:rmrf')
+            let s:rmrf =
+                \ has('unix') || has('mac') ? 'rm -rf' :
+                \ has('win32') || has('win64') ? 'rmdir /S /Q' :
+                \ has('win16') || has('win95') || has('dos16') || has('dos32') ? 'deltree /Y' : ''
+        endif
+
+        if s:rmrf !=# ''
+            silent! call syntastic#util#system(s:rmrf . ' ' . syntastic#util#shescape(a:what))
+        else
+            call s:_rmrf(a:what)
+        endif
+    else
+        silent! call delete(a:what)
+    endif
+endfunction " }}}2
+
+"search the first 5 lines of the file for a magic number and return a map
+"containing the args and the executable
+"
+"e.g.
+"
+"#!/usr/bin/perl -f -bar
+"
+"returns
+"
+"{'exe': '/usr/bin/perl', 'args': ['-f', '-bar']}
+function! syntastic#util#parseShebang() abort " {{{2
+    for lnum in range(1, 5)
+        let line = getline(lnum)
+        if line =~# '^#!'
+            let line = substitute(line, '\v^#!\s*(\S+/env(\s+-\S+)*\s+)?', '', '')
+            let exe = matchstr(line, '\m^\S*\ze')
+            let args = split(matchstr(line, '\m^\S*\zs.*'))
+            return { 'exe': exe, 'args': args }
+        endif
+    endfor
+
+    return { 'exe': '', 'args': [] }
+endfunction " }}}2
+
+" Get the value of a variable.  Allow local variables to override global ones.
+function! syntastic#util#var(name, ...) abort " {{{2
+    return
+        \ exists('b:syntastic_' . a:name) ? b:syntastic_{a:name} :
+        \ exists('g:syntastic_' . a:name) ? g:syntastic_{a:name} :
+        \ a:0 > 0 ? a:1 : ''
+endfunction " }}}2
+
+" Parse a version string.  Return an array of version components.
+function! syntastic#util#parseVersion(version, ...) abort " {{{2
+    return map(split(matchstr( a:version, a:0 ? a:1 : '\v^\D*\zs\d+(\.\d+)+\ze' ), '\m\.'), 'str2nr(v:val)')
+endfunction " }}}2
+
+" Verify that the 'installed' version is at least the 'required' version.
+"
+" 'installed' and 'required' must be arrays. If they have different lengths,
+" the "missing" elements will be assumed to be 0 for the purposes of checking.
+"
+" See http://semver.org for info about version numbers.
+function! syntastic#util#versionIsAtLeast(installed, required) abort " {{{2
+    return syntastic#util#compareLexi(a:installed, a:required) >= 0
+endfunction " }}}2
+
+" Almost lexicographic comparison of two lists of integers. :) If lists
+" have different lengths, the "missing" elements are assumed to be 0.
+function! syntastic#util#compareLexi(a, b) abort " {{{2
+    for idx in range(max([len(a:a), len(a:b)]))
+        let a_element = str2nr(get(a:a, idx, 0))
+        let b_element = str2nr(get(a:b, idx, 0))
+        if a_element != b_element
+            return a_element > b_element ? 1 : -1
+        endif
+    endfor
+    " still here, thus everything matched
+    return 0
+endfunction " }}}2
+
+" strwidth() was added in Vim 7.3; if it doesn't exist, we use strlen()
+" and hope for the best :)
+let s:_width = function(exists('*strwidth') ? 'strwidth' : 'strlen')
+lockvar s:_width
+
+function! syntastic#util#screenWidth(str, tabstop) abort " {{{2
+    let chunks = split(a:str, "\t", 1)
+    let width = s:_width(chunks[-1])
+    for c in chunks[:-2]
+        let cwidth = s:_width(c)
+        let width += cwidth + a:tabstop - cwidth % a:tabstop
+    endfor
+    return width
+endfunction " }}}2
+
+"print as much of a:msg as possible without "Press Enter" prompt appearing
+function! syntastic#util#wideMsg(msg) abort " {{{2
+    let old_ruler = &ruler
+    let old_showcmd = &showcmd
+
+    "This is here because it is possible for some error messages to
+    "begin with \n which will cause a "press enter" prompt.
+    let msg = substitute(a:msg, "\n", '', 'g')
+
+    "convert tabs to spaces so that the tabs count towards the window
+    "width as the proper amount of characters
+    let chunks = split(msg, "\t", 1)
+    let msg = join(map(chunks[:-2], 'v:val . repeat(" ", &tabstop - s:_width(v:val) % &tabstop)'), '') . chunks[-1]
+    let msg = strpart(msg, 0, &columns - 1)
+
+    set noruler noshowcmd
+    call syntastic#util#redraw(0)
+
+    echo msg
+
+    let &ruler = old_ruler
+    let &showcmd = old_showcmd
+endfunction " }}}2
+
+" Check whether a buffer is loaded, listed, and not hidden
+function! syntastic#util#bufIsActive(buffer) abort " {{{2
+    " convert to number, or hell breaks loose
+    let buf = str2nr(a:buffer)
+
+    if !bufloaded(buf) || !buflisted(buf)
+        return 0
+    endif
+
+    " get rid of hidden buffers
+    for tab in range(1, tabpagenr('$'))
+        if index(tabpagebuflist(tab), buf) >= 0
+            return 1
+        endif
+    endfor
+
+    return 0
+endfunction " }}}2
+
+" start in directory a:where and walk up the parent folders until it
+" finds a file matching a:what; return path to that file
+function! syntastic#util#findInParent(what, where) abort " {{{2
+    let here = fnamemodify(a:where, ':p')
+
+    let root = syntastic#util#Slash()
+    if syntastic#util#isRunningWindows() && here[1] ==# ':'
+        " The drive letter is an ever-green source of fun.  That's because
+        " we don't care about running syntastic on Amiga these days. ;)
+        let root = fnamemodify(root, ':p')
+        let root = here[0] . root[1:]
+    endif
+
+    let old = ''
+    while here !=# ''
+        let p = split(globpath(here, a:what, 1), '\n')
+
+        if !empty(p)
+            return fnamemodify(p[0], ':p')
+        elseif here ==? root || here ==? old
+            break
+        endif
+
+        let old = here
+
+        " we use ':h:h' rather than ':h' since ':p' adds a trailing '/'
+        " if 'here' is a directory
+        let here = fnamemodify(here, ':p:h:h')
+    endwhile
+
+    return ''
+endfunction " }}}2
+
+" Returns unique elements in a list
+function! syntastic#util#unique(list) abort " {{{2
+    let seen = {}
+    let uniques = []
+    for e in a:list
+        if !has_key(seen, e)
+            let seen[e] = 1
+            call add(uniques, e)
+        endif
+    endfor
+    return uniques
+endfunction " }}}2
+
+" A less noisy shellescape()
+function! syntastic#util#shescape(string) abort " {{{2
+    return a:string =~# '\m^[A-Za-z0-9_/.-]\+$' ? a:string : shellescape(a:string)
+endfunction " }}}2
+
+" A less noisy shellescape(expand())
+function! syntastic#util#shexpand(string, ...) abort " {{{2
+    return syntastic#util#shescape(a:0 ? expand(a:string, a:1) : expand(a:string, 1))
+endfunction " }}}2
+
+" Escape arguments
+function! syntastic#util#argsescape(opt) abort " {{{2
+    if type(a:opt) == type('') && a:opt !=# ''
+        return [a:opt]
+    elseif type(a:opt) == type([])
+        return map(copy(a:opt), 'syntastic#util#shescape(v:val)')
+    endif
+
+    return []
+endfunction " }}}2
+
+" decode XML entities
+function! syntastic#util#decodeXMLEntities(string) abort " {{{2
+    let str = a:string
+    let str = substitute(str, '\m&lt;', '<', 'g')
+    let str = substitute(str, '\m&gt;', '>', 'g')
+    let str = substitute(str, '\m&quot;', '"', 'g')
+    let str = substitute(str, '\m&apos;', "'", 'g')
+    let str = substitute(str, '\m&amp;', '\&', 'g')
+    return str
+endfunction " }}}2
+
+function! syntastic#util#redraw(full) abort " {{{2
+    if a:full
+        redraw!
+    else
+        redraw
+    endif
+endfunction " }}}2
+
+function! syntastic#util#dictFilter(errors, filter) abort " {{{2
+    let rules = s:_translateFilter(a:filter)
+    " call syntastic#log#debug(g:_SYNTASTIC_DEBUG_TRACE, "applying filter:", rules)
+    try
+        call filter(a:errors, rules)
+    catch /\m^Vim\%((\a\+)\)\=:E/
+        let msg = matchstr(v:exception, '\m^Vim\%((\a\+)\)\=:\zs.*')
+        call syntastic#log#error('quiet_messages: ' . msg)
+    endtry
+endfunction " }}}2
+
+" Return a [seconds, fractions] list of strings, representing the
+" (hopefully high resolution) time since program start
+function! syntastic#util#stamp() abort " {{{2
+    return split( split(reltimestr(reltime(g:_SYNTASTIC_START)))[0], '\.' )
+endfunction " }}}2
+
+" }}}1
+
+" Private functions {{{1
+
+function! s:_translateFilter(filters) abort " {{{2
+    let conditions = []
+    for k in keys(a:filters)
+        if type(a:filters[k]) == type([])
+            call extend(conditions, map(copy(a:filters[k]), 's:_translateElement(k, v:val)'))
+        else
+            call add(conditions, s:_translateElement(k, a:filters[k]))
+        endif
+    endfor
+
+    if conditions == []
+        let conditions = ['1']
+    endif
+    return len(conditions) == 1 ? conditions[0] : join(map(conditions, '"(" . v:val . ")"'), ' && ')
+endfunction " }}}2
+
+function! s:_translateElement(key, term) abort " {{{2
+    let fkey = a:key
+    if fkey[0] ==# '!'
+        let fkey = fkey[1:]
+        let not = 1
+    else
+        let not = 0
+    endif
+
+    if fkey ==? 'level'
+        let op = not ? ' ==? ' : ' !=? '
+        let ret = 'v:val["type"]' . op . string(a:term[0])
+    elseif fkey ==? 'type'
+        if a:term ==? 'style'
+            let op = not ? ' ==? ' : ' !=? '
+            let ret = 'get(v:val, "subtype", "")' . op . '"style"'
+        else
+            let op = not ? '!' : ''
+            let ret = op . 'has_key(v:val, "subtype")'
+        endif
+    elseif fkey ==? 'regex'
+        let op = not ? ' =~? ' : ' !~? '
+        let ret = 'v:val["text"]' . op . string(a:term)
+    elseif fkey ==? 'file' || fkey[:4] ==? 'file:'
+        let op = not ? ' =~# ' : ' !~# '
+        let ret = 'bufname(str2nr(v:val["bufnr"]))'
+        let mod = fkey[4:]
+        if mod !=# ''
+            let ret = 'fnamemodify(' . ret . ', ' . string(mod) . ')'
+        endif
+        let ret .= op . string(a:term)
+    else
+        call syntastic#log#warn('quiet_messages: ignoring invalid key ' . strtrans(string(fkey)))
+        let ret = '1'
+    endif
+    return ret
+endfunction " }}}2
+
+function! s:_rmrf(what) abort " {{{2
+    if !exists('s:rmdir')
+        let s:rmdir = syntastic#util#shescape(get(g:, 'netrw_localrmdir', 'rmdir'))
+    endif
+
+    if getftype(a:what) ==# 'dir'
+        if filewritable(a:what) != 2
+            return
+        endif
+
+        for f in split(globpath(a:what, '*', 1), "\n")
+            call s:_rmrf(f)
+        endfor
+        silent! call syntastic#util#system(s:rmdir . ' ' . syntastic#util#shescape(a:what))
+    else
+        silent! call delete(a:what)
+    endif
+endfunction " }}}2
+
+" }}}1
+
+let &cpo = s:save_cpo
+unlet s:save_cpo
+
+" vim: set sw=4 sts=4 et fdm=marker:

vim/doc/syntastic.txt

@@ -0,0 +1,956 @@
+*syntastic.txt*   Syntax checking on the fly has never been so pimp.
+*syntastic*
+
+
+                    It's a bird! It's a plane! ZOMG It's ... ~
+
+                   _____             __             __  _      ~
+                  / ___/__  ______  / /_____ ______/ /_(_)____ ~
+                  \__ \/ / / / __ \/ __/ __ `/ ___/ __/ / ___/ ~
+                 ___/ / /_/ / / / / /_/ /_/ (__  ) /_/ / /__   ~
+                /____/\__, /_/ /_/\__/\__,_/____/\__/_/\___/   ~
+                     /____/                                    ~
+
+
+
+                              Reference Manual~
+
+
+==============================================================================
+CONTENTS                                                  *syntastic-contents*
+
+    1.Intro........................................|syntastic-intro|
+        1.1.Quick start............................|syntastic-quickstart|
+        1.2.Recommended settings...................|syntastic-recommended|
+    2.Functionality provided.......................|syntastic-functionality|
+        2.1.The statusline flag....................|syntastic-statusline-flag|
+        2.2.Error signs............................|syntastic-error-signs|
+        2.3.Error window...........................|syntastic-error-window|
+        2.4.Error highlighting.....................|syntastic-highlighting|
+        2.5.Aggregating errors.....................|syntastic-aggregating-errors|
+        2.6.Filtering errors.......................|syntastic-filtering-errors|
+    3.Commands.....................................|syntastic-commands|
+    4.Global Options...............................|syntastic-global-options|
+    5.Checker Options..............................|syntastic-checker-options|
+        5.1.Choosing which checkers to use.........|syntastic-filetype-checkers|
+        5.2.Choosing the executable................|syntastic-config-exec|
+        5.3.Configuring specific checkers..........|syntastic-config-makeprg|
+        5.4.Sorting errors.........................|syntastic-config-sort|
+    6.Notes........................................|syntastic-notes|
+        6.1.Handling of composite filetypes........|syntastic-composite|
+        6.2.Editing files over network.............|syntastic-netrw|
+        6.3.The 'shellslash' option................|syntastic-shellslash|
+    7.Compatibility with other software............|syntastic-compatibility|
+        7.1.The csh and tcsh shells................|syntastic-csh|
+        7.2.Eclim..................................|syntastic-eclim|
+        7.3.The fish shell.........................|syntastic-fish|
+        7.4.The fizsh shell........................|syntastic-fizsh|
+        7.5.powerline..............................|syntastic-powerline|
+        7.6.The PowerShell shell...................|syntastic-powershell|
+        7.7.python-mode............................|syntastic-pymode|
+        7.8.vim-auto-save..........................|syntastic-vim-auto-save|
+        7.9.vim-go.................................|syntastic-vim-go|
+        7.10.vim-virtualenv........................|syntastic-vim-virtualenv|
+        7.11.YouCompleteMe.........................|syntastic-ycm|
+    8.About........................................|syntastic-about|
+    9.License......................................|syntastic-license|
+
+
+==============================================================================
+1. Intro                                                     *syntastic-intro*
+
+Syntastic is a syntax checking plugin that runs files through external syntax
+checkers. This can be done on demand, or automatically as files are saved and
+opened.  If syntax errors are detected, the user is notified and is happy
+because they didn't have to compile their code or execute their script to find
+them.
+
+Syntastic comes in two parts: the syntax checker plugins, and the core. The
+syntax checker plugins are defined on a per-filetype basis where each one wraps
+up an external syntax checking program. The core script delegates off to these
+plugins and uses their output to provide the syntastic functionality.
+
+Take a look at the wiki for a list of supported filetypes and checkers:
+
+    https://github.com/scrooloose/syntastic/wiki/Syntax-Checkers
+
+Note: This doc only deals with using syntastic. To learn how to write syntax
+checker integrations, see the guide on the GitHub wiki:
+
+    https://github.com/scrooloose/syntastic/wiki/Syntax-Checker-Guide
+
+------------------------------------------------------------------------------
+1.1. Quick start                                        *syntastic-quickstart*
+
+Syntastic comes preconfigured with a default list of enabled checkers per
+filetype. This list is kept reasonably short to prevent slowing down Vim or
+trying to use conflicting checkers.
+
+You can see the list of checkers available for the current filetype with the
+|:SyntasticInfo| command.
+
+You probably want to override the configured list of checkers for the
+filetypes you use, and also change the arguments passed to specific checkers
+to suit your needs. See |syntastic-checker-options| below for details.
+
+Use |:SyntasticCheck| to manually check right now. Use |:Errors| to open the
+|location-list| window, and |:lclose| to close it. You can clear the error
+list with |:SyntasticReset|, and you can use |:SyntasticToggleMode| to switch
+between active (checking on writing the buffer) and passive (manual) checking.
+
+You don't have to switch focus to the |location-list| window to jump to the
+different errors.  Vim provides several built-in commands for this, for
+example |:lnext| and |:lprevious|.  You may want to add shortcut mappings for
+these commands, or perhaps install a plugin such as Tim Pope's 'unimpaired'
+(see https://github.com/tpope/vim-unimpaired) that provides such mappings.
+
+------------------------------------------------------------------------------
+1.2. Recommended settings                              *syntastic-recommended*
+
+Syntastic has a large number of options that can be configured, and the
+defaults are not particularly well suitable for new users. It is recommended
+that you start by adding the following lines to your vimrc, and return to them
+later as needed: >
+    set statusline+=%#warningmsg#
+    set statusline+=%{SyntasticStatuslineFlag()}
+    set statusline+=%*
+
+    let g:syntastic_always_populate_loc_list = 1
+    let g:syntastic_auto_loc_list = 1
+    let g:syntastic_check_on_open = 1
+    let g:syntastic_check_on_wq = 0
+<
+==============================================================================
+2. Functionality provided                            *syntastic-functionality*
+
+Syntax checking can be done automatically or on demand (see
+|'syntastic_mode_map'| and |:SyntasticToggleMode| for configuring this).
+
+When syntax checking is done, the features below can be used to notify the
+user of errors. See |syntastic-global-options| for how to configure and
+activate/deactivate these features.
+
+    * A statusline flag
+    * Signs beside lines with errors
+    * The |location-list| can be populated with the errors for the associated
+      buffer
+    * Erroneous parts of lines can be highlighted (this functionality is only
+      provided by some syntax checkers)
+    * Balloons (if the |+balloon_eval| feature is compiled in) can be used to
+      display error messages for erroneous lines when hovering the mouse over
+      them
+    * Error messages from multiple checkers can be aggregated in a single list
+
+------------------------------------------------------------------------------
+2.1. The statusline flag                           *syntastic-statusline-flag*
+
+To use the statusline flag, this must appear in your |'statusline'| setting >
+    %{SyntasticStatuslineFlag()}
+<
+Something like this could be more useful: >
+    set statusline+=%#warningmsg#
+    set statusline+=%{SyntasticStatuslineFlag()}
+    set statusline+=%*
+<
+When syntax errors are detected a flag will be shown. The content of the flag
+is derived from the |syntastic_stl_format| option.
+
+------------------------------------------------------------------------------
+2.2. Error signs                                       *syntastic-error-signs*
+
+Syntastic uses the |:sign| commands to mark lines with errors and warnings in
+the sign column. To enable this feature, use the |'syntastic_enable_signs'|
+option.
+
+Signs are colored using the Error and Todo syntax highlight groups by default.
+If you wish to customize the colors for the signs, you can use the following
+groups:
+    SyntasticErrorSign - For syntax errors, links to 'error' by default
+    SyntasticWarningSign - For syntax warnings, links to 'todo' by default
+    SyntasticStyleErrorSign - For style errors, links to 'SyntasticErrorSign'
+                              by default
+    SyntasticStyleWarningSign - For style warnings, links to
+                                'SyntasticWarningSign' by default
+
+Example: >
+    highlight SyntasticErrorSign guifg=white guibg=red
+<
+To set up highlighting for the line where a sign resides, you can use the
+following highlight groups:
+    SyntasticErrorLine
+    SyntasticWarningLine
+    SyntasticStyleErrorLine - Links to 'SyntasticErrorLine' by default
+    SyntasticStyleWarningLine - Links to 'SyntasticWarningLine' by default
+
+Example: >
+    highlight SyntasticErrorLine guibg=#2f0000
+<
+------------------------------------------------------------------------------
+2.3. The error window                                   *syntastic-error-window*
+
+You can use the |:Errors| command to display the errors for the current buffer
+in the |location-list|.
+
+Note that when you use |:Errors| the current location list is overwritten with
+Syntastic's own location list. The location list is also overwritten when
+|syntastic_auto_jump| is non-zero and the cursor has to jump to an issue.
+
+By default syntastic doesn't fill the |location-list| with the errors found by
+the checkers, in order to reduce clashes with other plugins. Consequently, if
+you run |:lopen| or |:lwindow| rather than |:Errors| to open the error window you
+wouldn't see syntastic's list of errors. If you insist on using |:lopen| or
+|:lwindow| you should either run |:SyntasticSetLoclist| after running the checks,
+or set |syntastic_always_populate_loc_list| which tells syntastic to update the
+|location-list| automatically.
+
+------------------------------------------------------------------------------
+2.4. Error highlighting                               *syntastic-highlighting*
+
+Some checkers provide enough information for syntastic to be able to highlight
+errors. By default the SpellBad syntax highlight group is used to color errors,
+and the SpellCap group is used for warnings. If you wish to customize the
+colors for highlighting you can use the following groups:
+    SyntasticError - Links to 'SpellBad' by default
+    SyntasticWarning - Links to 'SpellCap' by default
+    SyntasticStyleError - Links to SyntasticError by default
+    SyntasticStyleWarning - Links to SyntasticWarning by default
+
+Example: >
+    highlight SyntasticError guibg=#2f0000
+<
+------------------------------------------------------------------------------
+2.5. Aggregating errors                         *syntastic-aggregating-errors*
+
+By default, namely if |'syntastic_aggregate_errors'| is unset, syntastic runs
+in turn the checkers corresponding to the filetype of the current file (see
+|syntastic-filetype-checkers|), and stops as soon as a checker reports any
+errors. It then notifies you of the errors using the notification mechanisms
+above. In this mode error lists are always produced by a single checker, and,
+if you open the error window, the name of the checker that generated the errors
+is shown on the statusline of the error window.
+
+If |'syntastic_aggregate_errors'| is set, syntastic runs all checkers that
+apply (still cf. |syntastic-filetype-checkers|), then aggregates errors found
+by all checkers in a single list, and notifies you. In this mode each error
+message is labeled with the name of the checker that generated it, but you can
+disable generation of these labels by turning off '|syntastic_id_checkers|'.
+
+If |'syntastic_sort_aggregated_errors'| is set (which is the default), messages
+in the aggregated list are grouped by file, then sorted by line number, then
+type, then column number.  Otherwise messages produced by the same checker are
+grouped together, and sorting within each group is decided by the variables
+|'syntastic_<filetype>_<checker>_sort'|.
+
+------------------------------------------------------------------------------
+2.6 Filtering errors                              *syntastic-filtering-errors*
+
+You can selectively disable some of the errors found by checkers either
+using |'syntastic_quiet_messages'|, or by specifying a list of patterns in
+|'syntastic_ignore_files'|.
+
+See also: |'syntastic_<filetype>_<checker>_quiet_messages'|.
+
+==============================================================================
+3. Commands                                               *syntastic-commands*
+
+:Errors                                                              *:Errors*
+
+When errors have been detected, use this command to pop up the |location-list|
+and display the error messages.
+
+Please note that the |:Errors| command overwrites the current location list with
+syntastic's own location list.
+
+:SyntasticToggleMode                                    *:SyntasticToggleMode*
+
+Toggles syntastic between active and passive mode. See |'syntastic_mode_map'|
+for more info.
+
+:SyntasticCheck                                              *:SyntasticCheck*
+
+Manually cause a syntax check to be done.  By default the checkers in the
+|'g:syntastic_<filetype>_checkers'| or |'b:syntastic_checkers'| lists are run,
+cf. |syntastic-filetype-checkers|.  If |syntastic_aggregate_errors| is unset
+(which is the default), checking stops the first time a checker reports any
+errors; if |syntastic_aggregate_errors| is set, all checkers that apply are run
+in turn, and all errors found are aggregated in a single list.
+
+The command may be followed by a (space separated) list of checkers.  In this
+case |'g:syntastic_<filetype>_checkers'| and |'b:syntastic_checkers'| are
+ignored, and the checkers named by the command's arguments are run instead, in
+the order specified.  The rules of |syntastic_aggregate_errors| still apply.
+
+Example: >
+    :SyntasticCheck flake8 pylint
+<
+:SyntasticInfo                                                *:SyntasticInfo*
+
+The command takes an optional argument, and outputs information about the
+checkers available for the filetype named by said argument, or for the current
+filetype if no argument was provided.
+
+:SyntasticReset                                              *:SyntasticReset*
+
+Resets the list of errors and turns off all error notifiers.
+
+:SyntasticSetLoclist                                    *:SyntasticSetLoclist*
+
+If |'syntastic_always_populate_loc_list'| is not set, the |location-list| is
+not filled in automatically with the list of errors detected by the checkers.
+This is useful if you run syntastic along with other plugins that use location
+lists.  The |:SyntasticSetLoclist| command allows you to stick the errors into
+the location list explicitly.
+
+==============================================================================
+4. Global Options                                   *syntastic-global-options*
+
+
+                                                   *'syntastic_check_on_open'*
+Default: 0
+If enabled, syntastic will do syntax checks when buffers are first loaded as
+well as on saving >
+    let g:syntastic_check_on_open = 1
+<
+                                                     *'syntastic_check_on_wq'*
+Default: 1
+Normally syntastic runs syntax checks whenever buffers are written to disk.
+If you want to skip these checks when you issue |:wq|, |:x|, and |:ZZ|, set this
+variable to 0. >
+    let g:syntastic_check_on_wq = 0
+<
+                                                *'syntastic_aggregate_errors'*
+Default: 0
+When enabled, syntastic runs all checkers that apply to the current filetype,
+then aggregates errors found by all checkers and displays them. When disabled,
+syntastic runs each checker in turn, and stops to display the results the first
+time a checker finds any errors. >
+    let g:syntastic_aggregate_errors = 1
+<
+                                                     *'syntastic_id_checkers'*
+Default: 1
+When results from multiple checkers are aggregated in a single error list
+(that is either when |syntastic_aggregate_errors| is enabled, or when checking
+a file with a composite filetype), it might not be immediately obvious which
+checker has produced a given error message. This variable instructs syntastic
+to label error messages with the names of the checkers that created them. >
+    let g:syntastic_id_checkers = 0
+<
+                                          *'syntastic_sort_aggregated_errors'*
+Default: 1
+By default, when results from multiple checkers are aggregated in a single
+error list (that is either when |syntastic_aggregate_errors| is enabled, or
+when checking a file with a composite filetype), errors are grouped by file,
+then sorted by line number, then grouped by type (namely errors take precedence
+over warnings), then they are sorted by column number.  If you want to leave
+messages grouped by checker output, set this variable to 0. >
+    let g:syntastic_sort_aggregated_errors = 0
+<
+                                              *'syntastic_echo_current_error'*
+Default: 1
+If enabled, syntastic will echo current error to the command window. If
+multiple errors are found on the same line, |syntastic_cursor_columns| is used
+to decide which one is shown. >
+    let g:syntastic_echo_current_error = 1
+<
+                                                  *'syntastic_cursor_columns'*
+Default: 1
+This option controls which errors are echoed to the command window if
+|syntastic_echo_current_error| is set and multiple errors are found on the same
+line. When the option is enabled, the first error corresponding to the current
+column is show. Otherwise, the first error on the current line is echoed,
+regardless of the cursor position on the current line.
+
+When dealing with very large lists of errors, disabling this option can speed
+up navigation significantly: >
+    let g:syntastic_cursor_column = 0
+<
+                                                    *'syntastic_enable_signs'*
+Default: 1
+Use this option to tell syntastic whether to use the |:sign| interface to mark
+syntax errors: >
+    let g:syntastic_enable_signs = 1
+<
+                     *'syntastic_error_symbol'* *'syntastic_style_error_symbol'*
+                 *'syntastic_warning_symbol'* *'syntastic_style_warning_symbol'*
+Use this option to control what the syntastic |:sign| text contains. Several
+error symbols can be customized:
+    syntastic_error_symbol - For syntax errors, defaults to '>>'
+    syntastic_style_error_symbol - For style errors, defaults to 'S>'
+    syntastic_warning_symbol - For syntax warnings, defaults to '>>'
+    syntastic_style_warning_symbol - For style warnings, defaults to 'S>'
+
+Example: >
+    let g:syntastic_error_symbol = "✗"
+    let g:syntastic_warning_symbol = "⚠"
+<
+                                                 *'syntastic_enable_balloons'*
+Default: 1
+Use this option to tell syntastic whether to display error messages in balloons
+when the mouse is hovered over erroneous lines: >
+    let g:syntastic_enable_balloons = 1
+<
+Note that Vim must be compiled with |+balloon_eval|.
+
+                                             *'syntastic_enable_highlighting'*
+Default: 1
+Use this option to tell syntastic whether to use syntax highlighting to mark
+errors (where possible). Highlighting can be turned off with the following >
+    let g:syntastic_enable_highlighting = 0
+<
+                                        *'syntastic_always_populate_loc_list'*
+Default: 0
+Enable this option to tell syntastic to always stick any detected errors into
+the |location-list|: >
+    let g:syntastic_always_populate_loc_list = 1
+<
+                                                       *'syntastic_auto_jump'*
+Default: 0
+Enable this option if you want the cursor to jump to the first detected issue
+when saving or opening a file.
+
+When set to 0 the cursor won't jump automatically. >
+    let g:syntastic_auto_jump = 0
+<
+When set to 1 the cursor will always jump to the first issue detected,
+regardless of type. >
+    let g:syntastic_auto_jump = 1
+<
+When set to 2 the cursor will jump to the first issue detected, but only if
+this issue is an error. >
+    let g:syntastic_auto_jump = 2
+<
+When set to 3 the cursor will jump to the first error detected, if any. If
+all issues detected are warnings, the cursor won't jump. >
+    let g:syntastic_auto_jump = 3
+<
+                                                   *'syntastic_auto_loc_list'*
+Default: 2
+Use this option to tell syntastic to automatically open and/or close the
+|location-list| (see |syntastic-error-window|).
+
+When set to 0 the error window will not be opened or closed automatically. >
+    let g:syntastic_auto_loc_list = 0
+<
+When set to 1 the error window will be automatically opened when errors are
+detected, and closed when none are detected. >
+    let g:syntastic_auto_loc_list = 1
+<
+When set to 2 the error window will be automatically closed when no errors are
+detected, but not opened automatically. >
+    let g:syntastic_auto_loc_list = 2
+<
+                                                 *'syntastic_loc_list_height'*
+Default: 10
+Use this option to specify the height of the location lists that syntastic
+opens. >
+    let g:syntastic_loc_list_height = 5
+<
+                                                    *'syntastic_ignore_files'*
+Default: []
+Use this option to specify files that syntastic should never check.  It's a
+list of |regular-expression| patterns.  The full paths of files (see |::p|) are
+matched against these patterns, and the matches are case sensitive. Use |\c|
+to specify case insensitive patterns.  Example: >
+    let g:syntastic_ignore_files = ['\m^/usr/include/', '\m\c\.h$']
+<
+                                                    *'syntastic_filetype_map'*
+Default: {}
+Use this option to map non-standard filetypes to standard ones.  Corresponding
+checkers are mapped accordingly, which allows syntastic to check files with
+non-standard filetypes: >
+    let g:syntastic_filetype_map = {
+        \ "latex": "tex",
+        \ "gentoo-metadata": "xml" }
+<
+Composite filetypes can also be mapped to simple types, which disables the
+default behaviour of running both checkers against the input file: >
+    let g:syntastic_filetype_map = { "handlebars.html": "handlebars" }
+<
+                                                        *'syntastic_mode_map'*
+Default: { "mode": "active",
+           "active_filetypes": [],
+           "passive_filetypes": [] }
+Use this option to fine tune when automatic syntax checking is done (or not
+done).
+
+The option should be set to something like: >
+
+    let g:syntastic_mode_map = {
+        \ "mode": "active",
+        \ "active_filetypes": ["ruby", "php"],
+        \ "passive_filetypes": ["puppet"] }
+<
+"mode" can be mapped to one of two values - "active" or "passive". When set
+to "active", syntastic does automatic checking whenever a buffer is saved or
+initially opened.  When set to "passive" syntastic only checks when the user
+calls |:SyntasticCheck|.
+
+The exceptions to these rules are defined with "active_filetypes" and
+"passive_filetypes". In passive mode, automatic checks are still done for
+filetypes in the "active_filetypes" array (and "passive_filetypes" is
+ignored). In active mode, automatic checks are not done for any filetypes in
+the "passive_filetypes" array ("active_filetypes" is ignored).
+
+If any of "mode", "active_filetypes", or "passive_filetypes" are left
+unspecified, they default to values above.
+
+If local variable |'b:syntastic_mode'| is defined its value takes precedence
+over all calculations involving |'syntastic_mode_map'| for the corresponding
+buffer.
+
+At runtime, the |:SyntasticToggleMode| command can be used to switch between
+active and passive modes.
+
+                                                          *'b:syntastic_mode'*
+Default: unset
+Only the local form |'b:syntastic_mode'| is used. When set to either "active"
+or "passive", it takes precedence over |'syntastic_mode_map'| when deciding
+whether the corresponding buffer should be checked automatically.
+
+                                                  *'syntastic_quiet_messages'*
+Default: {}
+Use this option to filter out some of the messages produced by checkers.  The
+option should be set to something like: >
+    let g:syntastic_quiet_messages = {
+        \ "!level":  "errors",
+        \ "type":    "style",
+        \ "regex":   '\m\[C03\d\d\]',
+        \ "file:p":  ['\m^/usr/include/', '\m\c\.h$'] }
+<
+Each element turns off messages matching the patterns specified by the
+corresponding value. Values are lists, but if a list consist of a single
+element you may omit the brackets (e.g. you may write "style" instead of
+["style"]). Elements with values [] or '' are ignored (this is useful for
+overriding filters, cf. |filter-overrides|).
+
+    "level" - takes one of two values, "warnings" or "errors"
+    "type"  - can be either "syntax" or "style"
+    "regex" - is matched against the messages' text as a case insensitive
+              |regular-expression|
+    "file"  - is matched against the filenames the messages refer to, as a
+              case sensitive |regular-expression|.
+
+If a key is prefixed by an exclamation mark "!", the corresponding filter is
+negated (i.e. the above example silences all messages that are NOT errors).
+
+The "file" key may be followed by one or more filename modifiers (see
+|filename-modifiers|). The modifiers are applied to the filenames the messages
+refer to before matching against the value (i.e. in the above example the full
+path of the issues are matched against '\m^/usr/include/' and '\m\c\.h$').
+
+If |'syntastic_id_checkers'| is set, filters are applied before error messages
+are labeled with the names of the checkers that created them.
+
+There are also checker-specific variants of this option, providing finer
+control. They are named |'syntastic_<filetype>_<checker>_quiet_messages'|.
+
+For a particular checker, if both a |'syntastic_quiet_messages'| filter and
+a checker-specific filter are present, they are both applied (to the list of
+errors produced by the said checker). In case of conflicting values for the
+same keys, the values of the checker-specific filters take precedence.
+
+                                                            *filter-overrides*
+Since filter elements with values [] or '' are ignored, you can disable global
+filters for particular checkers, by setting the values of the corresponding
+elements in |'syntastic_<filetype>_<checker>_quiet_messages'| to [] or ''. For
+example, the following setting will silence all warnings, except for the
+ones produced by "pylint": >
+    let g:syntastic_quiet_messages = { "level": "warnings" }
+    let g:syntastic_python_pylint_quiet_messages = { "level" : [] }
+<
+                                                      *'syntastic_stl_format'*
+Default: [Syntax: line:%F (%t)]
+Use this option to control what the syntastic statusline text contains. Several
+magic flags are available to insert information:
+    %e - number of errors
+    %w - number of warnings
+    %t - total number of warnings and errors
+    %fe - line number of first error
+    %fw - line number of first warning
+    %F - line number of first warning or error
+
+Several additional flags are available to hide text under certain conditions:
+    %E{...} - hide the text in the brackets unless there are errors
+    %W{...} - hide the text in the brackets unless there are warnings
+    %B{...} - hide the text in the brackets unless there are both warnings AND
+              errors
+These flags can't be nested.
+
+Example: >
+    let g:syntastic_stl_format = '[%E{Err: %fe #%e}%B{, }%W{Warn: %fw #%w}]'
+<
+If this format is used and the current buffer has 5 errors and 1 warning
+starting on lines 20 and 10 respectively then this would appear on the
+statusline: >
+    [Err: 20 #5, Warn: 10 #1]
+<
+If the buffer had 2 warnings, starting on line 5 then this would appear: >
+    [Warn: 5 #2]
+<
+                                                   *'b:syntastic_skip_checks'*
+Default: unset
+Only the local form |'b:syntastic_skip_checks'| is used. When set to a true
+value, no checks are run against the corresponding buffer. Example: >
+    let b:syntastic_skip_checks = 1
+<
+                                                    *'syntastic_full_redraws'*
+Default: 0 in GUI Vim and MacVim, 1 otherwise
+Controls whether syntastic calls |:redraw| or |:redraw!| for screen redraws.
+Changing it can in principle make screen redraws smoother, but it can also
+cause screen to flicker, or cause ghost characters. Leaving it to the default
+should be safe.
+
+                                                     *'syntastic_exit_checks'*
+Default: 0 when running under "cmd.exe" on Windows, 1 otherwise
+Syntastic attempts to catch abnormal termination conditions from checkers by
+looking at their exit codes. The "cmd.exe" shell on Windows make these checks
+meaningless, by returning 1 to Vim when the checkers exit with non-zero codes.
+The above variable can be used to disable exit code checks in syntastic.
+
+                                                           *'syntastic_shell'*
+Default: Vim's 'shell'
+
+This is the (full path to) the shell syntastic will use to run the checkers.
+On UNIX and Mac OS-X this shell must accept Bourne-compatible syntax for
+file "stdout" and "stderr" redirections ">file" and "2>file".  Examples of
+compatible shells are "zsh", "bash", "ksh", and of course the original Bourne
+"sh".
+
+This shell is independent of Vim's 'shell', and it isn't used for interactive
+operations.  It must take care to initialize all environment variables needed
+by the checkers you're using.  Example: >
+    let g:syntastic_shell = "/bin/sh"
+<
+                                                           *'syntastic_debug'*
+Default: 0
+Set this to the sum of one or more of the following flags to enable
+debugging:
+
+     1 - trace general workflow
+     2 - dump location lists
+     4 - trace notifiers
+     8 - trace autocommands
+    16 - dump options
+    32 - trace running of specific checkers
+
+Example: >
+    let g:syntastic_debug = 1
+<
+Syntastic will then add debugging messages to Vim's |message-history|. You can
+examine these messages with |:mes|.
+
+                                                      *'syntastic_debug_file'*
+Default: unset
+When set, debugging messages are written to the file named by its value, in
+addition to being added to Vim's |message-history|: >
+    let g:syntastic_debug_file = '~/syntastic.log'
+<
+                                                 *'syntastic_extra_filetypes'*
+Default: []
+List of filetypes handled by checkers external to syntastic.  If you have a Vim
+plugin that adds a checker for syntastic, and if the said checker deals with a
+filetype that is unknown to syntastic, you might consider adding that filetype
+to this list: >
+    let g:syntastic_extra_filetypes = [ "make", "gitcommit" ]
+<
+This will allow |:SyntasticInfo| to do proper tab completion for the new
+filetypes.
+
+==============================================================================
+5. Checker Options                                 *syntastic-checker-options*
+
+------------------------------------------------------------------------------
+5.1 Choosing which checkers to use               *syntastic-filetype-checkers*
+
+                                           *'g:syntastic_<filetype>_checkers'*
+You can tell syntastic which checkers to run for a given filetype by setting a
+variable 'g:syntastic_<filetype>_checkers' to a list of checkers, e.g. >
+    let g:syntastic_php_checkers = ["php", "phpcs", "phpmd"]
+<
+                                                      *'b:syntastic_checkers'*
+There is also a per-buffer version of this setting, 'b:syntastic_checkers'.
+When set, it takes precedence over |'g:syntastic_<filetype>_checkers'|.  You can
+use this in an autocmd to configure specific checkers for particular paths: >
+    autocmd FileType python if stridx(expand("%:p"), "/some/path/") == 0 |
+        \ let b:syntastic_checkers = ["pylint"] | endif
+<
+If neither |'g:syntastic_<filetype>_checkers'| nor |'b:syntastic_checkers'|
+is set, a default list of checker is used. Beware however that this list
+deliberately kept minimal, for performance reasons.
+
+Take a look at the wiki to find out what checkers and filetypes are supported
+by syntastic:
+
+    https://github.com/scrooloose/syntastic/wiki/Syntax-Checkers
+
+Use |:SyntasticInfo| to see which checkers are available for a given filetype.
+
+------------------------------------------------------------------------------
+5.2 Choosing the executable                            *syntastic-config-exec*
+
+                                       *'syntastic_<filetype>_<checker>_exec'*
+The executable run by a checker is normally defined automatically, when the
+checker is registered. You can however override it, by setting the variable
+'g:syntastic_<filetype>_<checker>_exec': >
+    let g:syntastic_ruby_mri_exec = '~/bin/ruby2'
+<
+This variable has a local version, 'b:syntastic_<filetype>_<checker>_exec',
+which takes precedence over the global one in the corresponding buffer.
+
+                                                *'b:syntastic_<checker>_exec'*
+And there is also a local variable named 'b:syntastic_<checker>_exec', which
+takes precedence over both 'b:syntastic_<filetype>_<checker>_exec' and
+'g:syntastic_<filetype>_<checker>_exec' in the buffers where it is defined.
+
+------------------------------------------------------------------------------
+5.3 Configuring specific checkers                   *syntastic-config-makeprg*
+
+Most checkers use the 'makeprgBuild()' function and provide many options by
+default - in fact you can customise every part of the command that gets called.
+
+                                   *'syntastic_<filetype>_<checker>_<option>'*
+Checkers that use 'makeprgBuild()' construct a 'makeprg' like this: >
+    let makeprg = self.makeprgBuild({
+                \ "exe": self.getExec(),
+                \ "args": "-a -b -c",
+                \ "post_args": "--more --args",
+                \ "tail": "2>/dev/null" })
+<
+The result is a 'makeprg' of the form: >
+    <exe> <args> <fname> <post_args> <tail>
+<
+All arguments above are optional, and can be overridden by setting global
+variables 'g:syntastic_<filetype>_<checker-name>_<option-name>' - even
+parameters not specified in the call to makeprgBuild(). These variables also
+have local versions 'b:syntastic_<filetype>_<checker-name>_<option-name>',
+which take precedence over the global ones in the corresponding buffers.
+
+If one of these variables has a non-empty default and you want it to be empty,
+you can set it to an empty string, e.g.: >
+    let g:syntastic_javascript_jslint_args = ""
+<
+                                        *'syntastic_<filetype>_<checker>_exe'*
+The 'exe' is normally the same as the 'exec' attribute described above, in
+which case it may be omitted. However, you can use it to add environment
+variables, or to change the way the checker is run. For example this setup
+allows you to run PC-Lint under Wine emulation on Linux: >
+    let  g:syntastic_c_pc_lint_exec = "wine"
+    let  g:syntastic_c_pc_lint_exe = "wine c:/path/to/lint-nt.exe"
+<
+To override the args and the tail: >
+    let g:syntastic_c_pc_lint_args = "-w5 -Iz:/usr/include/linux"
+    let g:syntastic_c_pc_lint_tail = "2>/dev/null"
+<
+The general form of the override options is: >
+    syntastic_<filetype>_<checker>_<option-name>
+<
+For checkers that do not use the 'makeprgBuild()' function you will have to
+look at the source code of the checker in question. If there are specific
+options that can be set, these are usually documented in the wiki:
+
+    https://github.com/scrooloose/syntastic/wiki/Syntax-Checkers
+
+                             *'syntastic_<filetype>_<checker>_quiet_messages'*
+In the same vein, 'g:syntastic_<filetype>_<checker-name>_quiet_messages' can
+be used to restrict message filters to messages produced by specific checkers.
+Example: >
+    let g:syntastic_python_pylama_quiet_messages = {
+        \ "type":  "style",
+        \ "regex": '\m\[C03\d\d\]' }
+<
+See |syntastic_quiet_messages| for the syntax.
+
+------------------------------------------------------------------------------
+5.4 Sorting errors                                     *syntastic-config-sort*
+
+                                       *'syntastic_<filetype>_<checker>_sort'*
+Syntastic may decide to group the errors produced by some checkers by file,
+then sort them by line number, then by type, then by column number. If you'd
+prefer to see the errors in the order in which they are output by the external
+checker you can set the variable |'g:syntastic_<filetype>_<checker>_sort'| to 0.
+
+Alternatively, if syntastic doesn't reorder the errors produced by a checker
+but you'd like it to sort them, you can set the same variable to 1.
+
+There is also a local version |'b:syntastic_<filetype>_<checker>_sort'| of
+this variable, that takes precedence over it in the buffers where it is
+defined.
+
+For aggregated lists (see |syntastic-aggregating-errors|) these variables are
+ignored if |syntastic_sort_aggregated_errors| is set (which is the default).
+
+==============================================================================
+6. Notes                                                     *syntastic-notes*
+
+------------------------------------------------------------------------------
+6.1. Handling of composite filetypes                     *syntastic-composite*
+
+Some Vim plugins use composite filetypes, such as "django.python" or
+"handlebars.html". Normally, syntastic deals with this situation by splitting
+the filetype in its simple components, and calling all checkers that apply.
+If this behaviour is not desirable, you can disable it by mapping the
+composite filetypes to a simple ones using |syntastic_filetype_map|, e.g.: >
+    let g:syntastic_filetype_map = { "handlebars.html": "handlebars" }
+<
+------------------------------------------------------------------------------
+6.2 Editing files over network                               *syntastic-netrw*
+
+The standard plugin |netrw| allows Vim to transparently edit files over
+network and inside archives.  Currently syntastic doesn't support this mode
+of operation.  It can only check files that can be accessed directly by local
+checkers, without any translation or conversion.
+
+------------------------------------------------------------------------------
+6.3 The 'shellslash' option                             *syntastic-shellslash*
+
+The 'shellslash' option is relevant only on Windows systems.  This option
+determines (among other things) the rules for quoting command lines, and there
+is no easy way for syntastic to make sure its state is appropriate for your
+shell.  It should be turned off if your 'shell' (or |g:syntastic_shell|) is
+"cmd.exe", and on for shells that expect an UNIX-like syntax, such as Cygwin's
+"sh".  Most checkers will stop working if 'shellslash' is set to the wrong
+value.
+
+==============================================================================
+7. Compatibility with other software                 *syntastic-compatibility*
+
+------------------------------------------------------------------------------
+7.1 The csh and tcsh shells                                    *syntastic-csh*
+
+The "csh" and "tcsh" shells are mostly compatible with syntastic.  However,
+some checkers assume Bourne shell syntax for redirecting "stderr".  For this
+reason, you should point |g:syntastic_shell| to a Bourne-compatible shell,
+such as "zsh", "bash", "ksh", or even the original Bourne "sh": >
+    let g:syntastic_shell = "/bin/sh"
+<
+------------------------------------------------------------------------------
+7.2. Eclim                                                   *syntastic-eclim*
+
+Syntastic can be used together with "Eclim" (see http://eclim.org/). However,
+by default Eclim disables syntastic's checks for the filetypes it supports, in
+order to run its own validation. If you'd prefer to use Eclim but still run
+syntastic's checks, set |g:EclimFileTypeValidate| to 0: >
+    let g:EclimFileTypeValidate = 0
+<
+It is also possible to re-enable syntastic checks only for some filetypes, and
+run Eclim's validation for others. Please consult Eclim's documentation for
+details.
+
+------------------------------------------------------------------------------
+7.3 The fish shell                                            *syntastic-fish*
+
+At the time of this writing the "fish" shell (see http://fishshell.com/)
+doesn't support the standard UNIX syntax for file redirections, and thus it
+can't be used together with syntastic. You can however set |g:syntastic_shell|
+to a more traditional shell, such as "zsh", "bash", "ksh", or even the
+original Bourne "sh": >
+    let g:syntastic_shell = "/bin/sh"
+<
+------------------------------------------------------------------------------
+7.4. The fizsh shell                                         *syntastic-fizsh*
+
+Using syntastic with the "fizsh" shell (see https://github.com/zsh-users/fizsh)
+is possible, but potentially problematic. In order to do it you'll need to set
+'shellredir' like this: >
+    set shellredir=>%s\ 2>&1
+<
+Please keep in mind however that Vim can't take advantage of any of the
+interactive features of "fizsh". Using a more traditional shell such as "zsh",
+"bash", "ksh", or the original Bourne "sh" might be a better choice: >
+    let g:syntastic_shell = "/bin/sh"
+<
+------------------------------------------------------------------------------
+7.5. powerline                                           *syntastic-powerline*
+
+The "powerline" Vim plugin (https://github.com/powerline/powerline) comes
+packaged with a syntastic segment. To customize this segment create a file
+~/.config/powerline/themes/vim/default.json, with a content like this: >
+    {
+        "segment_data" : {
+            "powerline.segments.vim.plugin.syntastic.syntastic" : {
+                "args" : {
+                    "err_format" : "Err: {first_line} #{num} ",
+                    "warn_format" : "Warn: {first_line} #{num} "
+                }
+            }
+        }
+    }
+<
+------------------------------------------------------------------------------
+7.6. The PowerShell shell                               *syntastic-powershell*
+
+At the time of this writing, syntastic is not compatible with using "Windows
+PowerShell" (http://technet.microsoft.com/en-us/library/bb978526.aspx) as Vim's
+'shell'.  You may still run Vim from 'PowerShell', but you do have to point
+Vim's 'shell' to a more traditional program, such as "cmd.exe": >
+    set shell=cmd.exe
+<
+------------------------------------------------------------------------------
+7.7 python-mode                                             *syntastic-pymode*
+
+Syntastic can be used along with the "python-mode" Vim plugin (see
+https://github.com/klen/python-mode). However, they both run syntax checks by
+default when you save buffers to disk, and this is probably not what you want.
+To avoid both plugins opening error windows, you can either set passive mode
+for python in syntastic (see |syntastic_mode_map|), or disable lint checks in
+"python-mode", by setting |pymode_lint_write| to 0. E.g.: >
+    let g:pymode_lint_write = 0
+<
+------------------------------------------------------------------------------
+7.8. vim-auto-save                                   *syntastic-vim-auto-save*
+
+Syntastic can be used together with the "vim-auto-save" Vim plugin (see
+https://github.com/907th/vim-auto-save).  However, syntastic checks in active
+mode only work with "vim-auto-save" version 0.1.7 or later.
+
+------------------------------------------------------------------------------
+7.9. vim-go                                                 *syntastic-vim-go*
+
+The "vim-go" Vim plugin (https://github.com/fatih/vim-go) uses |quickfix|
+lists, and thus doesn't conflict with syntastic (which uses |location-list|
+lists).  However, both "vim-go" and syntastic run syntax checks by default
+when you save buffers to disk, and this can have confusing results.  To
+avoid both plugins opening error windows, you can either set passive
+mode for go in syntastic (see |syntastic_mode_map|), or prevent "vim-go"
+from showing a quickfix window when |g:go_fmt_command| fails, by setting
+|g:go_fmt_fail_silently| to 1.  E.g.: >
+    let g:go_fmt_fail_silently = 1
+<
+------------------------------------------------------------------------------
+7.10. vim-virtualenv                                *syntastic-vim-virtualenv*
+
+At the time of this writing, syntastic can't run checkers installed
+in Python virtual environments activated by "vim-virtualenv" (see
+https://github.com/jmcantrell/vim-virtualenv).  This is a limitation of
+"vim-virtualenv".
+
+------------------------------------------------------------------------------
+7.11 YouCompleteMe                                             *syntastic-ycm*
+
+Syntastic can be used together with the "YouCompleteMe" Vim plugin (see
+http://valloric.github.io/YouCompleteMe/).  However, by default "YouCompleteMe"
+disables syntastic's checkers for the "c", "cpp", "objc", and "objcpp"
+filetypes, in order to allow its own checkers to run.  If you want to use YCM's
+identifier completer but still run syntastic's checkers for those filetypes you
+have to set |ycm_show_diagnostics_ui| to 0. E.g.: >
+    let g:ycm_show_diagnostics_ui = 0
+<
+==============================================================================
+8. About                                                     *syntastic-about*
+
+The core maintainers of syntastic are:
+    Martin Grenfell (GitHub: scrooloose)
+    Gregor Uhlenheuer (GitHub: kongo2002)
+    LCD 047 (GitHub: lcd047)
+
+Find the latest version of syntastic at:
+
+    http://github.com/scrooloose/syntastic
+
+==============================================================================
+9. License                                                 *syntastic-license*
+
+Syntastic is released under the WTFPL.
+See http://sam.zoy.org/wtfpl/COPYING.
+
+ vim:tw=78:sw=4:ft=help:norl:

vim/ftplugin/python/pyflakes.vim

@@ -1,360 +0,0 @@
-" pyflakes.vim - A script to highlight Python code on the fly with warnings
-" from Pyflakes, a Python lint tool.
-"
-" Place this script and the accompanying pyflakes directory in
-" .vim/ftplugin/python.
-"
-" See README for additional installation and information.
-"
-" Thanks to matlib.vim for ideas/code on interactive linting.
-"
-" Maintainer: Kevin Watters <kevin.watters@gmail.com>
-" Version: 0.1
-
-if exists("b:did_pyflakes_plugin")
-    finish " only load once
-else
-    let b:did_pyflakes_plugin = 1
-endif
-
-if !exists('g:pyflakes_builtins')
-    let g:pyflakes_builtins = []
-endif
-
-if !exists("b:did_python_init")
-    let b:did_python_init = 0
-
-    if !has('python')
-        " the pyflakes.vim plugin requires Vim to be compiled with +python
-        finish
-    endif
-
-if !exists('g:pyflakes_use_quickfix')
-    let g:pyflakes_use_quickfix = 1
-endif
-
-if !exists('g:pyflakes_autostart')
-    let g:pyflakes_autostart = 1
-endif
-
-    python << EOF
-import vim
-import os.path
-import sys
-
-if sys.version_info[:2] < (2, 5):
-    raise AssertionError('Vim must be compiled with Python 2.5 or higher; you have ' + sys.version)
-
-# get the directory this script is in: the pyflakes python module should be installed there.
-scriptdir = os.path.join(os.path.dirname(vim.eval('expand("<sfile>")')), 'pyflakes')
-if scriptdir not in sys.path:
-    sys.path.insert(0, scriptdir)
-
-import ast
-from pyflakes import checker, messages
-from operator import attrgetter
-import re
-
-class loc(object):
-    def __init__(self, lineno, col=None):
-        self.lineno = lineno
-        self.col_offset = col
-
-class SyntaxError(messages.Message):
-    message = 'could not compile: %s'
-    def __init__(self, filename, lineno, col, message):
-        messages.Message.__init__(self, filename, loc(lineno, col))
-        self.message_args = (message,)
-
-class blackhole(object):
-    write = flush = lambda *a, **k: None
-
-def check(buffer):
-    filename = buffer.name
-    contents = buffer[:]
-
-    # shebang usually found at the top of the file, followed by source code encoding marker.
-    # assume everything else that follows is encoded in the encoding.
-    encoding_found = False
-    for n, line in enumerate(contents):
-        if n >= 2:
-            break
-        elif re.match(r'#.*coding[:=]\s*([-\w.]+)', line):
-            contents = ['']*(n+1) + contents[n+1:]
-            break
-
-    contents = '\n'.join(contents) + '\n'
-
-    vimenc = vim.eval('&encoding')
-    if vimenc:
-        contents = contents.decode(vimenc)
-
-    builtins = set(['__file__'])
-    try:
-        builtins.update(set(eval(vim.eval('string(g:pyflakes_builtins)'))))
-    except Exception:
-        pass
-
-    try:
-        # TODO: use warnings filters instead of ignoring stderr
-        old_stderr, sys.stderr = sys.stderr, blackhole()
-        try:
-            tree = ast.parse(contents, filename or '<unknown>')
-        finally:
-            sys.stderr = old_stderr
-    except:
-        try:
-            value = sys.exc_info()[1]
-            lineno, offset, line = value[1][1:]
-        except IndexError:
-            lineno, offset, line = 1, 0, ''
-        if line and line.endswith("\n"):
-            line = line[:-1]
-
-        return [SyntaxError(filename, lineno, offset, str(value))]
-    else:
-        # pyflakes looks to _MAGIC_GLOBALS in checker.py to see which
-        # UndefinedNames to ignore
-        old_globals = getattr(checker,' _MAGIC_GLOBALS', [])
-        checker._MAGIC_GLOBALS = set(old_globals) | builtins
-
-        filename = '(none)' if filename is None else filename
-        w = checker.Checker(tree, filename)
-
-        checker._MAGIC_GLOBALS = old_globals
-
-        w.messages.sort(key = attrgetter('lineno'))
-        return w.messages
-
-
-def vim_quote(s):
-    return s.replace("'", "''")
-EOF
-    let b:did_python_init = 1
-endif
-
-if !b:did_python_init
-    finish
-endif
-
-au BufLeave <buffer> call s:ClearPyflakes()
-
-if !exists("*s:PyflakesToggle")
-    function s:PyflakesToggle()
-        if ! exists("b:pyflakes_off") || b:pyflakes_off == 1
-            silent call s:RunPyflakes()
-            echo 'pyflake on'
-
-            au BufEnter <buffer> call s:RunPyflakes()
-            au InsertLeave <buffer> call s:RunPyflakes()
-            au InsertEnter <buffer> call s:RunPyflakes()
-            au BufWritePost <buffer> call s:RunPyflakes()
-
-            au CursorHold <buffer> call s:RunPyflakes()
-            au CursorHoldI <buffer> call s:RunPyflakes()
-
-            au CursorHold <buffer> call s:GetPyflakesMessage()
-            au CursorMoved <buffer> call s:GetPyflakesMessage()
-
-            noremap <buffer><silent> dd dd:PyflakesUpdate<CR>
-            noremap <buffer><silent> dw dw:PyflakesUpdate<CR>
-            noremap <buffer><silent> u u:PyflakesUpdate<CR>
-
-            let b:pyflakes_off = 0
-        else
-            silent call s:ClearPyflakes()
-            echo 'pyflake off'
-
-            au! BufEnter <buffer>
-            au! InsertLeave <buffer>
-            au! InsertEnter <buffer>
-            au! BufWritePost <buffer>
-
-            au! CursorHold <buffer>
-            au! CursorHoldI <buffer>
-            au! CursorMoved <buffer>
-
-            unmap <buffer><silent> dd
-            unmap <buffer><silent> dw
-            unmap <buffer><silent> u
-
-            let b:pyflakes_off = 1
-        endif
-    endfunction
-endif
-
-
-if !exists("*s:PyflakesUpdate")
-    function s:PyflakesUpdate()
-        silent call s:RunPyflakes()
-        call s:GetPyflakesMessage()
-    endfunction
-endif
-
-" Call this function in your .vimrc to update PyFlakes
-if !exists(":PyflakesUpdate")
-  command PyflakesUpdate :call s:PyflakesUpdate()
-endif
-
-" WideMsg() prints [long] message up to (&columns-1) length
-" guaranteed without "Press Enter" prompt.
-if !exists("*s:WideMsg")
-    function s:WideMsg(msg)
-        let x=&ruler | let y=&showcmd
-        set noruler noshowcmd
-        redraw
-        echo strpart(a:msg, 0, &columns-1)
-        let &ruler=x | let &showcmd=y
-    endfun
-endif
-
-if !exists("*s:GetQuickFixStackCount")
-    function s:GetQuickFixStackCount()
-        let l:stack_count = 0
-        try
-            silent colder 9
-        catch /E380:/
-        endtry
-
-        try
-            for i in range(9)
-                silent cnewer
-                let l:stack_count = l:stack_count + 1
-            endfor
-        catch /E381:/
-            return l:stack_count
-        endtry
-    endfunction
-endif
-
-if !exists("*s:ActivatePyflakesQuickFixWindow")
-    function s:ActivatePyflakesQuickFixWindow()
-        try
-            silent colder 9 " go to the bottom of quickfix stack
-        catch /E380:/
-        catch /E788:/
-        endtry
-
-        if s:pyflakes_qf > 0
-            try
-                exe "silent cnewer " . s:pyflakes_qf
-            catch /E381:/
-                echoerr "Could not activate Pyflakes Quickfix Window."
-            endtry
-        endif
-    endfunction
-endif
-
-if !exists("*s:RunPyflakes")
-    function s:RunPyflakes()
-        highlight link PyFlakes SpellBad
-
-        if exists("b:cleared")
-            if b:cleared == 0
-                silent call s:ClearPyflakes()
-                let b:cleared = 1
-            endif
-        else
-            let b:cleared = 1
-        endif
-        
-        let b:matched = []
-        let b:matchedlines = {}
-
-        let b:qf_list = []
-        let b:qf_window_count = -1
-        
-        python << EOF
-for w in check(vim.current.buffer):
-    vim.command('let s:matchDict = {}')
-    vim.command("let s:matchDict['lineNum'] = " + str(w.lineno))
-    vim.command("let s:matchDict['message'] = '%s'" % vim_quote(w.message % w.message_args))
-    vim.command("let b:matchedlines[" + str(w.lineno) + "] = s:matchDict")
-    
-    vim.command("let l:qf_item = {}")
-    vim.command("let l:qf_item.bufnr = bufnr('%')")
-    vim.command("let l:qf_item.filename = expand('%')")
-    vim.command("let l:qf_item.lnum = %s" % str(w.lineno))
-    vim.command("let l:qf_item.text = '%s'" % vim_quote(w.message % w.message_args))
-    vim.command("let l:qf_item.type = 'E'")
-
-    if getattr(w, 'col', None) is None or isinstance(w, SyntaxError):
-        # without column information, just highlight the whole line
-        # (minus the newline)
-        vim.command(r"let s:mID = matchadd('PyFlakes', '\%" + str(w.lineno) + r"l\n\@!')")
-    else:
-        # with a column number, highlight the first keyword there
-        vim.command(r"let s:mID = matchadd('PyFlakes', '^\%" + str(w.lineno) + r"l\_.\{-}\zs\k\+\k\@!\%>" + str(w.col) + r"c')")
-
-        vim.command("let l:qf_item.vcol = 1")
-        vim.command("let l:qf_item.col = %s" % str(w.col + 1))
-
-    vim.command("call add(b:matched, s:matchDict)")
-    vim.command("call add(b:qf_list, l:qf_item)")
-EOF
-        if g:pyflakes_use_quickfix == 1
-            if exists("s:pyflakes_qf")
-                " if pyflakes quickfix window is already created, reuse it
-                call s:ActivatePyflakesQuickFixWindow()
-                call setqflist(b:qf_list, 'r')
-            else
-                " one pyflakes quickfix window for all buffer
-                call setqflist(b:qf_list, '')
-                let s:pyflakes_qf = s:GetQuickFixStackCount()
-            endif
-        endif
-
-        let b:cleared = 0
-    endfunction
-end
-
-" keep track of whether or not we are showing a message
-let b:showing_message = 0
-
-if !exists("*s:GetPyflakesMessage")
-    function s:GetPyflakesMessage()
-        let s:cursorPos = getpos(".")
-
-        " Bail if RunPyflakes hasn't been called yet.
-        if !exists('b:matchedlines')
-            return
-        endif
-
-        " if there's a message for the line the cursor is currently on, echo
-        " it to the console
-        if has_key(b:matchedlines, s:cursorPos[1])
-            let s:pyflakesMatch = get(b:matchedlines, s:cursorPos[1])
-            call s:WideMsg(s:pyflakesMatch['message'])
-            let b:showing_message = 1
-            return
-        endif
-
-        " otherwise, if we're showing a message, clear it
-        if b:showing_message == 1
-            echo
-            let b:showing_message = 0
-        endif
-    endfunction
-endif
-
-if !exists('*s:ClearPyflakes')
-    function s:ClearPyflakes()
-        let s:matches = getmatches()
-        for s:matchId in s:matches
-            if s:matchId['group'] == 'PyFlakes'
-                call matchdelete(s:matchId['id'])
-            endif
-        endfor
-        let b:matched = []
-        let b:matchedlines = {}
-        let b:cleared = 1
-    endfunction
-endif
-
-
-if g:pyflakes_autostart == 1
-    call s:PyflakesToggle()
-endif
-
-command! -nargs=0 -bar PyflakesToggle call s:PyflakesToggle()
-

vim/ftplugin/python/pyflakes/.gitignore

@@ -1,4 +0,0 @@
-*.pyc
-.svn
-_trial_temp/
-_trial_temp*

vim/ftplugin/python/pyflakes/LICENSE

@@ -1,21 +0,0 @@
-
-Copyright (c) 2005 Divmod, Inc., http://www.divmod.com/
-
-Permission is hereby granted, free of charge, to any person obtaining
-a copy of this software and associated documentation files (the
-"Software"), to deal in the Software without restriction, including
-without limitation the rights to use, copy, modify, merge, publish,
-distribute, sublicense, and/or sell copies of the Software, and to
-permit persons to whom the Software is furnished to do so, subject to
-the following conditions:
-
-The above copyright notice and this permission notice shall be
-included in all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
-LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
-OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
-WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

vim/ftplugin/python/pyflakes/NEWS.txt

@@ -1,29 +0,0 @@
-0.4.0 (2009-11-25):
-  - Fix reporting for certain SyntaxErrors which lack line number
-    information.
-  - Check for syntax errors more rigorously.
-  - Support checking names used with the class decorator syntax in versions
-    of Python which have it.
-  - Detect local variables which are bound but never used.
-  - Handle permission errors when trying to read source files.
-  - Handle problems with the encoding of source files.
-  - Support importing dotted names so as not to incorrectly report them as
-    redefined unused names.
-  - Support all forms of the with statement.
-  - Consider static `__all__` definitions and avoid reporting unused names
-    if the names are listed there.
-  - Fix incorrect checking of class names with respect to the names of their
-    bases in the class statement.
-  - Support the `__path__` global in `__init__.py`.
-
-0.3.0 (2009-01-30):
-  - Display more informative SyntaxError messages.
-  - Don't hang flymake with unmatched triple quotes (only report a single
-    line of source for a multiline syntax error).
-  - Recognize __builtins__ as a defined name.
-  - Improve pyflakes support for python versions 2.3-2.5
-  - Support for if-else expressions and with statements.
-  - Warn instead of error on non-existant file paths.
-  - Check for __future__ imports after other statements.
-  - Add reporting for some types of import shadowing.
-  - Improve reporting of unbound locals

vim/ftplugin/python/pyflakes/bin/pyflakes

@@ -1,4 +0,0 @@
-#!/usr/bin/python
-
-from pyflakes.scripts.pyflakes import main
-main()

vim/ftplugin/python/pyflakes/pyflakes/__init__.py

@@ -1,2 +0,0 @@
-
-__version__ = '0.4.0'

vim/ftplugin/python/pyflakes/pyflakes/checker.py

@@ -1,625 +0,0 @@
-# -*- test-case-name: pyflakes -*-
-# (c) 2005-2010 Divmod, Inc.
-# See LICENSE file for details
-
-import __builtin__
-import os.path
-import _ast
-
-from pyflakes import messages
-
-
-# utility function to iterate over an AST node's children, adapted
-# from Python 2.6's standard ast module
-try:
-    import ast
-    iter_child_nodes = ast.iter_child_nodes
-except (ImportError, AttributeError):
-    def iter_child_nodes(node, astcls=_ast.AST):
-        """
-        Yield all direct child nodes of *node*, that is, all fields that are nodes
-        and all items of fields that are lists of nodes.
-        """
-        for name in node._fields:
-            field = getattr(node, name, None)
-            if isinstance(field, astcls):
-                yield field
-            elif isinstance(field, list):
-                for item in field:
-                    yield item
-
-
-class Binding(object):
-    """
-    Represents the binding of a value to a name.
-
-    The checker uses this to keep track of which names have been bound and
-    which names have not. See L{Assignment} for a special type of binding that
-    is checked with stricter rules.
-
-    @ivar used: pair of (L{Scope}, line-number) indicating the scope and
-                line number that this binding was last used
-    """
-
-    def __init__(self, name, source):
-        self.name = name
-        self.source = source
-        self.used = False
-
-
-    def __str__(self):
-        return self.name
-
-
-    def __repr__(self):
-        return '<%s object %r from line %r at 0x%x>' % (self.__class__.__name__,
-                                                        self.name,
-                                                        self.source.lineno,
-                                                        id(self))
-
-
-
-class UnBinding(Binding):
-    '''Created by the 'del' operator.'''
-
-
-
-class Importation(Binding):
-    """
-    A binding created by an import statement.
-
-    @ivar fullName: The complete name given to the import statement,
-        possibly including multiple dotted components.
-    @type fullName: C{str}
-    """
-    def __init__(self, name, source):
-        self.fullName = name
-        name = name.split('.')[0]
-        super(Importation, self).__init__(name, source)
-
-
-
-class Argument(Binding):
-    """
-    Represents binding a name as an argument.
-    """
-
-
-
-class Assignment(Binding):
-    """
-    Represents binding a name with an explicit assignment.
-
-    The checker will raise warnings for any Assignment that isn't used. Also,
-    the checker does not consider assignments in tuple/list unpacking to be
-    Assignments, rather it treats them as simple Bindings.
-    """
-
-
-
-class FunctionDefinition(Binding):
-    pass
-
-
-
-class ExportBinding(Binding):
-    """
-    A binding created by an C{__all__} assignment.  If the names in the list
-    can be determined statically, they will be treated as names for export and
-    additional checking applied to them.
-
-    The only C{__all__} assignment that can be recognized is one which takes
-    the value of a literal list containing literal strings.  For example::
-
-        __all__ = ["foo", "bar"]
-
-    Names which are imported and not otherwise used but appear in the value of
-    C{__all__} will not have an unused import warning reported for them.
-    """
-    def names(self):
-        """
-        Return a list of the names referenced by this binding.
-        """
-        names = []
-        if isinstance(self.source, _ast.List):
-            for node in self.source.elts:
-                if isinstance(node, _ast.Str):
-                    names.append(node.s)
-        return names
-
-
-
-class Scope(dict):
-    importStarred = False       # set to True when import * is found
-
-
-    def __repr__(self):
-        return '<%s at 0x%x %s>' % (self.__class__.__name__, id(self), dict.__repr__(self))
-
-
-    def __init__(self):
-        super(Scope, self).__init__()
-
-
-
-class ClassScope(Scope):
-    pass
-
-
-
-class FunctionScope(Scope):
-    """
-    I represent a name scope for a function.
-
-    @ivar globals: Names declared 'global' in this function.
-    """
-    def __init__(self):
-        super(FunctionScope, self).__init__()
-        self.globals = {}
-
-
-
-class ModuleScope(Scope):
-    pass
-
-
-# Globally defined names which are not attributes of the __builtin__ module.
-_MAGIC_GLOBALS = ['__file__', '__builtins__']
-
-
-
-class Checker(object):
-    """
-    I check the cleanliness and sanity of Python code.
-
-    @ivar _deferredFunctions: Tracking list used by L{deferFunction}.  Elements
-        of the list are two-tuples.  The first element is the callable passed
-        to L{deferFunction}.  The second element is a copy of the scope stack
-        at the time L{deferFunction} was called.
-
-    @ivar _deferredAssignments: Similar to C{_deferredFunctions}, but for
-        callables which are deferred assignment checks.
-    """
-
-    nodeDepth = 0
-    traceTree = False
-
-    def __init__(self, tree, filename='(none)'):
-        self._deferredFunctions = []
-        self._deferredAssignments = []
-        self.dead_scopes = []
-        self.messages = []
-        self.filename = filename
-        self.scopeStack = [ModuleScope()]
-        self.futuresAllowed = True
-        self.handleChildren(tree)
-        self._runDeferred(self._deferredFunctions)
-        # Set _deferredFunctions to None so that deferFunction will fail
-        # noisily if called after we've run through the deferred functions.
-        self._deferredFunctions = None
-        self._runDeferred(self._deferredAssignments)
-        # Set _deferredAssignments to None so that deferAssignment will fail
-        # noisly if called after we've run through the deferred assignments.
-        self._deferredAssignments = None
-        del self.scopeStack[1:]
-        self.popScope()
-        self.check_dead_scopes()
-
-
-    def deferFunction(self, callable):
-        '''
-        Schedule a function handler to be called just before completion.
-
-        This is used for handling function bodies, which must be deferred
-        because code later in the file might modify the global scope. When
-        `callable` is called, the scope at the time this is called will be
-        restored, however it will contain any new bindings added to it.
-        '''
-        self._deferredFunctions.append((callable, self.scopeStack[:]))
-
-
-    def deferAssignment(self, callable):
-        """
-        Schedule an assignment handler to be called just after deferred
-        function handlers.
-        """
-        self._deferredAssignments.append((callable, self.scopeStack[:]))
-
-
-    def _runDeferred(self, deferred):
-        """
-        Run the callables in C{deferred} using their associated scope stack.
-        """
-        for handler, scope in deferred:
-            self.scopeStack = scope
-            handler()
-
-
-    def scope(self):
-        return self.scopeStack[-1]
-    scope = property(scope)
-
-    def popScope(self):
-        self.dead_scopes.append(self.scopeStack.pop())
-
-
-    def check_dead_scopes(self):
-        """
-        Look at scopes which have been fully examined and report names in them
-        which were imported but unused.
-        """
-        for scope in self.dead_scopes:
-            export = isinstance(scope.get('__all__'), ExportBinding)
-            if export:
-                all = scope['__all__'].names()
-                if os.path.split(self.filename)[1] != '__init__.py':
-                    # Look for possible mistakes in the export list
-                    undefined = set(all) - set(scope)
-                    for name in undefined:
-                        self.report(
-                            messages.UndefinedExport,
-                            scope['__all__'].source,
-                            name)
-            else:
-                all = []
-
-            # Look for imported names that aren't used.
-            for importation in scope.itervalues():
-                if isinstance(importation, Importation):
-                    if not importation.used and importation.name not in all:
-                        self.report(
-                            messages.UnusedImport,
-                            importation.source,
-                            importation.name)
-
-
-    def pushFunctionScope(self):
-        self.scopeStack.append(FunctionScope())
-
-    def pushClassScope(self):
-        self.scopeStack.append(ClassScope())
-
-    def report(self, messageClass, *args, **kwargs):
-        self.messages.append(messageClass(self.filename, *args, **kwargs))
-
-    def handleChildren(self, tree):
-        for node in iter_child_nodes(tree):
-            self.handleNode(node, tree)
-
-    def isDocstring(self, node):
-        """
-        Determine if the given node is a docstring, as long as it is at the
-        correct place in the node tree.
-        """
-        return isinstance(node, _ast.Str) or \
-               (isinstance(node, _ast.Expr) and
-                isinstance(node.value, _ast.Str))
-
-    def handleNode(self, node, parent):
-        node.parent = parent
-        if self.traceTree:
-            print '  ' * self.nodeDepth + node.__class__.__name__
-        self.nodeDepth += 1
-        if self.futuresAllowed and not \
-               (isinstance(node, _ast.ImportFrom) or self.isDocstring(node)):
-            self.futuresAllowed = False
-        nodeType = node.__class__.__name__.upper()
-        try:
-            handler = getattr(self, nodeType)
-            handler(node)
-        finally:
-            self.nodeDepth -= 1
-        if self.traceTree:
-            print '  ' * self.nodeDepth + 'end ' + node.__class__.__name__
-
-    def ignore(self, node):
-        pass
-
-    # "stmt" type nodes
-    RETURN = DELETE = PRINT = WHILE = IF = WITH = RAISE = TRYEXCEPT = \
-        TRYFINALLY = ASSERT = EXEC = EXPR = handleChildren
-
-    CONTINUE = BREAK = PASS = ignore
-
-    # "expr" type nodes
-    BOOLOP = BINOP = UNARYOP = IFEXP = DICT = SET = YIELD = COMPARE = \
-    CALL = REPR = ATTRIBUTE = SUBSCRIPT = LIST = TUPLE = handleChildren
-
-    NUM = STR = ELLIPSIS = ignore
-
-    # "slice" type nodes
-    SLICE = EXTSLICE = INDEX = handleChildren
-
-    # expression contexts are node instances too, though being constants
-    LOAD = STORE = DEL = AUGLOAD = AUGSTORE = PARAM = ignore
-
-    # same for operators
-    AND = OR = ADD = SUB = MULT = DIV = MOD = POW = LSHIFT = RSHIFT = \
-    BITOR = BITXOR = BITAND = FLOORDIV = INVERT = NOT = UADD = USUB = \
-    EQ = NOTEQ = LT = LTE = GT = GTE = IS = ISNOT = IN = NOTIN = ignore
-
-    # additional node types
-    COMPREHENSION = EXCEPTHANDLER = KEYWORD = handleChildren
-
-    def addBinding(self, loc, value, reportRedef=True):
-        '''Called when a binding is altered.
-
-        - `loc` is the location (an object with lineno and optionally
-          col_offset attributes) of the statement responsible for the change
-        - `value` is the optional new value, a Binding instance, associated
-          with the binding; if None, the binding is deleted if it exists.
-        - if `reportRedef` is True (default), rebinding while unused will be
-          reported.
-        '''
-        if (isinstance(self.scope.get(value.name), FunctionDefinition)
-                    and isinstance(value, FunctionDefinition)):
-            self.report(messages.RedefinedFunction,
-                        loc, value.name, self.scope[value.name].source)
-
-        if not isinstance(self.scope, ClassScope):
-            for scope in self.scopeStack[::-1]:
-                existing = scope.get(value.name)
-                if (isinstance(existing, Importation)
-                        and not existing.used
-                        and (not isinstance(value, Importation) or value.fullName == existing.fullName)
-                        and reportRedef):
-
-                    self.report(messages.RedefinedWhileUnused,
-                                loc, value.name, scope[value.name].source)
-
-        if isinstance(value, UnBinding):
-            try:
-                del self.scope[value.name]
-            except KeyError:
-                self.report(messages.UndefinedName, loc, value.name)
-        else:
-            self.scope[value.name] = value
-
-    def GLOBAL(self, node):
-        """
-        Keep track of globals declarations.
-        """
-        if isinstance(self.scope, FunctionScope):
-            self.scope.globals.update(dict.fromkeys(node.names))
-
-    def LISTCOMP(self, node):
-        # handle generators before element
-        for gen in node.generators:
-            self.handleNode(gen, node)
-        self.handleNode(node.elt, node)
-
-    GENERATOREXP = SETCOMP = LISTCOMP
-
-    # dictionary comprehensions; introduced in Python 2.7
-    def DICTCOMP(self, node):
-        for gen in node.generators:
-            self.handleNode(gen, node)
-        self.handleNode(node.key, node)
-        self.handleNode(node.value, node)
-
-    def FOR(self, node):
-        """
-        Process bindings for loop variables.
-        """
-        vars = []
-        def collectLoopVars(n):
-            if isinstance(n, _ast.Name):
-                vars.append(n.id)
-            elif isinstance(n, _ast.expr_context):
-                return
-            else:
-                for c in iter_child_nodes(n):
-                    collectLoopVars(c)
-
-        collectLoopVars(node.target)
-        for varn in vars:
-            if (isinstance(self.scope.get(varn), Importation)
-                    # unused ones will get an unused import warning
-                    and self.scope[varn].used):
-                self.report(messages.ImportShadowedByLoopVar,
-                            node, varn, self.scope[varn].source)
-
-        self.handleChildren(node)
-
-    def NAME(self, node):
-        """
-        Handle occurrence of Name (which can be a load/store/delete access.)
-        """
-        # Locate the name in locals / function / globals scopes.
-        if isinstance(node.ctx, (_ast.Load, _ast.AugLoad)):
-            # try local scope
-            importStarred = self.scope.importStarred
-            try:
-                self.scope[node.id].used = (self.scope, node)
-            except KeyError:
-                pass
-            else:
-                return
-
-            # try enclosing function scopes
-
-            for scope in self.scopeStack[-2:0:-1]:
-                importStarred = importStarred or scope.importStarred
-                if not isinstance(scope, FunctionScope):
-                    continue
-                try:
-                    scope[node.id].used = (self.scope, node)
-                except KeyError:
-                    pass
-                else:
-                    return
-
-            # try global scope
-
-            importStarred = importStarred or self.scopeStack[0].importStarred
-            try:
-                self.scopeStack[0][node.id].used = (self.scope, node)
-            except KeyError:
-                if ((not hasattr(__builtin__, node.id))
-                        and node.id not in _MAGIC_GLOBALS
-                        and not importStarred):
-                    if (os.path.basename(self.filename) == '__init__.py' and
-                        node.id == '__path__'):
-                        # the special name __path__ is valid only in packages
-                        pass
-                    else:
-                        self.report(messages.UndefinedName, node, node.id)
-        elif isinstance(node.ctx, (_ast.Store, _ast.AugStore)):
-            # if the name hasn't already been defined in the current scope
-            if isinstance(self.scope, FunctionScope) and node.id not in self.scope:
-                # for each function or module scope above us
-                for scope in self.scopeStack[:-1]:
-                    if not isinstance(scope, (FunctionScope, ModuleScope)):
-                        continue
-                    # if the name was defined in that scope, and the name has
-                    # been accessed already in the current scope, and hasn't
-                    # been declared global
-                    if (node.id in scope
-                            and scope[node.id].used
-                            and scope[node.id].used[0] is self.scope
-                            and node.id not in self.scope.globals):
-                        # then it's probably a mistake
-                        self.report(messages.UndefinedLocal,
-                                    scope[node.id].used[1],
-                                    node.id,
-                                    scope[node.id].source)
-                        break
-
-            if isinstance(node.parent,
-                          (_ast.For, _ast.comprehension, _ast.Tuple, _ast.List)):
-                binding = Binding(node.id, node)
-            elif (node.id == '__all__' and
-                  isinstance(self.scope, ModuleScope)):
-                binding = ExportBinding(node.id, node.parent.value)
-            else:
-                binding = Assignment(node.id, node)
-            if node.id in self.scope:
-                binding.used = self.scope[node.id].used
-            self.addBinding(node, binding)
-        elif isinstance(node.ctx, _ast.Del):
-            if isinstance(self.scope, FunctionScope) and \
-                   node.id in self.scope.globals:
-                del self.scope.globals[node.id]
-            else:
-                self.addBinding(node, UnBinding(node.id, node))
-        else:
-            # must be a Param context -- this only happens for names in function
-            # arguments, but these aren't dispatched through here
-            raise RuntimeError(
-                "Got impossible expression context: %r" % (node.ctx,))
-
-
-    def FUNCTIONDEF(self, node):
-        # the decorators attribute is called decorator_list as of Python 2.6
-        if hasattr(node, 'decorators'):
-            for deco in node.decorators:
-                self.handleNode(deco, node)
-        else:
-            for deco in node.decorator_list:
-                self.handleNode(deco, node)
-        self.addBinding(node, FunctionDefinition(node.name, node))
-        self.LAMBDA(node)
-
-    def LAMBDA(self, node):
-        for default in node.args.defaults:
-            self.handleNode(default, node)
-
-        def runFunction():
-            args = []
-
-            def addArgs(arglist):
-                for arg in arglist:
-                    if isinstance(arg, _ast.Tuple):
-                        addArgs(arg.elts)
-                    else:
-                        if arg.id in args:
-                            self.report(messages.DuplicateArgument,
-                                        node, arg.id)
-                        args.append(arg.id)
-
-            self.pushFunctionScope()
-            addArgs(node.args.args)
-            # vararg/kwarg identifiers are not Name nodes
-            if node.args.vararg:
-                args.append(node.args.vararg)
-            if node.args.kwarg:
-                args.append(node.args.kwarg)
-            for name in args:
-                self.addBinding(node, Argument(name, node), reportRedef=False)
-            if isinstance(node.body, list):
-                # case for FunctionDefs
-                for stmt in node.body:
-                    self.handleNode(stmt, node)
-            else:
-                # case for Lambdas
-                self.handleNode(node.body, node)
-            def checkUnusedAssignments():
-                """
-                Check to see if any assignments have not been used.
-                """
-                for name, binding in self.scope.iteritems():
-                    if (not binding.used and not name in self.scope.globals
-                        and isinstance(binding, Assignment)):
-                        self.report(messages.UnusedVariable,
-                                    binding.source, name)
-            self.deferAssignment(checkUnusedAssignments)
-            self.popScope()
-
-        self.deferFunction(runFunction)
-
-
-    def CLASSDEF(self, node):
-        """
-        Check names used in a class definition, including its decorators, base
-        classes, and the body of its definition.  Additionally, add its name to
-        the current scope.
-        """
-        # decorator_list is present as of Python 2.6
-        for deco in getattr(node, 'decorator_list', []):
-            self.handleNode(deco, node)
-        for baseNode in node.bases:
-            self.handleNode(baseNode, node)
-        self.pushClassScope()
-        for stmt in node.body:
-            self.handleNode(stmt, node)
-        self.popScope()
-        self.addBinding(node, Binding(node.name, node))
-
-    def ASSIGN(self, node):
-        self.handleNode(node.value, node)
-        for target in node.targets:
-            self.handleNode(target, node)
-
-    def AUGASSIGN(self, node):
-        # AugAssign is awkward: must set the context explicitly and visit twice,
-        # once with AugLoad context, once with AugStore context
-        node.target.ctx = _ast.AugLoad()
-        self.handleNode(node.target, node)
-        self.handleNode(node.value, node)
-        node.target.ctx = _ast.AugStore()
-        self.handleNode(node.target, node)
-
-    def IMPORT(self, node):
-        for alias in node.names:
-            name = alias.asname or alias.name
-            importation = Importation(name, node)
-            self.addBinding(node, importation)
-
-    def IMPORTFROM(self, node):
-        if node.module == '__future__':
-            if not self.futuresAllowed:
-                self.report(messages.LateFutureImport, node,
-                            [n.name for n in node.names])
-        else:
-            self.futuresAllowed = False
-
-        for alias in node.names:
-            if alias.name == '*':
-                self.scope.importStarred = True
-                self.report(messages.ImportStarUsed, node, node.module)
-                continue
-            name = alias.asname or alias.name
-            importation = Importation(name, node)
-            if node.module == '__future__':
-                importation.used = (self.scope, node)
-            self.addBinding(node, importation)

vim/ftplugin/python/pyflakes/pyflakes/messages.py

@@ -1,96 +0,0 @@
-# (c) 2005 Divmod, Inc.  See LICENSE file for details
-
-class Message(object):
-    message = ''
-    message_args = ()
-    def __init__(self, filename, loc, use_column=True):
-        self.filename = filename
-        self.lineno = loc.lineno
-        self.col = getattr(loc, 'col_offset', None) if use_column else None
-
-    def __str__(self):
-        return '%s:%s: %s' % (self.filename, self.lineno, self.message % self.message_args)
-
-
-class UnusedImport(Message):
-    message = '%r imported but unused'
-    def __init__(self, filename, loc, name):
-        Message.__init__(self, filename, loc, use_column=False)
-        self.message_args = (name,)
-
-
-class RedefinedWhileUnused(Message):
-    message = 'redefinition of unused %r from line %r'
-    def __init__(self, filename, loc, name, orig_loc):
-        Message.__init__(self, filename, loc)
-        self.message_args = (name, orig_loc.lineno)
-
-
-class ImportShadowedByLoopVar(Message):
-    message = 'import %r from line %r shadowed by loop variable'
-    def __init__(self, filename, loc, name, orig_loc):
-        Message.__init__(self, filename, loc)
-        self.message_args = (name, orig_loc.lineno)
-
-
-class ImportStarUsed(Message):
-    message = "'from %s import *' used; unable to detect undefined names"
-    def __init__(self, filename, loc, modname):
-        Message.__init__(self, filename, loc)
-        self.message_args = (modname,)
-
-
-class UndefinedName(Message):
-    message = 'undefined name %r'
-    def __init__(self, filename, loc, name):
-        Message.__init__(self, filename, loc)
-        self.message_args = (name,)
-
-
-
-class UndefinedExport(Message):
-    message = 'undefined name %r in __all__'
-    def __init__(self, filename, loc, name):
-        Message.__init__(self, filename, loc)
-        self.message_args = (name,)
-
-
-
-class UndefinedLocal(Message):
-    message = "local variable %r (defined in enclosing scope on line %r) referenced before assignment"
-    def __init__(self, filename, loc, name, orig_loc):
-        Message.__init__(self, filename, loc)
-        self.message_args = (name, orig_loc.lineno)
-
-
-class DuplicateArgument(Message):
-    message = 'duplicate argument %r in function definition'
-    def __init__(self, filename, loc, name):
-        Message.__init__(self, filename, loc)
-        self.message_args = (name,)
-
-
-class RedefinedFunction(Message):
-    message = 'redefinition of function %r from line %r'
-    def __init__(self, filename, loc, name, orig_loc):
-        Message.__init__(self, filename, loc)
-        self.message_args = (name, orig_loc.lineno)
-
-
-class LateFutureImport(Message):
-    message = 'future import(s) %r after other statements'
-    def __init__(self, filename, loc, names):
-        Message.__init__(self, filename, loc)
-        self.message_args = (names,)
-
-
-class UnusedVariable(Message):
-    """
-    Indicates that a variable has been explicity assigned to but not actually
-    used.
-    """
-
-    message = 'local variable %r is assigned to but never used'
-    def __init__(self, filename, loc, names):
-        Message.__init__(self, filename, loc)
-        self.message_args = (names,)

vim/ftplugin/python/pyflakes/pyflakes/scripts/pyflakes.py

@@ -1,90 +0,0 @@
-
-"""
-Implementation of the command-line I{pyflakes} tool.
-"""
-
-import sys
-import os
-import _ast
-
-checker = __import__('pyflakes.checker').checker
-
-def check(codeString, filename):
-    """
-    Check the Python source given by C{codeString} for flakes.
-
-    @param codeString: The Python source to check.
-    @type codeString: C{str}
-
-    @param filename: The name of the file the source came from, used to report
-        errors.
-    @type filename: C{str}
-
-    @return: The number of warnings emitted.
-    @rtype: C{int}
-    """
-    # First, compile into an AST and handle syntax errors.
-    try:
-        tree = compile(codeString, filename, "exec", _ast.PyCF_ONLY_AST)
-    except SyntaxError, value:
-        msg = value.args[0]
-
-        (lineno, offset, text) = value.lineno, value.offset, value.text
-
-        # If there's an encoding problem with the file, the text is None.
-        if text is None:
-            # Avoid using msg, since for the only known case, it contains a
-            # bogus message that claims the encoding the file declared was
-            # unknown.
-            print >> sys.stderr, "%s: problem decoding source" % (filename, )
-        else:
-            line = text.splitlines()[-1]
-
-            if offset is not None:
-                offset = offset - (len(text) - len(line))
-
-            print >> sys.stderr, '%s:%d: %s' % (filename, lineno, msg)
-            print >> sys.stderr, line
-
-            if offset is not None:
-                print >> sys.stderr, " " * offset, "^"
-
-        return 1
-    else:
-        # Okay, it's syntactically valid.  Now check it.
-        w = checker.Checker(tree, filename)
-        w.messages.sort(lambda a, b: cmp(a.lineno, b.lineno))
-        for warning in w.messages:
-            print warning
-        return len(w.messages)
-
-
-def checkPath(filename):
-    """
-    Check the given path, printing out any warnings detected.
-
-    @return: the number of warnings printed
-    """
-    try:
-        return check(file(filename, 'U').read() + '\n', filename)
-    except IOError, msg:
-        print >> sys.stderr, "%s: %s" % (filename, msg.args[1])
-        return 1
-
-
-def main():
-    warnings = 0
-    args = sys.argv[1:]
-    if args:
-        for arg in args:
-            if os.path.isdir(arg):
-                for dirpath, dirnames, filenames in os.walk(arg):
-                    for filename in filenames:
-                        if filename.endswith('.py'):
-                            warnings += checkPath(os.path.join(dirpath, filename))
-            else:
-                warnings += checkPath(arg)
-    else:
-        warnings += check(sys.stdin.read(), '<stdin>')
-
-    raise SystemExit(warnings > 0)

vim/ftplugin/python/pyflakes/pyflakes/test/harness.py

@@ -1,27 +0,0 @@
-
-import textwrap
-import _ast
-
-from twisted.trial import unittest
-
-from pyflakes import checker
-
-
-class Test(unittest.TestCase):
-
-    def flakes(self, input, *expectedOutputs, **kw):
-        ast = compile(textwrap.dedent(input), "<test>", "exec",
-                      _ast.PyCF_ONLY_AST)
-        w = checker.Checker(ast, **kw)
-        outputs = [type(o) for o in w.messages]
-        expectedOutputs = list(expectedOutputs)
-        outputs.sort()
-        expectedOutputs.sort()
-        self.assert_(outputs == expectedOutputs, '''\
-for input:
-%s
-expected outputs:
-%s
-but got:
-%s''' % (input, repr(expectedOutputs), '\n'.join([str(o) for o in w.messages])))
-        return w

vim/ftplugin/python/pyflakes/pyflakes/test/test_imports.py

@@ -1,673 +0,0 @@
-
-from sys import version_info
-
-from pyflakes import messages as m
-from pyflakes.test import harness
-
-class Test(harness.Test):
-
-    def test_unusedImport(self):
-        self.flakes('import fu, bar', m.UnusedImport, m.UnusedImport)
-        self.flakes('from baz import fu, bar', m.UnusedImport, m.UnusedImport)
-
-    def test_aliasedImport(self):
-        self.flakes('import fu as FU, bar as FU', m.RedefinedWhileUnused, m.UnusedImport)
-        self.flakes('from moo import fu as FU, bar as FU', m.RedefinedWhileUnused, m.UnusedImport)
-
-    def test_usedImport(self):
-        self.flakes('import fu; print fu')
-        self.flakes('from baz import fu; print fu')
-
-    def test_redefinedWhileUnused(self):
-        self.flakes('import fu; fu = 3', m.RedefinedWhileUnused)
-        self.flakes('import fu; del fu', m.RedefinedWhileUnused)
-        self.flakes('import fu; fu, bar = 3', m.RedefinedWhileUnused)
-        self.flakes('import fu; [fu, bar] = 3', m.RedefinedWhileUnused)
-
-    def test_redefinedByFunction(self):
-        self.flakes('''
-        import fu
-        def fu():
-            pass
-        ''', m.RedefinedWhileUnused)
-
-    def test_redefinedInNestedFunction(self):
-        """
-        Test that shadowing a global name with a nested function definition
-        generates a warning.
-        """
-        self.flakes('''
-        import fu
-        def bar():
-            def baz():
-                def fu():
-                    pass
-        ''', m.RedefinedWhileUnused, m.UnusedImport)
-
-    def test_redefinedByClass(self):
-        self.flakes('''
-        import fu
-        class fu:
-            pass
-        ''', m.RedefinedWhileUnused)
-
-
-    def test_redefinedBySubclass(self):
-        """
-        If an imported name is redefined by a class statement which also uses
-        that name in the bases list, no warning is emitted.
-        """
-        self.flakes('''
-        from fu import bar
-        class bar(bar):
-            pass
-        ''')
-
-
-    def test_redefinedInClass(self):
-        """
-        Test that shadowing a global with a class attribute does not produce a
-        warning.
-        """
-        self.flakes('''
-        import fu
-        class bar:
-            fu = 1
-        print fu
-        ''')
-
-    def test_usedInFunction(self):
-        self.flakes('''
-        import fu
-        def fun():
-            print fu
-        ''')
-
-    def test_shadowedByParameter(self):
-        self.flakes('''
-        import fu
-        def fun(fu):
-            print fu
-        ''', m.UnusedImport)
-
-        self.flakes('''
-        import fu
-        def fun(fu):
-            print fu
-        print fu
-        ''')
-
-    def test_newAssignment(self):
-        self.flakes('fu = None')
-
-    def test_usedInGetattr(self):
-        self.flakes('import fu; fu.bar.baz')
-        self.flakes('import fu; "bar".fu.baz', m.UnusedImport)
-
-    def test_usedInSlice(self):
-        self.flakes('import fu; print fu.bar[1:]')
-
-    def test_usedInIfBody(self):
-        self.flakes('''
-        import fu
-        if True: print fu
-        ''')
-
-    def test_usedInIfConditional(self):
-        self.flakes('''
-        import fu
-        if fu: pass
-        ''')
-
-    def test_usedInElifConditional(self):
-        self.flakes('''
-        import fu
-        if False: pass
-        elif fu: pass
-        ''')
-
-    def test_usedInElse(self):
-        self.flakes('''
-        import fu
-        if False: pass
-        else: print fu
-        ''')
-
-    def test_usedInCall(self):
-        self.flakes('import fu; fu.bar()')
-
-    def test_usedInClass(self):
-        self.flakes('''
-        import fu
-        class bar:
-            bar = fu
-        ''')
-
-    def test_usedInClassBase(self):
-        self.flakes('''
-        import fu
-        class bar(object, fu.baz):
-            pass
-        ''')
-
-    def test_notUsedInNestedScope(self):
-        self.flakes('''
-        import fu
-        def bleh():
-            pass
-        print fu
-        ''')
-
-    def test_usedInFor(self):
-        self.flakes('''
-        import fu
-        for bar in range(9):
-            print fu
-        ''')
-
-    def test_usedInForElse(self):
-        self.flakes('''
-        import fu
-        for bar in range(10):
-            pass
-        else:
-            print fu
-        ''')
-
-    def test_redefinedByFor(self):
-        self.flakes('''
-        import fu
-        for fu in range(2):
-            pass
-        ''', m.RedefinedWhileUnused)
-
-    def test_shadowedByFor(self):
-        """
-        Test that shadowing a global name with a for loop variable generates a
-        warning.
-        """
-        self.flakes('''
-        import fu
-        fu.bar()
-        for fu in ():
-            pass
-        ''', m.ImportShadowedByLoopVar)
-
-    def test_shadowedByForDeep(self):
-        """
-        Test that shadowing a global name with a for loop variable nested in a
-        tuple unpack generates a warning.
-        """
-        self.flakes('''
-        import fu
-        fu.bar()
-        for (x, y, z, (a, b, c, (fu,))) in ():
-            pass
-        ''', m.ImportShadowedByLoopVar)
-
-    def test_usedInReturn(self):
-        self.flakes('''
-        import fu
-        def fun():
-            return fu
-        ''')
-
-    def test_usedInOperators(self):
-        self.flakes('import fu; 3 + fu.bar')
-        self.flakes('import fu; 3 % fu.bar')
-        self.flakes('import fu; 3 - fu.bar')
-        self.flakes('import fu; 3 * fu.bar')
-        self.flakes('import fu; 3 ** fu.bar')
-        self.flakes('import fu; 3 / fu.bar')
-        self.flakes('import fu; 3 // fu.bar')
-        self.flakes('import fu; -fu.bar')
-        self.flakes('import fu; ~fu.bar')
-        self.flakes('import fu; 1 == fu.bar')
-        self.flakes('import fu; 1 | fu.bar')
-        self.flakes('import fu; 1 & fu.bar')
-        self.flakes('import fu; 1 ^ fu.bar')
-        self.flakes('import fu; 1 >> fu.bar')
-        self.flakes('import fu; 1 << fu.bar')
-
-    def test_usedInAssert(self):
-        self.flakes('import fu; assert fu.bar')
-
-    def test_usedInSubscript(self):
-        self.flakes('import fu; fu.bar[1]')
-
-    def test_usedInLogic(self):
-        self.flakes('import fu; fu and False')
-        self.flakes('import fu; fu or False')
-        self.flakes('import fu; not fu.bar')
-
-    def test_usedInList(self):
-        self.flakes('import fu; [fu]')
-
-    def test_usedInTuple(self):
-        self.flakes('import fu; (fu,)')
-
-    def test_usedInTry(self):
-        self.flakes('''
-        import fu
-        try: fu
-        except: pass
-        ''')
-
-    def test_usedInExcept(self):
-        self.flakes('''
-        import fu
-        try: fu
-        except: pass
-        ''')
-
-    def test_redefinedByExcept(self):
-        self.flakes('''
-        import fu
-        try: pass
-        except Exception, fu: pass
-        ''', m.RedefinedWhileUnused)
-
-    def test_usedInRaise(self):
-        self.flakes('''
-        import fu
-        raise fu.bar
-        ''')
-
-    def test_usedInYield(self):
-        self.flakes('''
-        import fu
-        def gen():
-            yield fu
-        ''')
-
-    def test_usedInDict(self):
-        self.flakes('import fu; {fu:None}')
-        self.flakes('import fu; {1:fu}')
-
-    def test_usedInParameterDefault(self):
-        self.flakes('''
-        import fu
-        def f(bar=fu):
-            pass
-        ''')
-
-    def test_usedInAttributeAssign(self):
-        self.flakes('import fu; fu.bar = 1')
-
-    def test_usedInKeywordArg(self):
-        self.flakes('import fu; fu.bar(stuff=fu)')
-
-    def test_usedInAssignment(self):
-        self.flakes('import fu; bar=fu')
-        self.flakes('import fu; n=0; n+=fu')
-
-    def test_usedInListComp(self):
-        self.flakes('import fu; [fu for _ in range(1)]')
-        self.flakes('import fu; [1 for _ in range(1) if fu]')
-
-    def test_redefinedByListComp(self):
-        self.flakes('import fu; [1 for fu in range(1)]', m.RedefinedWhileUnused)
-
-
-    def test_usedInTryFinally(self):
-        self.flakes('''
-        import fu
-        try: pass
-        finally: fu
-        ''')
-
-        self.flakes('''
-        import fu
-        try: fu
-        finally: pass
-        ''')
-
-    def test_usedInWhile(self):
-        self.flakes('''
-        import fu
-        while 0:
-            fu
-        ''')
-
-        self.flakes('''
-        import fu
-        while fu: pass
-        ''')
-
-    def test_usedInGlobal(self):
-        self.flakes('''
-        import fu
-        def f(): global fu
-        ''', m.UnusedImport)
-
-    def test_usedInBackquote(self):
-        self.flakes('import fu; `fu`')
-
-    def test_usedInExec(self):
-        self.flakes('import fu; exec "print 1" in fu.bar')
-
-    def test_usedInLambda(self):
-        self.flakes('import fu; lambda: fu')
-
-    def test_shadowedByLambda(self):
-        self.flakes('import fu; lambda fu: fu', m.UnusedImport)
-
-    def test_usedInSliceObj(self):
-        self.flakes('import fu; "meow"[::fu]')
-
-    def test_unusedInNestedScope(self):
-        self.flakes('''
-        def bar():
-            import fu
-        fu
-        ''', m.UnusedImport, m.UndefinedName)
-
-    def test_methodsDontUseClassScope(self):
-        self.flakes('''
-        class bar:
-            import fu
-            def fun(self):
-                fu
-        ''', m.UnusedImport, m.UndefinedName)
-
-    def test_nestedFunctionsNestScope(self):
-        self.flakes('''
-        def a():
-            def b():
-                fu
-            import fu
-        ''')
-
-    def test_nestedClassAndFunctionScope(self):
-        self.flakes('''
-        def a():
-            import fu
-            class b:
-                def c(self):
-                    print fu
-        ''')
-
-    def test_importStar(self):
-        self.flakes('from fu import *', m.ImportStarUsed)
-
-
-    def test_packageImport(self):
-        """
-        If a dotted name is imported and used, no warning is reported.
-        """
-        self.flakes('''
-        import fu.bar
-        fu.bar
-        ''')
-
-
-    def test_unusedPackageImport(self):
-        """
-        If a dotted name is imported and not used, an unused import warning is
-        reported.
-        """
-        self.flakes('import fu.bar', m.UnusedImport)
-
-
-    def test_duplicateSubmoduleImport(self):
-        """
-        If a submodule of a package is imported twice, an unused import warning
-        and a redefined while unused warning are reported.
-        """
-        self.flakes('''
-        import fu.bar, fu.bar
-        fu.bar
-        ''', m.RedefinedWhileUnused)
-        self.flakes('''
-        import fu.bar
-        import fu.bar
-        fu.bar
-        ''', m.RedefinedWhileUnused)
-
-
-    def test_differentSubmoduleImport(self):
-        """
-        If two different submodules of a package are imported, no duplicate
-        import warning is reported for the package.
-        """
-        self.flakes('''
-        import fu.bar, fu.baz
-        fu.bar, fu.baz
-        ''')
-        self.flakes('''
-        import fu.bar
-        import fu.baz
-        fu.bar, fu.baz
-        ''')
-
-    def test_assignRHSFirst(self):
-        self.flakes('import fu; fu = fu')
-        self.flakes('import fu; fu, bar = fu')
-        self.flakes('import fu; [fu, bar] = fu')
-        self.flakes('import fu; fu += fu')
-
-    def test_tryingMultipleImports(self):
-        self.flakes('''
-        try:
-            import fu
-        except ImportError:
-            import bar as fu
-        ''')
-    test_tryingMultipleImports.todo = ''
-
-    def test_nonGlobalDoesNotRedefine(self):
-        self.flakes('''
-        import fu
-        def a():
-            fu = 3
-            return fu
-        fu
-        ''')
-
-    def test_functionsRunLater(self):
-        self.flakes('''
-        def a():
-            fu
-        import fu
-        ''')
-
-    def test_functionNamesAreBoundNow(self):
-        self.flakes('''
-        import fu
-        def fu():
-            fu
-        fu
-        ''', m.RedefinedWhileUnused)
-
-    def test_ignoreNonImportRedefinitions(self):
-        self.flakes('a = 1; a = 2')
-
-    def test_importingForImportError(self):
-        self.flakes('''
-        try:
-            import fu
-        except ImportError:
-            pass
-        ''')
-    test_importingForImportError.todo = ''
-
-    def test_importedInClass(self):
-        '''Imports in class scope can be used through self'''
-        self.flakes('''
-        class c:
-            import i
-            def __init__(self):
-                self.i
-        ''')
-    test_importedInClass.todo = 'requires evaluating attribute access'
-
-    def test_futureImport(self):
-        '''__future__ is special'''
-        self.flakes('from __future__ import division')
-        self.flakes('''
-        "docstring is allowed before future import"
-        from __future__ import division
-        ''')
-
-    def test_futureImportFirst(self):
-        """
-        __future__ imports must come before anything else.
-        """
-        self.flakes('''
-        x = 5
-        from __future__ import division
-        ''', m.LateFutureImport)
-        self.flakes('''
-        from foo import bar
-        from __future__ import division
-        bar
-        ''', m.LateFutureImport)
-
-
-
-class TestSpecialAll(harness.Test):
-    """
-    Tests for suppression of unused import warnings by C{__all__}.
-    """
-    def test_ignoredInFunction(self):
-        """
-        An C{__all__} definition does not suppress unused import warnings in a
-        function scope.
-        """
-        self.flakes('''
-        def foo():
-            import bar
-            __all__ = ["bar"]
-        ''', m.UnusedImport, m.UnusedVariable)
-
-
-    def test_ignoredInClass(self):
-        """
-        An C{__all__} definition does not suppress unused import warnings in a
-        class scope.
-        """
-        self.flakes('''
-        class foo:
-            import bar
-            __all__ = ["bar"]
-        ''', m.UnusedImport)
-
-
-    def test_warningSuppressed(self):
-        """
-        If a name is imported and unused but is named in C{__all__}, no warning
-        is reported.
-        """
-        self.flakes('''
-        import foo
-        __all__ = ["foo"]
-        ''')
-
-
-    def test_unrecognizable(self):
-        """
-        If C{__all__} is defined in a way that can't be recognized statically,
-        it is ignored.
-        """
-        self.flakes('''
-        import foo
-        __all__ = ["f" + "oo"]
-        ''', m.UnusedImport)
-        self.flakes('''
-        import foo
-        __all__ = [] + ["foo"]
-        ''', m.UnusedImport)
-
-
-    def test_unboundExported(self):
-        """
-        If C{__all__} includes a name which is not bound, a warning is emitted.
-        """
-        self.flakes('''
-        __all__ = ["foo"]
-        ''', m.UndefinedExport)
-
-        # Skip this in __init__.py though, since the rules there are a little
-        # different.
-        for filename in ["foo/__init__.py", "__init__.py"]:
-            self.flakes('''
-            __all__ = ["foo"]
-            ''', filename=filename)
-
-
-    def test_usedInGenExp(self):
-        """
-        Using a global in a generator expression results in no warnings.
-        """
-        self.flakes('import fu; (fu for _ in range(1))')
-        self.flakes('import fu; (1 for _ in range(1) if fu)')
-
-
-    def test_redefinedByGenExp(self):
-        """
-        Re-using a global name as the loop variable for a generator
-        expression results in a redefinition warning.
-        """
-        self.flakes('import fu; (1 for fu in range(1))', m.RedefinedWhileUnused)
-
-
-    def test_usedAsDecorator(self):
-        """
-        Using a global name in a decorator statement results in no warnings,
-        but using an undefined name in a decorator statement results in an
-        undefined name warning.
-        """
-        self.flakes('''
-        from interior import decorate
-        @decorate
-        def f():
-            return "hello"
-        ''')
-
-        self.flakes('''
-        from interior import decorate
-        @decorate('value')
-        def f():
-            return "hello"
-        ''')
-
-        self.flakes('''
-        @decorate
-        def f():
-            return "hello"
-        ''', m.UndefinedName)
-
-
-class Python26Tests(harness.Test):
-    """
-    Tests for checking of syntax which is valid in PYthon 2.6 and newer.
-    """
-    if version_info < (2, 6):
-        skip = "Python 2.6 required for class decorator tests."
-
-
-    def test_usedAsClassDecorator(self):
-        """
-        Using an imported name as a class decorator results in no warnings,
-        but using an undefined name as a class decorator results in an
-        undefined name warning.
-        """
-        self.flakes('''
-        from interior import decorate
-        @decorate
-        class foo:
-            pass
-        ''')
-
-        self.flakes('''
-        from interior import decorate
-        @decorate("foo")
-        class bar:
-            pass
-        ''')
-
-        self.flakes('''
-        @decorate
-        class foo:
-            pass
-        ''', m.UndefinedName)

vim/ftplugin/python/pyflakes/pyflakes/test/test_other.py

@@ -1,575 +0,0 @@
-# (c) 2005-2010 Divmod, Inc.
-# See LICENSE file for details
-
-"""
-Tests for various Pyflakes behavior.
-"""
-
-from sys import version_info
-
-from pyflakes import messages as m
-from pyflakes.test import harness
-
-
-class Test(harness.Test):
-
-    def test_duplicateArgs(self):
-        self.flakes('def fu(bar, bar): pass', m.DuplicateArgument)
-
-    def test_localReferencedBeforeAssignment(self):
-        self.flakes('''
-        a = 1
-        def f():
-            a; a=1
-        f()
-        ''', m.UndefinedName)
-    test_localReferencedBeforeAssignment.todo = 'this requires finding all assignments in the function body first'
-
-    def test_redefinedFunction(self):
-        """
-        Test that shadowing a function definition with another one raises a
-        warning.
-        """
-        self.flakes('''
-        def a(): pass
-        def a(): pass
-        ''', m.RedefinedFunction)
-
-    def test_redefinedClassFunction(self):
-        """
-        Test that shadowing a function definition in a class suite with another
-        one raises a warning.
-        """
-        self.flakes('''
-        class A:
-            def a(): pass
-            def a(): pass
-        ''', m.RedefinedFunction)
-
-    def test_functionDecorator(self):
-        """
-        Test that shadowing a function definition with a decorated version of
-        that function does not raise a warning.
-        """
-        self.flakes('''
-        from somewhere import somedecorator
-
-        def a(): pass
-        a = somedecorator(a)
-        ''')
-
-    def test_classFunctionDecorator(self):
-        """
-        Test that shadowing a function definition in a class suite with a
-        decorated version of that function does not raise a warning.
-        """
-        self.flakes('''
-        class A:
-            def a(): pass
-            a = classmethod(a)
-        ''')
-
-    def test_unaryPlus(self):
-        '''Don't die on unary +'''
-        self.flakes('+1')
-
-
-    def test_undefinedBaseClass(self):
-        """
-        If a name in the base list of a class definition is undefined, a
-        warning is emitted.
-        """
-        self.flakes('''
-        class foo(foo):
-            pass
-        ''', m.UndefinedName)
-
-
-    def test_classNameUndefinedInClassBody(self):
-        """
-        If a class name is used in the body of that class's definition and
-        the name is not already defined, a warning is emitted.
-        """
-        self.flakes('''
-        class foo:
-            foo
-        ''', m.UndefinedName)
-
-
-    def test_classNameDefinedPreviously(self):
-        """
-        If a class name is used in the body of that class's definition and
-        the name was previously defined in some other way, no warning is
-        emitted.
-        """
-        self.flakes('''
-        foo = None
-        class foo:
-            foo
-        ''')
-
-
-    def test_comparison(self):
-        """
-        If a defined name is used on either side of any of the six comparison
-        operators, no warning is emitted.
-        """
-        self.flakes('''
-        x = 10
-        y = 20
-        x < y
-        x <= y
-        x == y
-        x != y
-        x >= y
-        x > y
-        ''')
-
-
-    def test_identity(self):
-        """
-        If a deefined name is used on either side of an identity test, no
-        warning is emitted.
-        """
-        self.flakes('''
-        x = 10
-        y = 20
-        x is y
-        x is not y
-        ''')
-
-
-    def test_containment(self):
-        """
-        If a defined name is used on either side of a containment test, no
-        warning is emitted.
-        """
-        self.flakes('''
-        x = 10
-        y = 20
-        x in y
-        x not in y
-        ''')
-
-
-    def test_loopControl(self):
-        """
-        break and continue statements are supported.
-        """
-        self.flakes('''
-        for x in [1, 2]:
-            break
-        ''')
-        self.flakes('''
-        for x in [1, 2]:
-            continue
-        ''')
-
-
-    def test_ellipsis(self):
-        """
-        Ellipsis in a slice is supported.
-        """
-        self.flakes('''
-        [1, 2][...]
-        ''')
-
-
-    def test_extendedSlice(self):
-        """
-        Extended slices are supported.
-        """
-        self.flakes('''
-        x = 3
-        [1, 2][x,:]
-        ''')
-
-
-
-class TestUnusedAssignment(harness.Test):
-    """
-    Tests for warning about unused assignments.
-    """
-
-    def test_unusedVariable(self):
-        """
-        Warn when a variable in a function is assigned a value that's never
-        used.
-        """
-        self.flakes('''
-        def a():
-            b = 1
-        ''', m.UnusedVariable)
-
-
-    def test_assignToGlobal(self):
-        """
-        Assigning to a global and then not using that global is perfectly
-        acceptable. Do not mistake it for an unused local variable.
-        """
-        self.flakes('''
-        b = 0
-        def a():
-            global b
-            b = 1
-        ''')
-
-
-    def test_assignToMember(self):
-        """
-        Assigning to a member of another object and then not using that member
-        variable is perfectly acceptable. Do not mistake it for an unused
-        local variable.
-        """
-        # XXX: Adding this test didn't generate a failure. Maybe not
-        # necessary?
-        self.flakes('''
-        class b:
-            pass
-        def a():
-            b.foo = 1
-        ''')
-
-
-    def test_assignInForLoop(self):
-        """
-        Don't warn when a variable in a for loop is assigned to but not used.
-        """
-        self.flakes('''
-        def f():
-            for i in range(10):
-                pass
-        ''')
-
-
-    def test_assignInListComprehension(self):
-        """
-        Don't warn when a variable in a list comprehension is assigned to but
-        not used.
-        """
-        self.flakes('''
-        def f():
-            [None for i in range(10)]
-        ''')
-
-
-    def test_generatorExpression(self):
-        """
-        Don't warn when a variable in a generator expression is assigned to but not used.
-        """
-        self.flakes('''
-        def f():
-            (None for i in range(10))
-        ''')
-
-
-    def test_assignmentInsideLoop(self):
-        """
-        Don't warn when a variable assignment occurs lexically after its use.
-        """
-        self.flakes('''
-        def f():
-            x = None
-            for i in range(10):
-                if i > 2:
-                    return x
-                x = i * 2
-        ''')
-
-
-    def test_tupleUnpacking(self):
-        """
-        Don't warn when a variable included in tuple unpacking is unused. It's
-        very common for variables in a tuple unpacking assignment to be unused
-        in good Python code, so warning will only create false positives.
-        """
-        self.flakes('''
-        def f():
-            (x, y) = 1, 2
-        ''')
-
-
-    def test_listUnpacking(self):
-        """
-        Don't warn when a variable included in list unpacking is unused.
-        """
-        self.flakes('''
-        def f():
-            [x, y] = [1, 2]
-        ''')
-
-
-    def test_closedOver(self):
-        """
-        Don't warn when the assignment is used in an inner function.
-        """
-        self.flakes('''
-        def barMaker():
-            foo = 5
-            def bar():
-                return foo
-            return bar
-        ''')
-
-
-    def test_doubleClosedOver(self):
-        """
-        Don't warn when the assignment is used in an inner function, even if
-        that inner function itself is in an inner function.
-        """
-        self.flakes('''
-        def barMaker():
-            foo = 5
-            def bar():
-                def baz():
-                    return foo
-            return bar
-        ''')
-
-
-
-class Python25Test(harness.Test):
-    """
-    Tests for checking of syntax only available in Python 2.5 and newer.
-    """
-    if version_info < (2, 5):
-        skip = "Python 2.5 required for if-else and with tests"
-
-    def test_ifexp(self):
-        """
-        Test C{foo if bar else baz} statements.
-        """
-        self.flakes("a = 'moo' if True else 'oink'")
-        self.flakes("a = foo if True else 'oink'", m.UndefinedName)
-        self.flakes("a = 'moo' if True else bar", m.UndefinedName)
-
-
-    def test_withStatementNoNames(self):
-        """
-        No warnings are emitted for using inside or after a nameless C{with}
-        statement a name defined beforehand.
-        """
-        self.flakes('''
-        from __future__ import with_statement
-        bar = None
-        with open("foo"):
-            bar
-        bar
-        ''')
-
-    def test_withStatementSingleName(self):
-        """
-        No warnings are emitted for using a name defined by a C{with} statement
-        within the suite or afterwards.
-        """
-        self.flakes('''
-        from __future__ import with_statement
-        with open('foo') as bar:
-            bar
-        bar
-        ''')
-
-
-    def test_withStatementAttributeName(self):
-        """
-        No warnings are emitted for using an attribute as the target of a
-        C{with} statement.
-        """
-        self.flakes('''
-        from __future__ import with_statement
-        import foo
-        with open('foo') as foo.bar:
-            pass
-        ''')
-
-
-    def test_withStatementSubscript(self):
-        """
-        No warnings are emitted for using a subscript as the target of a
-        C{with} statement.
-        """
-        self.flakes('''
-        from __future__ import with_statement
-        import foo
-        with open('foo') as foo[0]:
-            pass
-        ''')
-
-
-    def test_withStatementSubscriptUndefined(self):
-        """
-        An undefined name warning is emitted if the subscript used as the
-        target of a C{with} statement is not defined.
-        """
-        self.flakes('''
-        from __future__ import with_statement
-        import foo
-        with open('foo') as foo[bar]:
-            pass
-        ''', m.UndefinedName)
-
-
-    def test_withStatementTupleNames(self):
-        """
-        No warnings are emitted for using any of the tuple of names defined by
-        a C{with} statement within the suite or afterwards.
-        """
-        self.flakes('''
-        from __future__ import with_statement
-        with open('foo') as (bar, baz):
-            bar, baz
-        bar, baz
-        ''')
-
-
-    def test_withStatementListNames(self):
-        """
-        No warnings are emitted for using any of the list of names defined by a
-        C{with} statement within the suite or afterwards.
-        """
-        self.flakes('''
-        from __future__ import with_statement
-        with open('foo') as [bar, baz]:
-            bar, baz
-        bar, baz
-        ''')
-
-
-    def test_withStatementComplicatedTarget(self):
-        """
-        If the target of a C{with} statement uses any or all of the valid forms
-        for that part of the grammar (See
-        U{http://docs.python.org/reference/compound_stmts.html#the-with-statement}),
-        the names involved are checked both for definedness and any bindings
-        created are respected in the suite of the statement and afterwards.
-        """
-        self.flakes('''
-        from __future__ import with_statement
-        c = d = e = g = h = i = None
-        with open('foo') as [(a, b), c[d], e.f, g[h:i]]:
-            a, b, c, d, e, g, h, i
-        a, b, c, d, e, g, h, i
-        ''')
-
-
-    def test_withStatementSingleNameUndefined(self):
-        """
-        An undefined name warning is emitted if the name first defined by a
-        C{with} statement is used before the C{with} statement.
-        """
-        self.flakes('''
-        from __future__ import with_statement
-        bar
-        with open('foo') as bar:
-            pass
-        ''', m.UndefinedName)
-
-
-    def test_withStatementTupleNamesUndefined(self):
-        """
-        An undefined name warning is emitted if a name first defined by a the
-        tuple-unpacking form of the C{with} statement is used before the
-        C{with} statement.
-        """
-        self.flakes('''
-        from __future__ import with_statement
-        baz
-        with open('foo') as (bar, baz):
-            pass
-        ''', m.UndefinedName)
-
-
-    def test_withStatementSingleNameRedefined(self):
-        """
-        A redefined name warning is emitted if a name bound by an import is
-        rebound by the name defined by a C{with} statement.
-        """
-        self.flakes('''
-        from __future__ import with_statement
-        import bar
-        with open('foo') as bar:
-            pass
-        ''', m.RedefinedWhileUnused)
-
-
-    def test_withStatementTupleNamesRedefined(self):
-        """
-        A redefined name warning is emitted if a name bound by an import is
-        rebound by one of the names defined by the tuple-unpacking form of a
-        C{with} statement.
-        """
-        self.flakes('''
-        from __future__ import with_statement
-        import bar
-        with open('foo') as (bar, baz):
-            pass
-        ''', m.RedefinedWhileUnused)
-
-
-    def test_withStatementUndefinedInside(self):
-        """
-        An undefined name warning is emitted if a name is used inside the
-        body of a C{with} statement without first being bound.
-        """
-        self.flakes('''
-        from __future__ import with_statement
-        with open('foo') as bar:
-            baz
-        ''', m.UndefinedName)
-
-
-    def test_withStatementNameDefinedInBody(self):
-        """
-        A name defined in the body of a C{with} statement can be used after
-        the body ends without warning.
-        """
-        self.flakes('''
-        from __future__ import with_statement
-        with open('foo') as bar:
-            baz = 10
-        baz
-        ''')
-
-
-    def test_withStatementUndefinedInExpression(self):
-        """
-        An undefined name warning is emitted if a name in the I{test}
-        expression of a C{with} statement is undefined.
-        """
-        self.flakes('''
-        from __future__ import with_statement
-        with bar as baz:
-            pass
-        ''', m.UndefinedName)
-
-        self.flakes('''
-        from __future__ import with_statement
-        with bar as bar:
-            pass
-        ''', m.UndefinedName)
-
-
-
-class Python27Test(harness.Test):
-    """
-    Tests for checking of syntax only available in Python 2.7 and newer.
-    """
-    if version_info < (2, 7):
-        skip = "Python 2.7 required for dict/set comprehension tests"
-
-    def test_dictComprehension(self):
-        """
-        Dict comprehensions are properly handled.
-        """
-        self.flakes('''
-        a = {1: x for x in range(10)}
-        ''')
-
-    def test_setComprehensionAndLiteral(self):
-        """
-        Set comprehensions are properly handled.
-        """
-        self.flakes('''
-        a = {1, 2, 3}
-        b = {x for x in range(10)}
-        ''')

vim/ftplugin/python/pyflakes/pyflakes/test/test_script.py

@@ -1,185 +0,0 @@
-
-"""
-Tests for L{pyflakes.scripts.pyflakes}.
-"""
-
-import sys
-from StringIO import StringIO
-
-from twisted.python.filepath import FilePath
-from twisted.trial.unittest import TestCase
-
-from pyflakes.scripts.pyflakes import checkPath
-
-def withStderrTo(stderr, f):
-    """
-    Call C{f} with C{sys.stderr} redirected to C{stderr}.
-    """
-    (outer, sys.stderr) = (sys.stderr, stderr)
-    try:
-        return f()
-    finally:
-        sys.stderr = outer
-
-
-
-class CheckTests(TestCase):
-    """
-    Tests for L{check} and L{checkPath} which check a file for flakes.
-    """
-    def test_missingTrailingNewline(self):
-        """
-        Source which doesn't end with a newline shouldn't cause any
-        exception to be raised nor an error indicator to be returned by
-        L{check}.
-        """
-        fName = self.mktemp()
-        FilePath(fName).setContent("def foo():\n\tpass\n\t")
-        self.assertFalse(checkPath(fName))
-
-
-    def test_checkPathNonExisting(self):
-        """
-        L{checkPath} handles non-existing files.
-        """
-        err = StringIO()
-        count = withStderrTo(err, lambda: checkPath('extremo'))
-        self.assertEquals(err.getvalue(), 'extremo: No such file or directory\n')
-        self.assertEquals(count, 1)
-
-
-    def test_multilineSyntaxError(self):
-        """
-        Source which includes a syntax error which results in the raised
-        L{SyntaxError.text} containing multiple lines of source are reported
-        with only the last line of that source.
-        """
-        source = """\
-def foo():
-    '''
-
-def bar():
-    pass
-
-def baz():
-    '''quux'''
-"""
-
-        # Sanity check - SyntaxError.text should be multiple lines, if it
-        # isn't, something this test was unprepared for has happened.
-        def evaluate(source):
-            exec source
-        exc = self.assertRaises(SyntaxError, evaluate, source)
-        self.assertTrue(exc.text.count('\n') > 1)
-
-        sourcePath = FilePath(self.mktemp())
-        sourcePath.setContent(source)
-        err = StringIO()
-        count = withStderrTo(err, lambda: checkPath(sourcePath.path))
-        self.assertEqual(count, 1)
-
-        self.assertEqual(
-            err.getvalue(),
-            """\
-%s:8: invalid syntax
-    '''quux'''
-           ^
-""" % (sourcePath.path,))
-
-
-    def test_eofSyntaxError(self):
-        """
-        The error reported for source files which end prematurely causing a
-        syntax error reflects the cause for the syntax error.
-        """
-        source = "def foo("
-        sourcePath = FilePath(self.mktemp())
-        sourcePath.setContent(source)
-        err = StringIO()
-        count = withStderrTo(err, lambda: checkPath(sourcePath.path))
-        self.assertEqual(count, 1)
-        self.assertEqual(
-            err.getvalue(),
-            """\
-%s:1: unexpected EOF while parsing
-def foo(
-         ^
-""" % (sourcePath.path,))
-
-
-    def test_nonDefaultFollowsDefaultSyntaxError(self):
-        """
-        Source which has a non-default argument following a default argument
-        should include the line number of the syntax error.  However these
-        exceptions do not include an offset.
-        """
-        source = """\
-def foo(bar=baz, bax):
-    pass
-"""
-        sourcePath = FilePath(self.mktemp())
-        sourcePath.setContent(source)
-        err = StringIO()
-        count = withStderrTo(err, lambda: checkPath(sourcePath.path))
-        self.assertEqual(count, 1)
-        self.assertEqual(
-            err.getvalue(),
-            """\
-%s:1: non-default argument follows default argument
-def foo(bar=baz, bax):
-""" % (sourcePath.path,))
-
-
-    def test_nonKeywordAfterKeywordSyntaxError(self):
-        """
-        Source which has a non-keyword argument after a keyword argument should
-        include the line number of the syntax error.  However these exceptions
-        do not include an offset.
-        """
-        source = """\
-foo(bar=baz, bax)
-"""
-        sourcePath = FilePath(self.mktemp())
-        sourcePath.setContent(source)
-        err = StringIO()
-        count = withStderrTo(err, lambda: checkPath(sourcePath.path))
-        self.assertEqual(count, 1)
-        self.assertEqual(
-            err.getvalue(),
-            """\
-%s:1: non-keyword arg after keyword arg
-foo(bar=baz, bax)
-""" % (sourcePath.path,))
-
-
-    def test_permissionDenied(self):
-        """
-        If the a source file is not readable, this is reported on standard
-        error.
-        """
-        sourcePath = FilePath(self.mktemp())
-        sourcePath.setContent('')
-        sourcePath.chmod(0)
-        err = StringIO()
-        count = withStderrTo(err, lambda: checkPath(sourcePath.path))
-        self.assertEquals(count, 1)
-        self.assertEquals(
-            err.getvalue(), "%s: Permission denied\n" % (sourcePath.path,))
-
-
-    def test_misencodedFile(self):
-        """
-        If a source file contains bytes which cannot be decoded, this is
-        reported on stderr.
-        """
-        source = u"""\
-# coding: ascii
-x = "\N{SNOWMAN}"
-""".encode('utf-8')
-        sourcePath = FilePath(self.mktemp())
-        sourcePath.setContent(source)
-        err = StringIO()
-        count = withStderrTo(err, lambda: checkPath(sourcePath.path))
-        self.assertEquals(count, 1)
-        self.assertEquals(
-            err.getvalue(), "%s: problem decoding source\n" % (sourcePath.path,))

vim/ftplugin/python/pyflakes/pyflakes/test/test_undefined_names.py

@@ -1,265 +0,0 @@
-
-from _ast import PyCF_ONLY_AST
-
-from twisted.trial.unittest import TestCase
-
-from pyflakes import messages as m, checker
-from pyflakes.test import harness
-
-
-class Test(harness.Test):
-    def test_undefined(self):
-        self.flakes('bar', m.UndefinedName)
-
-    def test_definedInListComp(self):
-        self.flakes('[a for a in range(10) if a]')
-
-
-    def test_functionsNeedGlobalScope(self):
-        self.flakes('''
-        class a:
-            def b():
-                fu
-        fu = 1
-        ''')
-
-    def test_builtins(self):
-        self.flakes('range(10)')
-
-
-    def test_magicGlobalsFile(self):
-        """
-        Use of the C{__file__} magic global should not emit an undefined name
-        warning.
-        """
-        self.flakes('__file__')
-
-
-    def test_magicGlobalsBuiltins(self):
-        """
-        Use of the C{__builtins__} magic global should not emit an undefined
-        name warning.
-        """
-        self.flakes('__builtins__')
-
-
-    def test_magicGlobalsName(self):
-        """
-        Use of the C{__name__} magic global should not emit an undefined name
-        warning.
-        """
-        self.flakes('__name__')
-
-
-    def test_magicGlobalsPath(self):
-        """
-        Use of the C{__path__} magic global should not emit an undefined name
-        warning, if you refer to it from a file called __init__.py.
-        """
-        self.flakes('__path__', m.UndefinedName)
-        self.flakes('__path__', filename='package/__init__.py')
-
-
-    def test_globalImportStar(self):
-        '''Can't find undefined names with import *'''
-        self.flakes('from fu import *; bar', m.ImportStarUsed)
-
-    def test_localImportStar(self):
-        '''A local import * still allows undefined names to be found in upper scopes'''
-        self.flakes('''
-        def a():
-            from fu import *
-        bar
-        ''', m.ImportStarUsed, m.UndefinedName)
-
-    def test_unpackedParameter(self):
-        '''Unpacked function parameters create bindings'''
-        self.flakes('''
-        def a((bar, baz)):
-            bar; baz
-        ''')
-
-    def test_definedByGlobal(self):
-        '''"global" can make an otherwise undefined name in another function defined'''
-        self.flakes('''
-        def a(): global fu; fu = 1
-        def b(): fu
-        ''')
-    test_definedByGlobal.todo = ''
-
-    def test_globalInGlobalScope(self):
-        """
-        A global statement in the global scope is ignored.
-        """
-        self.flakes('''
-        global x
-        def foo():
-            print x
-        ''', m.UndefinedName)
-
-    def test_del(self):
-        '''del deletes bindings'''
-        self.flakes('a = 1; del a; a', m.UndefinedName)
-
-    def test_delGlobal(self):
-        '''del a global binding from a function'''
-        self.flakes('''
-        a = 1
-        def f():
-            global a
-            del a
-        a
-        ''')
-
-    def test_delUndefined(self):
-        '''del an undefined name'''
-        self.flakes('del a', m.UndefinedName)
-
-    def test_globalFromNestedScope(self):
-        '''global names are available from nested scopes'''
-        self.flakes('''
-        a = 1
-        def b():
-            def c():
-                a
-        ''')
-
-    def test_laterRedefinedGlobalFromNestedScope(self):
-        """
-        Test that referencing a local name that shadows a global, before it is
-        defined, generates a warning.
-        """
-        self.flakes('''
-        a = 1
-        def fun():
-            a
-            a = 2
-            return a
-        ''', m.UndefinedLocal)
-
-    def test_laterRedefinedGlobalFromNestedScope2(self):
-        """
-        Test that referencing a local name in a nested scope that shadows a
-        global declared in an enclosing scope, before it is defined, generates
-        a warning.
-        """
-        self.flakes('''
-            a = 1
-            def fun():
-                global a
-                def fun2():
-                    a
-                    a = 2
-                    return a
-        ''', m.UndefinedLocal)
-
-
-    def test_intermediateClassScopeIgnored(self):
-        """
-        If a name defined in an enclosing scope is shadowed by a local variable
-        and the name is used locally before it is bound, an unbound local
-        warning is emitted, even if there is a class scope between the enclosing
-        scope and the local scope.
-        """
-        self.flakes('''
-        def f():
-            x = 1
-            class g:
-                def h(self):
-                    a = x
-                    x = None
-                    print x, a
-            print x
-        ''', m.UndefinedLocal)
-
-
-    def test_doubleNestingReportsClosestName(self):
-        """
-        Test that referencing a local name in a nested scope that shadows a
-        variable declared in two different outer scopes before it is defined
-        in the innermost scope generates an UnboundLocal warning which
-        refers to the nearest shadowed name.
-        """
-        exc = self.flakes('''
-            def a():
-                x = 1
-                def b():
-                    x = 2 # line 5
-                    def c():
-                        x
-                        x = 3
-                        return x
-                    return x
-                return x
-        ''', m.UndefinedLocal).messages[0]
-        self.assertEqual(exc.message_args, ('x', 5))
-
-
-    def test_laterRedefinedGlobalFromNestedScope3(self):
-        """
-        Test that referencing a local name in a nested scope that shadows a
-        global, before it is defined, generates a warning.
-        """
-        self.flakes('''
-            def fun():
-                a = 1
-                def fun2():
-                    a
-                    a = 1
-                    return a
-                return a
-        ''', m.UndefinedLocal)
-
-    def test_nestedClass(self):
-        '''nested classes can access enclosing scope'''
-        self.flakes('''
-        def f(foo):
-            class C:
-                bar = foo
-                def f(self):
-                    return foo
-            return C()
-
-        f(123).f()
-        ''')
-
-    def test_badNestedClass(self):
-        '''free variables in nested classes must bind at class creation'''
-        self.flakes('''
-        def f():
-            class C:
-                bar = foo
-            foo = 456
-            return foo
-        f()
-        ''', m.UndefinedName)
-
-    def test_definedAsStarArgs(self):
-        '''star and double-star arg names are defined'''
-        self.flakes('''
-        def f(a, *b, **c):
-            print a, b, c
-        ''')
-
-    def test_definedInGenExp(self):
-        """
-        Using the loop variable of a generator expression results in no
-        warnings.
-        """
-        self.flakes('(a for a in xrange(10) if a)')
-
-
-
-class NameTests(TestCase):
-    """
-    Tests for some extra cases of name handling.
-    """
-    def test_impossibleContext(self):
-        """
-        A Name node with an unrecognized context results in a RuntimeError being
-        raised.
-        """
-        tree = compile("x = 10", "<test>", "exec", PyCF_ONLY_AST)
-        # Make it into something unrecognizable.
-        tree.body[0].targets[0].ctx = object()
-        self.assertRaises(RuntimeError, checker.Checker, tree)

vim/ftplugin/python/pyflakes/setup.py

@@ -1,28 +0,0 @@
-#!/usr/bin/python
-# (c) 2005-2009 Divmod, Inc.  See LICENSE file for details
-
-from distutils.core import setup
-
-setup(
-    name="pyflakes",
-    license="MIT",
-    version="0.4.0",
-    description="passive checker of Python programs",
-    author="Phil Frost",
-    maintainer="Moe Aboulkheir",
-    maintainer_email="moe@divmod.com",
-    url="http://www.divmod.org/trac/wiki/DivmodPyflakes",
-    packages=["pyflakes", "pyflakes.scripts", "pyflakes.test"],
-    scripts=["bin/pyflakes"],
-    long_description="""Pyflakes is program to analyze Python programs and detect various errors. It
-works by parsing the source file, not importing it, so it is safe to use on
-modules with side effects. It's also much faster.""",
-    classifiers=[
-        "Development Status :: 6 - Mature",
-        "Environment :: Console",
-        "Intended Audience :: Developers",
-        "License :: OSI Approved :: MIT License",
-        "Programming Language :: Python",
-        "Topic :: Software Development",
-        "Topic :: Utilities",
-        ])

vim/plugin/syntastic.vim

@@ -0,0 +1,672 @@
+"============================================================================
+"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')
+    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.6.0-80'
+lockvar g:_SYNTASTIC_VERSION
+
+" Sanity checks {{{1
+
+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,
+        \ 'quiet_messages':           {},
+        \ 'reuse_loc_lists':          0,
+        \ '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 v:version > 703 || (v:version == 703 && has('patch446'))
+    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()
+
+" 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! -nargs=* -complete=custom,s:CompleteCheckerName SyntasticCheck call SyntasticCheck(<f-args>)
+command! -nargs=? -complete=custom,s:CompleteFiletypes   SyntasticInfo  call SyntasticInfo(<f-args>)
+command! Errors              call SyntasticErrors()
+command! SyntasticReset      call SyntasticReset()
+command! SyntasticToggleMode call SyntasticToggleMode()
+command! SyntasticSetLoclist call SyntasticSetLoclist()
+
+" }}}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 BufReadPost  * call s:BufReadPostHook()
+    autocmd BufWritePost * call s:BufWritePostHook()
+    autocmd BufEnter     * call s:BufEnterHook()
+augroup END
+
+if v:version > 703 || (v:version == 703 && has('patch544'))
+    " QuitPre was added in Vim 7.3.544
+    augroup syntastic
+        autocmd QuitPre * call s:QuitPreHook()
+    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 get(w:, 'syntastic_loclist_set', 0) && !empty(loclist) && empty(filter( buffers, 'syntastic#util#bufIsActive(v:val)' ))
+            call SyntasticLoclistHide()
+        endif
+    endif
+endfunction " }}}2
+
+function! s:QuitPreHook() abort " {{{2
+    call syntastic#log#debug(g:_SYNTASTIC_DEBUG_AUTOCOMMANDS,
+        \ 'autocmd: QuitPre, buffer ' . bufnr('') . ' = ' . string(bufname(str2nr(bufnr('')))))
+    let b:syntastic_skip_checks = get(b:, 'syntastic_skip_checks', 0) || !syntastic#util#var('check_on_wq')
+    if get(w:, 'syntastic_loclist_set', 0)
+        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'))
+    if s:_skip_file()
+        return
+    endif
+
+    call s:modemap.synch()
+    let run_checks = !a:auto_invoked || s:modemap.doAutoChecking()
+    if run_checks
+        call s:CacheErrors(a:checker_names)
+        unlockvar! b:syntastic_changedtick
+        let b:syntastic_changedtick = b:changedtick
+        lockvar! b:syntastic_changedtick
+    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 = 0
+    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())
+        let w:syntastic_loclist_set = 1
+        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']
+    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_]\+$'
+                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
+        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
+
+" Skip running in special buffers
+function! s:_skip_file() abort " {{{2
+    let fname = expand('%', 1)
+    let skip = get(b:, 'syntastic_skip_checks', 0) || (&buftype !=# '') ||
+        \ !filereadable(fname) || getwinvar(0, '&diff') || 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 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 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:

vim/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')
+    if !a:loclist.isEmpty()
+        if syntastic#util#var('auto_loc_list') == 1
+            call a:loclist.show()
+        endif
+    else
+        if syntastic#util#var('auto_loc_list') > 0
+
+            "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:

vim/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:

vim/plugin/syntastic/checker.vim

@@ -0,0 +1,228 @@
+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']
+    let newObj._exec = get(a:args, 'exec', newObj._name)
+
+    if has_key(a:args, 'redirect')
+        let [filetype, name] = split(a:args['redirect'], '/')
+        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
+    else
+        let prefix = 'SyntaxCheckers_' . newObj._filetype . '_' . newObj._name . '_'
+    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() dict " {{{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 name = self._filetype . '/' . self._name
+    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)
+    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 . ')' : '') )
+        call self.setVersion(syntastic#util#parseVersion(version_output))
+    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)
+    else
+        call syntastic#log#error("checker " . self._filetype . "/" . self._name . ": can't parse version string (abnormal termination?)")
+    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.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:

vim/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:

vim/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:

vim/plugin/syntastic/loclist.vim

@@ -0,0 +1,434 @@
+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')
+
+            "sub in the total errors/warnings/both
+            let output = substitute(output, '\m\C%w', num_warnings, 'g')
+            let output = substitute(output, '\m\C%e', num_errors, 'g')
+            let output = substitute(output, '\m\C%t', num_issues, 'g')
+
+            "first error/warning line num
+            let output = substitute(output, '\m\C%F', num_issues ? self._rawLoclist[0]['lnum'] : '', 'g')
+
+            "first error line num
+            let output = substitute(output, '\m\C%fe', num_errors ? errors[0]['lnum'] : '', 'g')
+
+            "first warning line num
+            let output = substitute(output, '\m\C%fw', num_warnings ? warnings[0]['lnum'] : '', '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 = 0
+    endif
+    let replace = g:syntastic_reuse_loc_lists && w:syntastic_loclist_set
+    call syntastic#log#debug(g:_SYNTASTIC_DEBUG_NOTIFICATIONS, 'loclist: setloclist ' . (replace ? '(replace)' : '(new)'))
+    call setloclist(0, self.getRaw(), replace ? 'r' : ' ')
+    let w:syntastic_loclist_set = 1
+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:

vim/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:

vim/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:

vim/plugin/syntastic/registry.vim

@@ -0,0 +1,333 @@
+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'],
+        \ 'apiblueprint':  ['snowcrash'],
+        \ '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'],
+        \ 'dustjs':        ['swiffer'],
+        \ 'elixir':        [],
+        \ 'erlang':        ['escript'],
+        \ 'eruby':         ['ruby'],
+        \ 'fortran':       ['gfortran'],
+        \ 'glsl':          ['cgc'],
+        \ 'go':            ['go'],
+        \ 'haml':          ['haml'],
+        \ 'handlebars':    ['handlebars'],
+        \ 'haskell':       ['ghc_mod', 'hdevtools', 'hlint'],
+        \ 'haxe':          ['haxe'],
+        \ 'hss':           ['hss'],
+        \ 'html':          ['tidy'],
+        \ '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'],
+        \ 'nroff':         ['mandoc'],
+        \ 'objc':          ['gcc'],
+        \ 'objcpp':        ['gcc'],
+        \ 'ocaml':         ['camlp4o'],
+        \ 'perl':          ['perlcritic'],
+        \ 'php':           ['php', 'phpcs', 'phpmd'],
+        \ 'po':            ['msgfmt'],
+        \ 'pod':           ['podchecker'],
+        \ 'puppet':        ['puppet', 'puppetlint'],
+        \ 'python':        ['python', 'flake8', 'pylint'],
+        \ 'r':             [],
+        \ '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'],
+        \ 'tcl':           ['nagelfar'],
+        \ 'tex':           ['lacheck', 'chktex'],
+        \ 'texinfo':       ['makeinfo'],
+        \ 'text':          [],
+        \ 'twig':          ['twiglint'],
+        \ 'typescript':    ['tsc'],
+        \ 'vala':          ['valac'],
+        \ 'verilog':       ['verilator'],
+        \ 'vhdl':          ['ghdl'],
+        \ 'vim':           ['vimlint'],
+        \ 'xhtml':         ['tidy'],
+        \ 'xml':           ['xmllint'],
+        \ 'xslt':          ['xmllint'],
+        \ 'yacc':          ['bison'],
+        \ 'yaml':          ['jsyaml'],
+        \ '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 checker = g:SyntasticChecker.New(a:args)
+    let registry = g:SyntasticRegistry.Instance()
+    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)
+
+    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 checkers available.  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
+
+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)
+    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 = []
+
+        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()' ))
+        endfor
+    else
+        let ft = ft_list[0]
+        let available = self.getNamesOfAvailableCheckers(ft)
+        let active = map(self.getCheckersAvailable(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
+
+    " 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) abort " {{{2
+    if 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:

vim/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)
+
+    if !s:setup_done
+        call self._setup()
+        let s:setup_done = 1
+        lockvar s:setup_done
+    endif
+
+    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()
+        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:

vim/syntax_checkers/actionscript/mxmlc.vim

@@ -0,0 +1,67 @@
+"============================================================================
+"File:        mxmlc.vim
+"Description: ActionScript syntax checker - using mxmlc
+"Maintainer:  Andy Earnshaw <andyearnshaw@gmail.com>
+"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_actionscript_mxmlc_checker')
+    finish
+endif
+let g:loaded_syntastic_actionscript_mxmlc_checker = 1
+
+let s:save_cpo = &cpo
+set cpo&vim
+
+function! SyntaxCheckers_actionscript_mxmlc_GetHighlightRegex(item)
+    let term = ''
+
+    if match(a:item['text'], '\mvariable ''') > -1
+        let term = matchstr(a:item['text'], '\m''\zs[^'']\+\ze''')
+
+    elseif match(a:item['text'], 'expected a definition keyword') > -1
+        let term = matchstr(a:item['text'], '\mnot \zs[^.]\+\ze\.')
+
+    elseif match(a:item['text'], '\mundefined \%(property\|method\)') > -1
+        let term = matchstr(a:item['text'], '\mundefined \%(property\|method\) \zs[^. ]\+\ze')
+
+    elseif match(a:item['text'], 'could not be found') > -1
+        let term = matchstr(a:item['text'], '\m \zs\S\+\ze could not be found')
+
+    elseif match(a:item['text'], 'Type was not found') > -1
+        let term = matchstr(a:item['text'], '\m: \zs[^.]\+\zs\.')
+
+    endif
+
+    return term !=# '' ? '\V\<' . escape(term, '\') . '\>' : ''
+endfunction
+
+function! SyntaxCheckers_actionscript_mxmlc_GetLocList() dict
+    call syntastic#log#deprecationWarn('actionscript_mxmlc_conf', 'actionscript_mxmlc_args',
+        \ "'-load-config+=' . syntastic#util#shexpand(OLD_VAR)")
+
+    let makeprg = self.makeprgBuild({ 'args_after': '-output=' . syntastic#util#DevNull() })
+
+    let errorformat =
+        \ '%f(%l): col: %c %trror: %m,' .
+        \ '%f(%l): col: %c %tarning: %m,' .
+        \ '%f: %trror: %m,' .
+        \ '%-G%.%#'
+
+    return SyntasticMake({
+        \ 'makeprg': makeprg,
+        \ 'errorformat': errorformat })
+endfunction
+
+call g:SyntasticRegistry.CreateAndRegisterChecker({
+    \ 'filetype': 'actionscript',
+    \ 'name': 'mxmlc'})
+
+let &cpo = s:save_cpo
+unlet s:save_cpo
+
+" vim: set sw=4 sts=4 et fdm=marker:

vim/syntax_checkers/ada/gcc.vim

@@ -0,0 +1,47 @@
+"============================================================================
+"File:        ada.vim
+"Description: Syntax checking plugin for syntastic.vim
+"Maintainer:  Alfredo Di Napoli <alfredo.dinapoli@gmail.com>
+"License:     This program is free software. It comes without any warranty,
+"             to the extent permitted by applicable law.
+"
+"============================================================================
+
+if exists('g:loaded_syntastic_ada_gcc_checker')
+    finish
+endif
+let g:loaded_syntastic_ada_gcc_checker = 1
+
+if !exists('g:syntastic_ada_compiler_options')
+    let g:syntastic_ada_compiler_options = ''
+endif
+
+let s:save_cpo = &cpo
+set cpo&vim
+
+function! SyntaxCheckers_ada_gcc_IsAvailable() dict
+    if !exists('g:syntastic_ada_compiler')
+        let g:syntastic_ada_compiler = self.getExec()
+    endif
+    return executable(expand(g:syntastic_ada_compiler, 1))
+endfunction
+
+function! SyntaxCheckers_ada_gcc_GetLocList() dict
+    return syntastic#c#GetLocList('ada', 'gcc', {
+        \ 'errorformat':
+        \     '%-G%f:%s:,' .
+        \     '%f:%l:%c: %m,' .
+        \     '%f:%l: %m',
+        \ 'main_flags': '-c -x ada -fsyntax-only',
+        \ 'header_flags': '-x ada',
+        \ 'header_names': '\.ads$' })
+endfunction
+
+call g:SyntasticRegistry.CreateAndRegisterChecker({
+    \ 'filetype': 'ada',
+    \ 'name': 'gcc' })
+
+let &cpo = s:save_cpo
+unlet s:save_cpo
+
+" vim: set sw=4 sts=4 et fdm=marker:

vim/syntax_checkers/apiblueprint/snowcrash.vim

@@ -0,0 +1,66 @@
+"============================================================================
+"File:        snowcrash.vim
+"Description: Syntax checking plugin for syntastic.vim
+"Maintainer:  LCD 47 <lcd047 at gmail dot com>
+"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_apiblueprint_snowcrash_checker')
+    finish
+endif
+let g:loaded_syntastic_apiblueprint_snowcrash_checker = 1
+
+if !exists('g:syntastic_apiblueprint_snowcrash_sort')
+    let g:syntastic_apiblueprint_snowcrash_sort = 1
+endif
+
+let s:save_cpo = &cpo
+set cpo&vim
+
+function! SyntaxCheckers_apiblueprint_snowcrash_GetLocList() dict
+    let makeprg = self.makeprgBuild({ 'post_args': '-u -l' })
+
+    let errorformat =
+        \ '%trror: (%n)  %m,' .
+        \ '%tarning: (%n)  %m,' .
+        \ '%-G%.%#'
+
+    let loclist = SyntasticMake({
+        \ 'makeprg': makeprg,
+        \ 'errorformat': errorformat,
+        \ 'defaults': {'bufnr': bufnr('')},
+        \ 'returns': [0, 2] })
+
+    for e in loclist
+        let matches = matchlist(e['text'], '\v^(.+); line (\d+), column (\d+) - line (\d+), column (\d+)$')
+        if len(matches) > 5
+            let e['lnum'] = str2nr(matches[2])
+            let e['col']  = str2nr(matches[3])
+            let e['vcol'] = 0
+
+            if matches[2] == matches[4]
+                let e['hl'] = '\%>' . (e['col'] - 1) . 'c\%<' . matches[5] . 'c'
+            endif
+
+            let e['text'] = matches[1]
+        else
+            let e['valid'] = 0
+        endif
+    endfor
+
+    return loclist
+endfunction
+
+call g:SyntasticRegistry.CreateAndRegisterChecker({
+    \ 'filetype': 'apiblueprint',
+    \ 'name': 'snowcrash'})
+
+let &cpo = s:save_cpo
+unlet s:save_cpo
+
+" vim: set sw=4 sts=4 et fdm=marker:

vim/syntax_checkers/applescript/osacompile.vim

@@ -0,0 +1,49 @@
+"==============================================================================
+"       FileName: applescript.vim
+"           Desc: Syntax checking plugin for syntastic.vim
+"         Author: Zhao Cai
+"          Email: caizhaoff@gmail.com
+"        Version: 0.2.1
+"   Date Created: Thu 09 Sep 2011 10:30:09 AM EST
+"  Last Modified: Fri 09 Dec 2011 01:10:24 PM EST
+"
+"        History: 0.1.0 - working, but it will run the script everytime to check
+"                 syntax. Should use osacompile but strangely it does not give
+"                 errors.
+"
+"                 0.2.0 - switch to osacompile, it gives less errors compared
+"                 with osascript.
+"
+"                 0.2.1 - remove g:syntastic_applescript_tempfile. use
+"                 tempname() instead.
+"
+"        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_applescript_osacompile_checker')
+    finish
+endif
+let g:loaded_syntastic_applescript_osacompile_checker = 1
+
+let s:save_cpo = &cpo
+set cpo&vim
+
+function! SyntaxCheckers_applescript_osacompile_GetLocList() dict
+    let makeprg = self.makeprgBuild({ 'args_after': '-o ' . tempname() . '.scpt' })
+    let errorformat = '%f:%l:%m'
+    return SyntasticMake({ 'makeprg': makeprg, 'errorformat': errorformat })
+endfunction
+
+call g:SyntasticRegistry.CreateAndRegisterChecker({
+    \ 'filetype': 'applescript',
+    \ 'name': 'osacompile' })
+
+let &cpo = s:save_cpo
+unlet s:save_cpo
+
+" vim: set sw=4 sts=4 et fdm=marker:

vim/syntax_checkers/asciidoc/asciidoc.vim

@@ -0,0 +1,47 @@
+"============================================================================
+"File:        asciidoc.vim
+"Description: Syntax checking plugin for syntastic.vim
+"Maintainer:  LCD 47 <lcd047 at gmail dot com>
+"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_asciidoc_asciidoc_checker')
+    finish
+endif
+let g:loaded_syntastic_asciidoc_asciidoc_checker = 1
+
+let s:save_cpo = &cpo
+set cpo&vim
+
+function! SyntaxCheckers_asciidoc_asciidoc_GetLocList() dict
+    let makeprg = self.makeprgBuild({ 'args_after': syntastic#c#NullOutput() })
+
+    let errorformat =
+        \ '%Easciidoc: %tRROR: %f: line %l: %m,' .
+        \ '%Easciidoc: %tRROR: %f: %m,' .
+        \ '%Easciidoc: FAILED: %f: line %l: %m,' .
+        \ '%Easciidoc: FAILED: %f: %m,' .
+        \ '%Wasciidoc: %tARNING: %f: line %l: %m,' .
+        \ '%Wasciidoc: %tARNING: %f: %m,' .
+        \ '%Wasciidoc: DEPRECATED: %f: line %l: %m,' .
+        \ '%Wasciidoc: DEPRECATED: %f: %m'
+
+    return SyntasticMake({
+        \ 'makeprg': makeprg,
+        \ 'errorformat': errorformat,
+        \ 'returns': [0, 1] })
+endfunction
+
+call g:SyntasticRegistry.CreateAndRegisterChecker({
+    \ 'filetype': 'asciidoc',
+    \ 'name': 'asciidoc'})
+
+let &cpo = s:save_cpo
+unlet s:save_cpo
+
+" vim: set sw=4 sts=4 et fdm=marker:

vim/syntax_checkers/asm/gcc.vim

@@ -0,0 +1,58 @@
+"============================================================================
+"File:        gcc.vim
+"Description: Syntax checking for at&t and intel assembly files with gcc
+"Maintainer:  Josh Rahm <joshuarahm@gmail.com>
+"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_asm_gcc_checker')
+    finish
+endif
+let g:loaded_syntastic_asm_gcc_checker = 1
+
+if !exists('g:syntastic_asm_compiler_options')
+    let g:syntastic_asm_compiler_options = ''
+endif
+
+let s:save_cpo = &cpo
+set cpo&vim
+
+function! SyntaxCheckers_asm_gcc_IsAvailable() dict " {{{1
+    if !exists('g:syntastic_asm_compiler')
+        let g:syntastic_asm_compiler = self.getExec()
+    endif
+    return executable(expand(g:syntastic_asm_compiler, 1))
+endfunction " }}}1
+
+function! SyntaxCheckers_asm_gcc_GetLocList() dict " {{{1
+    return syntastic#c#GetLocList('asm', 'gcc', {
+        \ 'errorformat':
+        \     '%-G%f:%s:,' .
+        \     '%f:%l:%c: %trror: %m,' .
+        \     '%f:%l:%c: %tarning: %m,' .
+        \     '%f:%l: %m',
+        \ 'main_flags': '-x assembler -fsyntax-only -masm=' . s:GetDialect() })
+endfunction " }}}1
+
+" Utilities {{{1
+
+function! s:GetDialect() " {{{2
+    return exists('g:syntastic_asm_dialect') ? g:syntastic_asm_dialect :
+        \ expand('%:e', 1) ==? 'asm' ? 'intel' : 'att'
+endfunction " }}}2
+
+" }}}1
+
+call g:SyntasticRegistry.CreateAndRegisterChecker({
+    \ 'filetype': 'asm',
+    \ 'name': 'gcc' })
+
+let &cpo = s:save_cpo
+unlet s:save_cpo
+
+" vim: set sw=4 sts=4 et fdm=marker:

vim/syntax_checkers/bemhtml/bemhtmllint.vim

@@ -0,0 +1,35 @@
+"============================================================================
+"File:        bemhtmllint.vim
+"Description: Syntax checking plugin for syntastic.vim
+"Maintainer:  Sergej Tatarincev <s.tatarincev at yandex.ua>
+"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_bemhtml_bemhtmllint_checker')
+    finish
+endif
+
+let g:loaded_syntastic_bemhtml_bemhtmllint_checker = 1
+
+let s:save_cpo = &cpo
+set cpo&vim
+
+function SyntaxCheckers_bemhtml_bemhtmllint_GetLocList() dict
+    let makeprg = self.makeprgBuild({})
+    let errorformat = '%f:%l:%c: %m'
+    return SyntasticMake({ 'makeprg': makeprg, 'errorformat': errorformat })
+endfunction
+
+call g:SyntasticRegistry.CreateAndRegisterChecker({
+    \ 'filetype': 'bemhtml',
+    \ 'name': 'bemhtmllint',
+    \ 'exec': 'bemhtml-lint' })
+
+let &cpo = s:save_cpo
+unlet s:save_cpo
+
+" vim: set sw=4 sts=4 et fdm=marker:

vim/syntax_checkers/bro/bro.vim

@@ -0,0 +1,60 @@
+"============================================================================
+"File:        bro.vim
+"Description: Syntax checking plugin for syntastic.vim
+"Maintainer:  Justin Azoff <justin.azoff@gmail.com>
+"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_bro_bro_checker')
+    finish
+endif
+let g:loaded_syntastic_bro_bro_checker = 1
+
+let s:save_cpo = &cpo
+set cpo&vim
+
+function! SyntaxCheckers_bro_bro_GetHighlightRegex(item)
+    let term = matchstr(a:item['text'], '\m at or near "\zs[^"]\+\ze"')
+    return term !=# '' ? '\V\<' . escape(term, '\') . '\>' : ''
+endfunction
+
+function! SyntaxCheckers_bro_bro_IsAvailable() dict
+    if !executable(self.getExec())
+        return 0
+    endif
+
+    if syntastic#util#system(self.getExecEscaped() . ' --help') !~# '--parse-only'
+        call self.log('unknown option "--parse-only"')
+        return 0
+    endif
+
+    return 1
+endfunction
+
+function! SyntaxCheckers_bro_bro_GetLocList() dict
+    let makeprg = self.makeprgBuild({ 'args_before': '--parse-only' })
+
+    "example: error in ./foo.bro, line 3: unknown identifier banana, at or near "banana"
+    let errorformat =
+        \ 'fatal %trror in %f\, line %l: %m,' .
+        \ '%trror in %f\, line %l: %m,' .
+        \ '%tarning in %f\, line %l: %m'
+
+    return SyntasticMake({
+        \ 'makeprg': makeprg,
+        \ 'errorformat': errorformat })
+endfunction
+
+call g:SyntasticRegistry.CreateAndRegisterChecker({
+    \ 'filetype': 'bro',
+    \ 'name': 'bro'})
+
+let &cpo = s:save_cpo
+unlet s:save_cpo
+
+" vim: set sw=4 sts=4 et fdm=marker:

vim/syntax_checkers/c/avrgcc.vim

@@ -0,0 +1,57 @@
+"============================================================================
+"File:        avrgcc.vim
+"Description: Syntax checking plugin for syntastic.vim
+"Maintainer:  Karel <karelishere at gmail dot com>
+"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_c_avrgcc_checker')
+    finish
+endif
+let g:loaded_syntastic_c_avrgcc_checker = 1
+
+if !exists('g:syntastic_avrgcc_config_file')
+    let g:syntastic_avrgcc_config_file = '.syntastic_avrgcc_config'
+endif
+
+let s:save_cpo = &cpo
+set cpo&vim
+
+function! SyntaxCheckers_c_avrgcc_GetLocList() dict
+    let makeprg = self.makeprgBuild({
+        \ 'args_before': syntastic#c#ReadConfig(g:syntastic_avrgcc_config_file),
+        \ 'args_after': '-x c -fsyntax-only' })
+
+    let errorformat =
+        \ '%-G%f:%s:,' .
+        \ '%-G%f:%l: %#error: %#(Each undeclared identifier is reported only%.%#,' .
+        \ '%-G%f:%l: %#error: %#for each function it appears%.%#,' .
+        \ '%-GIn file included%.%#,' .
+        \ '%-G %#from %f:%l\,,' .
+        \ '%f:%l:%c: %trror: %m,' .
+        \ '%f:%l:%c: %tarning: %m,' .
+        \ '%f:%l:%c: %m,' .
+        \ '%f:%l: %trror: %m,' .
+        \ '%f:%l: %tarning: %m,'.
+        \ '%f:%l: %m'
+
+    return SyntasticMake({
+        \ 'makeprg': makeprg,
+        \ 'errorformat': errorformat,
+        \ 'postprocess': ['compressWhitespace'] })
+endfunction
+
+call g:SyntasticRegistry.CreateAndRegisterChecker({
+    \ 'filetype': 'c',
+    \ 'name': 'avrgcc',
+    \ 'exec': 'avr-gcc'})
+
+let &cpo = s:save_cpo
+unlet s:save_cpo
+
+" vim: set sw=4 sts=4 et fdm=marker:

vim/syntax_checkers/c/checkpatch.vim

@@ -0,0 +1,60 @@
+"============================================================================
+"File:        checkpatch.vim
+"Description: Syntax checking plugin for syntastic.vim using checkpatch.pl
+"Maintainer:  Daniel Walker <dwalker at fifo99 dot com>
+"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_c_checkpatch_checker')
+    finish
+endif
+let g:loaded_syntastic_c_checkpatch_checker = 1
+
+let s:save_cpo = &cpo
+set cpo&vim
+
+function! SyntaxCheckers_c_checkpatch_IsAvailable() dict
+    call syntastic#log#deprecationWarn('c_checker_checkpatch_location', 'c_checkpatch_exec')
+
+    if !exists('g:syntastic_c_checkpatch_exec') && !executable(self.getExec())
+        if executable('checkpatch')
+            let g:syntastic_c_checkpatch_exec = 'checkpatch'
+        elseif executable('./scripts/checkpatch.pl')
+            let g:syntastic_c_checkpatch_exec = fnamemodify('./scripts/checkpatch.pl', ':p')
+        elseif executable('./scripts/checkpatch')
+            let g:syntastic_c_checkpatch_exec = fnamemodify('./scripts/checkpatch', ':p')
+        endif
+    endif
+
+    call self.log('exec =', self.getExec())
+
+    return executable(self.getExec())
+endfunction
+
+function! SyntaxCheckers_c_checkpatch_GetLocList() dict
+    let makeprg = self.makeprgBuild({ 'args_after': '--no-summary --no-tree --terse --file' })
+
+    let errorformat =
+        \ '%f:%l: %tARNING: %m,' .
+        \ '%f:%l: %tRROR: %m'
+
+    return SyntasticMake({
+        \ 'makeprg': makeprg,
+        \ 'errorformat': errorformat,
+        \ 'returns': [0, 1],
+        \ 'subtype': 'Style' })
+endfunction
+
+call g:SyntasticRegistry.CreateAndRegisterChecker({
+    \ 'filetype': 'c',
+    \ 'name': 'checkpatch',
+    \ 'exec': 'checkpatch.pl'})
+
+let &cpo = s:save_cpo
+unlet s:save_cpo
+
+" vim: set sw=4 sts=4 et fdm=marker:

vim/syntax_checkers/c/clang_check.vim

@@ -0,0 +1,61 @@
+"============================================================================
+"File:        clang_check.vim
+"Description: Syntax checking plugin for syntastic.vim
+"Maintainer:  Benjamin Bannier <bbannier at gmail dot com>
+"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_c_clang_check_checker')
+  finish
+endif
+let g:loaded_syntastic_c_clang_check_checker = 1
+
+if !exists('g:syntastic_clang_check_config_file')
+    let g:syntastic_clang_check_config_file = '.syntastic_clang_check_config'
+endif
+
+if !exists('g:syntastic_c_clang_check_sort')
+    let g:syntastic_c_clang_check_sort = 1
+endif
+
+let s:save_cpo = &cpo
+set cpo&vim
+
+function! SyntaxCheckers_c_clang_check_GetLocList() dict
+    let makeprg = self.makeprgBuild({
+        \ 'post_args':
+        \   '-- ' .
+        \   syntastic#c#ReadConfig(g:syntastic_clang_check_config_file) . ' ' .
+        \   '-fshow-column ' .
+        \   '-fshow-source-location ' .
+        \   '-fno-caret-diagnostics ' .
+        \   '-fno-color-diagnostics ' .
+        \   '-fdiagnostics-format=clang' })
+
+    let errorformat =
+        \ '%E%f:%l:%c: fatal error: %m,' .
+        \ '%E%f:%l:%c: error: %m,' .
+        \ '%W%f:%l:%c: warning: %m,' .
+        \ '%-G%\m%\%%(LLVM ERROR:%\|No compilation database found%\)%\@!%.%#,' .
+        \ '%E%m'
+
+    return SyntasticMake({
+        \ 'makeprg': makeprg,
+        \ 'errorformat': errorformat,
+        \ 'defaults': {'bufnr': bufnr('')},
+        \ 'returns': [0, 1] })
+endfunction
+
+call g:SyntasticRegistry.CreateAndRegisterChecker({
+    \ 'filetype': 'c',
+    \ 'name': 'clang_check',
+    \ 'exec': 'clang-check'})
+
+let &cpo = s:save_cpo
+unlet s:save_cpo
+
+" vim: set sw=4 sts=4 et fdm=marker:

vim/syntax_checkers/c/clang_tidy.vim

@@ -0,0 +1,61 @@
+"============================================================================
+"File:        clang_tidy.vim
+"Description: Syntax checking plugin for syntastic.vim
+"Maintainer:  Benjamin Bannier <bbannier at gmail dot com>
+"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_c_clang_tidy_checker')
+  finish
+endif
+let g:loaded_syntastic_c_clang_tidy_checker = 1
+
+if !exists('g:syntastic_clang_tidy_config_file')
+    let g:syntastic_clang_tidy_config_file = '.syntastic_clang_tidy_config'
+endif
+
+if !exists('g:syntastic_c_clang_tidy_sort')
+    let g:syntastic_c_clang_tidy_sort = 1
+endif
+
+let s:save_cpo = &cpo
+set cpo&vim
+
+function! SyntaxCheckers_c_clang_tidy_GetLocList() dict
+    let makeprg = self.makeprgBuild({
+        \ 'post_args':
+        \   '-- ' .
+        \   syntastic#c#ReadConfig(g:syntastic_clang_tidy_config_file) . ' ' .
+        \   '-fshow-column ' .
+        \   '-fshow-source-location ' .
+        \   '-fno-caret-diagnostics ' .
+        \   '-fno-color-diagnostics ' .
+        \   '-fdiagnostics-format=clang' })
+
+    let errorformat =
+        \ '%E%f:%l:%c: fatal error: %m,' .
+        \ '%E%f:%l:%c: error: %m,' .
+        \ '%W%f:%l:%c: warning: %m,' .
+        \ '%-G%\m%\%%(LLVM ERROR:%\|No compilation database found%\)%\@!%.%#,' .
+        \ '%E%m'
+
+    return SyntasticMake({
+        \ 'makeprg': makeprg,
+        \ 'errorformat': errorformat,
+        \ 'defaults': {'bufnr': bufnr('')},
+        \ 'returns': [0, 1] })
+endfunction
+
+call g:SyntasticRegistry.CreateAndRegisterChecker({
+    \ 'filetype': 'c',
+    \ 'name': 'clang_tidy',
+    \ 'exec': 'clang-tidy'})
+
+let &cpo = s:save_cpo
+unlet s:save_cpo
+
+" vim: set sw=4 sts=4 et fdm=marker:

vim/syntax_checkers/c/cppcheck.vim

@@ -0,0 +1,62 @@
+"============================================================================
+"File:        cppcheck.vim
+"Description: Syntax checking plugin for syntastic.vim using cppcheck.pl
+"Maintainer:  LCD 47 <lcd047 at gmail dot com>
+"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_c_cppcheck_checker')
+    finish
+endif
+let g:loaded_syntastic_c_cppcheck_checker = 1
+
+if !exists('g:syntastic_cppcheck_config_file')
+    let g:syntastic_cppcheck_config_file = '.syntastic_cppcheck_config'
+endif
+
+let s:save_cpo = &cpo
+set cpo&vim
+
+function! SyntaxCheckers_c_cppcheck_GetLocList() dict
+    let makeprg = self.makeprgBuild({
+        \ 'args': syntastic#c#ReadConfig(g:syntastic_cppcheck_config_file),
+        \ 'args_after': '-q --enable=style' })
+
+    let errorformat =
+        \ '[%f:%l]: (%trror) %m,' .
+        \ '[%f:%l]: (%tarning) %m,' .
+        \ '[%f:%l]: (%ttyle) %m,' .
+        \ '[%f:%l]: (%terformance) %m,' .
+        \ '[%f:%l]: (%tortability) %m,' .
+        \ '[%f:%l]: (%tnformation) %m,' .
+        \ '[%f:%l]: (%tnconclusive) %m,' .
+        \ '%-G%.%#'
+
+    let loclist = SyntasticMake({
+        \ 'makeprg': makeprg,
+        \ 'errorformat': errorformat,
+        \ 'preprocess': 'cppcheck',
+        \ 'returns': [0] })
+
+    for e in loclist
+        if e['type'] =~? '\m^[SPI]'
+            let e['type'] = 'w'
+            let e['subtype'] = 'Style'
+        endif
+    endfor
+
+    return loclist
+endfunction
+
+call g:SyntasticRegistry.CreateAndRegisterChecker({
+    \ 'filetype': 'c',
+    \ 'name': 'cppcheck'})
+
+let &cpo = s:save_cpo
+unlet s:save_cpo
+
+" vim: set sw=4 sts=4 et fdm=marker:

vim/syntax_checkers/c/gcc.vim

@@ -0,0 +1,59 @@
+"============================================================================
+"File:        c.vim
+"Description: Syntax checking plugin for syntastic.vim
+"Maintainer:  Gregor Uhlenheuer <kongo2002 at gmail dot com>
+"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_c_gcc_checker')
+    finish
+endif
+let g:loaded_syntastic_c_gcc_checker = 1
+
+if !exists('g:syntastic_c_compiler_options')
+    let g:syntastic_c_compiler_options = '-std=gnu99'
+endif
+
+let s:save_cpo = &cpo
+set cpo&vim
+
+function! SyntaxCheckers_c_gcc_IsAvailable() dict
+    if !exists('g:syntastic_c_compiler')
+        let g:syntastic_c_compiler = executable(self.getExec()) ? self.getExec() : 'clang'
+    endif
+    call self.log('g:syntastic_c_compiler =', g:syntastic_c_compiler)
+    return executable(expand(g:syntastic_c_compiler, 1))
+endfunction
+
+function! SyntaxCheckers_c_gcc_GetLocList() dict
+    return syntastic#c#GetLocList('c', 'gcc', {
+        \ 'errorformat':
+        \     '%-G%f:%s:,' .
+        \     '%-G%f:%l: %#error: %#(Each undeclared identifier is reported only%.%#,' .
+        \     '%-G%f:%l: %#error: %#for each function it appears%.%#,' .
+        \     '%-GIn file included%.%#,' .
+        \     '%-G %#from %f:%l\,,' .
+        \     '%f:%l:%c: %trror: %m,' .
+        \     '%f:%l:%c: %tarning: %m,' .
+        \     '%f:%l:%c: %m,' .
+        \     '%f:%l: %trror: %m,' .
+        \     '%f:%l: %tarning: %m,'.
+        \     '%f:%l: %m',
+        \ 'main_flags': '-x c -fsyntax-only',
+        \ 'header_flags': '-x c',
+        \ 'header_names': '\m\.h$' })
+endfunction
+
+call g:SyntasticRegistry.CreateAndRegisterChecker({
+    \ 'filetype': 'c',
+    \ 'name': 'gcc' })
+
+let &cpo = s:save_cpo
+unlet s:save_cpo
+
+" vim: set sw=4 sts=4 et fdm=marker:

vim/syntax_checkers/c/make.vim

@@ -0,0 +1,61 @@
+"============================================================================
+"File:        make.vim
+"Description: Syntax checking plugin for syntastic.vim
+"Maintainer:  Gregor Uhlenheuer <kongo2002 at gmail dot com>
+"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_c_make_checker')
+    finish
+endif
+let g:loaded_syntastic_c_make_checker = 1
+
+let s:save_cpo = &cpo
+set cpo&vim
+
+function! SyntaxCheckers_c_make_GetLocList() dict
+    let makeprg = self.makeprgBuild({ 'args': '-sk', 'fname': '' })
+
+    let errorformat =
+        \ '%-G%f:%s:,' .
+        \ '%-G%f:%l: %#error: %#(Each undeclared identifier is reported only%.%#,' .
+        \ '%-G%f:%l: %#error: %#for each function it appears%.%#,' .
+        \ '%-GIn file included%.%#,' .
+        \ '%-G %#from %f:%l\,,' .
+        \ '%f:%l:%c: %trror: %m,' .
+        \ '%f:%l:%c: %tarning: %m,' .
+        \ '%f:%l:%c: %m,' .
+        \ '%f:%l: %trror: %m,' .
+        \ '%f:%l: %tarning: %m,'.
+        \ '%f:%l: %m'
+
+    if exists('g:syntastic_c_errorformat')
+        let errorformat = g:syntastic_c_errorformat
+    endif
+
+    " process makeprg
+    let errors = SyntasticMake({
+        \ 'makeprg': makeprg,
+        \ 'errorformat': errorformat })
+
+    " filter the processed errors if desired
+    if exists('g:syntastic_c_remove_include_errors') && g:syntastic_c_remove_include_errors != 0
+        return filter(errors, 'has_key(v:val, "bufnr") && v:val["bufnr"] == ' . bufnr(''))
+    else
+        return errors
+    endif
+endfunction
+
+call g:SyntasticRegistry.CreateAndRegisterChecker({
+    \ 'filetype': 'c',
+    \ 'name': 'make'})
+
+let &cpo = s:save_cpo
+unlet s:save_cpo
+
+" vim: set sw=4 sts=4 et fdm=marker:

vim/syntax_checkers/c/oclint.vim

@@ -0,0 +1,65 @@
+"============================================================================
+"File:        oclint.vim
+"Description: Syntax checking plugin for syntastic.vim
+"Maintainer:  "UnCO" Lin <undercooled aT lavabit com>
+"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_c_oclint_checker')
+    finish
+endif
+let g:loaded_syntastic_c_oclint_checker = 1
+
+if !exists('g:syntastic_oclint_config_file')
+    let g:syntastic_oclint_config_file = '.syntastic_oclint_config'
+endif
+
+if !exists('g:syntastic_c_oclint_sort')
+    let g:syntastic_c_oclint_sort = 1
+endif
+
+let s:save_cpo = &cpo
+set cpo&vim
+
+function! SyntaxCheckers_c_oclint_GetLocList() dict
+    let makeprg = self.makeprgBuild({
+        \ 'post_args': '-- -c ' . syntastic#c#ReadConfig(g:syntastic_oclint_config_file) })
+
+    let errorformat =
+        \ '%E%f:%l:%c: fatal error: %m,' .
+        \ '%E%f:%l:%c: error: %m,' .
+        \ '%W%f:%l:%c: warning: %m,' .
+        \ '%E%f:%l:%c: %m,' .
+        \ '%-G%.%#'
+
+    let loclist = SyntasticMake({
+        \ 'makeprg': makeprg,
+        \ 'errorformat': errorformat,
+        \ 'subtype': 'Style',
+        \ 'postprocess': ['compressWhitespace'],
+        \ 'returns': [0, 3, 5] })
+
+    for e in loclist
+        if e['text'] =~# '\v P3( |$)'
+            let e['type'] = 'W'
+        endif
+
+        let e['text'] = substitute(e['text'], '\m\C P[1-3]$', '', '')
+        let e['text'] = substitute(e['text'], '\m\C P[1-3] ', ': ', '')
+    endfor
+
+    return loclist
+endfunction
+
+call g:SyntasticRegistry.CreateAndRegisterChecker({
+    \ 'filetype': 'c',
+    \ 'name': 'oclint'})
+
+let &cpo = s:save_cpo
+unlet s:save_cpo
+
+" vim: set sw=4 sts=4 et fdm=marker:

vim/syntax_checkers/c/pc_lint.vim

@@ -0,0 +1,66 @@
+"============================================================================
+"File:        pc_lint.vim
+"Description: Syntax checking plugin for syntastic.vim
+"Maintainer:  Steve Bragg <steve at empresseffects dot com>
+"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_c_pc_lint_checker')
+    finish
+endif
+let g:loaded_syntastic_c_pc_lint_checker = 1
+
+let s:save_cpo = &cpo
+set cpo&vim
+
+if !exists('g:syntastic_pc_lint_config_file')
+    let g:syntastic_pc_lint_config_file = 'options.lnt'
+endif
+
+function! SyntaxCheckers_c_pc_lint_GetLocList() dict
+    let config = findfile(g:syntastic_pc_lint_config_file, '.;')
+    call self.log('config =', config)
+
+    " -hFs1         - show filename, add space after messages, try to make message 1 line
+    " -width(0,0)   - make sure there are no line breaks
+    " -t            - set tab size
+    " -v            - turn off verbosity
+    let makeprg = self.makeprgBuild({
+        \ 'args': (filereadable(config) ? syntastic#util#shescape(fnamemodify(config, ':p')) : ''),
+        \ 'args_after': ['-hFs1', '-width(0,0)', '-t' . &tabstop, '-format=%f:%l:%C:%t:%n:%m'] })
+
+    let errorformat =
+        \ '%E%f:%l:%v:Error:%n:%m,' .
+        \ '%W%f:%l:%v:Warning:%n:%m,' .
+        \ '%I%f:%l:%v:Info:%n:%m,' .
+        \ '%-G%.%#'
+
+    let loclist = SyntasticMake({
+        \ 'makeprg': makeprg,
+        \ 'errorformat': errorformat,
+        \ 'postprocess': ['cygwinRemoveCR'] })
+
+    for e in loclist
+        if e['type'] ==? 'I'
+            let e['type'] = 'W'
+            let e['subtype'] = 'Style'
+        endif
+    endfor
+
+    return loclist
+endfunction
+
+call g:SyntasticRegistry.CreateAndRegisterChecker({
+    \ 'filetype': 'c',
+    \ 'name': 'pc_lint',
+    \ 'exec': 'lint-nt'})
+
+let &cpo = s:save_cpo
+unlet s:save_cpo
+
+" vim: set sw=4 sts=4 et fdm=marker:

vim/syntax_checkers/c/sparse.vim

@@ -0,0 +1,48 @@
+"============================================================================
+"File:        sparse.vim
+"Description: Syntax checking plugin for syntastic.vim using sparse.pl
+"Maintainer:  Daniel Walker <dwalker at fifo99 dot com>
+"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_c_sparse_checker')
+    finish
+endif
+let g:loaded_syntastic_c_sparse_checker = 1
+
+if !exists('g:syntastic_sparse_config_file')
+    let g:syntastic_sparse_config_file = '.syntastic_sparse_config'
+endif
+
+let s:save_cpo = &cpo
+set cpo&vim
+
+function! SyntaxCheckers_c_sparse_GetLocList() dict
+    let makeprg = self.makeprgBuild({
+        \ 'args': syntastic#c#ReadConfig(g:syntastic_sparse_config_file),
+        \ 'args_after': '-ftabstop=' . &ts })
+
+    let errorformat =
+        \ '%f:%l:%v: %trror: %m,' .
+        \ '%f:%l:%v: %tarning: %m,'
+
+    let loclist = SyntasticMake({
+        \ 'makeprg': makeprg,
+        \ 'errorformat': errorformat,
+        \ 'defaults': {'bufnr': bufnr('')},
+        \ 'returns': [0, 1] })
+    return loclist
+endfunction
+
+call g:SyntasticRegistry.CreateAndRegisterChecker({
+    \ 'filetype': 'c',
+    \ 'name': 'sparse'})
+
+let &cpo = s:save_cpo
+unlet s:save_cpo
+
+" vim: set sw=4 sts=4 et fdm=marker:

vim/syntax_checkers/c/splint.vim

@@ -0,0 +1,55 @@
+"============================================================================
+"File:        splint.vim
+"Description: Syntax checking plugin for syntastic.vim
+"Maintainer:  LCD 47 <lcd047 at gmail dot com>
+"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_c_splint_checker')
+    finish
+endif
+let g:loaded_syntastic_c_splint_checker = 1
+
+if !exists('g:syntastic_splint_config_file')
+    let g:syntastic_splint_config_file = '.syntastic_splint_config'
+endif
+
+let s:save_cpo = &cpo
+set cpo&vim
+
+function! SyntaxCheckers_c_splint_GetLocList() dict
+    let makeprg = self.makeprgBuild({
+        \ 'args': syntastic#c#ReadConfig(g:syntastic_splint_config_file),
+        \ 'args_after': '-showfunc -hints +quiet' })
+
+    let errorformat =
+        \ '%-G%f:%l:%v: %[%#]%[%#]%[%#] Internal Bug %.%#,' .
+        \ '%-G%f(%l\,%v): %[%#]%[%#]%[%#] Internal Bug %.%#,' .
+        \ '%W%f:%l:%v: %m,' .
+        \ '%W%f(%l\,%v): %m,' .
+        \ '%W%f:%l: %m,' .
+        \ '%W%f(%l): %m,' .
+        \ '%-C %\+In file included from %.%#,' .
+        \ '%-C %\+from %.%#,' .
+        \ '%+C %.%#'
+
+    return SyntasticMake({
+        \ 'makeprg': makeprg,
+        \ 'errorformat': errorformat,
+        \ 'subtype': 'Style',
+        \ 'postprocess': ['compressWhitespace'],
+        \ 'defaults': {'type': 'W'} })
+endfunction
+
+call g:SyntasticRegistry.CreateAndRegisterChecker({
+    \ 'filetype': 'c',
+    \ 'name': 'splint'})
+
+let &cpo = s:save_cpo
+unlet s:save_cpo
+
+" vim: set sw=4 sts=4 et fdm=marker:

vim/syntax_checkers/cabal/cabal.vim

@@ -0,0 +1,55 @@
+"============================================================================
+"File:        cabal.vim
+"Description: Haskell package description (.cabal file) linting and syntax
+"             validation via 'cabal check'
+"Maintainer: Ian D. Bollinger <ian.bollinger@gmail.com>
+"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_cabal_cabal_checker')
+    finish
+endif
+let g:loaded_syntastic_cabal_cabal_checker = 1
+
+let s:save_cpo = &cpo
+set cpo&vim
+
+function! SyntaxCheckers_cabal_cabal_GetHighlightRegex(item)
+    let field = matchstr(a:item['text'], "\\vParse of field '\\zs[^']+")
+    if field !=# ''
+        return '\v\c^\s*' . field . '\s*:\s*\zs.*$'
+    endif
+    let field = matchstr(a:item['text'], "\\v(^|\\s)'\\zs[^']+\\ze'")
+    if field !=# ''
+        return '\V\c\<' . escape(field, '\') . '\>'
+    endif
+    return ''
+endfunction
+
+function! SyntaxCheckers_cabal_cabal_GetLocList() dict
+    let makeprg = self.getExecEscaped() . ' check'
+
+    let errorformat =
+        \ '%Ecabal: %f:%l: %m,' .
+        \ '%W* %m'
+
+    return SyntasticMake({
+        \ 'makeprg': makeprg,
+        \ 'errorformat': errorformat,
+        \ 'cwd': expand('%:p:h', 1),
+        \ 'preprocess': 'cabal',
+        \ 'defaults': {'bufnr': bufnr('')} })
+endfunction
+
+call g:SyntasticRegistry.CreateAndRegisterChecker({
+    \ 'filetype': 'cabal',
+    \ 'name': 'cabal'})
+
+let &cpo = s:save_cpo
+unlet s:save_cpo
+
+" vim: set sw=4 sts=4 et fdm=marker:

vim/syntax_checkers/chef/foodcritic.vim

@@ -0,0 +1,39 @@
+"============================================================================
+"File:        foodcritic.vim
+"Description: Syntax checking plugin for syntastic.vim
+"Maintainer:  Doug Ireton <dougireton@gmail.com>
+"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_chef_foodcritic_checker')
+    finish
+endif
+let g:loaded_syntastic_chef_foodcritic_checker = 1
+
+let s:save_cpo = &cpo
+set cpo&vim
+
+function! SyntaxCheckers_chef_foodcritic_GetLocList() dict
+    let makeprg = self.makeprgBuild({})
+
+    " FC023: Prefer conditional attributes: ./recipes/config.rb:49
+    let errorformat = 'FC%n: %m: %f:%l'
+
+    return SyntasticMake({
+        \ 'makeprg': makeprg,
+        \ 'errorformat': errorformat })
+endfunction
+
+call g:SyntasticRegistry.CreateAndRegisterChecker({
+      \ 'filetype': 'chef',
+      \ 'name': 'foodcritic'})
+
+let &cpo = s:save_cpo
+unlet s:save_cpo
+
+" vim: set sw=4 sts=4 et fdm=marker:

vim/syntax_checkers/co/coco.vim

@@ -0,0 +1,47 @@
+"============================================================================
+"File:        co.vim
+"Description: Syntax checking plugin for syntastic.vim
+"Maintainer:  Andrew Kelley <superjoe30@gmail.com>
+"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_co_coco_checker')
+    finish
+endif
+let g:loaded_syntastic_co_coco_checker = 1
+
+let s:save_cpo = &cpo
+set cpo&vim
+
+function! SyntaxCheckers_co_coco_GetLocList() dict
+    let tmpdir = syntastic#util#tmpdir()
+    let makeprg = self.makeprgBuild({ 'args_after': '-c -o ' . tmpdir })
+
+    let errorformat =
+        \ '%EFailed at: %f,' .
+        \ '%ZSyntax%trror: %m on line %l,'.
+        \ '%EFailed at: %f,'.
+        \ '%Z%trror: Parse error on line %l: %m'
+
+    let loclist = SyntasticMake({
+        \ 'makeprg': makeprg,
+        \ 'errorformat': errorformat })
+
+    call syntastic#util#rmrf(tmpdir)
+
+    return loclist
+endfunction
+
+call g:SyntasticRegistry.CreateAndRegisterChecker({
+    \ 'filetype': 'co',
+    \ 'name': 'coco'})
+
+let &cpo = s:save_cpo
+unlet s:save_cpo
+
+" vim: set sw=4 sts=4 et fdm=marker:

vim/syntax_checkers/cobol/cobc.vim

@@ -0,0 +1,47 @@
+"============================================================================
+"File:        cobc.vim
+"Description: Syntax checking plugin for syntastic.vim
+"Maintainer:  LCD 47 <lcd047 at gmail dot com>
+"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_cobol_cobc_checker')
+    finish
+endif
+let g:loaded_syntastic_cobol_cobc_checker = 1
+
+if !exists('g:syntastic_cobol_compiler_options')
+    let g:syntastic_cobol_compiler_options = ''
+endif
+
+let s:save_cpo = &cpo
+set cpo&vim
+
+function! SyntaxCheckers_cobol_cobc_IsAvailable() dict
+    if !exists('g:syntastic_cobol_compiler')
+        let g:syntastic_cobol_compiler = self.getExec()
+    endif
+    call self.log('g:syntastic_cobol_compiler =', g:syntastic_cobol_compiler)
+    return executable(expand(g:syntastic_cobol_compiler, 1))
+endfunction
+
+function! SyntaxCheckers_cobol_cobc_GetLocList() dict
+    return syntastic#c#GetLocList('cobol', 'cobc', {
+        \ 'errorformat': '%f:%l: %trror: %m',
+        \ 'main_flags': '-fsyntax-only' })
+endfunction
+
+call g:SyntasticRegistry.CreateAndRegisterChecker({
+    \ 'filetype': 'cobol',
+    \ 'name': 'cobc' })
+
+let &cpo = s:save_cpo
+unlet s:save_cpo
+
+" vim: set sw=4 sts=4 et fdm=marker:

vim/syntax_checkers/coffee/coffee.vim

@@ -0,0 +1,58 @@
+"============================================================================
+"File:        coffee.vim
+"Description: Syntax checking plugin for syntastic.vim
+"Maintainer:  Lincoln Stoll <l@lds.li>
+"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.
+"
+"============================================================================
+"
+" Note: this script requires CoffeeScript version 1.6.2 or newer.
+"
+
+if exists('g:loaded_syntastic_coffee_coffee_checker')
+    finish
+endif
+let g:loaded_syntastic_coffee_coffee_checker = 1
+
+let s:save_cpo = &cpo
+set cpo&vim
+
+function! SyntaxCheckers_coffee_coffee_IsAvailable() dict
+    if !executable(self.getExec())
+        return 0
+    endif
+    let ver = self.getVersion(self.getExecEscaped() . ' --version 2>' . syntastic#util#DevNull())
+    return syntastic#util#versionIsAtLeast(ver, [1, 6, 2])
+endfunction
+
+function! SyntaxCheckers_coffee_coffee_GetLocList() dict
+    let makeprg = self.makeprgBuild({ 'args_after': '-cp' })
+
+    let errorformat =
+        \ '%E%f:%l:%c: %trror: %m,' .
+        \ 'Syntax%trror: In %f\, %m on line %l,' .
+        \ '%EError: In %f\, Parse error on line %l: %m,' .
+        \ '%EError: In %f\, %m on line %l,' .
+        \ '%W%f(%l): lint warning: %m,' .
+        \ '%W%f(%l): warning: %m,' .
+        \ '%E%f(%l): SyntaxError: %m,' .
+        \ '%-Z%p^,' .
+        \ '%-G%.%#'
+
+    return SyntasticMake({
+        \ 'makeprg': makeprg,
+        \ 'errorformat': errorformat })
+endfunction
+
+call g:SyntasticRegistry.CreateAndRegisterChecker({
+    \ 'filetype': 'coffee',
+    \ 'name': 'coffee'})
+
+let &cpo = s:save_cpo
+unlet s:save_cpo
+
+" vim: set sw=4 sts=4 et fdm=marker:

vim/syntax_checkers/coffee/coffeelint.vim

@@ -0,0 +1,47 @@
+"============================================================================
+"File:        coffeelint.vim
+"Description: Syntax checking plugin for syntastic.vim
+"Maintainer:  Lincoln Stoll <l@lds.li>
+"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_coffee_coffeelint_checker')
+    finish
+endif
+let g:loaded_syntastic_coffee_coffeelint_checker = 1
+
+let s:save_cpo = &cpo
+set cpo&vim
+
+function! SyntaxCheckers_coffee_coffeelint_GetLocList() dict
+    if !exists('s:coffeelint_new')
+        let s:coffeelint_new = syntastic#util#versionIsAtLeast(self.getVersion(), [1, 4])
+    endif
+    let makeprg = self.makeprgBuild({ 'args_after': (s:coffeelint_new ? '--reporter csv' : '--csv') })
+
+    let errorformat =
+        \ '%f\,%l\,%\d%#\,%trror\,%m,' .
+        \ '%f\,%l\,%trror\,%m,' .
+        \ '%f\,%l\,%\d%#\,%tarn\,%m,' .
+        \ '%f\,%l\,%tarn\,%m'
+
+    return SyntasticMake({
+        \ 'makeprg': makeprg,
+        \ 'errorformat': errorformat,
+        \ 'subtype': 'Style',
+        \ 'returns': [0, 1] })
+endfunction
+
+call g:SyntasticRegistry.CreateAndRegisterChecker({
+    \ 'filetype': 'coffee',
+    \ 'name': 'coffeelint'})
+
+let &cpo = s:save_cpo
+unlet s:save_cpo
+
+" vim: set sw=4 sts=4 et fdm=marker:

vim/syntax_checkers/coq/coqtop.vim

@@ -0,0 +1,40 @@
+"============================================================================
+"File:        coqtop.vim
+"Description: Syntax checking plugin for syntastic.vim
+"Maintainer:  Matvey Aksenov <matvey.aksenov at gmail dot com>
+"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_coq_coqtop_checker')
+    finish
+endif
+let g:loaded_syntastic_coq_coqtop_checker = 1
+
+let s:save_cpo = &cpo
+set cpo&vim
+
+function! SyntaxCheckers_coq_coqtop_GetLocList() dict
+    let makeprg = self.makeprgBuild({ 'args_after': '-noglob -batch -load-vernac-source' })
+
+    let errorformat =
+        \ '%AFile \"%f\"\, line %l\, characters %c\-%.%#\:,'.
+        \ '%C%m'
+
+    return SyntasticMake({
+        \ 'makeprg': makeprg,
+        \ 'errorformat': errorformat })
+endfunction
+
+call g:SyntasticRegistry.CreateAndRegisterChecker({
+    \ 'filetype': 'coq',
+    \ 'name': 'coqtop'})
+
+let &cpo = s:save_cpo
+unlet s:save_cpo
+
+" vim: set sw=4 sts=4 et fdm=marker:

vim/syntax_checkers/cpp/clang_check.vim

@@ -0,0 +1,25 @@
+"============================================================================
+"File:        clang_check.vim
+"Description: Syntax checking plugin for syntastic.vim
+"Maintainer:  Benjamin Bannier <bbannier at gmail dot com>
+"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_cpp_clang_check_checker')
+  finish
+endif
+let g:loaded_syntastic_cpp_clang_check_checker = 1
+
+runtime! syntax_checkers/c/*.vim
+
+call g:SyntasticRegistry.CreateAndRegisterChecker({
+    \ 'filetype': 'cpp',
+    \ 'name': 'clang_check',
+    \ 'exec': 'clang-check',
+    \ 'redirect': 'c/clang_check'})
+
+" vim: set sw=4 sts=4 et fdm=marker:

vim/syntax_checkers/cpp/clang_tidy.vim

@@ -0,0 +1,25 @@
+"============================================================================
+"File:        clang_tidy.vim
+"Description: Syntax checking plugin for syntastic.vim
+"Maintainer:  Benjamin Bannier <bbannier at gmail dot com>
+"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_cpp_clang_tidy_checker')
+  finish
+endif
+let g:loaded_syntastic_cpp_clang_tidy_checker = 1
+
+runtime! syntax_checkers/c/*.vim
+
+call g:SyntasticRegistry.CreateAndRegisterChecker({
+    \ 'filetype': 'cpp',
+    \ 'name': 'clang_tidy',
+    \ 'exec': 'clang-tidy',
+    \ 'redirect': 'c/clang_tidy'})
+
+" vim: set sw=4 sts=4 et fdm=marker:

vim/syntax_checkers/cpp/cppcheck.vim

@@ -0,0 +1,24 @@
+"============================================================================
+"File:        cppcheck.vim
+"Description: Syntax checking plugin for syntastic.vim using cppcheck.pl
+"Maintainer:  LCD 47 <lcd047 at gmail dot com>
+"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_cpp_cppcheck_checker')
+    finish
+endif
+let g:loaded_syntastic_cpp_cppcheck_checker = 1
+
+runtime! syntax_checkers/c/*.vim
+
+call g:SyntasticRegistry.CreateAndRegisterChecker({
+    \ 'filetype': 'cpp',
+    \ 'name': 'cppcheck',
+    \ 'redirect': 'c/cppcheck'})
+
+" vim: set sw=4 sts=4 et fdm=marker:

vim/syntax_checkers/cpp/cpplint.vim

@@ -0,0 +1,52 @@
+"============================================================================
+"File:        cpplint.vim
+"Description: Syntax checking plugin for syntastic.vim
+"Maintainer:  LCD 47 <lcd047 at gmail dot com>
+"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_cpp_cpplint_checker')
+    finish
+endif
+let g:loaded_syntastic_cpp_cpplint_checker = 1
+
+if !exists('g:syntastic_cpp_cpplint_thres')
+    let g:syntastic_cpp_cpplint_thres = 5
+endif
+
+let s:save_cpo = &cpo
+set cpo&vim
+
+function! SyntaxCheckers_cpp_cpplint_GetLocList() dict
+    let makeprg = self.makeprgBuild({ 'args': '--verbose=3' })
+
+    let errorformat = '%A%f:%l:  %m [%t],%-G%.%#'
+
+    let loclist = SyntasticMake({
+        \ 'makeprg': makeprg,
+        \ 'errorformat': errorformat,
+        \ 'subtype': 'Style',
+        \ 'returns': [0, 1] })
+
+    " change error types according to the prescribed threshold
+    for e in loclist
+        let e['type'] = e['type'] < g:syntastic_cpp_cpplint_thres ? 'W' : 'E'
+    endfor
+
+    return loclist
+endfunction
+
+call g:SyntasticRegistry.CreateAndRegisterChecker({
+    \ 'filetype': 'cpp',
+    \ 'name': 'cpplint',
+    \ 'exec': 'cpplint.py'})
+
+let &cpo = s:save_cpo
+unlet s:save_cpo
+
+" vim: set sw=4 sts=4 et fdm=marker:

vim/syntax_checkers/cpp/gcc.vim

@@ -0,0 +1,56 @@
+"============================================================================
+"File:        cpp.vim
+"Description: Syntax checking plugin for syntastic.vim
+"Maintainer:  Gregor Uhlenheuer <kongo2002 at gmail dot com>
+"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_cpp_gcc_checker')
+    finish
+endif
+let g:loaded_syntastic_cpp_gcc_checker = 1
+
+if !exists('g:syntastic_cpp_compiler_options')
+    let g:syntastic_cpp_compiler_options = ''
+endif
+
+let s:save_cpo = &cpo
+set cpo&vim
+
+function! SyntaxCheckers_cpp_gcc_IsAvailable() dict
+    if !exists('g:syntastic_cpp_compiler')
+        let g:syntastic_cpp_compiler = executable(self.getExec()) ? self.getExec() : 'clang++'
+    endif
+    call self.log('g:syntastic_cpp_compiler =', g:syntastic_cpp_compiler)
+    return executable(expand(g:syntastic_cpp_compiler, 1))
+endfunction
+
+function! SyntaxCheckers_cpp_gcc_GetLocList() dict
+    return syntastic#c#GetLocList('cpp', 'gcc', {
+        \ 'errorformat':
+        \     '%-G%f:%s:,' .
+        \     '%f:%l:%c: %trror: %m,' .
+        \     '%f:%l:%c: %tarning: %m,' .
+        \     '%f:%l:%c: %m,'.
+        \     '%f:%l: %trror: %m,'.
+        \     '%f:%l: %tarning: %m,'.
+        \     '%f:%l: %m',
+        \ 'main_flags': '-x c++ -fsyntax-only',
+        \ 'header_flags': '-x c++',
+        \ 'header_names': '\m\.\(h\|hpp\|hh\)$' })
+endfunction
+
+call g:SyntasticRegistry.CreateAndRegisterChecker({
+    \ 'filetype': 'cpp',
+    \ 'name': 'gcc',
+    \ 'exec': 'g++' })
+
+let &cpo = s:save_cpo
+unlet s:save_cpo
+
+" vim: set sw=4 sts=4 et fdm=marker:

vim/syntax_checkers/cpp/oclint.vim

@@ -0,0 +1,24 @@
+"============================================================================
+"File:        oclint.vim
+"Description: Syntax checking plugin for syntastic.vim
+"Maintainer:  "UnCO" Lin <undercooled aT lavabit com>
+"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_cpp_oclint_checker')
+    finish
+endif
+let g:loaded_syntastic_cpp_oclint_checker = 1
+
+runtime! syntax_checkers/c/*.vim
+
+call g:SyntasticRegistry.CreateAndRegisterChecker({
+    \ 'filetype': 'cpp',
+    \ 'name': 'oclint',
+    \ 'redirect': 'c/oclint'})
+
+" vim: set sw=4 sts=4 et fdm=marker:

vim/syntax_checkers/cpp/pc_lint.vim

@@ -0,0 +1,26 @@
+"============================================================================
+"File:        pc_lint.vim
+"Description: Syntax checking plugin for syntastic.vim
+"Maintainer:  Steve Bragg <steve at empresseffects dot com>
+"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_cpp_pc_lint_checker')
+    finish
+endif
+let g:loaded_syntastic_cpp_pc_lint_checker = 1
+
+runtime! syntax_checkers/c/*.vim
+
+call g:SyntasticRegistry.CreateAndRegisterChecker({
+    \ 'filetype': 'cpp',
+    \ 'name': 'pc_lint',
+    \ 'exec': 'lint-nt',
+    \ 'redirect': 'c/pc_lint'})
+
+" vim: set sw=4 sts=4 et fdm=marker:

vim/syntax_checkers/cs/mcs.vim

@@ -0,0 +1,39 @@
+"============================================================================
+"File:        cs.vim
+"Description: Syntax checking plugin for syntastic.vim
+"Maintainer:  Daniel Walker <dwalker@fifo99.com>
+"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_cs_mcs_checker')
+    finish
+endif
+let g:loaded_syntastic_cs_mcs_checker = 1
+
+let s:save_cpo = &cpo
+set cpo&vim
+
+function! SyntaxCheckers_cs_mcs_GetLocList() dict
+    let makeprg = self.makeprgBuild({ 'args_after': '--parse' })
+
+    let errorformat = '%f(%l\,%c): %trror %m'
+
+    return SyntasticMake({
+        \ 'makeprg': makeprg,
+        \ 'errorformat': errorformat,
+        \ 'defaults': {'bufnr': bufnr('')} })
+endfunction
+
+call g:SyntasticRegistry.CreateAndRegisterChecker({
+    \ 'filetype': 'cs',
+    \ 'name': 'mcs'})
+
+let &cpo = s:save_cpo
+unlet s:save_cpo
+
+" vim: set sw=4 sts=4 et fdm=marker:

vim/syntax_checkers/css/csslint.vim

@@ -0,0 +1,47 @@
+"============================================================================
+"File:        css.vim
+"Description: Syntax checking plugin for syntastic.vim using `csslint` CLI tool (http://csslint.net).
+"Maintainer:  Ory Band <oryband at gmail dot com>
+"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_css_csslint_checker')
+    finish
+endif
+let g:loaded_syntastic_css_csslint_checker = 1
+
+let s:save_cpo = &cpo
+set cpo&vim
+
+function! SyntaxCheckers_css_csslint_GetLocList() dict
+    call syntastic#log#deprecationWarn('csslint_options', 'css_csslint_args')
+
+    let makeprg = self.makeprgBuild({ 'args_after': '--format=compact' })
+
+    " Print CSS Lint's error/warning messages from compact format. Ignores blank lines.
+    let errorformat =
+        \ '%-G,' .
+        \ '%-G%f: lint free!,' .
+        \ '%f: line %l\, col %c\, %trror - %m,' .
+        \ '%f: line %l\, col %c\, %tarning - %m,'.
+        \ '%f: line %l\, col %c\, %m,'
+
+    return SyntasticMake({
+        \ 'makeprg': makeprg,
+        \ 'errorformat': errorformat,
+        \ 'defaults': {'bufnr': bufnr('')} })
+
+endfunction
+
+call g:SyntasticRegistry.CreateAndRegisterChecker({
+    \ 'filetype': 'css',
+    \ 'name': 'csslint'})
+
+let &cpo = s:save_cpo
+unlet s:save_cpo
+
+" vim: set sw=4 sts=4 et fdm=marker:

vim/syntax_checkers/css/phpcs.vim

@@ -0,0 +1,25 @@
+"============================================================================
+"File:        phpcs.vim
+"Description: Syntax checking plugin for syntastic.vim
+"Maintainer:  LCD 47 <lcd047 at gmail dot com>
+"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_css_phpcs_checker')
+    finish
+endif
+let g:loaded_syntastic_css_phpcs_checker = 1
+
+runtime! syntax_checkers/php/*.vim
+
+call g:SyntasticRegistry.CreateAndRegisterChecker({
+    \ 'filetype': 'css',
+    \ 'name': 'phpcs',
+    \ 'redirect': 'php/phpcs'})
+
+" vim: set sw=4 sts=4 et fdm=marker:

vim/syntax_checkers/css/prettycss.vim

@@ -0,0 +1,61 @@
+"============================================================================
+"File:        prettycss.vim
+"Description: Syntax checking plugin for syntastic.vim
+"Maintainer:  LCD 47 <lcd047 at gmail dot com>
+"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_css_prettycss_checker')
+    finish
+endif
+let g:loaded_syntastic_css_prettycss_checker = 1
+
+if !exists('g:syntastic_css_prettycss_sort')
+    let g:syntastic_css_prettycss_sort = 1
+endif
+
+let s:save_cpo = &cpo
+set cpo&vim
+
+function! SyntaxCheckers_css_prettycss_GetHighlightRegex(item)
+    let term = matchstr(a:item['text'], '\m (\zs[^)]\+\ze)$')
+    if term !=# ''
+        let term = '\V' . escape(term, '\')
+    endif
+    return term
+endfunction
+
+function! SyntaxCheckers_css_prettycss_GetLocList() dict
+    let makeprg = self.makeprgBuild({})
+
+    " Print CSS Lint's error/warning messages from compact format. Ignores blank lines.
+    let errorformat =
+        \ '%EError:  %m\, line %l\, char %c),' .
+        \ '%WWarning:  %m\, line %l\, char %c),' .
+        \ '%-G%.%#'
+
+    let loclist = SyntasticMake({
+        \ 'makeprg': makeprg,
+        \ 'errorformat': errorformat,
+        \ 'defaults': {'bufnr': bufnr('')} })
+
+    for e in loclist
+        let e['text'] .= ')'
+    endfor
+
+    return loclist
+endfunction
+
+call g:SyntasticRegistry.CreateAndRegisterChecker({
+    \ 'filetype': 'css',
+    \ 'name': 'prettycss'})
+
+let &cpo = s:save_cpo
+unlet s:save_cpo
+
+" vim: set sw=4 sts=4 et fdm=marker:

vim/syntax_checkers/css/recess.vim

@@ -0,0 +1,26 @@
+"============================================================================
+"File:        recess.vim
+"Description: Syntax checking plugin for syntastic.vim using `recess`
+"             (http://twitter.github.io/recess/).
+"Maintainer:  Tim Carry <tim at pixelastic dot com>
+"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_css_recess_checker')
+    finish
+endif
+let g:loaded_syntastic_css_recess_checker = 1
+
+runtime! syntax_checkers/less/*.vim
+
+call g:SyntasticRegistry.CreateAndRegisterChecker({
+    \ 'filetype': 'css',
+    \ 'name': 'recess',
+    \ 'redirect': 'less/recess'})
+
+" vim: set sw=4 sts=4 et fdm=marker:

vim/syntax_checkers/cucumber/cucumber.vim

@@ -0,0 +1,42 @@
+"============================================================================
+"File:        cucumber.vim
+"Description: Syntax checking plugin for syntastic.vim
+"Maintainer:  Martin Grenfell <martin.grenfell at gmail dot com>
+"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_cucumber_cucumber_checker')
+    finish
+endif
+let g:loaded_syntastic_cucumber_cucumber_checker = 1
+
+let s:save_cpo = &cpo
+set cpo&vim
+
+function! SyntaxCheckers_cucumber_cucumber_GetLocList() dict
+    let makeprg = self.makeprgBuild({ 'args_after': '--dry-run --quiet --strict --format pretty' })
+
+    let errorformat =
+        \ '%f:%l:%c:%m,' .
+        \ '%W      %.%# (%m),' .
+        \ '%-Z%f:%l:%.%#,'.
+        \ '%-G%.%#'
+
+    return SyntasticMake({
+        \ 'makeprg': makeprg,
+        \ 'errorformat': errorformat })
+endfunction
+
+call g:SyntasticRegistry.CreateAndRegisterChecker({
+    \ 'filetype': 'cucumber',
+    \ 'name': 'cucumber'})
+
+let &cpo = s:save_cpo
+unlet s:save_cpo
+
+" vim: set sw=4 sts=4 et fdm=marker:

vim/syntax_checkers/cuda/nvcc.vim

@@ -0,0 +1,66 @@
+"============================================================================
+"File:        cuda.vim
+"Description: Syntax checking plugin for syntastic.vim
+"
+"Author:      Hannes Schulz <schulz at ais dot uni-bonn dot de>
+"
+"============================================================================
+
+if exists('g:loaded_syntastic_cuda_nvcc_checker')
+    finish
+endif
+let g:loaded_syntastic_cuda_nvcc_checker = 1
+
+let s:save_cpo = &cpo
+set cpo&vim
+
+function! SyntaxCheckers_cuda_nvcc_GetLocList() dict
+    if exists('g:syntastic_cuda_arch')
+        let arch_flag = '-arch=' . g:syntastic_cuda_arch
+    else
+        let arch_flag = ''
+    endif
+    let makeprg =
+        \ self.getExecEscaped() . ' ' . arch_flag .
+        \ ' --cuda -O0 -I . -Xcompiler -fsyntax-only ' .
+        \ syntastic#util#shexpand('%') . ' ' . syntastic#c#NullOutput()
+
+    let errorformat =
+        \ '%*[^"]"%f"%*\D%l: %m,'.
+        \ '"%f"%*\D%l: %m,'.
+        \ '%-G%f:%l: (Each undeclared identifier is reported only once,'.
+        \ '%-G%f:%l: for each function it appears in.),'.
+        \ '%f:%l:%c:%m,'.
+        \ '%f(%l):%m,'.
+        \ '%f:%l:%m,'.
+        \ '"%f"\, line %l%*\D%c%*[^ ] %m,'.
+        \ '%D%*\a[%*\d]: Entering directory `%f'','.
+        \ '%X%*\a[%*\d]: Leaving directory `%f'','.
+        \ '%D%*\a: Entering directory `%f'','.
+        \ '%X%*\a: Leaving directory `%f'','.
+        \ '%DMaking %*\a in %f,'.
+        \ '%f|%l| %m'
+
+    if expand('%', 1) =~? '\m\%(.h\|.hpp\|.cuh\)$'
+        if exists('g:syntastic_cuda_check_header')
+            let makeprg =
+                \ 'echo > .syntastic_dummy.cu ; ' .
+                \ self.getExecEscaped() . ' ' . arch_flag .
+                \ ' --cuda -O0 -I . .syntastic_dummy.cu -Xcompiler -fsyntax-only -include ' .
+                \ syntastic#util#shexpand('%') . ' ' . syntastic#c#NullOutput()
+        else
+            return []
+        endif
+    endif
+
+    return SyntasticMake({ 'makeprg': makeprg, 'errorformat': errorformat })
+endfunction
+
+call g:SyntasticRegistry.CreateAndRegisterChecker({
+    \ 'filetype': 'cuda',
+    \ 'name': 'nvcc'})
+
+let &cpo = s:save_cpo
+unlet s:save_cpo
+
+" vim: set sw=4 sts=4 et fdm=marker:

vim/syntax_checkers/d/dmd.vim

@@ -0,0 +1,60 @@
+"============================================================================
+"File:        d.vim
+"Description: Syntax checking plugin for syntastic.vim
+"Maintainer:  Alfredo Di Napoli <alfredo dot dinapoli at gmail dot com>
+"License:     Based on the original work of Gregor Uhlenheuer and his
+"             cpp.vim checker so credits are dued.
+"             THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+"             EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+"             OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+"             NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+"             HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+"             WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+"             FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+"             OTHER DEALINGS IN THE SOFTWARE.
+"
+"============================================================================
+
+if exists('g:loaded_syntastic_d_dmd_checker')
+    finish
+endif
+let g:loaded_syntastic_d_dmd_checker = 1
+
+if !exists('g:syntastic_d_compiler_options')
+    let g:syntastic_d_compiler_options = ''
+endif
+
+let s:save_cpo = &cpo
+set cpo&vim
+
+function! SyntaxCheckers_d_dmd_IsAvailable() dict
+    if !exists('g:syntastic_d_compiler')
+        let g:syntastic_d_compiler = self.getExec()
+    endif
+    call self.log('g:syntastic_d_compiler =', g:syntastic_d_compiler)
+    return executable(expand(g:syntastic_d_compiler, 1))
+endfunction
+
+function! SyntaxCheckers_d_dmd_GetLocList() dict
+    if !exists('g:syntastic_d_include_dirs')
+        let g:syntastic_d_include_dirs = filter(glob($HOME . '/.dub/packages/*', 1, 1), 'isdirectory(v:val)')
+        call map(g:syntastic_d_include_dirs, 'isdirectory(v:val . "/source") ? v:val . "/source" : v:val')
+        call add(g:syntastic_d_include_dirs, './source')
+    endif
+
+    return syntastic#c#GetLocList('d', 'dmd', {
+        \ 'errorformat':
+        \     '%-G%f:%s:,%f(%l): %m,' .
+        \     '%f:%l: %m',
+        \ 'main_flags': '-c -of' . syntastic#util#DevNull(),
+        \ 'header_names': '\m\.di$' })
+endfunction
+
+call g:SyntasticRegistry.CreateAndRegisterChecker({
+    \ 'filetype': 'd',
+    \ 'name': 'dmd' })
+
+let &cpo = s:save_cpo
+unlet s:save_cpo
+
+" vim: set sw=4 sts=4 et fdm=marker:

vim/syntax_checkers/dart/dartanalyzer.vim

@@ -0,0 +1,76 @@
+"============================================================================
+"File:        dartanalyzer.vim
+"Description: Dart syntax checker - using dartanalyzer
+"Maintainer:  Maksim Ryzhikov <rv.maksim at gmail dot com>
+"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_dart_dartanalyzer_checker')
+    finish
+endif
+let g:loaded_syntastic_dart_dartanalyzer_checker = 1
+
+let s:save_cpo = &cpo
+set cpo&vim
+
+function! SyntaxCheckers_dart_dartanalyzer_GetHighlightRegex(error)
+    if a:error['len']
+        let lcol = a:error['col'] - 1
+        let rcol = a:error['col'] + a:error['len']
+        let ret = '\%>' . lcol . 'c\%<' . rcol . 'c'
+    else
+        let ret = ''
+    endif
+
+    return ret
+endfunction
+
+function! SyntaxCheckers_dart_dartanalyzer_GetLocList() dict
+    let makeprg = self.makeprgBuild({ 'args_after': '--machine' })
+
+    " Machine readable format looks like:
+    " SEVERITY|TYPE|ERROR_CODE|FILENAME|LINE_NUMBER|COLUMN|LENGTH|MESSAGE
+    " SEVERITY: (WARNING|ERROR)
+    " TYPE: (RESOLVER|STATIC_TYPE|...)
+    " ERROR_CODE: (NO_SUCH_TYPE|...)
+    " FILENAME: String
+    " LINE_NUMBER: int
+    " COLUMN: int
+    " LENGTH: int
+    " MESSAGE: String
+
+    " We use %n to grab the error length, for the syntax highlighter
+    let commonformat = '|%.%#|%.%#|%f|%l|%c|%n|%m'
+
+    let errorformat =
+        \ '%EERROR'   . commonformat . ',' .
+        \ '%WWARNING' . commonformat
+
+    let loclist = SyntasticMake({
+        \ 'makeprg': makeprg,
+        \ 'errorformat': errorformat,
+        \ 'returns': [0, 1, 2, 3] })
+
+    for e in loclist
+        let e['text'] = substitute(e['text'], '\m\\\([\\|]\)', '\1', 'g')
+
+        " Undo the %n hack
+        let e['len'] = e['nr']
+        call remove(e, 'nr')
+    endfor
+
+    return loclist
+endfunction
+
+call g:SyntasticRegistry.CreateAndRegisterChecker({
+    \ 'filetype': 'dart',
+    \ 'name': 'dartanalyzer' })
+
+let &cpo = s:save_cpo
+unlet s:save_cpo
+
+" vim: set sw=4 sts=4 et fdm=marker:

vim/syntax_checkers/docbk/igor.vim

@@ -0,0 +1,55 @@
+"============================================================================
+"File:        igor.vim
+"Description: Syntax checking plugin for syntastic.vim
+"Maintainer:  LCD 47 <lcd047 at gmail dot com>
+"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_docbk_igor_checker')
+    finish
+endif
+let g:loaded_syntastic_docbk_igor_checker = 1
+
+let s:save_cpo = &cpo
+set cpo&vim
+
+function! SyntaxCheckers_docbk_igor_GetLocList() dict
+    let makeprg = self.makeprgBuild({})
+
+    let errorformat = '%f:%l:%m'
+
+    let loclist = SyntasticMake({
+        \ 'makeprg': makeprg,
+        \ 'errorformat': errorformat,
+        \ 'defaults': { 'type': 'W' },
+        \ 'subtype': 'Style',
+        \ 'returns': [0] })
+
+    let buf = bufnr('')
+    for e in loclist
+        " XXX: igor strips directories from filenames
+        let e['bufnr'] = buf
+
+        let e['hl'] = '\V' . escape( substitute(e['text'], '\m[^:]*:', '', ''), '\' )
+        let e['hl'] = substitute(e['hl'], '\V[', '\\zs', 'g')
+        let e['hl'] = substitute(e['hl'], '\V]', '\\ze', 'g')
+
+        " let e['text'] = substitute(e['text'], '\m:.*$', '', '')
+    endfor
+
+    return loclist
+endfunction
+
+call g:SyntasticRegistry.CreateAndRegisterChecker({
+    \ 'filetype': 'docbk',
+    \ 'name': 'igor'})
+
+let &cpo = s:save_cpo
+unlet s:save_cpo
+
+" vim: set sw=4 sts=4 et fdm=marker:

vim/syntax_checkers/docbk/xmllint.vim

@@ -0,0 +1,25 @@
+"============================================================================
+"File:        docbk.vim
+"Description: Syntax checking plugin for syntastic.vim
+"Maintainer:  Martin Grenfell <martin.grenfell at gmail dot com>
+"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_docbk_xmllint_checker')
+    finish
+endif
+let g:loaded_syntastic_docbk_xmllint_checker = 1
+
+runtime! syntax_checkers/xml/*.vim
+
+call g:SyntasticRegistry.CreateAndRegisterChecker({
+    \ 'filetype': 'docbk',
+    \ 'name': 'xmllint',
+    \ 'redirect': 'xml/xmllint'})
+
+" vim: set sw=4 sts=4 et fdm=marker:

vim/syntax_checkers/dustjs/swiffer.vim

@@ -0,0 +1,38 @@
+"============================================================================
+"File:        swiffer.vim
+"Description: Dust.js syntax checker - using swiffer
+"Maintainer:  Steven Foote <smfoote at gmail dot com>
+"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_dustjs_swiffer_checker')
+    finish
+endif
+
+let g:loaded_syntastic_dustjs_swiffer_checker = 1
+
+let s:save_cpo = &cpo
+set cpo&vim
+
+function! SyntaxCheckers_dustjs_swiffer_GetLocList() dict
+    let makeprg = self.makeprgBuild({})
+
+    let errorformat = '%E%f - Line %l\, Column %c: %m'
+
+    return SyntasticMake({
+        \ 'makeprg': makeprg,
+        \ 'errorformat': errorformat })
+ endfunction
+
+call SyntasticRegistry.CreateAndRegisterChecker({
+    \ 'filetype': 'dustjs',
+    \ 'name': 'swiffer'})
+
+let &cpo = s:save_cpo
+unlet s:save_cpo
+
+" vim: set sw=4 sts=4 et fdm=marker:

vim/syntax_checkers/elixir/elixir.vim

@@ -0,0 +1,61 @@
+"============================================================================
+"File:        elixir.vim
+"Description: Syntax checking plugin for syntastic.vim
+"Maintainer:  Richard Ramsden <rramsden at gmail dot com>
+"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_elixir_elixir_checker')
+    finish
+endif
+let g:loaded_syntastic_elixir_elixir_checker = 1
+
+let s:save_cpo = &cpo
+set cpo&vim
+
+" TODO: we should probably split this into separate checkers
+function! SyntaxCheckers_elixir_elixir_IsAvailable() dict
+    call self.log(
+        \ 'executable("elixir") = ' . executable('elixir') . ', ' .
+        \ 'executable("mix") = ' . executable('mix'))
+    return executable('elixir') && executable('mix')
+endfunction
+
+function! SyntaxCheckers_elixir_elixir_GetLocList() dict
+    if !exists('g:syntastic_enable_elixir_checker') || !g:syntastic_enable_elixir_checker
+        call syntastic#log#error('checker elixir/elixir: checks disabled for security reasons; ' .
+            \ 'set g:syntastic_enable_elixir_checker to 1 to override')
+        return []
+    endif
+
+    let make_options = {}
+    let compile_command = 'elixir'
+    let mix_file = syntastic#util#findInParent('mix.exs', expand('%:p:h', 1))
+
+    if filereadable(mix_file)
+        let compile_command = 'mix compile'
+        let make_options['cwd'] = fnamemodify(mix_file, ':p:h')
+    endif
+
+    let make_options['makeprg'] = self.makeprgBuild({ 'exe': compile_command })
+
+    let make_options['errorformat'] =
+        \ '%E** %*[^\ ] %f:%l: %m,' .
+        \ '%W%f:%l: warning: %m'
+
+    return SyntasticMake(make_options)
+endfunction
+
+call g:SyntasticRegistry.CreateAndRegisterChecker({
+    \ 'filetype': 'elixir',
+    \ 'name': 'elixir'})
+
+let &cpo = s:save_cpo
+unlet s:save_cpo
+
+" vim: set sw=4 sts=4 et fdm=marker:

vim/syntax_checkers/erlang/erlang_check_file.erl

@@ -0,0 +1,76 @@
+#!/usr/bin/env escript
+
+main([File]) ->
+    Dir = get_root(filename:dirname(File)),
+    Defs = [strong_validation,
+            warn_export_all,
+            warn_export_vars,
+            warn_shadow_vars,
+            warn_obsolete_guard,
+            warn_unused_import,
+            report,
+            {i, Dir ++ "/include"}],
+    RebarFile = rebar_file(Dir),
+    RebarOpts = rebar_opts(Dir ++ "/" ++ RebarFile),
+    code:add_patha(filename:absname("ebin")),
+    compile:file(File, Defs ++ RebarOpts);
+
+main(_) ->
+    io:format("Usage: ~s <file>~n", [escript:script_name()]),
+    halt(1).
+
+rebar_file(Dir) ->
+    DirList = filename:split(Dir),
+    case lists:last(DirList) of
+        "test" ->
+            "rebar.test.config";
+        _ ->
+            "rebar.config"
+    end.
+
+rebar_opts(RebarFile) ->
+    Dir = get_root(filename:dirname(RebarFile)),
+    case file:consult(RebarFile) of
+        {ok, Terms} ->
+            RebarLibDirs = proplists:get_value(lib_dirs, Terms, []),
+            lists:foreach(
+                fun(LibDir) ->
+                        code:add_pathsa(filelib:wildcard(LibDir ++ "/*/ebin"))
+                end, RebarLibDirs),
+            RebarDepsDir = proplists:get_value(deps_dir, Terms, "deps"),
+            code:add_pathsa(filelib:wildcard(RebarDepsDir ++ "/*/ebin")),
+            IncludeDeps = {i, filename:join(Dir, RebarDepsDir)},
+            proplists:get_value(erl_opts, Terms, []) ++ [IncludeDeps];
+        {error, _} when RebarFile == "rebar.config" ->
+          fallback_opts();
+        {error, _} ->
+            rebar_opts("rebar.config")
+    end.
+
+fallback_opts() ->
+    code:add_pathsa(filelib:wildcard("deps/*/ebin")),
+    code:add_pathsa(nested_app_ebins()),
+    [ { i, filename:absname("deps") }
+      | [ { i, filename:absname(Path) } || Path <- filelib:wildcard("deps/*/apps")]
+    ].
+
+nested_app_ebins() ->
+    DetectedAppSrcFiles = filelib:wildcard("deps/*/apps/**/*.app.src"),
+    [apps_dir_from_src(AppSrcFile)||AppSrcFile<-DetectedAppSrcFiles].
+
+apps_dir_from_src(SrcFile) ->
+    SrcDir = filename:dirname(SrcFile),
+    filename:join(SrcDir, "../../ebin").
+
+get_root(Dir) ->
+    Path = filename:split(filename:absname(Dir)),
+    filename:join(get_root(lists:reverse(Path), Path)).
+
+get_root([], Path) ->
+    Path;
+get_root(["src" | Tail], _Path) ->
+    lists:reverse(Tail);
+get_root(["test" | Tail], _Path) ->
+    lists:reverse(Tail);
+get_root([_ | Tail], Path) ->
+    get_root(Tail, Path).

vim/syntax_checkers/erlang/escript.vim

@@ -0,0 +1,61 @@
+"============================================================================
+"File:        erlang.vim
+"Description: Syntax checking plugin for syntastic.vim
+"Maintainer:  Pawel Salata <rockplayer.pl at gmail dot com>
+"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_erlang_erlang_checker')
+    finish
+endif
+let g:loaded_syntastic_erlang_erlang_checker = 1
+
+if !exists('g:syntastic_erlc_include_path')
+    let g:syntastic_erlc_include_path = ''
+endif
+
+let s:check_file = syntastic#util#shescape(expand('<sfile>:p:h', 1) . syntastic#util#Slash() . 'erlang_check_file.erl')
+
+let s:save_cpo = &cpo
+set cpo&vim
+
+function! SyntaxCheckers_erlang_escript_GetLocList() dict
+    if expand('%:e', 1) ==# 'hrl'
+        return []
+    endif
+
+    let shebang = syntastic#util#parseShebang()
+    if shebang['exe'] ==# 'escript'
+        let args = '-s'
+        let post_args = ''
+    else
+        let args = s:check_file
+        let post_args = g:syntastic_erlc_include_path
+    endif
+    let makeprg = self.makeprgBuild({
+        \ 'args_after': args,
+        \ 'fname': syntastic#util#shexpand('%:p'),
+        \ 'post_args_after': post_args })
+
+    let errorformat =
+        \ '%W%f:%l: warning: %m,'.
+        \ '%E%f:%l: %m'
+
+    return SyntasticMake({
+        \ 'makeprg': makeprg,
+        \ 'errorformat': errorformat })
+endfunction
+
+call g:SyntasticRegistry.CreateAndRegisterChecker({
+    \ 'filetype': 'erlang',
+    \ 'name': 'escript'})
+
+let &cpo = s:save_cpo
+unlet s:save_cpo
+
+" vim: set sw=4 sts=4 et fdm=marker:

vim/syntax_checkers/erlang/syntaxerl.vim

@@ -0,0 +1,42 @@
+"============================================================================
+"File:        syntaxerl.vim
+"Description: Syntax checking plugin for syntastic.
+"Maintainer:  locojay
+"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_erlang_syntaxerl_checker')
+    finish
+endif
+
+let g:loaded_syntastic_erlang_syntaxerl_checker = 1
+
+let s:save_cpo = &cpo
+set cpo&vim
+
+
+function! SyntaxCheckers_erlang_syntaxerl_GetLocList() dict
+
+    let makeprg = self.makeprgBuild({})
+
+    let errorformat =
+        \ '%W%f:%l: warning: %m,'.
+        \ '%E%f:%l: %m'
+
+    return SyntasticMake({
+        \ 'makeprg': makeprg,
+        \ 'errorformat': errorformat })
+endfunction
+
+call g:SyntasticRegistry.CreateAndRegisterChecker({
+    \ 'filetype': 'erlang',
+    \ 'name': 'syntaxerl'})
+
+let &cpo = s:save_cpo
+unlet s:save_cpo
+
+" vim: set sw=4 sts=4 et fdm=marker:

vim/syntax_checkers/eruby/ruby.vim

@@ -0,0 +1,82 @@
+"============================================================================
+"File:        ruby.vim
+"Description: Syntax checking plugin for syntastic.vim
+"Maintainer:  Martin Grenfell <martin.grenfell at gmail dot com>
+"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_eruby_ruby_checker')
+    finish
+endif
+let g:loaded_syntastic_eruby_ruby_checker = 1
+
+let s:save_cpo = &cpo
+set cpo&vim
+
+function! SyntaxCheckers_eruby_ruby_IsAvailable() dict
+    if !exists('g:syntastic_eruby_ruby_exec') && exists('g:syntastic_ruby_exec')
+        let g:syntastic_eruby_ruby_exec = g:syntastic_ruby_exec
+        call self.log('g:syntastic_eruby_ruby_exec =', g:syntastic_eruby_ruby_exec)
+    endif
+    return executable(self.getExec())
+endfunction
+
+function! SyntaxCheckers_eruby_ruby_GetLocList() dict
+    if !exists('s:ruby_new')
+        let s:ruby_new = syntastic#util#versionIsAtLeast(self.getVersion(), [1, 9])
+    endif
+
+    let fname = "'" . escape(expand('%', 1), "\\'") . "'"
+
+    " TODO: encodings became useful in ruby 1.9 :)
+    if s:ruby_new
+        let enc = &fileencoding !=# '' ? &fileencoding : &encoding
+        let encoding_spec = ', :encoding => "' . (enc ==? 'utf-8' ? 'UTF-8' : 'BINARY') . '"'
+    else
+        let encoding_spec = ''
+    endif
+
+    "gsub fixes issue #7, rails has it's own eruby syntax
+    let makeprg =
+        \ self.getExecEscaped() . ' -rerb -e ' .
+        \ syntastic#util#shescape('puts ERB.new(File.read(' .
+        \     fname . encoding_spec .
+        \     ').gsub(''<%='',''<%''), nil, ''-'').src') .
+        \ ' | ' . self.getExecEscaped() . ' -w -c'
+
+    let errorformat = '%-G%\m%.%#warning: %\%%(possibly %\)%\?useless use of a literal in void context,'
+
+    " filter out lines starting with ...
+    " long lines are truncated and wrapped in ... %p then returns the wrong
+    " column offset
+    let errorformat .= '%-G%\%.%\%.%\%.%.%#,'
+
+    let errorformat .=
+        \ '%-GSyntax OK,'.
+        \ '%E-:%l: syntax error\, %m,%Z%p^,'.
+        \ '%W-:%l: warning: %m,'.
+        \ '%Z%p^,'.
+        \ '%-C%.%#'
+
+    let env = syntastic#util#isRunningWindows() ? {} : { 'RUBYOPT': '' }
+
+    return SyntasticMake({
+        \ 'makeprg': makeprg,
+        \ 'errorformat': errorformat,
+        \ 'env': env,
+        \ 'defaults': { 'bufnr': bufnr(''), 'vcol': 1 } })
+endfunction
+
+call g:SyntasticRegistry.CreateAndRegisterChecker({
+    \ 'filetype': 'eruby',
+    \ 'name': 'ruby'})
+
+let &cpo = s:save_cpo
+unlet s:save_cpo
+
+" vim: set sw=4 sts=4 et fdm=marker:

vim/syntax_checkers/fortran/gfortran.vim

@@ -0,0 +1,99 @@
+"============================================================================
+"File:        fortran.vim
+"Description: Syntax checking plugin for syntastic.vim
+"Maintainer:  Karl Yngve Lervåg <karl.yngve@lervag.net>
+"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_fortran_gfortran_checker')
+    finish
+endif
+let g:loaded_syntastic_fortran_gfortran_checker = 1
+
+if !exists('g:syntastic_fortran_compiler_options')
+    let g:syntastic_fortran_compiler_options = ''
+endif
+
+let s:type_map = {}
+
+let s:save_cpo = &cpo
+set cpo&vim
+
+function! SyntaxCheckers_fortran_gfortran_IsAvailable() dict " {{{1
+    if !exists('g:syntastic_fortran_compiler')
+        let g:syntastic_fortran_compiler = self.getExec()
+    endif
+    call self.log('g:syntastic_fortran_compiler = ', g:syntastic_fortran_compiler)
+    return executable(expand(g:syntastic_fortran_compiler, 1))
+endfunction " }}}1
+
+" @vimlint(EVL104, 1, l:errorformat)
+function! SyntaxCheckers_fortran_gfortran_GetLocList() dict " {{{1
+    call s:SetCompilerType(g:syntastic_fortran_compiler)
+    if !has_key(s:type_map, g:syntastic_fortran_compiler)
+        call syntastic#log#error("checker fortran/gfortran: can't parse version string (abnormal termination?)")
+        return []
+    endif
+
+    if s:type_map[g:syntastic_fortran_compiler] ==# 'gfortran'
+        let errorformat =
+            \ '%-C %#,'.
+            \ '%-C  %#%.%#,'.
+            \ '%A%f:%l.%c:,'.
+            \ '%Z%trror: %m,'.
+            \ '%Z%tarning: %m,'.
+            \ '%-G%.%#'
+        if !exists('g:syntastic_fortran_gfortran_sort')
+            let g:syntastic_fortran_gfortran_sort = 0
+        endif
+    elseif s:type_map[g:syntastic_fortran_compiler] ==# 'ifort'
+        let errorformat =
+            \ '%E%f(%l): error #%n: %m,'.
+            \ '%W%f(%l): warning #%n: %m,'.
+            \ '%W%f(%l): remark #%n: %m,'.
+            \ '%-Z%p^,'.
+            \ '%-G%.%#'
+        if !exists('g:syntastic_fortran_gfortran_sort')
+            let g:syntastic_fortran_gfortran_sort = 1
+        endif
+    endif
+
+    return syntastic#c#GetLocList('fortran', 'gfortran', {
+        \ 'errorformat': errorformat,
+        \ 'main_flags': '-fsyntax-only' })
+endfunction " }}}1
+" @vimlint(EVL104, 0, l:errorformat)
+
+" Utilities {{{1
+
+function! s:SetCompilerType(exe) " {{{2
+    if !has_key(s:type_map, a:exe)
+        try
+            let ver = filter( split(syntastic#util#system(syntastic#util#shescape(a:exe) . ' --version'), '\n'),
+                \ 'v:val =~# "\\v^%(GNU Fortran|ifort) "' )[0]
+            if ver =~# '\m^GNU Fortran '
+                let s:type_map[a:exe] = 'gfortran'
+            elseif ver =~# '\m^ifort '
+                let s:type_map[a:exe] = 'ifort'
+            endif
+        catch /\m^Vim\%((\a\+)\)\=:E684/
+            " do nothing
+        endtry
+    endif
+endfunction " }}}2
+
+" }}}
+
+call g:SyntasticRegistry.CreateAndRegisterChecker({
+    \ 'filetype': 'fortran',
+    \ 'name': 'gfortran' })
+
+let &cpo = s:save_cpo
+unlet s:save_cpo
+
+" vim: set sw=4 sts=4 et fdm=marker:

vim/syntax_checkers/glsl/cgc.vim

@@ -0,0 +1,81 @@
+"============================================================================
+"File:        glsl.vim
+"Description: Syntax checker for OpenGL Shading Language
+"Maintainer:  Joshua Rahm <joshuarahm@gmail.com>
+"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_glsl_cgc_checker')
+    finish
+endif
+let g:loaded_syntastic_glsl_cgc_checker = 1
+
+let s:glsl_extensions = {
+        \ 'glslf': 'gpu_fp',
+        \ 'glslv': 'gpu_vp',
+        \ 'frag':  'gpu_fp',
+        \ 'vert':  'gpu_vp',
+        \ 'fp':    'gpu_fp',
+        \ 'vp':    'gpu_vp'
+    \ }
+
+let s:save_cpo = &cpo
+set cpo&vim
+
+function! SyntaxCheckers_glsl_cgc_GetLocList() dict " {{{1
+    let makeprg = self.makeprgBuild({
+        \ 'args_before': '-oglsl -profile ' . s:GetProfile(),
+        \ 'args': (exists('g:syntastic_glsl_options') ? ' ' . g:syntastic_glsl_options : '') })
+
+    let errorformat =
+        \ '%E%f(%l) : error %m,' .
+        \ '%W%f(%l) : warning %m'
+
+    return SyntasticMake({
+        \ 'makeprg': makeprg,
+        \ 'errorformat': errorformat })
+endfunction " }}}1
+
+" Utilities {{{1
+
+function! s:GetProfile() " {{{2
+    let save_view = winsaveview()
+    let old_foldenable = &foldenable
+    let old_lazyredraw = &lazyredraw
+
+    let &lazyredraw = 1
+    let &foldenable = 0
+    call cursor(1, 1)
+
+    let magic = '\m\C^// profile:\s*'
+    let line = search(magic, 'c')
+
+    call winrestview(save_view)
+    let &foldenable = old_foldenable
+    let &lazyredraw = old_lazyredraw
+
+    if line
+        let profile = matchstr(getline(line), magic . '\zs.*')
+    else
+        let extensions = exists('g:syntastic_glsl_extensions') ? g:syntastic_glsl_extensions : s:glsl_extensions
+        let profile = get(extensions, tolower(expand('%:e', 1)), 'gpu_vert')
+    endif
+
+    return profile
+endfunction " }}}2
+
+" }}}1
+
+call g:SyntasticRegistry.CreateAndRegisterChecker({
+    \'filetype': 'glsl',
+    \'name': 'cgc'})
+
+let &cpo = s:save_cpo
+unlet s:save_cpo
+
+" vim: set sw=4 sts=4 et fdm=marker:

vim/syntax_checkers/go/go.vim

@@ -0,0 +1,96 @@
+"============================================================================
+"File:        go.vim
+"Description: Check go syntax using 'gofmt -l' followed by 'go [build|test]'
+"Maintainer:  Kamil Kisiel <kamil@kamilkisiel.net>
+"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.
+"
+"============================================================================
+"
+" This syntax checker does not reformat your source code.
+" Use a BufWritePre autocommand to that end:
+"   autocmd FileType go autocmd BufWritePre <buffer> Fmt
+
+if exists('g:loaded_syntastic_go_go_checker')
+    finish
+endif
+let g:loaded_syntastic_go_go_checker = 1
+
+let s:save_cpo = &cpo
+set cpo&vim
+
+function! SyntaxCheckers_go_go_IsAvailable() dict
+    return executable(self.getExec()) && executable('gofmt')
+endfunction
+
+function! SyntaxCheckers_go_go_GetLocList() dict
+    " Check with gofmt first, since `go build` and `go test` might not report
+    " syntax errors in the current file if another file with syntax error is
+    " compiled first.
+    let makeprg = self.makeprgBuild({
+        \ 'exe': 'gofmt',
+        \ 'args': '-l',
+        \ 'tail': '> ' . syntastic#util#DevNull() })
+
+    let errorformat =
+        \ '%f:%l:%c: %m,' .
+        \ '%-G%.%#'
+
+    let errors = SyntasticMake({
+        \ 'makeprg': makeprg,
+        \ 'errorformat': errorformat,
+        \ 'defaults': {'type': 'e'} })
+    if !empty(errors)
+        return errors
+    endif
+
+    " Test files, i.e. files with a name ending in `_test.go`, are not
+    " compiled by `go build`, therefore `go test` must be called for those.
+    if match(expand('%', 1), '\m_test\.go$') == -1
+        let cmd = 'build'
+        let opts = syntastic#util#var('go_go_build_args')
+        let cleanup = 0
+    else
+        let cmd = 'test -c'
+        let opts = syntastic#util#var('go_go_test_args')
+        let cleanup = 1
+    endif
+    let opt_str = (type(opts) != type('') || opts !=# '') ? join(syntastic#util#argsescape(opts)) : opts
+    let makeprg = self.getExec() . ' ' . cmd . ' ' . opt_str . ' ' . syntastic#c#NullOutput()
+
+    " The first pattern is for warnings from C compilers.
+    let errorformat =
+        \ '%W%f:%l: warning: %m,' .
+        \ '%E%f:%l:%c:%m,' .
+        \ '%E%f:%l:%m,' .
+        \ '%C%\s%\+%m,' .
+        \ '%-G#%.%#'
+
+    " The go compiler needs to either be run with an import path as an
+    " argument or directly from the package directory. Since figuring out
+    " the proper import path is fickle, just cwd to the package.
+
+    let errors = SyntasticMake({
+        \ 'makeprg': makeprg,
+        \ 'errorformat': errorformat,
+        \ 'cwd': expand('%:p:h', 1),
+        \ 'defaults': {'type': 'e'} })
+
+    if cleanup
+        call delete(expand('%:p:h', 1) . syntastic#util#Slash() . expand('%:p:h:t', 1) . '.test')
+    endif
+
+    return errors
+endfunction
+
+call g:SyntasticRegistry.CreateAndRegisterChecker({
+    \ 'filetype': 'go',
+    \ 'name': 'go'})
+
+let &cpo = s:save_cpo
+unlet s:save_cpo
+
+" vim: set sw=4 sts=4 et fdm=marker:

vim/syntax_checkers/go/gofmt.vim

@@ -0,0 +1,45 @@
+"============================================================================
+"File:        gofmt.vim
+"Description: Check go syntax using 'gofmt -l'
+"Maintainer:  Brandon Thomson <bt@brandonthomson.com>
+"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.
+"
+"============================================================================
+"
+" This syntax checker does not reformat your source code.
+" Use a BufWritePre autocommand to that end:
+"   autocmd FileType go autocmd BufWritePre <buffer> Fmt
+
+if exists('g:loaded_syntastic_go_gofmt_checker')
+    finish
+endif
+let g:loaded_syntastic_go_gofmt_checker = 1
+
+let s:save_cpo = &cpo
+set cpo&vim
+
+function! SyntaxCheckers_go_gofmt_GetLocList() dict
+    let makeprg = self.makeprgBuild({
+        \ 'args_after': '-l',
+        \ 'tail_after': '> ' . syntastic#util#DevNull() })
+
+    let errorformat = '%f:%l:%c: %m,%-G%.%#'
+
+    return SyntasticMake({
+        \ 'makeprg': makeprg,
+        \ 'errorformat': errorformat,
+        \ 'defaults': {'type': 'e'} })
+endfunction
+
+call g:SyntasticRegistry.CreateAndRegisterChecker({
+    \ 'filetype': 'go',
+    \ 'name': 'gofmt'})
+
+let &cpo = s:save_cpo
+unlet s:save_cpo
+
+" vim: set sw=4 sts=4 et fdm=marker:

vim/syntax_checkers/go/golint.vim

@@ -0,0 +1,42 @@
+"============================================================================
+"File:        golint.vim
+"Description: Check go syntax using 'golint'
+"Maintainer:  Hiroshi Ioka <hirochachacha@gmail.com>
+"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_go_golint_checker')
+    finish
+endif
+let g:loaded_syntastic_go_golint_checker = 1
+
+let s:save_cpo = &cpo
+set cpo&vim
+
+function! SyntaxCheckers_go_golint_GetLocList() dict
+    let makeprg = self.makeprgBuild({})
+
+    let errorformat =
+        \ '%f:%l:%c: %m,' .
+        \ '%-G%.%#'
+
+    return SyntasticMake({
+        \ 'makeprg': makeprg,
+        \ 'errorformat': errorformat,
+        \ 'defaults': {'type': 'w'},
+        \ 'subtype': 'Style' })
+endfunction
+
+call g:SyntasticRegistry.CreateAndRegisterChecker({
+    \ 'filetype': 'go',
+    \ 'name': 'golint'})
+
+let &cpo = s:save_cpo
+unlet s:save_cpo
+
+" vim: set sw=4 sts=4 et fdm=marker:

vim/syntax_checkers/go/gotype.vim

@@ -0,0 +1,46 @@
+"============================================================================
+"File:        gotype.vim
+"Description: Perform syntactic and semantic checking of Go code using 'gotype'
+"Maintainer:  luz <ne.tetewi@gmail.com>
+"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_go_gotype_checker')
+    finish
+endif
+let g:loaded_syntastic_go_gotype_checker = 1
+
+let s:save_cpo = &cpo
+set cpo&vim
+
+function! SyntaxCheckers_go_gotype_GetLocList() dict
+    let makeprg = self.getExecEscaped() . ' .'
+
+    let errorformat =
+        \ '%f:%l:%c: %m,' .
+        \ '%-G%.%#'
+
+    " gotype needs the full go package to test types properly. Just cwd to
+    " the package for the same reasons specified in go.vim ("figuring out
+    " the import path is fickle").
+
+    return SyntasticMake({
+        \ 'makeprg': makeprg,
+        \ 'errorformat': errorformat,
+        \ 'cwd': expand('%:p:h', 1),
+        \ 'defaults': {'type': 'e'} })
+endfunction
+
+call g:SyntasticRegistry.CreateAndRegisterChecker({
+    \ 'filetype': 'go',
+    \ 'name': 'gotype'})
+
+let &cpo = s:save_cpo
+unlet s:save_cpo
+
+" vim: set sw=4 sts=4 et fdm=marker:

vim/syntax_checkers/go/govet.vim

@@ -0,0 +1,52 @@
+"============================================================================
+"File:        govet.vim
+"Description: Perform static analysis of Go code with the vet tool
+"Maintainer:  Kamil Kisiel <kamil@kamilkisiel.net>
+"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_go_govet_checker')
+    finish
+endif
+let g:loaded_syntastic_go_govet_checker = 1
+
+let s:save_cpo = &cpo
+set cpo&vim
+
+function! SyntaxCheckers_go_govet_IsAvailable() dict
+    return executable(self.getExec())
+endfunction
+
+function! SyntaxCheckers_go_govet_GetLocList() dict
+    let makeprg = self.getExec() . ' vet'
+
+    let errorformat =
+        \ '%Evet: %.%\+: %f:%l:%c: %m,' .
+        \ '%W%f:%l: %m,' .
+        \ '%-G%.%#'
+
+    " The go compiler needs to either be run with an import path as an
+    " argument or directly from the package directory. Since figuring out
+    " the proper import path is fickle, just cwd to the package.
+
+    return SyntasticMake({
+        \ 'makeprg': makeprg,
+        \ 'errorformat': errorformat,
+        \ 'cwd': expand('%:p:h', 1),
+        \ 'defaults': {'type': 'w'} })
+endfunction
+
+call g:SyntasticRegistry.CreateAndRegisterChecker({
+    \ 'filetype': 'go',
+    \ 'name': 'govet',
+    \ 'exec': 'go' })
+
+let &cpo = s:save_cpo
+unlet s:save_cpo
+
+" vim: set sw=4 sts=4 et fdm=marker:

vim/syntax_checkers/haml/haml.vim

@@ -0,0 +1,46 @@
+"============================================================================
+"File:        haml.vim
+"Description: Syntax checking plugin for syntastic.vim
+"Maintainer:  Martin Grenfell <martin.grenfell at gmail dot com>
+"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_haml_haml_checker')
+    finish
+endif
+let g:loaded_syntastic_haml_haml_checker = 1
+
+let s:save_cpo = &cpo
+set cpo&vim
+
+function! SyntaxCheckers_haml_haml_IsAvailable() dict
+    call syntastic#log#deprecationWarn('haml_interpreter', 'haml_haml_exec')
+    return executable(self.getExec())
+endfunction
+
+function! SyntaxCheckers_haml_haml_GetLocList() dict
+    let makeprg = self.makeprgBuild({ 'args_after': '-c' })
+
+    let errorformat =
+        \ 'Haml error on line %l: %m,' .
+        \ 'Syntax error on line %l: %m,' .
+        \ '%-G%.%#'
+
+    return SyntasticMake({
+        \ 'makeprg': makeprg,
+        \ 'errorformat': errorformat })
+endfunction
+
+call g:SyntasticRegistry.CreateAndRegisterChecker({
+    \ 'filetype': 'haml',
+    \ 'name': 'haml'})
+
+let &cpo = s:save_cpo
+unlet s:save_cpo
+
+" vim: set sw=4 sts=4 et fdm=marker:

vim/syntax_checkers/haml/haml_lint.vim

@@ -0,0 +1,37 @@
+"============================================================================
+"File:        haml_lint.vim
+"Description: HAML style and syntax checker plugin for Syntastic
+"Maintainer:  Shane da Silva <shane@dasilva.io>
+"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_haml_haml_lint_checker')
+    finish
+endif
+let g:loaded_syntastic_haml_haml_lint_checker = 1
+
+let s:save_cpo = &cpo
+set cpo&vim
+
+function! SyntaxCheckers_haml_haml_lint_GetLocList() dict
+    let makeprg = self.makeprgBuild({})
+    let errorformat = '%f:%l [%t] %m'
+    return SyntasticMake({
+        \ 'makeprg': makeprg,
+        \ 'errorformat': errorformat,
+        \ 'subtype': 'Style'})
+endfunction
+
+call g:SyntasticRegistry.CreateAndRegisterChecker({
+    \ 'filetype': 'haml',
+    \ 'name': 'haml_lint',
+    \ 'exec': 'haml-lint' })
+
+let &cpo = s:save_cpo
+unlet s:save_cpo
+
+" vim: set sw=4 sts=4 et fdm=marker:

vim/syntax_checkers/handlebars/handlebars.vim

@@ -0,0 +1,43 @@
+"============================================================================
+"File:        handlebars.vim
+"Description: Syntax checking plugin for syntastic.vim
+"Maintainer:  Martin Grenfell <martin.grenfell at gmail dot com>
+"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_handlebars_handlebars_checker')
+    finish
+endif
+let g:loaded_syntastic_handlebars_handlebars_checker = 1
+
+let s:save_cpo = &cpo
+set cpo&vim
+
+function! SyntaxCheckers_handlebars_handlebars_GetLocList() dict
+    let makeprg = self.makeprgBuild({ 'args_after': '-f ' . syntastic#util#DevNull() })
+
+    let errorformat =
+        \ '%EError: %m on line %l:,' .
+        \ '%EError: %m,' .
+        \ '%Z%p^,' .
+        \ '%-G%.%#'
+
+    return SyntasticMake({
+        \ 'makeprg': makeprg,
+        \ 'errorformat': errorformat,
+        \ 'postprocess': ['guards'],
+        \ 'defaults': {'bufnr': bufnr('')} })
+endfunction
+
+call g:SyntasticRegistry.CreateAndRegisterChecker({
+    \ 'filetype': 'handlebars',
+    \ 'name': 'handlebars'})
+
+let &cpo = s:save_cpo
+unlet s:save_cpo
+
+" vim: set sw=4 sts=4 et fdm=marker:

vim/syntax_checkers/haskell/ghc-mod.vim

@@ -0,0 +1,83 @@
+"============================================================================
+"File:        ghc-mod.vim
+"Description: Syntax checking plugin for syntastic.vim
+"Maintainer:  Anthony Carapetis <anthony.carapetis at gmail dot com>
+"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_haskell_ghc_mod_checker')
+    finish
+endif
+let g:loaded_syntastic_haskell_ghc_mod_checker = 1
+
+let s:ghc_mod_new = -1
+
+let s:save_cpo = &cpo
+set cpo&vim
+
+function! SyntaxCheckers_haskell_ghc_mod_IsAvailable() dict
+    if !executable(self.getExec())
+        return 0
+    endif
+
+    " ghc-mod 5.0.0 and later needs the "version" command to print the
+    " version.  But the "version" command appeared in 4.1.0.  Thus, we need to
+    " know the version in order to know how to find out the version. :)
+
+    " Try "ghc-mod version".
+    let ver = filter(split(syntastic#util#system(self.getExecEscaped() . ' version'), '\n'), 'v:val =~# ''\m\sversion''')
+    if !len(ver)
+        " That didn't work.  Try "ghc-mod" alone.
+        let ver = filter(split(syntastic#util#system(self.getExecEscaped()), '\n'), 'v:val =~# ''\m\sversion''')
+    endif
+
+    if len(ver)
+        " Encouraged by the great success in finding out the version, now we
+        " need either a Vim that can handle NULs in system() output, or a
+        " ghc-mod that has the "--boundary" option.
+        let parsed_ver = syntastic#util#parseVersion(ver[0])
+        call self.setVersion(parsed_ver)
+        let s:ghc_mod_new = syntastic#util#versionIsAtLeast(parsed_ver, [2, 1, 2])
+    else
+        call syntastic#log#error("checker haskell/ghc_mod: can't parse version string (abnormal termination?)")
+        let s:ghc_mod_new = -1
+    endif
+
+    return (s:ghc_mod_new >= 0) && (v:version >= 704 || s:ghc_mod_new)
+endfunction
+
+function! SyntaxCheckers_haskell_ghc_mod_GetLocList() dict
+    let makeprg = self.makeprgBuild({
+        \ 'exe': self.getExecEscaped() . ' check' . (s:ghc_mod_new ? ' --boundary=""' : '') })
+
+    let errorformat =
+        \ '%-G%\s%#,' .
+        \ '%f:%l:%c:%trror: %m,' .
+        \ '%f:%l:%c:%tarning: %m,'.
+        \ '%f:%l:%c: %trror: %m,' .
+        \ '%f:%l:%c: %tarning: %m,' .
+        \ '%f:%l:%c:%m,' .
+        \ '%E%f:%l:%c:,' .
+        \ '%Z%m'
+
+    return SyntasticMake({
+        \ 'makeprg': makeprg,
+        \ 'errorformat': errorformat,
+        \ 'postprocess': ['compressWhitespace'],
+        \ 'returns': [0] })
+endfunction
+
+call g:SyntasticRegistry.CreateAndRegisterChecker({
+    \ 'filetype': 'haskell',
+    \ 'name': 'ghc_mod',
+    \ 'exec': 'ghc-mod' })
+
+let &cpo = s:save_cpo
+unlet s:save_cpo
+
+" vim: set sw=4 sts=4 et fdm=marker:

vim/syntax_checkers/haskell/hdevtools.vim

@@ -0,0 +1,56 @@
+"============================================================================
+"File:        hdevtools.vim
+"Description: Syntax checking plugin for syntastic.vim
+"Maintainer:  Anthony Carapetis <anthony.carapetis at gmail dot com>
+"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_haskell_hdevtools_checker')
+    finish
+endif
+let g:loaded_syntastic_haskell_hdevtools_checker = 1
+
+let s:save_cpo = &cpo
+set cpo&vim
+
+function! SyntaxCheckers_haskell_hdevtools_GetLocList() dict
+    if !exists('g:syntastic_haskell_hdevtools_args') && exists('g:hdevtools_options')
+        call syntastic#log#oneTimeWarn('variable g:hdevtools_options is deprecated, ' .
+            \ 'please use g:syntastic_haskell_hdevtools_args instead')
+        let g:syntastic_haskell_hdevtools_args = g:hdevtools_options
+    endif
+
+    let makeprg = self.makeprgBuild({
+        \ 'exe_after': 'check',
+        \ 'fname': syntastic#util#shexpand('%:p') })
+
+    let errorformat =
+        \ '%-Z %#,'.
+        \ '%W%f:%l:%v: Warning: %m,'.
+        \ '%W%f:%l:%v: Warning:,'.
+        \ '%E%f:%l:%v: %m,'.
+        \ '%E%>%f:%l:%v:,'.
+        \ '%+C  %#%m,'.
+        \ '%W%>%f:%l:%v:,'.
+        \ '%+C  %#%tarning: %m,'
+
+    return SyntasticMake({
+        \ 'makeprg': makeprg,
+        \ 'errorformat': errorformat,
+        \ 'defaults': {'vcol': 1},
+        \ 'postprocess': ['compressWhitespace'] })
+endfunction
+
+call g:SyntasticRegistry.CreateAndRegisterChecker({
+    \ 'filetype': 'haskell',
+    \ 'name': 'hdevtools'})
+
+let &cpo = s:save_cpo
+unlet s:save_cpo
+
+" vim: set sw=4 sts=4 et fdm=marker:

vim/syntax_checkers/haskell/hlint.vim

@@ -0,0 +1,39 @@
+"============================================================================
+"File:        hlint.vim
+"Description: Syntax checking plugin for syntastic.vim
+"Maintainer:  Nicolas Wu <nicolas.wu at gmail dot com>
+"License:     BSD
+"============================================================================
+
+if exists('g:loaded_syntastic_haskell_hlint_checker')
+    finish
+endif
+let g:loaded_syntastic_haskell_hlint_checker = 1
+
+let s:save_cpo = &cpo
+set cpo&vim
+
+function! SyntaxCheckers_haskell_hlint_GetLocList() dict
+    let makeprg = self.makeprgBuild({
+        \ 'fname': syntastic#util#shexpand('%:p')})
+
+    let errorformat =
+        \ '%E%f:%l:%v: Error: %m,' .
+        \ '%W%f:%l:%v: Warning: %m,' .
+        \ '%C%m'
+
+    return SyntasticMake({
+        \ 'makeprg': makeprg,
+        \ 'errorformat': errorformat,
+        \ 'defaults': {'vcol': 1},
+        \ 'postprocess': ['compressWhitespace'] })
+endfunction
+
+call g:SyntasticRegistry.CreateAndRegisterChecker({
+    \ 'filetype': 'haskell',
+    \ 'name': 'hlint'})
+
+let &cpo = s:save_cpo
+unlet s:save_cpo
+
+" vim: set sw=4 sts=4 et fdm=marker:

vim/syntax_checkers/haskell/scan.vim

@@ -0,0 +1,43 @@
+"============================================================================
+"File:        scan.vim
+"Description: Syntax checking plugin for syntastic.vim
+"Maintainer:  LCD 47 <lcd047 at gmail dot com>
+"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_haskell_scan_checker')
+    finish
+endif
+let g:loaded_syntastic_haskell_scan_checker = 1
+
+if !exists('g:syntastic_haskell_scan_sort')
+    let g:syntastic_haskell_scan_sort = 1
+endif
+
+let s:save_cpo = &cpo
+set cpo&vim
+
+function! SyntaxCheckers_haskell_scan_GetLocList() dict
+    let makeprg = self.makeprgBuild({})
+
+    let errorformat = '%f:%l:%v: %m'
+
+    return SyntasticMake({
+        \ 'makeprg': makeprg,
+        \ 'errorformat': errorformat,
+        \ 'subtype': 'Style' })
+endfunction
+
+call g:SyntasticRegistry.CreateAndRegisterChecker({
+    \ 'filetype': 'haskell',
+    \ 'name': 'scan'})
+
+let &cpo = s:save_cpo
+unlet s:save_cpo
+
+" vim: set sw=4 sts=4 et fdm=marker:

vim/syntax_checkers/haxe/haxe.vim

@@ -0,0 +1,63 @@
+"============================================================================
+"File:        haxe.vim
+"Description: Syntax checking plugin for syntastic.vim
+"Maintainer:  David Bernard <david.bernard.31 at gmail dot com>
+"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_haxe_haxe_checker')
+    finish
+endif
+let g:loaded_syntastic_haxe_haxe_checker = 1
+
+let s:save_cpo = &cpo
+set cpo&vim
+
+function! SyntaxCheckers_haxe_haxe_GetLocList() dict
+    if exists('b:vaxe_hxml')
+        let hxml = b:vaxe_hxml
+    elseif exists('g:vaxe_hxml')
+        let hxml = g:vaxe_hxml
+    else
+        let hxml = syntastic#util#findInParent('*.hxml', expand('%:p:h', 1))
+    endif
+    let hxml = fnamemodify(hxml, ':p')
+
+    call self.log('hxml =', hxml)
+
+    if hxml !=# ''
+        let makeprg = self.makeprgBuild({
+            \ 'fname': syntastic#util#shescape(fnamemodify(hxml, ':t')) })
+
+        let errorformat = '%E%f:%l: characters %c-%n : %m'
+
+        let loclist = SyntasticMake({
+            \ 'makeprg': makeprg,
+            \ 'errorformat': errorformat,
+            \ 'cwd': fnamemodify(hxml, ':h') })
+
+        for e in loclist
+            let e['hl'] = '\%>' . e['col'] . 'c\%<' . (e['nr'] + 1) . 'c'
+            let e['col'] += 1
+            let e['nr'] = 0
+        endfor
+
+        return loclist
+    endif
+
+    return []
+endfunction
+
+call g:SyntasticRegistry.CreateAndRegisterChecker({
+    \ 'filetype': 'haxe',
+    \ 'name': 'haxe'})
+
+let &cpo = s:save_cpo
+unlet s:save_cpo
+
+" vim: set sw=4 sts=4 et fdm=marker: