diff options
Diffstat (limited to 'vim/bundle/syntastic')
245 files changed, 24971 insertions, 0 deletions
diff --git a/vim/bundle/syntastic/.gitignore b/vim/bundle/syntastic/.gitignore new file mode 100644 index 0000000..cc07c93 --- /dev/null +++ b/vim/bundle/syntastic/.gitignore @@ -0,0 +1,4 @@ +*~ +*.swp +tags +.DS_Store diff --git a/vim/bundle/syntastic/CONTRIBUTING.md b/vim/bundle/syntastic/CONTRIBUTING.md new file mode 100644 index 0000000..1949415 --- /dev/null +++ b/vim/bundle/syntastic/CONTRIBUTING.md @@ -0,0 +1,105 @@ +# CONTRIBUTING +- - - +1\. [Bug reports / GitHub issues](#bugreps) +2\. [Submitting a patch](#patches) +3\. [General style notes](#generalstyle) +4\. [Syntax checker notes](#checkerstyle) +- - - + +<a name="bugreps"></a> + +## 1. Bug reports / GitHub issues + +Please note that the preferred channel for posting bug reports is the +[issue tracker at GitHub][bug_tracker]. Reports posted elsewhere are less likely +to be seen by the core team. + +When reporting a bug make sure you search the existing GitHub issues +for the same/similar issues. If you find one, feel free to add a `+1` +comment with any additional information that may help us solve the +issue. + +When creating a new issue be sure to state the following: + +* steps to reproduce the bug; +* the version of Vim you are using (run `:ver` to find out); +* the version of syntastic you are using (see `:SyntasticInfo`). + +For syntax checker bugs also state the version of the checker executable +that you are using. Adding debugging information is typically useful +too: + +* open a file handled by your checker; +* set `g:syntastic_debug` to 1 or 3; +* run the checker; +* copy the output of `:mes`. + +<a name="patches"></a> + +## 2. Submitting a patch + +Before you consider adding features to syntastic, _please_ spend a few minutes +(re-)reading the latest version of the [manual][manual]. Syntastic is changing +rapidly at times, and it's possible that some features you want to add exist +already. + +To submit a patch: + +* fork the [repo][github] on GitHub; +* make a [topic branch][branches] and start hacking; +* submit a pull request based off your topic branch. + +Small, focused patches are preferred. + +Large changes to the code should be discussed with the core team first. +Create an issue and explain your plan and see what we say. + +Also, make sure to update the manual whenever applicable. Nobody can use +features that aren't documented. + +<a name="generalstyle"></a> + +## 3. General style notes + +Follow the coding conventions/styles used in the syntastic core: + +* use 4 space indents; +* don't use abbreviated keywords - e.g. use `endfunction`, not `endfun` +(there's always room for more fun!); +* don't use `l:` prefixes for variables unless actually required (i.e. +almost never); +* code for maintainability; we would rather a function be a couple of +lines longer and have (for example) some [explaining variables][variables] to +aid readability. + +<a name="checkerstyle"></a> + +## 4. Syntax checker notes + +Make sure to read the [guide][guide] if you plan to add new syntax checkers. + +Use the existing checkers as templates, rather than writing everything +from scratch. + +The preferred style for error format strings is one "clause" per line. +E.g. (from the `coffee` checker): + +```vim +let errorformat = + \ '%E%f:%l:%c: %trror: %m,' . + \ 'Syntax%trror: In %f\, %m on line %l,' . + \ '%EError: In %f\, Parse error on line %l: %m,' . + \ '%EError: In %f\, %m on line %l,' . + \ '%W%f(%l): lint warning: %m,' . + \ '%W%f(%l): warning: %m,' . + \ '%E%f(%l): SyntaxError: %m,' . + \ '%-Z%p^,' . + \ '%-G%.%#' +``` + +[bug_tracker]: https://github.com/scrooloose/syntastic/issues +[manual]: https://github.com/scrooloose/syntastic/blob/master/doc/syntastic.txt +[github]: https://github.com/scrooloose/syntastic +[branches]: https://github.com/dchelimsky/rspec/wiki/Topic-Branches#using-topic-branches-when-contributing-patches +[variables]: http://www.refactoring.com/catalog/extractVariable.html +[guide]: https://github.com/scrooloose/syntastic/wiki/Syntax-Checker-Guide diff --git a/vim/bundle/syntastic/LICENCE b/vim/bundle/syntastic/LICENCE new file mode 100644 index 0000000..8b1a9d8 --- /dev/null +++ b/vim/bundle/syntastic/LICENCE @@ -0,0 +1,13 @@ + DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE + Version 2, December 2004 + +Copyright (C) 2004 Sam Hocevar <sam@hocevar.net> + +Everyone is permitted to copy and distribute verbatim or modified +copies of this license document, and changing it is allowed as long +as the name is changed. + + DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE + TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION + + 0. You just DO WHAT THE FUCK YOU WANT TO. diff --git a/vim/bundle/syntastic/README.markdown b/vim/bundle/syntastic/README.markdown new file mode 100644 index 0000000..685d840 --- /dev/null +++ b/vim/bundle/syntastic/README.markdown @@ -0,0 +1,480 @@ + , + / \,,_ .'| + ,{{| /}}}}/_.' _____________________________________________ + }}}}` '{{' '. / \ + {{{{{ _ ;, \ / Ladies and Gentlemen, \ + ,}}}}}} /o`\ ` ;) | | + {{{{{{ / ( | this is ... | + }}}}}} | \ | | + {{{{{{{{ \ \ | | + }}}}}}}}} '.__ _ | | _____ __ __ _ | + {{{{{{{{ /`._ (_\ / | / ___/__ ______ / /_____ ______/ /_(_)____ | + }}}}}}' | //___/ --=: \__ \/ / / / __ \/ __/ __ `/ ___/ __/ / ___/ | + jgs `{{{{` | '--' | ___/ / /_/ / / / / /_/ /_/ (__ ) /_/ / /__ | + }}}` | /____/\__, /_/ /_/\__/\__,_/____/\__/_/\___/ | + | /____/ | + | / + \_____________________________________________/ + + +- - - +1. [Introduction](#introduction) +2. [Installation](#installation) +2.1. [Requirements](#requirements) +2.2. [Installing syntastic with Pathogen](#installpathogen) +3. [Recommended settings](#settings) +4. [FAQ](#faq) +4.1. [I installed syntastic but it isn't reporting any errors...](#faqinfo) +4.2. [The `python` checker complains about syntactically valid Python 3 constructs...](#faqpython3) +4.3. [Are there any local checkers for HTML5 that I can use with syntastic?](#faqhtml5) +4.4. [The `perl` checker has stopped working...](#faqperl) +4.5. [What happened to the `rustc` checker?](#faqrust) +4.6. [What happened to the `xcrun` checker?](#faqxcrun) +4.7. [I run a checker and the location list is not updated...](#faqloclist) +4.7. [I run`:lopen` or `:lwindow` and the error window is empty...](#faqloclist) +4.8. [How can I pass additional arguments to a checker?](#faqargs) +4.9. [Syntastic supports several checkers for my filetype - how do I tell which one(s) to use?](#faqcheckers) +4.10. [What is the difference between syntax checkers and style checkers?](#faqstyle) +4.11. [I have enabled multiple checkers for the current filetype. How can I display all errors from all checkers together?](#faqaggregate) +4.12. [How can I jump between the different errors without using the location list at the bottom of the window?](#faqlnext) +4.13. [The error window is closed automatically when I :quit the current buffer but not when I :bdelete it?](#faqbdelete) +5. [Resources](#otherresources) + +- - - + +<a name="introduction"></a> + +## 1\. Introduction + +Syntastic is a syntax checking plugin for [Vim][vim] that runs files through +external syntax checkers and displays any resulting errors to the user. This +can be done on demand, or automatically as files are saved. If syntax errors +are detected, the user is notified and is happy because they didn't have to +compile their code or execute their script to find them. + +At the time of this writing, syntastic has checking plugins for ActionScript, +Ada, Ansible configurations, API Blueprint, AppleScript, AsciiDoc, Assembly +languages, BEMHTML, Bro, Bourne shell, C, C++, C#, Cabal, Chef, CoffeeScript, +Coco, Coq, CSS, Cucumber, CUDA, D, Dart, DocBook, Dockerfile, Dust, Elixir, +Erlang, eRuby, Fortran, Gentoo metadata, GLSL, Go, Haml, Haskell, Haxe, +Handlebars, HSS, HTML, Java, JavaScript, JSON, JSX, LESS, Lex, Limbo, LISP, +LLVM intermediate language, Lua, Markdown, MATLAB, Mercury, NASM, Nix, +Objective-C, Objective-C++, OCaml, Perl, Perl POD, PHP, gettext Portable +Object, OS X and iOS property lists, Pug (formerly Jade), Puppet, Python, +QML, R, Racket, RDF TriG, RDF Turtle, Relax NG, reStructuredText, RPM spec, +Ruby, SASS/SCSS, Scala, Slim, SML, Sphinx, SQL, Stylus, Tcl, TeX, Texinfo, +Twig, TypeScript, Vala, Verilog, VHDL, VimL, xHtml, XML, XSLT, XQuery, +YACC, YAML, YANG data models, z80, Zope page templates, and Zsh. See the +[manual][checkers] for details about the corresponding supported checkers +(`:help syntastic-checkers` in Vim). + +A number of third-party Vim plugins also provide checkers for syntastic, +for example: [merlin][merlin], [omnisharp-vim][omnisharp], [rust.vim][rust], +[syntastic-extras][myint], [syntastic-more][roktas], [vim-crystal][crystal], +[vim-eastwood][eastwood], and [vim-swift][swift]. + +Below is a screenshot showing the methods that Syntastic uses to display syntax +errors. Note that, in practise, you will only have a subset of these methods +enabled. + +![Screenshot 1][screenshot] + +1. Errors are loaded into the location list for the corresponding window. +2. When the cursor is on a line containing an error, the error message is echoed in the command window. +3. Signs are placed beside lines with errors - note that warnings are displayed in a different color. +4. There is a configurable statusline flag you can include in your statusline config. +5. Hover the mouse over a line containing an error and the error message is displayed as a balloon. +6. (not shown) Highlighting errors with syntax highlighting. Erroneous parts of lines can be highlighted. + +<a name="installation"></a> + +## 2\. Installation + +<a name="requirements"></a> + +### 2.1\. Requirements + +Syntastic itself has rather relaxed requirements: it doesn't have any external +dependencies, and it needs a version of [Vim][vim] compiled with a few common +features: `autocmd`, `eval`, `file_in_path`, `modify_fname`, `quickfix`, +`reltime`, and `user_commands`. Not all possible combinations of features that +include the ones above make equal sense on all operating systems, but Vim +version 7 or later with the "normal", "big", or "huge" feature sets should be +fine. + +Syntastic should work with any modern plugin managers for Vim, such as +[NeoBundle][neobundle], [Pathogen][pathogen], [Vim-Addon-Manager][vam], [Vim-Plug][plug], or +[Vundle][vundle]. Instructions for installing syntastic with [Pathogen][pathogen] are +included below for completeness. + +Starting with Vim version 7.4.1486 you can also load syntastic using the +standard mechanism of packages, without the help of third-party plugin managers +(see `:help packages` in Vim for details). Beware however that, while support +for packages has been added in Vim 7.4.1384, the functionality needed by +syntastic is present only in versions 7.4.1486 and later. + +Last but not least: syntastic doesn't know how to do any syntax checks by +itself. In order to get meaningful results you need to install external +checkers corresponding to the types of files you use. Please consult the +[manual][checkers] (`:help syntastic-checkers` in Vim) for a list of supported +checkers. + +<a name="installpathogen"></a> + +### 2.2\. Installing syntastic with Pathogen + +If you already have [Pathogen][pathogen] working then skip [Step 1](#step1) and go to +[Step 2](#step2). + +<a name="step1"></a> + +#### 2.2.1\. Step 1: Install pathogen.vim + +First I'll show you how to install Tim Pope's [Pathogen][pathogen] so that it's easy to +install syntastic. Do this in your terminal so that you get the `pathogen.vim` +file and the directories it needs: +```sh +mkdir -p ~/.vim/autoload ~/.vim/bundle && \ +curl -LSso ~/.vim/autoload/pathogen.vim https://tpo.pe/pathogen.vim +``` +Next you *need* to add this to your `~/.vimrc`: +```vim +execute pathogen#infect() +``` + +<a name="step2"></a> + +#### 2.2.2\. Step 2: Install syntastic as a Pathogen bundle + +You now have pathogen installed and can put syntastic into `~/.vim/bundle` like +this: +```sh +cd ~/.vim/bundle && \ +git clone https://github.com/scrooloose/syntastic.git +``` +Quit vim and start it back up to reload it, then type: +```vim +:Helptags +``` +If you get an error when you do this, then you probably didn't install +[Pathogen][pathogen] right. Go back to [Step 1](#step1) and make sure you did the +following: + +1. Created both the `~/.vim/autoload` and `~/.vim/bundle` directories. +2. Added the `execute pathogen#infect()` line to your `~/.vimrc` file +3. Did the `git clone` of syntastic inside `~/.vim/bundle` +4. Have permissions to access all of these directories. + +<a name="settings"></a> + +## 3\. Recommended settings + +Syntastic has numerous options that can be configured, and the defaults +are not particularly well suitable for new users. It is recommended +that you start by adding the following lines to your `vimrc` file, and +return to them after reading the manual (see `:help syntastic` in Vim): +```vim +set statusline+=%#warningmsg# +set statusline+=%{SyntasticStatuslineFlag()} +set statusline+=%* + +let g:syntastic_always_populate_loc_list = 1 +let g:syntastic_auto_loc_list = 1 +let g:syntastic_check_on_open = 1 +let g:syntastic_check_on_wq = 0 +``` + +<a name="faq"></a> + +## 4\. FAQ + +<a name="faqinfo"></a> + +__4.1. Q. I installed syntastic but it isn't reporting any errors...__ + +A. The most likely reason is that none of the syntax checkers that it requires +are installed. For example: by default, python requires either `flake8` or +`pylint` to be installed and in your `$PATH`. Read the [manual][checkers] +(`:help syntastic-checkers` in Vim) to find out what executables are +supported. Note that aliases do not work; the actual executables must be +available in your `$PATH`. Symbolic links are okay though. You can see +syntastic's idea of available checkers by running `:SyntasticInfo`. + +A second probable reason is that none of the available checkers are +enabled. Syntastic comes preconfigured with a default list of enabled checkers +per filetype, but this list is kept short in order to prevent slowing down Vim +or trying to run conflicting checks. The command `:SyntasticInfo` will show you +which checkers are enabled. You can tell syntastic which checkers (among the +available ones) you want to run by setting `g:syntastic_<filetype>_checkers` in +your `vimrc` (see [below](#faqcheckers)). + +A third possible reason is that the `$PATH` seen by syntastic might not be same +as the `$PATH` in your login shell. Syntastic runs checkers using the shell +pointed to by Vim's `shell` (or by `g:syntastic_shell`, if set), and that's the +shell you need to configure to set the proper `$PATH` and environment variables +for your checkers. You can see syntastic's idea of `$PATH` by running +```vim +:echo syntastic#util#system('echo "$PATH"') +``` +on UNIX and Mac OS-X systems, or +```vim +:echo syntastic#util#system('echo %PATH%') +``` +on Windows. + +Finally, another reason it could fail is that either the command line options +or the error output for a syntax checker may have changed. In this case, make +sure you have the latest version of the syntax checker installed. If it still +fails then post an [issue][bug_tracker] - or better yet, create a pull request. + +<a name="faqpython3"></a> + +__4.2. Q. The `python` checker complains about syntactically valid Python 3 constructs...__ + +A. Configure the `python` checker to call a Python 3 interpreter rather than +Python 2, e.g: +```vim +let g:syntastic_python_python_exec = '/path/to/python3' +``` + +<a name="faqhtml5"></a> + +__4.3. Q. Are there any local checkers for HTML5 that I can use with syntastic?__ + +[HTML Tidy][tidy_old] has a fork named [HTML Tidy for HTML5][tidy]. It's a drop +in replacement, and syntastic can use it without changes. Just install it +somewhere and point `g:syntastic_html_tidy_exec` to its executable: +```vim +let g:syntastic_html_tidy_exec = 'tidy5' +``` +Alternatively, you can install [vnu.jar][vnu_jar] from the [validator.nu][vnu] +project and run it as a [HTTP server][vnu_server]: +```sh +$ java -Xss512k -cp /path/to/vnu.jar nu.validator.servlet.Main 8888 +``` +Then you can configure syntastic to use it: +```vim +let g:syntastic_html_validator_api = 'http://localhost:8888/' +``` + +<a name="faqperl"></a> + +__4.4. Q. The `perl` checker has stopped working...__ + +A. The `perl` checker runs `perl -c` against your file, which in turn +__executes__ any `BEGIN`, `UNITCHECK`, and `CHECK` blocks, and any `use` +statements in your file (cf. [perlrun][perlrun]). This is probably fine if you +wrote the file yourself, but it's a security problem if you're checking +third-party files. Since there is currently no way to disable this behaviour +while still producing useful results, the checker is now disabled by default. +To (re-)enable it, make sure the `g:syntastic_perl_checkers` list includes +`perl`, and set `g:syntastic_enable_perl_checker` to 1 in your `vimrc`: +```vim +let g:syntastic_enable_perl_checker = 1 +``` + +<a name="faqrust"></a> + +__4.5. Q. What happened to the `rustc` checker?__ + +A. It is now part of the [rust.vim][rust] plugin. If you install this plugin the +checker should be picked up automatically by syntastic. + +<a name="faqxcrun"></a> + +__4.6. Q. What happened to the `xcrun` checker?__ + +A. The `xcrun` checker used to have a security problem and it has been removed. +A better checker for __Swift__ is part of the [vim-swift][swift] plugin. If you +install this plugin the checker should be picked up automatically by syntastic. + +<a name="faqloclist"></a> + +__4.7. Q. I run a checker and the location list is not updated...__ +__4.7. Q. I run`:lopen` or `:lwindow` and the error window is empty...__ + +A. By default the location list is changed only when you run the `:Errors` +command, in order to minimise conflicts with other plugins. If you want the +location list to always be updated when you run the checkers, add this line to +your `vimrc`: +```vim +let g:syntastic_always_populate_loc_list = 1 +``` + +<a name="faqargs"></a> + +__4.8. Q. How can I pass additional arguments to a checker?__ + +A. Almost all syntax checkers use the `makeprgBuild()` function. Those checkers +that do can be configured using global variables. The general form of the +global `args` variables is `syntastic_<filetype>_<checker>_args`. + +So, If you wanted to pass `--my --args --here` to the ruby mri checker you +would add this line to your `vimrc`: +```vim +let g:syntastic_ruby_mri_args = "--my --args --here" +``` + +See `:help syntastic-checker-options` for more information. + +<a name="faqcheckers"></a> + +__4.9. Q. Syntastic supports several checkers for my filetype - how do I tell it +which one(s) to use?__ + +A. Stick a line like this in your `vimrc`: +```vim +let g:syntastic_<filetype>_checkers = ['<checker-name>'] +``` + +To see the list of supported checkers for your filetype read the +[manual][checkers] (`:help syntastic-checkers` in Vim). + +e.g. Python has the following checkers, among others: `flake8`, `pyflakes`, +`pylint` and a native `python` checker. + +To tell syntastic to use `pylint`, you would use this setting: +```vim +let g:syntastic_python_checkers = ['pylint'] +``` + +Checkers can be chained together like this: +```vim +let g:syntastic_php_checkers = ['php', 'phpcs', 'phpmd'] +``` + +This is telling syntastic to run the `php` checker first, and if no errors are +found, run `phpcs`, and then `phpmd`. + +You can also run checkers explicitly by calling `:SyntasticCheck <checker>`. + +e.g. to run `phpcs` and `phpmd`: +```vim +:SyntasticCheck phpcs phpmd +``` + +This works for any checkers available for the current filetype, even if they +aren't listed in `g:syntastic_<filetype>_checkers`. You can't run checkers for +"foreign" filetypes though (e.g. you can't run, say, a Python checker if the +filetype of the current file is `php`). + +<a name="faqstyle"></a> + +__4.10. Q. What is the difference between syntax checkers and style checkers?__ + +A. The errors and warnings they produce are highlighted differently and can +be filtered by different rules, but otherwise the distinction is pretty much +arbitrary. There is an ongoing effort to keep things consistent, so you can +_generally_ expect messages produced by syntax checkers to be _mostly_ related +to syntax, and messages produced by style checkers to be _mostly_ about style. +But there can be no formal guarantee that, say, a style checker that runs into +a syntax error wouldn't die with a fatal message, nor that a syntax checker +wouldn't give you warnings against using some constructs as being bad practice. +There is also no guarantee that messages marked as "style" are less severe than +the ones marked as "syntax" (whatever that might mean). And there are even a +few Frankenstein checkers (for example `flake8` and `pylama`) that, by their +nature, produce both kinds of messages. Syntastic is not smart enough to be +able to sort out these things by itself. + +In fact it's more useful to look at this from the perspective of filtering +unwanted messages, rather than as an indicator of severity levels. The +distinction between syntax and style is orthogonal to the distinction between +errors and warnings, and thus you can turn off messages based on level, on +type, or both. + +e.g. To disable all style messages: +```vim +let g:syntastic_quiet_messages = { "type": "style" } +``` +See `:help syntastic_quiet_messages` for details. + +<a name="faqaggregate"></a> + +__4.11. Q. I have enabled multiple checkers for the current filetype. How can I +display all errors from all checkers together?__ + +A. Set `g:syntastic_aggregate_errors` to 1 in your `vimrc`: +```vim +let g:syntastic_aggregate_errors = 1 +``` + +See `:help syntastic-aggregating-errors` for more details. + +<a name="faqlnext"></a> + +__4.12. Q. How can I jump between the different errors without using the location +list at the bottom of the window?__ + +A. Vim provides several built-in commands for this. See `:help :lnext` and +`:help :lprevious`. + +If you use these commands a lot then you may want to add shortcut mappings to +your `vimrc`, or install something like [unimpaired][unimpaired], which provides such +mappings (among other things). + +<a name="faqbdelete"></a> + +__4.13. Q. The error window is closed automatically when I :quit the current buffer +but not when I :bdelete it?__ + +A. There is no safe way to handle that situation automatically, but you can +work around it: + +```vim +nnoremap <silent> <C-d> :lclose<CR>:bdelete<CR> +cabbrev <silent> bd <C-r>=(getcmdtype()==#':' && getcmdpos()==1 ? 'lclose\|bdelete' : 'bd')<CR> +``` + +<a name="otherresources"></a> + +## 5\. Resources + +The preferred place for posting suggestions, reporting bugs, and general +discussions related to syntastic is the [issue tracker at GitHub][bug_tracker]. +A guide for writing syntax checkers can be found in the [wiki][guide]. +There are also a dedicated [google group][google_group], and a +[syntastic tag at StackOverflow][stack_overflow]. + +Syntastic aims to provide a common interface to syntax checkers for as many +languages as possible. For particular languages, there are, of course, other +plugins that provide more functionality than syntastic. You might want to take +a look at [ghcmod-vim][ghcmod], [jedi-vim][jedi], [python-mode][python_mode], [vim-go][vimgo], or +[YouCompleteMe][ycm]. + +[screenshot]: https://github.com/scrooloose/syntastic/raw/master/_assets/screenshot_1.png + +[bug_tracker]: https://github.com/scrooloose/syntastic/issues +[checkers]: https://github.com/scrooloose/syntastic/blob/master/doc/syntastic-checkers.txt +[crystal]: https://github.com/rhysd/vim-crystal +[eastwood]: https://github.com/venantius/vim-eastwood +[ghcmod]: https://github.com/eagletmt/ghcmod-vim +[google_group]: https://groups.google.com/group/vim-syntastic +[guide]: https://github.com/scrooloose/syntastic/wiki/Syntax-Checker-Guide +[jedi]: https://github.com/davidhalter/jedi-vim +[merlin]: https://github.com/the-lambda-church/merlin +[myint]: https://github.com/myint/syntastic-extras +[neobundle]: https://github.com/Shougo/neobundle.vim +[omnisharp]: https://github.com/OmniSharp/omnisharp-vim +[pathogen]: https://github.com/tpope/vim-pathogen +[perlrun]: http://perldoc.perl.org/perlrun.html#*-c* +[plug]: https://github.com/junegunn/vim-plug/ +[python_mode]: https://github.com/klen/python-mode +[roktas]: https://github.com/roktas/syntastic-more +[rust]: https://github.com/rust-lang/rust.vim +[stack_overflow]: http://stackoverflow.com/questions/tagged/syntastic +[swift]: https://github.com/kballard/vim-swift +[tidy]: http://www.htacg.org/tidy-html5/ +[tidy_old]: http://tidy.sourceforge.net/ +[unimpaired]: https://github.com/tpope/vim-unimpaired +[vam]: https://github.com/MarcWeber/vim-addon-manager +[vim]: http://www.vim.org/ +[vimgo]: https://github.com/fatih/vim-go +[vnu]: http://about.validator.nu/ +[vnu_jar]: https://github.com/validator/validator/releases/latest +[vnu_server]: http://validator.github.io/validator/#standalone +[vundle]: https://github.com/gmarik/Vundle.vim +[ycm]: http://valloric.github.io/YouCompleteMe/ + +<!-- +vim:tw=79:sw=4: +--> diff --git a/vim/bundle/syntastic/_assets/screenshot_1.png b/vim/bundle/syntastic/_assets/screenshot_1.png Binary files differnew file mode 100644 index 0000000..c1b69f4 --- /dev/null +++ b/vim/bundle/syntastic/_assets/screenshot_1.png diff --git a/vim/bundle/syntastic/autoload/syntastic/c.vim b/vim/bundle/syntastic/autoload/syntastic/c.vim new file mode 100644 index 0000000..e49a29a --- /dev/null +++ b/vim/bundle/syntastic/autoload/syntastic/c.vim @@ -0,0 +1,341 @@ +if exists('g:loaded_syntastic_c_autoload') || !exists('g:loaded_syntastic_plugin') + finish +endif +let g:loaded_syntastic_c_autoload = 1 + +let s:save_cpo = &cpo +set cpo&vim + +" Public functions {{{1 + +" convenience function to determine the 'null device' parameter +" based on the current operating system +function! syntastic#c#NullOutput() abort " {{{2 + let known_os = has('unix') || has('mac') || syntastic#util#isRunningWindows() + return known_os ? '-o ' . syntastic#util#DevNull() : '' +endfunction " }}}2 + +" read additional compiler flags from the given configuration file +" the file format and its parsing mechanism is inspired by clang_complete +function! syntastic#c#ReadConfig(file) abort " {{{2 + call syntastic#log#debug(g:_SYNTASTIC_DEBUG_CHECKERS, 'ReadConfig: looking for', a:file) + + " search upwards from the current file's directory + let config = syntastic#util#findFileInParent(a:file, expand('%:p:h', 1)) + if config ==# '' + call syntastic#log#debug(g:_SYNTASTIC_DEBUG_CHECKERS, 'ReadConfig: file not found') + return '' + endif + call syntastic#log#debug(g:_SYNTASTIC_DEBUG_CHECKERS, 'ReadConfig: config file:', config) + if !filereadable(config) + call syntastic#log#debug(g:_SYNTASTIC_DEBUG_CHECKERS, 'ReadConfig: file unreadable') + return '' + endif + + " convert filename into absolute path + let filepath = fnamemodify(config, ':p:h') + + " try to read config file + try + let lines = readfile(config) + catch /\m^Vim\%((\a\+)\)\=:E48[45]/ + call syntastic#log#debug(g:_SYNTASTIC_DEBUG_CHECKERS, 'ReadConfig: error reading file') + return '' + endtry + + " filter out empty lines and comments + call filter(lines, 'v:val !~# ''\v^(\s*#|$)''') + + " remove leading and trailing spaces + call map(lines, 'substitute(v:val, ''\m^\s\+'', "", "")') + call map(lines, 'substitute(v:val, ''\m\s\+$'', "", "")') + + let parameters = [] + for line in lines + let matches = matchstr(line, '\m\C^\s*-I\s*\zs.\+') + if matches !=# '' + " this one looks like an absolute path + if match(matches, '\m^\%(/\|\a:\)') != -1 + call add(parameters, '-I' . matches) + else + call add(parameters, '-I' . filepath . syntastic#util#Slash() . matches) + endif + else + call add(parameters, line) + endif + endfor + + return join(map(parameters, 'syntastic#util#shescape(v:val)')) +endfunction " }}}2 + +" GetLocList() for C-like compilers +function! syntastic#c#GetLocList(filetype, subchecker, options) abort " {{{2 + try + let flags = s:_get_cflags(a:filetype, a:subchecker, a:options) + catch /\m\C^Syntastic: skip checks$/ + return [] + endtry + + let makeprg = syntastic#util#shexpand(g:syntastic_{a:filetype}_compiler) . + \ ' ' . flags . ' ' . syntastic#util#shexpand('%') + + let errorformat = s:_get_checker_var('g', a:filetype, a:subchecker, 'errorformat', a:options['errorformat']) + + let postprocess = s:_get_checker_var('g', a:filetype, a:subchecker, 'remove_include_errors', 0) ? + \ ['filterForeignErrors'] : [] + + " process makeprg + return SyntasticMake({ + \ 'makeprg': makeprg, + \ 'errorformat': errorformat, + \ 'postprocess': postprocess }) +endfunction " }}}2 + +" }}}1 + +" Private functions {{{1 + +" initialize c/cpp syntax checker handlers +function! s:_init() abort " {{{2 + let s:handlers = [] + let s:cflags = {} + + call s:_registerHandler('\m\<cairo', 's:_checkPackage', ['cairo', 'cairo']) + call s:_registerHandler('\m\<freetype', 's:_checkPackage', ['freetype', 'freetype2', 'freetype']) + call s:_registerHandler('\m\<glade', 's:_checkPackage', ['glade', 'libglade-2.0', 'libglade']) + call s:_registerHandler('\m\<glib', 's:_checkPackage', ['glib', 'glib-2.0', 'glib']) + call s:_registerHandler('\m\<gtk', 's:_checkPackage', ['gtk', 'gtk+-2.0', 'gtk+', 'glib-2.0', 'glib']) + call s:_registerHandler('\m\<libsoup', 's:_checkPackage', ['libsoup', 'libsoup-2.4', 'libsoup-2.2']) + call s:_registerHandler('\m\<libxml', 's:_checkPackage', ['libxml', 'libxml-2.0', 'libxml']) + call s:_registerHandler('\m\<pango', 's:_checkPackage', ['pango', 'pango']) + call s:_registerHandler('\m\<SDL', 's:_checkPackage', ['sdl', 'sdl']) + call s:_registerHandler('\m\<opengl', 's:_checkPackage', ['opengl', 'gl']) + call s:_registerHandler('\m\<webkit', 's:_checkPackage', ['webkit', 'webkit-1.0']) + + call s:_registerHandler('\m\<php\.h\>', 's:_checkPhp', []) + call s:_registerHandler('\m\<Python\.h\>', 's:_checkPython', []) + call s:_registerHandler('\m\<ruby', 's:_checkRuby', []) +endfunction " }}}2 + +" register a handler dictionary object +function! s:_registerHandler(regex, function, args) abort " {{{2 + let handler = {} + let handler['regex'] = a:regex + let handler['func'] = function(a:function) + let handler['args'] = a:args + call add(s:handlers, handler) +endfunction " }}}2 + +" try to find library with 'pkg-config' +" search possible libraries from first to last given +" argument until one is found +function! s:_checkPackage(name, ...) abort " {{{2 + if executable('pkg-config') + if !has_key(s:cflags, a:name) + for pkg in a:000 + let pkg_flags = syntastic#util#system('pkg-config --cflags ' . pkg) + " since we cannot necessarily trust the pkg-config exit code + " we have to check for an error output as well + if v:shell_error == 0 && pkg_flags !~? 'not found' + let pkg_flags = ' ' . substitute(pkg_flags, "\n", '', '') + let s:cflags[a:name] = pkg_flags + return pkg_flags + endif + endfor + else + return s:cflags[a:name] + endif + endif + return '' +endfunction " }}}2 + +" try to find PHP includes with 'php-config' +function! s:_checkPhp() abort " {{{2 + if executable('php-config') + if !has_key(s:cflags, 'php') + let s:cflags['php'] = syntastic#util#system('php-config --includes') + let s:cflags['php'] = ' ' . substitute(s:cflags['php'], "\n", '', '') + endif + return s:cflags['php'] + endif + return '' +endfunction " }}}2 + +" try to find the python headers with distutils +function! s:_checkPython() abort " {{{2 + if executable('python') + if !has_key(s:cflags, 'python') + let s:cflags['python'] = syntastic#util#system('python -c ''from distutils import ' . + \ 'sysconfig; import sys; sys.stdout.write(sysconfig.get_python_inc())''') + let s:cflags['python'] = substitute(s:cflags['python'], "\n", '', '') + let s:cflags['python'] = ' -I' . s:cflags['python'] + endif + return s:cflags['python'] + endif + return '' +endfunction " }}}2 + +" try to find the ruby headers with 'rbconfig' +function! s:_checkRuby() abort " {{{2 + if executable('ruby') + if !has_key(s:cflags, 'ruby') + let s:cflags['ruby'] = syntastic#util#system('ruby -r rbconfig -e ' . + \ '''puts RbConfig::CONFIG["rubyhdrdir"] || RbConfig::CONFIG["archdir"]''') + let s:cflags['ruby'] = substitute(s:cflags['ruby'], "\n", '', '') + let s:cflags['ruby'] = ' -I' . s:cflags['ruby'] + endif + return s:cflags['ruby'] + endif + return '' +endfunction " }}}2 + +" }}}1 + +" Utilities {{{1 + +" resolve checker-related user variables +function! s:_get_checker_var(scope, filetype, subchecker, name, default) abort " {{{2 + let prefix = a:scope . ':' . 'syntastic_' + if exists(prefix . a:filetype . '_' . a:subchecker . '_' . a:name) + return {a:scope}:syntastic_{a:filetype}_{a:subchecker}_{a:name} + elseif exists(prefix . a:filetype . '_' . a:name) + return {a:scope}:syntastic_{a:filetype}_{a:name} + else + return a:default + endif +endfunction " }}}2 + +" resolve user CFLAGS +function! s:_get_cflags(ft, ck, opts) abort " {{{2 + " determine whether to parse header files as well + if has_key(a:opts, 'header_names') && expand('%', 1) =~? a:opts['header_names'] + if s:_get_checker_var('g', a:ft, a:ck, 'check_header', 0) + let flags = get(a:opts, 'header_flags', '') . ' -c ' . syntastic#c#NullOutput() + else + " checking headers when check_header is unset: bail out + throw 'Syntastic: skip checks' + endif + else + let flags = get(a:opts, 'main_flags', '') + endif + + let flags .= ' ' . s:_get_checker_var('g', a:ft, a:ck, 'compiler_options', '') . ' ' . s:_get_include_dirs(a:ft) + + " check if the user manually set some cflags + let b_cflags = s:_get_checker_var('b', a:ft, a:ck, 'cflags', '') + if b_cflags !=# '' + let flags .= ' ' . b_cflags + endif + + " add optional config file parameters + let config_file = s:_get_checker_var('g', a:ft, a:ck, 'config_file', '.syntastic_' . a:ft . '_config') + let flags .= ' ' . syntastic#c#ReadConfig(config_file) + + if b_cflags ==# '' && (a:ft ==# 'c' || a:ft ==# 'cpp') && !s:_get_checker_var('g', a:ft, a:ck, 'no_include_search', 0) + " refresh the include file search if desired + if s:_get_checker_var('g', a:ft, a:ck, 'auto_refresh_includes', 0) + let flags .= ' ' . s:_search_headers() + else + " search for header includes if not cached already + if !exists('b:syntastic_' . a:ft . '_includes') + let b:syntastic_{a:ft}_includes = s:_search_headers() + endif + let flags .= ' ' . b:syntastic_{a:ft}_includes + endif + endif + + return flags +endfunction " }}}2 + +" get the gcc include directory argument depending on the default +" includes and the optional user-defined 'g:syntastic_c_include_dirs' +function! s:_get_include_dirs(filetype) abort " {{{2 + let include_dirs = [] + + if a:filetype =~# '\v^%(c|cpp|objc|objcpp)$' && + \ (!exists('g:syntastic_'.a:filetype.'_no_default_include_dirs') || + \ !g:syntastic_{a:filetype}_no_default_include_dirs) + let include_dirs = copy(s:default_includes) + endif + + if exists('g:syntastic_'.a:filetype.'_include_dirs') + call extend(include_dirs, g:syntastic_{a:filetype}_include_dirs) + endif + + return join(map(syntastic#util#unique(include_dirs), 'syntastic#util#shescape("-I" . v:val)')) +endfunction " }}}2 + +" search the first 100 lines for include statements that are +" given in the handlers dictionary +function! s:_search_headers() abort " {{{2 + let includes = '' + let files = [] + let found = [] + let lines = filter(getline(1, 100), 'v:val =~# ''\m^\s*#\s*include''') + + " search current buffer + for line in lines + let file = matchstr(line, '\m"\zs\S\+\ze"') + if file !=# '' + call add(files, file) + continue + endif + + for handler in s:handlers + if line =~# handler['regex'] + let includes .= call(handler['func'], handler['args']) + call add(found, handler['regex']) + break + endif + endfor + endfor + + " search included headers + for hfile in files + if hfile !=# '' + let filename = expand('%:p:h', 1) . syntastic#util#Slash() . hfile + + try + let lines = readfile(filename, '', 100) + catch /\m^Vim\%((\a\+)\)\=:E484/ + continue + endtry + + call filter(lines, 'v:val =~# ''\m^\s*#\s*include''') + + for handler in s:handlers + if index(found, handler['regex']) != -1 + continue + endif + + for line in lines + if line =~# handler['regex'] + let includes .= call(handler['func'], handler['args']) + call add(found, handler['regex']) + break + endif + endfor + endfor + endif + endfor + + return includes +endfunction " }}}2 + +" }}}1 + +" default include directories +let s:default_includes = [ + \ '.', + \ '..', + \ 'include', + \ 'includes', + \ '..' . syntastic#util#Slash() . 'include', + \ '..' . syntastic#util#Slash() . 'includes' ] + +call s:_init() + +let &cpo = s:save_cpo +unlet s:save_cpo + +" vim: set sw=4 sts=4 et fdm=marker: diff --git a/vim/bundle/syntastic/autoload/syntastic/log.vim b/vim/bundle/syntastic/autoload/syntastic/log.vim new file mode 100644 index 0000000..5ad562d --- /dev/null +++ b/vim/bundle/syntastic/autoload/syntastic/log.vim @@ -0,0 +1,222 @@ +if exists('g:loaded_syntastic_log_autoload') || !exists('g:loaded_syntastic_plugin') + finish +endif +let g:loaded_syntastic_log_autoload = 1 + +let s:save_cpo = &cpo +set cpo&vim + +let s:one_time_notices_issued = [] + +" Public functions {{{1 + +function! syntastic#log#info(msg) abort " {{{2 + echomsg 'syntastic: info: ' . a:msg +endfunction " }}}2 + +function! syntastic#log#warn(msg) abort " {{{2 + echohl WarningMsg + echomsg 'syntastic: warning: ' . a:msg + echohl None +endfunction " }}}2 + +function! syntastic#log#error(msg) abort " {{{2 + execute "normal \<Esc>" + echohl ErrorMsg + echomsg 'syntastic: error: ' . a:msg + echohl None +endfunction " }}}2 + +function! syntastic#log#oneTimeWarn(msg) abort " {{{2 + if index(s:one_time_notices_issued, a:msg) >= 0 + return + endif + + call add(s:one_time_notices_issued, a:msg) + call syntastic#log#warn(a:msg) +endfunction " }}}2 + +" @vimlint(EVL102, 1, l:OLD_VAR) +function! syntastic#log#deprecationWarn(old, new, ...) abort " {{{2 + if exists('g:syntastic_' . a:old) && !exists('g:syntastic_' . a:new) + let msg = 'variable g:syntastic_' . a:old . ' is deprecated, please use ' + + if a:0 + let OLD_VAR = g:syntastic_{a:old} + try + let NEW_VAR = eval(a:1) + let msg .= 'in its stead: let g:syntastic_' . a:new . ' = ' . string(NEW_VAR) + let g:syntastic_{a:new} = NEW_VAR + catch + let msg .= 'g:syntastic_' . a:new . ' instead' + endtry + else + let msg .= 'g:syntastic_' . a:new . ' instead' + let g:syntastic_{a:new} = g:syntastic_{a:old} + endif + + call syntastic#log#oneTimeWarn(msg) + endif +endfunction " }}}2 +" @vimlint(EVL102, 0, l:OLD_VAR) + +function! syntastic#log#debug(level, msg, ...) abort " {{{2 + if !s:_isDebugEnabled(a:level) + return + endif + + let leader = s:_log_timestamp() + call s:_logRedirect(1) + + if a:0 > 0 + " filter out dictionary functions + echomsg leader . a:msg . ' ' . + \ strtrans(string(type(a:1) == type({}) || type(a:1) == type([]) ? + \ filter(copy(a:1), 'type(v:val) != type(function("tr"))') : a:1)) + else + echomsg leader . a:msg + endif + + call s:_logRedirect(0) +endfunction " }}}2 + +function! syntastic#log#debugShowOptions(level, names) abort " {{{2 + if !s:_isDebugEnabled(a:level) + return + endif + + let leader = s:_log_timestamp() + call s:_logRedirect(1) + + let vlist = copy(type(a:names) == type('') ? [a:names] : a:names) + let add_shell = index(vlist, 'shell') >= 0 && &shell !=# syntastic#util#var('shell') + if !empty(vlist) + call map(vlist, "'&' . v:val . ' = ' . strtrans(string(eval('&' . v:val))) . (s:_is_modified(v:val) ? ' (!)' : '')") + if add_shell + call add(vlist, 'u:shell = ' . strtrans(string(syntastic#util#var('shell'))) . ' (!)') + endif + echomsg leader . join(vlist, ', ') + endif + call s:_logRedirect(0) +endfunction " }}}2 + +function! syntastic#log#debugShowVariables(level, names) abort " {{{2 + if !s:_isDebugEnabled(a:level) + return + endif + + let leader = s:_log_timestamp() + call s:_logRedirect(1) + + let vlist = type(a:names) == type('') ? [a:names] : a:names + for name in vlist + let msg = s:_format_variable(name) + if msg !=# '' + echomsg leader . msg + endif + endfor + + call s:_logRedirect(0) +endfunction " }}}2 + +function! syntastic#log#debugDump(level) abort " {{{2 + if !s:_isDebugEnabled(a:level) + return + endif + + call syntastic#log#debugShowVariables( a:level, sort(keys(g:_SYNTASTIC_DEFAULTS)) ) +endfunction " }}}2 + +function! syntastic#log#ndebug(level, title, messages) abort " {{{2 + if s:_isDebugEnabled(a:level) + return + endif + + call syntastic#log#error(a:title) + if type(a:messages) == type([]) + for msg in a:messages + echomsg msg + endfor + else + echomsg a:messages + endif +endfunction " }}}2 + +" }}}1 + +" Private functions {{{1 + +function! s:_isDebugEnabled_smart(level) abort " {{{2 + return and(g:syntastic_debug, a:level) +endfunction " }}}2 + +function! s:_isDebugEnabled_dumb(level) abort " {{{2 + " poor man's bit test for bit N, assuming a:level == 2**N + return (g:syntastic_debug / a:level) % 2 +endfunction " }}}2 + +let s:_isDebugEnabled = function(exists('*and') ? 's:_isDebugEnabled_smart' : 's:_isDebugEnabled_dumb') +lockvar s:_isDebugEnabled + +function! s:_logRedirect(on) abort " {{{2 + if exists('g:syntastic_debug_file') + if a:on + try + execute 'redir >> ' . fnameescape(expand(g:syntastic_debug_file, 1)) + catch /\m^Vim\%((\a\+)\)\=:/ + silent! redir END + unlet g:syntastic_debug_file + endtry + else + silent! redir END + endif + endif +endfunction " }}}2 + +" }}}1 + +" Utilities {{{1 + +function! s:_log_timestamp_smart() abort " {{{2 + return printf('syntastic: %f: ', reltimefloat(reltime(g:_SYNTASTIC_START))) +endfunction " }}}2 + +function! s:_log_timestamp_dumb() abort " {{{2 + return 'syntastic: ' . split(reltimestr(reltime(g:_SYNTASTIC_START)))[0] . ': ' +endfunction " }}}2 + +let s:_log_timestamp = function(has('float') && exists('*reltimefloat') ? 's:_log_timestamp_smart' : 's:_log_timestamp_dumb') +lockvar s:_log_timestamp + +function! s:_format_variable(name) abort " {{{2 + let vals = [] + if exists('g:syntastic_' . a:name) + call add(vals, 'g:syntastic_' . a:name . ' = ' . strtrans(string(g:syntastic_{a:name}))) + endif + if exists('b:syntastic_' . a:name) + call add(vals, 'b:syntastic_' . a:name . ' = ' . strtrans(string(b:syntastic_{a:name}))) + endif + + return join(vals, ', ') +endfunction " }}}2 + +function! s:_is_modified(name) abort " {{{2 + if !exists('s:option_defaults') + let s:option_defaults = {} + endif + if !has_key(s:option_defaults, a:name) + let opt_save = eval('&' . a:name) + execute 'set ' . a:name . '&' + let s:option_defaults[a:name] = eval('&' . a:name) + execute 'let &' . a:name . ' = ' . string(opt_save) + endif + + return s:option_defaults[a:name] !=# eval('&' . a:name) +endfunction " }}}2 + +" }}}1 + +let &cpo = s:save_cpo +unlet s:save_cpo + +" vim: set sw=4 sts=4 et fdm=marker: diff --git a/vim/bundle/syntastic/autoload/syntastic/postprocess.vim b/vim/bundle/syntastic/autoload/syntastic/postprocess.vim new file mode 100644 index 0000000..136fa58 --- /dev/null +++ b/vim/bundle/syntastic/autoload/syntastic/postprocess.vim @@ -0,0 +1,73 @@ +if exists('g:loaded_syntastic_postprocess_autoload') || !exists('g:loaded_syntastic_plugin') + finish +endif +let g:loaded_syntastic_postprocess_autoload = 1 + +let s:save_cpo = &cpo +set cpo&vim + +" Public functions {{{1 + +" merge consecutive blanks +function! syntastic#postprocess#compressWhitespace(errors) abort " {{{2 + for e in a:errors + let e['text'] = substitute(e['text'], "\001", '', 'g') + let e['text'] = substitute(e['text'], '\n', ' ', 'g') + let e['text'] = substitute(e['text'], '\m\s\{2,}', ' ', 'g') + let e['text'] = substitute(e['text'], '\m^\s\+', '', '') + let e['text'] = substitute(e['text'], '\m\s\+$', '', '') + endfor + + return a:errors +endfunction " }}}2 + +" remove spurious CR under Cygwin +function! syntastic#postprocess#cygwinRemoveCR(errors) abort " {{{2 + if has('win32unix') + for e in a:errors + let e['text'] = substitute(e['text'], '\r', '', 'g') + endfor + endif + + return a:errors +endfunction " }}}2 + +" decode XML entities +function! syntastic#postprocess#decodeXMLEntities(errors) abort " {{{2 + for e in a:errors + let e['text'] = syntastic#util#decodeXMLEntities(e['text']) + endfor + + return a:errors +endfunction " }}}2 + +" filter out errors referencing other files +function! syntastic#postprocess#filterForeignErrors(errors) abort " {{{2 + return filter(copy(a:errors), 'get(v:val, "bufnr") == ' . bufnr('')) +endfunction " }}}2 + +" make sure line numbers are not past end of buffers +" XXX: this loads all referenced buffers in memory +function! syntastic#postprocess#guards(errors) abort " {{{2 + let buffers = syntastic#util#unique(map(filter(copy(a:errors), 'v:val["valid"]'), 'str2nr(v:val["bufnr"])')) + + let guards = {} + for b in buffers + let guards[b] = len(getbufline(b, 1, '$')) + endfor + + for e in a:errors + if e['valid'] && e['lnum'] > guards[e['bufnr']] + let e['lnum'] = guards[e['bufnr']] + endif + endfor + + return a:errors +endfunction " }}}2 + +" }}}1 + +let &cpo = s:save_cpo +unlet s:save_cpo + +" vim: set sw=4 sts=4 et fdm=marker: diff --git a/vim/bundle/syntastic/autoload/syntastic/preprocess.vim b/vim/bundle/syntastic/autoload/syntastic/preprocess.vim new file mode 100644 index 0000000..cbab6fd --- /dev/null +++ b/vim/bundle/syntastic/autoload/syntastic/preprocess.vim @@ -0,0 +1,614 @@ +if exists('g:loaded_syntastic_preprocess_autoload') || !exists('g:loaded_syntastic_plugin') + finish +endif +let g:loaded_syntastic_preprocess_autoload = 1 + +let s:save_cpo = &cpo +set cpo&vim + +" Public functions {{{1 + +function! syntastic#preprocess#cabal(errors) abort " {{{2 + let out = [] + let star = 0 + for err in a:errors + if star + if err ==# '' + let star = 0 + else + let out[-1] .= ' ' . err + endif + else + call add(out, err) + if err =~# '\m^*\s' + let star = 1 + endif + endif + endfor + return out +endfunction " }}}2 + +function! syntastic#preprocess#checkstyle(errors) abort " {{{2 + let out = [] + let fname = expand('%', 1) + for err in a:errors + if match(err, '\m<error\>') > -1 + let line = str2nr(matchstr(err, '\m\<line="\zs\d\+\ze"')) + if line == 0 + continue + endif + + let col = str2nr(matchstr(err, '\m\<column="\zs\d\+\ze"')) + + let type = matchstr(err, '\m\<severity="\zs.\ze') + if type !~? '^[EW]' + let type = 'E' + endif + + let message = syntastic#util#decodeXMLEntities(matchstr(err, '\m\<message="\zs[^"]\+\ze"')) + + call add(out, join([fname, type, line, col, message], ':')) + elseif match(err, '\m<file name="') > -1 + let fname = syntastic#util#decodeXMLEntities(matchstr(err, '\v\<file name\="\zs[^"]+\ze"')) + endif + endfor + return out +endfunction " }}}2 + +function! syntastic#preprocess#cppcheck(errors) abort " {{{2 + return map(copy(a:errors), 'substitute(v:val, ''\v^\[[^]]+\]\zs( -\> \[[^]]+\])+\ze:'', "", "")') +endfunction " }}}2 + +function! syntastic#preprocess#dockerfile_lint(errors) abort " {{{2 + let out = [] + let json = s:_decode_JSON(join(a:errors, '')) + + if type(json) == type({}) + try + let data = json['error']['data'] + json['warn']['data'] + json['info']['data'] + for e in data + let type = toupper(e['level'][0]) + if type ==# 'I' + let type = 'W' + let style = 1 + else + let style = 0 + endif + + let line = get(e, 'line', 1) + let message = e['message'] + if has_key(e, 'description') && e['description'] !=# 'None' + let message = message . '. ' . e['description'] + endif + + let msg = + \ type . ':' . + \ style . ':' . + \ line . ':' . + \ message + call add(out, msg) + endfor + catch /\m^Vim\%((\a\+)\)\=:E716/ + call syntastic#log#warn('checker dockerfile/dockerfile_lint: unrecognized error format') + let out = [] + endtry + else + call syntastic#log#warn('checker dockerfile/dockerfile_lint: unrecognized error format') + endif + return out +endfunction " }}}2 + +function! syntastic#preprocess#flow(errors) abort " {{{2 + let idx = 0 + while idx < len(a:errors) && a:errors[idx][0] !=# '{' + let idx += 1 + endwhile + let errs = s:_decode_JSON(join(a:errors[idx :], '')) + + let out = [] + if type(errs) == type({}) && has_key(errs, 'errors') && type(errs['errors']) == type([]) + for e in errs['errors'] + if type(e) == type({}) && has_key(e, 'message') && type(e['message']) == type([]) && len(e['message']) + let m = e['message'][0] + let t = e['message'][1:] + + try + let msg = + \ m['path'] . ':' . + \ m['line'] . ':' . + \ m['start'] . ':' . + \ (m['line'] ==# m['endline'] && str2nr(m['end']) > 0 ? m['end'] . ':' : '') . + \ ' ' . m['descr'] + + if len(t) + let msg .= ' ' . join(map(t, + \ 'v:val["descr"] . " (" . v:val["path"] . ":" . v:val["line"] . ":" . v:val["start"] . ' . + \ '"," . (v:val["line"] !=# v:val["endline"] ? v:val["endline"] . ":" : "") . ' . + \ 'v:val["end"] . ")"')) + endif + + let msg = substitute(msg, '\r', '', 'g') + let msg = substitute(msg, '\n', ' ', 'g') + + call add(out, msg) + catch /\m^Vim\%((\a\+)\)\=:E716/ + call syntastic#log#warn('checker javascript/flow: unrecognized error format') + let out = [] + break + endtry + else + call syntastic#log#warn('checker javascript/flow: unrecognized error format') + let out = [] + break + endif + endfor + else + call syntastic#log#warn('checker javascript/flow: unrecognized error format') + endif + + return out +endfunction " }}}2 + +function! syntastic#preprocess#iconv(errors) abort " {{{2 + return + \ has('iconv') && &encoding !=# '' && &encoding !=# 'utf-8' ? + \ map(a:errors, 'iconv(v:val, "utf-8", &encoding)') : + \ a:errors +endfunction " }}}2 + +function! syntastic#preprocess#jscs(errors) abort " {{{2 + let errs = join(a:errors, '') + if errs ==# '' + return [] + endif + + let json = s:_decode_JSON(errs) + + let out = [] + if type(json) == type({}) + for fname in keys(json) + if type(json[fname]) == type([]) + for e in json[fname] + try + let e['message'] = substitute(e['message'], "\n", ' ', 'g') + cal add(out, fname . ':' . e['line'] . ':' . e['column'] . ':' . e['message']) + catch /\m^Vim\%((\a\+)\)\=:E716/ + call syntastic#log#warn('checker javascript/jscs: unrecognized error item ' . string(e)) + let out = [] + endtry + endfor + else + call syntastic#log#warn('checker javascript/jscs: unrecognized error format') + endif + endfor + else + call syntastic#log#warn('checker javascript/jscs: unrecognized error format') + endif + return out +endfunction " }}}2 + +function! syntastic#preprocess#killEmpty(errors) abort " {{{2 + return filter(copy(a:errors), 'v:val !=# ""') +endfunction " }}}2 + +function! syntastic#preprocess#perl(errors) abort " {{{2 + let out = [] + + for e in a:errors + let parts = matchlist(e, '\v^(.*)\sat\s(.{-})\sline\s(\d+)(.*)$') + if !empty(parts) + call add(out, parts[2] . ':' . parts[3] . ':' . parts[1] . parts[4]) + endif + endfor + + return syntastic#util#unique(out) +endfunction " }}}2 + +function! syntastic#preprocess#prospector(errors) abort " {{{2 + let errs = s:_decode_JSON(join(a:errors, '')) + + let out = [] + if type(errs) == type({}) && has_key(errs, 'messages') + if type(errs['messages']) == type([]) + for e in errs['messages'] + if type(e) == type({}) + try + if e['source'] ==# 'pylint' + let e['location']['character'] += 1 + endif + + let msg = + \ e['location']['path'] . ':' . + \ e['location']['line'] . ':' . + \ e['location']['character'] . ': ' . + \ e['code'] . ' ' . + \ e['message'] . ' ' . + \ '[' . e['source'] . ']' + + call add(out, msg) + catch /\m^Vim\%((\a\+)\)\=:E716/ + call syntastic#log#warn('checker python/prospector: unrecognized error item ' . string(e)) + let out = [] + break + endtry + else + call syntastic#log#warn('checker python/prospector: unrecognized error item ' . string(e)) + let out = [] + break + endif + endfor + else + call syntastic#log#warn('checker python/prospector: unrecognized error format') + endif + endif + + return out +endfunction " }}}2 + +function! syntastic#preprocess#rparse(errors) abort " {{{2 + let errlist = copy(a:errors) + + " remove uninteresting lines and handle continuations + let i = 0 + while i < len(errlist) + if i > 0 && errlist[i][:1] ==# ' ' && errlist[i] !~# '\m\s\+\^$' + let errlist[i-1] .= errlist[i][1:] + call remove(errlist, i) + elseif errlist[i] !~# '\m^\(Lint:\|Lint checking:\|Error in\) ' + call remove(errlist, i) + else + let i += 1 + endif + endwhile + + let out = [] + let fname = '' + for e in errlist + if match(e, '\m^Lint: ') == 0 + let parts = matchlist(e, '\m^Lint: \(.*\): found on lines \([0-9, ]\+\)\(+\(\d\+\) more\)\=') + if len(parts) >= 3 + for line in split(parts[2], '\m,\s*') + call add(out, 'E:' . fname . ':' . line . ': ' . parts[1]) + endfor + endif + if len(parts) >= 5 && parts[4] !=# '' + call add(out, 'E:' . fname . ':0: ' . parts[1] . ' - ' . parts[4] . ' messages not shown') + endif + elseif match(e, '\m^Lint checking: ') == 0 + let fname = matchstr(e, '\m^Lint checking: \zs.*') + elseif match(e, '\m^Error in ') == 0 + call add(out, substitute(e, '\m^Error in .\+ : .\+\ze:\d\+:\d\+: ', 'E:' . fname, '')) + endif + endfor + + return out +endfunction " }}}2 + +function! syntastic#preprocess#scss_lint(errors) abort " {{{2 + let errs = join(a:errors, '') + if errs ==# '' + return [] + endif + + let json = s:_decode_JSON(errs) + + let out = [] + if type(json) == type({}) + for fname in keys(json) + if type(json[fname]) == type([]) + for e in json[fname] + try + cal add(out, fname . ':' . + \ e['severity'][0] . ':' . + \ e['line'] . ':' . + \ e['column'] . ':' . + \ e['length'] . ':' . + \ ( has_key(e, 'linter') ? e['linter'] . ': ' : '' ) . + \ e['reason']) + catch /\m^Vim\%((\a\+)\)\=:E716/ + call syntastic#log#warn('checker scss/scss_lint: unrecognized error item ' . string(e)) + let out = [] + endtry + endfor + else + call syntastic#log#warn('checker scss/scss_lint: unrecognized error format') + endif + endfor + else + call syntastic#log#warn('checker scss/scss_lint: unrecognized error format') + endif + return out +endfunction " }}}2 + +function! syntastic#preprocess#stylelint(errors) abort " {{{2 + let out = [] + + " CssSyntaxError: /path/to/file.css:2:11: Missed semicolon + let parts = matchlist(a:errors[0], '\v^CssSyntaxError: (.{-1,}):(\d+):(\d+): (.+)') + if len(parts) > 4 + call add(out, 'E:' . join(parts[1:4], ':')) + else + let errs = s:_decode_JSON(join(a:errors, '')) + + let out = [] + if type(errs) == type([]) && len(errs) == 1 && type(errs[0]) == type({}) && + \ has_key(errs[0], 'source') && has_key(errs[0], 'warnings') && type(errs[0]['warnings']) == type([]) + + for e in errs[0]['warnings'] + try + let severity = type(e['severity']) == type(0) ? ['W', 'E'][e['severity']-1] : e['severity'][0] + let msg = + \ severity . ':' . + \ errs[0]['source'] . ':' . + \ e['line'] . ':' . + \ e['column'] . ':' . + \ e['text'] + call add(out, msg) + catch /\m^Vim\%((\a\+)\)\=:E716/ + call syntastic#log#warn('checker css/stylelint: unrecognized error item ' . string(e)) + let out = [] + break + endtry + endfor + else + call syntastic#log#warn('checker css/stylelint: unrecognized error format') + endif + endif + return out +endfunction " }}}2 + +function! syntastic#preprocess#tern_lint(errors) abort " {{{2 + let errs = join(a:errors, '') + let json = s:_decode_JSON(errs) + +echomsg string(json) + let out = [] + if type(json) == type({}) && has_key(json, 'messages') && type(json['messages']) == type([]) + for e in json['messages'] + try + let line_from = byte2line(e['from'] + 1) + if line_from > 0 + let line = line_from + let column = e['from'] - line2byte(line_from) + 2 + let line_to = byte2line(e['from'] + 1) + let hl = line_to == line ? e['to'] - line2byte(line_to) + 1 : 0 + else + let line = 0 + let column = 0 + let hl = 0 + endif + + if column < 0 + let column = 0 + endif + if hl < 0 + let hl = 0 + endif + + call add(out, + \ e['file'] . ':' . + \ e['severity'][0] . ':' . + \ line . ':' . + \ column . ':' . + \ hl . ':' . + \ e['message']) + catch /\m^Vim\%((\a\+)\)\=:E716/ + call syntastic#log#warn('checker javascript/tern_lint: unrecognized error item ' . string(e)) + let out = [] + endtry + endfor + else + call syntastic#log#warn('checker javascript/tern_lint: unrecognized error format') + endif + +echomsg string(out) + return out +endfunction " }}}2 + +function! syntastic#preprocess#tslint(errors) abort " {{{2 + return map(copy(a:errors), 'substitute(v:val, ''\m^\(([^)]\+)\)\s\(.\+\)$'', ''\2 \1'', "")') +endfunction " }}}2 + +function! syntastic#preprocess#validator(errors) abort " {{{2 + let out = [] + for e in a:errors + let parts = matchlist(e, '\v^"([^"]+)"(.+)') + if len(parts) >= 3 + " URL decode, except leave alone any "+" + let parts[1] = substitute(parts[1], '\m%\(\x\x\)', '\=nr2char("0x".submatch(1))', 'g') + let parts[1] = substitute(parts[1], '\m\\"', '"', 'g') + let parts[1] = substitute(parts[1], '\m\\\\', '\\', 'g') + call add(out, '"' . parts[1] . '"' . parts[2]) + endif + endfor + return out +endfunction " }}}2 + +function! syntastic#preprocess#vint(errors) abort " {{{2 + let errs = s:_decode_JSON(join(a:errors, '')) + + let out = [] + if type(errs) == type([]) + for e in errs + if type(e) == type({}) + try + let msg = + \ e['file_path'] . ':' . + \ e['line_number'] . ':' . + \ e['column_number'] . ':' . + \ e['severity'][0] . ': ' . + \ e['description'] . ' (' . + \ e['policy_name'] . ')' + + call add(out, msg) + catch /\m^Vim\%((\a\+)\)\=:E716/ + call syntastic#log#warn('checker vim/vint: unrecognized error item ' . string(e)) + let out = [] + break + endtry + else + call syntastic#log#warn('checker vim/vint: unrecognized error item ' . string(e)) + let out = [] + break + endif + endfor + else + call syntastic#log#warn('checker vim/vint: unrecognized error format') + endif + + return out +endfunction " }}}2 + +" }}}1 + +" Workarounds {{{1 + +" In errorformat, \ or % following %f make it depend on isfname. The default +" setting of isfname is crafted to work with completion, rather than general +" filename matching. The result for syntastic is that filenames containing +" spaces (or a few other special characters) can't be matched. +" +" Fixing isfname to address this problem would depend on the set of legal +" characters for filenames on the filesystem the project's files lives on. +" Inferring the kind of filesystem a file lives on, in advance to parsing the +" file's name, is an interesting problem (think f.i. a file loaded from a VFAT +" partition, mounted on Linux). A problem syntastic is not prepared to solve. +" +" As a result, the functions below exist for the only reason to avoid using +" things like %f\, in errorformat. +" +" References: +" https://groups.google.com/forum/#!topic/vim_dev/pTKmZmouhio +" https://vimhelp.appspot.com/quickfix.txt.html#error-file-format + +function! syntastic#preprocess#basex(errors) abort " {{{2 + let out = [] + let idx = 0 + while idx < len(a:errors) + let parts = matchlist(a:errors[idx], '\v^\[\S+\] Stopped at (.+), (\d+)/(\d+):') + if len(parts) > 3 + let err = parts[1] . ':' . parts[2] . ':' . parts[3] . ':' + let parts = matchlist(a:errors[idx+1], '\v^\[(.)\D+(\d+)\] (.+)') + if len(parts) > 3 + let err .= (parts[1] ==? 'W' || parts[1] ==? 'E' ? parts[1] : 'E') . ':' . parts[2] . ':' . parts[3] + call add(out, err) + let idx +=1 + endif + elseif a:errors[idx] =~# '\m^\[' + " unparseable errors + call add(out, a:errors[idx]) + endif + let idx +=1 + endwhile + return out +endfunction " }}}2 + +function! syntastic#preprocess#bro(errors) abort " {{{2 + let out = [] + for e in a:errors + let parts = matchlist(e, '\v^%(fatal )?(error|warning) in (.{-1,}), line (\d+): (.+)') + if len(parts) > 4 + let parts[1] = parts[1][0] + call add(out, join(parts[1:4], ':')) + endif + endfor + return out +endfunction " }}}2 + +function! syntastic#preprocess#coffeelint(errors) abort " {{{2 + let out = [] + for e in a:errors + let parts = matchlist(e, '\v^(.{-1,}),(\d+)%(,\d*)?,(error|warn),(.+)') + if len(parts) > 4 + let parts[3] = parts[3][0] + call add(out, join(parts[1:4], ':')) + endif + endfor + return out +endfunction " }}}2 + +function! syntastic#preprocess#mypy(errors) abort " {{{2 + let out = [] + for e in a:errors + " new format + let parts = matchlist(e, '\v^(.{-1,}):(\d+): error: (.+)') + if len(parts) > 3 + call add(out, join(parts[1:3], ':')) + continue + endif + + " old format + let parts = matchlist(e, '\v^(.{-1,}), line (\d+): (.+)') + if len(parts) > 3 + call add(out, join(parts[1:3], ':')) + endif + endfor + return out +endfunction " }}}2 + +function! syntastic#preprocess#nix(errors) abort " {{{2 + let out = [] + for e in a:errors + let parts = matchlist(e, '\v^(.{-1,}), at (.{-1,}):(\d+):(\d+)$') + if len(parts) > 4 + call add(out, join(parts[2:4], ':') . ':' . parts[1]) + continue + endif + + let parts = matchlist(e, '\v^(.{-1,}) at (.{-1,}), line (\d+):') + if len(parts) > 3 + call add(out, parts[2] . ':' . parts[3] . ':' . parts[1]) + continue + endif + + let parts = matchlist(e, '\v^error: (.{-1,}), in (.{-1,})$') + if len(parts) > 2 + call add(out, parts[2] . ':' . parts[1]) + endif + endfor + return out +endfunction " }}}2 + +" }}}1 + +" Private functions {{{1 + +" @vimlint(EVL102, 1, l:true) +" @vimlint(EVL102, 1, l:false) +" @vimlint(EVL102, 1, l:null) +function! s:_decode_JSON(json) abort " {{{2 + if a:json ==# '' + return [] + endif + + " The following is inspired by https://github.com/MarcWeber/vim-addon-manager and + " http://stackoverflow.com/questions/17751186/iterating-over-a-string-in-vimscript-or-parse-a-json-file/19105763#19105763 + " A hat tip to Marc Weber for this trick + if substitute(a:json, '\v\"%(\\.|[^"\\])*\"|true|false|null|[+-]?\d+%(\.\d+%([Ee][+-]?\d+)?)?', '', 'g') !~# "[^,:{}[\\] \t]" + " JSON artifacts + let true = 1 + let false = 0 + let null = '' + + try + let object = eval(a:json) + catch + " malformed JSON + let object = '' + endtry + else + let object = '' + endif + + return object +endfunction " }}}2 +" @vimlint(EVL102, 0, l:true) +" @vimlint(EVL102, 0, l:false) +" @vimlint(EVL102, 0, l:null) + +" }}}1 + +let &cpo = s:save_cpo +unlet s:save_cpo + +" vim: set sw=4 sts=4 et fdm=marker: diff --git a/vim/bundle/syntastic/autoload/syntastic/util.vim b/vim/bundle/syntastic/autoload/syntastic/util.vim new file mode 100644 index 0000000..68eb06e --- /dev/null +++ b/vim/bundle/syntastic/autoload/syntastic/util.vim @@ -0,0 +1,552 @@ +if exists('g:loaded_syntastic_util_autoload') || !exists('g:loaded_syntastic_plugin') + finish +endif +let g:loaded_syntastic_util_autoload = 1 + +let s:save_cpo = &cpo +set cpo&vim + +" Public functions {{{1 + +function! syntastic#util#isRunningWindows() abort " {{{2 + return has('win16') || has('win32') || has('win64') +endfunction " }}}2 + +function! syntastic#util#DevNull() abort " {{{2 + if syntastic#util#isRunningWindows() + return 'NUL' + endif + return '/dev/null' +endfunction " }}}2 + +" Get directory separator +function! syntastic#util#Slash() abort " {{{2 + return (!exists('+shellslash') || &shellslash) ? '/' : '\' +endfunction " }}}2 + +function! syntastic#util#CygwinPath(path) abort " {{{2 + return substitute(syntastic#util#system('cygpath -m ' . syntastic#util#shescape(a:path)), "\n", '', 'g') +endfunction " }}}2 + +function! syntastic#util#system(command) abort " {{{2 + let old_shell = &shell + let old_lc_messages = $LC_MESSAGES + let old_lc_all = $LC_ALL + + let &shell = syntastic#util#var('shell') + let $LC_MESSAGES = 'C' + let $LC_ALL = '' + + let cmd_start = reltime() + let out = system(a:command) + let cmd_time = split(reltimestr(reltime(cmd_start)))[0] + + let $LC_ALL = old_lc_all + let $LC_MESSAGES = old_lc_messages + + let &shell = old_shell + + if exists('g:_SYNTASTIC_DEBUG_TRACE') + call syntastic#log#debug(g:_SYNTASTIC_DEBUG_TRACE, 'system: command run in ' . cmd_time . 's') + endif + + return out +endfunction " }}}2 + +" Create a temporary directory +function! syntastic#util#tmpdir() abort " {{{2 + let tempdir = '' + + if (has('unix') || has('mac')) && executable('mktemp') && !has('win32unix') + " TODO: option "-t" to mktemp(1) is not portable + let tmp = $TMPDIR !=# '' ? $TMPDIR : $TMP !=# '' ? $TMP : '/tmp' + let out = split(syntastic#util#system('mktemp -q -d ' . tmp . '/vim-syntastic-' . getpid() . '-XXXXXXXX'), "\n") + if v:shell_error == 0 && len(out) == 1 + let tempdir = out[0] + endif + endif + + if tempdir ==# '' + if has('win32') || has('win64') + let tempdir = $TEMP . syntastic#util#Slash() . 'vim-syntastic-' . getpid() + elseif has('win32unix') + let tempdir = syntastic#util#CygwinPath('/tmp/vim-syntastic-' . getpid()) + elseif $TMPDIR !=# '' + let tempdir = $TMPDIR . '/vim-syntastic-' . getpid() + else + let tempdir = '/tmp/vim-syntastic-' . getpid() + endif + + try + call mkdir(tempdir, 'p', 0700) + catch /\m^Vim\%((\a\+)\)\=:E739/ + call syntastic#log#error(v:exception) + let tempdir = '.' + endtry + endif + + return tempdir +endfunction " }}}2 + +" Recursively remove a directory +function! syntastic#util#rmrf(what) abort " {{{2 + " try to make sure we don't delete directories we didn't create + if a:what !~? 'vim-syntastic-' + return + endif + + if getftype(a:what) ==# 'dir' + call s:_delete(a:what, 'rf') + else + silent! call delete(a:what) + endif +endfunction " }}}2 + +" Search the first 5 lines of the file for a magic number and return a map +" containing the args and the executable +" +" e.g. +" +" #!/usr/bin/perl -f -bar +" +" returns +" +" {'exe': '/usr/bin/perl', 'args': ['-f', '-bar']} +function! syntastic#util#parseShebang() abort " {{{2 + for lnum in range(1, 5) + let line = getline(lnum) + if line =~# '^#!' + let line = substitute(line, '\v^#!\s*(\S+/env(\s+-\S+)*\s+)?', '', '') + let exe = matchstr(line, '\m^\S*\ze') + let args = split(matchstr(line, '\m^\S*\zs.*')) + return { 'exe': exe, 'args': args } + endif + endfor + + return { 'exe': '', 'args': [] } +endfunction " }}}2 + +" Get the value of a Vim variable. Allow local variables to override global ones. +function! syntastic#util#rawVar(name, ...) abort " {{{2 + return get(b:, a:name, get(g:, a:name, a:0 > 0 ? a:1 : '')) +endfunction " }}}2 + +" Get the value of a syntastic variable. Allow local variables to override global ones. +function! syntastic#util#var(name, ...) abort " {{{2 + return call('syntastic#util#rawVar', ['syntastic_' . a:name] + a:000) +endfunction " }}}2 + +" Parse a version string. Return an array of version components. +function! syntastic#util#parseVersion(version, ...) abort " {{{2 + return map(split(matchstr( a:version, a:0 ? a:1 : '\v^\D*\zs\d+(\.\d+)+\ze' ), '\m\.'), 'str2nr(v:val)') +endfunction " }}}2 + +" Verify that the 'installed' version is at least the 'required' version. +" +" 'installed' and 'required' must be arrays. If they have different lengths, +" the "missing" elements will be assumed to be 0 for the purposes of checking. +" +" See http://semver.org for info about version numbers. +function! syntastic#util#versionIsAtLeast(installed, required) abort " {{{2 + return syntastic#util#compareLexi(a:installed, a:required) >= 0 +endfunction " }}}2 + +" Almost lexicographic comparison of two lists of integers. :) If lists +" have different lengths, the "missing" elements are assumed to be 0. +function! syntastic#util#compareLexi(a, b) abort " {{{2 + for idx in range(max([len(a:a), len(a:b)])) + let a_element = str2nr(get(a:a, idx, 0)) + let b_element = str2nr(get(a:b, idx, 0)) + if a_element != b_element + return a_element > b_element ? 1 : -1 + endif + endfor + " still here, thus everything matched + return 0 +endfunction " }}}2 + +" strwidth() was added in Vim 7.3; if it doesn't exist, we use strlen() +" and hope for the best :) +let s:_width = function(exists('*strwidth') ? 'strwidth' : 'strlen') +lockvar s:_width + +function! syntastic#util#screenWidth(str, tabstop) abort " {{{2 + let chunks = split(a:str, "\t", 1) + let width = s:_width(chunks[-1]) + for c in chunks[:-2] + let cwidth = s:_width(c) + let width += cwidth + a:tabstop - cwidth % a:tabstop + endfor + return width +endfunction " }}}2 + +" Print as much of a:msg as possible without "Press Enter" prompt appearing +function! syntastic#util#wideMsg(msg) abort " {{{2 + let old_ruler = &ruler + let old_showcmd = &showcmd + + "This is here because it is possible for some error messages to + "begin with \n which will cause a "press enter" prompt. + let msg = substitute(a:msg, "\n", '', 'g') + + "convert tabs to spaces so that the tabs count towards the window + "width as the proper amount of characters + let chunks = split(msg, "\t", 1) + let msg = join(map(chunks[:-2], 'v:val . repeat(" ", &tabstop - s:_width(v:val) % &tabstop)'), '') . chunks[-1] + let msg = strpart(msg, 0, &columns - 1) + + set noruler noshowcmd + call syntastic#util#redraw(0) + + echo msg + + let &ruler = old_ruler + let &showcmd = old_showcmd +endfunction " }}}2 + +" Check whether a buffer is loaded, listed, and not hidden +function! syntastic#util#bufIsActive(buffer) abort " {{{2 + " convert to number, or hell breaks loose + let buf = str2nr(a:buffer) + + if !bufloaded(buf) || !buflisted(buf) + return 0 + endif + + " get rid of hidden buffers + for tab in range(1, tabpagenr('$')) + if index(tabpagebuflist(tab), buf) >= 0 + return 1 + endif + endfor + + return 0 +endfunction " }}}2 + +" Start in directory a:where and walk up the parent folders until it finds a +" file named a:what; return path to that file +function! syntastic#util#findFileInParent(what, where) abort " {{{2 + let old_suffixesadd = &suffixesadd + let &suffixesadd = '' + let file = findfile(a:what, escape(a:where, ' ') . ';') + let &suffixesadd = old_suffixesadd + return file +endfunction " }}}2 + +" Start in directory a:where and walk up the parent folders until it finds a +" file matching a:what; return path to that file +function! syntastic#util#findGlobInParent(what, where) abort " {{{2 + let here = fnamemodify(a:where, ':p') + + let root = syntastic#util#Slash() + if syntastic#util#isRunningWindows() && here[1] ==# ':' + " The drive letter is an ever-green source of fun. That's because + " we don't care about running syntastic on Amiga these days. ;) + let root = fnamemodify(root, ':p') + let root = here[0] . root[1:] + endif + + let old = '' + while here !=# '' + try + " Vim 7.4.279 and later + let p = globpath(here, a:what, 1, 1) + catch /\m^Vim\%((\a\+)\)\=:E118/ + let p = split(globpath(here, a:what, 1), "\n") + endtry + + if !empty(p) + return fnamemodify(p[0], ':p') + elseif here ==? root || here ==? old + break + endif + + let old = here + + " we use ':h:h' rather than ':h' since ':p' adds a trailing '/' + " if 'here' is a directory + let here = fnamemodify(here, ':p:h:h') + endwhile + + return '' +endfunction " }}}2 + +" Returns unique elements in a list +function! syntastic#util#unique(list) abort " {{{2 + let seen = {} + let uniques = [] + for e in a:list + let k = string(e) + if !has_key(seen, k) + let seen[k] = 1 + call add(uniques, e) + endif + endfor + return uniques +endfunction " }}}2 + +" A less noisy shellescape() +function! syntastic#util#shescape(string) abort " {{{2 + return a:string =~# '\m^[A-Za-z0-9_/.-]\+$' ? a:string : shellescape(a:string) +endfunction " }}}2 + +" A less noisy shellescape(expand()) +function! syntastic#util#shexpand(string, ...) abort " {{{2 + return syntastic#util#shescape(a:0 ? expand(a:string, a:1) : expand(a:string, 1)) +endfunction " }}}2 + +" Escape arguments +function! syntastic#util#argsescape(opt) abort " {{{2 + if type(a:opt) == type('') && a:opt !=# '' + return [a:opt] + elseif type(a:opt) == type([]) + return map(copy(a:opt), 'syntastic#util#shescape(v:val)') + endif + + return [] +endfunction " }}}2 + +" Decode XML entities +function! syntastic#util#decodeXMLEntities(string) abort " {{{2 + let str = a:string + let str = substitute(str, '\m<', '<', 'g') + let str = substitute(str, '\m>', '>', 'g') + let str = substitute(str, '\m"', '"', 'g') + let str = substitute(str, '\m'', "'", 'g') + let str = substitute(str, '\m&', '\&', 'g') + return str +endfunction " }}}2 + +function! syntastic#util#redraw(full) abort " {{{2 + if a:full + redraw! + else + redraw + endif +endfunction " }}}2 + +function! syntastic#util#dictFilter(errors, filter) abort " {{{2 + let rules = s:_translateFilter(a:filter) + " call syntastic#log#debug(g:_SYNTASTIC_DEBUG_TRACE, "applying filter:", rules) + try + call filter(a:errors, rules) + catch /\m^Vim\%((\a\+)\)\=:E/ + let msg = matchstr(v:exception, '\m^Vim\%((\a\+)\)\=:\zs.*') + call syntastic#log#error('quiet_messages: ' . msg) + endtry +endfunction " }}}2 + +" Return a [seconds, fractions] list of strings, representing the +" (hopefully high resolution) time since program start +function! syntastic#util#stamp() abort " {{{2 + return split( split(reltimestr(reltime(g:_SYNTASTIC_START)))[0], '\.' ) +endfunction " }}}2 + +function! syntastic#util#setChangedtick() abort " {{{2 + unlockvar! b:syntastic_changedtick + let b:syntastic_changedtick = b:changedtick + lockvar! b:syntastic_changedtick +endfunction " }}}2 + +let s:_wid_base = 'syntastic_' . getpid() . '_' . reltimestr(g:_SYNTASTIC_START) . '_' +let s:_wid_pool = 0 + +" Add unique IDs to windows +function! syntastic#util#setWids() abort " {{{2 + for tab in range(1, tabpagenr('$')) + for win in range(1, tabpagewinnr(tab, '$')) + if gettabwinvar(tab, win, 'syntastic_wid') ==# '' + call settabwinvar(tab, win, 'syntastic_wid', s:_wid_base . s:_wid_pool) + let s:_wid_pool += 1 + endif + endfor + endfor +endfunction " }}}2 + +let s:_str2float = function(exists('*str2float') ? 'str2float' : 'str2nr') +lockvar s:_str2float + +function! syntastic#util#str2float(val) abort " {{{2 + return s:_str2float(a:val) +endfunction " }}}2 + +function! syntastic#util#float2str(val) abort " {{{2 + return s:_float2str(a:val) +endfunction " }}}2 + +" Crude printf()-like width formatter. Handles wide characters. +function! syntastic#util#wformat(format, str) abort " {{{2 + if a:format ==# '' + return a:str + endif + + echomsg string(a:format) . ', ' . string(a:str) + let specs = matchlist(a:format, '\v^(-?)(0?)(%([1-9]\d*))?%(\.(\d+))?$') + if len(specs) < 5 + return a:str + endif + + let flushleft = specs[1] ==# '-' + let lpad = specs[2] ==# '0' ? '0' : ' ' + let minlen = str2nr(specs[3]) + let maxlen = str2nr(specs[4]) + let out = substitute(a:str, "\t", ' ', 'g') + + if maxlen && s:_width(out) > maxlen + let chars = filter(split(out, '\zs\ze', 1), 'v:val !=# ""') + let out = '' + + if flushleft + for c in chars + if s:_width(out . c) < maxlen + let out .= c + else + let out .= &encoding ==# 'utf-8' && &termencoding ==# 'utf-8' ? "\u2026" : '>' + break + endif + endfor + else + call reverse(chars) + for c in chars + if s:_width(c . out) < maxlen + let out = c . out + else + let out = (&encoding ==# 'utf-8' && &termencoding ==# 'utf-8' ? "\u2026" : '<') . out + break + endif + endfor + endif + endif + + if minlen && s:_width(out) < minlen + if flushleft + let out .= repeat(' ', minlen - s:_width(out)) + else + let out = repeat(lpad, minlen - s:_width(out)) . out + endif + endif + + return out +endfunction " }}}2 + +" }}}1 + +" Private functions {{{1 + +function! s:_translateFilter(filters) abort " {{{2 + let conditions = [] + for k in keys(a:filters) + if type(a:filters[k]) == type([]) + call extend(conditions, map(copy(a:filters[k]), 's:_translateElement(k, v:val)')) + else + call add(conditions, s:_translateElement(k, a:filters[k])) + endif + endfor + + if conditions == [] + let conditions = ['1'] + endif + return len(conditions) == 1 ? conditions[0] : join(map(conditions, '"(" . v:val . ")"'), ' && ') +endfunction " }}}2 + +function! s:_translateElement(key, term) abort " {{{2 + let fkey = a:key + if fkey[0] ==# '!' + let fkey = fkey[1:] + let not = 1 + else + let not = 0 + endif + + if fkey ==? 'level' + let op = not ? ' ==? ' : ' !=? ' + let ret = 'v:val["type"]' . op . string(a:term[0]) + elseif fkey ==? 'type' + if a:term ==? 'style' + let op = not ? ' ==? ' : ' !=? ' + let ret = 'get(v:val, "subtype", "")' . op . '"style"' + else + let op = not ? '!' : '' + let ret = op . 'has_key(v:val, "subtype")' + endif + elseif fkey ==? 'regex' + let op = not ? ' =~? ' : ' !~? ' + let ret = 'v:val["text"]' . op . string(a:term) + elseif fkey ==? 'file' || fkey[:4] ==? 'file:' + let op = not ? ' =~# ' : ' !~# ' + let ret = 'bufname(str2nr(v:val["bufnr"]))' + let mod = fkey[4:] + if mod !=# '' + let ret = 'fnamemodify(' . ret . ', ' . string(mod) . ')' + endif + let ret .= op . string(a:term) + else + call syntastic#log#warn('quiet_messages: ignoring invalid key ' . strtrans(string(fkey))) + let ret = '1' + endif + return ret +endfunction " }}}2 + +" @vimlint(EVL103, 1, a:flags) +function! s:_delete_dumb(what, flags) abort " {{{2 + if !exists('s:rmrf') + let s:rmrf = + \ has('unix') || has('mac') ? 'rm -rf' : + \ has('win32') || has('win64') ? 'rmdir /S /Q' : + \ has('win16') || has('win95') || has('dos16') || has('dos32') ? 'deltree /Y' : '' + endif + + if s:rmrf !=# '' + silent! call syntastic#util#system(s:rmrf . ' ' . syntastic#util#shescape(a:what)) + else + call s:_rmrf(a:what) + endif +endfunction " }}}2 +" @vimlint(EVL103, 0, a:flags) + +" delete(dir, 'rf') was added in Vim 7.4.1107, but it didn't become usable until 7.4.1128 +let s:_delete = function(v:version > 704 || (v:version == 704 && has('patch1128')) ? 'delete' : 's:_delete_dumb') +lockvar s:_delete + +function! s:_rmrf(what) abort " {{{2 + if !exists('s:rmdir') + let s:rmdir = syntastic#util#shescape(get(g:, 'netrw_localrmdir', 'rmdir')) + endif + + if getftype(a:what) ==# 'dir' + if filewritable(a:what) != 2 + return + endif + + try + " Vim 7.4.279 and later + let entries = globpath(a:what, '*', 1, 1) + catch /\m^Vim\%((\a\+)\)\=:E118/ + let entries = split(globpath(a:what, '*', 1), "\n") + endtry + for f in entries + call s:_rmrf(f) + endfor + silent! call syntastic#util#system(s:rmdir . ' ' . syntastic#util#shescape(a:what)) + else + silent! call delete(a:what) + endif +endfunction " }}}2 + +function! s:_float2str_smart(val) abort " {{{2 + return printf('%.1f', a:val) +endfunction " }}}2 + +function! s:_float2str_dumb(val) abort " {{{2 + return a:val +endfunction " }}}2 + +let s:_float2str = function(has('float') ? 's:_float2str_smart' : 's:_float2str_dumb') +lockvar s:_float2str + +" }}}1 + +let &cpo = s:save_cpo +unlet s:save_cpo + +" vim: set sw=4 sts=4 et fdm=marker: diff --git a/vim/bundle/syntastic/doc/syntastic-checkers.txt b/vim/bundle/syntastic/doc/syntastic-checkers.txt new file mode 100644 index 0000000..4794849 --- /dev/null +++ b/vim/bundle/syntastic/doc/syntastic-checkers.txt @@ -0,0 +1,6931 @@ +*syntastic-checkers.txt* Syntastic checkers +*syntastic-checkers* + +============================================================================== +SYNTAX CHECKERS BY LANGUAGE *syntastic-checkers-lang* + +|syntastic| comes with checkers for the following languages: + + ActionScript.............................|syntastic-checkers-actionscript| + Ada......................................|syntastic-checkers-ada| + Ansible..................................|syntastic-checkers-ansible| + API Blueprint............................|syntastic-checkers-apiblueprint| + AppleScript..............................|syntastic-checkers-applescript| + AsciiDoc.................................|syntastic-checkers-asciidoc| + Assembly Languages.......................|syntastic-checkers-asm| + + BEMHTML..................................|syntastic-checkers-bemhtml| + Bro......................................|syntastic-checkers-bro| + + C........................................|syntastic-checkers-c| + C#.......................................|syntastic-checkers-cs| + C++......................................|syntastic-checkers-cpp| + Cabal....................................|syntastic-checkers-cabal| + Chef.....................................|syntastic-checkers-chef| + COBOL....................................|syntastic-checkers-cobol| + Coco.....................................|syntastic-checkers-co| + CoffeeScript.............................|syntastic-checkers-coffee| + Coq......................................|syntastic-checkers-coq| + CSS......................................|syntastic-checkers-css| + Cucumber.................................|syntastic-checkers-cucumber| + CUDA.....................................|syntastic-checkers-cuda| + + D........................................|syntastic-checkers-d| + Dart.....................................|syntastic-checkers-dart| + DocBook..................................|syntastic-checkers-docbk| + Dockerfile...............................|syntastic-checkers-dockerfile| + Dust.....................................|syntastic-checkers-dustjs| + + Elixir...................................|syntastic-checkers-elixir| + Erlang...................................|syntastic-checkers-erlang| + eRuby....................................|syntastic-checkers-eruby| + + Fortran..................................|syntastic-checkers-fortran| + + Gentoo Metadata..........................|syntastic-checkers-gentoo| + Gettext PO...............................|syntastic-checkers-po| + GLSL.....................................|syntastic-checkers-glsl| + Go.......................................|syntastic-checkers-go| + + Haml.....................................|syntastic-checkers-haml| + Handlebars...............................|syntastic-checkers-handlebars| + Haskell..................................|syntastic-checkers-haskell| + Haxe.....................................|syntastic-checkers-haxe| + HSS......................................|syntastic-checkers-hss| + HTML.....................................|syntastic-checkers-html| + + Java.....................................|syntastic-checkers-java| + JavaScript...............................|syntastic-checkers-javascript| + JSON.....................................|syntastic-checkers-json| + + LESS.....................................|syntastic-checkers-less| + Lex......................................|syntastic-checkers-lex| + Limbo....................................|syntastic-checkers-limbo| + LISP.....................................|syntastic-checkers-lisp| + LLVM.....................................|syntastic-checkers-llvm| + Lua......................................|syntastic-checkers-lua| + + Markdown.................................|syntastic-checkers-markdown| + MATLAB...................................|syntastic-checkers-matlab| + Mercury..................................|syntastic-checkers-mercury| + + NASM.....................................|syntastic-checkers-nasm| + Nix......................................|syntastic-checkers-nix| + nroff....................................|syntastic-checkers-nroff| + + Objective-C..............................|syntastic-checkers-objc| + Objective-C++............................|syntastic-checkers-objcpp| + OCaml....................................|syntastic-checkers-ocaml| + + Perl.....................................|syntastic-checkers-perl| + PHP......................................|syntastic-checkers-php| + POD......................................|syntastic-checkers-pod| + Pug (formerly Jade)......................|syntastic-checkers-pug| + Puppet...................................|syntastic-checkers-puppet| + Python...................................|syntastic-checkers-python| + + QML......................................|syntastic-checkers-qml| + + R........................................|syntastic-checkers-r| + R Markdown...............................|syntastic-checkers-rmd| + Racket...................................|syntastic-checkers-racket| + Relax NG.................................|syntastic-checkers-rnc| + reStructuredText.........................|syntastic-checkers-rst| + RPM spec.................................|syntastic-checkers-spec| + Ruby.....................................|syntastic-checkers-ruby| + + SASS.....................................|syntastic-checkers-sass| + Scala....................................|syntastic-checkers-scala| + SCSS.....................................|syntastic-checkers-scss| + Sh.......................................|syntastic-checkers-sh| + Slim.....................................|syntastic-checkers-slim| + SML......................................|syntastic-checkers-sml| + SQL......................................|syntastic-checkers-sql| + Stylus...................................|syntastic-checkers-stylus| + + Tcl......................................|syntastic-checkers-tcl| + TeX......................................|syntastic-checkers-tex| + Texinfo..................................|syntastic-checkers-texinfo| + Text.....................................|syntastic-checkers-text| + Turtle...................................|syntastic-checkers-turtle| + TriG.....................................|syntastic-checkers-trig| + Twig.....................................|syntastic-checkers-twig| + TypeScript...............................|syntastic-checkers-typescript| + + Vala.....................................|syntastic-checkers-vala| + Verilog..................................|syntastic-checkers-verilog| + VHDL.....................................|syntastic-checkers-vhdl| + VimL.....................................|syntastic-checkers-vim| + + xHTML....................................|syntastic-checkers-xhtml| + XML......................................|syntastic-checkers-xml| + XQuery...................................|syntastic-checkers-xquery| + XSLT.....................................|syntastic-checkers-xslt| + + YACC.....................................|syntastic-checkers-yacc| + YAML.....................................|syntastic-checkers-yaml| + YANG.....................................|syntastic-checkers-yang| + + Z80......................................|syntastic-checkers-z80| + Zope Page Templates......................|syntastic-checkers-zpt| + Zsh......................................|syntastic-checkers-zsh| + +Third-party checkers are available for additional languages. + +============================================================================== +SYNTAX CHECKERS FOR ACTIONSCRIPT *syntastic-checkers-actionscript* + +The following checkers are available for ActionScript (filetype +"actionscript"): + + 1. mxmlc....................|syntastic-actionscript-mxmlc| + +------------------------------------------------------------------------------ +1. mxmlc *syntastic-actionscript-mxmlc* + +Name: mxmlc +Maintainer: Andy Earnshaw <andyearnshaw@gmail.com> + +"mxmlc" is a compiler for ActionScript. See Apache Flex for details: + + http://flex.apache.org/ + +Checker options~ + +This checker is initialised using the "makeprgBuild()" function and thus it +accepts the standard options described at |syntastic-config-makeprg|. + +============================================================================== +SYNTAX CHECKERS FOR ADA *syntastic-checkers-ada* + +The following checkers are available for Ada (filetype "ada"): + + 1. GCC......................|syntastic-ada-gcc| + +------------------------------------------------------------------------------ +1. GCC *syntastic-ada-gcc* + +Name: gcc +Maintainer: Alfredo Di Napoli <alfredo.dinapoli@gmail.com> + +Checker options~ + *'g:syntastic_ada_compiler'* +Type: string +Default: "gcc" +Compiler executable. + + *'g:syntastic_ada_errorformat'* +Type: string +Default: unset +Override for the default |'errorformat'|. + + *'g:syntastic_ada_remove_include_errors'* +Type: boolean +Default: 0 +By default, errors in files included from the file being checked are shown. +Set this variable to 1 to remove messages about errors in included files. +Please note that this means syntastic will silently abort checks if there are +fatal errors in one of the included files. + + *'g:syntastic_ada_compiler_options'* +Type: string +Default: unset +Compilation flags (such as defines or include directories) to be passed to the +checker. + + *'g:syntastic_ada_config_file'* +Type: string +Default: ".syntastic_ada_config" +File containing additional compilation flags to be passed to the checker, one +option per line (cf. |syntastic-config-files|). + + *'g:syntastic_ada_include_dirs'* +Type: array of strings +Default: [] +Include directories to be passed to the checker, in addition to the above +compilation flags. You can set it like this: > + let g:syntastic_ada_include_dirs = ["includes", "headers"] +< +and the corresponding "-Iincludes -Iheaders" will be added to the compilation +flags. + + *'b:syntastic_ada_cflags'* +Type: string +Default: unset +Buffer-local variable. Additional compilation flags specific to the current +buffer. + + *'g:syntastic_ada_check_header'* +Type: boolean +Default: 0 +If the current file is a header (namely if its extension is "ads"), all checks +are silently skipped. You can force syntastic to check header files by +setting the above variable to 1. + +Note~ + +This checker doesn't call the "makeprgBuild()" function, and thus it ignores +the usual 'g:syntastic_ada_gcc_<option>' variables. The only exception is +'g:syntastic_ada_gcc_exec', which can still be used to override the checker's +executable. + +============================================================================== +SYNTAX CHECKERS FOR ANSIBLE *syntastic-checkers-ansible* + +The following checkers are available for Ansible (filetype "ansible"): + + 1. Ansible-lint.............|syntastic-ansible-ansible_lint| + +------------------------------------------------------------------------------ +1. Ansible-lint *syntastic-ansible-ansible_lint* + +Name: ansible_lint +Maintainer: Erik Zaadi <erik.zaadi@gmail.com> + +"Ansible-lint" is a style checker for Ansible playbooks. See the project's +page at GitHub for details: + + https://github.com/willthames/ansible-lint + +Syntastic requires "Ansible-lint" version 2.0.4 or later. + +Checker options~ + +This checker is initialised using the "makeprgBuild()" function and thus it +accepts the standard options described at |syntastic-config-makeprg|. + +Note~ + +You probably also need a plugin to set |filetype| for Ansible playbooks, such +as "ansible-vim": + + https://github.com/pearofducks/ansible-vim + +============================================================================== +SYNTAX CHECKERS FOR API BLUEPRINT *syntastic-checkers-apiblueprint* + +The following checkers are available for API Blueprint (filetype "apiblueprint"): + + 1. Drafter..................|syntastic-apiblueprint-drafter| + +------------------------------------------------------------------------------ +1. Drafter *syntastic-apiblueprint-drafter* + +Name: drafter +Maintainer: LCD 47 <lcd047@gmail.com> + +"Drafter" is a parser for Apiary's "API Blueprint" (http://apiblueprint.org/). +See the project's page at GitHub for details: + + https://github.com/apiaryio/drafter + +Checker options~ + +This checker is initialised using the "makeprgBuild()" function and thus it +accepts the standard options described at |syntastic-config-makeprg|. + +Note~ + +You probably also need a plugin to set |filetype| for API Blueprint files, such +as "apiblueprint.vim": + + https://github.com/kylef/apiblueprint.vim + +============================================================================== +SYNTAX CHECKERS FOR APPLESCRIPT *syntastic-checkers-applescript* + +The following checkers are available for AppleScript (filetype "applescript"): + + 1. osacompile...............|syntastic-applescript-osacompile| + +------------------------------------------------------------------------------ +1. osacompile *syntastic-applescript-osacompile* + +Name: osacompile +Author: Zhao Cai <caizhaoff@gmail.com> + +"osacompile" is a compiler for "AppleScript". See the program's manual for +details: + + https://developer.apple.com/library/mac/documentation/Darwin/Reference/ManPages/man1/osacompile.1.html + +Checker options~ + +This checker is initialised using the "makeprgBuild()" function and thus it +accepts the standard options described at |syntastic-config-makeprg|. + +============================================================================== +SYNTAX CHECKERS FOR ASCIIDOC *syntastic-checkers-asciidoc* + +The following checkers are available for AsciiDoc (filetype "asciidoc"): + + 1. Asciidoc.................|syntastic-asciidoc-asciidoc| + +------------------------------------------------------------------------------ +1. Asciidoc *syntastic-asciidoc-asciidoc* + +Name: asciidoc +Maintainer: LCD 47 <lcd047@gmail.com> + +"Asciidoc" is a translator for AsciiDoc documents (http://asciidoc.org/). + +Note~ + +If you would prefer to use Asciidoctor (http://asciidoctor.org/) as an +external checker instead of "Asciidoc", you can do that by pointing +'g:syntastic_asciidoc_asciidoc_exec' to it: > + let g:syntastic_asciidoc_asciidoc_exec = "asciidoctor" +< +Checker options~ + +This checker is initialised using the "makeprgBuild()" function and thus it +accepts the standard options described at |syntastic-config-makeprg|. + +============================================================================== +SYNTAX CHECKERS FOR ASSEMBLY LANGUAGES *syntastic-checkers-asm* + +The following checkers are available for asembly languages (filetype "asm"): + + 1. GCC......................|syntastic-asm-gcc| + +------------------------------------------------------------------------------ +1. GCC *syntastic-asm-gcc* + +Name: gcc +Maintainer: Joshua Rahm <joshuarahm@gmail.com> + +This plugin supports both the AT&T and Intel dialects. + +Checker Options~ + *'g:syntastic_asm_compiler'* +Type: string +Default: "gcc" +Compiler executable. Set it to something like "mipsel-linux-gcc": > + let g:syntastic_asm_compiler = "mipsel-linux-gcc" +< + *'g:syntastic_asm_errorformat'* +Type: string +Default: unset +Override for the default |'errorformat'|. + + *'g:syntastic_asm_dialect'* +Type: string +Default: unset +Normally the assembler will select the dialect to use for checking based on +the file extension (AT&T for ".s", Intel for ".asm"). If you want to override +the automatic choice set this variable to either "att" or "intel". + + *'g:syntastic_asm_remove_include_errors'* +Type: boolean +Default: 0 +By default, errors in files included from the file being checked are shown. +Set this variable to 1 to remove messages about errors in included files. +Please note that this means syntastic will silently abort checks if there are +fatal errors in one of the included files. + + *'g:syntastic_asm_compiler_options'* +Type: string +Default: unset +Compilation flags (such as defines or include directories) to be passed to the +assembler. Set it to something like "-mtune=native": > + let g:syntastic_asm_compiler_options = "-mtune=native" +< + *'g:syntastic_asm_config_file'* +Type: string +Default: ".syntastic_asm_config" +File containing additional compilation flags to be passed to the assembler, +one option per line (see |syntastic-config-files|). + + *'g:syntastic_asm_include_dirs'* +Type: array of strings +Default: [] +Include directories to be passed to the assembler, in addition to the +above compilation flags. You can set it like this: > + let g:syntastic_asm_include_dirs = ["inc", "asm/src/include"] +< +and the corresponding "-Iinc -Iasm/src/include" will be added to the +compilation flags. + + *'b:syntastic_asm_cflags'* +Type: string +Default: unset +Buffer-local variable. Additional compilation flags specific to the current +buffer. + +Note~ + +This checker doesn't call the "makeprgBuild()" function, and thus it ignores +the usual 'g:syntastic_asm_gcc_<option>' variables. The only exception is +'g:syntastic_asm_gcc_exec', which can still be used to override the checker's +executable. + +============================================================================== +SYNTAX CHECKERS FOR BEMHTML *syntastic-checkers-bemhtml* + +The following checkers are available for BEMHTML (filetype "bemhtml"): + + 1. bemhtml-lint.............|syntastic-bemhtml-bemhtmllint| + +------------------------------------------------------------------------------ +1. bemhtml-lint *syntastic-bemhtml-bemhtmllint* + +Name: bemhtmllint +Maintainer: Sergej Tatarincev + +BEMHTML is a template engine intended for using with BEM methodology +(http://bem.info/method/). See the project's page at GitHub for details: + + https://github.com/SevInf/bemhtml-lint + +Checker options~ + +This checker is initialised using the "makeprgBuild()" function and thus it +accepts the standard options described at |syntastic-config-makeprg|. + +============================================================================== +SYNTAX CHECKERS FOR BRO *syntastic-checkers-bro* + +The following checkers are available for Bro (filetype "bro"): + + 1. Bro......................|syntastic-bro-bro| + +------------------------------------------------------------------------------ +1. Bro *syntastic-bro-bro* + +Name: bro +Maintainer: Justin Azoff <justin.azoff@gmail.com> + +"Bro" is a network security monitor. See the project's page for details: + + https://www.bro.org/ + +Checker options~ + +This checker is initialised using the "makeprgBuild()" function and thus it +accepts the standard options described at |syntastic-config-makeprg|. + +============================================================================== +SYNTAX CHECKERS FOR C *syntastic-checkers-c* + +The following checkers are available for C (filetype "c"): + + 1. AVR-GCC..................|syntastic-c-avrgcc| + 2. Checkpatch...............|syntastic-c-checkpatch| + 3. ClangCheck...............|syntastic-c-clang_check| + 4. Clang-Tidy...............|syntastic-c-clang_tidy| + 5. Cppcheck.................|syntastic-c-cppcheck| + 6. GCC......................|syntastic-c-gcc| + 7. make.....................|syntastic-c-make| + 8. OClint...................|syntastic-c-oclint| + 9. PC-Lint..................|syntastic-c-pc_lint| + 10. Sparse..................|syntastic-c-sparse| + 11. Splint..................|syntastic-c-splint| + +------------------------------------------------------------------------------ +1. AVR-GCC *syntastic-c-avrgcc* + +Name: avrgcc +Maintainer: Karel <karelishere@gmail.com> + +Checker options~ + +This checker is initialised using the "makeprgBuild()" function and thus it +accepts the standard options described at |syntastic-config-makeprg|. + +Aditionally: + + *g:syntastic_avrgcc_config_file* +Type: string +Default: ".syntastic_avrgcc_config" +File containing compilation flags (such as defines or include directories), +one option per line (cf. |syntastic-config-files|). + +------------------------------------------------------------------------------ +2. Checkpatch *syntastic-c-checkpatch* + +Name: checkpatch +Maintainer: Daniel Walker <dwalker@fifo99.com> + +"Checkpatch" is a style checker for the Linux kernel sources. It's +distributed along with the Linux kernel sources: + + https://github.com/torvalds/linux/blob/master/scripts/checkpatch.pl + +Checker options~ + +This checker is initialised using the "makeprgBuild()" function and thus it +accepts the standard options described at |syntastic-config-makeprg|. + +------------------------------------------------------------------------------ +3. ClangCheck *syntastic-c-clang_check* + +Name: clang_check +Maintainer: Benjamin Bannier <bbannier@gmail.com> + +"ClangCheck" is a wrapper around Clang's "LibTooling" +(http://clang.llvm.org/docs/LibTooling.html). See the official page for +details: + + http://clang.llvm.org/docs/ClangCheck.html + +Checker options~ + +This checker is initialised using the "makeprgBuild()" function and thus it +accepts the standard options described at |syntastic-config-makeprg|. + +Additionally: + + *'g:syntastic_clang_check_config_file'* +Type: string +Default: ".syntastic_clang_check_config" +File containing compilation flags (such as defines or include directories), +one option per line (cf. |syntastic-config-files|). + +Note~ + +By default you can set "ClangCheck" parameters in +'g:syntastic_c_clang_check_args', and compilation parameters +(defines, optimisation flags, etc.) in the configuration file. + +However, if you want "ClangCheck" to use compilation databases +(http://clang.llvm.org/docs/JSONCompilationDatabase.html) -- perhaps +generated by "CMake" (https://github.com/rizsotto/Bear) or "Build EAR" +(https://github.com/rizsotto/Bear) -- rather than pass compilation flags +explicitly, set 'g:syntastic_c_clang_check_post_args' to an empty string: > + let g:syntastic_c_clang_check_post_args = "" +< +Configuration files pointed to by 'g:syntastic_clang_check_config_file' are +then ignored. + +See also: |syntastic-cpp-clang_check|. + +------------------------------------------------------------------------------ +4. Clang-Tidy *syntastic-c-clang_tidy* + +Name: clang_tidy +Maintainer: Benjamin Bannier <bbannier@gmail.com> + +"Clang-Tidy" is a lint tool based on "Clang" (http://clang.llvm.org/). See +the project's page for details: + + http://clang.llvm.org/extra/clang-tidy.html + +Installation~ + +"Clang-Tidy" is part of the "Clang" (http://clang.llvm.org/) project, but it +isn't built by default. You need to enable compilation of the "Extra Clang +Tools" (http://clang.llvm.org/docs/ClangTools.html#extra-clang-tools) to get +it. See the build tutorial for details: + + http://clang.llvm.org/docs/LibASTMatchersTutorial.html + +Checker options~ + +This checker is initialised using the "makeprgBuild()" function and thus it +accepts the standard options described at |syntastic-config-makeprg|. + +Additionally: + + *'g:syntastic_clang_tidy_config_file'* +Type: string +Default: ".syntastic_clang_tidy_config" +File containing compilation flags (such as defines or include directories), +one option per line (cf. |syntastic-config-files|). + +Note~ + +By default you can set "ClangTidy" parameters in +'g:syntastic_c_clang_tidy_args', and compilation parameters +(defines, optimisation flags, etc.) in the configuration file. + +If you want "ClangTidy" to use compilation databases +(http://clang.llvm.org/docs/JSONCompilationDatabase.html) -- +perhaps generated by "CMake" (http://cmake.org/) or "Build EAR" +(https://github.com/rizsotto/Bear) -- rather than pass compilation flags +explicitly, set 'g:syntastic_c_clang_tidy_post_args' to an empty string: > + let g:syntastic_c_clang_tidy_post_args = "" +< +Configuration files pointed to by 'g:syntastic_clang_tidy_config_file' are +then ignored. + +See also: |syntastic-cpp-clang_tidy|. + +------------------------------------------------------------------------------ +5. Cppcheck *syntastic-c-cppcheck* + +Name: cppcheck +Maintainer: LCD 47 <lcd047@gmail.com> + +"Cppcheck" is a static analysis tool for C/C++ code. See the project's page +for details: + + http://cppcheck.sourceforge.net/ + +Checker options~ + +This checker is initialised using the "makeprgBuild()" function and thus it +accepts the standard options described at |syntastic-config-makeprg|. + +Additionally: + + *'g:syntastic_cppcheck_config_file'* +Type: string +Default: ".syntastic_cppcheck_config" +File containing compilation flags (such as defines or include directories), +one option per line (cf. |syntastic-config-files|). + +See also: |syntastic-cpp-cppcheck|. + +------------------------------------------------------------------------------ +6. GCC *syntastic-c-gcc* + +Name: gcc +Maintainer: Gregor Uhlenheuer <kongo2002@gmail.com> + +Checker options~ + *'g:syntastic_c_compiler'* +Type: string +Default: "gcc", or "clang" if GCC is not found +Compiler executable. + + *'g:syntastic_c_errorformat'* +Type: string +Default: unset +Override for the default |'errorformat'|. + + *'g:syntastic_c_remove_include_errors'* +Type: boolean +Default: 0 +By default, errors in files included from the file being checked are shown. +Set this variable to 1 to remove messages about errors in included files. +Please note that this means syntastic will silently abort checks if there are +fatal errors in one of the included files. + + *'g:syntastic_c_compiler_options'* +Type: string +Default: "-std=gnu99" +Compilation flags (such as defines or include directories) to be passed to the +checker. + + *'g:syntastic_c_config_file'* +Type: string +Default: ".syntastic_c_config" +File containing additional compilation flags to be passed to the checker, one +option per line (cf. |syntastic-config-files|). + + *'g:syntastic_c_include_dirs'* +Type: array of strings +Default: [] +Include directories to be passed to the checker, in addition to the above +compilation flags. You can set it to something like this: > + let g:syntastic_c_include_dirs = ["includes", "headers"] +< +and the corresponding "-Iincludes -Iheaders" will be added to the compilation +flags. + + *'g:syntastic_c_no_default_include_dirs'* +Type: boolean +Default: 0 +By default syntastic adds a number of common include directories to the +compilation flags, namely: > + -I. -I.. -Iinclude -Iincludes -I../include -I../includes +< +You can disable this behaviour by setting the above variable to 1. + + *'g:syntastic_c_no_include_search'* +Type: boolean +Default: 0 +By default syntastic looks at the first 100 lines of the file being checked, +and tries to determine if it needs to include headers for some common +libraries, such as "GLib" or "Gtk". It then tries to add the corresponding +include directories to the compilation flags. You can disable this behaviour +by setting the above variable to 1. + + *'g:syntastic_c_auto_refresh_includes'* +Type: boolean +Default: 0 +Used only if "g:syntastic_c_no_include_search" is set to a false value. By +default syntastic searches for common libraries only the first time the +current file is checked. Setting the above variable to 1 instructs syntastic +to refresh the list of common libraries every time the current file is +checked. You can also force a refresh even when the above variable is 0, by +`:unlet`-ing the buffer variable 'b:syntastic_c_includes'. + + *'b:syntastic_c_cflags'* +Type: string +Default: unset +Buffer-local variable. When set, no search for common libraries is performed, +and the contents of the variable are added to the compilation flags. + + *'g:syntastic_c_check_header'* +Type: boolean +Default: 0 +If the current file is a header (namely if its extension is "h"), all checks +are silently skipped. You can force syntastic to check header files by +setting the above variable to 1. + +Note~ + +This checker doesn't call the "makeprgBuild()" function, and thus it ignores +the usual 'g:syntastic_c_gcc_<option>' variables. The only exception is +'g:syntastic_c_gcc_exec', which can still be used to override the checker's +executable. + +See also: |syntastic-cpp-gcc|. + +------------------------------------------------------------------------------ +7. make *syntastic-c-make* + +Name: make +Maintainer: Gregor Uhlenheuer <kongo2002@gmail.com> + +Checker options~ + +This checker is initialised using the "makeprgBuild()" function and thus it +accepts the standard options described at |syntastic-config-makeprg|. + +------------------------------------------------------------------------------ +8. OClint *syntastic-c-oclint* + +Name: oclint +Maintainer: "UnCO" Lin <undercooled@lavabit.com> + +"OClint" is a static code analysis tool. See the project's page for details: + + http://oclint.org/ + +Checker options~ + +This checker is initialised using the "makeprgBuild()" function and thus it +accepts the standard options described at |syntastic-config-makeprg|. + +Additionally: + + 'g:syntastic_oclint_config_file' +Type: string +Default: ".syntastic_oclint_config" +File containing compilation flags (such as defines or include directories), +one option per line (cf. |syntastic-config-files|). + +Notes~ + +By default you can set "OClint" parameters in 'g:syntastic_c_oclint_args', and +compilation parameters (defines, optimisation flags, etc.) in the config file. + +If you want "OClint" to use "Clang"-style compilation databases +(http://clang.llvm.org/docs/JSONCompilationDatabase.html) -- +perhaps generated by "CMake" (http://cmake.org/) or "Build EAR" +(https://github.com/rizsotto/Bear) -- rather than pass compilation flags +explicitly, set 'g:syntastic_c_oclint_post_args' to an empty string: > + let g:syntastic_c_oclint_post_args = "" +< +Config files pointed to by 'g:syntastic_oclint_config_file' are then ignored. + +See also: |syntastic-cpp-oclint|. + +------------------------------------------------------------------------------ +9. PC-Lint *syntastic-c-pc_lint* + +Name: pc_lint +Maintainer: Steve Bragg <steve@empresseffects.com> + +"PC-Lint" is a commercial static code analysis tool for Windows, produced +by "Gimpel Software" (http://www.gimpel.com/). See the project's page for +details: + + http://www.gimpel.com/html/pcl.htm + +Checker options~ + +This checker is initialised using the "makeprgBuild()" function and thus it +accepts the standard options described at |syntastic-config-makeprg|. + +Additionally: + + *'g:syntastic_pc_lint_config_file'* +Type: string +Default: "options.lnt" +Name of an indirect (.lnt) file. A file with that name is looked up in the +current directory and in parent directories; first such file found is used. + +See also: |syntastic-cpp-pc_lint|. + +------------------------------------------------------------------------------ +10. Sparse *syntastic-c-sparse* + +Name: sparse +Maintainer: Daniel Walker <dwalker@fifo99.com> + +"Sparse" is a semantic parser for C, see the official wiki for details: + + https://sparse.wiki.kernel.org/index.php/Main_Page + +Checker options~ + +This checker is initialised using the "makeprgBuild()" function and thus it +accepts the standard options described at |syntastic-config-makeprg|. + +Additionally: + + *'g:syntastic_sparse_config_file'* +Type: string +Default: ".syntastic_sparse_config" +File containing compilation flags (such as defines or include directories), +one option per line (cf. |syntastic-config-files|). + +Notes~ + +If you use "Sparse" with "GCC" you probably want to add something like this to +your vimrc: > + let g:syntastic_c_sparse_post_args="-gcc-base-dir " . + \ system("gcc -v 2>&1 | sed -n '/^Reading specs/ { s#.* /#/#; s#/[^/]*$##; p; }'") +< +This allows "Sparse" to read "GCC"'s private include files. + +------------------------------------------------------------------------------ +11. Splint *syntastic-c-splint* + +Name: splint +Maintainer: LCD 47 <lcd047@gmail.com> + +"Splint" is a tool for statically checking C programs for security +vulnerabilities, see the project's page for details: + + http://www.splint.org/ + +Checker options~ + +This checker is initialised using the "makeprgBuild()" function and thus it +accepts the standard options described at |syntastic-config-makeprg|. + +Additionally: + + *'g:syntastic_splint_config_file'* +Type: string +Default: ".syntastic_splint_config" +File containing project-specific options to be passed to "Splint" +(such as defines or include directories), one option per line (cf. +|syntastic-config-files|). + +============================================================================== +SYNTAX CHECKERS FOR C# *syntastic-checkers-cs* + +The following checkers are available for C# (filetype "cs"): + + 1. mcs......................|syntastic-cs-mcs| + +------------------------------------------------------------------------------ +1. mcs *syntastic-cs-mcs* + +Name: mcs +Maintainer: Daniel Walker <dwalker@fifo99.com> + +"mcs" is a compiler for C# from the "Mono" project +(http://www.mono-project.com/Main_Page). See the program's manual for details: + + http://mono.wikia.com/wiki/Man_mcs + +Checker options~ + +This checker is initialised using the "makeprgBuild()" function and thus it +accepts the standard options described at |syntastic-config-makeprg|. + +============================================================================== +SYNTAX CHECKERS FOR C++ *syntastic-checkers-cpp* + +The following checkers are available for C++ (filetype "cpp"): + + 1. ClangCheck...............|syntastic-cpp-clang_check| + 2. Clang-Tidy...............|syntastic-cpp-clang_tidy| + 3. Cppcheck.................|syntastic-cpp-cppcheck| + 4. Cpplint..................|syntastic-cpp-cpplint| + 5. GCC......................|syntastic-cpp-gcc| + 6. OClint...................|syntastic-cpp-oclint| + 7. PC-Lint..................|syntastic-cpp-pc_lint| + 8. Vera++...................|syntastic-cpp-verapp| + +------------------------------------------------------------------------------ +1. ClangCheck *syntastic-cpp-clang_check* + +Name: clang_check +Maintainer: Benjamin Bannier <bbannier@gmail.com> + +"ClangCheck" is a wrapper around Clang's "LibTooling" +(http://clang.llvm.org/docs/LibTooling.html). See the official page for +details: + + http://clang.llvm.org/docs/ClangCheck.html + +Checker options~ + +This checker is initialised using the "makeprgBuild()" function and thus it +accepts the standard options described at |syntastic-config-makeprg|. + +Additionally: + + 'g:syntastic_clang_check_config_file' +Type: string +Default: ".syntastic_clang_check_config" +file containing compilation flags (such as defines or include directories), +one option per line (cf. |syntastic-config-files|). + +Note~ + +By default you can set "ClangCheck" parameters in +'g:syntastic_cpp_clang_check_args', and compilation parameters (defines, +optimisation flags, etc.) in the configuration file. + +However, if you want "ClangCheck" to use compilation databases +(http://clang.llvm.org/docs/JSONCompilationDatabase.html) -- perhaps +generated by "CMake" (https://github.com/rizsotto/Bear) or "Build EAR" +(https://github.com/rizsotto/Bear) -- rather than pass compilation flags +explicitly, set 'g:syntastic_cpp_clang_check_post_args' to an empty string: > + let g:syntastic_cpp_clang_check_post_args = "" +< +Configuration files pointed to by 'g:syntastic_clang_check_config_file' are +then ignored. + +See also: |syntastic-c-clang_check|. + +------------------------------------------------------------------------------ +2. Clang-Tidy *syntastic-cpp-clang_tidy* + +Name: clang_tidy +Maintainer: Benjamin Bannier <bbannier@gmail.com> + +"Clang-Tidy" is a lint tool based on "Clang" (http://clang.llvm.org/). See +the project's page for details: + + http://clang.llvm.org/extra/clang-tidy.html + +Installation~ + +"Clang-Tidy" is part of the "Clang" (http://clang.llvm.org/) project, but it +isn't built by default. You need to enable compilation of the "Extra Clang +Tools" (http://clang.llvm.org/docs/ClangTools.html#extra-clang-tools) to get +it. See the build tutorial for details: + + http://clang.llvm.org/docs/LibASTMatchersTutorial.html + +Checker options~ + +This checker is initialised using the "makeprgBuild()" function and thus it +accepts the standard options described at |syntastic-config-makeprg|. + +Additionally: + + 'g:syntastic_clang_tidy_config_file' +Type: string +Default: ".syntastic_clang_tidy_config" +File containing compilation flags (such as defines or include directories), +one option per line (cf. |syntastic-config-files|). + +Note~ + +By default you can set "ClangTidy" parameters in +'g:syntastic_ppc_clang_tidy_args', and compilation parameters (defines, +optimisation flags, etc.) in the configuration file. + +If you want "ClangTidy" to use compilation databases +(http://clang.llvm.org/docs/JSONCompilationDatabase.html) -- +perhaps generated by "CMake" (http://cmake.org/) or "Build EAR" +(https://github.com/rizsotto/Bear) -- rather than pass compilation flags +explicitly, set 'g:syntastic_cpp_clang_tidy_post_args' to an empty string: > + let g:syntastic_cpp_clang_tidy_post_args = "" +< +Configuration files pointed to by 'g:syntastic_clang_tidy_config_file' are +then ignored. + +See also: |syntastic-c-clang_tidy|. + +------------------------------------------------------------------------------ +3. Cppcheck *syntastic-cpp-cppcheck* + +Name: cppcheck +Maintainer: LCD 47 <lcd047@gmail.com> + +"Cppcheck" is a static analysis tool for C/C++ code. See the project's page +for details: + + http://cppcheck.sourceforge.net/ + +Checker options~ + +This checker is initialised using the "makeprgBuild()" function and thus it +accepts the standard options described at |syntastic-config-makeprg|. + +Additionally: + + 'g:syntastic_cppcheck_config_file' +Type: string +Default: ".syntastic_cppcheck_config" +File containing compilation flags (such as defines or include directories), +one option per line (cf. |syntastic-config-files|). + +See also: |syntastic-c-cppcheck|. + +------------------------------------------------------------------------------ +4. Cpplint *syntastic-cpp-cpplint* + +Name: cpplint +Maintainer: LCD 47 <lcd047@gmail.com> + +For details about "Cpplint" see the project's page: + + https://code.google.com/p/google-styleguide/ + +Checker options~ + +This checker is initialised using the "makeprgBuild()" function and thus it +accepts the standard options described at |syntastic-config-makeprg|. + +Additionally: + + *'g:syntastic_cpp_cpplint_thres'* +Type: integer +Default: 5 +Error threshold. Policy violations with a severity above this value are +highlighted as errors, the others are considered warnings by syntastic. + + *'g:syntastic_cpp_cpplint_args'* +Type: string +Default: "--verbose=3" +Command line options to pass to "Cpplint" + +Note~ + +By default syntastic expects the "cpplint" script to be named "cpplint.py". +However, if your "cpplint" was installed with "pip", the script's name is +"cpplint", and you need to set 'g:syntastic_cpp_cpplint_exec' accordingly: +> + let g:syntastic_cpp_cpplint_exec = "cpplint" +< +------------------------------------------------------------------------------ +5. GCC *syntastic-cpp-gcc* + +Name: gcc +Maintainer: Gregor Uhlenheuer <kongo2002@gmail.com> + +Checker options~ + *'g:syntastic_cpp_compiler'* +Type: string +Default: "g++", or "clang++" if GCC is not found +Compiler executable. + + *'g:syntastic_cpp_errorformat'* +Type: string +Default: unset +Override for the default |'errorformat'|. + + *'g:syntastic_cpp_remove_include_errors'* +Type: boolean +Default: 0 +By default, errors in files included from the file being checked are shown. +Set this variable to 1 to remove messages about errors in included files. +Please note that this means syntastic will silently abort checks if there are +fatal errors in one of the included files. + + *'g:syntastic_cpp_compiler_options'* +Type: string +Default: unset +Compilation flags (such as defines or include directories) to be passed to the +checker. + + *'g:syntastic_cpp_config_file'* +Type: string +Default: ".syntastic_cpp_config" +File containing additional compilation flags to be passed to the checker, one +option per line (cf. |syntastic-config-files|). + + *'g:syntastic_cpp_include_dirs'* +Type: array of strings +Default: [] +Include directories to be passed to the checker, in addition to the above +compilation flags. You can set it to something like this: > + let g:syntastic_cpp_include_dirs = ["includes", "headers"] +> +and the corresponding "-Iincludes -Iheaders" will be added to the compilation +flags. + + *'g:syntastic_cpp_no_default_include_dirs'* +Type: boolean +Default: 0 +By default syntastic adds a number of common include directories to the +compilation flags, namely: > + -I. -I.. -Iinclude -Iincludes -I../include -I../includes +< +You can disable this behaviour by setting the above variable to 1. + + *'g:syntastic_cpp_no_include_search'* +Type: boolean +Default: 0 +By default syntastic looks at the first 100 lines of the file being checked, +and tries to determine if it needs to include headers for some common +libraries, such as "GLib" or "Gtk". It then tries to add the corresponding +include directories to the compilation flags. You can disable this behaviour +by setting the above variable to 1. + + *'g:syntastic_cpp_auto_refresh_includes'* +Type: boolean +Default: 0 +Used only if "g:syntastic_cpp_no_include_search" is set to a false value. +By default syntastic searches for common libraries only the first time the +current file is checked. Setting the above variable to 1 instructs syntastic +to refresh the list of common libraries every time the current file is +checked. You can also force a refresh even when the above variable is 0, by +`:unlet`-ing the buffer variable 'b:syntastic_cpp_includes'. + + *'b:syntastic_cpp_cflags'* +Type: string +Default: unset +Buffer-local variable. When set, no search for common libraries is performed, +and the contents of the variable are added to the compilation flags. + + *'g:syntastic_cpp_check_header'* +Type: boolean +Default: 0 +If the current file is a header (namely if its extension is "h", "hpp", or +"hh"), all checks are silently skipped. You can force syntastic to check +header files by setting the above variable to 1. + +Note~ + +This checker doesn't call the "makeprgBuild()" function, and thus it ignores +the usual 'g:syntastic_cpp_gcc_<option>' variables. The only exception is +'g:syntastic_cpp_gcc_exec', which can still be used to override the checker's +executable. + +See also: |syntastic-c-gcc|. + +------------------------------------------------------------------------------ +6. OClint *syntastic-cpp-oclint* + +Name: oclint +Maintainer: "UnCO" Lin <undercooled@lavabit.com> + +"OClint" is a static code analysis tool. See the project's page for details: + + http://oclint.org/ + +Checker options~ + +This checker is initialised using the "makeprgBuild()" function and thus it +accepts the standard options described at |syntastic-config-makeprg|. + +Additionally: + + 'g:syntastic_oclint_config_file' +Type: string +Default: ".syntastic_oclint_config" +File containing compilation flags (such as defines or include directories), +one option per line (cf. |syntastic-config-files|). + +Notes~ + +By default you can set "OClint" parameters in 'g:syntastic_cpp_oclint_args', +and compilation parameters (defines, optimisation flags, etc.) in the config +file. + +If you want "OClint" to use "Clang"-style compilation databases +(http://clang.llvm.org/docs/JSONCompilationDatabase.html) -- +perhaps generated by "CMake" (http://cmake.org/) or "Build EAR" +(https://github.com/rizsotto/Bear) -- rather than pass compilation flags +explicitly, set 'g:syntastic_c_oclint_post_args' to an empty string: > + let g:syntastic_cpp_oclint_post_args = "" +< +Config files pointed to by 'g:syntastic_oclint_config_file' are then ignored. + +See also: |syntastic-c-oclint|. + +------------------------------------------------------------------------------ +7. PC-Lint *syntastic-cpp-pc_lint* + +Name: pc_lint +Maintainer: Steve Bragg <steve@empresseffects.com> + +"PC-Lint" is a commercial static code analysis tool for Windows, produced +by "Gimpel Software" (http://www.gimpel.com/). See the project's page for +details: + + http://www.gimpel.com/html/pcl.htm + +Checker options~ + +This checker is initialised using the "makeprgBuild()" function and thus it +accepts the standard options described at |syntastic-config-makeprg|. + +Additionally: + + 'g:syntastic_pc_lint_config_file' +Type: string +Default: "options.lnt" +Name of an indirect (.lnt) file. A file with that name is looked up in the +current directory and in parent directories; first such file found is used. + +See also: |syntastic-c-pc_lint|. + +------------------------------------------------------------------------------ +8. Vera++ *syntastic-cpp-verapp* + +Name: verapp +Maintainer: Lucas Verney <phyks@phyks.me> + +"Vera++" is a programmable tool for verification, analysis and transformation +of C++ source code. See the project's page for details: + + https://bitbucket.org/verateam/vera/wiki/Home + +Checker options~ + +This checker is initialised using the "makeprgBuild()" function and thus it +accepts the standard options described at |syntastic-config-makeprg|. + +Additionally: + + *'g:syntastic_verapp_config_file'* +Type: string +Default: ".syntastic_verapp_config" +File containing additional compilation flags to be passed to the checker, one +option per line (cf. |syntastic-config-files|). + +============================================================================== +SYNTAX CHECKERS FOR CABAL *syntastic-checkers-cabal* + +The following checkers are available for Cabal (filetype "cabal"): + + 1. Cabal....................|syntastic-cabal-cabal| + +------------------------------------------------------------------------------ +1. Cabal *syntastic-cabal-cabal* + +Name: cabal +Maintainer: Ian D. Bollinger <ian.bollinger@gmail.com> + +This checker runs "cabal check" against Haskell Cabal package descriptions. +See the project's page for more information: + + http://www.haskell.org/cabal/ + +Note~ + +This checker doesn't call the "makeprgBuild()" function, and thus it ignores +the usual 'g:syntastic_cabal_cabal_<option>' variables. The only exception +is 'g:syntastic_cabal_cabal_exec', which can still be used to override the +checker's executable. + +============================================================================== +SYNTAX CHECKERS FOR CHEF *syntastic-checkers-chef* + +The following checkers are available for Chef (filetype "chef"): + + 1. Foodcritic...............|syntastic-chef-foodcritic| + +------------------------------------------------------------------------------ +1. Foodcritic *syntastic-chef-foodcritic* + +Name: foodcritic +Maintainer: Doug Ireton + +"Foodcritic" is a linter for "Chef" cookbooks (http://www.opscode.com/chef/). +See the project's page for more information: + + http://acrmp.github.io/foodcritic/ + +Checker options~ + +This checker is initialised using the "makeprgBuild()" function and thus it +accepts the standard options described at |syntastic-config-makeprg|. + +Note~ + +You probably also need a plugin to set |filetype| for Chef files, such as +"vim-chef": + + https://github.com/dougireton/vim-chef + +============================================================================== +SYNTAX CHECKERS FOR COBOL *syntastic-checkers-cobol* + +The following checkers are available for COBOL (filetype "cobol"): + + 1. OpenCOBOL................|syntastic-cobol-cobc| + +------------------------------------------------------------------------------ +1. OpenCOBOL *syntastic-cobol-cobc* + +Name: cobc +Maintainer: LCD 47 <lcd047@gmail.com> + +"OpenCOBOL" is a compiler for COBOL. See the project's page for more +information: + + http://www.opencobol.org/ + +Checker options~ + *'g:syntastic_cobol_compiler'* +Type: string +Default: "cobc" +Compiler executable. + + *'g:syntastic_cobol_errorformat'* +Type: string +Default: unset +Override for the default |'errorformat'|. + + *'g:syntastic_cobol_remove_include_errors'* +Type: boolean +Default: 0 +By default, errors in files included from the file being checked are shown. +Set this variable to 1 to remove messages about errors in included files. +Please note that this means syntastic will silently abort checks if there are +fatal errors in one of the included files. + + *'g:syntastic_cobol_compiler_options'* +Type: string +Default: unset +Compilation flags (such as "-std=cobol2002") to be passed to the checker. + + *'g:syntastic_cobol_config_file'* +Type: string +Default: ".syntastic_cobol_config" +File containing additional compilation flags to be passed to the checker, one +option per line (cf. |syntastic-config-files|). + + *'g:syntastic_cobol_include_dirs'* +Type: array of strings +Default: [] +Include directories to be passed to the checker, in addition to the above +compilation flags. You can set it to something like this: > + let g:syntastic_cobol_include_dirs = ["includes", "headers"] +< +and the corresponding "-Iincludes -Iheaders" will be added to the compilation +flags. + + *'b:syntastic_cobol_cflags'* +Type: string +Default: unset +Buffer-local variable. Additional compilation flags specific to the current +buffer. + +Note~ + +This checker doesn't call the "makeprgBuild()" function, and thus it ignores +the usual 'g:syntastic_cobol_cobc_<option>' variables. The only exception +is 'g:syntastic_cobol_cobc_exec', which can still be used to override the +checker's executable. + +============================================================================== +SYNTAX CHECKERS FOR COCO *syntastic-checkers-co* + +The following checkers are available for Coco (filetype "co"): + + 1. Coco.....................|syntastic-co-coco| + +------------------------------------------------------------------------------ +1. Coco *syntastic-co-coco* + +Name: coco +Maintainer: Andrew Kelley <superjoe30@gmail.com> + +For details about "Coco" see the project's page: + + https://github.com/satyr/coco/ + +Checker options~ + +This checker is initialised using the "makeprgBuild()" function and thus it +accepts the standard options described at |syntastic-config-makeprg|. + +============================================================================== +SYNTAX CHECKERS FOR COFFEESCRIPT *syntastic-checkers-coffee* + +The following checkers are available for CoffeeScript (filetype "coffee"): + + 1. Coffee...................|syntastic-coffee-coffee| + 2. CoffeeLint...............|syntastic-coffee-coffeelint| + +------------------------------------------------------------------------------ +1. Coffee *syntastic-coffee-coffee* + +Name: coffee +Maintainer: Lincoln Stoll <l@lds.li> + +"Coffee" is a compiler for CoffeeScript. See the project's page for details: + + http://coffeescript.org/ + +Syntastic requires "Coffee" version 1.6.2 or later. + +Checker options~ + +This checker is initialised using the "makeprgBuild()" function and thus it +accepts the standard options described at |syntastic-config-makeprg|. + +------------------------------------------------------------------------------ +2. CoffeeLint *syntastic-coffee-coffeelint* + +Name: coffeelint +Maintainer: Lincoln Stoll <l@lds.li> + +"CoffeeLint" is a style checker for CoffeeScript. See the project's page for +details: + + http://www.coffeelint.org/ + +Checker options~ + +This checker is initialised using the "makeprgBuild()" function and thus it +accepts the standard options described at |syntastic-config-makeprg|. + +============================================================================== +SYNTAX CHECKERS FOR COQ *syntastic-checkers-coq* + +The following checkers are available for Coq (filetype "coq"): + + 1. Coqtop...................|syntastic-coq-coqtop| + +------------------------------------------------------------------------------ +1. Coqtop *syntastic-coq-coqtop* + +Name: coqtop +Maintainer: Matvey Aksenov <matvey.aksenov@gmail.com> + +"Coqtop" is the top level intrface for Coq. See the project's page for +details: + + http://coq.inria.fr/ + +Checker options~ + +This checker is initialised using the "makeprgBuild()" function and thus it +accepts the standard options described at |syntastic-config-makeprg|. + +============================================================================== +SYNTAX CHECKERS FOR CSS *syntastic-checkers-css* + +The following checkers are available for CSS (filetype "css"): + + 1. CSSLint..................|syntastic-css-csslint| + 2. mixedindentlint..........|syntastic-css-mixedindentlint| + 3. PHP_CodeSniffer..........|syntastic-css-phpcs| + 4. PrettyCSS................|syntastic-css-prettycss| + 5. RECESS...................|syntastic-css-recess| + 6. stylelint................|syntastic-css-stylelint| + +------------------------------------------------------------------------------ +1. CSSLint *syntastic-css-csslint* + +Name: csslint +Maintainer: Ory Band <oryband@gmail.com> + +"CSSLint" is a lint tool for Cascading Stylesheets. See the project's page +for details: + + http://csslint.net/ + +Installation~ + +Install it with "npm": > + npm install -g csslint +< +Checker options~ + +This checker is initialised using the "makeprgBuild()" function and thus it +accepts the standard options described at |syntastic-config-makeprg|. + +------------------------------------------------------------------------------ +2. mixedindentlint *syntastic-css-mixedindentlint* + +Name: mixedindentlint +Maintainer: Payton Swick <payton@foolord.com> + +"mixedindentlint" is a general-purpose indentation checker. See the project's +page at GitHub for more information: + + https://github.com/sirbrillig/mixedindentlint + +Checker options~ + +This checker is initialised using the "makeprgBuild()" function and thus it +accepts the standard options described at |syntastic-config-makeprg|. + +See also: |syntastic-javascript-mixedindentlint|, |syntastic-scss-mixedindentlint|. + +------------------------------------------------------------------------------ +3. PHP_CodeSniffer *syntastic-css-phpcs* + +Name: phpcs +Maintainer: LCD 47 <lcd047@gmail.com> + +"PHP_CodeSniffer" is a style checker for PHP and CSS. See the project's page +at GitHub for details: + + https://github.com/squizlabs/PHP_CodeSniffer/ + +Installation~ + +Install it with: > + pear install PHP_CodeSniffer +< +Checker options~ + +This checker is initialised using the "makeprgBuild()" function and thus it +accepts the standard options described at |syntastic-config-makeprg|. + +Note~ + +If you're checking files containing tab characters then "PHP_CodeSniffer"'s +idea of tabstop must match Vim's 'tabstop', otherwise syntastic will highlight +the errors at shifted positions. By default syntastic does that by adding +an option "--tab-width=&tabstop" to "PHP_CodeSniffer", but that option +also instructs "PHP_CodeSniffer" to expand tabs, and some code sniffers +(f.i. "CakePHP", see https://github.com/cakephp/cakephp-codesniffer) insist on +indenting lines with tabs. To work around the resulting mess if you're using +one of these sniffers, set "--tab-width=0" and 'tabstop' to 8: > + let g:syntastic_php_phpcs_args = "--tab-width=0" + set tabstop=8 +< +See also: |syntastic-php-phpcs|. + +------------------------------------------------------------------------------ +4. PrettyCSS *syntastic-css-prettycss* + +Name: prettycss +Maintainer: LCD 47 <lcd047@gmail.com> + +"PrettyCSS" is a beautifier, lint checker, and validator for Cascading +Stylesheets. For more details see: + +PrettyCSS Demo: + + http://fidian.github.io/PrettyCSS/ + +The project's page at GitHub: + + https://github.com/fidian/PrettyCSS/ + +Installation~ + +Install it with: > + npm install -g PrettyCSS +< +Checker options~ + +This checker is initialised using the "makeprgBuild()" function and thus it +accepts the standard options described at |syntastic-config-makeprg|. + +------------------------------------------------------------------------------ +5. RECESS *syntastic-css-recess* + +Name: recess +Maintainer: Tim Carry <tim@pixelastic.com> + +"RECESS" is a code quality tool for CSS built on top of LESS. See the +project's page for details: + + http://twitter.github.io/recess/ + +Checker options~ + +This checker is initialised using the "makeprgBuild()" function and thus it +accepts the standard options described at |syntastic-config-makeprg|. + +See also: |syntastic-less-recess|. + +------------------------------------------------------------------------------ +6. stylelint *syntastic-css-stylelint* + +Name: stylelint +Maintainer: Tim Carry <tim@pixelastic.com> + +"stylelint" is a style checker for Cascading Stylesheets. See the project's +page for more information: + + http://stylelint.io/ + +Checker options~ + +This checker is initialised using the "makeprgBuild()" function and thus it +accepts the standard options described at |syntastic-config-makeprg|. + +See also: |syntastic-scss-stylelint|. + +============================================================================== +SYNTAX CHECKERS FOR CUCUMBER *syntastic-checkers-cucumber* + +The following checkers are available for Cucumber (filetype "cucumber"): + + 1. Cucumber.................|syntastic-cucumber-cucumber| + +------------------------------------------------------------------------------ +1. Cucumber *syntastic-cucumber-cucumber* + +Name: cucumber +Maintainer: Martin Grenfell <martin.grenfell@gmail.com> + +"Cucumber" is a tool that executes plain-text functional descriptions as +automated tests. See the project's page for more information: + + http://cukes.info/ + +Checker options~ + +This checker is initialised using the "makeprgBuild()" function and thus it +accepts the standard options described at |syntastic-config-makeprg|. + +============================================================================== +SYNTAX CHECKERS FOR CUDA *syntastic-checkers-cuda* + +The following checkers are available for CUDA (filetype "cuda"): + + 1. NVCC.....................|syntastic-cuda-nvcc| + +------------------------------------------------------------------------------ +1. NVCC *syntastic-cuda-nvcc* + +Name: nvcc +Author: Hannes Schulz <schulz@ais.uni-bonn.de> + +"NVCC" is a CUDA Compiler from nVidia. See the project's page for details: + + https://developer.nvidia.com/cuda-llvm-compiler + +Checker options~ + +This checker is initialised using the "makeprgBuild()" function and thus it +accepts the standard options described at |syntastic-config-makeprg|. + +Additionally: + + *'g:syntastic_cuda_check_header'* +Type: boolean +Default: 0 +Turn this on to check header files. The checker then creates an empty file +".syntastic_dummy.cu" in the base directory of the file being checked. +Example: > + let g:syntastic_cuda_check_header = 1 +< + *'g:syntastic_cuda_config_file'* +Type: string +Default: ".syntastic_cuda_config" +File containing additional compilation flags to be passed to the checker, one +option per line (cf. |syntastic-config-files|). + +============================================================================== +SYNTAX CHECKERS FOR D *syntastic-checkers-d* + +The following checkers are available for D (filetype "d"): + + 1. DMD......................|syntastic-d-dmd| + +------------------------------------------------------------------------------ +1. DMD *syntastic-d-dmd* + +Name: dmd +Maintainer: Alfredo Di Napoli <alfredo.dinapoli@gmail.com> + +Checker options~ + *'g:syntastic_d_compiler'* +Type: string +Default: "dmd" +Compiler executable. + + *'g:syntastic_d_errorformat'* +Type: string +Default: unset +Override for the default |'errorformat'|. + + *'g:syntastic_d_remove_include_errors'* +Type: boolean +Default: 0 +By default, errors in files included from the file being checked are shown. +Set this variable to 1 to remove messages about errors in included files. +Please note that this means syntastic will silently abort checks if there are +fatal errors in one of the included files. + + *'g:syntastic_d_compiler_options'* +Type: string +Default: unset +Compilation flags (such as defines or include directories) to be passed to the +checker. + + *'g:syntastic_d_config_file'* +Type: string +Default: ".syntastic_d_config" +File containing additional compilation flags to be passed to the checker, one +option per line (cf. |syntastic-config-files|). + + *'g:syntastic_d_include_dirs'* +Type: array of strings +Default: inferred from ".dub/packages" +Include directories to be passed to the checker, in addition to the above +compilation flags. You can set it like this: > + let g:syntastic_d_include_dirs = ["includes", "headers"] +< +and the corresponding "-Iincludes -Iheaders" will be added to the compilation +flags. + + *'g:syntastic_d_use_dub'* +Type: boolean +Default: 1 +Whether to use "dub" to find include directories. This requires "dub" version +0.9.24 or later. + + *'g:syntastic_d_dub_exec'* +Type: string +Default: "dub" +Path to the "dub" executable. Ignored if |'g:syntastic_d_use_dub'| is unset. + + *'b:syntastic_d_cflags'* +Type: string +Default: unset +Buffer-local variable. Additional compilation flags specific to the current +buffer. + + *'g:syntastic_d_check_header'* +Type: boolean +Default: 0 +If the current file is a header (namely if its extension is "di"), all checks +are silently skipped. You can force syntastic to check header files by setting +the above variable to 1. + +Note~ + +This checker doesn't call the "makeprgBuild()" function, and thus it ignores +the usual 'g:syntastic_d_dmd_<option>' variables. The only exception is +'g:syntastic_d_dmd_exec', which can still be used to override the checker's +executable. + +============================================================================== +SYNTAX CHECKERS FOR DART *syntastic-checkers-dart* + +The following checkers are available for Dart (filetype "dart"): + + 1. Analyzer.................|syntastic-dart-dartanalyzer| + +------------------------------------------------------------------------------ +1. Analyzer *syntastic-dart-dartanalyzer* + +Name: dartanalyzer +Maintainer: Maksim Ryzhikov <rv.maksim@gmail.com> + +"Analyzer" is a static analysis tool for Dart (https://www.dartlang.org/). +See the manual for more information: + + https://www.dartlang.org/tools/analyzer/ + +Checker options~ + +This checker is initialised using the "makeprgBuild()" function and thus it +accepts the standard options described at |syntastic-config-makeprg|. + +============================================================================== +SYNTAX CHECKERS FOR DOCBOOK *syntastic-checkers-docbk* + +The following checkers are available for DocBook (filetype "docbk"): + + 1. Igor.....................|syntastic-docbk-igor| + 2. xmllint..................|syntastic-docbk-xmllint| + +------------------------------------------------------------------------------ +1. Igor *syntastic-docbk-igor* + +Name: igor +Maintainer: LCD 47 <lcd047@gmail.com> + +"Igor" is a proofreader for DocBook SGML, man pages, and text files used by +the FreeBSD project (https://www.freebsd.org/). See the author's presentation +for details: + + http://www.youtube.com/watch?v=sczHqUPygZY + +The latest version can be obtained from Glen Barber's repository: + + http://docscripts.glenbarber.us/tags/igor/ + +Checker options~ + +This checker is initialised using the "makeprgBuild()" function and thus it +accepts the standard options described at |syntastic-config-makeprg|. + +See also: |syntastic-nroff-igor|, |syntastic-text-igor|. + +------------------------------------------------------------------------------ +2. xmllint *syntastic-docbk-xmllint* + +Name: xmllint +Maintainer: Martin Grenfell <martin.grenfell@gmail.com> + +"xmllint" is a checker and transformer tool for XML files, distributed with +the "libxml" package (http://www.xmlsoft.org/). See the tool's manual for more +information: + + http://xmlsoft.org/xmllint.html + +Checker options~ + +This checker is initialised using the "makeprgBuild()" function and thus it +accepts the standard options described at |syntastic-config-makeprg|. + +Note~ + +You can use a local installation of DTDs to significantly speed up validation +and allow you to validate XML data without network access. See the +"xmlcatalog" manual, and the catalog documentation for more information: + + http://www.xmlsoft.org/xmlcatalog_man.html + http://www.xmlsoft.org/catalog.html + +For an example of a DTD catalog see f.i. "XMLCatalog": + + https://github.com/darcyparker/XMLCatalog + +In order to use it with syntastic you'll have to clone it to a local +directory, and point the environment variable "XML_CATALOG_FILES" to the file +"catalog.xml" in the said directory: > + XML_CATALOG_FILES=/some/path/XMLCatalog/catalog.xml + export XML_CATALOG_FILES +< +Otherwise "xmllint" will try to load XML catalogs from "/etc/xml/catalog". + +See also: |syntastic-xml-xmllint|, |syntastic-xslt-xmllint|. + +============================================================================== +SYNTAX CHECKERS FOR DOCKERFILE *syntastic-checkers-dockerfile* + +The following checkers are available for Dockerfile (filetype "dockerfile"): + + 1. dockerfile-lint..........|syntastic-dockerfile-dockerfile_lint| + +------------------------------------------------------------------------------ +1. dockerfile-lint *syntastic-dockerfile-dockerfile_lint* + +Name: dockerfile_lint +Maintainer: Tim Carry <tim@pixelastic.com> + +"dockerfile-lint" is a linter for Dockerfiles +(http://docs.docker.com/engine/reference/builder). See the project's page at +GitHub for details: + + https://github.com/projectatomic/dockerfile_lint + +Installation~ + +Install it with: > + npm install -g dockerfile_lint +< +Checker options~ + +This checker is initialised using the "makeprgBuild()" function and thus it +accepts the standard options described at |syntastic-config-makeprg|. + +============================================================================== +SYNTAX CHECKERS FOR DUST *syntastic-checkers-dustjs* + +The following checkers are available for Dust (filetype "dustjs"): + + 1. Swiffer..................|syntastic-dustjs-swiffer| + +------------------------------------------------------------------------------ +1. Swiffer *syntastic-dustjs-swiffer* + +Name: swiffer +Maintainer: Steven Foote <smfoote@gmail.com> + +"Swiffer" is a command line lint tool for Dust. See the project's page for +details: + + https://github.com/smfoote/Swiffer.js + +Checker options~ + +This checker is initialised using the "makeprgBuild()" function and thus it +accepts the standard options described at |syntastic-config-makeprg|. + +Note~ + +To enable Dust syntax checking, you must set the filetype of your Dust +template files to "dustjs". An easy way to do this is by installing the dustjs +syntax highlighter: + + https://github.com/jimmyhchan/dustjs.vim + +============================================================================== +SYNTAX CHECKERS FOR ELIXIR *syntastic-checkers-elixir* + +The following checkers are available for Elixir (filetype "elixir"): + + 1. elixir...................|syntastic-elixir-elixir| + +------------------------------------------------------------------------------ +1. elixir *syntastic-elixir-elixir* + +Name: elixir +Maintainer: Richard Ramsden <rramsden@gmail.com> + +See the project's page for details: + + http://elixir-lang.org/ + +Security~ + +This checker executes the code in the files it checks: + + https://github.com/scrooloose/syntastic/issues/1141 + +This is probably fine if you wrote the files yourself, but it can be a problem +if you're trying to check third party files. If you are 100% willing to let +Vim run the code in your files, set 'g:syntastic_enable_elixir_checker' to 1 +in your vimrc to enable this checker: > + let g:syntastic_enable_elixir_checker = 1 +< +There is also a buffer-local version of this variable, that takes precedence +over a global one in the buffers where it is defined. + +Please note that setting this variable doesn't automatically enable the +checker, you still need to add "elixir" to 'g:syntastic_elixir_checkers' if +you plan to use it. + +Checker options~ + +This checker is initialised using the "makeprgBuild()" function and thus it +accepts the standard options described at |syntastic-config-makeprg|. + +============================================================================== +SYNTAX CHECKERS FOR ERLANG *syntastic-checkers-erlang* + +The following checkers are available for Erlang (filetype "erlang"): + + 1. escript..................|syntastic-erlang-escript| + 2. SyntaxErl................|syntastic-erlang-syntaxerl| + +------------------------------------------------------------------------------ +1. escript *syntastic-erlang-escript* + +Name: escript +Maintainer: Pawel Salata <rockplayer.pl@gmail.com> + +"escript" is an interpreter for Erlang programs. See the tool's manual for +more information: + + http://www.erlang.org/doc/man/escript.html + +Checker options~ + +This checker is initialised using the "makeprgBuild()" function and thus it +accepts the standard options described at |syntastic-config-makeprg|. + +Note~ + +If you get warning: "behaviour X undefined" with your customize behaviour, add +the following line in your vimrc: > + let g:syntastic_erlc_include_path = "ebin" +< + +------------------------------------------------------------------------------ +2. SyntaxErl *syntastic-erlang-syntaxerl* + +Name: syntaxerl +Maintainer: locojay + +"SyntaxErl" is a syntax checker for Erlang. It uses "rebar" +(https://github.com/basho/rebar) to determine correct deps and libs paths. +See the project's page for more information: + + https://github.com/ten0s/syntaxerl + +Checker options~ + +This checker is initialised using the "makeprgBuild()" function and thus it +accepts the standard options described at |syntastic-config-makeprg|. + +============================================================================== +SYNTAX CHECKERS FOR ERUBY *syntastic-checkers-eruby* + +The following checkers are available for eRuby (filetype "eruby"): + + 1. Ruby.....................|syntastic-eruby-ruby| + +------------------------------------------------------------------------------ +1. Ruby *syntastic-eruby-ruby* + +Name: ruby +Maintainer: Martin Grenfell <martin.grenfell@gmail.com> + +Checker options~ + 'g:syntastic_ruby_exec' +Type: string +Default: "ruby" +The Ruby executable to use. + +Note~ + +The variable 'g:syntastic_ruby_exec' is also used by the Ruby +"MRI" checker (cf. |syntastic-ruby-mri|), and it can be overriden +by 'g:syntastic_eruby_ruby_exec'. However, this checker doesn't +call the "makeprgBuild()" function, and thus it ignores all other +'g:syntastic_eruby_ruby_<option>' variables. + +============================================================================== +SYNTAX CHECKERS FOR FORTRAN *syntastic-checkers-fortran* + +The following checkers are available for Fortran (filetype "fortran"): + + 1. GNU Fortran..............|syntastic-fortran-gfortran| + +------------------------------------------------------------------------------ +1. GNU Fortran *syntastic-fortran-gfortran* + +Name: gfortran +Maintainer: Karl Yngve Lervåg <karl.yngve@lervag.net> + +"GNU Fortran" is a checker for Fortran files using either GNU +Fortran (https://gcc.gnu.org/fortran/) or Intel Fortran Compilers +(https://software.intel.com/en-us/fortran-compilers). + +Checker options~ + *'g:syntastic_fortran_compiler'* +Type: string +Default: "gfortran" +Compiler executable. Set this to either "gfortran" (to use GNU Fortran), or to +"ifort" (for Intel Fortran). + + *'g:syntastic_fortran_errorformat'* +Type: string +Default: unset +Override for the default |'errorformat'|. + + *'g:syntastic_fortran_remove_include_errors'* +Type: boolean +Default: 0 +By default, errors in files included from the file being checked are shown. +Set this variable to 1 to remove messages about errors in included files. +Please note that this means syntastic will silently abort checks if there are +fatal errors in one of the included files. + + *'g:syntastic_fortran_compiler_options'* +Type: string +Default: unset +Compilation flags (such as "-std=f95") to be passed to the checker. + + *'g:syntastic_fortran_config_file'* +Type: string +Default: ".syntastic_fortran_config" +File containing additional compilation flags to be passed to the checker, one +option per line (cf. |syntastic-config-files|). + + *'g:syntastic_fortran_include_dirs'* +Type: array of strings +Default: [] +Include directories to be passed to the checker, in addition to the above +compilation flags. You can set it like this: > + let g:syntastic_fortran_include_dirs = ["includes", "headers"]" +< +and the corresponding "-Iincludes -Iheaders" will be added to the compilation +flags. + + *'b:syntastic_fortran_cflags'* +Type: string +Default: unset +Buffer-local variable. Additional compilation flags specific to the current +buffer. + +Note~ + +This checker doesn't call the "makeprgBuild()" function, and thus it ignores +the usual 'g:syntastic_fortran_gfortran_<option>' variables. The only +exception is 'g:syntastic_fortran_gfortran_exec', which can still be used to +override the checker's executable. + +============================================================================== +SYNTAX CHECKERS FOR GENTOO METADATA *syntastic-checkers-gentoo* + +The following checkers are available for Gentoo Metadata (filetype "gentoo"): + + 1. xmllint..................|syntastic-gentoo-xmllint| + +------------------------------------------------------------------------------ +1. xmllint *syntastic-gentoo-xmllint* + +Name: xmllint +Maintainer: James Rowe <jnrowe@gmail.com> + +Checker options~ + +This checker is initialised using the "makeprgBuild()" function and thus it +accepts the standard options described at |syntastic-config-makeprg|. + +Note~ + +The DTDs required to validate "metadata.xml" files are available in +"$PORTDIR/metadata/dtd", and these local files can be used to significantly +speed up validation. You can create a catalog file with: > + xmlcatalog --create --add rewriteURI http://www.gentoo.org/dtd/ \ + ${PORTDIR:-/usr/portage}/metadata/dtd/ /etc/xml/gentoo +< +See "xmlcatalog" for more information: + + http://www.xmlsoft.org/catalog.html + +============================================================================== +SYNTAX CHECKERS FOR GETTEXT PO *syntastic-checkers-po* + +The following checkers are available for gettext .po files (filetype "po"): + + 1. msgfmt...................|syntastic-po-msgfmt| + +------------------------------------------------------------------------------ +1. msgfmt *syntastic-po-msgfmt* + +Name: msgfmt +Maintainer: Ryo Okubo <syucream1031@gmail.com> + +"msgfmt" is a compiler for gettext Portable Object +(http://www.gnu.org/software/gettext/manual/html_node/PO-Files.html) +translation files. See the program's manual for details: + + http://www.gnu.org/software/gettext/manual/html_node/msgfmt-Invocation.html#msgfmt-Invocation + +Checker options~ + +This checker is initialised using the "makeprgBuild()" function and thus it +accepts the standard options described at |syntastic-config-makeprg|. + +============================================================================== +SYNTAX CHECKERS FOR GLSL *syntastic-checkers-glsl* + +The following checkers are available for GLSL (filetype "glsl"): + + 1. cgc......................|syntastic-glsl-cgc| + +------------------------------------------------------------------------------ +1. cgc *syntastic-glsl-cgc* + +Name: cgc +Maintainer: Joshua Rahm <joshuarahm@gmail.com> + +"cgc" is a compiler that translates Cg or GLSL programs into OpenGL or DirectX +code. See the manual for more details: + + http://http.developer.nvidia.com/Cg/cgc.html + +Checker options~ + +This checker is initialised using the "makeprgBuild()" function and thus it +accepts the standard options described at |syntastic-config-makeprg|. + +Additionally: + + *'g:syntastic_glsl_extensions'* +Type: dictionary +Default: unset + +You can control the profiles used by "cgc" with magic comments: put the magic +comment "// profile:" followed by the profile for "cgc" to use. For example +use > + // profile: glslf +< +to force the fragment shader profile. + +If the magic comment does not exist, then the dictionary +'g:syntastic_glsl_extensions' is used to infer the appropriate profile from +the current file's extension. If this dictionary does not exist either, a +default dictionary is used instead. Finally, if the current file's extension +cannott be found in these dictionaries, the checker assumes a vertex shader +profile. + + *'g:syntastic_glsl_options'* +Type: string +Default: unset +Additional arguments to pass to "cgc". + +============================================================================== +SYNTAX CHECKERS FOR GO *syntastic-checkers-go* + +The following checkers are available for Go (filetype "go"): + + 1. go.......................|syntastic-go-go| + 2. gofmt....................|syntastic-go-gofmt| + 3. Golint...................|syntastic-go-golint| + 4. Go Meta Linter...........|syntastic-go-gometalinter| + 5. gotype...................|syntastic-go-gotype| + 6. vet......................|syntastic-go-govet| + +------------------------------------------------------------------------------ +1. go *syntastic-go-go* + +Name: go +Maintainer: Kamil Kisiel <kamil@kamilkisiel.net> + +Checker options~ + +This checker is initialised using the "makeprgBuild()" function and thus it +accepts the standard options described at |syntastic-config-makeprg|. + +Additionally: + + *'g:syntastic_go_go_build_args'* +Type: string +Default: "-buildmode=archive" +arguments passed to "go build" + + *'g:syntastic_go_go_test_args'* +Type: string +Default: "-buildmode=archive" +arguments passed to "go test". + +Note~ + +This syntax checker does not reformat your source code. Use a |BufWritePre| +autocommand towards that end: > + autocmd FileType go autocmd BufWritePre <buffer> Fmt +< +------------------------------------------------------------------------------ +2. gofmt *syntastic-go-gofmt* + +Name: gofmt +Maintainer: Brandon Thomson <bt@brandonthomson.com> + +Checker options~ + +This checker is initialised using the "makeprgBuild()" function and thus it +accepts the standard options described at |syntastic-config-makeprg|. + +Note~ + +This syntax checker does not reformat your source code. Use a |BufWritePre| +autocommand towards that end: > + autocmd FileType go autocmd BufWritePre <buffer> Fmt +< +------------------------------------------------------------------------------ +3. Golint *syntastic-go-golint* + +Name: golint +Maintainer: Hiroshi Ioka <hirochachacha@gmail.com> + +"Golint" is a linter for Go. See the project's page for details: + + https://github.com/golang/lint + +Checker options~ + +This checker is initialised using the "makeprgBuild()" function and thus it +accepts the standard options described at |syntastic-config-makeprg|. + +------------------------------------------------------------------------------ +4. Go Meta Linter *syntastic-go-gometalinter* + +Name: gometalinter +Maintainer: Joshua Rubin <joshua@rubixconsulting.com> + +"Go Meta Linter" is a linter for Go. It runs a number of other linters +against your files, and normalises their output to a standard format. +See the project's page at GitHub for details: + + https://github.com/alecthomas/gometalinter + +Checker options~ + +This checker is initialised using the "makeprgBuild()" function and thus it +accepts the standard options described at |syntastic-config-makeprg|. + +------------------------------------------------------------------------------ +5. gotype *syntastic-go-gotype* + +Name: gotype +Maintainer: luz <ne.tetewi@gmail.com> + +See the tool's documentation for details: + + https://godoc.org/golang.org/x/tools/cmd/gotype + +------------------------------------------------------------------------------ +6. vet *syntastic-go-govet* + +Name: govet +Maintainer: Kamil Kisiel <kamil@kamilkisiel.net> + +See the tool's documentation for details: + + https://godoc.org/golang.org/x/tools/cmd/vet + +Note~ + +This checker doesn't call the "makeprgBuild()" function, and thus it ignores +the usual 'g:syntastic_go_govet_<option>' variables. + +============================================================================== +SYNTAX CHECKERS FOR HAML *syntastic-checkers-haml* + +The following checkers are available for Haml (filetype "haml"): + + 1. Haml.....................|syntastic-haml-haml| + 2. HAML-Lint................|syntastic-haml-haml_lint| + +------------------------------------------------------------------------------ +1. Haml *syntastic-haml-haml* + +Name: haml +Maintainer: Martin Grenfell <martin.grenfell@gmail.com> + +See the project's page for details: + + http://haml.info/ + +Checker options~ + +This checker is initialised using the "makeprgBuild()" function and thus it +accepts the standard options described at |syntastic-config-makeprg|. + +------------------------------------------------------------------------------ +2. HAML-Lint *syntastic-haml-haml_lint* + +Name: haml_lint +Maintainer: Shane da Silva <shane@dasilva.io> + +"HAML-Lint" is a checker for HAML files. See the project's page for details: + + https://github.com/causes/haml-lint + +Checker options~ + +This checker is initialised using the "makeprgBuild()" function and thus it +accepts the standard options described at |syntastic-config-makeprg|. + +============================================================================== +SYNTAX CHECKERS FOR HANDLEBARS *syntastic-checkers-handlebars* + +The following checkers are available for Handlebars (filetype "handlebars"): + + 1. Handlebars...............|syntastic-handlebars-handlebars| + +------------------------------------------------------------------------------ +1. Handlebars *syntastic-handlebars-handlebars* + +Name: handlebars +Maintainer: Jeremy Mack + +"Handlebars" is a JavaScript library for building semantic templates. See the +project's page for details: + + http://handlebarsjs.com/ + +Checker options~ + +This checker is initialised using the "makeprgBuild()" function and thus it +accepts the standard options described at |syntastic-config-makeprg|. + +Note~ + +You probably also need a plugin to set |filetype| for Handlebars files, such as +"vim-mustache-handlebars": + + https://github.com/mustache/vim-mustache-handlebars + +============================================================================== +SYNTAX CHECKERS FOR HASKELL *syntastic-checkers-haskell* + +The following checkers are available for Haskell (filetype "haskell"): + + 1. hdevtools................|syntastic-haskell-hdevtools| + 2. HLint....................|syntastic-haskell-hlint| + 3. Style scanner............|syntastic-haskell-scan| + +------------------------------------------------------------------------------ +1. hdevtools *syntastic-haskell-hdevtools* + +Name: hdevtools +Maintainer: Anthony Carapetis <anthony.carapetis@gmail.com> + +"hdevtools" is a backend for text editor plugins. See the project's page at +GitHub for details: + + https://github.com/bitc/hdevtools/ + +Checker options~ + +This checker is initialised using the "makeprgBuild()" function and thus it +accepts the standard options described at |syntastic-config-makeprg|. + +Note~ + +If you're checking files containing tab characters, then Vim's 'tabstop' +must match "hdevtools"'s idea of tabstop, otherwise column numbers will be +shifted. At the time of this writing, "hdevtools"'s tabstop is hardcoded to 8, +so you should probably add something like this to your vimrc: > + set tabstop=8 +< +------------------------------------------------------------------------------ +2. HLint *syntastic-haskell-hlint* + +Name: hlint +Maintainer: Nicolas Wu <nicolas.wu@gmail.com> + +"HLint" is a linter and style checker for Haskell. See the project's page for +details: + + http://community.haskell.org/~ndm/hlint/ + +Checker options~ + +This checker is initialised using the "makeprgBuild()" function and thus it +accepts the standard options described at |syntastic-config-makeprg|. + +Note~ + +If you're checking files containing tab characters, Vim's 'tabstop' must +match "HLint"'s idea of tabstop, otherwise column numbers will be shifted. At +the time of this writing "HLint"'s tabstop is hardcoded to 8, so you should +probably add something like this to your vimrc: > + set tabstop=8 +< +------------------------------------------------------------------------------ +3. Style scanner *syntastic-haskell-scan* + +Name: scan +Maintainer: LCD 47 <lcd047@gmail.com> + +"Style scanner" is a style checker for Haskell. See the project's page for +details: + + http://projects.haskell.org/style-scanner/ + +Checker options~ + +This checker is initialised using the "makeprgBuild()" function and thus it +accepts the standard options described at |syntastic-config-makeprg|. + +Note~ + +If you're checking files containing tab characters, Vim's 'tabstop' must +match "Style scanner"'s idea of tabstop, otherwise column numbers will be +shifted. At the time of this writing "Style scanner"'s tabstop is hardcoded to +8, so you should probably add something like this to your vimrc: > + set tabstop=8 +< +============================================================================== +SYNTAX CHECKERS FOR HAXE *syntastic-checkers-haxe* + +The following checkers are available for Haxe (filetype "haxe"): + + 1. Haxe.....................|syntastic-haxe-haxe| + +------------------------------------------------------------------------------ +1. Haxe *syntastic-haxe-haxe* + +Name: haxe +Maintainer: David Bernard <david.bernard.31@gmail.com> + +"Haxe" is a programming language and compiler that can produce applications +and source code for multiple different platforms from a single code-base. See +the project's page for details: + + http://haxe.org/ + +Checker options~ + +This checker is initialised using the "makeprgBuild()" function and thus it +accepts the standard options described at |syntastic-config-makeprg|. + +Additionally: + + *'g:vaxe_hxml'* + *'b:vaxe_hxml'* +Type: string +Default: unset +By default the checker will search parent folders for "hxml" files, and +use the first one it finds. You can override that behaviour by pointing +'g:vaxe_hxml' or 'b:vaxe_hxml' to a specific build file. Those variables can +also be set by Vaxe: + + https://github.com/jdonaldson/vaxe + +============================================================================== +SYNTAX CHECKERS FOR HSS *syntastic-checkers-hss* + +The following checkers are available for HSS (filetype "hss"): + + 1. HSS......................|syntastic-hss-hss| + +------------------------------------------------------------------------------ +1. HSS *syntastic-hss-hss* + +Name: hss +Maintainer: Justin Donaldson <jdonaldson@gmail.com> + +"HSS" is a tool that extends the CSS syntax with features such as variables +and nested blocks. See the project's page for details: + + http://ncannasse.fr/projects/hss + +Checker options~ + +This checker is initialised using the "makeprgBuild()" function and thus it +accepts the standard options described at |syntastic-config-makeprg|. + +============================================================================== +SYNTAX CHECKERS FOR HTML *syntastic-checkers-html* + +The following checkers are available for HTML (filetype "html"): + + 1. ESLint...................|syntastic-html-eslint| + 2. gjslint..................|syntastic-html-gjslint| + 3. HTML tidy................|syntastic-html-tidy| + 4. JSHint...................|syntastic-html-jshint| + 5. textlint.................|syntastic-html-textlint| + 6. Validator................|syntastic-html-validator| + 7. W3.......................|syntastic-html-w3| + +------------------------------------------------------------------------------ +1. ESLint *syntastic-html-eslint* + +Name: eslint +Maintainer: LCD 47 <lcd047@gmail.com> + +"ESLint" is a tool for identifying and reporting on patterns found in +ECMAScript/JavaScript code. It can also detect problems in JavaScript code +embedded in HTML files. See the project's page for details: + + https://github.com/nzakas/eslint + +Checker options~ + +This checker is initialised using the "makeprgBuild()" function and thus it +accepts the standard options described at |syntastic-config-makeprg|. + +Note~ + +You can also use "eslint_d" (https://github.com/mantoni/eslint_d.js), version +2.1.0 or later, instead of "ESLint". Just point 'g:syntastic_html_eslint_exec' +to it: + + https://github.com/mantoni/eslint_d.js#editor-integration + +See also: |syntastic-javascript-eslint|, |syntastic-typescript-eslint|. + +------------------------------------------------------------------------------ +2. gjslint *syntastic-html-gjslint* + +Name: gjslint +Maintainer: Martin Grenfell <martin.grenfell@gmail.com> + +"Closure Linter", or "gjslint", is a style checker for JavaScript. It can also +detect problems in HTML files. See the project's page for more information: + + https://developers.google.com/closure/utilities/ + +Checker options~ + +This checker is initialised using the "makeprgBuild()" function and thus it +accepts the standard options described at |syntastic-config-makeprg|. + +See also: |syntastic-javascript-gjslint|. + +------------------------------------------------------------------------------ +3. HTML tidy *syntastic-html-tidy* + +Name: tidy +Maintainer: Martin Grenfell <martin.grenfell@gmail.com> + +"HTML Tidy" is a syntax checker and formatter for HTML. See the project's page +for more information: + + http://www.html-tidy.org/ + +Checker options~ + +This checker is initialised using the "makeprgBuild()" function and thus it +accepts the standard options described at |syntastic-config-makeprg|. + +Additionally: + + *'g:syntastic_html_tidy_ignore_errors'* +Type: array of strings +Default: [] +List of errors to ignore. Case-sensitive patterns matched as substrings +(not regular expressions) against the error messages. See also +|'syntastic_quiet_messages'|. + + *'g:syntastic_html_tidy_blocklevel_tags'* +Type: array of strings +Default: [] +List of additional blocklevel tags to be added to "--new-blocklevel-tags". + + *'g:syntastic_html_tidy_inline_tags'* +Type: array of strings +Default: [] +List of additional inline tags to be added to "--new-inline-tags". + + *'g:syntastic_html_tidy_empty_tags'* +Type: array of strings +Default: [] +List of additional empty tags, to be added to "--new-empty-tags". + +See also: |syntastic-xhtml-tidy|. + +------------------------------------------------------------------------------ +4. jshint *syntastic-html-jshint* + +Name: JSHint +Maintainer: LCD 47 <lcd047@gmail.com> + +"JSHint" can detect JavaScript errors and potential problems in HTML +files. See the project's page for details: + + http://jshint.com/ + +Syntastic requires "JSHint" version 2.4.0 or later. + +Checker options~ + +This checker is initialised using the "makeprgBuild()" function and thus it +accepts the standard options described at |syntastic-config-makeprg|. + +Note~ + +If you're checking files containing tab characters then "JSHint"'s idea of +tabstop must match Vim's 'tabstop', otherwise syntastic will highlight the +errors at shifted positions. By default "JSHint"'s tabstop is 4, while Vim's +default 'tabstop' is 8. + +In order to change "JSHint"'s tabstop you have to change its "indent" config +option (cf. http://jshint.com/docs/options/#indent). One way to do that is +to put it in a file named ".jshintrc" in the current directory, the parent +directories, or your home directory. The file is supposed to be in JSON +format. For example: > + { + "indent": 8 + } +< +See JSHint documentation for more details: + + http://jshint.com/docs/ + +Please note however that setting "indent" also triggers the indentation checks +in "JSHint". If that is undesirable, your only other option is to leave +"JSHint"'s tabstop alone, and change Vim's 'tabstop' to 4. To change Vim's +'tabstop', you can add this to your vimrc: > + set tabstop=4 +< +See also: |syntastic-javascript-jshint|, |syntastic-xhtml-jshint|. + +------------------------------------------------------------------------------ +5. textlint *syntastic-html-textlint* + +Name: textlint +Maintainer: LCD 47 <lcd047@gmail.com> + +"textlint" is a natural language linter for text, Markdown, and HTML files. +See the project's page for details: + + https://textlint.github.io/ + +Checker options~ + +This checker is initialised using the "makeprgBuild()" function and thus it +accepts the standard options described at |syntastic-config-makeprg|. + +Note~ + +You need to install both "textlint" and the "textlint HTML" plugin for this to +work: + + https://github.com/textlint/textlint-plugin-html + +See also: |syntastic-markdown-textlint|, |syntastic-text-textlint|. + +------------------------------------------------------------------------------ +6. Validator *syntastic-html-validator* + +Name: validator +Maintainer: LCD 47 <lcd047@gmail.com> + +"Validator" is a non-DTD-based HTML checker. See the project's page for +details: + + http://validator.github.io/validator/ + +As a syntastic checker, you can validate your files against the online service +(see https://validator.nu/), or you can install "vnu.jar": + + https://github.com/validator/validator/releases/latest + +then run it as a HTTP server: > + $ java -Xss512k -cp /path/to/vnu.jar nu.validator.servlet.Main 8888 +< +Requirement~ + +This checker uses cURL: + + http://curl.haxx.se/ + +Checker options~ + + *'g:syntastic_html_validator_api'* +Type: string +Default: "http://validator.nu/" +URL of the service to use for checking. Leave it to the default to run the +checks against "https://validator.nu/", or set it to "http://localhost:8888/" +if you have "vnu.jar" installed, and you're running it as a standalone HTTP +server. See: + + http://validator.github.io/validator/#standalone + + *'g:syntastic_html_validator_parser'* +Type: string +Default: empty +Parser to use. Legal values are: "xml", "xmldtd", "html", "html5", "html4", +and "html4tr". Set it to "html5" to check HTML5 files. References: + + https://wiki.whatwg.org/wiki/Validator.nu_Common_Input_Parameters#parser + + *'g:syntastic_html_validator_nsfilter'* +Type: string +Default: empty +Sets the "nsfilter" for the parser. See: + + https://wiki.whatwg.org/wiki/Validator.nu_Common_Input_Parameters#nsfilter + + *'g:syntastic_html_validator_exec'* +Type: string +Default: "curl" +Path to the "cURL" executable. Override it with a full path if your "cURL" is +not installed in a standard location. + +This checker doesn't call the "makeprgBuild()" function, and thus it ignores +the usual 'g:syntastic_html_validator_<option>' variables. The only exception +is 'g:syntastic_html_validator_exec', which can be used to override the path +to the "cURL" executable. + +Note~ + +Non-zero exit codes from "cURL" are typically network errors, and are signaled +by syntastic with messages such as: > + syntastic: error: checker html/validator returned abnormal status 26 +< +You can lookup the meaning of these codes in cURL's manual: + + http://curl.haxx.se/docs/manpage.html#EXIT + +------------------------------------------------------------------------------ +7. W3 *syntastic-html-w3* + +Name: w3 +Maintainer: Martin Grenfell <martin.grenfell@gmail.com> + +"W3" is the W3C Markup Validator for HTML. See the project's page for +details: + + https://validator.w3.org/source/ + +As a syntastic checker, you can validate your files against the online service +(see http://validator.w3.org/), or you can install it from sources and run it +as a local service: + + https://github.com/w3c/markup-validator/ + +Requirement~ + +This checker uses cURL: + + http://curl.haxx.se/ + +Checker options~ + + *'g:syntastic_html_w3_api'* +Type: string +Default: "http://validator.w3.org/check" +URL of the service to use for checking. Leave it to the default to +run the checks against "http://validator.w3.org/", or set it to +"http://localhost/w3c-validator/check" if you're running a local service. + + *'g:syntastic_html_w3_exec'* +Type: string +Default: "curl" +Path to the "cURL" executable. Override it with a full path if your "cURL" is +not installed in a standard location. + +This checker doesn't call the "makeprgBuild()" function, and thus it ignores +the usual 'g:syntastic_html_w3_<option>' variables. The only exception is +'g:syntastic_html_w3_exec', which can be used to override the path to the +"cURL" executable. + +Note~ + +Non-zero exit codes from "cURL" are typically network errors, and are signaled +by syntastic with messages such as: > + syntastic: error: checker html/validator returned abnormal status 26 +< +You can lookup the meaning of these codes in cURL's manual: + + http://curl.haxx.se/docs/manpage.html#EXIT + +============================================================================== +SYNTAX CHECKERS FOR JAVA *syntastic-checkers-java* + +The following checkers are available for Java (filetype "java"): + + 1. checkstyle...............|syntastic-java-checkstyle| + 2. javac....................|syntastic-java-javac| + +------------------------------------------------------------------------------ +1. checkstyle *syntastic-java-checkstyle* + +Name: checkstyle +Maintainer: Dmitry Geurkov <d.geurkov@gmail.com> + +"Checkstyle" is a style checker for Java. See the project's page for details: + + http://checkstyle.sourceforge.net/ + +Checker options~ + +This checker is initialised using the "makeprgBuild()" function and thus it +accepts the standard options described at |syntastic-config-makeprg|. + +Additionally: + + *'g:syntastic_java_checkstyle_classpath'* +Type: string +Default: "checkstyle-6.10.1-all.jar" +Classpath to use. Multiple files are allowed. + + *'g:syntastic_java_checkstyle_conf_file'* +Type: string +Default: "sun_checks.xml" +Path to the configuration file for the "-c" option (cf. +http://checkstyle.sourceforge.net/cmdline.html#Command_line_usage). + + +Notes~ + +1. The checker was tested with "checkstyle" version 5.5. If you're using +it with version 5.6 or later you should remove DoubleCheckedLocking from +your configuration file: + + http://stackoverflow.com/a/12798807/1658042 + +2. At the time of this writing, the "checkstyle" checker doesn't distinguish +between error severity levels. All messages are treated as errors, regardless +of their severity defined in the "checkstyle" config file. + +3. You can specify a property file: > + let g:syntastic_java_checkstyle_post_args = + \ ["-p", "/path/to/checkstyle.properties"] +< +4. You probably want to download the "fat jar" "checkstyle-*-all.jar" and +point |'g:syntastic_java_checkstyle_classpath'| to it: + + http://iweb.dl.sourceforge.net/project/checkstyle/checkstyle/ + http://checkstyle.sourceforge.net/cmdline.html#Usage_by_Classpath_update + +Current builds at Maven Central do not package "checkstyles" with its +dependencies: + + http://search.maven.org/#search|gav|1|g%3A%22com.puppycrawl.tools%22%20AND%20a%3A%22checkstyle%22 + +However, |'g:syntastic_java_checkstyle_classpath'| accepts multiple files if +you want to include the "checkstyle" jar and all of its dependencies. + +------------------------------------------------------------------------------ +2. javac *syntastic-java-javac* + +Name: javac +Maintainers: Jochen Keil <jochen.keil@gmail.com> + Dmitry Geurkov <d.geurkov@gmail.com> + +Commands~ + +The following commands are available: + + *:SyntasticJavacEditClasspath* +This opens a new window where you can specify a classpath. Individual paths +may be specified one per line, or separated by colons ":" on UNIX, or by +semicolons ";" on Windows. + + *:SyntasticJavacEditConfig* +This command relevant only if |'g:syntastic_java_javac_config_file_enabled'| +is set. It opens a buffer where you can specify project-specific options from +the list below. These options will be saved in a file pointed to by +|'g:syntastic_java_javac_config_file'| (".syntastic_javac_config" by default). +Set |'g:syntastic_java_javac_config_file'| to a full path to use a +project-wide configuration file, rather than a file in the current directory. +The settings have to be specified as Vim commands. + +Checker options~ + +This checker is initialised using the "makeprgBuild()" function and thus it +accepts the standard options described at |syntastic-config-makeprg|. + +Additionally: + + *'g:syntastic_java_javac_executable'* +Type: string +Default: "javac" +Compiler executable used for checking files. + + *'g:syntastic_java_maven_executable'* +Type: string +Default: "mvn" +Maven executable used for loading classpath for "maven" projects. + + *'g:syntastic_java_javac_options'* +Type: string +Default: "-Xlint" +Options for "javac". + + *'g:syntastic_java_javac_classpath'* +Type: string +Default: "" +Classpath. It can be changed by running the `:SyntasticJavacEditClasspath` +command. + + *'g:syntastic_java_javac_delete_output'* +Type: boolean +Default: 1 +When set the checker will delete the ".class" files created by "javac". + + *'g:syntastic_java_javac_autoload_maven_classpath'* +Type: boolean +Default: 1 +If enabled and a file "pom.xml" is found in the current working directory, +"maven" is used to load classpath. + + *'g:syntastic_java_javac_config_file'* +Type: string +Default: ".syntastic_javac_config" +Path to the configuration file used by "javac". As usual, if a filename is +specified rather than a full path, the file is created and looked for in the +current directory. + + *'g:syntastic_java_javac_config_file_enabled'* +Type: boolean +Default: 0 +When enabled, the classpath is written to the file pointed to by +|'g:syntastic_java_javac_config_file'|. The file is created as needed. +You can edit this file with the `:SyntasticJavacEditClasspath` command. +The change will take effect next time you run the checker. + + *'g:syntastic_java_javac_custom_classpath_command'* +Type: string +Default: "" +Custom command to run in order to get the classpath. The command classpath +output can be in traditional Java form, or specified on separate lines. +"%file_path%", "%FILE_NAME%", and "%FILE_DIR%" are expanded to the current +file's full path, filename, and base directory respectively, all of them +escaped for use in a shell command. + +Using Ant~ + +When using "ant" (http://ant.apache.org/) you can have a custom build target +(named for example "path") that will output your project's classpath. You can +then use `:SyntasticJavacEditConfig` and add the following line to use it with +"javac" checker: > + let g:syntastic_java_javac_custom_classpath_command = + \ "ant -q path | grep echo | cut -f2- -d] | tr -d ' ' | tr ':' '\n'" +< +Using Gradle~ + +For "Gradle" projects (http://gradle.org/) you might consider using +"gradle-syntastic-plugin": + + https://github.com/Scuilion/gradle-syntastic-plugin + +This will write the relevant classpath to a file ".syntastic_javac_config". + +============================================================================== +SYNTAX CHECKERS FOR JAVASCRIPT *syntastic-checkers-javascript* + +The following checkers are available for JavaScript (filetype "javascript"): + + 1. Closure Compiler.........|syntastic-javascript-closurecompiler| + 2. ESLint...................|syntastic-javascript-eslint| + 3. Flow.....................|syntastic-javascript-flow| + 4. gjslint..................|syntastic-javascript-gjslint| + 5. JavaScript Lint..........|syntastic-javascript-jsl| + 6. JSCS.....................|syntastic-javascript-jscs| + 7. JSHint...................|syntastic-javascript-jshint| + 8. JSLint...................|syntastic-javascript-jslint| + 9. JSXHint..................|syntastic-javascript-jsxhint| + 10. mixedindentlint.........|syntastic-javascript-mixedindentlint| + 11. standard................|syntastic-javascript-standard| + 12. tern-lint...............|syntastic-javascript-tern_lint| + +------------------------------------------------------------------------------ +1. Closure Compiler *syntastic-javascript-closurecompiler* + +Name: closurecompiler +Maintainer: Motohiro Takayama <mootoh@gmail.com> + +"Closure Compiler" is a compiler for JavaScript maintained by Google. See the +project's page for details: + + https://developers.google.com/closure/compiler/ + +Checker options~ + +This checker is initialised using the "makeprgBuild()" function and thus it +accepts the standard options described at |syntastic-config-makeprg|. + +Additionally: + + *'g:syntastic_javascript_closurecompiler_path'* +Type: string +Default: unset +Path to "google-closure-compiler.jar" + + *'g:syntastic_javascript_closurecompiler_script'* +Type: string +Default: unset +Path to a "closurecompiler" executable script. + +Note~ + +In order to enable the checker you have to set exactly one of the options +above. If you have a package manager (such as "Homebrew") that installs a +shell script that runs "Closure Compiler", point +|'g:syntastic_javascript_closurecompiler_script'| to that script. Otherwise +set |'g:syntastic_javascript_closurecompiler_path'| to point to the "Closure +Compiler" jar file. + +------------------------------------------------------------------------------ +2. ESLint *syntastic-javascript-eslint* + +Name: eslint +Maintainer: Maksim Ryzhikov <rv.maksim@gmail.com> + +"ESLint" is a tool for identifying and reporting on patterns found in +ECMAScript/JavaScript code. See the project's page for details: + + https://github.com/nzakas/eslint + +Checker options~ + +This checker is initialised using the "makeprgBuild()" function and thus it +accepts the standard options described at |syntastic-config-makeprg|. + +Note~ + +You can also use "eslint_d" (https://github.com/mantoni/eslint_d.js), +version 2.1.0 or later, instead of "ESLint". Just point +'g:syntastic_javascript_eslint_exec' to it: + + https://github.com/mantoni/eslint_d.js#editor-integration + +See also: |syntastic-html-eslint|, |syntastic-typescript-eslint|. + +------------------------------------------------------------------------------ +3. Flow *syntastic-javascript-flow* + +Name: flow +Maintainer: Michael Robinson <mike@pagesofinterest.net> + +"Flow" is a static type checker for JavaScript, written by Facebook. See the +project's page for details: + + http://flowtype.org/ + +Checker options~ + +This checker is initialised using the "makeprgBuild()" function and thus it +accepts the standard options described at |syntastic-config-makeprg|. + +Notes~ + +Syntastic requires "Flow" version 0.6 or later. + +To use "Flow" with your projects, you must: + +a. Install it: + + https://github.com/sindresorhus/flow-bin + +b. Configure your project: +> + cd /path/to/your/project + flow init +< +c. Read the docs to find out more. It won't work out of the box. + + http://flowtype.org/docs/existing.html + +------------------------------------------------------------------------------ +4. gjslint *syntastic-javascript-gjslint* + +Name: gjslint +Maintainer: Martin Grenfell <martin.grenfell@gmail.com> + +"Closure Linter", or "gjslint", is a style checker for JavaScript. See the +project's page for more information: + + https://developers.google.com/closure/utilities/ + +Checker options~ + +This checker is initialised using the "makeprgBuild()" function and thus it +accepts the standard options described at |syntastic-config-makeprg|. + +See also: |syntastic-html-gjslint|. + +------------------------------------------------------------------------------ +5. JavaScript Lint *syntastic-javascript-jsl* + +Name: jsl +Maintainer: Martin Grenfell <martin.grenfell@gmail.com> + +For details about "JavaScript Lint" see the project's page: + + http://www.javascriptlint.com/ + +Checker options~ + +This checker is initialised using the "makeprgBuild()" function and thus it +accepts the standard options described at |syntastic-config-makeprg|. + +------------------------------------------------------------------------------ +6. JSCS *syntastic-javascript-jscs* + +Name: jscs +Maintainer: LCD 47 <lcd047@gmail.com> + +"JSCS" is a code style checker for JavaScript. See the project's page for +more information: + + https://github.com/mdevils/node-jscs + +Syntastic requires "JSCS" version 0.2.0 or later. + +Checker options~ + +This checker is initialised using the "makeprgBuild()" function and thus it +accepts the standard options described at |syntastic-config-makeprg|. + +------------------------------------------------------------------------------ +7. JSHint *syntastic-javascript-jshint* + +Name: jshint +Maintainer: Martin Grenfell <martin.grenfell@gmail.com> + +"JSHint" is a tool to detect errors and potential problems in JavaScript +files. See the project's page for details: + + http://jshint.com/ + +Syntastic requires "JSHint" version 1.0.0 or later. + +Checker options~ + +This checker is initialised using the "makeprgBuild()" function and thus it +accepts the standard options described at |syntastic-config-makeprg|. + +Notes~ + +If you're checking files containing tab characters then "JSHint"'s idea of +tabstop must match Vim's 'tabstop', otherwise syntastic will highlight the +errors at shifted positions. By default "JSHint"'s tabstop is 4, while Vim's +default 'tabstop' is 8. + +In order to change "JSHint"'s tabstop you have to change its "indent" config +option (cf. http://jshint.com/docs/options/#indent). One way to do that is +to put it in a file named ".jshintrc" in the current directory, the parent +directories, or your home directory. The file is supposed to be in JSON +format. For example: > + { + "indent": 8 + } +< +See JSHint documentation for more details: + + http://jshint.com/docs/ + +Please note however that setting "indent" also triggers the indentation checks +in "JSHint". If that is undesirable, your only other option is to leave +"JSHint"'s tabstop alone, and change Vim's 'tabstop' to 4. To change Vim's +'tabstop', you can add this to your vimrc: > + set tabstop=4 +< +See also: |syntastic-html-jshint|, |syntastic-xhtml-jshint|. + +------------------------------------------------------------------------------ +8. JSLint *syntastic-javascript-jslint* + +Name: jslint +Maintainer: Martin Grenfell <martin.grenfell@gmail.com> + +"JSLint" is a code quality checker for JavaScript. See the program's page for +details: + + http://www.jslint.com/ + +Checker options~ + +This checker is initialised using the "makeprgBuild()" function and thus it +accepts the standard options described at |syntastic-config-makeprg|. + +Note~ + +By default the checker calls "JSLint" with these options: > + --white --nomen --regexp --plusplus --bitwise --newcap --sloppy --vars +< +This can be changed by setting 'g:syntastic_javascript_jslint_args' in your +vimrc to your own list of options, for example: > + let g:syntastic_javascript_jslint_args = + \ "--nomen --regexp --browser --devel --windows --sloppy --vars" +< +Setting this variable to the empty string "" is allowed, and instructs +syntastic to call "JSLint" with no options. + +------------------------------------------------------------------------------ +9. JSXHint *syntastic-javascript-jsxhint* + +Name: JSXHint +Maintainer: Thomas Boyt <me@thomasboyt.com> + +"JSXHint" is a wrapper around JSHint (http://jshint.com/) for +linting JSX syntax, which is inline markup-in-JS used by React +(http://facebook.github.io/react/docs/getting-started.html). + +See the project's page for details: + + https://github.com/strml/jsxhint + +Checker options~ + +This checker is initialised using the "makeprgBuild()" function and thus it +accepts the standard options described at |syntastic-config-makeprg|. + +Installation~ + +Install it with "npm": > + npm install -g jsxhint +< +Syntastic requires "JSXHint" version v0.4.1 or later. You also need "JSHint" +v1.1.0 or later. + +Note~ + +Since "JSXHint" is a wrapper around JSHint, the following note relevant to +the latter still applies: + +If you're checking files containing tab characters then JSHint's idea of +tabstop must match Vim's 'tabstop', otherwise syntastic will highlight the +errors at shifted positions. By default JSHint's tabstop is 4, while Vim's +default 'tabstop' is 8. + +In order to change "JSHint"'s tabstop you have to change its "indent" config +option (http://jshint.com/docs/options/#indent). One way to do that is to +put it in a file named ".jshintrc" in the current directory, the parent +directories, or your home directory. The file is supposed to be in JSON +format. For example: > + { + "indent": 8 + } +< +See JSHint documentation for more details: + + http://jshint.com/docs/ + +Please note however that setting "indent" also triggers the indentation checks +in JSHint. If that is undesirable, your only other option is to leave JSHint's +tabstop alone, and change Vim's 'tabstop' to 4. To change Vim's 'tabstop', you +can add this to your 'vimrc': > + set tabstop=4 +< +Alternative~ + +"JSXHint" will not show JSX-related errors in syntastic, because failed JSX +compiles will result in the uncompiled data being passed to JSHint: + + https://github.com/STRML/JSXHint/issues/45 + +To get around this, "Syntastic-React" can be used as a replacement for +"JSXHint": + + https://github.com/jaxbot/syntastic-react + +------------------------------------------------------------------------------ +10. mixedindentlint *syntastic-javascript-mixedindentlint* + +Name: mixedindentlint +Maintainer: Payton Swick <payton@foolord.com> + +"mixedindentlint" is a general-purpose indentation checker. See the project's +page at GitHub for more information: + + https://github.com/sirbrillig/mixedindentlint + +Checker options~ + +This checker is initialised using the "makeprgBuild()" function and thus it +accepts the standard options described at |syntastic-config-makeprg|. + +See also: |syntastic-css-mixedindentlint|, |syntastic-scss-mixedindentlint|. + +------------------------------------------------------------------------------ +11. standard *syntastic-javascript-standard* + +Name: standard +Maintainer: LCD 47 <lcd047@gmail.com> + +"Standard" is a code style checker for JavaScript. See the project's page for +more information: + + https://github.com/feross/standard + +Checker options~ + +This checker is initialised using the "makeprgBuild()" function and thus it +accepts the standard options described at |syntastic-config-makeprg|. + +Additionally: + + *'g:syntastic_javascript_standard_generic'* +Type: boolean +Default: 0 +Flag that can be used to disable version checks for "standard". + +Note~ + +Most forks of "standard" can also be used with syntastic. Just +set 'g:syntastic_javascript_standard_generic' to 1, and point +'g:syntastic_javascript_standard_exec' to the fork's executable. For +example to use happiness (https://github.com/JedWatson/happiness) instead of +"standard": > + let g:syntastic_javascript_checkers = ["standard"] + let g:syntastic_javascript_standard_exec = "happiness" + let g:syntastic_javascript_standard_generic = 1 +< +------------------------------------------------------------------------------ +12. tern-lint *syntastic-javascript-tern_lint* + +Name: tern_lint +Maintainer: LCD 47 <lcd047@gmail.com> + +"tern-lint" is a static type checker for JavaScript. See the project's page +for more information: + + https://github.com/angelozerr/tern-lint + +Syntastic requires a version of Vim compiled with the |+byte_offset| feature +to use this checker. + +Checker options~ + +This checker is initialised using the "makeprgBuild()" function and thus it +accepts the standard options described at |syntastic-config-makeprg|. + +Note~ + +"tern-lint" recursively scans files starting from (Vim's idea of) the current +directory, regardless of the current file. + +============================================================================== +SYNTAX CHECKERS FOR JSON *syntastic-checkers-json* + +The following checkers are available for JSON (filetype "json"): + + 1. JSONLint.................|syntastic-json-jsonlint| + 2. jsonval..................|syntastic-json-jsonval| + +------------------------------------------------------------------------------ +1. JSONLint *syntastic-json-jsonlint* + +Name: jsonlint +Maintainer: Miller Medeiros <contact@millermedeiros.com> + +"JSONLint" is a validator for JSON. See the project's page for details: + + http://jsonlint.com/ + +Installation~ + +Install it with: > + npm install -g jsonlint +< +Checker options~ + +This checker is initialised using the "makeprgBuild()" function and thus it +accepts the standard options described at |syntastic-config-makeprg|. + +------------------------------------------------------------------------------ +2. jsonval *syntastic-json-jsonval* + +Name: jsonval +Maintainer: Miller Medeiros <contact@millermedeiros.com> + +"jsonval" is a validator for JSON. See the project's page at GitHub for +details: + + https://github.com/dangerousben/jsonval + +Checker options~ + +This checker is initialised using the "makeprgBuild()" function and thus it +accepts the standard options described at |syntastic-config-makeprg|. + +============================================================================== +SYNTAX CHECKERS FOR LESS *syntastic-checkers-less* + +The following checkers are available for LESS (filetype "less"): + + 1. lessc....................|syntastic-less-lessc| + 2. RECESS...................|syntastic-less-recess| + +------------------------------------------------------------------------------ +1. lessc *syntastic-less-lessc* + +Name: lessc +Maintainer: Julien Blanchard <julien@sideburns.eu> + +"lessc" is a compiler for LESS. See the project's page for details: + + http://lesscss.org/ + +Checker options~ + +This checker is initialised using the "makeprgBuild()" function and thus it +accepts the standard options described at |syntastic-config-makeprg|. + +Additionally: + *'g:syntastic_less_use_less_lint'* +Type: boolean +Default: 0 +Flag that can be set to instruct syntastic to run "less-lint" instead of +"less". + +------------------------------------------------------------------------------ +2. RECESS *syntastic-less-recess* + +Name: recess +Maintainer: Tim Carry <tim@pixelastic.com> + +"RECESS" is a code quality tool for CSS built on top of LESS. See the +project's page for details: + + http://twitter.github.io/recess/ + +Checker options~ + +This checker is initialised using the "makeprgBuild()" function and thus it +accepts the standard options described at |syntastic-config-makeprg|. + +See also: |syntastic-css-recess|. + +============================================================================== +SYNTAX CHECKERS FOR LEX *syntastic-checkers-lex* + +The following checkers are available for Lex (filetype "lex"): + + 1. flex.....................|syntastic-lex-flex| + +------------------------------------------------------------------------------ +1. flex *syntastic-lex-flex* + +Name: flex +Maintainer: LCD 47 <lcd047@gmail.com> + +"Flex" is the GNU implementation of the standard UNIX lexical analyzer "lex" +(http://en.wikipedia.org/wiki/Lex_programming_tool). See the project's page +for more information: + + http://flex.sourceforge.net/ + +Checker options~ + +This checker is initialised using the "makeprgBuild()" function and thus it +accepts the standard options described at |syntastic-config-makeprg|. + +============================================================================== +SYNTAX CHECKERS FOR LIMBO *syntastic-checkers-limbo* + +The following checkers are available for Limbo (filetype "limbo"): + + 1. Limbo....................|syntastic-limbo-limbo| + +------------------------------------------------------------------------------ +1. Limbo *syntastic-limbo-limbo* + +Name: limbo +Maintainer: Alex Efros <powerman-asdf@ya.ru> + +"Limbo" is a compiler for the Limbo language +(http://doc.cat-v.org/inferno/4th_edition/limbo_language/), the +language used to write applications for the "Inferno" operating system +(http://doc.cat-v.org/inferno/). See the "Inferno" project's page for +a reference implementation: + + http://code.google.com/p/inferno-os/ + +Checker options~ + +This checker is initialised using the "makeprgBuild()" function and thus it +accepts the standard options described at |syntastic-config-makeprg|. + +============================================================================== +SYNTAX CHECKERS FOR LISP *syntastic-checkers-lisp* + +The following checkers are available for LISP (filetype "lisp"): + + 1. CLISP....................|syntastic-lisp-clisp| + +------------------------------------------------------------------------------ +1. CLISP *syntastic-lisp-clisp* + +Name: clisp +Maintainer: Karl Yngve Lervåg <karl.yngve@lervag.net> + +"CLISP" is an interpreter for LISP programs. See the project's page for +details: + + http://www.clisp.org/ + +Checker options~ + +This checker is initialised using the "makeprgBuild()" function and thus it +accepts the standard options described at |syntastic-config-makeprg|. + +============================================================================== +SYNTAX CHECKERS FOR LLVM *syntastic-checkers-llvm* + +The following checkers are available for LLVM (filetype "llvm"): + + 1. LLVM.....................|syntastic-llvm-llvm| + +------------------------------------------------------------------------------ +1. LLVM *syntastic-llvm-llvm* + +Name: llvm +Maintainer: Andrew Kelley <superjoe30@gmail.com> + +"LLVM" is the intermediate language for the LLVM compilers (http://llvm.org/). +See the reference manual for details: + + http://llvm.org/docs/LangRef.html + +Checker options~ + +This checker is initialised using the "makeprgBuild()" function and thus it +accepts the standard options described at |syntastic-config-makeprg|. + +============================================================================== +SYNTAX CHECKERS FOR LUA *syntastic-checkers-lua* + +The following checkers are available for Lua (filetype "lua"): + + 1. luac.....................|syntastic-lua-luac| + 2. luacheck.................|syntastic-lua-luacheck| + +------------------------------------------------------------------------------ +1. luac *syntastic-lua-luac* + +Name: luac +Maintainer: Gregor Uhlenheuer <kongo2002@gmail.com> + +"luac" is a compiler for Lua. See the tool's manual for details: + + http://www.lua.org/manual/ + +Checker options~ + +This checker is initialised using the "makeprgBuild()" function and thus it +accepts the standard options described at |syntastic-config-makeprg|. + +Note~ + +"luac" truncates filenames when the full path of the files involved is longer +than a certain fixed amount. Syntastic can't detect this situation, and will +silently ignore error messages with truncated filenames. + +------------------------------------------------------------------------------ +2. luacheck *syntastic-lua-luacheck* + +Name: luacheck +Maintainer: Thiago Bastos <tbastos@tbastos.com> + +"Luacheck" is a tool for static analysis of Lua code. See the project's page +for details: + + https://github.com/mpeterv/luacheck + +In contrast to "luac" (see |syntastic-lua-luac|) which only flags syntax +errors, this checker detects code smells, so you probably want to enable both +when available. + +Checker options~ + +This checker is initialised using the "makeprgBuild()" function and thus it +accepts the standard options described at |syntastic-config-makeprg|. + +Note~ + +A sensible set of options for LUA projects might be something like this: > + let g:syntastic_check_on_open = 1 + let g:syntastic_lua_checkers = ["luac", "luacheck"] + let g:syntastic_lua_luacheck_args = "--no-unused-args" +< +============================================================================== +SYNTAX CHECKERS FOR MARKDOWN *syntastic-checkers-markdown* + +The following checkers are available for Markdown (filetype "markdown"): + + 1. Markdown lint tool.......|syntastic-markdown-mdl| + 2. textlint.................|syntastic-markdown-textlint| + +------------------------------------------------------------------------------ +1. Markdown lint tool *syntastic-markdown-mdl* + +Name: mdl +Maintainer: Charles Beynon <etothepiipower@gmail.com> + +"Markdown lint tool" is a style checker for Markdown files. See the project's +page at GitHub for details: + + https://github.com/mivok/markdownlint + +Installation~ + +Install it with: > + gem install mdl +< +Checker options~ + +This checker is initialised using the "makeprgBuild()" function and thus it +accepts the standard options described at |syntastic-config-makeprg|. + +Note~ + +You can also use the "Node.js"-based "markdownlint-cli" as a checker instead +of "mdl": + + https://github.com/igorshubovych/markdownlint-cli + +To do that, you have to point 'g:syntastic_markdown_mdl_exec' to +"markdownlint", and set 'g:syntastic_markdown_mdl_args' to an empty string (or +to a set of valid "markdownlint-cli" options): > + let g:syntastic_markdown_mdl_exec = "markdownlint" + let g:syntastic_markdown_mdl_args = "" +< +------------------------------------------------------------------------------ +2. textlint *syntastic-markdown-textlint* + +Name: textlint +Maintainer: LCD 47 <lcd047@gmail.com> + +"textlint" is a natural language linter for text, Markdown, and HTML files. +See the project's page for details: + + https://textlint.github.io/ + +Checker options~ + +This checker is initialised using the "makeprgBuild()" function and thus it +accepts the standard options described at |syntastic-config-makeprg|. + +See also: |syntastic-html-textlint|, |syntastic-text-textlint|. + +============================================================================== +SYNTAX CHECKERS FOR MATLAB *syntastic-checkers-matlab* + +The following checkers are available for MATLAB (filetype "matlab"): + + 1. mlint....................|syntastic-matlab-mlint| + +------------------------------------------------------------------------------ +1. mlint *syntastic-matlab-mlint* + +Name: mlint +Maintainer: Jason Graham <jason@the-graham.com> + +"mlint" is a code checker for MATLAB. The "mlint" binary is distributed with +the "MATLAB" package: + + http://www.mathworks.com/help/matlab/ + +Checker options~ + +This checker is initialised using the "makeprgBuild()" function and thus it +accepts the standard options described at |syntastic-config-makeprg|. + +============================================================================== +SYNTAX CHECKERS FOR MERCURY *syntastic-checkers-mercury* + +The following checkers are available for Mercury (filetype "mercury"): + + 1. mmc......................|syntastic-mercury-mmc| + +------------------------------------------------------------------------------ +1. mmc *syntastic-mercury-mmc* + +Name: mmc +Maintainer: Joshua Rahm <joshuarahm@gmail.com> + +"mmc" is a compiler for Mercury. See Mercury's page for more details: + + http://www.mercurylang.org/ + +Checker options~ + +This checker is initialised using the "makeprgBuild()" function and thus it +accepts the standard options described at |syntastic-config-makeprg|. + +============================================================================== +SYNTAX CHECKERS FOR NASM *syntastic-checkers-nasm* + +The following checkers are available for NASM (filetype "nasm"): + + 1. nasm.....................|syntastic-nasm-nasm| + +------------------------------------------------------------------------------ +1. nasm *syntastic-nasm-nasm* + +Name: nasm +Maintainer: HĂĽvard Pettersson <haavard.pettersson@gmail.com> + +"NASM" is an assembler and disassembler for the Intel x86 architecture. See +the project's page for details: + + http://www.nasm.us/ + +Checker options~ + +This checker is initialised using the "makeprgBuild()" function and thus it +accepts the standard options described at |syntastic-config-makeprg|. + +============================================================================== +SYNTAX CHECKERS FOR NIX *syntastic-checkers-nix* + +The following checkers are available for Nix (filetype "nix"): + + 1. Nix......................|syntastic-nix-nix| + +------------------------------------------------------------------------------ +1. Nix *syntastic-nix-nix* + +Name: nix +Maintainer: Tim Cuthbertson <tim@gfxmonk.net> + +"Nix" is a checker for language "Nix" using "nix-instantiate". See the +project's page for details: + + http://nixos.org/ + +Checker options~ + +This checker is initialised using the "makeprgBuild()" function and thus it +accepts the standard options described at |syntastic-config-makeprg|. + +============================================================================== +SYNTAX CHECKERS FOR NROFF *syntastic-checkers-nroff* + +The following checkers are available for nroff (filetype "nroff"): + + 1. Igor.....................|syntastic-nroff-igor| + 2. mandoc...................|syntastic-nroff-mandoc| + +------------------------------------------------------------------------------ +1. Igor *syntastic-nroff-igor* + +Name: igor +Maintainer: LCD 47 <lcd047@gmail.com> + +"Igor" is a proofreader for DocBook SGML, man pages, and text files used by +the FreeBSD project (https://www.freebsd.org/). See the author's presentation +for details: + + http://www.youtube.com/watch?v=sczHqUPygZY + +The latest version can be obtained from Glen Barber's repository: + + http://docscripts.glenbarber.us/tags/igor/ + +Checker options~ + +This checker is initialised using the "makeprgBuild()" function and thus it +accepts the standard options described at |syntastic-config-makeprg|. + +See also: |syntastic-docbk-igor|, |syntastic-text-igor|. + +------------------------------------------------------------------------------ +2. mandoc *syntastic-nroff-mandoc* + +Name: mandoc +Maintainer: LCD 47 <lcd047@gmail.com> + +See the project's page for details: + + http://mdocml.bsd.lv/ + +Checker options~ + +This checker is initialised using the "makeprgBuild()" function and thus it +accepts the standard options described at |syntastic-config-makeprg|. + +============================================================================== +SYNTAX CHECKERS FOR OBJECTIVE-C *syntastic-checkers-objc* + +The following checkers are available for Objective-C (filetype "objc"): + + 1. GCC......................|syntastic-objc-gcc| + 2. OClint...................|syntastic-objc-oclint| + +------------------------------------------------------------------------------ +1. GCC *syntastic-objc-gcc* + +Name: gcc +Maintainer: Gregor Uhlenheuer <kongo2002@gmail.com> + +Checker options~ + *'g:syntastic_objc_compiler'* +Type: string +Default: "gcc", or "clang" if GCC is not found +Compiler executable. + + *'g:syntastic_objc_errorformat'* +Type: string +Default: unset +Override for the default |'errorformat'|. + + *'g:syntastic_objc_remove_include_errors'* +Type: boolean +Default: 0 +By default, errors in files included from the file being checked are shown. +Set this variable to 1 to remove messages about errors in included files. +Please note that this means syntastic will silently abort checks if there are +fatal errors in one of the included files. + + *'g:syntastic_objc_compiler_options'* +Type: string +Default: unset +Compilation flags (such as defines or include directories) to be passed to the +checker. + + *'g:syntastic_objc_config_file'* +Type: string +Default: ".syntastic_objc_config" +File containing additional compilation flags to be passed to the checker, one +option per line (cf. |syntastic-config-files|). + + *'g:syntastic_objc_include_dirs'* +Type: array of strings +Default: [] +Include directories to be passed to the checker, in addition to the above +compilation flags. You can set it like this: > + let g:syntastic_objc_include_dirs = ["includes", "headers"] +< +and the corresponding "-Iincludes -Iheaders" will be added to the compilation +flags. + + *'g:syntastic_objc_no_default_include_dirs'* +Type: boolean +Default: 0 +By default syntastic adds a number of common include directories to the +compilation flags, namely: > + -I. -I.. -Iinclude -Iincludes -I../include -I../includes +< +You can disable this behaviour by setting the above variable to 1. + + *'b:syntastic_objc_cflags'* +Type: string +Default: unset +Buffer-local variable. Additional compilation flags specific to the current +buffer. + + *'g:syntastic_objc_check_header'* +Type: boolean +Default: 0 +If the current file is a header (namely if its extension is "h"), all checks +are silently skipped. You can force syntastic to check header files by +setting the above variable to 1. + +Note~ + +This checker doesn't call the "makeprgBuild()" function, and thus it ignores +the usual 'g:syntastic_objc_gcc_<option>' variables. The only exception is +'g:syntastic_objc_gcc_exec', which can still be used to override the checker's +executable. + +See also: |syntastic-objcpp-gcc|. + +------------------------------------------------------------------------------ +2. OClint *syntastic-objc-oclint* + +Name: oclint +Maintainer: "UnCO" Lin <undercooled@lavabit.com> + +"OClint" is a static code analysis tool. See the project's page for details: + + http://oclint.org/ + +Checker options~ + +This checker is initialised using the "makeprgBuild()" function and thus it +accepts the standard options described at |syntastic-config-makeprg|. + +Additionally: + + 'g:syntastic_oclint_config_file' +Type: string +Default: ".syntastic_oclint_config" +File containing compilation flags (such as defines or include directories), +one option per line (cf. |syntastic-config-files|). + +See also: |syntastic-objcpp-oclint|. + +============================================================================== +SYNTAX CHECKERS FOR OBJECTIVE-C++ *syntastic-checkers-objcpp* + +The following checkers are available for Objective-C++ (filetype "objcpp"): + + 1. GCC......................|syntastic-objcpp-gcc| + 2. OClint...................|syntastic-objcpp-oclint| + +------------------------------------------------------------------------------ +1. GCC *syntastic-objcpp-gcc* + +Name: gcc +Maintainer: Gregor Uhlenheuer <kongo2002@gmail.com> + +Checker options~ + *'g:syntastic_objcpp_compiler'* +Type: string +Default: "gcc", or "clang" if GCC is not found +Compiler executable. + + *'g:syntastic_objcpp_errorformat'* +Type: string +Default: unset +Override for the default |'errorformat'|. + + *'g:syntastic_objcpp_remove_include_errors'* +Type: boolean +Default: 0 +By default, errors in files included from the file being checked are shown. +Set this variable to 1 to remove messages about errors in included files. +Please note that this means syntastic will silently abort checks if there are +fatal errors in one of the included files. + + *'g:syntastic_objcpp_compiler_options'* +Type: string +Default: unset +Compilation flags (such as defines or include directories) to be passed to the +checker. + + *'g:syntastic_objcpp_config_file'* +Type: string +Default: ".syntastic_objcpp_config" +File containing additional compilation flags to be passed to the checker, one +option per line (cf. |syntastic-config-files|). + + *'g:syntastic_objcpp_include_dirs'* +Type: array of strings +Default: [] +Include directories to be passed to the checker, in addition to the above +compilation flags. You can set it like this: > + let g:syntastic_objcpp_include_dirs = ["includes", "headers"] +< +and the corresponding "-Iincludes -Iheaders" will be added to the compilation +flags. + + *'g:syntastic_objcpp_no_default_include_dirs'* +Type: boolean +Default: 0 +By default syntastic adds a number of common include directories to the +compilation flags, namely: > + -I. -I.. -Iinclude -Iincludes -I../include -I../includes +< +You can disable this behaviour by setting the above variable to 1. + + *'b:syntastic_objcpp_cflags'* +Type: string +Default: unset +Buffer-local variable. Additional compilation flags specific to the current +buffer. + + *'g:syntastic_objcpp_check_header'* +Type: boolean +Default: 0 +If the current file is a header (namely if its extension is "h"), all checks +are silently skipped. You can force syntastic to check header files by +setting the above variable to 1. + +Note~ + +This checker doesn't call the "makeprgBuild()" function, and thus it ignores +the usual 'g:syntastic_objcpp_gcc_<option>' variables. The only exception +is 'g:syntastic_objcpp_gcc_exec', which can still be used to override the +checker's executable. + +See also: |syntastic-objc-gcc|. + +------------------------------------------------------------------------------ +2. OClint *syntastic-objcpp-oclint* + +Name: oclint +Maintainer: "UnCO" Lin <undercooled@lavabit.com> + +"OClint" is a static code analysis tool. See the project's page for details: + + http://oclint.org/ + +Checker options~ + +This checker is initialised using the "makeprgBuild()" function and thus it +accepts the standard options described at |syntastic-config-makeprg|. + +Additionally: + + 'g:syntastic_oclint_config_file' +Type: string +Default: ".syntastic_oclint_config" +File containing compilation flags (such as defines or include directories), +one option per line (cf. |syntastic-config-files|). + +See also: |syntastic-objc-oclint|. + +============================================================================== +SYNTAX CHECKERS FOR OCAML *syntastic-checkers-ocaml* + +The following checkers are available for OCaml (filetype "ocaml"): + + 1. camlp4o..................|syntastic-ocaml-camlp4o| + +------------------------------------------------------------------------------ +1. camlp4o *syntastic-ocaml-camlp4o* + +Name: camlp4o +Maintainer: Tőrők Edwin <edwintorok@gmail.com> + +"ocamlc" is a compiler for Caml. See the project's page for details: + + http://caml.inria.fr/ + +Checker options~ + *'g:syntastic_ocaml_use_ocamlc'* +Type: boolean +Default: 0 +Enable this variable to use "ocamlc". + + *'g:syntastic_ocaml_use_janestreet_core'* +Type: boolean +Default: 0 +It's possible to use "ocamlc" in conjunction with Jane Street's "core". In +order to do that you have to set the above variable. + + *'g:syntastic_ocaml_janestreet_core_dir'* +Type: string +Default: "." +Path to Jane Street's "core". + + *'g:syntastic_ocaml_camlp4r'* +Type: boolean +Default: 0 +By default, .ml and .mli files are checked with the "camlp4o" preprocessor, +.mll with "ocamllex", and .mly with "menhir". If your source code requires +"camlp4r" you can set this variable. + + *'g:syntastic_ocaml_use_ocamlbuild'* +Type: boolean +Default: 0 +Whether to enable typechecking and syntax extensions. This tells syntastic to +run "ocamlbuild <name>.inferred.mli". It writes object files to the "_build" +directory, and possibly rebuilds your "myocamlbuild.ml" plugin. If you are +using syntax extensions / external libraries and have a properly set up +"_tags" (and "myocamlbuild.ml" file), setting this flag should just work. For +best results your current directory should be the project root (same situation +if you want useful output from `:make`). + +This checker doesn't call the "makeprgBuild()" function, and thus it ignores +the usual 'g:syntastic_ocaml_camlp4o_<option>' variables. + +Note~ + +You might consider using the checkers packaged with Merlin instead of this +one. They provide type errors and let you use packages outside core: + + https://github.com/the-lambda-church/merlin + +============================================================================== +SYNTAX CHECKERS FOR PERL *syntastic-checkers-perl* + +The following checkers are available for Perl (filetype "perl"): + + 1. perl.....................|syntastic-perl-perl| + 2. Perl::Critic.............|syntastic-perl-perlcritic| + 3. Pod::Checker.............|syntastic-perl-podchecker| + +------------------------------------------------------------------------------ +1. perl *syntastic-perl-perl* + +Name: perl +Maintainers: Anthony Carapetis <anthony.carapetis@gmail.com> + Eric Harmon + +Security~ + +This checker runs "perl -c" against your files, which in turn executes any +"BEGIN", "UNITCHECK", and "CHECK" blocks, and any "use" statements in your +file (cf. http://perldoc.perl.org/perlrun.html#*-c*). This is probably fine if +you wrote the file yourself, but it can be a problem if you're trying to check +third party files. If you are 100% willing to let Vim run the code in your +file, set 'g:syntastic_enable_perl_checker' to 1 in your vimrc to enable this +checker: > + let g:syntastic_enable_perl_checker = 1 +< +There is also a buffer-local version of this variable, that takes precedence +over it in the buffers where it is defined. + +Please note that setting this variable doesn't automatically enable the +checker, you still need to add it to 'g:syntastic_perl_checkers' if you plan +to use it. + +Checker options~ + +This checker is initialised using the "makeprgBuild()" function and thus it +accepts the standard options described at |syntastic-config-makeprg|. + +Additionally: + + *'g:syntastic_perl_interpreter'* +Type: string +Default: "perl" +The perl interpreter to use. + + *'g:syntastic_perl_lib_path'* +Type: list os strings +Default: [] +List of include directories to be added to the perl command line. Example: > + let g:syntastic_perl_lib_path = [ "./lib", "./lib/auto" ] +< +Note~ + +The variable |'g:syntastic_perl_interpreter'| is shared with the YAML::XS +checker (cf. |syntastic-yaml-yamlxs|). If for some reasons you don't want to +use the same interpreter for both checkers, you can override it locally by +setting 'g:syntastic_perl_perl_exec'. + +------------------------------------------------------------------------------ +2. Perl::Critic *syntastic-perl-perlcritic* + +Name: perlcritic +Maintainer: LCD 47 <lcd047@gmail.com> + +"Perl::Critic" is a static analyzer for Perl. See the project's page for +details: + + http://perlcritic.com/ + +Checker options~ + +This checker is initialised using the "makeprgBuild()" function and thus it +accepts the standard options described at |syntastic-config-makeprg|. + +Additionally: + + *'g:syntastic_perl_perlcritic_thres'* +Type: integer +Default: 5 +Error threshold: policy violations with a severity above this value are +highlighted as errors, the others are warnings. + +Note~ + +You can override the format of "perlcritic" messages, for example: > + let g:syntastic_perl_perlcritic_post_args = + \ '--verbose "\%s:\%f:\%l:\%c: \%p: \%m\n"' +< +Just make sure to leave alone the leading "\%s:\%f:\%l:\%c:". + +------------------------------------------------------------------------------ +3. Pod::Checker *syntastic-perl-podchecker* + +Name: podchecker +Maintainer: LCD 47 <lcd047@gmail.com> + +"Pod::Checker" is a checker for pod documents. See the module's manual for +details: + + http://perldoc.perl.org/Pod/Checker.html + +Checker options~ + +This checker is initialised using the "makeprgBuild()" function and thus it +accepts the standard options described at |syntastic-config-makeprg|. + +See also: |syntastic-pod-podchecker|. + +============================================================================== +SYNTAX CHECKERS FOR PHP *syntastic-checkers-php* + +The following checkers are available for PHP (filetype "php"): + + 1. PHP......................|syntastic-php-php| + 2. PHP_CodeSniffer..........|syntastic-php-phpcs| + 3. PHPLint..................|syntastic-php-phplint| + 4. PHP Mess Detector........|syntastic-php-phpmd| + +------------------------------------------------------------------------------ +1. PHP *syntastic-php-php* + +Name: php +Maintainer: Martin Grenfell <martin.grenfell@gmail.com> + +Checker options~ + +This checker is initialised using the "makeprgBuild()" function and thus it +accepts the standard options described at |syntastic-config-makeprg|. + +------------------------------------------------------------------------------ +2. PHP_CodeSniffer *syntastic-php-phpcs* + +Name: phpcs +Maintainer: Martin Grenfell <martin.grenfell@gmail.com> + +"PHP_CodeSniffer" is a style checker for PHP and CSS. See the project's page +at GitHub for details: + + https://github.com/squizlabs/PHP_CodeSniffer/ + +Installation~ + +Install it with: > + pear install PHP_CodeSniffer +< +Checker options~ + +This checker is initialised using the "makeprgBuild()" function and thus it +accepts the standard options described at |syntastic-config-makeprg|. + +Note~ + +If you're checking files containing tab characters then "PHP_CodeSniffer"'s +idea of tabstop must match Vim's 'tabstop', otherwise syntastic will highlight +the errors at shifted positions. By default syntastic does that by adding +an option "--tab-width=&tabstop" to "PHP_CodeSniffer", but that option +also instructs "PHP_CodeSniffer" to expand tabs, and some code sniffers +(f.i. "CakePHP", see https://github.com/cakephp/cakephp-codesniffer) insist on +indenting lines with tabs. To work around the resulting mess if you're using +one of these sniffers, set "--tab-width=0" and 'tabstop' to 8: > + let g:syntastic_php_phpcs_args = "--tab-width=0" + set tabstop=8 +< +See also: |syntastic-css-phpcs|. + +------------------------------------------------------------------------------ +3. PHPLint *syntastic-php-phplint* + +Name: phplint +Maintainer: LCD 47 <lcd047@gmail.com> + +"PHPLint" is a style checker for PHP. See the project's page for details: + + http://www.icosaedro.it/phplint/ + +Checker options~ + +This checker is initialised using the "makeprgBuild()" function and thus it +accepts the standard options described at |syntastic-config-makeprg|. + +------------------------------------------------------------------------------ +4. PHP Mess Detector *syntastic-php-phpmd* + +Name: phpmd +Maintainer: Martin Grenfell <martin.grenfell@gmail.com> + +"PHP Mess Detector" is a code analyzer for PHP. See the project's page for +details: + + http://phpmd.org + +Checker options~ + +This checker is initialised using the "makeprgBuild()" function and thus it +accepts the standard options described at |syntastic-config-makeprg|. + +============================================================================== +SYNTAX CHECKERS FOR POD *syntastic-checkers-pod* + +The following checkers are available for POD (filetype "pod"): + + 1. Pod::Checker.............|syntastic-pod-podchecker| + +------------------------------------------------------------------------------ +1. Pod::Checker *syntastic-pod-podchecker* + +Name: podchecker +Maintainer: LCD 47 <lcd047@gmail.com> + +"Pod::Checker" is a checker for pod documents. See the module's manual for +details: + + http://perldoc.perl.org/Pod/Checker.html + +Checker options~ + +This checker is initialised using the "makeprgBuild()" function and thus it +accepts the standard options described at |syntastic-config-makeprg|. + +See also: |syntastic-perl-podchecker|. + +============================================================================== +SYNTAX CHECKERS FOR PUG (FORMERLY JADE) *syntastic-checkers-pug* + +The following checkers are available for Pug (formerly Jade; filetype "pug"): + + 1. pug_lint.................|syntastic-pug-pug_lint| + +------------------------------------------------------------------------------ +1. pug_lint *syntastic-pug-pug_lint* + +Name: pug_lint +Maintainer: Ben Parnell <benjaminparnell.94@gmail.com> + +"pug-lint" is a linter and style checker for Pug (formerly known as "Jade"; +http://jade-lang.com/). See the project's page at GitHub for details: + + https://github.com/pugjs/pug-lint + +Checker options~ + +This checker is initialised using the "makeprgBuild()" function and thus it +accepts the standard options described at |syntastic-config-makeprg|. + +============================================================================== +SYNTAX CHECKERS FOR PUPPET *syntastic-checkers-puppet* + +The following checkers are available for Puppet (filetype "puppet"): + + 1. puppet...................|syntastic-puppet-puppet| + 2. puppet-lint..............|syntastic-puppet-puppetlint| + +------------------------------------------------------------------------------ +1. puppet *syntastic-puppet-puppet* + +Name: puppet +Maintainer: Eivind Uggedal <eivind@uggedal.com> + +"Puppet" is an automated administrative engine for UNIX systems. See the +project's page for details: + + http://projects.puppetlabs.com/projects/puppet + +Checker options~ + +This checker is initialised using the "makeprgBuild()" function and thus it +accepts the standard options described at |syntastic-config-makeprg|. + +------------------------------------------------------------------------------ +2. puppet-lint *syntastic-puppet-puppetlint* + +Name: puppetlint +Maintainer: Eivind Uggedal <eivind@uggedal.com> + +"puppet-lint" is a style checker for puppet manifests +(http://projects.puppetlabs.com/projects/puppet). See the project's page for +details: + + http://puppet-lint.com/ + +Checker options~ + +This checker is initialised using the "makeprgBuild()" function and thus it +accepts the standard options described at |syntastic-config-makeprg|. + +============================================================================== +SYNTAX CHECKERS FOR PYTHON *syntastic-checkers-python* + +The following checkers are available for Python (filetype "python"): + + 1. flake8...................|syntastic-python-flake8| + 2. Frosted..................|syntastic-python-frosted| + 3. mypy.....................|syntastic-python-mypy| + 4. Prospector...............|syntastic-python-prospector| + 5. py3kwarn.................|syntastic-python-py3kwarn| + 6. pycodestyle..............|syntastic-python-pycodestyle| + 7. pydocstyle...............|syntastic-python-pydocstyle| + 8. Pyflakes.................|syntastic-python-pyflakes| + 9. Pylama...................|syntastic-python-pylama| + 10. Pylint..................|syntastic-python-pylint| + 11. python..................|syntastic-python-python| + +------------------------------------------------------------------------------ +1. flake8 *syntastic-python-flake8* + +Name: flake8 +Maintainers: Sylvain Soliman <Sylvain.Soliman+git@gmail.com> + kstep <me@kstep.me> + +"Flake8" is a wrapper around PyFlakes (https://launchpad.net/pyflakes), pep8 +(https://github.com/jcrocholl/pep8), and Ned Batchelder's McCabe script +(http://nedbatchelder.com/blog/200803/python_code_complexity_microtool.html). +See the project's page and the official docs for details: + + https://gitlab.com/pycqa/flake8 + http://flake8.readthedocs.org/ + +Checker options~ + +This checker is initialised using the "makeprgBuild()" function and thus it +accepts the standard options described at |syntastic-config-makeprg|. + +------------------------------------------------------------------------------ +2. Frosted *syntastic-python-frosted* + +Name: frosted +Maintainer: LCD 47 <lcd047@gmail.com> + +"Frosted" is a fork of pyflakes (https://launchpad.net/pyflakes). See the +project's page for details: + + https://github.com/timothycrosley/frosted + +Checker options~ + +This checker is initialised using the "makeprgBuild()" function and thus it +accepts the standard options described at |syntastic-config-makeprg|. + +------------------------------------------------------------------------------ +3. mypy *syntastic-python-mypy* + +Name: mypy +Maintainer: Russ Hewgill <Russ.Hewgill@gmail.com> + +"mypy" is a static type checker for Python. See the project's page for +details: + + http://www.mypy-lang.org/ + +Checker options~ + +This checker is initialised using the "makeprgBuild()" function and thus it +accepts the standard options described at |syntastic-config-makeprg|. + +------------------------------------------------------------------------------ +4. Prospector *syntastic-python-prospector* + +Name: prospector +Maintainer: LCD 47 <lcd047@gmail.com> + +"Prospector" is a static analysis tool for Python. It brings +together the functionality of other tools such as pylint +(http://www.pylint.org/), pyflakes (https://launchpad.net/pyflakes), +pep8 (https://github.com/jcrocholl/pep8), pydocstyle (formerly +"pep257"; https://github.com/PyCQA/pydocstyle), and McCabe complexity +(http://nedbatchelder.com/blog/200803/python_code_complexity_microtool.html). +See the project's official documentation for details: + + http://prospector.readthedocs.org/en/latest/ + +Syntastic supports "Prospector" versions 0.7 and later. + +Checker options~ + +This checker is initialised using the "makeprgBuild()" function and thus it +accepts the standard options described at |syntastic-config-makeprg|. + +------------------------------------------------------------------------------ +5. py3kwarn *syntastic-python-py3kwarn* + +Name: py3kwarn +Author: Liam Curry <liam@curry.name> + +"Py3kwarn" is a code checker for Python that detects incompatibilities with +Python 3. See the project's page for details: + + https://github.com/liamcurry/py3kwarn + +Checker options~ + +This checker is initialised using the "makeprgBuild()" function and thus it +accepts the standard options described at |syntastic-config-makeprg|. + +------------------------------------------------------------------------------ +6. pycodestyle *syntastic-python-pycodestyle* + +Name: pycodestyle +Maintainer: LCD 47 <lcd047@gmail.com> + +"pycodestyle" (formerly "pep8") is a style checker for Python, derived from +the conventions in PEP 8 (http://www.python.org/dev/peps/pep-0008/). See the +project's page for details: + + https://github.com/PyCQA/pycodestyle + +Checker options~ + +This checker is initialised using the "makeprgBuild()" function and thus it +accepts the standard options described at |syntastic-config-makeprg|. + +------------------------------------------------------------------------------ +7. pydocstyle *syntastic-python-pydocstyle* + +Name: pydocstyle +Maintainer: LCD 47 <lcd047@gmail.com> + +"pydocstyle" (formerly "pep257") is a docstring style checker +for Python, derived from the conventions established in PEP 257 +(http://www.python.org/dev/peps/pep-0257/). See the project's page for +details: + + https://github.com/PyCQA/pydocstyle + +Checker options~ + +This checker is initialised using the "makeprgBuild()" function and thus it +accepts the standard options described at |syntastic-config-makeprg|. + +------------------------------------------------------------------------------ +8. Pyflakes *syntastic-python-pyflakes* + +Name: pyflakes +Authors: Martin Grenfell <martin.grenfell@gmail.com> + kstep <me@kstep.me> + Parantapa Bhattacharya <parantapa@gmail.com> + +"Pyflakes" is a simple code checker for Python. See the project's page for +more information: + + https://launchpad.net/pyflakes + +Checker options~ + +This checker is initialised using the "makeprgBuild()" function and thus it +accepts the standard options described at |syntastic-config-makeprg|. + +------------------------------------------------------------------------------ +9. Pylama *syntastic-python-pylama* + +Name: pylama +Maintainer: LCD 47 <lcd047@gmail.com> + +"Pylama" is a wrapper around pep8 (https://github.com/jcrocholl/pep8), +pydocstyle (formerly "pep257"; https://github.com/PyCQA/pydocstyle), +Pyflakes (https://launchpad.net/pyflakes), +Pylint (http://www.pylint.org/), and Ned Batchelder's McCabe script +(http://nedbatchelder.com/blog/200803/python_code_complexity_microtool.html). +See the project's page for details: + + https://github.com/klen/pylama + +Note~ + +The Pylint backend requires you to install "pylama_pylint": + + https://github.com/klen/pylama_pylint + +Checker options~ + +This checker is initialised using the "makeprgBuild()" function and thus it +accepts the standard options described at |syntastic-config-makeprg|. + +------------------------------------------------------------------------------ +10. Pylint *syntastic-python-pylint* + +Name: pylint +Author: Parantapa Bhattacharya <parantapa@gmail.com> + +"Pylint" is a code checker for Python. See the project's page for details: + + http://www.pylint.org/ + +Checker options~ + +This checker is initialised using the "makeprgBuild()" function and thus it +accepts the standard options described at |syntastic-config-makeprg|. + +Notes~ + +On OS X you need to set the environment variable "LC_CTYPE" to "UTF-8" +before running Vim: > + LC_CTYPE=en_US.UTF-8 + export LC_CTYPE +< +Several people have expressed interest in showing the old message IDs +along with the error messages. You can override the message format in +'g:syntastic_python_pylint_post_args'. Please note that the new format must +start with "{path}:{line}:{column}:{C}: ", otherwise syntastic will not +recognise any messages. Example: > + let g:syntastic_python_pylint_post_args = + \ '--msg-template="{path}:{line}:{column}:{C}: [{symbol} {msg_id}] {msg}"' +< +------------------------------------------------------------------------------ +11. python *syntastic-python-python* + +Name: python +Maintainer: LCD 47 <lcd047@gmail.com> + +This checker uses Python's builtin "compile()" function for detecting syntax +errors. + +Syntastic requires Python version 2.6 or later. + +Codecs~ + +In Python you have the ability to specify a particular codec at the top of +the file with a special comment that looks something like this: > + # coding: spec +< +Further references: + + https://docs.python.org/reference/lexical_analysis.html#encoding-declarations + +Python will see this comment at import time and use the corresponding codec to +transform the file before using it. The "python" checker has an option +|'g:syntastic_python_python_use_codec'| that will make syntastic aware of such +comments before running compiler checks on the file. + +Please note that transforming a file like this affects line numbers and +column numbers, and syntastic has no way to make the necessary adjustments. +Consequently, errors might appear on surprising lines if you enable this +feature and the transformed file has code on different lines than the raw +file. For this reason the use of these transformations should be limitted +to codecs that preserve line numbers, such as the "spec" codec provided by +"NoseOfYeti": + + https://noseofyeti.readthedocs.org/en/latest/ + +Checker options~ + +This checker is initialised using the "makeprgBuild()" function and thus it +accepts the standard options described at |syntastic-config-makeprg|. + +Additionally: + + *'g:syntastic_python_python_use_codec'* +Type: boolean +Default: 0 +Enables handling of "# coding: spec" comments. + +============================================================================== +SYNTAX CHECKERS FOR QML *syntastic-checkers-qml* + +The following checkers are available for QML (filetype "qml"): + + 1. qmllint..................|syntastic-qml-qmllint| + +------------------------------------------------------------------------------ +1. qmllint *syntastic-qml-qmllint* + +Name: qmllint +Maintainer: Peter Wu <peter@lekensteyn.nl> + +"qmllint" is a QML syntax verifier. It was introduced with Qt 5.4 (cf. +https://www.kdab.com/kdab-contributions-qt-5-4-qmllint/) as part of Qt +Declarative: + + https://code.qt.io/cgit/qt/qtdeclarative.git/tree/tools/qmllint + +Checker options~ + +This checker is initialised using the "makeprgBuild()" function and thus it +accepts the standard options described at |syntastic-config-makeprg|. + +============================================================================== +SYNTAX CHECKERS FOR R *syntastic-checkers-r* + +The following checkers are available for R (filetype "r"): + + 1. lint.....................|syntastic-r-lint| + 2. lintr....................|syntastic-r-lintr| + 3. svtools..................|syntastic-r-svtools| + +------------------------------------------------------------------------------ +1. lint *syntastic-r-lint* + +Name: lint +Maintainer: LCD 47 <lcd047@gmail.com> + +This is a style checker for R files, using the R package "lint": + + http://cran.r-project.org/web/packages/lint/ + +Checker option~ + + *'g:syntastic_r_lint_styles'* +Type: string +Default: "lint.style" +R list of style tests to apply. + +Set 'g:syntastic_r_lint_styles' to something like this: > + let g:syntastic_r_lint_styles = + \ 'list(spacing.indentation.notabs, spacing.indentation.evenindent)' +< +See "lint"'s manual for possible values: + + http://cran.r-project.org/web/packages/lint/lint.pdf + +Note~ + +This checker doesn't call the "makeprgBuild()" function, and thus it ignores +the usual 'g:syntastic_r_lint_<option>' variables. The only exception is +'g:syntastic_r_lint_exec', which can still be used to override the "R" +executable. + +Limitations~ + +The checker uses column numbers only when running into syntax errors. If +you're checking files containing tab characters, then Vim's 'tabstop' must +match R's idea of tabstop, otherwise column numbers will be shifted. At the +time of this writing R's tabstop is hardcoded to 8, so you should probably +add something like this to your vimrc: > + set tabstop=8 +< +The "lint" package will only show at most 5 messages of a kind. At the time of +this writing this is not configurable. + +Beware also that the checker is pretty slow when using the default style +setting of "lint.style". + +------------------------------------------------------------------------------ +2. lintr *syntastic-r-lintr* + +Name: lintr +Maintainer: Jim Hester <james.f.hester@gmail.com> + +"lintr" is a static code analysys tool for R files. See the project's page at +GitHub for details: + + https://github.com/jimhester/lintr + +Security~ + +This checker executes parts of the files it checks. This is probably fine if +you wrote the file yourself, but it can be a problem if you're trying to check +third party files. If you are 100% willing to let Vim run the code in your +file, set 'g:syntastic_enable_r_lintr_checker' to 1 in your vimrc to enable +this checker: > + let g:syntastic_enable_r_lintr_checker = 1 +< +There is also a buffer-local version of this variable, that takes precedence +over it in the buffers where it is defined. + +Please note that setting this variable doesn't automatically enable the +checker, you still need to add "lintr" to 'g:syntastic_r_checkers' if you plan +to use it. + +Checker Options~ + *'g:syntastic_r_lintr_linters'* +Type: string +Default: "default_linters" +Which "lintr" linters to apply to your code. + + *'g:syntastic_r_lintr_cache'* +Type: string +Default: "FALSE" +Whether to use the lintr cache. This speeds up linting time, but can introduce +false positives in some cases. + +Note~ + +This checker doesn't call the "makeprgBuild()" function, and thus it ignores +the usual 'g:syntastic_r_lintr_<option>' variables. The only exception is +'g:syntastic_r_lintr_exec', which can still be used to override the "R" +executable. + +See also: |syntastic-rmd-lintr|. + +------------------------------------------------------------------------------ +3. svtools *syntastic-r-svtools* + +Name: svtools +Maintainer: LCD 47 <lcd047@gmail.com> + +This is a checker for R files, using the R package "svTools": + + http://cran.r-project.org/web/packages/svTools/ + +In turn, this package delegates most of the work to the "checkUsage()" +function in the codetools package: + + http://cran.r-project.org/web/packages/codetools/ + +Security~ + +This checker executes parts of the files it checks. This is probably fine if +you wrote the file yourself, but it can be a problem if you're trying to check +third party files. If you are 100% willing to let Vim run the code in your +file, set 'g:syntastic_enable_r_svtools_checker' to 1 in your vimrc to enable +this checker: > + let g:syntastic_enable_r_svtools_checker = 1 +< +There is also a buffer-local version of this variable, that takes precedence +over it in the buffers where it is defined. + +Please note that setting this variable doesn't automatically enable the +checker, you still need to add "svtools" to 'g:syntastic_r_checkers' if you +plan to use it. + +Note~ + +This checker doesn't call the "makeprgBuild()" function, and thus it ignores +the usual 'g:syntastic_r_svtools_<option>' variables. The only exception is +'g:syntastic_r_svtools_exec', which can still be used to override the "R" +executable. + +Limitations~ + +"svTools" version 0.9-4 (current at the time of this writing) has a number +of problems that prevents it from checking most sources. You might consider +applying this patch as a workaround: + + https://gist.github.com/lcd047/9988687#file-svtools-patch + +At the time of this writing "svTools" doesn't produce meaningful column +numbers (the column numbers are always set to 1). The patch mentioned above +enables "svTools" to produce more useful column numbers, but only for syntax +errors. If you apply the said patch and you're checking files containing +tab characters Vim's 'tabstop' must match "R"'s idea of tabstop, otherwise +column numbers will be shifted. At the time of this writing "R"'s tabstop is +hardcoded to 8, so you should probably add something like this to your vimrc: > + set tabstop=8 +< +============================================================================== +SYNTAX CHECKERS FOR R MARKDOWN *syntastic-checkers-rmd* + +The following checkers are available for R Markdown (filetype "rmd"): + + 1. lintr....................|syntastic-rmd-lintr| + +------------------------------------------------------------------------------ +1. lintr *syntastic-rmd-lintr* + +Name: lintr +Maintainer: Jim Hester <james.f.hester@gmail.com> + +"lintr" is a static code analysys tool for R files. See the project's page at +GitHub for details: + + https://github.com/jimhester/lintr + +Security~ + +This checker executes parts of the files it checks. This is probably fine if +you wrote the file yourself, but it can be a problem if you're trying to check +third party files. If you are 100% willing to let Vim run the code in your +file, set 'g:syntastic_enable_r_lintr_checker' to 1 in your vimrc to enable +this checker: > + let g:syntastic_enable_r_lintr_checker = 1 +< +There is also a buffer-local version of this variable, that takes precedence +over it in the buffers where it is defined. + +Please note that setting this variable doesn't automatically enable the +checker, you still need to add "lintr" to 'g:syntastic_rmd_checkers' if you +plan to use it. + +Checker Options~ + 'g:syntastic_r_lintr_linters' +Type: string +Default: "default_linters" +Which "lintr" linters to apply to your code. + + 'g:syntastic_r_lintr_cache' +Type: string +Default: "FALSE" +Whether to use the lintr cache. This speeds up linting time, but can introduce +false positives in some cases. + +Note~ + +This checker doesn't call the "makeprgBuild()" function, and thus it ignores +the usual 'g:syntastic_rmd_lintr_<option>' variables. The only exception is +'g:syntastic_rmd_lintr_exec', which can still be used to override the "R" +executable. + +See also: |syntastic-r-lintr|. + +============================================================================== +SYNTAX CHECKERS FOR RACKET *syntastic-checkers-racket* + +The following checkers are available for Racket (filetype "racket"): + + 1. code-ayatollah...........|syntastic-racket-code-ayatollah| + 2. racket...................|syntastic-racket-racket| + +------------------------------------------------------------------------------ +1. code-ayatollah *syntastic-racket-code-ayatollah* + +Name: code_ayatollah +Maintainer: LCD 47 <lcd047@gmail.com> + +Installation~ + +Download "code-ayatollah.rkt" (http://tmp.barzilay.org/code-ayatollah.rkt) +and point 'g:syntastic_racket_code_ayatollah_script' to it: > + let g:syntastic_racket_code_ayatollah_script = "/path/to/code-ayatollah.rkt" +< +Of course, you also need "racket" (http://racket-lang.org/). + +Checker options~ + +This checker is initialised using the "makeprgBuild()" function and thus it +accepts the standard options described at |syntastic-config-makeprg|. + +------------------------------------------------------------------------------ +2. racket *syntastic-racket-racket* + +Name: racket +Maintainer: Steve Bragg <steve@empresseffects.com> + +Security~ + +This checker executes the code in the files it checks: + + https://github.com/scrooloose/syntastic/issues/1773 + +This is probably fine if you wrote the files yourself, but it can be a problem +if you're trying to check third party files. If you are 100% willing to let +Vim run the code in your files, set 'g:syntastic_enable_racket_racket_checker' +to 1 in your vimrc to enable this checker: > + let g:syntastic_enable_racket_racket_checker = 1 +< +There is also a buffer-local version of this variable, that takes precedence +over a global one in the buffers where it is defined. + +Please note that setting this variable doesn't automatically enable the +checker, you still need to add "racket" to 'g:syntastic_racket_checkers' if +you plan to use it. + +Checker options~ + +This checker is initialised using the "makeprgBuild()" function and thus it +accepts the standard options described at |syntastic-config-makeprg|. + +============================================================================== +SYNTAX CHECKERS FOR RELAX NG *syntastic-checkers-rnc* + +The following checkers are available for Relax NG (filetype "rnc"): + + 1. rnv......................|syntastic-rnc-rnv| + +------------------------------------------------------------------------------ +1. rnv *syntastic-rnc-rnv* + +Name: rnv +Maintainer: Remko Tronçon <remko@el-tramo.be> + +"RNV" is an implementation of Relax NG Compact Syntax validator (cf. +http://relaxng.org/compact-20021121.html). See the project's page for +details: + + http://www.davidashen.net/rnv.html + +Checker options~ + +This checker is initialised using the "makeprgBuild()" function and thus it +accepts the standard options described at |syntastic-config-makeprg|. + +============================================================================== +SYNTAX CHECKERS FOR RESTRUCTUREDTEXT *syntastic-checkers-rst* + +The following checkers are available for reStructuredText (filetype "rst"): + + 1. rst2pseudoxml............|syntastic-rst-rst2pseudoxml| + 2. rstcheck.................|syntastic-rst-rstcheck| + 3. Sphinx...................|syntastic-rst-sphinx| + +------------------------------------------------------------------------------ +1. rst2pseudoxml *syntastic-rst-rst2pseudoxml* + +Name: rst2pseudoxml +Maintainer: James Rowe <jnrowe@gmail.com> + +"rst2pseudoxml" is part of the Python package Docutils: + + http://docutils.sourceforge.net/ + +We use "rst2pseudoxml", as it is ever so marginally faster than the other +"rst2${x}" tools in docutils. + +Checker options~ + +This checker is initialised using the "makeprgBuild()" function and thus it +accepts the standard options described at |syntastic-config-makeprg|. + +------------------------------------------------------------------------------ +2. rstcheck *syntastic-rst-rstcheck* + +Name: rstcheck +Maintainer: Steven Myint <git@stevenmyint.com> + +"rstcheck" is a checker for reStructuredText files. See the project's page at +GitHub for details: + + https://github.com/myint/rstcheck + +Checker options~ + +This checker is initialised using the "makeprgBuild()" function and thus it +accepts the standard options described at |syntastic-config-makeprg|. + +------------------------------------------------------------------------------ +3. Sphinx *syntastic-rst-sphinx* + +Name: sphinx +Maintainer: Buck Evan <buck@yelp.com> + +"Sphinx" is a checker for documentation files written in the Sphinx dialect +of reStructuredText, using the "pseudoxml" builder of "sphinx-build". See the +project's page for details: + + http://sphinx-doc.org/ + +Checker options~ + +This checker is initialised using the "makeprgBuild()" function and thus it +accepts the standard options described at |syntastic-config-makeprg|. + +Additionally: + + *'g:syntastic_rst_sphinx_source_dir'* +Type: string +Default: unset +Base directory of the project being checked. + + *'g:syntastic_rst_sphinx_config_dir'* +Type: string +Default: unset +Directory containing the "conf.py" file. + +Notes~ + +The checker needs to know two paths to run: the source directory where the +project's files are located, and the directory where the configuration file +"conf.py" is located. By default it looks for "conf.py" in the base directory +of the current file, then upwards in parent directories. If a configuration +file is found and the file is readable, its base directory is assumed to be +both the source directory and the configuration directory of the project. + +If syntastic can't determine the source directory or the configuration +directory, or if you want to override the autodetected paths, options +|'g:syntastic_rst_sphinx_source_dir'| and |'g:syntastic_rst_sphinx_config_dir'| +take precedence over the detected values. + +Please not also that the checker creates output files in a temporary directory +that is created upon the first run in the current session, and is removed when +Vim exits. If you need to change the location of this directory you can do +so by exporting the environment variables "TMPDIR" or "TMP" (on UNIX and Mac +OS-X), or "TEMP" (on Windows) before running Vim. Various index files are also +cached in this directory, so it might be advantageous to avoid quitting Vim +between checker runs. + +============================================================================== +SYNTAX CHECKERS FOR RPM SPEC *syntastic-checkers-spec* + +The following checkers are available for Linux RPM packages (filetype "spec"): + + 1. rpmlint..................|syntastic-spec-rpmlint| + +------------------------------------------------------------------------------ +1. rpmlint *syntastic-spec-rpmlint* + +Name: rpmlint +Maintainer: LCD 47 <lcd047@gmail.com> + +"rpmlint" is a trool for checking Linux RPM packages. See the project's page +for details: + + http://sourceforge.net/projects/rpmlint/ + +Checker options~ + +This checker is initialised using the "makeprgBuild()" function and thus it +accepts the standard options described at |syntastic-config-makeprg|. + +============================================================================== +SYNTAX CHECKERS FOR RUBY *syntastic-checkers-ruby* + +The following checkers are available for Ruby (filetype "ruby"): + + 1. Flog.....................|syntastic-ruby-flog| + 2. JRuby....................|syntastic-ruby-jruby| + 3. MacRuby..................|syntastic-ruby-macruby| + 4. MRI......................|syntastic-ruby-mri| + 5. reek.....................|syntastic-ruby-reek| + 6. RuboCop..................|syntastic-ruby-rubocop| + 7. Ruby-lint................|syntastic-ruby-rubylint| + +------------------------------------------------------------------------------ +1. Flog *syntastic-ruby-flog* + +Name: flog +Maintainer: Tim Carry <tim@pixelastic.com> + +"Flog" is a complexity checker for Ruby files. See the project's page for +details: + + http://ruby.sadi.st/Flog.html + +Checker options~ + +This checker is initialised using the "makeprgBuild()" function and thus it +accepts the standard options described at |syntastic-config-makeprg|. + +Additionally: + + *'g:syntastic_ruby_flog_threshold_warning'* +Type: number +Default: 45 +Threshold for warnings. Functions with complexity below this number are not +flagged as either errors or warnings. + + *'g:syntastic_ruby_flog_threshold_error'* +Type: number +Default: 90 +Threshold for errors. Functions with complexity above this number are flagged +as errors. + + +Note~ + +"Flog" reports complexity values as floating point numbers. If your Vim is +not compiled with the "+float" feature, both the numbers reported by flog and +the two options above are rounded by syntastic towards zero (that is, "39.9" +is taken as "39"). + +------------------------------------------------------------------------------ +2. JRuby *syntastic-ruby-jruby* + +Name: jruby +Maintainer: Leonid Shevtsov <leonid@shevtsov.me> + +"JRuby" is a Java implementation of the Ruby programming language. See the +project's page for details: + + http://jruby.org/ + +Checker options~ + +This checker is initialised using the "makeprgBuild()" function and thus it +accepts the standard options described at |syntastic-config-makeprg|. + +------------------------------------------------------------------------------ +3. MacRuby *syntastic-ruby-macruby* + +Name: macruby +Maintainer: Martin Grenfell <martin.grenfell@gmail.com> + +"MacRuby" is an implementation of Ruby for Mac OS X. See the project's +pagefor details: + + http://www.macruby.org/ + +Checker options~ + +This checker is initialised using the "makeprgBuild()" function and thus it +accepts the standard options described at |syntastic-config-makeprg|. + +------------------------------------------------------------------------------ +4. MRI *syntastic-ruby-mri* + +Name: mri +Maintainer: Martin Grenfell <martin.grenfell@gmail.com> + +Checker options~ + +This checker is initialised using the "makeprgBuild()" function and thus it +accepts the standard options described at |syntastic-config-makeprg|. + +Additionally: + + *'g:syntastic_ruby_exec'* +Type: string +Default: unset +Ruby executable. This is a convenience variable shared with the eRuby checker +"Ruby" (cf. |syntastic-eruby-ruby|). Used only if 'g:syntastic_ruby_mri_exec' +is unset. + +------------------------------------------------------------------------------ +5. Reek *syntastic-ruby-reek* + +Name: reek +Maintainer: Mindaugas Mozūras + +"Reek" is a code smell detection tool for Ruby. See the project's page at +GitHub for details: + + https://github.com/troessner/reek + +Checker options~ + +This checker is initialised using the "makeprgBuild()" function and thus it +accepts the standard options described at |syntastic-config-makeprg|. + +------------------------------------------------------------------------------ +6. RuboCop *syntastic-ruby-rubocop* + +Name: rubocop +Maintainer: Recai Oktaş <roktas@bil.omu.edu.tr> + +"RuboCop" is a style checker for Ruby. See the project's page for details: + + https://github.com/bbatsov/rubocop + +Syntastic requires "RuboCop" version 0.12.0 or later. + +Running "RuboCop" under development versions of "Ruby" is explicitly NOT +supported. + +Checker options~ + +This checker is initialised using the "makeprgBuild()" function and thus it +accepts the standard options described at |syntastic-config-makeprg|. + +Notes~ + +Most issues returned by "rubocop" are warnings, so for best results your +|'syntastic_quiet_messages'| should not filter out warnings. + +If the "RuboCop" checker is not enabled automatically by syntastic try +running "rubocop --version" from the shell. If it complains about "Parser" +(see https://github.com/whitequark/parser) expecting a different version of +"Ruby" than you are running, your configuration is not directly supported by +syntastic. + +While passing around the blame for this does have a certain entertaining value +(cf. https://github.com/bbatsov/rubocop/issues/1819), the problem is real, +since "Ruby" syntax did change between versions. The solution is to run a +system such as "rbenv" (http://rbenv.org/) or "rvm" (https://rvm.io/), that +allows you to run multiple versions of "Ruby" without conflicts: > + $ rbenv version + 2.1.3 (set by /usr/local/var/rbenv/version) + + $ rubocop --version + warning: parser/current is loading parser/ruby21, which recognizes + warning: 2.1.2-compliant syntax, but you are running 2.1.3. + 0.26.1 + + $ rbenv shell 2.1.2 + + $ rubocop --version + 0.26.1 +< +Alternatively, if you absolutely must do it the wrong way, you can +also install a wrapper script that kills the version warning and point +'g:syntastic_ruby_rubocop_exec' to it: + + https://gist.github.com/lcd047/96138909015f2f8d2d36 + +------------------------------------------------------------------------------ +7. Ruby-lint *syntastic-ruby-rubylint* + +Name: rubylint +Maintainer: Yorick Peterse <yorickpeterse@gmail.com> + +"Ruby-lint" is a linter and static code analysis tool for Ruby. See the +project's page for details: + + https://github.com/YorickPeterse/ruby-lint + +Checker options~ + +This checker is initialised using the "makeprgBuild()" function and thus it +accepts the standard options described at |syntastic-config-makeprg|. + +Note~ + +If the "rubylint" checker is not enabled automatically by syntastic, try +running "ruby-lint --version" from the shell. If it complains about "Parser" +(see https://github.com/whitequark/parser) expecting a different version of +"Ruby" than you are running, your configuration is not directly supported by +syntastic. + +While passing around the blame for this does have a certain entertaining value +(cf. https://github.com/bbatsov/rubocop/issues/1819), the problem is real, +since "Ruby" syntax did change between versions. The solution is to run a +system such as "rbenv" (http://rbenv.org/) or "rvm" (https://rvm.io/), that +allows you to run multiple versions of "Ruby" without conflicts: > + $ rbenv version + 2.1.3 (set by /usr/local/var/rbenv/version) + + $ ruby-lint --version + warning: parser/current is loading parser/ruby21, which recognizes + warning: 2.1.2-compliant syntax, but you are running 2.1.3. + ruby-lint v2.0.4 on ruby 2.1.3 [i486-linux] + + $ rbenv shell 2.1.2 + + $ ruby-lint --version + ruby-lint v2.0.4 on ruby 2.1.2 [i486-linux] +< +Alternatively, if you absolutely must do it the wrong way, you can +also install a wrapper script that kills the version warning and point +'g:syntastic_ruby_rubylint_exec' to it: + + https://gist.github.com/lcd047/492245d9923af45fb964 + +============================================================================== +SYNTAX CHECKERS FOR SASS *syntastic-checkers-sass* + +The following checkers are available for SASS (filetype "sass"): + + 1. Sass.....................|syntastic-sass-sass| + 2. Sass Lint................|syntastic-sass-sass_lint| + 3. SassC....................|syntastic-sass-sassc| + +------------------------------------------------------------------------------ +1. Sass *syntastic-sass-sass* + +Name: sass +Maintainer: Martin Grenfell <martin.grenfell@gmail.com> + +"Sass" is a translator for SASS. See the project's page for details: + + http://sass-lang.com/ + +Installation~ + +Install it with "gem": > + gem install sass +< +Checker options~ + +This checker is initialised using the "makeprgBuild()" function and thus it +accepts the standard options described at |syntastic-config-makeprg|. + +See also: |syntastic-scss-sass|. + +------------------------------------------------------------------------------ +2. Sass Lint *syntastic-sass-sass_lint* + +Name: sass_lint +Maintainer: LCD 47 <lcd047@gmail.com> + +"Sass Lint" is a checker for SASS and SCSS files. See the project's page for +details: + + https://github.com/sasstools/sass-lint + +Syntastic requires "Sass Lint" version 1.5.0 or later. + +Checker options~ + +This checker is initialised using the "makeprgBuild()" function and thus it +accepts the standard options described at |syntastic-config-makeprg|. + +See also: |syntastic-scss-sass_lint|. + +------------------------------------------------------------------------------ +3. SassC *syntastic-sass-sassc* + +Name: sassc +Maintainer: LCD 47 <lcd047@gmail.com> + +"SassC" is a checker for SASS and SCSS files, based on the "libsass" library +(https://github.com/hcatlin/libsass). See the project's page for details: + + https://github.com/hcatlin/sassc + +Checker options~ + +This checker is initialised using the "makeprgBuild()" function and thus it +accepts the standard options described at |syntastic-config-makeprg|. + +See also: |syntastic-scss-sassc|. + +============================================================================== +SYNTAX CHECKERS FOR SCALA *syntastic-checkers-scala* + +The following checkers are available for Scala (filetype "scala"): + + 1. fsc......................|syntastic-scala-fsc| + 2. scalac...................|syntastic-scala-scalac| + 3. Scalastyle...............|syntastic-scala-scalastyle| + +------------------------------------------------------------------------------ +1. fsc *syntastic-scala-fsc* + +Name: fsc +Maintainer: Gregor Uhlenheuer <kongo2002@gmail.com> + +Checker options~ + +This checker is initialised using the "makeprgBuild()" function and thus it +accepts the standard options described at |syntastic-config-makeprg|. + +------------------------------------------------------------------------------ +2. scalac *syntastic-scala-scalac* + +Name: scalac +Maintainer: Rickey Visinski <rickeyvisinski@gmail.com> + +"scalac" is a compiler for Scala. See the project's page for more information: + + http://docs.scala-lang.org + +Checker options~ + +This checker is initialised using the "makeprgBuild()" function and thus it +accepts the standard options described at |syntastic-config-makeprg|. + +------------------------------------------------------------------------------ +3. Scalastyle *syntastic-scala-scalastyle* + +Name: scalastyle +Maintainer: LCD 47 <lcd047@gmail.com> + +"Scalastyle" is a style checker for Scala. See the project's page for +details: + + http://www.scalastyle.org/ + +Syntastic uses the command line version of "Scalastyle": + + http://www.scalastyle.org/command-line.html + +Checker options~ + +This checker is initialised using the "makeprgBuild()" function and thus it +accepts the standard options described at |syntastic-config-makeprg|. + +Additionally: + + *'g:syntastic_scala_scalastyle_jar'* +Type: string +Default: "scalastyle-batch_2.10.jar" +Path to the "scalastyle-batch" jar file. You might want to set this to a full +path. + + *'g:syntastic_scala_scalastyle_config_file'* +Type: string +Default: "scalastyle_config.xml" +Path to the configuration file to use. You might want to also set this to a +full path. + +============================================================================== +SYNTAX CHECKERS FOR SCSS *syntastic-checkers-scss* + +The following checkers are available for SCSS (filetype "scss"): + + 1. mixedindentlint..........|syntastic-scss-mixedindentlint| + 2. Sass.....................|syntastic-scss-sass| + 3. Sass Lint................|syntastic-scss-sass_lint| + 4. SassC....................|syntastic-scss-sassc| + 5. SCSS-lint................|syntastic-scss-scss_lint| + 6. stylelint................|syntastic-scss-stylelint| + +------------------------------------------------------------------------------ +1. mixedindentlint *syntastic-scss-mixedindentlint* + +Name: mixedindentlint +Maintainer: Payton Swick <payton@foolord.com> + +"mixedindentlint" is a general-purpose indentation checker. See the project's +page at GitHub for more information: + + https://github.com/sirbrillig/mixedindentlint + +Checker options~ + +This checker is initialised using the "makeprgBuild()" function and thus it +accepts the standard options described at |syntastic-config-makeprg|. + +See also: |syntastic-css-mixedindentlint|, |syntastic-javascript-mixedindentlint|. + +------------------------------------------------------------------------------ +2. Sass *syntastic-scss-sass* + +Name: sass +Maintainer: Martin Grenfell <martin.grenfell@gmail.com> + +"Sass" is a translator for SASS. See the project's page for details: + + http://sass-lang.com/ + +Installation~ + +Install it with "gem": > + gem install sass +< +Checker options~ + +This checker is initialised using the "makeprgBuild()" function and thus it +accepts the standard options described at |syntastic-config-makeprg|. + +See also: |syntastic-sass-sass|. + +------------------------------------------------------------------------------ +3. Sass Lint *syntastic-scss-sass_lint* + +Name: sass_lint +Maintainer: LCD 47 <lcd047@gmail.com> + +"Sass Lint" is a checker for SASS and SCSS files. See the project's page for +details: + + https://github.com/sasstools/sass-lint + +Syntastic requires "Sass Lint" version 1.5.0 or later. + +Checker options~ + +This checker is initialised using the "makeprgBuild()" function and thus it +accepts the standard options described at |syntastic-config-makeprg|. + +See also: |syntastic-sass-sass_lint|. + +------------------------------------------------------------------------------ +4. SassC *syntastic-scss-sassc* + +Name: sassc +Maintainer: LCD 47 <lcd047@gmail.com> + + +"SassC" is a checker for SASS and SCSS files, based on the "libsass" library +(https://github.com/hcatlin/libsass). See the project's page for details: + + https://github.com/hcatlin/sassc + +Checker options~ + +This checker is initialised using the "makeprgBuild()" function and thus it +accepts the standard options described at |syntastic-config-makeprg|. + +See also: |syntastic-sass-sassc|. + +------------------------------------------------------------------------------ +5. SCSS-lint *syntastic-scss-scss_lint* + +Name: scss_lint +Maintainer: Shane da Silva <shane@dasilva.io> + +"SCSS-Lint" is a lint tool for SCSS. See the project's page for details: + + https://github.com/brigade/scss-lint + +Syntastic requires "SCSS-Lint" version 0.29.0 or later. + +Installation~ + +Install it with "gem": > + gem install scss_lint +< +Checker options~ + +This checker is initialised using the "makeprgBuild()" function and thus it +accepts the standard options described at |syntastic-config-makeprg|. + +------------------------------------------------------------------------------ +6. stylelint *syntastic-scss-stylelint* + +Name: stylelint +Maintainer: Tim Carry <tim@pixelastic.com> + +"stylelint" is a style checker for Cascading Stylesheets. See the project's +page for more information: + + http://stylelint.io/ + +Checker options~ + +This checker is initialised using the "makeprgBuild()" function and thus it +accepts the standard options described at |syntastic-config-makeprg|. + +See also: |syntastic-css-stylelint|. + +============================================================================== +SYNTAX CHECKERS FOR SH *syntastic-checkers-sh* + +The following checkers are available for Sh (filetype "sh"): + + 1. Bashate..................|syntastic-sh-bashate| + 2. checkbashisms............|syntastic-sh-checkbashisms| + 3. sh.......................|syntastic-sh-sh| + 4. ShellCheck...............|syntastic-sh-shellcheck| + +------------------------------------------------------------------------------ +1. Bashate *syntastic-sh-bashate* + +Name: bashate +Maintainer: aswna + +"Bashate" is a style checker for bash scripts used by the OpenStack +(http://www.openstack.org/). See the project's page at GitHub for details: + + https://github.com/openstack-dev/bashate + +Installation~ + +Install it with "pip": > + pip install bashate +< +Checker options~ + +This checker is initialised using the "makeprgBuild()" function and thus it +accepts the standard options described at |syntastic-config-makeprg|. + +------------------------------------------------------------------------------ +2. checkbashisms *syntastic-sh-checkbashisms* + +Name: checkbashisms +Maintainer: LCD 47 <lcd047@gmail.com> + +"checkbashisms" is part of the Linux "devscripts" package. It can be obtained +from the Debian source archive: + + http://packages.qa.debian.org/d/devscripts.html + +For FreeBSD and OpenBSD you can also install the "devel/checkbashisms" port. + +Checker options~ + +This checker is initialised using the "makeprgBuild()" function and thus it +accepts the standard options described at |syntastic-config-makeprg|. + +------------------------------------------------------------------------------ +3. sh *syntastic-sh-sh* + +Name: sh +Maintainer: Gregor Uhlenheuer <kongo2002@gmail.com> + +Checker options~ + +This checker is initialised using the "makeprgBuild()" function and thus it +accepts the standard options described at |syntastic-config-makeprg|. + +------------------------------------------------------------------------------ +4. ShellCheck *syntastic-sh-shellcheck* + +Name: shellcheck +Maintainer: LCD 47 <lcd047@gmail.com> + +"ShellCheck" is a static analysis tool for Bourne shell scripts. See the +project's page for details: + + http://www.shellcheck.net/about.html + +Checker options~ + +This checker is initialised using the "makeprgBuild()" function and thus it +accepts the standard options described at |syntastic-config-makeprg|. + +============================================================================== +SYNTAX CHECKERS FOR SLIM *syntastic-checkers-slim* + +The following checkers are available for Slim (filetype "slim"): + + 1. Slim-Lint................|syntastic-slim-slim_lint| + 2. Slimrb...................|syntastic-slim-slimrb| + +------------------------------------------------------------------------------ +1. Slim-Lint *syntastic-slim-slim_lint* + +Name: slim_lint +Maintainer: Vasily Kolesnikov <re.vkolesnikov@gmail.com> + +"Slim-Lint" is a style checker for Slim files (http://slim-lang.com/). See +the project's page at GitHub for details: + + https://github.com/sds/slim-lint + +Checker options~ + +This checker is initialised using the "makeprgBuild()" function and thus it +accepts the standard options described at |syntastic-config-makeprg|. + +Installation~ + +You can install "Slim-Lint" with "gem": > + gem install slim_lint +< +------------------------------------------------------------------------------ +2. Slimrb *syntastic-slim-slimrb* + +Name: slimrb +Maintainer: Martin Grenfell <martin.grenfell@gmail.com> + +"Slimrb" is a processor for the template language Slim +(http://slim-lang.com/). See the project's page for details: + + https://github.com/slim-template/slim + +Checker options~ + +This checker is initialised using the "makeprgBuild()" function and thus it +accepts the standard options described at |syntastic-config-makeprg|. + +============================================================================== +SYNTAX CHECKERS FOR SML *syntastic-checkers-sml* + +The following checkers are available for SML (filetype "sml"): + + 1. smlnj....................|syntastic-sml-smlnj| + +------------------------------------------------------------------------------ +1. smlnj *syntastic-sml-smlnj* + +Name: smlnj +Maintainer: LCD 47 <lcd047@gmail.com> + +"smlnj" is a compiler for Standard ML '97. See the project's page for details: + + http://www.smlnj.org/ + +Checker options~ + +This checker is initialised using the "makeprgBuild()" function and thus it +accepts the standard options described at |syntastic-config-makeprg|. + +============================================================================== +SYNTAX CHECKERS FOR SQL *syntastic-checkers-sql* + +The following checkers are available for SQL (filetype "sql"): + + 1. sqlint...................|syntastic-sql-sqlint| + +------------------------------------------------------------------------------ +1. sqlint *syntastic-sql-sqlint* + +Name: sqlint +Maintainer: Steve Purcell <steve@sanityinc.com> + +"sqlint" is a lint checker for ANSI SQL. See the project's page at GitHub for +details: + + https://github.com/purcell/sqlint + +Checker options~ + +This checker is initialised using the "makeprgBuild()" function and thus it +accepts the standard options described at |syntastic-config-makeprg|. + +============================================================================== +SYNTAX CHECKERS FOR STYLUS *syntastic-checkers-stylus* + +The following checkers are available for Stylus (filetype "stylus"): + + 1. Stylint..................|syntastic-stylus-stylint| + +------------------------------------------------------------------------------ +1. Stylint *syntastic-stylus-stylint* + +Name: stylint +Maintainer: LCD 47 <lcd047@gmail.com> + +"Stylint" is a linter for Stylus (http://learnboost.github.io/stylus). See +the project's page at GitHub for details: + + https://github.com/rossPatton/stylint + +Checker options~ + +This checker is initialised using the "makeprgBuild()" function and thus it +accepts the standard options described at |syntastic-config-makeprg|. + +Note~ + +You might also find useful the "vim-stylus" plugin: + + https://github.com/wavded/vim-stylus + +============================================================================== +SYNTAX CHECKERS FOR TCL *syntastic-checkers-tcl* + +The following checkers are available for Tcl (filetype "tcl"): + + 1. nagelfar.................|syntastic-tcl-nagelfar| + +------------------------------------------------------------------------------ +1. nagelfar *syntastic-tcl-nagelfar* + +Name: nagelfar +Maintainer: James Pickard <james.pickard@gmail.com> + +"Nagelfar" is a syntax checker for Tcl. See the project's page for details: + + http://nagelfar.sourceforge.net/ + +Checker options~ + +This checker is initialised using the "makeprgBuild()" function and thus it +accepts the standard options described at |syntastic-config-makeprg|. + +============================================================================== +SYNTAX CHECKERS FOR TEX *syntastic-checkers-tex* + +The following checkers are available for TeX (filetype "tex"): + + 1. ChkTeX...................|syntastic-tex-chktex| + 2. lacheck..................|syntastic-tex-lacheck| + +------------------------------------------------------------------------------ +1. ChkTeX *syntastic-tex-chktex* + +Name: chktex +Maintainer: LCD 47 <lcd047@gmail.com> + +"ChkTeX" is a checker for TeX and LaTeX. See the project's page for details: + + http://baruch.ev-en.org/proj/chktex/ + +Checker options~ + +This checker is initialised using the "makeprgBuild()" function and thus it +accepts the standard options described at |syntastic-config-makeprg|. + +Additionally: + + *'g:syntastic_tex_chktex_showmsgs'* +Type: boolean +Default: 1 +Whether to show informational messages ("chktex" option "-m"). By default +informational messages are shown as warnings. + +------------------------------------------------------------------------------ +2. lacheck *syntastic-tex-lacheck* + +Name: lacheck +Maintainer: Martin Grenfell <martin.grenfell@gmail.com> + +"lacheck" is a style checker for LaTeX documents. See the project's page for +details: + + http://www.ctan.org/tex-archive/support/lacheck + +Checker options~ + +This checker is initialised using the "makeprgBuild()" function and thus it +accepts the standard options described at |syntastic-config-makeprg|. + +Limitations~ + +At the time of this writing "lacheck" can't expand "\def" commands. As a +result, most "\input" commands using macros are signaled as errors. + +============================================================================== +SYNTAX CHECKERS FOR TEXINFO *syntastic-checkers-texinfo* + +The following checkers are available for Texinfo (filetype "texinfo"): + + 1. Makeinfo.................|syntastic-texinfo-makeinfo| + +------------------------------------------------------------------------------ +1. Makeinfo *syntastic-texinfo-makeinfo* + +Name: makeinfo +Maintainer: LCD 47 <lcd047@gmail.com> + +"Makeinfo" is a convertor for Texinfo files. It is distributed together with +the GNU package "texinfo": + + http://www.gnu.org/software/texinfo/ + +Checker options~ + +This checker is initialised using the "makeprgBuild()" function and thus it +accepts the standard options described at |syntastic-config-makeprg|. + +============================================================================== +SYNTAX CHECKERS FOR TEXT *syntastic-checkers-text* + +The following checkers are available for plain text (filetype "text"): + + 1. atdtool..................|syntastic-text-atdtool| + 2. Igor.....................|syntastic-text-igor| + 3. language-check...........|syntastic-text-language_check| + 4. textlint.................|syntastic-text-textlint| + +------------------------------------------------------------------------------ +1. atdtool *syntastic-text-atdtool* + +Name: atdtool +Maintainer: LCD 47 <lcd047@gmail.com> + +"atdtool" is a script that runs a text file through the "After the Deadline" +language service (http://www.afterthedeadline.com/) and returns a list of +spelling, style, and grammar errors. See the project's page for details: + + https://github.com/lpenz/atdtool + +See also the list of features of "After the Deadline": + + http://www.afterthedeadline.com/features.slp + +Checker options~ + +This checker is initialised using the "makeprgBuild()" function and thus it +accepts the standard options described at |syntastic-config-makeprg|. + +------------------------------------------------------------------------------ +2. Igor *syntastic-text-igor* + +Name: igor +Maintainer: LCD 47 <lcd047@gmail.com> + +"Igor" is a proofreader for DocBook SGML, man pages, and text files used by +the FreeBSD (https://www.freebsd.org/). See the author's presentation for +details: + + http://www.youtube.com/watch?v=sczHqUPygZY + +The latest version can be obtained from Glen Barber's repository: + + http://docscripts.glenbarber.us/tags/igor/ + +Checker options~ + +This checker is initialised using the "makeprgBuild()" function and thus it +accepts the standard options described at |syntastic-config-makeprg|. + +See also: |syntastic-docbk-igor|, |syntastic-nroff-igor|. + +------------------------------------------------------------------------------ +3. language-check *syntastic-text-language_check* + +Name: language_check +Maintainer: Steven Myint <git@stevenmyint.com> + +"language-check" is a wrapper for the LanguageTool grammar checker +(https://www.languagetool.org/). See the project's page for details: + + https://github.com/myint/language-check + +Checker options~ + +This checker is initialised using the "makeprgBuild()" function and thus it +accepts the standard options described at |syntastic-config-makeprg|. + +------------------------------------------------------------------------------ +4. textlint *syntastic-text-textlint* + +Name: textlint +Maintainer: LCD 47 <lcd047@gmail.com> + +"textlint" is a natural language linter for text, Markdown, and HTML files. +See the project's page for details: + + https://textlint.github.io/ + +Checker options~ + +This checker is initialised using the "makeprgBuild()" function and thus it +accepts the standard options described at |syntastic-config-makeprg|. + +See also: |syntastic-html-textlint|, |syntastic-markdown-textlint|. + +============================================================================== +SYNTAX CHECKERS FOR TRIG *syntastic-checkers-trig* + +The following checkers are available for TriG (filetype "trig"): + + 1. rapper...................|syntastic-trig-rapper| + +------------------------------------------------------------------------------ +1. rapper *syntastic-trig-rapper* + +Name: rapper +Maintainer: Sebastian Tramp <mail@sebastian.tramp.name> + +"rapper" is an RDF parsing and serializing utility. See the project's page for +details: + + http://librdf.org/raptor/rapper.html + +Checker options~ + +This checker is initialised using the "makeprgBuild()" function and thus it +accepts the standard options described at |syntastic-config-makeprg|. + +Note~ + +You probably also need a plugin to set |filetype| for TriG files, such as +"Vim-RDF": + + https://github.com/niklasl/vim-rdf + +See also: |syntastic-turtle-rapper|. + +============================================================================== +SYNTAX CHECKERS FOR TURTLE *syntastic-checkers-turtle* + +The following checkers are available for Turtle (filetype "turtle"): + + 1. rapper...................|syntastic-turtle-rapper| + 2. ttl......................|syntastic-turtle-ttl| + +------------------------------------------------------------------------------ +1. rapper *syntastic-turtle-rapper* + +Name: rapper +Maintainer: Sebastian Tramp <mail@sebastian.tramp.name> + +"rapper" is an RDF parsing and serializing utility. See the project's page +for details: + + http://librdf.org/raptor/rapper.html + +Checker options~ + +This checker is initialised using the "makeprgBuild()" function and thus it +accepts the standard options described at |syntastic-config-makeprg|. + +Note~ + +You probably also need a plugin to set |filetype| for Turtle files, such as +"Vim-RDF": + + https://github.com/niklasl/vim-rdf + +See also: |syntastic-trig-rapper|. + +------------------------------------------------------------------------------ +2. ttl *syntastic-turtle-ttl* + +Name: ttl +Maintainer: Antoine Reilles <tonio@NetBSD.org> + +"ttl" is an RDF validator. See the project's page at GitHub for details: + + https://github.com/mmlab/TurtleValidator + +Checker options~ + +This checker is initialised using the "makeprgBuild()" function and thus it +accepts the standard options described at |syntastic-config-makeprg|. + +Note~ + +You probably also need a plugin to set |filetype| for Turtle files, such as +"Vim-RDF": + + https://github.com/niklasl/vim-rdf + +============================================================================== +SYNTAX CHECKERS FOR TWIG *syntastic-checkers-twig* + +The following checkers are available for Twig (filetype "twig"): + + 1. twig-lint................|syntastic-twig-twiglint| + +------------------------------------------------------------------------------ +1. twig-lint *syntastic-twig-twiglint* + +Name: twiglint +Maintainer: Alexander <iam.asm89@gmail.com> + +"twig-lint" is a lint tool for Twig templates. See the project's page at +GitHub for details: + + https://github.com/asm89/twig-lint + +Checker options~ + +This checker is initialised using the "makeprgBuild()" function and thus it +accepts the standard options described at |syntastic-config-makeprg|. + +Notes~ + +For the standalone executable, add the following to your vimrc file: > + let g:syntastic_twig_twiglint_exec = "php" + let g:syntastic_twig_twiglint_exe = "php /path/to/twig-lint.phar" +< +For the "Composer" (https://getcomposer.org/) dependency "twig-lint" must be +in your "$PATH". No further configuration is needed. + +============================================================================== +SYNTAX CHECKERS FOR TYPESCRIPT *syntastic-checkers-typescript* + +The following checkers are available for TypeScript (filetype "typescript"): + + 1. ESLint...................|syntastic-typescript-eslint| + 2. tsc......................|syntastic-typescript-tsc| + 3. TSLint...................|syntastic-typescript-tslint| + +------------------------------------------------------------------------------ +1. ESLint *syntastic-typescript-eslint* + +Name: eslint +Maintainer: LCD 47 <lcd047@gmail.com> + +"ESLint" is a tool for identifying and reporting on patterns found +in ECMAScript/JavaScript code. With the "babel-eslint" plugin +(https://github.com/babel/babel-eslint) "ESLint" can also can also be +used to check TypeScript files. See the project's page for details: + + https://github.com/nzakas/eslint + +Checker options~ + +This checker is initialised using the "makeprgBuild()" function and thus it +accepts the standard options described at |syntastic-config-makeprg|. + +Note~ + +You probably also need a plugin to set |filetype| for TypeScript files, such +as "typescript-vim": + + https://github.com/leafgarland/typescript-vim + +See also: |syntastic-html-eslint|, |syntastic-javascript-eslint|. + +------------------------------------------------------------------------------ +2. tsc *syntastic-typescript-tsc* + +Name: tsc +Maintainer: Bill Casarin <bill@casarin.ca> + +"tsc" is a compiler for TypeScript. See the project's page for details: + + http://www.typescriptlang.org/ + +Checker options~ + +This checker is initialised using the "makeprgBuild()" function and thus it +accepts the standard options described at |syntastic-config-makeprg|. + +Note~ + +You probably also need a plugin to set |filetype| for TypeScript files, such +as "typescript-vim": + + https://github.com/leafgarland/typescript-vim + +------------------------------------------------------------------------------ +3. TSLint *syntastic-typescript-tslint* + +Name: tslint +Maintainer: Seon-Wook Park <seon.wook@swook.net> + +"TSLint" is a lint checker for TypeScript. See the project's page for +details: + + https://github.com/palantir/tslint + +Checker options~ + +This checker is initialised using the "makeprgBuild()" function and thus it +accepts the standard options described at |syntastic-config-makeprg|. + +Note~ + +You probably also need a plugin to set |filetype| for TypeScript files, such +as "typescript-vim": + + https://github.com/leafgarland/typescript-vim + +============================================================================== +SYNTAX CHECKERS FOR VALA *syntastic-checkers-vala* + +The following checkers are available for Vala (filetype "vala"): + + 1. Valac....................|syntastic-vala-valac| + +------------------------------------------------------------------------------ +1. Valac *syntastic-vala-valac* + +Name: valac +Maintainer: Konstantin Stepanov (me@kstep.me) + +"valac" is a compiler for Vala. See the project's page for details: + + https://wiki.gnome.org/Projects/Vala + +Checker options~ + +This checker is initialised using the "makeprgBuild()" function and thus it +accepts the standard options described at |syntastic-config-makeprg|. + +Additionally: + + *'g:syntastic_vala_modules'* +Type: string or array of strings +Default: unset +Space-separated list of Vala modules to be passed as "--pkg" arguments. + + *'g:syntastic_vala_vapi_dirs'* +Type: string or array of strings +Default: unset +Space-separated list of "vapi" directories to be passed as "--vapidirs" +arguments. + +Notes~ + +If |'g:syntastic_vala_modules'| is unset, you can also specify a list of +module to load for the current file by adding a special comment starting with +"// modules: " and containing a space-delimited list of names. + +If |'g:syntastic_vala_vapi_dirs'| is unset, you can also specify a list of +"vapi" directories for the current file by adding a special comment starting +with "// vapidirs:" and containing a space-delimited list of names. + +============================================================================== +SYNTAX CHECKERS FOR VERILOG *syntastic-checkers-verilog* + +The following checkers are available for Verilog (filetype "verilog"): + + 1. Icarus Verilog...........|syntastic-verilog-iverilog| + 2. Verilator................|syntastic-verilog-verilator| + +------------------------------------------------------------------------------ +1. Icarus Verilog *syntastic-verilog-iverilog* + +Name: iverilog +Maintainer: Psidium <psiidium@gmail.com> + +"Icarus Verilog" is a Verilog simulation and synthesis tool. See the +project's page for details: + + http://iverilog.icarus.com/ + +Checker options~ + +This checker is initialised using the "makeprgBuild()" function and thus it +accepts the standard options described at |syntastic-config-makeprg|. + +------------------------------------------------------------------------------ +2. Verilator *syntastic-verilog-verilator* + +Name: verilator +Maintainer: Kocha <kocha.lsifrontend@gmail.com> + +Checker options~ + + *'g:syntastic_verilog_compiler'* +Type: string +Default: "verilator" +Compiler executable. + + *'g:syntastic_verilog_errorformat'* +Type: string +Default: unset +Override for the default |'errorformat'|. + + *'g:syntastic_verilog_remove_include_errors'* +Type: boolean +Default: 0 +By default, errors in files included from the file being checked are shown. +Set this variable to 1 to remove messages about errors in included files. +Please note that this means syntastic will silently abort checks if there are +fatal errors in one of the included files. + + *'g:syntastic_verilog_compiler_options'* +Type: string +Default: unset +Compilation flags (such as defines or include directories) to be passed to the +checker. + + *'g:syntastic_verilog_config_file'* +Type: string +Default: ".syntastic_verilog_config" +File containing additional compilation flags to be passed to the checker, one +option per line (cf. |syntastic-config-files|). + + *'g:syntastic_verilog_include_dirs'* +Type: array of strings +Default: [] +Include directories to be passed to the checker, in addition to the +above compilation flags. You can set it like this: > + let g:syntastic_verilog_include_dirs = ["includes", "headers"] +< +and the corresponding "-Iincludes -Iheaders" will be added to the compilation +flags. + + *'b:syntastic_verilog_cflags'* +Type: string +Default: unset +Buffer-local variable. Additional compilation flags specific to the current +buffer. + +Note~ + +This checker doesn't call the "makeprgBuild()" function, and thus it ignores +the usual 'g:syntastic_verilog_verilator_<option>' variables. The only +exception is 'g:syntastic_verilog_verilator_exec', which can still be used to +override the checker's executable. + +============================================================================== +SYNTAX CHECKERS FOR VHDL *syntastic-checkers-vhdl* + +The following checkers are available for VHDL (filetype "vhdl"): + + 1. GHDL.....................|syntastic-vhdl-ghdl| + 2. vcom.....................|syntastic-vhdl-vcom| + +------------------------------------------------------------------------------ +1. GHDL *syntastic-vhdl-ghdl* + +Name: ghdl +Maintainer: Jan Wagner <jaydyou@janidom.de> + +"GHDL" is a VHDL simulator. See the project's page for details: + + http://gna.org/projects/ghdl/ + +Checker options~ + +This checker is initialised using the "makeprgBuild()" function and thus it +accepts the standard options described at |syntastic-config-makeprg|. + +------------------------------------------------------------------------------ +2. vcom *syntastic-vhdl-vcom* + +Name: vcom +Maintainer: Jim Vogel <jim.e.vogel@gmail.com> + +"vcom" is compiler for VHDL files distributed with the "ModelSim" HDL +simulation environment: + + https://www.mentor.com/products/fpga/model/ + +Checker options~ + +This checker is initialised using the "makeprgBuild()" function and thus it +accepts the standard options described at |syntastic-config-makeprg|. + +============================================================================== +SYNTAX CHECKERS FOR VIML *syntastic-checkers-vim* + +The following checkers are available for VimL (filetype "vim"): + + 1. Vimlint..................|syntastic-vim-vimlint| + 2. Vint.....................|syntastic-vim-vint| + +------------------------------------------------------------------------------ +1. Vimlint *syntastic-vim-vimlint* + +Name: vimlint +Maintainer: LCD 47 <lcd047@gmail.com> + +"Vimlint" is a lint checker for VimL written in pure VimL, based on Yukihiro +Nakadaira's "vimlparser" (https://github.com/ynkdir/vim-vimlparser/). See the +project's page for details: + + https://github.com/syngan/vim-vimlint/ + +Installation~ + +You need to install the Vim plugins "vim-vimlint" and "vim-vimlparser" +mentioned above. + +Checker Options~ + + *'g:syntastic_vimlint_options'* +Type: dictionary +Default: |EVL102|, |EVL103|, |EVL104|, |EVL105|, |EVL106|, |EVL201|, |EVL204|, and |EVL205| + are warnings. +Dictionary of "Vimlint" options, with the same syntax as |g:vimlint#config|. +See |g:vimlint#config| and |vimlint-errorcode| for more details. + +"Vimlint" does not call the "makeprgBuild()" function, and thus ignores the +usual 'g:syntastic_vim_vimlint_<option>' variables. + +Note~ + +The values of |'g:syntastic_vimlint_options'| useful for syntastic are those +that ignore or change the severity of some "EVLxxx" messages. For example +to ignore warnings about unused arguments: > + let g:syntastic_vimlint_options = { "EVL103": 1 } +< +Limitation~ + +Certain error messages can't be turned off by |'g:syntastic_vimlint_options'|. +This is a misfeature of "Vimlint" rather than a limitation of syntastic. You +can still ignore these messages using the standard mechanism of +|'syntastic_quiet_messages'|: > + let g:syntastic_vim_vimlint_quiet_messages = { "regex": '\v\[EVL%(105|205)\]' } +< +At the time of this writing the messages that can't be turned off by setting +|'g:syntastic_vimlint_options'| are: + + |EVL105| - global variable defined without 'g:' + |EVL202| - missing call + |EVL203| - parse error in command + |EVL205| - missing 'scriptencoding' + |EVL901| - unknown type + |EVL902| - assert error. + +------------------------------------------------------------------------------ +2. Vint *syntastic-vim-vint* + +Name: vint +Maintainer: LCD 47 <lcd047@gmail.com> + +"Vint" is a lint checker for VimL. See the project's page at GitHub for +details: + + https://github.com/Kuniwak/vint + +Checker options~ + +This checker is initialised using the "makeprgBuild()" function and thus it +accepts the standard options described at |syntastic-config-makeprg|. + +============================================================================== +SYNTAX CHECKERS FOR XHTML *syntastic-checkers-xhtml* + +The following checkers are available for xHTML (filetype "xhtml"): + + 1. HTML Tidy................|syntastic-xhtml-tidy| + 2. jshint...................|syntastic-xhtml-jshint| + +------------------------------------------------------------------------------ +1. HTML tidy *syntastic-xhtml-tidy* + +Name: tidy +Maintainer: Martin Grenfell <martin.grenfell@gmail.com> + +"HTML Tidy" is a syntax checker and formatter for HTML. See the HTML Tidy +Library Project for more information: + + http://tidy.sourceforge.net/ + +Checker options~ + +This checker is initialised using the "makeprgBuild()" function and thus it +accepts the standard options described at |syntastic-config-makeprg|. + +Additionally: + + *'g:syntastic_xhtml_tidy_ignore_errors'* +Type: array of strings +Default: [] +List of errors to ignore. Case-sensitive patterns matched as substrings +(not regular expressions) against the error messages. See also +|'syntastic_quiet_messages'|. + +See also: |syntastic-html-tidy|. + +------------------------------------------------------------------------------ +2. jshint *syntastic-xhtml-jshint* + +Name: JSHint +Maintainer: LCD 47 <lcd047@gmail.com> + +"JSHint" can detect JavaScript errors and potential problems in HTML +files. See the project's page for details: + + http://jshint.com/ + +Syntastic requires "JSHint" version 2.4.0 or later. + +Checker options~ + +This checker is initialised using the "makeprgBuild()" function and thus it +accepts the standard options described at |syntastic-config-makeprg|. + +Note~ + +If you're checking files containing tab characters then "JSHint"'s idea of +tabstop must match Vim's 'tabstop', otherwise syntastic will highlight the +errors at shifted positions. By default "JSHint"'s tabstop is 4, while Vim's +default 'tabstop' is 8. + +In order to change "JSHint"'s tabstop you have to change its "indent" config +option (cf. http://jshint.com/docs/options/#indent). One way to do that is +to put it in a file named ".jshintrc" in the current directory, the parent +directories, or your home directory. The file is supposed to be in JSON +format. For example: > + { + "indent": 8 + } +< +See JSHint documentation for more details: + + http://jshint.com/docs/ + +Please note however that setting "indent" also triggers the indentation checks +in "JSHint". If that is undesirable, your only other option is to leave +"JSHint"'s tabstop alone, and change Vim's 'tabstop' to 4. To change Vim's +'tabstop', you can add this to your vimrc: > + set tabstop=4 +< +See also: |syntastic-html-jshint|, |syntastic-javascript-jshint|. + +============================================================================== +SYNTAX CHECKERS FOR XML *syntastic-checkers-xml* + +The following checkers are available for XML (filetype "xml"): + + 1. plutil...................|syntastic-xml-plutil| + 2. xmllint..................|syntastic-xml-xmllint| + +------------------------------------------------------------------------------ +1. plutil *syntastic-xml-plutil* + +Name: plutil +Maintainer: LCD 47 <lcd047@gmail.com> + +"plutil" is a checker for OS X and iOS property list files. See the "plist(5)" +and "plutil(1)" manual pages for details: + + https://developer.apple.com/library/mac/documentation/Darwin/Reference/ManPages/man5/plist.5.html + https://developer.apple.com/library/mac/documentation/Darwin/Reference/ManPages/man1/plutil.1.html + +Checker options~ + +This checker is initialised using the "makeprgBuild()" function and thus it +accepts the standard options described at |syntastic-config-makeprg|. + +------------------------------------------------------------------------------ +2. xmllint *syntastic-xml-xmllint* + +Name: xmllint +Maintainer: Sebastian Kusnier <sebastian@kusnier.net> + +"xmllint" is a checker and transformer tool for XML files, distributed with +the "libxml" package (http://www.xmlsoft.org/). See the tool's manual for more +information: + + http://xmlsoft.org/xmllint.html + +Checker options~ + +This checker is initialised using the "makeprgBuild()" function and thus it +accepts the standard options described at |syntastic-config-makeprg|. + +Note~ + +You can use a local installation of DTDs to significantly speed up validation +and allow you to validate XML data without network access. See the +"xmlcatalog" manual, and the catalog documentation for more information: + + http://www.xmlsoft.org/xmlcatalog_man.html + http://www.xmlsoft.org/catalog.html + +For an example of a DTD catalog see f.i. "XMLCatalog": + + https://github.com/darcyparker/XMLCatalog + +In order to use it with syntastic you'll have to clone it to a local +directory, and point the environment variable "XML_CATALOG_FILES" to the file +"catalog.xml" in the said directory: > + XML_CATALOG_FILES=/some/path/XMLCatalog/catalog.xml + export XML_CATALOG_FILES +< +Otherwise "xmllint" will try to load XML catalogs from "/etc/xml/catalog". + +See also: |syntastic-docbk-xmllint|, |syntastic-xslt-xmllint|. + +============================================================================== +SYNTAX CHECKERS FOR XQUERY *syntastic-checkers-xquery* + +The following checkers are available for XQuery (filetype "xquery"): + + 1. BaseX....................|syntastic-xquery-basex| + +------------------------------------------------------------------------------ +1. BaseX *syntastic-xquery-basex* + +Name: basex +Maintainer: James Wright <james.jw@hotmail.com> + +"BaseX" is an XML database engine and XPath`/`XQuery processor. See the +project's page for details: + + http://basex.org/ + +Installation~ + +1. Install "BaseX" +2. Add the "basex/bin" folder to your "$PATH". + +Checker options~ + +This checker is initialised using the "makeprgBuild()" function and thus it +accepts the standard options described at |syntastic-config-makeprg|. + +============================================================================== +SYNTAX CHECKERS FOR XSLT *syntastic-checkers-xslt* + +The following checkers are available for XSLT (filetype "xslt"): + + 1. xmllint..................|syntastic-xslt-xmllint| + +------------------------------------------------------------------------------ +1. xmllint *syntastic-xslt-xmllint* + +Name: xmllint +Maintainer: Sebastian Kusnier <sebastian@kusnier.net> + +"xmllint" is a checker and transformer tool for XML files, distributed with +the "libxml" package (http://www.xmlsoft.org/). See the tool's manual for more +information: + + http://xmlsoft.org/xmllint.html + +Checker options~ + +This checker is initialised using the "makeprgBuild()" function and thus it +accepts the standard options described at |syntastic-config-makeprg|. + +See also: |syntastic-docbk-xmllint|, |syntastic-xml-xmllint|. + +============================================================================== +SYNTAX CHECKERS FOR YACC *syntastic-checkers-yacc* + +The following checkers are available for YACC (filetype "yacc"): + + 1. Bison....................|syntastic-yacc-bison| + +------------------------------------------------------------------------------ +1. Bison *syntastic-yacc-bison* + +Name: bison +Maintainer: LCD 47 <lcd047@gmail.com> + +"Bison" is the GNU implementation of the standard UNIX parser generator +"yacc" (http://en.wikipedia.org/wiki/Yacc). See the project's page for more +information: + + http://www.gnu.org/software/bison/ + +Checker options~ + +This checker is initialised using the "makeprgBuild()" function and thus it +accepts the standard options described at |syntastic-config-makeprg|. + +============================================================================== +SYNTAX CHECKERS FOR YAML *syntastic-checkers-yaml* + +The following checkers are available for YAML (filetype "yaml"): + + 1. JavaScript YAML..........|syntastic-yaml-jsyaml| + 2. yamllint.................|syntastic-yaml-yamllint| + 3. YAML::XS.................|syntastic-yaml-yamlxs| + +------------------------------------------------------------------------------ +1. JavaScript YAML *syntastic-yaml-jsyaml* + +Name: jsyaml +Maintainer: Martin Grenfell <martin.grenfell@gmail.com> + +"JavaScript YAML" is a parser for YAML. See the project's page at GitHub for +details: + + https://github.com/nodeca/js-yaml + +Installation~ + +Install it with "npm": > + npm install -g js-yaml +< +Checker options~ + +This checker is initialised using the "makeprgBuild()" function and thus it +accepts the standard options described at |syntastic-config-makeprg|. + +------------------------------------------------------------------------------ +2. yamllint *syntastic-yaml-yamllint* + +Name: yamllint +Maintainer: Adrien VergĂŠ+ +Checker options~ + +This checker is initialised using the "makeprgBuild()" function and thus it +accepts the standard options described at |syntastic-config-makeprg|. + +"yamllint" is a linter and style checker for YAML. +See the project's page at GitHub for details: + + https://github.com/adrienverge/yamllint + +Installation~ + +Install it with "pip": > + pip install yamllint +< +------------------------------------------------------------------------------ +3. YAML::XS *syntastic-yaml-yamlxs* + +Name: yamlxs +Maintainer: LCD 47 <lcd047@gmail.com> + +This is a syntax checker for YAML 1.1 using the Perl module "YAML::XS": + + https://metacpan.org/pod/YAML::XS + +Checker options~ + +This checker is initialised using the "makeprgBuild()" function and thus it +accepts the standard options described at |syntastic-config-makeprg|. + +Additionally: + + 'g:syntastic_perl_interpreter' +Type: string +Default: "perl" +The perl interpreter to use. + + 'g:syntastic_perl_lib_path' +Type: list +Default: [] +List of include directories to be added to the perl command line. Example: > + let g:syntastic_perl_lib_path = [ "/usr/local/lib/perl5/auto" ] +< +Note~ + +The variable |'g:syntastic_perl_interpreter'| is shared with the "perl" checker +(cf. |syntastic-perl-perl|). If for some reasons you don't want to use the same +interpreter for both checkers, you can override it locally by setting +'g:syntastic_yaml_yamlxs_exec'. + +============================================================================== +SYNTAX CHECKERS FOR YANG *syntastic-checkers-yang* + +The following checkers are available for YANG data models (filetype "yang"): + + 1. pyang....................|syntastic-yang-pyang| + +------------------------------------------------------------------------------ +1. pyang *syntastic-yang-pyang* + +Name: pyang +Maintainer: Joshua Downer <joshua.downer@gmail.com> + +"pyang" is a validator for YANG data models (http://www.yang-central.org/). +See the project's page at GitHub for more information: + + https://github.com/mbj4668/pyang + +Checker options~ + +This checker is initialised using the "makeprgBuild()" function and thus it +accepts the standard options described at |syntastic-config-makeprg|. + +Note~ + +You probably also need a plugin to set |filetype| for YANG files, such as +"yang.vim": + + https://github.com/nathanalderson/yang.vim + +============================================================================== +SYNTAX CHECKERS FOR Z80 *syntastic-checkers-z80* + +The following checkers are available for Z80 (filetype "z80"): + + 1. Z80syntaxchecker.........|syntastic-z80-z80syntaxchecker| + +------------------------------------------------------------------------------ +1. Z80syntaxchecker *syntastic-z80-z80syntaxchecker* + +Name: z80syntaxchecker +Maintainer: Romain Giot <giot.romain@gmail.com> + +"Z80syntaxchecker" is a syntax checker for Z80 assembly files. + +Installation~ + +To install "Z80syntaxchecker" either install "pycpcdemotools" +(https://github.com/cpcsdk/pycpcdemotools), or copy the following script to a +directory in your "$PATH": + + https://raw.githubusercontent.com/rgiot/pycpcdemotools/master/cpcdemotools/source_checker/z80_syntax_checker.py + +Checker options~ + +This checker is initialised using the "makeprgBuild()" function and thus it +accepts the standard options described at |syntastic-config-makeprg|. + +============================================================================== +SYNTAX CHECKERS FOR ZOPE PAGE TEMPLATES *syntastic-checkers-zpt* + +The following checkers are available for Zope Page Templates (filetype "zpt"): + + 1. zptlint..................|syntastic-zpt-zptlint| + +------------------------------------------------------------------------------ +1. zptlint *syntastic-zpt-zptlint* + +Name: zptlint +Maintainer: claytron <robots@claytron.com> + +"zptlint" is a checker for Zope Page Templates. See the project's README for +more information: + + https://trac.bubblenet.be/browser/bubblenet/pythoncode/zptlint/trunk/README.txt?format=txt + +Installation~ + +Install it with "pip": > + pip install zptlint +< +Checker options~ + +This checker is initialised using the "makeprgBuild()" function and thus it +accepts the standard options described at |syntastic-config-makeprg|. + +Note~ + +You probably also need to set |filetype| for Zope Page Templates to "zpt". +You can do that with an `:autocmd`: > + autocmd BufNewFile,BufRead *.pt,*.cpt,*.zpt set filetype=zpt syntax=xml +< +============================================================================== +SYNTAX CHECKERS FOR ZSH *syntastic-checkers-zsh* + +The following checkers are available for Zsh (filetype "zsh"): + + 1. zsh......................|syntastic-zsh-zsh| + +------------------------------------------------------------------------------ +1. zsh *syntastic-zsh-zsh* + +Name: zsh +Maintainer: Martin Grenfell <martin.grenfell@gmail.com> + +Checker options~ + +This checker is initialised using the "makeprgBuild()" function and thus it +accepts the standard options described at |syntastic-config-makeprg|. + +============================================================================== +CONFIGURATION FILES *syntastic-config-files* + + Supported checkers..........|syntastic-config-checkers| + Naming......................|syntastic-config-naming| + Location....................|syntastic-config-location| + Format......................|syntastic-config-format| + + *syntastic-config-checkers* +Currently, the following checkers can read some of their options from +syntastic-specific configuration files: + + ADA~ + GCC (|syntastic-ada-gcc|) + + Assembly Languages~ + GCC (|syntastic-asm-gcc|) + + C~ + AVR-GCC (|syntastic-c-avrgcc|) + ClangCheck (|syntastic-c-clang_check|) + Clang-Tidy (|syntastic-c-clang_tidy|) + Cppcheck (|syntastic-c-cppcheck|) + GCC (|syntastic-c-gcc|) + OCLint (|syntastic-c-oclint|) + Sparse (|syntastic-c-sparse|) + Splint (|syntastic-c-splint|) + + COBOL~ + OpenCOBOL (|syntastic-cobol-cobc|) + + C++~ + ClangCheck (|syntastic-cpp-clang_check|) + Clang-Tidy (|syntastic-cpp-clang_tidy|) + Cppcheck (|syntastic-cpp-cppcheck|) + GCC (|syntastic-cpp-gcc|) + OCLint (|syntastic-cpp-oclint|) + Vera++ (|syntastic-cpp-verapp|) + + D~ + DMD (|syntastic-d-dmd|) + + Fortran~ + GNU Fortran (|syntastic-fortran-gfortran|) + + Objective-C~ + GCC (|syntastic-objc-gcc|) + OCLint (|syntastic-objc-oclint|) + + Objective-C++~ + GCC (|syntastic-objcpp-gcc|) + OCLint (|syntastic-objcpp-oclint|) + + Verilog~ + Verilator (|syntastic-verilog-verilator|) + + *syntastic-config-naming* +Naming~ + +Depending on checker, the filename of the corresponding configuration file +can be specified by setting either 'g:syntastic_<filetype>_config_file' or +'g:syntastic_<checker>_config_file'. Refer to the docs for the particular +checkers above for the exact names. + *syntastic-config-location* +Location~ + +A configuration file is looked up in the directory of the file being checked, +then upwards in parent directories. The search stops either when a file with +the right name is found, or when the root of the filesystem is reached. + +Consequently, you would normally put a configuration file in the top directory +of your project, and you would override it when needed with other configuration +files placed in subdirectories. + *syntastic-config-format* +Format~ + +The file is expected to contain one option per line. Empty lines and lines +starting with `#` are removed. On each line, leading and trailing spaces are +also removed. Each option is then escaped, so you don't have to worry about +special characters. + +Lines starting with `-I` are assumed to be include paths, and are handled +specially. If the path following an `-I` is relative, it's treated as +being relative to the current configuration file, and is replaced by the +corresponding absolute path. If the path is absolute to begin with, it is +left unchanged. + +Please note that, aside from `-I`, syntastic doesn't try to keep track of +options with arguments. If you need to pass f.i. `-aux-info filename` to your +compiler you have to write `-aux-info` and `filename` on separate lines in the +configuration file, otherwise syntastic will quote the space and merge them in +a single string, which is probably not what you mean: > + -aux-info + filename +< +In the same vein, `=` in options not special in any way. As stated +above, everything on a line (except lines starting with `-I`, as noted) +is considered an "option" and escaped. + + vim:tw=78:sw=4:ft=help:norl: diff --git a/vim/bundle/syntastic/doc/syntastic.txt b/vim/bundle/syntastic/doc/syntastic.txt new file mode 100644 index 0000000..9b9674e --- /dev/null +++ b/vim/bundle/syntastic/doc/syntastic.txt @@ -0,0 +1,1128 @@ +*syntastic.txt* Syntax checking on the fly has never been so pimp. +*syntastic* + + + It's a bird! It's a plane! ZOMG It's ... ~ + + _____ __ __ _ ~ + / ___/__ ______ / /_____ ______/ /_(_)____ ~ + \__ \/ / / / __ \/ __/ __ `/ ___/ __/ / ___/ ~ + ___/ / /_/ / / / / /_/ /_/ (__ ) /_/ / /__ ~ + /____/\__, /_/ /_/\__/\__,_/____/\__/_/\___/ ~ + /____/ ~ + + + + Reference Manual~ + + +============================================================================== +CONTENTS *syntastic-contents* + + 1.Intro........................................|syntastic-intro| + 1.1.Quick start............................|syntastic-quickstart| + 1.2.Recommended settings...................|syntastic-recommended| + 2.Functionality provided.......................|syntastic-functionality| + 2.1.The statusline flag....................|syntastic-statusline-flag| + 2.2.Error signs............................|syntastic-error-signs| + 2.3.Error window...........................|syntastic-error-window| + 2.4.Error highlighting.....................|syntastic-highlighting| + 2.5.Aggregating errors.....................|syntastic-aggregating-errors| + 2.6.Filtering errors.......................|syntastic-filtering-errors| + 3.Commands.....................................|syntastic-commands| + 4.Global Options...............................|syntastic-global-options| + 5.Checker Options..............................|syntastic-checker-options| + 5.1.Choosing which checkers to use.........|syntastic-filetype-checkers| + 5.2.Choosing the executable................|syntastic-config-exec| + 5.3.Configuring specific checkers..........|syntastic-config-makeprg| + 5.4.Sorting errors.........................|syntastic-config-sort| + 5.5.Filtering errors.......................|syntastic-config-filtering| + 5.6.Debugging..............................|syntastic-config-debug| + 5.7.Profiling..............................|syntastic-profiling| + 6.Notes........................................|syntastic-notes| + 6.1.Handling of composite filetypes........|syntastic-composite| + 6.2.Editing files over network.............|syntastic-netrw| + 6.3.The 'shellslash' option................|syntastic-shellslash| + 6.4.Saving Vim sessions....................|syntastic-sessions| + 7.Compatibility with other software............|syntastic-compatibility| + 7.1.The csh and tcsh shells................|syntastic-csh| + 7.2.Eclim..................................|syntastic-eclim| + 7.3.The fish shell.........................|syntastic-fish| + 7.4.The fizsh shell........................|syntastic-fizsh| + 7.5.flagship...............................|syntastic-flagship| + 7.6.powerline..............................|syntastic-powerline| + 7.7.The PowerShell shell...................|syntastic-powershell| + 7.8.python-mode............................|syntastic-pymode| + 7.9.vim-auto-save..........................|syntastic-vim-auto-save| + 7.10.vim-go................................|syntastic-vim-go| + 7.11.vim-virtualenv........................|syntastic-vim-virtualenv| + 7.12.YouCompleteMe.........................|syntastic-ycm| + 7.13.The zsh shell and MacVim..............|syntastic-zsh| + 8.About........................................|syntastic-about| + 9.License......................................|syntastic-license| + + +============================================================================== +1. Intro *syntastic-intro* + +Syntastic is a syntax checking plugin that runs files through external syntax +checkers. This can be done on demand, or automatically as files are saved +and opened. If syntax errors are detected, the user is notified and is happy +because they didn't have to compile their code or execute their script to find +them. + +Syntastic comes in two parts: the syntax checker plugins, and the core. The +syntax checker plugins are defined on a per-filetype basis where each one wraps +up an external syntax checking program. The core script delegates off to these +plugins and uses their output to provide the syntastic functionality. + +Take a look at the list of supported filetypes and checkers: |syntastic-checkers|. + +Note: This doc only deals with using syntastic. To learn how to write syntax +checker integrations, see the guide on the GitHub wiki: + + https://github.com/scrooloose/syntastic/wiki/Syntax-Checker-Guide + +------------------------------------------------------------------------------ +1.1. Quick start *syntastic-quickstart* + +Syntastic comes preconfigured with a default list of enabled checkers per +|filetype|. This list is kept reasonably short to prevent slowing down Vim or +trying to use conflicting checkers. + +You can see the list of checkers available for the current filetype with the +`:SyntasticInfo` command. + +You probably want to override the configured list of checkers for the +filetypes you use, and also change the arguments passed to specific checkers +to suit your needs. See |syntastic-checker-options| below for details. + +Use `:SyntasticCheck` to manually check right now. Use `:Errors` to open the +|location-list| window, and `:lclose` to close it. You can clear the error +list with `:SyntasticReset`, and you can use `:SyntasticToggleMode` to switch +between active (checking on writing the buffer) and passive (manual) checking. + +You don't have to switch focus to the |location-list| window to jump to the +different errors. Vim provides several built-in commands for this, for +example `:lnext` and `:lprevious`. You may want to add shortcut mappings for +these commands, or perhaps install a plugin such as Tim Pope's "unimpaired" +(see https://github.com/tpope/vim-unimpaired) that provides such mappings. + +------------------------------------------------------------------------------ +1.2. Recommended settings *syntastic-recommended* + +Syntastic has numerous options that can be configured, and the defaults are +not particularly well suitable for new users. It is recommended that you start +by adding the following lines to your vimrc, and return to them later as +needed: > + set statusline+=%#warningmsg# + set statusline+=%{SyntasticStatuslineFlag()} + set statusline+=%* + + let g:syntastic_always_populate_loc_list = 1 + let g:syntastic_auto_loc_list = 1 + let g:syntastic_check_on_open = 1 + let g:syntastic_check_on_wq = 0 +< +============================================================================== +2. Functionality provided *syntastic-functionality* + +Syntax checking can be done automatically or on demand (see +|'syntastic_mode_map'| and `:SyntasticToggleMode` for configuring this). + +When syntax checking is done, the features below can be used to notify the +user of errors. See |syntastic-global-options| for how to configure and +activate/deactivate these features. + + * A statusline flag + * Signs beside lines with errors + * The |location-list| can be populated with the errors for the associated + buffer + * Erroneous parts of lines can be highlighted (this functionality is only + provided by some syntax checkers) + * Balloons (if the |+balloon_eval| feature is compiled in) can be used to + display error messages for erroneous lines when hovering the mouse over + them + * Error messages from multiple checkers can be aggregated in a single list + +------------------------------------------------------------------------------ +2.1. The statusline flag *syntastic-statusline-flag* + +To use the statusline flag, this must appear in your |'statusline'| setting > + %{SyntasticStatuslineFlag()} +< +Something like this could be more useful: > + set statusline+=%#warningmsg# + set statusline+=%{SyntasticStatuslineFlag()} + set statusline+=%* +< +When syntax errors are detected a flag will be shown. The content of the flag +is derived from the |syntastic_stl_format| option. + +Please note that these settings might conflict with other Vim plugins that +change the way statusline works. Refer to these plugins' documentation for +possible solutions. See also |syntastic-powerline| below if you're using the +"powerline" Vim plugin (https://github.com/powerline/powerline). + +------------------------------------------------------------------------------ +2.2. Error signs *syntastic-error-signs* + +Syntastic uses the `:sign` commands (provided that the |+signs| feature is +compiled in) 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 +(see |group-name|). 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 *syntastic-error-window* + +You can use the `:Errors` command to display the errors for the current buffer +in the |location-list|. + +By default syntastic doesn't fill the |location-list| with the errors found by +the checkers, in order to reduce clashes with other plugins. Consequently, if +you run `:lopen` or `:lwindow` rather than `:Errors` to open the error window +you wouldn't see syntastic's list of errors. If you insist on using `:lopen` +or `:lwindow` you should either run `:SyntasticSetLoclist` after running the +checks, or set |'syntastic_always_populate_loc_list'| which tells syntastic to +update the |location-list| automatically. + +------------------------------------------------------------------------------ +2.4. Error highlighting *syntastic-highlighting* + +Some checkers provide enough information for syntastic to be able to highlight +errors. By default the SpellBad syntax highlight group is used to color errors, +and the SpellCap group is used for warnings. If you wish to customize the +colors for highlighting you can use the following groups: + SyntasticError - Links to "SpellBad" by default (see |hl-SpellBad|) + SyntasticWarning - Links to "SpellCap" by default (see |hl-SpellCap|) + SyntasticStyleError - Links to "SyntasticError" by default + SyntasticStyleWarning - Links to "SyntasticWarning" by default + +Example: > + highlight SyntasticError guibg=#2f0000 +< +------------------------------------------------------------------------------ +2.5. Aggregating errors *syntastic-aggregating-errors* + +By default, namely if |'syntastic_aggregate_errors'| is unset, syntastic runs +in turn the checkers corresponding to the filetype of the current file (see +|syntastic-filetype-checkers|), and stops as soon as a checker reports any +errors. It then notifies you of the errors using the notification mechanisms +above. In this mode error lists are always produced by a single checker, and, +if you open the error window, the name of the checker that generated the errors +is shown on the statusline of the error window. + +If |'syntastic_aggregate_errors'| is set, syntastic runs all checkers that +apply (still cf. |syntastic-filetype-checkers|), then aggregates errors found +by all checkers in a single list, and notifies you. In this mode each error +message is labeled with the name of the checker that generated it, but you can +disable generation of these labels by turning off |'syntastic_id_checkers'|. + +If |'syntastic_sort_aggregated_errors'| is set (which is the default), messages +in the aggregated list are grouped by file, then sorted by line number, then +type, then column number. Otherwise messages produced by the same checker are +grouped together, and sorting within each group is decided by the variables +|'syntastic_<filetype>_<checker>_sort'|. + +------------------------------------------------------------------------------ +2.6 Filtering errors *syntastic-filtering-errors* + +You can selectively disable some of the errors found by checkers either +using |'syntastic_quiet_messages'|, or by specifying a list of patterns in +|'syntastic_ignore_files'|. + +See also: |'syntastic_<filetype>_<checker>_quiet_messages'| and +|'b:syntastic_skip_checks'|. + +============================================================================== +3. Commands *syntastic-commands* + +:Errors *:Errors* + +When errors have been detected, use this command to pop up the |location-list| +and display the error messages. + +Please note that the `:Errors` command overwrites the current location list with +syntastic's own location list. + +:SyntasticToggleMode *:SyntasticToggleMode* + +Toggles syntastic between active and passive mode. See |'syntastic_mode_map'| +for more info. + +:SyntasticCheck *:SyntasticCheck* + +Manually cause a syntax check to be done. By default the checkers in the +|'g:syntastic_<filetype>_checkers'| or |'b:syntastic_checkers'| lists are run, +cf. |syntastic-filetype-checkers|. If |'syntastic_aggregate_errors'| is unset +(which is the default), checking stops the first time a checker reports any +errors; if |'syntastic_aggregate_errors'| is set, all checkers that apply are +run in turn, and all errors found are aggregated in a single list. + +The command may be followed by a (space separated) list of checkers. In this +case |'g:syntastic_<filetype>_checkers'| and |'b:syntastic_checkers'| are +ignored, and the checkers named by the command's arguments are run instead, in +the order specified. The set by |'syntastic_aggregate_errors'| still apply. + +Example: > + :SyntasticCheck flake8 pylint +< +:SyntasticInfo *:SyntasticInfo* + +The command takes an optional argument, and outputs information about the +checkers available for the filetype named by said argument, or for the current +filetype if no argument was provided. + +:SyntasticReset *:SyntasticReset* + +Resets the list of errors and turns off all error notifiers. + +:SyntasticSetLoclist *:SyntasticSetLoclist* + +If |'syntastic_always_populate_loc_list'| is not set, the |location-list| is +not filled in automatically with the list of errors detected by the checkers. +This is useful if you run syntastic along with other plugins that use location +lists. The `:SyntasticSetLoclist` command allows you to stick the errors into +the location list explicitly. + +============================================================================== +4. Global Options *syntastic-global-options* + + *'syntastic_check_on_open'* +Type: boolean +Default: 0 +If this variable is enabled, syntastic in active mode will run syntax checks +when buffers are first loaded, as well as on saving: > + let g:syntastic_check_on_open = 1 +< + *'syntastic_check_on_wq'* +Type: boolean +Default: 1 +In active mode syntax checks are normally run whenever buffers are written to +disk, even when the writes happen just before quitting Vim. If you want to +skip checks when you issue `:wq`, `:x`, and `:ZZ`, set this variable to 0: > + let g:syntastic_check_on_wq = 0 +< + *'syntastic_aggregate_errors'* +Type: boolean +Default: 0 +When enabled, syntastic runs all checkers that apply to the current filetype, +then aggregates errors found by all checkers and displays them. When disabled, +syntastic runs each checker in turn, and stops to display the results the first +time a checker finds any errors. > + let g:syntastic_aggregate_errors = 1 +< + *'syntastic_id_checkers'* +Type: boolean +Default: 1 +When results from multiple checkers are aggregated in a single error list +(that is either when |'syntastic_aggregate_errors'| is enabled, or when +checking a file with a composite filetype, cf. |syntastic-composite|), it +might not be immediately obvious which checker has produced a given error +message. This variable instructs syntastic to label error messages with the +names of the checkers that created them. > + let g:syntastic_id_checkers = 0 +< + *'syntastic_sort_aggregated_errors'* +Type: boolean +Default: 1 +By default, when results from multiple checkers are aggregated in a single +error list (that is either when |'syntastic_aggregate_errors'| is enabled, or +when checking a file with a composite filetype, cf. |syntastic-composite|), +errors are grouped by file, then sorted by line number, then grouped by type +(namely errors take precedence over warnings), then they are sorted by column +number. If you want to leave messages grouped by checker output, set this +variable to 0: > + let g:syntastic_sort_aggregated_errors = 0 +< + *'syntastic_echo_current_error'* +Type: boolean +Default: 1 +If enabled, syntastic will echo current error to the command window. If +multiple errors are found on the same line, |'syntastic_cursor_columns'| is +used to decide which one is shown. > + let g:syntastic_echo_current_error = 1 +< + *'syntastic_cursor_columns'* +Type: boolean +Default: 1 +This option controls which errors are echoed to the command window if +|'syntastic_echo_current_error'| is set and multiple errors are found on the +same line. When the option is enabled, the first error corresponding to the +current column is shown. Otherwise, the first error on the current line is +echoed, regardless of the cursor position on the current line. + +When dealing with very large lists of errors, disabling this option can speed +up navigation significantly: > + let g:syntastic_cursor_column = 0 +< + *'syntastic_enable_signs'* +Type: boolean +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'* +Type: string +Use these options to control what the syntastic `:sign` text contains. Several +error symbols can be customized: + syntastic_error_symbol - For syntax errors, defaults to ">>" + syntastic_style_error_symbol - For style errors, defaults to "S>" + syntastic_warning_symbol - For syntax warnings, defaults to ">>" + syntastic_style_warning_symbol - For style warnings, defaults to "S>" + +Example: > + let g:syntastic_error_symbol = "\u2717" + let g:syntastic_warning_symbol = "\u26A0" +< + *'syntastic_enable_balloons'* +Type: boolean +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'* +Type: boolean +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'* +Type: boolean +Default: 0 +By default syntastic doesn't fill the |location-list| with the errors found +by the checkers, in order to reduce clashes with other plugins. Enable this +option to tell syntastic to always stick any detected errors into the +|location-list|: > + let g:syntastic_always_populate_loc_list = 1 +< +Please note that if |'syntastic_auto_jump'| is set to a non-zero value the +location list is overwritten with Syntastic's own list when taking a jump, +regardless of the value of |'syntastic_always_populate_loc_list'|. The +location list is also overwritten when running the `:Errors` command. + + *'syntastic_auto_jump'* +Type: integer +Default: 0 +Enable this option if you want the cursor to jump to the first detected issue +when saving or opening a file. + +When set to 0 the cursor won't jump automatically. > + let g:syntastic_auto_jump = 0 +< +When set to 1 the cursor will always jump to the first issue detected, +regardless of type. > + let g:syntastic_auto_jump = 1 +< +When set to 2 the cursor will jump to the first issue detected, but only if +this issue is an error. > + let g:syntastic_auto_jump = 2 +< +When set to 3 the cursor will jump to the first error detected, if any. If +all issues detected are warnings, the cursor won't jump. > + let g:syntastic_auto_jump = 3 +< +Please note that in either situation taking the jump also has the side effect +of the location list being overwritten with Syntastic's own location list, +regardless of the value of |'syntastic_always_populate_loc_list'|. + + *'syntastic_auto_loc_list'* +Type: integer +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 be neither opened nor 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 +< +When set to 3 the error window will be automatically opened when errors are +detected, but not closed automatically. > + let g:syntastic_auto_loc_list = 3 +< + *'syntastic_loc_list_height'* +Type: integer +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'* +Type: list of strings +Default: [] +Use this option to specify files that syntastic should never check. It's a +list of |regular-expression| patterns. The full paths of files (see |::p|) are +matched against these patterns, and the matches are case-sensitive. Use |\c| +to specify case-insensitive patterns. Example: > + let g:syntastic_ignore_files = ['\m^/usr/include/', '\m\c\.h$'] +< + *'syntastic_filetype_map'* +Type: dictionary +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 = { + \ "plaintex": "tex", + \ "gentoo-metadata": "xml" } +< +Composite filetypes (cf. |syntastic-composite|) can also be mapped to simple +types, which disables the default behaviour of running both checkers against +the input file: > + let g:syntastic_filetype_map = { "handlebars.html": "handlebars" } +< + *'syntastic_mode_map'* +Type: dictionary +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 +filetypes in the "active_filetypes" array (and "passive_filetypes" is +ignored). In active mode, automatic checks are not done for any filetypes in +the "passive_filetypes" array ("active_filetypes" is ignored). + +If any of "mode", "active_filetypes", or "passive_filetypes" are left +unspecified, they default to values above. + +If local variable |'b:syntastic_mode'| is defined its value takes precedence +over all calculations involving |'syntastic_mode_map'| for the corresponding +buffer. + +At runtime, the `:SyntasticToggleMode` command can be used to switch between +active and passive modes. + + *'b:syntastic_mode'* +Type: string +Default: unset +Only the local form |'b:syntastic_mode'| is used. When set to either "active" +or "passive", it takes precedence over |'syntastic_mode_map'| when deciding +whether the corresponding buffer should be checked automatically. + + *'syntastic_quiet_messages'* +Type: dictionary +Default: {} +Use this option to filter out some of the messages produced by checkers. The +option should be set to something like: > + let g:syntastic_quiet_messages = { + \ "!level": "errors", + \ "type": "style", + \ "regex": '\m\[C03\d\d\]', + \ "file:p": ['\m^/usr/include/', '\m\c\.h$'] } +< +Each element turns off messages matching the patterns specified by the +corresponding value. Values are lists, but if a list consists of a single +element you may omit the brackets (e.g. you may write "style" instead of +["style"]). Elements with values [] or "" are ignored (this is useful for +overriding filters, cf. |filter-overrides|). + + "level" - takes one of two values, "warnings" or "errors" + "type" - can be either "syntax" or "style" + "regex" - each item in list is matched against the messages' text as a + case-insensitive |regular-expression| + "file" - each item in list is matched against the filenames the messages + refer to, as a case-sensitive |regular-expression|. + +If a key is prefixed by an exclamation mark "!", the corresponding filter is +negated (i.e. the above example silences all messages that are NOT errors). + +The "file" key may be followed by one or more filename modifiers (see +|filename-modifiers|). The modifiers are applied to the filenames the messages +refer to before matching against the value (i.e. in the above example the full +path of the issues are matched against '\m^/usr/include/' and '\m\c\.h$'). + +If |'syntastic_id_checkers'| is set, filters are applied before error messages +are labeled with the names of the checkers that created them. + +There are also checker-specific variants of this option, providing finer +control. They are named |'syntastic_<filetype>_<checker>_quiet_messages'|. + +For a particular checker, if both a |'syntastic_quiet_messages'| filter and +a checker-specific filter are present, they are both applied (to the list of +errors produced by the said checker). In case of conflicting values for the +same keys, the values of the checker-specific filters take precedence. + + *filter-overrides* +Since filter elements with values [] or "" are ignored, you can disable global +filters for particular checkers, by setting the values of the corresponding +elements in |'syntastic_<filetype>_<checker>_quiet_messages'| to [] or "". For +example, the following setting will silence all warnings, except for the +ones produced by "pylint": > + let g:syntastic_quiet_messages = { "level": "warnings" } + let g:syntastic_python_pylint_quiet_messages = { "level" : [] } +< + *'syntastic_stl_format'* +Type: string +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 + %ne - filename of file containing first error + %nw - filename of file containing first warning + %N - filename of file containing first warning or error + %pe - filename with path of file containing first error + %pw - filename with path of file containing first warning + %P - filename with path of file containing first warning or error + %fe - line number of first error + %fw - line number of first warning + %F - line number of first warning or error + +These flags accept width and alignment controls similar to the ones used by +|'statusline'| flags: + %-0{minwid}.{maxwid}{flag} + +All fields except {flag} are optional. A single percent sign can be given as +"%%". + +Several additional flags are available to hide text under certain conditions: + %E{...} - hide the text in the brackets unless there are errors + %W{...} - hide the text in the brackets unless there are warnings + %B{...} - hide the text in the brackets unless there are both warnings AND + errors +These flags can't be nested. + +Example: > + let g:syntastic_stl_format = "[%E{Err: %fe #%e}%B{, }%W{Warn: %fw #%w}]" +< +If this format is used and the current buffer has 5 errors and 1 warning +starting on lines 20 and 10 respectively then this would appear on the +statusline: > + [Err: 20 #5, Warn: 10 #1] +< +If the buffer had 2 warnings, starting on line 5 then this would appear: > + [Warn: 5 #2] +< + *'b:syntastic_skip_checks'* +Type: boolean +Default: unset +Only the local form |'b:syntastic_skip_checks'| is used. When set to a true +value, no checks are run against the corresponding buffer. Example: > + let b:syntastic_skip_checks = 1 +< + *'syntastic_full_redraws'* +Type: boolean +Default: 0 in GUI Vim and MacVim, 1 otherwise +Controls whether syntastic calls `:redraw` or `:redraw!` for screen redraws. +Changing it can in principle make screen redraws smoother, but it can also +cause screen to flicker, or cause ghost characters. Leaving it to the default +should be safe. + + *'syntastic_exit_checks'* +Type: boolean +Default: 0 when running under "cmd.exe" on Windows, 1 otherwise +Syntastic attempts to catch abnormal termination conditions from checkers by +looking at their exit codes. The "cmd.exe" shell on Windows make these checks +meaningless, by returning 1 to Vim when the checkers exit with non-zero codes. +The above variable can be used to disable exit code checks in syntastic. + + *'syntastic_shell'* +Type: string +Default: Vim's 'shell' +This is the (full path to) the shell syntastic will use to run the checkers. +On UNIX and Mac OS-X this shell must accept Bourne-compatible syntax for +file "stdout" and "stderr" redirections ">file" and "2>file". Examples of +compatible shells are "zsh", "bash", "ksh", and of course the original Bourne +"sh". + +This shell is independent of Vim's 'shell', and it isn't used for interactive +operations. It must take care to initialize all environment variables needed +by the checkers you're using. Example: > + let g:syntastic_shell = "/bin/sh" +< + *'syntastic_nested_autocommands'* +Type: boolean +Default: 0 +Controls whether syntastic's autocommands |BufReadPost| and |BufWritePost| +are called from other |BufReadPost| and |BufWritePost| autocommands (see +|autocmd-nested|). This is known to trigger interoperability problems with +other plugins, so only enable it if you actually need that functionality. + + *'syntastic_debug'* +Type: integer +Default: 0 +Set this to the sum of one or more of the following flags to enable +debugging: + + 1 - trace general workflow + 2 - dump location lists + 4 - trace notifiers + 8 - trace autocommands + 16 - dump options + 32 - trace running of specific checkers + +Example: > + let g:syntastic_debug = 1 +< +Syntastic will then add debugging messages to Vim's |message-history|. You can +examine these messages with `:mes`. + + *'syntastic_debug_file'* +Type: string +Default: unset +When set, debugging messages are written to the file named by its value, in +addition to being added to Vim's |message-history|: > + let g:syntastic_debug_file = "~/syntastic.log" +< + *'syntastic_extra_filetypes'* +Type: list of strings +Default: [] +List of filetypes handled by checkers external to syntastic. If you have a Vim +plugin that adds a checker for syntastic, and if the said checker deals with a +filetype that is unknown to syntastic, you might consider adding that filetype +to this list: > + let g:syntastic_extra_filetypes = [ "make", "gitcommit" ] +< +This will allow `:SyntasticInfo` to do proper tab completion for the new +filetypes. + +============================================================================== +5. Checker Options *syntastic-checker-options* + +------------------------------------------------------------------------------ +5.1 Choosing which checkers to use *syntastic-filetype-checkers* + + *'g:syntastic_<filetype>_checkers'* +You can tell syntastic which checkers to run for a given filetype by setting a +variable 'g:syntastic_<filetype>_checkers' to a list of checkers, e.g. > + let g:syntastic_php_checkers = ["php", "phpcs", "phpmd"] +< + *'b:syntastic_checkers'* +There is also a per-buffer version of this setting, |'b:syntastic_checkers'|. +When set, it takes precedence over |'g:syntastic_<filetype>_checkers'|. You can +use this in an autocmd to configure specific checkers for particular paths: > + autocmd FileType python if stridx(expand("%:p"), "/some/path/") == 0 | + \ let b:syntastic_checkers = ["pylint"] | endif +< +If neither |'g:syntastic_<filetype>_checkers'| nor |'b:syntastic_checkers'| +is set, a default list of checker is used. Beware however that this list +deliberately kept minimal, for performance reasons. + +Take a look elsewhere in this manual to find out what checkers and filetypes +are supported by syntastic: |syntastic-checkers|. + +Use `:SyntasticInfo` to see which checkers are available for a given filetype. + +------------------------------------------------------------------------------ +5.2 Choosing the executable *syntastic-config-exec* + + *'syntastic_<filetype>_<checker>_exec'* +The executable run by a checker is normally defined automatically, when the +checker is registered. You can however override it, by setting the variable +'g:syntastic_<filetype>_<checker>_exec': > + let g:syntastic_ruby_mri_exec = "~/bin/ruby2" +< +This variable has a local version, 'b:syntastic_<filetype>_<checker>_exec', +which takes precedence over the global one in the corresponding buffer. + + *'b:syntastic_<checker>_exec'* +There is also a local variable named 'b:syntastic_<checker>_exec', which +takes precedence over both 'b:syntastic_<filetype>_<checker>_exec' and +'g:syntastic_<filetype>_<checker>_exec' in the buffers where it is defined. + +------------------------------------------------------------------------------ +5.3 Configuring specific checkers *syntastic-config-makeprg* + +Checkers are run by constructing a command line and by passing it to a shell +(see |'shell'| and |'syntastic_shell'|). In most cases this command line is +built using an internal function named "makeprgBuild()", which provides a +number of options that allow you to customise every part of the command that +gets called. + + *'syntastic_<filetype>_<checker>_<option>'* +Checkers that use "makeprgBuild()" construct the corresponding command line +like this: > + let makeprg = self.makeprgBuild({ + \ "exe": self.getExec(), + \ "args": "-a -b -c", + \ "fname": shellescape(expand("%", 1)), + \ "post_args": "--more --args", + \ "tail": "2>/dev/null" }) +< +The result is a command line of the form: > + <exe> <args> <fname> <post_args> <tail> +< +All fields above are optional, and can be overridden by setting global +variables 'g:syntastic_<filetype>_<checker-name>_<option-name>' - even +parameters not specified in the call to "makeprgBuild()". For example to +override the argguments and the tail: > + let g:syntastic_c_pc_lint_args = "-w5 -Iz:/usr/include/linux" + let g:syntastic_c_pc_lint_tail = "2>/dev/null" +< +These variables also have buffer-local versions named +'b:syntastic_<filetype>_<checker-name>_<option-name>', which takes precedence +over the global ones in the corresponding buffers. + +You can see the final outcome of setting these variables in the debug logs +(cf. |syntastic-config-debug|). + +Special characters need to be escaped, so that they can survive shell +expansions. Vim function |shellescape()| can help you with escaping: > + let g:syntastic_c_cppcheck_args = + \ "-DBUILD_BASENAME=my-module " . shellescape("-DBUILD_STR(s)=#s") +< +Alternatively, you can tell syntastic to escape special characters by turning +the value into a list: > + let g:syntastic_c_cppcheck_args = + \ ["-DBUILD_BASENAME=my-module", "-DBUILD_STR(s)=#s"] +< +Each element of this list is then escaped as needed, and turned into a +separate argument for the shell. + + *syntastic-config-empty* +If one of the above variables has a non-empty default and you want it to be +empty, you can set it to an empty string, e.g.: > + let g:syntastic_javascript_jslint_args = "" +< + *'syntastic_<filetype>_<checker>_exe'* +The 'exe' option is special. Normally it is the same as the 'exec' attribute +described above, but you can use it to add environment variables to the +command line, or to change the way the checker is run. For example this setup +allows you to run PC-Lint on Linux, under Wine emulation: > + let g:syntastic_c_pc_lint_exec = "wine" + let g:syntastic_c_pc_lint_exe = "wine c:/path/to/lint-nt.exe" +< + *'syntastic_<filetype>_<checker>_fname'* + +The 'fname' option is also special. Normally it is automatically set by +syntastic to the name of the current file, but you can change that as needed. +For example you can tell the SML/NJ compiler to use Compilation Manager by +omitting the filename from the command line: > + let g:syntastic_sml_smlnj_fname = "" +< + *syntastic-config-no-makeprgbuild* +For checkers that do not use the "makeprgBuild()" function you will have to +look at the source code of the checker in question. If there are specific +options that can be set they are normally documented in this manual (see +|syntastic-checkers|). + +------------------------------------------------------------------------------ +5.4 Sorting errors *syntastic-config-sort* + + *'syntastic_<filetype>_<checker>_sort'* +Syntastic may decide to group the errors produced by some checkers by file, +then sort them by line number, then by type, then by column number. If you'd +prefer to see the errors in the order in which they are output by the external +checker you can set the variable |'g:syntastic_<filetype>_<checker>_sort'| to 0. + +Alternatively, if syntastic doesn't reorder the errors produced by a checker +but you'd like it to sort them, you can set the same variable to 1. + +There is also a local version |'b:syntastic_<filetype>_<checker>_sort'| of +this variable, that takes precedence over it in the buffers where it is +defined. + +For aggregated lists (see |syntastic-aggregating-errors|) these variables are +ignored if |'syntastic_sort_aggregated_errors'| is set (which is the default). + +------------------------------------------------------------------------------ +5.5 Filtering errors *syntastic-config-filtering* + + *'syntastic_<filetype>_<checker>_quiet_messages'* +Finally, variables 'g:syntastic_<filetype>_<checker-name>_quiet_messages' can +be used to filter out some of the messages produced by specific checkers. The +effect is identical to that of |syntastic_quiet_messages|, except only messages +from the corresponding checkers are filtered. Example: > + let g:syntastic_python_pylama_quiet_messages = { + \ "type": "style", + \ "regex": '\m\[C03\d\d\]' } +< +The syntax is of course identical to that of |syntastic_quiet_messages|. + +------------------------------------------------------------------------------ +5.6 Debugging *syntastic-config-debug* + +Syntastic can log a trace of its working to Vim's |message-history|. To verify +the command line constructed by syntastic to run a checker, set the variable +|'syntastic_debug'| to a non-zero value, run the checker, then run `:mes` to +display the messages, and look for "makeprg" in the output. + +From a user's perspective, the useful values for |'syntastic_debug'| are 1, 3, +and 33: + + 1 - logs syntastic's workflow + 3 - logs workflow, checker's output, and |location-list| manipulations + 33 - logs workflow and checker-specific details (such as version checks). + +Debug logs can be saved to a file; see |'syntastic_debug_file'| for details. + +Setting |'syntastic_debug'| to 0 turns off logging. + +------------------------------------------------------------------------------ +5.7 Profiling *syntastic-profiling* + +A very useful tool for debugging performance problems is Vim's built-in +|profiler|. In order to enable profiling for syntastic you need to add two lines +to your vimrc (not to gvimrc): > + profile start syntastic.log + profile! file */syntastic/* +< +(assuming your copy of syntastic lives in a directory creatively named +"syntastic"). These lines must be executed before syntastic is loaded, so you +need to put them before package managers such as "pathogen" or "Vundle", and +(in newer Vim versions) before any commands related to |packages|. + +A log file is created in the current directory, and is updated when you quit +Vim. + +============================================================================== +6. Notes *syntastic-notes* + +------------------------------------------------------------------------------ +6.1. Handling of composite filetypes *syntastic-composite* + +Some Vim plugins use composite filetypes, such as "django.python" or +"handlebars.html". Normally syntastic deals with this situation by splitting +the filetype in its simple components, and calling all checkers that apply. +If this behaviour is not desirable, you can disable it by mapping the +composite filetypes to simple ones using |'syntastic_filetype_map'|, e.g.: > + let g:syntastic_filetype_map = { "handlebars.html": "handlebars" } +< +------------------------------------------------------------------------------ +6.2 Editing files over network *syntastic-netrw* + +The standard plugin |netrw| allows Vim to transparently edit files over +network and inside archives. Currently syntastic doesn't support this mode +of operation. It can only check files that can be accessed directly by local +checkers, without any translation or conversion. + +------------------------------------------------------------------------------ +6.3 The 'shellslash' option *syntastic-shellslash* + +The 'shellslash' option is relevant only on Windows systems. This option +determines (among other things) the rules for quoting command lines, and there +is no easy way for syntastic to make sure its state is appropriate for your +shell. It should be turned off if your 'shell' (or |'syntastic_shell'|) is +"cmd.exe", and on for shells that expect an UNIX-like syntax, such as Cygwin's +"sh". Most checkers will stop working if 'shellslash' is set to the wrong +value. + +------------------------------------------------------------------------------ +6.4 Saving Vim sessions *syntastic-sessions* + +If you use `:mksession` to save Vim sessions you should probably make sure to +remove option "blank" from 'sessionoptions': > + set sessionoptions-=blank +< +This will prevent `:mksession` from saving |syntastic-error-window| as empty +quickfix windows. + +============================================================================== +7. Compatibility with other software *syntastic-compatibility* + +------------------------------------------------------------------------------ +7.1 The csh and tcsh shells *syntastic-csh* + +The "csh" and "tcsh" shells are mostly compatible with syntastic. However, +some checkers assume Bourne shell syntax for redirecting "stderr". For this +reason, you should point |'syntastic_shell'| to a Bourne-compatible shell, +such as "zsh", "bash", "ksh", or even the original Bourne "sh": > + let g:syntastic_shell = "/bin/sh" +< +------------------------------------------------------------------------------ +7.2. Eclim *syntastic-eclim* + +Syntastic can be used together with "Eclim" (see http://eclim.org/). However, +by default Eclim disables syntastic's checks for the filetypes it supports, in +order to run its own validation. If you'd prefer to use Eclim but still run +syntastic's checks, set |g:EclimFileTypeValidate| to 0: > + let g:EclimFileTypeValidate = 0 +< +It is also possible to re-enable syntastic checks only for some filetypes, and +run Eclim's validation for others. Please consult Eclim's documentation for +details. + +------------------------------------------------------------------------------ +7.3 The fish shell *syntastic-fish* + +At the time of this writing the "fish" shell (see http://fishshell.com/) +doesn't support the standard UNIX syntax for file redirections, and thus it +can't be used together with syntastic. You can however set |'syntastic_shell'| +to a more traditional shell, such as "zsh", "bash", "ksh", or even the +original Bourne "sh": > + let g:syntastic_shell = "/bin/sh" +< +------------------------------------------------------------------------------ +7.4. The fizsh shell *syntastic-fizsh* + +Using syntastic with the "fizsh" shell (see https://github.com/zsh-users/fizsh) +is possible, but potentially problematic. In order to do it you'll need to set +'shellredir' like this: > + set shellredir=>%s\ 2>&1 +< +Please keep in mind however that Vim can't take advantage of any of the +interactive features of "fizsh". Using a more traditional shell such as "zsh", +"bash", "ksh", or the original Bourne "sh" might be a better choice: > + let g:syntastic_shell = "/bin/sh" +< +------------------------------------------------------------------------------ +7.5 flagship *syntastic-flagship* + +The "flagship" Vim plugin (https://github.com/tpope/vim-flagship) has its +own mechanism of showing flags on the |'statusline'|. To allow "flagship" +to manage syntastic's statusline flag add the following |autocommand| to +your vimrc, rather than explicitly adding the flag to your |'statusline'| as +described in the |syntastic-statusline-flag| section above: > + autocmd User Flags call Hoist("window", "SyntasticStatuslineFlag") +< +------------------------------------------------------------------------------ +7.6. powerline *syntastic-powerline* + +The "powerline" Vim plugin (https://github.com/powerline/powerline) comes +packaged with a syntastic segment. To customize this segment create a file +"~/.config/powerline/themes/vim/default.json", with a content like this: > + { + "segment_data" : { + "powerline.segments.vim.plugin.syntastic.syntastic" : { + "args" : { + "err_format" : "Err: {first_line} #{num} ", + "warn_format" : "Warn: {first_line} #{num} " + } + } + } + } +< +------------------------------------------------------------------------------ +7.7. The PowerShell shell *syntastic-powershell* + +At the time of this writing, syntastic is not compatible with using "Windows +PowerShell" (http://technet.microsoft.com/en-us/library/bb978526.aspx) as Vim's +'shell'. You may still run Vim from 'PowerShell', but you do have to point +Vim's 'shell' to a more traditional program, such as "cmd.exe": > + set shell=cmd.exe +< +------------------------------------------------------------------------------ +7.8 python-mode *syntastic-pymode* + +Syntastic can be used along with the "python-mode" Vim plugin (see +https://github.com/klen/python-mode). However, they both run syntax checks by +default when you save buffers to disk, and this is probably not what you want. +To avoid both plugins opening error windows, you can either set passive mode +for python in syntastic (see |'syntastic_mode_map'|), or disable lint checks in +"python-mode", by setting |pymode_lint_on_write| to 0. E.g.: > + let g:pymode_lint_on_write = 0 +< +------------------------------------------------------------------------------ +7.9. vim-auto-save *syntastic-vim-auto-save* + +Syntastic can be used together with the "vim-auto-save" Vim plugin (see +https://github.com/907th/vim-auto-save). However, syntastic checks in active +mode only work with "vim-auto-save" version 0.1.7 or later. + +------------------------------------------------------------------------------ +7.10. vim-go *syntastic-vim-go* + +Syntastic can be used along with the "vim-go" Vim plugin (see +https://github.com/fatih/vim-go). However, both "vim-go" and syntastic run +syntax checks by default when you save buffers to disk. To avoid conflicts, +you have to either set passive mode in syntastic for the "go" filetype (see +|syntastic_mode_map|), or prevent "vim-go" from showing a quickfix window when +|g:go_fmt_command| fails, by setting |g:go_fmt_fail_silently| to 1. E.g.: > + let g:go_fmt_fail_silently = 1 +< +"vim-go" version 1.4 and earlier always uses |quickfix| lists. Starting with +version 1.5, "vim-go" can also use location lists (see |location-list|). To +avoid conflicts with syntastic, you probably want to configure "vim-go" to +stick with |quickfix| lists: > + let g:go_list_type = "quickfix" +< +------------------------------------------------------------------------------ +7.11. vim-virtualenv *syntastic-vim-virtualenv* + +At the time of this writing, syntastic can't run checkers installed +in Python virtual environments activated by "vim-virtualenv" (see +https://github.com/jmcantrell/vim-virtualenv). This is a limitation of +"vim-virtualenv". + +------------------------------------------------------------------------------ +7.12 YouCompleteMe *syntastic-ycm* + +Syntastic can be used together with the "YouCompleteMe" Vim plugin (see +http://valloric.github.io/YouCompleteMe/). However, by default "YouCompleteMe" +disables syntastic's checkers for the "c", "cpp", "objc", and "objcpp" +filetypes, in order to allow its own checkers to run. If you want to use YCM's +identifier completer but still run syntastic's checkers for those filetypes you +have to set |g:ycm_show_diagnostics_ui| to 0. E.g.: > + let g:ycm_show_diagnostics_ui = 0 +< +------------------------------------------------------------------------------ +7.13 The zsh shell and MacVim *syntastic-zsh* + +If you're running MacVim together with the "zsh" shell (http://www.zsh.org/) +you need to be aware that MacVim does not source your .zshrc file, but will +source a .zshenv file. Consequently you have to move any setup steps relevant +to the checkers you're using from .zshrc to .zshenv, otherwise your checkers +will misbehave when run by syntastic. This is particularly important for +programs such as "rvm" (https://rvm.io/) or "rbenv" (http://rbenv.org/), that +rely on setting environment variables. + +============================================================================== +8. About *syntastic-about* + +The core maintainers of syntastic are: + Martin Grenfell (GitHub: scrooloose) + Gregor Uhlenheuer (GitHub: kongo2002) + LCD 047 (GitHub: lcd047) + +Find the latest version of syntastic at: + + http://github.com/scrooloose/syntastic + +============================================================================== +9. 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/vim/bundle/syntastic/plugin/syntastic.vim b/vim/bundle/syntastic/plugin/syntastic.vim new file mode 100644 index 0000000..49b586c --- /dev/null +++ b/vim/bundle/syntastic/plugin/syntastic.vim @@ -0,0 +1,729 @@ +"============================================================================ +"File: syntastic.vim +"Description: Vim plugin for on the fly syntax checking. +"License: This program is free software. It comes without any warranty, +" to the extent permitted by applicable law. You can redistribute +" it and/or modify it under the terms of the Do What The Fuck You +" Want To Public License, Version 2, as published by Sam Hocevar. +" See http://sam.zoy.org/wtfpl/COPYING for more details. +" +"============================================================================ + +if exists('g:loaded_syntastic_plugin') || &compatible + finish +endif +let g:loaded_syntastic_plugin = 1 + +if has('reltime') + let g:_SYNTASTIC_START = reltime() + lockvar! g:_SYNTASTIC_START +endif + +let g:_SYNTASTIC_VERSION = '3.7.0-157' +lockvar g:_SYNTASTIC_VERSION + +" Sanity checks {{{1 + +if v:version < 700 || (v:version == 700 && !has('patch175')) + call syntastic#log#error('need Vim version 7.0.175 or later') + finish +endif + +for s:feature in [ + \ 'autocmd', + \ 'eval', + \ 'file_in_path', + \ 'modify_fname', + \ 'quickfix', + \ 'reltime', + \ 'user_commands' + \ ] + if !has(s:feature) + call syntastic#log#error('need Vim compiled with feature ' . s:feature) + finish + endif +endfor + +let s:_running_windows = syntastic#util#isRunningWindows() +lockvar s:_running_windows + +if !exists('g:syntastic_shell') + let g:syntastic_shell = &shell +endif + +if s:_running_windows + let g:_SYNTASTIC_UNAME = 'Windows' +elseif executable('uname') + try + let g:_SYNTASTIC_UNAME = split(syntastic#util#system('uname'), "\n")[0] + catch /\m^Vim\%((\a\+)\)\=:E484/ + call syntastic#log#error("your shell " . syntastic#util#var('shell') . " can't handle traditional UNIX syntax for redirections") + finish + catch /\m^Vim\%((\a\+)\)\=:E684/ + let g:_SYNTASTIC_UNAME = 'Unknown' + endtry +else + let g:_SYNTASTIC_UNAME = 'Unknown' +endif +lockvar g:_SYNTASTIC_UNAME + +" }}}1 + +" Defaults {{{1 + +let g:_SYNTASTIC_DEFAULTS = { + \ 'aggregate_errors': 0, + \ 'always_populate_loc_list': 0, + \ 'auto_jump': 0, + \ 'auto_loc_list': 2, + \ 'check_on_open': 0, + \ 'check_on_wq': 1, + \ 'cursor_columns': 1, + \ 'debug': 0, + \ 'echo_current_error': 1, + \ 'enable_balloons': 1, + \ 'enable_highlighting': 1, + \ 'enable_signs': 1, + \ 'error_symbol': '>>', + \ 'exit_checks': !(s:_running_windows && syntastic#util#var('shell', &shell) =~? '\m\<cmd\.exe$'), + \ 'filetype_map': {}, + \ 'full_redraws': !(has('gui_running') || has('gui_macvim')), + \ 'id_checkers': 1, + \ 'ignore_extensions': '\c\v^([gx]?z|lzma|bz2)$', + \ 'ignore_files': [], + \ 'loc_list_height': 10, + \ 'nested_autocommands': 0, + \ 'quiet_messages': {}, + \ 'reuse_loc_lists': 1, + \ 'shell': &shell, + \ 'sort_aggregated_errors': 1, + \ 'stl_format': '[Syntax: line:%F (%t)]', + \ 'style_error_symbol': 'S>', + \ 'style_warning_symbol': 'S>', + \ 'warning_symbol': '>>' + \ } +lockvar! g:_SYNTASTIC_DEFAULTS + +for s:key in keys(g:_SYNTASTIC_DEFAULTS) + if !exists('g:syntastic_' . s:key) + let g:syntastic_{s:key} = copy(g:_SYNTASTIC_DEFAULTS[s:key]) + endif +endfor + +if exists('g:syntastic_quiet_warnings') + call syntastic#log#oneTimeWarn("variable g:syntastic_quiet_warnings is deprecated, please use let g:syntastic_quiet_messages = {'level': 'warnings'} instead") + if g:syntastic_quiet_warnings + let s:quiet_warnings = get(g:syntastic_quiet_messages, 'type', []) + if type(s:quiet_warnings) != type([]) + let s:quiet_warnings = [s:quiet_warnings] + endif + call add(s:quiet_warnings, 'warnings') + let g:syntastic_quiet_messages['type'] = s:quiet_warnings + endif +endif + +" }}}1 + +" Debug {{{1 + +let s:_DEBUG_DUMP_OPTIONS = [ + \ 'shell', + \ 'shellcmdflag', + \ 'shellpipe', + \ 'shellquote', + \ 'shellredir', + \ 'shellslash', + \ 'shelltemp', + \ 'shellxquote' + \ ] +if exists('+shellxescape') + call add(s:_DEBUG_DUMP_OPTIONS, 'shellxescape') +endif +lockvar! s:_DEBUG_DUMP_OPTIONS + +" debug constants +let g:_SYNTASTIC_DEBUG_TRACE = 1 +lockvar g:_SYNTASTIC_DEBUG_TRACE +let g:_SYNTASTIC_DEBUG_LOCLIST = 2 +lockvar g:_SYNTASTIC_DEBUG_LOCLIST +let g:_SYNTASTIC_DEBUG_NOTIFICATIONS = 4 +lockvar g:_SYNTASTIC_DEBUG_NOTIFICATIONS +let g:_SYNTASTIC_DEBUG_AUTOCOMMANDS = 8 +lockvar g:_SYNTASTIC_DEBUG_AUTOCOMMANDS +let g:_SYNTASTIC_DEBUG_VARIABLES = 16 +lockvar g:_SYNTASTIC_DEBUG_VARIABLES +let g:_SYNTASTIC_DEBUG_CHECKERS = 32 +lockvar g:_SYNTASTIC_DEBUG_CHECKERS + +" }}}1 + +runtime! plugin/syntastic/*.vim + +let s:registry = g:SyntasticRegistry.Instance() +let s:notifiers = g:SyntasticNotifiers.Instance() +let s:modemap = g:SyntasticModeMap.Instance() + +let s:_quit_pre = [] + +" Commands {{{1 + +" @vimlint(EVL103, 1, a:cursorPos) +" @vimlint(EVL103, 1, a:cmdLine) +" @vimlint(EVL103, 1, a:argLead) +function! s:CompleteCheckerName(argLead, cmdLine, cursorPos) abort " {{{2 + let checker_names = [] + for ft in s:_resolve_filetypes([]) + call extend(checker_names, s:registry.getNamesOfAvailableCheckers(ft)) + endfor + return join(checker_names, "\n") +endfunction " }}}2 +" @vimlint(EVL103, 0, a:cursorPos) +" @vimlint(EVL103, 0, a:cmdLine) +" @vimlint(EVL103, 0, a:argLead) + + +" @vimlint(EVL103, 1, a:cursorPos) +" @vimlint(EVL103, 1, a:cmdLine) +" @vimlint(EVL103, 1, a:argLead) +function! s:CompleteFiletypes(argLead, cmdLine, cursorPos) abort " {{{2 + return join(s:registry.getKnownFiletypes(), "\n") +endfunction " }}}2 +" @vimlint(EVL103, 0, a:cursorPos) +" @vimlint(EVL103, 0, a:cmdLine) +" @vimlint(EVL103, 0, a:argLead) + +command! -bar -nargs=* -complete=custom,s:CompleteCheckerName SyntasticCheck call SyntasticCheck(<f-args>) +command! -bar -nargs=? -complete=custom,s:CompleteFiletypes SyntasticInfo call SyntasticInfo(<f-args>) +command! -bar Errors call SyntasticErrors() +command! -bar SyntasticReset call SyntasticReset() +command! -bar SyntasticToggleMode call SyntasticToggleMode() +command! -bar SyntasticSetLoclist call SyntasticSetLoclist() + +command! SyntasticJavacEditClasspath runtime! syntax_checkers/java/*.vim | SyntasticJavacEditClasspath +command! SyntasticJavacEditConfig runtime! syntax_checkers/java/*.vim | SyntasticJavacEditConfig + +" }}}1 + +" Public API {{{1 + +function! SyntasticCheck(...) abort " {{{2 + call s:UpdateErrors(0, a:000) + call syntastic#util#redraw(g:syntastic_full_redraws) +endfunction " }}}2 + +function! SyntasticInfo(...) abort " {{{2 + call s:modemap.modeInfo(a:000) + call s:registry.echoInfoFor(s:_resolve_filetypes(a:000)) + call s:_explain_skip(a:000) +endfunction " }}}2 + +function! SyntasticErrors() abort " {{{2 + call g:SyntasticLoclist.current().show() +endfunction " }}}2 + +function! SyntasticReset() abort " {{{2 + call s:ClearCache() + call s:notifiers.refresh(g:SyntasticLoclist.New([])) +endfunction " }}}2 + +function! SyntasticToggleMode() abort " {{{2 + call s:modemap.toggleMode() + call s:ClearCache() + call s:notifiers.refresh(g:SyntasticLoclist.New([])) + call s:modemap.echoMode() +endfunction " }}}2 + +function! SyntasticSetLoclist() abort " {{{2 + call g:SyntasticLoclist.current().setloclist() +endfunction " }}}2 + +" }}}1 + +" Autocommands {{{1 + +augroup syntastic + autocmd! + autocmd BufEnter * call s:BufEnterHook() +augroup END + +if g:syntastic_nested_autocommands + augroup syntastic + autocmd BufReadPost * nested call s:BufReadPostHook() + autocmd BufWritePost * nested call s:BufWritePostHook() + augroup END +else + augroup syntastic + autocmd BufReadPost * call s:BufReadPostHook() + autocmd BufWritePost * call s:BufWritePostHook() + augroup END +endif + +if exists('##QuitPre') + " QuitPre was added in Vim 7.3.544 + augroup syntastic + autocmd QuitPre * call s:QuitPreHook(expand('<amatch>', 1)) + augroup END +endif + +function! s:BufReadPostHook() abort " {{{2 + if g:syntastic_check_on_open + call syntastic#log#debug(g:_SYNTASTIC_DEBUG_AUTOCOMMANDS, + \ 'autocmd: BufReadPost, buffer ' . bufnr('') . ' = ' . string(bufname(str2nr(bufnr(''))))) + call s:UpdateErrors(1, []) + endif +endfunction " }}}2 + +function! s:BufWritePostHook() abort " {{{2 + call syntastic#log#debug(g:_SYNTASTIC_DEBUG_AUTOCOMMANDS, + \ 'autocmd: BufWritePost, buffer ' . bufnr('') . ' = ' . string(bufname(str2nr(bufnr(''))))) + call s:UpdateErrors(1, []) +endfunction " }}}2 + +function! s:BufEnterHook() abort " {{{2 + call syntastic#log#debug(g:_SYNTASTIC_DEBUG_AUTOCOMMANDS, + \ 'autocmd: BufEnter, buffer ' . bufnr('') . ' = ' . string(bufname(str2nr(bufnr('')))) . + \ ', &buftype = ' . string(&buftype)) + if &buftype ==# '' + call s:notifiers.refresh(g:SyntasticLoclist.current()) + elseif &buftype ==# 'quickfix' + " TODO: this is needed because in recent versions of Vim lclose + " can no longer be called from BufWinLeave + " TODO: at this point there is no b:syntastic_loclist + let loclist = filter(copy(getloclist(0)), 'v:val["valid"] == 1') + let owner = str2nr(getbufvar(bufnr(''), 'syntastic_owner_buffer')) + let buffers = syntastic#util#unique(map(loclist, 'v:val["bufnr"]') + (owner ? [owner] : [])) + if !empty(get(w:, 'syntastic_loclist_set', [])) && !empty(loclist) && empty(filter( buffers, 'syntastic#util#bufIsActive(v:val)' )) + call SyntasticLoclistHide() + endif + endif +endfunction " }}}2 + +function! s:QuitPreHook(fname) abort " {{{2 + let buf = bufnr(fnameescape(a:fname)) + call syntastic#log#debug(g:_SYNTASTIC_DEBUG_AUTOCOMMANDS, 'autocmd: QuitPre, buffer ' . buf . ' = ' . string(a:fname)) + + if !syntastic#util#var('check_on_wq') + call syntastic#util#setWids() + call add(s:_quit_pre, buf . '_' . getbufvar(buf, 'changetick') . '_' . w:syntastic_wid) + endif + + if !empty(get(w:, 'syntastic_loclist_set', [])) + call SyntasticLoclistHide() + endif +endfunction " }}}2 + +" }}}1 + +" Main {{{1 + +"refresh and redraw all the error info for this buf when saving or reading +function! s:UpdateErrors(auto_invoked, checker_names) abort " {{{2 + call syntastic#log#debugShowVariables(g:_SYNTASTIC_DEBUG_TRACE, 'version') + call syntastic#log#debugShowOptions(g:_SYNTASTIC_DEBUG_TRACE, s:_DEBUG_DUMP_OPTIONS) + call syntastic#log#debugDump(g:_SYNTASTIC_DEBUG_VARIABLES) + call syntastic#log#debug(g:_SYNTASTIC_DEBUG_TRACE, 'UpdateErrors' . (a:auto_invoked ? ' (auto)' : '') . + \ ': ' . (len(a:checker_names) ? join(a:checker_names) : 'default checkers')) + + call s:modemap.synch() + + if s:_skip_file() + return + endif + + let run_checks = !a:auto_invoked || s:modemap.doAutoChecking() + if run_checks + call s:CacheErrors(a:checker_names) + call syntastic#util#setChangedtick() + else + if a:auto_invoked + return + endif + endif + + let loclist = g:SyntasticLoclist.current() + + if exists('*SyntasticCheckHook') + call SyntasticCheckHook(loclist.getRaw()) + endif + + " populate loclist and jump {{{3 + let do_jump = syntastic#util#var('auto_jump') + 0 + if do_jump == 2 + let do_jump = loclist.getFirstError(1) + elseif do_jump == 3 + let do_jump = loclist.getFirstError() + elseif 0 > do_jump || do_jump > 3 + let do_jump = 0 + endif + + let w:syntastic_loclist_set = [] + if syntastic#util#var('always_populate_loc_list') || do_jump + call syntastic#log#debug(g:_SYNTASTIC_DEBUG_NOTIFICATIONS, 'loclist: setloclist (new)') + call setloclist(0, loclist.getRaw()) + if !exists('b:syntastic_changedtick') + call syntastic#util#setChangedtick() + endif + let w:syntastic_loclist_set = [bufnr(''), b:syntastic_changedtick] + if run_checks && do_jump && !loclist.isEmpty() + call syntastic#log#debug(g:_SYNTASTIC_DEBUG_NOTIFICATIONS, 'loclist: jump') + execute 'silent! lrewind ' . do_jump + + " XXX: Vim doesn't call autocmd commands in a predictible + " order, which can lead to missing filetype when jumping + " to a new file; the following is a workaround for the + " resulting brain damage + if &filetype ==# '' + silent! filetype detect + endif + endif + endif + " }}}3 + + call s:notifiers.refresh(loclist) +endfunction " }}}2 + +"clear the loc list for the buffer +function! s:ClearCache() abort " {{{2 + call s:notifiers.reset(g:SyntasticLoclist.current()) + call b:syntastic_loclist.destroy() +endfunction " }}}2 + +"detect and cache all syntax errors in this buffer +function! s:CacheErrors(checker_names) abort " {{{2 + call syntastic#log#debug(g:_SYNTASTIC_DEBUG_TRACE, 'CacheErrors: ' . + \ (len(a:checker_names) ? join(a:checker_names) : 'default checkers')) + call s:ClearCache() + let newLoclist = g:SyntasticLoclist.New([]) + + if !s:_skip_file() + " debug logging {{{3 + call syntastic#log#debugShowVariables(g:_SYNTASTIC_DEBUG_TRACE, 'aggregate_errors') + call syntastic#log#debug(g:_SYNTASTIC_DEBUG_CHECKERS, '$PATH = ' . string($PATH)) + call syntastic#log#debug(g:_SYNTASTIC_DEBUG_TRACE, 'getcwd() = ' . string(getcwd())) + " }}}3 + + let filetypes = s:_resolve_filetypes([]) + let aggregate_errors = syntastic#util#var('aggregate_errors') || len(filetypes) > 1 + let decorate_errors = aggregate_errors && syntastic#util#var('id_checkers') + let sort_aggregated_errors = aggregate_errors && syntastic#util#var('sort_aggregated_errors') + + let clist = [] + for type in filetypes + call extend(clist, s:registry.getCheckers(type, a:checker_names)) + endfor + + let names = [] + let unavailable_checkers = 0 + for checker in clist + let cname = checker.getFiletype() . '/' . checker.getName() + if !checker.isAvailable() + call syntastic#log#debug(g:_SYNTASTIC_DEBUG_TRACE, 'CacheErrors: Checker ' . cname . ' is not available') + let unavailable_checkers += 1 + continue + endif + + call syntastic#log#debug(g:_SYNTASTIC_DEBUG_TRACE, 'CacheErrors: Invoking checker: ' . cname) + + let loclist = checker.getLocList() + + if !loclist.isEmpty() + if decorate_errors + call loclist.decorate(cname) + endif + call add(names, cname) + if checker.wantSort() && !sort_aggregated_errors + call loclist.sort() + call syntastic#log#debug(g:_SYNTASTIC_DEBUG_LOCLIST, 'sorted:', loclist) + endif + + let newLoclist = newLoclist.extend(loclist) + + if !aggregate_errors + break + endif + endif + endfor + + " set names {{{3 + if !empty(names) + if len(syntastic#util#unique(map( copy(names), 'substitute(v:val, "\\m/.*", "", "")' ))) == 1 + let type = substitute(names[0], '\m/.*', '', '') + let name = join(map( names, 'substitute(v:val, "\\m.\\{-}/", "", "")' ), ', ') + call newLoclist.setName( name . ' ('. type . ')' ) + else + " checkers from mixed types + call newLoclist.setName(join(names, ', ')) + endif + endif + " }}}3 + + " issue warning about no active checkers {{{3 + if len(clist) == unavailable_checkers + if !empty(a:checker_names) + if len(a:checker_names) == 1 + call syntastic#log#warn('checker ' . a:checker_names[0] . ' is not available') + else + call syntastic#log#warn('checkers ' . join(a:checker_names, ', ') . ' are not available') + endif + else + call syntastic#log#debug(g:_SYNTASTIC_DEBUG_TRACE, 'CacheErrors: no checkers available for ' . &filetype) + endif + endif + " }}}3 + + call syntastic#log#debug(g:_SYNTASTIC_DEBUG_LOCLIST, 'aggregated:', newLoclist) + if sort_aggregated_errors + call newLoclist.sort() + call syntastic#log#debug(g:_SYNTASTIC_DEBUG_LOCLIST, 'sorted:', newLoclist) + endif + endif + + call newLoclist.deploy() +endfunction " }}}2 + +"Emulates the :lmake command. Sets up the make environment according to the +"options given, runs make, resets the environment, returns the location list +" +"a:options can contain the following keys: +" 'makeprg' +" 'errorformat' +" +"The corresponding options are set for the duration of the function call. They +"are set with :let, so dont escape spaces. +" +"a:options may also contain: +" 'defaults' - a dict containing default values for the returned errors +" 'subtype' - all errors will be assigned the given subtype +" 'preprocess' - a function to be applied to the error file before parsing errors +" 'postprocess' - a list of functions to be applied to the error list +" 'cwd' - change directory to the given path before running the checker +" 'env' - environment variables to set before running the checker +" 'returns' - a list of valid exit codes for the checker +" @vimlint(EVL102, 1, l:env_save) +function! SyntasticMake(options) abort " {{{2 + call syntastic#log#debug(g:_SYNTASTIC_DEBUG_TRACE, 'SyntasticMake: called with options:', a:options) + + " save options and locale env variables {{{3 + let old_local_errorformat = &l:errorformat + let old_errorformat = &errorformat + let old_cwd = getcwd() + " }}}3 + + if has_key(a:options, 'errorformat') + let &errorformat = a:options['errorformat'] + set errorformat< + endif + + if has_key(a:options, 'cwd') + execute 'lcd ' . fnameescape(a:options['cwd']) + endif + + " set environment variables {{{3 + let env_save = {} + if has_key(a:options, 'env') && len(a:options['env']) + for key in keys(a:options['env']) + if key =~? '\m^[a-z_][a-z0-9_]*$' + execute 'let env_save[' . string(key) . '] = $' . key + execute 'let $' . key . ' = ' . string(a:options['env'][key]) + endif + endfor + endif + " }}}3 + + let err_lines = split(syntastic#util#system(a:options['makeprg']), "\n", 1) + + " restore environment variables {{{3 + if len(env_save) + for key in keys(env_save) + execute 'let $' . key . ' = ' . string(env_save[key]) + endfor + endif + " }}}3 + + call syntastic#log#debug(g:_SYNTASTIC_DEBUG_LOCLIST, 'checker output:', err_lines) + + " Does it still make sense to go on? + let bailout = + \ syntastic#util#var('exit_checks') && + \ has_key(a:options, 'returns') && + \ index(a:options['returns'], v:shell_error) == -1 + + if !bailout + if has_key(a:options, 'Preprocess') + let err_lines = call(a:options['Preprocess'], [err_lines]) + call syntastic#log#debug(g:_SYNTASTIC_DEBUG_LOCLIST, 'preprocess (external):', err_lines) + elseif has_key(a:options, 'preprocess') + let err_lines = call('syntastic#preprocess#' . a:options['preprocess'], [err_lines]) + call syntastic#log#debug(g:_SYNTASTIC_DEBUG_LOCLIST, 'preprocess:', err_lines) + endif + lgetexpr err_lines + + let errors = deepcopy(getloclist(0)) + + if has_key(a:options, 'cwd') + execute 'lcd ' . fnameescape(old_cwd) + endif + + try + silent lolder + catch /\m^Vim\%((\a\+)\)\=:E380/ + " E380: At bottom of quickfix stack + call setloclist(0, [], 'r') + catch /\m^Vim\%((\a\+)\)\=:E776/ + " E776: No location list + " do nothing + endtry + else + let errors = [] + endif + + " restore options {{{3 + let &errorformat = old_errorformat + let &l:errorformat = old_local_errorformat + " }}}3 + + if !s:_running_windows && (s:_os_name() =~? 'FreeBSD' || s:_os_name() =~? 'OpenBSD') + call syntastic#util#redraw(g:syntastic_full_redraws) + endif + + if bailout + call syntastic#log#ndebug(g:_SYNTASTIC_DEBUG_LOCLIST, 'checker output:', err_lines) + throw 'Syntastic: checker error' + endif + + call syntastic#log#debug(g:_SYNTASTIC_DEBUG_LOCLIST, 'raw loclist:', errors) + + if has_key(a:options, 'defaults') + call s:_add_to_errors(errors, a:options['defaults']) + endif + + " Add subtype info if present. + if has_key(a:options, 'subtype') + call s:_add_to_errors(errors, { 'subtype': a:options['subtype'] }) + endif + + if has_key(a:options, 'Postprocess') && !empty(a:options['Postprocess']) + for rule in a:options['Postprocess'] + let errors = call(rule, [errors]) + endfor + call syntastic#log#debug(g:_SYNTASTIC_DEBUG_LOCLIST, 'postprocess (external):', errors) + elseif has_key(a:options, 'postprocess') && !empty(a:options['postprocess']) + for rule in a:options['postprocess'] + let errors = call('syntastic#postprocess#' . rule, [errors]) + endfor + call syntastic#log#debug(g:_SYNTASTIC_DEBUG_LOCLIST, 'postprocess:', errors) + endif + + return errors +endfunction " }}}2 +" @vimlint(EVL102, 0, l:env_save) + +"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() abort " {{{2 + return g:SyntasticLoclist.current().getStatuslineFlag() +endfunction " }}}2 + +" }}}1 + +" Utilities {{{1 + +function! s:_resolve_filetypes(filetypes) abort " {{{2 + let type = len(a:filetypes) ? a:filetypes[0] : &filetype + return split( get(g:syntastic_filetype_map, type, type), '\m\.' ) +endfunction " }}}2 + +function! s:_ignore_file(filename) abort " {{{2 + let fname = fnamemodify(a:filename, ':p') + for pattern in g:syntastic_ignore_files + if fname =~# pattern + return 1 + endif + endfor + return 0 +endfunction " }}}2 + +function! s:_is_quitting(buf) abort " {{{2 + let quitting = 0 + if exists('w:syntastic_wid') + let key = a:buf . '_' . getbufvar(a:buf, 'changetick') . '_' . w:syntastic_wid + let idx = index(s:_quit_pre, key) + if idx >= 0 + call remove(s:_quit_pre, idx) + let quitting = 1 + endif + endif + + return quitting +endfunction " }}}2 + +" Skip running in special buffers +function! s:_skip_file() abort " {{{2 + let fname = expand('%', 1) + let skip = s:_is_quitting(bufnr('%')) || get(b:, 'syntastic_skip_checks', 0) || + \ (&buftype !=# '') || !filereadable(fname) || getwinvar(0, '&diff') || + \ getwinvar(0, '&previewwindow') || s:_ignore_file(fname) || + \ fnamemodify(fname, ':e') =~? g:syntastic_ignore_extensions + if skip + call syntastic#log#debug(g:_SYNTASTIC_DEBUG_TRACE, '_skip_file: skipping checks') + endif + return skip +endfunction " }}}2 + +" Explain why checks will be skipped for the current file +function! s:_explain_skip(filetypes) abort " {{{2 + if empty(a:filetypes) && s:_skip_file() + let why = [] + let fname = expand('%', 1) + + if s:_is_quitting(bufnr('%')) + call add(why, 'quitting buffer') + endif + if get(b:, 'syntastic_skip_checks', 0) + call add(why, 'b:syntastic_skip_checks set') + endif + if &buftype !=# '' + call add(why, 'buftype = ' . string(&buftype)) + endif + if !filereadable(fname) + call add(why, 'file not readable / not local') + endif + if getwinvar(0, '&diff') + call add(why, 'diff mode') + endif + if getwinvar(0, '&previewwindow') + call add(why, 'preview window') + endif + if s:_ignore_file(fname) + call add(why, 'filename matching g:syntastic_ignore_files') + endif + if fnamemodify(fname, ':e') =~? g:syntastic_ignore_extensions + call add(why, 'extension matching g:syntastic_ignore_extensions') + endif + + echomsg 'The current file will not be checked (' . join(why, ', ') . ')' + endif +endfunction " }}}2 + +" Take a list of errors and add default values to them from a:options +function! s:_add_to_errors(errors, options) abort " {{{2 + for err in a:errors + for key in keys(a:options) + if !has_key(err, key) || empty(err[key]) + let err[key] = a:options[key] + endif + endfor + endfor + + return a:errors +endfunction " }}}2 + +function! s:_os_name() abort " {{{2 + return g:_SYNTASTIC_UNAME +endfunction " }}}2 + +" }}}1 + +" vim: set sw=4 sts=4 et fdm=marker: diff --git a/vim/bundle/syntastic/plugin/syntastic/autoloclist.vim b/vim/bundle/syntastic/plugin/syntastic/autoloclist.vim new file mode 100644 index 0000000..153b0bc --- /dev/null +++ b/vim/bundle/syntastic/plugin/syntastic/autoloclist.vim @@ -0,0 +1,38 @@ +if exists('g:loaded_syntastic_notifier_autoloclist') || !exists('g:loaded_syntastic_plugin') + finish +endif +let g:loaded_syntastic_notifier_autoloclist = 1 + +let g:SyntasticAutoloclistNotifier = {} + +" Public methods {{{1 +" +function! g:SyntasticAutoloclistNotifier.New() abort " {{{2 + let newObj = copy(self) + return newObj +endfunction " }}}2 + +function! g:SyntasticAutoloclistNotifier.refresh(loclist) abort " {{{2 + call syntastic#log#debug(g:_SYNTASTIC_DEBUG_NOTIFICATIONS, 'autoloclist: refresh') + call g:SyntasticAutoloclistNotifier.AutoToggle(a:loclist) +endfunction " }}}2 + +function! g:SyntasticAutoloclistNotifier.AutoToggle(loclist) abort " {{{2 + call syntastic#log#debug(g:_SYNTASTIC_DEBUG_NOTIFICATIONS, 'autoloclist: toggle') + let auto_loc_list = syntastic#util#var('auto_loc_list') + if !a:loclist.isEmpty() + if auto_loc_list == 1 || auto_loc_list == 3 + call a:loclist.show() + endif + else + if auto_loc_list == 1 || auto_loc_list == 2 + "TODO: this will close the loc list window if one was opened by + "something other than syntastic + lclose + endif + endif +endfunction " }}}2 + +" }}}1 + +" vim: set sw=4 sts=4 et fdm=marker: diff --git a/vim/bundle/syntastic/plugin/syntastic/balloons.vim b/vim/bundle/syntastic/plugin/syntastic/balloons.vim new file mode 100644 index 0000000..fdd70bf --- /dev/null +++ b/vim/bundle/syntastic/plugin/syntastic/balloons.vim @@ -0,0 +1,59 @@ +if exists('g:loaded_syntastic_notifier_balloons') || !exists('g:loaded_syntastic_plugin') + finish +endif +let g:loaded_syntastic_notifier_balloons = 1 + +if !has('balloon_eval') + let g:syntastic_enable_balloons = 0 +endif + +let g:SyntasticBalloonsNotifier = {} + +" Public methods {{{1 + +function! g:SyntasticBalloonsNotifier.New() abort " {{{2 + let newObj = copy(self) + return newObj +endfunction " }}}2 + +function! g:SyntasticBalloonsNotifier.enabled() abort " {{{2 + return has('balloon_eval') && syntastic#util#var('enable_balloons') +endfunction " }}}2 + +" Update the error balloons +function! g:SyntasticBalloonsNotifier.refresh(loclist) abort " {{{2 + unlet! b:syntastic_private_balloons + if self.enabled() && !a:loclist.isEmpty() + let b:syntastic_private_balloons = a:loclist.balloons() + if !empty(b:syntastic_private_balloons) + set ballooneval balloonexpr=SyntasticBalloonsExprNotifier() + endif + endif +endfunction " }}}2 + +" Reset the error balloons +" @vimlint(EVL103, 1, a:loclist) +function! g:SyntasticBalloonsNotifier.reset(loclist) abort " {{{2 + let b:syntastic_private_balloons = {} + if has('balloon_eval') + call syntastic#log#debug(g:_SYNTASTIC_DEBUG_NOTIFICATIONS, 'balloons: reset') + unlet! b:syntastic_private_balloons + set noballooneval + endif +endfunction " }}}2 +" @vimlint(EVL103, 0, a:loclist) + +" }}}1 + +" Private functions {{{1 + +function! SyntasticBalloonsExprNotifier() abort " {{{2 + if !exists('b:syntastic_private_balloons') + return '' + endif + return get(b:syntastic_private_balloons, v:beval_lnum, '') +endfunction " }}}2 + +" }}}1 + +" vim: set sw=4 sts=4 et fdm=marker: diff --git a/vim/bundle/syntastic/plugin/syntastic/checker.vim b/vim/bundle/syntastic/plugin/syntastic/checker.vim new file mode 100644 index 0000000..22ad820 --- /dev/null +++ b/vim/bundle/syntastic/plugin/syntastic/checker.vim @@ -0,0 +1,273 @@ +if exists('g:loaded_syntastic_checker') || !exists('g:loaded_syntastic_plugin') + finish +endif +let g:loaded_syntastic_checker = 1 + +let g:SyntasticChecker = {} + +" Public methods {{{1 + +function! g:SyntasticChecker.New(args, ...) abort " {{{2 + let newObj = copy(self) + + let newObj._filetype = a:args['filetype'] + let newObj._name = a:args['name'] + + if a:0 + " redirected checker + let newObj._exec = get(a:args, 'exec', a:1['_exec']) + + let filetype = a:1['_filetype'] + let name = a:1['_name'] + let prefix = 'SyntaxCheckers_' . filetype . '_' . name . '_' + + if exists('g:syntastic_' . filetype . '_' . name . '_sort') && !exists('g:syntastic_' . newObj._filetype . '_' . newObj._name . '_sort') + let g:syntastic_{newObj._filetype}_{newObj._name}_sort = g:syntastic_{filetype}_{name}_sort + endif + + if has_key(a:args, 'enable') + let newObj._enable = a:args['enable'] + elseif has_key(a:1, '_enable') + let newObj._enable = a:1['_enable'] + endif + else + let newObj._exec = get(a:args, 'exec', newObj._name) + let prefix = 'SyntaxCheckers_' . newObj._filetype . '_' . newObj._name . '_' + + if has_key(a:args, 'enable') + let newObj._enable = a:args['enable'] + endif + endif + + let newObj._locListFunc = function(prefix . 'GetLocList') + + if exists('*' . prefix . 'IsAvailable') + let newObj._isAvailableFunc = function(prefix . 'IsAvailable') + else + let newObj._isAvailableFunc = function('s:_isAvailableDefault') + endif + + if exists('*' . prefix . 'GetHighlightRegex') + let newObj._highlightRegexFunc = function(prefix . 'GetHighlightRegex') + endif + + return newObj +endfunction " }}}2 + +function! g:SyntasticChecker.getFiletype() abort " {{{2 + return self._filetype +endfunction " }}}2 + +function! g:SyntasticChecker.getName() abort " {{{2 + return self._name +endfunction " }}}2 + +" Synchronise _exec with user's setting. Force re-validation if needed. +" +" XXX: This function must be called at least once before calling either +" getExec() or getExecEscaped(). Normally isAvailable() does that for you +" automatically, but you should keep still this in mind if you change the +" current checker workflow. +function! g:SyntasticChecker.syncExec() abort " {{{2 + let user_exec = + \ expand( exists('b:syntastic_' . self._name . '_exec') ? b:syntastic_{self._name}_exec : + \ syntastic#util#var(self._filetype . '_' . self._name . '_exec'), 1 ) + + if user_exec !=# '' && user_exec !=# self._exec + let self._exec = user_exec + if has_key(self, '_available') + " we have a new _exec on the block, it has to be validated + call remove(self, '_available') + endif + endif +endfunction " }}}2 + +function! g:SyntasticChecker.getExec() abort " {{{2 + return self._exec +endfunction " }}}2 + +function! g:SyntasticChecker.getExecEscaped() abort " {{{2 + return syntastic#util#shescape(self._exec) +endfunction " }}}2 + +function! g:SyntasticChecker.getLocListRaw() abort " {{{2 + let checker_start = reltime() + let name = self._filetype . '/' . self._name + + if has_key(self, '_enable') + let status = syntastic#util#var(self._enable, -1) + if type(status) != type(0) + call syntastic#log#error('checker ' . name . ': invalid value ' . strtrans(string(status)) . + \ ' for g:syntastic_' . self._enable . '; try 0 or 1 instead') + return [] + endif + if status < 0 + call syntastic#log#error('checker ' . name . ': checks disabled for security reasons; ' . + \ 'set g:syntastic_' . self._enable . ' to 1 to override') + endif + if status <= 0 + call syntastic#log#debug(g:_SYNTASTIC_DEBUG_TRACE, 'getLocList: checker ' . name . ' enabled but not forced') + return [] + else + call syntastic#log#debug(g:_SYNTASTIC_DEBUG_TRACE, 'getLocList: checker ' . name . ' forced') + endif + endif + + try + let list = self._locListFunc() + if self._exec !=# '' + call syntastic#log#debug(g:_SYNTASTIC_DEBUG_TRACE, 'getLocList: checker ' . name . ' returned ' . v:shell_error) + endif + catch /\m\C^Syntastic: checker error$/ + let list = [] + if self._exec !=# '' + call syntastic#log#error('checker ' . name . ' returned abnormal status ' . v:shell_error) + else + call syntastic#log#error('checker ' . name . ' aborted') + endif + endtry + call self._populateHighlightRegexes(list) + call syntastic#log#debug(g:_SYNTASTIC_DEBUG_LOCLIST, name . ' raw:', list) + call self._quietMessages(list) + call syntastic#log#debug(g:_SYNTASTIC_DEBUG_TRACE, + \ 'getLocList: checker ' . name . ' run in ' . split(reltimestr(reltime(checker_start)))[0] . 's') + return list +endfunction " }}}2 + +function! g:SyntasticChecker.getLocList() abort " {{{2 + return g:SyntasticLoclist.New(self.getLocListRaw()) +endfunction " }}}2 + +function! g:SyntasticChecker.getVersion(...) abort " {{{2 + if !exists('self._version') + let command = a:0 ? a:1 : self.getExecEscaped() . ' --version' + let version_output = syntastic#util#system(command) + call self.log('getVersion: ' . string(command) . ': ' . + \ string(split(version_output, "\n", 1)) . + \ (v:shell_error ? ' (exit code ' . v:shell_error . ')' : '') ) + let parsed_ver = syntastic#util#parseVersion(version_output) + if len(parsed_ver) + call self.setVersion(parsed_ver) + else + call syntastic#log#ndebug(g:_SYNTASTIC_DEBUG_LOCLIST, 'checker output:', split(version_output, "\n", 1)) + call syntastic#log#error("checker " . self._filetype . "/" . self._name . ": can't parse version string (abnormal termination?)") + endif + endif + return get(self, '_version', []) +endfunction " }}}2 + +function! g:SyntasticChecker.setVersion(version) abort " {{{2 + if len(a:version) + let self._version = copy(a:version) + call self.log(self.getExec() . ' version =', a:version) + endif +endfunction " }}}2 + +function! g:SyntasticChecker.log(msg, ...) abort " {{{2 + let leader = self._filetype . '/' . self._name . ': ' + if a:0 > 0 + call syntastic#log#debug(g:_SYNTASTIC_DEBUG_CHECKERS, leader . a:msg, a:1) + else + call syntastic#log#debug(g:_SYNTASTIC_DEBUG_CHECKERS, leader . a:msg) + endif +endfunction " }}}2 + +function! g:SyntasticChecker.makeprgBuild(opts) abort " {{{2 + let basename = self._filetype . '_' . self._name . '_' + + let parts = [] + call extend(parts, self._getOpt(a:opts, basename, 'exe', self.getExecEscaped())) + call extend(parts, self._getOpt(a:opts, basename, 'args', '')) + call extend(parts, self._getOpt(a:opts, basename, 'fname', syntastic#util#shexpand('%'))) + call extend(parts, self._getOpt(a:opts, basename, 'post_args', '')) + call extend(parts, self._getOpt(a:opts, basename, 'tail', '')) + + return join(parts) +endfunction " }}}2 + +function! g:SyntasticChecker.isAvailable() abort " {{{2 + call self.syncExec() + if !has_key(self, '_available') + let self._available = self._isAvailableFunc() + endif + return self._available +endfunction " }}}2 + +function! g:SyntasticChecker.isDisabled() abort " {{{2 + return has_key(self, '_enable') && syntastic#util#var(self._enable, -1) <= 0 +endfunction " }}}2 + +function! g:SyntasticChecker.wantSort() abort " {{{2 + return syntastic#util#var(self._filetype . '_' . self._name . '_sort', 0) +endfunction " }}}2 + +" This method is no longer used by syntastic. It's here only to maintain +" backwards compatibility with external checkers which might depend on it. +function! g:SyntasticChecker.setWantSort(val) abort " {{{2 + if !exists('g:syntastic_' . self._filetype . '_' . self._name . '_sort') + let g:syntastic_{self._filetype}_{self._name}_sort = a:val + endif +endfunction " }}}2 + +" }}}1 + +" Private methods {{{1 + +function! g:SyntasticChecker._quietMessages(errors) abort " {{{2 + " wildcard quiet_messages + let quiet_filters = copy(syntastic#util#var('quiet_messages', {})) + if type(quiet_filters) != type({}) + call syntastic#log#warn('ignoring invalid syntastic_quiet_messages') + unlet quiet_filters + let quiet_filters = {} + endif + + " per checker quiet_messages + let name = self._filetype . '_' . self._name + try + call extend( quiet_filters, copy(syntastic#util#var(name . '_quiet_messages', {})), 'force' ) + catch /\m^Vim\%((\a\+)\)\=:E712/ + call syntastic#log#warn('ignoring invalid syntastic_' . name . '_quiet_messages') + endtry + + call syntastic#log#debug(g:_SYNTASTIC_DEBUG_LOCLIST, 'quiet_messages filter:', quiet_filters) + + if !empty(quiet_filters) + call syntastic#util#dictFilter(a:errors, quiet_filters) + call syntastic#log#debug(g:_SYNTASTIC_DEBUG_LOCLIST, 'filtered by quiet_messages:', a:errors) + endif +endfunction " }}}2 + +function! g:SyntasticChecker._populateHighlightRegexes(errors) abort " {{{2 + if has_key(self, '_highlightRegexFunc') + for e in a:errors + if e['valid'] + let term = self._highlightRegexFunc(e) + if term !=# '' + let e['hl'] = term + endif + endif + endfor + endif +endfunction " }}}2 + +function! g:SyntasticChecker._getOpt(opts, basename, name, default) abort " {{{2 + let ret = [] + call extend( ret, syntastic#util#argsescape(get(a:opts, a:name . '_before', '')) ) + call extend( ret, syntastic#util#argsescape(syntastic#util#var( a:basename . a:name, get(a:opts, a:name, a:default) )) ) + call extend( ret, syntastic#util#argsescape(get(a:opts, a:name . '_after', '')) ) + + return ret +endfunction " }}}2 + +" }}}1 + +" Private functions {{{1 + +function! s:_isAvailableDefault() dict " {{{2 + return executable(self.getExec()) +endfunction " }}}2 + +" }}}1 + +" vim: set sw=4 sts=4 et fdm=marker: diff --git a/vim/bundle/syntastic/plugin/syntastic/cursor.vim b/vim/bundle/syntastic/plugin/syntastic/cursor.vim new file mode 100644 index 0000000..f59d87b --- /dev/null +++ b/vim/bundle/syntastic/plugin/syntastic/cursor.vim @@ -0,0 +1,138 @@ +if exists('g:loaded_syntastic_notifier_cursor') || !exists('g:loaded_syntastic_plugin') + finish +endif +let g:loaded_syntastic_notifier_cursor = 1 + +let g:SyntasticCursorNotifier = {} + +" Public methods {{{1 + +function! g:SyntasticCursorNotifier.New() abort " {{{2 + let newObj = copy(self) + return newObj +endfunction " }}}2 + +function! g:SyntasticCursorNotifier.enabled() abort " {{{2 + return syntastic#util#var('echo_current_error') +endfunction " }}}2 + +function! g:SyntasticCursorNotifier.refresh(loclist) abort " {{{2 + if self.enabled() && !a:loclist.isEmpty() + call syntastic#log#debug(g:_SYNTASTIC_DEBUG_NOTIFICATIONS, 'cursor: refresh') + let b:syntastic_private_messages = copy(a:loclist.messages(bufnr(''))) + let b:syntastic_private_line = -1 + let b:syntastic_cursor_columns = a:loclist.getCursorColumns() + autocmd! syntastic CursorMoved + autocmd syntastic CursorMoved * call SyntasticRefreshCursor() + endif +endfunction " }}}2 + +" @vimlint(EVL103, 1, a:loclist) +function! g:SyntasticCursorNotifier.reset(loclist) abort " {{{2 + call syntastic#log#debug(g:_SYNTASTIC_DEBUG_NOTIFICATIONS, 'cursor: reset') + autocmd! syntastic CursorMoved + unlet! b:syntastic_private_messages + let b:syntastic_private_line = -1 +endfunction " }}}2 +" @vimlint(EVL103, 0, a:loclist) + +" }}}1 + +" Private functions {{{1 + +function! SyntasticRefreshCursor() abort " {{{2 + if !exists('b:syntastic_private_messages') || empty(b:syntastic_private_messages) + " file not checked + return + endif + + if !exists('b:syntastic_private_line') + let b:syntastic_private_line = -1 + endif + let l = line('.') + let current_messages = get(b:syntastic_private_messages, l, {}) + + if !exists('b:syntastic_cursor_columns') + let b:syntastic_cursor_columns = g:syntastic_cursor_columns + endif + + if b:syntastic_cursor_columns + let c = virtcol('.') + if !exists('b:syntastic_private_idx') + let b:syntastic_private_idx = -1 + endif + + if s:_is_same_index(l, b:syntastic_private_line, c, b:syntastic_private_idx, current_messages) + return + else + let b:syntastic_private_line = l + endif + + if !empty(current_messages) + let b:syntastic_private_idx = s:_find_index(c, current_messages) + call syntastic#util#wideMsg(current_messages[b:syntastic_private_idx].text) + else + let b:syntastic_private_idx = -1 + echo + endif + else + if l == b:syntastic_private_line + return + endif + let b:syntastic_private_line = l + + if !empty(current_messages) + call syntastic#util#wideMsg(current_messages[0].text) + else + echo + endif + endif +endfunction " }}}2 + +" }}}1 + +" Utilities {{{1 + +function! s:_is_same_index(line, old_line, column, idx, messages) abort " {{{2 + if a:old_line >= 0 && a:line == a:old_line && a:idx >= 0 + if len(a:messages) <= 1 + return 1 + endif + + if a:messages[a:idx].scol <= a:column || a:idx == 0 + if a:idx == len(a:messages) - 1 || a:column < a:messages[a:idx + 1].scol + return 1 + else + return 0 + endif + else + return 0 + endif + else + return 0 + endif +endfunction " }}}2 + +function! s:_find_index(column, messages) abort " {{{2 + let max = len(a:messages) - 1 + if max == 0 + return 0 + endif + let min = 0 + + " modified binary search: assign index 0 to columns to the left of the first error + while min < max - 1 + let mid = (min + max) / 2 + if a:column < a:messages[mid].scol + let max = mid + else + let min = mid + endif + endwhile + + return a:column < a:messages[max].scol ? min : max +endfunction " }}}2 + +" }}}1 + +" vim: set sw=4 sts=4 et fdm=marker: diff --git a/vim/bundle/syntastic/plugin/syntastic/highlighting.vim b/vim/bundle/syntastic/plugin/syntastic/highlighting.vim new file mode 100644 index 0000000..a9e1a08 --- /dev/null +++ b/vim/bundle/syntastic/plugin/syntastic/highlighting.vim @@ -0,0 +1,104 @@ +if exists('g:loaded_syntastic_notifier_highlighting') || !exists('g:loaded_syntastic_plugin') + finish +endif +let g:loaded_syntastic_notifier_highlighting = 1 + +" Highlighting requires getmatches introduced in 7.1.040 +let s:has_highlighting = v:version > 701 || (v:version == 701 && has('patch040')) +lockvar s:has_highlighting + +let g:SyntasticHighlightingNotifier = {} + +let s:setup_done = 0 + +" Public methods {{{1 + +function! g:SyntasticHighlightingNotifier.New() abort " {{{2 + let newObj = copy(self) + + if !s:setup_done + call self._setup() + let s:setup_done = 1 + lockvar s:setup_done + endif + + return newObj +endfunction " }}}2 + +function! g:SyntasticHighlightingNotifier.enabled() abort " {{{2 + return s:has_highlighting && syntastic#util#var('enable_highlighting') +endfunction " }}}2 + +" Sets error highlights in the current window +function! g:SyntasticHighlightingNotifier.refresh(loclist) abort " {{{2 + if self.enabled() + call syntastic#log#debug(g:_SYNTASTIC_DEBUG_NOTIFICATIONS, 'highlighting: refresh') + call self._reset() + let buf = bufnr('') + let issues = filter(a:loclist.copyRaw(), 'v:val["bufnr"] == buf') + for item in issues + let group = 'Syntastic' . get(item, 'subtype', '') . ( item['type'] ==? 'E' ? 'Error' : 'Warning' ) + + " The function `Syntastic_{filetype}_{checker}_GetHighlightRegex` is + " used to override default highlighting. + if has_key(item, 'hl') + call matchadd(group, '\%' . item['lnum'] . 'l' . item['hl']) + elseif get(item, 'col', 0) + if get(item, 'vcol', 0) + let lastcol = virtcol([item['lnum'], '$']) + let coltype = 'v' + else + let lastcol = col([item['lnum'], '$']) + let coltype = 'c' + endif + let lcol = min([lastcol, item['col']]) + + call matchadd(group, '\%' . item['lnum'] . 'l\%' . lcol . coltype) + endif + endfor + endif +endfunction " }}}2 + +" Remove all error highlights from the window +" @vimlint(EVL103, 1, a:loclist) +function! g:SyntasticHighlightingNotifier.reset(loclist) abort " {{{2 + if s:has_highlighting + call syntastic#log#debug(g:_SYNTASTIC_DEBUG_NOTIFICATIONS, 'highlighting: reset') + call self._reset() + endif +endfunction " }}}2 +" @vimlint(EVL103, 0, a:loclist) + +" }}}1 + +" Private methods {{{1 + +" One time setup: define our own highlighting +function! g:SyntasticHighlightingNotifier._setup() abort " {{{2 + if s:has_highlighting + if !hlexists('SyntasticError') + highlight link SyntasticError SpellBad + endif + if !hlexists('SyntasticWarning') + highlight link SyntasticWarning SpellCap + endif + if !hlexists('SyntasticStyleError') + highlight link SyntasticStyleError SyntasticError + endif + if !hlexists('SyntasticStyleWarning') + highlight link SyntasticStyleWarning SyntasticWarning + endif + endif +endfunction " }}}2 + +function! g:SyntasticHighlightingNotifier._reset() abort " {{{2 + for match in getmatches() + if stridx(match['group'], 'Syntastic') == 0 + call matchdelete(match['id']) + endif + endfor +endfunction " }}}2 + +" }}}1 + +" vim: set sw=4 sts=4 et fdm=marker: diff --git a/vim/bundle/syntastic/plugin/syntastic/loclist.vim b/vim/bundle/syntastic/plugin/syntastic/loclist.vim new file mode 100644 index 0000000..3e9528b --- /dev/null +++ b/vim/bundle/syntastic/plugin/syntastic/loclist.vim @@ -0,0 +1,439 @@ +if exists('g:loaded_syntastic_loclist') || !exists('g:loaded_syntastic_plugin') + finish +endif +let g:loaded_syntastic_loclist = 1 + +let g:SyntasticLoclist = {} + +" Public methods {{{1 + +function! g:SyntasticLoclist.New(rawLoclist) abort " {{{2 + let newObj = copy(self) + + let llist = filter(copy(a:rawLoclist), 'v:val["valid"] == 1') + + for e in llist + if get(e, 'type', '') ==# '' + let e['type'] = 'E' + endif + endfor + + let newObj._rawLoclist = llist + let newObj._name = '' + let newObj._owner = bufnr('') + let newObj._sorted = 0 + let newObj._columns = g:syntastic_cursor_columns + + return newObj +endfunction " }}}2 + +function! g:SyntasticLoclist.current() abort " {{{2 + if !exists('b:syntastic_loclist') || empty(b:syntastic_loclist) + let b:syntastic_loclist = g:SyntasticLoclist.New([]) + endif + return b:syntastic_loclist +endfunction " }}}2 + +function! g:SyntasticLoclist.extend(other) abort " {{{2 + let list = self.copyRaw() + call extend(list, a:other.copyRaw()) + return g:SyntasticLoclist.New(list) +endfunction " }}}2 + +function! g:SyntasticLoclist.sort() abort " {{{2 + if !self._sorted + for e in self._rawLoclist + call s:_set_screen_column(e) + endfor + + call sort(self._rawLoclist, self._columns ? 's:_compare_error_items_by_columns' : 's:_compare_error_items_by_lines') + + let self._sorted = 1 + endif +endfunction " }}}2 + +function! g:SyntasticLoclist.isEmpty() abort " {{{2 + return empty(self._rawLoclist) +endfunction " }}}2 + +function! g:SyntasticLoclist.isNewerThan(stamp) abort " {{{2 + if !exists('self._stamp') + let self._stamp = [] + return 0 + endif + return syntastic#util#compareLexi(self._stamp, a:stamp) > 0 +endfunction " }}}2 + +function! g:SyntasticLoclist.copyRaw() abort " {{{2 + return copy(self._rawLoclist) +endfunction " }}}2 + +function! g:SyntasticLoclist.getRaw() abort " {{{2 + return self._rawLoclist +endfunction " }}}2 + +function! g:SyntasticLoclist.getBuffers() abort " {{{2 + return syntastic#util#unique(map(copy(self._rawLoclist), 'str2nr(v:val["bufnr"])') + [self._owner]) +endfunction " }}}2 + +function! g:SyntasticLoclist.getCursorColumns() abort " {{{2 + return self._columns +endfunction " }}}2 + +function! g:SyntasticLoclist.getStatuslineFlag() abort " {{{2 + if !exists('self._stl_format') + let self._stl_format = '' + endif + if !exists('self._stl_flag') + let self._stl_flag = '' + endif + + if g:syntastic_stl_format !=# self._stl_format + let self._stl_format = g:syntastic_stl_format + + if !empty(self._rawLoclist) + let errors = self.errors() + let warnings = self.warnings() + + let num_errors = len(errors) + let num_warnings = len(warnings) + let num_issues = len(self._rawLoclist) + + let output = self._stl_format + + "hide stuff wrapped in %E(...) unless there are errors + let output = substitute(output, '\m\C%E{\([^}]*\)}', num_errors ? '\1' : '' , 'g') + + "hide stuff wrapped in %W(...) unless there are warnings + let output = substitute(output, '\m\C%W{\([^}]*\)}', num_warnings ? '\1' : '' , 'g') + + "hide stuff wrapped in %B(...) unless there are both errors and warnings + let output = substitute(output, '\m\C%B{\([^}]*\)}', (num_warnings && num_errors) ? '\1' : '' , 'g') + + let flags = { + \ '%': '%', + \ 't': num_issues, + \ 'e': num_errors, + \ 'w': num_warnings, + \ 'N': (num_issues ? fnamemodify( bufname(self._rawLoclist[0]['bufnr']), ':t') : ''), + \ 'P': (num_issues ? fnamemodify( bufname(self._rawLoclist[0]['bufnr']), ':p:~:.') : ''), + \ 'F': (num_issues ? self._rawLoclist[0]['lnum'] : ''), + \ 'ne': (num_errors ? fnamemodify( bufname(errors[0]['bufnr']), ':t') : ''), + \ 'pe': (num_errors ? fnamemodify( bufname(errors[0]['bufnr']), ':p:~:.') : ''), + \ 'fe': (num_errors ? errors[0]['lnum'] : ''), + \ 'nw': (num_warnings ? fnamemodify( bufname(warnings[0]['bufnr']), ':t') : ''), + \ 'pw': (num_warnings ? fnamemodify( bufname(warnings[0]['bufnr']), ':p:~:.') : ''), + \ 'fw': (num_warnings ? warnings[0]['lnum'] : '') } + let output = substitute(output, '\v\C\%(-?\d*%(\.\d+)?)([npf][ew]|[NPFtew%])', '\=syntastic#util#wformat(submatch(1), flags[submatch(2)])', 'g') + + let self._stl_flag = output + else + let self._stl_flag = '' + endif + endif + + return self._stl_flag +endfunction " }}}2 + +function! g:SyntasticLoclist.getFirstError(...) abort " {{{2 + let max_issues = len(self._rawLoclist) + if a:0 && a:1 < max_issues + let max_issues = a:1 + endif + + for idx in range(max_issues) + if get(self._rawLoclist[idx], 'type', '') ==? 'E' + return idx + 1 + endif + endfor + + return 0 +endfunction " }}}2 + +function! g:SyntasticLoclist.getName() abort " {{{2 + return len(self._name) +endfunction " }}}2 + +function! g:SyntasticLoclist.setName(name) abort " {{{2 + let self._name = a:name +endfunction " }}}2 + +function! g:SyntasticLoclist.getOwner() abort " {{{2 + return self._owner +endfunction " }}}2 + +function! g:SyntasticLoclist.setOwner(buffer) abort " {{{2 + let self._owner = type(a:buffer) == type(0) ? a:buffer : str2nr(a:buffer) +endfunction " }}}2 + +function! g:SyntasticLoclist.deploy() abort " {{{2 + call self.setOwner(bufnr('')) + let self._stamp = syntastic#util#stamp() + for buf in self.getBuffers() + call setbufvar(buf, 'syntastic_loclist', self) + endfor +endfunction " }}}2 + +function! g:SyntasticLoclist.destroy() abort " {{{2 + for buf in self.getBuffers() + call setbufvar(buf, 'syntastic_loclist', {}) + endfor +endfunction " }}}2 + +function! g:SyntasticLoclist.decorate(tag) abort " {{{2 + for e in self._rawLoclist + let e['text'] .= ' [' . a:tag . ']' + endfor +endfunction " }}}2 + +function! g:SyntasticLoclist.balloons() abort " {{{2 + if !exists('self._cachedBalloons') + let sep = has('balloon_multiline') ? "\n" : ' | ' + + let self._cachedBalloons = {} + for e in self._rawLoclist + let buf = e['bufnr'] + + if !has_key(self._cachedBalloons, buf) + let self._cachedBalloons[buf] = {} + endif + + if has_key(self._cachedBalloons[buf], e['lnum']) + let self._cachedBalloons[buf][e['lnum']] .= sep . e['text'] + else + let self._cachedBalloons[buf][e['lnum']] = e['text'] + endif + endfor + endif + + return get(self._cachedBalloons, bufnr(''), {}) +endfunction " }}}2 + +function! g:SyntasticLoclist.errors() abort " {{{2 + if !exists('self._cachedErrors') + let self._cachedErrors = self.filter({'type': 'E'}) + endif + return self._cachedErrors +endfunction " }}}2 + +function! g:SyntasticLoclist.warnings() abort " {{{2 + if !exists('self._cachedWarnings') + let self._cachedWarnings = self.filter({'type': 'W'}) + endif + return self._cachedWarnings +endfunction " }}}2 + +" Legacy function. Syntastic no longer calls it, but we keep it +" around because other plugins (f.i. powerline) depend on it. +function! g:SyntasticLoclist.hasErrorsOrWarningsToDisplay() abort " {{{2 + return !self.isEmpty() +endfunction " }}}2 + +" cache used by EchoCurrentError() +function! g:SyntasticLoclist.messages(buf) abort " {{{2 + if !exists('self._cachedMessages') + let self._cachedMessages = {} + + let errors = self.errors() + self.warnings() + for e in errors + let b = e['bufnr'] + let l = e['lnum'] + + if !has_key(self._cachedMessages, b) + let self._cachedMessages[b] = {} + endif + + if !has_key(self._cachedMessages[b], l) + let self._cachedMessages[b][l] = [e] + elseif self._columns + call add(self._cachedMessages[b][l], e) + endif + endfor + + if self._columns + if !self._sorted + for b in keys(self._cachedMessages) + for l in keys(self._cachedMessages[b]) + if len(self._cachedMessages[b][l]) > 1 + for e in self._cachedMessages[b][l] + call s:_set_screen_column(e) + endfor + call sort(self._cachedMessages[b][l], 's:_compare_error_items_by_columns') + endif + endfor + endfor + endif + + for b in keys(self._cachedMessages) + for l in keys(self._cachedMessages[b]) + call s:_remove_shadowed_items(self._cachedMessages[b][l]) + endfor + endfor + endif + endif + + return get(self._cachedMessages, a:buf, {}) +endfunction " }}}2 + +"Filter the list and return new native loclist +"e.g. +" .filter({'bufnr': 10, 'type': 'e'}) +" +"would return all errors for buffer 10. +" +"Note that all comparisons are done with ==? +function! g:SyntasticLoclist.filter(filters) abort " {{{2 + let conditions = values(map(copy(a:filters), 's:_translate(v:key, v:val)')) + let filter = len(conditions) == 1 ? + \ conditions[0] : join(map(conditions, '"(" . v:val . ")"'), ' && ') + return filter(copy(self._rawLoclist), filter) +endfunction " }}}2 + +function! g:SyntasticLoclist.setloclist() abort " {{{2 + if !exists('w:syntastic_loclist_set') + let w:syntastic_loclist_set = [] + endif + if empty(w:syntastic_loclist_set) || w:syntastic_loclist_set != [bufnr(''), b:changedtick] + let replace = g:syntastic_reuse_loc_lists && !empty(w:syntastic_loclist_set) + call syntastic#log#debug(g:_SYNTASTIC_DEBUG_NOTIFICATIONS, 'loclist: setloclist ' . (replace ? '(replace)' : '(new)')) + call setloclist(0, self.getRaw(), replace ? 'r' : ' ') + call syntastic#util#setChangedtick() + let w:syntastic_loclist_set = [bufnr(''), b:syntastic_changedtick] + endif +endfunction " }}}2 + +"display the cached errors for this buf in the location list +function! g:SyntasticLoclist.show() abort " {{{2 + call syntastic#log#debug(g:_SYNTASTIC_DEBUG_NOTIFICATIONS, 'loclist: show') + call self.setloclist() + + if !self.isEmpty() + let num = winnr() + execute 'lopen ' . syntastic#util#var('loc_list_height') + if num != winnr() + execute num . 'wincmd w' + 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) + call setbufvar(buf, 'syntastic_owner_buffer', self._owner) + endif + endif + endfor + endif +endfunction " }}}2 + +" }}}1 + +" Public functions {{{1 + +function! SyntasticLoclistHide() abort " {{{2 + call syntastic#log#debug(g:_SYNTASTIC_DEBUG_NOTIFICATIONS, 'loclist: hide') + silent! lclose +endfunction " }}}2 + +" }}}1 + +" Utilities {{{1 + +function! s:_translate(key, val) abort " {{{2 + return 'get(v:val, ' . string(a:key) . ', "") ==? ' . string(a:val) +endfunction " }}}2 + +function! s:_set_screen_column(item) abort " {{{2 + if !has_key(a:item, 'scol') + let col = get(a:item, 'col', 0) + if col != 0 && get(a:item, 'vcol', 0) == 0 + let buf = str2nr(a:item['bufnr']) + try + let line = getbufline(buf, a:item['lnum'])[0] + catch /\m^Vim\%((\a\+)\)\=:E684/ + let line = '' + endtry + let a:item['scol'] = syntastic#util#screenWidth(strpart(line, 0, col), getbufvar(buf, '&tabstop')) + else + let a:item['scol'] = col + endif + endif +endfunction " }}}2 + +function! s:_remove_shadowed_items(errors) abort " {{{2 + " keep only the first message at a given column + let i = 0 + while i < len(a:errors) - 1 + let j = i + 1 + let dupes = 0 + while j < len(a:errors) && a:errors[j].scol == a:errors[i].scol + let dupes = 1 + let j += 1 + endwhile + if dupes + call remove(a:errors, i + 1, j - 1) + endif + let i += 1 + endwhile + + " merge messages with the same text + let i = 0 + while i < len(a:errors) - 1 + let j = i + 1 + let dupes = 0 + while j < len(a:errors) && a:errors[j].text == a:errors[i].text + let dupes = 1 + let j += 1 + endwhile + if dupes + call remove(a:errors, i + 1, j - 1) + endif + let i += 1 + endwhile +endfunction " }}}2 + +function! s:_compare_error_items_by_columns(a, b) abort " {{{2 + if a:a['bufnr'] != a:b['bufnr'] + " group by file + return a:a['bufnr'] - a:b['bufnr'] + elseif a:a['lnum'] != a:b['lnum'] + " sort by line + return a:a['lnum'] - a:b['lnum'] + elseif a:a['scol'] != a:b['scol'] + " sort by screen column + return a:a['scol'] - a:b['scol'] + elseif a:a['type'] !=? a:b['type'] + " errors take precedence over warnings + return a:a['type'] ==? 'E' ? -1 : 1 + else + return 0 + endif +endfunction " }}}2 + +function! s:_compare_error_items_by_lines(a, b) abort " {{{2 + if a:a['bufnr'] != a:b['bufnr'] + " group by file + return a:a['bufnr'] - a:b['bufnr'] + elseif a:a['lnum'] != a:b['lnum'] + " sort by line + 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 + " sort by screen column + return a:a['scol'] - a:b['scol'] + endif +endfunction " }}}2 + +" }}}1 + +" vim: set sw=4 sts=4 et fdm=marker: diff --git a/vim/bundle/syntastic/plugin/syntastic/modemap.vim b/vim/bundle/syntastic/plugin/syntastic/modemap.vim new file mode 100644 index 0000000..501c82b --- /dev/null +++ b/vim/bundle/syntastic/plugin/syntastic/modemap.vim @@ -0,0 +1,117 @@ +if exists('g:loaded_syntastic_modemap') || !exists('g:loaded_syntastic_plugin') + finish +endif +let g:loaded_syntastic_modemap = 1 + +let g:SyntasticModeMap = {} + +" Public methods {{{1 + +function! g:SyntasticModeMap.Instance() abort " {{{2 + if !exists('s:SyntasticModeMapInstance') + let s:SyntasticModeMapInstance = copy(self) + call s:SyntasticModeMapInstance.synch() + endif + + return s:SyntasticModeMapInstance +endfunction " }}}2 + +function! g:SyntasticModeMap.synch() abort " {{{2 + if exists('g:syntastic_mode_map') + let self._mode = get(g:syntastic_mode_map, 'mode', 'active') + let self._activeFiletypes = copy(get(g:syntastic_mode_map, 'active_filetypes', [])) + let self._passiveFiletypes = copy(get(g:syntastic_mode_map, 'passive_filetypes', [])) + else + let self._mode = 'active' + let self._activeFiletypes = [] + let self._passiveFiletypes = [] + endif +endfunction " }}}2 + +function! g:SyntasticModeMap.allowsAutoChecking(filetype) abort " {{{2 + let fts = split(a:filetype, '\m\.') + + if self.isPassive() + return self._isOneFiletypeActive(fts) + else + return self._noFiletypesArePassive(fts) + endif +endfunction " }}}2 + +function! g:SyntasticModeMap.doAutoChecking() abort " {{{2 + let local_mode = get(b:, 'syntastic_mode', '') + if local_mode ==# 'active' || local_mode ==# 'passive' + return local_mode ==# 'active' + endif + + return self.allowsAutoChecking(&filetype) +endfunction " }}}2 + +function! g:SyntasticModeMap.isPassive() abort " {{{2 + return self._mode ==# 'passive' +endfunction " }}}2 + +function! g:SyntasticModeMap.toggleMode() abort " {{{2 + call self.synch() + + if self._mode ==# 'active' + let self._mode = 'passive' + else + let self._mode = 'active' + endif + + "XXX Changing a global variable. Tsk, tsk... + if !exists('g:syntastic_mode_map') + let g:syntastic_mode_map = {} + endif + let g:syntastic_mode_map['mode'] = self._mode +endfunction " }}}2 + +function! g:SyntasticModeMap.echoMode() abort " {{{2 + echo 'Syntastic: ' . self._mode . ' mode enabled' +endfunction " }}}2 + +function! g:SyntasticModeMap.modeInfo(filetypes) abort " {{{2 + echomsg 'Syntastic version: ' . g:_SYNTASTIC_VERSION . ' (Vim ' . v:version . ', ' . g:_SYNTASTIC_UNAME . ')' + let type = len(a:filetypes) ? a:filetypes[0] : &filetype + echomsg 'Info for filetype: ' . type + + call self.synch() + echomsg 'Global mode: ' . self._mode + if self._mode ==# 'active' + if len(self._passiveFiletypes) + let plural = len(self._passiveFiletypes) != 1 ? 's' : '' + echomsg 'Passive filetype' . plural . ': ' . join(sort(copy(self._passiveFiletypes))) + endif + else + if len(self._activeFiletypes) + let plural = len(self._activeFiletypes) != 1 ? 's' : '' + echomsg 'Active filetype' . plural . ': ' . join(sort(copy(self._activeFiletypes))) + endif + endif + echomsg 'Filetype ' . type . ' is ' . (self.allowsAutoChecking(type) ? 'active' : 'passive') + + if !len(a:filetypes) + if exists('b:syntastic_mode') && (b:syntastic_mode ==# 'active' || b:syntastic_mode ==# 'passive') + echomsg 'Local mode: ' . b:syntastic_mode + endif + + echomsg 'The current file will ' . (self.doAutoChecking() ? '' : 'not ') . 'be checked automatically' + endif +endfunction " }}}2 + +" }}}1 + +" Private methods {{{1 + +function! g:SyntasticModeMap._isOneFiletypeActive(filetypes) abort " {{{2 + return !empty(filter(copy(a:filetypes), 'index(self._activeFiletypes, v:val) != -1')) +endfunction " }}}2 + +function! g:SyntasticModeMap._noFiletypesArePassive(filetypes) abort " {{{2 + return empty(filter(copy(a:filetypes), 'index(self._passiveFiletypes, v:val) != -1')) +endfunction " }}}2 + +" }}}1 + +" vim: set sw=4 sts=4 et fdm=marker: diff --git a/vim/bundle/syntastic/plugin/syntastic/notifiers.vim b/vim/bundle/syntastic/plugin/syntastic/notifiers.vim new file mode 100644 index 0000000..fe158ca --- /dev/null +++ b/vim/bundle/syntastic/plugin/syntastic/notifiers.vim @@ -0,0 +1,86 @@ +if exists('g:loaded_syntastic_notifiers') || !exists('g:loaded_syntastic_plugin') + finish +endif +let g:loaded_syntastic_notifiers = 1 + +let g:SyntasticNotifiers = {} + +let s:_NOTIFIER_TYPES = ['signs', 'balloons', 'highlighting', 'cursor', 'autoloclist'] +lockvar! s:_NOTIFIER_TYPES + +let s:_PERSISTENT_NOTIFIERS = ['signs', 'balloons'] +lockvar! s:_PERSISTENT_NOTIFIERS + +" Public methods {{{1 + +function! g:SyntasticNotifiers.Instance() abort " {{{2 + if !exists('s:SyntasticNotifiersInstance') + let s:SyntasticNotifiersInstance = copy(self) + call s:SyntasticNotifiersInstance._initNotifiers() + endif + + return s:SyntasticNotifiersInstance +endfunction " }}}2 + +function! g:SyntasticNotifiers.refresh(loclist) abort " {{{2 + if !a:loclist.isEmpty() && !a:loclist.isNewerThan([]) + " loclist not fully constructed yet + return + endif + + call syntastic#log#debug(g:_SYNTASTIC_DEBUG_NOTIFICATIONS, 'notifiers: refresh') + for type in self._enabled_types + let class = substitute(type, '\m.*', 'Syntastic\u&Notifier', '') + if !has_key(g:{class}, 'enabled') || self._notifier[type].enabled() + if index(s:_PERSISTENT_NOTIFIERS, type) > -1 + " refresh only if loclist has changed since last call + if !exists('b:syntastic_private_' . type . '_stamp') + let b:syntastic_private_{type}_stamp = [] + endif + if a:loclist.isNewerThan(b:syntastic_private_{type}_stamp) || a:loclist.isEmpty() + call self._notifier[type].refresh(a:loclist) + let b:syntastic_private_{type}_stamp = syntastic#util#stamp() + endif + else + call self._notifier[type].refresh(a:loclist) + endif + endif + endfor +endfunction " }}}2 + +function! g:SyntasticNotifiers.reset(loclist) abort " {{{2 + call syntastic#log#debug(g:_SYNTASTIC_DEBUG_NOTIFICATIONS, 'notifiers: reset') + for type in self._enabled_types + let class = substitute(type, '\m.*', 'Syntastic\u&Notifier', '') + + " reset notifiers regardless if they are enabled or not, since + " the user might have disabled them since the last refresh(); + " notifiers MUST be prepared to deal with reset() when disabled + if has_key(g:{class}, 'reset') + call self._notifier[type].reset(a:loclist) + endif + + " also reset stamps + if index(s:_PERSISTENT_NOTIFIERS, type) > -1 + let b:syntastic_private_{type}_stamp = [] + endif + endfor +endfunction " }}}2 + +" }}}1 + +" Private methods {{{1 + +function! g:SyntasticNotifiers._initNotifiers() abort " {{{2 + let self._notifier = {} + for type in s:_NOTIFIER_TYPES + let class = substitute(type, '\m.*', 'Syntastic\u&Notifier', '') + let self._notifier[type] = g:{class}.New() + endfor + + let self._enabled_types = copy(s:_NOTIFIER_TYPES) +endfunction " }}}2 + +" }}}1 + +" vim: set sw=4 sts=4 et fdm=marker: diff --git a/vim/bundle/syntastic/plugin/syntastic/registry.vim b/vim/bundle/syntastic/plugin/syntastic/registry.vim new file mode 100644 index 0000000..0c2d261 --- /dev/null +++ b/vim/bundle/syntastic/plugin/syntastic/registry.vim @@ -0,0 +1,375 @@ +if exists('g:loaded_syntastic_registry') || !exists('g:loaded_syntastic_plugin') + finish +endif +let g:loaded_syntastic_registry = 1 + +" Initialisation {{{1 + +let s:_DEFAULT_CHECKERS = { + \ 'actionscript': ['mxmlc'], + \ 'ada': ['gcc'], + \ 'ansible': ['ansible_lint'], + \ 'apiblueprint': ['drafter'], + \ 'applescript': ['osacompile'], + \ 'asciidoc': ['asciidoc'], + \ 'asm': ['gcc'], + \ 'bro': ['bro'], + \ 'bemhtml': ['bemhtmllint'], + \ 'c': ['gcc'], + \ 'cabal': ['cabal'], + \ 'chef': ['foodcritic'], + \ 'co': ['coco'], + \ 'cobol': ['cobc'], + \ 'coffee': ['coffee', 'coffeelint'], + \ 'coq': ['coqtop'], + \ 'cpp': ['gcc'], + \ 'cs': ['mcs'], + \ 'css': ['csslint'], + \ 'cucumber': ['cucumber'], + \ 'cuda': ['nvcc'], + \ 'd': ['dmd'], + \ 'dart': ['dartanalyzer'], + \ 'docbk': ['xmllint'], + \ 'dockerfile': ['dockerfile_lint'], + \ 'dustjs': ['swiffer'], + \ 'elixir': [], + \ 'erlang': ['escript'], + \ 'eruby': ['ruby'], + \ 'fortran': ['gfortran'], + \ 'glsl': ['cgc'], + \ 'go': [], + \ 'haml': ['haml'], + \ 'handlebars': ['handlebars'], + \ 'haskell': ['hdevtools', 'hlint'], + \ 'haxe': ['haxe'], + \ 'hss': ['hss'], + \ 'html': ['tidy'], + \ 'jade': ['jade_lint'], + \ 'java': ['javac'], + \ 'javascript': ['jshint', 'jslint'], + \ 'json': ['jsonlint', 'jsonval'], + \ 'less': ['lessc'], + \ 'lex': ['flex'], + \ 'limbo': ['limbo'], + \ 'lisp': ['clisp'], + \ 'llvm': ['llvm'], + \ 'lua': ['luac'], + \ 'markdown': ['mdl'], + \ 'matlab': ['mlint'], + \ 'mercury': ['mmc'], + \ 'nasm': ['nasm'], + \ 'nix': ['nix'], + \ 'nroff': ['mandoc'], + \ 'objc': ['gcc'], + \ 'objcpp': ['gcc'], + \ 'ocaml': ['camlp4o'], + \ 'perl': ['perlcritic'], + \ 'php': ['php', 'phpcs', 'phpmd'], + \ 'po': ['msgfmt'], + \ 'pod': ['podchecker'], + \ 'puppet': ['puppet', 'puppetlint'], + \ 'pug': ['pug_lint'], + \ 'python': ['python', 'flake8', 'pylint'], + \ 'qml': ['qmllint'], + \ 'r': [], + \ 'rmd': [], + \ 'racket': ['racket'], + \ 'rnc': ['rnv'], + \ 'rst': ['rst2pseudoxml'], + \ 'ruby': ['mri'], + \ 'sass': ['sass'], + \ 'scala': ['fsc', 'scalac'], + \ 'scss': ['sass', 'scss_lint'], + \ 'sh': ['sh', 'shellcheck'], + \ 'slim': ['slimrb'], + \ 'sml': ['smlnj'], + \ 'spec': ['rpmlint'], + \ 'sql': ['sqlint'], + \ 'stylus': ['stylint'], + \ 'tcl': ['nagelfar'], + \ 'tex': ['lacheck', 'chktex'], + \ 'texinfo': ['makeinfo'], + \ 'text': [], + \ 'trig': ['rapper'], + \ 'turtle': ['rapper'], + \ 'twig': ['twiglint'], + \ 'typescript': ['tsc'], + \ 'vala': ['valac'], + \ 'verilog': ['verilator'], + \ 'vhdl': ['ghdl'], + \ 'vim': ['vimlint'], + \ 'xhtml': ['tidy'], + \ 'xml': ['xmllint'], + \ 'xslt': ['xmllint'], + \ 'xquery': ['basex'], + \ 'yacc': ['bison'], + \ 'yaml': ['jsyaml'], + \ 'yang': ['pyang'], + \ 'z80': ['z80syntaxchecker'], + \ 'zpt': ['zptlint'], + \ 'zsh': ['zsh'], + \ } +lockvar! s:_DEFAULT_CHECKERS + +let s:_DEFAULT_FILETYPE_MAP = { + \ 'gentoo-metadata': 'xml', + \ 'groff': 'nroff', + \ 'lhaskell': 'haskell', + \ 'litcoffee': 'coffee', + \ 'mail': 'text', + \ 'mkd': 'markdown', + \ 'pe-puppet': 'puppet', + \ 'sgml': 'docbk', + \ 'sgmllnx': 'docbk', + \ } +lockvar! s:_DEFAULT_FILETYPE_MAP + +let s:_ECLIM_TYPES = [ + \ 'c', + \ 'cpp', + \ 'html', + \ 'java', + \ 'php', + \ 'python', + \ 'ruby', + \ ] +lockvar! s:_ECLIM_TYPES + +let s:_YCM_TYPES = [ + \ 'c', + \ 'cpp', + \ 'objc', + \ 'objcpp', + \ ] +lockvar! s:_YCM_TYPES + +let g:SyntasticRegistry = {} + +" }}}1 + +" Public methods {{{1 + +" Note: Handling of filetype aliases: all public methods take aliases as +" parameters, all private methods take normalized filetypes. Public methods +" are thus supposed to normalize filetypes before calling private methods. + +function! g:SyntasticRegistry.Instance() abort " {{{2 + if !exists('s:SyntasticRegistryInstance') + let s:SyntasticRegistryInstance = copy(self) + let s:SyntasticRegistryInstance._checkerMap = {} + endif + + return s:SyntasticRegistryInstance +endfunction " }}}2 + +function! g:SyntasticRegistry.CreateAndRegisterChecker(args) abort " {{{2 + let registry = g:SyntasticRegistry.Instance() + + if has_key(a:args, 'redirect') + let [ft, name] = split(a:args['redirect'], '/') + call registry._loadCheckersFor(ft, 1) + + let clone = get(registry._checkerMap[ft], name, {}) + if empty(clone) + throw 'Syntastic: Checker ' . a:args['redirect'] . ' redirects to unregistered checker ' . ft . '/' . name + endif + + let checker = g:SyntasticChecker.New(a:args, clone) + else + let checker = g:SyntasticChecker.New(a:args) + endif + call registry._registerChecker(checker) +endfunction " }}}2 + +" Given a list of checker names hints_list, return a map name --> checker. +" If hints_list is empty, user settings are are used instead. Checkers are +" not checked for availability (that is, the corresponding IsAvailable() are +" not run). +function! g:SyntasticRegistry.getCheckers(ftalias, hints_list) abort " {{{2 + let ft = s:_normalise_filetype(a:ftalias) + call self._loadCheckersFor(ft, 0) + + let checkers_map = self._checkerMap[ft] + if empty(checkers_map) + return [] + endif + + call self._checkDeprecation(ft) + + let names = + \ !empty(a:hints_list) ? syntastic#util#unique(a:hints_list) : + \ exists('b:syntastic_checkers') ? b:syntastic_checkers : + \ exists('g:syntastic_' . ft . '_checkers') ? g:syntastic_{ft}_checkers : + \ get(s:_DEFAULT_CHECKERS, ft, 0) + + return type(names) == type([]) ? + \ self._filterCheckersByName(checkers_map, names) : [checkers_map[keys(checkers_map)[0]]] +endfunction " }}}2 + +" Same as getCheckers(), but keep only the available checkers. This runs the +" corresponding IsAvailable() functions for all checkers. +function! g:SyntasticRegistry.getCheckersAvailable(ftalias, hints_list) abort " {{{2 + return filter(self.getCheckers(a:ftalias, a:hints_list), 'v:val.isAvailable()') +endfunction " }}}2 + +" Same as getCheckers(), but keep only the checkers that are available and +" disabled. This runs the corresponding IsAvailable() functions for all checkers. +function! g:SyntasticRegistry.getCheckersDisabled(ftalias, hints_list) abort " {{{2 + return filter(self.getCheckers(a:ftalias, a:hints_list), 'v:val.isDisabled() && v:val.isAvailable()') +endfunction " }}}2 + +function! g:SyntasticRegistry.getKnownFiletypes() abort " {{{2 + let types = keys(s:_DEFAULT_CHECKERS) + + call extend(types, keys(s:_DEFAULT_FILETYPE_MAP)) + + if exists('g:syntastic_filetype_map') + call extend(types, keys(g:syntastic_filetype_map)) + endif + + if exists('g:syntastic_extra_filetypes') && type(g:syntastic_extra_filetypes) == type([]) + call extend(types, g:syntastic_extra_filetypes) + endif + + return syntastic#util#unique(types) +endfunction " }}}2 + +function! g:SyntasticRegistry.getNamesOfAvailableCheckers(ftalias) abort " {{{2 + let ft = s:_normalise_filetype(a:ftalias) + call self._loadCheckersFor(ft, 0) + return keys(filter( copy(self._checkerMap[ft]), 'v:val.isAvailable()' )) +endfunction " }}}2 + +function! g:SyntasticRegistry.echoInfoFor(ftalias_list) abort " {{{2 + let ft_list = syntastic#util#unique(map( copy(a:ftalias_list), 's:_normalise_filetype(v:val)' )) + if len(ft_list) != 1 + let available = [] + let active = [] + let disabled = [] + + for ft in ft_list + call extend(available, map( self.getNamesOfAvailableCheckers(ft), 'ft . "/" . v:val' )) + call extend(active, map( self.getCheckersAvailable(ft, []), 'ft . "/" . v:val.getName()' )) + call extend(disabled, map( self.getCheckersDisabled(ft, []), 'ft . "/" . v:val.getName()' )) + endfor + else + let ft = ft_list[0] + let available = self.getNamesOfAvailableCheckers(ft) + let active = map(self.getCheckersAvailable(ft, []), 'v:val.getName()') + let disabled = map(self.getCheckersDisabled(ft, []), 'v:val.getName()') + endif + + let cnt = len(available) + let plural = cnt != 1 ? 's' : '' + let cklist = cnt ? join(sort(available)) : '-' + echomsg 'Available checker' . plural . ': ' . cklist + + let cnt = len(active) + let plural = cnt != 1 ? 's' : '' + let cklist = cnt ? join(active) : '-' + echomsg 'Currently enabled checker' . plural . ': ' . cklist + + let cnt = len(disabled) + let plural = cnt != 1 ? 's' : '' + if len(disabled) + let cklist = join(sort(disabled)) + echomsg 'Checker' . plural . ' disabled for security reasons: ' . cklist + endif + + " Eclim feels entitled to mess with syntastic's variables {{{3 + if exists(':EclimValidate') && get(g:, 'EclimFileTypeValidate', 1) + let disabled = filter(copy(ft_list), 's:_disabled_by_eclim(v:val)') + let cnt = len(disabled) + if cnt + let plural = cnt != 1 ? 's' : '' + let cklist = join(disabled, ', ') + echomsg 'Checkers for filetype' . plural . ' ' . cklist . ' possibly disabled by Eclim' + endif + endif + " }}}3 + + " So does YouCompleteMe {{{3 + if exists('g:loaded_youcompleteme') && get(g:, 'ycm_show_diagnostics_ui', get(g:, 'ycm_register_as_syntastic_checker', 1)) + let disabled = filter(copy(ft_list), 's:_disabled_by_ycm(v:val)') + let cnt = len(disabled) + if cnt + let plural = cnt != 1 ? 's' : '' + let cklist = join(disabled, ', ') + echomsg 'Checkers for filetype' . plural . ' ' . cklist . ' possibly disabled by YouCompleteMe' + endif + endif + " }}}3 +endfunction " }}}2 + +" }}}1 + +" Private methods {{{1 + +function! g:SyntasticRegistry._registerChecker(checker) abort " {{{2 + let ft = a:checker.getFiletype() + if !has_key(self._checkerMap, ft) + let self._checkerMap[ft] = {} + endif + + let name = a:checker.getName() + if has_key(self._checkerMap[ft], name) + throw 'Syntastic: Duplicate syntax checker name: ' . ft . '/' . name + endif + + let self._checkerMap[ft][name] = a:checker +endfunction " }}}2 + +function! g:SyntasticRegistry._filterCheckersByName(checkers_map, list) abort " {{{2 + return filter( map(copy(a:list), 'get(a:checkers_map, v:val, {})'), '!empty(v:val)' ) +endfunction " }}}2 + +function! g:SyntasticRegistry._loadCheckersFor(filetype, force) abort " {{{2 + if !a:force && has_key(self._checkerMap, a:filetype) + return + endif + + execute 'runtime! syntax_checkers/' . a:filetype . '/*.vim' + + if !has_key(self._checkerMap, a:filetype) + let self._checkerMap[a:filetype] = {} + endif +endfunction " }}}2 + +" Check for obsolete variable g:syntastic_<filetype>_checker +function! g:SyntasticRegistry._checkDeprecation(filetype) abort " {{{2 + if exists('g:syntastic_' . a:filetype . '_checker') && !exists('g:syntastic_' . a:filetype . '_checkers') + let g:syntastic_{a:filetype}_checkers = [g:syntastic_{a:filetype}_checker] + call syntastic#log#oneTimeWarn('variable g:syntastic_' . a:filetype . '_checker is deprecated') + endif +endfunction " }}}2 + +" }}}1 + +" Utilities {{{1 + +"resolve filetype aliases, and replace - with _ otherwise we cant name +"syntax checker functions legally for filetypes like "gentoo-metadata" +function! s:_normalise_filetype(ftalias) abort " {{{2 + let ft = get(s:_DEFAULT_FILETYPE_MAP, a:ftalias, a:ftalias) + let ft = get(g:syntastic_filetype_map, ft, ft) + let ft = substitute(ft, '\m-', '_', 'g') + return ft +endfunction " }}}2 + +function! s:_disabled_by_eclim(filetype) abort " {{{2 + if index(s:_ECLIM_TYPES, a:filetype) >= 0 + let lang = toupper(a:filetype[0]) . a:filetype[1:] + let ft = a:filetype !=# 'cpp' ? lang : 'C' + return get(g:, 'Eclim' . lang . 'Validate', 1) && !get(g:, 'Eclim' . ft . 'SyntasticEnabled', 0) + endif + + return 0 +endfunction " }}}2 + +function! s:_disabled_by_ycm(filetype) abort " {{{2 + return index(s:_YCM_TYPES, a:filetype) >= 0 +endfunction " }}}2 + +" }}}1 + +" vim: set sw=4 sts=4 et fdm=marker: diff --git a/vim/bundle/syntastic/plugin/syntastic/signs.vim b/vim/bundle/syntastic/plugin/syntastic/signs.vim new file mode 100644 index 0000000..e3bafa0 --- /dev/null +++ b/vim/bundle/syntastic/plugin/syntastic/signs.vim @@ -0,0 +1,138 @@ +if exists('g:loaded_syntastic_notifier_signs') || !exists('g:loaded_syntastic_plugin') + finish +endif +let g:loaded_syntastic_notifier_signs = 1 + +" Initialisation {{{1 + +" start counting sign ids at 5000, start here to hopefully avoid conflicting +" with any other code that places signs (not sure if this precaution is +" actually needed) +let s:first_sign_id = 5000 +let s:next_sign_id = s:first_sign_id + +let g:SyntasticSignsNotifier = {} + +let s:setup_done = 0 + +" }}}1 + +" Public methods {{{1 + +function! g:SyntasticSignsNotifier.New() abort " {{{2 + let newObj = copy(self) + return newObj +endfunction " }}}2 + +function! g:SyntasticSignsNotifier.enabled() abort " {{{2 + return has('signs') && syntastic#util#var('enable_signs') +endfunction " }}}2 + +function! g:SyntasticSignsNotifier.refresh(loclist) abort " {{{2 + call syntastic#log#debug(g:_SYNTASTIC_DEBUG_NOTIFICATIONS, 'signs: refresh') + + let old_signs = copy(self._bufSignIds()) + if self.enabled() + if !s:setup_done + call self._setup() + let s:setup_done = 1 + lockvar s:setup_done + endif + + call self._signErrors(a:loclist) + endif + call self._removeSigns(old_signs) +endfunction " }}}2 + +" }}}1 + +" Private methods {{{1 + +" One time setup: define our own sign types and highlighting +function! g:SyntasticSignsNotifier._setup() abort " {{{2 + if has('signs') + if !hlexists('SyntasticErrorSign') + highlight link SyntasticErrorSign error + endif + if !hlexists('SyntasticWarningSign') + highlight link SyntasticWarningSign todo + endif + if !hlexists('SyntasticStyleErrorSign') + highlight link SyntasticStyleErrorSign SyntasticErrorSign + endif + if !hlexists('SyntasticStyleWarningSign') + highlight link SyntasticStyleWarningSign SyntasticWarningSign + endif + if !hlexists('SyntasticStyleErrorLine') + highlight link SyntasticStyleErrorLine SyntasticErrorLine + endif + if !hlexists('SyntasticStyleWarningLine') + highlight link SyntasticStyleWarningLine SyntasticWarningLine + endif + + " define the signs used to display syntax and style errors/warns + execute 'sign define SyntasticError text=' . g:syntastic_error_symbol . + \ ' texthl=SyntasticErrorSign linehl=SyntasticErrorLine' + execute 'sign define SyntasticWarning text=' . g:syntastic_warning_symbol . + \ ' texthl=SyntasticWarningSign linehl=SyntasticWarningLine' + execute 'sign define SyntasticStyleError text=' . g:syntastic_style_error_symbol . + \ ' texthl=SyntasticStyleErrorSign linehl=SyntasticStyleErrorLine' + execute 'sign define SyntasticStyleWarning text=' . g:syntastic_style_warning_symbol . + \ ' texthl=SyntasticStyleWarningSign linehl=SyntasticStyleWarningLine' + endif +endfunction " }}}2 + +" Place signs by all syntax errors in the buffer +function! g:SyntasticSignsNotifier._signErrors(loclist) abort " {{{2 + let loclist = a:loclist + if !loclist.isEmpty() + + let buf = bufnr('') + if !bufloaded(buf) + " signs can be placed only in loaded buffers + return + endif + + " errors come first, so that they are not masked by warnings + let issues = copy(loclist.errors()) + call extend(issues, loclist.warnings()) + call filter(issues, 'v:val["bufnr"] == buf') + let seen = {} + + for i in issues + if i['lnum'] > 0 && !has_key(seen, i['lnum']) + let seen[i['lnum']] = 1 + + let sign_severity = i['type'] ==? 'W' ? 'Warning' : 'Error' + let sign_subtype = get(i, 'subtype', '') + let sign_type = 'Syntastic' . sign_subtype . sign_severity + + execute 'sign place ' . s:next_sign_id . ' line=' . i['lnum'] . ' name=' . sign_type . ' buffer=' . i['bufnr'] + call add(self._bufSignIds(), s:next_sign_id) + let s:next_sign_id += 1 + endif + endfor + endif +endfunction " }}}2 + +" Remove the signs with the given ids from this buffer +function! g:SyntasticSignsNotifier._removeSigns(ids) abort " {{{2 + if has('signs') + for s in reverse(copy(a:ids)) + execute 'sign unplace ' . s + call remove(self._bufSignIds(), index(self._bufSignIds(), s)) + endfor + endif +endfunction " }}}2 + +" Get all the ids of the SyntaxError signs in the buffer +function! g:SyntasticSignsNotifier._bufSignIds() abort " {{{2 + if !exists('b:syntastic_private_sign_ids') + let b:syntastic_private_sign_ids = [] + endif + return b:syntastic_private_sign_ids +endfunction " }}}2 + +" }}}1 + +" vim: set sw=4 sts=4 et fdm=marker: diff --git a/vim/bundle/syntastic/syntax_checkers/actionscript/mxmlc.vim b/vim/bundle/syntastic/syntax_checkers/actionscript/mxmlc.vim new file mode 100644 index 0000000..1066769 --- /dev/null +++ b/vim/bundle/syntastic/syntax_checkers/actionscript/mxmlc.vim @@ -0,0 +1,67 @@ +"============================================================================ +"File: mxmlc.vim +"Description: ActionScript syntax checker - using mxmlc +"Maintainer: Andy Earnshaw <andyearnshaw@gmail.com> +"License: This program is free software. It comes without any warranty, +" to the extent permitted by applicable law. You can redistribute +" it and/or modify it under the terms of the Do What The Fuck You +" Want To Public License, Version 2, as published by Sam Hocevar. +" See http://sam.zoy.org/wtfpl/COPYING for more details. +"============================================================================ + +if exists('g:loaded_syntastic_actionscript_mxmlc_checker') + finish +endif +let g:loaded_syntastic_actionscript_mxmlc_checker = 1 + +let s:save_cpo = &cpo +set cpo&vim + +function! SyntaxCheckers_actionscript_mxmlc_GetHighlightRegex(item) + let term = '' + + if match(a:item['text'], '\mvariable ''') > -1 + let term = matchstr(a:item['text'], '\m''\zs[^'']\+\ze''') + + elseif match(a:item['text'], 'expected a definition keyword') > -1 + let term = matchstr(a:item['text'], '\mnot \zs[^.]\+\ze\.') + + elseif match(a:item['text'], '\mundefined \%(property\|method\)') > -1 + let term = matchstr(a:item['text'], '\mundefined \%(property\|method\) \zs[^. ]\+\ze') + + elseif match(a:item['text'], 'could not be found') > -1 + let term = matchstr(a:item['text'], '\m \zs\S\+\ze could not be found') + + elseif match(a:item['text'], 'Type was not found') > -1 + let term = matchstr(a:item['text'], '\m: \zs[^.]\+\zs\.') + + endif + + return term !=# '' ? '\V\<' . escape(term, '\') . '\>' : '' +endfunction + +function! SyntaxCheckers_actionscript_mxmlc_GetLocList() dict + call syntastic#log#deprecationWarn('actionscript_mxmlc_conf', 'actionscript_mxmlc_args', + \ "'-load-config+=' . syntastic#util#shexpand(OLD_VAR)") + + let makeprg = self.makeprgBuild({ 'args_after': '-output=' . syntastic#util#DevNull() }) + + let errorformat = + \ '%f(%l): col: %c %trror: %m,' . + \ '%f(%l): col: %c %tarning: %m,' . + \ '%f: %trror: %m,' . + \ '%-G%.%#' + + return SyntasticMake({ + \ 'makeprg': makeprg, + \ 'errorformat': errorformat }) +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'actionscript', + \ 'name': 'mxmlc'}) + +let &cpo = s:save_cpo +unlet s:save_cpo + +" vim: set sw=4 sts=4 et fdm=marker: diff --git a/vim/bundle/syntastic/syntax_checkers/ada/gcc.vim b/vim/bundle/syntastic/syntax_checkers/ada/gcc.vim new file mode 100644 index 0000000..6072ae4 --- /dev/null +++ b/vim/bundle/syntastic/syntax_checkers/ada/gcc.vim @@ -0,0 +1,47 @@ +"============================================================================ +"File: ada.vim +"Description: Syntax checking plugin for syntastic.vim +"Maintainer: Alfredo Di Napoli <alfredo.dinapoli@gmail.com> +"License: This program is free software. It comes without any warranty, +" to the extent permitted by applicable law. +" +"============================================================================ + +if exists('g:loaded_syntastic_ada_gcc_checker') + finish +endif +let g:loaded_syntastic_ada_gcc_checker = 1 + +if !exists('g:syntastic_ada_compiler_options') + let g:syntastic_ada_compiler_options = '' +endif + +let s:save_cpo = &cpo +set cpo&vim + +function! SyntaxCheckers_ada_gcc_IsAvailable() dict + if !exists('g:syntastic_ada_compiler') + let g:syntastic_ada_compiler = self.getExec() + endif + return executable(expand(g:syntastic_ada_compiler, 1)) +endfunction + +function! SyntaxCheckers_ada_gcc_GetLocList() dict + return syntastic#c#GetLocList('ada', 'gcc', { + \ 'errorformat': + \ '%-G%f:%s:,' . + \ '%f:%l:%c: %m,' . + \ '%f:%l: %m', + \ 'main_flags': '-c -x ada -gnats -gnatef', + \ 'header_flags': '-x ada -gnats -gnatef', + \ 'header_names': '\.ads$' }) +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'ada', + \ 'name': 'gcc' }) + +let &cpo = s:save_cpo +unlet s:save_cpo + +" vim: set sw=4 sts=4 et fdm=marker: diff --git a/vim/bundle/syntastic/syntax_checkers/ansible/ansible_lint.vim b/vim/bundle/syntastic/syntax_checkers/ansible/ansible_lint.vim new file mode 100644 index 0000000..fe62581 --- /dev/null +++ b/vim/bundle/syntastic/syntax_checkers/ansible/ansible_lint.vim @@ -0,0 +1,54 @@ +"============================================================================ +"File: ansible_lint.vim +"Description: Syntax checking plugin for syntastic.vim +"Maintainer: Erik Zaadi <erik.zaadi at gmail dot com> +"License: This program is free software. It comes without any warranty, +" to the extent permitted by applicable law. You can redistribute +" it and/or modify it under the terms of the Do What The Fuck You +" Want To Public License, Version 2, as published by Sam Hocevar. +" See http://sam.zoy.org/wtfpl/COPYING for more details. +" +"============================================================================ + +if exists('g:loaded_syntastic_ansible_ansible_lint_checker') + finish +endif +let g:loaded_syntastic_ansible_ansible_lint_checker = 1 + +let s:save_cpo = &cpo +set cpo&vim + +function! SyntaxCheckers_ansible_ansible_lint_IsAvailable() dict + if !executable(self.getExec()) + return 0 + endif + return syntastic#util#versionIsAtLeast(self.getVersion(), [2, 0, 4]) +endfunction + +function! SyntaxCheckers_ansible_ansible_lint_GetLocList() dict + let makeprg = self.makeprgBuild({ 'args_after': '-p' }) + + let errorformat = + \ '%f:%l: [EANSIBLE%n] %m,' . + \ '%f:%l: [ANSIBLE%n] %m' + + let env = syntastic#util#isRunningWindows() ? {} : { 'TERM': 'dumb' } + + return SyntasticMake({ + \ 'makeprg': makeprg, + \ 'errorformat': errorformat, + \ 'env': env, + \ 'defaults': {'type': 'E'}, + \ 'subtype': 'Style', + \ 'returns': [0, 2] }) +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'ansible', + \ 'name': 'ansible_lint', + \ 'exec': 'ansible-lint'}) + +let &cpo = s:save_cpo +unlet s:save_cpo + +" vim: set sw=4 sts=4 et fdm=marker: diff --git a/vim/bundle/syntastic/syntax_checkers/apiblueprint/drafter.vim b/vim/bundle/syntastic/syntax_checkers/apiblueprint/drafter.vim new file mode 100644 index 0000000..e404a4f --- /dev/null +++ b/vim/bundle/syntastic/syntax_checkers/apiblueprint/drafter.vim @@ -0,0 +1,66 @@ +"============================================================================ +"File: drafter.vim +"Description: Syntax checking plugin for syntastic.vim +"Maintainer: LCD 47 <lcd047 at gmail dot com> +"License: This program is free software. It comes without any warranty, +" to the extent permitted by applicable law. You can redistribute +" it and/or modify it under the terms of the Do What The Fuck You +" Want To Public License, Version 2, as published by Sam Hocevar. +" See http://sam.zoy.org/wtfpl/COPYING for more details. +" +"============================================================================ + +if exists('g:loaded_syntastic_apiblueprint_drafter_checker') + finish +endif +let g:loaded_syntastic_apiblueprint_drafter_checker = 1 + +if !exists('g:syntastic_apiblueprint_drafter_sort') + let g:syntastic_apiblueprint_drafter_sort = 1 +endif + +let s:save_cpo = &cpo +set cpo&vim + +function! SyntaxCheckers_apiblueprint_drafter_GetLocList() dict + let makeprg = self.makeprgBuild({ 'post_args': '-u -l' }) + + let errorformat = + \ '%trror: (%n) %m,' . + \ '%tarning: (%n) %m,' . + \ '%-G%.%#' + + let loclist = SyntasticMake({ + \ 'makeprg': makeprg, + \ 'errorformat': errorformat, + \ 'defaults': {'bufnr': bufnr('')}, + \ 'returns': [0, 2, 3, 4] }) + + for e in loclist + let matches = matchlist(e['text'], '\v^(.+); line (\d+), column (\d+) - line (\d+), column (\d+)$') + if len(matches) > 5 + let e['lnum'] = str2nr(matches[2]) + let e['col'] = str2nr(matches[3]) + let e['vcol'] = 0 + + if matches[2] == matches[4] + let e['hl'] = '\%>' . (e['col'] - 1) . 'c\%<' . matches[5] . 'c' + endif + + let e['text'] = matches[1] + else + let e['valid'] = 0 + endif + endfor + + return loclist +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'apiblueprint', + \ 'name': 'drafter'}) + +let &cpo = s:save_cpo +unlet s:save_cpo + +" vim: set sw=4 sts=4 et fdm=marker: diff --git a/vim/bundle/syntastic/syntax_checkers/applescript/osacompile.vim b/vim/bundle/syntastic/syntax_checkers/applescript/osacompile.vim new file mode 100644 index 0000000..406e029 --- /dev/null +++ b/vim/bundle/syntastic/syntax_checkers/applescript/osacompile.vim @@ -0,0 +1,49 @@ +"============================================================================== +" FileName: applescript.vim +" Desc: Syntax checking plugin for syntastic.vim +" Author: Zhao Cai +" Email: caizhaoff@gmail.com +" Version: 0.2.1 +" Date Created: Thu 09 Sep 2011 10:30:09 AM EST +" Last Modified: Fri 09 Dec 2011 01:10:24 PM EST +" +" History: 0.1.0 - working, but it will run the script everytime to check +" syntax. Should use osacompile but strangely it does not give +" errors. +" +" 0.2.0 - switch to osacompile, it gives less errors compared +" with osascript. +" +" 0.2.1 - remove g:syntastic_applescript_tempfile. use +" tempname() instead. +" +" License: This program is free software. It comes without any +" warranty, to the extent permitted by applicable law. You can +" redistribute it and/or modify it under the terms of the Do What The +" Fuck You Want To Public License, Version 2, as published by Sam +" Hocevar. See http://sam.zoy.org/wtfpl/COPYING for more details. +" +"============================================================================ + +if exists('g:loaded_syntastic_applescript_osacompile_checker') + finish +endif +let g:loaded_syntastic_applescript_osacompile_checker = 1 + +let s:save_cpo = &cpo +set cpo&vim + +function! SyntaxCheckers_applescript_osacompile_GetLocList() dict + let makeprg = self.makeprgBuild({ 'args_after': '-o ' . tempname() . '.scpt' }) + let errorformat = '%f:%l:%m' + return SyntasticMake({ 'makeprg': makeprg, 'errorformat': errorformat }) +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'applescript', + \ 'name': 'osacompile' }) + +let &cpo = s:save_cpo +unlet s:save_cpo + +" vim: set sw=4 sts=4 et fdm=marker: diff --git a/vim/bundle/syntastic/syntax_checkers/asciidoc/asciidoc.vim b/vim/bundle/syntastic/syntax_checkers/asciidoc/asciidoc.vim new file mode 100644 index 0000000..bc64e6a --- /dev/null +++ b/vim/bundle/syntastic/syntax_checkers/asciidoc/asciidoc.vim @@ -0,0 +1,47 @@ +"============================================================================ +"File: asciidoc.vim +"Description: Syntax checking plugin for syntastic.vim +"Maintainer: LCD 47 <lcd047 at gmail dot com> +"License: This program is free software. It comes without any warranty, +" to the extent permitted by applicable law. You can redistribute +" it and/or modify it under the terms of the Do What The Fuck You +" Want To Public License, Version 2, as published by Sam Hocevar. +" See http://sam.zoy.org/wtfpl/COPYING for more details. +" +"============================================================================ + +if exists('g:loaded_syntastic_asciidoc_asciidoc_checker') + finish +endif +let g:loaded_syntastic_asciidoc_asciidoc_checker = 1 + +let s:save_cpo = &cpo +set cpo&vim + +function! SyntaxCheckers_asciidoc_asciidoc_GetLocList() dict + let makeprg = self.makeprgBuild({ 'args_after': syntastic#c#NullOutput() }) + + let errorformat = + \ '%E%\w%\+: %tRROR: %f: line %l: %m,' . + \ '%E%\w%\+: %tRROR: %f: %m,' . + \ '%E%\w%\+: FAILED: %f: line %l: %m,' . + \ '%E%\w%\+: FAILED: %f: %m,' . + \ '%W%\w%\+: %tARNING: %f: line %l: %m,' . + \ '%W%\w%\+: %tARNING: %f: %m,' . + \ '%W%\w%\+: DEPRECATED: %f: line %l: %m,' . + \ '%W%\w%\+: DEPRECATED: %f: %m' + + return SyntasticMake({ + \ 'makeprg': makeprg, + \ 'errorformat': errorformat, + \ 'returns': [0, 1] }) +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'asciidoc', + \ 'name': 'asciidoc'}) + +let &cpo = s:save_cpo +unlet s:save_cpo + +" vim: set sw=4 sts=4 et fdm=marker: diff --git a/vim/bundle/syntastic/syntax_checkers/asm/gcc.vim b/vim/bundle/syntastic/syntax_checkers/asm/gcc.vim new file mode 100644 index 0000000..d352eee --- /dev/null +++ b/vim/bundle/syntastic/syntax_checkers/asm/gcc.vim @@ -0,0 +1,61 @@ +"============================================================================ +"File: gcc.vim +"Description: Syntax checking for at&t and intel assembly files with gcc +"Maintainer: Josh Rahm <joshuarahm@gmail.com> +"License: This program is free software. It comes without any warranty, +" to the extent permitted by applicable law. You can redistribute +" it and/or modify it under the terms of the Do What The Fuck You +" Want To Public License, Version 2, as published by Sam Hocevar. +" See http://sam.zoy.org/wtfpl/COPYING for more details. +" +"============================================================================ + +if exists('g:loaded_syntastic_asm_gcc_checker') + finish +endif +let g:loaded_syntastic_asm_gcc_checker = 1 + +if !exists('g:syntastic_asm_compiler_options') + let g:syntastic_asm_compiler_options = '' +endif + +if !exists('g:syntastic_asm_generic') + let g:syntastic_asm_generic = 0 +endif + +let s:save_cpo = &cpo +set cpo&vim + +function! SyntaxCheckers_asm_gcc_IsAvailable() dict " {{{1 + if !exists('g:syntastic_asm_compiler') + let g:syntastic_asm_compiler = self.getExec() + endif + return executable(expand(g:syntastic_asm_compiler, 1)) +endfunction " }}}1 + +function! SyntaxCheckers_asm_gcc_GetLocList() dict " {{{1 + return syntastic#c#GetLocList('asm', 'gcc', { + \ 'errorformat': + \ '%-G%f:%s:,' . + \ '%f:%l:%c: %trror: %m,' . + \ '%f:%l:%c: %tarning: %m,' . + \ '%f:%l: %m', + \ 'main_flags': '-x assembler -fsyntax-only' . (g:syntastic_asm_generic ? '' : ' -masm=' . s:GetDialect()) }) +endfunction " }}}1 + +" Utilities {{{1 + +function! s:GetDialect() " {{{2 + return syntastic#util#var('asm_dialect', expand('%:e', 1) ==? 'asm' ? 'intel' : 'att') +endfunction " }}}2 + +" }}}1 + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'asm', + \ 'name': 'gcc' }) + +let &cpo = s:save_cpo +unlet s:save_cpo + +" vim: set sw=4 sts=4 et fdm=marker: diff --git a/vim/bundle/syntastic/syntax_checkers/bemhtml/bemhtmllint.vim b/vim/bundle/syntastic/syntax_checkers/bemhtml/bemhtmllint.vim new file mode 100644 index 0000000..1837067 --- /dev/null +++ b/vim/bundle/syntastic/syntax_checkers/bemhtml/bemhtmllint.vim @@ -0,0 +1,35 @@ +"============================================================================ +"File: bemhtmllint.vim +"Description: Syntax checking plugin for syntastic.vim +"Maintainer: Sergej Tatarincev <s.tatarincev at yandex.ua> +"License: This program is free software. It comes without any warranty, +" to the extent permitted by applicable law. You can redistribute +" it and/or modify it under the terms of the Do What The Fuck You +" Want To Public License, Version 2, as published by Sam Hocevar. +" See http://sam.zoy.org/wtfpl/COPYING for more details. +"============================================================================ + +if exists('g:loaded_syntastic_bemhtml_bemhtmllint_checker') + finish +endif + +let g:loaded_syntastic_bemhtml_bemhtmllint_checker = 1 + +let s:save_cpo = &cpo +set cpo&vim + +function SyntaxCheckers_bemhtml_bemhtmllint_GetLocList() dict + let makeprg = self.makeprgBuild({}) + let errorformat = '%f:%l:%c: %m' + return SyntasticMake({ 'makeprg': makeprg, 'errorformat': errorformat }) +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'bemhtml', + \ 'name': 'bemhtmllint', + \ 'exec': 'bemhtml-lint' }) + +let &cpo = s:save_cpo +unlet s:save_cpo + +" vim: set sw=4 sts=4 et fdm=marker: diff --git a/vim/bundle/syntastic/syntax_checkers/bro/bro.vim b/vim/bundle/syntastic/syntax_checkers/bro/bro.vim new file mode 100644 index 0000000..cea441b --- /dev/null +++ b/vim/bundle/syntastic/syntax_checkers/bro/bro.vim @@ -0,0 +1,58 @@ +"============================================================================ +"File: bro.vim +"Description: Syntax checking plugin for syntastic.vim +"Maintainer: Justin Azoff <justin.azoff@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_bro_bro_checker') + finish +endif +let g:loaded_syntastic_bro_bro_checker = 1 + +let s:save_cpo = &cpo +set cpo&vim + +function! SyntaxCheckers_bro_bro_GetHighlightRegex(item) + let term = matchstr(a:item['text'], '\m at or near "\zs[^"]\+\ze"') + return term !=# '' ? '\V\<' . escape(term, '\') . '\>' : '' +endfunction + +function! SyntaxCheckers_bro_bro_IsAvailable() dict + if !executable(self.getExec()) + return 0 + endif + + if syntastic#util#system(self.getExecEscaped() . ' --help') !~# '--parse-only' + call self.log('unknown option "--parse-only"') + return 0 + endif + + return 1 +endfunction + +function! SyntaxCheckers_bro_bro_GetLocList() dict + let makeprg = self.makeprgBuild({ 'args_before': '--parse-only' }) + + "example: error in ./foo.bro, line 3: unknown identifier banana, at or near "banana" + let errorformat = '%t:%f:%l:%m' + + return SyntasticMake({ + \ 'makeprg': makeprg, + \ 'errorformat': errorformat, + \ 'preprocess': 'bro' }) +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'bro', + \ 'name': 'bro'}) + +let &cpo = s:save_cpo +unlet s:save_cpo + +" vim: set sw=4 sts=4 et fdm=marker: diff --git a/vim/bundle/syntastic/syntax_checkers/c/avrgcc.vim b/vim/bundle/syntastic/syntax_checkers/c/avrgcc.vim new file mode 100644 index 0000000..0fbb984 --- /dev/null +++ b/vim/bundle/syntastic/syntax_checkers/c/avrgcc.vim @@ -0,0 +1,57 @@ +"============================================================================ +"File: avrgcc.vim +"Description: Syntax checking plugin for syntastic.vim +"Maintainer: Karel <karelishere at gmail dot com> +"License: This program is free software. It comes without any warranty, +" to the extent permitted by applicable law. You can redistribute +" it and/or modify it under the terms of the Do What The Fuck You +" Want To Public License, Version 2, as published by Sam Hocevar. +" See http://sam.zoy.org/wtfpl/COPYING for more details. +" +"============================================================================ + +if exists('g:loaded_syntastic_c_avrgcc_checker') + finish +endif +let g:loaded_syntastic_c_avrgcc_checker = 1 + +if !exists('g:syntastic_avrgcc_config_file') + let g:syntastic_avrgcc_config_file = '.syntastic_avrgcc_config' +endif + +let s:save_cpo = &cpo +set cpo&vim + +function! SyntaxCheckers_c_avrgcc_GetLocList() dict + let makeprg = self.makeprgBuild({ + \ 'args_before': syntastic#c#ReadConfig(g:syntastic_avrgcc_config_file), + \ 'args_after': '-x c -fsyntax-only' }) + + let errorformat = + \ '%-G%f:%s:,' . + \ '%-G%f:%l: %#error: %#(Each undeclared identifier is reported only%.%#,' . + \ '%-G%f:%l: %#error: %#for each function it appears%.%#,' . + \ '%-GIn file included%.%#,' . + \ '%-G %#from %f:%l\,,' . + \ '%f:%l:%c: %trror: %m,' . + \ '%f:%l:%c: %tarning: %m,' . + \ '%f:%l:%c: %m,' . + \ '%f:%l: %trror: %m,' . + \ '%f:%l: %tarning: %m,'. + \ '%f:%l: %m' + + return SyntasticMake({ + \ 'makeprg': makeprg, + \ 'errorformat': errorformat, + \ 'postprocess': ['compressWhitespace'] }) +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'c', + \ 'name': 'avrgcc', + \ 'exec': 'avr-gcc'}) + +let &cpo = s:save_cpo +unlet s:save_cpo + +" vim: set sw=4 sts=4 et fdm=marker: diff --git a/vim/bundle/syntastic/syntax_checkers/c/checkpatch.vim b/vim/bundle/syntastic/syntax_checkers/c/checkpatch.vim new file mode 100644 index 0000000..43b047c --- /dev/null +++ b/vim/bundle/syntastic/syntax_checkers/c/checkpatch.vim @@ -0,0 +1,60 @@ +"============================================================================ +"File: checkpatch.vim +"Description: Syntax checking plugin for syntastic.vim using checkpatch.pl +"Maintainer: Daniel Walker <dwalker at fifo99 dot com> +"License: This program is free software. It comes without any warranty, +" to the extent permitted by applicable law. You can redistribute +" it and/or modify it under the terms of the Do What The Fuck You +" Want To Public License, Version 2, as published by Sam Hocevar. +" See http://sam.zoy.org/wtfpl/COPYING for more details. +"============================================================================ + +if exists('g:loaded_syntastic_c_checkpatch_checker') + finish +endif +let g:loaded_syntastic_c_checkpatch_checker = 1 + +let s:save_cpo = &cpo +set cpo&vim + +function! SyntaxCheckers_c_checkpatch_IsAvailable() dict + call syntastic#log#deprecationWarn('c_checker_checkpatch_location', 'c_checkpatch_exec') + + if !exists('g:syntastic_c_checkpatch_exec') && !executable(self.getExec()) + if executable('checkpatch') + let g:syntastic_c_checkpatch_exec = 'checkpatch' + elseif executable('./scripts/checkpatch.pl') + let g:syntastic_c_checkpatch_exec = fnamemodify('./scripts/checkpatch.pl', ':p') + elseif executable('./scripts/checkpatch') + let g:syntastic_c_checkpatch_exec = fnamemodify('./scripts/checkpatch', ':p') + endif + endif + + call self.log('exec =', self.getExec()) + + return executable(self.getExec()) +endfunction + +function! SyntaxCheckers_c_checkpatch_GetLocList() dict + let makeprg = self.makeprgBuild({ 'args_after': '--no-summary --no-tree --terse --file' }) + + let errorformat = + \ '%f:%l: %tARNING: %m,' . + \ '%f:%l: %tRROR: %m' + + return SyntasticMake({ + \ 'makeprg': makeprg, + \ 'errorformat': errorformat, + \ 'returns': [0, 1], + \ 'subtype': 'Style' }) +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'c', + \ 'name': 'checkpatch', + \ 'exec': 'checkpatch.pl'}) + +let &cpo = s:save_cpo +unlet s:save_cpo + +" vim: set sw=4 sts=4 et fdm=marker: diff --git a/vim/bundle/syntastic/syntax_checkers/c/clang_check.vim b/vim/bundle/syntastic/syntax_checkers/c/clang_check.vim new file mode 100644 index 0000000..4c3677a --- /dev/null +++ b/vim/bundle/syntastic/syntax_checkers/c/clang_check.vim @@ -0,0 +1,64 @@ +"============================================================================ +"File: clang_check.vim +"Description: Syntax checking plugin for syntastic.vim +"Maintainer: Benjamin Bannier <bbannier at gmail dot com> +"License: This program is free software. It comes without any warranty, +" to the extent permitted by applicable law. You can redistribute +" it and/or modify it under the terms of the Do What The Fuck You +" Want To Public License, Version 2, as published by Sam Hocevar. +" See http://sam.zoy.org/wtfpl/COPYING for more details. +"============================================================================ + +if exists('g:loaded_syntastic_c_clang_check_checker') + finish +endif +let g:loaded_syntastic_c_clang_check_checker = 1 + +if !exists('g:syntastic_clang_check_config_file') + let g:syntastic_clang_check_config_file = '.syntastic_clang_check_config' +endif + +if !exists('g:syntastic_c_clang_check_sort') + let g:syntastic_c_clang_check_sort = 1 +endif + +let s:save_cpo = &cpo +set cpo&vim + +function! SyntaxCheckers_c_clang_check_GetLocList() dict + let makeprg = self.makeprgBuild({ + \ 'post_args': + \ '-- ' . + \ syntastic#c#ReadConfig(g:syntastic_clang_check_config_file) . ' ' . + \ '-fshow-column ' . + \ '-fshow-source-location ' . + \ '-fno-caret-diagnostics ' . + \ '-fno-color-diagnostics ' . + \ '-fdiagnostics-format=clang' }) + + let errorformat = + \ '%E%f:%l:%c: fatal error: %m,' . + \ '%E%f:%l:%c: error: %m,' . + \ '%W%f:%l:%c: warning: %m,' . + \ '%-G%\m%\%%(LLVM ERROR:%\|No compilation database found%\)%\@!%.%#,' . + \ '%E%m' + + let env = syntastic#util#isRunningWindows() ? {} : { 'TERM': 'dumb' } + + return SyntasticMake({ + \ 'makeprg': makeprg, + \ 'errorformat': errorformat, + \ 'env': env, + \ 'defaults': {'bufnr': bufnr('')}, + \ 'returns': [0, 1] }) +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'c', + \ 'name': 'clang_check', + \ 'exec': 'clang-check'}) + +let &cpo = s:save_cpo +unlet s:save_cpo + +" vim: set sw=4 sts=4 et fdm=marker: diff --git a/vim/bundle/syntastic/syntax_checkers/c/clang_tidy.vim b/vim/bundle/syntastic/syntax_checkers/c/clang_tidy.vim new file mode 100644 index 0000000..6d8cbfe --- /dev/null +++ b/vim/bundle/syntastic/syntax_checkers/c/clang_tidy.vim @@ -0,0 +1,64 @@ +"============================================================================ +"File: clang_tidy.vim +"Description: Syntax checking plugin for syntastic.vim +"Maintainer: Benjamin Bannier <bbannier at gmail dot com> +"License: This program is free software. It comes without any warranty, +" to the extent permitted by applicable law. You can redistribute +" it and/or modify it under the terms of the Do What The Fuck You +" Want To Public License, Version 2, as published by Sam Hocevar. +" See http://sam.zoy.org/wtfpl/COPYING for more details. +"============================================================================ + +if exists('g:loaded_syntastic_c_clang_tidy_checker') + finish +endif +let g:loaded_syntastic_c_clang_tidy_checker = 1 + +if !exists('g:syntastic_clang_tidy_config_file') + let g:syntastic_clang_tidy_config_file = '.syntastic_clang_tidy_config' +endif + +if !exists('g:syntastic_c_clang_tidy_sort') + let g:syntastic_c_clang_tidy_sort = 1 +endif + +let s:save_cpo = &cpo +set cpo&vim + +function! SyntaxCheckers_c_clang_tidy_GetLocList() dict + let makeprg = self.makeprgBuild({ + \ 'post_args': + \ '-- ' . + \ syntastic#c#ReadConfig(g:syntastic_clang_tidy_config_file) . ' ' . + \ '-fshow-column ' . + \ '-fshow-source-location ' . + \ '-fno-caret-diagnostics ' . + \ '-fno-color-diagnostics ' . + \ '-fdiagnostics-format=clang' }) + + let errorformat = + \ '%E%f:%l:%c: fatal error: %m,' . + \ '%E%f:%l:%c: error: %m,' . + \ '%W%f:%l:%c: warning: %m,' . + \ '%-G%\m%\%%(LLVM ERROR:%\|No compilation database found%\)%\@!%.%#,' . + \ '%E%m' + + let env = syntastic#util#isRunningWindows() ? {} : { 'TERM': 'dumb' } + + return SyntasticMake({ + \ 'makeprg': makeprg, + \ 'errorformat': errorformat, + \ 'env': env, + \ 'defaults': {'bufnr': bufnr('')}, + \ 'returns': [0, 1] }) +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'c', + \ 'name': 'clang_tidy', + \ 'exec': 'clang-tidy'}) + +let &cpo = s:save_cpo +unlet s:save_cpo + +" vim: set sw=4 sts=4 et fdm=marker: diff --git a/vim/bundle/syntastic/syntax_checkers/c/cppcheck.vim b/vim/bundle/syntastic/syntax_checkers/c/cppcheck.vim new file mode 100644 index 0000000..cd802a8 --- /dev/null +++ b/vim/bundle/syntastic/syntax_checkers/c/cppcheck.vim @@ -0,0 +1,62 @@ +"============================================================================ +"File: cppcheck.vim +"Description: Syntax checking plugin for syntastic.vim using cppcheck.pl +"Maintainer: LCD 47 <lcd047 at gmail dot com> +"License: This program is free software. It comes without any warranty, +" to the extent permitted by applicable law. You can redistribute +" it and/or modify it under the terms of the Do What The Fuck You +" Want To Public License, Version 2, as published by Sam Hocevar. +" See http://sam.zoy.org/wtfpl/COPYING for more details. +"============================================================================ + +if exists('g:loaded_syntastic_c_cppcheck_checker') + finish +endif +let g:loaded_syntastic_c_cppcheck_checker = 1 + +if !exists('g:syntastic_cppcheck_config_file') + let g:syntastic_cppcheck_config_file = '.syntastic_cppcheck_config' +endif + +let s:save_cpo = &cpo +set cpo&vim + +function! SyntaxCheckers_c_cppcheck_GetLocList() dict + let makeprg = self.makeprgBuild({ + \ 'args': syntastic#c#ReadConfig(g:syntastic_cppcheck_config_file), + \ 'args_after': '-q --enable=style' }) + + let errorformat = + \ '[%f:%l]: (%trror) %m,' . + \ '[%f:%l]: (%tarning) %m,' . + \ '[%f:%l]: (%ttyle) %m,' . + \ '[%f:%l]: (%terformance) %m,' . + \ '[%f:%l]: (%tortability) %m,' . + \ '[%f:%l]: (%tnformation) %m,' . + \ '[%f:%l]: (%tnconclusive) %m,' . + \ '%-G%.%#' + + let loclist = SyntasticMake({ + \ 'makeprg': makeprg, + \ 'errorformat': errorformat, + \ 'preprocess': 'cppcheck', + \ 'returns': [0] }) + + for e in loclist + if e['type'] =~? '\m^[SPI]' + let e['type'] = 'w' + let e['subtype'] = 'Style' + endif + endfor + + return loclist +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'c', + \ 'name': 'cppcheck'}) + +let &cpo = s:save_cpo +unlet s:save_cpo + +" vim: set sw=4 sts=4 et fdm=marker: diff --git a/vim/bundle/syntastic/syntax_checkers/c/gcc.vim b/vim/bundle/syntastic/syntax_checkers/c/gcc.vim new file mode 100644 index 0000000..4fa9216 --- /dev/null +++ b/vim/bundle/syntastic/syntax_checkers/c/gcc.vim @@ -0,0 +1,59 @@ +"============================================================================ +"File: c.vim +"Description: Syntax checking plugin for syntastic.vim +"Maintainer: Gregor Uhlenheuer <kongo2002 at gmail dot com> +"License: This program is free software. It comes without any warranty, +" to the extent permitted by applicable law. You can redistribute +" it and/or modify it under the terms of the Do What The Fuck You +" Want To Public License, Version 2, as published by Sam Hocevar. +" See http://sam.zoy.org/wtfpl/COPYING for more details. +" +"============================================================================ + +if exists('g:loaded_syntastic_c_gcc_checker') + finish +endif +let g:loaded_syntastic_c_gcc_checker = 1 + +if !exists('g:syntastic_c_compiler_options') + let g:syntastic_c_compiler_options = '-std=gnu99' +endif + +let s:save_cpo = &cpo +set cpo&vim + +function! SyntaxCheckers_c_gcc_IsAvailable() dict + if !exists('g:syntastic_c_compiler') + let g:syntastic_c_compiler = executable(self.getExec()) ? self.getExec() : 'clang' + endif + call self.log('g:syntastic_c_compiler =', g:syntastic_c_compiler) + return executable(expand(g:syntastic_c_compiler, 1)) +endfunction + +function! SyntaxCheckers_c_gcc_GetLocList() dict + return syntastic#c#GetLocList('c', 'gcc', { + \ 'errorformat': + \ '%-G%f:%s:,' . + \ '%-G%f:%l: %#error: %#(Each undeclared identifier is reported only%.%#,' . + \ '%-G%f:%l: %#error: %#for each function it appears%.%#,' . + \ '%-GIn file included%.%#,' . + \ '%-G %#from %f:%l\,,' . + \ '%f:%l:%c: %trror: %m,' . + \ '%f:%l:%c: %tarning: %m,' . + \ '%f:%l:%c: %m,' . + \ '%f:%l: %trror: %m,' . + \ '%f:%l: %tarning: %m,'. + \ '%f:%l: %m', + \ 'main_flags': '-x c -fsyntax-only', + \ 'header_flags': '-x c', + \ 'header_names': '\m\.h$' }) +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'c', + \ 'name': 'gcc' }) + +let &cpo = s:save_cpo +unlet s:save_cpo + +" vim: set sw=4 sts=4 et fdm=marker: diff --git a/vim/bundle/syntastic/syntax_checkers/c/make.vim b/vim/bundle/syntastic/syntax_checkers/c/make.vim new file mode 100644 index 0000000..e477994 --- /dev/null +++ b/vim/bundle/syntastic/syntax_checkers/c/make.vim @@ -0,0 +1,61 @@ +"============================================================================ +"File: make.vim +"Description: Syntax checking plugin for syntastic.vim +"Maintainer: Gregor Uhlenheuer <kongo2002 at gmail dot com> +"License: This program is free software. It comes without any warranty, +" to the extent permitted by applicable law. You can redistribute +" it and/or modify it under the terms of the Do What The Fuck You +" Want To Public License, Version 2, as published by Sam Hocevar. +" See http://sam.zoy.org/wtfpl/COPYING for more details. +" +"============================================================================ + +if exists('g:loaded_syntastic_c_make_checker') + finish +endif +let g:loaded_syntastic_c_make_checker = 1 + +let s:save_cpo = &cpo +set cpo&vim + +function! SyntaxCheckers_c_make_GetLocList() dict + let makeprg = self.makeprgBuild({ 'args': '-sk', 'fname': '' }) + + let errorformat = + \ '%-G%f:%s:,' . + \ '%-G%f:%l: %#error: %#(Each undeclared identifier is reported only%.%#,' . + \ '%-G%f:%l: %#error: %#for each function it appears%.%#,' . + \ '%-GIn file included%.%#,' . + \ '%-G %#from %f:%l\,,' . + \ '%f:%l:%c: %trror: %m,' . + \ '%f:%l:%c: %tarning: %m,' . + \ '%f:%l:%c: %m,' . + \ '%f:%l: %trror: %m,' . + \ '%f:%l: %tarning: %m,'. + \ '%f:%l: %m' + + if exists('g:syntastic_c_errorformat') + let errorformat = g:syntastic_c_errorformat + endif + + " process makeprg + let errors = SyntasticMake({ + \ 'makeprg': makeprg, + \ 'errorformat': errorformat }) + + " filter the processed errors if desired + if exists('g:syntastic_c_remove_include_errors') && g:syntastic_c_remove_include_errors != 0 + return filter(errors, 'has_key(v:val, "bufnr") && v:val["bufnr"] == ' . bufnr('')) + else + return errors + endif +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'c', + \ 'name': 'make'}) + +let &cpo = s:save_cpo +unlet s:save_cpo + +" vim: set sw=4 sts=4 et fdm=marker: diff --git a/vim/bundle/syntastic/syntax_checkers/c/oclint.vim b/vim/bundle/syntastic/syntax_checkers/c/oclint.vim new file mode 100644 index 0000000..f172a11 --- /dev/null +++ b/vim/bundle/syntastic/syntax_checkers/c/oclint.vim @@ -0,0 +1,65 @@ +"============================================================================ +"File: oclint.vim +"Description: Syntax checking plugin for syntastic.vim +"Maintainer: "UnCO" Lin <undercooled aT lavabit com> +"License: This program is free software. It comes without any warranty, +" to the extent permitted by applicable law. You can redistribute +" it and/or modify it under the terms of the Do What The Fuck You +" Want To Public License, Version 2, as published by Sam Hocevar. +" See http://sam.zoy.org/wtfpl/COPYING for more details. +"============================================================================ + +if exists('g:loaded_syntastic_c_oclint_checker') + finish +endif +let g:loaded_syntastic_c_oclint_checker = 1 + +if !exists('g:syntastic_oclint_config_file') + let g:syntastic_oclint_config_file = '.syntastic_oclint_config' +endif + +if !exists('g:syntastic_c_oclint_sort') + let g:syntastic_c_oclint_sort = 1 +endif + +let s:save_cpo = &cpo +set cpo&vim + +function! SyntaxCheckers_c_oclint_GetLocList() dict + let makeprg = self.makeprgBuild({ + \ 'post_args': '-- -c ' . syntastic#c#ReadConfig(g:syntastic_oclint_config_file) }) + + let errorformat = + \ '%E%f:%l:%c: fatal error: %m,' . + \ '%E%f:%l:%c: error: %m,' . + \ '%W%f:%l:%c: warning: %m,' . + \ '%E%f:%l:%c: %m,' . + \ '%-G%.%#' + + let loclist = SyntasticMake({ + \ 'makeprg': makeprg, + \ 'errorformat': errorformat, + \ 'subtype': 'Style', + \ 'postprocess': ['compressWhitespace'], + \ 'returns': [0, 3, 5] }) + + for e in loclist + if e['text'] =~# '\v P3( |$)' + let e['type'] = 'W' + endif + + let e['text'] = substitute(e['text'], '\m\C P[1-3]$', '', '') + let e['text'] = substitute(e['text'], '\m\C P[1-3] ', ': ', '') + endfor + + return loclist +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'c', + \ 'name': 'oclint'}) + +let &cpo = s:save_cpo +unlet s:save_cpo + +" vim: set sw=4 sts=4 et fdm=marker: diff --git a/vim/bundle/syntastic/syntax_checkers/c/pc_lint.vim b/vim/bundle/syntastic/syntax_checkers/c/pc_lint.vim new file mode 100644 index 0000000..6efd17a --- /dev/null +++ b/vim/bundle/syntastic/syntax_checkers/c/pc_lint.vim @@ -0,0 +1,66 @@ +"============================================================================ +"File: pc_lint.vim +"Description: Syntax checking plugin for syntastic.vim +"Maintainer: Steve Bragg <steve at empresseffects dot com> +"License: This program is free software. It comes without any warranty, +" to the extent permitted by applicable law. You can redistribute +" it and/or modify it under the terms of the Do What The Fuck You +" Want To Public License, Version 2, as published by Sam Hocevar. +" See http://sam.zoy.org/wtfpl/COPYING for more details. +" +"============================================================================ + +if exists('g:loaded_syntastic_c_pc_lint_checker') + finish +endif +let g:loaded_syntastic_c_pc_lint_checker = 1 + +let s:save_cpo = &cpo +set cpo&vim + +if !exists('g:syntastic_pc_lint_config_file') + let g:syntastic_pc_lint_config_file = 'options.lnt' +endif + +function! SyntaxCheckers_c_pc_lint_GetLocList() dict + let config = syntastic#util#findFileInParent(g:syntastic_pc_lint_config_file, expand('%:p:h', 1)) + call self.log('config =', config) + + " -hFs1 - show filename, add space after messages, try to make message 1 line + " -width(0,0) - make sure there are no line breaks + " -t - set tab size + " -v - turn off verbosity + let makeprg = self.makeprgBuild({ + \ 'args': (filereadable(config) ? syntastic#util#shescape(fnamemodify(config, ':p')) : ''), + \ 'args_after': ['-hFs1', '-width(0,0)', '-t' . &tabstop, '-format=%f:%l:%C:%t:%n:%m'] }) + + let errorformat = + \ '%E%f:%l:%v:Error:%n:%m,' . + \ '%W%f:%l:%v:Warning:%n:%m,' . + \ '%I%f:%l:%v:Info:%n:%m,' . + \ '%-G%.%#' + + let loclist = SyntasticMake({ + \ 'makeprg': makeprg, + \ 'errorformat': errorformat, + \ 'postprocess': ['cygwinRemoveCR'] }) + + for e in loclist + if e['type'] ==? 'I' + let e['type'] = 'W' + let e['subtype'] = 'Style' + endif + endfor + + return loclist +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'c', + \ 'name': 'pc_lint', + \ 'exec': 'lint-nt'}) + +let &cpo = s:save_cpo +unlet s:save_cpo + +" vim: set sw=4 sts=4 et fdm=marker: diff --git a/vim/bundle/syntastic/syntax_checkers/c/sparse.vim b/vim/bundle/syntastic/syntax_checkers/c/sparse.vim new file mode 100644 index 0000000..ca831c0 --- /dev/null +++ b/vim/bundle/syntastic/syntax_checkers/c/sparse.vim @@ -0,0 +1,48 @@ +"============================================================================ +"File: sparse.vim +"Description: Syntax checking plugin for syntastic.vim using sparse.pl +"Maintainer: Daniel Walker <dwalker at fifo99 dot com> +"License: This program is free software. It comes without any warranty, +" to the extent permitted by applicable law. You can redistribute +" it and/or modify it under the terms of the Do What The Fuck You +" Want To Public License, Version 2, as published by Sam Hocevar. +" See http://sam.zoy.org/wtfpl/COPYING for more details. +"============================================================================ + +if exists('g:loaded_syntastic_c_sparse_checker') + finish +endif +let g:loaded_syntastic_c_sparse_checker = 1 + +if !exists('g:syntastic_sparse_config_file') + let g:syntastic_sparse_config_file = '.syntastic_sparse_config' +endif + +let s:save_cpo = &cpo +set cpo&vim + +function! SyntaxCheckers_c_sparse_GetLocList() dict + let makeprg = self.makeprgBuild({ + \ 'args': syntastic#c#ReadConfig(g:syntastic_sparse_config_file), + \ 'args_after': '-ftabstop=' . &ts }) + + let errorformat = + \ '%f:%l:%v: %trror: %m,' . + \ '%f:%l:%v: %tarning: %m,' + + let loclist = SyntasticMake({ + \ 'makeprg': makeprg, + \ 'errorformat': errorformat, + \ 'defaults': {'bufnr': bufnr('')}, + \ 'returns': [0, 1] }) + return loclist +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'c', + \ 'name': 'sparse'}) + +let &cpo = s:save_cpo +unlet s:save_cpo + +" vim: set sw=4 sts=4 et fdm=marker: diff --git a/vim/bundle/syntastic/syntax_checkers/c/splint.vim b/vim/bundle/syntastic/syntax_checkers/c/splint.vim new file mode 100644 index 0000000..a4e19f0 --- /dev/null +++ b/vim/bundle/syntastic/syntax_checkers/c/splint.vim @@ -0,0 +1,55 @@ +"============================================================================ +"File: splint.vim +"Description: Syntax checking plugin for syntastic.vim +"Maintainer: LCD 47 <lcd047 at gmail dot com> +"License: This program is free software. It comes without any warranty, +" to the extent permitted by applicable law. You can redistribute +" it and/or modify it under the terms of the Do What The Fuck You +" Want To Public License, Version 2, as published by Sam Hocevar. +" See http://sam.zoy.org/wtfpl/COPYING for more details. +"============================================================================ + +if exists('g:loaded_syntastic_c_splint_checker') + finish +endif +let g:loaded_syntastic_c_splint_checker = 1 + +if !exists('g:syntastic_splint_config_file') + let g:syntastic_splint_config_file = '.syntastic_splint_config' +endif + +let s:save_cpo = &cpo +set cpo&vim + +function! SyntaxCheckers_c_splint_GetLocList() dict + let makeprg = self.makeprgBuild({ + \ 'args': syntastic#c#ReadConfig(g:syntastic_splint_config_file), + \ 'args_after': '-showfunc -hints +quiet' }) + + let errorformat = + \ '%-G%f:%l:%v: %[%#]%[%#]%[%#] Internal Bug %.%#,' . + \ '%-G%f(%l\,%v): %[%#]%[%#]%[%#] Internal Bug %.%#,' . + \ '%W%f:%l:%v: %m,' . + \ '%W%f(%l\,%v): %m,' . + \ '%W%f:%l: %m,' . + \ '%W%f(%l): %m,' . + \ '%-C %\+In file included from %.%#,' . + \ '%-C %\+from %.%#,' . + \ '%+C %.%#' + + return SyntasticMake({ + \ 'makeprg': makeprg, + \ 'errorformat': errorformat, + \ 'subtype': 'Style', + \ 'postprocess': ['compressWhitespace'], + \ 'defaults': {'type': 'W'} }) +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'c', + \ 'name': 'splint'}) + +let &cpo = s:save_cpo +unlet s:save_cpo + +" vim: set sw=4 sts=4 et fdm=marker: diff --git a/vim/bundle/syntastic/syntax_checkers/cabal/cabal.vim b/vim/bundle/syntastic/syntax_checkers/cabal/cabal.vim new file mode 100644 index 0000000..e43aefa --- /dev/null +++ b/vim/bundle/syntastic/syntax_checkers/cabal/cabal.vim @@ -0,0 +1,55 @@ +"============================================================================ +"File: cabal.vim +"Description: Haskell package description (.cabal file) linting and syntax +" validation via 'cabal check' +"Maintainer: Ian D. Bollinger <ian.bollinger@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_cabal_cabal_checker') + finish +endif +let g:loaded_syntastic_cabal_cabal_checker = 1 + +let s:save_cpo = &cpo +set cpo&vim + +function! SyntaxCheckers_cabal_cabal_GetHighlightRegex(item) + let field = matchstr(a:item['text'], "\\vParse of field '\\zs[^']+") + if field !=# '' + return '\v\c^\s*' . field . '\s*:\s*\zs.*$' + endif + let field = matchstr(a:item['text'], "\\v(^|\\s)'\\zs[^']+\\ze'") + if field !=# '' + return '\V\c\<' . escape(field, '\') . '\>' + endif + return '' +endfunction + +function! SyntaxCheckers_cabal_cabal_GetLocList() dict + let makeprg = self.getExecEscaped() . ' check' + + let errorformat = + \ '%Ecabal: %f:%l: %m,' . + \ '%W* %m' + + return SyntasticMake({ + \ 'makeprg': makeprg, + \ 'errorformat': errorformat, + \ 'cwd': expand('%:p:h', 1), + \ 'preprocess': 'cabal', + \ 'defaults': {'bufnr': bufnr('')} }) +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'cabal', + \ 'name': 'cabal'}) + +let &cpo = s:save_cpo +unlet s:save_cpo + +" vim: set sw=4 sts=4 et fdm=marker: diff --git a/vim/bundle/syntastic/syntax_checkers/chef/foodcritic.vim b/vim/bundle/syntastic/syntax_checkers/chef/foodcritic.vim new file mode 100644 index 0000000..84d9af1 --- /dev/null +++ b/vim/bundle/syntastic/syntax_checkers/chef/foodcritic.vim @@ -0,0 +1,39 @@ +"============================================================================ +"File: foodcritic.vim +"Description: Syntax checking plugin for syntastic.vim +"Maintainer: Doug Ireton <dougireton@gmail.com> +"License: This program is free software. It comes without any warranty, +" to the extent permitted by applicable law. You can redistribute +" it and/or modify it under the terms of the Do What The Fuck You +" Want To Public License, Version 2, as published by Sam Hocevar. +" See http://sam.zoy.org/wtfpl/COPYING for more details. +" +"============================================================================ + +if exists('g:loaded_syntastic_chef_foodcritic_checker') + finish +endif +let g:loaded_syntastic_chef_foodcritic_checker = 1 + +let s:save_cpo = &cpo +set cpo&vim + +function! SyntaxCheckers_chef_foodcritic_GetLocList() dict + let makeprg = self.makeprgBuild({}) + + " FC023: Prefer conditional attributes: ./recipes/config.rb:49 + let errorformat = 'FC%n: %m: %f:%l' + + return SyntasticMake({ + \ 'makeprg': makeprg, + \ 'errorformat': errorformat }) +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'chef', + \ 'name': 'foodcritic'}) + +let &cpo = s:save_cpo +unlet s:save_cpo + +" vim: set sw=4 sts=4 et fdm=marker: diff --git a/vim/bundle/syntastic/syntax_checkers/co/coco.vim b/vim/bundle/syntastic/syntax_checkers/co/coco.vim new file mode 100644 index 0000000..9be5d7d --- /dev/null +++ b/vim/bundle/syntastic/syntax_checkers/co/coco.vim @@ -0,0 +1,47 @@ +"============================================================================ +"File: co.vim +"Description: Syntax checking plugin for syntastic.vim +"Maintainer: Andrew Kelley <superjoe30@gmail.com> +"License: This program is free software. It comes without any warranty, +" to the extent permitted by applicable law. You can redistribute +" it and/or modify it under the terms of the Do What The Fuck You +" Want To Public License, Version 2, as published by Sam Hocevar. +" See http://sam.zoy.org/wtfpl/COPYING for more details. +" +"============================================================================ + +if exists('g:loaded_syntastic_co_coco_checker') + finish +endif +let g:loaded_syntastic_co_coco_checker = 1 + +let s:save_cpo = &cpo +set cpo&vim + +function! SyntaxCheckers_co_coco_GetLocList() dict + let tmpdir = syntastic#util#tmpdir() + let makeprg = self.makeprgBuild({ 'args_after': '-c -o ' . tmpdir }) + + let errorformat = + \ '%EFailed at: %f,' . + \ '%ZSyntax%trror: %m on line %l,'. + \ '%EFailed at: %f,'. + \ '%Z%trror: Parse error on line %l: %m' + + let loclist = SyntasticMake({ + \ 'makeprg': makeprg, + \ 'errorformat': errorformat }) + + call syntastic#util#rmrf(tmpdir) + + return loclist +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'co', + \ 'name': 'coco'}) + +let &cpo = s:save_cpo +unlet s:save_cpo + +" vim: set sw=4 sts=4 et fdm=marker: diff --git a/vim/bundle/syntastic/syntax_checkers/cobol/cobc.vim b/vim/bundle/syntastic/syntax_checkers/cobol/cobc.vim new file mode 100644 index 0000000..0cff0cc --- /dev/null +++ b/vim/bundle/syntastic/syntax_checkers/cobol/cobc.vim @@ -0,0 +1,47 @@ +"============================================================================ +"File: cobc.vim +"Description: Syntax checking plugin for syntastic.vim +"Maintainer: LCD 47 <lcd047 at gmail dot com> +"License: This program is free software. It comes without any warranty, +" to the extent permitted by applicable law. You can redistribute +" it and/or modify it under the terms of the Do What The Fuck You +" Want To Public License, Version 2, as published by Sam Hocevar. +" See http://sam.zoy.org/wtfpl/COPYING for more details. +" +"============================================================================ + + +if exists('g:loaded_syntastic_cobol_cobc_checker') + finish +endif +let g:loaded_syntastic_cobol_cobc_checker = 1 + +if !exists('g:syntastic_cobol_compiler_options') + let g:syntastic_cobol_compiler_options = '' +endif + +let s:save_cpo = &cpo +set cpo&vim + +function! SyntaxCheckers_cobol_cobc_IsAvailable() dict + if !exists('g:syntastic_cobol_compiler') + let g:syntastic_cobol_compiler = self.getExec() + endif + call self.log('g:syntastic_cobol_compiler =', g:syntastic_cobol_compiler) + return executable(expand(g:syntastic_cobol_compiler, 1)) +endfunction + +function! SyntaxCheckers_cobol_cobc_GetLocList() dict + return syntastic#c#GetLocList('cobol', 'cobc', { + \ 'errorformat': '%f:%l: %trror: %m', + \ 'main_flags': '-fsyntax-only' }) +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'cobol', + \ 'name': 'cobc' }) + +let &cpo = s:save_cpo +unlet s:save_cpo + +" vim: set sw=4 sts=4 et fdm=marker: diff --git a/vim/bundle/syntastic/syntax_checkers/coffee/coffee.vim b/vim/bundle/syntastic/syntax_checkers/coffee/coffee.vim new file mode 100644 index 0000000..3b521fc --- /dev/null +++ b/vim/bundle/syntastic/syntax_checkers/coffee/coffee.vim @@ -0,0 +1,58 @@ +"============================================================================ +"File: coffee.vim +"Description: Syntax checking plugin for syntastic.vim +"Maintainer: Lincoln Stoll <l@lds.li> +"License: This program is free software. It comes without any warranty, +" to the extent permitted by applicable law. You can redistribute +" it and/or modify it under the terms of the Do What The Fuck You +" Want To Public License, Version 2, as published by Sam Hocevar. +" See http://sam.zoy.org/wtfpl/COPYING for more details. +" +"============================================================================ +" +" Note: this script requires CoffeeScript version 1.6.2 or newer. +" + +if exists('g:loaded_syntastic_coffee_coffee_checker') + finish +endif +let g:loaded_syntastic_coffee_coffee_checker = 1 + +let s:save_cpo = &cpo +set cpo&vim + +function! SyntaxCheckers_coffee_coffee_IsAvailable() dict + if !executable(self.getExec()) + return 0 + endif + let ver = self.getVersion(self.getExecEscaped() . ' --version 2>' . syntastic#util#DevNull()) + return syntastic#util#versionIsAtLeast(ver, [1, 6, 2]) +endfunction + +function! SyntaxCheckers_coffee_coffee_GetLocList() dict + let makeprg = self.makeprgBuild({ 'args_after': '-cp' }) + + let errorformat = + \ '%E%f:%l:%c: %trror: %m,' . + \ 'Syntax%trror: In %f\, %m on line %l,' . + \ '%EError: In %f\, Parse error on line %l: %m,' . + \ '%EError: In %f\, %m on line %l,' . + \ '%W%f(%l): lint warning: %m,' . + \ '%W%f(%l): warning: %m,' . + \ '%E%f(%l): SyntaxError: %m,' . + \ '%-Z%p^,' . + \ '%-G%.%#' + + return SyntasticMake({ + \ 'makeprg': makeprg, + \ 'errorformat': errorformat }) +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'coffee', + \ 'name': 'coffee'}) + +let &cpo = s:save_cpo +unlet s:save_cpo + +" vim: set sw=4 sts=4 et fdm=marker: diff --git a/vim/bundle/syntastic/syntax_checkers/coffee/coffeelint.vim b/vim/bundle/syntastic/syntax_checkers/coffee/coffeelint.vim new file mode 100644 index 0000000..befdbc8 --- /dev/null +++ b/vim/bundle/syntastic/syntax_checkers/coffee/coffeelint.vim @@ -0,0 +1,44 @@ +"============================================================================ +"File: coffeelint.vim +"Description: Syntax checking plugin for syntastic.vim +"Maintainer: Lincoln Stoll <l@lds.li> +"License: This program is free software. It comes without any warranty, +" to the extent permitted by applicable law. You can redistribute +" it and/or modify it under the terms of the Do What The Fuck You +" Want To Public License, Version 2, as published by Sam Hocevar. +" See http://sam.zoy.org/wtfpl/COPYING for more details. +" +"============================================================================ + +if exists('g:loaded_syntastic_coffee_coffeelint_checker') + finish +endif +let g:loaded_syntastic_coffee_coffeelint_checker = 1 + +let s:save_cpo = &cpo +set cpo&vim + +function! SyntaxCheckers_coffee_coffeelint_GetLocList() dict + if !exists('s:coffeelint_new') + let s:coffeelint_new = syntastic#util#versionIsAtLeast(self.getVersion(), [1, 4]) + endif + let makeprg = self.makeprgBuild({ 'args_after': (s:coffeelint_new ? '--reporter csv' : '--csv') }) + + let errorformat = '%f:%l:%t:%m' + + return SyntasticMake({ + \ 'makeprg': makeprg, + \ 'errorformat': errorformat, + \ 'subtype': 'Style', + \ 'returns': [0, 1], + \ 'preprocess': 'coffeelint' }) +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'coffee', + \ 'name': 'coffeelint'}) + +let &cpo = s:save_cpo +unlet s:save_cpo + +" vim: set sw=4 sts=4 et fdm=marker: diff --git a/vim/bundle/syntastic/syntax_checkers/coq/coqtop.vim b/vim/bundle/syntastic/syntax_checkers/coq/coqtop.vim new file mode 100644 index 0000000..6385554 --- /dev/null +++ b/vim/bundle/syntastic/syntax_checkers/coq/coqtop.vim @@ -0,0 +1,40 @@ +"============================================================================ +"File: coqtop.vim +"Description: Syntax checking plugin for syntastic.vim +"Maintainer: Matvey Aksenov <matvey.aksenov at gmail dot com> +"License: This program is free software. It comes without any warranty, +" to the extent permitted by applicable law. You can redistribute +" it and/or modify it under the terms of the Do What The Fuck You +" Want To Public License, Version 2, as published by Sam Hocevar. +" See http://sam.zoy.org/wtfpl/COPYING for more details. +" +"============================================================================ + +if exists('g:loaded_syntastic_coq_coqtop_checker') + finish +endif +let g:loaded_syntastic_coq_coqtop_checker = 1 + +let s:save_cpo = &cpo +set cpo&vim + +function! SyntaxCheckers_coq_coqtop_GetLocList() dict + let makeprg = self.makeprgBuild({ 'args_after': '-noglob -batch -load-vernac-source' }) + + let errorformat = + \ '%AFile "%f"\, line %l\, characters %c-%.%#\:,'. + \ '%C%m' + + return SyntasticMake({ + \ 'makeprg': makeprg, + \ 'errorformat': errorformat }) +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'coq', + \ 'name': 'coqtop'}) + +let &cpo = s:save_cpo +unlet s:save_cpo + +" vim: set sw=4 sts=4 et fdm=marker: diff --git a/vim/bundle/syntastic/syntax_checkers/cpp/clang_check.vim b/vim/bundle/syntastic/syntax_checkers/cpp/clang_check.vim new file mode 100644 index 0000000..cf9ec0c --- /dev/null +++ b/vim/bundle/syntastic/syntax_checkers/cpp/clang_check.vim @@ -0,0 +1,22 @@ +"============================================================================ +"File: clang_check.vim +"Description: Syntax checking plugin for syntastic.vim +"Maintainer: Benjamin Bannier <bbannier at gmail dot com> +"License: This program is free software. It comes without any warranty, +" to the extent permitted by applicable law. You can redistribute +" it and/or modify it under the terms of the Do What The Fuck You +" Want To Public License, Version 2, as published by Sam Hocevar. +" See http://sam.zoy.org/wtfpl/COPYING for more details. +"============================================================================ + +if exists('g:loaded_syntastic_cpp_clang_check_checker') + finish +endif +let g:loaded_syntastic_cpp_clang_check_checker = 1 + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'cpp', + \ 'name': 'clang_check', + \ 'redirect': 'c/clang_check'}) + +" vim: set sw=4 sts=4 et fdm=marker: diff --git a/vim/bundle/syntastic/syntax_checkers/cpp/clang_tidy.vim b/vim/bundle/syntastic/syntax_checkers/cpp/clang_tidy.vim new file mode 100644 index 0000000..770d1f6 --- /dev/null +++ b/vim/bundle/syntastic/syntax_checkers/cpp/clang_tidy.vim @@ -0,0 +1,22 @@ +"============================================================================ +"File: clang_tidy.vim +"Description: Syntax checking plugin for syntastic.vim +"Maintainer: Benjamin Bannier <bbannier at gmail dot com> +"License: This program is free software. It comes without any warranty, +" to the extent permitted by applicable law. You can redistribute +" it and/or modify it under the terms of the Do What The Fuck You +" Want To Public License, Version 2, as published by Sam Hocevar. +" See http://sam.zoy.org/wtfpl/COPYING for more details. +"============================================================================ + +if exists('g:loaded_syntastic_cpp_clang_tidy_checker') + finish +endif +let g:loaded_syntastic_cpp_clang_tidy_checker = 1 + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'cpp', + \ 'name': 'clang_tidy', + \ 'redirect': 'c/clang_tidy'}) + +" vim: set sw=4 sts=4 et fdm=marker: diff --git a/vim/bundle/syntastic/syntax_checkers/cpp/cppcheck.vim b/vim/bundle/syntastic/syntax_checkers/cpp/cppcheck.vim new file mode 100644 index 0000000..4e0eb86 --- /dev/null +++ b/vim/bundle/syntastic/syntax_checkers/cpp/cppcheck.vim @@ -0,0 +1,22 @@ +"============================================================================ +"File: cppcheck.vim +"Description: Syntax checking plugin for syntastic.vim using cppcheck.pl +"Maintainer: LCD 47 <lcd047 at gmail dot com> +"License: This program is free software. It comes without any warranty, +" to the extent permitted by applicable law. You can redistribute +" it and/or modify it under the terms of the Do What The Fuck You +" Want To Public License, Version 2, as published by Sam Hocevar. +" See http://sam.zoy.org/wtfpl/COPYING for more details. +"============================================================================ + +if exists('g:loaded_syntastic_cpp_cppcheck_checker') + finish +endif +let g:loaded_syntastic_cpp_cppcheck_checker = 1 + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'cpp', + \ 'name': 'cppcheck', + \ 'redirect': 'c/cppcheck'}) + +" vim: set sw=4 sts=4 et fdm=marker: diff --git a/vim/bundle/syntastic/syntax_checkers/cpp/cpplint.vim b/vim/bundle/syntastic/syntax_checkers/cpp/cpplint.vim new file mode 100644 index 0000000..54984bb --- /dev/null +++ b/vim/bundle/syntastic/syntax_checkers/cpp/cpplint.vim @@ -0,0 +1,52 @@ +"============================================================================ +"File: cpplint.vim +"Description: Syntax checking plugin for syntastic.vim +"Maintainer: LCD 47 <lcd047 at gmail dot com> +"License: This program is free software. It comes without any warranty, +" to the extent permitted by applicable law. You can redistribute +" it and/or modify it under the terms of the Do What The Fuck You +" Want To Public License, Version 2, as published by Sam Hocevar. +" See http://sam.zoy.org/wtfpl/COPYING for more details. +" +"============================================================================ + +if exists('g:loaded_syntastic_cpp_cpplint_checker') + finish +endif +let g:loaded_syntastic_cpp_cpplint_checker = 1 + +if !exists('g:syntastic_cpp_cpplint_thres') + let g:syntastic_cpp_cpplint_thres = 5 +endif + +let s:save_cpo = &cpo +set cpo&vim + +function! SyntaxCheckers_cpp_cpplint_GetLocList() dict + let makeprg = self.makeprgBuild({ 'args': '--verbose=3' }) + + let errorformat = '%A%f:%l: %m [%t],%-G%.%#' + + let loclist = SyntasticMake({ + \ 'makeprg': makeprg, + \ 'errorformat': errorformat, + \ 'subtype': 'Style', + \ 'returns': [0, 1] }) + + " change error types according to the prescribed threshold + for e in loclist + let e['type'] = e['type'] < g:syntastic_cpp_cpplint_thres ? 'W' : 'E' + endfor + + return loclist +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'cpp', + \ 'name': 'cpplint', + \ 'exec': 'cpplint.py'}) + +let &cpo = s:save_cpo +unlet s:save_cpo + +" vim: set sw=4 sts=4 et fdm=marker: diff --git a/vim/bundle/syntastic/syntax_checkers/cpp/gcc.vim b/vim/bundle/syntastic/syntax_checkers/cpp/gcc.vim new file mode 100644 index 0000000..1243980 --- /dev/null +++ b/vim/bundle/syntastic/syntax_checkers/cpp/gcc.vim @@ -0,0 +1,56 @@ +"============================================================================ +"File: cpp.vim +"Description: Syntax checking plugin for syntastic.vim +"Maintainer: Gregor Uhlenheuer <kongo2002 at gmail dot com> +"License: This program is free software. It comes without any warranty, +" to the extent permitted by applicable law. You can redistribute +" it and/or modify it under the terms of the Do What The Fuck You +" Want To Public License, Version 2, as published by Sam Hocevar. +" See http://sam.zoy.org/wtfpl/COPYING for more details. +" +"============================================================================ + +if exists('g:loaded_syntastic_cpp_gcc_checker') + finish +endif +let g:loaded_syntastic_cpp_gcc_checker = 1 + +if !exists('g:syntastic_cpp_compiler_options') + let g:syntastic_cpp_compiler_options = '' +endif + +let s:save_cpo = &cpo +set cpo&vim + +function! SyntaxCheckers_cpp_gcc_IsAvailable() dict + if !exists('g:syntastic_cpp_compiler') + let g:syntastic_cpp_compiler = executable(self.getExec()) ? self.getExec() : 'clang++' + endif + call self.log('g:syntastic_cpp_compiler =', g:syntastic_cpp_compiler) + return executable(expand(g:syntastic_cpp_compiler, 1)) +endfunction + +function! SyntaxCheckers_cpp_gcc_GetLocList() dict + return syntastic#c#GetLocList('cpp', 'gcc', { + \ 'errorformat': + \ '%-G%f:%s:,' . + \ '%f:%l:%c: %trror: %m,' . + \ '%f:%l:%c: %tarning: %m,' . + \ '%f:%l:%c: %m,'. + \ '%f:%l: %trror: %m,'. + \ '%f:%l: %tarning: %m,'. + \ '%f:%l: %m', + \ 'main_flags': '-x c++ -fsyntax-only', + \ 'header_flags': '-x c++', + \ 'header_names': '\m\.\(h\|hpp\|hh\)$' }) +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'cpp', + \ 'name': 'gcc', + \ 'exec': 'g++' }) + +let &cpo = s:save_cpo +unlet s:save_cpo + +" vim: set sw=4 sts=4 et fdm=marker: diff --git a/vim/bundle/syntastic/syntax_checkers/cpp/oclint.vim b/vim/bundle/syntastic/syntax_checkers/cpp/oclint.vim new file mode 100644 index 0000000..8217769 --- /dev/null +++ b/vim/bundle/syntastic/syntax_checkers/cpp/oclint.vim @@ -0,0 +1,22 @@ +"============================================================================ +"File: oclint.vim +"Description: Syntax checking plugin for syntastic.vim +"Maintainer: "UnCO" Lin <undercooled aT lavabit com> +"License: This program is free software. It comes without any warranty, +" to the extent permitted by applicable law. You can redistribute +" it and/or modify it under the terms of the Do What The Fuck You +" Want To Public License, Version 2, as published by Sam Hocevar. +" See http://sam.zoy.org/wtfpl/COPYING for more details. +"============================================================================ + +if exists('g:loaded_syntastic_cpp_oclint_checker') + finish +endif +let g:loaded_syntastic_cpp_oclint_checker = 1 + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'cpp', + \ 'name': 'oclint', + \ 'redirect': 'c/oclint'}) + +" vim: set sw=4 sts=4 et fdm=marker: diff --git a/vim/bundle/syntastic/syntax_checkers/cpp/pc_lint.vim b/vim/bundle/syntastic/syntax_checkers/cpp/pc_lint.vim new file mode 100644 index 0000000..a7c95e8 --- /dev/null +++ b/vim/bundle/syntastic/syntax_checkers/cpp/pc_lint.vim @@ -0,0 +1,23 @@ +"============================================================================ +"File: pc_lint.vim +"Description: Syntax checking plugin for syntastic.vim +"Maintainer: Steve Bragg <steve at empresseffects dot com> +"License: This program is free software. It comes without any warranty, +" to the extent permitted by applicable law. You can redistribute +" it and/or modify it under the terms of the Do What The Fuck You +" Want To Public License, Version 2, as published by Sam Hocevar. +" See http://sam.zoy.org/wtfpl/COPYING for more details. +" +"============================================================================ + +if exists('g:loaded_syntastic_cpp_pc_lint_checker') + finish +endif +let g:loaded_syntastic_cpp_pc_lint_checker = 1 + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'cpp', + \ 'name': 'pc_lint', + \ 'redirect': 'c/pc_lint'}) + +" vim: set sw=4 sts=4 et fdm=marker: diff --git a/vim/bundle/syntastic/syntax_checkers/cpp/verapp.vim b/vim/bundle/syntastic/syntax_checkers/cpp/verapp.vim new file mode 100644 index 0000000..af1fd8c --- /dev/null +++ b/vim/bundle/syntastic/syntax_checkers/cpp/verapp.vim @@ -0,0 +1,48 @@ +"============================================================================ +"File: verapp.vim +"Description: Syntax checking plugin for syntastic.vim +"Maintainer: Lucas Verney <phyks@phyks.me> +"License: This program is free software. It comes without any warranty, +" to the extent permitted by applicable law. You can redistribute +" it and/or modify it under the terms of the Do What The Fuck You +" Want To Public License, Version 2, as published by Sam Hocevar. +" See http://sam.zoy.org/wtfpl/COPYING for more details. +" +" Tested with Vera++ 1.3.0 +"============================================================================ + +if exists('g:loaded_syntastic_cpp_verapp_checker') + finish +endif +let g:loaded_syntastic_cpp_verapp_checker = 1 + +if !exists('g:syntastic_verapp_config_file') + let g:syntastic_verapp_config_file = '.syntastic_verapp_config' +endif + +let s:save_cpo = &cpo +set cpo&vim + +function! SyntaxCheckers_cpp_verapp_GetLocList() dict + let makeprg = self.makeprgBuild({ + \ 'args': syntastic#c#ReadConfig(g:syntastic_verapp_config_file), + \ 'args_after': '--show-rule --no-duplicate -S -c -' }) + + let errorformat = '%f:%t:%l:%c:%m' + + return SyntasticMake({ + \ 'makeprg': makeprg, + \ 'errorformat': errorformat, + \ 'preprocess': 'checkstyle', + \ 'subtype': 'Style' }) +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'cpp', + \ 'name': 'verapp', + \ 'exec': 'vera++'}) + +let &cpo = s:save_cpo +unlet s:save_cpo + +" vim: set sw=4 sts=4 et fdm=marker: diff --git a/vim/bundle/syntastic/syntax_checkers/cs/mcs.vim b/vim/bundle/syntastic/syntax_checkers/cs/mcs.vim new file mode 100644 index 0000000..4544a93 --- /dev/null +++ b/vim/bundle/syntastic/syntax_checkers/cs/mcs.vim @@ -0,0 +1,39 @@ +"============================================================================ +"File: cs.vim +"Description: Syntax checking plugin for syntastic.vim +"Maintainer: Daniel Walker <dwalker@fifo99.com> +"License: This program is free software. It comes without any warranty, +" to the extent permitted by applicable law. You can redistribute +" it and/or modify it under the terms of the Do What The Fuck You +" Want To Public License, Version 2, as published by Sam Hocevar. +" See http://sam.zoy.org/wtfpl/COPYING for more details. +" +"============================================================================ + +if exists('g:loaded_syntastic_cs_mcs_checker') + finish +endif +let g:loaded_syntastic_cs_mcs_checker = 1 + +let s:save_cpo = &cpo +set cpo&vim + +function! SyntaxCheckers_cs_mcs_GetLocList() dict + let makeprg = self.makeprgBuild({ 'args_after': '--parse' }) + + let errorformat = '%f(%l\,%c): %trror %m' + + return SyntasticMake({ + \ 'makeprg': makeprg, + \ 'errorformat': errorformat, + \ 'defaults': {'bufnr': bufnr('')} }) +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'cs', + \ 'name': 'mcs'}) + +let &cpo = s:save_cpo +unlet s:save_cpo + +" vim: set sw=4 sts=4 et fdm=marker: diff --git a/vim/bundle/syntastic/syntax_checkers/css/csslint.vim b/vim/bundle/syntastic/syntax_checkers/css/csslint.vim new file mode 100644 index 0000000..2d3702b --- /dev/null +++ b/vim/bundle/syntastic/syntax_checkers/css/csslint.vim @@ -0,0 +1,47 @@ +"============================================================================ +"File: css.vim +"Description: Syntax checking plugin for syntastic.vim using `csslint` CLI tool (http://csslint.net). +"Maintainer: Ory Band <oryband at gmail dot com> +"License: This program is free software. It comes without any warranty, +" to the extent permitted by applicable law. You can redistribute +" it and/or modify it under the terms of the Do What The Fuck You +" Want To Public License, Version 2, as published by Sam Hocevar. +" See http://sam.zoy.org/wtfpl/COPYING for more details. +"============================================================================ + +if exists('g:loaded_syntastic_css_csslint_checker') + finish +endif +let g:loaded_syntastic_css_csslint_checker = 1 + +let s:save_cpo = &cpo +set cpo&vim + +function! SyntaxCheckers_css_csslint_GetLocList() dict + call syntastic#log#deprecationWarn('csslint_options', 'css_csslint_args') + + let makeprg = self.makeprgBuild({ 'args_after': '--format=compact' }) + + " Print CSS Lint's error/warning messages from compact format. Ignores blank lines. + let errorformat = + \ '%-G,' . + \ '%-G%f: lint free!,' . + \ '%f: line %l\, col %c\, %trror - %m,' . + \ '%f: line %l\, col %c\, %tarning - %m,'. + \ '%f: line %l\, col %c\, %m,' + + return SyntasticMake({ + \ 'makeprg': makeprg, + \ 'errorformat': errorformat, + \ 'defaults': {'bufnr': bufnr('')} }) + +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'css', + \ 'name': 'csslint'}) + +let &cpo = s:save_cpo +unlet s:save_cpo + +" vim: set sw=4 sts=4 et fdm=marker: diff --git a/vim/bundle/syntastic/syntax_checkers/css/mixedindentlint.vim b/vim/bundle/syntastic/syntax_checkers/css/mixedindentlint.vim new file mode 100644 index 0000000..a0ce3ba --- /dev/null +++ b/vim/bundle/syntastic/syntax_checkers/css/mixedindentlint.vim @@ -0,0 +1,22 @@ +"============================================================================ +"File: mixedindentlint.vim +"Description: Mixed indentation linter for vim +"Maintainer: Payton Swick <payton@foolord.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_css_mixedindentlint_checker') + finish +endif +let g:loaded_syntastic_css_mixedindentlint_checker = 1 + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'css', + \ 'name': 'mixedindentlint', + \ 'redirect': 'javascript/mixedindentlint'}) + +" vim: set et sts=4 sw=4: diff --git a/vim/bundle/syntastic/syntax_checkers/css/phpcs.vim b/vim/bundle/syntastic/syntax_checkers/css/phpcs.vim new file mode 100644 index 0000000..a065f0e --- /dev/null +++ b/vim/bundle/syntastic/syntax_checkers/css/phpcs.vim @@ -0,0 +1,23 @@ +"============================================================================ +"File: phpcs.vim +"Description: Syntax checking plugin for syntastic.vim +"Maintainer: LCD 47 <lcd047 at gmail dot com> +"License: This program is free software. It comes without any warranty, +" to the extent permitted by applicable law. You can redistribute +" it and/or modify it under the terms of the Do What The Fuck You +" Want To Public License, Version 2, as published by Sam Hocevar. +" See http://sam.zoy.org/wtfpl/COPYING for more details. +" +"============================================================================ + +if exists('g:loaded_syntastic_css_phpcs_checker') + finish +endif +let g:loaded_syntastic_css_phpcs_checker = 1 + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'css', + \ 'name': 'phpcs', + \ 'redirect': 'php/phpcs'}) + +" vim: set sw=4 sts=4 et fdm=marker: diff --git a/vim/bundle/syntastic/syntax_checkers/css/prettycss.vim b/vim/bundle/syntastic/syntax_checkers/css/prettycss.vim new file mode 100644 index 0000000..b531f49 --- /dev/null +++ b/vim/bundle/syntastic/syntax_checkers/css/prettycss.vim @@ -0,0 +1,61 @@ +"============================================================================ +"File: prettycss.vim +"Description: Syntax checking plugin for syntastic.vim +"Maintainer: LCD 47 <lcd047 at gmail dot com> +"License: This program is free software. It comes without any warranty, +" to the extent permitted by applicable law. You can redistribute +" it and/or modify it under the terms of the Do What The Fuck You +" Want To Public License, Version 2, as published by Sam Hocevar. +" See http://sam.zoy.org/wtfpl/COPYING for more details. +" +"============================================================================ + +if exists('g:loaded_syntastic_css_prettycss_checker') + finish +endif +let g:loaded_syntastic_css_prettycss_checker = 1 + +if !exists('g:syntastic_css_prettycss_sort') + let g:syntastic_css_prettycss_sort = 1 +endif + +let s:save_cpo = &cpo +set cpo&vim + +function! SyntaxCheckers_css_prettycss_GetHighlightRegex(item) + let term = matchstr(a:item['text'], '\m (\zs[^)]\+\ze)$') + if term !=# '' + let term = '\V' . escape(term, '\') + endif + return term +endfunction + +function! SyntaxCheckers_css_prettycss_GetLocList() dict + let makeprg = self.makeprgBuild({}) + + " Print CSS Lint's error/warning messages from compact format. Ignores blank lines. + let errorformat = + \ '%EError: %m\, line %l\, char %c),' . + \ '%WWarning: %m\, line %l\, char %c),' . + \ '%-G%.%#' + + let loclist = SyntasticMake({ + \ 'makeprg': makeprg, + \ 'errorformat': errorformat, + \ 'defaults': {'bufnr': bufnr('')} }) + + for e in loclist + let e['text'] .= ')' + endfor + + return loclist +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'css', + \ 'name': 'prettycss'}) + +let &cpo = s:save_cpo +unlet s:save_cpo + +" vim: set sw=4 sts=4 et fdm=marker: diff --git a/vim/bundle/syntastic/syntax_checkers/css/recess.vim b/vim/bundle/syntastic/syntax_checkers/css/recess.vim new file mode 100644 index 0000000..ce6d5ae --- /dev/null +++ b/vim/bundle/syntastic/syntax_checkers/css/recess.vim @@ -0,0 +1,24 @@ +"============================================================================ +"File: recess.vim +"Description: Syntax checking plugin for syntastic.vim using `recess` +" (http://twitter.github.io/recess/). +"Maintainer: Tim Carry <tim at pixelastic dot com> +"License: This program is free software. It comes without any warranty, +" to the extent permitted by applicable law. You can redistribute +" it and/or modify it under the terms of the Do What The Fuck You +" Want To Public License, Version 2, as published by Sam Hocevar. +" See http://sam.zoy.org/wtfpl/COPYING for more details. +" +"============================================================================ + +if exists('g:loaded_syntastic_css_recess_checker') + finish +endif +let g:loaded_syntastic_css_recess_checker = 1 + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'css', + \ 'name': 'recess', + \ 'redirect': 'less/recess'}) + +" vim: set sw=4 sts=4 et fdm=marker: diff --git a/vim/bundle/syntastic/syntax_checkers/css/stylelint.vim b/vim/bundle/syntastic/syntax_checkers/css/stylelint.vim new file mode 100644 index 0000000..58c7dec --- /dev/null +++ b/vim/bundle/syntastic/syntax_checkers/css/stylelint.vim @@ -0,0 +1,47 @@ +"============================================================================ +"File: stylelint.vim +"Description: Syntax checking plugin for syntastic.vim using `stylelint` +" (https://github.com/stylelint/stylelint). +"Maintainer: Tim Carry <tim at pixelastic dot com> +"License: This program is free software. It comes without any warranty, +" to the extent permitted by applicable law. You can redistribute +" it and/or modify it under the terms of the Do What The Fuck You +" Want To Public License, Version 2, as published by Sam Hocevar. +" See http://sam.zoy.org/wtfpl/COPYING for more details. +" +"============================================================================ + +if exists('g:loaded_syntastic_css_stylelint_checker') + finish +endif +let g:loaded_syntastic_css_stylelint_checker = 1 + +let s:save_cpo = &cpo +set cpo&vim + +let s:args_after = { + \ 'css': '-f json', + \ 'scss': '-f json -s scss' } + +function! SyntaxCheckers_css_stylelint_GetLocList() dict + let makeprg = self.makeprgBuild({ 'args_after': get(s:args_after, self.getFiletype(), '') }) + + let errorformat = '%t:%f:%l:%c:%m' + + return SyntasticMake({ + \ 'makeprg': makeprg, + \ 'errorformat': errorformat, + \ 'subtype': 'Style', + \ 'preprocess': 'stylelint', + \ 'returns': [0, 1, 2] }) +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'css', + \ 'name': 'stylelint'}) + +let &cpo = s:save_cpo +unlet s:save_cpo + +" vim: set sw=4 sts=4 et fdm=marker: + diff --git a/vim/bundle/syntastic/syntax_checkers/cucumber/cucumber.vim b/vim/bundle/syntastic/syntax_checkers/cucumber/cucumber.vim new file mode 100644 index 0000000..8a48690 --- /dev/null +++ b/vim/bundle/syntastic/syntax_checkers/cucumber/cucumber.vim @@ -0,0 +1,42 @@ +"============================================================================ +"File: cucumber.vim +"Description: Syntax checking plugin for syntastic.vim +"Maintainer: Martin Grenfell <martin.grenfell at gmail dot com> +"License: This program is free software. It comes without any warranty, +" to the extent permitted by applicable law. You can redistribute +" it and/or modify it under the terms of the Do What The Fuck You +" Want To Public License, Version 2, as published by Sam Hocevar. +" See http://sam.zoy.org/wtfpl/COPYING for more details. +" +"============================================================================ + +if exists('g:loaded_syntastic_cucumber_cucumber_checker') + finish +endif +let g:loaded_syntastic_cucumber_cucumber_checker = 1 + +let s:save_cpo = &cpo +set cpo&vim + +function! SyntaxCheckers_cucumber_cucumber_GetLocList() dict + let makeprg = self.makeprgBuild({ 'args_after': '--dry-run --quiet --strict --format pretty' }) + + let errorformat = + \ '%f:%l:%c:%m,' . + \ '%W %.%# (%m),' . + \ '%-Z%f:%l:%.%#,'. + \ '%-G%.%#' + + return SyntasticMake({ + \ 'makeprg': makeprg, + \ 'errorformat': errorformat }) +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'cucumber', + \ 'name': 'cucumber'}) + +let &cpo = s:save_cpo +unlet s:save_cpo + +" vim: set sw=4 sts=4 et fdm=marker: diff --git a/vim/bundle/syntastic/syntax_checkers/cuda/nvcc.vim b/vim/bundle/syntastic/syntax_checkers/cuda/nvcc.vim new file mode 100644 index 0000000..3476039 --- /dev/null +++ b/vim/bundle/syntastic/syntax_checkers/cuda/nvcc.vim @@ -0,0 +1,81 @@ +"============================================================================ +"File: cuda.vim +"Description: Syntax checking plugin for syntastic +"Author: Hannes Schulz <schulz at ais dot uni-bonn dot de> +" +"============================================================================ + +if exists('g:loaded_syntastic_cuda_nvcc_checker') + finish +endif +let g:loaded_syntastic_cuda_nvcc_checker = 1 + +if !exists('g:syntastic_cuda_config_file') + let g:syntastic_cuda_config_file = '.syntastic_cuda_config' +endif + +let s:save_cpo = &cpo +set cpo&vim + +function! SyntaxCheckers_cuda_nvcc_GetLocList() dict + let arch_flag = syntastic#util#var('cuda_arch') + if arch_flag !=# '' + let arch_flag = '-arch=' . arch_flag + call syntastic#log#oneTimeWarn('variable g:syntastic_cuda_arch is deprecated, ' . + \ 'please add ' . string(arch_flag) . ' to g:syntastic_cuda_nvcc_args instead') + endif + + let build_opts = {} + let dummy = '' + if index(['h', 'hpp', 'cuh'], expand('%:e', 1), 0, 1) >= 0 + if syntastic#util#var('cuda_check_header', 0) + let dummy = expand('%:p:h', 1) . syntastic#util#Slash() . '.syntastic_dummy.cu' + let build_opts = { + \ 'exe_before': 'echo > ' . syntastic#util#shescape(dummy) . ' ;', + \ 'fname_before': '.syntastic_dummy.cu -include' } + else + return [] + endif + endif + + call extend(build_opts, { + \ 'args_before': arch_flag . ' --cuda -O0 -I .', + \ 'args': syntastic#c#ReadConfig(g:syntastic_cuda_config_file), + \ 'args_after': '-Xcompiler -fsyntax-only', + \ 'tail_after': syntastic#c#NullOutput() }) + + let makeprg = self.makeprgBuild(build_opts) + + 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' + + let loclist = SyntasticMake({ 'makeprg': makeprg, 'errorformat': errorformat }) + + if dummy !=# '' + call delete(dummy) + endif + + return loclist +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'cuda', + \ 'name': 'nvcc'}) + +let &cpo = s:save_cpo +unlet s:save_cpo + +" vim: set sw=4 sts=4 et fdm=marker: diff --git a/vim/bundle/syntastic/syntax_checkers/d/dmd.vim b/vim/bundle/syntastic/syntax_checkers/d/dmd.vim new file mode 100644 index 0000000..8897995 --- /dev/null +++ b/vim/bundle/syntastic/syntax_checkers/d/dmd.vim @@ -0,0 +1,132 @@ +"============================================================================ +"File: d.vim +"Description: Syntax checking plugin for syntastic.vim +"Maintainer: Alfredo Di Napoli <alfredo dot dinapoli at gmail dot com> +"License: Based on the original work of Gregor Uhlenheuer and his +" cpp.vim checker so credits are dued. +" THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +" EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES +" OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +" NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT +" HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, +" WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING +" FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR +" OTHER DEALINGS IN THE SOFTWARE. +" +"============================================================================ + +if exists('g:loaded_syntastic_d_dmd_checker') + finish +endif +let g:loaded_syntastic_d_dmd_checker = 1 + +if !exists('g:syntastic_d_compiler_options') + let g:syntastic_d_compiler_options = '' +endif + +if !exists('g:syntastic_d_use_dub') + let g:syntastic_d_use_dub = 1 +endif + +if !exists('g:syntastic_d_dub_exec') + let g:syntastic_d_dub_exec = 'dub' +endif + +let s:save_cpo = &cpo +set cpo&vim + +function! SyntaxCheckers_d_dmd_IsAvailable() dict " {{{1 + if !exists('g:syntastic_d_compiler') + let g:syntastic_d_compiler = self.getExec() + endif + call self.log('g:syntastic_d_compiler =', g:syntastic_d_compiler) + return executable(expand(g:syntastic_d_compiler, 1)) +endfunction " }}}1 + +function! SyntaxCheckers_d_dmd_GetLocList() dict " {{{1 + if !exists('g:syntastic_d_include_dirs') + let g:syntastic_d_include_dirs = s:GetIncludes(self, expand('%:p:h')) + endif + + return syntastic#c#GetLocList('d', 'dmd', { + \ 'errorformat': + \ '%-G%f:%s:,%f(%l): %m,' . + \ '%f:%l: %m', + \ 'main_flags': '-c -of' . syntastic#util#DevNull(), + \ 'header_names': '\m\.di$' }) +endfunction " }}}1 + +" Utilities {{{1 + +function! s:GetIncludes(checker, base) " {{{2 + let includes = [] + + if g:syntastic_d_use_dub && !exists('s:dub_ok') + let s:dub_ok = s:ValidateDub(a:checker) + endif + + if g:syntastic_d_use_dub && s:dub_ok + let where = escape(a:base, ' ') . ';' + + let old_suffixesadd = &suffixesadd + let dirs = syntastic#util#unique(map(filter( + \ findfile('dub.json', where, -1) + + \ findfile('dub.sdl', where, -1) + + \ findfile('package.json', where, -1), + \ 'filereadable(v:val)'), 'fnamemodify(v:val, ":h")')) + let &suffixesadd = old_suffixesadd + call a:checker.log('using dub: looking for includes in', dirs) + + for dir in dirs + try + execute 'silent lcd ' . fnameescape(dir) + let paths = split(syntastic#util#system(syntastic#util#shescape(g:syntastic_d_dub_exec) . ' describe --import-paths'), "\n") + silent lcd - + if v:shell_error == 0 + call extend(includes, paths) + call a:checker.log('using dub: found includes', paths) + endif + catch /\m^Vim\%((\a\+)\)\=:E472/ + " evil directory is evil + endtry + endfor + endif + + if empty(includes) + let includes = filter(glob($HOME . '/.dub/packages/*', 1, 1), 'isdirectory(v:val)') + call map(includes, 'isdirectory(v:val . "/source") ? v:val . "/source" : v:val') + call add(includes, './source') + endif + + return syntastic#util#unique(includes) +endfunction " }}}2 + +function! s:ValidateDub(checker) " {{{2 + let ok = 0 + + if executable(g:syntastic_d_dub_exec) + let command = syntastic#util#shescape(g:syntastic_d_dub_exec) . ' --version' + let version_output = syntastic#util#system(command) + call a:checker.log('getVersion: ' . string(command) . ': ' . + \ string(split(version_output, "\n", 1)) . + \ (v:shell_error ? ' (exit code ' . v:shell_error . ')' : '') ) + let parsed_ver = syntastic#util#parseVersion(version_output) + call a:checker.log(g:syntastic_d_dub_exec . ' version =', parsed_ver) + if len(parsed_ver) + let ok = syntastic#util#versionIsAtLeast(parsed_ver, [0, 9, 24]) + endif + endif + + return ok +endfunction " }}}2 + +" }}}1 + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'd', + \ 'name': 'dmd' }) + +let &cpo = s:save_cpo +unlet s:save_cpo + +" vim: set sw=4 sts=4 et fdm=marker: diff --git a/vim/bundle/syntastic/syntax_checkers/dart/dartanalyzer.vim b/vim/bundle/syntastic/syntax_checkers/dart/dartanalyzer.vim new file mode 100644 index 0000000..63b8267 --- /dev/null +++ b/vim/bundle/syntastic/syntax_checkers/dart/dartanalyzer.vim @@ -0,0 +1,76 @@ +"============================================================================ +"File: dartanalyzer.vim +"Description: Dart syntax checker - using dartanalyzer +"Maintainer: Maksim Ryzhikov <rv.maksim at gmail dot com> +"License: This program is free software. It comes without any warranty, +" to the extent permitted by applicable law. You can redistribute +" it and/or modify it under the terms of the Do What The Fuck You +" Want To Public License, Version 2, as published by Sam Hocevar. +" See http://sam.zoy.org/wtfpl/COPYING for more details. +"============================================================================ + +if exists('g:loaded_syntastic_dart_dartanalyzer_checker') + finish +endif +let g:loaded_syntastic_dart_dartanalyzer_checker = 1 + +let s:save_cpo = &cpo +set cpo&vim + +function! SyntaxCheckers_dart_dartanalyzer_GetHighlightRegex(error) + if a:error['len'] + let lcol = a:error['col'] - 1 + let rcol = a:error['col'] + a:error['len'] + let ret = '\%>' . lcol . 'c\%<' . rcol . 'c' + else + let ret = '' + endif + + return ret +endfunction + +function! SyntaxCheckers_dart_dartanalyzer_GetLocList() dict + let makeprg = self.makeprgBuild({ 'args_after': '--machine' }) + + " Machine readable format looks like: + " SEVERITY|TYPE|ERROR_CODE|FILENAME|LINE_NUMBER|COLUMN|LENGTH|MESSAGE + " SEVERITY: (WARNING|ERROR) + " TYPE: (RESOLVER|STATIC_TYPE|...) + " ERROR_CODE: (NO_SUCH_TYPE|...) + " FILENAME: String + " LINE_NUMBER: int + " COLUMN: int + " LENGTH: int + " MESSAGE: String + + " We use %n to grab the error length, for the syntax highlighter + let commonformat = '|%.%#|%.%#|%f|%l|%c|%n|%m' + + let errorformat = + \ '%EERROR' . commonformat . ',' . + \ '%WWARNING' . commonformat + + let loclist = SyntasticMake({ + \ 'makeprg': makeprg, + \ 'errorformat': errorformat, + \ 'returns': [0, 1, 2, 3] }) + + for e in loclist + let e['text'] = substitute(e['text'], '\m\\\([\\|]\)', '\1', 'g') + + " Undo the %n hack + let e['len'] = e['nr'] + call remove(e, 'nr') + endfor + + return loclist +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'dart', + \ 'name': 'dartanalyzer' }) + +let &cpo = s:save_cpo +unlet s:save_cpo + +" vim: set sw=4 sts=4 et fdm=marker: diff --git a/vim/bundle/syntastic/syntax_checkers/docbk/igor.vim b/vim/bundle/syntastic/syntax_checkers/docbk/igor.vim new file mode 100644 index 0000000..5448861 --- /dev/null +++ b/vim/bundle/syntastic/syntax_checkers/docbk/igor.vim @@ -0,0 +1,55 @@ +"============================================================================ +"File: igor.vim +"Description: Syntax checking plugin for syntastic.vim +"Maintainer: LCD 47 <lcd047 at gmail dot com> +"License: This program is free software. It comes without any warranty, +" to the extent permitted by applicable law. You can redistribute +" it and/or modify it under the terms of the Do What The Fuck You +" Want To Public License, Version 2, as published by Sam Hocevar. +" See http://sam.zoy.org/wtfpl/COPYING for more details. +" +"============================================================================ + +if exists('g:loaded_syntastic_docbk_igor_checker') + finish +endif +let g:loaded_syntastic_docbk_igor_checker = 1 + +let s:save_cpo = &cpo +set cpo&vim + +function! SyntaxCheckers_docbk_igor_GetLocList() dict + let makeprg = self.makeprgBuild({}) + + let errorformat = '%f:%l:%m' + + let loclist = SyntasticMake({ + \ 'makeprg': makeprg, + \ 'errorformat': errorformat, + \ 'defaults': { 'type': 'W' }, + \ 'subtype': 'Style', + \ 'returns': [0] }) + + let buf = bufnr('') + for e in loclist + " XXX: igor strips directories from filenames + let e['bufnr'] = buf + + let e['hl'] = '\V' . escape( substitute(e['text'], '\m[^:]*:', '', ''), '\' ) + let e['hl'] = substitute(e['hl'], '\V[', '\\zs', 'g') + let e['hl'] = substitute(e['hl'], '\V]', '\\ze', 'g') + + " let e['text'] = substitute(e['text'], '\m:.*$', '', '') + endfor + + return loclist +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'docbk', + \ 'name': 'igor'}) + +let &cpo = s:save_cpo +unlet s:save_cpo + +" vim: set sw=4 sts=4 et fdm=marker: diff --git a/vim/bundle/syntastic/syntax_checkers/docbk/xmllint.vim b/vim/bundle/syntastic/syntax_checkers/docbk/xmllint.vim new file mode 100644 index 0000000..30d66d2 --- /dev/null +++ b/vim/bundle/syntastic/syntax_checkers/docbk/xmllint.vim @@ -0,0 +1,23 @@ +"============================================================================ +"File: docbk.vim +"Description: Syntax checking plugin for syntastic.vim +"Maintainer: Martin Grenfell <martin.grenfell at gmail dot com> +"License: This program is free software. It comes without any warranty, +" to the extent permitted by applicable law. You can redistribute +" it and/or modify it under the terms of the Do What The Fuck You +" Want To Public License, Version 2, as published by Sam Hocevar. +" See http://sam.zoy.org/wtfpl/COPYING for more details. +" +"============================================================================ + +if exists('g:loaded_syntastic_docbk_xmllint_checker') + finish +endif +let g:loaded_syntastic_docbk_xmllint_checker = 1 + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'docbk', + \ 'name': 'xmllint', + \ 'redirect': 'xml/xmllint'}) + +" vim: set sw=4 sts=4 et fdm=marker: diff --git a/vim/bundle/syntastic/syntax_checkers/dockerfile/dockerfile_lint.vim b/vim/bundle/syntastic/syntax_checkers/dockerfile/dockerfile_lint.vim new file mode 100644 index 0000000..3a5b769 --- /dev/null +++ b/vim/bundle/syntastic/syntax_checkers/dockerfile/dockerfile_lint.vim @@ -0,0 +1,53 @@ +"============================================================================ +"File: dockerfile_lint.vim +"Description: Syntax checking plugin for syntastic.vim using dockerfile-lint +" (https://github.com/projectatomic/dockerfile-lint). +"Maintainer: Tim Carry <tim at pixelastic dot com> +"License: This program is free software. It comes without any warranty, +" to the extent permitted by applicable law. You can redistribute +" it and/or modify it under the terms of the Do What The Fuck You +" Want To Public License, Version 2, as published by Sam Hocevar. +" See http://sam.zoy.org/wtfpl/COPYING for more details. +" +"============================================================================ + +if exists('g:loaded_syntastic_dockerfile_dockerfile_lint_checker') + finish +endif +let g:loaded_syntastic_dockerfile_dockerfile_lint_checker = 1 + +let s:save_cpo = &cpo +set cpo&vim + +function! SyntaxCheckers_dockerfile_dockerfile_lint_GetLocList() dict + let makeprg = self.makeprgBuild({ + \ 'args_after': '-j', + \ 'fname_before': '-f' }) + + let errorformat = '%t:%n:%l:%m' + + let loclist = SyntasticMake({ + \ 'makeprg': makeprg, + \ 'errorformat': errorformat, + \ 'preprocess': 'dockerfile_lint', + \ 'defaults': {'bufnr': bufnr('')}, + \ 'returns': [0, 1] }) + + for e in loclist + if e['nr'] + let e['subtype'] = 'Style' + endif + call remove(e, 'nr') + endfor + + return loclist +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'dockerfile', + \ 'name': 'dockerfile_lint'}) + +let &cpo = s:save_cpo +unlet s:save_cpo + +" vim: set sw=4 sts=4 et fdm=marker: diff --git a/vim/bundle/syntastic/syntax_checkers/dustjs/swiffer.vim b/vim/bundle/syntastic/syntax_checkers/dustjs/swiffer.vim new file mode 100644 index 0000000..8edf1d5 --- /dev/null +++ b/vim/bundle/syntastic/syntax_checkers/dustjs/swiffer.vim @@ -0,0 +1,38 @@ +"============================================================================ +"File: swiffer.vim +"Description: Dust.js syntax checker - using swiffer +"Maintainer: Steven Foote <smfoote at gmail dot com> +"License: This program is free software. It comes without any warranty, +" to the extent permitted by applicable law. You can redistribute +" it and/or modify it under the terms of the Do What The Fuck You +" Want To Public License, Version 2, as published by Sam Hocevar. +" See http://sam.zoy.org/wtfpl/COPYING for more details. +"============================================================================ + +if exists('g:loaded_syntastic_dustjs_swiffer_checker') + finish +endif + +let g:loaded_syntastic_dustjs_swiffer_checker = 1 + +let s:save_cpo = &cpo +set cpo&vim + +function! SyntaxCheckers_dustjs_swiffer_GetLocList() dict + let makeprg = self.makeprgBuild({}) + + let errorformat = '%E%f - Line %l\, Column %c: %m' + + return SyntasticMake({ + \ 'makeprg': makeprg, + \ 'errorformat': errorformat }) + endfunction + +call SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'dustjs', + \ 'name': 'swiffer'}) + +let &cpo = s:save_cpo +unlet s:save_cpo + +" vim: set sw=4 sts=4 et fdm=marker: diff --git a/vim/bundle/syntastic/syntax_checkers/elixir/elixir.vim b/vim/bundle/syntastic/syntax_checkers/elixir/elixir.vim new file mode 100644 index 0000000..f2ffe67 --- /dev/null +++ b/vim/bundle/syntastic/syntax_checkers/elixir/elixir.vim @@ -0,0 +1,56 @@ +"============================================================================ +"File: elixir.vim +"Description: Syntax checking plugin for syntastic.vim +"Maintainer: Richard Ramsden <rramsden at gmail dot com> +"License: This program is free software. It comes without any warranty, +" to the extent permitted by applicable law. You can redistribute +" it and/or modify it under the terms of the Do What The Fuck You +" Want To Public License, Version 2, as published by Sam Hocevar. +" See http://sam.zoy.org/wtfpl/COPYING for more details. +" +"============================================================================ + +if exists('g:loaded_syntastic_elixir_elixir_checker') + finish +endif +let g:loaded_syntastic_elixir_elixir_checker = 1 + +let s:save_cpo = &cpo +set cpo&vim + +" TODO: we should probably split this into separate checkers +function! SyntaxCheckers_elixir_elixir_IsAvailable() dict + call self.log( + \ 'executable("elixir") = ' . executable('elixir') . ', ' . + \ 'executable("mix") = ' . executable('mix')) + return executable('elixir') && executable('mix') +endfunction + +function! SyntaxCheckers_elixir_elixir_GetLocList() dict + let make_options = {} + let compile_command = 'elixir' + let mix_file = syntastic#util#findFileInParent('mix.exs', expand('%:p:h', 1)) + + if filereadable(mix_file) + let compile_command = 'mix compile' + let make_options['cwd'] = fnamemodify(mix_file, ':p:h') + endif + + let make_options['makeprg'] = self.makeprgBuild({ 'exe': compile_command }) + + let make_options['errorformat'] = + \ '%E** %*[^\ ] %f:%l: %m,' . + \ '%W%f:%l: warning: %m' + + return SyntasticMake(make_options) +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'elixir', + \ 'name': 'elixir', + \ 'enable': 'enable_elixir_checker'}) + +let &cpo = s:save_cpo +unlet s:save_cpo + +" vim: set sw=4 sts=4 et fdm=marker: diff --git a/vim/bundle/syntastic/syntax_checkers/erlang/erlang_check_file.erl b/vim/bundle/syntastic/syntax_checkers/erlang/erlang_check_file.erl new file mode 100755 index 0000000..730e600 --- /dev/null +++ b/vim/bundle/syntastic/syntax_checkers/erlang/erlang_check_file.erl @@ -0,0 +1,95 @@ +#!/usr/bin/env escript + +main([File]) -> + Dir = get_root(filename:dirname(File)), + Defs = [strong_validation, + warn_export_all, + warn_export_vars, + warn_shadow_vars, + warn_obsolete_guard, + warn_unused_import, + report, + {i, Dir ++ "/include"}], + %% `rebar.config` is looked for, + %% but it is not necessarily the one in the project root. + %% I.e. it may be one deeper in the project file hierarchy. + RebarFile = rebar_file(Dir), + %% `rebar.config` might contain relative paths. + %% They are relative to the file! Not to the project root. + RebarOpts = rebar_opts(Dir ++ "/" ++ RebarFile), + code:add_patha(filename:absname("ebin")), + %% `compile:file/2` requires the `{i, Path}` to be relative + %% to CWD - no surprise here. + compile:file(File, Defs ++ translate_paths(Dir, RebarOpts)); + +main(_) -> + io:format("Usage: ~s <file>~n", [escript:script_name()]), + halt(1). + +rebar_file(Dir) -> + DirList = filename:split(Dir), + case lists:last(DirList) of + "test" -> + "rebar.test.config"; + _ -> + "rebar.config" + end. + +rebar_opts(RebarFile) -> + Dir = get_root(filename:dirname(RebarFile)), + case file:consult(RebarFile) of + {ok, Terms} -> + RebarLibDirs = proplists:get_value(lib_dirs, Terms, []), + lists:foreach( + fun(LibDir) -> + code:add_pathsa(filelib:wildcard(LibDir ++ "/*/ebin")) + end, RebarLibDirs), + RebarDepsDir = proplists:get_value(deps_dir, Terms, "deps"), + code:add_pathsa(filelib:wildcard(RebarDepsDir ++ "/*/ebin")), + IncludeDeps = {i, filename:join(Dir, RebarDepsDir)}, + proplists:get_value(erl_opts, Terms, []) ++ [IncludeDeps]; + {error, _} when RebarFile == "rebar.config" -> + fallback_opts(); + {error, _} -> + rebar_opts("rebar.config") + end. + +fallback_opts() -> + code:add_pathsa(filelib:wildcard("deps/*/ebin")), + code:add_pathsa(nested_app_ebins()), + [ + { i, filename:absname("apps") }, { i, filename:absname("deps") } | [ { i, filename:absname(Path) } || Path <- filelib:wildcard("deps/*/apps")] + ]. + +nested_app_ebins() -> + DetectedAppSrcFiles = filelib:wildcard("deps/*/apps/**/*.app.src"), + [apps_dir_from_src(AppSrcFile)||AppSrcFile<-DetectedAppSrcFiles]. + +apps_dir_from_src(SrcFile) -> + SrcDir = filename:dirname(SrcFile), + filename:join(SrcDir, "../../ebin"). + +get_root(Dir) -> + Path = filename:split(filename:absname(Dir)), + filename:join(get_root(lists:reverse(Path), Path)). + +get_root([], Path) -> + Path; +get_root(["src" | Tail], _Path) -> + lists:reverse(Tail); +get_root(["test" | Tail], _Path) -> + lists:reverse(Tail); +get_root([_ | Tail], Path) -> + get_root(Tail, Path). + +translate_paths(Dir, RebarOpts) -> + [ translate_path(Dir, Opt) || Opt <- RebarOpts ]. + +translate_path(Dir, {i, Path}) -> + case Path of + %% absolute + "/" ++ _ -> {i, Path}; + %% relative -> make absolute taking rebar.config location into account + _ -> {i, filename:join([Dir, Path])} + end; +translate_path(_, Other) -> Other. diff --git a/vim/bundle/syntastic/syntax_checkers/erlang/escript.vim b/vim/bundle/syntastic/syntax_checkers/erlang/escript.vim new file mode 100644 index 0000000..9fd869f --- /dev/null +++ b/vim/bundle/syntastic/syntax_checkers/erlang/escript.vim @@ -0,0 +1,61 @@ +"============================================================================ +"File: erlang.vim +"Description: Syntax checking plugin for syntastic.vim +"Maintainer: Pawel Salata <rockplayer.pl at gmail dot com> +"License: This program is free software. It comes without any warranty, +" to the extent permitted by applicable law. You can redistribute +" it and/or modify it under the terms of the Do What The Fuck You +" Want To Public License, Version 2, as published by Sam Hocevar. +" See http://sam.zoy.org/wtfpl/COPYING for more details. +" +"============================================================================ + +if exists('g:loaded_syntastic_erlang_erlang_checker') + finish +endif +let g:loaded_syntastic_erlang_erlang_checker = 1 + +if !exists('g:syntastic_erlc_include_path') + let g:syntastic_erlc_include_path = '' +endif + +let s:check_file = syntastic#util#shescape(expand('<sfile>:p:h', 1) . syntastic#util#Slash() . 'erlang_check_file.erl') + +let s:save_cpo = &cpo +set cpo&vim + +function! SyntaxCheckers_erlang_escript_GetLocList() dict + if expand('%:e', 1) ==# 'hrl' + return [] + endif + + let shebang = syntastic#util#parseShebang() + if shebang['exe'] ==# 'escript' + let args = '-s' + let post_args = '' + else + let args = s:check_file + let post_args = g:syntastic_erlc_include_path + endif + let makeprg = self.makeprgBuild({ + \ 'args_after': args, + \ 'fname': syntastic#util#shexpand('%:p'), + \ 'post_args_after': post_args }) + + let errorformat = + \ '%W%f:%l: warning: %m,'. + \ '%E%f:%l: %m' + + return SyntasticMake({ + \ 'makeprg': makeprg, + \ 'errorformat': errorformat }) +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'erlang', + \ 'name': 'escript'}) + +let &cpo = s:save_cpo +unlet s:save_cpo + +" vim: set sw=4 sts=4 et fdm=marker: diff --git a/vim/bundle/syntastic/syntax_checkers/erlang/syntaxerl.vim b/vim/bundle/syntastic/syntax_checkers/erlang/syntaxerl.vim new file mode 100644 index 0000000..45f4735 --- /dev/null +++ b/vim/bundle/syntastic/syntax_checkers/erlang/syntaxerl.vim @@ -0,0 +1,42 @@ +"============================================================================ +"File: syntaxerl.vim +"Description: Syntax checking plugin for syntastic. +"Maintainer: locojay +"License: This program is free software. It comes without any warranty, +" to the extent permitted by applicable law. You can redistribute +" it and/or modify it under the terms of the Do What The Fuck You +" Want To Public License, Version 2, as published by Sam Hocevar. +" See http://sam.zoy.org/wtfpl/COPYING for more details. +"============================================================================ + +if exists('g:loaded_syntastic_erlang_syntaxerl_checker') + finish +endif + +let g:loaded_syntastic_erlang_syntaxerl_checker = 1 + +let s:save_cpo = &cpo +set cpo&vim + + +function! SyntaxCheckers_erlang_syntaxerl_GetLocList() dict + + let makeprg = self.makeprgBuild({}) + + let errorformat = + \ '%W%f:%l: warning: %m,'. + \ '%E%f:%l: %m' + + return SyntasticMake({ + \ 'makeprg': makeprg, + \ 'errorformat': errorformat }) +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'erlang', + \ 'name': 'syntaxerl'}) + +let &cpo = s:save_cpo +unlet s:save_cpo + +" vim: set sw=4 sts=4 et fdm=marker: diff --git a/vim/bundle/syntastic/syntax_checkers/eruby/ruby.vim b/vim/bundle/syntastic/syntax_checkers/eruby/ruby.vim new file mode 100644 index 0000000..16eed62 --- /dev/null +++ b/vim/bundle/syntastic/syntax_checkers/eruby/ruby.vim @@ -0,0 +1,82 @@ +"============================================================================ +"File: ruby.vim +"Description: Syntax checking plugin for syntastic.vim +"Maintainer: Martin Grenfell <martin.grenfell at gmail dot com> +"License: This program is free software. It comes without any warranty, +" to the extent permitted by applicable law. You can redistribute +" it and/or modify it under the terms of the Do What The Fuck You +" Want To Public License, Version 2, as published by Sam Hocevar. +" See http://sam.zoy.org/wtfpl/COPYING for more details. +" +"============================================================================ + +if exists('g:loaded_syntastic_eruby_ruby_checker') + finish +endif +let g:loaded_syntastic_eruby_ruby_checker = 1 + +let s:save_cpo = &cpo +set cpo&vim + +function! SyntaxCheckers_eruby_ruby_IsAvailable() dict + if !exists('g:syntastic_eruby_ruby_exec') && exists('g:syntastic_ruby_exec') + let g:syntastic_eruby_ruby_exec = g:syntastic_ruby_exec + call self.log('g:syntastic_eruby_ruby_exec =', g:syntastic_eruby_ruby_exec) + endif + return executable(self.getExec()) +endfunction + +function! SyntaxCheckers_eruby_ruby_GetLocList() dict + if !exists('s:ruby_new') + let s:ruby_new = syntastic#util#versionIsAtLeast(self.getVersion(), [1, 9]) + endif + + let fname = "'" . escape(expand('%', 1), "\\'") . "'" + + " TODO: encodings became useful in ruby 1.9 :) + if s:ruby_new + 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 = + \ self.getExecEscaped() . ' -rerb -e ' . + \ syntastic#util#shescape('puts ERB.new(File.read(' . + \ fname . encoding_spec . + \ ').gsub(''<%='',''<%''), nil, ''-'').src') . + \ ' | ' . self.getExecEscaped() . ' -w -c' + + let errorformat = '%-G%\m%.%#warning: %\%%(possibly %\)%\?useless use of a literal 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-:%l: syntax error\, %m,%Z%p^,'. + \ '%W-:%l: warning: %m,'. + \ '%Z%p^,'. + \ '%-C%.%#' + + let env = syntastic#util#isRunningWindows() ? {} : { 'RUBYOPT': '' } + + return SyntasticMake({ + \ 'makeprg': makeprg, + \ 'errorformat': errorformat, + \ 'env': env, + \ 'defaults': { 'bufnr': bufnr(''), 'vcol': 1 } }) +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'eruby', + \ 'name': 'ruby'}) + +let &cpo = s:save_cpo +unlet s:save_cpo + +" vim: set sw=4 sts=4 et fdm=marker: diff --git a/vim/bundle/syntastic/syntax_checkers/fortran/gfortran.vim b/vim/bundle/syntastic/syntax_checkers/fortran/gfortran.vim new file mode 100644 index 0000000..fffaf30 --- /dev/null +++ b/vim/bundle/syntastic/syntax_checkers/fortran/gfortran.vim @@ -0,0 +1,99 @@ +"============================================================================ +"File: fortran.vim +"Description: Syntax checking plugin for syntastic.vim +"Maintainer: Karl Yngve Lervåg <karl.yngve@lervag.net> +"License: This program is free software. It comes without any warranty, +" to the extent permitted by applicable law. You can redistribute +" it and/or modify it under the terms of the Do What The Fuck You +" Want To Public License, Version 2, as published by Sam Hocevar. +" See http://sam.zoy.org/wtfpl/COPYING for more details. +" +"============================================================================ + +if exists('g:loaded_syntastic_fortran_gfortran_checker') + finish +endif +let g:loaded_syntastic_fortran_gfortran_checker = 1 + +if !exists('g:syntastic_fortran_compiler_options') + let g:syntastic_fortran_compiler_options = '' +endif + +let s:type_map = {} + +let s:save_cpo = &cpo +set cpo&vim + +function! SyntaxCheckers_fortran_gfortran_IsAvailable() dict " {{{1 + if !exists('g:syntastic_fortran_compiler') + let g:syntastic_fortran_compiler = self.getExec() + endif + call self.log('g:syntastic_fortran_compiler = ', g:syntastic_fortran_compiler) + return executable(expand(g:syntastic_fortran_compiler, 1)) +endfunction " }}}1 + +" @vimlint(EVL104, 1, l:errorformat) +function! SyntaxCheckers_fortran_gfortran_GetLocList() dict " {{{1 + call s:SetCompilerType(g:syntastic_fortran_compiler) + if !has_key(s:type_map, g:syntastic_fortran_compiler) + call syntastic#log#error("checker fortran/gfortran: can't parse version string (abnormal termination?)") + return [] + endif + + if s:type_map[g:syntastic_fortran_compiler] ==# 'gfortran' + let errorformat = + \ '%-C %#,'. + \ '%-C %#%.%#,'. + \ '%A%f:%l%[.:]%c:,'. + \ '%Z%\m%\%%(Fatal %\)%\?%trror: %m,'. + \ '%Z%tarning: %m,'. + \ '%-G%.%#' + if !exists('g:syntastic_fortran_gfortran_sort') + let g:syntastic_fortran_gfortran_sort = 0 + endif + elseif s:type_map[g:syntastic_fortran_compiler] ==# 'ifort' + let errorformat = + \ '%E%f(%l): error #%n: %m,'. + \ '%W%f(%l): warning #%n: %m,'. + \ '%W%f(%l): remark #%n: %m,'. + \ '%-Z%p^,'. + \ '%-G%.%#' + if !exists('g:syntastic_fortran_gfortran_sort') + let g:syntastic_fortran_gfortran_sort = 1 + endif + endif + + return syntastic#c#GetLocList('fortran', 'gfortran', { + \ 'errorformat': errorformat, + \ 'main_flags': '-fsyntax-only' }) +endfunction " }}}1 +" @vimlint(EVL104, 0, l:errorformat) + +" Utilities {{{1 + +function! s:SetCompilerType(exe) " {{{2 + if !has_key(s:type_map, a:exe) + try + let ver = filter( split(syntastic#util#system(syntastic#util#shescape(a:exe) . ' --version'), '\n'), + \ 'v:val =~# "\\v^%(GNU Fortran|ifort) "' )[0] + if ver =~# '\m^GNU Fortran ' + let s:type_map[a:exe] = 'gfortran' + elseif ver =~# '\m^ifort ' + let s:type_map[a:exe] = 'ifort' + endif + catch /\m^Vim\%((\a\+)\)\=:E684/ + " do nothing + endtry + endif +endfunction " }}}2 + +" }}} + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'fortran', + \ 'name': 'gfortran' }) + +let &cpo = s:save_cpo +unlet s:save_cpo + +" vim: set sw=4 sts=4 et fdm=marker: diff --git a/vim/bundle/syntastic/syntax_checkers/glsl/cgc.vim b/vim/bundle/syntastic/syntax_checkers/glsl/cgc.vim new file mode 100644 index 0000000..602399d --- /dev/null +++ b/vim/bundle/syntastic/syntax_checkers/glsl/cgc.vim @@ -0,0 +1,81 @@ +"============================================================================ +"File: glsl.vim +"Description: Syntax checker for OpenGL Shading Language +"Maintainer: Joshua Rahm <joshuarahm@gmail.com> +"License: This program is free software. It comes without any warranty, +" to the extent permitted by applicable law. You can redistribute +" it and/or modify it under the terms of the Do What The Fuck You +" Want To Public License, Version 2, as published by Sam Hocevar. +" See http://sam.zoy.org/wtfpl/COPYING for more details. +" +"============================================================================ + +if exists('g:loaded_syntastic_glsl_cgc_checker') + finish +endif +let g:loaded_syntastic_glsl_cgc_checker = 1 + +let s:glsl_extensions = { + \ 'glslf': 'gpu_fp', + \ 'glslv': 'gpu_vp', + \ 'frag': 'gpu_fp', + \ 'vert': 'gpu_vp', + \ 'fp': 'gpu_fp', + \ 'vp': 'gpu_vp' + \ } + +let s:save_cpo = &cpo +set cpo&vim + +function! SyntaxCheckers_glsl_cgc_GetLocList() dict " {{{1 + let makeprg = self.makeprgBuild({ + \ 'args_before': '-oglsl -profile ' . s:GetProfile(), + \ 'args': (exists('g:syntastic_glsl_options') ? ' ' . g:syntastic_glsl_options : '') }) + + let errorformat = + \ '%E%f(%l) : error %m,' . + \ '%W%f(%l) : warning %m' + + return SyntasticMake({ + \ 'makeprg': makeprg, + \ 'errorformat': errorformat }) +endfunction " }}}1 + +" Utilities {{{1 + +function! s:GetProfile() " {{{2 + let save_view = winsaveview() + let old_foldenable = &foldenable + let old_lazyredraw = &lazyredraw + + let &lazyredraw = 1 + let &foldenable = 0 + call cursor(1, 1) + + let magic = '\m\C^// profile:\s*' + let line = search(magic, 'c') + + call winrestview(save_view) + let &foldenable = old_foldenable + let &lazyredraw = old_lazyredraw + + if line + let profile = matchstr(getline(line), magic . '\zs.*') + else + let extensions = exists('g:syntastic_glsl_extensions') ? g:syntastic_glsl_extensions : s:glsl_extensions + let profile = get(extensions, tolower(expand('%:e', 1)), 'gpu_vert') + endif + + return profile +endfunction " }}}2 + +" }}}1 + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \'filetype': 'glsl', + \'name': 'cgc'}) + +let &cpo = s:save_cpo +unlet s:save_cpo + +" vim: set sw=4 sts=4 et fdm=marker: diff --git a/vim/bundle/syntastic/syntax_checkers/go/go.vim b/vim/bundle/syntastic/syntax_checkers/go/go.vim new file mode 100644 index 0000000..f32f505 --- /dev/null +++ b/vim/bundle/syntastic/syntax_checkers/go/go.vim @@ -0,0 +1,103 @@ +"============================================================================ +"File: go.vim +"Description: Check go syntax using 'gofmt -l' followed by 'go [build|test]' +"Maintainer: Kamil Kisiel <kamil@kamilkisiel.net> +"License: This program is free software. It comes without any warranty, +" to the extent permitted by applicable law. You can redistribute +" it and/or modify it under the terms of the Do What The Fuck You +" Want To Public License, Version 2, as published by Sam Hocevar. +" See http://sam.zoy.org/wtfpl/COPYING for more details. +" +"============================================================================ +" +" This syntax checker does not reformat your source code. +" Use a BufWritePre autocommand to that end: +" autocmd FileType go autocmd BufWritePre <buffer> Fmt + +if exists('g:loaded_syntastic_go_go_checker') + finish +endif +let g:loaded_syntastic_go_go_checker = 1 + +let s:save_cpo = &cpo +set cpo&vim + +function! SyntaxCheckers_go_go_IsAvailable() dict + return executable(self.getExec()) && executable('gofmt') +endfunction + +function! SyntaxCheckers_go_go_GetLocList() dict + if !exists('s:go_new') + let s:go_new = syntastic#util#versionIsAtLeast(self.getVersion(self.getExecEscaped() . ' version'), [1, 5]) + endif + + " Check with gofmt first, since `go build` and `go test` might not report + " syntax errors in the current file if another file with syntax error is + " compiled first. + let makeprg = self.makeprgBuild({ + \ 'exe': 'gofmt', + \ 'args': '-l', + \ 'tail': '> ' . syntastic#util#DevNull() }) + + let errorformat = + \ '%f:%l:%c: %m,' . + \ '%-G%.%#' + + let errors = SyntasticMake({ + \ 'makeprg': makeprg, + \ 'errorformat': errorformat, + \ 'defaults': {'type': 'e'} }) + if !empty(errors) + return errors + endif + + " Test files, i.e. files with a name ending in `_test.go`, are not + " compiled by `go build`, therefore `go test` must be called for those. + if match(expand('%', 1), '\m_test\.go$') == -1 + let cmd = 'build' + let opts = syntastic#util#var('go_go_build_args', s:go_new ? '-buildmode=archive' : '') + let cleanup = 0 + else + let cmd = 'test -c' + let opts = syntastic#util#var('go_go_test_args', s:go_new ? '-buildmode=archive' : '') + let cleanup = 1 + endif + let opt_str = (type(opts) != type('') || opts !=# '') ? join(syntastic#util#argsescape(opts)) : opts + let makeprg = self.getExecEscaped() . ' ' . cmd . ' ' . opt_str + + " The first pattern is for warnings from C compilers. + let errorformat = + \ '%W%f:%l: warning: %m,' . + \ '%E%f:%l:%c:%m,' . + \ '%E%f:%l:%m,' . + \ '%C%\s%\+%m,' . + \ '%+Ecan''t load package: %m,' . + \ '%+Einternal error: %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', 1), + \ 'env': {'GOGC': 'off'}, + \ 'defaults': {'type': 'e'} }) + + if cleanup + call delete(expand('%:p:h', 1) . syntastic#util#Slash() . expand('%:p:h:t', 1) . '.test') + endif + + return errors +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'go', + \ 'name': 'go'}) + +let &cpo = s:save_cpo +unlet s:save_cpo + +" vim: set sw=4 sts=4 et fdm=marker: diff --git a/vim/bundle/syntastic/syntax_checkers/go/gofmt.vim b/vim/bundle/syntastic/syntax_checkers/go/gofmt.vim new file mode 100644 index 0000000..bdb6218 --- /dev/null +++ b/vim/bundle/syntastic/syntax_checkers/go/gofmt.vim @@ -0,0 +1,45 @@ +"============================================================================ +"File: gofmt.vim +"Description: Check go syntax using 'gofmt -l' +"Maintainer: Brandon Thomson <bt@brandonthomson.com> +"License: This program is free software. It comes without any warranty, +" to the extent permitted by applicable law. You can redistribute +" it and/or modify it under the terms of the Do What The Fuck You +" Want To Public License, Version 2, as published by Sam Hocevar. +" See http://sam.zoy.org/wtfpl/COPYING for more details. +" +"============================================================================ +" +" This syntax checker does not reformat your source code. +" Use a BufWritePre autocommand to that end: +" autocmd FileType go autocmd BufWritePre <buffer> Fmt + +if exists('g:loaded_syntastic_go_gofmt_checker') + finish +endif +let g:loaded_syntastic_go_gofmt_checker = 1 + +let s:save_cpo = &cpo +set cpo&vim + +function! SyntaxCheckers_go_gofmt_GetLocList() dict + let makeprg = self.makeprgBuild({ + \ 'args_after': '-l', + \ 'tail_after': '> ' . syntastic#util#DevNull() }) + + let errorformat = '%f:%l:%c: %m,%-G%.%#' + + return SyntasticMake({ + \ 'makeprg': makeprg, + \ 'errorformat': errorformat, + \ 'defaults': {'type': 'e'} }) +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'go', + \ 'name': 'gofmt'}) + +let &cpo = s:save_cpo +unlet s:save_cpo + +" vim: set sw=4 sts=4 et fdm=marker: diff --git a/vim/bundle/syntastic/syntax_checkers/go/golint.vim b/vim/bundle/syntastic/syntax_checkers/go/golint.vim new file mode 100644 index 0000000..29eee0c --- /dev/null +++ b/vim/bundle/syntastic/syntax_checkers/go/golint.vim @@ -0,0 +1,42 @@ +"============================================================================ +"File: golint.vim +"Description: Check go syntax using 'golint' +"Maintainer: Hiroshi Ioka <hirochachacha@gmail.com> +"License: This program is free software. It comes without any warranty, +" to the extent permitted by applicable law. You can redistribute +" it and/or modify it under the terms of the Do What The Fuck You +" Want To Public License, Version 2, as published by Sam Hocevar. +" See http://sam.zoy.org/wtfpl/COPYING for more details. +" +"============================================================================ + +if exists('g:loaded_syntastic_go_golint_checker') + finish +endif +let g:loaded_syntastic_go_golint_checker = 1 + +let s:save_cpo = &cpo +set cpo&vim + +function! SyntaxCheckers_go_golint_GetLocList() dict + let makeprg = self.makeprgBuild({}) + + let errorformat = + \ '%f:%l:%c: %m,' . + \ '%-G%.%#' + + return SyntasticMake({ + \ 'makeprg': makeprg, + \ 'errorformat': errorformat, + \ 'defaults': {'type': 'w'}, + \ 'subtype': 'Style' }) +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'go', + \ 'name': 'golint'}) + +let &cpo = s:save_cpo +unlet s:save_cpo + +" vim: set sw=4 sts=4 et fdm=marker: diff --git a/vim/bundle/syntastic/syntax_checkers/go/gometalinter.vim b/vim/bundle/syntastic/syntax_checkers/go/gometalinter.vim new file mode 100644 index 0000000..780f49b --- /dev/null +++ b/vim/bundle/syntastic/syntax_checkers/go/gometalinter.vim @@ -0,0 +1,53 @@ +"============================================================================ +"File: gometalinter.vim +"Description: Check go syntax using 'gometalint' +"Maintainer: Joshua Rubin <joshua@rubixconsulting.com> +"License: This program is free software. It comes without any warranty, +" to the extent permitted by applicable law. You can redistribute +" it and/or modify it under the terms of the Do What The Fuck You +" Want To Public License, Version 2, as published by Sam Hocevar. +" See http://sam.zoy.org/wtfpl/COPYING for more details. +" +"============================================================================ + +if exists('g:loaded_syntastic_go_gometalinter_checker') + finish +endif +let g:loaded_syntastic_go_gometalinter_checker = 1 + +let s:save_cpo = &cpo +set cpo&vim + +function! SyntaxCheckers_go_gometalinter_GetLocList() dict + let makeprg = self.makeprgBuild({ + \ 'args': '-t', + \ 'fname': syntastic#util#shexpand('%:p:h') }) + + let errorformat = + \ '%f:%l:%c:%trror: %m,' . + \ '%f:%l:%c:%tarning: %m,' . + \ '%f:%l::%trror: %m,' . + \ '%f:%l::%tarning: %m' + + let loclist = SyntasticMake({ + \ 'makeprg': makeprg, + \ 'errorformat': errorformat, + \ 'returns': [0, 1] }) + + for e in loclist + if e['text'] =~# '\v\(%(deadcode|gocyclo|golint|defercheck|varcheck|structcheck|errcheck|dupl)\)$' + let e['subtype'] = 'Style' + endif + endfor + + return loclist +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'go', + \ 'name': 'gometalinter'}) + +let &cpo = s:save_cpo +unlet s:save_cpo + +" vim: set sw=4 sts=4 et fdm=marker: diff --git a/vim/bundle/syntastic/syntax_checkers/go/gotype.vim b/vim/bundle/syntastic/syntax_checkers/go/gotype.vim new file mode 100644 index 0000000..37472ee --- /dev/null +++ b/vim/bundle/syntastic/syntax_checkers/go/gotype.vim @@ -0,0 +1,48 @@ +"============================================================================ +"File: gotype.vim +"Description: Perform syntactic and semantic checking of Go code using 'gotype' +"Maintainer: luz <ne.tetewi@gmail.com> +"License: This program is free software. It comes without any warranty, +" to the extent permitted by applicable law. You can redistribute +" it and/or modify it under the terms of the Do What The Fuck You +" Want To Public License, Version 2, as published by Sam Hocevar. +" See http://sam.zoy.org/wtfpl/COPYING for more details. +" +"============================================================================ + +if exists('g:loaded_syntastic_go_gotype_checker') + finish +endif +let g:loaded_syntastic_go_gotype_checker = 1 + +let s:save_cpo = &cpo +set cpo&vim + +function! SyntaxCheckers_go_gotype_GetLocList() dict + let makeprg = self.makeprgBuild({ + \ 'args': (expand('%', 1) =~# '\m_test\.go$' ? '-a' : ''), + \ 'fname': '.' }) + + let errorformat = + \ '%f:%l:%c: %m,' . + \ '%-G%.%#' + + " gotype needs the full go package to test types properly. Just cwd to + " the package for the same reasons specified in go.vim ("figuring out + " the import path is fickle"). + + return SyntasticMake({ + \ 'makeprg': makeprg, + \ 'errorformat': errorformat, + \ 'cwd': expand('%:p:h', 1), + \ 'defaults': {'type': 'e'} }) +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'go', + \ 'name': 'gotype'}) + +let &cpo = s:save_cpo +unlet s:save_cpo + +" vim: set sw=4 sts=4 et fdm=marker: diff --git a/vim/bundle/syntastic/syntax_checkers/go/govet.vim b/vim/bundle/syntastic/syntax_checkers/go/govet.vim new file mode 100644 index 0000000..6c30631 --- /dev/null +++ b/vim/bundle/syntastic/syntax_checkers/go/govet.vim @@ -0,0 +1,48 @@ +"============================================================================ +"File: govet.vim +"Description: Perform static analysis of Go code with the vet tool +"Maintainer: Kamil Kisiel <kamil@kamilkisiel.net> +"License: This program is free software. It comes without any warranty, +" to the extent permitted by applicable law. You can redistribute +" it and/or modify it under the terms of the Do What The Fuck You +" Want To Public License, Version 2, as published by Sam Hocevar. +" See http://sam.zoy.org/wtfpl/COPYING for more details. +" +"============================================================================ + +if exists('g:loaded_syntastic_go_govet_checker') + finish +endif +let g:loaded_syntastic_go_govet_checker = 1 + +let s:save_cpo = &cpo +set cpo&vim + +function! SyntaxCheckers_go_govet_GetLocList() dict + let makeprg = self.getExecEscaped() . ' 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. + + return SyntasticMake({ + \ 'makeprg': makeprg, + \ 'errorformat': errorformat, + \ 'cwd': expand('%:p:h', 1), + \ 'defaults': {'type': 'w'} }) +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'go', + \ 'name': 'govet', + \ 'exec': 'go' }) + +let &cpo = s:save_cpo +unlet s:save_cpo + +" vim: set sw=4 sts=4 et fdm=marker: diff --git a/vim/bundle/syntastic/syntax_checkers/haml/haml.vim b/vim/bundle/syntastic/syntax_checkers/haml/haml.vim new file mode 100644 index 0000000..c0c7318 --- /dev/null +++ b/vim/bundle/syntastic/syntax_checkers/haml/haml.vim @@ -0,0 +1,46 @@ +"============================================================================ +"File: haml.vim +"Description: Syntax checking plugin for syntastic.vim +"Maintainer: Martin Grenfell <martin.grenfell at gmail dot com> +"License: This program is free software. It comes without any warranty, +" to the extent permitted by applicable law. You can redistribute +" it and/or modify it under the terms of the Do What The Fuck You +" Want To Public License, Version 2, as published by Sam Hocevar. +" See http://sam.zoy.org/wtfpl/COPYING for more details. +" +"============================================================================ + +if exists('g:loaded_syntastic_haml_haml_checker') + finish +endif +let g:loaded_syntastic_haml_haml_checker = 1 + +let s:save_cpo = &cpo +set cpo&vim + +function! SyntaxCheckers_haml_haml_IsAvailable() dict + call syntastic#log#deprecationWarn('haml_interpreter', 'haml_haml_exec') + return executable(self.getExec()) +endfunction + +function! SyntaxCheckers_haml_haml_GetLocList() dict + let makeprg = self.makeprgBuild({ 'args_after': '-c' }) + + let errorformat = + \ 'Haml error on line %l: %m,' . + \ 'Syntax error on line %l: %m,' . + \ '%-G%.%#' + + return SyntasticMake({ + \ 'makeprg': makeprg, + \ 'errorformat': errorformat }) +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'haml', + \ 'name': 'haml'}) + +let &cpo = s:save_cpo +unlet s:save_cpo + +" vim: set sw=4 sts=4 et fdm=marker: diff --git a/vim/bundle/syntastic/syntax_checkers/haml/haml_lint.vim b/vim/bundle/syntastic/syntax_checkers/haml/haml_lint.vim new file mode 100644 index 0000000..60b3db3 --- /dev/null +++ b/vim/bundle/syntastic/syntax_checkers/haml/haml_lint.vim @@ -0,0 +1,37 @@ +"============================================================================ +"File: haml_lint.vim +"Description: HAML style and syntax checker plugin for Syntastic +"Maintainer: Shane da Silva <shane@dasilva.io> +"License: This program is free software. It comes without any warranty, +" to the extent permitted by applicable law. You can redistribute +" it and/or modify it under the terms of the Do What The Fuck You +" Want To Public License, Version 2, as published by Sam Hocevar. +" See http://sam.zoy.org/wtfpl/COPYING for more details. +"============================================================================ + +if exists('g:loaded_syntastic_haml_haml_lint_checker') + finish +endif +let g:loaded_syntastic_haml_haml_lint_checker = 1 + +let s:save_cpo = &cpo +set cpo&vim + +function! SyntaxCheckers_haml_haml_lint_GetLocList() dict + let makeprg = self.makeprgBuild({}) + let errorformat = '%f:%l [%t] %m' + return SyntasticMake({ + \ 'makeprg': makeprg, + \ 'errorformat': errorformat, + \ 'subtype': 'Style'}) +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'haml', + \ 'name': 'haml_lint', + \ 'exec': 'haml-lint' }) + +let &cpo = s:save_cpo +unlet s:save_cpo + +" vim: set sw=4 sts=4 et fdm=marker: diff --git a/vim/bundle/syntastic/syntax_checkers/handlebars/handlebars.vim b/vim/bundle/syntastic/syntax_checkers/handlebars/handlebars.vim new file mode 100644 index 0000000..f5ae742 --- /dev/null +++ b/vim/bundle/syntastic/syntax_checkers/handlebars/handlebars.vim @@ -0,0 +1,43 @@ +"============================================================================ +"File: handlebars.vim +"Description: Syntax checking plugin for syntastic.vim +"Maintainer: Martin Grenfell <martin.grenfell at gmail dot com> +"License: This program is free software. It comes without any warranty, +" to the extent permitted by applicable law. You can redistribute +" it and/or modify it under the terms of the Do What The Fuck You +" Want To Public License, Version 2, as published by Sam Hocevar. +" See http://sam.zoy.org/wtfpl/COPYING for more details. +"============================================================================ + +if exists('g:loaded_syntastic_handlebars_handlebars_checker') + finish +endif +let g:loaded_syntastic_handlebars_handlebars_checker = 1 + +let s:save_cpo = &cpo +set cpo&vim + +function! SyntaxCheckers_handlebars_handlebars_GetLocList() dict + let makeprg = self.makeprgBuild({ 'args_after': '-f ' . syntastic#util#DevNull() }) + + let errorformat = + \ '%EError: %m on line %l:,' . + \ '%EError: %m,' . + \ '%Z%p^,' . + \ '%-G%.%#' + + return SyntasticMake({ + \ 'makeprg': makeprg, + \ 'errorformat': errorformat, + \ 'postprocess': ['guards'], + \ 'defaults': {'bufnr': bufnr('')} }) +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'handlebars', + \ 'name': 'handlebars'}) + +let &cpo = s:save_cpo +unlet s:save_cpo + +" vim: set sw=4 sts=4 et fdm=marker: diff --git a/vim/bundle/syntastic/syntax_checkers/haskell/ghc-mod.vim b/vim/bundle/syntastic/syntax_checkers/haskell/ghc-mod.vim new file mode 100644 index 0000000..928e5b3 --- /dev/null +++ b/vim/bundle/syntastic/syntax_checkers/haskell/ghc-mod.vim @@ -0,0 +1,94 @@ +"============================================================================ +"File: ghc-mod.vim +"Description: Syntax checking plugin for syntastic.vim +"Maintainer: Anthony Carapetis <anthony.carapetis at gmail dot com> +"License: This program is free software. It comes without any warranty, +" to the extent permitted by applicable law. You can redistribute +" it and/or modify it under the terms of the Do What The Fuck You +" Want To Public License, Version 2, as published by Sam Hocevar. +" See http://sam.zoy.org/wtfpl/COPYING for more details. +" +"============================================================================ + +if exists('g:loaded_syntastic_haskell_ghc_mod_checker') + finish +endif +let g:loaded_syntastic_haskell_ghc_mod_checker = 1 + +let s:ghc_mod_new = -1 + +let s:save_cpo = &cpo +set cpo&vim + +function! SyntaxCheckers_haskell_ghc_mod_IsAvailable() dict " {{{1 + if !executable(self.getExec()) + return 0 + endif + + " ghc-mod 5.0.0 and later needs the "version" command to print the + " version. But the "version" command appeared in 4.1.0. Thus, we need to + " know the version in order to know how to find out the version. :) + + " Try "ghc-mod version". + let version_output = split(syntastic#util#system(self.getExecEscaped() . ' version'), '\n', 1) + let ver = filter(copy(version_output), 'v:val =~# ''\m\sversion''') + if !len(ver) + " That didn't work. Try "ghc-mod" alone. + let version_output = split(syntastic#util#system(self.getExecEscaped()), '\n', 1) + let ver = filter(copy(version_output), 'v:val =~# ''\m\sversion''') + endif + let parsed_ver = len(ver) ? syntastic#util#parseVersion(ver[0]) : [] + + if len(parsed_ver) + " Encouraged by the great success in finding out the version, now we + " need either a Vim that can handle NULs in system() output, or a + " ghc-mod that has the "--boundary" option. + call self.setVersion(parsed_ver) + let s:ghc_mod_new = syntastic#util#versionIsAtLeast(parsed_ver, [2, 1, 2]) + else + call syntastic#log#ndebug(g:_SYNTASTIC_DEBUG_LOCLIST, 'checker output:', version_output) + call syntastic#log#error("checker haskell/ghc_mod: can't parse version string (abnormal termination?)") + let s:ghc_mod_new = -1 + endif + + " ghc-mod 5.4.0 wants to run in the root directory of the project; + " syntastic can't cope with the resulting complications + " + " References: + " https://hackage.haskell.org/package/ghc-mod-5.4.0.0/changelog + let s:ghc_mod_bailout = syntastic#util#versionIsAtLeast(parsed_ver, [5, 4]) + + return (s:ghc_mod_new >= 0) && (v:version >= 704 || s:ghc_mod_new) && !s:ghc_mod_bailout +endfunction " }}}1 + +function! SyntaxCheckers_haskell_ghc_mod_GetLocList() dict " {{{1 + let makeprg = self.makeprgBuild({ + \ 'exe': self.getExecEscaped() . ' check' . (s:ghc_mod_new ? ' --boundary=""' : '') }) + + let errorformat = + \ '%-G%\s%#,' . + \ '%f:%l:%c:%trror: %m,' . + \ '%f:%l:%c:%tarning: %m,'. + \ '%f:%l:%c: %trror: %m,' . + \ '%f:%l:%c: %tarning: %m,' . + \ '%f:%l:%c:%m,' . + \ '%E%f:%l:%c:,' . + \ '%Z%m' + + return SyntasticMake({ + \ 'makeprg': makeprg, + \ 'errorformat': errorformat, + \ 'preprocess': 'iconv', + \ 'postprocess': ['compressWhitespace'], + \ 'returns': [0] }) +endfunction " }}}1 + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'haskell', + \ 'name': 'ghc_mod', + \ 'exec': 'ghc-mod' }) + +let &cpo = s:save_cpo +unlet s:save_cpo + +" vim: set sw=4 sts=4 et fdm=marker: diff --git a/vim/bundle/syntastic/syntax_checkers/haskell/hdevtools.vim b/vim/bundle/syntastic/syntax_checkers/haskell/hdevtools.vim new file mode 100644 index 0000000..4b0a80f --- /dev/null +++ b/vim/bundle/syntastic/syntax_checkers/haskell/hdevtools.vim @@ -0,0 +1,56 @@ +"============================================================================ +"File: hdevtools.vim +"Description: Syntax checking plugin for syntastic.vim +"Maintainer: Anthony Carapetis <anthony.carapetis at gmail dot com> +"License: This program is free software. It comes without any warranty, +" to the extent permitted by applicable law. You can redistribute +" it and/or modify it under the terms of the Do What The Fuck You +" Want To Public License, Version 2, as published by Sam Hocevar. +" See http://sam.zoy.org/wtfpl/COPYING for more details. +" +"============================================================================ + +if exists('g:loaded_syntastic_haskell_hdevtools_checker') + finish +endif +let g:loaded_syntastic_haskell_hdevtools_checker = 1 + +let s:save_cpo = &cpo +set cpo&vim + +function! SyntaxCheckers_haskell_hdevtools_GetLocList() dict + if !exists('g:syntastic_haskell_hdevtools_args') && exists('g:hdevtools_options') + call syntastic#log#oneTimeWarn('variable g:hdevtools_options is deprecated, ' . + \ 'please use g:syntastic_haskell_hdevtools_args instead') + let g:syntastic_haskell_hdevtools_args = g:hdevtools_options + endif + + let makeprg = self.makeprgBuild({ + \ 'exe_after': 'check', + \ 'fname': syntastic#util#shexpand('%:p') }) + + let errorformat = + \ '%-Z %#,'. + \ '%W%f:%l:%v: Warning: %m,'. + \ '%W%f:%l:%v: Warning:,'. + \ '%E%f:%l:%v: %m,'. + \ '%E%>%f:%l:%v:,'. + \ '%+C %#%m,'. + \ '%W%>%f:%l:%v:,'. + \ '%+C %#%tarning: %m,' + + return SyntasticMake({ + \ 'makeprg': makeprg, + \ 'errorformat': errorformat, + \ 'defaults': {'vcol': 1}, + \ 'postprocess': ['compressWhitespace'] }) +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'haskell', + \ 'name': 'hdevtools'}) + +let &cpo = s:save_cpo +unlet s:save_cpo + +" vim: set sw=4 sts=4 et fdm=marker: diff --git a/vim/bundle/syntastic/syntax_checkers/haskell/hlint.vim b/vim/bundle/syntastic/syntax_checkers/haskell/hlint.vim new file mode 100644 index 0000000..c75ea8b --- /dev/null +++ b/vim/bundle/syntastic/syntax_checkers/haskell/hlint.vim @@ -0,0 +1,41 @@ +"============================================================================ +"File: hlint.vim +"Description: Syntax checking plugin for syntastic.vim +"Maintainer: Nicolas Wu <nicolas.wu at gmail dot com> +"License: BSD +"============================================================================ + +if exists('g:loaded_syntastic_haskell_hlint_checker') + finish +endif +let g:loaded_syntastic_haskell_hlint_checker = 1 + +let s:save_cpo = &cpo +set cpo&vim + +function! SyntaxCheckers_haskell_hlint_GetLocList() dict + let makeprg = self.makeprgBuild({ + \ 'fname': syntastic#util#shexpand('%:p')}) + + let errorformat = + \ '%E%f:%l:%v: Error while reading hint file\, %m,' . + \ '%E%f:%l:%v: Error: %m,' . + \ '%W%f:%l:%v: Warning: %m,' . + \ '%W%f:%l:%v: Suggestion: %m,' . + \ '%C%m' + + return SyntasticMake({ + \ 'makeprg': makeprg, + \ 'errorformat': errorformat, + \ 'defaults': {'vcol': 1}, + \ 'postprocess': ['compressWhitespace'] }) +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'haskell', + \ 'name': 'hlint'}) + +let &cpo = s:save_cpo +unlet s:save_cpo + +" vim: set sw=4 sts=4 et fdm=marker: diff --git a/vim/bundle/syntastic/syntax_checkers/haskell/scan.vim b/vim/bundle/syntastic/syntax_checkers/haskell/scan.vim new file mode 100644 index 0000000..7cf7e7b --- /dev/null +++ b/vim/bundle/syntastic/syntax_checkers/haskell/scan.vim @@ -0,0 +1,43 @@ +"============================================================================ +"File: scan.vim +"Description: Syntax checking plugin for syntastic.vim +"Maintainer: LCD 47 <lcd047 at gmail dot com> +"License: This program is free software. It comes without any warranty, +" to the extent permitted by applicable law. You can redistribute +" it and/or modify it under the terms of the Do What The Fuck You +" Want To Public License, Version 2, as published by Sam Hocevar. +" See http://sam.zoy.org/wtfpl/COPYING for more details. +" +"============================================================================ + +if exists('g:loaded_syntastic_haskell_scan_checker') + finish +endif +let g:loaded_syntastic_haskell_scan_checker = 1 + +if !exists('g:syntastic_haskell_scan_sort') + let g:syntastic_haskell_scan_sort = 1 +endif + +let s:save_cpo = &cpo +set cpo&vim + +function! SyntaxCheckers_haskell_scan_GetLocList() dict + let makeprg = self.makeprgBuild({}) + + let errorformat = '%f:%l:%v: %m' + + return SyntasticMake({ + \ 'makeprg': makeprg, + \ 'errorformat': errorformat, + \ 'subtype': 'Style' }) +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'haskell', + \ 'name': 'scan'}) + +let &cpo = s:save_cpo +unlet s:save_cpo + +" vim: set sw=4 sts=4 et fdm=marker: diff --git a/vim/bundle/syntastic/syntax_checkers/haxe/haxe.vim b/vim/bundle/syntastic/syntax_checkers/haxe/haxe.vim new file mode 100644 index 0000000..789e9f3 --- /dev/null +++ b/vim/bundle/syntastic/syntax_checkers/haxe/haxe.vim @@ -0,0 +1,63 @@ +"============================================================================ +"File: haxe.vim +"Description: Syntax checking plugin for syntastic.vim +"Maintainer: David Bernard <david.bernard.31 at gmail dot com> +"License: This program is free software. It comes without any warranty, +" to the extent permitted by applicable law. You can redistribute +" it and/or modify it under the terms of the Do What The Fuck You +" Want To Public License, Version 2, as published by Sam Hocevar. +" See http://sam.zoy.org/wtfpl/COPYING for more details. +" +"============================================================================ + +if exists('g:loaded_syntastic_haxe_haxe_checker') + finish +endif +let g:loaded_syntastic_haxe_haxe_checker = 1 + +let s:save_cpo = &cpo +set cpo&vim + +function! SyntaxCheckers_haxe_haxe_GetLocList() dict + if exists('b:vaxe_hxml') + let hxml = b:vaxe_hxml + elseif exists('g:vaxe_hxml') + let hxml = g:vaxe_hxml + else + let hxml = syntastic#util#findGlobInParent('*.hxml', expand('%:p:h', 1)) + endif + let hxml = fnamemodify(hxml, ':p') + + call self.log('hxml =', hxml) + + if hxml !=# '' + let makeprg = self.makeprgBuild({ + \ 'fname': syntastic#util#shescape(fnamemodify(hxml, ':t')) }) + + let errorformat = '%E%f:%l: characters %c-%n : %m' + + let loclist = SyntasticMake({ + \ 'makeprg': makeprg, + \ 'errorformat': errorformat, + \ 'cwd': fnamemodify(hxml, ':h') }) + + for e in loclist + let e['hl'] = '\%>' . e['col'] . 'c\%<' . (e['nr'] + 1) . 'c' + let e['col'] += 1 + let e['nr'] = 0 + endfor + + return loclist + endif + + return [] +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'haxe', + \ 'name': 'haxe'}) + +let &cpo = s:save_cpo +unlet s:save_cpo + +" vim: set sw=4 sts=4 et fdm=marker: diff --git a/vim/bundle/syntastic/syntax_checkers/hss/hss.vim b/vim/bundle/syntastic/syntax_checkers/hss/hss.vim new file mode 100644 index 0000000..d988615 --- /dev/null +++ b/vim/bundle/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 + +let s:save_cpo = &cpo +set cpo&vim + +function! SyntaxCheckers_hss_hss_GetLocList() dict + let makeprg = self.makeprgBuild({ 'args_after' : '-output ' . syntastic#util#DevNull() }) + + let errorformat = '%E%f:%l: %m' + + return SyntasticMake({ + \ 'makeprg': makeprg, + \ 'errorformat': errorformat }) +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'hss', + \ 'name': 'hss'}) + +let &cpo = s:save_cpo +unlet s:save_cpo + +" vim: set sw=4 sts=4 et fdm=marker: diff --git a/vim/bundle/syntastic/syntax_checkers/html/eslint.vim b/vim/bundle/syntastic/syntax_checkers/html/eslint.vim new file mode 100644 index 0000000..3e91931 --- /dev/null +++ b/vim/bundle/syntastic/syntax_checkers/html/eslint.vim @@ -0,0 +1,23 @@ +"============================================================================ +"File: eslint.vim +"Description: Syntax checking plugin for syntastic +"Maintainer: LCD 47 <lcd047 at gmail dot com> +"License: This program is free software. It comes without any warranty, +" to the extent permitted by applicable law. You can redistribute +" it and/or modify it under the terms of the Do What The Fuck You +" Want To Public License, Version 2, as published by Sam Hocevar. +" See http://sam.zoy.org/wtfpl/COPYING for more details. +" +"============================================================================ + +if exists('g:loaded_syntastic_html_eslint_checker') + finish +endif +let g:loaded_syntastic_html_eslint_checker = 1 + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'html', + \ 'name': 'eslint', + \ 'redirect': 'javascript/eslint'}) + +" vim: set sw=4 sts=4 et fdm=marker: diff --git a/vim/bundle/syntastic/syntax_checkers/html/gjslint.vim b/vim/bundle/syntastic/syntax_checkers/html/gjslint.vim new file mode 100644 index 0000000..a26e2f3 --- /dev/null +++ b/vim/bundle/syntastic/syntax_checkers/html/gjslint.vim @@ -0,0 +1,23 @@ +"============================================================================ +"File: gjslint.vim +"Description: Syntax checking plugin for syntastic +"Maintainer: LCD 47 <lcd047 at gmail dot com> +"License: This program is free software. It comes without any warranty, +" to the extent permitted by applicable law. You can redistribute +" it and/or modify it under the terms of the Do What The Fuck You +" Want To Public License, Version 2, as published by Sam Hocevar. +" See http://sam.zoy.org/wtfpl/COPYING for more details. +" +"============================================================================ + +if exists('g:loaded_syntastic_html_gjslint_checker') + finish +endif +let g:loaded_syntastic_html_gjslint_checker = 1 + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'html', + \ 'name': 'gjslint', + \ 'redirect': 'javascript/gjslint'}) + +" vim: set sw=4 sts=4 et fdm=marker: diff --git a/vim/bundle/syntastic/syntax_checkers/html/jshint.vim b/vim/bundle/syntastic/syntax_checkers/html/jshint.vim new file mode 100644 index 0000000..a7af758 --- /dev/null +++ b/vim/bundle/syntastic/syntax_checkers/html/jshint.vim @@ -0,0 +1,50 @@ +"============================================================================ +"File: jshint.vim +"Description: Javascript syntax checker for HTML - using jshint +"Maintainer: LCD 47 <lcd047@gmail.com> +"License: This program is free software. It comes without any warranty, +" to the extent permitted by applicable law. You can redistribute +" it and/or modify it under the terms of the Do What The Fuck You +" Want To Public License, Version 2, as published by Sam Hocevar. +" See http://sam.zoy.org/wtfpl/COPYING for more details. +"============================================================================ + +if exists('g:loaded_syntastic_html_jshint_checker') + finish +endif +let g:loaded_syntastic_html_jshint_checker = 1 + +let s:save_cpo = &cpo +set cpo&vim + +function! SyntaxCheckers_html_jshint_IsAvailable() dict + call syntastic#log#deprecationWarn('jshint_exec', 'html_jshint_exec') + if !executable(self.getExec()) + return 0 + endif + return syntastic#util#versionIsAtLeast(self.getVersion(), [2, 4]) +endfunction + +function! SyntaxCheckers_html_jshint_GetLocList() dict + call syntastic#log#deprecationWarn('html_jshint_conf', 'html_jshint_args', + \ "'--config ' . syntastic#util#shexpand(OLD_VAR)") + + let makeprg = self.makeprgBuild({ 'args_after': '--verbose --extract always' }) + + let errorformat = '%A%f: line %l\, col %v\, %m \(%t%*\d\)' + + return SyntasticMake({ + \ 'makeprg': makeprg, + \ 'errorformat': errorformat, + \ 'defaults': {'bufnr': bufnr('')}, + \ 'returns': [0, 2] }) +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'html', + \ 'name': 'jshint'}) + +let &cpo = s:save_cpo +unlet s:save_cpo + +" vim: set sw=4 sts=4 et fdm=marker: diff --git a/vim/bundle/syntastic/syntax_checkers/html/textlint.vim b/vim/bundle/syntastic/syntax_checkers/html/textlint.vim new file mode 100644 index 0000000..b95d8be --- /dev/null +++ b/vim/bundle/syntastic/syntax_checkers/html/textlint.vim @@ -0,0 +1,23 @@ +"============================================================================ +"File: textlint.vim +"Description: Syntax checking plugin for syntastic +"Maintainer: LCD 47 <lcd047 at gmail dot com> +"License: This program is free software. It comes without any warranty, +" to the extent permitted by applicable law. You can redistribute +" it and/or modify it under the terms of the Do What The Fuck You +" Want To Public License, Version 2, as published by Sam Hocevar. +" See http://sam.zoy.org/wtfpl/COPYING for more details. +" +"============================================================================ + +if exists('g:loaded_syntastic_html_textlint_checker') + finish +endif +let g:loaded_syntastic_html_textlint_checker = 1 + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'html', + \ 'name': 'textlint', + \ 'redirect': 'text/textlint'}) + +" vim: set sw=4 sts=4 et fdm=marker: diff --git a/vim/bundle/syntastic/syntax_checkers/html/tidy.vim b/vim/bundle/syntastic/syntax_checkers/html/tidy.vim new file mode 100644 index 0000000..3075a7d --- /dev/null +++ b/vim/bundle/syntastic/syntax_checkers/html/tidy.vim @@ -0,0 +1,212 @@ +"============================================================================ +"File: tidy.vim +"Description: Syntax checking plugin for syntastic.vim +"Maintainer: Martin Grenfell <martin.grenfell at gmail dot com> +"License: This program is free software. It comes without any warranty, +" to the extent permitted by applicable law. You can redistribute +" it and/or modify it under the terms of the Do What The Fuck You +" Want To Public License, Version 2, as published by Sam Hocevar. +" See http://sam.zoy.org/wtfpl/COPYING for more details. +" +"============================================================================ + +if exists('g:loaded_syntastic_html_tidy_checker') + finish +endif +let g:loaded_syntastic_html_tidy_checker = 1 + +let s:save_cpo = &cpo +set cpo&vim + +" Checker options {{{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 + +" }}}1 + +" Constants {{{1 + +let s:IGNORE_ERRORS = [ + \ "<table> lacks \"summary\" attribute", + \ "not approved by W3C", + \ "<input> proprietary attribute \"placeholder\"", + \ "<meta> proprietary attribute \"charset\"", + \ "<meta> lacks \"content\" attribute", + \ "inserting \"type\" attribute", + \ "proprietary attribute \"data-", + \ "missing <!DOCTYPE> declaration", + \ "inserting implicit <body>", + \ "inserting missing 'title' element", + \ "unescaped & or unknown entity", + \ "<input> attribute \"type\" has invalid value", + \ "proprietary attribute \"role\"", + \ "proprietary attribute \"aria-activedescendant\"", + \ "proprietary attribute \"aria-atomic\"", + \ "proprietary attribute \"aria-autocomplete\"", + \ "proprietary attribute \"aria-busy\"", + \ "proprietary attribute \"aria-checked\"", + \ "proprietary attribute \"aria-controls\"", + \ "proprietary attribute \"aria-describedby\"", + \ "proprietary attribute \"aria-disabled\"", + \ "proprietary attribute \"aria-dropeffect\"", + \ "proprietary attribute \"aria-expanded\"", + \ "proprietary attribute \"aria-flowto\"", + \ "proprietary attribute \"aria-grabbed\"", + \ "proprietary attribute \"aria-haspopup\"", + \ "proprietary attribute \"aria-hidden\"", + \ "proprietary attribute \"aria-invalid\"", + \ "proprietary attribute \"aria-label\"", + \ "proprietary attribute \"aria-labelledby\"", + \ "proprietary attribute \"aria-level\"", + \ "proprietary attribute \"aria-live\"", + \ "proprietary attribute \"aria-multiline\"", + \ "proprietary attribute \"aria-multiselectable\"", + \ "proprietary attribute \"aria-orientation\"", + \ "proprietary attribute \"aria-owns\"", + \ "proprietary attribute \"aria-posinset\"", + \ "proprietary attribute \"aria-pressed\"", + \ "proprietary attribute \"aria-readonly\"", + \ "proprietary attribute \"aria-relevant\"", + \ "proprietary attribute \"aria-relevant\"", + \ "proprietary attribute \"aria-required\"", + \ "proprietary attribute \"aria-selected\"", + \ "proprietary attribute \"aria-setsize\"", + \ "proprietary attribute \"aria-sort\"", + \ "proprietary attribute \"aria-valuemax\"", + \ "proprietary attribute \"aria-valuemin\"", + \ "proprietary attribute \"aria-valuenow\"", + \ "proprietary attribute \"aria-valuetext\"" + \ ] +lockvar! s:IGNORE_ERRORS + +let s:BLOCKLEVEL_TAGS = [ + \ 'main', + \ 'section', + \ 'article', + \ 'aside', + \ 'header', + \ 'footer', + \ 'nav', + \ 'figure', + \ 'figcaption' + \ ] +lockvar! s:BLOCKLEVEL_TAGS + +let s:INLINE_TAGS = [ + \ 'video', + \ 'audio', + \ 'source', + \ 'embed', + \ 'mark', + \ 'progress', + \ 'meter', + \ 'time', + \ 'ruby', + \ 'rt', + \ 'rp', + \ 'canvas', + \ 'command', + \ 'details', + \ 'datalist' + \ ] +lockvar! s:INLINE_TAGS + +let s:EMPTY_TAGS = [ + \ 'wbr', + \ 'keygen' + \ ] +lockvar! s:EMPTY_TAGS + +" }}}1 + +function! SyntaxCheckers_html_tidy_GetLocList() dict " {{{1 + let makeprg = self.makeprgBuild({ 'args_after': s:Args() }) + + let errorformat = + \ '%Wline %l column %v - Warning: %m,' . + \ '%Eline %l column %v - Error: %m,' . + \ '%-G%.%#' + + let loclist = SyntasticMake({ + \ 'makeprg': makeprg, + \ 'errorformat': errorformat, + \ 'defaults': {'bufnr': bufnr('')}, + \ 'returns': [0, 1, 2] }) + + " filter out valid HTML5 from the errors + for e in loclist + if e['valid'] && s:IgnoreError(e['text']) == 1 + let e['valid'] = 0 + endif + endfor + + return loclist +endfunction " }}}1 + +" Utilities {{{1 + +" TODO: join this with xhtml.vim for DRY's sake? +function! s:TidyEncOptByFenc() " {{{2 + 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 " }}}2 + +function! s:IgnoreError(text) " {{{2 + for item in s:IGNORE_ERRORS + g:syntastic_html_tidy_ignore_errors + if stridx(a:text, item) != -1 + return 1 + endif + endfor + return 0 +endfunction " }}}2 + +function! s:NewTags(name) " {{{2 + return syntastic#util#shescape(join( s:{toupper(a:name)} + g:syntastic_html_tidy_{a:name}, ',' )) +endfunction " }}}2 + +function! s:Args() " {{{2 + 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 " }}}2 + +" }}}1 + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'html', + \ 'name': 'tidy'}) + +let &cpo = s:save_cpo +unlet s:save_cpo + +" vim: set sw=4 sts=4 et fdm=marker: diff --git a/vim/bundle/syntastic/syntax_checkers/html/validator.vim b/vim/bundle/syntastic/syntax_checkers/html/validator.vim new file mode 100644 index 0000000..14a4c64 --- /dev/null +++ b/vim/bundle/syntastic/syntax_checkers/html/validator.vim @@ -0,0 +1,69 @@ +"============================================================================ +"File: validator.vim +"Description: Syntax checking plugin for syntastic.vim +"Maintainer: LCD 47 <lcd047 at gmail dot com> +"License: This program is free software. It comes without any warranty, +" to the extent permitted by applicable law. You can redistribute +" it and/or modify it under the terms of the Do What The Fuck You +" Want To Public License, Version 2, as published by Sam Hocevar. +" See http://sam.zoy.org/wtfpl/COPYING for more details. +" +"============================================================================ + +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 = 'https://validator.nu/' +endif + +if !exists('g:syntastic_html_validator_parser') + let g:syntastic_html_validator_parser = '' +endif + +if !exists('g:syntastic_html_validator_nsfilter') + let g:syntastic_html_validator_nsfilter = '' +endif + +let s:save_cpo = &cpo +set cpo&vim + +function! SyntaxCheckers_html_validator_GetLocList() dict + let fname = syntastic#util#shexpand('%') + let makeprg = self.getExecEscaped() . ' -q -L -s --compressed -F out=gnu -F asciiquotes=yes' . + \ (g:syntastic_html_validator_parser !=# '' ? ' -F parser=' . g:syntastic_html_validator_parser : '') . + \ (g:syntastic_html_validator_nsfilter !=# '' ? ' -F nsfilter=' . g:syntastic_html_validator_nsfilter : '') . + \ ' -F doc=@' . fname . '\;type=text/html\;filename=' . fname . ' ' . g:syntastic_html_validator_api + + let errorformat = + \ '%E"%f":%l: %trror: %m,' . + \ '%E"%f":%l-%\d%\+: %trror: %m,' . + \ '%E"%f":%l%\%.%c: %trror: %m,' . + \ '%E"%f":%l%\%.%c-%\d%\+%\%.%\d%\+: %trror: %m,' . + \ '%E"%f":%l: %trror fatal: %m,' . + \ '%E"%f":%l-%\d%\+: %trror fatal: %m,' . + \ '%E"%f":%l%\%.%c: %trror fatal: %m,' . + \ '%E"%f":%l%\%.%c-%\d%\+%\%.%\d%\+: %trror fatal: %m,' . + \ '%W"%f":%l: info %tarning: %m,' . + \ '%W"%f":%l-%\d%\+: info %tarning: %m,' . + \ '%W"%f":%l%\%.%c: info %tarning: %m,' . + \ '%W"%f":%l%\%.%c-%\d%\+%\%.%\d%\+: info %tarning: %m' + + return SyntasticMake({ + \ 'makeprg': makeprg, + \ 'errorformat': errorformat, + \ 'preprocess': 'validator', + \ 'returns': [0] }) +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'html', + \ 'name': 'validator', + \ 'exec': 'curl' }) + +let &cpo = s:save_cpo +unlet s:save_cpo + +" vim: set sw=4 sts=4 et fdm=marker: diff --git a/vim/bundle/syntastic/syntax_checkers/html/w3.vim b/vim/bundle/syntastic/syntax_checkers/html/w3.vim new file mode 100644 index 0000000..37ff11a --- /dev/null +++ b/vim/bundle/syntastic/syntax_checkers/html/w3.vim @@ -0,0 +1,62 @@ +"============================================================================ +"File: w3.vim +"Description: Syntax checking plugin for syntastic.vim +"Maintainer: Martin Grenfell <martin.grenfell at gmail dot com> +"License: This program is free software. It comes without any warranty, +" to the extent permitted by applicable law. You can redistribute +" it and/or modify it under the terms of the Do What The Fuck You +" Want To Public License, Version 2, as published by Sam Hocevar. +" See http://sam.zoy.org/wtfpl/COPYING for more details. +" +"============================================================================ + +if exists('g:loaded_syntastic_html_w3_checker') + finish +endif +let g:loaded_syntastic_html_w3_checker = 1 + +if !exists('g:syntastic_html_w3_api') + let g:syntastic_html_w3_api = 'http://validator.w3.org/check' +endif + +let s:save_cpo = &cpo +set cpo&vim + +function! SyntaxCheckers_html_w3_GetLocList() dict + let makeprg = self.getExecEscaped() . ' -q -L -s -F output=json ' . + \ '-F uploaded_file=@' . syntastic#util#shexpand('%:p') . '\;type=text/html ' . + \ g:syntastic_html_w3_api + + let errorformat = + \ '%A %\+{,' . + \ '%C %\+"lastLine": %l\,%\?,' . + \ '%C %\+"lastColumn": %c\,%\?,' . + \ '%C %\+"message": "%m"\,%\?,' . + \ '%C %\+"type": "%trror"\,%\?,' . + \ '%-G %\+"type": "%tnfo"\,%\?,' . + \ '%C %\+"subtype": "%tarning"\,%\?,' . + \ '%Z %\+}\,,' . + \ '%-G%.%#' + + let loclist = SyntasticMake({ + \ 'makeprg': makeprg, + \ 'errorformat': errorformat, + \ 'defaults': {'bufnr': bufnr('')}, + \ 'returns': [0] }) + + for e in loclist + let e['text'] = substitute(e['text'], '\m\\\([\"]\)', '\1', 'g') + endfor + + return loclist +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'html', + \ 'name': 'w3', + \ 'exec': 'curl' }) + +let &cpo = s:save_cpo +unlet s:save_cpo + +" vim: set sw=4 sts=4 et fdm=marker: diff --git a/vim/bundle/syntastic/syntax_checkers/jade/jade_lint.vim b/vim/bundle/syntastic/syntax_checkers/jade/jade_lint.vim new file mode 100644 index 0000000..32cc808 --- /dev/null +++ b/vim/bundle/syntastic/syntax_checkers/jade/jade_lint.vim @@ -0,0 +1,24 @@ +"============================================================================ +"File: jade_lint.vim +"Description: Syntax checking plugin for syntastic +"Maintainer: LCD 47 <lcd047 at gmail dot com> +"License: This program is free software. It comes without any warranty, +" to the extent permitted by applicable law. You can redistribute +" it and/or modify it under the terms of the Do What The Fuck You +" Want To Public License, Version 2, as published by Sam Hocevar. +" See http://sam.zoy.org/wtfpl/COPYING for more details. +" +"============================================================================ + +if exists('g:loaded_syntastic_jade_jade_lint_checker') + finish +endif +let g:loaded_syntastic_jade_jade_lint_checker = 1 + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'jade', + \ 'name': 'jade_lint', + \ 'exec': 'jade-lint', + \ 'redirect': 'pug/pug_lint'}) + +" vim: set sw=4 sts=4 et fdm=marker: diff --git a/vim/bundle/syntastic/syntax_checkers/java/checkstyle.vim b/vim/bundle/syntastic/syntax_checkers/java/checkstyle.vim new file mode 100644 index 0000000..f4eee5e --- /dev/null +++ b/vim/bundle/syntastic/syntax_checkers/java/checkstyle.vim @@ -0,0 +1,85 @@ +"============================================================================ +"File: checkstyle.vim +"Description: Syntax checking plugin for syntastic.vim +"Maintainer: Dmitry Geurkov <d.geurkov at gmail dot com> +"License: This program is free software. It comes without any warranty, +" to the extent permitted by applicable law. You can redistribute +" it and/or modify it under the terms of the Do What The Fuck You +" Want To Public License, Version 2, as published by Sam Hocevar. +" See http://sam.zoy.org/wtfpl/COPYING for more details. +" +" Tested with checkstyle 5.5 +"============================================================================ + +if exists('g:loaded_syntastic_java_checkstyle_checker') + finish +endif +let g:loaded_syntastic_java_checkstyle_checker = 1 + +if !exists('g:syntastic_java_checkstyle_classpath') + let g:syntastic_java_checkstyle_classpath = 'checkstyle-6.10.1-all.jar' +endif + +if !exists('g:syntastic_java_checkstyle_conf_file') + let g:syntastic_java_checkstyle_conf_file = 'sun_checks.xml' +endif + +let s:save_cpo = &cpo +set cpo&vim + +function! SyntaxCheckers_java_checkstyle_IsAvailable() dict + if !executable(self.getExec()) + return 0 + endif + + let conf_file = expand(g:syntastic_java_checkstyle_conf_file, 1) + call self.log('filereadable(' . string(conf_file) . ') = ' . filereadable(conf_file)) + + return filereadable(conf_file) +endfunction + +function! SyntaxCheckers_java_checkstyle_GetLocList() dict + + " classpath + if !exists('s:sep') + let s:sep = syntastic#util#isRunningWindows() || has('win32unix') ? ';' : ':' + endif + let classpath = join(map( split(g:syntastic_java_checkstyle_classpath, s:sep, 1), 'expand(v:val, 1)' ), s:sep) + call self.log('classpath =', classpath) + + " forced options + let opts = [] + if classpath !=# '' + call extend(opts, ['-cp', classpath]) + endif + call extend(opts, [ + \ 'com.puppycrawl.tools.checkstyle.Main', + \ '-c', expand(g:syntastic_java_checkstyle_conf_file, 1), + \ '-f', 'xml' ]) + + " filename + let fname = syntastic#util#shescape( expand('%:p:h', 1) . syntastic#util#Slash() . expand('%:t', 1) ) + if has('win32unix') + let fname = substitute(syntastic#util#system('cygpath -m ' . fname), '\m\%x00', '', 'g') + endif + + let makeprg = self.makeprgBuild({ 'args_after': opts, 'fname': fname }) + + let errorformat = '%f:%t:%l:%c:%m' + + return SyntasticMake({ + \ 'makeprg': makeprg, + \ 'errorformat': errorformat, + \ 'preprocess': 'checkstyle', + \ 'subtype': 'Style' }) +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'java', + \ 'name': 'checkstyle', + \ 'exec': 'java'}) + +let &cpo = s:save_cpo +unlet s:save_cpo + +" vim: set sw=4 sts=4 et fdm=marker: diff --git a/vim/bundle/syntastic/syntax_checkers/java/javac.vim b/vim/bundle/syntastic/syntax_checkers/java/javac.vim new file mode 100644 index 0000000..948c244 --- /dev/null +++ b/vim/bundle/syntastic/syntax_checkers/java/javac.vim @@ -0,0 +1,427 @@ +"============================================================================ +"File: javac.vim +"Description: Syntax checking plugin for syntastic.vim +"Maintainer: Jochen Keil <jochen.keil at gmail dot com> +" Dmitry Geurkov <d.geurkov at gmail dot com> +"License: This program is free software. It comes without any warranty, +" to the extent permitted by applicable law. You can redistribute +" it and/or modify it under the terms of the Do What The Fuck You +" Want To Public License, Version 2, as published by Sam Hocevar. +" See http://sam.zoy.org/wtfpl/COPYING for more details. +"============================================================================ + +if exists('g:loaded_syntastic_java_javac_checker') + finish +endif +let g:loaded_syntastic_java_javac_checker = 1 +let g:syntastic_java_javac_maven_pom_tags = ['build', 'properties'] +let g:syntastic_java_javac_maven_pom_properties = {} +let s:has_maven = 0 + +let s:save_cpo = &cpo +set cpo&vim + +" Checker options {{{1 + +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_maven_options') + let g:syntastic_java_maven_options = '' +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 + +if !exists('g:syntastic_java_javac_autoload_maven_classpath') + let g:syntastic_java_javac_autoload_maven_classpath = 1 +endif + +if !exists('g:syntastic_java_javac_config_file_enabled') + let g:syntastic_java_javac_config_file_enabled = 0 +endif + +if !exists('g:syntastic_java_javac_config_file') + let g:syntastic_java_javac_config_file = '.syntastic_javac_config' +endif + +if !exists('g:syntastic_java_javac_custom_classpath_command') + let g:syntastic_java_javac_custom_classpath_command = '' +endif + +if !exists('g:syntastic_java_javac_maven_pom_ftime') + let g:syntastic_java_javac_maven_pom_ftime = {} +endif + +if !exists('g:syntastic_java_javac_maven_pom_classpath') + let g:syntastic_java_javac_maven_pom_classpath = {} +endif + +" }}}1 + +" Constants {{{1 + +let s:_FILE_SHORTCUTS = { + \ '%FILE_PATH%': '%:p', + \ '%FILE_NAME%': '%:t', + \ '%FILE_DIR%': '%:p:h', + \ } +lockvar! s:_FILE_SHORTCUTS + +" }}}1 + +" Commands {{{1 + +command! SyntasticJavacEditClasspath call s:EditClasspath() +command! SyntasticJavacEditConfig call s:EditConfig() + +" }}}1 + +function! SyntaxCheckers_java_javac_IsAvailable() dict " {{{1 + let s:has_maven = executable(expand(g:syntastic_java_maven_executable, 1)) + return executable(expand(g:syntastic_java_javac_executable, 1)) +endfunction " }}}1 + +function! SyntaxCheckers_java_javac_GetLocList() dict " {{{1 + let javac_opts = g:syntastic_java_javac_options + + let output_dir = '' + if g:syntastic_java_javac_delete_output + let output_dir = syntastic#util#tmpdir() + let javac_opts .= ' -d ' . syntastic#util#shescape(output_dir) + endif + + " load classpath from config file + if g:syntastic_java_javac_config_file_enabled + call s:LoadConfigFile() + endif + + + " add classpathes to javac_classpath {{{2 + let javac_classpath = '' + + for path in split(g:syntastic_java_javac_classpath, s:ClassSep()) + if path !=# '' + try + let ps = glob(path, 1, 1) + catch + let ps = split(glob(path, 1), "\n") + endtry + if type(ps) == type([]) + for p in ps + let javac_classpath = s:AddToClasspath(javac_classpath, p) + endfor + else + let javac_classpath = s:AddToClasspath(javac_classpath, ps) + endif + endif + endfor + + if s:has_maven && g:syntastic_java_javac_autoload_maven_classpath + if !g:syntastic_java_javac_delete_output + let javac_opts .= ' -d ' . syntastic#util#shescape(s:MavenOutputDirectory()) + endif + let javac_classpath = s:AddToClasspath(javac_classpath, s:GetMavenClasspath()) + endif + " }}}2 + + " load custom classpath {{{2 + if g:syntastic_java_javac_custom_classpath_command !=# '' + " Pre-process the classpath command string a little. + let classpath_command = g:syntastic_java_javac_custom_classpath_command + for [key, val] in items(s:_FILE_SHORTCUTS) + let classpath_command = substitute(classpath_command, '\V' . key, syntastic#util#shexpand(val), 'g') + endfor + let lines = syntastic#util#system(classpath_command) + if syntastic#util#isRunningWindows() || has('win32unix') + let lines = substitute(lines, "\r\n", "\n", 'g') + endif + for l in split(lines, "\n") + let javac_classpath = s:AddToClasspath(javac_classpath, l) + endfor + endif + + if javac_classpath !=# '' + let javac_opts .= ' -cp ' . syntastic#util#shexpand(javac_classpath) + endif + " }}}2 + + let fname = expand('%:p:h', 1) . syntastic#util#Slash() . expand ('%:t', 1) + + if has('win32unix') + let fname = syntastic#util#CygwinPath(fname) + endif + + let makeprg = self.makeprgBuild({ + \ 'args': javac_opts, + \ 'fname': syntastic#util#shescape(fname) }) + + " 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,'. + \ '%E%f:%l: %m,'. + \ '%Z%p^,'. + \ '%-G%.%#' + + if output_dir !=# '' + silent! call mkdir(output_dir, 'p') + endif + let errors = SyntasticMake({ + \ 'makeprg': makeprg, + \ 'errorformat': errorformat, + \ 'postprocess': ['cygwinRemoveCR'] }) + + if output_dir !=# '' + call syntastic#util#rmrf(output_dir) + endif + return errors + +endfunction " }}}1 + +" Utilities {{{1 + +function! s:RemoveCarriageReturn(line) " {{{2 + return substitute(a:line, "\r", '', 'g') +endfunction " }}}2 + +function! s:ClassSep() " {{{2 + return (syntastic#util#isRunningWindows() || has('win32unix')) ? ';' : ':' +endfunction " }}}2 + +function! s:AddToClasspath(classpath, path) " {{{2 + if a:path ==# '' + return a:classpath + endif + return (a:classpath !=# '') ? a:classpath . s:ClassSep() . a:path : a:path +endfunction " }}}2 + +function! s:SplitClasspath(classpath) " {{{2 + return split(a:classpath, s:ClassSep()) +endfunction " }}}2 + +function! s:LoadConfigFile() " {{{2 + if filereadable(expand(g:syntastic_java_javac_config_file, 1)) + execute 'source ' . fnameescape(expand(g:syntastic_java_javac_config_file, 1)) + endif +endfunction " }}}2 + +function! s:SaveClasspath() " {{{2 + " build classpath from lines + let path = '' + let lines = getline(1, line('$')) + for l in lines + let path = s:AddToClasspath(path, l) + endfor + " save classpath to config file + if g:syntastic_java_javac_config_file_enabled + if filereadable(expand(g:syntastic_java_javac_config_file, 1)) + " load lines from config file + let lines = readfile(expand(g:syntastic_java_javac_config_file, 1)) + " strip g:syntastic_java_javac_classpath options from config file lines + let i = 0 + while i < len(lines) + if match(lines[i], 'g:syntastic_java_javac_classpath') != -1 + call remove(lines, i) + else + let i += 1 + endif + endwhile + else + let lines = [] + endif + " add new g:syntastic_java_javac_classpath option to config + call add(lines, 'let g:syntastic_java_javac_classpath = ' . string(path)) + " save config file lines + call writefile(lines, expand(g:syntastic_java_javac_config_file, 1)) + endif + " set new classpath + let g:syntastic_java_javac_classpath = path + let &modified = 0 +endfunction " }}}2 + +function! s:EditClasspath() " {{{2 + let command = 'syntastic javac classpath' + let winnr = bufwinnr('^' . command . '$') + if winnr < 0 + let path = [] + let pathlines = split(g:syntastic_java_javac_classpath, "\n") + for p in pathlines + call extend(path, s:SplitClasspath(p)) + endfor + execute (len(path) + 5) . 'sp ' . fnameescape(command) + + augroup syntastic + autocmd BufWriteCmd <buffer> call s:SaveClasspath() | bwipeout + augroup END + + setlocal buftype=acwrite bufhidden=wipe nobuflisted noswapfile nowrap number + for p in path + call append(line('$') - 1, p) + endfor + let &modified = 0 + else + execute winnr . 'wincmd w' + endif +endfunction " }}}2 + +function! s:SaveConfig() " {{{2 + " get lines + let lines = getline(1, line('$')) + if g:syntastic_java_javac_config_file_enabled + " save config file lines + call writefile(lines, expand(g:syntastic_java_javac_config_file, 1)) + endif + let &modified = 0 +endfunction " }}}2 + +function! s:EditConfig() " {{{2 + if !g:syntastic_java_javac_config_file_enabled + return + endif + + let command = 'syntastic javac config' + let winnr = bufwinnr('^' . command . '$') + if winnr < 0 + let lines = [] + if filereadable(expand(g:syntastic_java_javac_config_file, 1)) + let lines = readfile(expand(g:syntastic_java_javac_config_file, 1)) + endif + execute (len(lines) + 5) . 'sp ' . fnameescape(command) + + augroup syntastic + autocmd BufWriteCmd <buffer> call s:SaveConfig() | bwipeout + augroup END + + setlocal ft=vim buftype=acwrite bufhidden=wipe nobuflisted noswapfile nowrap number + for l in lines + call append(line('$') - 1, l) + endfor + let &modified = 0 + else + execute winnr . 'wincmd w' + endif +endfunction " }}}2 + +function! s:GetMavenProperties() " {{{2 + let mvn_properties = {} + let pom = syntastic#util#findFileInParent('pom.xml', expand('%:p:h', 1)) + if s:has_maven && filereadable(pom) + if !has_key(g:syntastic_java_javac_maven_pom_properties, pom) + let mvn_cmd = syntastic#util#shexpand(g:syntastic_java_maven_executable) . + \ ' -f ' . syntastic#util#shescape(pom) . + \ ' ' . g:syntastic_java_maven_options + let mvn_is_managed_tag = 1 + let mvn_settings_output = split(syntastic#util#system(mvn_cmd . ' help:effective-pom'), "\n") + let current_path = 'project' + for line in mvn_settings_output + let matches = matchlist(line, '\m^\s*<\([a-zA-Z0-9\-\.]\+\)>\s*$') + if mvn_is_managed_tag && !empty(matches) + let mvn_is_managed_tag = index(g:syntastic_java_javac_maven_pom_tags, matches[1]) >= 0 + let current_path .= '.' . matches[1] + else + let matches = matchlist(line, '\m^\s*</\([a-zA-Z0-9\-\.]\+\)>\s*$') + if !empty(matches) + let mvn_is_managed_tag = index(g:syntastic_java_javac_maven_pom_tags, matches[1]) < 0 + let current_path = substitute(current_path, '\m\.' . matches[1] . '$', '', '') + else + let matches = matchlist(line, '\m^\s*<\([a-zA-Z0-9\-\.]\+\)>\(.\+\)</[a-zA-Z0-9\-\.]\+>\s*$') + if mvn_is_managed_tag && !empty(matches) + let mvn_properties[current_path . '.' . matches[1]] = matches[2] + endif + endif + endif + endfor + let g:syntastic_java_javac_maven_pom_properties[pom] = mvn_properties + endif + return g:syntastic_java_javac_maven_pom_properties[pom] + endif + return mvn_properties +endfunction " }}}2 + +function! s:GetMavenClasspath() " {{{2 + let pom = syntastic#util#findFileInParent('pom.xml', expand('%:p:h', 1)) + if s:has_maven && filereadable(pom) + if !has_key(g:syntastic_java_javac_maven_pom_ftime, pom) || g:syntastic_java_javac_maven_pom_ftime[pom] != getftime(pom) + let mvn_cmd = syntastic#util#shexpand(g:syntastic_java_maven_executable) . + \ ' -f ' . syntastic#util#shescape(pom) . + \ ' ' . g:syntastic_java_maven_options + let mvn_classpath_output = split(syntastic#util#system(mvn_cmd . ' dependency:build-classpath -DincludeScope=test'), "\n") + let mvn_classpath = '' + let class_path_next = 0 + + for line in mvn_classpath_output + if class_path_next == 1 + let mvn_classpath = s:RemoveCarriageReturn(line) + break + endif + if stridx(line, 'Dependencies classpath:') >= 0 + let class_path_next = 1 + endif + endfor + + let mvn_properties = s:GetMavenProperties() + + let sep = syntastic#util#Slash() + let output_dir = get(mvn_properties, 'project.build.outputDirectory', join(['target', 'classes'], sep)) + let mvn_classpath = s:AddToClasspath(mvn_classpath, output_dir) + + let test_output_dir = get(mvn_properties, 'project.build.testOutputDirectory', join(['target', 'test-classes'], sep)) + 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 " }}}2 + +function! s:MavenOutputDirectory() " {{{2 + let pom = syntastic#util#findFileInParent('pom.xml', expand('%:p:h', 1)) + if s:has_maven && filereadable(pom) + let mvn_properties = s:GetMavenProperties() + let output_dir = get(mvn_properties, 'project.properties.build.dir', getcwd()) + + let sep = syntastic#util#Slash() + let src_main_dir = get(mvn_properties, 'project.build.sourceDirectory', join(['src', 'main', 'java'], sep)) + let src_test_dir = get(mvn_properties, 'project.build.testsourceDirectory', join(['src', 'test', 'java'], sep)) + if stridx(expand('%:p:h', 1), src_main_dir) >= 0 + let output_dir = get(mvn_properties, 'project.build.outputDirectory', join ([output_dir, 'target', 'classes'], sep)) + endif + if stridx(expand('%:p:h', 1), src_test_dir) >= 0 + let output_dir = get(mvn_properties, 'project.build.testOutputDirectory', join([output_dir, 'target', 'test-classes'], sep)) + endif + + if has('win32unix') + let output_dir = syntastic#util#CygwinPath(output_dir) + endif + return output_dir + endif + return '.' +endfunction " }}}2 + +" }}}1 + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'java', + \ 'name': 'javac'}) + +let &cpo = s:save_cpo +unlet s:save_cpo + +" vim: set sw=4 sts=4 et fdm=marker: diff --git a/vim/bundle/syntastic/syntax_checkers/javascript/closurecompiler.vim b/vim/bundle/syntastic/syntax_checkers/javascript/closurecompiler.vim new file mode 100644 index 0000000..8c4190a --- /dev/null +++ b/vim/bundle/syntastic/syntax_checkers/javascript/closurecompiler.vim @@ -0,0 +1,76 @@ +"============================================================================ +"File: closurecompiler.vim +"Description: Javascript syntax checker - using Google Closure Compiler +"Maintainer: Motohiro Takayama <mootoh at gmail dot com> +"License: This program is free software. It comes without any warranty, +" to the extent permitted by applicable law. You can redistribute +" it and/or modify it under the terms of the Do What The Fuck You +" Want To Public License, Version 2, as published by Sam Hocevar. +" See http://sam.zoy.org/wtfpl/COPYING for more details. +"============================================================================ + +if exists('g:loaded_syntastic_javascript_closurecompiler_checker') + finish +endif +let g:loaded_syntastic_javascript_closurecompiler_checker = 1 + +let s:save_cpo = &cpo +set cpo&vim + +function! SyntaxCheckers_javascript_closurecompiler_IsAvailable() dict + call syntastic#log#deprecationWarn('javascript_closure_compiler_path', 'javascript_closurecompiler_path') + + if !executable(self.getExec()) + return 0 + endif + + let s:has_script = exists('g:syntastic_javascript_closurecompiler_script') + if s:has_script + return 1 + endif + + let cp = get(g:, 'syntastic_javascript_closurecompiler_path', '') + call self.log('g:syntastic_javascript_closurecompiler_path =', cp) + + let jar = expand(cp, 1) + call self.log('filereadable(' . string(jar) . ') = ' . filereadable(jar)) + + return filereadable(jar) +endfunction + +function! SyntaxCheckers_javascript_closurecompiler_GetLocList() dict + call syntastic#log#deprecationWarn('javascript_closure_compiler_options', 'javascript_closurecompiler_args') + call syntastic#log#deprecationWarn('javascript_closure_compiler_file_list', 'javascript_closurecompiler_file_list') + + let flist = expand(get(g:, 'syntastic_javascript_closurecompiler_file_list', ''), 1) + if filereadable(flist) + let file_list = map( readfile(flist), 'expand(v:var, 1)' ) + else + let file_list = [expand('%', 1)] + endif + + let makeprg = self.makeprgBuild({ + \ 'exe_after': (s:has_script ? [] : ['-jar', expand(g:syntastic_javascript_closurecompiler_path, 1)]), + \ 'args_after': '--js', + \ 'fname': file_list }) + + let errorformat = + \ '%-GOK,'. + \ '%E%f:%l: ERROR - %m,'. + \ '%W%f:%l: WARNING - %m,'. + \ '%Z%p^' + + return SyntasticMake({ + \ 'makeprg': makeprg, + \ 'errorformat': errorformat }) +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'javascript', + \ 'name': 'closurecompiler', + \ 'exec': get(g:, 'syntastic_javascript_closurecompiler_script', 'java')}) + +let &cpo = s:save_cpo +unlet s:save_cpo + +" vim: set sw=4 sts=4 et fdm=marker: diff --git a/vim/bundle/syntastic/syntax_checkers/javascript/eslint.vim b/vim/bundle/syntastic/syntax_checkers/javascript/eslint.vim new file mode 100644 index 0000000..437bc55 --- /dev/null +++ b/vim/bundle/syntastic/syntax_checkers/javascript/eslint.vim @@ -0,0 +1,78 @@ +"============================================================================ +"File: eslint.vim +"Description: Javascript syntax checker - using eslint +"Maintainer: Maksim Ryzhikov <rv.maksim at gmail dot com> +"License: This program is free software. It comes without any warranty, +" to the extent permitted by applicable law. You can redistribute +" it and/or modify it under the terms of the Do What The Fuck You +" Want To Public License, Version 2, as published by Sam Hocevar. +" See http://sam.zoy.org/wtfpl/COPYING for more details. +"============================================================================ + +if exists('g:loaded_syntastic_javascript_eslint_checker') + finish +endif +let g:loaded_syntastic_javascript_eslint_checker = 1 + +if !exists('g:syntastic_javascript_eslint_sort') + let g:syntastic_javascript_eslint_sort = 1 +endif + +if !exists('g:syntastic_javascript_eslint_generic') + let g:syntastic_javascript_eslint_generic = 0 +endif + +let s:save_cpo = &cpo +set cpo&vim + +function! SyntaxCheckers_javascript_eslint_IsAvailable() dict + if g:syntastic_javascript_eslint_generic + call self.log('generic eslint, exec =', self.getExec()) + endif + + if !executable(self.getExec()) + return 0 + endif + return g:syntastic_javascript_eslint_generic || syntastic#util#versionIsAtLeast(self.getVersion(), [0, 1]) +endfunction + +function! SyntaxCheckers_javascript_eslint_GetLocList() dict + if !g:syntastic_javascript_eslint_generic + call syntastic#log#deprecationWarn('javascript_eslint_conf', 'javascript_eslint_args', + \ "'--config ' . syntastic#util#shexpand(OLD_VAR)") + endif + + let makeprg = self.makeprgBuild({ 'args_before': (g:syntastic_javascript_eslint_generic ? '' : '-f compact') }) + + let errorformat = + \ '%E%f: line %l\, col %c\, Error - %m,' . + \ '%W%f: line %l\, col %c\, Warning - %m' + + let loclist = SyntasticMake({ + \ 'makeprg': makeprg, + \ 'errorformat': errorformat, + \ 'postprocess': ['guards'] }) + + if !g:syntastic_javascript_eslint_generic + if !exists('s:eslint_new') + let s:eslint_new = syntastic#util#versionIsAtLeast(self.getVersion(), [1]) + endif + + if !s:eslint_new + for e in loclist + let e['col'] += 1 + endfor + endif + endif + + return loclist +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'javascript', + \ 'name': 'eslint'}) + +let &cpo = s:save_cpo +unlet s:save_cpo + +" vim: set sw=4 sts=4 et fdm=marker: diff --git a/vim/bundle/syntastic/syntax_checkers/javascript/flow.vim b/vim/bundle/syntastic/syntax_checkers/javascript/flow.vim new file mode 100644 index 0000000..13ee47a --- /dev/null +++ b/vim/bundle/syntastic/syntax_checkers/javascript/flow.vim @@ -0,0 +1,67 @@ +"============================================================================ +"File: flow.vim +"Description: Javascript syntax checker - using flow +"Maintainer: Michael Robinson <mike@pagesofinterest.net> +"License: This program is free software. It comes without any warranty, +" to the extent permitted by applicable law. You can redistribute +" it and/or modify it under the terms of the Do What The Fuck You +" Want To Public License, Version 2, as published by Sam Hocevar. +" See http://sam.zoy.org/wtfpl/COPYING for more details. +"============================================================================ + +if exists('g:loaded_syntastic_javascript_flow_checker') + finish +endif +let g:loaded_syntastic_javascript_flow_checker = 1 + +if !exists('g:syntastic_javascript_flow_sort') + let g:syntastic_javascript_flow_sort = 1 +endif + +let s:save_cpo = &cpo +set cpo&vim + +function! SyntaxCheckers_javascript_flow_IsAvailable() dict + if !executable(self.getExec()) + return 0 + endif + return syntastic#util#versionIsAtLeast(self.getVersion(), [0, 6]) +endfunction + +function! SyntaxCheckers_javascript_flow_GetLocList() dict + if syntastic#util#findFileInParent('.flowconfig', expand('%:p:h', 1)) ==# '' + return [] + endif + + let makeprg = self.makeprgBuild({ + \ 'exe': self.getExecEscaped() . ' check', + \ 'args_after': '--show-all-errors --json' }) + + let errorformat = + \ '%f:%l:%c:%n: %m,' . + \ '%f:%l:%c: %m' + + let loclist = SyntasticMake({ + \ 'makeprg': makeprg, + \ 'errorformat': errorformat, + \ 'preprocess': 'flow', + \ 'defaults': {'type': 'E'} }) + + for e in loclist + if get(e, 'col', 0) && get(e, 'nr', 0) + let e['hl'] = '\%>' . (e['col'] - 1) . 'c\%<' . (e['nr'] + 1) . 'c' + let e['nr'] = 0 + endif + endfor + + return loclist +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'javascript', + \ 'name': 'flow'}) + +let &cpo = s:save_cpo +unlet s:save_cpo + +" vim: set sw=4 sts=4 et fdm=marker: diff --git a/vim/bundle/syntastic/syntax_checkers/javascript/gjslint.vim b/vim/bundle/syntastic/syntax_checkers/javascript/gjslint.vim new file mode 100644 index 0000000..3368905 --- /dev/null +++ b/vim/bundle/syntastic/syntax_checkers/javascript/gjslint.vim @@ -0,0 +1,46 @@ +"============================================================================ +"File: gjslint.vim +"Description: Javascript syntax checker - using gjslint +"Maintainer: Martin Grenfell <martin.grenfell at gmail dot com> +"License: This program is free software. It comes without any warranty, +" to the extent permitted by applicable law. You can redistribute +" it and/or modify it under the terms of the Do What The Fuck You +" Want To Public License, Version 2, as published by Sam Hocevar. +" See http://sam.zoy.org/wtfpl/COPYING for more details. +"============================================================================ + +if exists('g:loaded_syntastic_javascript_gjslint_checker') + finish +endif +let g:loaded_syntastic_javascript_gjslint_checker = 1 + +let s:save_cpo = &cpo +set cpo&vim + +function! SyntaxCheckers_javascript_gjslint_GetLocList() dict + call syntastic#log#deprecationWarn('javascript_gjslint_conf', 'javascript_gjslint_args') + + let makeprg = self.makeprgBuild({ + \ 'args': '--nodebug_indentation', + \ 'args_after': '--check_html --nosummary --unix_mode --nobeep' }) + + let errorformat = + \ "%f:%l:(New Error -%\\?\%n) %m," . + \ "%f:%l:(-%\\?%n) %m," . + \ "%-G1 files checked," . + \ " no errors found.," . + \ "%-G%.%#" + + return SyntasticMake({ + \ 'makeprg': makeprg, + \ 'errorformat': errorformat }) +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'javascript', + \ 'name': 'gjslint'}) + +let &cpo = s:save_cpo +unlet s:save_cpo + +" vim: set sw=4 sts=4 et fdm=marker: diff --git a/vim/bundle/syntastic/syntax_checkers/javascript/jscs.vim b/vim/bundle/syntastic/syntax_checkers/javascript/jscs.vim new file mode 100644 index 0000000..d259086 --- /dev/null +++ b/vim/bundle/syntastic/syntax_checkers/javascript/jscs.vim @@ -0,0 +1,53 @@ +"============================================================================ +"File: jscs.vim +"Description: Javascript syntax checker - using jscs +"Maintainer: LCD 47 <lcd047@gmail.com> +"License: This program is free software. It comes without any warranty, +" to the extent permitted by applicable law. You can redistribute +" it and/or modify it under the terms of the Do What The Fuck You +" Want To Public License, Version 2, as published by Sam Hocevar. +" See http://sam.zoy.org/wtfpl/COPYING for more details. +"============================================================================ + +if exists('g:loaded_syntastic_javascript_jscs_checker') + finish +endif +let g:loaded_syntastic_javascript_jscs_checker = 1 + +if !exists('g:syntastic_javascript_jscs_sort') + let g:syntastic_javascript_jscs_sort = 1 +endif + +let s:save_cpo = &cpo +set cpo&vim + +function! SyntaxCheckers_javascript_jscs_IsAvailable() dict + if !executable(self.getExec()) + return 0 + endif + return syntastic#util#versionIsAtLeast(self.getVersion(), [2, 1]) +endfunction + +function! SyntaxCheckers_javascript_jscs_GetLocList() dict + let makeprg = self.makeprgBuild({ + \ 'args_after': '--no-colors --max-errors -1 --reporter json' }) + + let errorformat = '%f:%l:%c:%m' + + return SyntasticMake({ + \ 'makeprg': makeprg, + \ 'errorformat': errorformat, + \ 'subtype': 'Style', + \ 'preprocess': 'jscs', + \ 'defaults': {'type': 'E'}, + \ 'returns': [0, 2] }) +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'javascript', + \ 'name': 'jscs'}) + +let &cpo = s:save_cpo +unlet s:save_cpo + +" vim: set sw=4 sts=4 et fdm=marker: diff --git a/vim/bundle/syntastic/syntax_checkers/javascript/jshint.vim b/vim/bundle/syntastic/syntax_checkers/javascript/jshint.vim new file mode 100644 index 0000000..492aa69 --- /dev/null +++ b/vim/bundle/syntastic/syntax_checkers/javascript/jshint.vim @@ -0,0 +1,60 @@ +"============================================================================ +"File: jshint.vim +"Description: Javascript syntax checker - using jshint +"Maintainer: Martin Grenfell <martin.grenfell at gmail dot com> +"License: This program is free software. It comes without any warranty, +" to the extent permitted by applicable law. You can redistribute +" it and/or modify it under the terms of the Do What The Fuck You +" Want To Public License, Version 2, as published by Sam Hocevar. +" See http://sam.zoy.org/wtfpl/COPYING for more details. +"============================================================================ + +if exists('g:loaded_syntastic_javascript_jshint_checker') + finish +endif +let g:loaded_syntastic_javascript_jshint_checker = 1 + +if !exists('g:syntastic_javascript_jshint_sort') + let g:syntastic_javascript_jshint_sort = 1 +endif + +let s:save_cpo = &cpo +set cpo&vim + +function! SyntaxCheckers_javascript_jshint_IsAvailable() dict + call syntastic#log#deprecationWarn('jshint_exec', 'javascript_jshint_exec') + if !executable(self.getExec()) + return 0 + endif + + let ver = self.getVersion() + let s:jshint_new = syntastic#util#versionIsAtLeast(ver, [1, 1]) + + return syntastic#util#versionIsAtLeast(ver, [1]) +endfunction + +function! SyntaxCheckers_javascript_jshint_GetLocList() dict + call syntastic#log#deprecationWarn('javascript_jshint_conf', 'javascript_jshint_args', + \ "'--config ' . syntastic#util#shexpand(OLD_VAR)") + + let makeprg = self.makeprgBuild({ 'args_after': (s:jshint_new ? '--verbose ' : '') }) + + let errorformat = s:jshint_new ? + \ '%A%f: line %l\, col %v\, %m \(%t%*\d\)' : + \ '%E%f: line %l\, col %v\, %m' + + return SyntasticMake({ + \ 'makeprg': makeprg, + \ 'errorformat': errorformat, + \ 'defaults': {'bufnr': bufnr('')}, + \ 'returns': [0, 2] }) +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'javascript', + \ 'name': 'jshint'}) + +let &cpo = s:save_cpo +unlet s:save_cpo + +" vim: set sw=4 sts=4 et fdm=marker: diff --git a/vim/bundle/syntastic/syntax_checkers/javascript/jsl.vim b/vim/bundle/syntastic/syntax_checkers/javascript/jsl.vim new file mode 100644 index 0000000..aa9862b --- /dev/null +++ b/vim/bundle/syntastic/syntax_checkers/javascript/jsl.vim @@ -0,0 +1,48 @@ +"============================================================================ +"File: jsl.vim +"Description: Javascript syntax checker - using jsl +"Maintainer: Martin Grenfell <martin.grenfell at gmail dot com> +"License: This program is free software. It comes without any warranty, +" to the extent permitted by applicable law. You can redistribute +" it and/or modify it under the terms of the Do What The Fuck You +" Want To Public License, Version 2, as published by Sam Hocevar. +" See http://sam.zoy.org/wtfpl/COPYING for more details. +"============================================================================ + +if exists('g:loaded_syntastic_javascript_jsl_checker') + finish +endif +let g:loaded_syntastic_javascript_jsl_checker = 1 + +let s:save_cpo = &cpo +set cpo&vim + +function! SyntaxCheckers_javascript_jsl_GetLocList() dict + call syntastic#log#deprecationWarn('javascript_jsl_conf', 'javascript_jsl_args', + \ "'-conf ' . syntastic#util#shexpand(OLD_VAR)") + + let makeprg = self.makeprgBuild({ + \ 'args_after': '-nologo -nofilelisting -nosummary -nocontext -process' }) + + 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'}) + +let &cpo = s:save_cpo +unlet s:save_cpo + +" vim: set sw=4 sts=4 et fdm=marker: diff --git a/vim/bundle/syntastic/syntax_checkers/javascript/jslint.vim b/vim/bundle/syntastic/syntax_checkers/javascript/jslint.vim new file mode 100644 index 0000000..e2ce76c --- /dev/null +++ b/vim/bundle/syntastic/syntax_checkers/javascript/jslint.vim @@ -0,0 +1,51 @@ +"============================================================================ +"File: jslint.vim +"Description: Javascript syntax checker - using jslint +"Maintainer: Martin Grenfell <martin.grenfell at gmail dot com> +"License: This program is free software. It comes without any warranty, +" to the extent permitted by applicable law. You can redistribute +" it and/or modify it under the terms of the Do What The Fuck You +" Want To Public License, Version 2, as published by Sam Hocevar. +" See http://sam.zoy.org/wtfpl/COPYING for more details. +" +"============================================================================ + +if exists('g:loaded_syntastic_javascript_jslint_checker') + finish +endif + +let g:loaded_syntastic_javascript_jslint_checker = 1 + +let s:save_cpo = &cpo +set cpo&vim + +function! SyntaxCheckers_javascript_jslint_GetHighlightRegex(item) + let term = matchstr(a:item['text'], '\mExpected .* and instead saw ''\zs.*\ze''') + if term !=# '' + let term = '\V\<' . escape(term, '\') . '\>' + endif + return term +endfunction + +function! SyntaxCheckers_javascript_jslint_GetLocList() dict + let makeprg = self.makeprgBuild({ 'args': '--white --nomen --regexp --plusplus --bitwise --newcap --sloppy --vars' }) + + let errorformat = + \ '%E %##%\d%\+ %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'}) + +let &cpo = s:save_cpo +unlet s:save_cpo + +" vim: set sw=4 sts=4 et fdm=marker: diff --git a/vim/bundle/syntastic/syntax_checkers/javascript/jsxhint.vim b/vim/bundle/syntastic/syntax_checkers/javascript/jsxhint.vim new file mode 100644 index 0000000..e29ce06 --- /dev/null +++ b/vim/bundle/syntastic/syntax_checkers/javascript/jsxhint.vim @@ -0,0 +1,56 @@ +"============================================================================ +"File: jsxhint.vim +"Description: Javascript syntax checker - using jsxhint +"Maintainer: Thomas Boyt <me@thomasboyt.com> +"License: This program is free software. It comes without any warranty, +" to the extent permitted by applicable law. You can redistribute +" it and/or modify it under the terms of the Do What The Fuck You +" Want To Public License, Version 2, as published by Sam Hocevar. +" See http://sam.zoy.org/wtfpl/COPYING for more details. +"============================================================================ + +if exists('g:loaded_syntastic_javascript_jsxhint_checker') + finish +endif +let g:loaded_syntastic_javascript_jsxhint_checker = 1 + +let s:save_cpo = &cpo +set cpo&vim + +function! SyntaxCheckers_javascript_jsxhint_IsAvailable() dict " {{{1 + if !executable(self.getExec()) + return 0 + endif + + let version_output = syntastic#util#system(self.getExecEscaped() . ' --version') + let parsed_ver = !v:shell_error && (version_output =~# '\m^JSXHint\>') ? syntastic#util#parseVersion(version_output) : [] + if len(parsed_ver) + call self.setVersion(parsed_ver) + else + call syntastic#log#ndebug(g:_SYNTASTIC_DEBUG_LOCLIST, 'checker output:', split(version_output, "\n", 1)) + call syntastic#log#error("checker javascript/jsxhint: can't parse version string (abnormal termination?)") + endif + + return syntastic#util#versionIsAtLeast(parsed_ver, [0, 4, 1]) +endfunction " }}}1 + +function! SyntaxCheckers_javascript_jsxhint_GetLocList() dict " {{{1 + let makeprg = self.makeprgBuild({ + \ 'args_after': '--verbose' }) + + let errorformat = '%A%f: line %l\, col %v\, %m \(%t%*\d\)' + + return SyntasticMake({ + \ 'makeprg': makeprg, + \ 'errorformat': errorformat, + \ 'defaults': {'bufnr': bufnr('')} }) +endfunction " }}}1 + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'javascript', + \ 'name': 'jsxhint'}) + +let &cpo = s:save_cpo +unlet s:save_cpo + +" vim: set sw=4 sts=4 et fdm=marker: diff --git a/vim/bundle/syntastic/syntax_checkers/javascript/mixedindentlint.vim b/vim/bundle/syntastic/syntax_checkers/javascript/mixedindentlint.vim new file mode 100644 index 0000000..2995409 --- /dev/null +++ b/vim/bundle/syntastic/syntax_checkers/javascript/mixedindentlint.vim @@ -0,0 +1,40 @@ +"============================================================================ +"File: mixedindentlint.vim +"Description: Mixed indentation linter for vim +"Maintainer: Payton Swick <payton@foolord.com> +"License: This program is free software. It comes without any warranty, +" to the extent permitted by applicable law. You can redistribute +" it and/or modify it under the terms of the Do What The Fuck You +" Want To Public License, Version 2, as published by Sam Hocevar. +" See http://sam.zoy.org/wtfpl/COPYING for more details. +"============================================================================ + +if exists('g:loaded_syntastic_javascript_mixedindentlint_checker') + finish +endif +let g:loaded_syntastic_javascript_mixedindentlint_checker = 1 + +let s:save_cpo = &cpo +set cpo&vim + +function! SyntaxCheckers_javascript_mixedindentlint_GetLocList() dict + let makeprg = self.makeprgBuild({}) + + let errorformat = 'Line %l in "%f" %.%#' + + return SyntasticMake({ + \ 'makeprg': makeprg, + \ 'errorformat': errorformat, + \ 'subtype': 'Style', + \ 'defaults': { 'text': 'Indentation differs from rest of file' }, + \ 'returns': [0, 1] }) +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'javascript', + \ 'name': 'mixedindentlint'}) + +let &cpo = s:save_cpo +unlet s:save_cpo + +" vim: set sw=4 sts=4 et fdm=marker: diff --git a/vim/bundle/syntastic/syntax_checkers/javascript/standard.vim b/vim/bundle/syntastic/syntax_checkers/javascript/standard.vim new file mode 100644 index 0000000..e652bd0 --- /dev/null +++ b/vim/bundle/syntastic/syntax_checkers/javascript/standard.vim @@ -0,0 +1,55 @@ +"============================================================================ +"File: standard.vim +"Description: JavaScript syntax checker - using standard +"Maintainer: LCD 47 <lcd047@gmail.com> +"License: This program is free software. It comes without any warranty, +" to the extent permitted by applicable law. You can redistribute +" it and/or modify it under the terms of the Do What The Fuck You +" Want To Public License, Version 2, as published by Sam Hocevar. +" See http://sam.zoy.org/wtfpl/COPYING for more details. +"============================================================================ + +if exists('g:loaded_syntastic_javascript_standard_checker') + finish +endif +let g:loaded_syntastic_javascript_standard_checker = 1 + +if !exists('g:syntastic_javascript_standard_generic') + let g:syntastic_javascript_standard_generic = 0 +endif + +let s:save_cpo = &cpo +set cpo&vim + +function! SyntaxCheckers_javascript_standard_IsAvailable() dict + if g:syntastic_javascript_standard_generic + call self.log('generic standard, exec =', self.getExec()) + endif + + if !executable(self.getExec()) + return 0 + endif + return g:syntastic_javascript_standard_generic || syntastic#util#versionIsAtLeast(self.getVersion(), [2, 6, 1]) +endfunction + +function! SyntaxCheckers_javascript_standard_GetLocList() dict + let makeprg = self.makeprgBuild({ 'args': '-v' }) + + let errorformat = ' %f:%l:%c: %m' + + return SyntasticMake({ + \ 'makeprg': makeprg, + \ 'errorformat': errorformat, + \ 'subtype': 'Style', + \ 'defaults': {'type': 'W'}, + \ 'returns': [0, 1] }) +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'javascript', + \ 'name': 'standard'}) + +let &cpo = s:save_cpo +unlet s:save_cpo + +" vim: set sw=4 sts=4 et fdm=marker: diff --git a/vim/bundle/syntastic/syntax_checkers/javascript/tern_lint.vim b/vim/bundle/syntastic/syntax_checkers/javascript/tern_lint.vim new file mode 100644 index 0000000..547942b --- /dev/null +++ b/vim/bundle/syntastic/syntax_checkers/javascript/tern_lint.vim @@ -0,0 +1,53 @@ +"============================================================================ +"File: tern_lint.vim +"Description: Syntax checking plugin for syntastic +"Maintainer: LCD 47 <lcd047@gmail.com> +"License: This program is free software. It comes without any warranty, +" to the extent permitted by applicable law. You can redistribute +" it and/or modify it under the terms of the Do What The Fuck You +" Want To Public License, Version 2, as published by Sam Hocevar. +" See http://sam.zoy.org/wtfpl/COPYING for more details. +"============================================================================ + +if exists('g:loaded_syntastic_javascript_tern_lint_checker') + finish +endif +let g:loaded_syntastic_javascript_tern_lint_checker = 1 + +let s:save_cpo = &cpo +set cpo&vim + +function! SyntaxCheckers_javascript_tern_lint_IsAvailable() dict + return has('byte_offset') && executable(self.getExec()) +endfunction + +function! SyntaxCheckers_javascript_tern_lint_GetLocList() dict + let makeprg = self.makeprgBuild({}) + + let errorformat = '%f:%t:%l:%c:%n:%m' + + let loclist = SyntasticMake({ + \ 'makeprg': makeprg, + \ 'errorformat': errorformat, + \ 'preprocess': 'tern_lint', + \ 'returns': [0] }) + + for e in loclist + if get(e, 'col', 0) && get(e, 'nr', 0) + let e['hl'] = '\%>' . (e['col'] - 1) . 'c\%<' . (e['nr'] + 1) . 'c' + endif + let e['nr'] = 0 + endfor + + return loclist +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'javascript', + \ 'name': 'tern_lint', + \ 'exec': 'tern-lint' }) + +let &cpo = s:save_cpo +unlet s:save_cpo + +" vim: set sw=4 sts=4 et fdm=marker: diff --git a/vim/bundle/syntastic/syntax_checkers/json/jsonlint.vim b/vim/bundle/syntastic/syntax_checkers/json/jsonlint.vim new file mode 100644 index 0000000..9a89c78 --- /dev/null +++ b/vim/bundle/syntastic/syntax_checkers/json/jsonlint.vim @@ -0,0 +1,43 @@ +"============================================================================ +"File: jsonlint.vim +"Description: JSON syntax checker - using jsonlint +"Maintainer: Miller Medeiros <contact at millermedeiros dot com> +"License: This program is free software. It comes without any warranty, +" to the extent permitted by applicable law. You can redistribute +" it and/or modify it under the terms of the Do What The Fuck You +" Want To Public License, Version 2, as published by Sam Hocevar. +" See http://sam.zoy.org/wtfpl/COPYING for more details. +"============================================================================ + +if exists('g:loaded_syntastic_json_jsonlint_checker') + finish +endif +let g:loaded_syntastic_json_jsonlint_checker = 1 + +let s:save_cpo = &cpo +set cpo&vim + +function! SyntaxCheckers_json_jsonlint_GetLocList() dict + let makeprg = self.makeprgBuild({ 'post_args_after': '--compact' }) + + let errorformat = + \ '%ELine %l:%c,'. + \ '%Z\\s%#Reason: %m,'. + \ '%C%.%#,'. + \ '%f: line %l\, col %c\, %m,'. + \ '%-G%.%#' + + return SyntasticMake({ + \ 'makeprg': makeprg, + \ 'errorformat': errorformat, + \ 'defaults': {'bufnr': bufnr('')} }) +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'json', + \ 'name': 'jsonlint'}) + +let &cpo = s:save_cpo +unlet s:save_cpo + +" vim: set sw=4 sts=4 et fdm=marker: diff --git a/vim/bundle/syntastic/syntax_checkers/json/jsonval.vim b/vim/bundle/syntastic/syntax_checkers/json/jsonval.vim new file mode 100644 index 0000000..2a756b6 --- /dev/null +++ b/vim/bundle/syntastic/syntax_checkers/json/jsonval.vim @@ -0,0 +1,41 @@ +"============================================================================ +"File: jsonval.vim +"Description: JSON syntax checker - using jsonval +"Maintainer: Miller Medeiros <contact at millermedeiros dot com> +"License: This program is free software. It comes without any warranty, +" to the extent permitted by applicable law. You can redistribute +" it and/or modify it under the terms of the Do What The Fuck You +" Want To Public License, Version 2, as published by Sam Hocevar. +" See http://sam.zoy.org/wtfpl/COPYING for more details. +"============================================================================ + +if exists('g:loaded_syntastic_json_jsonval_checker') + finish +endif +let g:loaded_syntastic_json_jsonval_checker = 1 + +let s:save_cpo = &cpo +set cpo&vim + +function! SyntaxCheckers_json_jsonval_GetLocList() dict + " based on https://gist.github.com/1196345 + let makeprg = self.makeprgBuild({}) + + 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'}) + +let &cpo = s:save_cpo +unlet s:save_cpo + +" vim: set sw=4 sts=4 et fdm=marker: diff --git a/vim/bundle/syntastic/syntax_checkers/less/less-lint.coffee b/vim/bundle/syntastic/syntax_checkers/less/less-lint.coffee new file mode 100644 index 0000000..0b05e4a --- /dev/null +++ b/vim/bundle/syntastic/syntax_checkers/less/less-lint.coffee @@ -0,0 +1,41 @@ +#!/usr/bin/env node + +fs = require 'fs' +less = require 'less' +args = process.argv.slice(1) +options = {} + +args = args.filter (arg) -> + match = arg.match(/^-I(.+)$/) + if match + options.paths.push(match[1]); + return false + + match = arg.match(/^--?([a-z][\-0-9a-z]*)(?:=([^\s]+))?$/i) + if match + arg = match[1] + else + return arg + + switch arg + when 'strict-imports' then options.strictImports = true + when 'include-path' + options.paths = match[2].split(if os.type().match(/Windows/) then ';' else ':') + .map (p) -> + if p + return path.resolve(process.cwd(), p) + when 'O0' then options.optimization = 0 + when 'O1' then options.optimization = 1 + when 'O2' then options.optimization = 2 + +options.filename = args[1] + +parser = new(less.Parser) options + +fs.readFile(options.filename, 'utf-8', (err,data) -> + parser.parse(data, (err, tree) -> + if err + less.writeError err + process.exit(1) + ) +) diff --git a/vim/bundle/syntastic/syntax_checkers/less/less-lint.js b/vim/bundle/syntastic/syntax_checkers/less/less-lint.js new file mode 100644 index 0000000..5abc653 --- /dev/null +++ b/vim/bundle/syntastic/syntax_checkers/less/less-lint.js @@ -0,0 +1,57 @@ +// Generated by CoffeeScript 1.3.3 +(function() { + var args, fs, less, options, parser; + + fs = require('fs'); + + less = require('less'); + + args = process.argv.slice(1); + + options = {}; + + args = args.filter(function(arg) { + var match; + match = arg.match(/^-I(.+)$/); + if (match) { + options.paths.push(match[1]); + return false; + } + match = arg.match(/^--?([a-z][\-0-9a-z]*)(?:=([^\s]+))?$/i); + if (match) { + arg = match[1]; + } else { + return arg; + } + switch (arg) { + case 'strict-imports': + return options.strictImports = true; + case 'include-path': + return options.paths = match[2].split(os.type().match(/Windows/) ? ';' : ':').map(function(p) { + if (p) { + return path.resolve(process.cwd(), p); + } + }); + case 'O0': + return options.optimization = 0; + case 'O1': + return options.optimization = 1; + case 'O2': + return options.optimization = 2; + } + }); + + options.filename = args[1]; + + parser = new less.Parser(options); + + fs.readFile(options.filename, 'utf-8', function(err, data) { + return parser.parse(data, function(err, tree) { + if (err) { + less.writeError(err); + return process.exit(1); + } + }); + }); + +}).call(this); diff --git a/vim/bundle/syntastic/syntax_checkers/less/lessc.vim b/vim/bundle/syntastic/syntax_checkers/less/lessc.vim new file mode 100644 index 0000000..ad4035e --- /dev/null +++ b/vim/bundle/syntastic/syntax_checkers/less/lessc.vim @@ -0,0 +1,59 @@ +"============================================================================ +"File: less.vim +"Description: Syntax checking plugin for syntastic.vim +"Maintainer: Julien Blanchard <julien at sideburns dot eu> +"License: This program is free software. It comes without any warranty, +" to the extent permitted by applicable law. You can redistribute +" it and/or modify it under the terms of the Do What The Fuck You +" Want To Public License, Version 2, as published by Sam Hocevar. +" See http://sam.zoy.org/wtfpl/COPYING for more details. +" +"============================================================================ + +if exists('g:loaded_syntastic_less_lessc_checker') + finish +endif +let g:loaded_syntastic_less_lessc_checker = 1 + +if !exists('g:syntastic_less_use_less_lint') + let g:syntastic_less_use_less_lint = 0 +endif + +let s:save_cpo = &cpo +set cpo&vim + +let s:node_file = 'node ' . syntastic#util#shescape(expand('<sfile>:p:h', 1) . syntastic#util#Slash() . 'less-lint.js') + +function! SyntaxCheckers_less_lessc_IsAvailable() dict + call self.log('g:syntastic_less_use_less_lint =', g:syntastic_less_use_less_lint) + return g:syntastic_less_use_less_lint ? executable('node') : executable(self.getExec()) +endfunction + +function! SyntaxCheckers_less_lessc_GetLocList() dict + call syntastic#log#deprecationWarn('less_options', 'less_lessc_args') + + let makeprg = self.makeprgBuild({ + \ 'exe': (g:syntastic_less_use_less_lint ? s:node_file : self.getExecEscaped()), + \ 'args_after': '--no-color', + \ 'tail': '> ' . syntastic#util#DevNull() }) + + let errorformat = + \ '%m in %f on line %l\, column %c:,' . + \ '%m in %f:%l:%c,' . + \ '%-G%.%#' + + return SyntasticMake({ + \ 'makeprg': makeprg, + \ 'errorformat': errorformat, + \ 'postprocess': ['guards'], + \ 'defaults': {'bufnr': bufnr(''), 'text': 'Syntax error'} }) +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'less', + \ 'name': 'lessc'}) + +let &cpo = s:save_cpo +unlet s:save_cpo + +" vim: set sw=4 sts=4 et fdm=marker: diff --git a/vim/bundle/syntastic/syntax_checkers/less/recess.vim b/vim/bundle/syntastic/syntax_checkers/less/recess.vim new file mode 100644 index 0000000..1a8d876 --- /dev/null +++ b/vim/bundle/syntastic/syntax_checkers/less/recess.vim @@ -0,0 +1,44 @@ +"============================================================================ +"File: recess.vim +"Description: Syntax checking plugin for syntastic.vim using `recess` +" (http://twitter.github.io/recess/). +"Maintainer: Tim Carry <tim at pixelastic dot com> +"License: This program is free software. It comes without any warranty, +" to the extent permitted by applicable law. You can redistribute +" it and/or modify it under the terms of the Do What The Fuck You +" Want To Public License, Version 2, as published by Sam Hocevar. +" See http://sam.zoy.org/wtfpl/COPYING for more details. +" +"============================================================================ + +if exists('g:loaded_syntastic_less_recess_checker') + finish +endif +let g:loaded_syntastic_less_recess_checker = 1 + +let s:save_cpo = &cpo +set cpo&vim + +function! SyntaxCheckers_less_recess_GetLocList() dict + let makeprg = self.makeprgBuild({ + \ 'post_args_after': '--format=compact --stripColors' }) + + let errorformat = + \ '%E%m in %f,' . + \ '%Z %#%l.%.%#,' . + \ '%f:%l:%m,' . + \ '%-G%.%#' + + return SyntasticMake({ + \ 'makeprg': makeprg, + \ 'errorformat': errorformat }) +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'less', + \ 'name': 'recess'}) + +let &cpo = s:save_cpo +unlet s:save_cpo + +" vim: set sw=4 sts=4 et fdm=marker: diff --git a/vim/bundle/syntastic/syntax_checkers/lex/flex.vim b/vim/bundle/syntastic/syntax_checkers/lex/flex.vim new file mode 100644 index 0000000..82cbf10 --- /dev/null +++ b/vim/bundle/syntastic/syntax_checkers/lex/flex.vim @@ -0,0 +1,50 @@ +"============================================================================ +"File: lex.vim +"Description: Syntax checking plugin for syntastic.vim +"Maintainer: LCD 47 <lcd047 at gmail dot com> +"License: This program is free software. It comes without any warranty, +" to the extent permitted by applicable law. You can redistribute +" it and/or modify it under the terms of the Do What The Fuck You +" Want To Public License, Version 2, as published by Sam Hocevar. +" See http://sam.zoy.org/wtfpl/COPYING for more details. +" +"============================================================================ + +if exists('g:loaded_syntastic_lex_flex_checker') + finish +endif +let g:loaded_syntastic_lex_flex_checker = 1 + +let s:save_cpo = &cpo +set cpo&vim + +function! SyntaxCheckers_lex_flex_GetHighlightRegex(item) + let term = matchstr(a:item['text'], + \ '\m^\(unrecognized %option\|bad <start condition>\|bad character\( class expression\)\=\): \zs.*') + if term ==# '' + let term = matchstr(a:item['text'], + \ '\m^\(Definition value for\|undefined definition\) \zs{[^}]\+}\ze') + endif + + return term !=# '' ? '\V' . escape(term, '\') : '' +endfunction + +function! SyntaxCheckers_lex_flex_GetLocList() dict + let makeprg = self.makeprgBuild({ + \ 'args_after': syntastic#c#NullOutput() }) + + let errorformat = '%f:%l: %m' + + return SyntasticMake({ + \ 'makeprg': makeprg, + \ 'errorformat': errorformat }) +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'lex', + \ 'name': 'flex'}) + +let &cpo = s:save_cpo +unlet s:save_cpo + +" vim: set sw=4 sts=4 et fdm=marker: diff --git a/vim/bundle/syntastic/syntax_checkers/limbo/limbo.vim b/vim/bundle/syntastic/syntax_checkers/limbo/limbo.vim new file mode 100644 index 0000000..0dfe03c --- /dev/null +++ b/vim/bundle/syntastic/syntax_checkers/limbo/limbo.vim @@ -0,0 +1,46 @@ +"============================================================================ +"File: limbo.vim +"Description: Syntax checking plugin for syntastic.vim +"Maintainer: Alex Efros <powerman-asdf@ya.ru> +"License: This program is free software. It comes without any warranty, +" to the extent permitted by applicable law. You can redistribute +" it and/or modify it under the terms of the Do What 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_limbo_limbo_checker') + finish +endif +let g:loaded_syntastic_limbo_limbo_checker = 1 + +let s:save_cpo = &cpo +set cpo&vim + +function! SyntaxCheckers_limbo_limbo_GetLocList() dict + let include = $INFERNO_HOME !=# '' ? '-I$INFERNO_HOME ' : '' + " don't generate .dis in current dir while checking syntax, + " .dis should be generated by `mk` + let output = filereadable('mkfile') ? (' ' . syntastic#c#NullOutput()) : '' + + let makeprg = self.makeprgBuild({ 'args_before': include . '-w' . output }) + + let errorformat = '%E%f:%l:%m' + if expand('%', 1) =~# '\m\.m$' + let errorformat = '%-G%f:%l: near ` EOF ` : no implementation module,' . errorformat + endif + + return SyntasticMake({ + \ 'makeprg': makeprg, + \ 'errorformat': errorformat }) +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'limbo', + \ 'name': 'limbo' }) + +let &cpo = s:save_cpo +unlet s:save_cpo + +" vim: set sw=4 sts=4 et fdm=marker: diff --git a/vim/bundle/syntastic/syntax_checkers/lisp/clisp.vim b/vim/bundle/syntastic/syntax_checkers/lisp/clisp.vim new file mode 100644 index 0000000..26de435 --- /dev/null +++ b/vim/bundle/syntastic/syntax_checkers/lisp/clisp.vim @@ -0,0 +1,57 @@ +"============================================================================ +"File: lisp.vim +"Description: Syntax checking plugin for syntastic.vim +"Maintainer: Karl Yngve Lervåg <karl.yngve@lervag.net> +"License: This program is free software. It comes without any warranty, +" to the extent permitted by applicable law. You can redistribute +" it and/or modify it under the terms of the Do What The Fuck You +" Want To Public License, Version 2, as published by Sam Hocevar. +" See http://sam.zoy.org/wtfpl/COPYING for more details. +" +"============================================================================ + +if exists('g:loaded_syntastic_lisp_clisp_checker') + finish +endif +let g:loaded_syntastic_lisp_clisp_checker = 1 + +let s:save_cpo = &cpo +set cpo&vim + +function! SyntaxCheckers_lisp_clisp_GetLocList() dict + let tmpdir = syntastic#util#tmpdir() + let out = tmpdir !=# '.' ? ('-o ' . syntastic#util#shescape(tmpdir . syntastic#util#Slash() . 'syntastic_' . getpid())) : '' + + let makeprg = self.makeprgBuild({ + \ 'args_after': '-q', + \ 'fname_before': '-c', + \ 'post_args_after': out }) + + 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%.%#' + + let loclist = SyntasticMake({ + \ 'makeprg': makeprg, + \ 'errorformat': errorformat, + \ 'defaults': {'bufnr': bufnr('')} }) + + call syntastic#util#rmrf(tmpdir) + + return loclist +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'lisp', + \ 'name': 'clisp'}) + +let &cpo = s:save_cpo +unlet s:save_cpo + +" vim: set sw=4 sts=4 et fdm=marker: diff --git a/vim/bundle/syntastic/syntax_checkers/llvm/llvm.vim b/vim/bundle/syntastic/syntax_checkers/llvm/llvm.vim new file mode 100644 index 0000000..7e90314 --- /dev/null +++ b/vim/bundle/syntastic/syntax_checkers/llvm/llvm.vim @@ -0,0 +1,39 @@ +"============================================================================ +"File: llvm.vim +"Description: Syntax checking plugin for syntastic.vim +"Maintainer: Andrew Kelley <superjoe30@gmail.com> +"License: This program is free software. It comes without any warranty, +" to the extent permitted by applicable law. You can redistribute +" it and/or modify it under the terms of the Do What The Fuck You +" Want To Public License, Version 2, as published by Sam Hocevar. +" See http://sam.zoy.org/wtfpl/COPYING for more details. +" +"============================================================================ + +if exists('g:loaded_syntastic_llvm_llvm_checker') + finish +endif +let g:loaded_syntastic_llvm_llvm_checker = 1 + +let s:save_cpo = &cpo +set cpo&vim + +function! SyntaxCheckers_llvm_llvm_GetLocList() dict + let makeprg = self.makeprgBuild({ 'args_after': syntastic#c#NullOutput() }) + + let errorformat = 'llc: %f:%l:%c: %trror: %m' + + return SyntasticMake({ + \ 'makeprg': makeprg, + \ 'errorformat': errorformat }) +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'llvm', + \ 'name': 'llvm', + \ 'exec': 'llc'}) + +let &cpo = s:save_cpo +unlet s:save_cpo + +" vim: set sw=4 sts=4 et fdm=marker: diff --git a/vim/bundle/syntastic/syntax_checkers/lua/luac.vim b/vim/bundle/syntastic/syntax_checkers/lua/luac.vim new file mode 100644 index 0000000..178f76a --- /dev/null +++ b/vim/bundle/syntastic/syntax_checkers/lua/luac.vim @@ -0,0 +1,65 @@ +"============================================================================ +"File: lua.vim +"Description: Syntax checking plugin for syntastic.vim +"Maintainer: Gregor Uhlenheuer <kongo2002 at gmail dot com> +"License: This program is free software. It comes without any warranty, +" to the extent permitted by applicable law. You can redistribute +" it and/or modify it under the terms of the Do What The Fuck You +" Want To Public License, Version 2, as published by Sam Hocevar. +" See http://sam.zoy.org/wtfpl/COPYING for more details. +" +"============================================================================ + +if exists('g:loaded_syntastic_lua_luac_checker') + finish +endif +let g:loaded_syntastic_lua_luac_checker = 1 + +let s:save_cpo = &cpo +set cpo&vim + +function! SyntaxCheckers_lua_luac_GetHighlightRegex(pos) + let result = '' + let near = matchstr(a:pos['text'], '\mnear ''\zs[^'']\+\ze''') + if near !=# '' + if near ==# '<eof>' + let p = getpos('$') + let a:pos['lnum'] = p[1] + let a:pos['col'] = p[2] + let result = '\%' . p[2] . 'c' + else + let result = '\V' . escape(near, '\') + endif + + " XXX the following piece of code is evil, and is likely to break + " in future versions of syntastic; enable it at your own risk :) + + "let open = matchstr(a:pos['text'], '\m(to close ''\zs[^'']\+\ze'' at line [0-9]\+)') + "if open != '' + " let line = str2nr(matchstr(a:pos['text'], '\m(to close ''[^'']\+'' at line \zs[0-9]\+\ze)')) + " let group = a:pos['type'] ==? 'E' ? 'SyntasticError' : 'SyntasticWarning' + " call matchadd(group, '\%' . line . 'l\V' . escape(open, '\')) + "endif + endif + return result +endfunction + +function! SyntaxCheckers_lua_luac_GetLocList() dict + let makeprg = self.makeprgBuild({ 'args_after': '-p' }) + + 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'}) + +let &cpo = s:save_cpo +unlet s:save_cpo + +" vim: set sw=4 sts=4 et fdm=marker: diff --git a/vim/bundle/syntastic/syntax_checkers/lua/luacheck.vim b/vim/bundle/syntastic/syntax_checkers/lua/luacheck.vim new file mode 100644 index 0000000..5c8521d --- /dev/null +++ b/vim/bundle/syntastic/syntax_checkers/lua/luacheck.vim @@ -0,0 +1,67 @@ +"============================================================================ +"File: luacheck.vim +"Description: Lua static analysis using luacheck +"Maintainer: Thiago Bastos <tbastos@tbastos.com> +"License: This program is free software. It comes without any warranty, +" to the extent permitted by applicable law. You can redistribute +" it and/or modify it under the terms of the Do What The Fuck You +" Want To Public License, Version 2, as published by Sam Hocevar. +" See http://sam.zoy.org/wtfpl/COPYING for more details. +"============================================================================ + +if exists('g:loaded_syntastic_lua_luacheck_checker') + finish +endif +let g:loaded_syntastic_lua_luacheck_checker = 1 + +let s:save_cpo = &cpo +set cpo&vim + +function! SyntaxCheckers_lua_luacheck_GetHighlightRegex(item) + let term = matchstr(a:item['text'], '\m''\zs\S\+\ze''') + if term !=# '' + return '\V\<' . escape(term, '\') . '\>' + endif + + let term = matchstr(a:item['text'], '\m\(accessing undefined\|setting non-standard global\|' . + \ 'setting non-module global\|unused global\) variable \zs\S\+') + if term ==# '' + let term = matchstr(a:item['text'], '\mvariable \zs\S\+\ze was previously defined') + endif + if term ==# '' + let term = matchstr(a:item['text'], '\munused \(variable\|argument\|loop variable\) \zs\S\+') + endif + if term ==# '' + let term = matchstr(a:item['text'], '\m\(value assigned to variable\|value of argument\|' . + \ 'value of loop variable\) \zs\S\+') + endif + if term ==# '' + let term = matchstr(a:item['text'], '\mvariable \zs\S\+\ze is never set') + endif + + return term !=# '' ? '\V\<' . escape(term, '\') . '\>' : '' +endfunction + +function! SyntaxCheckers_lua_luacheck_GetLocList() dict + let makeprg = self.makeprgBuild({ 'args_after': '--no-color' }) + + let errorformat = + \ '%f:%l:%c: %m,'. + \ '%-G%.%#' + + return SyntasticMake({ + \ 'makeprg': makeprg, + \ 'errorformat': errorformat, + \ 'subtype': 'Style', + \ 'defaults': { 'type': 'W' }, + \ 'returns': [0, 1, 2] }) +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'lua', + \ 'name': 'luacheck' }) + +let &cpo = s:save_cpo +unlet s:save_cpo + +" vim: set sw=4 sts=4 et fdm=marker: diff --git a/vim/bundle/syntastic/syntax_checkers/markdown/mdl.vim b/vim/bundle/syntastic/syntax_checkers/markdown/mdl.vim new file mode 100644 index 0000000..17dc86d --- /dev/null +++ b/vim/bundle/syntastic/syntax_checkers/markdown/mdl.vim @@ -0,0 +1,45 @@ +"============================================================================ +"File: mdl.vim +"Description: Syntax checking plugin for syntastic.vim +"Maintainer: Charles Beynon <etothepiipower at gmail dot com> +"License: This program is free software. It comes without any warranty, +" to the extent permitted by applicable law. You can redistribute +" it and/or modify it under the terms of the Do What The Fuck You +" Want To Public License, Version 2, as published by Sam Hocevar. +" See http://sam.zoy.org/wtfpl/COPYING for more details. +" +"============================================================================ + +if exists('g:loaded_syntastic_markdown_mdl_checker') + finish +endif +let g:loaded_syntastic_markdown_mdl_checker = 1 + +if !exists('g:syntastic_markdown_mdl_sort') + let g:syntastic_markdown_mdl_sort = 1 +endif + +let s:save_cpo = &cpo +set cpo&vim + +function! SyntaxCheckers_markdown_mdl_GetLocList() dict + let makeprg = self.makeprgBuild({ 'args': '--warnings' }) + + let errorformat = + \ '%E%f:%\s%\=%l: %m,'. + \ '%W%f: Kramdown Warning: %m found on line %l' + + return SyntasticMake({ + \ 'makeprg': makeprg, + \ 'errorformat': errorformat, + \ 'subtype': 'Style' }) +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'markdown', + \ 'name': 'mdl'}) + +let &cpo = s:save_cpo +unlet s:save_cpo + +" vim: set sw=4 sts=4 et fdm=marker: diff --git a/vim/bundle/syntastic/syntax_checkers/markdown/textlint.vim b/vim/bundle/syntastic/syntax_checkers/markdown/textlint.vim new file mode 100644 index 0000000..3419d4d --- /dev/null +++ b/vim/bundle/syntastic/syntax_checkers/markdown/textlint.vim @@ -0,0 +1,23 @@ +"============================================================================ +"File: textlint.vim +"Description: Syntax checking plugin for syntastic +"Maintainer: LCD 47 <lcd047 at gmail dot com> +"License: This program is free software. It comes without any warranty, +" to the extent permitted by applicable law. You can redistribute +" it and/or modify it under the terms of the Do What The Fuck You +" Want To Public License, Version 2, as published by Sam Hocevar. +" See http://sam.zoy.org/wtfpl/COPYING for more details. +" +"============================================================================ + +if exists('g:loaded_syntastic_markdown_textlint_checker') + finish +endif +let g:loaded_syntastic_markdown_textlint_checker = 1 + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'markdown', + \ 'name': 'textlint', + \ 'redirect': 'text/textlint'}) + +" vim: set sw=4 sts=4 et fdm=marker: diff --git a/vim/bundle/syntastic/syntax_checkers/matlab/mlint.vim b/vim/bundle/syntastic/syntax_checkers/matlab/mlint.vim new file mode 100644 index 0000000..6e0b8d1 --- /dev/null +++ b/vim/bundle/syntastic/syntax_checkers/matlab/mlint.vim @@ -0,0 +1,41 @@ +"============================================================================ +"File: matlab.vim +"Description: Syntax checking plugin for syntastic.vim +"Maintainer: Jason Graham <jason at the-graham dot com> +"License: This program is free software. It comes without any warranty, +" to the extent permitted by applicable law. You can redistribute +" it and/or modify it under the terms of the Do What The Fuck You +" Want To Public License, Version 2, as published by Sam Hocevar. +" See http://sam.zoy.org/wtfpl/COPYING for more details. +" +"============================================================================ + +if exists('g:loaded_syntastic_matlab_mlint_checker') + finish +endif +let g:loaded_syntastic_matlab_mlint_checker = 1 + +let s:save_cpo = &cpo +set cpo&vim + +function! SyntaxCheckers_matlab_mlint_GetLocList() dict + let makeprg = self.makeprgBuild({ 'args_after': '-id $*' }) + + 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'}) + +let &cpo = s:save_cpo +unlet s:save_cpo + +" vim: set sw=4 sts=4 et fdm=marker: diff --git a/vim/bundle/syntastic/syntax_checkers/mercury/mmc.vim b/vim/bundle/syntastic/syntax_checkers/mercury/mmc.vim new file mode 100644 index 0000000..75ee654 --- /dev/null +++ b/vim/bundle/syntastic/syntax_checkers/mercury/mmc.vim @@ -0,0 +1,49 @@ +"============================================================================ +"File: mercury.vim +"Description: Syntax checking plugin for syntastic.vim +"Maintainer: Joshua Rahm (joshuarahm@gmail.com) +"License: This program is free software. It comes without any warranty, +" to the extent permitted by applicable law. You can redistribute +" it and/or modify it under the terms of the Do What The Fuck You +" Want To Public License, Version 2, as published by Sam Hocevar. +" See http://sam.zoy.org/wtfpl/COPYING for more details. +" +"============================================================================ + +if exists('g:loaded_syntastic_mercury_mmc_checker') + finish +endif +let g:loaded_syntastic_mercury_mmc_checker = 1 + +let s:save_cpo = &cpo +set cpo&vim + +function! SyntaxCheckers_mercury_mmc_GetLocList() dict + let makeprg = self.makeprgBuild({ 'args_before': '-e' }) + + let errorformat = + \ '%C%f:%l: %m,' . + \ '%E%f:%l: %m,' . + \ '%-G%.%#' + + let loclist = SyntasticMake({ + \ 'makeprg': makeprg, + \ 'errorformat': errorformat }) + + for e in loclist + if stridx(e['text'], ' warning:') >= 0 + let e['type'] = 'W' + endif + endfor + + return loclist +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'mercury', + \ 'name': 'mmc'}) + +let &cpo = s:save_cpo +unlet s:save_cpo + +" vim: set sw=4 sts=4 et fdm=marker: diff --git a/vim/bundle/syntastic/syntax_checkers/nasm/nasm.vim b/vim/bundle/syntastic/syntax_checkers/nasm/nasm.vim new file mode 100644 index 0000000..e309c1f --- /dev/null +++ b/vim/bundle/syntastic/syntax_checkers/nasm/nasm.vim @@ -0,0 +1,41 @@ +"============================================================================ +"File: nasm.vim +"Description: Syntax checking plugin for syntastic.vim +"Maintainer: Håvard Pettersson <haavard.pettersson at gmail dot com> +"License: This program is free software. It comes without any warranty, +" to the extent permitted by applicable law. You can redistribute +" it and/or modify it under the terms of the Do What The Fuck You +" Want To Public License, Version 2, as published by Sam Hocevar. +" See http://sam.zoy.org/wtfpl/COPYING for more details. +" +"============================================================================ + +if exists('g:loaded_syntastic_nasm_nasm_checker') + finish +endif +let g:loaded_syntastic_nasm_nasm_checker = 1 + +let s:save_cpo = &cpo +set cpo&vim + +function! SyntaxCheckers_nasm_nasm_GetLocList() dict + let makeprg = self.makeprgBuild({ + \ 'args_after': '-X gnu -f elf' . + \ ' -I ' . syntastic#util#shescape(expand('%:p:h', 1) . syntastic#util#Slash()) . + \ ' ' . syntastic#c#NullOutput() }) + + let errorformat = '%f:%l: %t%*[^:]: %m' + + return SyntasticMake({ + \ 'makeprg': makeprg, + \ 'errorformat': errorformat }) +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'nasm', + \ 'name': 'nasm'}) + +let &cpo = s:save_cpo +unlet s:save_cpo + +" vim: set sw=4 sts=4 et fdm=marker: diff --git a/vim/bundle/syntastic/syntax_checkers/nix/nix.vim b/vim/bundle/syntastic/syntax_checkers/nix/nix.vim new file mode 100644 index 0000000..f3c449d --- /dev/null +++ b/vim/bundle/syntastic/syntax_checkers/nix/nix.vim @@ -0,0 +1,45 @@ +"============================================================================ +"File: nix.vim +"Description: Check nix syntax using 'nix-instantiate --eval-only' +"Maintainer: Tim Cuthbertson <tim@gfxmonk.net> +"License: This program is free software. It comes without any warranty, +" to the extent permitted by applicable law. You can redistribute +" it and/or modify it under the terms of the Do What The Fuck You +" Want To Public License, Version 2, as published by Sam Hocevar. +" See http://sam.zoy.org/wtfpl/COPYING for more details. +" +"============================================================================ +" +" +if exists('g:loaded_syntastic_nix_nix_checker') + finish +endif +let g:loaded_syntastic_nix_nix_checker = 1 + +let s:save_cpo = &cpo +set cpo&vim + +function! SyntaxCheckers_nix_nix_GetLocList() dict + let makeprg = self.makeprgBuild({ 'args_after': '--parse-only' }) + + let errorformat = + \ '%f:%l:%c:%m,' . + \ '%f:%l:%m,' . + \ '%f:%m' + + return SyntasticMake({ + \ 'makeprg': makeprg, + \ 'errorformat': errorformat, + \ 'defaults': {'type': 'e'}, + \ 'preprocess': 'nix' }) +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'nix', + \ 'name': 'nix', + \ 'exec': 'nix-instantiate' }) + +let &cpo = s:save_cpo +unlet s:save_cpo + +" vim: set sw=4 sts=4 et fdm=marker: diff --git a/vim/bundle/syntastic/syntax_checkers/nroff/igor.vim b/vim/bundle/syntastic/syntax_checkers/nroff/igor.vim new file mode 100644 index 0000000..dcad8c5 --- /dev/null +++ b/vim/bundle/syntastic/syntax_checkers/nroff/igor.vim @@ -0,0 +1,23 @@ +"============================================================================ +"File: igor.vim +"Description: Syntax checking plugin for syntastic.vim +"Maintainer: LCD 47 <lcd047 at gmail dot com> +"License: This program is free software. It comes without any warranty, +" to the extent permitted by applicable law. You can redistribute +" it and/or modify it under the terms of the Do What The Fuck You +" Want To Public License, Version 2, as published by Sam Hocevar. +" See http://sam.zoy.org/wtfpl/COPYING for more details. +" +"============================================================================ + +if exists('g:loaded_syntastic_nroff_igor_checker') + finish +endif +let g:loaded_syntastic_nroff_igor_checker = 1 + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'nroff', + \ 'name': 'igor', + \ 'redirect': 'docbk/igor'}) + +" vim: set sw=4 sts=4 et fdm=marker: diff --git a/vim/bundle/syntastic/syntax_checkers/nroff/mandoc.vim b/vim/bundle/syntastic/syntax_checkers/nroff/mandoc.vim new file mode 100644 index 0000000..8efc4ce --- /dev/null +++ b/vim/bundle/syntastic/syntax_checkers/nroff/mandoc.vim @@ -0,0 +1,41 @@ +"============================================================================ +"File: mandoc.vim +"Description: Syntax checking plugin for syntastic.vim +"Maintainer: LCD 47 <lcd047 at gmail dot com> +"License: This program is free software. It comes without any warranty, +" to the extent permitted by applicable law. You can redistribute +" it and/or modify it under the terms of the Do What The Fuck You +" Want To Public License, Version 2, as published by Sam Hocevar. +" See http://sam.zoy.org/wtfpl/COPYING for more details. +" +"============================================================================ + +if exists('g:loaded_syntastic_nroff_mandoc_checker') + finish +endif +let g:loaded_syntastic_nroff_mandoc_checker = 1 + +let s:save_cpo = &cpo +set cpo&vim + +function! SyntaxCheckers_nroff_mandoc_GetLocList() dict + let makeprg = self.makeprgBuild({ 'args_after': '-Tlint' }) + + 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'}) + +let &cpo = s:save_cpo +unlet s:save_cpo + +" vim: set sw=4 sts=4 et fdm=marker: diff --git a/vim/bundle/syntastic/syntax_checkers/objc/gcc.vim b/vim/bundle/syntastic/syntax_checkers/objc/gcc.vim new file mode 100644 index 0000000..73da7f8 --- /dev/null +++ b/vim/bundle/syntastic/syntax_checkers/objc/gcc.vim @@ -0,0 +1,59 @@ +"============================================================================ +"File: objc.vim +"Description: Syntax checking plugin for syntastic.vim +"Maintainer: Gregor Uhlenheuer <kongo2002 at gmail dot com> +"License: This program is free software. It comes without any warranty, +" to the extent permitted by applicable law. You can redistribute +" it and/or modify it under the terms of the Do What The Fuck You +" Want To Public License, Version 2, as published by Sam Hocevar. +" See http://sam.zoy.org/wtfpl/COPYING for more details. +" +"============================================================================ + +if exists('g:loaded_syntastic_objc_gcc_checker') + finish +endif +let g:loaded_syntastic_objc_gcc_checker = 1 + +if !exists('g:syntastic_objc_compiler_options') + let g:syntastic_objc_compiler_options = '-std=gnu99' +endif + +let s:save_cpo = &cpo +set cpo&vim + +function! SyntaxCheckers_objc_gcc_IsAvailable() dict + if !exists('g:syntastic_objc_compiler') + let g:syntastic_objc_compiler = executable(self.getExec()) ? self.getExec() : 'clang' + endif + call self.log('g:syntastic_objc_compiler =', g:syntastic_objc_compiler) + return executable(expand(g:syntastic_objc_compiler, 1)) +endfunction + +function! SyntaxCheckers_objc_gcc_GetLocList() dict + return syntastic#c#GetLocList('objc', 'gcc', { + \ 'errorformat': + \ '%-G%f:%s:,' . + \ '%-G%f:%l: %#error: %#(Each undeclared identifier is reported only%.%#,' . + \ '%-G%f:%l: %#error: %#for each function it appears%.%#,' . + \ '%-GIn file included%.%#,'. + \ '%-G %#from %f:%l\,,' . + \ '%f:%l:%c: %trror: %m,' . + \ '%f:%l:%c: %tarning: %m,' . + \ '%f:%l:%c: %m,' . + \ '%f:%l: %trror: %m,' . + \ '%f:%l: %tarning: %m,' . + \ '%f:%l: %m', + \ 'main_flags': '-x objective-c -fsyntax-only', + \ 'header_flags': '-x objective-c-header -lobjc', + \ 'header_names': '\m\.h$' }) +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'objc', + \ 'name': 'gcc' }) + +let &cpo = s:save_cpo +unlet s:save_cpo + +" vim: set sw=4 sts=4 et fdm=marker: diff --git a/vim/bundle/syntastic/syntax_checkers/objc/oclint.vim b/vim/bundle/syntastic/syntax_checkers/objc/oclint.vim new file mode 100644 index 0000000..534d82b --- /dev/null +++ b/vim/bundle/syntastic/syntax_checkers/objc/oclint.vim @@ -0,0 +1,22 @@ +"============================================================================ +"File: oclint.vim +"Description: Syntax checking plugin for syntastic.vim +"Maintainer: "UnCO" Lin <undercooled aT lavabit com> +"License: This program is free software. It comes without any warranty, +" to the extent permitted by applicable law. You can redistribute +" it and/or modify it under the terms of the Do What The Fuck You +" Want To Public License, Version 2, as published by Sam Hocevar. +" See http://sam.zoy.org/wtfpl/COPYING for more details. +"============================================================================ + +if exists('g:loaded_syntastic_objc_oclint_checker') + finish +endif +let g:loaded_syntastic_objc_oclint_checker = 1 + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'objc', + \ 'name': 'oclint', + \ 'redirect': 'c/oclint'}) + +" vim: set sw=4 sts=4 et fdm=marker: diff --git a/vim/bundle/syntastic/syntax_checkers/objcpp/gcc.vim b/vim/bundle/syntastic/syntax_checkers/objcpp/gcc.vim new file mode 100644 index 0000000..6ae7ba5 --- /dev/null +++ b/vim/bundle/syntastic/syntax_checkers/objcpp/gcc.vim @@ -0,0 +1,59 @@ +"============================================================================ +"File: objcpp.vim +"Description: Syntax checking plugin for syntastic.vim +"Maintainer: Gregor Uhlenheuer <kongo2002 at gmail dot com> +"License: This program is free software. It comes without any warranty, +" to the extent permitted by applicable law. You can redistribute +" it and/or modify it under the terms of the Do What The Fuck You +" Want To Public License, Version 2, as published by Sam Hocevar. +" See http://sam.zoy.org/wtfpl/COPYING for more details. +" +"============================================================================ + +if exists('g:loaded_syntastic_objcpp_gcc_checker') + finish +endif +let g:loaded_syntastic_objcpp_gcc_checker = 1 + +if !exists('g:syntastic_objcpp_compiler_options') + let g:syntastic_objcpp_compiler_options = '-std=gnu99' +endif + +let s:save_cpo = &cpo +set cpo&vim + +function! SyntaxCheckers_objcpp_gcc_IsAvailable() dict + if !exists('g:syntastic_c_compiler') + let g:syntastic_objcpp_compiler = executable(self.getExec()) ? self.getExec() : 'clang' + endif + call self.log('g:syntastic_objcpp_compiler =', g:syntastic_objcpp_compiler) + return executable(expand(g:syntastic_objcpp_compiler, 1)) +endfunction + +function! SyntaxCheckers_objcpp_gcc_GetLocList() dict + return syntastic#c#GetLocList('objcpp', 'gcc', { + \ 'errorformat': + \ '%-G%f:%s:,' . + \ '%-G%f:%l: %#error: %#(Each undeclared identifier is reported only%.%#,' . + \ '%-G%f:%l: %#error: %#for each function it appears%.%#,' . + \ '%-GIn file included%.%#,'. + \ '%-G %#from %f:%l\,,' . + \ '%f:%l:%c: %trror: %m,' . + \ '%f:%l:%c: %tarning: %m,' . + \ '%f:%l:%c: %m,' . + \ '%f:%l: %trror: %m,' . + \ '%f:%l: %tarning: %m,' . + \ '%f:%l: %m', + \ 'main_flags': '-x objective-c++ -fsyntax-only', + \ 'header_flags': '-x objective-c++-header -lobjc', + \ 'header_names': '\m\.h$' }) +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'objcpp', + \ 'name': 'gcc' }) + +let &cpo = s:save_cpo +unlet s:save_cpo + +" vim: set sw=4 sts=4 et fdm=marker: diff --git a/vim/bundle/syntastic/syntax_checkers/objcpp/oclint.vim b/vim/bundle/syntastic/syntax_checkers/objcpp/oclint.vim new file mode 100644 index 0000000..5528258 --- /dev/null +++ b/vim/bundle/syntastic/syntax_checkers/objcpp/oclint.vim @@ -0,0 +1,22 @@ +"============================================================================ +"File: oclint.vim +"Description: Syntax checking plugin for syntastic.vim +"Maintainer: "UnCO" Lin <undercooled aT lavabit com> +"License: This program is free software. It comes without any warranty, +" to the extent permitted by applicable law. You can redistribute +" it and/or modify it under the terms of the Do What The Fuck You +" Want To Public License, Version 2, as published by Sam Hocevar. +" See http://sam.zoy.org/wtfpl/COPYING for more details. +"============================================================================ + +if exists('g:loaded_syntastic_objcpp_oclint_checker') + finish +endif +let g:loaded_syntastic_objcpp_oclint_checker = 1 + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'objcpp', + \ 'name': 'oclint', + \ 'redirect': 'c/oclint'}) + +" vim: set sw=4 sts=4 et fdm=marker: diff --git a/vim/bundle/syntastic/syntax_checkers/ocaml/camlp4o.vim b/vim/bundle/syntastic/syntax_checkers/ocaml/camlp4o.vim new file mode 100644 index 0000000..f7f34e7 --- /dev/null +++ b/vim/bundle/syntastic/syntax_checkers/ocaml/camlp4o.vim @@ -0,0 +1,130 @@ +"============================================================================ +"File: ocaml.vim +"Description: Syntax checking plugin for syntastic.vim +"Maintainer: Török Edwin <edwintorok at gmail dot com> +"License: This program is free software. It comes without any warranty, +" to the extent permitted by applicable law. You can redistribute +" it and/or modify it under the terms of the Do What The Fuck You +" Want To Public License, Version 2, as published by Sam Hocevar. +" See http://sam.zoy.org/wtfpl/COPYING for more details. +" +"============================================================================ + +if exists('g:loaded_syntastic_ocaml_camlp4o_checker') + finish +endif +let g:loaded_syntastic_ocaml_camlp4o_checker = 1 + +let s:save_cpo = &cpo +set cpo&vim + +" Checker options {{{1 + +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_janestreet_core = 0 +endif + +if !exists('g:syntastic_ocaml_janestreet_core_dir') + let g:syntastic_ocaml_janestreet_core_dir = '.' +endif + +if !exists('g:syntastic_ocaml_use_ocamlbuild') || !executable('ocamlbuild') + let g:syntastic_ocaml_use_ocamlbuild = 0 +endif + +" }}}1 + +function! SyntaxCheckers_ocaml_camlp4o_IsAvailable() dict " {{{1 + let s:ocamlpp = get(g:, 'syntastic_ocaml_camlp4r', 0) ? 'camlp4r' : 'camlp4o' + return executable(s:ocamlpp) +endfunction " }}}1 + +function! SyntaxCheckers_ocaml_camlp4o_GetLocList() dict " {{{1 + let makeprg = s:GetMakeprg() + if makeprg ==# '' + return [] + endif + + let errorformat = + \ '%WWarning: File "%f"\, line %l\, chars %c-%n:,'. + \ '%WWarning: line %l\, chars %c-%n:,'. + \ '%AFile "%f"\, line %l\, characters %c-%n:,'. + \ '%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 %*\d: %m,'. + \ '%C%m,'. + \ '%-G+%.%#' + + let loclist = SyntasticMake({ + \ 'makeprg': makeprg, + \ 'errorformat': errorformat, + \ 'defaults': {'bufnr': bufnr('')} }) + + for e in loclist + if get(e, 'col', 0) && get(e, 'nr', 0) + let e['hl'] = '\%>' . (e['col'] - 1) . 'c\%<' . (e['nr'] + 1) . 'c' + let e['nr'] = 0 + endif + endfor + + return loclist +endfunction " }}}1 + +" Utilities {{{1 + +function! s:GetMakeprg() " {{{2 + return + \ g:syntastic_ocaml_use_ocamlc ? g:syntastic_ocaml_use_ocamlc : + \ (g:syntastic_ocaml_use_ocamlbuild && isdirectory('_build')) ? s:GetOcamlcMakeprg() : + \ s:GetOtherMakeprg() +endfunction " }}}2 + +function! s:GetOcamlcMakeprg() " {{{2 + let build_cmd = g:syntastic_ocaml_use_janestreet_core ? + \ 'ocamlc -I ' . syntastic#util#shexpand(g:syntastic_ocaml_janestreet_core_dir) : 'ocamlc' + let build_cmd .= ' -c ' . syntastic#util#shexpand('%') + return build_cmd +endfunction " }}}2 + +function! s:GetOcamlBuildMakeprg() " {{{2 + return 'ocamlbuild -quiet -no-log -tag annot,' . s:ocamlpp . ' -no-links -no-hygiene -no-sanitize ' . + \ syntastic#util#shexpand('%:r') . '.cmi' +endfunction " }}}2 + +function! s:GetOtherMakeprg() " {{{2 + "TODO: give this function a better name? + " + "TODO: should use throw/catch instead of returning an empty makeprg + + let extension = expand('%:e', 1) + let makeprg = '' + + if stridx(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 stridx(extension,'mll') >= 0 && executable('ocamllex') + let makeprg = 'ocamllex -q ' . syntastic#c#NullOutput() . ' ' . syntastic#util#shexpand('%') + else + let makeprg = 'camlp4o ' . syntastic#c#NullOutput() . ' ' . syntastic#util#shexpand('%') + endif + + return makeprg +endfunction " }}}2 + +" }}}1 + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'ocaml', + \ 'name': 'camlp4o'}) + +let &cpo = s:save_cpo +unlet s:save_cpo + +" vim: set sw=4 sts=4 et fdm=marker: diff --git a/vim/bundle/syntastic/syntax_checkers/perl/perl.vim b/vim/bundle/syntastic/syntax_checkers/perl/perl.vim new file mode 100644 index 0000000..e039518 --- /dev/null +++ b/vim/bundle/syntastic/syntax_checkers/perl/perl.vim @@ -0,0 +1,94 @@ +"============================================================================ +"File: perl.vim +"Description: Syntax checking plugin for syntastic.vim +"Maintainer: Anthony Carapetis <anthony.carapetis at gmail dot com>, +" Eric Harmon <http://eharmon.net> +"License: This program is free software. It comes without any warranty, +" to the extent permitted by applicable law. You can redistribute +" it and/or modify it under the terms of the Do What The Fuck You +" Want To Public License, Version 2, as published by Sam Hocevar. +" See http://sam.zoy.org/wtfpl/COPYING for more details. +" +"============================================================================ +" +" Security: +" +" This checker runs 'perl -c' against your file, which in turn executes +" any BEGIN, UNITCHECK, and CHECK blocks, and any use statements in +" your file. This is probably fine if you wrote the file yourself, +" but it can be a problem if you're trying to check third party files. +" If you are 100% willing to let Vim run the code in your file, set +" g:syntastic_enable_perl_checker to 1 in your vimrc to enable this +" checker: +" +" let g:syntastic_enable_perl_checker = 1 +" +" References: +" +" - http://perldoc.perl.org/perlrun.html#*-c* + +if exists('g:loaded_syntastic_perl_perl_checker') + finish +endif +let g:loaded_syntastic_perl_perl_checker = 1 + +if !exists('g:syntastic_perl_lib_path') + let g:syntastic_perl_lib_path = [] +endif + +let s:save_cpo = &cpo +set cpo&vim + +function! SyntaxCheckers_perl_perl_IsAvailable() dict " {{{1 + if !exists('g:syntastic_perl_perl_exec') && exists('g:syntastic_perl_interpreter') + let g:syntastic_perl_perl_exec = g:syntastic_perl_interpreter + endif + + " don't call executable() here, to allow things like + " let g:syntastic_perl_interpreter='/usr/bin/env perl' + silent! call syntastic#util#system(self.getExecEscaped() . ' -e ' . syntastic#util#shescape('exit(0)')) + return v:shell_error == 0 +endfunction " }}}1 + +function! SyntaxCheckers_perl_perl_GetLocList() dict " {{{1 + if type(g:syntastic_perl_lib_path) == type('') + call syntastic#log#oneTimeWarn('variable g:syntastic_perl_lib_path should be a list') + let includes = split(g:syntastic_perl_lib_path, ',') + else + let includes = copy(syntastic#util#var('perl_lib_path')) + endif + let shebang = syntastic#util#parseShebang() + let extra = join(map(includes, '"-I" . v:val')) . + \ (index(shebang['args'], '-T') >= 0 ? ' -T' : '') . + \ (index(shebang['args'], '-t') >= 0 ? ' -t' : '') + let errorformat = '%f:%l:%m' + + let makeprg = self.makeprgBuild({ 'args_before': '-c -X ' . extra }) + + let errors = SyntasticMake({ + \ 'makeprg': makeprg, + \ 'errorformat': errorformat, + \ 'preprocess': 'perl', + \ 'defaults': {'type': 'E'} }) + if !empty(errors) + return errors + endif + + let makeprg = self.makeprgBuild({ 'args_before': '-c -Mwarnings ' . extra }) + + return SyntasticMake({ + \ 'makeprg': makeprg, + \ 'errorformat': errorformat, + \ 'preprocess': 'perl', + \ 'defaults': {'type': 'W'} }) +endfunction " }}}1 + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'perl', + \ 'name': 'perl', + \ 'enable': 'enable_perl_checker'}) + +let &cpo = s:save_cpo +unlet s:save_cpo + +" vim: set sw=4 sts=4 et fdm=marker: diff --git a/vim/bundle/syntastic/syntax_checkers/perl/perlcritic.vim b/vim/bundle/syntastic/syntax_checkers/perl/perlcritic.vim new file mode 100644 index 0000000..abe9f43 --- /dev/null +++ b/vim/bundle/syntastic/syntax_checkers/perl/perlcritic.vim @@ -0,0 +1,52 @@ +"============================================================================ +"File: perlcritic.vim +"Description: Syntax checking plugin for syntastic.vim +"Maintainer: LCD 47 <lcd047 at gmail dot com> +"License: This program is free software. It comes without any warranty, +" to the extent permitted by applicable law. You can redistribute +" it and/or modify it under the terms of the Do What The Fuck You +" Want To Public License, Version 2, as published by Sam Hocevar. +" See http://sam.zoy.org/wtfpl/COPYING for more details. +" +"============================================================================ + +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 + +let s:save_cpo = &cpo +set cpo&vim + +function! SyntaxCheckers_perl_perlcritic_GetLocList() dict + let makeprg = self.makeprgBuild({ + \ 'args_after': '--quiet --nocolor --verbose "\%s:\%f:\%l:\%c:(\%s) \%m (\%e)\n"' }) + + 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 e in loclist + let e['type'] = e['type'] < g:syntastic_perl_perlcritic_thres ? 'W' : 'E' + endfor + + return loclist +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'perl', + \ 'name': 'perlcritic'}) + +let &cpo = s:save_cpo +unlet s:save_cpo + +" vim: set sw=4 sts=4 et fdm=marker: diff --git a/vim/bundle/syntastic/syntax_checkers/perl/podchecker.vim b/vim/bundle/syntastic/syntax_checkers/perl/podchecker.vim new file mode 100644 index 0000000..cad39bd --- /dev/null +++ b/vim/bundle/syntastic/syntax_checkers/perl/podchecker.vim @@ -0,0 +1,23 @@ +"============================================================================ +"File: podchecker.vim +"Description: Syntax checking plugin for syntastic.vim +"Maintainer: LCD 47 <lcd047 at gmail dot com> +"License: This program is free software. It comes without any warranty, +" to the extent permitted by applicable law. You can redistribute +" it and/or modify it under the terms of the Do What The Fuck You +" Want To Public License, Version 2, as published by Sam Hocevar. +" See http://sam.zoy.org/wtfpl/COPYING for more details. +" +"============================================================================ + +if exists('g:loaded_syntastic_perl_podchecker_checker') + finish +endif +let g:loaded_syntastic_perl_podchecker_checker = 1 + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'perl', + \ 'name': 'podchecker', + \ 'redirect': 'pod/podchecker'}) + +" vim: set sw=4 sts=4 et fdm=marker: diff --git a/vim/bundle/syntastic/syntax_checkers/php/php.vim b/vim/bundle/syntastic/syntax_checkers/php/php.vim new file mode 100644 index 0000000..5b118f6 --- /dev/null +++ b/vim/bundle/syntastic/syntax_checkers/php/php.vim @@ -0,0 +1,52 @@ +"============================================================================ +"File: php.vim +"Description: Syntax checking plugin for syntastic.vim +"Maintainer: Martin Grenfell <martin.grenfell at gmail dot com> +"License: This program is free software. It comes without any warranty, +" to the extent permitted by applicable law. You can redistribute +" it and/or modify it under the terms of the Do What The Fuck You +" Want To Public License, Version 2, as published by Sam Hocevar. +" See http://sam.zoy.org/wtfpl/COPYING for more details. +" +"============================================================================ + +if exists('g:loaded_syntastic_php_php_checker') + finish +endif +let g:loaded_syntastic_php_php_checker = 1 + +let s:save_cpo = &cpo +set cpo&vim + +function! SyntaxCheckers_php_php_GetHighlightRegex(item) + let term = matchstr(a:item['text'], "\\munexpected '\\zs[^']\\+\\ze'") + return term !=# '' ? '\V' . escape(term, '\') : '' +endfunction + +function! SyntaxCheckers_php_php_GetLocList() dict + let makeprg = self.makeprgBuild({ + \ 'args': '-d error_reporting=E_ALL', + \ 'args_after': '-l -d display_errors=1 -d log_errors=0 -d xdebug.cli_color=0' }) + + 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, + \ 'postprocess': ['guards'] }) +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'php', + \ 'name': 'php'}) + +let &cpo = s:save_cpo +unlet s:save_cpo + +" vim: set sw=4 sts=4 et fdm=marker: diff --git a/vim/bundle/syntastic/syntax_checkers/php/phpcs.vim b/vim/bundle/syntastic/syntax_checkers/php/phpcs.vim new file mode 100644 index 0000000..1bd8f98 --- /dev/null +++ b/vim/bundle/syntastic/syntax_checkers/php/phpcs.vim @@ -0,0 +1,41 @@ +"============================================================================ +"File: phpcs.vim +"Description: Syntax checking plugin for syntastic.vim +"Maintainer: Martin Grenfell <martin.grenfell at gmail dot com> +"License: This program is free software. It comes without any warranty, +" to the extent permitted by applicable law. You can redistribute +" it and/or modify it under the terms of the Do What The Fuck You +" Want To Public License, Version 2, as published by Sam Hocevar. +" See http://sam.zoy.org/wtfpl/COPYING for more details. +" +"============================================================================ + +if exists('g:loaded_syntastic_php_phpcs_checker') + finish +endif +let g:loaded_syntastic_php_phpcs_checker = 1 + +let s:save_cpo = &cpo +set cpo&vim + +function! SyntaxCheckers_php_phpcs_GetLocList() dict + let makeprg = self.makeprgBuild({ 'args_after': '--report=csv' }) + + 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' }) + +let &cpo = s:save_cpo +unlet s:save_cpo + +" vim: set sw=4 sts=4 et fdm=marker: diff --git a/vim/bundle/syntastic/syntax_checkers/php/phplint.vim b/vim/bundle/syntastic/syntax_checkers/php/phplint.vim new file mode 100644 index 0000000..d04f3ba --- /dev/null +++ b/vim/bundle/syntastic/syntax_checkers/php/phplint.vim @@ -0,0 +1,91 @@ +"============================================================================ +"File: phplint.vim +"Description: Syntax checking plugin for syntastic.vim +"Maintainer: LCD 47 <lcd047 at gmail dot com> +"License: This program is free software. It comes without any warranty, +" to the extent permitted by applicable law. You can redistribute +" it and/or modify it under the terms of the Do What The Fuck You +" Want To Public License, Version 2, as published by Sam Hocevar. +" See http://sam.zoy.org/wtfpl/COPYING for more details. +" +"============================================================================ + +if exists('g:loaded_syntastic_php_phplint_checker') + finish +endif +let g:loaded_syntastic_php_phplint_checker = 1 + +let s:save_cpo = &cpo +set cpo&vim + +function! SyntaxCheckers_php_phplint_GetHighlightRegex(item) + let term = matchstr(a:item['text'], '\munresolved function \zs\S\+\ze') + if term !=# '' + return '\V' . escape(term, '\') + endif + let term = matchstr(a:item['text'], '\m\(class\|function\|method\) \zs\S\+\ze was declared as') + if term !=# '' + return '\V' . escape(term, '\') + endif + let term = matchstr(a:item['text'], '\maccess forbidden to \(private\|protected\) \(class\|constant\|method\|variable\|\(private\|protected\) property\) \zs\S\+\ze') + if term !=# '' + return '\V' . escape(term, '\') + endif + let term = matchstr(a:item['text'], '\musing deprecated \(class\|constant\|method\|property\|variable\) \zs\S\+\ze') + if term !=# '' + return '\V' . escape(term, '\') + endif + let term = matchstr(a:item['text'], '\munresolved function \zs\S\+\ze') + if term !=# '' + return '\V' . escape(term, '\') + endif + let term = matchstr(a:item['text'], '\munresolved function \zs\S\+\ze') + if term !=# '' + return '\V' . escape(term, '\') + endif + let term = matchstr(a:item['text'], '\munresolved function \zs\S\+\ze') + return term !=# '' ? '\V' . escape(term, '\') : '' +endfunction + +function! SyntaxCheckers_php_phplint_GetLocList() dict + let makeprg = self.makeprgBuild({ + \ 'args_after': + \ '--print-file-name ' . + \ '--print-line-numbers ' . + \ '--print-column-number ' . + \ '--print-errors ' . + \ '--print-warnings ' . + \ '--no-print-notices ' . + \ '--no-print-context ' . + \ '--no-print-source ' . + \ '--tab-size ' . &tabstop }) + + let errorformat = + \ '%E%f:%l:%v: %tRROR: %m,' . + \ '%W%f:%l:%v: %tarning: %m,' . + \ '%+C%\t%.%#,' . + \ '%-G%.%#' + + let loclist = SyntasticMake({ + \ 'makeprg': makeprg, + \ 'errorformat': errorformat, + \ 'postprocess': ['compressWhitespace'], + \ 'subtype': 'Style', + \ 'returns': [0, 1] }) + + for e in loclist + let e['text'] = substitute(e['text'], '\m \(Hint\|Examples\):.*', '', '') + endfor + + return loclist +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'php', + \ 'name': 'phplint', + \ 'exec': 'phpl' }) + +let &cpo = s:save_cpo +unlet s:save_cpo + +" vim: set sw=4 sts=4 et fdm=marker: diff --git a/vim/bundle/syntastic/syntax_checkers/php/phpmd.vim b/vim/bundle/syntastic/syntax_checkers/php/phpmd.vim new file mode 100644 index 0000000..5207d3d --- /dev/null +++ b/vim/bundle/syntastic/syntax_checkers/php/phpmd.vim @@ -0,0 +1,77 @@ +"============================================================================ +"File: phpmd.vim +"Description: Syntax checking plugin for syntastic.vim +"Maintainer: Martin Grenfell <martin.grenfell at gmail dot com> +"License: This program is free software. It comes without any warranty, +" to the extent permitted by applicable law. You can redistribute +" it and/or modify it under the terms of the Do What The Fuck You +" Want To Public License, Version 2, as published by Sam Hocevar. +" See http://sam.zoy.org/wtfpl/COPYING for more details. +" +"============================================================================ + +if exists('g:loaded_syntastic_php_phpmd_checker') + finish +endif +let g:loaded_syntastic_php_phpmd_checker = 1 + +let s:save_cpo = &cpo +set cpo&vim + +function! SyntaxCheckers_php_phpmd_GetHighlightRegex(item) + let term = matchstr(a:item['text'], '\m\C^The \S\+ \w\+\(()\)\= \(has\|is not\|utilizes\)') + if term !=# '' + return '\V'.substitute(term, '\m\C^The \S\+ \(\w\+\)\(()\)\= .*', '\1', '') + endif + let term = matchstr(a:item['text'], '\m\C^Avoid \(variables with short\|excessively long variable\) names like \S\+\.') + if term !=# '' + return '\V'.substitute(term, '\m\C^Avoid \(variables with short\|excessively long variable\) names like \(\S\+\)\..*', '\2', '') + endif + let term = matchstr(a:item['text'], '\m\C^Avoid using short method names like \S\+::\S\+()\.') + if term !=# '' + return '\V'.substitute(term, '\m\C^Avoid using short method names like \S\+::\(\S\+\)()\..*', '\1', '') + endif + let term = matchstr(a:item['text'], '\m\C^\S\+ accesses the super-global variable ') + if term !=# '' + return '\V'.substitute(term, '\m\C accesses the super-global variable .*$', '', '') + endif + let term = matchstr(a:item['text'], '\m\C^Constant \S\+ should be defined in uppercase') + if term !=# '' + return '\V'.substitute(term, '\m\C^Constant \(\S\+\) should be defined in uppercase', '\1', '') + endif + let term = matchstr(a:item['text'], "\\m\\C^The '\\S\\+()' method which returns ") + if term !=# '' + return '\V'.substitute(term, "\\m\\C^The '\\(\\S\\+\\)()' method which returns.*", '\1', '') + endif + let term = matchstr(a:item['text'], '\m\C variable \S\+ should begin with ') + if term !=# '' + return '\V'.substitute(term, '\m\C.* variable \(\S\+\) should begin with .*', '\1', '') + endif + let term = matchstr(a:item['text'], "\\m\\C^Avoid unused \\(private fields\\|local variables\\|private methods\\|parameters\\) such as '\\S\\+'") + if term !=# '' + return '\V'.substitute(term, "\\m\\C^Avoid unused \\(private fields\\|local variables\\|private methods\\|parameters\\) such as '\\(\\S\\+\\)'.*", '\2', '') + endif + return '' +endfunction + +function! SyntaxCheckers_php_phpmd_GetLocList() dict + let makeprg = self.makeprgBuild({ + \ 'post_args_before': 'text', + \ 'post_args': 'codesize,design,unusedcode,naming' }) + + let errorformat = '%E%f:%l%\s%#%m' + + return SyntasticMake({ + \ 'makeprg': makeprg, + \ 'errorformat': errorformat, + \ 'subtype' : 'Style' }) +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'php', + \ 'name': 'phpmd'}) + +let &cpo = s:save_cpo +unlet s:save_cpo + +" vim: set sw=4 sts=4 et fdm=marker: diff --git a/vim/bundle/syntastic/syntax_checkers/po/msgfmt.vim b/vim/bundle/syntastic/syntax_checkers/po/msgfmt.vim new file mode 100644 index 0000000..1d09733 --- /dev/null +++ b/vim/bundle/syntastic/syntax_checkers/po/msgfmt.vim @@ -0,0 +1,50 @@ +"============================================================================ +"File: msgfmt.vim +"Description: Syntax checking plugin for po files of gettext +"Maintainer: Ryo Okubo <syucream1031@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_po_msgfmt_checker') + finish +endif +let g:loaded_syntastic_po_msgfmt_checker = 1 + +let s:save_cpo = &cpo +set cpo&vim + +function! SyntaxCheckers_po_msgfmt_GetHighlightRegex(item) + let term = matchstr(a:item['text'], '\mkeyword "\zs[^"]\+\ze" unknown') + return term !=# '' ? '\V' . escape(term, '\') : '' +endfunction + +function! SyntaxCheckers_po_msgfmt_GetLocList() dict + let makeprg = self.makeprgBuild({ 'args_after': '-c ' . syntastic#c#NullOutput() }) + + let errorformat = + \ '%W%f:%l: warning: %m,' . + \ '%E%f:%l:%v: %m,' . + \ '%E%f:%l: %m,' . + \ '%+C %.%#,' . + \ '%Z%p^,' . + \ '%-G%.%#' + + return SyntasticMake({ + \ 'makeprg': makeprg, + \ 'errorformat': errorformat, + \ 'postprocess': ['compressWhitespace'] }) +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'po', + \ 'name': 'msgfmt'}) + +let &cpo = s:save_cpo +unlet s:save_cpo + +" vim: set sw=4 sts=4 et fdm=marker: diff --git a/vim/bundle/syntastic/syntax_checkers/pod/podchecker.vim b/vim/bundle/syntastic/syntax_checkers/pod/podchecker.vim new file mode 100644 index 0000000..9ef5dca --- /dev/null +++ b/vim/bundle/syntastic/syntax_checkers/pod/podchecker.vim @@ -0,0 +1,51 @@ +"============================================================================ +"File: podchecker.vim +"Description: Syntax checking plugin for syntastic.vim +"Maintainer: LCD 47 <lcd047 at gmail dot com> +"License: This program is free software. It comes without any warranty, +" to the extent permitted by applicable law. You can redistribute +" it and/or modify it under the terms of the Do What The Fuck You +" Want To Public License, Version 2, as published by Sam Hocevar. +" See http://sam.zoy.org/wtfpl/COPYING for more details. +" +"============================================================================ + +if exists('g:loaded_syntastic_pod_podchecker_checker') + finish +endif +let g:loaded_syntastic_pod_podchecker_checker = 1 + +let s:save_cpo = &cpo +set cpo&vim + +function! SyntaxCheckers_pod_podchecker_GetLocList() dict + let makeprg = self.makeprgBuild({}) + + 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 e in loclist + if e['valid'] && e['lnum'] == 0 + let e['lnum'] = str2nr(matchstr(e['text'], '\m\<line \zs\d\+\ze')) + endif + endfor + + return loclist +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'pod', + \ 'name': 'podchecker'}) + +let &cpo = s:save_cpo +unlet s:save_cpo + +" vim: set sw=4 sts=4 et fdm=marker: diff --git a/vim/bundle/syntastic/syntax_checkers/pug/pug_lint.vim b/vim/bundle/syntastic/syntax_checkers/pug/pug_lint.vim new file mode 100644 index 0000000..880838e --- /dev/null +++ b/vim/bundle/syntastic/syntax_checkers/pug/pug_lint.vim @@ -0,0 +1,40 @@ +"============================================================================ +"File: pug_lint.vim +"Description: Syntax checking plugin for syntastic.vim +"Maintainer: Ben Parnell <benjaminparnell.94@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_pug_pug_lint_checker') + finish +endif +let g:loaded_syntastic_pug_pug_lint_checker = 1 + +let s:save_cpo = &cpo +set cpo&vim + +function! SyntaxCheckers_pug_pug_lint_GetLocList() dict + let makeprg = self.makeprgBuild({ 'args_after': '-r inline' }) + + let errorformat = '%f:%l:%c %m' + + return SyntasticMake({ + \ 'makeprg': makeprg, + \ 'errorformat': errorformat, + \ 'returns': [0, 2] }) +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'pug', + \ 'name': 'pug_lint', + \ 'exec': 'pug-lint' }) + +let &cpo = s:save_cpo +unlet s:save_cpo + +" vim: set sw=4 sts=4 et fdm=marker: diff --git a/vim/bundle/syntastic/syntax_checkers/puppet/puppet.vim b/vim/bundle/syntastic/syntax_checkers/puppet/puppet.vim new file mode 100644 index 0000000..83077c7 --- /dev/null +++ b/vim/bundle/syntastic/syntax_checkers/puppet/puppet.vim @@ -0,0 +1,47 @@ +"============================================================================ +"File: puppet.vim +"Description: Syntax checking plugin for syntastic.vim +"Maintainer: Eivind Uggedal <eivind at uggedal dot com> +"License: This program is free software. It comes without any warranty, +" to the extent permitted by applicable law. You can redistribute +" it and/or modify it under the terms of the Do What The Fuck You +" Want To Public License, Version 2, as published by Sam Hocevar. +" See http://sam.zoy.org/wtfpl/COPYING for more details. +" +"============================================================================ + +if exists('g:loaded_syntastic_puppet_puppet_checker') + finish +endif +let g:loaded_syntastic_puppet_puppet_checker = 1 + +let s:save_cpo = &cpo +set cpo&vim + +function! SyntaxCheckers_puppet_puppet_GetLocList() dict + if !exists('s:puppet_new') + let s:puppet_new = syntastic#util#versionIsAtLeast(self.getVersion(), [2, 7, 0]) + endif + + let makeprg = self.makeprgBuild({ + \ 'args_before': (s:puppet_new ? 'parser validate --color=false' : '--color=false --parseonly') }) + + let errorformat = + \ '%-Gerr: Try ''puppet help parser validate'' for usage,' . + \ '%-GError: Try ''puppet help parser validate'' for usage,' . + \ '%A%t%*[a-zA-Z]: %m at %f:%l:%c,' . + \ '%A%t%*[a-zA-Z]: %m at %f:%l' + + return SyntasticMake({ + \ 'makeprg': makeprg, + \ 'errorformat': errorformat }) +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'puppet', + \ 'name': 'puppet'}) + +let &cpo = s:save_cpo +unlet s:save_cpo + +" vim: set sw=4 sts=4 et fdm=marker: diff --git a/vim/bundle/syntastic/syntax_checkers/puppet/puppetlint.vim b/vim/bundle/syntastic/syntax_checkers/puppet/puppetlint.vim new file mode 100644 index 0000000..a492db6 --- /dev/null +++ b/vim/bundle/syntastic/syntax_checkers/puppet/puppetlint.vim @@ -0,0 +1,52 @@ +"============================================================================ +"File: puppetlint.vim +"Description: Syntax checking plugin for syntastic.vim +"Maintainer: Eivind Uggedal <eivind at uggedal dot com> +"License: This program is free software. It comes without any warranty, +" to the extent permitted by applicable law. You can redistribute +" it and/or modify it under the terms of the Do What The Fuck You +" Want To Public License, Version 2, as published by Sam Hocevar. +" See http://sam.zoy.org/wtfpl/COPYING for more details. +" +"============================================================================ + +if exists('g:loaded_syntastic_puppet_puppetlint_checker') + finish +endif +let g:loaded_syntastic_puppet_puppetlint_checker = 1 + +let s:save_cpo = &cpo +set cpo&vim + +function! SyntaxCheckers_puppet_puppetlint_IsAvailable() dict + if !executable(self.getExec()) + return 0 + endif + let s:puppetlint_new = syntastic#util#versionIsAtLeast(self.getVersion(), [1]) + return syntastic#util#versionIsAtLeast(self.getVersion(), [0, 2]) +endfunction + +function! SyntaxCheckers_puppet_puppetlint_GetLocList() dict + call syntastic#log#deprecationWarn('puppet_lint_arguments', 'puppet_puppetlint_args') + + let makeprg = self.makeprgBuild({ + \ 'args_after': + \ '--log-format "%{KIND} [%{check}] %{message} at %{fullpath}:' . + \ (s:puppetlint_new ? '%{line}' : '%{linenumber}') . '"' }) + + 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', + \ 'exec': 'puppet-lint'}) + +let &cpo = s:save_cpo +unlet s:save_cpo + +" vim: set sw=4 sts=4 et fdm=marker: diff --git a/vim/bundle/syntastic/syntax_checkers/python/codec.py b/vim/bundle/syntastic/syntax_checkers/python/codec.py new file mode 100755 index 0000000..6e980c7 --- /dev/null +++ b/vim/bundle/syntastic/syntax_checkers/python/codec.py @@ -0,0 +1,31 @@ +#!/usr/bin/env python + +from __future__ import print_function +from sys import argv, exit + +import codecs +import re +import os + + +if len(argv) != 2: + exit(1) + +try: + with open(argv[1]) as fle: + text = fle.readlines() + + if text: + match = re.match(r"#\s*coding\s*:\s*(?P<coding>\w+)", text[0]) + if match: + text = codecs.lookup(match.groupdict()["coding"]).incrementaldecoder().decode( + ''.join(text).encode('utf-8')).encode('utf-8') + + if isinstance(text, list): + text = ''.join(text).encode('utf-8') + + compile(text, argv[1], 'exec', 0, 1) +except SyntaxError as err: + print('%s:%s:%s: %s' % (err.filename, err.lineno, err.offset, err.msg)) +except Exception as err: + print('%s:%s:%s: %s' % (os.path.abspath(argv[1]), 1, 0, err)) diff --git a/vim/bundle/syntastic/syntax_checkers/python/compile.py b/vim/bundle/syntastic/syntax_checkers/python/compile.py new file mode 100755 index 0000000..32f1413 --- /dev/null +++ b/vim/bundle/syntastic/syntax_checkers/python/compile.py @@ -0,0 +1,13 @@ +#!/usr/bin/env python + +from __future__ import print_function +from sys import argv, exit + + +if len(argv) != 2: + exit(1) + +try: + compile(open(argv[1]).read(), argv[1], 'exec', 0, 1) +except SyntaxError as err: + print('%s:%s:%s: %s' % (err.filename, err.lineno, err.offset, err.msg)) diff --git a/vim/bundle/syntastic/syntax_checkers/python/flake8.vim b/vim/bundle/syntastic/syntax_checkers/python/flake8.vim new file mode 100644 index 0000000..257b69d --- /dev/null +++ b/vim/bundle/syntastic/syntax_checkers/python/flake8.vim @@ -0,0 +1,72 @@ +"============================================================================ +"File: flake8.vim +"Description: Syntax checking plugin for syntastic.vim +"Authors: Sylvain Soliman <Sylvain dot Soliman+git at gmail dot com> +" kstep <me@kstep.me> +" +"============================================================================ + +if exists('g:loaded_syntastic_python_flake8_checker') + finish +endif +let g:loaded_syntastic_python_flake8_checker = 1 + +let s:save_cpo = &cpo +set cpo&vim + +function! SyntaxCheckers_python_flake8_GetHighlightRegex(item) + return SyntaxCheckers_python_pyflakes_GetHighlightRegex(a:item) +endfunction + +function! SyntaxCheckers_python_flake8_GetLocList() dict + let makeprg = self.makeprgBuild({}) + + let errorformat = + \ '%E%f:%l: could not compile,%-Z%p^,' . + \ '%A%f:%l:%c: %t%n %m,' . + \ '%A%f:%l: %t%n %m,' . + \ '%-G%.%#' + + let env = syntastic#util#isRunningWindows() ? {} : { 'TERM': 'dumb' } + + let loclist = SyntasticMake({ + \ 'makeprg': makeprg, + \ 'errorformat': errorformat, + \ 'env': env }) + + for e in loclist + " E*** and W*** are pep8 errors + " F*** are PyFlakes codes + " C*** are McCabe complexity messages + " N*** are naming conventions from pep8-naming + + if has_key(e, 'nr') + let e['text'] .= printf(' [%s%03d]', e['type'], e['nr']) + " E901 are syntax errors + " E902 are I/O errors + if e['type'] ==? 'E' && e['nr'] !~# '\m^9' + let e['subtype'] = 'Style' + endif + call remove(e, 'nr') + endif + + if e['type'] =~? '\m^[CNW]' + let e['subtype'] = 'Style' + endif + + let e['type'] = e['type'] =~? '\m^[EFC]' ? 'E' : 'W' + endfor + + return loclist +endfunction + +runtime! syntax_checkers/python/pyflakes.vim + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'python', + \ 'name': 'flake8'}) + +let &cpo = s:save_cpo +unlet s:save_cpo + +" vim: set sw=4 sts=4 et fdm=marker: diff --git a/vim/bundle/syntastic/syntax_checkers/python/frosted.vim b/vim/bundle/syntastic/syntax_checkers/python/frosted.vim new file mode 100644 index 0000000..d642795 --- /dev/null +++ b/vim/bundle/syntastic/syntax_checkers/python/frosted.vim @@ -0,0 +1,63 @@ +"============================================================================ +"File: frosted.vim +"Description: Syntax checking plugin for syntastic.vim +"Maintainer: LCD 47 <lcd047 at gmail dot com> +"License: This program is free software. It comes without any warranty, +" to the extent permitted by applicable law. You can redistribute +" it and/or modify it under the terms of the Do What The Fuck You +" Want To Public License, Version 2, as published by Sam Hocevar. +" See http://sam.zoy.org/wtfpl/COPYING for more details. +" +"============================================================================ + +if exists('g:loaded_syntastic_python_frosted_checker') + finish +endif +let g:loaded_syntastic_python_frosted_checker = 1 + +let s:save_cpo = &cpo +set cpo&vim + +function! SyntaxCheckers_python_frosted_GetLocList() dict + let makeprg = self.makeprgBuild({ 'args_after': '-vb' }) + + let errorformat = + \ '%f:%l:%c:%m,' . + \ '%E%f:%l: %m,' . + \ '%-Z%p^,' . + \ '%-G%.%#' + + let env = syntastic#util#isRunningWindows() ? {} : { 'TERM': 'dumb' } + + let loclist = SyntasticMake({ + \ 'makeprg': makeprg, + \ 'errorformat': errorformat, + \ 'env': env, + \ 'returns': [0, 1] }) + + for e in loclist + let e['col'] += 1 + + let parts = matchlist(e.text, '\v^([EW]\d+):([^:]*):(.+)') + if len(parts) >= 4 + let e['type'] = parts[1][0] + let e['text'] = parts[3] . ' [' . parts[1] . ']' + let e['hl'] = '\V\<' . escape(parts[2], '\') . '\>' + elseif e['text'] =~? '\v^I\d+:' + let e['valid'] = 0 + else + let e['vcol'] = 0 + endif + endfor + + return loclist +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'python', + \ 'name': 'frosted' }) + +let &cpo = s:save_cpo +unlet s:save_cpo + +" vim: set sw=4 sts=4 et fdm=marker: diff --git a/vim/bundle/syntastic/syntax_checkers/python/mypy.vim b/vim/bundle/syntastic/syntax_checkers/python/mypy.vim new file mode 100644 index 0000000..19ca1fd --- /dev/null +++ b/vim/bundle/syntastic/syntax_checkers/python/mypy.vim @@ -0,0 +1,36 @@ +"============================================================================ +"File: mypy.vim +"Description: Syntax checking plugin for syntastic.vim +"Author: Russ Hewgill <Russ dot Hewgill at gmail dot com> +" +"============================================================================ + +if exists('g:loaded_syntastic_python_mypy_checker') + finish +endif +let g:loaded_syntastic_python_mypy_checker = 1 + +let s:save_cpo = &cpo +set cpo&vim + +function! SyntaxCheckers_python_mypy_GetLocList() dict + let makeprg = self.makeprgBuild({}) + + let errorformat = '%f:%l:%m' + + return SyntasticMake({ + \ 'makeprg': makeprg, + \ 'errorformat': errorformat, + \ 'defaults': { 'type': 'E' }, + \ 'returns': [0, 1], + \ 'preprocess': 'mypy' }) +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'python', + \ 'name': 'mypy'}) + +let &cpo = s:save_cpo +unlet s:save_cpo + +" vim: set sw=4 sts=4 et fdm=marker: diff --git a/vim/bundle/syntastic/syntax_checkers/python/pep257.vim b/vim/bundle/syntastic/syntax_checkers/python/pep257.vim new file mode 100644 index 0000000..e59166b --- /dev/null +++ b/vim/bundle/syntastic/syntax_checkers/python/pep257.vim @@ -0,0 +1,23 @@ +"============================================================================ +"File: pep257.vim +"Description: Syntax checking plugin for syntastic +"Maintainer: LCD 47 <lcd047 at gmail dot com> +"License: This program is free software. It comes without any warranty, +" to the extent permitted by applicable law. You can redistribute +" it and/or modify it under the terms of the Do What The Fuck You +" Want To Public License, Version 2, as published by Sam Hocevar. +" See http://sam.zoy.org/wtfpl/COPYING for more details. +" +"============================================================================ + +if exists('g:loaded_syntastic_python_pep257_checker') + finish +endif +let g:loaded_syntastic_python_pep257_checker = 1 + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'python', + \ 'name': 'pep257', + \ 'redirect': 'python/pydocstyle'}) + +" vim: set sw=4 sts=4 et fdm=marker: diff --git a/vim/bundle/syntastic/syntax_checkers/python/pep8.vim b/vim/bundle/syntastic/syntax_checkers/python/pep8.vim new file mode 100644 index 0000000..80ab980 --- /dev/null +++ b/vim/bundle/syntastic/syntax_checkers/python/pep8.vim @@ -0,0 +1,23 @@ +"============================================================================ +"File: pep8.vim +"Description: Syntax checking plugin for syntastic +"Maintainer: LCD 47 <lcd047 at gmail dot com> +"License: This program is free software. It comes without any warranty, +" to the extent permitted by applicable law. You can redistribute +" it and/or modify it under the terms of the Do What The Fuck You +" Want To Public License, Version 2, as published by Sam Hocevar. +" See http://sam.zoy.org/wtfpl/COPYING for more details. +" +"============================================================================ + +if exists('g:loaded_syntastic_python_pep8_checker') + finish +endif +let g:loaded_syntastic_python_pep8_checker = 1 + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'python', + \ 'name': 'pep8', + \ 'redirect': 'python/pycodestyle'}) + +" vim: set sw=4 sts=4 et fdm=marker: diff --git a/vim/bundle/syntastic/syntax_checkers/python/prospector.vim b/vim/bundle/syntastic/syntax_checkers/python/prospector.vim new file mode 100644 index 0000000..c5e4735 --- /dev/null +++ b/vim/bundle/syntastic/syntax_checkers/python/prospector.vim @@ -0,0 +1,73 @@ +"============================================================================ +"File: prospector.vim +"Description: Syntax checking plugin for syntastic.vim +"Maintainer: LCD 47 <lcd047 at gmail dot com> +"License: This program is free software. It comes without any warranty, +" to the extent permitted by applicable law. You can redistribute +" it and/or modify it under the terms of the Do What The Fuck You +" Want To Public License, Version 2, as published by Sam Hocevar. +" See http://sam.zoy.org/wtfpl/COPYING for more details. +" +"============================================================================ + +if exists('g:loaded_syntastic_python_prospector_checker') + finish +endif +let g:loaded_syntastic_python_prospector_checker = 1 + +if !exists('g:syntastic_python_prospector_sort') + let g:syntastic_python_prospector_sort = 1 +endif + +let s:save_cpo = &cpo +set cpo&vim + +function! SyntaxCheckers_python_prospector_IsAvailable() dict + if !executable(self.getExec()) + return 0 + endif + return syntastic#util#versionIsAtLeast(self.getVersion(), [0, 7]) +endfunction + +function! SyntaxCheckers_python_prospector_GetLocList() dict + let makeprg = self.makeprgBuild({ + \ 'args_after': '--messages-only --absolute-paths --die-on-tool-error --zero-exit --output-format json' }) + + let errorformat = '%f:%l:%c: %m' + + let env = syntastic#util#isRunningWindows() ? {} : { 'TERM': 'dumb' } + + let loclist = SyntasticMake({ + \ 'makeprg': makeprg, + \ 'errorformat': errorformat, + \ 'env': env, + \ 'preprocess': 'prospector', + \ 'returns': [0] }) + + for e in loclist + if e['text'] =~# '\v\[%(dodgy|mccabe|pep8|pep257|pyroma)\]$' + let e['subtype'] = 'Style' + endif + + if e['text'] =~# '\v\[pylint\]$' + let e['type'] = e['text'] =~? '\m^[CRW]' ? 'W' : 'E' + elseif e['text'] =~# '\v\[%(frosted|pep8)\]$' + let e['type'] = e['text'] =~? '\m^W' ? 'W' : 'E' + elseif e['text'] =~# '\v\[%(dodgy|pyroma|vulture)\]$' + let e['type'] = 'W' + else + let e['type'] = 'E' + endif + endfor + + return loclist +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'python', + \ 'name': 'prospector'}) + +let &cpo = s:save_cpo +unlet s:save_cpo + +" vim: set sw=4 sts=4 et fdm=marker: diff --git a/vim/bundle/syntastic/syntax_checkers/python/py3kwarn.vim b/vim/bundle/syntastic/syntax_checkers/python/py3kwarn.vim new file mode 100644 index 0000000..b0e7771 --- /dev/null +++ b/vim/bundle/syntastic/syntax_checkers/python/py3kwarn.vim @@ -0,0 +1,36 @@ +"============================================================================ +"File: py3kwarn.vim +"Description: Syntax checking plugin for syntastic.vim +"Authors: Liam Curry <liam@curry.name> +" +"============================================================================ + +if exists('g:loaded_syntastic_python_py3kwarn_checker') + finish +endif +let g:loaded_syntastic_python_py3kwarn_checker = 1 + +let s:save_cpo = &cpo +set cpo&vim + +function! SyntaxCheckers_python_py3kwarn_GetLocList() dict + let makeprg = self.makeprgBuild({}) + + let errorformat = '%W%f:%l:%c: %m' + + let env = syntastic#util#isRunningWindows() ? {} : { 'TERM': 'dumb' } + + return SyntasticMake({ + \ 'makeprg': makeprg, + \ 'errorformat': errorformat, + \ 'env': env }) +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'python', + \ 'name': 'py3kwarn'}) + +let &cpo = s:save_cpo +unlet s:save_cpo + +" vim: set sw=4 sts=4 et fdm=marker: diff --git a/vim/bundle/syntastic/syntax_checkers/python/pycodestyle.vim b/vim/bundle/syntastic/syntax_checkers/python/pycodestyle.vim new file mode 100644 index 0000000..3b1e705 --- /dev/null +++ b/vim/bundle/syntastic/syntax_checkers/python/pycodestyle.vim @@ -0,0 +1,48 @@ +"============================================================================ +"File: pycodestyle.vim +"Description: Syntax checking plugin for syntastic +"Maintainer: LCD 47 <lcd047 at gmail dot com> +"License: This program is free software. It comes without any warranty, +" to the extent permitted by applicable law. You can redistribute +" it and/or modify it under the terms of the Do What The Fuck You +" Want To Public License, Version 2, as published by Sam Hocevar. +" See http://sam.zoy.org/wtfpl/COPYING for more details. +" +"============================================================================ + +if exists('g:loaded_syntastic_python_pycodestyle_checker') + finish +endif +let g:loaded_syntastic_python_pycodestyle_checker = 1 + +let s:save_cpo = &cpo +set cpo&vim + +function! SyntaxCheckers_python_pycodestyle_GetLocList() dict + let makeprg = self.makeprgBuild({}) + + let errorformat = '%f:%l:%c: %m' + + let env = syntastic#util#isRunningWindows() ? {} : { 'TERM': 'dumb' } + + let loclist = SyntasticMake({ + \ 'makeprg': makeprg, + \ 'errorformat': errorformat, + \ 'env': env, + \ 'subtype': 'Style' }) + + for e in loclist + let e['type'] = e['text'] =~? '^W' ? 'W' : 'E' + endfor + + return loclist +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'python', + \ 'name': 'pycodestyle'}) + +let &cpo = s:save_cpo +unlet s:save_cpo + +" vim: set sw=4 sts=4 et fdm=marker: diff --git a/vim/bundle/syntastic/syntax_checkers/python/pydocstyle.vim b/vim/bundle/syntastic/syntax_checkers/python/pydocstyle.vim new file mode 100644 index 0000000..05ea6b3 --- /dev/null +++ b/vim/bundle/syntastic/syntax_checkers/python/pydocstyle.vim @@ -0,0 +1,66 @@ +"============================================================================ +"File: pydocstyle.vim +"Description: Syntax checking plugin for syntastic +"Maintainer: LCD 47 <lcd047 at gmail dot com> +"License: This program is free software. It comes without any warranty, +" to the extent permitted by applicable law. You can redistribute +" it and/or modify it under the terms of the Do What The Fuck You +" Want To Public License, Version 2, as published by Sam Hocevar. +" See http://sam.zoy.org/wtfpl/COPYING for more details. +" +"============================================================================ + +if exists('g:loaded_syntastic_python_pydocstyle_checker') + finish +endif +let g:loaded_syntastic_python_pydocstyle_checker = 1 + +let s:save_cpo = &cpo +set cpo&vim + +function! SyntaxCheckers_python_pydocstyle_GetLocList() dict + if !exists('s:pydocstyle_new') + let s:pydocstyle_new = syntastic#util#versionIsAtLeast(self.getVersion(), [0, 3]) + endif + + let makeprg = self.makeprgBuild({}) + + if s:pydocstyle_new + let errorformat = + \ '%E%f:%l %.%#:,' . + \ '%+C %m' + else + let errorformat = + \ '%E%f:%l:%c%\%.%\%.%\d%\+:%\d%\+: %m,' . + \ '%E%f:%l:%c: %m,' . + \ '%+C %m' + endif + + let env = syntastic#util#isRunningWindows() ? {} : { 'TERM': 'dumb' } + + let loclist = SyntasticMake({ + \ 'makeprg': makeprg, + \ 'errorformat': errorformat, + \ 'env': env, + \ 'subtype': 'Style', + \ 'preprocess': 'killEmpty', + \ 'postprocess': ['compressWhitespace'] }) + + if s:pydocstyle_new == 0 + " byte offsets rather than column numbers + for e in loclist + let e['col'] = get(e, 'col', 0) + 1 + endfor + endif + + return loclist +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'python', + \ 'name': 'pydocstyle'}) + +let &cpo = s:save_cpo +unlet s:save_cpo + +" vim: set sw=4 sts=4 et fdm=marker: diff --git a/vim/bundle/syntastic/syntax_checkers/python/pyflakes.vim b/vim/bundle/syntastic/syntax_checkers/python/pyflakes.vim new file mode 100644 index 0000000..d403135 --- /dev/null +++ b/vim/bundle/syntastic/syntax_checkers/python/pyflakes.vim @@ -0,0 +1,74 @@ +"============================================================================ +"File: pyflakes.vim +"Description: Syntax checking plugin for syntastic.vim +"Authors: Martin Grenfell <martin.grenfell@gmail.com> +" kstep <me@kstep.me> +" Parantapa Bhattacharya <parantapa@gmail.com> +" +"============================================================================ + +if exists('g:loaded_syntastic_python_pyflakes_checker') + finish +endif +let g:loaded_syntastic_python_pyflakes_checker = 1 + +let s:save_cpo = &cpo +set cpo&vim + +function! SyntaxCheckers_python_pyflakes_GetHighlightRegex(i) + if stridx(a:i['text'], 'is assigned to but never used') >= 0 + \ || stridx(a:i['text'], 'imported but unused') >= 0 + \ || stridx(a:i['text'], 'undefined name') >= 0 + \ || stridx(a:i['text'], 'redefinition of') >= 0 + \ || stridx(a:i['text'], 'referenced before assignment') >= 0 + \ || stridx(a:i['text'], 'duplicate argument') >= 0 + \ || stridx(a:i['text'], 'after other statements') >= 0 + \ || stridx(a:i['text'], 'shadowed by loop variable') >= 0 + + " fun with Python's %r: try "..." first, then '...' + let term = matchstr(a:i['text'], '\m^.\{-}"\zs.\{-1,}\ze"') + if term !=# '' + return '\V\<' . escape(term, '\') . '\>' + endif + + let term = matchstr(a:i['text'], '\m^.\{-}''\zs.\{-1,}\ze''') + if term !=# '' + return '\V\<' . escape(term, '\') . '\>' + endif + endif + return '' +endfunction + +function! SyntaxCheckers_python_pyflakes_GetLocList() dict + let makeprg = self.makeprgBuild({}) + + let errorformat = + \ '%E%f:%l: could not compile,'. + \ '%-Z%p^,'. + \ '%E%f:%l:%c: %m,'. + \ '%E%f:%l: %m,'. + \ '%-G%.%#' + + let env = syntastic#util#isRunningWindows() ? {} : { 'TERM': 'dumb' } + + let loclist = SyntasticMake({ + \ 'makeprg': makeprg, + \ 'errorformat': errorformat, + \ 'env': env, + \ 'defaults': {'text': 'Syntax error'} }) + + for e in loclist + let e['vcol'] = 0 + endfor + + return loclist +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'python', + \ 'name': 'pyflakes'}) + +let &cpo = s:save_cpo +unlet s:save_cpo + +" vim: set sw=4 sts=4 et fdm=marker: diff --git a/vim/bundle/syntastic/syntax_checkers/python/pylama.vim b/vim/bundle/syntastic/syntax_checkers/python/pylama.vim new file mode 100644 index 0000000..d4aab0a --- /dev/null +++ b/vim/bundle/syntastic/syntax_checkers/python/pylama.vim @@ -0,0 +1,79 @@ +"============================================================================ +"File: pylama.vim +"Description: Syntax checking plugin for syntastic.vim +"Maintainer: LCD 47 <lcd047 at gmail dot com> +"License: This program is free software. It comes without any warranty, +" to the extent permitted by applicable law. You can redistribute +" it and/or modify it under the terms of the Do What The Fuck You +" Want To Public License, Version 2, as published by Sam Hocevar. +" See http://sam.zoy.org/wtfpl/COPYING for more details. +" +"============================================================================ + +if exists('g:loaded_syntastic_python_pylama_checker') + finish +endif +let g:loaded_syntastic_python_pylama_checker = 1 + +if !exists('g:syntastic_python_pylama_sort') + let g:syntastic_python_pylama_sort = 1 +endif + +let s:save_cpo = &cpo +set cpo&vim + +function! SyntaxCheckers_python_pylama_GetHighlightRegex(item) + return SyntaxCheckers_python_pyflakes_GetHighlightRegex(a:item) +endfunction + +function! SyntaxCheckers_python_pylama_GetLocList() dict + if !exists('s:pylama_new') + let s:pylama_new = syntastic#util#versionIsAtLeast(self.getVersion(), [4]) + endif + + let makeprg = self.makeprgBuild({ + \ 'args_after': '-f pep8' . (s:pylama_new ? ' --force' : '') }) + + " TODO: "WARNING:pylama:..." messages are probably a logging bug + let errorformat = + \ '%-GWARNING:pylama:%.%#,' . + \ '%A%f:%l:%c: %m' + + let env = syntastic#util#isRunningWindows() ? {} : { 'TERM': 'dumb' } + + let loclist = SyntasticMake({ + \ 'makeprg': makeprg, + \ 'errorformat': errorformat, + \ 'env': env }) + + " adjust for weirdness in each checker + for e in loclist + let e['type'] = e['text'] =~? '\m^[RCW]' ? 'W' : 'E' + if e['text'] =~# '\v\[%(isort|mccabe|pep257|pylint)\]$' + if has_key(e, 'col') + let e['col'] += 1 + endif + endif + if e['text'] =~# '\v\[pylint\]$' + if has_key(e, 'vcol') + let e['vcol'] = 0 + endif + endif + if e['text'] =~# '\v\[%(isort|mccabe|pep257|pep8)\]$' + let e['subtype'] = 'Style' + endif + endfor + + return loclist +endfunction + +runtime! syntax_checkers/python/pyflakes.vim + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'python', + \ 'name': 'pylama' }) + +let &cpo = s:save_cpo +unlet s:save_cpo + +" vim: set sw=4 sts=4 et fdm=marker: diff --git a/vim/bundle/syntastic/syntax_checkers/python/pylint.vim b/vim/bundle/syntastic/syntax_checkers/python/pylint.vim new file mode 100644 index 0000000..884d07a --- /dev/null +++ b/vim/bundle/syntastic/syntax_checkers/python/pylint.vim @@ -0,0 +1,98 @@ +"============================================================================ +"File: pylint.vim +"Description: Syntax checking plugin for syntastic.vim +"Maintainer: Parantapa Bhattacharya <parantapa at gmail dot com> +" +"============================================================================ + +if exists('g:loaded_syntastic_python_pylint_checker') + finish +endif +let g:loaded_syntastic_python_pylint_checker = 1 + +if !exists('g:syntastic_python_pylint_sort') + let g:syntastic_python_pylint_sort = 1 +endif + +let s:save_cpo = &cpo +set cpo&vim + +let s:pylint_new = -1 + +function! SyntaxCheckers_python_pylint_IsAvailable() dict " {{{1 + if !executable(self.getExec()) + return 0 + endif + + try + " On Windows the version is shown as "pylint-script.py 1.0.0". + " On Gentoo Linux it's "pylint-python2.7 0.28.0". + " On NixOS, that would be ".pylint-wrapped 0.26.0". + " On Arch Linux it's "pylint2 1.1.0". + " On new-ish Fedora it's "python3-pylint 1.2.0". + " Have you guys considered switching to creative writing yet? ;) + + let version_output = syntastic#util#system(self.getExecEscaped() . ' --version') + let pylint_version = filter( split(version_output, '\m, \=\|\n'), 'v:val =~# ''\m^\(python[-0-9]*-\|\.\)\=pylint[-0-9]*\>''' )[0] + let parsed_ver = syntastic#util#parseVersion(substitute(pylint_version, '\v^\S+\s+', '', '')) + call self.setVersion(parsed_ver) + + let s:pylint_new = syntastic#util#versionIsAtLeast(parsed_ver, [1]) + catch /\m^Vim\%((\a\+)\)\=:E684/ + call syntastic#log#ndebug(g:_SYNTASTIC_DEBUG_LOCLIST, 'checker output:', split(version_output, "\n", 1)) + call syntastic#log#error("checker python/pylint: can't parse version string (abnormal termination?)") + let s:pylint_new = -1 + endtry + + return s:pylint_new >= 0 +endfunction " }}}1 + +function! SyntaxCheckers_python_pylint_GetLocList() dict " {{{1 + let makeprg = self.makeprgBuild({ + \ 'args_after': (s:pylint_new ? + \ '-f text --msg-template="{path}:{line}:{column}:{C}: [{symbol}] {msg}" -r n' : + \ '-f parseable -r n -i y') }) + + let errorformat = + \ '%A%f:%l:%c:%t: %m,' . + \ '%A%f:%l: %m,' . + \ '%A%f:(%l): %m,' . + \ '%-Z%p^%.%#,' . + \ '%-G%.%#' + + let env = syntastic#util#isRunningWindows() ? {} : { 'TERM': 'dumb' } + + let loclist = SyntasticMake({ + \ 'makeprg': makeprg, + \ 'errorformat': errorformat, + \ 'env': env, + \ 'returns': range(32) }) + + for e in loclist + if !s:pylint_new + let e['type'] = e['text'][1] + endif + + if e['type'] =~? '\m^[EF]' + let e['type'] = 'E' + elseif e['type'] =~? '\m^[CRW]' + let e['type'] = 'W' + else + let e['valid'] = 0 + endif + + let e['col'] += 1 + let e['vcol'] = 0 + endfor + + return loclist +endfunction " }}}1 + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'python', + \ 'name': 'pylint' }) + +let &cpo = s:save_cpo +unlet s:save_cpo + +" vim: set sw=4 sts=4 et fdm=marker: diff --git a/vim/bundle/syntastic/syntax_checkers/python/python.vim b/vim/bundle/syntastic/syntax_checkers/python/python.vim new file mode 100644 index 0000000..17ad2c9 --- /dev/null +++ b/vim/bundle/syntastic/syntax_checkers/python/python.vim @@ -0,0 +1,57 @@ +"============================================================================ +"File: python.vim +"Description: Syntax checking plugin for syntastic.vim +"Maintainer: LCD 47 <lcd047 at gmail dot com> +"License: This program is free software. It comes without any warranty, +" to the extent permitted by applicable law. You can redistribute +" it and/or modify it under the terms of the Do What The Fuck You +" Want To Public License, Version 2, as published by Sam Hocevar. +" See http://sam.zoy.org/wtfpl/COPYING for more details. +" +"============================================================================ + +if exists('g:loaded_syntastic_python_python_checker') + finish +endif +let g:loaded_syntastic_python_python_checker = 1 + +if !exists('g:syntastic_python_python_use_codec') + let g:syntastic_python_python_use_codec = 0 +endif + +let s:save_cpo = &cpo +set cpo&vim + +let s:base_path = expand('<sfile>:p:h', 1) . syntastic#util#Slash() + +function! SyntaxCheckers_python_python_IsAvailable() dict + if !executable(self.getExec()) + return 0 + endif + return syntastic#util#versionIsAtLeast(self.getVersion(), [2, 6]) +endfunction + +function! SyntaxCheckers_python_python_GetLocList() dict + let compiler = s:base_path . (g:syntastic_python_python_use_codec ? 'codec.py' : 'compile.py') + call self.log('using compiler script', compiler) + let makeprg = self.makeprgBuild({ 'exe': [self.getExec(), compiler] }) + + let errorformat = '%E%f:%l:%c: %m' + + let env = syntastic#util#isRunningWindows() ? {} : { 'TERM': 'dumb' } + + return SyntasticMake({ + \ 'makeprg': makeprg, + \ 'errorformat': errorformat, + \ 'env': env, + \ 'returns': [0] }) +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'python', + \ 'name': 'python'}) + +let &cpo = s:save_cpo +unlet s:save_cpo + +" vim: set sw=4 sts=4 et fdm=marker: diff --git a/vim/bundle/syntastic/syntax_checkers/qml/qmllint.vim b/vim/bundle/syntastic/syntax_checkers/qml/qmllint.vim new file mode 100644 index 0000000..0aef61c --- /dev/null +++ b/vim/bundle/syntastic/syntax_checkers/qml/qmllint.vim @@ -0,0 +1,39 @@ +"============================================================================ +"File: qmllint.vim +"Description: Syntax checking plugin for syntastic.vim using qmllint +"Maintainer: Peter Wu <peter@lekensteyn.nl> +"License: This program is free software. It comes without any warranty, +" to the extent permitted by applicable law. You can redistribute +" it and/or modify it under the terms of the Do What 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_qml_qmllint_checker') + finish +endif +let g:loaded_syntastic_qml_qmllint_checker = 1 + +let s:save_cpo = &cpo +set cpo&vim + +function! SyntaxCheckers_qml_qmllint_GetLocList() dict + let makeprg = self.makeprgBuild({}) + + let errorformat = '%f:%l : %m' + + return SyntasticMake({ + \ 'makeprg': makeprg, + \ 'errorformat': errorformat, + \ 'postprocess': ['guards'], + \ 'returns': [0, 255] }) +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'qml', + \ 'name': 'qmllint'}) + +let &cpo = s:save_cpo +unlet s:save_cpo + +" vim: set sw=4 sts=4 et fdm=marker: diff --git a/vim/bundle/syntastic/syntax_checkers/r/lint.vim b/vim/bundle/syntastic/syntax_checkers/r/lint.vim new file mode 100644 index 0000000..854c170 --- /dev/null +++ b/vim/bundle/syntastic/syntax_checkers/r/lint.vim @@ -0,0 +1,82 @@ +"============================================================================ +"File: lint.vim +"Description: Syntax checking plugin for syntastic.vim +"Maintainer: LCD 47 <lcd047 at gmail dot com> +"License: This program is free software. It comes without any warranty, +" to the extent permitted by applicable law. You can redistribute +" it and/or modify it under the terms of the Do What The Fuck You +" Want To Public License, Version 2, as published by Sam Hocevar. +" See http://sam.zoy.org/wtfpl/COPYING for more details. +" +"============================================================================ + +if exists('g:loaded_syntastic_r_lint_checker') + finish +endif +let g:loaded_syntastic_r_lint_checker = 1 + +if !exists('g:syntastic_r_lint_styles') + let g:syntastic_r_lint_styles = 'lint.style' +endif + +if !exists('g:syntastic_r_lint_sort') + let g:syntastic_r_lint_sort = 1 +endif + +let s:save_cpo = &cpo +set cpo&vim + +function! SyntaxCheckers_r_lint_GetHighlightRegex(item) + let term = matchstr(a:item['text'], '\m`\zs[^`]\+\ze`') + if term ==# '' + let term = matchstr(a:item['text'], "\\m'\\zs[^']\\+\\ze'") + endif + return term !=# '' ? '\V' . escape(term, '\') : '' +endfunction + +function! SyntaxCheckers_r_lint_IsAvailable() dict + if !executable(self.getExec()) + return 0 + endif + call syntastic#util#system(self.getExecEscaped() . ' --slave --restore --no-save -e ' . syntastic#util#shescape('library(lint)')) + return v:shell_error == 0 +endfunction + +function! SyntaxCheckers_r_lint_GetLocList() dict + let setwd = syntastic#util#isRunningWindows() ? 'setwd("' . escape(getcwd(), '"\') . '"); ' : '' + let makeprg = self.getExecEscaped() . ' --slave --restore --no-save' . + \ ' -e ' . syntastic#util#shescape(setwd . 'library(lint); ' . + \ 'try(lint(commandArgs(TRUE), ' . g:syntastic_r_lint_styles . '))') . + \ ' --args ' . syntastic#util#shexpand('%') + + let errorformat = + \ '%t:%f:%l:%v: %m,' . + \ '%t:%f:%l: %m' + + let loclist = SyntasticMake({ + \ 'makeprg': makeprg, + \ 'errorformat': errorformat, + \ 'subtype': 'Style', + \ 'preprocess': 'rparse', + \ 'returns': [0] }) + + for e in loclist + if e['type'] ==? 'F' + " parse error + let e['type'] = 'E' + call remove(e, 'subtype') + endif + endfor + + return loclist +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'r', + \ 'name': 'lint', + \ 'exec': 'R' }) + +let &cpo = s:save_cpo +unlet s:save_cpo + +" vim: set sw=4 sts=4 et fdm=marker: diff --git a/vim/bundle/syntastic/syntax_checkers/r/lintr.vim b/vim/bundle/syntastic/syntax_checkers/r/lintr.vim new file mode 100644 index 0000000..7c71ec0 --- /dev/null +++ b/vim/bundle/syntastic/syntax_checkers/r/lintr.vim @@ -0,0 +1,81 @@ +"============================================================================ +"File: lintr.vim +"Description: Syntax checking plugin for syntastic.vim +"Maintainer: Jim Hester <james.f.hester at gmail dot com> +"License: This program is free software. It comes without any warranty, +" to the extent permitted by applicable law. You can redistribute +" it and/or modify it under the terms of the Do What The Fuck You +" Want To Public License, Version 2, as published by Sam Hocevar. +" See http://sam.zoy.org/wtfpl/COPYING for more details. +" +"============================================================================ +" +" Security: +" +" This checker runs the code in your file. This is probably fine if you +" wrote the file yourself, but it can be a problem if you're trying to +" check third party files. If you are 100% willing to let Vim run the +" code in your file, set g:syntastic_enable_r_lintr_checker to 1 in +" your vimrc to enable this checker: +" +" let g:syntastic_enable_r_lintr_checker = 1 + +if exists("g:loaded_syntastic_r_lintr_checker") + finish +endif +let g:loaded_syntastic_r_lintr_checker = 1 + +if !exists('g:syntastic_r_lintr_linters') + let g:syntastic_r_lintr_linters = 'default_linters' +endif + +if !exists('g:syntastic_r_lintr_cache') + let g:syntastic_r_lintr_cache = 'FALSE' +endif + +let s:save_cpo = &cpo +set cpo&vim + +function! SyntaxCheckers_r_lintr_GetHighlightRegex(item) + let term = matchstr(a:item['text'], "\\m'\\zs[^']\\+\\ze'") + return term != '' ? '\V' . escape(term, '\') : '' +endfunction + +function! SyntaxCheckers_r_lintr_IsAvailable() dict + if !executable(self.getExec()) + return 0 + endif + call system(self.getExecEscaped() . ' --slave --no-restore --no-save -e ' . syntastic#util#shescape('library(lintr)')) + return v:shell_error == 0 +endfunction + +function! SyntaxCheckers_r_lintr_GetLocList() dict + let setwd = syntastic#util#isRunningWindows() ? 'setwd("' . escape(getcwd(), '"\') . '"); ' : '' + let makeprg = self.getExecEscaped() . ' --slave --no-restore --no-save' . + \ ' -e ' . syntastic#util#shescape(setwd . 'suppressPackageStartupMessages(library(lintr)); ' . + \ 'lint(cache = ' . g:syntastic_r_lintr_cache . ', commandArgs(TRUE), ' . g:syntastic_r_lintr_linters . ')') . + \ ' --args ' . syntastic#util#shexpand('%') + + let errorformat = + \ '%W%f:%l:%c: style: %m,' . + \ '%W%f:%l:%c: warning: %m,' . + \ '%E%f:%l:%c: error: %m,' + + call self.setWantSort(1) + + return SyntasticMake({ + \ 'makeprg': makeprg, + \ 'errorformat': errorformat, + \ 'returns': [0] }) +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'r', + \ 'name': 'lintr', + \ 'exec': 'R', + \ 'enable': 'enable_r_lintr_checker'}) + +let &cpo = s:save_cpo +unlet s:save_cpo + +" vim: set sw=4 sts=4 et fdm=marker: diff --git a/vim/bundle/syntastic/syntax_checkers/r/svtools.vim b/vim/bundle/syntastic/syntax_checkers/r/svtools.vim new file mode 100644 index 0000000..d2a6a74 --- /dev/null +++ b/vim/bundle/syntastic/syntax_checkers/r/svtools.vim @@ -0,0 +1,74 @@ +"============================================================================ +"File: svtools.vim +"Description: Syntax checking plugin for syntastic.vim +"Maintainer: LCD 47 <lcd047 at gmail dot com> +"License: This program is free software. It comes without any warranty, +" to the extent permitted by applicable law. You can redistribute +" it and/or modify it under the terms of the Do What The Fuck You +" Want To Public License, Version 2, as published by Sam Hocevar. +" See http://sam.zoy.org/wtfpl/COPYING for more details. +" +"============================================================================ +" +" Security: +" +" This checker runs the code in your file. This is probably fine if you +" wrote the file yourself, but it can be a problem if you're trying to +" check third party files. If you are 100% willing to let Vim run the +" code in your file, set g:syntastic_enable_r_svtools_checker to 1 in +" your vimrc to enable this checker: +" +" let g:syntastic_enable_r_svtools_checker = 1 + +if exists('g:loaded_syntastic_r_svtools_checker') + finish +endif +let g:loaded_syntastic_r_svtools_checker = 1 + +if !exists('g:syntastic_r_svtools_styles') + let g:syntastic_r_svtools_styles = 'lint.style' +endif + +let s:save_cpo = &cpo +set cpo&vim + +function! SyntaxCheckers_r_svtools_GetHighlightRegex(item) + let term = matchstr(a:item['text'], "\\m'\\zs[^']\\+\\ze'") + return term !=# '' ? '\V' . escape(term, '\') : '' +endfunction + +function! SyntaxCheckers_r_svtools_IsAvailable() dict + if !executable(self.getExec()) + return 0 + endif + call syntastic#util#system(self.getExecEscaped() . ' --slave --restore --no-save -e ' . syntastic#util#shescape('library(svTools)')) + return v:shell_error == 0 +endfunction + +function! SyntaxCheckers_r_svtools_GetLocList() dict + let setwd = syntastic#util#isRunningWindows() ? 'setwd("' . escape(getcwd(), '"\') . '"); ' : '' + let makeprg = self.getExecEscaped() . ' --slave --restore --no-save' . + \ ' -e ' . syntastic#util#shescape(setwd . 'library(svTools); ' . + \ 'try(lint(commandArgs(TRUE), filename = commandArgs(TRUE), type = "flat", sep = ":"))') . + \ ' --args ' . syntastic#util#shexpand('%') + + let errorformat = + \ '%trror:%f:%\s%#%l:%\s%#%v:%m,' . + \ '%tarning:%f:%\s%#%l:%\s%#%v:%m' + + return SyntasticMake({ + \ 'makeprg': makeprg, + \ 'errorformat': errorformat, + \ 'returns': [0] }) +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'r', + \ 'name': 'svtools', + \ 'exec': 'R', + \ 'enable': 'enable_r_svtools_checker'}) + +let &cpo = s:save_cpo +unlet s:save_cpo + +" vim: set sw=4 sts=4 et fdm=marker: diff --git a/vim/bundle/syntastic/syntax_checkers/racket/code-ayatollah.vim b/vim/bundle/syntastic/syntax_checkers/racket/code-ayatollah.vim new file mode 100644 index 0000000..14463c4 --- /dev/null +++ b/vim/bundle/syntastic/syntax_checkers/racket/code-ayatollah.vim @@ -0,0 +1,62 @@ +"============================================================================ +"File: code-ayatollah.vim +"Description: Syntax checking plugin for syntastic.vim +"Maintainer: LCD 47 <lcd047 at gmail dot com> +"License: This program is free software. It comes without any warranty, +" to the extent permitted by applicable law. You can redistribute +" it and/or modify it under the terms of the Do What The Fuck You +" Want To Public License, Version 2, as published by Sam Hocevar. +" See http://sam.zoy.org/wtfpl/COPYING for more details. +" +"============================================================================ + +if exists('g:loaded_syntastic_racket_code_ayatollah_checker') + finish +endif +let g:loaded_syntastic_racket_code_ayatollah_checker = 1 + +if !exists('g:syntastic_racket_code_ayatollah_script') + let g:syntastic_racket_code_ayatollah_script = 'code-ayatollah.rkt' +endif + +if !exists('g:syntastic_racket_code_ayatollah_sort') + let g:syntastic_racket_code_ayatollah_sort = 1 +endif + +let s:save_cpo = &cpo +set cpo&vim + +function! SyntaxCheckers_racket_code_ayatollah_IsAvailable() dict + let s:script = expand(g:syntastic_racket_code_ayatollah_script, 1) + return executable(self.getExec()) && filereadable(s:script) +endfunction + +function! SyntaxCheckers_racket_code_ayatollah_GetLocList() dict + let makeprg = self.makeprgBuild({ 'exe': [self.getExec(), s:script] }) + + let errorformat = + \ ' %l:%v: %m,' . + \ '%PErrors in %f:,' . + \ '%-G%.%#' + + let loclist = SyntasticMake({ + \ 'makeprg': makeprg, + \ 'errorformat': errorformat, + \ 'subtype': 'Style' }) + + for e in loclist + let e['col'] += 1 + endfor + + return loclist +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'racket', + \ 'name': 'code_ayatollah', + \ 'exec': 'racket' }) + +let &cpo = s:save_cpo +unlet s:save_cpo + +" vim: set sw=4 sts=4 et fdm=marker: diff --git a/vim/bundle/syntastic/syntax_checkers/racket/racket.vim b/vim/bundle/syntastic/syntax_checkers/racket/racket.vim new file mode 100644 index 0000000..b563a5b --- /dev/null +++ b/vim/bundle/syntastic/syntax_checkers/racket/racket.vim @@ -0,0 +1,51 @@ +"============================================================================ +"File: racket.vim +"Description: Syntax checking plugin for syntastic.vim +"Author: Steve Bragg <steve at empresseffects dot com> +" +"License: This program is free software. It comes without any warranty, +" to the extent permitted by applicable law. You can redistribute +" it and/or modify it under the terms of the Do What The Fuck You +" Want To Public License, Version 2, as published by Sam Hocevar. +" See http://sam.zoy.org/wtfpl/COPYING for more details. +" +"============================================================================ + +if exists('g:loaded_syntastic_racket_racket_checker') + finish +endif +let g:loaded_syntastic_racket_racket_checker=1 + +let s:save_cpo = &cpo +set cpo&vim + +function! SyntaxCheckers_racket_racket_GetLocList() dict + let makeprg = self.makeprgBuild({}) + + " example of error message + "eval-apply.rkt:460:30: the-empty-environment: unbound identifier in module + " in: the-empty-environment + let errorformat = '%f:%l:%v: %m' + + let loclist = SyntasticMake({ + \ 'makeprg': makeprg, + \ 'errorformat': errorformat }) + + for e in loclist + if has_key(e, 'col') + let e['col'] += 1 + endif + endfor + + return loclist +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'racket', + \ 'name': 'racket', + \ 'enable': 'enable_racket_racket_checker' }) + +let &cpo = s:save_cpo +unlet s:save_cpo + +" vim: set sw=4 sts=4 et fdm=marker: diff --git a/vim/bundle/syntastic/syntax_checkers/rmd/lintr.vim b/vim/bundle/syntastic/syntax_checkers/rmd/lintr.vim new file mode 100644 index 0000000..dcc235f --- /dev/null +++ b/vim/bundle/syntastic/syntax_checkers/rmd/lintr.vim @@ -0,0 +1,23 @@ +"============================================================================ +"File: lintr.vim +"Description: Syntax checking plugin for syntastic.vim +"Maintainer: Jim Hester <james.f.hester at gmail dot com> +"License: This program is free software. It comes without any warranty, +" to the extent permitted by applicable law. You can redistribute +" it and/or modify it under the terms of the Do What The Fuck You +" Want To Public License, Version 2, as published by Sam Hocevar. +" See http://sam.zoy.org/wtfpl/COPYING for more details. +" +"============================================================================ + +if exists('g:loaded_syntastic_rmd_lintr_checker') + finish +endif +let g:loaded_syntastic_rmd_lintr_checker = 1 + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'rmd', + \ 'name': 'lintr', + \ 'redirect': 'r/lintr'}) + +" vim: set sw=4 sts=4 et fdm=marker: diff --git a/vim/bundle/syntastic/syntax_checkers/rnc/rnv.vim b/vim/bundle/syntastic/syntax_checkers/rnc/rnv.vim new file mode 100644 index 0000000..848d60c --- /dev/null +++ b/vim/bundle/syntastic/syntax_checkers/rnc/rnv.vim @@ -0,0 +1,38 @@ +"============================================================================ +"File: rnv.vim +"Description: RelaxNG RNV syntax checking plugin for syntastic.vim +"Maintainer: Remko Tronçon <remko at el-tramo dot be> +"License: This program is free software. It comes without any warranty, +" to the extent permitted by applicable law. You can redistribute +" it and/or modify it under the terms of the Do What 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_rnc_rnv_checker') + finish +endif +let g:loaded_syntastic_rnc_rnv_checker = 1 + +let s:save_cpo = &cpo +set cpo&vim + +function! SyntaxCheckers_rnc_rnv_GetLocList() dict + let makeprg = self.makeprgBuild({ 'args': '-c' }) + + let errorformat = + \ '%f:%l:%c: %trror: %m' + + return SyntasticMake({ + \ 'makeprg': makeprg, + \ 'errorformat': errorformat }) +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'rnc', + \ 'name': 'rnv'}) + +let &cpo = s:save_cpo +unlet s:save_cpo + +" vim: set sw=4 sts=4 et fdm=marker: diff --git a/vim/bundle/syntastic/syntax_checkers/rst/rst2pseudoxml.vim b/vim/bundle/syntastic/syntax_checkers/rst/rst2pseudoxml.vim new file mode 100644 index 0000000..532c75c --- /dev/null +++ b/vim/bundle/syntastic/syntax_checkers/rst/rst2pseudoxml.vim @@ -0,0 +1,65 @@ +"============================================================================ +"File: rst.vim +"Description: Syntax checking plugin for docutils' reStructuredText files +"Maintainer: James Rowe <jnrowe at gmail dot com> +"License: This program is free software. It comes without any warranty, +" to the extent permitted by applicable law. You can redistribute +" it and/or modify it under the terms of the Do What The Fuck You +" Want To Public License, Version 2, as published by Sam Hocevar. +" See http://sam.zoy.org/wtfpl/COPYING for more details. +" +"============================================================================ + +" We use rst2pseudoxml.py, as it is ever so marginally faster than the other +" rst2${x} tools in docutils. + +if exists('g:loaded_syntastic_rst_rst2pseudoxml_checker') + finish +endif +let g:loaded_syntastic_rst_rst2pseudoxml_checker = 1 + +let s:rst2pseudoxml = (executable('rst2pseudoxml.py') && !syntastic#util#isRunningWindows()) ? 'rst2pseudoxml.py' : 'rst2pseudoxml' + +let s:save_cpo = &cpo +set cpo&vim + +function! SyntaxCheckers_rst_rst2pseudoxml_IsAvailable() dict + call self.log('exec =', self.getExec()) + return executable(self.getExec()) +endfunction + +function! SyntaxCheckers_rst_rst2pseudoxml_GetLocList() dict + let makeprg = self.makeprgBuild({ + \ 'args_after': '--report=2 --exit-status=1', + \ 'tail': syntastic#util#DevNull() }) + + let errorformat = + \ '%f:%l: (%t%\w%\+/%\d%\+) %m,'. + \ '%f:: (%t%\w%\+/%\d%\+) %m,'. + \ '%-G%.%#' + + let loclist = SyntasticMake({ + \ 'makeprg': makeprg, + \ 'errorformat': errorformat }) + + for e in loclist + if e['type'] ==? 'I' + let e['type'] = 'W' + let e['subtype'] = 'Style' + else + let e['type'] = 'E' + endif + endfor + + return loclist +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'rst', + \ 'name': 'rst2pseudoxml', + \ 'exec': s:rst2pseudoxml }) + +let &cpo = s:save_cpo +unlet s:save_cpo + +" vim: set sw=4 sts=4 et fdm=marker: diff --git a/vim/bundle/syntastic/syntax_checkers/rst/rstcheck.vim b/vim/bundle/syntastic/syntax_checkers/rst/rstcheck.vim new file mode 100644 index 0000000..3c3b8c4 --- /dev/null +++ b/vim/bundle/syntastic/syntax_checkers/rst/rstcheck.vim @@ -0,0 +1,50 @@ +"============================================================================ +"File: rstcheck.vim +"Description: Syntax checking for reStructuredText and embedded code blocks +"Authors: Steven Myint <git@stevenmyint.com> +" +"============================================================================ + +if exists('g:loaded_syntastic_rst_rstcheck_checker') + finish +endif +let g:loaded_syntastic_rst_rstcheck_checker = 1 + +let s:save_cpo = &cpo +set cpo&vim + +function! SyntaxCheckers_rst_rstcheck_GetLocList() dict + let makeprg = self.makeprgBuild({}) + + 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, + \ 'returns': [0, 1] }) + + for e in loclist + if e['type'] ==? 'S' + let e['type'] = 'E' + elseif e['type'] ==? 'I' + let e['type'] = 'W' + let e['subtype'] = 'Style' + endif + endfor + + return loclist +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'rst', + \ 'name': 'rstcheck'}) + +let &cpo = s:save_cpo +unlet s:save_cpo + +" vim: set sw=4 sts=4 et fdm=marker: diff --git a/vim/bundle/syntastic/syntax_checkers/rst/sphinx.vim b/vim/bundle/syntastic/syntax_checkers/rst/sphinx.vim new file mode 100644 index 0000000..3c211f4 --- /dev/null +++ b/vim/bundle/syntastic/syntax_checkers/rst/sphinx.vim @@ -0,0 +1,80 @@ +"============================================================================ +"File: sphinx.vim +"Description: Syntax checking plugin for Sphinx reStructuredText files +"Maintainer: Buck Evan <buck dot 2019 at gmail dot com> +"License: This program is free software. It comes without any warranty, +" to the extent permitted by applicable law. You can redistribute +" it and/or modify it under the terms of the Do What The Fuck You +" Want To Public License, Version 2, as published by Sam Hocevar. +" See http://sam.zoy.org/wtfpl/COPYING for more details. +" +"============================================================================ + +if exists("g:loaded_syntastic_rst_sphinx_checker") + finish +endif +let g:loaded_syntastic_rst_sphinx_checker = 1 + +let s:save_cpo = &cpo +set cpo&vim + +let s:sphinx_cache_location = syntastic#util#tmpdir() +lockvar s:sphinx_cache_location + +augroup syntastic + autocmd VimLeave * call syntastic#util#rmrf(s:sphinx_cache_location) +augroup END + +function! SyntaxCheckers_rst_sphinx_GetLocList() dict + + let srcdir = syntastic#util#var('rst_sphinx_source_dir') + call self.log('g:syntastic_rst_sphinx_source_dir =', srcdir) + if srcdir ==# '' + let config = syntastic#util#findFileInParent('conf.py', expand('%:p:h', 1)) + if config ==# '' || !filereadable(config) + call self.log('conf.py file not found') + return [] + endif + let srcdir = fnamemodify(config, ':p:h') + endif + + let confdir = syntastic#util#var('rst_sphinx_config_dir') + call self.log('g:syntastic_rst_sphinx_config_dir =', confdir) + if confdir ==# '' + let config = syntastic#util#findFileInParent('conf.py', expand('%:p:h', 1)) + let confdir = (config !=# '' && filereadable(config)) ? fnamemodify(config, ':p:h') : srcdir + endif + + let makeprg = self.makeprgBuild({ + \ 'args': '-n -E', + \ 'args_after': '-q -N -b pseudoxml -c ' . syntastic#util#shescape(confdir), + \ 'fname': syntastic#util#shescape(srcdir), + \ 'fname_after': syntastic#util#shescape(s:sphinx_cache_location) }) + + let errorformat = + \ '%E%f:%l: SEVER%t: %m,' . + \ '%f:%l: %tRROR: %m,' . + \ '%f:%l: %tARNING: %m,' . + \ '%E%f:: SEVER%t: %m,' . + \ '%f:: %tRROR: %m,' . + \ '%f:: %tARNING: %m,' . + \ '%trror: %m,' . + \ '%+C%.%#' + + let loclist = SyntasticMake({ + \ 'makeprg': makeprg, + \ 'errorformat': errorformat, + \ 'returns': [0] }) + + return loclist +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'rst', + \ 'name': 'sphinx', + \ 'exec': 'sphinx-build' }) + +let &cpo = s:save_cpo +unlet s:save_cpo + +" vim: set sw=4 sts=4 et fdm=marker: diff --git a/vim/bundle/syntastic/syntax_checkers/ruby/flog.vim b/vim/bundle/syntastic/syntax_checkers/ruby/flog.vim new file mode 100644 index 0000000..127cdbd --- /dev/null +++ b/vim/bundle/syntastic/syntax_checkers/ruby/flog.vim @@ -0,0 +1,72 @@ +"============================================================================ +"File: flog.vim +"Description: Syntax checking plugin for syntastic.vim +"Maintainer: Tim Carry <tim at pixelastic dot com> +"License: This program is free software. It comes without any warranty, +" to the extent permitted by applicable law. You can redistribute +" it and/or modify it under the terms of the Do What The Fuck You +" Want To Public License, Version 2, as published by Sam Hocevar. +" See http://sam.zoy.org/wtfpl/COPYING for more details. +" +"============================================================================ + +if exists('g:loaded_syntastic_ruby_flog_checker') + finish +endif +let g:loaded_syntastic_ruby_flog_checker = 1 + +if !exists('g:syntastic_ruby_flog_threshold_warning') + let g:syntastic_ruby_flog_threshold_warning = 45 +endif + +if !exists('g:syntastic_ruby_flog_threshold_error') + let g:syntastic_ruby_flog_threshold_error = 90 +endif + +if !exists('g:syntastic_ruby_flog_sort') + let g:syntastic_ruby_flog_sort = 1 +endif + +let s:save_cpo = &cpo +set cpo&vim + +function! SyntaxCheckers_ruby_flog_GetLocList() dict + let makeprg = self.makeprgBuild({ 'args': '-a' }) + + " Example output: + " 93.25: MyClass::my_method my_file:42 + let errorformat = '%\m%\s%#%m: %.%# %f:%l' + + let loclist = SyntasticMake({ + \ 'makeprg': makeprg, + \ 'errorformat': errorformat, + \ 'subtype': 'Style' }) + + let trail_w = syntastic#util#float2str(g:syntastic_ruby_flog_threshold_warning) . ')' + let trail_e = syntastic#util#float2str(g:syntastic_ruby_flog_threshold_error) . ')' + for e in loclist + let score = syntastic#util#str2float(e['text']) + + let e['text'] = 'Complexity is too high (' . syntastic#util#float2str(score) . '/' + if score < g:syntastic_ruby_flog_threshold_warning + let e['valid'] = 0 + elseif score < g:syntastic_ruby_flog_threshold_error + let e['type'] = 'W' + let e['text'] .= trail_w + else + let e['type'] = 'E' + let e['text'] .= trail_e + endif + endfor + + return loclist +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'ruby', + \ 'name': 'flog'}) + +let &cpo = s:save_cpo +unlet s:save_cpo + +" vim: set sw=4 sts=4 et fdm=marker: diff --git a/vim/bundle/syntastic/syntax_checkers/ruby/jruby.vim b/vim/bundle/syntastic/syntax_checkers/ruby/jruby.vim new file mode 100644 index 0000000..d9d2aee --- /dev/null +++ b/vim/bundle/syntastic/syntax_checkers/ruby/jruby.vim @@ -0,0 +1,50 @@ +"============================================================================ +"File: jruby.vim +"Description: Syntax checking plugin for syntastic.vim +"Maintainer: Leonid Shevtsov <leonid at shevtsov dot me> +"License: This program is free software. It comes without any warranty, +" to the extent permitted by applicable law. You can redistribute +" it and/or modify it under the terms of the Do What The Fuck You +" Want To Public License, Version 2, as published by Sam Hocevar. +" See http://sam.zoy.org/wtfpl/COPYING for more details. +" +"============================================================================ + +if exists('g:loaded_syntastic_ruby_jruby_checker') + finish +endif +let g:loaded_syntastic_ruby_jruby_checker = 1 + +let s:save_cpo = &cpo +set cpo&vim + +function! SyntaxCheckers_ruby_jruby_GetLocList() dict + let makeprg = self.makeprgBuild({ + \ 'args': (syntastic#util#isRunningWindows() ? '-T1 -W1' : '-W1'), + \ 'args_after': '-c' }) + + 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%.%#' + + let env = syntastic#util#isRunningWindows() ? {} : { 'RUBYOPT': '' } + + return SyntasticMake({ + \ 'makeprg': makeprg, + \ 'errorformat': errorformat, + \ 'env': env }) +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'ruby', + \ 'name': 'jruby'}) + +let &cpo = s:save_cpo +unlet s:save_cpo + +" vim: set sw=4 sts=4 et fdm=marker: diff --git a/vim/bundle/syntastic/syntax_checkers/ruby/macruby.vim b/vim/bundle/syntastic/syntax_checkers/ruby/macruby.vim new file mode 100644 index 0000000..c51188f --- /dev/null +++ b/vim/bundle/syntastic/syntax_checkers/ruby/macruby.vim @@ -0,0 +1,49 @@ +"============================================================================ +"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 + +let s:save_cpo = &cpo +set cpo&vim + +function! SyntaxCheckers_ruby_macruby_GetLocList() dict + let makeprg = self.makeprgBuild({ + \ 'args': '-W1', + \ 'args_after': '-c' }) + + let errorformat = + \ '%-GSyntax OK,'. + \ '%E%f:%l: syntax error\, %m,'. + \ '%Z%p^,'. + \ '%W%f:%l: warning: %m,'. + \ '%Z%p^,'. + \ '%W%f:%l: %m,'. + \ '%-C%.%#' + + let env = { 'RUBYOPT': '' } + + return SyntasticMake({ + \ 'makeprg': makeprg, + \ 'errorformat': errorformat, + \ 'env': env }) +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'ruby', + \ 'name': 'macruby'}) + +let &cpo = s:save_cpo +unlet s:save_cpo + +" vim: set sw=4 sts=4 et fdm=marker: diff --git a/vim/bundle/syntastic/syntax_checkers/ruby/mri.vim b/vim/bundle/syntastic/syntax_checkers/ruby/mri.vim new file mode 100644 index 0000000..563ed4f --- /dev/null +++ b/vim/bundle/syntastic/syntax_checkers/ruby/mri.vim @@ -0,0 +1,82 @@ +"============================================================================ +"File: mri.vim +"Description: Syntax checking plugin for syntastic.vim +"Maintainer: Martin Grenfell <martin.grenfell at gmail dot com> +"License: This program is free software. It comes without any warranty, +" to the extent permitted by applicable law. You can redistribute +" it and/or modify it under the terms of the Do What The Fuck You +" Want To Public License, Version 2, as published by Sam Hocevar. +" See http://sam.zoy.org/wtfpl/COPYING for more details. +" +"============================================================================ + +if exists('g:loaded_syntastic_ruby_mri_checker') + finish +endif +let g:loaded_syntastic_ruby_mri_checker = 1 + +let s:save_cpo = &cpo +set cpo&vim + +function! SyntaxCheckers_ruby_mri_IsAvailable() dict + if !exists('g:syntastic_ruby_mri_exec') && exists('g:syntastic_ruby_exec') + let g:syntastic_ruby_mri_exec = g:syntastic_ruby_exec + call self.log('g:syntastic_ruby_exec =', g:syntastic_ruby_exec) + endif + return executable(self.getExec()) +endfunction + +function! SyntaxCheckers_ruby_mri_GetHighlightRegex(i) + if stridx(a:i['text'], 'assigned but unused variable') >= 0 + let term = split(a:i['text'], ' - ')[1] + return '\V\<' . escape(term, '\') . '\>' + endif + + return '' +endfunction + +function! SyntaxCheckers_ruby_mri_GetLocList() dict + let makeprg = self.makeprgBuild({ + \ 'args': '-w -T1', + \ 'args_after': '-c' }) + + "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%\m%.%#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%.%#' + + let env = syntastic#util#isRunningWindows() ? {} : { 'RUBYOPT': '' } + + return SyntasticMake({ + \ 'makeprg': makeprg, + \ 'errorformat': errorformat, + \ 'env': env }) +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'ruby', + \ 'name': 'mri', + \ 'exec': 'ruby'}) + +let &cpo = s:save_cpo +unlet s:save_cpo + +" vim: set sw=4 sts=4 et fdm=marker: diff --git a/vim/bundle/syntastic/syntax_checkers/ruby/reek.vim b/vim/bundle/syntastic/syntax_checkers/ruby/reek.vim new file mode 100644 index 0000000..d9a564a --- /dev/null +++ b/vim/bundle/syntastic/syntax_checkers/ruby/reek.vim @@ -0,0 +1,56 @@ +"============================================================================ +"File: reek.vim +"Description: Syntax checking plugin for syntastic.vim +"Maintainer: Mindaugas Mozūras +"License: This program is free software. It comes without any warranty, +" to the extent permitted by applicable law. You can redistribute +" it and/or modify it under the terms of the Do What 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_reek_checker') + finish +endif +let g:loaded_syntastic_ruby_reek_checker = 1 + +let s:save_cpo = &cpo +set cpo&vim + +function! SyntaxCheckers_ruby_reek_IsAvailable() dict + if !executable(self.getExec()) + return 0 + endif + return syntastic#util#versionIsAtLeast(self.getVersion(), [1, 3, 0]) +endfunction + +function! SyntaxCheckers_ruby_reek_GetLocList() dict + let makeprg = self.makeprgBuild({ 'args_before': '--no-color --line-number --single-line' }) + + let errorformat = + \ '%E%.%#: Racc::ParseError: %f:%l :: %m,' . + \ '%W%f:%l: %m' + + let loclist = SyntasticMake({ + \ 'makeprg': makeprg, + \ 'errorformat': errorformat, + \ 'returns': [0, 2] }) + + for e in loclist + if e['type'] ==? 'W' + let e['subtype'] = 'Style' + endif + endfor + + return loclist +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'ruby', + \ 'name': 'reek'}) + +let &cpo = s:save_cpo +unlet s:save_cpo + +" vim: set sw=4 sts=4 et fdm=marker: diff --git a/vim/bundle/syntastic/syntax_checkers/ruby/rubocop.vim b/vim/bundle/syntastic/syntax_checkers/ruby/rubocop.vim new file mode 100644 index 0000000..56f54bf --- /dev/null +++ b/vim/bundle/syntastic/syntax_checkers/ruby/rubocop.vim @@ -0,0 +1,57 @@ +"============================================================================ +"File: rubocop.vim +"Description: Syntax checking plugin for syntastic.vim +"Maintainer: Recai Oktaş <roktas@bil.omu.edu.tr> +"License: This program is free software. It comes without any warranty, +" to the extent permitted by applicable law. You can redistribute +" it and/or modify it under the terms of the Do What The Fuck You +" Want To Public License, Version 2, as published by Sam Hocevar. +" See http://sam.zoy.org/wtfpl/COPYING for more details. +" +"============================================================================ + +if exists('g:loaded_syntastic_ruby_rubocop_checker') + finish +endif +let g:loaded_syntastic_ruby_rubocop_checker = 1 + +let s:save_cpo = &cpo +set cpo&vim + +function! SyntaxCheckers_ruby_rubocop_IsAvailable() dict + if !executable(self.getExec()) + return 0 + endif + return syntastic#util#versionIsAtLeast(self.getVersion(), [0, 12, 0]) +endfunction + +function! SyntaxCheckers_ruby_rubocop_GetLocList() dict + let makeprg = self.makeprgBuild({ 'args_after': '--format emacs' }) + + 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 e in loclist + if e['type'] ==# 'F' + let e['type'] = 'E' + elseif e['type'] !=# 'W' && e['type'] !=# 'E' + let e['type'] = 'W' + endif + endfor + + return loclist +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'ruby', + \ 'name': 'rubocop'}) + +let &cpo = s:save_cpo +unlet s:save_cpo + +" vim: set sw=4 sts=4 et fdm=marker: diff --git a/vim/bundle/syntastic/syntax_checkers/ruby/rubylint.vim b/vim/bundle/syntastic/syntax_checkers/ruby/rubylint.vim new file mode 100644 index 0000000..2e74f87 --- /dev/null +++ b/vim/bundle/syntastic/syntax_checkers/ruby/rubylint.vim @@ -0,0 +1,45 @@ +"============================================================================ +"File: rubylint.vim +"Description: Checks Ruby source code using ruby-lint +"Maintainer: Yorick Peterse <yorickpeterse@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_ruby_rubylint_checker') + finish +endif + +let g:loaded_syntastic_ruby_rubylint_checker = 1 + +let s:save_cpo = &cpo +set cpo&vim + +function! SyntaxCheckers_ruby_rubylint_GetLocList() dict + if !exists('s:rubylint_new') + let s:rubylint_new = syntastic#util#versionIsAtLeast(self.getVersion(), [2]) + endif + let makeprg = self.makeprgBuild({ + \ 'args': (s:rubylint_new ? '' : 'analyze '), + \ 'args_after': '--presenter=syntastic' }) + + let errorformat = '%f:%t:%l:%c: %m' + + return SyntasticMake({ + \ 'makeprg': makeprg, + \ 'errorformat': errorformat }) +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'ruby', + \ 'name': 'rubylint', + \ 'exec': 'ruby-lint'}) + +let &cpo = s:save_cpo +unlet s:save_cpo + +" vim: set sw=4 sts=4 et fdm=marker: diff --git a/vim/bundle/syntastic/syntax_checkers/sass/sass.vim b/vim/bundle/syntastic/syntax_checkers/sass/sass.vim new file mode 100644 index 0000000..5f6194f --- /dev/null +++ b/vim/bundle/syntastic/syntax_checkers/sass/sass.vim @@ -0,0 +1,84 @@ +"============================================================================ +"File: sass.vim +"Description: Syntax checking plugin for syntastic.vim +"Maintainer: Martin Grenfell <martin.grenfell at gmail dot com> +"License: This program is free software. It comes without any warranty, +" to the extent permitted by applicable law. You can redistribute +" it and/or modify it under the terms of the Do What The Fuck You +" Want To Public License, Version 2, as published by Sam Hocevar. +" See http://sam.zoy.org/wtfpl/COPYING for more details. +" +"============================================================================ + +if exists('g:loaded_syntastic_sass_sass_checker') + finish +endif +let g:loaded_syntastic_sass_sass_checker = 1 + +"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 = syntastic#util#tmpdir() +lockvar s:sass_cache_location + +augroup syntastic + autocmd VimLeave * call syntastic#util#rmrf(s:sass_cache_location) +augroup END + +"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 + +let s:save_cpo = &cpo +set cpo&vim + +function! SyntaxCheckers_sass_sass_GetLocList() dict + if !g:syntastic_sass_check_partials && expand('%:t', 1)[0] ==# '_' + return [] + endif + + let makeprg = self.makeprgBuild({ + \ 'args_before': '--cache-location ' . s:sass_cache_location . ' ' . s:imports . ' --check' }) + + let errorformat = + \ '%E%\m%\%%(Syntax %\)%\?%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'}) + +let &cpo = s:save_cpo +unlet s:save_cpo + +" vim: set sw=4 sts=4 et fdm=marker: diff --git a/vim/bundle/syntastic/syntax_checkers/sass/sass_lint.vim b/vim/bundle/syntastic/syntax_checkers/sass/sass_lint.vim new file mode 100644 index 0000000..e87da29 --- /dev/null +++ b/vim/bundle/syntastic/syntax_checkers/sass/sass_lint.vim @@ -0,0 +1,51 @@ +"============================================================================ +"File: sass_lint.vim +"Description: Syntax checking plugin for syntastic +"Maintainer: LCD 47 <lcd047 at gmail dot com> +"License: This program is free software. It comes without any warranty, +" to the extent permitted by applicable law. You can redistribute +" it and/or modify it under the terms of the Do What The Fuck You +" Want To Public License, Version 2, as published by Sam Hocevar. +" See http://sam.zoy.org/wtfpl/COPYING for more details. +" +"============================================================================ + +if exists('g:loaded_syntastic_sass_sass_lint_checker') + finish +endif +let g:loaded_syntastic_sass_sass_lint_checker = 1 + +let s:save_cpo = &cpo +set cpo&vim + +function! SyntaxCheckers_sass_sass_lint_IsAvailable() dict + if !executable(self.getExec()) + return 0 + endif + return syntastic#util#versionIsAtLeast(self.getVersion(), [1, 5]) +endfunction + +function! SyntaxCheckers_sass_sass_lint_GetLocList() dict + let makeprg = self.makeprgBuild({ + \ 'args': '-v', + \ 'args_after': '-q -f compact' }) + + let errorformat = + \ '%f: line %l\, col %c\, %trror - %m,' . + \ '%f: line %l\, col %c\, %tarning - %m' + + return SyntasticMake({ + \ 'makeprg': makeprg, + \ 'errorformat': errorformat, + \ 'returns': [0, 1] }) +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'sass', + \ 'name': 'sass_lint', + \ 'exec': 'sass-lint' }) + +let &cpo = s:save_cpo +unlet s:save_cpo + +" vim: set sw=4 sts=4 et fdm=marker: diff --git a/vim/bundle/syntastic/syntax_checkers/sass/sassc.vim b/vim/bundle/syntastic/syntax_checkers/sass/sassc.vim new file mode 100644 index 0000000..699e04e --- /dev/null +++ b/vim/bundle/syntastic/syntax_checkers/sass/sassc.vim @@ -0,0 +1,38 @@ +"============================================================================ +"File: sassc.vim +"Description: Syntax checking plugin for syntastic +"Maintainer: LCD 47 <lcd047 at gmail dot com> +"License: This program is free software. It comes without any warranty, +" to the extent permitted by applicable law. You can redistribute +" it and/or modify it under the terms of the Do What The Fuck You +" Want To Public License, Version 2, as published by Sam Hocevar. +" See http://sam.zoy.org/wtfpl/COPYING for more details. +" +"============================================================================ + +if exists('g:loaded_syntastic_sass_sassc_checker') + finish +endif +let g:loaded_syntastic_sass_sassc_checker = 1 + +let s:save_cpo = &cpo +set cpo&vim + +function! SyntaxCheckers_sass_sassc_GetLocList() dict + let makeprg = self.makeprgBuild({ 'fname_after': syntastic#util#DevNull() }) + + let errorformat = '%f:%l: %trror: %m' + + return SyntasticMake({ + \ 'makeprg': makeprg, + \ 'errorformat': errorformat }) +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'sass', + \ 'name': 'sassc'}) + +let &cpo = s:save_cpo +unlet s:save_cpo + +" vim: set sw=4 sts=4 et fdm=marker: diff --git a/vim/bundle/syntastic/syntax_checkers/scala/fsc.vim b/vim/bundle/syntastic/syntax_checkers/scala/fsc.vim new file mode 100644 index 0000000..25d6a4d --- /dev/null +++ b/vim/bundle/syntastic/syntax_checkers/scala/fsc.vim @@ -0,0 +1,48 @@ +"============================================================================ +"File: fsc.vim +"Description: Syntax checking plugin for syntastic.vim +"Maintainer: Gregor Uhlenheuer <kongo2002 at gmail dot com> +"License: This program is free software. It comes without any warranty, +" to the extent permitted by applicable law. You can redistribute +" it and/or modify it under the terms of the Do What The Fuck You +" Want To Public License, Version 2, as published by Sam Hocevar. +" See http://sam.zoy.org/wtfpl/COPYING for more details. +" +"============================================================================ + +if exists('g:loaded_syntastic_scala_fsc_checker') + finish +endif +let g:loaded_syntastic_scala_fsc_checker = 1 + +let s:save_cpo = &cpo +set cpo&vim + +function! SyntaxCheckers_scala_fsc_GetLocList() dict + call syntastic#log#deprecationWarn('scala_options', 'scala_fsc_args') + + " fsc has some serious problems with the + " working directory changing after being started + " that's why we better pass an absolute path + let makeprg = self.makeprgBuild({ + \ 'args_after': '-Ystop-after:parser', + \ 'fname': syntastic#util#shexpand('%:p') }) + + let errorformat = + \ '%E%f:%l: %trror: %m,' . + \ '%Z%p^,' . + \ '%-G%.%#' + + return SyntasticMake({ + \ 'makeprg': makeprg, + \ 'errorformat': errorformat }) +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'scala', + \ 'name': 'fsc'}) + +let &cpo = s:save_cpo +unlet s:save_cpo + +" vim: set sw=4 sts=4 et fdm=marker: diff --git a/vim/bundle/syntastic/syntax_checkers/scala/scalac.vim b/vim/bundle/syntastic/syntax_checkers/scala/scalac.vim new file mode 100644 index 0000000..854876b --- /dev/null +++ b/vim/bundle/syntastic/syntax_checkers/scala/scalac.vim @@ -0,0 +1,43 @@ +"============================================================================ +"File: scala.vim +"Description: Syntax checking plugin for syntastic.vim +"Maintainer: Rickey Visinski <rickeyvisinski at gmail dot com> +"License: This program is free software. It comes without any warranty, +" to the extent permitted by applicable law. You can redistribute +" it and/or modify it under the terms of the Do What The Fuck You +" Want To Public License, Version 2, as published by Sam Hocevar. +" See http://sam.zoy.org/wtfpl/COPYING for more details. +" +"============================================================================ + +if exists('g:loaded_syntastic_scala_scalac_checker') + finish +endif +let g:loaded_syntastic_scala_scalac_checker = 1 + +let s:save_cpo = &cpo +set cpo&vim + +function! SyntaxCheckers_scala_scalac_GetLocList() dict + call syntastic#log#deprecationWarn('scala_options', 'scala_scalac_args') + + let makeprg = self.makeprgBuild({ 'args_after': '-Ystop-after:parser' }) + + let errorformat = + \ '%E%f:%l: %trror: %m,' . + \ '%Z%p^,' . + \ '%-G%.%#' + + return SyntasticMake({ + \ 'makeprg': makeprg, + \ 'errorformat': errorformat }) +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'scala', + \ 'name': 'scalac'}) + +let &cpo = s:save_cpo +unlet s:save_cpo + +" vim: set sw=4 sts=4 et fdm=marker: diff --git a/vim/bundle/syntastic/syntax_checkers/scala/scalastyle.vim b/vim/bundle/syntastic/syntax_checkers/scala/scalastyle.vim new file mode 100644 index 0000000..60d2163 --- /dev/null +++ b/vim/bundle/syntastic/syntax_checkers/scala/scalastyle.vim @@ -0,0 +1,77 @@ +"============================================================================ +"File: scalastyle.vim +"Description: Syntax checking plugin for syntastic.vim +"Maintainer: LCD 47 <lcd047 at gmail dot com> +"License: This program is free software. It comes without any warranty, +" to the extent permitted by applicable law. You can redistribute +" it and/or modify it under the terms of the Do What The Fuck You +" Want To Public License, Version 2, as published by Sam Hocevar. +" See http://sam.zoy.org/wtfpl/COPYING for more details. +" +"============================================================================ + +if exists('g:loaded_syntastic_scala_scalastyle_checker') + finish +endif +let g:loaded_syntastic_scala_scalastyle_checker = 1 + +if !exists('g:syntastic_scala_scalastyle_jar') + let g:syntastic_scala_scalastyle_jar = 'scalastyle-batch_2.10.jar' +endif + +if !exists('g:syntastic_scala_scalastyle_config_file') + let g:syntastic_scala_scalastyle_config_file = 'scalastyle_config.xml' +endif + +let s:save_cpo = &cpo +set cpo&vim + +function! SyntaxCheckers_scala_scalastyle_IsAvailable() dict + if !executable(self.getExec()) + return 0 + endif + + let jar = expand(g:syntastic_scala_scalastyle_jar, 1) + let conf_file = expand(g:syntastic_scala_scalastyle_config_file, 1) + call self.log('filereadable(' . string(jar) . ') = ' . filereadable(jar) . ', ' . + \ 'filereadable(' . string(conf_file) . ') = ' . filereadable(conf_file)) + + return filereadable(jar) && filereadable(conf_file) +endfunction + +function! SyntaxCheckers_scala_scalastyle_GetLocList() dict + + let makeprg = self.makeprgBuild({ + \ 'exe_after': ['-jar', expand(g:syntastic_scala_scalastyle_jar, 1)], + \ 'args_before': ['-c', expand(g:syntastic_scala_scalastyle_config_file, 1)] }) + + let errorformat = + \ '%trror file=%f message=%m line=%l column=%c,' . + \ '%trror file=%f message=%m line=%l,' . + \ '%tarning file=%f message=%m line=%l column=%c,' . + \ '%tarning file=%f message=%m line=%l' + + let loclist = SyntasticMake({ + \ 'makeprg': makeprg, + \ 'errorformat': errorformat, + \ 'subtype': 'Style', + \ 'returns': [0, 1] }) + + for e in loclist + if has_key(e, 'col') + let e['col'] += 1 + endif + endfor + + return loclist +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'scala', + \ 'name': 'scalastyle', + \ 'exec': 'java'}) + +let &cpo = s:save_cpo +unlet s:save_cpo + +" vim: set sw=4 sts=4 et fdm=marker: diff --git a/vim/bundle/syntastic/syntax_checkers/scss/mixedindentlint.vim b/vim/bundle/syntastic/syntax_checkers/scss/mixedindentlint.vim new file mode 100644 index 0000000..04a1fec --- /dev/null +++ b/vim/bundle/syntastic/syntax_checkers/scss/mixedindentlint.vim @@ -0,0 +1,22 @@ +"============================================================================ +"File: mixedindentlint.vim +"Description: Mixed indentation linter for vim +"Maintainer: Payton Swick <payton@foolord.com> +"License: This program is free software. It comes without any warranty, +" to the extent permitted by applicable law. You can redistribute +" it and/or modify it under the terms of the Do What The Fuck You +" Want To Public License, Version 2, as published by Sam Hocevar. +" See http://sam.zoy.org/wtfpl/COPYING for more details. +"============================================================================ + +if exists('g:loaded_syntastic_scss_mixedindentlint_checker') + finish +endif +let g:loaded_syntastic_scss_mixedindentlint_checker = 1 + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'scss', + \ 'name': 'mixedindentlint', + \ 'redirect': 'javascript/mixedindentlint'}) + +" vim: set et sts=4 sw=4: diff --git a/vim/bundle/syntastic/syntax_checkers/scss/sass.vim b/vim/bundle/syntastic/syntax_checkers/scss/sass.vim new file mode 100644 index 0000000..3df8c80 --- /dev/null +++ b/vim/bundle/syntastic/syntax_checkers/scss/sass.vim @@ -0,0 +1,23 @@ +"============================================================================ +"File: scss.vim +"Description: scss syntax checking plugin for syntastic +"Maintainer: Martin Grenfell <martin.grenfell at gmail dot com> +"License: This program is free software. It comes without any warranty, +" to the extent permitted by applicable law. You can redistribute +" it and/or modify it under the terms of the Do What The Fuck You +" Want To Public License, Version 2, as published by Sam Hocevar. +" See http://sam.zoy.org/wtfpl/COPYING for more details. +" +"============================================================================ + +if exists('g:loaded_syntastic_scss_sass_checker') + finish +endif +let g:loaded_syntastic_scss_sass_checker = 1 + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'scss', + \ 'name': 'sass', + \ 'redirect': 'sass/sass'}) + +" vim: set sw=4 sts=4 et fdm=marker: diff --git a/vim/bundle/syntastic/syntax_checkers/scss/sass_lint.vim b/vim/bundle/syntastic/syntax_checkers/scss/sass_lint.vim new file mode 100644 index 0000000..c50dac4 --- /dev/null +++ b/vim/bundle/syntastic/syntax_checkers/scss/sass_lint.vim @@ -0,0 +1,23 @@ +"============================================================================ +"File: sass_lint.vim +"Description: Syntax checking plugin for syntastic +"Maintainer: LCD 47 <lcd047 at gmail dot com> +"License: This program is free software. It comes without any warranty, +" to the extent permitted by applicable law. You can redistribute +" it and/or modify it under the terms of the Do What The Fuck You +" Want To Public License, Version 2, as published by Sam Hocevar. +" See http://sam.zoy.org/wtfpl/COPYING for more details. +" +"============================================================================ + +if exists('g:loaded_syntastic_scss_sass_lint_checker') + finish +endif +let g:loaded_syntastic_scss_sass_lint_checker = 1 + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'scss', + \ 'name': 'sass_lint', + \ 'redirect': 'sass/sass_lint'}) + +" vim: set sw=4 sts=4 et fdm=marker: diff --git a/vim/bundle/syntastic/syntax_checkers/scss/sassc.vim b/vim/bundle/syntastic/syntax_checkers/scss/sassc.vim new file mode 100644 index 0000000..f1b2372 --- /dev/null +++ b/vim/bundle/syntastic/syntax_checkers/scss/sassc.vim @@ -0,0 +1,23 @@ +"============================================================================ +"File: sassc.vim +"Description: Syntax checking plugin for syntastic +"Maintainer: LCD 47 <lcd047 at gmail dot com> +"License: This program is free software. It comes without any warranty, +" to the extent permitted by applicable law. You can redistribute +" it and/or modify it under the terms of the Do What The Fuck You +" Want To Public License, Version 2, as published by Sam Hocevar. +" See http://sam.zoy.org/wtfpl/COPYING for more details. +" +"============================================================================ + +if exists('g:loaded_syntastic_scss_sassc_checker') + finish +endif +let g:loaded_syntastic_scss_sassc_checker = 1 + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'scss', + \ 'name': 'sassc', + \ 'redirect': 'sass/sassc'}) + +" vim: set sw=4 sts=4 et fdm=marker: diff --git a/vim/bundle/syntastic/syntax_checkers/scss/scss_lint.vim b/vim/bundle/syntastic/syntax_checkers/scss/scss_lint.vim new file mode 100644 index 0000000..c0f921a --- /dev/null +++ b/vim/bundle/syntastic/syntax_checkers/scss/scss_lint.vim @@ -0,0 +1,64 @@ +"============================================================================ +"File: scss_lint.vim +"Description: SCSS style and syntax checker plugin for Syntastic +"Maintainer: Shane da Silva <shane@dasilva.io> +"License: This program is free software. It comes without any warranty, +" to the extent permitted by applicable law. You can redistribute +" it and/or modify it under the terms of the Do What The Fuck You +" Want To Public License, Version 2, as published by Sam Hocevar. +" See http://sam.zoy.org/wtfpl/COPYING for more details. +"============================================================================ + +if exists('g:loaded_syntastic_scss_scss_lint_checker') + finish +endif +let g:loaded_syntastic_scss_scss_lint_checker = 1 + +let s:save_cpo = &cpo +set cpo&vim + +function! SyntaxCheckers_scss_scss_lint_IsAvailable() dict + if !executable(self.getExec()) + return 0 + endif + return syntastic#util#versionIsAtLeast(self.getVersion(), [0, 29]) +endfunction + +function! SyntaxCheckers_scss_scss_lint_GetLocList() dict + let makeprg = self.makeprgBuild({ 'args_after': '-f JSON' }) + + let errorformat = '%f:%t:%l:%c:%n:%m' + + let loclist = SyntasticMake({ + \ 'makeprg': makeprg, + \ 'errorformat': errorformat, + \ 'preprocess': 'scss_lint', + \ 'postprocess': ['guards'], + \ 'returns': [0, 1, 2, 65, 66] }) + + let cutoff = strlen('Syntax Error: ') + for e in loclist + if e['nr'] > 1 + let e['hl'] = '\%>' . (e['col'] - 1) . 'c\%<' . (e['col'] + e['nr']) . 'c' + endif + let e['nr'] = 0 + + if e['text'][: cutoff-1] ==# 'Syntax Error: ' + let e['text'] = e['text'][cutoff :] + else + let e['subtype'] = 'Style' + endif + endfor + + return loclist +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'scss', + \ 'name': 'scss_lint', + \ 'exec': 'scss-lint' }) + +let &cpo = s:save_cpo +unlet s:save_cpo + +" vim: set sw=4 sts=4 et fdm=marker: diff --git a/vim/bundle/syntastic/syntax_checkers/scss/stylelint.vim b/vim/bundle/syntastic/syntax_checkers/scss/stylelint.vim new file mode 100644 index 0000000..1962916 --- /dev/null +++ b/vim/bundle/syntastic/syntax_checkers/scss/stylelint.vim @@ -0,0 +1,23 @@ +"============================================================================ +"File: stylelint.vim +"Description: Syntax checking plugin for syntastic.vim +"Maintainer: LCD 47 <lcd047 at gmail dot com> +"License: This program is free software. It comes without any warranty, +" to the extent permitted by applicable law. You can redistribute +" it and/or modify it under the terms of the Do What The Fuck You +" Want To Public License, Version 2, as published by Sam Hocevar. +" See http://sam.zoy.org/wtfpl/COPYING for more details. +" +"============================================================================ + +if exists('g:loaded_syntastic_scss_stylelint_checker') + finish +endif +let g:loaded_syntastic_scss_stylelint_checker = 1 + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'scss', + \ 'name': 'stylelint', + \ 'redirect': 'css/stylelint'}) + +" vim: set sw=4 sts=4 et fdm=marker: diff --git a/vim/bundle/syntastic/syntax_checkers/sh/bashate.vim b/vim/bundle/syntastic/syntax_checkers/sh/bashate.vim new file mode 100644 index 0000000..c7888ad --- /dev/null +++ b/vim/bundle/syntastic/syntax_checkers/sh/bashate.vim @@ -0,0 +1,48 @@ +"============================================================================ +"File: bashate.vim +"Description: Bash script style 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_sh_bashate_checker') + finish +endif +let g:loaded_syntastic_sh_bashate_checker = 1 + +let s:save_cpo = &cpo +set cpo&vim + +function! SyntaxCheckers_sh_bashate_GetLocList() dict + let makeprg = self.makeprgBuild({}) + + let errorformat = + \ '%EE%n: %m,' . + \ '%Z - %f%\s%\+: L%l,' . + \ '%-G%.%#' + + let loclist = SyntasticMake({ + \ 'makeprg': makeprg, + \ 'errorformat': errorformat, + \ 'subtype': 'Style', + \ 'returns': [0, 1] }) + + for e in loclist + let e['text'] = substitute(e['text'], "\\m: '.*", '', '') + endfor + + return loclist +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'sh', + \ 'name': 'bashate' }) + +let &cpo = s:save_cpo +unlet s:save_cpo + +" vim: set sw=4 sts=4 et fdm=marker: diff --git a/vim/bundle/syntastic/syntax_checkers/sh/checkbashisms.vim b/vim/bundle/syntastic/syntax_checkers/sh/checkbashisms.vim new file mode 100644 index 0000000..2ed0717 --- /dev/null +++ b/vim/bundle/syntastic/syntax_checkers/sh/checkbashisms.vim @@ -0,0 +1,42 @@ +"============================================================================ +"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 + +let s:save_cpo = &cpo +set cpo&vim + +function! SyntaxCheckers_sh_checkbashisms_GetLocList() dict + let makeprg = self.makeprgBuild({ 'args': '-fx' }) + + 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' }) + +let &cpo = s:save_cpo +unlet s:save_cpo + +" vim: set sw=4 sts=4 et fdm=marker: diff --git a/vim/bundle/syntastic/syntax_checkers/sh/sh.vim b/vim/bundle/syntastic/syntax_checkers/sh/sh.vim new file mode 100644 index 0000000..395b81b --- /dev/null +++ b/vim/bundle/syntastic/syntax_checkers/sh/sh.vim @@ -0,0 +1,93 @@ +"============================================================================ +"File: sh.vim +"Description: Syntax checking plugin for syntastic.vim +"Maintainer: Gregor Uhlenheuer <kongo2002 at gmail dot com> +"License: This program is free software. It comes without any warranty, +" to the extent permitted by applicable law. You can redistribute +" it and/or modify it under the terms of the Do What The Fuck You +" Want To Public License, Version 2, as published by Sam Hocevar. +" See http://sam.zoy.org/wtfpl/COPYING for more details. +" +"============================================================================ + +if exists('g:loaded_syntastic_sh_sh_checker') + finish +endif +let g:loaded_syntastic_sh_sh_checker = 1 + +let s:save_cpo = &cpo +set cpo&vim + +function! SyntaxCheckers_sh_sh_IsAvailable() dict " {{{1 + call self.log('shell =', s:GetShell()) + return s:IsShellValid() +endfunction " }}}1 + +function! SyntaxCheckers_sh_sh_GetLocList() dict " {{{1 + if s:GetShell() ==# 'zsh' + return s:ForwardToZshChecker() + endif + + if !s:IsShellValid() + return [] + endif + + let makeprg = self.makeprgBuild({ + \ 'exe': s:GetShell(), + \ 'args_after': '-n' }) + + let errorformat = '%f: line %l: %m' + + return SyntasticMake({ + \ 'makeprg': makeprg, + \ 'errorformat': errorformat }) +endfunction " }}}1 + +" Utilities {{{1 + +function! s:GetShell() " {{{2 + if !exists('b:shell') || b:shell ==# '' + let b:shell = '' + let shebang = syntastic#util#parseShebang()['exe'] + if shebang !=# '' + if shebang[-strlen('bash'):-1] ==# 'bash' + let b:shell = 'bash' + elseif shebang[-strlen('zsh'):-1] ==# 'zsh' + let b:shell = 'zsh' + elseif shebang[-strlen('sh'):-1] ==# 'sh' + 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($SHELL, ':t') + endif + endif + return b:shell +endfunction " }}}2 + +function! s:IsShellValid() " {{{2 + let shell = s:GetShell() + return shell !=# '' && executable(shell) +endfunction " }}}2 + +function! s:ForwardToZshChecker() " {{{2 + let registry = g:SyntasticRegistry.Instance() + let zsh_checkers = registry.getCheckersAvailable('zsh', ['zsh']) + if !empty(zsh_checkers) + return zsh_checkers[0].getLocListRaw() + else + return [] + endif +endfunction " }}}2 + +" }}}1 + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'sh', + \ 'name': 'sh' }) + +let &cpo = s:save_cpo +unlet s:save_cpo + +" vim: set sw=4 sts=4 et fdm=marker: diff --git a/vim/bundle/syntastic/syntax_checkers/sh/shellcheck.vim b/vim/bundle/syntastic/syntax_checkers/sh/shellcheck.vim new file mode 100644 index 0000000..5189e19 --- /dev/null +++ b/vim/bundle/syntastic/syntax_checkers/sh/shellcheck.vim @@ -0,0 +1,66 @@ +"============================================================================ +"File: shellcheck.vim +"Description: Shell script syntax/style checking plugin for syntastic.vim +"============================================================================ + +if exists('g:loaded_syntastic_sh_shellcheck_checker') + finish +endif +let g:loaded_syntastic_sh_shellcheck_checker = 1 + +let s:save_cpo = &cpo +set cpo&vim + +function! SyntaxCheckers_sh_shellcheck_GetLocList() dict " {{{1 + let makeprg = self.makeprgBuild({ + \ 'args': s:GetShell(), + \ 'args_after': '-f gcc' }) + + let errorformat = + \ '%f:%l:%c: %trror: %m,' . + \ '%f:%l:%c: %tarning: %m,' . + \ '%f:%l:%c: %tote: %m' + + let loclist = SyntasticMake({ + \ 'makeprg': makeprg, + \ 'errorformat': errorformat, + \ 'returns': [0, 1] }) + + for e in loclist + if e['type'] ==? 'n' + let e['type'] = 'w' + let e['subtype'] = 'Style' + endif + endfor + + return loclist +endfunction " }}}1 + +" Utilities {{{1 + +function! s:GetShell() " {{{2 + let sh = '' + + if syntastic#util#parseShebang()['exe'] ==# '' + if syntastic#util#rawVar('is_kornshell', 0) || syntastic#util#rawVar('is_posix', 0) + let sh = 'ksh' + elseif syntastic#util#rawVar('is_bash', 0) + let sh = 'bash' + elseif syntastic#util#rawVar('is_sh', 0) + let sh = 'sh' + endif + endif + + return sh !=# '' ? '-s ' . sh : '' +endfunction " }}}2 + +" }}}1 + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'sh', + \ 'name': 'shellcheck' }) + +let &cpo = s:save_cpo +unlet s:save_cpo + +" vim: set sw=4 sts=4 et fdm=marker: diff --git a/vim/bundle/syntastic/syntax_checkers/slim/slim_lint.vim b/vim/bundle/syntastic/syntax_checkers/slim/slim_lint.vim new file mode 100644 index 0000000..f387971 --- /dev/null +++ b/vim/bundle/syntastic/syntax_checkers/slim/slim_lint.vim @@ -0,0 +1,39 @@ +"============================================================================ +"File: slim_lint.vim +"Description: Slim style and syntax checker plugin for Syntastic +"Maintainer: Vasily Kolesnikov <re.vkolesnikov@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_slim_slim_lint_checker') + finish +endif +let g:loaded_syntastic_slim_slim_lint_checker = 1 + +let s:save_cpo = &cpo +set cpo&vim + +function! SyntaxCheckers_slim_slim_lint_GetLocList() dict + let makeprg = self.makeprgBuild({}) + + let errorformat = '%f:%l [%t] %m' + + return SyntasticMake({ + \ 'makeprg': makeprg, + \ 'errorformat': errorformat, + \ 'subtype': 'Style'}) +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'slim', + \ 'name': 'slim_lint', + \ 'exec': 'slim-lint' }) + +let &cpo = s:save_cpo +unlet s:save_cpo + +" vim: set sw=4 sts=4 et fdm=marker: diff --git a/vim/bundle/syntastic/syntax_checkers/slim/slimrb.vim b/vim/bundle/syntastic/syntax_checkers/slim/slimrb.vim new file mode 100644 index 0000000..80bac05 --- /dev/null +++ b/vim/bundle/syntastic/syntax_checkers/slim/slimrb.vim @@ -0,0 +1,55 @@ +"============================================================================ +"File: slim.vim +"Description: Syntax checking plugin for syntastic.vim +"Maintainer: Martin Grenfell <martin.grenfell at gmail dot com> +"License: This program is free software. It comes without any warranty, +" to the extent permitted by applicable law. You can redistribute +" it and/or modify it under the terms of the Do What The Fuck You +" Want To Public License, Version 2, as published by Sam Hocevar. +" See http://sam.zoy.org/wtfpl/COPYING for more details. +" +"============================================================================ + +if exists('g:loaded_syntastic_slim_slimrb_checker') + finish +endif +let g:loaded_syntastic_slim_slimrb_checker = 1 + +let s:save_cpo = &cpo +set cpo&vim + +function! SyntaxCheckers_slim_slimrb_GetLocList() dict + if !exists('s:slimrb_new') + let ver = self.getVersion(self.getExecEscaped() . ' --version 2>'. syntastic#util#DevNull()) + let s:slimrb_new = syntastic#util#versionIsAtLeast(ver, [1, 3, 1]) + endif + + let makeprg = self.makeprgBuild({ 'args_after': '-c' }) + + if s:slimrb_new + 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'}) + +let &cpo = s:save_cpo +unlet s:save_cpo + +" vim: set sw=4 sts=4 et fdm=marker: diff --git a/vim/bundle/syntastic/syntax_checkers/sml/smlnj.vim b/vim/bundle/syntastic/syntax_checkers/sml/smlnj.vim new file mode 100644 index 0000000..8b29db4 --- /dev/null +++ b/vim/bundle/syntastic/syntax_checkers/sml/smlnj.vim @@ -0,0 +1,47 @@ +"============================================================================ +"File: smlnj.vim +"Description: Syntax checking plugin for syntastic.vim +"Maintainer: LCD 47 <lcd047 at gmail dot com> +"License: This program is free software. It comes without any warranty, +" to the extent permitted by applicable law. You can redistribute +" it and/or modify it under the terms of the Do What The Fuck You +" Want To Public License, Version 2, as published by Sam Hocevar. +" See http://sam.zoy.org/wtfpl/COPYING for more details. +" +"============================================================================ + +if exists('g:loaded_syntastic_sml_smlnj_checker') + finish +endif +let g:loaded_syntastic_sml_smlnj_checker = 1 + +let s:save_cpo = &cpo +set cpo&vim + +function! SyntaxCheckers_sml_smlnj_GetLocList() dict + let makeprg = self.makeprgBuild({}) + + let errorformat = + \ '%E%f:%l%\%.%c %trror: %m,' . + \ '%E%f:%l%\%.%c-%\d%\+%\%.%\d%\+ %trror: %m,' . + \ '%W%f:%l%\%.%c %tarning: %m,' . + \ '%W%f:%l%\%.%c-%\d%\+%\%.%\d%\+ %tarning: %m,' . + \ '%C%\s%\+%m,' . + \ '%-G%.%#' + + return SyntasticMake({ + \ 'makeprg': makeprg, + \ 'errorformat': errorformat, + \ 'postprocess': ['compressWhitespace'], + \ 'returns': [0, 1] }) +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'sml', + \ 'name': 'smlnj', + \ 'exec': 'sml'}) + +let &cpo = s:save_cpo +unlet s:save_cpo + +" vim: set sw=4 sts=4 et fdm=marker: diff --git a/vim/bundle/syntastic/syntax_checkers/spec/rpmlint.vim b/vim/bundle/syntastic/syntax_checkers/spec/rpmlint.vim new file mode 100644 index 0000000..7e9431b --- /dev/null +++ b/vim/bundle/syntastic/syntax_checkers/spec/rpmlint.vim @@ -0,0 +1,43 @@ +"============================================================================ +"File: rpmlint.vim +"Description: Syntax checking plugin for syntastic.vim +"Maintainer: LCD 47 <lcd047 at gmail dot com> +"License: This program is free software. It comes without any warranty, +" to the extent permitted by applicable law. You can redistribute +" it and/or modify it under the terms of the Do What The Fuck You +" Want To Public License, Version 2, as published by Sam Hocevar. +" See http://sam.zoy.org/wtfpl/COPYING for more details. +" +"============================================================================ + +if exists('g:loaded_syntastic_spec_rpmlint_checker') + finish +endif +let g:loaded_syntastic_spec_rpmlint_checker = 1 + +let s:save_cpo = &cpo +set cpo&vim + +function! SyntaxCheckers_spec_rpmlint_GetLocList() dict + let makeprg = self.makeprgBuild({}) + + let errorformat = + \ '%E%f:%l: E: %m,' . + \ '%E%f: E: %m,' . + \ '%W%f:%l: W: %m,' . + \ '%W%f: W: %m,' . + \ '%-G%.%#' + + return SyntasticMake({ + \ 'makeprg': makeprg, + \ 'errorformat': errorformat }) +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'spec', + \ 'name': 'rpmlint'}) + +let &cpo = s:save_cpo +unlet s:save_cpo + +" vim: set sw=4 sts=4 et fdm=marker: diff --git a/vim/bundle/syntastic/syntax_checkers/sql/sqlint.vim b/vim/bundle/syntastic/syntax_checkers/sql/sqlint.vim new file mode 100644 index 0000000..1e1eea5 --- /dev/null +++ b/vim/bundle/syntastic/syntax_checkers/sql/sqlint.vim @@ -0,0 +1,50 @@ +"============================================================================ +"File: sqlint.vim +"Description: Syntax checking plugin for syntastic.vim +"Maintainer: Steve Purcell <steve@sanityinc.com> +"License: MIT +"============================================================================ + +if exists('g:loaded_syntastic_sql_sqlint_checker') + finish +endif +let g:loaded_syntastic_sql_sqlint_checker = 1 + +let s:save_cpo = &cpo +set cpo&vim + +function! SyntaxCheckers_sql_sqlint_GetHighlightRegex(i) + let term = matchstr(a:i['text'], '\m at or near "\zs[^"]\+\ze"') + return term !=# '' ? '\V\<' . escape(term, '\') . '\>' : '' +endfunction + +function! SyntaxCheckers_sql_sqlint_IsAvailable() dict + if !executable(self.getExec()) + return 0 + endif + return syntastic#util#versionIsAtLeast(self.getVersion(), [0, 0, 3]) +endfunction + +function! SyntaxCheckers_sql_sqlint_GetLocList() dict + let makeprg = self.makeprgBuild({}) + + let errorformat = + \ '%E%f:%l:%c:ERROR %m,' . + \ '%W%f:%l:%c:WARNING %m,' . + \ '%C %m' + + return SyntasticMake({ + \ 'makeprg': makeprg, + \ 'errorformat': errorformat, + \ 'subtype': 'Style', + \ 'returns': [0, 1] }) +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'sql', + \ 'name': 'sqlint'}) + +let &cpo = s:save_cpo +unlet s:save_cpo + +" vim: set sw=4 sts=4 et fdm=marker: diff --git a/vim/bundle/syntastic/syntax_checkers/stylus/stylint.vim b/vim/bundle/syntastic/syntax_checkers/stylus/stylint.vim new file mode 100644 index 0000000..f489910 --- /dev/null +++ b/vim/bundle/syntastic/syntax_checkers/stylus/stylint.vim @@ -0,0 +1,43 @@ +"============================================================================ +"File: stylint.vim +"Description: Syntax checking plugin for syntastic.vim +"Maintainer: LCD 47 <lcd047 at gmail dot com> +"License: This program is free software. It comes without any warranty, +" to the extent permitted by applicable law. You can redistribute +" it and/or modify it under the terms of the Do What The Fuck You +" Want To Public License, Version 2, as published by Sam Hocevar. +" See http://sam.zoy.org/wtfpl/COPYING for more details. +" +"============================================================================ + +if exists('g:loaded_syntastic_stylus_stylint_checker') + finish +endif +let g:loaded_syntastic_stylus_stylint_checker = 1 + +let s:save_cpo = &cpo +set cpo&vim + +function! SyntaxCheckers_stylus_stylint_GetLocList() dict + let makeprg = self.makeprgBuild({}) + + let errorformat = + \ '%WWarning: %m,' . + \ '%EError: %m,' . + \ '%CFile: %f,' . + \ '%CLine: %l:%.%#' + + return SyntasticMake({ + \ 'makeprg': makeprg, + \ 'errorformat': errorformat, + \ 'subtype': 'Style' }) +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'stylus', + \ 'name': 'stylint'}) + +let &cpo = s:save_cpo +unlet s:save_cpo + +" vim: set sw=4 sts=4 et fdm=marker: diff --git a/vim/bundle/syntastic/syntax_checkers/tcl/nagelfar.vim b/vim/bundle/syntastic/syntax_checkers/tcl/nagelfar.vim new file mode 100644 index 0000000..adbce63 --- /dev/null +++ b/vim/bundle/syntastic/syntax_checkers/tcl/nagelfar.vim @@ -0,0 +1,44 @@ +"============================================================================ +"File: nagelfar.vim +"Description: Syntax checking plugin for syntastic.vim +"Maintainer: James Pickard <james.pickard at gmail dot com> +"License: This program is free software. It comes without any warranty, +" to the extent permitted by applicable law. You can redistribute +" it and/or modify it under the terms of the Do What The Fuck You +" Want To Public License, Version 2, as published by Sam Hocevar. +" See http://sam.zoy.org/wtfpl/COPYING for more details. +" +"============================================================================ +" +"Notes: Requires nagelfar v1.1.12 or later with support for -H option. +" See nagelfar homepage http://nagelfar.berlios.de/. + +if exists('g:loaded_syntastic_tcl_nagelfar_checker') + finish +endif +let g:loaded_syntastic_tcl_nagelfar_checker = 1 + +let s:save_cpo = &cpo +set cpo&vim + +function! SyntaxCheckers_tcl_nagelfar_GetLocList() dict + let makeprg = self.makeprgBuild({ 'args_after': '-H' }) + + 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'}) + +let &cpo = s:save_cpo +unlet s:save_cpo + +" vim: set sw=4 sts=4 et fdm=marker: diff --git a/vim/bundle/syntastic/syntax_checkers/tex/chktex.vim b/vim/bundle/syntastic/syntax_checkers/tex/chktex.vim new file mode 100644 index 0000000..9b35902 --- /dev/null +++ b/vim/bundle/syntastic/syntax_checkers/tex/chktex.vim @@ -0,0 +1,52 @@ +"============================================================================ +"File: chktex.vim +"Description: Syntax checking plugin for syntastic.vim +"Maintainer: LCD 47 <lcd047 at gmail dot com> +"License: This program is free software. It comes without any warranty, +" to the extent permitted by applicable law. You can redistribute +" it and/or modify it under the terms of the Do What The Fuck You +" Want To Public License, Version 2, as published by Sam Hocevar. +" See http://sam.zoy.org/wtfpl/COPYING for more details. +" +"============================================================================ + +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 + +if !exists('g:syntastic_tex_chktex_sort') + let g:syntastic_tex_chktex_sort = 1 +endif + +let s:save_cpo = &cpo +set cpo&vim + +function! SyntaxCheckers_tex_chktex_GetLocList() dict + let makeprg = self.makeprgBuild({ 'args_after': '-q -v1' }) + + 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' }) +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'tex', + \ 'name': 'chktex'}) + +let &cpo = s:save_cpo +unlet s:save_cpo + +" vim: set sw=4 sts=4 et fdm=marker: diff --git a/vim/bundle/syntastic/syntax_checkers/tex/lacheck.vim b/vim/bundle/syntastic/syntax_checkers/tex/lacheck.vim new file mode 100644 index 0000000..f156520 --- /dev/null +++ b/vim/bundle/syntastic/syntax_checkers/tex/lacheck.vim @@ -0,0 +1,40 @@ +"============================================================================ +"File: tex.vim +"Description: Syntax checking plugin for syntastic.vim +"Maintainer: Martin Grenfell <martin.grenfell at gmail dot com> +"License: This program is free software. It comes without any warranty, +" to the extent permitted by applicable law. You can redistribute +" it and/or modify it under the terms of the Do What The Fuck You +" Want To Public License, Version 2, as published by Sam Hocevar. +" See http://sam.zoy.org/wtfpl/COPYING for more details. +" +"============================================================================ + +if exists('g:loaded_syntastic_tex_lacheck_checker') + finish +endif +let g:loaded_syntastic_tex_lacheck_checker = 1 + +let s:save_cpo = &cpo +set cpo&vim + +function! SyntaxCheckers_tex_lacheck_GetLocList() dict + let makeprg = self.makeprgBuild({}) + + let errorformat = + \ '%-G** %f:,' . + \ '%E"%f"\, line %l: %m' + + return SyntasticMake({ + \ 'makeprg': makeprg, + \ 'errorformat': errorformat }) +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'tex', + \ 'name': 'lacheck'}) + +let &cpo = s:save_cpo +unlet s:save_cpo + +" vim: set sw=4 sts=4 et fdm=marker: diff --git a/vim/bundle/syntastic/syntax_checkers/texinfo/makeinfo.vim b/vim/bundle/syntastic/syntax_checkers/texinfo/makeinfo.vim new file mode 100644 index 0000000..a66e787 --- /dev/null +++ b/vim/bundle/syntastic/syntax_checkers/texinfo/makeinfo.vim @@ -0,0 +1,47 @@ +"============================================================================ +"File: makeinfo.vim +"Description: Syntax checking plugin for syntastic.vim +"Maintainer: LCD 47 <lcd047 at gmail dot com> +"License: This program is free software. It comes without any warranty, +" to the extent permitted by applicable law. You can redistribute +" it and/or modify it under the terms of the Do What The Fuck You +" Want To Public License, Version 2, as published by Sam Hocevar. +" See http://sam.zoy.org/wtfpl/COPYING for more details. +" +"============================================================================ + +if exists('g:loaded_syntastic_texinfo_makeinfo_checker') + finish +endif +let g:loaded_syntastic_texinfo_makeinfo_checker = 1 + +let s:save_cpo = &cpo +set cpo&vim + +function! SyntaxCheckers_texinfo_makeinfo_GetHighlightRegex(item) + let term = matchstr(a:item['text'], "\\m`\\zs[^']\\+\\ze'") + return term !=# '' ? '\V' . escape(term, '\') : '' +endfunction + +function! SyntaxCheckers_texinfo_makeinfo_GetLocList() dict + let makeprg = self.makeprgBuild({ 'args_after': syntastic#c#NullOutput() }) + + let errorformat = + \ '%f:%l: %tarning: %m,' . + \ '%f:%l: %m,' . + \ '%-G%.%#' + + return SyntasticMake({ + \ 'makeprg': makeprg, + \ 'errorformat': errorformat, + \ 'type': 'e' }) +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'texinfo', + \ 'name': 'makeinfo'}) + +let &cpo = s:save_cpo +unlet s:save_cpo + +" vim: set sw=4 sts=4 et fdm=marker: diff --git a/vim/bundle/syntastic/syntax_checkers/text/atdtool.vim b/vim/bundle/syntastic/syntax_checkers/text/atdtool.vim new file mode 100644 index 0000000..e43d9dc --- /dev/null +++ b/vim/bundle/syntastic/syntax_checkers/text/atdtool.vim @@ -0,0 +1,61 @@ +"============================================================================ +"File: atdtool.vim +"Description: Syntax checking plugin for syntastic.vim +"Maintainer: LCD 47 <lcd047 at gmail dot com> +"License: This program is free software. It comes without any warranty, +" to the extent permitted by applicable law. You can redistribute +" it and/or modify it under the terms of the Do What The Fuck You +" Want To Public License, Version 2, as published by Sam Hocevar. +" See http://sam.zoy.org/wtfpl/COPYING for more details. +" +"============================================================================ + +if exists('g:loaded_syntastic_text_atdtool_checker') + finish +endif +let g:loaded_syntastic_text_atdtool_checker = 1 + +if !exists('g:syntastic_text_atdtool_sort') + let g:syntastic_text_atdtool_sort = 1 +endif + +let s:save_cpo = &cpo +set cpo&vim + +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' . escape(term, '\') + endif + return term +endfunction + +function! SyntaxCheckers_text_atdtool_GetLocList() dict + let makeprg = self.makeprgBuild({ 'tail': '2> ' . syntastic#util#DevNull() }) + + let errorformat = + \ '%W%f:%l:%c: %m,'. + \ '%+C suggestions:%.%#' + + let loclist = SyntasticMake({ + \ 'makeprg': makeprg, + \ 'errorformat': errorformat, + \ 'returns': [0], + \ 'subtype': 'Style' }) + + for e in loclist + let e['text'] = substitute(e['text'], '\m\n\s\+', ' | ', 'g') + endfor + + return loclist +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'text', + \ 'name': 'atdtool'}) + +let &cpo = s:save_cpo +unlet s:save_cpo + +" vim: set sw=4 sts=4 et fdm=marker: diff --git a/vim/bundle/syntastic/syntax_checkers/text/igor.vim b/vim/bundle/syntastic/syntax_checkers/text/igor.vim new file mode 100644 index 0000000..588cf3b --- /dev/null +++ b/vim/bundle/syntastic/syntax_checkers/text/igor.vim @@ -0,0 +1,23 @@ +"============================================================================ +"File: igor.vim +"Description: Syntax checking plugin for syntastic.vim +"Maintainer: LCD 47 <lcd047 at gmail dot com> +"License: This program is free software. It comes without any warranty, +" to the extent permitted by applicable law. You can redistribute +" it and/or modify it under the terms of the Do What The Fuck You +" Want To Public License, Version 2, as published by Sam Hocevar. +" See http://sam.zoy.org/wtfpl/COPYING for more details. +" +"============================================================================ + +if exists('g:loaded_syntastic_text_igor_checker') + finish +endif +let g:loaded_syntastic_text_igor_checker = 1 + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'text', + \ 'name': 'igor', + \ 'redirect': 'docbk/igor'}) + +" vim: set sw=4 sts=4 et fdm=marker: diff --git a/vim/bundle/syntastic/syntax_checkers/text/language_check.vim b/vim/bundle/syntastic/syntax_checkers/text/language_check.vim new file mode 100644 index 0000000..e1aa69f --- /dev/null +++ b/vim/bundle/syntastic/syntax_checkers/text/language_check.vim @@ -0,0 +1,37 @@ +"============================================================================ +"File: language_check.vim +"Description: Grammar checker (https://github.com/myint/language-check) +"Authors: Steven Myint <git@stevenmyint.com> +" +"============================================================================ + +if exists('g:loaded_syntastic_text_language_check_checker') + finish +endif +let g:loaded_syntastic_text_language_check_checker = 1 + +let s:save_cpo = &cpo +set cpo&vim + +function! SyntaxCheckers_text_language_check_GetLocList() dict + let makeprg = self.makeprgBuild({}) + + let errorformat = + \ '%f:%l:%c: %m' + + return SyntasticMake({ + \ 'makeprg': makeprg, + \ 'errorformat': errorformat, + \ 'subtype': 'Style', + \ 'returns': [0, 2] }) +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'text', + \ 'name': 'language_check', + \ 'exec': 'language-check'}) + +let &cpo = s:save_cpo +unlet s:save_cpo + +" vim: set sw=4 sts=4 et fdm=marker: diff --git a/vim/bundle/syntastic/syntax_checkers/text/textlint.vim b/vim/bundle/syntastic/syntax_checkers/text/textlint.vim new file mode 100644 index 0000000..3b51ae7 --- /dev/null +++ b/vim/bundle/syntastic/syntax_checkers/text/textlint.vim @@ -0,0 +1,42 @@ +"============================================================================ +"File: textlint.vim +"Description: Syntax checking plugin for syntastic +"Maintainer: LCD 47 <lcd047 at gmail dot com> +"License: This program is free software. It comes without any warranty, +" to the extent permitted by applicable law. You can redistribute +" it and/or modify it under the terms of the Do What The Fuck You +" Want To Public License, Version 2, as published by Sam Hocevar. +" See http://sam.zoy.org/wtfpl/COPYING for more details. +" +"============================================================================ + +if exists('g:loaded_syntastic_text_textlint_checker') + finish +endif +let g:loaded_syntastic_text_textlint_checker = 1 + +let s:save_cpo = &cpo +set cpo&vim + +function! SyntaxCheckers_text_textlint_GetLocList() dict + let makeprg = self.makeprgBuild({ 'args_after': '-f compact' }) + + let errorformat = + \ '%f: line %l\, col %c\, %tarning - %m,' . + \ '%f: line %l\, col %c\, %trror - %m' + + return SyntasticMake({ + \ 'makeprg': makeprg, + \ 'errorformat': errorformat, + \ 'subtype': 'Style', + \ 'returns': [0, 1] }) +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'text', + \ 'name': 'textlint'}) + +let &cpo = s:save_cpo +unlet s:save_cpo + +" vim: set sw=4 sts=4 et fdm=marker: diff --git a/vim/bundle/syntastic/syntax_checkers/trig/rapper.vim b/vim/bundle/syntastic/syntax_checkers/trig/rapper.vim new file mode 100644 index 0000000..f459cda --- /dev/null +++ b/vim/bundle/syntastic/syntax_checkers/trig/rapper.vim @@ -0,0 +1,23 @@ +"============================================================================ +"File: rapper.vim +"Description: Syntax checking plugin for syntastic +"Maintainer: Sebastian Tramp <mail@sebastian.tramp.name> +"License: This program is free software. It comes without any warranty, +" to the extent permitted by applicable law. You can redistribute +" it and/or modify it under the terms of the Do What 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_trig_rapper_checker') + finish +endif +let g:loaded_syntastic_trig_rapper_checker = 1 + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'trig', + \ 'name': 'rapper', + \ 'redirect': 'turtle/rapper'}) + +" vim: set sw=4 sts=4 et fdm=marker: diff --git a/vim/bundle/syntastic/syntax_checkers/turtle/rapper.vim b/vim/bundle/syntastic/syntax_checkers/turtle/rapper.vim new file mode 100644 index 0000000..4585a07 --- /dev/null +++ b/vim/bundle/syntastic/syntax_checkers/turtle/rapper.vim @@ -0,0 +1,46 @@ +"============================================================================ +"File: rapper.vim +"Description: Syntax checking plugin for syntastic +"Maintainer: Sebastian Tramp <mail@sebastian.tramp.name> +"License: This program is free software. It comes without any warranty, +" to the extent permitted by applicable law. You can redistribute +" it and/or modify it under the terms of the Do What 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_turtle_rapper_checker') + finish +endif +let g:loaded_syntastic_turtle_rapper_checker = 1 + +let s:save_cpo = &cpo +set cpo&vim + +function! SyntaxCheckers_turtle_rapper_GetHighlightRegex(item) + let term = matchstr(a:item['text'], '\mFailed to convert qname \zs\S\+\ze to URI') + return term !=# '' ? '\V\<' . escape(term, '\') . '\>' : '' +endfunction + +function! SyntaxCheckers_turtle_rapper_GetLocList() dict + let makeprg = self.makeprgBuild({ 'args': '-i guess -q --count' }) + + let errorformat = + \ 'rapper: %trror - URI file://%f:%l - %m,' . + \ 'rapper: %tarning - URI file://%f:%l - %m' + + return SyntasticMake({ + \ 'makeprg': makeprg, + \ 'errorformat': errorformat, + \ 'returns': [0, 1] }) +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'turtle', + \ 'name': 'rapper'}) + +let &cpo = s:save_cpo +unlet s:save_cpo + +" vim: set sw=4 sts=4 et fdm=marker: diff --git a/vim/bundle/syntastic/syntax_checkers/turtle/ttl.vim b/vim/bundle/syntastic/syntax_checkers/turtle/ttl.vim new file mode 100644 index 0000000..c28e354 --- /dev/null +++ b/vim/bundle/syntastic/syntax_checkers/turtle/ttl.vim @@ -0,0 +1,43 @@ +"============================================================================ +"File: ttl.vim +"Description: turtle syntax checker - using ttl from turtle-validator (npm) +"Maintainer: Antoine Reilles (tonio@NetBSD.org) +"License: This program is free software. It comes without any warranty, +" to the extent permitted by applicable law. You can redistribute +" it and/or modify it under the terms of the Do What 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_turtle_ttl_checker') + finish +endif +let g:loaded_syntastic_turtle_ttl_checker = 1 + +let s:save_cpo = &cpo +set cpo&vim + +function! SyntaxCheckers_turtle_ttl_GetHighlightRegex(item) + let term = matchstr(a:item['text'], '\m"\zs[^"]\+\ze"') + return term !=# '' ? '\V\<' . escape(term, '\') . '\>' : '' +endfunction + +function! SyntaxCheckers_turtle_ttl_GetLocList() dict + let makeprg = self.makeprgBuild({}) + + let errorformat = '%\m[Error: %m %\%%(at%\|on%\) line %l%\%.]' + + return SyntasticMake({ + \ 'makeprg': makeprg, + \ 'errorformat': errorformat, + \ 'defaults': {'bufnr': bufnr('')} }) +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'turtle', + \ 'name': 'ttl'}) + +let &cpo = s:save_cpo +unlet s:save_cpo + +" vim: set sw=4 sts=4 et fdm=marker: diff --git a/vim/bundle/syntastic/syntax_checkers/twig/twiglint.vim b/vim/bundle/syntastic/syntax_checkers/twig/twiglint.vim new file mode 100644 index 0000000..547648f --- /dev/null +++ b/vim/bundle/syntastic/syntax_checkers/twig/twiglint.vim @@ -0,0 +1,41 @@ +"============================================================================ +"File: twig.vim +"Description: Syntax checking plugin for syntastic.vim +"Maintainer: Alexander <iam.asm89 at gmail dot com> +"License: This program is free software. It comes without any warranty, +" to the extent permitted by applicable law. You can redistribute +" it and/or modify it under the terms of the Do What The Fuck You +" Want To Public License, Version 2, as published by Sam Hocevar. +" See http://sam.zoy.org/wtfpl/COPYING for more details. +" +"============================================================================ + +if exists('g:loaded_syntastic_twig_twiglint_checker') + finish +endif +let g:loaded_syntastic_twig_twiglint_checker = 1 + +let s:save_cpo = &cpo +set cpo&vim + +function! SyntaxCheckers_twig_twiglint_GetLocList() dict + let makeprg = self.makeprgBuild({ + \ 'args_before': 'lint', + \ 'args_after': '--format=csv' }) + + let errorformat = '"%f"\,%l\,%m' + + return SyntasticMake({ + \ 'makeprg': makeprg, + \ 'errorformat': errorformat}) +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'twig', + \ 'name': 'twiglint', + \ 'exec': 'twig-lint'}) + +let &cpo = s:save_cpo +unlet s:save_cpo + +" vim: set sw=4 sts=4 et fdm=marker: diff --git a/vim/bundle/syntastic/syntax_checkers/typescript/eslint.vim b/vim/bundle/syntastic/syntax_checkers/typescript/eslint.vim new file mode 100644 index 0000000..41e5276 --- /dev/null +++ b/vim/bundle/syntastic/syntax_checkers/typescript/eslint.vim @@ -0,0 +1,23 @@ +"============================================================================ +"File: eslint.vim +"Description: Syntax checking plugin for syntastic +"Maintainer: LCD 47 <lcd047 at gmail dot com> +"License: This program is free software. It comes without any warranty, +" to the extent permitted by applicable law. You can redistribute +" it and/or modify it under the terms of the Do What The Fuck You +" Want To Public License, Version 2, as published by Sam Hocevar. +" See http://sam.zoy.org/wtfpl/COPYING for more details. +" +"============================================================================ + +if exists('g:loaded_syntastic_typescript_eslint_checker') + finish +endif +let g:loaded_syntastic_typescript_eslint_checker = 1 + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'typescript', + \ 'name': 'eslint', + \ 'redirect': 'javascript/eslint'}) + +" vim: set sw=4 sts=4 et fdm=marker: diff --git a/vim/bundle/syntastic/syntax_checkers/typescript/tsc.vim b/vim/bundle/syntastic/syntax_checkers/typescript/tsc.vim new file mode 100644 index 0000000..de9242e --- /dev/null +++ b/vim/bundle/syntastic/syntax_checkers/typescript/tsc.vim @@ -0,0 +1,66 @@ +"============================================================================ +"File: tsc.vim +"Description: TypeScript syntax checker +"Maintainer: Bill Casarin <bill@casarin.ca> +" +"============================================================================ + +if exists('g:loaded_syntastic_typescript_tsc_checker') + finish +endif +let g:loaded_syntastic_typescript_tsc_checker = 1 + +if !exists('g:syntastic_typescript_tsc_sort') + let g:syntastic_typescript_tsc_sort = 1 +endif + +let s:save_cpo = &cpo +set cpo&vim + +function! SyntaxCheckers_typescript_tsc_IsAvailable() dict + if !executable(self.getExec()) + return 0 + endif + + let version_output = split(syntastic#util#system(self.getExecEscaped() . ' --version'), '\n', 1) + let ver = filter(copy(version_output), 'v:val =~# ''\m\<Version ''') + let parsed_ver = len(ver) ? syntastic#util#parseVersion(ver[0], '\v<Version \zs\d+(\.\d+)\ze') : [] + + if len(parsed_ver) + call self.setVersion(parsed_ver) + let s:tsc_new = syntastic#util#versionIsAtLeast(parsed_ver, [1, 5]) + else + call syntastic#log#ndebug(g:_SYNTASTIC_DEBUG_LOCLIST, 'checker output:', version_output) + call syntastic#log#error("checker typescript/tsc: can't parse version string (abnormal termination?)") + let s:tsc_new = -1 + endif + + return s:tsc_new >= 0 +endfunction + +function! SyntaxCheckers_typescript_tsc_GetLocList() dict + let makeprg = self.makeprgBuild({ + \ 'args': '--module commonjs', + \ 'args_after': (s:tsc_new ? '--noEmit' : '--out ' . syntastic#util#DevNull()) }) + + let errorformat = + \ '%E%f %#(%l\,%c): error %m,' . + \ '%E%f %#(%l\,%c): %m,' . + \ '%Eerror %m,' . + \ '%C%\s%\+%m' + + return SyntasticMake({ + \ 'makeprg': makeprg, + \ 'errorformat': errorformat, + \ 'postprocess': ['guards'], + \ 'defaults': {'bufnr': bufnr('')} }) +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'typescript', + \ 'name': 'tsc'}) + +let &cpo = s:save_cpo +unlet s:save_cpo + +" vim: set sw=4 sts=4 et fdm=marker: diff --git a/vim/bundle/syntastic/syntax_checkers/typescript/tslint.vim b/vim/bundle/syntastic/syntax_checkers/typescript/tslint.vim new file mode 100644 index 0000000..de224b6 --- /dev/null +++ b/vim/bundle/syntastic/syntax_checkers/typescript/tslint.vim @@ -0,0 +1,51 @@ +"============================================================================ +"File: typescript/tslint.vim +"Description: TypeScript linter +"Maintainer: Seon-Wook Park <seon.wook@swook.net> +"============================================================================ + +if exists('g:loaded_syntastic_typescript_tslint_checker') + finish +endif +let g:loaded_syntastic_typescript_tslint_checker = 1 + +if !exists('g:syntastic_typescript_tslint_sort') + let g:syntastic_typescript_tslint_sort = 1 +endif + +let s:save_cpo = &cpo +set cpo&vim + +function! SyntaxCheckers_typescript_tslint_GetHighlightRegex(item) + let term = matchstr(a:item['text'], "\\m\\s'\\zs.\\{-}\\ze'\\s") + return term !=# '' ? '\V' . escape(term, '\') : '' +endfunction + +function! SyntaxCheckers_typescript_tslint_GetLocList() dict + if !exists('s:tslint_new') + let s:tslint_new = syntastic#util#versionIsAtLeast(self.getVersion(), [2, 4]) + endif + + let makeprg = self.makeprgBuild({ + \ 'args_after': '--format verbose', + \ 'fname_before': (s:tslint_new ? '' : '-f') }) + + " (comment-format) ts/app.ts[12, 36]: comment must start with lowercase letter + let errorformat = '%f[%l\, %c]: %m' + + return SyntasticMake({ + \ 'makeprg': makeprg, + \ 'errorformat': errorformat, + \ 'preprocess': 'tslint', + \ 'subtype': 'Style', + \ 'returns': [0, 2] }) +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'typescript', + \ 'name': 'tslint'}) + +let &cpo = s:save_cpo +unlet s:save_cpo + +" vim: set sw=4 sts=4 et fdm=marker: diff --git a/vim/bundle/syntastic/syntax_checkers/vala/valac.vim b/vim/bundle/syntastic/syntax_checkers/vala/valac.vim new file mode 100644 index 0000000..a60c249 --- /dev/null +++ b/vim/bundle/syntastic/syntax_checkers/vala/valac.vim @@ -0,0 +1,86 @@ +"============================================================================ +"File: vala.vim +"Description: Syntax checking plugin for syntastic.vim +"Maintainer: Konstantin Stepanov (me@kstep.me) +"License: This program is free software. It comes without any warranty, +" to the extent permitted by applicable law. You can redistribute +" it and/or modify it under the terms of the Do What The Fuck You +" Want To Public License, Version 2, as published by Sam Hocevar. +" See http://sam.zoy.org/wtfpl/COPYING for more details. +" +"============================================================================ + +if exists('g:loaded_syntastic_vala_valac_checker') + finish +endif +let g:loaded_syntastic_vala_valac_checker = 1 + +let s:save_cpo = &cpo +set cpo&vim + +function! SyntaxCheckers_vala_valac_GetHighlightRegex(pos) " {{{1 + let length = strlen(matchstr(a:pos['text'], '\m\^\+$')) + return '\%>' . (a:pos['col'] - 1) . 'c\%<' . (a:pos['col'] + length) . 'c' +endfunction " }}}1 + +function! SyntaxCheckers_vala_valac_GetLocList() dict " {{{1 + let vala_pkg_args = join(map(s:GetValaModules(), '"--pkg ".v:val'), ' ') + let vala_vapi_args = join(map(s:GetValaVapiDirs(), '"--vapidir ".v:val'), ' ') + let makeprg = self.makeprgBuild({ 'args': '-C ' . vala_pkg_args . ' ' . vala_vapi_args }) + + let errorformat = + \ '%A%f:%l.%c-%\d%\+.%\d%\+: %t%[a-z]%\+: %m,'. + \ '%C%m,'. + \ '%Z%m' + + return SyntasticMake({ + \ 'makeprg': makeprg, + \ 'errorformat': errorformat }) +endfunction " }}}1 + +" Utilities {{{1 + +function! s:GetValaModules() " {{{2 + if exists('g:syntastic_vala_modules') || exists('b:syntastic_vala_modules') + let modules = syntastic#util#var('vala_modules') + if type(modules) == type('') + return split(modules, '\m\s\+') + elseif type(modules) == type([]) + return copy(modules) + else + echoerr '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), '\m\s\+') +endfunction " }}}2 + +function! s:GetValaVapiDirs() " {{{2 + if exists('g:syntastic_vala_vapi_dirs') || exists('b:syntastic_vala_vapi_dirs') + let vapi_dirs = syntastic#util#var('vala_vapi_dirs') + if type(vapi_dirs) == type('') + return split(vapi_dirs, '\m\s\+') + elseif type(vapi_dirs) == type([]) + return copy(vapi_dirs) + else + echoerr 'syntastic_vala_vapi_dirs must be either a list, or a string: fallback to in-file modules string' + endif + endif + + let vapi_line = search('^//\s*vapidirs:\s*','n') + let vapi_str = getline(vapi_line) + return split( substitute( vapi_str, '\m^//\s*vapidirs:\s*', '', 'g' ), '\m\s\+' ) +endfunction " }}}2 + +" }}}1 + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'vala', + \ 'name': 'valac'}) + +let &cpo = s:save_cpo +unlet s:save_cpo + +" vim: set sw=4 sts=4 et fdm=marker: diff --git a/vim/bundle/syntastic/syntax_checkers/verilog/iverilog.vim b/vim/bundle/syntastic/syntax_checkers/verilog/iverilog.vim new file mode 100644 index 0000000..c34fec1 --- /dev/null +++ b/vim/bundle/syntastic/syntax_checkers/verilog/iverilog.vim @@ -0,0 +1,38 @@ +"============================================================================ +"File: iverilog.vim +"Description: Syntax checking plugin for syntastic.vim +"Maintainer: Psidium <psiidium at gmail dot com> +"License: The MIT License +"============================================================================ + +if exists('g:loaded_syntastic_verilog_iverilog_checker') + finish +endif +let g:loaded_syntastic_verilog_iverilog_checker = 1 + +let s:save_cpo = &cpo +set cpo&vim + +function! SyntaxCheckers_verilog_iverilog_GetLocList() dict + let makeprg = self.makeprgBuild({ + \ 'args_before': '-t null', + \ 'args': '-Wall' }) + + let errorformat = + \ '%f:%l: %trror: %m,' . + \ '%f:%l: %tarning: %m,' . + \ '%E%f:%l: : %m,' . + \ '%W%f:%l: : %m,' . + \ '%f:%l: %m' + + return SyntasticMake({'makeprg': makeprg, 'errorformat': errorformat}) +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'verilog', + \ 'name': 'iverilog'}) + +let &cpo = s:save_cpo +unlet s:save_cpo + +" vim: set sw=4 sts=4 et fdm=marker: diff --git a/vim/bundle/syntastic/syntax_checkers/verilog/verilator.vim b/vim/bundle/syntastic/syntax_checkers/verilog/verilator.vim new file mode 100644 index 0000000..e5cfddc --- /dev/null +++ b/vim/bundle/syntastic/syntax_checkers/verilog/verilator.vim @@ -0,0 +1,42 @@ +"============================================================================ +"File: verilator.vim +"Description: Syntax checking plugin for syntastic.vim +"Maintainer: Kocha <kocha dot lsifrontend at gmail dot com> +"============================================================================ + +if exists('g:loaded_syntastic_verilog_verilator_checker') + finish +endif +let g:loaded_syntastic_verilog_verilator_checker = 1 + +if !exists('g:syntastic_verilog_compiler_options') + let g:syntastic_verilog_compiler_options = '-Wall' +endif + +let s:save_cpo = &cpo +set cpo&vim + +function! SyntaxCheckers_verilog_verilator_IsAvailable() dict + if !exists('g:syntastic_verilog_compiler') + let g:syntastic_verilog_compiler = self.getExec() + endif + call self.log('g:syntastic_verilog_compiler =', g:syntastic_verilog_compiler) + return executable(expand(g:syntastic_verilog_compiler, 1)) +endfunction + +function! SyntaxCheckers_verilog_verilator_GetLocList() dict + return syntastic#c#GetLocList('verilog', 'verilator', { + \ 'errorformat': + \ '%%%trror-%\=%\w%#: %f:%l: %m,' . + \ '%%%tarning-%\=%\w%#: %f:%l: %m', + \ 'main_flags': '--lint-only' }) +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'verilog', + \ 'name': 'verilator' }) + +let &cpo = s:save_cpo +unlet s:save_cpo + +" vim: set sw=4 sts=4 et fdm=marker: diff --git a/vim/bundle/syntastic/syntax_checkers/vhdl/ghdl.vim b/vim/bundle/syntastic/syntax_checkers/vhdl/ghdl.vim new file mode 100644 index 0000000..497152b --- /dev/null +++ b/vim/bundle/syntastic/syntax_checkers/vhdl/ghdl.vim @@ -0,0 +1,38 @@ +"============================================================================ +"File: ghdl.vim +"Description: Syntax checking plugin for syntastic.vim +"Maintainer: Jan Wagner <jaydyou at janidom dot de> +"License: This program is free software. It comes without any warranty, +" to the extent permitted by applicable law. You can redistribute +" it and/or modify it under the terms of the Do What The Fuck You +" Want To Public License, Version 2, as published by Sam Hocevar. +" See http://sam.zoy.org/wtfpl/COPYING for more details. +" +"============================================================================ + +if exists('g:loaded_syntastic_vhdl_ghdl_checker') + finish +endif +let g:loaded_syntastic_vhdl_ghdl_checker = 1 + +let s:save_cpo = &cpo +set cpo&vim + +function! SyntaxCheckers_vhdl_ghdl_GetLocList() dict + let makeprg = self.makeprgBuild({ 'args_before': '-s' }) + + let errorformat = '%f:%l:%c: %m' + + return SyntasticMake({ + \ 'makeprg': makeprg, + \ 'errorformat': errorformat }) +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'vhdl', + \ 'name': 'ghdl'}) + +let &cpo = s:save_cpo +unlet s:save_cpo + +" vim: set sw=4 sts=4 et fdm=marker: diff --git a/vim/bundle/syntastic/syntax_checkers/vhdl/vcom.vim b/vim/bundle/syntastic/syntax_checkers/vhdl/vcom.vim new file mode 100644 index 0000000..6cdf4fb --- /dev/null +++ b/vim/bundle/syntastic/syntax_checkers/vhdl/vcom.vim @@ -0,0 +1,55 @@ +"============================================================================ +"File: vcom.vim +"Description: Syntax checking plugin for syntastic.vim +"Maintainer: Jim Vogel <jim dot e dot vogel at gmail dot com> +"License: This program is free software. It comes without any warranty, +" to the extent permitted by applicable law. You can redistribute +" it and/or modify it under the terms of the Do What The Fuck You +" Want To Public License, Version 2, as published by Sam Hocevar. +" See http://sam.zoy.org/wtfpl/COPYING for more details. +" +"============================================================================ + +if exists('g:loaded_syntastic_vhdl_vcom_checker') + finish +endif +let g:loaded_syntastic_vhdl_vcom_checker = 1 + +let s:save_cpo = &cpo +set cpo&vim + +function! SyntaxCheckers_vhdl_vcom_GetLocList() dict + let makeprg = self.makeprgBuild({ 'args_before': '-lint' }) + + let errorformat = + \ '** %tRROR: %f(%l): %m,' . + \ '** %tRROR: %m,' . + \ '** %tARNING: %f(%l): %m,' . + \ '** %tARNING: %m,' . + \ '** %tOTE: %m,' . + \ '%tRROR: %f(%l): %m,' . + \ '%tARNING[%*[0-9]]: %f(%l): %m,' . + \ '%tRROR: %m,' . + \ '%tARNING[%*[0-9]]: %m' + + let loclist = SyntasticMake({ + \ 'makeprg': makeprg, + \ 'errorformat': errorformat }) + + for e in loclist + if e['type'] !=? 'E' && e['type'] !=? 'W' + let e['type'] = 'W' + endif + endfor + + return loclist +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'vhdl', + \ 'name': 'vcom'}) + +let &cpo = s:save_cpo +unlet s:save_cpo + +" vim: set sw=4 sts=4 et fdm=marker: diff --git a/vim/bundle/syntastic/syntax_checkers/vim/vimlint.vim b/vim/bundle/syntastic/syntax_checkers/vim/vimlint.vim new file mode 100644 index 0000000..0e03ed0 --- /dev/null +++ b/vim/bundle/syntastic/syntax_checkers/vim/vimlint.vim @@ -0,0 +1,108 @@ +"============================================================================ +"File: vimlint.vim +"Description: Syntax checking plugin for syntastic.vim +"Maintainer: LCD 47 <lcd047 at gmail dot com> +"License: This program is free software. It comes without any warranty, +" to the extent permitted by applicable law. You can redistribute +" it and/or modify it under the terms of the Do What The Fuck You +" Want To Public License, Version 2, as published by Sam Hocevar. +" See http://sam.zoy.org/wtfpl/COPYING for more details. +" +"============================================================================ + +if exists('g:loaded_syntastic_vim_vimlint_checker') + finish +endif +let g:loaded_syntastic_vim_vimlint_checker = 1 + +let s:save_cpo = &cpo +set cpo&vim + +function! SyntaxCheckers_vim_vimlint_GetHighlightRegex(item) " {{{1 + let term = matchstr(a:item['text'], '\m `\zs[^`]\+\ze`') + if term !=# '' + let col = get(a:item, 'col', 0) + + if col && term[0:1] ==# 'l:' + if getline(a:item.lnum)[col-1:col] !=# 'l:' + let term = term[2:] + endif + endif + + return col ? '\%>' . (col - 1) . 'c\%<' . (col + strlen(term)) . 'c' : '\V' . escape(term, '\') + endif + + return '' +endfunction " }}}1 + +function! SyntaxCheckers_vim_vimlint_IsAvailable() dict " {{{1 + let vimlparser = globpath(&runtimepath, 'autoload/vimlparser.vim', 1) + let vimlint = globpath(&runtimepath, 'autoload/vimlint.vim', 1) + call self.log("globpath(&runtimepath, 'autoload/vimlparser.vim', 1) = " . string(vimlparser) . ', ' . + \ "globpath(&runtimepath, 'autoload/vimlint.vim', 1) = " . string(vimlint)) + return vimlparser !=# '' && vimlint !=# '' +endfunction " }}}1 + +function! SyntaxCheckers_vim_vimlint_GetLocList() dict " {{{1 + " EVL102: unused variable v + " EVL103: unused argument v + " EVL104: variable may not be initialized on some execution path: v + " EVL105: global variable v is defined without g: + " EVL106: local variable v is used without l: + " EVL201: unreachable code + " EVL204: constant in conditional context + " EVL205: missing scriptencoding + " value 3: the message is a warning + " + " References: :help vimlint-errorcode and :help vimlint-variables + let param = { + \ 'output': function('s:vimlintOutput'), + \ 'quiet': 1, + \ 'EVL102': 3, + \ 'EVL103': 3, + \ 'EVL104': 3, + \ 'EVL105': 3, + \ 'EVL106': 3, + \ 'EVL201': 3, + \ 'EVL204': 3, + \ 'EVL205': 3 } + + if exists('g:syntastic_vimlint_options') || exists('b:syntastic_vimlint_options') + let opts = syntastic#util#var('vimlint_options') + if type(opts) == type({}) + let options = filter(copy(opts), 'v:key =~# "\\m^EVL"') + call extend(param, options, 'force') + endif + endif + + call self.log('options =', param) + + return vimlint#vimlint(expand('%', 1), param) +endfunction " }}}1 + +" Utilities {{{1 + +" @vimlint(EVL103, 1, a:filename) +function! s:vimlintOutput(filename, pos, ev, eid, mes, obj) " {{{2 + call add(a:obj.error, { + \ 'bufnr': bufnr(''), + \ 'lnum': a:pos.lnum, + \ 'col': a:pos.col, + \ 'vcol': 0, + \ 'type': a:ev[0], + \ 'text': '[' . a:eid . '] ' . a:mes, + \ 'valid': a:pos.lnum > 0 }) +endfunction " }}}2 +" @vimlint(EVL103, 0, a:filename) + +" }}}1 + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'vim', + \ 'name': 'vimlint', + \ 'exec': '' }) + +let &cpo = s:save_cpo +unlet s:save_cpo + +" vim: set sw=4 sts=4 et fdm=marker: diff --git a/vim/bundle/syntastic/syntax_checkers/vim/vint.vim b/vim/bundle/syntastic/syntax_checkers/vim/vint.vim new file mode 100644 index 0000000..23a041e --- /dev/null +++ b/vim/bundle/syntastic/syntax_checkers/vim/vint.vim @@ -0,0 +1,55 @@ +"============================================================================ +"File: vint.vim +"Description: Syntax checking plugin for syntastic.vim +"Maintainer: LCD 47 <lcd047 at gmail dot com> +"License: This program is free software. It comes without any warranty, +" to the extent permitted by applicable law. You can redistribute +" it and/or modify it under the terms of the Do What The Fuck You +" Want To Public License, Version 2, as published by Sam Hocevar. +" See http://sam.zoy.org/wtfpl/COPYING for more details. +" +"============================================================================ + +if exists('g:loaded_syntastic_vim_vint_checker') + finish +endif +let g:loaded_syntastic_vim_vint_checker = 1 + +if !exists('g:syntastic_vim_vint_sort') + let g:syntastic_vim_vint_sort = 1 +endif + +let s:save_cpo = &cpo +set cpo&vim + +function! SyntaxCheckers_vim_vint_GetLocList() dict + let makeprg = self.makeprgBuild({ 'post_args': '--json' }) + + let errorformat = '%f:%l:%c:%t: %m' + + let loclist = SyntasticMake({ + \ 'makeprg': makeprg, + \ 'errorformat': errorformat, + \ 'preprocess': 'vint', + \ 'returns': [0, 1] }) + + for e in loclist + if e['type'] ==? 's' + let e['type'] = 'w' + let e['subtype'] = 'Style' + elseif e['type'] !=? 'e' && e['type'] !=? 'w' + let e['type'] = 'e' + endif + endfor + + return loclist +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'vim', + \ 'name': 'vint'}) + +let &cpo = s:save_cpo +unlet s:save_cpo + +" vim: set sw=4 sts=4 et fdm=marker: diff --git a/vim/bundle/syntastic/syntax_checkers/xhtml/jshint.vim b/vim/bundle/syntastic/syntax_checkers/xhtml/jshint.vim new file mode 100644 index 0000000..f4536e2 --- /dev/null +++ b/vim/bundle/syntastic/syntax_checkers/xhtml/jshint.vim @@ -0,0 +1,23 @@ +"============================================================================ +"File: jshint.vim +"Description: Javascript syntax checker for xHTML - using jshint +"Maintainer: LCD 47 <lcd047 at gmail dot com> +"License: This program is free software. It comes without any warranty, +" to the extent permitted by applicable law. You can redistribute +" it and/or modify it under the terms of the Do What The Fuck You +" Want To Public License, Version 2, as published by Sam Hocevar. +" See http://sam.zoy.org/wtfpl/COPYING for more details. +" +"============================================================================ + +if exists('g:loaded_syntastic_xhtml_jshint_checker') + finish +endif +let g:loaded_syntastic_xhtml_jshint_checker = 1 + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'xhtml', + \ 'name': 'jshint', + \ 'redirect': 'html/jshint'}) + +" vim: set sw=4 sts=4 et fdm=marker: diff --git a/vim/bundle/syntastic/syntax_checkers/xhtml/tidy.vim b/vim/bundle/syntastic/syntax_checkers/xhtml/tidy.vim new file mode 100644 index 0000000..7f76d8b --- /dev/null +++ b/vim/bundle/syntastic/syntax_checkers/xhtml/tidy.vim @@ -0,0 +1,92 @@ +"============================================================================ +"File: xhtml.vim +"Description: Syntax checking plugin for syntastic.vim +"Maintainer: Martin Grenfell <martin.grenfell at gmail dot com> +"License: This program is free software. It comes without any warranty, +" to the extent permitted by applicable law. You can redistribute +" it and/or modify it under the terms of the Do What The Fuck You +" Want To Public License, Version 2, as published by Sam Hocevar. +" See http://sam.zoy.org/wtfpl/COPYING for more details. +" +"============================================================================ + +if exists('g:loaded_syntastic_xhtml_tidy_checker') + finish +endif +let g:loaded_syntastic_xhtml_tidy_checker = 1 + +let s:save_cpo = &cpo +set cpo&vim + +if !exists('g:syntastic_xhtml_tidy_ignore_errors') + let g:syntastic_xhtml_tidy_ignore_errors = [] +endif + +" Constants {{{1 + +" 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 + +" }}}1 + +function! SyntaxCheckers_xhtml_tidy_GetLocList() dict " {{{1 + let encopt = s:TidyEncOptByFenc() + let makeprg = self.makeprgBuild({ 'args_after': encopt . ' -xml -e' }) + + 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 e in loclist + if e['valid'] && s:IgnoreError(e['text']) == 1 + let e['valid'] = 0 + endif + endfor + + return loclist +endfunction " }}}1 + +" Utilities {{{1 + +function! s:IgnoreError(text) " {{{2 + for item in g:syntastic_xhtml_tidy_ignore_errors + if stridx(a:text, item) != -1 + return 1 + endif + endfor + return 0 +endfunction " }}}2 + +" }}}1 + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'xhtml', + \ 'name': 'tidy'}) + +let &cpo = s:save_cpo +unlet s:save_cpo + +" vim: set sw=4 sts=4 et fdm=marker: diff --git a/vim/bundle/syntastic/syntax_checkers/xml/plutil.vim b/vim/bundle/syntastic/syntax_checkers/xml/plutil.vim new file mode 100644 index 0000000..8e80dde --- /dev/null +++ b/vim/bundle/syntastic/syntax_checkers/xml/plutil.vim @@ -0,0 +1,42 @@ +"============================================================================ +"File: plutil.vim +"Description: Syntax checking plugin for syntastic.vim +"Maintainer: LCD 47 <lcd047 at gmail dot com> +"License: This program is free software. It comes without any warranty, +" to the extent permitted by applicable law. You can redistribute +" it and/or modify it under the terms of the Do What The Fuck You +" Want To Public License, Version 2, as published by Sam Hocevar. +" See http://sam.zoy.org/wtfpl/COPYING for more details. +" +"============================================================================ + +if exists('g:loaded_syntastic_xml_plutil_checker') + finish +endif +let g:loaded_syntastic_xml_plutil_checker = 1 + +let s:save_cpo = &cpo +set cpo&vim + +function! SyntaxCheckers_xml_plutil_GetLocList() dict + let makeprg = self.makeprgBuild({ + \ 'args_before': '-lint -s', + \ 'fname_before': '--' }) + + let errorformat = + \ '%E%f: %m at line %l' + + return SyntasticMake({ + \ 'makeprg': makeprg, + \ 'errorformat': errorformat, + \ 'returns': [0, 1] }) +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'xml', + \ 'name': 'plutil'}) + +let &cpo = s:save_cpo +unlet s:save_cpo + +" vim: set sw=4 sts=4 et fdm=marker: diff --git a/vim/bundle/syntastic/syntax_checkers/xml/xmllint.vim b/vim/bundle/syntastic/syntax_checkers/xml/xmllint.vim new file mode 100644 index 0000000..1300437 --- /dev/null +++ b/vim/bundle/syntastic/syntax_checkers/xml/xmllint.vim @@ -0,0 +1,54 @@ +"============================================================================ +"File: xml.vim +"Description: Syntax checking plugin for syntastic.vim +"Maintainer: Sebastian Kusnier <sebastian at kusnier dot net> +"License: This program is free software. It comes without any warranty, +" to the extent permitted by applicable law. You can redistribute +" it and/or modify it under the terms of the Do What The Fuck You +" Want To Public License, Version 2, as published by Sam Hocevar. +" See http://sam.zoy.org/wtfpl/COPYING for more details. +" +"============================================================================ + +if exists('g:loaded_syntastic_xml_xmllint_checker') + finish +endif +let g:loaded_syntastic_xml_xmllint_checker = 1 + +let s:save_cpo = &cpo +set cpo&vim + +" 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_GetLocList() dict + let makeprg = self.makeprgBuild({ + \ 'args': '--xinclude --postvalid', + \ 'args_after': '--noout' }) + + 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'}) + +let &cpo = s:save_cpo +unlet s:save_cpo + +" vim: set sw=4 sts=4 et fdm=marker: diff --git a/vim/bundle/syntastic/syntax_checkers/xquery/basex.vim b/vim/bundle/syntastic/syntax_checkers/xquery/basex.vim new file mode 100644 index 0000000..640a191 --- /dev/null +++ b/vim/bundle/syntastic/syntax_checkers/xquery/basex.vim @@ -0,0 +1,51 @@ +"============================================================================ +"File: basex.vim +"Description: Syntax checking plugin for syntastic.vim +"Maintainer: James Wright <james dot jw at hotmail dot com> +"License: This program is free software. It comes without any warranty, +" to the extent permitted by applicable law. You can redistribute +" it and/or modify it under the terms of the Do What The Fuck You +" Want To Public License, Version 2, as published by Sam Hocevar. +" +"============================================================================ + +if exists('g:loaded_syntastic_xquery_basex_checker') + finish +endif +let g:loaded_syntastic_xquery_basex_checker = 1 + +let s:save_cpo = &cpo +set cpo&vim + +function! SyntaxCheckers_xquery_basex_GetLocList() dict + let makeprg = self.makeprgBuild({ + \ 'args_after': '-z', + \ 'fname_before': '-q', + \ 'fname': syntastic#util#shescape('inspect:module("' . escape(expand('%:p', 1), '"') . '")') }) + + let errorformat = + \ '%f:%l:%c:%t:%n:%m,' . + \ '%m' + + let loclist = SyntasticMake({ + \ 'makeprg': makeprg, + \ 'errorformat': errorformat, + \ 'preprocess': 'basex' }) + + for e in loclist + if e['type'] !=# 'W' && e['type'] !=# 'E' + let e['type'] = 'E' + endif + endfor + + return loclist +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'xquery', + \ 'name': 'basex'}) + +let &cpo = s:save_cpo +unlet s:save_cpo + +" vim: set sw=4 sts=4 et fdm=marker: diff --git a/vim/bundle/syntastic/syntax_checkers/xslt/xmllint.vim b/vim/bundle/syntastic/syntax_checkers/xslt/xmllint.vim new file mode 100644 index 0000000..9ffb548 --- /dev/null +++ b/vim/bundle/syntastic/syntax_checkers/xslt/xmllint.vim @@ -0,0 +1,23 @@ +"============================================================================ +"File: xslt.vim +"Description: Syntax checking plugin for syntastic.vim +"Maintainer: Sebastian Kusnier <sebastian at kusnier dot net> +"License: This program is free software. It comes without any warranty, +" to the extent permitted by applicable law. You can redistribute +" it and/or modify it under the terms of the Do What The Fuck You +" Want To Public License, Version 2, as published by Sam Hocevar. +" See http://sam.zoy.org/wtfpl/COPYING for more details. +" +"============================================================================ + +if exists('g:loaded_syntastic_xslt_xmllint_checker') + finish +endif +let g:loaded_syntastic_xslt_xmllint_checker = 1 + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'xslt', + \ 'name': 'xmllint', + \ 'redirect': 'xml/xmllint'}) + +" vim: set sw=4 sts=4 et fdm=marker: diff --git a/vim/bundle/syntastic/syntax_checkers/yacc/bison.vim b/vim/bundle/syntastic/syntax_checkers/yacc/bison.vim new file mode 100644 index 0000000..af8ac91 --- /dev/null +++ b/vim/bundle/syntastic/syntax_checkers/yacc/bison.vim @@ -0,0 +1,55 @@ +"============================================================================ +"File: yacc.vim +"Description: Syntax checking plugin for syntastic.vim +"Maintainer: LCD 47 <lcd047 at gmail dot com> +"License: This program is free software. It comes without any warranty, +" to the extent permitted by applicable law. You can redistribute +" it and/or modify it under the terms of the Do What The Fuck You +" Want To Public License, Version 2, as published by Sam Hocevar. +" See http://sam.zoy.org/wtfpl/COPYING for more details. +" +"============================================================================ + +if exists('g:loaded_syntastic_yacc_bison_checker') + finish +endif +let g:loaded_syntastic_yacc_bison_checker = 1 + +let s:save_cpo = &cpo +set cpo&vim + +function! SyntaxCheckers_yacc_bison_GetLocList() dict + let makeprg = self.makeprgBuild({ + \ 'args_after': syntastic#c#NullOutput() }) + + let errorformat = + \ '%E%f:%l%.%v-%.%\{-}: %trror: %m,' . + \ '%E%f:%l%.%v: %trror: %m,' . + \ '%W%f:%l%.%v-%.%\{-}: %tarning: %m,' . + \ '%W%f:%l%.%v: %tarning: %m,' . + \ '%I%f:%l%.%v-%.%\{-}: %\s%\+%m,' . + \ '%I%f:%l%.%v: %\s%\+%m' + + let loclist = SyntasticMake({ + \ 'makeprg': makeprg, + \ 'errorformat': errorformat }) + + let last_type = 'E' + for e in loclist + if e['type'] ==? 'I' + let e['type'] = last_type + endif + let last_type = e['type'] + endfor + + return loclist +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'yacc', + \ 'name': 'bison'}) + +let &cpo = s:save_cpo +unlet s:save_cpo + +" vim: set sw=4 sts=4 et fdm=marker: diff --git a/vim/bundle/syntastic/syntax_checkers/yaml/jsyaml.vim b/vim/bundle/syntastic/syntax_checkers/yaml/jsyaml.vim new file mode 100644 index 0000000..e8baa7e --- /dev/null +++ b/vim/bundle/syntastic/syntax_checkers/yaml/jsyaml.vim @@ -0,0 +1,48 @@ +"============================================================================ +"File: yaml.vim +"Description: Syntax checking plugin for syntastic.vim +"Maintainer: Martin Grenfell <martin.grenfell at gmail dot com> +"License: This program is free software. It comes without any warranty, +" to the extent permitted by applicable law. You can redistribute +" it and/or modify it under the terms of the Do What The Fuck You +" Want To Public License, Version 2, as published by Sam Hocevar. +" See http://sam.zoy.org/wtfpl/COPYING for more details. +" +"============================================================================ + +if exists('g:loaded_syntastic_yaml_jsyaml_checker') + finish +endif +let g:loaded_syntastic_yaml_jsyaml_checker = 1 + +let s:save_cpo = &cpo +set cpo&vim + +function! SyntaxCheckers_yaml_jsyaml_GetLocList() dict + if !exists('s:js_yaml_new') + let s:js_yaml_new = syntastic#util#versionIsAtLeast(self.getVersion(), [2]) + endif + + let makeprg = self.makeprgBuild({ 'args_after': (s:js_yaml_new ? '' : '--compact') }) + + let errorformat = + \ 'Error on line %l\, col %c:%m,' . + \ 'JS-YAML: %m at line %l\, column %c:,' . + \ 'YAMLException: %m at line %l\, column %c:,' . + \ '%-G%.%#' + + return SyntasticMake({ + \ 'makeprg': makeprg, + \ 'errorformat': errorformat, + \ 'defaults': {'bufnr': bufnr('')} }) +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'yaml', + \ 'name': 'jsyaml', + \ 'exec': 'js-yaml'}) + +let &cpo = s:save_cpo +unlet s:save_cpo + +" vim: set sw=4 sts=4 et fdm=marker: diff --git a/vim/bundle/syntastic/syntax_checkers/yaml/yamllint.vim b/vim/bundle/syntastic/syntax_checkers/yaml/yamllint.vim new file mode 100644 index 0000000..130877d --- /dev/null +++ b/vim/bundle/syntastic/syntax_checkers/yaml/yamllint.vim @@ -0,0 +1,52 @@ +"============================================================================ +"File: yamllint.vim +"Description: YAML files linting for syntastic.vim +"Maintainer: Adrien Vergé +"License: This program is free software. It comes without any warranty, +" to the extent permitted by applicable law. You can redistribute +" it and/or modify it under the terms of the Do What 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_yaml_yamllint_checker') + finish +endif +let g:loaded_syntastic_yaml_yamllint_checker = 1 + +let s:save_cpo = &cpo +set cpo&vim + +function! SyntaxCheckers_yaml_yamllint_GetLocList() dict + let makeprg = self.makeprgBuild({ 'args_after': '-f parsable' }) + + let errorformat = + \ '%f:%l:%c: [%trror] %m,' . + \ '%f:%l:%c: [%tarning] %m' + + let env = syntastic#util#isRunningWindows() ? {} : { 'TERM': 'dumb' } + + let loclist = SyntasticMake({ + \ 'makeprg': makeprg, + \ 'errorformat': errorformat, + \ 'env': env, + \ 'returns': [0, 1] }) + + for e in loclist + if e['type'] ==? 'W' + let e['subtype'] = 'Style' + endif + endfor + + return loclist +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'yaml', + \ 'name': 'yamllint' }) + +let &cpo = s:save_cpo +unlet s:save_cpo + +" vim: set sw=4 sts=4 et fdm=marker: diff --git a/vim/bundle/syntastic/syntax_checkers/yaml/yamlxs.vim b/vim/bundle/syntastic/syntax_checkers/yaml/yamlxs.vim new file mode 100644 index 0000000..ace118a --- /dev/null +++ b/vim/bundle/syntastic/syntax_checkers/yaml/yamlxs.vim @@ -0,0 +1,72 @@ +"============================================================================ +"File: yamlxs.vim +"Description: Syntax checking plugin for syntastic.vim +"Maintainer: LCD 47 <lcd047 at gmail dot com> +"License: This program is free software. It comes without any warranty, +" to the extent permitted by applicable law. You can redistribute +" it and/or modify it under the terms of the Do What The Fuck You +" Want To Public License, Version 2, as published by Sam Hocevar. +" See http://sam.zoy.org/wtfpl/COPYING for more details. +" +"============================================================================ + +if exists('g:loaded_syntastic_yaml_yamlxs_checker') + finish +endif +let g:loaded_syntastic_yaml_yamlxs_checker = 1 + +if !exists('g:syntastic_perl_lib_path') + let g:syntastic_perl_lib_path = [] +endif + +let s:save_cpo = &cpo +set cpo&vim + +function! SyntaxCheckers_yaml_yamlxs_IsAvailable() dict + if !exists('g:syntastic_yaml_yamlxs_exec') && exists('g:syntastic_perl_interpreter') + let g:syntastic_yaml_yamlxs_exec = g:syntastic_perl_interpreter + endif + + " don't call executable() here, to allow things like + " let g:syntastic_perl_interpreter='/usr/bin/env perl' + silent! call syntastic#util#system(self.getExecEscaped() . ' ' . s:Modules() . ' -e ' . syntastic#util#shescape('exit(0)')) + return v:shell_error == 0 +endfunction + +function! SyntaxCheckers_yaml_yamlxs_GetLocList() dict + let makeprg = self.makeprgBuild({ + \ 'args_before': s:Modules() . ' -e ' . syntastic#util#shescape('YAML::XS::LoadFile($ARGV[0])') }) + + let errorformat = + \ '%EYAML::XS::Load Error: The problem:,' . + \ '%-C,' . + \ '%C %m,' . + \ '%Cwas found at document: %\d%\+\, line: %l\, column: %c,' . + \ '%-G%.%#' + + return SyntasticMake({ + \ 'makeprg': makeprg, + \ 'errorformat': errorformat, + \ 'postprocess': ['compressWhitespace'], + \ 'defaults': {'bufnr': bufnr('')} }) +endfunction + +function s:Modules() + if type(g:syntastic_perl_lib_path) == type('') + call syntastic#log#oneTimeWarn('variable g:syntastic_perl_lib_path should be a list') + let includes = split(g:syntastic_perl_lib_path, ',') + else + let includes = copy(syntastic#util#var('perl_lib_path')) + endif + return join(map(includes, '"-I" . v:val') + ['-MYAML::XS']) +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'yaml', + \ 'name': 'yamlxs', + \ 'exec': 'perl' }) + +let &cpo = s:save_cpo +unlet s:save_cpo + +" vim: set sw=4 sts=4 et fdm=marker: diff --git a/vim/bundle/syntastic/syntax_checkers/yang/pyang.vim b/vim/bundle/syntastic/syntax_checkers/yang/pyang.vim new file mode 100644 index 0000000..f397fa0 --- /dev/null +++ b/vim/bundle/syntastic/syntax_checkers/yang/pyang.vim @@ -0,0 +1,46 @@ +"============================================================================ +"File: pyang.vim +"Description: Syntax checking plugin for syntastic.vim +"Authors: joshua.downer@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_yang_pyang_checker') + finish +endif +let g:loaded_syntastic_yang_pyang_checker = 1 + +let s:save_cpo = &cpo +set cpo&vim + +function! SyntaxCheckers_yang_pyang_GetHighlightRegex(item) + let term = matchstr(a:item['text'], '\m"\zs[^"]\+\ze"') + return term != '' ? '\V\<' . escape(term, '\') . '\>' : '' +endfunction + +function! SyntaxCheckers_yang_pyang_GetLocList() dict + let makeprg = self.makeprgBuild({}) + + let errorformat = + \ '%f:%l: %trror: %m,' . + \ '%f:%l: %tarning: %m' + + return SyntasticMake({ + \ 'makeprg': makeprg, + \ 'errorformat': errorformat, + \ 'postprocess': ['filterForeignErrors'] }) +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'yang', + \ 'name': 'pyang'}) + +let &cpo = s:save_cpo +unlet s:save_cpo + +" vim: set sw=4 sts=4 et fdm=marker: diff --git a/vim/bundle/syntastic/syntax_checkers/z80/z80syntaxchecker.vim b/vim/bundle/syntastic/syntax_checkers/z80/z80syntaxchecker.vim new file mode 100644 index 0000000..af61a8b --- /dev/null +++ b/vim/bundle/syntastic/syntax_checkers/z80/z80syntaxchecker.vim @@ -0,0 +1,39 @@ +"============================================================================ +"File: z80syntaxchecker.vim +"Description: Syntax checking plugin for syntastic.vim +"Maintainer: Romain Giot <giot.romain at gmail dot com> +"License: This program is free software. It comes without any warranty, +" to the extent permitted by applicable law. You can redistribute +" it and/or modify it under the terms of the Do What The Fuck You +" Want To Public License, Version 2, as published by Sam Hocevar. +" See http://sam.zoy.org/wtfpl/COPYING for more details. +" +"============================================================================ + +if exists('g:loaded_syntastic_z80_z80syntaxchecker_checker') + finish +endif +let g:loaded_syntastic_z80_z80syntaxchecker_checker = 1 + +let s:save_cpo = &cpo +set cpo&vim + +function! SyntaxCheckers_z80_z80syntaxchecker_GetLocList() dict + let makeprg = self.makeprgBuild({}) + + let errorformat = '%f:%l %m' + + return SyntasticMake({ + \ 'makeprg': makeprg, + \ 'errorformat': errorformat }) +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'z80', + \ 'name': 'z80syntaxchecker', + \ 'exec': 'z80_syntax_checker.py'}) + +let &cpo = s:save_cpo +unlet s:save_cpo + +" vim: set sw=4 sts=4 et fdm=marker: diff --git a/vim/bundle/syntastic/syntax_checkers/zpt/zptlint.vim b/vim/bundle/syntastic/syntax_checkers/zpt/zptlint.vim new file mode 100644 index 0000000..31a6093 --- /dev/null +++ b/vim/bundle/syntastic/syntax_checkers/zpt/zptlint.vim @@ -0,0 +1,42 @@ +"============================================================================ +"File: zpt.vim +"Description: Syntax checking plugin for syntastic.vim +"Maintainer: claytron <robots at claytron dot com> +"License: This program is free software. It comes without any warranty, +" to the extent permitted by applicable law. You can redistribute +" it and/or modify it under the terms of the Do What The Fuck You +" Want To Public License, Version 2, as published by Sam Hocevar. +" See http://sam.zoy.org/wtfpl/COPYING for more details. +" +"============================================================================ + +if exists('g:loaded_syntastic_zpt_zptlint_checker') + finish +endif +let g:loaded_syntastic_zpt_zptlint_checker = 1 + +let s:save_cpo = &cpo +set cpo&vim + +function! SyntaxCheckers_zpt_zptlint_GetLocList() dict + let makeprg = self.makeprgBuild({}) + + 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'}) + +let &cpo = s:save_cpo +unlet s:save_cpo + +" vim: set sw=4 sts=4 et fdm=marker: diff --git a/vim/bundle/syntastic/syntax_checkers/zsh/zsh.vim b/vim/bundle/syntastic/syntax_checkers/zsh/zsh.vim new file mode 100644 index 0000000..4d458de --- /dev/null +++ b/vim/bundle/syntastic/syntax_checkers/zsh/zsh.vim @@ -0,0 +1,38 @@ +"============================================================================ +"File: zsh.vim +"Description: Syntax checking plugin for syntastic.vim +"Maintainer: Martin Grenfell <martin.grenfell at gmail dot com> +"License: This program is free software. It comes without any warranty, +" to the extent permitted by applicable law. You can redistribute +" it and/or modify it under the terms of the Do What The Fuck You +" Want To Public License, Version 2, as published by Sam Hocevar. +" See http://sam.zoy.org/wtfpl/COPYING for more details. +" +"============================================================================ + +if exists('g:loaded_syntastic_zsh_zsh_checker') + finish +endif +let g:loaded_syntastic_zsh_zsh_checker = 1 + +let s:save_cpo = &cpo +set cpo&vim + +function! SyntaxCheckers_zsh_zsh_GetLocList() dict + let makeprg = self.makeprgBuild({ 'args_after': '-n' }) + + let errorformat = '%f:%l: %m' + + return SyntasticMake({ + \ 'makeprg': makeprg, + \ 'errorformat': errorformat}) +endfunction + +call g:SyntasticRegistry.CreateAndRegisterChecker({ + \ 'filetype': 'zsh', + \ 'name': 'zsh'}) + +let &cpo = s:save_cpo +unlet s:save_cpo + +" vim: set sw=4 sts=4 et fdm=marker: |
