From b0798e23f83334215075db4289eb1147c8ae550a Mon Sep 17 00:00:00 2001 From: bood Date: Sun, 18 Aug 2013 08:59:23 +0200 Subject: [PATCH] prefinal close --- sources_non_forked/bufexplorer/doc/tags | 24 - sources_non_forked/ctags | 1 - sources_non_forked/syntastic/.gitignore | 4 + sources_non_forked/syntastic/CONTRIBUTING.md | 49 ++ sources_non_forked/syntastic/LICENCE | 13 + sources_non_forked/syntastic/README.markdown | 174 +++++++ .../syntastic/_assets/screenshot_1.png | Bin 0 -> 92425 bytes .../syntastic/autoload/syntastic/c.vim | 239 +++++++++ .../syntastic/autoload/syntastic/makeprg.vim | 50 ++ .../autoload/syntastic/postprocess.vim | 71 +++ .../syntastic/autoload/syntastic/util.vim | 212 ++++++++ .../syntastic/doc/syntastic.txt | 468 ++++++++++++++++++ .../syntastic/plugin/syntastic.vim | 456 +++++++++++++++++ .../plugin/syntastic/autoloclist.vim | 38 ++ .../syntastic/plugin/syntastic/balloons.vim | 64 +++ .../syntastic/plugin/syntastic/checker.vim | 79 +++ .../syntastic/plugin/syntastic/cursor.vim | 63 +++ .../plugin/syntastic/highlighting.vim | 66 +++ .../syntastic/plugin/syntastic/loclist.vim | 184 +++++++ .../plugin/syntastic/makeprg_builder.vim | 72 +++ .../syntastic/plugin/syntastic/modemap.vim | 67 +++ .../syntastic/plugin/syntastic/notifiers.vim | 55 ++ .../syntastic/plugin/syntastic/registry.vim | 213 ++++++++ .../syntastic/plugin/syntastic/signs.vim | 149 ++++++ .../syntastic/syntax_checkers/ada/gcc.vim | 168 +++++++ .../applescript/osacompile.vim | 50 ++ .../syntax_checkers/asciidoc/asciidoc.vim | 47 ++ .../syntax_checkers/c/checkpatch.vim | 48 ++ .../syntastic/syntax_checkers/c/gcc.vim | 183 +++++++ .../syntastic/syntax_checkers/c/make.vim | 65 +++ .../syntastic/syntax_checkers/c/oclint.vim | 58 +++ .../syntastic/syntax_checkers/c/sparse.vim | 51 ++ .../syntastic/syntax_checkers/c/splint.vim | 57 +++ .../syntastic/syntax_checkers/c/ycm.vim | 32 ++ .../syntastic/syntax_checkers/co/coco.vim | 44 ++ .../syntax_checkers/coffee/coffee.vim | 48 ++ .../syntax_checkers/coffee/coffeelint.vim | 43 ++ .../syntastic/syntax_checkers/coq/coqtop.vim | 40 ++ .../syntastic/syntax_checkers/cpp/cpplint.vim | 65 +++ .../syntastic/syntax_checkers/cpp/gcc.vim | 179 +++++++ .../syntastic/syntax_checkers/cpp/oclint.vim | 36 ++ .../syntastic/syntax_checkers/cpp/ycm.vim | 34 ++ .../syntastic/syntax_checkers/cs/mcs.vim | 39 ++ .../syntastic/syntax_checkers/css/csslint.vim | 58 +++ .../syntastic/syntax_checkers/css/phpcs.vim | 33 ++ .../syntax_checkers/css/prettycss.vim | 62 +++ .../syntax_checkers/cucumber/cucumber.vim | 42 ++ .../syntastic/syntax_checkers/cuda/nvcc.vim | 72 +++ .../syntastic/syntax_checkers/d/dmd.vim | 177 +++++++ .../syntax_checkers/dart/dart_analyzer.vim | 66 +++ .../syntax_checkers/docbk/xmllint.vim | 30 ++ .../syntax_checkers/elixir/elixir.vim | 45 ++ .../syntax_checkers/erlang/erlang.vim | 51 ++ .../erlang/erlang_check_file.erl | 34 ++ .../syntastic/syntax_checkers/eruby/ruby.vim | 65 +++ .../syntax_checkers/fortran/gfortran.vim | 63 +++ .../syntastic/syntax_checkers/go/go.vim | 75 +++ .../syntastic/syntax_checkers/go/gofmt.vim | 42 ++ .../syntastic/syntax_checkers/go/golint.vim | 37 ++ .../syntastic/syntax_checkers/go/govet.vim | 40 ++ .../syntastic/syntax_checkers/haml/haml.vim | 45 ++ .../syntax_checkers/haskell/ghc-mod.vim | 46 ++ .../syntax_checkers/haskell/hdevtools.vim | 46 ++ .../syntax_checkers/haskell/hlint.vim | 36 ++ .../syntastic/syntax_checkers/haxe/haxe.vim | 52 ++ .../syntastic/syntax_checkers/hss/hss.vim | 38 ++ .../syntastic/syntax_checkers/html/tidy.vim | 174 +++++++ .../syntax_checkers/html/validator.vim | 97 ++++ .../syntastic/syntax_checkers/html/w3.vim | 65 +++ .../syntax_checkers/java/checkstyle.vim | 79 +++ .../syntastic/syntax_checkers/java/javac.vim | 366 ++++++++++++++ .../javascript/closurecompiler.vim | 66 +++ .../syntax_checkers/javascript/gjslint.vim | 46 ++ .../syntax_checkers/javascript/jshint.vim | 59 +++ .../syntax_checkers/javascript/jsl.vim | 56 +++ .../syntax_checkers/javascript/jslint.vim | 53 ++ .../syntax_checkers/json/jsonlint.vim | 43 ++ .../syntax_checkers/json/jsonval.vim | 40 ++ .../syntax_checkers/less/less-lint.coffee | 41 ++ .../syntax_checkers/less/less-lint.js | 57 +++ .../syntastic/syntax_checkers/less/lessc.vim | 61 +++ .../syntastic/syntax_checkers/lisp/clisp.vim | 47 ++ .../syntastic/syntax_checkers/llvm/llvm.vim | 38 ++ .../syntastic/syntax_checkers/lua/luac.vim | 64 +++ .../syntax_checkers/matlab/mlint.vim | 41 ++ .../syntastic/syntax_checkers/nasm/nasm.vim | 38 ++ .../syntax_checkers/nroff/mandoc.vim | 41 ++ .../syntastic/syntax_checkers/objc/gcc.vim | 184 +++++++ .../syntastic/syntax_checkers/objc/oclint.vim | 36 ++ .../syntastic/syntax_checkers/objc/ycm.vim | 34 ++ .../syntastic/syntax_checkers/objcpp/gcc.vim | 184 +++++++ .../syntax_checkers/objcpp/oclint.vim | 36 ++ .../syntastic/syntax_checkers/objcpp/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 | 65 +++ .../syntax_checkers/perl/podchecker.vim | 30 ++ .../syntastic/syntax_checkers/php/php.vim | 52 ++ .../syntastic/syntax_checkers/php/phpcs.vim | 44 ++ .../syntastic/syntax_checkers/php/phpmd.vim | 78 +++ .../syntax_checkers/pod/podchecker.vim | 51 ++ .../syntax_checkers/puppet/puppet.vim | 52 ++ .../syntax_checkers/puppet/puppetlint.vim | 47 ++ .../syntax_checkers/python/flake8.vim | 44 ++ .../syntax_checkers/python/pep257.vim | 50 ++ .../syntastic/syntax_checkers/python/pep8.vim | 46 ++ .../syntax_checkers/python/py3kwarn.vim | 31 ++ .../syntax_checkers/python/pyflakes.vim | 63 +++ .../syntax_checkers/python/pylama.vim | 67 +++ .../syntax_checkers/python/pylint.vim | 58 +++ .../syntax_checkers/python/python.vim | 43 ++ .../syntax_checkers/rst/rst2pseudoxml.vim | 62 +++ .../syntastic/syntax_checkers/ruby/jruby.vim | 52 ++ .../syntax_checkers/ruby/macruby.vim | 43 ++ .../syntastic/syntax_checkers/ruby/mri.vim | 77 +++ .../syntax_checkers/ruby/rubocop.vim | 55 ++ .../syntastic/syntax_checkers/rust/rustc.vim | 42 ++ .../syntastic/syntax_checkers/sass/sass.vim | 78 +++ .../syntastic/syntax_checkers/scala/fsc.vim | 46 ++ .../syntax_checkers/scala/scalac.vim | 43 ++ .../syntastic/syntax_checkers/scss/sass.vim | 31 ++ .../syntax_checkers/sh/checkbashisms.vim | 45 ++ .../syntastic/syntax_checkers/sh/sh.vim | 83 ++++ .../syntastic/syntax_checkers/slim/slimrb.vim | 57 +++ .../syntax_checkers/tcl/nagelfar.vim | 42 ++ .../syntastic/syntax_checkers/tex/chktex.vim | 62 +++ .../syntastic/syntax_checkers/tex/lacheck.vim | 39 ++ .../syntax_checkers/text/atdtool.vim | 57 +++ .../syntax_checkers/twig/twiglint.vim | 43 ++ .../syntax_checkers/typescript/tsc.vim | 40 ++ .../syntastic/syntax_checkers/vala/valac.vim | 74 +++ .../syntastic/syntax_checkers/vhdl/ghdl.vim | 37 ++ .../syntastic/syntax_checkers/xhtml/tidy.vim | 89 ++++ .../syntastic/syntax_checkers/xml/xmllint.vim | 52 ++ .../syntax_checkers/xslt/xmllint.vim | 30 ++ .../syntastic/syntax_checkers/yaml/jsyaml.vim | 42 ++ .../syntax_checkers/z80/z80syntaxchecker.vim | 41 ++ .../syntastic/syntax_checkers/zpt/zptlint.vim | 50 ++ .../syntastic/syntax_checkers/zsh/zsh.vim | 38 ++ sources_non_forked/taglist.vim/doc/tags | 62 --- sources_non_forked/vim-expand-region/doc/tags | 10 - .../vim-multiple-cursors/doc/tags | 21 - update_plugins.py | 9 +- 144 files changed, 10091 insertions(+), 121 deletions(-) delete mode 100644 sources_non_forked/bufexplorer/doc/tags delete mode 160000 sources_non_forked/ctags create mode 100644 sources_non_forked/syntastic/.gitignore create mode 100644 sources_non_forked/syntastic/CONTRIBUTING.md create mode 100644 sources_non_forked/syntastic/LICENCE create mode 100644 sources_non_forked/syntastic/README.markdown create mode 100644 sources_non_forked/syntastic/_assets/screenshot_1.png create mode 100644 sources_non_forked/syntastic/autoload/syntastic/c.vim create mode 100644 sources_non_forked/syntastic/autoload/syntastic/makeprg.vim create mode 100644 sources_non_forked/syntastic/autoload/syntastic/postprocess.vim create mode 100644 sources_non_forked/syntastic/autoload/syntastic/util.vim create mode 100644 sources_non_forked/syntastic/doc/syntastic.txt create mode 100644 sources_non_forked/syntastic/plugin/syntastic.vim create mode 100644 sources_non_forked/syntastic/plugin/syntastic/autoloclist.vim create mode 100644 sources_non_forked/syntastic/plugin/syntastic/balloons.vim create mode 100644 sources_non_forked/syntastic/plugin/syntastic/checker.vim create mode 100644 sources_non_forked/syntastic/plugin/syntastic/cursor.vim create mode 100644 sources_non_forked/syntastic/plugin/syntastic/highlighting.vim create mode 100644 sources_non_forked/syntastic/plugin/syntastic/loclist.vim create mode 100644 sources_non_forked/syntastic/plugin/syntastic/makeprg_builder.vim create mode 100644 sources_non_forked/syntastic/plugin/syntastic/modemap.vim create mode 100644 sources_non_forked/syntastic/plugin/syntastic/notifiers.vim create mode 100644 sources_non_forked/syntastic/plugin/syntastic/registry.vim create mode 100644 sources_non_forked/syntastic/plugin/syntastic/signs.vim create mode 100644 sources_non_forked/syntastic/syntax_checkers/ada/gcc.vim create mode 100644 sources_non_forked/syntastic/syntax_checkers/applescript/osacompile.vim create mode 100644 sources_non_forked/syntastic/syntax_checkers/asciidoc/asciidoc.vim create mode 100644 sources_non_forked/syntastic/syntax_checkers/c/checkpatch.vim create mode 100644 sources_non_forked/syntastic/syntax_checkers/c/gcc.vim create mode 100644 sources_non_forked/syntastic/syntax_checkers/c/make.vim create mode 100644 sources_non_forked/syntastic/syntax_checkers/c/oclint.vim create mode 100644 sources_non_forked/syntastic/syntax_checkers/c/sparse.vim create mode 100644 sources_non_forked/syntastic/syntax_checkers/c/splint.vim create mode 100644 sources_non_forked/syntastic/syntax_checkers/c/ycm.vim create mode 100644 sources_non_forked/syntastic/syntax_checkers/co/coco.vim create mode 100644 sources_non_forked/syntastic/syntax_checkers/coffee/coffee.vim create mode 100644 sources_non_forked/syntastic/syntax_checkers/coffee/coffeelint.vim create mode 100644 sources_non_forked/syntastic/syntax_checkers/coq/coqtop.vim create mode 100644 sources_non_forked/syntastic/syntax_checkers/cpp/cpplint.vim create mode 100644 sources_non_forked/syntastic/syntax_checkers/cpp/gcc.vim create mode 100644 sources_non_forked/syntastic/syntax_checkers/cpp/oclint.vim create mode 100644 sources_non_forked/syntastic/syntax_checkers/cpp/ycm.vim create mode 100644 sources_non_forked/syntastic/syntax_checkers/cs/mcs.vim create mode 100644 sources_non_forked/syntastic/syntax_checkers/css/csslint.vim create mode 100644 sources_non_forked/syntastic/syntax_checkers/css/phpcs.vim create mode 100644 sources_non_forked/syntastic/syntax_checkers/css/prettycss.vim create mode 100644 sources_non_forked/syntastic/syntax_checkers/cucumber/cucumber.vim create mode 100644 sources_non_forked/syntastic/syntax_checkers/cuda/nvcc.vim create mode 100644 sources_non_forked/syntastic/syntax_checkers/d/dmd.vim create mode 100644 sources_non_forked/syntastic/syntax_checkers/dart/dart_analyzer.vim create mode 100644 sources_non_forked/syntastic/syntax_checkers/docbk/xmllint.vim create mode 100644 sources_non_forked/syntastic/syntax_checkers/elixir/elixir.vim create mode 100644 sources_non_forked/syntastic/syntax_checkers/erlang/erlang.vim create mode 100644 sources_non_forked/syntastic/syntax_checkers/erlang/erlang_check_file.erl create mode 100644 sources_non_forked/syntastic/syntax_checkers/eruby/ruby.vim create mode 100644 sources_non_forked/syntastic/syntax_checkers/fortran/gfortran.vim create mode 100644 sources_non_forked/syntastic/syntax_checkers/go/go.vim create mode 100644 sources_non_forked/syntastic/syntax_checkers/go/gofmt.vim create mode 100644 sources_non_forked/syntastic/syntax_checkers/go/golint.vim create mode 100644 sources_non_forked/syntastic/syntax_checkers/go/govet.vim create mode 100644 sources_non_forked/syntastic/syntax_checkers/haml/haml.vim create mode 100644 sources_non_forked/syntastic/syntax_checkers/haskell/ghc-mod.vim create mode 100644 sources_non_forked/syntastic/syntax_checkers/haskell/hdevtools.vim create mode 100644 sources_non_forked/syntastic/syntax_checkers/haskell/hlint.vim create mode 100644 sources_non_forked/syntastic/syntax_checkers/haxe/haxe.vim create mode 100644 sources_non_forked/syntastic/syntax_checkers/hss/hss.vim create mode 100644 sources_non_forked/syntastic/syntax_checkers/html/tidy.vim create mode 100644 sources_non_forked/syntastic/syntax_checkers/html/validator.vim create mode 100644 sources_non_forked/syntastic/syntax_checkers/html/w3.vim create mode 100644 sources_non_forked/syntastic/syntax_checkers/java/checkstyle.vim create mode 100644 sources_non_forked/syntastic/syntax_checkers/java/javac.vim create mode 100644 sources_non_forked/syntastic/syntax_checkers/javascript/closurecompiler.vim create mode 100644 sources_non_forked/syntastic/syntax_checkers/javascript/gjslint.vim create mode 100644 sources_non_forked/syntastic/syntax_checkers/javascript/jshint.vim create mode 100644 sources_non_forked/syntastic/syntax_checkers/javascript/jsl.vim create mode 100644 sources_non_forked/syntastic/syntax_checkers/javascript/jslint.vim create mode 100644 sources_non_forked/syntastic/syntax_checkers/json/jsonlint.vim create mode 100644 sources_non_forked/syntastic/syntax_checkers/json/jsonval.vim create mode 100644 sources_non_forked/syntastic/syntax_checkers/less/less-lint.coffee create mode 100644 sources_non_forked/syntastic/syntax_checkers/less/less-lint.js create mode 100644 sources_non_forked/syntastic/syntax_checkers/less/lessc.vim create mode 100644 sources_non_forked/syntastic/syntax_checkers/lisp/clisp.vim create mode 100644 sources_non_forked/syntastic/syntax_checkers/llvm/llvm.vim create mode 100644 sources_non_forked/syntastic/syntax_checkers/lua/luac.vim create mode 100644 sources_non_forked/syntastic/syntax_checkers/matlab/mlint.vim create mode 100644 sources_non_forked/syntastic/syntax_checkers/nasm/nasm.vim create mode 100644 sources_non_forked/syntastic/syntax_checkers/nroff/mandoc.vim create mode 100644 sources_non_forked/syntastic/syntax_checkers/objc/gcc.vim create mode 100644 sources_non_forked/syntastic/syntax_checkers/objc/oclint.vim create mode 100644 sources_non_forked/syntastic/syntax_checkers/objc/ycm.vim create mode 100644 sources_non_forked/syntastic/syntax_checkers/objcpp/gcc.vim create mode 100644 sources_non_forked/syntastic/syntax_checkers/objcpp/oclint.vim create mode 100644 sources_non_forked/syntastic/syntax_checkers/objcpp/ycm.vim create mode 100644 sources_non_forked/syntastic/syntax_checkers/ocaml/camlp4o.vim create mode 100644 sources_non_forked/syntastic/syntax_checkers/perl/efm_perl.pl create mode 100644 sources_non_forked/syntastic/syntax_checkers/perl/perl.vim create mode 100644 sources_non_forked/syntastic/syntax_checkers/perl/perlcritic.vim create mode 100644 sources_non_forked/syntastic/syntax_checkers/perl/podchecker.vim create mode 100644 sources_non_forked/syntastic/syntax_checkers/php/php.vim create mode 100644 sources_non_forked/syntastic/syntax_checkers/php/phpcs.vim create mode 100644 sources_non_forked/syntastic/syntax_checkers/php/phpmd.vim create mode 100644 sources_non_forked/syntastic/syntax_checkers/pod/podchecker.vim create mode 100644 sources_non_forked/syntastic/syntax_checkers/puppet/puppet.vim create mode 100644 sources_non_forked/syntastic/syntax_checkers/puppet/puppetlint.vim create mode 100644 sources_non_forked/syntastic/syntax_checkers/python/flake8.vim create mode 100644 sources_non_forked/syntastic/syntax_checkers/python/pep257.vim create mode 100644 sources_non_forked/syntastic/syntax_checkers/python/pep8.vim create mode 100644 sources_non_forked/syntastic/syntax_checkers/python/py3kwarn.vim create mode 100644 sources_non_forked/syntastic/syntax_checkers/python/pyflakes.vim create mode 100644 sources_non_forked/syntastic/syntax_checkers/python/pylama.vim create mode 100644 sources_non_forked/syntastic/syntax_checkers/python/pylint.vim create mode 100644 sources_non_forked/syntastic/syntax_checkers/python/python.vim create mode 100644 sources_non_forked/syntastic/syntax_checkers/rst/rst2pseudoxml.vim create mode 100644 sources_non_forked/syntastic/syntax_checkers/ruby/jruby.vim create mode 100644 sources_non_forked/syntastic/syntax_checkers/ruby/macruby.vim create mode 100644 sources_non_forked/syntastic/syntax_checkers/ruby/mri.vim create mode 100644 sources_non_forked/syntastic/syntax_checkers/ruby/rubocop.vim create mode 100644 sources_non_forked/syntastic/syntax_checkers/rust/rustc.vim create mode 100644 sources_non_forked/syntastic/syntax_checkers/sass/sass.vim create mode 100644 sources_non_forked/syntastic/syntax_checkers/scala/fsc.vim create mode 100644 sources_non_forked/syntastic/syntax_checkers/scala/scalac.vim create mode 100644 sources_non_forked/syntastic/syntax_checkers/scss/sass.vim create mode 100644 sources_non_forked/syntastic/syntax_checkers/sh/checkbashisms.vim create mode 100644 sources_non_forked/syntastic/syntax_checkers/sh/sh.vim create mode 100644 sources_non_forked/syntastic/syntax_checkers/slim/slimrb.vim create mode 100644 sources_non_forked/syntastic/syntax_checkers/tcl/nagelfar.vim create mode 100644 sources_non_forked/syntastic/syntax_checkers/tex/chktex.vim create mode 100644 sources_non_forked/syntastic/syntax_checkers/tex/lacheck.vim create mode 100644 sources_non_forked/syntastic/syntax_checkers/text/atdtool.vim create mode 100644 sources_non_forked/syntastic/syntax_checkers/twig/twiglint.vim create mode 100644 sources_non_forked/syntastic/syntax_checkers/typescript/tsc.vim create mode 100644 sources_non_forked/syntastic/syntax_checkers/vala/valac.vim create mode 100644 sources_non_forked/syntastic/syntax_checkers/vhdl/ghdl.vim create mode 100644 sources_non_forked/syntastic/syntax_checkers/xhtml/tidy.vim create mode 100644 sources_non_forked/syntastic/syntax_checkers/xml/xmllint.vim create mode 100644 sources_non_forked/syntastic/syntax_checkers/xslt/xmllint.vim create mode 100644 sources_non_forked/syntastic/syntax_checkers/yaml/jsyaml.vim create mode 100644 sources_non_forked/syntastic/syntax_checkers/z80/z80syntaxchecker.vim create mode 100644 sources_non_forked/syntastic/syntax_checkers/zpt/zptlint.vim create mode 100644 sources_non_forked/syntastic/syntax_checkers/zsh/zsh.vim delete mode 100644 sources_non_forked/taglist.vim/doc/tags delete mode 100644 sources_non_forked/vim-expand-region/doc/tags delete mode 100644 sources_non_forked/vim-multiple-cursors/doc/tags diff --git a/sources_non_forked/bufexplorer/doc/tags b/sources_non_forked/bufexplorer/doc/tags deleted file mode 100644 index 5432bc98..00000000 --- a/sources_non_forked/bufexplorer/doc/tags +++ /dev/null @@ -1,24 +0,0 @@ -bufexplorer bufexplorer.txt /*bufexplorer* -bufexplorer-changelog bufexplorer.txt /*bufexplorer-changelog* -bufexplorer-credits bufexplorer.txt /*bufexplorer-credits* -bufexplorer-customization bufexplorer.txt /*bufexplorer-customization* -bufexplorer-installation bufexplorer.txt /*bufexplorer-installation* -bufexplorer-todo bufexplorer.txt /*bufexplorer-todo* -bufexplorer-usage bufexplorer.txt /*bufexplorer-usage* -bufexplorer-windowlayout bufexplorer.txt /*bufexplorer-windowlayout* -bufexplorer.txt bufexplorer.txt /*bufexplorer.txt* -buffer-explorer bufexplorer.txt /*buffer-explorer* -g:bufExplorerChgWin bufexplorer.txt /*g:bufExplorerChgWin* -g:bufExplorerDefaultHelp bufexplorer.txt /*g:bufExplorerDefaultHelp* -g:bufExplorerDetailedHelp bufexplorer.txt /*g:bufExplorerDetailedHelp* -g:bufExplorerFindActive bufexplorer.txt /*g:bufExplorerFindActive* -g:bufExplorerFuncRef bufexplorer.txt /*g:bufExplorerFuncRef* -g:bufExplorerReverseSort bufexplorer.txt /*g:bufExplorerReverseSort* -g:bufExplorerShowDirectories bufexplorer.txt /*g:bufExplorerShowDirectories* -g:bufExplorerShowRelativePath bufexplorer.txt /*g:bufExplorerShowRelativePath* -g:bufExplorerShowTabBuffer bufexplorer.txt /*g:bufExplorerShowTabBuffer* -g:bufExplorerShowUnlisted bufexplorer.txt /*g:bufExplorerShowUnlisted* -g:bufExplorerSortBy bufexplorer.txt /*g:bufExplorerSortBy* -g:bufExplorerSplitBelow bufexplorer.txt /*g:bufExplorerSplitBelow* -g:bufExplorerSplitOutPathName bufexplorer.txt /*g:bufExplorerSplitOutPathName* -g:bufExplorerSplitRight bufexplorer.txt /*g:bufExplorerSplitRight* diff --git a/sources_non_forked/ctags b/sources_non_forked/ctags deleted file mode 160000 index a438a4f5..00000000 --- a/sources_non_forked/ctags +++ /dev/null @@ -1 +0,0 @@ -Subproject commit a438a4f580c9445744c25941185c8cb8fb6b79b9 diff --git a/sources_non_forked/syntastic/.gitignore b/sources_non_forked/syntastic/.gitignore new file mode 100644 index 00000000..cc07c931 --- /dev/null +++ b/sources_non_forked/syntastic/.gitignore @@ -0,0 +1,4 @@ +*~ +*.swp +tags +.DS_Store diff --git a/sources_non_forked/syntastic/CONTRIBUTING.md b/sources_non_forked/syntastic/CONTRIBUTING.md new file mode 100644 index 00000000..764ffffc --- /dev/null +++ b/sources_non_forked/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 +additional information that may help us solve the issue. + +When creating a new issue be sure to state the following: + +* Steps to reproduce the bug. +* The version of vim you are using. +* The version of syntastic you are using. + +For syntax checker bugs also state the version of the checker executable that you are using. + +# Submitting a patch + +* Fork the repo on github +* Make a [topic branch](https://github.com/dchelimsky/rspec/wiki/Topic-Branches#using-topic-branches-when-contributing-patches) and start hacking +* Submit a pull request based off your topic branch + +Small focused patches are preferred. + +Large changes to the code should be discussed with the core team first. Create an issue and explain your plan and see what we say. + +# General style notes + +Following the coding conventions/styles used in the syntastic core: + +* Use 4 space indents. +* Don't use abbreviated keywords - e.g. use `endfunction`, not `endfun` (there's always room for more fun!). +* Don't use `l:` prefixes for variables unless actually required (i.e. almost never). +* Code for maintainability. We would rather a function be a couple of lines longer and have (for example) some [explaining variables](http://www.refactoring.com/catalog/introduceExplainingVariable.html) to aid readability. + +# Syntax checker style notes + +The preferred style for error format strings is one "clause" per line. E.g. +(from the coffeelint checker): + +```viml +let errorformat = '%E%f:%l:%c: %trror: %m,' . + \ 'Syntax%trror: In %f\, %m on line %l,' . + \ '%EError: In %f\, Parse error on line %l: %m,' . + \ '%EError: In %f\, %m on line %l,' . + \ '%W%f(%l): lint warning: %m,' . + \ '%W%f(%l): warning: %m,' . + \ '%E%f(%l): SyntaxError: %m,' . + \ '%-Z%p^,' . + \ '%-G%.%#' +``` diff --git a/sources_non_forked/syntastic/LICENCE b/sources_non_forked/syntastic/LICENCE new file mode 100644 index 00000000..8b1a9d81 --- /dev/null +++ b/sources_non_forked/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/sources_non_forked/syntastic/README.markdown b/sources_non_forked/syntastic/README.markdown new file mode 100644 index 00000000..30c96ccb --- /dev/null +++ b/sources_non_forked/syntastic/README.markdown @@ -0,0 +1,174 @@ + , + / \,,_ .'| + ,{{| /}}}}/_.' _____________________________________________ + }}}}` '{{' '. / \ + {{{{{ _ ;, \ / 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, AsciiDoc, Bourne shell, C, C++, C#, CoffeeScript, Coco, Coq, +CSS, Cucumber, CUDA, D, Dart, DocBook, Elixir, Erlang, eRuby, Fortran, +Gentoo metadata, Go, Haml, Haskell, Haxe, HSS, HTML, Java, JavaScript, JSON, +LESS, LISP, LLVM intermediate language, Lua, MATLAB, NASM, Objective-C, +Objective-C++, OCaml, Perl, Perl POD, PHP, Puppet, Python, reStructuredText, +Ruby, Rust, SASS/SCSS, Scala, Slim, Tcl, TeX, Twig, TypeScript, Vala, VHDL, +xHtml, XML, XSLT, YAML, z80, Zope page templates, 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 none of the syntax checkers that it requires is installed. For example: python requires either `flake8`, `pyflakes` or `pylint` to be installed and in `$PATH`. To see which executables are supported, 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. You can see syntastic's idea of available checkers by running `:SyntasticInfo`. + +Another reason it could fail is that either the command line options or the error output for a syntax checker may have changed. In this case, make sure you have the latest version of the syntax checker installed. If it still fails then create an issue - or better yet, create a pull request. + +__Q. 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. I run a checker and the location list is not updated...__ + +A. By default, the location list is changed only when you run the `:Errors` command, in order to minimise conflicts with other plugins. If you want the location list to always be updated when you run the checkers, add this line to your vimrc: +```vim +let g:syntastic_always_populate_loc_list=1 +``` + +__Q. How can I pass additional arguments to a checker?__ + +A. Almost all syntax checkers use the `syntastic#makeprg#build()` function. Those checkers that do can be configured using global variables. The general form of the global args variables are: +```vim +syntastic___args +``` + +So, If you wanted to pass "--my --args --here" to the ruby mri checker you would add this line to your vimrc: +```vim +let g:syntastic_ruby_mri_args="--my --args --here" +``` + +See `:help syntastic-checker-options` for more information. + +__Q. Syntastic supports several checkers for my filetype - how do I tell it which one(s) to use?__ + +A. Stick a line like this in your vimrc: +```vim +let g:syntastic__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: +```vim +let g:syntastic_python_checkers=['pylint'] +``` + +Some filetypes, like PHP, have style checkers as well as syntax checkers. These can be chained together like this: +```vim +let g:syntastic_php_checkers=['php', 'phpcs', 'phpmd'] +``` + +This is telling syntastic to run the `php` checker first, and if no errors are found, run `phpcs`, and then `phpmd`. + +__Q. How can I jump between the different errors without using the location list at the bottom of the window?__ + +A. Vim provides several built in commands for this. See `:help :lnext` and `:help :lprev`. + +If you use these commands a lot then you may want to add shortcut mappings to your vimrc, or install something like [unimpaired](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 [wiki](https://github.com/scrooloose/syntastic/wiki/Syntaxcheckers) 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/sources_non_forked/syntastic/_assets/screenshot_1.png b/sources_non_forked/syntastic/_assets/screenshot_1.png new file mode 100644 index 0000000000000000000000000000000000000000..c1b69f4ba26a2092aa4e9d42d2fa3ee08c6ab28a GIT binary patch literal 92425 zcmcF~byQSc6fcT^l&GYnN_T@ah?Gb>fOL1m5E6r+(jcI8cXxLq9Rmz7bPe4M4e#pr zeeb=s-dpSa^%iSjxHIRTbN1cw`|Y!Lkg}o-E*2>k3JMCYoa{SQ6ckij6qE;3kI{iE zYX*iO;LihRRhhRaCBx)fz(43l@-pvG?*IIxHRnbHS1=u9KRKhIVB`OJJwQoFA^|R9 zxX39;VZd?7@G;q=YL>Q9P+p?Qy_5LpKD#^b=7oQD-*yDk9dFit&)8Vxhcn~J7--Wy zG*bNdbzmL8--@)#JG2)}C8fc>54lWAD*}G&na1wV=g95*K&mk15_7aA7Dsxi@htX_ z>l;VrX;aU=V;*jzP*PH!?#@ID?bo5Qv$Nx%qrQFo>g!YB*PW<(Az^f1*NE8t;MLg< zXW|fpFC`IC&re1*i^&4Qv9Ym>i;Fad;I+6v-v)-%IbNMw*4WLzKUipHX8q0;{~<}p zEu2~={BX{B#PIa=)TI9>&5joTw?;PJM8=K$e-dW1V!rB*=V-XnUTO;_|KlT zdmc0glq;o*R#{E_WljnCFnnPam4=(rqDC@tGlRP-)U(yz3_^EWzm8B zmj@2F+0aJj7IfWB|M4rP_zVV%gpFgg(IyXPts0x4*4EZrZwLeeyq7!K7@GIdgH{bl zBsQ(lvU~IuI_a5@Bpd%`tu-vyEQ#};t+yuLdhz14`A!fAT{39LezC=0s+Ey!v#ZMa!nd(<&dO4OHV54oW7517|V-;vfkj*4w6I5x$e4c4~fOWbp=a? z@Zm#?>9TYYP42`YyIMngO2#46uTL|aF0L-dTNiQNJw2miW8I{7p$TU@^(7ig9UUFJ zVmSLYv(F{x1*`M*OH-Pk>b|%-+mpAjV5q_PZdz?Ak8_SgrMEo-56{$_Z_q4OZ)$4d zNF2JK_88@99=ukGM`XyYO6x$Y7_DLUOZ$!cEN+7IiYaT~H0YG6U;DMAVl1t$b_PY~ zPLtzzmL+~4FEEw&^Y{PMYKiZCtz*ybViP{|J^;D*_{o!=0!w#y_vw-B$%1nGdmq=` zS%qHYo-)BV`Ph|9)8*GJL?O_Iw~rmOCo5+B*fm&)um@t<%}3KDNN~_e`R#TO8`H{d zX1F>!J2^?iy6rj{^nKqxjy#yV#QqTXCTJFH<$QC287hrB-{@+3|HZ$Ho`%DH31$C< z4{>nDkNEgLAvMvpo6D0da}(u8byjI%cQMuketKr1MAHEcj*T&uOH0Mi$yaCFj!b++ zA(Q=*=Zo?ODIy`E9E7Pq+K8Pu4iTx4WduSdb>}m*QU;F_a?Hr1&}qOin&n7MNyZ!X zXXyS7T8}X2!aA2sL&*v33u-9Dt4OU_MoWuSLPA25g=l;nnomT8F7E2e*NEI*9){bk z@76nqlAgE+!7(hH_o_d5otd(A_nvGaxCNYcNzQgA*UMF?g9`Lhoe}J1Ufu6|!hHyI zVFF%j49+b#!BF$z(K18So-mKl-=w_3Lm|HkVFu-zBm!nE!5JK9w{DixX%Cn+ip`cw zTO)tOiJu)hh`OIsczJs#hj(sF%9T3bbOAD>#+!4-6KQaxW@av&cJ{dIkg7%4cT*MW z*j*dxBn=2Vbk8@0_ogvm4QSk{n0WRv=Ch4R8mX#A3O9LP=(_BVrX)AIrWbS$%;$Pf z&9Pg;8+c2bE`$pTW)lw>g8jxU-od~nJCo7+L~O5FMUvZmQNk(26jhC0dzV5^k6p3n zQTO20rpQ?R@e&1VU^&jMcL_u=ozCI;#*iZBuTM3!M%8sbm~xPyXjYhDN(MaXhC=am zVda`EET1a6TEZLSK1fFpynU?gkZDOnLp#>uEi_weJAkARy0qOoz#$X-x|>Aqb7%UX z7MJXMZ7p$2ON)yIEarNjGQ75yKYGz8cBD0KD3?k}3dX~uJ8~a21%Cb z9F`*Db$xrkIbWy|c`%PBnjrn|%t7?d0Lv@{EpyB_g8?ubN~#l*f{Zeo?)N!fr<|!? z7Y`b82pb1g)YXYBEw^~=rbj8OhOYNLeLmF%Hh{NBtDWhmY^Q&RZb1P9plEb8=1bg~ z$;3!Vw4JWGU#T2fT3(izZvY>jp04>vh~}sdC48W`WD~ou@MTmJ+lbDmdb2L?^d8H; z>Gnyn77rqyzK3&XfZgN3A20rR7@k+K&BZS0YB8cV(%i)r>-++0y?$%5tJYuA>W4eigTn|dqtEc-XvSy@Dldn?B% z0nTs0^u^W_ua*0O9+Gu&dkgVTdg^^5&4Lu*5`%+;R&9wv^H_BacGE6ZXv8> zb--hhfbosj^*XtqpWiOT+{`T9nza2@d)$y&44eKip4gqu{ah{;;|Vhx zY5?O@d{*@PX*14SKtT#GKC#$M!@%YqibWKxR<`XALO& zQ*!bTE-o&S`40r$_6L_c1LPDGSOqMi={4Ryejs?c=wDD^#1+5m?G2KWU}fO3`s~xr z!^jv9SaWxLrFq|A|7&V$R3)X68+Kb4VoRpD4<0};@#N;}J($0FTNJ)O`eFvDJcRTI zd?rU8)21LLdL}gDTcK$U4-f~HeRp@so0^2Nv8L3H&d%1a7MfK+gqdT3-A1qI=>v2d zU7ZKY60ye_=8?tf%qSa8!lPhSRn^0@qxMdVM=njm!pX;ijEtDRxv8EDDZ~jmkx@}v zqi*>YdT(q-TUy2}Otw7_DxA(p)l0Ox3wW*LIlW06N*aZqfK)iv*A00{_Ymnki1Eow zW;-}hNOqTS+3kLVHa|T-Yzx?h|BkT~yA$OHI<<0-xa4I2(o*|KYlqDx37kgDyyk8^~-*EeqZdSs9oqk6xwg=?DW5rwCjLEJ1Jl4LFU09?!C~p zYwT8ybjX3gZC<*^dSlS(YS#$f>S&h?==(jmRsy%LrBaIoe|x%ug*9uV(5(v?bx#-> z9QFxt$_*vl?uQ1RRJF-MZbX+Y%+IUpuO1S<4ZPPGRnOZ>*w0{0+)IwLg-_QQW32Xu zr^`k6+}sR2tg)Hj;7X1ffAkm&Crf=u%S-SC`}?A!(B{(emZ84+>IQ4vhk6$MOAG~4 z{vNTm)QhhdMzQfu&U>l2hv&UeX!Hs3F!Uu;zn<|gHDztHYOTF$H2`$A|BRIZf_IV+ z*_`d-k>*2G)O@wtCt}0*--PTNe|5`4=o=iPU+?e-20t`7O#5VF8`-eHKqHuLrE4;jlb}{a1NPAorWO|XcsNx|NmJs! zyQB41y>QYty?tXDV}I2@BB%VmwAEsJ-mokIypICG~ys}N9G?5 zCR`ILiQT^jj1y-ULJb6IG=pRK!P5GAH}6ow@mgJPd-~zF-HYjzLtZ1;z6jDF{|%r- z*+96ODAb1KJLrz{kwdCde2mDsTjGYIM?{q}zvH@Z_t6IzEf!hwtoDR%)Y7(|0PvV3 zOd5zu?bsutxJz8@c9eo&)BQ2ZU1pr7O0-Af#xgBtvoL`Ny9}qg3y6r|j}Sh6nVz0* zGt)4%?pP-rn=JHeM`vSWtzpj9&d#pfLm7w-r2JODLq9o_a9hz-TTQXJ&a-lID)uVR zAytDdRn>GT_u;Lnn{;8!r|`vMd13%8UtGqbvFNrW&FSFdlD#|H*on@2_RJ9Sa%pEr z9>$jZsnV4~5*?QX)QbDN^jS5b)7PgfR*$C%q!?=&itg}Os>ESrv|g#LguZM&ABq$Kj;WU&KRvTqSX zk*khzALtajdyY??*~?CWyKT5iXFkguvsk3po-G+K(_~pA9b8xvi+~96Nd=5}=f_($e1tT0tOIRR%VlO|VV> zdR%xRPna|{@XTq1gy363)10{S?XmTMKWrQoC#o5#(^A(Qp`5?mxTex<^g)H4F$vD2 ztcfvtt#=~;KMzh=s>`w^5arY8eNeU%0s0yc0Kd+fdC2Kj&G-${~5d!m6D>jZOVq)=9dEo;>v`=V1EN{ZF_#n>grzD zq}8vM_xDdJfN+TJpFZ8D`}oznndCQ)uOUCznG&QG5@Y~;Mfd>(^7HqTRZ?O<7TL4= z$)Sx`gjU1?H=F>sWYrh|?|T#pNYP&Nh(;farmRzKsW4t*b&h zKJ-8?Byi>1_wP~B(ULkk{9= ztVH4?oBt9WKK1qWK!Rm7TR!%^5}aWMU<-dgA~feq1i(UZLYjir?7!Dm`b{2fPUO4g z2SAAa8~+(zQ?fi)@4P$H9P;(+quL!HZvn7l+u52-KzgzMe1(%t68|MSK7N7b8qd^# znVU;nQ}Xh@1CQg>&l2Y1!eSVlT@9M4cp>!#NUI2)TPE^alNM;*VJ=g8 ztT|%d%>@P*NZfsp$`Cd(W`E7<@$JuIyC%)%6RN8YMpJ+cO~#I(mPGcaJFgj14-dNQ zMRfl!fq{>=r-}y}c&+Qs?=X}p@YO)5=>A&!8u1U~9H~`4R*!SjSk1|1^hCV2y2*Pl z-+GJ$NvPDl)?;2I^Bqgm0l^9X?smoMXKbuYfTFH4LH5LI5Rd(WAAoXh-V_(OvKVcm z+$8Y4J40sN8RKP;BwHUE<&H>~`f1fqZ&d~*^A$SbgYLbbb+!@58c*KcSuy)Fjm7?z z^o9M{19tXOE?ktY<>fE7dra7~P1e#sh>0WIOdjQYHE}6)_RY~y;eM|REnwN}uUMIX zK=QHs?m%og_3?B`&dsyGYs={O7tlp?TsqUDJAyYc1nww2)9)heX~<7Ozq zL^^Ld)Jz4k``FXDbK0^pcvoklF0zYVUqLn&NrL*2gFg31nH8$XQEWiZsr~qmwwmI@ z$G8&w@v<{DA)%-;3_}crDyz~&mI+%IDMma`XPdcw6i71|u=0h@XCoe&ZM>Bl1ZcsX*r2N6q{@5sz} z8-*<8X{Zfl;Pd{+KJKs|!0*J)BNLL|t#0P%G&xYZBwwkhlo)^QpL5@@59#vZN*tu7 zm(^_k0!{S}iZS0f4K3Y$pcUjj{1NS*4!8bv$7y)*>iceVZvIqbqBl)&nzi=RxpE4| z#2QD}VK*I}Q=x^(XQqL{1hoffZWbXj1}}+yG~4PAAnm!X3gj|gI9Bt|QyZ!SwJ(Is zTkoFnB>!OBW46r-HJsmp);N-|56!fr9+dQESk5h$J}YplM{YGt@p`NeB+rRj5^`d! zzVK9Y{^@62x6^<=fqRZP+Ts+x8l%(VecZmu5!estoAc_)K=8be+*WKABzu|dzm4x9 z@9Sevs|Y^pF2+iSC63m3%W!dx2Z<1BpGhQ^>})1{cS}xKOA(D-EM=~RA6Iw2nWKsP9N$?N!wm#7H>m8P*@2&SdR zx0a@pBdZn6rWh@FA!p6MexUFAq))qM70yubf%+0|Ri`uQg1fC5t3*V(=4C{b|H)(U zlk3lYR;xGNU%82?Hr}f8eX1w&(Sk&M=SAI1Y)#j-HDeR$%KmBd9O@K*d;N?j;I`K4 zbI|R~T(*9~Ept%gseJ!GivFs^b+S-qG}A5BuYSe_$T|;c>&crGYq@{+ApF#-nkXYJ z!uebQrt~QfJTSO(9CJ?nwvb4bYcFz>$BX>#t*UNTImPnfn`3cODui#`p z1A+Ru;|usKLT*j??pPC-Ke2{(@sj0x^eO7J(8593a#)2cK&b@YLiwK(p z^c$+vWM9^5k8>#Fn1?7gGdF&GC@HVVs!6%jBupJ$c|x4Iz9yKfE!XSDC=g(7W=GA+ zJYxD%Eh?)@$Lj0Fb5BNUv0yx8{seYW#`T{l1Ek#<68mi_^DW&c17Du6&?MHp52MR zc%b_CupkhNOWoB^kC$3@zMQOddpRyzZESEj6H7Xb470#5qhNyS{PEIff<7bvnr4XM zP#8NL+w!v3K#fK4u*ZKd|JnAy zjC}k}8S-5|{mQk^keu|B;EhVhd1ZnNyCFxw6F6Yy;1n38V&F2UEtZe(r`nSJb@6Wl zgH<+$5_6T}4*3#tIL(K1NpRLny*xM5IW0B~uu%xIWg*;BtO+f~Z8>>XktijE#F!t!8@dg`FwPhV52(#1h5)|+5v2#-wKjFH}pE+TPn#1iZbI1aNSwP>CG8mA$ zzr}dwQ<@||!H+b*EvjLQ;yoo@>XtEXa99-DDYI%A5br;#%$8f6zZ3AuahT0kXnm8b zs9Q9+AM(#SZ&;pmXgk5;<9qQRwXgS9;H=ZRNF0B zXq)v-D4JhBb@|Pr0f!Yb_&E?hs>dn|_B@yo(mv{(U8TuIIF8_k1qrzKrRd4Et5}Y^ z)k5~i8Evoroh*@@SH|%qjNk9cl;5*+UJ4!s`jMja9a42xvHkMxH0w)AayvLBDg)?g zRS;w@#W<+xT$Wxqlu0O@hQo8qFxT+@FNpa16hft|p-k{AR0msKK?Yjo2LU^suvnl$ zodjB_NSD6ZI^bf?-hI29_D-4fWFyddDceT(kHvyM+~)F;^V($%+}Zw$w41n4c^5_n zvfR>`Y-uniQB!j{N5aPuaCpz|2Za80ZSyh4Lv?ySvd+1ZTtBn)Q**>4@~&TrpBd^X|Gic zgkeLN-}mqFmCm|EqPfN6hHgJvZtR1E$T+qxIYoU#ntxZYvaOtt8hJ61FL#!Rv2lK{ zO0XT_*(Iu^r5rHTrI;vnTTZ<@gsZDiK*4KAb2OlVKb|ep@pR>bI2m*}9MwvE5vIApmvXNQq}%CgK^^$Z>pw>TfZ;I$0QU;xzLS_~b9;M)?i z7}H{mU=khz1WP%s#uu#Yr8*u&l)If^nDltAEvq!7Dah3RycXkQ30*T1$-`l#%-v91 z^d+M$=hksh=W`r+G@7q8FRDiwglA|QeR11@#l>rg%@6P)^pxAl3xzj%7f8m%=$yv zQ~f7Nip&0~=gypr@D$|6ZLG!oo6yCYB)SI0r$gJ1xZS!{hRPZ#uMIadc(uFPlkR5lvs8trs9gtv4ZBUO6%5thQKT)7=S!}qcsO9%1}aP> zLnn9kI!SHehp6?3oey1J-ds^mf1iEy_h zqI*^pSpmYVB3SViCKqsp%uk51L~1`BL7( z3^mWMs%*)7D^2Qp@Z=ZCPZ8Y(?(QCD@ zEwmoI=`7{Ujpr)BFZHVTKTuFlX+6=3u@mVmTEv4Ef^bDWGlX(ixiu@VACe(^BO`5N z8bN<;LUvSL<#YQx#|5xeRE4RhPixIrnxgug0escijMh)bImK~m&<6lYiAY1j0KnN$ zf3UN@Ku@g9&$kN1$kb>{38>S}RWGv3a4(0sWhQ!KyMd`%P*u6Xx#a_V__rp$n> z-mMb`rlr89AfT~<{8Za*Nv1O57*byvmhZYIe=h?72hyE$s9}SZ5VADL*OA2x1z?Yk z5naO*0O}du-=u|uPbe&3JSV9>>Q()3g_hAZeTm-*i(B0}8-TmWB zUP&a9sVIfMgMtY_*~6%vC(L>O;GXZp4mkhS0{lNP5HOjKk0QJ_D>qZ)uGKF@pv0PszNE#47+a8)T_Y^GNnf_d*Qv6aHC-9FYK4_u5 z^w7$4@dsa+eK2R;^k`Dg>E zNwMZ8POf)GRpf{}^=y$ASnG^`Ybl0^_S90z0?=mki%@hUc-tEm^ zBTtF1536E9hbM8`2^UK&RaU` zbG@~YMZ9RhCIk@w#3G1lb~t6eHK`u&>*GYW0wzksS8*#V%;3j&RU+5vKdvw}GvZQ1YF&wTt^;^&>Y1A&6l#mGuYr=p|Dm|bVS!%Qw!ggt)dKXh=e$;l zjj>llNf^S6Jw3OM!oqo&hF=!GqPufiDXa0_gZn5=nnf~DDKZL|_YB2Bgu-Fy6;7;D z<8tpuvW=k*INvKK4Q^X*St0-~7p6@05%j7-k)w1TPE?)7H`EK2wUVX;SU~}r2lrKu zb^k|szR$AUD{9U!&bNsENU~d7DLN(|@e%$HfbD_=l~>@O7QB$y4xe`i;q@jZ1)I52 zioXVkzcL{Ks2Wdt#p?e%3`C-6j2xhn#3l_zSSuYv8=@@|_MKd0dLt=X?^fSr2Jo0} zM9-`E76+`xpZ9WlvQA_ul+TSdKEOY~eg(5x|2^|@;lkA|GR+)0-Wl3lFM#jgq(a!e zF8iy5Wtt%5Nz;*mr`6XhC!{K!SdqvVy|PQ_wrOiNPd4X@yK<-7jc07_E-?@wwvS~CbN&2#glpl&$R1R&Pu zZG;{p>du)AzA0iT-wWTiWK3I^VnOs&u&&a!*6v#!t}c@&#bLVa7}rY-NQRc8s~#EKm_On30j;YG%k5>kDO?AlC%Y1UGna7HXeUW0Ek5iZ1SjA(ETo2{LO+e2)7 zeJJ?jy3^-yOXBnUl_Wv%v!L~V=}`{MyVPM|^v+~Wv&>2`A&2m$Fgnp(f|=yy=+W&c z3VV%hh+%(R%P)QC_YEK4A5m5lI;`x+dX}iPx^BA0YMZyOcQ(t10sR%`tkic z;zydozazf>ufhK_hxYjYHu!lJ=KnGH4jdW|`I>V3L=vsz4Vtdg$A53iq>}zr0reEC ziB0HgS`?>XxnL;nvQob{O}*&#ag2nBhsRBGUV*B~%w&p~22&qw0CwP4AN`5L%_(wc zdY;QSwr9Sx*#C1n!~6Q$#rv!9!T2lT)Ce|yUIg<* zc&+wkx>ysvM{GXzY7U-S`&o6fX?)GWaM{Oq*#wFt&CZP2Grs9ZkStoVRHIrs318B% zmw1Nx9|eq#?WOV;pofRwLG@lNF|lfFjQAuMH{y*Kd_s*Wo{`SXo8_@o4mcpXX%DW3 zkAai-leHWXLohWFmbgs%VJ`3ew`{aDaIsRN)AoAruCK3o?M}>FhbQ92oMB}}Y|`-5oBw2@ zOKFU${KZOoW^O%L*8Ui-6m!?~0*8sB#8&#f)ps0un!k?)B#}6iak4jia#OYSdXEfk ztkQ!d%=&W18vI^s!A4q}U}TTO5w z6p=V&5ds>q*8|P^z5{{O?dQ6WdExH2^#O4=WBfN!jVX@QcBbnM6u{9D!WDM7a7rcn zUeVMbl`XWv?QyhNLO{+IE%F>V-31=o@l@|(R7zy`l8>&(+J1Y}&9IG2z*}e8A7Xv^ zTT-I;N(j6q6~B54i4FLG$3;KGqKjJ(G0GSyvKQ16VN*de6U6P~4<07N6Q?PA=u zA|uC}ed3c^8`pTgql&=}if@IxQDw+CZjcMOqEjT7>}i*IAEdu89aB&oddb6)HdtLR zHk=e#P~e4}>|iQ1{d+`kQOYxZ8lH+8bW2_s5ko8}5W zm0PIScEfA=m6kuuei~PZADrcmHJePB#m){-t=%SKL4(A0r)Qc2rjNsbg%OdovDsJo z_1mLa>@=$3i^xg@dt|b)(N+OT0&jkVYFSm*ohXX_ZBPI(N7dwxR>8=GDKi^1JBz7^OCT>3a7*x8pL+M>qcH z%%1$sb9r@FHuK?LZsUd5vHs;hd;N>|SAT({r+p0Rw{md8=~I`otMT_9#5UeQ!O4-- zGCvl0zflLt$nl#Vo~161y{gcSY|$<)P8}>?i|#U~Jse$8(FE@W|6Uvty30_5TZ^jz zWlU^)iIrg3mjcWm{bM}G3!KrHN42~-d$8iSnM!}7N#H>6L{)z9+j$47?T;tRF>H}V zbBS#oaUp=VKjg2$lmUh4>&BNzn70W|ELPiW|}XRX7W6g=ELJ`-GeS!vOwzj|Pz&vL!#35plX7P*th zWJHR$mCxu}$UZ#^ijD22&k;mRo0OD%<19MN7?@Y&i<_n{t`JT~QHfzG_&L%yJL`sw zZ`UltYX`bwf!*QNamWE=*%m9e5WAK?X$=auZ$!M=o>b0!SVgZMDY3PWx5S{ zMf1jYqN<3C-*J$0z1(QX)sAdJ`%35U_CJC~(H%HxV~b@}XIyE%T}%jfJQUelVClMB zYpPqkJB3Y`*iS2WUM9nJ{rx&>bTOED8EPzN z^C;<+QUjb$KgbXKcCs30{2OqXa%4|_%iRn0GcS@G&Xl-sYn-p=Cz2f^Zxvq5=A#Fz z9v}BJC+TOnHB*xOs!*UsXj(_cnzO0OB9TZMUTXiOIUrBz?{0A+KEY(sQ|-L?tf9(U z0#yB!+5Yb1=>@EJclECEN{y8zE=?S=UtgW7#$87X>EgKhlK5vudMT9eq`z_=r@WG? zF-%;lFT!VsR3B(B?21IzL>3=$e#R%%iI8j7lLEa@9WFQSCE>FnQ4%?Ov`Xa@ilZi- z&C6c2eStQskFC4=i;HpR;y4KD))*6Yu@DhJiV8j3>C1$6EV=wL0?3Uk) z3DBbYDk0d`T7>M@wp83Ae{zc*6Vir;Z;xjNB~a#nS(z7FAeoUbIUhYoccbWz(;|2bo`0Td(P zP>Ci{L2e=^Q;VgcJT9kL=bZ(BSOP_ypB3h$qn4YmGI{^((TZH=u~SaW=Y}x3aU>>1 zDGpczy3~eQq#plH?++@=c>UAkWMd1Tt|=_Xk|k;Sh13JI>}k^13a}7eQJWQYaWK}( z4KFjUf&dR6;(SkVd8_kPX5@!}pmf}VblJ9ahTvPd=7-soHj*F$9^KwtEfOFX zajWI^{UQB>sZrsJ^G9zs%313$F_DNNVi~ThOT4}6q>`Ft%?m0AZ+c2{(I2skDcwiW zh<6ldayp-=X}%Tu3PV4BPud` z1nInbPQG@)L-E&&x*#g0*Luq_>9>8q%MB)7codi~H0b$9{BpLW7VvNnjo>vTIiXuS zpI=5r`Mq|-B6cN9a3YD0d1tQ1r`MpE(f(Wb-e3d$>kl>MLl=ku&p*{7AyyrWm+6GcO7vr@;7FrmRuv-aAf8kEYE$+ne0 z~ZTt8LC$UtNA z`1lwoX$NW(YwQXu&;?aE_5 zM*Za0!<@368Mun`Mk_uzX)PrmM1&!k0pa=4Pw9*Az?`$?sY$zT-xdBg1F zqt@$4BIor-wokG*m+|g{w@2+u955TrlAp|-Exo2BsT}iY=BhJQR??${uoqk{UR6wj zwLP_qbslufukJ5TNi;KkjGp}8$j>0P^6d0OK6on`zunsH`J(w`f$2n^O0lwSq}{zx z>sDH!c!`rp6CP1W_*|t&4#{)Yd@y^&*D9iww;8y40nhQS* zUfo;o`vJg~i@R7=d{ya_jZ%Z-6TFk_?c%kyg#KSW6p|&Yo$+Fh7Z)>5=kXPjH3Cx& z#h)tC?d|RPY%~=R!y>YZioG6+O&!%XPWu3}{kb(}-rkC4`YK?y=4OE$#I02PhpN_c zflwDQ9#z5z5`l>6(wABSRURHd{kYHVna1{Hp~fL<0Z{tg z9!{ZcF;hV?Gn3;-1xns$_hDWn1x$o#KBx8|vQ6Rf(FmF?A0S5$(JFMMY}#>dezI(3 z2@&PWV^yn%ufC`gU7@SLU)l%{$YoF9EuBlXUldFLs9=K?hPJZq2V3PAlzXrrw2f@X z%l0yXO8n0#H-|dCcTR@qSv`&my^&gd|MEtg>4wrl@6L~)q14!7KM(y(XgHLgXe_L#KSMVa-n(gh^UJAD>$e6 zhs~{1sPpEgr5(jM*|mvLwh2d`OI^(i#{3tAR&knz>a0daMnG?i+2!%N*U1pS@W~+e z*8mN~O83Q0n=(uVl-V3J6w_Kz@bk^tpEQdK5m4Z3!Nhp^8jyz{UvC?0-;e$uMJ~cv zXr$7*rK7*276&&`4e)-?vEG|WQ@PA*m5AEDlDMPE&1uw`s-Nd=;=jd+ic)(qor|5h zPtma!u`y#E{}Hr4OBCjQ(&=GhwhlP*Vivu6G+o#WzB2l1>cXRrM16xA%|Gmo1Si(I z8y&gzu62PT{&xPkVsgE#rtC|9`^}yNg+^vm9!YrDKnX!g)(oM>?R5hmuJK4dLGDXt z0bc*nHeW6=$s5Owcff3wr9?48vc+n-PdGU_S+r~XT=!}`=95ibtN4O@ypX(jOQv(6d(>?3=V)-+;Wl zn}WR%dhcb+G04MDV!nNU^eolg zG~!dxNeEI%#^Z7Wq)$#YuHSet4p@4=YJZTGWBN+~r~e;1@|wEf*R}a>Vd=)v)sFq@ z`nu%Xw_Nl}DJETk&w$2`3dp@rgWG|YiTiz_W5wpxvJcR-bQ$ApynYa}HBrC`e%o|6 z>5*+oYE0RZdxMu>;%DtR*m(|ALYGY6f@94*V*Ac}TG?!zxr;*qH(LXlHdM0L!wOp} z%Z(ifkgH}j%c0jZ5qCuw)o9Ba&WS@i}Fy*%$1Zj?Hnprp9+Sn1i!f z=LKV}0%R*En|P zo+^4lF5hd>h2hj(wU8SWUfYim(YYgPDYJ!Dp)9#{nWje_*zDZkZ5Lq?pqw8yIOBL! zGUE7nfc@lTM9g`J7glCIvheoWI#FzIyP>}LKGIJ^3M<~e>G+|VSmIFr#fMO7;~>je zS8a$!duaqgI?SNk zW|cXgy3egy-X&D~8oQ{mcD9L*yT4yupK7X^l9ryPH2> zrX7VA2&fIXbNdh*3cS!63o43nRtef$vI>EP}KV5t-O*sVw%!Gx783*!W24Zh|aOY>o%A{W=Yx8b2mLk%2 zE-!y2{rnx+XrK9M-ob8jDtun3b~Zv_zr$m{9{dy+VB#rFDPo@Ag#s32p|g{9-iNqJ zA{5q(>bDMJIW0o*L}%2SqfHMAWA5#g4tC=;zb}kNZ)&AC2`o#+^5%zc2VAT0Pb8MW zq$}+v-{+DBv*$qG<;H~Nk!^F&bG)zi>9~8oo@wX~Wp|cTa&^<<8m#}RS4Gni#?wYm)wJrg*zd#|?sj1h-qKU{aSAU*S6Bmr)KBJv+gus?eCP1SGkh- zmmIv`&BsR`(7By|kb^maQVTnJZzr7D8-?9~-sJ@6#|8|5!`p8L)QwtD5ME=`0fR;0 z?i|Z_E!2atlN*rYDnDCq^;i@P5F}lgK-DyH)y%_M%P)o>@UW<1Qmj8DU|aEtdwdSp zK&apFUPvqz-E02?euR=B9^WtBep>e%_fc`qxm|}TI=k*&?vN-oBN;oXlDp!Fb1EEn zMD08;K)GoMfL{gU`VE?4>)#y;QKxvt2K2TLOeI4ieB4dEogLAI6r9x>_Ktj>~Bd@Hh)|^H}|b*xge2eDtEhbsBD*G7nOujHt$*ri9TSzq2;Y{{jU~)r|Ga_Zcc}9Ph@cCKyf`thKh!t zJ|L_S?|4>Q&3$zeu?GjoY5=WKdt1n(5X)|&!{C9Daj%*~&uc@!D_O5%1u@sRK52scy=F#qzHeOH7-^I8< zh}@drFzqxKkmA@}o-l}f)*T^Z7Yi_By-Z=;(kj_@2Dy6%7c~4;DI`j+!|0TMu{K}& zj-WQb?NT{?s_DtqO`7fX6sybD6e`-feJk<&cZ+c%)yK;vH9gsYzX6Bnd(xhy~DR`m^^R)RhK<8LJe!QKuL!Ry|4aY<85n>%r>_6^=B&lRAfJj}3GB)8hWC1Qg7 z>`Wtt+6;=WRcots-_8$hhJlf!ZR%lGkx6ks#AX!Rk9z3L0O)P`4CD`n-)CvLgL7?b z^Ys1CgwFBRS(7H#Xc}s*hg*yh93){Am`5w4@sDm$9|HZnJfV-5y0USA9^j!JsWL;D z{#Ot-Ju7Ye2JY)1)||3t$9Yn^)+^!Oa7wxn6QGIHv%Od`kk~UKg|**09KN)yu%^H3yXOUV!5qklaJTjbp)j|$87cLh4wq(>_u5OEVkmRh znD0O-F{q#*?&R1)i#>_jJo;AsB+qHJgPQHUE{7yf{v-I#qU>x$a+tdf^Rf%ZxzUMdX??`&;UO&(P zyY|NY-=k&d>Fa|4boX*wZ5*|p)8-1RSsQYh7#9I?x%S^tRP?%8$&3gp_{dF%*E)vk zHC~Fz3OC;2jF8gG)>hv=QSlw@kGP(=~kB?*m$l6B*c zG!Ndb62E!snJ-J7l=ee8*Uzu93IwW#@vLpE5y%ZVLa^`m-aPgFAB?+D z7?61#m%NzP>FMb;xof>kQJT-r)@s*n6PL6V@1*?B-gdtv|G2nSYPEeC@p$|0-}r&q zu%eok;&{FRv1{@*Mab)9=M*fRfpScAQH2%Jzno}as`3GkBK!U zw`GMP64{VamzkW#cyD9dbsntvI!EZ z=&z3jvsJA_?lAV&Gv6Ka+Z|m#rSpq37k&$3nv*W)%4ODD_59rrv6L^>tkccRUCp== zh;1uoKDl4N@e&ID&EO>L&2m%f<+IfaKJ#Zf?a)XMz}t?SDuyiMsB?o;OFfU)7dksG zH@QQGT9{5-n3Z1}uu*s-#kLyc**CK2gI~?c3;T}Vyv^3^o z@kf!5BJ;3l3&>Hut>5zvFh>Upl| z3o$<$R!CZn2V59l=Avlb0=iXzAZ9M3lx@?;9m#B8G*S_LL%byM& z&yy9DOd_JAD_3z>P*P_SssvD#*ebrRQ*7 zyFSrUy}=g;Z72*q5wfoRGrJ({$e}*%IA{n!kgl_WLG@l zts-c?C~|c_*yi@#>{f)V!(B2{u%7t@Vl3MzF7LR?*I&+Fob%_J96hDLq1@i%!$930 zm6y|A`gEO@b-n&$nW;mW6@P)stqLJ2C}_P*MBmS-w{ac>+pJOx59xs@jaKFY{#Pe-l-daeTAT8POrNWSiRL+MI-?a%dmjaxC@ zzx}zg_x*Of{pl4Z<>g!32CHYNX zdXv9}O4A>2i{V;U9qWyRLav37tihglf8O)A-P9!#a{9B##gj!rOUoB+ZEO14Z7Y-n zwR~gZ<%)~=WF;AXHgiRM{?! z5=`05R&djqdq{!`xz5%NC8XEz;6 zzMrn{{WDYBnqdSO3JkC4>-U`$^ajqN5P^d#;RuhW+L_v5iUalcD5{lY0qXR6F`1*I zIBpxTY~|mfRzhSE0K~w$fO%lMm|{>>n5Vvd3}jXAjqygMm&6?AqtsbKBMK zJ{q(2nxZPPzoQORNqW^OhZ5F&YRn%c`*Q_g2USkyfZd|Fh&E~I{(9>+ci77io2*Ft zh0B?O?Ds4>Xvz|t*wrm)7npwXuGi0_eF*lH(_I6D=Z7AN;Hrp>%QH^EtI(T4LR@#E z;zaTfXIK@`iG4FTwh(aZR>2s1wTVyfxS#h@{quzJOFOL&=?4?zwIcPTL|?B>y@BH7 z4O03*d26z295~4!EzRo)8T{Axi@v+q7#r%?lzkM`{8ptktyEh2*GEFP0JRPaVUfuVQi zBDFFNOmRGE^ybDYtVj~t8oJr)haN(4urZ-5mNJ1@5?)!;_S1Jb4utymi*|D ztal7fV1J(e3}H6#@^{qe_?`QGPnIn=qQ8Tk_qciI)bDbJd~T#+r<>I%&~qM^Dwa3e zDOU^ptQxSKLIb8gG0j8^W-@A&#V;RKG4b!*4tgY6Y@~}rR+?ro(WrW}=7*xgL|ymx zh&T{bz6ee^V2GF>wD%?mPJ~cL-N@z`IJDQe!V|*Us1Y5wh7VE2XHUEc2#f8dR1!`% zq3FJ}qb)hFOa3s3G=C1T*xI7+A>;_|??Xb-+)0RJrr`QmQj*wxkA-3GHGU>VFk=L1 zX6b4f%cF<8XP#y)Wc}mWg@HygFS#y$2$}n1yolbn0jUiwis1{Vh-QlPz8%vrZbcGf zU3h`AOzwY;+O|)kddz`mI1)!1m&W*N{btDR;x3hXw^R3Mu7mn3PbVTk_F}s_%qocw zu6`rLi!qRWoT3>WhBgD+X9)*9DZ z^yLVD27x@N1>gQxCgG)m&-hm^P+Yp4e#eI^k)+2}-o60k!sMcfzTdx6mRlb=2rUUk zzwr~#qx8LQKH~dFU~$u-)sY;M3j3jNP_ORxekUjolTM3YvE@K8~<BI!KWAHQpl%2 zw*(Gr^mX~=;P@n7@k;8_C4lD`{Mc8NHE8^@4q2_knQ8U2%og$>GV~@L3^`;2dRH0n zgS~y$aS%FNaO6_-U;PcL>PNFEkP46U&lh3!x2oi}g{(P_#w?#|_OiSdA&a-7HPN6& z#B9F^dX%k-mDv7oJRF17M|BJ*W9L!+p8bfXPvLv>D!>?>4S%a_ea%NiMvTBNDqN{KsMj^yin8%`^D=7&5DbW1C-(68ETCkl2Q%*A)ijVcZ||Yx(&cP z_$AF6pH5JdzG>p=sj*djV@X)LKrwH}Krr>`oYgo13pQZ4bm-%Du8{dO9`5#IUenIG zC4}s4uF$*4&-E%NEhCIX=#Nr9+R|+?&lE1n@Fr$+0+zkC-=p(9@r)w*d+=bi9LM^ru2u)>) zq&b>gag_khjwRblBj{`6A3VcpO3rY(K6)ZHC)3wyX4Q_|{j3tE$E{s}eTt&QAdg7P zkCO_yQO|;MO-2%F^>L0XAtU+NH#F64NBx=b%UihRPbuFe-$f%goqZV>l#&h)Wco78 zRjbiu!fMp%Jyww8WTUHAb6>|JxR_WVQ5B`aB%8~*t|5y-k z*hnbaOpqJGggx{k7$-fn>-J~;ZPSplaAa;7w*-|d$1)FP=?D2RNw^`8=ITo#4$Tjm zJS|VoGZK-Vq{kKy2X&Z4eK-*Y02rZT)cHNEvKuK{`^^UI-aiWhzf)qE}k^g-A zvSF<`h#o%l1bkL0Zm%N#6mWoCNw+Q+97g7ziK{Lm1h@56zq0BlF6@Nc8MFGknmbRV zQQZ5tVEFa;dnk!yCa6^EN3dho#Rk=C=%FgrIzz00|K@ZXI>dX2^uXKbv|O%#E4j zT_OpuX*H)cp3?10u!(=4p47%hCAv1>g@8EB+315){^z;y>c!gEk>#0nlMQWhmwzEE z!XxhK;P`HIJw$}>57zsaXUxmXD<^U}K<;^R)agw>k}hywB`rL1phDp5SA^;XYGJ3= zMZ%W8z{y`;t36^seG#-42)_41y!J2ByBWI*RiTrvE54a&)wi6l#0&qBrP%CygI~GT zj*@$bg}I%?cGom`0WHe$IHHg(5(Hi2W*c-F$js_9cXhEETQoe2F92d_BMq_orJ;A4 zbmF7>>~U(=rNo=gasnADQ&;a#H;%dh{OQr&1wGk%ExCTq(%N#fJ+r#KsV!CfARJg*#7^ z-idHK;TrHdqPD2S`g=)ndR)4e2|rTPPg-d0Nqm4S%SY!L2)W)9bOg6}bHC|BybjHi zO01qX6XA5L?zvC+vzAnTGhYqG z|3R{g7}HHD^Syg7c*6Ce5dk!`GcbH>w?+epoQbPd8VVIT{+r7%lmZD!^P$gf&&&!m z&jgR);~1Y01rK)xar9{*oNd68(h1gpALgu9mTm)QINMsjOQJ(UyN%FclI#;=Qt|yk z^i3;O*=5Z3Y<}{~o$sMVSH?k~TXB<7r5I?aD8D<@Bg5J3tsGY&lG9c{zcFTMM!B{G4lRiAGx}>&a#2lPbE85TkUaC0kRYd-#>75lLrNON=c+# zEVq_LcJO<;kG4~dFskM z7_9za7Yl=SFU#_i&s&H2sK)9*;FyGXb9pf$X$z7kj%=IpK13uJ`c}B>kI^j^_zp6z3{CZ69U%9qJGRDt<# z-Xvgxj-n{O!$h?5^e224IdO}6j;pPHbtULxk}&ygB;N%j=3IB=8I|-F5?hFvAY7y{ z0$24Mj(FmAlJIV7MWz8rl)ptK7a?)hVc`PJ8;P9HJmu34)AFO#8o!dF$m1CnLoP&; z*4ts~9fPX8gb~!mLj^+!T+G0eU67N(j^UXD%lq!!;*NX5DoBU1{pL)-8)quXIj)s5c-s%1l>`C2!I%@t zLwFgZM~SEy!~T~mGpX&)SYTsa{17>EBx>f$%J3W>1&sibx|mS^FI}lb069cXQU`qi zR1~iC^B0g{{=4?5q@kh!8N+Med{PVW?oPtk&`p%{PD{bWG@}t(NK2^Njzc>KfHz=l zT*sLGJc8tuG&_b=CSpYYNNSE_93E!7IF>b^N#g#QBiww&1%L2i-tD(OwghZMr;4cZ z*)mC7N<_d;!b(y>zC@C;p36>Z)lw#(T!XpSwX;ed530)~pVOs1q>`}1OB_glqG_*k zBPcGGn}J%4h8lggKubL?d78DmeyP-=fz%{)$>-LF{E0bAo0Ggni$7jhCL)4v9AY`I zAOUm%w__N9MCKS|d9iU^;cK(1AcKAqF<;N}RO^P}?`?0&5^Vc$g*$ezI8vGkOhCc+ z{F1S8UDF1p-A}zK;Vd=f4&*9h4u`Q)m>BQtxfj0oeuRety$A&nNVoF##!u@GkIaEr zNzoenH#yJ*e9i7gWKxfiwI~b?LpSK1!9BO`3UF^^a(9j%cu>!FqcVmz5uxs{bf`YR zaGgMKGPv_KhB<;1NPfWXD~t^Hy}X`DV8Si)Eo@7``zF?Xyn+vWa~27zKzA!)+wBh_ zAob=uOC+#9-+IjtIY-1K2Eirp5jX zV#bIxhOK=aqEGHI@)UcP#U}ERlfw@MlE8Y5c*Dbr1CHQxSWAgODFlnD@1X>67p}8i z^{E79D9TTg&|0p1kTTGG)~KTK&-HmX>)+xp30*Lv?H-(Pkv2i9~hz`wXsr_Jpf<(flnY=DUY0hk6u~ z0!s!r$y>|5-Of ztQl10mdfSvue!soHVwq#i?e&aA0@ZaS~g_C%RXoUfxpkX3I~01cPpO-g(uxWa^lOl zS9*C2+$RidOiZy8Ic6|U!Xso;xvuufy8kshwLcVo%Z+7BX30wXs)rWcEaWQJiv6{ zzP!=-W4<__a(`cDdisa1Y@__fY>bC9_t$vQe>RYCv{UO^V-v0U~9#fAl8UG=8dFqj>+vWoYS+CV0)Z zwFJVRwL!`r;?=)O&W(ULg}(G0S9VXDV|d*(m3xX1cG&F!GP%F392C!3w)3uM}kF3{OO)g%QO$vht^bXgH3;rz9tdh!dP zyzR$P?HdMapa}3~?FmkPolKSxOcz@s)fQiN@u@7kpxs|>5MDTYC`Q-a?P#*u&E(JU zy$M{ac1US}iR;wxxeKh@ShOEcJ=ghqn8m)<)pmRM+jq*_izD9yc05T)f1G7u_T`UC z5Td0Vs+4ywv|LIi=r(idY~`!`>I)e*!_Z7o&HY|W@Q+3k_7x!pqJjkptv%nEU3GM7?gtIygwyiZKx&R;GsD7yADKu=4N@@b0n+xFXBhc?)3<_fhf zCV)9WpVbVGqzZvH`;)A@?DiX|>b)kMD`BjpvsbO7K<{lki3n`T;g~{6v$;~Sxk|RI z-V$gzdX>!tV)PdQLc|2QILf5!?gkRY;;7^Zj>$^yyT0>^$f<5T;i@kRO{G78=&68% z1M< zo;8M7Xym(j*M+2^$x~I_-}gPdsZu`*1x#J8wHPY(kzfAzO4~rC9?{)<<}!%+3?#L! zX5;rS%W41>w6e0XT)&8NecHMj*aWp?iPZQK_~4RTCJuSxv#be0|KJIqSOT2rWMa|@ zY2w>1Q---3mxfK&rQQ6!k20|(yuUPXb1E!QJG@$;w8jSNXf$uO1yakb6T#z-=wFP7 z3_oRE9p`}Bg&VkOV3M@;<}T(cm36O5VkekQS-p9iy{X?+i3?+4ONQTHEkRC-JD`U8 zNE}IQxR1ddJadey%eDO(2PxhdDNMCo{u726J!zC9-v%B#yg|Ds_pr~Zj_@r?Ty{5H ztUlxau{ z*2FEv&b}DsmlyFb)%>|x*a~RsE_>`z(VWmVi~Sk5n+X%U$J8eo*|<-iBI^ijB5jl# zUjrVZKR!hM)O$?&%)7APV(${(JL*Ycg0mXp6~>?Cr8jTZpL&mCdtFBMw&OK=c&cwV z9`{3ZqNtREFBy56RE_D*d0)eYtnIuK+w#xRXJgGNasSSls|v2`BrCFC(D+lImT0tw z(3Qq>X~ossA_OVD+@wq(&UTi%Y~3F+uatO`3AyX}4ftK+2gVkCy)38v%(>W%T4KD1%R9uyEF85;}&3q;mcEoGzH1<$m4CQ8rriH4OS2x6K4Ki9M;ghAhD}H}x)wASK_knP|Cx>wyDsg`1A@3sjinyRE+|6Mcr2hLnWrnd)y4s>kV#?f5DKdHd>W{ZY4e~UY=OngMgqOtJM>fUbcEWPbg3*~4_RHeaD(hj^ zFa2RVtv4A9_RC=36Y_Z<)8_^mfLo#_b+D9sbq%cE0sWa04wdCR|=lO4$KW4*o>R!W{cyd0)X3q@%uQIqFri4}5tW+qGs zxnKI8A6e1IYpGWgEC2|iKAZOoY_nko3MHVS*vF$~g2SM32jtKp(BkF**lZM z7`RTz2%$jE3QleEa@V8qx@#AOhkTB+P$zt+%yg@RH+IqNK1PEz%0xg04;lOQt`p4l zcQ6RTxOg>XtRk^@(aEr$0FOSmb6UItCy5ECx#HG_PZp`nB!*fU`5X&HF2q2I6z-bO z`9mAMzpUUUnGzScpUIq{5K~c?Duc<9Uji+5k(@btu;a7E^!{!V0~~XIQ4v{rkrC*XndIJH(&7Q& zVGxZD936|xoXLoitcx*QGnGx`|Gq_VcRXW->|L<}h9b;J;HB7sEdsmfExQp#&PzB4Lnc3f#S^O8%Eb)8&u&Sx8+)BgpZsL}{WmAU;= zOU#jQTqx%R05b%qA5xgW+<*psf`7BAt{%Q>$MVOl(cmDE7$kSHjud{uIG-heL$KZrRGT5oCN<7fFew-xq-X-z(gBfLfW~=v-Na)Dd zLODc4#Gc2~FyRpmzEGGx$1tt(^~?v)ZqEgVzRq^sp2&KArfm7z&BW}ePKig-{HOiK zQ*5WMyIm-1{4DYMEl?!7tl<(EG~ocEjPQ%HX}wC_pe$Pd!u!Bb(zvE<++koxwh5J2@$TFeL4#-;(PTU2Yr5=}DO$)FvTn>!7hj7CeZs(IhoZGdS;F!sL+E7B7$Ky>PC{wS!HH~LP-`#I z1M_aMke6EC#S?A>nW4>o7kOv>DLkUOEX^!FbIit9thn{|z$ojvGDk#0RJp%MFNeXJ z9H0R65-fmRvG^r1X;zt_53P~M-;{zq^U@Izf;b<&3{!M*<9ur!x~RfOv=PZGcdIXe z9K}1lnuEp66U!S?%j?}+%kb$&eqWq{Gb3fyHO2De7_v0>s`^*DxD>snQ4z>Fnz-r7++|07q)Yo9Af-|VZoLYMQl zz~o`CQzjFxDMF;wVYg#pH=+NDyM2TzpikjH!lvcc|DHov$?|z7p|s44mh07>+d(X= zP^m=ybRl^7h)dxg+0UHwxY-k7Q(* z^wcLM&3;c+p$49RSJUjFA@$c}f6Nq~9&WvKkEtj1{W(97-X7!2YRsj*K^L<6YX8rx ze2o)Er2T6~(ZtNFa%g9fTaD!Xd$t7r?dD$g!h3(0=3agAg>R1L?`pA~@eyfdNi*G` ztm1cG0!f3FS`vn8xeHiYHUCkVpVR;cs<$#oJ|!!|)Y)y7O{5X20moguTqjaP`QN1{ za?9IjaWD`@h~r?{@N8F%l@=xH0Sh+nn z5SJj?5=|}*IY&z5EJkSOJgXX8j9cJYY!;RY5 zL>9Qv0#w=*lF3lp)5AZ8%8k$lf7L^U9@guB$9Hl$urh#OD}k1bzC`(u4%XbVlfdXe z2Vc2^K2oPD{8bJH5_dl`ad-sk2!e}uYIMXT*8OM>Rxx+~$}nLz{bPE7lIm9a57<0346xHrKU82#+Xv}WEh`pt0o|{XQhS} z%T4{hINZ0|j%k-Vf5#f{&oZeN1r1uvx_We0Lnz)~37AHNoGB40dXo#JSYczfS{KW}BJVl6=%FDnA_uDetoqV=RVxJbg3}RNW zkcELs9{PARQY zsS}59&6k}vl?qCGtY!fc2#(@kl?VP7@N#4G-Eq1Jb0-(_!!Y<(o_Ht-^WfnqF(P}* zBQ=vUJnAkyY`AW}(-)>hZT=iwjxP0qT@YZ?rpP#SGb-+GmuQe*`cj74)1@U?>qo}? ze({8tm#}=xi_czl7yhVQatHz>YC8cTcpn8hSZV*7`d@2zlF6KI_O|4y+#n?FB{tJ? zb$X)b%w*%^BykilWrI$hA8TkiVC4*+we<#r~wJWZ`wyftw`}}#P z(qkkXuI{b*;wwBxpK&_w@pGc=hfP@joT=F%fmH2Jj6Gh{rMlAfXpVLnoAO>O^BVt3 zDB1ySqCO2exG*~UN#uHLOp-c+tTa4SG*}6wdruw3&KAe_eM_=F4_p2l@;WvRCZV*W zH1y`=NOdmGN%!7#CUdauZzbh^wMcP`@5n}<6jBBt8k|^3YreKmdb=w&xg@ws_1q;c zl4?RG`+crzRIn^xzL1ar|eM4kliC=(Pp0J0Oqn}gq%`>41M2d@+Wq{`IS`|6F#BktJ^vbT3 zd(}39{?XIFE|fauqZ+)Q-TUdjsh&+&7}#&|VTj!k1=f;cUr(+`V;eP(TchXq^9{q$ z(Gn08%-qM_^r;5KGRYV3;a4kOnHbrB^iF@5hCLQri69tBc zJ6FZwlgvTfzoz~-u%VgfK7zRB;$s}w+gVIgFAs6s`MYwsg6d(CxVhl@9uRlKb#yC6 zFQ9|O$Xsh>pz@LAvSgx?h?aJz$eM3Q7A zV_&V1LDwkVf~BCAz?+S?lw8f|WOMuZj$!Ctveehx$uvj;lxbkwE{V2@Iv_qpDr_}( zR9k5`_h?Vc3{P2o4;Lr*Axk!o{t&7gsR9Aqpl@fGjFDz1!#4$v*9p5BrFf67;YV5} z&+(DIj+=v)9_I!Pfd&PJ5Ag>86U7E*LB^J|SpvVB9J#6>qK{y|K_7dDq%pz05%Xm{ zRee#`Hc239?8Xty{F0s%)+z_ z6W}y+r*aK53h)yYaNs~1aNBkH95lM&hvy~sii9ayr#FHi%X_L*^p6A&#;mcv9O48R z2Zx0rCg`~s6^IAjK(kngkfpgCSMe%~y`3G8StA{3&eau1skb!YIK*pessW`0N*Xv1 z5>WLCzh)(*c#-TVy)m8l&w8CrUuuuH5;0Fb#Qy`sGTDp*J7nI$g#>ls3_NWm8x|@| zMP>+wR0#j*BAzbC#^MdOQ`*~n>!oV_f1|tjd9DC4pcdPrT{j}?s-94@iPQPD&7<{?5ftt802-ck&bcHfLd#BiBrownL;UlsosO5$|hyjyd4r z3=(dh4y8}boAO4qy|ksF{g2!^R}Tb$GsA;=)~IETKJ0IV-~X6Cc53wu?z^6lcjK!pmlh#&lP z1ebhXg9?SLvP4n!r~2j;57Bi3VQ70(ZF1!6K6x7Dm zm6DP3=0Vr|{`bm+kcs^UDLe~2Csj1~MGsFB&(})dD z)4b5>RKG?&gtct6*B8l9o;lmTVTP&iAiPqEl~M*rs^Zg1PMRE)GX!QM$KbnIop4yYlECSIe8Jtp^yBIC=UZ_C2&U|O^}oRnS%jUkCqE{Y9ZfAQcOyg z+Ti4B#vm`L#sCc{0Yj>3^{$VglUEi2>wNvugJx%dFSp%nhAni9c?+50TJ`{}@ zx$I7_mh~%Bvi*T^HANQ3_0NS^82k1R>s3{9XVG?^i|Uyari)O=j> zbM?Qyt#5mto&20)#!UL1^|dl*b=#nqbX`TIwB8R_7E8_&@{WeyX!!b>&4y-^=>h*8>bH?%K>I6>TOYQ^FE z8w?iw$;pWT+S}_U6QU2dM8)mnQwoD+?V)vAf`Cvt#fvzSPGG_V$?l%wt=et8(@c3f zRc)Fc{Ii;(GTTD~6Xh*~fN(^mH2En*-p@%vNg|#LNq#@LnKngg%FSENWbb;N_Gg?O z%6NNBddXsu-;*4i%_f}7JS>zuil-Qn*`MBx&Ju1RnH7!I%k%XbTJ)g-J;k2c(}@nK z(B`Daw0q(x@GjO&4IVm~AiTdfaOURNmrThE6Tnca6?Y#>cIMrENbF>~D zn!j`A1CE_VFaJhhb^XNF)l*mZ8B|bR8y)(;@4)WjPiEe`SUCB$U*#*6I-ICub?`pD zUNTfg!;n(VdZ{Hvns?YjxzC;r@K}45fsa(2Wcxa^|`6@+_`#JzF=m4X8K2kmwcd1( zCYvNC4lAz}UI{5{Jw@f5`$9#hd6$l%b9y2mkQQ|l$eOChP zX_j#z6pKs|9o}B1nP#Abtat$uk#IV##Fp6 zl@;=}6g}xscz}Hy+}S-cG~;u@LxVkPHMYzoVksyLh&})~gUUtNNr1~=Q{%07wv3;3 zm{!e*bCrh1ji<~ybdzKn8ic}IL;&JTrZBs;+lRxW}6~R{yk6f>OC*kUS zKeD?9$B%dEGL-UJQ7d!QHC}h-9E0nX{JVZ+7~W1vcjBh7s*U)42-n^5ihUQih|E1Q zSVd9SauNRK_gev5QZ5`8gWt?C;ihbJd~=63yVSPtg5+zq6XN#N2kJt{zC0TK)4};=v`^?@GSK3UhE53O8!vOz@323JGw;Jz1+cZ|$EuX)o zWHVkS5kxmFlY%rb&4WFCAKRK9?yUU;h49(6DLUbt5-CRC)*Fieg#<~Y5f?M^cAMW( zglAHzyazIlT3%S$hM$F@N~5^p%(GH^zMdEcH3uwMpkKv_`C5W zGP^<$CiHyqy{v^6F`?zVYkeIzw;ifH@yb`y5yoF;sLSnFF7d?kV?y4+Kjh^DF9z5Z z)F$98QGt7^B0zvum%eAaXoT?ypMf4R;R@#Duw#tN!q zFqWvACm}=G1SMwA>Ca>+7(P431LuklZA@LgvEC+#XP4(cgEtnY3c!#rSG!hE&1XKY zP=C3!7@hYm7UMj|NVP!i1`H^>(dFN)xDYvxZ;-H?P^Jj0aAr>`1E8dYZ_l_vHM?&4 z){DMSKe^A9cg2L`{%Q}Ek<=>A((P*U`L-$dimw7 z^zkNeM)|6CzFwuwcVVAEf-Thmars~Ru!*oB@0?>sgMY*(520=37Q7^s07bi-s0xuV z)E%EalyxY1H?&mBjU~RM#e*~Ry-3enU-eyf)d&6I@lnZWA}nILO;g-9kb^zuCOvJ;gO z_$;J$wi;QH7m~PM&JtaCbm{v%vze^zVY=q z{p8NgNd&aed;fV`vF~w>`QMJ6@qC2|VVSn3AZ=Z4`v1~BWm2Pxs;4RP45~Z+ zT+6&)@j}WAB0+PiM2CI}zIR(O^gaaod+sde;9mLQaq$S6yph-25sleOz4RGMJ87D! z)u&$Pn@aClyU&@gqQAlUFKHBAUOl@anH3RWYQ~qnY0|7UcKA=;{!^yLzA~k%Gj@E> zDp1UcxbrJ7N)0FH@W^oWq+GKwI@C%Jnp@+Q&XcGe*6yG7*nT?E{EUpLGsx@RCAhiE z*kjll`$7bxR3~;_#JHxwN$w*;j!-?vghm?m-`fR9OavxAaXdheOr=H)z1o3sh?M#` z{`>vjFJw$?&QQkc%+8~P;D=wvgz@QBYqO%NtJx$tS4f*0Oq>V1&r3qbbD50DYY z?Wiw-WE2OZlPAgFMK>NnB!v412a2fH`EPymSrhYw&Uuc3@U7Z>fohJ0`ri~>^E)Ho zT%*-24aeZ`Y%yPt_QI7Ketc@gyIztya%sshvW&{jUV76i=Jd^lnKsU#S&nu=L-<6n z$ZhT6@M8f#*`MIGU?}Y&wEiKFJm?{4&NcLWM;Vel)h{fj4OrSk82x2+bX2U`5e+1F z9|H<>|H}m^RKH8~J~V3e#>r#NMjIqd?9Y)MZ+te1;rqK;T|E0PlzeBX0GSpE?RcR# zVQs`@zpMVn<9U!2DEdL|zR6NF(aW*U;|n`1cYY;3T{?*WbK@XM3i`0z%#D7c`p<2O z>Ir&j(qGsV$l@6df1Cw|2ikr`NVq0W~REy_amU0K6-c zEQC^-@YE7^ORsUhDx0=Z<6jHqiVKgq6M&aFL#boN*jfLa1k(Wv8+-?Os+feb|jzUbCnfDY4aJ;qA+FtY!Hw;>f`OBeo=-2F3& z%)cA>51R9T9|q96f1eI~{;zNUKMVtr(7%fUKL6K4{y)RIZ+)Lup11vaenA3=#X@7$ z-}lxZzPS74G7kbtUX$rpnB2o3w3#u$?JCTaUJQ?5S(hNYirn6`*mm<*{VJex@?TJj zW_2`XVM_!?lSfE&v-HICspA}0Cg?eN>?*q;d5j}a0;4=;1x?dx{u2vY>>+gJWy#3f zXW4<@y%*3Mz!w~>NEff4{@(uo1qhkx*Wc7oc;V2{=7uv6D|tTuPk!X)uV$U?b&2;@ z)TQ$HT-O4*(nwuqNv%RzWKCyr-^1-02NUjYsjJJ{soYQiS1M&iMsFu5CFEbn48UEb zDWgx6#3)LjPLH8<0T2Pk;BQ-dldpp45szLGGE~s)7npF+5#(pFdNv7Fx;CHF+~g(* zZftj4jYOz~8l@C@mGv`{x;@B@g9oE;@9huuadS|;2|DW^=>HXUVAQu(>m!KmT?AOg zalWwg%<%o-gnRZOyh@Nw*WA_mOt~U#`C5I|a{g->IbWg6)FbC%NSzt{82as+}@;^8yiQmWvwCDYD!EOBe4?*dQI@1{qZi zY;mAIEB*${F|jQpd)|9Q*#QL=l{i4{@XUsLbVK%iE%oAT_t1|FV4?f(!*pjq|66Pd z6$+#T7Q07Le>n<hoV^0V<3Sj_;3M$e=9;u`BGg5gAi*OBrw5h6%gPa^8ad$jquM zvw#>ID02VkW~eB|SHWGRbqOoUyOQ z&K_4LCG60z-i0)gA3qp&W|+fc)HR-H73GBQ_18@I`d`Lz9)|~6H}niMff-OGi#Z`R zLA9(>SS7mo8i>ZTVt`6A4GWYg_N|eZ!_^565%vA?=?ii?8|bCgoIW@(A8m&A^_-`^ zhb-k_W-`83R+0;rvmeiE0r5F=Hz6<^M-;cxBZiK zcl4?szJJl(5=+^CR339v`*fUIcBTQTPSixJ2ci2HT>q7NLYN9&58yr|tWeKGIuXLV zfsQ_d?;_V*;`m)(F46uCZrMyaVl)~?g(OTaCxq79g9uvu9+o@*4{vW76<4!Gi$a0~ z2?TdYg1ZKn;KAM9-625m5Q0MpPUB8v!QI{69fG@S!`tLLe$IX4{<^;ygVEi4@2c9h z=A3J;T9nwuT5NvB%nN@(Tp>*{?9Az>2wk1ybIZf12H^2ILf(gojnRq7tb~h-v_Y{|Kuxd57mG^=_@E*2K%Z^N4dbsZU0@xrb zDK%j7LK;|ej&!Dci63bK4ErW_33YvdA;sk|D(Q&i_*&fcjl{tIUAK@jBJX4YH2Xoz z0n^h_dp!H!c8+hyKjhJ3!Ul^7zvaJ-@}OKfx*ll>g*IY(9fOz7u~TMrtZ=aCI?26| z%du13-gBn&2FCa0e^k~HN~6$Q!;J#={AoWoN6Xxl)pM9X0FbD_BJtM_jE*<-ZUu-j zcuTKJ`d(@ob@a`ELp@|m(J}4SSX>9nlM2!G`trW| zfcx7>bNF|lTokByd8j?0Z*XcC`f9%~8*f3i1F6o?#yNXe;hLN^RZTQcU?JpKb@v0LFTKyfo zitnQJ7dwW~xXeI(+BGmSe;-;P#ehh8Gzoj*na=mfdl9K5sQMGSR_L9u>1XycXV_N= zDDBz3-m9Sr{IbM6Z&pf{Uql7}18HUuwdid9>;`j^{h&%5d8$>#ZYhs{C7 zKEr?E%>RFENdl!Re%yTlaPuu|EY67YFLAx=e&zYTb64VYxV|;I31NUqX|Xx_E8xHU zLPwlgbJR0=`m)S;+35`oF@fu2Kna>nBe(^Cn;GtIFFmUbn`U%zY|ghoCEt#Z1$DS_ zp~xZIgqjH~BdNB_to$S1w7dQb0$uTGSyVBa zyv4WuXthaAK$PO{)sP|fz-bL-C}lB+i*7h^x zj;O|P@YC1OKOfDUZ&N~3rq@Pb$Qm-8iQqqK_YeYfwcJbd53kJJi2?uZvbRNu%Y?J< z%btuue(bGACcG%&d$+0#?!R~v0Jrj~Uw03LR~K5PVmaag-dDd5%nbue$xQ!r!oL3b zkNZ+82xhfh9<5R$(3Yz82L)4iMI7GQGr^=*Ji3Vf?c@v49QXB_9eM6*|D}lY;bfBO z!e6)n@DF^bHkfS1`(U^8mrlxa@yi@d^9Y6jD(n~|B0LcNpkzbh2Jol`?aU%(&;9i^ zu)y!2&YsR9ZC?O8WD4)w16w8LP!jvc(39^s?j0nvm)p!t-6#4pC<#n^2G5m~U9=ph zo8a(T&`;afBv?&IfK2rQijW&SGXJtcK7Gc6u%!XO3N_ZAL`{x<7FlewJRf(b3+O2# zym709rfOpo!b-gtzgZy!pGo4Vc z8exkX=CJJGc}Jo*@ctqWmQX{LxAh9*loT=Mm%`TkF>Nl@-LDwHF1K^AXM|FuoZSLsHDi0W@!yUDF zxqi)?4VzCwV^hS>VOFl`0UF@Vk$BPH{m$EC%AcRnQ~k-dwsfdTy_O8IV&x85EDJ3% z;tNcpjGNkSB;hoUi)F!ScRQAw&GL--LV0ipg1E~M^rw+!uO4xgoJf+VMIH%?CitLn zk!%Sq`4_KV)jG>(!zhQ82f^;o=;*lMpdmFJ*%{yre0>oLjYOsoEzRT9-09Pj;{s`n8_(*Bv@$Bd*T1I~_;+Fa+BsY2*W_56-#36i? zcK)`Y%jx)l44hfGIao)Rc5KCZM}X@oWt8gXL96-tIM`~U91jq+ppBVro~JzMPBvFu z*VNAs`ZqSFes#CE>vS+=s zwF$|)BEOh`3iYa+Dair2NwNFFg=PmSnh6S&JV9$raOQaV?IkY{L^nR>ZtB*chxmwq zFDSp4Df4|tLNe#<;pF7x68!F1l~;H<2g<=0zJfrOUTUg>)BBxj+rzorfi@b91m&qG z;4Ek0wCba%sOo`(!>%+YYKJ!?ylkmOi=O;JcotURo;iqoBOyd%vdjeN8x?ygu(9=bD*I2SJAUR z<>oOu+mn%&B*<@bbz}dA)-I=0x3yhUk z=KV3d<})`}F1ZTw|2GcL-a4vn@`>uM6oSLk2nAky_E_s$N-7Cv%4 zuGid{gb4J>3%^T-hDW%Lw+~PGrdB|Y4z6KmtKFcxLX-QK<|;saV#1o2#Y8zm>4?_% z+}%Zc;l`e*nuU1|<5l`_cPWGR z&I}_>l*sdlKY(@B%4C}P)wB+;O+8ddqn9UDCR~yOx2#oSsvHkZF=5lbmX>*G{<<0P z$Ej*wIB*~Mr8ee;*K#}&D@szb)?3Dk{_9WkxyhI4l~eCFkto#g-bkmsOL4}V^A}#Z zx^1~#u&PXxlHYyz>0zSib_%ZK&k6yW2sogD8(ggyD-)-3r)w;dMy^w*a;`ioAd=kP zyoc!U!OL(iKacdDm(%ly`;>8hxM37cUS8JmPCZ%LrXgGZxo(h@;F%xNpZ)ONzckGI zf81^FpOf+ZNhYMG3BYi`6+MAk$>p1{dr11JufTy z{&tNkBqI)B7gezG`{ac(%OHM_USGK}8_Xt~GL#<=i7&TT4S%^ZVa5vVFLVex^X2Xf zw$6}w1j|4D3Ohf%sVo5Z*9Mwq*43$(9QI7)3#TgyPImf^^j!}3+ktoBNs4;R1F zFSwF2gMh{LJi3<=xfZk5M=vXZeI%jbZQ`lxH6;T@$b{L1yIEfzA&&z#(aAY0lf&TK zJLh94a6kA1sLp5c4LXS@0w}jG>~|eO-MMlz7#v184}xxLK*vXy-aC5P*kJv^)TwNy z?W4>6Ozc&a^>V^ynzs_Qxs(QH=wZXvSeXsdv{!|H90yyjN+^ZrFH6$>76_Wo%x>&x zlmqGg#9NA=!s4>0)9Z4aX;Fu>0@Ut&uBeBvTTulbCC5W9W7LavFH1S@J-C5O<08}a zA(;tkoG0Ixd&GkZ4_X|77^;5})I3Wnuw=uhqEb9HX7p#I9bD?Sjx3Z^Vs#OS+#o9h zHysl`8+l9cZYRxaR3?7?OTzb~ocwVDEmsU9jTh{Pnjd=fYnd!rZ0DuB`8hiteY&pC z0#SEl^FDK&^(T`Ndw4UjgTg(;mi_ij#u4P6pH)=!+s_oxarHxK%R(Q4oloa1nwQ4? z6uaq&R(Ee(6Jan{y{kt#}2HV2@v1~@j=*?i%vnO@=uiP>XdZNew9 z*ZYSqil}y1rAIfL5VHxko{h67y;pbOqZY@xI#`jwKou@^HDcWNb&`JqE}3~@=uezs zLtyWsg~XU0YL%}`4d<8{(3GFd)gN0dvn@LuE|i*?E$fw~UJPoNJDq97mA9F&^{VoR zs13zb?e&w4ZeuTN)hAV6(48Sl(`nse0jta}UNC^;ekS;;j^yJD{ilp*!ka@fD#Uw~ z)YZ{3rB0Cmo(SguflbB+#(!S|-4~)_qs7NV7MOjS!Z_}@u6AOH=Cdte=%m0@-hxgtJN z@Ui0P*-?W_9%>V)mOUYTNY~WV=`BJ({WS0etiF6c-^8o z@A~@&PqW6lKha5ppPbZvYwgst`4N7r85CB~EA+|!jno$3@mbRB&MVnGlNde}O3Iee zyw=KkNE26cQy+J~=!G>XZiw^CI`UhMPk-jN#HCzT3l>y!XnJA#&LsjH_ z+v$CkyU1EO4spcjMt;xDlH404PZ2>hI8AbWgNdtJ)56gM-`m%hC)J~Rh1QN=Tdd{r z`O)!L|6mlgiIVUB`HSN}+kJb9ZbT)Q*`X8r=RM@e`x5PjL-&>N$Bt4l|T;c^+Uo>A558%*>_M1683QPsI5@c=08j%yR4G z{rB@lqcy6KbtMvA5|SPndVE&bHpH4sl-CGCAM$~f*vFatyyta(_$VPMIc_$X@Z6e9 z^P-xMROhu!BFoZYlX1L~%QeoNH9nk5vGb|+DVK@@VV0aiR7T^~0~@isElN^u9sPi3KS>f=C#biR_q8_;`^*t4W^2iDb{?T37*gu zVx*OuabY95o1S<~jW|AXp~ATv1wDG476cRWe@Xg1b>u(v4uavfnwrtbdC%v~^F{Lo z$Mf0?DqI}!@k)wF;l|KsyJN$kz3d@ECUQ`N5LleEB^jI>jve;oMi@@b)BpaB&GcDB z!29kNYExLWN};(_P*Zg3P%nPI=1C*z6HR7n4EfQ{f8k8@N}UZ$BTOUvC)+ThvB=&Nc_7s6f)Qc%&Z%TvAO}NS zKQ2f9yc0n1nhEMegCtbw!@_&>ko);QPcPWzJ>=VlLj~LrFTW2t>>hq3=nPj^yVIpw z@demzX-ZM=9hrGUh>W*0hSc_oU+!Ef9m89PX3*#!8By&~)!)oIf_w1b$t z{Az}7t=PDeTIxs`D`w`T*AKuJMhng z`9}sD?!|Csrk`m(+Jnn!0%9{RVqsqKIy~48TfZZHBii1y&i3_rUY%kNifRx?+A-xX z&KJ;g)xrLZ&;c3}rCeznpd3mSCo4nD!LidoT#4{KOnZk$1{+|Ys9aJLJ3e9gZcLks z(znoQvNURfF8BE5*WY9aK*#yxxZ#$Uz7mnMdE$HZ5dSXsr0h)G+7by4_7d;7^>xoL zE2l3!0I%&1;c`oa>fv{%t4TSazv{*oU+*wySXc7K)M-3p0uc5ZD}G~0^f3SwV|Y); z+7w*ptGId^q|QIUrB=B4R8l#6>SiF%DQY5BPI!I3U7IFA0vDh%-?Ky&(O?m7G#Kzu zvD%JPjQv*U(#Y!L+hdqOr}mMRZI(h1|E?_vyf4j$!<1PY1d=TNwu>(s(vIdYu<+u= z?ILbF{}WUsjnOtbu!z{>B=e-KQc0G7f=$@V#s=(h_s`uDIJrm zkez>UinQvVF5mnL`Lv!Pbx$pdaT}&J--_3?-z>XJgtRz@6;9yi*LHP6%Zn{FDY``@D*h&4;>^ze;23%YGsgxF@iJ;F@9z^*>fOYbFe} zr`wl)#kITmrK$Z$@``Or(!!G3SiLN`A#j2Ku$A z%m+;*PE+iy+C`)3ep8drf@$0bAO7wIV9%i{dWA^eLbZPR)%vKSHbP%)2fwKZ`-=v> zr@Gw`p-DuM0~pKi3ESa@rw zX>^Rd2ygKLc7G(~}}%V}V_H%GVxNV4~NF|dVe687tu zOQ>~>2+m7aUx}|?)KZUZvkbU{P`^|v*)rP! zGH(C&cJd?D=P9^jrYL`BV+3LX{&$tRqpE6jkBxp*B%|$dpub(32R= z^Gh?-liN|(55ZqhH1oMbxXaK>(c47@Lke*PcNX61DE-W82rJpox_4*^DUa&aXi|hK!4LuON(MvGqqx?2briKXuI54e!SX zX1eafeamRZZQ~fF)_X;DOaWLJ#cc2c=9}KZUsSi`STosQKz!xBF@2Xq^-gy;>^)vK z%l(`!s6(pl$Mq0D8_<)*2+ZyPe0@pQEUG5$b25i^{Q!)N z!j0M|vSauFhng-CN-JiF+Re>&YvLg59V6u&)@8+B9c+wZsbY~G&79Db z*@0h#@{;mYk(hJh^*^0PjKtPz+ajADp*;49x>q|{e7?K9P5m{n@q1=I!yIYTjq}=Q z^M}RxbA{nl$zp}Q$Ae@~?nn}x5g&CWg9 zs@gArRKBBRNaC`)=PVaplghCP*jpaS8*U0XMX9Boo;D9wgx_;no|uW01%ryoJ9qGH zY*gpxi^9qhZd~nQoPuj)R8a#8-o`xx|vxRQvcG0LdL>o6gC zmGGB4Mk|)q8K(z#tYTrESdZT0T#at4t6zT-*$ z0G-tliWqH_iDMlKc! zyHXb;BIejwAWRIxR+ejM#Kn8hMI7#PxeHK*33iE+sfSt^&~9SneRvTM7r>%`t&4+R ziI8rsV7p{O4fTvKCsQfgjdoQHGn6b4Ub7KInN;Wx7kVGOVk&>jncSfwy>>69&W33m ztzX3{*3;jFhAvT(`O}>G_ZKZ{Jh0#Ibonh?a2LRA7|oAy~GmSjT1k z)fQk}Ij9Cr!Yds+GVz(m4Ko|65`f9@tC#i5bOaET+za6wDyEC_>su>>u_6vQr_!7s zT18!Km2)S;l;R3p>)RtJPalDBTXMN^_eE9`D~K6^ zt35@>okOhxf5yaQk0dY?$V{kL?$~&M@9>jYOt_PzVH@cbv4;%-Wy!*P)T%aIhs0bW>q(dCe#L}zAd)Avwu+6TB^n3w%`ukc3N z8(8ghW?w+}DW@~>muiLk@lO?qqZ|OPYhseaTw;kx!8Nh#dHZbTu`J8lt;l)ztII8e zO40$fKaIZ_6RFHZgS5eSJpE1WFVz8V?rLur88)SJ0v+v!NmSf*gRc(wRH3C4#<0f=&7F%N<{7w&CvQkE9ccRs!#z$Zq-|RO?UxM)BPsq$f!OF1&Sc5j%le6erSL`;%HSTL5PHaT zBQ?r3JS>lGzCce0tDMk|TlBP#P48rkyPh=Qx!f{IFx@B%jPeZS`; z=ea;=zjK-Pt&+>!CZP7FmM3P-Gw*Tyv&Bkz2J@K@Zx z5G@%uO;~2-I?euHvQvLd@4$_y)S!!+Nz+kf!Y4KyM<)w}wR$nX%<>sVUo624&#kSk zdtCswe!w~7v0^SudL5eiYhtB$J>9+<*PpP|NjCnqKJ>VXKs6l9nXEl0<--HfLUJBd zy+;Y}Nr5dmo$=6~nzDo%psckk+8;?l;n8pcj|7C>fqohMUVXo1ASya$nRP&0J<&yF zOLFNMDn-l)+=n^rH@(~4Z?10PZzlh=frqhCD+?>qHf=0Rco53#dhc?~*zV+bZt(`A zudiYk3Q(#h_mJyCi_<7aczIJtW}aFXU89+?Gyr3ZVPE4m&a1OCB%-$HyhEt6F|=ga0V)qdS=oR?C}5Ava2d!==8E6EYOV&(T6ehU z#4B-2l5&_*a8BVkXT?*{{*Ax0|2Lw7OvSK%dZK<&zG|W>$R15gcSMlBe?eO|TH3je z{^^-3>EiqcS6auc)fxWG3DQW|DA#wO1;x(6&c$T@dY}Iphuph>De#{5LNB3YqOS5A zz@m5+V;I{K0Fj1P@_F_AFDZ`uX!p$cyn0ERSRi3G;nVwe;Y6k{`kMu=@fqIFo1Nup z;gtdl2@D+E4=s7$IYl97V;H3)yuC|^W7Y0W!TCkgp=&HQ<6^TD$#pofh_f-L0-6Dk z2^);ixu+(XKd&UxZ^ymA`lp7cj5w(1N|G%;bESgvYH_-lkH?2g-DImb>8d6Fo+1H> z$Zr_IpCpTvV4R`^0r=zCuK$#3BjSLDF&F?vmV`tEt<{`)Vy(^wkf;fo5`>NS1ZOHA ze@NX5)(^89Fgu6Vr4no;jen?SenO0}hoJ%V6~a;%j_}ci-GJumtjvEQQ$&PEZjath z-o@9q<^uuTyu`#(`?VC65mxQ1`EI5GVr4yy>8f`kKprBW8qcE8%=}g$=S1?X~za)ne=Mof2SwOaqAN9Jgmk7t=v5O zsXWjzL>&k>Hb$CF`)}SooNw+@As#Gx{n$+N30IwlPOW}P$p1N{u9WwC$-cGRl6ZfT zOzhWcn*xu-WX^={Q-@^U=%ez(yBkhh%dvzyB-L7?0Hl9vjEf)4la-*DN!jM3_~<{p z{ehP;)|h7IBS5Z+sDV$|4U>nKnV2zFmPlhZVh37}nU5`8Azl83e-=aiGpVjf4$9(6_9H@_{K2Y-@-+N;afhgH zu<-h=M&vf4wztwPk{0eelA~4Jl)POootEJPB!iif2OO_wb>_gCwT(xH`^QUMP@)Ql zf#6XT6&1o@1!reAnbJ4ERGYm1kuY@v`Z>cm5C4lC8qcEZY56`dGL^#plA=a%;m0Ea zulfVuUL+N3@x-7uuF=Gz1 zcDQ?3W$&DAJvH(UM*_Hb6`c)WM#9=1{7F0@FK^m$2WPrh2kvwMjZWdI@gIp+qnt$j zDT%-E966~?{MUxJy=dvR2>dks*RzufMVbu($%`+#BX)Y^1W4?qN6s-D|BP8-Npi?Y zgU3OMwN}7EJdPG%&xGEozlR(^D^DF>SL)2Tl5%=Hnt~&c^ zd}%h~^(F*ftP8{>=ny64Z%c>ny4|41(;o~yhx0|2TH zdzbvRTa-^R?z0LEEHFT8afJEK(si@vN}bnT{0cckID>E2y^aZF7K00fo6+jY{(*qG zh#7j+N_bonn1Jzu*2jmzc0%PP{RX(+hCfm5TOc1T1MnX{0)INNn&X4f=Kzn~J%1o~`urrZ z6U?QUc6%r77#N&xzm+w<#wVr3w?P`10a^Zihww8y*QhyUfz^+vWh&fD7{X^WvXI9` zm^S>5gX7>|9HUaVP1|H!#hhSbk|i|oQh3*xevM!19a_Dqo_}$A$Vy?le9uL1mph)U zpVFtQ%cV7vUSD)pDB6@gC7qU=`3TwqD+>f2r1HYWM+JHH;)`H_S12f5GNj$`p^g|1 zf5i$TTD}g+PHIsPSzihd_UncMYTEkBV_si6l9d>?s>YM$6q$9l62suXwA2<`5Aq(= z`SsNSwTTXT;e(hOX0CYWsfZih%02wg!u(lZZP87Sr;n+~k!xi^wMf_Q)QF7VdYG6q zq4&cCla*e_=#wDaQM~;TY?5USW%o_wtmen32>b^sIN3tDt?wcy+rJVl_b=jqnX|*e zL>+gSfkzH&zkV0}u-=r;baex(PeWibprZWwhTzsoovlLny;Y9fb2=mm>`H2r!%pCV zN=*8m7qet_MNv;|(DHqT6i-CTr;W+EFmCtM#qeyd2137(JnqTK-3mNHF7LQ+3^sF( zHm>1f3-AA~_P=(pm@+p0?Rapmq5mq)9T(cEx(l}x+ep5uw2T_@2_bk@;2j$O)NyiK zWI@zx%Sm>~BiS&C1H6Q7ds@j!2lAq)*YR_;5MH4Jr~+nW9Bk7WiO8C+xjKBp@K5 z>>tvmum9-@=J7Z~q!j1lb@%k7-tK&zOt`Isf(jN95g8gVr$O9BRaM`1-RF1{)4Dd? zH6G~i2^oJIztOXd9Y$*xzq~4p0A#CrNC`d9V@>3^;))n8pgqdn4{rnoS;|UC@HhB; zN$a?u;eL^g%>hXrULt-=Mwc4q)Nl zrxN(zv~5<`!NI2X$7%0G6}8u?e2%^vcdsm^ z0f=5UO=dfVJk9Z-Q^R>R<;h!UWx=}#NlyBs3Z|}`UWV}G-Sz@ zg>U_f09LFcNK&-eJAoQ0s-n{U*mfW0W5W}Xc{$`-W;D>!*Uu|r|A~;pRrdGEBO@Ws zii}-jirowZR>^?dhC3p+=THvF3{>pYcaPt?LNV>4-Cumtse!lLga&bJuGmi;-+mcN zD^qv0n4yk3YD!xVRf(*FG5wPqDxdX9DPAoX-_~eF+cCM~ZkE8M=`eb#L$Fng)Vksm2O{vavOQ zT)tq_*aYZ*jopv<plyY6Pr$W{ z;|pi5uP2*zAO{khsavvM_rFk*9vS#a9WCT`_aeKQ{oqc_q3FpJK@=;u*c}~xI%u&d ziy@0}7+S^In$~vr_6_svd40C;Sx_OCCtuK$^Uk291Gb5BG>T0h9$wJKrv2T3QF0g> z8oWLPAl(PbE>QgZlOX$RDXB5c zU#d6z*kB83n!(M_p~0^0S#t)+-9_MWcOh+BK~P)zPd)YD=iZ{Z&hImmq8z+i7MO}w z(i0!<&K;|*Jp+EOzj*PYy>=V5a49Bx!#2N5>2{g>pXSeaDB6EIMHR8O$GUZwxX}nP zeKV;R<3|0CtDn}XNNFh}_cu0f4reWD+?g7w1=zX2PFUcXM0WJ`F&0fK5)tLV8A#ab zz60JafC$69rQrU`%dx4}#l_^*Y&N`*7_?kTk}fk~O33GsE4Iy9+WM_6{k?(~1RFeO zZbQFDQ3wf*?|2kLxr3L_$Io{9_U2M3!%|5JTN$O7yrxaX~u;bosEkem6QJBE)vEpltRSGGSDC+2akV|Qd=r}MYl1pAch;c7q{hA9#eFBz6uq@QqJ_r1IFpV5@)!E0 z!VFo-w+f>fG*als`;LkAhHO6uaZUbMY+hLb5H zmjuWa_zi&wTd_Ou#9f1$ECGzrbDG|0-!Il5{I7|qh=V9V|C|0d$Ezzsz4PiVCB^7l z_7GMJyrMh9P*OL*SIY#T>7ll)yiu3%p@q+^m&*nZPLDn2NyGD{)lquphW&iPbKBW+%S@M0ln0S%+}#0c#X%~83u`u4CHq6K3<-L998Cni?Fno$M- zAi-(nG<)?&%FT{zsSG_>Mvxx}~*v&8Bb_!$^q!iuw?`-3hQk}+aq zYBD@6b0UruT>;vRFX(i=C<+;O+eyPoOX^+A%9GG-D(DtmAZluGJYH&{WO*M0^x~_h z3k?q)plqJ(-`vmfzH&Lc!_99Fy%`_?JvDQC>^a$)jYO_J|WzHK~c}-{@=L&K`1J~m0f$y_)d&z!n zvcp~@s;t)BusXQp1O-IF5={FwiXeOXfu-kXv#aqyWC7E3fL1$~;jVjJYkX|rc~j>F zJeFDFTWcwrZ@qC=9!~^fq~v`ZHeWN+w2}}NX0Ga8@t4scF2$S~{M`$14+$UV5(=^s zN=g$rZ#SB?MP46!uuh7PtA$K31WSJVRp@&B1(a(rQE6ouPOCH1q^l>b&7YL3cX2=B zZTkUXb}!?tjFGwmv??ZDh)`6fVs`%Te7I@YKuLIncO`hD;Qrin`P8srN@_MlDXg{x zr_7&}=O*q@fX(C$jtwB+#^$mjzGE;qqtA^h#w4N=Y%7}e0lt0;3Ih@vC4!s5lDS>F zJ$_K6^<*??LSL)z-UHzA9-^m~NXyLPTy-U?!(pjT0_YHiIfDs|yv%-M9k%gZEmr0q z72a6}M5)UtsM8_k}8Bv(3=dMk>3c+FZ2nh3?Dt16JhsCAjL8hob z$+U`o6t@*cMM1Exp*Tq)K*=ALFd2bv8xPrCg;MKA4 z1s$*kR&MsWvk=d3-a;@Z&dJ;`&?|!rCu31&jhzd<-iM zC8hgDF)Eji!NpF!7&A~$Ad>npz^mHGQ!)Q|E;gdYV?VQ+$`)bwF{2M?wPSaC*PsJj z0?7Zx=2okEmegOZjIyQPi#?@+Y|Vw_)1#uzhAS)&v8xXkLreCF?^h-sH#OPq2G8VL z3Ruh+e0E^6#4oxm+JtJ3FK$d#7Jx~Z)w9*c^Blt9yaah=(zOk?da9T> zHn`nhVYyy1u2c-i28^r2f_!t$R*dyWbx(YUdJHu0V-6M{XciJvv_3k!smJ;kZ~8Tb zb#r^M10i>Pi?5QMQ<{MWNX{YwufG`R49}#WbaH9Mgs3NfVg3ixGHQ5?Xq{-&TQ$Tg z>yK$#&wXIW$18einaZp;)ySMJ0?&EN$!VK^Yk$GceUFq@e4n}{vq3ad4f*nU3xc&T z0f0~-teH>~Xum)P<<2SXsbT2-$yyagoS#;e_Y6}%Hc|TwKWqXWWK-WeF0+>`kntmouoU0=vFLm8bORZTxm`#mM>A43g zw|eLg6)*#UY8(p>B_~YSRBv-SIT?abFwNp(E*>D@@9d24-Hk*Wy!2psf{e_0oNxlS zOgWOxDzK}RHZxHOhJ<8}W-HJQ5%gf-8XG^YVLU*JQHeG^_I%{-d1^^M7Ct1=0LgBD z1*OOL0|GJBdZ6O>(cp5iaxozJHPa}gtk}%!3+$bj0b!L>|44&nVI$^;Sbch~$C|bM zs~oEqDk37}Egx$ST2Qvx*7`on&{XWP41~etUh6;1)pF*F885b387};`E@U*7jXCi& z>TvETNqcg9fC3~Mo5+yL$XACv&dK*ZsDdi5ovmlkVdXJnO~VPwjzIh8-=me6o7d>`(Ex-9WuY*{uIwrYhAy%{8|eDieGFN9Yx=mIf%`~^Pi|A- z{KSo4@9Cw}icGh%@jEik=T>*6+TK`7ADqt4g2Pd^oi!<-n8!*W(I7Q-3lClIcij54 zRZ*WAqEl-Y2m2{)X^xj!j=Y#T`j2qNgVqp4%=ZbH|({;2Hv>2Mf7i5Rl5DpqPEPt(Pom*2W!n^{y_k-1E!}h*k9+)?0(p5k>ksov8Xi>(b<~g z*{Za&S2Tcgy*vD1Lf%Pv8s%aG}3yiZhJ-Ku~kq3n2wctnh%cfOUdyCY$zG z;slW?+|S*=5fItX2{8IzZUo*qdq3S>7<U$F%w;-0EBIj4O-hBBT{I^xH1jzE`nBsEfmh$?whe@r{HJ+QOpb_L8X1$ep5mZlpFK($&=4D61M1&xTOc@7=&aeFMa^c8Y21Lbv2rm{Wy z^0&rIu2+xL=ci_RtR@d{9&gW_F=0O+@%I9Z{xg~2T-EklRGIqdL!Rr5eSDu#TtOFP7mT0+M<>?m1jBT)rzLl){?PU;^R zo0q$Fguk307+otW8g8D9O+2(b(YcaIocfMS z8ci6yZq}7BxI8b|fRV3zJ^%eeZq?7@``P-z_08eVt`)yMC@Ol`KH7>xRz@L#*n@~C zT<}co6RU#l*z5bN*gRu!+8HSV^Aay@Y?<4>LCK$epml2Sn-swGQdnaZ-+EC8xM$ZPfD z`j?E-jAtu_RRzMk&e(Usk|JKDKqZ^`NORWU!v^H${6a(&!UcXl!5 zuKGtMU#k-an@8{WTfoQfg^03W@n{-dGz3&5ss#Z70)VVimJ`!y&tm%A1$&bi^+xG8 z0$XztFI}125g#r2!zUQ1+espG2VzP(v5Kl?mc%&Q;~Z&(pl zA6yvGh*2t3U$THxGF{1y@oSEn3i0wv9H?^|sh{(gAJs{Hx#x0^1-0|{E%c%#%CI|V`}+3 zxAlkAwO2mX|`>;o}bv z?zHc}-{Z3x04hsY$i0+7RtYnhDH3&Dj+syHD+j=8@-qf*!|O|@pS)hdsW?1nIV`9> z;qF~+TOz(%oLZWz!u>U6`lJKCo|$_8X#!VOS$@|&8hj=r|0(6kQ{sOU1zpxG8ytQd zHV+D&TemlvvM_ebMTe@X`M;0nw#}6cqarZW!WJh~)v^u;F2cXa#OQr$Xh>(zmyFF) zR#SRQMk=Xh_oQ=P$J1IdquHuV=fvm;^8g)kJI4e>%nnyi$Sc zlsLv30Y!r)}aK3F}t(vVrL#3 zGk}Qay3F`CUOhw#>Yif}z_8AJLOT!14P8|kTZu?UneTT}M*S8%K5r!^9xH2_jZ9o6 z{j&HH3q9|&!J}YZ#cVgF3kc193Wo?R_-?>?6@++fcE^|_3H%(RMFvy>qN;J;mjrr` z&WJiSrDN^V)uryqZom0I;PfE;g0$7LSa%&*ya_d2v{preFg@Xn5VnIr;SIyVsl)g z!QgY)L5aBzyS($JN5|&+tCtu1gd^F09Ai{82~CuaH)dzVn%fccxFqi! zpa0Ud!Azw8|JeG29P&=?>}c76$1?x&}s2x!NTdh0W;zQCF~IZK(3g-w{}r&Tk*M|vV}#|)ysn86V4A3r%BQ+m1DL}eF& zFMHe>xb81An=_8|dv&P}nH+H9;em3;KSeRwCqqF$UWy2yDA|}F;55$eBobcd{#TXw zi}C;4*uLi<2?`!4VV@oMP5yd&8<4O9?lQPYN5Pf(fVMrzrUr&~QDBqG+?DYFb7D%I zR?E@TFtT+3!IKdfrPqPv93XX3FhNg}7Jg2Nsr6Z{NqvLyRE+ospU`Nd>X|izk)F0TR53YPgrS}R|Pm=B*6Ih-$ zGq>)a`9VO-c8Z++SCpK`<#rSImEkGaLgcCB`DWqss}_OoE2qg1lg_NmKKjn-&5!1W zI;o-g2bz(-2_$Rf2#Q;uJ)cVLel2p6Q!HS#p+cgIirWfaoP~Gei5Z)Iox%P!BHr}A z*GUA6`pSM1^ON#_6Y-lBpI!4uU+qGyR>@wS{?ZjNr02xXn#Q{1`&Iw29ALShn)f~e z!>)S@dinAO_VzRW84#gkou-QaGZ)?0p{Velb8Ehsl{PioW513h2S!-o%U_sL6sKBV zz#*Z?bOJnWgKnmK|JWR@oPk$~4^RI$GgW$g1x$gG2sN|4-O2`-CWL){g%sXqDLWR- z@SRp3sxtD?9QzzaXgK@MyP|>rXpNT*z_Bz#SDAo?)FEX@03q^^VsWhY1(=iFS_ms0 zhXAI*oF}9wvH50Xx#JNAwZ(&OVNzCw zBb7Q;1t+Tv6hej8xOqk2EykUX7&!HzOMOjAe1&L5MIW!84RC+Ula>>$H1RpGzybh+ zK6$obG_oHokIb~!sm~u)SR6=F!1;?2HcPg7(&t@eH1fKy-u$doNXDy-$RNmlj(mNF zvA*KCxNF{JZoP9QII}=CYn5yhdIW(`(~KFu_}4yq+6|Vn=(&$OJ|Prie)~{>Y!HN( z5*6#=jaFX1B3MhYK4S)ReuB*0^)(c%MHnWEWZIY*dWpnence8$_lVisto843&CIN+ z!}v0693HCQpOrI1U;YjD&W;+kllAmi{*45h%ycY2num4X`B9O##XOs>y}LaY>GY;3 z$ue2Oziz07+mgQB8;?;hS-YmGzq=;`*~#t{TA56^{;vNRkg~*S0>pnZ5GtGQ1>FJB z!an~$MoJ3f^u+09Zy0oXFQ^BMJ4<1%M+3?GdVI3SK&V?}?7yt=xp7p7(vLNl1t zt-EA?c}Wb?sd|!^9@jU3-5jjO%)wfQFQ93^n$z_K>Mt78ObQm`;_n}ztUnvB2XW#{ z&`~U$zJ8!lfZjJj!Hmip>=l2$#{)bC(3g70863H}o#gz10Bdw%21qaa`v+ZZmB;$2 znAnf2d^W6AH2dC6B-?}3+8ce->%4P{CgPpaPpy{R1%sUV%yEs@LP!(6jftg@oUgz5 z*}(XP>^Th+434qm;GF9DdbT4QG1k2! zG&=taRz7j?^nq6os>yeaL+OseZY$e<6aj|p zwHLXm4wq%;_~A%?h`*kbTx3>?Vg`+WQ9YLTW!V2yEWC~LM$&V+~GgVZr zW*go;Vx)a*rU%%tv{B`MqtVi@X0mmkU>0Z1T`Bxk!cVKrOHOCp^PDNxALm`By!Wvt zk#l)usC;nLS`8ASZL3gHs!~3CQDMnYMvEe2d7<^Vd~6|vt8?sVk)3T>qp136I>3|= zZs!CUGl@2L*-Phh-W^U&;;?AAyN#&{v5IWVz(juF7byOIi580T7A2E2r_;U(*gxJU8R@RpQcqF}jhej>-5<(kPTu#KT6Nuke(#y-;LjNzF zrK#$HHhyxkOmdzay#6?btEgAF3{v_gqV|TbN3yATonK;S-~h&{=VuV26C<#U7g#fl ziW(LH*CtimGc*;)p61Jri;r!3gTX{Zl!c$ax~z=9v3DfCmVU9!ZceEz1SavuAT{Yr z&jI>CM(tY#zR=p8w0~cH9@Q@Wj0+#=5@EdM=R(6)eKllBbTBqh11^rsW7Zz>*r;B? z{bgy*iB0{(M`nm=7J_j}Ro?HkS(w2q0IF}!My37%mKpj`#_nH|2-2S~hOM0)3{IBr zLGLzy;Ko~{oL`t89KY**LM_FpO$?p9l%w%6ztmSzn!*C9mE#h5YLZMRKwKmKCcv`Q z_ZajW$zAxb0^Y<2O>j-F`&-&wuI8E8JlvcrWSpioq{ejJt^`3(3%Gzb3L05#q9nfS zBO>L+JZ9u<(Kf>i(=P*gRaKK&53rL;#uA;TAHc@*&$3p0zOBOG$2RTMSvCuGwy7*T z`41MmdONaTmb6lvz7biBRnNFS0?pqXM``7ZEFV6VmUKyJ7>Z>Dywvs5MQDW;1R?RK zNfF`VF<5pp;7MvdB7Pem(nrzA&Roq(O?Tn&)vu51qxdZW{NA4y!4PZg-fQpolv*Q3 z?k57hEAVXIOgNIE zpftE)ST5XZq_?$jTvSs1Y0=#tKaHR_&-V9WpMf!W_pD4jR8B?kzt~FPGzG@k*1gD4YxlLyl{v!cPAVjk9oa% z?A~1;&#d(g{dl5&OScpM6Up=Hek3j2^OeOETBDs2y0A6gJ1Sv8ZmLlh$n(pPAir>A zzY&H1bBl+mEmAc&h=A?*eC*pz*NyO;*4!niYG1o^CSA%?y-?x_+yY%;Yu_ifLPm2K z;X3UoH0d8<-QM95HklOwRl7N}2T11iR-1VPTcJi}yXIT>keA%Zj0bZ!js?JjU!j+` zx72Naf~%a~W_5@Oa=Mnx+}0L=Zpry&*T~asIENqaPKR5&=+hD&|JrA`>ff|cwpfRtgY1}v*r&#@vN z+ou=J*QS*Il)PjC3TJ_Iaq)3umoxfMvk~s(D^aZiiV1J``LX({Q*#`?nXR~P= z7buS4+vQjAMsp!7yXDm^ZFLpeFc=HpaL(4|eVg~+SbddI9vfwjZ10*2C?-U9qjBl) zx4DWs)1AbNkz{pr*>LtchTq6c^TP0lo~i?Qzy=n`t$muEDx z-K4yq^W@ss=8#lzCuFgq{2^;#II`@cfQ75@v%0`%X{F13ADo5SGr}sCi}Pv6V-csx z4YKp7Hp5Y$IO&Ue>4NAKP=EFg3E^^m@zjIa-YV`t3*1$GmuoP}?p>#=0e_;$v-dpa zTXZuDHaI9)n>~?0H1vER2f7piS2I$zR?lzy<%4cx(&PK6&6WiYl|qSx@>MCdC?)*1 z$HSmCkHakeB)2;cv=`_jl(I;|$qDV((K0TBrG(0xc!oa?$X9z~i54SXXtJ^Qhs9Ah z?@Fyhg2Oy>S%!?@ZVdDZwni)SsvW;AXVn2z*QN8kKNETv7^$!p;e~1ip$`s<} z9xRhjZ9yx3Tl|7ZQ}E#Kv(l(_S0p$ko0!g{vDGH*@Vs0Z?&}#*DP&4ij2KU81X%S) z-jWH>%8Yu6S6l6+X0{PmY&OSUwe8HBUb>;LDGs!VuZ{mX>$SD;?}^06mlh%e&1+fd z{qhjV%uajS#>-g7*q=Fp4lj*g7miB&Or{EnU$q|)Kho1q+MTIt68)GF(SI})8cDV< zD)nvjdBWOUtXm&}v3{KT3cEXQNfmYvp=0I&B?ecYPLJK*yO%XRAR<#rdn>ectRDHP`ONOgjdbCQF}5n$DxUOC%+1oSB090 z1UAgg3Q9j1+2oO;`^lE<4H==2*rlH9F%GQ?5HlSsP8O4>#LoO(io~VY=GZLRS;`Sl zD7{*FMJh-vsX0K`M&nv`Ru^z1Z`xfwV0h-b zD6ez1M{g(uE~4T-_B@2SZrgM3Jw}_}RM(!(OqCo&EFLCiXxoWlRUpG(&cg6{@$BlT z4lKN%nr7R~fEHTay4GlJV-?KShYg<5^tKX0TOi6C^Wyy3PTvF@GjTN&;Fb~Eqguc1 zu~g3#^&`Sa9o6DHoR53J;IqhGujlkn#jg*O{X0AKm zOjRa1$xeBLfI7TknTZ|G!qHIjlN`@%uq@>b@OvsS8O0IHbI!Vyr-;o?8>EbkvF)&o zJ3rAMtDh=4sSnRq(rWO2%JYZ0NS~UkpU?ScLvR@yE{x_~m-22mLOP4PHLOd#mI=#{ z2)`J1()(o{YdtcV{CpGS*d;p{%VxNhf@x@e94tIXx0u!B2*XKvC)xM(#es|`80LLz z7(|m{5G7mP^pXJngrthKqL)v>2h@6pE#C%iQ93*r z%+S~oE}A+R)90pLw0)kT?~TW&(sDn+gWp;K&W%AObGy2R5D^Qg z;&?8g*KB5GiFSZ`EmI!mNmn0_=}!qoa<#Gsk4XI2e|PMb-Wmg;l||>F@9jaP%ii_E z+uJvbQ29Cbucn~p8N=ESCYL|6nqdpd%g}wBLCK~FQq_39zyv(~+?3Ukd{IB(gkOmJ z&(F7WGC!V1+IHYmh`4YKOTy8Si80jS{7)}{I{^U$I&h9$i%hQkYD($!4C54s6Xwq5 zeI?v7hpQo11ndpJ(^nXltPT>LZC6#Nqu(aUA1tIQD$*Bv_vxMOA|fGtdvZzcN~C7C zY#`Lq^3TBYG}s}@Y-j;q9eBNY4{tVx)PR=`uG7D@Mbix7YX2T43c)gzlEOVK_li9I zJ%caQQWa93j2*ll*p9_~%8HlW?_eKE zT=<_CB+l3{pLf;YrH}|1Xx5-Xw!OPm|DD_Zb-BV%rfe5)vPoasje=LoEN`^X!ekL6 z$9YZw1vNx0hjClw(mhqUbZL&Rz1m_UVGZY2#ZBUL zqvUye?AMmT288+bD+Fdn=HgfD2Uhi}S%uqSQ08dUBuQ1%;`JguJ+IQAY4Hb?_N~(o`RWM`={Qj%YZ422zmA8`ki1XTXbkEYp<~=zqiiUEzXYHGX@Vw=4 zC~jQ9-Tbl&mXjN5xQmQYNaIX(ASjoLHEY#t2yKLc{d39FqRo=Z(w5krM+>BW*d3qK zN?{y~B%(pKz3_lPXQSr)*nTk5Ngu3A=pQANIH>a# zq+dbgdw#Y~+f=Pp*@9%D{_IO!bMfAUr5vxX2V;yX3gOc>t*iy-xT&ti?aIVuoI6;{%%}2~)m`{r z<)g!H7h9t07d3OR?{dE{_+bTAO(|bZO;2fYhebFI7B=yxT3fjNPJT8vPXAx(cLmYw zYR{F}T3}0~&6<*>JQ4>TxoEBx8znouefH}42NwGq^+Zo+-n2eiz4h^S;}+1rJyEs+ zuFc5<9t_fUpwBn^)zuqMbHiZ+NAGwR&U5eBBlSM=c#R<^g{c9NLe}_;Rg9!p2t(C` z^ryvtj`yF7IPH4dG&Ngd1#iRSD{rM6pgsmg;G`3|OI`R7TquS|yqcc=Oistbj#0~x z^%_eezDvpJb`XhyvDKJGv6!{1t7|Fy>B-;tv-lf^k&opdz=kMVp~JOXYHt8IX$}H* zhe>HEz4m_vu=hz5*hIvi7k3n@Ij8o2MgGc&k8=PEGt*~OM2pswfzSXnE-;t-bS(JU zf5g4n$>}QMI$qmS#oLqL)`(9{1di-qzTL!|plPYosNLrIP1h+1y;!quzLWSX43eS#5#~$)URsQTs)*^kVlKPHe>D7xF}UH2ZtgS=OCIb;uKlS0uWEq#c3Vvf zMV3XTP#%Vy*MySz@Al74lE30U5QA zG*GS3NUBQ2(rxQ4gWQhCu^%uzW8SN#U7Vl4XK3K_K@^En!Mo_|no7K^669P|13%O3 z3!Ph4VCPlU&<2^8KIllq)M&Tn%zN+C0?x1Qd{MvNm2K*bOxe@}Ih%5lJD-TdV%eZ&qw8exIa>{4y z=*!Gj9({^(qFR_5R@G>;_UW`$5#%eQ^6E~ReB|`GZv{VOBIe=s_1Q|2PmuELVQm!) z&45~q6p!XQF_<>wwN|#&ZZOl1J@e5yuSn~x*`W76&)sW*3c27QWdRaF&^C^k|`K8tPw>bB6(w(78hh!Z17^7Qc?do ziAJ7)NBXFIPYrmh#OmSj4@4e22j0Qxm>W(~+(W)=)|?;68@);O-N-k$8^ijmx)aiZ zJhsamn;#F1X=Tl49?}54Iv<~|#@Y;lP5Qci*QKDVsOKr|rh$ zRckX>eOF_%l6oidSUB4u@h?p0soP-WrAih|F(&_s$%?D<|29yyQs@21=wAI_aR&i) z8RP5A6ZEn~*MUkF8{~6SxoTIO;IW@Y)NA?uCV&pqEafOm6z03o{+HF;hO2NEDHy8^ zAtRbD&I$gx?Ds`<(of1@^A4$SGvw?ExKYkEEokVpB@0#npmGfE?Lsq88zNQzY^ zwm2DjSv-3c(Fv1k%{Q}}1oQG|yBQcPy(MvK??WZ9_D+w)t_$gQy-Z&Ui*$Qz+X`ko zo*2Sh(OuHa(wq2O+94j^k7#4!SpAU!UF|<^3-I_GwGct+&&Jx#)7AxoBe$muBl9Rc zYaRl2>f}C(B7Q~O6K;qPd)vg^ZKghikcI0z{v)$~{$j~_rnO{8bJn-(dz$(z=pRZ5 ziFVC&AA#36vuqWj$<1dc{bYFUTJhp*GbUhzwNSjK57Rd?zn?_};-AG-Bph;Wrn1;G zb&=Z8c$IP3wL*N*|93loaF)MGErG1w*p95LsoX`=E-2a+a2lF)-%nCMmFy>Jw!RLv z$^CEB&OD8%<5|5Y*Di~+UZ^TCmU!y9=p<>I$PS=JLbX@$II3CpG8JNqPt^5F3PM6! z!px1=Ys^sm7w?FPvC%MSG8GhXr!lp*wJG5alC=AW_4cl>0t0+Gauj1}w*uPOS~w9Z zt!F&$PPc3qUB>;=Ucc5pLyHWv>ByCZ3wLRLzRlJ%EG+ z;!rqyIk9mra>-}`hTyGgJxXmmZT#3@siB0JaMFdi zii%efsyp2LD>EV_%!>)zIEJd$RBKJ2Q{qle%9l6)Beb_znlbRNJb3tsDh~xG*1T>$ ztNHu!^(4B-#d%gLXGo3IZ(s_`9F-YB4}n$Up*(7;7y zKU2JZCcl>)^=12tq=dD3th&QqZ{uGtY9%9YouF4Tz-~oO)^PQ+hp+}`MMUPQ2BAhZQ)WBpnB{2$9 z{IoG>P55d2pnr=Qb|-?k=EGx6k)d}rUXf+=ah_K8bHP+rafw7uVPgA==;Lsog zGizQ=O*d~)t#>{kxoQ-LYV(cj(-ptpzw|=+y+b_em@2CI!kTRxQ+>d|X&Sus_R)Kw0Hy6}sYJnY?Og<~yRu z4!=jmo#r?`ko3O7{BFOp81oBPS|yrIQqt^r)yMz&QCWY+dn7r4!^Kh?|HJZkmLc;i zns_)layd_0tdhl7509c5^i=i$a+5x6e6k4Iq12_e zjM6XyXRkZ^`Us!5t_6dtUc_%!fV&qihuzoS;gXN8dEL2%=6?_mayqzoEK3z}aO-oh zHKu;1SI!sD5ccr&cIM)U6StYGvg&xlBq#s6!RbYiKwWKL&=mR67q;^G{b4eX5)w5L zcL@m+X8PBazt5JOdW*F-qun9TmNP{t6p*K|l}H}<(Vr5x?BOEU+G_!*%nhEF30n+6FJ^azyfVFf-;N#X#0QGc6o^!N!DcKs3pM2 z80qt<^flOA&{l^BIMpr+$gy-majy5>EjoFsjH&6zp+tuQ$uQ*829uA8Y!+8Hb2j6a zHRy!nJsS@QNJ!`Ha5OPyIxSw91RuUoQML!YJa6$iZG(SgfHVt~&k(4&emj~S+LUKa zS?k{4wZ-{dP_O#>cGJFRKW=^Gt+t3-3g?~(Q8_~`xjI|rSu;J#mQ(=m5*1{e30h(y z&6U@Gb0EE&RzHT`Xlwagzw6O1$0j5n9rr%l0seaXXfK23!*`0s3cq`?AM^EITyp~7 ze@sa&`6C<^zyHC`6d$ZrERL1==g)NbZL(JLVYRb8Xf7#wn;KQ%ky@)C{){z0vx$Nq z6qB%KHg&v58ck(l%wTmVN$rUWPs)~a0-3rP9VZ-$R(#OE;rJT()Gu<`n2h`VPrM}u zTip2w0>)ZKnydQ9LKk9E8B#z%p1G5{dTa5Y4~bkp zB3{>mc8e0~x{Q@yyM&ceWyBLs%BPi*IlnhF;Fsveg|iHW6HTQ|6|hy>F1Q8Zw&q+D zA#NucCRW`)!Frf&(*p>l_z;L>ecOuK+k$d zNOv!{Bvz(!M&ut2CT?3^QA5LbRp>TzdaLyMQ%_donWOg)MY=6OVp_lkq<46D#9Afu z3k=z^+ItY!ABwn=f#|Z7!orAHyuMFwQn<-JYu9?K&RzWggy~_@2_IT+D4AeZv$I3G zQWNrPBqfG6WUm#L&ULlxXk3uKmTt`jyFcMsP2-REPbFPdRN8&i2AN%NMd2*gFlvux z?Dfro_9h47D2IBll(OY|ng#}X?~?yoxseDZPecjJSx)8WlJj+L@;UdnxS)J*+8q|t zSM8XrU;UgwYY*AMoA&j6`e>7o^xD`Xs%b^!ByFxr8={I!blVO`tC;)~q=Ln$Uw?VE zCR9|I!}~t zv9^g<^z*VG-17B#*Mqawhf9~8!T9TwrNs4hBNII_vDX4_$41+VJi5dsqpj^KS%5e@ zhm+JBo^Sn91wBI~!?=?_Wm2U>V>F|e*rG?v4MlNwJK{f4xuiPB$cf-3=KrM8p3tA1 zO(|1OrL$Ke_H23PyHcq6^i3Kz!6-E+V`I^YZn5Hz`D^?j!^*N#i0@J2SEa3YKPgG) zKw`?4u8wR}&}j7ewI}M9Pc*{S<+B>I<&6P;fB{&>CpRQU*c<8^(cR6h@OwO{iv2Cf z7b<{;UsB+C^$o4De~`&&sg8!z2EQYkDx|j^|MqgF1zUgWZhBfFfptkr^gCu(kULK+ z-z``*w-$9lLw$ z)L7C;N98*`p8W8<=wVby7yP}|H>K0;F$H=E^$)(pe)!U2870Oa?Y(->0^a`Fey)B=a_ z-3EU8%S9i>veQxN_U`VR=nPQ%bfJ5t?=#}jRqtY}B_Ki7Vj&>F350}{4h$XH;-6== zjy+8yzkX6qFn9#Z!E|xlBJk{lWu&7;(~8&9n2wM2&CG@{nj`}qSVi+D+;c-^`V0y_ ztl>wNU|R~Y;oRW8?H|8=b_sL#e3ycT<-%@ZArUjzwI-9119c5pZ4sahr6%D%F38Nx z9gLt^_msU%wu@Yk7^K4YJ1R}Aju)JW&1J1CR%V6`T!wSIMwhpkz3vhtDW{x;fT-`a*%Wxm`}RbgOyYyaZi5?Po>)l#r6Jb z8qeAjK{kV4bN#GT3hltJc&qupHy=?@N@W#nyLLyABFGBFGJIlKL`d8^FPoro{G}*) zrPKRh3DbDdytXT5{A{T}z3aqF24yVKw6af&I4nx>+6sCDcJzNBIS#<<~%IQ5f8#wNS%+m+T(zp)Eo4MBuc4= zL`4yJ-=*i4l=usID~-27_KL_jk4G~G2RY&4@7Irt^D{Fq1GgZe-^+XM9b}rwuYOcz zQ_uRo@Ik;A2-ysiHFo-l%4vfJ4$U3zY^^e$j-RA?9P;-X9FHG%2o_zAdN&uUM|M%6 zNlCqDcxGlEGgxNh#K}E9pI!hZ2IQ5cvEbD(DeCx@3&%vM z>JBN0@p^_tV79m3Hch!)6OcO+hlLg z_ML@hF{>2@=JNtWYk>Y|!%i28f)%p6mF;^Nh(CIRCe$YNBqi0^!0I-JipA(EL=o)e zopOLUQ2_`gA>r{3cUxLXNo?fi`j(x^z@|75AjAVGk^db2F?hTV>6=myUsO{`J0z|-K|!J2-8!w0_GvSo%84H; z!$}gm52g-EbS~)Q-+%Z5%zxBazO%{#)#~-VUm*BkicLWwub`lgK_TqkAA(vC-A^4r@KE zynOLkVZJuLKcTzl;Q3iyy<8{Sf~~FYBl;^K)YmwyEuV~#U}KA_sgVLF?|7hw(c*Og zS4D`J3jpz|>Kll5*|ziLwxsWqBN~8R3-*~AConYvWdk^X!p!j)F1_;M3jV|O!O!}7 z0w3UNc;vwAwp|H(9VI5~0jH1iWZ0#{PJnLs86lsnRa+o|eOdr-BIN%HP_&Nqhsiv7 zmc3CkV%G{ruiNAH`wJgl$4%_Er>ZVv`qS|&=ibX1Yh|yS(CQ+PO|ppHn(r?lYXbmt zu3`#9bF*M@FtT~)&sKYZIn4}SFHSt&gppp@uV2#u4Dr~UQaHfGHJ}^M{7tG#?{S07Qj-2fd3X~?CmwC}1zVwvs z3^ktYB%;{NqO0a*OM(S4htq5v-%2Q6w~aUPjNKhu38Gng36CeO^!&10k|7jc&K?uI zz36ix;>TUfq|``Hm#DEFxTnvk`8fVJl2mrE&d#1IK}b-r;i#<8!*fyCe&bqcX*8`5 zKwtf(^?@|V)c<1plG{&%rbs^A;O?1yH`fSmnEc)`&IGA1Pr|ufK<_Kc{N99vp2elP z9=HTm+7sd+t}mlxwUq|wYN+3Uj@KWPdwWnEna$V-y(MN____`!G3GeH)FGOJ7&lj~wYSDrD-dUb;_U56lFX1zS}l-Gt&V7-j_rOMh>$ z;E>$DK3qE@`>)r%R9j7n0acI9O}+7I3vVDzTxfaZU8*C4%BNdg%~}z~`gBmYXzUD( zj_(e#X#4piBL6Vt?pbnR+w37Yt0`=Y0x(fjRB~=EZ@SkZerTAyZoPfR#5Vx^05NKs z@U2I8@M&;@)xavtC2fM%& z6cl0{9NFoPBx8B%6Dd0Z_p>)ap5sHtgog_CR#$G9f++qWUwGJ_2=aSXYyxc}w#u`+wZ?DT$gwQd4l_*eM^Xo#5<%R~dCpu|1DB1?N&Md2 z^{v;~*$l)7)%eeoNn~ZEVfcP5SLeWj1pw9R78csx?~~e;^+)=r=CZ7EPPfKJ_emNq1KVrj@^LKgn zy5&8TYkEbrYNI+QZHe3`KW*t(AJO+AzqHr}E@&fGp2k^K8Mpt@w)Go0DIyEpS?CcAvd8rTPj^ zUuIb3Cza^qnOe}g-|lNN$>fL^H@@2We8Jz!0WH9idgW~ zWSrG^DY-+jKPf|d!K%11#gnh$RV7}bY4iW+P(P}+^Eaw{Gy}Jhi4Vp+=oja3<&3C4 zl(tO0`W^MbUqF)+l-^t6`7@SC|-YiT-2KM9k~z@ zuSamDZQ-GE0v!_*Q<+cs1FYTeIhEft_L1D9VmFO@%9(9OAdu$HZ#tLum@z7jp6zl} zAk09EJFwy@5Ov=@*%XatsPkKFF^O80=2nT6?i}B(cgjvb<^0zQ%7qWWwM`Xv2-g&v z``>&H<%F-lx|kJQk;O+P?^ox})PWZt?IY}`*wYMxE2T4X1l`P{>on{B)sH)X`mxrT z`4Uh(PND)@3)_v9DfqI>Z4cUjgs94FC`)h5;Y*sx0&`B~zKOR9aO_ClAK&Ub@Nbm+ zn*HGN@bH}2OVBS#r>iy>)RB)fBUfB+gdY2ynS+wFl#TwRBFP)xH0kLtukO=yTDT`2cMh=i6FeqmuDIypbC z7?w5n;$iWXK(*6m_(g8!`Xym zP^N=T-f6CW>}^4l8d(x>`?k^l?zU7nr~k7_`p~q|`C^8?+=l@z1qF0+a`NLvD1EW7 zzE!oL7#8x|w>b`NzTMs3hwg6_S7;z!*_ceKDtgsaXvwVga!8j)B)7}LUmTCrGuzY7 z>r!a~5Vs%DtFmCAb|URl+F21a?LwZ%nqHsq_T9KJ=B{O?b^yMY_Z;+c;*tb0~Cr$hTn zindZ~KDHNBE^2SLG~i0x{C0`^v|}&@kIpP)p(g4vD{!8T;h?O?mOPwuW4ZK+;I5K~71+ln!(X>*3JOAV=4oJt%ZA z*_~L9i{AzNC)AUx=wZ$r>>8MVG~;`F-4!8>-@pXnKS*Zbln~koeNo$uz6l#4;dw_v zq5OF3*o#&}_rEw14JJIrWX>$Jp#Dofah@<`&7GtL+MZ z*|^fyqE`N0+OURs*g8HR!fPLhcocruq7s%sC_Ku2de|Mi5mj^zM^(eYIqdS258y%! zpN~t93X(H=_^uTpr`^Qg%8ffeg&CpyLOS3c^i(LZcip{~P!O$MR4K#8Fm+jP#%Mo7 zP}aX6LA@1$M;sAoDEr`zM<#?rM6pH`A;qRoj*4c3B%1(z8siM?ldQNF^~%Xws_@Un z#-ow(dsF-)S!$@F7^=ehw^Hdu*3h^_e^s?C=3Hf_b<7O!2(O_$v1s&K!lbuDKH%Dt z=y>`=7brx8Yhy@c%98AKD3kl^KJBzDgSN*RmZTX~M&hOZT9fm-+l|4Zoxgcg=q1b^LY*tl2>(i4Jf2}NG3~eI^J>erI(>PU~ z$npZDEdib^$dL-X80ZC1HeF{HwAcF!?7x?qq_z&I2-h5#*HoXJcyU0=F)92K=U0B{ z1?fO}Ofs)~^2Y&bgU)vr@%mk{ToZO?Wn0`(NyYEy5HDF z*2_NrrKY$&ET54DeogE$0PKPtet;WtY>G~&y*Nh>D}^2c>o%s8+3TQ3!QdVO{40mj zgf}Bxt?*C}wfRcEMI(`vX2)C~msmp#a($NuDZaWOspfEp9@M{AC{_vY;azbm!5wyIu-o&_j#Mo@iiHBO$n?#TulYA)`PZ(cuDSNfxAchAT|Po z`Bt~raY8Tr)SwZq6G=ffoNbd$L`KwYy6*X%h?d(=@u03qcf0qGTtZvcunMV+(mSr{ zi=2v*$>wKbWXKmX3iLR0{Tuf@2=OKt;g`l-rj(M0NVAG4dIYn0rJ;giVE4u|Fw0+d zocvcDLf-hLAC@#M;;Y=)If9~!{KoAjvG^gYb!UkDcpxJOa4hNK6Mn0v_`l%J2SZI{ zs@nB&w)z?V0Q%CTI$Vx7ozdZT-T(DNUfyK3CVFLMsmR^xZ;gdV5V96&Yv-AC z`FzWGm3%d&k_7<`9O%WvsU_sAbiH)T= zOzj<;IjErh8L{H;Hi8b}^yOs2ommDI>}Xw`j=U%K!CGuPnkNtNI#=6+orQBFFuh9+ zH+^3$)Idk22jR{w@>!vxs5@-i`<#9ORROWt9}%CpJR4Yn+|Sn%e5?9E-cJ|fTG%eT zi=&NHyE=Jo_2RE(j%%X|pJr!`s(Eys^B_7o$}T34U&=3l9{Rpe8{{WPS8%m9MEhZ{ zzG-q?Yfz9+20}ls{=*oc?Ht_m9EI$^Ru+hy%(RvDDZB5F9bQFk*VtTPN?&W6B(Ql` z&_ixmGwQ}U`%{Lqo!HTsqk$-dts6khjyiZFl`?+5H-~!IXC&Zsj|J6swwj}gY%Xq0 z6>-Nm9jHv>euatoS~K2=P*_{*Cb*`VJ%MbP^2VAmkC?0~d$$m~ZH7PI0S$DbkONpeKj%gHj1`La^2;miwEo>bp952Tt;}1jq{(Wc7QKTN@3I8Tq?;w# zD^ zc`xtyK-v4I{ODz`=%t1m#=y`bl|l1R{AnmrXg*FvdZ+q>YFwDHMl{a>0&%1n{=2zp z3fVvt?a+P(7J4QbyKQOlbP#jH3$N2XWdMRFIyv_n*~xc!E8$&8cX3|A@milgMH1P4 zew*>Sb>7$S9a)!WgM&P{MdOzh(8}x_sxF~*)-@Vz8eC4F6oA(q2<+atwoVFUP=0p1 zo>7bFSvO`|!&fq7-1RV5jTeE;92(6)5v51D=5s{Gm*R@^yg;Vko3UB_Ruis03ngm! zQEG#1;0j)Og!+qr@F&j}jT2?N&BGgK=_e_)HsfFyjgXG-b{S4*iYBONN?)*wEX~HU+#JxYL z^a07!8vtv0g#%Zk?ZEh0AA~JFIA5)^$+{}d!c45^zs(1QucR$ya@ zLnbOqAF<%wQXAzOwWKRTw6*?ARKel4pA)<7W%$XeSaQ?~gU@1t{)is=(){LOaKZG! zKE7Ezw%=;Hhj-yWkGA#VQeOt2RA#P&CMnV^&UZcxsvrvKC$DM#6Ps{aZ2O)%4%F7#|6*+2<~Z26RvK~#lw?GHDft#A__MRh zW15ZEHk#qqm{YAD3uf$HdzN6dEUK)gZe(&7#ThQdOU}2eEov6j59L`lRjnTcEls_;{l&Wz3N?2dh*`iv9qz?9s#E z$Q*9zXVph2HXj`^Es9!s0=t8Lk?QCQ9R*jGcCk?c*q9c1GfztK$&?D#@zFrcHMNU9h7F|UTHLr= z^tNDUF6p$gFC)2^O}j7XXaJ6;uvz6V;#E|I= zkk44#UhafGHBLpBzBS-#WRyZE;)^r*{3Y%cKi5p(D@*M4lk-kh@eC2hZz9Q3k|b<% z-0fXmaJ707`PrSDcS=D|kW6K?1ag_ZFfsz<+Y2M(&$vyaATE-UBI&szMN?LBB7C|3 zN7-9P#SuO0qPQi&Ex5ae;4%<21cwB73+^sMfZ!T5!6iU&cNio)en5JcHLa%87MJDf1Vk$`E)QIM;AvKr&$Wo$9I zI;>E;C3Z?q-ZMn6-JEG0#)2V(;?0|@%o4H~D*QWyYZOU0-T(XPNAzBjvo@u)eaWr5 z+wES;{&x0D{vu6+K#Alr$lt?z(MC6hM{eTg*iO@vUR^(q44);93ynx%y}tYmA*B!K zU6S9|K58ubrdgh6lR#oF!p~bt*Y-iewx`)U0A_6LhM$E}AR-6Ys+~&@kg_L8nY9~G zZX|L|vl91kZ?G_w$cQ@OuHY@$xy%@%Q)$Myki28wbfq<@!aNz-jkH6V=)WSdF8e1tx{iKQ6TLP1Kl1-{L<(?%okw{REfzNGURn|7Z3GKVuPwZBR~oKQ z`;?SuAr2zTN;Sk`qPzViz8pX@Acj_+!=JbACb;g0+K;fQC?5X0dH?04N# z0AB13*B>Jw-yLrDhH}dRp2OIopdC!LwwKy(tBn0Y^PA-sA3tDl_M>}UHRla#OLx^% zW4{K8^5IN4jeMH3p0lW?-Iv$wJ&SI`Cki*XG}gXNVwJ$ZKgTB7L~{+7OnFX6GoU|{9@*>{$5flw-s4bw_Gw{HRd#> zopEGx4pYH`Q*awky{qWYJR3V_ZK|26Z}%ISUz{dXIeGr%W$MI~TBUjlyvD*D4O!mZ z-NFE$G*q!)ZYaRYKxaxThX3hAkrHFu2Lt`*&%v;X2fr;{q6nE=wZx@@3Qe?(0$5We znxfai+Tvkk*qgwhK<%c7&|Ym zUGpZcP$_bAN6^IQJnK?lgaqCjQ?u9*4bDXP?{&=L>}H#R zQ++)wyeu3bAo9L8eP7T5U~=q5r!mzUnmHhGu4@f4)e>iMlp?@<(4 zJEw{>HBcB`eI|UQc`H$uzjN*N!(lC#Ys#jreM!|VKTVCBezwn@KyV0>eWP1|8Bl;U z=5_Y(kvWjGYeMG{Acw{+iFb4J>T9qe!^@2lD#vnITjkO(u3@hR2SOHShcS8@AT+g; zvd;i(5rDzp?EFv!FmeT)S8C+e6&|}(y2fZ3Z2*@-t?97X4Hha%%zRNC15pQ9Eef>hWQ@Zb|HO{tR_{97ZT{Hee74l z{@jPZPcVPnk90tlv{$ZP9gRujU{}dhl7x`?$D7Am3DG zX63uUN^G02sgq!tVVjiuu@D&u!lU@1>f5*4A9dDEhH2e%vsn#A%A!+wz0P#>O9dJ} z8XDhvzrOGj4)lMe=YYDpipapQtW;+eSu%_G`E6feG4<|5o-qqMyOwXV`qR&cfU0Gl z1I@)b@y~cfgEgAJ_T5|226ITPmHOuNM;i^p$qOfWd04*;DN?$DbVCiI8_SQf!otQN zVfFN%NIaZBN+5J}e;W2tlRjJXSUL63?JO_{$nRjzf)li`ik0$I&bH~6D{s$}htx7{ zZe0ASZ=C_u?+RFHIUT?ubA*_ff^MhFImc^of}cO{?;g+ys6lbhu;Mz);eqQjP;7oa z$KNV&cx~;w_73Fzc^5)}jBMT;1|?4xEkZ&SWb<#I1xQ3>90BTyrU-;7$pQ)waxV|N zwLwq)3s-4&9Z4E#W!JB=z_A`s*usIA^X0PaUx(G`5`6VvS}_z;(Qzkw7u_Tu5=!G# zn%SrYec_*SC8dyg7rC;1adSW#zxGLD;n0C!3K5b^{K2_i&<)5r%AYrk1bUix?t*L? zj|CD5%KO7h7YgieCAiD37uzi#oj5(0f#wO-)=g^X<T!lpn>Ysa?d=&n5eRJIAZ%4uZf0cKZ7I*V;2OM@r)*%(}J*@4kjs zTdj%-aO;>94u0wc`0)hU0jZ&;y+ACJK0}~p69)ao!r7qTDQYrq90+94dc*4&m0B!G z@l0tA6vsD{oWL7TU)?R%L*{Ze>&~>DH?L7GUW?Q_bZ9587+966l43g`Rz?= z`SR~DhsQ+A*G>&2P-QCRH7ZIe-1&|((zWO2uuH61{X6<7x}<*W?V>N@=g=$5vpfR- zP7_8;OClf=b9W^ohoee2u@>J4u{Y^kr2JE>WIxPu+UbCDVy3^oRl#&}Nt9Z#I5ZZ( z3eY*yz?FZ;CvSlw7#)7`_U{2lMEKoWC2T-pfBwfTx!1HnqwtA-lgUP{NBK(qz=mOt zDAjjVq)%RC_Jin>Ij0u__vWh44zp`PBzyj)IAL4cT&eue8AHJU%oDYEIsOrV;hybE zApr7HxdcygO64mA3mOGHP{~NG&sv|F&OMv^Kb^Q1bniy_H`_gx`~q{sT(Pgx%6C$0 zkP+u=_E>-v#AvxP{StIg|Bvf{e`0J&_wE9SMg^^#4`Wb@(o`+0sd4^-kzvCsazTtfw1?vHNe1T z$`F91ouB`ev+_K6g9wJ>{w?gQh=O$Fwdc6idn34(~q89RCJMn|=UNPrvkG@Zu`1t9~L(Ks0Z@YY!QZ4uWrL^%J z-zczhrb4(xz{nX}O(N)FQXbQ0Dir6mEgpK>nUTw+Oe*Z~LvyDsShRS2H_oQcHu)d_ zIAP|iAiOOoJm*nxFkFS_ zt}%AG-$8&&nQZKLy&@2Zp-lHK{rHgPmNksEOL+_{2a&=O@Hn&c)scO zUu<%;c?p*A+2rYwM!wmB2*d-Wgn-mr+ik$oeht>7#ushaxB*^poBga{`XF7zrujZg z2*|VBYkWHDxF7L85XawIB3lEw^=mbr2@erewGY5lVbM;+RaVXr8G6|5-JUIs!U2@U z@I9cC%bb699PdHEerZ6IntL-2Q(C7Xkl6|5gqS3U<6IiQZ|nT3j+y%5eT&2Md=gmy zMo)oGeoz04Y%Z# zVfuu!t?u@tz)HRYln05xc(MD}1v&P{?IV2Q2!4B=BYyAl5ds*q>}t-^uN@E$JG9Ri zy-;-#ZnBlyv8^;0X2$2EdvaD|_722C>0SZyD?ME{*nnM>l&b;cDiS~ar4pOQ!o%W6 z33MTJ7*Gqxuj4ThE$;nu-D{3OfETkGS)00cUw#FX^r7egp^ z@Ra_3M34fWO)!lis+1SeyrGvAv?Lj>aER`pLQWT{};){!ZC|QaR|uD zl`n}Es$#{2c^;U}jMLlUHtw?qZQmR5IkO?t9T#+5CYO)n=*bc#F@1B8nBhkNoZ-tu z4`*z`lbE#&N)*sLfK3@xi*h|rEKuw!6|+PJ6;!Aqf&T^bA`ZlH$~M^InEXkI=K+!z zUQ#~r;^R~OzStVJRE|9sb7%PkzN4+x&{Qv(-q_>rl#HelHxS`31KlBbRT{|#ej?sg z{=Ql3_oMic)948PU{=1= zPJMI85c$(gFasroFQPmbV+?!C!d&fbv!Xj%r<|>4<5krPl z(11&cp*YozEhDW~LH|9da;uj+HS+Sq!niTapB3a}XC-#PEZ=#R=D6OIBZv^!+Y&wJ za-hhzX;zPDV_Ntm9T%{D2VsUG>q0&ppXs2v9+N9Q0)_B8?;xVEGT(dE??QyMw2JM} z1$>N{jSkf`$-H$Qk4?1&?#|%I%!dvkOZM8@tAvW--hANEE6mwz{9z98!b6DGBl8aE zxv}btEgW;xvG3%Ez^Vlia@DtSC7X<1M_c0X_Jb1>TRa@Qfh;k1d_8;e&(Cj!gZg+}L=iFwEpzN)~&oea$3_M}%TbOI7ho*n+)W0a`;B3R=NJ z@R5zzZ)@@y<(}r^hxISM4Y+ufh(eNhT{n!plX@0bdr^&pe`fCMi|A|n|EQmFIQthqAN%SD=f%Y!u_T|^M7ibcuw}J z;P*%Hj~!1Sm}82!ibW(C-oAw)a3;1%CtrQ;HGCh#5q>#3GZhg1WUW52E*9Z zPC!!2no=2pwVNLNC$U%2FY879W7prmLU=5b_|+uUrS ztj`qq=umOY?*NR@-QiafwUTLJLz1E6Z;Z2(m+l~tDEVY$wN32Sc6?G~)D}GMy z?9fYmimt!rK#(-BPgcF**G~)o@qYGvZ}x5Tsh%s{+(N z+#GBHK`p0pyT3vbeA$tW;dcZG*ovs}fF?2B+(#7hJ}xi6+D6JVra3P(wj5^Oq1O0w z12<81FgJ0OZwhf(GnwOVc|Lm&FEx6ObNFiBrIpA>`=K!teW>Y!nZG^Z)D+)IPQ!$7 zauwtx2cmEv4>_^RT?7X=>u&@ENMdM9C0ZgFe-38krD%n_bI7y3VT1qNbKbf{Sz^gH zm#jJGs9ih3GGCJ6iN#NSP*<@#M3975VOKMSc9T^}onGH!EV<9Jb|tl*;iPe$$Q=Fc zO-R3^Nmk?s6!5<@=YuIO-B&wbUx-fBZ1E{5d`9{C21U<-PQ;y*K2C0>*#*gA@ujSe z&fB*?Sn6%AfX7wID@PJBBqMvfPe-LpllE{Unr{r5OUw?WYV!hPhtSTko@8boeO_?o z>FM3-zQPI(AIJyzkbeeSxY%L6c5`O)WmR;QR?6pCsJ4Q3Vb<2;#A{*?!v|TSye310 zGK>t8`+v#fk&y*22P2V2DM!S{^@OU! zR>tNaslMnyG5VSg+M6%P@__^CrU7^al#%KC3SxZuIjWj%0*;_ih?po!EcxHBA~IhK ze+wy5iK-=EoJYEm@|AO&6*NRd*8T))5K=L00U?Z4`)%?Ov=CsAV4mtch_ysLzxlV@>JJLpU7Ye0hk z_wcvzruM6b+Wam)GjXPltqcCE($%6J^z4UK;-+ewl##vgsd!zaBM`GpGAq+M7?ngFX&( zRXIU=l#y|iIW;-cMZF7kpyAb1_-3E6$y;I?VIPM2#Y3L&*FtVqnl@^#zLejRv$cJnRaTto|{{2zMWtfdV&OVvnCt3fQx9h-2 zap*0D5D!j;o_J(ufVE^rTdvIphNn!GmU~fdqe)Pw`nJyZ5M{6QA z``4+ndma3QT*aY}7PsZ>xF%tLf4k(G)3C+v>IqHST#R+sK}CGo)iAT9Vsy0=+&~J- z=Qi>&WvF$#s_{R;c0XHQWQ;vabNHQ%DeVw_C#;ezrP!JLs*N{L#(2c%ijjp-?62c$ zc-)|}LO`SKIKj;gWk{bEaD8E#NIE8g31Vu`7-W$Dd;2t~D+DJI7+>|!`on8d6RRXd*4iV3f)SQeAQa0LRnAJ%-B(;$#P4VJ#o`+Eol>@55;&1^K->o=E%&)*84DO2E>$Lx~a;XufMAu#c&nrjWF~(jMKm;2a5iS+S&`cVt7@*JGQbQb@~@+ zo_Ohn#IQDgiE!tS`iHw88i)S$`pn-@`y^a1o6rsxBoFuEb95Q!LWYvYr>(&kR_6cd zkEs1>zv=FbfRL;v$TKt4{tbAHr;TLDIO?0*ZLm7zwYijCFJJ*C13iPDA8^wI^U~8) zKqPlb%VQw$c67J7U`qi>;i5>Pu(pRJ6^BDpfH>m`HLHU~WE#LG)2oJFYW_$G+XJHfp_P`hFTaOt5@v z@Y-4Tj86yQ+0nokTd5oU*e?$3rK!7iBH>Xr7y0qZdf~72vUv=ZIF9*1V0?`^1lsz{ zPwM>fi92Bj+#~_9edZ|FJ;(mb;XQD4l~S>`f`w`?pvUhNf$CE|-gjEZ7c%ZE7= z&b=ZtxUUUi&%4=quRHga;6}fI!lv4zG{|ko(jvOcfMz&IRUxjPNXhm~1oikr<7^cQ zn<#v!sQsbX$an1MbJ$G4;8Tj2tHjBdKh$IIptk4>PGAm?hCe!gsqp~7!*;9b-FG9D z4*{I6#SLGrmR_X^zUXFyOU6d5R6YAN#ZzggJ^}C4pTdsra=ERzf762TB3iD_N;TJR zZg9SC?*k9hAF|O+Au1e@*z3JS_g{Ay$fHS z`~;o|Ej6u429xX;h6*j6c_n5a;xwqHjJ5K!a*5`9o{3LDb4N8)UtERoPCRKWe)pVP z@M^cRC5vv?UhJMJB@4wM(n@om2y`Pe&8QOoiFb41LKx?OWmir%nUno)8)|JZ_TefS zR2OgCyrji&GvyZXxJ0!Lt9ZrHK$rW#M^aNoDfy>`3 zqshQwWPb9 zg{iInK}Q&T`gwgd2eI5c>kiboSz3D-))KocY6=NFN5&PRQa6T&ErY!zPr`|Z$U2hf zA<3|(nzP#z>h6o>zTn`OnPM$S(&2%}nh4XSvq?PPqg*z6JnJ1qmy4+*T0NHX-Y0cV z*e00>99=w~kvrdC2J-ahYL!kFjXKZ#nkJ?gpyj_|P{}sHtP^(5;K2-TSe7Cizw*9b zu%2}JgBvO@yK%hQp#$3pXW`-?gj}te4^$sSbDy6_;9Ah_xgn^Aek#0K8W-p>*nc|=I zvqyCm<1AR(cEB)^_oRHsyl+d5$$zNvJ1)0}@Mqj^PDIw3#Jpc*mihU+c_ZM$Ied5B zo5~KniXOKo_7_>T)~{{tG11f8_q+gMd}Csg@6Kh1m{i$H_nB22c_J zZ}@6D7Lr3@hVwONh2?l3z$fe}z4XX`w|mVnes(E_KrSDH+nx|}?-GBokj>!EhF2o*ZE0zk&ylIYe?%^khj#(` zM4~sSI#wI+W~XZX+DiAH-1o2CX3|l&F6#EkVQ@R7Q4Vkpg1Q)By%&KeOrT(P;i~af z@8Jt$@HR4n^jd2K*oHazK$eAc4h489xt`w+z{OW-Q{%?)b4IY&ZBpsl^Iss#TEAzR zhYYhg={xxmu$@&dtK&i5AZ3qTx1EwT7wR*nafJjImD| zM?6X{)_48x!V+-uzEoF}zIA*eE zpq36FlT%PYiRnk$-d*ka`JpW#^|q|s$OtHeaBdQgoesSm<{>0B0SXN4LpP&!1g){t zVdzQPEaz%_W9fpHSl9RWq_DsG^L6gOSRhT0Fe7h7-pI&1izja$sV+@86ui%8gD(*H z+yYEYN!w(=T@zcbL0x@x#{}x<@#LzKD3S3Yz@gp#JW>h%s~6AHNo$0nuNf)vg$o$6 zzGZ9{aHrCXGLyjkJo;a3p>1ZV5)X>V7*zV_S6zcq^73pi5NyCFR~B%2HFj32s!mZH zt7xL6{+B`THkR}QSYbZd@@2cPE>1ILSvcOT@9c$}_BMt96JqzwF|_*v&^>@Wqck3i z1?x^TuLCzX_qd=^3J4@^Jdp@P>=4cSIE{XO3pAc0=W+C=jv)#{!V6OuHs%hVYVY(3uiJ+VZ;9%kk@C1HQ}C4C+&}Ynd@5zL7OC4&DQeRS2C|BZQWJ-H(qO_6_0iR20JA zMbFP`*TvYG^)FFfmTTB*GDP~8E{OfkgCEC4vM02HE8Ng;WQ`3*%=`c=P%9!vcsUX1 zg@&4>mmC)?HutgyzWCzi*Goy0^%qJJFeoC){ZO>&IdUVmwJ%;*&^}IF_e7b>0n49~ za9n5_rJ7;g0oBa~=CUpy0`D1h%1?;kJ*7PFax6n(Hn{&NU?8rk_^ATZ^w0e{-fx&4 z4&isSHS*zfHBw;a9fP3nJUFTU{^r>)YLY*V@r>{}s@B0?ed2y7Fjre;Lm|bz>gKiZ zUqheF$xPUz#)b;B*HsvEgu_$yB@iw&y_QrVXmnt)@Fz$kJ~`^(6XU;CF<@{l3&wEN zlyjpEw~+n~X+|D;y97&L7%|74km!v#>NoGk?jHMD-7(2h;om=~vo7(&~xW2)%HwkPtw z=^+Fs!3QQnY7Wf9s9|z7RjB^$;n(}=B3kIJ15bao>8XLz!!e)z!{&>eDQ<38IacDz z<=~hR3Ldn7u)Oqx2f-tu#<=JziQ?a!`*e7w)29f;p(0~!)A^v&^{&B7oP|q7Z(B8- z5<*1|ea%+gP{{4U!cTsQJO9^jYF&Zn`Sx*Xg0h(g$VTt?x2wo(Q$#F+tvKmpZMdhy;==(kzOdM~^^=qr0;1VqynHjo8I z$pEnYjTKd5U_W`B7+yeJUpzZ4dUMn`k>cCm3&lyF9A5k>PYKocs&#&jKN5lu@Yl5e zyaX3&erSgt;Hy8&vg%KEdYCWJ2e_Vct1Lv7+xtDRH?6~;C8&nMi>!a~oSqM&15ds4 zRZ0AxSI7+7{gGpM2@j$#M)PwlI;t^41AZQAS1*NwpFJ3Uye*Ah8+(qt(Z|`mz6Y7s z=s2thgMu4_l;Sx^mryqBxI(!39%yA7_L>Sz%=q?=&QRO}IE6ZhYU;3Q?YBM_k2$yzr^v+3>BG#J@+xSUg)( zv@dZV`=yq3L8QEO*u!jKOTAwKL^fZmnLZbTbB$&nhiW}NBRd8`QC__ovm^wrg?q% z>t@&{5kH)UvwnN>VrNQJOpMsaM=&eUgyO$L27UD}Uew_d6I1d$il7zs^`QdzlouiK zs#K0d)yDBc4x>kuvSLqJnRc5y%Fs8rIxTrG#FXMk_1RKdW^u#zG`Az-`il#RVrr$@ zS~uA=c7Y!N$oFynAs)>miRbi}gmN4J_-OSfp9|VBC}?A`u-m*f-^u2&DGW_(}h|=wha9R^AQ4V7uQ7O*XlM=8`Z&YL>KON&({}J6KE3XD-b>dY>T7KaQWIsYkjp5C zAmevzb>2pVuW0}Mh5ie{oz3=pG@6?JpW09>8i>Eg3)Tg zYsj*ln85-lHUk592H>X~C-8OJM|9Zdf%d;^qP{w|a*{X2V^(WF@GvamrH2Ba7fBH4 z=*#l#=HByse>q>fWB3^Hz5O>n0eOM%O%Y&~1W8Zyn2)5NRl6TB3{Hx47@=1*iqzIt zwsttZ-IXqg{JN0Ih311M-B}i|udK$RRju=6c+_vwpl6YjlAM$sR|S|KUq!N}J@Q7l zTs1)3*{6Hf*7PF0c(3Ow5fSnU2-MS)=pXOfP|?sTDQ&4^XrKL69N5dtLfDs)#2%#U3$Px5OlOeK-k>M_pc2$fQfrZ z{=5|YK8m6K%cOeo@S}kep%697$jDgVNIWqOr25Z6)2g;;>Ky2aQLqa4qDHUqr}e^h zeC#`;K+~@dyIKGDXa+}l9CxeOynI^P867ycf|Q#4YyGv-qctb6M}^Fz!hNv;Of0ct zSbDV3_U_77uccq)si8^>hUNLl^H{cnfis=!)@J2>dEuD;#)UL4TO=G=etaEzr9H%% z2AJn7&l<$9958NHGt?|vJj0~N_GsV>yCxfKI^XCL9?!5jh0MIJ!Q~QQwC;6A|j7oquK0!SBs`R2>NV3q;|h z9iOw0N$h*(48u+vu&e(@1o5kcw1b)29QwMqyPUb^ILFLgqN0LwHe^p5nLB0lWK*6iU!LHFZ4 zh@}dAH@rcx$77{q{9DcrkANuBTJE|xF=-E3gnWp+3J!Z+Z?lSVh|B1m9j^E@cvbCq z>WxqB_!oMJ`ABtVL}Z+dQoVAZ*N(O;M{u#jNyiHHWAdoPq&gm{U_13KHK%x^!iws znVw`k_Oc@TA>>Gbd_3>G#VX?Q2)l`h(Q21=yM2xbmAe52T!t~}rjq+vGGt2SKHu$6 z&J5Cmu{aiKxmwPc%u}-ArThrPrB~BqMzP`bvX|}nmvPpx)0?>Jw-HF%CUP?*kk)Gw zvsICpu7sFgKO9Z_c|=!3-U~tN-Ds>Z*j#1pu>0W?wmYKG$0Ui8u!^i4)`>Yi1g(DPozrUh2WdX z*4e4IYmPBMD;bY}9rT*puG=MZ_%tRv8}8bz7ehTsQq|6bztD28)9Hy0_)I5s1JGds zv!T#DVAFvh)dL)#CsQCw)h{tSz$)G{{-MTqnkt5Rm88!48I=OPe6bmwGAU!I65@Kp z?ex6Hxf%q-IZ1ob+~q%cQl(bFPz^=v6SAKBPr|zp+66o~@Hfq!`NRqA0#}dRMz#h) z!6&_N{U&4rIf*!U=MBCPw$R0rY`G3ZdO3n={;7Qn7Y(%fYTB6URnlM#sIqWlt4h0h z2CRDfexaHifQI@q1&xE>b(^2;1~guBE{$HA(|-f%mz$g}afe_cVN-#^0Wc`)1c-Mj z9x#9O%m@??ed?i8BAun?FVmJz%p)xmIQ~X?eQ&pB(v;)6gx+sIO~O~}TH|?T^i*$Y z{B^W*otRVax7C=x@rc@5G1ql38SQhG=yH|ph6%XL-Z+GD9&S8!z~)Dd+vLd|FgogY zTnISXV~Lc-cP$^(nI#}rI_V#W&rO6nVB0n5(Yd^cv zv4g!VH^+7m*buW?fqaykkM|Xb_5SBEb8n{|aeK%{l9dQ&VO-oNKXI8>hJ6<( zr4u6Fz=ecEo|7N_AK?xUmzTantI*`eg3QY+FE3}7BqDc@rVo8C6hh&G6H2(5*?UA- zX$Rj_M&o}6#O=wxer?W0iKRMTHOwD1``hq-*iO;#DBPS3E8FWJNXRJ3ceN&_RMd&1z#-*B-)z=z`#*WqAi86D+V>>nl#xGEct@DL2~ApAX~nl^f-%tfRge%^wCw$ZhM#e zHNac8sYq&=ujA$q;SwH$FR5EcZ_pAlK`w z0nql0vD0nRH(rDrL2FMznLrP+C?)YrBga>x+`m@mydK#80nXJ`nd|*?d?WtwPUvMy ztMRIT0OmyDwzW|(mlNXm%ts~Mc3bY7c2Kf)2-1L^t7vVuh@QrHo8Q=q9_bR9FD=aj z>XZb+`Q?>#jn%Z#zUvDfe-l-T$D82eG(Ferv~QF8&m*Vc>?x?$-?*F(kNll^dA3*J z039s-g#O?k;Z-+1X=j+00twZr1=&8W#;z;V4}7ffzlZ8Q=q*S;5^!@Oxf$DruH0&7eEdy19TbXt6%u7B0pa;+B5; zlDyZYy}9~j2y%G&*uw68l{5bCr`G278QAQiG?qvJR>`)lird|FVRF>gqRin0D`$bV z^hJ}@%^8EwD%V~`(_mm0Vkb5%GdcuqUH`6~R*m!{u8bO%H}YT}cK> zp%nXVbbw78u%PabG}>TDvHZ6(yx#%AH&i~n1iufuQBY-ni=WEJd^~i_P09Mt^)61= z+(Y^xc13WuK`aeM@P9t}hwr4w|Aid?^Fej^?*riU|2QVB$NOL36Md~cW@4?-hsu|I z3dqw6TaO1}Z#Jzp_I~D&dAwCMgFiFYAL0Ga9c5(E94xtIWPY2REPBykApLlI5JoF) zggkyF6yQs)3%u@sKSpgxBQknwWP!~hY&VW?~k+v_CL;zVv#0#c!J-^CvHo<*LH?oE=a4 ziqyy;Lcof?6ceeO!Z}=fz5NZ!(hS)XA(<4aH12Q14;Cf(pZdE{5I>>ue4*9q3*kj8 zTldfMd9nCk&xc^5J;s@4r^xfR=EtOrQ-Ad)ofuJ81i4}gobt6)7xTTY_lSjaXLk_V zrx#>8oZdYp#ksLG5pAhC0uIpo@81yLV*S^h&J~CU%#G5CLE&MvN!qzB3!%^#uIIV4 zF*4mzb1yv73A5IcH3l{iKr;1g7qKt#f^yepVi_`9VE3iCQ#`ZF; zI3P$``{nN7gv834b$Pze>(S($HCx6UhnMkFRFR;7!2-}2dPz?quMZ8mQ{T;1Rw8$quE28b(g24z5qc4QY zLY)}V!Cfv=AC6e1X`l5IIG-V;l4w=GyA#y>iHiDe-q3$nIjS$6?RE=860>8G^e7_| zBvgFDC62Vr!wZs@uw^n)RHs5CIZ9;Fan{WHO{dHd=xna(bUf4<3G_08iGq?xrp7Ns z1o^tD1Qs2aaP3@ae@+BR@;W@w0&F|#U1YWk|H{!iZr8^`N7n#mH4y@+Acei-up7nQ z8;78|y<_8_z!?1--=-%{w$+mx5M?mNM}*W)95+&_M+UJWR+FpwMAMf!d)B78>Syla zVVK_Y1~K8IefthG=1~GvBg*JDDuDuM^Et65pW1axLZW!ZoLD6DO;8bL@Ho7GvfzBB zh(|Tmi?6-Q__WX^IP(k>>HF&4qZ8WA`@Z?u6zeeKtB9C23(G5-3afVG1mqV&Zk31qs@y7P2!J16F)dvkS+Mo9rjU7XSgDT#LId==Ba7C) zJ=?5Zo5+YY1S8e4^Fc-SPzg6Xx3>ZFpCFt^%E$gZ8gpcM0>hV*qA9dBRbM~ z^9P-kYGyj_bY$9Pv8I!e&5mg{x$5yXVegv8<=-GWY}##{CAw@jz}biTP=8|mJ0}W1 zDiABgE2)1Qvyt*g$UUMg61{X*%GICKAD`G#HN#X(*8>9C6{HJzW<sh_shTI;JQxpx%Hmb&6g+gp#{H0`{Z0MZj^FqIFCG@eM z`*eP_*kpVV2RG!#Tjk-unhRTK3_ zfM|rH3h$c<(8Xao3X-1-AU1TFCXw#)DqtLcZ-bP4D2Bb_;ChE#hANxsko6srf~uN& zT&*Y0RfV7&V?~E(`hRzmHC1(b4Hq+|Ib~6@p*G8fmJ(eYx`{0VLb+$Ugir$uj_vCL z2e6R+$YkTlL%sku9L|Se{Rfp`fZq`w5hGo9w^)*)M#8yiht3f{{KkPXO`Mi2x%?f4 zLmE6;;}!kDMzS~pcZ(xZwP*yQl8-xk{FxSG7Uq9zW*V6=GOQY2W=drW&yA%LY-xBp z!_%py-ipT~A!y)asiQ`PG7gzdA7Ospw%>Mz(w&bCmk9%d1m$gQ`gw95ZrO?cFXS%8 zaLKcZ9twtxs611o#UHWWW!3JZD^YBLq)l7fqXyaGiCb!OX8i;Ax`@N(6(O%E98&Dr zJZn=7uzaZGk9UY{smnyj%&x-CZ;u$KC2_(-^CNJKyz0bSQwF?Bzm5HdVLIHa{#&X; z^>;-wDL?ff6c{b9cA|iB6s;)2N%BiKlAbuktls2)?F(h}d2N)VTOKJRUx$Yr<2%!& zSIq>C8}8+O0YzS%m_yeQ8r0FEAnTC6s)&v7bhw24?;=bKXLC3h4h!c?E;J#&_;u=?IQP#DFP?pktc&8`=mfA+_vie<-Qj6s<4M%@jQ z-}o4Aj`Y+w;zCNE6~x_JudqeLgVQ&WXZ7dHWR3y`?+N;%^e<-bf6mF#7Vep224 zWiP#Ba_V^Ys<)pdqqXHH#JVRJq6GP(z|gV7rp#O z3$*A3GYFT^vUNHLOoaeoq(0eA=tMn+3kOw0i2Bt#8RC9l#l6X8`9p!_vcy%3ovWun zcW#3IN@O$EmxbmGs#f)~dt?5`JdrVpHl3M?TFIYu6scwYbFnkRYRp?uKT5h%{}fzw zrLG~qy(x4B)xJ?Za|m3($S7}#YVUfoRpq~WiH9OrVE1nTQ|M-F^!tyx z;D2M~T)13di$xS$3XDmz;OC@wKQ%Td<@LAn!flb)oewm~JWs_?lLk2gi{B@S>`&zJ zZf-U3kd6Rs;Fl^nopji6eg{1g9MCe-^Hrh`E7s-Os^3DWg~vBLdpi##IP1^9*8^ z7?ywa98qg-sG)_ z$@|&#^winV)3+@JWo5$)1_VKD_+}7W{>Y`L2NFz~l%rC_?t)YoDuoDgFo50_{Z~Jt zry&yIP?ybi&i>DRDEj8oxzsGdW2Yf*ODO#C#)J38o8nYZA7<|n3nV(aQ8Ao%Yuac;Y-%Yd4*Rbu+&M?I|OtCRFx zy%H}J+jHy7OsDb7Lxp)!T1P3=-L*?|y{~08zGD_1A^azNJ6~F_N=U&VAm0?5)=Qro zE3IklAk1(@HV)UyS~fB9skK91-_(?@w^t=CCr5VJz~t|8-@3(i94sY%-+<=K>W!&k zUPENhTQfiJ(a#)hJ|h$LJ7bJp8x#1;-7%Pi1asx1hoXP|(m#Lx)>o>r;eAO})h^i! zcMe`;3&rN@UYC@W6(}e;2C0emji8lfYI?q@>qN#8Ih!VO0vf%@ZM@@#s8V|Njdq_- zIn;1!89bqlHn}HAHZ;HJ#~-ez8PmZ)7k+K|&yX!UDs+IZYQXg=5?dq^eOF6r5Z1(AP=j-u2 zF=5n5iMK3{?zzR5O`$Ce{a8Ya_$4C;hvP{`Bg<)02L~Ijn~OtC1`qBUx)#uZ z>;^^~Gh2@9!&M8mAR!W`LA)nEpsr&%Ed?vDwOlGA1r#tlBtJu9tHUzD95Ko^!umI9;IIILLGrKAXu$wIVCkmW& zQ@z>1rFYo8+Lw8)V8BUaiO>5914AI^rx^`XQ85Jc6gZ^QWS`v?8wiJrw$w5lcgM|M zIXiGux1(jFEVLFo!z#Ofq3vcy2bNqn@5e5DiGE;*=xo#|N^2orT3=z2P;$Tq^Fat5 zs3WPEwx#a(;ap0H=4Zc*#EYf_n;wL81YJbtOVCSePz8S~8)Lka zn>sPrBYC03f<9=WKR#x*{ww<-6%`dA**bG~Wr$a_C6sfxs1miK?+y|;=(XNA>IaP! zV^$xwm2WKu55?`{+k7P@~u!p|2tbQFh^!q zWihn`V79!sr_JlU3NbjF4Ps2p?29s+uf&o)KY-#_S9mmzIBo10HnjJ?mZREWuGpVJ zLD*+ZvlM3A4;HrkMIsKG6SspBY`V&%f~K85!usEpjKcy)#<5jV%-9z(&l+&= z7DAo$7O_j{3Vk8I2RLrm%$~>0Id7$Ltp4ZP53WIG$>D+1lc8f?_B)c9HVsn$h3PJ~ z*3_{m4-V3S`yPGzer&n#dm;a{7x%dEDx3JVq0pj78Lk~(IPA-k-k-Y*FrBW+dBHKT zoKKhJ+0=t_li58;fhft2^c%{E=my9?8yv+-CxJDc;M)=(WEFU3Z9L~f#c3as^-_plG!G0sb9h8Nho99Q2}nGDZ5D<w4YgHb>hI}7uZ0f(5g9Mc(-Hs*lx>n=SNsHpa7+E z#n)wcCJF=Q1LYd*J_sOH?%ZHikaA8ic^E+0pBU%tY+Td%NvY!!UAewedTC!k=vO(r zr<7Fwht_By9r}PEUQ}v6T*BG7%T4aqtYyUqXar7(3X~1TxV@4+x;-8$Za_jBtoXJi zuy7I9h^Jh}(m9lbl1$a?K8I<8h!HG4=QSuheVnDlFfi1AlxM^#6T}T(k*W$HpS7f{T%qz%&Mb)R_wY9awT%uDdj!#o@>%P{fB?-{pyqDwR7bJ|@1eE`_M3CV zOw?R00iBj{Vqf#bYTKRNz;XMxj);y07)8PcN287b>$G-*>I;bmu6>uD_V-H9I^C3( z%=V>is8$W(9bW&E5Z|KeGPTD%&`({VG!mzPE|8-xvUU-wNqqbR5KB<$@q>gF2VyJWabA4$Lc?cu~ZY-VWUHvYdSn)Z8>&;m>bR-y-F>2mxwF7~$FkU>bXZ>*N z$Gxm|uIq1qVI$E809=q_nSK#9{hg9RG8wWxHC>g5qs%5!v3*41_OZcfMI|PsL3LzB zs*uV6;%uBr4n@HR2Uyg^6C6t9rGH_a1!i{%kAkpxp$#lKql9V++;e~QWQAm;F~Umu z&CG0mRS)F#w=mCf4F}8O3MCa`<9^rECBVqDXc`|4!k}k56dh_At5rW*pcR`xckWx1 zo2KvX-~B&o?fq2@t$Cc(I}|r=r4@Ne z?dTa@Ud>R(kekaA6&cL|qMo*?#`X3WS^A3t0Kd1pn&@6gBP?v;&h1?zIY-P$ZD}h9 zuSIHBXE~xL{g)?#96qN%suA)z=Rvp#V0fS>Lz$8G6SeoXpWYMQXX=Zhkn$8ME2cDA zuhj`o!wU&KE0Gw6Lx_--J}Gkip|1SKanV zBb1B%sN!w2cGQ87GkrfL%iY^me7GGt_$WkNgiw{u<4liAF26UL!}7;OUp~}c_2#6! zwr#{a2k+B*Vud_JIVUqLN99nG5r^kJR;W=W<3QhXLYG?6^SA)Btw#DS&tnn}^!^`C zzTq-QNuIDz{I=+@W~?M>HQSey5;rLHt0oltt%&K)1$eI%84zgFYvc;Ezv;BoYoY#- zuG$BmkSali&=j$!NcgoRy-2Lv#2lq4O(@kZgO#W_nm{)0YGrdG_bZx*0RL2k2goR^ zkr{DShL0}Iq8*N2lpLVy&cnQ?2Gz3x$wEEYqBT`sR5e>tV{q3p5x$}k12hS(ImL%r z&~G3nX=&5u4cBT-6|E0^s0Z(u|3*s0uYkR_|5WKwCg`O6$$gyC@U)!@Y20NHVX-; zus9o}Q5h6k^vs$A<#Z($OT_=G)6d%6SZ9x9gVqm8t7;3X!tJ9Ez7+N{XD@7?G!u*a zas9|HsU;8MZ!Q;d*LMKQYs`gjMBD_MgkqMssC)Q~sDFz(>jfU(s}&pN#6-qA;-*L- zP6G(ZppD^Ap|dhP}z(x&^&;RtBIrXL9?3Bk`Z-XYM7<}@_E0FR)&sUEQ+H~Tpk+JKSBFgX4 z%jBB>Pa(8+{k?9*Y->z}CFR(C2P&7EmgCuBOhotVD8`Y7#xmzXGBJaKwA!=Xu27iP z<#buJ!mKB!Ji^zEll@ocR@@HH0CB4#xbuGd!lm1&+voYpO7tOvKTCRo$zbcVBQB0i z-Naz?_y&B@1UVKL2;hl=NqYPLJw}n<{BMi`qLISu{y1IHo#0CYF7Av)u(C0xRz2S- zKm=M1ee@$uA6{oqRC2XO{U~+fFnr)vI{e|%k8#vOu*;X$mNjCv)1ekR=_qUh{{k|^ z@%VCLBoLG{F#WD7Mx-5v#Xg^ZX1B57G!!|LhZOzty9Mh?>Uia<@(jd?JRNbc#TLNJ zAiK|~k8`mcS_jh!UmzJis9-wuV73K{Ps*w?-I5>N<_IRIucKtiD_QI1mnk(lk81sJ z&}Jb{7(Cua1evJ!9K;9U`_GyB9hnFdPT4r-8OI6@%Qa9dM;`^pfD_`e*FpNQ=b9Ul z0glnwE&dcgYkr-T-r4}<`x~7GLt9KQBI(qaN9=u?g#dpVnmY+ene-{t@D@8I1#@wx zcR_`p47osjXYs3bPD3nyRx`kppZ-qH*hG2c)YQr;U1ZnO))s~n!O$B+iV)Jp@uefh zn^Wzx^OeNR=1Y4ZOhpQn+48EU)|1g3A`qJTz)@tgcIxyT3jPGgN8=%Qj&)S}c4lzW z-g9RVA(dIhHIg3D!|-B~Vn5~Lp4ri1Ths`u1@Au>M|~3hHG^h_+oixpCO4okV+W&Q zbkvK{Q6#dnZ-#aGJ7-|E03I{wQwHPnXV%qJNkQ /tmp/output +" +"To generate this you would call: +" +" let makeprg = syntastic#makeprg#build({ +" \ 'exe': 'ruby', +" \ 'args': '-a -b -c', +" \ 'post_args': '--more --args', +" \ 'tail': '> /tmp/output', +" \ 'filetype': 'ruby', +" \ 'subchecker': 'mri' }) +" +"Note that the current filename is added by default - but can be overridden by +"passing in an 'fname' arg. +" +"Arguments 'filetype' and 'subchecker' are mandatory, handling of composite +"types and user-defined variables breaks if you omit them. +" +"All other options can be overriden by the user with global variables - even +"when not specified by the checker in syntastic#makeprg#build(). +" +"E.g. They could override the checker exe with +" +" let g:syntastic_ruby_mri_exe="another_ruby_checker_exe.rb" +" +"The general form of the override option is: +" syntastic_[filetype]_[subchecker]_[option-name] +" +function! syntastic#makeprg#build(opts) + let builder = g:SyntasticMakeprgBuilder.New( + \ get(a:opts, 'exe', ''), + \ get(a:opts, 'args', ''), + \ get(a:opts, 'fname', ''), + \ get(a:opts, 'post_args', ''), + \ get(a:opts, 'tail', ''), + \ get(a:opts, 'filetype', ''), + \ get(a:opts, 'subchecker', '') ) + + return builder.makeprg() +endfunction diff --git a/sources_non_forked/syntastic/autoload/syntastic/postprocess.vim b/sources_non_forked/syntastic/autoload/syntastic/postprocess.vim new file mode 100644 index 00000000..845b535e --- /dev/null +++ b/sources_non_forked/syntastic/autoload/syntastic/postprocess.vim @@ -0,0 +1,71 @@ +if exists("g:loaded_syntastic_postprocess_autoload") + finish +endif +let g:loaded_syntastic_postprocess_autoload = 1 + +let s:save_cpo = &cpo +set cpo&vim + +function! s:compareErrorItems(a, b) + if a:a['bufnr'] != a:b['bufnr'] + " group by files + return a:a['bufnr'] - a:b['bufnr'] + elseif a:a['lnum'] != a:b['lnum'] + return a:a['lnum'] - a:b['lnum'] + elseif a:a['type'] !=? a:b['type'] + " errors take precedence over warnings + return a:a['type'] ==? 'e' ? -1 : 1 + else + return get(a:a, 'col') - get(a:b, 'col') + endif +endfunction + +" natural sort +function! syntastic#postprocess#sort(errors) + return sort(a:errors, 's:compareErrorItems') +endfunction + +function syntastic#postprocess#compressWhitespace(errors) + let llist = [] + + for e in a:errors + let e['text'] = substitute(e['text'], "\001", '', 'g') + let e['text'] = substitute(e['text'], '\n', ' ', 'g') + let e['text'] = substitute(e['text'], '\s\{2,}', ' ', 'g') + call add(llist, e) + endfor + + return llist +endfunction + +" remove spurious CR under Cygwin +function! syntastic#postprocess#cygwinRemoveCR(errors) + if has('win32unix') + let llist = [] + + for e in a:errors + let e['text'] = substitute(e['text'], '\r', '', 'g') + call add(llist, e) + endfor + else + let llist = a:errors + endif + + return llist +endfunction + +" decode XML entities +function! syntastic#postprocess#decodeXMLEntities(errors) + let llist = [] + + for e in a:errors + let e['text'] = syntastic#util#decodeXMLEntities(e['text']) + call add(llist, e) + endfor + + return llist +endfunction + +let &cpo = s:save_cpo +unlet s:save_cpo +" vim: set et sts=4 sw=4: diff --git a/sources_non_forked/syntastic/autoload/syntastic/util.vim b/sources_non_forked/syntastic/autoload/syntastic/util.vim new file mode 100644 index 00000000..4511aac8 --- /dev/null +++ b/sources_non_forked/syntastic/autoload/syntastic/util.vim @@ -0,0 +1,212 @@ +if exists("g:loaded_syntastic_util_autoload") + finish +endif +let g:loaded_syntastic_util_autoload = 1 + +let s:save_cpo = &cpo +set cpo&vim + +if !exists("g:syntastic_debug") + let g:syntastic_debug = 0 +endif + +let s:deprecationNoticesIssued = [] + +function! syntastic#util#DevNull() + if has('win32') + return 'NUL' + endif + return '/dev/null' +endfunction + +"search the first 5 lines of the file for a magic number and return a map +"containing the args and the executable +" +"e.g. +" +"#!/usr/bin/perl -f -bar +" +"returns +" +"{'exe': '/usr/bin/perl', 'args': ['-f', '-bar']} +function! syntastic#util#parseShebang() + for lnum in range(1,5) + let line = getline(lnum) + + if line =~ '^#!' + let exe = matchstr(line, '^#!\s*\zs[^ \t]*') + let args = split(matchstr(line, '^#!\s*[^ \t]*\zs.*')) + return {'exe': exe, 'args': args} + endif + endfor + + return {'exe': '', 'args': []} +endfunction + +" Run 'command' in a shell and parse output as a version string. +" Returns an array of version components. +function! syntastic#util#parseVersion(command) + return split(matchstr( system(a:command), '\v^\D*\zs\d+(\.\d+)+\ze' ), '\.') +endfunction + +" Verify that the 'installed' version is at least the 'required' version. +" +" 'installed' and 'required' must be arrays. If they have different lengths, +" the "missing" elements will be assumed to be 0 for the purposes of checking. +" +" See http://semver.org for info about version numbers. +function! syntastic#util#versionIsAtLeast(installed, required) + for index in range(max([len(a:installed), len(a:required)])) + if len(a:installed) <= index + let installed_element = 0 + else + let installed_element = a:installed[index] + endif + if len(a:required) <= index + let required_element = 0 + else + let required_element = a:required[index] + endif + if installed_element != required_element + return installed_element > required_element + endif + endfor + " Everything matched, so it is at least the required version. + return 1 +endfunction + +"print as much of a:msg as possible without "Press Enter" prompt appearing +function! syntastic#util#wideMsg(msg) + let old_ruler = &ruler + let old_showcmd = &showcmd + + "convert tabs to spaces so that the tabs count towards the window width + "as the proper amount of characters + let msg = substitute(a:msg, "\t", repeat(" ", &tabstop), "g") + let msg = strpart(msg, 0, winwidth(0)-1) + + "This is here because it is possible for some error messages to begin with + "\n which will cause a "press enter" prompt. I have noticed this in the + "javascript:jshint checker and have been unable to figure out why it + "happens + let msg = substitute(msg, "\n", "", "g") + + set noruler noshowcmd + redraw + + echo msg + + let &ruler=old_ruler + let &showcmd=old_showcmd +endfunction + +" Check whether a buffer is loaded, listed, and not hidden +function! syntastic#util#bufIsActive(buffer) + " convert to number, or hell breaks loose + let buf = str2nr(a:buffer) + + if !bufloaded(buf) || !buflisted(buf) + return 0 + endif + + " get rid of hidden buffers + for tab in range(1, tabpagenr('$')) + if index(tabpagebuflist(tab), buf) >= 0 + return 1 + endif + endfor + + return 0 +endfunction + +" start in directory a:where and walk up the parent folders until it +" finds a file matching a:what; return path to that file +function! syntastic#util#findInParent(what, where) + let here = fnamemodify(a:where, ':p') + + while !empty(here) + let p = split(globpath(here, a:what), '\n') + + if !empty(p) + return fnamemodify(p[0], ':p') + elseif here == '/' + break + endif + + " we use ':h:h' rather than ':h' since ':p' adds a trailing '/' + " if 'here' is a directory + let here = fnamemodify(here, ':p:h:h') + endwhile + + return '' +endfunction + +" Returns unique elements in a list +function! syntastic#util#unique(list) + let seen = {} + let uniques = [] + for e in a:list + if !has_key(seen, e) + let seen[e] = 1 + call add(uniques, e) + endif + endfor + return uniques +endfunction + +" A less noisy shellescape() +function! syntastic#util#shescape(string) + return a:string =~ '\m^[A-Za-z0-9_/.-]\+$' ? a:string : shellescape(a:string) +endfunction + +" A less noisy shellescape(expand()) +function! syntastic#util#shexpand(string) + return syntastic#util#shescape(expand(a:string)) +endfunction + +" decode XML entities +function! syntastic#util#decodeXMLEntities(string) + let str = a:string + let str = substitute(str, '<', '<', 'g') + let str = substitute(str, '>', '>', 'g') + let str = substitute(str, '"', '"', 'g') + let str = substitute(str, ''', "'", 'g') + let str = substitute(str, '&', '\&', 'g') + return str +endfunction + +function! syntastic#util#debug(msg) + if g:syntastic_debug + echomsg "syntastic: debug: " . a:msg + endif +endfunction + +function! syntastic#util#info(msg) + echomsg "syntastic: info: " . a:msg +endfunction + +function! syntastic#util#warn(msg) + echohl WarningMsg + echomsg "syntastic: warning: " . a:msg + echohl None +endfunction + +function! syntastic#util#error(msg) + execute "normal \" + echohl ErrorMsg + echomsg "syntastic: error: " . a:msg + echohl None +endfunction + +function! syntastic#util#deprecationWarn(msg) + if index(s:deprecationNoticesIssued, a:msg) >= 0 + return + endif + + call add(s:deprecationNoticesIssued, a:msg) + call syntastic#util#warn(a:msg) +endfunction + +let &cpo = s:save_cpo +unlet s:save_cpo +" vim: set et sts=4 sw=4: diff --git a/sources_non_forked/syntastic/doc/syntastic.txt b/sources_non_forked/syntastic/doc/syntastic.txt new file mode 100644 index 00000000..24fa57c2 --- /dev/null +++ b/sources_non_forked/syntastic/doc/syntastic.txt @@ -0,0 +1,468 @@ +*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. + +:SyntasticReset *:SyntasticReset* + +Resets the list of errors and turns off all error notifiers. + + +============================================================================== +4. Global Options *syntastic-global-options* + + + *'syntastic_check_on_open'* +Default: 0 +If enabled, syntastic will do syntax checks when buffers are first loaded as +well as on saving > + let g:syntastic_check_on_open=1 +< + + *'syntastic_check_on_wq'* +Default: 1 +Normally syntastic runs syntax checks whenever buffers are written to disk. +If you want to skip these checks when you issue |:wq|, |:x|, and |:ZZ|, set this +variable to 0. > + let g:syntastic_check_on_wq=0 +< + + *'syntastic_aggregate_errors'* +Default: 0 +When enabled, |:SyntasticCheck| runs all checkers that apply, then aggregates +errors found by all checkers and displays them. When disabled, +|:SyntasticCheck| runs each checker in turn, and stops to display the results +the first time a checker finds any errors. > + let g:syntastic_aggregate_errors=1 +< + + *'syntastic_echo_current_error'* +Default: 1 +If enabled, syntastic will echo the error associated with the current line to +the command window. If multiple errors are found, the first will be used. > + let g:syntastic_echo_current_error=1 +< + + *'syntastic_enable_signs'* +Default: 1 +Use this option to tell syntastic whether to use the |:sign| interface to mark +syntax errors: > + let g:syntastic_enable_signs=1 +< + + *'syntastic_error_symbol'* *'syntastic_style_error_symbol'* + *'syntastic_warning_symbol'* *'syntastic_style_warning_symbol'* +Use this option to control what the syntastic |:sign| text contains. Several +error 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_filetype_map'* +Default: {} +Use this option to map non-standard filetypes to standard ones. Corresponding +checkers are mapped accordingly, which allows syntastic to check files with +non-standard filetypes: > + let g:syntastic_filetype_map = { 'latex': 'tex', + \ 'gentoo-metadata': 'xml' } +< + + *'syntastic_mode_map'* +Default: { "mode": "active", + "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] +< + *'syntastic_full_redraws'* +Default: 0 in GUI Vim and MacVim, 1 otherwise +Controls whether syntastic calls |:redraw| or |:redraw!| for screen redraws. +Changing it can in principle make screen redraws smoother, but it can also +cause screen flicker, or ghost characters. Leaving it to the default should +be safe. + + *'syntastic_debug'* +Default: 0 +Set this to 1 to enable debugging: > + let g:syntastic_debug = 1 +< +Checkers will then add debugging messages to Vim's |message-history|. You can +examine these messages with |:mes|. + + +============================================================================== +5. 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', + \ 'filetype': 'ruby', + \ 'subchecker': 'mri' }) +< + +The 'filetype' and 'subchecker' parameters are mandatory. All of the other +parameters above are optional (well, you probably need at least 'exe'), and +can be overriden by setting global variables - even parameters not specified +in the call to syntastic#makeprg#build(). + +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/sources_non_forked/syntastic/plugin/syntastic.vim b/sources_non_forked/syntastic/plugin/syntastic.vim new file mode 100644 index 00000000..20bf7ac3 --- /dev/null +++ b/sources_non_forked/syntastic/plugin/syntastic.vim @@ -0,0 +1,456 @@ +"============================================================================ +"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 g: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_aggregate_errors") + let g:syntastic_aggregate_errors = 0 +endif + +if !exists("g:syntastic_loc_list_height") + let g:syntastic_loc_list_height = 10 +endif + +if !exists("g:syntastic_ignore_files") + let g:syntastic_ignore_files = [] +endif + +if !exists("g:syntastic_filetype_map") + let g:syntastic_filetype_map = {} +endif + +if !exists("g:syntastic_full_redraws") + let g:syntastic_full_redraws = !( has('gui_running') || has('gui_macvim')) +endif + +" TODO: not documented +if !exists("g:syntastic_reuse_loc_lists") + " a relevant bug has been fixed in one of the pre-releases of Vim 7.4 + let g:syntastic_reuse_loc_lists = (v:version >= 704) +endif + +let s:registry = g:SyntasticRegistry.Instance() +let s:notifiers = g:SyntasticNotifiers.Instance() +let s:modemap = g:SyntasticModeMap.Instance() + +function! s:CompleteCheckerName(argLead, cmdLine, cursorPos) + let checker_names = [] + for ft in s:CurrentFiletypes() + for checker in s:registry.availableCheckersFor(ft) + call add(checker_names, checker.getName()) + endfor + endfor + return join(checker_names, "\n") +endfunction + +command! SyntasticToggleMode call s:ToggleMode() +command! -nargs=? -complete=custom,s:CompleteCheckerName SyntasticCheck call s:UpdateErrors(0, ) call s:Redraw() +command! Errors call s:ShowLocList() +command! SyntasticInfo call s:registry.echoInfoFor(s:CurrentFiletypes()) +command! SyntasticReset call s:ClearCache() | call s:notifiers.refresh(g:SyntasticLoclist.New([])) + +highlight link SyntasticError SpellBad +highlight link SyntasticWarning SpellCap + +augroup syntastic + 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 s:notifiers.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 + + let run_checks = !a:auto_invoked || s:modemap.allowsAutoChecking(&filetype) + if run_checks + if a:0 >= 1 + call s:CacheErrors(a:1) + else + call s:CacheErrors() + endif + end + + let loclist = g:SyntasticLoclist.current() + + let w:syntastic_loclist_set = 0 + if g:syntastic_always_populate_loc_list || g:syntastic_auto_jump + call setloclist(0, loclist.filteredRaw()) + let w:syntastic_loclist_set = 1 + if run_checks && g:syntastic_auto_jump && loclist.hasErrorsOrWarningsToDisplay() + silent! lrewind + endif + endif + + call s:notifiers.refresh(loclist) +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() + return split(&filetype, '\.') +endfunction + +"detect and cache all syntax errors in this buffer +function! s:CacheErrors(...) + call s:ClearCache() + let newLoclist = g:SyntasticLoclist.New([]) + + if !s:SkipFile() + let active_checkers = 0 + let names = [] + + call syntastic#util#debug("CacheErrors: g:syntastic_aggregate_errors = " . g:syntastic_aggregate_errors) + if exists('b:syntastic_aggregate_errors') + call syntastic#util#debug("CacheErrors: b:syntastic_aggregate_errors = " . b:syntastic_aggregate_errors) + endif + + for ft in s:CurrentFiletypes() + if a:0 + let checker = s:registry.getChecker(ft, a:1) + let checkers = !empty(checker) ? [checker] : [] + else + let checkers = s:registry.getActiveCheckers(ft) + endif + + for checker in checkers + let active_checkers += 1 + call syntastic#util#debug("CacheErrors: Invoking checker: " . checker.getName()) + + let loclist = checker.getLocList() + + if !loclist.isEmpty() + let newLoclist = newLoclist.extend(loclist) + call add(names, [checker.getName(), checker.getFiletype()]) + + if !(exists('b:syntastic_aggregate_errors') ? b:syntastic_aggregate_errors : g:syntastic_aggregate_errors) + break + endif + endif + endfor + endfor + + if !empty(names) + if len(syntastic#util#unique(map(copy(names), 'v:val[1]'))) == 1 + let type = names[0][1] + let name = join(map(names, 'v:val[0]'), ', ') + call newLoclist.setName( name . ' ('. type . ')' ) + else + " checkers from mixed types + call newLoclist.setName(join(map(names, 'v:val[1] . "/" . v:val[0]'), ', ')) + endif + endif + + if !active_checkers + if a:0 + call syntastic#util#warn('checker ' . a:1 . ' is not active for filetype ' . &filetype) + else + call syntastic#util#debug('no active checkers for filetype ' . &filetype) + endif + endif + endif + + let b:syntastic_loclist = newLoclist +endfunction + +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 &shellredir and &shell to stop the screen flicking when +"shelling out to syntax checkers. Not all OSs support the hacks though +function! s:OSSupportsShellredirHack() + return !s:running_windows && executable('/bin/bash') && (s:uname() !~ "FreeBSD") && (s:uname() !~ "OpenBSD") +endfunction + +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 g:syntastic_full_redraws + 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.getLength() + if loclist.hasErrorsOrWarningsToDisplay() + let errors = loclist.errors() + let warnings = loclist.warnings() + + let num_errors = len(errors) + let num_warnings = len(warnings) + + let output = g:syntastic_stl_format + + "hide stuff wrapped in %E(...) unless there are errors + let output = substitute(output, '\C%E{\([^}]*\)}', 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 + +"Emulates the :lmake command. Sets up the make environment according to the +"options given, runs make, resets the environment, returns the location list +" +"a:options can contain the following keys: +" 'makeprg' +" 'errorformat' +" +"The corresponding options are set for the duration of the function call. They +"are set with :let, so dont escape spaces. +" +"a:options may also contain: +" 'defaults' - a dict containing default values for the returned errors +" 'subtype' - all errors will be assigned the given subtype +" 'preprocess' - a function to be applied to the error file before parsing errors +" 'postprocess' - a list of functions to be applied to the error list +" 'cwd' - change directory to the given path before running the checker +" 'returns' - a list of valid exit codes for the checker +function! SyntasticMake(options) + call syntastic#util#debug('SyntasticMake: called with options: '. string(a:options)) + + let old_shell = &shell + let old_shellredir = &shellredir + let old_errorformat = &errorformat + let old_cwd = getcwd() + let old_lc_messages = $LC_MESSAGES + let old_lc_all = $LC_ALL + + if s:OSSupportsShellredirHack() + "this is a hack to stop the screen needing to be ':redraw'n when + "when :lmake is run. Otherwise the screen flickers annoyingly + let &shellredir = '&>' + let &shell = '/bin/bash' + endif + + if has_key(a:options, 'errorformat') + let &errorformat = a:options['errorformat'] + endif + + if has_key(a:options, 'cwd') + exec 'lcd ' . fnameescape(a:options['cwd']) + endif + + let $LC_MESSAGES = 'C' + let $LC_ALL = '' + let err_lines = split(system(a:options['makeprg']), "\n", 1) + let $LC_ALL = old_lc_all + let $LC_MESSAGES = old_lc_messages + + if has_key(a:options, 'preprocess') + let err_lines = call(a:options['preprocess'], [err_lines]) + endif + lgetexpr err_lines + + let errors = copy(getloclist(0)) + + if has_key(a:options, 'cwd') + exec 'lcd ' . fnameescape(old_cwd) + endif + + silent! lolder + let &errorformat = old_errorformat + let &shellredir = old_shellredir + let &shell=old_shell + + if s:IsRedrawRequiredAfterMake() + call s:Redraw() + endif + + if has_key(a:options, 'returns') && index(a:options['returns'], v:shell_error) == -1 + throw 'Syntastic: checker error' + endif + + if has_key(a:options, 'defaults') + call SyntasticAddToErrors(errors, a:options['defaults']) + endif + + " Apply ignore patterns + let ignore = {} + for buf in syntastic#util#unique(map(copy(errors), 'v:val["bufnr"]')) + let ignore[buf] = s:IgnoreFile(bufname(str2nr(buf))) + endfor + call filter(errors, '!ignore[v:val["bufnr"]]') + + " Add subtype info if present. + if has_key(a:options, 'subtype') + call SyntasticAddToErrors(errors, {'subtype': a:options['subtype']}) + endif + + 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/sources_non_forked/syntastic/plugin/syntastic/autoloclist.vim b/sources_non_forked/syntastic/plugin/syntastic/autoloclist.vim new file mode 100644 index 00000000..9a1a018f --- /dev/null +++ b/sources_non_forked/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/sources_non_forked/syntastic/plugin/syntastic/balloons.vim b/sources_non_forked/syntastic/plugin/syntastic/balloons.vim new file mode 100644 index 00000000..f6e60418 --- /dev/null +++ b/sources_non_forked/syntastic/plugin/syntastic/balloons.vim @@ -0,0 +1,64 @@ +if exists("g:loaded_syntastic_notifier_balloons") + finish +endif +let g:loaded_syntastic_notifier_balloons = 1 + +if !exists("g:syntastic_enable_balloons") + let g:syntastic_enable_balloons = 1 +endif + +if !has('balloon_eval') + let g:syntastic_enable_balloons = 0 +endif + +let g:SyntasticBalloonsNotifier = {} + +" Public methods {{{1 + +function! g:SyntasticBalloonsNotifier.New() + let newObj = copy(self) + return newObj +endfunction + +function! g:SyntasticBalloonsNotifier.enabled() + return + \ has('balloon_eval') && + \ (exists('b:syntastic_enable_balloons') ? b:syntastic_enable_balloons : g:syntastic_enable_balloons) +endfunction + +" Update the error balloons +function! g:SyntasticBalloonsNotifier.refresh(loclist) + let b:syntastic_balloons = {} + if self.enabled() && a:loclist.hasErrorsOrWarningsToDisplay() + let buf = bufnr('') + let issues = filter(a:loclist.filteredRaw(), 'v:val["bufnr"] == buf') + if !empty(issues) + for i in issues + if has_key(b:syntastic_balloons, i['lnum']) + let b:syntastic_balloons[i['lnum']] .= "\n" . i['text'] + else + let b:syntastic_balloons[i['lnum']] = i['text'] + endif + endfor + set beval bexpr=SyntasticBalloonsExprNotifier() + endif + endif +endfunction + +" Reset the error balloons +function! g:SyntasticBalloonsNotifier.reset(loclist) + if has('balloon_eval') + set nobeval + endif +endfunction + +" Private functions {{{1 + +function! SyntasticBalloonsExprNotifier() + if !exists('b:syntastic_balloons') + return '' + endif + return get(b:syntastic_balloons, v:beval_lnum, '') +endfunction + +" vim: set sw=4 sts=4 et fdm=marker: diff --git a/sources_non_forked/syntastic/plugin/syntastic/checker.vim b/sources_non_forked/syntastic/plugin/syntastic/checker.vim new file mode 100644 index 00000000..3ab1d212 --- /dev/null +++ b/sources_non_forked/syntastic/plugin/syntastic/checker.vim @@ -0,0 +1,79 @@ +if exists("g:loaded_syntastic_checker") + finish +endif +let g:loaded_syntastic_checker = 1 + +let g:SyntasticChecker = {} + +" Public methods {{{1 + +function! g:SyntasticChecker.New(args) + let newObj = copy(self) + + let newObj._filetype = a:args['filetype'] + let newObj._name = a:args['name'] + + + let prefix = 'SyntaxCheckers_' . newObj._filetype . '_' . newObj._name . '_' + let newObj._locListFunc = function(prefix . 'GetLocList') + let newObj._isAvailableFunc = function(prefix . 'IsAvailable') + + if exists('*' . prefix . 'GetHighlightRegex') + let newObj._highlightRegexFunc = function(prefix. 'GetHighlightRegex') + else + let newObj._highlightRegexFunc = '' + endif + + return newObj +endfunction + +function! g:SyntasticChecker.getFiletype() + return self._filetype +endfunction + +function! g:SyntasticChecker.getName() + return self._name +endfunction + +function! g:SyntasticChecker.getLocList() + try + let list = self._locListFunc() + call syntastic#util#debug('getLocList: checker ' . self._filetype . '/' . self._name . ' returned ' . v:shell_error) + catch /\m\C^Syntastic: checker error$/ + let list = [] + call syntastic#util#error('checker ' . self._filetype . '/' . self._name . ' returned abnormal status ' . v:shell_error) + endtry + call self._populateHighlightRegexes(list) + return g:SyntasticLoclist.New(list) +endfunction + +function! g:SyntasticChecker.getHighlightRegexFor(error) + if empty(self._highlightRegexFunc) + return [] + endif + + return self._highlightRegexFunc(error) +endfunction + +function! g:SyntasticChecker.isAvailable() + return self._isAvailableFunc() +endfunction + +" Private methods {{{1 + +function! g:SyntasticChecker._populateHighlightRegexes(list) + let list = a:list + if !empty(self._highlightRegexFunc) + for i in range(0, len(list)-1) + if list[i]['valid'] + let term = self._highlightRegexFunc(list[i]) + if len(term) > 0 + let list[i]['hl'] = term + endif + endif + endfor + endif + return list +endfunction + +" vim: set sw=4 sts=4 et fdm=marker: diff --git a/sources_non_forked/syntastic/plugin/syntastic/cursor.vim b/sources_non_forked/syntastic/plugin/syntastic/cursor.vim new file mode 100644 index 00000000..77f97dc5 --- /dev/null +++ b/sources_non_forked/syntastic/plugin/syntastic/cursor.vim @@ -0,0 +1,63 @@ +if exists("g:loaded_syntastic_notifier_cursor") + finish +endif +let g:loaded_syntastic_notifier_cursor = 1 + +if !exists('g:syntastic_echo_current_error') + let g:syntastic_echo_current_error = 1 +endif + +let g:SyntasticCursorNotifier = {} + +" Public methods {{{1 + +function! g:SyntasticCursorNotifier.New() + let newObj = copy(self) + return newObj +endfunction + +function! g:SyntasticCursorNotifier.enabled() + return exists('b:syntastic_echo_current_error') ? b:syntastic_echo_current_error : g:syntastic_echo_current_error +endfunction + +function! g:SyntasticCursorNotifier.refresh(loclist) + if self.enabled() && a:loclist.hasErrorsOrWarningsToDisplay() + let b:syntastic_messages = copy(a:loclist.messages(bufnr(''))) + let b:oldLine = -1 + autocmd! syntastic CursorMoved + autocmd syntastic CursorMoved * call g:SyntasticRefreshCursor() + endif +endfunction + +function! g:SyntasticCursorNotifier.reset(loclist) + autocmd! syntastic CursorMoved + unlet! b:syntastic_messages + let b:oldLine = -1 +endfunction + +" Private methods {{{1 + +" The following defensive nonsense is needed because of the nature of autocmd +function! g:SyntasticRefreshCursor() + if !exists('b:syntastic_messages') || empty(b:syntastic_messages) + " file not checked + return + endif + + if !exists('b:oldLine') + let b:oldLine = -1 + endif + let l = line('.') + if l == b:oldLine + return + endif + let b:oldLine = l + + if has_key(b:syntastic_messages, l) + call syntastic#util#wideMsg(b:syntastic_messages[l]) + else + echo + endif +endfunction + +" vim: set sw=4 sts=4 et fdm=marker: diff --git a/sources_non_forked/syntastic/plugin/syntastic/highlighting.vim b/sources_non_forked/syntastic/plugin/syntastic/highlighting.vim new file mode 100644 index 00000000..e04e6cc5 --- /dev/null +++ b/sources_non_forked/syntastic/plugin/syntastic/highlighting.vim @@ -0,0 +1,66 @@ +if exists("g:loaded_syntastic_notifier_highlighting") + finish +endif +let g:loaded_syntastic_notifier_highlighting = 1 + +" Highlighting requires getmatches introduced in 7.1.040 +let s:has_highlighting = v:version > 701 || (v:version == 701 && has('patch040')) + +if !exists("g:syntastic_enable_highlighting") + let g:syntastic_enable_highlighting = 1 +endif + +let g:SyntasticHighlightingNotifier = {} + +" Public methods {{{1 + +function! g:SyntasticHighlightingNotifier.New() + let newObj = copy(self) + return newObj +endfunction + +function! g:SyntasticHighlightingNotifier.enabled() + return + \ s:has_highlighting && + \ (exists('b:syntastic_enable_highlighting') ? b:syntastic_enable_highlighting : g:syntastic_enable_highlighting) +endfunction + +" Sets error highlights in the cuirrent window +function! g:SyntasticHighlightingNotifier.refresh(loclist) + if self.enabled() + call self.reset(a:loclist) + let buf = bufnr('') + let issues = filter(a:loclist.filteredRaw(), 'v:val["bufnr"] == buf') + for item in issues + let group = item['type'] == 'E' ? 'SyntasticError' : 'SyntasticWarning' + + " The function `Syntastic_{filetype}_{checker}_GetHighlightRegex` is + " used to override default highlighting. + if has_key(item, 'hl') + call matchadd(group, '\%' . item['lnum'] . 'l' . item['hl']) + elseif get(item, 'col') + let lastcol = col([item['lnum'], '$']) + let lcol = min([lastcol, item['col']]) + + " a bug in vim can sometimes cause there to be no 'vcol' key, + " so check for its existence + let coltype = has_key(item, 'vcol') && item['vcol'] ? 'v' : 'c' + + call matchadd(group, '\%' . item['lnum'] . 'l\%' . lcol . coltype) + endif + endfor + endif +endfunction + +" Remove all error highlights from the window +function! g:SyntasticHighlightingNotifier.reset(loclist) + if s:has_highlighting + for match in getmatches() + if stridx(match['group'], 'Syntastic') == 0 + call matchdelete(match['id']) + endif + endfor + endif +endfunction + +" vim: set sw=4 sts=4 et fdm=marker: diff --git a/sources_non_forked/syntastic/plugin/syntastic/loclist.vim b/sources_non_forked/syntastic/plugin/syntastic/loclist.vim new file mode 100644 index 00000000..f1f34eb6 --- /dev/null +++ b/sources_non_forked/syntastic/plugin/syntastic/loclist.vim @@ -0,0 +1,184 @@ +if exists("g:loaded_syntastic_loclist") + finish +endif +let g:loaded_syntastic_loclist = 1 + +let g:SyntasticLoclist = {} + +" Public methods {{{1 + +function! g:SyntasticLoclist.New(rawLoclist) + let newObj = copy(self) + let newObj._quietWarnings = g:syntastic_quiet_warnings + + let llist = copy(a:rawLoclist) + let llist = filter(llist, 'v:val["valid"] == 1') + + for e in llist + if empty(e['type']) + let e['type'] = 'E' + endif + endfor + + let newObj._rawLoclist = llist + let newObj._hasErrorsOrWarningsToDisplay = -1 + + let newObj._name = '' + + return newObj +endfunction + +function! g:SyntasticLoclist.current() + if !exists("b:syntastic_loclist") + let b:syntastic_loclist = g:SyntasticLoclist.New([]) + endif + return b:syntastic_loclist +endfunction + +function! g:SyntasticLoclist.extend(other) + let list = self.toRaw() + call extend(list, a:other.toRaw()) + return g:SyntasticLoclist.New(list) +endfunction + +function! g:SyntasticLoclist.toRaw() + return copy(self._rawLoclist) +endfunction + +function! g:SyntasticLoclist.filteredRaw() + return copy(self._quietWarnings ? self.errors() : self._rawLoclist) +endfunction + +function! g:SyntasticLoclist.quietWarnings() + return self._quietWarnings +endfunction + +function! g:SyntasticLoclist.isEmpty() + return empty(self._rawLoclist) +endfunction + +function! g:SyntasticLoclist.getLength() + return len(self._rawLoclist) +endfunction + +function! g:SyntasticLoclist.getName() + return len(self._name) +endfunction + +function! g:SyntasticLoclist.setName(name) + let self._name = a:name +endfunction + +function! g:SyntasticLoclist.hasErrorsOrWarningsToDisplay() + if self._hasErrorsOrWarningsToDisplay >= 0 + return self._hasErrorsOrWarningsToDisplay + endif + let self._hasErrorsOrWarningsToDisplay = empty(self._rawLoclist) ? 0 : (!self._quietWarnings || len(self.errors())) + return self._hasErrorsOrWarningsToDisplay +endfunction + +function! g:SyntasticLoclist.errors() + if !exists("self._cachedErrors") + let self._cachedErrors = self.filter({'type': "E"}) + endif + return self._cachedErrors +endfunction + +function! g:SyntasticLoclist.warnings() + if !exists("self._cachedWarnings") + let self._cachedWarnings = self.filter({'type': "W"}) + endif + return self._cachedWarnings +endfunction + +" cache used by EchoCurrentError() +function! g:SyntasticLoclist.messages(buf) + if !exists("self._cachedMessages") + let self._cachedMessages = {} + let errors = self.errors() + (self._quietWarnings ? [] : self.warnings()) + + for e in errors + let b = e['bufnr'] + let l = e['lnum'] + + if !has_key(self._cachedMessages, b) + let self._cachedMessages[b] = {} + endif + + if !has_key(self._cachedMessages[b], l) + let self._cachedMessages[b][l] = e['text'] + endif + endfor + endif + + return get(self._cachedMessages, a:buf, {}) +endfunction + +"Filter the list and return new native loclist +"e.g. +" .filter({'bufnr': 10, 'type': 'e'}) +" +"would return all errors for buffer 10. +" +"Note that all comparisons are done with ==? +function! g:SyntasticLoclist.filter(filters) + let rv = [] + + for error in self._rawLoclist + + let passes_filters = 1 + for key in keys(a:filters) + if error[key] !=? a:filters[key] + let passes_filters = 0 + break + endif + endfor + + if passes_filters + call add(rv, error) + endif + endfor + return rv +endfunction + +"display the cached errors for this buf in the location list +function! g:SyntasticLoclist.show() + if !exists('w:syntastic_loclist_set') + let w:syntastic_loclist_set = 0 + endif + call setloclist(0, self.filteredRaw(), g:syntastic_reuse_loc_lists && w:syntastic_loclist_set ? 'r' : ' ') + let w:syntastic_loclist_set = 1 + + if self.hasErrorsOrWarningsToDisplay() + let num = winnr() + exec "lopen " . g:syntastic_loc_list_height + if num != winnr() + wincmd p + endif + + " try to find the loclist window and set w:quickfix_title + let errors = getloclist(0) + for buf in tabpagebuflist() + if buflisted(buf) && bufloaded(buf) && getbufvar(buf, '&buftype') ==# 'quickfix' + let win = bufwinnr(buf) + let title = getwinvar(win, 'quickfix_title') + + " TODO: try to make sure we actually own this window; sadly, + " errors == getloclist(0) is the only somewhat safe way to + " achieve that + if strpart(title, 0, 16) ==# ':SyntasticCheck ' || + \ ( (title == '' || title ==# ':setloclist()') && errors == getloclist(0) ) + call setwinvar(win, 'quickfix_title', ':SyntasticCheck ' . self._name) + endif + endif + endfor + endif +endfunction + +" Non-method functions {{{1 + +function! g:SyntasticLoclistHide() + silent! lclose +endfunction + +" vim: set sw=4 sts=4 et fdm=marker: diff --git a/sources_non_forked/syntastic/plugin/syntastic/makeprg_builder.vim b/sources_non_forked/syntastic/plugin/syntastic/makeprg_builder.vim new file mode 100644 index 00000000..ef77efa9 --- /dev/null +++ b/sources_non_forked/syntastic/plugin/syntastic/makeprg_builder.vim @@ -0,0 +1,72 @@ +if exists("g:loaded_syntastic_makeprg_builder") + finish +endif +let g:loaded_syntastic_makeprg_builder = 1 + +let g:SyntasticMakeprgBuilder = {} + +" Public methods {{{1 + +function! g:SyntasticMakeprgBuilder.New(exe, args, fname, post_args, tail, filetype, subchecker) + let newObj = copy(self) + let newObj._exe = a:exe + let newObj._args = a:args + let newObj._fname = a:fname + let newObj._post_args = a:post_args + let newObj._tail = a:tail + let newObj._filetype = empty(a:filetype) ? &filetype : a:filetype + let newObj._subchecker = a:subchecker + return newObj +endfunction + +function! g:SyntasticMakeprgBuilder.makeprg() + return join([self.exe(), self.args(), self.fname(), self.post_args(), self.tail()]) +endfunction + +function! g:SyntasticMakeprgBuilder.exe() + return self._getOpt('exe') +endfunction + +function! g:SyntasticMakeprgBuilder.args() + return self._getOpt('args') +endfunction + +function! g:SyntasticMakeprgBuilder.fname() + if empty(self._fname) + return syntastic#util#shexpand('%') + else + return self._fname + endif +endfunction + +function! g:SyntasticMakeprgBuilder.post_args() + return self._getOpt('post_args') +endfunction + +function! g:SyntasticMakeprgBuilder.tail() + return self._getOpt('tail') +endfunction + +" Private methods {{{1 + +function g:SyntasticMakeprgBuilder._getOpt(name) + if self._optExists(a:name) + return {self._optName(a:name)} + endif + + return self['_' . a:name] +endfunction + +function! g:SyntasticMakeprgBuilder._optExists(name) + return exists(self._optName(a:name)) +endfunction + +function! g:SyntasticMakeprgBuilder._optName(name) + let setting = "g:syntastic_" . self._filetype + if !empty(self._subchecker) + let setting .= '_' . self._subchecker + endif + return setting . '_' . a:name +endfunction + +" vim: set sw=4 sts=4 et fdm=marker: diff --git a/sources_non_forked/syntastic/plugin/syntastic/modemap.vim b/sources_non_forked/syntastic/plugin/syntastic/modemap.vim new file mode 100644 index 00000000..2a838883 --- /dev/null +++ b/sources_non_forked/syntastic/plugin/syntastic/modemap.vim @@ -0,0 +1,67 @@ +if exists("g:loaded_syntastic_modemap") + finish +endif +let g:loaded_syntastic_modemap = 1 + +let g:SyntasticModeMap = {} + +" Public methods {{{1 + +function! g:SyntasticModeMap.Instance() + if !exists('s:SyntasticModeMapInstance') + let s:SyntasticModeMapInstance = copy(self) + call s:SyntasticModeMapInstance._initModeMapFromGlobalOpts() + endif + + return s:SyntasticModeMapInstance +endfunction + +function! g:SyntasticModeMap.allowsAutoChecking(filetype) + let fts = split(a:filetype, '\.') + + if self.isPassive() + return self._isOneFiletypeActive(fts) + else + return self._noFiletypesArePassive(fts) + endif +endfunction + +function! g:SyntasticModeMap.isPassive() + return self._mode == "passive" +endfunction + +function! g:SyntasticModeMap.toggleMode() + if self._mode == "active" + let self._mode = "passive" + else + let self._mode = "active" + endif +endfunction + +function! g:SyntasticModeMap.echoMode() + echo "Syntastic: " . self._mode . " mode enabled" +endfunction + +" Private methods {{{1 + +function! g:SyntasticModeMap._initModeMapFromGlobalOpts() + let self._mode = "active" + let self._activeFiletypes = [] + let self._passiveFiletypes = [] + + if exists("g:syntastic_mode_map") + let self._mode = get(g:syntastic_mode_map, 'mode', self._mode) + let self._activeFiletypes = get(g:syntastic_mode_map, 'active_filetypes', self._activeFiletypes) + let self._passiveFiletypes = get(g:syntastic_mode_map, 'passive_filetypes', self._passiveFiletypes) + endif +endfunction + +function! g:SyntasticModeMap._isOneFiletypeActive(filetypes) + return !empty(filter(a:filetypes, 'index(self._activeFiletypes, v:val) != -1')) +endfunction + +function! g:SyntasticModeMap._noFiletypesArePassive(filetypes) + return empty(filter(a:filetypes, 'index(self._passiveFiletypes, v:val) != -1')) +endfunction + +" vim: set sw=4 sts=4 et fdm=marker: diff --git a/sources_non_forked/syntastic/plugin/syntastic/notifiers.vim b/sources_non_forked/syntastic/plugin/syntastic/notifiers.vim new file mode 100644 index 00000000..12f41445 --- /dev/null +++ b/sources_non_forked/syntastic/plugin/syntastic/notifiers.vim @@ -0,0 +1,55 @@ +if exists("g:loaded_syntastic_notifiers") + finish +endif +let g:loaded_syntastic_notifiers = 1 + +let g:SyntasticNotifiers = {} + +let s:notifier_types = ['signs', 'balloons', 'highlighting', 'cursor', 'autoloclist'] + +" Public methods {{{1 + +function! g:SyntasticNotifiers.Instance() + if !exists('s:SyntasticNotifiersInstance') + let s:SyntasticNotifiersInstance = copy(self) + call s:SyntasticNotifiersInstance._initNotifiers() + endif + + return s:SyntasticNotifiersInstance +endfunction + +function! g:SyntasticNotifiers.refresh(loclist) + for type in self._enabled_types + let class = substitute(type, '.*', 'Syntastic\u&Notifier', '') + if !has_key(g:{class}, 'enabled') || self._notifier[type].enabled() + call self._notifier[type].refresh(a:loclist) + endif + endfor +endfunction + +function! g:SyntasticNotifiers.reset(loclist) + for type in self._enabled_types + let class = substitute(type, '.*', 'Syntastic\u&Notifier', '') + + " reset notifiers regardless if they are enabled or not, since + " the user might have disabled them since the last refresh(); + " notifiers MUST be prepared to deal with reset() when disabled + if has_key(g:{class}, 'reset') + call self._notifier[type].reset(a:loclist) + endif + endfor +endfunction + +" Private methods {{{1 + +function! g:SyntasticNotifiers._initNotifiers() + let self._notifier = {} + for type in s:notifier_types + let class = substitute(type, '.*', 'Syntastic\u&Notifier', '') + let self._notifier[type] = g:{class}.New() + endfor + + let self._enabled_types = copy(s:notifier_types) +endfunction + +" vim: set sw=4 sts=4 et fdm=marker: diff --git a/sources_non_forked/syntastic/plugin/syntastic/registry.vim b/sources_non_forked/syntastic/plugin/syntastic/registry.vim new file mode 100644 index 00000000..6f61d65f --- /dev/null +++ b/sources_non_forked/syntastic/plugin/syntastic/registry.vim @@ -0,0 +1,213 @@ +if exists("g:loaded_syntastic_registry") + finish +endif +let g:loaded_syntastic_registry = 1 + +let s:defaultCheckers = { + \ 'c': ['gcc'], + \ 'coffee': ['coffee', 'coffeelint'], + \ 'cpp': ['gcc'], + \ 'css': ['csslint', 'phpcs'], + \ 'go': ['go'], + \ 'html': ['tidy'], + \ 'java': ['javac'], + \ 'javascript': ['jshint', 'jslint'], + \ 'json': ['jsonlint', 'jsonval'], + \ 'objc': ['gcc'], + \ 'objcpp': ['gcc'], + \ 'perl': ['perl', 'perlcritic'], + \ 'php': ['php', 'phpcs', 'phpmd'], + \ 'puppet': ['puppet', 'puppetlint'], + \ 'python': ['python', 'flake8', 'pylint'], + \ 'ruby': ['mri'], + \ 'sh': ['sh'], + \ 'tex': ['lacheck'] + \ } + +let s:defaultFiletypeMap = { + \ 'gentoo-metadata': 'xml', + \ 'lhaskell': 'haskell' + \ } + +let g:SyntasticRegistry = {} + +" TODO: Handling of filetype aliases: all public methods take aliases as +" parameters, all private methods take normalized filetypes. Public methods +" are thus supposed to normalize filetypes before calling private methods. + +" Public methods {{{1 + +function! g:SyntasticRegistry.Instance() + if !exists('s:SyntasticRegistryInstance') + let s:SyntasticRegistryInstance = copy(self) + let s:SyntasticRegistryInstance._checkerMap = {} + endif + + return s:SyntasticRegistryInstance +endfunction + +function! g:SyntasticRegistry.CreateAndRegisterChecker(args) + let checker = g:SyntasticChecker.New(a:args) + let registry = g:SyntasticRegistry.Instance() + call registry.registerChecker(checker) +endfunction + +function! g:SyntasticRegistry.registerChecker(checker) abort + let ft = a:checker.getFiletype() + + if !has_key(self._checkerMap, ft) + let self._checkerMap[ft] = [] + endif + + call self._validateUniqueName(a:checker) + + call add(self._checkerMap[ft], a:checker) +endfunction + +function! g:SyntasticRegistry.checkable(ftalias) + return !empty(self.getActiveCheckers(a:ftalias)) +endfunction + +function! g:SyntasticRegistry.getActiveCheckers(ftalias) + let filetype = s:SyntasticRegistryNormaliseFiletype(a:ftalias) + let checkers = self.availableCheckersFor(a:ftalias) + + if self._userHasFiletypeSettings(filetype) + return self._filterCheckersByUserSettings(checkers, filetype) + endif + + if has_key(s:defaultCheckers, filetype) + return self._filterCheckersByDefaultSettings(checkers, filetype) + endif + + let checkers = self.availableCheckersFor(filetype) + + if !empty(checkers) + return [checkers[0]] + endif + + return [] +endfunction + +function! g:SyntasticRegistry.getChecker(ftalias, name) + for checker in self.availableCheckersFor(a:ftalias) + if checker.getName() == a:name + return checker + endif + endfor + + return {} +endfunction + +function! g:SyntasticRegistry.availableCheckersFor(ftalias) + let filetype = s:SyntasticRegistryNormaliseFiletype(a:ftalias) + let checkers = copy(self._allCheckersFor(filetype)) + return self._filterCheckersByAvailability(checkers) +endfunction + +function! g:SyntasticRegistry.echoInfoFor(ftalias_list) + echomsg "Syntastic info for filetype: " . join(a:ftalias_list, '.') + + let available = [] + let active = [] + for ftalias in a:ftalias_list + call extend(available, self.availableCheckersFor(ftalias)) + call extend(active, self.getActiveCheckers(ftalias)) + endfor + + echomsg "Available checkers: " . join(syntastic#util#unique(map(available, "v:val.getName()"))) + echomsg "Currently active checker(s): " . join(syntastic#util#unique(map(active, "v:val.getName()"))) +endfunction + +" Private methods {{{1 + +function! g:SyntasticRegistry._allCheckersFor(filetype) + call self._loadCheckers(a:filetype) + if empty(self._checkerMap[a:filetype]) + return [] + endif + + return self._checkerMap[a:filetype] +endfunction + +function! g:SyntasticRegistry._filterCheckersByDefaultSettings(checkers, filetype) + if has_key(s:defaultCheckers, a:filetype) + return self._filterCheckersByName(a:checkers, s:defaultCheckers[a:filetype]) + endif + + return a:checkers +endfunction + +function! g:SyntasticRegistry._filterCheckersByUserSettings(checkers, filetype) + if exists("b:syntastic_checkers") + let whitelist = b:syntastic_checkers + else + let whitelist = g:syntastic_{a:filetype}_checkers + endif + return self._filterCheckersByName(a:checkers, whitelist) +endfunction + +function! g:SyntasticRegistry._filterCheckersByName(checkers, list) + let checkers_by_name = {} + for c in a:checkers + let checkers_by_name[c.getName()] = c + endfor + + let filtered = [] + for name in a:list + if has_key(checkers_by_name, name) + call add(filtered, checkers_by_name[name]) + endif + endfor + + return filtered +endfunction + +function! g:SyntasticRegistry._filterCheckersByAvailability(checkers) + return filter(copy(a:checkers), "v:val.isAvailable()") +endfunction + +function! g:SyntasticRegistry._loadCheckers(filetype) + if self._haveLoadedCheckers(a:filetype) + return + endif + + exec "runtime! syntax_checkers/" . a:filetype . "/*.vim" + + if !has_key(self._checkerMap, a:filetype) + let self._checkerMap[a:filetype] = [] + endif +endfunction + +function! g:SyntasticRegistry._haveLoadedCheckers(filetype) + return has_key(self._checkerMap, a:filetype) +endfunction + +function! g:SyntasticRegistry._userHasFiletypeSettings(filetype) + if exists("g:syntastic_" . a:filetype . "_checker") && !exists("g:syntastic_" . a:filetype . "_checkers") + let g:syntastic_{a:filetype}_checkers = [g:syntastic_{a:filetype}_checker] + call syntastic#util#deprecationWarn("variable g:syntastic_" . a:filetype . "_checker is deprecated") + endif + return exists("b:syntastic_checkers") || exists("g:syntastic_" . a:filetype . "_checkers") +endfunction + +function! g:SyntasticRegistry._validateUniqueName(checker) abort + for checker in self._allCheckersFor(a:checker.getFiletype()) + if checker.getName() == a:checker.getName() + throw "Syntastic: Duplicate syntax checker name for: " . a:checker.getName() + endif + endfor +endfunction + +" Private functions {{{1 + +"resolve filetype aliases, and replace - with _ otherwise we cant name +"syntax checker functions legally for filetypes like "gentoo-metadata" +function! s:SyntasticRegistryNormaliseFiletype(ftalias) + let ft = get(s:defaultFiletypeMap, a:ftalias, a:ftalias) + let ft = get(g:syntastic_filetype_map, ft, ft) + let ft = substitute(ft, '-', '_', 'g') + return ft +endfunction + +" vim: set sw=4 sts=4 et fdm=marker: diff --git a/sources_non_forked/syntastic/plugin/syntastic/signs.vim b/sources_non_forked/syntastic/plugin/syntastic/signs.vim new file mode 100644 index 00000000..067658b1 --- /dev/null +++ b/sources_non_forked/syntastic/plugin/syntastic/signs.vim @@ -0,0 +1,149 @@ +if exists("g:loaded_syntastic_notifier_signs") + finish +endif +let g:loaded_syntastic_notifier_signs = 1 + +if !exists("g:syntastic_enable_signs") + let g:syntastic_enable_signs = 1 +endif + +if !exists("g:syntastic_error_symbol") + let g:syntastic_error_symbol = '>>' +endif + +if !exists("g:syntastic_warning_symbol") + let g:syntastic_warning_symbol = '>>' +endif + +if !exists("g:syntastic_style_error_symbol") + let g:syntastic_style_error_symbol = 'S>' +endif + +if !exists("g:syntastic_style_warning_symbol") + let g:syntastic_style_warning_symbol = 'S>' +endif + + +" start counting sign ids at 5000, start here to hopefully avoid conflicting +" with any other code that places signs (not sure if this precaution is +" actually needed) +let s:first_sign_id = 5000 +let s:next_sign_id = s:first_sign_id + +let g:SyntasticSignsNotifier = {} + +let s:setup_done = 0 + +" Public methods {{{1 + +function! g:SyntasticSignsNotifier.New() + let newObj = copy(self) + + if !s:setup_done + call self._setup() + let s:setup_done = 1 + endif + + return newObj +endfunction + +function! g:SyntasticSignsNotifier.enabled() + return + \ has('signs') && + \ exists('b:syntastic_enable_signs') ? b:syntastic_enable_signs : g:syntastic_enable_signs +endfunction + +function! g:SyntasticSignsNotifier.refresh(loclist) + let old_signs = copy(self._bufSignIds()) + if self.enabled() + call self._signErrors(a:loclist) + endif + call self._removeSigns(old_signs) + let s:first_sign_id = s:next_sign_id +endfunction + +" Private methods {{{1 + +" One time setup: define our own sign types and highlighting +function! g:SyntasticSignsNotifier._setup() + if has('signs') + if !hlexists('SyntasticErrorSign') + highlight link SyntasticErrorSign error + endif + if !hlexists('SyntasticWarningSign') + highlight link SyntasticWarningSign todo + endif + if !hlexists('SyntasticStyleErrorSign') + highlight link SyntasticStyleErrorSign SyntasticErrorSign + endif + if !hlexists('SyntasticStyleWarningSign') + highlight link SyntasticStyleWarningSign SyntasticWarningSign + endif + if !hlexists('SyntasticStyleErrorLine') + highlight link SyntasticStyleErrorLine SyntasticErrorLine + endif + if !hlexists('SyntasticStyleWarningLine') + highlight link SyntasticStyleWarningLine SyntasticWarningLine + endif + + " define the signs used to display syntax and style errors/warns + exe 'sign define SyntasticError text=' . g:syntastic_error_symbol . + \ ' texthl=SyntasticErrorSign linehl=SyntasticErrorLine' + exe 'sign define SyntasticWarning text=' . g:syntastic_warning_symbol . + \ ' texthl=SyntasticWarningSign linehl=SyntasticWarningLine' + exe 'sign define SyntasticStyleError text=' . g:syntastic_style_error_symbol . + \ ' texthl=SyntasticStyleErrorSign linehl=SyntasticStyleErrorLine' + exe 'sign define SyntasticStyleWarning text=' . g:syntastic_style_warning_symbol . + \ ' texthl=SyntasticStyleWarningSign linehl=SyntasticStyleWarningLine' + endif +endfunction + +" Place signs by all syntax errors in the buffer +function! g:SyntasticSignsNotifier._signErrors(loclist) + let loclist = a:loclist + if loclist.hasErrorsOrWarningsToDisplay() + + " errors some first, so that they are not masked by warnings + let buf = bufnr('') + let issues = copy(loclist.errors()) + if !loclist.quietWarnings() + call extend(issues, loclist.warnings()) + endif + call filter(issues, 'v:val["bufnr"] == buf') + let seen = {} + + for i in issues + if !has_key(seen, i['lnum']) + let seen[i['lnum']] = 1 + + let sign_severity = i['type'] ==? 'W' ? 'Warning' : 'Error' + let sign_subtype = get(i, 'subtype', '') + let sign_type = 'Syntastic' . sign_subtype . sign_severity + + exec "sign place " . s:next_sign_id . " line=" . i['lnum'] . " name=" . sign_type . " buffer=" . i['bufnr'] + call add(self._bufSignIds(), s:next_sign_id) + let s:next_sign_id += 1 + endif + endfor + endif +endfunction + +" Remove the signs with the given ids from this buffer +function! g:SyntasticSignsNotifier._removeSigns(ids) + if has('signs') + for i in a:ids + exec "sign unplace " . i + call remove(self._bufSignIds(), index(self._bufSignIds(), i)) + endfor + endif +endfunction + +" Get all the ids of the SyntaxError signs in the buffer +function! g:SyntasticSignsNotifier._bufSignIds() + if !exists("b:syntastic_sign_ids") + let b:syntastic_sign_ids = [] + endif + return b:syntastic_sign_ids +endfunction + +" vim: set sw=4 sts=4 et fdm=marker: diff --git a/sources_non_forked/syntastic/syntax_checkers/ada/gcc.vim b/sources_non_forked/syntastic/syntax_checkers/ada/gcc.vim new file mode 100644 index 00000000..7050c3d5 --- /dev/null +++ b/sources_non_forked/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 .= ' ' . syntastic#util#shexpand('%') . + \ ' ' . syntastic#c#GetIncludeDirs('ada') + + " determine whether to parse header files as well + if expand('%') =~? '\.ads$' + if exists('g:syntastic_ada_check_header') + let makeprg = g:syntastic_ada_compiler . + \ ' -c ' . syntastic#util#shexpand('%') . + \ ' ' . g:syntastic_ada_compiler_options . + \ ' ' . syntastic#c#GetIncludeDirs('ada') + else + return [] + endif + endif + + " check if the user manually set some cflags + if !exists('b:syntastic_ada_cflags') + " check whether to search for include files at all + if !exists('g:syntastic_ada_no_include_search') || + \ g:syntastic_ada_no_include_search != 1 + " refresh the include file search if desired + if exists('g:syntastic_ada_auto_refresh_includes') && + \ g:syntastic_ada_auto_refresh_includes != 0 + let makeprg .= syntastic#c#SearchHeaders() + else + " search for header includes if not cached already + if !exists('b:syntastic_ada_includes') + let b:syntastic_ada_includes = syntastic#c#SearchHeaders() + endif + let makeprg .= b:syntastic_ada_includes + endif + endif + else + " use the user-defined cflags + let makeprg .= b:syntastic_ada_cflags + endif + + " add optional config file parameters + let makeprg .= ' ' . syntastic#c#ReadConfig(g:syntastic_ada_config_file) + + " process makeprg + let errors = SyntasticMake({ 'makeprg': makeprg, + \ 'errorformat': errorformat }) + + " filter the processed errors if desired + if exists('g:syntastic_ada_remove_include_errors') && + \ g:syntastic_ada_remove_include_errors != 0 + return filter(errors, + \ 'has_key(v:val, "bufnr") && v:val["bufnr"]=='.bufnr('')) + else + return errors + endif +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'ada', + \ 'name': 'gcc'}) + +let &cpo = s:save_cpo +unlet s:save_cpo + +" vim: set et sts=4 sw=4: diff --git a/sources_non_forked/syntastic/syntax_checkers/applescript/osacompile.vim b/sources_non_forked/syntastic/syntax_checkers/applescript/osacompile.vim new file mode 100644 index 00000000..7567eb08 --- /dev/null +++ b/sources_non_forked/syntastic/syntax_checkers/applescript/osacompile.vim @@ -0,0 +1,50 @@ +"============================================================================== +" FileName: applescript.vim +" Desc: Syntax checking plugin for syntastic.vim +" Author: Zhao Cai +" Email: caizhaoff@gmail.com +" Version: 0.2.1 +" Date Created: Thu 09 Sep 2011 10:30:09 AM EST +" Last Modified: Fri 09 Dec 2011 01:10:24 PM EST +" +" History: 0.1.0 - working, but it will run the script everytime to check +" syntax. Should use osacompile but strangely it does not give +" errors. +" +" 0.2.0 - switch to osacompile, it gives less errors compared +" with osascript. +" +" 0.2.1 - remove g:syntastic_applescript_tempfile. use +" tempname() instead. +" +" License: This program is free software. It comes without any +" warranty, to the extent permitted by applicable law. You can +" redistribute it and/or modify it under the terms of the Do What The +" Fuck You Want To Public License, Version 2, as published by Sam +" Hocevar. See http://sam.zoy.org/wtfpl/COPYING for more details. +" +"============================================================================ + +if exists("g:loaded_syntastic_applescript_osacompile_checker") + finish +endif +let g:loaded_syntastic_applescript_osacompile_checker=1 + +function! SyntaxCheckers_applescript_osacompile_IsAvailable() + return executable('osacompile') +endfunction + +function! SyntaxCheckers_applescript_osacompile_GetLocList() + let makeprg = syntastic#makeprg#build({ + \ 'exe': 'osacompile', + \ 'args': '-o ' . tempname() . '.scpt ', + \ 'filetype': 'applescript', + \ 'subchecker': 'osacompile' }) + let errorformat = '%f:%l:%m' + + return SyntasticMake({ 'makeprg': makeprg, 'errorformat': errorformat }) +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'applescript', + \ 'name': 'osacompile'}) diff --git a/sources_non_forked/syntastic/syntax_checkers/asciidoc/asciidoc.vim b/sources_non_forked/syntastic/syntax_checkers/asciidoc/asciidoc.vim new file mode 100644 index 00000000..0f0f955f --- /dev/null +++ b/sources_non_forked/syntastic/syntax_checkers/asciidoc/asciidoc.vim @@ -0,0 +1,47 @@ +"============================================================================ +"File: asciidoc.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_asciidoc_asciidoc_checker") + finish +endif +let g:loaded_syntastic_asciidoc_asciidoc_checker = 1 + +function! SyntaxCheckers_asciidoc_asciidoc_IsAvailable() + return executable("asciidoc") +endfunction + +function! SyntaxCheckers_asciidoc_asciidoc_GetLocList() + let makeprg = syntastic#makeprg#build({ + \ 'exe': 'asciidoc', + \ 'args': syntastic#c#GetNullDevice(), + \ 'filetype': 'asciidoc', + \ 'subchecker': 'asciidoc' }) + + let errorformat = + \ '%Easciidoc: %tRROR: %f: line %l: %m,' . + \ '%Easciidoc: %tRROR: %f: %m,' . + \ '%Easciidoc: FAILED: %f: line %l: %m,' . + \ '%Easciidoc: FAILED: %f: %m,' . + \ '%Wasciidoc: %tARNING: %f: line %l: %m,' . + \ '%Wasciidoc: %tARNING: %f: %m,' . + \ '%Wasciidoc: DEPRECATED: %f: line %l: %m,' . + \ '%Wasciidoc: DEPRECATED: %f: %m' + + return SyntasticMake({ + \ 'makeprg': makeprg, + \ 'errorformat': errorformat, + \ 'returns': [0, 1] }) +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'asciidoc', + \ 'name': 'asciidoc'}) diff --git a/sources_non_forked/syntastic/syntax_checkers/c/checkpatch.vim b/sources_non_forked/syntastic/syntax_checkers/c/checkpatch.vim new file mode 100644 index 00000000..0d579bfd --- /dev/null +++ b/sources_non_forked/syntastic/syntax_checkers/c/checkpatch.vim @@ -0,0 +1,48 @@ +"============================================================================ +"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("g:loaded_syntastic_c_checkpatch_checker") + finish +endif +let g:loaded_syntastic_c_checkpatch_checker = 1 + +" Bail if the user doesn't have `checkpatch.pl` or ./scripts/checkpatch.pl installed. +if executable("checkpatch.pl") + let g:syntastic_c_checker_checkpatch_location = 'checkpatch.pl' +elseif executable("./scripts/checkpatch.pl") + let g:syntastic_c_checker_checkpatch_location = './scripts/checkpatch.pl' +endif + +function SyntaxCheckers_c_checkpatch_IsAvailable() + return exists("g:syntastic_c_checker_checkpatch_location") +endfunction + + +function! SyntaxCheckers_c_checkpatch_GetLocList() + let makeprg = syntastic#makeprg#build({ + \ 'exe': g:syntastic_c_checker_checkpatch_location, + \ 'args': '--no-summary --no-tree --terse --file', + \ 'filetype': 'c', + \ 'subchecker': 'checkpatch' }) + + let errorformat = + \ '%f:%l: %tARNING: %m,' . + \ '%f:%l: %tRROR: %m' + + return SyntasticMake({ + \ 'makeprg': makeprg, + \ 'errorformat': errorformat, + \ 'returns': [0], + \ 'subtype': 'Style' }) +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'c', + \ 'name': 'checkpatch'}) diff --git a/sources_non_forked/syntastic/syntax_checkers/c/gcc.vim b/sources_non_forked/syntastic/syntax_checkers/c/gcc.vim new file mode 100644 index 00000000..d5c05f99 --- /dev/null +++ b/sources_non_forked/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 .= ' ' . syntastic#util#shexpand('%') . + \ ' ' . syntastic#c#GetIncludeDirs('c') + + " determine whether to parse header files as well + if expand('%') =~? '\.h$' + if exists('g:syntastic_c_check_header') + let makeprg = g:syntastic_c_compiler . + \ ' -c ' . syntastic#util#shexpand('%') . + \ ' ' . g:syntastic_c_compiler_options . + \ ' ' . syntastic#c#GetNullDevice() . + \ ' ' . syntastic#c#GetIncludeDirs('c') + else + return [] + endif + endif + + " check if the user manually set some cflags + if !exists('b:syntastic_c_cflags') + " check whether to search for include files at all + if !exists('g:syntastic_c_no_include_search') || + \ g:syntastic_c_no_include_search != 1 + " refresh the include file search if desired + if exists('g:syntastic_c_auto_refresh_includes') && + \ g:syntastic_c_auto_refresh_includes != 0 + let makeprg .= syntastic#c#SearchHeaders() + else + " search for header includes if not cached already + if !exists('b:syntastic_c_includes') + let b:syntastic_c_includes = syntastic#c#SearchHeaders() + endif + let makeprg .= b:syntastic_c_includes + endif + endif + else + " use the user-defined cflags + let makeprg .= b:syntastic_c_cflags + endif + + " add optional config file parameters + let makeprg .= ' ' . syntastic#c#ReadConfig(g:syntastic_c_config_file) + + " process makeprg + let errors = SyntasticMake({ 'makeprg': makeprg, + \ 'errorformat': errorformat }) + + " filter the processed errors if desired + if exists('g:syntastic_c_remove_include_errors') && + \ g:syntastic_c_remove_include_errors != 0 + return filter(errors, + \ 'has_key(v:val, "bufnr") && v:val["bufnr"]=='.bufnr('')) + else + return errors + endif +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'c', + \ 'name': 'gcc'}) + +let &cpo = s:save_cpo +unlet s:save_cpo + +" vim: set et sts=4 sw=4: diff --git a/sources_non_forked/syntastic/syntax_checkers/c/make.vim b/sources_non_forked/syntastic/syntax_checkers/c/make.vim new file mode 100644 index 00000000..a0ccbf61 --- /dev/null +++ b/sources_non_forked/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('g:loaded_syntastic_c_make_checker') + finish +endif +let g:loaded_syntastic_c_make_checker = 1 + +function SyntaxCheckers_c_make_IsAvailable() + return executable('make') +endfunction + +let s:save_cpo = &cpo +set cpo&vim + +function! SyntaxCheckers_c_make_GetLocList() + + let makeprg = 'make -sk' + + let errorformat = + \ '%-G%f:%s:,' . + \ '%-G%f:%l: %#error: %#(Each undeclared identifier is reported only%.%#,' . + \ '%-G%f:%l: %#error: %#for each function it appears%.%#,' . + \ '%-GIn file included%.%#,' . + \ '%-G %#from %f:%l\,,' . + \ '%f:%l:%c: %trror: %m,' . + \ '%f:%l:%c: %tarning: %m,' . + \ '%f:%l:%c: %m,' . + \ '%f:%l: %trror: %m,' . + \ '%f:%l: %tarning: %m,'. + \ '%f:%l: %m' + + if exists('g:syntastic_c_errorformat') + let errorformat = g:syntastic_c_errorformat + endif + + " process makeprg + let errors = SyntasticMake({ 'makeprg': makeprg, + \ 'errorformat': errorformat }) + + " filter the processed errors if desired + if exists('g:syntastic_c_remove_include_errors') && + \ g:syntastic_c_remove_include_errors != 0 + return filter(errors, + \ 'has_key(v:val, "bufnr") && v:val["bufnr"]=='.bufnr('')) + else + return errors + endif +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'c', + \ 'name': 'make'}) + +let &cpo = s:save_cpo +unlet s:save_cpo diff --git a/sources_non_forked/syntastic/syntax_checkers/c/oclint.vim b/sources_non_forked/syntastic/syntax_checkers/c/oclint.vim new file mode 100644 index 00000000..e366a7ab --- /dev/null +++ b/sources_non_forked/syntastic/syntax_checkers/c/oclint.vim @@ -0,0 +1,58 @@ +"============================================================================ +"File: oclint.vim +"Description: Syntax checking plugin for syntastic.vim +"Maintainer: "UnCO" Lin +"License: This program is free software. It comes without any warranty, +" to the extent permitted by applicable law. You can redistribute +" it and/or modify it under the terms of the Do What The Fuck You +" Want To Public License, Version 2, as published by Sam Hocevar. +" See http://sam.zoy.org/wtfpl/COPYING for more details. +"============================================================================ +" +" The setting 'g:syntastic_oclint_config_file' allows you to define a file +" that contains additional compiler arguments like include directories or +" CFLAGS. The file is expected to contain one option per line. If none is +" given the filename defaults to '.syntastic_oclint_config': +" +" let g:syntastic_oclint_config_file = '.config' + +if exists("g:loaded_syntastic_c_oclint_checker") + finish +endif +let g:loaded_syntastic_c_oclint_checker = 1 + +function! SyntaxCheckers_c_oclint_IsAvailable() + return executable("oclint") +endfunction + +if !exists('g:syntastic_oclint_config_file') + let g:syntastic_oclint_config_file = '.syntastic_oclint_config' +endif + +function! SyntaxCheckers_c_oclint_GetLocList() + let makeprg = syntastic#makeprg#build({ + \ 'exe': 'oclint', + \ 'args': '-text', + \ 'post_args': '-- -c ' . syntastic#c#ReadConfig(g:syntastic_oclint_config_file), + \ 'filetype': 'c', + \ 'subchecker': 'oclint' }) + + let errorformat = + \ '%E%f:%l:%c: %m P1 ,' . + \ '%E%f:%l:%c: %m P2 ,' . + \ '%W%f:%l:%c: %m P3 ,' . + \ '%E%f:%l:%c: fatal error: %m,' . + \ '%E%f:%l:%c: error: %m,' . + \ '%W%f:%l:%c: warning: %m,' . + \ '%-G%.%#' + + return SyntasticMake({ + \ 'makeprg': makeprg, + \ 'errorformat': errorformat, + \ 'subtype': 'Style', + \ 'postprocess': ['compressWhitespace', 'sort'] }) +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'c', + \ 'name': 'oclint'}) diff --git a/sources_non_forked/syntastic/syntax_checkers/c/sparse.vim b/sources_non_forked/syntastic/syntax_checkers/c/sparse.vim new file mode 100644 index 00000000..0307e324 --- /dev/null +++ b/sources_non_forked/syntastic/syntax_checkers/c/sparse.vim @@ -0,0 +1,51 @@ +"============================================================================ +"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("g:loaded_syntastic_c_sparse_checker") + finish +endif +let g:loaded_syntastic_c_sparse_checker = 1 + +function! SyntaxCheckers_c_sparse_IsAvailable() + return executable("sparse") +endfunction + +if !exists('g:syntastic_sparse_config_file') + let g:syntastic_sparse_config_file = '.syntastic_sparse_config' +endif + +function! SyntaxCheckers_c_sparse_GetLocList() + let makeprg = syntastic#makeprg#build({ + \ 'exe': 'sparse', + \ 'args': '-ftabstop=' . &ts . ' ' . syntastic#c#ReadConfig(g:syntastic_sparse_config_file), + \ 'filetype': 'c', + \ 'subchecker': 'sparse' }) + + let errorformat = '%f:%l:%v: %trror: %m,%f:%l:%v: %tarning: %m,' + + let loclist = SyntasticMake({ + \ 'makeprg': makeprg, + \ 'errorformat': errorformat, + \ 'defaults': {'bufnr': bufnr("")}, + \ 'returns': [0] }) + return loclist +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'c', + \ 'name': 'sparse'}) diff --git a/sources_non_forked/syntastic/syntax_checkers/c/splint.vim b/sources_non_forked/syntastic/syntax_checkers/c/splint.vim new file mode 100644 index 00000000..6b2a1c1b --- /dev/null +++ b/sources_non_forked/syntastic/syntax_checkers/c/splint.vim @@ -0,0 +1,57 @@ +"============================================================================ +"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("g:loaded_syntastic_c_splint_checker") + finish +endif +let g:loaded_syntastic_c_splint_checker = 1 + +function! SyntaxCheckers_c_splint_IsAvailable() + return executable("splint") +endfunction + +if !exists('g:syntastic_splint_config_file') + let g:syntastic_splint_config_file = '.syntastic_splint_config' +endif + +function! SyntaxCheckers_c_splint_GetLocList() + let makeprg = syntastic#makeprg#build({ + \ 'exe': 'splint', + \ 'post_args': '-showfunc -hints +quiet ' . syntastic#c#ReadConfig(g:syntastic_splint_config_file), + \ 'filetype': 'c', + \ 'subchecker': 'splint' }) + + let errorformat = + \ '%-G%f:%l:%v: %[%#]%[%#]%[%#] Internal Bug %.%#,' . + \ '%W%f:%l:%v: %m,' . + \ '%W%f:%l: %m,' . + \ '%-C %\+In file included from %.%#,' . + \ '%-C %\+from %.%#,' . + \ '%+C %.%#' + + return SyntasticMake({ + \ 'makeprg': makeprg, + \ 'errorformat': errorformat, + \ 'subtype': 'Style', + \ 'postprocess': ['compressWhitespace'], + \ 'defaults': {'type': 'W'} }) +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'c', + \ 'name': 'splint'}) diff --git a/sources_non_forked/syntastic/syntax_checkers/c/ycm.vim b/sources_non_forked/syntastic/syntax_checkers/c/ycm.vim new file mode 100644 index 00000000..5cce6fc5 --- /dev/null +++ b/sources_non_forked/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("g:loaded_syntastic_c_ycm_checker") + finish +endif +let g:loaded_syntastic_c_ycm_checker = 1 + +function! SyntaxCheckers_c_ycm_IsAvailable() + return exists('g:loaded_youcompleteme') +endfunction + +if !exists('g:loaded_youcompleteme') + finish +endif + +function! SyntaxCheckers_c_ycm_GetLocList() + return youcompleteme#CurrentFileDiagnostics() +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'c', + \ 'name': 'ycm'}) diff --git a/sources_non_forked/syntastic/syntax_checkers/co/coco.vim b/sources_non_forked/syntastic/syntax_checkers/co/coco.vim new file mode 100644 index 00000000..a3186108 --- /dev/null +++ b/sources_non_forked/syntastic/syntax_checkers/co/coco.vim @@ -0,0 +1,44 @@ +"============================================================================ +"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', + \ 'filetype': 'co', + \ 'subchecker': 'coco' }) + + let errorformat = + \ '%EFailed at: %f,' . + \ '%ZSyntax%trror: %m on line %l,'. + \ '%EFailed at: %f,'. + \ '%Z%trror: Parse error on line %l: %m' + + return SyntasticMake({ 'makeprg': makeprg, 'errorformat': errorformat }) +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'co', + \ 'name': 'coco'}) diff --git a/sources_non_forked/syntastic/syntax_checkers/coffee/coffee.vim b/sources_non_forked/syntastic/syntax_checkers/coffee/coffee.vim new file mode 100644 index 00000000..846180b9 --- /dev/null +++ b/sources_non_forked/syntastic/syntax_checkers/coffee/coffee.vim @@ -0,0 +1,48 @@ +"============================================================================ +"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. +" +"============================================================================ +" +" Note: this script requires CoffeeScript version 1.6.2 or newer. +" +if exists("g:loaded_syntastic_coffee_coffee_checker") + finish +endif +let g:loaded_syntastic_coffee_coffee_checker=1 + +function! SyntaxCheckers_coffee_coffee_IsAvailable() + return executable("coffee") && + \ syntastic#util#versionIsAtLeast(syntastic#util#parseVersion('coffee --version 2>' . syntastic#util#DevNull()), [1,6,2]) +endfunction + +function! SyntaxCheckers_coffee_coffee_GetLocList() + let makeprg = syntastic#makeprg#build({ + \ 'exe': 'coffee', + \ 'args': '-cp', + \ 'filetype': 'coffee', + \ 'subchecker': 'coffee' }) + + let errorformat = + \ '%E%f:%l:%c: %trror: %m,' . + \ 'Syntax%trror: In %f\, %m on line %l,' . + \ '%EError: In %f\, Parse error on line %l: %m,' . + \ '%EError: In %f\, %m on line %l,' . + \ '%W%f(%l): lint warning: %m,' . + \ '%W%f(%l): warning: %m,' . + \ '%E%f(%l): SyntaxError: %m,' . + \ '%-Z%p^,' . + \ '%-G%.%#' + + return SyntasticMake({ 'makeprg': makeprg, 'errorformat': errorformat }) +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'coffee', + \ 'name': 'coffee'}) diff --git a/sources_non_forked/syntastic/syntax_checkers/coffee/coffeelint.vim b/sources_non_forked/syntastic/syntax_checkers/coffee/coffeelint.vim new file mode 100644 index 00000000..2099359c --- /dev/null +++ b/sources_non_forked/syntastic/syntax_checkers/coffee/coffeelint.vim @@ -0,0 +1,43 @@ +"============================================================================ +"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', + \ 'args': '--csv', + \ 'filetype': 'coffee', + \ 'subchecker': 'coffeelint' }) + + let errorformat = + \ '%f\,%l\,%\d%#\,%trror\,%m,' . + \ '%f\,%l\,%trror\,%m,' . + \ '%f\,%l\,%\d%#\,%tarn\,%m,' . + \ '%f\,%l\,%tarn\,%m' + + return SyntasticMake({ + \ 'makeprg': makeprg, + \ 'errorformat': errorformat, + \ 'subtype': 'Style', + \ 'returns': [0, 1] }) +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'coffee', + \ 'name': 'coffeelint'}) diff --git a/sources_non_forked/syntastic/syntax_checkers/coq/coqtop.vim b/sources_non_forked/syntastic/syntax_checkers/coq/coqtop.vim new file mode 100644 index 00000000..f1efa4d8 --- /dev/null +++ b/sources_non_forked/syntastic/syntax_checkers/coq/coqtop.vim @@ -0,0 +1,40 @@ +"============================================================================ +"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', + \ 'filetype': 'coq', + \ 'subchecker': 'coqtop' }) + + let errorformat = + \ '%AFile \"%f\"\, line %l\, characters %c\-%.%#\:,'. + \ '%C%m' + + return SyntasticMake({ + \ 'makeprg': makeprg, + \ 'errorformat': errorformat }) +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'coq', + \ 'name': 'coqtop'}) diff --git a/sources_non_forked/syntastic/syntax_checkers/cpp/cpplint.vim b/sources_non_forked/syntastic/syntax_checkers/cpp/cpplint.vim new file mode 100644 index 00000000..35e77ccc --- /dev/null +++ b/sources_non_forked/syntastic/syntax_checkers/cpp/cpplint.vim @@ -0,0 +1,65 @@ +"============================================================================ +"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', + \ 'filetype': 'cpp', + \ 'subchecker': 'cpplint' }) + + let errorformat = '%A%f:%l: %m [%t],%-G%.%#' + + let loclist = SyntasticMake({ + \ 'makeprg': makeprg, + \ 'errorformat': errorformat, + \ 'subtype': 'Style' }) + + " change error types according to the prescribed threshold + for n in range(len(loclist)) + let loclist[n]['type'] = loclist[n]['type'] < g:syntastic_cpp_cpplint_thres ? 'W' : 'E' + endfor + + return loclist +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'cpp', + \ 'name': 'cpplint'}) diff --git a/sources_non_forked/syntastic/syntax_checkers/cpp/gcc.vim b/sources_non_forked/syntastic/syntax_checkers/cpp/gcc.vim new file mode 100644 index 00000000..40b2a105 --- /dev/null +++ b/sources_non_forked/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 .= ' ' . syntastic#util#shexpand('%') . + \ ' ' . syntastic#c#GetIncludeDirs('cpp') + + " determine whether to parse header files as well + if expand('%') =~? '\.\(h\|hpp\|hh\)$' + if exists('g:syntastic_cpp_check_header') + let makeprg = g:syntastic_cpp_compiler . + \ ' -c ' . syntastic#util#shexpand('%') . + \ ' ' . g:syntastic_cpp_compiler_options . + \ ' ' . syntastic#c#GetNullDevice() . + \ ' ' . syntastic#c#GetIncludeDirs('cpp') + else + return [] + endif + endif + + " check if the user manually set some cflags + if !exists('b:syntastic_cpp_cflags') + " check whether to search for include files at all + if !exists('g:syntastic_cpp_no_include_search') || + \ g:syntastic_cpp_no_include_search != 1 + " refresh the include file search if desired + if exists('g:syntastic_cpp_auto_refresh_includes') && + \ g:syntastic_cpp_auto_refresh_includes != 0 + let makeprg .= syntastic#c#SearchHeaders() + else + " search for header includes if not cached already + if !exists('b:syntastic_cpp_includes') + let b:syntastic_cpp_includes = syntastic#c#SearchHeaders() + endif + let makeprg .= b:syntastic_cpp_includes + endif + endif + else + " use the user-defined cflags + let makeprg .= b:syntastic_cpp_cflags + endif + + " add optional config file parameters + let makeprg .= ' ' . syntastic#c#ReadConfig(g:syntastic_cpp_config_file) + + " process makeprg + let errors = SyntasticMake({ 'makeprg': makeprg, + \ 'errorformat': errorformat }) + + " filter the processed errors if desired + if exists('g:syntastic_cpp_remove_include_errors') && + \ g:syntastic_cpp_remove_include_errors != 0 + return filter(errors, + \ 'has_key(v:val, "bufnr") && v:val["bufnr"]=='.bufnr('')) + else + return errors + endif +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'cpp', + \ 'name': 'gcc'}) + +let &cpo = s:save_cpo +unlet s:save_cpo + +" vim: set et sts=4 sw=4: diff --git a/sources_non_forked/syntastic/syntax_checkers/cpp/oclint.vim b/sources_non_forked/syntastic/syntax_checkers/cpp/oclint.vim new file mode 100644 index 00000000..867f15de --- /dev/null +++ b/sources_non_forked/syntastic/syntax_checkers/cpp/oclint.vim @@ -0,0 +1,36 @@ +"============================================================================ +"File: oclint.vim +"Description: Syntax checking plugin for syntastic.vim +"Maintainer: "UnCO" Lin +"License: This program is free software. It comes without any warranty, +" to the extent permitted by applicable law. You can redistribute +" it and/or modify it under the terms of the Do What The Fuck You +" Want To Public License, Version 2, as published by Sam Hocevar. +" See http://sam.zoy.org/wtfpl/COPYING for more details. +"============================================================================ +" +" The setting 'g:syntastic_oclint_config_file' allows you to define a file +" that contains additional compiler arguments like include directories or +" CFLAGS. The file is expected to contain one option per line. If none is +" given the filename defaults to '.syntastic_oclint_config': +" +" let g:syntastic_oclint_config_file = '.config' + +if exists("g:loaded_syntastic_cpp_oclint_checker") + finish +endif +let g:loaded_syntastic_cpp_oclint_checker = 1 + +function! SyntaxCheckers_cpp_oclint_IsAvailable() + return SyntaxCheckers_c_oclint_IsAvailable() +endfunction + +function! SyntaxCheckers_cpp_oclint_GetLocList() + return SyntaxCheckers_c_oclint_GetLocList() +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'cpp', + \ 'name': 'oclint'}) + +runtime! syntax_checkers/c/*.vim diff --git a/sources_non_forked/syntastic/syntax_checkers/cpp/ycm.vim b/sources_non_forked/syntastic/syntax_checkers/cpp/ycm.vim new file mode 100644 index 00000000..b0dbab58 --- /dev/null +++ b/sources_non_forked/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("g:loaded_syntastic_cpp_ycm_checker") + finish +endif +let g:loaded_syntastic_cpp_ycm_checker = 1 + +function! SyntaxCheckers_cpp_ycm_IsAvailable() + return SyntaxCheckers_c_ycm_IsAvailable() +endfunction + +if !exists('g:loaded_youcompleteme') + finish +endif + +function! SyntaxCheckers_cpp_ycm_GetLocList() + return SyntaxCheckers_c_ycm_GetLocList() +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'cpp', + \ 'name': 'ycm'}) + +runtime! syntax_checkers/c/*.vim diff --git a/sources_non_forked/syntastic/syntax_checkers/cs/mcs.vim b/sources_non_forked/syntastic/syntax_checkers/cs/mcs.vim new file mode 100644 index 00000000..b3c96a95 --- /dev/null +++ b/sources_non_forked/syntastic/syntax_checkers/cs/mcs.vim @@ -0,0 +1,39 @@ +"============================================================================ +"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', + \ 'filetype': 'cs', + \ 'subchecker': 'mcs' }) + + let errorformat = '%f(%l\,%c): %trror %m' + + return SyntasticMake({ + \ 'makeprg': makeprg, + \ 'errorformat': errorformat, + \ 'defaults': {'bufnr': bufnr("")} }) +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'cs', + \ 'name': 'mcs'}) diff --git a/sources_non_forked/syntastic/syntax_checkers/css/csslint.vim b/sources_non_forked/syntastic/syntax_checkers/css/csslint.vim new file mode 100644 index 00000000..9093d982 --- /dev/null +++ b/sources_non_forked/syntastic/syntax_checkers/css/csslint.vim @@ -0,0 +1,58 @@ +"============================================================================ +"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_exec') + let g:syntastic_csslint_exec = 'csslint' +endif + +if !exists('g:syntastic_csslint_options') + let g:syntastic_csslint_options = '' +endif + +function! SyntaxCheckers_css_csslint_IsAvailable() + return executable(expand(g:syntastic_csslint_exec)) +endfunction + +function! SyntaxCheckers_css_csslint_GetLocList() + let makeprg = syntastic#makeprg#build({ + \ 'exe': expand(g:syntastic_csslint_exec), + \ 'args': '--format=compact ' . g:syntastic_csslint_options, + \ 'filetype': 'css', + \ 'subchecker': 'csslint' }) + + " Print CSS Lint's error/warning messages from compact format. Ignores blank lines. + let errorformat = + \ '%-G,' . + \ '%-G%f: lint free!,' . + \ '%f: line %l\, col %c\, %trror - %m,' . + \ '%f: line %l\, col %c\, %tarning - %m,'. + \ '%f: line %l\, col %c\, %m,' + + return SyntasticMake({ + \ 'makeprg': makeprg, + \ 'errorformat': errorformat, + \ 'defaults': {'bufnr': bufnr("")} }) + +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'css', + \ 'name': 'csslint'}) diff --git a/sources_non_forked/syntastic/syntax_checkers/css/phpcs.vim b/sources_non_forked/syntastic/syntax_checkers/css/phpcs.vim new file mode 100644 index 00000000..ffcb7fee --- /dev/null +++ b/sources_non_forked/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 + +function! SyntaxCheckers_css_phpcs_IsAvailable() + return SyntaxCheckers_php_phpcs_IsAvailable() +endfunction + +function! SyntaxCheckers_css_phpcs_GetLocList() + return SyntaxCheckers_php_phpcs_GetLocList() +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'css', + \ 'name': 'phpcs'}) + +runtime! syntax_checkers/php/*.vim diff --git a/sources_non_forked/syntastic/syntax_checkers/css/prettycss.vim b/sources_non_forked/syntastic/syntax_checkers/css/prettycss.vim new file mode 100644 index 00000000..c3cd9de1 --- /dev/null +++ b/sources_non_forked/syntastic/syntax_checkers/css/prettycss.vim @@ -0,0 +1,62 @@ +"============================================================================ +"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', + \ 'filetype': 'css', + \ 'subchecker': 'prettycss' }) + + " Print CSS Lint's error/warning messages from compact format. Ignores blank lines. + let errorformat = + \ '%EError: %m\, line %l\, char %c),' . + \ '%WWarning: %m\, line %l\, char %c),' . + \ '%-G%.%#' + + let loclist = SyntasticMake({ + \ 'makeprg': makeprg, + \ 'errorformat': errorformat, + \ 'defaults': {'bufnr': bufnr("")}, + \ 'postprocess': ['sort'] }) + + for n in range(len(loclist)) + let loclist[n]["text"] .= ')' + endfor + + return loclist +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'css', + \ 'name': 'prettycss'}) diff --git a/sources_non_forked/syntastic/syntax_checkers/cucumber/cucumber.vim b/sources_non_forked/syntastic/syntax_checkers/cucumber/cucumber.vim new file mode 100644 index 00000000..4458c78f --- /dev/null +++ b/sources_non_forked/syntastic/syntax_checkers/cucumber/cucumber.vim @@ -0,0 +1,42 @@ +"============================================================================ +"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', + \ 'filetype': 'cucumber', + \ 'subchecker': 'cucumber' }) + + let errorformat = + \ '%f:%l:%c:%m,' . + \ '%W %.%# (%m),' . + \ '%-Z%f:%l:%.%#,'. + \ '%-G%.%#' + + return SyntasticMake({ + \ 'makeprg': makeprg, + \ 'errorformat': errorformat }) +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'cucumber', + \ 'name': 'cucumber'}) diff --git a/sources_non_forked/syntastic/syntax_checkers/cuda/nvcc.vim b/sources_non_forked/syntastic/syntax_checkers/cuda/nvcc.vim new file mode 100644 index 00000000..7bc6c4bb --- /dev/null +++ b/sources_non_forked/syntastic/syntax_checkers/cuda/nvcc.vim @@ -0,0 +1,72 @@ +"============================================================================ +"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 ' . + \ syntastic#util#shexpand('%') . ' ' . syntastic#c#GetNullDevice() + let errorformat = + \ '%*[^"]"%f"%*\D%l: %m,'. + \ '"%f"%*\D%l: %m,'. + \ '%-G%f:%l: (Each undeclared identifier is reported only once,'. + \ '%-G%f:%l: for each function it appears in.),'. + \ '%f:%l:%c:%m,'. + \ '%f(%l):%m,'. + \ '%f:%l:%m,'. + \ '"%f"\, line %l%*\D%c%*[^ ] %m,'. + \ '%D%*\a[%*\d]: Entering directory `%f'','. + \ '%X%*\a[%*\d]: Leaving directory `%f'','. + \ '%D%*\a: Entering directory `%f'','. + \ '%X%*\a: Leaving directory `%f'','. + \ '%DMaking %*\a in %f,'. + \ '%f|%l| %m' + + if expand('%') =~? '\%(.h\|.hpp\|.cuh\)$' + if exists('g:syntastic_cuda_check_header') + let makeprg = + \ 'echo > .syntastic_dummy.cu ; ' . + \ 'nvcc ' . arch_flag . ' --cuda -O0 -I . .syntastic_dummy.cu -Xcompiler -fsyntax-only -include ' . + \ syntastic#util#shexpand('%') . ' ' . syntastic#c#GetNullDevice() + else + return [] + endif + endif + + return SyntasticMake({ 'makeprg': makeprg, 'errorformat': errorformat }) +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'cuda', + \ 'name': 'nvcc'}) diff --git a/sources_non_forked/syntastic/syntax_checkers/d/dmd.vim b/sources_non_forked/syntastic/syntax_checkers/d/dmd.vim new file mode 100644 index 00000000..17228e41 --- /dev/null +++ b/sources_non_forked/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 .= ' ' . syntastic#util#shexpand('%') . + \ ' ' . syntastic#c#GetIncludeDirs('d') + + " determine whether to parse header files as well + if expand('%') =~? '\.di$' + if exists('g:syntastic_d_check_header') + let makeprg = g:syntastic_d_compiler . + \ ' -c ' . syntastic#util#shexpand('%') . + \ ' -of' . syntastic#util#DevNull() . + \ ' ' . g:syntastic_d_compiler_options . + \ ' ' . syntastic#c#GetIncludeDirs('d') + else + return [] + endif + endif + + " check if the user manually set some cflags + if !exists('b:syntastic_d_cflags') + " check whether to search for include files at all + if !exists('g:syntastic_d_no_include_search') || + \ g:syntastic_d_no_include_search != 1 + " refresh the include file search if desired + if exists('g:syntastic_d_auto_refresh_includes') && + \ g:syntastic_d_auto_refresh_includes != 0 + let makeprg .= syntastic#c#SearchHeaders() + else + " search for header includes if not cached already + if !exists('b:syntastic_d_includes') + let b:syntastic_d_includes = syntastic#c#SearchHeaders() + endif + let makeprg .= b:syntastic_d_includes + endif + endif + else + " use the user-defined cflags + let makeprg .= b:syntastic_d_cflags + endif + + " add optional config file parameters + let makeprg .= ' ' . syntastic#c#ReadConfig(g:syntastic_d_config_file) + + " process makeprg + let errors = SyntasticMake({ 'makeprg': makeprg, + \ 'errorformat': errorformat }) + + " filter the processed errors if desired + if exists('g:syntastic_d_remove_include_errors') && + \ g:syntastic_d_remove_include_errors != 0 + return filter(errors, + \ 'has_key(v:val, "bufnr") && v:val["bufnr"]=='.bufnr('')) + else + return errors + endif +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'd', + \ 'name': 'dmd'}) + +let &cpo = s:save_cpo +unlet s:save_cpo + +" vim: set et sts=4 sw=4: diff --git a/sources_non_forked/syntastic/syntax_checkers/dart/dart_analyzer.vim b/sources_non_forked/syntastic/syntax_checkers/dart/dart_analyzer.vim new file mode 100644 index 00000000..a0835c41 --- /dev/null +++ b/sources_non_forked/syntastic/syntax_checkers/dart/dart_analyzer.vim @@ -0,0 +1,66 @@ +"============================================================================ +"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, + \ 'filetype': 'dart', + \ 'subchecker': 'dart_analyzer' }) + + " Machine readable format looks like: + " SEVERITY|TYPE|ERROR_CODE|file:FILENAME|LINE_NUMBER|COLUMN|LENGTH|MESSAGE + " SEVERITY: (WARNING|ERROR) + " TYPE: (RESOLVER|STATIC_TYPE|...) + " ERROR_CODE: (NO_SUCH_TYPE|...) + " FILENAME: String + " LINE_NUMBER: int + " COLUMN: int + " LENGHT: int + " MESSAGE: String + + " We use %n to grab the error length to be able to access it in the matcher. + let commonformat = '|%.%#|%.%#|file:%f|%l|%c|%n|%m' + + " TODO(amouravski): simply take everything after ERROR|WARNING as a message + " and then parse it by hand later. + let errorformat = '%EERROR'.l:commonformat.','. + \'%WWARNING'.l:commonformat + + return SyntasticMake({ + \ 'makeprg': makeprg, + \ 'errorformat': errorformat }) +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'dart', + \ 'name': 'dart_analyzer'}) diff --git a/sources_non_forked/syntastic/syntax_checkers/docbk/xmllint.vim b/sources_non_forked/syntastic/syntax_checkers/docbk/xmllint.vim new file mode 100644 index 00000000..cc0e3e35 --- /dev/null +++ b/sources_non_forked/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 + +function! SyntaxCheckers_docbk_xmllint_IsAvailable() + return SyntaxCheckers_xml_xmllint_IsAvailable() +endfunction + +function! SyntaxCheckers_docbk_xmllint_GetLocList() + return SyntaxCheckers_xml_xmllint_GetLocList() +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'docbk', + \ 'name': 'xmllint'}) + +runtime! syntax_checkers/xml/*.vim diff --git a/sources_non_forked/syntastic/syntax_checkers/elixir/elixir.vim b/sources_non_forked/syntastic/syntax_checkers/elixir/elixir.vim new file mode 100644 index 00000000..521e9456 --- /dev/null +++ b/sources_non_forked/syntastic/syntax_checkers/elixir/elixir.vim @@ -0,0 +1,45 @@ +"============================================================================ +"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 + +" TODO: we should probably split this into separate checkers +function! SyntaxCheckers_elixir_elixir_IsAvailable() + return executable('elixir') && executable('mix') +endfunction + +function! SyntaxCheckers_elixir_elixir_GetLocList() + + let make_options = {} + let compile_command = 'elixir' + let mix_file = syntastic#util#findInParent('mix.exs', expand('%:p:h')) + + if filereadable(mix_file) + let compile_command = 'mix compile' + let make_options['cwd'] = fnamemodify(mix_file, ':p:h') + endif + + let make_options['makeprg'] = syntastic#makeprg#build({ + \ 'exe': compile_command, + \ 'filetype': 'elixir', + \ 'subchecker': 'elixir' }) + + let make_options['errorformat'] = '** %*[^\ ] %f:%l: %m' + + return SyntasticMake(make_options) +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'elixir', + \ 'name': 'elixir'}) diff --git a/sources_non_forked/syntastic/syntax_checkers/erlang/erlang.vim b/sources_non_forked/syntastic/syntax_checkers/erlang/erlang.vim new file mode 100644 index 00000000..967b759d --- /dev/null +++ b/sources_non_forked/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 ' . syntastic#util#shexpand('%:p') + else + let makeprg = 'escript ' . s:check_file . ' ' . syntastic#util#shexpand('%:p') . ' ' . g:syntastic_erlc_include_path + endif + else + let makeprg = 'escript ' . s:check_file . ' ' . syntastic#util#shexpand('%:p') . ' '. g:syntastic_erlc_include_path + endif + let errorformat = + \ '%f:%l:\ %tarning:\ %m,'. + \ '%E%f:%l:\ %m' + + return SyntasticMake({ 'makeprg': makeprg, 'errorformat': errorformat }) +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'erlang', + \ 'name': 'escript'}) diff --git a/sources_non_forked/syntastic/syntax_checkers/erlang/erlang_check_file.erl b/sources_non_forked/syntastic/syntax_checkers/erlang/erlang_check_file.erl new file mode 100644 index 00000000..54cc9366 --- /dev/null +++ b/sources_non_forked/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/sources_non_forked/syntastic/syntax_checkers/eruby/ruby.vim b/sources_non_forked/syntastic/syntax_checkers/eruby/ruby.vim new file mode 100644 index 00000000..74e77a06 --- /dev/null +++ b/sources_non_forked/syntastic/syntax_checkers/eruby/ruby.vim @@ -0,0 +1,65 @@ +"============================================================================ +"File: ruby.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 exe = expand(g:syntastic_ruby_exec) + if !has('win32') + let exe = 'RUBYOPT= ' . exe + endif + + let fname = "'" . escape(expand('%'), "\\'") . "'" + + " TODO: encodings became useful in ruby 1.9 :) + if syntastic#util#versionIsAtLeast(syntastic#util#parseVersion('ruby --version'), [1, 9]) + let enc = &fileencoding != '' ? &fileencoding : &encoding + let encoding_spec = ', :encoding => "' . (enc ==? 'utf-8' ? 'UTF-8' : 'BINARY') . '"' + else + let encoding_spec = '' + endif + + "gsub fixes issue #7, rails has it's own eruby syntax + let makeprg = + \ exe . ' -rerb -e ' . + \ syntastic#util#shescape('puts ERB.new(File.read(' . + \ fname . encoding_spec . + \ ').gsub(''<%='',''<%''), nil, ''-'').src') . + \ ' | ' . exe . ' -c' + + let errorformat = + \ '%-GSyntax OK,'. + \ '%E-:%l: syntax error\, %m,%Z%p^,'. + \ '%W-:%l: warning: %m,'. + \ '%Z%p^,'. + \ '%-C%.%#' + + return SyntasticMake({ + \ 'makeprg': makeprg, + \ 'errorformat': errorformat, + \ 'defaults': { 'bufnr': bufnr(""), 'vcol': 1 } }) +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'eruby', + \ 'name': 'ruby'}) diff --git a/sources_non_forked/syntastic/syntax_checkers/fortran/gfortran.vim b/sources_non_forked/syntastic/syntax_checkers/fortran/gfortran.vim new file mode 100644 index 00000000..0df45d3a --- /dev/null +++ b/sources_non_forked/syntastic/syntax_checkers/fortran/gfortran.vim @@ -0,0 +1,63 @@ +"============================================================================ +"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(), + \ 'filetype': 'fortran', + \ 'subchecker': 'gfortran' }) + + let errorformat = + \ '%-C %#,'. + \ '%-C %#%.%#,'. + \ '%A%f:%l.%c:,'. + \ '%Z%m,'. + \ '%G%.%#' + + return SyntasticMake({ + \ 'makeprg': makeprg, + \ 'errorformat': errorformat }) +endfunction + +function s:args() + let rv = '-fsyntax-only ' . g:syntastic_fortran_flags + if exists('b:syntastic_fortran_flags') + let rv .= " " . b:syntastic_fortran_flags + endif + return rv +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'fortran', + \ 'name': 'gfortran'}) diff --git a/sources_non_forked/syntastic/syntax_checkers/go/go.vim b/sources_non_forked/syntastic/syntax_checkers/go/go.vim new file mode 100644 index 00000000..e389012a --- /dev/null +++ b/sources_non_forked/syntastic/syntax_checkers/go/go.vim @@ -0,0 +1,75 @@ +"============================================================================ +"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 = syntastic#makeprg#build({ + \ 'exe': 'gofmt', + \ 'args': '-l', + \ 'tail': '1>' . syntastic#util#DevNull(), + \ 'filetype': 'go', + \ 'subchecker': 'go' }) + + let errorformat = + \ '%f:%l:%c: %m,' . + \ '%-G%.%#' + + let errors = SyntasticMake({ + \ 'makeprg': makeprg, + \ 'errorformat': errorformat, + \ 'defaults': {'type': 'e'} }) + if !empty(errors) + return errors + endif + + " Test files, i.e. files with a name ending in `_test.go`, are not + " compiled by `go build`, therefore `go test` must be called for those. + if match(expand('%'), '_test.go$') == -1 + let makeprg = 'go build ' . syntastic#c#GetNullDevice() + else + let makeprg = 'go test -c ' . syntastic#c#GetNullDevice() + endif + + let errorformat = + \ '%f:%l:%c:%m,' . + \ '%f:%l%m,' . + \ '%-G#%.%#' + + " The go compiler needs to either be run with an import path as an + " argument or directly from the package directory. Since figuring out + " the proper import path is fickle, just cwd to the package. + + let errors = SyntasticMake({ + \ 'makeprg': makeprg, + \ 'errorformat': errorformat, + \ 'cwd': expand('%:p:h'), + \ 'defaults': {'type': 'e'} }) + + return errors +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'go', + \ 'name': 'go'}) diff --git a/sources_non_forked/syntastic/syntax_checkers/go/gofmt.vim b/sources_non_forked/syntastic/syntax_checkers/go/gofmt.vim new file mode 100644 index 00000000..b150916f --- /dev/null +++ b/sources_non_forked/syntastic/syntax_checkers/go/gofmt.vim @@ -0,0 +1,42 @@ +"============================================================================ +"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(), + \ 'filetype': 'go', + \ '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/sources_non_forked/syntastic/syntax_checkers/go/golint.vim b/sources_non_forked/syntastic/syntax_checkers/go/golint.vim new file mode 100644 index 00000000..954a7c2a --- /dev/null +++ b/sources_non_forked/syntastic/syntax_checkers/go/golint.vim @@ -0,0 +1,37 @@ +"============================================================================ +"File: golint.vim +"Description: Check go syntax using 'golint' +"Maintainer: Hiroshi Ioka +"License: This program is free software. It comes without any warranty, +" to the extent permitted by applicable law. You can redistribute +" it and/or modify it under the terms of the Do What The Fuck You +" Want To Public License, Version 2, as published by Sam Hocevar. +" See http://sam.zoy.org/wtfpl/COPYING for more details. +" +"============================================================================ +if exists("g:loaded_syntastic_go_golint_checker") + finish +endif +let g:loaded_syntastic_go_golint_checker=1 + +function! SyntaxCheckers_go_golint_IsAvailable() + return executable('golint') +endfunction + +function! SyntaxCheckers_go_golint_GetLocList() + let makeprg = syntastic#makeprg#build({ + \ 'exe': 'golint', + \ 'filetype': 'go', + \ 'subchecker': 'golint' }) + + let errorformat = '%f:%l:%c: %m,%-G%.%#' + + return SyntasticMake({ + \ 'makeprg': makeprg, + \ 'errorformat': errorformat, + \ 'subtype': 'Style' }) +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'go', + \ 'name': 'golint'}) diff --git a/sources_non_forked/syntastic/syntax_checkers/go/govet.vim b/sources_non_forked/syntastic/syntax_checkers/go/govet.vim new file mode 100644 index 00000000..4b1d7efb --- /dev/null +++ b/sources_non_forked/syntastic/syntax_checkers/go/govet.vim @@ -0,0 +1,40 @@ +"============================================================================ +"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 compiler needs to either be run with an import path as an + " argument or directly from the package directory. Since figuring out + " the proper import path is fickle, just cwd to the package. + + let errors = SyntasticMake({ + \ 'makeprg': makeprg, + \ 'errorformat': errorformat, + \ 'cwd': expand('%:p:h'), + \ 'defaults': {'type': 'w'} }) + + return errors +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'go', + \ 'name': 'govet'}) diff --git a/sources_non_forked/syntastic/syntax_checkers/haml/haml.vim b/sources_non_forked/syntastic/syntax_checkers/haml/haml.vim new file mode 100644 index 00000000..8371055f --- /dev/null +++ b/sources_non_forked/syntastic/syntax_checkers/haml/haml.vim @@ -0,0 +1,45 @@ +"============================================================================ +"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 + +if !exists('g:syntastic_haml_interpreter') + let g:syntastic_haml_interpreter = 'haml' +endif + +function! SyntaxCheckers_haml_haml_IsAvailable() + return executable(expand(g:syntastic_haml_interpreter)) +endfunction + +function! SyntaxCheckers_haml_haml_GetLocList() + let makeprg = syntastic#makeprg#build({ + \ 'exe': expand(g:syntastic_haml_interpreter), + \ 'args': '-c', + \ 'filetype': 'haml', + \ 'subchecker': 'haml' }) + + let errorformat = + \ 'Haml error on line %l: %m,' . + \ 'Syntax error on line %l: %m,' . + \ '%-G%.%#' + + return SyntasticMake({ + \ 'makeprg': makeprg, + \ 'errorformat': errorformat }) +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'haml', + \ 'name': 'haml'}) diff --git a/sources_non_forked/syntastic/syntax_checkers/haskell/ghc-mod.vim b/sources_non_forked/syntastic/syntax_checkers/haskell/ghc-mod.vim new file mode 100644 index 00000000..3dcc6e7e --- /dev/null +++ b/sources_non_forked/syntastic/syntax_checkers/haskell/ghc-mod.vim @@ -0,0 +1,46 @@ +"============================================================================ +"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 makeprg = syntastic#makeprg#build({ + \ 'exe': 'ghc-mod check', + \ 'filetype': 'haskell', + \ 'subchecker': 'ghc_mod' }) + + let errorformat = + \ '%-G%\s%#,' . + \ '%f:%l:%c:%trror: %m,' . + \ '%f:%l:%c:%tarning: %m,'. + \ '%f:%l:%c: %trror: %m,' . + \ '%f:%l:%c: %tarning: %m,' . + \ '%f:%l:%c:%m,' . + \ '%E%f:%l:%c:,' . + \ '%Z%m' + + return SyntasticMake({ + \ 'makeprg': makeprg, + \ 'errorformat': errorformat, + \ 'postprocess': ['compressWhitespace'] }) +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'haskell', + \ 'name': 'ghc_mod'}) diff --git a/sources_non_forked/syntastic/syntax_checkers/haskell/hdevtools.vim b/sources_non_forked/syntastic/syntax_checkers/haskell/hdevtools.vim new file mode 100644 index 00000000..3f4b0b73 --- /dev/null +++ b/sources_non_forked/syntastic/syntax_checkers/haskell/hdevtools.vim @@ -0,0 +1,46 @@ +"============================================================================ +"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', ''), + \ 'filetype': 'haskell', + \ 'subchecker': 'hdevtools' }) + + let errorformat= '\%-Z\ %#,'. + \ '%W%f:%l:%c:\ Warning:\ %m,'. + \ '%E%f:%l:%c:\ %m,'. + \ '%E%>%f:%l:%c:,'. + \ '%+C\ \ %#%m,'. + \ '%W%>%f:%l:%c:,'. + \ '%+C\ \ %#%tarning:\ %m,' + + return SyntasticMake({ + \ 'makeprg': makeprg, + \ 'errorformat': errorformat, + \ 'postprocess': ['compressWhitespace'] }) +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'haskell', + \ 'name': 'hdevtools'}) + diff --git a/sources_non_forked/syntastic/syntax_checkers/haskell/hlint.vim b/sources_non_forked/syntastic/syntax_checkers/haskell/hlint.vim new file mode 100644 index 00000000..f9f0fcd4 --- /dev/null +++ b/sources_non_forked/syntastic/syntax_checkers/haskell/hlint.vim @@ -0,0 +1,36 @@ +"============================================================================ +"File: hlint.vim +"Description: Syntax checking plugin for syntastic.vim +"Maintainer: Nicolas Wu +"License: BSD +"============================================================================ + +if exists('g:loaded_syntastic_haskell_hlint_checker') + finish +endif +let g:loaded_syntastic_haskell_hlint_checker = 1 + +function! SyntaxCheckers_haskell_hlint_IsAvailable() + return executable('hlint') +endfunction + +function! SyntaxCheckers_haskell_hlint_GetLocList() + let makeprg = syntastic#makeprg#build({ + \ 'exe': 'hlint', + \ 'filetype': 'haskell', + \ 'subchecker': 'hlint' }) + + let errorformat = + \ '%E%f:%l:%c: Error: %m,' . + \ '%W%f:%l:%c: Warning: %m,' . + \ '%C%m' + + return SyntasticMake({ + \ 'makeprg': makeprg, + \ 'errorformat': errorformat, + \ 'postprocess': ['compressWhitespace'] }) +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'haskell', + \ 'name': 'hlint'}) diff --git a/sources_non_forked/syntastic/syntax_checkers/haxe/haxe.vim b/sources_non_forked/syntastic/syntax_checkers/haxe/haxe.vim new file mode 100644 index 00000000..969a9369 --- /dev/null +++ b/sources_non_forked/syntastic/syntax_checkers/haxe/haxe.vim @@ -0,0 +1,52 @@ +"============================================================================ +"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 + +function! SyntaxCheckers_haxe_haxe_GetLocList() + if exists('b:vaxe_hxml') + let hxml = b:vaxe_hxml + elseif exists('g:vaxe_hxml') + let hxml = g:vaxe_hxml + else + let hxml = syntastic#util#findInParent('*.hxml', expand('%:p:h')) + endif + let hxml = fnamemodify(hxml, ':p') + + if !empty(hxml) + let makeprg = syntastic#makeprg#build({ + \ 'exe': 'haxe', + \ 'fname': syntastic#util#shescape(fnameescape(fnamemodify(hxml, ':t'))), + \ 'filetype': 'haxe', + \ 'subchecker': 'haxe' }) + + let errorformat = '%E%f:%l: characters %c-%*[0-9] : %m' + + return SyntasticMake({ + \ 'makeprg': makeprg, + \ 'errorformat': errorformat, + \ 'cwd': fnamemodify(hxml, ':h') }) + endif + + return [] +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'haxe', + \ 'name': 'haxe'}) diff --git a/sources_non_forked/syntastic/syntax_checkers/hss/hss.vim b/sources_non_forked/syntastic/syntax_checkers/hss/hss.vim new file mode 100644 index 00000000..5d2cf005 --- /dev/null +++ b/sources_non_forked/syntastic/syntax_checkers/hss/hss.vim @@ -0,0 +1,38 @@ +"============================================================================ +"File: hss.vim +"Description: Syntax checking plugin for syntastic.vim +"Maintainer: Justin Donaldson (jdonaldson@gmail.com) +"License: This program is free software. It comes without any warranty, +" to the extent permitted by applicable law. You can redistribute +" it and/or modify it under the terms of the Do What The Fuck You +" Want To Public License, Version 2, as published by Sam Hocevar. +" See http://sam.zoy.org/wtfpl/COPYING for more details. +" +"============================================================================ + +if exists("g:loaded_syntastic_hss_hss_checker") + finish +endif +let g:loaded_syntastic_hss_hss_checker=1 + +function! SyntaxCheckers_hss_hss_IsAvailable() + return executable('hss') +endfunction + +function! SyntaxCheckers_hss_hss_GetLocList() + let makeprg = syntastic#makeprg#build({ + \ 'exe': 'hss', + \ 'args' : '-output ' . syntastic#util#DevNull(), + \ 'filetype': 'hss', + \ 'subchecker': 'hss' }) + + let errorformat = '%E%f:%l: %m' + + return SyntasticMake({ + \ 'makeprg': makeprg, + \ 'errorformat': errorformat }) +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'hss', + \ 'name': 'hss'}) diff --git a/sources_non_forked/syntastic/syntax_checkers/html/tidy.vim b/sources_non_forked/syntastic/syntax_checkers/html/tidy.vim new file mode 100644 index 00000000..27a97613 --- /dev/null +++ b/sources_non_forked/syntastic/syntax_checkers/html/tidy.vim @@ -0,0 +1,174 @@ +"============================================================================ +"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 +" - g:syntastic_html_tidy_blocklevel_tags (list; default: []) +" list of additional blocklevel tags, to be added to "--new-blocklevel-tags" +" - g:syntastic_html_tidy_inline_tags (list; default: []) +" list of additional inline tags, to be added to "--new-inline-tags" +" - g:syntastic_html_tidy_empty_tags (list; default: []) +" list of additional empty tags, to be added to "--new-empty-tags" + +if exists("g:loaded_syntastic_html_tidy_checker") + finish +endif +let g:loaded_syntastic_html_tidy_checker = 1 + +if !exists('g:syntastic_html_tidy_ignore_errors') + let g:syntastic_html_tidy_ignore_errors = [] +endif + +if !exists('g:syntastic_html_tidy_blocklevel_tags') + let g:syntastic_html_tidy_blocklevel_tags = [] +endif + +if !exists('g:syntastic_html_tidy_inline_tags') + let g:syntastic_html_tidy_inline_tags = [] +endif + +if !exists('g:syntastic_html_tidy_empty_tags') + let g:syntastic_html_tidy_empty_tags = [] +endif + +function! SyntaxCheckers_html_tidy_IsAvailable() + return executable('tidy') +endfunction + +" TODO: join this with xhtml.vim for DRY's sake? +function! s:TidyEncOptByFenc() + let tidy_opts = { + \'utf-8' : '-utf8', + \'ascii' : '-ascii', + \'latin1' : '-latin1', + \'iso-2022-jp' : '-iso-2022', + \'cp1252' : '-win1252', + \'macroman' : '-mac', + \'utf-16le' : '-utf16le', + \'utf-16' : '-utf16', + \'big5' : '-big5', + \'cp932' : '-shiftjis', + \'sjis' : '-shiftjis', + \'cp850' : '-ibm858', + \} + return get(tidy_opts, &fileencoding, '-utf8') +endfunction + +let s:ignore_errors = [ + \ " 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\"" + \ ] + +let s:blocklevel_tags = [ + \ "main", + \ "section", + \ "article", + \ "aside", + \ "hgroup", + \ "header", + \ "footer", + \ "nav", + \ "figure", + \ "figcaption" + \ ] + +let s:inline_tags = [ + \ "video", + \ "audio", + \ "source", + \ "embed", + \ "mark", + \ "progress", + \ "meter", + \ "time", + \ "ruby", + \ "rt", + \ "rp", + \ "canvas", + \ "command", + \ "details", + \ "datalist" + \ ] + +let s:empty_tags = [ + \ "wbr", + \ "keygen" + \ ] + +function! s:IgnoreError(text) + for i in s:ignore_errors + g:syntastic_html_tidy_ignore_errors + if stridx(a:text, i) != -1 + return 1 + endif + endfor + return 0 +endfunction + +function! s:NewTags(name) + return syntastic#util#shescape(join( s:{a:name} + g:syntastic_html_tidy_{a:name}, ',' )) +endfunction + +function s:Args() + let args = s:TidyEncOptByFenc() . + \ ' --new-blocklevel-tags ' . s:NewTags('blocklevel_tags') . + \ ' --new-inline-tags ' . s:NewTags('inline_tags') . + \ ' --new-empty-tags ' . s:NewTags('empty_tags') . + \ ' -e' + return args +endfunction + +function! SyntaxCheckers_html_tidy_GetLocList() + let makeprg = syntastic#makeprg#build({ + \ 'exe': 'tidy', + \ 'args': s:Args(), + \ 'tail': '2>&1', + \ 'filetype': 'html', + \ 'subchecker': 'tidy' }) + + let errorformat = + \ '%Wline %l column %v - Warning: %m,' . + \ '%Eline %l column %v - Error: %m,' . + \ '%-G%.%#' + + let loclist = SyntasticMake({ + \ 'makeprg': makeprg, + \ 'errorformat': errorformat, + \ 'defaults': {'bufnr': bufnr("")}, + \ 'returns': [0, 1, 2] }) + + " filter out valid HTML5 from the errors + for n in range(len(loclist)) + if loclist[n]['valid'] && s:IgnoreError(loclist[n]['text']) == 1 + let loclist[n]['valid'] = 0 + endif + endfor + + return loclist +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'html', + \ 'name': 'tidy'}) + diff --git a/sources_non_forked/syntastic/syntax_checkers/html/validator.vim b/sources_non_forked/syntastic/syntax_checkers/html/validator.vim new file mode 100644 index 00000000..04666354 --- /dev/null +++ b/sources_non_forked/syntastic/syntax_checkers/html/validator.vim @@ -0,0 +1,97 @@ +"============================================================================ +"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 ' . syntastic#util#shescape(expand(':p:h') . '/validator_decode.awk') + +function! SyntaxCheckers_html_validator_IsAvailable() + return executable('curl') && executable('awk') +endfunction + +function! SyntaxCheckers_html_validator_Preprocess(errors) + let out = copy(a:errors) + for n in range(len(out)) + let parts = matchlist(out[n], '\v^"([^"]+)"(.+)') + " URL decode, except leave alone any "+" + let parts[1] = substitute(parts[1], '\m%\(\x\x\)', '\=nr2char("0x".submatch(1))', 'g') + let parts[1] = substitute(parts[1], '\\"', '"', 'g') + let parts[1] = substitute(parts[1], '\\\\', '\\', 'g') + let out[n] = '"' . parts[1] . '"' . parts[2] + endfor + return out +endfunction + +function! SyntaxCheckers_html_validator_GetLocList() + let makeprg = 'curl -s --compressed -F out=gnu -F asciiquotes=yes' . + \ (!empty(g:syntastic_html_validator_parser) ? ' -F parser=' . g:syntastic_html_validator_parser : '') . + \ (!empty(g:syntastic_html_validator_nsfilter) ? ' -F nsfilter=' . g:syntastic_html_validator_nsfilter : '') . + \ ' -F doc=@' . syntastic#util#shexpand('%') . '\;type=text/html\;filename=' . syntastic#util#shexpand('%') . ' ' . + \ g:syntastic_html_validator_api + + let errorformat = + \ '%E"%f":%l: %trror: %m,' . + \ '%E"%f":%l-%\d%\+: %trror: %m,' . + \ '%E"%f":%l%\%.%c: %trror: %m,' . + \ '%E"%f":%l%\%.%c-%\d%\+%\%.%\d%\+: %trror: %m,' . + \ '%E"%f":%l: %trror fatal: %m,' . + \ '%E"%f":%l-%\d%\+: %trror fatal: %m,' . + \ '%E"%f":%l%\%.%c: %trror fatal: %m,' . + \ '%E"%f":%l%\%.%c-%\d%\+%\%.%\d%\+: %trror fatal: %m,' . + \ '%W"%f":%l: info %tarning: %m,' . + \ '%W"%f":%l-%\d%\+: info %tarning: %m,' . + \ '%W"%f":%l%\%.%c: info %tarning: %m,' . + \ '%W"%f":%l%\%.%c-%\d%\+%\%.%\d%\+: info %tarning: %m' + + return SyntasticMake({ + \ 'makeprg': makeprg, + \ 'errorformat': errorformat, + \ 'preprocess': 'SyntaxCheckers_html_validator_Preprocess', + \ 'returns': [0] }) +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'html', + \ 'name': 'validator'}) diff --git a/sources_non_forked/syntastic/syntax_checkers/html/w3.vim b/sources_non_forked/syntastic/syntax_checkers/html/w3.vim new file mode 100644 index 00000000..01c413cc --- /dev/null +++ b/sources_non_forked/syntastic/syntax_checkers/html/w3.vim @@ -0,0 +1,65 @@ +"============================================================================ +"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=@' . syntastic#util#shexpand('%:p') . '\;type=text/html ' . + \ g:syntastic_html_w3_api + + let errorformat = + \ '%A %\+{,' . + \ '%C %\+"lastLine": %l\,%\?,' . + \ '%C %\+"lastColumn": %c\,%\?,' . + \ '%C %\+"message": "%m"\,%\?,' . + \ '%C %\+"type": "%trror"\,%\?,' . + \ '%-G %\+"type": "%tnfo"\,%\?,' . + \ '%C %\+"subtype": "%tarning"\,%\?,' . + \ '%Z %\+}\,,' . + \ '%-G%.%#' + + let loclist = SyntasticMake({ + \ 'makeprg': makeprg, + \ 'errorformat': errorformat, + \ 'defaults': {'bufnr': bufnr("")}, + \ 'returns': [0] }) + + for n in range(len(loclist)) + let loclist[n]['text'] = substitute(loclist[n]['text'], '\\\([\"]\)', '\1', 'g') + endfor + + return loclist +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'html', + \ 'name': 'w3'}) + diff --git a/sources_non_forked/syntastic/syntax_checkers/java/checkstyle.vim b/sources_non_forked/syntastic/syntax_checkers/java/checkstyle.vim new file mode 100644 index 00000000..da5aa019 --- /dev/null +++ b/sources_non_forked/syntastic/syntax_checkers/java/checkstyle.vim @@ -0,0 +1,79 @@ +"============================================================================ +"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_Preprocess(errors) + let out = copy(a:errors) + for n in range(len(out)) + let parts = matchlist(out[n], '\(.*.*\)') + if len(parts) >= 4 + let parts[2] = syntastic#util#decodeXMLEntities(parts[2]) + let out[n] = join(parts[1:3], '') + endif + endfor + return out +endfunction + +function! SyntaxCheckers_java_checkstyle_GetLocList() + + let fname = syntastic#util#shescape( expand('%:p:h') . '/' . expand('%:t') ) + + if has('win32unix') + let fname = substitute(system('cygpath -m ' . fname), '\%x00', '', 'g') + endif + + let makeprg = syntastic#makeprg#build({ + \ 'exe': 'java', + \ 'args': '-cp ' . g:syntastic_java_checkstyle_classpath . + \ ' com.puppycrawl.tools.checkstyle.Main -c ' . g:syntastic_java_checkstyle_conf_file . + \ ' -f xml', + \ 'fname': fname, + \ 'filetype': 'java', + \ 'subchecker': 'checkstyle' }) + + let errorformat = + \ '%P,' . + \ '%Q,' . + \ '%E,' . + \ '%E,' . + \ '%E,' . + \ '%E,' . + \ '%-G%.%#' + + return SyntasticMake({ + \ 'makeprg': makeprg, + \ 'errorformat': errorformat, + \ 'subtype': 'Style', + \ 'preprocess': 'SyntaxCheckers_java_checkstyle_Preprocess', + \ 'postprocess': ['cygwinRemoveCR', 'decodeXMLEntities'] }) + +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'java', + \ 'name': 'checkstyle'}) diff --git a/sources_non_forked/syntastic/syntax_checkers/java/javac.vim b/sources_non_forked/syntastic/syntax_checkers/java/javac.vim new file mode 100644 index 00000000..122a6368 --- /dev/null +++ b/sources_non_forked/syntastic/syntax_checkers/java/javac.vim @@ -0,0 +1,366 @@ +"============================================================================ +"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 +let g:syntastic_java_javac_maven_pom_tags = ["build", "properties"] +let g:syntastic_java_javac_maven_pom_properties = {} + +" Global Options +if !exists("g:syntastic_java_javac_executable") + let g:syntastic_java_javac_executable = 'javac' +endif + +if !exists("g:syntastic_java_maven_executable") + let g:syntastic_java_maven_executable = 'mvn' +endif + +if !exists("g:syntastic_java_javac_options") + let g:syntastic_java_javac_options = '-Xlint' +endif + +if !exists("g:syntastic_java_javac_classpath") + let g:syntastic_java_javac_classpath = '' +endif + +if !exists("g:syntastic_java_javac_delete_output") + let g:syntastic_java_javac_delete_output = 1 +endif + +function! s:CygwinPath(path) + return substitute(system("cygpath -m ".a:path), '\%x00', '', 'g') +endfunction + +if !exists("g:syntastic_java_javac_temp_dir") + if has('win32') || has('win64') + let g:syntastic_java_javac_temp_dir = $TEMP."\\vim-syntastic-javac" + elseif has('win32unix') + let g:syntastic_java_javac_temp_dir = s:CygwinPath('/tmp/vim-syntastic-javac') + else + let g:syntastic_java_javac_temp_dir = '/tmp/vim-syntastic-javac' + endif +endif + +if !exists("g:syntastic_java_javac_autoload_maven_classpath") + let g:syntastic_java_javac_autoload_maven_classpath = 1 +endif + +if !exists('g:syntastic_java_javac_config_file_enabled') + let g:syntastic_java_javac_config_file_enabled = 0 +endif + +if !exists('g:syntastic_java_javac_config_file') + let g:syntastic_java_javac_config_file = '.syntastic_javac_config' +endif + +if !exists("g:syntastic_java_javac_maven_pom_ftime") + let g:syntastic_java_javac_maven_pom_ftime = {} +endif + +if !exists("g:syntastic_java_javac_maven_pom_classpath") + let g:syntastic_java_javac_maven_pom_classpath = {} +endif + +function! s:RemoveCarriageReturn(line) + return substitute(a:line, '\r', '', 'g') +endfunction + +" recursively remove directory and all it's sub-directories +function! s:RemoveDir(dir) + if isdirectory(a:dir) + for f in split(globpath(a:dir, '*'), "\n") + call s:RemoveDir(f) + endfor + silent! call system('rmdir ' . a:dir) + else + silent! call delete(a:dir) + endif +endfunction + +function! s:AddToClasspath(classpath,path) + if a:path == '' + return a:classpath + endif + if a:classpath != '' && a:path != '' + if has('win32') || has('win32unix') || has('win64') + return a:classpath . ";" . a:path + else + return a:classpath . ":" . a:path + endif + else + return a:path + endif +endfunction + +function! s:LoadClasspathFromConfigFile() + if filereadable(g:syntastic_java_javac_config_file) + let path = '' + let lines = readfile(g:syntastic_java_javac_config_file) + for l in lines + if l != '' + let path .= l . "\n" + endif + endfor + return path + else + return '' + endif +endfunction + +function! s:SaveClasspath() + let path = '' + let lines = getline(1, line('$')) + " save classpath to config file + if g:syntastic_java_javac_config_file_enabled + call writefile(lines,g:syntastic_java_javac_config_file) + endif + for l in lines + if l != '' + let path .= l . "\n" + endif + endfor + let g:syntastic_java_javac_classpath = path + let &modified = 0 +endfunction + +function! s:EditClasspath() + let command = 'syntastic javac classpath' + let winnr = bufwinnr('^' . command . '$') + if winnr < 0 + let pathlist = split(g:syntastic_java_javac_classpath,"\n") + execute (len(pathlist) + 5) . 'sp ' . fnameescape(command) + + augroup syntastic + autocmd BufWriteCmd call s:SaveClasspath() | bwipeout + augroup END + + setlocal buftype=acwrite bufhidden=wipe nobuflisted noswapfile nowrap number + for p in pathlist + call append(line('$') - 1, p) + endfor + else + execute winnr . 'wincmd w' + endif +endfunction + +function! s:GetMavenProperties() + let mvn_properties = {} + let pom = findfile("pom.xml", ".;") + if filereadable(pom) + if !has_key(g:syntastic_java_javac_maven_pom_properties, pom) + let mvn_cmd = g:syntastic_java_maven_executable . ' -f ' . pom + let mvn_is_managed_tag = 1 + let mvn_settings_output = split(system(mvn_cmd . ' help:effective-pom'), "\n") + let current_path = 'project' + for line in mvn_settings_output + let matches = matchlist(line, '^\s*<\([a-zA-Z0-9\-\.]\+\)>\s*$') + if mvn_is_managed_tag && !empty(matches) + let mvn_is_managed_tag = index(g:syntastic_java_javac_maven_pom_tags, matches[1]) >= 0 + let current_path .= '.' . matches[1] + else + let matches = matchlist(line, '^\s*\s*$') + if !empty(matches) + let mvn_is_managed_tag = index(g:syntastic_java_javac_maven_pom_tags, matches[1]) < 0 + let current_path = substitute(current_path, '\.' . matches[1] . "$", '', '') + else + let matches = matchlist(line, '^\s*<\([a-zA-Z0-9\-\.]\+\)>\(.\+\)\s*$') + if mvn_is_managed_tag && !empty(matches) + let mvn_properties[current_path . '.' . matches[1]] = matches[2] + endif + endif + endif + endfor + let g:syntastic_java_javac_maven_pom_properties[pom] = mvn_properties + endif + return g:syntastic_java_javac_maven_pom_properties[pom] + endif + return mvn_properties +endfunction + +command! SyntasticJavacEditClasspath call s:EditClasspath() + +function! s:GetMavenClasspath() + let pom = findfile("pom.xml", ".;") + if filereadable(pom) + if !has_key(g:syntastic_java_javac_maven_pom_ftime, pom) || g:syntastic_java_javac_maven_pom_ftime[pom] != getftime(pom) + let mvn_cmd = g:syntastic_java_maven_executable . ' -f ' . pom + let mvn_classpath_output = split(system(mvn_cmd . ' dependency:build-classpath'), "\n") + let class_path_next = 0 + + for line in mvn_classpath_output + if class_path_next == 1 + let mvn_classpath = s:RemoveCarriageReturn(line) + break + endif + if match(line,'Dependencies classpath:') >= 0 + let class_path_next = 1 + endif + endfor + + let mvn_properties = s:GetMavenProperties() + + let output_dir = 'target/classes' + if has_key(mvn_properties, 'project.build.outputDirectory') + let output_dir = mvn_properties['project.build.outputDirectory'] + endif + let mvn_classpath = s:AddToClasspath(mvn_classpath, output_dir) + + let test_output_dir = 'target/test-classes' + if has_key(mvn_properties, 'project.build.testOutputDirectory') + let test_output_dir = mvn_properties['project.build.testOutputDirectory'] + endif + let mvn_classpath = s:AddToClasspath(mvn_classpath, test_output_dir) + + let g:syntastic_java_javac_maven_pom_ftime[pom] = getftime(pom) + let g:syntastic_java_javac_maven_pom_classpath[pom] = mvn_classpath + endif + return g:syntastic_java_javac_maven_pom_classpath[pom] + endif + return '' +endfunction + +function! SyntaxCheckers_java_javac_IsAvailable() + return executable(g:syntastic_java_javac_executable) +endfunction + +function! s:MavenOutputDirectory() + let pom = findfile("pom.xml", ".;") + if filereadable(pom) + let mvn_properties = s:GetMavenProperties() + let output_dir = getcwd() + if has_key(mvn_properties, 'project.properties.build.dir') + let output_dir = mvn_properties['project.properties.build.dir'] + endif + if match(expand( '%:p:h' ), "src.main.java") >= 0 + let output_dir .= '/target/classes' + if has_key(mvn_properties, 'project.build.outputDirectory') + let output_dir = mvn_properties['project.build.outputDirectory'] + endif + endif + if match(expand( '%:p:h' ), "src.test.java") >= 0 + let output_dir .= '/target/test-classes' + if has_key(mvn_properties, 'project.build.testOutputDirectory') + let output_dir = mvn_properties['project.build.testOutputDirectory'] + endif + endif + + if has('win32unix') + let output_dir=s:CygwinPath(output_dir) + endif + return output_dir + endif +endfunction + +function! SyntaxCheckers_java_javac_GetLocList() + + let javac_opts = g:syntastic_java_javac_options + + if g:syntastic_java_javac_delete_output + let output_dir = g:syntastic_java_javac_temp_dir + let javac_opts .= ' -d ' . output_dir + endif + + " load classpath from config file + if g:syntastic_java_javac_config_file_enabled + let loaded_classpath = s:LoadClasspathFromConfigFile() + if loaded_classpath != '' + let g:syntastic_java_javac_classpath = loaded_classpath + endif + endif + + let javac_classpath = '' + + " add classpathes to javac_classpath + for path in split(g:syntastic_java_javac_classpath,"\n") + if path != '' + try + let ps = glob(path,0,1) + catch + let ps = split(glob(path,0),"\n") + endtry + if type(ps) == type([]) + for p in ps + if p != '' + let javac_classpath = s:AddToClasspath(javac_classpath,p) + endif + endfor + else + let javac_classpath = s:AddToClasspath(javac_classpath,ps) + endif + endif + endfor + + if g:syntastic_java_javac_autoload_maven_classpath + if !g:syntastic_java_javac_delete_output + let maven_output_dir = s:MavenOutputDirectory() + let javac_opts .= ' -d ' . maven_output_dir + endif + let maven_classpath = s:GetMavenClasspath() + let javac_classpath = s:AddToClasspath(javac_classpath,maven_classpath) + endif + + if javac_classpath != '' + let javac_opts .= ' -cp "' . fnameescape(javac_classpath) . '"' + endif + + " path seperator + if has('win32') || has('win32unix') || has('win64') + let sep = "\\" + else + let sep = '/' + endif + + let fname = fnameescape(expand ( '%:p:h' ) . sep . expand ( '%:t' )) + + if has('win32unix') + let fname = s:CygwinPath(fname) + endif + + let makeprg = syntastic#makeprg#build({ + \ 'exe': g:syntastic_java_javac_executable, + \ 'args': javac_opts, + \ 'fname': fname, + \ 'tail': '2>&1', + \ 'filetype': 'java', + \ 'subchecker': 'javac' }) + + " unashamedly stolen from *errorformat-javac* (quickfix.txt) and modified to include error types + let errorformat = + \ '%E%f:%l:\ error:\ %m,'. + \ '%W%f:%l:\ warning:\ %m,'. + \ '%A%f:%l:\ %m,'. + \ '%+Z%p^,'. + \ '%+C%.%#,'. + \ '%-G%.%#' + + if g:syntastic_java_javac_delete_output + silent! call mkdir(output_dir,'p') + endif + let errors = SyntasticMake({ + \ 'makeprg': makeprg, + \ 'errorformat': errorformat, + \ 'postprocess': ['cygwinRemoveCR'] }) + + if g:syntastic_java_javac_delete_output + call s:RemoveDir(output_dir) + endif + return errors + +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'java', + \ 'name': 'javac'}) + diff --git a/sources_non_forked/syntastic/syntax_checkers/javascript/closurecompiler.vim b/sources_non_forked/syntastic/syntax_checkers/javascript/closurecompiler.vim new file mode 100644 index 00000000..6c55f4f2 --- /dev/null +++ b/sources_non_forked/syntastic/syntax_checkers/javascript/closurecompiler.vim @@ -0,0 +1,66 @@ +"============================================================================ +"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 = syntastic#util#shexpand('%') + endif + + let makeprg = syntastic#makeprg#build({ + \ 'exe': 'java -jar ' . g:syntastic_javascript_closure_compiler_path, + \ 'args': g:syntastic_javascript_closure_compiler_options . ' --js' , + \ 'fname': file_list, + \ 'filetype': 'javascript', + \ 'subchecker': 'closurecompiler' }) + + let errorformat = + \ '%-GOK,'. + \ '%E%f:%l: ERROR - %m,'. + \ '%Z%p^,'. + \ '%W%f:%l: WARNING - %m,'. + \ '%Z%p^' + + return SyntasticMake({ + \ 'makeprg': makeprg, + \ 'errorformat': errorformat }) +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'javascript', + \ 'name': 'closurecompiler'}) + diff --git a/sources_non_forked/syntastic/syntax_checkers/javascript/gjslint.vim b/sources_non_forked/syntastic/syntax_checkers/javascript/gjslint.vim new file mode 100644 index 00000000..039d0eed --- /dev/null +++ b/sources_non_forked/syntastic/syntax_checkers/javascript/gjslint.vim @@ -0,0 +1,46 @@ +"============================================================================ +"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", + \ 'filetype': 'javascript', + \ 'subchecker': 'gjslint' }) + + let errorformat = + \ "%f:%l:(New Error -%\\?\%n) %m," . + \ "%f:%l:(-%\\?%n) %m," . + \ "%-G1 files checked," . + \ " no errors found.," . + \ "%-G%.%#" + + return SyntasticMake({ + \ 'makeprg': makeprg, + \ 'errorformat': errorformat }) +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'javascript', + \ 'name': 'gjslint'}) + diff --git a/sources_non_forked/syntastic/syntax_checkers/javascript/jshint.vim b/sources_non_forked/syntastic/syntax_checkers/javascript/jshint.vim new file mode 100644 index 00000000..caef9a7e --- /dev/null +++ b/sources_non_forked/syntastic/syntax_checkers/javascript/jshint.vim @@ -0,0 +1,59 @@ +"============================================================================ +"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_jshint_exec') + let g:syntastic_jshint_exec = 'jshint' +endif + +if !exists('g:syntastic_javascript_jshint_conf') + let g:syntastic_javascript_jshint_conf = '' +endif + +function! SyntaxCheckers_javascript_jshint_IsAvailable() + return executable(expand(g:syntastic_jshint_exec)) +endfunction + +function! SyntaxCheckers_javascript_jshint_GetLocList() + let jshint_new = s:JshintNew() + let makeprg = syntastic#makeprg#build({ + \ 'exe': expand(g:syntastic_jshint_exec), + \ 'post_args': (jshint_new ? ' --verbose ' : '') . s:Args(), + \ 'filetype': 'javascript', + \ 'subchecker': 'jshint' }) + + let errorformat = jshint_new ? + \ '%f: line %l\, col %c\, %m \(%t%*\d\)' : + \ '%E%f: line %l\, col %c\, %m' + + return SyntasticMake({ + \ 'makeprg': makeprg, + \ 'errorformat': errorformat, + \ 'defaults': {'bufnr': bufnr('')} }) +endfunction + +function s:JshintNew() + return syntastic#util#versionIsAtLeast(syntastic#util#parseVersion(expand(g:syntastic_jshint_exec) . ' --version'), [1, 1]) +endfunction + +function s:Args() + " node-jshint uses .jshintrc as config unless --config arg is present + 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/sources_non_forked/syntastic/syntax_checkers/javascript/jsl.vim b/sources_non_forked/syntastic/syntax_checkers/javascript/jsl.vim new file mode 100644 index 00000000..bef1b89a --- /dev/null +++ b/sources_non_forked/syntastic/syntax_checkers/javascript/jsl.vim @@ -0,0 +1,56 @@ +"============================================================================ +"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", + \ 'filetype': 'javascript', + \ 'subchecker': 'jsl' }) + + let errorformat = + \ '%W%f(%l): lint warning: %m,'. + \ '%-Z%p^,'. + \ '%W%f(%l): warning: %m,'. + \ '%-Z%p^,'. + \ '%E%f(%l): SyntaxError: %m,'. + \ '%-Z%p^,'. + \ '%-G' + + return SyntasticMake({ + \ 'makeprg': makeprg, + \ 'errorformat': errorformat }) +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'javascript', + \ 'name': 'jsl'}) + diff --git a/sources_non_forked/syntastic/syntax_checkers/javascript/jslint.vim b/sources_non_forked/syntastic/syntax_checkers/javascript/jslint.vim new file mode 100644 index 00000000..ab6469d4 --- /dev/null +++ b/sources_non_forked/syntastic/syntax_checkers/javascript/jslint.vim @@ -0,0 +1,53 @@ +"============================================================================ +"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, + \ 'filetype': 'javascript', + \ '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/sources_non_forked/syntastic/syntax_checkers/json/jsonlint.vim b/sources_non_forked/syntastic/syntax_checkers/json/jsonlint.vim new file mode 100644 index 00000000..7c6b34d5 --- /dev/null +++ b/sources_non_forked/syntastic/syntax_checkers/json/jsonlint.vim @@ -0,0 +1,43 @@ +"============================================================================ +"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', + \ 'filetype': 'json', + \ 'subchecker': 'jsonlint' }) + + let errorformat = + \ '%ELine %l:%c,'. + \ '%Z\\s%#Reason: %m,'. + \ '%C%.%#,'. + \ '%f: line %l\, col %c\, %m,'. + \ '%-G%.%#' + + return SyntasticMake({ + \ 'makeprg': makeprg, + \ 'errorformat': errorformat, + \ 'defaults': {'bufnr': bufnr('')} }) +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'json', + \ 'name': 'jsonlint'}) diff --git a/sources_non_forked/syntastic/syntax_checkers/json/jsonval.vim b/sources_non_forked/syntastic/syntax_checkers/json/jsonval.vim new file mode 100644 index 00000000..4359e86c --- /dev/null +++ b/sources_non_forked/syntastic/syntax_checkers/json/jsonval.vim @@ -0,0 +1,40 @@ +"============================================================================ +"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', + \ 'filetype': 'json', + \ 'subchecker': 'jsonval' }) + + let errorformat = + \ '%E%f:\ %m\ at\ line\ %l,' . + \ '%-G%.%#' + + return SyntasticMake({ + \ 'makeprg': makeprg, + \ 'errorformat': errorformat, + \ 'defaults': {'bufnr': bufnr('')} }) +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'json', + \ 'name': 'jsonval'}) diff --git a/sources_non_forked/syntastic/syntax_checkers/less/less-lint.coffee b/sources_non_forked/syntastic/syntax_checkers/less/less-lint.coffee new file mode 100644 index 00000000..0b05e4a7 --- /dev/null +++ b/sources_non_forked/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/sources_non_forked/syntastic/syntax_checkers/less/less-lint.js b/sources_non_forked/syntastic/syntax_checkers/less/less-lint.js new file mode 100644 index 00000000..5abc653c --- /dev/null +++ b/sources_non_forked/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/sources_non_forked/syntastic/syntax_checkers/less/lessc.vim b/sources_non_forked/syntastic/syntax_checkers/less/lessc.vim new file mode 100644 index 00000000..001be351 --- /dev/null +++ b/sources_non_forked/syntastic/syntax_checkers/less/lessc.vim @@ -0,0 +1,61 @@ +"============================================================================ +"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(), + \ 'filetype': 'less', + \ 'subchecker': 'lessc' }) + + let errorformat = '%m in %f:%l:%c' + + return SyntasticMake({ + \ 'makeprg': makeprg, + \ 'errorformat': errorformat, + \ 'defaults': {'bufnr': bufnr(""), 'text': "Syntax error"} }) +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'less', + \ 'name': 'lessc'}) diff --git a/sources_non_forked/syntastic/syntax_checkers/lisp/clisp.vim b/sources_non_forked/syntastic/syntax_checkers/lisp/clisp.vim new file mode 100644 index 00000000..caf094f1 --- /dev/null +++ b/sources_non_forked/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', + \ 'filetype': 'lisp', + \ 'subchecker': 'clisp' }) + + let errorformat = + \ '%-G;%.%#,' . + \ '%W%>WARNING:%.%#line %l : %m,' . + \ '%Z %#%m,' . + \ '%W%>WARNING:%.%#lines %l..%\d\# : %m,' . + \ '%Z %#%m,' . + \ '%E%>The following functions were %m,' . + \ '%Z %m,' . + \ '%-G%.%#' + + return SyntasticMake({ + \ 'makeprg': makeprg, + \ 'errorformat': errorformat, + \ 'defaults': {'bufnr': bufnr('')} }) +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'lisp', + \ 'name': 'clisp'}) diff --git a/sources_non_forked/syntastic/syntax_checkers/llvm/llvm.vim b/sources_non_forked/syntastic/syntax_checkers/llvm/llvm.vim new file mode 100644 index 00000000..ea4fa04b --- /dev/null +++ b/sources_non_forked/syntastic/syntax_checkers/llvm/llvm.vim @@ -0,0 +1,38 @@ +"============================================================================ +"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(), + \ 'filetype': 'llvm', + \ 'subchecker': 'llvm' }) + + let errorformat = 'llc: %f:%l:%c: %trror: %m' + + return SyntasticMake({ + \ 'makeprg': makeprg, + \ 'errorformat': errorformat }) +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'llvm', + \ 'name': 'llvm'}) + diff --git a/sources_non_forked/syntastic/syntax_checkers/lua/luac.vim b/sources_non_forked/syntastic/syntax_checkers/lua/luac.vim new file mode 100644 index 00000000..c26e520a --- /dev/null +++ b/sources_non_forked/syntastic/syntax_checkers/lua/luac.vim @@ -0,0 +1,64 @@ +"============================================================================ +"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', + \ 'filetype': 'lua', + \ 'subchecker': 'luac' }) + + let errorformat = 'luac: %#%f:%l: %m' + + return SyntasticMake({ + \ 'makeprg': makeprg, + \ 'errorformat': errorformat, + \ 'defaults': { 'bufnr': bufnr(''), 'type': 'E' } }) + +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'lua', + \ 'name': 'luac'}) diff --git a/sources_non_forked/syntastic/syntax_checkers/matlab/mlint.vim b/sources_non_forked/syntastic/syntax_checkers/matlab/mlint.vim new file mode 100644 index 00000000..380d22c8 --- /dev/null +++ b/sources_non_forked/syntastic/syntax_checkers/matlab/mlint.vim @@ -0,0 +1,41 @@ +"============================================================================ +"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 $*', + \ 'filetype': 'matlab', + \ 'subchecker': 'mlint' }) + + let errorformat = + \ 'L %l (C %c): %*[a-zA-Z0-9]: %m,'. + \ 'L %l (C %c-%*[0-9]): %*[a-zA-Z0-9]: %m' + + return SyntasticMake({ + \ 'makeprg': makeprg, + \ 'errorformat': errorformat, + \ 'defaults': {'bufnr': bufnr("")} }) +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'matlab', + \ 'name': 'mlint'}) diff --git a/sources_non_forked/syntastic/syntax_checkers/nasm/nasm.vim b/sources_non_forked/syntastic/syntax_checkers/nasm/nasm.vim new file mode 100644 index 00000000..9c6195cf --- /dev/null +++ b/sources_non_forked/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() + let wd = syntastic#util#shescape(expand("%:p:h") . "/") + let makeprg = syntastic#makeprg#build({ + \ 'exe': 'nasm', + \ 'args': '-X gnu -f elf -I ' . wd . ' ' . syntastic#c#GetNullDevice() + \ 'filetype': 'nasm', + \ 'subchecker': 'nasm' }) + + let errorformat = '%f:%l: %t%*[^:]: %m' + + return SyntasticMake({ + \ 'makeprg': makeprg, + \ 'errorformat': errorformat }) +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'nasm', + \ 'name': 'nasm'}) diff --git a/sources_non_forked/syntastic/syntax_checkers/nroff/mandoc.vim b/sources_non_forked/syntastic/syntax_checkers/nroff/mandoc.vim new file mode 100644 index 00000000..3333d24e --- /dev/null +++ b/sources_non_forked/syntastic/syntax_checkers/nroff/mandoc.vim @@ -0,0 +1,41 @@ +"============================================================================ +"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', + \ 'filetype': 'nroff', + \ 'subchecker': 'mandoc' }) + + let errorformat = + \ '%E%f:%l:%c: %tRROR: %m,' . + \ '%W%f:%l:%c: %tARNING: %m' + + return SyntasticMake({ + \ 'makeprg': makeprg, + \ 'errorformat': errorformat, + \ 'returns': [0, 2, 3, 4] }) +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'nroff', + \ 'name': 'mandoc'}) + diff --git a/sources_non_forked/syntastic/syntax_checkers/objc/gcc.vim b/sources_non_forked/syntastic/syntax_checkers/objc/gcc.vim new file mode 100644 index 00000000..e16822f3 --- /dev/null +++ b/sources_non_forked/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 .= ' ' . syntastic#util#shexpand('%') . + \ ' ' . syntastic#c#GetIncludeDirs('objc') + + " determine whether to parse header files as well + if expand('%') =~? '\.h$' + if exists('g:syntastic_objc_check_header') + let makeprg = g:syntastic_objc_compiler . + \ ' -x objective-c-header ' . + \ ' -c ' . syntastic#util#shexpand('%') . + \ ' ' . g:syntastic_objc_compiler_options . + \ ' ' . syntastic#c#GetIncludeDirs('objc') + else + return [] + endif + endif + + " check if the user manually set some cflags + if !exists('b:syntastic_objc_cflags') + " check whether to search for include files at all + if !exists('g:syntastic_objc_no_include_search') || + \ g:syntastic_objc_no_include_search != 1 + " refresh the include file search if desired + if exists('g:syntastic_objc_auto_refresh_includes') && + \ g:syntastic_objc_auto_refresh_includes != 0 + let makeprg .= syntastic#c#SearchHeaders() + else + " search for header includes if not cached already + if !exists('b:syntastic_objc_includes') + let b:syntastic_objc_includes = syntastic#c#SearchHeaders() + endif + let makeprg .= b:syntastic_objc_includes + endif + endif + else + " use the user-defined cflags + let makeprg .= b:syntastic_objc_cflags + endif + + " add optional config file parameters + let makeprg .= ' ' . syntastic#c#ReadConfig(g:syntastic_objc_config_file) + + " process makeprg + let errors = SyntasticMake({ 'makeprg': makeprg, + \ 'errorformat': errorformat }) + + " filter the processed errors if desired + if exists('g:syntastic_objc_remove_include_errors') && + \ g:syntastic_objc_remove_include_errors != 0 + return filter(errors, + \ 'has_key(v:val, "bufnr") && v:val["bufnr"]=='.bufnr('')) + else + return errors + endif +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'objc', + \ 'name': 'gcc'}) + +let &cpo = s:save_cpo +unlet s:save_cpo + +" vim: set et sts=4 sw=4: diff --git a/sources_non_forked/syntastic/syntax_checkers/objc/oclint.vim b/sources_non_forked/syntastic/syntax_checkers/objc/oclint.vim new file mode 100644 index 00000000..0ebd6612 --- /dev/null +++ b/sources_non_forked/syntastic/syntax_checkers/objc/oclint.vim @@ -0,0 +1,36 @@ +"============================================================================ +"File: oclint.vim +"Description: Syntax checking plugin for syntastic.vim +"Maintainer: "UnCO" Lin +"License: This program is free software. It comes without any warranty, +" to the extent permitted by applicable law. You can redistribute +" it and/or modify it under the terms of the Do What The Fuck You +" Want To Public License, Version 2, as published by Sam Hocevar. +" See http://sam.zoy.org/wtfpl/COPYING for more details. +"============================================================================ +" +" The setting 'g:syntastic_oclint_config_file' allows you to define a file +" that contains additional compiler arguments like include directories or +" CFLAGS. The file is expected to contain one option per line. If none is +" given the filename defaults to '.syntastic_oclint_config': +" +" let g:syntastic_oclint_config_file = '.config' + +if exists("g:loaded_syntastic_objc_oclint_checker") + finish +endif +let g:loaded_syntastic_objc_oclint_checker = 1 + +function! SyntaxCheckers_objc_oclint_IsAvailable() + return SyntaxCheckers_c_oclint_IsAvailable() +endfunction + +function! SyntaxCheckers_objc_oclint_GetLocList() + return SyntaxCheckers_c_oclint_GetLocList() +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'objc', + \ 'name': 'oclint'}) + +runtime! syntax_checkers/c/*.vim diff --git a/sources_non_forked/syntastic/syntax_checkers/objc/ycm.vim b/sources_non_forked/syntastic/syntax_checkers/objc/ycm.vim new file mode 100644 index 00000000..40f53fb4 --- /dev/null +++ b/sources_non_forked/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("g:loaded_syntastic_objc_ycm_checker") + finish +endif +let g:loaded_syntastic_objc_ycm_checker = 1 + +runtime! syntax_checkers/c/*.vim + +function! SyntaxCheckers_objc_ycm_IsAvailable() + return SyntaxCheckers_c_ycm_IsAvailable() +endfunction + +if !exists('g:loaded_youcompleteme') + finish +endif + +function! SyntaxCheckers_objc_ycm_GetLocList() + return SyntaxCheckers_c_ycm_GetLocList() +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'objc', + \ 'name': 'ycm'}) diff --git a/sources_non_forked/syntastic/syntax_checkers/objcpp/gcc.vim b/sources_non_forked/syntastic/syntax_checkers/objcpp/gcc.vim new file mode 100644 index 00000000..889a5973 --- /dev/null +++ b/sources_non_forked/syntastic/syntax_checkers/objcpp/gcc.vim @@ -0,0 +1,184 @@ +"============================================================================ +"File: objcpp.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_objcpp_check_header = 1 +" +" To disable the search of included header files after special +" libraries like gtk and glib add this line to your .vimrc: +" +" let g:syntastic_objcpp_no_include_search = 1 +" +" To disable the include of the default include dirs (such as /usr/include) +" add this line to your .vimrc: +" +" let g:syntastic_objcpp_no_default_include_dirs = 1 +" +" To enable header files being re-checked on every file write add the +" following line to your .vimrc. Otherwise the header files are checked only +" one time on initially loading the file. +" In order to force syntastic to refresh the header includes simply +" unlet b:syntastic_objcpp_includes. Then the header files are being re-checked on +" the next file write. +" +" let g:syntastic_objcpp_auto_refresh_includes = 1 +" +" Alternatively you can set the buffer local variable b:syntastic_objcpp_cflags. +" If this variable is set for the current buffer no search for additional +" libraries is done. I.e. set the variable like this: +" +" let b:syntastic_objcpp_cflags = ' -I/usr/include/libsoup-2.4' +" +" In order to add some custom include directories that should be added to the +" gcc command line you can add those to the global variable +" g:syntastic_objcpp_include_dirs. This list can be used like this: +" +" let g:syntastic_objcpp_include_dirs = [ 'includes', 'headers' ] +" +" Moreover it is possible to add additional compiler options to the syntax +" checking execution via the variable 'g:syntastic_objcpp_compiler_options': +" +" let g:syntastic_objcpp_compiler_options = ' -ansi' +" +" Additionally the setting 'g:syntastic_objcpp_config_file' allows you to define a +" file that contains additional compiler arguments like include directories or +" CFLAGS. The file is expected to contain one option per line. If none is +" given the filename defaults to '.syntastic_objcpp_config': +" +" let g:syntastic_objcpp_config_file = '.config' +" +" Using the global variable 'g:syntastic_objcpp_remove_include_errors' you can +" specify whether errors of files included via the g:syntastic_objcpp_include_dirs' +" setting are removed from the result set: +" +" let g:syntastic_objcpp_remove_include_errors = 1 +" +" Use the variable 'g:syntastic_objcpp_errorformat' to override the default error +" format: +" +" let g:syntastic_objcpp_errorformat = '%f:%l:%c: %trror: %m' +" +" Set your compiler executable with e.g. (defaults to gcc) +" +" let g:syntastic_objcpp_compiler = 'clang' + +if exists('g:loaded_syntastic_objcpp_gcc_checker') + finish +endif +let g:loaded_syntastic_objcpp_gcc_checker = 1 + +if !exists('g:syntastic_objcpp_compiler') + let g:syntastic_objcpp_compiler = 'gcc' +endif + +function! SyntaxCheckers_objcpp_gcc_IsAvailable() + return executable(g:syntastic_objcpp_compiler) +endfunction + +let s:save_cpo = &cpo +set cpo&vim + +if !exists('g:syntastic_objcpp_compiler_options') + let g:syntastic_objcpp_compiler_options = '-std=gnu99' +endif + +if !exists('g:syntastic_objcpp_config_file') + let g:syntastic_objcpp_config_file = '.syntastic_objcpp_config' +endif + +function! SyntaxCheckers_objcpp_gcc_GetLocList() + let makeprg = g:syntastic_objcpp_compiler . ' -x objective-c++ -fsyntax-only -lobjc' + let errorformat = + \ '%-G%f:%s:,' . + \ '%-G%f:%l: %#error: %#(Each undeclared identifier is reported only%.%#,' . + \ '%-G%f:%l: %#error: %#for each function it appears%.%#,' . + \ '%-GIn file included%.%#,'. + \ '%-G %#from %f:%l\,,' . + \ '%f:%l:%c: %trror: %m,' . + \ '%f:%l:%c: %tarning: %m,' . + \ '%f:%l:%c: %m,' . + \ '%f:%l: %trror: %m,' . + \ '%f:%l: %tarning: %m,' . + \ '%f:%l: %m' + + if exists('g:syntastic_objcpp_errorformat') + let errorformat = g:syntastic_objcpp_errorformat + endif + + " add optional user-defined compiler options + let makeprg .= g:syntastic_objcpp_compiler_options + + let makeprg .= ' ' . syntastic#util#shexpand('%') . + \ ' ' . syntastic#c#GetIncludeDirs('objcpp') + + " determine whether to parse header files as well + if expand('%') =~? '\.h$' + if exists('g:syntastic_objcpp_check_header') + let makeprg = g:syntastic_objcpp_compiler . + \ ' -x objective-c++-header ' . + \ ' -c ' . syntastic#util#shexpand('%') . + \ ' ' . g:syntastic_objcpp_compiler_options . + \ ' ' . syntastic#c#GetIncludeDirs('objcpp') + else + return [] + endif + endif + + " check if the user manually set some cflags + if !exists('b:syntastic_objcpp_cflags') + " check whether to search for include files at all + if !exists('g:syntastic_objcpp_no_include_search') || + \ g:syntastic_objcpp_no_include_search != 1 + " refresh the include file search if desired + if exists('g:syntastic_objcpp_auto_refresh_includes') && + \ g:syntastic_objcpp_auto_refresh_includes != 0 + let makeprg .= syntastic#c#SearchHeaders() + else + " search for header includes if not cached already + if !exists('b:syntastic_objcpp_includes') + let b:syntastic_objcpp_includes = syntastic#c#SearchHeaders() + endif + let makeprg .= b:syntastic_objcpp_includes + endif + endif + else + " use the user-defined cflags + let makeprg .= b:syntastic_objcpp_cflags + endif + + " add optional config file parameters + let makeprg .= ' ' . syntastic#c#ReadConfig(g:syntastic_objcpp_config_file) + + " process makeprg + let errors = SyntasticMake({ 'makeprg': makeprg, + \ 'errorformat': errorformat }) + + " filter the processed errors if desired + if exists('g:syntastic_objcpp_remove_include_errors') && + \ g:syntastic_objcpp_remove_include_errors != 0 + return filter(errors, + \ 'has_key(v:val, "bufnr") && v:val["bufnr"]=='.bufnr('')) + else + return errors + endif +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'objcpp', + \ 'name': 'gcc'}) + +let &cpo = s:save_cpo +unlet s:save_cpo + +" vim: set et sts=4 sw=4: diff --git a/sources_non_forked/syntastic/syntax_checkers/objcpp/oclint.vim b/sources_non_forked/syntastic/syntax_checkers/objcpp/oclint.vim new file mode 100644 index 00000000..a46fe045 --- /dev/null +++ b/sources_non_forked/syntastic/syntax_checkers/objcpp/oclint.vim @@ -0,0 +1,36 @@ +"============================================================================ +"File: oclint.vim +"Description: Syntax checking plugin for syntastic.vim +"Maintainer: "UnCO" Lin +"License: This program is free software. It comes without any warranty, +" to the extent permitted by applicable law. You can redistribute +" it and/or modify it under the terms of the Do What The Fuck You +" Want To Public License, Version 2, as published by Sam Hocevar. +" See http://sam.zoy.org/wtfpl/COPYING for more details. +"============================================================================ +" +" The setting 'g:syntastic_oclint_config_file' allows you to define a file +" that contains additional compiler arguments like include directories or +" CFLAGS. The file is expected to contain one option per line. If none is +" given the filename defaults to '.syntastic_oclint_config': +" +" let g:syntastic_oclint_config_file = '.config' + +if exists("g:loaded_syntastic_objcpp_oclint_checker") + finish +endif +let g:loaded_syntastic_objcpp_oclint_checker = 1 + +function! SyntaxCheckers_objcpp_oclint_IsAvailable() + return SyntaxCheckers_c_oclint_IsAvailable() +endfunction + +function! SyntaxCheckers_objcpp_oclint_GetLocList() + return SyntaxCheckers_c_oclint_GetLocList() +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'objcpp', + \ 'name': 'oclint'}) + +runtime! syntax_checkers/c/*.vim diff --git a/sources_non_forked/syntastic/syntax_checkers/objcpp/ycm.vim b/sources_non_forked/syntastic/syntax_checkers/objcpp/ycm.vim new file mode 100644 index 00000000..c9a0e458 --- /dev/null +++ b/sources_non_forked/syntastic/syntax_checkers/objcpp/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("g:loaded_syntastic_objcpp_ycm_checker") + finish +endif +let g:loaded_syntastic_objcpp_ycm_checker = 1 + +runtime! syntax_checkers/c/*.vim + +function! SyntaxCheckers_objcpp_ycm_IsAvailable() + return SyntaxCheckers_c_ycm_IsAvailable() +endfunction + +if !exists('g:loaded_youcompleteme') + finish +endif + +function! SyntaxCheckers_objcpp_ycm_GetLocList() + return SyntaxCheckers_c_ycm_GetLocList() +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'objcpp', + \ 'name': 'ycm'}) diff --git a/sources_non_forked/syntastic/syntax_checkers/ocaml/camlp4o.vim b/sources_non_forked/syntastic/syntax_checkers/ocaml/camlp4o.vim new file mode 100644 index 00000000..ebec5cb7 --- /dev/null +++ b/sources_non_forked/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 " . syntastic#util#shexpand('%') + return build_cmd + else + return "ocamlc -c " . syntastic#util#shexpand('%') + endif +endfunction + +function s:GetOcamlBuildMakeprg() + return "ocamlbuild -quiet -no-log -tag annot," . s:ocamlpp . " -no-links -no-hygiene -no-sanitize " . + \ syntastic#util#shexpand('%:r') . ".cmi" +endfunction + +function s:GetOtherMakeprg() + "TODO: give this function a better name? + " + "TODO: should use throw/catch instead of returning an empty makeprg + + let extension = expand('%:e') + let makeprg = "" + + if match(extension, 'mly') >= 0 && executable("menhir") + " ocamlyacc output can't be redirected, so use menhir + let makeprg = "menhir --only-preprocess " . syntastic#util#shexpand('%') . " >" . syntastic#util#DevNull() + elseif match(extension,'mll') >= 0 && executable("ocamllex") + let makeprg = "ocamllex -q " . syntastic#c#GetNullDevice() . " " . syntastic#util#shexpand('%') + else + let makeprg = "camlp4o " . syntastic#c#GetNullDevice() . " " . syntastic#util#shexpand('%') + endif + + return makeprg +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'ocaml', + \ 'name': 'camlp4o'}) diff --git a/sources_non_forked/syntastic/syntax_checkers/perl/efm_perl.pl b/sources_non_forked/syntastic/syntax_checkers/perl/efm_perl.pl new file mode 100644 index 00000000..2e74bcb0 --- /dev/null +++ b/sources_non_forked/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/sources_non_forked/syntastic/syntax_checkers/perl/perl.vim b/sources_non_forked/syntastic/syntax_checkers/perl/perl.vim new file mode 100644 index 00000000..d88437dd --- /dev/null +++ b/sources_non_forked/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 . ' ' . + \ syntastic#util#shescape(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 .= ' ' . syntastic#util#shexpand('%') . s:ExtraMakeprgArgs() + + let errorformat = '%t:%f:%l:%m' + + return SyntasticMake({ 'makeprg': makeprg, 'errorformat': errorformat }) +endfunction + +function! s:ExtraMakeprgArgs() + let shebang = syntastic#util#parseShebang() + if index(shebang['args'], '-T') != -1 + return ' -Tc' + endif + + return '' +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'perl', + \ 'name': 'perl'}) diff --git a/sources_non_forked/syntastic/syntax_checkers/perl/perlcritic.vim b/sources_non_forked/syntastic/syntax_checkers/perl/perlcritic.vim new file mode 100644 index 00000000..910ded2b --- /dev/null +++ b/sources_non_forked/syntastic/syntax_checkers/perl/perlcritic.vim @@ -0,0 +1,65 @@ +"============================================================================ +"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"', + \ 'filetype': 'perl', + \ 'subchecker': 'perlcritic' }) + + let errorformat = '%t:%f:%l:%c:%m' + + let loclist = SyntasticMake({ + \ 'makeprg': makeprg, + \ 'errorformat': errorformat, + \ 'returns': [0, 2], + \ 'subtype': 'Style' }) + + " change error types according to the prescribed threshold + for n in range(len(loclist)) + let loclist[n]['type'] = loclist[n]['type'] < g:syntastic_perl_perlcritic_thres ? 'W' : 'E' + endfor + + return loclist +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'perl', + \ 'name': 'perlcritic'}) diff --git a/sources_non_forked/syntastic/syntax_checkers/perl/podchecker.vim b/sources_non_forked/syntastic/syntax_checkers/perl/podchecker.vim new file mode 100644 index 00000000..e6f80e66 --- /dev/null +++ b/sources_non_forked/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 + +function! SyntaxCheckers_perl_podchecker_IsAvailable() + return SyntaxCheckers_pod_podchecker_IsAvailable() +endfunction + +function! SyntaxCheckers_perl_podchecker_GetLocList() + return SyntaxCheckers_pod_podchecker_GetLocList() +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'perl', + \ 'name': 'podchecker'}) + +runtime! syntax_checkers/pod/*.vim diff --git a/sources_non_forked/syntastic/syntax_checkers/php/php.vim b/sources_non_forked/syntastic/syntax_checkers/php/php.vim new file mode 100644 index 00000000..a6abffb1 --- /dev/null +++ b/sources_non_forked/syntastic/syntax_checkers/php/php.vim @@ -0,0 +1,52 @@ +"============================================================================ +"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', + \ 'filetype': 'php', + \ 'subchecker': 'php' }) + + let errorformat = + \ '%-GNo syntax errors detected in%.%#,'. + \ 'Parse error: %#syntax %trror\, %m in %f on line %l,'. + \ 'Parse %trror: %m in %f on line %l,'. + \ 'Fatal %trror: %m in %f on line %l,'. + \ '%-G\s%#,'. + \ '%-GErrors parsing %.%#' + + return SyntasticMake({ + \ 'makeprg': makeprg, + \ 'errorformat': errorformat }) +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'php', + \ 'name': 'php'}) diff --git a/sources_non_forked/syntastic/syntax_checkers/php/phpcs.vim b/sources_non_forked/syntastic/syntax_checkers/php/phpcs.vim new file mode 100644 index 00000000..f6646c66 --- /dev/null +++ b/sources_non_forked/syntastic/syntax_checkers/php/phpcs.vim @@ -0,0 +1,44 @@ +"============================================================================ +"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', + \ 'filetype': 'php', + \ 'subchecker': 'phpcs' }) + + let errorformat = + \ '%-GFile\,Line\,Column\,Type\,Message\,Source\,Severity,'. + \ '"%f"\,%l\,%c\,%t%*[a-zA-Z]\,"%m"\,%*[a-zA-Z0-9_.-]\,%*[0-9]' + + return SyntasticMake({ + \ 'makeprg': makeprg, + \ 'errorformat': errorformat, + \ 'subtype': 'Style' }) +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'php', + \ 'name': 'phpcs'}) diff --git a/sources_non_forked/syntastic/syntax_checkers/php/phpmd.vim b/sources_non_forked/syntastic/syntax_checkers/php/phpmd.vim new file mode 100644 index 00000000..c21362f9 --- /dev/null +++ b/sources_non_forked/syntastic/syntax_checkers/php/phpmd.vim @@ -0,0 +1,78 @@ +"============================================================================ +"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', + \ 'filetype': 'php', + \ 'subchecker': 'phpmd' }) + + let errorformat = '%E%f:%l%\s%#%m' + + return SyntasticMake({ + \ 'makeprg': makeprg, + \ 'errorformat': errorformat, + \ 'subtype' : 'Style' }) +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'php', + \ 'name': 'phpmd'}) diff --git a/sources_non_forked/syntastic/syntax_checkers/pod/podchecker.vim b/sources_non_forked/syntastic/syntax_checkers/pod/podchecker.vim new file mode 100644 index 00000000..c429a495 --- /dev/null +++ b/sources_non_forked/syntastic/syntax_checkers/pod/podchecker.vim @@ -0,0 +1,51 @@ +"============================================================================ +"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', + \ 'filetype': 'pod', + \ 'subchecker': 'podchecker' }) + + let errorformat = + \ '%W%[%#]%[%#]%[%#] WARNING: %m at line %l in file %f,' . + \ '%W%[%#]%[%#]%[%#] WARNING: %m at line EOF in file %f,' . + \ '%E%[%#]%[%#]%[%#] ERROR: %m at line %l in file %f,' . + \ '%E%[%#]%[%#]%[%#] ERROR: %m at line EOF in file %f' + + let loclist = SyntasticMake({ + \ 'makeprg': makeprg, + \ 'errorformat': errorformat, + \ 'returns': [0, 1, 2] }) + + for n in range(len(loclist)) + let e = loclist[n] + if e['valid'] && e['lnum'] == 0 + let e['lnum'] = str2nr(matchstr(e['text'], '\m\ +"License: This program is free software. It comes without any warranty, +" to the extent permitted by applicable law. You can redistribute +" it and/or modify it under the terms of the Do What The Fuck You +" Want To Public License, Version 2, as published by Sam Hocevar. +" See http://sam.zoy.org/wtfpl/COPYING for more details. +" +"============================================================================ + +if exists("g:loaded_syntastic_puppet_puppet_checker") + finish +endif +let g:loaded_syntastic_puppet_puppet_checker=1 + +function! SyntaxCheckers_puppet_puppet_IsAvailable() + return executable("puppet") +endfunction + +function! SyntaxCheckers_puppet_puppet_GetLocList() + + let ver = syntastic#util#parseVersion('puppet --version 2>' . syntastic#util#DevNull()) + + if syntastic#util#versionIsAtLeast(ver, [2,7,0]) + let args = 'parser validate --color=false' + else + let args = '--color=false --parseonly' + endif + + let makeprg = syntastic#makeprg#build({ + \ 'exe': 'puppet', + \ 'args': args, + \ 'filetype': 'puppet', + \ 'subchecker': 'puppet' }) + + let errorformat = + \ '%-Gerr: Try ''puppet help parser validate'' for usage,' . + \ '%-GError: Try ''puppet help parser validate'' for usage,' . + \ '%Eerr: Could not parse for environment %*[a-z]: %m at %f:%l,' . + \ '%EError: Could not parse for environment %*[a-z]: %m at %f:%l' + + return SyntasticMake({ + \ 'makeprg': makeprg, + \ 'errorformat': errorformat }) + +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'puppet', + \ 'name': 'puppet'}) diff --git a/sources_non_forked/syntastic/syntax_checkers/puppet/puppetlint.vim b/sources_non_forked/syntastic/syntax_checkers/puppet/puppetlint.vim new file mode 100644 index 00000000..14afd8c6 --- /dev/null +++ b/sources_non_forked/syntastic/syntax_checkers/puppet/puppetlint.vim @@ -0,0 +1,47 @@ +"============================================================================ +"File: puppetlint.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 + +if exists("g:syntastic_puppet_lint_arguments") + let g:syntastic_puppet_puppetlint_args = g:syntastic_puppet_lint_arguments + call syntastic#util#deprecationWarn("variable g:syntastic_puppet_lint_arguments is deprecated, please use g:syntastic_puppet_puppetlint_args instead") +endif + +function! SyntaxCheckers_puppet_puppetlint_IsAvailable() + return + \ executable("puppet") && + \ executable("puppet-lint") && + \ syntastic#util#versionIsAtLeast(syntastic#util#parseVersion('puppet-lint --version 2>' . + \ syntastic#util#DevNull()), [0,1,10]) +endfunction + +function! SyntaxCheckers_puppet_puppetlint_GetLocList() + let makeprg = syntastic#makeprg#build({ + \ 'exe': 'puppet-lint', + \ 'post_args': '--log-format "%{KIND} [%{check}] %{message} at %{fullpath}:%{linenumber}"', + \ 'filetype': 'puppet', + \ 'subchecker': 'puppetlint' }) + + let errorformat = '%t%*[a-zA-Z] %m at %f:%l' + + return SyntasticMake({ + \ 'makeprg': makeprg, + \ 'errorformat': errorformat }) +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'puppet', + \ 'name': 'puppetlint'}) diff --git a/sources_non_forked/syntastic/syntax_checkers/python/flake8.vim b/sources_non_forked/syntastic/syntax_checkers/python/flake8.vim new file mode 100644 index 00000000..796ba6bd --- /dev/null +++ b/sources_non_forked/syntastic/syntax_checkers/python/flake8.vim @@ -0,0 +1,44 @@ +"============================================================================ +"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) + return SyntaxCheckers_python_pyflakes_GetHighlightRegex(a:i) +endfunction + +function! SyntaxCheckers_python_flake8_GetLocList() + let makeprg = syntastic#makeprg#build({ + \ 'exe': 'flake8', + \ 'filetype': 'python', + \ 'subchecker': 'flake8' }) + + let errorformat = + \ '%E%f:%l: could not compile,%-Z%p^,'. + \ '%W%f:%l:%c: F%n %m,'. + \ '%W%f:%l:%c: C%n %m,'. + \ '%E%f:%l:%c: %t%n %m,'. + \ '%E%f:%l: %t%n %m,'. + \ '%-G%.%#' + + return SyntasticMake({ + \ 'makeprg': makeprg, + \ 'errorformat': errorformat }) +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'python', + \ 'name': 'flake8'}) + +runtime! syntax_checkers/python/pyflakes.vim diff --git a/sources_non_forked/syntastic/syntax_checkers/python/pep257.vim b/sources_non_forked/syntastic/syntax_checkers/python/pep257.vim new file mode 100644 index 00000000..9d2b64d9 --- /dev/null +++ b/sources_non_forked/syntastic/syntax_checkers/python/pep257.vim @@ -0,0 +1,50 @@ +"============================================================================ +"File: pep257.vim +"Description: Docstring style checking plugin for syntastic.vim +"============================================================================ +" +" For details about pep257 see: https://github.com/GreenSteam/pep257 + +if exists("g:loaded_syntastic_python_pep257_checker") + finish +endif +let g:loaded_syntastic_python_pep257_checker = 1 + +function! SyntaxCheckers_python_pep257_IsAvailable() + return executable('pep257') +endfunction + +" sanity: kill empty lines here rather than munging errorformat +function! SyntaxCheckers_python_pep257_Preprocess(errors) + return filter(copy(a:errors), 'v:val != ""') +endfunction + +function! SyntaxCheckers_python_pep257_GetLocList() + let makeprg = syntastic#makeprg#build({ + \ 'exe': 'pep257', + \ 'filetype': 'python', + \ 'subchecker': 'pep257' }) + + let errorformat = + \ '%E%f:%l:%c%\%.%\%.%\d%\+:%\d%\+: %m,' . + \ '%E%f:%l:%c: %m,' . + \ '%+C %m' + + let loclist = SyntasticMake({ + \ 'makeprg': makeprg, + \ 'errorformat': errorformat, + \ 'subtype': 'Style', + \ 'preprocess': 'SyntaxCheckers_python_pep257_Preprocess', + \ 'postprocess': ['compressWhitespace'] }) + + " pep257 outputs byte offsets rather than column numbers + for n in range(len(loclist)) + let loclist[n]['col'] = get(loclist[n], 'col', 0) + 1 + endfor + + return loclist +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'python', + \ 'name': 'pep257'}) diff --git a/sources_non_forked/syntastic/syntax_checkers/python/pep8.vim b/sources_non_forked/syntastic/syntax_checkers/python/pep8.vim new file mode 100644 index 00000000..71837187 --- /dev/null +++ b/sources_non_forked/syntastic/syntax_checkers/python/pep8.vim @@ -0,0 +1,46 @@ +"============================================================================ +"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', + \ 'filetype': 'python', + \ 'subchecker': 'pep8' }) + + let errorformat = '%f:%l:%c: %m' + + let loclist = SyntasticMake({ + \ 'makeprg': makeprg, + \ 'errorformat': errorformat, + \ 'subtype': 'Style' }) + + for n in range(len(loclist)) + let loclist[n]['type'] = loclist[n]['text'] =~? '^W' ? 'W' : 'E' + endfor + + return loclist +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'python', + \ 'name': 'pep8'}) diff --git a/sources_non_forked/syntastic/syntax_checkers/python/py3kwarn.vim b/sources_non_forked/syntastic/syntax_checkers/python/py3kwarn.vim new file mode 100644 index 00000000..44d03655 --- /dev/null +++ b/sources_non_forked/syntastic/syntax_checkers/python/py3kwarn.vim @@ -0,0 +1,31 @@ +"============================================================================ +"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', + \ 'filetype': 'python', + \ 'subchecker': 'py3kwarn' }) + + let errorformat = '%W%f:%l:%c: %m' + + return SyntasticMake({ + \ 'makeprg': makeprg, + \ 'errorformat': errorformat }) +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'python', + \ 'name': 'py3kwarn'}) diff --git a/sources_non_forked/syntastic/syntax_checkers/python/pyflakes.vim b/sources_non_forked/syntastic/syntax_checkers/python/pyflakes.vim new file mode 100644 index 00000000..f93047bf --- /dev/null +++ b/sources_non_forked/syntastic/syntax_checkers/python/pyflakes.vim @@ -0,0 +1,63 @@ +"============================================================================ +"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 + + " fun with Python's %r: try "..." first, then '...' + let terms = split(a:i['text'], '"', 1) + if len(terms) > 2 + return terms[1] + endif + + let terms = split(a:i['text'], "'", 1) + if len(terms) > 2 + return terms[1] + endif + endif + return '' +endfunction + +function! SyntaxCheckers_python_pyflakes_GetLocList() + let makeprg = syntastic#makeprg#build({ + \ 'exe': 'pyflakes', + \ 'filetype': 'python', + \ 'subchecker': 'pyflakes' }) + + let errorformat = + \ '%E%f:%l: could not compile,'. + \ '%-Z%p^,'. + \ '%E%f:%l:%c: %m,'. + \ '%E%f:%l: %m,'. + \ '%-G%.%#' + + return SyntasticMake({ + \ 'makeprg': makeprg, + \ 'errorformat': errorformat, + \ 'defaults': {'text': "Syntax error"} }) +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'python', + \ 'name': 'pyflakes'}) diff --git a/sources_non_forked/syntastic/syntax_checkers/python/pylama.vim b/sources_non_forked/syntastic/syntax_checkers/python/pylama.vim new file mode 100644 index 00000000..8c8e2ba0 --- /dev/null +++ b/sources_non_forked/syntastic/syntax_checkers/python/pylama.vim @@ -0,0 +1,67 @@ +"============================================================================ +"File: pylama.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_python_pylama_checker') + finish +endif +let g:loaded_syntastic_python_pylama_checker = 1 + +function! SyntaxCheckers_python_pylama_IsAvailable() + return executable('pylama') +endfunction + +function! SyntaxCheckers_python_pylama_GetHighlightRegex(i) + return SyntaxCheckers_python_pyflakes_GetHighlightRegex(a:i) +endfunction + +function! SyntaxCheckers_python_pylama_GetLocList() + let makeprg = syntastic#makeprg#build({ + \ 'exe': 'pylama', + \ 'post_args': '-f pep8', + \ 'filetype': 'python', + \ 'subchecker': 'pylama' }) + + " TODO: "WARNING:pylama:..." messages are probably a logging bug + let errorformat = + \ '%-GWARNING:pylama:%.%#,' . + \ '%A%f:%l:%c: %m' + + let loclist = SyntasticMake({ + \ 'makeprg': makeprg, + \ 'errorformat': errorformat, + \ 'postprocess': ['sort'] }) + + " adjust for weirdness in each checker + for n in range(len(loclist)) + let loclist[n]['type'] = match(['R', 'C', 'W'], loclist[n]['text'][0]) >= 0 ? 'W' : 'E' + if loclist[n]['text'] =~# '\v\[%(mccabe|pep257|pylint)\]$' + if has_key(loclist[n], 'col') + let loclist[n]['col'] += 1 + endif + endif + if loclist[n]['text'] =~# '\v\[pylint\]$' + if has_key(loclist[n], 'vcol') + let loclist[n]['vcol'] = 0 + endif + endif + if loclist[n]['text'] =~# '\v\[%(mccabe|pep257|pep8)\]$' + let loclist[n]['subtype'] = 'Style' + endif + endfor + + return loclist +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'python', + \ 'name': 'pylama' }) + +runtime! syntax_checkers/python/pyflakes.vim diff --git a/sources_non_forked/syntastic/syntax_checkers/python/pylint.vim b/sources_non_forked/syntastic/syntax_checkers/python/pylint.vim new file mode 100644 index 00000000..477d9372 --- /dev/null +++ b/sources_non_forked/syntastic/syntax_checkers/python/pylint.vim @@ -0,0 +1,58 @@ +"============================================================================ +"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 pylint_new = s:PylintNew() + + let makeprg = syntastic#makeprg#build({ + \ 'exe': 'pylint', + \ 'args': (pylint_new ? '--msg-template="{path}:{line}: [{msg_id}] {msg}" -r n' : '-f parseable -r n -i y'), + \ 'filetype': 'python', + \ 'subchecker': 'pylint' }) + + let errorformat = + \ '%A%f:%l: %m,' . + \ '%A%f:(%l): %m,' . + \ '%-Z%p^%.%#,' . + \ '%-G%.%#' + + let loclist=SyntasticMake({ + \ 'makeprg': makeprg, + \ 'errorformat': errorformat, + \ 'postprocess': ['sort'] }) + + for n in range(len(loclist)) + let type = loclist[n]['text'][1] + if type =~# '\m^[EF]' + let loclist[n]['type'] = 'E' + elseif type =~# '\m^[CRW]' + let loclist[n]['type'] = 'W' + else + let loclist[n]['valid'] = 0 + endif + let loclist[n]['vcol'] = 0 + endfor + + return loclist +endfunction + +function s:PylintNew() + let pylint_version = filter(split(system('pylint --version'), '\m, \|\n'), 'v:val =~# "^pylint"')[0] + return syntastic#util#versionIsAtLeast(syntastic#util#parseVersion(pylint_version), [1]) +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'python', + \ 'name': 'pylint' }) diff --git a/sources_non_forked/syntastic/syntax_checkers/python/python.vim b/sources_non_forked/syntastic/syntax_checkers/python/python.vim new file mode 100644 index 00000000..eff1696b --- /dev/null +++ b/sources_non_forked/syntastic/syntax_checkers/python/python.vim @@ -0,0 +1,43 @@ +"============================================================================ +"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': syntastic#util#shescape("compile(open(" . fname . ").read(), " . fname . ", 'exec')"), + \ 'filetype': 'python', + \ 'subchecker': 'python' }) + + let errorformat = + \ '%E File "%f"\, line %l,' . + \ '%C %p^,' . + \ '%C %.%#,' . + \ '%Z%m,' . + \ '%-G%.%#' + + return SyntasticMake({ + \ 'makeprg': makeprg, + \ 'errorformat': errorformat }) +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'python', + \ 'name': 'python'}) diff --git a/sources_non_forked/syntastic/syntax_checkers/rst/rst2pseudoxml.vim b/sources_non_forked/syntastic/syntax_checkers/rst/rst2pseudoxml.vim new file mode 100644 index 00000000..454b4d85 --- /dev/null +++ b/sources_non_forked/syntastic/syntax_checkers/rst/rst2pseudoxml.vim @@ -0,0 +1,62 @@ +"============================================================================ +"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(), + \ 'filetype': 'rst', + \ 'subchecker': 'rst2pseudoxml' }) + + let errorformat = + \ '%f:%l: (%tNFO/1) %m,'. + \ '%f:%l: (%tARNING/2) %m,'. + \ '%f:%l: (%tRROR/3) %m,'. + \ '%f:%l: (%tEVERE/4) %m,'. + \ '%-G%.%#' + + let loclist = SyntasticMake({ + \ 'makeprg': makeprg, + \ 'errorformat': errorformat }) + + for n in range(len(loclist)) + if loclist[n]['type'] ==? 'S' + let loclist[n]['type'] = 'E' + elseif loclist[n]['type'] ==? 'I' + let loclist[n]['type'] = 'W' + let loclist[n]['subtype'] = 'Style' + endif + endfor + + return loclist +endfunction + +function s:exe() + return executable("rst2pseudoxml.py") ? "rst2pseudoxml.py" : "rst2pseudoxml" +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'rst', + \ 'name': 'rst2pseudoxml'}) diff --git a/sources_non_forked/syntastic/syntax_checkers/ruby/jruby.vim b/sources_non_forked/syntastic/syntax_checkers/ruby/jruby.vim new file mode 100644 index 00000000..bef2b5f5 --- /dev/null +++ b/sources_non_forked/syntastic/syntax_checkers/ruby/jruby.vim @@ -0,0 +1,52 @@ +"============================================================================ +"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(), + \ 'filetype': 'ruby', + \ 'subchecker': 'jruby' }) + + let errorformat = + \ '%-GSyntax OK for %f,'. + \ '%ESyntaxError in %f:%l: syntax error\, %m,'. + \ '%Z%p^,'. + \ '%W%f:%l: warning: %m,'. + \ '%Z%p^,'. + \ '%W%f:%l: %m,'. + \ '%-C%.%#' + + return SyntasticMake({ + \ 'makeprg': makeprg, + \ 'errorformat': errorformat }) +endfunction + +function s:args() + return has('win32') ? '-W1 -T1 -c' : '-W1 -c' +endfunction + +function s:exe() + return has('win32') ? 'jruby' : 'RUBYOPT= jruby' +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'ruby', + \ 'name': 'jruby'}) diff --git a/sources_non_forked/syntastic/syntax_checkers/ruby/macruby.vim b/sources_non_forked/syntastic/syntax_checkers/ruby/macruby.vim new file mode 100644 index 00000000..9226e41e --- /dev/null +++ b/sources_non_forked/syntastic/syntax_checkers/ruby/macruby.vim @@ -0,0 +1,43 @@ +"============================================================================ +"File: macruby.vim +"Description: Syntax checking plugin for syntastic.vim +"License: This program is free software. It comes without any warranty, +" to the extent permitted by applicable law. You can redistribute +" it and/or modify it under the terms of the Do What The Fuck You +" Want To Public License, Version 2, as published by Sam Hocevar. +" See http://sam.zoy.org/wtfpl/COPYING for more details. +" +"============================================================================ +if exists("g:loaded_syntastic_ruby_macruby_checker") + finish +endif +let g:loaded_syntastic_ruby_macruby_checker=1 + +function! SyntaxCheckers_ruby_macruby_IsAvailable() + return executable('macruby') +endfunction + +function! SyntaxCheckers_ruby_macruby_GetLocList() + let makeprg = syntastic#makeprg#build({ + \ 'exe': 'RUBYOPT= macruby', + \ 'args': '-W1 -c', + \ 'filetype': 'ruby', + \ 'subchecker': 'macruby' }) + + let errorformat = + \ '%-GSyntax OK,'. + \ '%E%f:%l: syntax error\, %m,'. + \ '%Z%p^,'. + \ '%W%f:%l: warning: %m,'. + \ '%Z%p^,'. + \ '%W%f:%l: %m,'. + \ '%-C%.%#' + + return SyntasticMake({ + \ 'makeprg': makeprg, + \ 'errorformat': errorformat }) +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'ruby', + \ 'name': 'macruby'}) diff --git a/sources_non_forked/syntastic/syntax_checkers/ruby/mri.vim b/sources_non_forked/syntastic/syntax_checkers/ruby/mri.vim new file mode 100644 index 00000000..27a46a48 --- /dev/null +++ b/sources_non_forked/syntastic/syntax_checkers/ruby/mri.vim @@ -0,0 +1,77 @@ +"============================================================================ +"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', + \ 'filetype': 'ruby', + \ 'subchecker': 'mri' }) + + "this is a hack to filter out a repeated useless warning in rspec files + "containing lines like + " + " foo.should == 'bar' + " + "Which always generate the warning below. Note that ruby >= 1.9.3 includes + "the word "possibly" in the warning + let errorformat = '%-G%.%#warning: %\(possibly %\)%\?useless use of == in void context,' + + " filter out lines starting with ... + " long lines are truncated and wrapped in ... %p then returns the wrong + " column offset + let errorformat .= '%-G%\%.%\%.%\%.%.%#,' + + let errorformat .= + \ '%-GSyntax OK,'. + \ '%E%f:%l: syntax error\, %m,'. + \ '%Z%p^,'. + \ '%W%f:%l: warning: %m,'. + \ '%Z%p^,'. + \ '%W%f:%l: %m,'. + \ '%-C%.%#' + + return SyntasticMake({ + \ 'makeprg': makeprg, + \ 'errorformat': errorformat }) +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'ruby', + \ 'name': 'mri'}) diff --git a/sources_non_forked/syntastic/syntax_checkers/ruby/rubocop.vim b/sources_non_forked/syntastic/syntax_checkers/ruby/rubocop.vim new file mode 100644 index 00000000..b93d8d1a --- /dev/null +++ b/sources_non_forked/syntastic/syntax_checkers/ruby/rubocop.vim @@ -0,0 +1,55 @@ +"============================================================================ +"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') && + \ syntastic#util#versionIsAtLeast(syntastic#util#parseVersion('rubocop --version'), [0,9,0]) +endfunction + +function! SyntaxCheckers_ruby_rubocop_GetLocList() + let makeprg = syntastic#makeprg#build({ + \ 'exe': 'rubocop', + \ 'args': '--format emacs --silent', + \ 'filetype': 'ruby', + \ 'subchecker': 'rubocop' }) + + let errorformat = '%f:%l:%c: %t: %m' + + let loclist = SyntasticMake({ + \ 'makeprg': makeprg, + \ 'errorformat': errorformat, + \ 'subtype': 'Style'}) + + " convert rubocop severities to error types recognized by syntastic + for n in range(len(loclist)) + if loclist[n]['type'] == 'F' + let loclist[n]['type'] = 'E' + elseif loclist[n]['type'] != 'W' && loclist[n]['type'] != 'E' + let loclist[n]['type'] = 'W' + endif + endfor + + return loclist +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'ruby', + \ 'name': 'rubocop'}) diff --git a/sources_non_forked/syntastic/syntax_checkers/rust/rustc.vim b/sources_non_forked/syntastic/syntax_checkers/rust/rustc.vim new file mode 100644 index 00000000..e88b4cf9 --- /dev/null +++ b/sources_non_forked/syntastic/syntax_checkers/rust/rustc.vim @@ -0,0 +1,42 @@ +"============================================================================ +"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', + \ 'filetype': 'rust', + \ 'subchecker': 'rustc' }) + + let errorformat = + \ '%E%f:%l:%c: \\d%#:\\d%# %.%\{-}error:%.%\{-} %m,' . + \ '%W%f:%l:%c: \\d%#:\\d%# %.%\{-}warning:%.%\{-} %m,' . + \ '%C%f:%l %m,' . + \ '%-Z%.%#' + + return SyntasticMake({ + \ 'makeprg': makeprg, + \ 'errorformat': errorformat }) +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'rust', + \ 'name': 'rustc'}) diff --git a/sources_non_forked/syntastic/syntax_checkers/sass/sass.vim b/sources_non_forked/syntastic/syntax_checkers/sass/sass.vim new file mode 100644 index 00000000..4b8d4863 --- /dev/null +++ b/sources_non_forked/syntastic/syntax_checkers/sass/sass.vim @@ -0,0 +1,78 @@ +"============================================================================ +"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 [] + endif + + let makeprg = syntastic#makeprg#build({ + \ 'exe': 'sass', + \ 'args': '--cache-location ' . s:sass_cache_location . ' ' . s:imports . ' --check', + \ 'filetype': 'sass', + \ 'subchecker': 'sass' }) + + let errorformat = + \ '%ESyntax %trror: %m,' . + \ '%+C %.%#,' . + \ '%C on line %l of %f\, %.%#,' . + \ '%C on line %l of %f,' . + \ '%-G %\+from line %.%#,' . + \ '%-G %\+Use --trace for backtrace.,' . + \ '%W%>DEPRECATION WARNING on line %l of %f:,' . + \ '%+C%> %.%#,' . + \ '%W%>WARNING: on line %l of %f:,' . + \ '%+C%> %.%#,' . + \ '%W%>WARNING on line %l of %f: %m,' . + \ '%+C%> %.%#,' . + \ '%W%>WARNING on line %l of %f:,' . + \ '%Z%m,' . + \ '%W%>WARNING: %m,' . + \ '%C on line %l of %f\, %.%#,' . + \ '%C on line %l of %f,' . + \ '%-G %\+from line %.%#,' . + \ 'Syntax %trror on line %l: %m,' . + \ '%-G%.%#' + + return SyntasticMake({ + \ 'makeprg': makeprg, + \ 'errorformat': errorformat, + \ 'postprocess': ['compressWhitespace'] }) +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'sass', + \ 'name': 'sass'}) diff --git a/sources_non_forked/syntastic/syntax_checkers/scala/fsc.vim b/sources_non_forked/syntastic/syntax_checkers/scala/fsc.vim new file mode 100644 index 00000000..d0e95a7d --- /dev/null +++ b/sources_non_forked/syntastic/syntax_checkers/scala/fsc.vim @@ -0,0 +1,46 @@ +"============================================================================ +"File: fsc.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_scala_fsc_checker') + finish +endif +let g:loaded_syntastic_scala_fsc_checker = 1 + +function! SyntaxCheckers_scala_fsc_IsAvailable() + return executable('fsc') +endfunction + +if !exists('g:syntastic_scala_options') + let g:syntastic_scala_options = '' +endif + +function! SyntaxCheckers_scala_fsc_GetLocList() + " fsc has some serious problems with the + " working directory changing after being started + " that's why we better pass an absolute path + let makeprg = syntastic#makeprg#build({ + \ 'exe': 'fsc', + \ 'args': '-Ystop-after:parser ' . g:syntastic_scala_options, + \ 'fname': syntastic#util#shexpand('%:p'), + \ 'filetype': 'scala', + \ 'subchecker': 'fsc' }) + + let errorformat = '%f:%l: %trror: %m' + + return SyntasticMake({ + \ 'makeprg': makeprg, + \ 'errorformat': errorformat }) +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'scala', + \ 'name': 'fsc'}) diff --git a/sources_non_forked/syntastic/syntax_checkers/scala/scalac.vim b/sources_non_forked/syntastic/syntax_checkers/scala/scalac.vim new file mode 100644 index 00000000..d6319c16 --- /dev/null +++ b/sources_non_forked/syntastic/syntax_checkers/scala/scalac.vim @@ -0,0 +1,43 @@ +"============================================================================ +"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, + \ 'filetype': 'scala', + \ 'subchecker': 'scalac' }) + + let errorformat = '%f:%l: %trror: %m' + + return SyntasticMake({ + \ 'makeprg': makeprg, + \ 'errorformat': errorformat }) +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'scala', + \ 'name': 'scalac'}) diff --git a/sources_non_forked/syntastic/syntax_checkers/scss/sass.vim b/sources_non_forked/syntastic/syntax_checkers/scss/sass.vim new file mode 100644 index 00000000..604bb41d --- /dev/null +++ b/sources_non_forked/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 + +function! SyntaxCheckers_scss_sass_IsAvailable() + return SyntaxCheckers_sass_sass_IsAvailable() +endfunction + +function! SyntaxCheckers_scss_sass_GetLocList() + return SyntaxCheckers_sass_sass_GetLocList() +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'scss', + \ 'name': 'sass'}) + +runtime! syntax_checkers/sass/*.vim diff --git a/sources_non_forked/syntastic/syntax_checkers/sh/checkbashisms.vim b/sources_non_forked/syntastic/syntax_checkers/sh/checkbashisms.vim new file mode 100644 index 00000000..9fb1f7ae --- /dev/null +++ b/sources_non_forked/syntastic/syntax_checkers/sh/checkbashisms.vim @@ -0,0 +1,45 @@ +"============================================================================ +"File: checkbashisms.vim +"Description: Shell script syntax/style checking plugin for syntastic.vim +"Notes: checkbashisms.pl can be downloaded from +" http://debian.inode.at/debian/pool/main/d/devscripts/ +" as part of the devscripts package. +"============================================================================ + +if exists("g:loaded_syntastic_sh_checkbashisms_checker") + finish +endif +let g:loaded_syntastic_sh_checkbashisms_checker=1 + + +function! SyntaxCheckers_sh_checkbashisms_IsAvailable() + return executable('checkbashisms') +endfunction + + +function! SyntaxCheckers_sh_checkbashisms_GetLocList() + let makeprg = syntastic#makeprg#build({ + \ 'exe': 'checkbashisms', + \ 'args': '-fx', + \ 'filetype': 'sh', + \ 'subchecker': 'checkbashisms'}) + + let errorformat = + \ '%-Gscript %f is already a bash script; skipping,' . + \ '%Eerror: %f: %m\, opened in line %l,' . + \ '%Eerror: %f: %m,' . + \ '%Ecannot open script %f for reading: %m,' . + \ '%Wscript %f %m,%C%.# lines,' . + \ '%Wpossible bashism in %f line %l (%m):,%C%.%#,%Z.%#,' . + \ '%-G%.%#' + + return SyntasticMake({ + \ 'makeprg': makeprg, + \ 'errorformat': errorformat, + \ 'subtype': 'Style'}) +endfunction + + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'sh', + \ 'name': 'checkbashisms'}) diff --git a/sources_non_forked/syntastic/syntax_checkers/sh/sh.vim b/sources_non_forked/syntastic/syntax_checkers/sh/sh.vim new file mode 100644 index 00000000..8c44960b --- /dev/null +++ b/sources_non_forked/syntastic/syntax_checkers/sh/sh.vim @@ -0,0 +1,83 @@ +"============================================================================ +"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', + \ 'filetype': 'sh', + \ 'subchecker': 'sh'}) + + let errorformat = '%f: line %l: %m' + + return SyntasticMake({ + \ 'makeprg': makeprg, + \ 'errorformat': errorformat}) +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'sh', + \ 'name': 'sh'}) diff --git a/sources_non_forked/syntastic/syntax_checkers/slim/slimrb.vim b/sources_non_forked/syntastic/syntax_checkers/slim/slimrb.vim new file mode 100644 index 00000000..2644decf --- /dev/null +++ b/sources_non_forked/syntastic/syntax_checkers/slim/slimrb.vim @@ -0,0 +1,57 @@ +"============================================================================ +"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 s:slimrb_version = syntastic#util#parseVersion('slimrb --version 2>' . syntastic#util#DevNull()) + end + return s:slimrb_version +endfunction + +function! SyntaxCheckers_slim_slimrb_GetLocList() + let makeprg = syntastic#makeprg#build({ + \ 'exe': 'slimrb', + \ 'args': '-c', + \ 'filetype': 'slim', + \ 'subchecker': 'slimrb' }) + + if syntastic#util#versionIsAtLeast(s:SlimrbVersion(), [1,3,1]) + let errorformat = + \ '%C\ %#%f\, Line %l\, Column %c,'. + \ '%-G\ %.%#,'. + \ '%ESlim::Parser::SyntaxError: %m,'. + \ '%+C%.%#' + else + let errorformat = + \ '%C\ %#%f\, Line %l,'. + \ '%-G\ %.%#,'. + \ '%ESlim::Parser::SyntaxError: %m,'. + \ '%+C%.%#' + endif + + return SyntasticMake({ + \ 'makeprg': makeprg, + \ 'errorformat': errorformat }) +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'slim', + \ 'name': 'slimrb'}) diff --git a/sources_non_forked/syntastic/syntax_checkers/tcl/nagelfar.vim b/sources_non_forked/syntastic/syntax_checkers/tcl/nagelfar.vim new file mode 100644 index 00000000..b93b17b9 --- /dev/null +++ b/sources_non_forked/syntastic/syntax_checkers/tcl/nagelfar.vim @@ -0,0 +1,42 @@ +"============================================================================ +"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, + \ 'filetype': 'tcl', + \ 'subchecker': 'nagelfar' }) + + let errorformat = + \ '%I%f: %l: N %m,'. + \ '%f: %l: %t %m,'. + \ '%-GChecking file %f' + + return SyntasticMake({ + \ 'makeprg': makeprg, + \ 'errorformat': errorformat }) +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'tcl', + \ 'name': 'nagelfar'}) diff --git a/sources_non_forked/syntastic/syntax_checkers/tex/chktex.vim b/sources_non_forked/syntastic/syntax_checkers/tex/chktex.vim new file mode 100644 index 00000000..43ae2f52 --- /dev/null +++ b/sources_non_forked/syntastic/syntax_checkers/tex/chktex.vim @@ -0,0 +1,62 @@ +"============================================================================ +"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', + \ 'filetype': 'tex', + \ 'subchecker': 'chktex' }) + + let errorformat = + \ '%EError %n in %f line %l: %m,' . + \ '%WWarning %n in %f line %l: %m,' . + \ (g:syntastic_tex_chktex_showmsgs ? '%WMessage %n in %f line %l: %m,' : '') . + \ '%Z%p^,' . + \ '%-G%.%#' + + return SyntasticMake({ + \ 'makeprg': makeprg, + \ 'errorformat': errorformat, + \ 'subtype': 'Style', + \ 'postprocess': ['sort'] }) +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'tex', + \ 'name': 'chktex'}) diff --git a/sources_non_forked/syntastic/syntax_checkers/tex/lacheck.vim b/sources_non_forked/syntastic/syntax_checkers/tex/lacheck.vim new file mode 100644 index 00000000..d68a519a --- /dev/null +++ b/sources_non_forked/syntastic/syntax_checkers/tex/lacheck.vim @@ -0,0 +1,39 @@ +"============================================================================ +"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', + \ 'filetype': 'tex', + \ 'subchecker': 'lacheck' }) + + let errorformat = + \ '%-G** %f:,' . + \ '%E"%f"\, line %l: %m' + + return SyntasticMake({ + \ 'makeprg': makeprg, + \ 'errorformat': errorformat }) +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'tex', + \ 'name': 'lacheck'}) diff --git a/sources_non_forked/syntastic/syntax_checkers/text/atdtool.vim b/sources_non_forked/syntastic/syntax_checkers/text/atdtool.vim new file mode 100644 index 00000000..9f5061b8 --- /dev/null +++ b/sources_non_forked/syntastic/syntax_checkers/text/atdtool.vim @@ -0,0 +1,57 @@ +"============================================================================ +"File: atdtool.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_text_atdtool_checker") + finish +endif +let g:loaded_syntastic_text_atdtool_checker = 1 + +function! SyntaxCheckers_text_atdtool_IsAvailable() + return executable('atdtool') +endfunction + +function! SyntaxCheckers_text_atdtool_GetHighlightRegex(item) + let term = matchstr(a:item['text'], '\m "\zs[^"]\+\ze"\($\| | suggestions:\)') + if term != '' + let col = get(a:item, 'col', 0) + let term = (col != 0 ? '\%' . col . 'c' : '') . '\V' . term + endif + return term +endfunction + +function! SyntaxCheckers_text_atdtool_GetLocList() + let makeprg = syntastic#makeprg#build({ + \ 'exe': 'atdtool', + \ 'tail': '2>' . syntastic#util#DevNull(), + \ 'filetype': 'text', + \ 'subchecker': 'atdtool' }) + + let errorformat = + \ '%W%f:%l:%c: %m,'. + \ '%+C suggestions:%.%#' + + let loclist = SyntasticMake({ + \ 'makeprg': makeprg, + \ 'errorformat': errorformat, + \ 'returns': [0], + \ 'subtype': 'Style' }) + + for n in range(len(loclist)) + let loclist[n]['text'] = substitute(loclist[n]['text'], '\n\s\+', ' | ', 'g') + endfor + + return loclist +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'text', + \ 'name': 'atdtool'}) diff --git a/sources_non_forked/syntastic/syntax_checkers/twig/twiglint.vim b/sources_non_forked/syntastic/syntax_checkers/twig/twiglint.vim new file mode 100644 index 00000000..7cbba5f4 --- /dev/null +++ b/sources_non_forked/syntastic/syntax_checkers/twig/twiglint.vim @@ -0,0 +1,43 @@ +"============================================================================ +"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', + \ 'filetype': 'twig', + \ '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/sources_non_forked/syntastic/syntax_checkers/typescript/tsc.vim b/sources_non_forked/syntastic/syntax_checkers/typescript/tsc.vim new file mode 100644 index 00000000..768dc4e0 --- /dev/null +++ b/sources_non_forked/syntastic/syntax_checkers/typescript/tsc.vim @@ -0,0 +1,40 @@ +"============================================================================ +"File: typescript.vim +"Description: TypeScript syntax checker +"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', + \ 'args': '--module commonjs', + \ 'post_args': '--out ' . syntastic#util#DevNull(), + \ 'filetype': 'typescript', + \ 'subchecker': 'tsc' }) + + let errorformat = + \ '%E%f %#(%l\,%c): error %m,' . + \ '%E%f %#(%l\,%c): %m,' . + \ '%Eerror %m,' . + \ '%C%\s%\+%m' + + return SyntasticMake({ + \ 'makeprg': makeprg, + \ 'errorformat': errorformat, + \ 'defaults': {'bufnr': bufnr("")}, + \ 'postprocess': ['sort'] }) +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'typescript', + \ 'name': 'tsc'}) diff --git a/sources_non_forked/syntastic/syntax_checkers/vala/valac.vim b/sources_non_forked/syntastic/syntax_checkers/vala/valac.vim new file mode 100644 index 00000000..09b6c28b --- /dev/null +++ b/sources_non_forked/syntastic/syntax_checkers/vala/valac.vim @@ -0,0 +1,74 @@ +"============================================================================ +"File: vala.vim +"Description: Syntax checking plugin for syntastic.vim +"Maintainer: Konstantin Stepanov (me@kstep.me) +"Notes: Add special comment line into your vala file starting with +" "// modules: " and containing space delimited list of vala +" modules, used by the file, so this script can build correct +" --pkg arguments. +" Alternatively you can set g:syntastic_vala_modules array +" in your .vimrc or .lvimrc with localvimrc plugin +" (http://www.vim.org/scripts/script.php?script_id=441). +" Valac compiler is not the fastest thing in the world, so you +" may want to disable this plugin with +" let g:syntastic_vala_check_disabled = 1 command in your .vimrc or +" command line. Unlet this variable to set it to 0 to reenable +" this checker. +"License: This program is free software. It comes without any warranty, +" to the extent permitted by applicable law. You can redistribute +" it and/or modify it under the terms of the Do What The Fuck You +" Want To Public License, Version 2, as published by Sam Hocevar. +" See http://sam.zoy.org/wtfpl/COPYING for more details. +" +"============================================================================ + +if exists("g:loaded_syntastic_vala_valac_checker") + finish +endif +let g:loaded_syntastic_vala_valac_checker = 1 + +function! SyntaxCheckers_vala_valac_IsAvailable() + return executable('valac') +endfunction + +function! SyntaxCheckers_vala_valac_GetHighlightRegex(pos) + let strlength = strlen(matchstr(a:pos['text'], '\^\+$')) + return '\%>'.(a:pos.col-1).'c.*\%<'.(a:pos.col+strlength+1).'c' +endfunction + +function! s:GetValaModules() + if exists('g:syntastic_vala_modules') + if type(g:syntastic_vala_modules) == type('') + return split(g:syntastic_vala_modules, '\s\+') + elseif type(g:syntastic_vala_modules) == type([]) + return copy(g:syntastic_vala_modules) + else + echoerr 'g:syntastic_vala_modules must be either list or string: fallback to in file modules string' + endif + endif + + let modules_line = search('^// modules: ', 'n') + let modules_str = getline(modules_line) + return split(strpart(modules_str, 12), '\s\+') +endfunction + +function! SyntaxCheckers_vala_valac_GetLocList() + let vala_pkg_args = join(map(s:GetValaModules(), '"--pkg ".v:val'), ' ') + let makeprg = syntastic#makeprg#build({ + \ 'exe': 'valac', + \ 'args': '-C ' . vala_pkg_args, + \ 'filetype': 'vala', + \ 'subchecker': 'valac' }) + let errorformat = + \ '%A%f:%l.%c-%\d%\+.%\d%\+: %t%[a-z]%\+: %m,'. + \ '%C%m,'. + \ '%Z%m' + + return SyntasticMake({ + \ 'makeprg': makeprg, + \ 'errorformat': errorformat }) +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'vala', + \ 'name': 'valac'}) diff --git a/sources_non_forked/syntastic/syntax_checkers/vhdl/ghdl.vim b/sources_non_forked/syntastic/syntax_checkers/vhdl/ghdl.vim new file mode 100644 index 00000000..7158cd78 --- /dev/null +++ b/sources_non_forked/syntastic/syntax_checkers/vhdl/ghdl.vim @@ -0,0 +1,37 @@ +"============================================================================ +"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("g:loaded_syntastic_vhdl_ghdl_checker") + finish +endif +let g:loaded_syntastic_vhdl_ghdl_checker = 1 + +function! SyntaxCheckers_vhdl_ghdl_IsAvailable() + return executable("ghdl") +endfunction + +function! SyntaxCheckers_vhdl_ghdl_GetLocList() + let makeprg = syntastic#makeprg#build({ + \ 'exe': 'ghdl', + \ 'args': '-s', + \ 'filetype': 'vhdl', + \ 'subchecker': 'ghdl' }) + + let errorformat = '%f:%l:%c: %m' + + return SyntasticMake({ + \ 'makeprg': makeprg, + \ 'errorformat': errorformat }) +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'vhdl', + \ 'name': 'ghdl'}) diff --git a/sources_non_forked/syntastic/syntax_checkers/xhtml/tidy.vim b/sources_non_forked/syntastic/syntax_checkers/xhtml/tidy.vim new file mode 100644 index 00000000..e0c22fbb --- /dev/null +++ b/sources_non_forked/syntastic/syntax_checkers/xhtml/tidy.vim @@ -0,0 +1,89 @@ +"============================================================================ +"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:IgnoreError(text) + for i in g:syntastic_xhtml_tidy_ignore_errors + if stridx(a:text, i) != -1 + return 1 + endif + endfor + return 0 +endfunction + +function! SyntaxCheckers_xhtml_tidy_GetLocList() + let encopt = s:TidyEncOptByFenc() + let makeprg = syntastic#makeprg#build({ + \ 'exe': 'tidy', + \ 'args': encopt . ' -xml -e', + \ 'filetype': 'xhtml', + \ 'subchecker': 'tidy' }) + + let errorformat= + \ '%Wline %l column %v - Warning: %m,' . + \ '%Eline %l column %v - Error: %m,' . + \ '%-G%.%#' + + let loclist = SyntasticMake({ + \ 'makeprg': makeprg, + \ 'errorformat': errorformat, + \ 'defaults': {'bufnr': bufnr("")}, + \ 'returns': [0, 1, 2] }) + + for n in range(len(loclist)) + if loclist[n]['valid'] && s:IgnoreError(loclist[n]['text']) == 1 + let loclist[n]['valid'] = 0 + endif + endfor + + return loclist +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'xhtml', + \ 'name': 'tidy'}) diff --git a/sources_non_forked/syntastic/syntax_checkers/xml/xmllint.vim b/sources_non_forked/syntastic/syntax_checkers/xml/xmllint.vim new file mode 100644 index 00000000..5a6e1db7 --- /dev/null +++ b/sources_non_forked/syntastic/syntax_checkers/xml/xmllint.vim @@ -0,0 +1,52 @@ +"============================================================================ +"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', + \ 'filetype': 'xml', + \ 'subchecker': 'xmllint' }) + + let errorformat= + \ '%E%f:%l: error : %m,' . + \ '%-G%f:%l: validity error : Validation failed: no DTD found %m,' . + \ '%W%f:%l: warning : %m,' . + \ '%W%f:%l: validity warning : %m,' . + \ '%E%f:%l: validity error : %m,' . + \ '%E%f:%l: parser error : %m,' . + \ '%E%f:%l: %m,' . + \ '%-Z%p^,' . + \ '%-G%.%#' + + return SyntasticMake({ + \ 'makeprg': makeprg, + \ 'errorformat': errorformat, + \ 'returns': [0, 1, 2, 3, 4, 5] }) +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'xml', + \ 'name': 'xmllint'}) diff --git a/sources_non_forked/syntastic/syntax_checkers/xslt/xmllint.vim b/sources_non_forked/syntastic/syntax_checkers/xslt/xmllint.vim new file mode 100644 index 00000000..db397ed8 --- /dev/null +++ b/sources_non_forked/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 + +function! SyntaxCheckers_xslt_xmllint_IsAvailable() + return SyntaxCheckers_xml_xmllint_IsAvailable() +endfunction + +function! SyntaxCheckers_xslt_xmllint_GetLocList() + return SyntaxCheckers_xml_xmllint_GetLocList() +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'xslt', + \ 'name': 'xmllint'}) + +runtime! syntax_checkers/xml/*.vim diff --git a/sources_non_forked/syntastic/syntax_checkers/yaml/jsyaml.vim b/sources_non_forked/syntastic/syntax_checkers/yaml/jsyaml.vim new file mode 100644 index 00000000..9ffdc658 --- /dev/null +++ b/sources_non_forked/syntastic/syntax_checkers/yaml/jsyaml.vim @@ -0,0 +1,42 @@ +"============================================================================ +"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', + \ 'filetype': 'yaml', + \ 'subchecker': 'jsyaml' }) + + let errorformat='Error on line %l\, col %c:%m,%-G%.%#' + + return SyntasticMake({ + \ 'makeprg': makeprg, + \ 'errorformat': errorformat, + \ 'defaults': {'bufnr': bufnr("")} }) +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'yaml', + \ 'name': 'jsyaml'}) diff --git a/sources_non_forked/syntastic/syntax_checkers/z80/z80syntaxchecker.vim b/sources_non_forked/syntastic/syntax_checkers/z80/z80syntaxchecker.vim new file mode 100644 index 00000000..b68acf13 --- /dev/null +++ b/sources_non_forked/syntastic/syntax_checkers/z80/z80syntaxchecker.vim @@ -0,0 +1,41 @@ +"============================================================================ +"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', + \ 'filetype': 'z80', + \ 'subchecker': 'z80syntaxchecker' }) + + let errorformat = '%f:%l %m' + + return SyntasticMake({ + \ 'makeprg': makeprg, + \ 'errorformat': errorformat }) +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'z80', + \ 'name': 'z80syntaxchecker'}) diff --git a/sources_non_forked/syntastic/syntax_checkers/zpt/zptlint.vim b/sources_non_forked/syntastic/syntax_checkers/zpt/zptlint.vim new file mode 100644 index 00000000..ae6ab8a3 --- /dev/null +++ b/sources_non_forked/syntastic/syntax_checkers/zpt/zptlint.vim @@ -0,0 +1,50 @@ +"============================================================================ +"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', + \ 'filetype': 'zpt', + \ 'subchecker': 'zptlint' }) + + let errorformat= + \ '%-P*** Error in: %f,'. + \ '%Z%*\s\, at line %l\, column %c,'. + \ '%E%*\s%m,'. + \ '%-Q' + + return SyntasticMake({ + \ 'makeprg': makeprg, + \ 'errorformat': errorformat }) +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'zpt', + \ 'name': 'zptlint'}) diff --git a/sources_non_forked/syntastic/syntax_checkers/zsh/zsh.vim b/sources_non_forked/syntastic/syntax_checkers/zsh/zsh.vim new file mode 100644 index 00000000..5e339a9c --- /dev/null +++ b/sources_non_forked/syntastic/syntax_checkers/zsh/zsh.vim @@ -0,0 +1,38 @@ +"============================================================================ +"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', + \ 'filetype': 'zsh', + \ '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/sources_non_forked/taglist.vim/doc/tags b/sources_non_forked/taglist.vim/doc/tags deleted file mode 100644 index 83e80ba1..00000000 --- a/sources_non_forked/taglist.vim/doc/tags +++ /dev/null @@ -1,62 +0,0 @@ -'Tlist_Auto_Highlight_Tag' taglist.txt /*'Tlist_Auto_Highlight_Tag'* -'Tlist_Auto_Open' taglist.txt /*'Tlist_Auto_Open'* -'Tlist_Auto_Update' taglist.txt /*'Tlist_Auto_Update'* -'Tlist_Close_On_Select' taglist.txt /*'Tlist_Close_On_Select'* -'Tlist_Compact_Format' taglist.txt /*'Tlist_Compact_Format'* -'Tlist_Ctags_Cmd' taglist.txt /*'Tlist_Ctags_Cmd'* -'Tlist_Display_Prototype' taglist.txt /*'Tlist_Display_Prototype'* -'Tlist_Display_Tag_Scope' taglist.txt /*'Tlist_Display_Tag_Scope'* -'Tlist_Enable_Fold_Column' taglist.txt /*'Tlist_Enable_Fold_Column'* -'Tlist_Exit_OnlyWindow' taglist.txt /*'Tlist_Exit_OnlyWindow'* -'Tlist_File_Fold_Auto_Close' taglist.txt /*'Tlist_File_Fold_Auto_Close'* -'Tlist_GainFocus_On_ToggleOpen' taglist.txt /*'Tlist_GainFocus_On_ToggleOpen'* -'Tlist_Highlight_Tag_On_BufEnter' taglist.txt /*'Tlist_Highlight_Tag_On_BufEnter'* -'Tlist_Inc_Winwidth' taglist.txt /*'Tlist_Inc_Winwidth'* -'Tlist_Max_Submenu_Items' taglist.txt /*'Tlist_Max_Submenu_Items'* -'Tlist_Max_Tag_Length' taglist.txt /*'Tlist_Max_Tag_Length'* -'Tlist_Process_File_Always' taglist.txt /*'Tlist_Process_File_Always'* -'Tlist_Show_Menu' taglist.txt /*'Tlist_Show_Menu'* -'Tlist_Show_One_File' taglist.txt /*'Tlist_Show_One_File'* -'Tlist_Sort_Type' taglist.txt /*'Tlist_Sort_Type'* -'Tlist_Use_Horiz_Window' taglist.txt /*'Tlist_Use_Horiz_Window'* -'Tlist_Use_Right_Window' taglist.txt /*'Tlist_Use_Right_Window'* -'Tlist_Use_SingleClick' taglist.txt /*'Tlist_Use_SingleClick'* -'Tlist_WinHeight' taglist.txt /*'Tlist_WinHeight'* -'Tlist_WinWidth' taglist.txt /*'Tlist_WinWidth'* -:TlistAddFiles taglist.txt /*:TlistAddFiles* -:TlistAddFilesRecursive taglist.txt /*:TlistAddFilesRecursive* -:TlistClose taglist.txt /*:TlistClose* -:TlistDebug taglist.txt /*:TlistDebug* -:TlistHighlightTag taglist.txt /*:TlistHighlightTag* -:TlistLock taglist.txt /*:TlistLock* -:TlistMessages taglist.txt /*:TlistMessages* -:TlistOpen taglist.txt /*:TlistOpen* -:TlistSessionLoad taglist.txt /*:TlistSessionLoad* -:TlistSessionSave taglist.txt /*:TlistSessionSave* -:TlistShowPrototype taglist.txt /*:TlistShowPrototype* -:TlistShowTag taglist.txt /*:TlistShowTag* -:TlistToggle taglist.txt /*:TlistToggle* -:TlistUndebug taglist.txt /*:TlistUndebug* -:TlistUnlock taglist.txt /*:TlistUnlock* -:TlistUpdate taglist.txt /*:TlistUpdate* -Tlist_Get_Tag_Prototype_By_Line() taglist.txt /*Tlist_Get_Tag_Prototype_By_Line()* -Tlist_Get_Tagname_By_Line() taglist.txt /*Tlist_Get_Tagname_By_Line()* -Tlist_Set_App() taglist.txt /*Tlist_Set_App()* -Tlist_Update_File_Tags() taglist.txt /*Tlist_Update_File_Tags()* -taglist-commands taglist.txt /*taglist-commands* -taglist-debug taglist.txt /*taglist-debug* -taglist-extend taglist.txt /*taglist-extend* -taglist-faq taglist.txt /*taglist-faq* -taglist-functions taglist.txt /*taglist-functions* -taglist-install taglist.txt /*taglist-install* -taglist-internet taglist.txt /*taglist-internet* -taglist-intro taglist.txt /*taglist-intro* -taglist-keys taglist.txt /*taglist-keys* -taglist-license taglist.txt /*taglist-license* -taglist-menu taglist.txt /*taglist-menu* -taglist-options taglist.txt /*taglist-options* -taglist-requirements taglist.txt /*taglist-requirements* -taglist-session taglist.txt /*taglist-session* -taglist-todo taglist.txt /*taglist-todo* -taglist-using taglist.txt /*taglist-using* -taglist.txt taglist.txt /*taglist.txt* diff --git a/sources_non_forked/vim-expand-region/doc/tags b/sources_non_forked/vim-expand-region/doc/tags deleted file mode 100644 index 402a0c43..00000000 --- a/sources_non_forked/vim-expand-region/doc/tags +++ /dev/null @@ -1,10 +0,0 @@ -expand-region-about expand_region.txt /*expand-region-about* -expand-region-contents expand_region.txt /*expand-region-contents* -expand-region-global-options expand_region.txt /*expand-region-global-options* -expand-region-intro expand_region.txt /*expand-region-intro* -expand-region-mappings expand_region.txt /*expand-region-mappings* -expand-region-usage expand_region.txt /*expand-region-usage* -expand_region_text_objects expand_region.txt /*expand_region_text_objects* -expand_region_use_select_mode expand_region.txt /*expand_region_use_select_mode* -vim-expand-region.txt expand_region.txt /*vim-expand-region.txt* -vim-expand-regions expand_region.txt /*vim-expand-regions* diff --git a/sources_non_forked/vim-multiple-cursors/doc/tags b/sources_non_forked/vim-multiple-cursors/doc/tags deleted file mode 100644 index 5efd6085..00000000 --- a/sources_non_forked/vim-multiple-cursors/doc/tags +++ /dev/null @@ -1,21 +0,0 @@ -MultipleCursorsFind multiple_cursors.txt /*MultipleCursorsFind* -g:multi_cursor_exit_from_insert_mode multiple_cursors.txt /*g:multi_cursor_exit_from_insert_mode* -g:multi_cursor_exit_from_visual_mode multiple_cursors.txt /*g:multi_cursor_exit_from_visual_mode* -g:multi_cursor_next_key multiple_cursors.txt /*g:multi_cursor_next_key* -g:multi_cursor_prev_key multiple_cursors.txt /*g:multi_cursor_prev_key* -g:multi_cursor_quit_key multiple_cursors.txt /*g:multi_cursor_quit_key* -g:multi_cursor_skip_key multiple_cursors.txt /*g:multi_cursor_skip_key* -g:multi_cursor_start_key multiple_cursors.txt /*g:multi_cursor_start_key* -g:multi_cursor_use_default_mapping multiple_cursors.txt /*g:multi_cursor_use_default_mapping* -multiple-cursors-contents multiple_cursors.txt /*multiple-cursors-contents* -multiple-cursors-contributing multiple_cursors.txt /*multiple-cursors-contributing* -multiple-cursors-credit multiple_cursors.txt /*multiple-cursors-credit* -multiple-cursors-global-options multiple_cursors.txt /*multiple-cursors-global-options* -multiple-cursors-intro multiple_cursors.txt /*multiple-cursors-intro* -multiple-cursors-issues multiple_cursors.txt /*multiple-cursors-issues* -multiple-cursors-license multiple_cursors.txt /*multiple-cursors-license* -multiple-cursors-mappings multiple_cursors.txt /*multiple-cursors-mappings* -multiple-cursors-references multiple_cursors.txt /*multiple-cursors-references* -multiple-cursors-usage multiple_cursors.txt /*multiple-cursors-usage* -vim-multiple-cursors multiple_cursors.txt /*vim-multiple-cursors* -vim-multiple-cursors.txt multiple_cursors.txt /*vim-multiple-cursors.txt* diff --git a/update_plugins.py b/update_plugins.py index 345c9ebb..7cbb8042 100644 --- a/update_plugins.py +++ b/update_plugins.py @@ -7,6 +7,8 @@ from os import path #--- Globals ---------------------------------------------- +### ctags https://github.com/vim-scripts/ctags.vim + PLUGINS = """ bufexplorer https://github.com/corntrace/bufexplorer ctrlp.vim https://github.com/kien/ctrlp.vim @@ -16,21 +18,22 @@ nginx.vim https://github.com/vim-scripts/nginx.vim open_file_under_cursor.vim https://github.com/amix/open_file_under_cursor.vim pyflakes https://github.com/vim-scripts/pyflakes snipmate-snippets https://github.com/scrooloose/snipmate-snippets +syntastic https://github.com/scrooloose/syntastic taglist.vim https://github.com/vim-scripts/taglist.vim tlib https://github.com/vim-scripts/tlib vim-addon-mw-utils https://github.com/MarcWeber/vim-addon-mw-utils vim-bundle-mako https://github.com/sophacles/vim-bundle-mako vim-colors-solarized https://github.com/altercation/vim-colors-solarized +vim-expand-region https://github.com/terryma/vim-expand-region vim-less https://github.com/groenewege/vim-less vim-markdown https://github.com/tpope/vim-markdown +vim-multiple-cursors https://github.com/terryma/vim-multiple-cursors +vim-pep8 https://github.com/xiaocao/vim-pep8 vim-pyte https://github.com/therubymug/vim-pyte vim-snipmate https://github.com/garbas/vim-snipmate vim-snippets https://github.com/honza/vim-snippets vim-statline https://github.com/millermedeiros/vim-statline vim-surround https://github.com/tpope/vim-surround -vim-expand-region https://github.com/terryma/vim-expand-region -vim-multiple-cursors https://github.com/terryma/vim-multiple-cursors -vim-pep8 https://github.com/xiaocao/vim-pep8 """.strip() GITHUB_ZIP = '%s/archive/master.zip'