syntastic upgrade
authorTomas Zeman <tzeman@volny.cz>
Wed, 06 Nov 2013 14:33:18 +0100
changeset 37 7cb1d50248a9
parent 30 1c032440b4bf
child 38 3afc2ae852e5
syntastic upgrade
config/.vim/autoload/syntastic/c.vim
config/.vim/autoload/syntastic/makeprg.vim
config/.vim/autoload/syntastic/postprocess.vim
config/.vim/autoload/syntastic/util.vim
config/.vim/doc/syntastic.txt
config/.vim/doc/tags
config/.vim/ftplugin/coffee.vim
config/.vim/plugin/syntastic.vim
config/.vim/plugin/syntastic/autoloclist.vim
config/.vim/plugin/syntastic/balloons.vim
config/.vim/plugin/syntastic/checker.vim
config/.vim/plugin/syntastic/cursor.vim
config/.vim/plugin/syntastic/highlighting.vim
config/.vim/plugin/syntastic/loclist.vim
config/.vim/plugin/syntastic/makeprg_builder.vim
config/.vim/plugin/syntastic/modemap.vim
config/.vim/plugin/syntastic/notifiers.vim
config/.vim/plugin/syntastic/registry.vim
config/.vim/plugin/syntastic/signs.vim
config/.vim/syntax_checkers/ada/gcc.vim
config/.vim/syntax_checkers/applescript.vim
config/.vim/syntax_checkers/applescript/osacompile.vim
config/.vim/syntax_checkers/asciidoc/asciidoc.vim
config/.vim/syntax_checkers/c.vim
config/.vim/syntax_checkers/c/checkpatch.vim
config/.vim/syntax_checkers/c/gcc.vim
config/.vim/syntax_checkers/c/make.vim
config/.vim/syntax_checkers/c/oclint.vim
config/.vim/syntax_checkers/c/sparse.vim
config/.vim/syntax_checkers/c/splint.vim
config/.vim/syntax_checkers/c/ycm.vim
config/.vim/syntax_checkers/co/coco.vim
config/.vim/syntax_checkers/coffee.vim
config/.vim/syntax_checkers/coffee/coffee.vim
config/.vim/syntax_checkers/coffee/coffeelint.vim
config/.vim/syntax_checkers/coq/coqtop.vim
config/.vim/syntax_checkers/cpp.vim
config/.vim/syntax_checkers/cpp/cpplint.vim
config/.vim/syntax_checkers/cpp/gcc.vim
config/.vim/syntax_checkers/cpp/oclint.vim
config/.vim/syntax_checkers/cpp/ycm.vim
config/.vim/syntax_checkers/cs/mcs.vim
config/.vim/syntax_checkers/css.vim
config/.vim/syntax_checkers/css/csslint.vim
config/.vim/syntax_checkers/css/phpcs.vim
config/.vim/syntax_checkers/css/prettycss.vim
config/.vim/syntax_checkers/cucumber.vim
config/.vim/syntax_checkers/cucumber/cucumber.vim
config/.vim/syntax_checkers/cuda.vim
config/.vim/syntax_checkers/cuda/nvcc.vim
config/.vim/syntax_checkers/d/dmd.vim
config/.vim/syntax_checkers/dart/dart_analyzer.vim
config/.vim/syntax_checkers/docbk.vim
config/.vim/syntax_checkers/docbk/xmllint.vim
config/.vim/syntax_checkers/efm_perl.pl
config/.vim/syntax_checkers/elixir/elixir.vim
config/.vim/syntax_checkers/erlang.vim
config/.vim/syntax_checkers/erlang/erlang.vim
config/.vim/syntax_checkers/erlang/erlang_check_file.erl
config/.vim/syntax_checkers/erlang_check_file.erl
config/.vim/syntax_checkers/eruby.vim
config/.vim/syntax_checkers/eruby/ruby.vim
config/.vim/syntax_checkers/fortran.vim
config/.vim/syntax_checkers/fortran/gfortran.vim
config/.vim/syntax_checkers/gentoo_metadata.vim
config/.vim/syntax_checkers/go.vim
config/.vim/syntax_checkers/go/6g.vim
config/.vim/syntax_checkers/go/go.vim
config/.vim/syntax_checkers/go/gofmt.vim
config/.vim/syntax_checkers/go/golint.vim
config/.vim/syntax_checkers/go/govet.vim
config/.vim/syntax_checkers/haml.vim
config/.vim/syntax_checkers/haml/haml.vim
config/.vim/syntax_checkers/haskell.vim
config/.vim/syntax_checkers/haskell/ghc-mod.vim
config/.vim/syntax_checkers/haskell/hdevtools.vim
config/.vim/syntax_checkers/haskell/hlint.vim
config/.vim/syntax_checkers/haxe.vim
config/.vim/syntax_checkers/haxe/haxe.vim
config/.vim/syntax_checkers/hss/hss.vim
config/.vim/syntax_checkers/html.vim
config/.vim/syntax_checkers/html/tidy.vim
config/.vim/syntax_checkers/html/validator.vim
config/.vim/syntax_checkers/html/w3.vim
config/.vim/syntax_checkers/java/checkstyle.vim
config/.vim/syntax_checkers/java/javac.vim
config/.vim/syntax_checkers/javascript.vim
config/.vim/syntax_checkers/javascript/closurecompiler.vim
config/.vim/syntax_checkers/javascript/gjslint.vim
config/.vim/syntax_checkers/javascript/jshint.vim
config/.vim/syntax_checkers/javascript/jsl.vim
config/.vim/syntax_checkers/javascript/jslint.vim
config/.vim/syntax_checkers/json.vim
config/.vim/syntax_checkers/json/jsonlint.vim
config/.vim/syntax_checkers/json/jsonval.vim
config/.vim/syntax_checkers/less.vim
config/.vim/syntax_checkers/less/less-lint.coffee
config/.vim/syntax_checkers/less/less-lint.js
config/.vim/syntax_checkers/less/lessc.vim
config/.vim/syntax_checkers/lisp/clisp.vim
config/.vim/syntax_checkers/llvm/llvm.vim
config/.vim/syntax_checkers/lua.vim
config/.vim/syntax_checkers/lua/luac.vim
config/.vim/syntax_checkers/matlab.vim
config/.vim/syntax_checkers/matlab/mlint.vim
config/.vim/syntax_checkers/nasm/nasm.vim
config/.vim/syntax_checkers/nroff/mandoc.vim
config/.vim/syntax_checkers/objc/gcc.vim
config/.vim/syntax_checkers/objc/oclint.vim
config/.vim/syntax_checkers/objc/ycm.vim
config/.vim/syntax_checkers/objcpp/gcc.vim
config/.vim/syntax_checkers/objcpp/oclint.vim
config/.vim/syntax_checkers/objcpp/ycm.vim
config/.vim/syntax_checkers/ocaml.vim
config/.vim/syntax_checkers/ocaml/camlp4o.vim
config/.vim/syntax_checkers/perl.vim
config/.vim/syntax_checkers/perl/efm_perl.pl
config/.vim/syntax_checkers/perl/perl.vim
config/.vim/syntax_checkers/perl/perlcritic.vim
config/.vim/syntax_checkers/perl/podchecker.vim
config/.vim/syntax_checkers/php.vim
config/.vim/syntax_checkers/php/php.vim
config/.vim/syntax_checkers/php/phpcs.vim
config/.vim/syntax_checkers/php/phpmd.vim
config/.vim/syntax_checkers/pod/podchecker.vim
config/.vim/syntax_checkers/puppet.vim
config/.vim/syntax_checkers/puppet/puppet.vim
config/.vim/syntax_checkers/puppet/puppetlint.vim
config/.vim/syntax_checkers/python.vim
config/.vim/syntax_checkers/python/flake8.vim
config/.vim/syntax_checkers/python/pep257.vim
config/.vim/syntax_checkers/python/pep8.vim
config/.vim/syntax_checkers/python/py3kwarn.vim
config/.vim/syntax_checkers/python/pyflakes.vim
config/.vim/syntax_checkers/python/pylama.vim
config/.vim/syntax_checkers/python/pylint.vim
config/.vim/syntax_checkers/python/python.vim
config/.vim/syntax_checkers/rst.vim
config/.vim/syntax_checkers/rst/rst2pseudoxml.vim
config/.vim/syntax_checkers/ruby.vim
config/.vim/syntax_checkers/ruby/jruby.vim
config/.vim/syntax_checkers/ruby/macruby.vim
config/.vim/syntax_checkers/ruby/mri.vim
config/.vim/syntax_checkers/ruby/rubocop.vim
config/.vim/syntax_checkers/rust.vim
config/.vim/syntax_checkers/rust/rustc.vim
config/.vim/syntax_checkers/sass.vim
config/.vim/syntax_checkers/sass/sass.vim
config/.vim/syntax_checkers/scala/fsc.vim
config/.vim/syntax_checkers/scala/scalac.vim
config/.vim/syntax_checkers/scss.vim
config/.vim/syntax_checkers/scss/sass.vim
config/.vim/syntax_checkers/sh.vim
config/.vim/syntax_checkers/sh/checkbashisms.vim
config/.vim/syntax_checkers/sh/sh.vim
config/.vim/syntax_checkers/slim/slimrb.vim
config/.vim/syntax_checkers/tcl.vim
config/.vim/syntax_checkers/tcl/nagelfar.vim
config/.vim/syntax_checkers/tex.vim
config/.vim/syntax_checkers/tex/chktex.vim
config/.vim/syntax_checkers/tex/lacheck.vim
config/.vim/syntax_checkers/text/atdtool.vim
config/.vim/syntax_checkers/twig/twiglint.vim
config/.vim/syntax_checkers/typescript/tsc.vim
config/.vim/syntax_checkers/vala.vim
config/.vim/syntax_checkers/vala/valac.vim
config/.vim/syntax_checkers/vhdl/ghdl.vim
config/.vim/syntax_checkers/xhtml.vim
config/.vim/syntax_checkers/xhtml/tidy.vim
config/.vim/syntax_checkers/xml.vim
config/.vim/syntax_checkers/xml/xmllint.vim
config/.vim/syntax_checkers/xslt.vim
config/.vim/syntax_checkers/xslt/xmllint.vim
config/.vim/syntax_checkers/yaml.vim
config/.vim/syntax_checkers/yaml/jsyaml.vim
config/.vim/syntax_checkers/z80/z80syntaxchecker.vim
config/.vim/syntax_checkers/zpt.vim
config/.vim/syntax_checkers/zpt/zptlint.vim
config/.vim/syntax_checkers/zsh/zsh.vim
--- a/config/.vim/autoload/syntastic/c.vim	Thu Sep 05 16:23:33 2013 +0200
+++ b/config/.vim/autoload/syntastic/c.vim	Wed Nov 06 14:33:18 2013 +0100
@@ -38,6 +38,74 @@
     call s:RegHandler('php\.h', 'syntastic#c#CheckPhp', [])
 endfunction
 
+" default include directories
+let s:default_includes = [ '.', '..', 'include', 'includes',
+            \ '../include', '../includes' ]
+
+" convenience function to determine the 'null device' parameter
+" based on the current operating system
+function! syntastic#c#GetNullDevice()
+    if has('win32')
+        return '-o nul'
+    elseif has('unix') || has('mac')
+        return '-o /dev/null'
+    endif
+    return ''
+endfunction
+
+" get the gcc include directory argument depending on the default
+" includes and the optional user-defined 'g:syntastic_c_include_dirs'
+function! syntastic#c#GetIncludeDirs(filetype)
+    let include_dirs = []
+
+    if !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), '"-I" . v:val'), ' ')
+endfunction
+
+" 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)
+    " search in the current file's directory upwards
+    let config = findfile(a:file, '.;')
+    if config == '' || !filereadable(config) | return '' | endif
+
+    " convert filename into absolute path
+    let filepath = substitute(fnamemodify(config, ':p:h'), '\', '/', 'g')
+
+    " try to read config file
+    try
+        let lines = map(readfile(config),
+                    \ 'substitute(v:val, ''\'', ''/'', ''g'')')
+    catch /E484/
+        return ''
+    endtry
+
+    let parameters = []
+    for line in lines
+        let matches = matchlist(line, '\C^\s*-I\s*\(\S\+\)')
+        if matches != [] && matches[1] != ''
+            " this one looks like an absolute path
+            if match(matches[1], '^\%(/\|\a:\)') != -1
+                call add(parameters, '-I' . matches[1])
+            else
+                call add(parameters, '-I' . filepath . '/' . matches[1])
+            endif
+        else
+            call add(parameters, line)
+        endif
+    endfor
+
+    return join(parameters, ' ')
+endfunction
+
 " search the first 100 lines for include statements that are
 " given in the handlers dictionary
 function! syntastic#c#SearchHeaders()
@@ -65,7 +133,7 @@
     " search included headers
     for hfile in files
         if hfile != ''
-            let filename = expand('%:p:h') . ((has('win32') || has('win64')) ?
+            let filename = expand('%:p:h') . (has('win32') ?
                         \ '\' : '/') . hfile
             try
                 let lines = readfile(filename, '', 100)
@@ -131,7 +199,7 @@
     if executable('ruby')
         if !exists('s:ruby_flags')
             let s:ruby_flags = system('ruby -r rbconfig -e '
-                        \ . '''puts Config::CONFIG["archdir"]''')
+                        \ . '''puts RbConfig::CONFIG["rubyhdrdir"] || RbConfig::CONFIG["archdir"]''')
             let s:ruby_flags = substitute(s:ruby_flags, "\n", '', '')
             let s:ruby_flags = ' -I' . s:ruby_flags
         endif
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/config/.vim/autoload/syntastic/makeprg.vim	Wed Nov 06 14:33:18 2013 +0100
@@ -0,0 +1,50 @@
+if exists("g:loaded_syntastic_makeprg_autoload")
+    finish
+endif
+let g:loaded_syntastic_makeprg_autoload = 1
+
+"Returns a makeprg of the form
+"
+"[exe] [args] [filename] [post_args] [tail]
+"
+"A (made up) example:
+"    ruby -a -b -c test_file.rb --more --args > /tmp/output
+"
+"To generate this you would call:
+"
+"    let makeprg = syntastic#makeprg#build({
+"                \ 'exe': 'ruby',
+"                \ 'args': '-a -b -c',
+"                \ 'post_args': '--more --args',
+"                \ 'tail': '> /tmp/output',
+"                \ 'filetype': 'ruby',
+"                \ 'subchecker': 'mri' })
+"
+"Note that the current filename is added by default - but can be overridden by
+"passing in an 'fname' arg.
+"
+"Arguments 'filetype' and 'subchecker' are mandatory, handling of composite
+"types and user-defined variables breaks if you omit them.
+"
+"All other options can be overriden by the user with global variables - even
+"when not specified by the checker in syntastic#makeprg#build().
+"
+"E.g. They could override the checker exe with
+"
+"   let g:syntastic_ruby_mri_exe="another_ruby_checker_exe.rb"
+"
+"The general form of the override option is:
+"   syntastic_[filetype]_[subchecker]_[option-name]
+"
+function! syntastic#makeprg#build(opts)
+    let builder = g:SyntasticMakeprgBuilder.New(
+                \ get(a:opts, 'exe', ''),
+                \ get(a:opts, 'args', ''),
+                \ get(a:opts, 'fname', ''),
+                \ get(a:opts, 'post_args', ''),
+                \ get(a:opts, 'tail', ''),
+                \ get(a:opts, 'filetype', ''),
+                \ get(a:opts, 'subchecker', '') )
+
+    return builder.makeprg()
+endfunction
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/config/.vim/autoload/syntastic/postprocess.vim	Wed Nov 06 14:33:18 2013 +0100
@@ -0,0 +1,71 @@
+if exists("g:loaded_syntastic_postprocess_autoload")
+    finish
+endif
+let g:loaded_syntastic_postprocess_autoload = 1
+
+let s:save_cpo = &cpo
+set cpo&vim
+
+function! s:compareErrorItems(a, b)
+    if a:a['bufnr'] != a:b['bufnr']
+        " group by files
+        return a:a['bufnr'] - a:b['bufnr']
+    elseif a:a['lnum'] != a:b['lnum']
+        return a:a['lnum'] - a:b['lnum']
+    elseif a:a['type'] !=? a:b['type']
+        " errors take precedence over warnings
+        return a:a['type'] ==? 'e' ? -1 : 1
+    else
+        return get(a:a, 'col') - get(a:b, 'col')
+    endif
+endfunction
+
+" natural sort
+function! syntastic#postprocess#sort(errors)
+    return sort(a:errors, 's:compareErrorItems')
+endfunction
+
+function syntastic#postprocess#compressWhitespace(errors)
+    let llist = []
+
+    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'], '\s\{2,}', ' ', 'g')
+        call add(llist, e)
+    endfor
+
+    return llist
+endfunction
+
+" remove spurious CR under Cygwin
+function! syntastic#postprocess#cygwinRemoveCR(errors)
+    if has('win32unix')
+        let llist = []
+
+        for e in a:errors
+            let e['text'] = substitute(e['text'], '\r', '', 'g')
+            call add(llist, e)
+        endfor
+    else
+        let llist = a:errors
+    endif
+
+    return llist
+endfunction
+
+" decode XML entities
+function! syntastic#postprocess#decodeXMLEntities(errors)
+    let llist = []
+
+    for e in a:errors
+        let e['text'] = syntastic#util#decodeXMLEntities(e['text'])
+        call add(llist, e)
+    endfor
+
+    return llist
+endfunction
+
+let &cpo = s:save_cpo
+unlet s:save_cpo
+" vim: set et sts=4 sw=4:
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/config/.vim/autoload/syntastic/util.vim	Wed Nov 06 14:33:18 2013 +0100
@@ -0,0 +1,212 @@
+if exists("g:loaded_syntastic_util_autoload")
+    finish
+endif
+let g:loaded_syntastic_util_autoload = 1
+
+let s:save_cpo = &cpo
+set cpo&vim
+
+if !exists("g:syntastic_debug")
+    let g:syntastic_debug = 0
+endif
+
+let s:deprecationNoticesIssued = []
+
+function! syntastic#util#DevNull()
+    if has('win32')
+        return 'NUL'
+    endif
+    return '/dev/null'
+endfunction
+
+"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()
+    for lnum in range(1,5)
+        let line = getline(lnum)
+
+        if line =~ '^#!'
+            let exe = matchstr(line, '^#!\s*\zs[^ \t]*')
+            let args = split(matchstr(line, '^#!\s*[^ \t]*\zs.*'))
+            return {'exe': exe, 'args': args}
+        endif
+    endfor
+
+    return {'exe': '', 'args': []}
+endfunction
+
+" Run 'command' in a shell and parse output as a version string.
+" Returns an array of version components.
+function! syntastic#util#parseVersion(command)
+    return split(matchstr( system(a:command), '\v^\D*\zs\d+(\.\d+)+\ze' ), '\.')
+endfunction
+
+" 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)
+    for index in range(max([len(a:installed), len(a:required)]))
+        if len(a:installed) <= index
+            let installed_element = 0
+        else
+            let installed_element = a:installed[index]
+        endif
+        if len(a:required) <= index
+            let required_element = 0
+        else
+            let required_element = a:required[index]
+        endif
+        if installed_element != required_element
+            return installed_element > required_element
+        endif
+    endfor
+    " Everything matched, so it is at least the required version.
+    return 1
+endfunction
+
+"print as much of a:msg as possible without "Press Enter" prompt appearing
+function! syntastic#util#wideMsg(msg)
+    let old_ruler = &ruler
+    let old_showcmd = &showcmd
+
+    "convert tabs to spaces so that the tabs count towards the window width
+    "as the proper amount of characters
+    let msg = substitute(a:msg, "\t", repeat(" ", &tabstop), "g")
+    let msg = strpart(msg, 0, winwidth(0)-1)
+
+    "This is here because it is possible for some error messages to begin with
+    "\n which will cause a "press enter" prompt. I have noticed this in the
+    "javascript:jshint checker and have been unable to figure out why it
+    "happens
+    let msg = substitute(msg, "\n", "", "g")
+
+    set noruler noshowcmd
+    redraw
+
+    echo msg
+
+    let &ruler=old_ruler
+    let &showcmd=old_showcmd
+endfunction
+
+" Check whether a buffer is loaded, listed, and not hidden
+function! syntastic#util#bufIsActive(buffer)
+    " 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
+
+" start in directory a:where and walk up the parent folders until it
+" finds a file matching a:what; return path to that file
+function! syntastic#util#findInParent(what, where)
+    let here = fnamemodify(a:where, ':p')
+
+    while !empty(here)
+        let p = split(globpath(here, a:what), '\n')
+
+        if !empty(p)
+            return fnamemodify(p[0], ':p')
+        elseif here == '/'
+            break
+        endif
+
+        " 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
+
+" Returns unique elements in a list
+function! syntastic#util#unique(list)
+    let seen = {}
+    let uniques = []
+    for e in a:list
+        if !has_key(seen, e)
+            let seen[e] = 1
+            call add(uniques, e)
+        endif
+    endfor
+    return uniques
+endfunction
+
+" A less noisy shellescape()
+function! syntastic#util#shescape(string)
+    return a:string =~ '\m^[A-Za-z0-9_/.-]\+$' ? a:string : shellescape(a:string)
+endfunction
+
+" A less noisy shellescape(expand())
+function! syntastic#util#shexpand(string)
+    return syntastic#util#shescape(expand(a:string))
+endfunction
+
+" decode XML entities
+function! syntastic#util#decodeXMLEntities(string)
+    let str = a:string
+    let str = substitute(str, '&lt;', '<', 'g')
+    let str = substitute(str, '&gt;', '>', 'g')
+    let str = substitute(str, '&quot;', '"', 'g')
+    let str = substitute(str, '&apos;', "'", 'g')
+    let str = substitute(str, '&amp;', '\&', 'g')
+    return str
+endfunction
+
+function! syntastic#util#debug(msg)
+    if g:syntastic_debug
+        echomsg "syntastic: debug: " . a:msg
+    endif
+endfunction
+
+function! syntastic#util#info(msg)
+    echomsg "syntastic: info: " . a:msg
+endfunction
+
+function! syntastic#util#warn(msg)
+    echohl WarningMsg
+    echomsg "syntastic: warning: " . a:msg
+    echohl None
+endfunction
+
+function! syntastic#util#error(msg)
+    execute "normal \<Esc>"
+    echohl ErrorMsg
+    echomsg "syntastic: error: " . a:msg
+    echohl None
+endfunction
+
+function! syntastic#util#deprecationWarn(msg)
+    if index(s:deprecationNoticesIssued, a:msg) >= 0
+        return
+    endif
+
+    call add(s:deprecationNoticesIssued, a:msg)
+    call syntastic#util#warn(a:msg)
+endfunction
+
+let &cpo = s:save_cpo
+unlet s:save_cpo
+" vim: set et sts=4 sw=4:
--- a/config/.vim/doc/syntastic.txt	Thu Sep 05 16:23:33 2013 +0200
+++ b/config/.vim/doc/syntastic.txt	Wed Nov 06 14:33:18 2013 +0100
@@ -25,41 +25,33 @@
         2.2.Error signs.......................|syntastic-error-signs|
         2.3.Error window......................|syntastic-error-window|
     3.Commands................................|syntastic-commands|
-    4.Options.................................|syntastic-options|
-    5.Writing syntax checkers.................|syntastic-syntax-checkers|
+    4.Global Options..........................|syntastic-global-options|
+    5.Checker Options.........................|syntastic-checker-options|
     6.About...................................|syntastic-about|
-    7.Changelog...............................|syntastic-changelog|
-    8.Credits.................................|syntastic-credits|
-    9.License.................................|syntastic-license|
+    7.License.................................|syntastic-license|
 
 
 ==============================================================================
 1. Intro                                                     *syntastic-intro*
 
+Note: This doc only deals with using syntastic. To learn how to write syntax
+checker integrations, see the guide on the github wiki:
+
+    https://github.com/scrooloose/syntastic/wiki/Syntax-Checker-Guide
+
 Syntastic is a syntax checking plugin that runs files through external syntax
 checkers. This can be done on demand, or automatically as files are saved and
 opened.  If syntax errors are detected, the user is notified and is happy
 because they didn't have to compile their code or execute their script to find
 them.
 
-Syntastic comes in two parts: the syntax checker plugins, and the core script
-(i.e. syntastic.vim). The syntax checker plugins are defined on a per-filetype
-basis where each one wraps up an external syntax checking program. The core
-script delegates off to these plugins and uses their output to provide the
-syntastic functionality. At the time of this writing, syntax checking plugins
-exist for c, coffee, cpp, css, cucumber, cuda, docbk, erlang, eruby, fortran,
-go, haml, haskell, html, javascript, less, lua, matlab, perl, php, puppet,
-python, ruby, sass/scss, sh, tcl, tex, vala, xhtml, xml, xslt, zpt
+Syntastic comes in two parts: the syntax checker plugins, and the core. The
+syntax checker plugins are defined on a per-filetype basis where each one wraps
+up an external syntax checking program. The core script delegates off to these
+plugins and uses their output to provide the syntastic functionality.
 
-Take a look in the syntax_checkers directory for the most up to date list.
-
-If your language is not supported then see |syntastic-syntax-checkers| for
-details on how to implement a syntax checking plugin, and be sure to send me a
-patch ;-)
-
-This plugin is currently only recommended for *nix users. It is functional on
-Windows, but since the syntax checking plugins shell out, the command window
-briefly appears whenever one is executed.
+Take a look in the syntax_checkers directory for a list of supported filetypes
+and checkers.
 
 
 ==============================================================================
@@ -72,21 +64,16 @@
 user of errors. See |syntastic-options| for how to configure and
 activate/deactivate these features.
 
-    * A configurable statusline flag
-    * Lines with errors can have |signs| placed beside them - where a different
-      sign is used for errors and warnings.
-    * A |location-list| can be displayed with error messages for erroneous
-      buffers.
-    * Offending parts of lines can be highlighted (this functionality is only
+    * A statusline flag
+    * Signs beside lines with errors
+    * The |location-list| can be populated with the errors for the associated
+      buffer.
+    * Erroneous parts of lines can be highlighted (this functionality is only
       provided by some syntax checkers).
     * Balloons (if compiled in) can be used to display error messages for
       erroneous lines when hovering the mouse over them.
 
 
-Note: This functionality is only available if a syntax checker plugin is
-present for the filetype of the buffer in question. See
-|syntastic-syntax-checkers| for details.
-
 ------------------------------------------------------------------------------
 2.1. The statusline flag                           *syntastic-statusline-flag*
 
@@ -107,6 +94,30 @@
 the sign column. To enable this feature, use the |'syntastic_enable_signs'|
 option.
 
+Signs are colored using the Error and Todo syntax highlight groups by default.
+If you wish to customize the colors for the signs, you can use the following
+groups:
+    SyntasticErrorSign - For syntax errors, links to 'error' by default
+    SyntasticWarningSign - For syntax warnings, links to 'todo' by default
+    SyntasticStyleErrorSign - For style errors, links to 'SyntasticErrorSign'
+                              by default
+    SyntasticStyleWarningSign - For style warnings, links to
+                                'SyntasticWarningSign' by default
+
+Example: >
+    highlight SyntasticErrorSign guifg=white guibg=red
+<
+To set up highlighting for the line where a sign resides, you can use the
+following highlight groups:
+    SyntasticErrorLine
+    SyntasticWarningLine
+    SyntasticStyleErrorLine - Links to 'SyntasticErrorLine' by default
+    SyntasticStyleWarningLine - Links to 'SyntasticWarningLine' by default
+
+Example: >
+    highlight SyntasticErrorLine guibg=#2f0000
+<
+
 ------------------------------------------------------------------------------
 2.3. The error window                       *:Errors* *syntastic-error-window*
 
@@ -137,9 +148,18 @@
 Manually cause a syntax check to be done. Useful in passive mode, or if the
 current filetype is set to passive. See |'syntastic_mode_map'| for more info.
 
+:SyntasticInfo                                               *:SyntasticInfo*
+
+Output info about what checkers are available and in use for the current
+filetype.
+
+:SyntasticReset                                              *:SyntasticReset*
+
+Resets the list of errors and turns off all error notifiers.
+
 
 ==============================================================================
-4. Options                                                 *syntastic-options*
+4. Global Options                                   *syntastic-global-options*
 
 
                                                    *'syntastic_check_on_open'*
@@ -149,9 +169,26 @@
     let g:syntastic_check_on_open=1
 <
 
+                                                     *'syntastic_check_on_wq'*
+Default: 1
+Normally syntastic runs syntax checks whenever buffers are written to disk.
+If you want to skip these checks when you issue |:wq|, |:x|, and |:ZZ|, set this
+variable to 0. >
+    let g:syntastic_check_on_wq=0
+<
+
+                                                *'syntastic_aggregate_errors'*
+Default: 0
+When enabled, |:SyntasticCheck| runs all checkers that apply, then aggregates
+errors found by all checkers and displays them.  When disabled,
+|:SyntasticCheck| runs each checker in turn, and stops to display the results
+the first time a checker finds any errors. >
+    let g:syntastic_aggregate_errors=1
+<
+
                                               *'syntastic_echo_current_error'*
 Default: 1
-If enabled, syntastic will error message associated with the current line to
+If enabled, syntastic will echo the error associated with the current line to
 the command window. If multiple errors are found, the first will be used. >
     let g:syntastic_echo_current_error=1
 <
@@ -163,6 +200,20 @@
     let g:syntastic_enable_signs=1
 <
 
+                     *'syntastic_error_symbol'* *'syntastic_style_error_symbol'*
+                 *'syntastic_warning_symbol'* *'syntastic_style_warning_symbol'*
+Use this option to control what the syntastic |:sign| text contains. Several
+error symobls can be customized:
+    syntastic_error_symbol - For syntax errors, defaults to '>>'
+    syntastic_style_error_symbol - For style errors, defaults to 'S>'
+    syntastic_warning_symbol - For syntax warnings, defaults to '>>'
+    syntastic_style_warning_symbol - For style warnings, defaults to 'S>'
+
+Example: >
+    let g:syntastic_error_symbol='✗'
+    let g:syntastic_warning_symbol='âš '
+<
+
                                                  *'syntastic_enable_balloons'*
 Default: 1
 Use this option to tell syntastic whether to display error messages in balloons
@@ -171,13 +222,19 @@
 <
 Note that vim must be compiled with |+balloon_eval|.
 
-                                            *'syntastic_enable_highlighting'*
+                                             *'syntastic_enable_highlighting'*
 Default: 1
 Use this option to tell syntastic whether to use syntax highlighting to mark
 errors (where possible). Highlighting can be turned off with the following >
     let g:syntastic_enable_highlighting = 0
 <
 
+                                        *'syntastic_always_populate_loc_list'*
+Default: 0
+Enable this option to tell syntastic to always stick any detected errors into
+the loclist: >
+    let g:syntastic_always_populate_loc_list=1
+<
                                                        *'syntastic_auto_jump'*
 Default: 0
 Enable this option if you want the cursor to jump to the first detected error
@@ -210,6 +267,24 @@
     let g:syntastic_loc_list_height=5
 <
 
+                                                    *'syntastic_ignore_files'*
+Default: []
+Use this option to specify files that syntastic should neither check, nor
+include in error lists. It has to be a list of |regular-expression| patterns.
+The full paths of files (see |::p|) are matched against these patterns, and
+the matches are case sensitive. Use |\c| if you need case insensitive
+patterns. >
+    let g:syntastic_ignore_files=['^/usr/include/', '\c\.h$']
+<
+
+                                                    *'syntastic_filetype_map'*
+Default: {}
+Use this option to map non-standard filetypes to standard ones.  Corresponding
+checkers are mapped accordingly, which allows syntastic to check files with
+non-standard filetypes: >
+    let g:syntastic_filetype_map = { 'latex': 'tex',
+                                   \ 'gentoo-metadata': 'xml' }
+<
 
                                                         *'syntastic_mode_map'*
 Default: { "mode": "active",
@@ -229,7 +304,7 @@
 "mode" can be mapped to one of two values - "active" or "passive". When set to
 active, syntastic does automatic checking whenever a buffer is saved or
 initially opened.  When set to "passive" syntastic only checks when the user
-calls :SyntasticCheck.
+calls |:SyntasticCheck|.
 
 The exceptions to these rules are defined with "active_filetypes" and
 "passive_filetypes". In passive mode, automatic checks are still done
@@ -260,7 +335,7 @@
 
 Default: [Syntax: line:%F (%t)]
 Use this option to control what the syntastic statusline text contains. Several
-magic flags are availble to insert information:
+magic flags are available to insert information:
     %e - number of errors
     %w - number of warnings
     %t - total number of warnings and errors
@@ -286,289 +361,108 @@
 If the buffer had 2 warnings, starting on line 5 then this would appear: >
     [Warn: 5 #2]
 <
+                                                    *'syntastic_full_redraws'*
+Default: 0 in GUI Vim and MacVim, 1 otherwise
+Controls whether syntastic calls |:redraw| or |:redraw!| for screen redraws.
+Changing it can in principle make screen redraws smoother, but it can also
+cause screen flicker, or ghost characters.  Leaving it to the default should
+be safe.
+
+                                                           *'syntastic_debug'*
+Default: 0
+Set this to 1 to enable debugging: >
+    let g:syntastic_debug = 1
+<
+Checkers will then add debugging messages to Vim's |message-history|. You can
+examine these messages with |:mes|.
 
 
 ==============================================================================
-5. Writing syntax checkers                         *syntastic-syntax-checkers*
+5. Checker Options                                 *syntastic-checker-options*
 
+------------------------------------------------------------------------------
+5.1 Telling syntastic which checker to use.
 
-A syntax checker plugin is really nothing more than a single function.  You
-should define them in ~/.vim/syntax_checkers/<filetype>.vim, but this is
-purely for convenience; Syntastic doesn't actually care where these functions
-are defined.
+Stick a line like this in your vimrc: >
+    let g:syntastic_<filetype>_checkers = ['<checker-name>']
+<
+e.g. >
+    let g:syntastic_python_checkers = ['flake8']
+<
 
-A syntax checker plugin must define a function of the form:
->
-    SyntaxCheckers_<filetype>_GetLocList()
+There's also a per-buffer version of this setting, b:syntastic_checkers. Use
+this in an autocmd to configure specific checkers for particular paths: >
+    autocmd FileType python if stridx(expand('%:p'), '/some/path/') == 0 |
+        \ let b:syntastic_checkers = ['pylint'] | endif
 <
-The output of this function must be of the same format as that returned by
-the |getloclist()| function. See |getloclist()| and |getqflist()| for
-details.
+
+To see the list of available checkers for your filetype, look in
+`syntax_checkers/<filetype>/`. The names of the files here correspond to
+'<checker-name>' above.
+
+e.g. Python has the following checkers: flake8, pyflakes, pylint and a
+native python checker.
 
-To achieve this, the function should call |SyntasticMake()| or shell out to a
-syntax checker, parse the output and munge it into the format.
+Some filetypes, like PHP, have style checkers as well as syntax checkers. These
+can be chained together like this: >
+    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'.
+
+------------------------------------------------------------------------------
+5.2 Configuring specific checkers                   *syntastic-config-makeprg*
 
-There are several syntax checker plugins provided with this plugin. The ruby
-one is a good example of |SyntasticMake()|, while the haml one is a good
-example of how to create the data structure manually.
+Most checkers use the 'syntastic#makeprg#build()' function and provide many
+options by default - in fact you can customise every part of the command
+that gets called.
 
-
-SyntasticMake({options})                                     *SyntasticMake()*
-    {options} must be a dictionary. It can contain "makeprg" and "errorformat"
-    as keys (both optional).
+Checkers that use 'syntastic#makeprg#build()' look like this: >
+    let makeprg = syntastic#makeprg#build({
+                \ 'exe': 'ruby',
+                \ 'args': '-a -b -c',
+                \ 'post_args': '--more --args',
+                \ 'tail': '> /tmp/output',
+                \ 'filetype': 'ruby',
+                \ 'subchecker': 'mri' })
+<
 
-    SyntasticMake will run |:lmake| with the given |'makeprg'| and
-    |'errorformat'| (using the current settings if none are supplied). It will
-    store the resulting error list and use it to provide all of the
-    |syntastic-functionality|. The previous makeprg and errorformat settings
-    will then be restored, as well as the location list for the window.  From
-    the user's perspective, it will be as though |:lmake| was never run.
+The 'filetype' and 'subchecker' parameters are mandatory.  All of the other
+parameters above are optional (well, you probably need at least 'exe'), and
+can be overriden by setting global variables - even parameters not specified
+in the call to syntastic#makeprg#build().
 
-    Note that the given "makeprg" and "errorformat" will be set using |:let-&|,
-    so you should not escape spaces.
+E.g. To override the checker exe above, you could do this: >
+    let g:syntastic_ruby_mri_exe="another_ruby_checker_exe.rb"
+<
+To override the args and the tail: >
+    let g:syntastic_ruby_mri_args="--my --args --here"
+    let g:syntastic_ruby_mri_tail="> /tmp/my-output-file-biatch"
+<
 
+The general form of the override options is: >
+    syntastic_[filetype]_[subchecker]_[option-name]
+<
+
+For checkers that do not use the 'syntastic#makeprg#build()' function you
+will have to look at the source code of the checker in question. If there are
+specific options that can be set, these are usually documented at the top of
+the script.
 
 ==============================================================================
 6. About                                                     *syntastic-about*
 
-The author of syntastic is a mighty wild stallion, hear him roar! >
-     _   _ _____ _____ ___ ___ ___ ____ _   _ _
-    | \ | | ____| ____|_ _|_ _|_ _/ ___| | | | |
-    |  \| |  _| |  _|  | | | | | | |  _| |_| | |
-    | |\  | |___| |___ | | | | | | |_| |  _  |_|
-    |_| \_|_____|_____|___|___|___\____|_| |_(_)
+The core maintainers of syntastic are:
+    Martin Grenfell (github: scrooloose)
+    Gregor Uhlenheuer (github: kongo2002)
 
-<
-He likes to trot around in the back yard reading his emails and sipping a
-scolding hot cup of Earl Grey. Email him at martin.grenfell at gmail dot com.
-He can also be found trolling the #vim channel on the freenode IRC network as
-scrooloose.
-
-Bug reports, feedback, suggestions etc are welcomed.
-
-
-The latest official releases will be on vim.org at some point.
-
-The latest dev versions are on github
+Find the latest version of syntastic here:
     http://github.com/scrooloose/syntastic
 
 ==============================================================================
-7. Changelog                                             *syntastic-changelog*
-
-2.3.0
-    - Add syntastic_loc_list_height option
-    - Allow errors to have a "subtype" that is signed differently to standard
-      errors. Currently geared towards differentiating style errors from
-      syntax errors. Currently implemented for phpcs (technosophos).
-    - New checkers for:
-        - yaml
-        - haxe (davidB)
-        - ocaml (edwintorok)
-        - pylint (parantapa)
-        - rust (cjab)
-
-    - Updates to existing checkers:
-        - jslint
-        - jshint (gillesruppert)
-        - fortran (bmattern)
-        - sass
-        - html (darcyparker)
-        - coffee (darcyparker)
-        - docbk (darcyparker)
-        - xml
-        - xslt
-        - less (irrationalfab)
-        - php (AD7six, technosophos)
-        - cuda
-        - python (mitchellh, pneff)
-        - perl (Anthony Carapetis)
-        - c (naoina, zsprackett)
-        - puppet (frimik)
-
-2.2.0
-    - only do syntax checks when files are saved (not when first opened) - add
-      g:syntastic_check_on_open option to get the old behavior back
-    - bug fix with echoing error messages; fixes incompatability with cmd-t (datanoise)
-    - dont allow warnings to mask errors when signing/echoing errors (ashikase)
-    - auto close location list when leaving buffer. (millermedeiros)
-    - update errors appropriately when :SyntasticToggleMode is called
-    - updates/fixes to existing checkers:
-        - javascript/jshint (millermedeiros)
-        - javascript/jslint
-        - c (kongo2002)
-    - Support for new filetypes:
-        - JSON (millermedeiros, tocer)
-        - rst (reStructuredText files) (JNRowe)
-        - gentoo-metadata (JNRowe)
-
-
-2.1.0
-    - when the cursor is on a line containing an error, echo the
-      error msg (kevinw)
-    - various bug fixes and refactoring
-    - updates/fixes to existing checkers:
-        - html (millermedeiros)
-        - erlang
-        - coffeescript
-        - javascript
-        - sh
-        - php (add support for phpcs - technosophos)
-    - add an applescript checker (Zhai Cai)
-    - add support for hyphenated filetypes (JNRowe)
-
-2.0.0
-    - Add support for highlighting the erroneous parts of lines (kstep)
-    - Add support for displaying errors via balloons (kstep)
-    - Add syntastic_mode_map option to give more control over when checking
-      should be done.
-    - Add :SyntasticCheck command to force a syntax check -  useful in passive
-      mode (justone).
-    - Add the option to automatically close the location list, but not
-      automatically open it (milkypostman)
-    - Add syntastic_auto_jump option to automatically jump to the first
-      error (milkypostman)
-    - Only source syntax checkers as needed - instead of loading all of them
-      when vim starts
-
-    - Support for new filetypes:
-        - less (julienXX)
-        - docbook (tpope)
-        - matlab (jasongraham)
-        - go (dtjm)
-        - puppet (uggedal, roman, zsprackett)
-        - haskell (baldo, roman)
-        - tcl (et)
-        - vala (kstep)
-        - cuda (temporaer)
-        - css (oryband, sitedyno)
-        - fortran (Karl Yngve Lervåg)
-        - xml (kusnier)
-        - xslt (kusnier)
-        - erlang (kTT)
-        - zpt (claytron)
-
-    - updates to existing checkers:
-        - javascript (mogren, bryanforbes, cjab, ajduncan)
-        - sass/scss (tmm1, atourino, dlee, epeli)
-        - ruby (changa)
-        - perl (harleypig)
-        - haml (bmihelac)
-        - php (kstep, docteurklein)
-        - python (kstep, soli)
-        - lua (kstep)
-        - html (kstep)
-        - xhtml (kstep)
-        - c (kongo2002, brandonw)
-        - cpp (kongo2002)
-        - coffee (industrial)
-        - eruby (sergevm)
-
-1.2.0
-    - New syntax checkers from github:kongo2002
-      - c (thanks also to github:jperras)
-      - cpp
-      - lua
-      - sh (thanks also to github:jmcantrell)
-    - add coffee syntax checked by github:lstoll
-    - add tex syntax checker
-    - make html checker play nicer with html5, thanks to github:enaeseth
-    - escape filenames properly when invoking syntax checkers, thanks to
-      github:jmcantrell
-    - adjust the ruby syntax checker to avoid some common annoying warnings,
-      thanks to github:robertwahler
-
-1.1.0 [codenamed: tpimp]
-    - Dont load rubygems for ruby/eruby syntax checkers. Thanks tpope.
-    - Improve the javascript syntax checker to catch some warnings that were
-      getting missed. Thanks tpope.
-    - Dont automatically focus the error window. Thanks tpope.
-    - Add support for cucumber [tpope], haskell & perl [Anthony Carapetis],
-      and xhtml
-    - Add commands to enable/disable syntax checking at runtime. See :help
-      syntastic-commands.
-    - Add an option to specifiy syntax checkers that should be disabled by
-      default. See :help syntastic_disabled_filetypes.
-    - Dont use :signs if vim wasnt compiled with support for them.
-)
-
-==============================================================================
-8. Credits                                                 *syntastic-credits*
-
-Thanks to the following people for testing, bug reports, patches etc. They own,
-hard.
-
-    Mikael Fridh (frimik)
-    Patrice Neff (pneff )
-    Gilles Ruppert (gillesruppert)
-    Naoya INADA (naoina)
-    Mitchell Hashimoto (mitchellh)
-    irrationalfab
-    Andy Dawson (AD7six)
-    Parantapa Bhattacharya (parantapa)
-    edwintorok
-    Darcy Parker (darcyparker)
-    bmattern
-    David Bernard (davidB)
-    Aleksey V. Zapparov (ixti)
-    Benji Fisher (benjifisher)
-    Lance Fetters (ashikase)
-    datanoise
-    Giuseppe Rota (grota)
-    tocer
-    James Rowe (JNRowe)
-    Zhai Cai
-    Matt Butcher (technosophos)
-    Kevin Watters (kevinw)
-    Miller Medeiros (millermedeiros)
-    Pawel Salata (kTT)
-    Fjölnir Ãsgeirsson (aptiva)
-    Clayton Parker (claytron)
-    S. Zachariah Sprackett (zsprackett)
-    Sylvain Soliman (soli)
-    Ricardo Catalinas Jiménez (jimenezrick)
-    kusnier
-    Klein Florian (docteurklein)
-    sitedyno
-    Matthew Batema (mlb-)
-    Nate Jones (justone)
-    sergevm
-    Karl Yngve Lervåg
-    Pavel Argentov (argent-smith)
-    Andy Duncan (ajduncan)
-    Antonio Touriño (atourino)
-    Chad Jablonski (cjab)
-    Roman Gonzalez (roman)
-    Tom Wieland (industrial)
-    Ory Band (oryband)
-    Esa-Matti Suuronen (epeli)
-    Brandon Waskiewicz (brandonw)
-    dlee
-    temporaer
-    Jason Graham (jasongraham)
-    Sam Nguyen (dtjm)
-    Claes Mogren (mogren)
-    Eivind Uggedal (uggedal)
-    kstep
-    Andreas Baldeau (baldo)
-    Eric Thomas (et)
-    Brian Donovan (eventualbuddha)
-    Bryan Forbes (bryanforbes)
-    Aman Gupta (tmm1)
-    Donald Ephraim Curtis (milkypostman)
-    Dominique Rose-Rosette (changa)
-    Harley Pig (harleypig)
-    bmihelac
-    Julien Blanchard (julienXX)
-    Gregor Uhlenheuer (kongo2002)
-    Lincoln Stoll
-    Tim Carey-Smith (halorgium)
-    Tim Pope (tpope)
-    Travis Jeffery
-    Anthony Carapetis
-
-
-==============================================================================
-9. License                                                 *syntastic-license*
+7. License                                                 *syntastic-license*
 
 Syntastic is released under the wtfpl.
 See http://sam.zoy.org/wtfpl/COPYING.
+
+ vim:tw=78:sw=4:ft=help:norl:
--- a/config/.vim/doc/tags	Thu Sep 05 16:23:33 2013 +0200
+++ b/config/.vim/doc/tags	Wed Nov 06 14:33:18 2013 +0100
@@ -1,14 +1,25 @@
+'syntastic_aggregate_errors'	syntastic.txt	/*'syntastic_aggregate_errors'*
+'syntastic_always_populate_loc_list'	syntastic.txt	/*'syntastic_always_populate_loc_list'*
 'syntastic_auto_jump'	syntastic.txt	/*'syntastic_auto_jump'*
 'syntastic_auto_loc_list'	syntastic.txt	/*'syntastic_auto_loc_list'*
 'syntastic_check_on_open'	syntastic.txt	/*'syntastic_check_on_open'*
+'syntastic_check_on_wq'	syntastic.txt	/*'syntastic_check_on_wq'*
+'syntastic_debug'	syntastic.txt	/*'syntastic_debug'*
 'syntastic_echo_current_error'	syntastic.txt	/*'syntastic_echo_current_error'*
 'syntastic_enable_balloons'	syntastic.txt	/*'syntastic_enable_balloons'*
 'syntastic_enable_highlighting'	syntastic.txt	/*'syntastic_enable_highlighting'*
 'syntastic_enable_signs'	syntastic.txt	/*'syntastic_enable_signs'*
+'syntastic_error_symbol'	syntastic.txt	/*'syntastic_error_symbol'*
+'syntastic_filetype_map'	syntastic.txt	/*'syntastic_filetype_map'*
+'syntastic_full_redraws'	syntastic.txt	/*'syntastic_full_redraws'*
+'syntastic_ignore_files'	syntastic.txt	/*'syntastic_ignore_files'*
 'syntastic_loc_list_height'	syntastic.txt	/*'syntastic_loc_list_height'*
 'syntastic_mode_map'	syntastic.txt	/*'syntastic_mode_map'*
 'syntastic_quiet_warnings'	syntastic.txt	/*'syntastic_quiet_warnings'*
 'syntastic_stl_format'	syntastic.txt	/*'syntastic_stl_format'*
+'syntastic_style_error_symbol'	syntastic.txt	/*'syntastic_style_error_symbol'*
+'syntastic_style_warning_symbol'	syntastic.txt	/*'syntastic_style_warning_symbol'*
+'syntastic_warning_symbol'	syntastic.txt	/*'syntastic_warning_symbol'*
 :AlignCenter	textformat.txt	/*:AlignCenter*
 :AlignJustify	textformat.txt	/*:AlignJustify*
 :AlignLeft	textformat.txt	/*:AlignLeft*
@@ -19,8 +30,9 @@
 :Errors	syntastic.txt	/*:Errors*
 :SyntasticCheck	syntastic.txt	/*:SyntasticCheck*
 :SyntasticErrors	syntastic.txt	/*:SyntasticErrors*
+:SyntasticInfo	syntastic.txt	/*:SyntasticInfo*
+:SyntasticReset	syntastic.txt	/*:SyntasticReset*
 :SyntasticToggleMode	syntastic.txt	/*:SyntasticToggleMode*
-SyntasticMake()	syntastic.txt	/*SyntasticMake()*
 bufexplorer	bufexplorer.txt	/*bufexplorer*
 bufexplorer-changelog	bufexplorer.txt	/*bufexplorer-changelog*
 bufexplorer-credits	bufexplorer.txt	/*bufexplorer-credits*
@@ -97,18 +109,17 @@
 project.txt	project.txt	/*project.txt*
 syntastic	syntastic.txt	/*syntastic*
 syntastic-about	syntastic.txt	/*syntastic-about*
-syntastic-changelog	syntastic.txt	/*syntastic-changelog*
+syntastic-checker-options	syntastic.txt	/*syntastic-checker-options*
 syntastic-commands	syntastic.txt	/*syntastic-commands*
+syntastic-config-makeprg	syntastic.txt	/*syntastic-config-makeprg*
 syntastic-contents	syntastic.txt	/*syntastic-contents*
-syntastic-credits	syntastic.txt	/*syntastic-credits*
 syntastic-error-signs	syntastic.txt	/*syntastic-error-signs*
 syntastic-error-window	syntastic.txt	/*syntastic-error-window*
 syntastic-functionality	syntastic.txt	/*syntastic-functionality*
+syntastic-global-options	syntastic.txt	/*syntastic-global-options*
 syntastic-intro	syntastic.txt	/*syntastic-intro*
 syntastic-license	syntastic.txt	/*syntastic-license*
-syntastic-options	syntastic.txt	/*syntastic-options*
 syntastic-statusline-flag	syntastic.txt	/*syntastic-statusline-flag*
-syntastic-syntax-checkers	syntastic.txt	/*syntastic-syntax-checkers*
 syntastic.txt	syntastic.txt	/*syntastic.txt*
 textformat-commands	textformat.txt	/*textformat-commands*
 textformat-config	textformat.txt	/*textformat-config*
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/config/.vim/ftplugin/coffee.vim	Wed Nov 06 14:33:18 2013 +0100
@@ -0,0 +1,221 @@
+" Language:    CoffeeScript
+" Maintainer:  Mick Koch <kchmck@gmail.com>
+" URL:         http://github.com/kchmck/vim-coffee-script
+" License:     WTFPL
+
+if exists("b:did_ftplugin")
+  finish
+endif
+
+let b:did_ftplugin = 1
+
+setlocal formatoptions-=t formatoptions+=croql
+setlocal comments=:#
+setlocal commentstring=#\ %s
+setlocal omnifunc=javascriptcomplete#CompleteJS
+
+" Enable CoffeeMake if it won't overwrite any settings.
+if !len(&l:makeprg)
+  compiler coffee
+endif
+
+" Reset the global variables used by CoffeeCompile.
+function! s:CoffeeCompileResetVars()
+  " Position in the source buffer
+  let s:coffee_compile_src_buf = -1
+  let s:coffee_compile_src_pos = []
+
+  " Position in the CoffeeCompile buffer
+  let s:coffee_compile_buf = -1
+  let s:coffee_compile_win = -1
+  let s:coffee_compile_pos = []
+
+  " If CoffeeCompile is watching a buffer
+  let s:coffee_compile_watch = 0
+endfunction
+
+" Save the cursor position when moving to and from the CoffeeCompile buffer.
+function! s:CoffeeCompileSavePos()
+  let buf = bufnr('%')
+  let pos = getpos('.')
+
+  if buf == s:coffee_compile_buf
+    let s:coffee_compile_pos = pos
+  else
+    let s:coffee_compile_src_buf = buf
+    let s:coffee_compile_src_pos = pos
+  endif
+endfunction
+
+" Restore the cursor to the source buffer.
+function! s:CoffeeCompileRestorePos()
+  let win = bufwinnr(s:coffee_compile_src_buf)
+
+  if win != -1
+    exec win 'wincmd w'
+    call setpos('.', s:coffee_compile_src_pos)
+  endif
+endfunction
+
+" Close the CoffeeCompile buffer and clean things up.
+function! s:CoffeeCompileClose()
+  silent! autocmd! CoffeeCompileAuPos
+  silent! autocmd! CoffeeCompileAuWatch
+
+  call s:CoffeeCompileRestorePos()
+  call s:CoffeeCompileResetVars()
+endfunction
+
+" Update the CoffeeCompile buffer given some input lines.
+function! s:CoffeeCompileUpdate(startline, endline)
+  let input = join(getline(a:startline, a:endline), "\n")
+
+  " Coffee doesn't like empty input.
+  if !len(input)
+    return
+  endif
+
+  " Compile input.
+  let output = system('coffee -scb 2>&1', input)
+
+  " Move to the CoffeeCompile buffer.
+  exec s:coffee_compile_win 'wincmd w'
+
+  " Replace buffer contents with new output and delete the last empty line.
+  setlocal modifiable
+    exec '% delete _'
+    put! =output
+    exec '$ delete _'
+  setlocal nomodifiable
+
+  " Highlight as JavaScript if there is no compile error.
+  if v:shell_error
+    setlocal filetype=
+  else
+    setlocal filetype=javascript
+  endif
+
+  " Restore the cursor in the compiled output.
+  call setpos('.', s:coffee_compile_pos)
+endfunction
+
+" Update the CoffeeCompile buffer with the whole source buffer and restore the
+" cursor.
+function! s:CoffeeCompileWatchUpdate()
+  call s:CoffeeCompileSavePos()
+  call s:CoffeeCompileUpdate(1, '$')
+  call s:CoffeeCompileRestorePos()
+endfunction
+
+" Peek at compiled CoffeeScript in a scratch buffer. We handle ranges like this
+" to prevent the cursor from being moved (and its position saved) before the
+" function is called.
+function! s:CoffeeCompile(startline, endline, args)
+  " Don't compile the CoffeeCompile buffer.
+  if bufnr('%') == s:coffee_compile_buf
+    return
+  endif
+
+  " Parse arguments.
+  let watch = a:args =~ '\<watch\>'
+  let unwatch = a:args =~ '\<unwatch\>'
+  let size = str2nr(matchstr(a:args, '\<\d\+\>'))
+   
+  " Determine default split direction.
+  if exists("g:coffee_compile_vert")
+    let vert = 1
+  else
+    let vert = a:args =~ '\<vert\%[ical]\>'
+  endif
+
+  " Remove any watch listeners.
+  silent! autocmd! CoffeeCompileAuWatch
+
+  " If just unwatching, don't compile.
+  if unwatch
+    let s:coffee_compile_watch = 0
+    return
+  endif
+
+  if watch
+    let s:coffee_compile_watch = 1
+  endif
+
+  call s:CoffeeCompileSavePos()
+
+  " Build the CoffeeCompile buffer if it doesn't exist.
+  if s:coffee_compile_buf == -1
+    let src_win = bufwinnr(s:coffee_compile_src_buf)
+
+    " Create the new window and resize it.
+    if vert
+      let width = size ? size : winwidth(src_win) / 2
+
+      vertical new
+      exec 'vertical resize' width
+    else
+      " Try to guess the compiled output's height.
+      let height = size ? size : min([winheight(src_win) / 2,
+      \                               a:endline - a:startline + 2])
+
+      botright new
+      exec 'resize' height
+    endif
+
+    " Set up scratch buffer.
+    setlocal bufhidden=wipe buftype=nofile
+    setlocal nobuflisted nomodifiable noswapfile nowrap
+
+    autocmd BufWipeout <buffer> call s:CoffeeCompileClose()
+    nnoremap <buffer> <silent> q :hide<CR>
+
+    " Save the cursor position on each buffer switch.
+    augroup CoffeeCompileAuPos
+      autocmd BufEnter,BufLeave * call s:CoffeeCompileSavePos()
+    augroup END
+
+    let s:coffee_compile_buf = bufnr('%')
+    let s:coffee_compile_win = bufwinnr(s:coffee_compile_buf)
+  endif
+
+  " Go back to the source buffer and do the initial compile.
+  call s:CoffeeCompileRestorePos()
+
+  if s:coffee_compile_watch
+    call s:CoffeeCompileWatchUpdate()
+
+    augroup CoffeeCompileAuWatch
+      autocmd InsertLeave <buffer> call s:CoffeeCompileWatchUpdate()
+    augroup END
+  else
+    call s:CoffeeCompileUpdate(a:startline, a:endline)
+  endif
+endfunction
+
+" Complete arguments for the CoffeeCompile command.
+function! s:CoffeeCompileComplete(arg, cmdline, cursor)
+  let args = ['unwatch', 'vertical', 'watch']
+
+  if !len(a:arg)
+    return args
+  endif
+
+  let match = '^' . a:arg
+
+  for arg in args
+    if arg =~ match
+      return [arg]
+    endif
+  endfor
+endfunction
+
+" Don't let new windows overwrite the CoffeeCompile variables.
+if !exists("s:coffee_compile_buf")
+  call s:CoffeeCompileResetVars()
+endif
+
+" Peek at compiled CoffeeScript.
+command! -range=% -bar -nargs=* -complete=customlist,s:CoffeeCompileComplete
+\        CoffeeCompile call s:CoffeeCompile(<line1>, <line2>, <q-args>)
+" Run some CoffeeScript.
+command! -range=% -bar CoffeeRun <line1>,<line2>:w !coffee -s
--- a/config/.vim/plugin/syntastic.vim	Thu Sep 05 16:23:33 2013 +0200
+++ b/config/.vim/plugin/syntastic.vim	Wed Nov 06 14:33:18 2013 +0100
@@ -1,9 +1,8 @@
 "============================================================================
 "File:        syntastic.vim
-"Description: vim plugin for on the fly syntax checking
-"Maintainer:  Martin Grenfell <martin.grenfell at gmail dot com>
-"Version:     2.3.0
-"Last Change: 16 Feb, 2012
+"Description: Vim plugin for on the fly syntax checking.
+"Version:     3.0.0
+"Released On: 13 April, 2013
 "License:     This program is free software. It comes without any warranty,
 "             to the extent permitted by applicable law. You can redistribute
 "             it and/or modify it under the terms of the Do What The Fuck You
@@ -17,40 +16,16 @@
 endif
 let g:loaded_syntastic_plugin = 1
 
-let s:running_windows = has("win16") || has("win32") || has("win64")
-
-if !s:running_windows
-    let s:uname = system('uname')
-endif
-
-if !exists("g:syntastic_enable_signs")
-    let g:syntastic_enable_signs = 1
-endif
-if !has('signs')
-    let g:syntastic_enable_signs = 0
-endif
+runtime! plugin/syntastic/*.vim
 
-if !exists("g:syntastic_enable_balloons")
-    let g:syntastic_enable_balloons = 1
-endif
-if !has('balloon_eval')
-    let g:syntastic_enable_balloons = 0
-endif
+let s:running_windows = has("win16") || has("win32")
 
-if !exists("g:syntastic_enable_highlighting")
-    let g:syntastic_enable_highlighting = 1
-endif
-
-if !exists("g:syntastic_echo_current_error")
-    let g:syntastic_echo_current_error = 1
-endif
-
-if !exists("g:syntastic_auto_loc_list")
-    let g:syntastic_auto_loc_list = 2
+if !exists("g:syntastic_always_populate_loc_list")
+    let g:syntastic_always_populate_loc_list = 0
 endif
 
 if !exists("g:syntastic_auto_jump")
-    let syntastic_auto_jump=0
+    let g:syntastic_auto_jump = 0
 endif
 
 if !exists("g:syntastic_quiet_warnings")
@@ -61,373 +36,265 @@
     let g:syntastic_stl_format = '[Syntax: line:%F (%t)]'
 endif
 
-if !exists("g:syntastic_mode_map")
-    let g:syntastic_mode_map = {}
-endif
-
-if !has_key(g:syntastic_mode_map, "mode")
-    let g:syntastic_mode_map['mode'] = 'active'
+if !exists("g:syntastic_check_on_open")
+    let g:syntastic_check_on_open = 0
 endif
 
-if !has_key(g:syntastic_mode_map, "active_filetypes")
-    let g:syntastic_mode_map['active_filetypes'] = []
+if !exists("g:syntastic_check_on_wq")
+    let g:syntastic_check_on_wq = 1
 endif
 
-if !has_key(g:syntastic_mode_map, "passive_filetypes")
-    let g:syntastic_mode_map['passive_filetypes'] = []
-endif
-
-if !exists("g:syntastic_check_on_open")
-    let g:syntastic_check_on_open = 0
+if !exists("g:syntastic_aggregate_errors")
+    let g:syntastic_aggregate_errors = 0
 endif
 
 if !exists("g:syntastic_loc_list_height")
     let g:syntastic_loc_list_height = 10
 endif
 
+if !exists("g:syntastic_ignore_files")
+    let g:syntastic_ignore_files = []
+endif
+
+if !exists("g:syntastic_filetype_map")
+    let g:syntastic_filetype_map = {}
+endif
+
+if !exists("g:syntastic_full_redraws")
+    let g:syntastic_full_redraws = !( has('gui_running') || has('gui_macvim'))
+endif
+
+" TODO: not documented
+if !exists("g:syntastic_reuse_loc_lists")
+    " a relevant bug has been fixed in one of the pre-releases of Vim 7.4
+    let g:syntastic_reuse_loc_lists = (v:version >= 704)
+endif
+
+let s:registry = g:SyntasticRegistry.Instance()
+let s:notifiers = g:SyntasticNotifiers.Instance()
+let s:modemap = g:SyntasticModeMap.Instance()
+
+function! s:CompleteCheckerName(argLead, cmdLine, cursorPos)
+    let checker_names = []
+    for ft in s:CurrentFiletypes()
+        for checker in s:registry.availableCheckersFor(ft)
+            call add(checker_names, checker.getName())
+        endfor
+    endfor
+    return join(checker_names, "\n")
+endfunction
+
 command! SyntasticToggleMode call s:ToggleMode()
-command! SyntasticCheck call s:UpdateErrors(0) <bar> redraw!
+command! -nargs=? -complete=custom,s:CompleteCheckerName SyntasticCheck call s:UpdateErrors(0, <f-args>) <bar> call s:Redraw()
 command! Errors call s:ShowLocList()
+command! SyntasticInfo call s:registry.echoInfoFor(s:CurrentFiletypes())
+command! SyntasticReset call s:ClearCache() | call s:notifiers.refresh(g:SyntasticLoclist.New([]))
 
 highlight link SyntasticError SpellBad
 highlight link SyntasticWarning SpellCap
 
 augroup syntastic
-    if g:syntastic_echo_current_error
-        autocmd cursormoved * call s:EchoCurrentError()
-    endif
-
     autocmd BufReadPost * if g:syntastic_check_on_open | call s:UpdateErrors(1) | endif
     autocmd BufWritePost * call s:UpdateErrors(1)
 
-    autocmd BufWinEnter * if empty(&bt) | call s:AutoToggleLocList() | endif
-    autocmd BufWinLeave * if empty(&bt) | lclose | endif
+    autocmd BufWinEnter * call s:BufWinEnterHook()
+
+    " TODO: the next autocmd should be "autocmd BufWinLeave * if empty(&bt) | lclose | endif"
+    " but in recent versions of Vim lclose can no longer be called from BufWinLeave
+    autocmd BufEnter * call s:BufEnterHook()
 augroup END
 
+if v:version > 703 || (v:version == 703 && has('patch544'))
+    " QuitPre was added in Vim 7.3.544
+    augroup syntastic
+        autocmd QuitPre * call s:QuitPreHook()
+    augroup END
+endif
+
 
-"refresh and redraw all the error info for this buf when saving or reading
-function! s:UpdateErrors(auto_invoked)
-    if !empty(&buftype)
-        return
-    endif
-
-    if !a:auto_invoked || s:ModeMapAllowsAutoChecking()
-        call s:CacheErrors()
-    end
-
-    if s:BufHasErrorsOrWarningsToDisplay()
-        call setloclist(0, s:LocList())
-    endif
-
-    if g:syntastic_enable_balloons
-        call s:RefreshBalloons()
-    endif
-
-    if g:syntastic_enable_signs
-        call s:RefreshSigns()
-    endif
-
-    if g:syntastic_auto_jump && s:BufHasErrorsOrWarningsToDisplay()
-        silent! ll
-    endif
-
-    call s:AutoToggleLocList()
-endfunction
-
-"automatically open/close the location list window depending on the users
-"config and buffer error state
-function! s:AutoToggleLocList()
-    if s:BufHasErrorsOrWarningsToDisplay()
-        if g:syntastic_auto_loc_list == 1
-            call s:ShowLocList()
-        endif
-    else
-        if g:syntastic_auto_loc_list > 0
-
-            "TODO: this will close the loc list window if one was opened by
-            "something other than syntastic
-            lclose
-        endif
+function! s:BufWinEnterHook()
+    if empty(&bt)
+        let loclist = g:SyntasticLoclist.current()
+        call s:notifiers.refresh(loclist)
     endif
 endfunction
 
-"lazy init the loc list for the current buffer
-function! s:LocList()
-    if !exists("b:syntastic_loclist")
-        let b:syntastic_loclist = []
-    endif
-    return b:syntastic_loclist
-endfunction
-
-"clear the loc list for the buffer
-function! s:ClearLocList()
-    let b:syntastic_loclist = []
-endfunction
-
-"detect and cache all syntax errors in this buffer
-"
-"depends on a function called SyntaxCheckers_{&ft}_GetLocList() existing
-"elsewhere
-function! s:CacheErrors()
-    call s:ClearLocList()
-
-    if filereadable(expand("%"))
-
-        "sub - for _ in filetypes otherwise we cant name syntax checker
-        "functions legally for filetypes like "gentoo-metadata"
-        let fts = substitute(&ft, '-', '_', 'g')
-        for ft in split(fts, '\.')
-            if s:Checkable(ft)
-                let errors = SyntaxCheckers_{ft}_GetLocList()
-                "make errors have type "E" by default
-                call SyntasticAddToErrors(errors, {'type': 'E'})
-                call extend(s:LocList(), errors)
-            endif
-        endfor
+function! s:BufEnterHook()
+    " TODO: at this point there is no b:syntastic_loclist
+    let loclist = filter(getloclist(0), 'v:val["valid"] == 1')
+    let buffers = syntastic#util#unique(map( loclist, 'v:val["bufnr"]' ))
+    if &bt=='quickfix' && !empty(loclist) && empty(filter( buffers, 'syntastic#util#bufIsActive(v:val)' ))
+        call g:SyntasticLoclistHide()
     endif
 endfunction
 
-"toggle the g:syntastic_mode_map['mode']
-function! s:ToggleMode()
-    if g:syntastic_mode_map['mode'] == "active"
-        let g:syntastic_mode_map['mode'] = "passive"
-    else
-        let g:syntastic_mode_map['mode'] = "active"
-    endif
 
-    call s:ClearLocList()
-    call s:UpdateErrors(1)
-
-    echo "Syntastic: " . g:syntastic_mode_map['mode'] . " mode enabled"
-endfunction
-
-"check the current filetypes against g:syntastic_mode_map to determine whether
-"active mode syntax checking should be done
-function! s:ModeMapAllowsAutoChecking()
-    let fts = split(&ft, '\.')
-
-    if g:syntastic_mode_map['mode'] == 'passive'
-        "check at least one filetype is active
-        let actives = g:syntastic_mode_map["active_filetypes"]
-        return !empty(filter(fts, 'index(actives, v:val) != -1'))
-    else
-        "check no filetypes are passive
-        let passives = g:syntastic_mode_map["passive_filetypes"]
-        return empty(filter(fts, 'index(passives, v:val) != -1'))
-    endif
-endfunction
-
-"return true if there are cached errors/warnings for this buf
-function! s:BufHasErrorsOrWarnings()
-    return !empty(s:LocList())
+function! s:QuitPreHook()
+    let b:syntastic_skip_checks = !g:syntastic_check_on_wq
+    call g:SyntasticLoclistHide()
 endfunction
 
-"return true if there are cached errors for this buf
-function! s:BufHasErrors()
-    return len(s:ErrorsForType('E')) > 0
-endfunction
+"refresh and redraw all the error info for this buf when saving or reading
+function! s:UpdateErrors(auto_invoked, ...)
+    if s:SkipFile()
+        return
+    endif
 
-function! s:BufHasErrorsOrWarningsToDisplay()
-    return s:BufHasErrors() || (!g:syntastic_quiet_warnings && s:BufHasErrorsOrWarnings())
-endfunction
+    let run_checks = !a:auto_invoked || s:modemap.allowsAutoChecking(&filetype)
+    if run_checks
+        if a:0 >= 1
+            call s:CacheErrors(a:1)
+        else
+            call s:CacheErrors()
+        endif
+    end
+
+    let loclist = g:SyntasticLoclist.current()
 
-function! s:ErrorsForType(type)
-    return s:FilterLocList({'type': a:type})
-endfunction
+    let w:syntastic_loclist_set = 0
+    if g:syntastic_always_populate_loc_list || g:syntastic_auto_jump
+        call setloclist(0, loclist.filteredRaw())
+        let w:syntastic_loclist_set = 1
+        if run_checks && g:syntastic_auto_jump && loclist.hasErrorsOrWarningsToDisplay()
+            silent! lrewind
+        endif
+    endif
 
-function! s:Errors()
-    return s:ErrorsForType("E")
+    call s:notifiers.refresh(loclist)
 endfunction
 
-function! s:Warnings()
-    return s:ErrorsForType("W")
+"clear the loc list for the buffer
+function! s:ClearCache()
+    call s:notifiers.reset(g:SyntasticLoclist.current())
+    unlet! b:syntastic_loclist
+endfunction
+
+function! s:CurrentFiletypes()
+    return split(&filetype, '\.')
 endfunction
 
-"Filter a loc list (defaults to s:LocList()) by a:filters
-"e.g.
-"  s:FilterLocList({'bufnr': 10, 'type': 'e'})
-"
-"would return all errors in s:LocList() for buffer 10.
-"
-"Note that all comparisons are done with ==?
-function! s:FilterLocList(filters, ...)
-    let llist = a:0 ? a:1 : s:LocList()
+"detect and cache all syntax errors in this buffer
+function! s:CacheErrors(...)
+    call s:ClearCache()
+    let newLoclist = g:SyntasticLoclist.New([])
+
+    if !s:SkipFile()
+        let active_checkers = 0
+        let names = []
 
-    let rv = deepcopy(llist)
-    for error in llist
-        for key in keys(a:filters)
-            let rhs = a:filters[key]
-            if type(rhs) == 1 "string
-                let rhs = '"' . rhs . '"'
+        call syntastic#util#debug("CacheErrors: g:syntastic_aggregate_errors = " . g:syntastic_aggregate_errors)
+        if exists('b:syntastic_aggregate_errors')
+            call syntastic#util#debug("CacheErrors: b:syntastic_aggregate_errors = " . b:syntastic_aggregate_errors)
+        endif
+
+        for ft in s:CurrentFiletypes()
+            if a:0
+                let checker = s:registry.getChecker(ft, a:1)
+                let checkers = !empty(checker) ? [checker] : []
+            else
+                let checkers = s:registry.getActiveCheckers(ft)
             endif
 
-            call filter(rv, "v:val['".key."'] ==? " . rhs)
+            for checker in checkers
+                let active_checkers += 1
+                call syntastic#util#debug("CacheErrors: Invoking checker: " . checker.getName())
+
+                let loclist = checker.getLocList()
+
+                if !loclist.isEmpty()
+                    let newLoclist = newLoclist.extend(loclist)
+                    call add(names, [checker.getName(), checker.getFiletype()])
+
+                    if !(exists('b:syntastic_aggregate_errors') ? b:syntastic_aggregate_errors : g:syntastic_aggregate_errors)
+                        break
+                    endif
+                endif
+            endfor
         endfor
-    endfor
-    return rv
+
+        if !empty(names)
+            if len(syntastic#util#unique(map(copy(names), 'v:val[1]'))) == 1
+                let type = names[0][1]
+                let name = join(map(names, 'v:val[0]'), ', ')
+                call newLoclist.setName( name . ' ('. type . ')' )
+            else
+                " checkers from mixed types
+                call newLoclist.setName(join(map(names, 'v:val[1] . "/" . v:val[0]'), ', '))
+            endif
+        endif
+
+        if !active_checkers
+            if a:0
+                call syntastic#util#warn('checker ' . a:1 . ' is not active for filetype ' . &filetype)
+            else
+                call syntastic#util#debug('no active checkers for filetype ' . &filetype)
+            endif
+        endif
+    endif
+
+    let b:syntastic_loclist = newLoclist
 endfunction
 
-if g:syntastic_enable_signs
-    "define the signs used to display syntax and style errors/warns
-    sign define SyntasticError text=>> texthl=error
-    sign define SyntasticWarning text=>> texthl=todo
-    sign define SyntasticStyleError text=S> texthl=error
-    sign define SyntasticStyleWarning text=S> texthl=todo
-endif
-
-"start counting sign ids at 5000, start here to hopefully avoid conflicting
-"with any other code that places signs (not sure if this precaution is
-"actually needed)
-let s:first_sign_id = 5000
-let s:next_sign_id = s:first_sign_id
-
-"place signs by all syntax errs in the buffer
-function! s:SignErrors()
-    if s:BufHasErrorsOrWarningsToDisplay()
-
-        let errors = s:FilterLocList({'bufnr': bufnr('')})
-        for i in errors
-            let sign_severity = 'Error'
-            let sign_subtype = ''
-            if has_key(i,'subtype')
-                let sign_subtype = i['subtype']
-            endif
-            if i['type'] ==? 'w'
-                let sign_severity = 'Warning'
-            endif
-            let sign_type = 'Syntastic' . sign_subtype . sign_severity
-
-            if !s:WarningMasksError(i, errors)
-                exec "sign place ". s:next_sign_id ." line=". i['lnum'] ." name=". sign_type ." file=". expand("%:p")
-                call add(s:BufSignIds(), s:next_sign_id)
-                let s:next_sign_id += 1
-            endif
-        endfor
-    endif
-endfunction
-
-"return true if the given error item is a warning that, if signed, would
-"potentially mask an error if displayed at the same time
-function! s:WarningMasksError(error, llist)
-    if a:error['type'] !=? 'w'
-        return 0
-    endif
-
-    return len(s:FilterLocList({ 'type': "E", 'lnum': a:error['lnum'] }, a:llist)) > 0
-endfunction
-
-"remove the signs with the given ids from this buffer
-function! s:RemoveSigns(ids)
-    for i in a:ids
-        exec "sign unplace " . i
-        call remove(s:BufSignIds(), index(s:BufSignIds(), i))
-    endfor
-endfunction
-
-"get all the ids of the SyntaxError signs in the buffer
-function! s:BufSignIds()
-    if !exists("b:syntastic_sign_ids")
-        let b:syntastic_sign_ids = []
-    endif
-    return b:syntastic_sign_ids
-endfunction
-
-"update the error signs
-function! s:RefreshSigns()
-    let old_signs = copy(s:BufSignIds())
-    call s:SignErrors()
-    call s:RemoveSigns(old_signs)
-    let s:first_sign_id = s:next_sign_id
+function! s:ToggleMode()
+    call s:modemap.toggleMode()
+    call s:ClearCache()
+    call s:UpdateErrors(1)
+    call s:modemap.echoMode()
 endfunction
 
 "display the cached errors for this buf in the location list
 function! s:ShowLocList()
-    if !empty(s:LocList())
-        let num = winnr()
-        exec "lopen " . g:syntastic_loc_list_height
-        if num != winnr()
-            wincmd p
-        endif
-    endif
+    let loclist = g:SyntasticLoclist.current()
+    call loclist.show()
 endfunction
 
-"remove all error highlights from the window
-function! s:ClearErrorHighlights()
-    for match in getmatches()
-        if stridx(match['group'], 'Syntastic') == 0
-            call matchdelete(match['id'])
-        endif
-    endfor
+"the script changes &shellredir and &shell to stop the screen flicking when
+"shelling out to syntax checkers. Not all OSs support the hacks though
+function! s:OSSupportsShellredirHack()
+    return !s:running_windows && executable('/bin/bash') && (s:uname() !~ "FreeBSD") && (s:uname() !~ "OpenBSD")
 endfunction
 
-"check if a syntax checker exists for the given filetype - and attempt to
-"load one
-function! s:Checkable(ft)
-    if !exists("g:loaded_" . a:ft . "_syntax_checker")
-        exec "runtime syntax_checkers/" . a:ft . ".vim"
-    endif
-
-    return exists("*SyntaxCheckers_". a:ft ."_GetLocList")
+function! s:IsRedrawRequiredAfterMake()
+    return !s:running_windows && (s:uname() =~ "FreeBSD" || s:uname() =~ "OpenBSD")
 endfunction
 
-"set up error ballons for the current set of errors
-function! s:RefreshBalloons()
-    let b:syntastic_balloons = {}
-    if s:BufHasErrorsOrWarningsToDisplay()
-        for i in s:LocList()
-            let b:syntastic_balloons[i['lnum']] = i['text']
-        endfor
-        set beval bexpr=SyntasticErrorBalloonExpr()
+"Redraw in a way that doesnt make the screen flicker or leave anomalies behind.
+"
+"Some terminal versions of vim require `redraw!` - otherwise there can be
+"random anomalies left behind.
+"
+"However, on some versions of gvim using `redraw!` causes the screen to
+"flicker - so use redraw.
+function! s:Redraw()
+    if g:syntastic_full_redraws
+        redraw!
+    else
+        redraw
     endif
 endfunction
 
-"print as much of a:msg as possible without "Press Enter" prompt appearing
-function! s:WideMsg(msg)
-    let old_ruler = &ruler
-    let old_showcmd = &showcmd
-
-    let msg = strpart(a:msg, 0, winwidth(0)-1)
-
-    "This is here because it is possible for some error messages to begin with
-    "\n which will cause a "press enter" prompt. I have noticed this in the
-    "javascript:jshint checker and have been unable to figure out why it
-    "happens
-    let msg = substitute(msg, "\n", "", "g")
-
-    set noruler noshowcmd
-    redraw
-
-    echo msg
-
-    let &ruler=old_ruler
-    let &showcmd=old_showcmd
+function! s:IgnoreFile(filename)
+    let fname = fnamemodify(a:filename, ':p')
+    for p in g:syntastic_ignore_files
+        if fname =~# p
+            return 1
+        endif
+    endfor
+    return 0
 endfunction
 
-"echo out the first error we find for the current line in the cmd window
-function! s:EchoCurrentError()
-    "If we have an error or warning at the current line, show it
-    let errors = s:FilterLocList({'lnum': line("."), "type": 'e'})
-    let warnings = s:FilterLocList({'lnum': line("."), "type": 'w'})
-
-    let b:syntastic_echoing_error = len(errors) || len(warnings)
-    if len(errors)
-        return s:WideMsg(errors[0]['text'])
-    endif
-    if len(warnings)
-        return s:WideMsg(warnings[0]['text'])
-    endif
-
-    "Otherwise, clear the status line
-    if b:syntastic_echoing_error
-        echo
-        let b:syntastic_echoing_error = 0
-    endif
+" Skip running in special buffers
+function! s:SkipFile()
+    let force_skip = exists('b:syntastic_skip_checks') ? b:syntastic_skip_checks : 0
+    let fname = expand('%')
+    return force_skip || !empty(&buftype) || !filereadable(fname) || getwinvar(0, '&diff') || s:IgnoreFile(fname)
 endfunction
 
-"load the chosen checker for the current filetype - useful for filetypes like
-"javascript that have more than one syntax checker
-function! s:LoadChecker(checker)
-    exec "runtime syntax_checkers/" . &ft . "/" . a:checker . ".vim"
+function! s:uname()
+    if !exists('s:uname')
+        let s:uname = system('uname')
+    endif
+    return s:uname
 endfunction
 
 "return a string representing the state of buffer according to
@@ -435,34 +302,41 @@
 "
 "return '' if no errors are cached for the buffer
 function! SyntasticStatuslineFlag()
-    if s:BufHasErrorsOrWarningsToDisplay()
-        let errors = s:Errors()
-        let warnings = s:Warnings()
+    let loclist = g:SyntasticLoclist.current()
+    let issues = loclist.filteredRaw()
+    let num_issues = loclist.getLength()
+    if loclist.hasErrorsOrWarningsToDisplay()
+        let errors = loclist.errors()
+        let warnings = loclist.warnings()
+
+        let num_errors = len(errors)
+        let num_warnings = len(warnings)
 
         let output = g:syntastic_stl_format
 
         "hide stuff wrapped in %E(...) unless there are errors
-        let output = substitute(output, '\C%E{\([^}]*\)}', len(errors) ? '\1' : '' , 'g')
+        let output = substitute(output, '\C%E{\([^}]*\)}', num_errors ? '\1' : '' , 'g')
 
         "hide stuff wrapped in %W(...) unless there are warnings
-        let output = substitute(output, '\C%W{\([^}]*\)}', len(warnings) ? '\1' : '' , 'g')
+        let output = substitute(output, '\C%W{\([^}]*\)}', num_warnings ? '\1' : '' , 'g')
 
         "hide stuff wrapped in %B(...) unless there are both errors and warnings
-        let output = substitute(output, '\C%B{\([^}]*\)}', (len(warnings) && len(errors)) ? '\1' : '' , 'g')
+        let output = substitute(output, '\C%B{\([^}]*\)}', (num_warnings && num_errors) ? '\1' : '' , 'g')
+
 
         "sub in the total errors/warnings/both
-        let output = substitute(output, '\C%w', len(warnings), 'g')
-        let output = substitute(output, '\C%e', len(errors), 'g')
-        let output = substitute(output, '\C%t', len(s:LocList()), 'g')
+        let output = substitute(output, '\C%w', num_warnings, 'g')
+        let output = substitute(output, '\C%e', num_errors, 'g')
+        let output = substitute(output, '\C%t', num_issues, 'g')
 
         "first error/warning line num
-        let output = substitute(output, '\C%F', s:LocList()[0]['lnum'], 'g')
+        let output = substitute(output, '\C%F', num_issues ? issues[0]['lnum'] : '', 'g')
 
         "first error line num
-        let output = substitute(output, '\C%fe', len(errors) ? errors[0]['lnum'] : '', 'g')
+        let output = substitute(output, '\C%fe', num_errors ? errors[0]['lnum'] : '', 'g')
 
         "first warning line num
-        let output = substitute(output, '\C%fw', len(warnings) ? warnings[0]['lnum'] : '', 'g')
+        let output = substitute(output, '\C%fw', num_warnings ? warnings[0]['lnum'] : '', 'g')
 
         return output
     else
@@ -470,9 +344,8 @@
     endif
 endfunction
 
-"A wrapper for the :lmake command. Sets up the make environment according to
-"the options given, runs make, resets the environment, returns the location
-"list
+"Emulates the :lmake command. Sets up the make environment according to the
+"options given, runs make, resets the environment, returns the location list
 "
 "a:options can contain the following keys:
 "    'makeprg'
@@ -484,90 +357,88 @@
 "a:options may also contain:
 "   'defaults' - a dict containing default values for the returned errors
 "   'subtype' - all errors will be assigned the given subtype
+"   'preprocess' - a function to be applied to the error file before parsing errors
+"   'postprocess' - a list of functions to be applied to the error list
+"   'cwd' - change directory to the given path before running the checker
+"   'returns' - a list of valid exit codes for the checker
 function! SyntasticMake(options)
-    let old_loclist = getloclist(0)
-    let old_makeprg = &makeprg
-    let old_shellpipe = &shellpipe
+    call syntastic#util#debug('SyntasticMake: called with options: '. string(a:options))
+
     let old_shell = &shell
+    let old_shellredir = &shellredir
     let old_errorformat = &errorformat
+    let old_cwd = getcwd()
+    let old_lc_messages = $LC_MESSAGES
+    let old_lc_all = $LC_ALL
 
-    if !s:running_windows && (s:uname !~ "FreeBSD")
+    if s:OSSupportsShellredirHack()
         "this is a hack to stop the screen needing to be ':redraw'n when
         "when :lmake is run. Otherwise the screen flickers annoyingly
-        let &shellpipe='&>'
+        let &shellredir = '&>'
         let &shell = '/bin/bash'
     endif
 
-    if has_key(a:options, 'makeprg')
-        let &makeprg = a:options['makeprg']
-    endif
-
     if has_key(a:options, 'errorformat')
         let &errorformat = a:options['errorformat']
     endif
 
-    silent lmake!
-    let errors = getloclist(0)
+    if has_key(a:options, 'cwd')
+        exec 'lcd ' . fnameescape(a:options['cwd'])
+    endif
+
+    let $LC_MESSAGES = 'C'
+    let $LC_ALL = ''
+    let err_lines = split(system(a:options['makeprg']), "\n", 1)
+    let $LC_ALL = old_lc_all
+    let $LC_MESSAGES = old_lc_messages
 
-    call setloclist(0, old_loclist)
-    let &makeprg = old_makeprg
+    if has_key(a:options, 'preprocess')
+        let err_lines = call(a:options['preprocess'], [err_lines])
+    endif
+    lgetexpr err_lines
+
+    let errors = copy(getloclist(0))
+
+    if has_key(a:options, 'cwd')
+        exec 'lcd ' . fnameescape(old_cwd)
+    endif
+
+    silent! lolder
     let &errorformat = old_errorformat
-    let &shellpipe=old_shellpipe
+    let &shellredir = old_shellredir
     let &shell=old_shell
 
-    if !s:running_windows && s:uname =~ "FreeBSD"
-        redraw!
+    if s:IsRedrawRequiredAfterMake()
+        call s:Redraw()
+    endif
+
+    if has_key(a:options, 'returns') && index(a:options['returns'], v:shell_error) == -1
+        throw 'Syntastic: checker error'
     endif
 
     if has_key(a:options, 'defaults')
         call SyntasticAddToErrors(errors, a:options['defaults'])
     endif
 
+    " Apply ignore patterns
+    let ignore = {}
+    for buf in syntastic#util#unique(map(copy(errors), 'v:val["bufnr"]'))
+        let ignore[buf] = s:IgnoreFile(bufname(str2nr(buf)))
+    endfor
+    call filter(errors, '!ignore[v:val["bufnr"]]')
+
     " Add subtype info if present.
     if has_key(a:options, 'subtype')
         call SyntasticAddToErrors(errors, {'subtype': a:options['subtype']})
     endif
 
-    return errors
-endfunction
-
-"get the error balloon for the current mouse position
-function! SyntasticErrorBalloonExpr()
-    if !exists('b:syntastic_balloons')
-        return ''
-    endif
-    return get(b:syntastic_balloons, v:beval_lnum, '')
-endfunction
-
-"highlight the list of errors (a:errors) using matchadd()
-"
-"a:termfunc is provided to highlight errors that do not have a 'col' key (and
-"hence cant be done automatically). This function must take one arg (an error
-"item) and return a regex to match that item in the buffer.
-"
-"an optional boolean third argument can be provided to force a:termfunc to be
-"used regardless of whether a 'col' key is present for the error
-function! SyntasticHighlightErrors(errors, termfunc, ...)
-    if !g:syntastic_enable_highlighting
-        return
+    if has_key(a:options, 'postprocess') && !empty(a:options['postprocess'])
+        for rule in a:options['postprocess']
+            let errors = call('syntastic#postprocess#' . rule, [errors])
+        endfor
     endif
 
-    call s:ClearErrorHighlights()
-
-    let force_callback = a:0 && a:1
-    for item in a:errors
-        let group = item['type'] == 'E' ? 'SyntasticError' : 'SyntasticWarning'
-        if item['col'] && !force_callback
-            let lastcol = col([item['lnum'], '$'])
-            let lcol = min([lastcol, item['col']])
-            call matchadd(group, '\%'.item['lnum'].'l\%'.lcol.'c')
-        else
-            let term = a:termfunc(item)
-            if len(term) > 0
-                call matchadd(group, '\%' . item['lnum'] . 'l' . term)
-            endif
-        endif
-    endfor
+    return errors
 endfunction
 
 "take a list of errors and add default values to them from a:options
@@ -582,33 +453,4 @@
     return a:errors
 endfunction
 
-"take a list of syntax checkers for the current filetype and load the right
-"one based on the global settings and checker executable availabity
-"
-"a:checkers should be a list of syntax checker names. These names are assumed
-"to be the names of the vim syntax checker files that should be sourced, as
-"well as the names of the actual syntax checker executables. The checkers
-"should be listed in order of default preference.
-"
-"if a option called 'g:syntastic_[filetype]_checker' exists then attempt to
-"load the checker that it points to
-function! SyntasticLoadChecker(checkers)
-    let opt_name = "g:syntastic_" . &ft . "_checker"
-
-    if exists(opt_name)
-        let opt_val = {opt_name}
-        if index(a:checkers, opt_val) != -1 && executable(opt_val)
-            call s:LoadChecker(opt_val)
-        else
-            echoerr &ft . " syntax not supported or not installed."
-        endif
-    else
-        for checker in a:checkers
-            if executable(checker)
-                return s:LoadChecker(checker)
-            endif
-        endfor
-    endif
-endfunction
-
 " vim: set et sts=4 sw=4:
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/config/.vim/plugin/syntastic/autoloclist.vim	Wed Nov 06 14:33:18 2013 +0100
@@ -0,0 +1,38 @@
+if exists("g:loaded_syntastic_notifier_autoloclist")
+    finish
+endif
+let g:loaded_syntastic_notifier_autoloclist = 1
+
+if !exists("g:syntastic_auto_loc_list")
+    let g:syntastic_auto_loc_list = 2
+endif
+
+let g:SyntasticAutoloclistNotifier = {}
+
+" Public methods {{{1
+"
+function! g:SyntasticAutoloclistNotifier.New()
+    let newObj = copy(self)
+    return newObj
+endfunction
+
+function! g:SyntasticAutoloclistNotifier.refresh(loclist)
+    call g:SyntasticAutoloclistNotifier.AutoToggle(a:loclist)
+endfunction
+
+function! g:SyntasticAutoloclistNotifier.AutoToggle(loclist)
+    if a:loclist.hasErrorsOrWarningsToDisplay()
+        if g:syntastic_auto_loc_list == 1
+            call a:loclist.show()
+        endif
+    else
+        if g:syntastic_auto_loc_list > 0
+
+            "TODO: this will close the loc list window if one was opened by
+            "something other than syntastic
+            lclose
+        endif
+    endif
+endfunction
+
+" vim: set sw=4 sts=4 et fdm=marker:
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/config/.vim/plugin/syntastic/balloons.vim	Wed Nov 06 14:33:18 2013 +0100
@@ -0,0 +1,64 @@
+if exists("g:loaded_syntastic_notifier_balloons")
+    finish
+endif
+let g:loaded_syntastic_notifier_balloons = 1
+
+if !exists("g:syntastic_enable_balloons")
+    let g:syntastic_enable_balloons = 1
+endif
+
+if !has('balloon_eval')
+    let g:syntastic_enable_balloons = 0
+endif
+
+let g:SyntasticBalloonsNotifier = {}
+
+" Public methods {{{1
+
+function! g:SyntasticBalloonsNotifier.New()
+    let newObj = copy(self)
+    return newObj
+endfunction
+
+function! g:SyntasticBalloonsNotifier.enabled()
+    return
+        \ has('balloon_eval') &&
+        \ (exists('b:syntastic_enable_balloons') ? b:syntastic_enable_balloons : g:syntastic_enable_balloons)
+endfunction
+
+" Update the error balloons
+function! g:SyntasticBalloonsNotifier.refresh(loclist)
+    let b:syntastic_balloons = {}
+    if self.enabled() && a:loclist.hasErrorsOrWarningsToDisplay()
+        let buf = bufnr('')
+        let issues = filter(a:loclist.filteredRaw(), 'v:val["bufnr"] == buf')
+        if !empty(issues)
+            for i in issues
+                if has_key(b:syntastic_balloons, i['lnum'])
+                    let b:syntastic_balloons[i['lnum']] .= "\n" . i['text']
+                else
+                    let b:syntastic_balloons[i['lnum']] = i['text']
+                endif
+            endfor
+            set beval bexpr=SyntasticBalloonsExprNotifier()
+        endif
+    endif
+endfunction
+
+" Reset the error balloons
+function! g:SyntasticBalloonsNotifier.reset(loclist)
+    if has('balloon_eval')
+        set nobeval
+    endif
+endfunction
+
+" Private functions {{{1
+
+function! SyntasticBalloonsExprNotifier()
+    if !exists('b:syntastic_balloons')
+        return ''
+    endif
+    return get(b:syntastic_balloons, v:beval_lnum, '')
+endfunction
+
+" vim: set sw=4 sts=4 et fdm=marker:
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/config/.vim/plugin/syntastic/checker.vim	Wed Nov 06 14:33:18 2013 +0100
@@ -0,0 +1,79 @@
+if exists("g:loaded_syntastic_checker")
+    finish
+endif
+let g:loaded_syntastic_checker = 1
+
+let g:SyntasticChecker = {}
+
+" Public methods {{{1
+
+function! g:SyntasticChecker.New(args)
+    let newObj = copy(self)
+
+    let newObj._filetype = a:args['filetype']
+    let newObj._name = a:args['name']
+
+
+    let prefix = 'SyntaxCheckers_' . newObj._filetype . '_' . newObj._name . '_'
+    let newObj._locListFunc = function(prefix . 'GetLocList')
+    let newObj._isAvailableFunc = function(prefix . 'IsAvailable')
+
+    if exists('*' . prefix . 'GetHighlightRegex')
+        let newObj._highlightRegexFunc = function(prefix. 'GetHighlightRegex')
+    else
+        let newObj._highlightRegexFunc = ''
+    endif
+
+    return newObj
+endfunction
+
+function! g:SyntasticChecker.getFiletype()
+    return self._filetype
+endfunction
+
+function! g:SyntasticChecker.getName()
+    return self._name
+endfunction
+
+function! g:SyntasticChecker.getLocList()
+    try
+        let list = self._locListFunc()
+        call syntastic#util#debug('getLocList: checker ' . self._filetype . '/' . self._name . ' returned ' . v:shell_error)
+    catch /\m\C^Syntastic: checker error$/
+        let list = []
+        call syntastic#util#error('checker ' . self._filetype . '/' . self._name . ' returned abnormal status ' . v:shell_error)
+    endtry
+    call self._populateHighlightRegexes(list)
+    return g:SyntasticLoclist.New(list)
+endfunction
+
+function! g:SyntasticChecker.getHighlightRegexFor(error)
+    if empty(self._highlightRegexFunc)
+        return []
+    endif
+
+    return self._highlightRegexFunc(error)
+endfunction
+
+function! g:SyntasticChecker.isAvailable()
+    return self._isAvailableFunc()
+endfunction
+
+" Private methods {{{1
+
+function! g:SyntasticChecker._populateHighlightRegexes(list)
+    let list = a:list
+    if !empty(self._highlightRegexFunc)
+        for i in range(0, len(list)-1)
+            if list[i]['valid']
+                let term = self._highlightRegexFunc(list[i])
+                if len(term) > 0
+                    let list[i]['hl'] = term
+                endif
+            endif
+        endfor
+    endif
+    return list
+endfunction
+
+" vim: set sw=4 sts=4 et fdm=marker:
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/config/.vim/plugin/syntastic/cursor.vim	Wed Nov 06 14:33:18 2013 +0100
@@ -0,0 +1,63 @@
+if exists("g:loaded_syntastic_notifier_cursor")
+    finish
+endif
+let g:loaded_syntastic_notifier_cursor = 1
+
+if !exists('g:syntastic_echo_current_error')
+    let g:syntastic_echo_current_error = 1
+endif
+
+let g:SyntasticCursorNotifier = {}
+
+" Public methods {{{1
+
+function! g:SyntasticCursorNotifier.New()
+    let newObj = copy(self)
+    return newObj
+endfunction
+
+function! g:SyntasticCursorNotifier.enabled()
+    return exists('b:syntastic_echo_current_error') ? b:syntastic_echo_current_error : g:syntastic_echo_current_error
+endfunction
+
+function! g:SyntasticCursorNotifier.refresh(loclist)
+    if self.enabled() && a:loclist.hasErrorsOrWarningsToDisplay()
+        let b:syntastic_messages = copy(a:loclist.messages(bufnr('')))
+        let b:oldLine = -1
+        autocmd! syntastic CursorMoved
+        autocmd syntastic CursorMoved * call g:SyntasticRefreshCursor()
+    endif
+endfunction
+
+function! g:SyntasticCursorNotifier.reset(loclist)
+    autocmd! syntastic CursorMoved
+    unlet! b:syntastic_messages
+    let b:oldLine = -1
+endfunction
+
+" Private methods {{{1
+
+" The following defensive nonsense is needed because of the nature of autocmd
+function! g:SyntasticRefreshCursor()
+    if !exists('b:syntastic_messages') || empty(b:syntastic_messages)
+        " file not checked
+        return
+    endif
+
+    if !exists('b:oldLine')
+        let b:oldLine = -1
+    endif
+    let l = line('.')
+    if l == b:oldLine
+        return
+    endif
+    let b:oldLine = l
+
+    if has_key(b:syntastic_messages, l)
+        call syntastic#util#wideMsg(b:syntastic_messages[l])
+    else
+        echo
+    endif
+endfunction
+
+" vim: set sw=4 sts=4 et fdm=marker:
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/config/.vim/plugin/syntastic/highlighting.vim	Wed Nov 06 14:33:18 2013 +0100
@@ -0,0 +1,66 @@
+if exists("g:loaded_syntastic_notifier_highlighting")
+    finish
+endif
+let g:loaded_syntastic_notifier_highlighting = 1
+
+" Highlighting requires getmatches introduced in 7.1.040
+let s:has_highlighting = v:version > 701 || (v:version == 701 && has('patch040'))
+
+if !exists("g:syntastic_enable_highlighting")
+    let g:syntastic_enable_highlighting = 1
+endif
+
+let g:SyntasticHighlightingNotifier = {}
+
+" Public methods {{{1
+
+function! g:SyntasticHighlightingNotifier.New()
+    let newObj = copy(self)
+    return newObj
+endfunction
+
+function! g:SyntasticHighlightingNotifier.enabled()
+    return
+        \ s:has_highlighting &&
+        \ (exists('b:syntastic_enable_highlighting') ? b:syntastic_enable_highlighting : g:syntastic_enable_highlighting)
+endfunction
+
+" Sets error highlights in the cuirrent window
+function! g:SyntasticHighlightingNotifier.refresh(loclist)
+    if self.enabled()
+        call self.reset(a:loclist)
+        let buf = bufnr('')
+        let issues = filter(a:loclist.filteredRaw(), 'v:val["bufnr"] == buf')
+        for item in issues
+            let group = item['type'] == 'E' ? 'SyntasticError' : 'SyntasticWarning'
+
+            " The function `Syntastic_{filetype}_{checker}_GetHighlightRegex` is
+            " used to override default highlighting.
+            if has_key(item, 'hl')
+                call matchadd(group, '\%' . item['lnum'] . 'l' . item['hl'])
+            elseif get(item, 'col')
+                let lastcol = col([item['lnum'], '$'])
+                let lcol = min([lastcol, item['col']])
+
+                " a bug in vim can sometimes cause there to be no 'vcol' key,
+                " so check for its existence
+                let coltype = has_key(item, 'vcol') && item['vcol'] ? 'v' : 'c'
+
+                call matchadd(group, '\%' . item['lnum'] . 'l\%' . lcol . coltype)
+            endif
+        endfor
+    endif
+endfunction
+
+" Remove all error highlights from the window
+function! g:SyntasticHighlightingNotifier.reset(loclist)
+    if s:has_highlighting
+        for match in getmatches()
+            if stridx(match['group'], 'Syntastic') == 0
+                call matchdelete(match['id'])
+            endif
+        endfor
+    endif
+endfunction
+
+" vim: set sw=4 sts=4 et fdm=marker:
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/config/.vim/plugin/syntastic/loclist.vim	Wed Nov 06 14:33:18 2013 +0100
@@ -0,0 +1,184 @@
+if exists("g:loaded_syntastic_loclist")
+    finish
+endif
+let g:loaded_syntastic_loclist = 1
+
+let g:SyntasticLoclist = {}
+
+" Public methods {{{1
+
+function! g:SyntasticLoclist.New(rawLoclist)
+    let newObj = copy(self)
+    let newObj._quietWarnings = g:syntastic_quiet_warnings
+
+    let llist = copy(a:rawLoclist)
+    let llist = filter(llist, 'v:val["valid"] == 1')
+
+    for e in llist
+        if empty(e['type'])
+            let e['type'] = 'E'
+        endif
+    endfor
+
+    let newObj._rawLoclist = llist
+    let newObj._hasErrorsOrWarningsToDisplay = -1
+
+    let newObj._name = ''
+
+    return newObj
+endfunction
+
+function! g:SyntasticLoclist.current()
+    if !exists("b:syntastic_loclist")
+        let b:syntastic_loclist = g:SyntasticLoclist.New([])
+    endif
+    return b:syntastic_loclist
+endfunction
+
+function! g:SyntasticLoclist.extend(other)
+    let list = self.toRaw()
+    call extend(list, a:other.toRaw())
+    return g:SyntasticLoclist.New(list)
+endfunction
+
+function! g:SyntasticLoclist.toRaw()
+    return copy(self._rawLoclist)
+endfunction
+
+function! g:SyntasticLoclist.filteredRaw()
+    return copy(self._quietWarnings ? self.errors() : self._rawLoclist)
+endfunction
+
+function! g:SyntasticLoclist.quietWarnings()
+    return self._quietWarnings
+endfunction
+
+function! g:SyntasticLoclist.isEmpty()
+    return empty(self._rawLoclist)
+endfunction
+
+function! g:SyntasticLoclist.getLength()
+    return len(self._rawLoclist)
+endfunction
+
+function! g:SyntasticLoclist.getName()
+    return len(self._name)
+endfunction
+
+function! g:SyntasticLoclist.setName(name)
+    let self._name = a:name
+endfunction
+
+function! g:SyntasticLoclist.hasErrorsOrWarningsToDisplay()
+    if self._hasErrorsOrWarningsToDisplay >= 0
+        return self._hasErrorsOrWarningsToDisplay
+    endif
+    let self._hasErrorsOrWarningsToDisplay = empty(self._rawLoclist) ? 0 : (!self._quietWarnings || len(self.errors()))
+    return self._hasErrorsOrWarningsToDisplay
+endfunction
+
+function! g:SyntasticLoclist.errors()
+    if !exists("self._cachedErrors")
+        let self._cachedErrors = self.filter({'type': "E"})
+    endif
+    return self._cachedErrors
+endfunction
+
+function! g:SyntasticLoclist.warnings()
+    if !exists("self._cachedWarnings")
+        let self._cachedWarnings = self.filter({'type': "W"})
+    endif
+    return self._cachedWarnings
+endfunction
+
+" cache used by EchoCurrentError()
+function! g:SyntasticLoclist.messages(buf)
+    if !exists("self._cachedMessages")
+        let self._cachedMessages = {}
+        let errors = self.errors() + (self._quietWarnings ? [] : self.warnings())
+
+        for e in errors
+            let b = e['bufnr']
+            let l = e['lnum']
+
+            if !has_key(self._cachedMessages, b)
+                let self._cachedMessages[b] = {}
+            endif
+
+            if !has_key(self._cachedMessages[b], l)
+                let self._cachedMessages[b][l] = e['text']
+            endif
+        endfor
+    endif
+
+    return get(self._cachedMessages, a:buf, {})
+endfunction
+
+"Filter the list and return new native loclist
+"e.g.
+"  .filter({'bufnr': 10, 'type': 'e'})
+"
+"would return all errors for buffer 10.
+"
+"Note that all comparisons are done with ==?
+function! g:SyntasticLoclist.filter(filters)
+    let rv = []
+
+    for error in self._rawLoclist
+
+        let passes_filters = 1
+        for key in keys(a:filters)
+            if error[key] !=? a:filters[key]
+                let passes_filters = 0
+                break
+            endif
+        endfor
+
+        if passes_filters
+            call add(rv, error)
+        endif
+    endfor
+    return rv
+endfunction
+
+"display the cached errors for this buf in the location list
+function! g:SyntasticLoclist.show()
+    if !exists('w:syntastic_loclist_set')
+        let w:syntastic_loclist_set = 0
+    endif
+    call setloclist(0, self.filteredRaw(), g:syntastic_reuse_loc_lists && w:syntastic_loclist_set ? 'r' : ' ')
+    let w:syntastic_loclist_set = 1
+
+    if self.hasErrorsOrWarningsToDisplay()
+        let num = winnr()
+        exec "lopen " . g:syntastic_loc_list_height
+        if num != winnr()
+            wincmd p
+        endif
+
+        " try to find the loclist window and set w:quickfix_title
+        let errors = getloclist(0)
+        for buf in tabpagebuflist()
+            if buflisted(buf) && bufloaded(buf) && getbufvar(buf, '&buftype') ==# 'quickfix'
+                let win = bufwinnr(buf)
+                let title = getwinvar(win, 'quickfix_title')
+
+                " TODO: try to make sure we actually own this window; sadly,
+                " errors == getloclist(0) is the only somewhat safe way to
+                " achieve that
+                if strpart(title, 0, 16) ==# ':SyntasticCheck ' ||
+                            \ ( (title == '' || title ==# ':setloclist()') && errors == getloclist(0) )
+                    call setwinvar(win, 'quickfix_title', ':SyntasticCheck ' . self._name)
+                endif
+            endif
+        endfor
+    endif
+endfunction
+
+" Non-method functions {{{1
+
+function! g:SyntasticLoclistHide()
+    silent! lclose
+endfunction
+
+" vim: set sw=4 sts=4 et fdm=marker:
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/config/.vim/plugin/syntastic/makeprg_builder.vim	Wed Nov 06 14:33:18 2013 +0100
@@ -0,0 +1,72 @@
+if exists("g:loaded_syntastic_makeprg_builder")
+    finish
+endif
+let g:loaded_syntastic_makeprg_builder = 1
+
+let g:SyntasticMakeprgBuilder = {}
+
+" Public methods {{{1
+
+function! g:SyntasticMakeprgBuilder.New(exe, args, fname, post_args, tail, filetype, subchecker)
+    let newObj = copy(self)
+    let newObj._exe = a:exe
+    let newObj._args = a:args
+    let newObj._fname = a:fname
+    let newObj._post_args = a:post_args
+    let newObj._tail = a:tail
+    let newObj._filetype = empty(a:filetype) ? &filetype : a:filetype
+    let newObj._subchecker = a:subchecker
+    return newObj
+endfunction
+
+function! g:SyntasticMakeprgBuilder.makeprg()
+    return join([self.exe(), self.args(), self.fname(), self.post_args(), self.tail()])
+endfunction
+
+function! g:SyntasticMakeprgBuilder.exe()
+    return self._getOpt('exe')
+endfunction
+
+function! g:SyntasticMakeprgBuilder.args()
+    return self._getOpt('args')
+endfunction
+
+function! g:SyntasticMakeprgBuilder.fname()
+    if empty(self._fname)
+        return syntastic#util#shexpand('%')
+    else
+        return self._fname
+    endif
+endfunction
+
+function! g:SyntasticMakeprgBuilder.post_args()
+    return self._getOpt('post_args')
+endfunction
+
+function! g:SyntasticMakeprgBuilder.tail()
+    return self._getOpt('tail')
+endfunction
+
+" Private methods {{{1
+
+function g:SyntasticMakeprgBuilder._getOpt(name)
+    if self._optExists(a:name)
+        return {self._optName(a:name)}
+    endif
+
+    return self['_' . a:name]
+endfunction
+
+function! g:SyntasticMakeprgBuilder._optExists(name)
+    return exists(self._optName(a:name))
+endfunction
+
+function! g:SyntasticMakeprgBuilder._optName(name)
+    let setting = "g:syntastic_" . self._filetype
+    if !empty(self._subchecker)
+        let setting .= '_' . self._subchecker
+    endif
+    return setting . '_' . a:name
+endfunction
+
+" vim: set sw=4 sts=4 et fdm=marker:
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/config/.vim/plugin/syntastic/modemap.vim	Wed Nov 06 14:33:18 2013 +0100
@@ -0,0 +1,67 @@
+if exists("g:loaded_syntastic_modemap")
+    finish
+endif
+let g:loaded_syntastic_modemap = 1
+
+let g:SyntasticModeMap = {}
+
+" Public methods {{{1
+
+function! g:SyntasticModeMap.Instance()
+    if !exists('s:SyntasticModeMapInstance')
+        let s:SyntasticModeMapInstance = copy(self)
+        call s:SyntasticModeMapInstance._initModeMapFromGlobalOpts()
+    endif
+
+    return s:SyntasticModeMapInstance
+endfunction
+
+function! g:SyntasticModeMap.allowsAutoChecking(filetype)
+    let fts = split(a:filetype, '\.')
+
+    if self.isPassive()
+        return self._isOneFiletypeActive(fts)
+    else
+        return self._noFiletypesArePassive(fts)
+    endif
+endfunction
+
+function! g:SyntasticModeMap.isPassive()
+    return self._mode == "passive"
+endfunction
+
+function! g:SyntasticModeMap.toggleMode()
+    if self._mode == "active"
+        let self._mode = "passive"
+    else
+        let self._mode = "active"
+    endif
+endfunction
+
+function! g:SyntasticModeMap.echoMode()
+    echo "Syntastic: " . self._mode . " mode enabled"
+endfunction
+
+" Private methods {{{1
+
+function! g:SyntasticModeMap._initModeMapFromGlobalOpts()
+    let self._mode = "active"
+    let self._activeFiletypes = []
+    let self._passiveFiletypes = []
+
+    if exists("g:syntastic_mode_map")
+        let self._mode = get(g:syntastic_mode_map, 'mode', self._mode)
+        let self._activeFiletypes = get(g:syntastic_mode_map, 'active_filetypes', self._activeFiletypes)
+        let self._passiveFiletypes = get(g:syntastic_mode_map, 'passive_filetypes', self._passiveFiletypes)
+    endif
+endfunction
+
+function! g:SyntasticModeMap._isOneFiletypeActive(filetypes)
+    return !empty(filter(a:filetypes, 'index(self._activeFiletypes, v:val) != -1'))
+endfunction
+
+function! g:SyntasticModeMap._noFiletypesArePassive(filetypes)
+    return empty(filter(a:filetypes, 'index(self._passiveFiletypes, v:val) != -1'))
+endfunction
+
+" vim: set sw=4 sts=4 et fdm=marker:
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/config/.vim/plugin/syntastic/notifiers.vim	Wed Nov 06 14:33:18 2013 +0100
@@ -0,0 +1,55 @@
+if exists("g:loaded_syntastic_notifiers")
+    finish
+endif
+let g:loaded_syntastic_notifiers = 1
+
+let g:SyntasticNotifiers = {}
+
+let s:notifier_types = ['signs', 'balloons', 'highlighting', 'cursor', 'autoloclist']
+
+" Public methods {{{1
+
+function! g:SyntasticNotifiers.Instance()
+    if !exists('s:SyntasticNotifiersInstance')
+        let s:SyntasticNotifiersInstance = copy(self)
+        call s:SyntasticNotifiersInstance._initNotifiers()
+    endif
+
+    return s:SyntasticNotifiersInstance
+endfunction
+
+function! g:SyntasticNotifiers.refresh(loclist)
+    for type in self._enabled_types
+        let class = substitute(type, '.*', 'Syntastic\u&Notifier', '')
+        if !has_key(g:{class}, 'enabled') || self._notifier[type].enabled()
+            call self._notifier[type].refresh(a:loclist)
+        endif
+    endfor
+endfunction
+
+function! g:SyntasticNotifiers.reset(loclist)
+    for type in self._enabled_types
+        let class = substitute(type, '.*', 'Syntastic\u&Notifier', '')
+
+        " reset notifiers regardless if they are enabled or not, since
+        " the user might have disabled them since the last refresh();
+        " notifiers MUST be prepared to deal with reset() when disabled
+        if has_key(g:{class}, 'reset')
+            call self._notifier[type].reset(a:loclist)
+        endif
+    endfor
+endfunction
+
+" Private methods {{{1
+
+function! g:SyntasticNotifiers._initNotifiers()
+    let self._notifier = {}
+    for type in s:notifier_types
+        let class = substitute(type, '.*', 'Syntastic\u&Notifier', '')
+        let self._notifier[type] = g:{class}.New()
+    endfor
+
+    let self._enabled_types = copy(s:notifier_types)
+endfunction
+
+" vim: set sw=4 sts=4 et fdm=marker:
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/config/.vim/plugin/syntastic/registry.vim	Wed Nov 06 14:33:18 2013 +0100
@@ -0,0 +1,213 @@
+if exists("g:loaded_syntastic_registry")
+    finish
+endif
+let g:loaded_syntastic_registry = 1
+
+let s:defaultCheckers = {
+        \ 'c':          ['gcc'],
+        \ 'coffee':     ['coffee', 'coffeelint'],
+        \ 'cpp':        ['gcc'],
+        \ 'css':        ['csslint', 'phpcs'],
+        \ 'go':         ['go'],
+        \ 'html':       ['tidy'],
+        \ 'java':       ['javac'],
+        \ 'javascript': ['jshint', 'jslint'],
+        \ 'json':       ['jsonlint', 'jsonval'],
+        \ 'objc':       ['gcc'],
+        \ 'objcpp':     ['gcc'],
+        \ 'perl':       ['perl', 'perlcritic'],
+        \ 'php':        ['php', 'phpcs', 'phpmd'],
+        \ 'puppet':     ['puppet', 'puppetlint'],
+        \ 'python':     ['python', 'flake8', 'pylint'],
+        \ 'ruby':       ['mri'],
+        \ 'sh':         ['sh'],
+        \ 'tex':        ['lacheck']
+    \ }
+
+let s:defaultFiletypeMap = {
+        \ 'gentoo-metadata': 'xml',
+        \ 'lhaskell': 'haskell'
+    \ }
+
+let g:SyntasticRegistry = {}
+
+" TODO: Handling of filetype aliases: all public methods take aliases as
+" parameters, all private methods take normalized filetypes.  Public methods
+" are thus supposed to normalize filetypes before calling private methods.
+
+" Public methods {{{1
+
+function! g:SyntasticRegistry.Instance()
+    if !exists('s:SyntasticRegistryInstance')
+        let s:SyntasticRegistryInstance = copy(self)
+        let s:SyntasticRegistryInstance._checkerMap = {}
+    endif
+
+    return s:SyntasticRegistryInstance
+endfunction
+
+function! g:SyntasticRegistry.CreateAndRegisterChecker(args)
+    let checker = g:SyntasticChecker.New(a:args)
+    let registry = g:SyntasticRegistry.Instance()
+    call registry.registerChecker(checker)
+endfunction
+
+function! g:SyntasticRegistry.registerChecker(checker) abort
+    let ft = a:checker.getFiletype()
+
+    if !has_key(self._checkerMap, ft)
+        let self._checkerMap[ft] = []
+    endif
+
+    call self._validateUniqueName(a:checker)
+
+    call add(self._checkerMap[ft], a:checker)
+endfunction
+
+function! g:SyntasticRegistry.checkable(ftalias)
+    return !empty(self.getActiveCheckers(a:ftalias))
+endfunction
+
+function! g:SyntasticRegistry.getActiveCheckers(ftalias)
+    let filetype = s:SyntasticRegistryNormaliseFiletype(a:ftalias)
+    let checkers = self.availableCheckersFor(a:ftalias)
+
+    if self._userHasFiletypeSettings(filetype)
+        return self._filterCheckersByUserSettings(checkers, filetype)
+    endif
+
+    if has_key(s:defaultCheckers, filetype)
+        return self._filterCheckersByDefaultSettings(checkers, filetype)
+    endif
+
+    let checkers = self.availableCheckersFor(filetype)
+
+    if !empty(checkers)
+        return [checkers[0]]
+    endif
+
+    return []
+endfunction
+
+function! g:SyntasticRegistry.getChecker(ftalias, name)
+    for checker in self.availableCheckersFor(a:ftalias)
+        if checker.getName() == a:name
+            return checker
+        endif
+    endfor
+
+    return {}
+endfunction
+
+function! g:SyntasticRegistry.availableCheckersFor(ftalias)
+    let filetype = s:SyntasticRegistryNormaliseFiletype(a:ftalias)
+    let checkers = copy(self._allCheckersFor(filetype))
+    return self._filterCheckersByAvailability(checkers)
+endfunction
+
+function! g:SyntasticRegistry.echoInfoFor(ftalias_list)
+    echomsg "Syntastic info for filetype: " . join(a:ftalias_list, '.')
+
+    let available = []
+    let active = []
+    for ftalias in a:ftalias_list
+        call extend(available, self.availableCheckersFor(ftalias))
+        call extend(active, self.getActiveCheckers(ftalias))
+    endfor
+
+    echomsg "Available checkers: " . join(syntastic#util#unique(map(available, "v:val.getName()")))
+    echomsg "Currently active checker(s): " . join(syntastic#util#unique(map(active, "v:val.getName()")))
+endfunction
+
+" Private methods {{{1
+
+function! g:SyntasticRegistry._allCheckersFor(filetype)
+    call self._loadCheckers(a:filetype)
+    if empty(self._checkerMap[a:filetype])
+        return []
+    endif
+
+    return self._checkerMap[a:filetype]
+endfunction
+
+function! g:SyntasticRegistry._filterCheckersByDefaultSettings(checkers, filetype)
+    if has_key(s:defaultCheckers, a:filetype)
+        return self._filterCheckersByName(a:checkers, s:defaultCheckers[a:filetype])
+    endif
+
+    return a:checkers
+endfunction
+
+function! g:SyntasticRegistry._filterCheckersByUserSettings(checkers, filetype)
+    if exists("b:syntastic_checkers")
+        let whitelist = b:syntastic_checkers
+    else
+        let whitelist = g:syntastic_{a:filetype}_checkers
+    endif
+    return self._filterCheckersByName(a:checkers, whitelist)
+endfunction
+
+function! g:SyntasticRegistry._filterCheckersByName(checkers, list)
+    let checkers_by_name = {}
+    for c in a:checkers
+        let checkers_by_name[c.getName()] = c
+    endfor
+
+    let filtered = []
+    for name in a:list
+        if has_key(checkers_by_name, name)
+            call add(filtered, checkers_by_name[name])
+        endif
+    endfor
+
+    return filtered
+endfunction
+
+function! g:SyntasticRegistry._filterCheckersByAvailability(checkers)
+    return filter(copy(a:checkers), "v:val.isAvailable()")
+endfunction
+
+function! g:SyntasticRegistry._loadCheckers(filetype)
+    if self._haveLoadedCheckers(a:filetype)
+        return
+    endif
+
+    exec "runtime! syntax_checkers/" . a:filetype . "/*.vim"
+
+    if !has_key(self._checkerMap, a:filetype)
+        let self._checkerMap[a:filetype] = []
+    endif
+endfunction
+
+function! g:SyntasticRegistry._haveLoadedCheckers(filetype)
+    return has_key(self._checkerMap, a:filetype)
+endfunction
+
+function! g:SyntasticRegistry._userHasFiletypeSettings(filetype)
+    if exists("g:syntastic_" . a:filetype . "_checker") && !exists("g:syntastic_" . a:filetype . "_checkers")
+        let g:syntastic_{a:filetype}_checkers = [g:syntastic_{a:filetype}_checker]
+        call syntastic#util#deprecationWarn("variable g:syntastic_" . a:filetype . "_checker is deprecated")
+    endif
+    return exists("b:syntastic_checkers") || exists("g:syntastic_" . a:filetype . "_checkers")
+endfunction
+
+function! g:SyntasticRegistry._validateUniqueName(checker) abort
+    for checker in self._allCheckersFor(a:checker.getFiletype())
+        if checker.getName() == a:checker.getName()
+            throw "Syntastic: Duplicate syntax checker name for: " . a:checker.getName()
+        endif
+    endfor
+endfunction
+
+" Private functions {{{1
+
+"resolve filetype aliases, and replace - with _ otherwise we cant name
+"syntax checker functions legally for filetypes like "gentoo-metadata"
+function! s:SyntasticRegistryNormaliseFiletype(ftalias)
+    let ft = get(s:defaultFiletypeMap, a:ftalias, a:ftalias)
+    let ft = get(g:syntastic_filetype_map, ft, ft)
+    let ft = substitute(ft, '-', '_', 'g')
+    return ft
+endfunction
+
+" vim: set sw=4 sts=4 et fdm=marker:
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/config/.vim/plugin/syntastic/signs.vim	Wed Nov 06 14:33:18 2013 +0100
@@ -0,0 +1,149 @@
+if exists("g:loaded_syntastic_notifier_signs")
+    finish
+endif
+let g:loaded_syntastic_notifier_signs = 1
+
+if !exists("g:syntastic_enable_signs")
+    let g:syntastic_enable_signs = 1
+endif
+
+if !exists("g:syntastic_error_symbol")
+    let g:syntastic_error_symbol = '>>'
+endif
+
+if !exists("g:syntastic_warning_symbol")
+    let g:syntastic_warning_symbol = '>>'
+endif
+
+if !exists("g:syntastic_style_error_symbol")
+    let g:syntastic_style_error_symbol = 'S>'
+endif
+
+if !exists("g:syntastic_style_warning_symbol")
+    let g:syntastic_style_warning_symbol = 'S>'
+endif
+
+
+" start counting sign ids at 5000, start here to hopefully avoid conflicting
+" with any other code that places signs (not sure if this precaution is
+" actually needed)
+let s:first_sign_id = 5000
+let s:next_sign_id = s:first_sign_id
+
+let g:SyntasticSignsNotifier = {}
+
+let s:setup_done = 0
+
+" Public methods {{{1
+
+function! g:SyntasticSignsNotifier.New()
+    let newObj = copy(self)
+
+    if !s:setup_done
+        call self._setup()
+        let s:setup_done = 1
+    endif
+
+    return newObj
+endfunction
+
+function! g:SyntasticSignsNotifier.enabled()
+    return
+        \ has('signs') &&
+        \ exists('b:syntastic_enable_signs') ? b:syntastic_enable_signs : g:syntastic_enable_signs
+endfunction
+
+function! g:SyntasticSignsNotifier.refresh(loclist)
+    let old_signs = copy(self._bufSignIds())
+    if self.enabled()
+        call self._signErrors(a:loclist)
+    endif
+    call self._removeSigns(old_signs)
+    let s:first_sign_id = s:next_sign_id
+endfunction
+
+" Private methods {{{1
+
+" One time setup: define our own sign types and highlighting
+function! g:SyntasticSignsNotifier._setup()
+    if has('signs')
+        if !hlexists('SyntasticErrorSign')
+            highlight link SyntasticErrorSign error
+        endif
+        if !hlexists('SyntasticWarningSign')
+            highlight link SyntasticWarningSign todo
+        endif
+        if !hlexists('SyntasticStyleErrorSign')
+            highlight link SyntasticStyleErrorSign SyntasticErrorSign
+        endif
+        if !hlexists('SyntasticStyleWarningSign')
+            highlight link SyntasticStyleWarningSign SyntasticWarningSign
+        endif
+        if !hlexists('SyntasticStyleErrorLine')
+            highlight link SyntasticStyleErrorLine SyntasticErrorLine
+        endif
+        if !hlexists('SyntasticStyleWarningLine')
+            highlight link SyntasticStyleWarningLine SyntasticWarningLine
+        endif
+
+        " define the signs used to display syntax and style errors/warns
+        exe 'sign define SyntasticError text=' . g:syntastic_error_symbol .
+            \ ' texthl=SyntasticErrorSign linehl=SyntasticErrorLine'
+        exe 'sign define SyntasticWarning text=' . g:syntastic_warning_symbol .
+            \ ' texthl=SyntasticWarningSign linehl=SyntasticWarningLine'
+        exe 'sign define SyntasticStyleError text=' . g:syntastic_style_error_symbol .
+            \ ' texthl=SyntasticStyleErrorSign linehl=SyntasticStyleErrorLine'
+        exe 'sign define SyntasticStyleWarning text=' . g:syntastic_style_warning_symbol .
+            \ ' texthl=SyntasticStyleWarningSign linehl=SyntasticStyleWarningLine'
+    endif
+endfunction
+
+" Place signs by all syntax errors in the buffer
+function! g:SyntasticSignsNotifier._signErrors(loclist)
+    let loclist = a:loclist
+    if loclist.hasErrorsOrWarningsToDisplay()
+
+        " errors some first, so that they are not masked by warnings
+        let buf = bufnr('')
+        let issues = copy(loclist.errors())
+        if !loclist.quietWarnings()
+            call extend(issues, loclist.warnings())
+        endif
+        call filter(issues, 'v:val["bufnr"] == buf')
+        let seen = {}
+
+        for i in issues
+            if !has_key(seen, i['lnum'])
+                let seen[i['lnum']] = 1
+
+                let sign_severity = i['type'] ==? 'W' ? 'Warning' : 'Error'
+                let sign_subtype = get(i, 'subtype', '')
+                let sign_type = 'Syntastic' . sign_subtype . sign_severity
+
+                exec "sign place " . s:next_sign_id . " line=" . i['lnum'] . " name=" . sign_type . " buffer=" . i['bufnr']
+                call add(self._bufSignIds(), s:next_sign_id)
+                let s:next_sign_id += 1
+            endif
+        endfor
+    endif
+endfunction
+
+" Remove the signs with the given ids from this buffer
+function! g:SyntasticSignsNotifier._removeSigns(ids)
+    if has('signs')
+        for i in a:ids
+            exec "sign unplace " . i
+            call remove(self._bufSignIds(), index(self._bufSignIds(), i))
+        endfor
+    endif
+endfunction
+
+" Get all the ids of the SyntaxError signs in the buffer
+function! g:SyntasticSignsNotifier._bufSignIds()
+    if !exists("b:syntastic_sign_ids")
+        let b:syntastic_sign_ids = []
+    endif
+    return b:syntastic_sign_ids
+endfunction
+
+" vim: set sw=4 sts=4 et fdm=marker:
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/config/.vim/syntax_checkers/ada/gcc.vim	Wed Nov 06 14:33:18 2013 +0100
@@ -0,0 +1,168 @@
+"============================================================================
+"File:        ada.vim
+"Description: Syntax checking plugin for syntastic.vim
+"Maintainer:  Alfredo Di Napoli <alfredo.dinapoli@gmail.com>
+"License:     This program is free software. It comes without any warranty,
+"             to the extent permitted by applicable law.
+"
+"============================================================================
+
+" In order to also check header files add this to your .vimrc:
+"
+"   let g:syntastic_ada_check_header = 1
+"
+" To disable the search of included header files after special
+" libraries like gtk and glib add this line to your .vimrc:
+"
+"   let g:syntastic_ada_no_include_search = 1
+"
+" To disable the include of the default include dirs (such as /usr/include)
+" add this line to your .vimrc:
+"
+"   let g:syntastic_ada_no_default_include_dirs = 1
+"
+" To enable header files being re-checked on every file write add the
+" following line to your .vimrc. Otherwise the header files are checked only
+" one time on initially loading the file.
+" In order to force syntastic to refresh the header includes simply
+" unlet b:syntastic_ada_includes. Then the header files are being re-checked
+" on the next file write.
+"
+"   let g:syntastic_ada_auto_refresh_includes = 1
+"
+" Alternatively you can set the buffer local variable b:syntastic_ada_cflags.
+" If this variable is set for the current buffer no search for additional
+" libraries is done. I.e. set the variable like this:
+"
+"   let b:syntastic_ada_cflags = ' -I/usr/include/libsoup-2.4'
+"
+" In order to add some custom include directories that should be added to the
+" gcc command line you can add those to the global variable
+" g:syntastic_ada_include_dirs. This list can be used like this:
+"
+"   let g:syntastic_ada_include_dirs = [ 'includes', 'headers' ]
+"
+" Moreover it is possible to add additional compiler options to the syntax
+" checking execution via the variable 'g:syntastic_ada_compiler_options':
+"
+"   let g:syntastic_ada_compiler_options = ' -std=c++0x'
+"
+" Additionally the setting 'g:syntastic_ada_config_file' allows you to define
+" a file that contains additional compiler arguments like include directories
+" or CFLAGS. The file is expected to contain one option per line. If none is
+" given the filename defaults to '.syntastic_ada_config':
+"
+"   let g:syntastic_ada_config_file = '.config'
+"
+" Using the global variable 'g:syntastic_ada_remove_include_errors' you can
+" specify whether errors of files included via the
+" g:syntastic_ada_include_dirs' setting are removed from the result set:
+"
+"   let g:syntastic_ada_remove_include_errors = 1
+"
+" Use the variable 'g:syntastic_ada_errorformat' to override the default error
+" format:
+"
+"   let g:syntastic_ada_errorformat = '%f:%l:%c: %trror: %m'
+"
+" Set your compiler executable with e.g. (defaults to gcc)
+"
+"   let g:syntastic_ada_compiler = 'gcc'
+
+if exists('g:loaded_syntastic_ada_gcc_checker')
+    finish
+endif
+let g:loaded_syntastic_ada_gcc_checker = 1
+
+if !exists('g:syntastic_ada_compiler')
+    let g:syntastic_ada_compiler = 'gcc'
+endif
+
+function! SyntaxCheckers_ada_gcc_IsAvailable()
+    return executable(g:syntastic_ada_compiler)
+endfunction
+
+let s:save_cpo = &cpo
+set cpo&vim
+
+if !exists('g:syntastic_ada_compiler_options')
+    let g:syntastic_ada_compiler_options = ''
+endif
+
+if !exists('g:syntastic_ada_config_file')
+    let g:syntastic_ada_config_file = '.syntastic_ada_config'
+endif
+
+function! SyntaxCheckers_ada_gcc_GetLocList()
+    let makeprg = g:syntastic_ada_compiler . ' -c -x ada -fsyntax-only '
+    let errorformat =  '%-G%f:%s:,%f:%l:%c: %m,%f:%l: %m'
+
+    if exists('g:syntastic_c_errorformat')
+        let errorformat = g:syntastic_c_errorformat
+    endif
+
+    " add optional user-defined compiler options
+    let makeprg .= g:syntastic_ada_compiler_options
+
+    let makeprg .= ' ' . syntastic#util#shexpand('%') .
+                \ ' ' . syntastic#c#GetIncludeDirs('ada')
+
+    " determine whether to parse header files as well
+    if expand('%') =~? '\.ads$'
+        if exists('g:syntastic_ada_check_header')
+            let makeprg = g:syntastic_ada_compiler .
+                        \ ' -c ' . syntastic#util#shexpand('%') .
+                        \ ' ' . g:syntastic_ada_compiler_options .
+                        \ ' ' . syntastic#c#GetIncludeDirs('ada')
+        else
+            return []
+        endif
+    endif
+
+    " check if the user manually set some cflags
+    if !exists('b:syntastic_ada_cflags')
+        " check whether to search for include files at all
+        if !exists('g:syntastic_ada_no_include_search') ||
+                    \ g:syntastic_ada_no_include_search != 1
+            " refresh the include file search if desired
+            if exists('g:syntastic_ada_auto_refresh_includes') &&
+                        \ g:syntastic_ada_auto_refresh_includes != 0
+                let makeprg .= syntastic#c#SearchHeaders()
+            else
+                " search for header includes if not cached already
+                if !exists('b:syntastic_ada_includes')
+                    let b:syntastic_ada_includes = syntastic#c#SearchHeaders()
+                endif
+                let makeprg .= b:syntastic_ada_includes
+            endif
+        endif
+    else
+        " use the user-defined cflags
+        let makeprg .= b:syntastic_ada_cflags
+    endif
+
+    " add optional config file parameters
+    let makeprg .= ' ' . syntastic#c#ReadConfig(g:syntastic_ada_config_file)
+
+    " process makeprg
+    let errors = SyntasticMake({ 'makeprg': makeprg,
+                \ 'errorformat': errorformat })
+
+    " filter the processed errors if desired
+    if exists('g:syntastic_ada_remove_include_errors') &&
+                \ g:syntastic_ada_remove_include_errors != 0
+        return filter(errors,
+                    \ 'has_key(v:val, "bufnr") && v:val["bufnr"]=='.bufnr(''))
+    else
+        return errors
+    endif
+endfunction
+
+call g:SyntasticRegistry.CreateAndRegisterChecker({
+    \ 'filetype': 'ada',
+    \ 'name': 'gcc'})
+
+let &cpo = s:save_cpo
+unlet s:save_cpo
+
+" vim: set et sts=4 sw=4:
--- a/config/.vim/syntax_checkers/applescript.vim	Thu Sep 05 16:23:33 2013 +0200
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,43 +0,0 @@
-"==============================================================================
-"       FileName: applescript.vim
-"           Desc: Syntax checking plugin for syntastic.vim
-"         Author: Zhao Cai
-"          Email: caizhaoff@gmail.com
-"        Version: 0.2.1
-"   Date Created: Thu 09 Sep 2011 10:30:09 AM EST 
-"  Last Modified: Fri 09 Dec 2011 01:10:24 PM EST 
-"
-"        History: 0.1.0 - working, but it will run the script everytime to check
-"                 syntax. Should use osacompile but strangely it does not give
-"                 errors.
-"
-"                 0.2.0 - switch to osacompile, it gives less errors compared
-"                 with osascript.
-"
-"                 0.2.1 - remove g:syntastic_applescript_tempfile. use
-"                 tempname() instead.
-"
-"        License: This program is free software. It comes without any
-"        warranty, to the extent permitted by applicable law. You can
-"        redistribute it and/or modify it under the terms of the Do What The
-"        Fuck You Want To Public License, Version 2, as published by Sam
-"        Hocevar.  See http://sam.zoy.org/wtfpl/COPYING for more details.
-"
-"============================================================================
-
-if exists("loaded_applescript_syntax_checker")
-    finish
-endif
-let loaded_applescript_syntax_checker = 1
-
-"bail if the user doesnt have osacompile installed
-if !executable("osacompile")
-    finish
-endif
-
-function! SyntaxCheckers_applescript_GetLocList()
-    let makeprg = 'osacompile -o ' . tempname() . '.scpt '. shellescape(expand('%'))
-    let errorformat = '%f:%l:%m'
-
-    return SyntasticMake({ 'makeprg': makeprg, 'errorformat': errorformat })
-endfunction
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/config/.vim/syntax_checkers/applescript/osacompile.vim	Wed Nov 06 14:33:18 2013 +0100
@@ -0,0 +1,50 @@
+"==============================================================================
+"       FileName: applescript.vim
+"           Desc: Syntax checking plugin for syntastic.vim
+"         Author: Zhao Cai
+"          Email: caizhaoff@gmail.com
+"        Version: 0.2.1
+"   Date Created: Thu 09 Sep 2011 10:30:09 AM EST
+"  Last Modified: Fri 09 Dec 2011 01:10:24 PM EST
+"
+"        History: 0.1.0 - working, but it will run the script everytime to check
+"                 syntax. Should use osacompile but strangely it does not give
+"                 errors.
+"
+"                 0.2.0 - switch to osacompile, it gives less errors compared
+"                 with osascript.
+"
+"                 0.2.1 - remove g:syntastic_applescript_tempfile. use
+"                 tempname() instead.
+"
+"        License: This program is free software. It comes without any
+"        warranty, to the extent permitted by applicable law. You can
+"        redistribute it and/or modify it under the terms of the Do What The
+"        Fuck You Want To Public License, Version 2, as published by Sam
+"        Hocevar.  See http://sam.zoy.org/wtfpl/COPYING for more details.
+"
+"============================================================================
+
+if exists("g:loaded_syntastic_applescript_osacompile_checker")
+    finish
+endif
+let g:loaded_syntastic_applescript_osacompile_checker=1
+
+function! SyntaxCheckers_applescript_osacompile_IsAvailable()
+    return executable('osacompile')
+endfunction
+
+function! SyntaxCheckers_applescript_osacompile_GetLocList()
+    let makeprg = syntastic#makeprg#build({
+        \ 'exe': 'osacompile',
+        \ 'args': '-o ' . tempname() . '.scpt ',
+        \ 'filetype': 'applescript',
+        \ 'subchecker': 'osacompile' })
+    let errorformat = '%f:%l:%m'
+
+    return SyntasticMake({ 'makeprg': makeprg, 'errorformat': errorformat })
+endfunction
+
+call g:SyntasticRegistry.CreateAndRegisterChecker({
+    \ 'filetype': 'applescript',
+    \ 'name': 'osacompile'})
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/config/.vim/syntax_checkers/asciidoc/asciidoc.vim	Wed Nov 06 14:33:18 2013 +0100
@@ -0,0 +1,47 @@
+"============================================================================
+"File:        asciidoc.vim
+"Description: Syntax checking plugin for syntastic.vim
+"Maintainer:  LCD 47 <lcd047 at gmail dot com>
+"License:     This program is free software. It comes without any warranty,
+"             to the extent permitted by applicable law. You can redistribute
+"             it and/or modify it under the terms of the Do What The Fuck You
+"             Want To Public License, Version 2, as published by Sam Hocevar.
+"             See http://sam.zoy.org/wtfpl/COPYING for more details.
+"
+"============================================================================
+
+if exists("g:loaded_syntastic_asciidoc_asciidoc_checker")
+    finish
+endif
+let g:loaded_syntastic_asciidoc_asciidoc_checker = 1
+
+function! SyntaxCheckers_asciidoc_asciidoc_IsAvailable()
+    return executable("asciidoc")
+endfunction
+
+function! SyntaxCheckers_asciidoc_asciidoc_GetLocList()
+    let makeprg = syntastic#makeprg#build({
+        \ 'exe': 'asciidoc',
+        \ 'args': syntastic#c#GetNullDevice(),
+        \ 'filetype': 'asciidoc',
+        \ 'subchecker': 'asciidoc' })
+
+    let errorformat =
+        \ '%Easciidoc: %tRROR: %f: line %l: %m,' .
+        \ '%Easciidoc: %tRROR: %f: %m,' .
+        \ '%Easciidoc: FAILED: %f: line %l: %m,' .
+        \ '%Easciidoc: FAILED: %f: %m,' .
+        \ '%Wasciidoc: %tARNING: %f: line %l: %m,' .
+        \ '%Wasciidoc: %tARNING: %f: %m,' .
+        \ '%Wasciidoc: DEPRECATED: %f: line %l: %m,' .
+        \ '%Wasciidoc: DEPRECATED: %f: %m'
+
+    return SyntasticMake({
+        \ 'makeprg': makeprg,
+        \ 'errorformat': errorformat,
+        \ 'returns': [0, 1] })
+endfunction
+
+call g:SyntasticRegistry.CreateAndRegisterChecker({
+    \ 'filetype': 'asciidoc',
+    \ 'name': 'asciidoc'})
--- a/config/.vim/syntax_checkers/c.vim	Thu Sep 05 16:23:33 2013 +0200
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,156 +0,0 @@
-"============================================================================
-"File:        c.vim
-"Description: Syntax checking plugin for syntastic.vim
-"Maintainer:  Gregor Uhlenheuer <kongo2002 at gmail dot com>
-"License:     This program is free software. It comes without any warranty,
-"             to the extent permitted by applicable law. You can redistribute
-"             it and/or modify it under the terms of the Do What The Fuck You
-"             Want To Public License, Version 2, as published by Sam Hocevar.
-"             See http://sam.zoy.org/wtfpl/COPYING for more details.
-"
-"============================================================================
-
-" In order to also check header files add this to your .vimrc:
-" (this usually creates a .gch file in your source directory)
-"
-"   let g:syntastic_c_check_header = 1
-"
-" To disable the search of included header files after special
-" libraries like gtk and glib add this line to your .vimrc:
-"
-"   let g:syntastic_c_no_include_search = 1
-"
-" To enable header files being re-checked on every file write add the
-" following line to your .vimrc. Otherwise the header files are checked only
-" one time on initially loading the file.
-" In order to force syntastic to refresh the header includes simply
-" unlet b:syntastic_c_includes. Then the header files are being re-checked on
-" the next file write.
-"
-"   let g:syntastic_c_auto_refresh_includes = 1
-"
-" Alternatively you can set the buffer local variable b:syntastic_c_cflags.
-" If this variable is set for the current buffer no search for additional
-" libraries is done. I.e. set the variable like this:
-"
-"   let b:syntastic_c_cflags = ' -I/usr/include/libsoup-2.4'
-"
-" In order to add some custom include directories that should be added to the
-" gcc command line you can add those to the global variable
-" g:syntastic_c_include_dirs. This list can be used like this:
-"
-"   let g:syntastic_c_include_dirs = [ 'includes', 'headers' ]
-"
-" Moreover it is possible to add additional compiler options to the syntax
-" checking execution via the variable 'g:syntastic_c_compiler_options':
-"
-"   let g:syntastic_c_compiler_options = ' -ansi'
-"
-" Using the global variable 'g:syntastic_c_remove_include_errors' you can
-" specify whether errors of files included via the g:syntastic_c_include_dirs'
-" setting are removed from the result set:
-"
-"   let g:syntastic_c_remove_include_errors = 1
-
-if exists('loaded_c_syntax_checker')
-    finish
-endif
-let loaded_c_syntax_checker = 1
-
-if !executable('gcc')
-    finish
-endif
-
-let s:save_cpo = &cpo
-set cpo&vim
-
-" default include directories
-let s:default_includes = [ '.', '..', 'include', 'includes',
-            \ '../include', '../includes' ]
-
-" uniquify the input list
-function! s:Unique(list)
-    let l = []
-    for elem in a:list
-        if index(l, elem) == -1
-            let l = add(l, elem)
-        endif
-    endfor
-    return l
-endfunction
-
-" get the gcc include directory argument depending on the default
-" includes and the optional user-defined 'g:syntastic_c_include_dirs'
-function! s:GetIncludeDirs()
-    let include_dirs = s:default_includes
-
-    if exists('g:syntastic_c_include_dirs')
-        call extend(include_dirs, g:syntastic_c_include_dirs)
-    endif
-
-    return join(map(s:Unique(include_dirs), '"-I" . v:val'), ' ')
-endfunction
-
-function! SyntaxCheckers_c_GetLocList()
-    let makeprg = 'gcc -fsyntax-only -std=gnu99 '.shellescape(expand('%')).
-               \ ' '.s:GetIncludeDirs()
-    let errorformat = '%-G%f:%s:,%-G%f:%l: %#error: %#(Each undeclared '.
-               \ 'identifier is reported only%.%#,%-G%f:%l: %#error: %#for '.
-               \ 'each function it appears%.%#,%-GIn file included%.%#,'.
-               \ '%-G %#from %f:%l\,,%f:%l:%c: %m,%f:%l: %trror: %m,%f:%l: %m'
-
-    " determine whether to parse header files as well
-    if expand('%') =~? '.h$'
-        if exists('g:syntastic_c_check_header')
-            let makeprg = 'gcc -c '.shellescape(expand('%')).
-                        \ ' '.s:GetIncludeDirs()
-        else
-            return []
-        endif
-    endif
-
-    " add optional user-defined compiler options
-    if exists('g:syntastic_c_compiler_options')
-        let makeprg .= g:syntastic_c_compiler_options
-    endif
-
-    " check if the user manually set some cflags
-    if !exists('b:syntastic_c_cflags')
-        " check whether to search for include files at all
-        if !exists('g:syntastic_c_no_include_search') ||
-                    \ g:syntastic_c_no_include_search != 1
-            " refresh the include file search if desired
-            if exists('g:syntastic_c_auto_refresh_includes') &&
-                        \ g:syntastic_c_auto_refresh_includes != 0
-                let makeprg .= syntastic#c#SearchHeaders()
-            else
-                " search for header includes if not cached already
-                if !exists('b:syntastic_c_includes')
-                    let b:syntastic_c_includes = syntastic#c#SearchHeaders()
-                endif
-                let makeprg .= b:syntastic_c_includes
-            endif
-        endif
-    else
-        " use the user-defined cflags
-        let makeprg .= b:syntastic_c_cflags
-    endif
-
-    " process makeprg
-    let errors = SyntasticMake({ 'makeprg': makeprg,
-                \ 'errorformat': errorformat })
-
-    " filter the processed errors if desired
-    if exists('g:syntastic_c_remove_include_errors') &&
-                \ g:syntastic_c_remove_include_errors != 0
-        return filter(errors,
-                    \ 'has_key(v:val, "bufnr") && v:val["bufnr"]=='.bufnr(''))
-    else
-        return errors
-    endif
-endfunction
-
-let &cpo = s:save_cpo
-unlet s:save_cpo
-
-" vim: set et sts=4 sw=4:
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/config/.vim/syntax_checkers/c/checkpatch.vim	Wed Nov 06 14:33:18 2013 +0100
@@ -0,0 +1,48 @@
+"============================================================================
+"File:        checkpatch.vim
+"Description: Syntax checking plugin for syntastic.vim using checkpatch.pl
+"Maintainer:  Daniel Walker <dwalker at fifo99 dot com>
+"License:     This program is free software. It comes without any warranty,
+"             to the extent permitted by applicable law. You can redistribute
+"             it and/or modify it under the terms of the Do What The Fuck You
+"             Want To Public License, Version 2, as published by Sam Hocevar.
+"             See http://sam.zoy.org/wtfpl/COPYING for more details.
+"============================================================================
+if exists("g:loaded_syntastic_c_checkpatch_checker")
+    finish
+endif
+let g:loaded_syntastic_c_checkpatch_checker = 1
+
+" Bail if the user doesn't have `checkpatch.pl` or ./scripts/checkpatch.pl installed.
+if executable("checkpatch.pl")
+    let g:syntastic_c_checker_checkpatch_location = 'checkpatch.pl'
+elseif executable("./scripts/checkpatch.pl")
+    let g:syntastic_c_checker_checkpatch_location = './scripts/checkpatch.pl'
+endif
+
+function SyntaxCheckers_c_checkpatch_IsAvailable()
+    return exists("g:syntastic_c_checker_checkpatch_location")
+endfunction
+
+
+function! SyntaxCheckers_c_checkpatch_GetLocList()
+    let makeprg = syntastic#makeprg#build({
+        \ 'exe': g:syntastic_c_checker_checkpatch_location,
+        \ 'args': '--no-summary --no-tree --terse --file',
+        \ 'filetype': 'c',
+        \ 'subchecker': 'checkpatch' })
+
+    let errorformat =
+        \ '%f:%l: %tARNING: %m,' .
+        \ '%f:%l: %tRROR: %m'
+
+    return SyntasticMake({
+        \ 'makeprg': makeprg,
+        \ 'errorformat': errorformat,
+        \ 'returns': [0],
+        \ 'subtype': 'Style' })
+endfunction
+
+call g:SyntasticRegistry.CreateAndRegisterChecker({
+    \ 'filetype': 'c',
+    \ 'name': 'checkpatch'})
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/config/.vim/syntax_checkers/c/gcc.vim	Wed Nov 06 14:33:18 2013 +0100
@@ -0,0 +1,183 @@
+"============================================================================
+"File:        c.vim
+"Description: Syntax checking plugin for syntastic.vim
+"Maintainer:  Gregor Uhlenheuer <kongo2002 at gmail dot com>
+"License:     This program is free software. It comes without any warranty,
+"             to the extent permitted by applicable law. You can redistribute
+"             it and/or modify it under the terms of the Do What The Fuck You
+"             Want To Public License, Version 2, as published by Sam Hocevar.
+"             See http://sam.zoy.org/wtfpl/COPYING for more details.
+"
+"============================================================================
+
+" In order to also check header files add this to your .vimrc:
+"
+"   let g:syntastic_c_check_header = 1
+"
+" To disable the search of included header files after special
+" libraries like gtk and glib add this line to your .vimrc:
+"
+"   let g:syntastic_c_no_include_search = 1
+"
+" To disable the include of the default include dirs (such as /usr/include)
+" add this line to your .vimrc:
+"
+"   let g:syntastic_c_no_default_include_dirs = 1
+"
+" To enable header files being re-checked on every file write add the
+" following line to your .vimrc. Otherwise the header files are checked only
+" one time on initially loading the file.
+" In order to force syntastic to refresh the header includes simply
+" unlet b:syntastic_c_includes. Then the header files are being re-checked on
+" the next file write.
+"
+"   let g:syntastic_c_auto_refresh_includes = 1
+"
+" Alternatively you can set the buffer local variable b:syntastic_c_cflags.
+" If this variable is set for the current buffer no search for additional
+" libraries is done. I.e. set the variable like this:
+"
+"   let b:syntastic_c_cflags = ' -I/usr/include/libsoup-2.4'
+"
+" In order to add some custom include directories that should be added to the
+" gcc command line you can add those to the global variable
+" g:syntastic_c_include_dirs. This list can be used like this:
+"
+"   let g:syntastic_c_include_dirs = [ 'includes', 'headers' ]
+"
+" Moreover it is possible to add additional compiler options to the syntax
+" checking execution via the variable 'g:syntastic_c_compiler_options':
+"
+"   let g:syntastic_c_compiler_options = ' -ansi'
+"
+" Additionally the setting 'g:syntastic_c_config_file' allows you to define a
+" file that contains additional compiler arguments like include directories or
+" CFLAGS. The file is expected to contain one option per line. If none is
+" given the filename defaults to '.syntastic_c_config':
+"
+"   let g:syntastic_c_config_file = '.config'
+"
+" Using the global variable 'g:syntastic_c_remove_include_errors' you can
+" specify whether errors of files included via the g:syntastic_c_include_dirs'
+" setting are removed from the result set:
+"
+"   let g:syntastic_c_remove_include_errors = 1
+"
+" Use the variable 'g:syntastic_c_errorformat' to override the default error
+" format:
+"
+"   let g:syntastic_c_errorformat = '%f:%l:%c: %trror: %m'
+"
+" Set your compiler executable with e.g. (defaults to gcc)
+"
+"   let g:syntastic_c_compiler = 'clang'
+
+if exists('g:loaded_syntastic_c_gcc_checker')
+    finish
+endif
+let g:loaded_syntastic_c_gcc_checker = 1
+
+if !exists('g:syntastic_c_compiler')
+    let g:syntastic_c_compiler = 'gcc'
+endif
+
+function! SyntaxCheckers_c_gcc_IsAvailable()
+    return executable(g:syntastic_c_compiler)
+endfunction
+
+let s:save_cpo = &cpo
+set cpo&vim
+
+if !exists('g:syntastic_c_compiler_options')
+    let g:syntastic_c_compiler_options = '-std=gnu99'
+endif
+
+if !exists('g:syntastic_c_config_file')
+    let g:syntastic_c_config_file = '.syntastic_c_config'
+endif
+
+function! SyntaxCheckers_c_gcc_GetLocList()
+    let makeprg = g:syntastic_c_compiler . ' -x c -fsyntax-only '
+    let errorformat =
+        \ '%-G%f:%s:,' .
+        \ '%-G%f:%l: %#error: %#(Each undeclared identifier is reported only%.%#,' .
+        \ '%-G%f:%l: %#error: %#for each function it appears%.%#,' .
+        \ '%-GIn file included%.%#,' .
+        \ '%-G %#from %f:%l\,,' .
+        \ '%f:%l:%c: %trror: %m,' .
+        \ '%f:%l:%c: %tarning: %m,' .
+        \ '%f:%l:%c: %m,' .
+        \ '%f:%l: %trror: %m,' .
+        \ '%f:%l: %tarning: %m,'.
+        \ '%f:%l: %m'
+
+    if exists('g:syntastic_c_errorformat')
+        let errorformat = g:syntastic_c_errorformat
+    endif
+
+    " add optional user-defined compiler options
+    let makeprg .= g:syntastic_c_compiler_options
+
+    let makeprg .= ' ' . syntastic#util#shexpand('%') .
+               \ ' ' . syntastic#c#GetIncludeDirs('c')
+
+    " determine whether to parse header files as well
+    if expand('%') =~? '\.h$'
+        if exists('g:syntastic_c_check_header')
+            let makeprg = g:syntastic_c_compiler .
+                        \ ' -c ' . syntastic#util#shexpand('%') .
+                        \ ' ' . g:syntastic_c_compiler_options .
+                        \ ' ' . syntastic#c#GetNullDevice() .
+                        \ ' ' . syntastic#c#GetIncludeDirs('c')
+        else
+            return []
+        endif
+    endif
+
+    " check if the user manually set some cflags
+    if !exists('b:syntastic_c_cflags')
+        " check whether to search for include files at all
+        if !exists('g:syntastic_c_no_include_search') ||
+                    \ g:syntastic_c_no_include_search != 1
+            " refresh the include file search if desired
+            if exists('g:syntastic_c_auto_refresh_includes') &&
+                        \ g:syntastic_c_auto_refresh_includes != 0
+                let makeprg .= syntastic#c#SearchHeaders()
+            else
+                " search for header includes if not cached already
+                if !exists('b:syntastic_c_includes')
+                    let b:syntastic_c_includes = syntastic#c#SearchHeaders()
+                endif
+                let makeprg .= b:syntastic_c_includes
+            endif
+        endif
+    else
+        " use the user-defined cflags
+        let makeprg .= b:syntastic_c_cflags
+    endif
+
+    " add optional config file parameters
+    let makeprg .= ' ' . syntastic#c#ReadConfig(g:syntastic_c_config_file)
+
+    " process makeprg
+    let errors = SyntasticMake({ 'makeprg': makeprg,
+                \ 'errorformat': errorformat })
+
+    " filter the processed errors if desired
+    if exists('g:syntastic_c_remove_include_errors') &&
+                \ g:syntastic_c_remove_include_errors != 0
+        return filter(errors,
+                    \ 'has_key(v:val, "bufnr") && v:val["bufnr"]=='.bufnr(''))
+    else
+        return errors
+    endif
+endfunction
+
+call g:SyntasticRegistry.CreateAndRegisterChecker({
+    \ 'filetype': 'c',
+    \ 'name': 'gcc'})
+
+let &cpo = s:save_cpo
+unlet s:save_cpo
+
+" vim: set et sts=4 sw=4:
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/config/.vim/syntax_checkers/c/make.vim	Wed Nov 06 14:33:18 2013 +0100
@@ -0,0 +1,65 @@
+"============================================================================
+"File:        make.vim
+"Description: Syntax checking plugin for syntastic.vim
+"Maintainer:  Gregor Uhlenheuer <kongo2002 at gmail dot com>
+"License:     This program is free software. It comes without any warranty,
+"             to the extent permitted by applicable law. You can redistribute
+"             it and/or modify it under the terms of the Do What The Fuck You
+"             Want To Public License, Version 2, as published by Sam Hocevar.
+"             See http://sam.zoy.org/wtfpl/COPYING for more details.
+"
+"============================================================================
+
+if exists('g:loaded_syntastic_c_make_checker')
+    finish
+endif
+let g:loaded_syntastic_c_make_checker = 1
+
+function SyntaxCheckers_c_make_IsAvailable()
+    return executable('make')
+endfunction
+
+let s:save_cpo = &cpo
+set cpo&vim
+
+function! SyntaxCheckers_c_make_GetLocList()
+
+    let makeprg = 'make -sk'
+
+    let errorformat =
+        \ '%-G%f:%s:,' .
+        \ '%-G%f:%l: %#error: %#(Each undeclared identifier is reported only%.%#,' .
+        \ '%-G%f:%l: %#error: %#for each function it appears%.%#,' .
+        \ '%-GIn file included%.%#,' .
+        \ '%-G %#from %f:%l\,,' .
+        \ '%f:%l:%c: %trror: %m,' .
+        \ '%f:%l:%c: %tarning: %m,' .
+        \ '%f:%l:%c: %m,' .
+        \ '%f:%l: %trror: %m,' .
+        \ '%f:%l: %tarning: %m,'.
+        \ '%f:%l: %m'
+
+    if exists('g:syntastic_c_errorformat')
+        let errorformat = g:syntastic_c_errorformat
+    endif
+
+    " process makeprg
+    let errors = SyntasticMake({ 'makeprg': makeprg,
+        \ 'errorformat': errorformat })
+
+    " filter the processed errors if desired
+    if exists('g:syntastic_c_remove_include_errors') &&
+            \ g:syntastic_c_remove_include_errors != 0
+        return filter(errors,
+            \ 'has_key(v:val, "bufnr") && v:val["bufnr"]=='.bufnr(''))
+    else
+        return errors
+    endif
+endfunction
+
+call g:SyntasticRegistry.CreateAndRegisterChecker({
+    \ 'filetype': 'c',
+    \ 'name': 'make'})
+
+let &cpo = s:save_cpo
+unlet s:save_cpo
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/config/.vim/syntax_checkers/c/oclint.vim	Wed Nov 06 14:33:18 2013 +0100
@@ -0,0 +1,58 @@
+"============================================================================
+"File:        oclint.vim
+"Description: Syntax checking plugin for syntastic.vim
+"Maintainer:  "UnCO" Lin <undercooled aT lavabit com>
+"License:     This program is free software. It comes without any warranty,
+"             to the extent permitted by applicable law. You can redistribute
+"             it and/or modify it under the terms of the Do What The Fuck You
+"             Want To Public License, Version 2, as published by Sam Hocevar.
+"             See http://sam.zoy.org/wtfpl/COPYING for more details.
+"============================================================================
+"
+" The setting 'g:syntastic_oclint_config_file' allows you to define a file
+" that contains additional compiler arguments like include directories or
+" CFLAGS. The file is expected to contain one option per line. If none is
+" given the filename defaults to '.syntastic_oclint_config':
+"
+"   let g:syntastic_oclint_config_file = '.config'
+
+if exists("g:loaded_syntastic_c_oclint_checker")
+    finish
+endif
+let g:loaded_syntastic_c_oclint_checker = 1
+
+function! SyntaxCheckers_c_oclint_IsAvailable()
+    return executable("oclint")
+endfunction
+
+if !exists('g:syntastic_oclint_config_file')
+    let g:syntastic_oclint_config_file = '.syntastic_oclint_config'
+endif
+
+function! SyntaxCheckers_c_oclint_GetLocList()
+    let makeprg = syntastic#makeprg#build({
+        \ 'exe': 'oclint',
+        \ 'args': '-text',
+        \ 'post_args': '-- -c ' . syntastic#c#ReadConfig(g:syntastic_oclint_config_file),
+        \ 'filetype': 'c',
+        \ 'subchecker': 'oclint' })
+
+    let errorformat =
+        \ '%E%f:%l:%c: %m P1 ,' .
+        \ '%E%f:%l:%c: %m P2 ,' .
+        \ '%W%f:%l:%c: %m P3 ,' .
+        \ '%E%f:%l:%c: fatal error: %m,' .
+        \ '%E%f:%l:%c: error: %m,' .
+        \ '%W%f:%l:%c: warning: %m,' .
+        \ '%-G%.%#'
+
+    return SyntasticMake({
+        \ 'makeprg': makeprg,
+        \ 'errorformat': errorformat,
+        \ 'subtype': 'Style',
+        \ 'postprocess': ['compressWhitespace', 'sort'] })
+endfunction
+
+call g:SyntasticRegistry.CreateAndRegisterChecker({
+    \ 'filetype': 'c',
+    \ 'name': 'oclint'})
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/config/.vim/syntax_checkers/c/sparse.vim	Wed Nov 06 14:33:18 2013 +0100
@@ -0,0 +1,51 @@
+"============================================================================
+"File:        sparse.vim
+"Description: Syntax checking plugin for syntastic.vim using sparse.pl
+"Maintainer:  Daniel Walker <dwalker at fifo99 dot com>
+"License:     This program is free software. It comes without any warranty,
+"             to the extent permitted by applicable law. You can redistribute
+"             it and/or modify it under the terms of the Do What The Fuck You
+"             Want To Public License, Version 2, as published by Sam Hocevar.
+"             See http://sam.zoy.org/wtfpl/COPYING for more details.
+"============================================================================
+"
+" The setting 'g:syntastic_sparse_config_file' allows you to define a file
+" that contains additional compiler arguments like include directories or
+" CFLAGS. The file is expected to contain one option per line. If none is
+" given the filename defaults to '.syntastic_sparse_config':
+"
+"   let g:syntastic_sparse_config_file = '.config'
+
+if exists("g:loaded_syntastic_c_sparse_checker")
+    finish
+endif
+let g:loaded_syntastic_c_sparse_checker = 1
+
+function! SyntaxCheckers_c_sparse_IsAvailable()
+    return executable("sparse")
+endfunction
+
+if !exists('g:syntastic_sparse_config_file')
+    let g:syntastic_sparse_config_file = '.syntastic_sparse_config'
+endif
+
+function! SyntaxCheckers_c_sparse_GetLocList()
+    let makeprg = syntastic#makeprg#build({
+        \ 'exe': 'sparse',
+        \ 'args': '-ftabstop=' . &ts . ' ' . syntastic#c#ReadConfig(g:syntastic_sparse_config_file),
+        \ 'filetype': 'c',
+        \ 'subchecker': 'sparse' })
+
+    let errorformat = '%f:%l:%v: %trror: %m,%f:%l:%v: %tarning: %m,'
+
+    let loclist = SyntasticMake({
+        \ 'makeprg': makeprg,
+        \ 'errorformat': errorformat,
+        \ 'defaults': {'bufnr': bufnr("")},
+        \ 'returns': [0] })
+    return loclist
+endfunction
+
+call g:SyntasticRegistry.CreateAndRegisterChecker({
+    \ 'filetype': 'c',
+    \ 'name': 'sparse'})
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/config/.vim/syntax_checkers/c/splint.vim	Wed Nov 06 14:33:18 2013 +0100
@@ -0,0 +1,57 @@
+"============================================================================
+"File:        splint.vim
+"Description: Syntax checking plugin for syntastic.vim
+"Maintainer:  LCD 47 <lcd047 at gmail dot com>
+"License:     This program is free software. It comes without any warranty,
+"             to the extent permitted by applicable law. You can redistribute
+"             it and/or modify it under the terms of the Do What The Fuck You
+"             Want To Public License, Version 2, as published by Sam Hocevar.
+"             See http://sam.zoy.org/wtfpl/COPYING for more details.
+"============================================================================
+"
+" The setting 'g:syntastic_splint_config_file' allows you to define a file
+" that contains additional compiler arguments like include directories or
+" CFLAGS. The file is expected to contain one option per line. If none is
+" given the filename defaults to '.syntastic_splint_config':
+"
+"   let g:syntastic_splint_config_file = '.config'
+
+if exists("g:loaded_syntastic_c_splint_checker")
+    finish
+endif
+let g:loaded_syntastic_c_splint_checker = 1
+
+function! SyntaxCheckers_c_splint_IsAvailable()
+    return executable("splint")
+endfunction
+
+if !exists('g:syntastic_splint_config_file')
+    let g:syntastic_splint_config_file = '.syntastic_splint_config'
+endif
+
+function! SyntaxCheckers_c_splint_GetLocList()
+    let makeprg = syntastic#makeprg#build({
+        \ 'exe': 'splint',
+        \ 'post_args': '-showfunc -hints +quiet ' . syntastic#c#ReadConfig(g:syntastic_splint_config_file),
+        \ 'filetype': 'c',
+        \ 'subchecker': 'splint' })
+
+    let errorformat =
+        \ '%-G%f:%l:%v: %[%#]%[%#]%[%#] Internal Bug %.%#,' .
+        \ '%W%f:%l:%v: %m,' .
+        \ '%W%f:%l: %m,' .
+        \ '%-C %\+In file included from %.%#,' .
+        \ '%-C %\+from %.%#,' .
+        \ '%+C %.%#'
+
+    return SyntasticMake({
+        \ 'makeprg': makeprg,
+        \ 'errorformat': errorformat,
+        \ 'subtype': 'Style',
+        \ 'postprocess': ['compressWhitespace'],
+        \ 'defaults': {'type': 'W'} })
+endfunction
+
+call g:SyntasticRegistry.CreateAndRegisterChecker({
+    \ 'filetype': 'c',
+    \ 'name': 'splint'})
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/config/.vim/syntax_checkers/c/ycm.vim	Wed Nov 06 14:33:18 2013 +0100
@@ -0,0 +1,32 @@
+"============================================================================
+"File:        ycm.vim
+"Description: Syntax checking plugin for syntastic.vim
+"Maintainer:  Val Markovic <val at markovic dot io>
+"License:     This program is free software. It comes without any warranty,
+"             to the extent permitted by applicable law. You can redistribute
+"             it and/or modify it under the terms of the Do What The Fuck You
+"             Want To Public License, Version 2, as published by Sam Hocevar.
+"             See http://sam.zoy.org/wtfpl/COPYING for more details.
+"
+"============================================================================
+
+if exists("g:loaded_syntastic_c_ycm_checker")
+    finish
+endif
+let g:loaded_syntastic_c_ycm_checker = 1
+
+function! SyntaxCheckers_c_ycm_IsAvailable()
+    return exists('g:loaded_youcompleteme')
+endfunction
+
+if !exists('g:loaded_youcompleteme')
+    finish
+endif
+
+function! SyntaxCheckers_c_ycm_GetLocList()
+    return youcompleteme#CurrentFileDiagnostics()
+endfunction
+
+call g:SyntasticRegistry.CreateAndRegisterChecker({
+    \ 'filetype': 'c',
+    \ 'name': 'ycm'})
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/config/.vim/syntax_checkers/co/coco.vim	Wed Nov 06 14:33:18 2013 +0100
@@ -0,0 +1,44 @@
+"============================================================================
+"File:        co.vim
+"Description: Syntax checking plugin for syntastic.vim
+"Maintainer:  Andrew Kelley <superjoe30@gmail.com>
+"License:     This program is free software. It comes without any warranty,
+"             to the extent permitted by applicable law. You can redistribute
+"             it and/or modify it under the terms of the Do What The Fuck You
+"             Want To Public License, Version 2, as published by Sam Hocevar.
+"             See http://sam.zoy.org/wtfpl/COPYING for more details.
+"
+"============================================================================
+if exists("g:loaded_syntastic_co_coco_checker")
+    finish
+endif
+let g:loaded_syntastic_co_coco_checker=1
+
+"bail if the user doesnt have coco installed
+if !executable("coco")
+    finish
+endif
+
+function! SyntaxCheckers_co_coco_GetLocList()
+    return executable('coco')
+endfunction
+
+function! SyntaxCheckers_co_coco_GetLocList()
+    let makeprg = syntastic#makeprg#build({
+        \ 'exe': 'coco',
+        \ 'args': '-c -o /tmp',
+        \ 'filetype': 'co',
+        \ 'subchecker': 'coco' })
+
+    let errorformat =
+        \ '%EFailed at: %f,' .
+        \ '%ZSyntax%trror: %m on line %l,'.
+        \ '%EFailed at: %f,'.
+        \ '%Z%trror: Parse error on line %l: %m'
+
+    return SyntasticMake({ 'makeprg': makeprg, 'errorformat': errorformat })
+endfunction
+
+call g:SyntasticRegistry.CreateAndRegisterChecker({
+    \ 'filetype': 'co',
+    \ 'name': 'coco'})
--- a/config/.vim/syntax_checkers/coffee.vim	Thu Sep 05 16:23:33 2013 +0200
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,27 +0,0 @@
-"============================================================================
-"File:        coffee.vim
-"Description: Syntax checking plugin for syntastic.vim
-"Maintainer:  Lincoln Stoll <l@lds.li>
-"License:     This program is free software. It comes without any warranty,
-"             to the extent permitted by applicable law. You can redistribute
-"             it and/or modify it under the terms of the Do What The Fuck You
-"             Want To Public License, Version 2, as published by Sam Hocevar.
-"             See http://sam.zoy.org/wtfpl/COPYING for more details.
-"
-"============================================================================
-if exists("loaded_coffee_syntax_checker")
-    finish
-endif
-let loaded_coffee_syntax_checker = 1
-
-"bail if the user doesnt have coffee installed
-if !executable("coffee")
-    finish
-endif
-
-function! SyntaxCheckers_coffee_GetLocList()
-    let makeprg = 'coffee -c -l -o /tmp '.shellescape(expand('%'))
-    let errorformat =  '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,%-Z%p^,%W%f(%l): warning: %m,%-Z%p^,%E%f(%l): SyntaxError: %m,%-Z%p^,%-G%.%#'
-
-    return SyntasticMake({ 'makeprg': makeprg, 'errorformat': errorformat })
-endfunction
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/config/.vim/syntax_checkers/coffee/coffee.vim	Wed Nov 06 14:33:18 2013 +0100
@@ -0,0 +1,48 @@
+"============================================================================
+"File:        coffee.vim
+"Description: Syntax checking plugin for syntastic.vim
+"Maintainer:  Lincoln Stoll <l@lds.li>
+"License:     This program is free software. It comes without any warranty,
+"             to the extent permitted by applicable law. You can redistribute
+"             it and/or modify it under the terms of the Do What The Fuck You
+"             Want To Public License, Version 2, as published by Sam Hocevar.
+"             See http://sam.zoy.org/wtfpl/COPYING for more details.
+"
+"============================================================================
+"
+" Note: this script requires CoffeeScript version 1.6.2 or newer.
+"
+if exists("g:loaded_syntastic_coffee_coffee_checker")
+    finish
+endif
+let g:loaded_syntastic_coffee_coffee_checker=1
+
+function! SyntaxCheckers_coffee_coffee_IsAvailable()
+    return executable("coffee") &&
+        \ syntastic#util#versionIsAtLeast(syntastic#util#parseVersion('coffee --version 2>' . syntastic#util#DevNull()), [1,6,2])
+endfunction
+
+function! SyntaxCheckers_coffee_coffee_GetLocList()
+    let makeprg = syntastic#makeprg#build({
+        \ 'exe': 'coffee',
+        \ 'args': '-cp',
+        \ 'filetype': 'coffee',
+        \ 'subchecker': 'coffee' })
+
+    let errorformat =
+        \ '%E%f:%l:%c: %trror: %m,' .
+        \ 'Syntax%trror: In %f\, %m on line %l,' .
+        \ '%EError: In %f\, Parse error on line %l: %m,' .
+        \ '%EError: In %f\, %m on line %l,' .
+        \ '%W%f(%l): lint warning: %m,' .
+        \ '%W%f(%l): warning: %m,' .
+        \ '%E%f(%l): SyntaxError: %m,' .
+        \ '%-Z%p^,' .
+        \ '%-G%.%#'
+
+    return SyntasticMake({ 'makeprg': makeprg, 'errorformat': errorformat })
+endfunction
+
+call g:SyntasticRegistry.CreateAndRegisterChecker({
+    \ 'filetype': 'coffee',
+    \ 'name': 'coffee'})
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/config/.vim/syntax_checkers/coffee/coffeelint.vim	Wed Nov 06 14:33:18 2013 +0100
@@ -0,0 +1,43 @@
+"============================================================================
+"File:        coffeelint.vim
+"Description: Syntax checking plugin for syntastic.vim
+"Maintainer:  Lincoln Stoll <l@lds.li>
+"License:     This program is free software. It comes without any warranty,
+"             to the extent permitted by applicable law. You can redistribute
+"             it and/or modify it under the terms of the Do What The Fuck You
+"             Want To Public License, Version 2, as published by Sam Hocevar.
+"             See http://sam.zoy.org/wtfpl/COPYING for more details.
+"
+"============================================================================
+if exists("g:loaded_syntastic_coffee_coffeelint_checker")
+    finish
+endif
+let g:loaded_syntastic_coffee_coffeelint_checker=1
+
+function! SyntaxCheckers_coffee_coffeelint_IsAvailable()
+    return executable('coffeelint')
+endfunction
+
+function! SyntaxCheckers_coffee_coffeelint_GetLocList()
+    let makeprg = syntastic#makeprg#build({
+        \ 'exe': 'coffeelint',
+        \ 'args': '--csv',
+        \ 'filetype': 'coffee',
+        \ 'subchecker': 'coffeelint' })
+
+    let errorformat =
+        \ '%f\,%l\,%\d%#\,%trror\,%m,' .
+        \ '%f\,%l\,%trror\,%m,' .
+        \ '%f\,%l\,%\d%#\,%tarn\,%m,' .
+        \ '%f\,%l\,%tarn\,%m'
+
+    return SyntasticMake({
+        \ 'makeprg': makeprg,
+        \ 'errorformat': errorformat,
+        \ 'subtype': 'Style',
+        \ 'returns': [0, 1] })
+endfunction
+
+call g:SyntasticRegistry.CreateAndRegisterChecker({
+    \ 'filetype': 'coffee',
+    \ 'name': 'coffeelint'})
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/config/.vim/syntax_checkers/coq/coqtop.vim	Wed Nov 06 14:33:18 2013 +0100
@@ -0,0 +1,40 @@
+"============================================================================
+"File:        coqtop.vim
+"Description: Syntax checking plugin for syntastic.vim
+"Maintainer:  Matvey Aksenov <matvey.aksenov at gmail dot com>
+"License:     This program is free software. It comes without any warranty,
+"             to the extent permitted by applicable law. You can redistribute
+"             it and/or modify it under the terms of the Do What The Fuck You
+"             Want To Public License, Version 2, as published by Sam Hocevar.
+"             See http://sam.zoy.org/wtfpl/COPYING for more details.
+"
+"============================================================================
+
+if exists("g:loaded_syntastic_coq_coqtop_checker")
+    finish
+endif
+let g:loaded_syntastic_coq_coqtop_checker=1
+
+function! SyntaxCheckers_coq_coqtop_IsAvailable()
+    return executable('coqtop')
+endfunction
+
+function! SyntaxCheckers_coq_coqtop_GetLocList()
+    let makeprg = syntastic#makeprg#build({
+        \ 'exe': 'coqtop',
+        \ 'args': '-noglob -batch -load-vernac-source',
+        \ 'filetype': 'coq',
+        \ 'subchecker': 'coqtop' })
+
+    let errorformat =
+        \ '%AFile \"%f\"\, line %l\, characters %c\-%.%#\:,'.
+        \ '%C%m'
+
+    return SyntasticMake({
+        \ 'makeprg': makeprg,
+        \ 'errorformat': errorformat })
+endfunction
+
+call g:SyntasticRegistry.CreateAndRegisterChecker({
+    \ 'filetype': 'coq',
+    \ 'name': 'coqtop'})
--- a/config/.vim/syntax_checkers/cpp.vim	Thu Sep 05 16:23:33 2013 +0200
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,94 +0,0 @@
-"============================================================================
-"File:        cpp.vim
-"Description: Syntax checking plugin for syntastic.vim
-"Maintainer:  Gregor Uhlenheuer <kongo2002 at gmail dot com>
-"License:     This program is free software. It comes without any warranty,
-"             to the extent permitted by applicable law. You can redistribute
-"             it and/or modify it under the terms of the Do What The Fuck You
-"             Want To Public License, Version 2, as published by Sam Hocevar.
-"             See http://sam.zoy.org/wtfpl/COPYING for more details.
-"
-"============================================================================
-
-" in order to also check header files add this to your .vimrc:
-" (this usually creates a .gch file in your source directory)
-"
-"   let g:syntastic_cpp_check_header = 1
-"
-" To disable the search of included header files after special
-" libraries like gtk and glib add this line to your .vimrc:
-"
-"   let g:syntastic_cpp_no_include_search = 1
-"
-" To enable header files being re-checked on every file write add the
-" following line to your .vimrc. Otherwise the header files are checked only
-" one time on initially loading the file.
-" In order to force syntastic to refresh the header includes simply
-" unlet b:syntastic_cpp_includes. Then the header files are being re-checked
-" on the next file write.
-"
-"   let g:syntastic_cpp_auto_refresh_includes = 1
-"
-" Alternatively you can set the buffer local variable b:syntastic_cpp_cflags.
-" If this variable is set for the current buffer no search for additional
-" libraries is done. I.e. set the variable like this:
-"
-"   let b:syntastic_cpp_cflags = ' -I/usr/include/libsoup-2.4'
-"
-" Moreover it is possible to add additional compiler options to the syntax
-" checking execution via the variable 'g:syntastic_cpp_compiler_options':
-"
-"   let g:syntastic_cpp_compiler_options = ' -std=c++0x'
-
-if exists('loaded_cpp_syntax_checker')
-    finish
-endif
-let loaded_cpp_syntax_checker = 1
-
-if !executable('g++')
-    finish
-endif
-
-let s:save_cpo = &cpo
-set cpo&vim
-
-function! SyntaxCheckers_cpp_GetLocList()
-    let makeprg = 'g++ -fsyntax-only '.shellescape(expand('%'))
-    let errorformat =  '%-G%f:%s:,%f:%l:%c: %m,%f:%l: %m'
-
-    if expand('%') =~? '\%(.h\|.hpp\|.hh\)$'
-        if exists('g:syntastic_cpp_check_header')
-            let makeprg = 'g++ -c '.shellescape(expand('%'))
-        else
-            return []
-        endif
-    endif
-
-    if exists('g:syntastic_cpp_compiler_options')
-        let makeprg .= g:syntastic_cpp_compiler_options
-    endif
-
-    if !exists('b:syntastic_cpp_cflags')
-        if !exists('g:syntastic_cpp_no_include_search') ||
-                    \ g:syntastic_cpp_no_include_search != 1
-            if exists('g:syntastic_cpp_auto_refresh_includes') &&
-                        \ g:syntastic_cpp_auto_refresh_includes != 0
-                let makeprg .= syntastic#c#SearchHeaders()
-            else
-                if !exists('b:syntastic_cpp_includes')
-                    let b:syntastic_cpp_includes = syntastic#c#SearchHeaders()
-                endif
-                let makeprg .= b:syntastic_cpp_includes
-            endif
-        endif
-    else
-        let makeprg .= b:syntastic_cpp_cflags
-    endif
-
-    return SyntasticMake({ 'makeprg': makeprg, 'errorformat': errorformat })
-endfunction
-
-let &cpo = s:save_cpo
-unlet s:save_cpo
-
-" vim: set et sts=4 sw=4:
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/config/.vim/syntax_checkers/cpp/cpplint.vim	Wed Nov 06 14:33:18 2013 +0100
@@ -0,0 +1,65 @@
+"============================================================================
+"File:        cpplint.vim
+"Description: Syntax checking plugin for syntastic.vim
+"Maintainer:  LCD 47 <lcd047 at gmail dot com>
+"License:     This program is free software. It comes without any warranty,
+"             to the extent permitted by applicable law. You can redistribute
+"             it and/or modify it under the terms of the Do What The Fuck You
+"             Want To Public License, Version 2, as published by Sam Hocevar.
+"             See http://sam.zoy.org/wtfpl/COPYING for more details.
+"
+"============================================================================
+"
+" For details about cpplint see:
+"    https://code.google.com/p/google-styleguide/
+"
+" Checker options:
+"
+" - g:syntastic_cpp_cpplint_thres (integer; default: 5)
+"   error threshold: policy violations with a severity above this
+"   value are highlighted as errors, the others are warnings
+"
+" - g:syntastic_cpp_cpplint_args (string; default: '--verbose=3')
+"   command line options to pass to cpplint
+
+if exists("g:loaded_syntastic_cpp_cpplint_checker")
+    finish
+endif
+let g:loaded_syntastic_cpp_cpplint_checker = 1
+
+if !exists('g:syntastic_cpp_cpplint_thres')
+    let g:syntastic_cpp_cpplint_thres = 5
+endif
+
+if ! exists('g:syntastic_cpp_cpplint_args')
+    let g:syntastic_cpp_cpplint_args = '--verbose=3'
+endif
+
+function! SyntaxCheckers_cpp_cpplint_IsAvailable()
+    return executable('cpplint.py')
+endfunction
+
+function! SyntaxCheckers_cpp_cpplint_GetLocList()
+    let makeprg = syntastic#makeprg#build({
+        \ 'exe': 'cpplint.py',
+        \ 'filetype': 'cpp',
+        \ 'subchecker': 'cpplint' })
+
+    let errorformat = '%A%f:%l:  %m [%t],%-G%.%#'
+
+    let loclist = SyntasticMake({
+        \ 'makeprg': makeprg,
+        \ 'errorformat': errorformat,
+        \ 'subtype': 'Style' })
+
+    " change error types according to the prescribed threshold
+    for n in range(len(loclist))
+        let loclist[n]['type'] = loclist[n]['type'] < g:syntastic_cpp_cpplint_thres ? 'W' : 'E'
+    endfor
+
+    return loclist
+endfunction
+
+call g:SyntasticRegistry.CreateAndRegisterChecker({
+    \ 'filetype': 'cpp',
+    \ 'name': 'cpplint'})
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/config/.vim/syntax_checkers/cpp/gcc.vim	Wed Nov 06 14:33:18 2013 +0100
@@ -0,0 +1,179 @@
+"============================================================================
+"File:        cpp.vim
+"Description: Syntax checking plugin for syntastic.vim
+"Maintainer:  Gregor Uhlenheuer <kongo2002 at gmail dot com>
+"License:     This program is free software. It comes without any warranty,
+"             to the extent permitted by applicable law. You can redistribute
+"             it and/or modify it under the terms of the Do What The Fuck You
+"             Want To Public License, Version 2, as published by Sam Hocevar.
+"             See http://sam.zoy.org/wtfpl/COPYING for more details.
+"
+"============================================================================
+
+" In order to also check header files add this to your .vimrc:
+"
+"   let g:syntastic_cpp_check_header = 1
+"
+" To disable the search of included header files after special
+" libraries like gtk and glib add this line to your .vimrc:
+"
+"   let g:syntastic_cpp_no_include_search = 1
+"
+" To disable the include of the default include dirs (such as /usr/include)
+" add this line to your .vimrc:
+"
+"   let g:syntastic_cpp_no_default_include_dirs = 1
+"
+" To enable header files being re-checked on every file write add the
+" following line to your .vimrc. Otherwise the header files are checked only
+" one time on initially loading the file.
+" In order to force syntastic to refresh the header includes simply
+" unlet b:syntastic_cpp_includes. Then the header files are being re-checked
+" on the next file write.
+"
+"   let g:syntastic_cpp_auto_refresh_includes = 1
+"
+" Alternatively you can set the buffer local variable b:syntastic_cpp_cflags.
+" If this variable is set for the current buffer no search for additional
+" libraries is done. I.e. set the variable like this:
+"
+"   let b:syntastic_cpp_cflags = ' -I/usr/include/libsoup-2.4'
+"
+" In order to add some custom include directories that should be added to the
+" gcc command line you can add those to the global variable
+" g:syntastic_cpp_include_dirs. This list can be used like this:
+"
+"   let g:syntastic_cpp_include_dirs = [ 'includes', 'headers' ]
+"
+" Moreover it is possible to add additional compiler options to the syntax
+" checking execution via the variable 'g:syntastic_cpp_compiler_options':
+"
+"   let g:syntastic_cpp_compiler_options = ' -std=c++0x'
+"
+" Additionally the setting 'g:syntastic_cpp_config_file' allows you to define
+" a file that contains additional compiler arguments like include directories
+" or CFLAGS. The file is expected to contain one option per line. If none is
+" given the filename defaults to '.syntastic_cpp_config':
+"
+"   let g:syntastic_cpp_config_file = '.config'
+"
+" Using the global variable 'g:syntastic_cpp_remove_include_errors' you can
+" specify whether errors of files included via the
+" g:syntastic_cpp_include_dirs' setting are removed from the result set:
+"
+"   let g:syntastic_cpp_remove_include_errors = 1
+"
+" Use the variable 'g:syntastic_cpp_errorformat' to override the default error
+" format:
+"
+"   let g:syntastic_cpp_errorformat = '%f:%l:%c: %trror: %m'
+"
+" Set your compiler executable with e.g. (defaults to g++)
+"
+"   let g:syntastic_cpp_compiler = 'clang++'
+
+if exists('g:loaded_syntastic_cpp_gcc_checker')
+    finish
+endif
+let g:loaded_syntastic_cpp_gcc_checker = 1
+
+if !exists('g:syntastic_cpp_compiler')
+    let g:syntastic_cpp_compiler = 'g++'
+endif
+
+function! SyntaxCheckers_cpp_gcc_IsAvailable()
+    return executable(g:syntastic_cpp_compiler)
+endfunction
+
+let s:save_cpo = &cpo
+set cpo&vim
+
+if !exists('g:syntastic_cpp_compiler_options')
+    let g:syntastic_cpp_compiler_options = ''
+endif
+
+if !exists('g:syntastic_cpp_config_file')
+    let g:syntastic_cpp_config_file = '.syntastic_cpp_config'
+endif
+
+function! SyntaxCheckers_cpp_gcc_GetLocList()
+    let makeprg = g:syntastic_cpp_compiler . ' -x c++ -fsyntax-only '
+    let errorformat =
+        \ '%-G%f:%s:,' .
+        \ '%f:%l:%c: %trror: %m,' .
+        \ '%f:%l:%c: %tarning: %m,' .
+        \ '%f:%l:%c: %m,'.
+        \ '%f:%l: %trror: %m,'.
+        \ '%f:%l: %tarning: %m,'.
+        \ '%f:%l: %m'
+
+    if exists('g:syntastic_cpp_errorformat')
+        let errorformat = g:syntastic_cpp_errorformat
+    endif
+
+    " add optional user-defined compiler options
+    let makeprg .= g:syntastic_cpp_compiler_options
+
+    let makeprg .= ' ' . syntastic#util#shexpand('%') .
+                \ ' ' . syntastic#c#GetIncludeDirs('cpp')
+
+    " determine whether to parse header files as well
+    if expand('%') =~? '\.\(h\|hpp\|hh\)$'
+        if exists('g:syntastic_cpp_check_header')
+            let makeprg = g:syntastic_cpp_compiler .
+                        \ ' -c ' . syntastic#util#shexpand('%') .
+                        \ ' ' . g:syntastic_cpp_compiler_options .
+                        \ ' ' . syntastic#c#GetNullDevice() .
+                        \ ' ' . syntastic#c#GetIncludeDirs('cpp')
+        else
+            return []
+        endif
+    endif
+
+    " check if the user manually set some cflags
+    if !exists('b:syntastic_cpp_cflags')
+        " check whether to search for include files at all
+        if !exists('g:syntastic_cpp_no_include_search') ||
+                    \ g:syntastic_cpp_no_include_search != 1
+            " refresh the include file search if desired
+            if exists('g:syntastic_cpp_auto_refresh_includes') &&
+                        \ g:syntastic_cpp_auto_refresh_includes != 0
+                let makeprg .= syntastic#c#SearchHeaders()
+            else
+                " search for header includes if not cached already
+                if !exists('b:syntastic_cpp_includes')
+                    let b:syntastic_cpp_includes = syntastic#c#SearchHeaders()
+                endif
+                let makeprg .= b:syntastic_cpp_includes
+            endif
+        endif
+    else
+        " use the user-defined cflags
+        let makeprg .= b:syntastic_cpp_cflags
+    endif
+
+    " add optional config file parameters
+    let makeprg .= ' ' . syntastic#c#ReadConfig(g:syntastic_cpp_config_file)
+
+    " process makeprg
+    let errors = SyntasticMake({ 'makeprg': makeprg,
+                \ 'errorformat': errorformat })
+
+    " filter the processed errors if desired
+    if exists('g:syntastic_cpp_remove_include_errors') &&
+                \ g:syntastic_cpp_remove_include_errors != 0
+        return filter(errors,
+                    \ 'has_key(v:val, "bufnr") && v:val["bufnr"]=='.bufnr(''))
+    else
+        return errors
+    endif
+endfunction
+
+call g:SyntasticRegistry.CreateAndRegisterChecker({
+    \ 'filetype': 'cpp',
+    \ 'name': 'gcc'})
+
+let &cpo = s:save_cpo
+unlet s:save_cpo
+
+" vim: set et sts=4 sw=4:
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/config/.vim/syntax_checkers/cpp/oclint.vim	Wed Nov 06 14:33:18 2013 +0100
@@ -0,0 +1,36 @@
+"============================================================================
+"File:        oclint.vim
+"Description: Syntax checking plugin for syntastic.vim
+"Maintainer:  "UnCO" Lin <undercooled aT lavabit com>
+"License:     This program is free software. It comes without any warranty,
+"             to the extent permitted by applicable law. You can redistribute
+"             it and/or modify it under the terms of the Do What The Fuck You
+"             Want To Public License, Version 2, as published by Sam Hocevar.
+"             See http://sam.zoy.org/wtfpl/COPYING for more details.
+"============================================================================
+"
+" The setting 'g:syntastic_oclint_config_file' allows you to define a file
+" that contains additional compiler arguments like include directories or
+" CFLAGS. The file is expected to contain one option per line. If none is
+" given the filename defaults to '.syntastic_oclint_config':
+"
+"   let g:syntastic_oclint_config_file = '.config'
+
+if exists("g:loaded_syntastic_cpp_oclint_checker")
+    finish
+endif
+let g:loaded_syntastic_cpp_oclint_checker = 1
+
+function! SyntaxCheckers_cpp_oclint_IsAvailable()
+    return SyntaxCheckers_c_oclint_IsAvailable()
+endfunction
+
+function! SyntaxCheckers_cpp_oclint_GetLocList()
+    return SyntaxCheckers_c_oclint_GetLocList()
+endfunction
+
+call g:SyntasticRegistry.CreateAndRegisterChecker({
+    \ 'filetype': 'cpp',
+    \ 'name': 'oclint'})
+
+runtime! syntax_checkers/c/*.vim
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/config/.vim/syntax_checkers/cpp/ycm.vim	Wed Nov 06 14:33:18 2013 +0100
@@ -0,0 +1,34 @@
+"============================================================================
+"File:        ycm.vim
+"Description: Syntax checking plugin for syntastic.vim
+"Maintainer:  Val Markovic <val at markovic dot io>
+"License:     This program is free software. It comes without any warranty,
+"             to the extent permitted by applicable law. You can redistribute
+"             it and/or modify it under the terms of the Do What The Fuck You
+"             Want To Public License, Version 2, as published by Sam Hocevar.
+"             See http://sam.zoy.org/wtfpl/COPYING for more details.
+"
+"============================================================================
+
+if exists("g:loaded_syntastic_cpp_ycm_checker")
+    finish
+endif
+let g:loaded_syntastic_cpp_ycm_checker = 1
+
+function! SyntaxCheckers_cpp_ycm_IsAvailable()
+    return SyntaxCheckers_c_ycm_IsAvailable()
+endfunction
+
+if !exists('g:loaded_youcompleteme')
+    finish
+endif
+
+function! SyntaxCheckers_cpp_ycm_GetLocList()
+    return SyntaxCheckers_c_ycm_GetLocList()
+endfunction
+
+call g:SyntasticRegistry.CreateAndRegisterChecker({
+    \ 'filetype': 'cpp',
+    \ 'name': 'ycm'})
+
+runtime! syntax_checkers/c/*.vim
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/config/.vim/syntax_checkers/cs/mcs.vim	Wed Nov 06 14:33:18 2013 +0100
@@ -0,0 +1,39 @@
+"============================================================================
+"File:        cs.vim
+"Description: Syntax checking plugin for syntastic.vim
+"Maintainer:  Daniel Walker <dwalker@fifo99.com>
+"License:     This program is free software. It comes without any warranty,
+"             to the extent permitted by applicable law. You can redistribute
+"             it and/or modify it under the terms of the Do What The Fuck You
+"             Want To Public License, Version 2, as published by Sam Hocevar.
+"             See http://sam.zoy.org/wtfpl/COPYING for more details.
+"
+"============================================================================
+
+if exists("g:loaded_syntastic_cs_mcs_checker")
+    finish
+endif
+let g:loaded_syntastic_cs_mcs_checker=1
+
+function! SyntaxCheckers_cs_mcs_IsAvailable()
+    return executable('mcs')
+endfunction
+
+function! SyntaxCheckers_cs_mcs_GetLocList()
+    let makeprg = syntastic#makeprg#build({
+        \ 'exe': 'mcs',
+        \ 'args': '--parse',
+        \ 'filetype': 'cs',
+        \ 'subchecker': 'mcs' })
+
+    let errorformat = '%f(%l\,%c): %trror %m'
+
+    return SyntasticMake({
+        \ 'makeprg': makeprg,
+        \ 'errorformat': errorformat,
+        \ 'defaults': {'bufnr': bufnr("")} })
+endfunction
+
+call g:SyntasticRegistry.CreateAndRegisterChecker({
+    \ 'filetype': 'cs',
+    \ 'name': 'mcs'})
--- a/config/.vim/syntax_checkers/css.vim	Thu Sep 05 16:23:33 2013 +0200
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,31 +0,0 @@
-"============================================================================
-"File:        css.vim
-"Description: Syntax checking plugin for syntastic.vim using `csslint` CLI tool (http://csslint.net).
-"Maintainer:  Ory Band <oryband at gmail dot com>
-"License:     This program is free software. It comes without any warranty,
-"             to the extent permitted by applicable law. You can redistribute
-"             it and/or modify it under the terms of the Do What The Fuck You
-"             Want To Public License, Version 2, as published by Sam Hocevar.
-"             See http://sam.zoy.org/wtfpl/COPYING for more details.
-"============================================================================
-if exists("loaded_css_syntax_checker")
-    finish
-endif
-let loaded_css_syntax_checker = 1
-
-" Bail if the user doesn't have `csslint` installed.
-if !executable("csslint")
-    finish
-endif
-
-function! SyntaxCheckers_css_GetLocList()
-    let makeprg = 'csslint --format=compact '.shellescape(expand('%'))
-
-    " Print CSS Lint's error/warning messages from compact format. Ignores blank lines.
-    let errorformat = '%-G,%-G%f: lint free!,%f: line %l\, col %c\, %trror - %m,%f: line %l\, col %c\, %tarning - %m,%f: line %l\, col %c\, %m,'
-
-    return SyntasticMake({ 'makeprg': makeprg,
-                                \ 'errorformat': errorformat,
-                                \ 'defaults': {'bufnr': bufnr("")} })
-
-endfunction
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/config/.vim/syntax_checkers/css/csslint.vim	Wed Nov 06 14:33:18 2013 +0100
@@ -0,0 +1,58 @@
+"============================================================================
+"File:        css.vim
+"Description: Syntax checking plugin for syntastic.vim using `csslint` CLI tool (http://csslint.net).
+"Maintainer:  Ory Band <oryband at gmail dot com>
+"License:     This program is free software. It comes without any warranty,
+"             to the extent permitted by applicable law. You can redistribute
+"             it and/or modify it under the terms of the Do What The Fuck You
+"             Want To Public License, Version 2, as published by Sam Hocevar.
+"             See http://sam.zoy.org/wtfpl/COPYING for more details.
+"============================================================================
+"
+" Specify additional options to csslint with this option. e.g. to disable
+" warnings:
+"
+"   let g:syntastic_csslint_options = '--warnings=none'
+
+if exists('g:loaded_syntastic_css_csslint_checker')
+    finish
+endif
+let g:loaded_syntastic_css_csslint_checker=1
+
+if !exists('g:syntastic_csslint_exec')
+    let g:syntastic_csslint_exec = 'csslint'
+endif
+
+if !exists('g:syntastic_csslint_options')
+    let g:syntastic_csslint_options = ''
+endif
+
+function! SyntaxCheckers_css_csslint_IsAvailable()
+    return executable(expand(g:syntastic_csslint_exec))
+endfunction
+
+function! SyntaxCheckers_css_csslint_GetLocList()
+    let makeprg = syntastic#makeprg#build({
+        \ 'exe': expand(g:syntastic_csslint_exec),
+        \ 'args': '--format=compact ' . g:syntastic_csslint_options,
+        \ 'filetype': 'css',
+        \ 'subchecker': 'csslint' })
+
+    " Print CSS Lint's error/warning messages from compact format. Ignores blank lines.
+    let errorformat =
+        \ '%-G,' .
+        \ '%-G%f: lint free!,' .
+        \ '%f: line %l\, col %c\, %trror - %m,' .
+        \ '%f: line %l\, col %c\, %tarning - %m,'.
+        \ '%f: line %l\, col %c\, %m,'
+
+    return SyntasticMake({
+        \ 'makeprg': makeprg,
+        \ 'errorformat': errorformat,
+        \ 'defaults': {'bufnr': bufnr("")} })
+
+endfunction
+
+call g:SyntasticRegistry.CreateAndRegisterChecker({
+    \ 'filetype': 'css',
+    \ 'name': 'csslint'})
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/config/.vim/syntax_checkers/css/phpcs.vim	Wed Nov 06 14:33:18 2013 +0100
@@ -0,0 +1,33 @@
+"============================================================================
+"File:        phpcs.vim
+"Description: Syntax checking plugin for syntastic.vim
+"Maintainer:  LCD 47 <lcd047 at gmail dot com>
+"License:     This program is free software. It comes without any warranty,
+"             to the extent permitted by applicable law. You can redistribute
+"             it and/or modify it under the terms of the Do What The Fuck You
+"             Want To Public License, Version 2, as published by Sam Hocevar.
+"             See http://sam.zoy.org/wtfpl/COPYING for more details.
+"
+"============================================================================
+"
+" See here for details of phpcs
+"    - phpcs (see http://pear.php.net/package/PHP_CodeSniffer)
+"
+if exists("g:loaded_syntastic_css_phpcs_checker")
+    finish
+endif
+let g:loaded_syntastic_css_phpcs_checker=1
+
+function! SyntaxCheckers_css_phpcs_IsAvailable()
+    return SyntaxCheckers_php_phpcs_IsAvailable()
+endfunction
+
+function! SyntaxCheckers_css_phpcs_GetLocList()
+    return SyntaxCheckers_php_phpcs_GetLocList()
+endfunction
+
+call g:SyntasticRegistry.CreateAndRegisterChecker({
+    \ 'filetype': 'css',
+    \ 'name': 'phpcs'})
+
+runtime! syntax_checkers/php/*.vim
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/config/.vim/syntax_checkers/css/prettycss.vim	Wed Nov 06 14:33:18 2013 +0100
@@ -0,0 +1,62 @@
+"============================================================================
+"File:        prettycss.vim
+"Description: Syntax checking plugin for syntastic.vim
+"Maintainer:  LCD 47 <lcd047 at gmail dot com>
+"License:     This program is free software. It comes without any warranty,
+"             to the extent permitted by applicable law. You can redistribute
+"             it and/or modify it under the terms of the Do What The Fuck You
+"             Want To Public License, Version 2, as published by Sam Hocevar.
+"             See http://sam.zoy.org/wtfpl/COPYING for more details.
+"
+"============================================================================
+"
+" For details about PrettyCSS see:
+"
+"   - http://fidian.github.io/PrettyCSS/
+"   - https://github.com/fidian/PrettyCSS
+
+if exists("g:loaded_syntastic_css_prettycss_checker")
+    finish
+endif
+let g:loaded_syntastic_css_prettycss_checker=1
+
+function! SyntaxCheckers_css_prettycss_IsAvailable()
+    return executable('prettycss')
+endfunction
+
+function! SyntaxCheckers_css_prettycss_GetHighlightRegex(item)
+    let term = matchstr(a:item["text"], ' (\zs[^)]\+\ze)$')
+    if term != ''
+        let term = '\V' . term
+    endif
+    return term
+endfunction
+
+function! SyntaxCheckers_css_prettycss_GetLocList()
+    let makeprg = syntastic#makeprg#build({
+        \ 'exe': 'prettycss',
+        \ 'filetype': 'css',
+        \ 'subchecker': 'prettycss' })
+
+    " Print CSS Lint's error/warning messages from compact format. Ignores blank lines.
+    let errorformat =
+        \ '%EError:  %m\, line %l\, char %c),' .
+        \ '%WWarning:  %m\, line %l\, char %c),' .
+        \ '%-G%.%#'
+
+    let loclist = SyntasticMake({
+        \ 'makeprg': makeprg,
+        \ 'errorformat': errorformat,
+        \ 'defaults': {'bufnr': bufnr("")},
+        \ 'postprocess': ['sort'] })
+
+    for n in range(len(loclist))
+        let loclist[n]["text"] .= ')'
+    endfor
+
+    return loclist
+endfunction
+
+call g:SyntasticRegistry.CreateAndRegisterChecker({
+    \ 'filetype': 'css',
+    \ 'name': 'prettycss'})
--- a/config/.vim/syntax_checkers/cucumber.vim	Thu Sep 05 16:23:33 2013 +0200
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,27 +0,0 @@
-"============================================================================
-"File:        cucumber.vim
-"Description: Syntax checking plugin for syntastic.vim
-"Maintainer:  Martin Grenfell <martin.grenfell at gmail dot com>
-"License:     This program is free software. It comes without any warranty,
-"             to the extent permitted by applicable law. You can redistribute
-"             it and/or modify it under the terms of the Do What The Fuck You
-"             Want To Public License, Version 2, as published by Sam Hocevar.
-"             See http://sam.zoy.org/wtfpl/COPYING for more details.
-"
-"============================================================================
-if exists("loaded_cucumber_syntax_checker")
-    finish
-endif
-let loaded_cucumber_syntax_checker = 1
-
-"bail if the user doesnt have cucumber installed
-if !executable("cucumber")
-    finish
-endif
-
-function! SyntaxCheckers_cucumber_GetLocList()
-    let makeprg = 'cucumber --dry-run --quiet --strict --format pretty '.shellescape(expand('%'))
-    let errorformat =  '%f:%l:%c:%m,%W      %.%# (%m),%-Z%f:%l:%.%#,%-G%.%#'
-
-    return SyntasticMake({ 'makeprg': makeprg, 'errorformat': errorformat })
-endfunction
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/config/.vim/syntax_checkers/cucumber/cucumber.vim	Wed Nov 06 14:33:18 2013 +0100
@@ -0,0 +1,42 @@
+"============================================================================
+"File:        cucumber.vim
+"Description: Syntax checking plugin for syntastic.vim
+"Maintainer:  Martin Grenfell <martin.grenfell at gmail dot com>
+"License:     This program is free software. It comes without any warranty,
+"             to the extent permitted by applicable law. You can redistribute
+"             it and/or modify it under the terms of the Do What The Fuck You
+"             Want To Public License, Version 2, as published by Sam Hocevar.
+"             See http://sam.zoy.org/wtfpl/COPYING for more details.
+"
+"============================================================================
+
+if exists("g:loaded_syntastic_cucumber_cucumber_checker")
+    finish
+endif
+let g:loaded_syntastic_cucumber_cucumber_checker=1
+
+function! SyntaxCheckers_cucumber_cucumber_IsAvailable()
+    return executable('cucumber')
+endfunction
+
+function! SyntaxCheckers_cucumber_cucumber_GetLocList()
+    let makeprg = syntastic#makeprg#build({
+        \ 'exe': 'cucumber',
+        \ 'args': '--dry-run --quiet --strict --format pretty',
+        \ 'filetype': 'cucumber',
+        \ 'subchecker': 'cucumber' })
+
+    let errorformat =
+        \ '%f:%l:%c:%m,' .
+        \ '%W      %.%# (%m),' .
+        \ '%-Z%f:%l:%.%#,'.
+        \ '%-G%.%#'
+
+    return SyntasticMake({
+        \ 'makeprg': makeprg,
+        \ 'errorformat': errorformat })
+endfunction
+
+call g:SyntasticRegistry.CreateAndRegisterChecker({
+    \ 'filetype': 'cucumber',
+    \ 'name': 'cucumber'})
--- a/config/.vim/syntax_checkers/cuda.vim	Thu Sep 05 16:23:33 2013 +0200
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,37 +0,0 @@
-"============================================================================
-"File:        cuda.vim
-"Description: Syntax checking plugin for syntastic.vim
-"
-"Author:      Hannes Schulz <schulz at ais dot uni-bonn dot de>
-"
-"============================================================================
-
-" in order to also check header files add this to your .vimrc:
-" (this creates an empty .syntastic_dummy.cu file in your source directory)
-"
-"   let g:syntastic_cuda_check_header = 1
-
-if exists('loaded_cuda_syntax_checker')
-    finish
-endif
-let loaded_cuda_syntax_checker = 1
-
-if !executable('nvcc')
-    finish
-endif
-
-function! SyntaxCheckers_cuda_GetLocList()
-    let makeprg = 'nvcc --cuda -O0 -I . -Xcompiler -fsyntax-only '.shellescape(expand('%')).' -o /dev/null'
-    "let errorformat =  '%-G%f:%s:,%f:%l:%c: %m,%f:%l: %m'
-    let errorformat =  '%*[^"]"%f"%*\D%l: %m,"%f"%*\D%l: %m,%-G%f:%l: (Each undeclared identifier is reported only once,%-G%f:%l: for each function it appears in.),%f:%l:%c:%m,%f(%l):%m,%f:%l:%m,"%f"\, line %l%*\D%c%*[^ ] %m,%D%*\a[%*\d]: Entering directory `%f'',%X%*\a[%*\d]: Leaving directory `%f'',%D%*\a: Entering directory `%f'',%X%*\a: Leaving directory `%f'',%DMaking %*\a in %f,%f|%l| %m'
-
-    if expand('%') =~? '\%(.h\|.hpp\|.cuh\)$'
-        if exists('g:syntastic_cuda_check_header')
-            let makeprg = 'echo > .syntastic_dummy.cu ; nvcc --cuda -O0 -I . .syntastic_dummy.cu -Xcompiler -fsyntax-only -include '.shellescape(expand('%')).' -o /dev/null'
-        else
-            return []
-        endif
-    endif
-
-    return SyntasticMake({ 'makeprg': makeprg, 'errorformat': errorformat })
-endfunction
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/config/.vim/syntax_checkers/cuda/nvcc.vim	Wed Nov 06 14:33:18 2013 +0100
@@ -0,0 +1,72 @@
+"============================================================================
+"File:        cuda.vim
+"Description: Syntax checking plugin for syntastic.vim
+"
+"Author:      Hannes Schulz <schulz at ais dot uni-bonn dot de>
+"
+"============================================================================
+
+" in order to also check header files add this to your .vimrc:
+" (this creates an empty .syntastic_dummy.cu file in your source directory)
+"
+"   let g:syntastic_cuda_check_header = 1
+
+" By default, nvcc and thus syntastic, defaults to the most basic architecture.
+" This can produce false errors if the developer intends to compile for newer
+" hardware and use newer features, eg. double precision numbers. To pass a
+" specific target arch to nvcc, e.g. add the following to your .vimrc:
+"
+"   let g:syntastic_cuda_arch = "sm_20"
+
+
+if exists("g:loaded_syntastic_cuda_nvcc_checker")
+    finish
+endif
+let g:loaded_syntastic_cuda_nvcc_checker=1
+
+function! SyntaxCheckers_cuda_nvcc_IsAvailable()
+    return executable('nvcc')
+endfunction
+
+function! SyntaxCheckers_cuda_nvcc_GetLocList()
+    if exists('g:syntastic_cuda_arch')
+        let arch_flag = '-arch=' . g:syntastic_cuda_arch
+    else
+        let arch_flag = ''
+    endif
+    let makeprg =
+        \ 'nvcc ' . arch_flag . ' --cuda -O0 -I . -Xcompiler -fsyntax-only ' .
+        \ syntastic#util#shexpand('%') . ' ' . syntastic#c#GetNullDevice()
+    let errorformat =
+        \ '%*[^"]"%f"%*\D%l: %m,'.
+        \ '"%f"%*\D%l: %m,'.
+        \ '%-G%f:%l: (Each undeclared identifier is reported only once,'.
+        \ '%-G%f:%l: for each function it appears in.),'.
+        \ '%f:%l:%c:%m,'.
+        \ '%f(%l):%m,'.
+        \ '%f:%l:%m,'.
+        \ '"%f"\, line %l%*\D%c%*[^ ] %m,'.
+        \ '%D%*\a[%*\d]: Entering directory `%f'','.
+        \ '%X%*\a[%*\d]: Leaving directory `%f'','.
+        \ '%D%*\a: Entering directory `%f'','.
+        \ '%X%*\a: Leaving directory `%f'','.
+        \ '%DMaking %*\a in %f,'.
+        \ '%f|%l| %m'
+
+    if expand('%') =~? '\%(.h\|.hpp\|.cuh\)$'
+        if exists('g:syntastic_cuda_check_header')
+            let makeprg =
+                \ 'echo > .syntastic_dummy.cu ; ' .
+                \ 'nvcc ' . arch_flag . ' --cuda -O0 -I . .syntastic_dummy.cu -Xcompiler -fsyntax-only -include ' .
+                \ syntastic#util#shexpand('%') . ' ' . syntastic#c#GetNullDevice()
+        else
+            return []
+        endif
+    endif
+
+    return SyntasticMake({ 'makeprg': makeprg, 'errorformat': errorformat })
+endfunction
+
+call g:SyntasticRegistry.CreateAndRegisterChecker({
+    \ 'filetype': 'cuda',
+    \ 'name': 'nvcc'})
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/config/.vim/syntax_checkers/d/dmd.vim	Wed Nov 06 14:33:18 2013 +0100
@@ -0,0 +1,177 @@
+"============================================================================
+"File:        d.vim
+"Description: Syntax checking plugin for syntastic.vim
+"Maintainer:  Alfredo Di Napoli <alfredo dot dinapoli at gmail dot com>
+"License:     Based on the original work of Gregor Uhlenheuer and his
+"             cpp.vim checker so credits are dued.
+"             THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+"             EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+"             OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+"             NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+"             HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+"             WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+"             FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+"             OTHER DEALINGS IN THE SOFTWARE.
+"
+"============================================================================
+
+" In order to also check header files add this to your .vimrc:
+"
+"   let g:syntastic_d_check_header = 1
+"
+" To disable the search of included header files after special
+" libraries like gtk and glib add this line to your .vimrc:
+"
+"   let g:syntastic_d_no_include_search = 1
+"
+" To disable the include of the default include dirs (such as /usr/include)
+" add this line to your .vimrc:
+"
+"   let g:syntastic_d_no_default_include_dirs = 1
+"
+" To enable header files being re-checked on every file write add the
+" following line to your .vimrc. Otherwise the header files are checked only
+" one time on initially loading the file.
+" In order to force syntastic to refresh the header includes simply
+" unlet b:syntastic_d_includes. Then the header files are being re-checked
+" on the next file write.
+"
+"   let g:syntastic_d_auto_refresh_includes = 1
+"
+" Alternatively you can set the buffer local variable b:syntastic_d_cflags.
+" If this variable is set for the current buffer no search for additional
+" libraries is done. I.e. set the variable like this:
+"
+"   let b:syntastic_d_cflags = ' -I/usr/include/libsoup-2.4'
+"
+" In order to add some custom include directories that should be added to the
+" dmd command line you can add those to the global variable
+" g:syntastic_d_include_dirs. This list can be used like this:
+"
+"   let g:syntastic_d_include_dirs = [ 'includes', 'headers' ]
+"
+" Moreover it is possible to add additional compiler options to the syntax
+" checking execution via the variable 'g:syntastic_d_compiler_options':
+"
+"   let g:syntastic_d_compiler_options = ' -std=c++0x'
+"
+" Additionally the setting 'g:syntastic_d_config_file' allows you to define
+" a file that contains additional compiler arguments like include directories
+" or CFLAGS. The file is expected to contain one option per line. If none is
+" given the filename defaults to '.syntastic_d_config':
+"
+"   let g:syntastic_d_config_file = '.config'
+"
+" Using the global variable 'g:syntastic_d_remove_include_errors' you can
+" specify whether errors of files included via the
+" g:syntastic_d_include_dirs' setting are removed from the result set:
+"
+"   let g:syntastic_d_remove_include_errors = 1
+"
+" Use the variable 'g:syntastic_d_errorformat' to override the default error
+" format:
+"
+"   let g:syntastic_d_errorformat = '%f:%l:%c: %trror: %m'
+"
+" Set your compiler executable with e.g. (defaults to dmd)
+"
+"   let g:syntastic_d_compiler = 'clang++'
+
+if exists('g:loaded_syntastic_d_dmd_checker')
+    finish
+endif
+let g:loaded_syntastic_d_dmd_checker = 1
+
+if !exists('g:syntastic_d_compiler')
+    let g:syntastic_d_compiler = 'dmd'
+endif
+
+function! SyntaxCheckers_d_dmd_IsAvailable()
+    return executable(g:syntastic_d_compiler)
+endfunction
+
+let s:save_cpo = &cpo
+set cpo&vim
+
+if !exists('g:syntastic_d_compiler_options')
+    let g:syntastic_d_compiler_options = ''
+endif
+
+if !exists('g:syntastic_d_config_file')
+    let g:syntastic_d_config_file = '.syntastic_d_config'
+endif
+
+function! SyntaxCheckers_d_dmd_GetLocList()
+    let makeprg = g:syntastic_d_compiler . ' -c -of' . syntastic#util#DevNull() . ' '
+    let errorformat =  '%-G%f:%s:,%f(%l): %m,%f:%l: %m'
+
+    if exists('g:syntastic_d_errorformat')
+        let errorformat = g:syntastic_d_errorformat
+    endif
+
+    " add optional user-defined compiler options
+    let makeprg .= g:syntastic_d_compiler_options
+
+    let makeprg .= ' ' . syntastic#util#shexpand('%') .
+                \ ' ' . syntastic#c#GetIncludeDirs('d')
+
+    " determine whether to parse header files as well
+    if expand('%') =~? '\.di$'
+        if exists('g:syntastic_d_check_header')
+            let makeprg = g:syntastic_d_compiler .
+                        \ ' -c ' . syntastic#util#shexpand('%') .
+                        \ ' -of' . syntastic#util#DevNull() .
+                        \ ' ' . g:syntastic_d_compiler_options .
+                        \ ' ' . syntastic#c#GetIncludeDirs('d')
+        else
+            return []
+        endif
+    endif
+
+    " check if the user manually set some cflags
+    if !exists('b:syntastic_d_cflags')
+        " check whether to search for include files at all
+        if !exists('g:syntastic_d_no_include_search') ||
+                    \ g:syntastic_d_no_include_search != 1
+            " refresh the include file search if desired
+            if exists('g:syntastic_d_auto_refresh_includes') &&
+                        \ g:syntastic_d_auto_refresh_includes != 0
+                let makeprg .= syntastic#c#SearchHeaders()
+            else
+                " search for header includes if not cached already
+                if !exists('b:syntastic_d_includes')
+                    let b:syntastic_d_includes = syntastic#c#SearchHeaders()
+                endif
+                let makeprg .= b:syntastic_d_includes
+            endif
+        endif
+    else
+        " use the user-defined cflags
+        let makeprg .= b:syntastic_d_cflags
+    endif
+
+    " add optional config file parameters
+    let makeprg .= ' ' . syntastic#c#ReadConfig(g:syntastic_d_config_file)
+
+    " process makeprg
+    let errors = SyntasticMake({ 'makeprg': makeprg,
+                \ 'errorformat': errorformat })
+
+    " filter the processed errors if desired
+    if exists('g:syntastic_d_remove_include_errors') &&
+                \ g:syntastic_d_remove_include_errors != 0
+        return filter(errors,
+                    \ 'has_key(v:val, "bufnr") && v:val["bufnr"]=='.bufnr(''))
+    else
+        return errors
+    endif
+endfunction
+
+call g:SyntasticRegistry.CreateAndRegisterChecker({
+    \ 'filetype': 'd',
+    \ 'name': 'dmd'})
+
+let &cpo = s:save_cpo
+unlet s:save_cpo
+
+" vim: set et sts=4 sw=4:
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/config/.vim/syntax_checkers/dart/dart_analyzer.vim	Wed Nov 06 14:33:18 2013 +0100
@@ -0,0 +1,66 @@
+"============================================================================
+"File:        dart_analyzer.vim
+"Description: Dart syntax checker - using dart_analyzer
+"Maintainer:  Maksim Ryzhikov <rv.maksim at gmail dot com>
+"License:     This program is free software. It comes without any warranty,
+"             to the extent permitted by applicable law. You can redistribute
+"             it and/or modify it under the terms of the Do What The Fuck You
+"             Want To Public License, Version 2, as published by Sam Hocevar.
+"             See http://sam.zoy.org/wtfpl/COPYING for more details.
+"============================================================================
+if exists("g:loaded_syntastic_dart_dart_analyzer_checker")
+    finish
+endif
+let g:loaded_syntastic_dart_dart_analyzer_checker=1
+
+if !exists("g:syntastic_dart_analyzer_conf")
+    let g:syntastic_dart_analyzer_conf = ''
+endif
+
+function! SyntaxCheckers_dart_dart_analyzer_IsAvailable()
+    return executable("dart_analyzer")
+endfunction
+
+function! SyntaxCheckers_dart_dart_analyzer_GetHighlightRegex(error)
+    let lcol = a:error['col'] - 1
+    let rcol = a:error['nr'] + lcol + 1
+
+    return '\%>'.lcol.'c\%<'.rcol.'c'
+endfunction
+
+function! SyntaxCheckers_dart_dart_analyzer_GetLocList()
+    let args = !empty(g:syntastic_dart_analyzer_conf) ? ' ' . g:syntastic_dart_analyzer_conf : ''
+    let makeprg = syntastic#makeprg#build({
+        \ 'exe': 'dart_analyzer',
+        \ 'args': '--error_format machine',
+        \ 'post_args': args,
+        \ 'filetype': 'dart',
+        \ 'subchecker': 'dart_analyzer' })
+
+    " Machine readable format looks like:
+    " SEVERITY|TYPE|ERROR_CODE|file:FILENAME|LINE_NUMBER|COLUMN|LENGTH|MESSAGE
+    " SEVERITY: (WARNING|ERROR)
+    " TYPE: (RESOLVER|STATIC_TYPE|...)
+    " ERROR_CODE: (NO_SUCH_TYPE|...)
+    " FILENAME: String
+    " LINE_NUMBER: int
+    " COLUMN: int
+    " LENGHT: int
+    " MESSAGE: String
+
+    " We use %n to grab the error length to be able to access it in the matcher.
+    let commonformat = '|%.%#|%.%#|file:%f|%l|%c|%n|%m'
+
+    " TODO(amouravski): simply take everything after ERROR|WARNING as a message
+    " and then parse it by hand later.
+    let errorformat = '%EERROR'.l:commonformat.','.
+        \'%WWARNING'.l:commonformat
+
+    return SyntasticMake({
+        \ 'makeprg': makeprg,
+        \ 'errorformat': errorformat })
+endfunction
+
+call g:SyntasticRegistry.CreateAndRegisterChecker({
+    \ 'filetype': 'dart',
+    \ 'name': 'dart_analyzer'})
--- a/config/.vim/syntax_checkers/docbk.vim	Thu Sep 05 16:23:33 2013 +0200
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,29 +0,0 @@
-"============================================================================
-"File:        docbk.vim
-"Description: Syntax checking plugin for syntastic.vim
-"Maintainer:  Martin Grenfell <martin.grenfell at gmail dot com>
-"License:     This program is free software. It comes without any warranty,
-"             to the extent permitted by applicable law. You can redistribute
-"             it and/or modify it under the terms of the Do What The Fuck You
-"             Want To Public License, Version 2, as published by Sam Hocevar.
-"             See http://sam.zoy.org/wtfpl/COPYING for more details.
-"
-"============================================================================
-if exists("loaded_docbk_syntax_checker")
-    finish
-endif
-let loaded_docbk_syntax_checker = 1
-
-"bail if the user doesnt have tidy or grep installed
-if !executable("xmllint")
-    finish
-endif
-
-function! SyntaxCheckers_docbk_GetLocList()
-
-    let makeprg="xmllint --xinclude --noout --postvalid ".shellescape(expand(%:p))
-    let errorformat='%E%f:%l: parser error : %m,%W%f:%l: parser warning : %m,%E%f:%l:%.%# validity error : %m,%W%f:%l:%.%# validity warning : %m,%-Z%p^,%-C%.%#,%-G%.%#'
-    let loclist = SyntasticMake({ 'makeprg': makeprg, 'errorformat': errorformat })
-
-    return loclist
-endfunction
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/config/.vim/syntax_checkers/docbk/xmllint.vim	Wed Nov 06 14:33:18 2013 +0100
@@ -0,0 +1,30 @@
+"============================================================================
+"File:        docbk.vim
+"Description: Syntax checking plugin for syntastic.vim
+"Maintainer:  Martin Grenfell <martin.grenfell at gmail dot com>
+"License:     This program is free software. It comes without any warranty,
+"             to the extent permitted by applicable law. You can redistribute
+"             it and/or modify it under the terms of the Do What The Fuck You
+"             Want To Public License, Version 2, as published by Sam Hocevar.
+"             See http://sam.zoy.org/wtfpl/COPYING for more details.
+"
+"============================================================================
+
+if exists("g:loaded_syntastic_docbk_xmllint_checker")
+    finish
+endif
+let g:loaded_syntastic_docbk_xmllint_checker=1
+
+function! SyntaxCheckers_docbk_xmllint_IsAvailable()
+    return SyntaxCheckers_xml_xmllint_IsAvailable()
+endfunction
+
+function! SyntaxCheckers_docbk_xmllint_GetLocList()
+    return SyntaxCheckers_xml_xmllint_GetLocList()
+endfunction
+
+call g:SyntasticRegistry.CreateAndRegisterChecker({
+    \ 'filetype': 'docbk',
+    \ 'name': 'xmllint'})
+
+runtime! syntax_checkers/xml/*.vim
--- a/config/.vim/syntax_checkers/efm_perl.pl	Thu Sep 05 16:23:33 2013 +0200
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,153 +0,0 @@
-#!/usr/bin/perl -w
-
-# vimparse.pl - Reformats the error messages of the Perl interpreter for use
-# with the quickfix mode of Vim
-#
-# Copyright (©) 2001 by Jörg Ziefle <joerg.ziefle@gmx.de>
-# You may use and distribute this software under the same terms as Perl itself.
-#
-# Usage: put one of the two configurations below in your ~/.vimrc (without the
-# description and '# ') and enjoy (be sure to adjust the paths to vimparse.pl
-# before):
-#
-# Program is run interactively with 'perl -w':
-#
-# set makeprg=$HOME/bin/vimparse.pl\ %\ $*
-# set errorformat=%f:%l:%m
-#
-# Program is only compiled with 'perl -wc':
-#
-# set makeprg=$HOME/bin/vimparse.pl\ -c\ %\ $*
-# set errorformat=%f:%l:%m
-#
-# Usage:
-#	vimparse.pl [-c] [-f <errorfile>] <programfile> [programargs]
-#
-#		-c	compile only, don't run (perl -wc)
-#		-f	write errors to <errorfile>
-#
-# Example usages:
-#	* From the command line:
-#		vimparse.pl program.pl
-#
-#		vimparse.pl -c -f errorfile program.pl
-#		Then run vim -q errorfile to edit the errors with Vim.
-#
-#	* From Vim:
-#		Edit in Vim (and save, if you don't have autowrite on), then
-#		type ':mak' or ':mak args' (args being the program arguments)
-#		to error check.
-#
-# Version history:
-#	0.2 (04/12/2001):
-#		* First public version (sent to Bram)
-#		* -c command line option for compiling only
-#		* grammatical fix: 'There was 1 error.'
-#		* bug fix for multiple arguments
-#		* more error checks
-#		* documentation (top of file, &usage)
-#		* minor code clean ups
-#	0.1 (02/02/2001):
-#		* Initial version
-#		* Basic functionality
-#
-# Todo:
-#	* test on more systems
-#	* use portable way to determine the location of perl ('use Config')
-#	* include option that shows perldiag messages for each error
-#	* allow to pass in program by STDIN
-#	* more intuitive behaviour if no error is found (show message)
-#
-# Tested under SunOS 5.7 with Perl 5.6.0.  Let me know if it's not working for
-# you.
-
-use strict;
-use Getopt::Std;
-
-use vars qw/$opt_c $opt_f $opt_h/; # needed for Getopt in combination with use strict 'vars'
-
-use constant VERSION => 0.2;
-
-getopts('cf:h');
-
-&usage if $opt_h; # not necessarily needed, but good for further extension
-
-if (defined $opt_f) {
-
-    open FILE, "> $opt_f" or do {
-	warn "Couldn't open $opt_f: $!.  Using STDOUT instead.\n";
-	undef $opt_f;
-    };
-
-};
-
-my $handle = (defined $opt_f ? \*FILE : \*STDOUT);
-
-(my $file = shift) or &usage; # display usage if no filename is supplied
-my $args = (@ARGV ? ' ' . join ' ', @ARGV : '');
-
-my @lines = `perl @{[defined $opt_c ? '-c ' : '' ]} -w "$file$args" 2>&1`;
-
-my $errors = 0;
-foreach my $line (@lines) {
-
-    chomp($line);
-    my ($file, $lineno, $message, $rest);
-
-    if ($line =~ /^(.*)\sat\s(.*)\sline\s(\d+)(\.|,\snear\s\".*\")$/) {
-
-	($message, $file, $lineno, $rest) = ($1, $2, $3, $4);
-	$errors++;
-	$message .= $rest if ($rest =~ s/^,//);
-	print $handle "$file:$lineno:$message\n";
-
-    } else { next };
-
-}
-
-if (defined $opt_f) {
-
-    my $msg;
-    if ($errors == 1) {
-
-	$msg = "There was 1 error.\n";
-
-    } else {
-
-	$msg = "There were $errors errors.\n";
-
-    };
-
-    print STDOUT $msg;
-    close FILE;
-    unlink $opt_f unless $errors;
-
-};
-
-sub usage {
-
-    (local $0 = $0) =~ s/^.*\/([^\/]+)$/$1/; # remove path from name of program
-    print<<EOT;
-Usage:
-	$0 [-c] [-f <errorfile>] <programfile> [programargs]
-
-		-c	compile only, don't run (executes 'perl -wc')
-		-f	write errors to <errorfile>
-
-Examples:
-	* At the command line:
-		$0 program.pl
-		Displays output on STDOUT.
-
-		$0 -c -f errorfile program.pl
-		Then run 'vim -q errorfile' to edit the errors with Vim.
-
-	* In Vim:
-		Edit in Vim (and save, if you don't have autowrite on), then
-		type ':mak' or ':mak args' (args being the program arguments)
-		to error check.
-EOT
-
-    exit 0;
-
-};
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/config/.vim/syntax_checkers/elixir/elixir.vim	Wed Nov 06 14:33:18 2013 +0100
@@ -0,0 +1,45 @@
+"============================================================================
+"File:        elixir.vim
+"Description: Syntax checking plugin for syntastic.vim
+"Maintainer:  Richard Ramsden <rramsden at gmail dot com>
+"License:     This program is free software. It comes without any warranty,
+"             to the extent permitted by applicable law. You can redistribute
+"             it and/or modify it under the terms of the Do What The Fuck You
+"             Want To Public License, Version 2, as published by Sam Hocevar.
+"             See http://sam.zoy.org/wtfpl/COPYING for more details.
+"
+"============================================================================
+if exists("g:loaded_syntastic_elixir_elixir_checker")
+    finish
+endif
+let g:loaded_syntastic_elixir_elixir_checker=1
+
+" TODO: we should probably split this into separate checkers
+function! SyntaxCheckers_elixir_elixir_IsAvailable()
+    return executable('elixir') && executable('mix')
+endfunction
+
+function! SyntaxCheckers_elixir_elixir_GetLocList()
+
+    let make_options = {}
+    let compile_command = 'elixir'
+    let mix_file = syntastic#util#findInParent('mix.exs', expand('%:p:h'))
+
+    if filereadable(mix_file)
+        let compile_command = 'mix compile'
+        let make_options['cwd'] = fnamemodify(mix_file, ':p:h')
+    endif
+
+    let make_options['makeprg'] = syntastic#makeprg#build({
+        \ 'exe': compile_command,
+        \ 'filetype': 'elixir',
+        \ 'subchecker': 'elixir' })
+
+    let make_options['errorformat'] = '** %*[^\ ] %f:%l: %m'
+
+    return SyntasticMake(make_options)
+endfunction
+
+call g:SyntasticRegistry.CreateAndRegisterChecker({
+    \ 'filetype': 'elixir',
+    \ 'name': 'elixir'})
--- a/config/.vim/syntax_checkers/erlang.vim	Thu Sep 05 16:23:33 2013 +0200
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,42 +0,0 @@
-"============================================================================
-"File:        erlang.vim
-"Description: Syntax checking plugin for syntastic.vim
-"Maintainer:  Pawel Salata <rockplayer.pl at gmail dot com>
-"License:     This program is free software. It comes without any warranty,
-"             to the extent permitted by applicable law. You can redistribute
-"             it and/or modify it under the terms of the Do What The Fuck You
-"             Want To Public License, Version 2, as published by Sam Hocevar.
-"             See http://sam.zoy.org/wtfpl/COPYING for more details.
-"
-"============================================================================
-if exists("loaded_erlang_syntax_checker")
-    finish
-endif
-let loaded_erlang_syntax_checker = 1
-
-"bail if the user doesnt have escript installed
-if !executable("escript")
-    finish
-endif
-
-let s:check_file = expand('<sfile>:p:h') . '/erlang_check_file.erl'
-
-function! SyntaxCheckers_erlang_GetLocList()
-    let extension = expand('%:e')
-    if match(extension, 'hrl') >= 0
-        return []
-    endif
-    let shebang = getbufline(bufnr('%'), 1)[0]
-    if len(shebang) > 0
-        if match(shebang, 'escript') >= 0
-            let makeprg = 'escript -s '.shellescape(expand('%:p'))
-        else
-            let makeprg = s:check_file . ' '. shellescape(expand('%:p'))
-        endif
-    else
-        let makeprg =  s:check_file . ' ' . shellescape(expand('%:p'))
-    endif
-    let errorformat = '%f:%l:\ %tarning:\ %m,%E%f:%l:\ %m'
-
-    return SyntasticMake({ 'makeprg': makeprg, 'errorformat': errorformat })
-endfunction
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/config/.vim/syntax_checkers/erlang/erlang.vim	Wed Nov 06 14:33:18 2013 +0100
@@ -0,0 +1,51 @@
+"============================================================================
+"File:        erlang.vim
+"Description: Syntax checking plugin for syntastic.vim
+"Maintainer:  Pawel Salata <rockplayer.pl at gmail dot com>
+"License:     This program is free software. It comes without any warranty,
+"             to the extent permitted by applicable law. You can redistribute
+"             it and/or modify it under the terms of the Do What The Fuck You
+"             Want To Public License, Version 2, as published by Sam Hocevar.
+"             See http://sam.zoy.org/wtfpl/COPYING for more details.
+"
+"============================================================================
+
+if exists("g:loaded_syntastic_erlang_erlang_checker")
+    finish
+endif
+let g:loaded_syntastic_erlang_erlang_checker=1
+
+let s:check_file = expand('<sfile>:p:h') . '/erlang_check_file.erl'
+if !exists("g:syntastic_erlc_include_path")
+    let g:syntastic_erlc_include_path=""
+endif
+
+function! SyntaxCheckers_erlang_escript_IsAvailable()
+    return executable('escript')
+endfunction
+
+function! SyntaxCheckers_erlang_escript_GetLocList()
+    let extension = expand('%:e')
+    if match(extension, 'hrl') >= 0
+        return []
+    endif
+    let shebang = getbufline(bufnr('%'), 1)[0]
+    if len(shebang) > 0
+        if match(shebang, 'escript') >= 0
+            let makeprg = 'escript -s ' . syntastic#util#shexpand('%:p')
+        else
+            let makeprg = 'escript ' . s:check_file . ' ' . syntastic#util#shexpand('%:p') . ' ' . g:syntastic_erlc_include_path
+        endif
+    else
+        let makeprg =  'escript ' . s:check_file . ' ' . syntastic#util#shexpand('%:p') . ' '. g:syntastic_erlc_include_path
+    endif
+    let errorformat =
+        \ '%f:%l:\ %tarning:\ %m,'.
+        \ '%E%f:%l:\ %m'
+
+    return SyntasticMake({ 'makeprg': makeprg, 'errorformat': errorformat })
+endfunction
+
+call g:SyntasticRegistry.CreateAndRegisterChecker({
+    \ 'filetype': 'erlang',
+    \ 'name': 'escript'})
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/config/.vim/syntax_checkers/erlang/erlang_check_file.erl	Wed Nov 06 14:33:18 2013 +0100
@@ -0,0 +1,34 @@
+#!/usr/bin/env escript
+-export([main/1]).
+
+main([FileName]) ->
+    LibDirs = filelib:wildcard("{lib,deps}/*/ebin"),
+    compile(FileName, LibDirs);
+main([FileName | LibDirs]) ->
+    compile(FileName, LibDirs).
+
+compile(FileName, LibDirs) ->
+    Root = get_root(filename:dirname(FileName)),
+    ok = code:add_pathsa(LibDirs),
+    compile:file(FileName, [warn_obsolete_guard,
+                            warn_unused_import,
+                            warn_shadow_vars,
+                            warn_export_vars,
+                            strong_validation,
+                            report,
+                            {i, filename:join(Root, "include")},
+                            {i, filename:join(Root, "deps")},
+                            {i, filename:join(Root, "apps")},
+                            {i, filename:join(Root, "lib")}
+                        ]).
+
+get_root(Dir) ->
+    Path = filename:split(filename:absname(Dir)),
+    filename:join(get_root(lists:reverse(Path), Path)).
+
+get_root([], Path) ->
+    Path;
+get_root(["src" | Tail], _Path) ->
+    lists:reverse(Tail);
+get_root([_ | Tail], Path) ->
+    get_root(Tail, Path).
--- a/config/.vim/syntax_checkers/erlang_check_file.erl	Thu Sep 05 16:23:33 2013 +0200
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,12 +0,0 @@
-#!/usr/bin/env escript
--export([main/1]).
-
-main([FileName]) ->
-    compile:file(FileName, [warn_obsolete_guard,
-                            warn_unused_import,
-                            warn_shadow_vars,
-                            warn_export_vars,
-                            strong_validation,
-                            report,
-                            {i, filename:dirname(FileName) ++ "/../include"}
-                        ]).
--- a/config/.vim/syntax_checkers/eruby.vim	Thu Sep 05 16:23:33 2013 +0200
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,34 +0,0 @@
-"============================================================================
-"File:        eruby.vim
-"Description: Syntax checking plugin for syntastic.vim
-"Maintainer:  Martin Grenfell <martin.grenfell at gmail dot com>
-"License:     This program is free software. It comes without any warranty,
-"             to the extent permitted by applicable law. You can redistribute
-"             it and/or modify it under the terms of the Do What The Fuck You
-"             Want To Public License, Version 2, as published by Sam Hocevar.
-"             See http://sam.zoy.org/wtfpl/COPYING for more details.
-"
-"============================================================================
-if exists("loaded_eruby_syntax_checker")
-    finish
-endif
-let loaded_eruby_syntax_checker = 1
-
-"bail if the user doesnt have ruby or cat installed
-if !executable("ruby") || !executable("cat")
-    finish
-endif
-
-function! SyntaxCheckers_eruby_GetLocList()
-    if has('win32') || has('win64')
-        let makeprg='sed "s/<\%=/<\%/g" '. shellescape(expand("%")) . ' \| ruby -e "require \"erb\"; puts ERB.new(ARGF.read, nil, \"-\").src" \| ruby -c'
-    else
-        let makeprg='sed "s/<\%=/<\%/g" '. shellescape(expand("%")) . ' \| RUBYOPT= ruby -e "require \"erb\"; puts ERB.new(ARGF.read, nil, \"-\").src" \| RUBYOPT= ruby -c'
-    endif
-
-    let errorformat='%-GSyntax OK,%E-:%l: syntax error\, %m,%Z%p^,%W-:%l: warning: %m,%Z%p^,%-C%.%#'
-    return SyntasticMake({ 'makeprg': makeprg,
-                         \ 'errorformat': errorformat,
-                         \ 'defaults': {'bufnr': bufnr("")} })
-
-endfunction
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/config/.vim/syntax_checkers/eruby/ruby.vim	Wed Nov 06 14:33:18 2013 +0100
@@ -0,0 +1,65 @@
+"============================================================================
+"File:        ruby.vim
+"Description: Syntax checking plugin for syntastic.vim
+"Maintainer:  Martin Grenfell <martin.grenfell at gmail dot com>
+"License:     This program is free software. It comes without any warranty,
+"             to the extent permitted by applicable law. You can redistribute
+"             it and/or modify it under the terms of the Do What The Fuck You
+"             Want To Public License, Version 2, as published by Sam Hocevar.
+"             See http://sam.zoy.org/wtfpl/COPYING for more details.
+"
+"============================================================================
+
+if exists("g:loaded_syntastic_eruby_ruby_checker")
+    finish
+endif
+let g:loaded_syntastic_eruby_ruby_checker=1
+
+if !exists("g:syntastic_ruby_exec")
+    let g:syntastic_ruby_exec = "ruby"
+endif
+
+function! SyntaxCheckers_eruby_ruby_IsAvailable()
+    return executable(expand(g:syntastic_ruby_exec))
+endfunction
+
+function! SyntaxCheckers_eruby_ruby_GetLocList()
+    let exe = expand(g:syntastic_ruby_exec)
+    if !has('win32')
+        let exe = 'RUBYOPT= ' . exe
+    endif
+
+    let fname = "'" . escape(expand('%'), "\\'") . "'"
+
+    " TODO: encodings became useful in ruby 1.9 :)
+    if syntastic#util#versionIsAtLeast(syntastic#util#parseVersion('ruby --version'), [1, 9])
+        let enc = &fileencoding != '' ? &fileencoding : &encoding
+        let encoding_spec = ', :encoding => "' . (enc ==? 'utf-8' ? 'UTF-8' : 'BINARY') . '"'
+    else
+        let encoding_spec = ''
+    endif
+
+    "gsub fixes issue #7, rails has it's own eruby syntax
+    let makeprg =
+        \ exe . ' -rerb -e ' .
+        \ syntastic#util#shescape('puts ERB.new(File.read(' .
+        \     fname . encoding_spec .
+        \     ').gsub(''<%='',''<%''), nil, ''-'').src') .
+        \ ' | ' . exe . ' -c'
+
+    let errorformat =
+        \ '%-GSyntax OK,'.
+        \ '%E-:%l: syntax error\, %m,%Z%p^,'.
+        \ '%W-:%l: warning: %m,'.
+        \ '%Z%p^,'.
+        \ '%-C%.%#'
+
+    return SyntasticMake({
+        \ 'makeprg': makeprg,
+        \ 'errorformat': errorformat,
+        \ 'defaults': { 'bufnr': bufnr(""), 'vcol': 1 } })
+endfunction
+
+call g:SyntasticRegistry.CreateAndRegisterChecker({
+    \ 'filetype': 'eruby',
+    \ 'name': 'ruby'})
--- a/config/.vim/syntax_checkers/fortran.vim	Thu Sep 05 16:23:33 2013 +0200
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,44 +0,0 @@
-"============================================================================
-"File:        fortran.vim
-"Description: Syntax checking plugin for syntastic.vim
-"Maintainer:  Karl Yngve Lervåg <karl.yngve@lervag.net>
-"License:     This program is free software. It comes without any warranty,
-"             to the extent permitted by applicable law. You can redistribute
-"             it and/or modify it under the terms of the Do What The Fuck You
-"             Want To Public License, Version 2, as published by Sam Hocevar.
-"             See http://sam.zoy.org/wtfpl/COPYING for more details.
-"Note:        This syntax checker uses gfortran with the option -fsyntax-only
-"             to check for errors and warnings. Additional flags may be
-"             supplied through both local and global variables,
-"               b:syntastic_fortran_flags,
-"               g:syntastic_fortran_flags.
-"             This is particularly useful when the source requires module files
-"             in order to compile (that is when it needs modules defined in
-"             separate files).
-"
-"============================================================================
-
-if exists("loaded_fortran_syntax_checker")
-    finish
-endif
-let loaded_fortran_syntax_checker = 1
-
-"bail if the user doesnt have fortran installed
-if !executable("gfortran")
-    finish
-endif
-
-if !exists('g:syntastic_fortran_flags')
-    let g:syntastic_fortran_flags = ''
-endif
-
-function! SyntaxCheckers_fortran_GetLocList()
-    let makeprg  = 'gfortran -fsyntax-only'
-    let makeprg .= g:syntastic_fortran_flags
-    if exists('b:syntastic_fortran_flags')
-        let makeprg .= b:syntastic_fortran_flags
-    endif
-    let makeprg .= ' ' . shellescape(expand('%'))
-    let errorformat = '%-C %#,%-C  %#%.%#,%A%f:%l.%c:,%Z%m,%G%.%#'
-    return SyntasticMake({ 'makeprg': makeprg, 'errorformat': errorformat })
-endfunction
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/config/.vim/syntax_checkers/fortran/gfortran.vim	Wed Nov 06 14:33:18 2013 +0100
@@ -0,0 +1,63 @@
+"============================================================================
+"File:        fortran.vim
+"Description: Syntax checking plugin for syntastic.vim
+"Maintainer:  Karl Yngve Lervåg <karl.yngve@lervag.net>
+"License:     This program is free software. It comes without any warranty,
+"             to the extent permitted by applicable law. You can redistribute
+"             it and/or modify it under the terms of the Do What The Fuck You
+"             Want To Public License, Version 2, as published by Sam Hocevar.
+"             See http://sam.zoy.org/wtfpl/COPYING for more details.
+"Note:        This syntax checker uses gfortran with the option -fsyntax-only
+"             to check for errors and warnings. Additional flags may be
+"             supplied through both local and global variables,
+"               b:syntastic_fortran_flags,
+"               g:syntastic_fortran_flags.
+"             This is particularly useful when the source requires module files
+"             in order to compile (that is when it needs modules defined in
+"             separate files).
+"
+"============================================================================
+
+if exists("g:loaded_syntastic_fortran_gfortran_checker")
+    finish
+endif
+let g:loaded_syntastic_fortran_gfortran_checker=1
+
+if !exists('g:syntastic_fortran_flags')
+    let g:syntastic_fortran_flags = ''
+endif
+
+function! SyntaxCheckers_fortran_gfortran_IsAvailable()
+    return executable('gfortran')
+endfunction
+
+function! SyntaxCheckers_fortran_gfortran_GetLocList()
+    let makeprg = syntastic#makeprg#build({
+        \ 'exe': 'gfortran',
+        \ 'args': s:args(),
+        \ 'filetype': 'fortran',
+        \ 'subchecker': 'gfortran' })
+
+    let errorformat =
+        \ '%-C %#,'.
+        \ '%-C  %#%.%#,'.
+        \ '%A%f:%l.%c:,'.
+        \ '%Z%m,'.
+        \ '%G%.%#'
+
+    return SyntasticMake({
+        \ 'makeprg': makeprg,
+        \ 'errorformat': errorformat })
+endfunction
+
+function s:args()
+    let rv  = '-fsyntax-only ' . g:syntastic_fortran_flags
+    if exists('b:syntastic_fortran_flags')
+        let rv .= " " . b:syntastic_fortran_flags
+    endif
+    return rv
+endfunction
+
+call g:SyntasticRegistry.CreateAndRegisterChecker({
+    \ 'filetype': 'fortran',
+    \ 'name': 'gfortran'})
--- a/config/.vim/syntax_checkers/gentoo_metadata.vim	Thu Sep 05 16:23:33 2013 +0200
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,37 +0,0 @@
-"============================================================================
-"File:        gentoo-metadata.vim
-"Description: Syntax checking plugin for Gentoo's metadata.xml files
-"Maintainer:  James Rowe <jnrowe at gmail dot com>
-"License:     This program is free software. It comes without any warranty,
-"             to the extent permitted by applicable law. You can redistribute
-"             it and/or modify it under the terms of the Do What The Fuck You
-"             Want To Public License, Version 2, as published by Sam Hocevar.
-"             See http://sam.zoy.org/wtfpl/COPYING for more details.
-"
-"============================================================================
-
-" 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(1) and http://www.xmlsoft.org/catalog.html for more
-" information.
-
-if exists("loaded_gentoo_metadata_syntax_checker")
-    finish
-endif
-let loaded_gentoo_metadata_syntax_checker = 1
-
-"bail if the user doesn't have xmllint installed
-if !executable("xmllint")
-    finish
-endif
-
-runtime syntax_checkers/xml.vim
-
-function! SyntaxCheckers_gentoo_metadata_GetLocList()
-    return SyntaxCheckers_xml_GetLocList()
-endfunction
--- a/config/.vim/syntax_checkers/go.vim	Thu Sep 05 16:23:33 2013 +0200
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,22 +0,0 @@
-"============================================================================
-"File:        go.vim
-"Description: Loads a go syntax checker from the go directory
-"Maintainer:  Martin Grenfell <martin.grenfell at gmail dot com>
-"License:     This program is free software. It comes without any warranty,
-"             to the extent permitted by applicable law. You can redistribute
-"             it and/or modify it under the terms of the Do What The Fuck You
-"             Want To Public License, Version 2, as published by Sam Hocevar.
-"             See http://sam.zoy.org/wtfpl/COPYING for more details.
-"
-" Use g:syntastic_go_checker option to specify which go executable
-" should be used (see below for a list of supported checkers).
-" If g:syntastic_go_checker is not set, just use the first syntax
-" checker that we find installed.
-"============================================================================
-if exists("loaded_go_syntax_checker")
-    finish
-endif
-let loaded_go_syntax_checker = 1
-
-let s:supported_checkers = ["6g", "gofmt"]
-call SyntasticLoadChecker(s:supported_checkers)
--- a/config/.vim/syntax_checkers/go/6g.vim	Thu Sep 05 16:23:33 2013 +0200
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,17 +0,0 @@
-"============================================================================
-"File:        6g.vim
-"Description: Syntax checking plugin for syntastic.vim
-"Maintainer:  Sam Nguyen <samxnguyen@gmail.com>
-"License:     This program is free software. It comes without any warranty,
-"             to the extent permitted by applicable law. You can redistribute
-"             it and/or modify it under the terms of the Do What The Fuck You
-"             Want To Public License, Version 2, as published by Sam Hocevar.
-"             See http://sam.zoy.org/wtfpl/COPYING for more details.
-"
-"============================================================================
-function! SyntaxCheckers_go_GetLocList()
-    let makeprg = '6g -o /dev/null %'
-    let errorformat = '%E%f:%l: %m'
-
-    return SyntasticMake({ 'makeprg': makeprg, 'errorformat': errorformat })
-endfunction
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/config/.vim/syntax_checkers/go/go.vim	Wed Nov 06 14:33:18 2013 +0100
@@ -0,0 +1,75 @@
+"============================================================================
+"File:        go.vim
+"Description: Check go syntax using 'gofmt -l' followed by 'go [build|test]'
+"Maintainer:  Kamil Kisiel <kamil@kamilkisiel.net>
+"License:     This program is free software. It comes without any warranty,
+"             to the extent permitted by applicable law. You can redistribute
+"             it and/or modify it under the terms of the Do What The Fuck You
+"             Want To Public License, Version 2, as published by Sam Hocevar.
+"             See http://sam.zoy.org/wtfpl/COPYING for more details.
+"
+" This syntax checker does not reformat your source code.
+" Use a BufWritePre autocommand to that end:
+"   autocmd FileType go autocmd BufWritePre <buffer> Fmt
+"============================================================================
+if exists("g:loaded_syntastic_go_go_checker")
+    finish
+endif
+let g:loaded_syntastic_go_go_checker=1
+
+function! SyntaxCheckers_go_go_IsAvailable()
+    return executable('go')
+endfunction
+
+function! SyntaxCheckers_go_go_GetLocList()
+    " Check with gofmt first, since `go build` and `go test` might not report
+    " syntax errors in the current file if another file with syntax error is
+    " compiled first.
+    let makeprg = syntastic#makeprg#build({
+        \ 'exe': 'gofmt',
+        \ 'args': '-l',
+        \ 'tail': '1>' . syntastic#util#DevNull(),
+        \ 'filetype': 'go',
+        \ 'subchecker': 'go' })
+
+    let errorformat =
+        \ '%f:%l:%c: %m,' .
+        \ '%-G%.%#'
+
+    let errors = SyntasticMake({
+        \ 'makeprg': makeprg,
+        \ 'errorformat': errorformat,
+        \ 'defaults': {'type': 'e'} })
+    if !empty(errors)
+        return errors
+    endif
+
+    " Test files, i.e. files with a name ending in `_test.go`, are not
+    " compiled by `go build`, therefore `go test` must be called for those.
+    if match(expand('%'), '_test.go$') == -1
+        let makeprg = 'go build ' . syntastic#c#GetNullDevice()
+    else
+        let makeprg = 'go test -c ' . syntastic#c#GetNullDevice()
+    endif
+
+    let errorformat =
+        \ '%f:%l:%c:%m,' .
+        \ '%f:%l%m,' .
+        \ '%-G#%.%#'
+
+    " The go compiler needs to either be run with an import path as an
+    " argument or directly from the package directory. Since figuring out
+    " the proper import path is fickle, just cwd to the package.
+
+    let errors = SyntasticMake({
+        \ 'makeprg': makeprg,
+        \ 'errorformat': errorformat,
+        \ 'cwd': expand('%:p:h'),
+        \ 'defaults': {'type': 'e'} })
+
+    return errors
+endfunction
+
+call g:SyntasticRegistry.CreateAndRegisterChecker({
+    \ 'filetype': 'go',
+    \ 'name': 'go'})
--- a/config/.vim/syntax_checkers/go/gofmt.vim	Thu Sep 05 16:23:33 2013 +0200
+++ b/config/.vim/syntax_checkers/go/gofmt.vim	Wed Nov 06 14:33:18 2013 +0100
@@ -1,6 +1,6 @@
 "============================================================================
 "File:        gofmt.vim
-"Description: Check go syntax using gofmt
+"Description: Check go syntax using 'gofmt -l'
 "Maintainer:  Brandon Thomson <bt@brandonthomson.com>
 "License:     This program is free software. It comes without any warranty,
 "             to the extent permitted by applicable law. You can redistribute
@@ -8,9 +8,35 @@
 "             Want To Public License, Version 2, as published by Sam Hocevar.
 "             See http://sam.zoy.org/wtfpl/COPYING for more details.
 "
+" This syntax checker does not reformat your source code.
+" Use a BufWritePre autocommand to that end:
+"   autocmd FileType go autocmd BufWritePre <buffer> Fmt
 "============================================================================
-function! SyntaxCheckers_go_GetLocList()
-    let makeprg = 'gofmt %'
+if exists("g:loaded_syntastic_go_gofmt_checker")
+    finish
+endif
+let g:loaded_syntastic_go_gofmt_checker=1
+
+function! SyntaxCheckers_go_gofmt_IsAvailable()
+    return executable('gofmt')
+endfunction
+
+function! SyntaxCheckers_go_gofmt_GetLocList()
+    let makeprg = syntastic#makeprg#build({
+        \ 'exe': 'gofmt',
+        \ 'args': '-l',
+        \ 'tail': '1>' . syntastic#util#DevNull(),
+        \ 'filetype': 'go',
+        \ 'subchecker': 'gofmt' })
+
     let errorformat = '%f:%l:%c: %m,%-G%.%#'
-    return SyntasticMake({ 'makeprg': makeprg, 'errorformat': errorformat, 'defaults': {'type': 'e'} })
+
+    return SyntasticMake({
+        \ 'makeprg': makeprg,
+        \ 'errorformat': errorformat,
+        \ 'defaults': {'type': 'e'} })
 endfunction
+
+call g:SyntasticRegistry.CreateAndRegisterChecker({
+    \ 'filetype': 'go',
+    \ 'name': 'gofmt'})
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/config/.vim/syntax_checkers/go/golint.vim	Wed Nov 06 14:33:18 2013 +0100
@@ -0,0 +1,37 @@
+"============================================================================
+"File:        golint.vim
+"Description: Check go syntax using 'golint'
+"Maintainer:  Hiroshi Ioka <hirochachacha@gmail.com>
+"License:     This program is free software. It comes without any warranty,
+"             to the extent permitted by applicable law. You can redistribute
+"             it and/or modify it under the terms of the Do What The Fuck You
+"             Want To Public License, Version 2, as published by Sam Hocevar.
+"             See http://sam.zoy.org/wtfpl/COPYING for more details.
+"
+"============================================================================
+if exists("g:loaded_syntastic_go_golint_checker")
+    finish
+endif
+let g:loaded_syntastic_go_golint_checker=1
+
+function! SyntaxCheckers_go_golint_IsAvailable()
+    return executable('golint')
+endfunction
+
+function! SyntaxCheckers_go_golint_GetLocList()
+    let makeprg = syntastic#makeprg#build({
+        \ 'exe': 'golint',
+        \ 'filetype': 'go',
+        \ 'subchecker': 'golint' })
+
+    let errorformat = '%f:%l:%c: %m,%-G%.%#'
+
+    return SyntasticMake({
+        \ 'makeprg': makeprg,
+        \ 'errorformat': errorformat,
+        \ 'subtype': 'Style' })
+endfunction
+
+call g:SyntasticRegistry.CreateAndRegisterChecker({
+    \ 'filetype': 'go',
+    \ 'name': 'golint'})
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/config/.vim/syntax_checkers/go/govet.vim	Wed Nov 06 14:33:18 2013 +0100
@@ -0,0 +1,40 @@
+"============================================================================
+"File:        govet.vim
+"Description: Perform static analysis of Go code with the vet tool
+"Maintainer:  Kamil Kisiel <kamil@kamilkisiel.net>
+"License:     This program is free software. It comes without any warranty,
+"             to the extent permitted by applicable law. You can redistribute
+"             it and/or modify it under the terms of the Do What The Fuck You
+"             Want To Public License, Version 2, as published by Sam Hocevar.
+"             See http://sam.zoy.org/wtfpl/COPYING for more details.
+"
+"============================================================================
+if exists("g:loaded_syntastic_go_govet_checker")
+    finish
+endif
+let g:loaded_syntastic_go_govet_checker=1
+
+function! SyntaxCheckers_go_govet_IsAvailable()
+    return executable('go')
+endfunction
+
+function! SyntaxCheckers_go_govet_GetLocList()
+    let makeprg = 'go vet'
+    let errorformat = '%Evet: %.%\+: %f:%l:%c: %m,%W%f:%l: %m,%-G%.%#'
+
+    " The go compiler needs to either be run with an import path as an
+    " argument or directly from the package directory. Since figuring out
+    " the proper import path is fickle, just cwd to the package.
+
+    let errors = SyntasticMake({
+        \ 'makeprg': makeprg,
+        \ 'errorformat': errorformat,
+        \ 'cwd': expand('%:p:h'),
+        \ 'defaults': {'type': 'w'} })
+
+    return errors
+endfunction
+
+call g:SyntasticRegistry.CreateAndRegisterChecker({
+    \ 'filetype': 'go',
+    \ 'name': 'govet'})
--- a/config/.vim/syntax_checkers/haml.vim	Thu Sep 05 16:23:33 2013 +0200
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,26 +0,0 @@
-"============================================================================
-"File:        haml.vim
-"Description: Syntax checking plugin for syntastic.vim
-"Maintainer:  Martin Grenfell <martin.grenfell at gmail dot com>
-"License:     This program is free software. It comes without any warranty,
-"             to the extent permitted by applicable law. You can redistribute
-"             it and/or modify it under the terms of the Do What The Fuck You
-"             Want To Public License, Version 2, as published by Sam Hocevar.
-"             See http://sam.zoy.org/wtfpl/COPYING for more details.
-"
-"============================================================================
-if exists("loaded_haml_syntax_checker")
-    finish
-endif
-let loaded_haml_syntax_checker = 1
-
-"bail if the user doesnt have the haml binary installed
-if !executable("haml")
-    finish
-endif
-
-function! SyntaxCheckers_haml_GetLocList()
-    let makeprg = "haml -c " . shellescape(expand("%"))
-    let errorformat = 'Haml error on line %l: %m,Syntax error on line %l: %m,%-G%.%#'
-    return SyntasticMake({ 'makeprg': makeprg, 'errorformat': errorformat })
-endfunction
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/config/.vim/syntax_checkers/haml/haml.vim	Wed Nov 06 14:33:18 2013 +0100
@@ -0,0 +1,45 @@
+"============================================================================
+"File:        haml.vim
+"Description: Syntax checking plugin for syntastic.vim
+"Maintainer:  Martin Grenfell <martin.grenfell at gmail dot com>
+"License:     This program is free software. It comes without any warranty,
+"             to the extent permitted by applicable law. You can redistribute
+"             it and/or modify it under the terms of the Do What The Fuck You
+"             Want To Public License, Version 2, as published by Sam Hocevar.
+"             See http://sam.zoy.org/wtfpl/COPYING for more details.
+"
+"============================================================================
+
+if exists('g:loaded_syntastic_haml_haml_checker')
+    finish
+endif
+let g:loaded_syntastic_haml_haml_checker=1
+
+if !exists('g:syntastic_haml_interpreter')
+    let g:syntastic_haml_interpreter = 'haml'
+endif
+
+function! SyntaxCheckers_haml_haml_IsAvailable()
+    return executable(expand(g:syntastic_haml_interpreter))
+endfunction
+
+function! SyntaxCheckers_haml_haml_GetLocList()
+    let makeprg = syntastic#makeprg#build({
+        \ 'exe': expand(g:syntastic_haml_interpreter),
+        \ 'args': '-c',
+        \ 'filetype': 'haml',
+        \ 'subchecker': 'haml' })
+
+    let errorformat =
+        \ 'Haml error on line %l: %m,' .
+        \ 'Syntax error on line %l: %m,' .
+        \ '%-G%.%#'
+
+    return SyntasticMake({
+        \ 'makeprg': makeprg,
+        \ 'errorformat': errorformat })
+endfunction
+
+call g:SyntasticRegistry.CreateAndRegisterChecker({
+    \ 'filetype': 'haml',
+    \ 'name': 'haml'})
--- a/config/.vim/syntax_checkers/haskell.vim	Thu Sep 05 16:23:33 2013 +0200
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,37 +0,0 @@
-"============================================================================
-"File:        haskell.vim
-"Description: Syntax checking plugin for syntastic.vim
-"Maintainer:  Anthony Carapetis <anthony.carapetis at gmail dot com>
-"License:     This program is free software. It comes without any warranty,
-"             to the extent permitted by applicable law. You can redistribute
-"             it and/or modify it under the terms of the Do What The Fuck You
-"             Want To Public License, Version 2, as published by Sam Hocevar.
-"             See http://sam.zoy.org/wtfpl/COPYING for more details.
-"
-"============================================================================
-if exists("loaded_haskell_syntax_checker")
-    finish
-endif
-let loaded_haskell_syntax_checker = 1
-
-"bail if the user doesnt have ghc-mod installed
-if !executable("ghc-mod")
-    finish
-endif
-
-function! SyntaxCheckers_haskell_GetLocList()
-    let makeprg =
-          \ "{ ".
-          \ "ghc-mod check ". shellescape(expand('%')) . "; " .
-          \ "ghc-mod lint " . shellescape(expand('%')) . ";" .
-          \ " }"
-    let errorformat = '%-G\\s%#,%f:%l:%c:%trror: %m,%f:%l:%c:%tarning: %m,'.
-                \ '%f:%l:%c: %trror: %m,%f:%l:%c: %tarning: %m,%f:%l:%c:%m,'.
-                \ '%E%f:%l:%c:,%Z%m,'
-
-    return SyntasticMake({ 'makeprg': makeprg, 'errorformat': errorformat })
-endfunction
-
-function! SyntaxCheckers_lhaskell_GetLocList()
-    return SyntaxCheckers_haskell_GetLocList()
-endfunction
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/config/.vim/syntax_checkers/haskell/ghc-mod.vim	Wed Nov 06 14:33:18 2013 +0100
@@ -0,0 +1,46 @@
+"============================================================================
+"File:        ghc-mod.vim
+"Description: Syntax checking plugin for syntastic.vim
+"Maintainer:  Anthony Carapetis <anthony.carapetis at gmail dot com>
+"License:     This program is free software. It comes without any warranty,
+"             to the extent permitted by applicable law. You can redistribute
+"             it and/or modify it under the terms of the Do What The Fuck You
+"             Want To Public License, Version 2, as published by Sam Hocevar.
+"             See http://sam.zoy.org/wtfpl/COPYING for more details.
+"
+"============================================================================
+
+if exists('g:loaded_syntastic_haskell_ghc_mod_checker')
+    finish
+endif
+let g:loaded_syntastic_haskell_ghc_mod_checker = 1
+
+function! SyntaxCheckers_haskell_ghc_mod_IsAvailable()
+    return executable('ghc-mod')
+endfunction
+
+function! SyntaxCheckers_haskell_ghc_mod_GetLocList()
+    let makeprg = syntastic#makeprg#build({
+        \ 'exe': 'ghc-mod check',
+        \ 'filetype': 'haskell',
+        \ 'subchecker': 'ghc_mod' })
+
+    let errorformat =
+        \ '%-G%\s%#,' .
+        \ '%f:%l:%c:%trror: %m,' .
+        \ '%f:%l:%c:%tarning: %m,'.
+        \ '%f:%l:%c: %trror: %m,' .
+        \ '%f:%l:%c: %tarning: %m,' .
+        \ '%f:%l:%c:%m,' .
+        \ '%E%f:%l:%c:,' .
+        \ '%Z%m'
+
+    return SyntasticMake({
+        \ 'makeprg': makeprg,
+        \ 'errorformat': errorformat,
+        \ 'postprocess': ['compressWhitespace'] })
+endfunction
+
+call g:SyntasticRegistry.CreateAndRegisterChecker({
+    \ 'filetype': 'haskell',
+    \ 'name': 'ghc_mod'})
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/config/.vim/syntax_checkers/haskell/hdevtools.vim	Wed Nov 06 14:33:18 2013 +0100
@@ -0,0 +1,46 @@
+"============================================================================
+"File:        hdevtools.vim
+"Description: Syntax checking plugin for syntastic.vim
+"Maintainer:  Anthony Carapetis <anthony.carapetis at gmail dot com>
+"License:     This program is free software. It comes without any warranty,
+"             to the extent permitted by applicable law. You can redistribute
+"             it and/or modify it under the terms of the Do What The Fuck You
+"             Want To Public License, Version 2, as published by Sam Hocevar.
+"             See http://sam.zoy.org/wtfpl/COPYING for more details.
+"
+"============================================================================
+
+if exists("g:loaded_syntastic_haskell_hdevtools_checker")
+    finish
+endif
+let g:loaded_syntastic_haskell_hdevtools_checker=1
+
+function! SyntaxCheckers_haskell_hdevtools_IsAvailable()
+    return executable('hdevtools')
+endfunction
+
+function! SyntaxCheckers_haskell_hdevtools_GetLocList()
+    let makeprg = syntastic#makeprg#build({
+        \ 'exe': 'hdevtools check',
+        \ 'args': get(g:, 'hdevtools_options', ''),
+        \ 'filetype': 'haskell',
+        \ 'subchecker': 'hdevtools' })
+
+    let errorformat= '\%-Z\ %#,'.
+        \ '%W%f:%l:%c:\ Warning:\ %m,'.
+        \ '%E%f:%l:%c:\ %m,'.
+        \ '%E%>%f:%l:%c:,'.
+        \ '%+C\ \ %#%m,'.
+        \ '%W%>%f:%l:%c:,'.
+        \ '%+C\ \ %#%tarning:\ %m,'
+
+    return SyntasticMake({
+        \ 'makeprg': makeprg,
+        \ 'errorformat': errorformat,
+        \ 'postprocess': ['compressWhitespace'] })
+endfunction
+
+call g:SyntasticRegistry.CreateAndRegisterChecker({
+    \ 'filetype': 'haskell',
+    \ 'name': 'hdevtools'})
+
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/config/.vim/syntax_checkers/haskell/hlint.vim	Wed Nov 06 14:33:18 2013 +0100
@@ -0,0 +1,36 @@
+"============================================================================
+"File:        hlint.vim
+"Description: Syntax checking plugin for syntastic.vim
+"Maintainer:  Nicolas Wu <nicolas.wu at gmail dot com>
+"License:     BSD
+"============================================================================
+
+if exists('g:loaded_syntastic_haskell_hlint_checker')
+    finish
+endif
+let g:loaded_syntastic_haskell_hlint_checker = 1
+
+function! SyntaxCheckers_haskell_hlint_IsAvailable()
+    return executable('hlint')
+endfunction
+
+function! SyntaxCheckers_haskell_hlint_GetLocList()
+    let makeprg = syntastic#makeprg#build({
+        \ 'exe': 'hlint',
+        \ 'filetype': 'haskell',
+        \ 'subchecker': 'hlint' })
+
+    let errorformat =
+        \ '%E%f:%l:%c: Error: %m,' .
+        \ '%W%f:%l:%c: Warning: %m,' .
+        \ '%C%m'
+
+    return SyntasticMake({
+        \ 'makeprg': makeprg,
+        \ 'errorformat': errorformat,
+        \ 'postprocess': ['compressWhitespace'] })
+endfunction
+
+call g:SyntasticRegistry.CreateAndRegisterChecker({
+    \ 'filetype': 'haskell',
+    \ 'name': 'hlint'})
--- a/config/.vim/syntax_checkers/haxe.vim	Thu Sep 05 16:23:33 2013 +0200
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,55 +0,0 @@
-"============================================================================
-"File:        haxe.vim
-"Description: Syntax checking plugin for syntastic.vim
-"Maintainer:  David Bernard <david.bernard.31 at gmail dot com>
-"License:     This program is free software. It comes without any warranty,
-"             to the extent permitted by applicable law. You can redistribute
-"             it and/or modify it under the terms of the Do What The Fuck You
-"             Want To Public License, Version 2, as published by Sam Hocevar.
-"             See http://sam.zoy.org/wtfpl/COPYING for more details.
-"
-"============================================================================
-if exists("loaded_haxe_syntax_checker")
-    finish
-endif
-let loaded_haxe_syntax_checker = 1
-
-"bail if the user doesn't have haxe installed
-if !executable("haxe")
-    finish
-endif
-
-" s:FindInParent
-" find the file argument and returns the path to it.
-" Starting with the current working dir, it walks up the parent folders
-" until it finds the file, or it hits the stop dir.
-" If it doesn't find it, it returns "Nothing"
-function! s:FindInParent(fln,flsrt,flstp)
-    let here = a:flsrt
-    while ( strlen( here) > 0 )
-        let p = split(globpath(here, a:fln), '\n')
-        if len(p) > 0
-            return ['ok', here, fnamemodify(p[0], ':p:t')]
-        endif
-        let fr = match(here, '/[^/]*$')
-        if fr == -1
-            break
-        endif
-        let here = strpart(here, 0, fr)
-        if here == a:flstp
-            break
-        endif
-    endwhile
-    return ['fail', '', '']
-endfunction
-
-function! SyntaxCheckers_haxe_GetLocList()
-    let [success, hxmldir, hxmlname] = s:FindInParent('*.hxml', expand('%:p:h'), '/')
-    if success == 'ok'
-        let makeprg = 'cd ' . hxmldir . '; haxe ' . hxmlname
-        let errorformat = '%E%f:%l: characters %c-%*[0-9] : %m'
-        return SyntasticMake({ 'makeprg': makeprg, 'errorformat': errorformat })
-    else
-        return SyntasticMake({})
-    endif
-endfunction
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/config/.vim/syntax_checkers/haxe/haxe.vim	Wed Nov 06 14:33:18 2013 +0100
@@ -0,0 +1,52 @@
+"============================================================================
+"File:        haxe.vim
+"Description: Syntax checking plugin for syntastic.vim
+"Maintainer:  David Bernard <david.bernard.31 at gmail dot com>
+"License:     This program is free software. It comes without any warranty,
+"             to the extent permitted by applicable law. You can redistribute
+"             it and/or modify it under the terms of the Do What The Fuck You
+"             Want To Public License, Version 2, as published by Sam Hocevar.
+"             See http://sam.zoy.org/wtfpl/COPYING for more details.
+"
+"============================================================================
+
+if exists("g:loaded_syntastic_haxe_haxe_checker")
+    finish
+endif
+let g:loaded_syntastic_haxe_haxe_checker=1
+
+function! SyntaxCheckers_haxe_haxe_IsAvailable()
+    return executable('haxe')
+endfunction
+
+function! SyntaxCheckers_haxe_haxe_GetLocList()
+    if exists('b:vaxe_hxml')
+        let hxml = b:vaxe_hxml
+    elseif exists('g:vaxe_hxml')
+        let hxml = g:vaxe_hxml
+    else
+        let hxml = syntastic#util#findInParent('*.hxml', expand('%:p:h'))
+    endif
+    let hxml = fnamemodify(hxml, ':p')
+
+    if !empty(hxml)
+        let makeprg = syntastic#makeprg#build({
+            \ 'exe': 'haxe',
+            \ 'fname': syntastic#util#shescape(fnameescape(fnamemodify(hxml, ':t'))),
+            \ 'filetype': 'haxe',
+            \ 'subchecker': 'haxe' })
+
+        let errorformat = '%E%f:%l: characters %c-%*[0-9] : %m'
+
+        return SyntasticMake({
+            \ 'makeprg': makeprg,
+            \ 'errorformat': errorformat,
+            \ 'cwd': fnamemodify(hxml, ':h') })
+    endif
+
+    return []
+endfunction
+
+call g:SyntasticRegistry.CreateAndRegisterChecker({
+    \ 'filetype': 'haxe',
+    \ 'name': 'haxe'})
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/config/.vim/syntax_checkers/hss/hss.vim	Wed Nov 06 14:33:18 2013 +0100
@@ -0,0 +1,38 @@
+"============================================================================
+"File:        hss.vim
+"Description: Syntax checking plugin for syntastic.vim
+"Maintainer:  Justin Donaldson (jdonaldson@gmail.com)
+"License:     This program is free software. It comes without any warranty,
+"             to the extent permitted by applicable law. You can redistribute
+"             it and/or modify it under the terms of the Do What The Fuck You
+"             Want To Public License, Version 2, as published by Sam Hocevar.
+"             See http://sam.zoy.org/wtfpl/COPYING for more details.
+"
+"============================================================================
+
+if exists("g:loaded_syntastic_hss_hss_checker")
+    finish
+endif
+let g:loaded_syntastic_hss_hss_checker=1
+
+function! SyntaxCheckers_hss_hss_IsAvailable()
+    return executable('hss')
+endfunction
+
+function! SyntaxCheckers_hss_hss_GetLocList()
+    let makeprg = syntastic#makeprg#build({
+	\ 'exe': 'hss',
+	\ 'args' : '-output ' . syntastic#util#DevNull(),
+	\ 'filetype': 'hss',
+	\ 'subchecker': 'hss' })
+
+    let errorformat = '%E%f:%l: %m'
+
+    return SyntasticMake({
+	\ 'makeprg': makeprg,
+	\ 'errorformat': errorformat })
+endfunction
+
+call g:SyntasticRegistry.CreateAndRegisterChecker({
+    \ 'filetype': 'hss',
+    \ 'name': 'hss'})
--- a/config/.vim/syntax_checkers/html.vim	Thu Sep 05 16:23:33 2013 +0200
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,86 +0,0 @@
-"============================================================================
-"File:        html.vim
-"Description: Syntax checking plugin for syntastic.vim
-"Maintainer:  Martin Grenfell <martin.grenfell at gmail dot com>
-"License:     This program is free software. It comes without any warranty,
-"             to the extent permitted by applicable law. You can redistribute
-"             it and/or modify it under the terms of the Do What The Fuck You
-"             Want To Public License, Version 2, as published by Sam Hocevar.
-"             See http://sam.zoy.org/wtfpl/COPYING for more details.
-"
-"============================================================================
-if exists("loaded_html_syntax_checker")
-    finish
-endif
-let loaded_html_syntax_checker = 1
-
-"bail if the user doesnt have tidy or grep installed
-if !executable("tidy") || !executable("grep")
-    finish
-endif
-
-" TODO: join this with xhtml.vim for DRY's sake?
-function! s:TidyEncOptByFenc()
-    let tidy_opts = {
-                \'utf-8'       : '-utf8',
-                \'ascii'       : '-ascii',
-                \'latin1'      : '-latin1',
-                \'iso-2022-jp' : '-iso-2022',
-                \'cp1252'      : '-win1252',
-                \'macroman'    : '-mac',
-                \'utf-16le'    : '-utf16le',
-                \'utf-16'      : '-utf16',
-                \'big5'        : '-big5',
-                \'sjis'        : '-shiftjis',
-                \'cp850'       : '-ibm858',
-                \}
-    return get(tidy_opts, &fileencoding, '-utf8')
-endfunction
-
-let s:ignore_html_errors = [
-                \ "<table> lacks \"summary\" attribute",
-                \ "not approved by W3C",
-                \ "attribute \"placeholder\"",
-                \ "<meta> proprietary attribute \"charset\"",
-                \ "<meta> lacks \"content\" attribute",
-                \ "inserting \"type\" attribute",
-                \ "proprietary attribute \"data-"
-                \]
-
-function! s:ValidateError(text)
-    let valid = 0
-    for i in s:ignore_html_errors
-        if stridx(a:text, i) != -1
-            let valid = 1
-            break
-        endif
-    endfor
-    return valid
-endfunction
-
-
-function! SyntaxCheckers_html_GetLocList()
-
-    let encopt = s:TidyEncOptByFenc()
-    let makeprg="tidy ".encopt." --new-blocklevel-tags ".shellescape('section, article, aside, hgroup, header, footer, nav, figure, figcaption')." --new-inline-tags ".shellescape('video, audio, embed, mark, progress, meter, time, ruby, rt, rp, canvas, command, details, datalist')." --new-empty-tags ".shellescape('wbr, keygen')." -e ".shellescape(expand('%'))." 2>&1"
-    let errorformat='%Wline %l column %c - Warning: %m,%Eline %l column %c - Error: %m,%-G%.%#,%-G%.%#'
-    let loclist = SyntasticMake({ 'makeprg': makeprg, 'errorformat': errorformat })
-
-    " process loclist since we need to add some info and filter out valid HTML5
-    " from the errors
-    let n = len(loclist) - 1
-    let bufnum = bufnr("")
-    while n >= 0
-        let i = loclist[n]
-        " filter out valid HTML5
-        if s:ValidateError(i['text']) == 1
-            unlet loclist[n]
-        else
-            "the file name isnt in the output so stick in the buf num manually
-            let i['bufnr'] = bufnum
-        endif
-        let n -= 1
-    endwhile
-
-    return loclist
-endfunction
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/config/.vim/syntax_checkers/html/tidy.vim	Wed Nov 06 14:33:18 2013 +0100
@@ -0,0 +1,174 @@
+"============================================================================
+"File:        tidy.vim
+"Description: Syntax checking plugin for syntastic.vim
+"Maintainer:  Martin Grenfell <martin.grenfell at gmail dot com>
+"License:     This program is free software. It comes without any warranty,
+"             to the extent permitted by applicable law. You can redistribute
+"             it and/or modify it under the terms of the Do What The Fuck You
+"             Want To Public License, Version 2, as published by Sam Hocevar.
+"             See http://sam.zoy.org/wtfpl/COPYING for more details.
+"
+"============================================================================
+"
+" Checker option:
+"
+" - g:syntastic_html_tidy_ignore_errors (list; default: [])
+"   list of errors to ignore
+" - g:syntastic_html_tidy_blocklevel_tags (list; default: [])
+"   list of additional blocklevel tags, to be added to "--new-blocklevel-tags"
+" - g:syntastic_html_tidy_inline_tags (list; default: [])
+"   list of additional inline tags, to be added to "--new-inline-tags"
+" - g:syntastic_html_tidy_empty_tags (list; default: [])
+"   list of additional empty tags, to be added to "--new-empty-tags"
+
+if exists("g:loaded_syntastic_html_tidy_checker")
+    finish
+endif
+let g:loaded_syntastic_html_tidy_checker = 1
+
+if !exists('g:syntastic_html_tidy_ignore_errors')
+    let g:syntastic_html_tidy_ignore_errors = []
+endif
+
+if !exists('g:syntastic_html_tidy_blocklevel_tags')
+    let g:syntastic_html_tidy_blocklevel_tags = []
+endif
+
+if !exists('g:syntastic_html_tidy_inline_tags')
+    let g:syntastic_html_tidy_inline_tags = []
+endif
+
+if !exists('g:syntastic_html_tidy_empty_tags')
+    let g:syntastic_html_tidy_empty_tags = []
+endif
+
+function! SyntaxCheckers_html_tidy_IsAvailable()
+    return executable('tidy')
+endfunction
+
+" TODO: join this with xhtml.vim for DRY's sake?
+function! s:TidyEncOptByFenc()
+    let tidy_opts = {
+                \'utf-8'       : '-utf8',
+                \'ascii'       : '-ascii',
+                \'latin1'      : '-latin1',
+                \'iso-2022-jp' : '-iso-2022',
+                \'cp1252'      : '-win1252',
+                \'macroman'    : '-mac',
+                \'utf-16le'    : '-utf16le',
+                \'utf-16'      : '-utf16',
+                \'big5'        : '-big5',
+                \'cp932'       : '-shiftjis',
+                \'sjis'        : '-shiftjis',
+                \'cp850'       : '-ibm858',
+                \}
+    return get(tidy_opts, &fileencoding, '-utf8')
+endfunction
+
+let s:ignore_errors = [
+                \ "<table> lacks \"summary\" attribute",
+                \ "not approved by W3C",
+                \ "attribute \"placeholder\"",
+                \ "<meta> proprietary attribute \"charset\"",
+                \ "<meta> lacks \"content\" attribute",
+                \ "inserting \"type\" attribute",
+                \ "proprietary attribute \"data-",
+                \ "missing <!DOCTYPE> declaration",
+                \ "inserting implicit <body>",
+                \ "inserting missing 'title' element",
+                \ "attribute \"[+",
+                \ "unescaped & or unknown entity",
+                \ "<input> attribute \"type\" has invalid value \"search\""
+                \ ]
+
+let s:blocklevel_tags = [
+                \ "main",
+                \ "section",
+                \ "article",
+                \ "aside",
+                \ "hgroup",
+                \ "header",
+                \ "footer",
+                \ "nav",
+                \ "figure",
+                \ "figcaption"
+                \ ]
+
+let s:inline_tags = [
+                \ "video",
+                \ "audio",
+                \ "source",
+                \ "embed",
+                \ "mark",
+                \ "progress",
+                \ "meter",
+                \ "time",
+                \ "ruby",
+                \ "rt",
+                \ "rp",
+                \ "canvas",
+                \ "command",
+                \ "details",
+                \ "datalist"
+                \ ]
+
+let s:empty_tags = [
+                \ "wbr",
+                \ "keygen"
+                \ ]
+
+function! s:IgnoreError(text)
+    for i in s:ignore_errors + g:syntastic_html_tidy_ignore_errors
+        if stridx(a:text, i) != -1
+            return 1
+        endif
+    endfor
+    return 0
+endfunction
+
+function! s:NewTags(name)
+    return syntastic#util#shescape(join( s:{a:name} + g:syntastic_html_tidy_{a:name}, ',' ))
+endfunction
+
+function s:Args()
+    let args = s:TidyEncOptByFenc() .
+        \ ' --new-blocklevel-tags ' . s:NewTags('blocklevel_tags') .
+        \ ' --new-inline-tags ' . s:NewTags('inline_tags') .
+        \ ' --new-empty-tags ' . s:NewTags('empty_tags') .
+        \ ' -e'
+    return args
+endfunction
+
+function! SyntaxCheckers_html_tidy_GetLocList()
+    let makeprg = syntastic#makeprg#build({
+        \ 'exe': 'tidy',
+        \ 'args': s:Args(),
+        \ 'tail': '2>&1',
+        \ 'filetype': 'html',
+        \ 'subchecker': 'tidy' })
+
+    let errorformat =
+        \ '%Wline %l column %v - Warning: %m,' .
+        \ '%Eline %l column %v - Error: %m,' .
+        \ '%-G%.%#'
+
+    let loclist = SyntasticMake({
+        \ 'makeprg': makeprg,
+        \ 'errorformat': errorformat,
+        \ 'defaults': {'bufnr': bufnr("")},
+        \ 'returns': [0, 1, 2] })
+
+    " filter out valid HTML5 from the errors
+    for n in range(len(loclist))
+        if loclist[n]['valid'] && s:IgnoreError(loclist[n]['text']) == 1
+            let loclist[n]['valid'] = 0
+        endif
+    endfor
+
+    return loclist
+endfunction
+
+call g:SyntasticRegistry.CreateAndRegisterChecker({
+    \ 'filetype': 'html',
+    \ 'name': 'tidy'})
+
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/config/.vim/syntax_checkers/html/validator.vim	Wed Nov 06 14:33:18 2013 +0100
@@ -0,0 +1,97 @@
+"============================================================================
+"File:        validator.vim
+"Description: Syntax checking plugin for syntastic.vim
+"Maintainer:  LCD 47 <lcd047 at gmail dot com>
+"License:     This program is free software. It comes without any warranty,
+"             to the extent permitted by applicable law. You can redistribute
+"             it and/or modify it under the terms of the Do What The Fuck You
+"             Want To Public License, Version 2, as published by Sam Hocevar.
+"             See http://sam.zoy.org/wtfpl/COPYING for more details.
+"
+"============================================================================
+"
+" For detail;s about validator see: http://about.validator.nu/
+"
+" Checker options:
+"
+" - g:syntastic_html_validator_api (string; default: 'http://validator.nu/')
+"   URL of the service to use for checking; leave it to the default to run the
+"   checks against http://validator.nu/, or set it to 'http://localhost:8888/'
+"   if you're running a local service as per http://about.validator.nu/#src
+"
+" - g:syntastic_html_validator_parser (string; default: empty)
+"   parser to use; legal values are: xml, xmldtd, html, html5, html4, html4tr;
+"   set it to 'html5' to check HTML5 files;  see the wiki for reference:
+"   http://wiki.whatwg.org/wiki/Validator.nu_Common_Input_Parameters#parser
+"
+" - g:syntastic_html_validator_nsfilter (string; default: empty)
+"   sets the nsfilter for the parser; see the wiki for details:
+"   http://wiki.whatwg.org/wiki/Validator.nu_Common_Input_Parameters#nsfilter
+
+if exists("g:loaded_syntastic_html_validator_checker")
+    finish
+endif
+let g:loaded_syntastic_html_validator_checker=1
+
+if !exists('g:syntastic_html_validator_api')
+    let g:syntastic_html_validator_api = 'http://validator.nu/'
+endif
+
+if !exists('g:syntastic_html_validator_parser')
+    let g:syntastic_html_validator_parser = ''
+endif
+
+if !exists('g:syntastic_html_validator_nsfilter')
+    let g:syntastic_html_validator_nsfilter = ''
+endif
+
+let s:decoder = 'awk -f ' . syntastic#util#shescape(expand('<sfile>:p:h') . '/validator_decode.awk')
+
+function! SyntaxCheckers_html_validator_IsAvailable()
+    return executable('curl') && executable('awk')
+endfunction
+
+function! SyntaxCheckers_html_validator_Preprocess(errors)
+    let out = copy(a:errors)
+    for n in range(len(out))
+        let parts = matchlist(out[n], '\v^"([^"]+)"(.+)')
+        " 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], '\\"', '"', 'g')
+        let parts[1] = substitute(parts[1], '\\\\', '\\', 'g')
+        let out[n] = '"' . parts[1] . '"' . parts[2]
+    endfor
+    return out
+endfunction
+
+function! SyntaxCheckers_html_validator_GetLocList()
+    let makeprg = 'curl -s --compressed -F out=gnu -F asciiquotes=yes' .
+        \ (!empty(g:syntastic_html_validator_parser) ? ' -F parser=' . g:syntastic_html_validator_parser : '') .
+        \ (!empty(g:syntastic_html_validator_nsfilter) ? ' -F nsfilter=' . g:syntastic_html_validator_nsfilter : '') .
+        \ ' -F doc=@' . syntastic#util#shexpand('%') . '\;type=text/html\;filename=' . syntastic#util#shexpand('%') . ' ' .
+        \ g:syntastic_html_validator_api
+
+    let errorformat =
+        \ '%E"%f":%l: %trror: %m,' .
+        \ '%E"%f":%l-%\d%\+: %trror: %m,' .
+        \ '%E"%f":%l%\%.%c: %trror: %m,' .
+        \ '%E"%f":%l%\%.%c-%\d%\+%\%.%\d%\+: %trror: %m,' .
+        \ '%E"%f":%l: %trror fatal: %m,' .
+        \ '%E"%f":%l-%\d%\+: %trror fatal: %m,' .
+        \ '%E"%f":%l%\%.%c: %trror fatal: %m,' .
+        \ '%E"%f":%l%\%.%c-%\d%\+%\%.%\d%\+: %trror fatal: %m,' .
+        \ '%W"%f":%l: info %tarning: %m,' .
+        \ '%W"%f":%l-%\d%\+: info %tarning: %m,' .
+        \ '%W"%f":%l%\%.%c: info %tarning: %m,' .
+        \ '%W"%f":%l%\%.%c-%\d%\+%\%.%\d%\+: info %tarning: %m'
+
+    return SyntasticMake({
+        \ 'makeprg': makeprg,
+        \ 'errorformat': errorformat,
+        \ 'preprocess': 'SyntaxCheckers_html_validator_Preprocess',
+        \ 'returns': [0] })
+endfunction
+
+call g:SyntasticRegistry.CreateAndRegisterChecker({
+    \ 'filetype': 'html',
+    \ 'name': 'validator'})
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/config/.vim/syntax_checkers/html/w3.vim	Wed Nov 06 14:33:18 2013 +0100
@@ -0,0 +1,65 @@
+"============================================================================
+"File:        w3.vim
+"Description: Syntax checking plugin for syntastic.vim
+"Maintainer:  Martin Grenfell <martin.grenfell at gmail dot com>
+"License:     This program is free software. It comes without any warranty,
+"             to the extent permitted by applicable law. You can redistribute
+"             it and/or modify it under the terms of the Do What The Fuck You
+"             Want To Public License, Version 2, as published by Sam Hocevar.
+"             See http://sam.zoy.org/wtfpl/COPYING for more details.
+"
+"============================================================================
+"
+" Checker option:
+"
+" - g:syntastic_html_w3_api (string; default: 'http://validator.w3.org/check')
+"   URL of the service to use for checking; leave it to the default to run the
+"   checks against http://validator.w3.org/, or set it to
+"   'http://localhost/w3c-validator/check' if you're running a local service
+
+if exists("g:loaded_syntastic_html_w3_checker")
+    finish
+endif
+let g:loaded_syntastic_html_w3_checker = 1
+
+if !exists('g:syntastic_html_w3_api')
+    let g:syntastic_html_w3_api = 'http://validator.w3.org/check'
+endif
+
+function! SyntaxCheckers_html_w3_IsAvailable()
+    return executable('curl')
+endfunction
+
+function! SyntaxCheckers_html_w3_GetLocList()
+    let makeprg = 'curl -s -F output=json ' .
+        \ '-F uploaded_file=@' . syntastic#util#shexpand('%:p') . '\;type=text/html ' .
+        \ g:syntastic_html_w3_api
+
+    let errorformat =
+        \ '%A %\+{,' .
+        \ '%C %\+"lastLine": %l\,%\?,' .
+        \ '%C %\+"lastColumn": %c\,%\?,' .
+        \ '%C %\+"message": "%m"\,%\?,' .
+        \ '%C %\+"type": "%trror"\,%\?,' .
+        \ '%-G %\+"type": "%tnfo"\,%\?,' .
+        \ '%C %\+"subtype": "%tarning"\,%\?,' .
+        \ '%Z %\+}\,,' .
+        \ '%-G%.%#'
+
+    let loclist = SyntasticMake({
+        \ 'makeprg': makeprg,
+        \ 'errorformat': errorformat,
+        \ 'defaults': {'bufnr': bufnr("")},
+        \ 'returns': [0] })
+
+    for n in range(len(loclist))
+        let loclist[n]['text'] = substitute(loclist[n]['text'], '\\\([\"]\)', '\1', 'g')
+    endfor
+
+    return loclist
+endfunction
+
+call g:SyntasticRegistry.CreateAndRegisterChecker({
+    \ 'filetype': 'html',
+    \ 'name': 'w3'})
+
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/config/.vim/syntax_checkers/java/checkstyle.vim	Wed Nov 06 14:33:18 2013 +0100
@@ -0,0 +1,79 @@
+"============================================================================
+"File:        checkstyle.vim
+"Description: Syntax checking plugin for syntastic.vim
+"Maintainer:  Dmitry Geurkov <d.geurkov at gmail dot com>
+"License:     This program is free software. It comes without any warranty,
+"             to the extent permitted by applicable law. You can redistribute
+"             it and/or modify it under the terms of the Do What The Fuck You
+"             Want To Public License, Version 2, as published by Sam Hocevar.
+"             See http://sam.zoy.org/wtfpl/COPYING for more details.
+"
+" Tested with checkstyle 5.5
+"============================================================================
+if exists("g:loaded_syntastic_java_checkstyle_checker")
+    finish
+endif
+let g:loaded_syntastic_java_checkstyle_checker=1
+
+if !exists("g:syntastic_java_checkstyle_classpath")
+    let g:syntastic_java_checkstyle_classpath = 'checkstyle-5.5-all.jar'
+endif
+
+if !exists("g:syntastic_java_checkstyle_conf_file")
+    let g:syntastic_java_checkstyle_conf_file = 'sun_checks.xml'
+endif
+
+function! SyntaxCheckers_java_checkstyle_IsAvailable()
+    return executable('java')
+endfunction
+
+function! SyntaxCheckers_java_checkstyle_Preprocess(errors)
+    let out = copy(a:errors)
+    for n in range(len(out))
+        let parts = matchlist(out[n], '\(.*<file name="\)\([^"]\+\)\(">.*\)')
+        if len(parts) >= 4
+            let parts[2] = syntastic#util#decodeXMLEntities(parts[2])
+            let out[n] = join(parts[1:3], '')
+        endif
+    endfor
+    return out
+endfunction
+
+function! SyntaxCheckers_java_checkstyle_GetLocList()
+
+    let fname = syntastic#util#shescape( expand('%:p:h') . '/' . expand('%:t') )
+
+    if has('win32unix')
+        let fname = substitute(system('cygpath -m ' . fname), '\%x00', '', 'g')
+    endif
+
+    let makeprg = syntastic#makeprg#build({
+        \ 'exe': 'java',
+        \ 'args': '-cp ' . g:syntastic_java_checkstyle_classpath .
+        \         ' com.puppycrawl.tools.checkstyle.Main -c ' . g:syntastic_java_checkstyle_conf_file .
+        \         ' -f xml',
+        \ 'fname': fname,
+        \ 'filetype': 'java',
+        \ 'subchecker': 'checkstyle' })
+
+    let errorformat =
+        \ '%P<file name="%f">,' .
+        \ '%Q</file>,' .
+        \ '%E<error line="%l" column="%c" severity="%trror" message="%m" source="%.%#"/>,' .
+        \ '%E<error line="%l" severity="%trror" message="%m" source="%.%#"/>,' .
+        \ '%E<error line="%l" column="%c" severity="%tarning" message="%m" source="%.%#"/>,' .
+        \ '%E<error line="%l" severity="%tarning" message="%m" source="%.%#"/>,' .
+        \ '%-G%.%#'
+
+    return SyntasticMake({
+        \ 'makeprg': makeprg,
+        \ 'errorformat': errorformat,
+        \ 'subtype': 'Style',
+        \ 'preprocess': 'SyntaxCheckers_java_checkstyle_Preprocess',
+        \ 'postprocess': ['cygwinRemoveCR', 'decodeXMLEntities'] })
+
+endfunction
+
+call g:SyntasticRegistry.CreateAndRegisterChecker({
+    \ 'filetype': 'java',
+    \ 'name': 'checkstyle'})
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/config/.vim/syntax_checkers/java/javac.vim	Wed Nov 06 14:33:18 2013 +0100
@@ -0,0 +1,366 @@
+"============================================================================
+"File:        javac.vim
+"Description: Syntax checking plugin for syntastic.vim
+"Maintainer:  Jochen Keil <jochen.keil at gmail dot com>
+"             Dmitry Geurkov <d.geurkov at gmail dot com>
+"License:     This program is free software. It comes without any warranty,
+"             to the extent permitted by applicable law. You can redistribute
+"             it and/or modify it under the terms of the Do What The Fuck You
+"             Want To Public License, Version 2, as published by Sam Hocevar.
+"             See http://sam.zoy.org/wtfpl/COPYING for more details.
+"
+"============================================================================
+
+if exists("g:loaded_syntastic_java_javac_checker")
+    finish
+endif
+let g:loaded_syntastic_java_javac_checker=1
+let g:syntastic_java_javac_maven_pom_tags = ["build", "properties"]
+let g:syntastic_java_javac_maven_pom_properties = {}
+
+" Global Options
+if !exists("g:syntastic_java_javac_executable")
+    let g:syntastic_java_javac_executable = 'javac'
+endif
+
+if !exists("g:syntastic_java_maven_executable")
+    let g:syntastic_java_maven_executable = 'mvn'
+endif
+
+if !exists("g:syntastic_java_javac_options")
+    let g:syntastic_java_javac_options = '-Xlint'
+endif
+
+if !exists("g:syntastic_java_javac_classpath")
+    let g:syntastic_java_javac_classpath = ''
+endif
+
+if !exists("g:syntastic_java_javac_delete_output")
+    let g:syntastic_java_javac_delete_output = 1
+endif
+
+function! s:CygwinPath(path)
+    return substitute(system("cygpath -m ".a:path), '\%x00', '', 'g')
+endfunction
+
+if !exists("g:syntastic_java_javac_temp_dir")
+    if has('win32') || has('win64')
+        let g:syntastic_java_javac_temp_dir = $TEMP."\\vim-syntastic-javac"
+    elseif has('win32unix')
+        let g:syntastic_java_javac_temp_dir = s:CygwinPath('/tmp/vim-syntastic-javac')
+    else
+        let g:syntastic_java_javac_temp_dir = '/tmp/vim-syntastic-javac'
+    endif
+endif
+
+if !exists("g:syntastic_java_javac_autoload_maven_classpath")
+    let g:syntastic_java_javac_autoload_maven_classpath = 1
+endif
+
+if !exists('g:syntastic_java_javac_config_file_enabled')
+    let g:syntastic_java_javac_config_file_enabled = 0
+endif
+
+if !exists('g:syntastic_java_javac_config_file')
+    let g:syntastic_java_javac_config_file = '.syntastic_javac_config'
+endif
+
+if !exists("g:syntastic_java_javac_maven_pom_ftime")
+    let g:syntastic_java_javac_maven_pom_ftime = {}
+endif
+
+if !exists("g:syntastic_java_javac_maven_pom_classpath")
+    let g:syntastic_java_javac_maven_pom_classpath = {}
+endif
+
+function! s:RemoveCarriageReturn(line)
+    return substitute(a:line, '\r', '', 'g')
+endfunction
+
+" recursively remove directory and all it's sub-directories
+function! s:RemoveDir(dir)
+    if isdirectory(a:dir)
+        for f in split(globpath(a:dir, '*'), "\n")
+            call s:RemoveDir(f)
+        endfor
+        silent! call system('rmdir ' . a:dir)
+    else
+        silent! call delete(a:dir)
+    endif
+endfunction
+
+function! s:AddToClasspath(classpath,path)
+    if a:path == ''
+        return a:classpath
+    endif
+    if a:classpath != '' && a:path != ''
+        if has('win32') || has('win32unix') || has('win64')
+            return a:classpath . ";" . a:path
+        else
+            return a:classpath . ":" . a:path
+        endif
+    else
+        return a:path
+    endif
+endfunction
+
+function! s:LoadClasspathFromConfigFile()
+    if filereadable(g:syntastic_java_javac_config_file)
+        let path = ''
+        let lines = readfile(g:syntastic_java_javac_config_file)
+        for l in lines
+            if l != ''
+                let path .= l . "\n"
+            endif
+        endfor
+        return path
+    else
+        return ''
+    endif
+endfunction
+
+function! s:SaveClasspath()
+    let path = ''
+    let lines = getline(1, line('$'))
+    " save classpath to config file
+    if g:syntastic_java_javac_config_file_enabled
+        call writefile(lines,g:syntastic_java_javac_config_file)
+    endif
+    for l in lines
+        if l != ''
+            let path .= l . "\n"
+        endif
+    endfor
+    let g:syntastic_java_javac_classpath = path
+    let &modified = 0
+endfunction
+
+function! s:EditClasspath()
+    let command = 'syntastic javac classpath'
+    let winnr = bufwinnr('^' . command . '$')
+    if winnr < 0
+        let pathlist = split(g:syntastic_java_javac_classpath,"\n")
+        execute (len(pathlist) + 5) . 'sp ' . fnameescape(command)
+
+        augroup syntastic
+            autocmd BufWriteCmd <buffer> call s:SaveClasspath() | bwipeout
+        augroup END
+
+        setlocal buftype=acwrite bufhidden=wipe nobuflisted noswapfile nowrap number
+        for p in pathlist
+            call append(line('$') - 1, p)
+        endfor
+    else
+        execute winnr . 'wincmd w'
+    endif
+endfunction
+
+function! s:GetMavenProperties()
+    let mvn_properties = {}
+    let pom = findfile("pom.xml", ".;")
+    if filereadable(pom)
+        if !has_key(g:syntastic_java_javac_maven_pom_properties, pom)
+            let mvn_cmd = g:syntastic_java_maven_executable . ' -f ' . pom
+            let mvn_is_managed_tag = 1
+            let mvn_settings_output = split(system(mvn_cmd . ' help:effective-pom'), "\n")
+            let current_path = 'project'
+            for line in mvn_settings_output
+                let matches = matchlist(line, '^\s*<\([a-zA-Z0-9\-\.]\+\)>\s*$')
+                if mvn_is_managed_tag && !empty(matches)
+                    let mvn_is_managed_tag = index(g:syntastic_java_javac_maven_pom_tags, matches[1]) >= 0
+                    let current_path .= '.' . matches[1]
+                else
+                    let matches = matchlist(line, '^\s*</\([a-zA-Z0-9\-\.]\+\)>\s*$')
+                    if !empty(matches)
+                        let mvn_is_managed_tag = index(g:syntastic_java_javac_maven_pom_tags, matches[1]) < 0
+                        let current_path  = substitute(current_path, '\.' . matches[1] . "$", '', '')
+                    else
+                        let matches = matchlist(line, '^\s*<\([a-zA-Z0-9\-\.]\+\)>\(.\+\)</[a-zA-Z0-9\-\.]\+>\s*$')
+                        if mvn_is_managed_tag && !empty(matches)
+                            let mvn_properties[current_path . '.' . matches[1]] = matches[2]
+                        endif
+                    endif
+                endif
+            endfor
+            let g:syntastic_java_javac_maven_pom_properties[pom] = mvn_properties
+        endif
+        return g:syntastic_java_javac_maven_pom_properties[pom]
+    endif
+    return mvn_properties
+endfunction
+
+command! SyntasticJavacEditClasspath call s:EditClasspath()
+
+function! s:GetMavenClasspath()
+    let pom = findfile("pom.xml", ".;")
+    if filereadable(pom)
+        if !has_key(g:syntastic_java_javac_maven_pom_ftime, pom) || g:syntastic_java_javac_maven_pom_ftime[pom] != getftime(pom)
+            let mvn_cmd = g:syntastic_java_maven_executable . ' -f ' . pom
+            let mvn_classpath_output = split(system(mvn_cmd . ' dependency:build-classpath'), "\n")
+            let class_path_next = 0
+
+            for line in mvn_classpath_output
+                if class_path_next == 1
+                    let mvn_classpath = s:RemoveCarriageReturn(line)
+                    break
+                endif
+                if match(line,'Dependencies classpath:') >= 0
+                    let class_path_next = 1
+                endif
+            endfor
+
+            let mvn_properties = s:GetMavenProperties()
+
+            let output_dir = 'target/classes'
+            if has_key(mvn_properties, 'project.build.outputDirectory')
+                let output_dir = mvn_properties['project.build.outputDirectory']
+            endif
+            let mvn_classpath = s:AddToClasspath(mvn_classpath, output_dir)
+
+            let test_output_dir = 'target/test-classes'
+            if has_key(mvn_properties, 'project.build.testOutputDirectory')
+                let test_output_dir = mvn_properties['project.build.testOutputDirectory']
+            endif
+            let mvn_classpath = s:AddToClasspath(mvn_classpath, test_output_dir)
+
+            let g:syntastic_java_javac_maven_pom_ftime[pom] = getftime(pom)
+            let g:syntastic_java_javac_maven_pom_classpath[pom] = mvn_classpath
+        endif
+        return g:syntastic_java_javac_maven_pom_classpath[pom]
+    endif
+    return ''
+endfunction
+
+function! SyntaxCheckers_java_javac_IsAvailable()
+    return executable(g:syntastic_java_javac_executable)
+endfunction
+
+function! s:MavenOutputDirectory()
+    let pom = findfile("pom.xml", ".;")
+    if filereadable(pom)
+        let mvn_properties = s:GetMavenProperties()
+        let output_dir = getcwd()
+        if has_key(mvn_properties, 'project.properties.build.dir')
+            let output_dir = mvn_properties['project.properties.build.dir']
+        endif
+        if match(expand( '%:p:h' ), "src.main.java") >= 0
+            let output_dir .= '/target/classes'
+            if has_key(mvn_properties, 'project.build.outputDirectory')
+                let output_dir = mvn_properties['project.build.outputDirectory']
+            endif
+        endif
+        if match(expand( '%:p:h' ), "src.test.java") >= 0
+            let output_dir .= '/target/test-classes'
+            if has_key(mvn_properties, 'project.build.testOutputDirectory')
+                let output_dir = mvn_properties['project.build.testOutputDirectory']
+            endif
+        endif
+
+        if has('win32unix')
+            let output_dir=s:CygwinPath(output_dir)
+        endif
+        return output_dir
+    endif
+endfunction
+
+function! SyntaxCheckers_java_javac_GetLocList()
+
+    let javac_opts = g:syntastic_java_javac_options
+
+    if g:syntastic_java_javac_delete_output
+        let output_dir = g:syntastic_java_javac_temp_dir
+        let javac_opts .= ' -d ' . output_dir
+    endif
+
+    " load classpath from config file
+    if g:syntastic_java_javac_config_file_enabled
+        let loaded_classpath = s:LoadClasspathFromConfigFile()
+        if loaded_classpath != ''
+            let g:syntastic_java_javac_classpath = loaded_classpath
+        endif
+    endif
+
+    let javac_classpath = ''
+
+    " add classpathes to javac_classpath
+    for path in split(g:syntastic_java_javac_classpath,"\n")
+        if path != ''
+            try
+                let ps = glob(path,0,1)
+            catch
+                let ps = split(glob(path,0),"\n")
+            endtry
+            if type(ps) == type([])
+                for p in ps
+                    if p != ''
+                        let javac_classpath = s:AddToClasspath(javac_classpath,p)
+                    endif
+                endfor
+            else
+                let javac_classpath = s:AddToClasspath(javac_classpath,ps)
+            endif
+        endif
+    endfor
+
+    if g:syntastic_java_javac_autoload_maven_classpath
+        if !g:syntastic_java_javac_delete_output
+            let maven_output_dir = s:MavenOutputDirectory()
+            let javac_opts .= ' -d ' . maven_output_dir
+        endif
+        let maven_classpath = s:GetMavenClasspath()
+        let javac_classpath = s:AddToClasspath(javac_classpath,maven_classpath)
+    endif
+
+    if javac_classpath != ''
+        let javac_opts .= ' -cp "' . fnameescape(javac_classpath) . '"'
+    endif
+
+    " path seperator
+    if has('win32') || has('win32unix') || has('win64')
+        let sep = "\\"
+    else
+        let sep = '/'
+    endif
+
+    let fname = fnameescape(expand ( '%:p:h' ) . sep . expand ( '%:t' ))
+
+    if has('win32unix')
+        let fname =  s:CygwinPath(fname)
+    endif
+
+    let makeprg = syntastic#makeprg#build({
+        \ 'exe': g:syntastic_java_javac_executable,
+        \ 'args': javac_opts,
+        \ 'fname': fname,
+        \ 'tail': '2>&1',
+        \ 'filetype': 'java',
+        \ 'subchecker': 'javac' })
+
+    " unashamedly stolen from *errorformat-javac* (quickfix.txt) and modified to include error types
+    let errorformat =
+        \ '%E%f:%l:\ error:\ %m,'.
+        \ '%W%f:%l:\ warning:\ %m,'.
+        \ '%A%f:%l:\ %m,'.
+        \ '%+Z%p^,'.
+        \ '%+C%.%#,'.
+        \ '%-G%.%#'
+
+    if g:syntastic_java_javac_delete_output
+        silent! call mkdir(output_dir,'p')
+    endif
+    let errors = SyntasticMake({
+        \ 'makeprg': makeprg,
+        \ 'errorformat': errorformat,
+        \ 'postprocess': ['cygwinRemoveCR'] })
+
+    if g:syntastic_java_javac_delete_output
+        call s:RemoveDir(output_dir)
+    endif
+    return errors
+
+endfunction
+
+call g:SyntasticRegistry.CreateAndRegisterChecker({
+    \ 'filetype': 'java',
+    \ 'name': 'javac'})
+
--- a/config/.vim/syntax_checkers/javascript.vim	Thu Sep 05 16:23:33 2013 +0200
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,23 +0,0 @@
-"============================================================================
-"File:        javascript.vim
-"Description: Figures out which javascript syntax checker (if any) to load
-"             from the javascript directory.
-"Maintainer:  Martin Grenfell <martin.grenfell at gmail dot com>
-"License:     This program is free software. It comes without any warranty,
-"             to the extent permitted by applicable law. You can redistribute
-"             it and/or modify it under the terms of the Do What The Fuck You
-"             Want To Public License, Version 2, as published by Sam Hocevar.
-"             See http://sam.zoy.org/wtfpl/COPYING for more details.
-"
-" Use g:syntastic_javascript_checker option to specify which jslint executable
-" should be used (see below for a list of supported checkers).
-" If g:syntastic_javascript_checker is not set, just use the first syntax
-" checker that we find installed.
-"============================================================================
-if exists("loaded_javascript_syntax_checker")
-    finish
-endif
-let loaded_javascript_syntax_checker = 1
-
-let s:supported_checkers = ["gjslint", "jslint", "jsl", "jshint"]
-call SyntasticLoadChecker(s:supported_checkers)
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/config/.vim/syntax_checkers/javascript/closurecompiler.vim	Wed Nov 06 14:33:18 2013 +0100
@@ -0,0 +1,66 @@
+"============================================================================
+"File:        closurecompiler.vim
+"Description: Javascript syntax checker - using Google Closure Compiler
+"Maintainer:  Motohiro Takayama <mootoh at gmail dot com>
+"License:     This program is free software. It comes without any warranty,
+"             to the extent permitted by applicable law. You can redistribute
+"             it and/or modify it under the terms of the Do What The Fuck You
+"             Want To Public License, Version 2, as published by Sam Hocevar.
+"             See http://sam.zoy.org/wtfpl/COPYING for more details.
+"============================================================================
+"
+" To enable this plugin, edit the .vimrc like this:
+"
+"   let g:syntastic_javascript_checker = "closurecompiler"
+"
+" and set the path to the Google Closure Compiler:
+"
+"   let g:syntastic_javascript_closure_compiler_path = '/path/to/google-closure-compiler.jar'
+"
+" It takes additional options for Google Closure Compiler with the variable
+" g:syntastic_javascript_closure_compiler_options.
+"
+
+if exists("g:loaded_syntastic_javascript_closurecompiler_checker")
+    finish
+endif
+let g:loaded_syntastic_javascript_closurecompiler_checker=1
+
+if !exists("g:syntastic_javascript_closure_compiler_options")
+    let g:syntastic_javascript_closure_compiler_options = ""
+endif
+
+function! SyntaxCheckers_javascript_closurecompiler_IsAvailable()
+    return exists("g:syntastic_javascript_closure_compiler_path")
+endfunction
+
+function! SyntaxCheckers_javascript_closurecompiler_GetLocList()
+    if exists("g:syntastic_javascript_closure_compiler_file_list")
+        let file_list = join(readfile(g:syntastic_javascript_closure_compiler_file_list), ' ')
+    else
+        let file_list = syntastic#util#shexpand('%')
+    endif
+
+    let makeprg = syntastic#makeprg#build({
+        \ 'exe': 'java -jar ' . g:syntastic_javascript_closure_compiler_path,
+        \ 'args': g:syntastic_javascript_closure_compiler_options . ' --js' ,
+        \ 'fname': file_list,
+        \ 'filetype': 'javascript',
+        \ 'subchecker': 'closurecompiler' })
+
+    let errorformat =
+        \ '%-GOK,'.
+        \ '%E%f:%l: ERROR - %m,'.
+        \ '%Z%p^,'.
+        \ '%W%f:%l: WARNING - %m,'.
+        \ '%Z%p^'
+
+    return SyntasticMake({
+        \ 'makeprg': makeprg,
+        \ 'errorformat': errorformat })
+endfunction
+
+call g:SyntasticRegistry.CreateAndRegisterChecker({
+    \ 'filetype': 'javascript',
+    \ 'name': 'closurecompiler'})
+
--- a/config/.vim/syntax_checkers/javascript/gjslint.vim	Thu Sep 05 16:23:33 2013 +0200
+++ b/config/.vim/syntax_checkers/javascript/gjslint.vim	Wed Nov 06 14:33:18 2013 +0100
@@ -8,13 +8,39 @@
 "             Want To Public License, Version 2, as published by Sam Hocevar.
 "             See http://sam.zoy.org/wtfpl/COPYING for more details.
 "============================================================================
+if exists("g:loaded_syntastic_javascript_gjslint_checker")
+    finish
+endif
+let g:loaded_syntastic_javascript_gjslint_checker=1
+
 if !exists("g:syntastic_javascript_gjslint_conf")
     let g:syntastic_javascript_gjslint_conf = ""
 endif
 
-function! SyntaxCheckers_javascript_GetLocList()
-    let makeprg = "gjslint " . g:syntastic_javascript_gjslint_conf . " --nosummary --unix_mode --nodebug_indentation --nobeep " . shellescape(expand('%'))
-    let errorformat="%f:%l:(New Error -%\\?\%n) %m,%f:%l:(-%\\?%n) %m,%-G1 files checked, no errors found.,%-G%.%#"
-    return SyntasticMake({ 'makeprg': makeprg, 'errorformat': errorformat })
+function! SyntaxCheckers_javascript_gjslint_IsAvailable()
+    return executable('gjslint')
 endfunction
 
+function! SyntaxCheckers_javascript_gjslint_GetLocList()
+    let makeprg = syntastic#makeprg#build({
+        \ 'exe': 'gjslint',
+        \ 'args': g:syntastic_javascript_gjslint_conf . " --nosummary --unix_mode --nodebug_indentation --nobeep",
+        \ 'filetype': 'javascript',
+        \ 'subchecker': 'gjslint' })
+
+    let errorformat =
+        \ "%f:%l:(New Error -%\\?\%n) %m," .
+        \ "%f:%l:(-%\\?%n) %m," .
+        \ "%-G1 files checked," .
+        \ " no errors found.," .
+        \ "%-G%.%#"
+
+    return SyntasticMake({
+        \ 'makeprg': makeprg,
+        \ 'errorformat': errorformat })
+endfunction
+
+call g:SyntasticRegistry.CreateAndRegisterChecker({
+    \ 'filetype': 'javascript',
+    \ 'name': 'gjslint'})
+
--- a/config/.vim/syntax_checkers/javascript/jshint.vim	Thu Sep 05 16:23:33 2013 +0200
+++ b/config/.vim/syntax_checkers/javascript/jshint.vim	Wed Nov 06 14:33:18 2013 +0100
@@ -8,14 +8,52 @@
 "             Want To Public License, Version 2, as published by Sam Hocevar.
 "             See http://sam.zoy.org/wtfpl/COPYING for more details.
 "============================================================================
-if !exists("g:syntastic_javascript_jshint_conf")
-    let g:syntastic_javascript_jshint_conf = ""
+
+if exists('g:loaded_syntastic_javascript_jshint_checker')
+    finish
+endif
+let g:loaded_syntastic_javascript_jshint_checker=1
+
+if !exists('g:syntastic_jshint_exec')
+    let g:syntastic_jshint_exec = 'jshint'
+endif
+
+if !exists('g:syntastic_javascript_jshint_conf')
+    let g:syntastic_javascript_jshint_conf = ''
 endif
 
-function! SyntaxCheckers_javascript_GetLocList()
+function! SyntaxCheckers_javascript_jshint_IsAvailable()
+    return executable(expand(g:syntastic_jshint_exec))
+endfunction
+
+function! SyntaxCheckers_javascript_jshint_GetLocList()
+    let jshint_new = s:JshintNew()
+    let makeprg = syntastic#makeprg#build({
+        \ 'exe': expand(g:syntastic_jshint_exec),
+        \ 'post_args': (jshint_new ? ' --verbose ' : '') . s:Args(),
+        \ 'filetype': 'javascript',
+        \ 'subchecker': 'jshint' })
+
+    let errorformat = jshint_new ?
+        \ '%f: line %l\, col %c\, %m \(%t%*\d\)' :
+        \ '%E%f: line %l\, col %c\, %m'
+
+    return SyntasticMake({
+        \ 'makeprg': makeprg,
+        \ 'errorformat': errorformat,
+        \ 'defaults': {'bufnr': bufnr('')} })
+endfunction
+
+function s:JshintNew()
+    return syntastic#util#versionIsAtLeast(syntastic#util#parseVersion(expand(g:syntastic_jshint_exec) . ' --version'), [1, 1])
+endfunction
+
+function s:Args()
     " node-jshint uses .jshintrc as config unless --config arg is present
-    let args = !empty(g:syntastic_javascript_jshint_conf) ? ' --config ' . g:syntastic_javascript_jshint_conf : ''
-    let makeprg = 'jshint ' . shellescape(expand("%")) . args
-    let errorformat = '%ELine %l:%c,%Z\\s%#Reason: %m,%C%.%#,%f: line %l\, col %c\, %m,%-G%.%#'
-    return SyntasticMake({ 'makeprg': makeprg, 'errorformat': errorformat, 'defaults': {'bufnr': bufnr('')} })
+    return !empty(g:syntastic_javascript_jshint_conf) ? ' --config ' . g:syntastic_javascript_jshint_conf : ''
 endfunction
+
+call g:SyntasticRegistry.CreateAndRegisterChecker({
+    \ 'filetype': 'javascript',
+    \ 'name': 'jshint'})
+
--- a/config/.vim/syntax_checkers/javascript/jsl.vim	Thu Sep 05 16:23:33 2013 +0200
+++ b/config/.vim/syntax_checkers/javascript/jsl.vim	Wed Nov 06 14:33:18 2013 +0100
@@ -8,13 +8,49 @@
 "             Want To Public License, Version 2, as published by Sam Hocevar.
 "             See http://sam.zoy.org/wtfpl/COPYING for more details.
 "============================================================================
+if exists("g:loaded_syntastic_javascript_jsl_checker")
+    finish
+endif
+let g:loaded_syntastic_javascript_jsl_checker=1
+
 if !exists("g:syntastic_javascript_jsl_conf")
     let g:syntastic_javascript_jsl_conf = ""
 endif
 
-function! SyntaxCheckers_javascript_GetLocList()
-    let makeprg = "jsl " . g:syntastic_javascript_jsl_conf . " -nologo -nofilelisting -nosummary -nocontext -process ".shellescape(expand('%'))
-    let errorformat='%W%f(%l): lint warning: %m,%-Z%p^,%W%f(%l): warning: %m,%-Z%p^,%E%f(%l): SyntaxError: %m,%-Z%p^,%-G'
-    return SyntasticMake({ 'makeprg': makeprg, 'errorformat': errorformat })
+function s:ConfFlag()
+    if !empty(g:syntastic_javascript_jsl_conf)
+        return "-conf " . g:syntastic_javascript_jsl_conf
+    endif
+
+    return ""
+endfunction
+
+function! SyntaxCheckers_javascript_jsl_IsAvailable()
+    return executable('jsl')
 endfunction
 
+function! SyntaxCheckers_javascript_jsl_GetLocList()
+    let makeprg = syntastic#makeprg#build({
+        \ 'exe': 'jsl',
+        \ 'args': s:ConfFlag() . " -nologo -nofilelisting -nosummary -nocontext -process",
+        \ 'filetype': 'javascript',
+        \ 'subchecker': 'jsl' })
+
+    let errorformat =
+        \ '%W%f(%l): lint warning: %m,'.
+        \ '%-Z%p^,'.
+        \ '%W%f(%l): warning: %m,'.
+        \ '%-Z%p^,'.
+        \ '%E%f(%l): SyntaxError: %m,'.
+        \ '%-Z%p^,'.
+        \ '%-G'
+
+    return SyntasticMake({
+        \ 'makeprg': makeprg,
+        \ 'errorformat': errorformat })
+endfunction
+
+call g:SyntasticRegistry.CreateAndRegisterChecker({
+    \ 'filetype': 'javascript',
+    \ 'name': 'jsl'})
+
--- a/config/.vim/syntax_checkers/javascript/jslint.vim	Thu Sep 05 16:23:33 2013 +0200
+++ b/config/.vim/syntax_checkers/javascript/jslint.vim	Wed Nov 06 14:33:18 2013 +0100
@@ -10,22 +10,44 @@
 "
 "Tested with jslint 0.1.4.
 "============================================================================
+if exists("g:loaded_syntastic_javascript_jslint_checker")
+    finish
+endif
+let g:loaded_syntastic_javascript_jslint_checker=1
+
 if !exists("g:syntastic_javascript_jslint_conf")
     let g:syntastic_javascript_jslint_conf = "--white --undef --nomen --regexp --plusplus --bitwise --newcap --sloppy --vars"
 endif
 
-function! SyntaxCheckers_javascript_HighlightTerm(error)
+function! SyntaxCheckers_javascript_jslint_IsAvailable()
+    return executable('jslint')
+endfunction
+
+function! SyntaxCheckers_javascript_jslint_HighlightTerm(error)
     let unexpected = matchstr(a:error['text'], 'Expected.*and instead saw \'\zs.*\ze\'')
     if len(unexpected) < 1 | return '' | end
     return '\V'.split(unexpected, "'")[1]
 endfunction
 
-function! SyntaxCheckers_javascript_GetLocList()
-    let makeprg = "jslint " . g:syntastic_javascript_jslint_conf . " " . shellescape(expand('%'))
-    let errorformat='%E %##%n %m,%-Z%.%#Line %l\, Pos %c,%-G%.%#'
-    let errors = SyntasticMake({ 'makeprg': makeprg, 'errorformat': errorformat, 'defaults': {'bufnr': bufnr("")} })
-    call SyntasticHighlightErrors(errors, function('SyntaxCheckers_javascript_HighlightTerm'))
+function! SyntaxCheckers_javascript_jslint_GetLocList()
+    let makeprg = syntastic#makeprg#build({
+        \ 'exe': 'jslint',
+        \ 'args': g:syntastic_javascript_jslint_conf,
+        \ 'filetype': 'javascript',
+        \ 'subchecker': 'jslint' })
 
-    return errors
+    let errorformat =
+        \ '%E %##%n %m,'.
+        \ '%-Z%.%#Line %l\, Pos %c,'.
+        \ '%-G%.%#'
+
+    return SyntasticMake({
+        \ 'makeprg': makeprg,
+        \ 'errorformat': errorformat,
+        \ 'defaults': {'bufnr': bufnr("")} })
 endfunction
 
+call g:SyntasticRegistry.CreateAndRegisterChecker({
+    \ 'filetype': 'javascript',
+    \ 'name': 'jslint'})
+
--- a/config/.vim/syntax_checkers/json.vim	Thu Sep 05 16:23:33 2013 +0200
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,23 +0,0 @@
-"============================================================================
-"File:        json.vim
-"Description: Figures out which json syntax checker (if any) to load
-"             from the json directory.
-"Maintainer:  Miller Medeiros <contact at millermedeiros dot com>
-"License:     This program is free software. It comes without any warranty,
-"             to the extent permitted by applicable law. You can redistribute
-"             it and/or modify it under the terms of the Do What The Fuck You
-"             Want To Public License, Version 2, as published by Sam Hocevar.
-"             See http://sam.zoy.org/wtfpl/COPYING for more details.
-"
-" Use g:syntastic_json_checker option to specify which jsonlint executable
-" should be used (see below for a list of supported checkers).
-" If g:syntastic_json_checker is not set, just use the first syntax
-" checker that we find installed.
-"============================================================================
-if exists("loaded_json_syntax_checker")
-    finish
-endif
-let loaded_json_syntax_checker = 1
-
-let s:supported_checkers = ["jsonlint", "jsonval"]
-call SyntasticLoadChecker(s:supported_checkers)
--- a/config/.vim/syntax_checkers/json/jsonlint.vim	Thu Sep 05 16:23:33 2013 +0200
+++ b/config/.vim/syntax_checkers/json/jsonlint.vim	Wed Nov 06 14:33:18 2013 +0100
@@ -9,8 +9,35 @@
 "             See http://sam.zoy.org/wtfpl/COPYING for more details.
 "============================================================================
 
-function! SyntaxCheckers_json_GetLocList()
-    let makeprg = 'jsonlint ' . shellescape(expand("%")) . ' --compact'
-    let errorformat = '%ELine %l:%c,%Z\\s%#Reason: %m,%C%.%#,%f: line %l\, col %c\, %m,%-G%.%#'
-    return SyntasticMake({ 'makeprg': makeprg, 'errorformat': errorformat, 'defaults': {'bufnr': bufnr('')} })
+if exists("g:loaded_syntastic_json_jsonlint_checker")
+    finish
+endif
+let g:loaded_syntastic_json_jsonlint_checker=1
+
+function! SyntaxCheckers_json_jsonlint_IsAvailable()
+    return executable('jsonlint')
 endfunction
+
+function! SyntaxCheckers_json_jsonlint_GetLocList()
+    let makeprg = syntastic#makeprg#build({
+        \ 'exe': 'jsonlint',
+        \ 'post_args': '--compact',
+        \ 'filetype': 'json',
+        \ 'subchecker': 'jsonlint' })
+
+    let errorformat =
+        \ '%ELine %l:%c,'.
+        \ '%Z\\s%#Reason: %m,'.
+        \ '%C%.%#,'.
+        \ '%f: line %l\, col %c\, %m,'.
+        \ '%-G%.%#'
+
+    return SyntasticMake({
+        \ 'makeprg': makeprg,
+        \ 'errorformat': errorformat,
+        \ 'defaults': {'bufnr': bufnr('')} })
+endfunction
+
+call g:SyntasticRegistry.CreateAndRegisterChecker({
+    \ 'filetype': 'json',
+    \ 'name': 'jsonlint'})
--- a/config/.vim/syntax_checkers/json/jsonval.vim	Thu Sep 05 16:23:33 2013 +0200
+++ b/config/.vim/syntax_checkers/json/jsonval.vim	Wed Nov 06 14:33:18 2013 +0100
@@ -9,9 +9,32 @@
 "             See http://sam.zoy.org/wtfpl/COPYING for more details.
 "============================================================================
 
-function! SyntaxCheckers_json_GetLocList()
+if exists("g:loaded_syntastic_json_jsonval_checker")
+    finish
+endif
+let g:loaded_syntastic_json_jsonval_checker=1
+
+function! SyntaxCheckers_json_jsonval_IsAvailable()
+    return executable('jsonval')
+endfunction
+
+function! SyntaxCheckers_json_jsonval_GetLocList()
     " based on https://gist.github.com/1196345
-    let makeprg = 'jsonval '. shellescape(expand('%'))
-    let errorformat = '%E%f:\ %m\ at\ line\ %l,%-G%.%#'
-    return SyntasticMake({ 'makeprg': makeprg, 'errorformat': errorformat, 'defaults': {'bufnr': bufnr('')} })
+    let makeprg = syntastic#makeprg#build({
+        \ 'exe': 'jsonval',
+        \ 'filetype': 'json',
+        \ 'subchecker': 'jsonval' })
+
+    let errorformat =
+        \ '%E%f:\ %m\ at\ line\ %l,' .
+        \ '%-G%.%#'
+
+    return SyntasticMake({
+        \ 'makeprg': makeprg,
+        \ 'errorformat': errorformat,
+        \ 'defaults': {'bufnr': bufnr('')} })
 endfunction
+
+call g:SyntasticRegistry.CreateAndRegisterChecker({
+    \ 'filetype': 'json',
+    \ 'name': 'jsonval'})
--- a/config/.vim/syntax_checkers/less.vim	Thu Sep 05 16:23:33 2013 +0200
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,38 +0,0 @@
-"============================================================================
-"File:        less.vim
-"Description: Syntax checking plugin for syntastic.vim
-"Maintainer:  Julien Blanchard <julien at sideburns dot eu>
-"License:     This program is free software. It comes without any warranty,
-"             to the extent permitted by applicable law. You can redistribute
-"             it and/or modify it under the terms of the Do What The Fuck You
-"             Want To Public License, Version 2, as published by Sam Hocevar.
-"             See http://sam.zoy.org/wtfpl/COPYING for more details.
-"
-"============================================================================
-if exists("loaded_less_syntax_checker")
-    finish
-endif
-let loaded_less_syntax_checker = 1
-
-"bail if the user doesnt have the lessc binary installed
-if !executable("lessc")
-    finish
-endif
-
-if !exists("g:syntastic_less_options")
-    let g:syntastic_less_options = "--no-color"
-endif
-
-function! SyntaxCheckers_less_GetLocList()
-    let makeprg = 'lessc '. g:syntastic_less_options .' '.  shellescape(expand('%')) . ' /dev/null'
-
-    "lessc >= 1.2
-    let errorformat = '%m in %f:%l:%c'
-    "lessc < 1.2
-    let errorformat .= ', Syntax %trror on line %l in %f,Syntax %trror on line %l,! Syntax %trror: on line %l: %m,%-G%.%#'
-
-    return SyntasticMake({ 'makeprg': makeprg,
-                         \ 'errorformat': errorformat,
-                         \ 'defaults': {'bufnr': bufnr(""), 'text': "Syntax error"} })
-endfunction
-
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/config/.vim/syntax_checkers/less/less-lint.coffee	Wed Nov 06 14:33:18 2013 +0100
@@ -0,0 +1,41 @@
+#!/usr/bin/env node
+
+fs = require 'fs'
+less = require 'less'
+args = process.argv.slice(1)
+options = {}
+
+args = args.filter (arg) ->
+    match = arg.match(/^-I(.+)$/)
+    if match
+        options.paths.push(match[1]);
+        return false
+
+    match = arg.match(/^--?([a-z][\-0-9a-z]*)(?:=([^\s]+))?$/i)
+    if match
+        arg = match[1]
+    else
+        return arg
+
+    switch arg
+        when 'strict-imports' then options.strictImports = true
+        when 'include-path'
+            options.paths = match[2].split(if os.type().match(/Windows/) then ';' else ':')
+                .map (p) ->
+                    if p
+                        return path.resolve(process.cwd(), p)
+        when 'O0' then options.optimization = 0
+        when 'O1' then options.optimization = 1
+        when 'O2' then options.optimization = 2
+
+options.filename = args[1]
+
+parser = new(less.Parser) options
+
+fs.readFile(options.filename, 'utf-8', (err,data) ->
+    parser.parse(data, (err, tree) ->
+        if err
+            less.writeError err
+            process.exit(1)
+    )
+)
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/config/.vim/syntax_checkers/less/less-lint.js	Wed Nov 06 14:33:18 2013 +0100
@@ -0,0 +1,57 @@
+// Generated by CoffeeScript 1.3.3
+(function() {
+  var args, fs, less, options, parser;
+
+  fs = require('fs');
+
+  less = require('less');
+
+  args = process.argv.slice(1);
+
+  options = {};
+
+  args = args.filter(function(arg) {
+    var match;
+    match = arg.match(/^-I(.+)$/);
+    if (match) {
+      options.paths.push(match[1]);
+      return false;
+    }
+    match = arg.match(/^--?([a-z][\-0-9a-z]*)(?:=([^\s]+))?$/i);
+    if (match) {
+      arg = match[1];
+    } else {
+      return arg;
+    }
+    switch (arg) {
+      case 'strict-imports':
+        return options.strictImports = true;
+      case 'include-path':
+        return options.paths = match[2].split(os.type().match(/Windows/) ? ';' : ':').map(function(p) {
+          if (p) {
+            return path.resolve(process.cwd(), p);
+          }
+        });
+      case 'O0':
+        return options.optimization = 0;
+      case 'O1':
+        return options.optimization = 1;
+      case 'O2':
+        return options.optimization = 2;
+    }
+  });
+
+  options.filename = args[1];
+
+  parser = new less.Parser(options);
+
+  fs.readFile(options.filename, 'utf-8', function(err, data) {
+    return parser.parse(data, function(err, tree) {
+      if (err) {
+        less.writeError(err);
+        return process.exit(1);
+      }
+    });
+  });
+
+}).call(this);
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/config/.vim/syntax_checkers/less/lessc.vim	Wed Nov 06 14:33:18 2013 +0100
@@ -0,0 +1,61 @@
+"============================================================================
+"File:        less.vim
+"Description: Syntax checking plugin for syntastic.vim
+"Maintainer:  Julien Blanchard <julien at sideburns dot eu>
+"License:     This program is free software. It comes without any warranty,
+"             to the extent permitted by applicable law. You can redistribute
+"             it and/or modify it under the terms of the Do What The Fuck You
+"             Want To Public License, Version 2, as published by Sam Hocevar.
+"             See http://sam.zoy.org/wtfpl/COPYING for more details.
+"
+"============================================================================
+
+" To send additional options to less use the variable g:syntastic_less_options.
+" The default is
+"   let g:syntastic_less_options = "--no-color"
+"
+" To use less-lint instead of less set the variable
+" g:syntastic_less_use_less_lint.
+
+if exists("g:loaded_syntastic_less_lessc_checker")
+    finish
+endif
+let g:loaded_syntastic_less_lessc_checker=1
+
+if !exists("g:syntastic_less_options")
+    let g:syntastic_less_options = "--no-color"
+endif
+
+if !exists("g:syntastic_less_use_less_lint")
+    let g:syntastic_less_use_less_lint = 0
+endif
+
+if g:syntastic_less_use_less_lint
+    let s:check_file = 'node ' . expand('<sfile>:p:h') . '/less-lint.js'
+else
+    let s:check_file = 'lessc'
+end
+
+function! SyntaxCheckers_less_lessc_IsAvailable()
+    return executable('lessc')
+endfunction
+
+function! SyntaxCheckers_less_lessc_GetLocList()
+    let makeprg = syntastic#makeprg#build({
+        \ 'exe': s:check_file,
+        \ 'args': g:syntastic_less_options,
+        \ 'tail': syntastic#util#DevNull(),
+        \ 'filetype': 'less',
+        \ 'subchecker': 'lessc' })
+
+    let errorformat = '%m in %f:%l:%c'
+
+    return SyntasticMake({
+        \ 'makeprg': makeprg,
+        \ 'errorformat': errorformat,
+        \ 'defaults': {'bufnr': bufnr(""), 'text': "Syntax error"} })
+endfunction
+
+call g:SyntasticRegistry.CreateAndRegisterChecker({
+    \ 'filetype': 'less',
+    \ 'name': 'lessc'})
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/config/.vim/syntax_checkers/lisp/clisp.vim	Wed Nov 06 14:33:18 2013 +0100
@@ -0,0 +1,47 @@
+"============================================================================
+"File:        lisp.vim
+"Description: Syntax checking plugin for syntastic.vim
+"Maintainer:  Karl Yngve Lervåg <karl.yngve@lervag.net>
+"License:     This program is free software. It comes without any warranty,
+"             to the extent permitted by applicable law. You can redistribute
+"             it and/or modify it under the terms of the Do What The Fuck You
+"             Want To Public License, Version 2, as published by Sam Hocevar.
+"             See http://sam.zoy.org/wtfpl/COPYING for more details.
+"
+"============================================================================
+if exists("g:loaded_syntastic_lisp_clisp_checker")
+    finish
+endif
+let g:loaded_syntastic_lisp_clisp_checker=1
+
+function! SyntaxCheckers_lisp_clisp_IsAvailable()
+    return executable("clisp")
+endfunction
+
+function! SyntaxCheckers_lisp_clisp_GetLocList()
+    let makeprg = syntastic#makeprg#build({
+        \ 'exe': 'clisp',
+        \ 'args': '-q -c',
+        \ 'tail': '-o /tmp/clisp-vim-compiled-file',
+        \ 'filetype': 'lisp',
+        \ 'subchecker': 'clisp' })
+
+    let errorformat  =
+        \ '%-G;%.%#,' .
+        \ '%W%>WARNING:%.%#line %l : %m,' .
+        \ '%Z  %#%m,' .
+        \ '%W%>WARNING:%.%#lines %l..%\d\# : %m,' .
+        \ '%Z  %#%m,' .
+        \ '%E%>The following functions were %m,' .
+        \ '%Z %m,' .
+        \ '%-G%.%#'
+
+    return SyntasticMake({
+        \ 'makeprg': makeprg,
+        \ 'errorformat': errorformat,
+        \ 'defaults': {'bufnr': bufnr('')} })
+endfunction
+
+call g:SyntasticRegistry.CreateAndRegisterChecker({
+    \ 'filetype': 'lisp',
+    \ 'name': 'clisp'})
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/config/.vim/syntax_checkers/llvm/llvm.vim	Wed Nov 06 14:33:18 2013 +0100
@@ -0,0 +1,38 @@
+"============================================================================
+"File:        llvm.vim
+"Description: Syntax checking plugin for syntastic.vim
+"Maintainer:  Andrew Kelley <superjoe30@gmail.com>
+"License:     This program is free software. It comes without any warranty,
+"             to the extent permitted by applicable law. You can redistribute
+"             it and/or modify it under the terms of the Do What The Fuck You
+"             Want To Public License, Version 2, as published by Sam Hocevar.
+"             See http://sam.zoy.org/wtfpl/COPYING for more details.
+"
+"============================================================================
+if exists("g:loaded_syntastic_llvm_llvm_checker")
+    finish
+endif
+let g:loaded_syntastic_llvm_llvm_checker=1
+
+function! SyntaxCheckers_llvm_llvm_IsAvailable()
+    return executable("llc")
+endfunction
+
+function! SyntaxCheckers_llvm_llvm_GetLocList()
+    let makeprg = syntastic#makeprg#build({
+        \ 'exe': 'llc',
+        \ 'args': syntastic#c#GetNullDevice(),
+        \ 'filetype': 'llvm',
+        \ 'subchecker': 'llvm' })
+
+    let errorformat = 'llc: %f:%l:%c: %trror: %m'
+
+    return SyntasticMake({
+        \ 'makeprg': makeprg,
+        \ 'errorformat': errorformat })
+endfunction
+
+call g:SyntasticRegistry.CreateAndRegisterChecker({
+    \ 'filetype': 'llvm',
+    \ 'name': 'llvm'})
+
--- a/config/.vim/syntax_checkers/lua.vim	Thu Sep 05 16:23:33 2013 +0200
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,58 +0,0 @@
-"============================================================================
-"File:        lua.vim
-"Description: Syntax checking plugin for syntastic.vim
-"Maintainer:  Gregor Uhlenheuer <kongo2002 at gmail dot com>
-"License:     This program is free software. It comes without any warranty,
-"             to the extent permitted by applicable law. You can redistribute
-"             it and/or modify it under the terms of the Do What The Fuck You
-"             Want To Public License, Version 2, as published by Sam Hocevar.
-"             See http://sam.zoy.org/wtfpl/COPYING for more details.
-"
-"============================================================================
-
-if exists('loaded_lua_syntax_checker')
-    finish
-endif
-let loaded_lua_syntax_checker = 1
-
-" check if the lua compiler is installed
-if !executable('luac')
-    finish
-endif
-
-function! SyntaxCheckers_lua_Term(pos)
-    let near = matchstr(a:pos['text'], "near '[^']\\+'")
-    let result = ''
-    if len(near) > 0
-        let near = split(near, "'")[1]
-        if near == '<eof>'
-            let p = getpos('$')
-            let a:pos['lnum'] = p[1]
-            let a:pos['col'] = p[2]
-            let result = '\%'.p[2].'c'
-        else
-            let result = '\V'.near
-        endif
-        let open = matchstr(a:pos['text'], "(to close '[^']\\+' at line [0-9]\\+)")
-        if len(open) > 0
-            let oline = split(open, "'")[1:2]
-            let line = 0+strpart(oline[1], 9)
-            call matchadd('SpellCap', '\%'.line.'l\V'.oline[0])
-        endif
-    endif
-    return result
-endfunction
-
-function! SyntaxCheckers_lua_GetLocList()
-    let makeprg = 'luac -p ' . shellescape(expand('%'))
-    let errorformat =  'luac: %#%f:%l: %m'
-
-    let loclist = SyntasticMake({ 'makeprg': makeprg,
-                                \ 'errorformat': errorformat,
-                                \ 'defaults': { 'bufnr': bufnr(''), 'type': 'E' } })
-
-    call SyntasticHighlightErrors(loclist, function("SyntaxCheckers_lua_Term"))
-
-    return loclist
-endfunction
-
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/config/.vim/syntax_checkers/lua/luac.vim	Wed Nov 06 14:33:18 2013 +0100
@@ -0,0 +1,64 @@
+"============================================================================
+"File:        lua.vim
+"Description: Syntax checking plugin for syntastic.vim
+"Maintainer:  Gregor Uhlenheuer <kongo2002 at gmail dot com>
+"License:     This program is free software. It comes without any warranty,
+"             to the extent permitted by applicable law. You can redistribute
+"             it and/or modify it under the terms of the Do What The Fuck You
+"             Want To Public License, Version 2, as published by Sam Hocevar.
+"             See http://sam.zoy.org/wtfpl/COPYING for more details.
+"
+"============================================================================
+
+if exists("g:loaded_syntastic_lua_luac_checker")
+    finish
+endif
+let g:loaded_syntastic_lua_luac_checker=1
+
+function! SyntaxCheckers_lua_luac_IsAvailable()
+    return executable('luac')
+endfunction
+
+function! SyntaxCheckers_lua_luac_GetHighlightRegex(pos)
+    let near = matchstr(a:pos['text'], "near '[^']\\+'")
+    let result = ''
+    if len(near) > 0
+        let near = split(near, "'")[1]
+        if near == '<eof>'
+            let p = getpos('$')
+            let a:pos['lnum'] = p[1]
+            let a:pos['col'] = p[2]
+            let result = '\%'.p[2].'c'
+        else
+            let result = '\V'.near
+        endif
+        let open = matchstr(a:pos['text'], "(to close '[^']\\+' at line [0-9]\\+)")
+        if len(open) > 0
+            let oline = split(open, "'")[1:2]
+            let line = 0+strpart(oline[1], 9)
+            call matchadd('SpellCap', '\%'.line.'l\V'.oline[0])
+        endif
+    endif
+    return result
+endfunction
+
+
+function! SyntaxCheckers_lua_luac_GetLocList()
+    let makeprg = syntastic#makeprg#build({
+        \ 'exe': 'luac',
+        \ 'args': '-p',
+        \ 'filetype': 'lua',
+        \ 'subchecker': 'luac' })
+
+    let errorformat =  'luac: %#%f:%l: %m'
+
+    return SyntasticMake({
+        \ 'makeprg': makeprg,
+        \ 'errorformat': errorformat,
+        \ 'defaults': { 'bufnr': bufnr(''), 'type': 'E' } })
+
+endfunction
+
+call g:SyntasticRegistry.CreateAndRegisterChecker({
+    \ 'filetype': 'lua',
+    \ 'name': 'luac'})
--- a/config/.vim/syntax_checkers/matlab.vim	Thu Sep 05 16:23:33 2013 +0200
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,28 +0,0 @@
-"============================================================================
-"File:        matlab.vim
-"Description: Syntax checking plugin for syntastic.vim
-"Maintainer:  Jason Graham <jason at the-graham dot com>
-"License:     This program is free software. It comes without any warranty,
-"             to the extent permitted by applicable law. You can redistribute
-"             it and/or modify it under the terms of the Do What The Fuck You
-"             Want To Public License, Version 2, as published by Sam Hocevar.
-"             See http://sam.zoy.org/wtfpl/COPYING for more details.
-"
-"============================================================================
-
-if exists("loaded_matlab_syntax_checker")
-    finish
-endif
-let loaded_matlab_syntax_checker = 1
-
-"bail if the user doesn't have mlint installed
-if !executable("mlint")
-    finish
-endif
-
-function! SyntaxCheckers_matlab_GetLocList()
-    let makeprg = 'mlint -id $* '.shellescape(expand('%'))
-    let errorformat = 'L %l (C %c): %*[a-zA-Z0-9]: %m,L %l (C %c-%*[0-9]): %*[a-zA-Z0-9]: %m'
-    return SyntasticMake({ 'makeprg': makeprg, 'errorformat': errorformat, 'defaults': {'bufnr': bufnr("")} })
-endfunction
-
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/config/.vim/syntax_checkers/matlab/mlint.vim	Wed Nov 06 14:33:18 2013 +0100
@@ -0,0 +1,41 @@
+"============================================================================
+"File:        matlab.vim
+"Description: Syntax checking plugin for syntastic.vim
+"Maintainer:  Jason Graham <jason at the-graham dot com>
+"License:     This program is free software. It comes without any warranty,
+"             to the extent permitted by applicable law. You can redistribute
+"             it and/or modify it under the terms of the Do What The Fuck You
+"             Want To Public License, Version 2, as published by Sam Hocevar.
+"             See http://sam.zoy.org/wtfpl/COPYING for more details.
+"
+"============================================================================
+
+if exists("g:loaded_syntastic_matlab_mlint_checker")
+    finish
+endif
+let g:loaded_syntastic_matlab_mlint_checker=1
+
+function! SyntaxCheckers_matlab_mlint_IsAvailable()
+    return executable("mlint")
+endfunction
+
+function! SyntaxCheckers_matlab_mlint_GetLocList()
+    let makeprg = syntastic#makeprg#build({
+        \ 'exe': 'mlint',
+        \ 'args': '-id $*',
+        \ 'filetype': 'matlab',
+        \ 'subchecker': 'mlint' })
+
+    let errorformat =
+        \ 'L %l (C %c): %*[a-zA-Z0-9]: %m,'.
+        \ 'L %l (C %c-%*[0-9]): %*[a-zA-Z0-9]: %m'
+
+    return SyntasticMake({
+        \ 'makeprg': makeprg,
+        \ 'errorformat': errorformat,
+        \ 'defaults': {'bufnr': bufnr("")} })
+endfunction
+
+call g:SyntasticRegistry.CreateAndRegisterChecker({
+    \ 'filetype': 'matlab',
+    \ 'name': 'mlint'})
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/config/.vim/syntax_checkers/nasm/nasm.vim	Wed Nov 06 14:33:18 2013 +0100
@@ -0,0 +1,38 @@
+"============================================================================
+"File:        nasm.vim
+"Description: Syntax checking plugin for syntastic.vim
+"Maintainer:  HÃ¥vard Pettersson <haavard.pettersson at gmail dot com>
+"License:     This program is free software. It comes without any warranty,
+"             to the extent permitted by applicable law. You can redistribute
+"             it and/or modify it under the terms of the Do What The Fuck You
+"             Want To Public License, Version 2, as published by Sam Hocevar.
+"             See http://sam.zoy.org/wtfpl/COPYING for more details.
+"
+"============================================================================
+if exists("g:loaded_syntastic_nasm_nasm_checker")
+    finish
+endif
+let g:loaded_syntastic_nasm_nasm_checker=1
+
+function! SyntaxCheckers_nasm_nasm_IsAvailable()
+    return executable("nasm")
+endfunction
+
+function! SyntaxCheckers_nasm_nasm_GetLocList()
+    let wd = syntastic#util#shescape(expand("%:p:h") . "/")
+    let makeprg = syntastic#makeprg#build({
+        \ 'exe': 'nasm',
+        \ 'args': '-X gnu -f elf -I ' . wd . ' ' . syntastic#c#GetNullDevice()
+        \ 'filetype': 'nasm',
+        \ 'subchecker': 'nasm' })
+
+    let errorformat = '%f:%l: %t%*[^:]: %m'
+
+    return SyntasticMake({
+        \ 'makeprg': makeprg,
+        \ 'errorformat': errorformat })
+endfunction
+
+call g:SyntasticRegistry.CreateAndRegisterChecker({
+    \ 'filetype': 'nasm',
+    \ 'name': 'nasm'})
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/config/.vim/syntax_checkers/nroff/mandoc.vim	Wed Nov 06 14:33:18 2013 +0100
@@ -0,0 +1,41 @@
+"============================================================================
+"File:        mandoc.vim
+"Description: Syntax checking plugin for syntastic.vim
+"Maintainer:  LCD 47 <lcd047 at gmail dot com>
+"License:     This program is free software. It comes without any warranty,
+"             to the extent permitted by applicable law. You can redistribute
+"             it and/or modify it under the terms of the Do What The Fuck You
+"             Want To Public License, Version 2, as published by Sam Hocevar.
+"             See http://sam.zoy.org/wtfpl/COPYING for more details.
+"
+"============================================================================
+if exists("g:loaded_syntastic_nroff_mandoc_checker")
+    finish
+endif
+let g:loaded_syntastic_nroff_mandoc_checker=1
+
+function! SyntaxCheckers_nroff_mandoc_IsAvailable()
+    return executable("mandoc")
+endfunction
+
+function! SyntaxCheckers_nroff_mandoc_GetLocList()
+    let makeprg = syntastic#makeprg#build({
+        \ 'exe': 'mandoc',
+        \ 'args': '-Tlint',
+        \ 'filetype': 'nroff',
+        \ 'subchecker': 'mandoc' })
+
+    let errorformat =
+        \ '%E%f:%l:%c: %tRROR: %m,' .
+        \ '%W%f:%l:%c: %tARNING: %m'
+
+    return SyntasticMake({
+        \ 'makeprg': makeprg,
+        \ 'errorformat': errorformat,
+        \ 'returns': [0, 2, 3, 4] })
+endfunction
+
+call g:SyntasticRegistry.CreateAndRegisterChecker({
+    \ 'filetype': 'nroff',
+    \ 'name': 'mandoc'})
+
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/config/.vim/syntax_checkers/objc/gcc.vim	Wed Nov 06 14:33:18 2013 +0100
@@ -0,0 +1,184 @@
+"============================================================================
+"File:        objc.vim
+"Description: Syntax checking plugin for syntastic.vim
+"Maintainer:  Gregor Uhlenheuer <kongo2002 at gmail dot com>
+"License:     This program is free software. It comes without any warranty,
+"             to the extent permitted by applicable law. You can redistribute
+"             it and/or modify it under the terms of the Do What The Fuck You
+"             Want To Public License, Version 2, as published by Sam Hocevar.
+"             See http://sam.zoy.org/wtfpl/COPYING for more details.
+"
+"============================================================================
+
+" In order to also check header files add this to your .vimrc:
+" (this usually creates a .gch file in your source directory)
+"
+"   let g:syntastic_objc_check_header = 1
+"
+" To disable the search of included header files after special
+" libraries like gtk and glib add this line to your .vimrc:
+"
+"   let g:syntastic_objc_no_include_search = 1
+"
+" To disable the include of the default include dirs (such as /usr/include)
+" add this line to your .vimrc:
+"
+"   let g:syntastic_objc_no_default_include_dirs = 1
+"
+" To enable header files being re-checked on every file write add the
+" following line to your .vimrc. Otherwise the header files are checked only
+" one time on initially loading the file.
+" In order to force syntastic to refresh the header includes simply
+" unlet b:syntastic_objc_includes. Then the header files are being re-checked on
+" the next file write.
+"
+"   let g:syntastic_objc_auto_refresh_includes = 1
+"
+" Alternatively you can set the buffer local variable b:syntastic_objc_cflags.
+" If this variable is set for the current buffer no search for additional
+" libraries is done. I.e. set the variable like this:
+"
+"   let b:syntastic_objc_cflags = ' -I/usr/include/libsoup-2.4'
+"
+" In order to add some custom include directories that should be added to the
+" gcc command line you can add those to the global variable
+" g:syntastic_objc_include_dirs. This list can be used like this:
+"
+"   let g:syntastic_objc_include_dirs = [ 'includes', 'headers' ]
+"
+" Moreover it is possible to add additional compiler options to the syntax
+" checking execution via the variable 'g:syntastic_objc_compiler_options':
+"
+"   let g:syntastic_objc_compiler_options = ' -ansi'
+"
+" Additionally the setting 'g:syntastic_objc_config_file' allows you to define a
+" file that contains additional compiler arguments like include directories or
+" CFLAGS. The file is expected to contain one option per line. If none is
+" given the filename defaults to '.syntastic_objc_config':
+"
+"   let g:syntastic_objc_config_file = '.config'
+"
+" Using the global variable 'g:syntastic_objc_remove_include_errors' you can
+" specify whether errors of files included via the g:syntastic_objc_include_dirs'
+" setting are removed from the result set:
+"
+"   let g:syntastic_objc_remove_include_errors = 1
+"
+" Use the variable 'g:syntastic_objc_errorformat' to override the default error
+" format:
+"
+"   let g:syntastic_objc_errorformat = '%f:%l:%c: %trror: %m'
+"
+" Set your compiler executable with e.g. (defaults to gcc)
+"
+"   let g:syntastic_objc_compiler = 'clang'
+
+if exists('g:loaded_syntastic_objc_gcc_checker')
+    finish
+endif
+let g:loaded_syntastic_objc_gcc_checker = 1
+
+if !exists('g:syntastic_objc_compiler')
+    let g:syntastic_objc_compiler = 'gcc'
+endif
+
+function! SyntaxCheckers_objc_gcc_IsAvailable()
+    return executable(g:syntastic_objc_compiler)
+endfunction
+
+let s:save_cpo = &cpo
+set cpo&vim
+
+if !exists('g:syntastic_objc_compiler_options')
+    let g:syntastic_objc_compiler_options = '-std=gnu99'
+endif
+
+if !exists('g:syntastic_objc_config_file')
+    let g:syntastic_objc_config_file = '.syntastic_objc_config'
+endif
+
+function! SyntaxCheckers_objc_gcc_GetLocList()
+    let makeprg = g:syntastic_objc_compiler . ' -x objective-c -fsyntax-only -lobjc'
+    let errorformat =
+        \ '%-G%f:%s:,' .
+        \ '%-G%f:%l: %#error: %#(Each undeclared identifier is reported only%.%#,' .
+        \ '%-G%f:%l: %#error: %#for each function it appears%.%#,' .
+        \ '%-GIn file included%.%#,'.
+        \ '%-G %#from %f:%l\,,' .
+        \ '%f:%l:%c: %trror: %m,' .
+        \ '%f:%l:%c: %tarning: %m,' .
+        \ '%f:%l:%c: %m,' .
+        \ '%f:%l: %trror: %m,' .
+        \ '%f:%l: %tarning: %m,' .
+        \ '%f:%l: %m'
+
+    if exists('g:syntastic_objc_errorformat')
+        let errorformat = g:syntastic_objc_errorformat
+    endif
+
+    " add optional user-defined compiler options
+    let makeprg .= g:syntastic_objc_compiler_options
+
+    let makeprg .= ' ' . syntastic#util#shexpand('%') .
+               \ ' ' . syntastic#c#GetIncludeDirs('objc')
+
+    " determine whether to parse header files as well
+    if expand('%') =~? '\.h$'
+        if exists('g:syntastic_objc_check_header')
+            let makeprg = g:syntastic_objc_compiler .
+                        \ ' -x objective-c-header ' .
+                        \ ' -c ' . syntastic#util#shexpand('%') .
+                        \ ' ' . g:syntastic_objc_compiler_options .
+                        \ ' ' . syntastic#c#GetIncludeDirs('objc')
+        else
+            return []
+        endif
+    endif
+
+    " check if the user manually set some cflags
+    if !exists('b:syntastic_objc_cflags')
+        " check whether to search for include files at all
+        if !exists('g:syntastic_objc_no_include_search') ||
+                    \ g:syntastic_objc_no_include_search != 1
+            " refresh the include file search if desired
+            if exists('g:syntastic_objc_auto_refresh_includes') &&
+                        \ g:syntastic_objc_auto_refresh_includes != 0
+                let makeprg .= syntastic#c#SearchHeaders()
+            else
+                " search for header includes if not cached already
+                if !exists('b:syntastic_objc_includes')
+                    let b:syntastic_objc_includes = syntastic#c#SearchHeaders()
+                endif
+                let makeprg .= b:syntastic_objc_includes
+            endif
+        endif
+    else
+        " use the user-defined cflags
+        let makeprg .= b:syntastic_objc_cflags
+    endif
+
+    " add optional config file parameters
+    let makeprg .= ' ' . syntastic#c#ReadConfig(g:syntastic_objc_config_file)
+
+    " process makeprg
+    let errors = SyntasticMake({ 'makeprg': makeprg,
+                \ 'errorformat': errorformat })
+
+    " filter the processed errors if desired
+    if exists('g:syntastic_objc_remove_include_errors') &&
+                \ g:syntastic_objc_remove_include_errors != 0
+        return filter(errors,
+                    \ 'has_key(v:val, "bufnr") && v:val["bufnr"]=='.bufnr(''))
+    else
+        return errors
+    endif
+endfunction
+
+call g:SyntasticRegistry.CreateAndRegisterChecker({
+    \ 'filetype': 'objc',
+    \ 'name': 'gcc'})
+
+let &cpo = s:save_cpo
+unlet s:save_cpo
+
+" vim: set et sts=4 sw=4:
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/config/.vim/syntax_checkers/objc/oclint.vim	Wed Nov 06 14:33:18 2013 +0100
@@ -0,0 +1,36 @@
+"============================================================================
+"File:        oclint.vim
+"Description: Syntax checking plugin for syntastic.vim
+"Maintainer:  "UnCO" Lin <undercooled aT lavabit com>
+"License:     This program is free software. It comes without any warranty,
+"             to the extent permitted by applicable law. You can redistribute
+"             it and/or modify it under the terms of the Do What The Fuck You
+"             Want To Public License, Version 2, as published by Sam Hocevar.
+"             See http://sam.zoy.org/wtfpl/COPYING for more details.
+"============================================================================
+"
+" The setting 'g:syntastic_oclint_config_file' allows you to define a file
+" that contains additional compiler arguments like include directories or
+" CFLAGS. The file is expected to contain one option per line. If none is
+" given the filename defaults to '.syntastic_oclint_config':
+"
+"   let g:syntastic_oclint_config_file = '.config'
+
+if exists("g:loaded_syntastic_objc_oclint_checker")
+    finish
+endif
+let g:loaded_syntastic_objc_oclint_checker = 1
+
+function! SyntaxCheckers_objc_oclint_IsAvailable()
+    return SyntaxCheckers_c_oclint_IsAvailable()
+endfunction
+
+function! SyntaxCheckers_objc_oclint_GetLocList()
+    return SyntaxCheckers_c_oclint_GetLocList()
+endfunction
+
+call g:SyntasticRegistry.CreateAndRegisterChecker({
+    \ 'filetype': 'objc',
+    \ 'name': 'oclint'})
+
+runtime! syntax_checkers/c/*.vim
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/config/.vim/syntax_checkers/objc/ycm.vim	Wed Nov 06 14:33:18 2013 +0100
@@ -0,0 +1,34 @@
+"============================================================================
+"File:        ycm.vim
+"Description: Syntax checking plugin for syntastic.vim
+"Maintainer:  Val Markovic <val at markovic dot io>
+"License:     This program is free software. It comes without any warranty,
+"             to the extent permitted by applicable law. You can redistribute
+"             it and/or modify it under the terms of the Do What The Fuck You
+"             Want To Public License, Version 2, as published by Sam Hocevar.
+"             See http://sam.zoy.org/wtfpl/COPYING for more details.
+"
+"============================================================================
+
+if exists("g:loaded_syntastic_objc_ycm_checker")
+    finish
+endif
+let g:loaded_syntastic_objc_ycm_checker = 1
+
+runtime! syntax_checkers/c/*.vim
+
+function! SyntaxCheckers_objc_ycm_IsAvailable()
+    return SyntaxCheckers_c_ycm_IsAvailable()
+endfunction
+
+if !exists('g:loaded_youcompleteme')
+    finish
+endif
+
+function! SyntaxCheckers_objc_ycm_GetLocList()
+    return SyntaxCheckers_c_ycm_GetLocList()
+endfunction
+
+call g:SyntasticRegistry.CreateAndRegisterChecker({
+    \ 'filetype': 'objc',
+    \ 'name': 'ycm'})
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/config/.vim/syntax_checkers/objcpp/gcc.vim	Wed Nov 06 14:33:18 2013 +0100
@@ -0,0 +1,184 @@
+"============================================================================
+"File:        objcpp.vim
+"Description: Syntax checking plugin for syntastic.vim
+"Maintainer:  Gregor Uhlenheuer <kongo2002 at gmail dot com>
+"License:     This program is free software. It comes without any warranty,
+"             to the extent permitted by applicable law. You can redistribute
+"             it and/or modify it under the terms of the Do What The Fuck You
+"             Want To Public License, Version 2, as published by Sam Hocevar.
+"             See http://sam.zoy.org/wtfpl/COPYING for more details.
+"
+"============================================================================
+
+" In order to also check header files add this to your .vimrc:
+" (this usually creates a .gch file in your source directory)
+"
+"   let g:syntastic_objcpp_check_header = 1
+"
+" To disable the search of included header files after special
+" libraries like gtk and glib add this line to your .vimrc:
+"
+"   let g:syntastic_objcpp_no_include_search = 1
+"
+" To disable the include of the default include dirs (such as /usr/include)
+" add this line to your .vimrc:
+"
+"   let g:syntastic_objcpp_no_default_include_dirs = 1
+"
+" To enable header files being re-checked on every file write add the
+" following line to your .vimrc. Otherwise the header files are checked only
+" one time on initially loading the file.
+" In order to force syntastic to refresh the header includes simply
+" unlet b:syntastic_objcpp_includes. Then the header files are being re-checked on
+" the next file write.
+"
+"   let g:syntastic_objcpp_auto_refresh_includes = 1
+"
+" Alternatively you can set the buffer local variable b:syntastic_objcpp_cflags.
+" If this variable is set for the current buffer no search for additional
+" libraries is done. I.e. set the variable like this:
+"
+"   let b:syntastic_objcpp_cflags = ' -I/usr/include/libsoup-2.4'
+"
+" In order to add some custom include directories that should be added to the
+" gcc command line you can add those to the global variable
+" g:syntastic_objcpp_include_dirs. This list can be used like this:
+"
+"   let g:syntastic_objcpp_include_dirs = [ 'includes', 'headers' ]
+"
+" Moreover it is possible to add additional compiler options to the syntax
+" checking execution via the variable 'g:syntastic_objcpp_compiler_options':
+"
+"   let g:syntastic_objcpp_compiler_options = ' -ansi'
+"
+" Additionally the setting 'g:syntastic_objcpp_config_file' allows you to define a
+" file that contains additional compiler arguments like include directories or
+" CFLAGS. The file is expected to contain one option per line. If none is
+" given the filename defaults to '.syntastic_objcpp_config':
+"
+"   let g:syntastic_objcpp_config_file = '.config'
+"
+" Using the global variable 'g:syntastic_objcpp_remove_include_errors' you can
+" specify whether errors of files included via the g:syntastic_objcpp_include_dirs'
+" setting are removed from the result set:
+"
+"   let g:syntastic_objcpp_remove_include_errors = 1
+"
+" Use the variable 'g:syntastic_objcpp_errorformat' to override the default error
+" format:
+"
+"   let g:syntastic_objcpp_errorformat = '%f:%l:%c: %trror: %m'
+"
+" Set your compiler executable with e.g. (defaults to gcc)
+"
+"   let g:syntastic_objcpp_compiler = 'clang'
+
+if exists('g:loaded_syntastic_objcpp_gcc_checker')
+    finish
+endif
+let g:loaded_syntastic_objcpp_gcc_checker = 1
+
+if !exists('g:syntastic_objcpp_compiler')
+    let g:syntastic_objcpp_compiler = 'gcc'
+endif
+
+function! SyntaxCheckers_objcpp_gcc_IsAvailable()
+    return executable(g:syntastic_objcpp_compiler)
+endfunction
+
+let s:save_cpo = &cpo
+set cpo&vim
+
+if !exists('g:syntastic_objcpp_compiler_options')
+    let g:syntastic_objcpp_compiler_options = '-std=gnu99'
+endif
+
+if !exists('g:syntastic_objcpp_config_file')
+    let g:syntastic_objcpp_config_file = '.syntastic_objcpp_config'
+endif
+
+function! SyntaxCheckers_objcpp_gcc_GetLocList()
+    let makeprg = g:syntastic_objcpp_compiler . ' -x objective-c++ -fsyntax-only -lobjc'
+    let errorformat =
+        \ '%-G%f:%s:,' .
+        \ '%-G%f:%l: %#error: %#(Each undeclared identifier is reported only%.%#,' .
+        \ '%-G%f:%l: %#error: %#for each function it appears%.%#,' .
+        \ '%-GIn file included%.%#,'.
+        \ '%-G %#from %f:%l\,,' .
+        \ '%f:%l:%c: %trror: %m,' .
+        \ '%f:%l:%c: %tarning: %m,' .
+        \ '%f:%l:%c: %m,' .
+        \ '%f:%l: %trror: %m,' .
+        \ '%f:%l: %tarning: %m,' .
+        \ '%f:%l: %m'
+
+    if exists('g:syntastic_objcpp_errorformat')
+        let errorformat = g:syntastic_objcpp_errorformat
+    endif
+
+    " add optional user-defined compiler options
+    let makeprg .= g:syntastic_objcpp_compiler_options
+
+    let makeprg .= ' ' . syntastic#util#shexpand('%') .
+               \ ' ' . syntastic#c#GetIncludeDirs('objcpp')
+
+    " determine whether to parse header files as well
+    if expand('%') =~? '\.h$'
+        if exists('g:syntastic_objcpp_check_header')
+            let makeprg = g:syntastic_objcpp_compiler .
+                        \ ' -x objective-c++-header ' .
+                        \ ' -c ' . syntastic#util#shexpand('%') .
+                        \ ' ' . g:syntastic_objcpp_compiler_options .
+                        \ ' ' . syntastic#c#GetIncludeDirs('objcpp')
+        else
+            return []
+        endif
+    endif
+
+    " check if the user manually set some cflags
+    if !exists('b:syntastic_objcpp_cflags')
+        " check whether to search for include files at all
+        if !exists('g:syntastic_objcpp_no_include_search') ||
+                    \ g:syntastic_objcpp_no_include_search != 1
+            " refresh the include file search if desired
+            if exists('g:syntastic_objcpp_auto_refresh_includes') &&
+                        \ g:syntastic_objcpp_auto_refresh_includes != 0
+                let makeprg .= syntastic#c#SearchHeaders()
+            else
+                " search for header includes if not cached already
+                if !exists('b:syntastic_objcpp_includes')
+                    let b:syntastic_objcpp_includes = syntastic#c#SearchHeaders()
+                endif
+                let makeprg .= b:syntastic_objcpp_includes
+            endif
+        endif
+    else
+        " use the user-defined cflags
+        let makeprg .= b:syntastic_objcpp_cflags
+    endif
+
+    " add optional config file parameters
+    let makeprg .= ' ' . syntastic#c#ReadConfig(g:syntastic_objcpp_config_file)
+
+    " process makeprg
+    let errors = SyntasticMake({ 'makeprg': makeprg,
+                \ 'errorformat': errorformat })
+
+    " filter the processed errors if desired
+    if exists('g:syntastic_objcpp_remove_include_errors') &&
+                \ g:syntastic_objcpp_remove_include_errors != 0
+        return filter(errors,
+                    \ 'has_key(v:val, "bufnr") && v:val["bufnr"]=='.bufnr(''))
+    else
+        return errors
+    endif
+endfunction
+
+call g:SyntasticRegistry.CreateAndRegisterChecker({
+    \ 'filetype': 'objcpp',
+    \ 'name': 'gcc'})
+
+let &cpo = s:save_cpo
+unlet s:save_cpo
+
+" vim: set et sts=4 sw=4:
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/config/.vim/syntax_checkers/objcpp/oclint.vim	Wed Nov 06 14:33:18 2013 +0100
@@ -0,0 +1,36 @@
+"============================================================================
+"File:        oclint.vim
+"Description: Syntax checking plugin for syntastic.vim
+"Maintainer:  "UnCO" Lin <undercooled aT lavabit com>
+"License:     This program is free software. It comes without any warranty,
+"             to the extent permitted by applicable law. You can redistribute
+"             it and/or modify it under the terms of the Do What The Fuck You
+"             Want To Public License, Version 2, as published by Sam Hocevar.
+"             See http://sam.zoy.org/wtfpl/COPYING for more details.
+"============================================================================
+"
+" The setting 'g:syntastic_oclint_config_file' allows you to define a file
+" that contains additional compiler arguments like include directories or
+" CFLAGS. The file is expected to contain one option per line. If none is
+" given the filename defaults to '.syntastic_oclint_config':
+"
+"   let g:syntastic_oclint_config_file = '.config'
+
+if exists("g:loaded_syntastic_objcpp_oclint_checker")
+    finish
+endif
+let g:loaded_syntastic_objcpp_oclint_checker = 1
+
+function! SyntaxCheckers_objcpp_oclint_IsAvailable()
+    return SyntaxCheckers_c_oclint_IsAvailable()
+endfunction
+
+function! SyntaxCheckers_objcpp_oclint_GetLocList()
+    return SyntaxCheckers_c_oclint_GetLocList()
+endfunction
+
+call g:SyntasticRegistry.CreateAndRegisterChecker({
+    \ 'filetype': 'objcpp',
+    \ 'name': 'oclint'})
+
+runtime! syntax_checkers/c/*.vim
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/config/.vim/syntax_checkers/objcpp/ycm.vim	Wed Nov 06 14:33:18 2013 +0100
@@ -0,0 +1,34 @@
+"============================================================================
+"File:        ycm.vim
+"Description: Syntax checking plugin for syntastic.vim
+"Maintainer:  Val Markovic <val at markovic dot io>
+"License:     This program is free software. It comes without any warranty,
+"             to the extent permitted by applicable law. You can redistribute
+"             it and/or modify it under the terms of the Do What The Fuck You
+"             Want To Public License, Version 2, as published by Sam Hocevar.
+"             See http://sam.zoy.org/wtfpl/COPYING for more details.
+"
+"============================================================================
+
+if exists("g:loaded_syntastic_objcpp_ycm_checker")
+    finish
+endif
+let g:loaded_syntastic_objcpp_ycm_checker = 1
+
+runtime! syntax_checkers/c/*.vim
+
+function! SyntaxCheckers_objcpp_ycm_IsAvailable()
+    return SyntaxCheckers_c_ycm_IsAvailable()
+endfunction
+
+if !exists('g:loaded_youcompleteme')
+    finish
+endif
+
+function! SyntaxCheckers_objcpp_ycm_GetLocList()
+    return SyntaxCheckers_c_ycm_GetLocList()
+endfunction
+
+call g:SyntasticRegistry.CreateAndRegisterChecker({
+    \ 'filetype': 'objcpp',
+    \ 'name': 'ycm'})
--- a/config/.vim/syntax_checkers/ocaml.vim	Thu Sep 05 16:23:33 2013 +0200
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,89 +0,0 @@
-"============================================================================
-"File:        ocaml.vim
-"Description: Syntax checking plugin for syntastic.vim
-"Maintainer:  Török Edwin <edwintorok at gmail dot com>
-"License:     This program is free software. It comes without any warranty,
-"             to the extent permitted by applicable law. You can redistribute
-"             it and/or modify it under the terms of the Do What The Fuck You
-"             Want To Public License, Version 2, as published by Sam Hocevar.
-"             See http://sam.zoy.org/wtfpl/COPYING for more details.
-"
-"============================================================================
-"
-" By default the camlp4o preprocessor is used to check the syntax of .ml, and .mli files,
-" ocamllex is used to check .mll files and menhir is used to check .mly files.
-" The output is all redirected to /dev/null, nothing is written to the disk.
-"
-" If your source code needs camlp4r then you can define this in your .vimrc:
-"
-"   let g:syntastic_ocaml_camlp4r = 1
-"
-" If you used some syntax extensions, or you want to also typecheck the source
-" code, then you can define this:
-"
-"   let g:syntastic_ocaml_use_ocamlbuild = 1
-"
-" This will run ocamlbuild <name>.inferred.mli, so it will write to your _build
-" directory (and possibly rebuild your myocamlbuild.ml plugin), only enable this
-" if you are ok with that.
-"
-" If you are using syntax extensions / external libraries and have a properly
-" set up _tags (and myocamlbuild.ml file) then it should just work
-" to enable this flag and get syntax / type checks through syntastic.
-"
-" For best results your current directory should be the project root
-" (same situation if you want useful output from :make).
-
-if exists("loaded_ocaml_syntax_checker")
-    finish
-endif
-let loaded_ocaml_syntax_checker = 1
-
-if exists('g:syntastic_ocaml_camlp4r') &&
-    \ g:syntastic_ocaml_camlp4r != 0
-    let s:ocamlpp="camlp4r"
-else
-    let s:ocamlpp="camlp4o"
-endif
-
-"bail if the user doesnt have the preprocessor
-if !executable(s:ocamlpp)
-    finish
-endif
-
-function! SyntaxCheckers_ocaml_GetLocList()
-    if exists('g:syntastic_ocaml_use_ocamlbuild') &&
-                \ g:syntastic_ocaml_use_ocamlbuild != 0 &&
-                \ executable("ocamlbuild") &&
-                \ isdirectory('_build')
-        let makeprg = "ocamlbuild -quiet -no-log -tag annot,". s:ocamlpp. " -no-links -no-hygiene -no-sanitize ".
-                    \ shellescape(expand('%:r')).".cmi"
-    else
-        let extension = expand('%:e')
-        if match(extension, 'mly') >= 0
-            " ocamlyacc output can't be redirected, so use menhir
-            if !executable("menhir")
-                return []
-            endif
-            let makeprg = "menhir --only-preprocess ".shellescape(expand('%')) . " >/dev/null"
-        elseif match(extension,'mll') >= 0
-            if !executable("ocamllex")
-                return []
-            endif
-            let makeprg = "ocamllex -q -o /dev/null ".shellescape(expand('%'))
-        else
-            let makeprg = "camlp4o -o /dev/null ".shellescape(expand('%'))
-        endif
-    endif
-    let errorformat = '%AFile "%f"\, line %l\, characters %c-%*\d:,'.
-                \ '%AFile "%f"\, line %l\, characters %c-%*\d (end at line %*\d\, character %*\d):,'.
-                \ '%AFile "%f"\, line %l\, character %c:,'.
-                \ '%AFile "%f"\, line %l\, character %c:%m,'.
-                \ '%-GPreprocessing error %.%#,'.
-                \ '%-GCommand exited %.%#,'.
-                \ '%C%tarning %n: %m,'.
-                \ '%C%m,'.
-                \ '%-G+%.%#'
-
-    return SyntasticMake({ 'makeprg': makeprg, 'errorformat': errorformat })
-endfunction
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/config/.vim/syntax_checkers/ocaml/camlp4o.vim	Wed Nov 06 14:33:18 2013 +0100
@@ -0,0 +1,149 @@
+"============================================================================
+"File:        ocaml.vim
+"Description: Syntax checking plugin for syntastic.vim
+"Maintainer:  Török Edwin <edwintorok at gmail dot com>
+"License:     This program is free software. It comes without any warranty,
+"             to the extent permitted by applicable law. You can redistribute
+"             it and/or modify it under the terms of the Do What The Fuck You
+"             Want To Public License, Version 2, as published by Sam Hocevar.
+"             See http://sam.zoy.org/wtfpl/COPYING for more details.
+"
+"============================================================================
+"
+" The more reliable way to check for a single .ml file is to use ocamlc.
+" You can do that setting this in your .vimrc:
+"
+"   let g:syntastic_ocaml_use_ocamlc = 1
+" It's possible to use ocamlc in conjuction with Jane Street's Core. In order
+" to do that, you have to specify this in your .vimrc:
+"
+"   let g:syntastic_ocaml_use_janestreet_core = 1
+"   let g:syntastic_ocaml_janestreet_core_dir = <path>
+"
+" Where path is the path to your core installation (usually a collection of
+" .cmx and .cmxa files).
+"
+"
+" By default the camlp4o preprocessor is used to check the syntax of .ml, and .mli files,
+" ocamllex is used to check .mll files and menhir is used to check .mly files.
+" The output is all redirected to /dev/null, nothing is written to the disk.
+"
+" If your source code needs camlp4r then you can define this in your .vimrc:
+"
+"   let g:syntastic_ocaml_camlp4r = 1
+"
+" If you used some syntax extensions, or you want to also typecheck the source
+" code, then you can define this:
+"
+"   let g:syntastic_ocaml_use_ocamlbuild = 1
+"
+" This will run ocamlbuild <name>.inferred.mli, so it will write to your _build
+" directory (and possibly rebuild your myocamlbuild.ml plugin), only enable this
+" if you are ok with that.
+"
+" If you are using syntax extensions / external libraries and have a properly
+" set up _tags (and myocamlbuild.ml file) then it should just work
+" to enable this flag and get syntax / type checks through syntastic.
+"
+" For best results your current directory should be the project root
+" (same situation if you want useful output from :make).
+
+if exists("g:loaded_syntastic_ocaml_camlp4o_checker")
+    finish
+endif
+let g:loaded_syntastic_ocaml_camlp4o_checker=1
+
+if exists('g:syntastic_ocaml_camlp4r') &&
+    \ g:syntastic_ocaml_camlp4r != 0
+    let s:ocamlpp="camlp4r"
+else
+    let s:ocamlpp="camlp4o"
+endif
+
+function! SyntaxCheckers_ocaml_camlp4o_IsAvailable()
+    return executable(s:ocamlpp)
+endfunction
+
+if !exists('g:syntastic_ocaml_use_ocamlc') || !executable('ocamlc')
+    let g:syntastic_ocaml_use_ocamlc = 0
+endif
+
+if !exists('g:syntastic_ocaml_use_janestreet_core')
+    let g:syntastic_ocaml_use_ocamlc = 0
+endif
+
+if !exists('g:syntastic_ocaml_use_ocamlbuild') || !executable("ocamlbuild")
+    let g:syntastic_ocaml_use_ocamlbuild = 0
+endif
+
+function! SyntaxCheckers_ocaml_camlp4o_GetLocList()
+    let makeprg = s:GetMakeprg()
+    if makeprg == ""
+        return []
+    endif
+
+    let errorformat =
+        \ '%AFile "%f"\, line %l\, characters %c-%*\d:,'.
+        \ '%AFile "%f"\, line %l\, characters %c-%*\d (end at line %*\d\, character %*\d):,'.
+        \ '%AFile "%f"\, line %l\, character %c:,'.
+        \ '%AFile "%f"\, line %l\, character %c:%m,'.
+        \ '%-GPreprocessing error %.%#,'.
+        \ '%-GCommand exited %.%#,'.
+        \ '%C%tarning %n: %m,'.
+        \ '%C%m,'.
+        \ '%-G+%.%#'
+
+    return SyntasticMake({ 'makeprg': makeprg, 'errorformat': errorformat })
+endfunction
+
+function s:GetMakeprg()
+    if g:syntastic_ocaml_use_ocamlc
+        return s:GetOcamlcMakeprg()
+    endif
+
+    if g:syntastic_ocaml_use_ocamlbuild && isdirectory('_build')
+        return s:GetOcamlBuildMakeprg()
+    endif
+
+    return s:GetOtherMakeprg()
+endfunction
+
+function s:GetOcamlcMakeprg()
+    if g:syntastic_ocaml_use_janestreet_core
+        let build_cmd = "ocamlc -I "
+        let build_cmd .= expand(g:syntastic_ocaml_janestreet_core_dir)
+        let build_cmd .= " -c " . syntastic#util#shexpand('%')
+        return build_cmd
+    else
+        return "ocamlc -c " . syntastic#util#shexpand('%')
+    endif
+endfunction
+
+function s:GetOcamlBuildMakeprg()
+    return "ocamlbuild -quiet -no-log -tag annot," . s:ocamlpp . " -no-links -no-hygiene -no-sanitize " .
+                \ syntastic#util#shexpand('%:r') . ".cmi"
+endfunction
+
+function s:GetOtherMakeprg()
+    "TODO: give this function a better name?
+    "
+    "TODO: should use throw/catch instead of returning an empty makeprg
+
+    let extension = expand('%:e')
+    let makeprg = ""
+
+    if match(extension, 'mly') >= 0 && executable("menhir")
+        " ocamlyacc output can't be redirected, so use menhir
+        let makeprg = "menhir --only-preprocess " . syntastic#util#shexpand('%') . " >" . syntastic#util#DevNull()
+    elseif match(extension,'mll') >= 0 && executable("ocamllex")
+        let makeprg = "ocamllex -q " . syntastic#c#GetNullDevice() . " " . syntastic#util#shexpand('%')
+    else
+        let makeprg = "camlp4o " . syntastic#c#GetNullDevice() . " " . syntastic#util#shexpand('%')
+    endif
+
+    return makeprg
+endfunction
+
+call g:SyntasticRegistry.CreateAndRegisterChecker({
+    \ 'filetype': 'ocaml',
+    \ 'name': 'camlp4o'})
--- a/config/.vim/syntax_checkers/perl.vim	Thu Sep 05 16:23:33 2013 +0200
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,29 +0,0 @@
-"============================================================================
-"File:        perl.vim
-"Description: Syntax checking plugin for syntastic.vim
-"Maintainer:  Anthony Carapetis <anthony.carapetis at gmail dot com>
-"License:     This program is free software. It comes without any warranty,
-"             to the extent permitted by applicable law. You can redistribute
-"             it and/or modify it under the terms of the Do What The Fuck You
-"             Want To Public License, Version 2, as published by Sam Hocevar.
-"             See http://sam.zoy.org/wtfpl/COPYING for more details.
-"
-"============================================================================
-if exists("loaded_perl_syntax_checker")
-    finish
-endif
-let loaded_perl_syntax_checker = 1
-
-"bail if the user doesnt have perl installed
-if !executable("perl")
-    finish
-endif
-
-let s:checker = 'perl ' . shellescape(expand('<sfile>:p:h') . '/efm_perl.pl') . ' -c'
-
-function! SyntaxCheckers_perl_GetLocList()
-    let makeprg = s:checker . ' ' . shellescape(expand('%'))
-    let errorformat =  '%f:%l:%m'
-
-    return SyntasticMake({ 'makeprg': makeprg, 'errorformat': errorformat })
-endfunction
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/config/.vim/syntax_checkers/perl/efm_perl.pl	Wed Nov 06 14:33:18 2013 +0100
@@ -0,0 +1,186 @@
+#!/usr/bin/env perl
+# vimparse.pl - Reformats the error messages of the Perl interpreter for use
+# with the quickfix mode of Vim
+#
+# Copyright (c) 2001 by Jörg Ziefle <joerg.ziefle@gmx.de>
+# Copyright (c) 2012 Eric Harmon <http://eharmon.net>
+# You may use and distribute this software under the same terms as Perl itself.
+#
+# Usage: put one of the two configurations below in your ~/.vimrc (without the
+# description and '# ') and enjoy (be sure to adjust the paths to vimparse.pl
+# before):
+#
+# Program is run interactively with 'perl -w':
+#
+# set makeprg=$HOME/bin/vimparse.pl\ %\ $*
+# set errorformat=%t:%f:%l:%m
+#
+# Program is only compiled with 'perl -wc':
+#
+# set makeprg=$HOME/bin/vimparse.pl\ -c\ %\ $*
+# set errorformat=%t:%f:%l:%m
+#
+# Usage:
+#	vimparse.pl [-c] [-w] [-f <errorfile>] <programfile> [programargs]
+#
+#		-c	compile only, don't run (perl -wc)
+#		-w	output warnings as warnings instead of errors (slightly slower)
+#		-f	write errors to <errorfile>
+#
+# Example usages:
+#	* From the command line:
+#		vimparse.pl program.pl
+#
+#		vimparse.pl -c -w -f errorfile program.pl
+#		Then run vim -q errorfile to edit the errors with Vim.
+#		This uses the custom errorformat: %t:%f:%l:%m.
+#
+#	* From Vim:
+#		Edit in Vim (and save, if you don't have autowrite on), then
+#		type ':mak' or ':mak args' (args being the program arguments)
+#		to error check.
+#
+# Version history:
+#	0.3 (05/31/2012):
+#		* Added support for the seperate display of warnings
+#		* Switched output format to %t:%f:%l:%m to support error levels
+#	0.2 (04/12/2001):
+#		* First public version (sent to Bram)
+#		* -c command line option for compiling only
+#		* grammatical fix: 'There was 1 error.'
+#		* bug fix for multiple arguments
+#		* more error checks
+#		* documentation (top of file, &usage)
+#		* minor code clean ups
+#	0.1 (02/02/2001):
+#		* Initial version
+#		* Basic functionality
+#
+# Todo:
+#	* test on more systems
+#	* use portable way to determine the location of perl ('use Config')
+#	* include option that shows perldiag messages for each error
+#	* allow to pass in program by STDIN
+#	* more intuitive behaviour if no error is found (show message)
+#
+# Tested under SunOS 5.7 with Perl 5.6.0.  Let me know if it's not working for
+# you.
+use warnings;
+use strict;
+use Getopt::Std;
+use File::Temp qw( tempfile );
+
+use vars qw/$opt_I $opt_c $opt_w $opt_f $opt_h/; # needed for Getopt in combination with use strict 'vars'
+
+use constant VERSION => 0.2;
+
+getopts('cwf:hI:');
+
+&usage if $opt_h; # not necessarily needed, but good for further extension
+
+if (defined $opt_f) {
+
+    open FILE, "> $opt_f" or do {
+	warn "Couldn't open $opt_f: $!.  Using STDOUT instead.\n";
+	undef $opt_f;
+    };
+
+};
+
+my $handle = (defined $opt_f ? \*FILE : \*STDOUT);
+
+(my $file = shift) or &usage; # display usage if no filename is supplied
+my $args = (@ARGV ? ' ' . join ' ', @ARGV : '');
+
+if ($file eq '-') { # make STDIN seek-able, so it can be read twice
+    my $fh = tempfile();
+    print {$fh} <STDIN>;
+    open \*STDIN, '<&', $fh or die "open: $!";
+    seek \*STDIN, 0, 0 or die "seek: $!";
+}
+
+my $libs = join ' ', map {"-I$_"} split ',', $opt_I || '';
+my @error_lines = `$^X $libs @{[defined $opt_c ? '-c ' : '' ]} @{[defined $opt_w ? '-X ' : '-Mwarnings ']} "$file$args" 2>&1`;
+
+my @lines = map { "E:$_" } @error_lines;
+
+my @warn_lines;
+if(defined($opt_w)) {
+    if ($file eq '-') {
+        seek \*STDIN, 0, 0 or die "seek: $!";
+    }
+    @warn_lines = `$^X $libs @{[defined $opt_c ? '-c ' : '' ]} -Mwarnings "$file$args" 2>&1`;
+}
+
+# Any new errors must be warnings
+foreach my $line (@warn_lines) {
+	if(!grep { $_ eq $line } @error_lines) {
+		push(@lines, "W:$line");
+	}
+}
+
+my $errors = 0;
+foreach my $line (@lines) {
+
+    chomp($line);
+    my ($file, $lineno, $message, $rest, $severity);
+
+    if ($line =~ /^([EW]):(.*)\sat\s(.*)\sline\s(\d+)(.*)$/) {
+	($severity, $message, $file, $lineno, $rest) = ($1, $2, $3, $4, $5);
+	$errors++;
+	$message .= $rest if ($rest =~ s/^,//);
+	print $handle "$severity:$file:$lineno:$message\n";
+
+    } else { next };
+
+}
+
+if (defined $opt_f) {
+
+    my $msg;
+    if ($errors == 1) {
+
+	$msg = "There was 1 error.\n";
+
+    } else {
+
+	$msg = "There were $errors errors.\n";
+
+    };
+
+    print STDOUT $msg;
+    close FILE;
+    unlink $opt_f unless $errors;
+
+};
+
+sub usage {
+
+    (local $0 = $0) =~ s/^.*\/([^\/]+)$/$1/; # remove path from name of program
+    print<<EOT;
+Usage:
+	$0 [-c] [-w] [-f <errorfile>] <programfile> [programargs]
+
+		-c	compile only, don't run (executes 'perl -c')
+		-w	output warnings as warnings instead of errors (slightly slower)
+		-f	write errors to <errorfile>
+		-I	specify \@INC/#include directory <perl_lib_path>
+
+Examples:
+	* At the command line:
+		$0 program.pl
+		Displays output on STDOUT.
+
+		$0 -c -w -f errorfile program.pl
+		Then run 'vim -q errorfile' to edit the errors with Vim.
+		This uses the custom errorformat: %t:%f:%l:%m.
+
+	* In Vim:
+		Edit in Vim (and save, if you don't have autowrite on), then
+		type ':mak' or ':mak args' (args being the program arguments)
+		to error check.
+EOT
+
+    exit 0;
+
+};
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/config/.vim/syntax_checkers/perl/perl.vim	Wed Nov 06 14:33:18 2013 +0100
@@ -0,0 +1,71 @@
+"============================================================================
+"File:        perl.vim
+"Description: Syntax checking plugin for syntastic.vim
+"Maintainer:  Anthony Carapetis <anthony.carapetis at gmail dot com>,
+"             Eric Harmon <http://eharmon.net>
+"License:     This program is free software. It comes without any warranty,
+"             to the extent permitted by applicable law. You can redistribute
+"             it and/or modify it under the terms of the Do What The Fuck You
+"             Want To Public License, Version 2, as published by Sam Hocevar.
+"             See http://sam.zoy.org/wtfpl/COPYING for more details.
+"
+"============================================================================
+"
+" In order to add some custom lib directories that should be added to the
+" perl command line you can add those as a comma-separated list to the variable
+" g:syntastic_perl_lib_path.
+"
+"   let g:syntastic_perl_lib_path = './lib,./lib/auto'
+"
+" To use your own perl error output munger script, use the
+" g:syntastic_perl_efm_program option. Any command line parameters should be
+" included in the variable declaration. The program should expect a single
+" parameter; the fully qualified filename of the file to be checked.
+"
+"   let g:syntastic_perl_efm_program = "foo.pl -o -m -g"
+"
+
+if exists("g:loaded_syntastic_perl_perl_checker")
+    finish
+endif
+let g:loaded_syntastic_perl_perl_checker=1
+
+if !exists("g:syntastic_perl_interpreter")
+    let g:syntastic_perl_interpreter = "perl"
+endif
+
+function! SyntaxCheckers_perl_perl_IsAvailable()
+    return executable(g:syntastic_perl_interpreter)
+endfunction
+
+if !exists("g:syntastic_perl_efm_program")
+    let g:syntastic_perl_efm_program =
+        \ g:syntastic_perl_interpreter . ' ' .
+        \ syntastic#util#shescape(expand('<sfile>:p:h') . '/efm_perl.pl') .
+        \ ' -c -w'
+endif
+
+function! SyntaxCheckers_perl_perl_GetLocList()
+    let makeprg = exists("b:syntastic_perl_efm_program") ? b:syntastic_perl_efm_program : g:syntastic_perl_efm_program
+    if exists("g:syntastic_perl_lib_path")
+        let makeprg .= ' -I' . g:syntastic_perl_lib_path
+    endif
+    let makeprg .= ' ' . syntastic#util#shexpand('%') . s:ExtraMakeprgArgs()
+
+    let errorformat =  '%t:%f:%l:%m'
+
+    return SyntasticMake({ 'makeprg': makeprg, 'errorformat': errorformat })
+endfunction
+
+function! s:ExtraMakeprgArgs()
+    let shebang = syntastic#util#parseShebang()
+    if index(shebang['args'], '-T') != -1
+        return ' -Tc'
+    endif
+
+    return ''
+endfunction
+
+call g:SyntasticRegistry.CreateAndRegisterChecker({
+    \ 'filetype': 'perl',
+    \ 'name': 'perl'})
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/config/.vim/syntax_checkers/perl/perlcritic.vim	Wed Nov 06 14:33:18 2013 +0100
@@ -0,0 +1,65 @@
+"============================================================================
+"File:        perlcritic.vim
+"Description: Syntax checking plugin for syntastic.vim
+"Maintainer:  LCD 47 <lcd047 at gmail dot com>
+"License:     This program is free software. It comes without any warranty,
+"             to the extent permitted by applicable law. You can redistribute
+"             it and/or modify it under the terms of the Do What The Fuck You
+"             Want To Public License, Version 2, as published by Sam Hocevar.
+"             See http://sam.zoy.org/wtfpl/COPYING for more details.
+"
+"============================================================================
+"
+" For details about perlcritic see:
+"
+" - http://perlcritic.tigris.org/
+" - https://metacpan.org/module/Perl::Critic
+"
+" Checker options:
+"
+" - g:syntastic_perl_perlcritic_thres (integer; default: 5)
+"   error threshold: policy violations with a severity above this
+"   value are highlighted as errors, the others are warnings
+"
+" - g:syntastic_perl_perlcritic_args (string; default: empty)
+"   command line options to pass to perlcritic
+
+if exists("g:loaded_syntastic_perl_perlcritic_checker")
+    finish
+endif
+let g:loaded_syntastic_perl_perlcritic_checker=1
+
+if !exists('g:syntastic_perl_perlcritic_thres')
+    let g:syntastic_perl_perlcritic_thres = 5
+endif
+
+function! SyntaxCheckers_perl_perlcritic_IsAvailable()
+    return executable('perlcritic')
+endfunction
+
+function! SyntaxCheckers_perl_perlcritic_GetLocList()
+    let makeprg = syntastic#makeprg#build({
+        \ 'exe': 'perlcritic',
+        \ 'post_args': '--quiet --nocolor --verbose "\%s:\%f:\%l:\%c:(\%s) \%m (\%e)\n"',
+        \ 'filetype': 'perl',
+        \ 'subchecker': 'perlcritic' })
+
+    let errorformat = '%t:%f:%l:%c:%m'
+
+    let loclist = SyntasticMake({
+        \ 'makeprg': makeprg,
+        \ 'errorformat': errorformat,
+        \ 'returns': [0, 2],
+        \ 'subtype': 'Style' })
+
+    " change error types according to the prescribed threshold
+    for n in range(len(loclist))
+        let loclist[n]['type'] = loclist[n]['type'] < g:syntastic_perl_perlcritic_thres ? 'W' : 'E'
+    endfor
+
+    return loclist
+endfunction
+
+call g:SyntasticRegistry.CreateAndRegisterChecker({
+    \ 'filetype': 'perl',
+    \ 'name': 'perlcritic'})
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/config/.vim/syntax_checkers/perl/podchecker.vim	Wed Nov 06 14:33:18 2013 +0100
@@ -0,0 +1,30 @@
+"============================================================================
+"File:        podchecker.vim
+"Description: Syntax checking plugin for syntastic.vim
+"Maintainer:  LCD 47 <lcd047 at gmail dot com>
+"License:     This program is free software. It comes without any warranty,
+"             to the extent permitted by applicable law. You can redistribute
+"             it and/or modify it under the terms of the Do What The Fuck You
+"             Want To Public License, Version 2, as published by Sam Hocevar.
+"             See http://sam.zoy.org/wtfpl/COPYING for more details.
+"
+"============================================================================
+
+if exists("g:loaded_syntastic_perl_podchecker_checker")
+    finish
+endif
+let g:loaded_syntastic_perl_podchecker_checker=1
+
+function! SyntaxCheckers_perl_podchecker_IsAvailable()
+    return SyntaxCheckers_pod_podchecker_IsAvailable()
+endfunction
+
+function! SyntaxCheckers_perl_podchecker_GetLocList()
+    return SyntaxCheckers_pod_podchecker_GetLocList()
+endfunction
+
+call g:SyntasticRegistry.CreateAndRegisterChecker({
+    \ 'filetype': 'perl',
+    \ 'name': 'podchecker'})
+
+runtime! syntax_checkers/pod/*.vim
--- a/config/.vim/syntax_checkers/php.vim	Thu Sep 05 16:23:33 2013 +0200
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,58 +0,0 @@
-"============================================================================
-"File:        php.vim
-"Description: Syntax checking plugin for syntastic.vim
-"Maintainer:  Martin Grenfell <martin.grenfell at gmail dot com>
-"License:     This program is free software. It comes without any warranty,
-"             to the extent permitted by applicable law. You can redistribute
-"             it and/or modify it under the terms of the Do What The Fuck You
-"             Want To Public License, Version 2, as published by Sam Hocevar.
-"             See http://sam.zoy.org/wtfpl/COPYING for more details.
-"
-"============================================================================
-if exists("loaded_php_syntax_checker")
-    finish
-endif
-let loaded_php_syntax_checker = 1
-
-"bail if the user doesnt have php installed
-if !executable("php")
-    finish
-endif
-
-"Support passing configuration directives to phpcs
-if !exists("g:syntastic_phpcs_conf")
-    let g:syntastic_phpcs_conf = ""
-endif
-
-if !exists("g:syntastic_phpcs_disable")
-    let g:syntastic_phpcs_disable = 0
-endif
-
-function! SyntaxCheckers_php_Term(item)
-    let unexpected = matchstr(a:item['text'], "unexpected '[^']\\+'")
-    if len(unexpected) < 1 | return '' | end
-    return '\V'.split(unexpected, "'")[1]
-endfunction
-
-function! SyntaxCheckers_php_GetLocList()
-
-    let errors = []
-
-    let makeprg = "php -l ".shellescape(expand('%'))
-    let errorformat='%-GNo syntax errors detected in%.%#,PHP Parse error: %#syntax %trror\, %m in %f on line %l,PHP Fatal %trror: %m in %f on line %l,%-GErrors parsing %.%#,%-G\s%#,Parse error: %#syntax %trror\, %m in %f on line %l,Fatal %trror: %m in %f on line %l'
-    let errors = SyntasticMake({ 'makeprg': makeprg, 'errorformat': errorformat })
-
-    if empty(errors) && !g:syntastic_phpcs_disable && executable("phpcs")
-        let errors = errors + s:GetPHPCSErrors()
-    endif
-
-    call SyntasticHighlightErrors(errors, function('SyntaxCheckers_php_Term'))
-
-    return errors
-endfunction
-
-function! s:GetPHPCSErrors()
-    let makeprg = "phpcs " . g:syntastic_phpcs_conf . " --report=csv ".shellescape(expand('%'))
-    let errorformat = '%-GFile\,Line\,Column\,Type\,Message\,Source\,Severity,"%f"\,%l\,%c\,%t%*[a-zA-Z]\,"%m"\,%*[a-zA-Z0-9_.-]\,%*[0-9]'
-    return SyntasticMake({ 'makeprg': makeprg, 'errorformat': errorformat, 'subtype': 'Style' })
-endfunction
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/config/.vim/syntax_checkers/php/php.vim	Wed Nov 06 14:33:18 2013 +0100
@@ -0,0 +1,52 @@
+"============================================================================
+"File:        php.vim
+"Description: Syntax checking plugin for syntastic.vim
+"Maintainer:  Martin Grenfell <martin.grenfell at gmail dot com>
+"License:     This program is free software. It comes without any warranty,
+"             to the extent permitted by applicable law. You can redistribute
+"             it and/or modify it under the terms of the Do What The Fuck You
+"             Want To Public License, Version 2, as published by Sam Hocevar.
+"             See http://sam.zoy.org/wtfpl/COPYING for more details.
+"
+"============================================================================
+
+if exists("g:loaded_syntastic_php_php_checker")
+    finish
+endif
+let g:loaded_syntastic_php_php_checker=1
+
+function! SyntaxCheckers_php_php_IsAvailable()
+    return executable("php")
+endfunction
+
+function! SyntaxCheckers_php_php_GetHighlightRegex(item)
+    let unexpected = matchstr(a:item['text'], "unexpected '[^']\\+'")
+    if len(unexpected) < 1
+        return ''
+    endif
+    return '\V'.split(unexpected, "'")[1]
+endfunction
+
+function! SyntaxCheckers_php_php_GetLocList()
+    let makeprg = syntastic#makeprg#build({
+        \ 'exe': 'php',
+        \ 'args': '-l -d error_reporting=E_ALL -d display_errors=1 -d log_errors=0 -d xdebug.cli_color=0',
+        \ 'filetype': 'php',
+        \ 'subchecker': 'php' })
+
+    let errorformat =
+        \ '%-GNo syntax errors detected in%.%#,'.
+        \ 'Parse error: %#syntax %trror\, %m in %f on line %l,'.
+        \ 'Parse %trror: %m in %f on line %l,'.
+        \ 'Fatal %trror: %m in %f on line %l,'.
+        \ '%-G\s%#,'.
+        \ '%-GErrors parsing %.%#'
+
+    return SyntasticMake({
+        \ 'makeprg': makeprg,
+        \ 'errorformat': errorformat })
+endfunction
+
+call g:SyntasticRegistry.CreateAndRegisterChecker({
+    \ 'filetype': 'php',
+    \ 'name': 'php'})
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/config/.vim/syntax_checkers/php/phpcs.vim	Wed Nov 06 14:33:18 2013 +0100
@@ -0,0 +1,44 @@
+"============================================================================
+"File:        phpcs.vim
+"Description: Syntax checking plugin for syntastic.vim
+"Maintainer:  Martin Grenfell <martin.grenfell at gmail dot com>
+"License:     This program is free software. It comes without any warranty,
+"             to the extent permitted by applicable law. You can redistribute
+"             it and/or modify it under the terms of the Do What The Fuck You
+"             Want To Public License, Version 2, as published by Sam Hocevar.
+"             See http://sam.zoy.org/wtfpl/COPYING for more details.
+"
+"============================================================================
+"
+" See here for details of phpcs
+"    - phpcs (see http://pear.php.net/package/PHP_CodeSniffer)
+"
+if exists("g:loaded_syntastic_php_phpcs_checker")
+    finish
+endif
+let g:loaded_syntastic_php_phpcs_checker=1
+
+function! SyntaxCheckers_php_phpcs_IsAvailable()
+    return executable('phpcs')
+endfunction
+
+function! SyntaxCheckers_php_phpcs_GetLocList()
+    let makeprg = syntastic#makeprg#build({
+        \ 'exe': 'phpcs',
+        \ 'args': '--report=csv',
+        \ 'filetype': 'php',
+        \ 'subchecker': 'phpcs' })
+
+    let errorformat =
+        \ '%-GFile\,Line\,Column\,Type\,Message\,Source\,Severity,'.
+        \ '"%f"\,%l\,%c\,%t%*[a-zA-Z]\,"%m"\,%*[a-zA-Z0-9_.-]\,%*[0-9]'
+
+    return SyntasticMake({
+        \ 'makeprg': makeprg,
+        \ 'errorformat': errorformat,
+        \ 'subtype': 'Style' })
+endfunction
+
+call g:SyntasticRegistry.CreateAndRegisterChecker({
+    \ 'filetype': 'php',
+    \ 'name': 'phpcs'})
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/config/.vim/syntax_checkers/php/phpmd.vim	Wed Nov 06 14:33:18 2013 +0100
@@ -0,0 +1,78 @@
+"============================================================================
+"File:        phpmd.vim
+"Description: Syntax checking plugin for syntastic.vim
+"Maintainer:  Martin Grenfell <martin.grenfell at gmail dot com>
+"License:     This program is free software. It comes without any warranty,
+"             to the extent permitted by applicable law. You can redistribute
+"             it and/or modify it under the terms of the Do What The Fuck You
+"             Want To Public License, Version 2, as published by Sam Hocevar.
+"             See http://sam.zoy.org/wtfpl/COPYING for more details.
+"
+"============================================================================
+"
+" See here for details of phpmd
+"   - phpmd (see http://phpmd.org)
+
+if exists("g:loaded_syntastic_php_phpmd_checker")
+    finish
+endif
+let g:loaded_syntastic_php_phpmd_checker=1
+
+function! SyntaxCheckers_php_phpmd_IsAvailable()
+    return executable('phpmd')
+endfunction
+
+function! SyntaxCheckers_php_phpmd_GetHighlightRegex(item)
+    let term = matchstr(a:item['text'], '\C^The \S\+ \w\+\(()\)\= \(has\|is not\|utilizes\)')
+    if term != ''
+        return '\V'.substitute(term, '\C^The \S\+ \(\w\+\)\(()\)\= .*', '\1', '')
+    endif
+    let term = matchstr(a:item['text'], '\C^Avoid \(variables with short\|excessively long variable\) names like \S\+\.')
+    if term != ''
+        return '\V'.substitute(term, '\C^Avoid \(variables with short\|excessively long variable\) names like \(\S\+\)\..*', '\2', '')
+    endif
+    let term = matchstr(a:item['text'], '\C^Avoid using short method names like \S\+::\S\+()\.')
+    if term != ''
+        return '\V'.substitute(term, '\C^Avoid using short method names like \S\+::\(\S\+\)()\..*', '\1', '')
+    endif
+    let term = matchstr(a:item['text'], '\C^\S\+ accesses the super-global variable ')
+    if term != ''
+        return '\V'.substitute(term, '\C accesses the super-global variable .*$', '', '')
+    endif
+    let term = matchstr(a:item['text'], '\C^Constant \S\+ should be defined in uppercase')
+    if term != ''
+        return '\V'.substitute(term, '\C^Constant \(\S\+\) should be defined in uppercase', '\1', '')
+    endif
+    let term = matchstr(a:item['text'], "\\C^The '\\S\\+()' method which returns ")
+    if term != ''
+        return '\V'.substitute(term, "\\C^The '\\(\\S\\+\\()' method which returns.*", '\1', '')
+    endif
+    let term = matchstr(a:item['text'], '\C variable \S\+ should begin with ')
+    if term != ''
+        return '\V'.substitute(term, '\C.* variable \(\S\+\) should begin with .*', '\1', '')
+    endif
+    let term = matchstr(a:item['text'], "\\C^Avoid unused \\(private fields\\|local variables\\|private methods\\|parameters\\) such as '\\S\\+'")
+    if term != ''
+        return '\V'.substitute(term, "\\C^Avoid unused \\(private fields\\|local variables\\|private methods\\|parameters\\) such as '\\(\\S\\+\\)'.*", '\2', '')
+    endif
+    return ''
+endfunction
+
+function! SyntaxCheckers_php_phpmd_GetLocList()
+    let makeprg = syntastic#makeprg#build({
+        \ 'exe': 'phpmd',
+        \ 'post_args': 'text codesize,design,unusedcode,naming',
+        \ 'filetype': 'php',
+        \ 'subchecker': 'phpmd' })
+
+    let errorformat = '%E%f:%l%\s%#%m'
+
+    return SyntasticMake({
+        \ 'makeprg': makeprg,
+        \ 'errorformat': errorformat,
+        \ 'subtype' : 'Style' })
+endfunction
+
+call g:SyntasticRegistry.CreateAndRegisterChecker({
+    \ 'filetype': 'php',
+    \ 'name': 'phpmd'})
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/config/.vim/syntax_checkers/pod/podchecker.vim	Wed Nov 06 14:33:18 2013 +0100
@@ -0,0 +1,51 @@
+"============================================================================
+"File:        podchecker.vim
+"Description: Syntax checking plugin for syntastic.vim
+"Maintainer:  LCD 47 <lcd047 at gmail dot com>
+"License:     This program is free software. It comes without any warranty,
+"             to the extent permitted by applicable law. You can redistribute
+"             it and/or modify it under the terms of the Do What The Fuck You
+"             Want To Public License, Version 2, as published by Sam Hocevar.
+"             See http://sam.zoy.org/wtfpl/COPYING for more details.
+"
+"============================================================================
+if exists("g:loaded_syntastic_pod_podchecker_checker")
+    finish
+endif
+let g:loaded_syntastic_pod_podchecker_checker=1
+
+function! SyntaxCheckers_pod_podchecker_IsAvailable()
+    return executable("podchecker")
+endfunction
+
+function! SyntaxCheckers_pod_podchecker_GetLocList()
+    let makeprg = syntastic#makeprg#build({
+        \ 'exe': 'podchecker',
+        \ 'filetype': 'pod',
+        \ 'subchecker': 'podchecker' })
+
+    let errorformat =
+        \ '%W%[%#]%[%#]%[%#] WARNING: %m at line %l in file %f,' .
+        \ '%W%[%#]%[%#]%[%#] WARNING: %m at line EOF in file %f,' .
+        \ '%E%[%#]%[%#]%[%#] ERROR: %m at line %l in file %f,' .
+        \ '%E%[%#]%[%#]%[%#] ERROR: %m at line EOF in file %f'
+
+    let loclist = SyntasticMake({
+        \ 'makeprg': makeprg,
+        \ 'errorformat': errorformat,
+        \ 'returns': [0, 1, 2] })
+
+    for n in range(len(loclist))
+        let e = loclist[n]
+        if e['valid'] && e['lnum'] == 0
+            let e['lnum'] = str2nr(matchstr(e['text'], '\m\<line \zs\d\+\ze'))
+        endif
+    endfor
+
+    return loclist
+endfunction
+
+call g:SyntasticRegistry.CreateAndRegisterChecker({
+    \ 'filetype': 'pod',
+    \ 'name': 'podchecker'})
+
--- a/config/.vim/syntax_checkers/puppet.vim	Thu Sep 05 16:23:33 2013 +0200
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,54 +0,0 @@
-"============================================================================
-"File:        puppet.vim
-"Description: Syntax checking plugin for syntastic.vim
-"Maintainer:  Eivind Uggedal <eivind at uggedal dot com>
-"License:     This program is free software. It comes without any warranty,
-"             to the extent permitted by applicable law. You can redistribute
-"             it and/or modify it under the terms of the Do What The Fuck You
-"             Want To Public License, Version 2, as published by Sam Hocevar.
-"             See http://sam.zoy.org/wtfpl/COPYING for more details.
-"
-"============================================================================
-if exists("loaded_puppet_syntax_checker")
-    finish
-endif
-let loaded_puppet_syntax_checker = 1
-
-"bail if the user doesnt have puppet installed
-if !executable("puppet")
-    finish
-endif
-
-function! s:ExtractVersion()
-    let output = system("puppet --version")
-    let output = substitute(output, '\n$', '', '')
-    return split(output, '\.')
-endfunction
-
-let s:puppetVersion = s:ExtractVersion()
-
-function! SyntaxCheckers_puppet_GetLocList()
-    "If puppet is >= version 2.7 then use the new executable
-    if s:puppetVersion[0] >= '2' && s:puppetVersion[1] >= '7'
-        let makeprg = 'puppet parser validate ' .
-                    \ shellescape(expand('%')) .
-                    \ ' --color=false' .
-                    \ ' --storeconfigs'
-
-        "add --ignoreimport for versions < 2.7.10
-        if s:puppetVersion[2] < '10'
-            let makeprg .= ' --ignoreimport'
-        endif
-
-    else
-        let makeprg = 'puppet --color=false --parseonly --ignoreimport '.shellescape(expand('%'))
-    endif
-
-    "some versions of puppet (e.g. 2.7.10) output the message below if there
-    "are any syntax errors
-    let errorformat = '%-Gerr: Try ''puppet help parser validate'' for usage,'
-
-    let errorformat .= 'err: Could not parse for environment %*[a-z]: %m at %f:%l'
-
-    return SyntasticMake({ 'makeprg': makeprg, 'errorformat': errorformat })
-endfunction
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/config/.vim/syntax_checkers/puppet/puppet.vim	Wed Nov 06 14:33:18 2013 +0100
@@ -0,0 +1,52 @@
+"============================================================================
+"File:        puppet.vim
+"Description: Syntax checking plugin for syntastic.vim
+"Maintainer:  Eivind Uggedal <eivind at uggedal dot com>
+"License:     This program is free software. It comes without any warranty,
+"             to the extent permitted by applicable law. You can redistribute
+"             it and/or modify it under the terms of the Do What The Fuck You
+"             Want To Public License, Version 2, as published by Sam Hocevar.
+"             See http://sam.zoy.org/wtfpl/COPYING for more details.
+"
+"============================================================================
+
+if exists("g:loaded_syntastic_puppet_puppet_checker")
+    finish
+endif
+let g:loaded_syntastic_puppet_puppet_checker=1
+
+function! SyntaxCheckers_puppet_puppet_IsAvailable()
+    return executable("puppet")
+endfunction
+
+function! SyntaxCheckers_puppet_puppet_GetLocList()
+
+    let ver = syntastic#util#parseVersion('puppet --version 2>' . syntastic#util#DevNull())
+
+    if syntastic#util#versionIsAtLeast(ver, [2,7,0])
+        let args = 'parser validate --color=false'
+    else
+        let args = '--color=false --parseonly'
+    endif
+
+    let makeprg = syntastic#makeprg#build({
+        \ 'exe': 'puppet',
+        \ 'args': args,
+        \ 'filetype': 'puppet',
+        \ 'subchecker': 'puppet' })
+
+    let errorformat =
+        \ '%-Gerr: Try ''puppet help parser validate'' for usage,' .
+        \ '%-GError: Try ''puppet help parser validate'' for usage,' .
+        \ '%Eerr: Could not parse for environment %*[a-z]: %m at %f:%l,' .
+        \ '%EError: Could not parse for environment %*[a-z]: %m at %f:%l'
+
+    return SyntasticMake({
+        \ 'makeprg': makeprg,
+        \ 'errorformat': errorformat })
+
+endfunction
+
+call g:SyntasticRegistry.CreateAndRegisterChecker({
+    \ 'filetype': 'puppet',
+    \ 'name': 'puppet'})
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/config/.vim/syntax_checkers/puppet/puppetlint.vim	Wed Nov 06 14:33:18 2013 +0100
@@ -0,0 +1,47 @@
+"============================================================================
+"File:        puppetlint.vim
+"Description: Syntax checking plugin for syntastic.vim
+"Maintainer:  Eivind Uggedal <eivind at uggedal dot com>
+"License:     This program is free software. It comes without any warranty,
+"             to the extent permitted by applicable law. You can redistribute
+"             it and/or modify it under the terms of the Do What The Fuck You
+"             Want To Public License, Version 2, as published by Sam Hocevar.
+"             See http://sam.zoy.org/wtfpl/COPYING for more details.
+"
+"============================================================================
+
+if exists("g:loaded_syntastic_puppet_puppetlint_checker")
+    finish
+endif
+let g:loaded_syntastic_puppet_puppetlint_checker=1
+
+if exists("g:syntastic_puppet_lint_arguments")
+    let g:syntastic_puppet_puppetlint_args = g:syntastic_puppet_lint_arguments
+    call syntastic#util#deprecationWarn("variable g:syntastic_puppet_lint_arguments is deprecated, please use g:syntastic_puppet_puppetlint_args instead")
+endif
+
+function! SyntaxCheckers_puppet_puppetlint_IsAvailable()
+    return
+        \ executable("puppet") &&
+        \ executable("puppet-lint") &&
+        \ syntastic#util#versionIsAtLeast(syntastic#util#parseVersion('puppet-lint --version 2>' .
+        \     syntastic#util#DevNull()), [0,1,10])
+endfunction
+
+function! SyntaxCheckers_puppet_puppetlint_GetLocList()
+    let makeprg = syntastic#makeprg#build({
+        \ 'exe': 'puppet-lint',
+        \ 'post_args': '--log-format "%{KIND} [%{check}] %{message} at %{fullpath}:%{linenumber}"',
+        \ 'filetype': 'puppet',
+        \ 'subchecker': 'puppetlint' })
+
+    let errorformat = '%t%*[a-zA-Z] %m at %f:%l'
+
+    return SyntasticMake({
+        \ 'makeprg': makeprg,
+        \ 'errorformat': errorformat })
+endfunction
+
+call g:SyntasticRegistry.CreateAndRegisterChecker({
+    \ 'filetype': 'puppet',
+    \ 'name': 'puppetlint'})
--- a/config/.vim/syntax_checkers/python.vim	Thu Sep 05 16:23:33 2013 +0200
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,80 +0,0 @@
-"============================================================================
-"File:        python.vim
-"Description: Syntax checking plugin for syntastic.vim
-"
-"Authors:     Martin Grenfell <martin.grenfell@gmail.com>
-"             kstep <me@kstep.me>
-"             Parantapa Bhattacharya <parantapa@gmail.com>
-"
-"============================================================================
-"
-" For forcing the use of flake8, pyflakes, or pylint set
-"
-"   let g:syntastic_python_checker = 'pyflakes'
-"
-" in your .vimrc. Default is flake8.
-
-if exists("loaded_python_syntax_checker")
-    finish
-endif
-let loaded_python_syntax_checker = 1
-
-"bail if the user doesnt have his favorite checker or flake8 or pyflakes installed
-if !exists('g:syntastic_python_checker') || !executable(g:syntastic_python_checker)
-    if executable("flake8")
-        let g:syntastic_python_checker = 'flake8'
-    elseif executable("pyflakes")
-        let g:syntastic_python_checker = 'pyflakes'
-    elseif executable("pylint")
-        let g:syntastic_python_checker = 'pylint'
-    else
-        finish
-    endif
-endif
-if !exists('g:syntastic_python_checker_args')
-    let g:syntastic_python_checker_args = ''
-endif
-
-function! SyntaxCheckers_python_Term(i)
-    if a:i['type'] ==# 'E'
-        let a:i['text'] = "Syntax error"
-    endif
-    if match(a:i['text'], 'is assigned to but never used') > -1
-                \ || match(a:i['text'], 'imported but unused') > -1
-                \ || match(a:i['text'], 'undefined name') > -1
-                \ || match(a:i['text'], 'redefinition of') > -1
-                \ || match(a:i['text'], 'referenced before assignment') > -1
-                \ || match(a:i['text'], 'duplicate argument') > -1
-                \ || match(a:i['text'], 'after other statements') > -1
-                \ || match(a:i['text'], 'shadowed by loop variable') > -1
-
-        let term = split(a:i['text'], "'", 1)[1]
-        return '\V\<'.term.'\>'
-    endif
-    return ''
-endfunction
-
-if g:syntastic_python_checker == 'pylint'
-    function! SyntaxCheckers_python_GetLocList()
-        let makeprg = 'pylint -f parseable -r n -i y ' .
-            \ shellescape(expand('%')) .
-            \ ' \| sed ''s_: \[[RC]_: \[W_''' .
-            \ ' \| sed ''s_: \[[F]_:\ \[E_'''
-        let errorformat = '%f:%l: [%t%n] %m,%-GNo config%m'
-        let errors = SyntasticMake({ 'makeprg': makeprg, 'errorformat': errorformat })
-
-        return errors
-    endfunction
-else
-    function! SyntaxCheckers_python_GetLocList()
-        let makeprg = g:syntastic_python_checker.' '.g:syntastic_python_checker_args.' '.shellescape(expand('%'))
-        let errorformat =
-            \ '%E%f:%l: could not compile,%-Z%p^,%W%f:%l:%c: %m,%W%f:%l: %m,%-G%.%#'
-
-        let errors = SyntasticMake({ 'makeprg': makeprg, 'errorformat': errorformat })
-
-        call SyntasticHighlightErrors(errors, function('SyntaxCheckers_python_Term'))
-
-        return errors
-    endfunction
-endif
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/config/.vim/syntax_checkers/python/flake8.vim	Wed Nov 06 14:33:18 2013 +0100
@@ -0,0 +1,44 @@
+"============================================================================
+"File:        flake8.vim
+"Description: Syntax checking plugin for syntastic.vim
+"Authors:     Sylvain Soliman <Sylvain dot Soliman+git at gmail dot com>
+"             kstep <me@kstep.me>
+"
+"============================================================================
+if exists("g:loaded_syntastic_python_flake8_checker")
+    finish
+endif
+let g:loaded_syntastic_python_flake8_checker=1
+
+function! SyntaxCheckers_python_flake8_IsAvailable()
+    return executable('flake8')
+endfunction
+
+function! SyntaxCheckers_python_flake8_GetHighlightRegex(i)
+    return SyntaxCheckers_python_pyflakes_GetHighlightRegex(a:i)
+endfunction
+
+function! SyntaxCheckers_python_flake8_GetLocList()
+    let makeprg = syntastic#makeprg#build({
+        \ 'exe': 'flake8',
+        \ 'filetype': 'python',
+        \ 'subchecker': 'flake8' })
+
+    let errorformat =
+        \ '%E%f:%l: could not compile,%-Z%p^,'.
+        \ '%W%f:%l:%c: F%n %m,'.
+        \ '%W%f:%l:%c: C%n %m,'.
+        \ '%E%f:%l:%c: %t%n %m,'.
+        \ '%E%f:%l: %t%n %m,'.
+        \ '%-G%.%#'
+
+    return SyntasticMake({
+        \ 'makeprg': makeprg,
+        \ 'errorformat': errorformat })
+endfunction
+
+call g:SyntasticRegistry.CreateAndRegisterChecker({
+    \ 'filetype': 'python',
+    \ 'name': 'flake8'})
+
+runtime! syntax_checkers/python/pyflakes.vim
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/config/.vim/syntax_checkers/python/pep257.vim	Wed Nov 06 14:33:18 2013 +0100
@@ -0,0 +1,50 @@
+"============================================================================
+"File:        pep257.vim
+"Description: Docstring style checking plugin for syntastic.vim
+"============================================================================
+"
+" For details about pep257 see: https://github.com/GreenSteam/pep257
+
+if exists("g:loaded_syntastic_python_pep257_checker")
+    finish
+endif
+let g:loaded_syntastic_python_pep257_checker = 1
+
+function! SyntaxCheckers_python_pep257_IsAvailable()
+    return executable('pep257')
+endfunction
+
+" sanity: kill empty lines here rather than munging errorformat
+function! SyntaxCheckers_python_pep257_Preprocess(errors)
+    return filter(copy(a:errors), 'v:val != ""')
+endfunction
+
+function! SyntaxCheckers_python_pep257_GetLocList()
+    let makeprg = syntastic#makeprg#build({
+        \ 'exe': 'pep257',
+        \ 'filetype': 'python',
+        \ 'subchecker': 'pep257' })
+
+    let errorformat =
+        \ '%E%f:%l:%c%\%.%\%.%\d%\+:%\d%\+: %m,' .
+        \ '%E%f:%l:%c: %m,' .
+        \ '%+C    %m'
+
+    let loclist = SyntasticMake({
+        \ 'makeprg': makeprg,
+        \ 'errorformat': errorformat,
+        \ 'subtype': 'Style',
+        \ 'preprocess': 'SyntaxCheckers_python_pep257_Preprocess',
+        \ 'postprocess': ['compressWhitespace'] })
+
+    " pep257 outputs byte offsets rather than column numbers
+    for n in range(len(loclist))
+        let loclist[n]['col'] = get(loclist[n], 'col', 0) + 1
+    endfor
+
+    return loclist
+endfunction
+
+call g:SyntasticRegistry.CreateAndRegisterChecker({
+    \ 'filetype': 'python',
+    \ 'name': 'pep257'})
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/config/.vim/syntax_checkers/python/pep8.vim	Wed Nov 06 14:33:18 2013 +0100
@@ -0,0 +1,46 @@
+"============================================================================
+"File:        pep8.vim
+"Description: Syntax checking plugin for syntastic.vim
+"Maintainer:  LCD 47 <lcd047 at gmail dot com>
+"License:     This program is free software. It comes without any warranty,
+"             to the extent permitted by applicable law. You can redistribute
+"             it and/or modify it under the terms of the Do What The Fuck You
+"             Want To Public License, Version 2, as published by Sam Hocevar.
+"             See http://sam.zoy.org/wtfpl/COPYING for more details.
+"
+"============================================================================
+"
+" For details about pep8 see: https://github.com/jcrocholl/pep8
+
+if exists("g:loaded_syntastic_python_pep8_checker")
+    finish
+endif
+let g:loaded_syntastic_python_pep8_checker=1
+
+function! SyntaxCheckers_python_pep8_IsAvailable()
+    return executable('pep8')
+endfunction
+
+function! SyntaxCheckers_python_pep8_GetLocList()
+    let makeprg = syntastic#makeprg#build({
+        \ 'exe': 'pep8',
+        \ 'filetype': 'python',
+        \ 'subchecker': 'pep8' })
+
+    let errorformat = '%f:%l:%c: %m'
+
+    let loclist = SyntasticMake({
+        \ 'makeprg': makeprg,
+        \ 'errorformat': errorformat,
+        \ 'subtype': 'Style' })
+
+    for n in range(len(loclist))
+        let loclist[n]['type'] = loclist[n]['text'] =~? '^W' ? 'W' : 'E'
+    endfor
+
+    return loclist
+endfunction
+
+call g:SyntasticRegistry.CreateAndRegisterChecker({
+    \ 'filetype': 'python',
+    \ 'name': 'pep8'})
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/config/.vim/syntax_checkers/python/py3kwarn.vim	Wed Nov 06 14:33:18 2013 +0100
@@ -0,0 +1,31 @@
+"============================================================================
+"File:        py3kwarn.vim
+"Description: Syntax checking plugin for syntastic.vim
+"Authors:     Liam Curry <liam@curry.name>
+"
+"============================================================================
+if exists("g:loaded_syntastic_python_py3kwarn_checker")
+    finish
+endif
+let g:loaded_syntastic_python_py3kwarn_checker=1
+
+function! SyntaxCheckers_python_py3kwarn_IsAvailable()
+    return executable('py3kwarn')
+endfunction
+
+function! SyntaxCheckers_python_py3kwarn_GetLocList()
+    let makeprg = syntastic#makeprg#build({
+        \ 'exe': 'py3kwarn',
+        \ 'filetype': 'python',
+        \ 'subchecker': 'py3kwarn' })
+
+    let errorformat = '%W%f:%l:%c: %m'
+
+    return SyntasticMake({
+        \ 'makeprg': makeprg,
+        \ 'errorformat': errorformat })
+endfunction
+
+call g:SyntasticRegistry.CreateAndRegisterChecker({
+    \ 'filetype': 'python',
+    \ 'name': 'py3kwarn'})
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/config/.vim/syntax_checkers/python/pyflakes.vim	Wed Nov 06 14:33:18 2013 +0100
@@ -0,0 +1,63 @@
+"============================================================================
+"File:        pyflakes.vim
+"Description: Syntax checking plugin for syntastic.vim
+"Authors:     Martin Grenfell <martin.grenfell@gmail.com>
+"             kstep <me@kstep.me>
+"             Parantapa Bhattacharya <parantapa@gmail.com>
+"
+"============================================================================
+if exists("g:loaded_syntastic_python_pyflakes_checker")
+    finish
+endif
+let g:loaded_syntastic_python_pyflakes_checker=1
+
+function! SyntaxCheckers_python_pyflakes_IsAvailable()
+    return executable('pyflakes')
+endfunction
+
+function! SyntaxCheckers_python_pyflakes_GetHighlightRegex(i)
+    if match(a:i['text'], 'is assigned to but never used') > -1
+        \ || match(a:i['text'], 'imported but unused') > -1
+        \ || match(a:i['text'], 'undefined name') > -1
+        \ || match(a:i['text'], 'redefinition of') > -1
+        \ || match(a:i['text'], 'referenced before assignment') > -1
+        \ || match(a:i['text'], 'duplicate argument') > -1
+        \ || match(a:i['text'], 'after other statements') > -1
+        \ || match(a:i['text'], 'shadowed by loop variable') > -1
+
+        " fun with Python's %r: try "..." first, then '...'
+        let terms =  split(a:i['text'], '"', 1)
+        if len(terms) > 2
+            return terms[1]
+        endif
+
+        let terms =  split(a:i['text'], "'", 1)
+        if len(terms) > 2
+            return terms[1]
+        endif
+    endif
+    return ''
+endfunction
+
+function! SyntaxCheckers_python_pyflakes_GetLocList()
+    let makeprg = syntastic#makeprg#build({
+        \ 'exe': 'pyflakes',
+        \ 'filetype': 'python',
+        \ 'subchecker': 'pyflakes' })
+
+    let errorformat =
+        \ '%E%f:%l: could not compile,'.
+        \ '%-Z%p^,'.
+        \ '%E%f:%l:%c: %m,'.
+        \ '%E%f:%l: %m,'.
+        \ '%-G%.%#'
+
+    return SyntasticMake({
+        \ 'makeprg': makeprg,
+        \ 'errorformat': errorformat,
+        \ 'defaults': {'text': "Syntax error"} })
+endfunction
+
+call g:SyntasticRegistry.CreateAndRegisterChecker({
+    \ 'filetype': 'python',
+    \ 'name': 'pyflakes'})
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/config/.vim/syntax_checkers/python/pylama.vim	Wed Nov 06 14:33:18 2013 +0100
@@ -0,0 +1,67 @@
+"============================================================================
+"File:        pylama.vim
+"Description: Syntax checking plugin for syntastic.vim
+"Maintainer:  LCD 47 <lcd047 at gmail dot com>
+"License:     This program is free software. It comes without any warranty,
+"             to the extent permitted by applicable law. You can redistribute
+"             it and/or modify it under the terms of the Do What The Fuck You
+"             Want To Public License, Version 2, as published by Sam Hocevar.
+"             See http://sam.zoy.org/wtfpl/COPYING for more details.
+"
+"============================================================================
+if exists('g:loaded_syntastic_python_pylama_checker')
+    finish
+endif
+let g:loaded_syntastic_python_pylama_checker = 1
+
+function! SyntaxCheckers_python_pylama_IsAvailable()
+    return executable('pylama')
+endfunction
+
+function! SyntaxCheckers_python_pylama_GetHighlightRegex(i)
+    return SyntaxCheckers_python_pyflakes_GetHighlightRegex(a:i)
+endfunction
+
+function! SyntaxCheckers_python_pylama_GetLocList()
+    let makeprg = syntastic#makeprg#build({
+        \ 'exe': 'pylama',
+        \ 'post_args': '-f pep8',
+        \ 'filetype': 'python',
+        \ 'subchecker': 'pylama' })
+
+    " TODO: "WARNING:pylama:..." messages are probably a logging bug
+    let errorformat =
+        \ '%-GWARNING:pylama:%.%#,' .
+        \ '%A%f:%l:%c: %m'
+
+    let loclist = SyntasticMake({
+        \ 'makeprg': makeprg,
+        \ 'errorformat': errorformat,
+        \ 'postprocess': ['sort'] })
+
+    " adjust for weirdness in each checker
+    for n in range(len(loclist))
+        let loclist[n]['type'] = match(['R', 'C', 'W'], loclist[n]['text'][0]) >= 0 ? 'W' : 'E'
+        if loclist[n]['text'] =~# '\v\[%(mccabe|pep257|pylint)\]$'
+            if has_key(loclist[n], 'col')
+                let loclist[n]['col'] += 1
+            endif
+        endif
+        if loclist[n]['text'] =~# '\v\[pylint\]$'
+            if has_key(loclist[n], 'vcol')
+                let loclist[n]['vcol'] = 0
+            endif
+        endif
+        if loclist[n]['text'] =~# '\v\[%(mccabe|pep257|pep8)\]$'
+            let loclist[n]['subtype'] = 'Style'
+        endif
+    endfor
+
+    return loclist
+endfunction
+
+call g:SyntasticRegistry.CreateAndRegisterChecker({
+    \ 'filetype': 'python',
+    \ 'name': 'pylama' })
+
+runtime! syntax_checkers/python/pyflakes.vim
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/config/.vim/syntax_checkers/python/pylint.vim	Wed Nov 06 14:33:18 2013 +0100
@@ -0,0 +1,58 @@
+"============================================================================
+"File:        pylint.vim
+"Description: Syntax checking plugin for syntastic.vim
+"Author:      Parantapa Bhattacharya <parantapa at gmail dot com>
+"
+"============================================================================
+if exists("g:loaded_syntastic_python_pylint_checker")
+    finish
+endif
+let g:loaded_syntastic_python_pylint_checker=1
+
+function! SyntaxCheckers_python_pylint_IsAvailable()
+    return executable('pylint')
+endfunction
+
+function! SyntaxCheckers_python_pylint_GetLocList()
+    let pylint_new = s:PylintNew()
+
+    let makeprg = syntastic#makeprg#build({
+        \ 'exe': 'pylint',
+        \ 'args': (pylint_new ? '--msg-template="{path}:{line}: [{msg_id}] {msg}" -r n' : '-f parseable -r n -i y'),
+        \ 'filetype': 'python',
+        \ 'subchecker': 'pylint' })
+
+    let errorformat =
+        \ '%A%f:%l: %m,' .
+        \ '%A%f:(%l): %m,' .
+        \ '%-Z%p^%.%#,' .
+        \ '%-G%.%#'
+
+    let loclist=SyntasticMake({
+        \ 'makeprg': makeprg,
+        \ 'errorformat': errorformat,
+        \ 'postprocess': ['sort'] })
+
+    for n in range(len(loclist))
+        let type = loclist[n]['text'][1]
+        if type =~# '\m^[EF]'
+            let loclist[n]['type'] = 'E'
+        elseif type =~# '\m^[CRW]'
+            let loclist[n]['type'] = 'W'
+        else
+            let loclist[n]['valid'] = 0
+        endif
+        let loclist[n]['vcol'] = 0
+    endfor
+
+    return loclist
+endfunction
+
+function s:PylintNew()
+    let pylint_version = filter(split(system('pylint --version'), '\m, \|\n'), 'v:val =~# "^pylint"')[0]
+    return syntastic#util#versionIsAtLeast(syntastic#util#parseVersion(pylint_version), [1])
+endfunction
+
+call g:SyntasticRegistry.CreateAndRegisterChecker({
+    \ 'filetype': 'python',
+    \ 'name': 'pylint' })
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/config/.vim/syntax_checkers/python/python.vim	Wed Nov 06 14:33:18 2013 +0100
@@ -0,0 +1,43 @@
+"============================================================================
+"File:        python.vim
+"Description: Syntax checking plugin for syntastic.vim
+"Author:      Artem Nezvigin <artem at artnez dot com>
+"
+" `errorformat` derived from:
+" http://www.vim.org/scripts/download_script.php?src_id=1392
+"
+"============================================================================
+if exists("g:loaded_syntastic_python_python_checker")
+    finish
+endif
+let g:loaded_syntastic_python_python_checker=1
+
+function! SyntaxCheckers_python_python_IsAvailable()
+    return executable('python')
+endfunction
+
+function! SyntaxCheckers_python_python_GetLocList()
+    let fname = "'" . escape(expand('%'), "\\'") . "'"
+
+    let makeprg = syntastic#makeprg#build({
+        \ 'exe': 'python',
+        \ 'args': '-c',
+        \ 'fname': syntastic#util#shescape("compile(open(" . fname . ").read(), " . fname . ", 'exec')"),
+        \ 'filetype': 'python',
+        \ 'subchecker': 'python' })
+
+    let errorformat =
+        \ '%E  File "%f"\, line %l,' .
+        \ '%C    %p^,' .
+        \ '%C    %.%#,' .
+        \ '%Z%m,' .
+        \ '%-G%.%#'
+
+    return SyntasticMake({
+        \ 'makeprg': makeprg,
+        \ 'errorformat': errorformat })
+endfunction
+
+call g:SyntasticRegistry.CreateAndRegisterChecker({
+    \ 'filetype': 'python',
+    \ 'name': 'python'})
--- a/config/.vim/syntax_checkers/rst.vim	Thu Sep 05 16:23:33 2013 +0200
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,37 +0,0 @@
-"============================================================================
-"File:        rst.vim
-"Description: Syntax checking plugin for docutil's reStructuredText files
-"Maintainer:  James Rowe <jnrowe at gmail dot com>
-"License:     This program is free software. It comes without any warranty,
-"             to the extent permitted by applicable law. You can redistribute
-"             it and/or modify it under the terms of the Do What The Fuck You
-"             Want To Public License, Version 2, as published by Sam Hocevar.
-"             See http://sam.zoy.org/wtfpl/COPYING for more details.
-"
-"============================================================================
-
-" We use rst2pseudoxml.py, as it is ever so marginally faster than the other
-" rst2${x} tools in docutils.
-
-if exists("loaded_rst_syntax_checker")
-    finish
-endif
-let loaded_rst_syntax_checker = 1
-
-"bail if the user doesn't have rst2pseudoxml.py installed
-if !executable("rst2pseudoxml.py")
-    finish
-endif
-
-function! SyntaxCheckers_rst_GetLocList()
-    let makeprg = 'rst2pseudoxml.py --report=1 --exit-status=1 ' .
-      \ shellescape(expand('%')) . ' /dev/null'
-
-    let errorformat = '%f:%l:\ (%tNFO/1)\ %m,
-      \%f:%l:\ (%tARNING/2)\ %m,
-      \%f:%l:\ (%tRROR/3)\ %m,
-      \%f:%l:\ (%tEVERE/4)\ %m,
-      \%-G%.%#'
-
-    return SyntasticMake({ 'makeprg': makeprg, 'errorformat': errorformat })
-endfunction
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/config/.vim/syntax_checkers/rst/rst2pseudoxml.vim	Wed Nov 06 14:33:18 2013 +0100
@@ -0,0 +1,62 @@
+"============================================================================
+"File:        rst.vim
+"Description: Syntax checking plugin for docutil's reStructuredText files
+"Maintainer:  James Rowe <jnrowe at gmail dot com>
+"License:     This program is free software. It comes without any warranty,
+"             to the extent permitted by applicable law. You can redistribute
+"             it and/or modify it under the terms of the Do What The Fuck You
+"             Want To Public License, Version 2, as published by Sam Hocevar.
+"             See http://sam.zoy.org/wtfpl/COPYING for more details.
+"
+"============================================================================
+
+" We use rst2pseudoxml.py, as it is ever so marginally faster than the other
+" rst2${x} tools in docutils.
+
+if exists("g:loaded_syntastic_rst_rst2pseudoxml_checker")
+    finish
+endif
+let g:loaded_syntastic_rst_rst2pseudoxml_checker=1
+
+function! SyntaxCheckers_rst_rst2pseudoxml_IsAvailable()
+    return executable("rst2pseudoxml.py") || executable("rst2pseudoxml")
+endfunction
+
+function! SyntaxCheckers_rst_rst2pseudoxml_GetLocList()
+    let makeprg = syntastic#makeprg#build({
+        \ 'exe': s:exe(),
+        \ 'args': '--report=2 --exit-status=1',
+        \ 'tail': syntastic#util#DevNull(),
+        \ 'filetype': 'rst',
+        \ 'subchecker': 'rst2pseudoxml' })
+
+    let errorformat =
+        \ '%f:%l: (%tNFO/1) %m,'.
+        \ '%f:%l: (%tARNING/2) %m,'.
+        \ '%f:%l: (%tRROR/3) %m,'.
+        \ '%f:%l: (%tEVERE/4) %m,'.
+        \ '%-G%.%#'
+
+    let loclist = SyntasticMake({
+        \ 'makeprg': makeprg,
+        \ 'errorformat': errorformat })
+
+    for n in range(len(loclist))
+        if loclist[n]['type'] ==? 'S'
+            let loclist[n]['type'] = 'E'
+        elseif loclist[n]['type'] ==? 'I'
+            let loclist[n]['type'] = 'W'
+            let loclist[n]['subtype'] = 'Style'
+        endif
+    endfor
+
+    return loclist
+endfunction
+
+function s:exe()
+    return executable("rst2pseudoxml.py") ? "rst2pseudoxml.py" : "rst2pseudoxml"
+endfunction
+
+call g:SyntasticRegistry.CreateAndRegisterChecker({
+    \ 'filetype': 'rst',
+    \ 'name': 'rst2pseudoxml'})
--- a/config/.vim/syntax_checkers/ruby.vim	Thu Sep 05 16:23:33 2013 +0200
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,32 +0,0 @@
-"============================================================================
-"File:        ruby.vim
-"Description: Syntax checking plugin for syntastic.vim
-"Maintainer:  Martin Grenfell <martin.grenfell at gmail dot com>
-"License:     This program is free software. It comes without any warranty,
-"             to the extent permitted by applicable law. You can redistribute
-"             it and/or modify it under the terms of the Do What The Fuck You
-"             Want To Public License, Version 2, as published by Sam Hocevar.
-"             See http://sam.zoy.org/wtfpl/COPYING for more details.
-"
-"============================================================================
-if exists("loaded_ruby_syntax_checker")
-    finish
-endif
-let loaded_ruby_syntax_checker = 1
-
-"bail if the user doesnt have ruby installed
-if !executable("ruby")
-    finish
-endif
-
-function! SyntaxCheckers_ruby_GetLocList()
-    " we cannot set RUBYOPT on windows like that
-    if has('win32') || has('win64')
-        let makeprg = 'ruby -W1 -T1 -c '.shellescape(expand('%'))
-    else
-        let makeprg = 'RUBYOPT= ruby -W1 -c '.shellescape(expand('%'))
-    endif
-    let errorformat =  '%-GSyntax OK,%E%f:%l: syntax error\, %m,%Z%p^,%W%f:%l: warning: %m,%Z%p^,%W%f:%l: %m,%-C%.%#'
-
-    return SyntasticMake({ 'makeprg': makeprg, 'errorformat': errorformat })
-endfunction
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/config/.vim/syntax_checkers/ruby/jruby.vim	Wed Nov 06 14:33:18 2013 +0100
@@ -0,0 +1,52 @@
+"============================================================================
+"File:        jruby.vim
+"Description: Syntax checking plugin for syntastic.vim
+"Maintainer:  Leonid Shevtsov <leonid at shevtsov dot me>
+"License:     This program is free software. It comes without any warranty,
+"             to the extent permitted by applicable law. You can redistribute
+"             it and/or modify it under the terms of the Do What The Fuck You
+"             Want To Public License, Version 2, as published by Sam Hocevar.
+"             See http://sam.zoy.org/wtfpl/COPYING for more details.
+"
+"============================================================================
+if exists("g:loaded_syntastic_ruby_jruby_checker")
+    finish
+endif
+let g:loaded_syntastic_ruby_jruby_checker=1
+
+function! SyntaxCheckers_ruby_jruby_IsAvailable()
+    return executable('jruby')
+endfunction
+
+function! SyntaxCheckers_ruby_jruby_GetLocList()
+    let makeprg = syntastic#makeprg#build({
+        \ 'exe': s:exe(),
+        \ 'args': s:args(),
+        \ 'filetype': 'ruby',
+        \ 'subchecker': 'jruby' })
+
+    let errorformat =
+        \ '%-GSyntax OK for %f,'.
+        \ '%ESyntaxError in %f:%l: syntax error\, %m,'.
+        \ '%Z%p^,'.
+        \ '%W%f:%l: warning: %m,'.
+        \ '%Z%p^,'.
+        \ '%W%f:%l: %m,'.
+        \ '%-C%.%#'
+
+    return SyntasticMake({
+        \ 'makeprg': makeprg,
+        \ 'errorformat': errorformat })
+endfunction
+
+function s:args()
+    return has('win32') ? '-W1 -T1 -c' : '-W1 -c'
+endfunction
+
+function s:exe()
+    return has('win32') ? 'jruby' : 'RUBYOPT= jruby'
+endfunction
+
+call g:SyntasticRegistry.CreateAndRegisterChecker({
+    \ 'filetype': 'ruby',
+    \ 'name': 'jruby'})
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/config/.vim/syntax_checkers/ruby/macruby.vim	Wed Nov 06 14:33:18 2013 +0100
@@ -0,0 +1,43 @@
+"============================================================================
+"File:        macruby.vim
+"Description: Syntax checking plugin for syntastic.vim
+"License:     This program is free software. It comes without any warranty,
+"             to the extent permitted by applicable law. You can redistribute
+"             it and/or modify it under the terms of the Do What The Fuck You
+"             Want To Public License, Version 2, as published by Sam Hocevar.
+"             See http://sam.zoy.org/wtfpl/COPYING for more details.
+"
+"============================================================================
+if exists("g:loaded_syntastic_ruby_macruby_checker")
+    finish
+endif
+let g:loaded_syntastic_ruby_macruby_checker=1
+
+function! SyntaxCheckers_ruby_macruby_IsAvailable()
+    return executable('macruby')
+endfunction
+
+function! SyntaxCheckers_ruby_macruby_GetLocList()
+    let makeprg = syntastic#makeprg#build({
+        \ 'exe': 'RUBYOPT= macruby',
+        \ 'args': '-W1 -c',
+        \ 'filetype': 'ruby',
+        \ 'subchecker': 'macruby' })
+
+    let errorformat =
+        \ '%-GSyntax OK,'.
+        \ '%E%f:%l: syntax error\, %m,'.
+        \ '%Z%p^,'.
+        \ '%W%f:%l: warning: %m,'.
+        \ '%Z%p^,'.
+        \ '%W%f:%l: %m,'.
+        \ '%-C%.%#'
+
+    return SyntasticMake({
+        \ 'makeprg': makeprg,
+        \ 'errorformat': errorformat })
+endfunction
+
+call g:SyntasticRegistry.CreateAndRegisterChecker({
+    \ 'filetype': 'ruby',
+    \ 'name': 'macruby'})
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/config/.vim/syntax_checkers/ruby/mri.vim	Wed Nov 06 14:33:18 2013 +0100
@@ -0,0 +1,77 @@
+"============================================================================
+"File:        mri.vim
+"Description: Syntax checking plugin for syntastic.vim
+"Maintainer:  Martin Grenfell <martin.grenfell at gmail dot com>
+"License:     This program is free software. It comes without any warranty,
+"             to the extent permitted by applicable law. You can redistribute
+"             it and/or modify it under the terms of the Do What The Fuck You
+"             Want To Public License, Version 2, as published by Sam Hocevar.
+"             See http://sam.zoy.org/wtfpl/COPYING for more details.
+"
+"============================================================================
+
+if exists("g:loaded_syntastic_ruby_mri_checker")
+    finish
+endif
+let g:loaded_syntastic_ruby_mri_checker=1
+
+if !exists("g:syntastic_ruby_exec")
+    let g:syntastic_ruby_exec = "ruby"
+endif
+
+function! SyntaxCheckers_ruby_mri_IsAvailable()
+    return executable(expand(g:syntastic_ruby_exec))
+endfunction
+
+function! SyntaxCheckers_ruby_mri_GetHighlightRegex(i)
+    if match(a:i['text'], 'assigned but unused variable') > -1
+        let term = split(a:i['text'], ' - ')[1]
+        return '\V\<'.term.'\>'
+    endif
+
+    return ''
+endfunction
+
+function! SyntaxCheckers_ruby_mri_GetLocList()
+    let exe = expand(g:syntastic_ruby_exec)
+    if !has('win32')
+        let exe = 'RUBYOPT= ' . exe
+    endif
+
+    let makeprg = syntastic#makeprg#build({
+        \ 'exe': exe,
+        \ 'args': '-w -T1 -c',
+        \ 'filetype': 'ruby',
+        \ 'subchecker': 'mri' })
+
+    "this is a hack to filter out a repeated useless warning in rspec files
+    "containing lines like
+    "
+    "  foo.should == 'bar'
+    "
+    "Which always generate the warning below. Note that ruby >= 1.9.3 includes
+    "the word "possibly" in the warning
+    let errorformat = '%-G%.%#warning: %\(possibly %\)%\?useless use of == in void context,'
+
+    " filter out lines starting with ...
+    " long lines are truncated and wrapped in ... %p then returns the wrong
+    " column offset
+    let errorformat .= '%-G%\%.%\%.%\%.%.%#,'
+
+    let errorformat .=
+        \ '%-GSyntax OK,'.
+        \ '%E%f:%l: syntax error\, %m,'.
+        \ '%Z%p^,'.
+        \ '%W%f:%l: warning: %m,'.
+        \ '%Z%p^,'.
+        \ '%W%f:%l: %m,'.
+        \ '%-C%.%#'
+
+    return SyntasticMake({
+        \ 'makeprg': makeprg,
+        \ 'errorformat': errorformat })
+endfunction
+
+call g:SyntasticRegistry.CreateAndRegisterChecker({
+    \ 'filetype': 'ruby',
+    \ 'name': 'mri'})
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/config/.vim/syntax_checkers/ruby/rubocop.vim	Wed Nov 06 14:33:18 2013 +0100
@@ -0,0 +1,55 @@
+"============================================================================
+"File:        rubocop.vim
+"Description: Syntax checking plugin for syntastic.vim
+"Maintainer:  Recai OktaÅŸ <roktas@bil.omu.edu.tr>
+"License:     This program is free software. It comes without any warranty,
+"             to the extent permitted by applicable law. You can redistribute
+"             it and/or modify it under the terms of the Do What The Fuck You
+"             Want To Public License, Version 2, as published by Sam Hocevar.
+"             See http://sam.zoy.org/wtfpl/COPYING for more details.
+"
+"============================================================================
+"
+" In order to use rubocop with the default ruby checker (mri):
+"     let g:syntastic_ruby_checkers = ['mri', 'rubocop']
+
+if exists("g:loaded_syntastic_ruby_rubocop_checker")
+    finish
+endif
+let g:loaded_syntastic_ruby_rubocop_checker=1
+
+function! SyntaxCheckers_ruby_rubocop_IsAvailable()
+    return
+        \ executable('rubocop') &&
+        \ syntastic#util#versionIsAtLeast(syntastic#util#parseVersion('rubocop --version'), [0,9,0])
+endfunction
+
+function! SyntaxCheckers_ruby_rubocop_GetLocList()
+    let makeprg = syntastic#makeprg#build({
+        \ 'exe': 'rubocop',
+        \ 'args': '--format emacs --silent',
+        \ 'filetype': 'ruby',
+        \ 'subchecker': 'rubocop' })
+
+    let errorformat = '%f:%l:%c: %t: %m'
+
+    let loclist = SyntasticMake({
+        \ 'makeprg': makeprg,
+        \ 'errorformat': errorformat,
+        \ 'subtype': 'Style'})
+
+    " convert rubocop severities to error types recognized by syntastic
+    for n in range(len(loclist))
+        if loclist[n]['type'] == 'F'
+            let loclist[n]['type'] = 'E'
+        elseif loclist[n]['type'] != 'W' && loclist[n]['type'] != 'E'
+            let loclist[n]['type'] = 'W'
+        endif
+    endfor
+
+    return loclist
+endfunction
+
+call g:SyntasticRegistry.CreateAndRegisterChecker({
+    \ 'filetype': 'ruby',
+    \ 'name': 'rubocop'})
--- a/config/.vim/syntax_checkers/rust.vim	Thu Sep 05 16:23:33 2013 +0200
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,33 +0,0 @@
-"============================================================================
-"File:        rust.vim
-"Description: Syntax checking plugin for syntastic.vim
-"Maintainer:  Chad Jablonski <chad.jablonski at gmail dot com>
-"License:     This program is free software. It comes without any warranty,
-"             to the extent permitted by applicable law. You can redistribute
-"             it and/or modify it under the terms of the Do What The Fuck You
-"             Want To Public License, Version 2, as published by Sam Hocevar.
-"             See http://sam.zoy.org/wtfpl/COPYING for more details.
-"
-"============================================================================
-if exists("loaded_rust_syntax_checker")
-    finish
-endif
-let loaded_rust_syntax_checker = 1
-
-"bail if the user doesnt have rustc installed
-if !executable("rustc")
-    finish
-endif
-
-function! SyntaxCheckers_rust_GetLocList()
-    let makeprg = 'rustc --parse-only '.shellescape(expand('%'))
-
-    let errorformat  = '%E%f:%l:%c: \\d%#:\\d%# %.%\{-}error:%.%\{-} %m,'   .
-                     \ '%W%f:%l:%c: \\d%#:\\d%# %.%\{-}warning:%.%\{-} %m,' .
-                     \ '%C%f:%l %m,' .
-                     \ '%-Z%.%#'
-
-    return SyntasticMake({ 'makeprg': makeprg, 'errorformat': errorformat })
-endfunction
-
-
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/config/.vim/syntax_checkers/rust/rustc.vim	Wed Nov 06 14:33:18 2013 +0100
@@ -0,0 +1,42 @@
+"============================================================================
+"File:        rust.vim
+"Description: Syntax checking plugin for syntastic.vim
+"Maintainer:  Chad Jablonski <chad.jablonski at gmail dot com>
+"License:     This program is free software. It comes without any warranty,
+"             to the extent permitted by applicable law. You can redistribute
+"             it and/or modify it under the terms of the Do What The Fuck You
+"             Want To Public License, Version 2, as published by Sam Hocevar.
+"             See http://sam.zoy.org/wtfpl/COPYING for more details.
+"
+"============================================================================
+
+if exists("g:loaded_syntastic_rust_rustc_checker")
+    finish
+endif
+let g:loaded_syntastic_rust_rustc_checker=1
+
+function! SyntaxCheckers_rust_rustc_IsAvailable()
+    return executable("rustc")
+endfunction
+
+function! SyntaxCheckers_rust_rustc_GetLocList()
+    let makeprg = syntastic#makeprg#build({
+        \ 'exe': 'rustc',
+        \ 'args': '--parse-only',
+        \ 'filetype': 'rust',
+        \ 'subchecker': 'rustc' })
+
+    let errorformat  =
+        \ '%E%f:%l:%c: \\d%#:\\d%# %.%\{-}error:%.%\{-} %m,'   .
+        \ '%W%f:%l:%c: \\d%#:\\d%# %.%\{-}warning:%.%\{-} %m,' .
+        \ '%C%f:%l %m,' .
+        \ '%-Z%.%#'
+
+    return SyntasticMake({
+        \ 'makeprg': makeprg,
+        \ 'errorformat': errorformat })
+endfunction
+
+call g:SyntasticRegistry.CreateAndRegisterChecker({
+    \ 'filetype': 'rust',
+    \ 'name': 'rustc'})
--- a/config/.vim/syntax_checkers/sass.vim	Thu Sep 05 16:23:33 2013 +0200
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,35 +0,0 @@
-"============================================================================
-"File:        sass.vim
-"Description: Syntax checking plugin for syntastic.vim
-"Maintainer:  Martin Grenfell <martin.grenfell at gmail dot com>
-"License:     This program is free software. It comes without any warranty,
-"             to the extent permitted by applicable law. You can redistribute
-"             it and/or modify it under the terms of the Do What The Fuck You
-"             Want To Public License, Version 2, as published by Sam Hocevar.
-"             See http://sam.zoy.org/wtfpl/COPYING for more details.
-"
-"============================================================================
-if exists("loaded_sass_syntax_checker")
-    finish
-endif
-let loaded_sass_syntax_checker = 1
-
-"bail if the user doesnt have the sass binary installed
-if !executable("sass")
-    finish
-endif
-
-"use compass imports if available
-let s:imports = ""
-if executable("compass")
-    let s:imports = "--compass"
-endif
-
-function! SyntaxCheckers_sass_GetLocList()
-    let makeprg='sass '.s:imports.' --check '.shellescape(expand('%'))
-    let errorformat = '%ESyntax %trror:%m,%C        on line %l of %f,%Z%.%#'
-    let errorformat .= ',%Wwarning on line %l:,%Z%m,Syntax %trror on line %l: %m'
-    let loclist = SyntasticMake({ 'makeprg': makeprg, 'errorformat': errorformat })
-
-    return loclist
-endfunction
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/config/.vim/syntax_checkers/sass/sass.vim	Wed Nov 06 14:33:18 2013 +0100
@@ -0,0 +1,78 @@
+"============================================================================
+"File:        sass.vim
+"Description: Syntax checking plugin for syntastic.vim
+"Maintainer:  Martin Grenfell <martin.grenfell at gmail dot com>
+"License:     This program is free software. It comes without any warranty,
+"             to the extent permitted by applicable law. You can redistribute
+"             it and/or modify it under the terms of the Do What The Fuck You
+"             Want To Public License, Version 2, as published by Sam Hocevar.
+"             See http://sam.zoy.org/wtfpl/COPYING for more details.
+"
+"============================================================================
+
+if exists("g:loaded_syntastic_sass_sass_checker")
+    finish
+endif
+let g:loaded_syntastic_sass_sass_checker=1
+
+function! SyntaxCheckers_sass_sass_IsAvailable()
+    return executable("sass")
+endfunction
+
+"sass caching for large files drastically speeds up the checking, but store it
+"in a temp location otherwise sass puts .sass_cache dirs in the users project
+let s:sass_cache_location = tempname()
+
+"By default do not check partials as unknown variables are a syntax error
+if !exists("g:syntastic_sass_check_partials")
+    let g:syntastic_sass_check_partials = 0
+endif
+
+"use compass imports if available
+let s:imports = ""
+if executable("compass")
+    let s:imports = "--compass"
+endif
+
+function! SyntaxCheckers_sass_sass_GetLocList()
+    if !g:syntastic_sass_check_partials && expand('%:t')[0] == '_'
+        return []
+    endif
+
+    let makeprg = syntastic#makeprg#build({
+        \ 'exe': 'sass',
+        \ 'args': '--cache-location ' . s:sass_cache_location . ' ' . s:imports . ' --check',
+        \ 'filetype': 'sass',
+        \ 'subchecker': 'sass' })
+
+    let errorformat =
+        \ '%ESyntax %trror: %m,' .
+        \ '%+C              %.%#,' .
+        \ '%C        on line %l of %f\, %.%#,' .
+        \ '%C        on line %l of %f,' .
+        \ '%-G %\+from line %.%#,' .
+        \ '%-G %\+Use --trace for backtrace.,' .
+        \ '%W%>DEPRECATION WARNING on line %l of %f:,' .
+        \ '%+C%>  %.%#,' .
+        \ '%W%>WARNING: on line %l of %f:,' .
+        \ '%+C%>  %.%#,' .
+        \ '%W%>WARNING on line %l of %f: %m,' .
+        \ '%+C%>  %.%#,' .
+        \ '%W%>WARNING on line %l of %f:,' .
+        \ '%Z%m,' .
+        \ '%W%>WARNING: %m,' .
+        \ '%C         on line %l of %f\, %.%#,' .
+        \ '%C         on line %l of %f,' .
+        \ '%-G %\+from line %.%#,' .
+        \ 'Syntax %trror on line %l: %m,' .
+        \ '%-G%.%#'
+
+    return SyntasticMake({
+        \ 'makeprg': makeprg,
+        \ 'errorformat': errorformat,
+        \ 'postprocess': ['compressWhitespace'] })
+endfunction
+
+call g:SyntasticRegistry.CreateAndRegisterChecker({
+    \ 'filetype': 'sass',
+    \ 'name': 'sass'})
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/config/.vim/syntax_checkers/scala/fsc.vim	Wed Nov 06 14:33:18 2013 +0100
@@ -0,0 +1,46 @@
+"============================================================================
+"File:        fsc.vim
+"Description: Syntax checking plugin for syntastic.vim
+"Maintainer:  Gregor Uhlenheuer <kongo2002 at gmail dot com>
+"License:     This program is free software. It comes without any warranty,
+"             to the extent permitted by applicable law. You can redistribute
+"             it and/or modify it under the terms of the Do What The Fuck You
+"             Want To Public License, Version 2, as published by Sam Hocevar.
+"             See http://sam.zoy.org/wtfpl/COPYING for more details.
+"
+"============================================================================
+
+if exists('g:loaded_syntastic_scala_fsc_checker')
+    finish
+endif
+let g:loaded_syntastic_scala_fsc_checker = 1
+
+function! SyntaxCheckers_scala_fsc_IsAvailable()
+    return executable('fsc')
+endfunction
+
+if !exists('g:syntastic_scala_options')
+    let g:syntastic_scala_options = ''
+endif
+
+function! SyntaxCheckers_scala_fsc_GetLocList()
+    " fsc has some serious problems with the
+    " working directory changing after being started
+    " that's why we better pass an absolute path
+    let makeprg = syntastic#makeprg#build({
+        \ 'exe': 'fsc',
+        \ 'args': '-Ystop-after:parser ' . g:syntastic_scala_options,
+        \ 'fname': syntastic#util#shexpand('%:p'),
+        \ 'filetype': 'scala',
+        \ 'subchecker': 'fsc' })
+
+    let errorformat = '%f:%l: %trror: %m'
+
+    return SyntasticMake({
+        \ 'makeprg': makeprg,
+        \ 'errorformat': errorformat })
+endfunction
+
+call g:SyntasticRegistry.CreateAndRegisterChecker({
+    \ 'filetype': 'scala',
+    \ 'name': 'fsc'})
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/config/.vim/syntax_checkers/scala/scalac.vim	Wed Nov 06 14:33:18 2013 +0100
@@ -0,0 +1,43 @@
+"============================================================================
+"File:        scala.vim
+"Description: Syntax checking plugin for syntastic.vim
+"Maintainer:  Rickey Visinski <rickeyvisinski at gmail dot com>
+"License:     This program is free software. It comes without any warranty,
+"             to the extent permitted by applicable law. You can redistribute
+"             it and/or modify it under the terms of the Do What The Fuck You
+"             Want To Public License, Version 2, as published by Sam Hocevar.
+"             See http://sam.zoy.org/wtfpl/COPYING for more details.
+"
+"============================================================================
+
+if exists("g:loaded_syntastic_scala_scalac_checker")
+    finish
+endif
+let g:loaded_syntastic_scala_scalac_checker=1
+
+function! SyntaxCheckers_scala_scalac_IsAvailable()
+    return executable("scalac")
+endfunction
+
+if !exists('g:syntastic_scala_options')
+    let g:syntastic_scala_options = ''
+endif
+
+
+function! SyntaxCheckers_scala_scalac_GetLocList()
+    let makeprg = syntastic#makeprg#build({
+        \ 'exe': 'scalac',
+        \ 'args': '-Ystop-after:parser ' . g:syntastic_scala_options,
+        \ 'filetype': 'scala',
+        \ 'subchecker': 'scalac' })
+
+    let errorformat = '%f:%l: %trror: %m'
+
+    return SyntasticMake({
+        \ 'makeprg': makeprg,
+        \ 'errorformat': errorformat })
+endfunction
+
+call g:SyntasticRegistry.CreateAndRegisterChecker({
+    \ 'filetype': 'scala',
+    \ 'name': 'scalac'})
--- a/config/.vim/syntax_checkers/scss.vim	Thu Sep 05 16:23:33 2013 +0200
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,27 +0,0 @@
-
-"============================================================================
-"File:        scss.vim
-"Description: scss syntax checking plugin for syntastic
-"Maintainer:  Martin Grenfell <martin.grenfell at gmail dot com>
-"License:     This program is free software. It comes without any warranty,
-"             to the extent permitted by applicable law. You can redistribute
-"             it and/or modify it under the terms of the Do What The Fuck You
-"             Want To Public License, Version 2, as published by Sam Hocevar.
-"             See http://sam.zoy.org/wtfpl/COPYING for more details.
-"
-"============================================================================
-if exists("loaded_scss_syntax_checker")
-    finish
-endif
-let loaded_scss_syntax_checker = 1
-
-"bail if the user doesnt have the sass binary installed
-if !executable("sass")
-    finish
-endif
-
-runtime syntax_checkers/sass.vim
-
-function! SyntaxCheckers_scss_GetLocList()
-    return SyntaxCheckers_sass_GetLocList()
-endfunction
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/config/.vim/syntax_checkers/scss/sass.vim	Wed Nov 06 14:33:18 2013 +0100
@@ -0,0 +1,31 @@
+
+"============================================================================
+"File:        scss.vim
+"Description: scss syntax checking plugin for syntastic
+"Maintainer:  Martin Grenfell <martin.grenfell at gmail dot com>
+"License:     This program is free software. It comes without any warranty,
+"             to the extent permitted by applicable law. You can redistribute
+"             it and/or modify it under the terms of the Do What The Fuck You
+"             Want To Public License, Version 2, as published by Sam Hocevar.
+"             See http://sam.zoy.org/wtfpl/COPYING for more details.
+"
+"============================================================================
+
+if exists("g:loaded_syntastic_scss_sass_checker")
+    finish
+endif
+let g:loaded_syntastic_scss_sass_checker=1
+
+function! SyntaxCheckers_scss_sass_IsAvailable()
+    return SyntaxCheckers_sass_sass_IsAvailable()
+endfunction
+
+function! SyntaxCheckers_scss_sass_GetLocList()
+    return SyntaxCheckers_sass_sass_GetLocList()
+endfunction
+
+call g:SyntasticRegistry.CreateAndRegisterChecker({
+    \ 'filetype': 'scss',
+    \ 'name': 'sass'})
+
+runtime! syntax_checkers/sass/*.vim
--- a/config/.vim/syntax_checkers/sh.vim	Thu Sep 05 16:23:33 2013 +0200
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,52 +0,0 @@
-"============================================================================
-"File:        sh.vim
-"Description: Syntax checking plugin for syntastic.vim
-"Maintainer:  Gregor Uhlenheuer <kongo2002 at gmail dot com>
-"License:     This program is free software. It comes without any warranty,
-"             to the extent permitted by applicable law. You can redistribute
-"             it and/or modify it under the terms of the Do What The Fuck You
-"             Want To Public License, Version 2, as published by Sam Hocevar.
-"             See http://sam.zoy.org/wtfpl/COPYING for more details.
-"
-"============================================================================
-if exists('loaded_sh_syntax_checker')
-    finish
-endif
-let loaded_sh_syntax_checker = 1
-
-function! s:GetShell()
-    if !exists('b:shell') || b:shell == ""
-        let b:shell = ''
-        let shebang = getbufline(bufnr('%'), 1)[0]
-        if len(shebang) > 0
-            if match(shebang, 'bash') >= 0
-                let b:shell = 'bash'
-            elseif match(shebang, 'zsh') >= 0
-                let b:shell = 'zsh'
-            elseif match(shebang, 'sh') >= 0
-                let b:shell = 'sh'
-            endif
-        endif
-    endif
-    return b:shell
-endfunction
-
-function! SyntaxCheckers_sh_GetLocList()
-    if len(s:GetShell()) == 0 || !executable(s:GetShell())
-        return []
-    endif
-    let output = split(system(s:GetShell().' -n '.shellescape(expand('%'))), '\n')
-    if v:shell_error != 0
-        let result = []
-        for err_line in output
-            let line = substitute(err_line, '^[^:]*:\D\{-}\(\d\+\):.*', '\1', '')
-            let msg = substitute(err_line, '^[^:]*:\D\{-}\d\+: \(.*\)', '\1', '')
-            call add(result, {'lnum' : line,
-                            \ 'text' : msg,
-                            \ 'bufnr': bufnr(''),
-                            \ 'type': 'E' })
-        endfor
-        return result
-    endif
-    return []
-endfunction
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/config/.vim/syntax_checkers/sh/checkbashisms.vim	Wed Nov 06 14:33:18 2013 +0100
@@ -0,0 +1,45 @@
+"============================================================================
+"File:        checkbashisms.vim
+"Description: Shell script syntax/style checking plugin for syntastic.vim
+"Notes:       checkbashisms.pl can be downloaded from
+"             http://debian.inode.at/debian/pool/main/d/devscripts/
+"             as part of the devscripts package.
+"============================================================================
+
+if exists("g:loaded_syntastic_sh_checkbashisms_checker")
+    finish
+endif
+let g:loaded_syntastic_sh_checkbashisms_checker=1
+
+
+function! SyntaxCheckers_sh_checkbashisms_IsAvailable()
+    return executable('checkbashisms')
+endfunction
+
+
+function! SyntaxCheckers_sh_checkbashisms_GetLocList()
+    let makeprg = syntastic#makeprg#build({
+        \ 'exe': 'checkbashisms',
+        \ 'args': '-fx',
+        \ 'filetype': 'sh',
+        \ 'subchecker': 'checkbashisms'})
+
+    let errorformat =
+        \ '%-Gscript %f is already a bash script; skipping,' .
+        \ '%Eerror: %f: %m\, opened in line %l,' .
+        \ '%Eerror: %f: %m,' .
+        \ '%Ecannot open script %f for reading: %m,' .
+        \ '%Wscript %f %m,%C%.# lines,' .
+        \ '%Wpossible bashism in %f line %l (%m):,%C%.%#,%Z.%#,' .
+        \ '%-G%.%#'
+
+    return SyntasticMake({
+        \ 'makeprg': makeprg,
+        \ 'errorformat': errorformat,
+        \ 'subtype': 'Style'})
+endfunction
+
+
+call g:SyntasticRegistry.CreateAndRegisterChecker({
+    \ 'filetype': 'sh',
+    \ 'name': 'checkbashisms'})
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/config/.vim/syntax_checkers/sh/sh.vim	Wed Nov 06 14:33:18 2013 +0100
@@ -0,0 +1,83 @@
+"============================================================================
+"File:        sh.vim
+"Description: Syntax checking plugin for syntastic.vim
+"Maintainer:  Gregor Uhlenheuer <kongo2002 at gmail dot com>
+"License:     This program is free software. It comes without any warranty,
+"             to the extent permitted by applicable law. You can redistribute
+"             it and/or modify it under the terms of the Do What The Fuck You
+"             Want To Public License, Version 2, as published by Sam Hocevar.
+"             See http://sam.zoy.org/wtfpl/COPYING for more details.
+"
+"============================================================================
+
+if exists("g:loaded_syntastic_sh_sh_checker")
+    finish
+endif
+let g:loaded_syntastic_sh_sh_checker=1
+
+function! s:GetShell()
+    if !exists('b:shell') || b:shell == ''
+        let b:shell = ''
+        let shebang = getbufline(bufnr('%'), 1)[0]
+        if len(shebang) > 0
+            if match(shebang, 'bash') >= 0
+                let b:shell = 'bash'
+            elseif match(shebang, 'zsh') >= 0
+                let b:shell = 'zsh'
+            elseif match(shebang, 'sh') >= 0
+                let b:shell = 'sh'
+            endif
+        endif
+        " try to use env variable in case no shebang could be found
+        if b:shell == ''
+            let b:shell = fnamemodify(expand('$SHELL'), ':t')
+        endif
+    endif
+    return b:shell
+endfunction
+
+function! s:ForwardToZshChecker()
+    let registry = g:SyntasticRegistry.Instance()
+    if registry.checkable('zsh')
+        return SyntaxCheckers_zsh_zsh_GetLocList()
+    else
+        return []
+    endif
+
+endfunction
+
+
+function! s:IsShellValid()
+    return len(s:GetShell()) > 0 && executable(s:GetShell())
+endfunction
+
+
+function! SyntaxCheckers_sh_sh_IsAvailable()
+    return s:IsShellValid()
+endfunction
+
+function! SyntaxCheckers_sh_sh_GetLocList()
+    if s:GetShell() == 'zsh'
+        return s:ForwardToZshChecker()
+    endif
+
+    if !s:IsShellValid()
+        return []
+    endif
+
+    let makeprg = syntastic#makeprg#build({
+        \ 'exe': s:GetShell(),
+        \ 'args': '-n',
+        \ 'filetype': 'sh',
+        \ 'subchecker': 'sh'})
+
+    let errorformat = '%f: line %l: %m'
+
+    return SyntasticMake({
+        \ 'makeprg': makeprg,
+        \ 'errorformat': errorformat})
+endfunction
+
+call g:SyntasticRegistry.CreateAndRegisterChecker({
+    \ 'filetype': 'sh',
+    \ 'name': 'sh'})
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/config/.vim/syntax_checkers/slim/slimrb.vim	Wed Nov 06 14:33:18 2013 +0100
@@ -0,0 +1,57 @@
+"============================================================================
+"File:        slim.vim
+"Description: Syntax checking plugin for syntastic.vim
+"Maintainer:  Martin Grenfell <martin.grenfell at gmail dot com>
+"License:     This program is free software. It comes without any warranty,
+"             to the extent permitted by applicable law. You can redistribute
+"             it and/or modify it under the terms of the Do What The Fuck You
+"             Want To Public License, Version 2, as published by Sam Hocevar.
+"             See http://sam.zoy.org/wtfpl/COPYING for more details.
+"
+"============================================================================
+
+if exists("g:loaded_syntastic_slim_slimrb_checker")
+    finish
+endif
+let g:loaded_syntastic_slim_slimrb_checker=1
+
+function! SyntaxCheckers_slim_slimrb_IsAvailable()
+    return executable("slimrb")
+endfunction
+
+function! s:SlimrbVersion()
+    if !exists('s:slimrb_version')
+        let s:slimrb_version = syntastic#util#parseVersion('slimrb --version 2>' . syntastic#util#DevNull())
+    end
+    return s:slimrb_version
+endfunction
+
+function! SyntaxCheckers_slim_slimrb_GetLocList()
+    let makeprg = syntastic#makeprg#build({
+        \ 'exe': 'slimrb',
+        \ 'args': '-c',
+        \ 'filetype': 'slim',
+        \ 'subchecker': 'slimrb' })
+
+    if syntastic#util#versionIsAtLeast(s:SlimrbVersion(), [1,3,1])
+        let errorformat =
+            \ '%C\ %#%f\, Line %l\, Column %c,'.
+            \ '%-G\ %.%#,'.
+            \ '%ESlim::Parser::SyntaxError: %m,'.
+            \ '%+C%.%#'
+    else
+        let errorformat =
+            \ '%C\ %#%f\, Line %l,'.
+            \ '%-G\ %.%#,'.
+            \ '%ESlim::Parser::SyntaxError: %m,'.
+            \ '%+C%.%#'
+    endif
+
+    return SyntasticMake({
+        \ 'makeprg': makeprg,
+        \ 'errorformat': errorformat })
+endfunction
+
+call g:SyntasticRegistry.CreateAndRegisterChecker({
+    \ 'filetype': 'slim',
+    \ 'name': 'slimrb'})
--- a/config/.vim/syntax_checkers/tcl.vim	Thu Sep 05 16:23:33 2013 +0200
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,28 +0,0 @@
-"============================================================================
-"File: tcl.vim
-"Description: Syntax checking plugin for syntastic.vim
-"Maintainer: Eric Thomas <eric.l.m.thomas at gmail dot com>
-"License: This program is free software. It comes without any warranty,
-" to the extent permitted by applicable law. You can redistribute
-" it and/or modify it under the terms of the Do What The Fuck You
-" Want To Public License, Version 2, as published by Sam Hocevar.
-" See http://sam.zoy.org/wtfpl/COPYING for more details.
-"
-"============================================================================
-
-if exists("loaded_tcl_syntax_checker")
-    finish
-endif
-let loaded_tcl_syntax_checker = 1
-
-"bail if the user doesnt have tclsh installed
-if !executable("tclsh")
-    finish
-endif
-
-function! SyntaxCheckers_tcl_GetLocList()
-    let makeprg = 'tclsh '.shellescape(expand('%'))
-    let errorformat = '%f:%l:%m'
-
-    return SyntasticMake({ 'makeprg': makeprg, 'errorformat': errorformat })
-endfunction
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/config/.vim/syntax_checkers/tcl/nagelfar.vim	Wed Nov 06 14:33:18 2013 +0100
@@ -0,0 +1,42 @@
+"============================================================================
+"File:        nagelfar.vim
+"Description: Syntax checking plugin for syntastic.vim
+"Maintainer:  James Pickard <james.pickard at gmail dot com>
+"License:     This program is free software. It comes without any warranty,
+"             to the extent permitted by applicable law. You can redistribute
+"             it and/or modify it under the terms of the Do What The Fuck You
+"             Want To Public License, Version 2, as published by Sam Hocevar.
+"             See http://sam.zoy.org/wtfpl/COPYING for more details.
+"Notes:       Requires nagelfar v1.1.12 or later with support for -H option.
+"             See nagelfar homepage http://nagelfar.berlios.de/.
+"
+"============================================================================
+if exists("g:loaded_syntastic_tcl_nagelfar_checker")
+    finish
+endif
+let g:loaded_syntastic_tcl_nagelfar_checker=1
+
+function! SyntaxCheckers_tcl_nagelfar_IsAvailable()
+    return executable('nagelfar')
+endfunction
+
+function! SyntaxCheckers_tcl_nagelfar_GetLocList()
+    let makeprg = syntastic#makeprg#build({
+        \ 'exe': 'nagelfar',
+        \ 'args': '-H ' . g:syntastic_tcl_nagelfar_conf,
+        \ 'filetype': 'tcl',
+        \ 'subchecker': 'nagelfar' })
+
+    let errorformat =
+        \ '%I%f: %l: N %m,'.
+        \ '%f: %l: %t %m,'.
+        \ '%-GChecking file %f'
+
+    return SyntasticMake({
+        \ 'makeprg': makeprg,
+        \ 'errorformat': errorformat })
+endfunction
+
+call g:SyntasticRegistry.CreateAndRegisterChecker({
+    \ 'filetype': 'tcl',
+    \ 'name': 'nagelfar'})
--- a/config/.vim/syntax_checkers/tex.vim	Thu Sep 05 16:23:33 2013 +0200
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,26 +0,0 @@
-"============================================================================
-"File:        tex.vim
-"Description: Syntax checking plugin for syntastic.vim
-"Maintainer:  Martin Grenfell <martin.grenfell at gmail dot com>
-"License:     This program is free software. It comes without any warranty,
-"             to the extent permitted by applicable law. You can redistribute
-"             it and/or modify it under the terms of the Do What The Fuck You
-"             Want To Public License, Version 2, as published by Sam Hocevar.
-"             See http://sam.zoy.org/wtfpl/COPYING for more details.
-"
-"============================================================================
-if exists("loaded_tex_syntax_checker")
-    finish
-endif
-let loaded_tex_syntax_checker = 1
-
-"bail if the user doesnt have lacheck installed
-if !executable("lacheck")
-    finish
-endif
-
-function! SyntaxCheckers_tex_GetLocList()
-    let makeprg = 'lacheck '.shellescape(expand('%'))
-    let errorformat =  '%-G** %f:,%E"%f"\, line %l: %m'
-    return SyntasticMake({ 'makeprg': makeprg, 'errorformat': errorformat })
-endfunction
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/config/.vim/syntax_checkers/tex/chktex.vim	Wed Nov 06 14:33:18 2013 +0100
@@ -0,0 +1,62 @@
+"============================================================================
+"File:        chktex.vim
+"Description: Syntax checking plugin for syntastic.vim
+"Maintainer:  LCD 47 <lcd047 at gmail dot com>
+"License:     This program is free software. It comes without any warranty,
+"             to the extent permitted by applicable law. You can redistribute
+"             it and/or modify it under the terms of the Do What The Fuck You
+"             Want To Public License, Version 2, as published by Sam Hocevar.
+"             See http://sam.zoy.org/wtfpl/COPYING for more details.
+"
+"============================================================================
+"
+" For details about ChkTeX see:
+"
+" http://baruch.ev-en.org/proj/chktex/
+"
+" Checker options:
+"
+" - g:syntastic_tex_chktex_showmsgs (boolean; default: 1)
+"   whether to show informational messages (chktex option "-m");
+"   by default informational messages are shown as warnings
+"
+" - g:syntastic_tex_chktex_args (string; default: empty)
+"   command line options to pass to chktex
+
+if exists('g:loaded_syntastic_tex_chktex_checker')
+    finish
+endif
+let g:loaded_syntastic_tex_chktex_checker = 1
+
+if !exists('g:syntastic_tex_chktex_showmsgs')
+    let g:syntastic_tex_chktex_showmsgs = 1
+endif
+
+function! SyntaxCheckers_tex_chktex_IsAvailable()
+    return executable('chktex')
+endfunction
+
+function! SyntaxCheckers_tex_chktex_GetLocList()
+    let makeprg = syntastic#makeprg#build({
+        \ 'exe': 'chktex',
+        \ 'post_args': '-q -v1',
+        \ 'filetype': 'tex',
+        \ 'subchecker': 'chktex' })
+
+    let errorformat =
+        \ '%EError %n in %f line %l: %m,' .
+        \ '%WWarning %n in %f line %l: %m,' .
+        \ (g:syntastic_tex_chktex_showmsgs ? '%WMessage %n in %f line %l: %m,' : '') .
+        \ '%Z%p^,' .
+        \ '%-G%.%#'
+
+    return SyntasticMake({
+        \ 'makeprg': makeprg,
+        \ 'errorformat': errorformat,
+        \ 'subtype': 'Style',
+        \ 'postprocess': ['sort'] })
+endfunction
+
+call g:SyntasticRegistry.CreateAndRegisterChecker({
+    \ 'filetype': 'tex',
+    \ 'name': 'chktex'})
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/config/.vim/syntax_checkers/tex/lacheck.vim	Wed Nov 06 14:33:18 2013 +0100
@@ -0,0 +1,39 @@
+"============================================================================
+"File:        tex.vim
+"Description: Syntax checking plugin for syntastic.vim
+"Maintainer:  Martin Grenfell <martin.grenfell at gmail dot com>
+"License:     This program is free software. It comes without any warranty,
+"             to the extent permitted by applicable law. You can redistribute
+"             it and/or modify it under the terms of the Do What The Fuck You
+"             Want To Public License, Version 2, as published by Sam Hocevar.
+"             See http://sam.zoy.org/wtfpl/COPYING for more details.
+"
+"============================================================================
+
+if exists('g:loaded_syntastic_tex_lacheck_checker')
+    finish
+endif
+let g:loaded_syntastic_tex_lacheck_checker=1
+
+function! SyntaxCheckers_tex_lacheck_IsAvailable()
+    return executable('lacheck')
+endfunction
+
+function! SyntaxCheckers_tex_lacheck_GetLocList()
+    let makeprg = syntastic#makeprg#build({
+        \ 'exe': 'lacheck',
+        \ 'filetype': 'tex',
+        \ 'subchecker': 'lacheck' })
+
+    let errorformat =
+        \ '%-G** %f:,' .
+        \ '%E"%f"\, line %l: %m'
+
+    return SyntasticMake({
+        \ 'makeprg': makeprg,
+        \ 'errorformat': errorformat })
+endfunction
+
+call g:SyntasticRegistry.CreateAndRegisterChecker({
+    \ 'filetype': 'tex',
+    \ 'name': 'lacheck'})
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/config/.vim/syntax_checkers/text/atdtool.vim	Wed Nov 06 14:33:18 2013 +0100
@@ -0,0 +1,57 @@
+"============================================================================
+"File:        atdtool.vim
+"Description: Syntax checking plugin for syntastic.vim
+"Maintainer:  LCD 47 <lcd047 at gmail dot com>
+"License:     This program is free software. It comes without any warranty,
+"             to the extent permitted by applicable law. You can redistribute
+"             it and/or modify it under the terms of the Do What The Fuck You
+"             Want To Public License, Version 2, as published by Sam Hocevar.
+"             See http://sam.zoy.org/wtfpl/COPYING for more details.
+"
+"============================================================================
+
+if exists("g:loaded_syntastic_text_atdtool_checker")
+    finish
+endif
+let g:loaded_syntastic_text_atdtool_checker = 1
+
+function! SyntaxCheckers_text_atdtool_IsAvailable()
+    return executable('atdtool')
+endfunction
+
+function! SyntaxCheckers_text_atdtool_GetHighlightRegex(item)
+    let term = matchstr(a:item['text'], '\m "\zs[^"]\+\ze"\($\| | suggestions:\)')
+    if term != ''
+        let col = get(a:item, 'col', 0)
+        let term = (col != 0 ? '\%' . col . 'c' : '') . '\V' . term
+    endif
+    return term
+endfunction
+
+function! SyntaxCheckers_text_atdtool_GetLocList()
+    let makeprg = syntastic#makeprg#build({
+        \ 'exe': 'atdtool',
+        \ 'tail': '2>' . syntastic#util#DevNull(),
+        \ 'filetype': 'text',
+        \ 'subchecker': 'atdtool' })
+
+    let errorformat =
+        \ '%W%f:%l:%c: %m,'.
+        \ '%+C  suggestions:%.%#'
+
+    let loclist = SyntasticMake({
+        \ 'makeprg': makeprg,
+        \ 'errorformat': errorformat,
+        \ 'returns': [0],
+        \ 'subtype': 'Style' })
+
+    for n in range(len(loclist))
+        let loclist[n]['text'] = substitute(loclist[n]['text'], '\n\s\+', ' | ', 'g')
+    endfor
+
+    return loclist
+endfunction
+
+call g:SyntasticRegistry.CreateAndRegisterChecker({
+    \ 'filetype': 'text',
+    \ 'name': 'atdtool'})
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/config/.vim/syntax_checkers/twig/twiglint.vim	Wed Nov 06 14:33:18 2013 +0100
@@ -0,0 +1,43 @@
+"============================================================================
+"File:        twig.vim
+"Description: Syntax checking plugin for syntastic.vim
+"Maintainer:  Alexander <iam.asm89 at gmail dot com>
+"License:     This program is free software. It comes without any warranty,
+"             to the extent permitted by applicable law. You can redistribute
+"             it and/or modify it under the terms of the Do What The Fuck You
+"             Want To Public License, Version 2, as published by Sam Hocevar.
+"             See http://sam.zoy.org/wtfpl/COPYING for more details.
+"
+"============================================================================
+
+if exists("g:loaded_syntastic_twig_twiglint_checker")
+    finish
+endif
+let g:loaded_syntastic_twig_twiglint_checker=1
+
+function! SyntaxCheckers_twig_twiglint_GetHighlightRegex(item)
+    " Let's match the full line for now
+    return '\V'
+endfunction
+
+function! SyntaxCheckers_twig_twiglint_IsAvailable()
+    return executable('twig-lint')
+endfunction
+
+function! SyntaxCheckers_twig_twiglint_GetLocList()
+    let makeprg = syntastic#makeprg#build({
+        \ 'exe': 'twig-lint',
+        \ 'args': 'lint --format=csv',
+        \ 'filetype': 'twig',
+        \ 'subchecker': 'twiglint' })
+
+    let errorformat = '"%f"\,%l\,%m'
+
+    return SyntasticMake({
+        \ 'makeprg': makeprg,
+        \ 'errorformat': errorformat})
+endfunction
+
+call g:SyntasticRegistry.CreateAndRegisterChecker({
+    \ 'filetype': 'twig',
+    \ 'name': 'twiglint'})
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/config/.vim/syntax_checkers/typescript/tsc.vim	Wed Nov 06 14:33:18 2013 +0100
@@ -0,0 +1,40 @@
+"============================================================================
+"File:        typescript.vim
+"Description: TypeScript syntax checker
+"Maintainer:  Bill Casarin <bill@casarin.ca>
+"============================================================================
+
+if exists("g:loaded_syntastic_typescript_tsc_checker")
+    finish
+endif
+let g:loaded_syntastic_typescript_tsc_checker=1
+
+function! SyntaxCheckers_typescript_tsc_IsAvailable()
+    return executable("tsc")
+endfunction
+
+
+function! SyntaxCheckers_typescript_tsc_GetLocList()
+    let makeprg = syntastic#makeprg#build({
+        \ 'exe': 'tsc',
+        \ 'args': '--module commonjs',
+        \ 'post_args': '--out ' . syntastic#util#DevNull(),
+        \ 'filetype': 'typescript',
+        \ 'subchecker': 'tsc' })
+
+    let errorformat =
+        \ '%E%f %#(%l\,%c): error %m,' .
+        \ '%E%f %#(%l\,%c): %m,' .
+        \ '%Eerror %m,' .
+        \ '%C%\s%\+%m'
+
+    return SyntasticMake({
+        \ 'makeprg': makeprg,
+        \ 'errorformat': errorformat,
+        \ 'defaults': {'bufnr': bufnr("")},
+        \ 'postprocess': ['sort'] })
+endfunction
+
+call g:SyntasticRegistry.CreateAndRegisterChecker({
+    \ 'filetype': 'typescript',
+    \ 'name': 'tsc'})
--- a/config/.vim/syntax_checkers/vala.vim	Thu Sep 05 16:23:33 2013 +0200
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,56 +0,0 @@
-"============================================================================
-"File:        vala.vim
-"Description: Syntax checking plugin for syntastic.vim
-"Maintainer:  Konstantin Stepanov (me@kstep.me)
-"Notes:       Add special comment line into your vala file starting with
-"             "// modules: " and containing space delimited list of vala
-"             modules, used by the file, so this script can build correct
-"             --pkg arguments.
-"             Valac compiler is not the fastest thing in the world, so you
-"             may want to disable this plugin with
-"             let g:syntastic_vala_check_disabled = 1 command in your .vimrc or
-"             command line. Unlet this variable to set it to 0 to reenable
-"             this checker.
-"License:     This program is free software. It comes without any warranty,
-"             to the extent permitted by applicable law. You can redistribute
-"             it and/or modify it under the terms of the Do What The Fuck You
-"             Want To Public License, Version 2, as published by Sam Hocevar.
-"             See http://sam.zoy.org/wtfpl/COPYING for more details.
-"
-"============================================================================
-
-if exists('loaded_vala_syntax_checker')
-    finish
-endif
-let loaded_vala_syntax_checker = 1
-
-if !executable('valac')
-    finish
-endif
-
-if exists('g:syntastic_vala_check_disabled') && g:syntastic_vala_check_disabled
-    finish
-endif
-
-function! SyntaxCheckers_vala_Term(pos)
-    let strlength = strlen(matchstr(a:pos['text'], '\^\+$'))
-    return '\%>'.(a:pos.col-1).'c.*\%<'.(a:pos.col+strlength+1).'c'
-endfunction
-
-function! s:GetValaModules()
-    let modules_line = search('^// modules: ', 'n')
-    let modules_str = getline(modules_line)
-    let modules = split(strpart(modules_str, 12), '\s\+')
-    return modules
-endfunction
-
-function! SyntaxCheckers_vala_GetLocList()
-    let vala_pkg_args = join(map(s:GetValaModules(), '"--pkg ".v:val'), ' ')
-    let makeprg = 'valac -C ' . vala_pkg_args . ' ' .shellescape(expand('%'))
-    let errorformat = '%A%f:%l.%c-%\d%\+.%\d%\+: %t%[a-z]%\+: %m,%C%m,%Z%m'
-
-    let loclist = SyntasticMake({ 'makeprg': makeprg, 'errorformat': errorformat })
-    call SyntasticHighlightErrors(loclist, function("SyntaxCheckers_vala_Term"), 1)
-    return loclist
-endfunction
-
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/config/.vim/syntax_checkers/vala/valac.vim	Wed Nov 06 14:33:18 2013 +0100
@@ -0,0 +1,74 @@
+"============================================================================
+"File:        vala.vim
+"Description: Syntax checking plugin for syntastic.vim
+"Maintainer:  Konstantin Stepanov (me@kstep.me)
+"Notes:       Add special comment line into your vala file starting with
+"             "// modules: " and containing space delimited list of vala
+"             modules, used by the file, so this script can build correct
+"             --pkg arguments.
+"             Alternatively you can set g:syntastic_vala_modules array
+"             in your .vimrc or .lvimrc with localvimrc plugin
+"             (http://www.vim.org/scripts/script.php?script_id=441).
+"             Valac compiler is not the fastest thing in the world, so you
+"             may want to disable this plugin with
+"             let g:syntastic_vala_check_disabled = 1 command in your .vimrc or
+"             command line. Unlet this variable to set it to 0 to reenable
+"             this checker.
+"License:     This program is free software. It comes without any warranty,
+"             to the extent permitted by applicable law. You can redistribute
+"             it and/or modify it under the terms of the Do What The Fuck You
+"             Want To Public License, Version 2, as published by Sam Hocevar.
+"             See http://sam.zoy.org/wtfpl/COPYING for more details.
+"
+"============================================================================
+
+if exists("g:loaded_syntastic_vala_valac_checker")
+    finish
+endif
+let g:loaded_syntastic_vala_valac_checker = 1
+
+function! SyntaxCheckers_vala_valac_IsAvailable()
+    return executable('valac')
+endfunction
+
+function! SyntaxCheckers_vala_valac_GetHighlightRegex(pos)
+    let strlength = strlen(matchstr(a:pos['text'], '\^\+$'))
+    return '\%>'.(a:pos.col-1).'c.*\%<'.(a:pos.col+strlength+1).'c'
+endfunction
+
+function! s:GetValaModules()
+    if exists('g:syntastic_vala_modules')
+        if type(g:syntastic_vala_modules) == type('')
+            return split(g:syntastic_vala_modules, '\s\+')
+        elseif type(g:syntastic_vala_modules) == type([])
+            return copy(g:syntastic_vala_modules)
+        else
+            echoerr 'g:syntastic_vala_modules must be either list or string: fallback to in file modules string'
+        endif
+    endif
+
+    let modules_line = search('^// modules: ', 'n')
+    let modules_str = getline(modules_line)
+    return split(strpart(modules_str, 12), '\s\+')
+endfunction
+
+function! SyntaxCheckers_vala_valac_GetLocList()
+    let vala_pkg_args = join(map(s:GetValaModules(), '"--pkg ".v:val'), ' ')
+    let makeprg = syntastic#makeprg#build({
+        \ 'exe': 'valac',
+        \ 'args': '-C ' . vala_pkg_args,
+        \ 'filetype': 'vala',
+        \ 'subchecker': 'valac' })
+    let errorformat =
+        \ '%A%f:%l.%c-%\d%\+.%\d%\+: %t%[a-z]%\+: %m,'.
+        \ '%C%m,'.
+        \ '%Z%m'
+
+    return SyntasticMake({
+        \ 'makeprg': makeprg,
+        \ 'errorformat': errorformat })
+endfunction
+
+call g:SyntasticRegistry.CreateAndRegisterChecker({
+    \ 'filetype': 'vala',
+    \ 'name': 'valac'})
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/config/.vim/syntax_checkers/vhdl/ghdl.vim	Wed Nov 06 14:33:18 2013 +0100
@@ -0,0 +1,37 @@
+"============================================================================
+"File:        ghdl.vim
+"Description: Syntax checking plugin for syntastic.vim
+"Maintainer:  Jan Wagner <jaydyou at janidom dot de>
+"License:     This program is free software. It comes without any warranty,
+"             to the extent permitted by applicable law. You can redistribute
+"             it and/or modify it under the terms of the Do What The Fuck You
+"             Want To Public License, Version 2, as published by Sam Hocevar.
+"             See http://sam.zoy.org/wtfpl/COPYING for more details.
+"
+"============================================================================
+if exists("g:loaded_syntastic_vhdl_ghdl_checker")
+    finish
+endif
+let g:loaded_syntastic_vhdl_ghdl_checker = 1
+
+function! SyntaxCheckers_vhdl_ghdl_IsAvailable()
+    return executable("ghdl")
+endfunction
+
+function! SyntaxCheckers_vhdl_ghdl_GetLocList()
+    let makeprg = syntastic#makeprg#build({
+        \ 'exe': 'ghdl',
+        \ 'args': '-s',
+        \ 'filetype': 'vhdl',
+        \ 'subchecker': 'ghdl' })
+
+    let errorformat =  '%f:%l:%c: %m'
+
+    return SyntasticMake({
+        \ 'makeprg': makeprg,
+        \ 'errorformat': errorformat })
+endfunction
+
+call g:SyntasticRegistry.CreateAndRegisterChecker({
+    \ 'filetype': 'vhdl',
+    \ 'name': 'ghdl'})
--- a/config/.vim/syntax_checkers/xhtml.vim	Thu Sep 05 16:23:33 2013 +0200
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,46 +0,0 @@
-"============================================================================
-"File:        xhtml.vim
-"Description: Syntax checking plugin for syntastic.vim
-"Maintainer:  Martin Grenfell <martin.grenfell at gmail dot com>
-"License:     This program is free software. It comes without any warranty,
-"             to the extent permitted by applicable law. You can redistribute
-"             it and/or modify it under the terms of the Do What The Fuck You
-"             Want To Public License, Version 2, as published by Sam Hocevar.
-"             See http://sam.zoy.org/wtfpl/COPYING for more details.
-"
-"============================================================================
-if exists("loaded_xhtml_syntax_checker")
-    finish
-endif
-let loaded_xhtml_syntax_checker = 1
-
-"bail if the user doesnt have tidy or grep installed
-if !executable("tidy")
-    finish
-endif
-
-" TODO: join this with html.vim DRY's sake?
-function! s:TidyEncOptByFenc()
-    let tidy_opts = {
-                \'utf-8'       : '-utf8',
-                \'ascii'       : '-ascii',
-                \'latin1'      : '-latin1',
-                \'iso-2022-jp' : '-iso-2022',
-                \'cp1252'      : '-win1252',
-                \'macroman'    : '-mac',
-                \'utf-16le'    : '-utf16le',
-                \'utf-16'      : '-utf16',
-                \'big5'        : '-big5',
-                \'sjis'        : '-shiftjis',
-                \'cp850'       : '-ibm858',
-                \}
-    return get(tidy_opts, &fileencoding, '-utf8')
-endfunction
-
-function! SyntaxCheckers_xhtml_GetLocList()
-
-    let encopt = s:TidyEncOptByFenc()
-    let makeprg="tidy ".encopt." -xml -e ".shellescape(expand('%'))
-    let errorformat='%Wline %l column %c - Warning: %m,%Eline %l column %c - Error: %m,%-G%.%#,%-G%.%#'
-    return SyntasticMake({ 'makeprg': makeprg, 'errorformat': errorformat, 'defaults': {'bufnr': bufnr("")} })
-endfunction
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/config/.vim/syntax_checkers/xhtml/tidy.vim	Wed Nov 06 14:33:18 2013 +0100
@@ -0,0 +1,89 @@
+"============================================================================
+"File:        xhtml.vim
+"Description: Syntax checking plugin for syntastic.vim
+"Maintainer:  Martin Grenfell <martin.grenfell at gmail dot com>
+"License:     This program is free software. It comes without any warranty,
+"             to the extent permitted by applicable law. You can redistribute
+"             it and/or modify it under the terms of the Do What The Fuck You
+"             Want To Public License, Version 2, as published by Sam Hocevar.
+"             See http://sam.zoy.org/wtfpl/COPYING for more details.
+"
+"============================================================================
+"
+" Checker option:
+"
+" - g:syntastic_xhtml_tidy_ignore_errors (list; default: [])
+"   list of errors to ignore
+
+if exists("g:loaded_syntastic_xhtml_tidy_checker")
+    finish
+endif
+let g:loaded_syntastic_xhtml_tidy_checker=1
+
+if !exists('g:syntastic_xhtml_tidy_ignore_errors')
+    let g:syntastic_xhtml_tidy_ignore_errors = []
+endif
+
+function! SyntaxCheckers_xhtml_tidy_IsAvailable()
+    return executable("tidy")
+endfunction
+
+" TODO: join this with html.vim DRY's sake?
+function! s:TidyEncOptByFenc()
+    let tidy_opts = {
+                \'utf-8'       : '-utf8',
+                \'ascii'       : '-ascii',
+                \'latin1'      : '-latin1',
+                \'iso-2022-jp' : '-iso-2022',
+                \'cp1252'      : '-win1252',
+                \'macroman'    : '-mac',
+                \'utf-16le'    : '-utf16le',
+                \'utf-16'      : '-utf16',
+                \'big5'        : '-big5',
+                \'cp932'       : '-shiftjis',
+                \'sjis'        : '-shiftjis',
+                \'cp850'       : '-ibm858',
+                \}
+    return get(tidy_opts, &fileencoding, '-utf8')
+endfunction
+
+function! s:IgnoreError(text)
+    for i in g:syntastic_xhtml_tidy_ignore_errors
+        if stridx(a:text, i) != -1
+            return 1
+        endif
+    endfor
+    return 0
+endfunction
+
+function! SyntaxCheckers_xhtml_tidy_GetLocList()
+    let encopt = s:TidyEncOptByFenc()
+    let makeprg = syntastic#makeprg#build({
+        \ 'exe': 'tidy',
+        \ 'args': encopt . ' -xml -e',
+        \ 'filetype': 'xhtml',
+        \ 'subchecker': 'tidy' })
+
+    let errorformat=
+        \ '%Wline %l column %v - Warning: %m,' .
+        \ '%Eline %l column %v - Error: %m,' .
+        \ '%-G%.%#'
+
+    let loclist = SyntasticMake({
+        \ 'makeprg': makeprg,
+        \ 'errorformat': errorformat,
+        \ 'defaults': {'bufnr': bufnr("")},
+        \ 'returns': [0, 1, 2] })
+
+    for n in range(len(loclist))
+        if loclist[n]['valid'] && s:IgnoreError(loclist[n]['text']) == 1
+            let loclist[n]['valid'] = 0
+        endif
+    endfor
+
+    return loclist
+endfunction
+
+call g:SyntasticRegistry.CreateAndRegisterChecker({
+    \ 'filetype': 'xhtml',
+    \ 'name': 'tidy'})
--- a/config/.vim/syntax_checkers/xml.vim	Thu Sep 05 16:23:33 2013 +0200
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,42 +0,0 @@
-"============================================================================
-"File:        xml.vim
-"Description: Syntax checking plugin for syntastic.vim
-"Maintainer:  Sebastian Kusnier <sebastian at kusnier dot net>
-"License:     This program is free software. It comes without any warranty,
-"             to the extent permitted by applicable law. You can redistribute
-"             it and/or modify it under the terms of the Do What The Fuck You
-"             Want To Public License, Version 2, as published by Sam Hocevar.
-"             See http://sam.zoy.org/wtfpl/COPYING for more details.
-"
-"============================================================================
-
-" You can use a local installation of DTDs to significantly speed up validation
-" and allow you to validate XML data without network access, see xmlcatalog(1)
-" and http://www.xmlsoft.org/catalog.html for more information.
-
-if exists("loaded_xml_syntax_checker")
-    finish
-endif
-let loaded_xml_syntax_checker = 1
-
-"bail if the user doesnt have tidy or grep installed
-if !executable("xmllint")
-    finish
-endif
-
-function! SyntaxCheckers_xml_GetLocList()
-
-    let makeprg="xmllint --xinclude --noout --postvalid " . shellescape(expand("%:p"))
-    let errorformat='%E%f:%l:\ error\ :\ %m,
-        \%-G%f:%l:\ validity\ error\ :\ Validation\ failed:\ no\ DTD\ found\ %m,
-        \%W%f:%l:\ warning\ :\ %m,
-        \%W%f:%l:\ validity\ warning\ :\ %m,
-        \%E%f:%l:\ validity\ error\ :\ %m,
-        \%E%f:%l:\ parser\ error\ :\ %m,
-        \%E%f:%l:\ %m,
-        \%-Z%p^,
-        \%-G%.%#'
-    let loclist = SyntasticMake({ 'makeprg': makeprg, 'errorformat': errorformat })
-
-    return loclist
-endfunction
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/config/.vim/syntax_checkers/xml/xmllint.vim	Wed Nov 06 14:33:18 2013 +0100
@@ -0,0 +1,52 @@
+"============================================================================
+"File:        xml.vim
+"Description: Syntax checking plugin for syntastic.vim
+"Maintainer:  Sebastian Kusnier <sebastian at kusnier dot net>
+"License:     This program is free software. It comes without any warranty,
+"             to the extent permitted by applicable law. You can redistribute
+"             it and/or modify it under the terms of the Do What The Fuck You
+"             Want To Public License, Version 2, as published by Sam Hocevar.
+"             See http://sam.zoy.org/wtfpl/COPYING for more details.
+"
+"============================================================================
+
+if exists("g:loaded_syntastic_xml_xmllint_checker")
+    finish
+endif
+let g:loaded_syntastic_xml_xmllint_checker=1
+
+" You can use a local installation of DTDs to significantly speed up validation
+" and allow you to validate XML data without network access, see xmlcatalog(1)
+" and http://www.xmlsoft.org/catalog.html for more information.
+
+function! SyntaxCheckers_xml_xmllint_IsAvailable()
+    return executable('xmllint')
+endfunction
+
+function! SyntaxCheckers_xml_xmllint_GetLocList()
+    let makeprg = syntastic#makeprg#build({
+        \ 'exe': 'xmllint',
+        \ 'args': '--xinclude --noout --postvalid',
+        \ 'filetype': 'xml',
+        \ 'subchecker': 'xmllint' })
+
+    let errorformat=
+        \ '%E%f:%l: error : %m,' .
+        \ '%-G%f:%l: validity error : Validation failed: no DTD found %m,' .
+        \ '%W%f:%l: warning : %m,' .
+        \ '%W%f:%l: validity warning : %m,' .
+        \ '%E%f:%l: validity error : %m,' .
+        \ '%E%f:%l: parser error : %m,' .
+        \ '%E%f:%l: %m,' .
+        \ '%-Z%p^,' .
+        \ '%-G%.%#'
+
+    return SyntasticMake({
+        \ 'makeprg': makeprg,
+        \ 'errorformat': errorformat,
+        \ 'returns': [0, 1, 2, 3, 4, 5] })
+endfunction
+
+call g:SyntasticRegistry.CreateAndRegisterChecker({
+    \ 'filetype': 'xml',
+    \ 'name': 'xmllint'})
--- a/config/.vim/syntax_checkers/xslt.vim	Thu Sep 05 16:23:33 2013 +0200
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,38 +0,0 @@
-"============================================================================
-"File:        xslt.vim
-"Description: Syntax checking plugin for syntastic.vim
-"Maintainer:  Sebastian Kusnier <sebastian at kusnier dot net>
-"License:     This program is free software. It comes without any warranty,
-"             to the extent permitted by applicable law. You can redistribute
-"             it and/or modify it under the terms of the Do What The Fuck You
-"             Want To Public License, Version 2, as published by Sam Hocevar.
-"             See http://sam.zoy.org/wtfpl/COPYING for more details.
-"
-"============================================================================
-if exists("loaded_xslt_syntax_checker")
-    finish
-endif
-let loaded_xslt_syntax_checker = 1
-
-"bail if the user doesnt have tidy or grep installed
-if !executable("xmllint")
-    finish
-endif
-
-function! SyntaxCheckers_xslt_GetLocList()
-
-    let makeprg="xmllint --xinclude --noout --postvalid " . shellescape(expand("%:p"))
-    let errorformat='%E%f:%l:\ error\ :\ %m,
-        \%-G%f:%l:\ validity\ error\ :\ Validation\ failed:\ no\ DTD\ found\ %m,
-        \%W%f:%l:\ warning\ :\ %m,
-        \%W%f:%l:\ validity\ warning\ :\ %m,
-        \%E%f:%l:\ validity\ error\ :\ %m,
-        \%E%f:%l:\ parser\ error\ :\ %m,
-        \%E%f:%l:\ namespace\ error\ :\ %m,
-        \%E%f:%l:\ %m,
-        \%-Z%p^,
-        \%-G%.%#'
-    let loclist = SyntasticMake({ 'makeprg': makeprg, 'errorformat': errorformat })
-
-    return loclist
-endfunction
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/config/.vim/syntax_checkers/xslt/xmllint.vim	Wed Nov 06 14:33:18 2013 +0100
@@ -0,0 +1,30 @@
+"============================================================================
+"File:        xslt.vim
+"Description: Syntax checking plugin for syntastic.vim
+"Maintainer:  Sebastian Kusnier <sebastian at kusnier dot net>
+"License:     This program is free software. It comes without any warranty,
+"             to the extent permitted by applicable law. You can redistribute
+"             it and/or modify it under the terms of the Do What The Fuck You
+"             Want To Public License, Version 2, as published by Sam Hocevar.
+"             See http://sam.zoy.org/wtfpl/COPYING for more details.
+"
+"============================================================================
+
+if exists("g:loaded_syntastic_xslt_xmllint_checker")
+    finish
+endif
+let g:loaded_syntastic_xslt_xmllint_checker=1
+
+function! SyntaxCheckers_xslt_xmllint_IsAvailable()
+    return SyntaxCheckers_xml_xmllint_IsAvailable()
+endfunction
+
+function! SyntaxCheckers_xslt_xmllint_GetLocList()
+    return SyntaxCheckers_xml_xmllint_GetLocList()
+endfunction
+
+call g:SyntasticRegistry.CreateAndRegisterChecker({
+    \ 'filetype': 'xslt',
+    \ 'name': 'xmllint'})
+
+runtime! syntax_checkers/xml/*.vim
--- a/config/.vim/syntax_checkers/yaml.vim	Thu Sep 05 16:23:33 2013 +0200
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,30 +0,0 @@
-"============================================================================
-"File:        yaml.vim
-"Description: Syntax checking plugin for syntastic.vim
-"Maintainer:  Martin Grenfell <martin.grenfell at gmail dot com>
-"License:     This program is free software. It comes without any warranty,
-"             to the extent permitted by applicable law. You can redistribute
-"             it and/or modify it under the terms of the Do What The Fuck You
-"             Want To Public License, Version 2, as published by Sam Hocevar.
-"             See http://sam.zoy.org/wtfpl/COPYING for more details.
-"
-"
-"Installation: $ npm install -g js-yaml.bin
-"
-"============================================================================
-if exists("loaded_yaml_syntax_checker")
-    finish
-endif
-let loaded_yaml_syntax_checker = 1
-
-if !executable("js-yaml")
-    finish
-endif
-
-function! SyntaxCheckers_yaml_GetLocList()
-    let makeprg='js-yaml --compact ' . shellescape(expand('%'))
-    let errorformat='Error on line %l\, col %c:%m,%-G%.%#'
-    return SyntasticMake({ 'makeprg': makeprg,
-                         \ 'errorformat': errorformat,
-                         \ 'defaults': {'bufnr': bufnr("")} })
-endfunction
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/config/.vim/syntax_checkers/yaml/jsyaml.vim	Wed Nov 06 14:33:18 2013 +0100
@@ -0,0 +1,42 @@
+"============================================================================
+"File:        yaml.vim
+"Description: Syntax checking plugin for syntastic.vim
+"Maintainer:  Martin Grenfell <martin.grenfell at gmail dot com>
+"License:     This program is free software. It comes without any warranty,
+"             to the extent permitted by applicable law. You can redistribute
+"             it and/or modify it under the terms of the Do What The Fuck You
+"             Want To Public License, Version 2, as published by Sam Hocevar.
+"             See http://sam.zoy.org/wtfpl/COPYING for more details.
+"
+"
+"Installation: $ npm install -g js-yaml
+"
+"============================================================================
+
+if exists("g:loaded_syntastic_yaml_jsyaml_checker")
+    finish
+endif
+let g:loaded_syntastic_yaml_jsyaml_checker=1
+
+function! SyntaxCheckers_yaml_jsyaml_IsAvailable()
+    return executable("js-yaml")
+endfunction
+
+function! SyntaxCheckers_yaml_jsyaml_GetLocList()
+    let makeprg = syntastic#makeprg#build({
+        \ 'exe': 'js-yaml',
+        \ 'args': '--compact',
+        \ 'filetype': 'yaml',
+        \ 'subchecker': 'jsyaml' })
+
+    let errorformat='Error on line %l\, col %c:%m,%-G%.%#'
+
+    return SyntasticMake({
+        \ 'makeprg': makeprg,
+        \ 'errorformat': errorformat,
+        \ 'defaults': {'bufnr': bufnr("")} })
+endfunction
+
+call g:SyntasticRegistry.CreateAndRegisterChecker({
+    \ 'filetype': 'yaml',
+    \ 'name': 'jsyaml'})
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/config/.vim/syntax_checkers/z80/z80syntaxchecker.vim	Wed Nov 06 14:33:18 2013 +0100
@@ -0,0 +1,41 @@
+"============================================================================
+"File:        z80.vim
+"Description: Syntax checking plugin for syntastic.vim
+"Maintainer:  Romain Giot <giot.romain at gmail dot com>
+"License:     This program is free software. It comes without any warranty,
+"             to the extent permitted by applicable law. You can redistribute
+"             it and/or modify it under the terms of the Do What The Fuck You
+"             Want To Public License, Version 2, as published by Sam Hocevar.
+"             See http://sam.zoy.org/wtfpl/COPYING for more details.
+"
+"============================================================================
+
+if exists("g:loaded_syntastic_z80_z80syntaxchecker_checker")
+    finish
+endif
+let g:loaded_syntastic_z80_z80syntaxchecker_checker=1
+
+"bail if the user doesnt have z80_syntax_checker.py installed
+"To obtain this application there are two solutions:
+" - Install this python package: https://github.com/rgiot/pycpcdemotools
+" - Copy/paste this script in your search path: https://raw.github.com/rgiot/pycpcdemotools/master/cpcdemotools/source_checker/z80_syntax_checker.py
+function! SyntaxCheckers_z80_z80syntaxchecker_IsAvailable()
+    return executable("z80_syntax_checker.py")
+endfunction
+
+function! SyntaxCheckers_z80_z80syntaxchecker_GetLocList()
+    let makeprg = syntastic#makeprg#build({
+        \ 'exe': 'z80_syntax_checker.py',
+        \ 'filetype': 'z80',
+        \ 'subchecker': 'z80syntaxchecker' })
+
+    let errorformat =  '%f:%l %m'
+
+    return SyntasticMake({
+        \ 'makeprg': makeprg,
+        \ 'errorformat': errorformat })
+endfunction
+
+call g:SyntasticRegistry.CreateAndRegisterChecker({
+    \ 'filetype': 'z80',
+    \ 'name': 'z80syntaxchecker'})
--- a/config/.vim/syntax_checkers/zpt.vim	Thu Sep 05 16:23:33 2013 +0200
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,36 +0,0 @@
-"============================================================================
-"File:        zpt.vim
-"Description: Syntax checking plugin for syntastic.vim
-"Maintainer:  claytron <robots at claytron dot com>
-"License:     This program is free software. It comes without any warranty,
-"             to the extent permitted by applicable law. You can redistribute
-"             it and/or modify it under the terms of the Do What The Fuck You
-"             Want To Public License, Version 2, as published by Sam Hocevar.
-"             See http://sam.zoy.org/wtfpl/COPYING for more details.
-"
-"============================================================================
-
-" In order for this plugin to be useful, you will need to set up the
-" zpt filetype in your vimrc
-"
-"    " set up zope page templates as the zpt filetype
-"    au BufNewFile,BufRead *.pt,*.cpt,*.zpt set filetype=zpt syntax=xml
-"
-" Then install the zptlint program, found on pypi:
-" http://pypi.python.org/pypi/zptlint
-
-if exists("loaded_zpt_syntax_checker")
-    finish
-endif
-let loaded_zpt_syntax_checker = 1
-
-" Bail if the user doesn't have zptlint installed
-if !executable("zptlint")
-    finish
-endif
-
-function! SyntaxCheckers_zpt_GetLocList()
-    let makeprg="zptlint ".shellescape(expand('%'))
-    let errorformat='%-P*** Error in: %f,%Z%*\s\, at line %l\, column %c,%E%*\s%m,%-Q'
-    return SyntasticMake({ 'makeprg': makeprg, 'errorformat': errorformat })
-endfunction
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/config/.vim/syntax_checkers/zpt/zptlint.vim	Wed Nov 06 14:33:18 2013 +0100
@@ -0,0 +1,50 @@
+"============================================================================
+"File:        zpt.vim
+"Description: Syntax checking plugin for syntastic.vim
+"Maintainer:  claytron <robots at claytron dot com>
+"License:     This program is free software. It comes without any warranty,
+"             to the extent permitted by applicable law. You can redistribute
+"             it and/or modify it under the terms of the Do What The Fuck You
+"             Want To Public License, Version 2, as published by Sam Hocevar.
+"             See http://sam.zoy.org/wtfpl/COPYING for more details.
+"
+"============================================================================
+
+if exists("g:loaded_syntastic_zpt_zptlint_checker")
+    finish
+endif
+let g:loaded_syntastic_zpt_zptlint_checker=1
+
+" In order for this plugin to be useful, you will need to set up the
+" zpt filetype in your vimrc
+"
+"    " set up zope page templates as the zpt filetype
+"    au BufNewFile,BufRead *.pt,*.cpt,*.zpt set filetype=zpt syntax=xml
+"
+" Then install the zptlint program, found on pypi:
+" http://pypi.python.org/pypi/zptlint
+
+function! SyntaxCheckers_zpt_zptlint_IsAvailable()
+    return executable("zptlint")
+endfunction
+
+function! SyntaxCheckers_zpt_zptlint_GetLocList()
+    let makeprg = syntastic#makeprg#build({
+        \ 'exe': 'zptlint',
+        \ 'filetype': 'zpt',
+        \ 'subchecker': 'zptlint' })
+
+    let errorformat=
+        \ '%-P*** Error in: %f,'.
+        \ '%Z%*\s\, at line %l\, column %c,'.
+        \ '%E%*\s%m,'.
+        \ '%-Q'
+
+    return SyntasticMake({
+        \ 'makeprg': makeprg,
+        \ 'errorformat': errorformat })
+endfunction
+
+call g:SyntasticRegistry.CreateAndRegisterChecker({
+    \ 'filetype': 'zpt',
+    \ 'name': 'zptlint'})
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/config/.vim/syntax_checkers/zsh/zsh.vim	Wed Nov 06 14:33:18 2013 +0100
@@ -0,0 +1,38 @@
+"============================================================================
+"File:        zsh.vim
+"Description: Syntax checking plugin for syntastic.vim
+"Maintainer:  Martin Grenfell <martin.grenfell at gmail dot com>
+"License:     This program is free software. It comes without any warranty,
+"             to the extent permitted by applicable law. You can redistribute
+"             it and/or modify it under the terms of the Do What The Fuck You
+"             Want To Public License, Version 2, as published by Sam Hocevar.
+"             See http://sam.zoy.org/wtfpl/COPYING for more details.
+"
+"============================================================================
+
+if exists("g:loaded_syntastic_zsh_zsh_checker")
+    finish
+endif
+let g:loaded_syntastic_zsh_zsh_checker=1
+
+function! SyntaxCheckers_zsh_zsh_IsAvailable()
+    return executable("zsh")
+endfunction
+
+function! SyntaxCheckers_zsh_zsh_GetLocList()
+    let makeprg = syntastic#makeprg#build({
+        \ 'exe': 'zsh',
+        \ 'args': '-n',
+        \ 'filetype': 'zsh',
+        \ 'subchecker': 'zsh' })
+
+    let errorformat = '%f:%l: %m'
+
+    return SyntasticMake({
+        \ 'makeprg': makeprg,
+        \ 'errorformat': errorformat})
+endfunction
+
+call g:SyntasticRegistry.CreateAndRegisterChecker({
+    \ 'filetype': 'zsh',
+    \ 'name': 'zsh'})