Merge 0eaf600eaf into 2a9908e4f0

.gitignore

@@ -3,5 +3,4 @@ sources_non_forked/ack.vim/.netrwhist
 temp_dirs/yankring_history_v2.txt
 sources_forked/yankring/doc/tags
 sources_non_forked/tlib/doc/tags
-my_configs.vim
 tags

my_configs.vim

@@ -0,0 +1,140 @@
+try
+    colorscheme zenburn
+catch
+endtry
+
+set t_Co=256
+" UltiSnips configuration
+function! g:UltiSnips_Complete()
+    call UltiSnips#ExpandSnippet()
+    if g:ulti_expand_res == 0
+        if pumvisible()
+            return "\<C-n>"
+        else
+            call UltiSnips#JumpForwards()
+            if g:ulti_jump_forwards_res == 0
+               return "\<TAB>"
+            endif
+        endif
+    endif
+    return ""
+endfunction
+
+au BufEnter * exec "inoremap <silent> " . g:UltiSnipsExpandTrigger . " <C-R>=g:UltiSnips_Complete()<cr>"
+let g:UltiSnipsJumpForwardTrigger="<tab>"
+let g:UltiSnipsListSnippets="<c-e>"
+" this mapping Enter key to <C-y> to chose the current highlight item
+" and close the selection list, same as other IDEs.
+" CONFLICT with some plugins like tpope/Endwise
+inoremap <expr> <CR> pumvisible() ? "\<C-y>" : "\<C-g>u\<CR>"
+
+" If you want :UltiSnipsEdit to split your window.
+let g:UltiSnipsEditSplit="vertical"
+" Trigger configuration. Do not use <tab> if you use
+" https://github.com/Valloric/YouCompleteMe.
+let g:UltiSnipsJumpForwardTrigger="<c-b>"
+let g:UltiSnipsJumpBackwardTrigger="<c-z>"
+
+" relative numbers and absolute numbers on current line
+set relativenumber
+set number
+
+" Highlight current line
+set cursorline
+
+
+" IndentGuides options
+let g:indent_guides_auto_colors = 0
+let g:indent_guides_enable_on_vim_startup = 1
+let g:indent_guides_exclude_filetypes = ['help', 'nerdtree']
+
+set ts=4 sw=4 et
+let g:indent_guides_start_level = 2
+let g:indent_guides_guide_size = 1
+
+autocmd VimEnter,Colorscheme * :hi IndentGuidesOdd  ctermbg=238
+autocmd VimEnter,Colorscheme * :hi IndentGuidesEven ctermbg=238
+
+
+" Syntastic configuration
+execute pathogen#infect()
+let g:syntastic_enable_signs=1
+" let g:syntastic_auto_jump=1
+let g:syntastic_stl_format = '[%E{Err: %fe #%e}%B{, }%W{Warn: %fw #%w}]'
+
+set statusline+=%#warningmsg#
+set statusline+=%{SyntasticStatuslineFlag()}
+set statusline+=%*
+let g:syntastic_check_on_open = 1
+let g:syntastic_aggregate_errors = 1
+let g:syntastic_python_checkers = ['flake8', 'frosted']
+let g:syntastic_javascript_checkers = ['jshint']
+
+" Ropevim configuration
+let g:ropevim_autoimport_modules = ["os", "shutil", 'django', 'rest_framework', 'moody365']
+
+" Mappings to access buffers (don't use "\p" because a
+" delay before pressing "p" would accidentally paste).
+" \g : go last-used
+nnoremap <Leader>/ :e#<CR>
+
+" No wordwrap
+set nowrap
+
+" NERDTree ignore *.pyc
+let NERDTreeIgnore = ['\.pyc$']
+
+" Enable TagBar
+nmap <F8> :TagbarToggle<CR>
+nmap <Leader>f :TagbarOpen fj<CR>
+
+
+"""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""
+" => Ag searching and cope displaying
+"    requires ag.vim - it's much better than vimgrep/grep
+"""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""
+let g:ackprg = 'ag --nogroup --nocolor --column'
+
+map <leader>cc :botright cope<cr>
+map <leader>co ggVGy:tabnew<cr>:set syntax=qf<cr>pgg
+map <leader>n :cn<cr>
+map <leader>p :cp<cr>
+
+
+" Pymode vim settings
+
+let g:pymode_trim_whitespaces = 0
+let g:pymode_run = 0
+let g:pymode_lint_checkers = ['mccabe']
+let g:pymode_rope_completion = 0
+let g:pymode_rope_complete_on_dot = 0
+let g:pymode_rope_autoimport_modules = ["os.*","traceback","django.*","lxml.etree","lxml.*", "rest_framework.*"]
+let g:pymode_rope_autoimport_import_after_complete = 1
+
+
+" Remove trailing space on save
+fun! <SID>StripTrailingWhitespaces()
+    let l = line(".")
+    let c = col(".")
+    %s/\s\+$//e
+    call cursor(l, c)
+endfun
+autocmd BufWritePre * :call <SID>StripTrailingWhitespaces()
+
+"Set tabs to spaces
+set tabstop=4
+set shiftwidth=4
+set expandtab
+
+"UltiSnipets in Tagbar
+let g:tagbar_type_snippets = {
+    \ 'ctagstype' : 'snippets',
+    \ 'kinds' : [
+        \ 's:snippets',
+    \ ]
+\ }
+
+" " Mark the max length line limit
+set textwidth=80
+set cc=80
+hi ColorColumn ctermbg=238

sources_non_forked/Minimap~

@@ -0,0 +1 @@
+Subproject commit eb257e53f9b99e38eba04040078079c63c708ada

sources_non_forked/Syntactic~

@@ -0,0 +1 @@
+Subproject commit 82bff20b0200c3ccb292a9261d565b5bbc609ac2

sources_non_forked/UltiSnips

@@ -0,0 +1 @@
+Subproject commit b6d545ecdfbfeb991d2555cb61df365e674ba8a9

sources_non_forked/YouCompleteMe

@@ -0,0 +1 @@
+Subproject commit f054fcfc0a270c4154a9ac5965126bead5c713b3

sources_non_forked/ag

@@ -0,0 +1 @@
+Subproject commit d3a00f8affb091e7a14eb34f1beb9db9bb57a4bf

sources_non_forked/delimitMate

@@ -0,0 +1 @@
+Subproject commit 38487bbec8ba50834e257940b357de03991fa8f9

sources_non_forked/html5.vim

@@ -0,0 +1 @@
+Subproject commit b1b184e0b395089b5fba122c73fd3f461dcdc08d

sources_non_forked/indent-lines~/after/plugin/indentLine.vim

@@ -0,0 +1,169 @@
+" Script Name: indentLine.vim
+" Version:     1.0.5
+" Last Change: April 1, 2013
+" Author:      Yggdroot <archofortune@gmail.com>
+"
+" Description: To show the indention levels with thin vertical lines
+
+"{{{1 global variables
+if !has("conceal") || exists("g:indentLine_loaded")
+    finish
+endif
+let g:indentLine_loaded = 1
+
+" | ¦ ┆ ┊ │
+if !exists("g:indentLine_char")
+    if &encoding ==? "utf-8"
+        let g:indentLine_char = "¦"
+    else
+        let g:indentLine_char = "|"
+    endif
+endif
+
+if !exists("g:indentLine_first_char")
+    if &encoding ==? "utf-8"
+        let g:indentLine_first_char = "¦"
+    else
+        let g:indentLine_first_char = "|"
+    endif
+endif
+
+if !exists("g:indentLine_indentLevel")
+    let g:indentLine_indentLevel = 10
+endif
+
+if !exists("g:indentLine_enabled")
+    let g:indentLine_enabled = 1
+endif
+
+if !exists("g:indentLine_fileType")
+    let g:indentLine_fileType = []
+endif
+
+if !exists("g:indentLine_fileTypeExclude")
+    let g:indentLine_fileTypeExclude = []
+endif
+
+if !exists("g:indentLine_bufNameExclude")
+    let g:indentLine_bufNameExclude = []
+endif
+
+if !exists("g:indentLine_showFirstIndentLevel")
+    let g:indentLine_showFirstIndentLevel = 0
+endif
+
+if !exists("g:indentLine_maxLines")
+    let g:indentLine_maxLines = 3000
+endif
+
+set conceallevel=1
+set concealcursor=inc
+
+"{{{1 function! <SID>InitColor()
+function! <SID>InitColor()
+    if !exists("g:indentLine_color_term")
+        if &bg ==? "light"
+            let term_color = 249
+        else
+            let term_color = 239
+        endif
+    else
+        let term_color = g:indentLine_color_term
+    endif
+
+    if !exists("g:indentLine_color_gui")
+        if &bg ==? "light"
+            let gui_color = "Grey70"
+        else
+            let gui_color = "Grey30"
+        endif
+    else
+        let gui_color = g:indentLine_color_gui
+    endif
+
+    exec "hi Conceal ctermfg=" . term_color . " ctermbg=NONE"
+    exec "hi Conceal guifg=" . gui_color .  " guibg=NONE"
+endfunction
+
+"{{{1 function! <SID>SetIndentLine()
+function! <SID>SetIndentLine()
+    let b:indentLine_enabled = 1
+    let space = &l:shiftwidth
+
+    if g:indentLine_showFirstIndentLevel
+        exec 'syn match IndentLine /^ / containedin=ALL conceal cchar=' . g:indentLine_first_char
+    endif
+
+    let pattern = line('$') < g:indentLine_maxLines ? 'v' : 'c'
+    for i in range(space+1, space * g:indentLine_indentLevel + 1, space)
+        exec 'syn match IndentLine /\%(^\s\+\)\@<=\%'.i.pattern.' / containedin=ALL conceal cchar=' . g:indentLine_char
+    endfor
+endfunction
+
+"{{{1 function! <SID>ResetWidth(...)
+function! <SID>ResetWidth(...)
+    if a:0 > 0
+        let &l:shiftwidth = a:1
+    endif
+
+    if exists("b:indentLine_enabled")
+        syn clear IndentLine
+    endif
+    call <SID>SetIndentLine()
+endfunction
+
+"{{{1 function! <SID>IndentLinesToggle()
+function! <SID>IndentLinesToggle()
+    if !exists("b:indentLine_enabled")
+        let b:indentLine_enabled = 0
+    endif
+
+    if b:indentLine_enabled
+        let b:indentLine_enabled = 0
+        syn clear IndentLine
+    else
+        call <SID>SetIndentLine()
+    endif
+endfunction
+
+"{{{1 function! <SID>Setup()
+function! <SID>Setup()
+    if !getbufvar("%","&hidden") || !exists("b:indentLine_set")
+        let b:indentLine_set = 1
+
+        if &ft == ""
+            call <SID>InitColor()
+        endif
+
+        if index(g:indentLine_fileTypeExclude, &ft) != -1
+            return
+        endif
+
+        if len(g:indentLine_fileType) != 0 && index(g:indentLine_fileType, &ft) == -1
+            return
+        end
+
+        for name in g:indentLine_bufNameExclude
+            if matchstr(bufname(''), name) == bufname('')
+                return
+            endif
+        endfor
+
+        if !exists("b:indentLine_enabled")
+            let b:indentLine_enabled = g:indentLine_enabled
+        endif
+
+        if b:indentLine_enabled
+            call <SID>SetIndentLine()
+        endif
+    endif
+endfunction
+
+"{{{1 commands
+autocmd BufWinEnter * call <SID>Setup()
+autocmd BufRead,ColorScheme * call <SID>InitColor()
+
+command! -nargs=? IndentLinesReset call <SID>ResetWidth(<f-args>)
+command! IndentLinesToggle call <SID>IndentLinesToggle()
+
+" vim:et:ts=4:sw=4:fdm=marker:fmr={{{,}}}

sources_non_forked/indent-lines~/doc/indentLine.txt

@@ -0,0 +1,118 @@
+*indentLine.txt*        Show vertical lines for indent with conceal feature
+
+CONTENTS                                        *indentLine-contents*
+Introduction                                    |indentLine-introduction|
+Config                                          |indentLine-config|
+Variables                                       |indentLine-variables|
+Commands                                        |indentLine-commands|
+FAQ                                             |indentLine-faq|
+Changelog                                       |indentLine-changelog|
+Credits                                         |indentLine-credits|
+==============================================================================
+INTRODUCTION                                    *indentLine-introduction*
+This plugin is used for displaying thin vertical lines at each indentation
+level for code indented with spaces. For code indented with tabs, I think
+there is no need to support it, using :set list lcs=tab:\|\ (here is a space)
+can achieve it.
+==============================================================================
+CONFIG                                          *indentLine-config*
+
+==============================================================================
+VARIABLES                                       *indentLine-variables*
+
+g:indentLine_loaded                             *g:loaded_indentLine*
+                Whether load indentLine plugin.
+                Default value is 0.
+
+g:indentLine_char                               *g:indentLine_char*
+                Specify a character to be used as indent line.
+                You also can use other characters:
+                  | ¦ ┆ │
+                Default value is "|".
+
+g:indentLine_first_char                         *g:indentLine_first_char*
+                Specify a character to be used as indent line
+                on the first level.
+                You also can use other characters:
+                  | ¦ ┆ │
+                Default value is "|".
+
+g:indentLine_color_term                         *g:indentLine_color_term*
+                Specify terminal vim indent line color.
+                e.g.  let g:indentLine_color_term = 239
+
+
+g:indentLine_color_gui                          *g:indentLine_color_gui*
+                Specify GUI vim indent line color.
+                e.g.  let g:indentLine_color_gui = '#A4E57E'
+
+g:indentLine_indentLevel                        *g:indentLine_indentLevel*
+                Specify how much indent level do you want to use for
+                indentLine. Most program will not has bigger indent level than
+                10.
+                Default value is 10.
+
+g:indentLine_showFirstIndentLevel               *g:indentLine_showFirstIndentLevel*
+                Specify whether the first indent level should be shown.
+                This is useful if you use indentLine in comination with
+                |listchars| in order to show tabs.
+                Default value is 0.
+
+g:indentLine_enabled                            *g:indentLine_enabled*
+                Specify whether to enable indentLine plugin by default.
+                If value is not 0, the plugin is on by default, otherwise off.
+                Default value is 1.
+
+g:indentLine_fileType                           *g:indentLine_fileType*
+                This variable specify a list of file types.
+                When opening these types of files, the plugin is enabled by
+                default.
+                e.g. let g:indentLine_fileType = ['c', 'cpp']
+                Default value is [] which means all file types is supported.
+
+g:indentLine_fileTypeExclude                    *g:indentLine_fileTypeExclude*
+                This variable specify a list of file types.
+                When opening these types of files, the plugin is disabled by
+                default.
+                e.g. let g:indentLine_fileType = ['text', 'sh']
+                Default value is [] which means no file types is excluded.
+
+g:indentLine_bufNameExclude                     *g:indentLine_bufNameExclude*
+                This variable specify a list of buffer names, which can be
+                regular expression. If the buffer's name fall into this list,
+                the indentLine won't display.
+                e.g. let g:indentLine_bufNameExclude = ['_.*', 'NERD_tree.*']
+                Default value is [].
+
+g:indentLine_maxLines                           *g:indentLine_maxLines*
+                This variable specify a number, when the number of buffer's
+                lines exceed it, the plugin try to use another pattern to make
+                the performance better.
+                Default value is 3000.
+
+==============================================================================
+COMMANDS                                         *indentLine-commands*
+
+IndentLinesReset [number]
+                if 'shiftwidth' changes, using this command can redraw the
+                indentLines. number is optional, it means the width between
+                two indent level, if ommited, value of 'shiftwidth' is used.
+
+IndentLinesToggle
+                toggle the indent lines of the current buffer.
+==============================================================================
+FAQ                                              *indentLine-faq*
+
+==============================================================================
+CHANGELOG                                        *indentLine-changelog*
+
+==============================================================================
+CREDITS                                          *indentLine-credits*
+
+Thanks to the following people for suggestions and patches:
+
+NagatoPain
+Salman Halim
+Christophe
+==============================================================================
+vim:tw=78:ts=8:ft=help:norl

sources_non_forked/javascript-libraries-syntax.vim

@@ -0,0 +1 @@
+Subproject commit c3e09cc87417f41047d4b324160ed42277757a4a

sources_non_forked/pycomplexity

@@ -0,0 +1 @@
+Subproject commit 1343a2eddde1b8893c4de2a95cb39b66b3af1822

sources_non_forked/python-mode

@@ -0,0 +1 @@
+Subproject commit b5b03ff1810b7a7ce5ea006842fa1033823a14a5

sources_non_forked/ropevim~

@@ -0,0 +1 @@
+Subproject commit af0c98dc4dd3efbc9f194e007979e37b2ed74a87

sources_non_forked/syntactic/.gitignore

@@ -0,0 +1,4 @@
+*~
+*.swp
+tags
+.DS_Store

sources_non_forked/syntactic/CONTRIBUTING.md

@@ -0,0 +1,49 @@
+# Bug reports / Github issues
+
+When reporting a bug make sure you search the existing github issues for the
+same/similar issues. If you find one, feel free to add a `+1` comment with any
+additional information that may help us solve the issue.
+
+When creating a new issue be sure to state the following:
+
+* Steps to reproduce the bug.
+* The version of vim you are using.
+* The version of syntastic you are using.
+
+For syntax checker bugs also state the version of the checker executable that you are using.
+
+# Submitting a patch
+
+* Fork the repo on github
+* Make a [topic branch](https://github.com/dchelimsky/rspec/wiki/Topic-Branches#using-topic-branches-when-contributing-patches) and start hacking
+* Submit a pull request based off your topic branch
+
+Small focused patches are preferred.
+
+Large changes to the code should be discussed with the core team first. Create an issue and explain your plan and see what we say.
+
+# General style notes
+
+Following the coding conventions/styles used in the syntastic core:
+
+* Use 4 space indents.
+* Don't use abbreviated keywords - e.g. use `endfunction`, not `endfun` (there's always room for more fun!).
+* Don't use `l:` prefixes for variables unless actually required (i.e. almost never).
+* Code for maintainability. We would rather a function be a couple of lines longer and have (for example) some [explaining variables](http://www.refactoring.com/catalog/introduceExplainingVariable.html) to aid readability.
+
+# Syntax checker style notes
+
+The preferred style for error format strings is one "clause" per line. E.g.
+(from the coffeelint checker):
+
+```viml
+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%.%#'
+```

sources_non_forked/syntactic/LICENCE

@@ -0,0 +1,13 @@
+           DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE
+                   Version 2, December 2004
+
+Copyright (C) 2004 Sam Hocevar <sam@hocevar.net>
+
+Everyone is permitted to copy and distribute verbatim or modified
+copies of this license document, and changing it is allowed as long
+as the name is changed.
+
+           DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE
+  TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+
+ 0. You just DO WHAT THE FUCK YOU WANT TO.

sources_non_forked/syntactic/README.markdown

@@ -0,0 +1,252 @@
+                   ,
+                  / \,,_  .'|
+               ,{{| /}}}}/_.'            _____________________________________________
+              }}}}` '{{'  '.            /                                             \
+            {{{{{    _   ;, \          /            Ladies and Gentlemen,              \
+         ,}}}}}}    /o`\  ` ;)        |                                                |
+        {{{{{{   /           (        |                 this is ...                    |
+        }}}}}}   |            \       |                                                |
+       {{{{{{{{   \            \      |                                                |
+       }}}}}}}}}   '.__      _  |     |    _____             __             __  _      |
+       {{{{{{{{       /`._  (_\ /     |   / ___/__  ______  / /_____ ______/ /_(_)____ |
+        }}}}}}'      |    //___/   --=:   \__ \/ / / / __ \/ __/ __ `/ ___/ __/ / ___/ |
+    jgs `{{{{`       |     '--'       |  ___/ / /_/ / / / / /_/ /_/ (__  ) /_/ / /__   |
+         }}}`                         | /____/\__, /_/ /_/\__/\__,_/____/\__/_/\___/   |
+                                      |      /____/                                    |
+                                      |                                               /
+                                       \_____________________________________________/
+
+
+- - -
+1\. [Introduction](#introduction)  
+2\. [Installation](#installation)  
+3\. [FAQ](#faq)  
+4\. [Other resources](#otherresources)  
+- - -
+
+<a name="introduction"></a>
+
+## 1\. Introduction
+
+Syntastic is a syntax checking plugin for Vim that runs files through external
+syntax checkers and displays any resulting errors to the user. This can be done
+on demand, or automatically as files are saved. If syntax errors are detected,
+the user is notified and is happy because they didn't have to compile their
+code or execute their script to find them.
+
+At the time of this writing, syntax checking plugins exist for ActionScript,
+Ada, AppleScript, AsciiDoc, ASM, BEMHTML, Bourne shell, C, C++, C#, Chef,
+CoffeeScript, Coco, Coq, CSS, Cucumber, CUDA, D, Dart, DocBook, Dust, Elixir,
+Erlang, eRuby, Fortran, Gentoo metadata, GLSL, Go, Haml, Haskell, Haxe,
+Handlebars, HSS, HTML, Java, JavaScript, JSON, JSX, LESS, Lex, Limbo, LISP,
+LLVM intermediate language, Lua, MATLAB, NASM, Objective-C, Objective-C++,
+OCaml, Perl, Perl POD, PHP, gettext Portable Object, Puppet, Python, Racket,
+reStructuredText, Ruby, Rust, SASS/SCSS, Scala, Slim, Tcl, TeX, Texinfo, Twig,
+TypeScript, Vala, Verilog, VHDL, VimL, xHtml, XML, XSLT, YACC, YAML, z80, Zope
+page templates, and zsh.
+
+Below is a screenshot showing the methods that Syntastic uses to display syntax
+errors.  Note that, in practise, you will only have a subset of these methods
+enabled.
+
+![Screenshot 1][0]
+
+1. Errors are loaded into the location list for the corresponding window.
+2. When the cursor is on a line containing an error, the error message is echoed in the command window.
+3. Signs are placed beside lines with errors - note that warnings are displayed in a different color.
+4. There is a configurable statusline flag you can include in your statusline config.
+5. Hover the mouse over a line containing an error and the error message is displayed as a balloon.
+6. (not shown) Highlighting errors with syntax highlighting. Erroneous parts of lines can be highlighted.
+
+<a name="installation"></a>
+
+## 2\. Installation
+
+Installing syntastic is easy but first you need to have the [pathogen][1]
+plugin installed.  If you already have [pathogen][1] working then skip
+[Step 1](#step1) and go to [Step 2](#step2).
+
+
+<a name="step1"></a>
+
+### 2.1\. Step 1: Install pathogen.vim
+
+First I'll show you how to install Tim Pope's [pathogen][1] so that it's easy to
+install syntastic.  Do this in your terminal so that you get the `pathogen.vim`
+file and the directories it needs:
+```sh
+mkdir -p ~/.vim/autoload ~/.vim/bundle; \
+curl -so ~/.vim/autoload/pathogen.vim \
+    https://raw.github.com/tpope/vim-pathogen/master/autoload/pathogen.vim
+```
+Next you *need* to add this to your `~/.vimrc`:
+```vim
+execute pathogen#infect()
+```
+
+<a name="step2"></a>
+
+### 2.2\. Step 2: Install syntastic as a pathogen bundle
+
+You now have pathogen installed and can put syntastic into `~/.vim/bundle` like
+this:
+```sh
+cd ~/.vim/bundle
+git clone https://github.com/scrooloose/syntastic.git
+```
+Quit vim and start it back up to reload it, then type:
+```vim
+:Helptags
+```
+If you get an error when you do this, then you probably didn't install
+[pathogen][1] right.  Go back to [Step 1](#step1) and make sure you did the following:
+
+1. Created both the `~/.vim/autoload` and `~/.vim/bundle` directories.
+2. Added the `call pathogen#infect()` line to your `~/.vimrc` file
+3. Did the `git clone` of syntastic inside `~/.vim/bundle`
+4. Have permissions to access all of these directories.
+
+
+<a name="faq"></a>
+
+## 3\. FAQ
+
+__Q. I installed syntastic but it isn't reporting any errors...__
+
+A. The most likely reason is that none of the syntax checkers that it requires
+is installed. For example: by default, python requires either `flake8` or
+`pylint` to be installed and in your `$PATH`. To see which executables are
+supported, look at the [wiki][3]. Note that aliases do not work; the actual
+executables must be available in your `$PATH`. Symbolic links are okay though.
+You can see syntastic's idea of available checkers by running `:SyntasticInfo`.
+
+Another reason it could fail is that either the command line options or the
+error output for a syntax checker may have changed. In this case, make sure you
+have the latest version of the syntax checker installed. If it still fails then
+create an issue - or better yet, create a pull request.
+
+__Q. The `perl` checker has stopped working...__
+
+A. The `perl` checker runs `perl -c` against your file, which in turn
+__executes__ any `BEGIN`, `UNITCHECK`, and `CHECK` blocks, and any `use`
+statements in your file (cf. [perlrun][10]).  This is probably fine if you
+wrote the file yourself, but it's a security problem if you're checking third
+party files.  Since there is currently no way to disable this behaviour while
+still producing useful results, the checker is now disabled by default.  To
+(re-)enable it, set `g:syntastic_enable_perl_checker` to 1 in your vimrc:
+```vim
+let g:syntastic_enable_perl_checker = 1
+```
+
+__Q. I run a checker and the location list is not updated...__
+
+A. By default the location list is changed only when you run the `:Errors`
+command, in order to minimise conflicts with other plugins.  If you want the
+location list to always be updated when you run the checkers, add this line to
+your vimrc:
+```vim
+let g:syntastic_always_populate_loc_list = 1
+```
+
+__Q. How can I pass additional arguments to a checker?__
+
+A. Almost all syntax checkers use the `makeprgBuild()` function. Those checkers
+that do can be configured using global variables. The general form of the
+global `args` variables is `syntastic_<filetype>_<checker>_args`.
+
+So, If you wanted to pass "--my --args --here" to the ruby mri checker you
+would add this line to your vimrc:
+```vim
+let g:syntastic_ruby_mri_args = "--my --args --here"
+```
+
+See `:help syntastic-checker-options` for more information.
+
+__Q. Syntastic supports several checkers for my filetype - how do I tell it
+which one(s) to use?__
+
+A. Stick a line like this in your vimrc:
+```vim
+let g:syntastic_<filetype>_checkers = ['<checker-name>']
+```
+
+To see the list of supported checkers for your filetype look at the
+[wiki][3].
+
+e.g. Python has the following checkers, among others: `flake8`, `pyflakes`,
+`pylint` and a native `python` checker.
+
+To tell syntastic to use `pylint`, you would use this setting:
+```vim
+let g:syntastic_python_checkers = ['pylint']
+```
+
+Some filetypes, like PHP, have style checkers as well as syntax checkers. These
+can be chained together like this:
+```vim
+let g:syntastic_php_checkers = ['php', 'phpcs', 'phpmd']
+```
+
+This is telling syntastic to run the `php` checker first, and if no errors are
+found, run `phpcs`, and then `phpmd`.
+
+__Q. How can I jump between the different errors without using the location
+list at the bottom of the window?__
+
+A. Vim provides several built in commands for this. See `:help :lnext` and
+`:help :lprev`.
+
+If you use these commands a lot then you may want to add shortcut mappings to
+your vimrc, or install something like [unimpaired][2], which provides such
+mappings (among other things).
+
+__Q. A syntax checker is giving me unwanted/strange style tips?__
+
+A. Some filetypes (e.g. php) have style checkers as well as syntax
+checkers. You can usually configure the options that are passed to the style
+checkers, or just disable them. Take a look at the [wiki][3] to see what
+options are available.
+
+Alternatively, you can use `g:syntastic_quiet_messages` to filter out the
+messages you don't want to see. e.g. To turn off all style messages:
+```vim
+let g:syntastic_quiet_messages = { "type": "style" }
+```
+See `:help syntastic_quiet_messages` for details.
+
+__Q. The error window is closed automatically when I :quit the current buffer
+but not when I :bdelete it?__
+
+A. There is no safe way to handle that situation automatically, but you can
+work around it:
+
+```vim
+nnoremap <silent> <C-d> :lclose<CR>:bdelete<CR>
+cabbrev <silent> bd lclose\|bdelete
+```
+
+
+<a name="otherresources"></a>
+
+## 4\. Other resources
+
+The preferred place for posting suggestions, reporting bugs, and general
+discussions related to syntastic is the [issue tracker at GitHub][4].  There
+are also a [google group][5], and a [syntastic tag at StackOverflow][6].
+
+Syntastic aims to provide a common interface to syntax checkers for as many
+languages as possible.  For particular languages, there are, of course, other
+plugins that provide more functionality than syntastic.  You might want to take
+a look at [jedi-vim][7], [python-mode][8], or [YouCompleteMe][9].
+
+[0]: https://github.com/scrooloose/syntastic/raw/master/_assets/screenshot_1.png
+[1]: https://github.com/tpope/vim-pathogen
+[2]: https://github.com/tpope/vim-unimpaired
+[3]: https://github.com/scrooloose/syntastic/wiki/Syntax-Checkers
+[4]: https://github.com/scrooloose/syntastic/issues
+[5]: https://groups.google.com/group/vim-syntastic
+[6]: http://stackoverflow.com/questions/tagged/syntastic
+[7]: https://github.com/davidhalter/jedi-vim
+[8]: https://github.com/klen/python-mode
+[9]: https://github.com/Valloric/YouCompleteMe
+[10]: http://perldoc.perl.org/perlrun.html#*-c*

sources_non_forked/syntactic/autoload/syntastic/c.vim

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

sources_non_forked/syntactic/autoload/syntastic/log.vim

@@ -0,0 +1,159 @@
+if exists("g:loaded_syntastic_log_autoload") || !exists("g:loaded_syntastic_plugin")
+    finish
+endif
+let g:loaded_syntastic_log_autoload = 1
+
+let s:save_cpo = &cpo
+set cpo&vim
+
+let s:deprecation_notices_issued = []
+
+" Public functions {{{1
+
+function! syntastic#log#info(msg) " {{{2
+    echomsg "syntastic: info: " . a:msg
+endfunction " }}}2
+
+function! syntastic#log#warn(msg) " {{{2
+    echohl WarningMsg
+    echomsg "syntastic: warning: " . a:msg
+    echohl None
+endfunction " }}}2
+
+function! syntastic#log#error(msg) " {{{2
+    execute "normal \<Esc>"
+    echohl ErrorMsg
+    echomsg "syntastic: error: " . a:msg
+    echohl None
+endfunction " }}}2
+
+function! syntastic#log#deprecationWarn(msg) " {{{2
+    if index(s:deprecation_notices_issued, a:msg) >= 0
+        return
+    endif
+
+    call add(s:deprecation_notices_issued, a:msg)
+    call syntastic#log#warn(a:msg)
+endfunction " }}}2
+
+function! syntastic#log#debug(level, msg, ...) " {{{2
+    if !s:isDebugEnabled(a:level)
+        return
+    endif
+
+    let leader = s:logTimestamp()
+    call s:logRedirect(1)
+
+    if a:0 > 0
+        " filter out dictionary functions
+        echomsg leader . a:msg . ' ' .
+            \ strtrans(string(type(a:1) == type({}) || type(a:1) == type([]) ?
+            \ filter(copy(a:1), 'type(v:val) != type(function("tr"))') : a:1))
+    else
+        echomsg leader . a:msg
+    endif
+
+    call s:logRedirect(0)
+endfunction " }}}2
+
+function! syntastic#log#debugShowOptions(level, names) " {{{2
+    if !s:isDebugEnabled(a:level)
+        return
+    endif
+
+    let leader = s:logTimestamp()
+    call s:logRedirect(1)
+
+    let vlist = copy(type(a:names) == type("") ? [a:names] : a:names)
+    if !empty(vlist)
+        call map(vlist, "'&' . v:val . ' = ' . strtrans(string(eval('&' . v:val)))")
+        echomsg leader . join(vlist, ', ')
+    endif
+    call s:logRedirect(0)
+endfunction " }}}2
+
+function! syntastic#log#debugShowVariables(level, names) " {{{2
+    if !s:isDebugEnabled(a:level)
+        return
+    endif
+
+    let leader = s:logTimestamp()
+    call s:logRedirect(1)
+
+    let vlist = type(a:names) == type("") ? [a:names] : a:names
+    for name in vlist
+        let msg = s:formatVariable(name)
+        if msg != ''
+            echomsg leader . msg
+        endif
+    endfor
+
+    call s:logRedirect(0)
+endfunction " }}}2
+
+function! syntastic#log#debugDump(level) " {{{2
+    if !s:isDebugEnabled(a:level)
+        return
+    endif
+
+    call syntastic#log#debugShowVariables( a:level, sort(keys(g:syntastic_defaults)) )
+endfunction " }}}2
+
+" }}}1
+
+" Private functions {{{1
+
+function! s:isDebugEnabled_smart(level) " {{{2
+    return and(g:syntastic_debug, a:level)
+endfunction " }}}2
+
+function! s:isDebugEnabled_dumb(level) " {{{2
+    " poor man's bit test for bit N, assuming a:level == 2**N
+    return (g:syntastic_debug / a:level) % 2
+endfunction " }}}2
+
+let s:isDebugEnabled = function(exists('*and') ? 's:isDebugEnabled_smart' : 's:isDebugEnabled_dumb')
+
+function! s:logRedirect(on) " {{{2
+    if exists("g:syntastic_debug_file")
+        if a:on
+            try
+                execute 'redir >> ' . fnameescape(expand(g:syntastic_debug_file))
+            catch /\m^Vim\%((\a\+)\)\=:/
+                silent! redir END
+                unlet g:syntastic_debug_file
+            endtry
+        else
+            silent! redir END
+        endif
+    endif
+endfunction " }}}2
+
+function! s:logTimestamp_smart() " {{{2
+    return 'syntastic: ' . split(reltimestr(reltime(g:syntastic_start)))[0] . ': '
+endfunction " }}}2
+
+function! s:logTimestamp_dumb() " {{{2
+    return 'syntastic: debug: '
+endfunction " }}}2
+
+let s:logTimestamp = function(has('reltime') ? 's:logTimestamp_smart' : 's:logTimestamp_dumb')
+
+function! s:formatVariable(name) " {{{2
+    let vals = []
+    if exists('g:syntastic_' . a:name)
+        call add(vals, 'g:syntastic_' . a:name . ' = ' . strtrans(string(g:syntastic_{a:name})))
+    endif
+    if exists('b:syntastic_' . a:name)
+        call add(vals, 'b:syntastic_' . a:name . ' = ' . strtrans(string(b:syntastic_{a:name})))
+    endif
+
+    return join(vals, ', ')
+endfunction " }}}2
+
+" }}}1
+
+let &cpo = s:save_cpo
+unlet s:save_cpo
+
+" vim: set sw=4 sts=4 et fdm=marker:

sources_non_forked/syntactic/autoload/syntastic/postprocess.vim

@@ -0,0 +1,71 @@
+if exists("g:loaded_syntastic_postprocess_autoload") || !exists("g:loaded_syntastic_plugin")
+    finish
+endif
+let g:loaded_syntastic_postprocess_autoload = 1
+
+let s:save_cpo = &cpo
+set cpo&vim
+
+" Public functions {{{1
+
+function! s:compareErrorItems(a, b) " {{{2
+    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', 0) - get(a:b, 'col', 0)
+    endif
+endfunction " }}}2
+
+" natural sort
+function! syntastic#postprocess#sort(errors) " {{{2
+    return sort(copy(a:errors), 's:compareErrorItems')
+endfunction " }}}2
+
+" merge consecutive blanks
+function! syntastic#postprocess#compressWhitespace(errors) " {{{2
+    for e in a:errors
+        let e['text'] = substitute(e['text'], "\001", '', 'g')
+        let e['text'] = substitute(e['text'], '\n', ' ', 'g')
+        let e['text'] = substitute(e['text'], '\m\s\{2,}', ' ', 'g')
+    endfor
+
+    return a:errors
+endfunction " }}}2
+
+" remove spurious CR under Cygwin
+function! syntastic#postprocess#cygwinRemoveCR(errors) " {{{2
+    if has('win32unix')
+        for e in a:errors
+            let e['text'] = substitute(e['text'], '\r', '', 'g')
+        endfor
+    endif
+
+    return a:errors
+endfunction " }}}2
+
+" decode XML entities
+function! syntastic#postprocess#decodeXMLEntities(errors) " {{{2
+    for e in a:errors
+        let e['text'] = syntastic#util#decodeXMLEntities(e['text'])
+    endfor
+
+    return a:errors
+endfunction " }}}2
+
+" filter out errors referencing other files
+function! syntastic#postprocess#filterForeignErrors(errors) " {{{2
+    return filter(copy(a:errors), 'get(v:val, "bufnr") == ' . bufnr(''))
+endfunction " }}}2
+
+" }}}1
+
+let &cpo = s:save_cpo
+unlet s:save_cpo
+
+" vim: set sw=4 sts=4 et fdm=marker:

sources_non_forked/syntactic/autoload/syntastic/preprocess.vim

@@ -0,0 +1,79 @@
+if exists("g:loaded_syntastic_preprocess_autoload") || !exists("g:loaded_syntastic_plugin")
+    finish
+endif
+let g:loaded_syntastic_preprocess_autoload = 1
+
+let s:save_cpo = &cpo
+set cpo&vim
+
+" Public functions {{{1
+
+function! syntastic#preprocess#checkstyle(errors) " {{{2
+    let out = []
+    let fname = expand('%')
+    for err in a:errors
+        if match(err, '\m<error\>') > -1
+            let line = str2nr(matchstr(err, '\m\<line="\zs\d\+\ze"'))
+            if line == 0
+                continue
+            endif
+
+            let col = str2nr(matchstr(err, '\m\<column="\zs\d\+\ze"'))
+
+            let type = matchstr(err, '\m\<severity="\zs.\ze')
+            if type !~? '^[EW]'
+                let type = 'E'
+            endif
+
+            let message = syntastic#util#decodeXMLEntities(matchstr(err, '\m\<message="\zs[^"]\+\ze"'))
+
+            call add(out, join([fname, type, line, col, message], ':'))
+        elseif match(err, '\m<file name="') > -1
+            let fname = syntastic#util#decodeXMLEntities(matchstr(err, '\v\<file name\="\zs[^"]+\ze"'))
+        endif
+    endfor
+    return out
+endfunction " }}}2
+
+function! syntastic#preprocess#cppcheck(errors) " {{{2
+    return map(copy(a:errors), 'substitute(v:val, ''\v^\[[^]]+\]\zs( -\> \[[^]]+\])+\ze:'', "", "")')
+endfunction " }}}2
+
+function! syntastic#preprocess#killEmpty(errors) " {{{2
+    return filter(copy(a:errors), 'v:val != ""')
+endfunction " }}}2
+
+function! syntastic#preprocess#perl(errors) " {{{2
+    let out = []
+
+    for e in a:errors
+        let parts = matchlist(e, '\v^(.*)\sat\s(.*)\sline\s(\d+)(.*)$')
+        if !empty(parts)
+            call add(out, parts[2] . ':' . parts[3] . ':' . parts[1] . parts[4])
+        endif
+    endfor
+
+    return syntastic#util#unique(out)
+endfunction " }}}2
+
+function! syntastic#preprocess#validator(errors) " {{{2
+    let out = []
+    for e in a:errors
+        let parts = matchlist(e, '\v^"([^"]+)"(.+)')
+        if len(parts) >= 3
+            " URL decode, except leave alone any "+"
+            let parts[1] = substitute(parts[1], '\m%\(\x\x\)', '\=nr2char("0x".submatch(1))', 'g')
+            let parts[1] = substitute(parts[1], '\m\\"', '"', 'g')
+            let parts[1] = substitute(parts[1], '\m\\\\', '\\', 'g')
+            call add(out, '"' . parts[1] . '"' . parts[2])
+        endif
+    endfor
+    return out
+endfunction " }}}2
+
+" }}}1
+
+let &cpo = s:save_cpo
+unlet s:save_cpo
+
+" vim: set sw=4 sts=4 et fdm=marker:

sources_non_forked/syntactic/autoload/syntastic/util.vim

@@ -0,0 +1,262 @@
+if exists('g:loaded_syntastic_util_autoload') || !exists("g:loaded_syntastic_plugin")
+    finish
+endif
+let g:loaded_syntastic_util_autoload = 1
+
+let s:save_cpo = &cpo
+set cpo&vim
+
+" Public functions {{{1
+
+function! syntastic#util#isRunningWindows() " {{{2
+    return has('win16') || has('win32') || has('win64')
+endfunction " }}}2
+
+function! syntastic#util#DevNull() " {{{2
+    if syntastic#util#isRunningWindows()
+        return 'NUL'
+    endif
+    return '/dev/null'
+endfunction " }}}2
+
+" Get directory separator
+function! syntastic#util#Slash() abort " {{{2
+    return (!exists("+shellslash") || &shellslash) ? '/' : '\'
+endfunction " }}}2
+
+"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() " {{{2
+    for lnum in range(1,5)
+        let line = getline(lnum)
+
+        if line =~ '^#!'
+            let exe = matchstr(line, '\m^#!\s*\zs[^ \t]*')
+            let args = split(matchstr(line, '\m^#!\s*[^ \t]*\zs.*'))
+            return { 'exe': exe, 'args': args }
+        endif
+    endfor
+
+    return { 'exe': '', 'args': [] }
+endfunction " }}}2
+
+" Get the value of a variable.  Allow local variables to override global ones.
+function! syntastic#util#var(name, ...) " {{{2
+    return
+        \ exists('b:syntastic_' . a:name) ? b:syntastic_{a:name} :
+        \ exists('g:syntastic_' . a:name) ? g:syntastic_{a:name} :
+        \ a:0 > 0 ? a:1 : ''
+endfunction " }}}2
+
+" Parse a version string.  Return an array of version components.
+function! syntastic#util#parseVersion(version) " {{{2
+    return split(matchstr( a:version, '\v^\D*\zs\d+(\.\d+)+\ze' ), '\m\.')
+endfunction " }}}2
+
+" Run 'command' in a shell and parse output as a version string.
+" Returns an array of version components.
+function! syntastic#util#getVersion(command) " {{{2
+    return syntastic#util#parseVersion(system(a:command))
+endfunction " }}}2
+
+" Verify that the 'installed' version is at least the 'required' version.
+"
+" 'installed' and 'required' must be arrays. If they have different lengths,
+" 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) " {{{2
+    for idx in range(max([len(a:installed), len(a:required)]))
+        let installed_element = get(a:installed, idx, 0)
+        let required_element = get(a:required, idx, 0)
+        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 " }}}2
+
+" strwidth() was added in Vim 7.3; if it doesn't exist, we use strlen()
+" and hope for the best :)
+let s:width = function(exists('*strwidth') ? 'strwidth' : 'strlen')
+
+"print as much of a:msg as possible without "Press Enter" prompt appearing
+function! syntastic#util#wideMsg(msg) " {{{2
+    let old_ruler = &ruler
+    let old_showcmd = &showcmd
+
+    "This is here because it is possible for some error messages to
+    "begin with \n which will cause a "press enter" prompt.
+    let msg = substitute(a:msg, "\n", "", "g")
+
+    "convert tabs to spaces so that the tabs count towards the window
+    "width as the proper amount of characters
+    let chunks = split(msg, "\t", 1)
+    let msg = join(map(chunks[:-2], 'v:val . repeat(" ", &ts - s:width(v:val) % &ts)'), '') . chunks[-1]
+    let msg = strpart(msg, 0, &columns - 1)
+
+    set noruler noshowcmd
+    call syntastic#util#redraw(0)
+
+    echo msg
+
+    let &ruler = old_ruler
+    let &showcmd = old_showcmd
+endfunction " }}}2
+
+" Check whether a buffer is loaded, listed, and not hidden
+function! syntastic#util#bufIsActive(buffer) " {{{2
+    " convert to number, or hell breaks loose
+    let buf = str2nr(a:buffer)
+
+    if !bufloaded(buf) || !buflisted(buf)
+        return 0
+    endif
+
+    " get rid of hidden buffers
+    for tab in range(1, tabpagenr('$'))
+        if index(tabpagebuflist(tab), buf) >= 0
+            return 1
+        endif
+    endfor
+
+    return 0
+endfunction " }}}2
+
+" start in directory a:where and walk up the parent folders until it
+" finds a file matching a:what; return path to that file
+function! syntastic#util#findInParent(what, where) " {{{2
+    let here = fnamemodify(a:where, ':p')
+
+    let root = syntastic#util#Slash()
+    if syntastic#util#isRunningWindows() && here[1] == ':'
+        " The drive letter is an ever-green source of fun.  That's because
+        " we don't care about running syntastic on Amiga these days. ;)
+        let root = fnamemodify(root, ':p')
+        let root = here[0] . root[1:]
+    endif
+
+    let old = ''
+    while here != ''
+        let p = split(globpath(here, a:what), '\n')
+
+        if !empty(p)
+            return fnamemodify(p[0], ':p')
+        elseif here ==? root || here ==? old
+            break
+        endif
+
+        let old = here
+
+        " we use ':h:h' rather than ':h' since ':p' adds a trailing '/'
+        " if 'here' is a directory
+        let here = fnamemodify(here, ':p:h:h')
+    endwhile
+
+    return ''
+endfunction " }}}2
+
+" Returns unique elements in a list
+function! syntastic#util#unique(list) " {{{2
+    let seen = {}
+    let uniques = []
+    for e in a:list
+        if !has_key(seen, e)
+            let seen[e] = 1
+            call add(uniques, e)
+        endif
+    endfor
+    return uniques
+endfunction " }}}2
+
+" A less noisy shellescape()
+function! syntastic#util#shescape(string) " {{{2
+    return a:string =~ '\m^[A-Za-z0-9_/.-]\+$' ? a:string : shellescape(a:string)
+endfunction " }}}2
+
+" A less noisy shellescape(expand())
+function! syntastic#util#shexpand(string) " {{{2
+    return syntastic#util#shescape(expand(a:string))
+endfunction " }}}2
+
+" decode XML entities
+function! syntastic#util#decodeXMLEntities(string) " {{{2
+    let str = a:string
+    let str = substitute(str, '\m&lt;', '<', 'g')
+    let str = substitute(str, '\m&gt;', '>', 'g')
+    let str = substitute(str, '\m&quot;', '"', 'g')
+    let str = substitute(str, '\m&apos;', "'", 'g')
+    let str = substitute(str, '\m&amp;', '\&', 'g')
+    return str
+endfunction " }}}2
+
+function! syntastic#util#redraw(full) " {{{2
+    if a:full
+        redraw!
+    else
+        redraw
+    endif
+endfunction " }}}2
+
+function! syntastic#util#dictFilter(errors, filter) " {{{2
+    let rules = s:translateFilter(a:filter)
+    " call syntastic#log#debug(g:SyntasticDebugFilters, "applying filter:", rules)
+    try
+        call filter(a:errors, rules)
+    catch /\m^Vim\%((\a\+)\)\=:E/
+        let msg = matchstr(v:exception, '\m^Vim\%((\a\+)\)\=:\zs.*')
+        call syntastic#log#error('quiet_messages: ' . msg)
+    endtry
+endfunction " }}}2
+
+" }}}1
+
+" Private functions {{{1
+
+function! s:translateFilter(filters) " {{{2
+    let conditions = []
+    for k in keys(a:filters)
+        if type(a:filters[k]) == type([])
+            call extend(conditions, map(copy(a:filters[k]), 's:translateElement(k, v:val)'))
+        else
+            call add(conditions, s:translateElement(k, a:filters[k]))
+        endif
+    endfor
+
+    if conditions == []
+        let conditions = ["1"]
+    endif
+    return len(conditions) == 1 ? conditions[0] : join(map(conditions, '"(" . v:val . ")"'), ' && ')
+endfunction " }}}2
+
+function! s:translateElement(key, term) " {{{2
+    if a:key ==? 'level'
+        let ret = 'v:val["type"] !=? ' . string(a:term[0])
+    elseif a:key ==? 'type'
+        let ret = a:term ==? 'style' ? 'get(v:val, "subtype", "") !=? "style"' : 'has_key(v:val, "subtype")'
+    elseif a:key ==? 'regex'
+        let ret = 'v:val["text"] !~? ' . string(a:term)
+    elseif a:key ==? 'file'
+        let ret = 'bufname(str2nr(v:val["bufnr"])) !~# ' . string(a:term)
+    else
+        call syntastic#log#warn('quiet_messages: ignoring invalid key ' . strtrans(string(a:key)))
+        let ret = "1"
+    endif
+    return ret
+endfunction " }}}2
+
+" }}}1
+
+let &cpo = s:save_cpo
+unlet s:save_cpo
+
+" vim: set sw=4 sts=4 et fdm=marker:

sources_non_forked/syntactic/doc/syntastic.txt

@@ -0,0 +1,684 @@
+*syntastic.txt*   Syntax checking on the fly has never been so pimp.
+*syntastic*
+
+
+                    It's a bird! It's a plane! ZOMG It's ... ~
+
+                   _____             __             __  _      ~
+                  / ___/__  ______  / /_____ ______/ /_(_)____ ~
+                  \__ \/ / / / __ \/ __/ __ `/ ___/ __/ / ___/ ~
+                 ___/ / /_/ / / / / /_/ /_/ (__  ) /_/ / /__   ~
+                /____/\__, /_/ /_/\__/\__,_/____/\__/_/\___/   ~
+                     /____/                                    ~
+
+
+
+                              Reference Manual~
+
+
+==============================================================================
+CONTENTS                                                  *syntastic-contents*
+
+    1.Intro........................................|syntastic-intro|
+        1.1.Quick start............................|syntastic-quickstart|
+    2.Functionality provided.......................|syntastic-functionality|
+        2.1.The statusline flag....................|syntastic-statusline-flag|
+        2.2.Error signs............................|syntastic-error-signs|
+        2.3.Error window...........................|syntastic-error-window|
+        2.4.Error highlighting.....................|syntastic-highlighting|
+        2.5.Aggregating errors.....................|syntastic-aggregating-errors|
+        2.6.Filtering errors.......................|syntastic-filtering-errors|
+    3.Commands.....................................|syntastic-commands|
+    4.Global Options...............................|syntastic-global-options|
+    5.Checker Options..............................|syntastic-checker-options|
+        5.1.Choosing which checkers to use.........|syntastic-filetype-checkers|
+        5.2.Choosing the executable................|syntastic-config-exec|
+        5.3.Configuring specific checkers..........|syntastic-config-makeprg|
+    6.Notes........................................|syntastic-notes|
+        6.1.Handling of composite filetypes........|syntastic-composite|
+        6.2.Interaction with python-mode...........|syntastic-pymode|
+        6.3.Interaction with the fish shell........|syntastic-fish|
+        6.4.Using syntastic with the fizsh shell...|syntastic-fizsh|
+    7.About........................................|syntastic-about|
+    8.License......................................|syntastic-license|
+
+
+==============================================================================
+1. Intro                                                     *syntastic-intro*
+
+Syntastic is a syntax checking plugin that runs files through external syntax
+checkers. This can be done on demand, or automatically as files are saved and
+opened.  If syntax errors are detected, the user is notified and is happy
+because they didn't have to compile their code or execute their script to find
+them.
+
+Syntastic comes in two parts: the syntax checker plugins, and the core. The
+syntax checker plugins are defined on a per-filetype basis where each one wraps
+up an external syntax checking program. The core script delegates off to these
+plugins and uses their output to provide the syntastic functionality.
+
+Take a look at the wiki for a list of supported filetypes and checkers:
+
+    https://github.com/scrooloose/syntastic/wiki/Syntax-Checkers
+
+Note: This doc only deals with using syntastic. To learn how to write syntax
+checker integrations, see the guide on the github wiki:
+
+    https://github.com/scrooloose/syntastic/wiki/Syntax-Checker-Guide
+
+------------------------------------------------------------------------------
+1.1. Quick start                                        *syntastic-quickstart*
+
+Syntastic comes preconfigured with a default list of enabled checkers per
+filetype. This list is kept reasonably short to prevent slowing down Vim or
+trying to use conflicting checkers.
+
+You can see the list checkers available for the current filetype with the
+|:SyntasticInfo| command.
+
+If you want to override the configured list of checkers for a filetype then
+see |syntastic-checker-options| for details. You can also change the arguments
+passed to a specific checker as well.
+
+Use |:SyntasticCheck| to manually check right now. Use |:SyntasticToggleMode|
+to switch between active (checking on writting the buffer) and passive (manual)
+checking.
+
+==============================================================================
+2. Functionality provided                            *syntastic-functionality*
+
+Syntax checking can be done automatically or on demand (see
+|'syntastic_mode_map'| and |:SyntasticToggleMode| for configuring this).
+
+When syntax checking is done, the features below can be used to notify the
+user of errors. See |syntastic-options| for how to configure and
+activate/deactivate these features.
+
+    * A statusline flag
+    * Signs beside lines with errors
+    * The |location-list| can be populated with the errors for the associated
+      buffer
+    * Erroneous parts of lines can be highlighted (this functionality is only
+      provided by some syntax checkers)
+    * Balloons (if the |+balloon_eval| feature is compiled in) can be used to
+      display error messages for erroneous lines when hovering the mouse over
+      them
+    * Error messages from multiple checkers can be aggregated in a single list
+
+------------------------------------------------------------------------------
+2.1. The statusline flag                           *syntastic-statusline-flag*
+
+To use the statusline flag, this must appear in your |'statusline'| setting >
+    %{SyntasticStatuslineFlag()}
+<
+Something like this could be more useful: >
+    set statusline+=%#warningmsg#
+    set statusline+=%{SyntasticStatuslineFlag()}
+    set statusline+=%*
+<
+When syntax errors are detected a flag will be shown. The content of the flag
+is derived from the |syntastic_stl_format| option.
+
+------------------------------------------------------------------------------
+2.2. Error signs                                       *syntastic-error-signs*
+
+Syntastic uses the |:sign| commands to mark lines with errors and warnings in
+the sign column. To enable this feature, use the |'syntastic_enable_signs'|
+option.
+
+Signs are colored using the Error and Todo syntax highlight groups by default.
+If you wish to customize the colors for the signs, you can use the following
+groups:
+    SyntasticErrorSign - For syntax errors, links to 'error' by default
+    SyntasticWarningSign - For syntax warnings, links to 'todo' by default
+    SyntasticStyleErrorSign - For style errors, links to 'SyntasticErrorSign'
+                              by default
+    SyntasticStyleWarningSign - For style warnings, links to
+                                'SyntasticWarningSign' by default
+
+Example: >
+    highlight SyntasticErrorSign guifg=white guibg=red
+<
+To set up highlighting for the line where a sign resides, you can use the
+following highlight groups:
+    SyntasticErrorLine
+    SyntasticWarningLine
+    SyntasticStyleErrorLine - Links to 'SyntasticErrorLine' by default
+    SyntasticStyleWarningLine - Links to 'SyntasticWarningLine' by default
+
+Example: >
+    highlight SyntasticErrorLine guibg=#2f0000
+<
+------------------------------------------------------------------------------
+2.3. The error window                         *:Errors* *syntastic-error-window*
+
+You can use the :Errors command to display the errors for the current buffer
+in the |location-list|.
+
+Note that when you use :Errors, the current location list is overwritten with
+Syntastic's own location list.
+
+------------------------------------------------------------------------------
+2.4. Error highlighting                               *syntastic-highlighting*
+
+Some checkers provide enough information for syntastic to be able to highlight
+errors. By default the SpellBad syntax highlight group is used to color errors,
+and the SpellCap group is used for warnings. If you wish to customize the
+colors for highlighting you can use the following groups:
+    SyntasticError - Links to 'SpellBad' by default
+    SyntasticWarning - Links to 'SpellCap' by default
+
+Example: >
+    highlight SyntasticError guibg=#2f0000
+<
+------------------------------------------------------------------------------
+2.5. Aggregating errors                         *syntastic-aggregating-errors*
+
+By default, namely if |'syntastic_aggregate_errors'| is unset, syntastic runs
+in turn the checkers corresponding to the filetype of the current file (see
+|syntastic-filetype-checkers|), and stops as soon as a checker reports any
+errors. It then notifies you of the errors using the notification mechanisms
+above. In this mode error lists are always produced by a single checker, and,
+if you open the error window, the name of the checker that generated the errors
+is shown on the statusline of the error window.
+
+If |'syntastic_aggregate_errors'| is set, syntastic runs all checkers that
+apply (still cf. |syntastic-filetype-checkers|), then aggregates errors found
+by all checkers in a single list, and notifies you. In this mode each error
+message is labeled with the name of the checker that generated it, but you can
+disable these labels by unsetting '|syntastic_id_checkers|'.
+
+------------------------------------------------------------------------------
+2.6 Filtering errors                              *syntastic-filtering-errors*
+
+You can selectively disable some of the errors found by checkers either
+using |'syntastic_quiet_messages'|, or by specifying a list of patterns in
+|'syntastic_ignore_files'|.
+
+See also: |'syntastic_<filetype>_<checker>_quiet_messages'|.
+
+==============================================================================
+3. Commands                                               *syntastic-commands*
+
+:Errors                                                     *:SyntasticErrors*
+
+When errors have been detected, use this command to pop up the |location-list|
+and display the error messages.
+
+:SyntasticToggleMode                                    *:SyntasticToggleMode*
+
+Toggles syntastic between active and passive mode. See |'syntastic_mode_map'|
+for more info.
+
+:SyntasticCheck                                              *:SyntasticCheck*
+
+Manually cause a syntax check to be done.  By default the checkers in the
+|'g:syntastic_<filetype>_checkers'| or |'b:syntastic_checkers'| lists are run,
+cf. |syntastic-filetype-checkers|.  If |syntastic_aggregate_errors| is unset
+(which is the default), checking stops the first time a checker reports any
+errors; if |syntastic_aggregate_errors| is set, all checkers that apply are run
+in turn, and all errors found are aggregated in a single list.
+
+The command may be followed by a (space separated) list of checkers.  In this
+case |'g:syntastic_<filetype>_checkers'| and |'b:syntastic_checkers'| are
+ignored, and the checkers named by the command's arguments are run instead, in
+the order specified.  The rules of |syntastic_aggregate_errors| still apply.
+
+Example: >
+    :SyntasticCheck flake8 pylint
+<
+:SyntasticInfo                                               *:SyntasticInfo*
+
+The command takes an optional argument, and outputs information about the
+checkers available for the filetype named by said argument, or for the current
+filetype if no argument was provided.
+
+:SyntasticReset                                              *:SyntasticReset*
+
+Resets the list of errors and turns off all error notifiers.
+
+:SyntasticSetLoclist                                    *:SyntasticSetLoclist*
+
+If |'syntastic_always_populate_loc_list'| is not set, the |location-list| is
+not filled in automatically with the list of errors detected by the checkers.
+This is useful if you run syntastic along with other plugins that use location
+lists.  The |:SyntasticSetLoclist| command allows you to stick the errors into
+the location list explicitly.
+
+==============================================================================
+4. Global Options                                   *syntastic-global-options*
+
+
+                                                   *'syntastic_check_on_open'*
+Default: 0
+If enabled, syntastic will do syntax checks when buffers are first loaded as
+well as on saving >
+    let g:syntastic_check_on_open = 1
+<
+                                                     *'syntastic_check_on_wq'*
+Default: 1
+Normally syntastic runs syntax checks whenever buffers are written to disk.
+If you want to skip these checks when you issue |:wq|, |:x|, and |:ZZ|, set this
+variable to 0. >
+    let g:syntastic_check_on_wq = 0
+<
+                                                *'syntastic_aggregate_errors'*
+Default: 0
+When enabled, syntastic runs all checkers that apply to the current filetype,
+then aggregates errors found by all checkers and displays them. When disabled,
+syntastic runs each checker in turn, and stops to display the results the first
+time a checker finds any errors. >
+    let g:syntastic_aggregate_errors = 1
+<
+                                                     *'syntastic_id_checkers'*
+Default: 1
+When results from multiple checkers are aggregated in a single error list
+(that is either when |syntastic_aggregate_errors| is enabled, or when checking
+a file with a composite filetype), it might not be immediately obvious which
+checker has produced a given error message. This variable instructs syntastic
+to label error messages with the names of the checkers that created them. >
+    let g:syntastic_id_checkers = 0
+<
+                                              *'syntastic_echo_current_error'*
+Default: 1
+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
+<
+                                                    *'syntastic_enable_signs'*
+Default: 1
+Use this option to tell syntastic whether to use the |:sign| interface to mark
+syntax errors: >
+    let g:syntastic_enable_signs = 1
+<
+                     *'syntastic_error_symbol'* *'syntastic_style_error_symbol'*
+                 *'syntastic_warning_symbol'* *'syntastic_style_warning_symbol'*
+Use this option to control what the syntastic |:sign| text contains. Several
+error symbols can be customized:
+    syntastic_error_symbol - For syntax errors, defaults to '>>'
+    syntastic_style_error_symbol - For style errors, defaults to 'S>'
+    syntastic_warning_symbol - For syntax warnings, defaults to '>>'
+    syntastic_style_warning_symbol - For style warnings, defaults to 'S>'
+
+Example: >
+    let g:syntastic_error_symbol = '✗'
+    let g:syntastic_warning_symbol = '⚠'
+<
+                                                 *'syntastic_enable_balloons'*
+Default: 1
+Use this option to tell syntastic whether to display error messages in balloons
+when the mouse is hovered over erroneous lines: >
+    let g:syntastic_enable_balloons = 1
+<
+Note that Vim must be compiled with |+balloon_eval|.
+
+                                             *'syntastic_enable_highlighting'*
+Default: 1
+Use this option to tell syntastic whether to use syntax highlighting to mark
+errors (where possible). Highlighting can be turned off with the following >
+    let g:syntastic_enable_highlighting = 0
+<
+                                        *'syntastic_always_populate_loc_list'*
+Default: 0
+Enable this option to tell syntastic to always stick any detected errors into
+the |location-list|: >
+    let g:syntastic_always_populate_loc_list = 1
+<
+                                                       *'syntastic_auto_jump'*
+Default: 0
+Enable this option if you want the cursor to jump to the first detected issue
+when saving or opening a file.
+
+When set to 0 the cursor won't jump automatically. >
+    let g:syntastic_auto_jump = 0
+<
+When set to 1 the cursor will always jump to the first issue detected. >
+    let g:syntastic_auto_jump = 1
+<
+When set to 2 the cursor will jump to the first issue detected, but only if
+this issue is an error. >
+    let g:syntastic_auto_jump = 2
+<
+                                                   *'syntastic_auto_loc_list'*
+Default: 2
+Use this option to tell syntastic to automatically open and/or close the
+|location-list| (see |syntastic-error-window|).
+
+When set to 0 the error window will not be opened or closed automatically. >
+    let g:syntastic_auto_loc_list = 0
+<
+When set to 1 the error window will be automatically opened when errors are
+detected, and closed when none are detected. >
+    let g:syntastic_auto_loc_list = 1
+<
+When set to 2 the error window will be automatically closed when no errors are
+detected, but not opened automatically. >
+    let g:syntastic_auto_loc_list = 2
+<
+                                                 *'syntastic_loc_list_height'*
+Default: 10
+Use this option to specify the height of the location lists that syntastic
+opens. >
+    let g:syntastic_loc_list_height = 5
+<
+                                                    *'syntastic_ignore_files'*
+Default: []
+Use this option to specify files that syntastic should never check.  It's a
+list of |regular-expression| patterns.  The full paths of files (see |::p|) are
+matched against these patterns, and the matches are case sensitive. Use |\c|
+to specify case insensitive patterns.  Example: >
+    let g:syntastic_ignore_files = ['\m^/usr/include/', '\m\c\.h$']
+<
+                                                    *'syntastic_filetype_map'*
+Default: {}
+Use this option to map non-standard filetypes to standard ones.  Corresponding
+checkers are mapped accordingly, which allows syntastic to check files with
+non-standard filetypes: >
+    let g:syntastic_filetype_map = { 'latex': 'tex',
+                                   \ 'gentoo-metadata': 'xml' }
+<
+Composite filetypes can also be mapped to simple types, which disables the
+default behaviour of running both checkers against the input file: >
+    let g:syntastic_filetype_map = { 'handlebars.html': 'handlebars' }
+<
+                                                        *'syntastic_mode_map'*
+Default: { "mode": "active",
+           "active_filetypes": [],
+           "passive_filetypes": [] }
+
+Use this option to fine tune when automatic syntax checking is done (or not
+done).
+
+The option should be set to something like: >
+
+    let g:syntastic_mode_map = { 'mode': 'active',
+                               \ 'active_filetypes': ['ruby', 'php'],
+                               \ 'passive_filetypes': ['puppet'] }
+<
+"mode" can be mapped to one of two values - "active" or "passive". When set to
+active, syntastic does automatic checking whenever a buffer is saved or
+initially opened.  When set to "passive" syntastic only checks when the user
+calls |:SyntasticCheck|.
+
+The exceptions to these rules are defined with "active_filetypes" and
+"passive_filetypes". In passive mode, automatic checks are still done
+for all filetypes in the "active_filetypes" array. In active mode,
+automatic checks are not done for any filetypes in the
+"passive_filetypes" array.
+
+At runtime, the |:SyntasticToggleMode| command can be used to switch between
+active and passive mode.
+
+If any of "mode", "active_filetypes", or "passive_filetypes" are not specified
+then they will default to their default value as above.
+
+                                                  *'syntastic_quiet_messages'*
+Default: {}
+
+Use this option to filter out some of the messages produced by checkers.  The
+option should be set to something like: >
+    let g:syntastic_quiet_messages = { "level": "warnings",
+                                     \ "type":  "style",
+                                     \ "regex": '\m\[C03\d\d\]',
+                                     \ "file":  ['\m^/usr/include/', '\m\c\.h$'] }
+<
+Each element turns off messages matching the patterns specified by the
+corresponding value. Values are lists, but if a list consist of a single
+element you can omit adding the brackets (e.g. you can write "style" instead
+of ["style"]). Elements with values [] or '' are ignored (this is useful for
+overriding filters, cf. |filter-overrides|).
+
+    "level" - takes one of two values, "warnings" or "errors"
+    "type"  - can be either "syntax" or "style"
+    "regex" - is matched against the messages' text as a case insensitive
+              |regular-expression|
+    "file"  - is matched against the filename the error refers to, as a case
+              sensitive |regular-expression|.
+
+If |'syntastic_id_checkers'| is set, filters are applied before error messages
+are labeled with the names of the checkers that created them.
+
+There are also checker-specific variants of this option, providing finer
+control. They are named |'syntastic_<filetype>_<checker>_quiet_messages'|.
+
+For a particular checker, if both a |'syntastic_quiet_messages'| filter and
+a checker-specific filter are present, they are both applied (to the list of
+errors produced by the said checker). In case of conflicting values for the
+same keys, the values of the checker-specific filters take precedence.
+
+                                                            *filter-overrides*
+Since filter elements with values [] or '' are ignored, you can disable global
+filters for particular checkers, by setting the values of the corresponding
+elements in |'syntastic_<filetype>_<checker>_quiet_messages'| to [] or ''. For
+example, the following setting will silence all warnings, except for the
+ones produced by 'pylint': >
+    let g:syntastic_quiet_messages = { "level": "warnings" }
+    let g:syntastic_python_pylint_quiet_messages = { "level" : [] }
+<
+                                                      *'syntastic_stl_format'*
+Default: [Syntax: line:%F (%t)]
+Use this option to control what the syntastic statusline text contains. Several
+magic flags are available to insert information:
+    %e - number of errors
+    %w - number of warnings
+    %t - total number of warnings and errors
+    %fe - line number of first error
+    %fw - line number of first warning
+    %F - line number of first warning or error
+
+Several additional flags are available to hide text under certain conditions:
+    %E{...} - hide the text in the brackets unless there are errors
+    %W{...} - hide the text in the brackets unless there are warnings
+    %B{...} - hide the text in the brackets unless there are both warnings AND
+              errors
+These flags can't be nested.
+
+Example: >
+    let g:syntastic_stl_format = '[%E{Err: %fe #%e}%B{, }%W{Warn: %fw #%w}]'
+<
+If this format is used and the current buffer has 5 errors and 1 warning
+starting on lines 20 and 10 respectively then this would appear on the
+statusline: >
+    [Err: 20 #5, Warn: 10 #1]
+<
+If the buffer had 2 warnings, starting on line 5 then this would appear: >
+    [Warn: 5 #2]
+<
+                                                    *'syntastic_full_redraws'*
+Default: 0 in GUI Vim and MacVim, 1 otherwise
+Controls whether syntastic calls |:redraw| or |:redraw!| for screen redraws.
+Changing it can in principle make screen redraws smoother, but it can also
+cause screen to flicker, or cause ghost characters. Leaving it to the default
+should be safe.
+
+                                                           *'syntastic_debug'*
+Default: 0
+Set this to the sum of one or more of the following flags to enable
+debugging:
+
+     1 - trace checker calls
+     2 - dump location lists
+     4 - trace notifiers
+     8 - trace autocommands
+    16 - dump options
+
+Example: >
+    let g:syntastic_debug = 1
+<
+Syntastic will then add debugging messages to Vim's |message-history|. You can
+examine these messages with |:mes|.
+
+                                                      *'syntastic_debug_file'*
+Default: unset
+When set, debugging messages are written to the file named by its value, in
+addition to being added to Vim's |message-history|: >
+    let g:syntastic_debug_file = '~/syntastic.log'
+<
+                                                 *'syntastic_extra_filetypes'*
+Default: []
+List of filetypes handled by checkers external to syntastic.  If you have a Vim
+plugin that adds a checker for syntastic, and if the said checker deals with a
+filetype that is unknown to syntastic, you might consider adding that filetype
+to this list: >
+    let g:syntastic_extra_filetypes = [ 'make', 'gitcommit' ]
+<
+This will allow |:SyntasticInfo| to do proper tab completion for the new
+filetypes.
+
+==============================================================================
+5. Checker Options                                 *syntastic-checker-options*
+
+------------------------------------------------------------------------------
+5.1 Choosing which checkers to use               *syntastic-filetype-checkers*
+
+                                           *'g:syntastic_<filetype>_checkers'*
+You can tell syntastic which checkers to run for a given filetype by setting a
+variable 'g:syntastic_<filetype>_checkers' to a list of checkers, e.g. >
+    let g:syntastic_php_checkers = ['php', 'phpcs', 'phpmd']
+<
+                                                      *'b:syntastic_checkers'*
+There is also a per-buffer version of this setting, 'b:syntastic_checkers'.
+When set, it takes precedence over |'g:syntastic_<filetype>_checkers'|.  You can
+use this in an autocmd to configure specific checkers for particular paths: >
+    autocmd FileType python if stridx(expand('%:p'), '/some/path/') == 0 |
+        \ let b:syntastic_checkers = ['pylint'] | endif
+<
+If neither |'g:syntastic_<filetype>_checkers'| nor |'b:syntastic_checkers'|
+is set, a default list of checker is used. Beware however that this list
+deliberately kept minimal, for performance reasons.
+
+Take a look at the wiki to find out what checkers and filetypes are supported
+by syntastic:
+
+    https://github.com/scrooloose/syntastic/wiki/Syntax-Checkers
+
+Use |:SyntasticInfo| to see which checkers are available for a given filetype.
+
+------------------------------------------------------------------------------
+5.2 Choosing the executable                            *syntastic-config-exec*
+
+                                    *'syntastic_<filetype>_<subchecker>_exec'*
+The executable used by a checker is normally defined automatically, when the
+checkers is registered. You can however override it by setting the variable
+'g:syntastic_<filetype>_<subchecker>_exec': >
+    let g:syntastic_ruby_mri_exec = '~/bin/ruby2'
+<
+------------------------------------------------------------------------------
+5.3 Configuring specific checkers                   *syntastic-config-makeprg*
+
+Most checkers use the 'makeprgBuild()' function and provide many options by
+default - in fact you can customise every part of the command that gets called.
+
+                                *'syntastic_<filetype>_<subchecker>_<option>'*
+Checkers that use 'makeprgBuild()' construct a 'makeprg' like this: >
+    let makeprg = self.makeprgBuild({
+                \ 'exe': self.getExec(),
+                \ 'args': '-a -b -c',
+                \ 'post_args': '--more --args',
+                \ 'tail': '> /tmp/output' })
+<
+The result is a 'makeprg' of the form: >
+    <exe> <args> <filename> <post_args> <tail>
+<
+                                     *'syntastic_<filetype>_<subchecker>_exe'*
+All arguments above are optional, and can be overridden by setting global
+variables 'g:syntastic_<filetype>_<checker-name>_<option-name>' - even
+parameters not specified in the call to makeprgBuild(). These variables also
+have local versions 'b:syntastic_<filetype>_<checker-name>_<option-name>',
+which take precedence over the global ones in the corresponding buffers.
+
+The 'exe' is normally the same as the 'exec' attribute described above, in
+which case it may be omitted. However, you can use it to add environment
+variables or additional parameters, e.g. to tell the mri checker to use KANJI
+encoding you could do something like this: >
+    let g:syntastic_ruby_mri_exe = 'RUBYOPT="-Ke" ruby'
+<
+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 'makeprgBuild()' function you will have to
+look at the source code of the checker in question. If there are specific
+options that can be set, these are usually documented in the wiki:
+
+    https://github.com/scrooloose/syntastic/wiki/Syntax-Checkers
+
+                             *'syntastic_<filetype>_<checker>_quiet_messages'*
+In the same vein, 'g:syntastic_<filetype>_<checker-name>_quiet_messages' can
+be used to restrict message filters to messages produced by specific checkers.
+Example: >
+    let g:syntastic_python_pylama_quiet_messages = { "type":  "style",
+                                                   \ "regex": '\m\[C03\d\d\]' }
+<
+See |syntastic_quiet_messages| for the syntax.
+
+==============================================================================
+6. Notes                                                     *syntastic-notes*
+
+------------------------------------------------------------------------------
+6.1. Handling of composite filetypes                     *syntastic-composite*
+
+Some Vim plugins use composite filetypes, such as 'django.python' or
+'handlebars.html'. Normally, syntastic deals with this situation by splitting
+the filetype in its simple components, and calling all checkers that apply.
+If this behaviour is not desirable, you can disable it by mapping the
+composite filetypes to a simple ones using |syntastic_filetype_map|, e.g.: >
+    let g:syntastic_filetype_map = { 'handlebars.html': 'handlebars' }
+<
+------------------------------------------------------------------------------
+6.2 Interaction with python-mode                            *syntastic-pymode*
+
+Syntastic can be used along with the 'python-mode' Vim plugin (see
+https://github.com/klen/python-mode). However, they both run syntax checks by
+default when you save buffers to disk, and this is probably not what you want.
+To avoid both plugins opening error windows, you can either set passive mode
+for python in syntastic (see |syntastic_mode_map|), or disable lint checks in
+python-mode, by setting |pymode_lint_write| to 0. E.g.: >
+    let g:pymode_lint_write = 0
+<
+------------------------------------------------------------------------------
+6.3 Interaction with the fish shell                           *syntastic-fish*
+
+At the time of this writing the 'fish' shell (see http://fishshell.com/)
+doesn't support the standard UNIX syntax for file redirections, and thus it
+can't be used together with syntastic. You don't need to change your login
+shell to address this problem, but you do have to point Vim's 'shell' to a more
+traditional shell, such as 'zsh', 'bash', 'ksh', or even the original Bourne
+'sh': >
+    set shell=bash
+<
+------------------------------------------------------------------------------
+6.4. Using syntastic with the fizsh shell                    *syntastic-fizsh*
+
+Using syntastic with the 'fizsh' shell (see https://github.com/zsh-users/fizsh)
+is possible, but potentially problematic. In order to do it you'll need to set
+'shellredir' like this: >
+    set shellredir=>%s\ 2>&1
+<
+Please keep in mind however that Vim can't take advantage of any of the
+interactive features of 'fizsh'. Using a more traditional shell such as 'zsh',
+'bash', 'ksh', or the original Bourne 'sh' might be a better choice: >
+    set shell=zsh
+<
+==============================================================================
+7. About                                                     *syntastic-about*
+
+The core maintainers of syntastic are:
+    Martin Grenfell (github: scrooloose)
+    Gregor Uhlenheuer (github: kongo2002)
+    LCD 047 (github: lcd047)
+
+Find the latest version of syntastic at:
+
+    http://github.com/scrooloose/syntastic
+
+==============================================================================
+8. License                                                 *syntastic-license*
+
+Syntastic is released under the wtfpl.
+See http://sam.zoy.org/wtfpl/COPYING.
+
+ vim:tw=78:sw=4:ft=help:norl:

sources_non_forked/syntactic/plugin/syntastic.vim

@@ -0,0 +1,553 @@
+"============================================================================
+"File:        syntastic.vim
+"Description: Vim plugin for on the fly syntax checking.
+"License:     This program is free software. It comes without any warranty,
+"             to the extent permitted by applicable law. You can redistribute
+"             it and/or modify it under the terms of the Do What The Fuck You
+"             Want To Public License, Version 2, as published by Sam Hocevar.
+"             See http://sam.zoy.org/wtfpl/COPYING for more details.
+"
+"============================================================================
+
+if exists("g:loaded_syntastic_plugin")
+    finish
+endif
+let g:loaded_syntastic_plugin = 1
+
+if has('reltime')
+    let g:syntastic_start = reltime()
+endif
+
+let g:syntastic_version = '3.4.0'
+
+" Sanity checks {{{1
+
+for s:feature in ['autocmd', 'eval', 'modify_fname', 'quickfix', 'user_commands']
+    if !has(s:feature)
+        call syntastic#log#error("need Vim compiled with feature " . s:feature)
+        finish
+    endif
+endfor
+
+let s:running_windows = syntastic#util#isRunningWindows()
+if !s:running_windows && executable('uname')
+    try
+        let s:uname = system('uname')
+    catch /\m^Vim\%((\a\+)\)\=:E484/
+        call syntastic#log#error("your shell " . &shell . " doesn't use traditional UNIX syntax for redirections")
+        finish
+    endtry
+endif
+
+" }}}1
+
+" Defaults {{{1
+
+let g:syntastic_defaults = {
+        \ 'aggregate_errors':         0,
+        \ 'always_populate_loc_list': 0,
+        \ 'auto_jump':                0,
+        \ 'auto_loc_list':            2,
+        \ 'bash_hack':                1,
+        \ 'check_on_open':            0,
+        \ 'check_on_wq':              1,
+        \ 'debug':                    0,
+        \ 'echo_current_error':       1,
+        \ 'enable_balloons':          1,
+        \ 'enable_highlighting':      1,
+        \ 'enable_signs':             1,
+        \ 'error_symbol':             '>>',
+        \ 'filetype_map':             {},
+        \ 'full_redraws':             !(has('gui_running') || has('gui_macvim')),
+        \ 'id_checkers':              1,
+        \ 'ignore_files':             [],
+        \ 'loc_list_height':          10,
+        \ 'quiet_messages':           {},
+        \ 'reuse_loc_lists':          (v:version >= 704),
+        \ 'stl_format':               '[Syntax: line:%F (%t)]',
+        \ 'style_error_symbol':       'S>',
+        \ 'style_warning_symbol':     'S>',
+        \ 'warning_symbol':           '>>'
+    \ }
+
+for s:key in keys(g:syntastic_defaults)
+    if !exists('g:syntastic_' . s:key)
+        let g:syntastic_{s:key} = g:syntastic_defaults[s:key]
+    endif
+endfor
+
+if exists("g:syntastic_quiet_warnings")
+    call syntastic#log#deprecationWarn("variable g:syntastic_quiet_warnings is deprecated, please use let g:syntastic_quiet_messages = {'level': 'warnings'} instead")
+    if g:syntastic_quiet_warnings
+        let s:quiet_warnings = get(g:syntastic_quiet_messages, 'type', [])
+        if type(s:quiet_warnings) != type([])
+            let s:quiet_warnings = [s:quiet_warnings]
+        endif
+        call add(s:quiet_warnings, 'warnings')
+        let g:syntastic_quiet_messages['type'] = s:quiet_warnings
+    endif
+endif
+
+" }}}1
+
+" Debug {{{1
+
+let s:debug_dump_options = [
+        \ 'shell',
+        \ 'shellcmdflag',
+        \ 'shellpipe',
+        \ 'shellquote',
+        \ 'shellredir',
+        \ 'shellslash',
+        \ 'shelltemp',
+        \ 'shellxquote'
+    \ ]
+if v:version > 703 || (v:version == 703 && has('patch446'))
+    call add(s:debug_dump_options, 'shellxescape')
+endif
+
+" debug constants
+let g:SyntasticDebugTrace         = 1
+let g:SyntasticDebugLoclist       = 2
+let g:SyntasticDebugNotifications = 4
+let g:SyntasticDebugAutocommands  = 8
+let g:SyntasticDebugVariables     = 16
+
+" }}}1
+
+runtime! plugin/syntastic/*.vim
+
+let s:registry = g:SyntasticRegistry.Instance()
+let s:notifiers = g:SyntasticNotifiers.Instance()
+let s:modemap = g:SyntasticModeMap.Instance()
+
+" Commands {{{1
+
+" @vimlint(EVL103, 1, a:cursorPos)
+" @vimlint(EVL103, 1, a:cmdLine)
+" @vimlint(EVL103, 1, a:argLead)
+function! s:CompleteCheckerName(argLead, cmdLine, cursorPos) " {{{2
+    let checker_names = []
+    for ft in s:resolveFiletypes()
+        call extend(checker_names, keys(s:registry.getCheckersMap(ft)))
+    endfor
+    return join(checker_names, "\n")
+endfunction " }}}2
+" @vimlint(EVL103, 0, a:cursorPos)
+" @vimlint(EVL103, 0, a:cmdLine)
+" @vimlint(EVL103, 0, a:argLead)
+
+
+" @vimlint(EVL103, 1, a:cursorPos)
+" @vimlint(EVL103, 1, a:cmdLine)
+" @vimlint(EVL103, 1, a:argLead)
+function! s:CompleteFiletypes(argLead, cmdLine, cursorPos) " {{{2
+    return join(s:registry.getKnownFiletypes(), "\n")
+endfunction " }}}2
+" @vimlint(EVL103, 0, a:cursorPos)
+" @vimlint(EVL103, 0, a:cmdLine)
+" @vimlint(EVL103, 0, a:argLead)
+
+command! SyntasticToggleMode call s:ToggleMode()
+command! -nargs=* -complete=custom,s:CompleteCheckerName SyntasticCheck
+            \ call s:UpdateErrors(0, <f-args>) <bar>
+            \ call syntastic#util#redraw(g:syntastic_full_redraws)
+command! Errors call s:ShowLocList()
+command! -nargs=? -complete=custom,s:CompleteFiletypes SyntasticInfo
+            \ call s:modemap.echoMode() |
+            \ call s:registry.echoInfoFor(s:resolveFiletypes(<f-args>))
+command! SyntasticReset
+            \ call s:ClearCache() |
+            \ call s:notifiers.refresh(g:SyntasticLoclist.New([]))
+command! SyntasticSetLoclist call g:SyntasticLoclist.current().setloclist()
+
+" }}}1
+
+" Autocommands and hooks {{{1
+
+augroup syntastic
+    autocmd BufReadPost * call s:BufReadPostHook()
+    autocmd BufWritePost * call s:BufWritePostHook()
+
+    autocmd BufWinEnter * call s:BufWinEnterHook()
+
+    " TODO: the next autocmd should be "autocmd BufWinLeave * if &buftype == '' | 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
+
+function! s:BufReadPostHook() " {{{2
+    if g:syntastic_check_on_open
+        call syntastic#log#debug(g:SyntasticDebugAutocommands,
+            \ 'autocmd: BufReadPost, buffer ' . bufnr("") . ' = ' . string(bufname(str2nr(bufnr("")))))
+        call s:UpdateErrors(1)
+    endif
+endfunction " }}}2
+
+function! s:BufWritePostHook() " {{{2
+    call syntastic#log#debug(g:SyntasticDebugAutocommands,
+        \ 'autocmd: BufWritePost, buffer ' . bufnr("") . ' = ' . string(bufname(str2nr(bufnr("")))))
+    call s:UpdateErrors(1)
+endfunction " }}}2
+
+function! s:BufWinEnterHook() " {{{2
+    call syntastic#log#debug(g:SyntasticDebugAutocommands,
+        \ 'autocmd: BufWinEnter, buffer ' . bufnr("") . ' = ' . string(bufname(str2nr(bufnr("")))) .
+        \ ', &buftype = ' . string(&buftype))
+    if &buftype == ''
+        call s:notifiers.refresh(g:SyntasticLoclist.current())
+    endif
+endfunction " }}}2
+
+function! s:BufEnterHook() " {{{2
+    call syntastic#log#debug(g:SyntasticDebugAutocommands,
+        \ 'autocmd: BufEnter, buffer ' . bufnr("") . ' = ' . string(bufname(str2nr(bufnr("")))) .
+        \ ', &buftype = ' . string(&buftype))
+    " 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 &buftype == 'quickfix' && !empty(loclist) && empty(filter( buffers, 'syntastic#util#bufIsActive(v:val)' ))
+        call g:SyntasticLoclistHide()
+    endif
+endfunction " }}}2
+
+function! s:QuitPreHook() " {{{2
+    call syntastic#log#debug(g:SyntasticDebugAutocommands,
+        \ 'autocmd: QuitPre, buffer ' . bufnr("") . ' = ' . string(bufname(str2nr(bufnr("")))))
+    let b:syntastic_skip_checks = !g:syntastic_check_on_wq
+    call g:SyntasticLoclistHide()
+endfunction " }}}2
+
+" }}}1
+
+" Main {{{1
+
+"refresh and redraw all the error info for this buf when saving or reading
+function! s:UpdateErrors(auto_invoked, ...) " {{{2
+    if s:skipFile()
+        return
+    endif
+
+    call s:modemap.synch()
+    let run_checks = !a:auto_invoked || s:modemap.allowsAutoChecking(&filetype)
+    if run_checks
+        call s:CacheErrors(a:000)
+    endif
+
+    let loclist = g:SyntasticLoclist.current()
+
+    " populate loclist and jump {{{3
+    let do_jump = syntastic#util#var('auto_jump')
+    if do_jump == 2
+        let first = loclist.getFirstIssue()
+        let type = get(first, 'type', '')
+        let do_jump = type ==? 'E'
+    endif
+
+    let w:syntastic_loclist_set = 0
+    if syntastic#util#var('always_populate_loc_list') || do_jump
+        call syntastic#log#debug(g:SyntasticDebugNotifications, 'loclist: setloclist (new)')
+        call setloclist(0, loclist.getRaw())
+        let w:syntastic_loclist_set = 1
+        if run_checks && do_jump && !loclist.isEmpty()
+            call syntastic#log#debug(g:SyntasticDebugNotifications, 'loclist: jump')
+            silent! lrewind
+
+            " XXX: Vim doesn't call autocmd commands in a predictible
+            " order, which can lead to missing filetype when jumping
+            " to a new file; the following is a workaround for the
+            " resulting brain damage
+            if &filetype == ''
+                silent! filetype detect
+            endif
+        endif
+    endif
+    " }}}3
+
+    call s:notifiers.refresh(loclist)
+endfunction " }}}2
+
+"clear the loc list for the buffer
+function! s:ClearCache() " {{{2
+    call s:notifiers.reset(g:SyntasticLoclist.current())
+    unlet! b:syntastic_loclist
+endfunction " }}}2
+
+"detect and cache all syntax errors in this buffer
+function! s:CacheErrors(checker_names) " {{{2
+    call s:ClearCache()
+    let newLoclist = g:SyntasticLoclist.New([])
+
+    if !s:skipFile()
+        " debug logging {{{3
+        call syntastic#log#debugShowVariables(g:SyntasticDebugTrace, 'version')
+        call syntastic#log#debugShowOptions(g:SyntasticDebugTrace, s:debug_dump_options)
+        call syntastic#log#debugDump(g:SyntasticDebugVariables)
+        call syntastic#log#debugShowVariables(g:SyntasticDebugTrace, 'aggregate_errors')
+        call syntastic#log#debug(g:SyntasticDebugTrace, 'getcwd() = ' . getcwd())
+        " }}}3
+
+        let filetypes = s:resolveFiletypes()
+        let aggregate_errors = syntastic#util#var('aggregate_errors')
+        let decorate_errors = (aggregate_errors || len(filetypes) > 1) && syntastic#util#var('id_checkers')
+
+        let clist = []
+        for type in filetypes
+            call extend(clist, s:registry.getCheckers(type, a:checker_names))
+        endfor
+
+        let names = []
+        for checker in clist
+            let cname = checker.getFiletype() . '/' . checker.getName()
+            call syntastic#log#debug(g:SyntasticDebugTrace, 'CacheErrors: Invoking checker: ' . cname)
+
+            let loclist = checker.getLocList()
+
+            if !loclist.isEmpty()
+                if decorate_errors
+                    call loclist.decorate(cname)
+                endif
+                call add(names, cname)
+
+                let newLoclist = newLoclist.extend(loclist)
+
+                if !aggregate_errors
+                    break
+                endif
+            endif
+        endfor
+
+        " set names {{{3
+        if !empty(names)
+            if len(syntastic#util#unique(map( copy(names), 'substitute(v:val, "\\m/.*", "", "")' ))) == 1
+                let type = substitute(names[0], '\m/.*', '', '')
+                let name = join(map( names, 'substitute(v:val, "\\m.\\{-}/", "", "")' ), ', ')
+                call newLoclist.setName( name . ' ('. type . ')' )
+            else
+                " checkers from mixed types
+                call newLoclist.setName(join(names, ', '))
+            endif
+        endif
+        " }}}3
+
+        " issue warning about no active checkers {{{3
+        if empty(clist)
+            if !empty(a:checker_names)
+                if len(a:checker_names) == 1
+                    call syntastic#log#warn('checker ' . a:checker_names[0] . ' is not available')
+                else
+                    call syntastic#log#warn('checkers ' . join(a:checker_names, ', ') . ' are not available')
+                endif
+            else
+                call syntastic#log#debug(g:SyntasticDebugTrace, 'CacheErrors: no checkers available for ' . &filetype)
+            endif
+        endif
+        " }}}3
+
+        call syntastic#log#debug(g:SyntasticDebugLoclist, 'aggregated:', newLoclist)
+    endif
+
+    let b:syntastic_loclist = newLoclist
+endfunction " }}}2
+
+function! s:ToggleMode() " {{{2
+    call s:modemap.toggleMode()
+    call s:ClearCache()
+    call s:UpdateErrors(1)
+    call s:modemap.echoMode()
+endfunction " }}}2
+
+"display the cached errors for this buf in the location list
+function! s:ShowLocList() " {{{2
+    call g:SyntasticLoclist.current().show()
+endfunction " }}}2
+
+"Emulates the :lmake command. Sets up the make environment according to the
+"options given, runs make, resets the environment, returns the location list
+"
+"a:options can contain the following keys:
+"    'makeprg'
+"    'errorformat'
+"
+"The corresponding options are set for the duration of the function call. They
+"are set with :let, so dont escape spaces.
+"
+"a:options may also contain:
+"   'defaults' - a dict containing default values for the returned errors
+"   'subtype' - all errors will be assigned the given subtype
+"   'preprocess' - a function to be applied to the error file before parsing errors
+"   'postprocess' - a list of functions to be applied to the error list
+"   'cwd' - change directory to the given path before running the checker
+"   'returns' - a list of valid exit codes for the checker
+function! SyntasticMake(options) " {{{2
+    call syntastic#log#debug(g:SyntasticDebugTrace, 'SyntasticMake: called with options:', a:options)
+
+    " save options and locale env variables {{{3
+    let old_shell = &shell
+    let old_shellredir = &shellredir
+    let old_local_errorformat = &l:errorformat
+    let old_errorformat = &errorformat
+    let old_cwd = getcwd()
+    let old_lc_messages = $LC_MESSAGES
+    let old_lc_all = $LC_ALL
+    " }}}3
+
+    call s:bashHack()
+
+    if has_key(a:options, 'errorformat')
+        let &errorformat = a:options['errorformat']
+    endif
+
+    if has_key(a:options, 'cwd')
+        execute 'lcd ' . fnameescape(a:options['cwd'])
+    endif
+
+    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 syntastic#log#debug(g:SyntasticDebugLoclist, 'checker output:', err_lines)
+
+    if has_key(a:options, 'Preprocess')
+        let err_lines = call(a:options['Preprocess'], [err_lines])
+        call syntastic#log#debug(g:SyntasticDebugLoclist, 'preprocess (external):', err_lines)
+    elseif has_key(a:options, 'preprocess')
+        let err_lines = call('syntastic#preprocess#' . a:options['preprocess'], [err_lines])
+        call syntastic#log#debug(g:SyntasticDebugLoclist, 'preprocess:', err_lines)
+    endif
+    lgetexpr err_lines
+
+    let errors = deepcopy(getloclist(0))
+
+    if has_key(a:options, 'cwd')
+        execute 'lcd ' . fnameescape(old_cwd)
+    endif
+
+    silent! lolder
+
+    " restore options {{{3
+    let &errorformat = old_errorformat
+    let &l:errorformat = old_local_errorformat
+    let &shellredir = old_shellredir
+    let &shell = old_shell
+    " }}}3
+
+    if !s:running_windows && (s:uname() =~ "FreeBSD" || s:uname() =~ "OpenBSD")
+        call syntastic#util#redraw(g:syntastic_full_redraws)
+    endif
+
+    call syntastic#log#debug(g:SyntasticDebugLoclist, 'raw loclist:', errors)
+
+    if has_key(a:options, 'returns') && index(a:options['returns'], v:shell_error) == -1
+        throw 'Syntastic: checker error'
+    endif
+
+    if has_key(a:options, 'defaults')
+        call s:addToErrors(errors, a:options['defaults'])
+    endif
+
+    " Add subtype info if present.
+    if has_key(a:options, 'subtype')
+        call s:addToErrors(errors, { 'subtype': a:options['subtype'] })
+    endif
+
+    if has_key(a:options, 'Postprocess') && !empty(a:options['Postprocess'])
+        for rule in a:options['Postprocess']
+            let errors = call(rule, [errors])
+        endfor
+        call syntastic#log#debug(g:SyntasticDebugLoclist, 'postprocess (external):', errors)
+    elseif has_key(a:options, 'postprocess') && !empty(a:options['postprocess'])
+        for rule in a:options['postprocess']
+            let errors = call('syntastic#postprocess#' . rule, [errors])
+        endfor
+        call syntastic#log#debug(g:SyntasticDebugLoclist, 'postprocess:', errors)
+    endif
+
+    return errors
+endfunction " }}}2
+
+"return a string representing the state of buffer according to
+"g:syntastic_stl_format
+"
+"return '' if no errors are cached for the buffer
+function! SyntasticStatuslineFlag() " {{{2
+    return g:SyntasticLoclist.current().getStatuslineFlag()
+endfunction " }}}2
+
+" }}}1
+
+" Utilities {{{1
+
+function! s:resolveFiletypes(...) " {{{2
+    let type = a:0 ? a:1 : &filetype
+    return split( get(g:syntastic_filetype_map, type, type), '\m\.' )
+endfunction " }}}2
+
+function! s:ignoreFile(filename) " {{{2
+    let fname = fnamemodify(a:filename, ':p')
+    for pattern in g:syntastic_ignore_files
+        if fname =~# pattern
+            return 1
+        endif
+    endfor
+    return 0
+endfunction " }}}2
+
+" Skip running in special buffers
+function! s:skipFile() " {{{2
+    let force_skip = exists('b:syntastic_skip_checks') ? b:syntastic_skip_checks : 0
+    let fname = expand('%')
+    return force_skip || (&buftype != '') || !filereadable(fname) || getwinvar(0, '&diff') || s:ignoreFile(fname)
+endfunction " }}}2
+
+" Take a list of errors and add default values to them from a:options
+function! s:addToErrors(errors, options) " {{{2
+    for err in a:errors
+        for key in keys(a:options)
+            if !has_key(err, key) || empty(err[key])
+                let err[key] = a:options[key]
+            endif
+        endfor
+    endfor
+
+    return a:errors
+endfunction " }}}2
+
+" The script changes &shellredir and &shell to stop the screen flicking when
+" shelling out to syntax checkers. Not all OSs support the hacks though.
+function! s:bashHack() " {{{2
+    if !exists('s:bash')
+        if !s:running_windows && (s:uname() !~# "FreeBSD") && (s:uname() !~# "OpenBSD")
+            let s:bash =
+                \ executable('/usr/local/bin/bash') ? '/usr/local/bin/bash' :
+                \ executable('/bin/bash') ? '/bin/bash' : ''
+        else
+            let s:bash = ''
+        endif
+    endif
+
+    if g:syntastic_bash_hack && s:bash != ''
+        let &shell = s:bash
+        let &shellredir = '&>'
+    endif
+endfunction " }}}2
+
+function! s:uname() " {{{2
+    if !exists('s:uname')
+        let s:uname = system('uname')
+    endif
+    return s:uname
+endfunction " }}}2
+
+" }}}1
+
+" vim: set sw=4 sts=4 et fdm=marker:

sources_non_forked/syntactic/plugin/syntastic/autoloclist.vim

@@ -0,0 +1,38 @@
+if exists("g:loaded_syntastic_notifier_autoloclist") || !exists("g:loaded_syntastic_plugin")
+    finish
+endif
+let g:loaded_syntastic_notifier_autoloclist = 1
+
+let g:SyntasticAutoloclistNotifier = {}
+
+" Public methods {{{1
+"
+function! g:SyntasticAutoloclistNotifier.New() " {{{2
+    let newObj = copy(self)
+    return newObj
+endfunction " }}}2
+
+function! g:SyntasticAutoloclistNotifier.refresh(loclist) " {{{2
+    call syntastic#log#debug(g:SyntasticDebugNotifications, 'autoloclist: refresh')
+    call g:SyntasticAutoloclistNotifier.AutoToggle(a:loclist)
+endfunction " }}}2
+
+function! g:SyntasticAutoloclistNotifier.AutoToggle(loclist) " {{{2
+    call syntastic#log#debug(g:SyntasticDebugNotifications, 'autoloclist: toggle')
+    if !a:loclist.isEmpty()
+        if syntastic#util#var('auto_loc_list') == 1
+            call a:loclist.show()
+        endif
+    else
+        if syntastic#util#var('auto_loc_list') > 0
+
+            "TODO: this will close the loc list window if one was opened by
+            "something other than syntastic
+            lclose
+        endif
+    endif
+endfunction " }}}2
+
+" }}}1
+
+" vim: set sw=4 sts=4 et fdm=marker:

sources_non_forked/syntactic/plugin/syntastic/balloons.vim

@@ -0,0 +1,66 @@
+if exists("g:loaded_syntastic_notifier_balloons") || !exists("g:loaded_syntastic_plugin")
+    finish
+endif
+let g:loaded_syntastic_notifier_balloons = 1
+
+if !has('balloon_eval')
+    let g:syntastic_enable_balloons = 0
+endif
+
+let g:SyntasticBalloonsNotifier = {}
+
+" Public methods {{{1
+
+function! g:SyntasticBalloonsNotifier.New() " {{{2
+    let newObj = copy(self)
+    return newObj
+endfunction " }}}2
+
+function! g:SyntasticBalloonsNotifier.enabled() " {{{2
+    return has('balloon_eval') && syntastic#util#var('enable_balloons')
+endfunction " }}}2
+
+" Update the error balloons
+function! g:SyntasticBalloonsNotifier.refresh(loclist) " {{{2
+    let b:syntastic_balloons = {}
+    if self.enabled() && !a:loclist.isEmpty()
+        call syntastic#log#debug(g:SyntasticDebugNotifications, 'balloons: refresh')
+        let buf = bufnr('')
+        let issues = filter(a:loclist.copyRaw(), 'v:val["bufnr"] == buf')
+        if !empty(issues)
+            for i in issues
+                if has_key(b:syntastic_balloons, i['lnum'])
+                    let b:syntastic_balloons[i['lnum']] .= "\n" . i['text']
+                else
+                    let b:syntastic_balloons[i['lnum']] = i['text']
+                endif
+            endfor
+            set beval bexpr=SyntasticBalloonsExprNotifier()
+        endif
+    endif
+endfunction " }}}2
+
+" Reset the error balloons
+" @vimlint(EVL103, 1, a:loclist)
+function! g:SyntasticBalloonsNotifier.reset(loclist) " {{{2
+    if has('balloon_eval')
+        call syntastic#log#debug(g:SyntasticDebugNotifications, 'balloons: reset')
+        set nobeval
+    endif
+endfunction " }}}2
+" @vimlint(EVL103, 0, a:loclist)
+
+" }}}1
+
+" Private functions {{{1
+
+function! SyntasticBalloonsExprNotifier() " {{{2
+    if !exists('b:syntastic_balloons')
+        return ''
+    endif
+    return get(b:syntastic_balloons, v:beval_lnum, '')
+endfunction " }}}2
+
+" }}}1
+
+" vim: set sw=4 sts=4 et fdm=marker:

sources_non_forked/syntactic/plugin/syntastic/checker.vim

@@ -0,0 +1,167 @@
+if exists("g:loaded_syntastic_checker") || !exists("g:loaded_syntastic_plugin")
+    finish
+endif
+let g:loaded_syntastic_checker = 1
+
+let g:SyntasticChecker = {}
+
+" Public methods {{{1
+
+function! g:SyntasticChecker.New(args) " {{{2
+    let newObj = copy(self)
+
+    let newObj._filetype = a:args['filetype']
+    let newObj._name = a:args['name']
+    let newObj._exec = get(a:args, 'exec', newObj._name)
+
+    if has_key(a:args, 'redirect')
+        let [filetype, name] = split(a:args['redirect'], '/')
+        let prefix = 'SyntaxCheckers_' . filetype . '_' . name . '_'
+    else
+        let prefix = 'SyntaxCheckers_' . newObj._filetype . '_' . newObj._name . '_'
+    endif
+
+    let newObj._locListFunc = function(prefix . 'GetLocList')
+
+    if exists('*' . prefix . 'IsAvailable')
+        let newObj._isAvailableFunc = function(prefix . 'IsAvailable')
+    else
+        let newObj._isAvailableFunc = function('SyntasticCheckerIsAvailableDefault')
+    endif
+
+    if exists('*' . prefix . 'GetHighlightRegex')
+        let newObj._highlightRegexFunc = function(prefix . 'GetHighlightRegex')
+    endif
+
+    return newObj
+endfunction " }}}2
+
+function! g:SyntasticChecker.getFiletype() " {{{2
+    return self._filetype
+endfunction " }}}2
+
+function! g:SyntasticChecker.getName() " {{{2
+    return self._name
+endfunction " }}}2
+
+function! g:SyntasticChecker.getExec() " {{{2
+    if exists('g:syntastic_' . self._filetype . '_' . self._name . '_exec')
+        return expand(g:syntastic_{self._filetype}_{self._name}_exec)
+    endif
+
+    return self._exec
+endfunction " }}}2
+
+function! g:SyntasticChecker.getExecEscaped() " {{{2
+    return syntastic#util#shescape(self.getExec())
+endfunction " }}}2
+
+function! g:SyntasticChecker.getLocListRaw() " {{{2
+    let name = self._filetype . '/' . self._name
+    try
+        let list = self._locListFunc()
+        call syntastic#log#debug(g:SyntasticDebugTrace, 'getLocList: checker ' . name . ' returned ' . v:shell_error)
+    catch /\m\C^Syntastic: checker error$/
+        let list = []
+        call syntastic#log#error('checker ' . name . ' returned abnormal status ' . v:shell_error)
+    endtry
+    call self._populateHighlightRegexes(list)
+    call syntastic#log#debug(g:SyntasticDebugLoclist, name . ' raw:', list)
+    call self._quietMessages(list)
+    return list
+endfunction " }}}2
+
+function! g:SyntasticChecker.getLocList() " {{{2
+    return g:SyntasticLoclist.New(self.getLocListRaw())
+endfunction " }}}2
+
+function! g:SyntasticChecker.makeprgBuild(opts) " {{{2
+    let basename = self._filetype . '_' . self._name . '_'
+
+    let parts = []
+    call extend(parts, self._getOpt(a:opts, basename, 'exe', self.getExecEscaped()))
+    call extend(parts, self._getOpt(a:opts, basename, 'args', ''))
+    call extend(parts, self._getOpt(a:opts, basename, 'fname', syntastic#util#shexpand('%')))
+    call extend(parts, self._getOpt(a:opts, basename, 'post_args', ''))
+    call extend(parts, self._getOpt(a:opts, basename, 'tail', ''))
+
+    return join(parts)
+endfunction " }}}2
+
+function! g:SyntasticChecker.isAvailable() " {{{2
+    return self._isAvailableFunc()
+endfunction " }}}2
+
+" }}}1
+
+" Private methods {{{1
+
+function! g:SyntasticChecker._quietMessages(errors) " {{{2
+    " wildcard quiet_messages
+    let quiet_filters = copy(syntastic#util#var('quiet_messages', {}))
+    if type(quiet_filters) != type({})
+        call syntastic#log#warn('ignoring invalid syntastic_quiet_messages')
+        unlet quiet_filters
+        let quiet_filters = {}
+    endif
+
+    " per checker quiet_messages
+    let name = self._filetype . '_' . self._name
+    try
+        call extend( quiet_filters, copy(syntastic#util#var(name . '_quiet_messages', {})), 'force' )
+    catch /\m^Vim\%((\a\+)\)\=:E712/
+        call syntastic#log#warn('ignoring invalid syntastic_' . name . '_quiet_messages')
+    endtry
+
+    call syntastic#log#debug(g:SyntasticDebugLoclist, 'quiet_messages filter:', quiet_filters)
+
+    if !empty(quiet_filters)
+        call syntastic#util#dictFilter(a:errors, quiet_filters)
+        call syntastic#log#debug(g:SyntasticDebugLoclist, 'filtered by quiet_messages:', a:errors)
+    endif
+endfunction " }}}2
+
+function! g:SyntasticChecker._populateHighlightRegexes(errors) " {{{2
+    if has_key(self, '_highlightRegexFunc')
+        for e in a:errors
+            if e['valid']
+                let term = self._highlightRegexFunc(e)
+                if len(term) > 0
+                    let e['hl'] = term
+                endif
+            endif
+        endfor
+    endif
+endfunction " }}}2
+
+function! g:SyntasticChecker._getOpt(opts, basename, name, default) " {{{2
+    let user_val = syntastic#util#var(a:basename . a:name)
+    let ret = []
+    call extend( ret, self._shescape(get(a:opts, a:name . '_before', '')) )
+    call extend( ret, self._shescape(user_val != '' ? user_val : get(a:opts, a:name, a:default)) )
+    call extend( ret, self._shescape(get(a:opts, a:name . '_after', '')) )
+
+    return ret
+endfunction " }}}2
+
+function! g:SyntasticChecker._shescape(opt) " {{{2
+    if type(a:opt) == type('') && a:opt != ''
+        return [a:opt]
+    elseif type(a:opt) == type([])
+        return map(copy(a:opt), 'syntastic#util#shescape(v:val)')
+    endif
+
+    return []
+endfunction " }}}2
+
+" }}}1
+
+" Non-method functions {{{1
+
+function! SyntasticCheckerIsAvailableDefault() dict " {{{2
+    return executable(self.getExec())
+endfunction " }}}2
+
+" }}}1
+
+" vim: set sw=4 sts=4 et fdm=marker:

sources_non_forked/syntactic/plugin/syntastic/cursor.vim

@@ -0,0 +1,67 @@
+if exists("g:loaded_syntastic_notifier_cursor") || !exists("g:loaded_syntastic_plugin")
+    finish
+endif
+let g:loaded_syntastic_notifier_cursor = 1
+
+let g:SyntasticCursorNotifier = {}
+
+" Public methods {{{1
+
+function! g:SyntasticCursorNotifier.New() " {{{2
+    let newObj = copy(self)
+    return newObj
+endfunction " }}}2
+
+function! g:SyntasticCursorNotifier.enabled() " {{{2
+    return syntastic#util#var('echo_current_error')
+endfunction " }}}2
+
+function! g:SyntasticCursorNotifier.refresh(loclist) " {{{2
+    if self.enabled() && !a:loclist.isEmpty()
+        call syntastic#log#debug(g:SyntasticDebugNotifications, 'cursor: refresh')
+        let b:syntastic_messages = copy(a:loclist.messages(bufnr('')))
+        let b:oldLine = -1
+        autocmd! syntastic CursorMoved
+        autocmd syntastic CursorMoved * call g:SyntasticRefreshCursor()
+    endif
+endfunction " }}}2
+
+" @vimlint(EVL103, 1, a:loclist)
+function! g:SyntasticCursorNotifier.reset(loclist) " {{{2
+    call syntastic#log#debug(g:SyntasticDebugNotifications, 'cursor: reset')
+    autocmd! syntastic CursorMoved
+    unlet! b:syntastic_messages
+    let b:oldLine = -1
+endfunction " }}}2
+" @vimlint(EVL103, 0, a:loclist)
+
+" }}}1
+
+" Private methods {{{1
+
+" The following defensive nonsense is needed because of the nature of autocmd
+function! g:SyntasticRefreshCursor() " {{{2
+    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 " }}}2
+
+" }}}1
+
+" vim: set sw=4 sts=4 et fdm=marker:

sources_non_forked/syntactic/plugin/syntastic/highlighting.vim

@@ -0,0 +1,93 @@
+if exists("g:loaded_syntastic_notifier_highlighting") || !exists("g:loaded_syntastic_plugin")
+    finish
+endif
+let g:loaded_syntastic_notifier_highlighting = 1
+
+" Highlighting requires getmatches introduced in 7.1.040
+let s:has_highlighting = v:version > 701 || (v:version == 701 && has('patch040'))
+
+let g:SyntasticHighlightingNotifier = {}
+
+let s:setup_done = 0
+
+" Public methods {{{1
+
+function! g:SyntasticHighlightingNotifier.New() " {{{2
+    let newObj = copy(self)
+
+    if !s:setup_done
+        call self._setup()
+        let s:setup_done = 1
+    endif
+
+    return newObj
+endfunction " }}}2
+
+function! g:SyntasticHighlightingNotifier.enabled() " {{{2
+    return s:has_highlighting && syntastic#util#var('enable_highlighting')
+endfunction " }}}2
+
+" Sets error highlights in the cuirrent window
+function! g:SyntasticHighlightingNotifier.refresh(loclist) " {{{2
+    if self.enabled()
+        call self.reset(a:loclist)
+        call syntastic#log#debug(g:SyntasticDebugNotifications, 'highlighting: refresh')
+        let buf = bufnr('')
+        let issues = filter(a:loclist.copyRaw(), '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', 0)
+                if get(item, 'vcol', 0)
+                    let lastcol = virtcol([item['lnum'], '$'])
+                    let coltype = 'v'
+                else
+                    let lastcol = col([item['lnum'], '$'])
+                    let coltype = 'c'
+                endif
+                let lcol = min([lastcol, item['col']])
+
+                call matchadd(group, '\%' . item['lnum'] . 'l\%' . lcol . coltype)
+            endif
+        endfor
+    endif
+endfunction " }}}2
+
+" Remove all error highlights from the window
+" @vimlint(EVL103, 1, a:loclist)
+function! g:SyntasticHighlightingNotifier.reset(loclist) " {{{2
+    if s:has_highlighting
+        call syntastic#log#debug(g:SyntasticDebugNotifications, 'highlighting: reset')
+        for match in getmatches()
+            if stridx(match['group'], 'Syntastic') == 0
+                call matchdelete(match['id'])
+            endif
+        endfor
+    endif
+endfunction " }}}2
+" @vimlint(EVL103, 0, a:loclist)
+
+" }}}1
+
+" Private methods {{{1
+
+" One time setup: define our own highlighting
+function! g:SyntasticHighlightingNotifier._setup() " {{{2
+    if s:has_highlighting
+        if !hlexists('SyntasticError')
+            highlight link SyntasticError SpellBad
+
+        endif
+        if !hlexists('SyntasticWarning')
+            highlight link SyntasticWarning SpellCap
+        endif
+    endif
+endfunction " }}}2
+
+" }}}1
+
+" vim: set sw=4 sts=4 et fdm=marker:

sources_non_forked/syntactic/plugin/syntastic/loclist.vim

@@ -0,0 +1,240 @@
+if exists("g:loaded_syntastic_loclist") || !exists("g:loaded_syntastic_plugin")
+    finish
+endif
+let g:loaded_syntastic_loclist = 1
+
+let g:SyntasticLoclist = {}
+
+" Public methods {{{1
+
+function! g:SyntasticLoclist.New(rawLoclist) " {{{2
+    let newObj = copy(self)
+
+    let llist = filter(copy(a:rawLoclist), 'v:val["valid"] == 1')
+
+    for e in llist
+        if get(e, 'type', '') == ''
+            let e['type'] = 'E'
+        endif
+    endfor
+
+    let newObj._rawLoclist = llist
+    let newObj._name = ''
+
+    return newObj
+endfunction " }}}2
+
+function! g:SyntasticLoclist.current() " {{{2
+    if !exists("b:syntastic_loclist")
+        let b:syntastic_loclist = g:SyntasticLoclist.New([])
+    endif
+    return b:syntastic_loclist
+endfunction " }}}2
+
+function! g:SyntasticLoclist.extend(other) " {{{2
+    let list = self.copyRaw()
+    call extend(list, a:other.copyRaw())
+    return g:SyntasticLoclist.New(list)
+endfunction " }}}2
+
+function! g:SyntasticLoclist.isEmpty() " {{{2
+    return empty(self._rawLoclist)
+endfunction " }}}2
+
+function! g:SyntasticLoclist.copyRaw() " {{{2
+    return copy(self._rawLoclist)
+endfunction " }}}2
+
+function! g:SyntasticLoclist.getRaw() " {{{2
+    return self._rawLoclist
+endfunction " }}}2
+
+function! g:SyntasticLoclist.getStatuslineFlag() " {{{2
+    if !exists("self._stl_format")
+        let self._stl_format = ''
+    endif
+    if !exists("self._stl_flag")
+        let self._stl_flag = ''
+    endif
+
+    if g:syntastic_stl_format !=# self._stl_format
+        let self._stl_format = g:syntastic_stl_format
+
+        if !empty(self._rawLoclist)
+            let errors = self.errors()
+            let warnings = self.warnings()
+
+            let num_errors = len(errors)
+            let num_warnings = len(warnings)
+            let num_issues = len(self._rawLoclist)
+
+            let output = self._stl_format
+
+            "hide stuff wrapped in %E(...) unless there are errors
+            let output = substitute(output, '\m\C%E{\([^}]*\)}', num_errors ? '\1' : '' , 'g')
+
+            "hide stuff wrapped in %W(...) unless there are warnings
+            let output = substitute(output, '\m\C%W{\([^}]*\)}', num_warnings ? '\1' : '' , 'g')
+
+            "hide stuff wrapped in %B(...) unless there are both errors and warnings
+            let output = substitute(output, '\m\C%B{\([^}]*\)}', (num_warnings && num_errors) ? '\1' : '' , 'g')
+
+            "sub in the total errors/warnings/both
+            let output = substitute(output, '\m\C%w', num_warnings, 'g')
+            let output = substitute(output, '\m\C%e', num_errors, 'g')
+            let output = substitute(output, '\m\C%t', num_issues, 'g')
+
+            "first error/warning line num
+            let output = substitute(output, '\m\C%F', num_issues ? self._rawLoclist[0]['lnum'] : '', 'g')
+
+            "first error line num
+            let output = substitute(output, '\m\C%fe', num_errors ? errors[0]['lnum'] : '', 'g')
+
+            "first warning line num
+            let output = substitute(output, '\m\C%fw', num_warnings ? warnings[0]['lnum'] : '', 'g')
+
+            let self._stl_flag = output
+        else
+            let self._stl_flag = ''
+        endif
+    endif
+
+    return self._stl_flag
+endfunction " }}}2
+
+function! g:SyntasticLoclist.getFirstIssue() " {{{2
+    return get(self._rawLoclist, 0, {})
+endfunction " }}}2
+
+function! g:SyntasticLoclist.getName() " {{{2
+    return len(self._name)
+endfunction " }}}2
+
+function! g:SyntasticLoclist.setName(name) " {{{2
+    let self._name = a:name
+endfunction " }}}2
+
+function! g:SyntasticLoclist.decorate(tag) " {{{2
+    for e in self._rawLoclist
+        let e['text'] .= ' [' . a:tag . ']'
+    endfor
+endfunction " }}}2
+
+function! g:SyntasticLoclist.errors() " {{{2
+    if !exists("self._cachedErrors")
+        let self._cachedErrors = self.filter({'type': "E"})
+    endif
+    return self._cachedErrors
+endfunction " }}}2
+
+function! g:SyntasticLoclist.warnings() " {{{2
+    if !exists("self._cachedWarnings")
+        let self._cachedWarnings = self.filter({'type': "W"})
+    endif
+    return self._cachedWarnings
+endfunction " }}}2
+
+" Legacy function.  Syntastic no longer calls it, but we keep it
+" around because other plugins (f.i. powerline) depend on it.
+function! g:SyntasticLoclist.hasErrorsOrWarningsToDisplay() " {{{2
+    return !self.isEmpty()
+endfunction " }}}2
+
+" cache used by EchoCurrentError()
+function! g:SyntasticLoclist.messages(buf) " {{{2
+    if !exists("self._cachedMessages")
+        let self._cachedMessages = {}
+        let errors = self.errors() + self.warnings()
+
+        for e in errors
+            let b = e['bufnr']
+            let l = e['lnum']
+
+            if !has_key(self._cachedMessages, b)
+                let self._cachedMessages[b] = {}
+            endif
+
+            if !has_key(self._cachedMessages[b], l)
+                let self._cachedMessages[b][l] = e['text']
+            endif
+        endfor
+    endif
+
+    return get(self._cachedMessages, a:buf, {})
+endfunction " }}}2
+
+"Filter the list and return new native loclist
+"e.g.
+"  .filter({'bufnr': 10, 'type': 'e'})
+"
+"would return all errors for buffer 10.
+"
+"Note that all comparisons are done with ==?
+function! g:SyntasticLoclist.filter(filters) " {{{2
+    let conditions = values(map(copy(a:filters), 's:translate(v:key, v:val)'))
+    let filter = len(conditions) == 1 ?
+        \ conditions[0] : join(map(conditions, '"(" . v:val . ")"'), ' && ')
+    return filter(copy(self._rawLoclist), filter)
+endfunction " }}}2
+
+function! g:SyntasticLoclist.setloclist() " {{{2
+    if !exists('w:syntastic_loclist_set')
+        let w:syntastic_loclist_set = 0
+    endif
+    let replace = g:syntastic_reuse_loc_lists && w:syntastic_loclist_set
+    call syntastic#log#debug(g:SyntasticDebugNotifications, 'loclist: setloclist ' . (replace ? '(replace)' : '(new)'))
+    call setloclist(0, self.getRaw(), replace ? 'r' : ' ')
+    let w:syntastic_loclist_set = 1
+endfunction " }}}2
+
+"display the cached errors for this buf in the location list
+function! g:SyntasticLoclist.show() " {{{2
+    call syntastic#log#debug(g:SyntasticDebugNotifications, 'loclist: show')
+    call self.setloclist()
+
+    if !self.isEmpty()
+        let num = winnr()
+        execute "lopen " . syntastic#util#var('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 " }}}2
+
+" }}}1
+
+" Non-method functions {{{1
+
+function! g:SyntasticLoclistHide() " {{{2
+    call syntastic#log#debug(g:SyntasticDebugNotifications, 'loclist: hide')
+    silent! lclose
+endfunction " }}}2
+
+" }}}1
+
+" Private functions {{{1
+
+function! s:translate(key, val) " {{{2
+    return 'get(v:val, ' . string(a:key) . ', "") ==? ' . string(a:val)
+endfunction " }}}2
+
+" }}}1
+
+" vim: set sw=4 sts=4 et fdm=marker:

sources_non_forked/syntactic/plugin/syntastic/modemap.vim

@@ -0,0 +1,79 @@
+if exists("g:loaded_syntastic_modemap") || !exists("g:loaded_syntastic_plugin")
+    finish
+endif
+let g:loaded_syntastic_modemap = 1
+
+let g:SyntasticModeMap = {}
+
+" Public methods {{{1
+
+function! g:SyntasticModeMap.Instance() " {{{2
+    if !exists('s:SyntasticModeMapInstance')
+        let s:SyntasticModeMapInstance = copy(self)
+        call s:SyntasticModeMapInstance.synch()
+    endif
+
+    return s:SyntasticModeMapInstance
+endfunction " }}}2
+
+function! g:SyntasticModeMap.synch() " {{{2
+    if exists('g:syntastic_mode_map')
+        let self._mode = get(g:syntastic_mode_map, 'mode', 'active')
+        let self._activeFiletypes = get(g:syntastic_mode_map, 'active_filetypes', [])
+        let self._passiveFiletypes = get(g:syntastic_mode_map, 'passive_filetypes', [])
+    else
+        let self._mode = 'active'
+        let self._activeFiletypes = []
+        let self._passiveFiletypes = []
+    endif
+endfunction " }}}2
+
+function! g:SyntasticModeMap.allowsAutoChecking(filetype) " {{{2
+    let fts = split(a:filetype, '\m\.')
+
+    if self.isPassive()
+        return self._isOneFiletypeActive(fts)
+    else
+        return self._noFiletypesArePassive(fts)
+    endif
+endfunction " }}}2
+
+function! g:SyntasticModeMap.isPassive() " {{{2
+    return self._mode ==# 'passive'
+endfunction " }}}2
+
+function! g:SyntasticModeMap.toggleMode() " {{{2
+    call self.synch()
+
+    if self._mode ==# 'active'
+        let self._mode = 'passive'
+    else
+        let self._mode = 'active'
+    endif
+
+    "XXX Changing a global variable.  Tsk, tsk...
+    if !exists('g:syntastic_mode_map')
+        let g:syntastic_mode_map = {}
+    endif
+    let g:syntastic_mode_map['mode'] = self._mode
+endfunction " }}}2
+
+function! g:SyntasticModeMap.echoMode() " {{{2
+    echo "Syntastic: " . self._mode . " mode enabled"
+endfunction " }}}2
+
+" }}}1
+
+" Private methods {{{1
+
+function! g:SyntasticModeMap._isOneFiletypeActive(filetypes) " {{{2
+    return !empty(filter(copy(a:filetypes), 'index(self._activeFiletypes, v:val) != -1'))
+endfunction " }}}2
+
+function! g:SyntasticModeMap._noFiletypesArePassive(filetypes) " {{{2
+    return empty(filter(copy(a:filetypes), 'index(self._passiveFiletypes, v:val) != -1'))
+endfunction " }}}2
+
+" }}}1
+
+" vim: set sw=4 sts=4 et fdm=marker:

sources_non_forked/syntactic/plugin/syntastic/notifiers.vim

@@ -0,0 +1,61 @@
+if exists("g:loaded_syntastic_notifiers") || !exists("g:loaded_syntastic_plugin")
+    finish
+endif
+let g:loaded_syntastic_notifiers = 1
+
+let g:SyntasticNotifiers = {}
+
+let s:notifier_types = ['signs', 'balloons', 'highlighting', 'cursor', 'autoloclist']
+
+" Public methods {{{1
+
+function! g:SyntasticNotifiers.Instance() " {{{2
+    if !exists('s:SyntasticNotifiersInstance')
+        let s:SyntasticNotifiersInstance = copy(self)
+        call s:SyntasticNotifiersInstance._initNotifiers()
+    endif
+
+    return s:SyntasticNotifiersInstance
+endfunction " }}}2
+
+function! g:SyntasticNotifiers.refresh(loclist) " {{{2
+    call syntastic#log#debug(g:SyntasticDebugNotifications, 'notifiers: refresh')
+    for type in self._enabled_types
+        let class = substitute(type, '\m.*', 'Syntastic\u&Notifier', '')
+        if !has_key(g:{class}, 'enabled') || self._notifier[type].enabled()
+            call self._notifier[type].refresh(a:loclist)
+        endif
+    endfor
+endfunction " }}}2
+
+function! g:SyntasticNotifiers.reset(loclist) " {{{2
+    call syntastic#log#debug(g:SyntasticDebugNotifications, 'notifiers: reset')
+    for type in self._enabled_types
+        let class = substitute(type, '\m.*', 'Syntastic\u&Notifier', '')
+
+        " reset notifiers regardless if they are enabled or not, since
+        " the user might have disabled them since the last refresh();
+        " notifiers MUST be prepared to deal with reset() when disabled
+        if has_key(g:{class}, 'reset')
+            call self._notifier[type].reset(a:loclist)
+        endif
+    endfor
+endfunction " }}}2
+
+" }}}1
+
+" Private methods {{{1
+
+function! g:SyntasticNotifiers._initNotifiers() " {{{2
+    let self._notifier = {}
+    for type in s:notifier_types
+        let class = substitute(type, '\m.*', 'Syntastic\u&Notifier', '')
+        let self._notifier[type] = g:{class}.New()
+    endfor
+
+    let self._enabled_types = copy(s:notifier_types)
+endfunction " }}}2
+
+" }}}1
+
+" vim: set sw=4 sts=4 et fdm=marker:

sources_non_forked/syntactic/plugin/syntastic/registry.vim

@@ -0,0 +1,263 @@
+if exists("g:loaded_syntastic_registry") || !exists("g:loaded_syntastic_plugin")
+    finish
+endif
+let g:loaded_syntastic_registry = 1
+
+" Initialisation {{{1
+
+let s:defaultCheckers = {
+        \ 'actionscript':['mxmlc'],
+        \ 'ada':         ['gcc'],
+        \ 'applescript': ['osacompile'],
+        \ 'asciidoc':    ['asciidoc'],
+        \ 'asm':         ['gcc'],
+        \ 'bemhtml':     ['bemhtmllint'],
+        \ 'c':           ['gcc'],
+        \ 'chef':        ['foodcritic'],
+        \ 'co':          ['coco'],
+        \ 'cobol':       ['cobc'],
+        \ 'coffee':      ['coffee', 'coffeelint'],
+        \ 'coq':         ['coqtop'],
+        \ 'cpp':         ['gcc'],
+        \ 'cs':          ['mcs'],
+        \ 'css':         ['csslint'],
+        \ 'cucumber':    ['cucumber'],
+        \ 'cuda':        ['nvcc'],
+        \ 'd':           ['dmd'],
+        \ 'dart':        ['dartanalyzer'],
+        \ 'docbk':       ['xmllint'],
+        \ 'dustjs':      ['swiffer'],
+        \ 'elixir':      ['elixir'],
+        \ 'erlang':      ['escript'],
+        \ 'eruby':       ['ruby'],
+        \ 'fortran':     ['gfortran'],
+        \ 'glsl':        ['cgc'],
+        \ 'go':          ['go'],
+        \ 'haml':        ['haml'],
+        \ 'handlebars':  ['handlebars'],
+        \ 'haskell':     ['ghc_mod', 'hdevtools', 'hlint'],
+        \ 'haxe':        ['haxe'],
+        \ 'hss':         ['hss'],
+        \ 'html':        ['tidy'],
+        \ 'java':        ['javac'],
+        \ 'javascript':  ['jshint', 'jslint'],
+        \ 'json':        ['jsonlint', 'jsonval'],
+        \ 'less':        ['lessc'],
+        \ 'lex':         ['flex'],
+        \ 'limbo':       ['limbo'],
+        \ 'lisp':        ['clisp'],
+        \ 'llvm':        ['llvm'],
+        \ 'lua':         ['luac'],
+        \ 'matlab':      ['mlint'],
+        \ 'nasm':        ['nasm'],
+        \ 'nroff':       ['mandoc'],
+        \ 'objc':        ['gcc'],
+        \ 'objcpp':      ['gcc'],
+        \ 'ocaml':       ['camlp4o'],
+        \ 'perl':        ['perlcritic'],
+        \ 'php':         ['php', 'phpcs', 'phpmd'],
+        \ 'po':          ['msgfmt'],
+        \ 'pod':         ['podchecker'],
+        \ 'puppet':      ['puppet', 'puppetlint'],
+        \ 'python':      ['python', 'flake8', 'pylint'],
+        \ 'racket':      ['racket'],
+        \ 'rst':         ['rst2pseudoxml'],
+        \ 'ruby':        ['mri'],
+        \ 'rust':        ['rustc'],
+        \ 'sass':        ['sass'],
+        \ 'scala':       ['fsc', 'scalac'],
+        \ 'scss':        ['sass', 'scss_lint'],
+        \ 'sh':          ['sh', 'shellcheck'],
+        \ 'slim':        ['slimrb'],
+        \ 'tcl':         ['nagelfar'],
+        \ 'tex':         ['lacheck', 'chktex'],
+        \ 'texinfo':     ['makeinfo'],
+        \ 'text':        ['atdtool'],
+        \ 'twig':        ['twiglint'],
+        \ 'typescript':  ['tsc'],
+        \ 'vala':        ['valac'],
+        \ 'verilog':     ['verilator'],
+        \ 'vhdl':        ['ghdl'],
+        \ 'vim':         ['vimlint'],
+        \ 'xhtml':       ['tidy'],
+        \ 'xml':         ['xmllint'],
+        \ 'xslt':        ['xmllint'],
+        \ 'yacc':        ['bison'],
+        \ 'yaml':        ['jsyaml'],
+        \ 'z80':         ['z80syntaxchecker'],
+        \ 'zpt':         ['zptlint'],
+        \ 'zsh':         ['zsh', 'shellcheck']
+    \ }
+
+let s:defaultFiletypeMap = {
+        \ 'gentoo-metadata': 'xml',
+        \ 'lhaskell': 'haskell',
+        \ 'litcoffee': 'coffee'
+    \ }
+
+let g:SyntasticRegistry = {}
+
+" }}}1
+
+" Public methods {{{1
+
+" 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.
+
+function! g:SyntasticRegistry.Instance() " {{{2
+    if !exists('s:SyntasticRegistryInstance')
+        let s:SyntasticRegistryInstance = copy(self)
+        let s:SyntasticRegistryInstance._checkerRaw = {}
+        let s:SyntasticRegistryInstance._checkerMap = {}
+    endif
+
+    return s:SyntasticRegistryInstance
+endfunction " }}}2
+
+function! g:SyntasticRegistry.CreateAndRegisterChecker(args) " {{{2
+    let checker = g:SyntasticChecker.New(a:args)
+    let registry = g:SyntasticRegistry.Instance()
+    call registry._registerChecker(checker)
+endfunction " }}}2
+
+function! g:SyntasticRegistry.isCheckable(ftalias) " {{{2
+    let ft = s:normaliseFiletype(a:ftalias)
+    call self._loadCheckers(ft)
+    return !empty(self._checkerMap[ft])
+endfunction " }}}2
+
+function! g:SyntasticRegistry.getCheckersMap(ftalias) " {{{2
+    let ft = s:normaliseFiletype(a:ftalias)
+    call self._loadCheckers(ft)
+    return self._checkerMap[ft]
+endfunction " }}}2
+
+function! g:SyntasticRegistry.getCheckers(ftalias, list) " {{{2
+    let checkers_map = self.getCheckersMap(a:ftalias)
+    if empty(checkers_map)
+        return []
+    endif
+
+    let ft = s:normaliseFiletype(a:ftalias)
+    call self._checkDeprecation(ft)
+
+    let names =
+        \ !empty(a:list) ? a:list :
+        \ exists('b:syntastic_checkers') ? b:syntastic_checkers :
+        \ exists('g:syntastic_' . ft . '_checkers') ? g:syntastic_{ft}_checkers :
+        \ get(s:defaultCheckers, ft, 0)
+
+    return type(names) == type([]) ?
+        \ self._filterCheckersByName(checkers_map, names) : [checkers_map[keys(checkers_map)[0]]]
+endfunction " }}}2
+
+function! g:SyntasticRegistry.getKnownFiletypes() " {{{2
+    let types = keys(s:defaultCheckers)
+
+    call extend(types, keys(s:defaultFiletypeMap))
+
+    if exists('g:syntastic_filetype_map')
+        call extend(types, keys(g:syntastic_filetype_map))
+    endif
+
+    if exists('g:syntastic_extra_filetypes') && type(g:syntastic_extra_filetypes) == type([])
+        call extend(types, g:syntastic_extra_filetypes)
+    endif
+
+    return syntastic#util#unique(types)
+endfunction " }}}2
+
+function! g:SyntasticRegistry.echoInfoFor(ftalias_list) " {{{2
+    echomsg "Syntastic info for filetype: " . join(a:ftalias_list, '.')
+
+    let ft_list = syntastic#util#unique(map( copy(a:ftalias_list), 's:normaliseFiletype(v:val)' ))
+    if len(ft_list) != 1
+        let available = []
+        let active = []
+
+        for ft in ft_list
+            call extend(available, map( keys(self.getCheckersMap(ft)), 'ft . "/" . v:val' ))
+            call extend(active, map( self.getCheckers(ft, []), 'ft . "/" . v:val.getName()' ))
+        endfor
+    else
+        let ft = ft_list[0]
+        let available = keys(self.getCheckersMap(ft))
+        let active = map(self.getCheckers(ft, []), 'v:val.getName()')
+    endif
+
+    echomsg "Available checker(s): " . join(sort(available))
+    echomsg "Currently enabled checker(s): " . join(active)
+endfunction " }}}2
+
+" }}}1
+
+" Private methods {{{1
+
+function! g:SyntasticRegistry._registerChecker(checker) abort " {{{2
+    let ft = a:checker.getFiletype()
+
+    if !has_key(self._checkerRaw, ft)
+        let self._checkerRaw[ft] = []
+        let self._checkerMap[ft] = {}
+    endif
+
+    call self._validateUniqueName(a:checker)
+
+    let name = a:checker.getName()
+    call add(self._checkerRaw[ft], name)
+
+    if a:checker.isAvailable()
+        let self._checkerMap[ft][name] = a:checker
+    endif
+endfunction " }}}2
+
+function! g:SyntasticRegistry._filterCheckersByName(checkers_map, list) " {{{2
+    return filter( map(copy(a:list), 'get(a:checkers_map, v:val, {})'), '!empty(v:val)' )
+endfunction " }}}2
+
+function! g:SyntasticRegistry._loadCheckers(filetype) " {{{2
+    if has_key(self._checkerRaw, a:filetype)
+        return
+    endif
+
+    execute "runtime! syntax_checkers/" . a:filetype . "/*.vim"
+
+    if !has_key(self._checkerRaw, a:filetype)
+        let self._checkerRaw[a:filetype] = []
+        let self._checkerMap[a:filetype] = {}
+    endif
+endfunction " }}}2
+
+function! g:SyntasticRegistry._validateUniqueName(checker) abort " {{{2
+    let ft = a:checker.getFiletype()
+    let name = a:checker.getName()
+    if index(self._checkerRaw[ft], name) > -1
+        throw 'Syntastic: Duplicate syntax checker name: ' . ft . '/' . name
+    endif
+endfunction " }}}2
+
+" Check for obsolete variable g:syntastic_<filetype>_checker
+function! g:SyntasticRegistry._checkDeprecation(filetype) " {{{2
+    if exists('g:syntastic_' . a:filetype . '_checker') && !exists('g:syntastic_' . a:filetype . '_checkers')
+        let g:syntastic_{a:filetype}_checkers = [g:syntastic_{a:filetype}_checker]
+        call syntastic#log#deprecationWarn('variable g:syntastic_' . a:filetype . '_checker is deprecated')
+    endif
+endfunction " }}}2
+
+" }}}1
+
+" Private functions {{{1
+
+"resolve filetype aliases, and replace - with _ otherwise we cant name
+"syntax checker functions legally for filetypes like "gentoo-metadata"
+function! s:normaliseFiletype(ftalias) " {{{2
+    let ft = get(s:defaultFiletypeMap, a:ftalias, a:ftalias)
+    let ft = get(g:syntastic_filetype_map, ft, ft)
+    let ft = substitute(ft, '\m-', '_', 'g')
+    return ft
+endfunction " }}}2
+
+" }}}1
+
+" vim: set sw=4 sts=4 et fdm=marker:

sources_non_forked/syntactic/plugin/syntastic/signs.vim

@@ -0,0 +1,133 @@
+if exists("g:loaded_syntastic_notifier_signs") || !exists("g:loaded_syntastic_plugin")
+    finish
+endif
+let g:loaded_syntastic_notifier_signs = 1
+
+" Initialisation {{{1
+
+" start counting sign ids at 5000, start here to hopefully avoid conflicting
+" with any other code that places signs (not sure if this precaution is
+" actually needed)
+let s:first_sign_id = 5000
+let s:next_sign_id = s:first_sign_id
+
+let g:SyntasticSignsNotifier = {}
+
+let s:setup_done = 0
+
+" }}}1
+
+" Public methods {{{1
+
+function! g:SyntasticSignsNotifier.New() " {{{2
+    let newObj = copy(self)
+
+    if !s:setup_done
+        call self._setup()
+        let s:setup_done = 1
+    endif
+
+    return newObj
+endfunction " }}}2
+
+function! g:SyntasticSignsNotifier.enabled() " {{{2
+    return has('signs') && syntastic#util#var('enable_signs')
+endfunction " }}}2
+
+function! g:SyntasticSignsNotifier.refresh(loclist) " {{{2
+    call syntastic#log#debug(g:SyntasticDebugNotifications, 'signs: refresh')
+    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 " }}}2
+
+" }}}1
+
+" Private methods {{{1
+
+" One time setup: define our own sign types and highlighting
+function! g:SyntasticSignsNotifier._setup() " {{{2
+    if has('signs')
+        if !hlexists('SyntasticErrorSign')
+            highlight link SyntasticErrorSign error
+        endif
+        if !hlexists('SyntasticWarningSign')
+            highlight link SyntasticWarningSign todo
+        endif
+        if !hlexists('SyntasticStyleErrorSign')
+            highlight link SyntasticStyleErrorSign SyntasticErrorSign
+        endif
+        if !hlexists('SyntasticStyleWarningSign')
+            highlight link SyntasticStyleWarningSign SyntasticWarningSign
+        endif
+        if !hlexists('SyntasticStyleErrorLine')
+            highlight link SyntasticStyleErrorLine SyntasticErrorLine
+        endif
+        if !hlexists('SyntasticStyleWarningLine')
+            highlight link SyntasticStyleWarningLine SyntasticWarningLine
+        endif
+
+        " define the signs used to display syntax and style errors/warns
+        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 " }}}2
+
+" Place signs by all syntax errors in the buffer
+function! g:SyntasticSignsNotifier._signErrors(loclist) " {{{2
+    let loclist = a:loclist
+    if !loclist.isEmpty()
+
+        " errors some first, so that they are not masked by warnings
+        let buf = bufnr('')
+        let issues = copy(loclist.errors())
+        call extend(issues, loclist.warnings())
+        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
+
+                execute "sign place " . s:next_sign_id . " line=" . i['lnum'] . " name=" . sign_type . " buffer=" . i['bufnr']
+                call add(self._bufSignIds(), s:next_sign_id)
+                let s:next_sign_id += 1
+            endif
+        endfor
+    endif
+endfunction " }}}2
+
+" Remove the signs with the given ids from this buffer
+function! g:SyntasticSignsNotifier._removeSigns(ids) " {{{2
+    if has('signs')
+        for i in a:ids
+            execute "sign unplace " . i
+            call remove(self._bufSignIds(), index(self._bufSignIds(), i))
+        endfor
+    endif
+endfunction " }}}2
+
+" Get all the ids of the SyntaxError signs in the buffer
+function! g:SyntasticSignsNotifier._bufSignIds() " {{{2
+    if !exists("b:syntastic_sign_ids")
+        let b:syntastic_sign_ids = []
+    endif
+    return b:syntastic_sign_ids
+endfunction " }}}2
+
+" }}}1
+
+" vim: set sw=4 sts=4 et fdm=marker:

sources_non_forked/syntactic/syntax_checkers/actionscript/mxmlc.vim

@@ -0,0 +1,71 @@
+"============================================================================
+"File:        mxmlc.vim
+"Description: ActionScript syntax checker - using mxmlc
+"Maintainer:  Andy Earnshaw <andyearnshaw@gmail.com>
+"License:     This program is free software. It comes without any warranty,
+"             to the extent permitted by applicable law. You can redistribute
+"             it and/or modify it under the terms of the Do What The Fuck You
+"             Want To Public License, Version 2, as published by Sam Hocevar.
+"             See http://sam.zoy.org/wtfpl/COPYING for more details.
+"============================================================================
+
+if exists('g:loaded_syntastic_actionscript_mxmlc_checker')
+    finish
+endif
+let g:loaded_syntastic_actionscript_mxmlc_checker = 1
+
+if !exists('g:syntastic_actionscript_mxmlc_conf')
+    let g:syntastic_actionscript_mxmlc_conf = ''
+endif
+
+let s:save_cpo = &cpo
+set cpo&vim
+
+function! SyntaxCheckers_actionscript_mxmlc_GetHighlightRegex(item)
+    let term = ''
+
+    if match(a:item['text'], '\mvariable ''') > -1
+        let term = matchstr(a:item['text'], '\m''\zs[^'']\+\ze''')
+
+    elseif match(a:item['text'], 'expected a definition keyword') > -1
+        let term = matchstr(a:item['text'], '\mnot \zs[^.]\+\ze\.')
+
+    elseif match(a:item['text'], '\mundefined \%(property\|method\)') > -1
+        let term = matchstr(a:item['text'], '\mundefined \%(property\|method\) \zs[^. ]\+\ze')
+
+    elseif match(a:item['text'], 'could not be found') > -1
+        let term = matchstr(a:item['text'], '\m \zs\S\+\ze could not be found')
+
+    elseif match(a:item['text'], 'Type was not found') > -1
+        let term = matchstr(a:item['text'], '\m: \zs[^.]\+\zs\.')
+
+    endif
+
+    return term != '' ? '\V\<' . escape(term, '\') . '\>' : ''
+endfunction
+
+function! SyntaxCheckers_actionscript_mxmlc_GetLocList() dict
+    let makeprg = self.makeprgBuild({
+        \ 'args_before': (g:syntastic_actionscript_mxmlc_conf != '' ?
+        \   ' -load-config+=' . g:syntastic_actionscript_mxmlc_conf : ''),
+        \ 'args_after': '-output=' . syntastic#util#DevNull() })
+
+    let errorformat =
+        \ '%f(%l): col: %c %trror: %m,' .
+        \ '%f(%l): col: %c %tarning: %m,' .
+        \ '%f: %trror: %m,' .
+        \ '%-G%.%#'
+
+    return SyntasticMake({
+        \ 'makeprg': makeprg,
+        \ 'errorformat': errorformat })
+endfunction
+
+call g:SyntasticRegistry.CreateAndRegisterChecker({
+    \ 'filetype': 'actionscript',
+    \ 'name': 'mxmlc'})
+
+let &cpo = s:save_cpo
+unlet s:save_cpo
+
+" vim: set et sts=4 sw=4:

sources_non_forked/syntactic/syntax_checkers/ada/gcc.vim

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

sources_non_forked/syntactic/syntax_checkers/applescript/osacompile.vim

@@ -0,0 +1,49 @@
+"==============================================================================
+"       FileName: applescript.vim
+"           Desc: Syntax checking plugin for syntastic.vim
+"         Author: Zhao Cai
+"          Email: caizhaoff@gmail.com
+"        Version: 0.2.1
+"   Date Created: Thu 09 Sep 2011 10:30:09 AM EST
+"  Last Modified: Fri 09 Dec 2011 01:10:24 PM EST
+"
+"        History: 0.1.0 - working, but it will run the script everytime to check
+"                 syntax. Should use osacompile but strangely it does not give
+"                 errors.
+"
+"                 0.2.0 - switch to osacompile, it gives less errors compared
+"                 with osascript.
+"
+"                 0.2.1 - remove g:syntastic_applescript_tempfile. use
+"                 tempname() instead.
+"
+"        License: This program is free software. It comes without any
+"        warranty, to the extent permitted by applicable law. You can
+"        redistribute it and/or modify it under the terms of the Do What The
+"        Fuck You Want To Public License, Version 2, as published by Sam
+"        Hocevar.  See http://sam.zoy.org/wtfpl/COPYING for more details.
+"
+"============================================================================
+
+if exists("g:loaded_syntastic_applescript_osacompile_checker")
+    finish
+endif
+let g:loaded_syntastic_applescript_osacompile_checker = 1
+
+let s:save_cpo = &cpo
+set cpo&vim
+
+function! SyntaxCheckers_applescript_osacompile_GetLocList() dict
+    let makeprg = self.makeprgBuild({ 'args_after': '-o ' . tempname() . '.scpt' })
+    let errorformat = '%f:%l:%m'
+    return SyntasticMake({ 'makeprg': makeprg, 'errorformat': errorformat })
+endfunction
+
+call g:SyntasticRegistry.CreateAndRegisterChecker({
+    \ 'filetype': 'applescript',
+    \ 'name': 'osacompile' })
+
+let &cpo = s:save_cpo
+unlet s:save_cpo
+
+" vim: set et sts=4 sw=4:

sources_non_forked/syntactic/syntax_checkers/asciidoc/asciidoc.vim

@@ -0,0 +1,47 @@
+"============================================================================
+"File:        asciidoc.vim
+"Description: Syntax checking plugin for syntastic.vim
+"Maintainer:  LCD 47 <lcd047 at gmail dot com>
+"License:     This program is free software. It comes without any warranty,
+"             to the extent permitted by applicable law. You can redistribute
+"             it and/or modify it under the terms of the Do What The Fuck You
+"             Want To Public License, Version 2, as published by Sam Hocevar.
+"             See http://sam.zoy.org/wtfpl/COPYING for more details.
+"
+"============================================================================
+
+if exists("g:loaded_syntastic_asciidoc_asciidoc_checker")
+    finish
+endif
+let g:loaded_syntastic_asciidoc_asciidoc_checker = 1
+
+let s:save_cpo = &cpo
+set cpo&vim
+
+function! SyntaxCheckers_asciidoc_asciidoc_GetLocList() dict
+    let makeprg = self.makeprgBuild({ 'args_after': syntastic#c#NullOutput() })
+
+    let errorformat =
+        \ '%Easciidoc: %tRROR: %f: line %l: %m,' .
+        \ '%Easciidoc: %tRROR: %f: %m,' .
+        \ '%Easciidoc: FAILED: %f: line %l: %m,' .
+        \ '%Easciidoc: FAILED: %f: %m,' .
+        \ '%Wasciidoc: %tARNING: %f: line %l: %m,' .
+        \ '%Wasciidoc: %tARNING: %f: %m,' .
+        \ '%Wasciidoc: DEPRECATED: %f: line %l: %m,' .
+        \ '%Wasciidoc: DEPRECATED: %f: %m'
+
+    return SyntasticMake({
+        \ 'makeprg': makeprg,
+        \ 'errorformat': errorformat,
+        \ 'returns': [0, 1] })
+endfunction
+
+call g:SyntasticRegistry.CreateAndRegisterChecker({
+    \ 'filetype': 'asciidoc',
+    \ 'name': 'asciidoc'})
+
+let &cpo = s:save_cpo
+unlet s:save_cpo
+
+" vim: set et sts=4 sw=4:

sources_non_forked/syntactic/syntax_checkers/asm/gcc.vim

@@ -0,0 +1,54 @@
+"============================================================================
+"File:        gcc.vim
+"Description: Syntax checking for at&t and intel assembly files with gcc
+"Maintainer:  Josh Rahm <joshuarahm@gmail.com>
+"License:     This program is free software. It comes without any warranty,
+"             to the extent permitted by applicable law. You can redistribute
+"             it and/or modify it under the terms of the Do What The Fuck You
+"             Want To Public License, Version 2, as published by Sam Hocevar.
+"             See http://sam.zoy.org/wtfpl/COPYING for more details.
+"
+"============================================================================
+
+if exists('g:loaded_syntastic_asm_gcc_checker')
+    finish
+endif
+let g:loaded_syntastic_asm_gcc_checker = 1
+
+if !exists('g:syntastic_asm_compiler_options')
+    let g:syntastic_asm_compiler_options = ''
+endif
+
+let s:save_cpo = &cpo
+set cpo&vim
+
+function! SyntaxCheckers_asm_gcc_IsAvailable() dict
+    if !exists('g:syntastic_asm_compiler')
+        let g:syntastic_asm_compiler = self.getExec()
+    endif
+    return executable(expand(g:syntastic_asm_compiler))
+endfunction
+
+function! SyntaxCheckers_asm_gcc_GetLocList() dict
+    return syntastic#c#GetLocList('asm', 'gcc', {
+        \ 'errorformat':
+        \     '%-G%f:%s:,' .
+        \     '%f:%l:%c: %trror: %m,' .
+        \     '%f:%l:%c: %tarning: %m,' .
+        \     '%f:%l: %m',
+        \ 'main_flags': '-x assembler -fsyntax-only -masm=' . s:GetDialect() })
+endfunction
+
+function! s:GetDialect()
+    return exists('g:syntastic_asm_dialect') ? g:syntastic_asm_dialect :
+        \ expand('%:e') ==? 'asm' ? 'intel' : 'att'
+endfunction
+
+call g:SyntasticRegistry.CreateAndRegisterChecker({
+    \ 'filetype': 'asm',
+    \ 'name': 'gcc' })
+
+let &cpo = s:save_cpo
+unlet s:save_cpo
+
+" vim: set et sts=4 sw=4:

sources_non_forked/syntactic/syntax_checkers/bemhtml/bemhtmllint.vim

@@ -0,0 +1,34 @@
+"============================================================================
+"File:        bemhtmllint.vim
+"Description: Syntax checking plugin for syntastic.vim
+"Maintainer:  Sergej Tatarincev <s.tatarincev at yandex.ua>
+"License:     This program is free software. It comes without any warranty,
+"             to the extent permitted by applicable law. You can redistribute
+"             it and/or modify it under the terms of the Do What The Fuck You
+"             Want To Public License, Version 2, as published by Sam Hocevar.
+"             See http://sam.zoy.org/wtfpl/COPYING for more details.
+"============================================================================
+"
+if exists("g:loaded_syntastic_bemhtml_bemhtmllint_checker")
+    finish
+endif
+
+let g:loaded_syntastic_bemhtml_bemhtmllint_checker = 1
+
+let s:save_cpo = &cpo
+set cpo&vim
+
+function SyntaxCheckers_bemhtml_bemhtmllint_GetLocList() dict
+    let makeprg = self.makeprgBuild({})
+    let errorformat = '%f:%l:%c: %m'
+    return SyntasticMake({ 'makeprg': makeprg, 'errorformat': errorformat })
+endfunction
+
+call g:SyntasticRegistry.CreateAndRegisterChecker({
+    \ 'filetype': 'bemhtml',
+    \ 'name': 'bemhtmllint',
+    \ 'exec': 'bemhtml-lint' })
+
+
+let &cpo = s:save_cpo
+unlet s:save_cpo

sources_non_forked/syntactic/syntax_checkers/c/avrgcc.vim

@@ -0,0 +1,55 @@
+"============================================================================
+"File:        avrgcc.vim
+"Description: Syntax checking plugin for syntastic.vim
+"Maintainer:  Karel <karelishere at gmail dot com>
+"License:     This program is free software. It comes without any warranty,
+"             to the extent permitted by applicable law. You can redistribute
+"             it and/or modify it under the terms of the Do What The Fuck You
+"             Want To Public License, Version 2, as published by Sam Hocevar.
+"             See http://sam.zoy.org/wtfpl/COPYING for more details.
+"
+"============================================================================
+
+if exists('g:loaded_syntastic_c_avrgcc_checker')
+    finish
+endif
+let g:loaded_syntastic_c_avrgcc_checker = 1
+
+if !exists('g:syntastic_avrgcc_config_file')
+    let g:syntastic_avrgcc_config_file = '.syntastic_avrgcc_config'
+endif
+
+let s:save_cpo = &cpo
+set cpo&vim
+
+function! SyntaxCheckers_c_avrgcc_GetLocList() dict
+    let makeprg = self.makeprgBuild({
+        \ 'args_before': syntastic#c#ReadConfig(g:syntastic_avrgcc_config_file),
+        \ 'args_after': '-x c -fsyntax-only' })
+
+    let errorformat =
+        \ '%-G%f:%s:,' .
+        \ '%-G%f:%l: %#error: %#(Each undeclared identifier is reported only%.%#,' .
+        \ '%-G%f:%l: %#error: %#for each function it appears%.%#,' .
+        \ '%-GIn file included%.%#,' .
+        \ '%-G %#from %f:%l\,,' .
+        \ '%f:%l:%c: %trror: %m,' .
+        \ '%f:%l:%c: %tarning: %m,' .
+        \ '%f:%l:%c: %m,' .
+        \ '%f:%l: %trror: %m,' .
+        \ '%f:%l: %tarning: %m,'.
+        \ '%f:%l: %m'
+
+    return SyntasticMake({
+        \ 'makeprg': makeprg,
+        \ 'errorformat': errorformat,
+        \ 'postprocess': ['compressWhitespace'] })
+endfunction
+
+call g:SyntasticRegistry.CreateAndRegisterChecker({
+    \ 'filetype': 'c',
+    \ 'name': 'avrgcc',
+    \ 'exec': 'avr-gcc'})
+
+let &cpo = s:save_cpo
+unlet s:save_cpo

sources_non_forked/syntactic/syntax_checkers/c/checkpatch.vim

@@ -0,0 +1,55 @@
+"============================================================================
+"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
+
+let s:save_cpo = &cpo
+set cpo&vim
+
+function! SyntaxCheckers_c_checkpatch_IsAvailable() dict
+    return exists("g:syntastic_c_checker_checkpatch_location")
+endfunction
+
+function! SyntaxCheckers_c_checkpatch_GetLocList() dict
+    let makeprg = self.makeprgBuild({
+        \ 'exe': g:syntastic_c_checker_checkpatch_location,
+        \ 'args_after': '--no-summary --no-tree --terse --file' })
+
+    let errorformat =
+        \ '%f:%l: %tARNING: %m,' .
+        \ '%f:%l: %tRROR: %m'
+
+    return SyntasticMake({
+        \ 'makeprg': makeprg,
+        \ 'errorformat': errorformat,
+        \ 'returns': [0, 1],
+        \ 'subtype': 'Style' })
+endfunction
+
+call g:SyntasticRegistry.CreateAndRegisterChecker({
+    \ 'filetype': 'c',
+    \ 'name': 'checkpatch',
+    \ 'exec': 'checkpatch.pl'})
+
+let &cpo = s:save_cpo
+unlet s:save_cpo
+
+" vim: set et sts=4 sw=4:

sources_non_forked/syntactic/syntax_checkers/c/cppcheck.vim

@@ -0,0 +1,69 @@
+"============================================================================
+"File:        cppcheck.vim
+"Description: Syntax checking plugin for syntastic.vim using cppcheck.pl
+"Maintainer:  LCD 47 <lcd047 at gmail dot com>
+"License:     This program is free software. It comes without any warranty,
+"             to the extent permitted by applicable law. You can redistribute
+"             it and/or modify it under the terms of the Do What The Fuck You
+"             Want To Public License, Version 2, as published by Sam Hocevar.
+"             See http://sam.zoy.org/wtfpl/COPYING for more details.
+"============================================================================
+"
+" The setting 'g:syntastic_cppcheck_config_file' allows you to define a file
+" that contains additional compiler arguments like include directories or
+" CFLAGS. The file is expected to contain one option per line. If none is
+" given the filename defaults to '.syntastic_cppcheck_config':
+"
+"   let g:syntastic_cppcheck_config_file = '.config'
+
+if exists("g:loaded_syntastic_c_cppcheck_checker")
+    finish
+endif
+let g:loaded_syntastic_c_cppcheck_checker = 1
+
+if !exists('g:syntastic_cppcheck_config_file')
+    let g:syntastic_cppcheck_config_file = '.syntastic_cppcheck_config'
+endif
+
+let s:save_cpo = &cpo
+set cpo&vim
+
+function! SyntaxCheckers_c_cppcheck_GetLocList() dict
+    let makeprg = self.makeprgBuild({
+        \ 'args': syntastic#c#ReadConfig(g:syntastic_cppcheck_config_file),
+        \ 'args_after': '-q --enable=style' })
+
+    let errorformat =
+        \ '[%f:%l]: (%trror) %m,' .
+        \ '[%f:%l]: (%tarning) %m,' .
+        \ '[%f:%l]: (%ttyle) %m,' .
+        \ '[%f:%l]: (%terformance) %m,' .
+        \ '[%f:%l]: (%tortability) %m,' .
+        \ '[%f:%l]: (%tnformation) %m,' .
+        \ '[%f:%l]: (%tnconclusive) %m,' .
+        \ '%-G%.%#'
+
+    let loclist = SyntasticMake({
+        \ 'makeprg': makeprg,
+        \ 'errorformat': errorformat,
+        \ 'preprocess': 'cppcheck',
+        \ 'returns': [0] })
+
+    for e in loclist
+        if e['type'] =~? '\m^[SPI]'
+            let e['type'] = 'w'
+            let e['subtype'] = 'Style'
+        endif
+    endfor
+
+    return loclist
+endfunction
+
+call g:SyntasticRegistry.CreateAndRegisterChecker({
+    \ 'filetype': 'c',
+    \ 'name': 'cppcheck'})
+
+let &cpo = s:save_cpo
+unlet s:save_cpo
+
+" vim: set et sts=4 sw=4:

sources_non_forked/syntactic/syntax_checkers/c/gcc.vim

@@ -0,0 +1,58 @@
+"============================================================================
+"File:        c.vim
+"Description: Syntax checking plugin for syntastic.vim
+"Maintainer:  Gregor Uhlenheuer <kongo2002 at gmail dot com>
+"License:     This program is free software. It comes without any warranty,
+"             to the extent permitted by applicable law. You can redistribute
+"             it and/or modify it under the terms of the Do What The Fuck You
+"             Want To Public License, Version 2, as published by Sam Hocevar.
+"             See http://sam.zoy.org/wtfpl/COPYING for more details.
+"
+"============================================================================
+
+if exists('g:loaded_syntastic_c_gcc_checker')
+    finish
+endif
+let g:loaded_syntastic_c_gcc_checker = 1
+
+if !exists('g:syntastic_c_compiler_options')
+    let g:syntastic_c_compiler_options = '-std=gnu99'
+endif
+
+let s:save_cpo = &cpo
+set cpo&vim
+
+function! SyntaxCheckers_c_gcc_IsAvailable() dict
+    if !exists('g:syntastic_c_compiler')
+        let g:syntastic_c_compiler = executable(self.getExec()) ? self.getExec() : 'clang'
+    endif
+    return executable(expand(g:syntastic_c_compiler))
+endfunction
+
+function! SyntaxCheckers_c_gcc_GetLocList() dict
+    return syntastic#c#GetLocList('c', 'gcc', {
+        \ 'errorformat':
+        \     '%-G%f:%s:,' .
+        \     '%-G%f:%l: %#error: %#(Each undeclared identifier is reported only%.%#,' .
+        \     '%-G%f:%l: %#error: %#for each function it appears%.%#,' .
+        \     '%-GIn file included%.%#,' .
+        \     '%-G %#from %f:%l\,,' .
+        \     '%f:%l:%c: %trror: %m,' .
+        \     '%f:%l:%c: %tarning: %m,' .
+        \     '%f:%l:%c: %m,' .
+        \     '%f:%l: %trror: %m,' .
+        \     '%f:%l: %tarning: %m,'.
+        \     '%f:%l: %m',
+        \ 'main_flags': '-x c -fsyntax-only',
+        \ 'header_flags': '-x c',
+        \ 'header_names': '\m\.h$' })
+endfunction
+
+call g:SyntasticRegistry.CreateAndRegisterChecker({
+    \ 'filetype': 'c',
+    \ 'name': 'gcc' })
+
+let &cpo = s:save_cpo
+unlet s:save_cpo
+
+" vim: set et sts=4 sw=4:

sources_non_forked/syntactic/syntax_checkers/c/make.vim

@@ -0,0 +1,61 @@
+"============================================================================
+"File:        make.vim
+"Description: Syntax checking plugin for syntastic.vim
+"Maintainer:  Gregor Uhlenheuer <kongo2002 at gmail dot com>
+"License:     This program is free software. It comes without any warranty,
+"             to the extent permitted by applicable law. You can redistribute
+"             it and/or modify it under the terms of the Do What The Fuck You
+"             Want To Public License, Version 2, as published by Sam Hocevar.
+"             See http://sam.zoy.org/wtfpl/COPYING for more details.
+"
+"============================================================================
+
+if exists('g:loaded_syntastic_c_make_checker')
+    finish
+endif
+let g:loaded_syntastic_c_make_checker = 1
+
+let s:save_cpo = &cpo
+set cpo&vim
+
+function! SyntaxCheckers_c_make_GetLocList() dict
+    let makeprg = self.getExecEscaped() . ' -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
+
+" vim: set et sts=4 sw=4:

sources_non_forked/syntactic/syntax_checkers/c/oclint.vim

@@ -0,0 +1,60 @@
+"============================================================================
+"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
+
+if !exists('g:syntastic_oclint_config_file')
+    let g:syntastic_oclint_config_file = '.syntastic_oclint_config'
+endif
+
+let s:save_cpo = &cpo
+set cpo&vim
+
+function! SyntaxCheckers_c_oclint_GetLocList() dict
+    let makeprg = self.makeprgBuild({
+        \ 'args_after': '-text',
+        \ 'post_args_before': '-- -c ' . syntastic#c#ReadConfig(g:syntastic_oclint_config_file) })
+
+    let errorformat =
+        \ '%E%f:%l:%c: %m P1 ,' .
+        \ '%E%f:%l:%c: %m P2 ,' .
+        \ '%W%f:%l:%c: %m P3 ,' .
+        \ '%E%f:%l:%c: fatal error: %m,' .
+        \ '%E%f:%l:%c: error: %m,' .
+        \ '%W%f:%l:%c: warning: %m,' .
+        \ '%-G%.%#'
+
+    return SyntasticMake({
+        \ 'makeprg': makeprg,
+        \ 'errorformat': errorformat,
+        \ 'subtype': 'Style',
+        \ 'postprocess': ['compressWhitespace', 'sort'],
+        \ 'returns': [0, 3, 5] })
+endfunction
+
+call g:SyntasticRegistry.CreateAndRegisterChecker({
+    \ 'filetype': 'c',
+    \ 'name': 'oclint'})
+
+let &cpo = s:save_cpo
+unlet s:save_cpo
+
+" vim: set et sts=4 sw=4:

sources_non_forked/syntactic/syntax_checkers/c/sparse.vim

@@ -0,0 +1,53 @@
+"============================================================================
+"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
+
+if !exists('g:syntastic_sparse_config_file')
+    let g:syntastic_sparse_config_file = '.syntastic_sparse_config'
+endif
+
+let s:save_cpo = &cpo
+set cpo&vim
+
+function! SyntaxCheckers_c_sparse_GetLocList() dict
+    let makeprg = self.makeprgBuild({
+        \ 'args': syntastic#c#ReadConfig(g:syntastic_sparse_config_file),
+        \ 'args_after': '-ftabstop=' . &ts })
+
+    let errorformat = '%f:%l:%v: %trror: %m,%f:%l:%v: %tarning: %m,'
+
+    let loclist = SyntasticMake({
+        \ 'makeprg': makeprg,
+        \ 'errorformat': errorformat,
+        \ 'defaults': {'bufnr': bufnr("")},
+        \ 'returns': [0] })
+    return loclist
+endfunction
+
+call g:SyntasticRegistry.CreateAndRegisterChecker({
+    \ 'filetype': 'c',
+    \ 'name': 'sparse'})
+
+let &cpo = s:save_cpo
+unlet s:save_cpo
+
+" vim: set et sts=4 sw=4:

sources_non_forked/syntactic/syntax_checkers/c/splint.vim

@@ -0,0 +1,59 @@
+"============================================================================
+"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
+
+if !exists('g:syntastic_splint_config_file')
+    let g:syntastic_splint_config_file = '.syntastic_splint_config'
+endif
+
+let s:save_cpo = &cpo
+set cpo&vim
+
+function! SyntaxCheckers_c_splint_GetLocList() dict
+    let makeprg = self.makeprgBuild({
+        \ 'args': syntastic#c#ReadConfig(g:syntastic_splint_config_file),
+        \ 'args_after': '-showfunc -hints +quiet' })
+
+    let errorformat =
+        \ '%-G%f:%l:%v: %[%#]%[%#]%[%#] Internal Bug %.%#,' .
+        \ '%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'})
+
+let &cpo = s:save_cpo
+unlet s:save_cpo
+
+" vim: set et sts=4 sw=4:

sources_non_forked/syntactic/syntax_checkers/chef/foodcritic.vim

@@ -0,0 +1,39 @@
+"============================================================================
+"File:        foodcritic.vim
+"Description: Syntax checking plugin for syntastic.vim
+"Maintainer:  Doug Ireton <dougireton@gmail.com>
+"License:     This program is free software. It comes without any warranty,
+"             to the extent permitted by applicable law. You can redistribute
+"             it and/or modify it under the terms of the Do What The Fuck You
+"             Want To Public License, Version 2, as published by Sam Hocevar.
+"             See http://sam.zoy.org/wtfpl/COPYING for more details.
+"
+"============================================================================
+
+if exists("g:loaded_syntastic_chef_foodcritic_checker")
+    finish
+endif
+let g:loaded_syntastic_chef_foodcritic_checker = 1
+
+let s:save_cpo = &cpo
+set cpo&vim
+
+function! SyntaxCheckers_chef_foodcritic_GetLocList() dict
+    let makeprg = self.makeprgBuild({})
+
+    " FC023: Prefer conditional attributes: ./recipes/config.rb:49
+    let errorformat = 'FC%n: %m: %f:%l'
+
+    return SyntasticMake({
+        \ 'makeprg': makeprg,
+        \ 'errorformat': errorformat })
+endfunction
+
+call g:SyntasticRegistry.CreateAndRegisterChecker({
+      \ 'filetype': 'chef',
+      \ 'name': 'foodcritic'})
+
+let &cpo = s:save_cpo
+unlet s:save_cpo
+
+" vim: set et sts=4 sw=4:

sources_non_forked/syntactic/syntax_checkers/co/coco.vim

@@ -0,0 +1,42 @@
+"============================================================================
+"File:        co.vim
+"Description: Syntax checking plugin for syntastic.vim
+"Maintainer:  Andrew Kelley <superjoe30@gmail.com>
+"License:     This program is free software. It comes without any warranty,
+"             to the extent permitted by applicable law. You can redistribute
+"             it and/or modify it under the terms of the Do What The Fuck You
+"             Want To Public License, Version 2, as published by Sam Hocevar.
+"             See http://sam.zoy.org/wtfpl/COPYING for more details.
+"
+"============================================================================
+
+if exists("g:loaded_syntastic_co_coco_checker")
+    finish
+endif
+let g:loaded_syntastic_co_coco_checker = 1
+
+let s:save_cpo = &cpo
+set cpo&vim
+
+function! SyntaxCheckers_co_coco_GetLocList() dict
+    let makeprg = self.makeprgBuild({ 'args_after': '-c -o /tmp' })
+
+    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'})
+
+let &cpo = s:save_cpo
+unlet s:save_cpo
+
+" vim: set et sts=4 sw=4:

sources_non_forked/syntactic/syntax_checkers/cobol/cobc.vim

@@ -0,0 +1,46 @@
+"============================================================================
+"File:        cobc.vim
+"Description: Syntax checking plugin for syntastic.vim
+"Maintainer:  LCD 47 <lcd047 at gmail dot com>
+"License:     This program is free software. It comes without any warranty,
+"             to the extent permitted by applicable law. You can redistribute
+"             it and/or modify it under the terms of the Do What The Fuck You
+"             Want To Public License, Version 2, as published by Sam Hocevar.
+"             See http://sam.zoy.org/wtfpl/COPYING for more details.
+"
+"============================================================================
+
+
+if exists('g:loaded_syntastic_cobol_cobc_checker')
+    finish
+endif
+let g:loaded_syntastic_cobol_cobc_checker = 1
+
+if !exists('g:syntastic_cobol_compiler_options')
+    let g:syntastic_cobol_compiler_options = ''
+endif
+
+let s:save_cpo = &cpo
+set cpo&vim
+
+function! SyntaxCheckers_cobol_cobc_IsAvailable() dict
+    if !exists('g:syntastic_cobol_compiler')
+        let g:syntastic_cobol_compiler = self.getExec()
+    endif
+    return executable(expand(g:syntastic_cobol_compiler))
+endfunction
+
+function! SyntaxCheckers_cobol_cobc_GetLocList() dict
+    return syntastic#c#GetLocList('cobol', 'cobc', {
+        \ 'errorformat': '%f:%l: %trror: %m',
+        \ 'main_flags': '-fsyntax-only' })
+endfunction
+
+call g:SyntasticRegistry.CreateAndRegisterChecker({
+    \ 'filetype': 'cobol',
+    \ 'name': 'cobc' })
+
+let &cpo = s:save_cpo
+unlet s:save_cpo
+
+" vim: set et sts=4 sw=4:

sources_non_forked/syntactic/syntax_checkers/coffee/coffee.vim

@@ -0,0 +1,56 @@
+"============================================================================
+"File:        coffee.vim
+"Description: Syntax checking plugin for syntastic.vim
+"Maintainer:  Lincoln Stoll <l@lds.li>
+"License:     This program is free software. It comes without any warranty,
+"             to the extent permitted by applicable law. You can redistribute
+"             it and/or modify it under the terms of the Do What The Fuck You
+"             Want To Public License, Version 2, as published by Sam Hocevar.
+"             See http://sam.zoy.org/wtfpl/COPYING for more details.
+"
+"============================================================================
+"
+" Note: this script requires CoffeeScript version 1.6.2 or newer.
+"
+
+if exists("g:loaded_syntastic_coffee_coffee_checker")
+    finish
+endif
+let g:loaded_syntastic_coffee_coffee_checker = 1
+
+let s:save_cpo = &cpo
+set cpo&vim
+
+function! SyntaxCheckers_coffee_coffee_IsAvailable() dict
+    return executable(self.getExec()) &&
+        \ syntastic#util#versionIsAtLeast(syntastic#util#getVersion(
+        \       self.getExecEscaped() . ' --version 2>' . syntastic#util#DevNull()), [1,6,2])
+endfunction
+
+function! SyntaxCheckers_coffee_coffee_GetLocList() dict
+    let makeprg = self.makeprgBuild({ 'args_after': '-cp' })
+
+    let errorformat =
+        \ '%E%f:%l:%c: %trror: %m,' .
+        \ 'Syntax%trror: In %f\, %m on line %l,' .
+        \ '%EError: In %f\, Parse error on line %l: %m,' .
+        \ '%EError: In %f\, %m on line %l,' .
+        \ '%W%f(%l): lint warning: %m,' .
+        \ '%W%f(%l): warning: %m,' .
+        \ '%E%f(%l): SyntaxError: %m,' .
+        \ '%-Z%p^,' .
+        \ '%-G%.%#'
+
+    return SyntasticMake({
+        \ 'makeprg': makeprg,
+        \ 'errorformat': errorformat })
+endfunction
+
+call g:SyntasticRegistry.CreateAndRegisterChecker({
+    \ 'filetype': 'coffee',
+    \ 'name': 'coffee'})
+
+let &cpo = s:save_cpo
+unlet s:save_cpo
+
+" vim: set et sts=4 sw=4:

sources_non_forked/syntactic/syntax_checkers/coffee/coffeelint.vim

@@ -0,0 +1,44 @@
+"============================================================================
+"File:        coffeelint.vim
+"Description: Syntax checking plugin for syntastic.vim
+"Maintainer:  Lincoln Stoll <l@lds.li>
+"License:     This program is free software. It comes without any warranty,
+"             to the extent permitted by applicable law. You can redistribute
+"             it and/or modify it under the terms of the Do What The Fuck You
+"             Want To Public License, Version 2, as published by Sam Hocevar.
+"             See http://sam.zoy.org/wtfpl/COPYING for more details.
+"
+"============================================================================
+
+if exists("g:loaded_syntastic_coffee_coffeelint_checker")
+    finish
+endif
+let g:loaded_syntastic_coffee_coffeelint_checker = 1
+
+let s:save_cpo = &cpo
+set cpo&vim
+
+function! SyntaxCheckers_coffee_coffeelint_GetLocList() dict
+    let makeprg = self.makeprgBuild({ 'args_after': '--csv' })
+
+    let errorformat =
+        \ '%f\,%l\,%\d%#\,%trror\,%m,' .
+        \ '%f\,%l\,%trror\,%m,' .
+        \ '%f\,%l\,%\d%#\,%tarn\,%m,' .
+        \ '%f\,%l\,%tarn\,%m'
+
+    return SyntasticMake({
+        \ 'makeprg': makeprg,
+        \ 'errorformat': errorformat,
+        \ 'subtype': 'Style',
+        \ 'returns': [0, 1] })
+endfunction
+
+call g:SyntasticRegistry.CreateAndRegisterChecker({
+    \ 'filetype': 'coffee',
+    \ 'name': 'coffeelint'})
+
+let &cpo = s:save_cpo
+unlet s:save_cpo
+
+" vim: set et sts=4 sw=4:

sources_non_forked/syntactic/syntax_checkers/coq/coqtop.vim

@@ -0,0 +1,40 @@
+"============================================================================
+"File:        coqtop.vim
+"Description: Syntax checking plugin for syntastic.vim
+"Maintainer:  Matvey Aksenov <matvey.aksenov at gmail dot com>
+"License:     This program is free software. It comes without any warranty,
+"             to the extent permitted by applicable law. You can redistribute
+"             it and/or modify it under the terms of the Do What The Fuck You
+"             Want To Public License, Version 2, as published by Sam Hocevar.
+"             See http://sam.zoy.org/wtfpl/COPYING for more details.
+"
+"============================================================================
+
+if exists("g:loaded_syntastic_coq_coqtop_checker")
+    finish
+endif
+let g:loaded_syntastic_coq_coqtop_checker = 1
+
+let s:save_cpo = &cpo
+set cpo&vim
+
+function! SyntaxCheckers_coq_coqtop_GetLocList() dict
+    let makeprg = self.makeprgBuild({ 'args_after': '-noglob -batch -load-vernac-source' })
+
+    let errorformat =
+        \ '%AFile \"%f\"\, line %l\, characters %c\-%.%#\:,'.
+        \ '%C%m'
+
+    return SyntasticMake({
+        \ 'makeprg': makeprg,
+        \ 'errorformat': errorformat })
+endfunction
+
+call g:SyntasticRegistry.CreateAndRegisterChecker({
+    \ 'filetype': 'coq',
+    \ 'name': 'coqtop'})
+
+let &cpo = s:save_cpo
+unlet s:save_cpo
+
+" vim: set et sts=4 sw=4:

sources_non_forked/syntactic/syntax_checkers/cpp/cppcheck.vim

@@ -0,0 +1,31 @@
+"============================================================================
+"File:        cppcheck.vim
+"Description: Syntax checking plugin for syntastic.vim using cppcheck.pl
+"Maintainer:  LCD 47 <lcd047 at gmail dot com>
+"License:     This program is free software. It comes without any warranty,
+"             to the extent permitted by applicable law. You can redistribute
+"             it and/or modify it under the terms of the Do What The Fuck You
+"             Want To Public License, Version 2, as published by Sam Hocevar.
+"             See http://sam.zoy.org/wtfpl/COPYING for more details.
+"============================================================================
+"
+" The setting 'g:syntastic_cppcheck_config_file' allows you to define a file
+" that contains additional compiler arguments like include directories or
+" CFLAGS. The file is expected to contain one option per line. If none is
+" given the filename defaults to '.syntastic_cppcheck_config':
+"
+"   let g:syntastic_cppcheck_config_file = '.config'
+
+if exists("g:loaded_syntastic_cpp_cppcheck_checker")
+    finish
+endif
+let g:loaded_syntastic_cpp_cppcheck_checker = 1
+
+runtime! syntax_checkers/c/*.vim
+
+call g:SyntasticRegistry.CreateAndRegisterChecker({
+    \ 'filetype': 'cpp',
+    \ 'name': 'cppcheck',
+    \ 'redirect': 'c/cppcheck'})
+
+" vim: set et sts=4 sw=4:

sources_non_forked/syntactic/syntax_checkers/cpp/cpplint.vim

@@ -0,0 +1,64 @@
+"============================================================================
+"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
+
+let s:save_cpo = &cpo
+set cpo&vim
+
+function! SyntaxCheckers_cpp_cpplint_GetLocList() dict
+    let makeprg = self.makeprgBuild({ 'args': '--verbose=3' })
+
+    let errorformat = '%A%f:%l:  %m [%t],%-G%.%#'
+
+    let loclist = SyntasticMake({
+        \ 'makeprg': makeprg,
+        \ 'errorformat': errorformat,
+        \ 'subtype': 'Style',
+        \ 'returns': [0, 1] })
+
+    " change error types according to the prescribed threshold
+    for e in loclist
+        let e['type'] = e['type'] < g:syntastic_cpp_cpplint_thres ? 'W' : 'E'
+    endfor
+
+    return loclist
+endfunction
+
+call g:SyntasticRegistry.CreateAndRegisterChecker({
+    \ 'filetype': 'cpp',
+    \ 'name': 'cpplint',
+    \ 'exec': 'cpplint.py'})
+
+let &cpo = s:save_cpo
+unlet s:save_cpo
+
+" vim: set et sts=4 sw=4:

sources_non_forked/syntactic/syntax_checkers/cpp/gcc.vim

@@ -0,0 +1,55 @@
+"============================================================================
+"File:        cpp.vim
+"Description: Syntax checking plugin for syntastic.vim
+"Maintainer:  Gregor Uhlenheuer <kongo2002 at gmail dot com>
+"License:     This program is free software. It comes without any warranty,
+"             to the extent permitted by applicable law. You can redistribute
+"             it and/or modify it under the terms of the Do What The Fuck You
+"             Want To Public License, Version 2, as published by Sam Hocevar.
+"             See http://sam.zoy.org/wtfpl/COPYING for more details.
+"
+"============================================================================
+
+if exists('g:loaded_syntastic_cpp_gcc_checker')
+    finish
+endif
+let g:loaded_syntastic_cpp_gcc_checker = 1
+
+if !exists('g:syntastic_cpp_compiler_options')
+    let g:syntastic_cpp_compiler_options = ''
+endif
+
+let s:save_cpo = &cpo
+set cpo&vim
+
+function! SyntaxCheckers_cpp_gcc_IsAvailable() dict
+    if !exists('g:syntastic_cpp_compiler')
+        let g:syntastic_cpp_compiler = executable(self.getExec()) ? self.getExec() : 'clang++'
+    endif
+    return executable(expand(g:syntastic_cpp_compiler))
+endfunction
+
+function! SyntaxCheckers_cpp_gcc_GetLocList() dict
+    return syntastic#c#GetLocList('cpp', 'gcc', {
+        \ 'errorformat':
+        \     '%-G%f:%s:,' .
+        \     '%f:%l:%c: %trror: %m,' .
+        \     '%f:%l:%c: %tarning: %m,' .
+        \     '%f:%l:%c: %m,'.
+        \     '%f:%l: %trror: %m,'.
+        \     '%f:%l: %tarning: %m,'.
+        \     '%f:%l: %m',
+        \ 'main_flags': '-x c++ -fsyntax-only',
+        \ 'header_flags': '-x c++',
+        \ 'header_names': '\m\.\(h\|hpp\|hh\)$' })
+endfunction
+
+call g:SyntasticRegistry.CreateAndRegisterChecker({
+    \ 'filetype': 'cpp',
+    \ 'name': 'gcc',
+    \ 'exec': 'g++' })
+
+let &cpo = s:save_cpo
+unlet s:save_cpo
+
+" vim: set et sts=4 sw=4:

sources_non_forked/syntactic/syntax_checkers/cpp/oclint.vim

@@ -0,0 +1,31 @@
+"============================================================================
+"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
+
+runtime! syntax_checkers/c/*.vim
+
+call g:SyntasticRegistry.CreateAndRegisterChecker({
+    \ 'filetype': 'cpp',
+    \ 'name': 'oclint',
+    \ 'redirect': 'c/oclint'})
+
+" vim: set et sts=4 sw=4:

sources_non_forked/syntactic/syntax_checkers/cs/mcs.vim

@@ -0,0 +1,39 @@
+"============================================================================
+"File:        cs.vim
+"Description: Syntax checking plugin for syntastic.vim
+"Maintainer:  Daniel Walker <dwalker@fifo99.com>
+"License:     This program is free software. It comes without any warranty,
+"             to the extent permitted by applicable law. You can redistribute
+"             it and/or modify it under the terms of the Do What The Fuck You
+"             Want To Public License, Version 2, as published by Sam Hocevar.
+"             See http://sam.zoy.org/wtfpl/COPYING for more details.
+"
+"============================================================================
+
+if exists("g:loaded_syntastic_cs_mcs_checker")
+    finish
+endif
+let g:loaded_syntastic_cs_mcs_checker = 1
+
+let s:save_cpo = &cpo
+set cpo&vim
+
+function! SyntaxCheckers_cs_mcs_GetLocList() dict
+    let makeprg = self.makeprgBuild({ 'args_after': '--parse' })
+
+    let errorformat = '%f(%l\,%c): %trror %m'
+
+    return SyntasticMake({
+        \ 'makeprg': makeprg,
+        \ 'errorformat': errorformat,
+        \ 'defaults': {'bufnr': bufnr("")} })
+endfunction
+
+call g:SyntasticRegistry.CreateAndRegisterChecker({
+    \ 'filetype': 'cs',
+    \ 'name': 'mcs'})
+
+let &cpo = s:save_cpo
+unlet s:save_cpo
+
+" vim: set et sts=4 sw=4:

sources_non_forked/syntactic/syntax_checkers/css/csslint.vim

@@ -0,0 +1,56 @@
+"============================================================================
+"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_options')
+    let g:syntastic_csslint_options = ''
+endif
+
+let s:save_cpo = &cpo
+set cpo&vim
+
+function! SyntaxCheckers_css_csslint_GetLocList() dict
+    let makeprg = self.makeprgBuild({
+        \ 'args': g:syntastic_csslint_options,
+        \ 'args_after': '--format=compact' })
+
+    " Print CSS Lint's error/warning messages from compact format. Ignores blank lines.
+    let errorformat =
+        \ '%-G,' .
+        \ '%-G%f: lint free!,' .
+        \ '%f: line %l\, col %c\, %trror - %m,' .
+        \ '%f: line %l\, col %c\, %tarning - %m,'.
+        \ '%f: line %l\, col %c\, %m,'
+
+    return SyntasticMake({
+        \ 'makeprg': makeprg,
+        \ 'errorformat': errorformat,
+        \ 'defaults': {'bufnr': bufnr("")} })
+
+endfunction
+
+call g:SyntasticRegistry.CreateAndRegisterChecker({
+    \ 'filetype': 'css',
+    \ 'name': 'csslint'})
+
+let &cpo = s:save_cpo
+unlet s:save_cpo
+
+" vim: set et sts=4 sw=4:

sources_non_forked/syntactic/syntax_checkers/css/phpcs.vim

@@ -0,0 +1,29 @@
+"============================================================================
+"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
+
+runtime! syntax_checkers/php/*.vim
+
+call g:SyntasticRegistry.CreateAndRegisterChecker({
+    \ 'filetype': 'css',
+    \ 'name': 'phpcs',
+    \ 'redirect': 'php/phpcs'})
+
+" vim: set et sts=4 sw=4:

sources_non_forked/syntactic/syntax_checkers/css/prettycss.vim

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

sources_non_forked/syntactic/syntax_checkers/cucumber/cucumber.vim

@@ -0,0 +1,42 @@
+"============================================================================
+"File:        cucumber.vim
+"Description: Syntax checking plugin for syntastic.vim
+"Maintainer:  Martin Grenfell <martin.grenfell at gmail dot com>
+"License:     This program is free software. It comes without any warranty,
+"             to the extent permitted by applicable law. You can redistribute
+"             it and/or modify it under the terms of the Do What The Fuck You
+"             Want To Public License, Version 2, as published by Sam Hocevar.
+"             See http://sam.zoy.org/wtfpl/COPYING for more details.
+"
+"============================================================================
+
+if exists("g:loaded_syntastic_cucumber_cucumber_checker")
+    finish
+endif
+let g:loaded_syntastic_cucumber_cucumber_checker = 1
+
+let s:save_cpo = &cpo
+set cpo&vim
+
+function! SyntaxCheckers_cucumber_cucumber_GetLocList() dict
+    let makeprg = self.makeprgBuild({ 'args_after': '--dry-run --quiet --strict --format pretty' })
+
+    let errorformat =
+        \ '%f:%l:%c:%m,' .
+        \ '%W      %.%# (%m),' .
+        \ '%-Z%f:%l:%.%#,'.
+        \ '%-G%.%#'
+
+    return SyntasticMake({
+        \ 'makeprg': makeprg,
+        \ 'errorformat': errorformat })
+endfunction
+
+call g:SyntasticRegistry.CreateAndRegisterChecker({
+    \ 'filetype': 'cucumber',
+    \ 'name': 'cucumber'})
+
+let &cpo = s:save_cpo
+unlet s:save_cpo
+
+" vim: set et sts=4 sw=4:

sources_non_forked/syntactic/syntax_checkers/cuda/nvcc.vim

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

sources_non_forked/syntactic/syntax_checkers/d/dmd.vim

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

sources_non_forked/syntactic/syntax_checkers/dart/dartanalyzer.vim

@@ -0,0 +1,76 @@
+"============================================================================
+"File:        dartanalyzer.vim
+"Description: Dart syntax checker - using dartanalyzer
+"Maintainer:  Maksim Ryzhikov <rv.maksim at gmail dot com>
+"License:     This program is free software. It comes without any warranty,
+"             to the extent permitted by applicable law. You can redistribute
+"             it and/or modify it under the terms of the Do What The Fuck You
+"             Want To Public License, Version 2, as published by Sam Hocevar.
+"             See http://sam.zoy.org/wtfpl/COPYING for more details.
+"============================================================================
+
+if exists("g:loaded_syntastic_dart_dartanalyzer_checker")
+    finish
+endif
+let g:loaded_syntastic_dart_dartanalyzer_checker = 1
+
+let s:save_cpo = &cpo
+set cpo&vim
+
+function! SyntaxCheckers_dart_dartanalyzer_GetHighlightRegex(error)
+    if a:error['len']
+        let lcol = a:error['col'] - 1
+        let rcol = a:error['col'] + a:error['len']
+        let ret = '\%>' . lcol . 'c\%<' . rcol . 'c'
+    else
+        let ret = ''
+    endif
+
+    return ret
+endfunction
+
+function! SyntaxCheckers_dart_dartanalyzer_GetLocList() dict
+    let makeprg = self.makeprgBuild({ 'args_after': '--machine' })
+
+    " Machine readable format looks like:
+    " SEVERITY|TYPE|ERROR_CODE|FILENAME|LINE_NUMBER|COLUMN|LENGTH|MESSAGE
+    " SEVERITY: (WARNING|ERROR)
+    " TYPE: (RESOLVER|STATIC_TYPE|...)
+    " ERROR_CODE: (NO_SUCH_TYPE|...)
+    " FILENAME: String
+    " LINE_NUMBER: int
+    " COLUMN: int
+    " LENGTH: int
+    " MESSAGE: String
+
+    " We use %n to grab the error length, for the syntax highlighter
+    let commonformat = '|%.%#|%.%#|%f|%l|%c|%n|%m'
+
+    let errorformat =
+        \ '%EERROR'   . commonformat . ',' .
+        \ '%WWARNING' . commonformat
+
+    let loclist = SyntasticMake({
+        \ 'makeprg': makeprg,
+        \ 'errorformat': errorformat,
+        \ 'returns': [0, 1, 2] })
+
+    for e in loclist
+        let e['text'] = substitute(e['text'], '\m\\\([\\|]\)', '\1', 'g')
+
+        " Undo the %n hack
+        let e['len'] = e['nr']
+        call remove(e, 'nr')
+    endfor
+
+    return loclist
+endfunction
+
+call g:SyntasticRegistry.CreateAndRegisterChecker({
+    \ 'filetype': 'dart',
+    \ 'name': 'dartanalyzer' })
+
+let &cpo = s:save_cpo
+unlet s:save_cpo
+
+" vim: set et sts=4 sw=4:

sources_non_forked/syntactic/syntax_checkers/docbk/xmllint.vim

@@ -0,0 +1,25 @@
+"============================================================================
+"File:        docbk.vim
+"Description: Syntax checking plugin for syntastic.vim
+"Maintainer:  Martin Grenfell <martin.grenfell at gmail dot com>
+"License:     This program is free software. It comes without any warranty,
+"             to the extent permitted by applicable law. You can redistribute
+"             it and/or modify it under the terms of the Do What The Fuck You
+"             Want To Public License, Version 2, as published by Sam Hocevar.
+"             See http://sam.zoy.org/wtfpl/COPYING for more details.
+"
+"============================================================================
+
+if exists("g:loaded_syntastic_docbk_xmllint_checker")
+    finish
+endif
+let g:loaded_syntastic_docbk_xmllint_checker = 1
+
+runtime! syntax_checkers/xml/*.vim
+
+call g:SyntasticRegistry.CreateAndRegisterChecker({
+    \ 'filetype': 'docbk',
+    \ 'name': 'xmllint',
+    \ 'redirect': 'xml/xmllint'})
+
+" vim: set et sts=4 sw=4:

sources_non_forked/syntactic/syntax_checkers/dustjs/swiffer.vim

@@ -0,0 +1,38 @@
+"============================================================================
+"File:        swiffer.vim
+"Description: Dust.js syntax checker - using swiffer
+"Maintainer:  Steven Foote <smfoote at gmail dot com>
+"License:     This program is free software. It comes without any warranty,
+"             to the extent permitted by applicable law. You can redistribute
+"             it and/or modify it under the terms of the Do What The Fuck You
+"             Want To Public License, Version 2, as published by Sam Hocevar.
+"             See http://sam.zoy.org/wtfpl/COPYING for more details.
+"============================================================================
+
+if exists("g:loaded_syntastic_dustjs_swiffer_checker")
+    finish
+endif
+
+let g:loaded_syntastic_dustjs_swiffer_checker = 1
+
+let s:save_cpo = &cpo
+set cpo&vim
+
+function! SyntaxCheckers_dustjs_swiffer_GetLocList() dict
+    let makeprg = self.makeprgBuild({})
+
+    let errorformat = '%E%f - Line %l\, Column %c: %m'
+
+    return SyntasticMake({
+        \ 'makeprg': makeprg,
+        \ 'errorformat': errorformat })
+ endfunction
+
+call SyntasticRegistry.CreateAndRegisterChecker({
+    \ 'filetype': 'dustjs',
+    \ 'name': 'swiffer'})
+
+let &cpo = s:save_cpo
+unlet s:save_cpo
+
+" vim: set et sts=4 sw=4:

sources_non_forked/syntactic/syntax_checkers/elixir/elixir.vim

@@ -0,0 +1,51 @@
+"============================================================================
+"File:        elixir.vim
+"Description: Syntax checking plugin for syntastic.vim
+"Maintainer:  Richard Ramsden <rramsden at gmail dot com>
+"License:     This program is free software. It comes without any warranty,
+"             to the extent permitted by applicable law. You can redistribute
+"             it and/or modify it under the terms of the Do What The Fuck You
+"             Want To Public License, Version 2, as published by Sam Hocevar.
+"             See http://sam.zoy.org/wtfpl/COPYING for more details.
+"
+"============================================================================
+
+if exists("g:loaded_syntastic_elixir_elixir_checker")
+    finish
+endif
+let g:loaded_syntastic_elixir_elixir_checker = 1
+
+let s:save_cpo = &cpo
+set cpo&vim
+
+" TODO: we should probably split this into separate checkers
+function! SyntaxCheckers_elixir_elixir_IsAvailable() dict
+    return executable('elixir') && executable('mix')
+endfunction
+
+function! SyntaxCheckers_elixir_elixir_GetLocList() dict
+
+    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'] = self.makeprgBuild({ 'exe': compile_command })
+
+    let make_options['errorformat'] = '** %*[^\ ] %f:%l: %m'
+
+    return SyntasticMake(make_options)
+endfunction
+
+call g:SyntasticRegistry.CreateAndRegisterChecker({
+    \ 'filetype': 'elixir',
+    \ 'name': 'elixir'})
+
+let &cpo = s:save_cpo
+unlet s:save_cpo
+
+" vim: set et sts=4 sw=4:

sources_non_forked/syntactic/syntax_checkers/erlang/erlang_check_file.erl

@@ -0,0 +1,61 @@
+#!/usr/bin/env escript
+-export([main/1]).
+
+main([FileName]) ->
+    LibDirs = (["ebin", "include", "src", "test"] ++
+               filelib:wildcard("{apps,deps,lib}/*/{ebin,include}")),
+    compile(FileName, LibDirs);
+
+main([FileName, "-rebar", Path, LibDirs]) ->
+    {ok, L} = file:consult(Path),
+    P = dict:from_list(L),
+    Root = filename:dirname(Path),
+
+    Lib1 = case dict:find(lib_dirs, P) of
+             {ok, X} -> lists:map(fun(Sub) -> Root ++ "/" ++ Sub end, X);
+             _ -> []
+           end,
+
+    Lib2 = case dict:find(sub_dirs, P) of
+             {ok, Y} -> lists:foldl(
+                          fun(Sub,Sofar) ->
+                              Sofar ++ [
+                                        Root ++ "/" ++ Sub,
+                                        Root ++ "/" ++ Sub ++ "/include",
+                                        Root ++ "/" ++ Sub ++ "/deps",
+                                        Root ++ "/" ++ Sub ++ "/lib"
+                                       ] end, [], Y);
+             _ -> []
+           end,
+
+    LibDirs1 = LibDirs ++ Lib1 ++ Lib2,
+    %io:format("~p~n", [LibDirs1]),
+    compile(FileName, LibDirs1);
+
+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, I)} || I <- LibDirs]).
+
+get_root(Dir) ->
+    Path = filename:split(filename:absname(Dir)),
+    filename:join(get_root(lists:reverse(Path), Path)).
+
+get_root([], Path) ->
+    Path;
+get_root(["src" | Tail], _Path) ->
+    lists:reverse(Tail);
+get_root(["test" | Tail], _Path) ->
+    lists:reverse(Tail);
+get_root([_ | Tail], Path) ->
+    get_root(Tail, Path).

sources_non_forked/syntactic/syntax_checkers/erlang/escript.vim

@@ -0,0 +1,61 @@
+"============================================================================
+"File:        erlang.vim
+"Description: Syntax checking plugin for syntastic.vim
+"Maintainer:  Pawel Salata <rockplayer.pl at gmail dot com>
+"License:     This program is free software. It comes without any warranty,
+"             to the extent permitted by applicable law. You can redistribute
+"             it and/or modify it under the terms of the Do What The Fuck You
+"             Want To Public License, Version 2, as published by Sam Hocevar.
+"             See http://sam.zoy.org/wtfpl/COPYING for more details.
+"
+"============================================================================
+
+if exists('g:loaded_syntastic_erlang_erlang_checker')
+    finish
+endif
+let g:loaded_syntastic_erlang_erlang_checker = 1
+
+if !exists('g:syntastic_erlc_include_path')
+    let g:syntastic_erlc_include_path = ''
+endif
+
+let s:check_file = syntastic#util#shescape(expand('<sfile>:p:h') . syntastic#util#Slash() . 'erlang_check_file.erl')
+
+let s:save_cpo = &cpo
+set cpo&vim
+
+function! SyntaxCheckers_erlang_escript_GetLocList() dict
+    if expand('%:e') ==# 'hrl'
+        return []
+    endif
+
+    let shebang = syntastic#util#parseShebang()
+    if shebang['exe'] =~# '\m\<escript$' || (shebang['exe'] ==# '/usr/bin/env' && shebang['args'][0] ==# 'escript')
+        let args = '-s'
+        let post_args = ''
+    else
+        let args = s:check_file
+        let post_args = g:syntastic_erlc_include_path
+    endif
+    let makeprg = self.makeprgBuild({
+        \ 'args_after': args,
+        \ 'fname': syntastic#util#shexpand('%:p'),
+        \ 'post_args_after': post_args })
+
+    let errorformat =
+        \ '%W%f:%l: warning: %m,'.
+        \ '%E%f:%l: %m'
+
+    return SyntasticMake({
+        \ 'makeprg': makeprg,
+        \ 'errorformat': errorformat })
+endfunction
+
+call g:SyntasticRegistry.CreateAndRegisterChecker({
+    \ 'filetype': 'erlang',
+    \ 'name': 'escript'})
+
+let &cpo = s:save_cpo
+unlet s:save_cpo
+
+" vim: set et sts=4 sw=4:

sources_non_forked/syntactic/syntax_checkers/erlang/syntaxerl.vim

@@ -0,0 +1,40 @@
+"============================================================================
+"File:        syntaxerl.vim
+"Description: Syntax checking plugin for syntastic.
+"Maintainer:  locojay
+"License:     This program is free software. It comes without any warranty,
+"             to the extent permitted by applicable law. You can redistribute
+"             it and/or modify it under the terms of the Do What The Fuck You
+"             Want To Public License, Version 2, as published by Sam Hocevar.
+"             See http://sam.zoy.org/wtfpl/COPYING for more details.
+"============================================================================
+
+if exists("g:loaded_syntastic_erlang_syntaxerl_checker")
+    finish
+endif
+
+let g:loaded_syntastic_erlang_syntaxerl_checker = 1
+
+let s:save_cpo = &cpo
+set cpo&vim
+
+
+function! SyntaxCheckers_erlang_syntaxerl_GetLocList() dict
+
+    let makeprg = self.makeprgBuild({})
+
+    let errorformat =
+        \ '%W%f:%l: warning: %m,'.
+        \ '%E%f:%l: %m'
+
+    return SyntasticMake({
+        \ 'makeprg': makeprg,
+        \ 'errorformat': errorformat })
+endfunction
+
+call g:SyntasticRegistry.CreateAndRegisterChecker({
+    \ 'filetype': 'erlang',
+    \ 'name': 'syntaxerl'})
+
+let &cpo = s:save_cpo
+unlet s:save_cpo

sources_non_forked/syntactic/syntax_checkers/eruby/ruby.vim

@@ -0,0 +1,72 @@
+"============================================================================
+"File:        ruby.vim
+"Description: Syntax checking plugin for syntastic.vim
+"Maintainer:  Martin Grenfell <martin.grenfell at gmail dot com>
+"License:     This program is free software. It comes without any warranty,
+"             to the extent permitted by applicable law. You can redistribute
+"             it and/or modify it under the terms of the Do What The Fuck You
+"             Want To Public License, Version 2, as published by Sam Hocevar.
+"             See http://sam.zoy.org/wtfpl/COPYING for more details.
+"
+"============================================================================
+
+if exists("g:loaded_syntastic_eruby_ruby_checker")
+    finish
+endif
+let g:loaded_syntastic_eruby_ruby_checker = 1
+
+let s:save_cpo = &cpo
+set cpo&vim
+
+function! SyntaxCheckers_eruby_ruby_IsAvailable() dict
+    if !exists("g:syntastic_ruby_exec")
+        let g:syntastic_ruby_exec = self.getExec()
+    endif
+    return executable(expand(g:syntastic_ruby_exec))
+endfunction
+
+function! SyntaxCheckers_eruby_ruby_GetLocList() dict
+    let exe = syntastic#util#shexpand(g:syntastic_ruby_exec)
+    if !syntastic#util#isRunningWindows()
+        let exe = 'RUBYOPT= ' . exe
+    endif
+
+    let fname = "'" . escape(expand('%'), "\\'") . "'"
+
+    " TODO: encodings became useful in ruby 1.9 :)
+    if syntastic#util#versionIsAtLeast(syntastic#util#getVersion(exe . ' --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'})
+
+let &cpo = s:save_cpo
+unlet s:save_cpo
+
+" vim: set et sts=4 sw=4:

sources_non_forked/syntactic/syntax_checkers/fortran/gfortran.vim

@@ -0,0 +1,51 @@
+"============================================================================
+"File:        fortran.vim
+"Description: Syntax checking plugin for syntastic.vim
+"Maintainer:  Karl Yngve Lervåg <karl.yngve@lervag.net>
+"License:     This program is free software. It comes without any warranty,
+"             to the extent permitted by applicable law. You can redistribute
+"             it and/or modify it under the terms of the Do What The Fuck You
+"             Want To Public License, Version 2, as published by Sam Hocevar.
+"             See http://sam.zoy.org/wtfpl/COPYING for more details.
+"
+"============================================================================
+
+if exists("g:loaded_syntastic_fortran_gfortran_checker")
+    finish
+endif
+let g:loaded_syntastic_fortran_gfortran_checker=1
+
+if !exists('g:syntastic_fortran_compiler_options')
+    let g:syntastic_fortran_compiler_options = ''
+endif
+
+let s:save_cpo = &cpo
+set cpo&vim
+
+function! SyntaxCheckers_fortran_gfortran_IsAvailable() dict
+    if !exists('g:syntastic_fortran_compiler')
+        let g:syntastic_fortran_compiler = self.getExec()
+    endif
+    return executable(expand(g:syntastic_fortran_compiler))
+endfunction
+
+function! SyntaxCheckers_fortran_gfortran_GetLocList() dict
+    return syntastic#c#GetLocList('fortran', 'gfortran', {
+        \ 'errorformat':
+        \     '%-C %#,'.
+        \     '%-C  %#%.%#,'.
+        \     '%A%f:%l.%c:,'.
+        \     '%Z%trror: %m,'.
+        \     '%Z%tarning: %m,'.
+        \     '%-G%.%#',
+        \ 'main_flags': '-fsyntax-only' })
+endfunction
+
+call g:SyntasticRegistry.CreateAndRegisterChecker({
+    \ 'filetype': 'fortran',
+    \ 'name': 'gfortran' })
+
+let &cpo = s:save_cpo
+unlet s:save_cpo
+
+" vim: set et sts=4 sw=4:

sources_non_forked/syntactic/syntax_checkers/glsl/cgc.vim

@@ -0,0 +1,77 @@
+"============================================================================
+"File:        glsl.vim
+"Description: Syntax checker for OpenGL Shading Language
+"Maintainer:  Joshua Rahm <joshuarahm@gmail.com>
+"License:     This program is free software. It comes without any warranty,
+"             to the extent permitted by applicable law. You can redistribute
+"             it and/or modify it under the terms of the Do What The Fuck You
+"             Want To Public License, Version 2, as published by Sam Hocevar.
+"             See http://sam.zoy.org/wtfpl/COPYING for more details.
+"
+"============================================================================
+
+if exists("g:loaded_syntastic_glsl_cgc_checker")
+    finish
+endif
+let g:loaded_syntastic_glsl_cgc_checker = 1
+
+let s:glsl_extensions = {
+        \ 'glslf': 'gpu_fp',
+        \ 'glslv': 'gpu_vp',
+        \ 'frag':  'gpu_fp',
+        \ 'vert':  'gpu_vp',
+        \ 'fp':    'gpu_fp',
+        \ 'vp':    'gpu_vp'
+    \ }
+
+let s:save_cpo = &cpo
+set cpo&vim
+
+function! SyntaxCheckers_glsl_cgc_GetLocList() dict
+    let makeprg = self.makeprgBuild({
+        \ 'args_before': '-oglsl -profile ' . s:GetProfile(),
+        \ 'args': (exists('g:syntastic_glsl_options') ? ' ' . g:syntastic_glsl_options : '') })
+
+    let errorformat =
+        \ "%E%f(%l) : error %m," .
+        \ "%W%f(%l) : warning %m"
+
+    return SyntasticMake({
+        \ 'makeprg': makeprg,
+        \ 'errorformat': errorformat })
+endfunction
+
+function! s:GetProfile()
+    let save_view = winsaveview()
+    let old_foldenable = &foldenable
+    let old_lazyredraw = &lazyredraw
+
+    let &lazyredraw = 1
+    let &foldenable = 0
+    call cursor(1, 1)
+
+    let magic = '\m\C^// profile:\s*'
+    let line = search(magic, 'c')
+
+    call winrestview(save_view)
+    let &foldenable = old_foldenable
+    let &lazyredraw = old_lazyredraw
+
+    if line
+        let profile = matchstr(getline(line), magic . '\zs.*')
+    else
+        let extensions = exists('g:syntastic_glsl_extensions') ? g:syntastic_glsl_extensions : s:glsl_extensions
+        let profile = get(extensions, tolower(expand('%:e')), 'gpu_vert')
+    endif
+
+    return profile
+endfunction
+
+call g:SyntasticRegistry.CreateAndRegisterChecker({
+    \'filetype': 'glsl',
+    \'name': 'cgc'})
+
+let &cpo = s:save_cpo
+unlet s:save_cpo
+
+" vim: set et sts=4 sw=4:

sources_non_forked/syntactic/syntax_checkers/go/go.vim

@@ -0,0 +1,91 @@
+"============================================================================
+"File:        go.vim
+"Description: Check go syntax using 'gofmt -l' followed by 'go [build|test]'
+"Maintainer:  Kamil Kisiel <kamil@kamilkisiel.net>
+"License:     This program is free software. It comes without any warranty,
+"             to the extent permitted by applicable law. You can redistribute
+"             it and/or modify it under the terms of the Do What The Fuck You
+"             Want To Public License, Version 2, as published by Sam Hocevar.
+"             See http://sam.zoy.org/wtfpl/COPYING for more details.
+"
+" This syntax checker does not reformat your source code.
+" Use a BufWritePre autocommand to that end:
+"   autocmd FileType go autocmd BufWritePre <buffer> Fmt
+"============================================================================
+
+if exists("g:loaded_syntastic_go_go_checker")
+    finish
+endif
+let g:loaded_syntastic_go_go_checker = 1
+
+let s:save_cpo = &cpo
+set cpo&vim
+
+function! SyntaxCheckers_go_go_IsAvailable() dict
+    return executable('go') && executable('gofmt')
+endfunction
+
+function! SyntaxCheckers_go_go_GetLocList() dict
+    " Check with gofmt first, since `go build` and `go test` might not report
+    " syntax errors in the current file if another file with syntax error is
+    " compiled first.
+    let makeprg = self.makeprgBuild({
+        \ 'exe': 'gofmt',
+        \ 'args': '-l',
+        \ 'tail': '> ' . syntastic#util#DevNull() })
+
+    let errorformat =
+        \ '%f:%l:%c: %m,' .
+        \ '%-G%.%#'
+
+    let errors = SyntasticMake({
+        \ 'makeprg': makeprg,
+        \ 'errorformat': errorformat,
+        \ 'defaults': {'type': 'e'} })
+    if !empty(errors)
+        return errors
+    endif
+
+    " Test files, i.e. files with a name ending in `_test.go`, are not
+    " compiled by `go build`, therefore `go test` must be called for those.
+    if match(expand('%'), '\m_test\.go$') == -1
+        let makeprg = 'go build ' . syntastic#c#NullOutput()
+        let cleanup = 0
+    else
+        let makeprg = 'go test -c ' . syntastic#c#NullOutput()
+        let cleanup = 1
+    endif
+
+    " The first pattern is for warnings from C compilers.
+    let errorformat =
+        \ '%W%f:%l: warning: %m,' .
+        \ '%E%f:%l:%c:%m,' .
+        \ '%E%f:%l:%m,' .
+        \ '%C%\s%\+%m,' .
+        \ '%-G#%.%#'
+
+    " The go compiler needs to either be run with an import path as an
+    " argument or directly from the package directory. Since figuring out
+    " the proper import path is fickle, just cwd to the package.
+
+    let errors = SyntasticMake({
+        \ 'makeprg': makeprg,
+        \ 'errorformat': errorformat,
+        \ 'cwd': expand('%:p:h'),
+        \ 'defaults': {'type': 'e'} })
+
+    if cleanup
+        call delete(expand('%:p:h') . syntastic#util#Slash() . expand('%:p:h:t') . '.test')
+    endif
+
+    return errors
+endfunction
+
+call g:SyntasticRegistry.CreateAndRegisterChecker({
+    \ 'filetype': 'go',
+    \ 'name': 'go'})
+
+let &cpo = s:save_cpo
+unlet s:save_cpo
+
+" vim: set et sts=4 sw=4:

sources_non_forked/syntactic/syntax_checkers/go/gofmt.vim

@@ -0,0 +1,44 @@
+"============================================================================
+"File:        gofmt.vim
+"Description: Check go syntax using 'gofmt -l'
+"Maintainer:  Brandon Thomson <bt@brandonthomson.com>
+"License:     This program is free software. It comes without any warranty,
+"             to the extent permitted by applicable law. You can redistribute
+"             it and/or modify it under the terms of the Do What The Fuck You
+"             Want To Public License, Version 2, as published by Sam Hocevar.
+"             See http://sam.zoy.org/wtfpl/COPYING for more details.
+"
+" This syntax checker does not reformat your source code.
+" Use a BufWritePre autocommand to that end:
+"   autocmd FileType go autocmd BufWritePre <buffer> Fmt
+"============================================================================
+
+if exists("g:loaded_syntastic_go_gofmt_checker")
+    finish
+endif
+let g:loaded_syntastic_go_gofmt_checker = 1
+
+let s:save_cpo = &cpo
+set cpo&vim
+
+function! SyntaxCheckers_go_gofmt_GetLocList() dict
+    let makeprg = self.makeprgBuild({
+        \ 'args_after': '-l',
+        \ 'tail_after': '> ' . syntastic#util#DevNull() })
+
+    let errorformat = '%f:%l:%c: %m,%-G%.%#'
+
+    return SyntasticMake({
+        \ 'makeprg': makeprg,
+        \ 'errorformat': errorformat,
+        \ 'defaults': {'type': 'e'} })
+endfunction
+
+call g:SyntasticRegistry.CreateAndRegisterChecker({
+    \ 'filetype': 'go',
+    \ 'name': 'gofmt'})
+
+let &cpo = s:save_cpo
+unlet s:save_cpo
+
+" vim: set et sts=4 sw=4:

sources_non_forked/syntactic/syntax_checkers/go/golint.vim

@@ -0,0 +1,39 @@
+"============================================================================
+"File:        golint.vim
+"Description: Check go syntax using 'golint'
+"Maintainer:  Hiroshi Ioka <hirochachacha@gmail.com>
+"License:     This program is free software. It comes without any warranty,
+"             to the extent permitted by applicable law. You can redistribute
+"             it and/or modify it under the terms of the Do What The Fuck You
+"             Want To Public License, Version 2, as published by Sam Hocevar.
+"             See http://sam.zoy.org/wtfpl/COPYING for more details.
+"
+"============================================================================
+
+if exists("g:loaded_syntastic_go_golint_checker")
+    finish
+endif
+let g:loaded_syntastic_go_golint_checker = 1
+
+let s:save_cpo = &cpo
+set cpo&vim
+
+function! SyntaxCheckers_go_golint_GetLocList() dict
+    let makeprg = self.makeprgBuild({})
+
+    let errorformat = '%f:%l:%c: %m,%-G%.%#'
+
+    return SyntasticMake({
+        \ 'makeprg': makeprg,
+        \ 'errorformat': errorformat,
+        \ 'subtype': 'Style' })
+endfunction
+
+call g:SyntasticRegistry.CreateAndRegisterChecker({
+    \ 'filetype': 'go',
+    \ 'name': 'golint'})
+
+let &cpo = s:save_cpo
+unlet s:save_cpo
+
+" vim: set et sts=4 sw=4:

sources_non_forked/syntactic/syntax_checkers/go/gotype.vim

@@ -0,0 +1,48 @@
+"============================================================================
+"File:        gotype.vim
+"Description: Perform syntactic and semantic checking of Go code using 'gotype'
+"Maintainer:  luz <ne.tetewi@gmail.com>
+"License:     This program is free software. It comes without any warranty,
+"             to the extent permitted by applicable law. You can redistribute
+"             it and/or modify it under the terms of the Do What The Fuck You
+"             Want To Public License, Version 2, as published by Sam Hocevar.
+"             See http://sam.zoy.org/wtfpl/COPYING for more details.
+"
+"============================================================================
+
+if exists("g:loaded_syntastic_go_gotype_checker")
+    finish
+endif
+let g:loaded_syntastic_go_gotype_checker = 1
+
+let s:save_cpo = &cpo
+set cpo&vim
+
+function! SyntaxCheckers_go_gotype_GetLocList() dict
+    let makeprg = self.getExecEscaped() . ' .'
+
+    let errorformat =
+        \ '%f:%l:%c: %m,' .
+        \ '%-G%.%#'
+
+    " gotype needs the full go package to test types properly. Just cwd to
+    " the package for the same reasons specified in go.vim ("figuring out
+    " the import path is fickle").
+
+    let errors = SyntasticMake({
+        \ 'makeprg': makeprg,
+        \ 'errorformat': errorformat,
+        \ 'cwd': expand('%:p:h'),
+        \ 'defaults': {'type': 'e'} })
+
+    return errors
+endfunction
+
+call g:SyntasticRegistry.CreateAndRegisterChecker({
+    \ 'filetype': 'go',
+    \ 'name': 'gotype'})
+
+let &cpo = s:save_cpo
+unlet s:save_cpo
+
+" vim: set et sts=4 sw=4:

sources_non_forked/syntactic/syntax_checkers/go/govet.vim

@@ -0,0 +1,49 @@
+"============================================================================
+"File:        govet.vim
+"Description: Perform static analysis of Go code with the vet tool
+"Maintainer:  Kamil Kisiel <kamil@kamilkisiel.net>
+"License:     This program is free software. It comes without any warranty,
+"             to the extent permitted by applicable law. You can redistribute
+"             it and/or modify it under the terms of the Do What The Fuck You
+"             Want To Public License, Version 2, as published by Sam Hocevar.
+"             See http://sam.zoy.org/wtfpl/COPYING for more details.
+"
+"============================================================================
+
+if exists("g:loaded_syntastic_go_govet_checker")
+    finish
+endif
+let g:loaded_syntastic_go_govet_checker = 1
+
+let s:save_cpo = &cpo
+set cpo&vim
+
+function! SyntaxCheckers_go_govet_IsAvailable() dict
+    return executable('go')
+endfunction
+
+function! SyntaxCheckers_go_govet_GetLocList() dict
+    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'})
+
+let &cpo = s:save_cpo
+unlet s:save_cpo
+
+" vim: set et sts=4 sw=4:

sources_non_forked/syntactic/syntax_checkers/haml/haml.vim

@@ -0,0 +1,50 @@
+"============================================================================
+"File:        haml.vim
+"Description: Syntax checking plugin for syntastic.vim
+"Maintainer:  Martin Grenfell <martin.grenfell at gmail dot com>
+"License:     This program is free software. It comes without any warranty,
+"             to the extent permitted by applicable law. You can redistribute
+"             it and/or modify it under the terms of the Do What The Fuck You
+"             Want To Public License, Version 2, as published by Sam Hocevar.
+"             See http://sam.zoy.org/wtfpl/COPYING for more details.
+"
+"============================================================================
+
+if exists('g:loaded_syntastic_haml_haml_checker')
+    finish
+endif
+let g:loaded_syntastic_haml_haml_checker = 1
+
+let s:save_cpo = &cpo
+set cpo&vim
+
+function! SyntaxCheckers_haml_haml_IsAvailable() dict
+    if !exists('g:syntastic_haml_interpreter')
+        let g:syntastic_haml_interpreter = self.getExec()
+    endif
+    return executable(expand(g:syntastic_haml_interpreter))
+endfunction
+
+function! SyntaxCheckers_haml_haml_GetLocList() dict
+    let makeprg = self.makeprgBuild({
+        \ 'exe': syntastic#util#shexpand(g:syntastic_haml_interpreter),
+        \ 'args_after': '-c' })
+
+    let errorformat =
+        \ 'Haml error on line %l: %m,' .
+        \ 'Syntax error on line %l: %m,' .
+        \ '%-G%.%#'
+
+    return SyntasticMake({
+        \ 'makeprg': makeprg,
+        \ 'errorformat': errorformat })
+endfunction
+
+call g:SyntasticRegistry.CreateAndRegisterChecker({
+    \ 'filetype': 'haml',
+    \ 'name': 'haml'})
+
+let &cpo = s:save_cpo
+unlet s:save_cpo
+
+" vim: set et sts=4 sw=4:

sources_non_forked/syntactic/syntax_checkers/haml/haml_lint.vim

@@ -0,0 +1,37 @@
+"============================================================================
+"File:        haml_lint.vim
+"Description: HAML style and syntax checker plugin for Syntastic
+"Maintainer:  Shane da Silva <shane@dasilva.io>
+"License:     This program is free software. It comes without any warranty,
+"             to the extent permitted by applicable law. You can redistribute
+"             it and/or modify it under the terms of the Do What The Fuck You
+"             Want To Public License, Version 2, as published by Sam Hocevar.
+"             See http://sam.zoy.org/wtfpl/COPYING for more details.
+"============================================================================
+
+if exists("g:loaded_syntastic_haml_haml_lint_checker")
+    finish
+endif
+let g:loaded_syntastic_haml_haml_lint_checker = 1
+
+let s:save_cpo = &cpo
+set cpo&vim
+
+function! SyntaxCheckers_haml_haml_lint_GetLocList() dict
+    let makeprg = self.makeprgBuild({})
+    let errorformat = '%f:%l [%t] %m'
+    return SyntasticMake({
+        \ 'makeprg': makeprg,
+        \ 'errorformat': errorformat,
+        \ 'subtype': 'Style'})
+endfunction
+
+call g:SyntasticRegistry.CreateAndRegisterChecker({
+    \ 'filetype': 'haml',
+    \ 'name': 'haml_lint',
+    \ 'exec': 'haml-lint' })
+
+let &cpo = s:save_cpo
+unlet s:save_cpo
+
+" vim: set et sts=4 sw=4:

sources_non_forked/syntactic/syntax_checkers/handlebars/handlebars.vim

@@ -0,0 +1,42 @@
+"============================================================================
+"File:        handlebars.vim
+"Description: Syntax checking plugin for syntastic.vim
+"Maintainer:  Martin Grenfell <martin.grenfell at gmail dot com>
+"License:     This program is free software. It comes without any warranty,
+"             to the extent permitted by applicable law. You can redistribute
+"             it and/or modify it under the terms of the Do What The Fuck You
+"             Want To Public License, Version 2, as published by Sam Hocevar.
+"             See http://sam.zoy.org/wtfpl/COPYING for more details.
+"============================================================================
+
+if exists("g:loaded_syntastic_handlebars_handlebars_checker")
+    finish
+endif
+let g:loaded_syntastic_handlebars_handlebars_checker = 1
+
+let s:save_cpo = &cpo
+set cpo&vim
+
+function! SyntaxCheckers_handlebars_handlebars_GetLocList() dict
+    let makeprg = self.makeprgBuild({ 'args_after': '-f ' . syntastic#util#DevNull() })
+
+    let errorformat =
+        \ '%EError: %m on line %l:,'.
+        \ "%EError: %m,".
+        \ '%Z%p^,' .
+        \ '%-G%.%#'
+
+    return SyntasticMake({
+        \ 'makeprg': makeprg,
+        \ 'errorformat': errorformat,
+        \ 'defaults': {'bufnr': bufnr("")} })
+endfunction
+
+call g:SyntasticRegistry.CreateAndRegisterChecker({
+    \ 'filetype': 'handlebars',
+    \ 'name': 'handlebars'})
+
+let &cpo = s:save_cpo
+unlet s:save_cpo
+
+" vim: set et sts=4 sw=4:

sources_non_forked/syntactic/syntax_checkers/haskell/ghc-mod.vim

@@ -0,0 +1,72 @@
+"============================================================================
+"File:        ghc-mod.vim
+"Description: Syntax checking plugin for syntastic.vim
+"Maintainer:  Anthony Carapetis <anthony.carapetis at gmail dot com>
+"License:     This program is free software. It comes without any warranty,
+"             to the extent permitted by applicable law. You can redistribute
+"             it and/or modify it under the terms of the Do What The Fuck You
+"             Want To Public License, Version 2, as published by Sam Hocevar.
+"             See http://sam.zoy.org/wtfpl/COPYING for more details.
+"
+"============================================================================
+
+if exists('g:loaded_syntastic_haskell_ghc_mod_checker')
+    finish
+endif
+let g:loaded_syntastic_haskell_ghc_mod_checker = 1
+
+let s:ghc_mod_new = -1
+
+let s:save_cpo = &cpo
+set cpo&vim
+
+function! SyntaxCheckers_haskell_ghc_mod_IsAvailable() dict
+    " We need either a Vim version that can handle NULs in system() output,
+    " or a ghc-mod version that has the --boundary option.
+    let exe = self.getExec()
+    let s:ghc_mod_new = executable(exe) ? s:GhcModNew(exe) : -1
+    return (s:ghc_mod_new >= 0) && (v:version >= 704 || s:ghc_mod_new)
+endfunction
+
+function! SyntaxCheckers_haskell_ghc_mod_GetLocList() dict
+    let makeprg = self.makeprgBuild({
+        \ 'exe': self.getExecEscaped() . ' check' . (s:ghc_mod_new ? ' --boundary=""' : '') })
+
+    let errorformat =
+        \ '%-G%\s%#,' .
+        \ '%f:%l:%c:%trror: %m,' .
+        \ '%f:%l:%c:%tarning: %m,'.
+        \ '%f:%l:%c: %trror: %m,' .
+        \ '%f:%l:%c: %tarning: %m,' .
+        \ '%f:%l:%c:%m,' .
+        \ '%E%f:%l:%c:,' .
+        \ '%Z%m'
+
+    return SyntasticMake({
+        \ 'makeprg': makeprg,
+        \ 'errorformat': errorformat,
+        \ 'postprocess': ['compressWhitespace'],
+        \ 'returns': [0] })
+endfunction
+
+function! s:GhcModNew(exe)
+    let exe = syntastic#util#shescape(a:exe)
+    try
+        let ghc_mod_version = filter(split(system(exe), '\n'), 'v:val =~# ''\m^ghc-mod version''')[0]
+        let ret = syntastic#util#versionIsAtLeast(syntastic#util#parseVersion(ghc_mod_version), [2, 1, 2])
+    catch /\m^Vim\%((\a\+)\)\=:E684/
+        call syntastic#log#error("checker haskell/ghc_mod: can't parse version string (abnormal termination?)")
+        let ret = -1
+    endtry
+    return ret
+endfunction
+
+call g:SyntasticRegistry.CreateAndRegisterChecker({
+    \ 'filetype': 'haskell',
+    \ 'name': 'ghc_mod',
+    \ 'exec': 'ghc-mod' })
+
+let &cpo = s:save_cpo
+unlet s:save_cpo
+
+" vim: set et sts=4 sw=4:

sources_non_forked/syntactic/syntax_checkers/haskell/hdevtools.vim

@@ -0,0 +1,48 @@
+"============================================================================
+"File:        hdevtools.vim
+"Description: Syntax checking plugin for syntastic.vim
+"Maintainer:  Anthony Carapetis <anthony.carapetis at gmail dot com>
+"License:     This program is free software. It comes without any warranty,
+"             to the extent permitted by applicable law. You can redistribute
+"             it and/or modify it under the terms of the Do What The Fuck You
+"             Want To Public License, Version 2, as published by Sam Hocevar.
+"             See http://sam.zoy.org/wtfpl/COPYING for more details.
+"
+"============================================================================
+
+if exists("g:loaded_syntastic_haskell_hdevtools_checker")
+    finish
+endif
+let g:loaded_syntastic_haskell_hdevtools_checker = 1
+
+let s:save_cpo = &cpo
+set cpo&vim
+
+function! SyntaxCheckers_haskell_hdevtools_GetLocList() dict
+    let makeprg = self.makeprgBuild({
+        \ 'exe': self.getExecEscaped() . ' check',
+        \ 'args': get(g:, 'hdevtools_options', '') })
+
+    let errorformat= '\%-Z\ %#,'.
+        \ '%W%f:%l:%c:\ Warning:\ %m,'.
+        \ '%W%f:%l:%c:\ Warning:,'.
+        \ '%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'})
+
+let &cpo = s:save_cpo
+unlet s:save_cpo
+
+" vim: set et sts=4 sw=4:

sources_non_forked/syntactic/syntax_checkers/haskell/hlint.vim

@@ -0,0 +1,37 @@
+"============================================================================
+"File:        hlint.vim
+"Description: Syntax checking plugin for syntastic.vim
+"Maintainer:  Nicolas Wu <nicolas.wu at gmail dot com>
+"License:     BSD
+"============================================================================
+
+if exists('g:loaded_syntastic_haskell_hlint_checker')
+    finish
+endif
+let g:loaded_syntastic_haskell_hlint_checker = 1
+
+let s:save_cpo = &cpo
+set cpo&vim
+
+function! SyntaxCheckers_haskell_hlint_GetLocList() dict
+    let makeprg = self.makeprgBuild({})
+
+    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'})
+
+let &cpo = s:save_cpo
+unlet s:save_cpo
+
+" vim: set et sts=4 sw=4:

sources_non_forked/syntactic/syntax_checkers/haxe/haxe.vim

@@ -0,0 +1,61 @@
+"============================================================================
+"File:        haxe.vim
+"Description: Syntax checking plugin for syntastic.vim
+"Maintainer:  David Bernard <david.bernard.31 at gmail dot com>
+"License:     This program is free software. It comes without any warranty,
+"             to the extent permitted by applicable law. You can redistribute
+"             it and/or modify it under the terms of the Do What The Fuck You
+"             Want To Public License, Version 2, as published by Sam Hocevar.
+"             See http://sam.zoy.org/wtfpl/COPYING for more details.
+"
+"============================================================================
+
+if exists("g:loaded_syntastic_haxe_haxe_checker")
+    finish
+endif
+let g:loaded_syntastic_haxe_haxe_checker = 1
+
+let s:save_cpo = &cpo
+set cpo&vim
+
+function! SyntaxCheckers_haxe_haxe_GetLocList() dict
+    if exists('b:vaxe_hxml')
+        let hxml = b:vaxe_hxml
+    elseif exists('g:vaxe_hxml')
+        let hxml = g:vaxe_hxml
+    else
+        let hxml = syntastic#util#findInParent('*.hxml', expand('%:p:h'))
+    endif
+    let hxml = fnamemodify(hxml, ':p')
+
+    if hxml != ''
+        let makeprg = self.makeprgBuild({
+            \ 'fname': syntastic#util#shescape(fnamemodify(hxml, ':t')) })
+
+        let errorformat = '%E%f:%l: characters %c-%n : %m'
+
+        let loclist = SyntasticMake({
+            \ 'makeprg': makeprg,
+            \ 'errorformat': errorformat,
+            \ 'cwd': fnamemodify(hxml, ':h') })
+
+        for e in loclist
+            let e['hl'] = '\%>' . e['col'] . 'c\%<' . (e['nr'] + 1) . 'c'
+            let e['col'] += 1
+            let e['nr'] = 0
+        endfor
+
+        return loclist
+    endif
+
+    return []
+endfunction
+
+call g:SyntasticRegistry.CreateAndRegisterChecker({
+    \ 'filetype': 'haxe',
+    \ 'name': 'haxe'})
+
+let &cpo = s:save_cpo
+unlet s:save_cpo
+
+" vim: set et sts=4 sw=4:

sources_non_forked/syntactic/syntax_checkers/hss/hss.vim

@@ -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
+
+let s:save_cpo = &cpo
+set cpo&vim
+
+function! SyntaxCheckers_hss_hss_GetLocList() dict
+    let makeprg = self.makeprgBuild({ 'args_after' : '-output ' . syntastic#util#DevNull() })
+
+    let errorformat = '%E%f:%l: %m'
+
+    return SyntasticMake({
+	\ 'makeprg': makeprg,
+	\ 'errorformat': errorformat })
+endfunction
+
+call g:SyntasticRegistry.CreateAndRegisterChecker({
+    \ 'filetype': 'hss',
+    \ 'name': 'hss'})
+
+let &cpo = s:save_cpo
+unlet s:save_cpo
+
+" vim: set et sts=4 sw=4:

sources_non_forked/syntactic/syntax_checkers/html/jshint.vim

@@ -0,0 +1,56 @@
+"============================================================================
+"File:        jshint.vim
+"Description: Javascript syntax checker for HTML - using jshint
+"Maintainer:  LCD 47 <lcd047@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_html_jshint_checker')
+    finish
+endif
+let g:loaded_syntastic_html_jshint_checker = 1
+
+if !exists('g:syntastic_jshint_exec')
+    let g:syntastic_jshint_exec = 'jshint'
+endif
+
+if !exists('g:syntastic_html_jshint_conf')
+    let g:syntastic_html_jshint_conf = ''
+endif
+
+let s:save_cpo = &cpo
+set cpo&vim
+
+function! SyntaxCheckers_html_jshint_IsAvailable() dict
+    let exe = expand(g:syntastic_jshint_exec)
+    return executable(exe) &&
+        \ syntastic#util#versionIsAtLeast(syntastic#util#getVersion(exe . ' --version'), [2,4])
+endfunction
+
+function! SyntaxCheckers_html_jshint_GetLocList() dict
+    let makeprg = self.makeprgBuild({
+        \ 'exe': expand(g:syntastic_jshint_exec),
+        \ 'args': (g:syntastic_html_jshint_conf != '' ? '--config ' . g:syntastic_html_jshint_conf : ''),
+        \ 'args_after': '--verbose --extract always' })
+
+    let errorformat = '%A%f: line %l\, col %v\, %m \(%t%*\d\)'
+
+    return SyntasticMake({
+        \ 'makeprg': makeprg,
+        \ 'errorformat': errorformat,
+        \ 'defaults': {'bufnr': bufnr('')},
+        \ 'returns': [0, 2] })
+endfunction
+
+call g:SyntasticRegistry.CreateAndRegisterChecker({
+    \ 'filetype': 'html',
+    \ 'name': 'jshint'})
+
+let &cpo = s:save_cpo
+unlet s:save_cpo
+
+" vim: set et sts=4 sw=4:

sources_non_forked/syntactic/syntax_checkers/html/tidy.vim

@@ -0,0 +1,209 @@
+"============================================================================
+"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
+
+let s:save_cpo = &cpo
+set cpo&vim
+
+" 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",
+                \ "<input> proprietary 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",
+                \ "unescaped & or unknown entity",
+                \ "<input> attribute \"type\" has invalid value",
+                \ "proprietary attribute \"role\"",
+                \ "proprietary attribute \"aria-activedescendant\"",
+                \ "proprietary attribute \"aria-atomic\"",
+                \ "proprietary attribute \"aria-autocomplete\"",
+                \ "proprietary attribute \"aria-busy\"",
+                \ "proprietary attribute \"aria-checked\"",
+                \ "proprietary attribute \"aria-controls\"",
+                \ "proprietary attribute \"aria-describedby\"",
+                \ "proprietary attribute \"aria-disabled\"",
+                \ "proprietary attribute \"aria-dropeffect\"",
+                \ "proprietary attribute \"aria-expanded\"",
+                \ "proprietary attribute \"aria-flowto\"",
+                \ "proprietary attribute \"aria-grabbed\"",
+                \ "proprietary attribute \"aria-haspopup\"",
+                \ "proprietary attribute \"aria-hidden\"",
+                \ "proprietary attribute \"aria-invalid\"",
+                \ "proprietary attribute \"aria-label\"",
+                \ "proprietary attribute \"aria-labelledby\"",
+                \ "proprietary attribute \"aria-level\"",
+                \ "proprietary attribute \"aria-live\"",
+                \ "proprietary attribute \"aria-multiline\"",
+                \ "proprietary attribute \"aria-multiselectable\"",
+                \ "proprietary attribute \"aria-orientation\"",
+                \ "proprietary attribute \"aria-owns\"",
+                \ "proprietary attribute \"aria-posinset\"",
+                \ "proprietary attribute \"aria-pressed\"",
+                \ "proprietary attribute \"aria-readonly\"",
+                \ "proprietary attribute \"aria-relevant\"",
+                \ "proprietary attribute \"aria-relevant\"",
+                \ "proprietary attribute \"aria-required\"",
+                \ "proprietary attribute \"aria-selected\"",
+                \ "proprietary attribute \"aria-setsize\"",
+                \ "proprietary attribute \"aria-sort\"",
+                \ "proprietary attribute \"aria-valuemax\"",
+                \ "proprietary attribute \"aria-valuemin\"",
+                \ "proprietary attribute \"aria-valuenow\"",
+                \ "proprietary attribute \"aria-valuetext\""
+                \ ]
+
+let s:blocklevel_tags = [
+                \ "main",
+                \ "section",
+                \ "article",
+                \ "aside",
+                \ "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() dict
+    let makeprg = self.makeprgBuild({
+        \ 'args_after': s:Args(),
+        \ 'tail': '2>&1' })
+
+    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 e in loclist
+        if e['valid'] && s:IgnoreError(e['text']) == 1
+            let e['valid'] = 0
+        endif
+    endfor
+
+    return loclist
+endfunction
+
+call g:SyntasticRegistry.CreateAndRegisterChecker({
+    \ 'filetype': 'html',
+    \ 'name': 'tidy'})
+
+let &cpo = s:save_cpo
+unlet s:save_cpo
+
+" vim: set et sts=4 sw=4:

sources_non_forked/syntactic/syntax_checkers/html/validator.vim

@@ -0,0 +1,87 @@
+"============================================================================
+"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:save_cpo = &cpo
+set cpo&vim
+
+function! SyntaxCheckers_html_validator_GetLocList() dict
+    let fname = syntastic#util#shexpand('%')
+    let makeprg = self.getExecEscaped() . ' -s --compressed -F out=gnu -F asciiquotes=yes' .
+        \ (g:syntastic_html_validator_parser != '' ? ' -F parser=' . g:syntastic_html_validator_parser : '') .
+        \ (g:syntastic_html_validator_nsfilter != '' ? ' -F nsfilter=' . g:syntastic_html_validator_nsfilter : '') .
+        \ ' -F doc=@' . fname . '\;type=text/html\;filename=' . fname . ' ' . g:syntastic_html_validator_api
+
+    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': 'validator',
+        \ 'returns': [0] })
+endfunction
+
+call g:SyntasticRegistry.CreateAndRegisterChecker({
+    \ 'filetype': 'html',
+    \ 'name': 'validator',
+    \ 'exec': 'curl' })
+
+let &cpo = s:save_cpo
+unlet s:save_cpo
+
+" vim: set et sts=4 sw=4:

sources_non_forked/syntactic/syntax_checkers/html/w3.vim

@@ -0,0 +1,69 @@
+"============================================================================
+"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
+
+let s:save_cpo = &cpo
+set cpo&vim
+
+function! SyntaxCheckers_html_w3_GetLocList() dict
+    let makeprg = self.getExecEscaped() . ' -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 e in loclist
+        let e['text'] = substitute(e['text'], '\m\\\([\"]\)', '\1', 'g')
+    endfor
+
+    return loclist
+endfunction
+
+call g:SyntasticRegistry.CreateAndRegisterChecker({
+    \ 'filetype': 'html',
+    \ 'name': 'w3',
+    \ 'exec': 'curl' })
+
+let &cpo = s:save_cpo
+unlet s:save_cpo
+
+" vim: set et sts=4 sw=4:

sources_non_forked/syntactic/syntax_checkers/java/checkstyle.vim

@@ -0,0 +1,61 @@
+"============================================================================
+"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
+
+let s:save_cpo = &cpo
+set cpo&vim
+
+function! SyntaxCheckers_java_checkstyle_GetLocList() dict
+
+    let fname = syntastic#util#shescape( expand('%:p:h') . '/' . expand('%:t') )
+
+    if has('win32unix')
+        let fname = substitute(system('cygpath -m ' . fname), '\m\%x00', '', 'g')
+    endif
+
+    let makeprg = self.makeprgBuild({
+        \ 'args_after': '-cp ' . g:syntastic_java_checkstyle_classpath .
+        \               ' com.puppycrawl.tools.checkstyle.Main -c ' . g:syntastic_java_checkstyle_conf_file .
+        \               ' -f xml',
+        \ 'fname': fname })
+
+    let errorformat = '%f:%t:%l:%c:%m'
+
+    return SyntasticMake({
+        \ 'makeprg': makeprg,
+        \ 'errorformat': errorformat,
+        \ 'preprocess': 'checkstyle',
+        \ 'subtype': 'Style' })
+endfunction
+
+call g:SyntasticRegistry.CreateAndRegisterChecker({
+    \ 'filetype': 'java',
+    \ 'name': 'checkstyle',
+    \ 'exec': 'java'})
+
+let &cpo = s:save_cpo
+unlet s:save_cpo
+
+" vim: set et sts=4 sw=4:

sources_non_forked/syntactic/syntax_checkers/java/javac.vim

@@ -0,0 +1,450 @@
+"============================================================================
+"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 = {}
+let s:has_maven = 0
+
+" 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
+
+let s:save_cpo = &cpo
+set cpo&vim
+
+function! s:CygwinPath(path)
+    return substitute(system("cygpath -m " . a:path), '\n', '', 'g')
+endfunction
+
+if !exists("g:syntastic_java_javac_temp_dir")
+    if has('win32') || has('win64')
+        let g:syntastic_java_javac_temp_dir = $TEMP."\\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_custom_classpath_command')
+    let g:syntastic_java_javac_custom_classpath_command = ''
+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:SplitClasspath(classpath)
+    if a:classpath == ''
+        return []
+    endif
+    if has('win32') || has('win32unix') || has('win64')
+        return split(a:classpath, ";")
+    else
+        return split(a:classpath, ":")
+    endif
+endfunction
+
+function! s:LoadConfigFile()
+    if filereadable(g:syntastic_java_javac_config_file)
+        exe 'source '.g:syntastic_java_javac_config_file
+    endif
+endfunction
+
+function! s:SaveClasspath()
+    " build classpath from lines
+    let path = ''
+    let lines = getline(1, line('$'))
+    for l in lines
+        let path = s:AddToClasspath(path, l)
+    endfor
+    " save classpath to config file
+    if g:syntastic_java_javac_config_file_enabled
+        if filereadable(g:syntastic_java_javac_config_file)
+            " load lines from config file
+            let lines = readfile(g:syntastic_java_javac_config_file)
+            " strip g:syntastic_java_javac_classpath options from config file lines
+            let i = 0
+            while i < len(lines)
+                if match(lines[i], 'g:syntastic_java_javac_classpath') != -1
+                    call remove(lines, i)
+                    let i -= 1
+                endif
+                let i += 1
+            endwhile
+        else
+            let lines = []
+        endif
+        " add new g:syntastic_java_javac_classpath option to config
+        call add(lines, 'let g:syntastic_java_javac_classpath = "'.path.'"')
+        " save config file lines
+        call writefile(lines, g:syntastic_java_javac_config_file)
+    endif
+    " set new classpath
+    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 path = []
+        let pathlines = split(g:syntastic_java_javac_classpath, "\n")
+        for p in pathlines
+            let path += s:SplitClasspath(p)
+        endfor
+        execute (len(path) + 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 path
+            call append(line('$') - 1, p)
+        endfor
+        let &modified = 0
+    else
+        execute winnr . 'wincmd w'
+    endif
+endfunction
+
+function! s:SaveConfig()
+    " get lines
+    let lines = getline(1, line('$'))
+    if g:syntastic_java_javac_config_file_enabled
+        " save config file lines
+        call writefile(lines, g:syntastic_java_javac_config_file)
+    endif
+    let &modified = 0
+endfunction
+
+function! s:EditConfig()
+    let command = 'syntastic javac config'
+    let winnr = bufwinnr('^' . command . '$')
+    if winnr < 0
+        let lines = []
+        if filereadable(g:syntastic_java_javac_config_file)
+            let lines = readfile(g:syntastic_java_javac_config_file)
+        endif
+        execute (len(lines) + 5) . 'sp ' . fnameescape(command)
+
+        augroup syntastic
+            autocmd BufWriteCmd <buffer> call s:SaveConfig() | bwipeout
+        augroup END
+
+        setlocal ft=vim buftype=acwrite bufhidden=wipe nobuflisted noswapfile nowrap number
+        for l in lines
+            call append(line('$') - 1, l)
+        endfor
+        let &modified = 0
+    else
+        execute winnr . 'wincmd w'
+    endif
+endfunction
+
+function! s:GetMavenProperties()
+    let mvn_properties = {}
+    let pom = findfile("pom.xml", ".;")
+    if s:has_maven && filereadable(pom)
+        if !has_key(g:syntastic_java_javac_maven_pom_properties, pom)
+            let mvn_cmd = syntastic#util#shexpand(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, '\m^\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, '\m^\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, '\m\.' . matches[1] . "$", '', '')
+                    else
+                        let matches = matchlist(line, '\m^\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()
+
+if g:syntastic_java_javac_config_file_enabled
+    command! SyntasticJavacEditConfig call s:EditConfig()
+endif
+
+function! s:GetMavenClasspath()
+    let pom = findfile("pom.xml", ".;")
+    if s:has_maven && filereadable(pom)
+        if !has_key(g:syntastic_java_javac_maven_pom_ftime, pom) || g:syntastic_java_javac_maven_pom_ftime[pom] != getftime(pom)
+            let mvn_cmd = syntastic#util#shexpand(g:syntastic_java_maven_executable) . ' -f ' . pom
+            let mvn_classpath_output = split(system(mvn_cmd . ' dependency:build-classpath'), "\n")
+            let mvn_classpath = ''
+            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 stridx(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() dict
+    let s:has_maven = executable(expand(g:syntastic_java_maven_executable))
+    return executable(expand(g:syntastic_java_javac_executable))
+endfunction
+
+function! s:MavenOutputDirectory()
+    let pom = findfile("pom.xml", ".;")
+    if s:has_maven && 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 stridx(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 stridx(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
+    return '.'
+endfunction
+
+function! SyntaxCheckers_java_javac_GetLocList() dict
+
+    let javac_opts = g:syntastic_java_javac_options
+
+    let output_dir = ""
+    if g:syntastic_java_javac_delete_output
+        let output_dir = g:syntastic_java_javac_temp_dir
+        let javac_opts .= ' -d ' . output_dir
+    endif
+
+    " load classpath from config file
+    if g:syntastic_java_javac_config_file_enabled
+        call s:LoadConfigFile()
+    endif
+
+    let javac_classpath = ''
+
+    " add classpathes to javac_classpath
+    if has('win32') || has('win32unix') || has('win64')
+        let javac_classpath_split = ';'
+    else
+        let javac_classpath_split = ':'
+    endif
+    for path in split(g:syntastic_java_javac_classpath, javac_classpath_split)
+        if path != ''
+            try
+                let ps = glob(path, 0, 1)
+            catch
+                let ps = split(glob(path, 0), "\n")
+            endtry
+            if type(ps) == type([])
+                for p in ps
+                    let javac_classpath = s:AddToClasspath(javac_classpath, p)
+                endfor
+            else
+                let javac_classpath = s:AddToClasspath(javac_classpath, ps)
+            endif
+        endif
+    endfor
+
+    if s:has_maven && g:syntastic_java_javac_autoload_maven_classpath
+        if !g:syntastic_java_javac_delete_output
+            let javac_opts .= ' -d ' . s:MavenOutputDirectory()
+        endif
+        let javac_classpath = s:AddToClasspath(javac_classpath, s:GetMavenClasspath())
+    endif
+
+    " load custom classpath
+    if g:syntastic_java_javac_custom_classpath_command != ''
+        let lines = system(g:syntastic_java_javac_custom_classpath_command)
+        if has('win32') || has('win32unix') || has('win64')
+            let lines = substitute(lines, "\r\n", "\n", 'g')
+        endif
+        for l in split(lines, "\n")
+            let javac_classpath = s:AddToClasspath(javac_classpath, l)
+        endfor
+    endif
+
+    if javac_classpath != ''
+        let javac_opts .= ' -cp "' . 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 = self.makeprgBuild({
+        \ 'args': javac_opts,
+        \ 'fname': fname,
+        \ 'tail': '2>&1' })
+
+    " 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'})
+
+let &cpo = s:save_cpo
+unlet s:save_cpo
+
+" vim: set et sts=4 sw=4:

sources_non_forked/syntactic/syntax_checkers/javascript/closurecompiler.vim

@@ -0,0 +1,76 @@
+"============================================================================
+"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
+
+let s:save_cpo = &cpo
+set cpo&vim
+
+function! SyntaxCheckers_javascript_closurecompiler_IsAvailable() dict
+    return
+        \ executable("java") &&
+        \ exists("g:syntastic_javascript_closure_compiler_path") &&
+        \ filereadable(g:syntastic_javascript_closure_compiler_path)
+endfunction
+
+function! SyntaxCheckers_javascript_closurecompiler_GetLocList() dict
+    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 = self.makeprgBuild({
+        \ 'exe': 'java -jar ' . g:syntastic_javascript_closure_compiler_path,
+        \ 'args': g:syntastic_javascript_closure_compiler_options,
+        \ 'args_after': '--js' ,
+        \ 'fname': file_list })
+
+    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',
+    \ 'exec': 'java'})
+
+let &cpo = s:save_cpo
+unlet s:save_cpo
+
+" vim: set et sts=4 sw=4:

sources_non_forked/syntactic/syntax_checkers/javascript/eslint.vim

@@ -0,0 +1,50 @@
+"============================================================================
+"File:        eslint.vim
+"Description: Javascript syntax checker - using eslint
+"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_javascript_eslint_checker')
+    finish
+endif
+let g:loaded_syntastic_javascript_eslint_checker = 1
+
+if !exists('g:syntastic_javascript_eslint_conf')
+    let g:syntastic_javascript_eslint_conf = ''
+endif
+
+let s:save_cpo = &cpo
+set cpo&vim
+
+function! SyntaxCheckers_javascript_eslint_GetLocList() dict
+    let makeprg = self.makeprgBuild({
+        \ 'args': (g:syntastic_javascript_eslint_conf != '' ? '--config ' . g:syntastic_javascript_eslint_conf : '') })
+
+    let errorformat =
+        \ '%E%f: line %l\, col %c\, Error - %m'
+
+    let loclist = SyntasticMake({
+        \ 'makeprg': makeprg,
+        \ 'errorformat': errorformat,
+        \ 'postprocess': ['sort'] })
+
+    for e in loclist
+        let e['col'] += 1
+    endfor
+
+    return loclist
+endfunction
+
+call g:SyntasticRegistry.CreateAndRegisterChecker({
+    \ 'filetype': 'javascript',
+    \ 'name': 'eslint'})
+
+let &cpo = s:save_cpo
+unlet s:save_cpo
+
+" vim: set et sts=4 sw=4:

sources_non_forked/syntactic/syntax_checkers/javascript/gjslint.vim

@@ -0,0 +1,48 @@
+"============================================================================
+"File:        gjslint.vim
+"Description: Javascript syntax checker - using gjslint
+"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_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
+
+let s:save_cpo = &cpo
+set cpo&vim
+
+function! SyntaxCheckers_javascript_gjslint_GetLocList() dict
+    let makeprg = self.makeprgBuild({
+        \ 'args': g:syntastic_javascript_gjslint_conf,
+        \ 'args_after': '--nosummary --unix_mode --nodebug_indentation --nobeep' })
+
+    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'})
+
+let &cpo = s:save_cpo
+unlet s:save_cpo
+
+" vim: set et sts=4 sw=4: