update config
authorBen Doumenc <bdoumenc@gmail.com>
Wed, 14 Sep 2016 21:14:58 +0000 (23:14 +0200)
committerBen Doumenc <bdoumenc@gmail.com>
Wed, 14 Sep 2016 21:14:58 +0000 (23:14 +0200)
291 files changed:
bash/conkyrc [new file with mode: 0644]
bash/customBashrc
bash/pythonrc [new file with mode: 0644]
data/cv.pdf
data/cv.tex
suckless/dwm/config.def.h
suckless/dwm/config.mk
suckless/dwmstatus-bar/Makefile
suckless/dwmstatus-bar/status.c
suckless/rxvt/Xdefaults
suckless/stest/Makefile [new file with mode: 0644]
suckless/stest/arg.h [new file with mode: 0644]
suckless/stest/stest.c [new file with mode: 0644]
vim/customVimrc
vim/vimfiles/bundle/plantuml/README.md [new file with mode: 0644]
vim/vimfiles/bundle/plantuml/ftdetect/plantuml.vim [new file with mode: 0644]
vim/vimfiles/bundle/plantuml/ftplugin/plantuml.vim [new file with mode: 0644]
vim/vimfiles/bundle/plantuml/syntax/plantuml.vim [new file with mode: 0644]
vim/vimfiles/bundle/syntastic/.gitignore [new file with mode: 0644]
vim/vimfiles/bundle/syntastic/CONTRIBUTING.md [new file with mode: 0644]
vim/vimfiles/bundle/syntastic/LICENCE [new file with mode: 0644]
vim/vimfiles/bundle/syntastic/README.markdown [new file with mode: 0644]
vim/vimfiles/bundle/syntastic/_assets/screenshot_1.png [new file with mode: 0644]
vim/vimfiles/bundle/syntastic/autoload/syntastic/c.vim [new file with mode: 0644]
vim/vimfiles/bundle/syntastic/autoload/syntastic/log.vim [new file with mode: 0644]
vim/vimfiles/bundle/syntastic/autoload/syntastic/postprocess.vim [new file with mode: 0644]
vim/vimfiles/bundle/syntastic/autoload/syntastic/preprocess.vim [new file with mode: 0644]
vim/vimfiles/bundle/syntastic/autoload/syntastic/util.vim [new file with mode: 0644]
vim/vimfiles/bundle/syntastic/doc/syntastic-checkers.txt [new file with mode: 0644]
vim/vimfiles/bundle/syntastic/doc/syntastic.txt [new file with mode: 0644]
vim/vimfiles/bundle/syntastic/plugin/syntastic.vim [new file with mode: 0644]
vim/vimfiles/bundle/syntastic/plugin/syntastic/autoloclist.vim [new file with mode: 0644]
vim/vimfiles/bundle/syntastic/plugin/syntastic/balloons.vim [new file with mode: 0644]
vim/vimfiles/bundle/syntastic/plugin/syntastic/checker.vim [new file with mode: 0644]
vim/vimfiles/bundle/syntastic/plugin/syntastic/cursor.vim [new file with mode: 0644]
vim/vimfiles/bundle/syntastic/plugin/syntastic/highlighting.vim [new file with mode: 0644]
vim/vimfiles/bundle/syntastic/plugin/syntastic/loclist.vim [new file with mode: 0644]
vim/vimfiles/bundle/syntastic/plugin/syntastic/modemap.vim [new file with mode: 0644]
vim/vimfiles/bundle/syntastic/plugin/syntastic/notifiers.vim [new file with mode: 0644]
vim/vimfiles/bundle/syntastic/plugin/syntastic/registry.vim [new file with mode: 0644]
vim/vimfiles/bundle/syntastic/plugin/syntastic/signs.vim [new file with mode: 0644]
vim/vimfiles/bundle/syntastic/syntax_checkers/actionscript/mxmlc.vim [new file with mode: 0644]
vim/vimfiles/bundle/syntastic/syntax_checkers/ada/gcc.vim [new file with mode: 0644]
vim/vimfiles/bundle/syntastic/syntax_checkers/ansible/ansible_lint.vim [new file with mode: 0644]
vim/vimfiles/bundle/syntastic/syntax_checkers/apiblueprint/drafter.vim [new file with mode: 0644]
vim/vimfiles/bundle/syntastic/syntax_checkers/applescript/osacompile.vim [new file with mode: 0644]
vim/vimfiles/bundle/syntastic/syntax_checkers/asciidoc/asciidoc.vim [new file with mode: 0644]
vim/vimfiles/bundle/syntastic/syntax_checkers/asl/iasl.vim [new file with mode: 0644]
vim/vimfiles/bundle/syntastic/syntax_checkers/asm/gcc.vim [new file with mode: 0644]
vim/vimfiles/bundle/syntastic/syntax_checkers/bemhtml/bemhtmllint.vim [new file with mode: 0644]
vim/vimfiles/bundle/syntastic/syntax_checkers/bro/bro.vim [new file with mode: 0644]
vim/vimfiles/bundle/syntastic/syntax_checkers/c/avrgcc.vim [new file with mode: 0644]
vim/vimfiles/bundle/syntastic/syntax_checkers/c/checkpatch.vim [new file with mode: 0644]
vim/vimfiles/bundle/syntastic/syntax_checkers/c/clang_check.vim [new file with mode: 0644]
vim/vimfiles/bundle/syntastic/syntax_checkers/c/clang_tidy.vim [new file with mode: 0644]
vim/vimfiles/bundle/syntastic/syntax_checkers/c/cppcheck.vim [new file with mode: 0644]
vim/vimfiles/bundle/syntastic/syntax_checkers/c/gcc.vim [new file with mode: 0644]
vim/vimfiles/bundle/syntastic/syntax_checkers/c/make.vim [new file with mode: 0644]
vim/vimfiles/bundle/syntastic/syntax_checkers/c/oclint.vim [new file with mode: 0644]
vim/vimfiles/bundle/syntastic/syntax_checkers/c/pc_lint.vim [new file with mode: 0644]
vim/vimfiles/bundle/syntastic/syntax_checkers/c/sparse.vim [new file with mode: 0644]
vim/vimfiles/bundle/syntastic/syntax_checkers/c/splint.vim [new file with mode: 0644]
vim/vimfiles/bundle/syntastic/syntax_checkers/cabal/cabal.vim [new file with mode: 0644]
vim/vimfiles/bundle/syntastic/syntax_checkers/chef/foodcritic.vim [new file with mode: 0644]
vim/vimfiles/bundle/syntastic/syntax_checkers/co/coco.vim [new file with mode: 0644]
vim/vimfiles/bundle/syntastic/syntax_checkers/cobol/cobc.vim [new file with mode: 0644]
vim/vimfiles/bundle/syntastic/syntax_checkers/coffee/coffee.vim [new file with mode: 0644]
vim/vimfiles/bundle/syntastic/syntax_checkers/coffee/coffeelint.vim [new file with mode: 0644]
vim/vimfiles/bundle/syntastic/syntax_checkers/coq/coqtop.vim [new file with mode: 0644]
vim/vimfiles/bundle/syntastic/syntax_checkers/cpp/avrgcc.vim [new file with mode: 0644]
vim/vimfiles/bundle/syntastic/syntax_checkers/cpp/clang_check.vim [new file with mode: 0644]
vim/vimfiles/bundle/syntastic/syntax_checkers/cpp/clang_tidy.vim [new file with mode: 0644]
vim/vimfiles/bundle/syntastic/syntax_checkers/cpp/cppcheck.vim [new file with mode: 0644]
vim/vimfiles/bundle/syntastic/syntax_checkers/cpp/cpplint.vim [new file with mode: 0644]
vim/vimfiles/bundle/syntastic/syntax_checkers/cpp/gcc.vim [new file with mode: 0644]
vim/vimfiles/bundle/syntastic/syntax_checkers/cpp/oclint.vim [new file with mode: 0644]
vim/vimfiles/bundle/syntastic/syntax_checkers/cpp/pc_lint.vim [new file with mode: 0644]
vim/vimfiles/bundle/syntastic/syntax_checkers/cpp/verapp.vim [new file with mode: 0644]
vim/vimfiles/bundle/syntastic/syntax_checkers/cs/mcs.vim [new file with mode: 0644]
vim/vimfiles/bundle/syntastic/syntax_checkers/css/csslint.vim [new file with mode: 0644]
vim/vimfiles/bundle/syntastic/syntax_checkers/css/mixedindentlint.vim [new file with mode: 0644]
vim/vimfiles/bundle/syntastic/syntax_checkers/css/phpcs.vim [new file with mode: 0644]
vim/vimfiles/bundle/syntastic/syntax_checkers/css/prettycss.vim [new file with mode: 0644]
vim/vimfiles/bundle/syntastic/syntax_checkers/css/recess.vim [new file with mode: 0644]
vim/vimfiles/bundle/syntastic/syntax_checkers/css/stylelint.vim [new file with mode: 0644]
vim/vimfiles/bundle/syntastic/syntax_checkers/cucumber/cucumber.vim [new file with mode: 0644]
vim/vimfiles/bundle/syntastic/syntax_checkers/cuda/nvcc.vim [new file with mode: 0644]
vim/vimfiles/bundle/syntastic/syntax_checkers/d/dmd.vim [new file with mode: 0644]
vim/vimfiles/bundle/syntastic/syntax_checkers/dart/dartanalyzer.vim [new file with mode: 0644]
vim/vimfiles/bundle/syntastic/syntax_checkers/docbk/igor.vim [new file with mode: 0644]
vim/vimfiles/bundle/syntastic/syntax_checkers/docbk/xmllint.vim [new file with mode: 0644]
vim/vimfiles/bundle/syntastic/syntax_checkers/dockerfile/dockerfile_lint.vim [new file with mode: 0644]
vim/vimfiles/bundle/syntastic/syntax_checkers/dustjs/swiffer.vim [new file with mode: 0644]
vim/vimfiles/bundle/syntastic/syntax_checkers/elixir/elixir.vim [new file with mode: 0644]
vim/vimfiles/bundle/syntastic/syntax_checkers/erlang/erlang_check_file.erl [new file with mode: 0755]
vim/vimfiles/bundle/syntastic/syntax_checkers/erlang/escript.vim [new file with mode: 0644]
vim/vimfiles/bundle/syntastic/syntax_checkers/erlang/syntaxerl.vim [new file with mode: 0644]
vim/vimfiles/bundle/syntastic/syntax_checkers/eruby/ruby.vim [new file with mode: 0644]
vim/vimfiles/bundle/syntastic/syntax_checkers/fortran/gfortran.vim [new file with mode: 0644]
vim/vimfiles/bundle/syntastic/syntax_checkers/glsl/cgc.vim [new file with mode: 0644]
vim/vimfiles/bundle/syntastic/syntax_checkers/go/go.vim [new file with mode: 0644]
vim/vimfiles/bundle/syntastic/syntax_checkers/go/gofmt.vim [new file with mode: 0644]
vim/vimfiles/bundle/syntastic/syntax_checkers/go/golint.vim [new file with mode: 0644]
vim/vimfiles/bundle/syntastic/syntax_checkers/go/gometalinter.vim [new file with mode: 0644]
vim/vimfiles/bundle/syntastic/syntax_checkers/go/gotype.vim [new file with mode: 0644]
vim/vimfiles/bundle/syntastic/syntax_checkers/go/govet.vim [new file with mode: 0644]
vim/vimfiles/bundle/syntastic/syntax_checkers/haml/haml.vim [new file with mode: 0644]
vim/vimfiles/bundle/syntastic/syntax_checkers/haml/haml_lint.vim [new file with mode: 0644]
vim/vimfiles/bundle/syntastic/syntax_checkers/handlebars/handlebars.vim [new file with mode: 0644]
vim/vimfiles/bundle/syntastic/syntax_checkers/haskell/ghc-mod.vim [new file with mode: 0644]
vim/vimfiles/bundle/syntastic/syntax_checkers/haskell/hdevtools.vim [new file with mode: 0644]
vim/vimfiles/bundle/syntastic/syntax_checkers/haskell/hlint.vim [new file with mode: 0644]
vim/vimfiles/bundle/syntastic/syntax_checkers/haskell/scan.vim [new file with mode: 0644]
vim/vimfiles/bundle/syntastic/syntax_checkers/haxe/haxe.vim [new file with mode: 0644]
vim/vimfiles/bundle/syntastic/syntax_checkers/hss/hss.vim [new file with mode: 0644]
vim/vimfiles/bundle/syntastic/syntax_checkers/html/eslint.vim [new file with mode: 0644]
vim/vimfiles/bundle/syntastic/syntax_checkers/html/gjslint.vim [new file with mode: 0644]
vim/vimfiles/bundle/syntastic/syntax_checkers/html/jshint.vim [new file with mode: 0644]
vim/vimfiles/bundle/syntastic/syntax_checkers/html/textlint.vim [new file with mode: 0644]
vim/vimfiles/bundle/syntastic/syntax_checkers/html/tidy.vim [new file with mode: 0644]
vim/vimfiles/bundle/syntastic/syntax_checkers/html/validator.vim [new file with mode: 0644]
vim/vimfiles/bundle/syntastic/syntax_checkers/html/w3.vim [new file with mode: 0644]
vim/vimfiles/bundle/syntastic/syntax_checkers/jade/jade_lint.vim [new file with mode: 0644]
vim/vimfiles/bundle/syntastic/syntax_checkers/java/checkstyle.vim [new file with mode: 0644]
vim/vimfiles/bundle/syntastic/syntax_checkers/java/javac.vim [new file with mode: 0644]
vim/vimfiles/bundle/syntastic/syntax_checkers/javascript/closurecompiler.vim [new file with mode: 0644]
vim/vimfiles/bundle/syntastic/syntax_checkers/javascript/eslint.vim [new file with mode: 0644]
vim/vimfiles/bundle/syntastic/syntax_checkers/javascript/flow.vim [new file with mode: 0644]
vim/vimfiles/bundle/syntastic/syntax_checkers/javascript/gjslint.vim [new file with mode: 0644]
vim/vimfiles/bundle/syntastic/syntax_checkers/javascript/jscs.vim [new file with mode: 0644]
vim/vimfiles/bundle/syntastic/syntax_checkers/javascript/jshint.vim [new file with mode: 0644]
vim/vimfiles/bundle/syntastic/syntax_checkers/javascript/jsl.vim [new file with mode: 0644]
vim/vimfiles/bundle/syntastic/syntax_checkers/javascript/jslint.vim [new file with mode: 0644]
vim/vimfiles/bundle/syntastic/syntax_checkers/javascript/jsxhint.vim [new file with mode: 0644]
vim/vimfiles/bundle/syntastic/syntax_checkers/javascript/mixedindentlint.vim [new file with mode: 0644]
vim/vimfiles/bundle/syntastic/syntax_checkers/javascript/standard.vim [new file with mode: 0644]
vim/vimfiles/bundle/syntastic/syntax_checkers/javascript/tern_lint.vim [new file with mode: 0644]
vim/vimfiles/bundle/syntastic/syntax_checkers/json/jsonlint.vim [new file with mode: 0644]
vim/vimfiles/bundle/syntastic/syntax_checkers/json/jsonval.vim [new file with mode: 0644]
vim/vimfiles/bundle/syntastic/syntax_checkers/less/less-lint.coffee [new file with mode: 0644]
vim/vimfiles/bundle/syntastic/syntax_checkers/less/less-lint.js [new file with mode: 0644]
vim/vimfiles/bundle/syntastic/syntax_checkers/less/lessc.vim [new file with mode: 0644]
vim/vimfiles/bundle/syntastic/syntax_checkers/less/recess.vim [new file with mode: 0644]
vim/vimfiles/bundle/syntastic/syntax_checkers/lex/flex.vim [new file with mode: 0644]
vim/vimfiles/bundle/syntastic/syntax_checkers/limbo/limbo.vim [new file with mode: 0644]
vim/vimfiles/bundle/syntastic/syntax_checkers/lisp/clisp.vim [new file with mode: 0644]
vim/vimfiles/bundle/syntastic/syntax_checkers/llvm/llvm.vim [new file with mode: 0644]
vim/vimfiles/bundle/syntastic/syntax_checkers/lua/luac.vim [new file with mode: 0644]
vim/vimfiles/bundle/syntastic/syntax_checkers/lua/luacheck.vim [new file with mode: 0644]
vim/vimfiles/bundle/syntastic/syntax_checkers/markdown/mdl.vim [new file with mode: 0644]
vim/vimfiles/bundle/syntastic/syntax_checkers/markdown/textlint.vim [new file with mode: 0644]
vim/vimfiles/bundle/syntastic/syntax_checkers/matlab/mlint.vim [new file with mode: 0644]
vim/vimfiles/bundle/syntastic/syntax_checkers/mercury/mmc.vim [new file with mode: 0644]
vim/vimfiles/bundle/syntastic/syntax_checkers/nasm/nasm.vim [new file with mode: 0644]
vim/vimfiles/bundle/syntastic/syntax_checkers/nix/nix.vim [new file with mode: 0644]
vim/vimfiles/bundle/syntastic/syntax_checkers/nroff/igor.vim [new file with mode: 0644]
vim/vimfiles/bundle/syntastic/syntax_checkers/nroff/mandoc.vim [new file with mode: 0644]
vim/vimfiles/bundle/syntastic/syntax_checkers/objc/gcc.vim [new file with mode: 0644]
vim/vimfiles/bundle/syntastic/syntax_checkers/objc/oclint.vim [new file with mode: 0644]
vim/vimfiles/bundle/syntastic/syntax_checkers/objcpp/gcc.vim [new file with mode: 0644]
vim/vimfiles/bundle/syntastic/syntax_checkers/objcpp/oclint.vim [new file with mode: 0644]
vim/vimfiles/bundle/syntastic/syntax_checkers/ocaml/camlp4o.vim [new file with mode: 0644]
vim/vimfiles/bundle/syntastic/syntax_checkers/perl/perl.vim [new file with mode: 0644]
vim/vimfiles/bundle/syntastic/syntax_checkers/perl/perlcritic.vim [new file with mode: 0644]
vim/vimfiles/bundle/syntastic/syntax_checkers/perl/podchecker.vim [new file with mode: 0644]
vim/vimfiles/bundle/syntastic/syntax_checkers/php/php.vim [new file with mode: 0644]
vim/vimfiles/bundle/syntastic/syntax_checkers/php/phpcs.vim [new file with mode: 0644]
vim/vimfiles/bundle/syntastic/syntax_checkers/php/phplint.vim [new file with mode: 0644]
vim/vimfiles/bundle/syntastic/syntax_checkers/php/phpmd.vim [new file with mode: 0644]
vim/vimfiles/bundle/syntastic/syntax_checkers/po/msgfmt.vim [new file with mode: 0644]
vim/vimfiles/bundle/syntastic/syntax_checkers/pod/podchecker.vim [new file with mode: 0644]
vim/vimfiles/bundle/syntastic/syntax_checkers/pug/pug_lint.vim [new file with mode: 0644]
vim/vimfiles/bundle/syntastic/syntax_checkers/puppet/puppet.vim [new file with mode: 0644]
vim/vimfiles/bundle/syntastic/syntax_checkers/puppet/puppetlint.vim [new file with mode: 0644]
vim/vimfiles/bundle/syntastic/syntax_checkers/python/codec.py [new file with mode: 0755]
vim/vimfiles/bundle/syntastic/syntax_checkers/python/compile.py [new file with mode: 0755]
vim/vimfiles/bundle/syntastic/syntax_checkers/python/flake8.vim [new file with mode: 0644]
vim/vimfiles/bundle/syntastic/syntax_checkers/python/frosted.vim [new file with mode: 0644]
vim/vimfiles/bundle/syntastic/syntax_checkers/python/mypy.vim [new file with mode: 0644]
vim/vimfiles/bundle/syntastic/syntax_checkers/python/pep257.vim [new file with mode: 0644]
vim/vimfiles/bundle/syntastic/syntax_checkers/python/pep8.vim [new file with mode: 0644]
vim/vimfiles/bundle/syntastic/syntax_checkers/python/prospector.vim [new file with mode: 0644]
vim/vimfiles/bundle/syntastic/syntax_checkers/python/py3kwarn.vim [new file with mode: 0644]
vim/vimfiles/bundle/syntastic/syntax_checkers/python/pycodestyle.vim [new file with mode: 0644]
vim/vimfiles/bundle/syntastic/syntax_checkers/python/pydocstyle.vim [new file with mode: 0644]
vim/vimfiles/bundle/syntastic/syntax_checkers/python/pyflakes.vim [new file with mode: 0644]
vim/vimfiles/bundle/syntastic/syntax_checkers/python/pylama.vim [new file with mode: 0644]
vim/vimfiles/bundle/syntastic/syntax_checkers/python/pylint.vim [new file with mode: 0644]
vim/vimfiles/bundle/syntastic/syntax_checkers/python/python.vim [new file with mode: 0644]
vim/vimfiles/bundle/syntastic/syntax_checkers/qml/qmllint.vim [new file with mode: 0644]
vim/vimfiles/bundle/syntastic/syntax_checkers/r/lint.vim [new file with mode: 0644]
vim/vimfiles/bundle/syntastic/syntax_checkers/r/lintr.vim [new file with mode: 0644]
vim/vimfiles/bundle/syntastic/syntax_checkers/r/svtools.vim [new file with mode: 0644]
vim/vimfiles/bundle/syntastic/syntax_checkers/racket/code-ayatollah.vim [new file with mode: 0644]
vim/vimfiles/bundle/syntastic/syntax_checkers/racket/racket.vim [new file with mode: 0644]
vim/vimfiles/bundle/syntastic/syntax_checkers/rmd/lintr.vim [new file with mode: 0644]
vim/vimfiles/bundle/syntastic/syntax_checkers/rnc/rnv.vim [new file with mode: 0644]
vim/vimfiles/bundle/syntastic/syntax_checkers/rst/rst2pseudoxml.vim [new file with mode: 0644]
vim/vimfiles/bundle/syntastic/syntax_checkers/rst/rstcheck.vim [new file with mode: 0644]
vim/vimfiles/bundle/syntastic/syntax_checkers/rst/sphinx.vim [new file with mode: 0644]
vim/vimfiles/bundle/syntastic/syntax_checkers/ruby/flog.vim [new file with mode: 0644]
vim/vimfiles/bundle/syntastic/syntax_checkers/ruby/jruby.vim [new file with mode: 0644]
vim/vimfiles/bundle/syntastic/syntax_checkers/ruby/macruby.vim [new file with mode: 0644]
vim/vimfiles/bundle/syntastic/syntax_checkers/ruby/mri.vim [new file with mode: 0644]
vim/vimfiles/bundle/syntastic/syntax_checkers/ruby/reek.vim [new file with mode: 0644]
vim/vimfiles/bundle/syntastic/syntax_checkers/ruby/rubocop.vim [new file with mode: 0644]
vim/vimfiles/bundle/syntastic/syntax_checkers/ruby/rubylint.vim [new file with mode: 0644]
vim/vimfiles/bundle/syntastic/syntax_checkers/sass/sass.vim [new file with mode: 0644]
vim/vimfiles/bundle/syntastic/syntax_checkers/sass/sass_lint.vim [new file with mode: 0644]
vim/vimfiles/bundle/syntastic/syntax_checkers/sass/sassc.vim [new file with mode: 0644]
vim/vimfiles/bundle/syntastic/syntax_checkers/scala/fsc.vim [new file with mode: 0644]
vim/vimfiles/bundle/syntastic/syntax_checkers/scala/scalac.vim [new file with mode: 0644]
vim/vimfiles/bundle/syntastic/syntax_checkers/scala/scalastyle.vim [new file with mode: 0644]
vim/vimfiles/bundle/syntastic/syntax_checkers/scss/mixedindentlint.vim [new file with mode: 0644]
vim/vimfiles/bundle/syntastic/syntax_checkers/scss/sass.vim [new file with mode: 0644]
vim/vimfiles/bundle/syntastic/syntax_checkers/scss/sass_lint.vim [new file with mode: 0644]
vim/vimfiles/bundle/syntastic/syntax_checkers/scss/sassc.vim [new file with mode: 0644]
vim/vimfiles/bundle/syntastic/syntax_checkers/scss/scss_lint.vim [new file with mode: 0644]
vim/vimfiles/bundle/syntastic/syntax_checkers/scss/stylelint.vim [new file with mode: 0644]
vim/vimfiles/bundle/syntastic/syntax_checkers/sh/bashate.vim [new file with mode: 0644]
vim/vimfiles/bundle/syntastic/syntax_checkers/sh/checkbashisms.vim [new file with mode: 0644]
vim/vimfiles/bundle/syntastic/syntax_checkers/sh/sh.vim [new file with mode: 0644]
vim/vimfiles/bundle/syntastic/syntax_checkers/sh/shellcheck.vim [new file with mode: 0644]
vim/vimfiles/bundle/syntastic/syntax_checkers/slim/slim_lint.vim [new file with mode: 0644]
vim/vimfiles/bundle/syntastic/syntax_checkers/slim/slimrb.vim [new file with mode: 0644]
vim/vimfiles/bundle/syntastic/syntax_checkers/sml/smlnj.vim [new file with mode: 0644]
vim/vimfiles/bundle/syntastic/syntax_checkers/spec/rpmlint.vim [new file with mode: 0644]
vim/vimfiles/bundle/syntastic/syntax_checkers/sql/sqlint.vim [new file with mode: 0644]
vim/vimfiles/bundle/syntastic/syntax_checkers/stylus/stylint.vim [new file with mode: 0644]
vim/vimfiles/bundle/syntastic/syntax_checkers/tcl/nagelfar.vim [new file with mode: 0644]
vim/vimfiles/bundle/syntastic/syntax_checkers/tex/chktex.vim [new file with mode: 0644]
vim/vimfiles/bundle/syntastic/syntax_checkers/tex/lacheck.vim [new file with mode: 0644]
vim/vimfiles/bundle/syntastic/syntax_checkers/texinfo/makeinfo.vim [new file with mode: 0644]
vim/vimfiles/bundle/syntastic/syntax_checkers/text/atdtool.vim [new file with mode: 0644]
vim/vimfiles/bundle/syntastic/syntax_checkers/text/igor.vim [new file with mode: 0644]
vim/vimfiles/bundle/syntastic/syntax_checkers/text/language_check.vim [new file with mode: 0644]
vim/vimfiles/bundle/syntastic/syntax_checkers/text/textlint.vim [new file with mode: 0644]
vim/vimfiles/bundle/syntastic/syntax_checkers/trig/rapper.vim [new file with mode: 0644]
vim/vimfiles/bundle/syntastic/syntax_checkers/turtle/rapper.vim [new file with mode: 0644]
vim/vimfiles/bundle/syntastic/syntax_checkers/turtle/ttl.vim [new file with mode: 0644]
vim/vimfiles/bundle/syntastic/syntax_checkers/twig/twiglint.vim [new file with mode: 0644]
vim/vimfiles/bundle/syntastic/syntax_checkers/typescript/eslint.vim [new file with mode: 0644]
vim/vimfiles/bundle/syntastic/syntax_checkers/typescript/tslint.vim [new file with mode: 0644]
vim/vimfiles/bundle/syntastic/syntax_checkers/vala/valac.vim [new file with mode: 0644]
vim/vimfiles/bundle/syntastic/syntax_checkers/verilog/iverilog.vim [new file with mode: 0644]
vim/vimfiles/bundle/syntastic/syntax_checkers/verilog/verilator.vim [new file with mode: 0644]
vim/vimfiles/bundle/syntastic/syntax_checkers/vhdl/ghdl.vim [new file with mode: 0644]
vim/vimfiles/bundle/syntastic/syntax_checkers/vhdl/vcom.vim [new file with mode: 0644]
vim/vimfiles/bundle/syntastic/syntax_checkers/vim/vimlint.vim [new file with mode: 0644]
vim/vimfiles/bundle/syntastic/syntax_checkers/vim/vint.vim [new file with mode: 0644]
vim/vimfiles/bundle/syntastic/syntax_checkers/xhtml/jshint.vim [new file with mode: 0644]
vim/vimfiles/bundle/syntastic/syntax_checkers/xhtml/tidy.vim [new file with mode: 0644]
vim/vimfiles/bundle/syntastic/syntax_checkers/xml/plutil.vim [new file with mode: 0644]
vim/vimfiles/bundle/syntastic/syntax_checkers/xml/xmllint.vim [new file with mode: 0644]
vim/vimfiles/bundle/syntastic/syntax_checkers/xquery/basex.vim [new file with mode: 0644]
vim/vimfiles/bundle/syntastic/syntax_checkers/xslt/xmllint.vim [new file with mode: 0644]
vim/vimfiles/bundle/syntastic/syntax_checkers/yacc/bison.vim [new file with mode: 0644]
vim/vimfiles/bundle/syntastic/syntax_checkers/yaml/jsyaml.vim [new file with mode: 0644]
vim/vimfiles/bundle/syntastic/syntax_checkers/yaml/yamllint.vim [new file with mode: 0644]
vim/vimfiles/bundle/syntastic/syntax_checkers/yaml/yamlxs.vim [new file with mode: 0644]
vim/vimfiles/bundle/syntastic/syntax_checkers/yang/pyang.vim [new file with mode: 0644]
vim/vimfiles/bundle/syntastic/syntax_checkers/z80/z80syntaxchecker.vim [new file with mode: 0644]
vim/vimfiles/bundle/syntastic/syntax_checkers/zpt/zptlint.vim [new file with mode: 0644]
vim/vimfiles/bundle/syntastic/syntax_checkers/zsh/zsh.vim [new file with mode: 0644]
vim/vimfiles/bundle/tagbar/README [deleted file]
vim/vimfiles/bundle/tagbar/autoload/tagbar.vim
vim/vimfiles/bundle/tagbar/doc/tagbar.txt
vim/vimfiles/bundle/tagbar/doc/tags
vim/vimfiles/bundle/tagbar/plugin/tagbar.vim
vim/vimfiles/bundle/tagbar/syntax/tagbar.vim
vim/vimfiles/bundle/vim-taskwarrior/LICENSE.txt [new file with mode: 0644]
vim/vimfiles/bundle/vim-taskwarrior/README.md [new file with mode: 0644]
vim/vimfiles/bundle/vim-taskwarrior/autoload/airline/extensions/taskwarrior.vim [new file with mode: 0644]
vim/vimfiles/bundle/vim-taskwarrior/autoload/taskinfo.vim [new file with mode: 0644]
vim/vimfiles/bundle/vim-taskwarrior/autoload/taskwarrior.vim [new file with mode: 0644]
vim/vimfiles/bundle/vim-taskwarrior/autoload/taskwarrior/action.vim [new file with mode: 0644]
vim/vimfiles/bundle/vim-taskwarrior/autoload/taskwarrior/complete.vim [new file with mode: 0644]
vim/vimfiles/bundle/vim-taskwarrior/autoload/taskwarrior/data.vim [new file with mode: 0644]
vim/vimfiles/bundle/vim-taskwarrior/autoload/taskwarrior/log.vim [new file with mode: 0644]
vim/vimfiles/bundle/vim-taskwarrior/autoload/taskwarrior/sort.vim [new file with mode: 0644]
vim/vimfiles/bundle/vim-taskwarrior/autoload/unite/kinds/task.vim [new file with mode: 0644]
vim/vimfiles/bundle/vim-taskwarrior/autoload/unite/sources/task.vim [new file with mode: 0644]
vim/vimfiles/bundle/vim-taskwarrior/autoload/webapi/json.vim [new file with mode: 0644]
vim/vimfiles/bundle/vim-taskwarrior/doc/tags [new file with mode: 0644]
vim/vimfiles/bundle/vim-taskwarrior/doc/vim-tw.txt [new file with mode: 0644]
vim/vimfiles/bundle/vim-taskwarrior/ftplugin/taskreport.vim [new file with mode: 0644]
vim/vimfiles/bundle/vim-taskwarrior/plugin/taskwarrior.vim [new file with mode: 0644]
vim/vimfiles/bundle/vim-taskwarrior/screenshot.png [new file with mode: 0644]
vim/vimfiles/bundle/vim-taskwarrior/syntax/taskinfo.vim [new file with mode: 0644]
vim/vimfiles/bundle/vim-taskwarrior/syntax/taskreport.vim [new file with mode: 0644]
vim/vimfiles/init.vim [new file with mode: 0644]

diff --git a/bash/conkyrc b/bash/conkyrc
new file mode 100644 (file)
index 0000000..6849839
--- /dev/null
@@ -0,0 +1,97 @@
+# UBUNTU-CONKY
+# A comprehensive conky script, configured for use on
+# Ubuntu / Debian Gnome, without the need for any external scripts.
+#
+# Based on conky-jc and the default .conkyrc.
+# INCLUDES:
+# - netstat connections to your computer
+#
+# -- Pengo (conky@pengo.us)
+#
+
+# Create own window instead of using desktop (required in nautilus)
+own_window yes
+own_window_type override
+own_window_hints below
+
+# Use double buffering (reduces flicker, may not work for everyone)
+double_buffer yes
+text_buffer_size 2048
+
+# fiddle with window
+use_spacer right
+use_xft yes
+
+# Update interval in seconds
+update_interval 3.0
+
+#Maximum Width of Window
+# maximum_width 520
+
+# Minimum size of text area
+# minimum_size 250 5
+
+# Draw shades?
+draw_shades yes
+
+# Text stuff
+draw_outline no # amplifies text if yes
+draw_borders no
+font FreeMono:8
+uppercase no # set to yes if you want all text to be in uppercase
+
+# Stippled borders?
+stippled_borders 3
+
+# border width
+border_width 6
+
+# Default colors and also border colors, grey90 == #e5e5e5
+default_color FFFFCC
+
+# own_window_colour 8A8A8A
+own_window_transparent yes
+
+# Text alignment, other possible values are commented
+alignment top_left
+# alignment top_right
+#alignment bottom_left
+#alignment bottom_right
+
+# Gap between borders of screen and text
+gap_x 10
+gap_y 10
+
+# stuff after ‘TEXT’ will be formatted on screen
+
+TEXT
+$color
+${color CC9900}SYSTEM ${hr 2}$color
+$nodename $sysname $kernel on $machine
+
+Total CPU: ${cpu cpu0}%
+${color 597DB2}${cpubar}$color
+
+NAME            PID     CPU%   MEM%
+${color CCFFFF}${top name 1} ${top pid 1} ${top cpu 1} ${top mem 1}
+${top name 2} ${top pid 2} ${top cpu 2} ${top mem 2}
+${top name 3} ${top pid 3} ${top cpu 3} ${top mem 3}
+${top name 4} ${top pid 4} ${top cpu 4} ${top mem 4}$color
+${top name 5} ${top pid 5} ${top cpu 5} ${top mem 5}$color
+${top name 6} ${top pid 6} ${top cpu 6} ${top mem 6}$color
+
+${color CC9900}MEMORY ${hr 2}$color
+RAM Used: ${mem}       RAM Free: ${memfree}/ ${memmax}
+ RAM: $memperc%  ${color FF6600} ${membar 6}$color
+Swap: $swapperc%   ${color FF6600} ${swapbar 6}$color
+
+${color CC9900}DISK ${hr 2}$color
+sda1 ${fs_type} (Root): ${fs_free_perc /}% ${color FFFF33} ${fs_bar 6 /}$color
+
+${color CC9900}NETWORK (${addr eth0}) ${hr 2}$color
+Down: $color${downspeed eth0} k/s ${alignr}Up: ${upspeed eth0} k/s
+
+${color CC9900}NETWORK (${addr wlan0}) ${hr 2}$color
+Down: $color${downspeed wlan0} k/s ${alignr}Up: ${upspeed wlan0} k/s
+
+${execi 360 task list}
index 182ee18..656c4e0 100644 (file)
@@ -1,21 +1,39 @@
 
+export TERM=xterm-256color
 export EDITOR=vim
 export PAGER=more
+export HOST_ARCH=linux64
+export HISTFILESIZE=""
+export HISTSIZE=""
+
+# avoid duplicates..
+export HISTCONTROL=ignoredups:erasedups  
+# append history entries..
+shopt -s histappend
+
+# locale
+export LC_ALL=C
+export LANG=en_US.UTF-8
+export LANGUAGE=en_US.UTF-8
 
 # Python startup file
 export PYTHONSTARTUP=$HOME/.pythonrc
 
+# SHELL
+PROMPT_COMMAND='echo -n "[$(date +%H:%M)] "'
+
+# Swap caps and ESC
+alias swapEscape='setxkbmap -option "caps:swapescape"'
+
 # Tags for Vim
 TAG_FILE=tags
 makeTags(){
        rm -f $TAG_FILE
-       ctags --extra=+f --python-kinds=-i --language-force=Python -f $TAG_FILE $(find . -name \*.py -o -name \*.config)
+       #ctags --extra=+f --python-kinds=-i --language-force=Python -f $TAG_FILE $(find . -name \*.py -o -name \*.config)
        ctags --extra=+f -a --language-force=C -f $TAG_FILE $(find . -name \*.[ch]) 2>/dev/null
        ctags --extra=+f -a --language-force='C++' -f $TAG_FILE $(find . -name \*.[ch] -o -name \*.[ch]pp) 2>/dev/null
-       ctags --extra=+f -a --language-force=Basic -f $TAG_FILE $(find . -name \*.bas -o -name \*.cls) 2>/dev/null
        ctags --extra=+f -a --language-force=java -f $TAG_FILE $(find . -name \*.java) 2>/dev/null
-       ctags --extra=+f -a --language-force=lua -f $TAG_FILE $(find . -name \*.lua) 2>/dev/null
-       ctags --extra=+f -a --language-force=JavaScript -f $TAG_FILE $(find . -name \*.js) 2>/dev/null
+       #ctags --extra=+f -a --language-force=JavaScript -f $TAG_FILE $(find . -name \*.js) 2>/dev/null
 }
 
 # Find helpers
@@ -39,6 +57,11 @@ fj() {
     find $(pwd) -iname \*.java -exec grep -Hn "$@" {} \;
 }
 
+fjs() {
+    find $(pwd) -iname \*.js -exec grep -Hn "$@" {} \;
+}
+
+
 fsh() {
     find $(pwd) -iname \*.sh -exec grep -Hn "$@" {} \;
 }
@@ -51,16 +74,44 @@ findLogs() {
     find $(pwd) -iname \*.log
 }
 
-cleanVim() {
-       find . -name "*.swp"
+cleanFiles() {
+    local pattern=$1
+       find . -name "$pattern"
        read -p "Clean up files [y/N]: " CLEAN_UP
        if [ "$CLEAN_UP" == "y" ]; then
-               find . -name "*.swp" -exec rm {} \;
+               find . -name "$pattern" -exec rm {} \;
        else 
                echo "Aborting cleanup..."
        fi
 }
 
+cleanVim() {
+    cleanFiles "*.sw[op]"
+}
+
+cleanPyc() {
+    cleanFiles "*.pyc"
+}
+
+alias localWebServer='python -m SimpleHTTPServer'
+
+
+# TaskWarrior
+alias tl='task list'
+alias ts='task sync'
+alias ta='task add'
+function tm() {
+    task "$1" modify "$2"
+}
+function sshTunnel() {
+    ssh -4 -L $1:$2:$3 web@doumenc.org
+}
+function sshTask() {
+    sshTunnel 6666 freecinc.com 53589
+}
+
+
+
 function listJarContent() {
        jar=$1
        # Loop through the classes (everything ending in .class)
@@ -103,6 +154,10 @@ export GREP_COLOR='1;32'
 export GREP_OPTIONS='--color=auto'
 
 alias lla='ls -al'
+function mkcd() {
+    mkdir -p "$1"
+    cd "$1"
+}
 
 
 
diff --git a/bash/pythonrc b/bash/pythonrc
new file mode 100644 (file)
index 0000000..706a265
--- /dev/null
@@ -0,0 +1,155 @@
+# -*- coding: utf-8 -*-
+"""Best goddamn .pythonrc file in the whole world.
+
+This file is executed when the Python interactive shell is started if
+$PYTHONSTARTUP is in your environment and points to this file. It's just
+regular Python commands, so do what you will. Your ~/.inputrc file can greatly
+complement this file.
+
+"""
+# Imports we need
+import sys
+import os
+import readline, rlcompleter
+import atexit
+import pprint
+from tempfile import mkstemp
+from code import InteractiveConsole
+
+# Imports we want
+import datetime
+import pdb
+
+AUTHOR = 'Seth House <seth@eseth.com>'
+
+# Color Support
+###############
+
+class TermColors(dict):
+    """Gives easy access to ANSI color codes. Attempts to fall back to no color
+    for certain TERM values. (Mostly stolen from IPython.)"""
+
+    COLOR_TEMPLATES = (
+        ("Black"       , "0;30"),
+        ("Red"         , "0;31"),
+        ("Green"       , "0;32"),
+        ("Brown"       , "0;33"),
+        ("Blue"        , "0;34"),
+        ("Purple"      , "0;35"),
+        ("Cyan"        , "0;36"),
+        ("LightGray"   , "0;37"),
+        ("DarkGray"    , "1;30"),
+        ("LightRed"    , "1;31"),
+        ("LightGreen"  , "1;32"),
+        ("Yellow"      , "1;33"),
+        ("LightBlue"   , "1;34"),
+        ("LightPurple" , "1;35"),
+        ("LightCyan"   , "1;36"),
+        ("White"       , "1;37"),
+        ("Normal"      , "0"),
+    )
+
+    NoColor = ''
+    _base  = '\001\033[%sm\002'
+
+    def __init__(self):
+        if os.environ.get('TERM') in ('xterm-color', 'xterm-256color', 'linux',
+                                    'screen', 'screen-256color', 'screen-bce'):
+            self.update(dict([(k, self._base % v) for k,v in self.COLOR_TEMPLATES]))
+        else:
+            self.update(dict([(k, self.NoColor) for k,v in self.COLOR_TEMPLATES]))
+_c = TermColors()
+
+# Enable a History
+##################
+
+HISTFILE="%s/.pyhistory" % os.environ["HOME"]
+
+# Read the existing history if there is one
+if os.path.exists(HISTFILE):
+    readline.read_history_file(HISTFILE)
+
+# Set maximum number of items that will be written to the history file
+readline.set_history_length(300)
+
+# autocomplete
+readline.parse_and_bind('tab:complete')
+
+def savehist():
+    readline.write_history_file(HISTFILE)
+
+atexit.register(savehist)
+
+# Enable Color Prompts
+######################
+
+sys.ps1 = '%s>>> %s' % (_c['Green'], _c['Normal'])
+sys.ps2 = '%s... %s' % (_c['Red'], _c['Normal'])
+
+# Enable Pretty Printing for stdout
+###################################
+
+def my_displayhook(value):
+    if value is not None:
+        try:
+            import __builtin__
+            __builtin__._ = value
+        except ImportError:
+            __builtins__._ = value
+
+        pprint.pprint(value)
+sys.displayhook = my_displayhook
+
+# Welcome message
+#################
+
+WELCOME = """\
+%(Cyan)s
+You've got color, history, and pretty printing.
+(If your ~/.inputrc doesn't suck, you've also
+got completion and vi-mode keybindings.)
+%(Brown)s
+Type \e to get an external editor.
+%(Normal)s""" % _c
+
+atexit.register(lambda: sys.stdout.write("""%(DarkGray)s
+Sheesh, I thought he'd never leave. Who invited that guy?
+%(Normal)s""" % _c))
+
+
+# Start an external editor with \e
+##################################
+# http://aspn.activestate.com/ASPN/Cookbook/Python/Recipe/438813/
+
+EDITOR = os.environ.get('EDITOR', 'vi')
+EDIT_CMD = '\e'
+
+class EditableBufferInteractiveConsole(InteractiveConsole):
+    def __init__(self, *args, **kwargs):
+        self.last_buffer = [] # This holds the last executed statement
+        InteractiveConsole.__init__(self, *args, **kwargs)
+
+    def runsource(self, source, *args):
+        self.last_buffer = [ source.encode('utf-8') ]
+        return InteractiveConsole.runsource(self, source, *args)
+
+    def raw_input(self, *args):
+        line = InteractiveConsole.raw_input(self, *args)
+        if line == EDIT_CMD:
+            fd, tmpfl = mkstemp('.py')
+            os.write(fd, b'\n'.join(self.last_buffer))
+            os.close(fd)
+            os.system('%s %s' % (EDITOR, tmpfl))
+            line = open(tmpfl).read()
+            os.unlink(tmpfl)
+            tmpfl = ''
+            lines = line.split( '\n' )
+            for i in range(len(lines) - 1): self.push( lines[i] )
+            line = lines[-1]
+        return line
+
+c = EditableBufferInteractiveConsole(locals=locals())
+c.interact(banner=WELCOME)
+
+# Exit the Python shell on exiting the InteractiveConsole
+sys.exit()
index 3016fdf..1221a92 100644 (file)
Binary files a/data/cv.pdf and b/data/cv.pdf differ
index 2e72af9..c57dad9 100644 (file)
@@ -55,7 +55,7 @@
   \hfill
   \begin{minipage}{5cm}
     \begin{center}
-      31 ans\\
+      32 ans\\
       Nationalité Française\\
       en couple\\
     \end{center}
@@ -67,9 +67,9 @@
 
 \begin{center}
 
-{\bfseries\huge Ingénieur Logiciel}
+{\bfseries\huge Responsable Développement Logiciel \\ Leader Technique}
 
-\vspace{2ex}{\small\today{} --- 4 pages}
+\vspace{2ex}{\small\today{} --- 3 pages}
 
 \end{center}
 
 \vspace{4pt}
 
 \begin{tabular}{p{0.22\linewidth}p{0.70\linewidth}}
+  {\bfseries{}Test} & {\bfseries{}xUnit}, FitNesse, Concordion \\
+\end{tabular}
+
+\vspace{4pt}
+
+\begin{tabular}{p{0.22\linewidth}p{0.70\linewidth}}
   {\bfseries{}Systèmes} & \begin{minipage}[t]{\linewidth}
-    {\bfseries{}Linux} --- {\bfseries{}Android}
+    {\bfseries{}Linux} (drivers noyau) --- {\bfseries{}Android}
   \end{minipage}
 \end{tabular}
 
 
 \begin{tabular}{p{0.22\linewidth}p{0.70\linewidth}}
   {\bfseries{}02/2013 -- } & {\em{}Parkeon}\\
-  & Leader technique d'une équipe de 4 personnes, définition, conception et développement d'une nouvelle architecture logicielle
+  & Leadership technique et management d'une équipe de 4 personnes + 1 offshore, définition, conception et développement d'une nouvelle architecture logicielle
     basée sur Android dans le cadre du développpement des équipements embarqués pour
     un projet de billétique complet. \\
   & Cette architecture a pour but de pouvoir supporter quatre configurations matérielles
     différentes, en s'appuyant sur les forces de la plateforme Android. Ces quatres configurations,
-    basé sur une même carte électronique, comportent un valideur de titres, un pupitre conducteur,
+    basées sur une même carte électronique, comportent un valideur de titres, un pupitre conducteur,
     un distributeur de titres mobile et un portable de contrôle. \\
-  & $\rightarrow$~{\bfseries{}Java, C, Android}\textnormal{, Jenkins}\\
+  & Fourniture d'un SDK au-dessus du SDK Android pour des développements clients\\
+  & $\rightarrow$~{\bfseries{}Java, JNI, C, Android}\textnormal{, Jenkins}\\
+  & $\rightarrow$~{\bfseries{}JavaScript / HTML5 /CSS3}\textnormal{, Angularjs}\\
 \end{tabular}
 
-\vspace{6pt}
+\vspace{4pt}
 
 
 \begin{tabular}{p{0.22\linewidth}p{0.70\linewidth}}
   {\bfseries{}10/2011 -- 02/2013} & {\em{}Parkeon}\\
-  & Développement du logiciel applicatif pour des automates de vente \\
-  & Dans le cadre d'un projet pour la RENFE, développement du logiciel applicatif
-   des automates, se basant sur le socle logiciel générique {\em{Parkeon}}. \\
-  & Interface directe avec le bureau d'étude du client pour la définition des interfaces logicielles
-    pour le module de séléction (composant réutilisable par le client). \\
-  & Customisation et mise en production du logiciel générique. \\
+  & Leadership technique, logiciel applicatif pour des automates de vente. \\
+  & Dans le cadre d'un projet pour la RENFE, pilotage du développement du logiciel applicatif
+   des automates, se basant sur le socle logiciel générique {\em{Parkeon}}. 
+   Interface directe avec le bureau d'étude du client pour la définition des interfaces logicielles.
+   Customisation et mise en production du logiciel générique. \\
   & $\rightarrow$~{\bfseries{}Java, C, Windows Xp}\textnormal{, Jenkins}\\
 \end{tabular}
 
-\vspace{6pt}
+\vspace{4pt}
 
 
 \begin{tabular}{p{0.22\linewidth}p{0.70\linewidth}}
   {\bfseries{}04/2011 -- 09/2011} & {\em{}Intitek~: en mission chez {\bfseries{}Parkeon}}\\
   & Développement d'une couche d'abstraction billétique ISO 1545 \\
-  & Dans le cadre du développement d'une couche d'abstraction billétique au sein de l'équipe
-   sans contact, participation à la conception et au développement du module TPL 
-   (Ticketing Presentation Layer). Ce module multiplateforme fournit la couche ISO1545, 
+  & Au sein de l'équipe sans contact, participation à la conception et au développement du module TPL 
+   (Ticketing Presentation Layer), fournissant la couche ISO1545, 
    permettant l'abstraction des types de cartes et l'utilisation de la norme Intercode 
    de manière générique. \\
   & $\rightarrow$~{\bfseries{}C, Linux Ubuntu}\textnormal{, CUnit, Python, PyConcordion, Jenkins}\\
 \end{tabular}
 
-\vspace{6pt}
+\vspace{4pt}
 
 \begin{tabular}{p{0.22\linewidth}p{0.70\linewidth}}
   {\bfseries{}08/2008 -- 04/2011} & {\em{}Intitek~: en mission chez {\bfseries{}Parkeon}}\\
-  & Maintenance corrective et évolutive des automates de vente de la {\bfseries{}RATP} \\
+  & Maintenance logicielle des automates de vente de la {\bfseries{}RATP} \\
   & Correction des anomalies logicielles sur les deux plateformes des automates de vente RATP.\\
   & Ces corrections ont inclus par exemple le développement d'un pilote d'acquisition
   pour le serveur graphique {\bfseries{}X.org} afin de corriger le comportement du pilote
   propriétaire de la dalle tactile.\\
-  & Participation au chiffrage et développement d'un lot d'évolutions portant sur l'ensemble
-  du logiciel équipant les automates de vente RATP.\\
-  & Dans le cadre du remplacement de l'architecture bancaire de la RATP, 
-   participation au chiffrage, à la conception et au développement d'un 
-   module multiplateforme permettant l'intégration d'un module tiers  
-   (module d'interface en Python communiquant par TCP/IP en local avec le service bancaire). \\
+  & Développement d'un lot d'évolutions du logiciel.\\
+  & Leadership technique sur l'intégration d'un module tiers
+  dans le cadre du remplacement de l'architecture bancaire de la RATP\\
   & $\rightarrow$~{\bfseries{}Python, Linux Debian}\textnormal{, C++, Corba, unittest, Fitnesse, Hudson}\\
   & $\rightarrow$~{\bfseries{}Visual Basic 6}\textnormal{, C++}
 \end{tabular}
 
-\vspace{6pt}
+\vspace{4pt}
 
 \begin{tabular}{p{0.22\linewidth}p{0.70\linewidth}}
   {\bfseries{}03/2008 -- 08/2008} & {\em{}Intitek~: en mission chez {\bfseries{}Parkeon}}\\
   & $\rightarrow$~{\bfseries{}Python}\textnormal{, Bash}
 \end{tabular}
 
-\vspace{6pt}
-
-\begin{tabular}{p{0.22\linewidth}p{0.70\linewidth}}
-  {\bfseries{}02/2007 --~06/2007} & {\em{}Laboratoire d'Automatique de Besançon: développement d'une bibliothèque d'extension pour {\bfseries{}MatLab/SimuLink}}\\
-  & Conception et implémentation en C et C++ d'une bibliothèque de blocs pour Matlab/Simulink.
-  Cette bibliothèque a pour but de fournir des fonctions pour le traitement d'images grâce
-  à {\bfseries{}OpenCV}. Elle permet en particulier le traitement de flux vidéos en temps réel,
-  facilitant ainsi le prototypage d'asservissements visuels.\\
-  & $\rightarrow$~{\bfseries{}C++}\textnormal{, OpenCV, SimuLink}
-\end{tabular}
-
 \newpage
 
 %----------------------------------------------------------------------------%
index 2045b83..6df13de 100644 (file)
@@ -53,7 +53,8 @@ static const Layout layouts[] = {
 
 /* commands */
 static const char *dmenucmd[] = { "dmenu_run", "-fn", font, "-nb", normbgcolor, "-nf", normfgcolor, "-sb", selbgcolor, "-sf", selfgcolor, NULL };
-static const char *termcmd[]  = { "rxvt-unicode", NULL };
+static const char *termcmd[]  = { "terminology", NULL };
+static const char *termprjcmd[]  = { "launchProjectTerm.sh", NULL };
 static const char *browsercmd[]  = { "firefox", NULL };
 static const char *projectcmd[]  = { "launchProjectVim.sh", NULL };
 static const char *lockcmd[]  = { "slock", NULL };
@@ -66,6 +67,7 @@ static Key keys[] = {
        { MODKEY|ShiftMask,             XK_e,      spawn,          {.v = browsercmd } },
        { MODKEY|ShiftMask,             XK_f,      spawn,          {.v = filecmd } },
        { MODKEY|ShiftMask,             XK_l,      spawn,          {.v = lockcmd } },
+       { MODKEY,                       XK_c,      spawn,          {.v = termprjcmd } },
        { MODKEY,                       XK_v,      spawn,          {.v = projectcmd } },
        { MODKEY,                       XK_b,      togglebar,      {0} },
        { MODKEY,                       XK_j,      focusstack,     {.i = +1 } },
index c9ef9cd..56ceb73 100644 (file)
@@ -4,7 +4,7 @@ VERSION = 6.1
 # Customize below to fit your system
 
 # paths
-PREFIX = /home/ben
+PREFIX = /home/bdoumenc
 MANPREFIX = ${PREFIX}/.local/share/man
 
 X11INC = /usr/X11R6/include
index bd52806..88cc0d3 100644 (file)
@@ -1,5 +1,5 @@
 
-PREFIX = /home/ben
+PREFIX = /home/bdoumenc
 
 all: dwmstatus
 
index cf5a755..7e3054a 100644 (file)
@@ -13,8 +13,8 @@
 #include <X11/Xlib.h>
 
 static Display *dpy;
-long cpu0_work = 0;
-long cpu0_total = 0;
+long cpu0_work=0, cpu1_work=0, cpu2_work=0, cpu3_work=0;
+long cpu0_total=0, cpu1_total=0, cpu2_total=0, cpu3_total=0;
 
 void setstatus(char *str) {
        XStoreName(dpy, DefaultRootWindow(dpy), str);
@@ -24,8 +24,9 @@ void setstatus(char *str) {
 int getcpu(char *status, size_t size) {
     FILE *fd;
     long jif1, jif2, jif3, jif4, jif5, jif6, jif7;
-    long work0, total0;
-    int load0, freq;
+    long work0, work1, work2, work3;
+    long total0, total1, total2, total3;
+    int load0, load1, load2, load3;
 
     // ---- LOAD
     fd = fopen("/proc/stat", "r");
@@ -35,19 +36,43 @@ int getcpu(char *status, size_t size) {
     work0 = jif1 + jif2 + jif3 + jif6 + jif7;
     total0 = work0 + jif4 + jif5;
 
+    c = 0;
+    while (c != '\n') c = fgetc(fd);
+    fscanf(fd, "cpu1 %ld %ld %ld %ld %ld %ld %ld", &jif1, &jif2, &jif3, &jif4, &jif5, &jif6, &jif7);
+    work1 = jif1 + jif2 + jif3 + jif6 + jif7;
+    total1 = work1 + jif4 + jif5;
+
+    c = 0;
+    while (c != '\n') c = fgetc(fd);
+    fscanf(fd, "cpu2 %ld %ld %ld %ld %ld %ld %ld", &jif1, &jif2, &jif3, &jif4, &jif5, &jif6, &jif7);
+    work2 = jif1 + jif2 + jif3 + jif6 + jif7;
+    total2 = work2 + jif4 + jif5;
+
+    c = 0;
+    while (c != '\n') c = fgetc(fd);
+    fscanf(fd, "cpu3 %ld %ld %ld %ld %ld %ld %ld", &jif1, &jif2, &jif3, &jif4, &jif5, &jif6, &jif7);
+    work3 = jif1 + jif2 + jif3 + jif6 + jif7;
+    total3 = work3 + jif4 + jif5;
+
     fclose(fd);
 
     load0 = 100 * (work0 - cpu0_work) / (total0 - cpu0_total);
-    
     cpu0_work = work0;
     cpu0_total = total0;
 
-    // ---- FREQ
-    fd = fopen("/sys/devices/system/cpu/cpu0/cpufreq/scaling_cur_freq", "r");
-    fscanf(fd, "%d", &freq);
-    fclose(fd);
+    load1 = 100 * (work1 - cpu1_work) / (total1 - cpu1_total);
+    cpu1_work = work1;
+    cpu1_total = total1;
+
+    load2 = 100 * (work2 - cpu2_work) / (total2 - cpu2_total);
+    cpu2_work = work2;
+    cpu2_total = total2;
+
+    load3 = 100 * (work3 - cpu3_work) / (total3 - cpu3_total);
+    cpu3_work = work3;
+    cpu3_total = total3;
 
-    return snprintf(status, size, "C: %3d%% |", load0);
+    return snprintf(status, size, "C: %3d%% %3d%% %3d%% %3d%% | ", load0, load1, load2, load3);
 }
 
 int getmem(char *status, size_t size) {
@@ -59,7 +84,7 @@ int getmem(char *status, size_t size) {
     fscanf(fd, "MemTotal: %ld kB\nMemFree: %ld kB\nBuffers: %ld kB\nCached: %ld kB\n", &total, &free, &buf, &cache);
     fclose(fd);
     used = 100 * (total - free - buf - cache) / total;
-    return snprintf(status, size, " M: %3d%% |", used);
+    return snprintf(status, size, "M: %3d%% | ", used);
 }
 
 int getdatetime(char *status, size_t size) {
@@ -93,16 +118,16 @@ int getbattery(char *status, size_t size) {
 
     if(strncmp(stat, "Discharging", 11) == 0) {    
         if(bat < 20) {            
-            return snprintf(status, size, "B%d%%", bat);
+            return snprintf(status, size, "B %d%% |", bat);
         } else if(bat > 80) {
-            return snprintf(status, size, "B%d%%", bat);
+            return snprintf(status, size, "B %d%% |", bat);
         } else {
-            return snprintf(status, size, "B%d%%", bat);
+            return snprintf(status, size, "B %d%% |", bat);
         }
     } else if(strncmp(stat, "Charging", 8) == 0) {
-        return snprintf(status, size, "B AC%d%%", bat);
+        return snprintf(status, size, "B AC%d%% |", bat);
     } else {
-        return snprintf(status, size, "B""AC");
+        return snprintf(status, size, "B ""AC |");
     }
 }
 
@@ -162,14 +187,14 @@ int getwireless(char* status, size_t size) {
     fscanf(fd, "%31s %x %d.", itf, &stat, &quality);
     fclose(fd);
 
-    return snprintf(status, size, " %s %d%% |", itf, quality);
+    return snprintf(status, size, "%s %d%% | ", itf, quality);
 }
 
 int getwired(char* status, size_t size) {
     if (access("/tmp/wired", F_OK) == -1) {
         return 0;
     }
-    return snprintf(status, size, "N""UP");
+    return snprintf(status, size, "N"" UP | ");
 }
 
 int main(void) {
@@ -188,11 +213,12 @@ int main(void) {
         l += getmem(status + l, sizeof(status) - l);
         l += getwireless(status + l, sizeof(status) - l);
         l += getwired(status + l, sizeof(status) - l);
-        //l += getbattery(status + l, sizeof(status) - l);
-        //l += getvol(status + l, sizeof(status) - l);
+        l += getbattery(status + l, sizeof(status) - l);
+        /* //l += getvol(status + l, sizeof(status) - l); */
         l += getdatetime(status + l, sizeof(status) - l);
         
         //fprintf(stderr, "%d\n", l);
+        fprintf(stderr, "%s\n", status);
 
                setstatus(status);
        }
index 69ba7b2..d99728b 100644 (file)
@@ -1,5 +1,6 @@
 
 URxvt*background:       rgba:0000/0000/0000/dddd
+URxvt*foreground:       #f2f2f2
 URxvt*color0:   #101010
 URxvt*color1:   #f13a21
 URxvt*color2:   #93f91d
@@ -17,10 +18,10 @@ URxvt*color13:  #ef0051
 URxvt*color14:  #4bb8fd
 URxvt*color15:  #a020f0
 URxvt*cursorColor:      white
-URxvt*depth:    32
-!URxvt*font:     xft:Bitstream Vera Sans Mono:style=Regular:pixelsize=13:antialias=true
-Rxvt*font:     xft:Inconsolata\-dz for Powerline:style=dzForPowerline:pixelsize=12:antialias=true
-URxvt*foreground:       #f2f2f2
+URxvt.colorUL: #4682B4
+! URxvt*depth:    32
+URxvt*font:     xft:Bitstream Vera Sans Mono:style=Regular:pixelsize=13:antialias=true
+! Rxvt*font:     xft:Inconsolata\-dz for Powerline:style=dzForPowerline:pixelsize=12:antialias=true
 URxvt*geometry: 74x27
 URxvt*keysym.End:       \033[8~
 URxvt*keysym.Home:      \033[7~
@@ -31,16 +32,15 @@ URxvt*scrollBar_right:  true
 URxvt*scrollColor:      #c2dd5a
 URxvt*scrollstyle:      plain
 URxvt*scrollTtyOutput:  false
-URxvt*scrollWithBuffer: false
+URxvt*scrollWithBuffer: true
 URxvt*scrollTtyKeypress: true
-URxvt*termName: xterm
-URxvt*transparent: true
+URxvt*transparent: false
 URxvt*shading: 20
 URxvt.letterSpace: -1
 URxvt.perl-ext-common: default,matcher,tabbedex,vtwheel
-URxvt.url-launcher: /usr/bin/firefox
-URxvt.matcher.button: 1
-URxvt.colorUL: #4682B4
+
+URxvt*keysym.Home: \033[1~
+URxvt*keysym.End: \033[4~
 
 
 URxvt.tabbed.tabbar-fg: 2
diff --git a/suckless/stest/Makefile b/suckless/stest/Makefile
new file mode 100644 (file)
index 0000000..6443970
--- /dev/null
@@ -0,0 +1,21 @@
+
+PREFIX = /home/bdoumenc
+
+all: stest
+
+dwmstatus: stest.c
+       gcc -g -Wall -pedantic -std=c99 -o stest stest.c -lX11
+
+clean:
+       rm stest
+
+install: all
+       @echo installing executable file to ${PREFIX}/bin
+       @mkdir -p ${PREFIX}/bin
+       @cp -f stest ${PREFIX}/bin
+
+uninstall:
+       @echo removing executable file from ${PREFIX}/bin
+       @rm -f ${PREFIX}/bin/stest
+
+.PHONY: all clean install uninstall
diff --git a/suckless/stest/arg.h b/suckless/stest/arg.h
new file mode 100644 (file)
index 0000000..8cc14e0
--- /dev/null
@@ -0,0 +1,51 @@
+
+/*
+ * Copy me if you can.
+ * by 20h
+ */
+
+#ifndef ARG_H__
+#define ARG_H__
+
+extern char *argv0;
+
+/* use main(int argc, char *argv[]) */
+#define ARGBEGIN       for (argv0 = *argv, argv++, argc--;\
+                                       argv[0] && argv[0][0] == '-'\
+                                       && argv[0][1];\
+                                       argc--, argv++) {\
+                               char argc_;\
+                               char **argv_;\
+                               int brk_;\
+                               if (argv[0][1] == '-' && argv[0][2] == '\0') {\
+                                       argv++;\
+                                       argc--;\
+                                       break;\
+                               }\
+                               for (brk_ = 0, argv[0]++, argv_ = argv;\
+                                               argv[0][0] && !brk_;\
+                                               argv[0]++) {\
+                                       if (argv_ != argv)\
+                                               break;\
+                                       argc_ = argv[0][0];\
+                                       switch (argc_)
+
+#define ARGEND                 }\
+                       }
+
+#define ARGC()         argc_
+
+#define EARGF(x)       ((argv[0][1] == '\0' && argv[1] == NULL)?\
+                               ((x), abort(), (char *)0) :\
+                               (brk_ = 1, (argv[0][1] != '\0')?\
+                                       (&argv[0][1]) :\
+                                       (argc--, argv++, argv[0])))
+
+#define ARGF()         ((argv[0][1] == '\0' && argv[1] == NULL)?\
+                               (char *)0 :\
+                               (brk_ = 1, (argv[0][1] != '\0')?\
+                                       (&argv[0][1]) :\
+                                       (argc--, argv++, argv[0])))
+
+#endif
+
diff --git a/suckless/stest/stest.c b/suckless/stest/stest.c
new file mode 100644 (file)
index 0000000..95ad932
--- /dev/null
@@ -0,0 +1,111 @@
+/* See LICENSE file for copyright and license details. */
+#include <sys/stat.h>
+
+#include <dirent.h>
+#include <limits.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+
+#include "arg.h"
+char *argv0;
+
+#define FLAG(x)  (flag[(x)-'a'])
+
+static void test(const char *, const char *);
+static void usage(void);
+
+static int match = 0;
+static int flag[26];
+static struct stat old, new;
+
+static void
+test(const char *path, const char *name)
+{
+       struct stat st, ln;
+
+       if ((!stat(path, &st) && (FLAG('a') || name[0] != '.')        /* hidden files      */
+       && (!FLAG('b') || S_ISBLK(st.st_mode))                        /* block special     */
+       && (!FLAG('c') || S_ISCHR(st.st_mode))                        /* character special */
+       && (!FLAG('d') || S_ISDIR(st.st_mode))                        /* directory         */
+       && (!FLAG('e') || access(path, F_OK) == 0)                    /* exists            */
+       && (!FLAG('f') || S_ISREG(st.st_mode))                        /* regular file      */
+       && (!FLAG('g') || st.st_mode & S_ISGID)                       /* set-group-id flag */
+       && (!FLAG('h') || (!lstat(path, &ln) && S_ISLNK(ln.st_mode))) /* symbolic link     */
+       && (!FLAG('n') || st.st_mtime > new.st_mtime)                 /* newer than file   */
+       && (!FLAG('o') || st.st_mtime < old.st_mtime)                 /* older than file   */
+       && (!FLAG('p') || S_ISFIFO(st.st_mode))                       /* named pipe        */
+       && (!FLAG('r') || access(path, R_OK) == 0)                    /* readable          */
+       && (!FLAG('s') || st.st_size > 0)                             /* not empty         */
+       && (!FLAG('u') || st.st_mode & S_ISUID)                       /* set-user-id flag  */
+       && (!FLAG('w') || access(path, W_OK) == 0)                    /* writable          */
+       && (!FLAG('x') || access(path, X_OK) == 0)) != FLAG('v')) {   /* executable        */
+               if (FLAG('q'))
+                       exit(0);
+               match = 1;
+               puts(name);
+       }
+}
+
+static void
+usage(void)
+{
+       fprintf(stderr, "usage: %s [-abcdefghlpqrsuvwx] "
+               "[-n file] [-o file] [file...]\n", argv0);
+       exit(2); /* like test(1) return > 1 on error */
+}
+
+int
+main(int argc, char *argv[])
+{
+       struct dirent *d;
+       char path[PATH_MAX], *line = NULL, *file;
+       size_t linesiz = 0;
+       ssize_t n;
+       DIR *dir;
+       int r;
+
+       ARGBEGIN {
+       case 'n': /* newer than file */
+       case 'o': /* older than file */
+               file = EARGF(usage());
+               if (!(FLAG(ARGC()) = !stat(file, (ARGC() == 'n' ? &new : &old))))
+                       perror(file);
+               break;
+       default:
+               /* miscellaneous operators */
+               if (strchr("abcdefghlpqrsuvwx", ARGC()))
+                       FLAG(ARGC()) = 1;
+               else
+                       usage(); /* unknown flag */
+       } ARGEND;
+
+       if (!argc) {
+               /* read list from stdin */
+               while ((n = getline(&line, &linesiz, stdin)) > 0) {
+                       if (n && line[n - 1] == '\n')
+                               line[n - 1] = '\0';
+                       test(line, line);
+               }
+               free(line);
+       } else {
+               for (; argc; argc--, argv++) {
+                       if (FLAG('l') && (dir = opendir(*argv))) {
+                               /* test directory contents */
+                               while ((d = readdir(dir))) {
+                                       r = snprintf(path, sizeof path, "%s/%s",
+                                                    *argv, d->d_name);
+                                       if (r >= 0 && (size_t)r < sizeof path)
+                                               test(path, d->d_name);
+                               }
+                               closedir(dir);
+                       } else {
+                               test(*argv, *argv);
+                       }
+               }
+       }
+       return match ? 0 : 1;
+}
+
+
index 9ad8e34..e0bcf99 100644 (file)
@@ -33,6 +33,13 @@ au BufRead,BufNewFile *.data set filetype=python
 " aidl files are Java files
 au BufRead,BufNewFile *.aidl set filetype=java
 
+" Indenting JSON and XML files (=l)
+au BufEnter *.xml setlocal equalprg=xmllint\ --format\ --recover\ -\ 2>/dev/null
+au BufEnter *.json setlocal equalprg=python\ -mjson.tool
+
+" Encoding
+set encoding=utf-8
+
 " Omnicomplete
 filetype plugin on
 set omnifunc=syntaxcomplete#Complete
@@ -62,8 +69,29 @@ endif
 
 set background=dark
 
+
 set guifont=Inconsolata-dz\ for\ Powerline\ 8
 
+function! FontSizePlus ()
+  let l:gf_size_whole = matchstr(&guifont, '\( \)\@<=\d\+$')
+  let l:gf_size_whole = l:gf_size_whole + 1
+  let l:new_font_size = ' '.l:gf_size_whole
+  let &guifont = substitute(&guifont, ' \d\+$', l:new_font_size, '')
+endfunction
+
+function! FontSizeMinus ()
+  let l:gf_size_whole = matchstr(&guifont, '\( \)\@<=\d\+$')
+  let l:gf_size_whole = l:gf_size_whole - 1
+  let l:new_font_size = ' '.l:gf_size_whole
+  let &guifont = substitute(&guifont, ' \d\+$', l:new_font_size, '')
+endfunction
+
+
+if has("gui_running")
+    nmap <S-F12> :call FontSizeMinus()<CR>
+    nmap <F12> :call FontSizePlus()<CR>
+endif
+
 " solarized theme http://ethanschoonover.com/solarized/vim-colors-solarized
 "let g:solarized_termcolors=256
 "colors solarized
@@ -79,7 +107,7 @@ let NERDTreeShowBookmarks=1
 let g:NERDTreeIgnore = ['\~$', '\.pyc$', '\.taghl$', 'tags', "CVS", '\.o$']
 
 " automatically remove trailing whitespace before write
-function! StripTrailingWhitespace()
+function! <SID>StripWhite()
   normal mZ
   %s/\s\+$//e
   if line("'Z") != line(".")
@@ -88,7 +116,8 @@ function! StripTrailingWhitespace()
   %retab
   normal `Z
 endfunction
-autocmd BufWritePre *.java,.[ch],*.[ch]pp :call StripTrailingWhitespace()
+"autocmd BufWritePre *.java,.[ch],*.[ch]pp :call StripWhite()
+command! -nargs=? Strip call <SID>StripWhite()
 
 
 " Common stuff
@@ -137,7 +166,7 @@ function! <SID>AgDir(word)
     echom "Use Ag dir " . l:path . " for searching " . l:pattern
     execute ":Ag! " . l:pattern . " " . l:path
 endfunction
-command! -nargs=1  -complete=tag F call <SID>AgDir(<f-args>)
+command! -nargs=1 -complete=tag F call <SID>AgDir(<f-args>)
 
 " Launch ag in base directory with under cursor word
 function AgDirCurrentWord()
@@ -183,15 +212,15 @@ set statusline+=,\ %c     "cursor column
 set statusline+=\ \ %P    "percent through file
 
 " Fuzzy finder (CtrlP) 
+map <c-d> :CtrlPBuffer<CR>
 let g:ctrlp_map = '<c-f>'
 let g:ctrlp_cmd = 'CtrlP ' . s:basePath
 let g:ctrlp_max_files = 0
-let g:ctrlp_custom_ignore = '\v[\/](\.git|\.hg|\.svn|.PUBLIC|.LIVR|gen|obj|.*\.pyc|.*\.class)$'
+let g:ctrlp_custom_ignore = '\v[\/](\.git|\.hg|\.svn|.PUBLIC|.LIVR|bin|gen|obj|deps|delivery|build|output|.*\.pyc|.*\.class|.*\.jar|.*\.gz|.*\.zip)$'
 let g:ctrlp_by_filename = 1
 let g:ctrlp_regex = 1
 let g:ctrlp_reuse_window = 'netrw\|NERD.*'
 let g:ctrlp_clear_cache_on_exit = 0
-let g:ctrlp_cache_dir = '/tmp/.cache/ctrlp'
 
 " vimwiki
 
@@ -205,25 +234,25 @@ let g:vimwiki_list = [wiki_work, wiki_perso]
 " Easily GREP current word in current file.
 command GREP :execute 'vimgrep '.expand('<cword>').' '.expand('%') | :copen | :cc
 
-" Java plugin      
-function! <SID>JavaImpUpdate()
-    echo 'Find jar paths...' 
-    let searchCmd = 'find $BASHJECT_PRJ_DIR -name "com"  | paste -s -d,'
-    let g:JavaImpPaths = system(searchCmd)
-    let g:JavaImpDataDir = expand($BASHJECT_PRJ_DIR) . '/.vimJava'
-    echo 'Done: ' . g:JavaImpPaths
-endfunction
-
-function! <SID>JavaImpFullUpdate()
-    echo 'Find base gen framework jar paths'
-    let searchCmdBase = 'find ${HOME}/sources/TVMGEN-trunk/soft_uc -name "com"  | paste -s -d,'
-    let searchCmdGen = 'find ${HOME}/sources/TVMBASE-trunk/soft_uc -name "com"  | paste -s -d,'
-    let searchCmdFramework = 'find ${HOME}/sources/TVM_FRAMEWORK/trunk/ -name "com"  | paste -s -d,'
-    let searchCmd = 'find $BASHJECT_PRJ_DIR -name "com"  | paste -s -d,'
-    let g:JavaImpPaths = expand($HOME) . '/.vim/bundle/JavaImp/,' . system(searchCmdBase) . ',' . system(searchCmdGen) . ',' . system(searchCmdFramework) . ',' . system(searchCmd)
-    echo 'Done: ' . g:JavaImpPaths
-endfunction
-
-command! -nargs=? JIU call <SID>JavaImpUpdate()
-command! -nargs=? JIFU call <SID>JavaImpFullUpdate()
+" Syntastic
+" 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 = 0
+" let g:syntastic_check_on_wq = 0
+" let g:syntastic_java_javac_delete_output = 0
+" function! ToggleErrors()
+"     let old_last_winnr = winnr('$')
+"     lclose
+"     if old_last_winnr == winnr('$')
+"         " Nothing was closed, open syntastic error location panel
+"         Errors
+"     endif
+endfunction
+" nnoremap <silent> <F3> :<C-u>call ToggleErrors()<CR>
+" 
+let g:syntastic_java_checkers=['']
 
diff --git a/vim/vimfiles/bundle/plantuml/README.md b/vim/vimfiles/bundle/plantuml/README.md
new file mode 100644 (file)
index 0000000..759da57
--- /dev/null
@@ -0,0 +1,16 @@
+# Vim PlantUML Syntax/Plugin/FTDetect
+
+This is a vim syntax file for [PlantUML](http://plantuml.sourceforge.net).
+
+The `filetype` will be set to `plantuml` for *.pu, *.uml or *.plantuml files or if the
+first line of a file contains `@startuml`.
+
+Additionally the `makeprg` is set to `plantuml` assuming you have this
+executable in your path.  This file could contain something like
+
+````sh
+#!/bin/bash
+java -jar $HOME/lib/java/plantuml.jar -tsvg $@
+````
+
+You can change the name of this file by setting `g:plantuml_executable_script`
diff --git a/vim/vimfiles/bundle/plantuml/ftdetect/plantuml.vim b/vim/vimfiles/bundle/plantuml/ftdetect/plantuml.vim
new file mode 100644 (file)
index 0000000..e12d3a7
--- /dev/null
@@ -0,0 +1,12 @@
+" Vim ftdetect file
+" Language:     PlantUML
+" Maintainer:   Aaron C. Meadows < language name at shadowguarddev dot com>
+" Last Change:  19-Jun-2012
+" Version:      0.1
+
+if did_filetype()
+         finish
+endif
+
+autocmd BufRead,BufNewFile * :if getline(1) =~ '^.*startuml.*$'|  setfiletype plantuml | endif
+autocmd BufRead,BufNewFile *.pu,*.uml,*.plantuml set filetype=plantuml
diff --git a/vim/vimfiles/bundle/plantuml/ftplugin/plantuml.vim b/vim/vimfiles/bundle/plantuml/ftplugin/plantuml.vim
new file mode 100644 (file)
index 0000000..e9e2602
--- /dev/null
@@ -0,0 +1,18 @@
+" Vim plugin file
+" Language:     PlantUML
+" Maintainer:   Aaron C. Meadows < language name at shadowguarddev dot com>
+" Last Change:  19-Jun-2012
+" Version:      0.1
+
+if exists("g:loaded_plantuml_plugin")
+    finish
+endif
+let g:loaded_plantuml_plugin = 1
+
+if !exists("g:plantuml_executable_script")
+       let g:plantuml_executable_script="plantuml"
+endif
+
+autocmd Filetype plantuml let &l:makeprg=g:plantuml_executable_script . " " .  fnameescape(expand("%"))
+
+setlocal comments=s1:/',mb:',ex:'/,:' commentstring=/'%s'/ formatoptions-=t formatoptions+=croql
diff --git a/vim/vimfiles/bundle/plantuml/syntax/plantuml.vim b/vim/vimfiles/bundle/plantuml/syntax/plantuml.vim
new file mode 100644 (file)
index 0000000..aa26df5
--- /dev/null
@@ -0,0 +1,169 @@
+" Vim syntax file
+" Language:     PlantUML
+" Maintainer:   Anders Thøgersen <first name at bladre dot dk>
+" Last Change:  03-Apr-2011
+" Version:      0.2
+" TODO:         There are some bugs, add << >>
+"
+if exists("b:current_syntax")
+    finish
+endif
+
+if version < 600
+  syntax clear
+endif
+
+let s:cpo_orig=&cpo
+set cpo&vim
+
+let b:current_syntax = "plantuml"
+
+syntax sync minlines=100
+
+syntax match plantumlPreProc /\%(^@startuml\|^@enduml\)\|!\%(include\|ifdef\|define\|endif\)\s*.*/ contains=plantumlDir
+syntax region plantumlDir start=/\s\+/ms=s+1 end=/$/ contained
+
+syntax keyword plantumlTypeKeyword namespace component package interface class interface enum object participant activity skinparam abstract
+syntax keyword plantumlKeyword actor boundary control entity database partition title activate as deactivate note left right top bottom of end
+syntax keyword plantumlKeyword if then else endif
+
+syntax keyword plantumlCommentTODO XXX TODO FIXME NOTE contained
+syntax match plantumlColor /#[0-9A-Fa-f]\{6\}\>/
+
+" Arrows - Differentiate between horizontal and vertical arrows
+syntax match plantumlHorizontalArrow /\%([-\.]\%(|>\|>\|\*\|o\>\|\\\\\|\\\|\/\/\|\/\|\.\|-\)\|\%(<|\|<\|\*\|\<o\|\\\\\|\\\|\/\/\|\/\)[\.-]\)\%(\[[^\]]*\]\)\?/ contains=plantumlLabel
+syntax match plantumlDirectedOrVerticalArrowLR /[-\.]\%(le\?f\?t\?\|ri\?g\?h\?t\?\|up\?\|\do\?w\?n\?\)\?[-\.]\%(|>\|>>\|>\|\*\|o\>\|\\\\\|\\\|\/\/\|\/\|\.\|-\)\%(\[[^\]]*\]\)\?/ contains=plantumlLabel
+syntax match plantumlDirectedOrVerticalArrowRL /\%(<|\|<<\|<\|\*\|\<o\|\\\\\|\\\|\/\/\|\/\)[-\.]\%(le\?f\?t\?\|ri\?g\?h\?t\?\|up\?\|\do\?w\?n\?\)\?[-\.]\%(\[[^\]]*\]\)\?/ contains=plantumlLabel
+syntax region plantumlLabel start=/\[/ms=s+1 end=/\]/me=s-1 contained contains=plantumlText
+syntax match plantumlText /\%([0-9A-Za-zÀ-ÿ]\|\s\|[\.,;_-]\)\+/ contained
+
+" Class
+syntax region plantumlClass start=/{/ end=/\s*}/ contains=plantumlClassArrows,
+\                                                         plantumlKeyword,
+\                                                         @plantumlClassOp
+
+syntax match plantumlClassPublic      /+\w\+/ contained
+syntax match plantumlClassPrivate     /-\w\+/ contained 
+syntax match plantumlClassProtected   /#\w\+/ contained 
+syntax match plantumlClassPackPrivate /\~\w\+/ contained
+
+syntax cluster plantumlClassOp contains=plantumlClassPublic,
+\                                       plantumlClassPrivate,
+\                                       plantumlClassProtected,
+\                                       plantumlClassProtected,
+\                                       plantumlClassPackPrivate
+
+" Strings
+syntax match plantumlSpecialString /\\n/ contained
+syntax region plantumlString start=/"/ skip=/\\\\\|\\"/ end=/"/ contains=plantumlSpecialString
+syntax region plantumlString start=/'/ skip=/\\\\\|\\'/ end=/'/ contains=plantumlSpecialString
+syntax match plantumlComment /'[^']*$/ contains=plantumlCommentTODO
+syntax region plantumlMultilineComment start=/\/'/ end=/'\// contains=plantumlCommentTODO
+
+" Labels with a colon
+syntax match plantumlColonLine /:[^:]\+$/ contains=plantumlText
+
+" Activity diagram
+syntax match plantumlActivityThing /([^)]*)/
+syntax match plantumlActivitySynch /===[^=]\+===/
+
+" Skinparam keywords
+syntax keyword plantumlSkinparamKeyword activityArrowColor activityArrowFontColor activityArrowFontName
+syntax keyword plantumlSkinparamKeyword activityArrowFontSize activityArrowFontStyle activityBackgroundColor
+syntax keyword plantumlSkinparamKeyword activityBarColor activityBorderColor activityEndColor activityFontColor
+syntax keyword plantumlSkinparamKeyword activityFontName activityFontSize activityFontStyle activityStartColor
+syntax keyword plantumlSkinparamKeyword backgroundColor circledCharacterFontColor circledCharacterFontName
+syntax keyword plantumlSkinparamKeyword circledCharacterFontSize circledCharacterFontStyle circledCharacterRadius
+syntax keyword plantumlSkinparamKeyword classArrowColor classArrowFontColor classArrowFontName classArrowFontSize
+syntax keyword plantumlSkinparamKeyword classArrowFontStyle classAttributeFontColor classAttributeFontName
+syntax keyword plantumlSkinparamKeyword classAttributeFontSize classAttributeFontStyle classAttributeIconSize
+syntax keyword plantumlSkinparamKeyword classBackgroundColor classBorderColor classFontColor classFontName
+syntax keyword plantumlSkinparamKeyword classFontSize classFontStyle classStereotypeFontColor classStereotypeFontName
+syntax keyword plantumlSkinparamKeyword classStereotypeFontSize classStereotypeFontStyle componentArrowColor
+syntax keyword plantumlSkinparamKeyword componentArrowFontColor componentArrowFontName componentArrowFontSize
+syntax keyword plantumlSkinparamKeyword componentArrowFontStyle componentBackgroundColor componentBorderColor
+syntax keyword plantumlSkinparamKeyword componentFontColor componentFontName componentFontSize componentFontStyle
+syntax keyword plantumlSkinparamKeyword componentInterfaceBackgroundColor componentInterfaceBorderColor
+syntax keyword plantumlSkinparamKeyword componentStereotypeFontColor componentStereotypeFontName
+syntax keyword plantumlSkinparamKeyword componentStereotypeFontSize componentStereotypeFontStyle footerFontColor
+syntax keyword plantumlSkinparamKeyword footerFontName footerFontSize footerFontStyle headerFontColor headerFontName
+syntax keyword plantumlSkinparamKeyword headerFontSize headerFontStyle noteBackgroundColor noteBorderColor
+syntax keyword plantumlSkinparamKeyword noteFontColor noteFontName noteFontSize noteFontStyle packageBackgroundColor
+syntax keyword plantumlSkinparamKeyword packageBorderColor packageFontColor packageFontName packageFontSize
+syntax keyword plantumlSkinparamKeyword packageFontStyle sequenceActorBackgroundColor sequenceActorBorderColor
+syntax keyword plantumlSkinparamKeyword sequenceActorFontColor sequenceActorFontName sequenceActorFontSize
+syntax keyword plantumlSkinparamKeyword sequenceActorFontStyle sequenceArrowColor sequenceArrowFontColor
+syntax keyword plantumlSkinparamKeyword sequenceArrowFontName sequenceArrowFontSize sequenceArrowFontStyle
+syntax keyword plantumlSkinparamKeyword sequenceDividerBackgroundColor sequenceDividerFontColor sequenceDividerFontName
+syntax keyword plantumlSkinparamKeyword sequenceDividerFontSize sequenceDividerFontStyle sequenceGroupBackgroundColor
+syntax keyword plantumlSkinparamKeyword sequenceGroupingFontColor sequenceGroupingFontName sequenceGroupingFontSize
+syntax keyword plantumlSkinparamKeyword sequenceGroupingFontStyle sequenceGroupingHeaderFontColor
+syntax keyword plantumlSkinparamKeyword sequenceGroupingHeaderFontName sequenceGroupingHeaderFontSize
+syntax keyword plantumlSkinparamKeyword sequenceGroupingHeaderFontStyle sequenceLifeLineBackgroundColor
+syntax keyword plantumlSkinparamKeyword sequenceLifeLineBorderColor sequenceParticipantBackgroundColor
+syntax keyword plantumlSkinparamKeyword sequenceParticipantBorderColor sequenceParticipantFontColor
+syntax keyword plantumlSkinparamKeyword sequenceParticipantFontName sequenceParticipantFontSize
+syntax keyword plantumlSkinparamKeyword sequenceParticipantFontStyle sequenceTitleFontColor sequenceTitleFontName
+syntax keyword plantumlSkinparamKeyword sequenceTitleFontSize sequenceTitleFontStyle stateArrowColor
+syntax keyword plantumlSkinparamKeyword stateArrowFontColor stateArrowFontName stateArrowFontSize stateArrowFontStyle
+syntax keyword plantumlSkinparamKeyword stateAttributeFontColor stateAttributeFontName stateAttributeFontSize
+syntax keyword plantumlSkinparamKeyword stateAttributeFontStyle stateBackgroundColor stateBorderColor stateEndColor
+syntax keyword plantumlSkinparamKeyword stateFontColor stateFontName stateFontSize stateFontStyle stateStartColor
+syntax keyword plantumlSkinparamKeyword stereotypeABackgroundColor stereotypeCBackgroundColor
+syntax keyword plantumlSkinparamKeyword stereotypeEBackgroundColor stereotypeIBackgroundColor titleFontColor
+syntax keyword plantumlSkinparamKeyword titleFontName titleFontSize titleFontStyle usecaseActorBackgroundColor
+syntax keyword plantumlSkinparamKeyword usecaseActorBorderColor usecaseActorFontColor usecaseActorFontName
+syntax keyword plantumlSkinparamKeyword usecaseActorFontSize usecaseActorFontStyle usecaseActorStereotypeFontColor
+syntax keyword plantumlSkinparamKeyword usecaseActorStereotypeFontName usecaseActorStereotypeFontSize
+syntax keyword plantumlSkinparamKeyword usecaseActorStereotypeFontStyle usecaseArrowColor usecaseArrowFontColor
+syntax keyword plantumlSkinparamKeyword usecaseArrowFontName usecaseArrowFontSize usecaseArrowFontStyle
+syntax keyword plantumlSkinparamKeyword usecaseBackgroundColor usecaseBorderColor usecaseFontColor usecaseFontName
+syntax keyword plantumlSkinparamKeyword usecaseFontSize usecaseFontStyle usecaseStereotypeFontColor
+syntax keyword plantumlSkinparamKeyword usecaseStereotypeFontName usecaseStereotypeFontSize usecaseStereotypeFontStyle
+
+syntax keyword plantumlSkinparamKeyword ActorBackgroundColor ActorBorderColor ActorFontColor ActorFontName
+syntax keyword plantumlSkinparamKeyword ActorFontSize ActorFontStyle ActorStereotypeFontColor ActorStereotypeFontName
+syntax keyword plantumlSkinparamKeyword ActorStereotypeFontSize ActorStereotypeFontStyle ArrowColor ArrowFontColor
+syntax keyword plantumlSkinparamKeyword ArrowFontName ArrowFontSize ArrowFontStyle AttributeFontColor AttributeFontName
+syntax keyword plantumlSkinparamKeyword AttributeFontSize AttributeFontStyle AttributeIconSize BackgroundColor BarColor
+syntax keyword plantumlSkinparamKeyword BorderColor CharacterFontColor CharacterFontName CharacterFontSize
+syntax keyword plantumlSkinparamKeyword CharacterFontStyle CharacterRadius Color DividerBackgroundColor
+syntax keyword plantumlSkinparamKeyword DividerFontColor DividerFontName DividerFontSize DividerFontStyle EndColor
+syntax keyword plantumlSkinparamKeyword FontColor FontName FontSize FontStyle GroupBackgroundColor GroupingFontColor
+syntax keyword plantumlSkinparamKeyword GroupingFontName GroupingFontSize GroupingFontStyle GroupingHeaderFontColor
+syntax keyword plantumlSkinparamKeyword GroupingHeaderFontName GroupingHeaderFontSize GroupingHeaderFontStyle
+syntax keyword plantumlSkinparamKeyword InterfaceBackgroundColor InterfaceBorderColor LifeLineBackgroundColor
+syntax keyword plantumlSkinparamKeyword LifeLineBorderColor ParticipantBackgroundColor ParticipantBorderColor
+syntax keyword plantumlSkinparamKeyword ParticipantFontColor ParticipantFontName ParticipantFontSize
+syntax keyword plantumlSkinparamKeyword ParticipantFontStyle StartColor stateArrowColor stereotypeABackgroundColor
+syntax keyword plantumlSkinparamKeyword stereotypeCBackgroundColor stereotypeEBackgroundColor StereotypeFontColor
+syntax keyword plantumlSkinparamKeyword StereotypeFontName StereotypeFontSize StereotypeFontStyle
+syntax keyword plantumlSkinparamKeyword stereotypeIBackgroundColor TitleFontColor TitleFontName TitleFontSize TitleFontStyle
+
+" Highlight
+highlight default link plantumlCommentTODO Todo
+highlight default link plantumlKeyword Keyword
+highlight default link plantumlTypeKeyword Type
+highlight default link plantumlPreProc PreProc
+highlight default link plantumlDir Constant
+highlight default link plantumlColor Constant
+highlight default link plantumlHorizontalArrow Identifier
+highlight default link plantumlDirectedOrVerticalArrowLR Special
+highlight default link plantumlDirectedOrVerticalArrowRL Special
+highlight default link plantumlLabel Special
+highlight default link plantumlText Label
+highlight default link plantumlClassPublic Structure
+highlight default link plantumlClassPrivate Macro
+highlight default link plantumlClassProtected Statement
+highlight default link plantumlClassPackPrivate Function
+highlight default link plantumlSpecialString Special
+highlight default link plantumlString String
+highlight default link plantumlComment Comment
+highlight default link plantumlMultilineComment Comment
+highlight default link plantumlColonLine Comment
+highlight default link plantumlActivityThing Type
+highlight default link plantumlActivitySynch Type
+highlight default link plantumlSkinparamKeyword Identifier
+
+let &cpo=s:cpo_orig
+unlet s:cpo_orig
diff --git a/vim/vimfiles/bundle/syntastic/.gitignore b/vim/vimfiles/bundle/syntastic/.gitignore
new file mode 100644 (file)
index 0000000..cc07c93
--- /dev/null
@@ -0,0 +1,4 @@
+*~
+*.swp
+tags
+.DS_Store
diff --git a/vim/vimfiles/bundle/syntastic/CONTRIBUTING.md b/vim/vimfiles/bundle/syntastic/CONTRIBUTING.md
new file mode 100644 (file)
index 0000000..1949415
--- /dev/null
@@ -0,0 +1,105 @@
+# CONTRIBUTING
+- - -
+1\. [Bug reports / GitHub issues](#bugreps)  
+2\. [Submitting a patch](#patches)  
+3\. [General style notes](#generalstyle)  
+4\. [Syntax checker notes](#checkerstyle)  
+- - -
+
+<a name="bugreps"></a>
+
+## 1. Bug reports / GitHub issues
+
+Please note that the preferred channel for posting bug reports is the
+[issue tracker at GitHub][bug_tracker]. Reports posted elsewhere are less likely
+to be seen by the core team.
+
+When reporting a bug make sure you search the existing GitHub issues
+for the same/similar issues. If you find one, feel free to add a `+1`
+comment with any additional information that may help us solve the
+issue.
+
+When creating a new issue be sure to state the following:
+
+* steps to reproduce the bug;
+* the version of Vim you are using (run `:ver` to find out);
+* the version of syntastic you are using (see `:SyntasticInfo`).
+
+For syntax checker bugs also state the version of the checker executable
+that you are using. Adding debugging information is typically useful
+too:
+
+* open a file handled by your checker;
+* set `g:syntastic_debug` to 1 or 3;
+* run the checker;
+* copy the output of `:mes`.
+
+<a name="patches"></a>
+
+## 2. Submitting a patch
+
+Before you consider adding features to syntastic, _please_ spend a few minutes
+(re-)reading the latest version of the [manual][manual]. Syntastic is changing
+rapidly at times, and it's possible that some features you want to add exist
+already.
+
+To submit a patch:
+
+* fork the [repo][github] on GitHub;
+* make a [topic branch][branches] and start hacking;
+* submit a pull request based off your topic branch.
+
+Small, focused patches are preferred.
+
+Large changes to the code should be discussed with the core team first.
+Create an issue and explain your plan and see what we say.
+
+Also, make sure to update the manual whenever applicable. Nobody can use
+features that aren't documented.
+
+<a name="generalstyle"></a>
+
+## 3. General style notes
+
+Follow the coding conventions/styles used in the syntastic core:
+
+* use 4 space indents;
+* don't use abbreviated keywords - e.g. use `endfunction`, not `endfun`
+(there's always room for more fun!);
+* don't use `l:` prefixes for variables unless actually required (i.e.
+almost never);
+* code for maintainability; we would rather a function be a couple of
+lines longer and have (for example) some [explaining variables][variables] to
+aid readability.
+
+<a name="checkerstyle"></a>
+
+## 4. Syntax checker notes
+
+Make sure to read the [guide][guide] if you plan to add new syntax checkers.
+
+Use the existing checkers as templates, rather than writing everything
+from scratch.
+
+The preferred style for error format strings is one "clause" per line.
+E.g. (from the `coffee` checker):
+
+```vim
+let errorformat =
+    \ '%E%f:%l:%c: %trror: %m,' .
+    \ 'Syntax%trror: In %f\, %m on line %l,' .
+    \ '%EError: In %f\, Parse error on line %l: %m,' .
+    \ '%EError: In %f\, %m on line %l,' .
+    \ '%W%f(%l): lint warning: %m,' .
+    \ '%W%f(%l): warning: %m,' .
+    \ '%E%f(%l): SyntaxError: %m,' .
+    \ '%-Z%p^,' .
+    \ '%-G%.%#'
+```
+
+[bug_tracker]:      https://github.com/scrooloose/syntastic/issues
+[manual]:           https://github.com/scrooloose/syntastic/blob/master/doc/syntastic.txt
+[github]:           https://github.com/scrooloose/syntastic
+[branches]:         https://github.com/dchelimsky/rspec/wiki/Topic-Branches#using-topic-branches-when-contributing-patches
+[variables]:        http://www.refactoring.com/catalog/extractVariable.html
+[guide]:            https://github.com/scrooloose/syntastic/wiki/Syntax-Checker-Guide
diff --git a/vim/vimfiles/bundle/syntastic/LICENCE b/vim/vimfiles/bundle/syntastic/LICENCE
new file mode 100644 (file)
index 0000000..8b1a9d8
--- /dev/null
@@ -0,0 +1,13 @@
+           DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE
+                   Version 2, December 2004
+
+Copyright (C) 2004 Sam Hocevar <sam@hocevar.net>
+
+Everyone is permitted to copy and distribute verbatim or modified
+copies of this license document, and changing it is allowed as long
+as the name is changed.
+
+           DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE
+  TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+
+ 0. You just DO WHAT THE FUCK YOU WANT TO.
diff --git a/vim/vimfiles/bundle/syntastic/README.markdown b/vim/vimfiles/bundle/syntastic/README.markdown
new file mode 100644 (file)
index 0000000..19e986e
--- /dev/null
@@ -0,0 +1,536 @@
+                   ,
+                  / \,,_  .'|
+               ,{{| /}}}}/_.'            _____________________________________________
+              }}}}` '{{'  '.            /                                             \
+            {{{{{    _   ;, \          /            Ladies and Gentlemen,              \
+         ,}}}}}}    /o`\  ` ;)        |                                                |
+        {{{{{{   /           (        |                 this is ...                    |
+        }}}}}}   |            \       |                                                |
+       {{{{{{{{   \            \      |                                                |
+       }}}}}}}}}   '.__      _  |     |    _____             __             __  _      |
+       {{{{{{{{       /`._  (_\ /     |   / ___/__  ______  / /_____ ______/ /_(_)____ |
+        }}}}}}'      |    //___/   --=:   \__ \/ / / / __ \/ __/ __ `/ ___/ __/ / ___/ |
+    jgs `{{{{`       |     '--'       |  ___/ / /_/ / / / / /_/ /_/ (__  ) /_/ / /__   |
+         }}}`                         | /____/\__, /_/ /_/\__/\__,_/____/\__/_/\___/   |
+                                      |      /____/                                    |
+                                      |                                               /
+                                       \_____________________________________________/
+
+
+- - -
+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. [How can I check scripts written for different versions of Python?](#faqpython)  
+4.3. [How can I check scripts written for different versions of Ruby?](#faqruby)  
+4.4. [Are there any local checkers for HTML5 that I can use with syntastic?](#faqhtml5)  
+4.5. [The `perl` checker has stopped working...](#faqperl)  
+4.6. [What happened to the `rustc` checker?](#faqrust)  
+4.7. [What happened to the `tsc` checker?](#faqtsc)  
+4.8. [What happened to the `xcrun` checker?](#faqxcrun)  
+4.9. [I run a checker and the location list is not updated...](#faqloclist)  
+4.9. [I run`:lopen` or `:lwindow` and the error window is empty...](#faqloclist)  
+4.10. [How can I pass additional arguments to a checker?](#faqargs)  
+4.11. [Syntastic supports several checkers for my filetype - how do I tell which one(s) to use?](#faqcheckers)  
+4.12. [What is the difference between syntax checkers and style checkers?](#faqstyle)  
+4.13. [I have enabled multiple checkers for the current filetype. How can I display all errors from all checkers together?](#faqaggregate)  
+4.14. [How can I jump between the different errors without using the location list at the bottom of the window?](#faqlnext)  
+4.15. [My favourite checker needs to load a configuration file from the project's root rather than the current directory...](#faqconfig)  
+4.16. [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][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.
+
+At the time of this writing, syntastic has checking plugins for ACPI
+Source Language, ActionScript, Ada, Ansible configurations, API Blueprint,
+AppleScript, AsciiDoc, Assembly languages, BEMHTML, Bro, Bourne shell, C,
+C++, C#, Cabal, Chef, CoffeeScript, Coco, Coq, CSS, Cucumber, CUDA, D, Dart,
+DocBook, Dockerfile, 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, Mercury, NASM, Nix, Objective-C, Objective-C++, OCaml, Perl, Perl
+POD, PHP, gettext Portable Object, OS X and iOS property lists, Pug (formerly
+Jade), Puppet, Python, QML, R, Racket, RDF TriG, RDF Turtle, Relax NG,
+reStructuredText, RPM spec, Ruby, SASS/SCSS, Scala, Slim, SML, Sphinx, SQL,
+Stylus, Tcl, TeX, Texinfo, Twig, TypeScript, Vala, Verilog, VHDL, VimL, xHtml,
+XML, XSLT, XQuery, YACC, YAML, YANG data models, z80, Zope page templates, and
+Zsh. See the [manual][checkers] for details about the corresponding supported
+checkers (`:help syntastic-checkers` in Vim).
+
+A number of third-party Vim plugins also provide checkers for syntastic, for
+example: [merlin][merlin], [omnisharp-vim][omnisharp], [rust.vim][rust],
+[syntastic-extras][myint], [syntastic-more][roktas], [tsuquyomi][tsuquyomi],
+[vim-crystal][crystal], [vim-eastwood][eastwood], and [vim-swift][swift].
+
+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
+enabled.
+
+![Screenshot 1][screenshot]
+
+1. Errors are loaded into the location list for the corresponding window.
+2. When the cursor is on a line containing an error, the error message is echoed in the command window.
+3. Signs are placed beside lines with errors - note that warnings are displayed in a different color.
+4. There is a configurable statusline flag you can include in your statusline config.
+5. Hover the mouse over a line containing an error and the error message is displayed as a balloon.
+6. (not shown) Highlighting errors with syntax highlighting. Erroneous parts of lines can be highlighted.
+
+<a name="installation"></a>
+
+## 2\. Installation
+
+<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][vim] 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][neobundle], [Pathogen][pathogen], [Vim-Addon-Manager][vam], [Vim-Plug][plug], or
+[Vundle][vundle]. Instructions for installing syntastic with [Pathogen][pathogen] are
+included below for completeness.
+
+Starting with Vim version 7.4.1486 you can also load syntastic using the
+standard mechanism of packages, without the help of third-party plugin managers
+(see `:help packages` in Vim for details). Beware however that, while support
+for packages has been added in Vim 7.4.1384, the functionality needed by
+syntastic is present only in versions 7.4.1486 and later.
+
+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
+[manual][checkers] (`:help syntastic-checkers` in Vim) for a list of supported
+checkers.
+
+<a name="installpathogen"></a>
+
+### 2.2\. Installing syntastic with Pathogen
+
+If you already have [Pathogen][pathogen] working then skip [Step 1](#step1) and go to
+[Step 2](#step2).
+
+<a name="step1"></a>
+
+#### 2.2.1\. Step 1: Install pathogen.vim
+
+First I'll show you how to install Tim Pope's [Pathogen][pathogen] 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
+mkdir -p ~/.vim/autoload ~/.vim/bundle && \
+curl -LSso ~/.vim/autoload/pathogen.vim https://tpo.pe/pathogen.vim
+```
+Next you *need* to add this to your `~/.vimrc`:
+```vim
+execute pathogen#infect()
+```
+
+<a name="step2"></a>
+
+#### 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:
+```sh
+cd ~/.vim/bundle && \
+git clone --depth=1 https://github.com/scrooloose/syntastic.git
+```
+Quit vim and start it back up to reload it, then type:
+```vim
+:Helptags
+```
+If you get an error when you do this, then you probably didn't install
+[Pathogen][pathogen] 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 `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 numerous 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>
+
+## 4\. FAQ
+
+<a name="faqinfo"></a>
+
+__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
+are installed. For example: by default, python requires either `flake8` or
+`pylint` to be installed and in your `$PATH`. Read the [manual][checkers]
+(`:help syntastic-checkers` in Vim) to find out what executables are
+supported. Note that aliases do not work; the actual executables must be
+available in your `$PATH`. Symbolic links are okay though.  You can see
+syntastic's idea of available checkers by running `:SyntasticInfo`.
+
+A second probable reason is that none of the available checkers are
+enabled. Syntastic comes preconfigured with a default list of enabled checkers
+per filetype, but this list is kept short in order to prevent slowing down Vim
+or trying to run conflicting checks. The command `:SyntasticInfo` will show you
+which checkers are enabled. You can tell syntastic which checkers (among the
+available ones) you want to run by setting `g:syntastic_<filetype>_checkers` in
+your `vimrc` (see [below](#faqcheckers)).
+
+A third possible reason is that the `$PATH` seen by syntastic might not be same
+as the `$PATH` in your login shell. Syntastic runs checkers using the shell
+pointed to by Vim's `shell` (or by `g:syntastic_shell`, if set), and that's the
+shell you need to configure to set the proper `$PATH` and environment variables
+for your checkers. You can see syntastic's idea of `$PATH` by running
+```vim
+:echo syntastic#util#system('echo "$PATH"')
+```
+on UNIX and Mac OS-X systems, or
+```vim
+:echo syntastic#util#system('echo %PATH%')
+```
+on Windows.
+
+Finally, another reason it could fail is that either the command line options
+or the 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 post an [issue][bug_tracker] - or better yet, create a pull request.
+
+<a name="faqpython"></a>
+
+__4.2. Q. How can I check scripts written for different versions of Python?__
+
+A. Install a Python version manager such as [virtualenv][virtualenv]
+or [pyenv][pyenv], activate the environment for the relevant version
+of Python, and install in it the checkers you want to use.  Set
+`g:syntastic_python_checkers` accordingly in your `vimrc`, and run [Vim][vim]
+from the virtual environment.
+
+If you're starting Vim from a desktop manager rather than from a terminal you
+might need to write wrapper scripts around your checkers, to activate the
+virtual environment before running the actual checks.  Then you'll need to
+point the relevant `g:syntastic_python_<checker>_exec` variables to the wrapper
+scripts.
+
+<a name="faqruby"></a>
+
+__4.3. Q. How can I check scripts written for different versions of Ruby?__
+
+A. Install a Ruby version manager such as [rvm][rvm] or [rbenv][rbenv],
+activate the environment for the relevant version of Ruby, and install in it
+the checkers you want to use.  Set `g:syntastic_ruby_checkers` accordingly in
+your `vimrc`, and run [Vim][vim] from the virtual environment.
+
+If you're starting Vim from a desktop manager rather than from a terminal you
+might need to write wrapper scripts around your checkers, to activate the
+virtual environment before running the actual checks.  Then you'll need to
+point the relevant `g:syntastic_ruby_<checker>_exec` variables to the wrapper
+scripts.
+
+<a name="faqhtml5"></a>
+
+__4.4. Q. Are there any local checkers for HTML5 that I can use with syntastic?__
+
+[HTML Tidy][tidy_old] has a fork named [HTML Tidy for HTML5][tidy]. 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:
+```vim
+let g:syntastic_html_tidy_exec = 'tidy5'
+```
+Alternatively, you can install [vnu.jar][vnu_jar] from the [validator.nu][vnu]
+project and run it as a [HTTP server][vnu_server]:
+```sh
+$ java -Xss512k -cp /path/to/vnu.jar nu.validator.servlet.Main 8888
+```
+Then you can configure syntastic to use it:
+```vim
+let g:syntastic_html_validator_api = 'http://localhost:8888/'
+```
+
+<a name="faqperl"></a>
+
+__4.5. 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`
+statements in your file (cf. [perlrun][perlrun]). This is probably fine if you
+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`:
+```vim
+let g:syntastic_enable_perl_checker = 1
+```
+
+<a name="faqrust"></a>
+
+__4.6. Q. What happened to the `rustc` checker?__
+
+A. It is now part of the [rust.vim][rust] plugin. If you install this plugin the
+checker should be picked up automatically by syntastic.
+
+<a name="faqtsc"></a>
+
+__4.7. Q. What happened to the `tsc` checker?__
+
+A. It didn't meet people's expectations and it has been removed. Please
+consider using the external checker [tsuquyomi][tsuquyomi] instead. If you
+install this plugin the checker should be picked up automatically by syntastic.
+
+<a name="faqxcrun"></a>
+
+__4.8. Q. What happened to the `xcrun` checker?__
+
+A. The `xcrun` checker used to have a security problem and it has been removed.
+A better checker for __Swift__ is part of the [vim-swift][swift] plugin. If you
+install this plugin the checker should be picked up automatically by syntastic.
+
+<a name="faqloclist"></a>
+
+__4.9. Q. I run a checker and the location list is not updated...__  
+__4.9. 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`:
+```vim
+let g:syntastic_always_populate_loc_list = 1
+```
+
+<a name="faqargs"></a>
+
+__4.10. 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`:
+```vim
+let g:syntastic_ruby_mri_args = "--my --args --here"
+```
+
+See `:help syntastic-checker-options` for more information.
+
+<a name="faqcheckers"></a>
+
+__4.11. 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`:
+```vim
+let g:syntastic_<filetype>_checkers = ['<checker-name>']
+```
+
+To see the list of supported checkers for your filetype read the
+[manual][checkers] (`:help syntastic-checkers` in Vim).
+
+e.g. Python has the following checkers, among others: `flake8`, `pyflakes`,
+`pylint` and a native `python` checker.
+
+To tell syntastic to use `pylint`, you would use this setting:
+```vim
+let g:syntastic_python_checkers = ['pylint']
+```
+
+Checkers can be chained together like this:
+```vim
+let g:syntastic_php_checkers = ['php', 'phpcs', 'phpmd']
+```
+
+This is telling syntastic to run the `php` checker first, and if no errors are
+found, run `phpcs`, and then `phpmd`.
+
+You can also run checkers explicitly by calling `:SyntasticCheck <checker>`.
+
+e.g. to run `phpcs` and `phpmd`:
+```vim
+:SyntasticCheck phpcs 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
+filetype of the current file is `php`).
+
+<a name="faqstyle"></a>
+
+__4.12. 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>
+
+__4.13. Q. I have enabled multiple checkers for the current filetype. How can I
+display all errors from all checkers together?__
+
+A. Set `g:syntastic_aggregate_errors` to 1 in your `vimrc`:
+```vim
+let g:syntastic_aggregate_errors = 1
+```
+
+See `:help syntastic-aggregating-errors` for more details.
+
+<a name="faqlnext"></a>
+
+__4.14. 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 :lprevious`.
+
+If you use these commands a lot then you may want to add shortcut mappings to
+your `vimrc`, or install something like [unimpaired][unimpaired], which provides such
+mappings (among other things).
+
+<a name="faqconfig"></a>
+
+__4.15. My favourite checker needs to load a configuration file from the
+project's root rather than the current directory...__
+
+A. You can set up an `autocmd` to search for the configuration file in the
+current directory and upwards, and add it to the checker's options when found.
+For example for `jscs`:
+
+```vim
+function! FindConfig(prefix, what, where)
+    let cfg = findfile(a:what, escape(a:where, ' ') . ';')
+    return cfg !=# '' ? ' ' . a:prefix . ' ' . cfg : ''
+endfunction
+
+autocmd FileType javascript let b:syntastic_javascript_jscs_args =
+    \ get(g:, 'syntastic_javascript_jscs_args', '') .
+    \ FindConfig('-c', '.jscsrc', expand('<amatch>:p:h', 1))
+```
+<a name="faqbdelete"></a>
+
+__4.16. 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
+work around it:
+
+```vim
+nnoremap <silent> <C-d> :lclose<CR>:bdelete<CR>
+cabbrev <silent> bd <C-r>=(getcmdtype()==#':' && getcmdpos()==1 ? 'lclose\|bdelete' : 'bd')<CR>
+```
+
+<a name="otherresources"></a>
+
+## 5\. Resources
+
+The preferred place for posting suggestions, reporting bugs, and general
+discussions related to syntastic is the [issue tracker at GitHub][bug_tracker].
+A guide for writing syntax checkers can be found in the [wiki][guide].
+There are also a dedicated [google group][google_group], and a
+[syntastic tag at StackOverflow][stack_overflow].
+
+Syntastic aims to provide a common interface to syntax checkers for as many
+languages as possible. For particular languages, there are, of course, other
+plugins that provide more functionality than syntastic. You might want to take
+a look at [ghcmod-vim][ghcmod], [jedi-vim][jedi], [python-mode][python_mode], [vim-go][vimgo], or
+[YouCompleteMe][ycm].
+
+[screenshot]:       https://github.com/scrooloose/syntastic/raw/master/_assets/screenshot_1.png
+
+[bug_tracker]:      https://github.com/scrooloose/syntastic/issues
+[checkers]:         https://github.com/scrooloose/syntastic/blob/master/doc/syntastic-checkers.txt
+[crystal]:          https://github.com/rhysd/vim-crystal
+[eastwood]:         https://github.com/venantius/vim-eastwood
+[ghcmod]:           https://github.com/eagletmt/ghcmod-vim
+[google_group]:     https://groups.google.com/group/vim-syntastic
+[guide]:            https://github.com/scrooloose/syntastic/wiki/Syntax-Checker-Guide
+[jedi]:             https://github.com/davidhalter/jedi-vim
+[merlin]:           https://github.com/the-lambda-church/merlin
+[myint]:            https://github.com/myint/syntastic-extras
+[neobundle]:        https://github.com/Shougo/neobundle.vim
+[omnisharp]:        https://github.com/OmniSharp/omnisharp-vim
+[pathogen]:         https://github.com/tpope/vim-pathogen
+[perlrun]:          http://perldoc.perl.org/perlrun.html#*-c*
+[plug]:             https://github.com/junegunn/vim-plug/
+[pyenv]:            https://github.com/yyuu/pyenv
+[python_mode]:      https://github.com/klen/python-mode
+[rbenv]:            https://github.com/rbenv/rbenv
+[roktas]:           https://github.com/roktas/syntastic-more
+[rust]:             https://github.com/rust-lang/rust.vim
+[rvm]:              https://rvm.io/
+[stack_overflow]:   http://stackoverflow.com/questions/tagged/syntastic
+[swift]:            https://github.com/kballard/vim-swift
+[tidy]:             http://www.htacg.org/tidy-html5/
+[tidy_old]:         http://tidy.sourceforge.net/
+[tsuquyomi]:        https://github.com/Quramy/tsuquyomi/
+[unimpaired]:       https://github.com/tpope/vim-unimpaired
+[vam]:              https://github.com/MarcWeber/vim-addon-manager
+[vim]:              http://www.vim.org/
+[vimgo]:            https://github.com/fatih/vim-go
+[virtualenv]:       https://virtualenv.pypa.io/en/stable/
+[vnu]:              http://about.validator.nu/
+[vnu_jar]:          https://github.com/validator/validator/releases/latest
+[vnu_server]:       http://validator.github.io/validator/#standalone
+[vundle]:           https://github.com/gmarik/Vundle.vim
+[ycm]:              http://valloric.github.io/YouCompleteMe/
+
+<!--
+vim:tw=79:sw=4:
+-->
diff --git a/vim/vimfiles/bundle/syntastic/_assets/screenshot_1.png b/vim/vimfiles/bundle/syntastic/_assets/screenshot_1.png
new file mode 100644 (file)
index 0000000..c1b69f4
Binary files /dev/null and b/vim/vimfiles/bundle/syntastic/_assets/screenshot_1.png differ
diff --git a/vim/vimfiles/bundle/syntastic/autoload/syntastic/c.vim b/vim/vimfiles/bundle/syntastic/autoload/syntastic/c.vim
new file mode 100644 (file)
index 0000000..e49a29a
--- /dev/null
@@ -0,0 +1,341 @@
+if exists('g:loaded_syntastic_c_autoload') || !exists('g:loaded_syntastic_plugin')
+    finish
+endif
+let g:loaded_syntastic_c_autoload = 1
+
+let s:save_cpo = &cpo
+set cpo&vim
+
+" Public functions {{{1
+
+" convenience function to determine the 'null device' parameter
+" based on the current operating system
+function! syntastic#c#NullOutput() abort " {{{2
+    let known_os = has('unix') || has('mac') || syntastic#util#isRunningWindows()
+    return known_os ? '-o ' . syntastic#util#DevNull() : ''
+endfunction " }}}2
+
+" read additional compiler flags from the given configuration file
+" the file format and its parsing mechanism is inspired by clang_complete
+function! syntastic#c#ReadConfig(file) abort " {{{2
+    call syntastic#log#debug(g:_SYNTASTIC_DEBUG_CHECKERS, 'ReadConfig: looking for', a:file)
+
+    " search upwards from the current file's directory
+    let config = syntastic#util#findFileInParent(a:file, expand('%:p:h', 1))
+    if config ==# ''
+        call syntastic#log#debug(g:_SYNTASTIC_DEBUG_CHECKERS, 'ReadConfig: file not found')
+        return ''
+    endif
+    call syntastic#log#debug(g:_SYNTASTIC_DEBUG_CHECKERS, 'ReadConfig: config file:', config)
+    if !filereadable(config)
+        call syntastic#log#debug(g:_SYNTASTIC_DEBUG_CHECKERS, 'ReadConfig: file unreadable')
+        return ''
+    endif
+
+    " convert filename into absolute path
+    let filepath = fnamemodify(config, ':p:h')
+
+    " try to read config file
+    try
+        let lines = readfile(config)
+    catch /\m^Vim\%((\a\+)\)\=:E48[45]/
+        call syntastic#log#debug(g:_SYNTASTIC_DEBUG_CHECKERS, 'ReadConfig: error reading file')
+        return ''
+    endtry
+
+    " filter out empty lines and comments
+    call filter(lines, 'v:val !~# ''\v^(\s*#|$)''')
+
+    " remove leading and trailing spaces
+    call map(lines, 'substitute(v:val, ''\m^\s\+'', "", "")')
+    call map(lines, 'substitute(v:val, ''\m\s\+$'', "", "")')
+
+    let parameters = []
+    for line in lines
+        let matches = matchstr(line, '\m\C^\s*-I\s*\zs.\+')
+        if matches !=# ''
+            " this one looks like an absolute path
+            if match(matches, '\m^\%(/\|\a:\)') != -1
+                call add(parameters, '-I' . matches)
+            else
+                call add(parameters, '-I' . filepath . syntastic#util#Slash() . matches)
+            endif
+        else
+            call add(parameters, line)
+        endif
+    endfor
+
+    return join(map(parameters, 'syntastic#util#shescape(v:val)'))
+endfunction " }}}2
+
+" GetLocList() for C-like compilers
+function! syntastic#c#GetLocList(filetype, subchecker, options) abort " {{{2
+    try
+        let flags = s:_get_cflags(a:filetype, a:subchecker, a:options)
+    catch /\m\C^Syntastic: skip checks$/
+        return []
+    endtry
+
+    let makeprg = syntastic#util#shexpand(g:syntastic_{a:filetype}_compiler) .
+        \ ' ' . flags . ' ' . syntastic#util#shexpand('%')
+
+    let errorformat = s:_get_checker_var('g', a:filetype, a:subchecker, 'errorformat', a:options['errorformat'])
+
+    let postprocess = s:_get_checker_var('g', a:filetype, a:subchecker, 'remove_include_errors', 0) ?
+        \ ['filterForeignErrors'] : []
+
+    " process makeprg
+    return SyntasticMake({
+        \ 'makeprg': makeprg,
+        \ 'errorformat': errorformat,
+        \ 'postprocess': postprocess })
+endfunction " }}}2
+
+" }}}1
+
+" Private functions {{{1
+
+" initialize c/cpp syntax checker handlers
+function! s:_init() abort " {{{2
+    let s:handlers = []
+    let s:cflags = {}
+
+    call s:_registerHandler('\m\<cairo',       's:_checkPackage', ['cairo', 'cairo'])
+    call s:_registerHandler('\m\<freetype',    's:_checkPackage', ['freetype', 'freetype2', 'freetype'])
+    call s:_registerHandler('\m\<glade',       's:_checkPackage', ['glade', 'libglade-2.0', 'libglade'])
+    call s:_registerHandler('\m\<glib',        's:_checkPackage', ['glib', 'glib-2.0', 'glib'])
+    call s:_registerHandler('\m\<gtk',         's:_checkPackage', ['gtk', 'gtk+-2.0', 'gtk+', 'glib-2.0', 'glib'])
+    call s:_registerHandler('\m\<libsoup',     's:_checkPackage', ['libsoup', 'libsoup-2.4', 'libsoup-2.2'])
+    call s:_registerHandler('\m\<libxml',      's:_checkPackage', ['libxml', 'libxml-2.0', 'libxml'])
+    call s:_registerHandler('\m\<pango',       's:_checkPackage', ['pango', 'pango'])
+    call s:_registerHandler('\m\<SDL',         's:_checkPackage', ['sdl', 'sdl'])
+    call s:_registerHandler('\m\<opengl',      's:_checkPackage', ['opengl', 'gl'])
+    call s:_registerHandler('\m\<webkit',      's:_checkPackage', ['webkit', 'webkit-1.0'])
+
+    call s:_registerHandler('\m\<php\.h\>',    's:_checkPhp',    [])
+    call s:_registerHandler('\m\<Python\.h\>', 's:_checkPython', [])
+    call s:_registerHandler('\m\<ruby',        's:_checkRuby',   [])
+endfunction " }}}2
+
+" register a handler dictionary object
+function! s:_registerHandler(regex, function, args) abort " {{{2
+    let handler = {}
+    let handler['regex'] = a:regex
+    let handler['func'] = function(a:function)
+    let handler['args'] = a:args
+    call add(s:handlers, handler)
+endfunction " }}}2
+
+" try to find library with 'pkg-config'
+" search possible libraries from first to last given
+" argument until one is found
+function! s:_checkPackage(name, ...) abort " {{{2
+    if executable('pkg-config')
+        if !has_key(s:cflags, a:name)
+            for pkg in a:000
+                let pkg_flags = syntastic#util#system('pkg-config --cflags ' . pkg)
+                " since we cannot necessarily trust the pkg-config exit code
+                " we have to check for an error output as well
+                if v:shell_error == 0 && pkg_flags !~? 'not found'
+                    let pkg_flags = ' ' . substitute(pkg_flags, "\n", '', '')
+                    let s:cflags[a:name] = pkg_flags
+                    return pkg_flags
+                endif
+            endfor
+        else
+            return s:cflags[a:name]
+        endif
+    endif
+    return ''
+endfunction " }}}2
+
+" try to find PHP includes with 'php-config'
+function! s:_checkPhp() abort " {{{2
+    if executable('php-config')
+        if !has_key(s:cflags, 'php')
+            let s:cflags['php'] = syntastic#util#system('php-config --includes')
+            let s:cflags['php'] = ' ' . substitute(s:cflags['php'], "\n", '', '')
+        endif
+        return s:cflags['php']
+    endif
+    return ''
+endfunction " }}}2
+
+" try to find the python headers with distutils
+function! s:_checkPython() abort " {{{2
+    if executable('python')
+        if !has_key(s:cflags, 'python')
+            let s:cflags['python'] = syntastic#util#system('python -c ''from distutils import ' .
+                \ 'sysconfig; import sys; sys.stdout.write(sysconfig.get_python_inc())''')
+            let s:cflags['python'] = substitute(s:cflags['python'], "\n", '', '')
+            let s:cflags['python'] = ' -I' . s:cflags['python']
+        endif
+        return s:cflags['python']
+    endif
+    return ''
+endfunction " }}}2
+
+" try to find the ruby headers with 'rbconfig'
+function! s:_checkRuby() abort " {{{2
+    if executable('ruby')
+        if !has_key(s:cflags, 'ruby')
+            let s:cflags['ruby'] = syntastic#util#system('ruby -r rbconfig -e ' .
+                \ '''puts RbConfig::CONFIG["rubyhdrdir"] || RbConfig::CONFIG["archdir"]''')
+            let s:cflags['ruby'] = substitute(s:cflags['ruby'], "\n", '', '')
+            let s:cflags['ruby'] = ' -I' . s:cflags['ruby']
+        endif
+        return s:cflags['ruby']
+    endif
+    return ''
+endfunction " }}}2
+
+" }}}1
+
+" Utilities {{{1
+
+" resolve checker-related user variables
+function! s:_get_checker_var(scope, filetype, subchecker, name, default) abort " {{{2
+    let prefix = a:scope . ':' . 'syntastic_'
+    if exists(prefix . a:filetype . '_' . a:subchecker . '_' . a:name)
+        return {a:scope}:syntastic_{a:filetype}_{a:subchecker}_{a:name}
+    elseif exists(prefix . a:filetype . '_' . a:name)
+        return {a:scope}:syntastic_{a:filetype}_{a:name}
+    else
+        return a:default
+    endif
+endfunction " }}}2
+
+" resolve user CFLAGS
+function! s:_get_cflags(ft, ck, opts) abort " {{{2
+    " determine whether to parse header files as well
+    if has_key(a:opts, 'header_names') && expand('%', 1) =~? a:opts['header_names']
+        if s:_get_checker_var('g', a:ft, a:ck, 'check_header', 0)
+            let flags = get(a:opts, 'header_flags', '') . ' -c ' . syntastic#c#NullOutput()
+        else
+            " checking headers when check_header is unset: bail out
+            throw 'Syntastic: skip checks'
+        endif
+    else
+        let flags = get(a:opts, 'main_flags', '')
+    endif
+
+    let flags .= ' ' . s:_get_checker_var('g', a:ft, a:ck, 'compiler_options', '') . ' ' . s:_get_include_dirs(a:ft)
+
+    " check if the user manually set some cflags
+    let b_cflags = s:_get_checker_var('b', a:ft, a:ck, 'cflags', '')
+    if b_cflags !=# ''
+        let flags .= ' ' . b_cflags
+    endif
+
+    " add optional config file parameters
+    let config_file = s:_get_checker_var('g', a:ft, a:ck, 'config_file', '.syntastic_' . a:ft . '_config')
+    let flags .= ' ' . syntastic#c#ReadConfig(config_file)
+
+    if b_cflags ==# '' && (a:ft ==# 'c' || a:ft ==# 'cpp') && !s:_get_checker_var('g', a:ft, a:ck, 'no_include_search', 0)
+        " refresh the include file search if desired
+        if s:_get_checker_var('g', a:ft, a:ck, 'auto_refresh_includes', 0)
+            let flags .= ' ' . s:_search_headers()
+        else
+            " search for header includes if not cached already
+            if !exists('b:syntastic_' . a:ft . '_includes')
+                let b:syntastic_{a:ft}_includes = s:_search_headers()
+            endif
+            let flags .= ' ' . b:syntastic_{a:ft}_includes
+        endif
+    endif
+
+    return flags
+endfunction " }}}2
+
+" get the gcc include directory argument depending on the default
+" includes and the optional user-defined 'g:syntastic_c_include_dirs'
+function! s:_get_include_dirs(filetype) abort " {{{2
+    let include_dirs = []
+
+    if a:filetype =~# '\v^%(c|cpp|objc|objcpp)$' &&
+                \ (!exists('g:syntastic_'.a:filetype.'_no_default_include_dirs') ||
+                \ !g:syntastic_{a:filetype}_no_default_include_dirs)
+        let include_dirs = copy(s:default_includes)
+    endif
+
+    if exists('g:syntastic_'.a:filetype.'_include_dirs')
+        call extend(include_dirs, g:syntastic_{a:filetype}_include_dirs)
+    endif
+
+    return join(map(syntastic#util#unique(include_dirs), 'syntastic#util#shescape("-I" . v:val)'))
+endfunction " }}}2
+
+" search the first 100 lines for include statements that are
+" given in the handlers dictionary
+function! s:_search_headers() abort " {{{2
+    let includes = ''
+    let files = []
+    let found = []
+    let lines = filter(getline(1, 100), 'v:val =~# ''\m^\s*#\s*include''')
+
+    " search current buffer
+    for line in lines
+        let file = matchstr(line, '\m"\zs\S\+\ze"')
+        if file !=# ''
+            call add(files, file)
+            continue
+        endif
+
+        for handler in s:handlers
+            if line =~# handler['regex']
+                let includes .= call(handler['func'], handler['args'])
+                call add(found, handler['regex'])
+                break
+            endif
+        endfor
+    endfor
+
+    " search included headers
+    for hfile in files
+        if hfile !=# ''
+            let filename = expand('%:p:h', 1) . syntastic#util#Slash() . hfile
+
+            try
+                let lines = readfile(filename, '', 100)
+            catch /\m^Vim\%((\a\+)\)\=:E484/
+                continue
+            endtry
+
+            call filter(lines, 'v:val =~# ''\m^\s*#\s*include''')
+
+            for handler in s:handlers
+                if index(found, handler['regex']) != -1
+                    continue
+                endif
+
+                for line in lines
+                    if line =~# handler['regex']
+                        let includes .= call(handler['func'], handler['args'])
+                        call add(found, handler['regex'])
+                        break
+                    endif
+                endfor
+            endfor
+        endif
+    endfor
+
+    return includes
+endfunction " }}}2
+
+" }}}1
+
+" default include directories
+let s:default_includes = [
+    \ '.',
+    \ '..',
+    \ 'include',
+    \ 'includes',
+    \ '..' . syntastic#util#Slash() . 'include',
+    \ '..' . syntastic#util#Slash() . 'includes' ]
+
+call s:_init()
+
+let &cpo = s:save_cpo
+unlet s:save_cpo
+
+" vim: set sw=4 sts=4 et fdm=marker:
diff --git a/vim/vimfiles/bundle/syntastic/autoload/syntastic/log.vim b/vim/vimfiles/bundle/syntastic/autoload/syntastic/log.vim
new file mode 100644 (file)
index 0000000..5ad562d
--- /dev/null
@@ -0,0 +1,222 @@
+if exists('g:loaded_syntastic_log_autoload') || !exists('g:loaded_syntastic_plugin')
+    finish
+endif
+let g:loaded_syntastic_log_autoload = 1
+
+let s:save_cpo = &cpo
+set cpo&vim
+
+let s:one_time_notices_issued = []
+
+" Public functions {{{1
+
+function! syntastic#log#info(msg) abort " {{{2
+    echomsg 'syntastic: info: ' . a:msg
+endfunction " }}}2
+
+function! syntastic#log#warn(msg) abort " {{{2
+    echohl WarningMsg
+    echomsg 'syntastic: warning: ' . a:msg
+    echohl None
+endfunction " }}}2
+
+function! syntastic#log#error(msg) abort " {{{2
+    execute "normal \<Esc>"
+    echohl ErrorMsg
+    echomsg 'syntastic: error: ' . a:msg
+    echohl None
+endfunction " }}}2
+
+function! syntastic#log#oneTimeWarn(msg) abort " {{{2
+    if index(s:one_time_notices_issued, a:msg) >= 0
+        return
+    endif
+
+    call add(s:one_time_notices_issued, a:msg)
+    call syntastic#log#warn(a:msg)
+endfunction " }}}2
+
+" @vimlint(EVL102, 1, l:OLD_VAR)
+function! syntastic#log#deprecationWarn(old, new, ...) abort " {{{2
+    if exists('g:syntastic_' . a:old) && !exists('g:syntastic_' . a:new)
+        let msg = 'variable g:syntastic_' . a:old . ' is deprecated, please use '
+
+        if a:0
+            let OLD_VAR = g:syntastic_{a:old}
+            try
+                let NEW_VAR = eval(a:1)
+                let msg .= 'in its stead: let g:syntastic_' . a:new . ' = ' . string(NEW_VAR)
+                let g:syntastic_{a:new} = NEW_VAR
+            catch
+                let msg .= 'g:syntastic_' . a:new . ' instead'
+            endtry
+        else
+            let msg .= 'g:syntastic_' . a:new . ' instead'
+            let g:syntastic_{a:new} = g:syntastic_{a:old}
+        endif
+
+        call syntastic#log#oneTimeWarn(msg)
+    endif
+endfunction " }}}2
+" @vimlint(EVL102, 0, l:OLD_VAR)
+
+function! syntastic#log#debug(level, msg, ...) abort " {{{2
+    if !s:_isDebugEnabled(a:level)
+        return
+    endif
+
+    let leader = s:_log_timestamp()
+    call s:_logRedirect(1)
+
+    if a:0 > 0
+        " filter out dictionary functions
+        echomsg leader . a:msg . ' ' .
+            \ strtrans(string(type(a:1) == type({}) || type(a:1) == type([]) ?
+            \ filter(copy(a:1), 'type(v:val) != type(function("tr"))') : a:1))
+    else
+        echomsg leader . a:msg
+    endif
+
+    call s:_logRedirect(0)
+endfunction " }}}2
+
+function! syntastic#log#debugShowOptions(level, names) abort " {{{2
+    if !s:_isDebugEnabled(a:level)
+        return
+    endif
+
+    let leader = s:_log_timestamp()
+    call s:_logRedirect(1)
+
+    let vlist = copy(type(a:names) == type('') ? [a:names] : a:names)
+    let add_shell = index(vlist, 'shell') >= 0 && &shell !=# syntastic#util#var('shell')
+    if !empty(vlist)
+        call map(vlist, "'&' . v:val . ' = ' . strtrans(string(eval('&' . v:val))) . (s:_is_modified(v:val) ? ' (!)' : '')")
+        if add_shell
+            call add(vlist, 'u:shell = ' . strtrans(string(syntastic#util#var('shell'))) . ' (!)')
+        endif
+        echomsg leader . join(vlist, ', ')
+    endif
+    call s:_logRedirect(0)
+endfunction " }}}2
+
+function! syntastic#log#debugShowVariables(level, names) abort " {{{2
+    if !s:_isDebugEnabled(a:level)
+        return
+    endif
+
+    let leader = s:_log_timestamp()
+    call s:_logRedirect(1)
+
+    let vlist = type(a:names) == type('') ? [a:names] : a:names
+    for name in vlist
+        let msg = s:_format_variable(name)
+        if msg !=# ''
+            echomsg leader . msg
+        endif
+    endfor
+
+    call s:_logRedirect(0)
+endfunction " }}}2
+
+function! syntastic#log#debugDump(level) abort " {{{2
+    if !s:_isDebugEnabled(a:level)
+        return
+    endif
+
+    call syntastic#log#debugShowVariables( a:level, sort(keys(g:_SYNTASTIC_DEFAULTS)) )
+endfunction " }}}2
+
+function! syntastic#log#ndebug(level, title, messages) abort " {{{2
+    if s:_isDebugEnabled(a:level)
+        return
+    endif
+
+    call syntastic#log#error(a:title)
+    if type(a:messages) == type([])
+        for msg in a:messages
+            echomsg msg
+        endfor
+    else
+        echomsg a:messages
+    endif
+endfunction " }}}2
+
+" }}}1
+
+" Private functions {{{1
+
+function! s:_isDebugEnabled_smart(level) abort " {{{2
+    return and(g:syntastic_debug, a:level)
+endfunction " }}}2
+
+function! s:_isDebugEnabled_dumb(level) abort " {{{2
+    " poor man's bit test for bit N, assuming a:level == 2**N
+    return (g:syntastic_debug / a:level) % 2
+endfunction " }}}2
+
+let s:_isDebugEnabled = function(exists('*and') ? 's:_isDebugEnabled_smart' : 's:_isDebugEnabled_dumb')
+lockvar s:_isDebugEnabled
+
+function! s:_logRedirect(on) abort " {{{2
+    if exists('g:syntastic_debug_file')
+        if a:on
+            try
+                execute 'redir >> ' . fnameescape(expand(g:syntastic_debug_file, 1))
+            catch /\m^Vim\%((\a\+)\)\=:/
+                silent! redir END
+                unlet g:syntastic_debug_file
+            endtry
+        else
+            silent! redir END
+        endif
+    endif
+endfunction " }}}2
+
+" }}}1
+
+" Utilities {{{1
+
+function! s:_log_timestamp_smart() abort " {{{2
+    return printf('syntastic: %f: ', reltimefloat(reltime(g:_SYNTASTIC_START)))
+endfunction " }}}2
+
+function! s:_log_timestamp_dumb() abort " {{{2
+    return 'syntastic: ' . split(reltimestr(reltime(g:_SYNTASTIC_START)))[0] . ': '
+endfunction " }}}2
+
+let s:_log_timestamp = function(has('float') && exists('*reltimefloat') ? 's:_log_timestamp_smart' : 's:_log_timestamp_dumb')
+lockvar s:_log_timestamp
+
+function! s:_format_variable(name) abort " {{{2
+    let vals = []
+    if exists('g:syntastic_' . a:name)
+        call add(vals, 'g:syntastic_' . a:name . ' = ' . strtrans(string(g:syntastic_{a:name})))
+    endif
+    if exists('b:syntastic_' . a:name)
+        call add(vals, 'b:syntastic_' . a:name . ' = ' . strtrans(string(b:syntastic_{a:name})))
+    endif
+
+    return join(vals, ', ')
+endfunction " }}}2
+
+function! s:_is_modified(name) abort " {{{2
+    if !exists('s:option_defaults')
+        let s:option_defaults = {}
+    endif
+    if !has_key(s:option_defaults, a:name)
+        let opt_save = eval('&' . a:name)
+        execute 'set ' . a:name . '&'
+        let s:option_defaults[a:name] = eval('&' . a:name)
+        execute 'let &' . a:name . ' = ' . string(opt_save)
+    endif
+
+    return s:option_defaults[a:name] !=# eval('&' . a:name)
+endfunction " }}}2
+
+" }}}1
+
+let &cpo = s:save_cpo
+unlet s:save_cpo
+
+" vim: set sw=4 sts=4 et fdm=marker:
diff --git a/vim/vimfiles/bundle/syntastic/autoload/syntastic/postprocess.vim b/vim/vimfiles/bundle/syntastic/autoload/syntastic/postprocess.vim
new file mode 100644 (file)
index 0000000..136fa58
--- /dev/null
@@ -0,0 +1,73 @@
+if exists('g:loaded_syntastic_postprocess_autoload') || !exists('g:loaded_syntastic_plugin')
+    finish
+endif
+let g:loaded_syntastic_postprocess_autoload = 1
+
+let s:save_cpo = &cpo
+set cpo&vim
+
+" Public functions {{{1
+
+" merge consecutive blanks
+function! syntastic#postprocess#compressWhitespace(errors) abort " {{{2
+    for e in a:errors
+        let e['text'] = substitute(e['text'], "\001", '', 'g')
+        let e['text'] = substitute(e['text'], '\n', ' ', 'g')
+        let e['text'] = substitute(e['text'], '\m\s\{2,}', ' ', 'g')
+        let e['text'] = substitute(e['text'], '\m^\s\+', '', '')
+        let e['text'] = substitute(e['text'], '\m\s\+$', '', '')
+    endfor
+
+    return a:errors
+endfunction " }}}2
+
+" remove spurious CR under Cygwin
+function! syntastic#postprocess#cygwinRemoveCR(errors) abort " {{{2
+    if has('win32unix')
+        for e in a:errors
+            let e['text'] = substitute(e['text'], '\r', '', 'g')
+        endfor
+    endif
+
+    return a:errors
+endfunction " }}}2
+
+" decode XML entities
+function! syntastic#postprocess#decodeXMLEntities(errors) abort " {{{2
+    for e in a:errors
+        let e['text'] = syntastic#util#decodeXMLEntities(e['text'])
+    endfor
+
+    return a:errors
+endfunction " }}}2
+
+" filter out errors referencing other files
+function! syntastic#postprocess#filterForeignErrors(errors) abort " {{{2
+    return filter(copy(a:errors), 'get(v:val, "bufnr") == ' . bufnr(''))
+endfunction " }}}2
+
+" make sure line numbers are not past end of buffers
+" XXX: this loads all referenced buffers in memory
+function! syntastic#postprocess#guards(errors) abort " {{{2
+    let buffers = syntastic#util#unique(map(filter(copy(a:errors), 'v:val["valid"]'), 'str2nr(v:val["bufnr"])'))
+
+    let guards = {}
+    for b in buffers
+        let guards[b] = len(getbufline(b, 1, '$'))
+    endfor
+
+    for e in a:errors
+        if e['valid'] && e['lnum'] > guards[e['bufnr']]
+            let e['lnum'] = guards[e['bufnr']]
+        endif
+    endfor
+
+    return a:errors
+endfunction " }}}2
+
+" }}}1
+
+let &cpo = s:save_cpo
+unlet s:save_cpo
+
+" vim: set sw=4 sts=4 et fdm=marker:
diff --git a/vim/vimfiles/bundle/syntastic/autoload/syntastic/preprocess.vim b/vim/vimfiles/bundle/syntastic/autoload/syntastic/preprocess.vim
new file mode 100644 (file)
index 0000000..cbab6fd
--- /dev/null
@@ -0,0 +1,614 @@
+if exists('g:loaded_syntastic_preprocess_autoload') || !exists('g:loaded_syntastic_plugin')
+    finish
+endif
+let g:loaded_syntastic_preprocess_autoload = 1
+
+let s:save_cpo = &cpo
+set cpo&vim
+
+" Public functions {{{1
+
+function! syntastic#preprocess#cabal(errors) abort " {{{2
+    let out = []
+    let star = 0
+    for err in a:errors
+        if star
+            if err ==# ''
+                let star = 0
+            else
+                let out[-1] .= ' ' . err
+            endif
+        else
+            call add(out, err)
+            if err =~# '\m^*\s'
+                let star = 1
+            endif
+        endif
+    endfor
+    return out
+endfunction " }}}2
+
+function! syntastic#preprocess#checkstyle(errors) abort " {{{2
+    let out = []
+    let fname = expand('%', 1)
+    for err in a:errors
+        if match(err, '\m<error\>') > -1
+            let line = str2nr(matchstr(err, '\m\<line="\zs\d\+\ze"'))
+            if line == 0
+                continue
+            endif
+
+            let col = str2nr(matchstr(err, '\m\<column="\zs\d\+\ze"'))
+
+            let type = matchstr(err, '\m\<severity="\zs.\ze')
+            if type !~? '^[EW]'
+                let type = 'E'
+            endif
+
+            let message = syntastic#util#decodeXMLEntities(matchstr(err, '\m\<message="\zs[^"]\+\ze"'))
+
+            call add(out, join([fname, type, line, col, message], ':'))
+        elseif match(err, '\m<file name="') > -1
+            let fname = syntastic#util#decodeXMLEntities(matchstr(err, '\v\<file name\="\zs[^"]+\ze"'))
+        endif
+    endfor
+    return out
+endfunction " }}}2
+
+function! syntastic#preprocess#cppcheck(errors) abort " {{{2
+    return map(copy(a:errors), 'substitute(v:val, ''\v^\[[^]]+\]\zs( -\> \[[^]]+\])+\ze:'', "", "")')
+endfunction " }}}2
+
+function! syntastic#preprocess#dockerfile_lint(errors) abort " {{{2
+    let out = []
+    let json = s:_decode_JSON(join(a:errors, ''))
+
+    if type(json) == type({})
+        try
+            let data = json['error']['data'] + json['warn']['data'] + json['info']['data']
+            for e in data
+                let type = toupper(e['level'][0])
+                if type ==# 'I'
+                    let type = 'W'
+                    let style = 1
+                else
+                    let style = 0
+                endif
+
+                let line = get(e, 'line', 1)
+                let message = e['message']
+                if has_key(e, 'description') && e['description'] !=# 'None'
+                    let message = message . '. ' . e['description']
+                endif
+
+                let msg =
+                    \ type . ':' .
+                    \ style . ':' .
+                    \ line . ':' .
+                    \ message
+                call add(out, msg)
+            endfor
+        catch /\m^Vim\%((\a\+)\)\=:E716/
+            call syntastic#log#warn('checker dockerfile/dockerfile_lint: unrecognized error format')
+            let out = []
+        endtry
+    else
+        call syntastic#log#warn('checker dockerfile/dockerfile_lint: unrecognized error format')
+    endif
+    return out
+endfunction " }}}2
+
+function! syntastic#preprocess#flow(errors) abort " {{{2
+    let idx = 0
+    while idx < len(a:errors) && a:errors[idx][0] !=# '{'
+        let idx += 1
+    endwhile
+    let errs = s:_decode_JSON(join(a:errors[idx :], ''))
+
+    let out = []
+    if type(errs) == type({}) && has_key(errs, 'errors') && type(errs['errors']) == type([])
+        for e in errs['errors']
+            if type(e) == type({}) && has_key(e, 'message') && type(e['message']) == type([]) && len(e['message'])
+                let m = e['message'][0]
+                let t = e['message'][1:]
+
+                try
+                    let msg =
+                        \ m['path'] . ':' .
+                        \ m['line'] . ':' .
+                        \ m['start'] . ':' .
+                        \ (m['line'] ==# m['endline'] && str2nr(m['end']) > 0 ? m['end'] . ':' : '') .
+                        \ ' ' . m['descr']
+
+                    if len(t)
+                        let msg .= ' ' . join(map(t,
+                            \ 'v:val["descr"] . " (" . v:val["path"] . ":" . v:val["line"] . ":" . v:val["start"] . ' .
+                            \ '"," . (v:val["line"] !=# v:val["endline"] ? v:val["endline"] . ":" : "") . ' .
+                            \ 'v:val["end"] . ")"'))
+                    endif
+
+                    let msg = substitute(msg, '\r', '', 'g')
+                    let msg = substitute(msg, '\n', ' ', 'g')
+
+                    call add(out, msg)
+                catch /\m^Vim\%((\a\+)\)\=:E716/
+                    call syntastic#log#warn('checker javascript/flow: unrecognized error format')
+                    let out = []
+                    break
+                endtry
+            else
+                call syntastic#log#warn('checker javascript/flow: unrecognized error format')
+                let out = []
+                break
+            endif
+        endfor
+    else
+        call syntastic#log#warn('checker javascript/flow: unrecognized error format')
+    endif
+
+    return out
+endfunction " }}}2
+
+function! syntastic#preprocess#iconv(errors) abort " {{{2
+    return
+        \ has('iconv') && &encoding !=# '' && &encoding !=# 'utf-8' ?
+        \       map(a:errors, 'iconv(v:val, "utf-8", &encoding)') :
+        \       a:errors
+endfunction " }}}2
+
+function! syntastic#preprocess#jscs(errors) abort " {{{2
+    let errs = join(a:errors, '')
+    if errs ==# ''
+        return []
+    endif
+
+    let json = s:_decode_JSON(errs)
+
+    let out = []
+    if type(json) == type({})
+        for fname in keys(json)
+            if type(json[fname]) == type([])
+                for e in json[fname]
+                    try
+                        let e['message'] = substitute(e['message'], "\n", ' ', 'g')
+                        cal add(out, fname . ':' . e['line'] . ':' . e['column'] . ':' . e['message'])
+                    catch /\m^Vim\%((\a\+)\)\=:E716/
+                        call syntastic#log#warn('checker javascript/jscs: unrecognized error item ' . string(e))
+                        let out = []
+                    endtry
+                endfor
+            else
+                call syntastic#log#warn('checker javascript/jscs: unrecognized error format')
+            endif
+        endfor
+    else
+        call syntastic#log#warn('checker javascript/jscs: unrecognized error format')
+    endif
+    return out
+endfunction " }}}2
+
+function! syntastic#preprocess#killEmpty(errors) abort " {{{2
+    return filter(copy(a:errors), 'v:val !=# ""')
+endfunction " }}}2
+
+function! syntastic#preprocess#perl(errors) abort " {{{2
+    let out = []
+
+    for e in a:errors
+        let parts = matchlist(e, '\v^(.*)\sat\s(.{-})\sline\s(\d+)(.*)$')
+        if !empty(parts)
+            call add(out, parts[2] . ':' . parts[3] . ':' . parts[1] . parts[4])
+        endif
+    endfor
+
+    return syntastic#util#unique(out)
+endfunction " }}}2
+
+function! syntastic#preprocess#prospector(errors) abort " {{{2
+    let errs = s:_decode_JSON(join(a:errors, ''))
+
+    let out = []
+    if type(errs) == type({}) && has_key(errs, 'messages')
+        if type(errs['messages']) == type([])
+            for e in errs['messages']
+                if type(e) == type({})
+                    try
+                        if e['source'] ==# 'pylint'
+                            let e['location']['character'] += 1
+                        endif
+
+                        let msg =
+                            \ e['location']['path'] . ':' .
+                            \ e['location']['line'] . ':' .
+                            \ e['location']['character'] . ': ' .
+                            \ e['code'] . ' ' .
+                            \ e['message'] . ' ' .
+                            \ '[' . e['source'] . ']'
+
+                        call add(out, msg)
+                    catch /\m^Vim\%((\a\+)\)\=:E716/
+                        call syntastic#log#warn('checker python/prospector: unrecognized error item ' . string(e))
+                        let out = []
+                        break
+                    endtry
+                else
+                    call syntastic#log#warn('checker python/prospector: unrecognized error item ' . string(e))
+                    let out = []
+                    break
+                endif
+            endfor
+        else
+            call syntastic#log#warn('checker python/prospector: unrecognized error format')
+        endif
+    endif
+
+    return out
+endfunction " }}}2
+
+function! syntastic#preprocess#rparse(errors) abort " {{{2
+    let errlist = copy(a:errors)
+
+    " remove uninteresting lines and handle continuations
+    let i = 0
+    while i < len(errlist)
+        if i > 0 && errlist[i][:1] ==# '  ' && errlist[i] !~# '\m\s\+\^$'
+            let errlist[i-1] .= errlist[i][1:]
+            call remove(errlist, i)
+        elseif errlist[i] !~# '\m^\(Lint:\|Lint checking:\|Error in\) '
+            call remove(errlist, i)
+        else
+            let i += 1
+        endif
+    endwhile
+
+    let out = []
+    let fname = ''
+    for e in errlist
+        if match(e, '\m^Lint: ') == 0
+            let parts = matchlist(e, '\m^Lint: \(.*\): found on lines \([0-9, ]\+\)\(+\(\d\+\) more\)\=')
+            if len(parts) >= 3
+                for line in split(parts[2], '\m,\s*')
+                    call add(out, 'E:' . fname . ':' . line . ': ' . parts[1])
+                endfor
+            endif
+            if len(parts) >= 5 && parts[4] !=# ''
+                call add(out, 'E:' . fname . ':0: ' . parts[1] . ' - ' . parts[4] . ' messages not shown')
+            endif
+        elseif match(e, '\m^Lint checking: ') == 0
+            let fname = matchstr(e, '\m^Lint checking: \zs.*')
+        elseif match(e, '\m^Error in ') == 0
+            call add(out, substitute(e, '\m^Error in .\+ : .\+\ze:\d\+:\d\+: ', 'E:' . fname, ''))
+        endif
+    endfor
+
+    return out
+endfunction " }}}2
+
+function! syntastic#preprocess#scss_lint(errors) abort " {{{2
+    let errs = join(a:errors, '')
+    if errs ==# ''
+        return []
+    endif
+
+    let json = s:_decode_JSON(errs)
+
+    let out = []
+    if type(json) == type({})
+        for fname in keys(json)
+            if type(json[fname]) == type([])
+                for e in json[fname]
+                    try
+                        cal add(out, fname . ':' .
+                            \ e['severity'][0] . ':' .
+                            \ e['line'] . ':' .
+                            \ e['column'] . ':' .
+                            \ e['length'] . ':' .
+                            \ ( has_key(e, 'linter') ? e['linter'] . ': ' : '' ) .
+                            \ e['reason'])
+                    catch /\m^Vim\%((\a\+)\)\=:E716/
+                        call syntastic#log#warn('checker scss/scss_lint: unrecognized error item ' . string(e))
+                        let out = []
+                    endtry
+                endfor
+            else
+                call syntastic#log#warn('checker scss/scss_lint: unrecognized error format')
+            endif
+        endfor
+    else
+        call syntastic#log#warn('checker scss/scss_lint: unrecognized error format')
+    endif
+    return out
+endfunction " }}}2
+
+function! syntastic#preprocess#stylelint(errors) abort " {{{2
+    let out = []
+
+    " CssSyntaxError: /path/to/file.css:2:11: Missed semicolon
+    let parts = matchlist(a:errors[0], '\v^CssSyntaxError: (.{-1,}):(\d+):(\d+): (.+)')
+    if len(parts) > 4
+        call add(out, 'E:' . join(parts[1:4], ':'))
+    else
+        let errs = s:_decode_JSON(join(a:errors, ''))
+
+        let out = []
+        if type(errs) == type([]) && len(errs) == 1 && type(errs[0]) == type({}) &&
+            \ has_key(errs[0], 'source') && has_key(errs[0], 'warnings') && type(errs[0]['warnings']) == type([])
+
+            for e in errs[0]['warnings']
+                try
+                    let severity = type(e['severity']) == type(0) ? ['W', 'E'][e['severity']-1] : e['severity'][0]
+                    let msg =
+                        \ severity . ':' .
+                        \ errs[0]['source'] . ':' .
+                        \ e['line'] . ':' .
+                        \ e['column'] . ':' .
+                        \ e['text']
+                    call add(out, msg)
+                catch /\m^Vim\%((\a\+)\)\=:E716/
+                    call syntastic#log#warn('checker css/stylelint: unrecognized error item ' . string(e))
+                    let out = []
+                    break
+                endtry
+            endfor
+        else
+            call syntastic#log#warn('checker css/stylelint: unrecognized error format')
+        endif
+    endif
+    return out
+endfunction " }}}2
+
+function! syntastic#preprocess#tern_lint(errors) abort " {{{2
+    let errs = join(a:errors, '')
+    let json = s:_decode_JSON(errs)
+
+echomsg string(json)
+    let out = []
+    if type(json) == type({}) && has_key(json, 'messages') && type(json['messages']) == type([])
+        for e in json['messages']
+            try
+                let line_from = byte2line(e['from'] + 1)
+                if line_from > 0
+                    let line = line_from
+                    let column = e['from'] - line2byte(line_from) + 2
+                    let line_to = byte2line(e['from'] + 1)
+                    let hl = line_to == line ? e['to'] - line2byte(line_to) + 1 : 0
+                else
+                    let line = 0
+                    let column = 0
+                    let hl = 0
+                endif
+
+                if column < 0
+                    let column = 0
+                endif
+                if hl < 0
+                    let hl = 0
+                endif
+
+                call add(out,
+                    \ e['file'] . ':' .
+                    \ e['severity'][0] . ':' .
+                    \ line . ':' .
+                    \ column . ':' .
+                    \ hl . ':' .
+                    \ e['message'])
+            catch /\m^Vim\%((\a\+)\)\=:E716/
+                call syntastic#log#warn('checker javascript/tern_lint: unrecognized error item ' . string(e))
+                let out = []
+            endtry
+        endfor
+    else
+        call syntastic#log#warn('checker javascript/tern_lint: unrecognized error format')
+    endif
+
+echomsg string(out)
+    return out
+endfunction " }}}2
+
+function! syntastic#preprocess#tslint(errors) abort " {{{2
+    return map(copy(a:errors), 'substitute(v:val, ''\m^\(([^)]\+)\)\s\(.\+\)$'', ''\2 \1'', "")')
+endfunction " }}}2
+
+function! syntastic#preprocess#validator(errors) abort " {{{2
+    let out = []
+    for e in a:errors
+        let parts = matchlist(e, '\v^"([^"]+)"(.+)')
+        if len(parts) >= 3
+            " URL decode, except leave alone any "+"
+            let parts[1] = substitute(parts[1], '\m%\(\x\x\)', '\=nr2char("0x".submatch(1))', 'g')
+            let parts[1] = substitute(parts[1], '\m\\"', '"', 'g')
+            let parts[1] = substitute(parts[1], '\m\\\\', '\\', 'g')
+            call add(out, '"' . parts[1] . '"' . parts[2])
+        endif
+    endfor
+    return out
+endfunction " }}}2
+
+function! syntastic#preprocess#vint(errors) abort " {{{2
+    let errs = s:_decode_JSON(join(a:errors, ''))
+
+    let out = []
+    if type(errs) == type([])
+        for e in errs
+            if type(e) == type({})
+                try
+                    let msg =
+                        \ e['file_path'] . ':' .
+                        \ e['line_number'] . ':' .
+                        \ e['column_number'] . ':' .
+                        \ e['severity'][0] . ': ' .
+                        \ e['description'] . ' (' .
+                        \ e['policy_name'] . ')'
+
+                    call add(out, msg)
+                catch /\m^Vim\%((\a\+)\)\=:E716/
+                    call syntastic#log#warn('checker vim/vint: unrecognized error item ' . string(e))
+                    let out = []
+                    break
+                endtry
+            else
+                call syntastic#log#warn('checker vim/vint: unrecognized error item ' . string(e))
+                let out = []
+                break
+            endif
+        endfor
+    else
+        call syntastic#log#warn('checker vim/vint: unrecognized error format')
+    endif
+
+    return out
+endfunction " }}}2
+
+" }}}1
+
+" Workarounds {{{1
+
+" In errorformat, \ or % following %f make it depend on isfname.  The default
+" setting of isfname is crafted to work with completion, rather than general
+" filename matching.  The result for syntastic is that filenames containing
+" spaces (or a few other special characters) can't be matched.
+"
+" Fixing isfname to address this problem would depend on the set of legal
+" characters for filenames on the filesystem the project's files lives on.
+" Inferring the kind of filesystem a file lives on, in advance to parsing the
+" file's name, is an interesting problem (think f.i. a file loaded from a VFAT
+" partition, mounted on Linux).  A problem syntastic is not prepared to solve.
+"
+" As a result, the functions below exist for the only reason to avoid using
+" things like %f\, in errorformat.
+"
+" References:
+" https://groups.google.com/forum/#!topic/vim_dev/pTKmZmouhio
+" https://vimhelp.appspot.com/quickfix.txt.html#error-file-format
+
+function! syntastic#preprocess#basex(errors) abort " {{{2
+    let out = []
+    let idx = 0
+    while idx < len(a:errors)
+        let parts = matchlist(a:errors[idx], '\v^\[\S+\] Stopped at (.+), (\d+)/(\d+):')
+        if len(parts) > 3
+            let err = parts[1] . ':' . parts[2] . ':' . parts[3] . ':'
+            let parts = matchlist(a:errors[idx+1], '\v^\[(.)\D+(\d+)\] (.+)')
+            if len(parts) > 3
+                let err .= (parts[1] ==? 'W' || parts[1] ==? 'E' ? parts[1] : 'E') . ':' . parts[2] . ':' . parts[3]
+                call add(out, err)
+                let idx +=1
+            endif
+        elseif a:errors[idx] =~# '\m^\['
+            " unparseable errors
+            call add(out, a:errors[idx])
+        endif
+        let idx +=1
+    endwhile
+    return out
+endfunction " }}}2
+
+function! syntastic#preprocess#bro(errors) abort " {{{2
+    let out = []
+    for e in a:errors
+        let parts = matchlist(e, '\v^%(fatal )?(error|warning) in (.{-1,}), line (\d+): (.+)')
+        if len(parts) > 4
+            let parts[1] = parts[1][0]
+            call add(out, join(parts[1:4], ':'))
+        endif
+    endfor
+    return out
+endfunction " }}}2
+
+function! syntastic#preprocess#coffeelint(errors) abort " {{{2
+    let out = []
+    for e in a:errors
+        let parts = matchlist(e, '\v^(.{-1,}),(\d+)%(,\d*)?,(error|warn),(.+)')
+        if len(parts) > 4
+            let parts[3] = parts[3][0]
+            call add(out, join(parts[1:4], ':'))
+        endif
+    endfor
+    return out
+endfunction " }}}2
+
+function! syntastic#preprocess#mypy(errors) abort " {{{2
+    let out = []
+    for e in a:errors
+        " new format
+        let parts = matchlist(e, '\v^(.{-1,}):(\d+): error: (.+)')
+        if len(parts) > 3
+            call add(out, join(parts[1:3], ':'))
+            continue
+        endif
+
+        " old format
+        let parts = matchlist(e, '\v^(.{-1,}), line (\d+): (.+)')
+        if len(parts) > 3
+            call add(out, join(parts[1:3], ':'))
+        endif
+    endfor
+    return out
+endfunction " }}}2
+
+function! syntastic#preprocess#nix(errors) abort " {{{2
+    let out = []
+    for e in a:errors
+        let parts = matchlist(e, '\v^(.{-1,}), at (.{-1,}):(\d+):(\d+)$')
+        if len(parts) > 4
+            call add(out, join(parts[2:4], ':') . ':' . parts[1])
+            continue
+        endif
+
+        let parts = matchlist(e, '\v^(.{-1,}) at (.{-1,}), line (\d+):')
+        if len(parts) > 3
+            call add(out, parts[2] . ':' . parts[3] . ':' . parts[1])
+            continue
+        endif
+
+        let parts = matchlist(e, '\v^error: (.{-1,}), in (.{-1,})$')
+        if len(parts) > 2
+            call add(out, parts[2] . ':' . parts[1])
+        endif
+    endfor
+    return out
+endfunction " }}}2
+
+" }}}1
+
+" Private functions {{{1
+
+" @vimlint(EVL102, 1, l:true)
+" @vimlint(EVL102, 1, l:false)
+" @vimlint(EVL102, 1, l:null)
+function! s:_decode_JSON(json) abort " {{{2
+    if a:json ==# ''
+        return []
+    endif
+
+    " The following is inspired by https://github.com/MarcWeber/vim-addon-manager and
+    " http://stackoverflow.com/questions/17751186/iterating-over-a-string-in-vimscript-or-parse-a-json-file/19105763#19105763
+    " A hat tip to Marc Weber for this trick
+    if substitute(a:json, '\v\"%(\\.|[^"\\])*\"|true|false|null|[+-]?\d+%(\.\d+%([Ee][+-]?\d+)?)?', '', 'g') !~# "[^,:{}[\\] \t]"
+        " JSON artifacts
+        let true = 1
+        let false = 0
+        let null = ''
+
+        try
+            let object = eval(a:json)
+        catch
+            " malformed JSON
+            let object = ''
+        endtry
+    else
+        let object = ''
+    endif
+
+    return object
+endfunction " }}}2
+" @vimlint(EVL102, 0, l:true)
+" @vimlint(EVL102, 0, l:false)
+" @vimlint(EVL102, 0, l:null)
+
+" }}}1
+
+let &cpo = s:save_cpo
+unlet s:save_cpo
+
+" vim: set sw=4 sts=4 et fdm=marker:
diff --git a/vim/vimfiles/bundle/syntastic/autoload/syntastic/util.vim b/vim/vimfiles/bundle/syntastic/autoload/syntastic/util.vim
new file mode 100644 (file)
index 0000000..68eb06e
--- /dev/null
@@ -0,0 +1,552 @@
+if exists('g:loaded_syntastic_util_autoload') || !exists('g:loaded_syntastic_plugin')
+    finish
+endif
+let g:loaded_syntastic_util_autoload = 1
+
+let s:save_cpo = &cpo
+set cpo&vim
+
+" Public functions {{{1
+
+function! syntastic#util#isRunningWindows() abort " {{{2
+    return has('win16') || has('win32') || has('win64')
+endfunction " }}}2
+
+function! syntastic#util#DevNull() abort " {{{2
+    if syntastic#util#isRunningWindows()
+        return 'NUL'
+    endif
+    return '/dev/null'
+endfunction " }}}2
+
+" Get directory separator
+function! syntastic#util#Slash() abort " {{{2
+    return (!exists('+shellslash') || &shellslash) ? '/' : '\'
+endfunction " }}}2
+
+function! syntastic#util#CygwinPath(path) abort " {{{2
+    return substitute(syntastic#util#system('cygpath -m ' . syntastic#util#shescape(a:path)), "\n", '', 'g')
+endfunction " }}}2
+
+function! syntastic#util#system(command) abort " {{{2
+    let old_shell = &shell
+    let old_lc_messages = $LC_MESSAGES
+    let old_lc_all = $LC_ALL
+
+    let &shell = syntastic#util#var('shell')
+    let $LC_MESSAGES = 'C'
+    let $LC_ALL = ''
+
+    let cmd_start = reltime()
+    let out = system(a:command)
+    let cmd_time = split(reltimestr(reltime(cmd_start)))[0]
+
+    let $LC_ALL = old_lc_all
+    let $LC_MESSAGES = old_lc_messages
+
+    let &shell = old_shell
+
+    if exists('g:_SYNTASTIC_DEBUG_TRACE')
+        call syntastic#log#debug(g:_SYNTASTIC_DEBUG_TRACE, 'system: command run in ' . cmd_time . 's')
+    endif
+
+    return out
+endfunction " }}}2
+
+" Create a temporary directory
+function! syntastic#util#tmpdir() abort " {{{2
+    let tempdir = ''
+
+    if (has('unix') || has('mac')) && executable('mktemp') && !has('win32unix')
+        " TODO: option "-t" to mktemp(1) is not portable
+        let tmp = $TMPDIR !=# '' ? $TMPDIR : $TMP !=# '' ? $TMP : '/tmp'
+        let out = split(syntastic#util#system('mktemp -q -d ' . tmp . '/vim-syntastic-' . getpid() . '-XXXXXXXX'), "\n")
+        if v:shell_error == 0 && len(out) == 1
+            let tempdir = out[0]
+        endif
+    endif
+
+    if tempdir ==# ''
+        if has('win32') || has('win64')
+            let tempdir = $TEMP . syntastic#util#Slash() . 'vim-syntastic-' . getpid()
+        elseif has('win32unix')
+            let tempdir = syntastic#util#CygwinPath('/tmp/vim-syntastic-'  . getpid())
+        elseif $TMPDIR !=# ''
+            let tempdir = $TMPDIR . '/vim-syntastic-' . getpid()
+        else
+            let tempdir = '/tmp/vim-syntastic-' . getpid()
+        endif
+
+        try
+            call mkdir(tempdir, 'p', 0700)
+        catch /\m^Vim\%((\a\+)\)\=:E739/
+            call syntastic#log#error(v:exception)
+            let tempdir = '.'
+        endtry
+    endif
+
+    return tempdir
+endfunction " }}}2
+
+" Recursively remove a directory
+function! syntastic#util#rmrf(what) abort " {{{2
+    " try to make sure we don't delete directories we didn't create
+    if a:what !~? 'vim-syntastic-'
+        return
+    endif
+
+    if  getftype(a:what) ==# 'dir'
+        call s:_delete(a:what, 'rf')
+    else
+        silent! call delete(a:what)
+    endif
+endfunction " }}}2
+
+" Search the first 5 lines of the file for a magic number and return a map
+" containing the args and the executable
+"
+" e.g.
+"
+" #!/usr/bin/perl -f -bar
+"
+" returns
+"
+" {'exe': '/usr/bin/perl', 'args': ['-f', '-bar']}
+function! syntastic#util#parseShebang() abort " {{{2
+    for lnum in range(1, 5)
+        let line = getline(lnum)
+        if line =~# '^#!'
+            let line = substitute(line, '\v^#!\s*(\S+/env(\s+-\S+)*\s+)?', '', '')
+            let exe = matchstr(line, '\m^\S*\ze')
+            let args = split(matchstr(line, '\m^\S*\zs.*'))
+            return { 'exe': exe, 'args': args }
+        endif
+    endfor
+
+    return { 'exe': '', 'args': [] }
+endfunction " }}}2
+
+" Get the value of a Vim variable.  Allow local variables to override global ones.
+function! syntastic#util#rawVar(name, ...) abort " {{{2
+    return get(b:, a:name, get(g:, a:name, a:0 > 0 ? a:1 : ''))
+endfunction " }}}2
+
+" Get the value of a syntastic variable.  Allow local variables to override global ones.
+function! syntastic#util#var(name, ...) abort " {{{2
+    return call('syntastic#util#rawVar', ['syntastic_' . a:name] + a:000)
+endfunction " }}}2
+
+" Parse a version string.  Return an array of version components.
+function! syntastic#util#parseVersion(version, ...) abort " {{{2
+    return map(split(matchstr( a:version, a:0 ? a:1 : '\v^\D*\zs\d+(\.\d+)+\ze' ), '\m\.'), 'str2nr(v:val)')
+endfunction " }}}2
+
+" Verify that the 'installed' version is at least the 'required' version.
+"
+" 'installed' and 'required' must be arrays. If they have different lengths,
+" the "missing" elements will be assumed to be 0 for the purposes of checking.
+"
+" See http://semver.org for info about version numbers.
+function! syntastic#util#versionIsAtLeast(installed, required) abort " {{{2
+    return syntastic#util#compareLexi(a:installed, a:required) >= 0
+endfunction " }}}2
+
+" Almost lexicographic comparison of two lists of integers. :) If lists
+" have different lengths, the "missing" elements are assumed to be 0.
+function! syntastic#util#compareLexi(a, b) abort " {{{2
+    for idx in range(max([len(a:a), len(a:b)]))
+        let a_element = str2nr(get(a:a, idx, 0))
+        let b_element = str2nr(get(a:b, idx, 0))
+        if a_element != b_element
+            return a_element > b_element ? 1 : -1
+        endif
+    endfor
+    " still here, thus everything matched
+    return 0
+endfunction " }}}2
+
+" strwidth() was added in Vim 7.3; if it doesn't exist, we use strlen()
+" and hope for the best :)
+let s:_width = function(exists('*strwidth') ? 'strwidth' : 'strlen')
+lockvar s:_width
+
+function! syntastic#util#screenWidth(str, tabstop) abort " {{{2
+    let chunks = split(a:str, "\t", 1)
+    let width = s:_width(chunks[-1])
+    for c in chunks[:-2]
+        let cwidth = s:_width(c)
+        let width += cwidth + a:tabstop - cwidth % a:tabstop
+    endfor
+    return width
+endfunction " }}}2
+
+" Print as much of a:msg as possible without "Press Enter" prompt appearing
+function! syntastic#util#wideMsg(msg) abort " {{{2
+    let old_ruler = &ruler
+    let old_showcmd = &showcmd
+
+    "This is here because it is possible for some error messages to
+    "begin with \n which will cause a "press enter" prompt.
+    let msg = substitute(a:msg, "\n", '', 'g')
+
+    "convert tabs to spaces so that the tabs count towards the window
+    "width as the proper amount of characters
+    let chunks = split(msg, "\t", 1)
+    let msg = join(map(chunks[:-2], 'v:val . repeat(" ", &tabstop - s:_width(v:val) % &tabstop)'), '') . chunks[-1]
+    let msg = strpart(msg, 0, &columns - 1)
+
+    set noruler noshowcmd
+    call syntastic#util#redraw(0)
+
+    echo msg
+
+    let &ruler = old_ruler
+    let &showcmd = old_showcmd
+endfunction " }}}2
+
+" Check whether a buffer is loaded, listed, and not hidden
+function! syntastic#util#bufIsActive(buffer) abort " {{{2
+    " convert to number, or hell breaks loose
+    let buf = str2nr(a:buffer)
+
+    if !bufloaded(buf) || !buflisted(buf)
+        return 0
+    endif
+
+    " get rid of hidden buffers
+    for tab in range(1, tabpagenr('$'))
+        if index(tabpagebuflist(tab), buf) >= 0
+            return 1
+        endif
+    endfor
+
+    return 0
+endfunction " }}}2
+
+" Start in directory a:where and walk up the parent folders until it finds a
+" file named a:what; return path to that file
+function! syntastic#util#findFileInParent(what, where) abort " {{{2
+    let old_suffixesadd = &suffixesadd
+    let &suffixesadd = ''
+    let file = findfile(a:what, escape(a:where, ' ') . ';')
+    let &suffixesadd = old_suffixesadd
+    return file
+endfunction " }}}2
+
+" Start in directory a:where and walk up the parent folders until it finds a
+" file matching a:what; return path to that file
+function! syntastic#util#findGlobInParent(what, where) abort " {{{2
+    let here = fnamemodify(a:where, ':p')
+
+    let root = syntastic#util#Slash()
+    if syntastic#util#isRunningWindows() && here[1] ==# ':'
+        " The drive letter is an ever-green source of fun.  That's because
+        " we don't care about running syntastic on Amiga these days. ;)
+        let root = fnamemodify(root, ':p')
+        let root = here[0] . root[1:]
+    endif
+
+    let old = ''
+    while here !=# ''
+        try
+            " Vim 7.4.279 and later
+            let p = globpath(here, a:what, 1, 1)
+        catch /\m^Vim\%((\a\+)\)\=:E118/
+            let p = split(globpath(here, a:what, 1), "\n")
+        endtry
+
+        if !empty(p)
+            return fnamemodify(p[0], ':p')
+        elseif here ==? root || here ==? old
+            break
+        endif
+
+        let old = here
+
+        " we use ':h:h' rather than ':h' since ':p' adds a trailing '/'
+        " if 'here' is a directory
+        let here = fnamemodify(here, ':p:h:h')
+    endwhile
+
+    return ''
+endfunction " }}}2
+
+" Returns unique elements in a list
+function! syntastic#util#unique(list) abort " {{{2
+    let seen = {}
+    let uniques = []
+    for e in a:list
+        let k = string(e)
+        if !has_key(seen, k)
+            let seen[k] = 1
+            call add(uniques, e)
+        endif
+    endfor
+    return uniques
+endfunction " }}}2
+
+" A less noisy shellescape()
+function! syntastic#util#shescape(string) abort " {{{2
+    return a:string =~# '\m^[A-Za-z0-9_/.-]\+$' ? a:string : shellescape(a:string)
+endfunction " }}}2
+
+" A less noisy shellescape(expand())
+function! syntastic#util#shexpand(string, ...) abort " {{{2
+    return syntastic#util#shescape(a:0 ? expand(a:string, a:1) : expand(a:string, 1))
+endfunction " }}}2
+
+" Escape arguments
+function! syntastic#util#argsescape(opt) abort " {{{2
+    if type(a:opt) == type('') && a:opt !=# ''
+        return [a:opt]
+    elseif type(a:opt) == type([])
+        return map(copy(a:opt), 'syntastic#util#shescape(v:val)')
+    endif
+
+    return []
+endfunction " }}}2
+
+" Decode XML entities
+function! syntastic#util#decodeXMLEntities(string) abort " {{{2
+    let str = a:string
+    let str = substitute(str, '\m&lt;', '<', 'g')
+    let str = substitute(str, '\m&gt;', '>', 'g')
+    let str = substitute(str, '\m&quot;', '"', 'g')
+    let str = substitute(str, '\m&apos;', "'", 'g')
+    let str = substitute(str, '\m&amp;', '\&', 'g')
+    return str
+endfunction " }}}2
+
+function! syntastic#util#redraw(full) abort " {{{2
+    if a:full
+        redraw!
+    else
+        redraw
+    endif
+endfunction " }}}2
+
+function! syntastic#util#dictFilter(errors, filter) abort " {{{2
+    let rules = s:_translateFilter(a:filter)
+    " call syntastic#log#debug(g:_SYNTASTIC_DEBUG_TRACE, "applying filter:", rules)
+    try
+        call filter(a:errors, rules)
+    catch /\m^Vim\%((\a\+)\)\=:E/
+        let msg = matchstr(v:exception, '\m^Vim\%((\a\+)\)\=:\zs.*')
+        call syntastic#log#error('quiet_messages: ' . msg)
+    endtry
+endfunction " }}}2
+
+" Return a [seconds, fractions] list of strings, representing the
+" (hopefully high resolution) time since program start
+function! syntastic#util#stamp() abort " {{{2
+    return split( split(reltimestr(reltime(g:_SYNTASTIC_START)))[0], '\.' )
+endfunction " }}}2
+
+function! syntastic#util#setChangedtick() abort " {{{2
+    unlockvar! b:syntastic_changedtick
+    let b:syntastic_changedtick = b:changedtick
+    lockvar! b:syntastic_changedtick
+endfunction " }}}2
+
+let s:_wid_base = 'syntastic_' . getpid() . '_' . reltimestr(g:_SYNTASTIC_START) . '_'
+let s:_wid_pool = 0
+
+" Add unique IDs to windows
+function! syntastic#util#setWids() abort " {{{2
+    for tab in range(1, tabpagenr('$'))
+        for win in range(1, tabpagewinnr(tab, '$'))
+            if gettabwinvar(tab, win, 'syntastic_wid') ==# ''
+                call settabwinvar(tab, win, 'syntastic_wid', s:_wid_base . s:_wid_pool)
+                let s:_wid_pool += 1
+            endif
+        endfor
+    endfor
+endfunction " }}}2
+
+let s:_str2float = function(exists('*str2float') ? 'str2float' : 'str2nr')
+lockvar s:_str2float
+
+function! syntastic#util#str2float(val) abort " {{{2
+    return s:_str2float(a:val)
+endfunction " }}}2
+
+function! syntastic#util#float2str(val) abort " {{{2
+    return s:_float2str(a:val)
+endfunction " }}}2
+
+" Crude printf()-like width formatter.  Handles wide characters.
+function! syntastic#util#wformat(format, str) abort " {{{2
+    if a:format ==# ''
+        return a:str
+    endif
+
+ echomsg string(a:format) . ', ' . string(a:str)
+    let specs = matchlist(a:format, '\v^(-?)(0?)(%([1-9]\d*))?%(\.(\d+))?$')
+    if len(specs) < 5
+        return a:str
+    endif
+
+    let flushleft = specs[1] ==# '-'
+    let lpad = specs[2] ==# '0' ? '0' : ' '
+    let minlen = str2nr(specs[3])
+    let maxlen = str2nr(specs[4])
+    let out = substitute(a:str, "\t", ' ', 'g')
+
+    if maxlen && s:_width(out) > maxlen
+        let chars = filter(split(out, '\zs\ze', 1), 'v:val !=# ""')
+        let out = ''
+
+        if flushleft
+            for c in chars
+                if s:_width(out . c) < maxlen
+                    let out .= c
+                else
+                    let out .= &encoding ==# 'utf-8' && &termencoding ==# 'utf-8' ? "\u2026" : '>'
+                    break
+                endif
+            endfor
+        else
+            call reverse(chars)
+            for c in chars
+                if s:_width(c . out) < maxlen
+                    let out = c . out
+                else
+                    let out = (&encoding ==# 'utf-8' && &termencoding ==# 'utf-8' ? "\u2026" : '<') . out
+                    break
+                endif
+            endfor
+        endif
+    endif
+
+    if minlen && s:_width(out) < minlen
+        if flushleft
+            let out .= repeat(' ', minlen - s:_width(out))
+        else
+            let out = repeat(lpad, minlen - s:_width(out)) . out
+        endif
+    endif
+
+    return out
+endfunction " }}}2
+
+" }}}1
+
+" Private functions {{{1
+
+function! s:_translateFilter(filters) abort " {{{2
+    let conditions = []
+    for k in keys(a:filters)
+        if type(a:filters[k]) == type([])
+            call extend(conditions, map(copy(a:filters[k]), 's:_translateElement(k, v:val)'))
+        else
+            call add(conditions, s:_translateElement(k, a:filters[k]))
+        endif
+    endfor
+
+    if conditions == []
+        let conditions = ['1']
+    endif
+    return len(conditions) == 1 ? conditions[0] : join(map(conditions, '"(" . v:val . ")"'), ' && ')
+endfunction " }}}2
+
+function! s:_translateElement(key, term) abort " {{{2
+    let fkey = a:key
+    if fkey[0] ==# '!'
+        let fkey = fkey[1:]
+        let not = 1
+    else
+        let not = 0
+    endif
+
+    if fkey ==? 'level'
+        let op = not ? ' ==? ' : ' !=? '
+        let ret = 'v:val["type"]' . op . string(a:term[0])
+    elseif fkey ==? 'type'
+        if a:term ==? 'style'
+            let op = not ? ' ==? ' : ' !=? '
+            let ret = 'get(v:val, "subtype", "")' . op . '"style"'
+        else
+            let op = not ? '!' : ''
+            let ret = op . 'has_key(v:val, "subtype")'
+        endif
+    elseif fkey ==? 'regex'
+        let op = not ? ' =~? ' : ' !~? '
+        let ret = 'v:val["text"]' . op . string(a:term)
+    elseif fkey ==? 'file' || fkey[:4] ==? 'file:'
+        let op = not ? ' =~# ' : ' !~# '
+        let ret = 'bufname(str2nr(v:val["bufnr"]))'
+        let mod = fkey[4:]
+        if mod !=# ''
+            let ret = 'fnamemodify(' . ret . ', ' . string(mod) . ')'
+        endif
+        let ret .= op . string(a:term)
+    else
+        call syntastic#log#warn('quiet_messages: ignoring invalid key ' . strtrans(string(fkey)))
+        let ret = '1'
+    endif
+    return ret
+endfunction " }}}2
+
+" @vimlint(EVL103, 1, a:flags)
+function! s:_delete_dumb(what, flags) abort " {{{2
+    if !exists('s:rmrf')
+        let s:rmrf =
+            \ has('unix') || has('mac') ? 'rm -rf' :
+            \ has('win32') || has('win64') ? 'rmdir /S /Q' :
+            \ has('win16') || has('win95') || has('dos16') || has('dos32') ? 'deltree /Y' : ''
+    endif
+
+    if s:rmrf !=# ''
+        silent! call syntastic#util#system(s:rmrf . ' ' . syntastic#util#shescape(a:what))
+    else
+        call s:_rmrf(a:what)
+    endif
+endfunction " }}}2
+" @vimlint(EVL103, 0, a:flags)
+
+" delete(dir, 'rf') was added in Vim 7.4.1107, but it didn't become usable until 7.4.1128
+let s:_delete = function(v:version > 704 || (v:version == 704 && has('patch1128')) ? 'delete' : 's:_delete_dumb')
+lockvar s:_delete
+
+function! s:_rmrf(what) abort " {{{2
+    if !exists('s:rmdir')
+        let s:rmdir = syntastic#util#shescape(get(g:, 'netrw_localrmdir', 'rmdir'))
+    endif
+
+    if getftype(a:what) ==# 'dir'
+        if filewritable(a:what) != 2
+            return
+        endif
+
+        try
+            " Vim 7.4.279 and later
+            let entries = globpath(a:what, '*', 1, 1)
+        catch /\m^Vim\%((\a\+)\)\=:E118/
+            let entries = split(globpath(a:what, '*', 1), "\n")
+        endtry
+        for f in entries
+            call s:_rmrf(f)
+        endfor
+        silent! call syntastic#util#system(s:rmdir . ' ' . syntastic#util#shescape(a:what))
+    else
+        silent! call delete(a:what)
+    endif
+endfunction " }}}2
+
+function! s:_float2str_smart(val) abort " {{{2
+    return printf('%.1f', a:val)
+endfunction " }}}2
+
+function! s:_float2str_dumb(val) abort " {{{2
+    return a:val
+endfunction " }}}2
+
+let s:_float2str = function(has('float') ? 's:_float2str_smart' : 's:_float2str_dumb')
+lockvar s:_float2str
+
+" }}}1
+
+let &cpo = s:save_cpo
+unlet s:save_cpo
+
+" vim: set sw=4 sts=4 et fdm=marker:
diff --git a/vim/vimfiles/bundle/syntastic/doc/syntastic-checkers.txt b/vim/vimfiles/bundle/syntastic/doc/syntastic-checkers.txt
new file mode 100644 (file)
index 0000000..1997405
--- /dev/null
@@ -0,0 +1,6963 @@
+*syntastic-checkers.txt*       Syntastic checkers
+*syntastic-checkers*
+
+==============================================================================
+SYNTAX CHECKERS BY LANGUAGE                          *syntastic-checkers-lang*
+
+|syntastic| comes with checkers for the following languages:
+
+    ACPI Source Language.....................|syntastic-checkers-asl|
+    ActionScript.............................|syntastic-checkers-actionscript|
+    Ada......................................|syntastic-checkers-ada|
+    Ansible..................................|syntastic-checkers-ansible|
+    API Blueprint............................|syntastic-checkers-apiblueprint|
+    AppleScript..............................|syntastic-checkers-applescript|
+    AsciiDoc.................................|syntastic-checkers-asciidoc|
+    Assembly Languages.......................|syntastic-checkers-asm|
+
+    BEMHTML..................................|syntastic-checkers-bemhtml|
+    Bro......................................|syntastic-checkers-bro|
+
+    C........................................|syntastic-checkers-c|
+    C#.......................................|syntastic-checkers-cs|
+    C++......................................|syntastic-checkers-cpp|
+    Cabal....................................|syntastic-checkers-cabal|
+    Chef.....................................|syntastic-checkers-chef|
+    COBOL....................................|syntastic-checkers-cobol|
+    Coco.....................................|syntastic-checkers-co|
+    CoffeeScript.............................|syntastic-checkers-coffee|
+    Coq......................................|syntastic-checkers-coq|
+    CSS......................................|syntastic-checkers-css|
+    Cucumber.................................|syntastic-checkers-cucumber|
+    CUDA.....................................|syntastic-checkers-cuda|
+
+    D........................................|syntastic-checkers-d|
+    Dart.....................................|syntastic-checkers-dart|
+    DocBook..................................|syntastic-checkers-docbk|
+    Dockerfile...............................|syntastic-checkers-dockerfile|
+    Dust.....................................|syntastic-checkers-dustjs|
+
+    Elixir...................................|syntastic-checkers-elixir|
+    Erlang...................................|syntastic-checkers-erlang|
+    eRuby....................................|syntastic-checkers-eruby|
+
+    Fortran..................................|syntastic-checkers-fortran|
+
+    Gentoo Metadata..........................|syntastic-checkers-gentoo|
+    Gettext PO...............................|syntastic-checkers-po|
+    GLSL.....................................|syntastic-checkers-glsl|
+    Go.......................................|syntastic-checkers-go|
+
+    Haml.....................................|syntastic-checkers-haml|
+    Handlebars...............................|syntastic-checkers-handlebars|
+    Haskell..................................|syntastic-checkers-haskell|
+    Haxe.....................................|syntastic-checkers-haxe|
+    HSS......................................|syntastic-checkers-hss|
+    HTML.....................................|syntastic-checkers-html|
+
+    Java.....................................|syntastic-checkers-java|
+    JavaScript...............................|syntastic-checkers-javascript|
+    JSON.....................................|syntastic-checkers-json|
+
+    LESS.....................................|syntastic-checkers-less|
+    Lex......................................|syntastic-checkers-lex|
+    Limbo....................................|syntastic-checkers-limbo|
+    LISP.....................................|syntastic-checkers-lisp|
+    LLVM.....................................|syntastic-checkers-llvm|
+    Lua......................................|syntastic-checkers-lua|
+
+    Markdown.................................|syntastic-checkers-markdown|
+    MATLAB...................................|syntastic-checkers-matlab|
+    Mercury..................................|syntastic-checkers-mercury|
+
+    NASM.....................................|syntastic-checkers-nasm|
+    Nix......................................|syntastic-checkers-nix|
+    nroff....................................|syntastic-checkers-nroff|
+
+    Objective-C..............................|syntastic-checkers-objc|
+    Objective-C++............................|syntastic-checkers-objcpp|
+    OCaml....................................|syntastic-checkers-ocaml|
+
+    Perl.....................................|syntastic-checkers-perl|
+    PHP......................................|syntastic-checkers-php|
+    POD......................................|syntastic-checkers-pod|
+    Pug (formerly Jade)......................|syntastic-checkers-pug|
+    Puppet...................................|syntastic-checkers-puppet|
+    Python...................................|syntastic-checkers-python|
+
+    QML......................................|syntastic-checkers-qml|
+
+    R........................................|syntastic-checkers-r|
+    R Markdown...............................|syntastic-checkers-rmd|
+    Racket...................................|syntastic-checkers-racket|
+    Relax NG.................................|syntastic-checkers-rnc|
+    reStructuredText.........................|syntastic-checkers-rst|
+    RPM spec.................................|syntastic-checkers-spec|
+    Ruby.....................................|syntastic-checkers-ruby|
+
+    SASS.....................................|syntastic-checkers-sass|
+    Scala....................................|syntastic-checkers-scala|
+    SCSS.....................................|syntastic-checkers-scss|
+    Sh.......................................|syntastic-checkers-sh|
+    Slim.....................................|syntastic-checkers-slim|
+    SML......................................|syntastic-checkers-sml|
+    SQL......................................|syntastic-checkers-sql|
+    Stylus...................................|syntastic-checkers-stylus|
+
+    Tcl......................................|syntastic-checkers-tcl|
+    TeX......................................|syntastic-checkers-tex|
+    Texinfo..................................|syntastic-checkers-texinfo|
+    Text.....................................|syntastic-checkers-text|
+    Turtle...................................|syntastic-checkers-turtle|
+    TriG.....................................|syntastic-checkers-trig|
+    Twig.....................................|syntastic-checkers-twig|
+    TypeScript...............................|syntastic-checkers-typescript|
+
+    Vala.....................................|syntastic-checkers-vala|
+    Verilog..................................|syntastic-checkers-verilog|
+    VHDL.....................................|syntastic-checkers-vhdl|
+    VimL.....................................|syntastic-checkers-vim|
+
+    xHTML....................................|syntastic-checkers-xhtml|
+    XML......................................|syntastic-checkers-xml|
+    XQuery...................................|syntastic-checkers-xquery|
+    XSLT.....................................|syntastic-checkers-xslt|
+
+    YACC.....................................|syntastic-checkers-yacc|
+    YAML.....................................|syntastic-checkers-yaml|
+    YANG.....................................|syntastic-checkers-yang|
+
+    Z80......................................|syntastic-checkers-z80|
+    Zope Page Templates......................|syntastic-checkers-zpt|
+    Zsh......................................|syntastic-checkers-zsh|
+
+Third-party checkers are available for additional languages.
+
+==============================================================================
+SYNTAX CHECKERS FOR ACPI SOURCE LANGUAGE              *syntastic-checkers-asl*
+
+The following checkers are available for the ACPI Source Language (filetype
+"asl"):
+
+    1. iasl.....................|syntastic-asl-iasl|
+
+------------------------------------------------------------------------------
+1. iasl                                                   *syntastic-asl-iasl*
+
+Name:        iasl
+Maintainer:  Peter Wu <peter@lekensteyn.nl>
+
+"iasl" is a compiler/decompiler for ACPI Source Language (ASL) and ACPI
+Machine Language (AML). See the project's page for details:
+
+    https://acpica.org/
+
+Checker options~
+
+This checker is initialised using the "makeprgBuild()" function and thus it
+accepts the standard options described at |syntastic-config-makeprg|.
+
+Note~
+
+You probably also need a plugin to set |filetype| for ASL files, such as
+"vim-acpi-asl":
+
+    https://github.com/martinlroth/vim-acpi-asl
+
+==============================================================================
+SYNTAX CHECKERS FOR ACTIONSCRIPT             *syntastic-checkers-actionscript*
+
+The following checkers are available for ActionScript (filetype
+"actionscript"):
+
+    1. mxmlc....................|syntastic-actionscript-mxmlc|
+
+------------------------------------------------------------------------------
+1. mxmlc                                        *syntastic-actionscript-mxmlc*
+
+Name:        mxmlc
+Maintainer:  Andy Earnshaw <andyearnshaw@gmail.com>
+
+"mxmlc" is a compiler for ActionScript. See Apache Flex for details:
+
+    http://flex.apache.org/
+
+Checker options~
+
+This checker is initialised using the "makeprgBuild()" function and thus it
+accepts the standard options described at |syntastic-config-makeprg|.
+
+==============================================================================
+SYNTAX CHECKERS FOR ADA                               *syntastic-checkers-ada*
+
+The following checkers are available for Ada (filetype "ada"):
+
+    1. GCC......................|syntastic-ada-gcc|
+
+------------------------------------------------------------------------------
+1. GCC                                                     *syntastic-ada-gcc*
+
+Name:        gcc
+Maintainer:  Alfredo Di Napoli <alfredo.dinapoli@gmail.com>
+
+Checker options~
+                                                  *'g:syntastic_ada_compiler'*
+Type: string
+Default: "gcc"
+Compiler executable.
+
+                                               *'g:syntastic_ada_errorformat'*
+Type: string
+Default: unset
+Override for the default |'errorformat'|.
+
+                                     *'g:syntastic_ada_remove_include_errors'*
+Type: boolean
+Default: 0
+By default, errors in files included from the file being checked are shown.
+Set this variable to 1 to remove messages about errors in included files.
+Please note that this means syntastic will silently abort checks if there are
+fatal errors in one of the included files.
+
+                                          *'g:syntastic_ada_compiler_options'*
+Type: string
+Default: unset
+Compilation flags (such as defines or include directories) to be passed to the
+checker.
+
+                                               *'g:syntastic_ada_config_file'*
+Type: string
+Default: ".syntastic_ada_config"
+File containing additional compilation flags to be passed to the checker, one
+option per line (cf. |syntastic-config-files|).
+
+                                              *'g:syntastic_ada_include_dirs'*
+Type: array of strings
+Default: []
+Include directories to be passed to the checker, in addition to the above
+compilation flags. You can set it like this: >
+    let g:syntastic_ada_include_dirs = ["includes", "headers"]
+<
+and the corresponding "-Iincludes -Iheaders" will be added to the compilation
+flags.
+
+                                                    *'b:syntastic_ada_cflags'*
+Type: string
+Default: unset
+Buffer-local variable. Additional compilation flags specific to the current
+buffer.
+
+                                              *'g:syntastic_ada_check_header'*
+Type: boolean
+Default: 0
+If the current file is a header (namely if its extension is "ads"), all checks
+are silently skipped. You can force syntastic to check header files by
+setting the above variable to 1.
+
+Note~
+
+This checker doesn't call the "makeprgBuild()" function, and thus it ignores
+the usual 'g:syntastic_ada_gcc_<option>' variables. The only exception is
+'g:syntastic_ada_gcc_exec', which can still be used to override the checker's
+executable.
+
+==============================================================================
+SYNTAX CHECKERS FOR ANSIBLE                       *syntastic-checkers-ansible*
+
+The following checkers are available for Ansible (filetype "ansible"):
+
+    1. Ansible-lint.............|syntastic-ansible-ansible_lint|
+
+------------------------------------------------------------------------------
+1. Ansible-lint                               *syntastic-ansible-ansible_lint*
+
+Name:        ansible_lint
+Maintainer:  Erik Zaadi <erik.zaadi@gmail.com>
+
+"Ansible-lint" is a style checker for Ansible playbooks. See the project's
+page at GitHub for details:
+
+    https://github.com/willthames/ansible-lint
+
+Syntastic requires "Ansible-lint" version 2.0.4 or later.
+
+Checker options~
+
+This checker is initialised using the "makeprgBuild()" function and thus it
+accepts the standard options described at |syntastic-config-makeprg|.
+
+Note~
+
+You probably also need a plugin to set |filetype| for Ansible playbooks, such
+as "ansible-vim":
+
+    https://github.com/pearofducks/ansible-vim
+
+==============================================================================
+SYNTAX CHECKERS FOR API BLUEPRINT            *syntastic-checkers-apiblueprint*
+
+The following checkers are available for API Blueprint (filetype "apiblueprint"):
+
+    1. Drafter..................|syntastic-apiblueprint-drafter|
+
+------------------------------------------------------------------------------
+1. Drafter                                    *syntastic-apiblueprint-drafter*
+
+Name:        drafter
+Maintainer:  LCD 47 <lcd047@gmail.com>
+
+"Drafter" is a parser for Apiary's "API Blueprint" (http://apiblueprint.org/).
+See the project's page at GitHub for details:
+
+    https://github.com/apiaryio/drafter
+
+Checker options~
+
+This checker is initialised using the "makeprgBuild()" function and thus it
+accepts the standard options described at |syntastic-config-makeprg|.
+
+Note~
+
+You probably also need a plugin to set |filetype| for API Blueprint files, such
+as "apiblueprint.vim":
+
+    https://github.com/kylef/apiblueprint.vim
+
+==============================================================================
+SYNTAX CHECKERS FOR APPLESCRIPT               *syntastic-checkers-applescript*
+
+The following checkers are available for AppleScript (filetype "applescript"):
+
+    1. osacompile...............|syntastic-applescript-osacompile|
+
+------------------------------------------------------------------------------
+1. osacompile                               *syntastic-applescript-osacompile*
+
+Name:        osacompile
+Author: Zhao Cai <caizhaoff@gmail.com>
+
+"osacompile" is a compiler for "AppleScript". See the program's manual for
+details:
+
+    https://developer.apple.com/library/mac/documentation/Darwin/Reference/ManPages/man1/osacompile.1.html
+
+Checker options~
+
+This checker is initialised using the "makeprgBuild()" function and thus it
+accepts the standard options described at |syntastic-config-makeprg|.
+
+==============================================================================
+SYNTAX CHECKERS FOR ASCIIDOC                     *syntastic-checkers-asciidoc*
+
+The following checkers are available for AsciiDoc (filetype "asciidoc"):
+
+    1. Asciidoc.................|syntastic-asciidoc-asciidoc|
+
+------------------------------------------------------------------------------
+1. Asciidoc                                      *syntastic-asciidoc-asciidoc*
+
+Name:        asciidoc
+Maintainer:  LCD 47 <lcd047@gmail.com>
+
+"Asciidoc" is a translator for AsciiDoc documents (http://asciidoc.org/).
+
+Note~
+
+If you would prefer to use Asciidoctor (http://asciidoctor.org/) as an
+external checker instead of "Asciidoc", you can do that by pointing
+'g:syntastic_asciidoc_asciidoc_exec' to it: >
+    let g:syntastic_asciidoc_asciidoc_exec = "asciidoctor"
+<
+Checker options~
+
+This checker is initialised using the "makeprgBuild()" function and thus it
+accepts the standard options described at |syntastic-config-makeprg|.
+
+==============================================================================
+SYNTAX CHECKERS FOR ASSEMBLY LANGUAGES                *syntastic-checkers-asm*
+
+The following checkers are available for assembly languages (filetype "asm"):
+
+    1. GCC......................|syntastic-asm-gcc|
+
+------------------------------------------------------------------------------
+1. GCC                                                     *syntastic-asm-gcc*
+
+Name:        gcc
+Maintainer:  Joshua Rahm <joshuarahm@gmail.com>
+
+This plugin supports both the AT&T and Intel dialects.
+
+Checker Options~
+                                                  *'g:syntastic_asm_compiler'*
+Type: string
+Default: "gcc"
+Compiler executable. Set it to something like "mipsel-linux-gcc": >
+    let g:syntastic_asm_compiler = "mipsel-linux-gcc"
+<
+                                               *'g:syntastic_asm_errorformat'*
+Type: string
+Default: unset
+Override for the default |'errorformat'|.
+
+                                                   *'g:syntastic_asm_dialect'*
+Type: string
+Default: unset
+Normally the assembler will select the dialect to use for checking based on
+the file extension (AT&T for ".s", Intel for ".asm"). If you want to override
+the automatic choice set this variable to either "att" or "intel".
+
+                                     *'g:syntastic_asm_remove_include_errors'*
+Type: boolean
+Default: 0
+By default, errors in files included from the file being checked are shown.
+Set this variable to 1 to remove messages about errors in included files.
+Please note that this means syntastic will silently abort checks if there are
+fatal errors in one of the included files.
+
+                                          *'g:syntastic_asm_compiler_options'*
+Type: string
+Default: unset
+Compilation flags (such as defines or include directories) to be passed to the
+assembler. Set it to something like "-mtune=native": >
+    let g:syntastic_asm_compiler_options = "-mtune=native"
+<
+                                               *'g:syntastic_asm_config_file'*
+Type: string
+Default: ".syntastic_asm_config"
+File containing additional compilation flags to be passed to the assembler,
+one option per line (see |syntastic-config-files|).
+
+                                              *'g:syntastic_asm_include_dirs'*
+Type: array of strings
+Default: []
+Include directories to be passed to the assembler, in addition to the
+above compilation flags. You can set it like this: >
+    let g:syntastic_asm_include_dirs = ["inc", "asm/src/include"]
+<
+and the corresponding "-Iinc -Iasm/src/include" will be added to the
+compilation flags.
+
+                                                    *'b:syntastic_asm_cflags'*
+Type: string
+Default: unset
+Buffer-local variable. Additional compilation flags specific to the current
+buffer.
+
+Note~
+
+This checker doesn't call the "makeprgBuild()" function, and thus it ignores
+the usual 'g:syntastic_asm_gcc_<option>' variables. The only exception is
+'g:syntastic_asm_gcc_exec', which can still be used to override the checker's
+executable.
+
+==============================================================================
+SYNTAX CHECKERS FOR BEMHTML                       *syntastic-checkers-bemhtml*
+
+The following checkers are available for BEMHTML (filetype "bemhtml"):
+
+    1. bemhtml-lint.............|syntastic-bemhtml-bemhtmllint|
+
+------------------------------------------------------------------------------
+1. bemhtml-lint                                *syntastic-bemhtml-bemhtmllint*
+
+Name:        bemhtmllint
+Maintainer:  Sergej Tatarincev
+
+BEMHTML is a template engine intended for using with the BEM methodology
+(http://bem.info/method/). See the project's page at GitHub for details:
+
+    https://github.com/SevInf/bemhtml-lint
+
+Checker options~
+
+This checker is initialised using the "makeprgBuild()" function and thus it
+accepts the standard options described at |syntastic-config-makeprg|.
+
+==============================================================================
+SYNTAX CHECKERS FOR BRO                               *syntastic-checkers-bro*
+
+The following checkers are available for Bro (filetype "bro"):
+
+    1. Bro......................|syntastic-bro-bro|
+
+------------------------------------------------------------------------------
+1. Bro                                                     *syntastic-bro-bro*
+
+Name:        bro
+Maintainer:  Justin Azoff <justin.azoff@gmail.com>
+
+"Bro" is a network security monitor. See the project's page for details:
+
+    https://www.bro.org/
+
+Checker options~
+
+This checker is initialised using the "makeprgBuild()" function and thus it
+accepts the standard options described at |syntastic-config-makeprg|.
+
+==============================================================================
+SYNTAX CHECKERS FOR C                                   *syntastic-checkers-c*
+
+The following checkers are available for C (filetype "c"):
+
+    1. AVR-GCC..................|syntastic-c-avrgcc|
+    2. Checkpatch...............|syntastic-c-checkpatch|
+    3. ClangCheck...............|syntastic-c-clang_check|
+    4. Clang-Tidy...............|syntastic-c-clang_tidy|
+    5. Cppcheck.................|syntastic-c-cppcheck|
+    6. GCC......................|syntastic-c-gcc|
+    7. make.....................|syntastic-c-make|
+    8. OClint...................|syntastic-c-oclint|
+    9. PC-Lint..................|syntastic-c-pc_lint|
+    10. Sparse..................|syntastic-c-sparse|
+    11. Splint..................|syntastic-c-splint|
+
+------------------------------------------------------------------------------
+1. AVR-GCC                                                *syntastic-c-avrgcc*
+
+Name:        avrgcc
+Maintainer:  Karel <karelishere@gmail.com>
+
+Checker options~
+
+This checker is initialised using the "makeprgBuild()" function and thus it
+accepts the standard options described at |syntastic-config-makeprg|.
+
+Additionally:
+
+                                            *'g:syntastic_avrgcc_config_file'*
+Type: string
+Default: ".syntastic_avrgcc_config"
+File containing compilation flags (such as defines or include directories),
+one option per line (cf. |syntastic-config-files|).
+
+------------------------------------------------------------------------------
+2. Checkpatch                                         *syntastic-c-checkpatch*
+
+Name:        checkpatch
+Maintainer:  Daniel Walker <dwalker@fifo99.com>
+
+"Checkpatch" is a style checker for the Linux kernel sources. It's
+distributed along with the Linux kernel sources:
+
+    https://github.com/torvalds/linux/blob/master/scripts/checkpatch.pl
+
+Checker options~
+
+This checker is initialised using the "makeprgBuild()" function and thus it
+accepts the standard options described at |syntastic-config-makeprg|.
+
+------------------------------------------------------------------------------
+3. ClangCheck                                        *syntastic-c-clang_check*
+
+Name:        clang_check
+Maintainer:  Benjamin Bannier <bbannier@gmail.com>
+
+"ClangCheck" is a wrapper around Clang's "LibTooling"
+(http://clang.llvm.org/docs/LibTooling.html). See the official page for
+details:
+
+    http://clang.llvm.org/docs/ClangCheck.html
+
+Checker options~
+
+This checker is initialised using the "makeprgBuild()" function and thus it
+accepts the standard options described at |syntastic-config-makeprg|.
+
+Additionally:
+
+                                       *'g:syntastic_clang_check_config_file'*
+Type: string
+Default: ".syntastic_clang_check_config"
+File containing compilation flags (such as defines or include directories),
+one option per line (cf. |syntastic-config-files|).
+
+Note~
+
+By default you can set "ClangCheck" parameters in
+'g:syntastic_c_clang_check_args', and compilation parameters
+(defines, optimisation flags, etc.) in the configuration file.
+
+However, if you want "ClangCheck" to use compilation databases
+(http://clang.llvm.org/docs/JSONCompilationDatabase.html) -- perhaps
+generated by "CMake" (https://github.com/rizsotto/Bear) or "Build EAR"
+(https://github.com/rizsotto/Bear) -- rather than pass compilation flags
+explicitly, set 'g:syntastic_c_clang_check_post_args' to an empty string: >
+    let g:syntastic_c_clang_check_post_args = ""
+<
+Configuration files pointed to by 'g:syntastic_clang_check_config_file' are
+then ignored.
+
+See also: |syntastic-cpp-clang_check|.
+
+------------------------------------------------------------------------------
+4. Clang-Tidy                                         *syntastic-c-clang_tidy*
+
+Name:        clang_tidy
+Maintainer:  Benjamin Bannier <bbannier@gmail.com>
+
+"Clang-Tidy" is a lint tool based on "Clang" (http://clang.llvm.org/). See
+the project's page for details:
+
+    http://clang.llvm.org/extra/clang-tidy.html
+
+Installation~
+
+"Clang-Tidy" is part of the "Clang" (http://clang.llvm.org/) project, but it
+isn't built by default. You need to enable compilation of the "Extra Clang
+Tools" (http://clang.llvm.org/docs/ClangTools.html#extra-clang-tools) to get
+it. See the build tutorial for details:
+
+    http://clang.llvm.org/docs/LibASTMatchersTutorial.html
+
+Checker options~
+
+This checker is initialised using the "makeprgBuild()" function and thus it
+accepts the standard options described at |syntastic-config-makeprg|.
+
+Additionally:
+
+                                        *'g:syntastic_clang_tidy_config_file'*
+Type: string
+Default: ".syntastic_clang_tidy_config"
+File containing compilation flags (such as defines or include directories),
+one option per line (cf. |syntastic-config-files|).
+
+Note~
+
+By default you can set "ClangTidy" parameters in
+'g:syntastic_c_clang_tidy_args', and compilation parameters
+(defines, optimisation flags, etc.) in the configuration file.
+
+If you want "ClangTidy" to use compilation databases
+(http://clang.llvm.org/docs/JSONCompilationDatabase.html) --
+perhaps generated by "CMake" (http://cmake.org/) or "Build EAR"
+(https://github.com/rizsotto/Bear) -- rather than pass compilation flags
+explicitly, set 'g:syntastic_c_clang_tidy_post_args' to an empty string: >
+    let g:syntastic_c_clang_tidy_post_args = ""
+<
+Configuration files pointed to by 'g:syntastic_clang_tidy_config_file' are
+then ignored.
+
+See also: |syntastic-cpp-clang_tidy|.
+
+------------------------------------------------------------------------------
+5. Cppcheck                                             *syntastic-c-cppcheck*
+
+Name:        cppcheck
+Maintainer:  LCD 47 <lcd047@gmail.com>
+
+"Cppcheck" is a static analysis tool for C/C++ code. See the project's page
+for details:
+
+    http://cppcheck.sourceforge.net/
+
+Checker options~
+
+This checker is initialised using the "makeprgBuild()" function and thus it
+accepts the standard options described at |syntastic-config-makeprg|.
+
+Additionally:
+
+                                          *'g:syntastic_cppcheck_config_file'*
+Type: string
+Default: ".syntastic_cppcheck_config"
+File containing compilation flags (such as defines or include directories),
+one option per line (cf. |syntastic-config-files|).
+
+See also: |syntastic-cpp-cppcheck|.
+
+------------------------------------------------------------------------------
+6. GCC                                                       *syntastic-c-gcc*
+
+Name:        gcc
+Maintainer:  Gregor Uhlenheuer <kongo2002@gmail.com>
+
+Checker options~
+                                                    *'g:syntastic_c_compiler'*
+Type: string
+Default: "gcc", or "clang" if GCC is not found
+Compiler executable.
+
+                                                 *'g:syntastic_c_errorformat'*
+Type: string
+Default: unset
+Override for the default |'errorformat'|.
+
+                                       *'g:syntastic_c_remove_include_errors'*
+Type: boolean
+Default: 0
+By default, errors in files included from the file being checked are shown.
+Set this variable to 1 to remove messages about errors in included files.
+Please note that this means syntastic will silently abort checks if there are
+fatal errors in one of the included files.
+
+                                            *'g:syntastic_c_compiler_options'*
+Type: string
+Default: "-std=gnu99"
+Compilation flags (such as defines or include directories) to be passed to the
+checker.
+
+                                                 *'g:syntastic_c_config_file'*
+Type: string
+Default: ".syntastic_c_config"
+File containing additional compilation flags to be passed to the checker, one
+option per line (cf. |syntastic-config-files|).
+
+                                                *'g:syntastic_c_include_dirs'*
+Type: array of strings
+Default: []
+Include directories to be passed to the checker, in addition to the above
+compilation flags. You can set it to something like this: >
+    let g:syntastic_c_include_dirs = ["includes", "headers"]
+<
+and the corresponding "-Iincludes -Iheaders" will be added to the compilation
+flags.
+
+                                     *'g:syntastic_c_no_default_include_dirs'*
+Type: boolean
+Default: 0
+By default syntastic adds a number of common include directories to the
+compilation flags, namely: >
+    -I. -I.. -Iinclude -Iincludes -I../include -I../includes
+<
+You can disable this behaviour by setting the above variable to 1.
+
+                                           *'g:syntastic_c_no_include_search'*
+Type: boolean
+Default: 0
+By default syntastic looks at the first 100 lines of the file being checked,
+and tries to determine if it needs to include headers for some common
+libraries, such as "GLib" or "Gtk". It then tries to add the corresponding
+include directories to the compilation flags. You can disable this behaviour
+by setting the above variable to 1.
+
+                                       *'g:syntastic_c_auto_refresh_includes'*
+Type: boolean
+Default: 0
+Used only if "g:syntastic_c_no_include_search" is set to a false value. By
+default syntastic searches for common libraries only the first time the
+current file is checked. Setting the above variable to 1 instructs syntastic
+to refresh the list of common libraries every time the current file is
+checked. You can also force a refresh even when the above variable is 0, by
+`:unlet`-ing the buffer variable 'b:syntastic_c_includes'.
+
+                                                      *'b:syntastic_c_cflags'*
+Type: string
+Default: unset
+Buffer-local variable. When set, no search for common libraries is performed,
+and the contents of the variable are added to the compilation flags.
+
+                                                *'g:syntastic_c_check_header'*
+Type: boolean
+Default: 0
+If the current file is a header (namely if its extension is "h"), all checks
+are silently skipped. You can force syntastic to check header files by
+setting the above variable to 1.
+
+Note~
+
+This checker doesn't call the "makeprgBuild()" function, and thus it ignores
+the usual 'g:syntastic_c_gcc_<option>' variables. The only exception is
+'g:syntastic_c_gcc_exec', which can still be used to override the checker's
+executable.
+
+See also: |syntastic-cpp-gcc|.
+
+------------------------------------------------------------------------------
+7. make                                                     *syntastic-c-make*
+
+Name:        make
+Maintainer:  Gregor Uhlenheuer <kongo2002@gmail.com>
+
+Checker options~
+
+This checker is initialised using the "makeprgBuild()" function and thus it
+accepts the standard options described at |syntastic-config-makeprg|.
+
+------------------------------------------------------------------------------
+8. OClint                                                 *syntastic-c-oclint*
+
+Name:        oclint
+Maintainer:  "UnCO" Lin <undercooled@lavabit.com>
+
+"OClint" is a static code analysis tool. See the project's page for details:
+
+    http://oclint.org/
+
+Checker options~
+
+This checker is initialised using the "makeprgBuild()" function and thus it
+accepts the standard options described at |syntastic-config-makeprg|.
+
+Additionally:
+
+                                            'g:syntastic_oclint_config_file'
+Type: string
+Default: ".syntastic_oclint_config"
+File containing compilation flags (such as defines or include directories),
+one option per line (cf. |syntastic-config-files|).
+
+Notes~
+
+By default you can set "OClint" parameters in 'g:syntastic_c_oclint_args', and
+compilation parameters (defines, optimisation flags, etc.) in the config file.
+
+If you want "OClint" to use "Clang"-style compilation databases
+(http://clang.llvm.org/docs/JSONCompilationDatabase.html) --
+perhaps generated by "CMake" (http://cmake.org/) or "Build EAR"
+(https://github.com/rizsotto/Bear) -- rather than pass compilation flags
+explicitly, set 'g:syntastic_c_oclint_post_args' to an empty string: >
+    let g:syntastic_c_oclint_post_args = ""
+<
+Config files pointed to by 'g:syntastic_oclint_config_file' are then ignored.
+
+See also: |syntastic-cpp-oclint|.
+
+------------------------------------------------------------------------------
+9. PC-Lint                                               *syntastic-c-pc_lint*
+
+Name:        pc_lint
+Maintainer:  Steve Bragg <steve@empresseffects.com>
+
+"PC-Lint" is a commercial static code analysis tool for Windows, produced
+by "Gimpel Software" (http://www.gimpel.com/). See the project's page for
+details:
+
+    http://www.gimpel.com/html/pcl.htm
+
+Checker options~
+
+This checker is initialised using the "makeprgBuild()" function and thus it
+accepts the standard options described at |syntastic-config-makeprg|.
+
+Additionally:
+
+                                           *'g:syntastic_pc_lint_config_file'*
+Type: string
+Default: "options.lnt"
+Name of an indirect (.lnt) file. A file with that name is looked up in the
+current directory and in parent directories; first such file found is used.
+
+See also: |syntastic-cpp-pc_lint|.
+
+------------------------------------------------------------------------------
+10. Sparse                                                *syntastic-c-sparse*
+
+Name:        sparse
+Maintainer:  Daniel Walker <dwalker@fifo99.com>
+
+"Sparse" is a semantic parser for C, see the official wiki for details:
+
+    https://sparse.wiki.kernel.org/index.php/Main_Page
+
+Checker options~
+
+This checker is initialised using the "makeprgBuild()" function and thus it
+accepts the standard options described at |syntastic-config-makeprg|.
+
+Additionally:
+
+                                            *'g:syntastic_sparse_config_file'*
+Type: string
+Default: ".syntastic_sparse_config"
+File containing compilation flags (such as defines or include directories),
+one option per line (cf. |syntastic-config-files|).
+
+Notes~
+
+If you use "Sparse" with "GCC" you probably want to add something like this to
+your vimrc: >
+    let g:syntastic_c_sparse_post_args="-gcc-base-dir " .
+        \ system("gcc -v 2>&1 | sed -n '/^Reading specs/ { s#.* /#/#; s#/[^/]*$##; p; }'")
+<
+This allows "Sparse" to read "GCC"'s private include files.
+
+------------------------------------------------------------------------------
+11. Splint                                                *syntastic-c-splint*
+
+Name:        splint
+Maintainer:  LCD 47 <lcd047@gmail.com>
+
+"Splint" is a tool for statically checking C programs for security
+vulnerabilities, see the project's page for details:
+
+    http://www.splint.org/
+
+Checker options~
+
+This checker is initialised using the "makeprgBuild()" function and thus it
+accepts the standard options described at |syntastic-config-makeprg|.
+
+Additionally:
+
+                                            *'g:syntastic_splint_config_file'*
+Type: string
+Default: ".syntastic_splint_config"
+File containing project-specific options to be passed to "Splint"
+(such as defines or include directories), one option per line (cf.
+|syntastic-config-files|).
+
+==============================================================================
+SYNTAX CHECKERS FOR C#                                 *syntastic-checkers-cs*
+
+The following checkers are available for C# (filetype "cs"):
+
+    1. mcs......................|syntastic-cs-mcs|
+
+------------------------------------------------------------------------------
+1. mcs                                                      *syntastic-cs-mcs*
+
+Name:        mcs
+Maintainer:  Daniel Walker <dwalker@fifo99.com>
+
+"mcs" is a compiler for C# from the "Mono" project
+(http://www.mono-project.com/Main_Page). See the program's manual for details:
+
+    http://mono.wikia.com/wiki/Man_mcs
+
+Checker options~
+
+This checker is initialised using the "makeprgBuild()" function and thus it
+accepts the standard options described at |syntastic-config-makeprg|.
+
+==============================================================================
+SYNTAX CHECKERS FOR C++                               *syntastic-checkers-cpp*
+
+The following checkers are available for C++ (filetype "cpp"):
+
+    1. AVR-GCC..................|syntastic-cpp-avrgcc|
+    2. ClangCheck...............|syntastic-cpp-clang_check|
+    3. Clang-Tidy...............|syntastic-cpp-clang_tidy|
+    4. Cppcheck.................|syntastic-cpp-cppcheck|
+    5. Cpplint..................|syntastic-cpp-cpplint|
+    6. GCC......................|syntastic-cpp-gcc|
+    7. OClint...................|syntastic-cpp-oclint|
+    8. PC-Lint..................|syntastic-cpp-pc_lint|
+    9. Vera++...................|syntastic-cpp-verapp|
+
+------------------------------------------------------------------------------
+1. AVR-GCC                                              *syntastic-cpp-avrgcc*
+
+Name:        avrgcc
+Maintainer:  Sławek Piotrowski <sentinel@atteo.com>
+
+Checker options~
+
+This checker is initialised using the "makeprgBuild()" function and thus it
+accepts the standard options described at |syntastic-config-makeprg|.
+
+Additionally:
+
+                                            'g:syntastic_avrgcc_config_file'
+Type: string
+Default: ".syntastic_avrgcc_config"
+File containing compilation flags (such as defines or include directories),
+one option per line (cf. |syntastic-config-files|).
+
+See also: |syntastic-c-avrgcc|.
+
+------------------------------------------------------------------------------
+2. ClangCheck                                      *syntastic-cpp-clang_check*
+
+Name:        clang_check
+Maintainer:  Benjamin Bannier <bbannier@gmail.com>
+
+"ClangCheck" is a wrapper around Clang's "LibTooling"
+(http://clang.llvm.org/docs/LibTooling.html). See the official page for
+details:
+
+    http://clang.llvm.org/docs/ClangCheck.html
+
+Checker options~
+
+This checker is initialised using the "makeprgBuild()" function and thus it
+accepts the standard options described at |syntastic-config-makeprg|.
+
+Additionally:
+
+                                       'g:syntastic_clang_check_config_file'
+Type: string
+Default: ".syntastic_clang_check_config"
+file containing compilation flags (such as defines or include directories),
+one option per line (cf. |syntastic-config-files|).
+
+Note~
+
+By default you can set "ClangCheck" parameters in
+'g:syntastic_cpp_clang_check_args', and compilation parameters (defines,
+optimisation flags, etc.) in the configuration file.
+
+However, if you want "ClangCheck" to use compilation databases
+(http://clang.llvm.org/docs/JSONCompilationDatabase.html) -- perhaps
+generated by "CMake" (https://github.com/rizsotto/Bear) or "Build EAR"
+(https://github.com/rizsotto/Bear) -- rather than pass compilation flags
+explicitly, set 'g:syntastic_cpp_clang_check_post_args' to an empty string: >
+    let g:syntastic_cpp_clang_check_post_args = ""
+<
+Configuration files pointed to by 'g:syntastic_clang_check_config_file' are
+then ignored.
+
+See also: |syntastic-c-clang_check|.
+
+------------------------------------------------------------------------------
+3. Clang-Tidy                                       *syntastic-cpp-clang_tidy*
+
+Name:        clang_tidy
+Maintainer:  Benjamin Bannier <bbannier@gmail.com>
+
+"Clang-Tidy" is a lint tool based on "Clang" (http://clang.llvm.org/). See
+the project's page for details:
+
+    http://clang.llvm.org/extra/clang-tidy.html
+
+Installation~
+
+"Clang-Tidy" is part of the "Clang" (http://clang.llvm.org/) project, but it
+isn't built by default. You need to enable compilation of the "Extra Clang
+Tools" (http://clang.llvm.org/docs/ClangTools.html#extra-clang-tools) to get
+it. See the build tutorial for details:
+
+    http://clang.llvm.org/docs/LibASTMatchersTutorial.html
+
+Checker options~
+
+This checker is initialised using the "makeprgBuild()" function and thus it
+accepts the standard options described at |syntastic-config-makeprg|.
+
+Additionally:
+
+                                        'g:syntastic_clang_tidy_config_file'
+Type: string
+Default: ".syntastic_clang_tidy_config"
+File containing compilation flags (such as defines or include directories),
+one option per line (cf. |syntastic-config-files|).
+
+Note~
+
+By default you can set "ClangTidy" parameters in
+'g:syntastic_ppc_clang_tidy_args', and compilation parameters (defines,
+optimisation flags, etc.) in the configuration file.
+
+If you want "ClangTidy" to use compilation databases
+(http://clang.llvm.org/docs/JSONCompilationDatabase.html) --
+perhaps generated by "CMake" (http://cmake.org/) or "Build EAR"
+(https://github.com/rizsotto/Bear) -- rather than pass compilation flags
+explicitly, set 'g:syntastic_cpp_clang_tidy_post_args' to an empty string: >
+    let g:syntastic_cpp_clang_tidy_post_args = ""
+<
+Configuration files pointed to by 'g:syntastic_clang_tidy_config_file' are
+then ignored.
+
+See also: |syntastic-c-clang_tidy|.
+
+------------------------------------------------------------------------------
+4. Cppcheck                                           *syntastic-cpp-cppcheck*
+
+Name:        cppcheck
+Maintainer:  LCD 47 <lcd047@gmail.com>
+
+"Cppcheck" is a static analysis tool for C/C++ code. See the project's page
+for details:
+
+    http://cppcheck.sourceforge.net/
+
+Checker options~
+
+This checker is initialised using the "makeprgBuild()" function and thus it
+accepts the standard options described at |syntastic-config-makeprg|.
+
+Additionally:
+
+                                          'g:syntastic_cppcheck_config_file'
+Type: string
+Default: ".syntastic_cppcheck_config"
+File containing compilation flags (such as defines or include directories),
+one option per line (cf. |syntastic-config-files|).
+
+See also: |syntastic-c-cppcheck|.
+
+------------------------------------------------------------------------------
+5. Cpplint                                             *syntastic-cpp-cpplint*
+
+Name:        cpplint
+Maintainer:  LCD 47 <lcd047@gmail.com>
+
+For details about "Cpplint" see the project's page:
+
+    https://code.google.com/p/google-styleguide/
+
+Checker options~
+
+This checker is initialised using the "makeprgBuild()" function and thus it
+accepts the standard options described at |syntastic-config-makeprg|.
+
+Additionally:
+
+                                             *'g:syntastic_cpp_cpplint_thres'*
+Type: integer
+Default: 5
+Error threshold. Policy violations with a severity above this value are
+highlighted as errors, the others are considered warnings by syntastic.
+
+                                              *'g:syntastic_cpp_cpplint_args'*
+Type: string
+Default: "--verbose=3"
+Command line options to pass to "Cpplint"
+
+Note~
+
+By default syntastic expects the "cpplint" script to be named "cpplint.py".
+However, if your "cpplint" was installed with "pip", the script's name is
+"cpplint", and you need to set 'g:syntastic_cpp_cpplint_exec' accordingly:
+>
+    let g:syntastic_cpp_cpplint_exec = "cpplint"
+<
+------------------------------------------------------------------------------
+6. GCC                                                     *syntastic-cpp-gcc*
+
+Name:        gcc
+Maintainer:  Gregor Uhlenheuer <kongo2002@gmail.com>
+
+Checker options~
+                                                  *'g:syntastic_cpp_compiler'*
+Type: string
+Default: "g++", or "clang++" if GCC is not found
+Compiler executable.
+
+                                               *'g:syntastic_cpp_errorformat'*
+Type: string
+Default: unset
+Override for the default |'errorformat'|.
+
+                                     *'g:syntastic_cpp_remove_include_errors'*
+Type: boolean
+Default: 0
+By default, errors in files included from the file being checked are shown.
+Set this variable to 1 to remove messages about errors in included files.
+Please note that this means syntastic will silently abort checks if there are
+fatal errors in one of the included files.
+
+                                          *'g:syntastic_cpp_compiler_options'*
+Type: string
+Default: unset
+Compilation flags (such as defines or include directories) to be passed to the
+checker.
+
+                                               *'g:syntastic_cpp_config_file'*
+Type: string
+Default: ".syntastic_cpp_config"
+File containing additional compilation flags to be passed to the checker, one
+option per line (cf. |syntastic-config-files|).
+
+                                              *'g:syntastic_cpp_include_dirs'*
+Type: array of strings
+Default: []
+Include directories to be passed to the checker, in addition to the above
+compilation flags. You can set it to something like this: >
+    let g:syntastic_cpp_include_dirs = ["includes", "headers"]
+>
+and the corresponding "-Iincludes -Iheaders" will be added to the compilation
+flags.
+
+                                   *'g:syntastic_cpp_no_default_include_dirs'*
+Type: boolean
+Default: 0
+By default syntastic adds a number of common include directories to the
+compilation flags, namely: >
+    -I. -I.. -Iinclude -Iincludes -I../include -I../includes
+<
+You can disable this behaviour by setting the above variable to 1.
+
+                                         *'g:syntastic_cpp_no_include_search'*
+Type: boolean
+Default: 0
+By default syntastic looks at the first 100 lines of the file being checked,
+and tries to determine if it needs to include headers for some common
+libraries, such as "GLib" or "Gtk". It then tries to add the corresponding
+include directories to the compilation flags. You can disable this behaviour
+by setting the above variable to 1.
+
+                                     *'g:syntastic_cpp_auto_refresh_includes'*
+Type: boolean
+Default: 0
+Used only if "g:syntastic_cpp_no_include_search" is set to a false value.
+By default syntastic searches for common libraries only the first time the
+current file is checked. Setting the above variable to 1 instructs syntastic
+to refresh the list of common libraries every time the current file is
+checked. You can also force a refresh even when the above variable is 0, by
+`:unlet`-ing the buffer variable 'b:syntastic_cpp_includes'.
+
+                                                    *'b:syntastic_cpp_cflags'*
+Type: string
+Default: unset
+Buffer-local variable. When set, no search for common libraries is performed,
+and the contents of the variable are added to the compilation flags.
+
+                                              *'g:syntastic_cpp_check_header'*
+Type: boolean
+Default: 0
+If the current file is a header (namely if its extension is "h", "hpp", or
+"hh"), all checks are silently skipped. You can force syntastic to check
+header files by setting the above variable to 1.
+
+Note~
+
+This checker doesn't call the "makeprgBuild()" function, and thus it ignores
+the usual 'g:syntastic_cpp_gcc_<option>' variables. The only exception is
+'g:syntastic_cpp_gcc_exec', which can still be used to override the checker's
+executable.
+
+See also: |syntastic-c-gcc|.
+
+------------------------------------------------------------------------------
+7. OClint                                               *syntastic-cpp-oclint*
+
+Name:        oclint
+Maintainer:  "UnCO" Lin <undercooled@lavabit.com>
+
+"OClint" is a static code analysis tool. See the project's page for details:
+
+    http://oclint.org/
+
+Checker options~
+
+This checker is initialised using the "makeprgBuild()" function and thus it
+accepts the standard options described at |syntastic-config-makeprg|.
+
+Additionally:
+
+                                            'g:syntastic_oclint_config_file'
+Type: string
+Default: ".syntastic_oclint_config"
+File containing compilation flags (such as defines or include directories),
+one option per line (cf. |syntastic-config-files|).
+
+Notes~
+
+By default you can set "OClint" parameters in 'g:syntastic_cpp_oclint_args',
+and compilation parameters (defines, optimisation flags, etc.) in the config
+file.
+
+If you want "OClint" to use "Clang"-style compilation databases
+(http://clang.llvm.org/docs/JSONCompilationDatabase.html) --
+perhaps generated by "CMake" (http://cmake.org/) or "Build EAR"
+(https://github.com/rizsotto/Bear) -- rather than pass compilation flags
+explicitly, set 'g:syntastic_c_oclint_post_args' to an empty string: >
+    let g:syntastic_cpp_oclint_post_args = ""
+<
+Config files pointed to by 'g:syntastic_oclint_config_file' are then ignored.
+
+See also: |syntastic-c-oclint|.
+
+------------------------------------------------------------------------------
+8. PC-Lint                                             *syntastic-cpp-pc_lint*
+
+Name:        pc_lint
+Maintainer:  Steve Bragg <steve@empresseffects.com>
+
+"PC-Lint" is a commercial static code analysis tool for Windows, produced
+by "Gimpel Software" (http://www.gimpel.com/). See the project's page for
+details:
+
+    http://www.gimpel.com/html/pcl.htm
+
+Checker options~
+
+This checker is initialised using the "makeprgBuild()" function and thus it
+accepts the standard options described at |syntastic-config-makeprg|.
+
+Additionally:
+
+                                           'g:syntastic_pc_lint_config_file'
+Type: string
+Default: "options.lnt"
+Name of an indirect (.lnt) file. A file with that name is looked up in the
+current directory and in parent directories; first such file found is used.
+
+See also: |syntastic-c-pc_lint|.
+
+------------------------------------------------------------------------------
+9. Vera++                                               *syntastic-cpp-verapp*
+
+Name:        verapp
+Maintainer:  Lucas Verney <phyks@phyks.me>
+
+"Vera++" is a programmable tool for verification, analysis and transformation
+of C++ source code. See the project's page for details:
+
+    https://bitbucket.org/verateam/vera/wiki/Home
+
+Checker options~
+
+This checker is initialised using the "makeprgBuild()" function and thus it
+accepts the standard options described at |syntastic-config-makeprg|.
+
+Additionally:
+
+                                            *'g:syntastic_verapp_config_file'*
+Type: string
+Default: ".syntastic_verapp_config"
+File containing additional compilation flags to be passed to the checker, one
+option per line (cf. |syntastic-config-files|).
+
+==============================================================================
+SYNTAX CHECKERS FOR CABAL                           *syntastic-checkers-cabal*
+
+The following checkers are available for Cabal (filetype "cabal"):
+
+    1. Cabal....................|syntastic-cabal-cabal|
+
+------------------------------------------------------------------------------
+1. Cabal                                               *syntastic-cabal-cabal*
+
+Name:        cabal
+Maintainer:  Ian D. Bollinger <ian.bollinger@gmail.com>
+
+This checker runs "cabal check" against Haskell Cabal package descriptions.
+See the project's page for more information:
+
+    http://www.haskell.org/cabal/
+
+Note~
+
+This checker doesn't call the "makeprgBuild()" function, and thus it ignores
+the usual 'g:syntastic_cabal_cabal_<option>' variables. The only exception
+is 'g:syntastic_cabal_cabal_exec', which can still be used to override the
+checker's executable.
+
+==============================================================================
+SYNTAX CHECKERS FOR CHEF                             *syntastic-checkers-chef*
+
+The following checkers are available for Chef (filetype "chef"):
+
+    1. Foodcritic...............|syntastic-chef-foodcritic|
+
+------------------------------------------------------------------------------
+1. Foodcritic                                      *syntastic-chef-foodcritic*
+
+Name:        foodcritic
+Maintainer:  Doug Ireton
+
+"Foodcritic" is a linter for "Chef" cookbooks (http://www.opscode.com/chef/).
+See the project's page for more information:
+
+    http://acrmp.github.io/foodcritic/
+
+Checker options~
+
+This checker is initialised using the "makeprgBuild()" function and thus it
+accepts the standard options described at |syntastic-config-makeprg|.
+
+Note~
+
+You probably also need a plugin to set |filetype| for Chef files, such as
+"vim-chef":
+
+    https://github.com/dougireton/vim-chef
+
+==============================================================================
+SYNTAX CHECKERS FOR COBOL                           *syntastic-checkers-cobol*
+
+The following checkers are available for COBOL (filetype "cobol"):
+
+    1. OpenCOBOL................|syntastic-cobol-cobc|
+
+------------------------------------------------------------------------------
+1. OpenCOBOL                                            *syntastic-cobol-cobc*
+
+Name:        cobc
+Maintainer:  LCD 47 <lcd047@gmail.com>
+
+"OpenCOBOL" is a compiler for COBOL. See the project's page for more
+information:
+
+    http://www.opencobol.org/
+
+Checker options~
+                                                *'g:syntastic_cobol_compiler'*
+Type: string
+Default: "cobc"
+Compiler executable.
+
+                                             *'g:syntastic_cobol_errorformat'*
+Type: string
+Default: unset
+Override for the default |'errorformat'|.
+
+                                   *'g:syntastic_cobol_remove_include_errors'*
+Type: boolean
+Default: 0
+By default, errors in files included from the file being checked are shown.
+Set this variable to 1 to remove messages about errors in included files.
+Please note that this means syntastic will silently abort checks if there are
+fatal errors in one of the included files.
+
+                                        *'g:syntastic_cobol_compiler_options'*
+Type: string
+Default: unset
+Compilation flags (such as "-std=cobol2002") to be passed to the checker.
+
+                                             *'g:syntastic_cobol_config_file'*
+Type: string
+Default: ".syntastic_cobol_config"
+File containing additional compilation flags to be passed to the checker, one
+option per line (cf. |syntastic-config-files|).
+
+                                            *'g:syntastic_cobol_include_dirs'*
+Type: array of strings
+Default: []
+Include directories to be passed to the checker, in addition to the above
+compilation flags. You can set it to something like this: >
+    let g:syntastic_cobol_include_dirs = ["includes", "headers"]
+<
+and the corresponding "-Iincludes -Iheaders" will be added to the compilation
+flags.
+
+                                                  *'b:syntastic_cobol_cflags'*
+Type: string
+Default: unset
+Buffer-local variable. Additional compilation flags specific to the current
+buffer.
+
+Note~
+
+This checker doesn't call the "makeprgBuild()" function, and thus it ignores
+the usual 'g:syntastic_cobol_cobc_<option>' variables. The only exception
+is 'g:syntastic_cobol_cobc_exec', which can still be used to override the
+checker's executable.
+
+==============================================================================
+SYNTAX CHECKERS FOR COCO                               *syntastic-checkers-co*
+
+The following checkers are available for Coco (filetype "co"):
+
+    1. Coco.....................|syntastic-co-coco|
+
+------------------------------------------------------------------------------
+1. Coco                                                    *syntastic-co-coco*
+
+Name:        coco
+Maintainer:  Andrew Kelley <superjoe30@gmail.com>
+
+For details about "Coco" see the project's page:
+
+    https://github.com/satyr/coco/
+
+Checker options~
+
+This checker is initialised using the "makeprgBuild()" function and thus it
+accepts the standard options described at |syntastic-config-makeprg|.
+
+==============================================================================
+SYNTAX CHECKERS FOR COFFEESCRIPT                   *syntastic-checkers-coffee*
+
+The following checkers are available for CoffeeScript (filetype "coffee"):
+
+    1. Coffee...................|syntastic-coffee-coffee|
+    2. CoffeeLint...............|syntastic-coffee-coffeelint|
+
+------------------------------------------------------------------------------
+1. Coffee                                            *syntastic-coffee-coffee*
+
+Name:        coffee
+Maintainer:  Lincoln Stoll <l@lds.li>
+
+"Coffee" is a compiler for CoffeeScript. See the project's page for details:
+
+    http://coffeescript.org/
+
+Syntastic requires "Coffee" version 1.6.2 or later.
+
+Checker options~
+
+This checker is initialised using the "makeprgBuild()" function and thus it
+accepts the standard options described at |syntastic-config-makeprg|.
+
+------------------------------------------------------------------------------
+2. CoffeeLint                                    *syntastic-coffee-coffeelint*
+
+Name:        coffeelint
+Maintainer:  Lincoln Stoll <l@lds.li>
+
+"CoffeeLint" is a style checker for CoffeeScript. See the project's page for
+details:
+
+    http://www.coffeelint.org/
+
+Checker options~
+
+This checker is initialised using the "makeprgBuild()" function and thus it
+accepts the standard options described at |syntastic-config-makeprg|.
+
+==============================================================================
+SYNTAX CHECKERS FOR COQ                               *syntastic-checkers-coq*
+
+The following checkers are available for Coq (filetype "coq"):
+
+    1. Coqtop...................|syntastic-coq-coqtop|
+
+------------------------------------------------------------------------------
+1. Coqtop                                               *syntastic-coq-coqtop*
+
+Name:        coqtop
+Maintainer:  Matvey Aksenov <matvey.aksenov@gmail.com>
+
+"Coqtop" is the top level interface for Coq. See the project's page for
+details:
+
+    http://coq.inria.fr/
+
+Checker options~
+
+This checker is initialised using the "makeprgBuild()" function and thus it
+accepts the standard options described at |syntastic-config-makeprg|.
+
+==============================================================================
+SYNTAX CHECKERS FOR CSS                               *syntastic-checkers-css*
+
+The following checkers are available for CSS (filetype "css"):
+
+    1. CSSLint..................|syntastic-css-csslint|
+    2. mixedindentlint..........|syntastic-css-mixedindentlint|
+    3. PHP_CodeSniffer..........|syntastic-css-phpcs|
+    4. PrettyCSS................|syntastic-css-prettycss|
+    5. RECESS...................|syntastic-css-recess|
+    6. stylelint................|syntastic-css-stylelint|
+
+------------------------------------------------------------------------------
+1. CSSLint                                             *syntastic-css-csslint*
+
+Name:        csslint
+Maintainer:  Ory Band <oryband@gmail.com>
+
+"CSSLint" is a lint tool for Cascading Stylesheets. See the project's page
+for details:
+
+    http://csslint.net/
+
+Installation~
+
+Install it with "npm": >
+    npm install -g csslint
+<
+Checker options~
+
+This checker is initialised using the "makeprgBuild()" function and thus it
+accepts the standard options described at |syntastic-config-makeprg|.
+
+------------------------------------------------------------------------------
+2. mixedindentlint                             *syntastic-css-mixedindentlint*
+
+Name:        mixedindentlint
+Maintainer:  Payton Swick <payton@foolord.com>
+
+"mixedindentlint" is a general-purpose indentation checker. See the project's
+page at GitHub for more information:
+
+    https://github.com/sirbrillig/mixedindentlint
+
+Checker options~
+
+This checker is initialised using the "makeprgBuild()" function and thus it
+accepts the standard options described at |syntastic-config-makeprg|.
+
+See also: |syntastic-javascript-mixedindentlint|, |syntastic-scss-mixedindentlint|.
+
+------------------------------------------------------------------------------
+3. PHP_CodeSniffer                                       *syntastic-css-phpcs*
+
+Name:        phpcs
+Maintainer:  LCD 47 <lcd047@gmail.com>
+
+"PHP_CodeSniffer" is a style checker for PHP and CSS. See the project's page
+at GitHub for details:
+
+    https://github.com/squizlabs/PHP_CodeSniffer/
+
+Installation~
+
+Install it with: >
+    pear install PHP_CodeSniffer
+<
+Checker options~
+
+This checker is initialised using the "makeprgBuild()" function and thus it
+accepts the standard options described at |syntastic-config-makeprg|.
+
+Note~
+
+If you're checking files containing tab characters then "PHP_CodeSniffer"'s
+idea of tabstop must match Vim's 'tabstop', otherwise syntastic will highlight
+the errors at shifted positions. By default syntastic does that by adding
+an option "--tab-width=&tabstop" to "PHP_CodeSniffer", but that option
+also instructs "PHP_CodeSniffer" to expand tabs, and some code sniffers
+(f.i. "CakePHP", see https://github.com/cakephp/cakephp-codesniffer) insist on
+indenting lines with tabs. To work around the resulting mess if you're using
+one of these sniffers, set "--tab-width=0" and 'tabstop' to 8: >
+    let g:syntastic_php_phpcs_args = "--tab-width=0"
+    set tabstop=8
+<
+See also: |syntastic-php-phpcs|.
+
+------------------------------------------------------------------------------
+4. PrettyCSS                                         *syntastic-css-prettycss*
+
+Name:        prettycss
+Maintainer:  LCD 47 <lcd047@gmail.com>
+
+"PrettyCSS" is a beautifier, lint checker, and validator for Cascading
+Stylesheets. For more details see:
+
+PrettyCSS Demo:
+
+    http://fidian.github.io/PrettyCSS/
+
+The project's page at GitHub:
+
+    https://github.com/fidian/PrettyCSS/
+
+Installation~
+
+Install it with: >
+    npm install -g PrettyCSS
+<
+Checker options~
+
+This checker is initialised using the "makeprgBuild()" function and thus it
+accepts the standard options described at |syntastic-config-makeprg|.
+
+------------------------------------------------------------------------------
+5. RECESS                                               *syntastic-css-recess*
+
+Name:        recess
+Maintainer:  Tim Carry <tim@pixelastic.com>
+
+"RECESS" is a code quality tool for CSS built on top of LESS. See the
+project's page for details:
+
+    http://twitter.github.io/recess/
+
+Checker options~
+
+This checker is initialised using the "makeprgBuild()" function and thus it
+accepts the standard options described at |syntastic-config-makeprg|.
+
+See also: |syntastic-less-recess|.
+
+------------------------------------------------------------------------------
+6. stylelint                                         *syntastic-css-stylelint*
+
+Name:        stylelint
+Maintainer:  Tim Carry <tim@pixelastic.com>
+
+"stylelint" is a style checker for Cascading Stylesheets. See the project's
+page for more information:
+
+    http://stylelint.io/
+
+Checker options~
+
+This checker is initialised using the "makeprgBuild()" function and thus it
+accepts the standard options described at |syntastic-config-makeprg|.
+
+See also: |syntastic-scss-stylelint|.
+
+==============================================================================
+SYNTAX CHECKERS FOR CUCUMBER                     *syntastic-checkers-cucumber*
+
+The following checkers are available for Cucumber (filetype "cucumber"):
+
+    1. Cucumber.................|syntastic-cucumber-cucumber|
+
+------------------------------------------------------------------------------
+1. Cucumber                                      *syntastic-cucumber-cucumber*
+
+Name:        cucumber
+Maintainer:  Martin Grenfell <martin.grenfell@gmail.com>
+
+"Cucumber" is a tool that executes plain-text functional descriptions as
+automated tests. See the project's page for more information:
+
+    http://cukes.info/
+
+Checker options~
+
+This checker is initialised using the "makeprgBuild()" function and thus it
+accepts the standard options described at |syntastic-config-makeprg|.
+
+==============================================================================
+SYNTAX CHECKERS FOR CUDA                             *syntastic-checkers-cuda*
+
+The following checkers are available for CUDA (filetype "cuda"):
+
+    1. NVCC.....................|syntastic-cuda-nvcc|
+
+------------------------------------------------------------------------------
+1. NVCC                                                  *syntastic-cuda-nvcc*
+
+Name:        nvcc
+Author: Hannes Schulz <schulz@ais.uni-bonn.de>
+
+"NVCC" is a CUDA Compiler from nVidia. See the project's page for details:
+
+    https://developer.nvidia.com/cuda-llvm-compiler
+
+Checker options~
+
+This checker is initialised using the "makeprgBuild()" function and thus it
+accepts the standard options described at |syntastic-config-makeprg|.
+
+Additionally:
+
+                                             *'g:syntastic_cuda_check_header'*
+Type: boolean
+Default: 0
+Turn this on to check header files.  The checker then creates an empty file
+".syntastic_dummy.cu" in the base directory of the file being checked.
+Example: >
+    let g:syntastic_cuda_check_header = 1
+<
+                                              *'g:syntastic_cuda_config_file'*
+Type: string
+Default: ".syntastic_cuda_config"
+File containing additional compilation flags to be passed to the checker, one
+option per line (cf. |syntastic-config-files|).
+
+==============================================================================
+SYNTAX CHECKERS FOR D                                   *syntastic-checkers-d*
+
+The following checkers are available for D (filetype "d"):
+
+    1. DMD......................|syntastic-d-dmd|
+
+------------------------------------------------------------------------------
+1. DMD                                                       *syntastic-d-dmd*
+
+Name:        dmd
+Maintainer:  Alfredo Di Napoli <alfredo.dinapoli@gmail.com>
+
+Checker options~
+                                                    *'g:syntastic_d_compiler'*
+Type: string
+Default: "dmd"
+Compiler executable.
+
+                                                 *'g:syntastic_d_errorformat'*
+Type: string
+Default: unset
+Override for the default |'errorformat'|.
+
+                                       *'g:syntastic_d_remove_include_errors'*
+Type: boolean
+Default: 0
+By default, errors in files included from the file being checked are shown.
+Set this variable to 1 to remove messages about errors in included files.
+Please note that this means syntastic will silently abort checks if there are
+fatal errors in one of the included files.
+
+                                            *'g:syntastic_d_compiler_options'*
+Type: string
+Default: unset
+Compilation flags (such as defines or include directories) to be passed to the
+checker.
+
+                                                 *'g:syntastic_d_config_file'*
+Type: string
+Default: ".syntastic_d_config"
+File containing additional compilation flags to be passed to the checker, one
+option per line (cf. |syntastic-config-files|).
+
+                                                *'g:syntastic_d_include_dirs'*
+Type: array of strings
+Default: inferred from ".dub/packages"
+Include directories to be passed to the checker, in addition to the above
+compilation flags. You can set it like this: >
+    let g:syntastic_d_include_dirs = ["includes", "headers"]
+<
+and the corresponding "-Iincludes -Iheaders" will be added to the compilation
+flags.
+
+                                                     *'g:syntastic_d_use_dub'*
+Type: boolean
+Default: 1
+Whether to use "dub" to find include directories. This requires "dub" version
+0.9.24 or later.
+
+                                                    *'g:syntastic_d_dub_exec'*
+Type: string
+Default: "dub"
+Path to the "dub" executable. Ignored if |'g:syntastic_d_use_dub'| is unset.
+
+                                                      *'b:syntastic_d_cflags'*
+Type: string
+Default: unset
+Buffer-local variable. Additional compilation flags specific to the current
+buffer.
+
+                                                *'g:syntastic_d_check_header'*
+Type: boolean
+Default: 0
+If the current file is a header (namely if its extension is "di"), all checks
+are silently skipped. You can force syntastic to check header files by setting
+the above variable to 1.
+
+Note~
+
+This checker doesn't call the "makeprgBuild()" function, and thus it ignores
+the usual 'g:syntastic_d_dmd_<option>' variables. The only exception is
+'g:syntastic_d_dmd_exec', which can still be used to override the checker's
+executable.
+
+==============================================================================
+SYNTAX CHECKERS FOR DART                             *syntastic-checkers-dart*
+
+The following checkers are available for Dart (filetype "dart"):
+
+    1. Analyzer.................|syntastic-dart-dartanalyzer|
+
+------------------------------------------------------------------------------
+1. Analyzer                                      *syntastic-dart-dartanalyzer*
+
+Name:        dartanalyzer
+Maintainer:  Maksim Ryzhikov <rv.maksim@gmail.com>
+
+"Analyzer" is a static analysis tool for Dart (https://www.dartlang.org/).
+See the manual for more information:
+
+    https://www.dartlang.org/tools/analyzer/
+
+Checker options~
+
+This checker is initialised using the "makeprgBuild()" function and thus it
+accepts the standard options described at |syntastic-config-makeprg|.
+
+==============================================================================
+SYNTAX CHECKERS FOR DOCBOOK                         *syntastic-checkers-docbk*
+
+The following checkers are available for DocBook (filetype "docbk"):
+
+    1. Igor.....................|syntastic-docbk-igor|
+    2. xmllint..................|syntastic-docbk-xmllint|
+
+------------------------------------------------------------------------------
+1. Igor                                                 *syntastic-docbk-igor*
+
+Name:        igor
+Maintainer:  LCD 47 <lcd047@gmail.com>
+
+"Igor" is a proofreader for DocBook SGML, man pages, and text files used by
+the FreeBSD project (https://www.freebsd.org/). See the author's presentation
+for details:
+
+    http://www.youtube.com/watch?v=sczHqUPygZY
+
+The latest version can be obtained from Glen Barber's repository:
+
+    http://docscripts.glenbarber.us/tags/igor/
+
+Checker options~
+
+This checker is initialised using the "makeprgBuild()" function and thus it
+accepts the standard options described at |syntastic-config-makeprg|.
+
+See also: |syntastic-nroff-igor|, |syntastic-text-igor|.
+
+------------------------------------------------------------------------------
+2. xmllint                                           *syntastic-docbk-xmllint*
+
+Name:        xmllint
+Maintainer:  Martin Grenfell <martin.grenfell@gmail.com>
+
+"xmllint" is a checker and transformer tool for XML files, distributed with
+the "libxml" package (http://www.xmlsoft.org/). See the tool's manual for more
+information:
+
+    http://xmlsoft.org/xmllint.html
+
+Checker options~
+
+This checker is initialised using the "makeprgBuild()" function and thus it
+accepts the standard options described at |syntastic-config-makeprg|.
+
+Note~
+
+You can use a local installation of DTDs to significantly speed up validation
+and allow you to validate XML data without network access. See the
+"xmlcatalog" manual, and the catalog documentation for more information:
+
+    http://www.xmlsoft.org/xmlcatalog_man.html
+    http://www.xmlsoft.org/catalog.html
+
+For an example of a DTD catalog see f.i. "XMLCatalog":
+
+    https://github.com/darcyparker/XMLCatalog
+
+In order to use it with syntastic you'll have to clone it to a local
+directory, and point the environment variable "XML_CATALOG_FILES" to the file
+"catalog.xml" in the said directory: >
+    XML_CATALOG_FILES=/some/path/XMLCatalog/catalog.xml
+    export XML_CATALOG_FILES
+<
+Otherwise "xmllint" will try to load XML catalogs from "/etc/xml/catalog".
+
+See also: |syntastic-xml-xmllint|, |syntastic-xslt-xmllint|.
+
+==============================================================================
+SYNTAX CHECKERS FOR DOCKERFILE                 *syntastic-checkers-dockerfile*
+
+The following checkers are available for Dockerfile (filetype "dockerfile"):
+
+    1. dockerfile-lint..........|syntastic-dockerfile-dockerfile_lint|
+
+------------------------------------------------------------------------------
+1. dockerfile-lint                      *syntastic-dockerfile-dockerfile_lint*
+
+Name:        dockerfile_lint
+Maintainer:  Tim Carry <tim@pixelastic.com>
+
+"dockerfile-lint" is a linter for Dockerfiles
+(http://docs.docker.com/engine/reference/builder). See the project's page at
+GitHub for details:
+
+    https://github.com/projectatomic/dockerfile_lint
+
+Installation~
+
+Install it with: >
+    npm install -g dockerfile_lint
+<
+Checker options~
+
+This checker is initialised using the "makeprgBuild()" function and thus it
+accepts the standard options described at |syntastic-config-makeprg|.
+
+==============================================================================
+SYNTAX CHECKERS FOR DUST                           *syntastic-checkers-dustjs*
+
+The following checkers are available for Dust (filetype "dustjs"):
+
+    1. Swiffer..................|syntastic-dustjs-swiffer|
+
+------------------------------------------------------------------------------
+1. Swiffer                                          *syntastic-dustjs-swiffer*
+
+Name:        swiffer
+Maintainer:  Steven Foote <smfoote@gmail.com>
+
+"Swiffer" is a command line lint tool for Dust. See the project's page for
+details:
+
+    https://github.com/smfoote/Swiffer.js
+
+Checker options~
+
+This checker is initialised using the "makeprgBuild()" function and thus it
+accepts the standard options described at |syntastic-config-makeprg|.
+
+Note~
+
+To enable Dust syntax checking, you must set the filetype of your Dust
+template files to "dustjs". An easy way to do this is by installing the dustjs
+syntax highlighter:
+
+    https://github.com/jimmyhchan/dustjs.vim
+
+==============================================================================
+SYNTAX CHECKERS FOR ELIXIR                         *syntastic-checkers-elixir*
+
+The following checkers are available for Elixir (filetype "elixir"):
+
+    1. elixir...................|syntastic-elixir-elixir|
+
+------------------------------------------------------------------------------
+1. elixir                                            *syntastic-elixir-elixir*
+
+Name:        elixir
+Maintainer:  Richard Ramsden <rramsden@gmail.com>
+
+See the project's page for details:
+
+    http://elixir-lang.org/
+
+Security~
+
+This checker executes the code in the files it checks:
+
+    https://github.com/scrooloose/syntastic/issues/1141
+
+This is probably fine if you wrote the files yourself, but it can be a problem
+if you're trying to check third party files. If you are 100% willing to let
+Vim run the code in your files, set 'g:syntastic_enable_elixir_checker' to 1
+in your vimrc to enable this checker: >
+    let g:syntastic_enable_elixir_checker = 1
+<
+There is also a buffer-local version of this variable, that takes precedence
+over a global one in the buffers where it is defined.
+
+Please note that setting this variable doesn't automatically enable the
+checker, you still need to add "elixir" to 'g:syntastic_elixir_checkers' if
+you plan to use it.
+
+Checker options~
+
+This checker is initialised using the "makeprgBuild()" function and thus it
+accepts the standard options described at |syntastic-config-makeprg|.
+
+==============================================================================
+SYNTAX CHECKERS FOR ERLANG                         *syntastic-checkers-erlang*
+
+The following checkers are available for Erlang (filetype "erlang"):
+
+    1. escript..................|syntastic-erlang-escript|
+    2. SyntaxErl................|syntastic-erlang-syntaxerl|
+
+------------------------------------------------------------------------------
+1. escript                                          *syntastic-erlang-escript*
+
+Name:        escript
+Maintainer:  Pawel Salata <rockplayer.pl@gmail.com>
+
+"escript" is an interpreter for Erlang programs. See the tool's manual for
+more information:
+
+    http://www.erlang.org/doc/man/escript.html
+
+Checker options~
+
+This checker is initialised using the "makeprgBuild()" function and thus it
+accepts the standard options described at |syntastic-config-makeprg|.
+
+Note~
+
+If you get warning: "behaviour X undefined" with your customize behaviour, add
+the following line in your vimrc: >
+    let g:syntastic_erlc_include_path = "ebin"
+<
+
+------------------------------------------------------------------------------
+2. SyntaxErl                                      *syntastic-erlang-syntaxerl*
+
+Name:        syntaxerl
+Maintainer:  locojay
+
+"SyntaxErl" is a syntax checker for Erlang. It uses "rebar"
+(https://github.com/basho/rebar) to determine correct dependencies and library
+paths. See the project's page for more information:
+
+    https://github.com/ten0s/syntaxerl
+
+Checker options~
+
+This checker is initialised using the "makeprgBuild()" function and thus it
+accepts the standard options described at |syntastic-config-makeprg|.
+
+==============================================================================
+SYNTAX CHECKERS FOR ERUBY                           *syntastic-checkers-eruby*
+
+The following checkers are available for eRuby (filetype "eruby"):
+
+    1. Ruby.....................|syntastic-eruby-ruby|
+
+------------------------------------------------------------------------------
+1. Ruby                                                 *syntastic-eruby-ruby*
+
+Name:        ruby
+Maintainer:  Martin Grenfell <martin.grenfell@gmail.com>
+
+Checker options~
+                                                     'g:syntastic_ruby_exec'
+Type: string
+Default: "ruby"
+The Ruby executable to use.
+
+Note~
+
+The variable 'g:syntastic_ruby_exec' is also used by the Ruby
+"MRI" checker (cf. |syntastic-ruby-mri|), and it can be overriden
+by 'g:syntastic_eruby_ruby_exec'. However, this checker doesn't
+call the "makeprgBuild()" function, and thus it ignores all other
+'g:syntastic_eruby_ruby_<option>' variables.
+
+==============================================================================
+SYNTAX CHECKERS FOR FORTRAN                       *syntastic-checkers-fortran*
+
+The following checkers are available for Fortran (filetype "fortran"):
+
+    1. GNU Fortran..............|syntastic-fortran-gfortran|
+
+------------------------------------------------------------------------------
+1. GNU Fortran                                    *syntastic-fortran-gfortran*
+
+Name:        gfortran
+Maintainer:  Karl Yngve Lervåg <karl.yngve@lervag.net>
+
+"GNU Fortran" is a checker for Fortran files using either GNU
+Fortran (https://gcc.gnu.org/fortran/) or Intel Fortran Compilers
+(https://software.intel.com/en-us/fortran-compilers).
+
+Checker options~
+                                              *'g:syntastic_fortran_compiler'*
+Type: string
+Default: "gfortran"
+Compiler executable. Set this to either "gfortran" (to use GNU Fortran), or to
+"ifort" (for Intel Fortran).
+
+                                           *'g:syntastic_fortran_errorformat'*
+Type: string
+Default: unset
+Override for the default |'errorformat'|.
+
+                                 *'g:syntastic_fortran_remove_include_errors'*
+Type: boolean
+Default: 0
+By default, errors in files included from the file being checked are shown.
+Set this variable to 1 to remove messages about errors in included files.
+Please note that this means syntastic will silently abort checks if there are
+fatal errors in one of the included files.
+
+                                      *'g:syntastic_fortran_compiler_options'*
+Type: string
+Default: unset
+Compilation flags (such as "-std=f95") to be passed to the checker.
+
+                                           *'g:syntastic_fortran_config_file'*
+Type: string
+Default: ".syntastic_fortran_config"
+File containing additional compilation flags to be passed to the checker, one
+option per line (cf. |syntastic-config-files|).
+
+                                          *'g:syntastic_fortran_include_dirs'*
+Type: array of strings
+Default: []
+Include directories to be passed to the checker, in addition to the above
+compilation flags. You can set it like this: >
+    let g:syntastic_fortran_include_dirs = ["includes", "headers"]"
+<
+and the corresponding "-Iincludes -Iheaders" will be added to the compilation
+flags.
+
+                                                *'b:syntastic_fortran_cflags'*
+Type: string
+Default: unset
+Buffer-local variable. Additional compilation flags specific to the current
+buffer.
+
+Note~
+
+This checker doesn't call the "makeprgBuild()" function, and thus it ignores
+the usual 'g:syntastic_fortran_gfortran_<option>' variables. The only
+exception is 'g:syntastic_fortran_gfortran_exec', which can still be used to
+override the checker's executable.
+
+==============================================================================
+SYNTAX CHECKERS FOR GENTOO METADATA                *syntastic-checkers-gentoo*
+
+The following checkers are available for Gentoo Metadata (filetype "gentoo"):
+
+    1. xmllint..................|syntastic-gentoo-xmllint|
+
+------------------------------------------------------------------------------
+1. xmllint                                          *syntastic-gentoo-xmllint*
+
+Name:        xmllint
+Maintainer:  James Rowe <jnrowe@gmail.com>
+
+Checker options~
+
+This checker is initialised using the "makeprgBuild()" function and thus it
+accepts the standard options described at |syntastic-config-makeprg|.
+
+Note~
+
+The DTDs required to validate "metadata.xml" files are available in
+"$PORTDIR/metadata/dtd", and these local files can be used to significantly
+speed up validation. You can create a catalog file with: >
+    xmlcatalog --create --add rewriteURI http://www.gentoo.org/dtd/ \
+        ${PORTDIR:-/usr/portage}/metadata/dtd/ /etc/xml/gentoo
+<
+See "xmlcatalog" for more information:
+
+    http://www.xmlsoft.org/catalog.html
+
+==============================================================================
+SYNTAX CHECKERS FOR GETTEXT PO                         *syntastic-checkers-po*
+
+The following checkers are available for gettext .po files (filetype "po"):
+
+    1. msgfmt...................|syntastic-po-msgfmt|
+
+------------------------------------------------------------------------------
+1. msgfmt                                                *syntastic-po-msgfmt*
+
+Name:        msgfmt
+Maintainer:  Ryo Okubo <syucream1031@gmail.com>
+
+"msgfmt" is a compiler for gettext Portable Object
+(http://www.gnu.org/software/gettext/manual/html_node/PO-Files.html)
+translation files.  See the program's manual for details:
+
+    http://www.gnu.org/software/gettext/manual/html_node/msgfmt-Invocation.html#msgfmt-Invocation
+
+Checker options~
+
+This checker is initialised using the "makeprgBuild()" function and thus it
+accepts the standard options described at |syntastic-config-makeprg|.
+
+==============================================================================
+SYNTAX CHECKERS FOR GLSL                             *syntastic-checkers-glsl*
+
+The following checkers are available for GLSL (filetype "glsl"):
+
+    1. cgc......................|syntastic-glsl-cgc|
+
+------------------------------------------------------------------------------
+1. cgc                                                    *syntastic-glsl-cgc*
+
+Name:        cgc
+Maintainer:  Joshua Rahm <joshuarahm@gmail.com>
+
+"cgc" is a compiler that translates Cg or GLSL programs into OpenGL or DirectX
+code. See the manual for more details:
+
+    http://http.developer.nvidia.com/Cg/cgc.html
+
+Checker options~
+
+This checker is initialised using the "makeprgBuild()" function and thus it
+accepts the standard options described at |syntastic-config-makeprg|.
+
+Additionally:
+
+                                               *'g:syntastic_glsl_extensions'*
+Type: dictionary
+Default: unset
+
+You can control the profiles used by "cgc" with magic comments: put the magic
+comment "// profile:" followed by the profile for "cgc" to use.  For example
+use >
+    // profile: glslf
+<
+to force the fragment shader profile.
+
+If the magic comment does not exist, then the dictionary
+'g:syntastic_glsl_extensions' is used to infer the appropriate profile from
+the current file's extension. If this dictionary does not exist either, a
+default dictionary is used instead. Finally, if the current file's extension
+cannot be found in these dictionaries, the checker assumes a vertex shader
+profile.
+
+                                                  *'g:syntastic_glsl_options'*
+Type: string
+Default: unset
+Additional arguments to pass to "cgc".
+
+==============================================================================
+SYNTAX CHECKERS FOR GO                                 *syntastic-checkers-go*
+
+The following checkers are available for Go (filetype "go"):
+
+    1. go.......................|syntastic-go-go|
+    2. gofmt....................|syntastic-go-gofmt|
+    3. Golint...................|syntastic-go-golint|
+    4. Go Meta Linter...........|syntastic-go-gometalinter|
+    5. gotype...................|syntastic-go-gotype|
+    6. vet......................|syntastic-go-govet|
+
+------------------------------------------------------------------------------
+1. go                                                        *syntastic-go-go*
+
+Name:        go
+Maintainer:  Kamil Kisiel <kamil@kamilkisiel.net>
+
+Checker options~
+
+This checker is initialised using the "makeprgBuild()" function and thus it
+accepts the standard options described at |syntastic-config-makeprg|.
+
+Additionally:
+
+                                              *'g:syntastic_go_go_build_args'*
+Type: string
+Default: "-buildmode=archive"
+arguments passed to "go build"
+
+                                               *'g:syntastic_go_go_test_args'*
+Type: string
+Default: "-buildmode=archive"
+arguments passed to "go test".
+
+Note~
+
+This syntax checker does not reformat your source code.  Use a |BufWritePre|
+autocommand towards that end: >
+    autocmd FileType go autocmd BufWritePre <buffer> Fmt
+<
+------------------------------------------------------------------------------
+2. gofmt                                                  *syntastic-go-gofmt*
+
+Name:        gofmt
+Maintainer:  Brandon Thomson <bt@brandonthomson.com>
+
+Checker options~
+
+This checker is initialised using the "makeprgBuild()" function and thus it
+accepts the standard options described at |syntastic-config-makeprg|.
+
+Note~
+
+This syntax checker does not reformat your source code.  Use a |BufWritePre|
+autocommand towards that end: >
+    autocmd FileType go autocmd BufWritePre <buffer> Fmt
+<
+------------------------------------------------------------------------------
+3. Golint                                                *syntastic-go-golint*
+
+Name:        golint
+Maintainer: Hiroshi Ioka <hirochachacha@gmail.com>
+
+"Golint" is a linter for Go. See the project's page for details:
+
+    https://github.com/golang/lint
+
+Checker options~
+
+This checker is initialised using the "makeprgBuild()" function and thus it
+accepts the standard options described at |syntastic-config-makeprg|.
+
+------------------------------------------------------------------------------
+4. Go Meta Linter                                  *syntastic-go-gometalinter*
+
+Name:        gometalinter
+Maintainer: Joshua Rubin <joshua@rubixconsulting.com>
+
+"Go Meta Linter" is a linter for Go. It runs a number of other linters
+against your files, and normalises their output to a standard format.
+See the project's page at GitHub for details:
+
+    https://github.com/alecthomas/gometalinter
+
+Checker options~
+
+This checker is initialised using the "makeprgBuild()" function and thus it
+accepts the standard options described at |syntastic-config-makeprg|.
+
+------------------------------------------------------------------------------
+5. gotype                                                *syntastic-go-gotype*
+
+Name:        gotype
+Maintainer:  luz <ne.tetewi@gmail.com>
+
+See the tool's documentation for details:
+
+    https://godoc.org/golang.org/x/tools/cmd/gotype
+
+------------------------------------------------------------------------------
+6. vet                                                    *syntastic-go-govet*
+
+Name:        govet
+Maintainer:  Kamil Kisiel <kamil@kamilkisiel.net>
+
+See the tool's documentation for details:
+
+    https://godoc.org/golang.org/x/tools/cmd/vet
+
+Note~
+
+This checker doesn't call the "makeprgBuild()" function, and thus it ignores
+the usual 'g:syntastic_go_govet_<option>' variables.
+
+==============================================================================
+SYNTAX CHECKERS FOR HAML                             *syntastic-checkers-haml*
+
+The following checkers are available for Haml (filetype "haml"):
+
+    1. Haml.....................|syntastic-haml-haml|
+    2. HAML-Lint................|syntastic-haml-haml_lint|
+
+------------------------------------------------------------------------------
+1. Haml                                                  *syntastic-haml-haml*
+
+Name:        haml
+Maintainer:  Martin Grenfell <martin.grenfell@gmail.com>
+
+See the project's page for details:
+
+    http://haml.info/
+
+Checker options~
+
+This checker is initialised using the "makeprgBuild()" function and thus it
+accepts the standard options described at |syntastic-config-makeprg|.
+
+------------------------------------------------------------------------------
+2. HAML-Lint                                        *syntastic-haml-haml_lint*
+
+Name:        haml_lint
+Maintainer:  Shane da Silva <shane@dasilva.io>
+
+"HAML-Lint" is a checker for HAML files. See the project's page for details:
+
+    https://github.com/causes/haml-lint
+
+Checker options~
+
+This checker is initialised using the "makeprgBuild()" function and thus it
+accepts the standard options described at |syntastic-config-makeprg|.
+
+==============================================================================
+SYNTAX CHECKERS FOR HANDLEBARS                 *syntastic-checkers-handlebars*
+
+The following checkers are available for Handlebars (filetype "handlebars"):
+
+    1. Handlebars...............|syntastic-handlebars-handlebars|
+
+------------------------------------------------------------------------------
+1. Handlebars                                *syntastic-handlebars-handlebars*
+
+Name:        handlebars
+Maintainer:  Jeremy Mack
+
+"Handlebars" is a JavaScript library for building semantic templates. See the
+project's page for details:
+
+    http://handlebarsjs.com/
+
+Checker options~
+
+This checker is initialised using the "makeprgBuild()" function and thus it
+accepts the standard options described at |syntastic-config-makeprg|.
+
+Note~
+
+You probably also need a plugin to set |filetype| for Handlebars files, such as
+"vim-mustache-handlebars":
+
+    https://github.com/mustache/vim-mustache-handlebars
+
+==============================================================================
+SYNTAX CHECKERS FOR HASKELL                       *syntastic-checkers-haskell*
+
+The following checkers are available for Haskell (filetype "haskell"):
+
+    1. hdevtools................|syntastic-haskell-hdevtools|
+    2. HLint....................|syntastic-haskell-hlint|
+    3. Style scanner............|syntastic-haskell-scan|
+
+------------------------------------------------------------------------------
+1. hdevtools                                     *syntastic-haskell-hdevtools*
+
+Name:        hdevtools
+Maintainer:  Anthony Carapetis <anthony.carapetis@gmail.com>
+
+"hdevtools" is a backend for text editor plugins. See the project's page at
+GitHub for details:
+
+    https://github.com/bitc/hdevtools/
+
+Checker options~
+
+This checker is initialised using the "makeprgBuild()" function and thus it
+accepts the standard options described at |syntastic-config-makeprg|.
+
+Note~
+
+If you're checking files containing tab characters, then Vim's 'tabstop'
+must match "hdevtools"'s idea of tabstop, otherwise column numbers will be
+shifted. At the time of this writing, "hdevtools"'s tabstop is hardcoded to 8,
+so you should probably add something like this to your vimrc: >
+    set tabstop=8
+<
+------------------------------------------------------------------------------
+2. HLint                                             *syntastic-haskell-hlint*
+
+Name:        hlint
+Maintainer:  Nicolas Wu <nicolas.wu@gmail.com>
+
+"HLint" is a linter and style checker for Haskell. See the project's page for
+details:
+
+    http://community.haskell.org/~ndm/hlint/
+
+Checker options~
+
+This checker is initialised using the "makeprgBuild()" function and thus it
+accepts the standard options described at |syntastic-config-makeprg|.
+
+Note~
+
+If you're checking files containing tab characters, Vim's 'tabstop' must
+match "HLint"'s idea of tabstop, otherwise column numbers will be shifted. At
+the time of this writing "HLint"'s tabstop is hardcoded to 8, so you should
+probably add something like this to your vimrc: >
+    set tabstop=8
+<
+------------------------------------------------------------------------------
+3. Style scanner                                      *syntastic-haskell-scan*
+
+Name:        scan
+Maintainer:  LCD 47 <lcd047@gmail.com>
+
+"Style scanner" is a style checker for Haskell. See the project's page for
+details:
+
+    http://projects.haskell.org/style-scanner/
+
+Checker options~
+
+This checker is initialised using the "makeprgBuild()" function and thus it
+accepts the standard options described at |syntastic-config-makeprg|.
+
+Note~
+
+If you're checking files containing tab characters, Vim's 'tabstop' must
+match "Style scanner"'s idea of tabstop, otherwise column numbers will be
+shifted. At the time of this writing "Style scanner"'s tabstop is hardcoded to
+8, so you should probably add something like this to your vimrc: >
+    set tabstop=8
+<
+==============================================================================
+SYNTAX CHECKERS FOR HAXE                             *syntastic-checkers-haxe*
+
+The following checkers are available for Haxe (filetype "haxe"):
+
+    1. Haxe.....................|syntastic-haxe-haxe|
+
+------------------------------------------------------------------------------
+1. Haxe                                                  *syntastic-haxe-haxe*
+
+Name:        haxe
+Maintainer:  David Bernard <david.bernard.31@gmail.com>
+
+"Haxe" is a programming language and compiler that can produce applications
+and source code for multiple different platforms from a single code-base. See
+the project's page for details:
+
+    http://haxe.org/
+
+Checker options~
+
+This checker is initialised using the "makeprgBuild()" function and thus it
+accepts the standard options described at |syntastic-config-makeprg|.
+
+Additionally:
+
+                                                               *'g:vaxe_hxml'*
+                                                               *'b:vaxe_hxml'*
+Type: string
+Default: unset
+By default the checker will search parent folders for "hxml" files, and
+use the first one it finds. You can override that behaviour by pointing
+'g:vaxe_hxml' or 'b:vaxe_hxml' to a specific build file. Those variables can
+also be set by Vaxe:
+
+    https://github.com/jdonaldson/vaxe
+
+==============================================================================
+SYNTAX CHECKERS FOR HSS                               *syntastic-checkers-hss*
+
+The following checkers are available for HSS (filetype "hss"):
+
+    1. HSS......................|syntastic-hss-hss|
+
+------------------------------------------------------------------------------
+1. HSS                                                     *syntastic-hss-hss*
+
+Name:        hss
+Maintainer:  Justin Donaldson <jdonaldson@gmail.com>
+
+"HSS" is a tool that extends the CSS syntax with features such as variables
+and nested blocks. See the project's page for details:
+
+    http://ncannasse.fr/projects/hss
+
+Checker options~
+
+This checker is initialised using the "makeprgBuild()" function and thus it
+accepts the standard options described at |syntastic-config-makeprg|.
+
+==============================================================================
+SYNTAX CHECKERS FOR HTML                             *syntastic-checkers-html*
+
+The following checkers are available for HTML (filetype "html"):
+
+    1. ESLint...................|syntastic-html-eslint|
+    2. gjslint..................|syntastic-html-gjslint|
+    3. HTML tidy................|syntastic-html-tidy|
+    4. JSHint...................|syntastic-html-jshint|
+    5. textlint.................|syntastic-html-textlint|
+    6. Validator................|syntastic-html-validator|
+    7. W3.......................|syntastic-html-w3|
+
+------------------------------------------------------------------------------
+1. ESLint                                              *syntastic-html-eslint*
+
+Name:        eslint
+Maintainer:  LCD 47 <lcd047@gmail.com>
+
+"ESLint" is a tool for identifying and reporting on patterns found in
+ECMAScript/JavaScript code. It can also detect problems in JavaScript code
+embedded in HTML files. See the project's page for details:
+
+    https://github.com/nzakas/eslint
+
+Checker options~
+
+This checker is initialised using the "makeprgBuild()" function and thus it
+accepts the standard options described at |syntastic-config-makeprg|.
+
+Note~
+
+You can also use "eslint_d" (https://github.com/mantoni/eslint_d.js), version
+2.1.0 or later, instead of "ESLint". Just point 'g:syntastic_html_eslint_exec'
+to it:
+
+    https://github.com/mantoni/eslint_d.js#editor-integration
+
+See also: |syntastic-javascript-eslint|, |syntastic-typescript-eslint|.
+
+------------------------------------------------------------------------------
+2. gjslint                                            *syntastic-html-gjslint*
+
+Name:        gjslint
+Maintainer:  Martin Grenfell <martin.grenfell@gmail.com>
+
+"Closure Linter", or "gjslint", is a style checker for JavaScript. It can also
+detect problems in HTML files. See the project's page for more information:
+
+    https://developers.google.com/closure/utilities/
+
+Checker options~
+
+This checker is initialised using the "makeprgBuild()" function and thus it
+accepts the standard options described at |syntastic-config-makeprg|.
+
+See also: |syntastic-javascript-gjslint|.
+
+------------------------------------------------------------------------------
+3. HTML tidy                                             *syntastic-html-tidy*
+
+Name:        tidy
+Maintainer:  Martin Grenfell <martin.grenfell@gmail.com>
+
+"HTML Tidy" is a syntax checker and formatter for HTML. See the project's page
+for more information:
+
+    http://www.html-tidy.org/
+
+Checker options~
+
+This checker is initialised using the "makeprgBuild()" function and thus it
+accepts the standard options described at |syntastic-config-makeprg|.
+
+Additionally:
+
+                                       *'g:syntastic_html_tidy_ignore_errors'*
+Type: array of strings
+Default: []
+List of errors to ignore. Case-sensitive patterns matched as substrings
+(not regular expressions) against the error messages. See also
+|'syntastic_quiet_messages'|.
+
+                                     *'g:syntastic_html_tidy_blocklevel_tags'*
+Type: array of strings
+Default: []
+List of additional blocklevel tags to be added to "--new-blocklevel-tags".
+
+                                         *'g:syntastic_html_tidy_inline_tags'*
+Type: array of strings
+Default: []
+List of additional inline tags to be added to "--new-inline-tags".
+
+                                          *'g:syntastic_html_tidy_empty_tags'*
+Type: array of strings
+Default: []
+List of additional empty tags, to be added to "--new-empty-tags".
+
+See also: |syntastic-xhtml-tidy|.
+
+------------------------------------------------------------------------------
+4. jshint                                              *syntastic-html-jshint*
+
+Name:        JSHint
+Maintainer:  LCD 47 <lcd047@gmail.com>
+
+"JSHint" can detect JavaScript errors and potential problems in HTML
+files. See the project's page for details:
+
+    http://jshint.com/
+
+Syntastic requires "JSHint" version 2.4.0 or later.
+
+Checker options~
+
+This checker is initialised using the "makeprgBuild()" function and thus it
+accepts the standard options described at |syntastic-config-makeprg|.
+
+Note~
+
+If you're checking files containing tab characters then "JSHint"'s idea of
+tabstop must match Vim's 'tabstop', otherwise syntastic will highlight the
+errors at shifted positions. By default "JSHint"'s tabstop is 4, while Vim's
+default 'tabstop' is 8.
+
+In order to change "JSHint"'s tabstop you have to change its "indent" config
+option (cf. http://jshint.com/docs/options/#indent). One way to do that is
+to put it in a file named ".jshintrc" in the current directory, the parent
+directories, or your home directory. The file is supposed to be in JSON
+format. For example: >
+    {
+        "indent": 8
+    }
+<
+See JSHint documentation for more details:
+
+    http://jshint.com/docs/
+
+Please note however that setting "indent" also triggers the indentation checks
+in "JSHint". If that is undesirable, your only other option is to leave
+"JSHint"'s tabstop alone, and change Vim's 'tabstop' to 4. To change Vim's
+'tabstop', you can add this to your vimrc: >
+    set tabstop=4
+<
+See also: |syntastic-javascript-jshint|, |syntastic-xhtml-jshint|.
+
+------------------------------------------------------------------------------
+5. textlint                                          *syntastic-html-textlint*
+
+Name:        textlint
+Maintainer:  LCD 47 <lcd047@gmail.com>
+
+"textlint" is a natural language linter for text, Markdown, and HTML files.
+See the project's page for details:
+
+    https://textlint.github.io/
+
+Checker options~
+
+This checker is initialised using the "makeprgBuild()" function and thus it
+accepts the standard options described at |syntastic-config-makeprg|.
+
+Note~
+
+You need to install both "textlint" and the "textlint HTML" plugin for this to
+work:
+
+    https://github.com/textlint/textlint-plugin-html
+
+See also: |syntastic-markdown-textlint|, |syntastic-text-textlint|.
+
+------------------------------------------------------------------------------
+6. Validator                                        *syntastic-html-validator*
+
+Name:        validator
+Maintainer:  LCD 47 <lcd047@gmail.com>
+
+"Validator" is a non-DTD-based HTML checker.  See the project's page for
+details:
+
+    http://validator.github.io/validator/
+
+As a syntastic checker, you can validate your files against the online service
+(see https://validator.nu/), or you can install "vnu.jar":
+
+    https://github.com/validator/validator/releases/latest
+
+then run it as a HTTP server: >
+    $ java -Xss512k -cp /path/to/vnu.jar nu.validator.servlet.Main 8888
+<
+Requirement~
+
+This checker uses cURL:
+
+    http://curl.haxx.se/
+
+Checker options~
+
+                                            *'g:syntastic_html_validator_api'*
+Type: string
+Default: "http://validator.nu/"
+URL of the service to use for checking. Leave it to the default to run the
+checks against "https://validator.nu/", or set it to "http://localhost:8888/"
+if you have "vnu.jar" installed, and you're running it as a standalone HTTP
+server. See:
+
+    http://validator.github.io/validator/#standalone
+
+                                         *'g:syntastic_html_validator_parser'*
+Type: string
+Default: empty
+Parser to use. Legal values are: "xml", "xmldtd", "html", "html5", "html4",
+and "html4tr". Set it to "html5" to check HTML5 files. References:
+
+    https://wiki.whatwg.org/wiki/Validator.nu_Common_Input_Parameters#parser
+
+                                       *'g:syntastic_html_validator_nsfilter'*
+Type: string
+Default: empty
+Sets the "nsfilter" for the parser. See:
+
+    https://wiki.whatwg.org/wiki/Validator.nu_Common_Input_Parameters#nsfilter
+
+                                           *'g:syntastic_html_validator_exec'*
+Type: string
+Default: "curl"
+Path to the "cURL" executable. Override it with a full path if your "cURL" is
+not installed in a standard location.
+
+This checker doesn't call the "makeprgBuild()" function, and thus it ignores
+the usual 'g:syntastic_html_validator_<option>' variables. The only exception
+is 'g:syntastic_html_validator_exec', which can be used to override the path
+to the "cURL" executable.
+
+Note~
+
+Non-zero exit codes from "cURL" are typically network errors, and are signaled
+by syntastic with messages such as: >
+    syntastic: error: checker html/validator returned abnormal status 26
+<
+You can lookup the meaning of these codes in cURL's manual:
+    
+    http://curl.haxx.se/docs/manpage.html#EXIT
+
+------------------------------------------------------------------------------
+7. W3                                                      *syntastic-html-w3*
+
+Name:        w3
+Maintainer:  Martin Grenfell <martin.grenfell@gmail.com>
+
+"W3" is the W3C Markup Validator for HTML.  See the project's page for
+details:
+
+    https://validator.w3.org/source/
+
+As a syntastic checker, you can validate your files against the online service
+(see http://validator.w3.org/), or you can install it from sources and run it
+as a local service:
+
+    https://github.com/w3c/markup-validator/
+
+Requirement~
+
+This checker uses cURL:
+
+    http://curl.haxx.se/
+
+Checker options~
+
+                                                   *'g:syntastic_html_w3_api'*
+Type: 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.
+
+                                                  *'g:syntastic_html_w3_exec'*
+Type: string
+Default: "curl"
+Path to the "cURL" executable. Override it with a full path if your "cURL" is
+not installed in a standard location.
+
+This checker doesn't call the "makeprgBuild()" function, and thus it ignores
+the usual 'g:syntastic_html_w3_<option>' variables. The only exception is
+'g:syntastic_html_w3_exec', which can be used to override the path to the
+"cURL" executable.
+
+Note~
+
+Non-zero exit codes from "cURL" are typically network errors, and are signaled
+by syntastic with messages such as: >
+    syntastic: error: checker html/validator returned abnormal status 26
+<
+You can lookup the meaning of these codes in cURL's manual:
+    
+    http://curl.haxx.se/docs/manpage.html#EXIT
+
+==============================================================================
+SYNTAX CHECKERS FOR JAVA                             *syntastic-checkers-java*
+
+The following checkers are available for Java (filetype "java"):
+
+    1. checkstyle...............|syntastic-java-checkstyle|
+    2. javac....................|syntastic-java-javac|
+
+------------------------------------------------------------------------------
+1. checkstyle                                      *syntastic-java-checkstyle*
+
+Name:        checkstyle
+Maintainer:  Dmitry Geurkov <d.geurkov@gmail.com>
+
+"Checkstyle" is a style checker for Java.  See the project's page for details:
+
+    http://checkstyle.sourceforge.net/
+
+Checker options~
+
+This checker is initialised using the "makeprgBuild()" function and thus it
+accepts the standard options described at |syntastic-config-makeprg|.
+
+Additionally:
+
+                                     *'g:syntastic_java_checkstyle_classpath'*
+Type: string
+Default: "checkstyle-6.10.1-all.jar"
+Classpath to use. Multiple files are allowed.
+
+                                     *'g:syntastic_java_checkstyle_conf_file'*
+Type: string
+Default: "sun_checks.xml"
+Path to the configuration file for the "-c" option (cf.
+http://checkstyle.sourceforge.net/cmdline.html#Command_line_usage).
+
+
+Notes~
+
+1. The checker was tested with "checkstyle" version 5.5. If you're using
+it with version 5.6 or later you should remove DoubleCheckedLocking from
+your configuration file:
+
+    http://stackoverflow.com/a/12798807/1658042
+
+2. At the time of this writing, the "checkstyle" checker doesn't distinguish
+between error severity levels. All messages are treated as errors, regardless
+of their severity defined in the "checkstyle" config file.
+
+3. You can specify a property file: >
+    let g:syntastic_java_checkstyle_post_args =
+        \ ["-p", "/path/to/checkstyle.properties"]
+<
+4. You probably want to download the "fat jar" "checkstyle-*-all.jar" and
+point |'g:syntastic_java_checkstyle_classpath'| to it:
+
+    http://iweb.dl.sourceforge.net/project/checkstyle/checkstyle/
+    http://checkstyle.sourceforge.net/cmdline.html#Usage_by_Classpath_update
+
+Current builds at Maven Central do not package "checkstyle" with its
+dependencies:
+
+    http://search.maven.org/#search|gav|1|g%3A%22com.puppycrawl.tools%22%20AND%20a%3A%22checkstyle%22
+
+However, |'g:syntastic_java_checkstyle_classpath'| accepts multiple files if
+you want to include the "checkstyle" jar and all of its dependencies.
+
+------------------------------------------------------------------------------
+2. javac                                                *syntastic-java-javac*
+
+Name:        javac
+Maintainers: Jochen Keil <jochen.keil@gmail.com>
+             Dmitry Geurkov <d.geurkov@gmail.com>
+
+Commands~
+
+The following commands are available:
+
+                                                *:SyntasticJavacEditClasspath*
+This opens a new window where you can specify a classpath. Individual paths
+may be specified one per line, or separated by colons ":" on UNIX, or by
+semicolons ";" on Windows.
+
+                                                   *:SyntasticJavacEditConfig*
+This command relevant only if |'g:syntastic_java_javac_config_file_enabled'|
+is set. It opens a buffer where you can specify project-specific options from
+the list below. These options will be saved in a file pointed to by
+|'g:syntastic_java_javac_config_file'| (".syntastic_javac_config" by default).
+Set |'g:syntastic_java_javac_config_file'| to a full path to use a
+project-wide configuration file, rather than a file in the current directory.
+The settings have to be specified as Vim commands.
+
+Checker options~
+
+This checker is initialised using the "makeprgBuild()" function and thus it
+accepts the standard options described at |syntastic-config-makeprg|.
+
+Additionally:
+
+                                         *'g:syntastic_java_javac_executable'*
+Type: string
+Default: "javac"
+Compiler executable used for checking files.
+
+                                         *'g:syntastic_java_maven_executable'*
+Type: string
+Default: "mvn"
+Maven executable used for loading classpath for "maven" projects.
+
+                                            *'g:syntastic_java_javac_options'*
+Type: string
+Default: "-Xlint"
+Options for "javac".
+
+                                          *'g:syntastic_java_javac_classpath'*
+Type: string
+Default: ""
+Classpath. It can be changed by running the `:SyntasticJavacEditClasspath`
+command.
+
+                                      *'g:syntastic_java_javac_delete_output'*
+Type: boolean
+Default: 1
+When set the checker will delete the ".class" files created by "javac".
+
+                           *'g:syntastic_java_javac_autoload_maven_classpath'*
+Type: boolean
+Default: 1
+If enabled and a file "pom.xml" is found in the current working directory,
+"maven" is used to load classpath.
+
+                                        *'g:syntastic_java_javac_config_file'*
+Type: string
+Default: ".syntastic_javac_config"
+Path to the configuration file used by "javac". As usual, if a filename is
+specified rather than a full path, the file is created and looked for in the
+current directory.
+
+                                *'g:syntastic_java_javac_config_file_enabled'*
+Type: boolean
+Default: 0
+When enabled, the classpath is written to the file pointed to by
+|'g:syntastic_java_javac_config_file'|. The file is created as needed.
+You can edit this file with the `:SyntasticJavacEditClasspath` command.
+The change will take effect next time you run the checker.
+
+                           *'g:syntastic_java_javac_custom_classpath_command'*
+Type: string
+Default: ""
+Custom command to run in order to get the classpath. The command classpath
+output can be in traditional Java form, or specified on separate lines.
+"%file_path%", "%FILE_NAME%", and "%FILE_DIR%" are expanded to the current
+file's full path, filename, and base directory respectively, all of them
+escaped for use in a shell command.
+
+Using Ant~
+
+When using "ant" (http://ant.apache.org/) you can have a custom build target
+(named for example "path") that will output your project's classpath. You can
+then use `:SyntasticJavacEditConfig` and add the following line to use it with
+"javac" checker: >
+    let g:syntastic_java_javac_custom_classpath_command =
+        \ "ant -q path | grep echo | cut -f2- -d] | tr -d ' ' | tr ':' '\n'"
+<
+Using Gradle~
+
+For "Gradle" projects (http://gradle.org/) you might consider using
+"gradle-syntastic-plugin":
+
+    https://github.com/Scuilion/gradle-syntastic-plugin
+
+This will write the relevant classpath to a file ".syntastic_javac_config".
+
+==============================================================================
+SYNTAX CHECKERS FOR JAVASCRIPT                 *syntastic-checkers-javascript*
+
+The following checkers are available for JavaScript (filetype "javascript"):
+
+    1. Closure Compiler.........|syntastic-javascript-closurecompiler|
+    2. ESLint...................|syntastic-javascript-eslint|
+    3. Flow.....................|syntastic-javascript-flow|
+    4. gjslint..................|syntastic-javascript-gjslint|
+    5. JavaScript Lint..........|syntastic-javascript-jsl|
+    6. JSCS.....................|syntastic-javascript-jscs|
+    7. JSHint...................|syntastic-javascript-jshint|
+    8. JSLint...................|syntastic-javascript-jslint|
+    9. JSXHint..................|syntastic-javascript-jsxhint|
+    10. mixedindentlint.........|syntastic-javascript-mixedindentlint|
+    11. standard................|syntastic-javascript-standard|
+    12. tern-lint...............|syntastic-javascript-tern_lint|
+
+------------------------------------------------------------------------------
+1. Closure Compiler                     *syntastic-javascript-closurecompiler*
+
+Name:        closurecompiler
+Maintainer:  Motohiro Takayama <mootoh@gmail.com>
+
+"Closure Compiler" is a compiler for JavaScript maintained by Google. See the
+project's page for details:
+
+    https://developers.google.com/closure/compiler/
+
+Checker options~
+
+This checker is initialised using the "makeprgBuild()" function and thus it
+accepts the standard options described at |syntastic-config-makeprg|.
+
+Additionally:
+
+                               *'g:syntastic_javascript_closurecompiler_path'*
+Type: string
+Default: unset
+Path to "google-closure-compiler.jar"
+
+                             *'g:syntastic_javascript_closurecompiler_script'*
+Type: string
+Default: unset
+Path to a "closurecompiler" executable script.
+
+Note~
+
+In order to enable the checker you have to set exactly one of the options
+above. If you have a package manager (such as "Homebrew") that installs a
+shell script that runs "Closure Compiler", point
+|'g:syntastic_javascript_closurecompiler_script'| to that script. Otherwise
+set |'g:syntastic_javascript_closurecompiler_path'| to point to the "Closure
+Compiler" jar file.
+
+------------------------------------------------------------------------------
+2. ESLint                                        *syntastic-javascript-eslint*
+
+Name:        eslint
+Maintainer:  Maksim Ryzhikov <rv.maksim@gmail.com>
+
+"ESLint" is a tool for identifying and reporting on patterns found in
+ECMAScript/JavaScript code. See the project's page for details:
+
+    https://github.com/nzakas/eslint
+
+Checker options~
+
+This checker is initialised using the "makeprgBuild()" function and thus it
+accepts the standard options described at |syntastic-config-makeprg|.
+
+Note~
+
+You can also use "eslint_d" (https://github.com/mantoni/eslint_d.js),
+version 2.1.0 or later, instead of "ESLint". Just point
+'g:syntastic_javascript_eslint_exec' to it:
+
+    https://github.com/mantoni/eslint_d.js#editor-integration
+
+See also: |syntastic-html-eslint|, |syntastic-typescript-eslint|.
+
+------------------------------------------------------------------------------
+3. Flow                                            *syntastic-javascript-flow*
+
+Name:        flow
+Maintainer:  Michael Robinson <mike@pagesofinterest.net>
+
+"Flow" is a static type checker for JavaScript, written by Facebook. See the
+project's page for details:
+
+    http://flowtype.org/
+
+Checker options~
+
+This checker is initialised using the "makeprgBuild()" function and thus it
+accepts the standard options described at |syntastic-config-makeprg|.
+
+Notes~
+
+Syntastic requires "Flow" version 0.6 or later.
+
+To use "Flow" with your projects, you must:
+
+a. Install it:
+
+    https://github.com/sindresorhus/flow-bin
+
+b. Configure your project:
+>
+    cd /path/to/your/project
+    flow init
+<
+c. Read the docs to find out more. It won't work out of the box.
+
+    http://flowtype.org/docs/existing.html
+
+------------------------------------------------------------------------------
+4. gjslint                                      *syntastic-javascript-gjslint*
+
+Name:        gjslint
+Maintainer:  Martin Grenfell <martin.grenfell@gmail.com>
+
+"Closure Linter", or "gjslint", is a style checker for JavaScript. See the
+project's page for more information:
+
+    https://developers.google.com/closure/utilities/
+
+Checker options~
+
+This checker is initialised using the "makeprgBuild()" function and thus it
+accepts the standard options described at |syntastic-config-makeprg|.
+
+See also: |syntastic-html-gjslint|.
+
+------------------------------------------------------------------------------
+5. JavaScript Lint                                  *syntastic-javascript-jsl*
+
+Name:        jsl
+Maintainer:  Martin Grenfell <martin.grenfell@gmail.com>
+
+For details about "JavaScript Lint" see the project's page:
+
+    http://www.javascriptlint.com/
+
+Checker options~
+
+This checker is initialised using the "makeprgBuild()" function and thus it
+accepts the standard options described at |syntastic-config-makeprg|.
+
+------------------------------------------------------------------------------
+6. JSCS                                            *syntastic-javascript-jscs*
+
+Name:        jscs
+Maintainer:  LCD 47 <lcd047@gmail.com>
+
+"JSCS" is a code style checker for JavaScript. See the project's page for
+more information:
+
+    https://github.com/mdevils/node-jscs
+
+Syntastic requires "JSCS" version 0.2.0 or later.
+
+Checker options~
+
+This checker is initialised using the "makeprgBuild()" function and thus it
+accepts the standard options described at |syntastic-config-makeprg|.
+
+------------------------------------------------------------------------------
+7. JSHint                                        *syntastic-javascript-jshint*
+
+Name:        jshint
+Maintainer:  Martin Grenfell <martin.grenfell@gmail.com>
+
+"JSHint" is a tool to detect errors and potential problems in JavaScript
+files. See the project's page for details:
+
+    http://jshint.com/
+
+Syntastic requires "JSHint" version 1.0.0 or later.
+
+Checker options~
+
+This checker is initialised using the "makeprgBuild()" function and thus it
+accepts the standard options described at |syntastic-config-makeprg|.
+
+Notes~
+
+If you're checking files containing tab characters then "JSHint"'s idea of
+tabstop must match Vim's 'tabstop', otherwise syntastic will highlight the
+errors at shifted positions. By default "JSHint"'s tabstop is 4, while Vim's
+default 'tabstop' is 8.
+
+In order to change "JSHint"'s tabstop you have to change its "indent" config
+option (cf. http://jshint.com/docs/options/#indent). One way to do that is
+to put it in a file named ".jshintrc" in the current directory, the parent
+directories, or your home directory. The file is supposed to be in JSON
+format. For example: >
+    {
+        "indent": 8
+    }
+<
+See JSHint documentation for more details:
+
+    http://jshint.com/docs/
+
+Please note however that setting "indent" also triggers the indentation checks
+in "JSHint". If that is undesirable, your only other option is to leave
+"JSHint"'s tabstop alone, and change Vim's 'tabstop' to 4. To change Vim's
+'tabstop', you can add this to your vimrc: >
+    set tabstop=4
+<
+See also: |syntastic-html-jshint|, |syntastic-xhtml-jshint|.
+
+------------------------------------------------------------------------------
+8. JSLint                                        *syntastic-javascript-jslint*
+
+Name:        jslint
+Maintainer:  Martin Grenfell <martin.grenfell@gmail.com>
+
+"JSLint" is a code quality checker for JavaScript. See the program's page for
+details:
+
+    http://www.jslint.com/
+
+Checker options~
+
+This checker is initialised using the "makeprgBuild()" function and thus it
+accepts the standard options described at |syntastic-config-makeprg|.
+
+Note~
+
+By default the checker calls "JSLint" with these options: >
+    --white --nomen --regexp --plusplus --bitwise --newcap --sloppy --vars
+<
+This can be changed by setting 'g:syntastic_javascript_jslint_args' in your
+vimrc to your own list of options, for example: >
+    let g:syntastic_javascript_jslint_args = 
+        \ "--nomen --regexp --browser --devel --windows --sloppy --vars"
+<
+Setting this variable to the empty string "" is allowed, and instructs
+syntastic to call "JSLint" with no options.
+
+------------------------------------------------------------------------------
+9. JSXHint                                      *syntastic-javascript-jsxhint*
+
+Name:        JSXHint
+Maintainer:  Thomas Boyt <me@thomasboyt.com>
+
+"JSXHint" is a wrapper around JSHint (http://jshint.com/) for
+linting JSX syntax, which is inline markup-in-JS used by React
+(http://facebook.github.io/react/docs/getting-started.html).
+
+See the project's page for details:
+
+    https://github.com/strml/jsxhint
+
+Checker options~
+
+This checker is initialised using the "makeprgBuild()" function and thus it
+accepts the standard options described at |syntastic-config-makeprg|.
+
+Installation~
+
+Install it with "npm": >
+    npm install -g jsxhint
+<
+Syntastic requires "JSXHint" version v0.4.1 or later. You also need "JSHint"
+v1.1.0 or later.
+
+Note~
+
+Since "JSXHint" is a wrapper around JSHint, the following note relevant to
+the latter still applies:
+
+If you're checking files containing tab characters then JSHint's idea of
+tabstop must match Vim's 'tabstop', otherwise syntastic will highlight the
+errors at shifted positions. By default JSHint's tabstop is 4, while Vim's
+default 'tabstop' is 8.
+
+In order to change "JSHint"'s tabstop you have to change its "indent" config
+option (http://jshint.com/docs/options/#indent). One way to do that is to
+put it in a file named ".jshintrc" in the current directory, the parent
+directories, or your home directory. The file is supposed to be in JSON
+format. For example: >
+    {
+        "indent": 8
+    }
+<
+See JSHint documentation for more details:
+
+    http://jshint.com/docs/
+
+Please note however that setting "indent" also triggers the indentation checks
+in JSHint. If that is undesirable, your only other option is to leave JSHint's
+tabstop alone, and change Vim's 'tabstop' to 4. To change Vim's 'tabstop', you
+can add this to your 'vimrc': >
+    set tabstop=4
+<
+Alternative~
+
+"JSXHint" will not show JSX-related errors in syntastic, because failed JSX
+compiles will result in the uncompiled data being passed to JSHint:
+
+    https://github.com/STRML/JSXHint/issues/45
+
+To get around this, "Syntastic-React" can be used as a replacement for
+"JSXHint":
+
+    https://github.com/jaxbot/syntastic-react
+
+------------------------------------------------------------------------------
+10. mixedindentlint                     *syntastic-javascript-mixedindentlint*
+
+Name:        mixedindentlint
+Maintainer:  Payton Swick <payton@foolord.com>
+
+"mixedindentlint" is a general-purpose indentation checker. See the project's
+page at GitHub for more information:
+
+    https://github.com/sirbrillig/mixedindentlint
+
+Checker options~
+
+This checker is initialised using the "makeprgBuild()" function and thus it
+accepts the standard options described at |syntastic-config-makeprg|.
+
+See also: |syntastic-css-mixedindentlint|, |syntastic-scss-mixedindentlint|.
+
+------------------------------------------------------------------------------
+11. standard                                   *syntastic-javascript-standard*
+
+Name:        standard
+Maintainer:  LCD 47 <lcd047@gmail.com>
+
+"Standard" is a code style checker for JavaScript.  See the project's page for
+more information:
+
+    https://github.com/feross/standard
+
+Checker options~
+
+This checker is initialised using the "makeprgBuild()" function and thus it
+accepts the standard options described at |syntastic-config-makeprg|.
+
+Additionally:
+
+                                   *'g:syntastic_javascript_standard_generic'*
+Type: boolean
+Default: 0
+Flag that can be used to disable version checks for "standard".
+
+Note~
+
+Most forks of "standard" can also be used with syntastic. Just
+set 'g:syntastic_javascript_standard_generic' to 1, and point
+'g:syntastic_javascript_standard_exec' to the fork's executable.  For
+example to use happiness (https://github.com/JedWatson/happiness) instead of
+"standard": >
+    let g:syntastic_javascript_checkers = ["standard"]
+    let g:syntastic_javascript_standard_exec = "happiness"
+    let g:syntastic_javascript_standard_generic = 1
+<
+------------------------------------------------------------------------------
+12. tern-lint                                 *syntastic-javascript-tern_lint*
+
+Name:        tern_lint
+Maintainer:  LCD 47 <lcd047@gmail.com>
+
+"tern-lint" is a static type checker for JavaScript.  See the project's page
+for more information:
+
+    https://github.com/angelozerr/tern-lint
+
+Syntastic requires a version of Vim compiled with the |+byte_offset| feature
+to use this checker.
+
+Checker options~
+
+This checker is initialised using the "makeprgBuild()" function and thus it
+accepts the standard options described at |syntastic-config-makeprg|.
+
+Note~
+
+"tern-lint" recursively scans files starting from (Vim's idea of) the current
+directory, regardless of the current file.
+
+==============================================================================
+SYNTAX CHECKERS FOR JSON                             *syntastic-checkers-json*
+
+The following checkers are available for JSON (filetype "json"):
+
+    1. JSONLint.................|syntastic-json-jsonlint|
+    2. jsonval..................|syntastic-json-jsonval|
+
+------------------------------------------------------------------------------
+1. JSONLint                                          *syntastic-json-jsonlint*
+
+Name:        jsonlint
+Maintainer:  Miller Medeiros <contact@millermedeiros.com>
+
+"JSONLint" is a validator for JSON. See the project's page for details:
+
+    http://jsonlint.com/
+
+Installation~
+
+Install it with: >
+    npm install -g jsonlint
+<
+Checker options~
+
+This checker is initialised using the "makeprgBuild()" function and thus it
+accepts the standard options described at |syntastic-config-makeprg|.
+
+------------------------------------------------------------------------------
+2. jsonval                                            *syntastic-json-jsonval*
+
+Name:        jsonval
+Maintainer:  Miller Medeiros <contact@millermedeiros.com>
+
+"jsonval" is a validator for JSON. See the project's page at GitHub for
+details:
+
+    https://github.com/dangerousben/jsonval
+
+Checker options~
+
+This checker is initialised using the "makeprgBuild()" function and thus it
+accepts the standard options described at |syntastic-config-makeprg|.
+
+==============================================================================
+SYNTAX CHECKERS FOR LESS                             *syntastic-checkers-less*
+
+The following checkers are available for LESS (filetype "less"):
+
+    1. lessc....................|syntastic-less-lessc|
+    2. RECESS...................|syntastic-less-recess|
+
+------------------------------------------------------------------------------
+1. lessc                                                *syntastic-less-lessc*
+
+Name:        lessc
+Maintainer:  Julien Blanchard <julien@sideburns.eu>
+
+"lessc" is a compiler for LESS. See the project's page for details:
+
+    http://lesscss.org/
+
+Checker options~
+
+This checker is initialised using the "makeprgBuild()" function and thus it
+accepts the standard options described at |syntastic-config-makeprg|.
+
+Additionally:
+                                            *'g:syntastic_less_use_less_lint'*
+Type: boolean
+Default: 0
+Flag that can be set to instruct syntastic to run "less-lint" instead of
+"less".
+
+------------------------------------------------------------------------------
+2. RECESS                                              *syntastic-less-recess*
+
+Name:        recess
+Maintainer:  Tim Carry <tim@pixelastic.com>
+
+"RECESS" is a code quality tool for CSS built on top of LESS. See the
+project's page for details:
+
+    http://twitter.github.io/recess/
+
+Checker options~
+
+This checker is initialised using the "makeprgBuild()" function and thus it
+accepts the standard options described at |syntastic-config-makeprg|.
+
+See also: |syntastic-css-recess|.
+
+==============================================================================
+SYNTAX CHECKERS FOR LEX                               *syntastic-checkers-lex*
+
+The following checkers are available for Lex (filetype "lex"):
+
+    1. flex.....................|syntastic-lex-flex|
+
+------------------------------------------------------------------------------
+1. flex                                                   *syntastic-lex-flex*
+
+Name:        flex
+Maintainer:  LCD 47 <lcd047@gmail.com>
+
+"Flex" is the GNU implementation of the standard UNIX lexical analyzer "lex"
+(http://en.wikipedia.org/wiki/Lex_programming_tool). See the project's page
+for more information:
+
+    http://flex.sourceforge.net/
+
+Checker options~
+
+This checker is initialised using the "makeprgBuild()" function and thus it
+accepts the standard options described at |syntastic-config-makeprg|.
+
+==============================================================================
+SYNTAX CHECKERS FOR LIMBO                           *syntastic-checkers-limbo*
+
+The following checkers are available for Limbo (filetype "limbo"):
+
+    1. Limbo....................|syntastic-limbo-limbo|
+
+------------------------------------------------------------------------------
+1. Limbo                                               *syntastic-limbo-limbo*
+
+Name:        limbo
+Maintainer:  Alex Efros <powerman-asdf@ya.ru>
+
+"Limbo" is a compiler for the Limbo language
+(http://doc.cat-v.org/inferno/4th_edition/limbo_language/), the
+language used to write applications for the "Inferno" operating system
+(http://doc.cat-v.org/inferno/). See the "Inferno" project's page for
+a reference implementation:
+
+    http://code.google.com/p/inferno-os/
+
+Checker options~
+
+This checker is initialised using the "makeprgBuild()" function and thus it
+accepts the standard options described at |syntastic-config-makeprg|.
+
+==============================================================================
+SYNTAX CHECKERS FOR LISP                             *syntastic-checkers-lisp*
+
+The following checkers are available for LISP (filetype "lisp"):
+
+    1. CLISP....................|syntastic-lisp-clisp|
+
+------------------------------------------------------------------------------
+1. CLISP                                                *syntastic-lisp-clisp*
+
+Name:        clisp
+Maintainer:  Karl Yngve Lervåg <karl.yngve@lervag.net>
+
+"CLISP" is an interpreter for LISP programs. See the project's page for
+details:
+
+    http://www.clisp.org/
+
+Checker options~
+
+This checker is initialised using the "makeprgBuild()" function and thus it
+accepts the standard options described at |syntastic-config-makeprg|.
+
+==============================================================================
+SYNTAX CHECKERS FOR LLVM                             *syntastic-checkers-llvm*
+
+The following checkers are available for LLVM (filetype "llvm"):
+
+    1. LLVM.....................|syntastic-llvm-llvm|
+
+------------------------------------------------------------------------------
+1. LLVM                                                  *syntastic-llvm-llvm*
+
+Name:        llvm
+Maintainer:  Andrew Kelley <superjoe30@gmail.com>
+
+"LLVM" is the intermediate language for the LLVM compilers (http://llvm.org/).
+See the reference manual for details:
+
+    http://llvm.org/docs/LangRef.html
+
+Checker options~
+
+This checker is initialised using the "makeprgBuild()" function and thus it
+accepts the standard options described at |syntastic-config-makeprg|.
+
+==============================================================================
+SYNTAX CHECKERS FOR LUA                               *syntastic-checkers-lua*
+
+The following checkers are available for Lua (filetype "lua"):
+
+    1. luac.....................|syntastic-lua-luac|
+    2. luacheck.................|syntastic-lua-luacheck|
+
+------------------------------------------------------------------------------
+1. luac                                                   *syntastic-lua-luac*
+
+Name:        luac
+Maintainer:  Gregor Uhlenheuer <kongo2002@gmail.com>
+
+"luac" is a compiler for Lua. See the tool's manual for details:
+
+    http://www.lua.org/manual/
+
+Checker options~
+
+This checker is initialised using the "makeprgBuild()" function and thus it
+accepts the standard options described at |syntastic-config-makeprg|.
+
+Note~
+
+"luac" truncates filenames when the full path of the files involved is longer
+than a certain fixed amount. Syntastic can't detect this situation, and will
+silently ignore error messages with truncated filenames.
+
+------------------------------------------------------------------------------
+2. luacheck                                           *syntastic-lua-luacheck*
+
+Name:        luacheck
+Maintainer:  Thiago Bastos <tbastos@tbastos.com>
+
+"Luacheck" is a tool for static analysis of Lua code. See the project's page
+for details:
+
+    https://github.com/mpeterv/luacheck
+
+In contrast to "luac" (see |syntastic-lua-luac|) which only flags syntax
+errors, this checker detects code smells, so you probably want to enable both
+when available.
+
+Checker options~
+
+This checker is initialised using the "makeprgBuild()" function and thus it
+accepts the standard options described at |syntastic-config-makeprg|.
+
+Note~
+
+A sensible set of options for LUA projects might be something like this: >
+    let g:syntastic_check_on_open = 1
+    let g:syntastic_lua_checkers = ["luac", "luacheck"]
+    let g:syntastic_lua_luacheck_args = "--no-unused-args" 
+<
+==============================================================================
+SYNTAX CHECKERS FOR MARKDOWN                     *syntastic-checkers-markdown*
+
+The following checkers are available for Markdown (filetype "markdown"):
+
+    1. Markdown lint tool.......|syntastic-markdown-mdl|
+    2. textlint.................|syntastic-markdown-textlint|
+
+------------------------------------------------------------------------------
+1. Markdown lint tool                                 *syntastic-markdown-mdl*
+
+Name:        mdl
+Maintainer:  Charles Beynon <etothepiipower@gmail.com>
+
+"Markdown lint tool" is a style checker for Markdown files. See the project's
+page at GitHub for details:
+
+    https://github.com/mivok/markdownlint
+
+Installation~
+
+Install it with: >
+    gem install mdl
+<
+Checker options~
+
+This checker is initialised using the "makeprgBuild()" function and thus it
+accepts the standard options described at |syntastic-config-makeprg|.
+
+Note~
+
+You can also use the "Node.js"-based "markdownlint-cli" as a checker instead
+of "mdl":
+
+    https://github.com/igorshubovych/markdownlint-cli
+
+To do that, you have to point 'g:syntastic_markdown_mdl_exec' to
+"markdownlint", and set 'g:syntastic_markdown_mdl_args' to an empty string (or
+to a set of valid "markdownlint-cli" options): >
+    let g:syntastic_markdown_mdl_exec = "markdownlint"
+    let g:syntastic_markdown_mdl_args = ""
+<
+------------------------------------------------------------------------------
+2. textlint                                      *syntastic-markdown-textlint*
+
+Name:        textlint
+Maintainer:  LCD 47 <lcd047@gmail.com>
+
+"textlint" is a natural language linter for text, Markdown, and HTML files.
+See the project's page for details:
+
+    https://textlint.github.io/
+
+Checker options~
+
+This checker is initialised using the "makeprgBuild()" function and thus it
+accepts the standard options described at |syntastic-config-makeprg|.
+
+See also: |syntastic-html-textlint|, |syntastic-text-textlint|.
+
+==============================================================================
+SYNTAX CHECKERS FOR MATLAB                         *syntastic-checkers-matlab*
+
+The following checkers are available for MATLAB (filetype "matlab"):
+
+    1. mlint....................|syntastic-matlab-mlint|
+
+------------------------------------------------------------------------------
+1. mlint                                              *syntastic-matlab-mlint*
+
+Name:        mlint
+Maintainer:  Jason Graham <jason@the-graham.com>
+
+"mlint" is a code checker for MATLAB. The "mlint" binary is distributed with
+the "MATLAB" package:
+
+    http://www.mathworks.com/help/matlab/
+
+Checker options~
+
+This checker is initialised using the "makeprgBuild()" function and thus it
+accepts the standard options described at |syntastic-config-makeprg|.
+
+==============================================================================
+SYNTAX CHECKERS FOR MERCURY                       *syntastic-checkers-mercury*
+
+The following checkers are available for Mercury (filetype "mercury"):
+
+    1. mmc......................|syntastic-mercury-mmc|
+
+------------------------------------------------------------------------------
+1. mmc                                                 *syntastic-mercury-mmc*
+
+Name:        mmc
+Maintainer:  Joshua Rahm <joshuarahm@gmail.com>
+
+"mmc" is a compiler for Mercury. See Mercury's page for more details:
+
+    http://www.mercurylang.org/
+
+Checker options~
+
+This checker is initialised using the "makeprgBuild()" function and thus it
+accepts the standard options described at |syntastic-config-makeprg|.
+
+==============================================================================
+SYNTAX CHECKERS FOR NASM                             *syntastic-checkers-nasm*
+
+The following checkers are available for NASM (filetype "nasm"):
+
+    1. nasm.....................|syntastic-nasm-nasm|
+
+------------------------------------------------------------------------------
+1. nasm                                                  *syntastic-nasm-nasm*
+
+Name:        nasm
+Maintainer:  HĂĽvard Pettersson <haavard.pettersson@gmail.com>
+
+"NASM" is an assembler and disassembler for the Intel x86 architecture. See
+the project's page for details:
+
+    http://www.nasm.us/
+
+Checker options~
+
+This checker is initialised using the "makeprgBuild()" function and thus it
+accepts the standard options described at |syntastic-config-makeprg|.
+
+==============================================================================
+SYNTAX CHECKERS FOR NIX                               *syntastic-checkers-nix*
+
+The following checkers are available for Nix (filetype "nix"):
+
+    1. Nix......................|syntastic-nix-nix|
+
+------------------------------------------------------------------------------
+1. Nix                                                     *syntastic-nix-nix*
+
+Name:        nix
+Maintainer:  Tim Cuthbertson <tim@gfxmonk.net>
+
+"Nix" is a checker for language "Nix" using "nix-instantiate". See the
+project's page for details:
+
+    http://nixos.org/
+
+Checker options~
+
+This checker is initialised using the "makeprgBuild()" function and thus it
+accepts the standard options described at |syntastic-config-makeprg|.
+
+==============================================================================
+SYNTAX CHECKERS FOR NROFF                           *syntastic-checkers-nroff*
+
+The following checkers are available for nroff (filetype "nroff"):
+
+    1. Igor.....................|syntastic-nroff-igor|
+    2. mandoc...................|syntastic-nroff-mandoc|
+
+------------------------------------------------------------------------------
+1. Igor                                                 *syntastic-nroff-igor*
+
+Name:        igor
+Maintainer:  LCD 47 <lcd047@gmail.com>
+
+"Igor" is a proofreader for DocBook SGML, man pages, and text files used by
+the FreeBSD project (https://www.freebsd.org/). See the author's presentation
+for details:
+
+    http://www.youtube.com/watch?v=sczHqUPygZY
+
+The latest version can be obtained from Glen Barber's repository:
+
+    http://docscripts.glenbarber.us/tags/igor/
+
+Checker options~
+
+This checker is initialised using the "makeprgBuild()" function and thus it
+accepts the standard options described at |syntastic-config-makeprg|.
+
+See also: |syntastic-docbk-igor|, |syntastic-text-igor|.
+
+------------------------------------------------------------------------------
+2. mandoc                                             *syntastic-nroff-mandoc*
+
+Name:        mandoc
+Maintainer:  LCD 47 <lcd047@gmail.com>
+
+See the project's page for details:
+
+    http://mdocml.bsd.lv/
+
+Checker options~
+
+This checker is initialised using the "makeprgBuild()" function and thus it
+accepts the standard options described at |syntastic-config-makeprg|.
+
+==============================================================================
+SYNTAX CHECKERS FOR OBJECTIVE-C                      *syntastic-checkers-objc*
+
+The following checkers are available for Objective-C (filetype "objc"):
+
+    1. GCC......................|syntastic-objc-gcc|
+    2. OClint...................|syntastic-objc-oclint|
+
+------------------------------------------------------------------------------
+1. GCC                                                    *syntastic-objc-gcc*
+
+Name:        gcc
+Maintainer:  Gregor Uhlenheuer <kongo2002@gmail.com>
+
+Checker options~
+                                                 *'g:syntastic_objc_compiler'*
+Type: string
+Default: "gcc", or "clang" if GCC is not found
+Compiler executable.
+
+                                              *'g:syntastic_objc_errorformat'*
+Type: string
+Default: unset
+Override for the default |'errorformat'|.
+
+                                    *'g:syntastic_objc_remove_include_errors'*
+Type: boolean
+Default: 0
+By default, errors in files included from the file being checked are shown.
+Set this variable to 1 to remove messages about errors in included files.
+Please note that this means syntastic will silently abort checks if there are
+fatal errors in one of the included files.
+
+                                         *'g:syntastic_objc_compiler_options'*
+Type: string
+Default: unset
+Compilation flags (such as defines or include directories) to be passed to the
+checker.
+
+                                              *'g:syntastic_objc_config_file'*
+Type: string
+Default: ".syntastic_objc_config"
+File containing additional compilation flags to be passed to the checker, one
+option per line (cf. |syntastic-config-files|).
+
+                                             *'g:syntastic_objc_include_dirs'*
+Type: array of strings
+Default: []
+Include directories to be passed to the checker, in addition to the above
+compilation flags. You can set it like this: >
+    let g:syntastic_objc_include_dirs = ["includes", "headers"]
+<
+and the corresponding "-Iincludes -Iheaders" will be added to the compilation
+flags.
+
+                                  *'g:syntastic_objc_no_default_include_dirs'*
+Type: boolean
+Default: 0
+By default syntastic adds a number of common include directories to the
+compilation flags, namely: >
+    -I. -I.. -Iinclude -Iincludes -I../include -I../includes
+<
+You can disable this behaviour by setting the above variable to 1.
+
+                                                   *'b:syntastic_objc_cflags'*
+Type: string
+Default: unset
+Buffer-local variable. Additional compilation flags specific to the current
+buffer.
+
+                                             *'g:syntastic_objc_check_header'*
+Type: boolean
+Default: 0
+If the current file is a header (namely if its extension is "h"), all checks
+are silently skipped. You can force syntastic to check header files by
+setting the above variable to 1.
+
+Note~
+
+This checker doesn't call the "makeprgBuild()" function, and thus it ignores
+the usual 'g:syntastic_objc_gcc_<option>' variables. The only exception is
+'g:syntastic_objc_gcc_exec', which can still be used to override the checker's
+executable.
+
+See also: |syntastic-objcpp-gcc|.
+
+------------------------------------------------------------------------------
+2. OClint                                              *syntastic-objc-oclint*
+
+Name:        oclint
+Maintainer:  "UnCO" Lin <undercooled@lavabit.com>
+
+"OClint" is a static code analysis tool. See the project's page for details:
+
+    http://oclint.org/
+
+Checker options~
+
+This checker is initialised using the "makeprgBuild()" function and thus it
+accepts the standard options described at |syntastic-config-makeprg|.
+
+Additionally:
+
+                                            'g:syntastic_oclint_config_file'
+Type: string
+Default: ".syntastic_oclint_config"
+File containing compilation flags (such as defines or include directories),
+one option per line (cf. |syntastic-config-files|).
+
+See also: |syntastic-objcpp-oclint|.
+
+==============================================================================
+SYNTAX CHECKERS FOR OBJECTIVE-C++                  *syntastic-checkers-objcpp*
+
+The following checkers are available for Objective-C++ (filetype "objcpp"):
+
+    1. GCC......................|syntastic-objcpp-gcc|
+    2. OClint...................|syntastic-objcpp-oclint|
+
+------------------------------------------------------------------------------
+1. GCC                                                  *syntastic-objcpp-gcc*
+
+Name:        gcc
+Maintainer:  Gregor Uhlenheuer <kongo2002@gmail.com>
+
+Checker options~
+                                               *'g:syntastic_objcpp_compiler'*
+Type: string
+Default: "gcc", or "clang" if GCC is not found
+Compiler executable.
+
+                                            *'g:syntastic_objcpp_errorformat'*
+Type: string
+Default: unset
+Override for the default |'errorformat'|.
+
+                                  *'g:syntastic_objcpp_remove_include_errors'*
+Type: boolean
+Default: 0
+By default, errors in files included from the file being checked are shown.
+Set this variable to 1 to remove messages about errors in included files.
+Please note that this means syntastic will silently abort checks if there are
+fatal errors in one of the included files.
+
+                                       *'g:syntastic_objcpp_compiler_options'*
+Type: string
+Default: unset
+Compilation flags (such as defines or include directories) to be passed to the
+checker.
+
+                                            *'g:syntastic_objcpp_config_file'*
+Type: string
+Default: ".syntastic_objcpp_config"
+File containing additional compilation flags to be passed to the checker, one
+option per line (cf. |syntastic-config-files|).
+
+                                           *'g:syntastic_objcpp_include_dirs'*
+Type: array of strings
+Default: []
+Include directories to be passed to the checker, in addition to the above
+compilation flags. You can set it like this: >
+    let g:syntastic_objcpp_include_dirs = ["includes", "headers"]
+<
+and the corresponding "-Iincludes -Iheaders" will be added to the compilation
+flags.
+
+                                *'g:syntastic_objcpp_no_default_include_dirs'*
+Type: boolean
+Default: 0
+By default syntastic adds a number of common include directories to the
+compilation flags, namely: >
+    -I. -I.. -Iinclude -Iincludes -I../include -I../includes
+<
+You can disable this behaviour by setting the above variable to 1.
+
+                                                 *'b:syntastic_objcpp_cflags'*
+Type: string
+Default: unset
+Buffer-local variable. Additional compilation flags specific to the current
+buffer.
+
+                                           *'g:syntastic_objcpp_check_header'*
+Type: boolean
+Default: 0
+If the current file is a header (namely if its extension is "h"), all checks
+are silently skipped. You can force syntastic to check header files by
+setting the above variable to 1.
+
+Note~
+
+This c