From c9d3f9d892cd04a4368d5e74242b3f44ea22b7f2 Mon Sep 17 00:00:00 2001 From: ma6174 Date: Sun, 26 May 2013 20:56:22 +0800 Subject: [PATCH] add syntastic --- .vimrc | 4 + README.md | 1 + autoload/pathogen.vim | 326 +++++++++++++ bundle/syntastic/.gitignore | 4 + bundle/syntastic/CONTRIBUTING.md | 49 ++ bundle/syntastic/LICENCE | 13 + bundle/syntastic/README.markdown | 165 +++++++ bundle/syntastic/_assets/screenshot_1.png | Bin 0 -> 92425 bytes bundle/syntastic/autoload/syntastic/c.vim | 239 ++++++++++ .../syntastic/autoload/syntastic/makeprg.vim | 45 ++ .../autoload/syntastic/postprocess.vim | 58 +++ bundle/syntastic/autoload/syntastic/util.vim | 146 ++++++ bundle/syntastic/doc/syntastic.txt | 428 ++++++++++++++++++ bundle/syntastic/plugin/syntastic.vim | 389 ++++++++++++++++ .../plugin/syntastic/autoloclist.vim | 38 ++ .../syntastic/plugin/syntastic/balloons.vim | 60 +++ bundle/syntastic/plugin/syntastic/checker.vim | 71 +++ bundle/syntastic/plugin/syntastic/cursor.vim | 59 +++ .../plugin/syntastic/highlighting.vim | 62 +++ bundle/syntastic/plugin/syntastic/loclist.vim | 152 +++++++ .../plugin/syntastic/makeprg_builder.vim | 65 +++ bundle/syntastic/plugin/syntastic/modemap.vim | 62 +++ .../syntastic/plugin/syntastic/notifiers.vim | 44 ++ .../syntastic/plugin/syntastic/registry.vim | 166 +++++++ bundle/syntastic/plugin/syntastic/signs.vim | 142 ++++++ bundle/syntastic/syntax_checkers/ada/gcc.vim | 168 +++++++ .../applescript/osacompile.vim | 49 ++ .../syntax_checkers/c/checkpatch.vim | 43 ++ bundle/syntastic/syntax_checkers/c/gcc.vim | 183 ++++++++ bundle/syntastic/syntax_checkers/c/make.vim | 65 +++ bundle/syntastic/syntax_checkers/c/sparse.vim | 48 ++ bundle/syntastic/syntax_checkers/c/splint.vim | 56 +++ bundle/syntastic/syntax_checkers/c/ycm.vim | 32 ++ bundle/syntastic/syntax_checkers/co/coco.vim | 42 ++ .../syntax_checkers/coffee/coffee.vim | 42 ++ .../syntax_checkers/coffee/coffeelint.vim | 32 ++ .../syntastic/syntax_checkers/coq/coqtop.vim | 36 ++ .../syntastic/syntax_checkers/cpp/cpplint.vim | 59 +++ bundle/syntastic/syntax_checkers/cpp/gcc.vim | 179 ++++++++ bundle/syntastic/syntax_checkers/cpp/ycm.vim | 34 ++ bundle/syntastic/syntax_checkers/cs/mcs.vim | 35 ++ .../syntastic/syntax_checkers/css/csslint.vim | 52 +++ .../syntastic/syntax_checkers/css/phpcs.vim | 33 ++ .../syntax_checkers/css/prettycss.vim | 61 +++ .../syntax_checkers/cucumber/cucumber.vim | 38 ++ .../syntastic/syntax_checkers/cuda/nvcc.vim | 67 +++ bundle/syntastic/syntax_checkers/d/dmd.vim | 177 ++++++++ .../syntax_checkers/dart/dart_analyzer.vim | 62 +++ .../syntax_checkers/docbk/xmllint.vim | 30 ++ .../syntax_checkers/elixir/elixir.vim | 42 ++ .../syntax_checkers/erlang/erlang.vim | 51 +++ .../erlang/erlang_check_file.erl | 34 ++ .../syntastic/syntax_checkers/eruby/ruby.vim | 49 ++ .../syntax_checkers/fortran/gfortran.vim | 58 +++ .../gentoo_metadata/xmllint.vim | 40 ++ bundle/syntastic/syntax_checkers/go/go.vim | 64 +++ bundle/syntastic/syntax_checkers/go/gofmt.vim | 36 ++ bundle/syntastic/syntax_checkers/go/govet.vim | 44 ++ .../syntastic/syntax_checkers/haml/haml.vim | 33 ++ .../syntax_checkers/haskell/ghc-mod.vim | 48 ++ .../syntax_checkers/haskell/hdevtools.vim | 45 ++ .../syntastic/syntax_checkers/haxe/haxe.vim | 59 +++ .../syntastic/syntax_checkers/html/tidy.vim | 110 +++++ .../syntax_checkers/html/validator.vim | 78 ++++ .../syntax_checkers/html/validator_decode.awk | 61 +++ bundle/syntastic/syntax_checkers/html/w3.vim | 59 +++ .../syntax_checkers/java/checkstyle.vim | 54 +++ .../syntastic/syntax_checkers/java/javac.vim | 307 +++++++++++++ .../javascript/closurecompiler.vim | 62 +++ .../syntax_checkers/javascript/gjslint.vim | 36 ++ .../syntax_checkers/javascript/jshint.vim | 51 +++ .../syntax_checkers/javascript/jsl.vim | 51 +++ .../syntax_checkers/javascript/jslint.vim | 47 ++ .../syntax_checkers/json/jsonlint.vim | 37 ++ .../syntax_checkers/json/jsonval.vim | 30 ++ .../syntax_checkers/less/less-lint.coffee | 41 ++ .../syntax_checkers/less/less-lint.js | 57 +++ .../syntastic/syntax_checkers/less/lessc.vim | 58 +++ .../syntastic/syntax_checkers/lisp/clisp.vim | 47 ++ .../syntastic/syntax_checkers/llvm/llvm.vim | 34 ++ bundle/syntastic/syntax_checkers/lua/luac.vim | 61 +++ .../syntax_checkers/matlab/mlint.vim | 35 ++ .../syntastic/syntax_checkers/nasm/nasm.vim | 38 ++ .../syntax_checkers/nroff/mandoc.vim | 36 ++ bundle/syntastic/syntax_checkers/objc/gcc.vim | 184 ++++++++ bundle/syntastic/syntax_checkers/objc/ycm.vim | 34 ++ .../syntax_checkers/ocaml/camlp4o.vim | 149 ++++++ .../syntax_checkers/perl/efm_perl.pl | 186 ++++++++ .../syntastic/syntax_checkers/perl/perl.vim | 71 +++ .../syntax_checkers/perl/perlcritic.vim | 58 +++ .../syntax_checkers/perl/podchecker.vim | 30 ++ bundle/syntastic/syntax_checkers/php/php.vim | 47 ++ .../syntastic/syntax_checkers/php/phpcs.vim | 38 ++ .../syntastic/syntax_checkers/php/phpmd.vim | 72 +++ .../syntax_checkers/pod/podchecker.vim | 35 ++ .../syntax_checkers/puppet/puppetlint.vim | 113 +++++ .../syntax_checkers/python/flake8.vim | 49 ++ .../syntastic/syntax_checkers/python/pep8.vim | 40 ++ .../syntax_checkers/python/py3kwarn.vim | 26 ++ .../syntax_checkers/python/pyflakes.vim | 52 +++ .../syntax_checkers/python/pylint.vim | 41 ++ .../syntax_checkers/python/python.vim | 37 ++ .../syntax_checkers/rst/rst2pseudoxml.vim | 48 ++ .../syntastic/syntax_checkers/ruby/jruby.vim | 49 ++ .../syntax_checkers/ruby/macruby.vim | 38 ++ bundle/syntastic/syntax_checkers/ruby/mri.vim | 73 +++ .../syntax_checkers/ruby/rubocop.vim | 52 +++ .../syntastic/syntax_checkers/rust/rustc.vim | 39 ++ .../syntastic/syntax_checkers/sass/sass.vim | 58 +++ .../syntax_checkers/scala/scalac.vim | 40 ++ .../syntastic/syntax_checkers/scss/sass.vim | 31 ++ .../syntax_checkers/sh/checkbashisms.vim | 41 ++ bundle/syntastic/syntax_checkers/sh/sh.vim | 79 ++++ .../syntastic/syntax_checkers/slim/slimrb.vim | 55 +++ .../syntax_checkers/tcl/nagelfar.vim | 38 ++ .../syntastic/syntax_checkers/tex/chktex.vim | 61 +++ .../syntastic/syntax_checkers/tex/lacheck.vim | 30 ++ .../syntax_checkers/twig/twiglint.vim | 39 ++ .../syntax_checkers/typescript/tsc.vim | 28 ++ .../syntastic/syntax_checkers/vala/valac.vim | 67 +++ .../syntastic/syntax_checkers/vhdl/ghdl.vim | 33 ++ .../syntastic/syntax_checkers/xhtml/tidy.vim | 82 ++++ .../syntastic/syntax_checkers/xml/xmllint.vim | 48 ++ .../syntax_checkers/xslt/xmllint.vim | 30 ++ .../syntastic/syntax_checkers/yaml/jsyaml.vim | 38 ++ .../syntax_checkers/z80/z80syntaxchecker.vim | 37 ++ .../syntastic/syntax_checkers/zpt/zptlint.vim | 43 ++ bundle/syntastic/syntax_checkers/zsh/zsh.vim | 33 ++ doc/tags | 28 ++ 129 files changed, 8904 insertions(+) create mode 100644 autoload/pathogen.vim create mode 100644 bundle/syntastic/.gitignore create mode 100644 bundle/syntastic/CONTRIBUTING.md create mode 100644 bundle/syntastic/LICENCE create mode 100644 bundle/syntastic/README.markdown create mode 100644 bundle/syntastic/_assets/screenshot_1.png create mode 100644 bundle/syntastic/autoload/syntastic/c.vim create mode 100644 bundle/syntastic/autoload/syntastic/makeprg.vim create mode 100644 bundle/syntastic/autoload/syntastic/postprocess.vim create mode 100644 bundle/syntastic/autoload/syntastic/util.vim create mode 100644 bundle/syntastic/doc/syntastic.txt create mode 100644 bundle/syntastic/plugin/syntastic.vim create mode 100644 bundle/syntastic/plugin/syntastic/autoloclist.vim create mode 100644 bundle/syntastic/plugin/syntastic/balloons.vim create mode 100644 bundle/syntastic/plugin/syntastic/checker.vim create mode 100644 bundle/syntastic/plugin/syntastic/cursor.vim create mode 100644 bundle/syntastic/plugin/syntastic/highlighting.vim create mode 100644 bundle/syntastic/plugin/syntastic/loclist.vim create mode 100644 bundle/syntastic/plugin/syntastic/makeprg_builder.vim create mode 100644 bundle/syntastic/plugin/syntastic/modemap.vim create mode 100644 bundle/syntastic/plugin/syntastic/notifiers.vim create mode 100644 bundle/syntastic/plugin/syntastic/registry.vim create mode 100644 bundle/syntastic/plugin/syntastic/signs.vim create mode 100644 bundle/syntastic/syntax_checkers/ada/gcc.vim create mode 100644 bundle/syntastic/syntax_checkers/applescript/osacompile.vim create mode 100644 bundle/syntastic/syntax_checkers/c/checkpatch.vim create mode 100644 bundle/syntastic/syntax_checkers/c/gcc.vim create mode 100644 bundle/syntastic/syntax_checkers/c/make.vim create mode 100644 bundle/syntastic/syntax_checkers/c/sparse.vim create mode 100644 bundle/syntastic/syntax_checkers/c/splint.vim create mode 100644 bundle/syntastic/syntax_checkers/c/ycm.vim create mode 100644 bundle/syntastic/syntax_checkers/co/coco.vim create mode 100644 bundle/syntastic/syntax_checkers/coffee/coffee.vim create mode 100644 bundle/syntastic/syntax_checkers/coffee/coffeelint.vim create mode 100644 bundle/syntastic/syntax_checkers/coq/coqtop.vim create mode 100644 bundle/syntastic/syntax_checkers/cpp/cpplint.vim create mode 100644 bundle/syntastic/syntax_checkers/cpp/gcc.vim create mode 100644 bundle/syntastic/syntax_checkers/cpp/ycm.vim create mode 100644 bundle/syntastic/syntax_checkers/cs/mcs.vim create mode 100644 bundle/syntastic/syntax_checkers/css/csslint.vim create mode 100644 bundle/syntastic/syntax_checkers/css/phpcs.vim create mode 100644 bundle/syntastic/syntax_checkers/css/prettycss.vim create mode 100644 bundle/syntastic/syntax_checkers/cucumber/cucumber.vim create mode 100644 bundle/syntastic/syntax_checkers/cuda/nvcc.vim create mode 100644 bundle/syntastic/syntax_checkers/d/dmd.vim create mode 100644 bundle/syntastic/syntax_checkers/dart/dart_analyzer.vim create mode 100644 bundle/syntastic/syntax_checkers/docbk/xmllint.vim create mode 100644 bundle/syntastic/syntax_checkers/elixir/elixir.vim create mode 100644 bundle/syntastic/syntax_checkers/erlang/erlang.vim create mode 100755 bundle/syntastic/syntax_checkers/erlang/erlang_check_file.erl create mode 100644 bundle/syntastic/syntax_checkers/eruby/ruby.vim create mode 100644 bundle/syntastic/syntax_checkers/fortran/gfortran.vim create mode 100644 bundle/syntastic/syntax_checkers/gentoo_metadata/xmllint.vim create mode 100644 bundle/syntastic/syntax_checkers/go/go.vim create mode 100644 bundle/syntastic/syntax_checkers/go/gofmt.vim create mode 100644 bundle/syntastic/syntax_checkers/go/govet.vim create mode 100644 bundle/syntastic/syntax_checkers/haml/haml.vim create mode 100644 bundle/syntastic/syntax_checkers/haskell/ghc-mod.vim create mode 100644 bundle/syntastic/syntax_checkers/haskell/hdevtools.vim create mode 100644 bundle/syntastic/syntax_checkers/haxe/haxe.vim create mode 100644 bundle/syntastic/syntax_checkers/html/tidy.vim create mode 100644 bundle/syntastic/syntax_checkers/html/validator.vim create mode 100644 bundle/syntastic/syntax_checkers/html/validator_decode.awk create mode 100644 bundle/syntastic/syntax_checkers/html/w3.vim create mode 100644 bundle/syntastic/syntax_checkers/java/checkstyle.vim create mode 100644 bundle/syntastic/syntax_checkers/java/javac.vim create mode 100644 bundle/syntastic/syntax_checkers/javascript/closurecompiler.vim create mode 100644 bundle/syntastic/syntax_checkers/javascript/gjslint.vim create mode 100644 bundle/syntastic/syntax_checkers/javascript/jshint.vim create mode 100644 bundle/syntastic/syntax_checkers/javascript/jsl.vim create mode 100644 bundle/syntastic/syntax_checkers/javascript/jslint.vim create mode 100644 bundle/syntastic/syntax_checkers/json/jsonlint.vim create mode 100644 bundle/syntastic/syntax_checkers/json/jsonval.vim create mode 100644 bundle/syntastic/syntax_checkers/less/less-lint.coffee create mode 100644 bundle/syntastic/syntax_checkers/less/less-lint.js create mode 100644 bundle/syntastic/syntax_checkers/less/lessc.vim create mode 100644 bundle/syntastic/syntax_checkers/lisp/clisp.vim create mode 100644 bundle/syntastic/syntax_checkers/llvm/llvm.vim create mode 100644 bundle/syntastic/syntax_checkers/lua/luac.vim create mode 100644 bundle/syntastic/syntax_checkers/matlab/mlint.vim create mode 100644 bundle/syntastic/syntax_checkers/nasm/nasm.vim create mode 100644 bundle/syntastic/syntax_checkers/nroff/mandoc.vim create mode 100644 bundle/syntastic/syntax_checkers/objc/gcc.vim create mode 100644 bundle/syntastic/syntax_checkers/objc/ycm.vim create mode 100644 bundle/syntastic/syntax_checkers/ocaml/camlp4o.vim create mode 100644 bundle/syntastic/syntax_checkers/perl/efm_perl.pl create mode 100644 bundle/syntastic/syntax_checkers/perl/perl.vim create mode 100644 bundle/syntastic/syntax_checkers/perl/perlcritic.vim create mode 100644 bundle/syntastic/syntax_checkers/perl/podchecker.vim create mode 100644 bundle/syntastic/syntax_checkers/php/php.vim create mode 100644 bundle/syntastic/syntax_checkers/php/phpcs.vim create mode 100644 bundle/syntastic/syntax_checkers/php/phpmd.vim create mode 100644 bundle/syntastic/syntax_checkers/pod/podchecker.vim create mode 100644 bundle/syntastic/syntax_checkers/puppet/puppetlint.vim create mode 100644 bundle/syntastic/syntax_checkers/python/flake8.vim create mode 100644 bundle/syntastic/syntax_checkers/python/pep8.vim create mode 100644 bundle/syntastic/syntax_checkers/python/py3kwarn.vim create mode 100644 bundle/syntastic/syntax_checkers/python/pyflakes.vim create mode 100644 bundle/syntastic/syntax_checkers/python/pylint.vim create mode 100644 bundle/syntastic/syntax_checkers/python/python.vim create mode 100644 bundle/syntastic/syntax_checkers/rst/rst2pseudoxml.vim create mode 100644 bundle/syntastic/syntax_checkers/ruby/jruby.vim create mode 100644 bundle/syntastic/syntax_checkers/ruby/macruby.vim create mode 100644 bundle/syntastic/syntax_checkers/ruby/mri.vim create mode 100644 bundle/syntastic/syntax_checkers/ruby/rubocop.vim create mode 100644 bundle/syntastic/syntax_checkers/rust/rustc.vim create mode 100644 bundle/syntastic/syntax_checkers/sass/sass.vim create mode 100644 bundle/syntastic/syntax_checkers/scala/scalac.vim create mode 100644 bundle/syntastic/syntax_checkers/scss/sass.vim create mode 100644 bundle/syntastic/syntax_checkers/sh/checkbashisms.vim create mode 100644 bundle/syntastic/syntax_checkers/sh/sh.vim create mode 100644 bundle/syntastic/syntax_checkers/slim/slimrb.vim create mode 100644 bundle/syntastic/syntax_checkers/tcl/nagelfar.vim create mode 100644 bundle/syntastic/syntax_checkers/tex/chktex.vim create mode 100644 bundle/syntastic/syntax_checkers/tex/lacheck.vim create mode 100644 bundle/syntastic/syntax_checkers/twig/twiglint.vim create mode 100644 bundle/syntastic/syntax_checkers/typescript/tsc.vim create mode 100644 bundle/syntastic/syntax_checkers/vala/valac.vim create mode 100644 bundle/syntastic/syntax_checkers/vhdl/ghdl.vim create mode 100644 bundle/syntastic/syntax_checkers/xhtml/tidy.vim create mode 100644 bundle/syntastic/syntax_checkers/xml/xmllint.vim create mode 100644 bundle/syntastic/syntax_checkers/xslt/xmllint.vim create mode 100644 bundle/syntastic/syntax_checkers/yaml/jsyaml.vim create mode 100644 bundle/syntastic/syntax_checkers/z80/z80syntaxchecker.vim create mode 100644 bundle/syntastic/syntax_checkers/zpt/zptlint.vim create mode 100644 bundle/syntastic/syntax_checkers/zsh/zsh.vim diff --git a/.vimrc b/.vimrc index 92d61c22..f3466508 100755 --- a/.vimrc +++ b/.vimrc @@ -1,3 +1,7 @@ +"syntastic相关 +execute pathogen#infect() +let g:syntastic_python_checkers=['pylint'] +let g:syntastic_php_checkers=['php', 'phpcs', 'phpmd'] "golang "Processing... % (ctrl+c to stop) let g:fencview_autodetect=0 diff --git a/README.md b/README.md index 94007086..00a8e5e0 100755 --- a/README.md +++ b/README.md @@ -21,6 +21,7 @@ - 打开vim时不加文件名自动打开NERDTree - 关闭文件时没有其他文件自动退出NERDTree - ``可以快速打开和关闭vim +- 增加`syntastic`，在保存代码时自动检查代码中的错误 ## 2013年5月24日更新 diff --git a/autoload/pathogen.vim b/autoload/pathogen.vim new file mode 100644 index 00000000..87ef0b68 --- /dev/null +++ b/autoload/pathogen.vim @@ -0,0 +1,326 @@ +" pathogen.vim - path option manipulation +" Maintainer: Tim Pope +" Version: 2.2 + +" Install in ~/.vim/autoload (or ~\vimfiles\autoload). +" +" For management of individually installed plugins in ~/.vim/bundle (or +" ~\vimfiles\bundle), adding `call pathogen#infect()` to the top of your +" .vimrc is the only other setup necessary. +" +" The API is documented inline below. For maximum ease of reading, +" :set foldmethod=marker + +if exists("g:loaded_pathogen") || &cp + finish +endif +let g:loaded_pathogen = 1 + +function! s:warn(msg) + echohl WarningMsg + echomsg a:msg + echohl NONE +endfunction + +" Point of entry for basic default usage. Give a relative path to invoke +" pathogen#incubate() (defaults to "bundle/{}"), or an absolute path to invoke +" pathogen#surround(). For backwards compatibility purposes, a full path that +" does not end in {} or * is given to pathogen#runtime_prepend_subdirectories() +" instead. +function! pathogen#infect(...) abort " {{{1 + for path in a:0 ? reverse(copy(a:000)) : ['bundle/{}'] + if path =~# '^[^\\/]\+$' + call s:warn('Change pathogen#infect('.string(path).') to pathogen#infect('.string(path.'/{}').')') + call pathogen#incubate(path . '/{}') + elseif path =~# '^[^\\/]\+[\\/]\%({}\|\*\)$' + call pathogen#incubate(path) + elseif path =~# '[\\/]\%({}\|\*\)$' + call pathogen#surround(path) + else + call s:warn('Change pathogen#infect('.string(path).') to pathogen#infect('.string(path.'/{}').')') + call pathogen#surround(path . '/{}') + endif + endfor + call pathogen#cycle_filetype() + return '' +endfunction " }}}1 + +" Split a path into a list. +function! pathogen#split(path) abort " {{{1 + if type(a:path) == type([]) | return a:path | endif + let split = split(a:path,'\\\@"),'!isdirectory(v:val)')) && (!filereadable(dir.sep.'doc'.sep.'tags') || filewritable(dir.sep.'doc'.sep.'tags')) + silent! execute 'helptags' pathogen#fnameescape(dir.'/doc') + endif + endfor + endfor +endfunction " }}}1 + +command! -bar Helptags :call pathogen#helptags() + +" Execute the given command. This is basically a backdoor for --remote-expr. +function! pathogen#execute(...) abort " {{{1 + for command in a:000 + execute command + endfor + return '' +endfunction " }}}1 + +" Like findfile(), but hardcoded to use the runtimepath. +function! pathogen#runtime_findfile(file,count) abort "{{{1 + let rtp = pathogen#join(1,pathogen#split(&rtp)) + let file = findfile(a:file,rtp,a:count) + if file ==# '' + return '' + else + return fnamemodify(file,':p') + endif +endfunction " }}}1 + +" Backport of fnameescape(). +function! pathogen#fnameescape(string) abort " {{{1 + if exists('*fnameescape') + return fnameescape(a:string) + elseif a:string ==# '-' + return '\-' + else + return substitute(escape(a:string," \t\n*?[{`$\\%#'\"|!<"),'^[+>]','\\&','') + endif +endfunction " }}}1 + +if exists(':Vedit') + finish +endif + +let s:vopen_warning = 0 + +function! s:find(count,cmd,file,lcd) " {{{1 + let rtp = pathogen#join(1,pathogen#split(&runtimepath)) + let file = pathogen#runtime_findfile(a:file,a:count) + if file ==# '' + return "echoerr 'E345: Can''t find file \"".a:file."\" in runtimepath'" + endif + if !s:vopen_warning + let s:vopen_warning = 1 + let warning = '|echohl WarningMsg|echo "Install scriptease.vim to continue using :V'.a:cmd.'"|echohl NONE' + else + let warning = '' + endif + if a:lcd + let path = file[0:-strlen(a:file)-2] + execute 'lcd `=path`' + return a:cmd.' '.pathogen#fnameescape(a:file) . warning + else + return a:cmd.' '.pathogen#fnameescape(file) . warning + endif +endfunction " }}}1 + +function! s:Findcomplete(A,L,P) " {{{1 + let sep = pathogen#separator() + let cheats = { + \'a': 'autoload', + \'d': 'doc', + \'f': 'ftplugin', + \'i': 'indent', + \'p': 'plugin', + \'s': 'syntax'} + if a:A =~# '^\w[\\/]' && has_key(cheats,a:A[0]) + let request = cheats[a:A[0]].a:A[1:-1] + else + let request = a:A + endif + let pattern = substitute(request,'/\|\'.sep,'*'.sep,'g').'*' + let found = {} + for path in pathogen#split(&runtimepath) + let path = expand(path, ':p') + let matches = split(glob(path.sep.pattern),"\n") + call map(matches,'isdirectory(v:val) ? v:val.sep : v:val') + call map(matches,'expand(v:val, ":p")[strlen(path)+1:-1]') + for match in matches + let found[match] = 1 + endfor + endfor + return sort(keys(found)) +endfunction " }}}1 + +command! -bar -bang -range=1 -nargs=1 -complete=customlist,s:Findcomplete Ve :execute s:find(,'edit',,0) +command! -bar -bang -range=1 -nargs=1 -complete=customlist,s:Findcomplete Vedit :execute s:find(,'edit',,0) +command! -bar -bang -range=1 -nargs=1 -complete=customlist,s:Findcomplete Vopen :execute s:find(,'edit',,1) +command! -bar -bang -range=1 -nargs=1 -complete=customlist,s:Findcomplete Vsplit :execute s:find(,'split',,1) +command! -bar -bang -range=1 -nargs=1 -complete=customlist,s:Findcomplete Vvsplit :execute s:find(,'vsplit',,1) +command! -bar -bang -range=1 -nargs=1 -complete=customlist,s:Findcomplete Vtabedit :execute s:find(,'tabedit',,1) +command! -bar -bang -range=1 -nargs=1 -complete=customlist,s:Findcomplete Vpedit :execute s:find(,'pedit',,1) +command! -bar -bang -range=1 -nargs=1 -complete=customlist,s:Findcomplete Vread :execute s:find(,'read',,1) + +" vim:set et sw=2: diff --git a/bundle/syntastic/.gitignore b/bundle/syntastic/.gitignore new file mode 100644 index 00000000..cc07c931 --- /dev/null +++ b/bundle/syntastic/.gitignore @@ -0,0 +1,4 @@ +*~ +*.swp +tags +.DS_Store diff --git a/bundle/syntastic/CONTRIBUTING.md b/bundle/syntastic/CONTRIBUTING.md new file mode 100644 index 00000000..025814f7 --- /dev/null +++ b/bundle/syntastic/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 +additonal 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!). +* Dont use `l:` prefixes for variables unless actually required (i.e. almost never). +* Code for maintainabiliy. 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%.%#' +``` diff --git a/bundle/syntastic/LICENCE b/bundle/syntastic/LICENCE new file mode 100644 index 00000000..8b1a9d81 --- /dev/null +++ b/bundle/syntastic/LICENCE @@ -0,0 +1,13 @@ + DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE + Version 2, December 2004 + +Copyright (C) 2004 Sam Hocevar + +Everyone is permitted to copy and distribute verbatim or modified +copies of this license document, and changing it is allowed as long +as the name is changed. + + DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE + TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION + + 0. You just DO WHAT THE FUCK YOU WANT TO. diff --git a/bundle/syntastic/README.markdown b/bundle/syntastic/README.markdown new file mode 100644 index 00000000..7a28bd03 --- /dev/null +++ b/bundle/syntastic/README.markdown @@ -0,0 +1,165 @@ + , + / \,,_ .'| + ,{{| /}}}}/_.' _____________________________________________ + }}}}` '{{' '. / \ + {{{{{ _ ;, \ / Ladies and Gentlemen, \ + ,}}}}}} /o`\ ` ;) | | + {{{{{{ / ( | this is ... | + }}}}}} | \ | | + {{{{{{{{ \ \ | | + }}}}}}}}} '.__ _ | | _____ __ __ _ | + {{{{{{{{ /`._ (_\ / | / ___/__ ______ / /_____ ______/ /_(_)____ | + }}}}}}' | //___/ --=: \__ \/ / / / __ \/ __/ __ `/ ___/ __/ / ___/ | + jgs `{{{{` | '--' | ___/ / /_/ / / / / /_/ /_/ (__ ) /_/ / /__ | + }}}` | /____/\__, /_/ /_/\__/\__,_/____/\__/_/\___/ | + | /____/ | + | / + \_____________________________________________/ + + + + +Syntastic is a syntax checking plugin 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 ada, applescript, c, co, +coffee, coq, cpp, cs, css, cucumber, cuda, d, dart, docbk, elixir, erlang, eruby, fortran, +gentoo_metadata, go, haml, haskell, haxe, html, java, javascript, json, less, lisp, lua, matlab, +nasm, objc, ocaml, perl, php, puppet, python, rst, ruby, rust, sass/scss, scala, sh, slim, tcl, tex, +twig, typescript, vala, vhdl, xhtml, xml, xslt, yaml, z80, zpt, zsh + +Screenshot +---------- + +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](https://github.com/scrooloose/syntastic/raw/master/_assets/screenshot_1.png) + +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. + +Installation +------------ + +Installing syntastic is easy but first you need to have the pathogen plugin installed. If you already +have pathogen working then skip Step 1 and go to Step 2. + +Step 1: Install pathogen.vim +---------------------------- + +First I'll show you how to install tpope's [pathogen.vim](https://github.com/tpope/vim-pathogen) so that +it's easy to install syntastic. Do this in your Terminal so that you get the pathogen.vim file +and the directories it needs: + + 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: + + execute pathogen#infect() + +Step 2: Install syntastic as a pathogen bundle +---------------------------------------------- + +You now have pathogen installed and can put syntastic into ~/.vim/bundle like this: + + + cd ~/.vim/bundle + git clone https://github.com/scrooloose/syntastic.git + +Quit vim and start it back up to reload it, then type: + + :Helptags + +If you get an error when you do this, then you probably didn't install pathogen right. Go back to +step 1 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. + + +Google group +------------ + +To get information or make suggestions check out the [google group](https://groups.google.com/group/vim-syntastic). + + +FAQ +--- + +__Q. I installed syntastic but it isn't reporting any errors ...__ + +A. The most likely reason is that the syntax checker that it requires isn't installed. For example: python requires either `flake8`, `pyflakes` or `pylint` to be installed and in `$PATH`. To see which executable is required, just look in `syntax_checkers/.vim`. Note that aliases do not work; the actual executable must be available in your `$PATH`. Symbolic links are okay. + +Another reason it could fail is that the error output for the 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. Recently some of my syntax checker options have stopped working...__ + +A. The options are still there, they have just been renamed. Recently, almost all syntax checkers were refactored to use the new `syntastic#makeprg#build()` function. This made a lot of the old explicit options redundant - as they are now implied. The new implied options usually have slightly different names to the old options. + +e.g. Previously there was `g:syntastic_phpcs_conf`, now you must use `g:syntastic_php_phpcs_args`. + +See `:help syntastic-checker-options` for more information. + +__Q. How can I pass additional arguments to a checker?__ + +A. Almost all syntax checkers use the `syntastic#makeprg#build()` function. Those checkers that do can be configured using global variables. The general form of the global args variables are: + +`syntastic_[filetype]_[subchecker]_args` + +So, If you wanted to pass "--my --args --here" to the ruby mri checker you would add this line to your vimrc: + +`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: + +`let g:syntastic__checkers=['']` + +To see the list of checkers for your filetype, look in `syntax_checkers//`. + +e.g. Python has the following checkers: `flake8`, `pyflakes`, `pylint` and a native `python` checker. + +To tell syntastic to use `pylint`, you would use this setting: + +`let g:syntastic_python_checkers=['pylint']` + +Some filetypes, like PHP, have style checkers as well as syntax checkers. These can be chained together like this: + +`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](https://github.com/tpope/vim-unimpaired) - 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 syntax checker integration file (e.g. `syntax_checkers/php.vim`) to see what options are available. + +__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 :lclose:bdelete +cabbrev bd lclose\|bdelete +``` diff --git a/bundle/syntastic/_assets/screenshot_1.png b/bundle/syntastic/_assets/screenshot_1.png new file mode 100644 index 0000000000000000000000000000000000000000..c1b69f4ba26a2092aa4e9d42d2fa3ee08c6ab28a GIT binary patch literal 92425 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 /tmp/output +" +"To generate this you would call: +" +" let makeprg = syntastic#makeprg#build({ +" \ 'exe': 'ruby', +" \ 'args': '-a -b -c', +" \ 'post_args': '--more --args', +" \ 'tail': '> /tmp/output', +" \ 'subchecker': 'mri' }) +" +"Note that the current filename is added by default - but can be overridden by +"passing in an 'fname' arg. +" +"All options can be overriden by the user with global variables - even when +"not specified by the checker in syntastic#makeprg#build(). +" +"E.g. They could override the checker exe with +" +" let g:syntastic_ruby_mri_exe="another_ruby_checker_exe.rb" +" +"The general form of the override option is: +" syntastic_[filetype]_[subchecker]_[option-name] +" +function! syntastic#makeprg#build(opts) + let builder = g:SyntasticMakeprgBuilder.New( + \ get(a:opts, 'exe', ''), + \ get(a:opts, 'args', ''), + \ get(a:opts, 'fname', ''), + \ get(a:opts, 'post_args', ''), + \ get(a:opts, 'tail', ''), + \ get(a:opts, 'subchecker', '') ) + + return builder.makeprg() +endfunction diff --git a/bundle/syntastic/autoload/syntastic/postprocess.vim b/bundle/syntastic/autoload/syntastic/postprocess.vim new file mode 100644 index 00000000..188a28a4 --- /dev/null +++ b/bundle/syntastic/autoload/syntastic/postprocess.vim @@ -0,0 +1,58 @@ +if exists("g:loaded_syntastic_postprocess_autoload") + finish +endif +let g:loaded_syntastic_postprocess_autoload = 1 + +let s:save_cpo = &cpo +set cpo&vim + +function! s:compareErrorItems(a, b) + if a:a['bufnr'] != a:b['bufnr'] + " group by files + return a:a['bufnr'] - a:b['bufnr'] + elseif a:a['lnum'] != a:b['lnum'] + return a:a['lnum'] - a:b['lnum'] + elseif a:a['type'] !=? a:b['type'] + " errors take precedence over warnings + return a:a['type'] ==? 'e' ? -1 : 1 + else + return get(a:a, 'col') - get(a:b, 'col') + endif +endfunction + +" natural sort +function! syntastic#postprocess#sort(errors) + return sort(a:errors, 's:compareErrorItems') +endfunction + +function syntastic#postprocess#compressWhitespace(errors) + let llist = [] + + for e in a:errors + let e['text'] = substitute(e['text'], '\n', ' ', 'g') + let e['text'] = substitute(e['text'], '\s\{2,}', ' ', 'g') + call add(llist, e) + endfor + + return llist +endfunction + +" remove spurious CR under Cygwin +function! syntastic#postprocess#cygwinRemoveCR(errors) + if has('win32unix') + let llist = [] + + for e in a:errors + let e['text'] = substitute(e['text'], '\r', '', 'g') + call add(llist, e) + endfor + else + let llist = a:errors + endif + + return llist +endfunction + +let &cpo = s:save_cpo +unlet s:save_cpo +" vim: set et sts=4 sw=4: diff --git a/bundle/syntastic/autoload/syntastic/util.vim b/bundle/syntastic/autoload/syntastic/util.vim new file mode 100644 index 00000000..e68f6c95 --- /dev/null +++ b/bundle/syntastic/autoload/syntastic/util.vim @@ -0,0 +1,146 @@ +if exists("g:loaded_syntastic_util_autoload") + finish +endif +let g:loaded_syntastic_util_autoload = 1 + +let s:save_cpo = &cpo +set cpo&vim + +if !exists("g:syntastic_debug") + let g:syntastic_debug = 0 +endif + +let s:deprecationNoticesIssued = [] + +function! syntastic#util#DevNull() + if has('win32') + return 'NUL' + endif + return '/dev/null' +endfunction + +"search the first 5 lines of the file for a magic number and return a map +"containing the args and the executable +" +"e.g. +" +"#!/usr/bin/perl -f -bar +" +"returns +" +"{'exe': '/usr/bin/perl', 'args': ['-f', '-bar']} +function! syntastic#util#parseShebang() + for lnum in range(1,5) + let line = getline(lnum) + + if line =~ '^#!' + let exe = matchstr(line, '^#!\s*\zs[^ \t]*') + let args = split(matchstr(line, '^#!\s*[^ \t]*\zs.*')) + return {'exe': exe, 'args': args} + endif + endfor + + return {'exe': '', 'args': []} +endfunction + +" Verify that the 'installed' version is at the 'required' version, if not +" better. +" +" 'installed' and 'required' must be arrays. Only the +" first three elements (major, minor, patch) are looked at. +" +" Either array may be less than three elements. The "missing" elements +" will be assumed to be '0' for the purposes of checking. +" +" See http://semver.org for info about version numbers. +function! syntastic#util#versionIsAtLeast(installed, required) + for index in [0,1,2] + if len(a:installed) <= index + let installed_element = 0 + else + let installed_element = a:installed[index] + endif + if len(a:required) <= index + let required_element = 0 + else + let required_element = a:required[index] + endif + if installed_element != required_element + return installed_element > required_element + endif + endfor + " Everything matched, so it is at least the required version. + return 1 +endfunction + +"print as much of a:msg as possible without "Press Enter" prompt appearing +function! syntastic#util#wideMsg(msg) + let old_ruler = &ruler + let old_showcmd = &showcmd + + "convert tabs to spaces so that the tabs count towards the window width + "as the proper amount of characters + let msg = substitute(a:msg, "\t", repeat(" ", &tabstop), "g") + let msg = strpart(msg, 0, winwidth(0)-1) + + "This is here because it is possible for some error messages to begin with + "\n which will cause a "press enter" prompt. I have noticed this in the + "javascript:jshint checker and have been unable to figure out why it + "happens + let msg = substitute(msg, "\n", "", "g") + + set noruler noshowcmd + redraw + + echo msg + + let &ruler=old_ruler + let &showcmd=old_showcmd +endfunction + +" Check whether a buffer is loaded, listed, and not hidden +function! syntastic#util#bufIsActive(buffer) + " convert to number, or hell breaks loose + let buf = str2nr(a:buffer) + + if !bufloaded(buf) || !buflisted(buf) + return 0 + endif + + " get rid of hidden buffers + for tab in range(1, tabpagenr('$')) + if index(tabpagebuflist(tab), buf) >= 0 + return 1 + endif + endfor + + return 0 +endfunction + +" Returns unique elements in a list +function! syntastic#util#unique(list) + let seen = {} + for e in a:list + let seen[e] = 1 + endfor + return copy(keys(seen)) +endfunction + +function! syntastic#util#debug(msg) + if g:syntastic_debug + echomsg "syntastic: debug: " . a:msg + endif +endfunction + +function! syntastic#util#deprecationWarn(msg) + if index(s:deprecationNoticesIssued, a:msg) >= 0 + return + endif + + call add(s:deprecationNoticesIssued, a:msg) + echomsg "syntastic: warning: " . a:msg +endfunction + +let &cpo = s:save_cpo +unlet s:save_cpo +" vim: set et sts=4 sw=4: diff --git a/bundle/syntastic/doc/syntastic.txt b/bundle/syntastic/doc/syntastic.txt new file mode 100644 index 00000000..6e005a71 --- /dev/null +++ b/bundle/syntastic/doc/syntastic.txt @@ -0,0 +1,428 @@ +*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| + 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| + 3.Commands................................|syntastic-commands| + 4.Global Options..........................|syntastic-global-options| + 5.Checker Options.........................|syntastic-checker-options| + 6.About...................................|syntastic-about| + 7.License.................................|syntastic-license| + + +============================================================================== +1. Intro *syntastic-intro* + +Note: This doc only deals with using syntastic. To learn how to write syntax +checker integrations, see the guide on the github wiki: + + https://github.com/scrooloose/syntastic/wiki/Syntax-Checker-Guide + +Syntastic is a syntax checking plugin that runs files through external syntax +checkers. This can be done on demand, or automatically as files are saved and +opened. If syntax errors are detected, the user is notified and is happy +because they didn't have to compile their code or execute their script to find +them. + +Syntastic comes in two parts: the syntax checker plugins, and the core. The +syntax checker plugins are defined on a per-filetype basis where each one wraps +up an external syntax checking program. The core script delegates off to these +plugins and uses their output to provide the syntastic functionality. + +Take a look in the syntax_checkers directory for a list of supported filetypes +and checkers. + + +============================================================================== +2. Functionality provided *syntastic-functionality* + +Syntax checking can be done automatically or on demand (see +|'syntastic_mode_map'| 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 compiled in) can be used to display error messages for + erroneous lines when hovering the mouse over them. + + +------------------------------------------------------------------------------ +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. + + +============================================================================== +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. Useful in passive mode, or if the +current filetype is set to passive. See |'syntastic_mode_map'| for more info. + +:SyntasticInfo *:SyntasticInfo* + +Output info about what checkers are available and in use for the current +filetype. + + +============================================================================== +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_echo_current_error'* +Default: 1 +If enabled, syntastic will echo the errror 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 symobls can be customized: + syntastic_error_symbol - For syntax errors, defaults to '>>' + syntastic_style_error_symbol - For style errors, defaults to 'S>' + syntastic_warning_symbol - For syntax warnings, defaults to '>>' + syntastic_style_warning_symbol - For style warnings, defaults to 'S>' + +Example: > + let g:syntastic_error_symbol='✗' + let g:syntastic_warning_symbol='⚠' +< + + *'syntastic_enable_balloons'* +Default: 1 +Use this option to tell syntastic whether to display error messages in balloons +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 loclist: > + let g:syntastic_always_populate_loc_list=1 +< + *'syntastic_auto_jump'* +Default: 0 +Enable this option if you want the cursor to jump to the first detected error +when saving or opening a file: > + let g:syntastic_auto_jump=1 +< + + *'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 neither check, nor +include in error lists. It has to be a list of |regular-expression| patterns. +The full paths of files (see |::p|) are matched against these patterns, and +the matches are case sensitive. Use |\c| if you need case insensitive +patterns. > + let g:syntastic_ignore_files=['^/usr/include/', '\c\.h$'] +< + + *'syntastic_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_warnings'* + +Use this option if you only care about syntax errors, not warnings. When set, +this option has the following effects: + * no |signs| appear unless there is at least one error, whereupon both + errors and warnings are displayed + * the |'syntastic_auto_loc_list'| option only pops up the error window if + there's at least one error, whereupon both errors and warnings are + displayed +> + let g:syntastic_quiet_warnings=1 +< + + *'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 cant 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] +< + +============================================================================== +5. Checker Options *syntastic-checker-options* + +------------------------------------------------------------------------------ +5.1 Telling syntastic which checker to use. + +Stick a line like this in your vimrc: > + let g:syntastic__checkers = [''] +< +e.g. > + let g:syntastic_python_checkers = ['flake8'] +< + +There's also a per-buffer version of this setting, b:syntastic_checkers. Use +this in an autocmd to configure specific checkers for particular paths: > + autocmd FileType python if stridx(expand('%:p'), '/some/path/') == 0 | + \ let b:syntastic_checkers = ['pylint'] | endif +< + +To see the list of available checkers for your filetype, look in +`syntax_checkers//`. The names of the files here correspond to +'' above. + +e.g. Python has the following checkers: flake8, pyflakes, pylint and a +native python checker. + +Some filetypes, like PHP, have style checkers as well as syntax checkers. These +can be chained together like this: > + let g:syntastic_php_checkers=['php', 'phpcs', 'phpmd']` +< +This is telling syntastic to run the 'php' checker first, and if no errors are +found, run 'phpcs', and then 'phpmd'. + +------------------------------------------------------------------------------ +5.2 Configuring specific checkers *syntastic-config-makeprg* + +Most checkers use the 'syntastic#makeprg#build()' function and provide many +options by default - in fact you can customise every part of the command +that gets called. + +Checkers that use 'syntastic#makeprg#build()' look like this: > + let makeprg = syntastic#makeprg#build({ + \ 'exe': 'ruby', + \ 'args': '-a -b -c', + \ 'post_args': '--more --args', + \ 'tail': '> /tmp/output', + \ 'subchecker': 'mri' }) +< + +All of the parameters above can be overriden by setting global variables - +even parameters not specified in the call to syntastic#makeprg#build(). + +E.g. To override the checker exe above, you could do this: > + let g:syntastic_ruby_mri_exe="another_ruby_checker_exe.rb" +< +To override the args and the tail: > + let g:syntastic_ruby_mri_args="--my --args --here" + let g:syntastic_ruby_mri_tail="> /tmp/my-output-file-biatch" +< + +The general form of the override options is: > + syntastic_[filetype]_[subchecker]_[option-name] +< + +For checkers that do not use the 'syntastic#makeprg#build()' function you +will have to look at the source code of the checker in question. If there are +specific options that can be set, these are usually documented at the top of +the script. + +============================================================================== +6. About *syntastic-about* + +The core maintainers of syntastic are: + Martin Grenfell (github: scrooloose) + Gregor Uhlenheuer (github: kongo2002) + +Find the latest version of syntastic here: + http://github.com/scrooloose/syntastic + +============================================================================== +7. License *syntastic-license* + +Syntastic is released under the wtfpl. +See http://sam.zoy.org/wtfpl/COPYING. + + vim:tw=78:sw=4:ft=help:norl: diff --git a/bundle/syntastic/plugin/syntastic.vim b/bundle/syntastic/plugin/syntastic.vim new file mode 100644 index 00000000..8fa4745d --- /dev/null +++ b/bundle/syntastic/plugin/syntastic.vim @@ -0,0 +1,389 @@ +"============================================================================ +"File: syntastic.vim +"Description: Vim plugin for on the fly syntax checking. +"Version: 3.0.0 +"Released On: 13 April, 2013 +"License: This program is free software. It comes without any warranty, +" to the extent permitted by applicable law. You can redistribute +" it and/or modify it under the terms of the Do What The Fuck You +" 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 + +runtime! plugin/syntastic/*.vim + +let s:running_windows = has("win16") || has("win32") + +if !exists("g:syntastic_always_populate_loc_list") + let g:syntastic_always_populate_loc_list = 0 +endif + +if !exists("g:syntastic_auto_jump") + let syntastic_auto_jump=0 +endif + +if !exists("g:syntastic_quiet_warnings") + let g:syntastic_quiet_warnings = 0 +endif + +if !exists("g:syntastic_stl_format") + let g:syntastic_stl_format = '[Syntax: line:%F (%t)]' +endif + +if !exists("g:syntastic_check_on_open") + let g:syntastic_check_on_open = 0 +endif + +if !exists("g:syntastic_check_on_wq") + let g:syntastic_check_on_wq = 1 +endif + +if !exists("g:syntastic_loc_list_height") + let g:syntastic_loc_list_height = 10 +endif + +if !exists("g:syntastic_ignore_files") + let g:syntastic_ignore_files = [] +endif + +let s:registry = g:SyntasticRegistry.Instance() +let s:notifiers = g:SyntasticNotifiers.New() +let s:modemap = g:SyntasticModeMap.Instance() + +function! s:CompleteCheckerName(argLead, cmdLine, cursorPos) + let checker_names = [] + for ft in s:CurrentFiletypes() + for checker in s:registry.availableCheckersFor(ft) + call add(checker_names, checker.name()) + endfor + endfor + return join(checker_names, "\n") +endfunction + +command! SyntasticToggleMode call s:ToggleMode() +command! -nargs=? -complete=custom,s:CompleteCheckerName SyntasticCheck call s:UpdateErrors(0, ) call s:Redraw() +command! Errors call s:ShowLocList() +command! SyntasticInfo call s:registry.echoInfoFor(&ft) + +highlight link SyntasticError SpellBad +highlight link SyntasticWarning SpellCap + +augroup syntastic + autocmd BufReadPost * if g:syntastic_check_on_open | call s:UpdateErrors(1) | endif + autocmd BufWritePost * call s:UpdateErrors(1) + + autocmd BufWinEnter * call s:BufWinEnterHook() + + " TODO: the next autocmd should be "autocmd BufWinLeave * if empty(&bt) | lclose | endif" + " but in recent versions of Vim lclose can no longer be called from BufWinLeave + autocmd BufEnter * call s:BufEnterHook() +augroup END + +if v:version > 703 || (v:version == 703 && has('patch544')) + " QuitPre was added in Vim 7.3.544 + augroup syntastic + autocmd QuitPre * call s:QuitPreHook() + augroup END +endif + + +function! s:BufWinEnterHook() + if empty(&bt) + let loclist = g:SyntasticLoclist.current() + call g:SyntasticAutoloclistNotifier.AutoToggle(loclist) + call g:SyntasticHighlightingNotifier.refresh(loclist) + endif +endfunction + +function! s:BufEnterHook() + " TODO: at this point there is no b:syntastic_loclist + let loclist = filter(getloclist(0), 'v:val["valid"] == 1') + let buffers = syntastic#util#unique(map( loclist, 'v:val["bufnr"]' )) + if &bt=='quickfix' && !empty(loclist) && empty(filter( buffers, 'syntastic#util#bufIsActive(v:val)' )) + call g:SyntasticLoclistHide() + endif +endfunction + + +function! s:QuitPreHook() + let b:syntastic_skip_checks = !g:syntastic_check_on_wq + call g:SyntasticLoclistHide() +endfunction + +"refresh and redraw all the error info for this buf when saving or reading +function! s:UpdateErrors(auto_invoked, ...) + if s:SkipFile() + return + endif + + if !a:auto_invoked || s:modemap.allowsAutoChecking(&filetype) + if a:0 >= 1 + call s:CacheErrors(a:1) + else + call s:CacheErrors() + endif + end + + let loclist = g:SyntasticLoclist.current() + call s:notifiers.refresh(loclist) + + if (g:syntastic_always_populate_loc_list || g:syntastic_auto_jump) && loclist.hasErrorsOrWarningsToDisplay() + call setloclist(0, loclist.filteredRaw()) + if g:syntastic_auto_jump + silent! lrewind + endif + endif +endfunction + +"clear the loc list for the buffer +function! s:ClearCache() + call s:notifiers.reset(g:SyntasticLoclist.current()) + unlet! b:syntastic_loclist +endfunction + +function! s:CurrentFiletypes() + "sub - for _ in filetypes otherwise we cant name syntax checker + "functions legally for filetypes like "gentoo-metadata" + let fts = substitute(&ft, '-', '_', 'g') + return split(fts, '\.') +endfunction + +"detect and cache all syntax errors in this buffer +function! s:CacheErrors(...) + call s:ClearCache() + let newLoclist = g:SyntasticLoclist.New([]) + + if !s:SkipFile() + for ft in s:CurrentFiletypes() + if a:0 + let checker = s:registry.getChecker(ft, a:1) + if !empty(checker) + let checkers = [checker] + endif + else + let checkers = s:registry.getActiveCheckers(ft) + endif + + for checker in checkers + call syntastic#util#debug("CacheErrors: Invoking checker: " . checker.name()) + + let loclist = checker.getLocList() + + if !loclist.isEmpty() + let newLoclist = newLoclist.extend(loclist) + + "only get errors from one checker at a time + break + endif + endfor + endfor + endif + + let b:syntastic_loclist = newLoclist +endfunction + +function! s:ToggleMode() + call s:modemap.toggleMode() + call s:ClearCache() + call s:UpdateErrors(1) + call s:modemap.echoMode() +endfunction + +"display the cached errors for this buf in the location list +function! s:ShowLocList() + let loclist = g:SyntasticLoclist.current() + call loclist.show() +endfunction + +"the script changes &shellpipe and &shell to stop the screen flicking when +"shelling out to syntax checkers. Not all OSs support the hacks though +function! s:OSSupportsShellpipeHack() + return !s:running_windows && executable('/bin/bash') && (s:uname() !~ "FreeBSD") && (s:uname() !~ "OpenBSD") +endfunction + +function! s:IsRedrawRequiredAfterMake() + return !s:running_windows && (s:uname() =~ "FreeBSD" || s:uname() =~ "OpenBSD") +endfunction + +"Redraw in a way that doesnt make the screen flicker or leave anomalies behind. +" +"Some terminal versions of vim require `redraw!` - otherwise there can be +"random anomalies left behind. +" +"However, on some versions of gvim using `redraw!` causes the screen to +"flicker - so use redraw. +function! s:Redraw() + if has('gui_running') || has('gui_macvim') + redraw + else + redraw! + endif +endfunction + +function! s:IgnoreFile(filename) + let fname = fnamemodify(a:filename, ':p') + for p in g:syntastic_ignore_files + if fname =~# p + return 1 + endif + endfor + return 0 +endfunction + +" Skip running in special buffers +function! s:SkipFile() + let force_skip = exists('b:syntastic_skip_checks') ? b:syntastic_skip_checks : 0 + let fname = expand('%') + return force_skip || !empty(&buftype) || !filereadable(fname) || getwinvar(0, '&diff') || s:IgnoreFile(fname) +endfunction + +function! s:uname() + if !exists('s:uname') + let s:uname = system('uname') + endif + return s:uname +endfunction + +"return a string representing the state of buffer according to +"g:syntastic_stl_format +" +"return '' if no errors are cached for the buffer +function! SyntasticStatuslineFlag() + let loclist = g:SyntasticLoclist.current() + let issues = loclist.filteredRaw() + let num_issues = loclist.length() + if loclist.hasErrorsOrWarningsToDisplay() + let errors = loclist.errors() + let warnings = loclist.warnings() + + let num_errors = len(errors) + let num_warnings = len(warnings) + + let output = g:syntastic_stl_format + + "hide stuff wrapped in %E(...) unless there are errors + let output = substitute(output, '\C%E{\([^}]*\)}', num_errors ? '\1' : '' , 'g') + + "hide stuff wrapped in %W(...) unless there are warnings + let output = substitute(output, '\C%W{\([^}]*\)}', num_warnings ? '\1' : '' , 'g') + + "hide stuff wrapped in %B(...) unless there are both errors and warnings + let output = substitute(output, '\C%B{\([^}]*\)}', (num_warnings && num_errors) ? '\1' : '' , 'g') + + + "sub in the total errors/warnings/both + let output = substitute(output, '\C%w', num_warnings, 'g') + let output = substitute(output, '\C%e', num_errors, 'g') + let output = substitute(output, '\C%t', num_issues, 'g') + + "first error/warning line num + let output = substitute(output, '\C%F', num_issues ? issues[0]['lnum'] : '', 'g') + + "first error line num + let output = substitute(output, '\C%fe', num_errors ? errors[0]['lnum'] : '', 'g') + + "first warning line num + let output = substitute(output, '\C%fw', num_warnings ? warnings[0]['lnum'] : '', 'g') + + return output + else + return '' + endif +endfunction + +"A wrapper for the :lmake command. Sets up the make environment according to +"the options given, runs make, resets the environment, returns the location +"list +" +"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 +" 'postprocess' - a list of functions to be applied to the error list +function! SyntasticMake(options) + call syntastic#util#debug('SyntasticMake: called with options: '. string(a:options)) + + let old_loclist = getloclist(0) + let old_makeprg = &l:makeprg + let old_shellpipe = &shellpipe + let old_shell = &shell + let old_errorformat = &l:errorformat + + if s:OSSupportsShellpipeHack() + "this is a hack to stop the screen needing to be ':redraw'n when + "when :lmake is run. Otherwise the screen flickers annoyingly + let &shellpipe='&>' + let &shell = '/bin/bash' + endif + + if has_key(a:options, 'makeprg') + let &l:makeprg = a:options['makeprg'] + endif + + if has_key(a:options, 'errorformat') + let &l:errorformat = a:options['errorformat'] + endif + + silent lmake! + let errors = getloclist(0) + + call setloclist(0, old_loclist) + let &l:makeprg = old_makeprg + let &l:errorformat = old_errorformat + let &shellpipe=old_shellpipe + let &shell=old_shell + + if s:IsRedrawRequiredAfterMake() + call s:Redraw() + endif + + if has_key(a:options, 'defaults') + call SyntasticAddToErrors(errors, a:options['defaults']) + endif + + " Apply ignore patterns + let ignore = {} + for buf in syntastic#util#unique(map(copy(errors), 'v:val["bufnr"]')) + let ignore[buf] = s:IgnoreFile(bufname(str2nr(buf))) + endfor + call filter(errors, '!ignore[v:val["bufnr"]]') + + " Add subtype info if present. + if has_key(a:options, 'subtype') + call SyntasticAddToErrors(errors, {'subtype': a:options['subtype']}) + endif + + if has_key(a:options, 'postprocess') && !empty(a:options['postprocess']) + for rule in a:options['postprocess'] + let errors = call('syntastic#postprocess#' . rule, [errors]) + endfor + endif + + return errors +endfunction + +"take a list of errors and add default values to them from a:options +function! SyntasticAddToErrors(errors, options) + for i in range(0, len(a:errors)-1) + for key in keys(a:options) + if !has_key(a:errors[i], key) || empty(a:errors[i][key]) + let a:errors[i][key] = a:options[key] + endif + endfor + endfor + return a:errors +endfunction + +" vim: set et sts=4 sw=4: diff --git a/bundle/syntastic/plugin/syntastic/autoloclist.vim b/bundle/syntastic/plugin/syntastic/autoloclist.vim new file mode 100644 index 00000000..9a1a018f --- /dev/null +++ b/bundle/syntastic/plugin/syntastic/autoloclist.vim @@ -0,0 +1,38 @@ +if exists("g:loaded_syntastic_notifier_autoloclist") + finish +endif +let g:loaded_syntastic_notifier_autoloclist = 1 + +if !exists("g:syntastic_auto_loc_list") + let g:syntastic_auto_loc_list = 2 +endif + +let g:SyntasticAutoloclistNotifier = {} + +" Public methods {{{1 +" +function! g:SyntasticAutoloclistNotifier.New() + let newObj = copy(self) + return newObj +endfunction + +function! g:SyntasticAutoloclistNotifier.refresh(loclist) + call g:SyntasticAutoloclistNotifier.AutoToggle(a:loclist) +endfunction + +function! g:SyntasticAutoloclistNotifier.AutoToggle(loclist) + if a:loclist.hasErrorsOrWarningsToDisplay() + if g:syntastic_auto_loc_list == 1 + call a:loclist.show() + endif + else + if g:syntastic_auto_loc_list > 0 + + "TODO: this will close the loc list window if one was opened by + "something other than syntastic + lclose + endif + endif +endfunction + +" vim: set sw=4 sts=4 et fdm=marker: diff --git a/bundle/syntastic/plugin/syntastic/balloons.vim b/bundle/syntastic/plugin/syntastic/balloons.vim new file mode 100644 index 00000000..c98cb170 --- /dev/null +++ b/bundle/syntastic/plugin/syntastic/balloons.vim @@ -0,0 +1,60 @@ +if exists("g:loaded_syntastic_notifier_balloons") + finish +endif +let g:loaded_syntastic_notifier_balloons = 1 + +if !exists("g:syntastic_enable_balloons") + let g:syntastic_enable_balloons = 1 +endif + +if !has('balloon_eval') + let g:syntastic_enable_balloons = 0 +endif + +let g:SyntasticBalloonsNotifier = {} + +" Public methods {{{1 + +function! g:SyntasticBalloonsNotifier.New() + let newObj = copy(self) + return newObj +endfunction + +function! g:SyntasticBalloonsNotifier.enabled() + return exists('b:syntastic_enable_balloons') ? b:syntastic_enable_balloons : g:syntastic_enable_balloons +endfunction + +" Update the error balloons +function! g:SyntasticBalloonsNotifier.refresh(loclist) + let b:syntastic_balloons = {} + if a:loclist.hasErrorsOrWarningsToDisplay() + let buf = bufnr('') + let issues = filter(a:loclist.filteredRaw(), 'v:val["bufnr"] == buf') + if !empty(issues) + for i in issues + if has_key(b:syntastic_balloons, i['lnum']) + let b:syntastic_balloons[i['lnum']] .= "\n" . i['text'] + else + let b:syntastic_balloons[i['lnum']] = i['text'] + endif + endfor + set beval bexpr=SyntasticBalloonsExprNotifier() + endif + endif +endfunction + +" Reset the error balloons +function! g:SyntasticBalloonsNotifier.reset(loclist) + set nobeval +endfunction + +" Private functions {{{1 + +function! SyntasticBalloonsExprNotifier() + if !exists('b:syntastic_balloons') + return '' + endif + return get(b:syntastic_balloons, v:beval_lnum, '') +endfunction + +" vim: set sw=4 sts=4 et fdm=marker: diff --git a/bundle/syntastic/plugin/syntastic/checker.vim b/bundle/syntastic/plugin/syntastic/checker.vim new file mode 100644 index 00000000..51dc0c80 --- /dev/null +++ b/bundle/syntastic/plugin/syntastic/checker.vim @@ -0,0 +1,71 @@ +if exists("g:loaded_syntastic_checker") + finish +endif +let g:loaded_syntastic_checker = 1 + +let g:SyntasticChecker = {} + +" Public methods {{{1 + +function! g:SyntasticChecker.New(args) + let newObj = copy(self) + + let newObj._filetype = a:args['filetype'] + let newObj._name = a:args['name'] + + + let prefix = 'SyntaxCheckers_' . newObj._filetype . '_' . newObj._name . '_' + let newObj._locListFunc = function(prefix . 'GetLocList') + let newObj._isAvailableFunc = function(prefix . 'IsAvailable') + + if exists('*' . prefix . 'GetHighlightRegex') + let newObj._highlightRegexFunc = function(prefix. 'GetHighlightRegex') + else + let newObj._highlightRegexFunc = '' + endif + + return newObj +endfunction + +function! g:SyntasticChecker.filetype() + return self._filetype +endfunction + +function! g:SyntasticChecker.name() + return self._name +endfunction + +function! g:SyntasticChecker.getLocList() + let list = self._locListFunc() + call self._populateHighlightRegexes(list) + return g:SyntasticLoclist.New(list) +endfunction + +function! g:SyntasticChecker.getHighlightRegexFor(error) + if empty(self._highlightRegexFunc) + return [] + endif + + return self._highlightRegexFunc(error) +endfunction + +function! g:SyntasticChecker.isAvailable() + return self._isAvailableFunc() +endfunction + +function! g:SyntasticChecker._populateHighlightRegexes(list) + let list = a:list + if !empty(self._highlightRegexFunc) + for i in range(0, len(list)-1) + if list[i]['valid'] + let term = self._highlightRegexFunc(list[i]) + if len(term) > 0 + let list[i]['hl'] = term + endif + endif + endfor + endif + return list +endfunction + +" vim: set sw=4 sts=4 et fdm=marker: diff --git a/bundle/syntastic/plugin/syntastic/cursor.vim b/bundle/syntastic/plugin/syntastic/cursor.vim new file mode 100644 index 00000000..11a2e559 --- /dev/null +++ b/bundle/syntastic/plugin/syntastic/cursor.vim @@ -0,0 +1,59 @@ +if exists("g:loaded_syntastic_notifier_cursor") + finish +endif +let g:loaded_syntastic_notifier_cursor = 1 + +if !exists('g:syntastic_echo_current_error') + let g:syntastic_echo_current_error = 1 +endif + +let g:SyntasticCursorNotifier = {} + +" Public methods {{{1 + +function! g:SyntasticCursorNotifier.New() + let newObj = copy(self) + return newObj +endfunction + +function! g:SyntasticCursorNotifier.refresh(loclist) + autocmd! syntastic CursorMoved + let enabled = exists('b:syntastic_echo_current_error') ? b:syntastic_echo_current_error : g:syntastic_echo_current_error + if enabled && a:loclist.hasErrorsOrWarningsToDisplay() + let b:syntastic_messages = copy(a:loclist.messages()) + let b:oldLine = -1 + autocmd syntastic CursorMoved * call g:SyntasticRefreshCursor() + endif +endfunction + +function! g:SyntasticCursorNotifier.reset(loclist) + unlet! b:syntastic_messages + let b:oldLine = -1 +endfunction + +" Private methods {{{1 + +" The following defensive nonsense is needed because of the nature of autocmd +function! g:SyntasticRefreshCursor() + if !exists('b:syntastic_messages') || empty(b:syntastic_messages) + " file not checked + return + endif + + if !exists('b:oldLine') + let b:oldLine = -1 + endif + let l = line('.') + if l == b:oldLine + return + endif + let b:oldLine = l + + if has_key(b:syntastic_messages, l) + call syntastic#util#wideMsg(b:syntastic_messages[l]) + else + echo + endif +endfunction + +" vim: set sw=4 sts=4 et fdm=marker: diff --git a/bundle/syntastic/plugin/syntastic/highlighting.vim b/bundle/syntastic/plugin/syntastic/highlighting.vim new file mode 100644 index 00000000..48bd4bb5 --- /dev/null +++ b/bundle/syntastic/plugin/syntastic/highlighting.vim @@ -0,0 +1,62 @@ +if exists("g:loaded_syntastic_notifier_highlighting") + finish +endif +let g:loaded_syntastic_notifier_highlighting = 1 + +if !exists("g:syntastic_enable_highlighting") + let g:syntastic_enable_highlighting = 1 +endif + +" Highlighting requires getmatches introduced in 7.1.040 +if v:version < 701 || (v:version == 701 && !has('patch040')) + let g:syntastic_enable_highlighting = 0 +endif + +let g:SyntasticHighlightingNotifier = {} + +" Public methods {{{1 + +function! g:SyntasticHighlightingNotifier.New() + let newObj = copy(self) + return newObj +endfunction + +function! g:SyntasticHighlightingNotifier.enabled() + return exists('b:syntastic_enable_highlighting') ? b:syntastic_enable_highlighting : g:syntastic_enable_highlighting +endfunction + +" Sets error highlights in the cuirrent window +function! g:SyntasticHighlightingNotifier.refresh(loclist) + call self.reset(a:loclist) + let buf = bufnr('') + let issues = filter(a:loclist.filteredRaw(), 'v:val["bufnr"] == buf') + for item in issues + let group = item['type'] == 'E' ? 'SyntasticError' : 'SyntasticWarning' + + " The function `Syntastic_{filetype}_{checker}_GetHighlightRegex` is + " used to override default highlighting. + if has_key(item, 'hl') + call matchadd(group, '\%' . item['lnum'] . 'l' . item['hl']) + elseif get(item, 'col') + let lastcol = col([item['lnum'], '$']) + let lcol = min([lastcol, item['col']]) + + " a bug in vim can sometimes cause there to be no 'vcol' key, + " so check for its existence + let coltype = has_key(item, 'vcol') && item['vcol'] ? 'v' : 'c' + + call matchadd(group, '\%' . item['lnum'] . 'l\%' . lcol . coltype) + endif + endfor +endfunction + +" Remove all error highlights from the window +function! g:SyntasticHighlightingNotifier.reset(loclist) + for match in getmatches() + if stridx(match['group'], 'Syntastic') == 0 + call matchdelete(match['id']) + endif + endfor +endfunction + +" vim: set sw=4 sts=4 et fdm=marker: diff --git a/bundle/syntastic/plugin/syntastic/loclist.vim b/bundle/syntastic/plugin/syntastic/loclist.vim new file mode 100644 index 00000000..1b9b5391 --- /dev/null +++ b/bundle/syntastic/plugin/syntastic/loclist.vim @@ -0,0 +1,152 @@ +if exists("g:loaded_syntastic_loclist") + finish +endif +let g:loaded_syntastic_loclist = 1 + +let g:SyntasticLoclist = {} + +" Public methods {{{1 + +function! g:SyntasticLoclist.New(rawLoclist) + let newObj = copy(self) + let newObj._quietWarnings = g:syntastic_quiet_warnings + + let llist = copy(a:rawLoclist) + let llist = filter(llist, 'v:val["valid"] == 1') + + for e in llist + if empty(e['type']) + let e['type'] = 'E' + endif + endfor + + let newObj._rawLoclist = llist + let newObj._hasErrorsOrWarningsToDisplay = -1 + + return newObj +endfunction + +function! g:SyntasticLoclist.current() + if !exists("b:syntastic_loclist") + let b:syntastic_loclist = g:SyntasticLoclist.New([]) + endif + return b:syntastic_loclist +endfunction + +function! g:SyntasticLoclist.extend(other) + let list = self.toRaw() + call extend(list, a:other.toRaw()) + return g:SyntasticLoclist.New(list) +endfunction + +function! g:SyntasticLoclist.toRaw() + return copy(self._rawLoclist) +endfunction + +function! g:SyntasticLoclist.filteredRaw() + return copy(self._quietWarnings ? self.errors() : self._rawLoclist) +endfunction + +function! g:SyntasticLoclist.quietWarnings() + return self._quietWarnings +endfunction + +function! g:SyntasticLoclist.isEmpty() + return empty(self._rawLoclist) +endfunction + +function! g:SyntasticLoclist.length() + return len(self._rawLoclist) +endfunction + +function! g:SyntasticLoclist.hasErrorsOrWarningsToDisplay() + if self._hasErrorsOrWarningsToDisplay >= 0 + return self._hasErrorsOrWarningsToDisplay + endif + let self._hasErrorsOrWarningsToDisplay = empty(self._rawLoclist) ? 0 : (!self._quietWarnings || len(self.errors())) + return self._hasErrorsOrWarningsToDisplay +endfunction + +function! g:SyntasticLoclist.errors() + if !exists("self._cachedErrors") + let self._cachedErrors = self.filter({'type': "E"}) + endif + return self._cachedErrors +endfunction + +function! g:SyntasticLoclist.warnings() + if !exists("self._cachedWarnings") + let self._cachedWarnings = self.filter({'type': "W"}) + endif + return self._cachedWarnings +endfunction + +" cache used by EchoCurrentError() +function! g:SyntasticLoclist.messages() + if !exists("self._cachedMessages") + let self._cachedMessages = {} + + for e in self.errors() + if !has_key(self._cachedMessages, e['lnum']) + let self._cachedMessages[e['lnum']] = e['text'] + endif + endfor + + if !self._quietWarnings + for e in self.warnings() + if !has_key(self._cachedMessages, e['lnum']) + let self._cachedMessages[e['lnum']] = e['text'] + endif + endfor + endif + endif + + return self._cachedMessages +endfunction + +"Filter the list and return new native loclist +"e.g. +" .filter({'bufnr': 10, 'type': 'e'}) +" +"would return all errors for buffer 10. +" +"Note that all comparisons are done with ==? +function! g:SyntasticLoclist.filter(filters) + let rv = [] + + for error in self._rawLoclist + + let passes_filters = 1 + for key in keys(a:filters) + if error[key] !=? a:filters[key] + let passes_filters = 0 + break + endif + endfor + + if passes_filters + call add(rv, error) + endif + endfor + return rv +endfunction + +"display the cached errors for this buf in the location list +function! g:SyntasticLoclist.show() + if self.hasErrorsOrWarningsToDisplay() + call setloclist(0, self.filteredRaw()) + let num = winnr() + exec "lopen " . g:syntastic_loc_list_height + if num != winnr() + wincmd p + endif + endif +endfunction + +" Non-method functions {{{1 + +function! g:SyntasticLoclistHide() + silent! lclose +endfunction + +" vim: set sw=4 sts=4 et fdm=marker: diff --git a/bundle/syntastic/plugin/syntastic/makeprg_builder.vim b/bundle/syntastic/plugin/syntastic/makeprg_builder.vim new file mode 100644 index 00000000..9f6a90f1 --- /dev/null +++ b/bundle/syntastic/plugin/syntastic/makeprg_builder.vim @@ -0,0 +1,65 @@ +if exists("g:loaded_syntastic_makeprg_builder") + finish +endif +let g:loaded_syntastic_makeprg_builder = 1 + +let g:SyntasticMakeprgBuilder = {} + +function! g:SyntasticMakeprgBuilder.New(exe, args, fname, post_args, tail, subchecker) + let newObj = copy(self) + let newObj._exe = a:exe + let newObj._args = a:args + let newObj._fname = a:fname + let newObj._post_args = a:post_args + let newObj._tail = a:tail + let newObj._subchecker = a:subchecker + return newObj +endfunction + +function! g:SyntasticMakeprgBuilder.makeprg() + return join([self.exe(), self.args(), self.fname(), self.post_args(), self.tail()]) +endfunction + +function! g:SyntasticMakeprgBuilder.exe() + return self._getOpt('exe') +endfunction + +function! g:SyntasticMakeprgBuilder.args() + return self._getOpt('args') +endfunction + +function! g:SyntasticMakeprgBuilder.fname() + if empty(self._fname) + return shellescape(expand("%")) + else + return self._fname + endif +endfunction + +function! g:SyntasticMakeprgBuilder.post_args() + return self._getOpt('post_args') +endfunction + +function! g:SyntasticMakeprgBuilder.tail() + return self._getOpt('tail') +endfunction + +function g:SyntasticMakeprgBuilder._getOpt(name) + if self._optExists(a:name) + return {self._optName(a:name)} + endif + + return self['_' . a:name] +endfunction + +function! g:SyntasticMakeprgBuilder._optExists(name) + return exists(self._optName(a:name)) +endfunction + +function! g:SyntasticMakeprgBuilder._optName(name) + let setting = "g:syntastic_" . &ft + if !empty(self._subchecker) + let setting .= '_' . self._subchecker + endif + return setting . '_' . a:name +endfunction diff --git a/bundle/syntastic/plugin/syntastic/modemap.vim b/bundle/syntastic/plugin/syntastic/modemap.vim new file mode 100644 index 00000000..058c695a --- /dev/null +++ b/bundle/syntastic/plugin/syntastic/modemap.vim @@ -0,0 +1,62 @@ +if exists("g:loaded_syntastic_modemap") + finish +endif +let g:loaded_syntastic_modemap = 1 + +let g:SyntasticModeMap = {} + +function! g:SyntasticModeMap.Instance() + if !exists('s:SyntasticModeMapInstance') + let s:SyntasticModeMapInstance = copy(self) + call s:SyntasticModeMapInstance._initModeMapFromGlobalOpts() + endif + + return s:SyntasticModeMapInstance +endfunction + +function! g:SyntasticModeMap.allowsAutoChecking(filetype) + let fts = split(a:filetype, '\.') + + if self.isPassive() + return self._isOneFiletypeActive(fts) + else + return self._noFiletypesArePassive(fts) + endif +endfunction + +function! g:SyntasticModeMap.isPassive() + return self._mode == "passive" +endfunction + +function! g:SyntasticModeMap.toggleMode() + if self._mode == "active" + let self._mode = "passive" + else + let self._mode = "active" + endif +endfunction + +function! g:SyntasticModeMap.echoMode() + echo "Syntastic: " . self._mode . " mode enabled" +endfunction + +function! g:SyntasticModeMap._initModeMapFromGlobalOpts() + let self._mode = "active" + let self._activeFiletypes = [] + let self._passiveFiletypes = [] + + if exists("g:syntastic_mode_map") + let self._mode = get(g:syntastic_mode_map, 'mode', self._mode) + let self._activeFiletypes = get(g:syntastic_mode_map, 'active_filetypes', self._activeFiletypes) + let self._passiveFiletypes = get(g:syntastic_mode_map, 'passive_filetypes', self._passiveFiletypes) + endif +endfunction + +function! g:SyntasticModeMap._isOneFiletypeActive(filetypes) + return !empty(filter(a:filetypes, 'index(self._activeFiletypes, v:val) != -1')) +endfunction + +function! g:SyntasticModeMap._noFiletypesArePassive(filetypes) + return empty(filter(a:filetypes, 'index(self._passiveFiletypes, v:val) != -1')) +endfunction + diff --git a/bundle/syntastic/plugin/syntastic/notifiers.vim b/bundle/syntastic/plugin/syntastic/notifiers.vim new file mode 100644 index 00000000..5a7c8432 --- /dev/null +++ b/bundle/syntastic/plugin/syntastic/notifiers.vim @@ -0,0 +1,44 @@ +if exists("g:loaded_syntastic_notifiers") + finish +endif +let g:loaded_syntastic_notifiers = 1 + +let g:SyntasticNotifiers = {} + +let s:notifier_types = ['signs', 'balloons', 'highlighting', 'cursor', 'autoloclist'] + +" Public methods {{{1 + +function! g:SyntasticNotifiers.New() + let newObj = copy(self) + + let newObj._notifier = {} + for type in s:notifier_types + let class = substitute(type, '.*', 'Syntastic\u&Notifier', '') + let newObj._notifier[type] = g:{class}.New() + endfor + + let newObj._enabled_types = copy(s:notifier_types) + + return newObj +endfunction + +function! g:SyntasticNotifiers.refresh(loclist) + for type in self._enabled_types + let class = substitute(type, '.*', 'Syntastic\u&Notifier', '') + if !has_key(g:{class}, 'enabled') || self._notifier[type].enabled() + call self._notifier[type].refresh(a:loclist) + endif + endfor +endfunction + +function! g:SyntasticNotifiers.reset(loclist) + for type in self._enabled_types + let class = substitute(type, '.*', 'Syntastic\u&Notifier', '') + if has_key(g:{class}, 'reset') && (!has_key(g:{class}, 'enabled') || self._notifier[type].enabled()) + call self._notifier[type].reset(a:loclist) + endif + endfor +endfunction + +" vim: set sw=4 sts=4 et fdm=marker: diff --git a/bundle/syntastic/plugin/syntastic/registry.vim b/bundle/syntastic/plugin/syntastic/registry.vim new file mode 100644 index 00000000..5fc01b65 --- /dev/null +++ b/bundle/syntastic/plugin/syntastic/registry.vim @@ -0,0 +1,166 @@ +if exists("g:loaded_syntastic_registry") + finish +endif +let g:loaded_syntastic_registry = 1 + +let s:defaultCheckers = { + \ 'c': ['gcc'], + \ 'coffee': ['coffee', 'coffeelint'], + \ 'cpp': ['gcc'], + \ 'html': ['tidy'], + \ 'java': ['javac'], + \ 'objc': ['gcc'], + \ 'php': ['php', 'phpcs', 'phpmd'], + \ 'ruby': ['mri'] + \ } + +let g:SyntasticRegistry = {} + +" Public methods {{{1 + +function! g:SyntasticRegistry.Instance() + if !exists('s:SyntasticRegistryInstance') + let s:SyntasticRegistryInstance = copy(self) + let s:SyntasticRegistryInstance._checkerMap = {} + endif + + return s:SyntasticRegistryInstance +endfunction + +function! g:SyntasticRegistry.CreateAndRegisterChecker(args) + let checker = g:SyntasticChecker.New(a:args) + let registry = g:SyntasticRegistry.Instance() + call registry.registerChecker(checker) +endfunction + +function! g:SyntasticRegistry.registerChecker(checker) abort + let ft = a:checker.filetype() + + if !has_key(self._checkerMap, ft) + let self._checkerMap[ft] = [] + endif + + call self._validateUniqueName(a:checker) + + call add(self._checkerMap[ft], a:checker) +endfunction + +function! g:SyntasticRegistry.checkable(filetype) + return !empty(self.getActiveCheckers(a:filetype)) +endfunction + +function! g:SyntasticRegistry.getActiveCheckers(filetype) + let checkers = self.availableCheckersFor(a:filetype) + + if self._userHasFiletypeSettings(a:filetype) + return self._filterCheckersByUserSettings(checkers, a:filetype) + endif + + if has_key(s:defaultCheckers, a:filetype) + return self._filterCheckersByDefaultSettings(checkers, a:filetype) + endif + + let checkers = self.availableCheckersFor(a:filetype) + + if !empty(checkers) + return [checkers[0]] + endif + + return [] +endfunction + +function! g:SyntasticRegistry.getActiveCheckerNames(filetype) + let checkers = self.getActiveCheckers(a:filetype) + return join(map(checkers, 'v:val.name()')) +endfunction + +function! g:SyntasticRegistry.getChecker(filetype, name) + for checker in self.availableCheckersFor(a:filetype) + if checker.name() == a:name + return checker + endif + endfor + + return {} +endfunction + +function! g:SyntasticRegistry.availableCheckersFor(filetype) + let checkers = copy(self._allCheckersFor(a:filetype)) + return self._filterCheckersByAvailability(checkers) +endfunction + +function! g:SyntasticRegistry.echoInfoFor(filetype) + echomsg "Syntastic info for filetype: " . a:filetype + + let available = self.availableCheckersFor(a:filetype) + echomsg "Available checkers: " . join(map(available, "v:val.name()")) + + echomsg "Currently active checker(s): " . self.getActiveCheckerNames(a:filetype) +endfunction + +" Private methods {{{1 + +function! g:SyntasticRegistry._allCheckersFor(filetype) + call self._loadCheckers(a:filetype) + if empty(self._checkerMap[a:filetype]) + return [] + endif + + return self._checkerMap[a:filetype] +endfunction + +function! g:SyntasticRegistry._filterCheckersByDefaultSettings(checkers, filetype) + if has_key(s:defaultCheckers, a:filetype) + let whitelist = s:defaultCheckers[a:filetype] + return filter(a:checkers, "index(whitelist, v:val.name()) != -1") + endif + + return a:checkers +endfunction + +function! g:SyntasticRegistry._filterCheckersByUserSettings(checkers, filetype) + if exists("b:syntastic_checkers") + let whitelist = b:syntastic_checkers + else + let whitelist = g:syntastic_{a:filetype}_checkers + endif + return filter(a:checkers, "index(whitelist, v:val.name()) != -1") +endfunction + +function! g:SyntasticRegistry._filterCheckersByAvailability(checkers) + return filter(a:checkers, "v:val.isAvailable()") +endfunction + +function! g:SyntasticRegistry._loadCheckers(filetype) + if self._haveLoadedCheckers(a:filetype) + return + endif + + exec "runtime! syntax_checkers/" . a:filetype . "/*.vim" + + if !has_key(self._checkerMap, a:filetype) + let self._checkerMap[a:filetype] = [] + endif +endfunction + +function! g:SyntasticRegistry._haveLoadedCheckers(filetype) + return has_key(self._checkerMap, a:filetype) +endfunction + +function! g:SyntasticRegistry._userHasFiletypeSettings(filetype) + if exists("g:syntastic_" . a:filetype . "_checker") && !exists("g:syntastic_" . a:filetype . "_checkers") + let g:syntastic_{a:filetype}_checkers = [g:syntastic_{a:filetype}_checker] + call syntastic#util#deprecationWarn("variable g:syntastic_" . a:filetype . "_checker is deprecated") + endif + return exists("b:syntastic_checkers") || exists("g:syntastic_" . a:filetype . "_checkers") +endfunction + +function! g:SyntasticRegistry._validateUniqueName(checker) abort + for checker in self._allCheckersFor(a:checker.filetype()) + if checker.name() == a:checker.name() + throw "Syntastic: Duplicate syntax checker name for: " . a:checker.name() + endif + endfor +endfunction + +" vim: set sw=4 sts=4 et fdm=marker: diff --git a/bundle/syntastic/plugin/syntastic/signs.vim b/bundle/syntastic/plugin/syntastic/signs.vim new file mode 100644 index 00000000..ab3a3f36 --- /dev/null +++ b/bundle/syntastic/plugin/syntastic/signs.vim @@ -0,0 +1,142 @@ +if exists("g:loaded_syntastic_notifier_signs") + finish +endif +let g:loaded_syntastic_notifier_signs = 1 + +if !exists("g:syntastic_enable_signs") + let g:syntastic_enable_signs = 1 +endif + +if !exists("g:syntastic_error_symbol") + let g:syntastic_error_symbol = '>>' +endif + +if !exists("g:syntastic_warning_symbol") + let g:syntastic_warning_symbol = '>>' +endif + +if !exists("g:syntastic_style_error_symbol") + let g:syntastic_style_error_symbol = 'S>' +endif + +if !exists("g:syntastic_style_warning_symbol") + let g:syntastic_style_warning_symbol = 'S>' +endif + +if !has('signs') + let g:syntastic_enable_signs = 0 +endif + + +" start counting sign ids at 5000, start here to hopefully avoid conflicting +" with any other code that places signs (not sure if this precaution is +" actually needed) +let s:first_sign_id = 5000 +let s:next_sign_id = s:first_sign_id + +let g:SyntasticSignsNotifier = {} + +let s:setup_done = 0 + +" Public methods {{{1 + +function! g:SyntasticSignsNotifier.New() + let newObj = copy(self) + + if !s:setup_done + call self._setup() + let s:setup_done = 1 + endif + + return newObj +endfunction + +function! g:SyntasticSignsNotifier.enabled() + return exists('b:syntastic_enable_signs') ? b:syntastic_enable_signs : g:syntastic_enable_signs +endfunction + +" Update the error signs +function! g:SyntasticSignsNotifier.refresh(loclist) + let old_signs = copy(self._bufSignIds()) + call self._signErrors(a:loclist) + call self._removeSigns(old_signs) + let s:first_sign_id = s:next_sign_id +endfunction + +" Private methods {{{1 + +" One time setup: define our own sign types and highlighting +function! g:SyntasticSignsNotifier._setup() + if has('signs') + if !hlexists('SyntasticErrorSign') + highlight link SyntasticErrorSign error + endif + if !hlexists('SyntasticWarningSign') + highlight link SyntasticWarningSign todo + endif + if !hlexists('SyntasticStyleErrorSign') + highlight link SyntasticStyleErrorSign SyntasticErrorSign + endif + if !hlexists('SyntasticStyleWarningSign') + highlight link SyntasticStyleWarningSign SyntasticWarningSign + endif + if !hlexists('SyntasticStyleErrorLine') + highlight link SyntasticStyleErrorLine SyntasticErrorLine + endif + if !hlexists('SyntasticStyleWarningLine') + highlight link SyntasticStyleWarningLine SyntasticWarningLine + endif + + " define the signs used to display syntax and style errors/warns + exe 'sign define SyntasticError text=' . g:syntastic_error_symbol . + \ ' texthl=SyntasticErrorSign linehl=SyntasticErrorLine' + exe 'sign define SyntasticWarning text=' . g:syntastic_warning_symbol . + \ ' texthl=SyntasticWarningSign linehl=SyntasticWarningLine' + exe 'sign define SyntasticStyleError text=' . g:syntastic_style_error_symbol . + \ ' texthl=SyntasticStyleErrorSign linehl=SyntasticStyleErrorLine' + exe 'sign define SyntasticStyleWarning text=' . g:syntastic_style_warning_symbol . + \ ' texthl=SyntasticStyleWarningSign linehl=SyntasticStyleWarningLine' + endif +endfunction + +" Place signs by all syntax errors in the buffer +function! g:SyntasticSignsNotifier._signErrors(loclist) + let loclist = a:loclist + if loclist.hasErrorsOrWarningsToDisplay() + + " make sure the errors come after the warnings, so that errors mask + " the warnings on the same line, not the other way around + let buf = bufnr('') + let issues = loclist.quietWarnings() ? [] : loclist.warnings() + call extend(issues, loclist.errors()) + call filter(issues, 'v:val["bufnr"] == buf') + + for i in issues + let sign_severity = i['type'] ==? 'W' ? 'Warning' : 'Error' + let sign_subtype = get(i, 'subtype', '') + let sign_type = 'Syntastic' . sign_subtype . sign_severity + + exec "sign place " . s:next_sign_id . " line=" . i['lnum'] . " name=" . sign_type . " buffer=" . i['bufnr'] + call add(self._bufSignIds(), s:next_sign_id) + let s:next_sign_id += 1 + endfor + endif +endfunction + +" Remove the signs with the given ids from this buffer +function! g:SyntasticSignsNotifier._removeSigns(ids) + for i in a:ids + exec "sign unplace " . i + call remove(self._bufSignIds(), index(self._bufSignIds(), i)) + endfor +endfunction + +" Get all the ids of the SyntaxError signs in the buffer +function! g:SyntasticSignsNotifier._bufSignIds() + if !exists("b:syntastic_sign_ids") + let b:syntastic_sign_ids = [] + endif + return b:syntastic_sign_ids +endfunction + +" vim: set sw=4 sts=4 et fdm=marker: diff --git a/bundle/syntastic/syntax_checkers/ada/gcc.vim b/bundle/syntastic/syntax_checkers/ada/gcc.vim new file mode 100644 index 00000000..39001fd2 --- /dev/null +++ b/bundle/syntastic/syntax_checkers/ada/gcc.vim @@ -0,0 +1,168 @@ +"============================================================================ +"File: ada.vim +"Description: Syntax checking plugin for syntastic.vim +"Maintainer: Alfredo Di Napoli +"License: This program is free software. It comes without any warranty, +" to the extent permitted by applicable law. +" +"============================================================================ + +" In order to also check header files add this to your .vimrc: +" +" let g:syntastic_ada_check_header = 1 +" +" To disable the search of included header files after special +" libraries like gtk and glib add this line to your .vimrc: +" +" let g:syntastic_ada_no_include_search = 1 +" +" To disable the include of the default include dirs (such as /usr/include) +" add this line to your .vimrc: +" +" let g:syntastic_ada_no_default_include_dirs = 1 +" +" To enable header files being re-checked on every file write add the +" following line to your .vimrc. Otherwise the header files are checked only +" one time on initially loading the file. +" In order to force syntastic to refresh the header includes simply +" unlet b:syntastic_ada_includes. Then the header files are being re-checked +" on the next file write. +" +" let g:syntastic_ada_auto_refresh_includes = 1 +" +" Alternatively you can set the buffer local variable b:syntastic_ada_cflags. +" If this variable is set for the current buffer no search for additional +" libraries is done. I.e. set the variable like this: +" +" let b:syntastic_ada_cflags = ' -I/usr/include/libsoup-2.4' +" +" In order to add some custom include directories that should be added to the +" gcc command line you can add those to the global variable +" g:syntastic_ada_include_dirs. This list can be used like this: +" +" let g:syntastic_ada_include_dirs = [ 'includes', 'headers' ] +" +" Moreover it is possible to add additional compiler options to the syntax +" checking execution via the variable 'g:syntastic_ada_compiler_options': +" +" let g:syntastic_ada_compiler_options = ' -std=c++0x' +" +" Additionally the setting 'g:syntastic_ada_config_file' allows you to define +" a file that contains additional compiler arguments like include directories +" or CFLAGS. The file is expected to contain one option per line. If none is +" given the filename defaults to '.syntastic_ada_config': +" +" let g:syntastic_ada_config_file = '.config' +" +" Using the global variable 'g:syntastic_ada_remove_include_errors' you can +" specify whether errors of files included via the +" g:syntastic_ada_include_dirs' setting are removed from the result set: +" +" let g:syntastic_ada_remove_include_errors = 1 +" +" Use the variable 'g:syntastic_ada_errorformat' to override the default error +" format: +" +" let g:syntastic_ada_errorformat = '%f:%l:%c: %trror: %m' +" +" Set your compiler executable with e.g. (defaults to gcc) +" +" let g:syntastic_ada_compiler = 'gcc' + +if exists('g:loaded_syntastic_ada_gcc_checker') + finish +endif +let g:loaded_syntastic_ada_gcc_checker = 1 + +if !exists('g:syntastic_ada_compiler') + let g:syntastic_ada_compiler = 'gcc' +endif + +function! SyntaxCheckers_ada_gcc_IsAvailable() + return executable(g:syntastic_ada_compiler) +endfunction + +let s:save_cpo = &cpo +set cpo&vim + +if !exists('g:syntastic_ada_compiler_options') + let g:syntastic_ada_compiler_options = '' +endif + +if !exists('g:syntastic_ada_config_file') + let g:syntastic_ada_config_file = '.syntastic_ada_config' +endif + +function! SyntaxCheckers_ada_gcc_GetLocList() + let makeprg = g:syntastic_ada_compiler . ' -c -x ada -fsyntax-only ' + let errorformat = '%-G%f:%s:,%f:%l:%c: %m,%f:%l: %m' + + if exists('g:syntastic_c_errorformat') + let errorformat = g:syntastic_c_errorformat + endif + + " add optional user-defined compiler options + let makeprg .= g:syntastic_ada_compiler_options + + let makeprg .= ' ' . shellescape(expand('%')) . + \ ' ' . syntastic#c#GetIncludeDirs('ada') + + " determine whether to parse header files as well + if expand('%') =~? '\.ads$' + if exists('g:syntastic_ada_check_header') + let makeprg = g:syntastic_ada_compiler . + \ ' -c ' . shellescape(expand('%')) . + \ ' ' . g:syntastic_ada_compiler_options . + \ ' ' . syntastic#c#GetIncludeDirs('ada') + else + return [] + endif + endif + + " check if the user manually set some cflags + if !exists('b:syntastic_ada_cflags') + " check whether to search for include files at all + if !exists('g:syntastic_ada_no_include_search') || + \ g:syntastic_ada_no_include_search != 1 + " refresh the include file search if desired + if exists('g:syntastic_ada_auto_refresh_includes') && + \ g:syntastic_ada_auto_refresh_includes != 0 + let makeprg .= syntastic#c#SearchHeaders() + else + " search for header includes if not cached already + if !exists('b:syntastic_ada_includes') + let b:syntastic_ada_includes = syntastic#c#SearchHeaders() + endif + let makeprg .= b:syntastic_ada_includes + endif + endif + else + " use the user-defined cflags + let makeprg .= b:syntastic_ada_cflags + endif + + " add optional config file parameters + let makeprg .= ' ' . syntastic#c#ReadConfig(g:syntastic_ada_config_file) + + " process makeprg + let errors = SyntasticMake({ 'makeprg': makeprg, + \ 'errorformat': errorformat }) + + " filter the processed errors if desired + if exists('g:syntastic_ada_remove_include_errors') && + \ g:syntastic_ada_remove_include_errors != 0 + return filter(errors, + \ 'has_key(v:val, "bufnr") && v:val["bufnr"]=='.bufnr('')) + else + return errors + endif +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'ada', + \ 'name': 'gcc'}) + +let &cpo = s:save_cpo +unlet s:save_cpo + +" vim: set et sts=4 sw=4: diff --git a/bundle/syntastic/syntax_checkers/applescript/osacompile.vim b/bundle/syntastic/syntax_checkers/applescript/osacompile.vim new file mode 100644 index 00000000..4ce21e73 --- /dev/null +++ b/bundle/syntastic/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 + +function! SyntaxCheckers_applescript_osacompile_IsAvailable() + return executable('osacompile') +endfunction + +function! SyntaxCheckers_applescript_osacompile_GetLocList() + let makeprg = syntastic#makeprg#build({ + \ 'exe': 'osacompile', + \ 'args': '-o ' . tempname() . '.scpt ', + \ 'subchecker': 'osacompile' }) + let errorformat = '%f:%l:%m' + + return SyntasticMake({ 'makeprg': makeprg, 'errorformat': errorformat }) +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'applescript', + \ 'name': 'osacompile'}) diff --git a/bundle/syntastic/syntax_checkers/c/checkpatch.vim b/bundle/syntastic/syntax_checkers/c/checkpatch.vim new file mode 100644 index 00000000..90745ef7 --- /dev/null +++ b/bundle/syntastic/syntax_checkers/c/checkpatch.vim @@ -0,0 +1,43 @@ +"============================================================================ +"File: checkpatch.vim +"Description: Syntax checking plugin for syntastic.vim using checkpatch.pl +"Maintainer: Daniel Walker +"License: This program is free software. It comes without any warranty, +" to the extent permitted by applicable law. You can redistribute +" it and/or modify it under the terms of the Do What The Fuck You +" Want To Public License, Version 2, as published by Sam Hocevar. +" See http://sam.zoy.org/wtfpl/COPYING for more details. +"============================================================================ +if exists("loaded_checkpatch_syntax_checker") + finish +endif +let loaded_checkpatch_syntax_checker = 1 + +" Bail if the user doesn't have `checkpatch.pl` or ./scripts/checkpatch.pl installed. +if executable("checkpatch.pl") + let g:syntastic_c_checker_checkpatch_location = 'checkpatch.pl' +elseif executable("./scripts/checkpatch.pl") + let g:syntastic_c_checker_checkpatch_location = './scripts/checkpatch.pl' +endif + +function SyntaxCheckers_c_checkpatch_IsAvailable() + return exists("g:syntastic_c_checker_checkpatch_location") +endfunction + + +function! SyntaxCheckers_c_checkpatch_GetLocList() + let makeprg = syntastic#makeprg#build({ + \ 'exe': g:syntastic_c_checker_checkpatch_location, + \ 'args': '--no-summary --no-tree --terse --file', + \ 'subchecker': 'checkpatch' }) + + let errorformat = '%f:%l: %tARNING: %m,%f:%l: %tRROR: %m' + + return SyntasticMake({ 'makeprg': makeprg, + \ 'errorformat': errorformat, + \ 'defaults': {'bufnr': bufnr("")} }) +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'c', + \ 'name': 'checkpatch'}) diff --git a/bundle/syntastic/syntax_checkers/c/gcc.vim b/bundle/syntastic/syntax_checkers/c/gcc.vim new file mode 100644 index 00000000..b8d72e17 --- /dev/null +++ b/bundle/syntastic/syntax_checkers/c/gcc.vim @@ -0,0 +1,183 @@ +"============================================================================ +"File: c.vim +"Description: Syntax checking plugin for syntastic.vim +"Maintainer: Gregor Uhlenheuer +"License: This program is free software. It comes without any warranty, +" to the extent permitted by applicable law. You can redistribute +" it and/or modify it under the terms of the Do What The Fuck You +" Want To Public License, Version 2, as published by Sam Hocevar. +" See http://sam.zoy.org/wtfpl/COPYING for more details. +" +"============================================================================ + +" In order to also check header files add this to your .vimrc: +" +" let g:syntastic_c_check_header = 1 +" +" To disable the search of included header files after special +" libraries like gtk and glib add this line to your .vimrc: +" +" let g:syntastic_c_no_include_search = 1 +" +" To disable the include of the default include dirs (such as /usr/include) +" add this line to your .vimrc: +" +" let g:syntastic_c_no_default_include_dirs = 1 +" +" To enable header files being re-checked on every file write add the +" following line to your .vimrc. Otherwise the header files are checked only +" one time on initially loading the file. +" In order to force syntastic to refresh the header includes simply +" unlet b:syntastic_c_includes. Then the header files are being re-checked on +" the next file write. +" +" let g:syntastic_c_auto_refresh_includes = 1 +" +" Alternatively you can set the buffer local variable b:syntastic_c_cflags. +" If this variable is set for the current buffer no search for additional +" libraries is done. I.e. set the variable like this: +" +" let b:syntastic_c_cflags = ' -I/usr/include/libsoup-2.4' +" +" In order to add some custom include directories that should be added to the +" gcc command line you can add those to the global variable +" g:syntastic_c_include_dirs. This list can be used like this: +" +" let g:syntastic_c_include_dirs = [ 'includes', 'headers' ] +" +" Moreover it is possible to add additional compiler options to the syntax +" checking execution via the variable 'g:syntastic_c_compiler_options': +" +" let g:syntastic_c_compiler_options = ' -ansi' +" +" Additionally the setting 'g:syntastic_c_config_file' allows you to define a +" file that contains additional compiler arguments like include directories or +" CFLAGS. The file is expected to contain one option per line. If none is +" given the filename defaults to '.syntastic_c_config': +" +" let g:syntastic_c_config_file = '.config' +" +" Using the global variable 'g:syntastic_c_remove_include_errors' you can +" specify whether errors of files included via the g:syntastic_c_include_dirs' +" setting are removed from the result set: +" +" let g:syntastic_c_remove_include_errors = 1 +" +" Use the variable 'g:syntastic_c_errorformat' to override the default error +" format: +" +" let g:syntastic_c_errorformat = '%f:%l:%c: %trror: %m' +" +" Set your compiler executable with e.g. (defaults to gcc) +" +" let g:syntastic_c_compiler = 'clang' + +if exists('g:loaded_syntastic_c_gcc_checker') + finish +endif +let g:loaded_syntastic_c_gcc_checker = 1 + +if !exists('g:syntastic_c_compiler') + let g:syntastic_c_compiler = 'gcc' +endif + +function! SyntaxCheckers_c_gcc_IsAvailable() + return executable(g:syntastic_c_compiler) +endfunction + +let s:save_cpo = &cpo +set cpo&vim + +if !exists('g:syntastic_c_compiler_options') + let g:syntastic_c_compiler_options = '-std=gnu99' +endif + +if !exists('g:syntastic_c_config_file') + let g:syntastic_c_config_file = '.syntastic_c_config' +endif + +function! SyntaxCheckers_c_gcc_GetLocList() + let makeprg = g:syntastic_c_compiler . ' -x c -fsyntax-only ' + let errorformat = + \ '%-G%f:%s:,' . + \ '%-G%f:%l: %#error: %#(Each undeclared identifier is reported only%.%#,' . + \ '%-G%f:%l: %#error: %#for each function it appears%.%#,' . + \ '%-GIn file included%.%#,' . + \ '%-G %#from %f:%l\,,' . + \ '%f:%l:%c: %trror: %m,' . + \ '%f:%l:%c: %tarning: %m,' . + \ '%f:%l:%c: %m,' . + \ '%f:%l: %trror: %m,' . + \ '%f:%l: %tarning: %m,'. + \ '%f:%l: %m' + + if exists('g:syntastic_c_errorformat') + let errorformat = g:syntastic_c_errorformat + endif + + " add optional user-defined compiler options + let makeprg .= g:syntastic_c_compiler_options + + let makeprg .= ' ' . shellescape(expand('%')) . + \ ' ' . syntastic#c#GetIncludeDirs('c') + + " determine whether to parse header files as well + if expand('%') =~? '\.h$' + if exists('g:syntastic_c_check_header') + let makeprg = g:syntastic_c_compiler . + \ ' -c ' . shellescape(expand('%')) . + \ ' ' . g:syntastic_c_compiler_options . + \ ' ' . syntastic#c#GetNullDevice() . + \ ' ' . syntastic#c#GetIncludeDirs('c') + else + return [] + endif + endif + + " check if the user manually set some cflags + if !exists('b:syntastic_c_cflags') + " check whether to search for include files at all + if !exists('g:syntastic_c_no_include_search') || + \ g:syntastic_c_no_include_search != 1 + " refresh the include file search if desired + if exists('g:syntastic_c_auto_refresh_includes') && + \ g:syntastic_c_auto_refresh_includes != 0 + let makeprg .= syntastic#c#SearchHeaders() + else + " search for header includes if not cached already + if !exists('b:syntastic_c_includes') + let b:syntastic_c_includes = syntastic#c#SearchHeaders() + endif + let makeprg .= b:syntastic_c_includes + endif + endif + else + " use the user-defined cflags + let makeprg .= b:syntastic_c_cflags + endif + + " add optional config file parameters + let makeprg .= ' ' . syntastic#c#ReadConfig(g:syntastic_c_config_file) + + " process makeprg + let errors = SyntasticMake({ 'makeprg': makeprg, + \ 'errorformat': errorformat }) + + " filter the processed errors if desired + if exists('g:syntastic_c_remove_include_errors') && + \ g:syntastic_c_remove_include_errors != 0 + return filter(errors, + \ 'has_key(v:val, "bufnr") && v:val["bufnr"]=='.bufnr('')) + else + return errors + endif +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'c', + \ 'name': 'gcc'}) + +let &cpo = s:save_cpo +unlet s:save_cpo + +" vim: set et sts=4 sw=4: diff --git a/bundle/syntastic/syntax_checkers/c/make.vim b/bundle/syntastic/syntax_checkers/c/make.vim new file mode 100644 index 00000000..68557ac7 --- /dev/null +++ b/bundle/syntastic/syntax_checkers/c/make.vim @@ -0,0 +1,65 @@ +"============================================================================ +"File: make.vim +"Description: Syntax checking plugin for syntastic.vim +"Maintainer: Gregor Uhlenheuer +"License: This program is free software. It comes without any warranty, +" to the extent permitted by applicable law. You can redistribute +" it and/or modify it under the terms of the Do What The Fuck You +" Want To Public License, Version 2, as published by Sam Hocevar. +" See http://sam.zoy.org/wtfpl/COPYING for more details. +" +"============================================================================ + +if exists('loaded_make_syntax_checker') + finish +endif +let loaded_make_syntax_checker = 1 + +function SyntaxCheckers_c_make_IsAvailable() + return executable('make') +endfunction + +let s:save_cpo = &cpo +set cpo&vim + +function! SyntaxCheckers_c_make_GetLocList() + + let makeprg = 'make -sk' + + let errorformat = + \ '%-G%f:%s:,' . + \ '%-G%f:%l: %#error: %#(Each undeclared identifier is reported only%.%#,' . + \ '%-G%f:%l: %#error: %#for each function it appears%.%#,' . + \ '%-GIn file included%.%#,' . + \ '%-G %#from %f:%l\,,' . + \ '%f:%l:%c: %trror: %m,' . + \ '%f:%l:%c: %tarning: %m,' . + \ '%f:%l:%c: %m,' . + \ '%f:%l: %trror: %m,' . + \ '%f:%l: %tarning: %m,'. + \ '%f:%l: %m' + + if exists('g:syntastic_c_errorformat') + let errorformat = g:syntastic_c_errorformat + endif + + " process makeprg + let errors = SyntasticMake({ 'makeprg': makeprg, + \ 'errorformat': errorformat }) + + " filter the processed errors if desired + if exists('g:syntastic_c_remove_include_errors') && + \ g:syntastic_c_remove_include_errors != 0 + return filter(errors, + \ 'has_key(v:val, "bufnr") && v:val["bufnr"]=='.bufnr('')) + else + return errors + endif +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'c', + \ 'name': 'make'}) + +let &cpo = s:save_cpo +unlet s:save_cpo diff --git a/bundle/syntastic/syntax_checkers/c/sparse.vim b/bundle/syntastic/syntax_checkers/c/sparse.vim new file mode 100644 index 00000000..5db60241 --- /dev/null +++ b/bundle/syntastic/syntax_checkers/c/sparse.vim @@ -0,0 +1,48 @@ +"============================================================================ +"File: sparse.vim +"Description: Syntax checking plugin for syntastic.vim using sparse.pl +"Maintainer: Daniel Walker +"License: This program is free software. It comes without any warranty, +" to the extent permitted by applicable law. You can redistribute +" it and/or modify it under the terms of the Do What 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("loaded_sparse_syntax_checker") + finish +endif +let loaded_sparse_syntax_checker = 1 + +function! SyntaxCheckers_c_sparse_IsAvailable() + return executable("sparse") +endfunction + +if !exists('g:syntastic_sparse_config_file') + let g:syntastic_sparse_config_file = '.syntastic_sparse_config' +endif + +function! SyntaxCheckers_c_sparse_GetLocList() + let makeprg = syntastic#makeprg#build({ + \ 'exe': 'sparse', + \ 'args': '-ftabstop=' . &ts . ' ' . syntastic#c#ReadConfig(g:syntastic_sparse_config_file), + \ 'subchecker': 'sparse' }) + + let errorformat = '%f:%l:%v: %trror: %m,%f:%l:%v: %tarning: %m,' + + let loclist = SyntasticMake({ 'makeprg': makeprg, + \ 'errorformat': errorformat, + \ 'defaults': {'bufnr': bufnr("")} }) + return loclist +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'c', + \ 'name': 'sparse'}) diff --git a/bundle/syntastic/syntax_checkers/c/splint.vim b/bundle/syntastic/syntax_checkers/c/splint.vim new file mode 100644 index 00000000..e71349e0 --- /dev/null +++ b/bundle/syntastic/syntax_checkers/c/splint.vim @@ -0,0 +1,56 @@ +"============================================================================ +"File: splint.vim +"Description: Syntax checking plugin for syntastic.vim +"Maintainer: LCD 47 +"License: This program is free software. It comes without any warranty, +" to the extent permitted by applicable law. You can redistribute +" it and/or modify it under the terms of the Do What 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("loaded_splint_syntax_checker") + finish +endif +let loaded_splint_syntax_checker = 1 + +function! SyntaxCheckers_c_splint_IsAvailable() + return executable("splint") +endfunction + +if !exists('g:syntastic_splint_config_file') + let g:syntastic_splint_config_file = '.syntastic_splint_config' +endif + +function! SyntaxCheckers_c_splint_GetLocList() + let makeprg = syntastic#makeprg#build({ + \ 'exe': 'splint', + \ 'post_args': '-showfunc -hints +quiet ' . syntastic#c#ReadConfig(g:syntastic_splint_config_file), + \ 'subchecker': 'splint' }) + + let errorformat = + \ '%-G%f:%l:%v: %[%#]%[%#]%[%#] Internal Bug %.%#,' . + \ '%W%f:%l:%v: %m,' . + \ '%W%f:%l: %m,' . + \ '%-C %\+In file included from %.%#,' . + \ '%-C %\+from %.%#,' . + \ '%+C %.%#' + + return SyntasticMake({ + \ 'makeprg': makeprg, + \ 'errorformat': errorformat, + \ 'subtype': 'Style', + \ 'postprocess': ['compressWhitespace'], + \ 'defaults': {'type': 'W'} }) +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'c', + \ 'name': 'splint'}) diff --git a/bundle/syntastic/syntax_checkers/c/ycm.vim b/bundle/syntastic/syntax_checkers/c/ycm.vim new file mode 100644 index 00000000..bc35b7cf --- /dev/null +++ b/bundle/syntastic/syntax_checkers/c/ycm.vim @@ -0,0 +1,32 @@ +"============================================================================ +"File: ycm.vim +"Description: Syntax checking plugin for syntastic.vim +"Maintainer: Val Markovic +"License: This program is free software. It comes without any warranty, +" to the extent permitted by applicable law. You can redistribute +" it and/or modify it under the terms of the Do What The Fuck You +" Want To Public License, Version 2, as published by Sam Hocevar. +" See http://sam.zoy.org/wtfpl/COPYING for more details. +" +"============================================================================ + +if exists("loaded_ycm_c_syntax_checker") + finish +endif +let loaded_ycm_c_syntax_checker = 1 + +function! SyntaxCheckers_c_ycm_IsAvailable() + return exists('g:loaded_youcompleteme') +endfunction + +if !exists('g:loaded_youcompleteme') + finish +endif + +function! SyntaxCheckers_c_ycm_GetLocList() + return youcompleteme#CurrentFileDiagnostics() +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'c', + \ 'name': 'ycm'}) diff --git a/bundle/syntastic/syntax_checkers/co/coco.vim b/bundle/syntastic/syntax_checkers/co/coco.vim new file mode 100644 index 00000000..e9b7e1f7 --- /dev/null +++ b/bundle/syntastic/syntax_checkers/co/coco.vim @@ -0,0 +1,42 @@ +"============================================================================ +"File: co.vim +"Description: Syntax checking plugin for syntastic.vim +"Maintainer: Andrew Kelley +"License: This program is free software. It comes without any warranty, +" to the extent permitted by applicable law. You can redistribute +" it and/or modify it under the terms of the Do What The Fuck You +" Want To Public License, Version 2, as published by Sam Hocevar. +" See http://sam.zoy.org/wtfpl/COPYING for more details. +" +"============================================================================ +if exists("g:loaded_syntastic_co_coco_checker") + finish +endif +let g:loaded_syntastic_co_coco_checker=1 + +"bail if the user doesnt have coco installed +if !executable("coco") + finish +endif + +function! SyntaxCheckers_co_coco_GetLocList() + return executable('coco') +endfunction + +function! SyntaxCheckers_co_coco_GetLocList() + let makeprg = syntastic#makeprg#build({ + \ 'exe': 'coco', + \ 'args': '-c -o /tmp', + \ 'subchecker': 'coco' }) + let errorformat = + \ '%EFailed at: %f,' . + \ '%ZSyntax%trror: %m on line %l,'. + \ '%EFailed at: %f,'. + \ '%Z%trror: Parse error on line %l: %m' + + return SyntasticMake({ 'makeprg': makeprg, 'errorformat': errorformat }) +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'co', + \ 'name': 'coco'}) diff --git a/bundle/syntastic/syntax_checkers/coffee/coffee.vim b/bundle/syntastic/syntax_checkers/coffee/coffee.vim new file mode 100644 index 00000000..039db208 --- /dev/null +++ b/bundle/syntastic/syntax_checkers/coffee/coffee.vim @@ -0,0 +1,42 @@ +"============================================================================ +"File: coffee.vim +"Description: Syntax checking plugin for syntastic.vim +"Maintainer: Lincoln Stoll +"License: This program is free software. It comes without any warranty, +" to the extent permitted by applicable law. You can redistribute +" it and/or modify it under the terms of the Do What 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_coffee_checker") + finish +endif +let g:loaded_syntastic_coffee_coffee_checker=1 + +function! SyntaxCheckers_coffee_coffee_IsAvailable() + return executable("coffee") +endfunction + +function! SyntaxCheckers_coffee_coffee_GetLocList() + let makeprg = syntastic#makeprg#build({ + \ 'exe': 'coffee', + \ 'args': '--lint', + \ 'subchecker': 'coffee' }) + let errorformat = + \ '%E%f:%l:%c: %trror: %m,' . + \ 'Syntax%trror: In %f\, %m on line %l,' . + \ '%EError: In %f\, Parse error on line %l: %m,' . + \ '%EError: In %f\, %m on line %l,' . + \ '%W%f(%l): lint warning: %m,' . + \ '%W%f(%l): warning: %m,' . + \ '%E%f(%l): SyntaxError: %m,' . + \ '%-Z%p^,' . + \ '%-G%.%#' + + return SyntasticMake({ 'makeprg': makeprg, 'errorformat': errorformat }) +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'coffee', + \ 'name': 'coffee'}) diff --git a/bundle/syntastic/syntax_checkers/coffee/coffeelint.vim b/bundle/syntastic/syntax_checkers/coffee/coffeelint.vim new file mode 100644 index 00000000..d58da16d --- /dev/null +++ b/bundle/syntastic/syntax_checkers/coffee/coffeelint.vim @@ -0,0 +1,32 @@ +"============================================================================ +"File: coffeelint.vim +"Description: Syntax checking plugin for syntastic.vim +"Maintainer: Lincoln Stoll +"License: This program is free software. It comes without any warranty, +" to the extent permitted by applicable law. You can redistribute +" it and/or modify it under the terms of the Do What The Fuck You +" Want To Public License, Version 2, as published by Sam Hocevar. +" See http://sam.zoy.org/wtfpl/COPYING for more details. +" +"============================================================================ +if exists("g:loaded_syntastic_coffee_coffeelint_checker") + finish +endif +let g:loaded_syntastic_coffee_coffeelint_checker=1 + +function! SyntaxCheckers_coffee_coffeelint_IsAvailable() + return executable('coffeelint') +endfunction + +function! SyntaxCheckers_coffee_coffeelint_GetLocList() + let makeprg = syntastic#makeprg#build({ + \ 'exe': 'coffeelint', + \ 'subchecker': 'coffeelint', + \ 'args': '--csv' }) + let efm = '%f\,%l\,%trror\,%m' + return SyntasticMake({ 'makeprg': makeprg, 'errorformat': efm, 'subtype': 'Style' }) +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'coffee', + \ 'name': 'coffeelint'}) diff --git a/bundle/syntastic/syntax_checkers/coq/coqtop.vim b/bundle/syntastic/syntax_checkers/coq/coqtop.vim new file mode 100644 index 00000000..e1dd239c --- /dev/null +++ b/bundle/syntastic/syntax_checkers/coq/coqtop.vim @@ -0,0 +1,36 @@ +"============================================================================ +"File: coqtop.vim +"Description: Syntax checking plugin for syntastic.vim +"Maintainer: Matvey Aksenov +"License: This program is free software. It comes without any warranty, +" to the extent permitted by applicable law. You can redistribute +" it and/or modify it under the terms of the Do What The Fuck You +" Want To Public License, Version 2, as published by Sam Hocevar. +" See http://sam.zoy.org/wtfpl/COPYING for more details. +" +"============================================================================ + +if exists("g:loaded_syntastic_coq_coqtop_checker") + finish +endif +let g:loaded_syntastic_coq_coqtop_checker=1 + +function! SyntaxCheckers_coq_coqtop_IsAvailable() + return executable('coqtop') +endfunction + +function! SyntaxCheckers_coq_coqtop_GetLocList() + let makeprg = syntastic#makeprg#build({ + \ 'exe': 'coqtop', + \ 'args': '-noglob -batch -load-vernac-source', + \ 'subchecker': 'coqtop' }) + let errorformat = + \ '%AFile \"%f\"\, line %l\, characters %c\-%.%#\:,'. + \ '%C%m' + + return SyntasticMake({ 'makeprg': makeprg, 'errorformat': errorformat }) +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'coq', + \ 'name': 'coqtop'}) diff --git a/bundle/syntastic/syntax_checkers/cpp/cpplint.vim b/bundle/syntastic/syntax_checkers/cpp/cpplint.vim new file mode 100644 index 00000000..48cf415b --- /dev/null +++ b/bundle/syntastic/syntax_checkers/cpp/cpplint.vim @@ -0,0 +1,59 @@ +"============================================================================ +"File: cpplint.vim +"Description: Syntax checking plugin for syntastic.vim +"Maintainer: LCD 47 +"License: This program is free software. It comes without any warranty, +" to the extent permitted by applicable law. You can redistribute +" it and/or modify it under the terms of the Do What The Fuck You +" Want To Public License, Version 2, as published by Sam Hocevar. +" See http://sam.zoy.org/wtfpl/COPYING for more details. +" +"============================================================================ +" +" For details about cpplint see: +" https://code.google.com/p/google-styleguide/ +" +" Checker options: +" +" - g:syntastic_cpp_cpplint_thres (integer; default: 5) +" error threshold: policy violations with a severity above this +" value are highlighted as errors, the others are warnings +" +" - g:syntastic_cpp_cpplint_args (string; default: '--verbose=3') +" command line options to pass to cpplint + +if exists("g:loaded_syntastic_cpp_cpplint_checker") + finish +endif +let g:loaded_syntastic_cpp_cpplint_checker = 1 + +if !exists('g:syntastic_cpp_cpplint_thres') + let g:syntastic_cpp_cpplint_thres = 5 +endif + +if ! exists('g:syntastic_cpp_cpplint_args') + let g:syntastic_cpp_cpplint_args = '--verbose=3' +endif + +function! SyntaxCheckers_cpp_cpplint_IsAvailable() + return executable('cpplint.py') +endfunction + +function! SyntaxCheckers_cpp_cpplint_GetLocList() + let makeprg = syntastic#makeprg#build({ + \ 'exe': 'cpplint.py', + \ 'subchecker': 'cpplint' }) + let errorformat = '%A%f:%l: %m [%t],%-G%.%#' + let loclist = SyntasticMake({ 'makeprg': makeprg, 'errorformat': errorformat, 'subtype': 'Style' }) + + " change error types according to the prescribed threshold + for n in range(len(loclist)) + let loclist[n]['type'] = loclist[n]['type'] < g:syntastic_cpp_cpplint_thres ? 'W' : 'E' + endfor + + return loclist +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'cpp', + \ 'name': 'cpplint'}) diff --git a/bundle/syntastic/syntax_checkers/cpp/gcc.vim b/bundle/syntastic/syntax_checkers/cpp/gcc.vim new file mode 100644 index 00000000..44178f19 --- /dev/null +++ b/bundle/syntastic/syntax_checkers/cpp/gcc.vim @@ -0,0 +1,179 @@ +"============================================================================ +"File: cpp.vim +"Description: Syntax checking plugin for syntastic.vim +"Maintainer: Gregor Uhlenheuer +"License: This program is free software. It comes without any warranty, +" to the extent permitted by applicable law. You can redistribute +" it and/or modify it under the terms of the Do What The Fuck You +" Want To Public License, Version 2, as published by Sam Hocevar. +" See http://sam.zoy.org/wtfpl/COPYING for more details. +" +"============================================================================ + +" In order to also check header files add this to your .vimrc: +" +" let g:syntastic_cpp_check_header = 1 +" +" To disable the search of included header files after special +" libraries like gtk and glib add this line to your .vimrc: +" +" let g:syntastic_cpp_no_include_search = 1 +" +" To disable the include of the default include dirs (such as /usr/include) +" add this line to your .vimrc: +" +" let g:syntastic_cpp_no_default_include_dirs = 1 +" +" To enable header files being re-checked on every file write add the +" following line to your .vimrc. Otherwise the header files are checked only +" one time on initially loading the file. +" In order to force syntastic to refresh the header includes simply +" unlet b:syntastic_cpp_includes. Then the header files are being re-checked +" on the next file write. +" +" let g:syntastic_cpp_auto_refresh_includes = 1 +" +" Alternatively you can set the buffer local variable b:syntastic_cpp_cflags. +" If this variable is set for the current buffer no search for additional +" libraries is done. I.e. set the variable like this: +" +" let b:syntastic_cpp_cflags = ' -I/usr/include/libsoup-2.4' +" +" In order to add some custom include directories that should be added to the +" gcc command line you can add those to the global variable +" g:syntastic_cpp_include_dirs. This list can be used like this: +" +" let g:syntastic_cpp_include_dirs = [ 'includes', 'headers' ] +" +" Moreover it is possible to add additional compiler options to the syntax +" checking execution via the variable 'g:syntastic_cpp_compiler_options': +" +" let g:syntastic_cpp_compiler_options = ' -std=c++0x' +" +" Additionally the setting 'g:syntastic_cpp_config_file' allows you to define +" a file that contains additional compiler arguments like include directories +" or CFLAGS. The file is expected to contain one option per line. If none is +" given the filename defaults to '.syntastic_cpp_config': +" +" let g:syntastic_cpp_config_file = '.config' +" +" Using the global variable 'g:syntastic_cpp_remove_include_errors' you can +" specify whether errors of files included via the +" g:syntastic_cpp_include_dirs' setting are removed from the result set: +" +" let g:syntastic_cpp_remove_include_errors = 1 +" +" Use the variable 'g:syntastic_cpp_errorformat' to override the default error +" format: +" +" let g:syntastic_cpp_errorformat = '%f:%l:%c: %trror: %m' +" +" Set your compiler executable with e.g. (defaults to g++) +" +" let g:syntastic_cpp_compiler = 'clang++' + +if exists('g:loaded_syntastic_cpp_gcc_checker') + finish +endif +let g:loaded_syntastic_cpp_gcc_checker = 1 + +if !exists('g:syntastic_cpp_compiler') + let g:syntastic_cpp_compiler = 'g++' +endif + +function! SyntaxCheckers_cpp_gcc_IsAvailable() + return executable(g:syntastic_cpp_compiler) +endfunction + +let s:save_cpo = &cpo +set cpo&vim + +if !exists('g:syntastic_cpp_compiler_options') + let g:syntastic_cpp_compiler_options = '' +endif + +if !exists('g:syntastic_cpp_config_file') + let g:syntastic_cpp_config_file = '.syntastic_cpp_config' +endif + +function! SyntaxCheckers_cpp_gcc_GetLocList() + let makeprg = g:syntastic_cpp_compiler . ' -x c++ -fsyntax-only ' + let errorformat = + \ '%-G%f:%s:,' . + \ '%f:%l:%c: %trror: %m,' . + \ '%f:%l:%c: %tarning: %m,' . + \ '%f:%l:%c: %m,'. + \ '%f:%l: %trror: %m,'. + \ '%f:%l: %tarning: %m,'. + \ '%f:%l: %m' + + if exists('g:syntastic_cpp_errorformat') + let errorformat = g:syntastic_cpp_errorformat + endif + + " add optional user-defined compiler options + let makeprg .= g:syntastic_cpp_compiler_options + + let makeprg .= ' ' . shellescape(expand('%')) . + \ ' ' . syntastic#c#GetIncludeDirs('cpp') + + " determine whether to parse header files as well + if expand('%') =~? '\.\(h\|hpp\|hh\)$' + if exists('g:syntastic_cpp_check_header') + let makeprg = g:syntastic_cpp_compiler . + \ ' -c ' . shellescape(expand('%')) . + \ ' ' . g:syntastic_cpp_compiler_options . + \ ' ' . syntastic#c#GetNullDevice() . + \ ' ' . syntastic#c#GetIncludeDirs('cpp') + else + return [] + endif + endif + + " check if the user manually set some cflags + if !exists('b:syntastic_cpp_cflags') + " check whether to search for include files at all + if !exists('g:syntastic_cpp_no_include_search') || + \ g:syntastic_cpp_no_include_search != 1 + " refresh the include file search if desired + if exists('g:syntastic_cpp_auto_refresh_includes') && + \ g:syntastic_cpp_auto_refresh_includes != 0 + let makeprg .= syntastic#c#SearchHeaders() + else + " search for header includes if not cached already + if !exists('b:syntastic_cpp_includes') + let b:syntastic_cpp_includes = syntastic#c#SearchHeaders() + endif + let makeprg .= b:syntastic_cpp_includes + endif + endif + else + " use the user-defined cflags + let makeprg .= b:syntastic_cpp_cflags + endif + + " add optional config file parameters + let makeprg .= ' ' . syntastic#c#ReadConfig(g:syntastic_cpp_config_file) + + " process makeprg + let errors = SyntasticMake({ 'makeprg': makeprg, + \ 'errorformat': errorformat }) + + " filter the processed errors if desired + if exists('g:syntastic_cpp_remove_include_errors') && + \ g:syntastic_cpp_remove_include_errors != 0 + return filter(errors, + \ 'has_key(v:val, "bufnr") && v:val["bufnr"]=='.bufnr('')) + else + return errors + endif +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'cpp', + \ 'name': 'gcc'}) + +let &cpo = s:save_cpo +unlet s:save_cpo + +" vim: set et sts=4 sw=4: diff --git a/bundle/syntastic/syntax_checkers/cpp/ycm.vim b/bundle/syntastic/syntax_checkers/cpp/ycm.vim new file mode 100644 index 00000000..97827a08 --- /dev/null +++ b/bundle/syntastic/syntax_checkers/cpp/ycm.vim @@ -0,0 +1,34 @@ +"============================================================================ +"File: ycm.vim +"Description: Syntax checking plugin for syntastic.vim +"Maintainer: Val Markovic +"License: This program is free software. It comes without any warranty, +" to the extent permitted by applicable law. You can redistribute +" it and/or modify it under the terms of the Do What The Fuck You +" Want To Public License, Version 2, as published by Sam Hocevar. +" See http://sam.zoy.org/wtfpl/COPYING for more details. +" +"============================================================================ + +if exists("loaded_ycm_cpp_syntax_checker") + finish +endif +let loaded_ycm_cpp_syntax_checker = 1 + +runtime syntax_checkers/c/ycm.vim + +function! SyntaxCheckers_cpp_ycm_IsAvailable() + return SyntaxCheckers_c_ycm_IsAvailable() +endfunction + +if !exists('g:loaded_youcompleteme') + finish +endif + +function! SyntaxCheckers_cpp_ycm_GetLocList() + return SyntaxCheckers_c_ycm_GetLocList() +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'cpp', + \ 'name': 'ycm'}) diff --git a/bundle/syntastic/syntax_checkers/cs/mcs.vim b/bundle/syntastic/syntax_checkers/cs/mcs.vim new file mode 100644 index 00000000..da809fd3 --- /dev/null +++ b/bundle/syntastic/syntax_checkers/cs/mcs.vim @@ -0,0 +1,35 @@ +"============================================================================ +"File: cs.vim +"Description: Syntax checking plugin for syntastic.vim +"Maintainer: Daniel Walker +"License: This program is free software. It comes without any warranty, +" to the extent permitted by applicable law. You can redistribute +" it and/or modify it under the terms of the Do What The Fuck You +" Want To Public License, Version 2, as published by Sam Hocevar. +" See http://sam.zoy.org/wtfpl/COPYING for more details. +" +"============================================================================ + +if exists("g:loaded_syntastic_cs_mcs_checker") + finish +endif +let g:loaded_syntastic_cs_mcs_checker=1 + +function! SyntaxCheckers_cs_mcs_IsAvailable() + return executable('mcs') +endfunction + +function! SyntaxCheckers_cs_mcs_GetLocList() + let makeprg = syntastic#makeprg#build({ + \ 'exe': 'mcs', + \ 'args': '--parse', + \ 'subchecker': 'mcs' }) + let errorformat = '%f(%l\,%c): %trror %m' + return SyntasticMake({ 'makeprg': makeprg, + \ 'errorformat': errorformat, + \ 'defaults': {'bufnr': bufnr("")} }) +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'cs', + \ 'name': 'mcs'}) diff --git a/bundle/syntastic/syntax_checkers/css/csslint.vim b/bundle/syntastic/syntax_checkers/css/csslint.vim new file mode 100644 index 00000000..269a9c8d --- /dev/null +++ b/bundle/syntastic/syntax_checkers/css/csslint.vim @@ -0,0 +1,52 @@ +"============================================================================ +"File: css.vim +"Description: Syntax checking plugin for syntastic.vim using `csslint` CLI tool (http://csslint.net). +"Maintainer: Ory Band +"License: This program is free software. It comes without any warranty, +" to the extent permitted by applicable law. You can redistribute +" it and/or modify it under the terms of the Do What 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 + +function! SyntaxCheckers_css_csslint_IsAvailable() + return executable('csslint') +endfunction + +function! SyntaxCheckers_css_csslint_GetLocList() + let makeprg = syntastic#makeprg#build({ + \ 'exe': 'csslint', + \ 'args': '--format=compact ' . g:syntastic_csslint_options, + \ 'subchecker': 'csslint' }) + + " Print CSS Lint's error/warning messages from compact format. Ignores blank lines. + let errorformat = + \ '%-G,' . + \ '%-G%f: lint free!,' . + \ '%f: line %l\, col %c\, %trror - %m,' . + \ '%f: line %l\, col %c\, %tarning - %m,'. + \ '%f: line %l\, col %c\, %m,' + + return SyntasticMake({ 'makeprg': makeprg, + \ 'errorformat': errorformat, + \ 'defaults': {'bufnr': bufnr("")} }) + +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'css', + \ 'name': 'csslint'}) diff --git a/bundle/syntastic/syntax_checkers/css/phpcs.vim b/bundle/syntastic/syntax_checkers/css/phpcs.vim new file mode 100644 index 00000000..aebedac5 --- /dev/null +++ b/bundle/syntastic/syntax_checkers/css/phpcs.vim @@ -0,0 +1,33 @@ +"============================================================================ +"File: phpcs.vim +"Description: Syntax checking plugin for syntastic.vim +"Maintainer: LCD 47 +"License: This program is free software. It comes without any warranty, +" to the extent permitted by applicable law. You can redistribute +" it and/or modify it under the terms of the Do What 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/phpcs.vim + +function! SyntaxCheckers_css_phpcs_IsAvailable() + return SyntaxCheckers_php_phpcs_IsAvailable() +endfunction + +function! SyntaxCheckers_css_phpcs_GetLocList() + return SyntaxCheckers_php_phpcs_GetLocList() +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'css', + \ 'name': 'phpcs'}) diff --git a/bundle/syntastic/syntax_checkers/css/prettycss.vim b/bundle/syntastic/syntax_checkers/css/prettycss.vim new file mode 100644 index 00000000..204b5142 --- /dev/null +++ b/bundle/syntastic/syntax_checkers/css/prettycss.vim @@ -0,0 +1,61 @@ +"============================================================================ +"File: prettycss.vim +"Description: Syntax checking plugin for syntastic.vim +"Maintainer: LCD 47 +"License: This program is free software. It comes without any warranty, +" to the extent permitted by applicable law. You can redistribute +" it and/or modify it under the terms of the Do What The Fuck You +" Want To Public License, Version 2, as published by Sam Hocevar. +" See http://sam.zoy.org/wtfpl/COPYING for more details. +" +"============================================================================ +" +" For details about PrettyCSS see: +" +" - http://fidian.github.io/PrettyCSS/ +" - https://github.com/fidian/PrettyCSS + +if exists("g:loaded_syntastic_css_prettycss_checker") + finish +endif +let g:loaded_syntastic_css_prettycss_checker=1 + +function! SyntaxCheckers_css_prettycss_IsAvailable() + return executable('prettycss') +endfunction + +function! SyntaxCheckers_css_prettycss_GetHighlightRegex(item) + let term = matchstr(a:item["text"], ' (\zs[^)]\+\ze)$') + if term != '' + let term = '\V' . term + endif + return term +endfunction + +function! SyntaxCheckers_css_prettycss_GetLocList() + let makeprg = syntastic#makeprg#build({ + \ 'exe': 'prettycss', + \ 'subchecker': 'prettycss' }) + + " Print CSS Lint's error/warning messages from compact format. Ignores blank lines. + let errorformat = + \ '%EError: %m\, line %l\, char %c),' . + \ '%WWarning: %m\, line %l\, char %c),' . + \ '%-G%.%#' + + let loclist = SyntasticMake({ + \ 'makeprg': makeprg, + \ 'errorformat': errorformat, + \ 'defaults': {'bufnr': bufnr("")}, + \ 'postprocess': ['sort'] }) + + for n in range(len(loclist)) + let loclist[n]["text"] .= ')' + endfor + + return loclist +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'css', + \ 'name': 'prettycss'}) diff --git a/bundle/syntastic/syntax_checkers/cucumber/cucumber.vim b/bundle/syntastic/syntax_checkers/cucumber/cucumber.vim new file mode 100644 index 00000000..70e5bab8 --- /dev/null +++ b/bundle/syntastic/syntax_checkers/cucumber/cucumber.vim @@ -0,0 +1,38 @@ +"============================================================================ +"File: cucumber.vim +"Description: Syntax checking plugin for syntastic.vim +"Maintainer: Martin Grenfell +"License: This program is free software. It comes without any warranty, +" to the extent permitted by applicable law. You can redistribute +" it and/or modify it under the terms of the Do What The Fuck You +" Want To Public License, Version 2, as published by Sam Hocevar. +" See http://sam.zoy.org/wtfpl/COPYING for more details. +" +"============================================================================ + +if exists("g:loaded_syntastic_cucumber_cucumber_checker") + finish +endif +let g:loaded_syntastic_cucumber_cucumber_checker=1 + +function! SyntaxCheckers_cucumber_cucumber_IsAvailable() + return executable('cucumber') +endfunction + +function! SyntaxCheckers_cucumber_cucumber_GetLocList() + let makeprg = syntastic#makeprg#build({ + \ 'exe': 'cucumber', + \ 'args': '--dry-run --quiet --strict --format pretty', + \ 'subchecker': 'cucumber' }) + let errorformat = + \ '%f:%l:%c:%m,' . + \ '%W %.%# (%m),' . + \ '%-Z%f:%l:%.%#,'. + \ '%-G%.%#' + + return SyntasticMake({ 'makeprg': makeprg, 'errorformat': errorformat }) +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'cucumber', + \ 'name': 'cucumber'}) diff --git a/bundle/syntastic/syntax_checkers/cuda/nvcc.vim b/bundle/syntastic/syntax_checkers/cuda/nvcc.vim new file mode 100644 index 00000000..d570152c --- /dev/null +++ b/bundle/syntastic/syntax_checkers/cuda/nvcc.vim @@ -0,0 +1,67 @@ +"============================================================================ +"File: cuda.vim +"Description: Syntax checking plugin for syntastic.vim +" +"Author: Hannes Schulz +" +"============================================================================ + +" in order to also check header files add this to your .vimrc: +" (this creates an empty .syntastic_dummy.cu file in your source directory) +" +" let g:syntastic_cuda_check_header = 1 + +" By default, nvcc and thus syntastic, defaults to the most basic architecture. +" This can produce false errors if the developer intends to compile for newer +" hardware and use newer features, eg. double precision numbers. To pass a +" specific target arch to nvcc, e.g. add the following to your .vimrc: +" +" let g:syntastic_cuda_arch = "sm_20" + + +if exists("g:loaded_syntastic_cuda_nvcc_checker") + finish +endif +let g:loaded_syntastic_cuda_nvcc_checker=1 + +function! SyntaxCheckers_cuda_nvcc_IsAvailable() + return executable('nvcc') +endfunction + +function! SyntaxCheckers_cuda_nvcc_GetLocList() + if exists('g:syntastic_cuda_arch') + let arch_flag = '-arch='.g:syntastic_cuda_arch + else + let arch_flag = '' + endif + let makeprg = 'nvcc '.arch_flag.' --cuda -O0 -I . -Xcompiler -fsyntax-only '.shellescape(expand('%')).' -o /dev/null' + let errorformat = + \ '%*[^"]"%f"%*\D%l: %m,'. + \ '"%f"%*\D%l: %m,'. + \ '%-G%f:%l: (Each undeclared identifier is reported only once,'. + \ '%-G%f:%l: for each function it appears in.),'. + \ '%f:%l:%c:%m,'. + \ '%f(%l):%m,'. + \ '%f:%l:%m,'. + \ '"%f"\, line %l%*\D%c%*[^ ] %m,'. + \ '%D%*\a[%*\d]: Entering directory `%f'','. + \ '%X%*\a[%*\d]: Leaving directory `%f'','. + \ '%D%*\a: Entering directory `%f'','. + \ '%X%*\a: Leaving directory `%f'','. + \ '%DMaking %*\a in %f,'. + \ '%f|%l| %m' + + if expand('%') =~? '\%(.h\|.hpp\|.cuh\)$' + if exists('g:syntastic_cuda_check_header') + let makeprg = 'echo > .syntastic_dummy.cu ; nvcc '.arch_flag.' --cuda -O0 -I . .syntastic_dummy.cu -Xcompiler -fsyntax-only -include '.shellescape(expand('%')).' -o /dev/null' + else + return [] + endif + endif + + return SyntasticMake({ 'makeprg': makeprg, 'errorformat': errorformat }) +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'cuda', + \ 'name': 'nvcc'}) diff --git a/bundle/syntastic/syntax_checkers/d/dmd.vim b/bundle/syntastic/syntax_checkers/d/dmd.vim new file mode 100644 index 00000000..0cb1de71 --- /dev/null +++ b/bundle/syntastic/syntax_checkers/d/dmd.vim @@ -0,0 +1,177 @@ +"============================================================================ +"File: d.vim +"Description: Syntax checking plugin for syntastic.vim +"Maintainer: Alfredo Di Napoli +"License: Based on the original work of Gregor Uhlenheuer and his +" cpp.vim checker so credits are dued. +" THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +" EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES +" OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +" NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT +" HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, +" WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING +" FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR +" OTHER DEALINGS IN THE SOFTWARE. +" +"============================================================================ + +" In order to also check header files add this to your .vimrc: +" +" let g:syntastic_d_check_header = 1 +" +" To disable the search of included header files after special +" libraries like gtk and glib add this line to your .vimrc: +" +" let g:syntastic_d_no_include_search = 1 +" +" To disable the include of the default include dirs (such as /usr/include) +" add this line to your .vimrc: +" +" let g:syntastic_d_no_default_include_dirs = 1 +" +" To enable header files being re-checked on every file write add the +" following line to your .vimrc. Otherwise the header files are checked only +" one time on initially loading the file. +" In order to force syntastic to refresh the header includes simply +" unlet b:syntastic_d_includes. Then the header files are being re-checked +" on the next file write. +" +" let g:syntastic_d_auto_refresh_includes = 1 +" +" Alternatively you can set the buffer local variable b:syntastic_d_cflags. +" If this variable is set for the current buffer no search for additional +" libraries is done. I.e. set the variable like this: +" +" let b:syntastic_d_cflags = ' -I/usr/include/libsoup-2.4' +" +" In order to add some custom include directories that should be added to the +" dmd command line you can add those to the global variable +" g:syntastic_d_include_dirs. This list can be used like this: +" +" let g:syntastic_d_include_dirs = [ 'includes', 'headers' ] +" +" Moreover it is possible to add additional compiler options to the syntax +" checking execution via the variable 'g:syntastic_d_compiler_options': +" +" let g:syntastic_d_compiler_options = ' -std=c++0x' +" +" Additionally the setting 'g:syntastic_d_config_file' allows you to define +" a file that contains additional compiler arguments like include directories +" or CFLAGS. The file is expected to contain one option per line. If none is +" given the filename defaults to '.syntastic_d_config': +" +" let g:syntastic_d_config_file = '.config' +" +" Using the global variable 'g:syntastic_d_remove_include_errors' you can +" specify whether errors of files included via the +" g:syntastic_d_include_dirs' setting are removed from the result set: +" +" let g:syntastic_d_remove_include_errors = 1 +" +" Use the variable 'g:syntastic_d_errorformat' to override the default error +" format: +" +" let g:syntastic_d_errorformat = '%f:%l:%c: %trror: %m' +" +" Set your compiler executable with e.g. (defaults to dmd) +" +" let g:syntastic_d_compiler = 'clang++' + +if exists('g:loaded_syntastic_d_dmd_checker') + finish +endif +let g:loaded_syntastic_d_dmd_checker = 1 + +if !exists('g:syntastic_d_compiler') + let g:syntastic_d_compiler = 'dmd' +endif + +function! SyntaxCheckers_d_dmd_IsAvailable() + return executable(g:syntastic_d_compiler) +endfunction + +let s:save_cpo = &cpo +set cpo&vim + +if !exists('g:syntastic_d_compiler_options') + let g:syntastic_d_compiler_options = '' +endif + +if !exists('g:syntastic_d_config_file') + let g:syntastic_d_config_file = '.syntastic_d_config' +endif + +function! SyntaxCheckers_d_dmd_GetLocList() + let makeprg = g:syntastic_d_compiler . ' -c -of' . syntastic#util#DevNull() . ' ' + let errorformat = '%-G%f:%s:,%f(%l): %m,%f:%l: %m' + + if exists('g:syntastic_d_errorformat') + let errorformat = g:syntastic_d_errorformat + endif + + " add optional user-defined compiler options + let makeprg .= g:syntastic_d_compiler_options + + let makeprg .= ' ' . shellescape(expand('%')) . + \ ' ' . syntastic#c#GetIncludeDirs('d') + + " determine whether to parse header files as well + if expand('%') =~? '\.di$' + if exists('g:syntastic_d_check_header') + let makeprg = g:syntastic_d_compiler . + \ ' -c ' . shellescape(expand('%')) . + \ ' -of' . syntastic#util#DevNull() . + \ ' ' . g:syntastic_d_compiler_options . + \ ' ' . syntastic#c#GetIncludeDirs('d') + else + return [] + endif + endif + + " check if the user manually set some cflags + if !exists('b:syntastic_d_cflags') + " check whether to search for include files at all + if !exists('g:syntastic_d_no_include_search') || + \ g:syntastic_d_no_include_search != 1 + " refresh the include file search if desired + if exists('g:syntastic_d_auto_refresh_includes') && + \ g:syntastic_d_auto_refresh_includes != 0 + let makeprg .= syntastic#c#SearchHeaders() + else + " search for header includes if not cached already + if !exists('b:syntastic_d_includes') + let b:syntastic_d_includes = syntastic#c#SearchHeaders() + endif + let makeprg .= b:syntastic_d_includes + endif + endif + else + " use the user-defined cflags + let makeprg .= b:syntastic_d_cflags + endif + + " add optional config file parameters + let makeprg .= ' ' . syntastic#c#ReadConfig(g:syntastic_d_config_file) + + " process makeprg + let errors = SyntasticMake({ 'makeprg': makeprg, + \ 'errorformat': errorformat }) + + " filter the processed errors if desired + if exists('g:syntastic_d_remove_include_errors') && + \ g:syntastic_d_remove_include_errors != 0 + return filter(errors, + \ 'has_key(v:val, "bufnr") && v:val["bufnr"]=='.bufnr('')) + else + return errors + endif +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'd', + \ 'name': 'dmd'}) + +let &cpo = s:save_cpo +unlet s:save_cpo + +" vim: set et sts=4 sw=4: diff --git a/bundle/syntastic/syntax_checkers/dart/dart_analyzer.vim b/bundle/syntastic/syntax_checkers/dart/dart_analyzer.vim new file mode 100644 index 00000000..f7b1e01d --- /dev/null +++ b/bundle/syntastic/syntax_checkers/dart/dart_analyzer.vim @@ -0,0 +1,62 @@ +"============================================================================ +"File: dart_analyzer.vim +"Description: Dart syntax checker - using dart_analyzer +"Maintainer: Maksim Ryzhikov +"License: This program is free software. It comes without any warranty, +" to the extent permitted by applicable law. You can redistribute +" it and/or modify it under the terms of the Do What The Fuck You +" Want To Public License, Version 2, as published by Sam Hocevar. +" See http://sam.zoy.org/wtfpl/COPYING for more details. +"============================================================================ +if exists("g:loaded_syntastic_dart_dart_analyzer_checker") + finish +endif +let g:loaded_syntastic_dart_dart_analyzer_checker=1 + +if !exists("g:syntastic_dart_analyzer_conf") + let g:syntastic_dart_analyzer_conf = '' +endif + +function! SyntaxCheckers_dart_dart_analyzer_IsAvailable() + return executable("dart_analyzer") +endfunction + +function! SyntaxCheckers_dart_dart_analyzer_GetHighlightRegex(error) + let lcol = a:error['col'] - 1 + let rcol = a:error['nr'] + lcol + 1 + + return '\%>'.lcol.'c\%<'.rcol.'c' +endfunction + +function! SyntaxCheckers_dart_dart_analyzer_GetLocList() + let args = !empty(g:syntastic_dart_analyzer_conf) ? ' ' . g:syntastic_dart_analyzer_conf : '' + let makeprg = syntastic#makeprg#build({ + \ 'exe': 'dart_analyzer', + \ 'args': '--error_format machine', + \ 'post_args': args, + \ 'subchecker': 'dart_analyzer' }) + " Machine readable format looks like: + " SEVERITY|TYPE|ERROR_CODE|file:FILENAME|LINE_NUMBER|COLUMN|LENGTH|MESSAGE + " SEVERITY: (WARNING|ERROR) + " TYPE: (RESOLVER|STATIC_TYPE|...) + " ERROR_CODE: (NO_SUCH_TYPE|...) + " FILENAME: String + " LINE_NUMBER: int + " COLUMN: int + " LENGHT: int + " MESSAGE: String + + " We use %n to grab the error length to be able to access it in the matcher. + let commonformat = '|%.%#|%.%#|file:%f|%l|%c|%n|%m' + + " TODO(amouravski): simply take everything after ERROR|WARNING as a message + " and then parse it by hand later. + let errorformat = '%EERROR'.l:commonformat.','. + \'%WWARNING'.l:commonformat + + return SyntasticMake({ 'makeprg': makeprg, 'errorformat': errorformat }) +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'dart', + \ 'name': 'dart_analyzer'}) diff --git a/bundle/syntastic/syntax_checkers/docbk/xmllint.vim b/bundle/syntastic/syntax_checkers/docbk/xmllint.vim new file mode 100644 index 00000000..f0612395 --- /dev/null +++ b/bundle/syntastic/syntax_checkers/docbk/xmllint.vim @@ -0,0 +1,30 @@ +"============================================================================ +"File: docbk.vim +"Description: Syntax checking plugin for syntastic.vim +"Maintainer: Martin Grenfell +"License: This program is free software. It comes without any warranty, +" to the extent permitted by applicable law. You can redistribute +" it and/or modify it under the terms of the Do What 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/xmllint.vim + +function! SyntaxCheckers_docbk_xmllint_IsAvailable() + return SyntaxCheckers_xml_xmllint_IsAvailable() +endfunction + +function! SyntaxCheckers_docbk_xmllint_GetLocList() + return SyntaxCheckers_xml_xmllint_GetLocList() +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'docbk', + \ 'name': 'xmllint'}) diff --git a/bundle/syntastic/syntax_checkers/elixir/elixir.vim b/bundle/syntastic/syntax_checkers/elixir/elixir.vim new file mode 100644 index 00000000..cbd91c8c --- /dev/null +++ b/bundle/syntastic/syntax_checkers/elixir/elixir.vim @@ -0,0 +1,42 @@ +"============================================================================ +"File: elixir.vim +"Description: Syntax checking plugin for syntastic.vim +"Maintainer: Richard Ramsden +"License: This program is free software. It comes without any warranty, +" to the extent permitted by applicable law. You can redistribute +" it and/or modify it under the terms of the Do What 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:syntastic_elixir_compile_command = 'elixir' + +if filereadable('mix.exs') + let s:syntastic_elixir_compile_command = 'mix compile' +endif + +function! SyntaxCheckers_elixir_elixir_IsAvailable() + if s:syntastic_elixir_compile_command == 'elixir' + return executable('elixir') + else + return executable('mix') + endif +endfunction + +function! SyntaxCheckers_elixir_elixir_GetLocList() + let makeprg = syntastic#makeprg#build({ + \ 'exe': s:syntastic_elixir_compile_command, + \ 'subchecker': 'elixir' }) + let errorformat = '** %*[^\ ] %f:%l: %m' + + return SyntasticMake({ 'makeprg': makeprg, 'errorformat': errorformat }) +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'elixir', + \ 'name': 'elixir'}) diff --git a/bundle/syntastic/syntax_checkers/erlang/erlang.vim b/bundle/syntastic/syntax_checkers/erlang/erlang.vim new file mode 100644 index 00000000..1a0b2787 --- /dev/null +++ b/bundle/syntastic/syntax_checkers/erlang/erlang.vim @@ -0,0 +1,51 @@ +"============================================================================ +"File: erlang.vim +"Description: Syntax checking plugin for syntastic.vim +"Maintainer: Pawel Salata +"License: This program is free software. It comes without any warranty, +" to the extent permitted by applicable law. You can redistribute +" it and/or modify it under the terms of the Do What The Fuck You +" Want To Public License, Version 2, as published by Sam Hocevar. +" See http://sam.zoy.org/wtfpl/COPYING for more details. +" +"============================================================================ + +if exists("g:loaded_syntastic_erlang_erlang_checker") + finish +endif +let g:loaded_syntastic_erlang_erlang_checker=1 + +let s:check_file = expand(':p:h') . '/erlang_check_file.erl' +if !exists("g:syntastic_erlc_include_path") + let g:syntastic_erlc_include_path="" +endif + +function! SyntaxCheckers_erlang_escript_IsAvailable() + return executable('escript') +endfunction + +function! SyntaxCheckers_erlang_escript_GetLocList() + let extension = expand('%:e') + if match(extension, 'hrl') >= 0 + return [] + endif + let shebang = getbufline(bufnr('%'), 1)[0] + if len(shebang) > 0 + if match(shebang, 'escript') >= 0 + let makeprg = 'escript -s '.shellescape(expand('%:p')) + else + let makeprg = 'escript ' . s:check_file . ' '. shellescape(expand('%:p')).' '.g:syntastic_erlc_include_path + endif + else + let makeprg = 'escript ' . s:check_file . ' ' . shellescape(expand('%:p')).' '.g:syntastic_erlc_include_path + endif + let errorformat = + \ '%f:%l:\ %tarning:\ %m,'. + \ '%E%f:%l:\ %m' + + return SyntasticMake({ 'makeprg': makeprg, 'errorformat': errorformat }) +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'erlang', + \ 'name': 'escript'}) diff --git a/bundle/syntastic/syntax_checkers/erlang/erlang_check_file.erl b/bundle/syntastic/syntax_checkers/erlang/erlang_check_file.erl new file mode 100755 index 00000000..54cc9366 --- /dev/null +++ b/bundle/syntastic/syntax_checkers/erlang/erlang_check_file.erl @@ -0,0 +1,34 @@ +#!/usr/bin/env escript +-export([main/1]). + +main([FileName]) -> + LibDirs = filelib:wildcard("{lib,deps}/*/ebin"), + compile(FileName, LibDirs); +main([FileName | LibDirs]) -> + compile(FileName, LibDirs). + +compile(FileName, LibDirs) -> + Root = get_root(filename:dirname(FileName)), + ok = code:add_pathsa(LibDirs), + compile:file(FileName, [warn_obsolete_guard, + warn_unused_import, + warn_shadow_vars, + warn_export_vars, + strong_validation, + report, + {i, filename:join(Root, "include")}, + {i, filename:join(Root, "deps")}, + {i, filename:join(Root, "apps")}, + {i, filename:join(Root, "lib")} + ]). + +get_root(Dir) -> + Path = filename:split(filename:absname(Dir)), + filename:join(get_root(lists:reverse(Path), Path)). + +get_root([], Path) -> + Path; +get_root(["src" | Tail], _Path) -> + lists:reverse(Tail); +get_root([_ | Tail], Path) -> + get_root(Tail, Path). diff --git a/bundle/syntastic/syntax_checkers/eruby/ruby.vim b/bundle/syntastic/syntax_checkers/eruby/ruby.vim new file mode 100644 index 00000000..aaf023ea --- /dev/null +++ b/bundle/syntastic/syntax_checkers/eruby/ruby.vim @@ -0,0 +1,49 @@ +"============================================================================ +"File: eruby.vim +"Description: Syntax checking plugin for syntastic.vim +"Maintainer: Martin Grenfell +"License: This program is free software. It comes without any warranty, +" to the extent permitted by applicable law. You can redistribute +" it and/or modify it under the terms of the Do What The Fuck You +" Want To Public License, Version 2, as published by Sam Hocevar. +" See http://sam.zoy.org/wtfpl/COPYING for more details. +" +"============================================================================ + +if exists("g:loaded_syntastic_eruby_ruby_checker") + finish +endif +let g:loaded_syntastic_eruby_ruby_checker=1 + +if !exists("g:syntastic_ruby_exec") + let g:syntastic_ruby_exec = "ruby" +endif + +function! SyntaxCheckers_eruby_ruby_IsAvailable() + return executable(expand(g:syntastic_ruby_exec)) +endfunction + +function! SyntaxCheckers_eruby_ruby_GetLocList() + let ruby_exec=expand(g:syntastic_ruby_exec) + if !has('win32') + let ruby_exec='RUBYOPT= ' . ruby_exec + endif + + "gsub fixes issue #7 rails has it's own eruby syntax + let makeprg=ruby_exec . ' -rerb -e "puts ERB.new(File.read(''' . + \ (expand("%")) . + \ ''').gsub(''<\%='',''<\%''), nil, ''-'').src" \| ' . ruby_exec . ' -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}) +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'eruby', + \ 'name': 'ruby'}) diff --git a/bundle/syntastic/syntax_checkers/fortran/gfortran.vim b/bundle/syntastic/syntax_checkers/fortran/gfortran.vim new file mode 100644 index 00000000..0f529df3 --- /dev/null +++ b/bundle/syntastic/syntax_checkers/fortran/gfortran.vim @@ -0,0 +1,58 @@ +"============================================================================ +"File: fortran.vim +"Description: Syntax checking plugin for syntastic.vim +"Maintainer: Karl Yngve Lervåg +"License: This program is free software. It comes without any warranty, +" to the extent permitted by applicable law. You can redistribute +" it and/or modify it under the terms of the Do What The Fuck You +" Want To Public License, Version 2, as published by Sam Hocevar. +" See http://sam.zoy.org/wtfpl/COPYING for more details. +"Note: This syntax checker uses gfortran with the option -fsyntax-only +" to check for errors and warnings. Additional flags may be +" supplied through both local and global variables, +" b:syntastic_fortran_flags, +" g:syntastic_fortran_flags. +" This is particularly useful when the source requires module files +" in order to compile (that is when it needs modules defined in +" separate files). +" +"============================================================================ + +if exists("g:loaded_syntastic_fortran_gfortran_checker") + finish +endif +let g:loaded_syntastic_fortran_gfortran_checker=1 + +if !exists('g:syntastic_fortran_flags') + let g:syntastic_fortran_flags = '' +endif + +function! SyntaxCheckers_fortran_gfortran_IsAvailable() + return executable('gfortran') +endfunction + +function! SyntaxCheckers_fortran_gfortran_GetLocList() + let makeprg = syntastic#makeprg#build({ + \ 'exe': 'gfortran', + \ 'args': s:args(), + \ 'subchecker': 'gfortran' }) + let errorformat = + \ '%-C %#,'. + \ '%-C %#%.%#,'. + \ '%A%f:%l.%c:,'. + \ '%Z%m,'. + \ '%G%.%#' + return SyntasticMake({ 'makeprg': makeprg, 'errorformat': errorformat }) +endfunction + +function s:args() + let rv = '-fsyntax-only ' . g:syntastic_fortran_flags + if exists('b:syntastic_fortran_flags') + let rv .= " " . b:syntastic_fortran_flags + endif + return rv +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'fortran', + \ 'name': 'gfortran'}) diff --git a/bundle/syntastic/syntax_checkers/gentoo_metadata/xmllint.vim b/bundle/syntastic/syntax_checkers/gentoo_metadata/xmllint.vim new file mode 100644 index 00000000..9b81c86f --- /dev/null +++ b/bundle/syntastic/syntax_checkers/gentoo_metadata/xmllint.vim @@ -0,0 +1,40 @@ +"============================================================================ +"File: gentoo-metadata.vim +"Description: Syntax checking plugin for Gentoo's metadata.xml files +"Maintainer: James Rowe +"License: This program is free software. It comes without any warranty, +" to the extent permitted by applicable law. You can redistribute +" it and/or modify it under the terms of the Do What The Fuck You +" Want To Public License, Version 2, as published by Sam Hocevar. +" See http://sam.zoy.org/wtfpl/COPYING for more details. +" +"============================================================================ + +" The DTDs required to validate metadata.xml files are available in +" $PORTDIR/metadata/dtd, and these local files can be used to significantly +" speed up validation. You can create a catalog file with: +" +" xmlcatalog --create --add rewriteURI http://www.gentoo.org/dtd/ \ +" ${PORTDIR:-/usr/portage}/metadata/dtd/ /etc/xml/gentoo +" +" See xmlcatalog(1) and http://www.xmlsoft.org/catalog.html for more +" information. + +if exists("g:loaded_syntastic_gentoo_metadata_xmllint_checker") + finish +endif +let g:loaded_syntastic_gentoo_metadata_xmllint_checker=1 + +runtime syntax_checkers/xml/xmllint.vim + +function! SyntaxCheckers_gentoo_metadata_xmllint_IsAvailable() + return SyntaxCheckers_xml_xmllint_IsAvailable() +endfunction + +function! SyntaxCheckers_gentoo_metadata_xmllint_GetLocList() + return SyntaxCheckers_xml_xmllint_GetLocList() +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'gentoo_metadata', + \ 'name': 'xmllint'}) diff --git a/bundle/syntastic/syntax_checkers/go/go.vim b/bundle/syntastic/syntax_checkers/go/go.vim new file mode 100644 index 00000000..2534bcb5 --- /dev/null +++ b/bundle/syntastic/syntax_checkers/go/go.vim @@ -0,0 +1,64 @@ +"============================================================================ +"File: go.vim +"Description: Check go syntax using 'gofmt -l' followed by 'go [build|test]' +"Maintainer: Kamil Kisiel +"License: This program is free software. It comes without any warranty, +" to the extent permitted by applicable law. You can redistribute +" it and/or modify it under the terms of the Do What 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 Fmt +"============================================================================ +if exists("g:loaded_syntastic_go_go_checker") + finish +endif +let g:loaded_syntastic_go_go_checker=1 + +function! SyntaxCheckers_go_go_IsAvailable() + return executable('go') +endfunction + +function! SyntaxCheckers_go_go_GetLocList() + " Check with gofmt first, since `go build` and `go test` might not report + " syntax errors in the current file if another file with syntax error is + " compiled first. + let makeprg = 'gofmt -l % 1>/dev/null' + let errorformat = '%f:%l:%c: %m,%-G%.%#' + let errors = SyntasticMake({ 'makeprg': makeprg, 'errorformat': errorformat, 'defaults': {'type': 'e'} }) + + if !empty(errors) + return errors + endif + + " Test files, i.e. files with a name ending in `_test.go`, are not + " compiled by `go build`, therefore `go test` must be called for those. + if match(expand('%'), '_test.go$') == -1 + let makeprg = 'go build -o /dev/null' + else + let makeprg = 'go test -c -o /dev/null' + endif + let errorformat = '%f:%l:%c:%m,%f:%l%m,%-G#%.%#' + + " The go compiler needs to either be run with an import path as an + " argument or directly from the package directory. Since figuring out + " the poper import path is fickle, just pushd/popd to the package. + let popd = getcwd() + let pushd = expand('%:p:h') + " + " pushd + exec 'lcd ' . fnameescape(pushd) + + let errors = SyntasticMake({ 'makeprg': makeprg, 'errorformat': errorformat }) + + " popd + exec 'lcd ' . fnameescape(popd) + + return errors +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'go', + \ 'name': 'go'}) diff --git a/bundle/syntastic/syntax_checkers/go/gofmt.vim b/bundle/syntastic/syntax_checkers/go/gofmt.vim new file mode 100644 index 00000000..804065f9 --- /dev/null +++ b/bundle/syntastic/syntax_checkers/go/gofmt.vim @@ -0,0 +1,36 @@ +"============================================================================ +"File: gofmt.vim +"Description: Check go syntax using 'gofmt -l' +"Maintainer: Brandon Thomson +"License: This program is free software. It comes without any warranty, +" to the extent permitted by applicable law. You can redistribute +" it and/or modify it under the terms of the Do What 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 Fmt +"============================================================================ +if exists("g:loaded_syntastic_go_gofmt_checker") + finish +endif +let g:loaded_syntastic_go_gofmt_checker=1 + +function! SyntaxCheckers_go_gofmt_IsAvailable() + return executable('gofmt') +endfunction + +function! SyntaxCheckers_go_gofmt_GetLocList() + let makeprg = syntastic#makeprg#build({ + \ 'exe': 'gofmt', + \ 'args': '-l', + \ 'tail': '1>' . syntastic#util#DevNull(), + \ 'subchecker': 'gofmt' }) + 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'}) diff --git a/bundle/syntastic/syntax_checkers/go/govet.vim b/bundle/syntastic/syntax_checkers/go/govet.vim new file mode 100644 index 00000000..b4f00682 --- /dev/null +++ b/bundle/syntastic/syntax_checkers/go/govet.vim @@ -0,0 +1,44 @@ +"============================================================================ +"File: govet.vim +"Description: Perform static analysis of Go code with the vet tool +"Maintainer: Kamil Kisiel +"License: This program is free software. It comes without any warranty, +" to the extent permitted by applicable law. You can redistribute +" it and/or modify it under the terms of the Do What The Fuck You +" Want To Public License, Version 2, as published by Sam Hocevar. +" See http://sam.zoy.org/wtfpl/COPYING for more details. +" +"============================================================================ +if exists("g:loaded_syntastic_go_govet_checker") + finish +endif +let g:loaded_syntastic_go_govet_checker=1 + +function! SyntaxCheckers_go_govet_IsAvailable() + return executable('go') +endfunction + +function! SyntaxCheckers_go_govet_GetLocList() + let makeprg = 'go vet' + let errorformat = '%Evet: %.%\+: %f:%l:%c: %m,%W%f:%l: %m,%-G%.%#' + + " The go tool needs to either be run with an import path as an + " argument or directly from the package directory. Since figuring out + " the poper import path is fickle, just pushd/popd to the package. + let popd = getcwd() + let pushd = expand('%:p:h') + " + " pushd + exec 'lcd ' . fnameescape(pushd) + + let errors = SyntasticMake({ 'makeprg': makeprg, 'errorformat': errorformat, 'defaults': {'type': 'w'} }) + + " popd + exec 'lcd ' . fnameescape(popd) + + return errors +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'go', + \ 'name': 'govet'}) diff --git a/bundle/syntastic/syntax_checkers/haml/haml.vim b/bundle/syntastic/syntax_checkers/haml/haml.vim new file mode 100644 index 00000000..62fdfafe --- /dev/null +++ b/bundle/syntastic/syntax_checkers/haml/haml.vim @@ -0,0 +1,33 @@ +"============================================================================ +"File: haml.vim +"Description: Syntax checking plugin for syntastic.vim +"Maintainer: Martin Grenfell +"License: This program is free software. It comes without any warranty, +" to the extent permitted by applicable law. You can redistribute +" it and/or modify it under the terms of the Do What 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 + +function! SyntaxCheckers_haml_haml_IsAvailable() + return executable('haml') +endfunction + +function! SyntaxCheckers_haml_haml_GetLocList() + let makeprg = syntastic#makeprg#build({ + \ 'exe': 'haml', + \ 'args': '-c', + \ 'subchecker': 'haml' }) + let errorformat = 'Haml error on line %l: %m,Syntax error on line %l: %m,%-G%.%#' + return SyntasticMake({ 'makeprg': makeprg, 'errorformat': errorformat }) +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'haml', + \ 'name': 'haml'}) diff --git a/bundle/syntastic/syntax_checkers/haskell/ghc-mod.vim b/bundle/syntastic/syntax_checkers/haskell/ghc-mod.vim new file mode 100644 index 00000000..43131001 --- /dev/null +++ b/bundle/syntastic/syntax_checkers/haskell/ghc-mod.vim @@ -0,0 +1,48 @@ +"============================================================================ +"File: ghc-mod.vim +"Description: Syntax checking plugin for syntastic.vim +"Maintainer: Anthony Carapetis +"License: This program is free software. It comes without any warranty, +" to the extent permitted by applicable law. You can redistribute +" it and/or modify it under the terms of the Do What The Fuck You +" Want To Public License, Version 2, as published by Sam Hocevar. +" See http://sam.zoy.org/wtfpl/COPYING for more details. +" +"============================================================================ + +if exists("g:loaded_syntastic_haskell_ghc_mod_checker") + finish +endif +let g:loaded_syntastic_haskell_ghc_mod_checker=1 + +function! SyntaxCheckers_haskell_ghc_mod_IsAvailable() + return executable('ghc-mod') +endfunction + +function! SyntaxCheckers_haskell_ghc_mod_GetLocList() + let 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' + + let makeprg = syntastic#makeprg#build({ + \ 'exe': 'ghc-mod check', + \ 'args': '--hlintOpt="--language=XmlSyntax"' }) + let loclist1 = SyntasticMake({ 'makeprg': makeprg, 'errorformat': errorformat }) + + let makeprg = syntastic#makeprg#build({ + \ 'exe': 'ghc-mod lint', + \ 'args': '--hlintOpt="--language=XmlSyntax"' }) + let loclist2 = SyntasticMake({ 'makeprg': makeprg, 'errorformat': errorformat }) + + return loclist1 + loclist2 +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'haskell', + \ 'name': 'ghc_mod'}) diff --git a/bundle/syntastic/syntax_checkers/haskell/hdevtools.vim b/bundle/syntastic/syntax_checkers/haskell/hdevtools.vim new file mode 100644 index 00000000..fd43b349 --- /dev/null +++ b/bundle/syntastic/syntax_checkers/haskell/hdevtools.vim @@ -0,0 +1,45 @@ +"============================================================================ +"File: hdevtools.vim +"Description: Syntax checking plugin for syntastic.vim +"Maintainer: Anthony Carapetis +"License: This program is free software. It comes without any warranty, +" to the extent permitted by applicable law. You can redistribute +" it and/or modify it under the terms of the Do What The Fuck You +" Want To Public License, Version 2, as published by Sam Hocevar. +" See http://sam.zoy.org/wtfpl/COPYING for more details. +" +"============================================================================ + +if exists("g:loaded_syntastic_haskell_hdevtools_checker") + finish +endif +let g:loaded_syntastic_haskell_hdevtools_checker=1 + +function! SyntaxCheckers_haskell_hdevtools_IsAvailable() + return executable('hdevtools') +endfunction + +function! SyntaxCheckers_haskell_hdevtools_GetLocList() + let makeprg = syntastic#makeprg#build({ + \ 'exe': 'hdevtools check', + \ 'args': get(g:, 'hdevtools_options', ''), + \ 'subchecker': 'hdevtools' }) + + let errorformat= '\%-Z\ %#,'. + \ '%W%f:%l:%c:\ Warning:\ %m,'. + \ '%E%f:%l:%c:\ %m,'. + \ '%E%>%f:%l:%c:,'. + \ '%+C\ \ %#%m,'. + \ '%W%>%f:%l:%c:,'. + \ '%+C\ \ %#%tarning:\ %m,' + + return SyntasticMake({ + \ 'makeprg': makeprg, + \ 'errorformat': errorformat, + \ 'postprocess': ['compressWhitespace'] }) +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'haskell', + \ 'name': 'hdevtools'}) + diff --git a/bundle/syntastic/syntax_checkers/haxe/haxe.vim b/bundle/syntastic/syntax_checkers/haxe/haxe.vim new file mode 100644 index 00000000..97095eec --- /dev/null +++ b/bundle/syntastic/syntax_checkers/haxe/haxe.vim @@ -0,0 +1,59 @@ +"============================================================================ +"File: haxe.vim +"Description: Syntax checking plugin for syntastic.vim +"Maintainer: David Bernard +"License: This program is free software. It comes without any warranty, +" to the extent permitted by applicable law. You can redistribute +" it and/or modify it under the terms of the Do What The Fuck You +" Want To Public License, Version 2, as published by Sam Hocevar. +" See http://sam.zoy.org/wtfpl/COPYING for more details. +" +"============================================================================ + +if exists("g:loaded_syntastic_haxe_haxe_checker") + finish +endif +let g:loaded_syntastic_haxe_haxe_checker=1 + +function! SyntaxCheckers_haxe_haxe_IsAvailable() + return executable('haxe') +endfunction + +" s:FindInParent +" find the file argument and returns the path to it. +" Starting with the current working dir, it walks up the parent folders +" until it finds the file, or it hits the stop dir. +" If it doesn't find it, it returns "Nothing" +function! s:FindInParent(fln,flsrt,flstp) + let here = a:flsrt + while ( strlen( here) > 0 ) + let p = split(globpath(here, a:fln), '\n') + if len(p) > 0 + return ['ok', here, fnamemodify(p[0], ':p:t')] + endif + let fr = match(here, '/[^/]*$') + if fr == -1 + break + endif + let here = strpart(here, 0, fr) + if here == a:flstp + break + endif + endwhile + return ['fail', '', ''] +endfunction + +function! SyntaxCheckers_haxe_haxe_GetLocList() + let [success, hxmldir, hxmlname] = s:FindInParent('*.hxml', expand('%:p:h'), '/') + if success == 'ok' + let makeprg = 'cd ' . hxmldir . '; haxe ' . hxmlname + let errorformat = '%E%f:%l: characters %c-%*[0-9] : %m' + return SyntasticMake({ 'makeprg': makeprg, 'errorformat': errorformat }) + else + return SyntasticMake({}) + endif +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'haxe', + \ 'name': 'haxe'}) diff --git a/bundle/syntastic/syntax_checkers/html/tidy.vim b/bundle/syntastic/syntax_checkers/html/tidy.vim new file mode 100644 index 00000000..a3002d25 --- /dev/null +++ b/bundle/syntastic/syntax_checkers/html/tidy.vim @@ -0,0 +1,110 @@ +"============================================================================ +"File: tidy.vim +"Description: Syntax checking plugin for syntastic.vim +"Maintainer: Martin Grenfell +"License: This program is free software. It comes without any warranty, +" to the extent permitted by applicable law. You can redistribute +" it and/or modify it under the terms of the Do What 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 + +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 + +function! SyntaxCheckers_html_tidy_IsAvailable() + return executable('tidy') +endfunction + +" TODO: join this with xhtml.vim for DRY's sake? +function! s:TidyEncOptByFenc() + let tidy_opts = { + \'utf-8' : '-utf8', + \'ascii' : '-ascii', + \'latin1' : '-latin1', + \'iso-2022-jp' : '-iso-2022', + \'cp1252' : '-win1252', + \'macroman' : '-mac', + \'utf-16le' : '-utf16le', + \'utf-16' : '-utf16', + \'big5' : '-big5', + \'cp932' : '-shiftjis', + \'sjis' : '-shiftjis', + \'cp850' : '-ibm858', + \} + return get(tidy_opts, &fileencoding, '-utf8') +endfunction + +let s:ignore_html_errors = [ + \ " lacks \"summary\" attribute", + \ "not approved by W3C", + \ "attribute \"placeholder\"", + \ " proprietary attribute \"charset\"", + \ " lacks \"content\" attribute", + \ "inserting \"type\" attribute", + \ "proprietary attribute \"data-", + \ "missing declaration", + \ "inserting implicit ", + \ "inserting missing 'title' element", + \ "attribute \"[+", + \ "unescaped & or unknown entity", + \ " attribute \"type\" has invalid value \"search\"" + \ ] + +function! s:IgnoreErrror(text) + for i in s:ignore_html_errors + g:syntastic_html_tidy_ignore_errors + if stridx(a:text, i) != -1 + return 1 + endif + endfor + return 0 +endfunction + +function s:Args() + let args = s:TidyEncOptByFenc() . + \ ' --new-blocklevel-tags ' . shellescape('main, section, article, aside, hgroup, header, footer, nav, figure, figcaption') . + \ ' --new-inline-tags ' . shellescape('video, audio, source, embed, mark, progress, meter, time, ruby, rt, rp, canvas, command, details, datalist') . + \ ' --new-empty-tags ' . shellescape('wbr, keygen') . + \ ' -e' + return args +endfunction + +function! SyntaxCheckers_html_tidy_GetLocList() + let makeprg = syntastic#makeprg#build({ + \ 'exe': 'tidy', + \ 'args': s:Args(), + \ 'tail': '2>&1', + \ 'subchecker': 'tidy' }) + let errorformat = + \ '%Wline %l column %v - Warning: %m,' . + \ '%Eline %l column %v - Error: %m,' . + \ '%-G%.%#' + + let loclist = SyntasticMake({ 'makeprg': makeprg, 'errorformat': errorformat, 'defaults': {'bufnr': bufnr("")} }) + + " filter out valid HTML5 from the errors + for n in range(len(loclist)) + if loclist[n]['valid'] && s:IgnoreErrror(loclist[n]['text']) == 1 + let loclist[n]['valid'] = 0 + endif + endfor + + return loclist +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'html', + \ 'name': 'tidy'}) + diff --git a/bundle/syntastic/syntax_checkers/html/validator.vim b/bundle/syntastic/syntax_checkers/html/validator.vim new file mode 100644 index 00000000..bf41edee --- /dev/null +++ b/bundle/syntastic/syntax_checkers/html/validator.vim @@ -0,0 +1,78 @@ +"============================================================================ +"File: validator.vim +"Description: Syntax checking plugin for syntastic.vim +"Maintainer: LCD 47 +"License: This program is free software. It comes without any warranty, +" to the extent permitted by applicable law. You can redistribute +" it and/or modify it under the terms of the Do What The Fuck You +" Want To Public License, Version 2, as published by Sam Hocevar. +" See http://sam.zoy.org/wtfpl/COPYING for more details. +" +"============================================================================ +" +" For detail;s about validator see: http://about.validator.nu/ +" +" Checker options: +" +" - g:syntastic_html_validator_api (string; default: 'http://validator.nu/') +" URL of the service to use for checking; leave it to the default to run the +" checks against http://validator.nu/, or set it to 'http://localhost:8888/' +" if you're running a local service as per http://about.validator.nu/#src +" +" - g:syntastic_html_validator_parser (string; default: empty) +" parser to use; legal values are: xml, xmldtd, html, html5, html4, html4tr; +" set it to 'html5' to check HTML5 files; see the wiki for reference: +" http://wiki.whatwg.org/wiki/Validator.nu_Common_Input_Parameters#parser +" +" - g:syntastic_html_validator_nsfilter (string; default: empty) +" sets the nsfilter for the parser; see the wiki for details: +" http://wiki.whatwg.org/wiki/Validator.nu_Common_Input_Parameters#nsfilter + +if exists("g:loaded_syntastic_html_validator_checker") + finish +endif +let g:loaded_syntastic_html_validator_checker=1 + +if !exists('g:syntastic_html_validator_api') + let g:syntastic_html_validator_api = 'http://validator.nu/' +endif + +if !exists('g:syntastic_html_validator_parser') + let g:syntastic_html_validator_parser = '' +endif + +if !exists('g:syntastic_html_validator_nsfilter') + let g:syntastic_html_validator_nsfilter = '' +endif + +let s:decoder = 'awk -f ' . shellescape(expand(':p:h') . '/validator_decode.awk') + +function! SyntaxCheckers_html_validator_IsAvailable() + return executable('curl') && executable('awk') +endfunction + +function! SyntaxCheckers_html_validator_GetLocList() + let makeprg = 'curl -s --compressed -F out=gnu -F asciiquotes=yes' . + \ (!empty(g:syntastic_html_validator_parser) ? ' -F parser=' . g:syntastic_html_validator_parser : '') . + \ (!empty(g:syntastic_html_validator_nsfilter) ? ' -F nsfilter=' . g:syntastic_html_validator_nsfilter : '') . + \ ' -F doc=@' . shellescape(expand('%')) . '\;type=text/html\;filename=' . shellescape(expand('%')) . ' ' . + \ g:syntastic_html_validator_api . ' \| ' . s:decoder + 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, 'defaults': {'bufnr': bufnr("")} }) +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'html', + \ 'name': 'validator'}) diff --git a/bundle/syntastic/syntax_checkers/html/validator_decode.awk b/bundle/syntastic/syntax_checkers/html/validator_decode.awk new file mode 100644 index 00000000..71db8067 --- /dev/null +++ b/bundle/syntastic/syntax_checkers/html/validator_decode.awk @@ -0,0 +1,61 @@ +#!/usr/bin/awk -f +#============================================================================ +#File: validator_decode.awk +#Description: Helper script for validator.vim +#Maintainer: LCD 47 +#License: This program is free software. It comes without any warranty, +# to the extent permitted by applicable law. You can redistribute +# it and/or modify it under the terms of the Do What The Fuck You +# Want To Public License, Version 2, as published by Sam Hocevar. +# See http://sam.zoy.org/wtfpl/COPYING for more details. +# +#============================================================================ + +BEGIN { + FS = OFS = "\"" + hextab ["0"] = 0; hextab ["8"] = 8; + hextab ["1"] = 1; hextab ["9"] = 9; + hextab ["2"] = 2; hextab ["A"] = hextab ["a"] = 10 + hextab ["3"] = 3; hextab ["B"] = hextab ["b"] = 11; + hextab ["4"] = 4; hextab ["C"] = hextab ["c"] = 12; + hextab ["5"] = 5; hextab ["D"] = hextab ["d"] = 13; + hextab ["6"] = 6; hextab ["E"] = hextab ["e"] = 14; + hextab ["7"] = 7; hextab ["F"] = hextab ["f"] = 15; +} + +function urldecode (url) { + decoded = "" + i = 1 + len = length (url) + while ( i <= len ) { + c = substr (url, i, 1) + if ( c == "%" ) { + if ( i + 2 <= len ) { + c1 = substr (url, i + 1, 1) + c2 = substr (url, i + 2, 1) + if ( hextab [c1] != "" && hextab [c2] != "" ) { + code = 0 + hextab [c1] * 16 + hextab [c2] + 0 + c = sprintf ("%c", code) + } + else + c = c c1 c2 + i += 2 + } + else if ( i + 1 <= len ) { + c = substr (url, i, 2) + i++ + } + } + else if ( c == "+" ) + c = " " + decoded = decoded c + i++ + } + return decoded +} + +{ + $2 = urldecode($2) + gsub ("\\\\\"", "\"", $2) + print +} diff --git a/bundle/syntastic/syntax_checkers/html/w3.vim b/bundle/syntastic/syntax_checkers/html/w3.vim new file mode 100644 index 00000000..7bb0fcd0 --- /dev/null +++ b/bundle/syntastic/syntax_checkers/html/w3.vim @@ -0,0 +1,59 @@ +"============================================================================ +"File: w3.vim +"Description: Syntax checking plugin for syntastic.vim +"Maintainer: Martin Grenfell +"License: This program is free software. It comes without any warranty, +" to the extent permitted by applicable law. You can redistribute +" it and/or modify it under the terms of the Do What The Fuck You +" Want To Public License, Version 2, as published by Sam Hocevar. +" See http://sam.zoy.org/wtfpl/COPYING for more details. +" +"============================================================================ +" +" Checker option: +" +" - g:syntastic_html_w3_api (string; default: 'http://validator.w3.org/check') +" URL of the service to use for checking; leave it to the default to run the +" checks against http://validator.w3.org/, or set it to +" 'http://localhost/w3c-validator/check' if you're running a local service + +if exists("g:loaded_syntastic_html_w3_checker") + finish +endif +let g:loaded_syntastic_html_w3_checker = 1 + +if !exists('g:syntastic_html_w3_api') + let g:syntastic_html_w3_api = 'http://validator.w3.org/check' +endif + +function! SyntaxCheckers_html_w3_IsAvailable() + return executable('curl') +endfunction + +function! SyntaxCheckers_html_w3_GetLocList() + let makeprg = 'curl -s -F output=json ' . + \ '-F uploaded_file=@' . shellescape(expand('%: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("")} }) + + for n in range(len(loclist)) + let loclist[n]['text'] = substitute(loclist[n]['text'], '\\\([\"]\)', '\1', 'g') + endfor + + return loclist +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'html', + \ 'name': 'w3'}) + diff --git a/bundle/syntastic/syntax_checkers/java/checkstyle.vim b/bundle/syntastic/syntax_checkers/java/checkstyle.vim new file mode 100644 index 00000000..7438b66a --- /dev/null +++ b/bundle/syntastic/syntax_checkers/java/checkstyle.vim @@ -0,0 +1,54 @@ +"============================================================================ +"File: checkstyle.vim +"Description: Syntax checking plugin for syntastic.vim +"Maintainer: Dmitry Geurkov +"License: This program is free software. It comes without any warranty, +" to the extent permitted by applicable law. You can redistribute +" it and/or modify it under the terms of the Do What The Fuck You +" Want To Public License, Version 2, as published by Sam Hocevar. +" See http://sam.zoy.org/wtfpl/COPYING for more details. +" +" Tested with checkstyle 5.5 +"============================================================================ +if exists("g:loaded_syntastic_java_checkstyle_checker") + finish +endif +let g:loaded_syntastic_java_checkstyle_checker=1 + +if !exists("g:syntastic_java_checkstyle_classpath") + let g:syntastic_java_checkstyle_classpath = 'checkstyle-5.5-all.jar' +endif + +if !exists("g:syntastic_java_checkstyle_conf_file") + let g:syntastic_java_checkstyle_conf_file = 'sun_checks.xml' +endif + +function! SyntaxCheckers_java_checkstyle_IsAvailable() + return executable('java') +endfunction + +function! SyntaxCheckers_java_checkstyle_GetLocList() + + let fname = fnameescape( expand('%:p:h') . '/' . expand('%:t') ) + + if has('win32unix') + let fname = substitute(system('cygpath -m ' . fname), '\%x00', '', 'g') + endif + + let makeprg = syntastic#makeprg#build({ + \ 'exe': 'java', + \ 'args': '-cp ' . g:syntastic_java_checkstyle_classpath . + \ ' com.puppycrawl.tools.checkstyle.Main -c ' . g:syntastic_java_checkstyle_conf_file, + \ 'fname': fname, + \ 'subchecker': 'checkstyle' }) + + " check style format + let errorformat = '%f:%l:%c:\ %m,%f:%l:\ %m' + + return SyntasticMake({ 'makeprg': makeprg, 'errorformat': errorformat, 'postprocess': ['cygwinRemoveCR'] }) + +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'java', + \ 'name': 'checkstyle'}) diff --git a/bundle/syntastic/syntax_checkers/java/javac.vim b/bundle/syntastic/syntax_checkers/java/javac.vim new file mode 100644 index 00000000..a05a074a --- /dev/null +++ b/bundle/syntastic/syntax_checkers/java/javac.vim @@ -0,0 +1,307 @@ +"============================================================================ +"File: javac.vim +"Description: Syntax checking plugin for syntastic.vim +"Maintainer: Jochen Keil +" Dmitry Geurkov +"License: This program is free software. It comes without any warranty, +" to the extent permitted by applicable law. You can redistribute +" it and/or modify it under the terms of the Do What 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 + +" Global Options +if !exists("g:syntastic_java_javac_executable") + let g:syntastic_java_javac_executable = 'javac' +endif + +if !exists("g:syntastic_java_maven_executable") + let g:syntastic_java_maven_executable = 'mvn' +endif + +if !exists("g:syntastic_java_javac_options") + let g:syntastic_java_javac_options = '-Xlint' +endif + +if !exists("g:syntastic_java_javac_classpath") + let g:syntastic_java_javac_classpath = '' +endif + +if !exists("g:syntastic_java_javac_delete_output") + let g:syntastic_java_javac_delete_output = 1 +endif + +function! s:CygwinPath(path) + return substitute(system("cygpath -m ".a:path), '\%x00', '', 'g') +endfunction + +if !exists("g:syntastic_java_javac_temp_dir") + if has('win32') || has('win64') + let g:syntastic_java_javac_temp_dir = $TEMP."\\vim-syntastic-javac" + elseif has('win32unix') + let g:syntastic_java_javac_temp_dir = s:CygwinPath('/tmp/vim-syntastic-javac') + else + let g:syntastic_java_javac_temp_dir = '/tmp/vim-syntastic-javac' + endif +endif + +if !exists("g:syntastic_java_javac_autoload_maven_classpath") + let g:syntastic_java_javac_autoload_maven_classpath = 1 +endif + +if !exists('g:syntastic_java_javac_config_file_enabled') + let g:syntastic_java_javac_config_file_enabled = 0 +endif + +if !exists('g:syntastic_java_javac_config_file') + let g:syntastic_java_javac_config_file = '.syntastic_javac_config' +endif + +" Internal variables, do not ovveride those +if !exists("g:syntastic_java_javac_maven_pom_cwd") + let g:syntastic_java_javac_maven_pom_cwd = '' +endif + +if !exists("g:syntastic_java_javac_maven_pom_ftime") + let g:syntastic_java_javac_maven_pom_ftime = 0 +endif + +if !exists("g:syntastic_java_javac_maven_pom_classpath") + let g:syntastic_java_javac_maven_pom_classpath = '' +endif + +function! s:RemoveCarriageReturn(line) + return substitute(a:line, '\r', '', 'g') +endfunction + +" recursively remove directory and all it's sub-directories +function! s:RemoveDir(dir) + if isdirectory(a:dir) + for f in split(globpath(a:dir, '*'), "\n") + call s:RemoveDir(f) + endfor + silent! call system('rmdir ' . a:dir) + else + silent! call delete(a:dir) + endif +endfunction + +function! s:AddToClasspath(classpath,path) + if a:path == '' + return a:classpath + endif + if a:classpath != '' && a:path != '' + if has('win32') || has('win32unix') || has('win64') + return a:classpath . ";" . a:path + else + return a:classpath . ":" . a:path + endif + else + return a:path + endif +endfunction + +function! s:LoadClasspathFromConfigFile() + if filereadable(g:syntastic_java_javac_config_file) + let path = '' + let lines = readfile(g:syntastic_java_javac_config_file) + for l in lines + if l != '' + let path .= l . "\n" + endif + endfor + return path + else + return '' + endif +endfunction + +function! s:SaveClasspath() + let path = '' + let lines = getline(1, line('$')) + " save classpath to config file + if g:syntastic_java_javac_config_file_enabled + call writefile(lines,g:syntastic_java_javac_config_file) + endif + for l in lines + if l != '' + let path .= l . "\n" + endif + endfor + let g:syntastic_java_javac_classpath = path + let &modified = 0 +endfunction + +function! s:EditClasspath() + let command = 'syntastic javac classpath' + let winnr = bufwinnr('^' . command . '$') + if winnr < 0 + let pathlist = split(g:syntastic_java_javac_classpath,"\n") + execute (len(pathlist) + 5) . 'sp ' . fnameescape(command) + + augroup syntastic + autocmd BufWriteCmd call s:SaveClasspath() | bwipeout + augroup END + + setlocal buftype=acwrite bufhidden=wipe nobuflisted noswapfile nowrap number + for p in pathlist + call append(line('$') - 1, p) + endfor + else + execute winnr . 'wincmd w' + endif +endfunction +command! SyntasticJavacEditClasspath call s:EditClasspath() + +function! s:GetMavenClasspath() + if filereadable('pom.xml') + if g:syntastic_java_javac_maven_pom_ftime != getftime('pom.xml') || g:syntastic_java_javac_maven_pom_cwd != getcwd() + let mvn_classpath_output = split(system(g:syntastic_java_maven_executable . ' dependency:build-classpath'), "\n") + let class_path_next = 0 + + for line in mvn_classpath_output + if class_path_next == 1 + let mvn_classpath = s:RemoveCarriageReturn(line) + break + endif + if match(line,'Dependencies classpath:') >= 0 + let class_path_next = 1 + endif + endfor + + let mvn_classpath = s:AddToClasspath(mvn_classpath, 'target/classes') + let mvn_classpath = s:AddToClasspath(mvn_classpath, 'target/test-classes') + + let g:syntastic_java_javac_maven_pom_cwd = getcwd() + let g:syntastic_java_javac_maven_pom_ftime = getftime('pom.xml') + let g:syntastic_java_javac_maven_pom_classpath = mvn_classpath + endif + return g:syntastic_java_javac_maven_pom_classpath + endif + return '' +endfunction + +function! SyntaxCheckers_java_javac_IsAvailable() + return executable(g:syntastic_java_javac_executable) +endfunction + +function! s:MavenOutputDirectory() + if filereadable('pom.xml') + let output_dir = getcwd() + if match(expand( '%:p:h' ), "src.main.java") >= 0 + let output_dir .= '/target/classes' + endif + if match(expand( '%:p:h' ), "src.test.java") >= 0 + let output_dir .= '/target/test-classes' + endif + + if has('win32unix') + let output_dir=s:CygwinPath(output_dir) + endif + return output_dir + endif +endfunction + +function! SyntaxCheckers_java_javac_GetLocList() + + let javac_opts = g:syntastic_java_javac_options + + if g:syntastic_java_javac_delete_output + let output_dir = g:syntastic_java_javac_temp_dir + let javac_opts .= ' -d ' . output_dir + endif + + " load classpath from config file + if g:syntastic_java_javac_config_file_enabled + let loaded_classpath = s:LoadClasspathFromConfigFile() + if loaded_classpath != '' + let g:syntastic_java_javac_classpath = loaded_classpath + endif + endif + + let javac_classpath = '' + + " add classpathes to javac_classpath + for path in split(g:syntastic_java_javac_classpath,"\n") + if path != '' + try + let ps = glob(path,0,1) + catch + let ps = split(glob(path,0),"\n") + endtry + if type(ps) == type([]) + for p in ps + if p != '' + let javac_classpath = s:AddToClasspath(javac_classpath,p) + endif + endfor + else + let javac_classpath = s:AddToClasspath(javac_classpath,ps) + endif + endif + endfor + + if g:syntastic_java_javac_autoload_maven_classpath + if !g:syntastic_java_javac_delete_output + let maven_output_dir = s:MavenOutputDirectory() + let javac_opts .= ' -d ' . maven_output_dir + endif + let maven_classpath = s:GetMavenClasspath() + let javac_classpath = s:AddToClasspath(javac_classpath,maven_classpath) + endif + + if javac_classpath != '' + let javac_opts .= ' -cp "' . fnameescape(javac_classpath) . '"' + endif + + " path seperator + if has('win32') || has('win32unix') || has('win64') + let sep = "\\" + else + let sep = '/' + endif + + let fname = fnameescape(expand ( '%:p:h' ) . sep . expand ( '%:t' )) + + if has('win32unix') + let fname = s:CygwinPath(fname) + endif + + let makeprg = syntastic#makeprg#build({ + \ 'exe': g:syntastic_java_javac_executable, + \ 'args': javac_opts, + \ 'fname': fname, + \ 'tail': '2>&1', + \ 'subchecker': 'javac' }) + + " unashamedly stolen from *errorformat-javac* (quickfix.txt) and modified to include error types + let errorformat = + \ '%E%f:%l:\ error:\ %m,'. + \ '%W%f:%l:\ warning:\ %m,'. + \ '%A%f:%l:\ %m,'. + \ '%+Z%p^,'. + \ '%+C%.%#,'. + \ '%-G%.%#' + + if g:syntastic_java_javac_delete_output + silent! call mkdir(output_dir,'p') + endif + let errors = SyntasticMake({ 'makeprg': makeprg, 'errorformat': errorformat, 'postprocess': ['cygwinRemoveCR'] }) + + if g:syntastic_java_javac_delete_output + call s:RemoveDir(output_dir) + endif + return errors + +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'java', + \ 'name': 'javac'}) + diff --git a/bundle/syntastic/syntax_checkers/javascript/closurecompiler.vim b/bundle/syntastic/syntax_checkers/javascript/closurecompiler.vim new file mode 100644 index 00000000..b8ed8831 --- /dev/null +++ b/bundle/syntastic/syntax_checkers/javascript/closurecompiler.vim @@ -0,0 +1,62 @@ +"============================================================================ +"File: closurecompiler.vim +"Description: Javascript syntax checker - using Google Closure Compiler +"Maintainer: Motohiro Takayama +"License: This program is free software. It comes without any warranty, +" to the extent permitted by applicable law. You can redistribute +" it and/or modify it under the terms of the Do What The Fuck You +" Want To Public License, Version 2, as published by Sam Hocevar. +" See http://sam.zoy.org/wtfpl/COPYING for more details. +"============================================================================ +" +" To enable this plugin, edit the .vimrc like this: +" +" let g:syntastic_javascript_checker = "closurecompiler" +" +" and set the path to the Google Closure Compiler: +" +" let g:syntastic_javascript_closure_compiler_path = '/path/to/google-closure-compiler.jar' +" +" It takes additional options for Google Closure Compiler with the variable +" g:syntastic_javascript_closure_compiler_options. +" + +if exists("g:loaded_syntastic_javascript_closurecompiler_checker") + finish +endif +let g:loaded_syntastic_javascript_closurecompiler_checker=1 + +if !exists("g:syntastic_javascript_closure_compiler_options") + let g:syntastic_javascript_closure_compiler_options = "" +endif + +function! SyntaxCheckers_javascript_closurecompiler_IsAvailable() + return exists("g:syntastic_javascript_closure_compiler_path") +endfunction + +function! SyntaxCheckers_javascript_closurecompiler_GetLocList() + if exists("g:syntastic_javascript_closure_compiler_file_list") + let file_list = join(readfile(g:syntastic_javascript_closure_compiler_file_list), ' ') + else + let file_list = shellescape(expand('%')) + endif + + let makeprg = syntastic#makeprg#build({ + \ 'exe': 'java -jar ' . g:syntastic_javascript_closure_compiler_path, + \ 'args': g:syntastic_javascript_closure_compiler_options . ' --js' , + \ 'fname': file_list, + \ 'subchecker': 'closurecompiler' }) + + let errorformat = + \ '%-GOK,'. + \ '%E%f:%l: ERROR - %m,'. + \ '%Z%p^,'. + \ '%W%f:%l: WARNING - %m,'. + \ '%Z%p^' + return SyntasticMake({ 'makeprg': makeprg, 'errorformat': errorformat }) +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'javascript', + \ 'name': 'closurecompiler'}) + diff --git a/bundle/syntastic/syntax_checkers/javascript/gjslint.vim b/bundle/syntastic/syntax_checkers/javascript/gjslint.vim new file mode 100644 index 00000000..f619c676 --- /dev/null +++ b/bundle/syntastic/syntax_checkers/javascript/gjslint.vim @@ -0,0 +1,36 @@ +"============================================================================ +"File: gjslint.vim +"Description: Javascript syntax checker - using gjslint +"Maintainer: Martin Grenfell +"License: This program is free software. It comes without any warranty, +" to the extent permitted by applicable law. You can redistribute +" it and/or modify it under the terms of the Do What 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 + +function! SyntaxCheckers_javascript_gjslint_IsAvailable() + return executable('gjslint') +endfunction + +function! SyntaxCheckers_javascript_gjslint_GetLocList() + let makeprg = syntastic#makeprg#build({ + \ 'exe': 'gjslint', + \ 'args': g:syntastic_javascript_gjslint_conf . " --nosummary --unix_mode --nodebug_indentation --nobeep", + \ 'subchecker': 'gjslint' }) + let errorformat="%f:%l:(New Error -%\\?\%n) %m,%f:%l:(-%\\?%n) %m,%-G1 files checked, no errors found.,%-G%.%#" + return SyntasticMake({ 'makeprg': makeprg, 'errorformat': errorformat }) +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'javascript', + \ 'name': 'gjslint'}) + diff --git a/bundle/syntastic/syntax_checkers/javascript/jshint.vim b/bundle/syntastic/syntax_checkers/javascript/jshint.vim new file mode 100644 index 00000000..0101a701 --- /dev/null +++ b/bundle/syntastic/syntax_checkers/javascript/jshint.vim @@ -0,0 +1,51 @@ +"============================================================================ +"File: jshint.vim +"Description: Javascript syntax checker - using jshint +"Maintainer: Martin Grenfell +"License: This program is free software. It comes without any warranty, +" to the extent permitted by applicable law. You can redistribute +" it and/or modify it under the terms of the Do What 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_jshint_checker") + finish +endif +let g:loaded_syntastic_javascript_jshint_checker=1 + +if !exists("g:syntastic_javascript_jshint_conf") + let g:syntastic_javascript_jshint_conf = "" +endif + +function! SyntaxCheckers_javascript_jshint_IsAvailable() + return executable('jshint') +endfunction + +function! SyntaxCheckers_javascript_jshint_GetLocList() + let jshint_new = s:JshintNew() + let makeprg = syntastic#makeprg#build({ + \ 'exe': 'jshint', + \ 'post_args': (jshint_new ? ' --verbose ' : '') . s:Args(), + \ 'subchecker': 'jshint' }) + + let errorformat = jshint_new ? + \ '%f: line %l\, col %c\, %m \(%t%*\d\)' : + \ '%E%f: line %l\, col %c\, %m' + return SyntasticMake({ 'makeprg': makeprg, 'errorformat': errorformat, 'defaults': {'bufnr': bufnr('')} }) +endfunction + +function s:JshintNew() + let ver = matchlist(system('jshint --version'), '^\D*\(\d\+\)\.\(\d\+\)') + return (ver[1] > 1 || (ver[1] == 1 && ver[2] >= 1)) +endfunction + +function s:Args() + " node-jshint uses .jshintrc as config unless --config arg is present + return !empty(g:syntastic_javascript_jshint_conf) ? ' --config ' . g:syntastic_javascript_jshint_conf : '' +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'javascript', + \ 'name': 'jshint'}) + diff --git a/bundle/syntastic/syntax_checkers/javascript/jsl.vim b/bundle/syntastic/syntax_checkers/javascript/jsl.vim new file mode 100644 index 00000000..0491b59f --- /dev/null +++ b/bundle/syntastic/syntax_checkers/javascript/jsl.vim @@ -0,0 +1,51 @@ +"============================================================================ +"File: jsl.vim +"Description: Javascript syntax checker - using jsl +"Maintainer: Martin Grenfell +"License: This program is free software. It comes without any warranty, +" to the extent permitted by applicable law. You can redistribute +" it and/or modify it under the terms of the Do What 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_jsl_checker") + finish +endif +let g:loaded_syntastic_javascript_jsl_checker=1 + +if !exists("g:syntastic_javascript_jsl_conf") + let g:syntastic_javascript_jsl_conf = "" +endif + +function s:ConfFlag() + if !empty(g:syntastic_javascript_jsl_conf) + return "-conf " . g:syntastic_javascript_jsl_conf + endif + + return "" +endfunction + +function! SyntaxCheckers_javascript_jsl_IsAvailable() + return executable('jsl') +endfunction + +function! SyntaxCheckers_javascript_jsl_GetLocList() + let makeprg = syntastic#makeprg#build({ + \ 'exe': 'jsl', + \ 'args': s:ConfFlag() . " -nologo -nofilelisting -nosummary -nocontext -process", + \ 'subchecker': 'jsl' }) + let errorformat = + \ '%W%f(%l): lint warning: %m,'. + \ '%-Z%p^,'. + \ '%W%f(%l): warning: %m,'. + \ '%-Z%p^,'. + \ '%E%f(%l): SyntaxError: %m,'. + \ '%-Z%p^,'. + \ '%-G' + return SyntasticMake({ 'makeprg': makeprg, 'errorformat': errorformat }) +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'javascript', + \ 'name': 'jsl'}) + diff --git a/bundle/syntastic/syntax_checkers/javascript/jslint.vim b/bundle/syntastic/syntax_checkers/javascript/jslint.vim new file mode 100644 index 00000000..46eeddbd --- /dev/null +++ b/bundle/syntastic/syntax_checkers/javascript/jslint.vim @@ -0,0 +1,47 @@ +"============================================================================ +"File: jslint.vim +"Description: Javascript syntax checker - using jslint +"Maintainer: Martin Grenfell +"License: This program is free software. It comes without any warranty, +" to the extent permitted by applicable law. You can redistribute +" it and/or modify it under the terms of the Do What 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 jslint 0.1.4. +"============================================================================ +if exists("g:loaded_syntastic_javascript_jslint_checker") + finish +endif +let g:loaded_syntastic_javascript_jslint_checker=1 + +if !exists("g:syntastic_javascript_jslint_conf") + let g:syntastic_javascript_jslint_conf = "--white --undef --nomen --regexp --plusplus --bitwise --newcap --sloppy --vars" +endif + +function! SyntaxCheckers_javascript_jslint_IsAvailable() + return executable('jslint') +endfunction + +function! SyntaxCheckers_javascript_jslint_HighlightTerm(error) + let unexpected = matchstr(a:error['text'], 'Expected.*and instead saw \'\zs.*\ze\'') + if len(unexpected) < 1 | return '' | end + return '\V'.split(unexpected, "'")[1] +endfunction + +function! SyntaxCheckers_javascript_jslint_GetLocList() + let makeprg = syntastic#makeprg#build({ + \ 'exe': 'jslint', + \ 'args': g:syntastic_javascript_jslint_conf, + \ 'subchecker': 'jslint' }) + let errorformat = + \ '%E %##%n %m,'. + \ '%-Z%.%#Line %l\, Pos %c,'. + \ '%-G%.%#' + return SyntasticMake({ 'makeprg': makeprg, 'errorformat': errorformat, 'defaults': {'bufnr': bufnr("")} }) +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'javascript', + \ 'name': 'jslint'}) + diff --git a/bundle/syntastic/syntax_checkers/json/jsonlint.vim b/bundle/syntastic/syntax_checkers/json/jsonlint.vim new file mode 100644 index 00000000..93b358a1 --- /dev/null +++ b/bundle/syntastic/syntax_checkers/json/jsonlint.vim @@ -0,0 +1,37 @@ +"============================================================================ +"File: jsonlint.vim +"Description: JSON syntax checker - using jsonlint +"Maintainer: Miller Medeiros +"License: This program is free software. It comes without any warranty, +" to the extent permitted by applicable law. You can redistribute +" it and/or modify it under the terms of the Do What 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_json_jsonlint_checker") + finish +endif +let g:loaded_syntastic_json_jsonlint_checker=1 + +function! SyntaxCheckers_json_jsonlint_IsAvailable() + return executable('jsonlint') +endfunction + +function! SyntaxCheckers_json_jsonlint_GetLocList() + let makeprg = syntastic#makeprg#build({ + \ 'exe': 'jsonlint', + \ 'post_args': '--compact', + \ 'subchecker': 'jsonlint' }) + let errorformat = + \ '%ELine %l:%c,'. + \ '%Z\\s%#Reason: %m,'. + \ '%C%.%#,'. + \ '%f: line %l\, col %c\, %m,'. + \ '%-G%.%#' + return SyntasticMake({ 'makeprg': makeprg, 'errorformat': errorformat, 'defaults': {'bufnr': bufnr('')} }) +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'json', + \ 'name': 'jsonlint'}) diff --git a/bundle/syntastic/syntax_checkers/json/jsonval.vim b/bundle/syntastic/syntax_checkers/json/jsonval.vim new file mode 100644 index 00000000..632cda2f --- /dev/null +++ b/bundle/syntastic/syntax_checkers/json/jsonval.vim @@ -0,0 +1,30 @@ +"============================================================================ +"File: jsonval.vim +"Description: JSON syntax checker - using jsonval +"Maintainer: Miller Medeiros +"License: This program is free software. It comes without any warranty, +" to the extent permitted by applicable law. You can redistribute +" it and/or modify it under the terms of the Do What 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_json_jsonval_checker") + finish +endif +let g:loaded_syntastic_json_jsonval_checker=1 + +function! SyntaxCheckers_json_jsonval_IsAvailable() + return executable('jsonval') +endfunction + +function! SyntaxCheckers_json_jsonval_GetLocList() + " based on https://gist.github.com/1196345 + let makeprg = syntastic#makeprg#build({ 'exe': 'jsonval', 'subchecker': 'jsonval' }) + let errorformat = '%E%f:\ %m\ at\ line\ %l,%-G%.%#' + return SyntasticMake({ 'makeprg': makeprg, 'errorformat': errorformat, 'defaults': {'bufnr': bufnr('')} }) +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'json', + \ 'name': 'jsonval'}) diff --git a/bundle/syntastic/syntax_checkers/less/less-lint.coffee b/bundle/syntastic/syntax_checkers/less/less-lint.coffee new file mode 100644 index 00000000..0b05e4a7 --- /dev/null +++ b/bundle/syntastic/syntax_checkers/less/less-lint.coffee @@ -0,0 +1,41 @@ +#!/usr/bin/env node + +fs = require 'fs' +less = require 'less' +args = process.argv.slice(1) +options = {} + +args = args.filter (arg) -> + match = arg.match(/^-I(.+)$/) + if match + options.paths.push(match[1]); + return false + + match = arg.match(/^--?([a-z][\-0-9a-z]*)(?:=([^\s]+))?$/i) + if match + arg = match[1] + else + return arg + + switch arg + when 'strict-imports' then options.strictImports = true + when 'include-path' + options.paths = match[2].split(if os.type().match(/Windows/) then ';' else ':') + .map (p) -> + if p + return path.resolve(process.cwd(), p) + when 'O0' then options.optimization = 0 + when 'O1' then options.optimization = 1 + when 'O2' then options.optimization = 2 + +options.filename = args[1] + +parser = new(less.Parser) options + +fs.readFile(options.filename, 'utf-8', (err,data) -> + parser.parse(data, (err, tree) -> + if err + less.writeError err + process.exit(1) + ) +) diff --git a/bundle/syntastic/syntax_checkers/less/less-lint.js b/bundle/syntastic/syntax_checkers/less/less-lint.js new file mode 100644 index 00000000..5abc653c --- /dev/null +++ b/bundle/syntastic/syntax_checkers/less/less-lint.js @@ -0,0 +1,57 @@ +// Generated by CoffeeScript 1.3.3 +(function() { + var args, fs, less, options, parser; + + fs = require('fs'); + + less = require('less'); + + args = process.argv.slice(1); + + options = {}; + + args = args.filter(function(arg) { + var match; + match = arg.match(/^-I(.+)$/); + if (match) { + options.paths.push(match[1]); + return false; + } + match = arg.match(/^--?([a-z][\-0-9a-z]*)(?:=([^\s]+))?$/i); + if (match) { + arg = match[1]; + } else { + return arg; + } + switch (arg) { + case 'strict-imports': + return options.strictImports = true; + case 'include-path': + return options.paths = match[2].split(os.type().match(/Windows/) ? ';' : ':').map(function(p) { + if (p) { + return path.resolve(process.cwd(), p); + } + }); + case 'O0': + return options.optimization = 0; + case 'O1': + return options.optimization = 1; + case 'O2': + return options.optimization = 2; + } + }); + + options.filename = args[1]; + + parser = new less.Parser(options); + + fs.readFile(options.filename, 'utf-8', function(err, data) { + return parser.parse(data, function(err, tree) { + if (err) { + less.writeError(err); + return process.exit(1); + } + }); + }); + +}).call(this); diff --git a/bundle/syntastic/syntax_checkers/less/lessc.vim b/bundle/syntastic/syntax_checkers/less/lessc.vim new file mode 100644 index 00000000..7ceddad8 --- /dev/null +++ b/bundle/syntastic/syntax_checkers/less/lessc.vim @@ -0,0 +1,58 @@ +"============================================================================ +"File: less.vim +"Description: Syntax checking plugin for syntastic.vim +"Maintainer: Julien Blanchard +"License: This program is free software. It comes without any warranty, +" to the extent permitted by applicable law. You can redistribute +" it and/or modify it under the terms of the Do What The Fuck You +" Want To Public License, Version 2, as published by Sam Hocevar. +" See http://sam.zoy.org/wtfpl/COPYING for more details. +" +"============================================================================ + +" To send additional options to less use the variable g:syntastic_less_options. +" The default is +" let g:syntastic_less_options = "--no-color" +" +" To use less-lint instead of less set the variable +" g:syntastic_less_use_less_lint. + +if exists("g:loaded_syntastic_less_lessc_checker") + finish +endif +let g:loaded_syntastic_less_lessc_checker=1 + +if !exists("g:syntastic_less_options") + let g:syntastic_less_options = "--no-color" +endif + +if !exists("g:syntastic_less_use_less_lint") + let g:syntastic_less_use_less_lint = 0 +endif + +if g:syntastic_less_use_less_lint + let s:check_file = 'node ' . expand(':p:h') . '/less-lint.js' +else + let s:check_file = 'lessc' +end + +function! SyntaxCheckers_less_lessc_IsAvailable() + return executable('lessc') +endfunction + +function! SyntaxCheckers_less_lessc_GetLocList() + let makeprg = syntastic#makeprg#build({ + \ 'exe': s:check_file, + \ 'args': g:syntastic_less_options, + \ 'tail': syntastic#util#DevNull(), + \ 'subchecker': 'lessc' }) + let errorformat = '%m in %f:%l:%c' + + return SyntasticMake({ 'makeprg': makeprg, + \ 'errorformat': errorformat, + \ 'defaults': {'bufnr': bufnr(""), 'text': "Syntax error"} }) +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'less', + \ 'name': 'lessc'}) diff --git a/bundle/syntastic/syntax_checkers/lisp/clisp.vim b/bundle/syntastic/syntax_checkers/lisp/clisp.vim new file mode 100644 index 00000000..60650c38 --- /dev/null +++ b/bundle/syntastic/syntax_checkers/lisp/clisp.vim @@ -0,0 +1,47 @@ +"============================================================================ +"File: lisp.vim +"Description: Syntax checking plugin for syntastic.vim +"Maintainer: Karl Yngve Lervåg +"License: This program is free software. It comes without any warranty, +" to the extent permitted by applicable law. You can redistribute +" it and/or modify it under the terms of the Do What The Fuck You +" Want To Public License, Version 2, as published by Sam Hocevar. +" See http://sam.zoy.org/wtfpl/COPYING for more details. +" +"============================================================================ +if exists("g:loaded_syntastic_lisp_clisp_checker") + finish +endif +let g:loaded_syntastic_lisp_clisp_checker=1 + +function! SyntaxCheckers_lisp_clisp_IsAvailable() + return executable("clisp") +endfunction + +function! SyntaxCheckers_lisp_clisp_GetLocList() + let makeprg = syntastic#makeprg#build({ + \ 'exe': 'clisp', + \ 'args': '-q -c', + \ 'tail': '-o /tmp/clisp-vim-compiled-file', + \ 'subchecker': 'clisp' }) + + let efm = '%-G;%.%#,' + + let efm .= '%W%>WARNING:%.%#line %l : %m,' + let efm .= '%Z %#%m,' + + let efm .= '%W%>WARNING:%.%#lines %l..%\d\# : %m,' + let efm .= '%Z %#%m,' + + let efm .= '%E%>The following functions were %m,' + let efm .= '%Z %m,' + + let efm .= '%-G%.%#' + return SyntasticMake({ 'makeprg': makeprg, + \ 'errorformat': efm, + \ 'defaults': {'bufnr': bufnr('')} }) +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'lisp', + \ 'name': 'clisp'}) diff --git a/bundle/syntastic/syntax_checkers/llvm/llvm.vim b/bundle/syntastic/syntax_checkers/llvm/llvm.vim new file mode 100644 index 00000000..5a1f18ed --- /dev/null +++ b/bundle/syntastic/syntax_checkers/llvm/llvm.vim @@ -0,0 +1,34 @@ +"============================================================================ +"File: llvm.vim +"Description: Syntax checking plugin for syntastic.vim +"Maintainer: Andrew Kelley +"License: This program is free software. It comes without any warranty, +" to the extent permitted by applicable law. You can redistribute +" it and/or modify it under the terms of the Do What The Fuck You +" Want To Public License, Version 2, as published by Sam Hocevar. +" See http://sam.zoy.org/wtfpl/COPYING for more details. +" +"============================================================================ +if exists("g:loaded_syntastic_llvm_llvm_checker") + finish +endif +let g:loaded_syntastic_llvm_llvm_checker=1 + +function! SyntaxCheckers_llvm_llvm_IsAvailable() + return executable("llc") +endfunction + +function! SyntaxCheckers_llvm_llvm_GetLocList() + let makeprg = syntastic#makeprg#build({ + \ 'exe': 'llc', + \ 'args': syntastic#c#GetNullDevice(), + \ 'subchecker': 'llvm' }) + let errorformat = 'llc: %f:%l:%c: %trror: %m' + + return SyntasticMake({ 'makeprg': makeprg, 'errorformat': errorformat }) +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'llvm', + \ 'name': 'llvm'}) + diff --git a/bundle/syntastic/syntax_checkers/lua/luac.vim b/bundle/syntastic/syntax_checkers/lua/luac.vim new file mode 100644 index 00000000..77f017eb --- /dev/null +++ b/bundle/syntastic/syntax_checkers/lua/luac.vim @@ -0,0 +1,61 @@ +"============================================================================ +"File: lua.vim +"Description: Syntax checking plugin for syntastic.vim +"Maintainer: Gregor Uhlenheuer +"License: This program is free software. It comes without any warranty, +" to the extent permitted by applicable law. You can redistribute +" it and/or modify it under the terms of the Do What The Fuck You +" Want To Public License, Version 2, as published by Sam Hocevar. +" See http://sam.zoy.org/wtfpl/COPYING for more details. +" +"============================================================================ + +if exists("g:loaded_syntastic_lua_luac_checker") + finish +endif +let g:loaded_syntastic_lua_luac_checker=1 + +function! SyntaxCheckers_lua_luac_IsAvailable() + return executable('luac') +endfunction + +function! SyntaxCheckers_lua_luac_GetHighlightRegex(pos) + let near = matchstr(a:pos['text'], "near '[^']\\+'") + let result = '' + if len(near) > 0 + let near = split(near, "'")[1] + if near == '' + let p = getpos('$') + let a:pos['lnum'] = p[1] + let a:pos['col'] = p[2] + let result = '\%'.p[2].'c' + else + let result = '\V'.near + endif + let open = matchstr(a:pos['text'], "(to close '[^']\\+' at line [0-9]\\+)") + if len(open) > 0 + let oline = split(open, "'")[1:2] + let line = 0+strpart(oline[1], 9) + call matchadd('SpellCap', '\%'.line.'l\V'.oline[0]) + endif + endif + return result +endfunction + + +function! SyntaxCheckers_lua_luac_GetLocList() + let makeprg = syntastic#makeprg#build({ + \ 'exe': 'luac', + \ 'args': '-p', + \ 'subchecker': 'luac' }) + let errorformat = 'luac: %#%f:%l: %m' + + return SyntasticMake({ 'makeprg': makeprg, + \ 'errorformat': errorformat, + \ 'defaults': { 'bufnr': bufnr(''), 'type': 'E' } }) + +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'lua', + \ 'name': 'luac'}) diff --git a/bundle/syntastic/syntax_checkers/matlab/mlint.vim b/bundle/syntastic/syntax_checkers/matlab/mlint.vim new file mode 100644 index 00000000..3cdc1b7f --- /dev/null +++ b/bundle/syntastic/syntax_checkers/matlab/mlint.vim @@ -0,0 +1,35 @@ +"============================================================================ +"File: matlab.vim +"Description: Syntax checking plugin for syntastic.vim +"Maintainer: Jason Graham +"License: This program is free software. It comes without any warranty, +" to the extent permitted by applicable law. You can redistribute +" it and/or modify it under the terms of the Do What The Fuck You +" Want To Public License, Version 2, as published by Sam Hocevar. +" See http://sam.zoy.org/wtfpl/COPYING for more details. +" +"============================================================================ + +if exists("g:loaded_syntastic_matlab_mlint_checker") + finish +endif +let g:loaded_syntastic_matlab_mlint_checker=1 + +function! SyntaxCheckers_matlab_mlint_IsAvailable() + return executable("mlint") +endfunction + +function! SyntaxCheckers_matlab_mlint_GetLocList() + let makeprg = syntastic#makeprg#build({ + \ 'exe': 'mlint', + \ 'args': '-id $*', + \ 'subchecker': 'mlint' }) + let errorformat = + \ 'L %l (C %c): %*[a-zA-Z0-9]: %m,'. + \ 'L %l (C %c-%*[0-9]): %*[a-zA-Z0-9]: %m' + return SyntasticMake({ 'makeprg': makeprg, 'errorformat': errorformat, 'defaults': {'bufnr': bufnr("")} }) +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'matlab', + \ 'name': 'mlint'}) diff --git a/bundle/syntastic/syntax_checkers/nasm/nasm.vim b/bundle/syntastic/syntax_checkers/nasm/nasm.vim new file mode 100644 index 00000000..0cf0b51a --- /dev/null +++ b/bundle/syntastic/syntax_checkers/nasm/nasm.vim @@ -0,0 +1,38 @@ +"============================================================================ +"File: nasm.vim +"Description: Syntax checking plugin for syntastic.vim +"Maintainer: Håvard Pettersson +"License: This program is free software. It comes without any warranty, +" to the extent permitted by applicable law. You can redistribute +" it and/or modify it under the terms of the Do What The Fuck You +" Want To Public License, Version 2, as published by Sam Hocevar. +" See http://sam.zoy.org/wtfpl/COPYING for more details. +" +"============================================================================ +if exists("g:loaded_syntastic_nasm_nasm_checker") + finish +endif +let g:loaded_syntastic_nasm_nasm_checker=1 + +function! SyntaxCheckers_nasm_nasm_IsAvailable() + return executable("nasm") +endfunction + +function! SyntaxCheckers_nasm_nasm_GetLocList() + if has("win32") + let outfile="NUL" + else + let outfile="/dev/null" + endif + let wd = shellescape(expand("%:p:h") . "/") + let makeprg = syntastic#makeprg#build({ + \ 'exe': 'nasm', + \ 'args': '-X gnu -f elf -I ' . wd . ' -o ' . outfile, + \ 'subchecker': 'nasm' }) + let errorformat = '%f:%l: %t%*[^:]: %m' + return SyntasticMake({ 'makeprg': makeprg, 'errorformat': errorformat }) +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'nasm', + \ 'name': 'nasm'}) diff --git a/bundle/syntastic/syntax_checkers/nroff/mandoc.vim b/bundle/syntastic/syntax_checkers/nroff/mandoc.vim new file mode 100644 index 00000000..06ccddf9 --- /dev/null +++ b/bundle/syntastic/syntax_checkers/nroff/mandoc.vim @@ -0,0 +1,36 @@ +"============================================================================ +"File: mandoc.vim +"Description: Syntax checking plugin for syntastic.vim +"Maintainer: LCD 47 +"License: This program is free software. It comes without any warranty, +" to the extent permitted by applicable law. You can redistribute +" it and/or modify it under the terms of the Do What The Fuck You +" Want To Public License, Version 2, as published by Sam Hocevar. +" See http://sam.zoy.org/wtfpl/COPYING for more details. +" +"============================================================================ +if exists("g:loaded_syntastic_nroff_mandoc_checker") + finish +endif +let g:loaded_syntastic_nroff_mandoc_checker=1 + +function! SyntaxCheckers_nroff_mandoc_IsAvailable() + return executable("mandoc") +endfunction + +function! SyntaxCheckers_nroff_mandoc_GetLocList() + let makeprg = syntastic#makeprg#build({ + \ 'exe': 'mandoc', + \ 'args': '-Tlint', + \ 'subchecker': 'mandoc' }) + let errorformat = + \ '%E%f:%l:%c: %tRROR: %m,' . + \ '%W%f:%l:%c: %tARNING: %m' + + return SyntasticMake({ 'makeprg': makeprg, 'errorformat': errorformat }) +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'nroff', + \ 'name': 'mandoc'}) + diff --git a/bundle/syntastic/syntax_checkers/objc/gcc.vim b/bundle/syntastic/syntax_checkers/objc/gcc.vim new file mode 100644 index 00000000..0cd13586 --- /dev/null +++ b/bundle/syntastic/syntax_checkers/objc/gcc.vim @@ -0,0 +1,184 @@ +"============================================================================ +"File: objc.vim +"Description: Syntax checking plugin for syntastic.vim +"Maintainer: Gregor Uhlenheuer +"License: This program is free software. It comes without any warranty, +" to the extent permitted by applicable law. You can redistribute +" it and/or modify it under the terms of the Do What The Fuck You +" Want To Public License, Version 2, as published by Sam Hocevar. +" See http://sam.zoy.org/wtfpl/COPYING for more details. +" +"============================================================================ + +" In order to also check header files add this to your .vimrc: +" (this usually creates a .gch file in your source directory) +" +" let g:syntastic_objc_check_header = 1 +" +" To disable the search of included header files after special +" libraries like gtk and glib add this line to your .vimrc: +" +" let g:syntastic_objc_no_include_search = 1 +" +" To disable the include of the default include dirs (such as /usr/include) +" add this line to your .vimrc: +" +" let g:syntastic_objc_no_default_include_dirs = 1 +" +" To enable header files being re-checked on every file write add the +" following line to your .vimrc. Otherwise the header files are checked only +" one time on initially loading the file. +" In order to force syntastic to refresh the header includes simply +" unlet b:syntastic_objc_includes. Then the header files are being re-checked on +" the next file write. +" +" let g:syntastic_objc_auto_refresh_includes = 1 +" +" Alternatively you can set the buffer local variable b:syntastic_objc_cflags. +" If this variable is set for the current buffer no search for additional +" libraries is done. I.e. set the variable like this: +" +" let b:syntastic_objc_cflags = ' -I/usr/include/libsoup-2.4' +" +" In order to add some custom include directories that should be added to the +" gcc command line you can add those to the global variable +" g:syntastic_objc_include_dirs. This list can be used like this: +" +" let g:syntastic_objc_include_dirs = [ 'includes', 'headers' ] +" +" Moreover it is possible to add additional compiler options to the syntax +" checking execution via the variable 'g:syntastic_objc_compiler_options': +" +" let g:syntastic_objc_compiler_options = ' -ansi' +" +" Additionally the setting 'g:syntastic_objc_config_file' allows you to define a +" file that contains additional compiler arguments like include directories or +" CFLAGS. The file is expected to contain one option per line. If none is +" given the filename defaults to '.syntastic_objc_config': +" +" let g:syntastic_objc_config_file = '.config' +" +" Using the global variable 'g:syntastic_objc_remove_include_errors' you can +" specify whether errors of files included via the g:syntastic_objc_include_dirs' +" setting are removed from the result set: +" +" let g:syntastic_objc_remove_include_errors = 1 +" +" Use the variable 'g:syntastic_objc_errorformat' to override the default error +" format: +" +" let g:syntastic_objc_errorformat = '%f:%l:%c: %trror: %m' +" +" Set your compiler executable with e.g. (defaults to gcc) +" +" let g:syntastic_objc_compiler = 'clang' + +if exists('g:loaded_syntastic_objc_gcc_checker') + finish +endif +let g:loaded_syntastic_objc_gcc_checker = 1 + +if !exists('g:syntastic_objc_compiler') + let g:syntastic_objc_compiler = 'gcc' +endif + +function! SyntaxCheckers_objc_gcc_IsAvailable() + return executable(g:syntastic_objc_compiler) +endfunction + +let s:save_cpo = &cpo +set cpo&vim + +if !exists('g:syntastic_objc_compiler_options') + let g:syntastic_objc_compiler_options = '-std=gnu99' +endif + +if !exists('g:syntastic_objc_config_file') + let g:syntastic_objc_config_file = '.syntastic_objc_config' +endif + +function! SyntaxCheckers_objc_gcc_GetLocList() + let makeprg = g:syntastic_objc_compiler . ' -x objective-c -fsyntax-only -lobjc' + let errorformat = + \ '%-G%f:%s:,' . + \ '%-G%f:%l: %#error: %#(Each undeclared identifier is reported only%.%#,' . + \ '%-G%f:%l: %#error: %#for each function it appears%.%#,' . + \ '%-GIn file included%.%#,'. + \ '%-G %#from %f:%l\,,' . + \ '%f:%l:%c: %trror: %m,' . + \ '%f:%l:%c: %tarning: %m,' . + \ '%f:%l:%c: %m,' . + \ '%f:%l: %trror: %m,' . + \ '%f:%l: %tarning: %m,' . + \ '%f:%l: %m' + + if exists('g:syntastic_objc_errorformat') + let errorformat = g:syntastic_objc_errorformat + endif + + " add optional user-defined compiler options + let makeprg .= g:syntastic_objc_compiler_options + + let makeprg .= ' ' . shellescape(expand('%')) . + \ ' ' . syntastic#c#GetIncludeDirs('objc') + + " determine whether to parse header files as well + if expand('%') =~? '\.h$' + if exists('g:syntastic_objc_check_header') + let makeprg = g:syntastic_objc_compiler . + \ ' -x objective-c-header ' . + \ ' -c ' . shellescape(expand('%')) . + \ ' ' . g:syntastic_objc_compiler_options . + \ ' ' . syntastic#c#GetIncludeDirs('objc') + else + return [] + endif + endif + + " check if the user manually set some cflags + if !exists('b:syntastic_objc_cflags') + " check whether to search for include files at all + if !exists('g:syntastic_objc_no_include_search') || + \ g:syntastic_objc_no_include_search != 1 + " refresh the include file search if desired + if exists('g:syntastic_objc_auto_refresh_includes') && + \ g:syntastic_objc_auto_refresh_includes != 0 + let makeprg .= syntastic#c#SearchHeaders() + else + " search for header includes if not cached already + if !exists('b:syntastic_objc_includes') + let b:syntastic_objc_includes = syntastic#c#SearchHeaders() + endif + let makeprg .= b:syntastic_objc_includes + endif + endif + else + " use the user-defined cflags + let makeprg .= b:syntastic_objc_cflags + endif + + " add optional config file parameters + let makeprg .= ' ' . syntastic#c#ReadConfig(g:syntastic_objc_config_file) + + " process makeprg + let errors = SyntasticMake({ 'makeprg': makeprg, + \ 'errorformat': errorformat }) + + " filter the processed errors if desired + if exists('g:syntastic_objc_remove_include_errors') && + \ g:syntastic_objc_remove_include_errors != 0 + return filter(errors, + \ 'has_key(v:val, "bufnr") && v:val["bufnr"]=='.bufnr('')) + else + return errors + endif +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'objc', + \ 'name': 'gcc'}) + +let &cpo = s:save_cpo +unlet s:save_cpo + +" vim: set et sts=4 sw=4: diff --git a/bundle/syntastic/syntax_checkers/objc/ycm.vim b/bundle/syntastic/syntax_checkers/objc/ycm.vim new file mode 100644 index 00000000..1406dd83 --- /dev/null +++ b/bundle/syntastic/syntax_checkers/objc/ycm.vim @@ -0,0 +1,34 @@ +"============================================================================ +"File: ycm.vim +"Description: Syntax checking plugin for syntastic.vim +"Maintainer: Val Markovic +"License: This program is free software. It comes without any warranty, +" to the extent permitted by applicable law. You can redistribute +" it and/or modify it under the terms of the Do What The Fuck You +" Want To Public License, Version 2, as published by Sam Hocevar. +" See http://sam.zoy.org/wtfpl/COPYING for more details. +" +"============================================================================ + +if exists("loaded_ycm_objc_syntax_checker") + finish +endif +let loaded_ycm_objc_syntax_checker = 1 + +runtime syntax_checkers/c/ycm.vim + +function! SyntaxCheckers_objc_ycm_IsAvailable() + return SyntaxCheckers_c_ycm_IsAvailable() +endfunction + +if !exists('g:loaded_youcompleteme') + finish +endif + +function! SyntaxCheckers_objc_ycm_GetLocList() + return SyntaxCheckers_c_ycm_GetLocList() +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'objc', + \ 'name': 'ycm'}) diff --git a/bundle/syntastic/syntax_checkers/ocaml/camlp4o.vim b/bundle/syntastic/syntax_checkers/ocaml/camlp4o.vim new file mode 100644 index 00000000..69d7494c --- /dev/null +++ b/bundle/syntastic/syntax_checkers/ocaml/camlp4o.vim @@ -0,0 +1,149 @@ +"============================================================================ +"File: ocaml.vim +"Description: Syntax checking plugin for syntastic.vim +"Maintainer: Török Edwin +"License: This program is free software. It comes without any warranty, +" to the extent permitted by applicable law. You can redistribute +" it and/or modify it under the terms of the Do What The Fuck You +" Want To Public License, Version 2, as published by Sam Hocevar. +" See http://sam.zoy.org/wtfpl/COPYING for more details. +" +"============================================================================ +" +" The more reliable way to check for a single .ml file is to use ocamlc. +" You can do that setting this in your .vimrc: +" +" let g:syntastic_ocaml_use_ocamlc = 1 +" It's possible to use ocamlc in conjuction with Jane Street's Core. In order +" to do that, you have to specify this in your .vimrc: +" +" let g:syntastic_ocaml_use_janestreet_core = 1 +" let g:syntastic_ocaml_janestreet_core_dir = +" +" Where path is the path to your core installation (usually a collection of +" .cmx and .cmxa files). +" +" +" By default the camlp4o preprocessor is used to check the syntax of .ml, and .mli files, +" ocamllex is used to check .mll files and menhir is used to check .mly files. +" The output is all redirected to /dev/null, nothing is written to the disk. +" +" If your source code needs camlp4r then you can define this in your .vimrc: +" +" let g:syntastic_ocaml_camlp4r = 1 +" +" If you used some syntax extensions, or you want to also typecheck the source +" code, then you can define this: +" +" let g:syntastic_ocaml_use_ocamlbuild = 1 +" +" This will run ocamlbuild .inferred.mli, so it will write to your _build +" directory (and possibly rebuild your myocamlbuild.ml plugin), only enable this +" if you are ok with that. +" +" If you are using syntax extensions / external libraries and have a properly +" set up _tags (and myocamlbuild.ml file) then it should just work +" to enable this flag and get syntax / type checks through syntastic. +" +" For best results your current directory should be the project root +" (same situation if you want useful output from :make). + +if exists("g:loaded_syntastic_ocaml_camlp4o_checker") + finish +endif +let g:loaded_syntastic_ocaml_camlp4o_checker=1 + +if exists('g:syntastic_ocaml_camlp4r') && + \ g:syntastic_ocaml_camlp4r != 0 + let s:ocamlpp="camlp4r" +else + let s:ocamlpp="camlp4o" +endif + +function! SyntaxCheckers_ocaml_camlp4o_IsAvailable() + return executable(s:ocamlpp) +endfunction + +if !exists('g:syntastic_ocaml_use_ocamlc') || !executable('ocamlc') + let g:syntastic_ocaml_use_ocamlc = 0 +endif + +if !exists('g:syntastic_ocaml_use_janestreet_core') + let g:syntastic_ocaml_use_ocamlc = 0 +endif + +if !exists('g:syntastic_ocaml_use_ocamlbuild') || !executable("ocamlbuild") + let g:syntastic_ocaml_use_ocamlbuild = 0 +endif + +function! SyntaxCheckers_ocaml_camlp4o_GetLocList() + let makeprg = s:GetMakeprg() + if makeprg == "" + return [] + endif + + let errorformat = + \ '%AFile "%f"\, line %l\, characters %c-%*\d:,'. + \ '%AFile "%f"\, line %l\, characters %c-%*\d (end at line %*\d\, character %*\d):,'. + \ '%AFile "%f"\, line %l\, character %c:,'. + \ '%AFile "%f"\, line %l\, character %c:%m,'. + \ '%-GPreprocessing error %.%#,'. + \ '%-GCommand exited %.%#,'. + \ '%C%tarning %n: %m,'. + \ '%C%m,'. + \ '%-G+%.%#' + + return SyntasticMake({ 'makeprg': makeprg, 'errorformat': errorformat }) +endfunction + +function s:GetMakeprg() + if g:syntastic_ocaml_use_ocamlc + return s:GetOcamlcMakeprg() + endif + + if g:syntastic_ocaml_use_ocamlbuild && isdirectory('_build') + return s:GetOcamlBuildMakeprg() + endif + + return s:GetOtherMakeprg() +endfunction + +function s:GetOcamlcMakeprg() + if g:syntastic_ocaml_use_janestreet_core + let build_cmd = "ocamlc -I " + let build_cmd .= expand(g:syntastic_ocaml_janestreet_core_dir) + let build_cmd .= " -c ".expand('%') + return build_cmd + else + return "ocamlc -c ". expand('%') + endif +endfunction + +function s:GetOcamlBuildMakeprg() + return "ocamlbuild -quiet -no-log -tag annot,". s:ocamlpp. " -no-links -no-hygiene -no-sanitize ". + \ shellescape(expand('%:r')).".cmi" +endfunction + +function s:GetOtherMakeprg() + "TODO: give this function a better name? + " + "TODO: should use throw/catch instead of returning an empty makeprg + + let extension = expand('%:e') + let makeprg = "" + + if match(extension, 'mly') >= 0 && executable("menhir") + " ocamlyacc output can't be redirected, so use menhir + let makeprg = "menhir --only-preprocess ".shellescape(expand('%')) . " >/dev/null" + elseif match(extension,'mll') >= 0 && executable("ocamllex") + let makeprg = "ocamllex -q -o /dev/null ".shellescape(expand('%')) + else + let makeprg = "camlp4o -o /dev/null ".shellescape(expand('%')) + endif + + return makeprg +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'ocaml', + \ 'name': 'camlp4o'}) diff --git a/bundle/syntastic/syntax_checkers/perl/efm_perl.pl b/bundle/syntastic/syntax_checkers/perl/efm_perl.pl new file mode 100644 index 00000000..2e74bcb0 --- /dev/null +++ b/bundle/syntastic/syntax_checkers/perl/efm_perl.pl @@ -0,0 +1,186 @@ +#!/usr/bin/env perl +# vimparse.pl - Reformats the error messages of the Perl interpreter for use +# with the quickfix mode of Vim +# +# Copyright (c) 2001 by Jörg Ziefle +# Copyright (c) 2012 Eric Harmon +# You may use and distribute this software under the same terms as Perl itself. +# +# Usage: put one of the two configurations below in your ~/.vimrc (without the +# description and '# ') and enjoy (be sure to adjust the paths to vimparse.pl +# before): +# +# Program is run interactively with 'perl -w': +# +# set makeprg=$HOME/bin/vimparse.pl\ %\ $* +# set errorformat=%t:%f:%l:%m +# +# Program is only compiled with 'perl -wc': +# +# set makeprg=$HOME/bin/vimparse.pl\ -c\ %\ $* +# set errorformat=%t:%f:%l:%m +# +# Usage: +# vimparse.pl [-c] [-w] [-f ] [programargs] +# +# -c compile only, don't run (perl -wc) +# -w output warnings as warnings instead of errors (slightly slower) +# -f write errors to +# +# Example usages: +# * From the command line: +# vimparse.pl program.pl +# +# vimparse.pl -c -w -f errorfile program.pl +# Then run vim -q errorfile to edit the errors with Vim. +# This uses the custom errorformat: %t:%f:%l:%m. +# +# * From Vim: +# Edit in Vim (and save, if you don't have autowrite on), then +# type ':mak' or ':mak args' (args being the program arguments) +# to error check. +# +# Version history: +# 0.3 (05/31/2012): +# * Added support for the seperate display of warnings +# * Switched output format to %t:%f:%l:%m to support error levels +# 0.2 (04/12/2001): +# * First public version (sent to Bram) +# * -c command line option for compiling only +# * grammatical fix: 'There was 1 error.' +# * bug fix for multiple arguments +# * more error checks +# * documentation (top of file, &usage) +# * minor code clean ups +# 0.1 (02/02/2001): +# * Initial version +# * Basic functionality +# +# Todo: +# * test on more systems +# * use portable way to determine the location of perl ('use Config') +# * include option that shows perldiag messages for each error +# * allow to pass in program by STDIN +# * more intuitive behaviour if no error is found (show message) +# +# Tested under SunOS 5.7 with Perl 5.6.0. Let me know if it's not working for +# you. +use warnings; +use strict; +use Getopt::Std; +use File::Temp qw( tempfile ); + +use vars qw/$opt_I $opt_c $opt_w $opt_f $opt_h/; # needed for Getopt in combination with use strict 'vars' + +use constant VERSION => 0.2; + +getopts('cwf:hI:'); + +&usage if $opt_h; # not necessarily needed, but good for further extension + +if (defined $opt_f) { + + open FILE, "> $opt_f" or do { + warn "Couldn't open $opt_f: $!. Using STDOUT instead.\n"; + undef $opt_f; + }; + +}; + +my $handle = (defined $opt_f ? \*FILE : \*STDOUT); + +(my $file = shift) or &usage; # display usage if no filename is supplied +my $args = (@ARGV ? ' ' . join ' ', @ARGV : ''); + +if ($file eq '-') { # make STDIN seek-able, so it can be read twice + my $fh = tempfile(); + print {$fh} ; + open \*STDIN, '<&', $fh or die "open: $!"; + seek \*STDIN, 0, 0 or die "seek: $!"; +} + +my $libs = join ' ', map {"-I$_"} split ',', $opt_I || ''; +my @error_lines = `$^X $libs @{[defined $opt_c ? '-c ' : '' ]} @{[defined $opt_w ? '-X ' : '-Mwarnings ']} "$file$args" 2>&1`; + +my @lines = map { "E:$_" } @error_lines; + +my @warn_lines; +if(defined($opt_w)) { + if ($file eq '-') { + seek \*STDIN, 0, 0 or die "seek: $!"; + } + @warn_lines = `$^X $libs @{[defined $opt_c ? '-c ' : '' ]} -Mwarnings "$file$args" 2>&1`; +} + +# Any new errors must be warnings +foreach my $line (@warn_lines) { + if(!grep { $_ eq $line } @error_lines) { + push(@lines, "W:$line"); + } +} + +my $errors = 0; +foreach my $line (@lines) { + + chomp($line); + my ($file, $lineno, $message, $rest, $severity); + + if ($line =~ /^([EW]):(.*)\sat\s(.*)\sline\s(\d+)(.*)$/) { + ($severity, $message, $file, $lineno, $rest) = ($1, $2, $3, $4, $5); + $errors++; + $message .= $rest if ($rest =~ s/^,//); + print $handle "$severity:$file:$lineno:$message\n"; + + } else { next }; + +} + +if (defined $opt_f) { + + my $msg; + if ($errors == 1) { + + $msg = "There was 1 error.\n"; + + } else { + + $msg = "There were $errors errors.\n"; + + }; + + print STDOUT $msg; + close FILE; + unlink $opt_f unless $errors; + +}; + +sub usage { + + (local $0 = $0) =~ s/^.*\/([^\/]+)$/$1/; # remove path from name of program + print<] [programargs] + + -c compile only, don't run (executes 'perl -c') + -w output warnings as warnings instead of errors (slightly slower) + -f write errors to + -I specify \@INC/#include directory + +Examples: + * At the command line: + $0 program.pl + Displays output on STDOUT. + + $0 -c -w -f errorfile program.pl + Then run 'vim -q errorfile' to edit the errors with Vim. + This uses the custom errorformat: %t:%f:%l:%m. + + * In Vim: + Edit in Vim (and save, if you don't have autowrite on), then + type ':mak' or ':mak args' (args being the program arguments) + to error check. +EOT + + exit 0; + +}; diff --git a/bundle/syntastic/syntax_checkers/perl/perl.vim b/bundle/syntastic/syntax_checkers/perl/perl.vim new file mode 100644 index 00000000..67316da3 --- /dev/null +++ b/bundle/syntastic/syntax_checkers/perl/perl.vim @@ -0,0 +1,71 @@ +"============================================================================ +"File: perl.vim +"Description: Syntax checking plugin for syntastic.vim +"Maintainer: Anthony Carapetis , +" Eric Harmon +"License: This program is free software. It comes without any warranty, +" to the extent permitted by applicable law. You can redistribute +" it and/or modify it under the terms of the Do What The Fuck You +" Want To Public License, Version 2, as published by Sam Hocevar. +" See http://sam.zoy.org/wtfpl/COPYING for more details. +" +"============================================================================ +" +" In order to add some custom lib directories that should be added to the +" perl command line you can add those as a comma-separated list to the variable +" g:syntastic_perl_lib_path. +" +" let g:syntastic_perl_lib_path = './lib,./lib/auto' +" +" To use your own perl error output munger script, use the +" g:syntastic_perl_efm_program option. Any command line parameters should be +" included in the variable declaration. The program should expect a single +" parameter; the fully qualified filename of the file to be checked. +" +" let g:syntastic_perl_efm_program = "foo.pl -o -m -g" +" + +if exists("g:loaded_syntastic_perl_perl_checker") + finish +endif +let g:loaded_syntastic_perl_perl_checker=1 + +if !exists("g:syntastic_perl_interpreter") + let g:syntastic_perl_interpreter = "perl" +endif + +function! SyntaxCheckers_perl_perl_IsAvailable() + return executable(g:syntastic_perl_interpreter) +endfunction + +if !exists("g:syntastic_perl_efm_program") + let g:syntastic_perl_efm_program = + \ g:syntastic_perl_interpreter . ' ' . + \ shellescape(expand(':p:h') . '/efm_perl.pl') . + \ ' -c -w' +endif + +function! SyntaxCheckers_perl_perl_GetLocList() + let makeprg = exists("b:syntastic_perl_efm_program") ? b:syntastic_perl_efm_program : g:syntastic_perl_efm_program + if exists("g:syntastic_perl_lib_path") + let makeprg .= ' -I' . g:syntastic_perl_lib_path + endif + let makeprg .= ' ' . shellescape(expand('%')) . s:ExtraMakeprgArgs() + + let errorformat = '%t:%f:%l:%m' + + return SyntasticMake({ 'makeprg': makeprg, 'errorformat': errorformat }) +endfunction + +function! s:ExtraMakeprgArgs() + let shebang = syntastic#util#parseShebang() + if index(shebang['args'], '-T') != -1 + return ' -Tc' + endif + + return '' +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'perl', + \ 'name': 'perl'}) diff --git a/bundle/syntastic/syntax_checkers/perl/perlcritic.vim b/bundle/syntastic/syntax_checkers/perl/perlcritic.vim new file mode 100644 index 00000000..45a6cec2 --- /dev/null +++ b/bundle/syntastic/syntax_checkers/perl/perlcritic.vim @@ -0,0 +1,58 @@ +"============================================================================ +"File: perlcritic.vim +"Description: Syntax checking plugin for syntastic.vim +"Maintainer: LCD 47 +"License: This program is free software. It comes without any warranty, +" to the extent permitted by applicable law. You can redistribute +" it and/or modify it under the terms of the Do What The Fuck You +" Want To Public License, Version 2, as published by Sam Hocevar. +" See http://sam.zoy.org/wtfpl/COPYING for more details. +" +"============================================================================ +" +" For details about perlcritic see: +" +" - http://perlcritic.tigris.org/ +" - https://metacpan.org/module/Perl::Critic +" +" Checker options: +" +" - g:syntastic_perl_perlcritic_thres (integer; default: 5) +" error threshold: policy violations with a severity above this +" value are highlighted as errors, the others are warnings +" +" - g:syntastic_perl_perlcritic_args (string; default: empty) +" command line options to pass to perlcritic + +if exists("g:loaded_syntastic_perl_perlcritic_checker") + finish +endif +let g:loaded_syntastic_perl_perlcritic_checker=1 + +if !exists('g:syntastic_perl_perlcritic_thres') + let g:syntastic_perl_perlcritic_thres = 5 +endif + +function! SyntaxCheckers_perl_perlcritic_IsAvailable() + return executable('perlcritic') +endfunction + +function! SyntaxCheckers_perl_perlcritic_GetLocList() + let makeprg = syntastic#makeprg#build({ + \ 'exe': 'perlcritic', + \ 'post_args': '--quiet --nocolor --verbose "\%s:\%f:\%l:\%c:(\%s) \%m (\%e)\n"', + \ 'subchecker': 'perlcritic' }) + let errorformat='%t:%f:%l:%c:%m' + let loclist = SyntasticMake({ 'makeprg': makeprg, 'errorformat': errorformat, 'subtype': 'Style' }) + + " change error types according to the prescribed threshold + for n in range(len(loclist)) + let loclist[n]['type'] = loclist[n]['type'] < g:syntastic_perl_perlcritic_thres ? 'W' : 'E' + endfor + + return loclist +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'perl', + \ 'name': 'perlcritic'}) diff --git a/bundle/syntastic/syntax_checkers/perl/podchecker.vim b/bundle/syntastic/syntax_checkers/perl/podchecker.vim new file mode 100644 index 00000000..b5355539 --- /dev/null +++ b/bundle/syntastic/syntax_checkers/perl/podchecker.vim @@ -0,0 +1,30 @@ +"============================================================================ +"File: podchecker.vim +"Description: Syntax checking plugin for syntastic.vim +"Maintainer: LCD 47 +"License: This program is free software. It comes without any warranty, +" to the extent permitted by applicable law. You can redistribute +" it and/or modify it under the terms of the Do What The Fuck You +" Want To Public License, Version 2, as published by Sam Hocevar. +" See http://sam.zoy.org/wtfpl/COPYING for more details. +" +"============================================================================ + +if exists("g:loaded_syntastic_perl_podchecker_checker") + finish +endif +let g:loaded_syntastic_perl_podchecker_checker=1 + +runtime syntax_checkers/pod/podchecker.vim + +function! SyntaxCheckers_perl_podchecker_IsAvailable() + return SyntaxCheckers_pod_podchecker_IsAvailable() +endfunction + +function! SyntaxCheckers_perl_podchecker_GetLocList() + return SyntaxCheckers_pod_podchecker_GetLocList() +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'perl', + \ 'name': 'podchecker'}) diff --git a/bundle/syntastic/syntax_checkers/php/php.vim b/bundle/syntastic/syntax_checkers/php/php.vim new file mode 100644 index 00000000..e5039ea5 --- /dev/null +++ b/bundle/syntastic/syntax_checkers/php/php.vim @@ -0,0 +1,47 @@ +"============================================================================ +"File: php.vim +"Description: Syntax checking plugin for syntastic.vim +"Maintainer: Martin Grenfell +"License: This program is free software. It comes without any warranty, +" to the extent permitted by applicable law. You can redistribute +" it and/or modify it under the terms of the Do What The Fuck You +" Want To Public License, Version 2, as published by Sam Hocevar. +" See http://sam.zoy.org/wtfpl/COPYING for more details. +" +"============================================================================ + +if exists("g:loaded_syntastic_php_php_checker") + finish +endif +let g:loaded_syntastic_php_php_checker=1 + +function! SyntaxCheckers_php_php_IsAvailable() + return executable("php") +endfunction + +function! SyntaxCheckers_php_php_GetHighlightRegex(item) + let unexpected = matchstr(a:item['text'], "unexpected '[^']\\+'") + if len(unexpected) < 1 + return '' + endif + return '\V'.split(unexpected, "'")[1] +endfunction + +function! SyntaxCheckers_php_php_GetLocList() + let makeprg = syntastic#makeprg#build({ + \ 'exe': 'php', + \ 'args': '-l -d error_reporting=E_ALL -d display_errors=1 -d log_errors=0 -d xdebug.cli_color=0', + \ 'subchecker': 'php' }) + let errorformat = + \ '%-GNo syntax errors detected in%.%#,'. + \ 'Parse error: %#syntax %trror\, %m in %f on line %l,'. + \ 'Parse %trror: %m in %f on line %l,'. + \ 'Fatal %trror: %m in %f on line %l,'. + \ '%-G\s%#,'. + \ '%-GErrors parsing %.%#' + return SyntasticMake({ 'makeprg': makeprg, 'errorformat': errorformat }) +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'php', + \ 'name': 'php'}) diff --git a/bundle/syntastic/syntax_checkers/php/phpcs.vim b/bundle/syntastic/syntax_checkers/php/phpcs.vim new file mode 100644 index 00000000..321f0f5a --- /dev/null +++ b/bundle/syntastic/syntax_checkers/php/phpcs.vim @@ -0,0 +1,38 @@ +"============================================================================ +"File: phpcs.vim +"Description: Syntax checking plugin for syntastic.vim +"Maintainer: Martin Grenfell +"License: This program is free software. It comes without any warranty, +" to the extent permitted by applicable law. You can redistribute +" it and/or modify it under the terms of the Do What The Fuck You +" Want To Public License, Version 2, as published by Sam Hocevar. +" See http://sam.zoy.org/wtfpl/COPYING for more details. +" +"============================================================================ +" +" See here for details of phpcs +" - phpcs (see http://pear.php.net/package/PHP_CodeSniffer) +" +if exists("g:loaded_syntastic_php_phpcs_checker") + finish +endif +let g:loaded_syntastic_php_phpcs_checker=1 + +function! SyntaxCheckers_php_phpcs_IsAvailable() + return executable('phpcs') +endfunction + +function! SyntaxCheckers_php_phpcs_GetLocList() + let makeprg = syntastic#makeprg#build({ + \ 'exe': 'phpcs', + \ 'args': '--report=csv', + \ 'subchecker': 'phpcs' }) + let errorformat = + \ '%-GFile\,Line\,Column\,Type\,Message\,Source\,Severity,'. + \ '"%f"\,%l\,%c\,%t%*[a-zA-Z]\,"%m"\,%*[a-zA-Z0-9_.-]\,%*[0-9]' + return SyntasticMake({ 'makeprg': makeprg, 'errorformat': errorformat, 'subtype': 'Style' }) +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'php', + \ 'name': 'phpcs'}) diff --git a/bundle/syntastic/syntax_checkers/php/phpmd.vim b/bundle/syntastic/syntax_checkers/php/phpmd.vim new file mode 100644 index 00000000..bf27a1ca --- /dev/null +++ b/bundle/syntastic/syntax_checkers/php/phpmd.vim @@ -0,0 +1,72 @@ +"============================================================================ +"File: phpmd.vim +"Description: Syntax checking plugin for syntastic.vim +"Maintainer: Martin Grenfell +"License: This program is free software. It comes without any warranty, +" to the extent permitted by applicable law. You can redistribute +" it and/or modify it under the terms of the Do What The Fuck You +" Want To Public License, Version 2, as published by Sam Hocevar. +" See http://sam.zoy.org/wtfpl/COPYING for more details. +" +"============================================================================ +" +" See here for details of phpmd +" - phpmd (see http://phpmd.org) + +if exists("g:loaded_syntastic_php_phpmd_checker") + finish +endif +let g:loaded_syntastic_php_phpmd_checker=1 + +function! SyntaxCheckers_php_phpmd_IsAvailable() + return executable('phpmd') +endfunction + +function! SyntaxCheckers_php_phpmd_GetHighlightRegex(item) + let term = matchstr(a:item['text'], '\C^The \S\+ \w\+\(()\)\= \(has\|is not\|utilizes\)') + if term != '' + return '\V'.substitute(term, '\C^The \S\+ \(\w\+\)\(()\)\= .*', '\1', '') + endif + let term = matchstr(a:item['text'], '\C^Avoid \(variables with short\|excessively long variable\) names like \S\+\.') + if term != '' + return '\V'.substitute(term, '\C^Avoid \(variables with short\|excessively long variable\) names like \(\S\+\)\..*', '\2', '') + endif + let term = matchstr(a:item['text'], '\C^Avoid using short method names like \S\+::\S\+()\.') + if term != '' + return '\V'.substitute(term, '\C^Avoid using short method names like \S\+::\(\S\+\)()\..*', '\1', '') + endif + let term = matchstr(a:item['text'], '\C^\S\+ accesses the super-global variable ') + if term != '' + return '\V'.substitute(term, '\C accesses the super-global variable .*$', '', '') + endif + let term = matchstr(a:item['text'], '\C^Constant \S\+ should be defined in uppercase') + if term != '' + return '\V'.substitute(term, '\C^Constant \(\S\+\) should be defined in uppercase', '\1', '') + endif + let term = matchstr(a:item['text'], "\\C^The '\\S\\+()' method which returns ") + if term != '' + return '\V'.substitute(term, "\\C^The '\\(\\S\\+\\()' method which returns.*", '\1', '') + endif + let term = matchstr(a:item['text'], '\C variable \S\+ should begin with ') + if term != '' + return '\V'.substitute(term, '\C.* variable \(\S\+\) should begin with .*', '\1', '') + endif + let term = matchstr(a:item['text'], "\\C^Avoid unused \\(private fields\\|local variables\\|private methods\\|parameters\\) such as '\\S\\+'") + if term != '' + return '\V'.substitute(term, "\\C^Avoid unused \\(private fields\\|local variables\\|private methods\\|parameters\\) such as '\\(\\S\\+\\)'.*", '\2', '') + endif + return '' +endfunction + +function! SyntaxCheckers_php_phpmd_GetLocList() + let makeprg = syntastic#makeprg#build({ + \ 'exe': 'phpmd', + \ 'post_args': 'text codesize,design,unusedcode,naming', + \ 'subchecker': 'phpmd' }) + let errorformat = '%E%f:%l%\s%#%m' + return SyntasticMake({ 'makeprg': makeprg, 'errorformat': errorformat, 'subtype' : 'Style' }) +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'php', + \ 'name': 'phpmd'}) diff --git a/bundle/syntastic/syntax_checkers/pod/podchecker.vim b/bundle/syntastic/syntax_checkers/pod/podchecker.vim new file mode 100644 index 00000000..212e4329 --- /dev/null +++ b/bundle/syntastic/syntax_checkers/pod/podchecker.vim @@ -0,0 +1,35 @@ +"============================================================================ +"File: podchecker.vim +"Description: Syntax checking plugin for syntastic.vim +"Maintainer: LCD 47 +"License: This program is free software. It comes without any warranty, +" to the extent permitted by applicable law. You can redistribute +" it and/or modify it under the terms of the Do What The Fuck You +" Want To Public License, Version 2, as published by Sam Hocevar. +" See http://sam.zoy.org/wtfpl/COPYING for more details. +" +"============================================================================ +if exists("g:loaded_syntastic_pod_podchecker_checker") + finish +endif +let g:loaded_syntastic_pod_podchecker_checker=1 + +function! SyntaxCheckers_pod_podchecker_IsAvailable() + return executable("podchecker") +endfunction + +function! SyntaxCheckers_pod_podchecker_GetLocList() + let makeprg = syntastic#makeprg#build({ + \ 'exe': 'podchecker', + \ 'subchecker': 'podchecker' }) + let errorformat = + \ '%W%[%#]%[%#]%[%#] WARNING: %m at line %l in file %f,' . + \ '%E%[%#]%[%#]%[%#] ERROR: %m at line %l in file %f' + + return SyntasticMake({ 'makeprg': makeprg, 'errorformat': errorformat }) +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'pod', + \ 'name': 'podchecker'}) + diff --git a/bundle/syntastic/syntax_checkers/puppet/puppetlint.vim b/bundle/syntastic/syntax_checkers/puppet/puppetlint.vim new file mode 100644 index 00000000..72173859 --- /dev/null +++ b/bundle/syntastic/syntax_checkers/puppet/puppetlint.vim @@ -0,0 +1,113 @@ +"============================================================================ +"File: puppet.vim +"Description: Syntax checking plugin for syntastic.vim +"Maintainer: Eivind Uggedal +"License: This program is free software. It comes without any warranty, +" to the extent permitted by applicable law. You can redistribute +" it and/or modify it under the terms of the Do What The Fuck You +" Want To Public License, Version 2, as published by Sam Hocevar. +" See http://sam.zoy.org/wtfpl/COPYING for more details. +" +"============================================================================ + +if exists("g:loaded_syntastic_puppet_puppetlint_checker") + finish +endif +let g:loaded_syntastic_puppet_puppetlint_checker=1 + +function! SyntaxCheckers_puppet_puppetlint_IsAvailable() + return executable("puppet-lint") +endfunction + +if !exists("g:syntastic_puppet_validate_disable") + let g:syntastic_puppet_validate_disable = 0 +endif + +if !exists("g:syntastic_puppet_lint_disable") + let g:syntastic_puppet_lint_disable = 0 +endif + +if !executable("puppet-lint") + let g:syntastic_puppet_lint_disable = 1 +endif + +function! s:PuppetVersion() + if !exists("s:puppet_version") + let output = system("puppet --version 2>/dev/null") + let output = substitute(output, '\n$', '', '') + let s:puppet_version = split(output, '\.') + endif + return s:puppet_version +endfunction + +function! s:PuppetLintVersion() + if !exists("s:puppet_lint_version") + let output = system("puppet-lint --version 2>/dev/null") + let output = substitute(output, '\n$', '', '') + let output = substitute(output, '^puppet-lint ', '', 'i') + let s:puppet_lint_version = split(output, '\.') + endif + return s:puppet_lint_version +endfunction + +if !g:syntastic_puppet_lint_disable + if !syntastic#util#versionIsAtLeast(s:PuppetLintVersion(), [0,1,10]) + let g:syntastic_puppet_lint_disable = 1 + endif +end + +function! s:getPuppetLintErrors() + if !exists("g:syntastic_puppet_lint_arguments") + let g:syntastic_puppet_lint_arguments = '' + endif + + let makeprg = 'puppet-lint --log-format "\%{KIND} [\%{check}] \%{message} at \%{fullpath}:\%{linenumber}" '.g:syntastic_puppet_lint_arguments.' '.shellescape(expand('%')) + let errorformat = '%t%*[a-zA-Z] %m at %f:%l' + return SyntasticMake({ 'makeprg': makeprg, 'errorformat': errorformat, 'subtype': 'Style' }) +endfunction + +function! s:getPuppetMakeprg() + "If puppet is >= version 2.7 then use the new executable + if syntastic#util#versionIsAtLeast(s:PuppetVersion(), [2,7,0]) + let makeprg = 'puppet parser validate ' . + \ shellescape(expand('%')) . + \ ' --color=false' + else + let makeprg = 'puppet --color=false --parseonly '.shellescape(expand('%')) + endif + return makeprg +endfunction + +function! s:getPuppetEfm() + "some versions of puppet (e.g. 2.7.10) output the message below if there + "are any syntax errors + let errorformat = '%-Gerr: Try ''puppet help parser validate'' for usage,' + let errorformat .= 'err: Could not parse for environment %*[a-z]: %m at %f:%l' + + "Puppet 3.0.0 changes this from "err:" to "Error:" + "reset errorformat in that case + if syntastic#util#versionIsAtLeast(s:PuppetVersion(), [3,0,0]) + let errorformat = '%-GError: Try ''puppet help parser validate'' for usage,' + let errorformat .= 'Error: Could not parse for environment %*[a-z]: %m at %f:%l' + endif + + return errorformat +endfunction + +function! SyntaxCheckers_puppet_puppetlint_GetLocList() + let errors = [] + + if !g:syntastic_puppet_validate_disable + let errors = errors + SyntasticMake({ 'makeprg': s:getPuppetMakeprg(), 'errorformat': s:getPuppetEfm() }) + endif + + if !g:syntastic_puppet_lint_disable + let errors = errors + s:getPuppetLintErrors() + endif + + return errors +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'puppet', + \ 'name': 'puppetlint'}) diff --git a/bundle/syntastic/syntax_checkers/python/flake8.vim b/bundle/syntastic/syntax_checkers/python/flake8.vim new file mode 100644 index 00000000..0dfa14db --- /dev/null +++ b/bundle/syntastic/syntax_checkers/python/flake8.vim @@ -0,0 +1,49 @@ +"============================================================================ +"File: flake8.vim +"Description: Syntax checking plugin for syntastic.vim +"Authors: Sylvain Soliman +" kstep +" +"============================================================================ +if exists("g:loaded_syntastic_python_flake8_checker") + finish +endif +let g:loaded_syntastic_python_flake8_checker=1 + +function! SyntaxCheckers_python_flake8_IsAvailable() + return executable('flake8') +endfunction + +function! SyntaxCheckers_python_flake8_GetHighlightRegex(i) + if match(a:i['text'], 'is assigned to but never used') > -1 + \ || match(a:i['text'], 'imported but unused') > -1 + \ || match(a:i['text'], 'undefined name') > -1 + \ || match(a:i['text'], 'redefinition of') > -1 + \ || match(a:i['text'], 'referenced before assignment') > -1 + \ || match(a:i['text'], 'duplicate argument') > -1 + \ || match(a:i['text'], 'after other statements') > -1 + \ || match(a:i['text'], 'shadowed by loop variable') > -1 + + let term = split(a:i['text'], "'", 1)[1] + return '\V\<'.term.'\>' + endif + return '' +endfunction + +function! SyntaxCheckers_python_flake8_GetLocList() + let makeprg = syntastic#makeprg#build({ + \ 'exe': 'flake8', + \ 'subchecker': 'flake8' }) + let errorformat = + \ '%E%f:%l: could not compile,%-Z%p^,'. + \ '%W%f:%l:%c: F%n %m,'. + \ '%W%f:%l:%c: C%n %m,'. + \ '%E%f:%l:%c: %t%n %m,'. + \ '%E%f:%l: %t%n %m,'. + \ '%-G%.%#' + return SyntasticMake({ 'makeprg': makeprg, 'errorformat': errorformat }) +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'python', + \ 'name': 'flake8'}) diff --git a/bundle/syntastic/syntax_checkers/python/pep8.vim b/bundle/syntastic/syntax_checkers/python/pep8.vim new file mode 100644 index 00000000..4cf194f5 --- /dev/null +++ b/bundle/syntastic/syntax_checkers/python/pep8.vim @@ -0,0 +1,40 @@ +"============================================================================ +"File: pep8.vim +"Description: Syntax checking plugin for syntastic.vim +"Maintainer: LCD 47 +"License: This program is free software. It comes without any warranty, +" to the extent permitted by applicable law. You can redistribute +" it and/or modify it under the terms of the Do What The Fuck You +" Want To Public License, Version 2, as published by Sam Hocevar. +" See http://sam.zoy.org/wtfpl/COPYING for more details. +" +"============================================================================ +" +" For details about pep8 see: https://github.com/jcrocholl/pep8 + +if exists("g:loaded_syntastic_python_pep8_checker") + finish +endif +let g:loaded_syntastic_python_pep8_checker=1 + +function! SyntaxCheckers_python_pep8_IsAvailable() + return executable('pep8') +endfunction + +function! SyntaxCheckers_python_pep8_GetLocList() + let makeprg = syntastic#makeprg#build({ + \ 'exe': 'pep8', + \ 'subchecker': 'pep8' }) + let errorformat = '%f:%l:%c: %m' + let loclist = SyntasticMake({ 'makeprg': makeprg, 'errorformat': errorformat, 'subtype': 'Style' }) + + for n in range(len(loclist)) + let loclist[n]['type'] = loclist[n]['text'] =~? '^W' ? 'W' : 'E' + endfor + + return loclist +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'python', + \ 'name': 'pep8'}) diff --git a/bundle/syntastic/syntax_checkers/python/py3kwarn.vim b/bundle/syntastic/syntax_checkers/python/py3kwarn.vim new file mode 100644 index 00000000..bb76aa77 --- /dev/null +++ b/bundle/syntastic/syntax_checkers/python/py3kwarn.vim @@ -0,0 +1,26 @@ +"============================================================================ +"File: py3kwarn.vim +"Description: Syntax checking plugin for syntastic.vim +"Authors: Liam Curry +" +"============================================================================ +if exists("g:loaded_syntastic_python_py3kwarn_checker") + finish +endif +let g:loaded_syntastic_python_py3kwarn_checker=1 + +function! SyntaxCheckers_python_py3kwarn_IsAvailable() + return executable('py3kwarn') +endfunction + +function! SyntaxCheckers_python_py3kwarn_GetLocList() + let makeprg = syntastic#makeprg#build({ + \ 'exe': 'py3kwarn', + \ 'subchecker': 'py3kwarn' }) + let errorformat = '%W%f:%l:%c: %m' + return SyntasticMake({ 'makeprg': makeprg, 'errorformat': errorformat }) +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'python', + \ 'name': 'py3kwarn'}) diff --git a/bundle/syntastic/syntax_checkers/python/pyflakes.vim b/bundle/syntastic/syntax_checkers/python/pyflakes.vim new file mode 100644 index 00000000..de434414 --- /dev/null +++ b/bundle/syntastic/syntax_checkers/python/pyflakes.vim @@ -0,0 +1,52 @@ +"============================================================================ +"File: pyflakes.vim +"Description: Syntax checking plugin for syntastic.vim +"Authors: Martin Grenfell +" kstep +" Parantapa Bhattacharya +" +"============================================================================ +if exists("g:loaded_syntastic_python_pyflakes_checker") + finish +endif +let g:loaded_syntastic_python_pyflakes_checker=1 + +function! SyntaxCheckers_python_pyflakes_IsAvailable() + return executable('pyflakes') +endfunction + +function! SyntaxCheckers_python_pyflakes_GetHighlightRegex(i) + if match(a:i['text'], 'is assigned to but never used') > -1 + \ || match(a:i['text'], 'imported but unused') > -1 + \ || match(a:i['text'], 'undefined name') > -1 + \ || match(a:i['text'], 'redefinition of') > -1 + \ || match(a:i['text'], 'referenced before assignment') > -1 + \ || match(a:i['text'], 'duplicate argument') > -1 + \ || match(a:i['text'], 'after other statements') > -1 + \ || match(a:i['text'], 'shadowed by loop variable') > -1 + + let term = split(a:i['text'], "'", 1)[1] + return '\V\<'.term.'\>' + endif + return '' +endfunction + +function! SyntaxCheckers_python_pyflakes_GetLocList() + let makeprg = syntastic#makeprg#build({ + \ 'exe': 'pyflakes', + \ 'subchecker': 'pyflakes' }) + let errorformat = + \ '%E%f:%l: could not compile,'. + \ '%-Z%p^,'. + \ '%E%f:%l:%c: %m,'. + \ '%E%f:%l: %m,'. + \ '%-G%.%#' + + return SyntasticMake({ 'makeprg': makeprg, + \ 'errorformat': errorformat, + \ 'defaults': {'text': "Syntax error"} }) +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'python', + \ 'name': 'pyflakes'}) diff --git a/bundle/syntastic/syntax_checkers/python/pylint.vim b/bundle/syntastic/syntax_checkers/python/pylint.vim new file mode 100644 index 00000000..b7bfa122 --- /dev/null +++ b/bundle/syntastic/syntax_checkers/python/pylint.vim @@ -0,0 +1,41 @@ +"============================================================================ +"File: pylint.vim +"Description: Syntax checking plugin for syntastic.vim +"Author: Parantapa Bhattacharya +" +"============================================================================ +if exists("g:loaded_syntastic_python_pylint_checker") + finish +endif +let g:loaded_syntastic_python_pylint_checker=1 + +function! SyntaxCheckers_python_pylint_IsAvailable() + return executable('pylint') +endfunction + +function! SyntaxCheckers_python_pylint_GetLocList() + let makeprg = syntastic#makeprg#build({ + \ 'exe': 'pylint', + \ 'args': ' -f parseable -r n -i y', + \ 'subchecker': 'pylint' }) + let errorformat = + \ '%A%f:%l:%m,' . + \ '%A%f:(%l):%m,' . + \ '%-Z%p^%.%#,' . + \ '%-G%.%#' + + let loclist=SyntasticMake({ + \ 'makeprg': makeprg, + \ 'errorformat': errorformat, + \ 'postprocess': ['sort'] }) + + for n in range(len(loclist)) + let loclist[n]['type'] = match(['R', 'C', 'W'], loclist[n]['text'][2]) >= 0 ? 'W' : 'E' + endfor + + return loclist +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'python', + \ 'name': 'pylint' }) diff --git a/bundle/syntastic/syntax_checkers/python/python.vim b/bundle/syntastic/syntax_checkers/python/python.vim new file mode 100644 index 00000000..8ede8fd1 --- /dev/null +++ b/bundle/syntastic/syntax_checkers/python/python.vim @@ -0,0 +1,37 @@ +"============================================================================ +"File: python.vim +"Description: Syntax checking plugin for syntastic.vim +"Author: Artem Nezvigin +" +" `errorformat` derived from: +" http://www.vim.org/scripts/download_script.php?src_id=1392 +" +"============================================================================ +if exists("g:loaded_syntastic_python_python_checker") + finish +endif +let g:loaded_syntastic_python_python_checker=1 + +function! SyntaxCheckers_python_python_IsAvailable() + return executable('python') +endfunction + +function! SyntaxCheckers_python_python_GetLocList() + let fname = "'" . escape(expand('%'), "\\'") . "'" + let makeprg = syntastic#makeprg#build({ + \ 'exe': 'python', + \ 'args': '-c', + \ 'fname': shellescape("compile(open(" . fname . ").read(), " . fname . ", 'exec')"), + \ 'subchecker': 'python' }) + let errorformat = + \ '%E File "%f"\, line %l,' . + \ '%C %p^,' . + \ '%C %.%#,' . + \ '%Z%m,' . + \ '%-G%.%#' + return SyntasticMake({ 'makeprg': makeprg, 'errorformat': errorformat }) +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'python', + \ 'name': 'python'}) diff --git a/bundle/syntastic/syntax_checkers/rst/rst2pseudoxml.vim b/bundle/syntastic/syntax_checkers/rst/rst2pseudoxml.vim new file mode 100644 index 00000000..734cff3a --- /dev/null +++ b/bundle/syntastic/syntax_checkers/rst/rst2pseudoxml.vim @@ -0,0 +1,48 @@ +"============================================================================ +"File: rst.vim +"Description: Syntax checking plugin for docutil's reStructuredText files +"Maintainer: James Rowe +"License: This program is free software. It comes without any warranty, +" to the extent permitted by applicable law. You can redistribute +" it and/or modify it under the terms of the Do What The Fuck You +" Want To Public License, Version 2, as published by Sam Hocevar. +" See http://sam.zoy.org/wtfpl/COPYING for more details. +" +"============================================================================ + +" We use rst2pseudoxml.py, as it is ever so marginally faster than the other +" rst2${x} tools in docutils. + +if exists("g:loaded_syntastic_rst_rst2pseudoxml_checker") + finish +endif +let g:loaded_syntastic_rst_rst2pseudoxml_checker=1 + +function! SyntaxCheckers_rst_rst2pseudoxml_IsAvailable() + return executable("rst2pseudoxml.py") || executable("rst2pseudoxml") +endfunction + +function! SyntaxCheckers_rst_rst2pseudoxml_GetLocList() + let makeprg = syntastic#makeprg#build({ + \ 'exe': s:exe(), + \ 'args': '--report=2 --exit-status=1', + \ 'tail': syntastic#util#DevNull(), + \ 'subchecker': 'rst2pseudoxml' }) + + let errorformat = + \ '%f:%l:\ (%tNFO/1)\ %m,'. + \ '%f:%l:\ (%tARNING/2)\ %m,'. + \ '%f:%l:\ (%tRROR/3)\ %m,'. + \ '%f:%l:\ (%tEVERE/4)\ %m,'. + \ '%-G%.%#' + + return SyntasticMake({ 'makeprg': makeprg, 'errorformat': errorformat }) +endfunction + +function s:exe() + return executable("rst2pseudoxml.py") ? "rst2pseudoxml.py" : "rst2pseudoxml" +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'rst', + \ 'name': 'rst2pseudoxml'}) diff --git a/bundle/syntastic/syntax_checkers/ruby/jruby.vim b/bundle/syntastic/syntax_checkers/ruby/jruby.vim new file mode 100644 index 00000000..d421741c --- /dev/null +++ b/bundle/syntastic/syntax_checkers/ruby/jruby.vim @@ -0,0 +1,49 @@ +"============================================================================ +"File: jruby.vim +"Description: Syntax checking plugin for syntastic.vim +"Maintainer: Leonid Shevtsov +"License: This program is free software. It comes without any warranty, +" to the extent permitted by applicable law. You can redistribute +" it and/or modify it under the terms of the Do What The Fuck You +" Want To Public License, Version 2, as published by Sam Hocevar. +" See http://sam.zoy.org/wtfpl/COPYING for more details. +" +"============================================================================ +if exists("g:loaded_syntastic_ruby_jruby_checker") + finish +endif +let g:loaded_syntastic_ruby_jruby_checker=1 + +function! SyntaxCheckers_ruby_jruby_IsAvailable() + return executable('jruby') +endfunction + +function! SyntaxCheckers_ruby_jruby_GetLocList() + let makeprg = syntastic#makeprg#build({ + \ 'exe': s:exe(), + \ 'args': s:args(), + \ 'subchecker': 'jruby' }) + + let errorformat = + \ '%-GSyntax OK for %f,'. + \ '%ESyntaxError in %f:%l: syntax error\, %m,'. + \ '%Z%p^,'. + \ '%W%f:%l: warning: %m,'. + \ '%Z%p^,'. + \ '%W%f:%l: %m,'. + \ '%-C%.%#' + + return SyntasticMake({ 'makeprg': makeprg, 'errorformat': errorformat }) +endfunction + +function s:args() + return has('win32') ? '-W1 -T1 -c' : '-W1 -c' +endfunction + +function s:exe() + return has('win32') ? 'jruby' : 'RUBYOPT= jruby' +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'ruby', + \ 'name': 'jruby'}) diff --git a/bundle/syntastic/syntax_checkers/ruby/macruby.vim b/bundle/syntastic/syntax_checkers/ruby/macruby.vim new file mode 100644 index 00000000..02c1a7d3 --- /dev/null +++ b/bundle/syntastic/syntax_checkers/ruby/macruby.vim @@ -0,0 +1,38 @@ +"============================================================================ +"File: macruby.vim +"Description: Syntax checking plugin for syntastic.vim +"License: This program is free software. It comes without any warranty, +" to the extent permitted by applicable law. You can redistribute +" it and/or modify it under the terms of the Do What The Fuck You +" Want To Public License, Version 2, as published by Sam Hocevar. +" See http://sam.zoy.org/wtfpl/COPYING for more details. +" +"============================================================================ +if exists("g:loaded_syntastic_ruby_macruby_checker") + finish +endif +let g:loaded_syntastic_ruby_macruby_checker=1 + +function! SyntaxCheckers_ruby_macruby_IsAvailable() + return executable('macruby') +endfunction + +function! SyntaxCheckers_ruby_macruby_GetLocList() + let makeprg = syntastic#makeprg#build({ + \ 'exe': 'RUBYOPT= macruby', + \ 'args': '-W1 -c', + \ 'subchecker': 'macruby' }) + let errorformat = + \ '%-GSyntax OK,'. + \ '%E%f:%l: syntax error\, %m,'. + \ '%Z%p^,'. + \ '%W%f:%l: warning: %m,'. + \ '%Z%p^,'. + \ '%W%f:%l: %m,'. + \ '%-C%.%#' + return SyntasticMake({ 'makeprg': makeprg, 'errorformat': errorformat }) +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'ruby', + \ 'name': 'macruby'}) diff --git a/bundle/syntastic/syntax_checkers/ruby/mri.vim b/bundle/syntastic/syntax_checkers/ruby/mri.vim new file mode 100644 index 00000000..3438e132 --- /dev/null +++ b/bundle/syntastic/syntax_checkers/ruby/mri.vim @@ -0,0 +1,73 @@ +"============================================================================ +"File: mri.vim +"Description: Syntax checking plugin for syntastic.vim +"Maintainer: Martin Grenfell +"License: This program is free software. It comes without any warranty, +" to the extent permitted by applicable law. You can redistribute +" it and/or modify it under the terms of the Do What The Fuck You +" Want To Public License, Version 2, as published by Sam Hocevar. +" See http://sam.zoy.org/wtfpl/COPYING for more details. +" +"============================================================================ + +if exists("g:loaded_syntastic_ruby_mri_checker") + finish +endif +let g:loaded_syntastic_ruby_mri_checker=1 + +if !exists("g:syntastic_ruby_exec") + let g:syntastic_ruby_exec = "ruby" +endif + +function! SyntaxCheckers_ruby_mri_IsAvailable() + return executable(expand(g:syntastic_ruby_exec)) +endfunction + +function! SyntaxCheckers_ruby_mri_GetHighlightRegex(i) + if match(a:i['text'], 'assigned but unused variable') > -1 + let term = split(a:i['text'], ' - ')[1] + return '\V\<'.term.'\>' + endif + + return '' +endfunction + +function! SyntaxCheckers_ruby_mri_GetLocList() + let exe = expand(g:syntastic_ruby_exec) + if !has('win32') + let exe = 'RUBYOPT= ' . exe + endif + + let makeprg = syntastic#makeprg#build({ + \ 'exe': exe, + \ 'args': '-w -T1 -c', + \ 'subchecker': 'mri' }) + + "this is a hack to filter out a repeated useless warning in rspec files + "containing lines like + " + " foo.should == 'bar' + " + "Which always generate the warning below. Note that ruby >= 1.9.3 includes + "the word "possibly" in the warning + let errorformat = '%-G%.%#warning: %\(possibly %\)%\?useless use of == in void context,' + + " filter out lines starting with ... + " long lines are truncated and wrapped in ... %p then returns the wrong + " column offset + let errorformat .= '%-G%\%.%\%.%\%.%.%#,' + + let errorformat .= + \ '%-GSyntax OK,'. + \ '%E%f:%l: syntax error\, %m,'. + \ '%Z%p^,'. + \ '%W%f:%l: warning: %m,'. + \ '%Z%p^,'. + \ '%W%f:%l: %m,'. + \ '%-C%.%#' + return SyntasticMake({ 'makeprg': makeprg, 'errorformat': errorformat }) +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'ruby', + \ 'name': 'mri'}) diff --git a/bundle/syntastic/syntax_checkers/ruby/rubocop.vim b/bundle/syntastic/syntax_checkers/ruby/rubocop.vim new file mode 100644 index 00000000..9570c4a7 --- /dev/null +++ b/bundle/syntastic/syntax_checkers/ruby/rubocop.vim @@ -0,0 +1,52 @@ +"============================================================================ +"File: rubocop.vim +"Description: Syntax checking plugin for syntastic.vim +"Maintainer: Recai Oktaş +"License: This program is free software. It comes without any warranty, +" to the extent permitted by applicable law. You can redistribute +" it and/or modify it under the terms of the Do What The Fuck You +" Want To Public License, Version 2, as published by Sam Hocevar. +" See http://sam.zoy.org/wtfpl/COPYING for more details. +" +"============================================================================ +" +" In order to use rubocop with the default ruby checker (mri): +" let g:syntastic_ruby_checkers = ['mri', 'rubocop'] + +if exists("g:loaded_syntastic_ruby_rubocop_checker") + finish +endif +let g:loaded_syntastic_ruby_rubocop_checker=1 + +function! SyntaxCheckers_ruby_rubocop_IsAvailable() + return executable('rubocop') +endfunction + +function! SyntaxCheckers_ruby_rubocop_GetLocList() + let makeprg = syntastic#makeprg#build({ + \ 'exe': 'rubocop', + \ 'args': '--emacs --silent', + \ 'subchecker': 'rubocop' }) + + let errorformat = '%f:%l:\ %t:\ %m' + + let loclist = SyntasticMake({ + \ 'makeprg': makeprg, + \ 'errorformat': errorformat, + \ 'subtype': 'Style'}) + + " convert rubocop severities to error types recognized by syntastic + for n in range(len(loclist)) + if loclist[n]['type'] == 'F' + let loclist[n]['type'] = 'E' + elseif loclist[n]['type'] != 'W' && loclist[n]['type'] != 'E' + let loclist[n]['type'] = 'W' + endif + endfor + + return loclist +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'ruby', + \ 'name': 'rubocop'}) diff --git a/bundle/syntastic/syntax_checkers/rust/rustc.vim b/bundle/syntastic/syntax_checkers/rust/rustc.vim new file mode 100644 index 00000000..28268b33 --- /dev/null +++ b/bundle/syntastic/syntax_checkers/rust/rustc.vim @@ -0,0 +1,39 @@ +"============================================================================ +"File: rust.vim +"Description: Syntax checking plugin for syntastic.vim +"Maintainer: Chad Jablonski +"License: This program is free software. It comes without any warranty, +" to the extent permitted by applicable law. You can redistribute +" it and/or modify it under the terms of the Do What The Fuck You +" Want To Public License, Version 2, as published by Sam Hocevar. +" See http://sam.zoy.org/wtfpl/COPYING for more details. +" +"============================================================================ + +if exists("g:loaded_syntastic_rust_rustc_checker") + finish +endif +let g:loaded_syntastic_rust_rustc_checker=1 + +function! SyntaxCheckers_rust_rustc_IsAvailable() + return executable("rustc") +endfunction + +function! SyntaxCheckers_rust_rustc_GetLocList() + let makeprg = syntastic#makeprg#build({ + \ 'exe': 'rustc', + \ 'args': '--parse-only', + \ 'subchecker': 'rustc' }) + + let errorformat = + \ '%E%f:%l:%c: \\d%#:\\d%# %.%\{-}error:%.%\{-} %m,' . + \ '%W%f:%l:%c: \\d%#:\\d%# %.%\{-}warning:%.%\{-} %m,' . + \ '%C%f:%l %m,' . + \ '%-Z%.%#' + + return SyntasticMake({ 'makeprg': makeprg, 'errorformat': errorformat }) +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'rust', + \ 'name': 'rustc'}) diff --git a/bundle/syntastic/syntax_checkers/sass/sass.vim b/bundle/syntastic/syntax_checkers/sass/sass.vim new file mode 100644 index 00000000..de99c617 --- /dev/null +++ b/bundle/syntastic/syntax_checkers/sass/sass.vim @@ -0,0 +1,58 @@ +"============================================================================ +"File: sass.vim +"Description: Syntax checking plugin for syntastic.vim +"Maintainer: Martin Grenfell +"License: This program is free software. It comes without any warranty, +" to the extent permitted by applicable law. You can redistribute +" it and/or modify it under the terms of the Do What The Fuck You +" Want To Public License, Version 2, as published by Sam Hocevar. +" See http://sam.zoy.org/wtfpl/COPYING for more details. +" +"============================================================================ + +if exists("g:loaded_syntastic_sass_sass_checker") + finish +endif +let g:loaded_syntastic_sass_sass_checker=1 + +function! SyntaxCheckers_sass_sass_IsAvailable() + return executable("sass") +endfunction + +"sass caching for large files drastically speeds up the checking, but store it +"in a temp location otherwise sass puts .sass_cache dirs in the users project +let s:sass_cache_location = tempname() + +"By default do not check partials as unknown variables are a syntax error +if !exists("g:syntastic_sass_check_partials") + let g:syntastic_sass_check_partials = 0 +endif + +"use compass imports if available +let s:imports = "" +if executable("compass") + let s:imports = "--compass" +endif + +function! SyntaxCheckers_sass_sass_GetLocList() + if !g:syntastic_sass_check_partials && expand('%:t')[0] == '_' + return [] + end + let makeprg = syntastic#makeprg#build({ + \ 'exe': 'sass', + \ 'args': '--cache-location ' . s:sass_cache_location . ' ' . s:imports . ' --check', + \ 'subchecker': 'sass' }) + let errorformat = + \ '%ESyntax %trror:%m,' . + \ '%C on line %l of %f,' . + \ '%Z%.%#,' . + \ '%Wwarning on line %l:,' . + \ '%Z%m,' . + \ 'Syntax %trror on line %l: %m' + + return SyntasticMake({ 'makeprg': makeprg, 'errorformat': errorformat }) +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'sass', + \ 'name': 'sass'}) diff --git a/bundle/syntastic/syntax_checkers/scala/scalac.vim b/bundle/syntastic/syntax_checkers/scala/scalac.vim new file mode 100644 index 00000000..a2394c10 --- /dev/null +++ b/bundle/syntastic/syntax_checkers/scala/scalac.vim @@ -0,0 +1,40 @@ +"============================================================================ +"File: scala.vim +"Description: Syntax checking plugin for syntastic.vim +"Maintainer: Rickey Visinski +"License: This program is free software. It comes without any warranty, +" to the extent permitted by applicable law. You can redistribute +" it and/or modify it under the terms of the Do What The Fuck You +" Want To Public License, Version 2, as published by Sam Hocevar. +" See http://sam.zoy.org/wtfpl/COPYING for more details. +" +"============================================================================ + +if exists("g:loaded_syntastic_scala_scalac_checker") + finish +endif +let g:loaded_syntastic_scala_scalac_checker=1 + +function! SyntaxCheckers_scala_scalac_IsAvailable() + return executable("scalac") +endfunction + +if !exists("g:syntastic_scala_options") + let g:syntastic_scala_options = " " +endif + + +function! SyntaxCheckers_scala_scalac_GetLocList() + let makeprg = syntastic#makeprg#build({ + \ 'exe': 'scalac', + \ 'args': '-Ystop-after:parser '. g:syntastic_scala_options, + \ 'subchecker': 'scalac' }) + + let errorformat = '%f\:%l: %trror: %m' + + return SyntasticMake({ 'makeprg': makeprg, 'errorformat': errorformat }) +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'scala', + \ 'name': 'scalac'}) diff --git a/bundle/syntastic/syntax_checkers/scss/sass.vim b/bundle/syntastic/syntax_checkers/scss/sass.vim new file mode 100644 index 00000000..9ded9ed3 --- /dev/null +++ b/bundle/syntastic/syntax_checkers/scss/sass.vim @@ -0,0 +1,31 @@ + +"============================================================================ +"File: scss.vim +"Description: scss syntax checking plugin for syntastic +"Maintainer: Martin Grenfell +"License: This program is free software. It comes without any warranty, +" to the extent permitted by applicable law. You can redistribute +" it and/or modify it under the terms of the Do What The Fuck You +" Want To Public License, Version 2, as published by Sam Hocevar. +" See http://sam.zoy.org/wtfpl/COPYING for more details. +" +"============================================================================ + +if exists("g:loaded_syntastic_scss_sass_checker") + finish +endif +let g:loaded_syntastic_scss_sass_checker=1 + +runtime syntax_checkers/sass/sass.vim + +function! SyntaxCheckers_scss_sass_IsAvailable() + return SyntaxCheckers_sass_sass_IsAvailable() +endfunction + +function! SyntaxCheckers_scss_sass_GetLocList() + return SyntaxCheckers_sass_sass_GetLocList() +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'scss', + \ 'name': 'sass'}) diff --git a/bundle/syntastic/syntax_checkers/sh/checkbashisms.vim b/bundle/syntastic/syntax_checkers/sh/checkbashisms.vim new file mode 100644 index 00000000..744b0006 --- /dev/null +++ b/bundle/syntastic/syntax_checkers/sh/checkbashisms.vim @@ -0,0 +1,41 @@ +"============================================================================ +"File: checkbashisms.vim +"Description: Shell script syntax/style checking plugin for syntastic.vim +"Notes: checkbashisms.pl can be downloaded from +" http://debian.inode.at/debian/pool/main/d/devscripts/ +" as part of the devscripts package. +"============================================================================ + +if exists("g:loaded_syntastic_sh_checkbashisms_checker") + finish +endif +let g:loaded_syntastic_sh_checkbashisms_checker=1 + + +function! SyntaxCheckers_sh_checkbashisms_IsAvailable() + return executable('checkbashisms') +endfunction + + +function! SyntaxCheckers_sh_checkbashisms_GetLocList() + let makeprg = syntastic#makeprg#build({ + \ 'exe': 'checkbashisms', + \ 'args': '-fpx', + \ 'subchecker': 'checkbashisms'}) + + let errorformat = + \ '%-Gscript %f is already a bash script; skipping,' . + \ '%Eerror: %f: %m\, opened in line %l,' . + \ '%Eerror: %f: %m,' . + \ '%Ecannot open script %f for reading: %m,' . + \ '%Wscript %f %m,%C%.# lines,' . + \ '%Wpossible bashism in %f line %l (%m):,%C%.%#,%Z.%#,' . + \ '%-G%.%#' + + return SyntasticMake({'makeprg': makeprg, 'errorformat': errorformat, 'subtype': 'Style'}) +endfunction + + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'sh', + \ 'name': 'checkbashisms'}) diff --git a/bundle/syntastic/syntax_checkers/sh/sh.vim b/bundle/syntastic/syntax_checkers/sh/sh.vim new file mode 100644 index 00000000..55b841e7 --- /dev/null +++ b/bundle/syntastic/syntax_checkers/sh/sh.vim @@ -0,0 +1,79 @@ +"============================================================================ +"File: sh.vim +"Description: Syntax checking plugin for syntastic.vim +"Maintainer: Gregor Uhlenheuer +"License: This program is free software. It comes without any warranty, +" to the extent permitted by applicable law. You can redistribute +" it and/or modify it under the terms of the Do What The Fuck You +" Want To Public License, Version 2, as published by Sam Hocevar. +" See http://sam.zoy.org/wtfpl/COPYING for more details. +" +"============================================================================ + +if exists("g:loaded_syntastic_sh_sh_checker") + finish +endif +let g:loaded_syntastic_sh_sh_checker=1 + +function! s:GetShell() + if !exists('b:shell') || b:shell == '' + let b:shell = '' + let shebang = getbufline(bufnr('%'), 1)[0] + if len(shebang) > 0 + if match(shebang, 'bash') >= 0 + let b:shell = 'bash' + elseif match(shebang, 'zsh') >= 0 + let b:shell = 'zsh' + elseif match(shebang, 'sh') >= 0 + let b:shell = 'sh' + endif + endif + " try to use env variable in case no shebang could be found + if b:shell == '' + let b:shell = fnamemodify(expand('$SHELL'), ':t') + endif + endif + return b:shell +endfunction + +function! s:ForwardToZshChecker() + let registry = g:SyntasticRegistry.Instance() + if registry.checkable('zsh') + return SyntaxCheckers_zsh_zsh_GetLocList() + else + return [] + endif + +endfunction + + +function! s:IsShellValid() + return len(s:GetShell()) > 0 && executable(s:GetShell()) +endfunction + + +function! SyntaxCheckers_sh_sh_IsAvailable() + return s:IsShellValid() +endfunction + +function! SyntaxCheckers_sh_sh_GetLocList() + if s:GetShell() == 'zsh' + return s:ForwardToZshChecker() + endif + + if !s:IsShellValid() + return [] + endif + + let makeprg = syntastic#makeprg#build({ + \ 'exe': s:GetShell(), + \ 'args': '-n', + \ 'subchecker': 'sh'}) + + let errorformat = '%f: line %l: %m' + return SyntasticMake({ 'makeprg': makeprg, 'errorformat': errorformat}) +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'sh', + \ 'name': 'sh'}) diff --git a/bundle/syntastic/syntax_checkers/slim/slimrb.vim b/bundle/syntastic/syntax_checkers/slim/slimrb.vim new file mode 100644 index 00000000..d9c5849b --- /dev/null +++ b/bundle/syntastic/syntax_checkers/slim/slimrb.vim @@ -0,0 +1,55 @@ +"============================================================================ +"File: slim.vim +"Description: Syntax checking plugin for syntastic.vim +"Maintainer: Martin Grenfell +"License: This program is free software. It comes without any warranty, +" to the extent permitted by applicable law. You can redistribute +" it and/or modify it under the terms of the Do What The Fuck You +" Want To Public License, Version 2, as published by Sam Hocevar. +" See http://sam.zoy.org/wtfpl/COPYING for more details. +" +"============================================================================ + +if exists("g:loaded_syntastic_slim_slimrb_checker") + finish +endif +let g:loaded_syntastic_slim_slimrb_checker=1 + +function! SyntaxCheckers_slim_slimrb_IsAvailable() + return executable("slimrb") +endfunction + +function! s:SlimrbVersion() + if !exists('s:slimrb_version') + let output = system("slimrb --version 2>/dev/null") + let output = substitute(output, '\n$', '', '') + let output = substitute(output, '^slim ', '', 'i') + let s:slimrb_version = split(output, '\.') + end + return s:slimrb_version +endfunction + +function! SyntaxCheckers_slim_slimrb_GetLocList() + let makeprg = syntastic#makeprg#build({ + \ 'exe': 'slimrb', + \ 'args': '-c', + \ 'subchecker': 'slimrb' }) + if syntastic#util#versionIsAtLeast(s:SlimrbVersion(), [1,3,1]) + let errorformat = + \ '%C\ %#%f\, Line %l\, Column %c,'. + \ '%-G\ %.%#,'. + \ '%ESlim::Parser::SyntaxError: %m,'. + \ '%+C%.%#' + else + let errorformat = + \ '%C\ %#%f\, Line %l,'. + \ '%-G\ %.%#,'. + \ '%ESlim::Parser::SyntaxError: %m,'. + \ '%+C%.%#' + endif + return SyntasticMake({ 'makeprg': makeprg, 'errorformat': errorformat }) +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'slim', + \ 'name': 'slimrb'}) diff --git a/bundle/syntastic/syntax_checkers/tcl/nagelfar.vim b/bundle/syntastic/syntax_checkers/tcl/nagelfar.vim new file mode 100644 index 00000000..046120ac --- /dev/null +++ b/bundle/syntastic/syntax_checkers/tcl/nagelfar.vim @@ -0,0 +1,38 @@ +"============================================================================ +"File: nagelfar.vim +"Description: Syntax checking plugin for syntastic.vim +"Maintainer: James Pickard +"License: This program is free software. It comes without any warranty, +" to the extent permitted by applicable law. You can redistribute +" it and/or modify it under the terms of the Do What The Fuck You +" Want To Public License, Version 2, as published by Sam Hocevar. +" See http://sam.zoy.org/wtfpl/COPYING for more details. +"Notes: Requires nagelfar v1.1.12 or later with support for -H option. +" See nagelfar homepage http://nagelfar.berlios.de/. +" +"============================================================================ +if exists("g:loaded_syntastic_tcl_nagelfar_checker") + finish +endif +let g:loaded_syntastic_tcl_nagelfar_checker=1 + +function! SyntaxCheckers_tcl_nagelfar_IsAvailable() + return executable('nagelfar') +endfunction + +function! SyntaxCheckers_tcl_nagelfar_GetLocList() + let makeprg = syntastic#makeprg#build({ + \ 'exe': 'nagelfar', + \ 'args': '-H ' . g:syntastic_tcl_nagelfar_conf, + \ 'subchecker': 'nagelfar' }) + let errorformat = + \ '%I%f: %l: N %m,'. + \ '%f: %l: %t %m,'. + \ '%-GChecking file %f' + + return SyntasticMake({ 'makeprg': makeprg, 'errorformat': errorformat }) +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'tcl', + \ 'name': 'nagelfar'}) diff --git a/bundle/syntastic/syntax_checkers/tex/chktex.vim b/bundle/syntastic/syntax_checkers/tex/chktex.vim new file mode 100644 index 00000000..d0fb30cb --- /dev/null +++ b/bundle/syntastic/syntax_checkers/tex/chktex.vim @@ -0,0 +1,61 @@ +"============================================================================ +"File: chktex.vim +"Description: Syntax checking plugin for syntastic.vim +"Maintainer: LCD 47 +"License: This program is free software. It comes without any warranty, +" to the extent permitted by applicable law. You can redistribute +" it and/or modify it under the terms of the Do What The Fuck You +" Want To Public License, Version 2, as published by Sam Hocevar. +" See http://sam.zoy.org/wtfpl/COPYING for more details. +" +"============================================================================ +" +" For details about ChkTeX see: +" +" http://baruch.ev-en.org/proj/chktex/ +" +" Checker options: +" +" - g:syntastic_tex_chktex_showmsgs (boolean; default: 1) +" whether to show informational messages (chktex option "-m"); +" by default informational messages are shown as warnings +" +" - g:syntastic_tex_chktex_args (string; default: empty) +" command line options to pass to chktex + +if exists("g:loaded_syntastic_tex_chktex_checker") + finish +endif +let g:loaded_syntastic_tex_chktex_checker = 1 + +if !exists('g:syntastic_tex_chktex_showmsgs') + let g:syntastic_tex_chktex_showmsgs = 1 +endif + +function! SyntaxCheckers_tex_chktex_IsAvailable() + return executable("chktex") +endfunction + +function! SyntaxCheckers_tex_chktex_GetLocList() + let makeprg = syntastic#makeprg#build({ + \ 'exe': 'chktex', + \ 'post_args': '-q -v1', + \ 'subchecker': 'chktex' }) + + let errorformat = + \ '%EError\ %\\d%\\+\ in\ %f\ line\ %l:\ %m,' . + \ '%WWarning\ %\\d%\\+\ in\ %f\ line\ %l:\ %m,' . + \ (g:syntastic_tex_chktex_showmsgs ? '%WMessage\ %\\d%\\+\ in\ %f\ line %l:\ %m,' : '') . + \ '%+Z%p^,' . + \ '%-G%.%#' + + return SyntasticMake({ + \ 'makeprg': makeprg, + \ 'errorformat': errorformat, + \ 'subtype': 'Style', + \ 'postprocess': ['sort'] }) +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'tex', + \ 'name': 'chktex'}) diff --git a/bundle/syntastic/syntax_checkers/tex/lacheck.vim b/bundle/syntastic/syntax_checkers/tex/lacheck.vim new file mode 100644 index 00000000..a8d8d6bf --- /dev/null +++ b/bundle/syntastic/syntax_checkers/tex/lacheck.vim @@ -0,0 +1,30 @@ +"============================================================================ +"File: tex.vim +"Description: Syntax checking plugin for syntastic.vim +"Maintainer: Martin Grenfell +"License: This program is free software. It comes without any warranty, +" to the extent permitted by applicable law. You can redistribute +" it and/or modify it under the terms of the Do What The Fuck You +" Want To Public License, Version 2, as published by Sam Hocevar. +" See http://sam.zoy.org/wtfpl/COPYING for more details. +" +"============================================================================ + +if exists("g:loaded_syntastic_tex_lacheck_checker") + finish +endif +let g:loaded_syntastic_tex_lacheck_checker=1 + +function! SyntaxCheckers_tex_lacheck_IsAvailable() + return executable("lacheck") +endfunction + +function! SyntaxCheckers_tex_lacheck_GetLocList() + let makeprg = syntastic#makeprg#build({ 'exe': 'lacheck', 'subchecker': 'lacheck' }) + let errorformat = '%-G** %f:,%E"%f"\, line %l: %m' + return SyntasticMake({ 'makeprg': makeprg, 'errorformat': errorformat }) +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'tex', + \ 'name': 'lacheck'}) diff --git a/bundle/syntastic/syntax_checkers/twig/twiglint.vim b/bundle/syntastic/syntax_checkers/twig/twiglint.vim new file mode 100644 index 00000000..919ec48b --- /dev/null +++ b/bundle/syntastic/syntax_checkers/twig/twiglint.vim @@ -0,0 +1,39 @@ +"============================================================================ +"File: twig.vim +"Description: Syntax checking plugin for syntastic.vim +"Maintainer: Alexander +"License: This program is free software. It comes without any warranty, +" to the extent permitted by applicable law. You can redistribute +" it and/or modify it under the terms of the Do What The Fuck You +" Want To Public License, Version 2, as published by Sam Hocevar. +" See http://sam.zoy.org/wtfpl/COPYING for more details. +" +"============================================================================ + +if exists("g:loaded_syntastic_twig_twiglint_checker") + finish +endif +let g:loaded_syntastic_twig_twiglint_checker=1 + +function! SyntaxCheckers_twig_twiglint_GetHighlightRegex(item) + " Let's match the full line for now + return '\V' +endfunction + +function! SyntaxCheckers_twig_twiglint_IsAvailable() + return executable('twig-lint') +endfunction + +function! SyntaxCheckers_twig_twiglint_GetLocList() + let makeprg = syntastic#makeprg#build({ + \ 'exe': 'twig-lint', + \ 'args': 'lint --format=csv', + \ 'subchecker': 'twiglint' }) + + let errorformat = '"%f"\,%l\,%m' + return SyntasticMake({ 'makeprg': makeprg, 'errorformat': errorformat}) +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'twig', + \ 'name': 'twiglint'}) diff --git a/bundle/syntastic/syntax_checkers/typescript/tsc.vim b/bundle/syntastic/syntax_checkers/typescript/tsc.vim new file mode 100644 index 00000000..a3279c36 --- /dev/null +++ b/bundle/syntastic/syntax_checkers/typescript/tsc.vim @@ -0,0 +1,28 @@ +"============================================================================ +"File: typescript.vim +"Description: TypeScript syntax checker. For TypeScript v0.8.0 +"Maintainer: Bill Casarin +"============================================================================ + +if exists("g:loaded_syntastic_typescript_tsc_checker") + finish +endif +let g:loaded_syntastic_typescript_tsc_checker=1 + +function! SyntaxCheckers_typescript_tsc_IsAvailable() + return executable("tsc") +endfunction + + +function! SyntaxCheckers_typescript_tsc_GetLocList() + let makeprg = syntastic#makeprg#build({ + \ 'exe': 'tsc', + \ 'post_args': '--out ' . syntastic#util#DevNull(), + \ 'subchecker': 'tsc' }) + let errorformat = '%f %#(%l\,%c): %m' + return SyntasticMake({ 'makeprg': makeprg, 'errorformat': errorformat }) +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'typescript', + \ 'name': 'tsc'}) diff --git a/bundle/syntastic/syntax_checkers/vala/valac.vim b/bundle/syntastic/syntax_checkers/vala/valac.vim new file mode 100644 index 00000000..a7457235 --- /dev/null +++ b/bundle/syntastic/syntax_checkers/vala/valac.vim @@ -0,0 +1,67 @@ +"============================================================================ +"File: vala.vim +"Description: Syntax checking plugin for syntastic.vim +"Maintainer: Konstantin Stepanov (me@kstep.me) +"Notes: Add special comment line into your vala file starting with +" "// modules: " and containing space delimited list of vala +" modules, used by the file, so this script can build correct +" --pkg arguments. +" Alternatively you can set g:syntastic_vala_modules array +" in your .vimrc or .lvimrc with localvimrc plugin +" (http://www.vim.org/scripts/script.php?script_id=441). +" Valac compiler is not the fastest thing in the world, so you +" may want to disable this plugin with +" let g:syntastic_vala_check_disabled = 1 command in your .vimrc or +" command line. Unlet this variable to set it to 0 to reenable +" this checker. +"License: This program is free software. It comes without any warranty, +" to the extent permitted by applicable law. You can redistribute +" it and/or modify it under the terms of the Do What The Fuck You +" Want To Public License, Version 2, as published by Sam Hocevar. +" See http://sam.zoy.org/wtfpl/COPYING for more details. +" +"============================================================================ + +function! SyntaxCheckers_vala_valac_IsAvailable() + return executable('valac') +endfunction + +function! SyntaxCheckers_vala_valac_GetHighlightRegex(pos) + let strlength = strlen(matchstr(a:pos['text'], '\^\+$')) + return '\%>'.(a:pos.col-1).'c.*\%<'.(a:pos.col+strlength+1).'c' +endfunction + +function! s:GetValaModules() + if exists('g:syntastic_vala_modules') + if type(g:syntastic_vala_modules) == type('') + return split(g:syntastic_vala_modules, '\s\+') + elseif type(g:syntastic_vala_modules) == type([]) + return copy(g:syntastic_vala_modules) + else + echoerr 'g:syntastic_vala_modules must be either list or string: fallback to in file modules string' + endif + endif + + let modules_line = search('^// modules: ', 'n') + let modules_str = getline(modules_line) + return split(strpart(modules_str, 12), '\s\+') +endfunction + +function! SyntaxCheckers_vala_valac_GetLocList() + let vala_pkg_args = join(map(s:GetValaModules(), '"--pkg ".v:val'), ' ') + let makeprg = syntastic#makeprg#build({ + \ 'exe': 'valac', + \ 'args': '-C ' . vala_pkg_args, + \ 'subchecker': 'valac' }) + let errorformat = + \ '%A%f:%l.%c-%\d%\+.%\d%\+: %t%[a-z]%\+: %m,'. + \ '%C%m,'. + \ '%Z%m' + + return SyntasticMake({ 'makeprg': makeprg, + \ 'errorformat': errorformat }) +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'vala', + \ 'name': 'valac'}) diff --git a/bundle/syntastic/syntax_checkers/vhdl/ghdl.vim b/bundle/syntastic/syntax_checkers/vhdl/ghdl.vim new file mode 100644 index 00000000..57faa9de --- /dev/null +++ b/bundle/syntastic/syntax_checkers/vhdl/ghdl.vim @@ -0,0 +1,33 @@ +"============================================================================ +"File: ghdl.vim +"Description: Syntax checking plugin for syntastic.vim +"Maintainer: Jan Wagner +"License: This program is free software. It comes without any warranty, +" to the extent permitted by applicable law. You can redistribute +" it and/or modify it under the terms of the Do What The Fuck You +" Want To Public License, Version 2, as published by Sam Hocevar. +" See http://sam.zoy.org/wtfpl/COPYING for more details. +" +"============================================================================ +if exists("loaded_vhdl_ghdl_syntax_checker") + finish +endif +let loaded_vhdl_ghdl_syntax_checker = 1 + +function! SyntaxCheckers_vhdl_ghdl_IsAvailable() + return executable("ghdl") +endfunction + +function! SyntaxCheckers_vhdl_ghdl_GetLocList() + let makeprg = syntastic#makeprg#build({ + \ 'exe': 'ghdl', + \ 'args': '-s', + \ 'subchecker': 'ghdl' }) + let errorformat = '%f:%l:%c: %m' + + return SyntasticMake({ 'makeprg': makeprg, 'errorformat': errorformat }) +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'vhdl', + \ 'name': 'ghdl'}) diff --git a/bundle/syntastic/syntax_checkers/xhtml/tidy.vim b/bundle/syntastic/syntax_checkers/xhtml/tidy.vim new file mode 100644 index 00000000..2983866a --- /dev/null +++ b/bundle/syntastic/syntax_checkers/xhtml/tidy.vim @@ -0,0 +1,82 @@ +"============================================================================ +"File: xhtml.vim +"Description: Syntax checking plugin for syntastic.vim +"Maintainer: Martin Grenfell +"License: This program is free software. It comes without any warranty, +" to the extent permitted by applicable law. You can redistribute +" it and/or modify it under the terms of the Do What The Fuck You +" Want To Public License, Version 2, as published by Sam Hocevar. +" See http://sam.zoy.org/wtfpl/COPYING for more details. +" +"============================================================================ +" +" Checker option: +" +" - g:syntastic_xhtml_tidy_ignore_errors (list; default: []) +" list of errors to ignore + +if exists("g:loaded_syntastic_xhtml_tidy_checker") + finish +endif +let g:loaded_syntastic_xhtml_tidy_checker=1 + +if !exists('g:syntastic_xhtml_tidy_ignore_errors') + let g:syntastic_xhtml_tidy_ignore_errors = [] +endif + +function! SyntaxCheckers_xhtml_tidy_IsAvailable() + return executable("tidy") +endfunction + +" TODO: join this with html.vim DRY's sake? +function! s:TidyEncOptByFenc() + let tidy_opts = { + \'utf-8' : '-utf8', + \'ascii' : '-ascii', + \'latin1' : '-latin1', + \'iso-2022-jp' : '-iso-2022', + \'cp1252' : '-win1252', + \'macroman' : '-mac', + \'utf-16le' : '-utf16le', + \'utf-16' : '-utf16', + \'big5' : '-big5', + \'cp932' : '-shiftjis', + \'sjis' : '-shiftjis', + \'cp850' : '-ibm858', + \} + return get(tidy_opts, &fileencoding, '-utf8') +endfunction + +function! s:IgnoreErrror(text) + for i in g:syntastic_xhtml_tidy_ignore_errors + if stridx(a:text, i) != -1 + return 1 + endif + endfor + return 0 +endfunction + +function! SyntaxCheckers_xhtml_tidy_GetLocList() + let encopt = s:TidyEncOptByFenc() + let makeprg = syntastic#makeprg#build({ + \ 'exe': 'tidy', + \ 'args': encopt . ' -xml -e', + \ 'subchecker': 'tidy' }) + let errorformat= + \ '%Wline %l column %v - Warning: %m,' . + \ '%Eline %l column %v - Error: %m,' . + \ '%-G%.%#' + let loclist = SyntasticMake({ 'makeprg': makeprg, 'errorformat': errorformat, 'defaults': {'bufnr': bufnr("")} }) + + for n in range(len(loclist)) + if loclist[n]['valid'] && s:IgnoreErrror(loclist[n]['text']) == 1 + let loclist[n]['valid'] = 0 + endif + endfor + + return loclist +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'xhtml', + \ 'name': 'tidy'}) diff --git a/bundle/syntastic/syntax_checkers/xml/xmllint.vim b/bundle/syntastic/syntax_checkers/xml/xmllint.vim new file mode 100644 index 00000000..b4439799 --- /dev/null +++ b/bundle/syntastic/syntax_checkers/xml/xmllint.vim @@ -0,0 +1,48 @@ +"============================================================================ +"File: xml.vim +"Description: Syntax checking plugin for syntastic.vim +"Maintainer: Sebastian Kusnier +"License: This program is free software. It comes without any warranty, +" to the extent permitted by applicable law. You can redistribute +" it and/or modify it under the terms of the Do What The Fuck You +" Want To Public License, Version 2, as published by Sam Hocevar. +" See http://sam.zoy.org/wtfpl/COPYING for more details. +" +"============================================================================ + +if exists("g:loaded_syntastic_xml_xmllint_checker") + finish +endif +let g:loaded_syntastic_xml_xmllint_checker=1 + +" You can use a local installation of DTDs to significantly speed up validation +" and allow you to validate XML data without network access, see xmlcatalog(1) +" and http://www.xmlsoft.org/catalog.html for more information. + +function! SyntaxCheckers_xml_xmllint_IsAvailable() + return executable('xmllint') +endfunction + +function! SyntaxCheckers_xml_xmllint_GetLocList() + let makeprg = syntastic#makeprg#build({ + \ 'exe': 'xmllint', + \ 'args': '--xinclude --noout --postvalid', + \ 'subchecker': 'xmllint' }) + let errorformat= + \ '%E%f:%l: error : %m,' . + \ '%-G%f:%l: validity error : Validation failed: no DTD found %m,' . + \ '%W%f:%l: warning : %m,' . + \ '%W%f:%l: validity warning : %m,' . + \ '%E%f:%l: validity error : %m,' . + \ '%E%f:%l: parser error : %m,' . + \ '%E%f:%l: %m,' . + \ '%-Z%p^,' . + \ '%-G%.%#' + let loclist = SyntasticMake({ 'makeprg': makeprg, 'errorformat': errorformat }) + + return loclist +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'xml', + \ 'name': 'xmllint'}) diff --git a/bundle/syntastic/syntax_checkers/xslt/xmllint.vim b/bundle/syntastic/syntax_checkers/xslt/xmllint.vim new file mode 100644 index 00000000..6a819a3c --- /dev/null +++ b/bundle/syntastic/syntax_checkers/xslt/xmllint.vim @@ -0,0 +1,30 @@ +"============================================================================ +"File: xslt.vim +"Description: Syntax checking plugin for syntastic.vim +"Maintainer: Sebastian Kusnier +"License: This program is free software. It comes without any warranty, +" to the extent permitted by applicable law. You can redistribute +" it and/or modify it under the terms of the Do What The Fuck You +" Want To Public License, Version 2, as published by Sam Hocevar. +" See http://sam.zoy.org/wtfpl/COPYING for more details. +" +"============================================================================ + +if exists("g:loaded_syntastic_xslt_xmllint_checker") + finish +endif +let g:loaded_syntastic_xslt_xmllint_checker=1 + +runtime syntax_checkers/xml/xmllint.vim + +function! SyntaxCheckers_xslt_xmllint_IsAvailable() + return SyntaxCheckers_xml_xmllint_IsAvailable() +endfunction + +function! SyntaxCheckers_xslt_xmllint_GetLocList() + return SyntaxCheckers_xml_xmllint_GetLocList() +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'xslt', + \ 'name': 'xmllint'}) diff --git a/bundle/syntastic/syntax_checkers/yaml/jsyaml.vim b/bundle/syntastic/syntax_checkers/yaml/jsyaml.vim new file mode 100644 index 00000000..bc91f1bb --- /dev/null +++ b/bundle/syntastic/syntax_checkers/yaml/jsyaml.vim @@ -0,0 +1,38 @@ +"============================================================================ +"File: yaml.vim +"Description: Syntax checking plugin for syntastic.vim +"Maintainer: Martin Grenfell +"License: This program is free software. It comes without any warranty, +" to the extent permitted by applicable law. You can redistribute +" it and/or modify it under the terms of the Do What The Fuck You +" Want To Public License, Version 2, as published by Sam Hocevar. +" See http://sam.zoy.org/wtfpl/COPYING for more details. +" +" +"Installation: $ npm install -g js-yaml +" +"============================================================================ + +if exists("g:loaded_syntastic_yaml_jsyaml_checker") + finish +endif +let g:loaded_syntastic_yaml_jsyaml_checker=1 + +function! SyntaxCheckers_yaml_jsyaml_IsAvailable() + return executable("js-yaml") +endfunction + +function! SyntaxCheckers_yaml_jsyaml_GetLocList() + let makeprg = syntastic#makeprg#build({ + \ 'exe': 'js-yaml', + \ 'args': '--compact', + \ 'subchecker': 'jsyaml' }) + let errorformat='Error on line %l\, col %c:%m,%-G%.%#' + return SyntasticMake({ 'makeprg': makeprg, + \ 'errorformat': errorformat, + \ 'defaults': {'bufnr': bufnr("")} }) +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'yaml', + \ 'name': 'jsyaml'}) diff --git a/bundle/syntastic/syntax_checkers/z80/z80syntaxchecker.vim b/bundle/syntastic/syntax_checkers/z80/z80syntaxchecker.vim new file mode 100644 index 00000000..bb8af00d --- /dev/null +++ b/bundle/syntastic/syntax_checkers/z80/z80syntaxchecker.vim @@ -0,0 +1,37 @@ +"============================================================================ +"File: z80.vim +"Description: Syntax checking plugin for syntastic.vim +"Maintainer: Romain Giot +"License: This program is free software. It comes without any warranty, +" to the extent permitted by applicable law. You can redistribute +" it and/or modify it under the terms of the Do What The Fuck You +" Want To Public License, Version 2, as published by Sam Hocevar. +" See http://sam.zoy.org/wtfpl/COPYING for more details. +" +"============================================================================ + +if exists("g:loaded_syntastic_z80_z80syntaxchecker_checker") + finish +endif +let g:loaded_syntastic_z80_z80syntaxchecker_checker=1 + +"bail if the user doesnt have z80_syntax_checker.py installed +"To obtain this application there are two solutions: +" - Install this python package: https://github.com/rgiot/pycpcdemotools +" - Copy/paste this script in your search path: https://raw.github.com/rgiot/pycpcdemotools/master/cpcdemotools/source_checker/z80_syntax_checker.py +function! SyntaxCheckers_z80_z80syntaxchecker_IsAvailable() + return executable("z80_syntax_checker.py") +endfunction + +function! SyntaxCheckers_z80_z80syntaxchecker_GetLocList() + let makeprg = syntastic#makeprg#build({ + \ 'exe': 'z80_syntax_checker.py', + \ 'subchecker': 'z80syntaxchecker' }) + let errorformat = '%f:%l %m' + let loclist = SyntasticMake({ 'makeprg': makeprg, 'errorformat': errorformat }) + return loclist +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'z80', + \ 'name': 'z80syntaxchecker'}) diff --git a/bundle/syntastic/syntax_checkers/zpt/zptlint.vim b/bundle/syntastic/syntax_checkers/zpt/zptlint.vim new file mode 100644 index 00000000..57390632 --- /dev/null +++ b/bundle/syntastic/syntax_checkers/zpt/zptlint.vim @@ -0,0 +1,43 @@ +"============================================================================ +"File: zpt.vim +"Description: Syntax checking plugin for syntastic.vim +"Maintainer: claytron +"License: This program is free software. It comes without any warranty, +" to the extent permitted by applicable law. You can redistribute +" it and/or modify it under the terms of the Do What The Fuck You +" Want To Public License, Version 2, as published by Sam Hocevar. +" See http://sam.zoy.org/wtfpl/COPYING for more details. +" +"============================================================================ + +if exists("g:loaded_syntastic_zpt_zptlint_checker") + finish +endif +let g:loaded_syntastic_zpt_zptlint_checker=1 + +" In order for this plugin to be useful, you will need to set up the +" zpt filetype in your vimrc +" +" " set up zope page templates as the zpt filetype +" au BufNewFile,BufRead *.pt,*.cpt,*.zpt set filetype=zpt syntax=xml +" +" Then install the zptlint program, found on pypi: +" http://pypi.python.org/pypi/zptlint + +function! SyntaxCheckers_zpt_zptlint_IsAvailable() + return executable("zptlint") +endfunction + +function! SyntaxCheckers_zpt_zptlint_GetLocList() + let makeprg = syntastic#makeprg#build({ 'exe': 'zptlint', 'subchecker': 'zptlint' }) + let errorformat= + \ '%-P*** Error in: %f,'. + \ '%Z%*\s\, at line %l\, column %c,'. + \ '%E%*\s%m,'. + \ '%-Q' + return SyntasticMake({ 'makeprg': makeprg, 'errorformat': errorformat }) +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'zpt', + \ 'name': 'zptlint'}) diff --git a/bundle/syntastic/syntax_checkers/zsh/zsh.vim b/bundle/syntastic/syntax_checkers/zsh/zsh.vim new file mode 100644 index 00000000..6cb776c5 --- /dev/null +++ b/bundle/syntastic/syntax_checkers/zsh/zsh.vim @@ -0,0 +1,33 @@ +"============================================================================ +"File: zsh.vim +"Description: Syntax checking plugin for syntastic.vim +"Maintainer: Martin Grenfell +"License: This program is free software. It comes without any warranty, +" to the extent permitted by applicable law. You can redistribute +" it and/or modify it under the terms of the Do What The Fuck You +" Want To Public License, Version 2, as published by Sam Hocevar. +" See http://sam.zoy.org/wtfpl/COPYING for more details. +" +"============================================================================ + +if exists("g:loaded_syntastic_zsh_zsh_checker") + finish +endif +let g:loaded_syntastic_zsh_zsh_checker=1 + +function! SyntaxCheckers_zsh_zsh_IsAvailable() + return executable("zsh") +endfunction + +function! SyntaxCheckers_zsh_zsh_GetLocList() + let makeprg = syntastic#makeprg#build({ + \ 'exe': 'zsh', + \ 'args': '-n', + \ 'subchecker': 'zsh' }) + let errorformat = '%f:%l: %m' + return SyntasticMake({ 'makeprg': makeprg, 'errorformat': errorformat}) +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'zsh', + \ 'name': 'zsh'}) diff --git a/doc/tags b/doc/tags index c8399e65..59657c15 100755 --- a/doc/tags +++ b/doc/tags @@ -30,6 +30,11 @@ .snippet snipMate.txt /*.snippet* .snippets snipMate.txt /*.snippets* :ColorSelect HTML.txt /*:ColorSelect* +:GraphvizCompile wmgraphviz.txt /*:GraphvizCompile* +:GraphvizCompileLaTeX wmgraphviz.txt /*:GraphvizCompileLaTeX* +:GraphvizCompilePDF wmgraphviz.txt /*:GraphvizCompilePDF* +:GraphvizCompilePS wmgraphviz.txt /*:GraphvizCompilePS* +:GraphvizView wmgraphviz.txt /*:GraphvizView* :HTMLmappings HTML.txt /*:HTMLmappings* :Mark mark.txt /*:Mark* :MarkClear mark.txt /*:MarkClear* @@ -66,6 +71,7 @@ CHANGE_LOG vimpress.txt /*CHANGE_LOG* COMMANDS vimpress.txt /*COMMANDS* CONFIGURE vimpress.txt /*CONFIGURE* +CoVim.txt CoVim.txt /*CoVim.txt* ConqueTerm conque_term.txt /*ConqueTerm* ConqueTerm_CWInsert conque_term.txt /*ConqueTerm_CWInsert* ConqueTerm_CloseOnEnd conque_term.txt /*ConqueTerm_CloseOnEnd* @@ -214,8 +220,20 @@ conque-term-usage conque_term.txt /*conque-term-usage* conque-term-windows conque_term.txt /*conque-term-windows* conque-term-write conque_term.txt /*conque-term-write* conque-term-writeln conque_term.txt /*conque-term-writeln* +covim CoVim.txt /*covim* +covim-about CoVim.txt /*covim-about* +covim-contents CoVim.txt /*covim-contents* +covim-intro CoVim.txt /*covim-intro* +covim-licence CoVim.txt /*covim-licence* +covim-usage CoVim.txt /*covim-usage* disable-HTML-macros HTML.txt /*disable-HTML-macros* disable-HTML-mappings HTML.txt /*disable-HTML-mappings* +g:WMGraphviz_dot wmgraphviz.txt /*g:WMGraphviz_dot* +g:WMGraphviz_output wmgraphviz.txt /*g:WMGraphviz_output* +g:WMGraphviz_shelloptions wmgraphviz.txt /*g:WMGraphviz_shelloptions* +g:WMGraphviz_tex2dot wmgraphviz.txt /*g:WMGraphviz_tex2dot* +g:WMGraphviz_tex2dotoptions wmgraphviz.txt /*g:WMGraphviz_tex2dotoptions* +g:WMGraphviz_viewer wmgraphviz.txt /*g:WMGraphviz_viewer* g:do_xhtml_mappings HTML.txt /*g:do_xhtml_mappings* g:force_html_menu HTML.txt /*g:force_html_menu* g:html_alinkcolor HTML.txt /*g:html_alinkcolor* @@ -884,6 +902,16 @@ v_html- HTML.txt /*v_html-* v_html-CTRL-I HTML.txt /*v_html-CTRL-I* v_html-tab HTML.txt /*v_html-tab* vimpress.txt vimpress.txt /*vimpress.txt* +wmgraphviz wmgraphviz.txt /*wmgraphviz* +wmgraphviz-commands wmgraphviz.txt /*wmgraphviz-commands* +wmgraphviz-contact wmgraphviz.txt /*wmgraphviz-contact* +wmgraphviz-dot2tex wmgraphviz.txt /*wmgraphviz-dot2tex* +wmgraphviz-mappings wmgraphviz.txt /*wmgraphviz-mappings* +wmgraphviz-omnicompletion wmgraphviz.txt /*wmgraphviz-omnicompletion* +wmgraphviz-requirements wmgraphviz.txt /*wmgraphviz-requirements* +wmgraphviz-settings wmgraphviz.txt /*wmgraphviz-settings* +wmgraphviz-snipmate wmgraphviz.txt /*wmgraphviz-snipmate* +wmgraphviz.txt wmgraphviz.txt /*wmgraphviz.txt* zencoding zencoding.txt /*zencoding* zencoding-balance-tag-inward zencoding.txt /*zencoding-balance-tag-inward* zencoding-balance-tag-outward zencoding.txt /*zencoding-balance-tag-outward*