Merge commit '0c33f9ea27e5c149c245a7392b32e6992d4d2cff' into main

vim/bundle/syntastic/README.markdown

@@ -18,33 +18,51 @@
 
 
 - - -
-1\. [Introduction](#introduction)  
-2\. [Installation](#installation)  
-3\. [FAQ](#faq)  
-4\. [Other resources](#otherresources)  
+1. [Introduction](#introduction)  
+2. [Installation](#installation)  
+2.1. [Requirements](#requirements)  
+2.2. [Installing syntastic with Pathogen](#installpathogen)  
+3. [Recommended settings](#settings)  
+4. [FAQ](#faq)  
+4.1. [I installed syntastic but it isn't reporting any errors...](#faqinfo)  
+4.2. [The `python` checker complains about syntactically valid Python 3 constructs...](#faqpython3)  
+4.3. [Are there any local checkers for HTML5 that I can use with syntastic?](#faqhtml5)  
+4.4. [The `perl` checker has stopped working...](#faqperl)  
+4.5. [What happened to the `rustc` checker?](#faqrust)  
+4.6. [I run a checker and the location list is not updated...](#faqloclist)  
+4.6. [I run`:lopen` or `:lwindow` and the error window is empty...](#faqloclist)  
+4.7. [How can I pass additional arguments to a checker?](#faqargs)  
+4.8. [Syntastic supports several checkers for my filetype - how do I tell which one(s) to use?](#faqcheckers)  
+4.9. [What is the difference between syntax checkers and style checkers?](#faqstyle)  
+4.10. [I have enabled multiple checkers for the current filetype.  How can I display all of the errors from all of the checkers together?](#faqaggregate)  
+4.11. [How can I jump between the different errors without using the location list at the bottom of the window?](#faqlnext)  
+4.12. [The error window is closed automatically when I :quit the current buffer but not when I :bdelete it?](#faqbdelete)  
+5. [Resources](#otherresources)  
+
 - - -
 
 <a name="introduction"></a>
 
 ## 1\. Introduction
 
-Syntastic is a syntax checking plugin for Vim that runs files through external
-syntax checkers and displays any resulting errors to the user. This can be done
-on demand, or automatically as files are saved. 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 is a syntax checking plugin for [Vim][13] that runs files through
+external syntax checkers and displays any resulting errors to the user. This
+can be done on demand, or automatically as files are saved. 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.
 
 At the time of this writing, syntax checking plugins exist for ActionScript,
-Ada, AppleScript, Arduino, AsciiDoc, ASM, BEMHTML, Bro, Bourne shell, C,
-C++, C#, Cabal, Chef, CoffeeScript, Coco, Coq, CSS, Cucumber, CUDA, D, Dart,
-DocBook, Dust, Elixir, Erlang, eRuby, Fortran, Gentoo metadata, GLSL, Go,
-Haml, Haskell, Haxe, Handlebars, HSS, HTML, Java, JavaScript, JSON, JSX, LESS,
-Lex, Limbo, LISP, LLVM intermediate language, Lua, MATLAB, NASM, Objective-C,
-Objective-C++, OCaml, Perl, Perl POD, PHP, gettext Portable Object, OS X
-and iOS property lists, Puppet, Python, Racket, R, reStructuredText, Ruby,
-SASS/SCSS, Scala, Slim, Tcl, TeX, Texinfo, Twig, TypeScript, Vala, Verilog,
-VHDL, VimL, xHtml, XML, XSLT, YACC, YAML, z80, Zope page templates, and zsh.
-See the [wiki][3] for details about the corresponding supported checkers.
+Ada, AppleScript, AsciiDoc, ASM, BEMHTML, Bro, Bourne shell, C, C++, C#, Cabal,
+Chef, CoffeeScript, Coco, Coq, CSS, Cucumber, CUDA, D, Dart, DocBook, Dust,
+Elixir, Erlang, eRuby, Fortran, Gentoo metadata, GLSL, Go, Haml, Haskell,
+Haxe, Handlebars, HSS, HTML, Java, JavaScript, JSON, JSX, LESS, Lex, Limbo,
+LISP, LLVM intermediate language, Lua, Markdown, MATLAB, NASM, Objective-C,
+Objective-C++, OCaml, Perl, Perl POD, PHP, gettext Portable Object, OS X and
+iOS property lists, Puppet, Python, R, Racket, Relax NG, reStructuredText, RPM
+spec, Ruby, SASS/SCSS, Scala, Slim, Tcl, TeX, Texinfo, Twig, TypeScript, Vala,
+Verilog, VHDL, VimL, xHtml, XML, XSLT, YACC, YAML, z80, Zope page templates,
+and zsh.  See the [wiki][3] for details about the corresponding supported
+checkers.
 
 Below is a screenshot showing the methods that Syntastic uses to display syntax
 errors.  Note that, in practise, you will only have a subset of these methods
@@ -63,16 +81,40 @@ enabled.
 
 ## 2\. Installation
 
-Installing syntastic is easy but first you need to have the [pathogen][1]
-plugin installed.  If you already have [pathogen][1] working then skip
-[Step 1](#step1) and go to [Step 2](#step2).
+<a name="requirements"></a>
+
+### 2.1\. Requirements
+
+Syntastic itself has rather relaxed requirements: it doesn't have any external
+dependencies, and it needs a version of [Vim][13] compiled with a few common
+features: `autocmd`, `eval`, `file_in_path`, `modify_fname`, `quickfix`,
+`reltime`, and `user_commands`. Not all possible combinations of features that
+include the ones above make equal sense on all operating systems, but Vim
+version 7 or later with the "normal", "big", or "huge" feature sets should be
+fine.
+
+Syntastic should work with any modern plugin managers for Vim, such as
+[NeoBundle][14], [Pathogen][1], [Vim-Addon-Manager][15], [Vim-Plug][16], or
+[Vundle][17]. Instructions for installing syntastic with [Pathogen][1] are
+included below for completeness.
+
+Last but not least: syntastic doesn't know how to do any syntax checks by
+itself. In order to get meaningful results you need to install external
+checkers corresponding to the types of files you use. Please consult the
+[wiki][3] for a list of supported checkers.
+
+<a name="installpathogen"></a>
 
+### 2.2\. Installing syntastic with Pathogen
+
+If you already have [Pathogen][1] working then skip [Step 1](#step1) and go to
+[Step 2](#step2).
 
 <a name="step1"></a>
 
-### 2.1\. Step 1: Install pathogen.vim
+#### 2.2.1\. Step 1: Install pathogen.vim
 
-First I'll show you how to install Tim Pope's [pathogen][1] so that it's easy to
+First I'll show you how to install Tim Pope's [Pathogen][1] so that it's easy to
 install syntastic.  Do this in your terminal so that you get the `pathogen.vim`
 file and the directories it needs:
 ```sh
@@ -86,7 +128,7 @@ execute pathogen#infect()
 
 <a name="step2"></a>
 
-### 2.2\. Step 2: Install syntastic as a pathogen bundle
+#### 2.2.2\. Step 2: Install syntastic as a Pathogen bundle
 
 You now have pathogen installed and can put syntastic into `~/.vim/bundle` like
 this:
@@ -99,21 +141,40 @@ Quit vim and start it back up to reload it, then type:
 :Helptags
 ```
 If you get an error when you do this, then you probably didn't install
-[pathogen][1] right.  Go back to [Step 1](#step1) and make sure you did the following:
+[Pathogen][1] right.  Go back to [Step 1](#step1) and make sure you did the
+following:
 
 1. Created both the `~/.vim/autoload` and `~/.vim/bundle` directories.
-2. Added the `call pathogen#infect()` line to your `~/.vimrc` file
+2. Added the `execute pathogen#infect()` line to your `~/.vimrc` file
 3. Did the `git clone` of syntastic inside `~/.vim/bundle`
 4. Have permissions to access all of these directories.
 
+<a name="settings"></a>
+
+## 3\. Recommended settings
+
+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` file, and return
+to them after reading the manual (see `:help syntastic` in Vim):
+```vim
+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
+```
 
 <a name="faq"></a>
 
-## 3\. FAQ
+## 4\. FAQ
 
 <a name="faqinfo"></a>
 
-__Q. I installed syntastic but it isn't reporting any errors...__
+__4.1. Q. I installed syntastic but it isn't reporting any errors...__
 
 A. The most likely reason is that none of the syntax checkers that it requires
 is installed. For example: by default, python requires either `flake8` or
@@ -127,9 +188,37 @@ error output for a syntax checker may have changed. In this case, make sure you
 have the latest version of the syntax checker installed. If it still fails then
 create an issue - or better yet, create a pull request.
 
+<a name="faqpython3"></a>
+
+__4.2. Q. The `python` checker complains about syntactically valid Python 3 constructs...__
+
+A. Configure the `python` checker to call a Python 3 interpreter rather than
+Python 2, e.g:
+```vim
+let g:syntastic_python_python_exec = '/path/to/python3'
+```
+
+<a name="faqhtml5"></a>
+
+__4.3. Q. Are there any local checkers for HTML5 that I can use with syntastic?__
+
+[HTML Tidy][18] has a fork named [HTML Tidy for HTML5][19].  It's a drop
+in replacement, and syntastic can use it without changes.  Just install it
+somewhere and point `g:syntastic_html_tidy_exec` to its executable.
+
+Alternatively, you can install [vnu.jar][21] from the [validator.nu][20]
+project and run it as a [HTTP server][23]:
+```sh
+$ java -Xss512k -cp /path/to/vnu.jar nu.validator.servlet.Main 8888
+```
+Then you can [configure][22] syntastic to use it:
+```vim
+let g:syntastic_html_validator_api = 'http://localhost:8888/'
+```
+
 <a name="faqperl"></a>
 
-__Q. The `perl` checker has stopped working...__
+__4.4. Q. The `perl` checker has stopped working...__
 
 A. The `perl` checker runs `perl -c` against your file, which in turn
 __executes__ any `BEGIN`, `UNITCHECK`, and `CHECK` blocks, and any `use`
@@ -138,14 +227,14 @@ wrote the file yourself, but it's a security problem if you're checking third
 party files.  Since there is currently no way to disable this behaviour while
 still producing useful results, the checker is now disabled by default.  To
 (re-)enable it, make sure the `g:syntastic_perl_checkers` list includes `perl`,
-and set `g:syntastic_enable_perl_checker` to 1 in your vimrc:
+and set `g:syntastic_enable_perl_checker` to 1 in your `vimrc`:
 ```vim
 let g:syntastic_enable_perl_checker = 1
 ```
 
 <a name="faqrust"></a>
 
-__Q. What happened to the `rustc` checker?__
+__4.5. Q. What happened to the `rustc` checker?__
 
 A. It has been included in the [Rust compiler package][12].  If you have
 a recent version of the Rust compiler, the checker should be picked up
@@ -153,26 +242,27 @@ automatically by syntastic.
 
 <a name="faqloclist"></a>
 
-__Q. I run a checker and the location list is not updated...__
+__4.6. Q. I run a checker and the location list is not updated...__  
+__4.6. Q. I run`:lopen` or `:lwindow` and the error window is empty...__
 
 A. By default the location list is changed only when you run the `:Errors`
 command, in order to minimise conflicts with other plugins.  If you want the
 location list to always be updated when you run the checkers, add this line to
-your vimrc:
+your `vimrc`:
 ```vim
 let g:syntastic_always_populate_loc_list = 1
 ```
 
 <a name="faqargs"></a>
 
-__Q. How can I pass additional arguments to a checker?__
+__4.7. Q. How can I pass additional arguments to a checker?__
 
 A. Almost all syntax checkers use the `makeprgBuild()` function. Those checkers
 that do can be configured using global variables. The general form of the
 global `args` variables is `syntastic_<filetype>_<checker>_args`.
 
-So, If you wanted to pass "--my --args --here" to the ruby mri checker you
-would add this line to your vimrc:
+So, If you wanted to pass `--my --args --here` to the ruby mri checker you
+would add this line to your `vimrc`:
 ```vim
 let g:syntastic_ruby_mri_args = "--my --args --here"
 ```
@@ -181,10 +271,10 @@ See `:help syntastic-checker-options` for more information.
 
 <a name="faqcheckers"></a>
 
-__Q. Syntastic supports several checkers for my filetype - how do I tell it
+__4.8. Q. Syntastic supports several checkers for my filetype - how do I tell it
 which one(s) to use?__
 
-A. Stick a line like this in your vimrc:
+A. Stick a line like this in your `vimrc`:
 ```vim
 let g:syntastic_<filetype>_checkers = ['<checker-name>']
 ```
@@ -200,8 +290,7 @@ To tell syntastic to use `pylint`, you would use this setting:
 let g:syntastic_python_checkers = ['pylint']
 ```
 
-Some filetypes, like PHP, have style checkers as well as syntax checkers. These
-can be chained together like this:
+Checkers can be chained together like this:
 ```vim
 let g:syntastic_php_checkers = ['php', 'phpcs', 'phpmd']
 ```
@@ -219,14 +308,44 @@ e.g. to run `phpcs` and `phpmd`:
 This works for any checkers available for the current filetype, even if they
 aren't listed in `g:syntastic_<filetype>_checkers`.  You can't run checkers for
 "foreign" filetypes though (e.g. you can't run, say, a Python checker if the
-current filetype is `php`).
+filetype of the current file is `php`).
+
+<a name="faqstyle"></a>
+
+__4.9. Q. What is the difference between syntax checkers and style checkers?__
+
+A. The errors and warnings they produce are highlighted differently and can
+be filtered by different rules, but otherwise the distinction is pretty much
+arbitrary. There is an ongoing effort to keep things consistent, so you can
+_generally_ expect messages produced by syntax checkers to be _mostly_ related
+to syntax, and messages produced by style checkers to be _mostly_ about style.
+But there can be no formal guarantee that, say, a style checker that runs into
+a syntax error wouldn't die with a fatal message, nor that a syntax checker
+wouldn't give you warnings against using some constructs as being bad practice.
+There is also no guarantee that messages marked as "style" are less severe than
+the ones marked as "syntax" (whatever that might mean). And there are even a
+few Frankenstein checkers (for example `flake8` and `pylama`) that, by their
+nature, produce both kinds of messages. Syntastic is not smart enough to be
+able to sort out these things by itself.
+
+In fact it's more useful to look at this from the perspective of filtering
+unwanted messages, rather than as an indicator of severity levels.  The
+distinction between syntax and style is orthogonal to the distinction between
+errors and warnings, and thus you can turn off messages based on level, on
+type, or both.
+
+e.g. To disable all style messages:
+```vim
+let g:syntastic_quiet_messages = { "type": "style" }
+```
+See `:help syntastic_quiet_messages` for details.
 
 <a name="faqaggregate"></a>
 
-__Q. How can I display together the errors found by all checkers enabled for
-the current file?__
+__4.10. Q. I have enabled multiple checkers for the current filetype.  How can I
+display all of the errors from all of the checkers together?__
 
-A. Set `g:syntastic_aggregate_errors` to 1 in your vimrc:
+A. Set `g:syntastic_aggregate_errors` to 1 in your `vimrc`:
 ```vim
 let g:syntastic_aggregate_errors = 1
 ```
@@ -235,35 +354,19 @@ See `:help syntastic-aggregating-errors` for more details.
 
 <a name="faqlnext"></a>
 
-__Q. How can I jump between the different errors without using the location
+__4.11. Q. How can I jump between the different errors without using the location
 list at the bottom of the window?__
 
-A. Vim provides several built in commands for this. See `:help :lnext` and
-`:help :lprev`.
+A. Vim provides several built-in commands for this. See `:help :lnext` and
+`:help :lprevious`.
 
 If you use these commands a lot then you may want to add shortcut mappings to
-your vimrc, or install something like [unimpaired][2], which provides such
+your `vimrc`, or install something like [unimpaired][2], which provides such
 mappings (among other things).
 
-<a name="faqstyle"></a>
-
-__Q. A syntax checker is giving me unwanted/strange style tips?__
-
-A. Some filetypes (e.g. php) have style checkers as well as syntax
-checkers. You can usually configure the options that are passed to the style
-checkers, or just disable them. Take a look at the [wiki][3] to see what
-options are available.
-
-Alternatively, you can use `g:syntastic_quiet_messages` to filter out the
-messages you don't want to see. e.g. To turn off all style messages:
-```vim
-let g:syntastic_quiet_messages = { "type": "style" }
-```
-See `:help syntastic_quiet_messages` for details.
-
 <a name="faqbdelete"></a>
 
-__Q. The error window is closed automatically when I :quit the current buffer
+__4.12. Q. The error window is closed automatically when I :quit the current buffer
 but not when I :bdelete it?__
 
 A. There is no safe way to handle that situation automatically, but you can
@@ -274,10 +377,9 @@ nnoremap <silent> <C-d> :lclose<CR>:bdelete<CR>
 cabbrev <silent> bd lclose\|bdelete
 ```
 
-
 <a name="otherresources"></a>
 
-## 4\. Other resources
+## 5\. Resources
 
 The preferred place for posting suggestions, reporting bugs, and general
 discussions related to syntastic is the [issue tracker at GitHub][4].
@@ -303,3 +405,18 @@ a look at [jedi-vim][7], [python-mode][8], or [YouCompleteMe][9].
 [10]: http://perldoc.perl.org/perlrun.html#*-c*
 [11]: https://github.com/scrooloose/syntastic/wiki/Syntax-Checker-Guide
 [12]: https://github.com/rust-lang/rust/
+[13]: http://www.vim.org/
+[14]: https://github.com/Shougo/neobundle.vim
+[15]: https://github.com/MarcWeber/vim-addon-manager
+[16]: https://github.com/junegunn/vim-plug/
+[17]: https://github.com/gmarik/Vundle.vim
+[18]: http://tidy.sourceforge.net/
+[19]: http://w3c.github.io/tidy-html5/
+[20]: http://about.validator.nu/
+[21]: https://github.com/validator/validator/releases/latest
+[22]: https://github.com/scrooloose/syntastic/wiki/HTML%3A---validator
+[23]: http://validator.github.io/validator/#standalone
+
+<!--
+vim:tw=79:sw=4:
+-->

vim/bundle/syntastic/autoload/syntastic/c.vim

@@ -18,9 +18,17 @@ 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) " {{{2
-    " search in the current file's directory upwards
+    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 == '' || !filereadable(config)
+    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
 
@@ -31,6 +39,7 @@ function! syntastic#c#ReadConfig(file) " {{{2
     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
 
@@ -62,7 +71,7 @@ endfunction " }}}2
 " GetLocList() for C-like compilers
 function! syntastic#c#GetLocList(filetype, subchecker, options) " {{{2
     try
-        let flags = s:_getCflags(a:filetype, a:subchecker, a:options)
+        let flags = s:_get_cflags(a:filetype, a:subchecker, a:options)
     catch /\m\C^Syntastic: skip checks$/
         return []
     endtry
@@ -70,9 +79,9 @@ function! syntastic#c#GetLocList(filetype, subchecker, options) " {{{2
     let makeprg = syntastic#util#shexpand(g:syntastic_{a:filetype}_compiler) .
         \ ' ' . flags . ' ' . syntastic#util#shexpand('%')
 
-    let errorformat = s:_getCheckerVar('g', a:filetype, a:subchecker, 'errorformat', a:options['errorformat'])
+    let errorformat = s:_get_checker_var('g', a:filetype, a:subchecker, 'errorformat', a:options['errorformat'])
 
-    let postprocess = s:_getCheckerVar('g', a:filetype, a:subchecker, 'remove_include_errors', 0) ?
+    let postprocess = s:_get_checker_var('g', a:filetype, a:subchecker, 'remove_include_errors', 0) ?
         \ ['filterForeignErrors'] : []
 
     " process makeprg
@@ -91,25 +100,25 @@ function! s:_init() " {{{2
     let s:handlers = []
     let s:cflags = {}
 
-    call s:_regHandler('\m\<cairo',       'syntastic#c#checkPKG', ['cairo', 'cairo'])
-    call s:_regHandler('\m\<freetype',    'syntastic#c#checkPKG', ['freetype', 'freetype2', 'freetype'])
-    call s:_regHandler('\m\<glade',       'syntastic#c#checkPKG', ['glade', 'libglade-2.0', 'libglade'])
-    call s:_regHandler('\m\<glib',        'syntastic#c#checkPKG', ['glib', 'glib-2.0', 'glib'])
-    call s:_regHandler('\m\<gtk',         'syntastic#c#checkPKG', ['gtk', 'gtk+-2.0', 'gtk+', 'glib-2.0', 'glib'])
-    call s:_regHandler('\m\<libsoup',     'syntastic#c#checkPKG', ['libsoup', 'libsoup-2.4', 'libsoup-2.2'])
-    call s:_regHandler('\m\<libxml',      'syntastic#c#checkPKG', ['libxml', 'libxml-2.0', 'libxml'])
-    call s:_regHandler('\m\<pango',       'syntastic#c#checkPKG', ['pango', 'pango'])
-    call s:_regHandler('\m\<SDL',         'syntastic#c#checkPKG', ['sdl', 'sdl'])
-    call s:_regHandler('\m\<opengl',      'syntastic#c#checkPKG', ['opengl', 'gl'])
-    call s:_regHandler('\m\<webkit',      'syntastic#c#checkPKG', ['webkit', 'webkit-1.0'])
-
-    call s:_regHandler('\m\<php\.h\>',    'syntastic#c#checkPHP',    [])
-    call s:_regHandler('\m\<Python\.h\>', 'syntastic#c#checkPython', [])
-    call s:_regHandler('\m\<ruby',        'syntastic#c#checkRuby',   [])
+    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
 
-" return a handler dictionary object
-function! s:_regHandler(regex, function, args) " {{{2
+" register a handler dictionary object
+function! s:_registerHandler(regex, function, args) " {{{2
     let handler = {}
     let handler["regex"] = a:regex
     let handler["func"] = function(a:function)
@@ -117,8 +126,75 @@ function! s:_regHandler(regex, function, args) " {{{2
     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, ...) " {{{2
+    if executable('pkg-config')
+        if !has_key(s:cflags, a:name)
+            for pkg in a:000
+                let pkg_flags = 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() " {{{2
+    if executable('php-config')
+        if !has_key(s:cflags, 'php')
+            let s:cflags['php'] = 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() " {{{2
+    if executable('python')
+        if !has_key(s:cflags, 'python')
+            let s:cflags['python'] = 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() " {{{2
+    if executable('ruby')
+        if !has_key(s:cflags, 'ruby')
+            let s:cflags['ruby'] = 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:_getCheckerVar(scope, filetype, subchecker, name, default) " {{{2
+function! s:_get_checker_var(scope, filetype, subchecker, name, default) " {{{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}
@@ -130,10 +206,10 @@ function! s:_getCheckerVar(scope, filetype, subchecker, name, default) " {{{2
 endfunction " }}}2
 
 " resolve user CFLAGS
-function! s:_getCflags(ft, ck, opts) " {{{2
+function! s:_get_cflags(ft, ck, opts) " {{{2
     " determine whether to parse header files as well
-    if has_key(a:opts, 'header_names') && expand('%') =~? a:opts['header_names']
-        if s:_getCheckerVar('g', a:ft, a:ck, 'check_header', 0)
+    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
@@ -143,21 +219,21 @@ function! s:_getCflags(ft, ck, opts) " {{{2
         let flags = get(a:opts, 'main_flags', '')
     endif
 
-    let flags .= ' ' . s:_getCheckerVar('g', a:ft, a:ck, 'compiler_options', '') . ' ' . s:_getIncludeDirs(a:ft)
+    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:_getCheckerVar('b', a:ft, a:ck, 'cflags', '')
+    let b_cflags = s:_get_checker_var('b', a:ft, a:ck, 'cflags', '')
     if b_cflags == ''
         " check whether to search for include files at all
-        if !s:_getCheckerVar('g', a:ft, a:ck, 'no_include_search', 0)
+        if !s:_get_checker_var('g', a:ft, a:ck, 'no_include_search', 0)
             if a:ft ==# 'c' || a:ft ==# 'cpp'
                 " refresh the include file search if desired
-                if s:_getCheckerVar('g', a:ft, a:ck, 'auto_refresh_includes', 0)
-                    let flags .= ' ' . s:_searchHeaders()
+                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:_searchHeaders()
+                        let b:syntastic_{a:ft}_includes = s:_search_headers()
                     endif
                     let flags .= ' ' . b:syntastic_{a:ft}_includes
                 endif
@@ -169,7 +245,7 @@ function! s:_getCflags(ft, ck, opts) " {{{2
     endif
 
     " add optional config file parameters
-    let config_file = s:_getCheckerVar('g', a:ft, a:ck, 'config_file', '.syntastic_' . a:ft . '_config')
+    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
@@ -177,7 +253,7 @@ 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:_getIncludeDirs(filetype) " {{{2
+function! s:_get_include_dirs(filetype) " {{{2
     let include_dirs = []
 
     if a:filetype =~# '\v^%(c|cpp|objc|objcpp)$' &&
@@ -195,7 +271,7 @@ endfunction " }}}2
 
 " search the first 100 lines for include statements that are
 " given in the handlers dictionary
-function! s:_searchHeaders() " {{{2
+function! s:_search_headers() " {{{2
     let includes = ''
     let files = []
     let found = []
@@ -221,7 +297,7 @@ function! s:_searchHeaders() " {{{2
     " search included headers
     for hfile in files
         if hfile != ''
-            let filename = expand('%:p:h') . syntastic#util#Slash() . hfile
+            let filename = expand('%:p:h', 1) . syntastic#util#Slash() . hfile
 
             try
                 let lines = readfile(filename, '', 100)
@@ -250,69 +326,6 @@ function! s:_searchHeaders() " {{{2
     return includes
 endfunction " }}}2
 
-" try to find library with 'pkg-config'
-" search possible libraries from first to last given
-" argument until one is found
-function! syntastic#c#checkPKG(name, ...) " {{{2
-    if executable('pkg-config')
-        if !has_key(s:cflags, a:name)
-            for pkg in a:000
-                let pkg_flags = 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! syntastic#c#checkPHP() " {{{2
-    if executable('php-config')
-        if !has_key(s:cflags, 'php')
-            let s:cflags['php'] = 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 ruby headers with 'rbconfig'
-function! syntastic#c#checkRuby() " {{{2
-    if executable('ruby')
-        if !has_key(s:cflags, 'ruby')
-            let s:cflags['ruby'] = 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
-
-" try to find the python headers with distutils
-function! syntastic#c#checkPython() " {{{2
-    if executable('python')
-        if !has_key(s:cflags, 'python')
-            let s:cflags['python'] = 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
-
 " }}}1
 
 " default include directories

vim/bundle/syntastic/autoload/syntastic/log.vim

@@ -61,11 +61,11 @@ endfunction " }}}2
 " @vimlint(EVL102, 0, l:OLD_VAR)
 
 function! syntastic#log#debug(level, msg, ...) " {{{2
-    if !s:isDebugEnabled(a:level)
+    if !s:_isDebugEnabled(a:level)
         return
     endif
 
-    let leader = s:_logTimestamp()
+    let leader = s:_log_timestamp()
     call s:_logRedirect(1)
 
     if a:0 > 0
@@ -81,11 +81,11 @@ function! syntastic#log#debug(level, msg, ...) " {{{2
 endfunction " }}}2
 
 function! syntastic#log#debugShowOptions(level, names) " {{{2
-    if !s:isDebugEnabled(a:level)
+    if !s:_isDebugEnabled(a:level)
         return
     endif
 
-    let leader = s:_logTimestamp()
+    let leader = s:_log_timestamp()
     call s:_logRedirect(1)
 
     let vlist = copy(type(a:names) == type("") ? [a:names] : a:names)
@@ -97,16 +97,16 @@ function! syntastic#log#debugShowOptions(level, names) " {{{2
 endfunction " }}}2
 
 function! syntastic#log#debugShowVariables(level, names) " {{{2
-    if !s:isDebugEnabled(a:level)
+    if !s:_isDebugEnabled(a:level)
         return
     endif
 
-    let leader = s:_logTimestamp()
+    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:_formatVariable(name)
+        let msg = s:_format_variable(name)
         if msg != ''
             echomsg leader . msg
         endif
@@ -116,11 +116,11 @@ function! syntastic#log#debugShowVariables(level, names) " {{{2
 endfunction " }}}2
 
 function! syntastic#log#debugDump(level) " {{{2
-    if !s:isDebugEnabled(a:level)
+    if !s:_isDebugEnabled(a:level)
         return
     endif
 
-    call syntastic#log#debugShowVariables( a:level, sort(keys(g:syntastic_defaults)) )
+    call syntastic#log#debugShowVariables( a:level, sort(keys(g:_SYNTASTIC_DEFAULTS)) )
 endfunction " }}}2
 
 " }}}1
@@ -136,14 +136,14 @@ function! s:_isDebugEnabled_dumb(level) " {{{2
     return (g:syntastic_debug / a:level) % 2
 endfunction " }}}2
 
-let s:isDebugEnabled = function(exists('*and') ? 's:_isDebugEnabled_smart' : 's:_isDebugEnabled_dumb')
-lockvar s:isDebugEnabled
+let s:_isDebugEnabled = function(exists('*and') ? 's:_isDebugEnabled_smart' : 's:_isDebugEnabled_dumb')
+lockvar s:_isDebugEnabled
 
 function! s:_logRedirect(on) " {{{2
     if exists("g:syntastic_debug_file")
         if a:on
             try
-                execute 'redir >> ' . fnameescape(expand(g:syntastic_debug_file))
+                execute 'redir >> ' . fnameescape(expand(g:syntastic_debug_file, 1))
             catch /\m^Vim\%((\a\+)\)\=:/
                 silent! redir END
                 unlet g:syntastic_debug_file
@@ -154,11 +154,15 @@ function! s:_logRedirect(on) " {{{2
     endif
 endfunction " }}}2
 
-function! s:_logTimestamp() " {{{2
-    return 'syntastic: ' . split(reltimestr(reltime(g:syntastic_start)))[0] . ': '
+" }}}1
+
+" Utilities {{{1
+
+function! s:_log_timestamp() " {{{2
+    return 'syntastic: ' . split(reltimestr(reltime(g:_SYNTASTIC_START)))[0] . ': '
 endfunction " }}}2
 
-function! s:_formatVariable(name) " {{{2
+function! s:_format_variable(name) " {{{2
     let vals = []
     if exists('g:syntastic_' . a:name)
         call add(vals, 'g:syntastic_' . a:name . ' = ' . strtrans(string(g:syntastic_{a:name})))

vim/bundle/syntastic/autoload/syntastic/postprocess.vim

@@ -46,6 +46,25 @@ function! syntastic#postprocess#filterForeignErrors(errors) " {{{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) " {{{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

vim/bundle/syntastic/autoload/syntastic/preprocess.vim

@@ -30,7 +30,7 @@ endfunction " }}}2
 
 function! syntastic#preprocess#checkstyle(errors) " {{{2
     let out = []
-    let fname = expand('%')
+    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"'))
@@ -59,6 +59,70 @@ function! syntastic#preprocess#cppcheck(errors) " {{{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) " {{{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'] ? 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) " {{{2
     return filter(copy(a:errors), 'v:val != ""')
 endfunction " }}}2
@@ -67,7 +131,7 @@ function! syntastic#preprocess#perl(errors) " {{{2
     let out = []
 
     for e in a:errors
-        let parts = matchlist(e, '\v^(.*)\sat\s(.*)\sline\s(\d+)(.*)$')
+        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
@@ -76,6 +140,62 @@ function! syntastic#preprocess#perl(errors) " {{{2
     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) " {{{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') && 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
+
+    return out
+endfunction " }}}2
+" @vimlint(EVL102, 0, l:true)
+" @vimlint(EVL102, 0, l:false)
+" @vimlint(EVL102, 0, l:null)
+
 function! syntastic#preprocess#rparse(errors) " {{{2
     let errlist = copy(a:errors)
 

vim/bundle/syntastic/autoload/syntastic/util.vim

@@ -24,6 +24,66 @@ function! syntastic#util#Slash() abort " {{{2
     return (!exists("+shellslash") || &shellslash) ? '/' : '\'
 endfunction " }}}2
 
+" Create a temporary directory
+function! syntastic#util#tmpdir() " {{{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(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 = s: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) " {{{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 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
 "
@@ -61,12 +121,6 @@ function! syntastic#util#parseVersion(version) " {{{2
     return map(split(matchstr( a:version, '\v^\D*\zs\d+(\.\d+)+\ze' ), '\m\.'), 'str2nr(v:val)')
 endfunction " }}}2
 
-" Run 'command' in a shell and parse output as a version string.
-" Returns an array of version components.
-function! syntastic#util#getVersion(command) " {{{2
-    return syntastic#util#parseVersion(system(a:command))
-endfunction " }}}2
-
 " Verify that the 'installed' version is at least the 'required' version.
 "
 " 'installed' and 'required' must be arrays. If they have different lengths,
@@ -93,14 +147,14 @@ 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
+let s:_width = function(exists('*strwidth') ? 'strwidth' : 'strlen')
+lockvar s:_width
 
 function! syntastic#util#screenWidth(str, tabstop) " {{{2
     let chunks = split(a:str, "\t", 1)
-    let width = s:width(chunks[-1])
+    let width = s:_width(chunks[-1])
     for c in chunks[:-2]
-        let cwidth = s:width(c)
+        let cwidth = s:_width(c)
         let width += cwidth + a:tabstop - cwidth % a:tabstop
     endfor
     return width
@@ -118,7 +172,7 @@ function! syntastic#util#wideMsg(msg) " {{{2
     "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 = 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
@@ -164,7 +218,7 @@ function! syntastic#util#findInParent(what, where) " {{{2
 
     let old = ''
     while here != ''
-        let p = split(globpath(here, a:what), '\n')
+        let p = split(globpath(here, a:what, 1), '\n')
 
         if !empty(p)
             return fnamemodify(p[0], ':p')
@@ -201,8 +255,19 @@ function! syntastic#util#shescape(string) " {{{2
 endfunction " }}}2
 
 " A less noisy shellescape(expand())
-function! syntastic#util#shexpand(string) " {{{2
-    return syntastic#util#shescape(expand(a:string))
+function! syntastic#util#shexpand(string, ...) " {{{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) " {{{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
@@ -226,7 +291,7 @@ endfunction " }}}2
 
 function! syntastic#util#dictFilter(errors, filter) " {{{2
     let rules = s:_translateFilter(a:filter)
-    " call syntastic#log#debug(g:SyntasticDebugFilters, "applying filter:", rules)
+    " call syntastic#log#debug(g:_SYNTASTIC_DEBUG_TRACE, "applying filter:", rules)
     try
         call filter(a:errors, rules)
     catch /\m^Vim\%((\a\+)\)\=:E/
@@ -239,7 +304,7 @@ endfunction " }}}2
 " (hopefully high resolution) since program start
 " TODO: This assumes reltime() returns a list of integers.
 function! syntastic#util#stamp() " {{{2
-    return reltime(g:syntastic_start)
+    return reltime(g:_SYNTASTIC_START)
 endfunction " }}}2
 
 " }}}1
@@ -263,21 +328,62 @@ function! s:_translateFilter(filters) " {{{2
 endfunction " }}}2
 
 function! s:_translateElement(key, term) " {{{2
-    if a:key ==? 'level'
-        let ret = 'v:val["type"] !=? ' . string(a:term[0])
-    elseif a:key ==? 'type'
-        let ret = a:term ==? 'style' ? 'get(v:val, "subtype", "") !=? "style"' : 'has_key(v:val, "subtype")'
-    elseif a:key ==? 'regex'
-        let ret = 'v:val["text"] !~? ' . string(a:term)
-    elseif a:key ==? 'file'
-        let ret = 'bufname(str2nr(v:val["bufnr"])) !~# ' . string(a:term)
+    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(a:key)))
+        call syntastic#log#warn('quiet_messages: ignoring invalid key ' . strtrans(string(fkey)))
         let ret = "1"
     endif
     return ret
 endfunction " }}}2
 
+function! s:_rmrf(what) " {{{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 system(s:rmdir . ' ' . syntastic#util#shescape(a:what))
+    else
+        silent! call delete(a:what)
+    endif
+endfunction " }}}2
+
 " }}}1
 
 let &cpo = s:save_cpo

vim/bundle/syntastic/doc/syntastic.txt

@@ -21,6 +21,7 @@ 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|
@@ -34,6 +35,7 @@ CONTENTS                                                  *syntastic-contents*
         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|
@@ -44,6 +46,7 @@ CONTENTS                                                  *syntastic-contents*
         6.7.Using syntastic with the fizsh shell...|syntastic-fizsh|
         6.8.Interaction with Eclim.................|syntastic-eclim|
         6.9.Interaction with vim-virtualenv........|syntastic-vim-virtualenv|
+        6.10.Interaction with vim-auto-save........|syntastic-vim-auto-save|
     7.About........................................|syntastic-about|
     8.License......................................|syntastic-license|
 
@@ -67,7 +70,7 @@ 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:
+checker integrations, see the guide on the GitHub wiki:
 
     https://github.com/scrooloose/syntastic/wiki/Syntax-Checker-Guide
 
@@ -78,17 +81,40 @@ 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 checkers available for the current filetype with the
+You can see the list of checkers available for the current filetype with the
 |:SyntasticInfo| command.
 
-If you want to override the configured list of checkers for a filetype then
-see |syntastic-checker-options| for details. You can also change the arguments
-passed to a specific checker as well.
+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 |:SyntasticToggleMode|
-to switch between active (checking on writing the buffer) and passive (manual)
-checking.
+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*
 
@@ -155,13 +181,22 @@ Example: >
     highlight SyntasticErrorLine guibg=#2f0000
 <
 ------------------------------------------------------------------------------
-2.3. The error window                         *:Errors* *syntastic-error-window*
+2.3. The error window                                   *syntastic-error-window*
 
-You can use the :Errors command to display the errors for the current buffer
+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.
+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*
@@ -198,7 +233,8 @@ 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.
+grouped together, and sorting within each group is decided by the variables
+|'syntastic_<filetype>_<checker>_sort'|.
 
 ------------------------------------------------------------------------------
 2.6 Filtering errors                              *syntastic-filtering-errors*
@@ -212,11 +248,14 @@ See also: |'syntastic_<filetype>_<checker>_quiet_messages'|.
 ==============================================================================
 3. Commands                                               *syntastic-commands*
 
-:Errors                                                     *:SyntasticErrors*
+: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'|
@@ -239,7 +278,7 @@ the order specified.  The rules of |syntastic_aggregate_errors| still apply.
 Example: >
     :SyntasticCheck flake8 pylint
 <
-:SyntasticInfo                                               *:SyntasticInfo*
+: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
@@ -367,12 +406,17 @@ 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. >
+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
@@ -409,8 +453,9 @@ 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" }
+    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: >
@@ -420,15 +465,15 @@ default behaviour of running both checkers against the input file: >
 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"] }
+    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
@@ -444,31 +489,49 @@ 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": "warnings",
-                                     \ "type":  "style",
-                                     \ "regex": '\m\[C03\d\d\]',
-                                     \ "file":  ['\m^/usr/include/', '\m\c\.h$'] }
+    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 can omit adding the brackets (e.g. you can write "style" instead
-of ["style"]). Elements with values [] or '' are ignored (this is useful for
+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 filename the error refers to, as a case
-              sensitive |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.
@@ -518,6 +581,12 @@ statusline: >
 <
 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
@@ -526,16 +595,24 @@ 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_debug'*
 Default: 0
 Set this to the sum of one or more of the following flags to enable
 debugging:
 
-     1 - trace checker calls
+     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
@@ -593,11 +670,19 @@ 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 used by a checker is normally defined automatically, when the
-checkers is registered. You can however override it by setting the variable
+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*
 
@@ -622,21 +707,20 @@ 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 a space, e.g.: >
-    let g:syntastic_javascript_jslint_args = " "
+you can set it to an empty string, e.g.: >
+    let g:syntastic_javascript_jslint_args = ""
 <
-(setting it to an empty string doesn't work, for implementation reasons).
-
                                         *'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 additional parameters, e.g. to tell the mri checker to use KANJI
-encoding you could do something like this: >
-    let g:syntastic_ruby_mri_exe = 'RUBYOPT="-Ke" ruby'
+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_ruby_mri_args = "--my --args --here"
-    let g:syntastic_ruby_mri_tail = "> /tmp/my-output-file-biatch"
+    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>
@@ -651,11 +735,31 @@ options that can be set, these are usually documented in the wiki:
 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\]' }
+    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*
 
@@ -693,7 +797,7 @@ for python in syntastic (see |syntastic_mode_map|), or disable lint checks in
 
 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"
+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.: >
@@ -735,11 +839,15 @@ interactive features of 'fizsh'. Using a more traditional shell such as "zsh",
 ------------------------------------------------------------------------------
 6.8. Interaction with Eclim                                  *syntastic-eclim*
 
-As far as syntastic is concerned there shouldn't be any compatibility problems
-with the 'Eclim' Vim plugin (see http://eclim.org/). However, at the time of
-this writing there are several reports that 'Eclim' triggers a bug in Vim that
-makes syntastic forget some of its configuration parameters. No solutions or
-workarounds are known for now.
+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.
 
 ------------------------------------------------------------------------------
 6.9. Interaction with vim-virtualenv                *syntastic-vim-virtualenv*
@@ -749,13 +857,26 @@ in Python virtual environments activated by 'vim-virtualenv' (see
 https://github.com/jmcantrell/vim-virtualenv).  This is a limitation of
 'vim-virtualenv'.
 
+------------------------------------------------------------------------------
+6.10. Interaction with vim-auto-save                 *syntastic-vim-auto-save*
+
+At the time of this writing, syntastic checks in active mode are not triggered
+by 'vim-auto-save' (see https://github.com/907th/vim-auto-save). The reason is
+a limitation in 'vim-auto-save', namely a missing flag to an 'autocmd' (see
+|autocmd-nested|). Fortunately it's pretty easy to achieve a similar effect
+without 'vim-auto-save'': >
+    augroup syntastic
+        autocmd CursorHold * nested update
+    augroup END
+    set updatetime=200
+<
 ==============================================================================
 7. About                                                     *syntastic-about*
 
 The core maintainers of syntastic are:
-    Martin Grenfell (github: scrooloose)
-    Gregor Uhlenheuer (github: kongo2002)
-    LCD 047 (github: lcd047)
+    Martin Grenfell (GitHub: scrooloose)
+    Gregor Uhlenheuer (GitHub: kongo2002)
+    LCD 047 (GitHub: lcd047)
 
 Find the latest version of syntastic at:
 

vim/bundle/syntastic/plugin/syntastic.vim

@@ -15,45 +15,53 @@ endif
 let g:loaded_syntastic_plugin = 1
 
 if has('reltime')
-    let g:syntastic_start = reltime()
-    lockvar! g:syntastic_start
+    let g:_SYNTASTIC_START = reltime()
+    lockvar! g:_SYNTASTIC_START
 endif
 
-let g:syntastic_version = '3.4.0-117'
-lockvar g:syntastic_version
+let g:_SYNTASTIC_VERSION = '3.6.0-5'
+lockvar g:_SYNTASTIC_VERSION
 
 " Sanity checks {{{1
 
-for s:feature in ['autocmd', 'eval', 'modify_fname', 'quickfix', 'reltime', 'user_commands']
+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
+let s:_running_windows = syntastic#util#isRunningWindows()
+lockvar s:_running_windows
 
-if !s:running_windows && executable('uname')
+if !s:_running_windows && executable('uname')
     try
-        let s:uname = system('uname')
+        let s:_uname = system('uname')
     catch /\m^Vim\%((\a\+)\)\=:E484/
-        call syntastic#log#error("your shell " . &shell . " doesn't use traditional UNIX syntax for redirections")
+        call syntastic#log#error("your shell " . &shell . " can't handle traditional UNIX syntax for redirections")
         finish
     endtry
-    lockvar s:uname
+    lockvar s:_uname
 endif
 
 " }}}1
 
 " Defaults {{{1
 
-let g:syntastic_defaults = {
+let g:_SYNTASTIC_DEFAULTS = {
         \ 'aggregate_errors':         0,
         \ 'always_populate_loc_list': 0,
         \ 'auto_jump':                0,
         \ 'auto_loc_list':            2,
-        \ 'bash_hack':                1,
+        \ 'bash_hack':                0,
         \ 'check_on_open':            0,
         \ 'check_on_wq':              1,
         \ 'cursor_columns':           1,
@@ -63,6 +71,7 @@ let g:syntastic_defaults = {
         \ 'enable_highlighting':      1,
         \ 'enable_signs':             1,
         \ 'error_symbol':             '>>',
+        \ 'exit_checks':              !(s:_running_windows && &shell =~? '\m\<cmd\.exe$'),
         \ 'filetype_map':             {},
         \ 'full_redraws':             !(has('gui_running') || has('gui_macvim')),
         \ 'id_checkers':              1,
@@ -77,11 +86,11 @@ let g:syntastic_defaults = {
         \ 'style_warning_symbol':     'S>',
         \ 'warning_symbol':           '>>'
     \ }
-lockvar! g:syntastic_defaults
+lockvar! g:_SYNTASTIC_DEFAULTS
 
-for s:key in keys(g:syntastic_defaults)
+for s:key in keys(g:_SYNTASTIC_DEFAULTS)
     if !exists('g:syntastic_' . s:key)
-        let g:syntastic_{s:key} = g:syntastic_defaults[s:key]
+        let g:syntastic_{s:key} = copy(g:_SYNTASTIC_DEFAULTS[s:key])
     endif
 endfor
 
@@ -101,7 +110,7 @@ endif
 
 " Debug {{{1
 
-let s:debug_dump_options = [
+let s:_DEBUG_DUMP_OPTIONS = [
         \ 'shell',
         \ 'shellcmdflag',
         \ 'shellpipe',
@@ -112,21 +121,23 @@ let s:debug_dump_options = [
         \ 'shellxquote'
     \ ]
 if v:version > 703 || (v:version == 703 && has('patch446'))
-    call add(s:debug_dump_options, 'shellxescape')
+    call add(s:_DEBUG_DUMP_OPTIONS, 'shellxescape')
 endif
-lockvar! s:debug_dump_options
+lockvar! s:_DEBUG_DUMP_OPTIONS
 
 " debug constants
-let     g:SyntasticDebugTrace         = 1
-lockvar g:SyntasticDebugTrace
-let     g:SyntasticDebugLoclist       = 2
-lockvar g:SyntasticDebugLoclist
-let     g:SyntasticDebugNotifications = 4
-lockvar g:SyntasticDebugNotifications
-let     g:SyntasticDebugAutocommands  = 8
-lockvar g:SyntasticDebugAutocommands
-let     g:SyntasticDebugVariables     = 16
-lockvar g:SyntasticDebugVariables
+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
 
@@ -143,7 +154,7 @@ let s:modemap = g:SyntasticModeMap.Instance()
 " @vimlint(EVL103, 1, a:argLead)
 function! s:CompleteCheckerName(argLead, cmdLine, cursorPos) " {{{2
     let checker_names = []
-    for ft in s:resolveFiletypes()
+    for ft in s:_resolve_filetypes([])
         call extend(checker_names, s:registry.getNamesOfAvailableCheckers(ft))
     endfor
     return join(checker_names, "\n")
@@ -163,27 +174,56 @@ endfunction " }}}2
 " @vimlint(EVL103, 0, a:cmdLine)
 " @vimlint(EVL103, 0, a:argLead)
 
-command! SyntasticToggleMode call s:ToggleMode()
-command! -nargs=* -complete=custom,s:CompleteCheckerName SyntasticCheck
-            \ call s:UpdateErrors(0, <f-args>) <bar>
-            \ call syntastic#util#redraw(g:syntastic_full_redraws)
-command! Errors call s:ShowLocList()
-command! -nargs=? -complete=custom,s:CompleteFiletypes SyntasticInfo
-            \ call s:modemap.modeInfo(<f-args>) |
-            \ call s:registry.echoInfoFor(s:resolveFiletypes(<f-args>))
-command! SyntasticReset
-            \ call s:ClearCache() |
-            \ call s:notifiers.refresh(g:SyntasticLoclist.New([]))
-command! SyntasticSetLoclist call g:SyntasticLoclist.current().setloclist()
+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
 
-" Autocommands and hooks {{{1
+" Public API {{{1
+
+function! SyntasticCheck(...) " {{{2
+    call s:UpdateErrors(0, a:000)
+    call syntastic#util#redraw(g:syntastic_full_redraws)
+endfunction " }}}2
+
+function! SyntasticInfo(...) " {{{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() " {{{2
+    call g:SyntasticLoclist.current().show()
+endfunction " }}}2
+
+function! SyntasticReset() " {{{2
+    call s:ClearCache()
+    call s:notifiers.refresh(g:SyntasticLoclist.New([]))
+endfunction " }}}2
+
+function! SyntasticToggleMode() " {{{2
+    call s:modemap.toggleMode()
+    call s:ClearCache()
+    call s:notifiers.refresh(g:SyntasticLoclist.New([]))
+    call s:modemap.echoMode()
+endfunction " }}}2
+
+function! SyntasticSetLoclist() " {{{2
+    call g:SyntasticLoclist.current().setloclist()
+endfunction " }}}2
+
+" }}}1
+
+" Autocommands {{{1
 
 augroup syntastic
-    autocmd BufReadPost * call s:BufReadPostHook()
+    autocmd BufReadPost  * call s:BufReadPostHook()
     autocmd BufWritePost * call s:BufWritePostHook()
-    autocmd BufEnter * call s:BufEnterHook()
+    autocmd BufEnter     * call s:BufEnterHook()
 augroup END
 
 if v:version > 703 || (v:version == 703 && has('patch544'))
@@ -195,20 +235,20 @@ endif
 
 function! s:BufReadPostHook() " {{{2
     if g:syntastic_check_on_open
-        call syntastic#log#debug(g:SyntasticDebugAutocommands,
+        call syntastic#log#debug(g:_SYNTASTIC_DEBUG_AUTOCOMMANDS,
             \ 'autocmd: BufReadPost, buffer ' . bufnr("") . ' = ' . string(bufname(str2nr(bufnr("")))))
-        call s:UpdateErrors(1)
+        call s:UpdateErrors(1, [])
     endif
 endfunction " }}}2
 
 function! s:BufWritePostHook() " {{{2
-    call syntastic#log#debug(g:SyntasticDebugAutocommands,
+    call syntastic#log#debug(g:_SYNTASTIC_DEBUG_AUTOCOMMANDS,
         \ 'autocmd: BufWritePost, buffer ' . bufnr("") . ' = ' . string(bufname(str2nr(bufnr("")))))
-    call s:UpdateErrors(1)
+    call s:UpdateErrors(1, [])
 endfunction " }}}2
 
 function! s:BufEnterHook() " {{{2
-    call syntastic#log#debug(g:SyntasticDebugAutocommands,
+    call syntastic#log#debug(g:_SYNTASTIC_DEBUG_AUTOCOMMANDS,
         \ 'autocmd: BufEnter, buffer ' . bufnr("") . ' = ' . string(bufname(str2nr(bufnr("")))) .
         \ ', &buftype = ' . string(&buftype))
     if &buftype == ''
@@ -220,17 +260,19 @@ function! s:BufEnterHook() " {{{2
         let loclist = filter(copy(getloclist(0)), 'v:val["valid"] == 1')
         let owner = str2nr(getbufvar(bufnr(""), 'syntastic_owner_buffer'))
         let buffers = syntastic#util#unique(map(loclist, 'v:val["bufnr"]') + (owner ? [owner] : []))
-        if !empty(loclist) && empty(filter( buffers, 'syntastic#util#bufIsActive(v:val)' ))
+        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() " {{{2
-    call syntastic#log#debug(g:SyntasticDebugAutocommands,
+    call syntastic#log#debug(g:_SYNTASTIC_DEBUG_AUTOCOMMANDS,
         \ 'autocmd: QuitPre, buffer ' . bufnr("") . ' = ' . string(bufname(str2nr(bufnr("")))))
-    let b:syntastic_skip_checks = !g:syntastic_check_on_wq
-    call SyntasticLoclistHide()
+    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
@@ -238,40 +280,46 @@ endfunction " }}}2
 " Main {{{1
 
 "refresh and redraw all the error info for this buf when saving or reading
-function! s:UpdateErrors(auto_invoked, ...) " {{{2
-    call syntastic#log#debugShowVariables(g:SyntasticDebugTrace, 'version')
-    call syntastic#log#debugShowOptions(g:SyntasticDebugTrace, s:debug_dump_options)
-    call syntastic#log#debugDump(g:SyntasticDebugVariables)
-    call syntastic#log#debug(g:SyntasticDebugTrace, 'UpdateErrors' . (a:auto_invoked ? ' (auto)' : '') .
-        \ ': ' . (a:0 ? join(a:000) : 'default checkers'))
-    if s:skipFile()
+function! s:UpdateErrors(auto_invoked, checker_names) " {{{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.allowsAutoChecking(&filetype)
+    let run_checks = !a:auto_invoked || s:modemap.doAutoChecking()
     if run_checks
-        call s:CacheErrors(a:000)
+        call s:CacheErrors(a:checker_names)
     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')
+    let do_jump = syntastic#util#var('auto_jump') + 0
     if do_jump == 2
-        let first = loclist.getFirstIssue()
-        let type = get(first, 'type', '')
-        let do_jump = type ==? 'E'
+        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:SyntasticDebugNotifications, 'loclist: setloclist (new)')
+        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:SyntasticDebugNotifications, 'loclist: jump')
-            silent! lrewind
+            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
@@ -295,18 +343,18 @@ endfunction " }}}2
 
 "detect and cache all syntax errors in this buffer
 function! s:CacheErrors(checker_names) " {{{2
-    call syntastic#log#debug(g:SyntasticDebugTrace, 'CacheErrors: ' .
+    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:skipFile()
+    if !s:_skip_file()
         " debug logging {{{3
-        call syntastic#log#debugShowVariables(g:SyntasticDebugTrace, 'aggregate_errors')
-        call syntastic#log#debug(g:SyntasticDebugTrace, 'getcwd() = ' . getcwd())
+        call syntastic#log#debugShowVariables(g:_SYNTASTIC_DEBUG_TRACE, 'aggregate_errors')
+        call syntastic#log#debug(g:_SYNTASTIC_DEBUG_TRACE, 'getcwd() = ' . getcwd())
         " }}}3
 
-        let filetypes = s:resolveFiletypes()
+        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')
@@ -321,12 +369,12 @@ function! s:CacheErrors(checker_names) " {{{2
         for checker in clist
             let cname = checker.getFiletype() . '/' . checker.getName()
             if !checker.isAvailable()
-                call syntastic#log#debug(g:SyntasticDebugTrace, 'CacheErrors: Checker ' . cname . ' is not available')
+                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:SyntasticDebugTrace, 'CacheErrors: Invoking checker: ' . cname)
+            call syntastic#log#debug(g:_SYNTASTIC_DEBUG_TRACE, 'CacheErrors: Invoking checker: ' . cname)
 
             let loclist = checker.getLocList()
 
@@ -335,9 +383,9 @@ function! s:CacheErrors(checker_names) " {{{2
                     call loclist.decorate(cname)
                 endif
                 call add(names, cname)
-                if checker.getWantSort() && !sort_aggregated_errors
+                if checker.wantSort() && !sort_aggregated_errors
                     call loclist.sort()
-                    call syntastic#log#debug(g:SyntasticDebugLoclist, 'sorted:', loclist)
+                    call syntastic#log#debug(g:_SYNTASTIC_DEBUG_LOCLIST, 'sorted:', loclist)
                 endif
 
                 let newLoclist = newLoclist.extend(loclist)
@@ -370,33 +418,21 @@ function! s:CacheErrors(checker_names) " {{{2
                     call syntastic#log#warn('checkers ' . join(a:checker_names, ', ') . ' are not available')
                 endif
             else
-                call syntastic#log#debug(g:SyntasticDebugTrace, 'CacheErrors: no checkers available for ' . &filetype)
+                call syntastic#log#debug(g:_SYNTASTIC_DEBUG_TRACE, 'CacheErrors: no checkers available for ' . &filetype)
             endif
         endif
         " }}}3
 
-        call syntastic#log#debug(g:SyntasticDebugLoclist, 'aggregated:', newLoclist)
+        call syntastic#log#debug(g:_SYNTASTIC_DEBUG_LOCLIST, 'aggregated:', newLoclist)
         if sort_aggregated_errors
             call newLoclist.sort()
-            call syntastic#log#debug(g:SyntasticDebugLoclist, 'sorted:', newLoclist)
+            call syntastic#log#debug(g:_SYNTASTIC_DEBUG_LOCLIST, 'sorted:', newLoclist)
         endif
     endif
 
     call newLoclist.deploy()
 endfunction " }}}2
 
-function! s:ToggleMode() " {{{2
-    call s:modemap.toggleMode()
-    call s:ClearCache()
-    call s:UpdateErrors(1)
-    call s:modemap.echoMode()
-endfunction " }}}2
-
-"display the cached errors for this buf in the location list
-function! s:ShowLocList() " {{{2
-    call g:SyntasticLoclist.current().show()
-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
 "
@@ -417,10 +453,9 @@ endfunction " }}}2
 "   'returns' - a list of valid exit codes for the checker
 " @vimlint(EVL102, 1, l:env_save)
 function! SyntasticMake(options) " {{{2
-    call syntastic#log#debug(g:SyntasticDebugTrace, 'SyntasticMake: called with options:', a:options)
+    call syntastic#log#debug(g:_SYNTASTIC_DEBUG_TRACE, 'SyntasticMake: called with options:', a:options)
 
     " save options and locale env variables {{{3
-    let old_shell = &shell
     let old_shellredir = &shellredir
     let old_local_errorformat = &l:errorformat
     let old_errorformat = &errorformat
@@ -429,7 +464,7 @@ function! SyntasticMake(options) " {{{2
     let old_lc_all = $LC_ALL
     " }}}3
 
-    call s:bashHack()
+    call s:_bash_hack()
 
     if has_key(a:options, 'errorformat')
         let &errorformat = a:options['errorformat']
@@ -465,61 +500,78 @@ function! SyntasticMake(options) " {{{2
     endif
     " }}}3
 
-    call syntastic#log#debug(g:SyntasticDebugLoclist, 'checker output:', err_lines)
+    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
 
-    if has_key(a:options, 'Preprocess')
-        let err_lines = call(a:options['Preprocess'], [err_lines])
-        call syntastic#log#debug(g:SyntasticDebugLoclist, '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:SyntasticDebugLoclist, 'preprocess:', err_lines)
-    endif
-    lgetexpr err_lines
+        let errors = deepcopy(getloclist(0))
 
-    let errors = deepcopy(getloclist(0))
+        if has_key(a:options, 'cwd')
+            execute 'lcd ' . fnameescape(old_cwd)
+        endif
 
-    if has_key(a:options, 'cwd')
-        execute 'lcd ' . fnameescape(old_cwd)
+        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
 
-    silent! lolder
-
     " restore options {{{3
     let &errorformat = old_errorformat
     let &l:errorformat = old_local_errorformat
     let &shellredir = old_shellredir
-    let &shell = old_shell
     " }}}3
 
-    if !s:running_windows && (s:uname() =~ "FreeBSD" || s:uname() =~ "OpenBSD")
+    if !s:_running_windows && (s:_os_name() =~ "FreeBSD" || s:_os_name() =~ "OpenBSD")
         call syntastic#util#redraw(g:syntastic_full_redraws)
     endif
 
-    call syntastic#log#debug(g:SyntasticDebugLoclist, 'raw loclist:', errors)
-
-    if has_key(a:options, 'returns') && index(a:options['returns'], v:shell_error) == -1
+    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:addToErrors(errors, 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:addToErrors(errors, { 'subtype': 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:SyntasticDebugLoclist, 'postprocess (external):', errors)
+        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:SyntasticDebugLoclist, 'postprocess:', errors)
+        call syntastic#log#debug(g:_SYNTASTIC_DEBUG_LOCLIST, 'postprocess:', errors)
     endif
 
     return errors
@@ -538,12 +590,12 @@ endfunction " }}}2
 
 " Utilities {{{1
 
-function! s:resolveFiletypes(...) " {{{2
-    let type = a:0 ? a:1 : &filetype
+function! s:_resolve_filetypes(filetypes) " {{{2
+    let type = len(a:filetypes) ? a:filetypes[0] : &filetype
     return split( get(g:syntastic_filetype_map, type, type), '\m\.' )
 endfunction " }}}2
 
-function! s:ignoreFile(filename) " {{{2
+function! s:_ignore_file(filename) " {{{2
     let fname = fnamemodify(a:filename, ':p')
     for pattern in g:syntastic_ignore_files
         if fname =~# pattern
@@ -554,19 +606,48 @@ function! s:ignoreFile(filename) " {{{2
 endfunction " }}}2
 
 " Skip running in special buffers
-function! s:skipFile() " {{{2
-    let fname = expand('%')
-    let skip = (exists('b:syntastic_skip_checks') ? b:syntastic_skip_checks : 0) ||
-        \ (&buftype != '') || !filereadable(fname) || getwinvar(0, '&diff') ||
-        \ s:ignoreFile(fname) || fnamemodify(fname, ':e') =~? g:syntastic_ignore_extensions
+function! s:_skip_file() " {{{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:SyntasticDebugTrace, 'skipFile: skipping')
+        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) " {{{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:addToErrors(errors, options) " {{{2
+function! s:_add_to_errors(errors, options) " {{{2
     for err in a:errors
         for key in keys(a:options)
             if !has_key(err, key) || empty(err[key])
@@ -578,31 +659,30 @@ function! s:addToErrors(errors, options) " {{{2
     return a:errors
 endfunction " }}}2
 
-" The script changes &shellredir and &shell to stop the screen flicking when
-" shelling out to syntax checkers. Not all OSs support the hacks though.
-function! s:bashHack() " {{{2
-    if !exists('s:bash')
-        if !s:running_windows && (s:uname() !~# "FreeBSD") && (s:uname() !~# "OpenBSD")
-            let s:bash =
-                \ executable('/usr/local/bin/bash') ? '/usr/local/bin/bash' :
-                \ executable('/bin/bash') ? '/bin/bash' : ''
-        else
-            let s:bash = ''
+" XXX: Is this still needed?
+" The script changes &shellredir to stop the screen
+" flicking when shelling out to syntax checkers.
+function! s:_bash_hack() " {{{2
+    if g:syntastic_bash_hack
+        if !exists('s:shell_is_bash')
+            let s:shell_is_bash =
+                \ !s:_running_windows &&
+                \ (s:_os_name() !~# "FreeBSD") && (s:_os_name() !~# "OpenBSD") &&
+                \ &shell =~# '\m\<bash$'
         endif
-    endif
 
-    if g:syntastic_bash_hack && s:bash != ''
-        let &shell = s:bash
-        let &shellredir = '&>'
+        if s:shell_is_bash
+            let &shellredir = '&>'
+        endif
     endif
 endfunction " }}}2
 
-function! s:uname() " {{{2
-    if !exists('s:uname')
-        let s:uname = system('uname')
-        lockvar s:uname
+function! s:_os_name() " {{{2
+    if !exists('s:_uname')
+        let s:_uname = system('uname')
+        lockvar s:_uname
     endif
-    return s:uname
+    return s:_uname
 endfunction " }}}2
 
 " }}}1

vim/bundle/syntastic/plugin/syntastic/autoloclist.vim

@@ -13,12 +13,12 @@ function! g:SyntasticAutoloclistNotifier.New() " {{{2
 endfunction " }}}2
 
 function! g:SyntasticAutoloclistNotifier.refresh(loclist) " {{{2
-    call syntastic#log#debug(g:SyntasticDebugNotifications, 'autoloclist: refresh')
+    call syntastic#log#debug(g:_SYNTASTIC_DEBUG_NOTIFICATIONS, 'autoloclist: refresh')
     call g:SyntasticAutoloclistNotifier.AutoToggle(a:loclist)
 endfunction " }}}2
 
 function! g:SyntasticAutoloclistNotifier.AutoToggle(loclist) " {{{2
-    call syntastic#log#debug(g:SyntasticDebugNotifications, 'autoloclist: toggle')
+    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()

vim/bundle/syntastic/plugin/syntastic/balloons.vim

@@ -22,20 +22,11 @@ endfunction " }}}2
 
 " Update the error balloons
 function! g:SyntasticBalloonsNotifier.refresh(loclist) " {{{2
-    let b:syntastic_balloons = {}
+    unlet! b:syntastic_private_balloons
     if self.enabled() && !a:loclist.isEmpty()
-        call syntastic#log#debug(g:SyntasticDebugNotifications, 'balloons: refresh')
-        let buf = bufnr('')
-        let issues = filter(a:loclist.copyRaw(), 'v:val["bufnr"] == buf')
-        if !empty(issues)
-            for i in issues
-                if has_key(b:syntastic_balloons, i['lnum'])
-                    let b:syntastic_balloons[i['lnum']] .= "\n" . i['text']
-                else
-                    let b:syntastic_balloons[i['lnum']] = i['text']
-                endif
-            endfor
-            set beval bexpr=SyntasticBalloonsExprNotifier()
+        let b:syntastic_private_balloons = a:loclist.balloons()
+        if !empty(b:syntastic_private_balloons)
+            set ballooneval balloonexpr=SyntasticBalloonsExprNotifier()
         endif
     endif
 endfunction " }}}2
@@ -43,10 +34,11 @@ endfunction " }}}2
 " Reset the error balloons
 " @vimlint(EVL103, 1, a:loclist)
 function! g:SyntasticBalloonsNotifier.reset(loclist) " {{{2
-    let b:syntastic_balloons = {}
+    let b:syntastic_private_balloons = {}
     if has('balloon_eval')
-        call syntastic#log#debug(g:SyntasticDebugNotifications, 'balloons: reset')
-        set nobeval
+        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)
@@ -56,10 +48,10 @@ endfunction " }}}2
 " Private functions {{{1
 
 function! SyntasticBalloonsExprNotifier() " {{{2
-    if !exists('b:syntastic_balloons')
+    if !exists('b:syntastic_private_balloons')
         return ''
     endif
-    return get(b:syntastic_balloons, v:beval_lnum, '')
+    return get(b:syntastic_private_balloons, v:beval_lnum, '')
 endfunction " }}}2
 
 " }}}1

vim/bundle/syntastic/plugin/syntastic/checker.vim

@@ -13,11 +13,14 @@ function! g:SyntasticChecker.New(args) " {{{2
     let newObj._filetype = a:args['filetype']
     let newObj._name = a:args['name']
     let newObj._exec = get(a:args, 'exec', newObj._name)
-    let newObj._sort = 0
 
     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
@@ -27,7 +30,7 @@ function! g:SyntasticChecker.New(args) " {{{2
     if exists('*' . prefix . 'IsAvailable')
         let newObj._isAvailableFunc = function(prefix . 'IsAvailable')
     else
-        let newObj._isAvailableFunc = function('SyntasticCheckerIsAvailableDefault')
+        let newObj._isAvailableFunc = function('s:_isAvailableDefault')
     endif
 
     if exists('*' . prefix . 'GetHighlightRegex')
@@ -46,11 +49,9 @@ function! g:SyntasticChecker.getName() " {{{2
 endfunction " }}}2
 
 function! g:SyntasticChecker.getExec() " {{{2
-    if exists('g:syntastic_' . self._filetype . '_' . self._name . '_exec')
-        return expand(g:syntastic_{self._filetype}_{self._name}_exec)
-    endif
-
-    return self._exec
+    return
+        \ expand( exists('b:syntastic_' . self._name . '_exec') ? b:syntastic_{self._name}_exec :
+        \ syntastic#util#var(self._filetype . '_' . self._name . '_exec', self._exec), 1 )
 endfunction " }}}2
 
 function! g:SyntasticChecker.getExecEscaped() " {{{2
@@ -61,13 +62,13 @@ function! g:SyntasticChecker.getLocListRaw() " {{{2
     let name = self._filetype . '/' . self._name
     try
         let list = self._locListFunc()
-        call syntastic#log#debug(g:SyntasticDebugTrace, 'getLocList: checker ' . name . ' returned ' . v:shell_error)
+        call syntastic#log#debug(g:_SYNTASTIC_DEBUG_TRACE, 'getLocList: checker ' . name . ' returned ' . v:shell_error)
     catch /\m\C^Syntastic: checker error$/
         let list = []
         call syntastic#log#error('checker ' . name . ' returned abnormal status ' . v:shell_error)
     endtry
     call self._populateHighlightRegexes(list)
-    call syntastic#log#debug(g:SyntasticDebugLoclist, name . ' raw:', list)
+    call syntastic#log#debug(g:_SYNTASTIC_DEBUG_LOCLIST, name . ' raw:', list)
     call self._quietMessages(list)
     return list
 endfunction " }}}2
@@ -76,12 +77,35 @@ function! g:SyntasticChecker.getLocList() " {{{2
     return g:SyntasticLoclist.New(self.getLocListRaw())
 endfunction " }}}2
 
-function! g:SyntasticChecker.getWantSort() " {{{2
-    return self._sort
+function! g:SyntasticChecker.getVersion(...) " {{{2
+    if !exists('self._version')
+        let command = a:0 ? a:1 : self.getExecEscaped() . ' --version'
+        let version_output = system(command)
+        call syntastic#log#debug( g:_SYNTASTIC_DEBUG_CHECKERS,
+            \ self._filetype . '/' . self._name . ': output of ' . 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.setWantSort(val) " {{{2
-    let self._sort = a:val
+function! g:SyntasticChecker.setVersion(version) " {{{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, ...) " {{{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) " {{{2
@@ -104,6 +128,18 @@ function! g:SyntasticChecker.isAvailable() " {{{2
     return self._available
 endfunction " }}}2
 
+function! g:SyntasticChecker.wantSort() " {{{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) " {{{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
@@ -125,11 +161,11 @@ function! g:SyntasticChecker._quietMessages(errors) " {{{2
         call syntastic#log#warn('ignoring invalid syntastic_' . name . '_quiet_messages')
     endtry
 
-    call syntastic#log#debug(g:SyntasticDebugLoclist, 'quiet_messages filter:', quiet_filters)
+    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:SyntasticDebugLoclist, 'filtered by quiet_messages:', a:errors)
+        call syntastic#log#debug(g:_SYNTASTIC_DEBUG_LOCLIST, 'filtered by quiet_messages:', a:errors)
     endif
 endfunction " }}}2
 
@@ -147,30 +183,19 @@ function! g:SyntasticChecker._populateHighlightRegexes(errors) " {{{2
 endfunction " }}}2
 
 function! g:SyntasticChecker._getOpt(opts, basename, name, default) " {{{2
-    let user_val = syntastic#util#var(a:basename . a:name)
     let ret = []
-    call extend( ret, self._shescape(get(a:opts, a:name . '_before', '')) )
-    call extend( ret, self._shescape(user_val != '' ? user_val : get(a:opts, a:name, a:default)) )
-    call extend( ret, self._shescape(get(a:opts, a:name . '_after', '')) )
+    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
 
-function! g:SyntasticChecker._shescape(opt) " {{{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
-
 " }}}1
 
-" Non-method functions {{{1
+" Private functions {{{1
 
-function! SyntasticCheckerIsAvailableDefault() dict " {{{2
+function! s:_isAvailableDefault() dict " {{{2
     return executable(self.getExec())
 endfunction " }}}2
 

vim/bundle/syntastic/plugin/syntastic/cursor.vim

@@ -18,9 +18,9 @@ endfunction " }}}2
 
 function! g:SyntasticCursorNotifier.refresh(loclist) " {{{2
     if self.enabled() && !a:loclist.isEmpty()
-        call syntastic#log#debug(g:SyntasticDebugNotifications, 'cursor: refresh')
-        let b:syntastic_messages = copy(a:loclist.messages(bufnr('')))
-        let b:syntastic_line = -1
+        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()
@@ -29,28 +29,28 @@ endfunction " }}}2
 
 " @vimlint(EVL103, 1, a:loclist)
 function! g:SyntasticCursorNotifier.reset(loclist) " {{{2
-    call syntastic#log#debug(g:SyntasticDebugNotifications, 'cursor: reset')
+    call syntastic#log#debug(g:_SYNTASTIC_DEBUG_NOTIFICATIONS, 'cursor: reset')
     autocmd! syntastic CursorMoved
-    unlet! b:syntastic_messages
-    let b:syntastic_line = -1
+    unlet! b:syntastic_private_messages
+    let b:syntastic_private_line = -1
 endfunction " }}}2
 " @vimlint(EVL103, 0, a:loclist)
 
 " }}}1
 
-" Private methods {{{1
+" Private functions {{{1
 
 function! SyntasticRefreshCursor() " {{{2
-    if !exists('b:syntastic_messages') || empty(b:syntastic_messages)
+    if !exists('b:syntastic_private_messages') || empty(b:syntastic_private_messages)
         " file not checked
         return
     endif
 
-    if !exists('b:syntastic_line')
-        let b:syntastic_line = -1
+    if !exists('b:syntastic_private_line')
+        let b:syntastic_private_line = -1
     endif
     let l = line('.')
-    let current_messages = get(b:syntastic_messages, l, {})
+    let current_messages = get(b:syntastic_private_messages, l, {})
 
     if !exists('b:syntastic_cursor_columns')
         let b:syntastic_cursor_columns = g:syntastic_cursor_columns
@@ -58,28 +58,28 @@ function! SyntasticRefreshCursor() " {{{2
 
     if b:syntastic_cursor_columns
         let c = virtcol('.')
-        if !exists('b:syntastic_idx')
-            let b:syntastic_idx = -1
+        if !exists('b:syntastic_private_idx')
+            let b:syntastic_private_idx = -1
         endif
 
-        if s:_isSameIndex(l, b:syntastic_line, c, b:syntastic_idx, current_messages)
+        if s:_is_same_index(l, b:syntastic_private_line, c, b:syntastic_private_idx, current_messages)
             return
         else
-            let b:syntastic_line = l
+            let b:syntastic_private_line = l
         endif
 
         if !empty(current_messages)
-            let b:syntastic_idx = s:_findIndex(c, current_messages)
-            call syntastic#util#wideMsg(current_messages[b:syntastic_idx].text)
+            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_idx = -1
+            let b:syntastic_private_idx = -1
             echo
         endif
     else
-        if l == b:syntastic_line
+        if l == b:syntastic_private_line
             return
         endif
-        let b:syntastic_line = l
+        let b:syntastic_private_line = l
 
         if !empty(current_messages)
             call syntastic#util#wideMsg(current_messages[0].text)
@@ -91,15 +91,15 @@ endfunction " }}}2
 
 " }}}1
 
-" Private functions {{{1
+" Utilities {{{1
 
-function! s:_isSameIndex(line, old_line, column, idx, messages) " {{{2
+function! s:_is_same_index(line, old_line, column, idx, messages) " {{{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
+        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
@@ -113,7 +113,7 @@ function! s:_isSameIndex(line, old_line, column, idx, messages) " {{{2
     endif
 endfunction " }}}2
 
-function! s:_findIndex(column, messages) " {{{2
+function! s:_find_index(column, messages) " {{{2
     let max = len(a:messages) - 1
     if max == 0
         return 0

vim/bundle/syntastic/plugin/syntastic/highlighting.vim

@@ -32,7 +32,7 @@ endfunction " }}}2
 " Sets error highlights in the cuirrent window
 function! g:SyntasticHighlightingNotifier.refresh(loclist) " {{{2
     if self.enabled()
-        call syntastic#log#debug(g:SyntasticDebugNotifications, 'highlighting: refresh')
+        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')
@@ -63,7 +63,7 @@ endfunction " }}}2
 " @vimlint(EVL103, 1, a:loclist)
 function! g:SyntasticHighlightingNotifier.reset(loclist) " {{{2
     if s:has_highlighting
-        call syntastic#log#debug(g:SyntasticDebugNotifications, 'highlighting: reset')
+        call syntastic#log#debug(g:_SYNTASTIC_DEBUG_NOTIFICATIONS, 'highlighting: reset')
         call self._reset()
     endif
 endfunction " }}}2

vim/bundle/syntastic/plugin/syntastic/loclist.vim

@@ -43,10 +43,10 @@ endfunction " }}}2
 function! g:SyntasticLoclist.sort() " {{{2
     if !self._sorted
         for e in self._rawLoclist
-            call s:_setScreenColumn(e)
+            call s:_set_screen_column(e)
         endfor
 
-        call sort(self._rawLoclist, self._columns ? 's:_compareErrorItemsByColumns' : 's:_compareErrorItemsByLines')
+        call sort(self._rawLoclist, self._columns ? 's:_compare_error_items_by_columns' : 's:_compare_error_items_by_lines')
 
         let self._sorted = 1
     endif
@@ -133,8 +133,19 @@ function! g:SyntasticLoclist.getStatuslineFlag() " {{{2
     return self._stl_flag
 endfunction " }}}2
 
-function! g:SyntasticLoclist.getFirstIssue() " {{{2
-    return get(self._rawLoclist, 0, {})
+function! g:SyntasticLoclist.getFirstError(...) " {{{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() " {{{2
@@ -173,6 +184,29 @@ function! g:SyntasticLoclist.decorate(tag) " {{{2
     endfor
 endfunction " }}}2
 
+function! g:SyntasticLoclist.balloons() " {{{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() " {{{2
     if !exists("self._cachedErrors")
         let self._cachedErrors = self.filter({'type': "E"})
@@ -220,9 +254,9 @@ function! g:SyntasticLoclist.messages(buf) " {{{2
                     for l in keys(self._cachedMessages[b])
                         if len(self._cachedMessages[b][l]) > 1
                             for e in self._cachedMessages[b][l]
-                                call s:_setScreenColumn(e)
+                                call s:_set_screen_column(e)
                             endfor
-                            call sort(self._cachedMessages[b][l], 's:_compareErrorItemsByColumns')
+                            call sort(self._cachedMessages[b][l], 's:_compare_error_items_by_columns')
                         endif
                     endfor
                 endfor
@@ -230,7 +264,7 @@ function! g:SyntasticLoclist.messages(buf) " {{{2
 
             for b in keys(self._cachedMessages)
                 for l in keys(self._cachedMessages[b])
-                    call s:_removeShadowedItems(self._cachedMessages[b][l])
+                    call s:_remove_shadowed_items(self._cachedMessages[b][l])
                 endfor
             endfor
         endif
@@ -258,14 +292,14 @@ function! g:SyntasticLoclist.setloclist() " {{{2
         let w:syntastic_loclist_set = 0
     endif
     let replace = g:syntastic_reuse_loc_lists && w:syntastic_loclist_set
-    call syntastic#log#debug(g:SyntasticDebugNotifications, 'loclist: setloclist ' . (replace ? '(replace)' : '(new)'))
+    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() " {{{2
-    call syntastic#log#debug(g:SyntasticDebugNotifications, 'loclist: show')
+    call syntastic#log#debug(g:_SYNTASTIC_DEBUG_NOTIFICATIONS, 'loclist: show')
     call self.setloclist()
 
     if !self.isEmpty()
@@ -297,25 +331,25 @@ endfunction " }}}2
 
 " }}}1
 
-" Non-method functions {{{1
+" Public functions {{{1
 
 function! SyntasticLoclistHide() " {{{2
-    call syntastic#log#debug(g:SyntasticDebugNotifications, 'loclist: hide')
+    call syntastic#log#debug(g:_SYNTASTIC_DEBUG_NOTIFICATIONS, 'loclist: hide')
     silent! lclose
 endfunction " }}}2
 
 " }}}1
 
-" Private functions {{{1
+" Utilities {{{1
 
 function! s:_translate(key, val) " {{{2
     return 'get(v:val, ' . string(a:key) . ', "") ==? ' . string(a:val)
 endfunction " }}}2
 
-function! s:_setScreenColumn(item) " {{{2
+function! s:_set_screen_column(item) " {{{2
     if !has_key(a:item, 'scol')
         let col = get(a:item, 'col', 0)
-        if col != 0 && a:item['vcol'] == 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]
@@ -329,7 +363,7 @@ function! s:_setScreenColumn(item) " {{{2
     endif
 endfunction " }}}2
 
-function! s:_removeShadowedItems(errors) " {{{2
+function! s:_remove_shadowed_items(errors) " {{{2
     " keep only the first message at a given column
     let i = 0
     while i < len(a:errors) - 1
@@ -361,7 +395,7 @@ function! s:_removeShadowedItems(errors) " {{{2
     endwhile
 endfunction " }}}2
 
-function! s:_compareErrorItemsByColumns(a, b) " {{{2
+function! s:_compare_error_items_by_columns(a, b) " {{{2
     if a:a['bufnr'] != a:b['bufnr']
         " group by file
         return a:a['bufnr'] - a:b['bufnr']
@@ -379,7 +413,7 @@ function! s:_compareErrorItemsByColumns(a, b) " {{{2
     endif
 endfunction " }}}2
 
-function! s:_compareErrorItemsByLines(a, b) " {{{2
+function! s:_compare_error_items_by_lines(a, b) " {{{2
     if a:a['bufnr'] != a:b['bufnr']
         " group by file
         return a:a['bufnr'] - a:b['bufnr']

vim/bundle/syntastic/plugin/syntastic/modemap.vim

@@ -38,6 +38,15 @@ function! g:SyntasticModeMap.allowsAutoChecking(filetype) " {{{2
     endif
 endfunction " }}}2
 
+function! g:SyntasticModeMap.doAutoChecking() " {{{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() " {{{2
     return self._mode ==# 'passive'
 endfunction " }}}2
@@ -62,13 +71,13 @@ function! g:SyntasticModeMap.echoMode() " {{{2
     echo "Syntastic: " . self._mode . " mode enabled"
 endfunction " }}}2
 
-function! g:SyntasticModeMap.modeInfo(...) " {{{2
-    echomsg 'Syntastic version: ' . g:syntastic_version
-    let type = a:0 ? a:1 : &filetype
+function! g:SyntasticModeMap.modeInfo(filetypes) " {{{2
+    echomsg 'Syntastic version: ' . g:_SYNTASTIC_VERSION
+    let type = len(a:filetypes) ? a:filetypes[0] : &filetype
     echomsg 'Info for filetype: ' . type
 
     call self.synch()
-    echomsg 'Mode: ' . self._mode
+    echomsg 'Global mode: ' . self._mode
     if self._mode ==# 'active'
         if len(self._passiveFiletypes)
             let plural = len(self._passiveFiletypes) != 1 ? 's' : ''
@@ -81,6 +90,14 @@ function! g:SyntasticModeMap.modeInfo(...) " {{{2
         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

vim/bundle/syntastic/plugin/syntastic/notifiers.vim

@@ -5,11 +5,11 @@ let g:loaded_syntastic_notifiers = 1
 
 let g:SyntasticNotifiers = {}
 
-let s:notifier_types = ['signs', 'balloons', 'highlighting', 'cursor', 'autoloclist']
-lockvar! s:notifier_types
+let s:_NOTIFIER_TYPES = ['signs', 'balloons', 'highlighting', 'cursor', 'autoloclist']
+lockvar! s:_NOTIFIER_TYPES
 
-let s:persistent_notifiers = ['signs', 'balloons']
-lockvar! s:persistent_notifiers
+let s:_PERSISTENT_NOTIFIERS = ['signs', 'balloons']
+lockvar! s:_PERSISTENT_NOTIFIERS
 
 " Public methods {{{1
 
@@ -28,18 +28,18 @@ function! g:SyntasticNotifiers.refresh(loclist) " {{{2
         return
     endif
 
-    call syntastic#log#debug(g:SyntasticDebugNotifications, 'notifiers: refresh')
+    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
+            if index(s:_PERSISTENT_NOTIFIERS, type) > -1
                 " refresh only if loclist has changed since last call
-                if !exists('b:syntastic_' . type . '_stamp')
-                    let b:syntastic_{type}_stamp = []
+                if !exists('b:syntastic_private_' . type . '_stamp')
+                    let b:syntastic_private_{type}_stamp = []
                 endif
-                if a:loclist.isNewerThan(b:syntastic_{type}_stamp) || a:loclist.isEmpty()
+                if a:loclist.isNewerThan(b:syntastic_private_{type}_stamp) || a:loclist.isEmpty()
                     call self._notifier[type].refresh(a:loclist)
-                    let b:syntastic_{type}_stamp = syntastic#util#stamp()
+                    let b:syntastic_private_{type}_stamp = syntastic#util#stamp()
                 endif
             else
                 call self._notifier[type].refresh(a:loclist)
@@ -49,7 +49,7 @@ function! g:SyntasticNotifiers.refresh(loclist) " {{{2
 endfunction " }}}2
 
 function! g:SyntasticNotifiers.reset(loclist) " {{{2
-    call syntastic#log#debug(g:SyntasticDebugNotifications, 'notifiers: reset')
+    call syntastic#log#debug(g:_SYNTASTIC_DEBUG_NOTIFICATIONS, 'notifiers: reset')
     for type in self._enabled_types
         let class = substitute(type, '\m.*', 'Syntastic\u&Notifier', '')
 
@@ -61,8 +61,8 @@ function! g:SyntasticNotifiers.reset(loclist) " {{{2
         endif
 
         " also reset stamps
-        if index(s:persistent_notifiers, type) > -1
-            let b:syntastic_{type}_stamp = []
+        if index(s:_PERSISTENT_NOTIFIERS, type) > -1
+            let b:syntastic_private_{type}_stamp = []
         endif
     endfor
 endfunction " }}}2
@@ -73,12 +73,12 @@ endfunction " }}}2
 
 function! g:SyntasticNotifiers._initNotifiers() " {{{2
     let self._notifier = {}
-    for type in s:notifier_types
+    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)
+    let self._enabled_types = copy(s:_NOTIFIER_TYPES)
 endfunction " }}}2
 
 " }}}1

vim/bundle/syntastic/plugin/syntastic/registry.vim

@@ -5,11 +5,10 @@ let g:loaded_syntastic_registry = 1
 
 " Initialisation {{{1
 
-let s:defaultCheckers = {
+let s:_DEFAULT_CHECKERS = {
         \ 'actionscript':['mxmlc'],
         \ 'ada':         ['gcc'],
         \ 'applescript': ['osacompile'],
-        \ 'arduino':     ['avrgcc'],
         \ 'asciidoc':    ['asciidoc'],
         \ 'asm':         ['gcc'],
         \ 'bro':         ['bro'],
@@ -51,6 +50,7 @@ let s:defaultCheckers = {
         \ 'lisp':        ['clisp'],
         \ 'llvm':        ['llvm'],
         \ 'lua':         ['luac'],
+        \ 'markdown':    ['mdl'],
         \ 'matlab':      ['mlint'],
         \ 'nasm':        ['nasm'],
         \ 'nroff':       ['mandoc'],
@@ -65,6 +65,7 @@ let s:defaultCheckers = {
         \ 'python':      ['python', 'flake8', 'pylint'],
         \ 'r':           [],
         \ 'racket':      ['racket'],
+        \ 'rnc':         ['rnv'],
         \ 'rst':         ['rst2pseudoxml'],
         \ 'ruby':        ['mri'],
         \ 'sass':        ['sass'],
@@ -72,10 +73,11 @@ let s:defaultCheckers = {
         \ 'scss':        ['sass', 'scss_lint'],
         \ 'sh':          ['sh', 'shellcheck'],
         \ 'slim':        ['slimrb'],
+        \ 'spec':        ['rpmlint'],
         \ 'tcl':         ['nagelfar'],
         \ 'tex':         ['lacheck', 'chktex'],
         \ 'texinfo':     ['makeinfo'],
-        \ 'text':        ['atdtool'],
+        \ 'text':        [],
         \ 'twig':        ['twiglint'],
         \ 'typescript':  ['tsc'],
         \ 'vala':        ['valac'],
@@ -89,16 +91,40 @@ let s:defaultCheckers = {
         \ 'yaml':        ['jsyaml'],
         \ 'z80':         ['z80syntaxchecker'],
         \ 'zpt':         ['zptlint'],
-        \ 'zsh':         ['zsh', 'shellcheck']
+        \ 'zsh':         ['zsh', 'shellcheck'],
     \ }
-lockvar! s:defaultCheckers
+lockvar! s:_DEFAULT_CHECKERS
 
-let s:defaultFiletypeMap = {
+let s:_DEFAULT_FILETYPE_MAP = {
         \ 'gentoo-metadata': 'xml',
+        \ 'groff': 'nroff',
         \ 'lhaskell': 'haskell',
-        \ 'litcoffee': 'coffee'
+        \ 'litcoffee': 'coffee',
+        \ 'mail': 'text',
+        \ 'mkd': 'markdown',
+        \ 'sgml': 'docbk',
+        \ 'sgmllnx': 'docbk',
     \ }
-lockvar! s:defaultFiletypeMap
+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 = {}
 
@@ -130,7 +156,7 @@ endfunction " }}}2
 " not checked for availability (that is, the corresponding IsAvailable() are
 " not run).
 function! g:SyntasticRegistry.getCheckers(ftalias, hints_list) " {{{2
-    let ft = s:_normaliseFiletype(a:ftalias)
+    let ft = s:_normalise_filetype(a:ftalias)
     call self._loadCheckersFor(ft)
 
     let checkers_map = self._checkerMap[ft]
@@ -144,7 +170,7 @@ function! g:SyntasticRegistry.getCheckers(ftalias, hints_list) " {{{2
         \ !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:defaultCheckers, ft, 0)
+        \ get(s:_DEFAULT_CHECKERS, ft, 0)
 
     return type(names) == type([]) ?
         \ self._filterCheckersByName(checkers_map, names) : [checkers_map[keys(checkers_map)[0]]]
@@ -157,9 +183,9 @@ function! g:SyntasticRegistry.getCheckersAvailable(ftalias, hints_list) " {{{2
 endfunction " }}}2
 
 function! g:SyntasticRegistry.getKnownFiletypes() " {{{2
-    let types = keys(s:defaultCheckers)
+    let types = keys(s:_DEFAULT_CHECKERS)
 
-    call extend(types, keys(s:defaultFiletypeMap))
+    call extend(types, keys(s:_DEFAULT_FILETYPE_MAP))
 
     if exists('g:syntastic_filetype_map')
         call extend(types, keys(g:syntastic_filetype_map))
@@ -173,13 +199,13 @@ function! g:SyntasticRegistry.getKnownFiletypes() " {{{2
 endfunction " }}}2
 
 function! g:SyntasticRegistry.getNamesOfAvailableCheckers(ftalias) " {{{2
-    let ft = s:_normaliseFiletype(a:ftalias)
+    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) " {{{2
-    let ft_list = syntastic#util#unique(map( copy(a:ftalias_list), 's:_normaliseFiletype(v:val)' ))
+    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 = []
@@ -203,6 +229,30 @@ function! g:SyntasticRegistry.echoInfoFor(ftalias_list) " {{{2
     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
@@ -249,17 +299,31 @@ endfunction " }}}2
 
 " }}}1
 
-" Private functions {{{1
+" Utilities {{{1
 
 "resolve filetype aliases, and replace - with _ otherwise we cant name
 "syntax checker functions legally for filetypes like "gentoo-metadata"
-function! s:_normaliseFiletype(ftalias) " {{{2
-    let ft = get(s:defaultFiletypeMap, a:ftalias, a:ftalias)
+function! s:_normalise_filetype(ftalias) " {{{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) " {{{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) " {{{2
+    return index(s:_YCM_TYPES, a:filetype) >= 0
+endfunction " }}}2
+
 " }}}1
 
 " vim: set sw=4 sts=4 et fdm=marker:

vim/bundle/syntastic/plugin/syntastic/signs.vim

@@ -36,7 +36,7 @@ function! g:SyntasticSignsNotifier.enabled() " {{{2
 endfunction " }}}2
 
 function! g:SyntasticSignsNotifier.refresh(loclist) " {{{2
-    call syntastic#log#debug(g:SyntasticDebugNotifications, 'signs: refresh')
+    call syntastic#log#debug(g:_SYNTASTIC_DEBUG_NOTIFICATIONS, 'signs: refresh')
     let old_signs = copy(self._bufSignIds())
     if self.enabled()
         call self._signErrors(a:loclist)
@@ -71,13 +71,13 @@ function! g:SyntasticSignsNotifier._setup() " {{{2
         endif
 
         " define the signs used to display syntax and style errors/warns
-        exe 'sign define SyntasticError text=' . g:syntastic_error_symbol .
+        execute 'sign define SyntasticError text=' . g:syntastic_error_symbol .
             \ ' texthl=SyntasticErrorSign linehl=SyntasticErrorLine'
-        exe 'sign define SyntasticWarning text=' . g:syntastic_warning_symbol .
+        execute 'sign define SyntasticWarning text=' . g:syntastic_warning_symbol .
             \ ' texthl=SyntasticWarningSign linehl=SyntasticWarningLine'
-        exe 'sign define SyntasticStyleError text=' . g:syntastic_style_error_symbol .
+        execute 'sign define SyntasticStyleError text=' . g:syntastic_style_error_symbol .
             \ ' texthl=SyntasticStyleErrorSign linehl=SyntasticStyleErrorLine'
-        exe 'sign define SyntasticStyleWarning text=' . g:syntastic_style_warning_symbol .
+        execute 'sign define SyntasticStyleWarning text=' . g:syntastic_style_warning_symbol .
             \ ' texthl=SyntasticStyleWarningSign linehl=SyntasticStyleWarningLine'
     endif
 endfunction " }}}2
@@ -127,10 +127,10 @@ endfunction " }}}2
 
 " Get all the ids of the SyntaxError signs in the buffer
 function! g:SyntasticSignsNotifier._bufSignIds() " {{{2
-    if !exists("b:syntastic_sign_ids")
-        let b:syntastic_sign_ids = []
+    if !exists("b:syntastic_private_sign_ids")
+        let b:syntastic_private_sign_ids = []
     endif
-    return b:syntastic_sign_ids
+    return b:syntastic_private_sign_ids
 endfunction " }}}2
 
 " }}}1

vim/bundle/syntastic/syntax_checkers/actionscript/mxmlc.vim

@@ -64,4 +64,4 @@ call g:SyntasticRegistry.CreateAndRegisterChecker({
 let &cpo = s:save_cpo
 unlet s:save_cpo
 
-" vim: set et sts=4 sw=4:
+" vim: set sw=4 sts=4 et fdm=marker:

vim/bundle/syntastic/syntax_checkers/ada/gcc.vim

@@ -23,7 +23,7 @@ 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))
+    return executable(expand(g:syntastic_ada_compiler, 1))
 endfunction
 
 function! SyntaxCheckers_ada_gcc_GetLocList() dict
@@ -44,4 +44,4 @@ call g:SyntasticRegistry.CreateAndRegisterChecker({
 let &cpo = s:save_cpo
 unlet s:save_cpo
 
-" vim: set et sts=4 sw=4:
+" vim: set sw=4 sts=4 et fdm=marker:

vim/bundle/syntastic/syntax_checkers/applescript/osacompile.vim

@@ -46,4 +46,4 @@ call g:SyntasticRegistry.CreateAndRegisterChecker({
 let &cpo = s:save_cpo
 unlet s:save_cpo
 
-" vim: set et sts=4 sw=4:
+" vim: set sw=4 sts=4 et fdm=marker:

vim/bundle/syntastic/syntax_checkers/asciidoc/asciidoc.vim

@@ -44,4 +44,4 @@ call g:SyntasticRegistry.CreateAndRegisterChecker({
 let &cpo = s:save_cpo
 unlet s:save_cpo
 
-" vim: set et sts=4 sw=4:
+" vim: set sw=4 sts=4 et fdm=marker:

vim/bundle/syntastic/syntax_checkers/asm/gcc.vim

@@ -22,14 +22,14 @@ endif
 let s:save_cpo = &cpo
 set cpo&vim
 
-function! SyntaxCheckers_asm_gcc_IsAvailable() dict
+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))
-endfunction
+    return executable(expand(g:syntastic_asm_compiler, 1))
+endfunction " }}}1
 
-function! SyntaxCheckers_asm_gcc_GetLocList() dict
+function! SyntaxCheckers_asm_gcc_GetLocList() dict " {{{1
     return syntastic#c#GetLocList('asm', 'gcc', {
         \ 'errorformat':
         \     '%-G%f:%s:,' .
@@ -37,12 +37,16 @@ function! SyntaxCheckers_asm_gcc_GetLocList() dict
         \     '%f:%l:%c: %tarning: %m,' .
         \     '%f:%l: %m',
         \ 'main_flags': '-x assembler -fsyntax-only -masm=' . s:GetDialect() })
-endfunction
+endfunction " }}}1
 
-function! s:GetDialect()
+" Utilities {{{1
+
+function! s:GetDialect() " {{{2
     return exists('g:syntastic_asm_dialect') ? g:syntastic_asm_dialect :
-        \ expand('%:e') ==? 'asm' ? 'intel' : 'att'
-endfunction
+        \ expand('%:e', 1) ==? 'asm' ? 'intel' : 'att'
+endfunction " }}}2
+
+" }}}1
 
 call g:SyntasticRegistry.CreateAndRegisterChecker({
     \ 'filetype': 'asm',
@@ -51,4 +55,4 @@ call g:SyntasticRegistry.CreateAndRegisterChecker({
 let &cpo = s:save_cpo
 unlet s:save_cpo
 
-" vim: set et sts=4 sw=4:
+" vim: set sw=4 sts=4 et fdm=marker:

vim/bundle/syntastic/syntax_checkers/bemhtml/bemhtmllint.vim

@@ -32,4 +32,4 @@ call g:SyntasticRegistry.CreateAndRegisterChecker({
 let &cpo = s:save_cpo
 unlet s:save_cpo
 
-" vim: set et sts=4 sw=4:
+" vim: set sw=4 sts=4 et fdm=marker:

vim/bundle/syntastic/syntax_checkers/bro/bro.vim

@@ -18,15 +18,30 @@ 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
-    return system(self.getExecEscaped() . ' --help') =~# '--parse-only'
+    if !executable(self.getExec())
+        return 0
+    endif
+
+    if 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"
+    "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'
 
@@ -42,4 +57,4 @@ call g:SyntasticRegistry.CreateAndRegisterChecker({
 let &cpo = s:save_cpo
 unlet s:save_cpo
 
-" vim: set et sts=4 sw=4:
+" vim: set sw=4 sts=4 et fdm=marker:

vim/bundle/syntastic/syntax_checkers/c/avrgcc.vim

@@ -54,4 +54,4 @@ call g:SyntasticRegistry.CreateAndRegisterChecker({
 let &cpo = s:save_cpo
 unlet s:save_cpo
 
-" vim: set et sts=4 sw=4:
+" vim: set sw=4 sts=4 et fdm=marker:

vim/bundle/syntastic/syntax_checkers/c/checkpatch.vim

@@ -18,18 +18,20 @@ let s:save_cpo = &cpo
 set cpo&vim
 
 function! SyntaxCheckers_c_checkpatch_IsAvailable() dict
-    call syntastic#log#deprecationWarn('c_checker_checkpatch_location', 'c_checkpatch_exe')
+    call syntastic#log#deprecationWarn('c_checker_checkpatch_location', 'c_checkpatch_exec')
 
-    if !exists('g:syntastic_c_checkpatch_exe') && !executable(self.getExec())
+    if !exists('g:syntastic_c_checkpatch_exec') && !executable(self.getExec())
         if executable('checkpatch')
-            let g:syntastic_c_checkpatch_exe = 'checkpatch'
+            let g:syntastic_c_checkpatch_exec = 'checkpatch'
         elseif executable('./scripts/checkpatch.pl')
-            let g:syntastic_c_checkpatch_exe = fnamemodify('./scripts/checkpatch.pl', ':p')
+            let g:syntastic_c_checkpatch_exec = fnamemodify('./scripts/checkpatch.pl', ':p')
         elseif executable('./scripts/checkpatch')
-            let g:syntastic_c_checkpatch_exe = fnamemodify('./scripts/checkpatch', ':p')
+            let g:syntastic_c_checkpatch_exec = fnamemodify('./scripts/checkpatch', ':p')
         endif
     endif
 
+    call self.log('exec =', self.getExec())
+
     return executable(self.getExec())
 endfunction
 
@@ -55,4 +57,4 @@ call g:SyntasticRegistry.CreateAndRegisterChecker({
 let &cpo = s:save_cpo
 unlet s:save_cpo
 
-" vim: set et sts=4 sw=4:
+" vim: set sw=4 sts=4 et fdm=marker:

vim/bundle/syntastic/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/bundle/syntastic/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/bundle/syntastic/syntax_checkers/c/cppcheck.vim

@@ -8,13 +8,6 @@
 "             Want To Public License, Version 2, as published by Sam Hocevar.
 "             See http://sam.zoy.org/wtfpl/COPYING for more details.
 "============================================================================
-"
-" The setting 'g:syntastic_cppcheck_config_file' allows you to define a file
-" that contains additional compiler arguments like include directories or
-" CFLAGS. The file is expected to contain one option per line. If none is
-" given the filename defaults to '.syntastic_cppcheck_config':
-"
-"   let g:syntastic_cppcheck_config_file = '.config'
 
 if exists("g:loaded_syntastic_c_cppcheck_checker")
     finish
@@ -66,4 +59,4 @@ call g:SyntasticRegistry.CreateAndRegisterChecker({
 let &cpo = s:save_cpo
 unlet s:save_cpo
 
-" vim: set et sts=4 sw=4:
+" vim: set sw=4 sts=4 et fdm=marker:

vim/bundle/syntastic/syntax_checkers/c/gcc.vim

@@ -26,7 +26,8 @@ function! SyntaxCheckers_c_gcc_IsAvailable() dict
     if !exists('g:syntastic_c_compiler')
         let g:syntastic_c_compiler = executable(self.getExec()) ? self.getExec() : 'clang'
     endif
-    return executable(expand(g:syntastic_c_compiler))
+    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
@@ -55,4 +56,4 @@ call g:SyntasticRegistry.CreateAndRegisterChecker({
 let &cpo = s:save_cpo
 unlet s:save_cpo
 
-" vim: set et sts=4 sw=4:
+" vim: set sw=4 sts=4 et fdm=marker:

vim/bundle/syntastic/syntax_checkers/c/make.vim

@@ -58,4 +58,4 @@ call g:SyntasticRegistry.CreateAndRegisterChecker({
 let &cpo = s:save_cpo
 unlet s:save_cpo
 
-" vim: set et sts=4 sw=4:
+" vim: set sw=4 sts=4 et fdm=marker:

vim/bundle/syntastic/syntax_checkers/c/oclint.vim

@@ -8,13 +8,6 @@
 "             Want To Public License, Version 2, as published by Sam Hocevar.
 "             See http://sam.zoy.org/wtfpl/COPYING for more details.
 "============================================================================
-"
-" The setting 'g:syntastic_oclint_config_file' allows you to define a file
-" that contains additional compiler arguments like include directories or
-" CFLAGS. The file is expected to contain one option per line. If none is
-" given the filename defaults to '.syntastic_oclint_config':
-"
-"   let g:syntastic_oclint_config_file = '.config'
 
 if exists("g:loaded_syntastic_c_oclint_checker")
     finish
@@ -25,20 +18,22 @@ 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_before': '-- -c ' . syntastic#c#ReadConfig(g:syntastic_oclint_config_file) })
+        \ 'post_args': '-- -c ' . syntastic#c#ReadConfig(g:syntastic_oclint_config_file) })
 
     let errorformat =
-        \ '%E%f:%l:%c: %m P1 ,' .
-        \ '%E%f:%l:%c: %m P2 ,' .
-        \ '%W%f:%l:%c: %m P3 ,' .
         \ '%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({
@@ -48,7 +43,14 @@ function! SyntaxCheckers_c_oclint_GetLocList() dict
         \ 'postprocess': ['compressWhitespace'],
         \ 'returns': [0, 3, 5] })
 
-    call self.setWantSort(1)
+    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
@@ -60,4 +62,4 @@ call g:SyntasticRegistry.CreateAndRegisterChecker({
 let &cpo = s:save_cpo
 unlet s:save_cpo
 
-" vim: set et sts=4 sw=4:
+" vim: set sw=4 sts=4 et fdm=marker:

vim/bundle/syntastic/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/bundle/syntastic/syntax_checkers/c/sparse.vim

@@ -8,13 +8,6 @@
 "             Want To Public License, Version 2, as published by Sam Hocevar.
 "             See http://sam.zoy.org/wtfpl/COPYING for more details.
 "============================================================================
-"
-" The setting 'g:syntastic_sparse_config_file' allows you to define a file
-" that contains additional compiler arguments like include directories or
-" CFLAGS. The file is expected to contain one option per line. If none is
-" given the filename defaults to '.syntastic_sparse_config':
-"
-"   let g:syntastic_sparse_config_file = '.config'
 
 if exists("g:loaded_syntastic_c_sparse_checker")
     finish
@@ -33,13 +26,15 @@ function! SyntaxCheckers_c_sparse_GetLocList() dict
         \ '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 errorformat =
+        \ '%f:%l:%v: %trror: %m,' .
+        \ '%f:%l:%v: %tarning: %m,'
 
     let loclist = SyntasticMake({
         \ 'makeprg': makeprg,
         \ 'errorformat': errorformat,
         \ 'defaults': {'bufnr': bufnr("")},
-        \ 'returns': [0] })
+        \ 'returns': [0, 1] })
     return loclist
 endfunction
 
@@ -50,4 +45,4 @@ call g:SyntasticRegistry.CreateAndRegisterChecker({
 let &cpo = s:save_cpo
 unlet s:save_cpo
 
-" vim: set et sts=4 sw=4:
+" vim: set sw=4 sts=4 et fdm=marker:

vim/bundle/syntastic/syntax_checkers/c/splint.vim

@@ -8,13 +8,6 @@
 "             Want To Public License, Version 2, as published by Sam Hocevar.
 "             See http://sam.zoy.org/wtfpl/COPYING for more details.
 "============================================================================
-"
-" The setting 'g:syntastic_splint_config_file' allows you to define a file
-" that contains additional compiler arguments like include directories or
-" CFLAGS. The file is expected to contain one option per line. If none is
-" given the filename defaults to '.syntastic_splint_config':
-"
-"   let g:syntastic_splint_config_file = '.config'
 
 if exists("g:loaded_syntastic_c_splint_checker")
     finish
@@ -59,4 +52,4 @@ call g:SyntasticRegistry.CreateAndRegisterChecker({
 let &cpo = s:save_cpo
 unlet s:save_cpo
 
-" vim: set et sts=4 sw=4:
+" vim: set sw=4 sts=4 et fdm=marker:

vim/bundle/syntastic/syntax_checkers/cabal/cabal.vim

@@ -40,7 +40,7 @@ function! SyntaxCheckers_cabal_cabal_GetLocList() dict
     return SyntasticMake({
         \ 'makeprg': makeprg,
         \ 'errorformat': errorformat,
-        \ 'cwd': expand('%:p:h'),
+        \ 'cwd': expand('%:p:h', 1),
         \ 'preprocess': 'cabal',
         \ 'defaults': {'bufnr': bufnr('')} })
 endfunction
@@ -52,4 +52,4 @@ call g:SyntasticRegistry.CreateAndRegisterChecker({
 let &cpo = s:save_cpo
 unlet s:save_cpo
 
-" vim: set et sts=4 sw=4:
+" vim: set sw=4 sts=4 et fdm=marker:

vim/bundle/syntastic/syntax_checkers/chef/foodcritic.vim

@@ -36,4 +36,4 @@ call g:SyntasticRegistry.CreateAndRegisterChecker({
 let &cpo = s:save_cpo
 unlet s:save_cpo
 
-" vim: set et sts=4 sw=4:
+" vim: set sw=4 sts=4 et fdm=marker:

vim/bundle/syntastic/syntax_checkers/co/coco.vim

@@ -19,7 +19,7 @@ let s:save_cpo = &cpo
 set cpo&vim
 
 function! SyntaxCheckers_co_coco_GetLocList() dict
-    let tmpdir = $TMPDIR != '' ? $TMPDIR : $TMP != '' ? $TMP : '/tmp'
+    let tmpdir = syntastic#util#tmpdir()
     let makeprg = self.makeprgBuild({ 'args_after': '-c -o ' . tmpdir })
 
     let errorformat =
@@ -28,9 +28,13 @@ function! SyntaxCheckers_co_coco_GetLocList() dict
         \ '%EFailed at: %f,'.
         \ '%Z%trror: Parse error on line %l: %m'
 
-    return SyntasticMake({
+    let loclist = SyntasticMake({
         \ 'makeprg': makeprg,
         \ 'errorformat': errorformat })
+
+    call syntastic#util#rmrf(tmpdir)
+
+    return loclist
 endfunction
 
 call g:SyntasticRegistry.CreateAndRegisterChecker({
@@ -40,4 +44,4 @@ call g:SyntasticRegistry.CreateAndRegisterChecker({
 let &cpo = s:save_cpo
 unlet s:save_cpo
 
-" vim: set et sts=4 sw=4:
+" vim: set sw=4 sts=4 et fdm=marker:

vim/bundle/syntastic/syntax_checkers/cobol/cobc.vim

@@ -27,7 +27,8 @@ function! SyntaxCheckers_cobol_cobc_IsAvailable() dict
     if !exists('g:syntastic_cobol_compiler')
         let g:syntastic_cobol_compiler = self.getExec()
     endif
-    return executable(expand(g:syntastic_cobol_compiler))
+    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
@@ -43,4 +44,4 @@ call g:SyntasticRegistry.CreateAndRegisterChecker({
 let &cpo = s:save_cpo
 unlet s:save_cpo
 
-" vim: set et sts=4 sw=4:
+" vim: set sw=4 sts=4 et fdm=marker:

vim/bundle/syntastic/syntax_checkers/coffee/coffee.vim

@@ -22,9 +22,11 @@ let s:save_cpo = &cpo
 set cpo&vim
 
 function! SyntaxCheckers_coffee_coffee_IsAvailable() dict
-    return executable(self.getExec()) &&
-        \ syntastic#util#versionIsAtLeast(syntastic#util#getVersion(
-        \       self.getExecEscaped() . ' --version 2>' . syntastic#util#DevNull()), [1,6,2])
+    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
@@ -53,4 +55,4 @@ call g:SyntasticRegistry.CreateAndRegisterChecker({
 let &cpo = s:save_cpo
 unlet s:save_cpo
 
-" vim: set et sts=4 sw=4:
+" vim: set sw=4 sts=4 et fdm=marker:

vim/bundle/syntastic/syntax_checkers/coffee/coffeelint.vim

@@ -20,8 +20,7 @@ set cpo&vim
 
 function! SyntaxCheckers_coffee_coffeelint_GetLocList() dict
     if !exists('s:coffeelint_new')
-        let s:coffeelint_new = syntastic#util#versionIsAtLeast(syntastic#util#getVersion(
-            \ self.getExecEscaped() . ' --version'), [1, 4])
+        let s:coffeelint_new = syntastic#util#versionIsAtLeast(self.getVersion(), [1, 4])
     endif
     let makeprg = self.makeprgBuild({ 'args_after': (s:coffeelint_new ? '--reporter csv' : '--csv') })
 
@@ -45,4 +44,4 @@ call g:SyntasticRegistry.CreateAndRegisterChecker({
 let &cpo = s:save_cpo
 unlet s:save_cpo
 
-" vim: set et sts=4 sw=4:
+" vim: set sw=4 sts=4 et fdm=marker:

vim/bundle/syntastic/syntax_checkers/coq/coqtop.vim

@@ -37,4 +37,4 @@ call g:SyntasticRegistry.CreateAndRegisterChecker({
 let &cpo = s:save_cpo
 unlet s:save_cpo
 
-" vim: set et sts=4 sw=4:
+" vim: set sw=4 sts=4 et fdm=marker:

vim/bundle/syntastic/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/bundle/syntastic/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/bundle/syntastic/syntax_checkers/cpp/cppcheck.vim

@@ -8,13 +8,6 @@
 "             Want To Public License, Version 2, as published by Sam Hocevar.
 "             See http://sam.zoy.org/wtfpl/COPYING for more details.
 "============================================================================
-"
-" The setting 'g:syntastic_cppcheck_config_file' allows you to define a file
-" that contains additional compiler arguments like include directories or
-" CFLAGS. The file is expected to contain one option per line. If none is
-" given the filename defaults to '.syntastic_cppcheck_config':
-"
-"   let g:syntastic_cppcheck_config_file = '.config'
 
 if exists("g:loaded_syntastic_cpp_cppcheck_checker")
     finish
@@ -28,4 +21,4 @@ call g:SyntasticRegistry.CreateAndRegisterChecker({
     \ 'name': 'cppcheck',
     \ 'redirect': 'c/cppcheck'})
 
-" vim: set et sts=4 sw=4:
+" vim: set sw=4 sts=4 et fdm=marker:

vim/bundle/syntastic/syntax_checkers/cpp/cpplint.vim

@@ -9,18 +9,6 @@
 "             See http://sam.zoy.org/wtfpl/COPYING for more details.
 "
 "============================================================================
-"
-" For details about cpplint see:
-"    https://code.google.com/p/google-styleguide/
-"
-" Checker options:
-"
-" - g:syntastic_cpp_cpplint_thres (integer; default: 5)
-"   error threshold: policy violations with a severity above this
-"   value are highlighted as errors, the others are warnings
-"
-" - g:syntastic_cpp_cpplint_args (string; default: '--verbose=3')
-"   command line options to pass to cpplint
 
 if exists("g:loaded_syntastic_cpp_cpplint_checker")
     finish
@@ -61,4 +49,4 @@ call g:SyntasticRegistry.CreateAndRegisterChecker({
 let &cpo = s:save_cpo
 unlet s:save_cpo
 
-" vim: set et sts=4 sw=4:
+" vim: set sw=4 sts=4 et fdm=marker:

vim/bundle/syntastic/syntax_checkers/cpp/gcc.vim

@@ -26,7 +26,8 @@ function! SyntaxCheckers_cpp_gcc_IsAvailable() dict
     if !exists('g:syntastic_cpp_compiler')
         let g:syntastic_cpp_compiler = executable(self.getExec()) ? self.getExec() : 'clang++'
     endif
-    return executable(expand(g:syntastic_cpp_compiler))
+    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
@@ -52,4 +53,4 @@ call g:SyntasticRegistry.CreateAndRegisterChecker({
 let &cpo = s:save_cpo
 unlet s:save_cpo
 
-" vim: set et sts=4 sw=4:
+" vim: set sw=4 sts=4 et fdm=marker:

vim/bundle/syntastic/syntax_checkers/cpp/oclint.vim

@@ -8,13 +8,6 @@
 "             Want To Public License, Version 2, as published by Sam Hocevar.
 "             See http://sam.zoy.org/wtfpl/COPYING for more details.
 "============================================================================
-"
-" The setting 'g:syntastic_oclint_config_file' allows you to define a file
-" that contains additional compiler arguments like include directories or
-" CFLAGS. The file is expected to contain one option per line. If none is
-" given the filename defaults to '.syntastic_oclint_config':
-"
-"   let g:syntastic_oclint_config_file = '.config'
 
 if exists("g:loaded_syntastic_cpp_oclint_checker")
     finish
@@ -28,4 +21,4 @@ call g:SyntasticRegistry.CreateAndRegisterChecker({
     \ 'name': 'oclint',
     \ 'redirect': 'c/oclint'})
 
-" vim: set et sts=4 sw=4:
+" vim: set sw=4 sts=4 et fdm=marker:

vim/bundle/syntastic/syntax_checkers/cpp/pc_lint.vim

@@ -1,7 +1,7 @@
 "============================================================================
-"File:        avrgcc.vim
+"File:        pc_lint.vim
 "Description: Syntax checking plugin for syntastic.vim
-"Maintainer:  Karel <karelishere at gmail dot com>
+"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
@@ -10,17 +10,17 @@
 "
 "============================================================================
 
-if exists('g:loaded_syntastic_arduino_avrgcc_checker')
+if exists("g:loaded_syntastic_cpp_pc_lint_checker")
     finish
 endif
-let g:loaded_syntastic_arduino_avrgcc_checker = 1
+let g:loaded_syntastic_cpp_pc_lint_checker = 1
 
 runtime! syntax_checkers/c/*.vim
 
 call g:SyntasticRegistry.CreateAndRegisterChecker({
-    \ 'filetype': 'arduino',
-    \ 'name': 'avrgcc',
-    \ 'exec': 'avr-gcc',
-    \ 'redirect': 'c/avrgcc'})
+    \ 'filetype': 'cpp',
+    \ 'name': 'pc_lint',
+    \ 'exec': 'lint-nt',
+    \ 'redirect': 'c/pc_lint'})
 
-" vim: set et sts=4 sw=4:
+" vim: set sw=4 sts=4 et fdm=marker:

vim/bundle/syntastic/syntax_checkers/cs/mcs.vim

@@ -36,4 +36,4 @@ call g:SyntasticRegistry.CreateAndRegisterChecker({
 let &cpo = s:save_cpo
 unlet s:save_cpo
 
-" vim: set et sts=4 sw=4:
+" vim: set sw=4 sts=4 et fdm=marker:

vim/bundle/syntastic/syntax_checkers/css/csslint.vim

@@ -8,11 +8,6 @@
 "             Want To Public License, Version 2, as published by Sam Hocevar.
 "             See http://sam.zoy.org/wtfpl/COPYING for more details.
 "============================================================================
-"
-" Specify additional options to csslint with this option. e.g. to disable
-" warnings:
-"
-"   let g:syntastic_csslint_options = '--warnings=none'
 
 if exists('g:loaded_syntastic_css_csslint_checker')
     finish
@@ -49,4 +44,4 @@ call g:SyntasticRegistry.CreateAndRegisterChecker({
 let &cpo = s:save_cpo
 unlet s:save_cpo
 
-" vim: set et sts=4 sw=4:
+" vim: set sw=4 sts=4 et fdm=marker:

vim/bundle/syntastic/syntax_checkers/css/phpcs.vim

@@ -9,10 +9,6 @@
 "             See http://sam.zoy.org/wtfpl/COPYING for more details.
 "
 "============================================================================
-"
-" See here for details of phpcs
-"    - phpcs (see http://pear.php.net/package/PHP_CodeSniffer)
-"
 
 if exists("g:loaded_syntastic_css_phpcs_checker")
     finish
@@ -26,4 +22,4 @@ call g:SyntasticRegistry.CreateAndRegisterChecker({
     \ 'name': 'phpcs',
     \ 'redirect': 'php/phpcs'})
 
-" vim: set et sts=4 sw=4:
+" vim: set sw=4 sts=4 et fdm=marker:

vim/bundle/syntastic/syntax_checkers/css/prettycss.vim

@@ -9,17 +9,16 @@
 "             See http://sam.zoy.org/wtfpl/COPYING for more details.
 "
 "============================================================================
-"
-" For details about PrettyCSS see:
-"
-"   - http://fidian.github.io/PrettyCSS/
-"   - https://github.com/fidian/PrettyCSS
 
 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
 
@@ -49,8 +48,6 @@ function! SyntaxCheckers_css_prettycss_GetLocList() dict
         let e["text"] .= ')'
     endfor
 
-    call self.setWantSort(1)
-
     return loclist
 endfunction
 
@@ -61,4 +58,4 @@ call g:SyntasticRegistry.CreateAndRegisterChecker({
 let &cpo = s:save_cpo
 unlet s:save_cpo
 
-" vim: set et sts=4 sw=4:
+" vim: set sw=4 sts=4 et fdm=marker:

vim/bundle/syntastic/syntax_checkers/css/recess.vim

@@ -23,4 +23,4 @@ call g:SyntasticRegistry.CreateAndRegisterChecker({
     \ 'name': 'recess',
     \ 'redirect': 'less/recess'})
 
-" vim: set et sts=4 sw=4:
+" vim: set sw=4 sts=4 et fdm=marker:

vim/bundle/syntastic/syntax_checkers/cucumber/cucumber.vim

@@ -39,4 +39,4 @@ call g:SyntasticRegistry.CreateAndRegisterChecker({
 let &cpo = s:save_cpo
 unlet s:save_cpo
 
-" vim: set et sts=4 sw=4:
+" vim: set sw=4 sts=4 et fdm=marker:

vim/bundle/syntastic/syntax_checkers/cuda/nvcc.vim

@@ -6,18 +6,6 @@
 "
 "============================================================================
 
-" in order to also check header files add this to your .vimrc:
-" (this creates an empty .syntastic_dummy.cu file in your source directory)
-"
-"   let g:syntastic_cuda_check_header = 1
-
-" By default, nvcc and thus syntastic, defaults to the most basic architecture.
-" This can produce false errors if the developer intends to compile for newer
-" hardware and use newer features, eg. double precision numbers. To pass a
-" specific target arch to nvcc, e.g. add the following to your .vimrc:
-"
-"   let g:syntastic_cuda_arch = "sm_20"
-
 if exists("g:loaded_syntastic_cuda_nvcc_checker")
     finish
 endif
@@ -53,7 +41,7 @@ function! SyntaxCheckers_cuda_nvcc_GetLocList() dict
         \ '%DMaking %*\a in %f,'.
         \ '%f|%l| %m'
 
-    if expand('%') =~? '\m\%(.h\|.hpp\|.cuh\)$'
+    if expand('%', 1) =~? '\m\%(.h\|.hpp\|.cuh\)$'
         if exists('g:syntastic_cuda_check_header')
             let makeprg =
                 \ 'echo > .syntastic_dummy.cu ; ' .
@@ -75,4 +63,4 @@ call g:SyntasticRegistry.CreateAndRegisterChecker({
 let &cpo = s:save_cpo
 unlet s:save_cpo
 
-" vim: set et sts=4 sw=4:
+" vim: set sw=4 sts=4 et fdm=marker:

vim/bundle/syntastic/syntax_checkers/d/dmd.vim

@@ -31,7 +31,8 @@ function! SyntaxCheckers_d_dmd_IsAvailable() dict
     if !exists('g:syntastic_d_compiler')
         let g:syntastic_d_compiler = self.getExec()
     endif
-    return executable(expand(g:syntastic_d_compiler))
+    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
@@ -56,4 +57,4 @@ call g:SyntasticRegistry.CreateAndRegisterChecker({
 let &cpo = s:save_cpo
 unlet s:save_cpo
 
-" vim: set et sts=4 sw=4:
+" vim: set sw=4 sts=4 et fdm=marker:

vim/bundle/syntastic/syntax_checkers/dart/dartanalyzer.vim

@@ -53,7 +53,7 @@ function! SyntaxCheckers_dart_dartanalyzer_GetLocList() dict
     let loclist = SyntasticMake({
         \ 'makeprg': makeprg,
         \ 'errorformat': errorformat,
-        \ 'returns': [0, 1, 2] })
+        \ 'returns': [0, 1, 2, 3] })
 
     for e in loclist
         let e['text'] = substitute(e['text'], '\m\\\([\\|]\)', '\1', 'g')
@@ -73,4 +73,4 @@ call g:SyntasticRegistry.CreateAndRegisterChecker({
 let &cpo = s:save_cpo
 unlet s:save_cpo
 
-" vim: set et sts=4 sw=4:
+" vim: set sw=4 sts=4 et fdm=marker:

vim/bundle/syntastic/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/bundle/syntastic/syntax_checkers/docbk/xmllint.vim

@@ -22,4 +22,4 @@ call g:SyntasticRegistry.CreateAndRegisterChecker({
     \ 'name': 'xmllint',
     \ 'redirect': 'xml/xmllint'})
 
-" vim: set et sts=4 sw=4:
+" vim: set sw=4 sts=4 et fdm=marker:

vim/bundle/syntastic/syntax_checkers/dustjs/swiffer.vim

@@ -35,4 +35,4 @@ call SyntasticRegistry.CreateAndRegisterChecker({
 let &cpo = s:save_cpo
 unlet s:save_cpo
 
-" vim: set et sts=4 sw=4:
+" vim: set sw=4 sts=4 et fdm=marker:

vim/bundle/syntastic/syntax_checkers/elixir/elixir.vim

@@ -20,6 +20,9 @@ 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
 
@@ -32,7 +35,7 @@ function! SyntaxCheckers_elixir_elixir_GetLocList() dict
 
     let make_options = {}
     let compile_command = 'elixir'
-    let mix_file = syntastic#util#findInParent('mix.exs', expand('%:p:h'))
+    let mix_file = syntastic#util#findInParent('mix.exs', expand('%:p:h', 1))
 
     if filereadable(mix_file)
         let compile_command = 'mix compile'
@@ -53,4 +56,4 @@ call g:SyntasticRegistry.CreateAndRegisterChecker({
 let &cpo = s:save_cpo
 unlet s:save_cpo
 
-" vim: set et sts=4 sw=4:
+" vim: set sw=4 sts=4 et fdm=marker:

vim/bundle/syntastic/syntax_checkers/erlang/erlang_check_file.erl

@@ -32,7 +32,7 @@ main([FileName, "-rebar", Path, LibDirs]) ->
     %io:format("~p~n", [LibDirs1]),
     compile(FileName, LibDirs1);
 
-main([FileName, LibDirs]) ->
+main([FileName | LibDirs]) ->
     compile(FileName, LibDirs).
 
 compile(FileName, LibDirs) ->
@@ -45,7 +45,12 @@ compile(FileName, LibDirs) ->
                   warn_export_vars,
                   strong_validation,
                   report] ++
-                 [{i, filename:join(Root, I)} || I <- LibDirs]).
+                 [{i, filename:join(Root, I)} || I <- LibDirs] ++
+                 case lists:member("deps/pmod_transform/include", LibDirs) of
+                     true -> [{parse_transform, pmod_pt}];
+                     _    -> []
+                 end
+                ).
 
 get_root(Dir) ->
     Path = filename:split(filename:absname(Dir)),

vim/bundle/syntastic/syntax_checkers/erlang/escript.vim

@@ -19,13 +19,13 @@ 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') . syntastic#util#Slash() . 'erlang_check_file.erl')
+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') ==# 'hrl'
+    if expand('%:e', 1) ==# 'hrl'
         return []
     endif
 
@@ -58,4 +58,4 @@ call g:SyntasticRegistry.CreateAndRegisterChecker({
 let &cpo = s:save_cpo
 unlet s:save_cpo
 
-" vim: set et sts=4 sw=4:
+" vim: set sw=4 sts=4 et fdm=marker:

vim/bundle/syntastic/syntax_checkers/erlang/syntaxerl.vim

@@ -39,4 +39,4 @@ call g:SyntasticRegistry.CreateAndRegisterChecker({
 let &cpo = s:save_cpo
 unlet s:save_cpo
 
-" vim: set et sts=4 sw=4:
+" vim: set sw=4 sts=4 et fdm=marker:

vim/bundle/syntastic/syntax_checkers/eruby/ruby.vim

@@ -21,15 +21,20 @@ 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
-    let fname = "'" . escape(expand('%'), "\\'") . "'"
+    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 syntastic#util#versionIsAtLeast(syntastic#util#getVersion(self.getExecEscaped(). ' --version'), [1, 9])
+    if s:ruby_new
         let enc = &fileencoding != '' ? &fileencoding : &encoding
         let encoding_spec = ', :encoding => "' . (enc ==? 'utf-8' ? 'UTF-8' : 'BINARY') . '"'
     else
@@ -42,9 +47,16 @@ function! SyntaxCheckers_eruby_ruby_GetLocList() dict
         \ syntastic#util#shescape('puts ERB.new(File.read(' .
         \     fname . encoding_spec .
         \     ').gsub(''<%='',''<%''), nil, ''-'').src') .
-        \ ' | ' . self.getExecEscaped() . ' -c'
+        \ ' | ' . 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 =
+    let errorformat .=
         \ '%-GSyntax OK,'.
         \ '%E-:%l: syntax error\, %m,%Z%p^,'.
         \ '%W-:%l: warning: %m,'.
@@ -67,4 +79,4 @@ call g:SyntasticRegistry.CreateAndRegisterChecker({
 let &cpo = s:save_cpo
 unlet s:save_cpo
 
-" vim: set et sts=4 sw=4:
+" vim: set sw=4 sts=4 et fdm=marker:

vim/bundle/syntastic/syntax_checkers/fortran/gfortran.vim

@@ -26,7 +26,8 @@ function! SyntaxCheckers_fortran_gfortran_IsAvailable() dict
     if !exists('g:syntastic_fortran_compiler')
         let g:syntastic_fortran_compiler = self.getExec()
     endif
-    return executable(expand(g:syntastic_fortran_compiler))
+    call self.log('g:syntastic_fortran_compiler = ', g:syntastic_fortran_compiler)
+    return executable(expand(g:syntastic_fortran_compiler, 1))
 endfunction
 
 function! SyntaxCheckers_fortran_gfortran_GetLocList() dict
@@ -48,4 +49,4 @@ call g:SyntasticRegistry.CreateAndRegisterChecker({
 let &cpo = s:save_cpo
 unlet s:save_cpo
 
-" vim: set et sts=4 sw=4:
+" vim: set sw=4 sts=4 et fdm=marker:

vim/bundle/syntastic/syntax_checkers/glsl/cgc.vim

@@ -27,7 +27,7 @@ let s:glsl_extensions = {
 let s:save_cpo = &cpo
 set cpo&vim
 
-function! SyntaxCheckers_glsl_cgc_GetLocList() dict
+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 : '') })
@@ -39,9 +39,11 @@ function! SyntaxCheckers_glsl_cgc_GetLocList() dict
     return SyntasticMake({
         \ 'makeprg': makeprg,
         \ 'errorformat': errorformat })
-endfunction
+endfunction " }}}1
 
-function! s:GetProfile()
+" Utilities {{{1
+
+function! s:GetProfile() " {{{2
     let save_view = winsaveview()
     let old_foldenable = &foldenable
     let old_lazyredraw = &lazyredraw
@@ -61,11 +63,13 @@ function! s:GetProfile()
         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')), 'gpu_vert')
+        let profile = get(extensions, tolower(expand('%:e', 1)), 'gpu_vert')
     endif
 
     return profile
-endfunction
+endfunction " }}}2
+
+" }}}1
 
 call g:SyntasticRegistry.CreateAndRegisterChecker({
     \'filetype': 'glsl',
@@ -74,4 +78,4 @@ call g:SyntasticRegistry.CreateAndRegisterChecker({
 let &cpo = s:save_cpo
 unlet s:save_cpo
 
-" vim: set et sts=4 sw=4:
+" vim: set sw=4 sts=4 et fdm=marker:

vim/bundle/syntastic/syntax_checkers/go/go.vim

@@ -8,10 +8,11 @@
 "             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
@@ -22,7 +23,7 @@ let s:save_cpo = &cpo
 set cpo&vim
 
 function! SyntaxCheckers_go_go_IsAvailable() dict
-    return executable('go') && executable('gofmt')
+    return executable(self.getExec()) && executable('gofmt')
 endfunction
 
 function! SyntaxCheckers_go_go_GetLocList() dict
@@ -48,13 +49,17 @@ function! SyntaxCheckers_go_go_GetLocList() dict
 
     " 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('%'), '\m_test\.go$') == -1
-        let makeprg = 'go build ' . syntastic#c#NullOutput()
+    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 makeprg = 'go test -c ' . syntastic#c#NullOutput()
+        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 =
@@ -71,11 +76,11 @@ function! SyntaxCheckers_go_go_GetLocList() dict
     let errors = SyntasticMake({
         \ 'makeprg': makeprg,
         \ 'errorformat': errorformat,
-        \ 'cwd': expand('%:p:h'),
+        \ 'cwd': expand('%:p:h', 1),
         \ 'defaults': {'type': 'e'} })
 
     if cleanup
-        call delete(expand('%:p:h') . syntastic#util#Slash() . expand('%:p:h:t') . '.test')
+        call delete(expand('%:p:h', 1) . syntastic#util#Slash() . expand('%:p:h:t', 1) . '.test')
     endif
 
     return errors
@@ -88,4 +93,4 @@ call g:SyntasticRegistry.CreateAndRegisterChecker({
 let &cpo = s:save_cpo
 unlet s:save_cpo
 
-" vim: set et sts=4 sw=4:
+" vim: set sw=4 sts=4 et fdm=marker:

vim/bundle/syntastic/syntax_checkers/go/gofmt.vim

@@ -8,10 +8,11 @@
 "             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
@@ -41,4 +42,4 @@ call g:SyntasticRegistry.CreateAndRegisterChecker({
 let &cpo = s:save_cpo
 unlet s:save_cpo
 
-" vim: set et sts=4 sw=4:
+" vim: set sw=4 sts=4 et fdm=marker:

vim/bundle/syntastic/syntax_checkers/go/golint.vim

@@ -21,11 +21,14 @@ set cpo&vim
 function! SyntaxCheckers_go_golint_GetLocList() dict
     let makeprg = self.makeprgBuild({})
 
-    let errorformat = '%f:%l:%c: %m,%-G%.%#'
+    let errorformat =
+        \ '%f:%l:%c: %m,' .
+        \ '%-G%.%#'
 
     return SyntasticMake({
         \ 'makeprg': makeprg,
         \ 'errorformat': errorformat,
+        \ 'defaults': {'type': 'w'},
         \ 'subtype': 'Style' })
 endfunction
 
@@ -36,4 +39,4 @@ call g:SyntasticRegistry.CreateAndRegisterChecker({
 let &cpo = s:save_cpo
 unlet s:save_cpo
 
-" vim: set et sts=4 sw=4:
+" vim: set sw=4 sts=4 et fdm=marker:

vim/bundle/syntastic/syntax_checkers/go/gotype.vim

@@ -29,13 +29,11 @@ function! SyntaxCheckers_go_gotype_GetLocList() dict
     " the package for the same reasons specified in go.vim ("figuring out
     " the import path is fickle").
 
-    let errors = SyntasticMake({
+    return SyntasticMake({
         \ 'makeprg': makeprg,
         \ 'errorformat': errorformat,
-        \ 'cwd': expand('%:p:h'),
+        \ 'cwd': expand('%:p:h', 1),
         \ 'defaults': {'type': 'e'} })
-
-    return errors
 endfunction
 
 call g:SyntasticRegistry.CreateAndRegisterChecker({
@@ -45,4 +43,4 @@ call g:SyntasticRegistry.CreateAndRegisterChecker({
 let &cpo = s:save_cpo
 unlet s:save_cpo
 
-" vim: set et sts=4 sw=4:
+" vim: set sw=4 sts=4 et fdm=marker:

vim/bundle/syntastic/syntax_checkers/go/govet.vim

@@ -19,31 +19,34 @@ let s:save_cpo = &cpo
 set cpo&vim
 
 function! SyntaxCheckers_go_govet_IsAvailable() dict
-    return executable('go')
+    return executable(self.getExec())
 endfunction
 
 function! SyntaxCheckers_go_govet_GetLocList() dict
-    let makeprg = 'go vet'
-    let errorformat = '%Evet: %.%\+: %f:%l:%c: %m,%W%f:%l: %m,%-G%.%#'
+    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.
 
-    let errors = SyntasticMake({
+    return SyntasticMake({
         \ 'makeprg': makeprg,
         \ 'errorformat': errorformat,
-        \ 'cwd': expand('%:p:h'),
+        \ 'cwd': expand('%:p:h', 1),
         \ 'defaults': {'type': 'w'} })
-
-    return errors
 endfunction
 
 call g:SyntasticRegistry.CreateAndRegisterChecker({
     \ 'filetype': 'go',
-    \ 'name': 'govet'})
+    \ 'name': 'govet',
+    \ 'exec': 'go' })
 
 let &cpo = s:save_cpo
 unlet s:save_cpo
 
-" vim: set et sts=4 sw=4:
+" vim: set sw=4 sts=4 et fdm=marker:

vim/bundle/syntastic/syntax_checkers/haml/haml.vim

@@ -43,4 +43,4 @@ call g:SyntasticRegistry.CreateAndRegisterChecker({
 let &cpo = s:save_cpo
 unlet s:save_cpo
 
-" vim: set et sts=4 sw=4:
+" vim: set sw=4 sts=4 et fdm=marker:

vim/bundle/syntastic/syntax_checkers/haml/haml_lint.vim

@@ -34,4 +34,4 @@ call g:SyntasticRegistry.CreateAndRegisterChecker({
 let &cpo = s:save_cpo
 unlet s:save_cpo
 
-" vim: set et sts=4 sw=4:
+" vim: set sw=4 sts=4 et fdm=marker:

vim/bundle/syntastic/syntax_checkers/handlebars/handlebars.vim

@@ -29,6 +29,7 @@ function! SyntaxCheckers_handlebars_handlebars_GetLocList() dict
     return SyntasticMake({
         \ 'makeprg': makeprg,
         \ 'errorformat': errorformat,
+        \ 'postprocess': ['guards'],
         \ 'defaults': {'bufnr': bufnr("")} })
 endfunction
 
@@ -39,4 +40,4 @@ call g:SyntasticRegistry.CreateAndRegisterChecker({
 let &cpo = s:save_cpo
 unlet s:save_cpo
 
-" vim: set et sts=4 sw=4:
+" vim: set sw=4 sts=4 et fdm=marker:

vim/bundle/syntastic/syntax_checkers/haskell/ghc-mod.vim

@@ -21,10 +21,33 @@ let s:save_cpo = &cpo
 set cpo&vim
 
 function! SyntaxCheckers_haskell_ghc_mod_IsAvailable() dict
-    " We need either a Vim version that can handle NULs in system() output,
-    " or a ghc-mod version that has the --boundary option.
-    let exe = self.getExec()
-    let s:ghc_mod_new = executable(exe) ? s:GhcModNew(exe) : -1
+    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(system(self.getExecEscaped() . ' version'), '\n'), 'v:val =~# ''\m\sversion''')
+    if !len(ver)
+        " That didn't work.  Try "ghc-mod" alone.
+        let ver = filter(split(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
 
@@ -49,18 +72,6 @@ function! SyntaxCheckers_haskell_ghc_mod_GetLocList() dict
         \ 'returns': [0] })
 endfunction
 
-function! s:GhcModNew(exe)
-    let exe = syntastic#util#shescape(a:exe)
-    try
-        let ghc_mod_version = filter(split(system(exe), '\n'), 'v:val =~# ''\m^ghc-mod version''')[0]
-        let ret = syntastic#util#versionIsAtLeast(syntastic#util#parseVersion(ghc_mod_version), [2, 1, 2])
-    catch /\m^Vim\%((\a\+)\)\=:E684/
-        call syntastic#log#error("checker haskell/ghc_mod: can't parse version string (abnormal termination?)")
-        let ret = -1
-    endtry
-    return ret
-endfunction
-
 call g:SyntasticRegistry.CreateAndRegisterChecker({
     \ 'filetype': 'haskell',
     \ 'name': 'ghc_mod',
@@ -69,4 +80,4 @@ call g:SyntasticRegistry.CreateAndRegisterChecker({
 let &cpo = s:save_cpo
 unlet s:save_cpo
 
-" vim: set et sts=4 sw=4:
+" vim: set sw=4 sts=4 et fdm=marker:

vim/bundle/syntastic/syntax_checkers/haskell/hdevtools.vim

@@ -53,4 +53,4 @@ call g:SyntasticRegistry.CreateAndRegisterChecker({
 let &cpo = s:save_cpo
 unlet s:save_cpo
 
-" vim: set et sts=4 sw=4:
+" vim: set sw=4 sts=4 et fdm=marker:

vim/bundle/syntastic/syntax_checkers/haskell/hlint.vim

@@ -36,4 +36,4 @@ call g:SyntasticRegistry.CreateAndRegisterChecker({
 let &cpo = s:save_cpo
 unlet s:save_cpo
 
-" vim: set et sts=4 sw=4:
+" vim: set sw=4 sts=4 et fdm=marker:

vim/bundle/syntastic/syntax_checkers/haskell/scan.vim

@@ -15,6 +15,10 @@ if exists('g:loaded_syntastic_haskell_scan_checker')
 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
 
@@ -23,14 +27,10 @@ function! SyntaxCheckers_haskell_scan_GetLocList() dict
 
     let errorformat = '%f:%l:%v: %m'
 
-    let loclist = SyntasticMake({
+    return SyntasticMake({
         \ 'makeprg': makeprg,
         \ 'errorformat': errorformat,
         \ 'subtype': 'Style' })
-
-    call self.setWantSort(1)
-
-    return loclist
 endfunction
 
 call g:SyntasticRegistry.CreateAndRegisterChecker({
@@ -40,4 +40,4 @@ call g:SyntasticRegistry.CreateAndRegisterChecker({
 let &cpo = s:save_cpo
 unlet s:save_cpo
 
-" vim: set et sts=4 sw=4:
+" vim: set sw=4 sts=4 et fdm=marker:

vim/bundle/syntastic/syntax_checkers/haxe/haxe.vim

@@ -24,10 +24,12 @@ function! SyntaxCheckers_haxe_haxe_GetLocList() dict
     elseif exists('g:vaxe_hxml')
         let hxml = g:vaxe_hxml
     else
-        let hxml = syntastic#util#findInParent('*.hxml', expand('%:p:h'))
+        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')) })
@@ -58,4 +60,4 @@ call g:SyntasticRegistry.CreateAndRegisterChecker({
 let &cpo = s:save_cpo
 unlet s:save_cpo
 
-" vim: set et sts=4 sw=4:
+" vim: set sw=4 sts=4 et fdm=marker:

vim/bundle/syntastic/syntax_checkers/hss/hss.vim

@@ -35,4 +35,4 @@ call g:SyntasticRegistry.CreateAndRegisterChecker({
 let &cpo = s:save_cpo
 unlet s:save_cpo
 
-" vim: set et sts=4 sw=4:
+" vim: set sw=4 sts=4 et fdm=marker:

vim/bundle/syntastic/syntax_checkers/html/jshint.vim

@@ -19,8 +19,10 @@ set cpo&vim
 
 function! SyntaxCheckers_html_jshint_IsAvailable() dict
     call syntastic#log#deprecationWarn('jshint_exec', 'html_jshint_exec')
-    return executable(self.getExec()) &&
-        \ syntastic#util#versionIsAtLeast(syntastic#util#getVersion(self.getExecEscaped() . ' --version'), [2,4])
+    if !executable(self.getExec())
+        return 0
+    endif
+    return syntastic#util#versionIsAtLeast(self.getVersion(), [2, 4])
 endfunction
 
 function! SyntaxCheckers_html_jshint_GetLocList() dict
@@ -31,8 +33,6 @@ function! SyntaxCheckers_html_jshint_GetLocList() dict
 
     let errorformat = '%A%f: line %l\, col %v\, %m \(%t%*\d\)'
 
-    call self.setWantSort(1)
-
     return SyntasticMake({
         \ 'makeprg': makeprg,
         \ 'errorformat': errorformat,
@@ -47,4 +47,4 @@ call g:SyntasticRegistry.CreateAndRegisterChecker({
 let &cpo = s:save_cpo
 unlet s:save_cpo
 
-" vim: set et sts=4 sw=4:
+" vim: set sw=4 sts=4 et fdm=marker:

vim/bundle/syntastic/syntax_checkers/html/tidy.vim

@@ -17,23 +17,17 @@
 "
 " HTML Tidy for HTML5 can be used without changes by this checker, just install
 " it and point g:syntastic_html_tidy_exec to the executable.
-"
-" Checker options:
-"
-" - g:syntastic_html_tidy_ignore_errors (list; default: [])
-"   list of errors to ignore
-" - g:syntastic_html_tidy_blocklevel_tags (list; default: [])
-"   list of additional blocklevel tags, to be added to "--new-blocklevel-tags"
-" - g:syntastic_html_tidy_inline_tags (list; default: [])
-"   list of additional inline tags, to be added to "--new-inline-tags"
-" - g:syntastic_html_tidy_empty_tags (list; default: [])
-"   list of additional empty tags, to be added to "--new-empty-tags"
 
 if exists("g:loaded_syntastic_html_tidy_checker")
     finish
 endif
 let g:loaded_syntastic_html_tidy_checker = 1
 
+let s:save_cpo = &cpo
+set cpo&vim
+
+" Checker options {{{1
+
 if !exists('g:syntastic_html_tidy_ignore_errors')
     let g:syntastic_html_tidy_ignore_errors = []
 endif
@@ -50,29 +44,11 @@ if !exists('g:syntastic_html_tidy_empty_tags')
     let g:syntastic_html_tidy_empty_tags = []
 endif
 
-let s:save_cpo = &cpo
-set cpo&vim
+" }}}1
 
-" TODO: join this with xhtml.vim for DRY's sake?
-function! s:TidyEncOptByFenc()
-    let tidy_opts = {
-            \ 'utf-8':        '-utf8',
-            \ 'ascii':        '-ascii',
-            \ 'latin1':       '-latin1',
-            \ 'iso-2022-jp':  '-iso-2022',
-            \ 'cp1252':       '-win1252',
-            \ 'macroman':     '-mac',
-            \ 'utf-16le':     '-utf16le',
-            \ 'utf-16':       '-utf16',
-            \ 'big5':         '-big5',
-            \ 'cp932':        '-shiftjis',
-            \ 'sjis':         '-shiftjis',
-            \ 'cp850':        '-ibm858',
-        \ }
-    return get(tidy_opts, &fileencoding, '-utf8')
-endfunction
+" Constants {{{1
 
-let s:ignore_errors = [
+let s:IGNORE_ERRORS = [
         \ "<table> lacks \"summary\" attribute",
         \ "not approved by W3C",
         \ "<input> proprietary attribute \"placeholder\"",
@@ -123,9 +99,9 @@ let s:ignore_errors = [
         \ "proprietary attribute \"aria-valuenow\"",
         \ "proprietary attribute \"aria-valuetext\""
     \ ]
-lockvar! s:ignore_errors
+lockvar! s:IGNORE_ERRORS
 
-let s:blocklevel_tags = [
+let s:BLOCKLEVEL_TAGS = [
         \ "main",
         \ "section",
         \ "article",
@@ -136,9 +112,9 @@ let s:blocklevel_tags = [
         \ "figure",
         \ "figcaption"
     \ ]
-lockvar! s:blocklevel_tags
+lockvar! s:BLOCKLEVEL_TAGS
 
-let s:inline_tags = [
+let s:INLINE_TAGS = [
         \ "video",
         \ "audio",
         \ "source",
@@ -155,37 +131,17 @@ let s:inline_tags = [
         \ "details",
         \ "datalist"
     \ ]
-lockvar! s:inline_tags
+lockvar! s:INLINE_TAGS
 
-let s:empty_tags = [
+let s:EMPTY_TAGS = [
         \ "wbr",
         \ "keygen"
     \ ]
-lockvar! s:empty_tags
-
-function! s:IgnoreError(text)
-    for i in s:ignore_errors + g:syntastic_html_tidy_ignore_errors
-        if stridx(a:text, i) != -1
-            return 1
-        endif
-    endfor
-    return 0
-endfunction
-
-function! s:NewTags(name)
-    return syntastic#util#shescape(join( s:{a:name} + g:syntastic_html_tidy_{a:name}, ',' ))
-endfunction
+lockvar! s:EMPTY_TAGS
 
-function! s:Args()
-    let args = s:TidyEncOptByFenc() .
-        \ ' --new-blocklevel-tags ' . s:NewTags('blocklevel_tags') .
-        \ ' --new-inline-tags ' . s:NewTags('inline_tags') .
-        \ ' --new-empty-tags ' . s:NewTags('empty_tags') .
-        \ ' -e'
-    return args
-endfunction
+" }}}1
 
-function! SyntaxCheckers_html_tidy_GetLocList() dict
+function! SyntaxCheckers_html_tidy_GetLocList() dict " {{{1
     let makeprg = self.makeprgBuild({ 'args_after': s:Args() })
 
     let errorformat =
@@ -207,7 +163,52 @@ function! SyntaxCheckers_html_tidy_GetLocList() dict
     endfor
 
     return loclist
-endfunction
+endfunction " }}}1
+
+" Utilities {{{1
+
+" TODO: join this with xhtml.vim for DRY's sake?
+function! s:TidyEncOptByFenc() " {{{2
+    let TIDY_OPTS = {
+            \ 'utf-8':        '-utf8',
+            \ 'ascii':        '-ascii',
+            \ 'latin1':       '-latin1',
+            \ 'iso-2022-jp':  '-iso-2022',
+            \ 'cp1252':       '-win1252',
+            \ 'macroman':     '-mac',
+            \ 'utf-16le':     '-utf16le',
+            \ 'utf-16':       '-utf16',
+            \ 'big5':         '-big5',
+            \ 'cp932':        '-shiftjis',
+            \ 'sjis':         '-shiftjis',
+            \ 'cp850':        '-ibm858',
+        \ }
+    return get(TIDY_OPTS, &fileencoding, '-utf8')
+endfunction " }}}2
+
+function! s:IgnoreError(text) " {{{2
+    for item in s:IGNORE_ERRORS + g:syntastic_html_tidy_ignore_errors
+        if stridx(a:text, item) != -1
+            return 1
+        endif
+    endfor
+    return 0
+endfunction " }}}2
+
+function! s:NewTags(name) " {{{2
+    return syntastic#util#shescape(join( s:{toupper(a:name)} + g:syntastic_html_tidy_{a:name}, ',' ))
+endfunction " }}}2
+
+function! s:Args() " {{{2
+    let args = s:TidyEncOptByFenc() .
+        \ ' --new-blocklevel-tags ' . s:NewTags('blocklevel_tags') .
+        \ ' --new-inline-tags ' . s:NewTags('inline_tags') .
+        \ ' --new-empty-tags ' . s:NewTags('empty_tags') .
+        \ ' -e'
+    return args
+endfunction " }}}2
+
+" }}}1
 
 call g:SyntasticRegistry.CreateAndRegisterChecker({
     \ 'filetype': 'html',
@@ -216,4 +217,4 @@ call g:SyntasticRegistry.CreateAndRegisterChecker({
 let &cpo = s:save_cpo
 unlet s:save_cpo
 
-" vim: set et sts=4 sw=4:
+" vim: set sw=4 sts=4 et fdm=marker:

vim/bundle/syntastic/syntax_checkers/html/validator.vim

@@ -9,24 +9,6 @@
 "             See http://sam.zoy.org/wtfpl/COPYING for more details.
 "
 "============================================================================
-"
-" For detail;s about validator see: http://about.validator.nu/
-"
-" Checker options:
-"
-" - g:syntastic_html_validator_api (string; default: 'http://validator.nu/')
-"   URL of the service to use for checking; leave it to the default to run the
-"   checks against http://validator.nu/, or set it to 'http://localhost:8888/'
-"   if you're running a local service as per http://about.validator.nu/#src
-"
-" - g:syntastic_html_validator_parser (string; default: empty)
-"   parser to use; legal values are: xml, xmldtd, html, html5, html4, html4tr;
-"   set it to 'html5' to check HTML5 files;  see the wiki for reference:
-"   http://wiki.whatwg.org/wiki/Validator.nu_Common_Input_Parameters#parser
-"
-" - g:syntastic_html_validator_nsfilter (string; default: empty)
-"   sets the nsfilter for the parser; see the wiki for details:
-"   http://wiki.whatwg.org/wiki/Validator.nu_Common_Input_Parameters#nsfilter
 
 if exists("g:loaded_syntastic_html_validator_checker")
     finish
@@ -50,7 +32,7 @@ set cpo&vim
 
 function! SyntaxCheckers_html_validator_GetLocList() dict
     let fname = syntastic#util#shexpand('%')
-    let makeprg = self.getExecEscaped() . ' -s --compressed -F out=gnu -F asciiquotes=yes' .
+    let makeprg = self.getExecEscaped() . ' -q -s --compressed -F out=gnu -F asciiquotes=yes' .
         \ (g:syntastic_html_validator_parser != '' ? ' -F parser=' . g:syntastic_html_validator_parser : '') .
         \ (g:syntastic_html_validator_nsfilter != '' ? ' -F nsfilter=' . g:syntastic_html_validator_nsfilter : '') .
         \ ' -F doc=@' . fname . '\;type=text/html\;filename=' . fname . ' ' . g:syntastic_html_validator_api
@@ -84,4 +66,4 @@ call g:SyntasticRegistry.CreateAndRegisterChecker({
 let &cpo = s:save_cpo
 unlet s:save_cpo
 
-" vim: set et sts=4 sw=4:
+" vim: set sw=4 sts=4 et fdm=marker:

vim/bundle/syntastic/syntax_checkers/html/w3.vim

@@ -9,13 +9,6 @@
 "             See http://sam.zoy.org/wtfpl/COPYING for more details.
 "
 "============================================================================
-"
-" Checker option:
-"
-" - g:syntastic_html_w3_api (string; default: 'http://validator.w3.org/check')
-"   URL of the service to use for checking; leave it to the default to run the
-"   checks against http://validator.w3.org/, or set it to
-"   'http://localhost/w3c-validator/check' if you're running a local service
 
 if exists("g:loaded_syntastic_html_w3_checker")
     finish
@@ -30,7 +23,7 @@ let s:save_cpo = &cpo
 set cpo&vim
 
 function! SyntaxCheckers_html_w3_GetLocList() dict
-    let makeprg = self.getExecEscaped() . ' -s -F output=json ' .
+    let makeprg = self.getExecEscaped() . ' -q -s -F output=json ' .
         \ '-F uploaded_file=@' . syntastic#util#shexpand('%:p') . '\;type=text/html ' .
         \ g:syntastic_html_w3_api
 
@@ -66,4 +59,4 @@ call g:SyntasticRegistry.CreateAndRegisterChecker({
 let &cpo = s:save_cpo
 unlet s:save_cpo
 
-" vim: set et sts=4 sw=4:
+" vim: set sw=4 sts=4 et fdm=marker:

vim/bundle/syntastic/syntax_checkers/java/checkstyle.vim

@@ -27,19 +27,34 @@ endif
 let s:save_cpo = &cpo
 set cpo&vim
 
+function! SyntaxCheckers_java_checkstyle_IsAvailable() dict
+    if !executable(self.getExec())
+        return 0
+    endif
+
+    let classpath = expand(g:syntastic_java_checkstyle_classpath, 1)
+    let conf_file = expand(g:syntastic_java_checkstyle_conf_file, 1)
+    call self.log(
+        \ 'filereadable(' . string(classpath) . ') = ' . filereadable(classpath) . ', ' .
+        \ 'filereadable(' . string(conf_file) . ') = ' . filereadable(conf_file))
+
+    return filereadable(classpath) && filereadable(conf_file)
+endfunction
+
 function! SyntaxCheckers_java_checkstyle_GetLocList() dict
 
-    let fname = syntastic#util#shescape( expand('%:p:h') . '/' . expand('%:t') )
+    let fname = syntastic#util#shescape( expand('%:p:h', 1) . syntastic#util#Slash() . expand('%:t', 1) )
 
     if has('win32unix')
         let fname = substitute(system('cygpath -m ' . fname), '\m\%x00', '', 'g')
     endif
 
     let makeprg = self.makeprgBuild({
-        \ 'args_after': '-cp ' . g:syntastic_java_checkstyle_classpath .
-        \       ' com.puppycrawl.tools.checkstyle.Main -c ' .
-        \       syntastic#util#shexpand(g:syntastic_java_checkstyle_conf_file) .
-        \       ' -f xml',
+        \ 'args_after': [
+        \       '-cp', expand(g:syntastic_java_checkstyle_classpath, 1),
+        \       'com.puppycrawl.tools.checkstyle.Main',
+        \       '-c', expand(g:syntastic_java_checkstyle_conf_file, 1),
+        \       '-f', 'xml'],
         \ 'fname': fname })
 
     let errorformat = '%f:%t:%l:%c:%m'
@@ -59,4 +74,4 @@ call g:SyntasticRegistry.CreateAndRegisterChecker({
 let &cpo = s:save_cpo
 unlet s:save_cpo
 
-" vim: set et sts=4 sw=4:
+" vim: set sw=4 sts=4 et fdm=marker:

vim/bundle/syntastic/syntax_checkers/java/javac.vim

@@ -18,7 +18,11 @@ let g:syntastic_java_javac_maven_pom_tags = ['build', 'properties']
 let g:syntastic_java_javac_maven_pom_properties = {}
 let s:has_maven = 0
 
-" Global Options
+let s:save_cpo = &cpo
+set cpo&vim
+
+" Checker options {{{1
+
 if !exists('g:syntastic_java_javac_executable')
     let g:syntastic_java_javac_executable = 'javac'
 endif
@@ -43,25 +47,6 @@ if !exists('g:syntastic_java_javac_delete_output')
     let g:syntastic_java_javac_delete_output = 1
 endif
 
-let s:save_cpo = &cpo
-set cpo&vim
-
-function! s:CygwinPath(path)
-    return substitute(system('cygpath -m ' . syntastic#util#shescape(a:path)), "\n", '', 'g')
-endfunction
-
-if !exists('g:syntastic_java_javac_temp_dir')
-    if has('win32') || has('win64')
-        let g:syntastic_java_javac_temp_dir = $TEMP . syntastic#util#Slash() . 'vim-syntastic-javac'
-    elseif has('win32unix')
-        let g:syntastic_java_javac_temp_dir = s:CygwinPath('/tmp/vim-syntastic-javac')
-    elseif $TMPDIR != ''
-        let g:syntastic_java_javac_temp_dir = $TMPDIR . '/vim-syntastic-javac'
-    else
-        let g:syntastic_java_javac_temp_dir = '/tmp/vim-syntastic-javac'
-    endif
-endif
-
 if !exists('g:syntastic_java_javac_autoload_maven_classpath')
     let g:syntastic_java_javac_autoload_maven_classpath = 1
 endif
@@ -86,44 +71,144 @@ if !exists('g:syntastic_java_javac_maven_pom_classpath')
     let g:syntastic_java_javac_maven_pom_classpath = {}
 endif
 
-function! s:RemoveCarriageReturn(line)
-    return substitute(a:line, "\r", '', 'g')
-endfunction
+" }}}1
+
+command! SyntasticJavacEditClasspath call s:EditClasspath()
+
+if g:syntastic_java_javac_config_file_enabled
+    command! SyntasticJavacEditConfig call s:EditConfig()
+endif
+
+function! SyntaxCheckers_java_javac_IsAvailable() dict " {{{1
+    let s:has_maven = executable(expand(g:syntastic_java_maven_executable, 1))
+    return executable(expand(g:syntastic_java_javac_executable, 1))
+endfunction " }}}1
+
+function! SyntaxCheckers_java_javac_GetLocList() dict " {{{1
+    let javac_opts = g:syntastic_java_javac_options
+
+    let output_dir = ''
+    if g:syntastic_java_javac_delete_output
+        let output_dir = syntastic#util#tmpdir()
+        let javac_opts .= ' -d ' . syntastic#util#shescape(output_dir)
+    endif
+
+    " load classpath from config file
+    if g:syntastic_java_javac_config_file_enabled
+        call s:LoadConfigFile()
+    endif
+
 
-" recursively remove directory and all it's sub-directories
-function! s:RemoveDir(dir)
-    if isdirectory(a:dir)
-        for f in split(globpath(a:dir, '*'), "\n")
-            call s:RemoveDir(f)
+    " add classpathes to javac_classpath {{{2
+    let javac_classpath = ''
+
+    for path in split(g:syntastic_java_javac_classpath, s:ClassSep())
+        if path != ''
+            try
+                let ps = glob(path, 1, 1)
+            catch
+                let ps = split(glob(path, 1), "\n")
+            endtry
+            if type(ps) == type([])
+                for p in ps
+                    let javac_classpath = s:AddToClasspath(javac_classpath, p)
+                endfor
+            else
+                let javac_classpath = s:AddToClasspath(javac_classpath, ps)
+            endif
+        endif
+    endfor
+
+    if s:has_maven && g:syntastic_java_javac_autoload_maven_classpath
+        if !g:syntastic_java_javac_delete_output
+            let javac_opts .= ' -d ' . syntastic#util#shescape(s:MavenOutputDirectory())
+        endif
+        let javac_classpath = s:AddToClasspath(javac_classpath, s:GetMavenClasspath())
+    endif
+    " }}}2
+
+    " load custom classpath {{{2
+    if g:syntastic_java_javac_custom_classpath_command != ''
+        let lines = system(g:syntastic_java_javac_custom_classpath_command)
+        if syntastic#util#isRunningWindows() || has('win32unix')
+            let lines = substitute(lines, "\r\n", "\n", 'g')
+        endif
+        for l in split(lines, "\n")
+            let javac_classpath = s:AddToClasspath(javac_classpath, l)
         endfor
-        silent! call system('rmdir ' . syntastic#util#shescape(a:dir))
-    else
-        silent! call delete(a:dir)
     endif
-endfunction
 
-function! s:ClassSep()
+    if javac_classpath != ''
+        let javac_opts .= ' -cp ' . syntastic#util#shexpand(javac_classpath)
+    endif
+    " }}}2
+
+    let fname = expand('%:p:h', 1) . syntastic#util#Slash() . expand ('%:t', 1)
+
+    if has('win32unix')
+        let fname = s:CygwinPath(fname)
+    endif
+
+    let makeprg = self.makeprgBuild({
+        \ 'args': javac_opts,
+        \ 'fname': syntastic#util#shescape(fname) })
+
+    " unashamedly stolen from *errorformat-javac* (quickfix.txt) and modified to include error types
+    let errorformat =
+        \ '%E%f:%l:\ error:\ %m,'.
+        \ '%W%f:%l:\ warning:\ %m,'.
+        \ '%A%f:%l:\ %m,'.
+        \ '%+Z%p^,'.
+        \ '%+C%.%#,'.
+        \ '%-G%.%#'
+
+    if output_dir != ''
+        silent! call mkdir(output_dir, 'p')
+    endif
+    let errors = SyntasticMake({
+        \ 'makeprg': makeprg,
+        \ 'errorformat': errorformat,
+        \ 'postprocess': ['cygwinRemoveCR'] })
+
+    if output_dir != ''
+        call syntastic#util#rmrf(output_dir)
+    endif
+    return errors
+
+endfunction " }}}1
+
+" Utilities {{{1
+
+function! s:CygwinPath(path) " {{{2
+    return substitute(system('cygpath -m ' . syntastic#util#shescape(a:path)), "\n", '', 'g')
+endfunction " }}}2
+
+function! s:RemoveCarriageReturn(line) " {{{2
+    return substitute(a:line, "\r", '', 'g')
+endfunction " }}}2
+
+function! s:ClassSep() " {{{2
     return (syntastic#util#isRunningWindows() || has('win32unix')) ? ';' : ':'
-endfunction
+endfunction " }}}2
 
-function! s:AddToClasspath(classpath, path)
+function! s:AddToClasspath(classpath, path) " {{{2
     if a:path == ''
         return a:classpath
     endif
     return (a:classpath != '') ? a:classpath . s:ClassSep() . a:path : a:path
-endfunction
+endfunction " }}}2
 
-function! s:SplitClasspath(classpath)
+function! s:SplitClasspath(classpath) " {{{2
     return split(a:classpath, s:ClassSep())
-endfunction
+endfunction " }}}2
 
-function! s:LoadConfigFile()
-    if filereadable(expand(g:syntastic_java_javac_config_file))
-        exe 'source ' . fnameescape(expand(g:syntastic_java_javac_config_file))
+function! s:LoadConfigFile() " {{{2
+    if filereadable(expand(g:syntastic_java_javac_config_file, 1))
+        execute 'source ' . fnameescape(expand(g:syntastic_java_javac_config_file, 1))
     endif
-endfunction
+endfunction " }}}2
 
-function! s:SaveClasspath()
+function! s:SaveClasspath() " {{{2
     " build classpath from lines
     let path = ''
     let lines = getline(1, line('$'))
@@ -132,9 +217,9 @@ function! s:SaveClasspath()
     endfor
     " save classpath to config file
     if g:syntastic_java_javac_config_file_enabled
-        if filereadable(expand(g:syntastic_java_javac_config_file))
+        if filereadable(expand(g:syntastic_java_javac_config_file, 1))
             " load lines from config file
-            let lines = readfile(expand(g:syntastic_java_javac_config_file))
+            let lines = readfile(expand(g:syntastic_java_javac_config_file, 1))
             " strip g:syntastic_java_javac_classpath options from config file lines
             let i = 0
             while i < len(lines)
@@ -150,14 +235,14 @@ function! s:SaveClasspath()
         " add new g:syntastic_java_javac_classpath option to config
         call add(lines, 'let g:syntastic_java_javac_classpath = ' . string(path))
         " save config file lines
-        call writefile(lines, expand(g:syntastic_java_javac_config_file))
+        call writefile(lines, expand(g:syntastic_java_javac_config_file, 1))
     endif
     " set new classpath
     let g:syntastic_java_javac_classpath = path
     let &modified = 0
-endfunction
+endfunction " }}}2
 
-function! s:EditClasspath()
+function! s:EditClasspath() " {{{2
     let command = 'syntastic javac classpath'
     let winnr = bufwinnr('^' . command . '$')
     if winnr < 0
@@ -180,25 +265,25 @@ function! s:EditClasspath()
     else
         execute winnr . 'wincmd w'
     endif
-endfunction
+endfunction " }}}2
 
-function! s:SaveConfig()
+function! s:SaveConfig() " {{{2
     " get lines
     let lines = getline(1, line('$'))
     if g:syntastic_java_javac_config_file_enabled
         " save config file lines
-        call writefile(lines, expand(g:syntastic_java_javac_config_file))
+        call writefile(lines, expand(g:syntastic_java_javac_config_file, 1))
     endif
     let &modified = 0
-endfunction
+endfunction " }}}2
 
-function! s:EditConfig()
+function! s:EditConfig() " {{{2
     let command = 'syntastic javac config'
     let winnr = bufwinnr('^' . command . '$')
     if winnr < 0
         let lines = []
-        if filereadable(expand(g:syntastic_java_javac_config_file))
-            let lines = readfile(expand(g:syntastic_java_javac_config_file))
+        if filereadable(expand(g:syntastic_java_javac_config_file, 1))
+            let lines = readfile(expand(g:syntastic_java_javac_config_file, 1))
         endif
         execute (len(lines) + 5) . 'sp ' . fnameescape(command)
 
@@ -214,9 +299,9 @@ function! s:EditConfig()
     else
         execute winnr . 'wincmd w'
     endif
-endfunction
+endfunction " }}}2
 
-function! s:GetMavenProperties()
+function! s:GetMavenProperties() " {{{2
     let mvn_properties = {}
     let pom = findfile('pom.xml', '.;')
     if s:has_maven && filereadable(pom)
@@ -250,15 +335,9 @@ function! s:GetMavenProperties()
         return g:syntastic_java_javac_maven_pom_properties[pom]
     endif
     return mvn_properties
-endfunction
-
-command! SyntasticJavacEditClasspath call s:EditClasspath()
-
-if g:syntastic_java_javac_config_file_enabled
-    command! SyntasticJavacEditConfig call s:EditConfig()
-endif
+endfunction " }}}2
 
-function! s:GetMavenClasspath()
+function! s:GetMavenClasspath() " {{{2
     let pom = findfile('pom.xml', '.;')
     if s:has_maven && filereadable(pom)
         if !has_key(g:syntastic_java_javac_maven_pom_ftime, pom) || g:syntastic_java_javac_maven_pom_ftime[pom] != getftime(pom)
@@ -299,14 +378,9 @@ function! s:GetMavenClasspath()
         return g:syntastic_java_javac_maven_pom_classpath[pom]
     endif
     return ''
-endfunction
-
-function! SyntaxCheckers_java_javac_IsAvailable() dict
-    let s:has_maven = executable(expand(g:syntastic_java_maven_executable))
-    return executable(expand(g:syntastic_java_javac_executable))
-endfunction
+endfunction " }}}2
 
-function! s:MavenOutputDirectory()
+function! s:MavenOutputDirectory() " {{{2
     let pom = findfile('pom.xml', '.;')
     if s:has_maven && filereadable(pom)
         let mvn_properties = s:GetMavenProperties()
@@ -314,13 +388,13 @@ function! s:MavenOutputDirectory()
         if has_key(mvn_properties, 'project.properties.build.dir')
             let output_dir = mvn_properties['project.properties.build.dir']
         endif
-        if stridx(expand( '%:p:h' ), 'src.main.java') >= 0
+        if stridx(expand('%:p:h', 1), 'src.main.java') >= 0
             let output_dir .= '/target/classes'
             if has_key(mvn_properties, 'project.build.outputDirectory')
                 let output_dir = mvn_properties['project.build.outputDirectory']
             endif
         endif
-        if stridx(expand( '%:p:h' ), 'src.test.java') >= 0
+        if stridx(expand('%:p:h', 1), 'src.test.java') >= 0
             let output_dir .= '/target/test-classes'
             if has_key(mvn_properties, 'project.build.testOutputDirectory')
                 let output_dir = mvn_properties['project.build.testOutputDirectory']
@@ -333,97 +407,9 @@ function! s:MavenOutputDirectory()
         return output_dir
     endif
     return '.'
-endfunction
-
-function! SyntaxCheckers_java_javac_GetLocList() dict
-    let javac_opts = g:syntastic_java_javac_options
-
-    let output_dir = ''
-    if g:syntastic_java_javac_delete_output
-        let output_dir = g:syntastic_java_javac_temp_dir
-        let javac_opts .= ' -d ' . syntastic#util#shescape(output_dir)
-    endif
-
-    " load classpath from config file
-    if g:syntastic_java_javac_config_file_enabled
-        call s:LoadConfigFile()
-    endif
-
-    let javac_classpath = ''
-
-    " add classpathes to javac_classpath
-    for path in split(g:syntastic_java_javac_classpath, s:ClassSep())
-        if path != ''
-            try
-                let ps = glob(path, 0, 1)
-            catch
-                let ps = split(glob(path, 0), "\n")
-            endtry
-            if type(ps) == type([])
-                for p in ps
-                    let javac_classpath = s:AddToClasspath(javac_classpath, p)
-                endfor
-            else
-                let javac_classpath = s:AddToClasspath(javac_classpath, ps)
-            endif
-        endif
-    endfor
-
-    if s:has_maven && g:syntastic_java_javac_autoload_maven_classpath
-        if !g:syntastic_java_javac_delete_output
-            let javac_opts .= ' -d ' . syntastic#util#shescape(s:MavenOutputDirectory())
-        endif
-        let javac_classpath = s:AddToClasspath(javac_classpath, s:GetMavenClasspath())
-    endif
-
-    " load custom classpath
-    if g:syntastic_java_javac_custom_classpath_command != ''
-        let lines = system(g:syntastic_java_javac_custom_classpath_command)
-        if syntastic#util#isRunningWindows() || has('win32unix')
-            let lines = substitute(lines, "\r\n", "\n", 'g')
-        endif
-        for l in split(lines, "\n")
-            let javac_classpath = s:AddToClasspath(javac_classpath, l)
-        endfor
-    endif
-
-    if javac_classpath != ''
-        let javac_opts .= ' -cp ' . syntastic#util#shexpand(javac_classpath)
-    endif
-
-    let fname = expand('%:p:h') . syntastic#util#Slash() . expand ('%:t')
-
-    if has('win32unix')
-        let fname = s:CygwinPath(fname)
-    endif
-
-    let makeprg = self.makeprgBuild({
-        \ 'args': javac_opts,
-        \ 'fname': syntastic#util#shescape(fname) })
-
-    " unashamedly stolen from *errorformat-javac* (quickfix.txt) and modified to include error types
-    let errorformat =
-        \ '%E%f:%l:\ error:\ %m,'.
-        \ '%W%f:%l:\ warning:\ %m,'.
-        \ '%A%f:%l:\ %m,'.
-        \ '%+Z%p^,'.
-        \ '%+C%.%#,'.
-        \ '%-G%.%#'
-
-    if g:syntastic_java_javac_delete_output
-        silent! call mkdir(output_dir, 'p')
-    endif
-    let errors = SyntasticMake({
-        \ 'makeprg': makeprg,
-        \ 'errorformat': errorformat,
-        \ 'postprocess': ['cygwinRemoveCR'] })
-
-    if g:syntastic_java_javac_delete_output
-        call s:RemoveDir(output_dir)
-    endif
-    return errors
+endfunction " }}}2
 
-endfunction
+" }}}1
 
 call g:SyntasticRegistry.CreateAndRegisterChecker({
     \ 'filetype': 'java',
@@ -432,4 +418,4 @@ call g:SyntasticRegistry.CreateAndRegisterChecker({
 let &cpo = s:save_cpo
 unlet s:save_cpo
 
-" vim: set et sts=4 sw=4:
+" vim: set sw=4 sts=4 et fdm=marker:

vim/bundle/syntastic/syntax_checkers/javascript/closurecompiler.vim

@@ -20,31 +20,43 @@ set cpo&vim
 function! SyntaxCheckers_javascript_closurecompiler_IsAvailable() dict
     call syntastic#log#deprecationWarn('javascript_closure_compiler_path', 'javascript_closurecompiler_path')
 
-    return
-        \ executable("java") &&
-        \ exists("g:syntastic_javascript_closurecompiler_path") &&
-        \ filereadable(g:syntastic_javascript_closurecompiler_path)
+    if !executable(self.getExec())
+        return 0
+    endif
+
+    let s:has_script = exists('g:syntastic_javascript_closurecompiler_script')
+    if s:has_script
+        return 1
+    endif
+
+    let cp = get(g:, 'syntastic_javascript_closurecompiler_path', '')
+    call self.log('g:syntastic_javascript_closurecompiler_path =', cp)
+
+    let jar = expand(cp, 1)
+    call self.log('filereadable(' . string(jar) . ') = ' . filereadable(jar))
+
+    return filereadable(jar)
 endfunction
 
 function! SyntaxCheckers_javascript_closurecompiler_GetLocList() dict
     call syntastic#log#deprecationWarn('javascript_closure_compiler_options', 'javascript_closurecompiler_args')
     call syntastic#log#deprecationWarn('javascript_closure_compiler_file_list', 'javascript_closurecompiler_file_list')
 
-    if exists("g:syntastic_javascript_closurecompiler_file_list")
-        let file_list = join(readfile(g:syntastic_javascript_closurecompiler_file_list))
+    let flist = expand(get(g:, 'syntastic_javascript_closurecompiler_file_list', ''), 1)
+    if filereadable(flist)
+        let file_list = map( readfile(flist), 'expand(v:var, 1)' )
     else
-        let file_list = syntastic#util#shexpand('%')
+        let file_list = [expand('%', 1)]
     endif
 
     let makeprg = self.makeprgBuild({
-        \ 'exe_after': '-jar ' . g:syntastic_javascript_closurecompiler_path,
-        \ 'args_after': '--js' ,
+        \ 'exe_after': (s:has_script ? [] : ['-jar', expand(g:syntastic_javascript_closurecompiler_path, 1)]),
+        \ 'args_after': '--js',
         \ 'fname': file_list })
 
     let errorformat =
         \ '%-GOK,'.
         \ '%E%f:%l: ERROR - %m,'.
-        \ '%Z%p^,'.
         \ '%W%f:%l: WARNING - %m,'.
         \ '%Z%p^'
 
@@ -56,9 +68,9 @@ endfunction
 call g:SyntasticRegistry.CreateAndRegisterChecker({
     \ 'filetype': 'javascript',
     \ 'name': 'closurecompiler',
-    \ 'exec': 'java'})
+    \ 'exec': get(g:, 'syntastic_javascript_closurecompiler_script', 'java')})
 
 let &cpo = s:save_cpo
 unlet s:save_cpo
 
-" vim: set et sts=4 sw=4:
+" vim: set sw=4 sts=4 et fdm=marker:

vim/bundle/syntastic/syntax_checkers/javascript/eslint.vim

@@ -14,13 +14,18 @@ if exists('g:loaded_syntastic_javascript_eslint_checker')
 endif
 let g:loaded_syntastic_javascript_eslint_checker = 1
 
+if !exists('g:syntastic_javascript_eslint_sort')
+    let g:syntastic_javascript_eslint_sort = 1
+endif
+
 let s:save_cpo = &cpo
 set cpo&vim
 
 function! SyntaxCheckers_javascript_eslint_IsAvailable() dict
-    return
-        \ executable(self.getExec()) &&
-        \ syntastic#util#versionIsAtLeast(syntastic#util#getVersion(self.getExecEscaped() . ' --version'), [0, 1])
+    if !executable(self.getExec())
+        return 0
+    endif
+    return syntastic#util#versionIsAtLeast(self.getVersion(), [0, 1])
 endfunction
 
 function! SyntaxCheckers_javascript_eslint_GetLocList() dict
@@ -35,14 +40,13 @@ function! SyntaxCheckers_javascript_eslint_GetLocList() dict
 
     let loclist = SyntasticMake({
         \ 'makeprg': makeprg,
-        \ 'errorformat': errorformat })
+        \ 'errorformat': errorformat,
+        \ 'postprocess': ['guards'] })
 
     for e in loclist
         let e['col'] += 1
     endfor
 
-    call self.setWantSort(1)
-
     return loclist
 endfunction
 
@@ -53,4 +57,4 @@ call g:SyntasticRegistry.CreateAndRegisterChecker({
 let &cpo = s:save_cpo
 unlet s:save_cpo
 
-" vim: set et sts=4 sw=4:
+" vim: set sw=4 sts=4 et fdm=marker:

vim/bundle/syntastic/syntax_checkers/javascript/flow.vim

@@ -0,0 +1,56 @@
+"============================================================================
+"File:        flow.vim
+"Description: Javascript syntax checker - using flow
+"Maintainer:  Michael Robinson <mike@pagesofinterest.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_javascript_flow_checker')
+    finish
+endif
+let g:loaded_syntastic_javascript_flow_checker = 1
+
+if !exists('g:syntastic_javascript_flow_sort')
+    let g:syntastic_javascript_flow_sort = 1
+endif
+
+let s:save_cpo = &cpo
+set cpo&vim
+
+function! SyntaxCheckers_javascript_flow_GetLocList() dict
+    let makeprg = self.makeprgBuild({
+        \ 'exe_after': 'check',
+        \ 'args_after': '--show-all-errors --json' })
+
+    let errorformat =
+        \ '%f:%l:%c:%n: %m,' .
+        \ '%f:%l:%c: %m'
+
+    let loclist = SyntasticMake({
+        \ 'makeprg': makeprg,
+        \ 'errorformat': errorformat,
+        \ 'preprocess': 'flow',
+        \ 'defaults': {'type': 'E'} })
+
+    for e in loclist
+        if get(e, 'col', 0) && get(e, 'nr', 0)
+            let e['hl'] = '\%>' . (e['col'] - 1) . 'c\%<' . (e['nr'] + 1) . 'c'
+            let e['nr'] = 0
+        endif
+    endfor
+
+    return loclist
+endfunction
+
+call g:SyntasticRegistry.CreateAndRegisterChecker({
+    \ 'filetype': 'javascript',
+    \ 'name': 'flow'})
+
+let &cpo = s:save_cpo
+unlet s:save_cpo
+
+" vim: set sw=4 sts=4 et fdm=marker:

vim/bundle/syntastic/syntax_checkers/javascript/gjslint.vim

@@ -42,4 +42,4 @@ call g:SyntasticRegistry.CreateAndRegisterChecker({
 let &cpo = s:save_cpo
 unlet s:save_cpo
 
-" vim: set et sts=4 sw=4:
+" vim: set sw=4 sts=4 et fdm=marker:

vim/bundle/syntastic/syntax_checkers/javascript/jscs.vim

@@ -14,6 +14,10 @@ if exists("g:loaded_syntastic_javascript_jscs_checker")
 endif
 let g:loaded_syntastic_javascript_jscs_checker = 1
 
+if !exists('g:syntastic_javascript_jscs_sort')
+    let g:syntastic_javascript_jscs_sort = 1
+endif
+
 let s:save_cpo = &cpo
 set cpo&vim
 
@@ -22,16 +26,12 @@ function! SyntaxCheckers_javascript_jscs_GetLocList() dict
 
     let errorformat = '%f:%t:%l:%c:%m'
 
-    let loclist = SyntasticMake({
+    return SyntasticMake({
         \ 'makeprg': makeprg,
         \ 'errorformat': errorformat,
         \ 'subtype': 'Style',
         \ 'preprocess': 'checkstyle',
         \ 'returns': [0, 2] })
-
-    call self.setWantSort(1)
-
-    return loclist
 endfunction
 
 call g:SyntasticRegistry.CreateAndRegisterChecker({
@@ -41,4 +41,4 @@ call g:SyntasticRegistry.CreateAndRegisterChecker({
 let &cpo = s:save_cpo
 unlet s:save_cpo
 
-" vim: set et sts=4 sw=4:
+" vim: set sw=4 sts=4 et fdm=marker:

vim/bundle/syntastic/syntax_checkers/javascript/jshint.vim

@@ -14,6 +14,10 @@ if exists('g:loaded_syntastic_javascript_jshint_checker')
 endif
 let g:loaded_syntastic_javascript_jshint_checker = 1
 
+if !exists('g:syntastic_javascript_jshint_sort')
+    let g:syntastic_javascript_jshint_sort = 1
+endif
+
 let s:save_cpo = &cpo
 set cpo&vim
 
@@ -22,26 +26,23 @@ function! SyntaxCheckers_javascript_jshint_IsAvailable() dict
     if !executable(self.getExec())
         return 0
     endif
-    let s:jshint_version = syntastic#util#getVersion(self.getExecEscaped() . ' --version')
-    return syntastic#util#versionIsAtLeast(s:jshint_version, [1])
+
+    let ver = self.getVersion()
+    let s:jshint_new = syntastic#util#versionIsAtLeast(ver, [1, 1])
+
+    return syntastic#util#versionIsAtLeast(ver, [1])
 endfunction
 
 function! SyntaxCheckers_javascript_jshint_GetLocList() dict
     call syntastic#log#deprecationWarn('javascript_jshint_conf', 'javascript_jshint_args',
         \ "'--config ' . syntastic#util#shexpand(OLD_VAR)")
 
-    if !exists('s:jshint_new')
-        let s:jshint_new = syntastic#util#versionIsAtLeast(s:jshint_version, [1, 1])
-    endif
-
     let makeprg = self.makeprgBuild({ 'args_after': (s:jshint_new ? '--verbose ' : '') })
 
     let errorformat = s:jshint_new ?
         \ '%A%f: line %l\, col %v\, %m \(%t%*\d\)' :
         \ '%E%f: line %l\, col %v\, %m'
 
-    call self.setWantSort(1)
-
     return SyntasticMake({
         \ 'makeprg': makeprg,
         \ 'errorformat': errorformat,
@@ -56,4 +57,4 @@ call g:SyntasticRegistry.CreateAndRegisterChecker({
 let &cpo = s:save_cpo
 unlet s:save_cpo
 
-" vim: set et sts=4 sw=4:
+" vim: set sw=4 sts=4 et fdm=marker:

vim/bundle/syntastic/syntax_checkers/javascript/jsl.vim

@@ -45,4 +45,4 @@ call g:SyntasticRegistry.CreateAndRegisterChecker({
 let &cpo = s:save_cpo
 unlet s:save_cpo
 
-" vim: set et sts=4 sw=4:
+" vim: set sw=4 sts=4 et fdm=marker:

vim/bundle/syntastic/syntax_checkers/javascript/jslint.vim

@@ -8,8 +8,8 @@
 "             Want To Public License, Version 2, as published by Sam Hocevar.
 "             See http://sam.zoy.org/wtfpl/COPYING for more details.
 "
-"Tested with jslint 0.1.4.
 "============================================================================
+
 if exists("g:loaded_syntastic_javascript_jslint_checker")
     finish
 endif
@@ -48,4 +48,4 @@ call g:SyntasticRegistry.CreateAndRegisterChecker({
 let &cpo = s:save_cpo
 unlet s:save_cpo
 
-" vim: set et sts=4 sw=4:
+" vim: set sw=4 sts=4 et fdm=marker:

vim/bundle/syntastic/syntax_checkers/javascript/jsxhint.vim

@@ -19,10 +19,14 @@ set cpo&vim
 
 function! SyntaxCheckers_javascript_jsxhint_IsAvailable() dict
     let jsxhint_version = system(self.getExecEscaped() . ' --version')
-    return
-        \ v:shell_error == 0 &&
-        \ jsxhint_version =~# '\m^JSXHint\>' &&
-        \ syntastic#util#versionIsAtLeast(syntastic#util#parseVersion(jsxhint_version), [0, 4, 1])
+    if v:shell_error || (jsxhint_version !~# '\m^JSXHint\>')
+        return 0
+    endif
+
+    let ver = syntastic#util#parseVersion(jsxhint_version)
+    call self.setVersion(ver)
+
+    return syntastic#util#versionIsAtLeast(ver, [0, 4, 1])
 endfunction
 
 function! SyntaxCheckers_javascript_jsxhint_GetLocList() dict
@@ -44,4 +48,4 @@ call g:SyntasticRegistry.CreateAndRegisterChecker({
 let &cpo = s:save_cpo
 unlet s:save_cpo
 
-" vim: set et sts=4 sw=4:
+" vim: set sw=4 sts=4 et fdm=marker:

vim/bundle/syntastic/syntax_checkers/json/jsonlint.vim

@@ -40,4 +40,4 @@ call g:SyntasticRegistry.CreateAndRegisterChecker({
 let &cpo = s:save_cpo
 unlet s:save_cpo
 
-" vim: set et sts=4 sw=4:
+" vim: set sw=4 sts=4 et fdm=marker:

vim/bundle/syntastic/syntax_checkers/json/jsonval.vim

@@ -38,4 +38,4 @@ call g:SyntasticRegistry.CreateAndRegisterChecker({
 let &cpo = s:save_cpo
 unlet s:save_cpo
 
-" vim: set et sts=4 sw=4:
+" vim: set sw=4 sts=4 et fdm=marker: